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',
