From 58f0e8c7c23b8e47d1331647111d5bfdaa4f0ee5 Mon Sep 17 00:00:00 2001 From: Fabio Priuli Date: Wed, 9 Dec 2009 16:04:47 +0000 Subject: [PATCH] Added driver data struct and save states to: jangou.c, jantotsu.c, jollyjgr.c and jongkyo.c --- src/mame/drivers/jangou.c | 354 +++++++++++++++++++++++++----------- src/mame/drivers/jantotsu.c | 229 ++++++++++++++++------- src/mame/drivers/jollyjgr.c | 222 +++++++++++++++------- src/mame/drivers/jongkyo.c | 231 +++++++++++++++-------- 4 files changed, 725 insertions(+), 311 deletions(-) diff --git a/src/mame/drivers/jangou.c b/src/mame/drivers/jangou.c index 988827bc439..2e406b27907 100644 --- a/src/mame/drivers/jangou.c +++ b/src/mame/drivers/jangou.c @@ -2,7 +2,7 @@ Jangou (c) 1983 Nichibutsu -driver by David Haywood,Angelo Salese and Phil Bennett +driver by David Haywood, Angelo Salese and Phil Bennett TODO: -unemulated screen flipping; @@ -33,18 +33,33 @@ $c088-$c095 player tiles #define MASTER_CLOCK XTAL_19_968MHz -static UINT8 *blit_buffer; -static UINT8 pen_data[0x10]; -static UINT8 blit_data[6]; +typedef struct _jangou_state jangou_state; +struct _jangou_state +{ + /* video-related */ + UINT8 *blit_buffer; + UINT8 pen_data[0x10]; + UINT8 blit_data[6]; -/* Jangou CVSD Sound */ -static emu_timer *cvsd_bit_timer; -static UINT8 cvsd_shiftreg; -static int cvsd_shift_cnt; + /* sound-related */ + // Jangou CVSD Sound + emu_timer *cvsd_bit_timer; + UINT8 cvsd_shiftreg; + int cvsd_shift_cnt; + // Jangou Lady ADPCM Sound + UINT8 adpcm_byte; + int msm5205_vclk_toggle; -/* Jangou Lady ADPCM Sound */ -static UINT8 adpcm_byte; -static int msm5205_vclk_toggle; + /* misc */ + UINT8 mux_data; + UINT8 nsc_latch, z80_latch; + + /* devices */ + const device_config *cpu_0; + const device_config *cpu_1; + const device_config *cvsd; + const device_config *nsc; +}; /************************************* @@ -62,7 +77,7 @@ static PALETTE_INIT( jangou ) int i; /* compute the color output resistor weights */ - compute_resistor_weights(0, 255, -1.0, + compute_resistor_weights(0, 255, -1.0, 3, resistances_rg, weights_rg, 0, 0, 2, resistances_b, weights_b, 0, 0, 0, 0, 0, 0, 0); @@ -95,16 +110,20 @@ static PALETTE_INIT( jangou ) static VIDEO_START( jangou ) { - blit_buffer = auto_alloc_array(machine, UINT8, 256*256); + jangou_state *state = (jangou_state *)machine->driver_data; + + state->blit_buffer = auto_alloc_array(machine, UINT8, 256 * 256); + state_save_register_global_pointer(machine, state->blit_buffer, 256 * 256); } static VIDEO_UPDATE( jangou ) { + jangou_state *state = (jangou_state *)screen->machine->driver_data; int x, y; for (y = cliprect->min_y; y <= cliprect->max_y; ++y) { - UINT8 *src = &blit_buffer[y * 512/2 + cliprect->min_x]; + UINT8 *src = &state->blit_buffer[y * 512 / 2 + cliprect->min_x]; UINT16 *dst = BITMAP_ADDR16(bitmap, y, cliprect->min_x); for (x = cliprect->min_x; x <= cliprect->max_x; x += 2) @@ -129,78 +148,76 @@ h [$16] w [$17] */ -static UINT8 jangou_gfx_nibble(running_machine *machine,UINT16 niboffset) +static UINT8 jangou_gfx_nibble( running_machine *machine, UINT16 niboffset ) { - const UINT8 *const blit_rom = memory_region(machine,"gfx"); + const UINT8 *const blit_rom = memory_region(machine, "gfx"); - if (niboffset&1) - { - return (blit_rom[(niboffset>>1)&0xffff] & 0xf0)>>4; - } + if (niboffset & 1) + return (blit_rom[(niboffset >> 1) & 0xffff] & 0xf0) >> 4; else - { - return (blit_rom[(niboffset>>1)&0xffff] & 0x0f); - } + return (blit_rom[(niboffset >> 1) & 0xffff] & 0x0f); } -static void plot_jangou_gfx_pixel(UINT8 pix, int x, int y) +static void plot_jangou_gfx_pixel( running_machine *machine, UINT8 pix, int x, int y ) { - if (y>=512) return; - if (x>=512) return; - if (y<0) return; - if (x<0) return; + jangou_state *state = (jangou_state *)machine->driver_data; + if (y < 0 || y >= 512) + return; + if (x < 0 || x >= 512) + return; - if (x&1) - { - blit_buffer[(y*256)+(x>>1)] = (blit_buffer[(y*256)+(x>>1)] & 0x0f) | ((pix<<4) & 0xf0); - } + if (x & 1) + state->blit_buffer[(y * 256) + (x >> 1)] = (state->blit_buffer[(y * 256) + (x >> 1)] & 0x0f) | ((pix << 4) & 0xf0); else - { - blit_buffer[(y*256)+(x>>1)] = (blit_buffer[(y*256)+(x>>1)] & 0xf0) | (pix & 0x0f); - } + state->blit_buffer[(y * 256) + (x >> 1)] = (state->blit_buffer[(y * 256) + (x >> 1)] & 0xf0) | (pix & 0x0f); } static WRITE8_HANDLER( blitter_process_w ) { - int src,x,y,h,w, flipx; - blit_data[offset] = data; + jangou_state *state = (jangou_state *)space->machine->driver_data; + int src, x, y, h, w, flipx; + state->blit_data[offset] = data; - if(offset == 5) + if (offset == 5) { - //printf("%02x %02x %02x %02x %02x %02x\n",blit_data[0],blit_data[1],blit_data[2],blit_data[3],blit_data[4],blit_data[5]); - w = (blit_data[4] & 0xff)+1; - h = (blit_data[5] & 0xff)+1; - src = ((blit_data[1]<<8)|(blit_data[0]<<0)); - x = (blit_data[2] & 0xff); - y = (blit_data[3] & 0xff); + int count = 0; + int xcount, ycount; + + /* printf("%02x %02x %02x %02x %02x %02x\n", state->blit_data[0], state->blit_data[1], state->blit_data[2], + state->blit_data[3], state->blit_data[4], state->blit_data[5]); */ + w = (state->blit_data[4] & 0xff) + 1; + h = (state->blit_data[5] & 0xff) + 1; + src = ((state->blit_data[1] << 8)|(state->blit_data[0] << 0)); + x = (state->blit_data[2] & 0xff); + y = (state->blit_data[3] & 0xff); // lowest bit of src controls flipping / draw direction? - flipx=(blit_data[0] & 1); + flipx = (state->blit_data[0] & 1); - if (!flipx) src += (w*h)-1; - else src -= (w*h)-1; + if (!flipx) + src += (w * h) - 1; + else + src -= (w * h) - 1; + for (ycount = 0; ycount < h; ycount++) { - int count = 0; - int xcount,ycount; - for(ycount=0;ycountmachine,src+count); - UINT8 cur_pen_hi = pen_data[(dat & 0xf0)>>4]; - UINT8 cur_pen_lo = pen_data[(dat & 0x0f)>>0]; + int drawx = (x + xcount) & 0xff; + int drawy = (y + ycount) & 0xff; + UINT8 dat = jangou_gfx_nibble(space->machine, src + count); + UINT8 cur_pen_hi = state->pen_data[(dat & 0xf0) >> 4]; + UINT8 cur_pen_lo = state->pen_data[(dat & 0x0f) >> 0]; - dat = cur_pen_lo | cur_pen_hi<<4; + dat = cur_pen_lo | (cur_pen_hi << 4); - if((dat & 0xff) != 0) - plot_jangou_gfx_pixel(dat, drawx,drawy); + if ((dat & 0xff) != 0) + plot_jangou_gfx_pixel(space->machine, dat, drawx, drawy); - if (!flipx) count--; - else count++; - } + if (!flipx) + count--; + else + count++; } } } @@ -209,8 +226,10 @@ static WRITE8_HANDLER( blitter_process_w ) /* What is the bit 5 (0x20) for?*/ static WRITE8_HANDLER( blit_vregs_w ) { -// printf("%02x %02x\n",offset,data); - pen_data[offset] = data & 0xf; + jangou_state *state = (jangou_state *)space->machine->driver_data; + + // printf("%02x %02x\n", offset, data); + state->pen_data[offset] = data & 0xf; } /************************************* @@ -219,11 +238,10 @@ static WRITE8_HANDLER( blit_vregs_w ) * *************************************/ -static UINT8 mux_data; - static WRITE8_HANDLER( mux_w ) { - mux_data = ~data; + jangou_state *state = (jangou_state *)space->machine->driver_data; + state->mux_data = ~data; } static WRITE8_HANDLER( output_w ) @@ -233,15 +251,16 @@ static WRITE8_HANDLER( output_w ) ---- -x-- flip screen ---- ---x coin counter */ -// printf("%02x\n",data); - coin_counter_w(space->machine, 0,data & 0x01); +// printf("%02x\n", data); + coin_counter_w(space->machine, 0, data & 0x01); // flip_screen_set(data & 0x04); -// coin_lockout_w(space->machine, 0,~data & 0x20); +// coin_lockout_w(space->machine, 0, ~data & 0x20); } static READ8_DEVICE_HANDLER( input_mux_r ) { - switch(mux_data) + jangou_state *state = (jangou_state *)device->machine->driver_data; + switch(state->mux_data) { case 0x01: return input_port_read(device->machine, "PL1_1"); case 0x02: return input_port_read(device->machine, "PL1_2"); @@ -268,53 +287,59 @@ static READ8_DEVICE_HANDLER( input_system_r ) static WRITE8_HANDLER( sound_latch_w ) { + jangou_state *state = (jangou_state *)space->machine->driver_data; soundlatch_w(space, 0, data & 0xff); - cputag_set_input_line(space->machine, "cpu1", INPUT_LINE_NMI, ASSERT_LINE); + cpu_set_input_line(state->cpu_1, INPUT_LINE_NMI, ASSERT_LINE); } static READ8_HANDLER( sound_latch_r ) { - cputag_set_input_line(space->machine, "cpu1", INPUT_LINE_NMI, CLEAR_LINE); + jangou_state *state = (jangou_state *)space->machine->driver_data; + cpu_set_input_line(state->cpu_1, INPUT_LINE_NMI, CLEAR_LINE); return soundlatch_r(space, 0); } /* Jangou HC-55516 CVSD */ static WRITE8_HANDLER( cvsd_w ) { - cvsd_shiftreg = data; + jangou_state *state = (jangou_state *)space->machine->driver_data; + state->cvsd_shiftreg = data; } static TIMER_CALLBACK( cvsd_bit_timer_callback ) { + jangou_state *state = (jangou_state *)machine->driver_data; + /* Data is shifted out at the MSB */ - hc55516_digit_w(devtag_get_device(machine, "cvsd"), (cvsd_shiftreg >> 7) & 1); - cvsd_shiftreg <<= 1; + hc55516_digit_w(state->cvsd, (state->cvsd_shiftreg >> 7) & 1); + state->cvsd_shiftreg <<= 1; /* Trigger an IRQ for every 8 shifted bits */ - if ((++cvsd_shift_cnt & 7) == 0) - cputag_set_input_line(machine, "cpu1", 0, HOLD_LINE); + if ((++state->cvsd_shift_cnt & 7) == 0) + cpu_set_input_line(state->cpu_1, 0, HOLD_LINE); } /* Jangou Lady MSM5218 (MSM5205-compatible) ADPCM */ static WRITE8_HANDLER( adpcm_w ) { - adpcm_byte = data; + jangou_state *state = (jangou_state *)space->machine->driver_data; + state->adpcm_byte = data; } -static void jngolady_vclk_cb(const device_config *device) +static void jngolady_vclk_cb( const device_config *device ) { - if (msm5205_vclk_toggle == 0) - { - msm5205_data_w(device, adpcm_byte >> 4); - } + jangou_state *state = (jangou_state *)device->machine->driver_data; + + if (state->msm5205_vclk_toggle == 0) + msm5205_data_w(device, state->adpcm_byte >> 4); else { - msm5205_data_w(device, adpcm_byte & 0xf); - cputag_set_input_line(device->machine, "cpu1", 0, HOLD_LINE); + msm5205_data_w(device, state->adpcm_byte & 0xf); + cpu_set_input_line(state->cpu_1, 0, HOLD_LINE); } - msm5205_vclk_toggle ^= 1; + state->msm5205_vclk_toggle ^= 1; } @@ -324,27 +349,30 @@ static void jngolady_vclk_cb(const device_config *device) * *************************************/ -static UINT8 nsc_latch,z80_latch; - static READ8_HANDLER( master_com_r ) { - return z80_latch; + jangou_state *state = (jangou_state *)space->machine->driver_data; + return state->z80_latch; } static WRITE8_HANDLER( master_com_w ) { - cputag_set_input_line(space->machine, "nsc", 0, HOLD_LINE); - nsc_latch = data; + jangou_state *state = (jangou_state *)space->machine->driver_data; + + cpu_set_input_line(state->nsc, 0, HOLD_LINE); + state->nsc_latch = data; } static READ8_HANDLER( slave_com_r ) { - return nsc_latch; + jangou_state *state = (jangou_state *)space->machine->driver_data; + return state->nsc_latch; } static WRITE8_HANDLER( slave_com_w ) { - z80_latch = data; + jangou_state *state = (jangou_state *)space->machine->driver_data; + state->z80_latch = data; } /************************************* @@ -750,14 +778,98 @@ static const msm5205_interface msm5205_config = static SOUND_START( jangou ) { + jangou_state *state = (jangou_state *)machine->driver_data; + /* Create a timer to feed the CVSD DAC with sample bits */ - cvsd_bit_timer = timer_alloc(machine, cvsd_bit_timer_callback, NULL); - timer_adjust_periodic(cvsd_bit_timer, ATTOTIME_IN_HZ(MASTER_CLOCK / 1024), 0, ATTOTIME_IN_HZ(MASTER_CLOCK / 1024)); + state->cvsd_bit_timer = timer_alloc(machine, cvsd_bit_timer_callback, NULL); + timer_adjust_periodic(state->cvsd_bit_timer, ATTOTIME_IN_HZ(MASTER_CLOCK / 1024), 0, ATTOTIME_IN_HZ(MASTER_CLOCK / 1024)); } +/************************************* + * + * Machine driver + * + *************************************/ + +static MACHINE_START( common ) +{ + jangou_state *state = (jangou_state *)machine->driver_data; + + state->cpu_0 = devtag_get_device(machine, "cpu0"); + state->cpu_1 = devtag_get_device(machine, "cpu1"); + state->cvsd = devtag_get_device(machine, "cvsd"); + state->nsc = devtag_get_device(machine, "nsc"); + + state_save_register_global_array(machine, state->pen_data); + state_save_register_global_array(machine, state->blit_data); + state_save_register_global(machine, state->mux_data); +} + +static MACHINE_START( jangou ) +{ + jangou_state *state = (jangou_state *)machine->driver_data; + + MACHINE_START_CALL(common); + + state_save_register_global(machine, state->cvsd_shiftreg); + state_save_register_global(machine, state->cvsd_shift_cnt); +} + +static MACHINE_START( jngolady ) +{ + jangou_state *state = (jangou_state *)machine->driver_data; + + MACHINE_START_CALL(common); + + state_save_register_global(machine, state->adpcm_byte); + state_save_register_global(machine, state->msm5205_vclk_toggle); + state_save_register_global(machine, state->nsc_latch); + state_save_register_global(machine, state->z80_latch); +} + +static MACHINE_RESET( common ) +{ + jangou_state *state = (jangou_state *)machine->driver_data; + int i; + + state->mux_data = 0; + + for (i = 0; i < 6; i++) + state->blit_data[i] = 0; + + for (i = 0; i < 16; i++) + state->pen_data[i] = 0; +} + +static MACHINE_RESET( jangou ) +{ + jangou_state *state = (jangou_state *)machine->driver_data; + + MACHINE_RESET_CALL(common); + + state->cvsd_shiftreg = 0; + state->cvsd_shift_cnt = 0; +} + +static MACHINE_RESET( jngolady ) +{ + jangou_state *state = (jangou_state *)machine->driver_data; + + MACHINE_RESET_CALL(common); + + state->adpcm_byte = 0; + state->msm5205_vclk_toggle = 0; + state->nsc_latch = 0; + state->z80_latch = 0; +} + /* Note: All frequencies and dividers are unverified */ static MACHINE_DRIVER_START( jangou ) + + /* driver data */ + MDRV_DRIVER_DATA(jangou_state) + /* basic machine hardware */ MDRV_CPU_ADD("cpu0", Z80, MASTER_CLOCK / 8) MDRV_CPU_PROGRAM_MAP(cpu0_map) @@ -768,6 +880,9 @@ static MACHINE_DRIVER_START( jangou ) MDRV_CPU_PROGRAM_MAP(cpu1_map) MDRV_CPU_IO_MAP(cpu1_io) + MDRV_MACHINE_START(jangou) + MDRV_MACHINE_RESET(jangou) + /* video hardware */ MDRV_PALETTE_INIT(jangou) @@ -810,6 +925,9 @@ static MACHINE_DRIVER_START( jngolady ) MDRV_CPU_ADD("nsc", NSC8105, MASTER_CLOCK / 8) MDRV_CPU_PROGRAM_MAP(nsc_map) + MDRV_MACHINE_START(jngolady) + MDRV_MACHINE_RESET(jngolady) + /* sound hardware */ MDRV_SOUND_START(0) MDRV_DEVICE_REMOVE("cvsd") @@ -829,11 +947,20 @@ static MACHINE_DRIVER_START( cntrygrl ) MDRV_DEVICE_REMOVE("cpu1") + MDRV_MACHINE_START(common) + MDRV_MACHINE_RESET(common) + /* sound hardware */ MDRV_SOUND_START(0) MDRV_DEVICE_REMOVE("cvsd") MACHINE_DRIVER_END +/************************************* + * + * ROM definition(s) + * + *************************************/ + /* JANGOU (C)1982 Nichibutsu @@ -1059,6 +1186,12 @@ ROM_START( luckygrl ) ROM_END +/************************************* + * + * Driver initialization + * + *************************************/ + /*Temporary kludge for make the RNG work*/ static READ8_HANDLER( jngolady_rng_r ) { @@ -1076,7 +1209,6 @@ static DRIVER_INIT (luckygrl) int A; UINT8 *ROM = memory_region(machine, "cpu0"); - unsigned char patn1[32] = { 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x00, 0xA0, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, @@ -1087,11 +1219,11 @@ static DRIVER_INIT (luckygrl) 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88, 0x28, 0x88 }; - for (A = 0;A < 0x3000;A++) + for (A = 0; A < 0x3000; A++) { UINT8 dat = ROM[A]; - if (A&0x100) dat = dat ^ patn2[A&0x1f]; - else dat = dat ^ patn1[A&0x1f]; + if (A&0x100) dat = dat ^ patn2[A & 0x1f]; + else dat = dat ^ patn1[A & 0x1f]; ROM[A] = dat; } @@ -1114,14 +1246,20 @@ static DRIVER_INIT (luckygrl) } -GAME( 1983, jangou, 0, jangou, jangou, 0, ROT0, "Nichibutsu", "Jangou [BET] (Japan)", GAME_NO_COCKTAIL ) -GAME( 1983, macha, 0, jangou, macha, 0, ROT0, "Logitec", "Monoshiri Quiz Osyaberi Macha (Japan)", GAME_NO_COCKTAIL ) -GAME( 1984, jngolady, 0, jngolady, jngolady, jngolady, ROT0, "Nichibutsu", "Jangou Lady (Japan)", GAME_NO_COCKTAIL ) -GAME( 1984, cntrygrl, 0, cntrygrl, cntrygrl, 0, ROT0, "Royal Denshi", "Country Girl (Japan set 1)", GAME_NO_COCKTAIL ) -GAME( 1984, cntrygrla, cntrygrl, cntrygrl, cntrygrl, 0, ROT0, "Nichibutsu", "Country Girl (Japan set 2)", GAME_NO_COCKTAIL ) -GAME( 1984, fruitbun, cntrygrl, cntrygrl, cntrygrl, 0, ROT0, "Nichibutsu", "Fruits & Bunny (World?)", GAME_NO_COCKTAIL ) +/************************************* + * + * Game driver(s) + * + *************************************/ + +GAME( 1983, jangou, 0, jangou, jangou, 0, ROT0, "Nichibutsu", "Jangou [BET] (Japan)", GAME_NO_COCKTAIL | GAME_SUPPORTS_SAVE ) +GAME( 1983, macha, 0, jangou, macha, 0, ROT0, "Logitec", "Monoshiri Quiz Osyaberi Macha (Japan)", GAME_NO_COCKTAIL | GAME_SUPPORTS_SAVE ) +GAME( 1984, jngolady, 0, jngolady, jngolady, jngolady, ROT0, "Nichibutsu", "Jangou Lady (Japan)", GAME_NO_COCKTAIL | GAME_SUPPORTS_SAVE ) +GAME( 1984, cntrygrl, 0, cntrygrl, cntrygrl, 0, ROT0, "Royal Denshi", "Country Girl (Japan set 1)", GAME_NO_COCKTAIL | GAME_SUPPORTS_SAVE ) +GAME( 1984, cntrygrla, cntrygrl, cntrygrl, cntrygrl, 0, ROT0, "Nichibutsu", "Country Girl (Japan set 2)", GAME_NO_COCKTAIL | GAME_SUPPORTS_SAVE ) +GAME( 1984, fruitbun, cntrygrl, cntrygrl, cntrygrl, 0, ROT0, "Nichibutsu", "Fruits & Bunny (World?)", GAME_NO_COCKTAIL | GAME_SUPPORTS_SAVE ) /* The following might not run there... */ -GAME( 1984?,luckygrl, 0, cntrygrl, cntrygrl, luckygrl, ROT0, "Wing", "Lucky Girl? (Wing)", GAME_NOT_WORKING ) +GAME( 1984?, luckygrl, 0, cntrygrl, cntrygrl, luckygrl, ROT0, "Wing", "Lucky Girl? (Wing)", GAME_NOT_WORKING | GAME_SUPPORTS_SAVE ) /* Some other games that might run on this HW: diff --git a/src/mame/drivers/jantotsu.c b/src/mame/drivers/jantotsu.c index 90aa7a3f2f5..f002c055b11 100644 --- a/src/mame/drivers/jantotsu.c +++ b/src/mame/drivers/jantotsu.c @@ -99,48 +99,65 @@ dumped by sayu #include "sound/sn76496.h" #include "sound/msm5205.h" -static UINT8 *jan_bitmap; -static UINT8 vram_bank,col_bank; -static UINT8 mux_data; +typedef struct _jantotsu_state jantotsu_state; +struct _jantotsu_state +{ + /* video-related */ + UINT8 *bitmap; + UINT8 vram_bank, col_bank; -static UINT32 adpcm_pos; -static UINT8 adpcm_idle; -static int adpcm_data; + /* sound-related */ + UINT32 adpcm_pos; + UINT8 adpcm_idle; + int adpcm_data; + UINT8 adpcm_trigger; + + /* misc */ + UINT8 mux_data; +}; + + +/************************************* + * + * Video emulation + * + *************************************/ static VIDEO_START(jantotsu) { - jan_bitmap = auto_alloc_array(machine, UINT8, 0x8000); + jantotsu_state *state = (jantotsu_state *)machine->driver_data; - vram_bank = 0; + state->bitmap = auto_alloc_array(machine, UINT8, 0x8000); + state_save_register_global_pointer(machine, state->bitmap, 0x8000); } static VIDEO_UPDATE(jantotsu) { - int x,y,i; - int count; + jantotsu_state *state = (jantotsu_state *)screen->machine->driver_data; + int x, y, i; + int count = 0; - count = 0; - for(y=0;y<256;y++) + for (y = 0; y < 256; y++) { - for(x=0;x<256;x+=8) + for (x = 0; x < 256; x += 8) { - int pen[4],color; + int pen[4], color; - for (i=0;i<8;i++) + for (i = 0; i < 8; i++) { - pen[0] = (jan_bitmap[count+0x0000])>>(7-i); - pen[1] = (jan_bitmap[count+0x2000])>>(7-i); - pen[2] = (jan_bitmap[count+0x4000])>>(7-i); - pen[3] = (jan_bitmap[count+0x6000])>>(7-i); + pen[0] = (state->bitmap[count + 0x0000]) >> (7 - i); + pen[1] = (state->bitmap[count + 0x2000]) >> (7 - i); + pen[2] = (state->bitmap[count + 0x4000]) >> (7 - i); + pen[3] = (state->bitmap[count + 0x6000]) >> (7 - i); - color = ((pen[0] & 1)<<0); - color|= ((pen[1] & 1)<<1); - color|= ((pen[2] & 1)<<2); - color|= ((pen[3] & 1)<<3); - color|= col_bank; + color = ((pen[0] & 1) << 0); + color |= ((pen[1] & 1) << 1); + color |= ((pen[2] & 1) << 2); + color |= ((pen[3] & 1) << 3); + color |= state->col_bank; - if((x+i)<=video_screen_get_visible_area(screen)->max_x && ((y)+0)max_y) - *BITMAP_ADDR32(bitmap, y, x+i) = screen->machine->pens[color]; + if ((x + i) <= video_screen_get_visible_area(screen)->max_x && (y + 0) < video_screen_get_visible_area(screen)->max_y) + *BITMAP_ADDR32(bitmap, y, x + i) = screen->machine->pens[color]; } count++; @@ -153,27 +170,31 @@ static VIDEO_UPDATE(jantotsu) /* banked vram */ static READ8_HANDLER( jantotsu_bitmap_r ) { - return jan_bitmap[offset+((vram_bank & 3)*0x2000)]; + jantotsu_state *state = (jantotsu_state *)space->machine->driver_data; + return state->bitmap[offset + ((state->vram_bank & 3) * 0x2000)]; } static WRITE8_HANDLER( jantotsu_bitmap_w ) { - jan_bitmap[offset+((vram_bank & 3)*0x2000)] = data; + jantotsu_state *state = (jantotsu_state *)space->machine->driver_data; + state->bitmap[offset + ((state->vram_bank & 3) * 0x2000)] = data; } static WRITE8_HANDLER( bankaddr_w ) { - vram_bank = ((data & 0xc0)>>6); // top 2 bits? + jantotsu_state *state = (jantotsu_state *)space->machine->driver_data; + + state->vram_bank = ((data & 0xc0) >> 6); // top 2 bits? // looks like the top 2 bits and bottom 2 bits are used.. // multiple buffers? different read / write ? -// printf("%02x\n",data & 0x03); + // printf("%02x\n",data & 0x03); } static PALETTE_INIT( jantotsu ) { - int bit0, bit1, bit2 , r, g, b; + int bit0, bit1, bit2, r, g, b; int i; for (i = 0; i < 0x20; ++i) @@ -196,16 +217,21 @@ static PALETTE_INIT( jantotsu ) } } +/************************************* + * + * Memory handlers + * + *************************************/ + /*Multiplexer is mapped as 6-bits reads,bits 6 & 7 are always connected to the coin mechs.*/ static READ8_HANDLER( jantotsu_mux_r ) { - static UINT8 coin_port; + jantotsu_state *state = (jantotsu_state *)space->machine->driver_data; + UINT8 coin_port = input_port_read(space->machine, "COINS"); - coin_port = input_port_read(space->machine, "COINS"); + // printf("%02x\n", state->mux_data); -// printf("%02x\n",mux_data); - - switch(mux_data) + switch (state->mux_data) { case 0x01: return input_port_read(space->machine, "PL1_1") | coin_port; case 0x02: return input_port_read(space->machine, "PL1_2") | coin_port; @@ -222,7 +248,8 @@ static READ8_HANDLER( jantotsu_mux_r ) static WRITE8_HANDLER( jantotsu_mux_w ) { - mux_data = ~data; + jantotsu_state *state = (jantotsu_state *)space->machine->driver_data; + state->mux_data = ~data; } /*If bits 6 & 7 doesn't return 0x80,the game hangs until this bit is set, @@ -236,58 +263,66 @@ static READ8_HANDLER( jantotsu_dsw2_r ) static WRITE8_DEVICE_HANDLER( jan_adpcm_w ) { + jantotsu_state *state = (jantotsu_state *)device->machine->driver_data; + switch (offset) { case 0: - adpcm_pos = (data & 0xff) * 0x100; - adpcm_idle = 0; - msm5205_reset_w(device,0); + state->adpcm_pos = (data & 0xff) * 0x100; + state->adpcm_idle = 0; + msm5205_reset_w(device, 0); /* I don't think that this will ever happen, it's there just to be sure (i.e. I'll probably never do a "nagare" in my entire life ;-) ) */ if(data & 0x20) - popmessage("ADPCM called with data = %02x, contact MAMEdev",data); -// printf("%02x 0\n",data); + popmessage("ADPCM called with data = %02x, contact MAMEdev", data); +// printf("%02x 0\n", data); break; /*same write as port 2? MSM sample ack? */ case 1: -// adpcm_idle = 1; -// msm5205_reset_w(device,1); -// printf("%02x 1\n",data); +// state->adpcm_idle = 1; +// msm5205_reset_w(device, 1); +// printf("%02x 1\n", data); break; } } -static void jan_adpcm_int(const device_config *device) +static void jan_adpcm_int( const device_config *device ) { - static UINT8 trigger; + jantotsu_state *state = (jantotsu_state *)device->machine->driver_data; - if (adpcm_pos >= 0x10000 || adpcm_idle) + if (state->adpcm_pos >= 0x10000 || state->adpcm_idle) { - //adpcm_idle = 1; - msm5205_reset_w(device,1); - trigger = 0; + //state->adpcm_idle = 1; + msm5205_reset_w(device, 1); + state->adpcm_trigger = 0; } else { UINT8 *ROM = memory_region(device->machine, "adpcm"); - adpcm_data = ((trigger ? (ROM[adpcm_pos] & 0x0f) : (ROM[adpcm_pos] & 0xf0)>>4) ); - msm5205_data_w(device,adpcm_data & 0xf); - trigger^=1; - if(trigger == 0) + state->adpcm_data = ((state->adpcm_trigger ? (ROM[state->adpcm_pos] & 0x0f) : (ROM[state->adpcm_pos] & 0xf0) >> 4)); + msm5205_data_w(device, state->adpcm_data & 0xf); + state->adpcm_trigger ^= 1; + if (state->adpcm_trigger == 0) { - adpcm_pos++; - if((ROM[adpcm_pos] & 0xff) == 0x70) - adpcm_idle = 1; + state->adpcm_pos++; + if ((ROM[state->adpcm_pos] & 0xff) == 0x70) + state->adpcm_idle = 1; } } } +/************************************* + * + * Address maps + * + *************************************/ + static ADDRESS_MAP_START( jantotsu_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x0000, 0xbfff) AM_ROM AM_RANGE(0xc000, 0xc7ff) AM_RAM - AM_RANGE(0xe000, 0xffff) AM_READWRITE(jantotsu_bitmap_r,jantotsu_bitmap_w) + AM_RANGE(0xe000, 0xffff) AM_READWRITE(jantotsu_bitmap_r, jantotsu_bitmap_w) ADDRESS_MAP_END static ADDRESS_MAP_START( jantotsu_io, ADDRESS_SPACE_IO, 8 ) @@ -295,10 +330,17 @@ static ADDRESS_MAP_START( jantotsu_io, ADDRESS_SPACE_IO, 8 ) AM_RANGE(0x00, 0x00) AM_READ_PORT("DSW1") AM_DEVWRITE("sn1", sn76496_w) AM_RANGE(0x01, 0x01) AM_READ(jantotsu_dsw2_r) AM_DEVWRITE("sn2", sn76496_w) AM_RANGE(0x02, 0x03) AM_DEVWRITE("adpcm", jan_adpcm_w) - AM_RANGE(0x04, 0x04) AM_READWRITE(jantotsu_mux_r,jantotsu_mux_w) + AM_RANGE(0x04, 0x04) AM_READWRITE(jantotsu_mux_r, jantotsu_mux_w) AM_RANGE(0x07, 0x07) AM_WRITE(bankaddr_w) ADDRESS_MAP_END + +/************************************* + * + * Input ports + * + *************************************/ + static INPUT_PORTS_START( jantotsu ) PORT_START("COINS") PORT_BIT( 0x40, IP_ACTIVE_LOW, IPT_COIN1 ) @@ -410,14 +452,12 @@ static INPUT_PORTS_START( jantotsu ) PORT_BIT( 0x20, IP_ACTIVE_LOW, IPT_MAHJONG_F ) PORT_PLAYER(2) INPUT_PORTS_END -static MACHINE_RESET( jantotsu ) -{ - mux_data = 0; - /*Load hard-wired background color.*/ - col_bank = (input_port_read(machine, "DSW2") & 0xc0)>>3; - adpcm_pos = 0; - adpcm_idle = 1; -} + +/************************************* + * + * Sound interface + * + *************************************/ static const msm5205_interface msm5205_config = { @@ -425,14 +465,53 @@ static const msm5205_interface msm5205_config = MSM5205_S64_4B /* 6 KHz */ }; +/************************************* + * + * Machine driver + * + *************************************/ + +static MACHINE_START( jantotsu ) +{ + jantotsu_state *state = (jantotsu_state *)machine->driver_data; + + state_save_register_global(machine, state->vram_bank); + state_save_register_global(machine, state->mux_data); + state_save_register_global(machine, state->adpcm_pos); + state_save_register_global(machine, state->adpcm_idle); + state_save_register_global(machine, state->adpcm_data); + state_save_register_global(machine, state->adpcm_trigger); +} + +static MACHINE_RESET( jantotsu ) +{ + jantotsu_state *state = (jantotsu_state *)machine->driver_data; + + /*Load hard-wired background color.*/ + state->col_bank = (input_port_read(machine, "DSW2") & 0xc0) >> 3; + + state->vram_bank = 0; + state->mux_data = 0; + state->adpcm_pos = 0; + state->adpcm_idle = 1; + state->adpcm_data = 0; + state->adpcm_trigger = 0; +} + static MACHINE_DRIVER_START( jantotsu ) + + /* driver data */ + MDRV_DRIVER_DATA(jantotsu_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu", Z80,18432000/4) MDRV_CPU_PROGRAM_MAP(jantotsu_map) MDRV_CPU_IO_MAP(jantotsu_io) MDRV_CPU_VBLANK_INT("screen", nmi_line_pulse) + MDRV_MACHINE_START(jantotsu) MDRV_MACHINE_RESET(jantotsu) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -462,6 +541,11 @@ static MACHINE_DRIVER_START( jantotsu ) MACHINE_DRIVER_END +/************************************* + * + * ROM definition(s) + * + *************************************/ ROM_START( jantotsu ) ROM_REGION( 0x10000, "maincpu", 0 ) @@ -482,4 +566,11 @@ ROM_START( jantotsu ) ROM_LOAD( "jat-60.10p", 0x00, 0x20, CRC(65528ae0) SHA1(6e3bf27d10ec14e3c6a494667b03b68726fcff14) ) ROM_END -GAME( 1983, jantotsu, 0, jantotsu, jantotsu, 0, ROT270, "Sanritsu", "4nin-uchi Mahjong Jantotsu", GAME_IMPERFECT_GRAPHICS ) + +/************************************* + * + * Game driver(s) + * + *************************************/ + +GAME( 1983, jantotsu, 0, jantotsu, jantotsu, 0, ROT270, "Sanritsu", "4nin-uchi Mahjong Jantotsu", GAME_IMPERFECT_GRAPHICS | GAME_SUPPORTS_SAVE ) diff --git a/src/mame/drivers/jollyjgr.c b/src/mame/drivers/jollyjgr.c index 0d39dacf8c4..b4ffed25057 100644 --- a/src/mame/drivers/jollyjgr.c +++ b/src/mame/drivers/jollyjgr.c @@ -101,44 +101,70 @@ Notes: #include "cpu/z80/z80.h" #include "sound/ay8910.h" -static tilemap *bg_tilemap; -static int nmi_enable = 0, jullyjgr_flip_screen_x = 0, jullyjgr_flip_screen_y = 0; -static UINT8 *jollyjgr_bitmap; + +typedef struct _jollyjgr_state jollyjgr_state; +struct _jollyjgr_state +{ + /* memory pointers */ + UINT8 * videoram; + UINT8 * colorram; + UINT8 * spriteram; + UINT8 * bitmap; + + /* video-related */ + tilemap *bg_tilemap; + + /* misc */ + int nmi_enable, flip_x, flip_y; +}; + + +/************************************* + * + * Memory handlers + * + *************************************/ static WRITE8_HANDLER( jollyjgr_videoram_w ) { - space->machine->generic.videoram.u8[offset] = data; - tilemap_mark_tile_dirty(bg_tilemap,offset); + jollyjgr_state *state = (jollyjgr_state *)space->machine->driver_data; + state->videoram[offset] = data; + tilemap_mark_tile_dirty(state->bg_tilemap, offset); } static WRITE8_HANDLER( jollyjgr_attrram_w ) { - if(offset & 1) + jollyjgr_state *state = (jollyjgr_state *)space->machine->driver_data; + + if (offset & 1) { /* color change */ int i; for (i = offset >> 1; i < 0x0400; i += 32) - tilemap_mark_tile_dirty(bg_tilemap, i); + tilemap_mark_tile_dirty(state->bg_tilemap, i); } else { - tilemap_set_scrolly(bg_tilemap, offset >> 1, data); + tilemap_set_scrolly(state->bg_tilemap, offset >> 1, data); } - space->machine->generic.colorram.u8[offset] = data; + state->colorram[offset] = data; } static WRITE8_HANDLER( jollyjgr_misc_w ) { + jollyjgr_state *state = (jollyjgr_state *)space->machine->driver_data; + // they could be swapped, because it always set "data & 3" - jullyjgr_flip_screen_x = data & 1; - jullyjgr_flip_screen_y = data & 2; + state->flip_x = data & 1; + state->flip_y = data & 2; - tilemap_set_flip(bg_tilemap, (jullyjgr_flip_screen_x ? TILEMAP_FLIPX : 0) | (jullyjgr_flip_screen_y ? TILEMAP_FLIPY : 0)); + tilemap_set_flip(state->bg_tilemap, (state->flip_x ? TILEMAP_FLIPX : 0) | (state->flip_y ? TILEMAP_FLIPY : 0)); - nmi_enable = data & 0x80; + state->nmi_enable = data & 0x80; } + static WRITE8_HANDLER( jollyjgr_coin_lookout_w ) { coin_lockout_global_w(space->machine, data & 1); @@ -146,6 +172,12 @@ static WRITE8_HANDLER( jollyjgr_coin_lookout_w ) /* bits 4, 5, 6 and 7 are used too */ } +/************************************* + * + * Address maps + * + *************************************/ + static ADDRESS_MAP_START( jollyjgr_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x0000, 0x7fff) AM_ROM AM_RANGE(0x8000, 0x87ff) AM_RAM @@ -156,14 +188,20 @@ static ADDRESS_MAP_START( jollyjgr_map, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x8fff, 0x8fff) AM_READ_PORT("DSW2") AM_RANGE(0x8ffc, 0x8ffc) AM_WRITE(jollyjgr_misc_w) AM_RANGE(0x8ffd, 0x8ffd) AM_WRITE(jollyjgr_coin_lookout_w) - AM_RANGE(0x9000, 0x93ff) AM_RAM_WRITE(jollyjgr_videoram_w) AM_BASE_GENERIC(videoram) - AM_RANGE(0x9800, 0x983f) AM_RAM_WRITE(jollyjgr_attrram_w) AM_BASE_GENERIC(colorram) - AM_RANGE(0x9840, 0x987f) AM_RAM AM_BASE_GENERIC(spriteram) + AM_RANGE(0x9000, 0x93ff) AM_RAM_WRITE(jollyjgr_videoram_w) AM_BASE_MEMBER(jollyjgr_state, videoram) + AM_RANGE(0x9800, 0x983f) AM_RAM_WRITE(jollyjgr_attrram_w) AM_BASE_MEMBER(jollyjgr_state, colorram) + AM_RANGE(0x9840, 0x987f) AM_RAM AM_BASE_MEMBER(jollyjgr_state, spriteram) AM_RANGE(0x9880, 0x9bff) AM_RAM - AM_RANGE(0xa000, 0xffff) AM_RAM AM_BASE(&jollyjgr_bitmap) + AM_RANGE(0xa000, 0xffff) AM_RAM AM_BASE_MEMBER(jollyjgr_state, bitmap) ADDRESS_MAP_END +/************************************* + * + * Input ports + * + *************************************/ + static INPUT_PORTS_START( jollyjgr ) PORT_START("DSW1") PORT_DIPNAME( 0x03, 0x02, DEF_STR( Bonus_Life ) ) @@ -232,82 +270,91 @@ static INPUT_PORTS_START( jollyjgr ) PORT_BIT( 0x80, IP_ACTIVE_HIGH, IPT_TILT ) INPUT_PORTS_END +/************************************* + * + * Video emulation + * + *************************************/ + static PALETTE_INIT( jollyjgr ) { int i; /* tilemap / sprites palette */ - for (i = 0;i < 32;i++) + for (i = 0; i < 32; i++) { - int bit0,bit1,bit2,r,g,b; + int bit0, bit1, bit2, r, g, b; /* red component */ - bit0 = BIT(*color_prom,0); - bit1 = BIT(*color_prom,1); - bit2 = BIT(*color_prom,2); + bit0 = BIT(*color_prom, 0); + bit1 = BIT(*color_prom, 1); + bit2 = BIT(*color_prom, 2); r = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; /* green component */ - bit0 = BIT(*color_prom,3); - bit1 = BIT(*color_prom,4); - bit2 = BIT(*color_prom,5); + bit0 = BIT(*color_prom, 3); + bit1 = BIT(*color_prom, 4); + bit2 = BIT(*color_prom, 5); g = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2; /* blue component */ - bit0 = BIT(*color_prom,6); - bit1 = BIT(*color_prom,7); + bit0 = BIT(*color_prom, 6); + bit1 = BIT(*color_prom, 7); b = 0x4f * bit0 + 0xa8 * bit1; - palette_set_color(machine,i,MAKE_RGB(r,g,b)); + palette_set_color(machine, i, MAKE_RGB(r,g,b)); color_prom++; } /* bitmap palette */ for (i = 0;i < 8;i++) - palette_set_color_rgb(machine,32 + i,pal1bit(i >> 0),pal1bit(i >> 1),pal1bit(i >> 2)); + palette_set_color_rgb(machine, 32 + i, pal1bit(i >> 0), pal1bit(i >> 1), pal1bit(i >> 2)); } /* Tilemap is the same as in Galaxian */ static TILE_GET_INFO( get_bg_tile_info ) { - int color = machine->generic.colorram.u8[((tile_index & 0x1f) << 1) | 1] & 7; - SET_TILE_INFO(0, machine->generic.videoram.u8[tile_index], color, 0); + jollyjgr_state *state = (jollyjgr_state *)machine->driver_data; + int color = state->colorram[((tile_index & 0x1f) << 1) | 1] & 7; + SET_TILE_INFO(0, state->videoram[tile_index], color, 0); } static VIDEO_START( jollyjgr ) { - bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 8, 32, 32); + jollyjgr_state *state = (jollyjgr_state *)machine->driver_data; + state->bg_tilemap = tilemap_create(machine, get_bg_tile_info, tilemap_scan_rows, 8, 8, 32, 32); - tilemap_set_transparent_pen(bg_tilemap, 0); - tilemap_set_scroll_cols(bg_tilemap, 32); + tilemap_set_transparent_pen(state->bg_tilemap, 0); + tilemap_set_scroll_cols(state->bg_tilemap, 32); } -static void draw_bitmap(bitmap_t *bitmap) +static void draw_bitmap( running_machine *machine, bitmap_t *bitmap ) { - int x,y,count; + jollyjgr_state *state = (jollyjgr_state *)machine->driver_data; + int x, y, count; int i, bit0, bit1, bit2; int color; count = 0; - for (y=0;y<256;y++) + for (y = 0; y < 256; y++) { - for (x=0;x<256/8;x++) + for (x = 0; x < 256 / 8; x++) { for(i = 0; i < 8; i++) { - bit0 = (jollyjgr_bitmap[count] >> i) & 1; - bit1 = (jollyjgr_bitmap[count + 0x2000] >> i) & 1; - bit2 = (jollyjgr_bitmap[count + 0x4000] >> i) & 1; + bit0 = (state->bitmap[count] >> i) & 1; + bit1 = (state->bitmap[count + 0x2000] >> i) & 1; + bit2 = (state->bitmap[count + 0x4000] >> i) & 1; color = bit0 | (bit1 << 1) | (bit2 << 2); if(color) { - if(jullyjgr_flip_screen_x && jullyjgr_flip_screen_y) - *BITMAP_ADDR16(bitmap, y, x*8 + i) = color + 32; - else if(jullyjgr_flip_screen_x && !jullyjgr_flip_screen_y) - *BITMAP_ADDR16(bitmap, 255 - y, x*8 + i) = color + 32; - else if(!jullyjgr_flip_screen_x && jullyjgr_flip_screen_y) - *BITMAP_ADDR16(bitmap, y, 255 - x*8 - i) = color + 32; + if(state->flip_x && state->flip_y) + *BITMAP_ADDR16(bitmap, y, x * 8 + i) = color + 32; + else if(state->flip_x && !state->flip_y) + *BITMAP_ADDR16(bitmap, 255 - y, x * 8 + i) = color + 32; + else if(!state->flip_x && state->flip_y) + *BITMAP_ADDR16(bitmap, y, 255 - x * 8 - i) = color + 32; else - *BITMAP_ADDR16(bitmap, 255 - y, 255 - x*8 - i) = color + 32; + *BITMAP_ADDR16(bitmap, 255 - y, 255 - x * 8 - i) = color + 32; } } @@ -318,17 +365,18 @@ static void draw_bitmap(bitmap_t *bitmap) static VIDEO_UPDATE( jollyjgr ) { - UINT8 *spriteram = screen->machine->generic.spriteram.u8; + jollyjgr_state *state = (jollyjgr_state *)screen->machine->driver_data; + UINT8 *spriteram = state->spriteram; int offs; - bitmap_fill(bitmap,cliprect,32); + bitmap_fill(bitmap, cliprect, 32); - tilemap_draw(bitmap,cliprect,bg_tilemap,0,0); + tilemap_draw(bitmap, cliprect, state->bg_tilemap, 0, 0); - draw_bitmap(bitmap); + draw_bitmap(screen->machine, bitmap); /* Sprites are the same as in Galaxian */ - for(offs = 0; offs < 0x40; offs += 4) + for (offs = 0; offs < 0x40; offs += 4) { int sx = spriteram[offs + 3] + 1; int sy = spriteram[offs]; @@ -337,22 +385,19 @@ static VIDEO_UPDATE( jollyjgr ) int code = spriteram[offs + 1] & 0x3f; int color = spriteram[offs + 2] & 7; - if (jullyjgr_flip_screen_x) + if (state->flip_x) { sx = 240 - sx; flipx = !flipx; } - if (jullyjgr_flip_screen_y) - { + if (state->flip_y) flipy = !flipy; - } else - { sy = 240 - sy; - } - if (offs < 3*4) sy++; + if (offs < 3 * 4) + sy++; drawgfx_transpen(bitmap,cliprect,screen->machine->gfx[1], code,color, @@ -363,6 +408,12 @@ static VIDEO_UPDATE( jollyjgr ) return 0; } +/************************************* + * + * Graphics definitions + * + *************************************/ + static const gfx_layout jollyjgr_charlayout = { 8,8, @@ -392,17 +443,52 @@ static GFXDECODE_START( jollyjgr ) GFXDECODE_ENTRY( "gfx2", 0, jollyjgr_spritelayout, 0, 8 ) GFXDECODE_END + +/************************************* + * + * Machine driver + * + *************************************/ + static INTERRUPT_GEN( jollyjgr_interrupt ) { - if(nmi_enable) + jollyjgr_state *state = (jollyjgr_state *)device->machine->driver_data; + if(state->nmi_enable) cpu_set_input_line(device, INPUT_LINE_NMI, PULSE_LINE); } + +static MACHINE_START( jollyjgr ) +{ + jollyjgr_state *state = (jollyjgr_state *)machine->driver_data; + + state_save_register_global(machine, state->nmi_enable); + state_save_register_global(machine, state->flip_x); + state_save_register_global(machine, state->flip_y); +} + +static MACHINE_RESET( jollyjgr ) +{ + jollyjgr_state *state = (jollyjgr_state *)machine->driver_data; + + state->nmi_enable = 0; + state->flip_x = 0; + state->flip_y = 0; +} + static MACHINE_DRIVER_START( jollyjgr ) + + /* driver data */ + MDRV_DRIVER_DATA(jollyjgr_state) + + /* basic machine hardware */ MDRV_CPU_ADD("maincpu", Z80, 3579545) /* 3,579545 MHz */ MDRV_CPU_PROGRAM_MAP(jollyjgr_map) MDRV_CPU_VBLANK_INT("screen", jollyjgr_interrupt) + MDRV_MACHINE_START(jollyjgr) + MDRV_MACHINE_RESET(jollyjgr) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -425,6 +511,12 @@ static MACHINE_DRIVER_START( jollyjgr ) MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.45) MACHINE_DRIVER_END +/************************************* + * + * ROM definition(s) + * + *************************************/ + ROM_START( jollyjgr ) ROM_REGION( 0x10000, "maincpu", 0 ) ROM_LOAD( "kd14.8a", 0x0000, 0x1000, CRC(404cfa2b) SHA1(023abecbc614d1deb6a239906f62e25bb688ac14) ) @@ -449,4 +541,10 @@ ROM_START( jollyjgr ) ROM_LOAD( "kd13.1f", 0x0000, 0x1000, CRC(4f4e4e13) SHA1(a8fe0e1fd354e6cc2cf65eab66882c3b98c82100) ) ROM_END -GAME( 1982, jollyjgr, 0, jollyjgr, jollyjgr, 0, ROT90, "Taito Corporation", "Jolly Jogger", 0 ) +/************************************* + * + * Game driver(s) + * + *************************************/ + +GAME( 1982, jollyjgr, 0, jollyjgr, jollyjgr, 0, ROT90, "Taito Corporation", "Jolly Jogger", GAME_SUPPORTS_SAVE ) diff --git a/src/mame/drivers/jongkyo.c b/src/mame/drivers/jongkyo.c index 3c6c561fb62..8760c38ca69 100644 --- a/src/mame/drivers/jongkyo.c +++ b/src/mame/drivers/jongkyo.c @@ -1,4 +1,29 @@ -/* Jongkyo */ +/********************************************************** + + Jongkyo + (c)1985 Kiwako + + 834-5558 JONGKYO + C2-00173 + + CPU: SEGA Custom 315-5084 (Z80) + Sound: AY-3-8910 + OSC: 18.432MHz + + ROMs: + EPR-6258 (2764) + EPR-6259 (2764) + EPR-6260 (2764) + EPR-6261 (2764) + EPR-6262 (2732) + + PR-6263.6J (82S123N) + PR-6264.0H (82S123N) + PR-6265.0M (82S129N) + PR-6266.0B (82S129N) + +**********************************************************/ + #include "driver.h" #include "cpu/z80/z80.h" #include "sound/ay8910.h" @@ -6,45 +31,34 @@ #define JONGKYO_CLOCK 18432000 -/* -Jongkyo -(c)1985 Kiwako +typedef struct _jongkyo_state jongkyo_state; +struct _jongkyo_state +{ + /* memory pointers */ + UINT8 * videoram; + UINT8 * videoram2; -834-5558 JONGKYO -C2-00173 - -CPU: SEGA Custom 315-5084 (Z80) -Sound: AY-3-8910 -OSC: 18.432MHz - -ROMs: -EPR-6258 (2764) -EPR-6259 (2764) -EPR-6260 (2764) -EPR-6261 (2764) -EPR-6262 (2732) - -PR-6263.6J (82S123N) -PR-6264.0H (82S123N) -PR-6265.0M (82S129N) -PR-6266.0B (82S129N) - -*/ + /* misc */ + UINT8 rom_bank; + UINT8 mux_data; +}; -//static UINT8 *videoram; +/************************************* + * + * Video emulation + * + *************************************/ -static int rom_bank; -static UINT8* videoram2; - -static VIDEO_START(jongkyo) +static VIDEO_START( jongkyo ) { } -static VIDEO_UPDATE(jongkyo) +static VIDEO_UPDATE( jongkyo ) { + jongkyo_state *state = (jongkyo_state *)screen->machine->driver_data; int y; for (y = 0; y < 256; ++y) @@ -58,7 +72,7 @@ static VIDEO_UPDATE(jongkyo) UINT8 data2; UINT8 data3; - // data3 = videoram2[x/4 + y*64]; // wrong + // data3 = state->videoram2[x/4 + y*64]; // wrong // good mahjong tiles data3 = 0x0f; // we're missing 2 bits.. there must be another piece of video ram somewhere or we can't use all the colours (6bpp).. banked somehow? @@ -67,17 +81,14 @@ static VIDEO_UPDATE(jongkyo) - data1 = screen->machine->generic.videoram.u8[0x4000 + x/4 + y*64]; - data2 = screen->machine->generic.videoram.u8[x/4 + y*64]; + data1 = state->videoram[0x4000 + x / 4 + y * 64]; + data2 = state->videoram[x / 4 + y * 64]; for (b = 0; b < 4; ++b) { - *BITMAP_ADDR16(bitmap, 255-y, 255-(x+b)) = ((data2 & 0x01)) + - ((data2 & 0x10) >> 3) + - ((data1 & 0x01) << 2) + - ((data1 & 0x10) >> 1) + - ((data3 & 0x01) << 4) + - ((data3 & 0x10) << 1); + *BITMAP_ADDR16(bitmap, 255 - y, 255 - (x + b)) = ((data2 & 0x01)) + ((data2 & 0x10) >> 3) + + ((data1 & 0x01) << 2) + ((data1 & 0x10) >> 1) + + ((data3 & 0x01) << 4) + ((data3 & 0x10) << 1); data1 >>= 1; data2 >>= 1; data3 >>= 1; @@ -89,42 +100,46 @@ static VIDEO_UPDATE(jongkyo) } +/************************************* + * + * Memory handlers + * + *************************************/ + static WRITE8_HANDLER( bank_select_w ) { - + jongkyo_state *state = (jongkyo_state *)space->machine->driver_data; int mask = 1 << (offset >> 1); - rom_bank &= ~mask; + state->rom_bank &= ~mask; if (offset & 1) - rom_bank |= mask; + state->rom_bank |= mask; - memory_set_bank(space->machine, "bank1", rom_bank); + memory_set_bank(space->machine, "bank1", state->rom_bank); } -static UINT8 mux_data; - static WRITE8_HANDLER( mux_w ) { - mux_data = ~data; -// printf("%02x\n",mux_data); + jongkyo_state *state = (jongkyo_state *)space->machine->driver_data; + state->mux_data = ~data; + // printf("%02x\n", state->mux_data); } static WRITE8_HANDLER( jongkyo_coin_counter_w ) { /* bit 1 = coin counter */ - coin_counter_w(space->machine, 0,data & 2); + coin_counter_w(space->machine, 0, data & 2); /* bit 2 always set? */ } static READ8_DEVICE_HANDLER( input_1p_r ) { - static UINT8 cr_clear; + jongkyo_state *state = (jongkyo_state *)device->machine->driver_data; + UINT8 cr_clear = input_port_read(device->machine, "CR_CLEAR"); - cr_clear = input_port_read(device->machine, "CR_CLEAR"); - - switch(mux_data) + switch (state->mux_data) { case 0x01: return input_port_read(device->machine, "PL1_1") | cr_clear; case 0x02: return input_port_read(device->machine, "PL1_2") | cr_clear; @@ -133,19 +148,18 @@ static READ8_DEVICE_HANDLER( input_1p_r ) case 0x10: return input_port_read(device->machine, "PL1_5") | cr_clear; case 0x20: return input_port_read(device->machine, "PL1_6") | cr_clear; } -// printf("%04x\n",mux_data); + // printf("%04x\n", state->mux_data); return (input_port_read(device->machine, "PL1_1") & input_port_read(device->machine, "PL1_2") & input_port_read(device->machine, "PL1_3") & - input_port_read(device->machine, "PL1_4") & input_port_read(device->machine, "PL1_5") & input_port_read(device->machine, "PL1_6")) | cr_clear;//input_port_read(device->machine, "PL1_0") && ; + input_port_read(device->machine, "PL1_4") & input_port_read(device->machine, "PL1_5") & input_port_read(device->machine, "PL1_6")) | cr_clear; } static READ8_DEVICE_HANDLER( input_2p_r ) { - static UINT8 coin_port; + jongkyo_state *state = (jongkyo_state *)device->machine->driver_data; + UINT8 coin_port = input_port_read(device->machine, "COINS"); - coin_port = input_port_read(device->machine, "COINS"); - - switch(mux_data) + switch (state->mux_data) { case 0x01: return input_port_read(device->machine, "PL2_1") | coin_port; case 0x02: return input_port_read(device->machine, "PL2_2") | coin_port; @@ -154,15 +168,16 @@ static READ8_DEVICE_HANDLER( input_2p_r ) case 0x10: return input_port_read(device->machine, "PL2_5") | coin_port; case 0x20: return input_port_read(device->machine, "PL2_6") | coin_port; } -// printf("%04x\n",mux_data); + // printf("%04x\n", state->mux_data); return (input_port_read(device->machine, "PL2_1") & input_port_read(device->machine, "PL2_2") & input_port_read(device->machine, "PL2_3") & - input_port_read(device->machine, "PL2_4") & input_port_read(device->machine, "PL2_5") & input_port_read(device->machine, "PL2_6")) | coin_port;//input_port_read(device->machine, "PL1_0") && ; - + input_port_read(device->machine, "PL2_4") & input_port_read(device->machine, "PL2_5") & input_port_read(device->machine, "PL2_6")) | coin_port; } + static WRITE8_HANDLER( videoram2_w ) { - videoram2[offset] = data; + jongkyo_state *state = (jongkyo_state *)space->machine->driver_data; + state->videoram2[offset] = data; } static WRITE8_HANDLER( unknown_w ) @@ -192,12 +207,19 @@ static WRITE8_HANDLER( unknown_w ) } } + +/************************************* + * + * Address maps + * + *************************************/ + static ADDRESS_MAP_START( jongkyo_memmap, ADDRESS_SPACE_PROGRAM, 8 ) AM_RANGE(0x0000, 0x3fff) AM_ROM AM_WRITE(videoram2_w) // wrong, this doesn't seem to be video ram on write.. AM_RANGE(0x4000, 0x6bff) AM_ROM // fixed rom AM_RANGE(0x6c00, 0x6fff) AM_ROMBANK("bank1") // banked (8 banks) AM_RANGE(0x7000, 0x77ff) AM_RAM - AM_RANGE(0x8000, 0xffff) AM_RAM AM_BASE_GENERIC(videoram) + AM_RANGE(0x8000, 0xffff) AM_RAM AM_BASE_MEMBER(jongkyo_state, videoram) ADDRESS_MAP_END @@ -214,7 +236,10 @@ static ADDRESS_MAP_START( jongkyo_portmap, ADDRESS_SPACE_IO, 8 ) AM_RANGE(0x46, 0x4f) AM_WRITE(unknown_w) ADDRESS_MAP_END -/* +/************************************* + * + * Input ports + * ------------------------------------------------------------- Jongkyo ?1985 Kiwako DIPSW | |1 2 3 4 |5 |6 |7 |8 @@ -248,7 +273,8 @@ Last chance |5 | | | |on | Bonus credit |50 | | | | |on |10 | | | | |off ------------------------------------------------------------- -*/ + + *************************************/ static INPUT_PORTS_START( jongkyo ) @@ -388,11 +414,18 @@ static INPUT_PORTS_START( jongkyo ) INPUT_PORTS_END +/************************************* + * + * Palette initialization and + * graphics definitions + * + *************************************/ + static PALETTE_INIT(jongkyo) { int i; UINT8* proms = memory_region(machine, "proms"); - for (i=0;i<0x40;i++) + for (i = 0; i < 0x40; i++) { int data = proms[i]; @@ -400,11 +433,17 @@ static PALETTE_INIT(jongkyo) int g = (data >> 3) & 0x07; int b = (data >> 6) & 0x03; - palette_set_color_rgb(machine, i, r<<5, g<<5, b<<6 ); + palette_set_color_rgb(machine, i, r << 5, g << 5, b << 6 ); } } +/************************************* + * + * Sound interface + * + *************************************/ + static const ay8910_interface ay8910_config = { AY8910_LEGACY_OUTPUT, @@ -415,13 +454,47 @@ static const ay8910_interface ay8910_config = DEVCB_NULL }; + +/************************************* + * + * Machine driver + * + *************************************/ + +static MACHINE_START( jongkyo ) +{ + jongkyo_state *state = (jongkyo_state *)machine->driver_data; + + state->videoram2 = auto_alloc_array(machine, UINT8, 0x4000); + state_save_register_global_pointer(machine, state->videoram2, 0x4000); + + state_save_register_global(machine, state->rom_bank); + state_save_register_global(machine, state->mux_data); +} + +static MACHINE_RESET( jongkyo ) +{ + jongkyo_state *state = (jongkyo_state *)machine->driver_data; + + state->rom_bank = 0; + state->mux_data = 0; +} + + static MACHINE_DRIVER_START( jongkyo ) + + /* driver data */ + MDRV_DRIVER_DATA(jongkyo_state) + /* basic machine hardware */ MDRV_CPU_ADD("maincpu", Z80,JONGKYO_CLOCK/4) MDRV_CPU_PROGRAM_MAP(jongkyo_memmap) MDRV_CPU_IO_MAP(jongkyo_portmap) MDRV_CPU_VBLANK_INT("screen", irq0_line_hold) + MDRV_MACHINE_START(jongkyo) + MDRV_MACHINE_RESET(jongkyo) + /* video hardware */ MDRV_SCREEN_ADD("screen", RASTER) MDRV_SCREEN_REFRESH_RATE(60) @@ -443,6 +516,12 @@ static MACHINE_DRIVER_START( jongkyo ) MACHINE_DRIVER_END +/************************************* + * + * ROM definition + * + *************************************/ + ROM_START( jongkyo ) ROM_REGION( 0x9000, "maincpu", 0 ) ROM_LOAD( "epr-6258", 0x00000, 0x02000, CRC(fb8b7bcc) SHA1(8ece7c2c82c237b4b51829d412b2109b96ccd0e7) ) @@ -462,6 +541,12 @@ ROM_START( jongkyo ) ROM_END +/************************************* + * + * Driver initialization + * + *************************************/ + static DRIVER_INIT( jongkyo ) { int i; @@ -475,11 +560,13 @@ static DRIVER_INIT( jongkyo ) /* then do the standard Sega decryption */ jongkyo_decode(machine, "maincpu"); - - videoram2 = auto_alloc_array(machine, UINT8, 0x4000); - state_save_register_global_pointer(machine, videoram2, 0x4000); - } -GAME( 1985, jongkyo, 0, jongkyo, jongkyo, jongkyo, ROT0, "Kiwako", "Jongkyo", GAME_WRONG_COLORS ) +/************************************* + * + * Game driver + * + *************************************/ + +GAME( 1985, jongkyo, 0, jongkyo, jongkyo, jongkyo, ROT0, "Kiwako", "Jongkyo", GAME_WRONG_COLORS | GAME_SUPPORTS_SAVE )