def write_fonts(out, fonts):
fp = open(out, 'wb')
writer = ByteReader(fp)
writer.writeInt(len(fonts))
for font in fonts:
font.write(writer)
fp.close()
def convert(reader):
newReader = ByteReader()
for i in xrange(len(reader)):
value = reader.readByte(True)
value = ~(value - i % 256) % 256
newReader.writeByte(value, True)
newReader.seek(0)
return newReader
def get_shader(self, name, vert, frag):
vert = translate_shader_data(vert, 'vertex', 'gles')
frag = translate_shader_data(frag, 'fragment', 'gles')
writer = ByteReader()
writer.writeInt(len(vert))
writer.write(vert)
writer.writeInt(len(frag))
writer.write(frag)
return str(writer)
def write_preload(self, images):
self.fp.seek(self.use_count_offset)
data = ByteReader()
for handle in images:
data.writeShort(handle, True)
for handle in xrange(self.image_count):
if handle in images:
continue
data.writeShort(handle, True)
self.fp.write(str(data))
def get_shader(self, name, vert, frag):
writer = ByteReader()
writer.writeInt(len(vert))
writer.write(vert)
writer.writeInt(len(frag))
writer.write(frag)
return str(writer)
def read_runinfo(data):
info = {}
reader = ByteReader(data)
count = reader.readInt(True)
for _ in xrange(count):
name = reader.read(reader.readInt(True))
alts = {}
for i in xrange(26):
alts[i] = reader.readByte(True)
info[name] = alts
return info
def get_shader(self, name, vert, frag):
vert = translate_shader_data(vert, 'vertex', 'gles')
frag = translate_shader_data(frag, 'fragment', 'gles')
writer = ByteReader()
writer.writeInt(len(vert))
writer.write(vert)
writer.writeInt(len(frag))
writer.write(frag)
return str(writer)
def compress(data):
reader = ByteReader()
compressed = zlib.compress(str(data))
reader.writeInt(len(data))
reader.writeInt(len(compressed))
reader.write(compressed)
return reader
def read(self, reader):
self.handle = reader.readInt(True)
self.checksum = reader.readInt()
self.references = reader.readInt()
decompressedLenght = reader.readInt()
self.flags.setFlags(reader.readInt(True))
reserved = reader.readInt()
nameLenght = reader.readInt()
if self.settings.get('compressed', True):
size = reader.readInt()
data = ByteReader(zlib.decompress(reader.read(size)))
else:
data = reader.readReader(decompressedLenght)
self.name = self.readString(data, nameLenght)
self.data = data.read()
def write_runinfo(info):
writer = ByteReader()
writer.writeInt(len(info), True)
for k, v in info.iteritems():
writer.writeInt(len(k), True)
writer.write(k)
for i in xrange(26):
reader.writeByte(v[i], True)
def read(self, reader):
self.handle = reader.readInt(True)
self.checksum = reader.readInt()
self.references = reader.readInt()
decompressedLenght = reader.readInt()
self.flags.setFlags(reader.readInt(True))
reserved = reader.readInt()
nameLenght = reader.readInt()
if self.settings.get('compressed', True):
size = reader.readInt()
data = ByteReader(zlib.decompress(reader.read(size)))
else:
data = reader.readReader(decompressedLenght)
self.name = self.readString(data, nameLenght)
self.data = data.read()
def add_image(self, hot_x, hot_y, act_x, act_y, data):
writer = ByteReader()
writer.writeShort(hot_x)
writer.writeShort(hot_y)
writer.writeShort(act_x)
writer.writeShort(act_y)
writer.writeIntString(data)
self.images.append(str(writer))
def execute(self, instance):
filename = self.evaluate_expression(self.get_parameter(0))
try:
data = open_file(filename, 'rb').read()
except IOError:
return
instance.objectPlayer.workspace.data = ByteReader(data)
def __init__(self, filename):
filename = os.path.join(DATA_DIR, filename)
self.filename = filename
self.tiles = os.stat(filename).st_size != 0
name = os.path.basename(filename).encode('utf-8')
self.name = os.path.splitext(name)[0]
self.outdir = os.path.join(DATA_DIR, 'mfas') # + self.name
try:
os.makedirs(self.outdir)
except OSError:
pass
self.objects = {}
self.x_size = 16
self.y_size = 16
template_path = os.path.join(DATA_DIR, 'template.mfa')
self.mfa = MFA(ByteReader(open(template_path, 'rb')))
self.object_id = 32
self.image_id = 0
self.icon_id = max(self.mfa.icons.itemDict) + 1
def get_shader(self, name, vert, frag):
vert_path = os.path.join(SHADERS_DIR, name + '.vsb')
frag_path = os.path.join(SHADERS_DIR, name + '.psb')
with open(vert_path, 'rb') as fp:
vert_data = fp.read()
with open(frag_path, 'rb') as fp:
frag_data = fp.read()
writer = ByteReader()
writer.writeInt(len(vert_data))
writer.write(vert_data)
writer.writeInt(len(frag_data))
writer.write(frag_data)
return str(writer)
def run(self):
image_path = os.path.join(SETS_PATH, '%s.png' % self.name)
image = Image.open(image_path).convert('RGBA')
col = image.getpixel((0, 0))
if col[3] == 255:
print 'Filtering image with transparent color', col
buf = image.load()
for y in xrange(image.size[1]):
for x in xrange(image.size[0]):
test_col = buf[(x, y)]
if test_col != col:
continue
buf[(x, y)] = (0, 0, 0, 0)
frame = self.mfa.frames[0]
if self.tiles:
self.run_tiles(image)
else:
self.run_special(image)
frame.folders = []
for item in frame.items:
folder = frame.new(ItemFolder)
folder.items = [item.handle]
frame.folders.append(folder)
basename = os.path.basename(self.filename)
out_name = os.path.splitext(basename)[0] + '.mfa'
out_path = os.path.join(self.outdir, out_name)
self.mfa.write(ByteReader(open(out_path, 'wb')))
print 'Created %s' % out_name
def execute(self, instance):
filename = self.evaluate_index(0)
try:
data = gzip.GzipFile(convert_path(filename), 'rb').read()
except IOError:
return
instance.objectPlayer.workspace.data = ByteReader(data)
def execute(self, instance):
filename = self.evaluate_index(0)
try:
data = open_file(filename, 'rb').read()
except IOError:
return
instance.objectPlayer.workspace.data = ByteReader(data)
def __init__(self, filename):
self.filename = filename
self.tiles = os.stat(filename).st_size != 0
name = os.path.basename(filename).encode('utf-8')
if self.tiles:
self.name, size = name.split('_')[:2]
size = size.split(',')
self.x_size = int(size[0])
self.y_size = int(size[1])
else:
self.name = name.split('_')[0]
self.outdir = os.path.splitext(filename)[0]
try:
os.makedirs(self.outdir)
except OSError:
pass
self.objects = {}
template_path = os.path.join(DATA_DIR, 'template.mfa')
self.mfa = MFA(ByteReader(open(template_path, 'rb')))
self.object_id = 32
self.image_id = 0
self.icon_id = max(self.mfa.icons.itemDict) + 1
def execute(self, instance):
filename = convert_path(self.get_filename(self.get_parameter(0)))
try:
reader = ByteReader(open(filename, 'rb'))
instance.objectPlayer.array.read(reader)
except IOError:
pass
def write(self, reader):
reader.writeShort(self.objectType)
reader.writeShort(self.num)
if self.objectType == 0 and self.num == 0:
return
dataReader = ByteReader()
if (self.objectType in expression_system
and self.num in expression_system[self.objectType]):
self.loader.write(dataReader)
elif self.objectType >= 2 or self.objectType == -7:
dataReader.writeShort(self.objectInfo, True)
dataReader.writeShort(self.objectInfoList)
if self.num in expression_extension:
self.loader.write(dataReader)
reader.writeShort(len(dataReader) + 6, True)
reader.writeReader(dataReader)
def save_data_loader(loader):
writer = ByteReader()
loader.write(writer)
loader.parent = None
data = str(writer)
fp = tempfile.TemporaryFile()
fp.write(data)
return DataWrapper(fp)
def read(self, reader):
debug = self.settings.get('debug', False)
old = self.settings.get('old', False)
if debug:
path = reader.readString()
reader = ByteReader(open(path, 'rb'))
reader.skipBytes(4)
numberOfItems = reader.readInt()
if old:
klass = OldFont
else:
klass = FontItem
self.items = [self.new(klass, reader)
for _ in xrange(numberOfItems)]
def execute(self, instance):
filename = self.evaluate_index(0)
try:
array = WorkspaceArray(ByteReader(open_file(filename, 'rb')))
except IOError:
return
instance.objectPlayer.array = array
instance.objectPlayer.workspace = array.items[-1]
def run(self, cmd):
self.room = ByteReader(open(self.filename, 'rb'))
self.file_ver = self.room.readByte(True)
self.x_size = self.room.readByte(True)
self.y_size = self.room.readByte(True)
tileset_len = self.room.readByte(True)
self.tileset = self.room.readString(tileset_len)
self.tile_count = self.room.readInt(True)
image_path = os.path.join(SETS_PATH, '%s.png' % self.tileset)
image = Image.open(image_path).convert('RGBA')
col = image.getpixel((0, 0))
self.tileset_transparent = col[:3]
if col[3] == 255:
print 'Filtering image with transparent color', col
buf = image.load()
for y in xrange(image.size[1]):
for x in xrange(image.size[0]):
test_col = buf[(x, y)]
if test_col != col:
continue
buf[(x, y)] = (0, 0, 0, 0)
frame = self.mfa.frames[0]
if cmd == 'extract_tiles':
self.run_extract_tiles(image)
return
elif cmd == 'build':
self.run_build(image)
frame.folders = []
for item in frame.items:
folder = frame.new(ItemFolder)
folder.items = [item.handle]
frame.folders.append(folder)
basename = os.path.basename(self.filename)
out_name = os.path.splitext(basename)[0] + '.mfa'
out_path = os.path.join(self.outdir, out_name)
if os.path.isfile(out_path):
os.remove(out_path)
self.mfa.write(ByteReader(open(out_path, 'wb')))
print 'Created %s' % out_name
class Workspace(DataLoader):
name = ''
data = None
def initialize(self):
size = self.settings.get('defaultSize', 0)
self.data = ByteReader()
self.data.write('\x00' * size)
def read(self, reader):
self.name = reader.readString()
self.data = reader.readReader(reader.readInt(True))
def write(self, reader):
reader.writeString(self.name)
reader.writeInt(len(self.data))
reader.writeReader(self.data)
def execute(self, instance):
try:
filename = open_file_selector()
reader = ByteReader(open(filename, 'rb'))
instance.objectPlayer.array.read(reader)
file.close()
except IOError:
pass
class Workspace(DataLoader):
name = ''
data = None
def initialize(self):
size = self.settings.get('defaultSize', 0)
self.data = ByteReader()
self.data.write('\x00' * size)
def read(self, reader):
self.name = reader.readString()
self.data = reader.readReader(reader.readInt(True))
def write(self, reader):
reader.writeString(self.name)
reader.writeInt(len(self.data))
reader.writeReader(self.data)
def read(self, reader):
# reader.openEditor()
debug = self.settings.get('debug', False)
java = self.settings.get('java', False)
flash = self.settings.get('flash', False)
old = self.settings.get('old', False)
if debug:
path = reader.readString()
reader = ByteReader(open(path, 'rb'))
reader.skipBytes(4)
if java:
numberOfItems = reader.readShort()
itemsToRead = reader.readShort()
if flash:
itemClass = FlashSound
elif old:
itemClass = OldSound
else:
itemClass = JavaSound
else:
itemsToRead = reader.readInt()
if old:
itemClass = OldSound
else:
itemClass = SoundItem
compressed = not debug
self.items = [self.new(itemClass, reader, compressed = compressed)
for _ in xrange(itemsToRead)]
self.names = dict([(item.name, item) for item in self.items])
def compress(data):
reader = ByteReader()
compressed = zlib.compress(str(data))
reader.writeInt(len(data))
reader.writeInt(len(compressed))
reader.write(compressed)
return reader
def execute(self, instance):
filename = self.evaluate_index(0)
try:
array = WorkspaceArray(
ByteReader(gzip.GzipFile(convert_path(filename), 'rb').read()))
except IOError:
return
instance.objectPlayer.array = array
instance.objectPlayer.workspace = array.items[-1]
def add_sound(self, name, ext=None, data=None):
if ext is None:
audio_type = NONE_TYPE
else:
audio_type = AUDIO_TYPES.get(ext, NATIVE_TYPE)
index = len(self.sounds)
sound_id = get_asset_name('SOUND', name, index)
self.sound_ids[name.lower()] = sound_id
self.header.putdefine(sound_id, index)
writer = ByteReader()
writer.writeInt(audio_type)
if data:
writer.writeIntString(data)
self.sounds.append(str(writer))
def write_runinfo(info):
writer = ByteReader()
writer.writeInt(len(info), True)
for k, v in info.iteritems():
writer.writeInt(len(k), True)
writer.write(k)
for i in xrange(26):
reader.writeByte(v[i], True)
def add_image(self, hot_x, hot_y, act_x, act_y, data):
writer = ByteReader()
writer.writeShort(hot_x)
writer.writeShort(hot_y)
writer.writeShort(act_x)
writer.writeShort(act_y)
writer.writeIntString(data)
self.images.append(str(writer))
def get_shader(self, name, vert, frag):
vert_path = os.path.join(SHADERS_DIR, name + '.vsb')
frag_path = os.path.join(SHADERS_DIR, name + '.psb')
with open(vert_path, 'rb') as fp:
vert_data = fp.read()
with open(frag_path, 'rb') as fp:
frag_data = fp.read()
writer = ByteReader()
writer.writeInt(len(vert_data))
writer.write(vert_data)
writer.writeInt(len(frag_data))
writer.write(frag_data)
return str(writer)
def main():
print('#' * 43)
print('# ======== FN@FSource Decompiler ======== #')
print('# ' + '-' * 39 + ' #')
print('# Original bimbam tool by Mathias Kaerlev #')
print('#' * 43)
print('\n\n')
input = sys.argv[1]
output = sys.argv[2]
fp = ByteReader(open(input, 'rb'))
if input.endswith('.ccn'):
newGame = GameData(fp)
else:
newExe = ExecutableData(fp, loadImages=True)
for file in newExe.packData.items:
name = file.filename.split('\\')[-1]
print('Writing pack file ' + name)
open(os.path.join(output, name), 'wb').write(file.data)
newGame = newExe.gameData
if newGame.files is not None:
for file in newGame.files.items:
name = file.name.split('\\')[-1]
print('Writing embedded file ' + name)
open(os.path.join(output, name), 'wb').write(str(file.data))
newGame.files = None
def out(value):
print(value)
newMfa = translate(newGame, print_func = out)
out_path = os.path.join(output, 'out.mfa')
newMfa.write(ByteReader(open(out_path, 'wb')))
# newMfa = MFA(ByteReader(open(out_path, 'rb')))
print('Decompilation Completed!')
def write(self, reader):
newReader = ByteReader()
for item in self.items:
item.write(newReader)
reader.write(PACK_HEADER)
reader.writeInt(32)
reader.writeInt(len(newReader) + 64)
reader.writeInt(self.formatVersion)
reader.writeInt(0)
reader.writeInt(0)
reader.writeInt(len(self.items))
reader.writeReader(newReader)
def convert(reader):
newReader = ByteReader()
for i in xrange(len(reader)):
value = reader.readByte(True)
value = ~(value - i % 256) % 256
newReader.writeByte(value, True)
newReader.seek(0)
return newReader
def main():
print 'Bimbam tool by Mathias Kaerlev'
print 'ONLY for use on your own applications.'
print ''
input = sys.argv[1]
output = sys.argv[2]
fp = ByteReader(open(input, 'rb'))
if input.endswith('.ccn'):
newGame = GameData(fp)
else:
newExe = ExecutableData(fp, loadImages=False)
for file in newExe.packData.items:
name = file.filename.split('\\')[-1]
print 'Writing pack file %r' % name
open(os.path.join(output, name), 'wb').write(file.data)
newGame = newExe.gameData
if newGame.files is not None:
for file in newGame.files.items:
name = file.name.split('\\')[-1]
print 'Writing embedded file %r' % name
open(os.path.join(output, name), 'wb').write(str(file.data))
newGame.files = None
def out(value):
print value
newMfa = translate(newGame, print_func=out)
out_path = os.path.join(output, 'out.mfa')
newMfa.write(ByteReader(open(out_path, 'wb')))
# newMfa = MFA(ByteReader(open(out_path, 'rb')))
print 'Finished!'
def read(self, reader):
debug = self.settings.get('debug', False)
old = self.settings.get('old', False)
if debug:
path = self.readString(reader)
reader = ByteReader(open(path, 'rb'))
reader.skipBytes(4)
numberOfItems = reader.readInt()
if old:
klass = OldFont
else:
klass = FontItem
offset = 0
if self.settings['build'] >= 284 and not debug:
offset = -1
self.items = []
for _ in xrange(numberOfItems):
item = self.new(klass, reader)
item.handle += offset
self.items.append(item)
def read(self, reader):
debug = self.settings.get('debug', False)
old = self.settings.get('old', False)
if debug:
path = self.readString(reader)
reader = ByteReader(open(path, 'rb'))
reader.skipBytes(4)
numberOfItems = reader.readInt()
if old:
klass = OldFont
else:
klass = FontItem
offset = 0
if self.settings['build'] >= 284 and not debug:
offset = -1
self.items = []
for _ in xrange(numberOfItems):
item = self.new(klass, reader)
item.handle += offset
self.items.append(item)
def write(self, reader):
java = self.settings.get('java', False)
debug = self.settings.get('debug', False)
compressed = not debug and self.settings.get('compressed', True)
reader.writeInt(self.handle, True)
compressedReader = ByteReader()
compressedReader.writeInt(self.checksum)
compressedReader.writeInt(self.references)
compressedReader.writeInt(0) # size
self.value.write(compressedReader)
if not java and compressed:
reader.writeReader(zlibdata.compress(compressedReader))
else:
reader.writeReader(compressedReader)
def execute(self, instance):
filename = self.evaluate_expression(self.get_parameter(0))
try:
data = open_file(filename, 'rb').read()
except IOError:
return
array = MMFArray()
array.read(ByteReader(data))
if array.size[1] != 1 or array.size[2] != 1 or not array.flags['Text']:
return
value = []
valueDict = array.items[0][0]
for i in xrange(len(valueDict)):
value.append(valueDict[i])
instance.objectPlayer.value = instance.objectPlayer.join(value)
def write_preload(self, images):
self.fp.seek(self.use_count_offset)
data = ByteReader()
for handle in images:
data.writeShort(handle, True)
for handle in xrange(self.image_count):
if handle in images:
continue
data.writeShort(handle, True)
self.fp.write(str(data))
def write(self, reader):
reader.writeShort(self.version, True)
reader.writeShort(self.frameType)
if self.items:
reader.write(EVENT_DATA)
newReader = ByteReader()
for item in self.items:
item.write(newReader)
reader.writeIntString(str(newReader))
if self.comments is not None:
reader.write(COMMENT_DATA)
reader.writeInt(len(self.comments), True)
for comment in self.comments:
comment.write(reader)
if self.objects is not None:
reader.write(OBJECT_DATA)
reader.writeInt(len(self.objects), True)
for item in self.objects:
item.write(reader)
reader.write(EVENT_EDITOR_DATA)
reader.write('\x00' * (4 + 2 * 2 + 4 * 3))
if self.objectTypes is not None:
reader.write(OBJECT_LIST_DATA)
reader.writeShort(-1)
reader.writeShort(len(self.objectTypes))
for item in (self.objectTypes, self.objectHandles, self.objectFlags):
for subitem in item:
reader.writeShort(subitem, True)
reader.writeShort(len(self.folders), True)
for item in self.folders:
reader.writeIntString(item)
if self.x is not None:
reader.write(EDITOR_POSITION_DATA)
reader.writeShort(1)
reader.writeInt(self.x)
reader.writeInt(self.y)
reader.writeInt(self.caretType, True)
reader.writeInt(self.caretX, True)
reader.writeInt(self.caretY, True)
if self.lineY is not None:
reader.write(EDITOR_LINE_DATA)
reader.writeShort(1)
reader.writeInt(self.lineY, True)
reader.writeInt(self.lineItemType, True)
reader.writeInt(self.eventLine, True)
reader.writeInt(self.eventLineY, True)
reader.write(EVENT_END)
def run(self, cmd):
self.room = ByteReader(open(self.filename, 'rb'))
self.file_ver = self.room.readByte(True)
self.x_size = self.room.readByte(True)
self.y_size = self.room.readByte(True)
tileset_len = self.room.readByte(True)
self.tileset = self.room.readString(tileset_len)
self.tile_count = self.room.readInt(True)
image_path = os.path.join(SETS_PATH, '%s.png' % self.tileset)
image = Image.open(image_path).convert('RGBA')
col = image.getpixel((0, 0))
self.tileset_transparent = col[:3]
if col[3] == 255:
print 'Filtering image with transparent color', col
buf = image.load()
for y in xrange(image.size[1]):
for x in xrange(image.size[0]):
test_col = buf[(x, y)]
if test_col != col:
continue
buf[(x, y)] = (0, 0, 0, 0)
frame = self.mfa.frames[0]
if cmd == 'extract_tiles':
self.run_extract_tiles(image)
return
elif cmd == 'build':
self.run_build(image)
frame.folders = []
for item in frame.items:
folder = frame.new(ItemFolder)
folder.items = [item.handle]
frame.folders.append(folder)
basename = os.path.basename(self.filename)
out_name = os.path.splitext(basename)[0] + '.mfa'
out_path = os.path.join(self.outdir, out_name)
if os.path.isfile(out_path):
os.remove(out_path)
self.mfa.write(ByteReader(open(out_path, 'wb')))
print 'Created %s' % out_name
def read(self, filename):
self.points = []
try:
data = ByteReader(open(filename, 'rb'))
except IOError:
return
while data.tell() < len(data):
count = (data.readInt() - 2) / 2
x = data.readInt()
y = data.readInt()
point = Point(x, y)
self.points.append(point)
for _ in xrange(count):
point_id = data.readInt()
distance = data.readFloat()
connection = Connection(point_id, distance)
point.connections.append(connection)
def read(self, reader):
java = self.settings.get('java', False)
debug = self.settings.get('debug', False)
if debug:
path = reader.readString()
reader = ByteReader(open(path, 'rb'))
reader.skipBytes(4)
if java:
totalReferences = reader.readShort()
numberOfItems = reader.readShort()
itemClass = JavaMusic
else:
numberOfItems = reader.readInt()
itemClass = MusicFile
self.items = [self.new(itemClass, reader)
for _ in xrange(numberOfItems)]
def write_data(self):
header = ByteReader()
data = ByteReader()
header_size = (len(self.images) + len(self.sounds) + len(self.fonts) +
len(self.shaders)) * 4 + len(self.images) * 2
# image preload
self.use_count_offset = header.tell()
for _ in xrange(len(self.images)):
header.writeShort(0, True)
for image in self.images:
header.writeInt(data.tell() + header_size, True)
data.write(image)
for sound in self.sounds:
header.writeInt(data.tell() + header_size, True)
data.write(sound)
for shader in self.shaders:
header.writeInt(data.tell() + header_size, True)
data.write(shader)
self.fp.write(str(header))
self.fp.write(str(data))
self.image_count = len(self.images)
self.sound_count = len(self.sounds)
self.font_count = len(self.fonts)
self.shader_count = len(self.shaders)
self.sounds = self.images = self.fonts = self.shaders = None
def write(self, reader):
newReader = ByteReader()
newReader.writeShort(self.handle)
newReader.writeInt(self.magicNumber)
newReader.writeInt(self.versionLS)
newReader.writeInt(self.versionMS)
newReader.writeString('.'.join([self.name, self.extension]))
newReader.writeString(self.subType)
reader.writeShort(len(newReader) + 2, True)
reader.writeReader(newReader)
def write_data(self):
header = ByteReader()
data = ByteReader()
header_size = ((len(self.images) + len(self.sounds) + len(self.fonts) +
len(self.shaders) + len(self.files)) * 4
+ len(self.images) * 2 + 5 * 4)
# image preload
self.use_count_offset = header.tell()
for _ in xrange(len(self.images)):
header.writeShort(0, True)
start = data.tell()
for image in self.images:
header.writeInt(data.tell() + header_size, True)
data.write(image)
image_size = data.tell() - start
start = data.tell()
for sound in self.sounds:
header.writeInt(data.tell() + header_size, True)
data.write(sound)
sound_size = data.tell() - start
start = data.tell()
for font in self.fonts:
header.writeInt(data.tell() + header_size, True)
data.write(font)
font_size = data.tell() - start
start = data.tell()
for shader in self.shaders:
header.writeInt(data.tell() + header_size, True)
data.write(shader)
shader_size = data.tell() - start
start = data.tell()
for packfile in self.files:
header.writeInt(data.tell() + header_size, True)
data.write(packfile)
packfile_size = data.tell() - start
for size in (image_size, sound_size, font_size, shader_size,
packfile_size):
header.writeInt(size, True)
self.fp.write(str(header))
self.fp.write(str(data))
self.image_count = len(self.images)
self.sound_count = len(self.sounds)
self.font_count = len(self.fonts)
self.shader_count = len(self.shaders)
self.file_count = len(self.files)
self.sounds = self.images = self.fonts = self.shaders = None
self.files = None
def write(self, reader):
reader.writeIntString(self.name)
reader.writeIntString(self.extension)
reader.writeInt(self.identifier)
newReader = ByteReader()
if not self.extension:
newReader.writeShort(self.player)
newReader.writeShort(self.type)
newReader.writeByte(self.movingAtStart)
newReader.write('\x00' * 3)
newReader.writeInt(self.directionAtStart)
self.loader.write(newReader)
reader.writeIntString(str(newReader))
class Tiler(object):
def __init__(self, filename):
filename = os.path.join(DATA_DIR, filename)
self.filename = filename
self.tiles = os.stat(filename).st_size != 0
name = os.path.basename(filename).encode('utf-8')
self.name = os.path.splitext(name)[0]
self.outdir = os.path.join(DATA_DIR, 'mfas')# + self.name
try:
os.makedirs(self.outdir)
except OSError:
pass
self.objects = {}
self.x_size = 16
self.y_size = 16
template_path = os.path.join(DATA_DIR, 'template.mfa')
self.mfa = MFA(ByteReader(open(template_path, 'rb')))
self.object_id = 32
self.image_id = 0
self.icon_id = max(self.mfa.icons.itemDict) + 1
def run(self, cmd):
self.room = ByteReader(open(self.filename, 'rb'))
self.file_ver = self.room.readByte(True)
self.x_size = self.room.readByte(True)
self.y_size = self.room.readByte(True)
tileset_len = self.room.readByte(True)
self.tileset = self.room.readString(tileset_len)
self.tile_count = self.room.readInt(True)
image_path = os.path.join(SETS_PATH, '%s.png' % self.tileset)
image = Image.open(image_path).convert('RGBA')
col = image.getpixel((0, 0))
self.tileset_transparent = col[:3]
if col[3] == 255:
print 'Filtering image with transparent color', col
buf = image.load()
for y in xrange(image.size[1]):
for x in xrange(image.size[0]):
test_col = buf[(x, y)]
if test_col != col:
continue
buf[(x, y)] = (0, 0, 0, 0)
frame = self.mfa.frames[0]
if cmd == 'extract_tiles':
self.run_extract_tiles(image)
return
elif cmd == 'build':
self.run_build(image)
frame.folders = []
for item in frame.items:
folder = frame.new(ItemFolder)
folder.items = [item.handle]
frame.folders.append(folder)
basename = os.path.basename(self.filename)
out_name = os.path.splitext(basename)[0] + '.mfa'
out_path = os.path.join(self.outdir, out_name)
if os.path.isfile(out_path):
os.remove(out_path)
self.mfa.write(ByteReader(open(out_path, 'wb')))
print 'Created %s' % out_name
def run_build(self, image):
mask_path = os.path.join(SETS_PATH, '%s_mask.png' % self.tileset)
mask = Image.open(mask_path)
if mask.mode != 'P':
raise ValueError('The mask has to be palette image')
#mask = mask.convert('P')
colors = mask.getcolors()
transparent = mask.getpixel((0, 0))
if transparent != 0:
raise ValueError('The transparent color should be the first color '
'in the palette')
buf = image.load()
for (_, color) in colors:
if color == transparent or color == 255:
continue
color_image = mask.point(lambda x: 1 if x == color else 0)
box = color_image.getbbox()
tile_x = box[0] / self.x_size
tile_y = box[1] / self.y_size
height = box[3] - box[1]
width = box[2] - box[0]
new_image = Image.new('RGBA', (width, height),
self.tileset_transparent)
buf2 = color_image.load()
buf3 = new_image.load()
for y in xrange(height):
for x in xrange(width):
xx = x + box[0]
yy = y + box[1]
if buf2[(xx, yy)] == 0 or buf[(xx, yy)][3] == 0:
continue
buf3[(x, y)] = buf[(xx, yy)]
obstacle = mask.getpixel((tile_x, tile_y)) == 255
self.create_object("%s%s" % (self.tileset, color), color,
new_image, obstacle)
room_width = 0
room_height = 0
instances = []
map = dict()
for _ in xrange(self.tile_count):
try:
x = self.room.readShort() * self.x_size
y = self.room.readShort() * self.y_size
room_width = max(room_width, x + 200)
room_height = max(room_height, y + 200)
key = self.room.readByte(True)
frameitem = self.objects[key]
instances.append((frameitem, x, y))
map[(x,y)] = 1
except:
break
for i in instances:
self.create_instance(*i)
#statt self.create_instance(i[0], i[1], i[2])
frame = self.mfa.frames[0]
frame.size = room_width, room_height
def run_extract_tiles(self, image):
tile_folder = sys.argv[3]
image_path = os.path.join(SETS_PATH, '%s.png' % self.tileset)
image = Image.open(image_path).convert('RGBA')
mask_path = os.path.join(SETS_PATH, '%s_mask.png' % self.tileset)
mask = Image.open(mask_path)
transparent_color = image.getpixel((0, 0))
if mask.mode != 'P':
raise ValueError('The mask has to be palette image')
#mask = mask.convert('P')
colors = mask.getcolors()
transparent = mask.getpixel((0, 0))
if transparent != 0:
raise ValueError('The transparent color should be the first color '
'in the palette')
ini = open(os.path.join(DATA_DIR, tile_folder, 'tiles.ini'), 'w')
for (_, color) in colors:
if color == transparent:
continue
# Extract the current tile's shape from the mask image
tile_mask = mask.point(lambda x: 1 if x == color else 0, '1')
box = tile_mask.getbbox()
tile_mask = tile_mask.crop(box)
# Create an image and render the tile to it
tile = Image.new('RGBA', tile_mask.size)
tile.paste(image.crop(box), tile_mask)
col = image.getpixel((0, 0))
buf = tile.load()
# Clear transparent pixels
for y in xrange(tile.size[1]):
for x in xrange(tile.size[0]):
if buf[(x, y)] == transparent_color:
buf[(x, y)] = (0, 0, 0, 0)
tile.save(os.path.join(DATA_DIR, tile_folder, "%s.png" % color),
"PNG")
x = box[0]
y = box[1]
height = box[3] - y
width = box[2] - x
tile_x = x / self.x_size
tile_y = y / self.y_size
if color == 25:
print tile_x * self.x_size, x
ini.write("[t%s]\n" % color)
ini.write("x=%s\n" % x)
ini.write("y=%s\n" % y)
ini.write("x_off=%s\n" % (x - tile_x * self.x_size))
ini.write("y_off=%s\n" % (y - tile_y * self.y_size))
ini.write("width=%s\n" % width)
ini.write("height=%s\n" % height)
ini.write("[image]\n")
ini.write("width=%s\n" % image.size[0])
ini.write("height=%s\n" % image.size[1])
ini.close()
def create_instance(self, frameitem, x, y):
frame = self.mfa.frames[0]
instance = frame.new(FrameInstance)
instance.x = x
instance.y = y
instance.handle = len(frame.instances) + 1
instance.flags = 0
instance.parentType = NONE_PARENT
instance.itemHandle = frameitem.handle
instance.parentHandle = 0
instance.layer = 0
frame.instances.append(instance)
def create_image(self, image, icon):
if icon:
bank = self.mfa.icons
handle = self.icon_id
self.icon_id += 1
image = image.resize((32, 32), Image.LANCZOS)
else:
bank = self.mfa.images
handle = self.image_id
self.image_id += 1
item = bank.new(ImageItem, debug=True)
item.handle = handle
item.checksum = 123
item.references = 0
item.width = image.size[0]
item.height = image.size[1]
item.xHotspot = item.yHotspot = item.actionX = item.actionY = 0
item.flags['Alpha'] = False#True
item.transparent = self.tileset_transparent
item.graphicMode = 4
item.image = image.tobytes('raw', 'RGBA')
item.alpha = image.tobytes('raw', 'A')
bank.items.append(item)
bank.itemDict[item.handle] = item
return item
def create_object(self, name, key, image, obstacle=False, size=None):
item = self.create_image(image, False)
icon = self.create_image(image, True)
frame = self.mfa.frames[0]
frameitem = frame.new(FrameItem)
frame.items.append(frameitem)
frameitem.name = name
if size is not None:
frameitem.objectType = QUICKBACKDROP
else:
frameitem.objectType = BACKDROP
frameitem.handle = self.object_id
self.object_id += 1
frameitem.transparent = True
frameitem.inkEffect = frameitem.inkEffectParameter = 0
frameitem.antiAliasing = False
frameitem.iconHandle = icon.handle
frameitem.chunks = frameitem.new(ChunkList)
if size is not None:
obj = frameitem.new(QuickBackdrop)
obj.width = size[0]
obj.height = size[1]
obj.shape = objects.RECTANGLE_SHAPE
obj.borderSize = 0
obj.borderColor = (0, 0, 0)
obj.fillType = objects.MOTIF_FILL
obj.color1 = (0, 0, 0)
obj.color2 = (0, 0, 0)
obj.image = item.handle
else:
obj = frameitem.new(Backdrop)
obj.handle = item.handle
obj.obstacleType = 1 if obstacle else 0
obj.collisionType = 0
frameitem.loader = obj
if key is not None:
self.objects[key] = frameitem
return frameitem
def to_png(data):
reader = ByteReader(data)
width = reader.readInt(True)
height = reader.readInt(True)
data = reader.read(width*height)
return Image.frombytes('L', (width, height), data)
def get_sized_data(data):
writer = ByteReader()
writer.writeIntString(data)
return str(writer)
def get_wav(self):
reader = ByteReader()
reader.write('RIFF')
reader.writeInt(len(self.data) - 44)
reader.write('WAVEfmt ')
reader.writeInt(16, True)
reader.writeShort(self.format, True)
reader.writeShort(self.channel_count, True)
reader.writeInt(self.sample_rate, True)
reader.writeInt(self.byte_rate, True)
reader.writeShort(self.block_align, True)
reader.writeShort(self.bits_per_sample, True)
reader.write('data')
reader.writeInt(self.chunk_size, True)
reader.write(self.data)
return reader
def write(self, reader):
reader.write(MFA_MAGIC)
reader.writeInt(self.mfaBuild)
reader.writeInt(self.product)
reader.writeInt(self.buildVersion)
if self.languageId is not None:
reader.writeInt(self.languageId)
reader.writeInt(len(self.name))
reader.write(self.name)
reader.writeInt(len(self.description))
reader.write(self.description)
reader.writeInt(len(self.path))
reader.write(self.path)
reader.writeInt(len(self.stamp), True)
reader.write(self.stamp)
reader.write(FONT_BANK)
self.fonts.write(reader)
reader.write(SOUND_BANK)
self.sounds.write(reader)
reader.write(MUSIC_BANK)
self.music.write(reader)
for item in (self.icons, self.images):
reader.write(IMAGE_BANK)
item.write(reader)
reader.writeInt(len(self.name))
reader.write(self.name)
reader.writeInt(len(self.author))
reader.write(self.author)
reader.writeInt(len(self.description))
reader.write(self.description)
reader.writeInt(len(self.copyright))
reader.write(self.copyright)
reader.writeInt(len(self.company))
reader.write(self.company)
reader.writeInt(len(self.version))
reader.write(self.version)
reader.writeInt(self.windowSize[0])
reader.writeInt(self.windowSize[1])
reader.writeColor(self.borderColor)
reader.writeInt(self.displaySettings.getFlags())
reader.writeInt(self.graphicSettings.getFlags())
reader.writeInt(len(self.helpFile)); reader.write(self.helpFile)
reader.writeInt(len(self.vitalizePreview))
reader.write(self.vitalizePreview)
reader.writeInt(self.initialScore, True)
reader.writeInt(self.initialLifes, True)
reader.writeInt(self.frameRate)
reader.writeInt(self.buildType)
reader.writeInt(len(self.buildPath))
reader.write(self.buildPath)
reader.writeInt(0)
reader.writeInt(len(self.commandLine))
reader.write(self.commandLine)
reader.writeInt(len(self.aboutBox))
reader.write(self.aboutBox)
reader.writeInt(0)
reader.writeInt(len(self.binaryFiles))
for item in self.binaryFiles:
reader.writeInt(len(item))
reader.write(item)
self.controls.write(reader)
if self.menu:
menuData = self.menu.generate()
reader.writeInt(len(menuData))
reader.writeReader(menuData)
else:
reader.writeInt(0)
reader.writeInt(self.windowMenuIndex)
reader.writeInt(len(self.menuImages))
for k, v in self.menuImages.iteritems():
reader.writeInt(k)
reader.writeInt(v)
self.globalValues.write(reader)
self.globalStrings.write(reader)
reader.writeInt(len(self.globalEvents))
reader.write(self.globalEvents)
reader.writeInt(self.graphicMode)
reader.writeInt(len(self.iconImages))
for item in self.iconImages:
reader.writeInt(item)
reader.writeInt(len(self.customQualifiers))
for item in self.customQualifiers:
name, handle = item
reader.writeInt(len(name)); reader.write(name)
reader.writeInt(handle)
reader.writeInt(len(self.extensions))
for item in self.extensions:
handle, filename, name, magic, subType = item
reader.writeInt(handle)
reader.writeIntString(filename)
reader.writeIntString(name)
reader.writeInt(magic)
reader.writeIntString(subType)
reader.writeInt(len(self.frames))
startPosition = reader.tell() + 4 * len(self.frames) + 4
newReader = ByteReader()
for frame in self.frames:
reader.writeInt(startPosition + newReader.tell(), True)
frame.write(newReader)
reader.writeInt(startPosition + newReader.tell(), True)
reader.writeReader(newReader)
self.chunks.write(reader)
