class FrameHeader(DataLoader):
width = None
height = None
flags = None
background = None
def initialize(self):
# 0x8000 == TimedMovements
self.flags = BitDict(
'DisplayName',
'GrabDesktop',
'KeepDisplay',
'FadeIn',
'FadeOut',
'TotalCollisionMask',
'Password',
'ResizeAtStart',
'DoNotCenter',
'ForceLoadOnCall',
'NoSurface',
'Reserved_1',
'Reserved_2',
'RecordDemo',
None,
'TimedMovements'
)
def read(self, reader):
self.width = reader.readShort(True)
self.height = reader.readShort(True)
self.background = reader.readColor()
self.flags.setFlags(reader.readShort(True))
class ExtendedHeader(DataLoader):
flags = None
buildType = None
buildFlags = None
screenRatioTolerance = None
screenAngle = None
def initialize(self):
self.flags = BitDict(
'KeepScreenRatio',
'FrameTransition', # (HWA only) frame has a transition
'ResampleStretch', # (HWA only) resample while resizing
'GlobalRefresh' # (Mobile) force global refresh
)
def read(self, reader):
self.flags.setFlags(reader.readInt())
self.buildType = reader.readInt(True)
self.buildFlags = reader.readInt(True)
self.screenRatioTolerance = reader.readShort()
self.screenAngle = reader.readShort()
reader.readInt() # unused
def write(self, reader):
reader.writeInt(self.flags.getFlags())
reader.writeInt(self.buildType, True)
reader.writeInt(self.buildFlags, True)
reader.writeShort(self.screenRatioTolerance)
reader.writeShort(self.screenAngle)
reader.writeInt(0) # unused
class Transition(DataLoader):
module = None
name = None
id = None
transitionId = None
duration = None # in ms
flags = None
color = None
parameterData = None
def initialize(self):
self.flags = BitDict('Color')
def read(self, reader):
self.module = reader.read(reader.readInt())
self.name = reader.read(reader.readInt())
self.id = reader.read(4)
self.transitionId = reader.read(4)
self.duration = reader.readInt()
self.flags.setFlags(reader.readInt())
self.color = reader.readColor()
self.parameterData = reader.read(reader.readInt())
def write(self, reader):
reader.writeInt(len(self.module)); reader.write(self.module)
reader.writeInt(len(self.name)); reader.write(self.name)
reader.write(self.id)
reader.write(self.transitionId)
reader.writeInt(self.duration)
reader.writeInt(self.flags.getFlags())
reader.writeColor(self.color)
reader.writeInt(len(self.parameterData)); reader.write(
self.parameterData)
class ExtendedHeader(DataLoader):
flags = None
buildType = None
buildFlags = None
screenRatioTolerance = None
screenAngle = None
def initialize(self):
self.flags = BitDict(
"KeepScreenRatio",
"FrameTransition", # (HWA only) frame has a transition
"ResampleStretch", # (HWA only) resample while resizing
"GlobalRefresh", # (Mobile) force global refresh
)
def read(self, reader):
self.flags.setFlags(reader.readInt())
self.buildType = reader.readInt(True)
self.buildFlags = reader.readInt(True)
self.screenRatioTolerance = reader.readShort()
self.screenAngle = reader.readShort()
reader.readInt() # unused
if self.buildType >= 0x10000000:
self.parent.settings["compat"] = True
def write(self, reader):
reader.writeInt(self.flags.getFlags())
reader.writeInt(self.buildType, True)
reader.writeInt(self.buildFlags, True)
reader.writeShort(self.screenRatioTolerance)
reader.writeShort(self.screenAngle)
reader.writeInt(0) # unused
class Transition(DataLoader):
module = None
name = None
duration = None # in ms
flags = None
color = None
moduleFile = None
parameterData = None
def initialize(self):
self.flags = BitDict('Color')
def read(self, reader):
currentPosition = reader.tell()
self.module = reader.read(4)
self.name = reader.read(4)
self.duration = reader.readInt()
self.flags.setFlags(reader.readInt(True))
self.color = reader.readColor()
nameOffset = reader.readInt()
parameterOffset = reader.readInt()
parameterSize = reader.readInt()
reader.seek(currentPosition + nameOffset)
self.moduleFile = reader.readString()
reader.seek(currentPosition + parameterOffset)
self.parameterData = reader.read(parameterSize)
def isStandard(self):
return self.name == 'STDT'
def write_init(self, writer):
data = self.get_data()
x_size = max(1, data.readInt())
y_size = max(1, data.readInt())
z_size = max(1, data.readInt())
flags = BitDict('Numeric', 'Text', 'Base1', 'Global')
flags.setFlags(data.readInt())
is_numeric = flags['Numeric']
offset = int(flags['Base1'])
init = to_c('initialize(%s, %s, %s, %s, %s);',
is_numeric, offset, x_size, y_size, z_size)
if flags['Global']:
glob = self.get_global('ArrayObject::SavedArray')
writer.putlnc('global_data = &%s;', glob)
writer.putlnc('if (!%s.init) {', glob)
writer.indent()
writer.putlnc('%s.init = true;', glob)
writer.putln(init)
writer.dedent()
writer.putln('} else {')
writer.indent()
writer.putlnc('data = %s.value;', glob)
writer.end_brace()
else:
writer.putln(init)
class ActivePicture(ObjectWriter):
class_name = 'ActivePicture'
filename = 'picture'
use_alterables = True
default_instance = 'default_picture_instance'
def write_init(self, writer):
data = self.get_data()
width = data.readInt()
height = data.readInt()
self.flags = BitDict(
'Resize',
'HideOnStart',
'TransparentBlack',
'TransparentFirstPixel',
'FlippedHorizontally',
'FlippedVertically',
'Resample',
'WrapModeOff',
)
self.flags.setFlags(data.readInt(True))
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
writer.putlnc('sprite_col.width = width = %s;', width)
writer.putlnc('sprite_col.height = height = %s;', height)
class MusicFile(DataLoader):
handle = None
name = None
checksum = None
references = None
flags = None
data = None
def initialize(self):
self.flags = BitDict(
'Wave',
'MIDI',
None, None,
'LoadOnCall',
'PlayFromDisk',
'Loaded'
)
def read(self, reader):
debug = self.settings.get('debug', False)
compressed = not debug and self.settings.get('compressed', True)
self.handle = reader.readInt()
if compressed:
reader = zlibdata.decompress(reader)
self.checksum = reader.readInt()
self.references = reader.readInt(True)
size = reader.readInt(True)
self.flags.setFlags(reader.readInt(True))
reserved = reader.readInt()
nameLength = reader.readInt()
self.name = reader.read(nameLength).replace('\x00', '')
self.data = reader.read(size - nameLength)
def write_init(self, writer):
data = self.get_data()
flags = BitDict(
'FreeFlag',
'VerticalScrollbar',
'Sort',
'Border',
'HideOnStart',
'SystemColor',
'3DLook',
'ScrollToNewline'
)
width = data.readShort()
height = data.readShort()
# XXX support unicode
font = LogFont(data, old = True)
font_color = data.readColor()
data.readString(40)
data.skipBytes(16 * 4)
back_color = data.readColor()
flags.setFlags(data.readInt())
line_count = data.readShort(True)
index_offset = -1 if data.readInt() == 1 else 0
data.skipBytes(4 * 3)
lines = []
for _ in xrange(line_count):
line = data.readString()
writer.putln(to_c('add_line(%r);', line))
if flags['HideOnStart']:
writer.putln('set_visible(false);')
class ExecuteEvaluatedProgram(_ExecuteProgram):
def created(self):
self.flags = BitDict('Wait', 'Hide')
def execute(self):
executable = self.evaluate_expression(self.get_parameter(0))
command = self.evaluate_expression(self.get_parameter(1))
self.flags.setFlags(self.get_parameter(2).value)
self.run(executable, command, self.flags['Wait'], self.flags['Hide'])
def write_init(self, writer):
data = self.get_data()
x_size = max(1, data.readInt())
y_size = max(1, data.readInt())
z_size = max(1, data.readInt())
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))
class Layer(DataLoader):
name = None
flags = None
xCoefficient = None
yCoefficient = None
numberOfBackgrounds = None
backgroundIndex = None
effect = None
def initialize(self):
self.flags = BitDict(
'XCoefficient',
'YCoefficient',
'DoNotSaveBackground',
None, #Wrap (Obsolete)
'Visible', # visible
'WrapHorizontally',
'WrapVertically',
None, None, None, None,
None, None, None, None, None,
'Redraw',
'ToHide',
'ToShow'
)
def read(self, reader):
value = reader.readInt(True)
self.flags.setFlags(value)
self.xCoefficient = reader.readFloat()
self.yCoefficient = reader.readFloat()
self.numberOfBackgrounds = reader.readInt()
self.backgroundIndex = reader.readInt()
self.name = self.readString(reader)
def write(self, reader):
reader.writeInt(self.flags.getFlags(), True)
reader.writeFloat(self.xCoefficient)
reader.writeFloat(self.yCoefficient)
reader.writeInt(self.numberOfBackgrounds)
reader.writeInt(self.backgroundIndex)
reader.writeString(self.name)
def getBackgrounds(self, objectInstances):
return objectInstances.items[
self.backgroundIndex:self.backgroundIndex+self.numberOfBackgrounds]
def getInstances(self, objectInstances):
return self.parent.getObjectInstances(self,
objectInstances)
def initialize(self):
self.flags = BitDict(
"KeepScreenRatio",
"FrameTransition", # (HWA only) frame has a transition
"ResampleStretch", # (HWA only) resample while resizing
"GlobalRefresh", # (Mobile) force global refresh
)
def initialize(self):
self.flags = BitDict(
'KeepScreenRatio',
'FrameTransition', # (HWA only) frame has a transition
'ResampleStretch', # (HWA only) resample while resizing
'GlobalRefresh' # (Mobile) force global refresh
)
def initialize(self):
self.flags = BitDict(
'Wave',
'MIDI',
None, None,
'LoadOnCall',
'PlayFromDisk',
'Loaded'
)
def created(self, data):
storage = self.get_storage()
if storage:
self.array = storage['value']
return
xDimension = data.readInt()
yDimension = data.readInt()
zDimension = data.readInt()
flags = BitDict('Numeric', 'Text', 'Base1', 'Global')
flags.setFlags(data.readInt())
if flags['Base1']:
self.arrayX = self.arrayY = self.arrayZ = 1
# yeah, I think this is comprehensive too.
self.array = array = MMFArray()
if flags['Numeric']:
arrayType = 'Numeric'
else:
arrayType = 'Text'
array.flags = flags
array.setup(xDimension, yDimension, zDimension, arrayType)
self.get_storage()['value'] = array
def write_init(self, writer):
data = self.get_data()
flags = BitDict(
'FreeFlag',
'VerticalScrollbar',
'Sort',
'Border',
'HideOnStart',
'SystemColor',
'3DLook',
'ScrollToNewline'
)
width = data.readShort()
height = data.readShort()
is_unicode = self.data.settings.get('unicode', False)
font = self.data.new(LogFont, data, old=not is_unicode)
font_color = data.readColor()
self.data.readString(data, 40)
data.skipBytes(16 * 4)
back_color = data.readColor()
flags.setFlags(data.readInt())
line_count = data.readShort(True)
index_offset = -1 if data.readInt() == 1 else 0
data.skipBytes(4 * 3)
for _ in xrange(line_count):
line = self.data.readString(data)
writer.putln(to_c('add_line(%r);', line))
if flags['HideOnStart']:
writer.putln('set_visible(false);')
if flags['Sort']:
writer.putln('list_flags |= SORT_LIST;')
if line_count:
writer.putln('sort();')
writer.putlnc('index_offset = current_line = %s;', index_offset)
def initialize(self):
self.palette = []
self.flags = BitDict(
'GrabDesktop',
'KeepDisplay',
'BackgroundCollisions',
'DisplayFrameTitle',
'ResizeToScreen',
'ForceLoadOnCall',
'NoDisplaySurface',
'ScreenSaverSetup',
'TimerBasedMovements',
'MochiAds',
'NoGlobalEvents'
)
def initialize(self):
self.flags = BitDict(
'XCoefficient',
'YCoefficient',
'DoNotSaveBackground',
None, #Wrap (Obsolete)
'Visible', # visible
'WrapHorizontally',
'WrapVertically',
None, None, None, None,
None, None, None, None, None,
'Redraw',
'ToHide',
'ToShow'
)
def initialize(self):
# 0x8000 == TimedMovements
self.flags = BitDict(
'DisplayName',
'GrabDesktop',
'KeepDisplay',
'FadeIn',
'FadeOut',
'TotalCollisionMask',
'Password',
'ResizeAtStart',
'DoNotCenter',
'ForceLoadOnCall',
'NoSurface',
'Reserved_1',
'Reserved_2',
'RecordDemo',
None,
'TimedMovements'
)
def write_init(self, writer):
data = self.get_data()
width = data.readInt()
height = data.readInt()
self.flags = BitDict(
'Resize',
'HideOnStart',
'TransparentBlack',
'TransparentFirstPixel',
'FlippedHorizontally',
'FlippedVertically',
'Resample',
'WrapModeOff',
)
self.flags.setFlags(data.readInt(True))
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
return get_color_tuple(index)
try:
return COLORS[index]
except KeyError:
return (0, 0, 0)
def read_system_color(reader):
value = reader.readInt(True)
return get_system_color(value)
FLAGS = BitDict('AlignTop', 'AlignVerticalCenter', 'AlignBottom', None,
'AlignLeft', 'AlignHorizontalCenter', 'AlignRight', None,
'Multiline', 'NoPrefix', 'EndEllipsis', 'PathEllipsis',
'Container', 'Contained', 'Hyperlink', None,
'AlignImageTopLeft', 'AlignImageCenter', 'AlignImagePattern',
None, 'Button', 'Checkbox', 'ShowButtonBorder',
'ImageCheckbox', 'HideImage', 'ForceClipping', None, None,
'ButtonPressed', 'ButtonHighlighted', 'Disabled')
NONE, HYPERLINK, BUTTON, CHECKBOX = xrange(4)
class SystemBox(ObjectWriter):
class_name = 'SystemBox'
filename = 'systembox'
use_alterables = True
default_instance = 'default_systembox_instance'
def write_init(self, writer):
data = self.get_data()
def created(self):
self.flags = BitDict('Wait', 'Hide')
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)
from mmfparser.data.font import LogFont
from mmfparser.bitdict import BitDict
EDIT_FLAGS = BitDict('HorizontalScrollbar', 'HorizontalAutoscroll',
'VerticalScrollbar', 'VerticalAutoscroll', 'ReadOnly',
'Multiline', 'Password', 'Border', 'HideOnStart',
'Uppercase', 'Lowercase', 'Tabstop', 'SystemColor',
'3DLook', 'Transparent', None, 'AlignCenter',
'AlignRight')
class EditObject(ObjectWriter):
class_name = 'EditObject'
filename = 'editext'
def write_init(self, writer):
if not self.has_updates():
return
data = self.get_data()
width = data.readShort(True)
height = data.readShort(True)
logFont = LogFont(data, old=True)
data.skipBytes(4 * 16) # custom colors?
foregroundColor = data.readColor()
backgroundColor = data.readColor()
data.skipBytes(40) # text-style?
def initialize(self):
self.flags = BitDict('Color')
def created(self):
self.flags = BitDict('Wait', 'Hide')
class Frame(DataLoader):
handle = None
name = None
size = None
background = None
maxObjects = None
password = None
palette = None
fadeIn = None
fadeOut = None
def initialize(self):
self.palette = []
self.flags = BitDict(
'GrabDesktop',
'KeepDisplay',
'BackgroundCollisions',
'DisplayFrameTitle',
'ResizeToScreen',
'ForceLoadOnCall',
'NoDisplaySurface',
'ScreenSaverSetup',
'TimerBasedMovements',
'MochiAds',
'NoGlobalEvents'
)
def read(self, reader):
self.handle = reader.readInt()
self.name = reader.read(reader.readInt())
self.size = (reader.readInt(), reader.readInt())
self.background = reader.readColor()
self.flags.setFlags(reader.readInt(True))
self.maxObjects = reader.readInt()
self.password = reader.read(reader.readInt())
checkDefault(reader, reader.readInt(), 0)
self.lastViewedX = reader.readInt()
self.lastViewedY = reader.readInt()
self.palette = [reader.readColor()
for _ in xrange(reader.readInt())]
self.stampHandle = reader.readInt()
self.activeLayer = reader.readInt()
self.layers = [self.new(Layer, reader)
for _ in xrange(reader.readInt())]
if reader.readByte() != 0:
self.fadeIn = self.new(Transition, reader)
if reader.readByte() != 0:
self.fadeOut = self.new(Transition, reader)
self.items = items = [self.new(FrameItem, reader)
for _ in xrange(reader.readInt())]
self.folders = [self.new(ItemFolder, reader)
for _ in xrange(reader.readInt(True))]
self.instances = [self.new(FrameInstance, reader)
for _ in xrange(reader.readInt())]
self.events = self.new(Events, reader)
self.chunks = self.new(ChunkList, reader)
def write(self, reader):
reader.writeInt(self.handle)
reader.writeInt(len(self.name)); reader.write(self.name)
reader.writeInt(self.size[0]); reader.writeInt(self.size[1])
reader.writeColor(self.background)
reader.writeInt(self.flags.getFlags(), True)
reader.writeInt(self.maxObjects)
reader.writeInt(len(self.password)); reader.write(self.password)
reader.writeInt(0)
reader.writeInt(self.lastViewedX)
reader.writeInt(self.lastViewedY)
reader.writeInt(len(self.palette))
for item in self.palette:
reader.writeColor(item)
reader.writeInt(self.stampHandle)
reader.writeInt(self.activeLayer)
reader.writeInt(len(self.layers))
for item in self.layers:
item.write(reader)
for item in (self.fadeIn, self.fadeOut):
if item is not None:
reader.writeByte(1)
item.write(reader)
else:
reader.writeByte(0)
for item in (self.items, self.folders, self.instances):
reader.writeInt(len(item), True)
for subitem in item:
subitem.write(reader)
self.events.write(reader)
self.chunks.write(reader)
return instance.x
class Expression3(Expression):
"""
Y Position of hiscore table
Return type: Int
"""
def get(self, instance):
return instance.y
from mmfparser.data.font import LogFont
from mmfparser.bitdict import BitDict
HIGHSCORE_FLAGS = BitDict('HideOnStart', 'NameFirst', 'CheckOnStart',
'HideScores', 'FullPath')
from mmfparser.player.objects.question import (draw_rectangle, draw_border,
X_MARGIN, Y_MARGIN)
from pyglet.text import Label
from mmfparser.player.ini import FastINI
import os
from pyglet import gl
from pyglet.window import key
BOX_WIDTH = 400
BOX_HEIGHT = 70
class DefaultObject(HiddenObject):
reader.writeColor(self.backColor)
reader.writeShort(0)
reader.writeInt(self.id)
class Int(ParameterCommon):
value = None
def read(self, reader):
self.value = reader.readInt()
def write(self, reader):
reader.writeInt(self.value)
SAMPLE_FLAGS = BitDict('Uninterruptible', 'Bad', 'IPhoneAudioPlayer',
'IPhoneOpenAL')
class Sample(ParameterCommon):
handle = None
flags = None
def initialize(self):
self.flags = SAMPLE_FLAGS.copy()
def read(self, reader):
self.handle = reader.readShort()
self.flags.setFlags(reader.readShort(True))
self.name = self.readString(reader)
def write(self, reader):
def initialize(self):
self.flags = BitDict('Numeric', 'Text', 'Base1', 'Global')
self.flags.setFlags(0) # to prevent BitDict from complaining :)
self.flags['Base1'] = True # default
self.flags['Text'] = True # default
self.default = ''
class Frame(DataLoader):
handle = None
name = None
size = None
background = None
maxObjects = None
password = None
palette = None
fadeIn = None
fadeOut = None
def initialize(self):
self.palette = []
self.flags = BitDict(
'GrabDesktop',
'KeepDisplay',
'BackgroundCollisions',
'DisplayFrameTitle',
'ResizeToScreen',
'ForceLoadOnCall',
'NoDisplaySurface',
'ScreenSaverSetup',
'TimerBasedMovements',
'MochiAds',
'NoGlobalEvents'
)
def read(self, reader):
self.handle = reader.readInt()
self.name = reader.read(reader.readInt())
self.size = (reader.readInt(), reader.readInt())
self.background = reader.readColor()
self.flags.setFlags(reader.readInt(True))
self.maxObjects = reader.readInt()
self.password = reader.read(reader.readInt())
checkDefault(reader, reader.readInt(), 0)
self.lastViewedX = reader.readInt()
self.lastViewedY = reader.readInt()
self.palette = [reader.readColor()
for _ in xrange(reader.readInt())]
self.stampHandle = reader.readInt()
self.activeLayer = reader.readInt()
self.layers = [self.new(Layer, reader)
for _ in xrange(reader.readInt())]
if reader.readByte() != 0:
self.fadeIn = self.new(Transition, reader)
if reader.readByte() != 0:
self.fadeOut = self.new(Transition, reader)
self.items = items = [self.new(FrameItem, reader)
for _ in xrange(reader.readInt())]
self.folders = [self.new(ItemFolder, reader)
for _ in xrange(reader.readInt(True))]
self.instances = [self.new(FrameInstance, reader)
for _ in xrange(reader.readInt())]
self.events = self.new(Events, reader)
self.chunks = self.new(ChunkList, reader)
def write(self, reader):
reader.writeInt(self.handle)
reader.writeInt(len(self.name)); reader.write(self.name)
reader.writeInt(self.size[0]); reader.writeInt(self.size[1])
reader.writeColor(self.background)
reader.writeInt(self.flags.getFlags(), True)
reader.writeInt(self.maxObjects)
reader.writeInt(len(self.password)); reader.write(self.password)
reader.writeInt(0)
reader.writeInt(self.lastViewedX)
reader.writeInt(self.lastViewedY)
reader.writeInt(len(self.palette))
for item in self.palette:
reader.writeColor(item)
reader.writeInt(self.stampHandle)
reader.writeInt(self.activeLayer)
reader.writeInt(len(self.layers))
for item in self.layers:
item.write(reader)
for item in (self.fadeIn, self.fadeOut):
if item is not None:
reader.writeByte(1)
item.write(reader)
else:
reader.writeByte(0)
for item in (self.items, self.folders, self.instances):
reader.writeInt(len(item), True)
for subitem in item:
subitem.write(reader)
self.events.write(reader)
self.chunks.write(reader)
def get(self, instance):
raise NotImplementedError('%s not implemented' % (str(self)))
class Expression14(Expression):
"""
Files->Get File Size
Return type: Int
"""
def get(self, instance):
raise NotImplementedError('%s not implemented' % (str(self)))
from mmfparser.bitdict import BitDict
FLAGS = BitDict('FilterCharacters', 'NoPadding')
global_keys = {}
class DefaultObject(HiddenObject):
def created(self, data):
self.flags = flags = FLAGS.copy()
flags.setFlags(data.readInt())
data.skipBytes(4)
self.filter = filter = []
while 1:
byte = data.read(1)
if byte == '\x00':
data.skipBytes(1)
break
def initialize(self):
self.flags = BitDict("Numeric", "Text", "Base1", "Global")
self.flags.setFlags(0) # to prevent BitDict from complaining :)
self.flags["Base1"] = True # default
self.flags["Text"] = True # default
self.default = ""
PlayerCondition.created(self)
self.playerHandler.push_handlers(lives_changed=self.lives_changed)
def lives_changed(self, value):
if value == 0:
self.generate()
return EVENT_HANDLED
def check(self):
return self.playerHandler.lives == 0
def on_detach(self):
self.playerHandler.remove_handlers(lives_changed=self.lives_changed)
KEY_FLAGS = BitDict('Up', 'Down', 'Left', 'Right', 'Button1', 'Button2',
'Button3', 'Button4')
class PlayerKeyPressed(PlayerCondition):
playerHandler = None
keys = None
pressed = False
fire = False
def key_pressed(self, name):
if self.keys_down():
if not self.pressed:
self.pressed = self.fire = True
if self.isTriggered:
self.generate()
else:
class MMFArray(DataLoader):
items = None
size = None
default = None
def initialize(self):
self.flags = BitDict('Numeric', 'Text', 'Base1', 'Global')
self.flags.setFlags(0) # to prevent BitDict from complaining :)
self.flags['Base1'] = True # default
self.flags['Text'] = True # default
self.default = ''
def read(self, reader):
if reader.readString() != MAGIC:
raise InvalidData('data is invalid')
if reader.readShort() != MAJOR_VERSION:
raise InvalidData('major version incompatibility')
if reader.readShort() != MINOR_VERSION:
raise InvalidData('minor version incompatibility')
xDimension = reader.readInt(True)
yDimension = reader.readInt(True)
zDimension = reader.readInt(True)
self.size = (xDimension, yDimension, zDimension)
items = self.items = {}
self.flags.setFlags(reader.readInt())
if self.flags['Numeric']:
self.default = 0
elif self.flags['Text']:
self.default = ''
else:
raise NotImplementedError(
'invalid array type (should be "Text" or "Numeric")')
for z in xrange(zDimension):
currentZ = {}
for y in xrange(yDimension):
currentY = {}
for x in xrange(xDimension):
if self.flags['Numeric']:
item = reader.readInt(True)
elif self.flags['Text']:
item = reader.read(reader.readInt(True))
else:
raise InvalidData('invalid flags')
currentY[x] = item
currentZ[y] = currentY
items[z] = currentZ
def write(self, reader):
reader.writeString(MAGIC)
reader.writeShort(MAJOR_VERSION)
reader.writeShort(MINOR_VERSION)
xDimension, yDimension, zDimension = self.size
reader.writeInt(xDimension)
reader.writeInt(yDimension)
reader.writeInt(zDimension)
reader.writeInt(self.flags.getFlags())
for z in xrange(zDimension):
for y in xrange(yDimension):
for x in xrange(xDimension):
try:
item = self.items[z][y][x]
except KeyError:
item = self.default
if self.flags['Numeric']:
reader.writeInt(int(item))
elif self.flags['Text']:
item = str(item)
reader.writeInt(len(item))
reader.write(item)
else:
raise NotImplementedError('invalid flags')
def get(self, x, y, z):
if self.flags['Base1']:
x -= 1
y -= 1
z -= 1
return self.items[z][y][x]
def set(self, x, y, z, value):
if self.flags['Base1']:
x -= 1
y -= 1
z -= 1
xDimension, yDimension, zDimension = self.size
self.size = (max(x + 1,
xDimension), max(y + 1,
yDimension), max(z + 1, zDimension))
if not z in self.items:
self.items[z] = {}
if not y in self.items[z]:
self.items[z][y] = {}
self.items[z][y][x] = value
def setup(self, xDimension, yDimension, zDimension, arrayType):
if arrayType == 'Text':
self.flags['Numeric'] = False
self.flags['Text'] = True
self.default = ''
elif arrayType == 'Numeric':
self.flags['Numeric'] = True
self.flags['Text'] = False
self.default = 0
else:
raise NotImplementedError(
'invalid array type (should be "Text" or "Numeric")')
self.size = (xDimension, yDimension, zDimension)
self.clear()
def clear(self):
self.items = {}
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Anaconda. If not, see <http://www.gnu.org/licenses/>.
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)
from mmfparser.data.font import LogFont
from mmfparser.bitdict import BitDict
BUTTON_FLAGS = BitDict('HideOnStart', 'DisableOnStart', 'TextOnLeft',
'Transparent', 'SystemColor')
PUSHTEXT_BUTTON = 0
CHECKBOX_BUTTON = 1
RADIO_BUTTON = 2
PUSHBITMAP_BUTTON = 3
PUSHTEXTBITMAP_BUTTON = 4
BUTTON_BORDER = 1
class ButtonObject(ObjectWriter):
class_name = 'ButtonObject'
filename = 'buttonext'
def write_init(self, writer):
items.append(self.new(CHUNK_LOADERS[id], data))
size = reader.tell() - start
reader.seek(start)
self.saved = reader.read(size)
def write(self, reader):
if self.saved is not None:
reader.write(self.saved)
else:
reader.writeByte(0)
LAYER_FLAGS = BitDict(
'Visible',
'Locked',
'Obsolete',
'HideAtStart',
'NoBackground',
'WrapHorizontally',
'WrapVertically',
'PreviousEffect'
)
class Layer(DataLoader):
name = None
xCoefficient = None
yCoefficient = None
flags = None
def initialize(self):
self.flags = LAYER_FLAGS.copy()
def read(self, reader):
def initialize(self):
self.flags = BitDict('Color')
class MMFArray(DataLoader):
items = None
size = None
default = None
def initialize(self):
self.flags = BitDict("Numeric", "Text", "Base1", "Global")
self.flags.setFlags(0) # to prevent BitDict from complaining :)
self.flags["Base1"] = True # default
self.flags["Text"] = True # default
self.default = ""
def read(self, reader):
if reader.readString() != MAGIC:
raise InvalidData("data is invalid")
if reader.readShort() != MAJOR_VERSION:
raise InvalidData("major version incompatibility")
if reader.readShort() != MINOR_VERSION:
raise InvalidData("minor version incompatibility")
xDimension = reader.readInt(True)
yDimension = reader.readInt(True)
zDimension = reader.readInt(True)
self.size = (xDimension, yDimension, zDimension)
items = self.items = {}
self.flags.setFlags(reader.readInt())
if self.flags["Numeric"]:
self.default = 0
elif self.flags["Text"]:
self.default = ""
else:
raise NotImplementedError('invalid array type (should be "Text" or "Numeric")')
for z in xrange(zDimension):
currentZ = {}
for y in xrange(yDimension):
currentY = {}
for x in xrange(xDimension):
if self.flags["Numeric"]:
item = reader.readInt(True)
elif self.flags["Text"]:
item = reader.read(reader.readInt(True))
else:
raise InvalidData("invalid flags")
currentY[x] = item
currentZ[y] = currentY
items[z] = currentZ
def write(self, reader):
reader.writeString(MAGIC)
reader.writeShort(MAJOR_VERSION)
reader.writeShort(MINOR_VERSION)
xDimension, yDimension, zDimension = self.size
reader.writeInt(xDimension)
reader.writeInt(yDimension)
reader.writeInt(zDimension)
reader.writeInt(self.flags.getFlags())
for z in xrange(zDimension):
for y in xrange(yDimension):
for x in xrange(xDimension):
try:
item = self.items[z][y][x]
except KeyError:
item = self.default
if self.flags["Numeric"]:
reader.writeInt(int(item))
elif self.flags["Text"]:
item = str(item)
reader.writeInt(len(item))
reader.write(item)
else:
raise NotImplementedError("invalid flags")
def get(self, x, y, z):
if self.flags["Base1"]:
x -= 1
y -= 1
z -= 1
return self.items[z][y][x]
def set(self, x, y, z, value):
if self.flags["Base1"]:
x -= 1
y -= 1
z -= 1
xDimension, yDimension, zDimension = self.size
self.size = (max(x + 1, xDimension), max(y + 1, yDimension), max(z + 1, zDimension))
if not z in self.items:
self.items[z] = {}
if not y in self.items[z]:
self.items[z][y] = {}
self.items[z][y][x] = value
def setup(self, xDimension, yDimension, zDimension, arrayType):
if arrayType == "Text":
self.flags["Numeric"] = False
self.flags["Text"] = True
self.default = ""
elif arrayType == "Numeric":
self.flags["Numeric"] = True
self.flags["Text"] = False
self.default = 0
else:
raise NotImplementedError('invalid array type (should be "Text" or "Numeric")')
self.size = (xDimension, yDimension, zDimension)
self.clear()
def clear(self):
self.items = {}
class BaseSound(DataLoader):
def getType(self):
header = self.data[:4]
if self.data[:4] == 'RIFF':
return 'WAV'
elif self.data[:4] == 'AIFF':
return 'AIFF'
elif self.data[:4] == 'OggS':
return 'OGG'
else:
# assume MOD
return 'MOD'
SOUND_FLAGS = BitDict('Wave', 'MIDI', None, None, 'LoadOnCall', 'PlayFromDisk',
'Loaded')
class SoundItem(BaseSound):
handle = None
checksum = None
references = None
flags = None
name = None
data = None
def initialize(self):
self.flags = SOUND_FLAGS.copy()
def read(self, reader):
start = reader.tell()
