Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-29 00:53:09 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Forgot to commit this: Added driver_data struct to aeroboto.c

Browse Source
This commit is contained in:
Fabio Priuli 2009-11-18 23:26:26 +00:00
parent df5e775183
commit 69e98c3a1e
4 changed files with 183 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitattributes vendored
View File

@ -2294,6 +2294,7 @@ src/mame/includes/1943.h svneol=native#text/plain
src/mame/includes/20pacgal.h svneol=native#text/plain src/mame/includes/20pacgal.h svneol=native#text/plain
src/mame/includes/4enraya.h svneol=native#text/plain src/mame/includes/4enraya.h svneol=native#text/plain
src/mame/includes/8080bw.h svneol=native#text/plain src/mame/includes/8080bw.h svneol=native#text/plain
src/mame/includes/aeroboto.h svneol=native#text/plain
src/mame/includes/aerofgt.h svneol=native#text/plain src/mame/includes/aerofgt.h svneol=native#text/plain
src/mame/includes/ajax.h svneol=native#text/plain src/mame/includes/ajax.h svneol=native#text/plain
src/mame/includes/amiga.h svneol=native#text/plain src/mame/includes/amiga.h svneol=native#text/plain

86
src/mame/drivers/aeroboto.c
View File

@ -25,74 +25,67 @@ Revisions:
#include "driver.h" #include "driver.h"
#include "cpu/m6809/m6809.h" #include "cpu/m6809/m6809.h"
#include "sound/ay8910.h" #include "sound/ay8910.h"
#include "aeroboto.h"
extern UINT8 *aeroboto_videoram;
extern UINT8 *aeroboto_hscroll, *aeroboto_vscroll, *aeroboto_tilecolor;
extern UINT8 *aeroboto_starx, *aeroboto_stary, *aeroboto_bgcolor;
VIDEO_START( aeroboto );
VIDEO_UPDATE( aeroboto );
READ8_HANDLER( aeroboto_in0_r );
WRITE8_HANDLER( aeroboto_3000_w );
WRITE8_HANDLER( aeroboto_videoram_w );
WRITE8_HANDLER( aeroboto_tilecolor_w );
static UINT8 *aeroboto_mainram;
static int disable_irq = 0;
static READ8_HANDLER( aeroboto_201_r ) static READ8_HANDLER( aeroboto_201_r )
{ {
aeroboto_state *state = (aeroboto_state *)space->machine->driver_data;
/* if you keep a button pressed during boot, the game will expect this */ /* if you keep a button pressed during boot, the game will expect this */
/* serie of values to be returned from 3004, and display "PASS 201" if it is */ /* serie of values to be returned from 3004, and display "PASS 201" if it is */
static const UINT8 res[4] = { 0xff, 0x9f, 0x1b, 0x03 }; static const UINT8 res[4] = { 0xff, 0x9f, 0x1b, 0x03 };
static int count;
logerror("PC %04x: read 3004\n", cpu_get_pc(space->cpu)); logerror("PC %04x: read 3004\n", cpu_get_pc(space->cpu));
return res[(count++)&3]; return res[(state->count++) & 3];
} }
static INTERRUPT_GEN( aeroboto_interrupt ) static INTERRUPT_GEN( aeroboto_interrupt )
{ {
if (!disable_irq) aeroboto_state *state = (aeroboto_state *)device->machine->driver_data;
if (!state->disable_irq)
cpu_set_input_line(device, 0, HOLD_LINE); cpu_set_input_line(device, 0, HOLD_LINE);
else else
disable_irq--; state->disable_irq--;
} }
static READ8_HANDLER( aeroboto_2973_r ) static READ8_HANDLER( aeroboto_2973_r )
{ {
aeroboto_mainram[0x02be] = 0; aeroboto_state *state = (aeroboto_state *)space->machine->driver_data;
return(0xff);
state->mainram[0x02be] = 0;
return 0xff;
} }
static WRITE8_HANDLER ( aeroboto_1a2_w ) static WRITE8_HANDLER ( aeroboto_1a2_w )
{ {
aeroboto_mainram[0x01a2] = data; aeroboto_state *state = (aeroboto_state *)space->machine->driver_data;
if (data) disable_irq = 1;
state->mainram[0x01a2] = data;
if (data)
state->disable_irq = 1;
} }
static ADDRESS_MAP_START( main_map, ADDRESS_SPACE_PROGRAM, 8 ) static ADDRESS_MAP_START( main_map, ADDRESS_SPACE_PROGRAM, 8 )
AM_RANGE(0x01a2, 0x01a2) AM_WRITE(aeroboto_1a2_w) // affects IRQ line (more protection?) AM_RANGE(0x01a2, 0x01a2) AM_WRITE(aeroboto_1a2_w) // affects IRQ line (more protection?)
AM_RANGE(0x0000, 0x07ff) AM_RAM AM_BASE(&aeroboto_mainram) // main RAM AM_RANGE(0x0000, 0x07ff) AM_RAM AM_BASE_MEMBER(aeroboto_state, mainram) // main RAM
AM_RANGE(0x0800, 0x08ff) AM_RAM // tile color buffer; copied to 0x2000 AM_RANGE(0x0800, 0x08ff) AM_RAM // tile color buffer; copied to 0x2000
AM_RANGE(0x0900, 0x09ff) AM_WRITEONLY // a backup of default tile colors AM_RANGE(0x0900, 0x09ff) AM_WRITEONLY // a backup of default tile colors
AM_RANGE(0x1000, 0x17ff) AM_RAM_WRITE(aeroboto_videoram_w) AM_BASE(&aeroboto_videoram) // tile RAM AM_RANGE(0x1000, 0x17ff) AM_RAM_WRITE(aeroboto_videoram_w) AM_BASE_MEMBER(aeroboto_state, videoram) // tile RAM
AM_RANGE(0x1800, 0x183f) AM_RAM AM_BASE(&aeroboto_hscroll) // horizontal scroll regs AM_RANGE(0x1800, 0x183f) AM_RAM AM_BASE_MEMBER(aeroboto_state, hscroll) // horizontal scroll regs
AM_RANGE(0x2000, 0x20ff) AM_RAM_WRITE(aeroboto_tilecolor_w) AM_BASE(&aeroboto_tilecolor) // tile color RAM AM_RANGE(0x2000, 0x20ff) AM_RAM_WRITE(aeroboto_tilecolor_w) AM_BASE_MEMBER(aeroboto_state, tilecolor) // tile color RAM
AM_RANGE(0x1840, 0x27ff) AM_WRITENOP // cleared during custom LSI test AM_RANGE(0x1840, 0x27ff) AM_WRITENOP // cleared during custom LSI test
AM_RANGE(0x2800, 0x28ff) AM_RAM AM_BASE(&spriteram) AM_SIZE(&spriteram_size) // sprite RAM AM_RANGE(0x2800, 0x28ff) AM_RAM AM_BASE_MEMBER(aeroboto_state, spriteram) AM_SIZE(&spriteram_size) // sprite RAM
AM_RANGE(0x2900, 0x2fff) AM_WRITENOP // cleared along with sprite RAM AM_RANGE(0x2900, 0x2fff) AM_WRITENOP // cleared along with sprite RAM
AM_RANGE(0x2973, 0x2973) AM_READ(aeroboto_2973_r) // protection read AM_RANGE(0x2973, 0x2973) AM_READ(aeroboto_2973_r) // protection read
AM_RANGE(0x3000, 0x3000) AM_READWRITE(aeroboto_in0_r, aeroboto_3000_w) AM_RANGE(0x3000, 0x3000) AM_READWRITE(aeroboto_in0_r, aeroboto_3000_w)
AM_RANGE(0x3001, 0x3001) AM_READ_PORT("DSW1") AM_WRITE(soundlatch_w) AM_RANGE(0x3001, 0x3001) AM_READ_PORT("DSW1") AM_WRITE(soundlatch_w)
AM_RANGE(0x3002, 0x3002) AM_READ_PORT("DSW2") AM_WRITE(soundlatch2_w) AM_RANGE(0x3002, 0x3002) AM_READ_PORT("DSW2") AM_WRITE(soundlatch2_w)
AM_RANGE(0x3003, 0x3003) AM_WRITEONLY AM_BASE(&aeroboto_vscroll) AM_RANGE(0x3003, 0x3003) AM_WRITEONLY AM_BASE_MEMBER(aeroboto_state, vscroll)
AM_RANGE(0x3004, 0x3004) AM_READ(aeroboto_201_r) AM_WRITEONLY AM_BASE(&aeroboto_starx) AM_RANGE(0x3004, 0x3004) AM_READ(aeroboto_201_r) AM_WRITEONLY AM_BASE_MEMBER(aeroboto_state, starx)
AM_RANGE(0x3005, 0x3005) AM_WRITEONLY AM_BASE(&aeroboto_stary) // usable but probably wrong AM_RANGE(0x3005, 0x3005) AM_WRITEONLY AM_BASE_MEMBER(aeroboto_state, stary) // usable but probably wrong
AM_RANGE(0x3006, 0x3006) AM_WRITEONLY AM_BASE(&aeroboto_bgcolor) AM_RANGE(0x3006, 0x3006) AM_WRITEONLY AM_BASE_MEMBER(aeroboto_state, bgcolor)
AM_RANGE(0x3800, 0x3800) AM_READNOP // watchdog or IRQ ack AM_RANGE(0x3800, 0x3800) AM_READNOP // watchdog or IRQ ack
AM_RANGE(0x4000, 0xffff) AM_ROM // main ROM AM_RANGE(0x4000, 0xffff) AM_ROM // main ROM
ADDRESS_MAP_END ADDRESS_MAP_END
@ -229,11 +222,35 @@ static const ay8910_interface ay8910_config =
static MACHINE_START( formatz ) static MACHINE_START( formatz )
{ {
state_save_register_global(machine, disable_irq); aeroboto_state *state = (aeroboto_state *)machine->driver_data;
state->stars_rom = memory_region(machine, "gfx2");
state->stars_length = memory_region_length(machine, "gfx2");
state_save_register_global(machine, state->disable_irq);
state_save_register_global(machine, state->count);
}
static MACHINE_RESET( formatz )
{
aeroboto_state *state = (aeroboto_state *)machine->driver_data;
state->disable_irq = 0;
state->count = 0;
state->charbank = 0;
state->starsoff = 0;
state->ox = 0;
state->oy = 0;
state->sx = 0;
state->sy = 0;
} }
static MACHINE_DRIVER_START( formatz ) static MACHINE_DRIVER_START( formatz )
/* driver data */
MDRV_DRIVER_DATA(aeroboto_state)
/* basic machine hardware */ /* basic machine hardware */
MDRV_CPU_ADD("maincpu", M6809, XTAL_10MHz/8) /* verified on pcb */ MDRV_CPU_ADD("maincpu", M6809, XTAL_10MHz/8) /* verified on pcb */
MDRV_CPU_PROGRAM_MAP(main_map) MDRV_CPU_PROGRAM_MAP(main_map)
@ -244,6 +261,7 @@ static MACHINE_DRIVER_START( formatz )
MDRV_CPU_VBLANK_INT("screen", irq0_line_hold) MDRV_CPU_VBLANK_INT("screen", irq0_line_hold)
MDRV_MACHINE_START(formatz) MDRV_MACHINE_START(formatz)
MDRV_MACHINE_RESET(formatz)
/* video hardware */ /* video hardware */
MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_ADD("screen", RASTER)

