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 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 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 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 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 = open_file(filename, 'rb').read()
except IOError:
return
instance.objectPlayer.workspace.data = ByteReader(data)
def compress(data):
reader = ByteReader()
compressed = zlib.compress(str(data))
reader.writeInt(len(data))
reader.writeInt(len(compressed))
reader.write(compressed)
return reader
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, vert, frag):
writer = ByteReader()
writer.writeInt(len(vert))
writer.write(vert)
writer.writeInt(len(frag))
writer.write(frag)
return str(writer)
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 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):
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 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 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 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 execute(self, instance):
try:
filename = open_file_selector()
reader = ByteReader(open(filename, 'rb'))
instance.objectPlayer.array.read(reader)
file.close()
except IOError:
pass
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 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 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 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 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 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):
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 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 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):
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))
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 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 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 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()
