mirror of
https://gitlab.com/xCrystal/pokecrystal-board.git
synced 2024-09-09 09:51:34 -07:00
1123 lines
28 KiB
Python
1123 lines
28 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import os
|
|
import sys
|
|
import errno
|
|
import string
|
|
from copy import copy, deepcopy
|
|
import random
|
|
import argparse
|
|
from math import sqrt, floor, ceil
|
|
from datetime import datetime
|
|
|
|
from crystal import load_rom
|
|
|
|
|
|
|
|
rom = load_rom()
|
|
|
|
|
|
def mkdir_p(path):
|
|
try:
|
|
os.makedirs(path)
|
|
except OSError as exc: # Python >2.5
|
|
if exc.errno == errno.EEXIST:
|
|
pass
|
|
else: raise
|
|
|
|
|
|
def hex_dump(input, debug = True):
|
|
"""display hex dump in rows of 16 bytes"""
|
|
|
|
dump = ''
|
|
output = ''
|
|
stream = ''
|
|
address = 0x00
|
|
margin = 2 + len(hex(len(input))[2:])
|
|
|
|
# dump
|
|
for byte in input:
|
|
cool = hex(byte)[2:].zfill(2)
|
|
dump += cool + ' '
|
|
if debug: stream += cool
|
|
|
|
# convenient for testing quick edits in bgb
|
|
if debug: output += stream + '\n'
|
|
|
|
# get dump info
|
|
bytes_per_line = 16
|
|
chars_per_byte = 3 # '__ '
|
|
chars_per_line = bytes_per_line * chars_per_byte
|
|
num_lines = int(ceil(float(len(dump)) / float(chars_per_line)))
|
|
|
|
# top
|
|
# margin
|
|
for char in range(margin):
|
|
output += ' '
|
|
#
|
|
for byte in range(bytes_per_line):
|
|
output += hex(byte)[2:].zfill(2) + ' '
|
|
output = output[:-1] # last space
|
|
|
|
# print hex
|
|
for line in range(num_lines):
|
|
# address
|
|
output += '\n' + hex(address)[2:].zfill(margin - 2) + ': '
|
|
# contents
|
|
start = line * chars_per_line
|
|
end = chars_per_line + start - 1 # ignore last space
|
|
output += dump[start:end]
|
|
address += 0x10
|
|
|
|
return output
|
|
|
|
|
|
def get_tiles(image):
|
|
"""split a 2bpp image into 8x8 tiles"""
|
|
tiles = []
|
|
tile = []
|
|
bytes_per_tile = 16
|
|
|
|
cur_byte = 0
|
|
for byte in image:
|
|
# build tile
|
|
tile.append(byte)
|
|
cur_byte += 1
|
|
# done building?
|
|
if cur_byte >= bytes_per_tile:
|
|
# push completed tile
|
|
tiles.append(tile)
|
|
tile = []
|
|
cur_byte = 0
|
|
return tiles
|
|
|
|
|
|
def connect(tiles):
|
|
"""combine 8x8 tiles into a 2bpp image"""
|
|
out = []
|
|
for tile in tiles:
|
|
for byte in tile:
|
|
out.append(byte)
|
|
return out
|
|
|
|
|
|
def transpose(tiles):
|
|
"""transpose a tile arrangement along line y=x"""
|
|
|
|
# horizontal <-> vertical
|
|
# 00 01 02 03 04 05 00 06 0c 12 18 1e
|
|
# 06 07 08 09 0a 0b 01 07 0d 13 19 1f
|
|
# 0c 0d 0e 0f 10 11 <-> 02 08 0e 14 1a 20
|
|
# 12 13 14 15 16 17 <-> 03 09 0f 15 1b 21
|
|
# 18 19 1a 1b 1c 1d 04 0a 10 16 1c 22
|
|
# 1e 1f 20 21 22 23 05 0b 11 17 1d 23
|
|
# etc
|
|
|
|
flipped = []
|
|
t = 0 # which tile we're on
|
|
w = int(sqrt(len(tiles))) # assume square image
|
|
for tile in tiles:
|
|
flipped.append(tiles[t])
|
|
t += w
|
|
# end of row?
|
|
if t >= w*w:
|
|
# wrap around
|
|
t -= w*w
|
|
# next row
|
|
t += 1
|
|
return flipped
|
|
|
|
|
|
def to_file(filename, data):
|
|
file = open(filename, 'wb')
|
|
for byte in data:
|
|
file.write('%c' % byte)
|
|
file.close()
|
|
|
|
|
|
|
|
|
|
# basic rundown of crystal's compression scheme:
|
|
|
|
# a control command consists of
|
|
# the command (bits 5-7)
|
|
# and the count (bits 0-4)
|
|
# followed by additional params
|
|
|
|
lz_lit = 0
|
|
# print literal for [count] bytes
|
|
|
|
lz_iter = 1
|
|
# print one byte [count] times
|
|
|
|
lz_alt = 2
|
|
# print alternating bytes (2 params) for [count] bytes
|
|
|
|
lz_zeros = 3
|
|
# print 00 for [count] bytes
|
|
|
|
# repeater control commands have a signed parameter used to determine the start point
|
|
# wraparound is simulated
|
|
# positive values are added to the start address of the decompressed data
|
|
# and negative values are subtracted from the current position
|
|
|
|
lz_repeat = 4
|
|
# print [count] bytes from decompressed data
|
|
|
|
lz_flip = 5
|
|
# print [count] bytes from decompressed data in bit order 01234567
|
|
|
|
lz_reverse = 6
|
|
# print [count] bytes from decompressed data backwards
|
|
|
|
lz_hi = 7
|
|
# -used when the count exceeds 5 bits. uses a 10-bit count instead
|
|
# -bits 2-4 now contain the control code, bits 0-1 are bits 8-9 of the count
|
|
# -the following byte contains bits 0-7 of the count
|
|
|
|
lz_end = 0xff
|
|
# if 0xff is encountered the decompression ends
|
|
|
|
# since frontpics have animation tiles lumped onto them,
|
|
# sizes must be grabbed from base stats to know when to stop reading them
|
|
|
|
max_length = 1 << 10 # can't go higher than 10 bits
|
|
lowmax = 1 << 5 # standard 5-bit param
|
|
|
|
|
|
class Compressed:
|
|
"""compress 2bpp data"""
|
|
|
|
def __init__(self, image = None, mode = 'horiz', size = None):
|
|
|
|
assert image, 'need something to compress!'
|
|
self.image = image
|
|
self.pic = []
|
|
self.animtiles = []
|
|
|
|
# only transpose pic (animtiles were never transposed in decompression)
|
|
if size != None:
|
|
for byte in range((size*size)*16):
|
|
self.pic += image[byte]
|
|
for byte in range(((size*size)*16),len(image)):
|
|
self.animtiles += image[byte]
|
|
else:
|
|
self.pic = image
|
|
|
|
if mode == 'vert':
|
|
self.tiles = get_tiles(self.pic)
|
|
self.tiles = transpose(self.tiles)
|
|
self.pic = connect(self.tiles)
|
|
|
|
self.image = self.pic + self.animtiles
|
|
|
|
self.end = len(self.image)
|
|
|
|
self.byte = None
|
|
self.address = 0
|
|
|
|
self.stream = []
|
|
|
|
self.zeros = []
|
|
self.alts = []
|
|
self.iters = []
|
|
self.repeats = []
|
|
self.flips = []
|
|
self.reverses = []
|
|
self.literals = []
|
|
|
|
self.output = []
|
|
|
|
self.compress()
|
|
|
|
|
|
def compress(self):
|
|
"""incomplete, but outputs working compressed data"""
|
|
|
|
self.address = 0
|
|
|
|
# todo
|
|
#self.scanRepeats()
|
|
|
|
while ( self.address < self.end ):
|
|
|
|
#if (self.repeats):
|
|
# self.doRepeats()
|
|
|
|
#if (self.flips):
|
|
# self.doFlips()
|
|
|
|
#if (self.reverses):
|
|
# self.doReverses
|
|
|
|
if (self.checkWhitespace()):
|
|
self.doLiterals()
|
|
self.doWhitespace()
|
|
|
|
elif (self.checkIter()):
|
|
self.doLiterals()
|
|
self.doIter()
|
|
|
|
elif (self.checkAlts()):
|
|
self.doLiterals()
|
|
self.doAlts()
|
|
|
|
else: # doesn't fit any pattern -> literal
|
|
self.addLiteral()
|
|
self.next()
|
|
|
|
self.doStream()
|
|
|
|
# add any literals we've been sitting on
|
|
self.doLiterals()
|
|
|
|
# done
|
|
self.output.append(lz_end)
|
|
|
|
|
|
def getCurByte(self):
|
|
if self.address < self.end:
|
|
self.byte = ord(self.image[self.address])
|
|
else: self.byte = None
|
|
|
|
def next(self):
|
|
self.address += 1
|
|
self.getCurByte()
|
|
|
|
def addLiteral(self):
|
|
self.getCurByte()
|
|
self.literals.append(self.byte)
|
|
if len(self.literals) > max_length:
|
|
raise Exception, "literals exceeded max length and the compressor didn't catch it"
|
|
elif len(self.literals) == max_length:
|
|
self.doLiterals()
|
|
|
|
def doLiterals(self):
|
|
if len(self.literals) > lowmax:
|
|
self.output.append( (lz_hi << 5) | (lz_lit << 2) | ((len(self.literals) - 1) >> 8) )
|
|
self.output.append( (len(self.literals) - 1) & 0xff )
|
|
elif len(self.literals) > 0:
|
|
self.output.append( (lz_lit << 5) | (len(self.literals) - 1) )
|
|
for byte in self.literals:
|
|
self.output.append(byte)
|
|
self.literals = []
|
|
|
|
def doStream(self):
|
|
for byte in self.stream:
|
|
self.output.append(byte)
|
|
self.stream = []
|
|
|
|
|
|
def scanRepeats(self):
|
|
"""works, but doesn't do flipped/reversed streams yet
|
|
|
|
this takes up most of the compress time and only saves a few bytes
|
|
it might be more feasible to exclude it entirely"""
|
|
|
|
self.repeats = []
|
|
self.flips = []
|
|
self.reverses = []
|
|
|
|
# make a 5-letter word list of the sequence
|
|
letters = 5 # how many bytes it costs to use a repeat over a literal
|
|
# any shorter and it's not worth the trouble
|
|
num_words = len(self.image) - letters
|
|
words = []
|
|
for i in range(self.address,num_words):
|
|
word = []
|
|
for j in range(letters):
|
|
word.append( ord(self.image[i+j]) )
|
|
words.append((word, i))
|
|
|
|
zeros = []
|
|
for zero in range(letters):
|
|
zeros.append( 0 )
|
|
|
|
# check for matches
|
|
def get_matches():
|
|
# TODO:
|
|
# append to 3 different match lists instead of yielding to one
|
|
#
|
|
#flipped = []
|
|
#for byte in enumerate(this[0]):
|
|
# flipped.append( sum(1<<(7-i) for i in range(8) if (this[0][byte])>>i&1) )
|
|
#reversed = this[0][::-1]
|
|
#
|
|
for whereabout, this in enumerate(words):
|
|
for that in range(whereabout+1,len(words)):
|
|
if words[that][0] == this[0]:
|
|
if words[that][1] - this[1] >= letters:
|
|
# remove zeros
|
|
if this[0] != zeros:
|
|
yield [this[0], this[1], words[that][1]]
|
|
|
|
matches = list(get_matches())
|
|
|
|
# remove more zeros
|
|
buffer = []
|
|
for match in matches:
|
|
# count consecutive zeros in a word
|
|
num_zeros = 0
|
|
highest = 0
|
|
for j in range(letters):
|
|
if match[0][j] == 0:
|
|
num_zeros += 1
|
|
else:
|
|
if highest < num_zeros: highest = num_zeros
|
|
num_zeros = 0
|
|
if highest < 4:
|
|
# any more than 3 zeros in a row isn't worth it
|
|
# (and likely to already be accounted for)
|
|
buffer.append(match)
|
|
matches = buffer
|
|
|
|
# combine overlapping matches
|
|
buffer = []
|
|
for this, match in enumerate(matches):
|
|
if this < len(matches) - 1: # special case for the last match
|
|
if matches[this+1][1] <= (match[1] + len(match[0])): # check overlap
|
|
if match[1] + len(match[0]) < match[2]:
|
|
# next match now contains this match's bytes too
|
|
# this only appends the last byte (assumes overlaps are +1
|
|
match[0].append(matches[this+1][0][-1])
|
|
matches[this+1] = match
|
|
elif match[1] + len(match[0]) == match[2]:
|
|
# we've run into the thing we matched
|
|
buffer.append(match)
|
|
# else we've gone past it and we can ignore it
|
|
else: # no more overlaps
|
|
buffer.append(match)
|
|
else: # last match, so there's nothing to check
|
|
buffer.append(match)
|
|
matches = buffer
|
|
|
|
# remove alternating sequences
|
|
buffer = []
|
|
for match in matches:
|
|
for i in range(6 if letters > 6 else letters):
|
|
if match[0][i] != match[0][i&1]:
|
|
buffer.append(match)
|
|
break
|
|
matches = buffer
|
|
|
|
self.repeats = matches
|
|
|
|
|
|
def doRepeats(self):
|
|
"""doesn't output the right values yet"""
|
|
|
|
unusedrepeats = []
|
|
for repeat in self.repeats:
|
|
if self.address >= repeat[2]:
|
|
|
|
# how far in we are
|
|
length = (len(repeat[0]) - (self.address - repeat[2]))
|
|
|
|
# decide which side we're copying from
|
|
if (self.address - repeat[1]) <= 0x80:
|
|
self.doLiterals()
|
|
self.stream.append( (lz_repeat << 5) | length - 1 )
|
|
|
|
# wrong?
|
|
self.stream.append( (((self.address - repeat[1])^0xff)+1)&0xff )
|
|
|
|
else:
|
|
self.doLiterals()
|
|
self.stream.append( (lz_repeat << 5) | length - 1 )
|
|
|
|
# wrong?
|
|
self.stream.append(repeat[1]>>8)
|
|
self.stream.append(repeat[1]&0xff)
|
|
|
|
#print hex(self.address) + ': ' + hex(len(self.output)) + ' ' + hex(length)
|
|
self.address += length
|
|
|
|
else: unusedrepeats.append(repeat)
|
|
|
|
self.repeats = unusedrepeats
|
|
|
|
|
|
def checkWhitespace(self):
|
|
self.zeros = []
|
|
self.getCurByte()
|
|
original_address = self.address
|
|
|
|
if ( self.byte == 0 ):
|
|
while ( self.byte == 0 ) & ( len(self.zeros) <= max_length ):
|
|
self.zeros.append(self.byte)
|
|
self.next()
|
|
if len(self.zeros) > 1:
|
|
return True
|
|
self.address = original_address
|
|
return False
|
|
|
|
def doWhitespace(self):
|
|
if (len(self.zeros) + 1) >= lowmax:
|
|
self.stream.append( (lz_hi << 5) | (lz_zeros << 2) | ((len(self.zeros) - 1) >> 8) )
|
|
self.stream.append( (len(self.zeros) - 1) & 0xff )
|
|
elif len(self.zeros) > 1:
|
|
self.stream.append( lz_zeros << 5 | (len(self.zeros) - 1) )
|
|
else:
|
|
raise Exception, "checkWhitespace() should prevent this from happening"
|
|
|
|
|
|
def checkAlts(self):
|
|
self.alts = []
|
|
self.getCurByte()
|
|
original_address = self.address
|
|
num_alts = 0
|
|
|
|
# make sure we don't check for alts at the end of the file
|
|
if self.address+2 >= self.end: return False
|
|
|
|
self.alts.append(self.byte)
|
|
self.alts.append(ord(self.image[self.address+1]))
|
|
|
|
# are we onto smething?
|
|
if ( ord(self.image[self.address+2]) == self.alts[0] ):
|
|
cur_alt = 0
|
|
while (ord(self.image[(self.address)+1]) == self.alts[num_alts&1]) & (num_alts <= max_length):
|
|
num_alts += 1
|
|
self.next()
|
|
# include the last alternated byte
|
|
num_alts += 1
|
|
self.address = original_address
|
|
if num_alts > lowmax:
|
|
return True
|
|
elif num_alts > 2:
|
|
return True
|
|
return False
|
|
|
|
def doAlts(self):
|
|
original_address = self.address
|
|
self.getCurByte()
|
|
|
|
#self.alts = []
|
|
#num_alts = 0
|
|
|
|
#self.alts.append(self.byte)
|
|
#self.alts.append(ord(self.image[self.address+1]))
|
|
|
|
#i = 0
|
|
#while (ord(self.image[self.address+1]) == self.alts[i^1]) & (num_alts <= max_length):
|
|
# num_alts += 1
|
|
# i ^=1
|
|
# self.next()
|
|
## include the last alternated byte
|
|
#num_alts += 1
|
|
|
|
num_alts = len(self.iters) + 1
|
|
|
|
if num_alts > lowmax:
|
|
self.stream.append( (lz_hi << 5) | (lz_alt << 2) | ((num_alts - 1) >> 8) )
|
|
self.stream.append( num_alts & 0xff )
|
|
self.stream.append( self.alts[0] )
|
|
self.stream.append( self.alts[1] )
|
|
elif num_alts > 2:
|
|
self.stream.append( (lz_alt << 5) | (num_alts - 1) )
|
|
self.stream.append( self.alts[0] )
|
|
self.stream.append( self.alts[1] )
|
|
else:
|
|
raise Exception, "checkAlts() should prevent this from happening"
|
|
|
|
self.address = original_address
|
|
self.address += num_alts
|
|
|
|
|
|
def checkIter(self):
|
|
self.iters = []
|
|
self.getCurByte()
|
|
iter = self.byte
|
|
original_address = self.address
|
|
while (self.byte == iter) & (len(self.iters) < max_length):
|
|
self.iters.append(self.byte)
|
|
self.next()
|
|
self.address = original_address
|
|
if len(self.iters) > 3:
|
|
# 3 or fewer isn't worth the trouble and actually longer
|
|
# if part of a larger literal set
|
|
return True
|
|
|
|
return False
|
|
|
|
def doIter(self):
|
|
self.getCurByte()
|
|
iter = self.byte
|
|
original_address = self.address
|
|
|
|
self.iters = []
|
|
while (self.byte == iter) & (len(self.iters) < max_length):
|
|
self.iters.append(self.byte)
|
|
self.next()
|
|
|
|
if (len(self.iters) - 1) >= lowmax:
|
|
self.stream.append( (lz_hi << 5) | (lz_iter << 2) | ((len(self.iters)-1) >> 8) )
|
|
self.stream.append( (len(self.iters) - 1) & 0xff )
|
|
self.stream.append( iter )
|
|
elif len(self.iters) > 3:
|
|
# 3 or fewer isn't worth the trouble and actually longer
|
|
# if part of a larger literal set
|
|
self.stream.append( (lz_iter << 5) | (len(self.iters) - 1) )
|
|
self.stream.append( iter )
|
|
else:
|
|
self.address = original_address
|
|
raise Exception, "checkIter() should prevent this from happening"
|
|
|
|
|
|
|
|
|
|
|
|
class Decompressed:
|
|
"""parse compressed 2bpp data
|
|
|
|
parameters:
|
|
[compressed 2bpp data]
|
|
[tile arrangement] default: 'vert'
|
|
[size of pic] default: None
|
|
[start] (optional)
|
|
|
|
splits output into pic [size] and animation tiles if applicable
|
|
data can be fed in from rom if [start] is specified"""
|
|
|
|
def __init__(self, lz = None, mode = None, size = None, start = 0):
|
|
# todo: play nice with Compressed
|
|
|
|
assert lz, 'need something to compress!'
|
|
self.lz = lz
|
|
|
|
self.byte = None
|
|
self.address = 0
|
|
self.start = start
|
|
|
|
self.output = []
|
|
|
|
self.decompress()
|
|
|
|
debug = False
|
|
# print tuple containing start and end address
|
|
if debug: print '(' + hex(self.start) + ', ' + hex(self.start + self.address+1) + '),'
|
|
|
|
# only transpose pic
|
|
self.pic = []
|
|
self.animtiles = []
|
|
|
|
if size != None:
|
|
self.tiles = get_tiles(self.output)
|
|
self.pic = connect(self.tiles[:(size*size)])
|
|
self.animtiles = connect(self.tiles[(size*size):])
|
|
else: self.pic = self.output
|
|
|
|
if mode == 'vert':
|
|
self.tiles = get_tiles(self.pic)
|
|
self.tiles = transpose(self.tiles)
|
|
self.pic = connect(self.tiles)
|
|
|
|
|
|
def decompress(self):
|
|
"""replica of crystal's decompression"""
|
|
|
|
self.output = []
|
|
|
|
while True:
|
|
self.getCurByte()
|
|
|
|
if (self.byte == lz_end):
|
|
break
|
|
|
|
self.cmd = (self.byte & 0b11100000) >> 5
|
|
|
|
if self.cmd == lz_hi: # 10-bit param
|
|
self.cmd = (self.byte & 0b00011100) >> 2
|
|
self.length = (self.byte & 0b00000011) << 8
|
|
self.next()
|
|
self.length += self.byte + 1
|
|
else: # 5-bit param
|
|
self.length = (self.byte & 0b00011111) + 1
|
|
|
|
# literals
|
|
if self.cmd == lz_lit:
|
|
self.doLiteral()
|
|
elif self.cmd == lz_iter:
|
|
self.doIter()
|
|
elif self.cmd == lz_alt:
|
|
self.doAlt()
|
|
elif self.cmd == lz_zeros:
|
|
self.doZeros()
|
|
|
|
else: # repeaters
|
|
self.next()
|
|
if self.byte > 0x7f: # negative
|
|
self.displacement = self.byte & 0x7f
|
|
self.displacement = len(self.output) - self.displacement - 1
|
|
else: # positive
|
|
self.displacement = self.byte * 0x100
|
|
self.next()
|
|
self.displacement += self.byte
|
|
|
|
if self.cmd == lz_flip:
|
|
self.doFlip()
|
|
elif self.cmd == lz_reverse:
|
|
self.doReverse()
|
|
else: # lz_repeat
|
|
self.doRepeat()
|
|
|
|
self.address += 1
|
|
#self.next() # somewhat of a hack
|
|
|
|
|
|
def getCurByte(self):
|
|
self.byte = ord(self.lz[self.start+self.address])
|
|
|
|
def next(self):
|
|
self.address += 1
|
|
self.getCurByte()
|
|
|
|
def doLiteral(self):
|
|
# copy 2bpp data directly
|
|
for byte in range(self.length):
|
|
self.next()
|
|
self.output.append(self.byte)
|
|
|
|
def doIter(self):
|
|
# write one byte repeatedly
|
|
self.next()
|
|
for byte in range(self.length):
|
|
self.output.append(self.byte)
|
|
|
|
def doAlt(self):
|
|
# write alternating bytes
|
|
self.alts = []
|
|
self.next()
|
|
self.alts.append(self.byte)
|
|
self.next()
|
|
self.alts.append(self.byte)
|
|
|
|
for byte in range(self.length):
|
|
self.output.append(self.alts[byte&1])
|
|
|
|
def doZeros(self):
|
|
# write zeros
|
|
for byte in range(self.length):
|
|
self.output.append(0x00)
|
|
|
|
def doFlip(self):
|
|
# repeat flipped bytes from 2bpp output
|
|
# eg 11100100 -> 00100111
|
|
# quat 3 2 1 0 -> 0 2 1 3
|
|
for byte in range(self.length):
|
|
flipped = sum(1<<(7-i) for i in range(8) if self.output[self.displacement+byte]>>i&1)
|
|
self.output.append(flipped)
|
|
|
|
def doReverse(self):
|
|
# repeat reversed bytes from 2bpp output
|
|
for byte in range(self.length):
|
|
self.output.append(self.output[self.displacement-byte])
|
|
|
|
def doRepeat(self):
|
|
# repeat bytes from 2bpp output
|
|
for byte in range(self.length):
|
|
self.output.append(self.output[self.displacement+byte])
|
|
|
|
|
|
|
|
sizes = [
|
|
5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 5, 7, 5, 5, 7, 5,
|
|
6, 7, 5, 6, 5, 7, 5, 7, 5, 7, 5, 6, 5, 6, 7, 5,
|
|
6, 7, 5, 6, 6, 7, 5, 6, 5, 7, 5, 6, 7, 5, 7, 5,
|
|
7, 5, 7, 5, 7, 5, 7, 5, 7, 5, 7, 5, 6, 7, 5, 6,
|
|
7, 5, 7, 7, 5, 6, 7, 5, 6, 5, 6, 6, 6, 7, 5, 7,
|
|
5, 6, 6, 5, 7, 6, 7, 5, 7, 5, 7, 7, 6, 6, 7, 6,
|
|
7, 5, 7, 5, 5, 7, 7, 5, 6, 7, 6, 7, 6, 7, 7, 7,
|
|
6, 6, 7, 5, 6, 6, 7, 6, 6, 6, 7, 6, 6, 6, 7, 7,
|
|
6, 7, 7, 5, 5, 6, 6, 6, 6, 5, 6, 5, 6, 7, 7, 7,
|
|
7, 7, 5, 6, 7, 7, 5, 5, 6, 7, 5, 6, 7, 5, 6, 7,
|
|
6, 6, 5, 7, 6, 6, 5, 7, 7, 6, 6, 5, 5, 5, 5, 7,
|
|
5, 6, 5, 6, 7, 7, 5, 7, 6, 7, 5, 6, 7, 5, 5, 6,
|
|
6, 5, 6, 6, 6, 6, 7, 6, 5, 6, 7, 5, 7, 6, 6, 7,
|
|
6, 6, 5, 7, 5, 6, 6, 5, 7, 5, 6, 5, 6, 6, 5, 6,
|
|
6, 7, 7, 6, 7, 7, 5, 7, 6, 7, 7, 5, 7, 5, 6, 6,
|
|
6, 7, 7, 7, 7, 5, 6, 7, 7, 7, 5,
|
|
]
|
|
|
|
def make_sizes():
|
|
"""front pics have specified sizes"""
|
|
top = 251
|
|
base_stats = 0x51424
|
|
# print monster sizes
|
|
address = base_stats + 0x11
|
|
|
|
output = ''
|
|
|
|
for id in range(top):
|
|
size = (ord(rom[address])) & 0x0f
|
|
if id % 16 == 0: output += '\n\t'
|
|
output += str(size) + ', '
|
|
address += 0x20
|
|
|
|
print output
|
|
|
|
|
|
|
|
fxs = 0xcfcf6
|
|
num_fx = 40
|
|
|
|
def decompress_fx_by_id(id):
|
|
address = fxs + id*4 # len_fxptr
|
|
# get size
|
|
num_tiles = ord(rom[address]) # # tiles
|
|
# get pointer
|
|
bank = ord(rom[address+1])
|
|
address = (ord(rom[address+3]) << 8) + ord(rom[address+2])
|
|
address = (bank * 0x4000) + (address & 0x3fff)
|
|
# decompress
|
|
fx = Decompressed(rom, 'horiz', num_tiles, address)
|
|
return fx
|
|
|
|
def decompress_fx():
|
|
for id in range(num_fx):
|
|
fx = decompress_fx_by_id(id)
|
|
filename = '../gfx/fx/' + str(id).zfill(3) + '.2bpp' # ../gfx/fx/039.2bpp
|
|
to_file(filename, fx.pic)
|
|
|
|
|
|
num_pics = 2
|
|
front = 0
|
|
back = 1
|
|
|
|
monsters = 0x120000
|
|
num_monsters = 251
|
|
|
|
unowns = 0x124000
|
|
num_unowns = 26
|
|
unown_dex = 201
|
|
|
|
def decompress_monster_by_id(id = 0, type = front):
|
|
# no unowns here
|
|
if id + 1 == unown_dex: return None
|
|
# get size
|
|
if type == front:
|
|
size = sizes[id]
|
|
else: size = None
|
|
# get pointer
|
|
address = monsters + (id*2 + type)*3 # bank, address
|
|
bank = ord(rom[address]) + 0x36 # crystal
|
|
address = (ord(rom[address+2]) << 8) + ord(rom[address+1])
|
|
address = (bank * 0x4000) + (address & 0x3fff)
|
|
# decompress
|
|
monster = Decompressed(rom, 'vert', size, address)
|
|
return monster
|
|
|
|
def decompress_monsters(type = front):
|
|
for id in range(num_monsters):
|
|
# decompress
|
|
monster = decompress_monster_by_id(id, type)
|
|
if monster != None: # no unowns here
|
|
if not type: # front
|
|
filename = 'front.2bpp'
|
|
folder = '../gfx/pics/' + str(id+1).zfill(3) + '/'
|
|
to_file(folder+filename, monster.pic)
|
|
filename = 'tiles.2bpp'
|
|
folder = '../gfx/pics/' + str(id+1).zfill(3) + '/'
|
|
to_file(folder+filename, monster.animtiles)
|
|
else: # back
|
|
filename = 'back.2bpp'
|
|
folder = '../gfx/pics/' + str(id+1).zfill(3) + '/'
|
|
to_file(folder+filename, monster.pic)
|
|
|
|
|
|
def decompress_unown_by_id(letter, type = front):
|
|
# get size
|
|
if type == front:
|
|
size = sizes[unown_dex-1]
|
|
else: size = None
|
|
# get pointer
|
|
address = unowns + (letter*2 + type)*3 # bank, address
|
|
bank = ord(rom[address]) + 0x36 # crystal
|
|
address = (ord(rom[address+2]) << 8) + ord(rom[address+1])
|
|
address = (bank * 0x4000) + (address & 0x3fff)
|
|
# decompress
|
|
unown = Decompressed(rom, 'vert', size, address)
|
|
return unown
|
|
|
|
def decompress_unowns(type = front):
|
|
for letter in range(num_unowns):
|
|
# decompress
|
|
unown = decompress_unown_by_id(letter, type)
|
|
|
|
if not type: # front
|
|
filename = 'front.2bpp'
|
|
folder = '../gfx/pics/' + str(unown_dex).zfill(3) + chr(ord('a') + letter) + '/'
|
|
to_file(folder+filename, unown.pic)
|
|
filename = 'tiles.2bpp'
|
|
folder = '../gfx/anim/'
|
|
to_file(folder+filename, unown.animtiles)
|
|
else: # back
|
|
filename = 'back.2bpp'
|
|
folder = '../gfx/pics/' + str(unown_dex).zfill(3) + chr(ord('a') + letter) + '/'
|
|
to_file(folder+filename, unown.pic)
|
|
|
|
|
|
trainers = 0x128000
|
|
num_trainers = 67
|
|
|
|
def decompress_trainer_by_id(id):
|
|
# get pointer
|
|
address = trainers + id*3 # bank, address
|
|
bank = ord(rom[address]) + 0x36 # crystal
|
|
address = (ord(rom[address+2]) << 8) + ord(rom[address+1])
|
|
address = (bank * 0x4000) + (address & 0x3fff)
|
|
# decompress
|
|
trainer = Decompressed(rom, 'vert', None, address)
|
|
return trainer
|
|
|
|
def decompress_trainers():
|
|
for id in range(num_trainers):
|
|
# decompress
|
|
trainer = decompress_trainer_by_id(id)
|
|
filename = '../gfx/trainers/' + str(id).zfill(3) + '.2bpp' # ../gfx/trainers/066.2bpp
|
|
to_file(filename, trainer.pic)
|
|
|
|
|
|
# in order of use (sans repeats)
|
|
intro_gfx = [
|
|
('logo', 0x109407),
|
|
('001', 0xE641D), # tilemap
|
|
('unowns', 0xE5F5D),
|
|
('pulse', 0xE634D),
|
|
('002', 0xE63DD), # tilemap
|
|
('003', 0xE5ECD), # tilemap
|
|
('background', 0xE5C7D),
|
|
('004', 0xE5E6D), # tilemap
|
|
('005', 0xE647D), # tilemap
|
|
('006', 0xE642D), # tilemap
|
|
('pichu_wooper', 0xE592D),
|
|
('suicune_run', 0xE555D),
|
|
('007', 0xE655D), # tilemap
|
|
('008', 0xE649D), # tilemap
|
|
('009', 0xE76AD), # tilemap
|
|
('suicune_jump', 0xE6DED),
|
|
('unown_back', 0xE785D),
|
|
('010', 0xE764D), # tilemap
|
|
('011', 0xE6D0D), # tilemap
|
|
('suicune_close', 0xE681D),
|
|
('012', 0xE6C3D), # tilemap
|
|
('013', 0xE778D), # tilemap
|
|
('suicune_back', 0xE72AD),
|
|
('014', 0xE76BD), # tilemap
|
|
('015', 0xE676D), # tilemap
|
|
('crystal_unowns', 0xE662D),
|
|
('017', 0xE672D), # tilemap
|
|
]
|
|
|
|
def decompress_intro():
|
|
for name, address in intro_gfx:
|
|
filename = '../gfx/intro/' + name + '.2bpp'
|
|
gfx = Decompressed( rom, 'horiz', None, address )
|
|
to_file(filename, gfx.output)
|
|
|
|
|
|
title_gfx = [
|
|
('suicune', 0x10EF46),
|
|
('logo', 0x10F326),
|
|
('crystal', 0x10FCEE),
|
|
]
|
|
|
|
def decompress_title():
|
|
for name, address in title_gfx:
|
|
filename = '../gfx/title/' + name + '.2bpp'
|
|
gfx = Decompressed( rom, 'horiz', None, address )
|
|
to_file(filename, gfx.output)
|
|
|
|
def decompress_tilesets():
|
|
tileset_headers = 0x4d596
|
|
len_tileset = 15
|
|
num_tilesets = 0x25
|
|
for tileset in range(num_tilesets):
|
|
ptr = tileset*len_tileset + tileset_headers
|
|
address = (ord(rom[ptr])*0x4000) + (((ord(rom[ptr+1]))+ord(rom[ptr+2])*0x100)&0x3fff)
|
|
tiles = Decompressed( rom, 'horiz', None, address )
|
|
filename = '../gfx/tilesets/'+str(tileset).zfill(2)+'.2bpp'
|
|
to_file( filename, tiles.output )
|
|
#print '(' + hex(address) + ', '+ hex(address+tiles.address+1) + '),'
|
|
|
|
misc = [
|
|
('player', 0x2BA1A, 'vert'),
|
|
('dude', 0x2BBAA, 'vert'),
|
|
('town_map', 0xF8BA0, 'horiz'),
|
|
('pokegear', 0x1DE2E4, 'horiz'),
|
|
('pokegear_sprites', 0x914DD, 'horiz'),
|
|
]
|
|
def decompress_misc():
|
|
for name, address, mode in misc:
|
|
filename = '../gfx/misc/' + name + '.2bpp'
|
|
gfx = Decompressed( rom, mode, None, address )
|
|
to_file(filename, gfx.output)
|
|
|
|
def decompress_all(debug = False):
|
|
"""decompress all known compressed data in baserom"""
|
|
|
|
#mkdir_p('../gfx/')
|
|
#mkdir_p('../gfx/frontpics/')
|
|
#mkdir_p('../gfx/anim/')
|
|
#mkdir_p('../gfx/backpics/')
|
|
#mkdir_p('../gfx/trainers/')
|
|
#mkdir_p('../gfx/fx/')
|
|
#mkdir_p('../gfx/intro/')
|
|
#mkdir_p('../gfx/title/')
|
|
#mkdir_p('../gfx/tilesets/')
|
|
#mkdir_p('../gfx/misc/')
|
|
|
|
if debug: print 'fronts'
|
|
decompress_monsters(front)
|
|
if debug: print 'backs'
|
|
decompress_monsters(back)
|
|
if debug: print 'unown fronts'
|
|
decompress_unowns(front)
|
|
if debug: print 'unown backs'
|
|
decompress_unowns(back)
|
|
|
|
if debug: print 'trainers'
|
|
decompress_trainers()
|
|
|
|
if debug: print 'fx'
|
|
decompress_fx()
|
|
|
|
if debug: print 'intro'
|
|
decompress_intro()
|
|
|
|
if debug: print 'title'
|
|
decompress_title()
|
|
|
|
if debug: print 'tilesets'
|
|
decompress_tilesets()
|
|
|
|
if debug: print 'misc'
|
|
decompress_misc()
|
|
|
|
return
|
|
|
|
|
|
def decompress_from_address(address, mode='horiz', filename = 'de.2bpp', size = None):
|
|
"""write decompressed data from an address to a 2bpp file"""
|
|
image = Decompressed(rom, mode, size, address)
|
|
to_file(filename, image.pic)
|
|
|
|
|
|
def decompress_file(filein, fileout, mode = 'horiz', size = None):
|
|
f = open(filein, 'rb')
|
|
image = f.read()
|
|
f.close()
|
|
|
|
de = Decompressed(image, mode, size)
|
|
|
|
to_file(fileout, de.pic)
|
|
|
|
|
|
def compress_file(filein, fileout, mode = 'horiz'):
|
|
f = open(filein, 'rb')
|
|
image = f.read()
|
|
f.close()
|
|
|
|
lz = Compressed(image, mode)
|
|
|
|
to_file(fileout, lz.output)
|
|
|
|
|
|
|
|
|
|
def compress_monster_frontpic(id, fileout):
|
|
mode = 'vert'
|
|
|
|
fpic = '../gfx/pics/' + str(id).zfill(3) + '/front.2bpp'
|
|
fanim = '../gfx/pics/' + str(id).zfill(3) + '/tiles.2bpp'
|
|
|
|
pic = open(fpic, 'rb').read()
|
|
anim = open(fanim, 'rb').read()
|
|
image = pic + anim
|
|
|
|
lz = Compressed(image, mode, 5)
|
|
|
|
out = '../gfx/pics/' + str(id).zfill(3) + '/front.lz'
|
|
|
|
to_file(out, lz.output)
|
|
|
|
|
|
|
|
def get_uncompressed_gfx(start, num_tiles, filename):
|
|
"""grab tiles directly from rom and write to file"""
|
|
bytes_per_tile = 0x10
|
|
length = num_tiles*bytes_per_tile
|
|
end = start + length
|
|
rom = load_rom()
|
|
image = []
|
|
for address in range(start,end):
|
|
image.append(ord(rom[address]))
|
|
to_file(filename, image)
|
|
|
|
|
|
|
|
def hex_to_rgb(word):
|
|
red = word & 0b11111
|
|
word >>= 5
|
|
green = word & 0b11111
|
|
word >>= 5
|
|
blue = word & 0b11111
|
|
return (red, green, blue)
|
|
|
|
def grab_palettes(address, length = 0x80):
|
|
output = ''
|
|
for word in range(length/2):
|
|
color = ord(rom[address+1])*0x100 + ord(rom[address])
|
|
address += 2
|
|
color = hex_to_rgb(color)
|
|
red = str(color[0]).zfill(2)
|
|
green = str(color[1]).zfill(2)
|
|
blue = str(color[2]).zfill(2)
|
|
output += '\tRGB '+red+', '+green+', '+blue
|
|
output += '\n'
|
|
return output
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('cmd', nargs='?', metavar='cmd', type=str)
|
|
parser.add_argument('arg1', nargs='?', metavar='arg1', type=str)
|
|
parser.add_argument('arg2', nargs='?', metavar='arg2', type=str)
|
|
parser.add_argument('arg3', nargs='?', metavar='arg3', type=str)
|
|
args = parser.parse_args()
|
|
|
|
debug = True
|
|
|
|
if args.cmd == 'de':
|
|
# python gfx.py de [addr] [fileout] [mode]
|
|
addr = int(args.arg1,16)
|
|
fileout = args.arg2
|
|
mode = args.arg3
|
|
decompress_from_address(addr, fileout, mode)
|
|
if debug: print 'decompressed to ' + args.arg2 + ' from ' + hex(int(args.arg1,16)) + '!'
|
|
|
|
elif args.cmd == 'lz':
|
|
# python gfx.py lz [filein] [fileout] [mode]
|
|
filein = args.arg1
|
|
fileout = args.arg2
|
|
mode = args.arg3
|
|
compress_file(filein, fileout, mode)
|
|
if debug: print 'compressed ' + filein + ' to ' + fileout + '!'
|
|
|
|
elif args.cmd == 'lzf':
|
|
# python gfx.py lzf [id] [fileout]
|
|
compress_monster_frontpic(int(args.arg1), args.arg2)
|
|
|
|
elif args.cmd == 'un':
|
|
# python gfx.py un [address] [num_tiles] [filename]
|
|
get_uncompressed_gfx(int(args.arg1,16), int(args.arg2), args.arg3)
|
|
|
|
elif args.cmd == 'pal':
|
|
# python gfx.py pal [address] [length]
|
|
print grab_palettes(int(args.arg1,16), int(args.arg2))
|
|
|
|
#else:
|
|
## python gfx.py
|
|
#decompress_all()
|
|
#if debug: print 'decompressed known gfx to ../gfx/!'
|