mirror of https://github.com/pret/pokecrystal.git
265 lines
8.0 KiB
Python
265 lines
8.0 KiB
Python
"""Supplementary scripts for graphics conversion."""
|
|
|
|
import os
|
|
import argparse
|
|
|
|
from extras.pokemontools import gfx, lz
|
|
|
|
|
|
# Graphics with inverted tilemaps that aren't covered by filepath_rules.
|
|
pics = [
|
|
'gfx/shrink1',
|
|
'gfx/shrink2',
|
|
]
|
|
|
|
def recursive_read(filename):
|
|
def recurse(filename_):
|
|
lines = []
|
|
for line in open(filename_):
|
|
if 'include "' in line.lower():
|
|
lines += recurse(line.split('"')[1])
|
|
else:
|
|
lines += [line]
|
|
return lines
|
|
lines = recurse(filename)
|
|
return ''.join(lines)
|
|
|
|
base_stats = None
|
|
def get_base_stats():
|
|
global base_stats
|
|
if not base_stats:
|
|
base_stats = recursive_read('data/base_stats.asm')
|
|
return base_stats
|
|
|
|
def get_pokemon_dimensions(path):
|
|
try:
|
|
byte = bytearray(open(path, 'rb').read())[0]
|
|
width = byte & 0xf
|
|
height = (byte >> 8) & 0xf
|
|
return width, height
|
|
except:
|
|
return None
|
|
|
|
|
|
def get_animation_frames(path=None, w=7, h=7, bitmask_path=None, frame_path=None):
|
|
"""Retrieve animation frame tilemaps from generated frame/bitmask data."""
|
|
if not path:
|
|
path = bitmask_path
|
|
if not path:
|
|
path = frame_path
|
|
if not path:
|
|
raise Exception("need at least one of path, bitmask_path or frame_path")
|
|
|
|
if not bitmask_path:
|
|
bitmask_path = os.path.join(os.path.split(path)[0], 'bitmask.asm')
|
|
if not frame_path:
|
|
frame_path = os.path.join(os.path.split(path)[0], 'frames.asm')
|
|
bitmask_lines = open(bitmask_path).readlines()
|
|
frame_lines = open(frame_path).readlines()
|
|
|
|
bitmask_length = w * h
|
|
|
|
bitmasks = []
|
|
bitmask = []
|
|
for line in bitmask_lines:
|
|
if '\tdb ' in line:
|
|
value = line.split('\tdb ')[1].strip().replace('%', '0b')
|
|
value = int(value, 0)
|
|
#print line.strip(), value, len(bitmasks), len(bitmask)
|
|
for bit in xrange(8):
|
|
bitmask += [(value >> bit) & 1]
|
|
if len(bitmask) >= bitmask_length:
|
|
bitmasks += [bitmask]
|
|
bitmask = []
|
|
break
|
|
if bitmask:
|
|
bitmasks += [bitmask]
|
|
|
|
frames = []
|
|
frame_labels = []
|
|
i = 0
|
|
for line in frame_lines:
|
|
if '\tdw ' in line:
|
|
frame_labels += [line.split('\tdw ')[1].strip()]
|
|
else:
|
|
for part in line.split():
|
|
part = part.strip()
|
|
if part in frame_labels:
|
|
frames += [(part, i)]
|
|
i += 1
|
|
|
|
results = []
|
|
|
|
for label, i in frames:
|
|
result = []
|
|
|
|
# get the bitmask and tile ids for each frame
|
|
# don't care if we read past bounds, so just read the rest of the file
|
|
values = []
|
|
for line in frame_lines[i:]:
|
|
if '\tdb ' in line:
|
|
values += line.split('\tdb ')[1].split(';')[0].split(',')
|
|
|
|
#print bitmasks
|
|
#print values[0]
|
|
#print int(values[0].replace('$', '0x'), 0)
|
|
bitmask = bitmasks[int(values[0].replace('$', '0x'), 0)]
|
|
tiles = values[1:]
|
|
k = 0
|
|
j = 0
|
|
for bit in bitmask:
|
|
if bit:
|
|
result += [int(tiles[k].replace('$', '0x'), 0)]
|
|
k += 1
|
|
else:
|
|
result += [j]
|
|
j += 1
|
|
|
|
results += [result]
|
|
|
|
return results
|
|
|
|
def get_animated_graphics(path, w=7, h=7, bitmask_path=None, frame_path=None):
|
|
frames = get_animation_frames(path, w, h, bitmask_path, frame_path)
|
|
new_path = path.replace('.animated.2bpp', '.2bpp')
|
|
tiles = gfx.get_tiles(bytearray(open(path, 'rb').read()))
|
|
new_tiles = tiles[:w * h]
|
|
for frame in frames:
|
|
for tile in frame:
|
|
new_tiles += [tiles[tile]]
|
|
new_graphic = gfx.connect(new_tiles)
|
|
print new_path, list(new_graphic)
|
|
open(new_path, 'wb').write(bytearray(new_graphic))
|
|
return new_path
|
|
|
|
def filepath_rules(filepath):
|
|
"""Infer attributes of certain graphics by their location in the filesystem."""
|
|
args = {}
|
|
|
|
filedir, filename = os.path.split(filepath)
|
|
if filedir.startswith('./'):
|
|
filedir = filedir[2:]
|
|
|
|
name, ext = os.path.splitext(filename)
|
|
if ext == '.lz':
|
|
name, ext = os.path.splitext(name)
|
|
|
|
pokemon_name = ''
|
|
|
|
if 'gfx/pics/' in filedir:
|
|
pokemon_name = filedir.split('/')[-1]
|
|
if pokemon_name.startswith('unown_'):
|
|
index = filedir.find(pokemon_name)
|
|
if index != -1:
|
|
filedir = filedir[:index + len('unown')] + filedir[index + len('unown_a'):]
|
|
if name == 'front' or name == 'front.animated':
|
|
args['pal_file'] = os.path.join(filedir, 'normal.pal')
|
|
args['pic'] = True
|
|
args['animate'] = True
|
|
elif name == 'back':
|
|
args['pal_file'] = os.path.join(filedir, 'normal.pal')
|
|
args['pic'] = True
|
|
|
|
elif 'gfx/trainers' in filedir:
|
|
args['pic'] = True
|
|
|
|
elif os.path.join(filedir, name) in pics:
|
|
args['pic'] = True
|
|
|
|
elif filedir == 'gfx/tilesets':
|
|
args['tileset'] = True
|
|
|
|
if args.get('pal_file'):
|
|
if os.path.exists(args['pal_file']):
|
|
args['palout'] = args['pal_file']
|
|
else:
|
|
del args['pal_file']
|
|
|
|
if args.get('pic'):
|
|
if ext == '.png':
|
|
w, h = gfx.png.Reader(filepath).asRGBA8()[:2]
|
|
w = min(w/8, h/8)
|
|
args['pic_dimensions'] = w, w
|
|
elif ext == '.2bpp':
|
|
if pokemon_name and name == 'front' or name == 'front.animated':
|
|
w, h = get_pokemon_dimensions(filepath.replace(ext, '.dimensions')) or (7, 7)
|
|
args['pic_dimensions'] = w, w
|
|
elif pokemon_name and name == 'back':
|
|
args['pic_dimensions'] = 6, 6
|
|
else:
|
|
args['pic_dimensions'] = 7, 7
|
|
|
|
if args.get('tileset'):
|
|
args['width'] = 128
|
|
return args
|
|
|
|
|
|
def to_1bpp(filename, **kwargs):
|
|
name, ext = os.path.splitext(filename)
|
|
if ext == '.1bpp': pass
|
|
elif ext == '.2bpp': gfx.export_2bpp_to_1bpp(filename, **kwargs)
|
|
elif ext == '.png': gfx.export_png_to_1bpp(filename, **kwargs)
|
|
elif ext == '.lz':
|
|
decompress(filename, **kwargs)
|
|
to_1bpp(name, **kwargs)
|
|
|
|
def to_2bpp(filename, **kwargs):
|
|
name, ext = os.path.splitext(filename)
|
|
if ext == '.1bpp': gfx.export_1bpp_to_2bpp(filename, **kwargs)
|
|
elif ext == '.2bpp': pass
|
|
elif ext == '.png': gfx.export_png_to_2bpp(filename, **kwargs)
|
|
elif ext == '.lz':
|
|
decompress(filename, **kwargs)
|
|
to_2bpp(name, **kwargs)
|
|
|
|
def to_png(filename, **kwargs):
|
|
name, ext = os.path.splitext(filename)
|
|
if ext == '.1bpp': gfx.export_1bpp_to_png(filename, **kwargs)
|
|
elif ext == '.2bpp' and name.endswith('.animated'):
|
|
w, h = kwargs.get('pic_dimensions') or (7, 7)
|
|
new_path = get_animated_graphics(filename, w=w, h=h)
|
|
return to_png(new_path, **kwargs)
|
|
elif ext == '.2bpp': gfx.export_2bpp_to_png(filename, **kwargs)
|
|
elif ext == '.png': pass
|
|
elif ext == '.lz':
|
|
decompress(filename, **kwargs)
|
|
to_png(name, **kwargs)
|
|
|
|
def compress(filename, **kwargs):
|
|
data = open(filename, 'rb').read()
|
|
lz_data = lz.Compressed(data).output
|
|
open(filename + '.lz', 'wb').write(bytearray(lz_data))
|
|
|
|
def decompress(filename, **kwargs):
|
|
lz_data = open(filename, 'rb').read()
|
|
data = lz.Decompressed(lz_data).output
|
|
name, ext = os.path.splitext(filename)
|
|
open(name, 'wb').write(bytearray(data))
|
|
|
|
|
|
methods = {
|
|
'2bpp': to_2bpp,
|
|
'1bpp': to_1bpp,
|
|
'png': to_png,
|
|
'lz': compress,
|
|
'unlz': decompress,
|
|
}
|
|
|
|
def main(method_name, filenames=None):
|
|
if filenames is None: filenames = []
|
|
for filename in filenames:
|
|
args = filepath_rules(filename)
|
|
method = methods.get(method_name)
|
|
if method:
|
|
method(filename, **args)
|
|
|
|
def get_args():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument('method_name')
|
|
ap.add_argument('filenames', nargs='*')
|
|
args = ap.parse_args()
|
|
return args
|
|
|
|
if __name__ == '__main__':
|
|
main(**get_args().__dict__)
|