def __init__(self):
super(TitleScreenModule, self).__init__()
# Background data (includes the central "B", the copyright
# notice and the glow around the letters)
self.bg_tileset = EbGraphicTileset(num_tiles=BG_NUM_TILES,
tile_width=TILE_WIDTH,
tile_height=TILE_HEIGHT)
self.bg_arrangement = EbTileArrangement(width=BG_ARRANGEMENT_WIDTH,
height=BG_ARRANGEMENT_HEIGHT)
self.bg_anim_palette = EbPalette(
num_subpalettes=BG_NUM_ANIM_SUBPALETTES,
subpalette_length=ANIM_SUBPALETTE_LENGTH)
self.bg_palette = EbPalette(num_subpalettes=NUM_SUBPALETTES,
subpalette_length=BG_SUBPALETTE_LENGTH)
# Characters data (the title screen's animated letters)
self.chars_tileset = EbGraphicTileset(num_tiles=CHARS_NUM_TILES,
tile_width=TILE_WIDTH,
tile_height=TILE_HEIGHT)
self.chars_anim_palette = EbPalette(
num_subpalettes=CHARS_NUM_ANIM_SUBPALETTES,
subpalette_length=ANIM_SUBPALETTE_LENGTH)
self.chars_palette = EbPalette(
num_subpalettes=NUM_SUBPALETTES,
subpalette_length=CHARS_SUBPALETTE_LENGTH)
self.chars_layouts = [[] for _ in xrange(NUM_CHARS)]
def __init__(self):
super(WindowGraphicsModule, self).__init__()
self.graphics_1 = EbGraphicTileset(num_tiles=416, tile_width=8, tile_height=8)
self.graphics_2 = EbGraphicTileset(num_tiles=7, tile_width=8, tile_height=8)
self.flavor_palettes = [EbPalette(8, 4) for i in range(7)]
self.flavor_names = dict()
def __init__(self):
super(DeathScreenModule, self).__init__()
self.ness_tileset = EbGraphicTileset(num_tiles=NUM_TILES,
tile_width=TILE_WIDTH,
tile_height=TILE_HEIGHT)
self.jeff_tileset = EbGraphicTileset(num_tiles=NUM_TILES,
tile_width=TILE_WIDTH,
tile_height=TILE_HEIGHT)
self.arrangement = EbTileArrangement(width=ARRANGEMENT_WIDTH,
height=ARRANGEMENT_HEIGHT)
self.palette = EbPalette(num_subpalettes=NUM_SUBPALETTES,
subpalette_length=SUBPALETTE_LENGTH)
def test_from_image_8x8_1bpp(self):
palette = EbPalette(1, 2)
palette[0, 0].from_tuple((0xff, 0xff, 0xff))
palette[0, 1].from_tuple((0x0, 0x0, 0x0))
arrangement = EbTileArrangement(width=2, height=2)
arrangement[0, 0].tile = 0
arrangement[1, 0].tile = 2
arrangement[0, 1].tile = 1
arrangement[1, 1].tile = 3
tileset = EbGraphicTileset(num_tiles=4, tile_width=8, tile_height=8)
tileset.from_image(self.tile_8x8_2bpp_img,
arrangement=arrangement,
palette=palette)
assert_list_equal(tileset[0], [[0] * 8] * 8)
assert_list_equal(tileset[2], [[1] * 8] * 8)
assert_list_equal(tileset[1],
[[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]])
assert_list_equal(tileset[3],
[[0, 1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1, 1],
[0, 1, 0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 0, 1, 1],
[1, 1, 0, 1, 0, 0, 1, 1], [1, 1, 0, 0, 0, 0, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 0]])
def test_from_block_1bpp_out_of_bounds(self):
block = Block()
block.from_list([
0b00000011, 0b01110000, 0b01001001, 0b11110000, 0b01001010,
0b11001000, 0b01110001, 0b00000001, 0b00100000, 0b00110000,
0b00101000, 0b00101000, 0b01100000, 0b11100000, 0b11000000,
0b00000001
])
tileset = EbGraphicTileset(num_tiles=3, tile_width=8, tile_height=8)
tileset.from_block(block, offset=0, bpp=1)
assert_list_equal(tileset[0],
[[0, 0, 0, 0, 0, 0, 1, 1], [0, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0, 0, 1], [1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0, 1, 0], [1, 1, 0, 0, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1]])
assert_list_equal(tileset[1],
[[0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0],
[0, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1]])
assert_list_equal(tileset[2],
[[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]])
def __init__(self):
self.minitiles = EbGraphicTileset(num_tiles=896,
tile_width=8,
tile_height=8)
self.arrangements = [None for i in range(1024)]
self.collisions = [None for i in range(1024)]
self.palettes = []
def test_to_image_single_subpalette(self):
palette = EbPalette(1, 2)
tileset = EbGraphicTileset(num_tiles=6, tile_width=8, tile_height=8)
arrangement = EbTileArrangement(width=6, height=1)
arrangement.from_image(self.tile_8x8_2bpp_2_img,
tileset=tileset,
palette=palette)
new_image = arrangement.image(tileset, palette)
assert_images_equal(self.tile_8x8_2bpp_2_img, new_image)
def read_background_data_from_project(self, resource_open):
# Load the background reference image
# The image's arrangement, tileset and palette will be used for the
# animation frames
with resource_open(BG_REFERENCE_PATH, "png") as f:
image = open_indexed_image(f)
self.bg_arrangement.from_image(
image, self.bg_tileset, self.bg_palette
)
# Read the background animated frames
for frame in range(NUM_ANIM_FRAMES):
# Create temporary structures used to check consistency between
# frames
tileset = EbGraphicTileset(BG_NUM_TILES, TILE_WIDTH, TILE_HEIGHT)
arrangement = EbTileArrangement(
BG_ARRANGEMENT_WIDTH, BG_ARRANGEMENT_HEIGHT
)
palette = EbPalette(NUM_SUBPALETTES, BG_SUBPALETTE_LENGTH)
# Read one frame's image data
with resource_open(BG_FRAMES_PATH.format(frame), "png") as f:
image = open_indexed_image(f)
arrangement.from_image(image, tileset, palette)
# Make sure each frame's tileset and arrangement is identical
# The background palette is checked only if it isn't the fake
# palette used for the first few frames
if frame >= CHARS_NUM_ANIM_SUBPALETTES:
# Get the background animated subpalette from the background
# palette
colors = palette[0, BG_ANIM_SLICE]
self.bg_anim_palette.subpalettes[
frame - CHARS_NUM_ANIM_SUBPALETTES
] = colors
palette[0, BG_ANIM_SLICE] = self.bg_palette[
0, BG_ANIM_SLICE
]
if self.bg_palette != palette:
log.warn(
"Palette from background frame {} does not match "
"reference.".format(frame)
)
if self.bg_tileset != tileset:
log.warn(
"Tileset from background frame {} does not match "
"reference.".format(frame)
)
if self.bg_arrangement != arrangement:
log.warn(
"Arrangement from background frame {} does not match "
"reference.".format(frame)
)
def test_init(self):
tileset = EbGraphicTileset(num_tiles=1, tile_width=8, tile_height=16)
assert_equal(tileset.num_tiles_maximum, 1)
assert_equal(tileset.tile_width, 8)
assert_equal(tileset.tile_height, 16)
assert_raises(InvalidArgumentError, EbGraphicTileset, 0, 8, 8)
assert_raises(InvalidArgumentError, EbGraphicTileset, -1, 8, 8)
assert_raises(InvalidArgumentError, EbGraphicTileset, 1, 0, 8)
assert_raises(InvalidArgumentError, EbGraphicTileset, 1, -1, 8)
assert_raises(InvalidArgumentError, EbGraphicTileset, 1, 1, 8)
assert_raises(InvalidArgumentError, EbGraphicTileset, 1, 8, 0)
assert_raises(InvalidArgumentError, EbGraphicTileset, 1, 8, -1)
def test_to_block_2bpp(self):
tileset = EbGraphicTileset(num_tiles=2, tile_width=8, tile_height=8)
tileset.tiles = [None, None]
tileset.tiles[0] = [[2, 1, 2, 3, 2, 1, 2, 1], [2, 3, 1, 0, 2, 3, 2, 2],
[3, 0, 3, 2, 2, 2, 0, 2], [1, 3, 3, 0, 2, 0, 2, 3],
[1, 0, 1, 1, 0, 3, 3, 3], [1, 3, 3, 3, 3, 2, 1, 2],
[2, 2, 3, 1, 2, 2, 1, 0], [2, 0, 3, 3, 2, 3, 1, 0]]
tileset.tiles[1] = [[1, 3, 3, 1, 3, 0, 2, 1], [3, 2, 2, 3, 3, 2, 2, 2],
[1, 1, 2, 2, 3, 0, 1, 1], [0, 3, 2, 2, 0, 0, 0, 3],
[3, 3, 0, 0, 1, 0, 1, 0], [2, 3, 1, 3, 3, 2, 1, 2],
[0, 0, 0, 1, 3, 2, 3, 3], [2, 2, 3, 2, 0, 0, 0, 1]]
block = Block()
block.from_list([0] * 32)
tileset.to_block(block, 0, 2)
assert_list_equal(
block.to_list(),
[
0b01010101, # Tile 1
0b10111010,
0b01100100,
0b11001111,
0b10100000,
0b10111101,
0b11100001,
0b01101011,
0b10110111,
0b00000111,
0b11111010,
0b01111101,
0b00110010,
0b11101100,
0b00110110,
0b10111100,
0b11111001, # Tile 2
0b01101010,
0b10011000,
0b11111111,
0b11001011,
0b00111000,
0b01000001,
0b01110001,
0b11001010,
0b11000000,
0b01111010,
0b11011101,
0b00011011,
0b00001111,
0b00100001,
0b11110000
])
def test_add_tile(self):
tileset = EbGraphicTileset(num_tiles=5, tile_width=8, tile_height=8)
tile = [
array('B', [5, 7, 6, 4, 1, 5, 3, 3]),
array('B', [5, 8, 3, 7, 5, 7, 1, 1]),
array('B', [6, 1, 1, 5, 4, 0, 1, 5]),
array('B', [2, 1, 4, 5, 4, 1, 6, 4]),
array('B', [4, 6, 6, 2, 1, 0, 4, 4]),
array('B', [6, 1, 0, 7, 5, 8, 1, 8]),
array('B', [8, 0, 4, 0, 2, 8, 0, 8]),
array('B', [0, 6, 8, 6, 0, 5, 4, 0])
]
tile1_id, tile1_vflip, tile1_hflip = tileset.add_tile(tile)
tile2_id, tile2_vflip, tile2_hflip = tileset.add_tile(tile)
assert_equal(tile2_id, tile1_id)
assert_equal(tile2_vflip, tile1_vflip)
assert_equal(tile2_hflip, tile1_hflip)
tile.reverse()
tile2_id, tile2_vflip, tile2_hflip = tileset.add_tile(tile)
assert_equal(tile2_id, tile1_id)
assert_equal(tile2_vflip, not tile1_vflip)
assert_equal(tile2_hflip, tile1_hflip)
for row in tile:
row.reverse()
tile2_id, tile2_vflip, tile2_hflip = tileset.add_tile(tile)
assert_equal(tile2_id, tile1_id)
assert_equal(tile2_vflip, not tile1_vflip)
assert_equal(tile2_hflip, not tile1_hflip)
tile.reverse()
tile2_id, tile2_vflip, tile2_hflip = tileset.add_tile(tile)
assert_equal(tile2_id, tile1_id)
assert_equal(tile2_vflip, tile1_vflip)
assert_equal(tile2_hflip, not tile1_hflip)
tile = [
array('B', [1, 2, 3, 4, 1, 5, 3, 3]),
array('B', [5, 8, 3, 7, 5, 7, 1, 1]),
array('B', [6, 1, 1, 5, 4, 0, 1, 5]),
array('B', [2, 1, 4, 5, 4, 1, 6, 4]),
array('B', [4, 6, 6, 2, 1, 0, 4, 4]),
array('B', [6, 1, 0, 7, 5, 8, 1, 8]),
array('B', [8, 0, 4, 0, 2, 8, 0, 8]),
array('B', [0, 6, 8, 6, 0, 5, 4, 0])
]
tile2_id, tile2_vflip, tile2_hflip = tileset.add_tile(tile)
assert_not_equal(tile2_id, tile1_id)
def test_from_block_2bpp(self):
block = Block()
block.from_list([
0b01010101, # Tile 1
0b10111010,
0b01100100,
0b11001111,
0b10100000,
0b10111101,
0b11100001,
0b01101011,
0b10110111,
0b00000111,
0b11111010,
0b01111101,
0b00110010,
0b11101100,
0b00110110,
0b10111100,
0b11111001, # Tile 2
0b01101010,
0b10011000,
0b11111111,
0b11001011,
0b00111000,
0b01000001,
0b01110001,
0b11001010,
0b11000000,
0b01111010,
0b11011101,
0b00011011,
0b00001111,
0b00100001,
0b11110000
])
tileset = EbGraphicTileset(num_tiles=2, tile_width=8, tile_height=8)
tileset.from_block(block, offset=0, bpp=2)
assert_list_equal(tileset[0],
[[2, 1, 2, 3, 2, 1, 2, 1], [2, 3, 1, 0, 2, 3, 2, 2],
[3, 0, 3, 2, 2, 2, 0, 2], [1, 3, 3, 0, 2, 0, 2, 3],
[1, 0, 1, 1, 0, 3, 3, 3], [1, 3, 3, 3, 3, 2, 1, 2],
[2, 2, 3, 1, 2, 2, 1, 0], [2, 0, 3, 3, 2, 3, 1, 0]])
assert_list_equal(tileset[1],
[[1, 3, 3, 1, 3, 0, 2, 1], [3, 2, 2, 3, 3, 2, 2, 2],
[1, 1, 2, 2, 3, 0, 1, 1], [0, 3, 2, 2, 0, 0, 0, 3],
[3, 3, 0, 0, 1, 0, 1, 0], [2, 3, 1, 3, 3, 2, 1, 2],
[0, 0, 0, 1, 3, 2, 3, 3], [2, 2, 3, 2, 0, 0, 0, 1]])
def test_from_image_single_subpalette(self):
palette = EbPalette(1, 2)
tileset = EbGraphicTileset(num_tiles=6, tile_width=8, tile_height=8)
arrangement = EbTileArrangement(width=6, height=1)
arrangement.from_image(self.tile_8x8_2bpp_2_img,
tileset=tileset,
palette=palette)
assert_equal(palette[0, 0], EbColor(0, 0, 0))
assert_equal(palette[0, 1], EbColor(0xf8, 0xf8, 0xf8))
item = arrangement[0, 0]
assert_equal(item.subpalette, 0)
assert_equal(arrangement[1, 0].tile, item.tile)
assert_equal(arrangement[1, 0].is_horizontally_flipped,
not item.is_horizontally_flipped)
assert_equal(arrangement[1, 0].is_vertically_flipped,
item.is_vertically_flipped)
assert_equal(arrangement[1, 0].subpalette, 0)
assert_equal(arrangement[2, 0].tile, item.tile)
assert_equal(arrangement[2, 0].is_horizontally_flipped,
item.is_horizontally_flipped)
assert_equal(arrangement[2, 0].is_vertically_flipped,
not item.is_vertically_flipped)
assert_equal(arrangement[2, 0].subpalette, 0)
assert_equal(arrangement[3, 0].tile, item.tile)
assert_equal(arrangement[3, 0].is_horizontally_flipped,
not item.is_horizontally_flipped)
assert_equal(arrangement[2, 0].is_vertically_flipped,
not item.is_vertically_flipped)
assert_equal(arrangement[3, 0].subpalette, 0)
assert_not_equal(arrangement[4, 0].tile, item.tile)
assert_equal(arrangement[4, 0].subpalette, 0)
assert_equal(arrangement[5, 0].tile, item.tile)
assert_equal(arrangement[5, 0].is_horizontally_flipped,
item.is_horizontally_flipped)
assert_equal(arrangement[5, 0].is_vertically_flipped,
item.is_vertically_flipped)
assert_equal(arrangement[5, 0].subpalette, 0)
def test_from_image_2_subpalettes(self):
palette = EbPalette(2, 4)
tileset = EbGraphicTileset(num_tiles=4, tile_width=8, tile_height=8)
arrangement = EbTileArrangement(width=4, height=1)
arrangement.from_image(image=self.tile_8x8_2bpp_3_img,
tileset=tileset,
palette=palette)
img_palette = self.tile_8x8_2bpp_3_img.getpalette()
self.tile_8x8_2bpp_3_img.putpalette([x & 0xf8 for x in img_palette])
before_image_rgb = self.tile_8x8_2bpp_3_img.convert("RGB")
after_image_rgb = arrangement.image(tileset, palette).convert("RGB")
assert_images_equal(before_image_rgb, after_image_rgb)
assert_set_equal({palette[1, i]
for i in range(4)}, {
EbColor(24, 0, 248),
EbColor(0, 248, 24),
EbColor(152, 0, 248),
EbColor(248, 144, 0)
})
assert_set_equal({palette[0, i]
for i in range(4)}, {
EbColor(24, 0, 248),
EbColor(0, 248, 24),
EbColor(216, 248, 0),
EbColor(152, 0, 248)
})
assert_equal(arrangement[0, 0].tile, 0)
assert_equal(arrangement[0, 0].subpalette, 0)
assert_equal({tileset[0][0][i]
for i in [-1, -2, -3, -4]}, {0, 1, 2, 3})
assert_equal(arrangement[1, 0].tile, 1)
assert_equal(arrangement[1, 0].subpalette, 1)
assert_equal({tileset[1][0][i]
for i in [-1, -2, -3, -4]}, {0, 1, 2, 3})
assert_equal(arrangement[2, 0].tile, 2)
assert_equal(arrangement[2, 0].subpalette, 0)
assert_equal(arrangement[3, 0].tile, 3)
assert_equal(arrangement[3, 0].subpalette, 1)
def test_from_image_8x16_2bpp(self):
palette = EbPalette(1, 4)
palette[0, 0].from_tuple((0xff, 0xff, 0xff))
palette[0, 1].from_tuple((0x30, 0x00, 0xff))
palette[0, 2].from_tuple((0xff, 0x00, 0x00))
palette[0, 3].from_tuple((0x00, 0xff, 0x48))
arrangement = EbTileArrangement(width=2, height=3)
arrangement[0, 0].tile = 1
arrangement[1, 0].tile = 1
arrangement[0, 1].tile = 3
arrangement[1, 1].tile = 2
arrangement[0, 2].tile = 0
arrangement[1, 2].tile = 4
tileset = EbGraphicTileset(num_tiles=5, tile_width=8, tile_height=16)
tileset.from_image(self.tile_8x16_4bpp_img,
arrangement=arrangement,
palette=palette)
assert_list_equal(tileset[1], [[2] * 8] * 16)
assert_list_equal(tileset[3], [[3] * 8] * 16)
assert_list_equal(tileset[2],
[[3] * 8, [3] * 8, [3] * 8, [3] * 8, [3] * 8,
[3, 3, 1, 3, 3, 3, 3, 3], [3, 3, 1, 3, 3, 1, 3, 3],
[1] * 8, [1, 1, 2, 2, 1, 1, 1, 1],
[1, 2, 2, 2, 2, 2, 1, 1], [1, 1, 1, 1, 1, 2, 1, 1],
[1, 1, 1, 1, 2, 2, 1, 1], [1, 1, 2, 2, 2, 1, 1, 1],
[1] * 8, [1] * 8, [1, 1, 1, 3, 1, 1, 1, 1]])
assert_list_equal(tileset[0],
[[2, 1, 1, 1, 1, 1, 1, 1], [2, 3, 3, 3, 3, 3, 3, 1],
[0, 2, 3, 3, 3, 3, 1, 3], [0, 2, 3, 3, 3, 3, 1, 3],
[0, 0, 2, 3, 3, 1, 3, 3], [0, 0, 2, 3, 3, 1, 3, 3],
[0, 0, 0, 2, 1, 3, 3, 3], [0, 0, 0, 2, 1, 3, 3, 3],
[0, 0, 0, 1, 2, 3, 3, 3], [0, 0, 0, 1, 2, 3, 3, 3],
[0, 0, 1, 0, 0, 2, 3, 3], [0, 0, 1, 0, 0, 2, 3, 3],
[0, 1, 0, 0, 0, 0, 2, 3], [0, 1, 0, 0, 0, 0, 2, 3],
[1, 0, 0, 0, 0, 0, 0, 2], [1, 0, 0, 0, 0, 0, 0, 2]])
assert_list_equal(tileset[4],
[[3] * 8, [3] * 8, [3] * 8, [3] * 8, [3] * 8,
[3, 2, 3, 3, 3, 2, 3, 3], [3] * 8, [3] * 8,
[3, 3, 3, 3, 3, 3, 3, 2], [2, 3, 3, 3, 3, 3, 2, 3],
[3, 2, 3, 3, 3, 2, 2, 3], [3, 2, 2, 2, 2, 2, 3, 3],
[3] * 8, [3] * 8, [3] * 8, [3] * 8])
def test_from_block_4bpp(self):
block = Block()
block.from_list([
0b01010110, 0b00001011, 0b11001110, 0b10010110, 0b01110001,
0b00111011, 0b00001011, 0b10011110, 0b00011000, 0b00000011,
0b10000001, 0b11101011, 0b00000100, 0b01000101, 0b01010110,
0b10001111, 0b00101100, 0b10110000, 0b01010110, 0b10110010,
0b01010000, 0b11000000, 0b00111000, 0b10010111, 0b00101101,
0b11111100, 0b01111101, 0b11101010, 0b10101111, 0b10110111,
0b01100000, 0b11101110
])
tileset = EbGraphicTileset(num_tiles=1, tile_width=8, tile_height=8)
tileset.from_block(block, offset=0, bpp=4)
assert_list_equal(
tileset[0],
[[8, 1, 12, 9, 6, 5, 3, 2], [11, 5, 8, 14, 1, 7, 15, 0],
[8, 13, 3, 7, 2, 0, 2, 3], [10, 0, 4, 14, 7, 10, 11, 9],
[8, 8, 12, 9, 13, 12, 2, 6], [11, 14, 14, 4, 14, 4, 10, 7],
[12, 2, 12, 8, 4, 15, 12, 14], [10, 13, 12, 1, 10, 11, 11, 2]])
def read_from_project(self, resource_open):
with resource_open("bg_data_table", "yml", True) as f:
self.bg_table.from_yml_file(f)
with resource_open("bg_scrolling_table", "yml", True) as f:
self.scroll_table.from_yml_file(f)
with resource_open("bg_distortion_table", "yml", True) as f:
self.distortion_table.from_yml_file(f)
self.backgrounds = []
self.palettes = []
for i in range(self.bg_table.num_rows):
new_color_depth = self.bg_table[i][2]
with resource_open("BattleBGs/" + str(i).zfill(3), "png") as f:
image = open_indexed_image(f)
new_palette = EbPalette(num_subpalettes=1,
subpalette_length=16)
new_tileset = EbGraphicTileset(num_tiles=512,
tile_width=8,
tile_height=8)
new_arrangement = EbTileArrangement(width=32, height=32)
new_arrangement.from_image(image, new_tileset, new_palette)
for j, (tileset, color_depth,
arrangement) in enumerate(self.backgrounds):
if (color_depth == new_color_depth) \
and (tileset == new_tileset) \
and (arrangement == new_arrangement):
self.bg_table[i][0] = j
break
else:
self.bg_table[i][0] = len(self.backgrounds)
self.backgrounds.append(
(new_tileset, new_color_depth, new_arrangement))
for j, palette in enumerate(self.palettes):
if palette == new_palette:
self.bg_table[i][1] = j
break
else:
self.bg_table[i][1] = len(self.palettes)
self.palettes.append(new_palette)
def test_to_block_1bpp(self):
tileset = EbGraphicTileset(num_tiles=2, tile_width=8, tile_height=8)
tileset.tiles = [None, None]
tileset.tiles[0] = [[0, 0, 0, 0, 0, 0, 1, 1], [0, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0, 0, 1], [1, 1, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 0, 1, 0], [1, 1, 0, 0, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1]]
tileset.tiles[1] = [[0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0],
[0, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1]]
block = Block()
block.from_list([0] * 16)
tileset.to_block(block, 0, 1)
assert_list_equal(block.to_list(), [
0b00000011, 0b01110000, 0b01001001, 0b11110000, 0b01001010,
0b11001000, 0b01110001, 0b00000001, 0b00100000, 0b00110000,
0b00101000, 0b00101000, 0b01100000, 0b11100000, 0b11000000,
0b00000001
])
def __init__(self, frames, unknown, graphics_data_size=None):
self.graphics_data_size = graphics_data_size
self.frames = frames
self.unknown = unknown
if graphics_data_size:
num_tiles = EbGraphicTileset.tiles_from_parameters(
graphics_data_size, TILE_WIDTH, TILE_HEIGHT, TILE_BPP)
else: # Make tileset with maximum number of tiles possible for each frame of animation
num_tiles = SCREEN_WIDTH_TILES * SCREEN_HEIGHT_TILES * frames
# Animations are 2 bpp, so the palette will have 4 colors
self.palette = EbPalette(num_subpalettes=1, subpalette_length=4)
self.graphics = EbGraphicTileset(num_tiles=num_tiles,
tile_width=TILE_WIDTH,
tile_height=TILE_HEIGHT)
self.arrangements = [
EbTileArrangement(width=SCREEN_WIDTH_TILES,
height=SCREEN_HEIGHT_TILES)
for i in range(self.frames)
]
def test_to_block_4bpp(self):
tileset = EbGraphicTileset(num_tiles=1, tile_width=8, tile_height=8)
tileset.tiles = [None]
tileset.tiles[0] = [[8, 1, 12, 9, 6, 5, 3, 2],
[11, 5, 8, 14, 1, 7, 15, 0],
[8, 13, 3, 7, 2, 0, 2, 3],
[10, 0, 4, 14, 7, 10, 11, 9],
[8, 8, 12, 9, 13, 12, 2, 6],
[11, 14, 14, 4, 14, 4, 10, 7],
[12, 2, 12, 8, 4, 15, 12, 14],
[10, 13, 12, 1, 10, 11, 11, 2]]
block = Block()
block.from_list([0] * 32)
tileset.to_block(block, 0, 4)
assert_list_equal(block.to_list(), [
0b01010110, 0b00001011, 0b11001110, 0b10010110, 0b01110001,
0b00111011, 0b00001011, 0b10011110, 0b00011000, 0b00000011,
0b10000001, 0b11101011, 0b00000100, 0b01000101, 0b01010110,
0b10001111, 0b00101100, 0b10110000, 0b01010110, 0b10110010,
0b01010000, 0b11000000, 0b00111000, 0b10010111, 0b00101101,
0b11111100, 0b01111101, 0b11101010, 0b10101111, 0b10110111,
0b01100000, 0b11101110
])
def test_block_size(self):
assert_equal(
EbGraphicTileset(num_tiles=2, tile_width=8,
tile_height=8).block_size(2), 32)
assert_equal(
EbGraphicTileset(num_tiles=10, tile_width=8,
tile_height=8).block_size(2), 160)
assert_equal(
EbGraphicTileset(num_tiles=10, tile_width=8,
tile_height=8).block_size(4), 320)
assert_equal(
EbGraphicTileset(num_tiles=10, tile_width=8,
tile_height=8).block_size(8), 640)
assert_equal(
EbGraphicTileset(num_tiles=10, tile_width=8,
tile_height=8).block_size(1), 80)
assert_equal(
EbGraphicTileset(num_tiles=10, tile_width=8,
tile_height=16).block_size(1), 160)
assert_equal(
EbGraphicTileset(num_tiles=10, tile_width=16,
tile_height=16).block_size(1), 320)
def __init__(self):
super(SoundStoneModule, self).__init__()
self.tileset = EbGraphicTileset(num_tiles=352,
tile_width=8,
tile_height=8)
self.palette = EbPalette(num_subpalettes=6, subpalette_length=16)
def read_chars_data_from_project(self, resource_open):
# Read the characters positions
with resource_open(CHARS_POSITIONS_PATH, "yml") as f:
chars_positions = yml_load(f)
# Read the characters animated frames
self.chars_tileset = None
self.chars_anim_palette = EbPalette(CHARS_NUM_ANIM_SUBPALETTES,
ANIM_SUBPALETTE_LENGTH)
original_tileset = None
for p in xrange(CHARS_NUM_ANIM_SUBPALETTES):
# Read one of the animation frames
with resource_open(CHARS_FRAMES_PATH.format(p), "png") as f:
# Create temporary structures to hold the data
image = open_indexed_image(f)
arrangement = EbTileArrangement(image.width / TILE_WIDTH,
image.height / TILE_HEIGHT)
tileset = EbGraphicTileset(CHARS_NUM_TILES, TILE_WIDTH,
TILE_HEIGHT)
anim_subpalette = EbPalette(NUM_SUBPALETTES,
ANIM_SUBPALETTE_LENGTH)
arrangement.from_image(image, tileset, anim_subpalette, True)
# Add the characters animation subpalette
for i in xrange(ANIM_SUBPALETTE_LENGTH):
self.chars_anim_palette[p, i] = anim_subpalette[0, i]
# Add the characters tileset if not already set, otherwise
# ensure that it the current tileset is identical
if not self.chars_tileset:
original_tileset = tileset
self.chars_tileset = EbGraphicTileset(CHARS_NUM_TILES,
TILE_WIDTH, TILE_HEIGHT)
self.chars_tileset.tiles = [[[0 for _ in xrange(TILE_HEIGHT)]
for _ in xrange(TILE_WIDTH)]
for _ in xrange(CHARS_NUM_TILES)]
unused_tiles = set(xrange(CHARS_NUM_TILES))
# Set the new character layouts
self.chars_layouts = [[] for _ in xrange(NUM_CHARS)]
for c, data in chars_positions.items():
# Get the data from the YAML file
x = int(data['x'] / TILE_WIDTH)
y = int(data['y'] / TILE_HEIGHT)
width = int(data['width'] / TILE_WIDTH)
height = int(data['height'] / TILE_HEIGHT)
x_offset = data['top_left_offset']['x']
y_offset = data['top_left_offset']['y']
unknown = data['unknown']
# Generate a list of all tiles must be visited
# Where possible, we try to generate a multi tile (4 tiles
# stored as one); otherwise, bordering tiles that are
# visited will all be single tiles.
l = [(i, j) for i in xrange(0, width, 2)
for j in xrange(0, height, 2)]
if width % 2 == 1:
l.extend([(width - 1, j)
for j in xrange(1, height, 2)])
if height % 2 == 1:
l.extend([(i, height - 1)
for i in xrange(1, width, 2)])
# Generate the new reduced tileset
for i, j in l:
# Put the tile in the new tileset
o_tile = arrangement[x + i, y + j].tile
n_tile = unused_tiles.pop()
self.chars_tileset.tiles[n_tile] = tileset[o_tile]
entry = TitleScreenLayoutEntry(i * 8 + x_offset,
j * 8 + y_offset,
n_tile, 0, unknown)
# Create a multi entry if possible to save space
if i < width - 1 and j < height - 1:
entry.set_single(True)
o_tile_r = arrangement[x + i + 1, y + j].tile
o_tile_d = arrangement[x + i, y + j + 1].tile
o_tile_dr = arrangement[x + i + 1, y + j + 1].tile
n_tile_r = n_tile + 1
n_tile_d = n_tile + 16
n_tile_dr = n_tile + 17
unused_tiles.difference_update(
(n_tile_r, n_tile_d, n_tile_dr))
self.chars_tileset.tiles[n_tile_r] = \
tileset[o_tile_r]
self.chars_tileset.tiles[n_tile_d] = \
tileset[o_tile_d]
self.chars_tileset.tiles[n_tile_dr] = \
tileset[o_tile_dr]
self.chars_layouts[c].append(entry)
self.chars_layouts[c][-1].set_final(True)
elif original_tileset != tileset:
log.warn("Tileset from characters frame {} does not match "
"tileset from characters frame 0.".format(p))
# Read the initial characters palette
with resource_open(CHARS_INITIAL_PATH, "png") as f:
image = open_indexed_image(f)
arrangement = EbTileArrangement(image.width / TILE_WIDTH,
image.height / TILE_HEIGHT)
tileset = EbGraphicTileset(CHARS_NUM_TILES, TILE_WIDTH,
TILE_HEIGHT)
self.chars_palette = EbPalette(NUM_SUBPALETTES,
ANIM_SUBPALETTE_LENGTH)
arrangement.from_image(image, tileset, self.chars_palette)
def __init__(self):
self.tileset = EbGraphicTileset(num_tiles=192, tile_width=8, tile_height=8)
self.palette = EbPalette(num_subpalettes=2, subpalette_length=4)
def read_from_rom(self, rom):
self.bg_table.from_block(
block=rom, offset=from_snes_address(BACKGROUND_TABLE_OFFSET))
self.scroll_table.from_block(
block=rom, offset=from_snes_address(SCROLL_TABLE_OFFSET))
self.distortion_table.from_block(
block=rom, offset=from_snes_address(DISTORTION_TABLE_OFFSET))
self.graphics_pointer_table.from_block(
block=rom,
offset=from_snes_address(
read_asm_pointer(
block=rom,
offset=GRAPHICS_POINTER_TABLE_ASM_POINTER_OFFSETS[0])))
self.arrangement_pointer_table.from_block(
block=rom,
offset=from_snes_address(
read_asm_pointer(
block=rom,
offset=ARRANGEMENT_POINTER_TABLE_ASM_POINTER_OFFSETS[0])))
self.palette_pointer_table.from_block(
block=rom,
offset=from_snes_address(
read_asm_pointer(
block=rom,
offset=PALETTE_POINTER_TABLE_ASM_POINTER_OFFSETS[0])))
self.backgrounds = [
None for i in range(self.graphics_pointer_table.num_rows)
]
self.palettes = [
None for i in range(self.palette_pointer_table.num_rows)
]
for i in range(self.bg_table.num_rows):
graphics_id = self.bg_table[i][0]
color_depth = self.bg_table[i][2]
if self.backgrounds[graphics_id] is None:
# Max tiles used in rom: 421 (2bpp) 442 (4bpp)
tileset = EbGraphicTileset(num_tiles=512,
tile_width=8,
tile_height=8)
with EbCompressibleBlock() as compressed_block:
compressed_block.from_compressed_block(
block=rom,
offset=from_snes_address(
self.graphics_pointer_table[graphics_id][0]))
tileset.from_block(compressed_block,
offset=0,
bpp=color_depth)
arrangement = EbTileArrangement(width=32, height=32)
with EbCompressibleBlock() as compressed_block:
compressed_block.from_compressed_block(
block=rom,
offset=from_snes_address(
self.arrangement_pointer_table[graphics_id][0]))
arrangement.from_block(block=compressed_block, offset=0)
self.backgrounds[graphics_id] = (tileset, color_depth,
arrangement)
palette_id = self.bg_table[i][1]
if self.palettes[palette_id] is None:
palette = EbPalette(num_subpalettes=1, subpalette_length=16)
palette.from_block(
block=rom,
offset=from_snes_address(
self.palette_pointer_table[palette_id][0]))
self.palettes[palette_id] = palette
def __init__(self, num_characters=96, tile_width=16, tile_height=8):
self.num_characters = num_characters
self.tileset = EbGraphicTileset(num_tiles=num_characters, tile_width=tile_width, tile_height=tile_height)
self.character_widths = None
def test_from_block_invalid(self):
tileset = EbGraphicTileset(num_tiles=1, tile_width=8, tile_height=16)
block = Block()
assert_raises(NotImplementedError, tileset.from_block, block, 0, 32)
assert_raises(NotImplementedError, tileset.from_block, block, 0, 2)
