from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (ConditionMethodWriter, ActionMethodWriter, ExpressionMethodWriter, make_table) class ChowdrenPlatform(ObjectWriter): class_name = 'ChowdrenPlatform' static = True def write_init(self, writer): pass class PlatformAction(ActionMethodWriter): has_object = False actions = make_table(PlatformAction, { 0 : 'platform_set_lightbar', 1 : 'platform_reset_lightbar', 2 : 'set_local' }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { }) def get_object(): return ChowdrenPlatform
ExpressionMethodWriter, EmptyAction) class KeyObject(ObjectWriter): class_name = 'Keyboard' static = True def write_init(self, writer): pass class AlwaysCondition(ConditionMethodWriter): is_always = True actions = make_table(StaticActionWriter, {1: EmptyAction, 0: EmptyAction}) conditions = make_table( AlwaysCondition, { 1: 'is_key_pressed(translate_string_to_key(%s))', # 3 : 'is_key_pressed_once(translate_vk_to_key(%s))', # 6 : 'is_key_released_once(translate_vk_to_key(%s))', 3: 'is_key_pressed_once(%s)', 6: 'is_key_released_once(%s)', 7: 'is_key_released_once(translate_string_to_key(%s))' }) expressions = make_table(ExpressionMethodWriter, {})
obj = (obj.objectInfo, obj.objectType) writer.start_brace() writer.putlnc('FrameObject * selected; selected = NULL;') writer.putlnc('int alt_index = %s;', self.convert_index(1)) writer.putlnc('double lowest = 0.0;') with self.converter.iterate_object(obj, writer, copy=False): writer.putlnc('FrameObject * obj = %s;', self.converter.get_object(obj)) check = 'obj->alterables->values.get(alt_index)' writer.putlnc('if (selected == NULL || %s < lowest)', check) writer.indent() writer.putlnc('selected = obj;') writer.dedent() obj_list = self.converter.create_list(obj, writer) writer.putlnc('if (selected == NULL) %s', self.converter.event_break) writer.putlnc('%s.select_single(selected);', obj_list) writer.end_brace() actions = make_table(ActionMethodWriter, {}) conditions = make_table(ConditionMethodWriter, {2: LowestValue}) expressions = make_table(ExpressionMethodWriter, {}) def get_object(): return SelectObject
from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, ExpressionWriter, make_table, EmptyAction) class ClockObject(ObjectWriter): class_name = 'ClockObject' static = True def write_init(self, writer): pass class NullExpression(ExpressionWriter): def get_string(self): return '0' actions = make_table(StaticActionWriter, { }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(StaticExpressionWriter, { 5 : NullExpression, # day of month 6 : NullExpression, # month 7 : NullExpression # retrieve year }) def get_object(): return ClockObject
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, make_table class Util(ObjectWriter): class_name = "Utility" static = True def write_init(self, writer): pass actions = make_table( ActionMethodWriter, {0: "media.play_name(%s, %s-1, %s)", 1: "media.play_name(%s, %s-1)", 3: "media.add_file"} ) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table(ExpressionMethodWriter, {}) def get_object(): return Util
object_class = self.converter.get_object_class(obj[1]) set_value = '((%s)%s)' % (object_class, instance_name) self.converter.set_object(obj, set_value) for qual_obj in self.converter.resolve_qualifier(obj): self.converter.set_object(qual_obj, set_value) name = self.converter.write_generated(name, writer, groups) self.loop_names[real_name] = name class GetForeachFixed(ExpressionMethodWriter): def get_string(self): converter = self.converter name = converter.expression_items[converter.item_index + 1].loader.value foreach_instance = 'foreach_instance_' + get_method_name(name) fixed = foreach_instance + '->get_fixed()' converter.item_index += 2 return fixed actions = make_table(StaticActionWriter, {0: StartForObject}) conditions = make_table(StaticConditionWriter, {}) expressions = make_table(ExpressionMethodWriter, {0: GetForeachFixed}) def get_object(): return ForEach
index = len(keys) keys[key] = index AssociateArray.key_count = max(len(keys), AssociateArray.key_count) self.method = '%s(%s, %%s, %%s)' % (value, index) ActionMethodWriter.write(self, writer) return NewAction actions = make_table(ActionMethodWriter, { 0 : create_key_action('set_value'), 1 : create_key_action('set_string'), 2 : 'remove_key', 3 : 'clear', 8 : 'save', 42 : 'save_encrypted', 43 : 'load_encrypted', 44 : 'set_key', 25 : EmptyAction, # set_file_saving_interval 24 : EmptyAction, # set_file_loading_interval 26 : EmptyAction, # file_progress_set_to_load_entire_file_all_at_once 28 : create_key_action('add_value'), 29 : create_key_action('sub_value') }) def create_key_condition(value): class NewCondition(ConditionMethodWriter): method = value def write(self, writer): items = self.parameters[0].loader.items key = self.converter.convert_static_expression(items) if key is None:
writer.putlnc('platform_walk_folder(%s, items);', path) writer.putlnc('vector<FilesystemItem>::iterator it;') writer.putlnc('for (it = items.begin(); it != items.end(); ++it) {') writer.indent() writer.putlnc('if (it->is_folder()) continue;') writer.putlnc('folder_search_name = join_path(%s, it->name);', path) writer.putlnc('%s();', folder_obj.on_loop) writer.end_brace() writer.putlnc('%s();', folder_obj.on_loop_finish) writer.end_brace() actions = make_table(StaticActionWriter, { 1: 'delete_folder', 8: StartWalk, 15: 'create_directory' }) conditions = make_table(StaticConditionWriter, {15: 'file_exists'}) expressions = make_table(ExpressionMethodWriter, { 3: '.folder_search_name', 6: '.folder_search_id' }) def get_object(): return FolderObject
class SteamObject(ObjectWriter): static = True update = False def write_init(self, writer): pass actions = make_table(ActionMethodWriter, { 0 : EmptyAction, # sarasteamfp_general_frame_update_0 1 : EmptyAction, # sarasteamfp_leaderboards_uploading_find_boards_1 2 : EmptyAction, # sarasteamfp_leaderboards_uploading_upload_crystals_2 3 : EmptyAction, # sarasteamfp_leaderboards_uploading_upload_time_3 6 : EmptyAction, # sarasteamfp_achievements_simple_unlock_6 7 : EmptyAction, # sarasteamfp_achievements_simple_lock_7 11 : EmptyAction, # sarasteamfp_steam_cloud_simple_upload_records_dat_11 13 : EmptyAction, # sarasteamfp_steam_cloud_simple_upload_gamepad_cfg_13 14 : EmptyAction, # sarasteamfp_steam_cloud_simple_upload_keyboard_cfg_14 15 : EmptyAction, # sarasteamfp_steam_cloud_simple_download_records_dat_15 17 : EmptyAction, # sarasteamfp_steam_cloud_simple_download_gamepad_cfg_17 18 : EmptyAction, # sarasteamfp_steam_cloud_simple_download_keyboard_cfg_18 27 : EmptyAction, # sarasteamfp_steam_cloud_simple_upload_adventure_27 29 : EmptyAction # sarasteamfp_steam_cloud_simple_download_adventure_29 }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { })
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (ComparisonWriter, ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, make_table, EmptyAction) class ButtonObject(ObjectWriter): class_name = 'ButtonObject' filename = 'buttonext' def write_init(self, writer): pass actions = make_table( ActionMethodWriter, { 4: 'disable', # disable 3: 'enable' # enable }) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table(ExpressionMethodWriter, {}) def get_object(): return ButtonObject
class_name = 'ModFusion' filename = 'modfusion' static = True defines = ['CHOWDREN_USE_MODFUSION'] def write_init(self, writer): pass actions = make_table( StaticActionWriter, { 2: 'load_track', 3: 'clear_cache', 5: 'load_wgm', 7: 'load_wgm', 11: 'play', 12: 'stop', 13: 'stop_fade', 15: 'set_volume', 21: 'enable_loop', 22: 'disable_loop', }) conditions = make_table(StaticConditionWriter, {1: 'is_playing'}) expressions = make_table(StaticExpressionWriter, {2: 'get_volume'}) def get_object(): return ModFusionEX
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table, ConditionMethodWriter, ExpressionMethodWriter, EmptyAction, StaticConditionWriter, ActionMethodWriter) class Lacewing(ObjectWriter): class_name = 'Lacewing' filename = 'lacewing' static = False actions = make_table(ActionMethodWriter, {}) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table(ExpressionMethodWriter, {}) def get_object(): return Lacewing
writer.putlnc('init_scrollbar(%s);', val) def has_updates(self): return True #def get_sources(self): # script_dir = os.path.dirname(__file__) # base_dir = os.path.join(script_dir, '..', '..', '..', 'base') # base_dir = os.path.abspath(base_dir) # print glob.glob(os.path.join(base_dir, 'staticlibs', 'gwen', '*.cpp')) # return ['objects/scrollbarext.cpp'] actions = make_table(ActionMethodWriter, { 1 : 'set_scroll_range', 9 : 'set_width', 10 : 'set_height', 11 : 'set_visible(true)', 12 : 'set_visible(false)' }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { 0 : 'get_value()' }) def get_object(): return ScrollbarObject
def write_init(self, writer): pass class GetFrameName(ExpressionWriter): def get_string(self): return 'data->name' class GetAboutText(ExpressionWriter): def get_string(self): return 'ABOUT' actions = make_table( StaticActionWriter, { 8: EmptyAction, # set frame width }) conditions = make_table(StaticConditionWriter, {}) expressions = make_table(StaticExpressionWriter, { 2: GetFrameName, 1: GetAboutText }) def get_object(): return MMF2Params
from chowdren.writers.events import (ComparisonWriter, ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, make_table) class StringParser(ObjectWriter): class_name = 'StringParser' filename = 'stringparser' def write_init(self, writer): pass actions = make_table(ActionMethodWriter, { 0: 'set', 2: 'load', 5: 'reset_delimiters', 6: 'add_delimiter' }) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table( ExpressionMethodWriter, { 0: '.value', 1: '.value.size()', 9: 'remove', 10: 'replace', 24: 'get_count()', 25: 'set_element', 29: 'get_element', 30: 'get_element(1)',
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticActionWriter, StaticConditionWriter, StaticExpressionWriter, make_table) class WindowControl(ObjectWriter): class_name = 'WindowControl' static = True actions = make_table(StaticActionWriter, { }) conditions = make_table(StaticConditionWriter, { 0 : 'has_focus' }) expressions = make_table(StaticExpressionWriter, { }) def get_object(): return WindowControl
writer.putc('plan_path(%s);', obj) # mmkpathplanner_3: Add agents # mmkpathplanner_11: Look at next node # mmkpathplanner_4: Add obstacle # mmkpathplanner_6: Set destination # mmkpathplanner_14: Plan path for single agent # mmkpathplanner_0: Is agent at destination? # mmkpathplanner_4: Agent wants to stop # mmkpathplanner_6: Is agent NOT at destination? actions = make_table(ActionMethodWriter, { 3 : AddAgents, 4 : AddObstacles, 6 : SetDestination, 11 : Orient, 14 : PlanPath }) class ObjectCondition(ConditionMethodWriter): def __init__(self, *arg, **kw): ConditionMethodWriter.__init__(self, *arg, **kw) self.obj = self.parameters[0].loader self.parameters = self.parameters[1:] def get_object(self): return (self.obj.objectInfo, self.obj.objectType) conditions = make_table(ObjectCondition, { 0 : 'agent->at_destination',
EmptyAction) from mmfparser.data.font import LogFont class ColorizerObject(ObjectWriter): class_name = 'ColorizerObject' filename = 'colorizer' use_alterables = True def write_init(self, writer): pass actions = make_table(ActionMethodWriter, { 29 : EmptyAction, # load mask from overlay/surface 32 : EmptyAction, # change mask mode 0 : 'set_red', # set red out of old red 4 : 'set_green', # set green out of old green, 8 : 'set_blue' # set blue out of old blue }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { 2 : '.r', # red out of red, 6 : '.g', # green out of old green 10 : '.b' # blue out of old blue }) def get_object(): return ColorizerObject
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table, ConditionMethodWriter, ExpressionMethodWriter, EmptyAction, StaticConditionWriter, ActionMethodWriter) class XBOXGamepad(ObjectWriter): class_name = 'Joystick' static = True actions = make_table(ActionMethodWriter, { 0 : 'joystick_vibrate' }) conditions = make_table(ConditionMethodWriter, { 0 : 'is_joystick_attached(%s+1)', 2 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_B)', 1 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_A)', 9 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_RIGHTSHOULDER)', 3 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_X)', 4 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_Y)', 5 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_BACK)', 7 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_LEFTSHOULDER)', 14 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_DPAD_LEFT)', 15 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_DPAD_RIGHT)', 12 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_DPAD_UP)', 11 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_START)', 13 : 'is_joystick_pressed(%s, CHOWDREN_BUTTON_DPAD_DOWN)'
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table) class AdvancedDirection(ObjectWriter): class_name = 'AdvancedDirection' static = True actions = make_table(StaticActionWriter, { }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(StaticExpressionWriter, { 57 : 'get_object_angle' }) def get_object(): return AdvancedDirection
from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table, ActionWriter, ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, EmptyAction) class SystemTray(ObjectWriter): class_name = 'SystemTray' static = True # filename = 'systemtray' def write_init(self, writer): pass actions = make_table(ActionMethodWriter, { # systray_halt_system_commands_halt_close_command_15 15 : EmptyAction, }) actions.update(make_table(StaticActionWriter, { })) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { }) def get_object(): return SystemTray
from chowdren.writers.events import (ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, make_table, ActionWriter, EmptyAction) class UltimateFullcsreen(ObjectWriter): class_name = 'Fullscreen' static = True class Action(ActionMethodWriter): has_object = False actions = make_table(Action, { 1 : 'manager.set_window(false)', 0 : 'manager.set_window(true)', 5 : 'manager.set_window_scale', 4 : 'manager.set_scale_type', # 11 : 'manager.set_rectangle_width', # 12 : 'manager.set_rectangle_height', # 13 : 'manager.refresh_rect' 11 : EmptyAction, 12 : EmptyAction, 13 : EmptyAction }) conditions = make_table(ConditionMethodWriter, { 1 : '!manager.is_fullscreen()' }) expressions = make_table(ExpressionMethodWriter, { 0 : 'WindowControl::get_x', 1 : 'WindowControl::get_y' })
if not self.has_updates(): return data = self.get_data() width = data.readInt() height = data.readInt() writer.putlnc('width = %s;', width) writer.putlnc('height = %s;', height) data.skipBytes(88) value = data.readInt() minimum = data.readInt() maximum = data.readInt() writer.putlnc('init_control(%s, %s, %s);', value, minimum, maximum) def has_updates(self): return self.converter.config.use_gwen() actions = make_table(ActionMethodWriter, { 0: 'set_value', 14: 'set_visible(false)', 15: 'set_visible(true)' }) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table(ExpressionMethodWriter, {0: 'get_value()'}) def get_object(): return NumericUpDown
class SetFrameWidth(ActionMethodWriter): has_object = False method = 'set_width(%s, %s == 1)' actions = make_table( StaticActionWriter, { 0: 'set_x', 1: 'set_y', 2: 'set_placement', 3: 'set_width', 4: 'set_height', 7: EmptyAction, # always on top, not portable 9: 'set_visible(true)', 10: 'set_visible(false)', 11: 'minimize', 17: 'set_position', 12: 'maximize', 13: 'restore', 18: 'set_title', 21: 'set_focus(true)', 28: SetFrameWidth, 29: SetFrameHeight }) conditions = make_table(StaticConditionWriter, { 1: 'is_maximized', 4: 'has_focus' })
from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table, EmptyAction, ExpressionMethodWriter, TrueCondition) class Yaso(ObjectWriter): class_name = 'Yaso' static = True def write_init(self, writer): pass actions = make_table(StaticActionWriter, {}) conditions = make_table( StaticConditionWriter, { 1: TrueCondition # is connected to the internet }) expressions = make_table(ExpressionMethodWriter, {14: '.empty_string'}) def get_object(): return Yaso
writer.putlnc('vector<FilesystemItem>::iterator it;') writer.putlnc('for (it = items.begin(); it != items.end(); ++it) {') writer.indent() writer.putlnc('if (it->is_folder()) continue;') writer.putlnc('folder_search_name = join_path(%s, it->name);', path) writer.putlnc('%s();', folder_obj.on_loop) writer.end_brace() writer.putlnc('%s();', folder_obj.on_loop_finish) writer.end_brace() actions = make_table(StaticActionWriter, { 1 : 'delete_folder', 8 : StartWalk, 15 : 'create_directory' }) conditions = make_table(StaticConditionWriter, { 15 : 'file_exists' }) expressions = make_table(ExpressionMethodWriter, { 3 : '.folder_search_name', 6 : '.folder_search_id' }) def get_object(): return FolderObject
steam.on_publish_done_name, steam.on_publish_fail_name) actions = make_table( ActionMethodWriter, { 15: 'request_user_data', 16: 'store_user_data', 17: 'set_int', 22: 'unlock_achievement', 26: 'clear_achievements', 34: 'reset_files', 52: 'reset_uncommited_changes', 53: 'start_publish', 54: 'start_content_change', 55: 'set_file', 57: 'reset_file_changes', 58: 'set_preview_latest', 61: 'set_content_appid', 62: 'set_content_title', 63: 'set_description', 64: SearchContentItems, 66: 'set_content_visibility', 69: 'set_tags', 74: 'reset_changes', 75: UploadChanges, 116: LoopResults, 158: SearchSubscribedItems, 162: DownloadUGC }) class OnConnect(OnceCondition):
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, make_table) class VitalizePlugin(ObjectWriter): class_name = 'VitalizePlugin' static = True actions = make_table(ActionMethodWriter, {4: 'open_url(%s)'}) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table(ExpressionMethodWriter, {}) def get_object(): return VitalizePlugin
class Viewport(ObjectWriter): class_name = 'Viewport' defines = ['CHOWDREN_USE_VIEWPORT'] use_alterables = True def write_init(self, writer): data = self.get_data() data.skipBytes(4) width = data.readShort() height = data.readShort() writer.putln('src_width = width = %s;' % width) writer.putln('src_height = height = %s;' % height) writer.putln('center_x = x + width / 2;') writer.putln('center_y = y + height / 2;') actions = make_table(ActionMethodWriter, { 0 : 'set_width', 1 : 'set_height', 3 : 'set_source' }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { }) def get_object(): return Viewport
actions = make_table(ActionMethodWriter, { 0 : '.obstacle_collision = true', 1 : '.platform_collision = true', 2 : SetObject, 3 : '.right = true', 4 : '.left = true', 5 : 'jump', 6 : '.x_vel = %s', # 6 : 'set_x_vel', # 7 : '.y_vel = %s', 7 : 'set_y_vel', 8 : '.max_x_vel = %s', # 8 : 'set_max_x_vel', # for debug 9 : '.max_y_vel = %s', 10 : '.x_accel = %s', # 10 : 'set_x_accel', 11 : '.x_decel = %s', 12 : '.gravity = %s', 13 : '.jump_strength = %s', 14 : '.jump_hold_height = %s', 16 : 'jump_in_air', 17 : '.paused = true', 18 : '.paused = false', 20 : '.add_x_vel = %s', 21 : 'set_add_y_vel' # 21 : '.add_y_vel = %s' }) conditions = make_table(ConditionMethodWriter, {
actions = make_table( ActionMethodWriter, { 15: "request_user_data", 16: "store_user_data", 17: "set_int", 22: "unlock_achievement", 26: "clear_achievements", 34: "reset_files", 52: "reset_uncommited_changes", 53: "start_publish", 54: "start_content_change", 55: "set_file", 57: "reset_file_changes", 58: "set_preview_latest", 61: "set_content_appid", 62: "set_content_title", 63: "set_description", 64: SearchContentItems, 66: "set_content_visibility", 69: "set_tags", 74: "reset_changes", 75: UploadChanges, 116: LoopResults, 158: SearchSubscribedItems, 162: DownloadUGC, }, )
if not details.get('parent'): raise NotImplementedError() obj = self.converter.get_object(details['parent']) x = '%s->get_x() + %s' % (obj, details['x']) y = '%s->get_y() + %s' % (obj, details['y']) writer.put('look_at(%s, %s);' % (x, y)) class RotateToward(ActionMethodWriter): method = 'rotate_toward' def write(self, writer): direction = self.convert_index(0) writer.putc('rotate_toward(%s);', direction) def get_object(self): loader = self.parameters[1].loader return loader.objectInfo, loader.objectType actions = make_table(ActionMethodWriter, { 1: RotateToward, 2 : LookAt }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { }) def get_object(): return DirectionCalculator
# mmkpathplanner_3: Add agents # mmkpathplanner_11: Look at next node # mmkpathplanner_4: Add obstacle # mmkpathplanner_6: Set destination # mmkpathplanner_14: Plan path for single agent # mmkpathplanner_0: Is agent at destination? # mmkpathplanner_4: Agent wants to stop # mmkpathplanner_6: Is agent NOT at destination? actions = make_table(ActionMethodWriter, { 3: AddAgents, 4: AddObstacles, 6: SetDestination, 11: Orient, 14: PlanPath }) class ObjectCondition(ConditionMethodWriter): def __init__(self, *arg, **kw): ConditionMethodWriter.__init__(self, *arg, **kw) self.obj = self.parameters[0].loader self.parameters = self.parameters[1:] def get_object(self): return (self.obj.objectInfo, self.obj.objectType)
def get_images(self): if self.image == -1: return () return (self.image,) actions = make_table( ActionMethodWriter, { 0: "set_size", 1: "set_global_position", 6: "hide_fill", 22: "hide_border_1", 31: "hide_border_2", # actually system colors 51: "set_fill(Color(%s))", 52: "set_border_1(Color(%s))", 53: "set_border_2(Color(%s))", 54: EmptyAction, # set text color, other 55: "set_text", 62: "set_visible(true)", 63: "set_visible(false)", }, ) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table( ExpressionMethodWriter, {29: ".text", 31: ".width", 32: ".height", 34: "get_x()", 35: "get_y()"} )
actions = make_table(ActionMethodWriter, { 1 : 'set_item', 7 : 'set_value_int', 9 : 'set_string', 10 : 'set_string', 12 : 'delete_item', 11 : 'delete_item', 13 : 'delete_group', 6 : 'load_file', 8 : 'set_value_int', 0 : 'set_group' # 14 : 'set_value', # specified group # 15 : 'set_string', # specified group # 1 : 'set_value', # current group # 2 : 'set_string', # current group # 28 : 'delete_group', # 9 : 'delete_group', # 10 : 'delete_item', # 29 : 'delete_item', # 43 : 'load_file', # 48 : 'load_string', # 32 : 'reset', # 38 : 'merge_file', # 45 : 'save_file', # 31 : DeletePattern, # 33 : PerformSearch, # 40 : MergeObject, # 41 : MergeGroupObject, # 71 : SortGroup })
flags = BitDict('Numeric', 'Text', 'Base1', 'Global') flags.setFlags(data.readInt()) is_numeric = flags['Numeric'] offset = int(flags['Base1']) writer.putln(to_c('initialize(%s, %s, %s, %s, %s);', is_numeric, offset, x_size, y_size, z_size)) # if flags['Global']: # raise NotImplementedError() actions = make_table(ActionMethodWriter, { 0 : '.x_pos = %s', 1 : '.y_pos = %s', 2 : '.z_pos = %s', 3 : '.x_pos++', 4 : '.y_pos++', 7 : 'set_string', 14 : 'set_value', 16 : 'set_string', 18 : 'set_string', # with xyz 8 : 'clear', 9 : 'load' }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { 0 : '.x_pos', 1 : '.y_pos', 4 : 'get_string', # current pos 6 : 'get_value',
visible = not self.flags['HideOnStart'] transparent_color = data.readColor() if not self.flags['TransparentFirstPixel']: writer.putln('set_transparent_color(%s);' % make_color(transparent_color)) image = data.readString(260) or None # objects_file.putdef('filename', image) actions = make_table( ActionMethodWriter, { 0: 'load', 2: 'set_hotspot', 11: 'set_hotspot_mul(1.0f, 0.5f)', 9: 'set_hotspot_mul(0.0f, 0.5f)', 10: 'set_hotspot_mul(0.5f, 0.5f)', 13: 'set_hotspot_mul(0.5f, 1.0f)', 26: 'paste', 15: 'flip_horizontal', 4: 'set_angle', 29: 'set_zoom' }) conditions = make_table(ConditionMethodWriter, {0: '.image != NULL'}) expressions = make_table(ExpressionMethodWriter, { 1: 'get_width()', 2: 'get_height()', 9: '.angle', 13: 'get_zoom_x()' })
data.skipBytes(4) data.skipBytes(4) # width, height is_global = data.readByte() != 0 if is_global: writer.putln('map = &global_map;') else: writer.putln('map = new ArrayMap();') actions = make_table(ActionMethodWriter, { 0 : 'set_value', 1 : 'set_string', 2 : 'remove_key', 3 : 'clear', 8 : 'save', 42 : 'save_encrypted', 43 : 'load_encrypted', 44 : 'set_key', 25 : EmptyAction, # set_file_saving_interval 24 : EmptyAction, # set_file_loading_interval 28 : 'add_value', 29 : 'sub_value' }) conditions = make_table(ConditionMethodWriter, { 0 : 'has_key', 4 : 'count_prefix' }) expressions = make_table(ExpressionMethodWriter, { 0 : 'get_value', 1 : 'get_string',
case_sensitive = data.readByte() == 1 use_match_count = data.readByte() == 1 data.skipBytes(2) # padding match_count = data.readInt() right_to_left = data.readByte() == 1 if case_sensitive: raise NotImplementedError() if use_match_count: raise NotImplementedError() if right_to_left: raise NotImplementedError() class ReplaceExpression(StaticExpressionWriter): method = 'replace' actions = make_table(ActionMethodWriter, {1: 'add_replacement'}) conditions = make_table(StaticConditionWriter, {}) expressions = make_table(ExpressionMethodWriter, { 0: 'replace', 1: ReplaceExpression }) def get_object(): return StringReplace
actions = make_table(ActionMethodWriter, { 0 : 'set_group', 14 : SetValue, # specified group 15 : 'set_string', # specified group 1 : SetValue, # current group 2 : 'set_string', # current group 28 : 'delete_group', 9 : 'delete_group', 10 : 'delete_item', 29 : 'delete_item', 43 : 'load_file', 44 : 'save_file', 48 : 'load_string', 49 : 'set_auto', 52 : 'read_only = bool(%s)', 32 : 'reset', 38 : 'merge_file', 45 : 'save_file', 31 : DeletePattern, 33 : PerformSearch, 40 : MergeObject, 41 : MergeGroupObject, 47 : 'close', 50 : 'set_compression', 51 : 'set_encryption_key', 61 : EmptyAction, # open dialog box 71 : SortGroup, 78 : FileOperation })
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (ComparisonWriter, StaticActionWriter, StaticConditionWriter, StaticExpressionWriter, make_table, ActionMethodWriter) class OpenURL(ObjectWriter): class_name = 'OpenURL' static = True def write_init(self, writer): pass class OpenAction(ActionMethodWriter): has_object = False method = 'open_url' actions = make_table(StaticActionWriter, { 0 : OpenAction }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(StaticExpressionWriter, { }) def get_object(): return OpenURL
from kcpica import ActivePicture from chowdren.writers.events import (ComparisonWriter, ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, make_table) class BackgroundPicture(ActivePicture): is_active_picture = False def is_static_background(self): return False def is_background_collider(self): # also: # ObstaclePlatform, both ObstaclePlatform and ObstascleSolid: Ladder return self.common.newFlags['ObstacleSolid'] actions = make_table(ActionMethodWriter, { 0 : 'load', 2 : 'set_visible(true)', 3 : 'set_visible(false)', }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { 0 : '.filename' }) def get_object(): return BackgroundPicture
def write_init(self, writer): data = self.get_data() data.skipBytes(4) data.skipBytes(4) # width, height is_global = data.readInt() != 0 case_insensitive = data.readInt() != 0 if case_insensitive: raise NotImplementedError() self.write_assarray(writer, is_global) actions = make_table( ActionMethodWriter, { 0: create_key_action("set_value"), 1: create_key_action("add_value"), 2: create_key_action("sub_value"), 8: create_key_action("set_string"), 11: "clear", }, ) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table( ExpressionMethodWriter, {0: create_key_expression("get_value"), 1: create_key_expression("get_string")} ) def get_object(): return NamedVariables
object_class = self.converter.get_object_class(obj[1]) set_value = '((%s)%s)' % (object_class, instance_name) self.converter.set_object(obj, set_value) for qual_obj in self.converter.resolve_qualifier(obj): self.converter.set_object(qual_obj, set_value) name = self.converter.write_generated(name, writer, groups) self.loop_names[real_name] = name class GetForeachFixed(ExpressionMethodWriter): def get_string(self): converter = self.converter name = converter.expression_items[converter.item_index+1].loader.value foreach_instance = 'foreach_instance_' + get_method_name(name) fixed = foreach_instance + '->get_fixed()' converter.item_index += 2 return fixed actions = make_table(StaticActionWriter, { 0 : StartForObject }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(ExpressionMethodWriter, { 0 : GetForeachFixed }) def get_object(): return ForEach
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (ConditionMethodWriter, ActionMethodWriter, ExpressionMethodWriter, make_table, EmptyAction) class MaskedText(ObjectWriter): class_name = 'MaskedText' filename = 'maskedtext' def write_init(self, writer): pass actions = make_table(ActionMethodWriter, { 8 : EmptyAction, # set focus on 16 : EmptyAction, # go to pos 11 : '.text = %s' }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { 4 : '.text' }) def get_object(): return MaskedText
class Viewport(ObjectWriter): class_name = 'Viewport' filename = 'viewport' defines = ['CHOWDREN_USE_VIEWPORT'] use_alterables = True def write_init(self, writer): data = self.get_data() data.skipBytes(4) width = data.readShort() height = data.readShort() writer.putln('src_width = width = %s;' % width) writer.putln('src_height = height = %s;' % height) writer.putln('center_x = x + width / 2;') writer.putln('center_y = y + height / 2;') actions = make_table(ActionMethodWriter, { 0 : 'set_width', 1 : 'set_height', 3 : 'set_source' }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { }) def get_object(): return Viewport
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (ComparisonWriter, StaticActionWriter, StaticConditionWriter, StaticExpressionWriter, make_table, ActionMethodWriter, ExpressionMethodWriter) class StringReplace(ObjectWriter): class_name = 'StringReplace' filename = 'stringreplace' def write_init(self, writer): pass class ReplaceExpression(StaticExpressionWriter): method = 'replace' actions = make_table(ActionMethodWriter, { 1 : 'add_replacement' }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(ExpressionMethodWriter, { 0 : 'replace', 1 : ReplaceExpression }) def get_object(): return StringReplace
class WindowName(ExpressionMethodWriter): has_object = False method = '.NAME' class SetFrameWidth(ActionMethodWriter): has_object = False method = 'set_width(%s, %s == 1)' actions = make_table(StaticActionWriter, { 0 : 'set_x', 1 : 'set_y', 3 : 'set_width', 4 : 'set_height', 9 : 'set_visible(true)', 10 : 'set_visible(false)', 11 : 'minimize', 17 : 'set_position', 28 : SetFrameWidth, 12 : 'maximize', 13 : 'restore', 21 : 'set_focus(true)' }) conditions = make_table(StaticConditionWriter, { 1 : 'is_maximized', 4 : 'has_focus' }) expressions = make_table(StaticExpressionWriter, { 0 : 'get_x()', 1 : 'get_y()',
loop_objects = {} for loop in self.get_conditions(ON_LOOP): parameter = loop.conditions[0].parameters[0] items = parameter.loader.items loop_id = self.converter.convert_static_expression(items) loops[loop_id].append(loop) for loop_id in loops.keys(): loop_index = get_loop_index(loop_id) writer.add_member('int %s' % loop_index) self.converter.begin_events() for loop_id, groups in loops.iteritems(): func = get_loop_func(loop_id, self.converter) func = self.converter.write_generated(func, writer, groups) self.loop_funcs[loop_id] = func actions = make_table(StaticActionWriter, { 0 : StartLoop }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(ExpressionMethodWriter, { 0 : GetLoopIndex }) def get_object(): return FastLoop
from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table, ActionWriter, ActionMethodWriter, ConditionMethodWriter, ExpressionMethodWriter, EmptyAction) class CommonDialog(ObjectWriter): class_name = 'CommonDialog' static = True def write_init(self, writer): pass actions = make_table(ActionMethodWriter, { 0: EmptyAction, 11: 'std::cout << ({1}) << std::endl' }) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table(ExpressionMethodWriter, {}) def get_object(): return CommonDialog
writer.putln('data = static_global_data;') writer.end_brace() else: writer.putln(init) actions = make_table( ActionMethodWriter, { 0: '.data.x_pos = %s', 1: '.data.y_pos = %s', 2: '.data.z_pos = %s', 3: '.data.x_pos++', 4: '.data.y_pos++', 6: 'set_value', # current pos 7: 'set_string', 13: 'set_value', 14: 'set_value', 15: 'set_value', # xyz 16: 'set_string', 18: 'set_string', # with xyz 8: 'clear', 9: 'load', 11: 'save' }) conditions = make_table(ConditionMethodWriter, {}) expressions = make_table( ExpressionMethodWriter, {
writer.putln('set_transparent_color(%s);' % make_color(transparent_color)) writer.putlnc('sprite_col.width = width = %s;', width) writer.putlnc('sprite_col.height = height = %s;', height) if flags['Resize']: writer.putlnc('picture_flags |= FORCE_RESIZE;') # objects_file.putdef('filename', image) actions = make_table(ActionMethodWriter, { 0 : 'load', 2 : 'set_hotspot', 3 : 'set_size', 11 : 'set_hotspot_mul(1.0f, 0.5f)', 9 : 'set_hotspot_mul(0.0f, 0.5f)', 10 : 'set_hotspot_mul(0.5f, 0.5f)', 13 : 'set_hotspot_mul(0.5f, 1.0f)', 21 : 'set_offset_y', 25 : 'set_wrap(false)', 26 : 'paste', 15 : 'flip_horizontal', 4 : 'set_angle', 29 : 'set_zoom' }) conditions = make_table(ConditionMethodWriter, { 0 : '.image != NULL' }) expressions = make_table(ExpressionMethodWriter, { 0 : '.filename', 1 : 'get_width()',
parent = details.get('parent', None) if parent is not None: writer.putln('int parent_x, parent_y;') writer.putln('FrameObject * parent = %s;' % ( self.converter.get_object(parent))) writer.putln('if (parent == NULL) parent_x = parent_y = 0;') writer.putln('else {') writer.indent() writer.putln('parent_x = parent->x;') writer.putln('parent_y = parent->y;') writer.end_brace() x = 'parent_x + %s' % x y = 'parent_y + %s' % y object_info = self.get_object() obj = self.converter.get_object(object_info) writer.put('%s->find_closest(%s, %s, %s);' % (obj, instances, x, y)) writer.end_brace() actions = make_table(ActionMethodWriter, { 1 : FindClosest }) conditions = make_table(ConditionMethodWriter, { }) expressions = make_table(ExpressionMethodWriter, { 8 : 'get_closest' }) def get_object(): return AdvancedDirection
from chowdren.writers.objects import ObjectWriter from chowdren.common import get_animation_name, to_c, make_color from chowdren.writers.events import (StaticConditionWriter, StaticActionWriter, StaticExpressionWriter, make_table) class Util(ObjectWriter): class_name = 'Utility' static = True def write_init(self, writer): pass actions = make_table(StaticActionWriter, { 1 : 'SetRandomSeedToTimer' }) conditions = make_table(StaticConditionWriter, { }) expressions = make_table(StaticExpressionWriter, { 0 : 'IntGenerateRandom', 1 : 'GenerateRandom', 3 : 'Substr', 4 : 'Nearest', 6 : 'ModifyRange', 2 : 'Limit', 13 : 'IntNearest', 15 : 'IntModifyRange', 21 : 'ExpressionCompare',