diff options
Diffstat (limited to 'src/mame/video/dooyong.c')
-rw-r--r-- | src/mame/video/dooyong.c | 875 |
1 files changed, 875 insertions, 0 deletions
diff --git a/src/mame/video/dooyong.c b/src/mame/video/dooyong.c new file mode 100644 index 00000000000..4318fdbd6e7 --- /dev/null +++ b/src/mame/video/dooyong.c @@ -0,0 +1,875 @@ +#include "driver.h" + + +UINT8 *dooyong_txvideoram; + +static UINT8 sprites_disabled; /* Used by lastday/lastdaya */ +static UINT8 flytiger_pri; /* Used by flytiger */ +static UINT8 tx_pri; /* Used by sadari/gundl94/primella */ +static UINT16 rshark_pri; /* Used by rshark/superx/popbingo */ + +/* Up to four ROM-based and one RAM-based tilemap */ +static tilemap *bg_tilemap, *bg2_tilemap, *fg_tilemap, *fg2_tilemap; +static tilemap *tx_tilemap; + +/* Tilemap control registers */ +static UINT8 bgscroll8[0x10] = {0}, bg2scroll8[0x10] = {0}, fgscroll8[0x10] = {0}, fg2scroll8[0x10] = {0}; + +/* These are set at startup to configure the tilemap callbacks */ +static UINT8 *bg_tilerom, *bg2_tilerom, *fg_tilerom, *fg2_tilerom; +static UINT8 *bg_tilerom2, *bg2_tilerom2, *fg_tilerom2, *fg2_tilerom2; /* For rshark/superx */ +static int bg_gfx, bg2_gfx, fg_gfx, fg2_gfx; +static int tx_tilemap_mode; /* 0 = lastday/gulfstrm/pollux/flytiger; 1 = bluehawk/primella */ + + +/* All the dooyong games have the same tilemap control registers */ + +INLINE void dooyong_scroll8_w(offs_t offset, UINT8 data, UINT8 *scroll, tilemap *map) +{ + UINT8 old = scroll[offset]; + if (old != data) + { + scroll[offset] = data; + if (map != NULL) switch (offset) + { + case 0: /* Low byte of x scroll - scroll tilemap */ + tilemap_set_scrollx(map, 0, data); + break; + case 1: /* High byte of x scroll - mark tilemap dirty so new tile gfx will be loaded */ + tilemap_mark_all_tiles_dirty(map); + break; + case 3: /* Low byte of y scroll */ + case 4: /* High byte of y scroll */ + tilemap_set_scrolly(map, 0, (int)scroll[3] | ((int)scroll[4] << 8)); + break; + case 6: /* Tilemap enable and mode control */ + tilemap_set_enable(map, !(data & 0x10)); + if ((data & 0x20) != (old & 0x20)) // This sets the tilemap data format + tilemap_mark_all_tiles_dirty(map); + break; + default: /* Other addresses are used but function is unknown */ + /* 0x05 and 0x07 are initialised on startup */ + /* 0x02 is initialised on startup by some games and written to continuously by others */ + /*{ + const char *name; + if (scroll == bgscroll8) name = "bg"; + else if (scroll == bg2scroll8) name = "bg2"; + else if (scroll == fgscroll8) name = "fg"; + else if (scroll == fg2scroll8) name = "fg2"; + else name = "unknown"; + printf("Unknown %s tilemap control: 0x%02x = 0x%02x\n", name, (unsigned)offset, (unsigned)data); + }*/ + break; + } + } +} + + +/* These handle writes to the tilemap scroll registers in 8-bit machines. + There is one per tilemap, wrapping the above function that does the work. */ + +WRITE8_HANDLER( dooyong_bgscroll8_w ) +{ + dooyong_scroll8_w(offset, data, bgscroll8, bg_tilemap); +} + +static WRITE8_HANDLER( dooyong_bg2scroll8_w ) +{ + dooyong_scroll8_w(offset, data, bg2scroll8, bg2_tilemap); +} + +WRITE8_HANDLER( dooyong_fgscroll8_w ) +{ + dooyong_scroll8_w(offset, data, fgscroll8, fg_tilemap); +} + +WRITE8_HANDLER( dooyong_fg2scroll8_w ) +{ + dooyong_scroll8_w(offset, data, fg2scroll8, fg2_tilemap); +} + + +/* These handle writes to the tilemap scroll registers in 16-bit machines. + This is just an 8-bit peripheral in a 16-bit machine. */ + +WRITE16_HANDLER( dooyong_bgscroll16_w ) +{ + if (ACCESSING_LSB) dooyong_bgscroll8_w(offset, data & 0x00ff); +} + +WRITE16_HANDLER( dooyong_bg2scroll16_w ) +{ + if (ACCESSING_LSB) dooyong_bg2scroll8_w(offset, data & 0x00ff); +} + +WRITE16_HANDLER( dooyong_fgscroll16_w ) +{ + if (ACCESSING_LSB) dooyong_fgscroll8_w(offset, data & 0x00ff); +} + +WRITE16_HANDLER( dooyong_fg2scroll16_w ) +{ + if (ACCESSING_LSB) dooyong_fg2scroll8_w(offset, data & 0x00ff); +} + + +WRITE8_HANDLER( dooyong_txvideoram8_w ) +{ + if (dooyong_txvideoram[offset] != data) + { + dooyong_txvideoram[offset] = data; + if (tx_tilemap_mode == 0) + tilemap_mark_tile_dirty(tx_tilemap, offset & 0x07ff); + else + tilemap_mark_tile_dirty(tx_tilemap, offset >> 1); + } +} + + +/* Control registers seem to be different on every game */ + +WRITE8_HANDLER( lastday_ctrl_w ) +{ + /* bits 0 and 1 are coin counters */ + coin_counter_w(0, data & 0x01); + coin_counter_w(1, data & 0x02); + + /* bit 3 is used but unknown */ + + /* bit 4 disables sprites */ + sprites_disabled = data & 0x10; + + /* bit 6 is flip screen */ + flip_screen_set(data & 0x40); +} + +WRITE8_HANDLER( pollux_ctrl_w ) +{ + /* bit 0 is flip screen */ + flip_screen_set(data & 0x01); + + /* bits 6 and 7 are coin counters */ + coin_counter_w(0, data & 0x80); + coin_counter_w(1, data & 0x40); + + /* bit 1 is used but unknown */ + + /* bit 2 is continuously toggled (unknown) */ + + /* bit 4 is used but unknown */ +} + +WRITE8_HANDLER( primella_ctrl_w ) +{ + /* bits 0-2 select ROM bank */ + memory_set_bank(1, data & 0x07); + + /* bit 3 disables tx layer */ + tx_pri = data & 0x08; + + /* bit 4 flips screen */ + flip_screen_set(data & 0x10); + + /* bit 5 used but unknown */ + +// logerror("%04x: bankswitch = %02x\n",activecpu_get_pc(),data&0xe0); +} + +WRITE8_HANDLER( flytiger_ctrl_w ) +{ + /* bit 0 is flip screen */ + flip_screen_set(data & 0x01); + + /* bits 1, 2, 3 used but unknown */ + + /* bit 4 changes tilemaps priority */ + flytiger_pri = data & 0x10; +} + +WRITE16_HANDLER( rshark_ctrl_w ) +{ + if (ACCESSING_LSB) + { + /* bit 0 flips screen */ + flip_screen_set(data & 0x0001); + + /* bit 4 changes tilemaps priority */ + rshark_pri = data & 0x0010; + + /* bit 5 used but unknown */ + } +} + + +/* These games all have ROM-based tilemaps for the backgrounds, title + screens and sometimes "bosses" and special attacks. There are three + schemes for tilemap encoding. The scheme is chosen based on the + contents of the tilemap control variables declared above. + Note that although the tilemaps are arbitrarily wide (hundreds of + thousands of pixels, depending on the size of the ROM), we only + decode a 1024 pixel wide block at a time, and invalidate the tilemap + when the x scroll moves out of range (trying to decode the whole lot + at once uses hundreds of megabytes of RAM). */ + +INLINE void lastday_get_tile_info(running_machine *machine, tile_data *tileinfo, int tile_index, + const UINT8 *tilerom, UINT8 *scroll, int graphics) +{ + int offs = (tile_index + ((int)scroll[1] << 6)) * 2; + int attr = tilerom[offs]; + int code, color, flags; + if (scroll[6] & 0x20) + { /* lastday/gulfstrm/pollux/flytiger */ + /* Tiles take two bytes in ROM: + MSB LSB + [offs + 0x00] cCCC CYXc (bit 9 of gfx code, bits 3-0 of color, Y flip, X flip, bit 8 of gfx code) + [offs + 0x01] cccc cccc (bits 7-0 of gfx code) + c = gfx code + C = color code + X = x flip + Y = y flip */ + code = tilerom[offs + 1] | ((attr & 0x01) << 8) | ((attr & 0x80) << 2); + color = (attr & 0x78) >> 3; + flags = ((attr & 0x02) ? TILE_FLIPX : 0) | ((attr & 0x04) ? TILE_FLIPY : 0); + } + else + { /* primella/popbingo */ + /* Tiles take two bytes in ROM: + MSB LSB + [offs + 0x00] YXCC CCcc (Y flip, X flip, bits 3-0 of color code, bits 9-8 of gfx code) + [offs + 0x01] cccc cccc (bits 7-0 of gfx code) + c = gfx code + C = color code + X = x flip + Y = y flip */ + code = tilerom[offs + 1] | ((attr & 0x03) << 8); + color = (attr & 0x3c) >> 2; + flags = ((attr & 0x40) ? TILE_FLIPX : 0) | ((attr & 0x80) ? TILE_FLIPY : 0); + } + + SET_TILE_INFO(graphics, code, color, flags); +} + +INLINE void rshark_get_tile_info(running_machine *machine, tile_data *tileinfo, int tile_index, + const UINT8 *tilerom1, const UINT8 *tilerom2, UINT8 *scroll, int graphics) +{ + /* Tiles take two bytes in tile ROM 1: + MSB LSB + [offs + 0x00] YX?c cccc (Y flip, X flip, bits 12-8 of gfx code) + [offs + 0x01] cccc cccc (bits 7-0 of gfx code) + ? = unused/unknown + c = gfx code + X = x flip + Y = y flip */ + int offs = tile_index + ((int)scroll[1] << 9); + int attr = tilerom1[offs * 2]; + int code = tilerom1[(offs * 2) + 1] | ((attr & 0x1f) << 8); + int color = tilerom2[offs] & 0x0f; + int flags = ((attr & 0x40) ? TILE_FLIPX : 0) | ((attr & 0x80) ? TILE_FLIPY : 0); + + SET_TILE_INFO(graphics, code, color, flags); +} + +static TILE_GET_INFO( get_bg_tile_info ) +{ + if (bg_tilerom2 != NULL) + rshark_get_tile_info(machine, tileinfo, tile_index, bg_tilerom, bg_tilerom2, bgscroll8, bg_gfx); + else + lastday_get_tile_info(machine, tileinfo, tile_index, bg_tilerom, bgscroll8, bg_gfx); +} + +static TILE_GET_INFO( get_bg2_tile_info ) +{ + if (bg2_tilerom2 != NULL) + rshark_get_tile_info(machine, tileinfo, tile_index, bg2_tilerom, bg2_tilerom2, bg2scroll8, bg2_gfx); + else + lastday_get_tile_info(machine, tileinfo, tile_index, bg2_tilerom, bg2scroll8, bg2_gfx); +} + +static TILE_GET_INFO( get_fg_tile_info ) +{ + if (fg_tilerom2 != NULL) + rshark_get_tile_info(machine, tileinfo, tile_index, fg_tilerom, fg_tilerom2, fgscroll8, fg_gfx); + else + lastday_get_tile_info(machine, tileinfo, tile_index, fg_tilerom, fgscroll8, fg_gfx); +} + +static TILE_GET_INFO( get_fg2_tile_info ) +{ + if (fg2_tilerom2 != NULL) + rshark_get_tile_info(machine, tileinfo, tile_index, fg2_tilerom, fg2_tilerom2, fg2scroll8, fg2_gfx); + else + lastday_get_tile_info(machine, tileinfo, tile_index, fg2_tilerom, fg2scroll8, fg2_gfx); +} + +/* flytiger uses some palette banking technique or something, but we + don't know what it is. For now, this is the same as the code used + for the other layers (hence the really strange colour). */ + +static TILE_GET_INFO( flytiger_get_fg_tile_info ) +{ + const UINT8 *tilerom = fg_tilerom; + + int offs = (tile_index + (fgscroll8[1] << 6)) * 2; + int attr = tilerom[offs]; + int code = tilerom[offs + 1] | ((attr & 0x01) << 8) | ((attr & 0x80) << 2); + int color = (attr & 0x78) >> 3; //TODO: missing 4th bit or palette bank + int flags = ((attr & 0x02) ? TILE_FLIPX : 0) | ((attr & 0x04) ? TILE_FLIPY : 0); + + SET_TILE_INFO(fg_gfx, code, color, flags); +} + +static TILE_GET_INFO( get_tx_tile_info ) +{ + /* Each tile takes two bytes of memory: + MSB LSB + [offs + 0x00] cccc cccc (bits 7-0 of gfx code) + [offs + 0x01] CCCC cccc (bits 3-0 of color code, bits 11-8 of gfx code) + c = gfx code + C = color code */ + int offs, attr, code, color; + if (tx_tilemap_mode == 0) + { /* lastday/gulfstrm/pollux/flytiger */ + offs = tile_index; + attr = dooyong_txvideoram[offs | 0x0800]; + } + else + { /* bluehawk/primella */ + offs = tile_index * 2; + attr = dooyong_txvideoram[offs + 1]; + } + code = dooyong_txvideoram[offs] | ((attr & 0x0f) << 8); + color = (attr & 0xf0) >> 4; + + SET_TILE_INFO(0, code, color, 0); +} + + +static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect, int pollux_extensions) +{ + /* Sprites take 32 bytes each in memory: + MSB LSB + [offs + 0x00] cccc cccc (bits 7-0 of gfx code) + [offs + 0x01] cccx CCCC (bits 10-8 of gfx code, bit 8 of x position, bits 3-0 of color code) + [offs + 0x02] yyyy yyyy + [offs + 0x03] xxxx xxxx (bits 7-0 of x offset) + ... + [offs + 0x1c] ?hhh XY*c (bits 2-0 of height, x flip, y flip, * see note, bit 11 of gfx code) + ... + ? = unused/unknown + E = enable + c = gfx code + x = x position + y = y position + C = color code + w = width + X = x flip + Y = y flip + * = alters y position in pollux and flytiger - see code below + bit 11 of gfx code only used by gulfstrm, pollux, bluehawk and flytiger + height only used by pollux, bluehawk and flytiger + x flip and y flip only used by pollux and flytiger */ + + int offs; + + for (offs = 0; offs < spriteram_size; offs += 32) + { + int sx, sy, code, color, pri; + int flipx = 0, flipy = 0, height = 0, y; + + sx = buffered_spriteram[offs+3] | ((buffered_spriteram[offs+1] & 0x10) << 4); + sy = buffered_spriteram[offs+2]; + code = buffered_spriteram[offs] | ((buffered_spriteram[offs+1] & 0xe0) << 3); + color = buffered_spriteram[offs+1] & 0x0f; + //TODO: This priority mechanism works for known games, but seems a bit strange. + //Are we missing something? (The obvious spare palette bit isn't it.) + pri = (((color == 0x00) || (color == 0x0f)) ? 0xfc : 0xf0); + + if (pollux_extensions) + { + /* gulfstrm, pollux, bluehawk, flytiger */ + code |= ((buffered_spriteram[offs+0x1c] & 0x01) << 11); + + if (pollux_extensions >= 2) + { + /* pollux, bluehawk, flytiger */ + height = (buffered_spriteram[offs+0x1c] & 0x70) >> 4; + code &= ~height; + + if (pollux_extensions == 3) + { + /* bluehawk */ + sy += 6 - ((~buffered_spriteram[offs+0x1c] & 0x02) << 7); + flipx = buffered_spriteram[offs+0x1c] & 0x08; + flipy = buffered_spriteram[offs+0x1c] & 0x04; + } + + if (pollux_extensions == 4) + { + /* flytiger */ + sy -=(buffered_spriteram[offs+0x1c] & 0x02) << 7; + flipx = buffered_spriteram[offs+0x1c] & 0x08; + flipy = buffered_spriteram[offs+0x1c] & 0x04; + } + } + } + + if (flip_screen) + { + sx = 498 - sx; + sy = 240 - (16 * height) - sy; + flipx = !flipx; + flipy = !flipy; + } + + for (y = 0; y <= height; y++) + { + pdrawgfx(bitmap, machine->gfx[1], + code + y, + color, + flipx, flipy, + sx, sy + (16 * (flipy ? (height - y) : y)), + cliprect, TRANSPARENCY_PEN, 15, + pri); + } + } +} + +static void rshark_draw_sprites(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect) +{ + /* Sprites take 8 16-bit words each in memory: + MSB LSB + [offs + 0] ???? ???? ???? ???E + [offs + 1] ???? ???? hhhh wwww + [offs + 2] ???? ???? ???? ???? + [offs + 3] cccc cccc cccc cccc + [offs + 4] ???? ???x xxxx xxxx + [offs + 5] ???? ???? ???? ???? + [offs + 6] ???? ???y yyyy yyyy + [offs + 7] ???? ???? ???? CCCC + ? = unused/unknown + E = enable + c = gfx code + x = x offset + y = y offset (signed) + C = color code + w = width + h = height */ + + int offs; + + for (offs = (spriteram_size / 2) - 8; offs >= 0; offs -= 8) + { + if (buffered_spriteram16[offs] & 0x0001) /* enable */ + { + int sx, sy, code, color, pri; + int flipx = 0, flipy = 0, width, height, x, y; + + sx = buffered_spriteram16[offs+4] & 0x01ff; + sy = (INT16)buffered_spriteram16[offs+6] & 0x01ff; + if (sy & 0x0100) sy |= ~(int)0x01ff; // Correctly sign-extend 9-bit number + code = buffered_spriteram16[offs+3]; + color = buffered_spriteram16[offs+7] & 0x000f; + //TODO: This priority mechanism works for known games, but seems a bit strange. + //Are we missing something? (The obvious spare palette bit isn't it.) + pri = (((color == 0x00) || (color == 0x0f)) ? 0xfc : 0xf0); + width = buffered_spriteram16[offs+1] & 0x000f; + height = (buffered_spriteram16[offs+1] & 0x00f0) >> 4; + + if (flip_screen) + { + sx = 498 - (16 * width) - sx; + sy = 240 - (16 * height) - sy; + flipx = !flipx; + flipy = !flipy; + } + + for (y = 0; y <= height; y++) + { + int _y = sy + (16 * (flipy ? (height - y) : y)); + for (x = 0; x <= width; x++) + { + int _x = sx + (16 * (flipx ? (width - x) : x)); + pdrawgfx(bitmap, machine->gfx[0], + code, + color, + flipx, flipy, + _x, _y, + cliprect, TRANSPARENCY_PEN, 15, + pri); + code++; + } + } + } + } +} + + +VIDEO_UPDATE( lastday ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 2); + tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 4); + + if (!sprites_disabled) + draw_sprites(machine, bitmap, cliprect, 0); + return 0; +} + +VIDEO_UPDATE( gulfstrm ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 2); + tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 4); + + draw_sprites(machine, bitmap, cliprect, 1); + return 0; +} + +VIDEO_UPDATE( pollux ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 2); + tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 4); + + draw_sprites(machine, bitmap, cliprect, 2); + return 0; +} + +VIDEO_UPDATE( flytiger ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + if (flytiger_pri) + { + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 2); + } + else + { + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 2); + } + tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 4); + + draw_sprites(machine, bitmap, cliprect, 4); + return 0; +} + + +VIDEO_UPDATE( bluehawk ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 2); + tilemap_draw(bitmap, cliprect, fg2_tilemap, 0, 4); + tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 4); + + draw_sprites(machine, bitmap, cliprect, 3); + return 0; +} + +VIDEO_UPDATE( primella ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 0); + if (tx_pri) tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 0); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 0); + if (!tx_pri) tilemap_draw(bitmap, cliprect, tx_tilemap, 0, 0); + return 0; +} + +VIDEO_UPDATE( rshark ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + tilemap_draw(bitmap, cliprect, bg2_tilemap, 0, (rshark_pri ? 2 : 1)); + tilemap_draw(bitmap, cliprect, fg_tilemap, 0, 2); + tilemap_draw(bitmap, cliprect, fg2_tilemap, 0, 2); + + rshark_draw_sprites(machine, bitmap, cliprect); + return 0; +} + +VIDEO_UPDATE( popbingo ) +{ + fillbitmap(bitmap, get_black_pen(machine), cliprect); + fillbitmap(priority_bitmap, 0, cliprect); + + tilemap_draw(bitmap, cliprect, bg_tilemap, 0, 1); + + rshark_draw_sprites(machine, bitmap, cliprect); + return 0; +} + + +VIDEO_START( lastday ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX5); + fg_tilerom = memory_region(REGION_GFX6); + bg_tilerom2 = NULL; + fg_tilerom2 = NULL; + bg_gfx = 2; + fg_gfx = 3; + tx_tilemap_mode = 0; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg_tilemap = tilemap_create(get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + tx_tilemap = tilemap_create(get_tx_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 8, 8, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(tx_tilemap, 15); + + /* Text layer is offset on this machine */ + tilemap_set_scrolly(tx_tilemap, 0, 8); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(fgscroll8); + state_save_register_global(sprites_disabled); +} + +VIDEO_START( gulfstrm ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX5); + fg_tilerom = memory_region(REGION_GFX6); + bg_tilerom2 = NULL; + fg_tilerom2 = NULL; + bg_gfx = 2; + fg_gfx = 3; + tx_tilemap_mode = 0; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg_tilemap = tilemap_create(get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + tx_tilemap = tilemap_create(get_tx_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 8, 8, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(tx_tilemap, 15); + + /* Text layer is offset on this machine */ + tilemap_set_scrolly(tx_tilemap, 0, 8); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(fgscroll8); +} + +VIDEO_START( pollux ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX5); + fg_tilerom = memory_region(REGION_GFX6); + bg_tilerom2 = NULL; + fg_tilerom2 = NULL; + bg_gfx = 2; + fg_gfx = 3; + tx_tilemap_mode = 0; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg_tilemap = tilemap_create(get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + tx_tilemap = tilemap_create(get_tx_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 8, 8, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(tx_tilemap, 15); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(fgscroll8); +} + +VIDEO_START( bluehawk ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX3) + 0x78000; + fg_tilerom = memory_region(REGION_GFX4) + 0x78000; + fg2_tilerom = memory_region(REGION_GFX5) + 0x38000; + bg_tilerom2 = NULL; + fg_tilerom2 = NULL; + fg2_tilerom2 = NULL; + bg_gfx = 2; + fg_gfx = 3; + fg2_gfx = 4; + tx_tilemap_mode = 1; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg_tilemap = tilemap_create(get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg2_tilemap = tilemap_create(get_fg2_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + tx_tilemap = tilemap_create(get_tx_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 8, 8, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(fg2_tilemap, 15); + tilemap_set_transparent_pen(tx_tilemap, 15); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(fgscroll8); + state_save_register_global_array(fg2scroll8); +} + +VIDEO_START( flytiger ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX3) + 0x78000; + fg_tilerom = memory_region(REGION_GFX4) + 0x78000; + bg_tilerom2 = NULL; + fg_tilerom2 = NULL; + bg_gfx = 2; + fg_gfx = 3; + tx_tilemap_mode = 0; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg_tilemap = tilemap_create(flytiger_get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + tx_tilemap = tilemap_create(get_tx_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 8, 8, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(bg_tilemap, 15); + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(tx_tilemap, 15); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(fgscroll8); + state_save_register_global(flytiger_pri); +} + +VIDEO_START( primella ) +{ + /* Configure memory banking */ + memory_configure_bank(1, 0, 8, memory_region(REGION_CPU1) + 0x10000, 0x4000); + + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX2) + memory_region_length(REGION_GFX2) - 0x8000; + fg_tilerom = memory_region(REGION_GFX3) + memory_region_length(REGION_GFX3) - 0x8000; + bg_tilerom2 = NULL; + fg_tilerom2 = NULL; + bg_gfx = 1; + fg_gfx = 2; + tx_tilemap_mode = 1; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + fg_tilemap = tilemap_create(get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + tx_tilemap = tilemap_create(get_tx_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 8, 8, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(tx_tilemap, 15); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(fgscroll8); + state_save_register_global(tx_pri); +} + +VIDEO_START( rshark ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX5); + bg2_tilerom = memory_region(REGION_GFX4); + fg_tilerom = memory_region(REGION_GFX3); + fg2_tilerom = memory_region(REGION_GFX2); + bg_tilerom2 = memory_region(REGION_GFX6) + 0x60000; + bg2_tilerom2 = memory_region(REGION_GFX6) + 0x40000; + fg_tilerom2 = memory_region(REGION_GFX6) + 0x20000; + fg2_tilerom2 = memory_region(REGION_GFX6) + 0x00000; + bg_gfx = 4; + bg2_gfx = 3; + fg_gfx = 2; + fg2_gfx = 1; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 16, 16, 64, 32); + bg2_tilemap = tilemap_create(get_bg2_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 16, 16, 64, 32); + fg_tilemap = tilemap_create(get_fg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 16, 16, 64, 32); + fg2_tilemap = tilemap_create(get_fg2_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 16, 16, 64, 32); + + /* Configure tilemap transparency */ + tilemap_set_transparent_pen(bg2_tilemap, 15); + tilemap_set_transparent_pen(fg_tilemap, 15); + tilemap_set_transparent_pen(fg2_tilemap, 15); + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(bg2scroll8); + state_save_register_global_array(fgscroll8); + state_save_register_global_array(fg2scroll8); + state_save_register_global(rshark_pri); +} + +VIDEO_START( popbingo ) +{ + /* Configure tilemap callbacks */ + bg_tilerom = memory_region(REGION_GFX2); + bg_gfx = 1; + + /* Create tilemaps */ + bg_tilemap = tilemap_create(get_bg_tile_info, tilemap_scan_cols, + TILEMAP_TYPE_PEN, 32, 32, 32, 8); + bg2_tilemap = fg_tilemap = fg2_tilemap = NULL; /* Stop scroll handler from crashing on these */ + + /* Register for save/restore */ + state_save_register_global_array(bgscroll8); + state_save_register_global_array(bg2scroll8); // Not used atm + state_save_register_global_array(fgscroll8); // Not used atm + state_save_register_global_array(fg2scroll8); // Not used atm + state_save_register_global(rshark_pri); +} + + +VIDEO_EOF( dooyong ) +{ + buffer_spriteram_w(0, 0); +} + +VIDEO_EOF( rshark ) +{ + buffer_spriteram16_w(0, 0, 0); +} |