45
src/mame/includes/aeroboto.h Normal file
View File

@ -0,0 +1,45 @@
/***************************************************************************
Aeroboto
***************************************************************************/
typedef struct _aeroboto_state aeroboto_state;
struct _aeroboto_state
{
/* memory pointers */
UINT8 * mainram;
UINT8 * spriteram;
UINT8 * videoram;
UINT8 * hscroll;
UINT8 * vscroll;
UINT8 * tilecolor;
UINT8 * starx;
UINT8 * stary;
UINT8 * bgcolor;
/* stars layout */
UINT8 * stars_rom;
int stars_length;
/* video-related */
tilemap *bg_tilemap;
int charbank, starsoff;
int sx, sy;
UINT8 ox, oy;
/* misc */
int count;
int disable_irq;
};
/*----------- defined in video/aeroboto.c -----------*/
VIDEO_START( aeroboto );
VIDEO_UPDATE( aeroboto );
READ8_HANDLER( aeroboto_in0_r );
WRITE8_HANDLER( aeroboto_3000_w );
WRITE8_HANDLER( aeroboto_videoram_w );
WRITE8_HANDLER( aeroboto_tilecolor_w );

135
src/mame/video/aeroboto.c
View File

@ -1,4 +1,12 @@
/***************************************************************************
video/aeroboto.c
***************************************************************************/
#include "driver.h" #include "driver.h"
#include "aeroboto.h"
// how the starfield ROM is interpreted: 0=256x256x1 linear bitmap, 1=8x8x1x1024 tilemap // how the starfield ROM is interpreted: 0=256x256x1 linear bitmap, 1=8x8x1x1024 tilemap
@ -7,15 +15,6 @@
// scroll speed of the stars: 1=normal, 2=half, 3=one-third...etc.(possitive integers only) // scroll speed of the stars: 1=normal, 2=half, 3=one-third...etc.(possitive integers only)
#define SCROLL_SPEED 1 #define SCROLL_SPEED 1
UINT8 *aeroboto_videoram;
UINT8 *aeroboto_hscroll, *aeroboto_vscroll, *aeroboto_tilecolor;
UINT8 *aeroboto_starx, *aeroboto_stary, *aeroboto_bgcolor;
static int aeroboto_charbank, aeroboto_starsoff;
static tilemap *bg_tilemap;
/*************************************************************************** /***************************************************************************
Callbacks for the TileMap code Callbacks for the TileMap code
@ -24,12 +23,13 @@ static tilemap *bg_tilemap;
static TILE_GET_INFO( get_tile_info ) static TILE_GET_INFO( get_tile_info )
{ {
UINT8 code = aeroboto_videoram[tile_index]; aeroboto_state *state = (aeroboto_state *)machine->driver_data;
UINT8 code = state->videoram[tile_index];
SET_TILE_INFO( SET_TILE_INFO(
0, 0,
code + (aeroboto_charbank << 8), code + (state->charbank << 8),
aeroboto_tilecolor[code], state->tilecolor[code],
(aeroboto_tilecolor[code] >= 0x33) ? 0 : TILE_FORCE_LAYER0); (state->tilecolor[code] >= 0x33) ? 0 : TILE_FORCE_LAYER0);
} }
// transparency should only affect tiles with color 0x33 or higher // transparency should only affect tiles with color 0x33 or higher
@ -42,26 +42,29 @@ static TILE_GET_INFO( get_tile_info )
VIDEO_START( aeroboto ) VIDEO_START( aeroboto )
{ {
bg_tilemap = tilemap_create(machine, get_tile_info,tilemap_scan_rows,8,8,32,64); aeroboto_state *state = (aeroboto_state *)machine->driver_data;
tilemap_set_transparent_pen(bg_tilemap,0); state->bg_tilemap = tilemap_create(machine, get_tile_info, tilemap_scan_rows, 8, 8, 32, 64);
tilemap_set_transparent_pen(state->bg_tilemap, 0);
tilemap_set_scroll_rows(state->bg_tilemap, 64);
tilemap_set_scroll_rows(bg_tilemap,64); state_save_register_global(machine, state->charbank);
state_save_register_global(machine, state->starsoff);
state_save_register_global(machine, aeroboto_charbank); state_save_register_global(machine, state->sx);
state_save_register_global(machine, aeroboto_starsoff); state_save_register_global(machine, state->sy);
state_save_register_global(machine, state->ox);
state_save_register_global(machine, state->oy);
#if STARS_LAYOUT #if STARS_LAYOUT
{ {
UINT8 *rom, *temp; UINT8 *temp;
int i, length; int i;
rom = memory_region(machine, "gfx2"); temp = alloc_array_or_die(UINT8, state->stars_length);
length = memory_region_length(machine, "gfx2"); memcpy(temp, state->stars_rom, state->stars_length);
temp = alloc_array_or_die(UINT8, length);
memcpy(temp, rom, length);
for (i=0; i<length; i++) rom[(i&~0xff)+(i<<5&0xe0)+(i>>3&0x1f)] = temp[i]; for (i = 0; i < state->stars_length; i++)
state->stars_rom[(i & ~0xff) + (i << 5 & 0xe0) + (i >> 3 & 0x1f)] = temp[i];
free(temp); free(temp);
} }
@ -83,32 +86,38 @@ READ8_HANDLER( aeroboto_in0_r )
WRITE8_HANDLER( aeroboto_3000_w ) WRITE8_HANDLER( aeroboto_3000_w )
{ {
aeroboto_state *state = (aeroboto_state *)space->machine->driver_data;
/* bit 0 selects both flip screen and player1/player2 controls */ /* bit 0 selects both flip screen and player1/player2 controls */
flip_screen_set(space->machine, data & 0x01); flip_screen_set(space->machine, data & 0x01);
/* bit 1 = char bank select */ /* bit 1 = char bank select */
if (aeroboto_charbank != ((data & 0x02) >> 1)) if (state->charbank != ((data & 0x02) >> 1))
{ {
tilemap_mark_all_tiles_dirty(bg_tilemap); tilemap_mark_all_tiles_dirty(state->bg_tilemap);
aeroboto_charbank = (data & 0x02) >> 1; state->charbank = (data & 0x02) >> 1;
} }
/* bit 2 = disable star field? */ /* bit 2 = disable star field? */
aeroboto_starsoff = data & 0x4; state->starsoff = data & 0x4;
} }
WRITE8_HANDLER( aeroboto_videoram_w ) WRITE8_HANDLER( aeroboto_videoram_w )
{ {
aeroboto_videoram[offset] = data; aeroboto_state *state = (aeroboto_state *)space->machine->driver_data;
tilemap_mark_tile_dirty(bg_tilemap,offset);
state->videoram[offset] = data;
tilemap_mark_tile_dirty(state->bg_tilemap,offset);
} }
WRITE8_HANDLER( aeroboto_tilecolor_w ) WRITE8_HANDLER( aeroboto_tilecolor_w )
{ {
if (aeroboto_tilecolor[offset] != data) aeroboto_state *state = (aeroboto_state *)space->machine->driver_data;
if (state->tilecolor[offset] != data)
{ {
aeroboto_tilecolor[offset] = data; state->tilecolor[offset] = data;
tilemap_mark_all_tiles_dirty(bg_tilemap); tilemap_mark_all_tiles_dirty(state->bg_tilemap);
} }
} }
@ -122,12 +131,13 @@ WRITE8_HANDLER( aeroboto_tilecolor_w )
static void draw_sprites( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect ) static void draw_sprites( running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect )
{ {
aeroboto_state *state = (aeroboto_state *)machine->driver_data;
int offs; int offs;
for (offs = 0; offs < spriteram_size; offs += 4) for (offs = 0; offs < spriteram_size; offs += 4)
{ {
int x = spriteram[offs+3]; int x = state->spriteram[offs + 3];
int y = 240 - spriteram[offs]; int y = 240 - state->spriteram[offs];
if (flip_screen_get(machine)) if (flip_screen_get(machine))
{ {
@ -136,8 +146,8 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
} }
drawgfx_transpen(bitmap, cliprect, machine->gfx[1], drawgfx_transpen(bitmap, cliprect, machine->gfx[1],
spriteram[offs+1], state->spriteram[offs + 1],
spriteram[offs+2] & 0x07, state->spriteram[offs + 2] & 0x07,
flip_screen_get(machine), flip_screen_get(machine), flip_screen_get(machine), flip_screen_get(machine),
((x + 8) & 0xff) - 8, y, 0); ((x + 8) & 0xff) - 8, y, 0);
} }
@ -146,33 +156,39 @@ static void draw_sprites(running_machine *machine, bitmap_t *bitmap, const recta
VIDEO_UPDATE( aeroboto ) VIDEO_UPDATE( aeroboto )
{ {
aeroboto_state *state = (aeroboto_state *)screen->machine->driver_data;
static const rectangle splitrect1 = { 0, 255, 0, 39 }; static const rectangle splitrect1 = { 0, 255, 0, 39 };
static const rectangle splitrect2 = { 0, 255, 40, 255 }; static const rectangle splitrect2 = { 0, 255, 40, 255 };
static int sx=0, sy=0;
static UINT8 ox=0, oy=0;
UINT8 *src_base, *src_colptr, *src_rowptr; UINT8 *src_base, *src_colptr, *src_rowptr;
int src_offsx, src_colmask, sky_color, star_color, x, y, i, j, pen; int src_offsx, src_colmask, sky_color, star_color, x, y, i, j, pen;
sky_color = star_color = *aeroboto_bgcolor << 2; sky_color = star_color = *state->bgcolor << 2;
// the star field is supposed to be seen through tile pen 0 when active // the star field is supposed to be seen through tile pen 0 when active
if (!aeroboto_starsoff) if (!state->starsoff)
{ {
if (star_color < 0xd0) { star_color = 0xd0; sky_color = 0; } if (star_color < 0xd0)
{
star_color = 0xd0;
sky_color = 0;
}
star_color += 2; star_color += 2;
bitmap_fill(bitmap, cliprect, sky_color); bitmap_fill(bitmap, cliprect, sky_color);
// actual scroll speed is unknown but it can be adjusted by changing the SCROLL_SPEED constant // actual scroll speed is unknown but it can be adjusted by changing the SCROLL_SPEED constant
sx += (char)(*aeroboto_starx - ox); state->sx += (char)(*state->starx - state->ox);
ox = *aeroboto_starx; state->ox = *state->starx;
x = sx / SCROLL_SPEED; x = state->sx / SCROLL_SPEED;
if (*aeroboto_vscroll != 0xff) sy += (char)(*aeroboto_stary - oy); if (*state->vscroll != 0xff)
oy = *aeroboto_stary; state->sy += (char)(*state->stary - state->oy);
y = sy / SCROLL_SPEED; state->oy = *state->stary;
y = state->sy / SCROLL_SPEED;
src_base = memory_region(screen->machine, "gfx2"); src_base = state->stars_rom;
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
@ -185,28 +201,29 @@ VIDEO_UPDATE( aeroboto )
for (j = 0; j < 256; j++) for (j = 0; j < 256; j++)
{ {
src_rowptr = src_colptr + (((y + j) & 0xff) << 5 ); src_rowptr = src_colptr + (((y + j) & 0xff) << 5 );
if (!((unsigned)*src_rowptr & src_colmask)) *BITMAP_ADDR16(bitmap, j, i) = pen; if (!((unsigned)*src_rowptr & src_colmask))
*BITMAP_ADDR16(bitmap, j, i) = pen;
} }
} }
} }
else else
{ {
sx = ox = *aeroboto_starx; state->sx = state->ox = *state->starx;
sy = oy = *aeroboto_stary; state->sy = state->oy = *state->stary;
bitmap_fill(bitmap, cliprect, sky_color); bitmap_fill(bitmap, cliprect, sky_color);
} }
for (y = 0; y < 64; y++) for (y = 0; y < 64; y++)
tilemap_set_scrollx(bg_tilemap,y,aeroboto_hscroll[y]); tilemap_set_scrollx(state->bg_tilemap, y, state->hscroll[y]);
// the playfield is part of a splitscreen and should not overlap with status display // the playfield is part of a splitscreen and should not overlap with status display
tilemap_set_scrolly(bg_tilemap,0,*aeroboto_vscroll); tilemap_set_scrolly(state->bg_tilemap, 0, *state->vscroll);
tilemap_draw(bitmap,&splitrect2,bg_tilemap,0,0); tilemap_draw(bitmap, &splitrect2, state->bg_tilemap, 0, 0);
draw_sprites(screen->machine, bitmap, cliprect); draw_sprites(screen->machine, bitmap, cliprect);
// the status display behaves more closely to a 40-line splitscreen than an overlay // the status display behaves more closely to a 40-line splitscreen than an overlay
tilemap_set_scrolly(bg_tilemap,0,0); tilemap_set_scrolly(state->bg_tilemap, 0, 0);
tilemap_draw(bitmap,&splitrect1,bg_tilemap,0,0); tilemap_draw(bitmap, &splitrect1, state->bg_tilemap, 0, 0);
return 0; return 0;
} }