ref: aee96a5cf75d5731cb8cb8eb97ad16cb44a7b53e
parent: b710b8721eb12db39ba0413fdaede654999a426a
parent: 72fbe86c7aee557282322666c1c3a25fbe964b0b
author: Bryan Bishop <[email protected]>
date: Tue Jun 25 19:47:22 EDT 2013
Merge branch 'cogitokat/master' into master. fixes #152
--- a/extras/comparator.py
+++ b/extras/comparator.py
@@ -1,6 +1,6 @@
# -*- coding: utf-8 -*-
"""
-Finds shared functions between red/crystal.
+Find shared functions between red/crystal.
"""
from crystal import (
@@ -18,13 +18,13 @@
def load_rom(path):
"""
- Loads a ROM file into an abbreviated RomStr object.
+ Load a ROM file into an abbreviated RomStr object.
"""
return direct_load_rom(filename=path)
def load_asm(path):
"""
- Loads source ASM into an abbreviated AsmList object.
+ Load source ASM into an abbreviated AsmList object.
"""
return direct_load_asm(filename=path)
@@ -63,7 +63,8 @@
class BinaryBlob(object):
"""
- Stores a label, line number, and addresses of a function from Pokémon Red.
+ Store a label, line number, and addresses of a function from Pokémon Red.
+
These details can be used to determine whether or not the function was
copied into Pokémon Crystal.
"""
@@ -128,7 +129,7 @@
def parse_from_red(self):
"""
- Reads bytes from Pokémon Red and stores them.
+ Read bytes from Pokémon Red and stores them.
"""
self.bytes = redrom[self.start_address : self.end_address + 1]
@@ -146,7 +147,7 @@
def find_in_crystal(self):
"""
- Checks whether or not the bytes appear in Pokémon Crystal.
+ Check whether or not the bytes appear in Pokémon Crystal.
"""
finditer = findall_iter(self.bytes, cryrom)
@@ -160,7 +161,7 @@
def find_by_first_bytes(self):
"""
- Finds this blob in Crystal based on the first n bytes.
+ Find this blob in Crystal based on the first n bytes.
"""
# how many bytes to match
@@ -194,7 +195,7 @@
def scan_red_asm(bank_stop=3, debug=True):
"""
- Scans the ASM from Pokémon Red. Finds labels and objects. Does things.
+ Scan the ASM from Pokémon Red. Finds labels and objects. Does things.
Uses get_label_from_line and get_address_from_line_comment.
"""
--- a/extras/gbz80disasm.py
+++ b/extras/gbz80disasm.py
@@ -13,6 +13,11 @@
json.read = json.loads
def load_rom(filename="../baserom.gbc"):
+ """
+ Load the specified rom.
+
+ If no rom is given, load "../baserom.gbc".
+ """
global rom
rom = bytearray(open(filename,'rb').read())
return rom
@@ -557,6 +562,11 @@
all_labels = {}def load_labels(filename="labels.json"):
+ """
+ Load labels from specified file.
+
+ If no filename is given, loads 'labels.json'.
+ """
global all_labels
# don't re-load labels each time
@@ -588,22 +598,29 @@
return None
def asm_label(address):
- # why using a random value when you can use the address?
+ """
+ Return the ASM label using the address.
+ """
+
return ".ASM_" + hex(address)[2:]
-def output_bank_opcodes(original_offset, max_byte_count=0x4000, include_last_address=True, stop_at=[], debug = False):
- #fs = current_address
- #b = bank_byte
- #in = input_data -- rom
- #bank_size = byte_count
- #i = offset
- #ad = end_address
- #a, oa = current_byte_number
+def output_bank_opcodes(original_offset, max_byte_count=0x4000, include_last_address=True, stop_at=[], debug=False):
+ """
+ Output bank opcodes.
- # stop_at can be used to supply a list of addresses to not disassemble
- # over. This is useful if you know in advance that there are a lot of
- # fall-throughs.
+ fs = current_address
+ b = bank_byte
+ in = input_data -- rom
+ bank_size = byte_count
+ i = offset
+ ad = end_address
+ a, oa = current_byte_number
+ stop_at can be used to supply a list of addresses to not disassemble
+ over. This is useful if you know in advance that there are a lot of
+ fall-throughs.
+ """
+
load_labels()
load_rom()
@@ -851,8 +868,9 @@
def has_outstanding_labels(byte_labels):
"""
- If a label is used once in the asm output, then that means it has to be
- called or specified later.
+ Check whether a label is used once in the asm output.
+
+ If so, then that means it has to be called or specified later.
"""
for label_line in byte_labels.keys():
real_line = byte_labels[label_line]
--- a/extras/gfx.py
+++ b/extras/gfx.py
@@ -12,125 +12,137 @@
if __name__ != "__main__":
- rom = 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
+ """
+ Make a directory at a given 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"""
+ """
+ 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'
- dump = ''
- output = ''
- stream = ''
- address = 0x00
- margin = 2 + len(hex(len(input))[2:])
+ # 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 += ' '
- # dump
- for byte in input:
- cool = hex(byte)[2:].zfill(2)
- dump += cool + ' '
- if debug: stream += cool
+ #
+ 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
- # 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
+ """
+ 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
- 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
+ """
+ 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"""
+ """
+ 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
- # 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()
+ file = open(filename, 'wb')
+ for byte in data:
+ file.write('%c' % byte)+ file.close()
@@ -184,578 +196,605 @@
class Compressed:
- """compress 2bpp data"""
-
- def __init__(self, image = None, mode = 'horiz', size = None):
+
+ """
+ Compress 2bpp data.
+ """
+
+ def __init__(self, image = None, mode = 'horiz', size = None):
+ assert image, 'need something to compress!'
+ image = list(image)
+ 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
- assert image, 'need something to compress!'
- image = list(image)
- self.image = image
- self.pic = []
- self.animtiles = []
+ 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
- # 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
+ self.end = len(self.image)
- if mode == 'vert':
- self.tiles = get_tiles(self.pic)
- self.tiles = transpose(self.tiles)
- self.pic = connect(self.tiles)
+ self.byte = None
+ self.address = 0
- self.image = self.pic + self.animtiles
+ self.stream = []
- self.end = len(self.image)
+ self.zeros = []
+ self.alts = []
+ self.iters = []
+ self.repeats = []
+ self.flips = []
+ self.reverses = []
+ self.literals = []
- self.byte = None
- self.address = 0
+ self.output = []
- self.stream = []
+ self.compress()
- self.zeros = []
- self.alts = []
- self.iters = []
- self.repeats = []
- self.flips = []
- self.reverses = []
- self.literals = []
- self.output = []
+ def compress(self):
+ """
+ Incomplete, but outputs working compressed data.
+ """
- self.compress()
+ self.address = 0
+ # todo
+ #self.scanRepeats()
- def compress(self):
- """incomplete, but outputs working compressed data"""
+ while ( self.address < self.end ):
- self.address = 0
+ #if (self.repeats):
+ # self.doRepeats()
- # todo
- #self.scanRepeats()
+ #if (self.flips):
+ # self.doFlips()
- while ( self.address < self.end ):
+ #if (self.reverses):
+ # self.doReverses
- #if (self.repeats):
- # self.doRepeats()
+ if (self.checkWhitespace()):
+ self.doLiterals()
+ self.doWhitespace()
- #if (self.flips):
- # self.doFlips()
+ elif (self.checkIter()):
+ self.doLiterals()
+ self.doIter()
- #if (self.reverses):
- # self.doReverses
+ elif (self.checkAlts()):
+ self.doLiterals()
+ self.doAlts()
- if (self.checkWhitespace()):
- self.doLiterals()
- self.doWhitespace()
+ else: # doesn't fit any pattern -> literal
+ self.addLiteral()
+ self.next()
- elif (self.checkIter()):
- self.doLiterals()
- self.doIter()
+ self.doStream()
- elif (self.checkAlts()):
- self.doLiterals()
- self.doAlts()
+ # add any literals we've been sitting on
+ self.doLiterals()
- else: # doesn't fit any pattern -> literal
- self.addLiteral()
- self.next()
+ # done
+ self.output.append(lz_end)
- self.doStream()
- # add any literals we've been sitting on
- self.doLiterals()
+ def getCurByte(self):
+ if self.address < self.end:
+ self.byte = ord(self.image[self.address])
+ else: self.byte = None
- # done
- self.output.append(lz_end)
+ 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 getCurByte(self):
- if self.address < self.end:
- self.byte = ord(self.image[self.address])
- else: self.byte = None
+ 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 next(self):
- self.address += 1
- self.getCurByte()
+ def doStream(self):
+ for byte in self.stream:
+ self.output.append(byte)
+ self.stream = []
- 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
+ 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 )
- this takes up most of the compress time and only saves a few bytes
- it might be more feasible to exclude it entirely"""
+ # 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]]
- self.repeats = []
- self.flips = []
- self.reverses = []
+ matches = list(get_matches())
- # 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))
+ # 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
- zeros = []
- for zero in range(letters):
- zeros.append( 0 )
+ # 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
- # 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]]
+ # 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
- matches = list(get_matches())
+ self.repeats = 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
+ def doRepeats(self):
+ """doesn't output the right values yet"""
+
+ unusedrepeats = []
+ for repeat in self.repeats:
+ if self.address >= repeat[2]:
- # 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
+ # how far in we are
+ length = (len(repeat[0]) - (self.address - repeat[2]))
- self.repeats = matches
+ # 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 )
- def doRepeats(self):
- """doesn't output the right values yet"""
+ else:
+ self.doLiterals()
+ self.stream.append( (lz_repeat << 5) | length - 1 )
- unusedrepeats = []
- for repeat in self.repeats:
- if self.address >= repeat[2]:
+ # wrong?
+ self.stream.append(repeat[1]>>8)
+ self.stream.append(repeat[1]&0xff)
- # how far in we are
- length = (len(repeat[0]) - (self.address - repeat[2]))
+ #print hex(self.address) + ': ' + hex(len(self.output)) + ' ' + hex(length)
+ self.address += length
- # decide which side we're copying from
- if (self.address - repeat[1]) <= 0x80:
- self.doLiterals()
- self.stream.append( (lz_repeat << 5) | length - 1 )
+ else: unusedrepeats.append(repeat)
- # wrong?
- self.stream.append( (((self.address - repeat[1])^0xff)+1)&0xff )
+ self.repeats = unusedrepeats
- else:
- self.doLiterals()
- self.stream.append( (lz_repeat << 5) | length - 1 )
- # wrong?
- self.stream.append(repeat[1]>>8)
- self.stream.append(repeat[1]&0xff)
+ def checkWhitespace(self):
+ self.zeros = []
+ self.getCurByte()
+ original_address = self.address
- #print hex(self.address) + ': ' + hex(len(self.output)) + ' ' + hex(length)
- self.address += length
+ 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
- else: unusedrepeats.append(repeat)
+ 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"
- self.repeats = unusedrepeats
+ def checkAlts(self):
+ self.alts = []
+ self.getCurByte()
+ original_address = self.address
+ num_alts = 0
- def checkWhitespace(self):
- self.zeros = []
- self.getCurByte()
- original_address = self.address
+ # make sure we don't check for alts at the end of the file
+ if self.address+3 >= self.end: return False
- 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
+ self.alts.append(self.byte)
+ self.alts.append(ord(self.image[self.address+1]))
- 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"
+ # 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()
- def checkAlts(self):
- self.alts = []
- self.getCurByte()
- original_address = self.address
- num_alts = 0
+ #self.alts = []
+ #num_alts = 0
- # make sure we don't check for alts at the end of the file
- if self.address+3 >= self.end: return False
+ #self.alts.append(self.byte)
+ #self.alts.append(ord(self.image[self.address+1]))
- 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
- # 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
+ num_alts = len(self.iters) + 1
- def doAlts(self):
- original_address = self.address
- self.getCurByte()
+ 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.alts = []
- #num_alts = 0
+ self.address = original_address
+ self.address += num_alts
- #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
+ 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
- num_alts = len(self.iters) + 1
+ return False
- 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"
+ def doIter(self):
+ self.getCurByte()
+ iter = self.byte
+ original_address = self.address
- self.address = original_address
- self.address += num_alts
+ 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"
- 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
+ """
+ Parse compressed 2bpp data.
- parameters:
- [compressed 2bpp data]
- [tile arrangement] default: 'vert'
- [size of pic] default: None
- [start] (optional)
+ 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"""
+ 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
+ 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
+ assert lz, 'need something to compress!'
+ self.lz = lz
- self.byte = None
- self.address = 0
- self.start = start
+ self.byte = None
+ self.address = 0
+ self.start = start
- self.output = []
+ self.output = []
- self.decompress()
+ self.decompress()
- debug = False
- # print tuple containing start and end address
- if debug: print '(' + hex(self.start) + ', ' + hex(self.start + self.address+1) + '),'+ 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 = []
+ # 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 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)
+ if mode == 'vert':
+ self.tiles = get_tiles(self.pic)
+ self.tiles = transpose(self.tiles)
+ self.pic = connect(self.tiles)
- self.output = self.pic + self.animtiles
+ self.output = self.pic + self.animtiles
- def decompress(self):
- """replica of crystal's decompression"""
+ def decompress(self):
+ """
+ Replica of crystal's decompression.
+ """
- self.output = []
+ self.output = []
- while True:
- self.getCurByte()
+ while True:
+ self.getCurByte()
- if (self.byte == lz_end):
- break
+ if (self.byte == lz_end):
+ break
- self.cmd = (self.byte & 0b11100000) >> 5
+ 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
+ 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()
+ # 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
+ 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()
+ 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
+ self.address += 1
+ #self.next() # somewhat of a hack
- def getCurByte(self):
- self.byte = ord(self.lz[self.start+self.address])
+ def getCurByte(self):
+ self.byte = ord(self.lz[self.start+self.address])
- def next(self):
- self.address += 1
- self.getCurByte()
+ 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 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 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)
+ 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])
+ 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 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 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 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])
+ 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,
+ 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
+ """
+ Front pics have specified sizes.
+ """
+ top = 251
+ base_stats = 0x51424
+ # print monster sizes
+ address = base_stats + 0x11
- output = ''
+ output = ''
- for id in range(top):
- size = (ord(rom[address])) & 0x0f
- if id % 16 == 0: output += '\n\t'
- output += str(size) + ', '
- address += 0x20
+ for id in range(top):
+ size = (ord(rom[address])) & 0x0f
+ if id % 16 == 0: output += '\n\t'
+ output += str(size) + ', '
+ address += 0x20
- print output
+ print output
@@ -763,22 +802,22 @@
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
+ 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)
+ 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
@@ -793,69 +832,69 @@
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
+ # 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)
+ 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
+ # 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)
+ 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)
+ 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
@@ -862,210 +901,216 @@
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
+ # 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)
+ 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+ ('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)
+ 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),+ ('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)
+ 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) + '),'+ 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'),+ ('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)
+ 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"""
+ """
+ Decompress all known compressed data in baserom.
+ """
- 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 '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 'trainers'
+ decompress_trainers()
- if debug: print 'fx'
- decompress_fx()
+ if debug: print 'fx'
+ decompress_fx()
- if debug: print 'intro'
- decompress_intro()
+ if debug: print 'intro'
+ decompress_intro()
- if debug: print 'title'
- decompress_title()
+ if debug: print 'title'
+ decompress_title()
- if debug: print 'tilesets'
- decompress_tilesets()
+ if debug: print 'tilesets'
+ decompress_tilesets()
- if debug: print 'misc'
- decompress_misc()
+ if debug: print 'misc'
+ decompress_misc()
- return
+ 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)
+ """
+ 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()
+ f = open(filein, 'rb')
+ image = f.read()
+ f.close()
- de = Decompressed(image, mode, size)
+ de = Decompressed(image, mode, size)
- to_file(fileout, de.pic)
+ to_file(fileout, de.pic)
def compress_file(filein, fileout, mode = 'horiz'):
- f = open(filein, 'rb')
- image = f.read()
- f.close()
+ f = open(filein, 'rb')
+ image = f.read()
+ f.close()
- lz = Compressed(image, mode)
+ lz = Compressed(image, mode)
- to_file(fileout, lz.output)
+ to_file(fileout, lz.output)
def compress_monster_frontpic(id, fileout):
- mode = 'vert'
+ mode = 'vert'
- fpic = '../gfx/pics/' + str(id).zfill(3) + '/front.2bpp'
- fanim = '../gfx/pics/' + str(id).zfill(3) + '/tiles.2bpp'
+ 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
+ pic = open(fpic, 'rb').read()
+ anim = open(fanim, 'rb').read()
+ image = pic + anim
- lz = Compressed(image, mode, sizes[id-1])
+ lz = Compressed(image, mode, sizes[id-1])
- out = '../gfx/pics/' + str(id).zfill(3) + '/front.lz'
+ out = '../gfx/pics/' + str(id).zfill(3) + '/front.lz'
- to_file(out, lz.output)
+ 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)
+ """
+ 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)
+ 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
+ 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
@@ -1074,433 +1119,433 @@
def dump_monster_pals():
- rom = load_rom()
+ rom = load_rom()
- pals = 0xa8d6
- pal_length = 0x4
- for mon in range(251):
+ pals = 0xa8d6
+ pal_length = 0x4
+ for mon in range(251):
- name = pokemon_constants[mon+1].title().replace('_','')- num = str(mon+1).zfill(3)
- dir = 'gfx/pics/'+num+'/'
+ name = pokemon_constants[mon+1].title().replace('_','')+ num = str(mon+1).zfill(3)
+ dir = 'gfx/pics/'+num+'/'
- address = pals + mon*pal_length*2
+ address = pals + mon*pal_length*2
- pal_data = []
- for byte in range(pal_length):
- pal_data.append(ord(rom[address]))
- address += 1
+ pal_data = []
+ for byte in range(pal_length):
+ pal_data.append(ord(rom[address]))
+ address += 1
- filename = 'normal.pal'
- to_file('../'+dir+filename, pal_data)+ filename = 'normal.pal'
+ to_file('../'+dir+filename, pal_data)- spacing = ' ' * (15 - len(name))
- #print name+'Palette:'+spacing+' INCBIN "'+dir+filename+'"'
+ spacing = ' ' * (15 - len(name))
+ #print name+'Palette:'+spacing+' INCBIN "'+dir+filename+'"'
- pal_data = []
- for byte in range(pal_length):
- pal_data.append(ord(rom[address]))
- address += 1
+ pal_data = []
+ for byte in range(pal_length):
+ pal_data.append(ord(rom[address]))
+ address += 1
- filename = 'shiny.pal'
- to_file('../'+dir+filename, pal_data)+ filename = 'shiny.pal'
+ to_file('../'+dir+filename, pal_data)- spacing = ' ' * (10 - len(name))
- #print name+'ShinyPalette:'+spacing+' INCBIN "'+dir+filename+'"'
+ spacing = ' ' * (10 - len(name))
+ #print name+'ShinyPalette:'+spacing+' INCBIN "'+dir+filename+'"'
def dump_trainer_pals():
- rom = load_rom()
+ rom = load_rom()
- pals = 0xb0d2
- pal_length = 0x4
- for trainer in range(67):
+ pals = 0xb0d2
+ pal_length = 0x4
+ for trainer in range(67):
- name = trainer_group_names[trainer+1]['constant'].title().replace('_','')- num = str(trainer).zfill(3)
- dir = 'gfx/trainers/'
+ name = trainer_group_names[trainer+1]['constant'].title().replace('_','')+ num = str(trainer).zfill(3)
+ dir = 'gfx/trainers/'
- address = pals + trainer*pal_length
+ address = pals + trainer*pal_length
- pal_data = []
- for byte in range(pal_length):
- pal_data.append(ord(rom[address]))
- address += 1
+ pal_data = []
+ for byte in range(pal_length):
+ pal_data.append(ord(rom[address]))
+ address += 1
- filename = num+'.pal'
- to_file('../'+dir+filename, pal_data)+ filename = num+'.pal'
+ to_file('../'+dir+filename, pal_data)- spacing = ' ' * (12 - len(name))
- print name+'Palette:'+spacing+' INCBIN"'+dir+filename+'"'
+ spacing = ' ' * (12 - len(name))
+ print name+'Palette:'+spacing+' INCBIN"'+dir+filename+'"'
def flatten(planar):
- """
- Flattens planar 2bpp image data into a quaternary pixel map.
- """
- strips = []
- for pair in range(len(planar)/2):
- bottom = ord(planar[(pair*2) ])
- top = ord(planar[(pair*2)+1])
- strip = []
- for i in range(7,-1,-1):
- color = ((bottom >> i) & 1) + (((top >> i-1) if i > 0 else (top << 1-i)) & 2)
- strip.append(color)
- strips += strip
- return strips
+ """
+ Flatten planar 2bpp image data into a quaternary pixel map.
+ """
+ strips = []
+ for pair in range(len(planar)/2):
+ bottom = ord(planar[(pair*2) ])
+ top = ord(planar[(pair*2)+1])
+ strip = []
+ for i in range(7,-1,-1):
+ color = ((bottom >> i) & 1) + (((top >> i-1) if i > 0 else (top << 1-i)) & 2)
+ strip.append(color)
+ strips += strip
+ return strips
def to_lines(image, width):
- """
- Converts a tiled quaternary pixel map to lines of quaternary pixels.
- """
+ """
+ Convert a tiled quaternary pixel map to lines of quaternary pixels.
+ """
- tile = 8 * 8
+ tile = 8 * 8
- # so we know how many strips of 8px we're putting into a line
- num_columns = width / 8
- # number of lines
- height = len(image) / width
+ # so we know how many strips of 8px we're putting into a line
+ num_columns = width / 8
+ # number of lines
+ height = len(image) / width
- lines = []
- for cur_line in range(height):
- tile_row = int(cur_line / 8)
- line = []
- for column in range(num_columns):
- anchor = num_columns*tile_row*tile + column*tile + (cur_line%8)*8
- line += image[anchor:anchor+8]
- lines.append(line)
- return lines
+ lines = []
+ for cur_line in range(height):
+ tile_row = int(cur_line / 8)
+ line = []
+ for column in range(num_columns):
+ anchor = num_columns*tile_row*tile + column*tile + (cur_line%8)*8
+ line += image[anchor:anchor+8]
+ lines.append(line)
+ return lines
def dmg2rgb(word):
- red = word & 0b11111
- word >>= 5
- green = word & 0b11111
- word >>= 5
- blue = word & 0b11111
- alpha = 255
- return ((red<<3)+0b100, (green<<3)+0b100, (blue<<3)+0b100, alpha)
-
+ red = word & 0b11111
+ word >>= 5
+ green = word & 0b11111
+ word >>= 5
+ blue = word & 0b11111
+ alpha = 255
+ return ((red<<3)+0b100, (green<<3)+0b100, (blue<<3)+0b100, alpha)
+
def rgb_to_dmg(color):
- word = (color['r'] / 8)
- word += (color['g'] / 8) << 5
- word += (color['b'] / 8) << 10
- return word
+ word = (color['r'] / 8)
+ word += (color['g'] / 8) << 5
+ word += (color['b'] / 8) << 10
+ return word
def png_pal(filename):
- palette = []
- with open(filename, 'rb') as pal_data:
- words = pal_data.read()
- dmg_pals = []
- for word in range(len(words)/2):
- dmg_pals.append(ord(words[word*2]) + ord(words[word*2+1])*0x100)
- white = (255,255,255,255)
- black = (000,000,000,255)
- for word in dmg_pals: palette += [dmg2rgb(word)]
- if white not in dmg_pals and len(palette) < 4: palette = [white] + palette
- if black not in dmg_pals and len(palette) < 4: palette += [black]
- return palette
+ palette = []
+ with open(filename, 'rb') as pal_data:
+ words = pal_data.read()
+ dmg_pals = []
+ for word in range(len(words)/2):
+ dmg_pals.append(ord(words[word*2]) + ord(words[word*2+1])*0x100)
+ white = (255,255,255,255)
+ black = (000,000,000,255)
+ for word in dmg_pals: palette += [dmg2rgb(word)]
+ if white not in dmg_pals and len(palette) < 4: palette = [white] + palette
+ if black not in dmg_pals and len(palette) < 4: palette += [black]
+ return palette
def to_png(filein, fileout=None, pal_file=None, height=None, width=None):
- """
- Takes a planar 2bpp graphics file and converts it to png.
- """
+ """
+ Take a planar 2bpp graphics file and converts it to png.
+ """
- if fileout == None: fileout = '.'.join(filein.split('.')[:-1]) + '.png'+ if fileout == None: fileout = '.'.join(filein.split('.')[:-1]) + '.png'- image = open(filein, 'rb').read()
+ image = open(filein, 'rb').read()
- num_pixels = len(image) * 4
+ num_pixels = len(image) * 4
- if num_pixels == 0: return 'empty image!'
+ if num_pixels == 0: return 'empty image!'
- # unless the pic is square, at least one dimension should be given
+ # unless the pic is square, at least one dimension should be given
- if width == None and height == None:
- width = int(sqrt(num_pixels))
- height = width
+ if width == None and height == None:
+ width = int(sqrt(num_pixels))
+ height = width
- elif height == None:
- height = num_pixels / width
+ elif height == None:
+ height = num_pixels / width
- elif width == None:
- width = num_pixels / height
+ elif width == None:
+ width = num_pixels / height
- # but try to see if it can be made rectangular
+ # but try to see if it can be made rectangular
- if width * height != num_pixels:
+ if width * height != num_pixels:
- # look for possible combos of width/height that would form a rectangle
- matches = []
+ # look for possible combos of width/height that would form a rectangle
+ matches = []
- # this is pretty inefficient, and there is probably a simpler way
- for width in range(8,256+1,8): # we only want dimensions that fit in tiles
- height = num_pixels / width
- if height % 8 == 0:
- matches.append((width, height))
+ # this is pretty inefficient, and there is probably a simpler way
+ for width in range(8,256+1,8): # we only want dimensions that fit in tiles
+ height = num_pixels / width
+ if height % 8 == 0:
+ matches.append((width, height))
- # go for the most square image
- width, height = sorted(matches, key=lambda (x,y): x+y)[0] # favors height
+ # go for the most square image
+ width, height = sorted(matches, key=lambda (x,y): x+y)[0] # favors height
- # if it can't, the only option is a width of 1 tile
+ # if it can't, the only option is a width of 1 tile
- if width * height != num_pixels:
- width = 8
- height = num_pixels / width
+ if width * height != num_pixels:
+ width = 8
+ height = num_pixels / width
- # if this still isn't rectangular, then the image isn't made of tiles
+ # if this still isn't rectangular, then the image isn't made of tiles
- # for now we'll just spit out a warning
- if width * height != num_pixels:
- print 'Warning! ' + fileout + ' is ' + width + 'x' + height + '(' + width*height + ' pixels),\n' +\- 'but ' + filein + ' is ' + num_pixels + ' pixels!'
+ # for now we'll just spit out a warning
+ if width * height != num_pixels:
+ print 'Warning! ' + fileout + ' is ' + width + 'x' + height + '(' + width*height + ' pixels),\n' +\+ 'but ' + filein + ' is ' + num_pixels + ' pixels!'
- # map it out
+ # map it out
- lines = to_lines(flatten(image), width)
+ lines = to_lines(flatten(image), width)
- if pal_file == None:
- if os.path.exists(os.path.splitext(fileout)[0]+'.pal'):
- pal_file = os.path.splitext(fileout)[0]+'.pal'
+ if pal_file == None:
+ if os.path.exists(os.path.splitext(fileout)[0]+'.pal'):
+ pal_file = os.path.splitext(fileout)[0]+'.pal'
- if pal_file == None:
- palette = None
- greyscale = True
- bitdepth = 2
- inverse = { 0:3, 1:2, 2:1, 3:0 }- map = [[inverse[pixel] for pixel in line] for line in lines]
+ if pal_file == None:
+ palette = None
+ greyscale = True
+ bitdepth = 2
+ inverse = { 0:3, 1:2, 2:1, 3:0 }+ map = [[inverse[pixel] for pixel in line] for line in lines]
- else: # gbc color
- palette = png_pal(pal_file)
- greyscale = False
- bitdepth = 8
- map = [[pixel for pixel in line] for line in lines]
+ else: # gbc color
+ palette = png_pal(pal_file)
+ greyscale = False
+ bitdepth = 8
+ map = [[pixel for pixel in line] for line in lines]
- w = png.Writer(width, height, palette=palette, compression = 9, greyscale = greyscale, bitdepth = bitdepth)
- with open(fileout, 'wb') as file:
- w.write(file, map)
+ w = png.Writer(width, height, palette=palette, compression = 9, greyscale = greyscale, bitdepth = bitdepth)
+ with open(fileout, 'wb') as file:
+ w.write(file, map)
def to_2bpp(filein, fileout=None, palout=None):
- """
- Takes a png and converts it to planar 2bpp.
- """
+ """
+ Take a png and converts it to planar 2bpp.
+ """
- if fileout == None: fileout = '.'.join(filein.split('.')[:-1]) + '.2bpp'+ if fileout == None: fileout = '.'.join(filein.split('.')[:-1]) + '.2bpp'- with open(filein, 'rb') as file:
+ with open(filein, 'rb') as file:
- r = png.Reader(file)
- info = r.asRGBA8()
+ r = png.Reader(file)
+ info = r.asRGBA8()
- width = info[0]
- height = info[1]
+ width = info[0]
+ height = info[1]
- rgba = list(info[2])
- greyscale = info[3]['greyscale']
+ rgba = list(info[2])
+ greyscale = info[3]['greyscale']
- padding = { 'left': 0,- 'right': 0,
- 'top': 0,
- 'bottom': 0, }
- #if width % 8 != 0:
- # padding['left'] = int(ceil((width / 8 + 8 - width) / 2))
- # padding['right'] = int(floor((width / 8 + 8 - width) / 2))
- #if height % 8 != 0:
- # padding['top'] = int(ceil((height / 8 + 8 - height) / 2))
- # padding['bottom'] = int(floor((height / 8 + 8 - height) / 2))
+ padding = { 'left': 0,+ 'right': 0,
+ 'top': 0,
+ 'bottom': 0, }
+ #if width % 8 != 0:
+ # padding['left'] = int(ceil((width / 8 + 8 - width) / 2))
+ # padding['right'] = int(floor((width / 8 + 8 - width) / 2))
+ #if height % 8 != 0:
+ # padding['top'] = int(ceil((height / 8 + 8 - height) / 2))
+ # padding['bottom'] = int(floor((height / 8 + 8 - height) / 2))
- # turn the flat values into something more workable
+ # turn the flat values into something more workable
- pixel_length = 4 # rgba
- image = []
+ pixel_length = 4 # rgba
+ image = []
- # while we're at it, let's size up the palette
+ # while we're at it, let's size up the palette
- palette = []
+ palette = []
- for line in rgba:
- newline = []
- for pixel in range(len(line)/pixel_length):
- i = pixel * pixel_length
- color = { 'r': line[i ],- 'g': line[i+1],
- 'b': line[i+2],
- 'a': line[i+3], }
- newline += [color]
- if color not in palette: palette += [color]
- image.append(newline)
+ for line in rgba:
+ newline = []
+ for pixel in range(len(line)/pixel_length):
+ i = pixel * pixel_length
+ color = { 'r': line[i ],+ 'g': line[i+1],
+ 'b': line[i+2],
+ 'a': line[i+3], }
+ newline += [color]
+ if color not in palette: palette += [color]
+ image.append(newline)
- # pad out any small palettes
- hues = {- 'white': { 'r': 0xff, 'g': 0xff, 'b': 0xff, 'a': 0xff },- 'black': { 'r': 0x00, 'g': 0x00, 'b': 0x00, 'a': 0xff },- 'grey': { 'r': 0x55, 'g': 0x55, 'b': 0x55, 'a': 0xff },- 'gray': { 'r': 0xaa, 'g': 0xaa, 'b': 0xaa, 'a': 0xff },- }
- while len(palette) < 4:
- for hue in hues.values():
- if not any(color is hue for color in palette):
- palette += [hue]
- if len(palette) >= 4: break
+ # pad out any small palettes
+ hues = {+ 'white': { 'r': 0xff, 'g': 0xff, 'b': 0xff, 'a': 0xff },+ 'black': { 'r': 0x00, 'g': 0x00, 'b': 0x00, 'a': 0xff },+ 'grey': { 'r': 0x55, 'g': 0x55, 'b': 0x55, 'a': 0xff },+ 'gray': { 'r': 0xaa, 'g': 0xaa, 'b': 0xaa, 'a': 0xff },+ }
+ while len(palette) < 4:
+ for hue in hues.values():
+ if not any(color is hue for color in palette):
+ palette += [hue]
+ if len(palette) >= 4: break
- assert len(palette) <= 4, 'Palette should be 4 colors, is really ' + str(len(palette))
+ assert len(palette) <= 4, 'Palette should be 4 colors, is really ' + str(len(palette))
- # sort by luminance
- def luminance(color):
- # this is actually in reverse, thanks to dmg/cgb palette ordering
- rough = { 'r': 4.7,- 'g': 1.4,
- 'b': 13.8, }
- return sum(color[key] * -rough[key] for key in rough.keys())
- palette = sorted(palette, key=luminance)
+ # sort by luminance
+ def luminance(color):
+ # this is actually in reverse, thanks to dmg/cgb palette ordering
+ rough = { 'r': 4.7,+ 'g': 1.4,
+ 'b': 13.8, }
+ return sum(color[key] * -rough[key] for key in rough.keys())
+ palette = sorted(palette, key=luminance)
- # spit out a new .pal file
- # disable this if it causes problems with paletteless images
- if palout == None:
- if os.path.exists(os.path.splitext(fileout)[0]+'.pal'):
- palout = os.path.splitext(fileout)[0]+'.pal'
- if palout != None:
- output = []
- for color in palette:
- word = rgb_to_dmg(color)
- output += [word & 0xff]
- output += [word >> 8]
- to_file(palout, output)
+ # spit out a new .pal file
+ # disable this if it causes problems with paletteless images
+ if palout == None:
+ if os.path.exists(os.path.splitext(fileout)[0]+'.pal'):
+ palout = os.path.splitext(fileout)[0]+'.pal'
+ if palout != None:
+ output = []
+ for color in palette:
+ word = rgb_to_dmg(color)
+ output += [word & 0xff]
+ output += [word >> 8]
+ to_file(palout, output)
- # create a new map of quaternary color ids
- map = []
- if padding['top']: map += [0] * (width + padding['left'] + padding['right']) * padding['top']
- for line in image:
- if padding['left']: map += [0] * padding['left']
- for color in line:
- map.append(palette.index(color))
- if padding['right']: map += [0] * padding['right']
- if padding['bottom']: map += [0] * (width + padding['left'] + padding['right']) * padding['bottom']
+ # create a new map of quaternary color ids
+ map = []
+ if padding['top']: map += [0] * (width + padding['left'] + padding['right']) * padding['top']
+ for line in image:
+ if padding['left']: map += [0] * padding['left']
+ for color in line:
+ map.append(palette.index(color))
+ if padding['right']: map += [0] * padding['right']
+ if padding['bottom']: map += [0] * (width + padding['left'] + padding['right']) * padding['bottom']
- # split it into strips of 8, and make them planar
- num_columns = width / 8
- num_rows = height / 8
- tile = 8 * 8
- image = []
- for row in range(num_rows):
- for column in range(num_columns):
- for strip in range(tile / 8):
- anchor = row*num_columns*tile + column*tile/8 + strip*width
- line = map[anchor:anchor+8]
- bottom = 0
- top = 0
- for bit, quad in enumerate(line):
- bottom += (quad & 1) << (7-bit)
- top += ((quad & 2) >> 1) << (7-bit)
- image.append(bottom)
- image.append(top)
+ # split it into strips of 8, and make them planar
+ num_columns = width / 8
+ num_rows = height / 8
+ tile = 8 * 8
+ image = []
+ for row in range(num_rows):
+ for column in range(num_columns):
+ for strip in range(tile / 8):
+ anchor = row*num_columns*tile + column*tile/8 + strip*width
+ line = map[anchor:anchor+8]
+ bottom = 0
+ top = 0
+ for bit, quad in enumerate(line):
+ bottom += (quad & 1) << (7-bit)
+ top += ((quad & 2) >> 1) << (7-bit)
+ image.append(bottom)
+ image.append(top)
- to_file(fileout, image)
+ to_file(fileout, image)
def png_to_lz(filein):
- name = os.path.splitext(filein)[0]
+ name = os.path.splitext(filein)[0]
- to_2bpp(filein)
- image = open(name+'.2bpp', 'rb').read()
- to_file(name+'.lz', Compressed(image).output)
+ to_2bpp(filein)
+ image = open(name+'.2bpp', 'rb').read()
+ to_file(name+'.lz', Compressed(image).output)
def mass_to_png(debug=False):
- # greyscale
- for root, dirs, files in os.walk('../gfx/'):- for name in files:
- if debug: print os.path.splitext(name), os.path.join(root, name)
- if os.path.splitext(name)[1] == '.2bpp':
- to_png(os.path.join(root, name))
+ # greyscale
+ for root, dirs, files in os.walk('../gfx/'):+ for name in files:
+ if debug: print os.path.splitext(name), os.path.join(root, name)
+ if os.path.splitext(name)[1] == '.2bpp':
+ to_png(os.path.join(root, name))
def mass_to_colored_png(debug=False):
- # greyscale, unless a palette is detected
- for root, dirs, files in os.walk('../gfx/'):- if 'pics' not in root and 'trainers' not in root:
- for name in files:
- if debug: print os.path.splitext(name), os.path.join(root, name)
- if os.path.splitext(name)[1] == '.2bpp':
- to_png(os.path.join(root, name))
- os.utime(os.path.join(root, name), None)
+ # greyscale, unless a palette is detected
+ for root, dirs, files in os.walk('../gfx/'):+ if 'pics' not in root and 'trainers' not in root:
+ for name in files:
+ if debug: print os.path.splitext(name), os.path.join(root, name)
+ if os.path.splitext(name)[1] == '.2bpp':
+ to_png(os.path.join(root, name))
+ os.utime(os.path.join(root, name), None)
- # only monster and trainer pics for now
- for root, dirs, files in os.walk('../gfx/pics/'):- for name in files:
- if debug: print os.path.splitext(name), os.path.join(root, name)
- if os.path.splitext(name)[1] == '.2bpp':
- if 'normal.pal' in files:
- to_png(os.path.join(root, name), None, os.path.join(root, 'normal.pal'))
- else:
- to_png(os.path.join(root, name))
- os.utime(os.path.join(root, name), None)
+ # only monster and trainer pics for now
+ for root, dirs, files in os.walk('../gfx/pics/'):+ for name in files:
+ if debug: print os.path.splitext(name), os.path.join(root, name)
+ if os.path.splitext(name)[1] == '.2bpp':
+ if 'normal.pal' in files:
+ to_png(os.path.join(root, name), None, os.path.join(root, 'normal.pal'))
+ else:
+ to_png(os.path.join(root, name))
+ os.utime(os.path.join(root, name), None)
- for root, dirs, files in os.walk('../gfx/trainers/'):- for name in files:
- if debug: print os.path.splitext(name), os.path.join(root, name)
- if os.path.splitext(name)[1] == '.2bpp':
- to_png(os.path.join(root, name))
- os.utime(os.path.join(root, name), None)
+ for root, dirs, files in os.walk('../gfx/trainers/'):+ for name in files:
+ if debug: print os.path.splitext(name), os.path.join(root, name)
+ if os.path.splitext(name)[1] == '.2bpp':
+ to_png(os.path.join(root, name))
+ os.utime(os.path.join(root, name), None)
def mass_decompress(debug=False):
- for root, dirs, files in os.walk('../gfx/'):- for name in files:
- if 'lz' in name:
- if '/pics' in root:
- if 'front' in name:
- id = root.split('pics/')[1][:3]- if id != 'egg':
- with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert', sizes[int(id)-1])
- else:
- with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert', 4)
- to_file(os.path.join(root, 'front.2bpp'), de.pic)
- to_file(os.path.join(root, 'tiles.2bpp'), de.animtiles)
- elif 'back' in name:
- with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert')
- to_file(os.path.join(root, 'back.2bpp'), de.output)
- elif '/trainers' in root or '/fx' in root:
- with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert')
- to_file(os.path.join(root, os.path.splitext(name)[0]+'.2bpp'), de.output)
- else:
- with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read())
- to_file(os.path.join(root, os.path.splitext(name)[0]+'.2bpp'), de.output)
- os.utime(os.path.join(root, name), None)
+ for root, dirs, files in os.walk('../gfx/'):+ for name in files:
+ if 'lz' in name:
+ if '/pics' in root:
+ if 'front' in name:
+ id = root.split('pics/')[1][:3]+ if id != 'egg':
+ with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert', sizes[int(id)-1])
+ else:
+ with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert', 4)
+ to_file(os.path.join(root, 'front.2bpp'), de.pic)
+ to_file(os.path.join(root, 'tiles.2bpp'), de.animtiles)
+ elif 'back' in name:
+ with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert')
+ to_file(os.path.join(root, 'back.2bpp'), de.output)
+ elif '/trainers' in root or '/fx' in root:
+ with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read(), 'vert')
+ to_file(os.path.join(root, os.path.splitext(name)[0]+'.2bpp'), de.output)
+ else:
+ with open(os.path.join(root, name), 'rb') as lz: de = Decompressed(lz.read())
+ to_file(os.path.join(root, os.path.splitext(name)[0]+'.2bpp'), de.output)
+ os.utime(os.path.join(root, name), None)
def append_terminator_to_lzs(directory):
- # fix lzs that were extracted with a missing terminator
- for root, dirs, files in os.walk(directory):
- for file in files:
- if '.lz' in file:
- data = open(root+file,'rb').read()
- if data[-1] != chr(0xff):
- data += chr(0xff)
- new = open(root+file,'wb')
- new.write(data)
- new.close()
+ # fix lzs that were extracted with a missing terminator
+ for root, dirs, files in os.walk(directory):
+ for file in files:
+ if '.lz' in file:
+ data = open(root+file,'rb').read()
+ if data[-1] != chr(0xff):
+ data += chr(0xff)
+ new = open(root+file,'wb')
+ new.write(data)
+ new.close()
def lz_to_png_by_file(filename):
"""
- Converts a lz file to png. Dumps a 2bpp file too.
+ Convert a lz file to png. Dump a 2bpp file too.
"""
assert filename[-3:] == ".lz"
lz_data = open(filename, "rb").read()
@@ -1511,8 +1556,9 @@
def dump_tileset_pngs():
"""
- Converts .lz format tilesets into .png format tilesets. Also, leaves a
- bunch of wonderful .2bpp files everywhere for your amusement.
+ Convert .lz format tilesets into .png format tilesets.
+
+ Also, leaves a bunch of wonderful .2bpp files everywhere for your amusement.
"""
for tileset_id in range(37):
tileset_filename = "../gfx/tilesets/" + str(tileset_id).zfill(2) + ".lz"
@@ -1519,109 +1565,109 @@
lz_to_png_by_file(tileset_filename)
def decompress_frontpic(lz_file):
- """
- Convert the pic portion of front.lz to front.2bpp
- """
- lz = open(lz_file, 'rb').read()
- to_file(Decompressed(lz).pic, os.path.splitext(filein)[0] + '.2bpp')
+ """
+ Convert the pic portion of front.lz to front.2bpp
+ """
+ lz = open(lz_file, 'rb').read()
+ to_file(Decompressed(lz).pic, os.path.splitext(filein)[0] + '.2bpp')
def decompress_frontpic_anim(lz_file):
- """
- Convert the animation tile portion of front.lz to tiles.2bpp
- """
- lz = open(lz_file, 'rb').read()
- to_file(Decompressed(lz).animtiles, 'tiles.2bpp')
+ """
+ Convert the animation tile portion of front.lz to tiles.2bpp
+ """
+ lz = open(lz_file, 'rb').read()
+ to_file(Decompressed(lz).animtiles, 'tiles.2bpp')
def expand_pic_palettes():
- """
- Add white and black to palette files with fewer than 4 colors.
-
- Pokemon Crystal only defines two colors for a pic palette to
- save space, filling in black/white at runtime.
- Instead of managing palette files of varying length, black
- and white are added to pic palettes and excluded from incbins.
- """
- for root, dirs, files in os.walk('../gfx/'):- if 'gfx/pics' in root or 'gfx/trainers' in root:
- for name in files:
- if os.path.splitext(name)[1] == '.pal':
- filename = os.path.join(root, name)
- palette = bytearray(open(filename, 'rb').read())
- w = bytearray([0xff, 0x7f])
- b = bytearray([0x00, 0x00])
- if len(palette) == 4:
- with open(filename, 'wb') as out:
- out.write(w + palette + b)
+ """
+ Add white and black to palette files with fewer than 4 colors.
+
+ Pokemon Crystal only defines two colors for a pic palette to
+ save space, filling in black/white at runtime.
+ Instead of managing palette files of varying length, black
+ and white are added to pic palettes and excluded from incbins.
+ """
+ for root, dirs, files in os.walk('../gfx/'):+ if 'gfx/pics' in root or 'gfx/trainers' in root:
+ for name in files:
+ if os.path.splitext(name)[1] == '.pal':
+ filename = os.path.join(root, name)
+ palette = bytearray(open(filename, 'rb').read())
+ w = bytearray([0xff, 0x7f])
+ b = bytearray([0x00, 0x00])
+ if len(palette) == 4:
+ with open(filename, 'wb') as out:
+ out.write(w + palette + b)
if __name__ == "__main__":
- debug = False
-
- argv = [None] * 5
- for i, arg in enumerate(sys.argv):
- argv[i] = arg
+ debug = False
+
+ argv = [None] * 5
+ for i, arg in enumerate(sys.argv):
+ argv[i] = arg
- if argv[1] == 'dump-pngs':
- mass_to_colored_png()
+ if argv[1] == 'dump-pngs':
+ mass_to_colored_png()
- elif argv[1] == 'mass-decompress':
- mass_decompress()
+ elif argv[1] == 'mass-decompress':
+ mass_decompress()
- elif argv[1] == 'front-to-2bpp':
- decompress_frontpic(argv[2])
+ elif argv[1] == 'front-to-2bpp':
+ decompress_frontpic(argv[2])
- elif argv[1] == 'anim-from-front':
- decompress_frontpic_anim(argv[2])
+ elif argv[1] == 'anim-from-front':
+ decompress_frontpic_anim(argv[2])
- elif argv[1] == 'lz-to-2bpp':
- name = os.path.splitext(argv[3])[0]
- lz = open(name+'.lz', 'rb').read()
- if argv[2] == '--vert':
- to_file(name+'.2bpp', Decompressed(lz, 'vert').output)
- else:
- to_file(name+'.2bpp', Decompressed(lz).output)
+ elif argv[1] == 'lz-to-2bpp':
+ name = os.path.splitext(argv[3])[0]
+ lz = open(name+'.lz', 'rb').read()
+ if argv[2] == '--vert':
+ to_file(name+'.2bpp', Decompressed(lz, 'vert').output)
+ else:
+ to_file(name+'.2bpp', Decompressed(lz).output)
- elif argv[1] == 'lz-to-png':
- if argv[2] == '--vert':
- name = os.path.splitext(argv[3])[0]
- lz = open(name+'.lz', 'rb').read()
- to_file(name+'.2bpp', Decompressed(lz, 'vert').output)
- pic = open(name+'.2bpp', 'rb').read()
- to_file(name+'.png', to_png(pic))
- else:
- lz_to_png_by_file(argv[2])
+ elif argv[1] == 'lz-to-png':
+ if argv[2] == '--vert':
+ name = os.path.splitext(argv[3])[0]
+ lz = open(name+'.lz', 'rb').read()
+ to_file(name+'.2bpp', Decompressed(lz, 'vert').output)
+ pic = open(name+'.2bpp', 'rb').read()
+ to_file(name+'.png', to_png(pic))
+ else:
+ lz_to_png_by_file(argv[2])
- elif argv[1] == 'png-to-lz':
- # python gfx.py png-to-lz [--front anim(2bpp) | --vert] [png]
- if argv[2] == '--front':
- # front.2bpp and tiles.2bpp are combined before compression,
- # so we have to pass in the anim file and pic size
- name = os.path.splitext(argv[4])[0]
- to_2bpp(name+'.png', name+'.2bpp')
- pic = open(name+'.2bpp', 'rb').read()
- anim = open(argv[3], 'rb').read()
- size = int(sqrt(len(pic)/16)) # assume square pic
- to_file(name+'.lz', Compressed(pic + anim, 'vert', size).output)
- elif argv[2] == '--vert':
- name = os.path.splitext(argv[3])[0]
- to_2bpp(name+'.png', name+'.2bpp')
- pic = open(name+'.2bpp', 'rb').read()
- to_file(name+'.lz', Compressed(pic, 'vert').output)
- else:
- png_to_lz(argv[2])
+ elif argv[1] == 'png-to-lz':
+ # python gfx.py png-to-lz [--front anim(2bpp) | --vert] [png]
+ if argv[2] == '--front':
+ # front.2bpp and tiles.2bpp are combined before compression,
+ # so we have to pass in the anim file and pic size
+ name = os.path.splitext(argv[4])[0]
+ to_2bpp(name+'.png', name+'.2bpp')
+ pic = open(name+'.2bpp', 'rb').read()
+ anim = open(argv[3], 'rb').read()
+ size = int(sqrt(len(pic)/16)) # assume square pic
+ to_file(name+'.lz', Compressed(pic + anim, 'vert', size).output)
+ elif argv[2] == '--vert':
+ name = os.path.splitext(argv[3])[0]
+ to_2bpp(name+'.png', name+'.2bpp')
+ pic = open(name+'.2bpp', 'rb').read()
+ to_file(name+'.lz', Compressed(pic, 'vert').output)
+ else:
+ png_to_lz(argv[2])
- elif argv[1] == 'png-to-2bpp':
- to_2bpp(argv[2])
+ elif argv[1] == 'png-to-2bpp':
+ to_2bpp(argv[2])
- elif argv[1] == '2bpp-to-lz':
- if argv[2] == '--vert':
- filein = argv[3]
- fileout = argv[4]
- compress_file(filein, fileout, 'vert')
- else:
- filein = argv[2]
- fileout = argv[3]
- compress_file(filein, fileout)
-
- elif argv[1] == '2bpp-to-png':
- to_png(argv[2])
+ elif argv[1] == '2bpp-to-lz':
+ if argv[2] == '--vert':
+ filein = argv[3]
+ fileout = argv[4]
+ compress_file(filein, fileout, 'vert')
+ else:
+ filein = argv[2]
+ fileout = argv[3]
+ compress_file(filein, fileout)
+
+ elif argv[1] == '2bpp-to-png':
+ to_png(argv[2])
--- a/extras/overworldripper.py
+++ b/extras/overworldripper.py
@@ -1,6 +1,11 @@
import gfx
def rip_sprites_from_bank(bank, offset=0):
+ """
+ Rips sprites from specified bank.
+
+ Sprites are 4x4.
+ """
file_handler = open("../gfx/overworld/bank" + str(hex(bank))[2:] + ".asm", "w")for sprite in range(0 + offset, 256 + offset):
filename = "../gfx/overworld/" + str(sprite).zfill(3) + ".2bpp"
@@ -10,4 +15,4 @@
file_handler.close()
rip_sprites_from_bank(0x30)
-rip_sprites_from_bank(0x31, offset=256)
\ No newline at end of file
+rip_sprites_from_bank(0x31, offset=256)
--- a/extras/romstr.py
+++ b/extras/romstr.py
@@ -50,7 +50,7 @@
@classmethod
def load(cls, filename=None, crystal=True, red=False):
"""
- Loads a ROM into a RomStr.
+ Load a ROM into a RomStr.
"""
if crystal and not red and not filename:
file_handler = open("../baserom.gbc", "r")@@ -66,8 +66,10 @@
def load_labels(self, filename="labels.json"):
"""
- Loads labels from labels.json, or parses the source code file and
- generates new labels.
+ Loads labels from labels.json.
+
+ (Or parses the source code file and
+ generates new labels.)
"""
filename = os.path.join(os.path.dirname(__file__), filename)
@@ -114,8 +116,9 @@
def get_address_for(self, label):
"""
- Returns the address of a label. This is slow and could be improved
- dramatically.
+ Return the address of a label.
+
+ This is slow and could be improved dramatically.
"""
label = str(label)
for address in self.labels.keys():
@@ -137,7 +140,7 @@
def interval(self, offset, length, strings=True, debug=True):
"""
- returns hex values for the rom starting at offset until offset+length
+ Return hex values for the rom starting at offset until offset+length.
"""
returnable = []
for byte in self[offset:offset+length]:
@@ -149,16 +152,17 @@
def until(self, offset, byte, strings=True, debug=False):
"""
- Returns hex values from rom starting at offset until the given byte.
+ Return hex values from rom starting at offset until the given byte.
"""
return self.interval(offset, self.find(chr(byte), offset) - offset, strings=strings)
def to_asm(self, address, end_address=None, size=None, max_size=0x4000, debug=None):
"""
- Disassembles ASM at some address. This will stop disassembling when
- either the end_address or size is met. Also, there's a maximum size
- that will be parsed, so that large patches of data aren't parsed as
- code.
+ Disassemble ASM at some address.
+
+ This will stop disassembling when either the end_address or size is
+ met. Also, there's a maximum size that will be parsed, so that large
+ patches of data aren't parsed as code.
"""
if type(address) in [str, unicode] and "0x" in address:
address = int(address, 16)
--- a/extras/vba.py
+++ b/extras/vba.py
@@ -6,13 +6,15 @@
This is jython, not python. Use jython to run this file. Before running this
file, some of the dependencies need to be constructed. These can be obtained
from the vba-clojure project.
- sudo apt-get install g++ libtool openjdk-6-jre openjdk-6-jdk libsdl1.2-dev ant jython
+ sudo apt-get install g++ libtool openjdk-6-jre openjdk-6-jdk libsdl1.2-dev mercurial ant autoconf jython
export JAVA_INCLUDE_PATH=/usr/lib/jvm/java-6-openjdk-amd64/include/
export JAVA_INCLUDE_PATH2=/usr/lib/jvm/java-6-openjdk-amd64/include/
hg clone http://hg.bortreb.com/vba-clojure
- cd vba-clojure/java/
+ cd vba-clojure/
+ ./dl-libs.sh
+ cd java/
ant all
cd ..
autoreconf -i
@@ -28,6 +30,9 @@
$HOME/local/vba-clojure/vba-clojure/src/clojure/.libs/libvba.so.0.0.0 \
/usr/lib/jni/libvba.so
+(In the above command, substitute the first path with the path of the vba-clojure
+directory you made, if it is different.)
+
Also make sure VisualBoyAdvance.cfg is somewhere in the $PATH for VBA to find.
A default configuration is provided in vba-clojure under src/.
@@ -114,15 +119,19 @@
def _check_java_library_path():
"""
- Returns the value of java.library.path. The vba-clojure library must be
- compiled and linked from this location.
+ Returns the value of java.library.path.
+
+ The vba-clojure library must be compiled
+ and linked from this location.
"""
return System.getProperty("java.library.path")class RomList(list):
+
"""
Simple wrapper to prevent a giant rom from being shown on screen.
"""
+
def __init__(self, *args, **kwargs):
list.__init__(self, *args, **kwargs)
@@ -150,8 +159,9 @@
def button_combiner(buttons):
"""
- Combines multiple button presses into an integer. This is used when sending
- a keypress to the emulator.
+ Combines multiple button presses into an integer.
+
+ This is used when sending a keypress to the emulator.
"""
result = 0
@@ -186,8 +196,9 @@
def load_rom(path=None):
"""
- Starts the emulator with a certain ROM. Defaults to rom_path if no
- parameters are given.
+ Starts the emulator with a certain ROM.
+
+ Defaults to rom_path if no parameters are given.
"""
if path == None:
path = rom_path
@@ -204,8 +215,9 @@
def shutdown():
"""
- Stops the emulator. Closes the window. The "opposite" of this is the
- load_rom function.
+ Stops the emulator. Closes the window.
+
+ The "opposite" of this is the load_rom function.
"""
Gb.shutdown()
@@ -239,8 +251,9 @@
def _create_byte_buffer(data):
"""
- Converts data into a ByteBuffer. This is useful for interfacing with the Gb
- class.
+ Converts data into a ByteBuffer.
+
+ This is useful for interfacing with the Gb class.
"""
buf = ByteBuffer.allocateDirect(len(data))
if isinstance(data[0], int):
@@ -253,9 +266,11 @@
def set_state(state, do_step=False):
"""
- Injects the given state into the emulator. Use do_step if you want to call
- step(), which also allows SDL to render the latest frame. Note that the
- default is to not step, and that the screen (if it is enabled) will appear
+ Injects the given state into the emulator.
+
+ Use do_step if you want to call step(), which also allows
+ SDL to render the latest frame. Note that the default is to
+ not step, and that the screen (if it is enabled) will appear
as if it still has the last state loaded. This is normal.
"""
Gb.loadState(_create_byte_buffer(state))
@@ -274,7 +289,9 @@
def save_state(name, state=None, override=False):
"""
- Saves the given state to save_state_path. The file format must be ".sav"
+ Saves the given state to save_state_path.
+
+ The file format must be ".sav"
(and this will be appended to your string if necessary).
"""
if state == None:
@@ -296,7 +313,9 @@
def load_state(name):
"""
- Reads a state from file based on name. Looks in save_state_path for a file
+ Reads a state from file based on name.
+
+ Looks in save_state_path for a file
with this name (".sav" is optional)."""
save_path = os.path.join(save_state_path, name)
@@ -321,8 +340,9 @@
def get_root():
"""
- Loads the root state, or restarts the emulator and creates a new root
- state.
+ Loads the root state.
+
+ (Or restarts the emulator and creates a new root state.)
"""
try:
root = load_state("root")@@ -377,15 +397,17 @@
def set_memory(memory):
"""
- Sets memory in the emulator. Use get_memory() to retrieve the current
- state.
+ Sets memory in the emulator.
+
+ Use get_memory() to retrieve the current state.
"""
Gb.writeMemory(memory)
def get_pixels():
"""
- Returns a list of pixels on the screen display. Broken, probably. Use
- screenshot() instead.
+ Returns a list of pixels on the screen display.
+
+ Broken, probably. Use screenshot() instead.
"""
sys.stderr.write("ERROR: seems to be broken on VBA's end? Good luck. Use"" screenshot() instead.\n")
@@ -396,9 +418,10 @@
def screenshot(filename, literal=False):
"""
- Saves a PNG screenshot to the file at filename. Use literal if you want to
- store it in the current directory. Default is to save it to screenshots/
- under the project.
+ Saves a PNG screenshot to the file at filename.
+
+ Use literal if you want to store it in the current directory.
+ Default is to save it to screenshots/ under the project.
"""
screenshots_path = os.path.join(project_path, "screenshots/")
filename = os.path.join(screenshots_path, filename)
@@ -430,14 +453,18 @@
def set_memory_at(address, value):
"""
- Sets a byte at a certain address in memory. This directly sets the memory
- instead of copying the memory from the emulator.
+ Sets a byte at a certain address in memory.
+
+ This directly sets the memory instead of copying
+ the memory from the emulator.
"""
Gb.setMemoryAt(address, value)
def press(buttons, holdsteps=1, aftersteps=1):
"""
- Press a button. Use steplimit to say for how many steps you want to press
+ Press a button.
+
+ Use steplimit to say for how many steps you want to press
the button (try leaving it at the default, 1).
"""
if hasattr(buttons, "__len__"):
@@ -456,7 +483,9 @@
def get_buttons():
"""
- Returns the currentButtons[0] value (an integer with bits set for which
+ Returns the currentButtons[0] value
+
+ (an integer with bits set for which
buttons are currently pressed).
"""
return Gb.getCurrentButtons()
@@ -708,6 +737,7 @@
Gb.cheatAddGameshark(code, description)
class crystal:
+
"""
Just a simple namespace to store a bunch of functions for Pokémon Crystal.
"""
@@ -715,8 +745,7 @@
@staticmethod
def text_wait(step_size=10, max_wait=500):
"""
- Watches for a sign that text is done being drawn to screen, then
- presses the "A" button.
+ Presses the "A" button when text is done being drawn to screen.
:param step_size: number of steps per wait loop
:param max_wait: number of wait loops to perform
@@ -744,10 +773,12 @@
@staticmethod
def walk_through_walls():
"""
- Lets the player walk all over the map. These values are probably reset
- by some of the map/collision functions when you move on to a new
- location, so this needs to be executed each step/tick if continuous
- walk-through-walls is desired.
+ Lets the player walk all over the map.
+
+ These values are probably reset by some of the map/collision
+ functions when you move on to a new location, so this needs
+ to be executed each step/tick if continuous walk-through-walls
+ is desired.
"""
set_memory_at(0xC2FA, 0)
set_memory_at(0xC2FB, 0)
@@ -761,8 +792,9 @@
@staticmethod
def nstep(steplimit=500):
"""
- Steps the CPU forward and calls some functions in between each step,
- like to manipulate memory. This is pretty slow.
+ Steps the CPU forward and calls some functions in between each step.
+
+ (For example, to manipulate memory.) This is pretty slow.
"""
for step_counter in range(0, steplimit):
crystal.walk_through_walls()
@@ -806,6 +838,7 @@
def get_xy():
"""
(x, y) coordinates of player on map.
+
Relative to top-left corner of map.
"""
x = get_memory_at(0xdcb8)
@@ -815,9 +848,10 @@
@staticmethod
def menu_select(id=1):
"""
- Sets the cursor to the given pokemon in the player's party. This is
- under Start -> PKMN. This is useful for selecting a certain pokemon
- with fly or another skill.
+ Sets the cursor to the given pokemon in the player's party.
+
+ This is under Start -> PKMN. This is useful for selecting a
+ certain pokemon with fly or another skill.
This probably works on other menus.
"""
@@ -902,8 +936,9 @@
@staticmethod
def get_text():
"""
- Returns alphanumeric text on the screen. Other characters will not be
- shown.
+ Returns alphanumeric text on the screen.
+
+ Other characters will not be shown.
"""
output = ""
tiles = get_memory_range(0xc4a0, 1000)
@@ -942,8 +977,9 @@
@staticmethod
def write(something="TrAiNeR"):
"""
- Uses a planning algorithm to type out a word in the most efficient way
- possible.
+ Types out a word.
+
+ Uses a planning algorithm to do this in the most efficient way possible.
"""
button_sequence = keyboard.plan_typing(something)
crystal.keyboard_apply([[x] for x in button_sequence])
--- a/extras/vba_autoplayer.py
+++ b/extras/vba_autoplayer.py
@@ -26,8 +26,10 @@
def skippable(func):
"""
- Makes a function skippable by saving the state before and after the
- function runs. Pass "skip=True" to the function to load the previous save
+ Makes a function skippable.
+
+ Saves the state before and after the function runs.
+ Pass "skip=True" to the function to load the previous save
state from when the function finished.
"""
def wrapped_function(*args, **kwargs):
@@ -433,6 +435,8 @@
@skippable
def new_bark_level_grind(level):
"""
+ Do level grinding in New Bark.
+
Starting just outside of Elm's Lab, do some level grinding until the first
partymon level is equal to the given value..
"""