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)