From c5ba574585f6f673341987524c5a676216a0729f Mon Sep 17 00:00:00 2001 From: dinkc64 Date: Tue, 2 Apr 2019 00:16:50 -0400 Subject: [PATCH] add WIP driver for mcr. tapper, timber, tron, discs of tron, etc. --- makefile.burn_rules | 4 +- src/burn/devices/midsat.cpp | 221 +++ src/burn/devices/midsat.h | 17 + src/burn/devices/midssio.cpp | 334 ++++ src/burn/devices/midssio.h | 16 + src/burn/drv/pre90s/d_mcr.cpp | 3159 +++++++++++++++++++++++++++++++++ 6 files changed, 3749 insertions(+), 2 deletions(-) create mode 100644 src/burn/devices/midsat.cpp create mode 100644 src/burn/devices/midsat.h create mode 100644 src/burn/devices/midssio.cpp create mode 100644 src/burn/devices/midssio.h create mode 100644 src/burn/drv/pre90s/d_mcr.cpp diff --git a/makefile.burn_rules b/makefile.burn_rules index 17638dc7e..c872abdc2 100644 --- a/makefile.burn_rules +++ b/makefile.burn_rules @@ -58,7 +58,7 @@ drvsrc = d_arcadecl.cpp d_atarig1.cpp d_badlands.cpp d_batman.cpp d_blstroid.cp d_dynduke.o d_efdt.o d_epos.o d_espial.o d_ettrivia.o d_exedexes.o d_fantland.o d_fastfred.o d_firetrap.o d_flipjack.o d_flower.o d_foodf.o \ d_freekick.o d_funkybee.o d_galaga.o d_galivan.o d_gaplus.o d_ginganin.o d_gng.o d_goindol.o d_gunsmoke.o d_headonb.o d_higemaru.o \ d_himesiki.o d_holeland.o d_hvyunit.o d_invaders.o d_iqblock.o d_jack.o d_jedi.o d_jrpacman.o d_kangaroo.o d_kncljoe.o d_kyugo.o d_ladybug.o d_lasso.o \ - d_lastduel.o d_lwings.o d_mainsnk.o d_mappy.o d_marineb.o d_mario.o d_madmotor.o d_markham.o d_mastboyo.o d_matmania.o d_megasys1.o d_meijinsn.o \ + d_lastduel.o d_lwings.o d_mainsnk.o d_mappy.o d_marineb.o d_mario.o d_madmotor.o d_markham.o d_mastboyo.o d_matmania.o d_mcr.o d_megasys1.o d_meijinsn.o \ d_metlfrzr.o d_mhavoc.o d_millipede.o d_mirax.o d_mitchell.o d_mole.o d_momoko.o d_mmagic.o d_mouser.o d_mrdo.o d_mrflea.o d_mrjong.o d_munchmo.o \ d_mustache.o d_mystston.o d_namcos1.o d_namcos86.o d_ninjakd2.o d_nitedrvr.o d_naughtyb.o d_olibochu.o d_omegrace.o d_pacland.o d_pacman.o \ d_pbaction.o d_pac2650.o d_pengadvb.o d_phoenix.o d_pitnrun.o d_pkunwar.o d_popeye.o d_popper.o d_prehisle.o d_psychic5.o d_pturn.o d_punchout.o \ @@ -100,7 +100,7 @@ depobj = burn.o burn_bitmap.o burn_gun.o burn_led.o burn_shift.o burn_memory.o load.o tilemap_generic.o tiles_generic.o timer.o vector.o \ \ 6821pia.o 8255ppi.o 8257dma.o c169.o atariic.o atarijsa.o atarimo.o atarirle.o atarivad.o avgdvg.o bsmt2000.o decobsmt.o earom.o eeprom.o \ - gaelco_crypt.o joyprocess.o nb1414m4.o nb1414m4_8bit.o nmk004.o nmk112.o kaneko_tmap.o mathbox.o mb87078.o mermaid.o namco_c45.o namcoio.o \ + gaelco_crypt.o joyprocess.o nb1414m4.o nb1414m4_8bit.o nmk004.o nmk112.o kaneko_tmap.o mathbox.o mb87078.o mermaid.o midsat.o midssio.o namco_c45.o namcoio.o \ pandora.o resnet.o seibusnd.o sknsspr.o slapstic.o st0020.o t5182.o timekpr.o tms34061.o v3021.o vdc.o tms9928a.o watchdog.o x2212.o \ \ asteroids.o ay8910.o burn_y8950.o burn_ym2151.o burn_ym2203.o burn_ym2413.o burn_ym2608.o burn_ym2610.o burn_ym2612.o burn_md2612.o \ diff --git a/src/burn/devices/midsat.cpp b/src/burn/devices/midsat.cpp new file mode 100644 index 000000000..5a9e425af --- /dev/null +++ b/src/burn/devices/midsat.cpp @@ -0,0 +1,221 @@ +// Midway Squeak and Talk module +// based on MAME code by Aaron Giles + +#include "burnint.h" +#include "m6800_intf.h" +#include "tms5220.h" +#include "6821pia.h" + +static UINT8 *M6800RAM; +static INT32 tms_command; +static INT32 tms_strobes; +static INT32 midsat_in_reset; +static INT32 midsat_initialized = 0; + +static void midsat_cpu_write(UINT16 address, UINT8 data) +{ + if (address < 0x0080) { + M6800RAM[address] = data; + return; + } + + if ((address & 0xfffc) == 0x0080) { + pia_write(0, address & 3, data); + return; + } + + if ((address & 0xfffc) == 0x0090) { + pia_write(1, address & 3, data); + return; + } + + if ((address & 0x9000) == 0x1000) { + // dac write (no chip on this hardware) + return; + } +} + +static UINT8 midsat_cpu_read(UINT16 address) +{ + if (address < 0x0080) { + return M6800RAM[address]; + } + + if ((address & 0xfffc) == 0x0080) { + return pia_read(0, address & 3); + } + + if ((address & 0xfffc) == 0x0090) { + return pia_read(1, address & 3); + } + + return 0xff; +} + +static void pia0_out_a(UINT16 , UINT8 ) +{ + // for ay8912 (no chip on this hardware) +} + +static void pia1_out_a(UINT16 , UINT8 data) +{ + tms_command = data; +} + +static void pia1_out_b(UINT16 , UINT8 data) +{ + if (((data ^ tms_strobes) & 2) && (~data & 2)) + { + tms5220_write(tms_command); + + pia_set_input_ca2(1, 1); + pia_set_input_ca2(1, 0); + } + else if (((data ^ tms_strobes) & 1) && (~data & 1)) + { + pia_set_input_a(1, tms5220_status()); + + pia_set_input_ca2(1, 1); + pia_set_input_ca2(1, 0); + } + + tms_strobes = data; +} + +static void pia_irq(INT32 state) +{ + M6800SetIRQLine(M6800_IRQ_LINE, state ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE); +} + +static pia6821_interface pia_0 = { + NULL, NULL, + NULL, NULL, NULL, NULL, + pia0_out_a, NULL, NULL, NULL, + pia_irq, pia_irq +}; + +static pia6821_interface pia_1 = { + NULL, NULL, + NULL, NULL, NULL, NULL, + pia1_out_a, pia1_out_b, NULL, NULL, + pia_irq, pia_irq +}; + +void midsat_write(UINT8 data) +{ + M6800Open(0); + pia_set_input_a(0, ~data & 0x0f); + pia_set_input_cb1(0, (~data & 0x10) >> 4); + M6800Close(); +} + +void midsat_reset_write(INT32 state) +{ + if (state == 0 && midsat_in_reset) { + M6800Reset(); + } + + midsat_in_reset = state; +} + +INT32 midsat_reset_status() +{ + return midsat_in_reset; +} + +void midsat_reset() +{ + memset (M6800RAM, 0x00, 0x80); + + M6800Open(0); + M6800Reset(); + tms5220_reset(); + pia_reset(); + M6800Close(); + + tms_command = 0; + tms_strobes = 0; + midsat_in_reset = 0; +} + +void midsat_init(UINT8 *rom) +{ + M6800RAM = (UINT8*)BurnMalloc(0x80); + M6800Init(0); + M6800Open(0); + M6800MapMemory(rom + 0x0000, 0xd000, 0xffff, MAP_ROM); + M6800SetWriteHandler(midsat_cpu_write); + M6800SetReadHandler(midsat_cpu_read); + M6800Close(); + + pia_init(); + pia_config(0, 0, &pia_0); + pia_config(1, 0, &pia_1); + + tms5220_init(M6800TotalCycles, 3579545/4); + tms5220_set_frequency(640000); + midsat_initialized = 1; +} + +void midsat_exit() +{ + M6800Exit(); + pia_exit(); + tms5220_exit(); + + BurnFree(M6800RAM); + + midsat_initialized = 0; +} + +INT32 has_midsat() +{ + return midsat_initialized; +} + +void midsatNewFrame() +{ + M6800NewFrame(); +} + +INT32 midsat_run(INT32 cycles) +{ + if (midsat_in_reset) { + return cycles; + } + + M6800Open(0); + INT32 cyc = M6800Run(cycles); + M6800Close(); + + return cyc; +} + +void midsat_update(INT16 *samples, INT32 length) +{ + M6800Open(0); + tms5220_update(samples, length); + M6800Close(); +} + +void midsat_scan(INT32 nAction, INT32 *pnMin) +{ + struct BurnArea ba; + + if (nAction & ACB_VOLATILE) { + memset(&ba, 0, sizeof(ba)); + + ba.Data = M6800RAM; + ba.nLen = 0x80; + ba.szName = "M6800 Ram"; + BurnAcb(&ba); + + M6800Scan(nAction); + pia_scan(nAction, pnMin); + tms5220_scan(nAction, pnMin); + + SCAN_VAR(tms_strobes); + SCAN_VAR(tms_command); + SCAN_VAR(midsat_in_reset); + } +} diff --git a/src/burn/devices/midsat.h b/src/burn/devices/midsat.h new file mode 100644 index 000000000..ed1a0f709 --- /dev/null +++ b/src/burn/devices/midsat.h @@ -0,0 +1,17 @@ +// Midway Squeak and Talk module + +void midsat_write(UINT8 data); + +void midsat_reset_write(INT32 state); +INT32 midsat_reset_status(); + +void midsat_reset(); +void midsat_init(UINT8 *rom); +void midsat_exit(); + +INT32 has_midsat(); + +void midsatNewFrame(); +INT32 midsat_run(INT32 cycles); +void midsat_update(INT16 *samples, INT32 length); +void midsat_scan(INT32 nAction, INT32 *pnMin); diff --git a/src/burn/devices/midssio.cpp b/src/burn/devices/midssio.cpp new file mode 100644 index 000000000..d5b8cbc22 --- /dev/null +++ b/src/burn/devices/midssio.cpp @@ -0,0 +1,334 @@ +#include "burnint.h" +#include "z80_intf.h" +#include "ay8910.h" + +// #define SSIODEBUG + +static INT32 ssio_14024_count; +static INT32 ssio_data[4]; +static INT32 ssio_status; +static INT32 ssio_duty_cycle[2][3]; +static INT32 ssio_mute; +static INT32 ssio_overall[2]; + +typedef void (*output_func)(UINT8 offset, UINT8 data); +typedef UINT8 (*input_func)(UINT8 offset); + +static double ssio_ayvolume_lookup[16]; +static output_func output_handlers[2] = { NULL, NULL }; +static input_func input_handlers[5] = { NULL, NULL, NULL, NULL, NULL }; +static INT32 output_mask[2] = { 0xff, 0xff }; +static INT32 input_mask[5] = { 0, 0, 0, 0, 0 }; + +UINT8 *ssio_inputs; // 5 +UINT8 ssio_dips; // 1 + +static void __fastcall ssio_cpu_write(UINT16 address, UINT8 data) +{ +// bprintf (0, _T("SW: %4.4x, %2.2x!!!!!!\n"), address, data); + + if ((address & 0xf000) == 0xc000) { +#ifdef SSIODEBUG + bprintf (0, _T("SSIO Status Write: %2.2x\n"), data); +#endif + ssio_status = data; + return; + } + + if ((address & 0xf000) == 0xd000) { + return; // nop + } + + switch (address & ~0xffc) + { + case 0xa000: + AY8910Write(0, 0, data); + return; + + case 0xa002: + AY8910Write(0, 1, data); + return; + + case 0xb000: + AY8910Write(1, 0, data); + return; + + case 0xb002: + AY8910Write(1, 1, data); + return; + } + +} + +static UINT8 __fastcall ssio_cpu_read(UINT16 address) +{ +// bprintf (0, _T("SR: %4.4x!!!!!!\n"), address); + + if ((address & 0xf000) == 0xc000) { + return 0; // nop + } + + if ((address & 0xf000) == 0xe000) { + ssio_14024_count = 0; + ZetSetIRQLine(0, CPU_IRQSTATUS_NONE); + return 0xff; + } + + if ((address & 0xf000) == 0xf000) { + return ssio_dips; + } + + switch (address & ~0xffc) + { + case 0x9000: + case 0x9001: + case 0x9002: + case 0x9003: + return ssio_data[address & 3]; + + case 0xa001: + return AY8910Read(0); + + case 0xb001: + return AY8910Read(1); + } + + + return 0; +} + +static void ssio_update_volumes() +{ + AY8910SetRoute(0, BURN_SND_AY8910_ROUTE_1, ssio_mute ? 0 : ssio_ayvolume_lookup[ssio_duty_cycle[0][0]], BURN_SND_ROUTE_PANLEFT); + AY8910SetRoute(0, BURN_SND_AY8910_ROUTE_2, ssio_mute ? 0 : ssio_ayvolume_lookup[ssio_duty_cycle[0][1]], BURN_SND_ROUTE_PANLEFT); + AY8910SetRoute(0, BURN_SND_AY8910_ROUTE_3, ssio_mute ? 0 : ssio_ayvolume_lookup[ssio_duty_cycle[0][2]], BURN_SND_ROUTE_PANLEFT); + + AY8910SetRoute(1, BURN_SND_AY8910_ROUTE_1, ssio_mute ? 0 : ssio_ayvolume_lookup[ssio_duty_cycle[1][0]], BURN_SND_ROUTE_PANRIGHT); + AY8910SetRoute(1, BURN_SND_AY8910_ROUTE_2, ssio_mute ? 0 : ssio_ayvolume_lookup[ssio_duty_cycle[1][1]], BURN_SND_ROUTE_PANRIGHT); + AY8910SetRoute(1, BURN_SND_AY8910_ROUTE_3, ssio_mute ? 0 : ssio_ayvolume_lookup[ssio_duty_cycle[1][2]], BURN_SND_ROUTE_PANRIGHT); +} + +static void AY8910_write_0A(UINT32 /*addr*/, UINT32 data) +{ + ssio_duty_cycle[0][0] = data & 15; + ssio_duty_cycle[0][1] = data >> 4; + ssio_update_volumes(); +} + +static void AY8910_write_0B(UINT32 /*addr*/, UINT32 data) +{ + ssio_duty_cycle[0][2] = data & 15; + ssio_overall[0] = (data >> 4) & 7; + ssio_update_volumes(); +} + +static void AY8910_write_1A(UINT32 /*addr*/, UINT32 data) +{ + ssio_duty_cycle[1][0] = data & 15; + ssio_duty_cycle[1][1] = data >> 4; + ssio_update_volumes(); +} + +static void AY8910_write_1B(UINT32 /*addr*/, UINT32 data) +{ + ssio_duty_cycle[1][2] = data & 15; + ssio_overall[1] = (data >> 4) & 7; + ssio_mute = data & 0x80; + ssio_update_volumes(); +} + +void ssio_14024_clock() // interrupt generator +{ + // ~26x per frame + if (++ssio_14024_count >= 18) { + ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD); + ssio_14024_count = 0; + } +} + +void ssio_reset_write(INT32 state) +{ + if (state) + { + ZetSetRESETLine(1, 1); + + for (INT32 i = 0; i < 4; i++) + ssio_data[i] = 0; + ssio_status = 0; + ssio_14024_count = 0; + } else { + ZetSetRESETLine(1, 0); + } +} + +static void ssio_compute_ay8910_modulation(UINT8 *prom) +{ + for (INT32 volval = 0; volval < 16; volval++) + { + INT32 clock; + INT32 remaining_clocks = volval; + INT32 cur = 0, prev = 1; + + for (clock = 0; clock < 160 && remaining_clocks; clock++) + { + cur = prom[clock / 8] & (0x80 >> (clock % 8)); + + if (cur == 0 && prev != 0) + remaining_clocks--; + + prev = cur; + } + + ssio_ayvolume_lookup[15-volval] = ((double)(clock * 100 / 160) / 100) / 4; + //bprintf(0, _T("vol %02d: %f\n"), 15-volval,ssio_ayvolume_lookup[15-volval]); + } +} + +static UINT8 ssio_input_port_read(UINT8 offset) +{ + offset &= 7; +// static const char *port[] = { "SSIO.IP0", "SSIO.IP1", "SSIO.IP2", "SSIO.IP3", "SSIO.IP4" }; + + UINT8 result = ssio_inputs[offset & 7]; + + if (input_handlers[offset]) + result = (result & ~input_mask[offset]) | ((input_handlers[offset])(offset) & input_mask[offset]); + + return result; +} + +static void ssio_output_port_write(UINT8 offset, UINT8 data) +{ + offset &= 7; + int which = offset >> 2; +// if (which == 0) mcr_control_port_w(offset, data); + + if (output_handlers[which]) + (*output_handlers[which])(offset, data & output_mask[which]); +} + +void ssio_write_ports(UINT8 address, UINT8 data) +{ + switch (address) + { + case 0x00: + case 0x01: + case 0x02: + case 0x03: + case 0x04: + case 0x05: + case 0x06: + case 0x07: + ssio_output_port_write(address & 7, data); + return; + + case 0x1c: + case 0x1d: + case 0x1e: + case 0x1f: +#ifdef SSIODEBUG + bprintf (0, _T("SSIO Write: %2.2x, %2.2x\n"), address & 3, data); +#endif + ssio_data[address & 3] = data; + return; + } +} + +UINT8 ssio_read_ports(UINT8 address) +{ + switch (address & ~0x18) + { + case 0x00: + case 0x01: + case 0x02: + case 0x03: + case 0x04: + return ssio_input_port_read(address & 7); + + case 0x07: +#ifdef SSIODEBUG + bprintf (0, _T("SSIO Status Read: %2.2x\n"), ssio_status); +#endif + return ssio_status; + } + + return 0xff; +} + +void ssio_set_custom_input(INT32 which, INT32 mask, UINT8 (*handler)(UINT8 offset)) +{ + input_handlers[which] = handler; + input_mask[which] = mask; +} + +void ssio_set_custom_output(INT32 which, INT32 mask, void (*handler)(UINT8 offset, UINT8 data)) +{ + output_handlers[which/4] = handler; + output_mask[which/4] = mask; +} + +void ssio_reset() +{ + ssio_reset_write(1); + ssio_reset_write(0); + + AY8910Reset(0); + AY8910Reset(1); +} + +void ssio_init(UINT8 *rom, UINT8 *ram, UINT8 *prom) +{ + ssio_compute_ay8910_modulation(prom); + + for (INT32 i = 0; i < 4; i++) { + output_handlers[i>>1] = NULL; + input_handlers[i] = NULL; + output_mask[i>>1] = 0xff; + input_mask[i] = 0; + } + + ZetInit(1); + ZetOpen(1); + ZetMapMemory(rom, 0x0000, 0x3fff, MAP_ROM); + ZetMapMemory(ram, 0x8000, 0x83ff, MAP_RAM); + ZetMapMemory(ram, 0x8400, 0x87ff, MAP_RAM); + ZetMapMemory(ram, 0x8800, 0x8bff, MAP_RAM); + ZetMapMemory(ram, 0x8c00, 0x8fff, MAP_RAM); + ZetSetWriteHandler(ssio_cpu_write); + ZetSetReadHandler(ssio_cpu_read); + ZetClose(); + + AY8910Init(0, 2000000, 0); + AY8910Init(1, 2000000, 0); + AY8910SetPorts(0, NULL, NULL, AY8910_write_0A, AY8910_write_0B); + AY8910SetPorts(1, NULL, NULL, AY8910_write_1A, AY8910_write_1B); + AY8910SetAllRoutes(0, 0.05, BURN_SND_ROUTE_PANLEFT); + AY8910SetAllRoutes(1, 0.05, BURN_SND_ROUTE_PANRIGHT); +} + +void ssio_scan(INT32 nAction, INT32 *pnMin) +{ + if (nAction & ACB_VOLATILE) { + AY8910Scan(nAction, pnMin); + + SCAN_VAR(ssio_14024_count); + SCAN_VAR(ssio_data); + SCAN_VAR(ssio_status); + SCAN_VAR(ssio_duty_cycle); + SCAN_VAR(ssio_mute); + SCAN_VAR(ssio_overall); + } +} + +void ssio_exit() +{ + AY8910Exit(0); + AY8910Exit(1); + + ssio_set_custom_output(0, 0xff, NULL); + ssio_set_custom_output(1, 0xff, NULL); + + for (INT32 i = 0; i < 5; i++ ){ + ssio_set_custom_input(i, 0, NULL); + } +} diff --git a/src/burn/devices/midssio.h b/src/burn/devices/midssio.h new file mode 100644 index 000000000..fac897ac8 --- /dev/null +++ b/src/burn/devices/midssio.h @@ -0,0 +1,16 @@ +extern UINT8 *ssio_inputs; // 5 - point to inputs +extern UINT8 ssio_dips; // 1 - dips for ssio board + +void ssio_14024_clock(); // interrupt generator (480x per frame!) + +void ssio_reset_write(INT32 state); +void ssio_write_ports(UINT8 offset, UINT8 data); +UINT8 ssio_read_ports(UINT8 offset); + +void ssio_set_custom_input(INT32 which, INT32 mask, UINT8 (*handler)(UINT8 offset)); +void ssio_set_custom_output(INT32 which, INT32 mask, void (*handler)(UINT8 offset, UINT8 data)); +void ssio_reset(); +void ssio_init(UINT8 *rom, UINT8 *ram, UINT8 *prom); +void ssio_exit(); +void ssio_scan(INT32 nAction, INT32 *pnMin); + diff --git a/src/burn/drv/pre90s/d_mcr.cpp b/src/burn/drv/pre90s/d_mcr.cpp new file mode 100644 index 000000000..2bb0a8d30 --- /dev/null +++ b/src/burn/drv/pre90s/d_mcr.cpp @@ -0,0 +1,3159 @@ +// FB Alpha Midway MCR driver module +// Based on MAME driver by Aaron Giles + +// dink NOTE: +// nvram is really work-ram. for states to work, we need to treat it as +// such. (leave in ram-section of memindex) +// todo(maybe?): figure out where actual nvram is stored in that ram-block + +/* +twotigerc - <<-- todo (alt.inpt) (marked not working/BurnDriverD for now) +demoderb - <<-- todo sound (turbo cheap squeak) +dpoker - don't bother with this (uses light panel/special buttons/etc) +nflfoot - don't bother with this (laserdisc) +*/ + +#include "tiles_generic.h" +#include "z80_intf.h" +#include "midssio.h" +#include "midsat.h" // for dotron +#include "ay8910.h" +#include "samples.h" +#include "watchdog.h" +#include "burn_pal.h" +#include "burn_gun.h" // for dial (kick, kroozr, ..), and trackball (wacko) + +static UINT8 *AllMem; +static UINT8 *MemEnd; +static UINT8 *AllRam; +static UINT8 *RamEnd; +static UINT8 *DrvZ80ROM0; +static UINT8 *DrvZ80ROM1; +static UINT8 *DrvGfxROM0; +static UINT8 *DrvGfxROM1; +static UINT8 *DrvSndPROM; +static UINT8 *DrvNVRAM; +static UINT8 *DrvSprRAM; +static UINT8 *DrvVidRAM; +static UINT8 *DrvZ80RAM1; +static UINT8 *DrvTCSROM; +static UINT16 *DrvPalRAM16; + +static UINT32 *DrvPalette; +static UINT8 DrvRecalc; + +static INT32 flipscreen; + +static INT32 nGraphicsLen0; +static INT32 nGraphicsLen1; +static INT32 nMainClock; +static INT32 nScreenFlip = 0; +static INT32 has_ssio; +static INT32 sprite_config; + +static UINT8 DrvJoy1[8]; +static UINT8 DrvJoy2[8]; +static UINT8 DrvJoy3[8]; +static UINT8 DrvJoy4[8]; +static UINT8 DrvJoy5[8]; +static UINT8 DrvJoy6[8]; +static UINT8 DrvDips[5]; +static UINT8 DrvInputs[6]; +static UINT8 DrvReset; + +static UINT8 DrvJoy4f[8]; +static INT16 DrvAnalogPortX = 0; +static INT16 DrvAnalogPortY = 0; +static INT16 DrvAnalogPort2 = 0; +static INT16 DrvAnalogPort3 = 0; +static INT16 DrvAnalogPortZ = 0; // dial + +static INT32 input_playernum = 0; + +static INT32 has_dial = 0; +static INT32 has_squak = 0; + +static INT32 is_kroozr = 0; +static INT32 is_wacko = 0; +static INT32 is_twotiger = 0; +static INT32 is_dotron = 0; +static INT32 is_demoderb = 0; + +#define A(a, b, c, d) {a, b, (UINT8*)(c), d} +static struct BurnInputInfo SolarfoxInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Up", BIT_DIGITAL, DrvJoy2 + 3, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy2 + 2, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy2 + 1, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy2 + 0, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 2, "p1 fire 2" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Up", BIT_DIGITAL, DrvJoy2 + 7, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy2 + 6, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy2 + 5, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy2 + 4, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy3 + 0, "p2 fire 1" }, + {"P2 Button 2", BIT_DIGITAL, DrvJoy1 + 3, "p2 fire 2" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Solarfox) + +static struct BurnInputInfo KickInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + {"P1 Left", BIT_DIGITAL, DrvJoy4f + 0, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy4f + 1, "p1 right" }, + A("P1 Dial", BIT_ANALOG_REL, &DrvAnalogPortZ,"p1 x-axis"), + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Kick) + +static struct BurnInputInfo TapperInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy2 + 3, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy2 + 2, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy2 + 1, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy2 + 0, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p1 fire 1" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Up", BIT_DIGITAL, DrvJoy3 + 3, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy3 + 2, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy3 + 1, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy3 + 0, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy3 + 4, "p2 fire 1" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Tapper) + +static struct BurnInputInfo ShollowInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Left", BIT_DIGITAL, DrvJoy2 + 0, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy2 + 1, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy2 + 2, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy2 + 3, "p1 fire 2" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Left", BIT_DIGITAL, DrvJoy2 + 4, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy2 + 5, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 1" }, + {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 7, "p2 fire 2" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Shollow) + +static struct BurnInputInfo TronInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy3 + 2, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy3 + 3, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy3 + 0, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy3 + 1, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + A("P1 Dial", BIT_ANALOG_REL, &DrvAnalogPortZ,"p1 x-axis"), + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Up", BIT_DIGITAL, DrvJoy3 + 6, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy3 + 7, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy3 + 4, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy3 + 5, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy4 + 7, "p2 fire 1" }, + A("P2 Dial", BIT_ANALOG_REL, &DrvAnalogPort2,"p2 x-axis"), + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Tron) + +static struct BurnInputInfo KroozrInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + A("P1 Stick X", BIT_ANALOG_REL, &DrvAnalogPortX,"p1 x-axis"), + A("P1 Stick Y", BIT_ANALOG_REL, &DrvAnalogPortY,"p1 y-axis"), + A("P1 Dial", BIT_ANALOG_REL, &DrvAnalogPortZ,"p1 z-axis"), + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy2 + 7, "p1 fire 2" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Kroozr) + +static struct BurnInputInfo DominoInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy2 + 2, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy2 + 3, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy2 + 0, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy2 + 1, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Up", BIT_DIGITAL, DrvJoy3 + 2, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy3 + 3, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy3 + 0, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy3 + 1, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy3 + 4, "p2 fire 1" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Domino) + +static struct BurnInputInfo JourneyInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy2 + 2, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy2 + 3, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy2 + 0, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy2 + 1, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Up", BIT_DIGITAL, DrvJoy3 + 2, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy3 + 3, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy3 + 0, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy3 + 1, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy3 + 4, "p2 fire 1" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Journey) + +static struct BurnInputInfo WackoInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy5 + 3, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy5 + 2, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy5 + 1, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy5 + 0, "p1 right" }, + A("P1 Trackball X", BIT_ANALOG_REL, &DrvAnalogPortX,"p1 x-axis"), + A("P1 Trackball Y", BIT_ANALOG_REL, &DrvAnalogPortY,"p1 y-axis"), + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Up", BIT_DIGITAL, DrvJoy5 + 7, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy5 + 6, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy5 + 5, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy5 + 4, "p2 right" }, + A("P2 Trackball X", BIT_ANALOG_REL, &DrvAnalogPort2,"p2 x-axis"), + A("P2 Trackball Y", BIT_ANALOG_REL, &DrvAnalogPort3,"p2 y-axis"), + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Wacko) + +static struct BurnInputInfo TimberInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy2 + 3, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy2 + 2, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy2 + 1, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy2 + 0, "p1 right" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p1 fire 2" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + {"P2 Up", BIT_DIGITAL, DrvJoy3 + 3, "p2 up" }, + {"P2 Down", BIT_DIGITAL, DrvJoy3 + 2, "p2 down" }, + {"P2 Left", BIT_DIGITAL, DrvJoy3 + 1, "p2 left" }, + {"P2 Right", BIT_DIGITAL, DrvJoy3 + 0, "p2 right" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy3 + 4, "p2 fire 1" }, + {"P2 Button 2", BIT_DIGITAL, DrvJoy3 + 5, "p2 fire 2" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Timber) + +static struct BurnInputInfo TwotigerInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 4, "p1 start" }, + {"P1 & P2 Dogfight Start", BIT_DIGITAL, DrvJoy1 + 3, "p3 start" }, + {"P1 Button 1", BIT_DIGITAL, DrvJoy5 + 2, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy5 + 1, "p1 fire 2" }, + {"P1 Button 3", BIT_DIGITAL, DrvJoy5 + 0, "p1 fire 3" }, + A("P1 Stick X", BIT_ANALOG_REL, &DrvAnalogPortX,"p1 x-axis"), + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 2, "p2 start" }, + {"P2 Button 1", BIT_DIGITAL, DrvJoy5 + 5, "p2 fire 1" }, + {"P2 Button 2", BIT_DIGITAL, DrvJoy5 + 4, "p2 fire 2" }, + {"P2 Button 3", BIT_DIGITAL, DrvJoy5 + 3, "p2 fire 3" }, + A("P2 Stick X", BIT_ANALOG_REL, &DrvAnalogPortY,"p2 x-axis"), + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Twotiger) + +static struct BurnInputInfo DotronInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + {"P1 Up", BIT_DIGITAL, DrvJoy3 + 2, "p1 up" }, + {"P1 Down", BIT_DIGITAL, DrvJoy3 + 3, "p1 down" }, + {"P1 Left", BIT_DIGITAL, DrvJoy3 + 0, "p1 left" }, + {"P1 Right", BIT_DIGITAL, DrvJoy3 + 1, "p1 right" }, + A("P1 Dial", BIT_ANALOG_REL, &DrvAnalogPortZ,"p1 x-axis"), + A("P1 Aim Analog", BIT_ANALOG_REL, &DrvAnalogPortY,"p1 y-axis"), + {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy3 + 6, "p1 fire 2" }, + {"P1 Aim Down", BIT_DIGITAL, DrvJoy3 + 4, "p1 fire 3" }, + {"P1 Aim Up", BIT_DIGITAL, DrvJoy3 + 5, "p1 fire 4" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 5, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, + {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" }, +}; + +STDINPUTINFO(Dotron) + +static struct BurnInputInfo DemoderbInputList[] = { + {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" }, + {"P1 Start", BIT_DIGITAL, DrvJoy1 + 2, "p1 start" }, + A("P1 Dial", BIT_ANALOG_REL, &DrvAnalogPortZ,"p1 x-axis"), + {"P1 Button 1", BIT_DIGITAL, DrvJoy2 + 0, "p1 fire 1" }, + {"P1 Button 2", BIT_DIGITAL, DrvJoy2 + 1, "p1 fire 2" }, + + {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" }, + {"P2 Start", BIT_DIGITAL, DrvJoy1 + 3, "p2 start" }, + A("P2 Dial", BIT_ANALOG_REL, &DrvAnalogPort2,"p2 x-axis"), + {"P2 Button 1", BIT_DIGITAL, DrvJoy3 + 0, "p2 fire 1" }, + {"P2 Button 2", BIT_DIGITAL, DrvJoy3 + 1, "p2 fire 2" }, + + {"P3 Coin", BIT_DIGITAL, DrvJoy5 + 0, "p3 coin" }, + {"P3 Start", BIT_DIGITAL, DrvJoy5 + 2, "p3 start" }, + A("P3 Dial", BIT_ANALOG_REL, &DrvAnalogPortX,"p3 x-axis"), + {"P3 Button 1", BIT_DIGITAL, DrvJoy5 + 4, "p3 fire 1" }, + {"P3 Button 2", BIT_DIGITAL, DrvJoy5 + 5, "p3 fire 2" }, + + {"P4 Coin", BIT_DIGITAL, DrvJoy5 + 1, "p4 coin" }, + {"P4 Start", BIT_DIGITAL, DrvJoy5 + 3, "p4 start" }, + A("P4 Dial", BIT_ANALOG_REL, &DrvAnalogPortY,"p4 x-axis"), + {"P4 Button 1", BIT_DIGITAL, DrvJoy5 + 6, "p4 fire 1" }, + {"P4 Button 2", BIT_DIGITAL, DrvJoy5 + 7, "p4 fire 2" }, + + {"Reset", BIT_DIGITAL, &DrvReset, "reset" }, + {"Tilt", BIT_DIGITAL, DrvJoy1 + 6, "tilt" }, + {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" }, + {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" }, +}; + +STDINPUTINFO(Demoderb) +#undef A + +static struct BurnDIPInfo DemoderbDIPList[]= +{ + {0x16, 0xff, 0xff, 0xff, NULL }, + {0x17, 0xff, 0xff, 0x20, NULL }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x16, 0x01, 0x01, 0x01, "2P Upright" }, + {0x16, 0x01, 0x01, 0x00, "4P Cocktail" }, + + {0 , 0xfe, 0 , 2, "Difficulty" }, + {0x16, 0x01, 0x02, 0x02, "Normal" }, + {0x16, 0x01, 0x02, 0x00, "Harder" }, + + {0 , 0xfe, 0 , 2, "Free Play" }, + {0x16, 0x01, 0x04, 0x04, "Off" }, + {0x16, 0x01, 0x04, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Reward Screen" }, + {0x16, 0x01, 0x08, 0x08, "Expanded" }, + {0x16, 0x01, 0x08, 0x00, "Limited" }, + + {0 , 0xfe, 0 , 4, "Coinage" }, + {0x16, 0x01, 0x30, 0x20, "2 Coins 1 Credits" }, + {0x16, 0x01, 0x30, 0x00, "2 Coins 2 Credits" }, + {0x16, 0x01, 0x30, 0x30, "1 Coin 1 Credits" }, + {0x16, 0x01, 0x30, 0x10, "1 Coin 2 Credits" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x17, 0x01, 0x20, 0x20, "Off" }, + {0x17, 0x01, 0x20, 0x00, "On" }, +}; + +STDDIPINFO(Demoderb) + +static struct BurnDIPInfo DotronDIPList[]= +{ + {0x0f, 0xff, 0xff, 0x80, NULL }, + {0x10, 0xff, 0xff, 0xff, NULL }, + {0x11, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x0f, 0x01, 0x80, 0x00, "Environmental" }, + {0x0f, 0x01, 0x80, 0x80, "Upright" }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x10, 0x01, 0x01, 0x01, "1" }, + {0x10, 0x01, 0x01, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x11, 0x01, 0x80, 0x80, "Off" }, + {0x11, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Dotron) + +static struct BurnDIPInfo DotroneDIPList[]= +{ + {0x0f, 0xff, 0xff, 0x00, NULL }, + {0x10, 0xff, 0xff, 0xff, NULL }, + {0x11, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x0f, 0x01, 0x80, 0x00, "Environmental" }, + {0x0f, 0x01, 0x80, 0x80, "Upright" }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x10, 0x01, 0x01, 0x01, "1" }, + {0x10, 0x01, 0x01, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x11, 0x01, 0x80, 0x80, "Off" }, + {0x11, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Dotrone) + +static struct BurnDIPInfo TwotigerDIPList[]= +{ + {0x10, 0xff, 0xff, 0xfc, NULL }, + {0x11, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Shot Speed" }, + {0x10, 0x01, 0x01, 0x01, "Fast" }, + {0x10, 0x01, 0x01, 0x00, "Slow" }, + + {0 , 0xfe, 0 , 2, "Dogfight" }, + {0x10, 0x01, 0x02, 0x00, "1 Credit" }, + {0x10, 0x01, 0x02, 0x02, "2 Credits" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x11, 0x01, 0x80, 0x80, "Off" }, + {0x11, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Twotiger) + +static struct BurnDIPInfo TimberDIPList[]= +{ + {0x13, 0xff, 0xff, 0xfb, NULL }, + {0x14, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Demo Sounds" }, + {0x13, 0x01, 0x04, 0x04, "Off" }, + {0x13, 0x01, 0x04, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x13, 0x01, 0x40, 0x40, "Upright" }, + {0x13, 0x01, 0x40, 0x00, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x13, 0x01, 0x80, 0x80, "1" }, + {0x13, 0x01, 0x80, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x14, 0x01, 0x80, 0x80, "Off" }, + {0x14, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Timber) + +static struct BurnDIPInfo WackoDIPList[]= +{ + {0x13, 0xff, 0xff, 0x3f, NULL }, + {0x14, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x13, 0x01, 0x40, 0x00, "Upright" }, + {0x13, 0x01, 0x40, 0x40, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x13, 0x01, 0x80, 0x80, "1" }, + {0x13, 0x01, 0x80, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x14, 0x01, 0x80, 0x80, "Off" }, + {0x14, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Wacko) + +static struct BurnDIPInfo JourneyDIPList[]= +{ + {0x11, 0xff, 0xff, 0xfd, NULL }, + {0x12, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x11, 0x01, 0x01, 0x01, "1" }, + {0x11, 0x01, 0x01, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x11, 0x01, 0x02, 0x00, "Upright" }, + {0x11, 0x01, 0x02, 0x02, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x12, 0x01, 0x80, 0x80, "Off" }, + {0x12, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Journey) + +static struct BurnDIPInfo DominoDIPList[]= +{ + {0x11, 0xff, 0xff, 0x3e, NULL }, + {0x12, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Music" }, + {0x11, 0x01, 0x01, 0x01, "Off" }, + {0x11, 0x01, 0x01, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Skin Color" }, + {0x11, 0x01, 0x02, 0x02, "Light" }, + {0x11, 0x01, 0x02, 0x00, "Dark" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x11, 0x01, 0x40, 0x00, "Upright" }, + {0x11, 0x01, 0x40, 0x40, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x11, 0x01, 0x80, 0x80, "1" }, + {0x11, 0x01, 0x80, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x12, 0x01, 0x80, 0x80, "Off" }, + {0x12, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Domino) + +static struct BurnDIPInfo TronDIPList[]= +{ + {0x13, 0xff, 0xff, 0x80, NULL }, + {0x14, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x13, 0x01, 0x01, 0x01, "1" }, + {0x13, 0x01, 0x01, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x13, 0x01, 0x02, 0x00, "Upright" }, + {0x13, 0x01, 0x02, 0x02, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Allow Continue" }, + {0x13, 0x01, 0x04, 0x04, "No" }, + {0x13, 0x01, 0x04, 0x00, "Yes" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x14, 0x01, 0x80, 0x80, "Off" }, + {0x14, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Tron) + +static struct BurnDIPInfo KroozrDIPList[]= +{ + {0x0c, 0xff, 0xff, 0xbf, NULL }, + {0x0d, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x0c, 0x01, 0x40, 0x00, "Upright" }, + {0x0c, 0x01, 0x40, 0x40, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x0d, 0x01, 0x80, 0x80, "Off" }, + {0x0d, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Kroozr) + +static struct BurnDIPInfo SolarfoxDIPList[]= +{ + {0x11, 0xff, 0xff, 0xef, NULL }, + {0x12, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 3, "Bonus" }, + {0x11, 0x01, 0x03, 0x02, "None" }, + {0x11, 0x01, 0x03, 0x03, "After 10 racks" }, + {0x11, 0x01, 0x03, 0x01, "After 20 racks" }, + + {0 , 0xfe, 0 , 2, "Demo Sounds" }, + {0x11, 0x01, 0x10, 0x10, "Off" }, + {0x11, 0x01, 0x10, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Ignore Hardware Failure" }, + {0x11, 0x01, 0x40, 0x40, "Off" }, + {0x11, 0x01, 0x40, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x11, 0x01, 0x80, 0x80, "Upright" }, + {0x11, 0x01, 0x80, 0x00, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x12, 0x01, 0x80, 0x80, "Off" }, + {0x12, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Solarfox) + +static struct BurnDIPInfo KickDIPList[]= +{ + {0x09, 0xff, 0xff, 0xfe, NULL }, + {0x0a, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Music" }, + {0x09, 0x01, 0x01, 0x01, "Off" }, + {0x09, 0x01, 0x01, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x0a, 0x01, 0x80, 0x80, "Off" }, + {0x0a, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Kick) + +static struct BurnDIPInfo TapperDIPList[]= +{ + {0x11, 0xff, 0xff, 0xfb, NULL }, + {0x12, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Demo Sounds" }, + {0x11, 0x01, 0x04, 0x04, "Off" }, + {0x11, 0x01, 0x04, 0x00, "On" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x11, 0x01, 0x40, 0x40, "Upright" }, + {0x11, 0x01, 0x40, 0x00, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x11, 0x01, 0x80, 0x80, "1" }, + {0x11, 0x01, 0x80, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x12, 0x01, 0x80, 0x80, "Off" }, + {0x12, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Tapper) + +static struct BurnDIPInfo ShollowDIPList[]= +{ + {0x0f, 0xff, 0xff, 0xfd, NULL }, + {0x10, 0xff, 0xff, 0x80, NULL }, + + {0 , 0xfe, 0 , 2, "Coin Meters" }, + {0x0f, 0x01, 0x01, 0x01, "1" }, + {0x0f, 0x01, 0x01, 0x00, "2" }, + + {0 , 0xfe, 0 , 2, "Cabinet" }, + {0x0f, 0x01, 0x02, 0x00, "Upright" }, + {0x0f, 0x01, 0x02, 0x02, "Cocktail" }, + + {0 , 0xfe, 0 , 2, "Service Mode" }, + {0x10, 0x01, 0x80, 0x80, "Off" }, + {0x10, 0x01, 0x80, 0x00, "On" }, +}; + +STDDIPINFO(Shollow) + +static void __fastcall mcr_90009_write(UINT16 address, UINT8 data) +{ + if (address >= 0xf400 && address <= 0xfbff) { + INT32 select = (address >> 8) & 8; + address = address & 0x1f; + DrvPalRAM16[address] &= ~(0xff << select); + DrvPalRAM16[address] |= data << select; + return; + } +} + +static void __fastcall mcr_90010_write(UINT16 address, UINT8 data) +{ + if ((address & 0xe800) == 0xe800) { + DrvVidRAM[address & 0x7ff] = data; + + if ((address & 0xef80) == 0xef80) { + address &= 0x7f; + DrvPalRAM16[address/2] = data | ((address & 1) << 8); + } + return; + } +} + +static void __fastcall mcr_91490_write(UINT16 address, UINT8 data) +{ + //bprintf (0, _T("MW: %4.4x, %2.2x\n"), address, data); + if ((address & 0xf800) == 0xf800) { + address &= 0x7f; + DrvPalRAM16[address/2] = data | ((address & 1) << 8); + return; + } +} + +static void __fastcall twotiger_vidram_write(UINT16 address, UINT8 data) +{ + if ((address & 0xe800) == 0xe800) { + INT32 offs = ((address & 0x3ff) << 1) | ((address & 0x400) >> 10); + DrvVidRAM[offs] = data; + + if ((offs & 0x780) == 0x780) { + DrvPalRAM16[((address & 0x400) >> 5) | ((address >> 1) & 0x1f)] = data | ((address & 1) << 8); + return; + } + } +} + +static UINT8 _fastcall twotiger_vidram_read(UINT16 address) +{ + if ((address & 0xe800) == 0xe800) { + INT32 offs = ((address & 0x3ff) << 1) | ((address & 0x400) >> 10); + return DrvVidRAM[offs]; + } + + return 0; +} + +static void __fastcall mcr_write_port(UINT16 address, UINT8 data) +{ +// if ((address & 0xf0) != 0xe0) bprintf (0, _T("MWP: %2.2x, %2.2x\n"), address & 0xff, data); + switch (address & 0xff) + { + case 0x00: + case 0x01: + case 0x02: + case 0x03: + flipscreen = (data >> 6) & 1; + // coin cointers.. + break; // use ssio_write_ports + + case 0xe0: + BurnWatchdogWrite(); + return; + + case 0xe8: + return; // nop + + case 0xf0: + case 0xf1: + case 0xf2: + case 0xf3: + z80ctc_write(address & 3, data); + return; + } + + ssio_write_ports(address, data); +} + +static UINT8 __fastcall mcr_read_port(UINT16 address) +{ +// bprintf (0, _T("MRP: %2.2x\n"), address & 0xff); + switch (address & 0xff) + { + case 0xf0: + case 0xf1: + case 0xf2: + case 0xf3: + return z80ctc_read(address & 3); + } + + return ssio_read_ports(address); +} + +static UINT8 solarfox_ip0_read(UINT8) +{ + return DrvInputs[0]; // wrong! +} + +static UINT8 solarfox_ip1_read(UINT8) +{ + return DrvInputs[1]; // wrong! +} + +static void solarfox_op0_write(UINT8 , UINT8 data) +{ + flipscreen = (data >> 6) & 1; +} + +static UINT8 kroozr_ip1_read(UINT8) +{ + UINT8 tb = BurnTrackballRead(0, 0); + BurnTrackballUpdate(0); + return ((tb & 0x80) >> 1) | ((tb & 0x70) >> 4); +} + +static UINT8 kick_ip1_read(UINT8) +{ + UINT8 tb = (BurnTrackballRead(0, 0) ) & 0x0f; + BurnTrackballUpdate(0); + + return tb; +} + +static tilemap_callback( bg90009 ) +{ + TILE_SET_INFO(0, DrvVidRAM[offs], 0, TILE_GROUP(1)); +} + +static tilemap_callback( bg90010 ) +{ + INT32 attr = DrvVidRAM[offs * 2 + 1]; + INT32 code = DrvVidRAM[offs * 2 + 0] | (attr * 256); + + TILE_SET_INFO(0, code, attr >> 3, TILE_FLIPYX(attr >> 1) | TILE_GROUP(attr >> 6)); +} + +static tilemap_callback( bg91490 ) +{ + INT32 attr = DrvVidRAM[offs * 2 + 1]; + INT32 code = DrvVidRAM[offs * 2 + 0] | (attr * 256); + + TILE_SET_INFO(0, code, attr >> 4, TILE_FLIPYX(attr >> 2) | TILE_GROUP(attr >> 6)); +} + +static void ctc_interrupt(INT32 state) +{ + ZetSetIRQLine(0, state ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE); +// bprintf(0, _T("ctc state %X\n"), state); +// if (state) ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD); +} + +static void ctc_trigger(INT32 , UINT8 data) +{ + z80ctc_trg_write(1, data); +} + +static INT32 DrvDoReset(INT32 clear_mem) +{ + if (clear_mem) { + memset (AllRam, 0x00, RamEnd - AllRam); + } + + memset (DrvNVRAM, 0xff, 0x800); // dink. + + ZetOpen(0); + ZetReset(); + ZetClose(); + + BurnSampleReset(); + ssio_reset(); + if (has_squak) midsat_reset(); + + flipscreen = 0; + + return 0; +} + +static INT32 MemIndex() +{ + UINT8 *Next; Next = AllMem; + + DrvZ80ROM1 = Next; Next += 0x010000; + DrvZ80ROM0 = Next; Next += 0x010000; + DrvTCSROM = Next; Next += 0x010000; + + DrvGfxROM0 = Next; Next += nGraphicsLen0 * 2 * 2 * 2; + DrvGfxROM1 = Next; Next += nGraphicsLen1 * 2; + + DrvSndPROM = Next; Next += 0x0000200; + + DrvPalette = (UINT32*)Next; Next += 0x80 * sizeof(UINT32); + + AllRam = Next; + + DrvNVRAM = Next; Next += 0x000800; // this is really work-ram + DrvSprRAM = Next; Next += 0x000200; + DrvVidRAM = Next; Next += 0x000800; + DrvZ80RAM1 = Next; Next += 0x000400; + DrvPalRAM16 = (UINT16*)Next; Next += 0x40 * sizeof(UINT16); + + RamEnd = Next; + + MemEnd = Next; + + return 0; +} + +static INT32 DrvGfxDecode() +{ + INT32 Plane0[4] = { ((nGraphicsLen0/2)*8)+0, ((nGraphicsLen0/2)*8)+1, 0, 1 }; + INT32 XOffs0[8] = { STEP8(0,2) }; + INT32 YOffs0[8] = { STEP8(0,16) }; + + INT32 L = (nGraphicsLen1 / 4) * 8; + INT32 Plane1[4] = { STEP4(0,1) }; + INT32 XOffs1[32] = { + L*0+0, L*0+4, L*1+0, L*1+4, L*2+0, L*2+4, L*3+0, L*3+4, + L*0+0+8, L*0+4+8, L*1+0+8, L*1+4+8, L*2+0+8, L*2+4+8, L*3+0+8, L*3+4+8, + L*0+0+16, L*0+4+16, L*1+0+16, L*1+4+16, L*2+0+16, L*2+4+16, L*3+0+16, L*3+4+16, + L*0+0+24, L*0+4+24, L*1+0+24, L*1+4+24, L*2+0+24, L*2+4+24, L*3+0+24, L*3+4+24 + }; + INT32 YOffs1[32] = { STEP32(0,32) }; + + UINT8 *tmp = (UINT8*)BurnMalloc((nGraphicsLen1 > nGraphicsLen0) ? nGraphicsLen1 : nGraphicsLen0); + if (tmp == NULL) { + return 1; + } + + GfxDecode((nGraphicsLen0 * 2) / (8 * 8), 4, 8, 8, Plane0, XOffs0, YOffs0, 0x080, DrvGfxROM0, tmp); + + for (INT32 i = 0; i < nGraphicsLen0*2; i+=0x40) { // 2x size and invert pixel + for (INT32 y = 0; y < 16; y++) { + for (INT32 x = 0; x < 16; x++) { + DrvGfxROM0[(i * 4) + (y * 16) + x] = tmp[i + ((y / 2) * 8) + (x / 2)]; + } + } + } + + memcpy (tmp, DrvGfxROM1, nGraphicsLen1); + + GfxDecode((nGraphicsLen1 * 2) / (32 * 32), 4, 32, 32, Plane1, XOffs1, YOffs1, 0x400, tmp, DrvGfxROM1); + + BurnFree(tmp); + + return 0; +} + +static void map_90009() +{ +// ZetInit(0); +// ZetOpen(0); + ZetMapMemory(DrvZ80ROM0, 0x0000, 0x6fff, MAP_ROM); + ZetMapMemory(DrvNVRAM, 0x7000, 0x77ff, MAP_RAM); + ZetMapMemory(DrvNVRAM, 0x7800, 0x7fff, MAP_RAM); + ZetMapMemory(DrvSprRAM, 0xf000, 0xf1ff, MAP_RAM); + ZetMapMemory(DrvSprRAM, 0xf200, 0xf3ff, MAP_RAM); + ZetMapMemory(DrvVidRAM, 0xfc00, 0xffff, MAP_RAM); + ZetSetWriteHandler(mcr_90009_write); + ZetSetOutHandler(mcr_write_port); + ZetSetInHandler(mcr_read_port); +// ZetClose(); + + nMainClock = 2496000; +} + +static UINT8 __fastcall mcr_read_test(UINT16 address) +{ + //bprintf (0, _T("RT: %4.4x\n"), address); + return 0xff; +} + +static void map_90010() +{ +// ZetInit(0); +// ZetOpen(0); + ZetMapMemory(DrvZ80ROM0, 0x0000, 0xbfff, MAP_ROM); + for (INT32 i = 0; i < 0x2000; i+=0x0800) { + ZetMapMemory(DrvNVRAM, 0xc000 + i + 0, 0xc7ff + i + 0, MAP_RAM); + } + for (INT32 i = 0; i < 0x2000; i+=0x1000) { + for (INT32 j = 0; j < 0x800; j+= 0x200) { + ZetMapMemory(DrvSprRAM, 0xe000 + i + j, 0xe1ff + i + j, MAP_RAM); + } + ZetMapMemory(DrvVidRAM, 0xe800 + i + 0, 0xefff + i + 0, MAP_ROM); + } + ZetSetWriteHandler(mcr_90010_write); + ZetSetReadHandler(mcr_read_test); + ZetSetOutHandler(mcr_write_port); + ZetSetInHandler(mcr_read_port); +// ZetClose(); + + nMainClock = 2496000; +} + +static void map_91490() +{ + // ZetInit(0); +// ZetOpen(0); + ZetMapMemory(DrvZ80ROM0, 0x0000, 0xdfff, MAP_ROM); + ZetMapMemory(DrvNVRAM, 0xe000, 0xe7ff, MAP_RAM); + ZetMapMemory(DrvSprRAM, 0xe800, 0xe9ff, MAP_RAM); + ZetMapMemory(DrvSprRAM, 0xea00, 0xebff, MAP_RAM); + ZetMapMemory(DrvVidRAM, 0xf000, 0xf7ff, MAP_RAM); + ZetSetWriteHandler(mcr_91490_write); + ZetSetReadHandler(mcr_read_test); + ZetSetOutHandler(mcr_write_port); + ZetSetInHandler(mcr_read_port); +// ZetClose(); + + nMainClock = 5000000; +} + +static INT32 DrvLoadRoms(bool bLoad) +{ + char* pRomName; + struct BurnRomInfo ri; + UINT8 *pLoad[3] = { DrvZ80ROM0, DrvZ80ROM1, DrvTCSROM }; + UINT8 *gLoad[2] = { DrvGfxROM0, DrvGfxROM1 }; + + for (INT32 i = 0; !BurnDrvGetRomName(&pRomName, i, 0); i++) + { + BurnDrvGetRomInfo(&ri, i); + + if ((ri.nType & BRF_PRG) && ((ri.nType & 7) == 1 || (ri.nType & 7) == 2 || (ri.nType & 7) == 3)) { + INT32 type = (ri.nType - 1) & 3; + //bprintf(0, _T("loading %S, type %d\n"), pRomName, type); + if (bLoad) if (BurnLoadRom(pLoad[type], i, 1)) return 1; + pLoad[type] += ri.nLen; + continue; + } + + if ((ri.nType & BRF_GRA) && ((ri.nType & 7) == 3 || (ri.nType & 7) == 4)) { + INT32 type = (ri.nType - 3) & 1; + if (bLoad) if (BurnLoadRom(gLoad[type], i, 1)) return 1; + gLoad[type] += ri.nLen; + continue; + } + } + + INT32 prg0 = pLoad[0] - DrvZ80ROM0; + INT32 prg1 = pLoad[1] - DrvZ80ROM1; + INT32 prg2 = pLoad[2] - DrvTCSROM; + nGraphicsLen0 = gLoad[0] - DrvGfxROM0; + nGraphicsLen1 = gLoad[1] - DrvGfxROM1; + if (bLoad) { + bprintf (0, _T("PRG0: %x, PRG1: %x, GFX0: %x, GFX1: %x, PRG2: %x\n"), prg0, prg1, nGraphicsLen0, nGraphicsLen1, prg2); + } + if (nGraphicsLen1 & 0x20) nGraphicsLen1 -= 0x20; // wtfff??? + + has_ssio = (prg1) ? 1 : 0; + + return 0; +} + +static INT32 DrvInit(INT32 cpu_board) +{ + BurnSetRefreshRate(30.00); + + DrvZ80ROM0 = DrvZ80ROM1 = DrvTCSROM = 0; + DrvGfxROM0 = DrvGfxROM1 = 0; + + DrvLoadRoms(false); + + AllMem = NULL; + MemIndex(); + INT32 nLen = MemEnd - (UINT8 *)0; + if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1; + memset(AllMem, 0, nLen); + MemIndex(); + + memset (DrvNVRAM, 0xff, 0x800); + + if (DrvLoadRoms(true)) return 1; + + if (BurnLoadRom(DrvSndPROM, 0x80, 1)) return 1; // load sound prom! + + DrvGfxDecode(); + + GenericTilesInit(); + GenericTilemapSetGfx(0, DrvGfxROM0, 4, 16, 16, nGraphicsLen0 * 8, 0, 3); + + ZetInit(0); + ZetOpen(0); + + ZetDaisyInit(Z80_CTC, 0); + z80ctc_init(nMainClock, 0, ctc_interrupt, ctc_trigger, NULL, NULL); + + switch (cpu_board) + { + case 90009: + map_90009(); + GenericTilemapInit(0, TILEMAP_SCAN_ROWS, bg90009_map_callback, 16, 16, 32, 30); + sprite_config = 0x000000; + break; + + case 90010: + map_90010(); + GenericTilemapInit(0, TILEMAP_SCAN_ROWS, bg90010_map_callback, 16, 16, 32, 30); + sprite_config = 0x000000; + break; + + case 91490: // tapper + map_91490(); + GenericTilemapInit(0, TILEMAP_SCAN_ROWS, bg91490_map_callback, 16, 16, 32, 30); + sprite_config = 0x003000; + break; + + case 91475: // journey + map_90010(); + GenericTilemapInit(0, TILEMAP_SCAN_ROWS, bg90010_map_callback, 16, 16, 32, 30); + sprite_config = 0x003040; + break; + + default: bprintf (0, _T("No map selected!!\n")); + } + + ZetClose(); + + BurnSampleInit(1); + BurnSampleSetAllRoutesAllSamples(0.80, BURN_SND_ROUTE_BOTH); + + ssio_init(DrvZ80ROM1, DrvZ80RAM1, DrvSndPROM); + + if (has_squak) { + bprintf(0, _T("Has squak n talk or tcs.\n")); + midsat_init(DrvTCSROM); + } + + BurnWatchdogInit(DrvDoReset, 1180); + + BurnTrackballInit(2); // kick + + DrvDoReset(1); + + return 0; +} + +static INT32 DrvExit() +{ + GenericTilesExit(); + ZetExit(); + ssio_exit(); + + if (has_squak) midsat_exit(); + + BurnSampleExit(); + + BurnTrackballExit(); + + BurnFree(AllMem); + + nScreenFlip = 0; + sprite_config = 0; + + input_playernum = 0; + + has_dial = 0; + + is_kroozr = 0; + is_wacko = 0; + is_twotiger = 0; + is_dotron = 0; + is_demoderb = 0; + + return 0; +} + +static void DrvPaletteUpdate(INT32 type) +{ + if (type == 0) + { + for (INT32 i = 0; i < BurnDrvGetPaletteEntries(); i++) + { + UINT8 r = pal4bit((DrvPalRAM16[i] >> 8) & 0xf); + UINT8 g = pal4bit(DrvPalRAM16[i] & 0xf); + UINT8 b = pal4bit((DrvPalRAM16[i] >> 4)&0xf); + + DrvPalette[i] = BurnHighCol(r,g,b,0); + } + } + else if (type == 1) + { + for (INT32 i = 0; i < BurnDrvGetPaletteEntries(); i++) + { + UINT8 r = pal3bit((DrvPalRAM16[i] >> 6) & 7); + UINT8 g = pal3bit(DrvPalRAM16[i] & 7); + UINT8 b = pal3bit((DrvPalRAM16[i] >> 3) & 7); + + DrvPalette[i] = BurnHighCol(r,g,b,0); + } + } + else if (type == 2) // journey + { + for (INT32 i = 0; i < BurnDrvGetPaletteEntries()/2; i++) + { + UINT8 r = (DrvPalRAM16[i] >> 6) & 7; + UINT8 g = (DrvPalRAM16[i] >> 0) & 7; + UINT8 b = (DrvPalRAM16[i] >> 3) & 7; + + r = (r << 5) | (r << 1); + g = (g << 5) | (g << 1); + b = (b << 5) | (b << 1); + + DrvPalette[i] = BurnHighCol(r,g,b,0); + + if ((i & 0x31) == 0x31) + { + r |= 0x11; + g |= 0x11; + b |= 0x11; + } + + DrvPalette[i + 0x40] = BurnHighCol(r,g,b,0); + } + } +} + +static void render_sprites_91399() +{ + for (INT32 offs = 0; offs < 0x200; offs += 4) + { + INT32 code = DrvSprRAM[offs + 1] & 0x3f; + INT32 hflip = (DrvSprRAM[offs + 1] & 0x40) ? 31 : 0; + INT32 vflip = (DrvSprRAM[offs + 1] & 0x80) ? 31 : 0; + INT32 sx = (DrvSprRAM[offs + 2] - 4) * 2; + INT32 sy = (240 - DrvSprRAM[offs]) * 2; + + /* apply cocktail mode */ + if (flipscreen) + { + hflip ^= 31; + vflip ^= 31; + sx = 466 - sx; // + m_mcr12_sprite_xoffs_flip; + sy = 450 - sy; + } + else + sx += 0; //m_mcr12_sprite_xoffs; + + if (nScreenFlip & TMAP_FLIPY) { + vflip ^= 31; + sy = 450 - sy; + } + if (nScreenFlip & TMAP_FLIPX) { + hflip ^= 31; + sx = 466 - sx; + } + + sx &= 0x1ff; + sy &= 0x1ff; + + for (int y = 0; y < 32; y++, sy = (sy + 1) & 0x1ff) + { + if (sy >= 0 && sy < nScreenHeight) + { + const UINT8 *src = DrvGfxROM1 + (code * 0x400) + 32 * (y ^ vflip); + UINT16 *dst = pTransDraw + (sy * nScreenWidth); + UINT8 *pri = pPrioDraw + (sy * nScreenWidth); + + for (INT32 x = 0; x < 32; x++) + { + INT32 tx = (sx + x) & 0x1ff; + if (tx >= nScreenWidth) continue; + INT32 pix = 0x10 | src[x ^ hflip]; + + pri[tx] = pix; + + if (pix & 0x07) + dst[tx] = pix; + } + } + } + } +} + +static void render_sprites_91464(int primask, int sprmask, int colormask) +{ + INT32 codemask = (nGraphicsLen1 * 2) / (32 * 32); + + for (int offs = 0x200 - 4; offs >= 0; offs -= 4) + { + /* extract the bits of information */ + int code = (DrvSprRAM[offs + 2] + 256 * ((DrvSprRAM[offs + 1] >> 3) & 0x01)) % codemask; + int color = (((~DrvSprRAM[offs + 1] & 3) << 4) & sprmask) | colormask; + int hflip = (DrvSprRAM[offs + 1] & 0x10) ? 31 : 0; + int vflip = (DrvSprRAM[offs + 1] & 0x20) ? 31 : 0; + int sx = (DrvSprRAM[offs + 3] - 3) * 2; + int sy = (241 - DrvSprRAM[offs]) * 2; + + /* apply cocktail mode */ + if (flipscreen) + { + hflip ^= 31; + vflip ^= 31; + sx = 480 - sx; + sy = 452 - sy; + } + + if (nScreenFlip & TMAP_FLIPY) { + vflip ^= 31; + sy = 452 - sy; + } + if (nScreenFlip & TMAP_FLIPX) { + hflip ^= 31; + sx = 480 - sx; + } + + /* clamp within 512 */ + sx &= 0x1ff; + sy &= 0x1ff; + + /* loop over lines in the sprite */ + for (int y = 0; y < 32; y++, sy = (sy + 1) & 0x1ff) + { + if (sy >= 2 && sy >= 0 && sy < nScreenHeight) + { + const UINT8 *src = DrvGfxROM1 + (code * 0x400) + 32 * (y ^ vflip); + UINT16 *dst = pTransDraw + (sy * nScreenWidth); + UINT8 *pri = pPrioDraw + (sy * nScreenWidth); + + /* loop over columns */ + for (int x = 0; x < 32; x++) + { + int tx = (sx + x) & 0x1ff; + if (tx >= nScreenWidth) continue; + + int pix = pri[tx]; + if (pix != 0xff) + { + /* compute the final value */ + pix = (pix & primask) | color | src[x ^ hflip]; + + /* if non-zero, draw */ + if (pix & 0x0f) + { + /* mark this pixel so we don't draw there again */ + pri[tx] = 0xff; + + /* only draw if the low 3 bits are set */ + if (pix & 0x07) + dst[tx] = pix; + } + } + } + } + } + } +} + +static INT32 DrvDraw() +{ + //if (DrvRecalc) { + DrvPaletteUpdate(BurnDrvGetPaletteEntries()/0x40); + DrvRecalc = 1; + //} + + GenericTilemapSetFlip(0, (flipscreen ? (TMAP_FLIPX | TMAP_FLIPY) : 0) ^ nScreenFlip); + + BurnTransferClear(); + + if (nBurnLayer & 1) GenericTilemapDraw(0, pTransDraw, 0x0 | TMAP_SET_GROUP(0)); + if (nBurnLayer & 2) GenericTilemapDraw(0, pTransDraw, 0x1 | TMAP_SET_GROUP(1)); + if (nBurnLayer & 4) GenericTilemapDraw(0, pTransDraw, 0x2 | TMAP_SET_GROUP(2)); + if (nBurnLayer & 8) GenericTilemapDraw(0, pTransDraw, 0x3 | TMAP_SET_GROUP(3)); + + if (sprite_config == 0) + { + if (nSpriteEnable & 1) render_sprites_91399(); + } + else + { + if (nSpriteEnable & 1) render_sprites_91464((sprite_config >> 16) & 0xff, (sprite_config >> 8) & 0xff, sprite_config & 0xff); + } + + BurnTransferCopy(DrvPalette); + + return 0; +} + +static void mcr_interrupt(INT32 scanline) +{ + if (scanline == 0 || scanline == 240) + { + z80ctc_trg_write(2, 1); + z80ctc_trg_write(2, 0); + } + if (scanline == 0) + { + z80ctc_trg_write(3, 1); + z80ctc_trg_write(3, 0); + } +} + +static INT32 DrvFrame() +{ + BurnWatchdogUpdate(); + + if (DrvReset) { + DrvDoReset(1); + } + + ZetNewFrame(); + if (has_squak) midsatNewFrame(); + + { + memset (DrvInputs, 0xff, 6); + + for (INT32 i = 0; i < 8; i++) { + DrvInputs[0] ^= (DrvJoy1[i] & 1) << i; + DrvInputs[1] ^= (DrvJoy2[i] & 1) << i; + DrvInputs[2] ^= (DrvJoy3[i] & 1) << i; + DrvInputs[3] ^= (DrvJoy4[i] & 1) << i; + DrvInputs[4] ^= (DrvJoy5[i] & 1) << i; + DrvInputs[5] ^= (DrvJoy6[i] & 1) << i; + } + + ssio_inputs = DrvInputs; + + DrvInputs[3] = (is_dotron) ? DrvDips[1] : DrvDips[0]; + if (is_demoderb) { + DrvInputs[0] = (DrvInputs[0] & ~0x20) | (DrvDips[1] & 0x20); // service mode + } else { + DrvInputs[0] = (DrvInputs[0] & ~0x80) | (DrvDips[((is_dotron) ? 2 : 1)] & 0x80); // service mode + } + ssio_dips = 0xff; // always 0xff in every mcr game + + { + if (has_dial) { // kick, kroozr, tron, dotron + BurnTrackballConfig(0, AXIS_REVERSED, AXIS_REVERSED); + BurnTrackballFrame(0, DrvAnalogPortZ, DrvAnalogPort2, (is_dotron) ? 2 : 7, (is_dotron) ? 5 : 10); + BurnTrackballUDLR(0, 0, 0, DrvJoy4f[0], DrvJoy4f[1]); + BurnTrackballUpdate(0); + } + + if (is_demoderb) { + BurnTrackballConfig(0, AXIS_NORMAL, AXIS_NORMAL); + BurnTrackballFrame(0, DrvAnalogPortZ, DrvAnalogPort2, 2, 5); + BurnTrackballUpdate(0); + + BurnTrackballConfig(1, AXIS_NORMAL, AXIS_NORMAL); + BurnTrackballFrame(1, DrvAnalogPortX, DrvAnalogPortY, 2, 5); + BurnTrackballUpdate(1); + } + + if (is_dotron) { // dotron up/down "aim" analog + UINT8 an = ProcessAnalog(DrvAnalogPortY, 0, INPUT_DEADZONE, 0x00, 0xff); + if (an != 0x80) { + DrvInputs[2] |= 0x30; // processing analog: ignore digital buttons + if (an < 0x80) DrvInputs[2] &= ( 1 << 4 ); // down + if (an > 0x80) DrvInputs[2] &= ( 1 << 5 ); // up + } + } + + if (is_kroozr) { + DrvInputs[2] = ProcessAnalog(DrvAnalogPortX, 0, INPUT_DEADZONE, 0x30, 0x98); + DrvInputs[4] = ProcessAnalog(DrvAnalogPortY, 0, INPUT_DEADZONE, 0x30, 0x98); + } + + if (is_twotiger) { + DrvInputs[2] = ProcessAnalog(DrvAnalogPortX, 0, INPUT_DEADZONE, 0x00, 0xce); + DrvInputs[1] = ProcessAnalog(DrvAnalogPortY, 0, INPUT_DEADZONE, 0x00, 0xce); + } + + if (is_wacko) { + BurnTrackballConfig(0, AXIS_NORMAL, AXIS_REVERSED); + BurnTrackballFrame(0, DrvAnalogPortX, DrvAnalogPortY, 0x06, 0x0a); + BurnTrackballUpdate(0); + + BurnTrackballConfig(1, AXIS_NORMAL, AXIS_REVERSED); + BurnTrackballFrame(1, DrvAnalogPort2, DrvAnalogPort3, 0x06, 0x0a); + BurnTrackballUpdate(1); + } + } + } + + INT32 nInterleave = 480; + INT32 nCyclesTotal[3] = { nMainClock / 30, 2000000 / 30, 3579545 / 4 / 30 }; + INT32 nCyclesDone[3] = { 0, 0, 0 }; + INT32 nSoundBufferPos = 0; + + for (INT32 i = 0; i < nInterleave; i++) + { + ZetOpen(0); + INT32 cyc_ran = ZetRun(((i + 1) * nCyclesTotal[0] / nInterleave) - nCyclesDone[0]); + nCyclesDone[0] += cyc_ran; + z80ctc_timer_update(cyc_ran); + mcr_interrupt(i); + ZetClose(); + + if (has_ssio) + { + ZetOpen(1); + nCyclesDone[1] += ZetRun(((i + 1) * nCyclesTotal[1] / nInterleave) - nCyclesDone[1]); + ssio_14024_clock(); + ZetClose(); + } + + if (has_squak) { + nCyclesDone[2] += midsat_run(((i + 1) * nCyclesTotal[2] / nInterleave) - nCyclesDone[2]); + } + + // Render Sound Segment + if (pBurnSoundOut && (i%4)==3) { + INT32 nSegmentLength = nBurnSoundLen / (nInterleave/4); + INT16* pSoundBuf = pBurnSoundOut + (nSoundBufferPos << 1); + AY8910Render(pSoundBuf, nSegmentLength); + nSoundBufferPos += nSegmentLength; + } + } + + // Make sure the buffer is entirely filled. + if (pBurnSoundOut) { + INT32 nSegmentLength = nBurnSoundLen - nSoundBufferPos; + INT16* pSoundBuf = pBurnSoundOut + (nSoundBufferPos << 1); + if (nSegmentLength) { + AY8910Render(pSoundBuf, nSegmentLength); + } + BurnSampleRender(pBurnSoundOut, nBurnSoundLen); + if (has_squak) { + midsat_update(pBurnSoundOut, nBurnSoundLen); + } + } + + if (pBurnDraw) { + BurnDrvRedraw(); + } + + return 0; +} + +static INT32 DrvScan(INT32 nAction, INT32 *pnMin) +{ + struct BurnArea ba; + + if (pnMin) { + *pnMin = 0x029702; + } + + if (nAction & ACB_VOLATILE) { + memset(&ba, 0, sizeof(ba)); + + ba.Data = AllRam; + ba.nLen = RamEnd - AllRam; + ba.szName = "All Ram"; + BurnAcb(&ba); + + ZetScan(nAction); + + ssio_scan(nAction, pnMin); + if (has_squak) midsat_scan(nAction, pnMin); + + BurnSampleScan(nAction, pnMin); + + BurnTrackballScan(); + + //SCAN_VAR(); + } + + if (nAction & ACB_WRITE) { + } + + return 0; +} + + +#if 0 + m_mcr12_sprite_xoffs_flip = 0; + m_mcr12_sprite_xoffs = 16; +#endif + + +static struct BurnRomInfo emptyRomDesc[] = { + { "", 0, 0, 0 }, +}; + +static struct BurnRomInfo SsiopromRomDesc[] = { +#if !defined (ROM_VERIFY) + { "82s123.12d", 0x0020, 0xe1281ee9, 0 | BRF_SND }, +#else + { "", 0x000000, 0x00000000, BRF_ESS | BRF_PRG | BRF_BIOS }, +#endif +}; + + +// Solar Fox (upright) + +static struct BurnRomInfo solarfoxRomDesc[] = { + { "sfcpu.3b", 0x1000, 0x8c40f6eb, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code + { "sfcpu.4b", 0x1000, 0x4d47bd7e, 1 | BRF_PRG | BRF_ESS }, // 1 + { "sfcpu.5b", 0x1000, 0xb52c3bd5, 1 | BRF_PRG | BRF_ESS }, // 2 + { "sfcpu.4d", 0x1000, 0xbd5d25ba, 1 | BRF_PRG | BRF_ESS }, // 3 + { "sfcpu.5d", 0x1000, 0xdd57d817, 1 | BRF_PRG | BRF_ESS }, // 4 + { "sfcpu.6d", 0x1000, 0xbd993cd9, 1 | BRF_PRG | BRF_ESS }, // 5 + { "sfcpu.7d", 0x1000, 0x8ad8731d, 1 | BRF_PRG | BRF_ESS }, // 6 + + { "sfsnd.7a", 0x1000, 0xcdecf83a, 2 | BRF_PRG | BRF_ESS }, // 7 Z80 #1 Code (SSIO) + { "sfsnd.8a", 0x1000, 0xcb7788cb, 2 | BRF_PRG | BRF_ESS }, // 8 + { "sfsnd.9a", 0x1000, 0x304896ce, 2 | BRF_PRG | BRF_ESS }, // 9 + + { "sfcpu.4g", 0x1000, 0xba019a60, 3 | BRF_GRA }, // 10 Background Tiles + { "sfcpu.5g", 0x1000, 0x7ff0364e, 3 | BRF_GRA }, // 11 + + { "sfvid.1a", 0x2000, 0x9d9b5d7e, 4 | BRF_GRA }, // 12 Sprites + { "sfvid.1b", 0x2000, 0x78801e83, 4 | BRF_GRA }, // 13 + { "sfvid.1d", 0x2000, 0x4d8445cf, 4 | BRF_GRA }, // 14 + { "sfvid.1e", 0x2000, 0x3da25495, 4 | BRF_GRA }, // 15 +}; + +STDROMPICKEXT(solarfox, solarfox, Ssioprom) +STD_ROM_FN(solarfox) + +static INT32 SolarfoxInit() +{ + INT32 nRet = DrvInit(90009); + + nScreenFlip = TMAP_FLIPY; + + if (nRet == 0) + { + ssio_set_custom_input(0, 0x1c, solarfox_ip0_read); + ssio_set_custom_input(1, 0xff, solarfox_ip1_read); + ssio_set_custom_output(0, 0xff, solarfox_op0_write); + } + + return nRet; +} + +struct BurnDriver BurnDrvSolarfox = { + "solarfox", NULL, "midssio", NULL, "1981", + "Solar Fox (upright)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, solarfoxRomInfo, solarfoxRomName, NULL, NULL, NULL, NULL, SolarfoxInputInfo, SolarfoxDIPInfo, + SolarfoxInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x20, + 480, 512, 3, 4 +}; + + +// Kick (upright) + +static struct BurnRomInfo kickRomDesc[] = { + { "1200a-v2.b3", 0x1000, 0x65924917, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code + { "1300b-v2.b4", 0x1000, 0x27929f52, 1 | BRF_PRG | BRF_ESS }, // 1 + { "1400c-v2.b5", 0x1000, 0x69107ce6, 1 | BRF_PRG | BRF_ESS }, // 2 + { "1500d-v2.d4", 0x1000, 0x04a23aa1, 1 | BRF_PRG | BRF_ESS }, // 3 + { "1600e-v2.d5", 0x1000, 0x1d2834c0, 1 | BRF_PRG | BRF_ESS }, // 4 + { "1700f-v2.d6", 0x1000, 0xddf84ce1, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "4200-a.a7", 0x1000, 0x9e35c02e, 2 | BRF_PRG | BRF_ESS }, // 6 Z80 #1 Code + { "4300-b.a8", 0x1000, 0xca2b7c28, 2 | BRF_PRG | BRF_ESS }, // 7 + { "4400-c.a9", 0x1000, 0xd1901551, 2 | BRF_PRG | BRF_ESS }, // 8 + { "4500-d.a10", 0x1000, 0xd36ddcdc, 2 | BRF_PRG | BRF_ESS }, // 9 + + { "1800g-v2.g4", 0x1000, 0xb4d120f3, 3 | BRF_GRA }, // 10 Background Tiles + { "1900h-v2.g5", 0x1000, 0xc3ba4893, 3 | BRF_GRA }, // 11 + + { "2600a-v2.1e", 0x2000, 0x2c5d6b55, 4 | BRF_GRA }, // 12 Sprites + { "2700b-v2.1d", 0x2000, 0x565ea97d, 4 | BRF_GRA }, // 13 + { "2800c-v2.1b", 0x2000, 0xf3be56a1, 4 | BRF_GRA }, // 14 + { "2900d-v2.1a", 0x2000, 0x77da795e, 4 | BRF_GRA }, // 15 +}; + +STDROMPICKEXT(kick, kick, Ssioprom) +STD_ROM_FN(kick) + +static INT32 KickInit() +{ + INT32 nRet = DrvInit(90009); + + nScreenFlip = TMAP_FLIPY; + + if (nRet == 0) + { + has_dial = 1; + ssio_set_custom_input(1, 0xff, kick_ip1_read); + ssio_set_custom_output(0, 0xff, solarfox_op0_write); + } + + return nRet; +} + +static INT32 KickcInit() +{ + INT32 nRet = KickInit(); + + nScreenFlip = 0; + + return nRet; +} + +struct BurnDriver BurnDrvKick = { + "kick", NULL, "midssio", NULL, "1981", + "Kick (upright)\0", NULL, "Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, kickRomInfo, kickRomName, NULL, NULL, NULL, NULL, KickInputInfo, KickDIPInfo, + KickInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x20, + 480, 512, 3, 4 +}; + + +// Kickman (upright) + +static struct BurnRomInfo kickmanRomDesc[] = { + { "1200-a-ur.b3", 0x1000, 0xd8cd9f0f, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "1300-b-ur.b4", 0x1000, 0x4dee27bb, 1 | BRF_PRG | BRF_ESS }, // 1 + { "1400-c-ur.b5", 0x1000, 0x06f070c9, 1 | BRF_PRG | BRF_ESS }, // 2 + { "1500-d-ur.d4", 0x1000, 0x8d95b740, 1 | BRF_PRG | BRF_ESS }, // 3 + { "1600-e-ur.d5", 0x1000, 0xf24bc0d7, 1 | BRF_PRG | BRF_ESS }, // 4 + { "1700-f-ur.d6", 0x1000, 0x672361fc, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "4200-a.a7", 0x1000, 0x9e35c02e, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "4300-b.a8", 0x1000, 0xca2b7c28, 2 | BRF_PRG | BRF_ESS }, // 7 + { "4400-c.a9", 0x1000, 0xd1901551, 2 | BRF_PRG | BRF_ESS }, // 8 + { "4500-d.a10", 0x1000, 0xd36ddcdc, 2 | BRF_PRG | BRF_ESS }, // 9 + + { "1800g-v2.g4", 0x1000, 0xb4d120f3, 3 | BRF_GRA }, // 10 gfx1 + { "1900h-v2.g5", 0x1000, 0xc3ba4893, 3 | BRF_GRA }, // 11 + + { "2600a-v2.1e", 0x2000, 0x2c5d6b55, 4 | BRF_GRA }, // 12 gfx2 + { "2700b-v2.1d", 0x2000, 0x565ea97d, 4 | BRF_GRA }, // 13 + { "2800c-v2.1b", 0x2000, 0xf3be56a1, 4 | BRF_GRA }, // 14 + { "2900d-v2.1a", 0x2000, 0x77da795e, 4 | BRF_GRA }, // 15 +}; + +STDROMPICKEXT(kickman, kickman, Ssioprom) +STD_ROM_FN(kickman) + +struct BurnDriver BurnDrvKickman = { + "kickman", "kick", "ssio", NULL, "1981", + "Kickman (upright)\0", NULL, "Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, kickmanRomInfo, kickmanRomName, NULL, NULL, NULL, NULL, KickInputInfo, KickDIPInfo, + KickInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x20, + 480, 512, 3, 4 +}; + + +// Kick (cocktail) + +static struct BurnRomInfo kickcRomDesc[] = { + { "1200-a.b3", 0x1000, 0x22fa42ed, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "1300-b.b4", 0x1000, 0xafaca819, 1 | BRF_PRG | BRF_ESS }, // 1 + { "1400-c.b5", 0x1000, 0x6054ee56, 1 | BRF_PRG | BRF_ESS }, // 2 + { "1500-d.d4", 0x1000, 0x263af0f3, 1 | BRF_PRG | BRF_ESS }, // 3 + { "1600-e.d5", 0x1000, 0xeaaa78a7, 1 | BRF_PRG | BRF_ESS }, // 4 + { "1700-f.d6", 0x1000, 0xc06c880f, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "4200-a.a7", 0x1000, 0x9e35c02e, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "4300-b.a8", 0x1000, 0xca2b7c28, 2 | BRF_PRG | BRF_ESS }, // 7 + { "4400-c.a9", 0x1000, 0xd1901551, 2 | BRF_PRG | BRF_ESS }, // 8 + { "4500-d.a10", 0x1000, 0xd36ddcdc, 2 | BRF_PRG | BRF_ESS }, // 9 + + { "1000-g.g4", 0x1000, 0xacdae4f6, 3 | BRF_GRA }, // 10 gfx1 + { "1100-h.g5", 0x1000, 0xdbb18c96, 3 | BRF_GRA }, // 11 + + { "2600-a.1e", 0x2000, 0x74b409d7, 4 | BRF_GRA }, // 12 gfx2 + { "2700-b.1d", 0x2000, 0x78eda36c, 4 | BRF_GRA }, // 13 + { "2800-c.1b", 0x2000, 0xc93e0170, 4 | BRF_GRA }, // 14 + { "2900-d.1a", 0x2000, 0x91e59383, 4 | BRF_GRA }, // 15 +}; + +STDROMPICKEXT(kickc, kickc, Ssioprom) +STD_ROM_FN(kickc) + +struct BurnDriver BurnDrvKickc = { + "kickc", "kick", "ssio", NULL, "1981", + "Kick (cocktail)\0", NULL, "Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, kickcRomInfo, kickcRomName, NULL, NULL, NULL, NULL, KickInputInfo, KickDIPInfo,//, KickcInputInfo, KickcDIPInfo, + KickcInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x20, + 480, 512, 3, 4 +}; + + +// Draw Poker (Bally, 03-20) + +static struct BurnRomInfo dpokerRomDesc[] = { + { "vppp.b3", 0x1000, 0x2a76ded2, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "vppp.b4", 0x1000, 0xd6948faa, 1 | BRF_PRG | BRF_ESS }, // 1 + { "vppp.b5", 0x1000, 0xa49916e5, 1 | BRF_PRG | BRF_ESS }, // 2 + { "vppp.d4", 0x1000, 0xc496934f, 1 | BRF_PRG | BRF_ESS }, // 3 + { "vppp.d5", 0x1000, 0x84f4bd38, 1 | BRF_PRG | BRF_ESS }, // 4 + { "vppp.d6", 0x1000, 0xb0023bf1, 1 | BRF_PRG | BRF_ESS }, // 5 + { "vppp.d7", 0x1000, 0xa4012f5a, 1 | BRF_PRG | BRF_ESS }, // 6 + + { "vssp.a7", 0x1000, 0xf78b2283, 2 | BRF_PRG | BRF_ESS }, // 7 ssio:cpu + { "vssp.a8", 0x1000, 0x3f531bd0, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "vpbg.g4", 0x1000, 0x9fe9aad8, 3 | BRF_GRA }, // 9 gfx1 + { "vpbg.g5", 0x1000, 0xd43aeaae, 3 | BRF_GRA }, // 10 + + { "vpfg.a1", 0x2000, 0xd76ec7dd, 4 | BRF_GRA }, // 11 gfx2 + { "vpfg.b1", 0x2000, 0xcdba9a7d, 4 | BRF_GRA }, // 12 + { "vpfg.d1", 0x2000, 0xc661cace, 4 | BRF_GRA }, // 13 + { "vpfg.e1", 0x2000, 0xacb3b469, 4 | BRF_GRA }, // 14 +}; + +STDROMPICKEXT(dpoker, dpoker, Ssioprom) +STD_ROM_FN(dpoker) + +static INT32 DpokerInit() +{ + INT32 nRet = DrvInit(90009); + + if (nRet == 0) + { + // ssio_set_custom_input(1, 0xff, kick_ip1_read); + // ssio_set_custom_output(0, 0xff, solarfox_op0_write); + } + + return nRet; +} + +struct BurnDriverD BurnDrvDpoker = { + "dpoker", NULL, "midssio", NULL, "1985", + "Draw Poker (Bally, 03-20)\0", NULL, "Bally", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_NOT_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, dpokerRomInfo, dpokerRomName, NULL, NULL, NULL, NULL, KickInputInfo, KickDIPInfo,//DpokerInputInfo, DpokerDIPInfo, + DpokerInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x20, + 512, 480, 4, 3 +}; + + +// Satan's Hollow (set 1) + +static struct BurnRomInfo shollowRomDesc[] = { + { "sh-pro.00", 0x2000, 0x95e2b800, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "sh-pro.01", 0x2000, 0xb99f6ff8, 1 | BRF_PRG | BRF_ESS }, // 1 + { "sh-pro.02", 0x2000, 0x1202c7b2, 1 | BRF_PRG | BRF_ESS }, // 2 + { "sh-pro.03", 0x2000, 0x0a64afb9, 1 | BRF_PRG | BRF_ESS }, // 3 + { "sh-pro.04", 0x2000, 0x22fa9175, 1 | BRF_PRG | BRF_ESS }, // 4 + { "sh-pro.05", 0x2000, 0x1716e2bb, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "sh-snd.01", 0x1000, 0x55a297cc, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "sh-snd.02", 0x1000, 0x46fc31f6, 2 | BRF_PRG | BRF_ESS }, // 7 + { "sh-snd.03", 0x1000, 0xb1f4a6a8, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "sh-bg.00", 0x2000, 0x3e2b333c, 3 | BRF_GRA }, // 9 gfx1 + { "sh-bg.01", 0x2000, 0xd1d70cc4, 3 | BRF_GRA }, // 10 + + { "sh-fg.00", 0x2000, 0x33f4554e, 4 | BRF_GRA }, // 11 gfx2 + { "sh-fg.01", 0x2000, 0xba1a38b4, 4 | BRF_GRA }, // 12 + { "sh-fg.02", 0x2000, 0x6b57f6da, 4 | BRF_GRA }, // 13 + { "sh-fg.03", 0x2000, 0x37ea9d07, 4 | BRF_GRA }, // 14 +}; + +STDROMPICKEXT(shollow, shollow, Ssioprom) +STD_ROM_FN(shollow) + +static INT32 ShollowInit() +{ + return DrvInit(90010); +} + +struct BurnDriver BurnDrvShollow = { + "shollow", NULL, "midssio", NULL, "1981", + "Satan's Hollow (set 1)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, shollowRomInfo, shollowRomName, NULL, NULL, NULL, NULL, ShollowInputInfo, ShollowDIPInfo, + ShollowInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 +}; + + +// Satan's Hollow (set 2) + +static struct BurnRomInfo shollow2RomDesc[] = { + { "sh-pro.00", 0x2000, 0x95e2b800, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "sh-pro.01", 0x2000, 0xb99f6ff8, 1 | BRF_PRG | BRF_ESS }, // 1 + { "sh-pro.02", 0x2000, 0x1202c7b2, 1 | BRF_PRG | BRF_ESS }, // 2 + { "sh-pro.03", 0x2000, 0x0a64afb9, 1 | BRF_PRG | BRF_ESS }, // 3 + { "sh-pro.04", 0x2000, 0x22fa9175, 1 | BRF_PRG | BRF_ESS }, // 4 + { "sh-pro.05", 0x2000, 0x1716e2bb, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "snd-0.a7", 0x1000, 0x9d815bb3, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "snd-1.a8", 0x1000, 0x9f253412, 2 | BRF_PRG | BRF_ESS }, // 7 + { "snd-2.a9", 0x1000, 0x7783d6c6, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "sh-bg.00", 0x2000, 0x3e2b333c, 3 | BRF_GRA }, // 9 gfx1 + { "sh-bg.01", 0x2000, 0xd1d70cc4, 3 | BRF_GRA }, // 10 + + { "sh-fg.00", 0x2000, 0x33f4554e, 4 | BRF_GRA }, // 11 gfx2 + { "sh-fg.01", 0x2000, 0xba1a38b4, 4 | BRF_GRA }, // 12 + { "sh-fg.02", 0x2000, 0x6b57f6da, 4 | BRF_GRA }, // 13 + { "sh-fg.03", 0x2000, 0x37ea9d07, 4 | BRF_GRA }, // 14 +}; + +STDROMPICKEXT(shollow2, shollow2, Ssioprom) +STD_ROM_FN(shollow2) + +struct BurnDriver BurnDrvShollow2 = { + "shollow2", "shollow", "midssio", NULL, "1981", + "Satan's Hollow (set 2)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, shollow2RomInfo, shollow2RomName, NULL, NULL, NULL, NULL, ShollowInputInfo, ShollowDIPInfo, + ShollowInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 + +}; + + +// Tron (8/9) + +static struct BurnRomInfo tronRomDesc[] = { + { "pro0.d2", 0x2000, 0x0de0471a, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "scpu_pgb.d3", 0x2000, 0x8ddf8717, 1 | BRF_PRG | BRF_ESS }, // 1 + { "scpu_pgc.d4", 0x2000, 0x4241e3a0, 1 | BRF_PRG | BRF_ESS }, // 2 + { "scpu_pgd.d5", 0x2000, 0x035d2fe7, 1 | BRF_PRG | BRF_ESS }, // 3 + { "scpu_pge.d6", 0x2000, 0x24c185d8, 1 | BRF_PRG | BRF_ESS }, // 4 + { "scpu_pgf.d7", 0x2000, 0x38c4bbaf, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "ssi_0a.a7", 0x1000, 0x765e6eba, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "ssi_0b.a8", 0x1000, 0x1b90ccdd, 2 | BRF_PRG | BRF_ESS }, // 7 + { "ssi_0c.a9", 0x1000, 0x3a4bc629, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "scpu_bgg.g3", 0x2000, 0x1a9ed2f5, 3 | BRF_GRA }, // 9 gfx1 + { "scpu_bgh.g4", 0x2000, 0x3220f974, 3 | BRF_GRA }, // 10 + + { "vga.e1", 0x2000, 0xbc036d1d, 4 | BRF_GRA }, // 11 gfx2 + { "vgb.dc1", 0x2000, 0x58ee14d3, 4 | BRF_GRA }, // 12 + { "vgc.cb1", 0x2000, 0x3329f9d4, 4 | BRF_GRA }, // 13 + { "vga.a1", 0x2000, 0x9743f873, 4 | BRF_GRA }, // 14 + + { "0066-313bx-xxqx.a12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 15 scpu_pals + { "0066-315bx-xxqx.b12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 16 + { "0066-322bx-xx0x.e3.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 17 + { "0066-316bx-xxqx.g11.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 18 + { "0066-314bx-xxqx.g12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 19 +}; + +STDROMPICKEXT(tron, tron, Ssioprom) +STD_ROM_FN(tron) + +static UINT8 tron_ip1_read(UINT8) +{ + return BurnTrackballRead(0, 0); +} + +static UINT8 tron_ip4_read(UINT8) +{ + return BurnTrackballRead(0, 1); +} + +static INT32 TronInit() +{ + INT32 nRet = DrvInit(90010); + + if (!nRet) { + has_dial = 1; + ssio_set_custom_input(1, 0xff, tron_ip1_read); + ssio_set_custom_input(4, 0xff, tron_ip4_read); + } + + return nRet; +} + +struct BurnDriver BurnDrvTron = { + "tron", NULL, "midssio", NULL, "1982", + "Tron (8/9)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tronRomInfo, tronRomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo, + TronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 +}; + + +// Tron (6/25) + +static struct BurnRomInfo tron2RomDesc[] = { + { "scpu_pga.d2", 0x2000, 0x5151770b, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "scpu_pgb.d3", 0x2000, 0x8ddf8717, 1 | BRF_PRG | BRF_ESS }, // 1 + { "scpu_pgc.d4", 0x2000, 0x4241e3a0, 1 | BRF_PRG | BRF_ESS }, // 2 + { "scpu_pgd.d5", 0x2000, 0x035d2fe7, 1 | BRF_PRG | BRF_ESS }, // 3 + { "scpu_pge.d6", 0x2000, 0x24c185d8, 1 | BRF_PRG | BRF_ESS }, // 4 + { "scpu_pgf.d7", 0x2000, 0x38c4bbaf, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "ssi_0a.a7", 0x1000, 0x765e6eba, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "ssi_0b.a8", 0x1000, 0x1b90ccdd, 2 | BRF_PRG | BRF_ESS }, // 7 + { "ssi_0c.a9", 0x1000, 0x3a4bc629, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "scpu_bgg.g3", 0x2000, 0x1a9ed2f5, 3 | BRF_GRA }, // 9 gfx1 + { "scpu_bgh.g4", 0x2000, 0x3220f974, 3 | BRF_GRA }, // 10 + + { "vga.e1", 0x2000, 0xbc036d1d, 4 | BRF_GRA }, // 11 gfx2 + { "vgb.dc1", 0x2000, 0x58ee14d3, 4 | BRF_GRA }, // 12 + { "vgc.cb1", 0x2000, 0x3329f9d4, 4 | BRF_GRA }, // 13 + { "vga.a1", 0x2000, 0x9743f873, 4 | BRF_GRA }, // 14 + + { "0066-313bx-xxqx.a12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 15 scpu_pals + { "0066-315bx-xxqx.b12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 16 + { "0066-322bx-xx0x.e3.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 17 + { "0066-316bx-xxqx.g11.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 18 + { "0066-314bx-xxqx.g12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 19 +}; + +STDROMPICKEXT(tron2, tron2, Ssioprom) +STD_ROM_FN(tron2) + +struct BurnDriver BurnDrvTron2 = { + "tron2", "tron", "midssio", NULL, "1982", + "Tron (6/25)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tron2RomInfo, tron2RomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo, + TronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 +}; + + +// Tron (6/17) + +static struct BurnRomInfo tron3RomDesc[] = { + { "scpu_pga.d2", 0x2000, 0xfc33afd7, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "scpu_pgb.d3", 0x2000, 0x7d9e22ac, 1 | BRF_PRG | BRF_ESS }, // 1 + { "scpu_pgc.d4", 0x2000, 0x902011c6, 1 | BRF_PRG | BRF_ESS }, // 2 + { "scpu_pgd.d5", 0x2000, 0x86477e89, 1 | BRF_PRG | BRF_ESS }, // 3 + { "scpu_pge.d6", 0x2000, 0xea198fa8, 1 | BRF_PRG | BRF_ESS }, // 4 + { "scpu_pgf.d7", 0x2000, 0x4325fb08, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "ssi_0a.a7", 0x1000, 0x765e6eba, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "ssi_0b.a8", 0x1000, 0x1b90ccdd, 2 | BRF_PRG | BRF_ESS }, // 7 + { "ssi_0c.a9", 0x1000, 0x3a4bc629, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "scpu_bgg.g3", 0x2000, 0x1a9ed2f5, 3 | BRF_GRA }, // 9 gfx1 + { "scpu_bgh.g4", 0x2000, 0x3220f974, 3 | BRF_GRA }, // 10 + + { "vga.e1", 0x2000, 0xbc036d1d, 4 | BRF_GRA }, // 11 gfx2 + { "vgb.dc1", 0x2000, 0x58ee14d3, 4 | BRF_GRA }, // 12 + { "vgc.cb1", 0x2000, 0x3329f9d4, 4 | BRF_GRA }, // 13 + { "vga.a1", 0x2000, 0x9743f873, 4 | BRF_GRA }, // 14 + + { "0066-313bx-xxqx.a12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 15 scpu_pals + { "0066-315bx-xxqx.b12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 16 + { "0066-322bx-xx0x.e3.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 17 + { "0066-316bx-xxqx.g11.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 18 + { "0066-314bx-xxqx.g12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 19 +}; + +STDROMPICKEXT(tron3, tron3, Ssioprom) +STD_ROM_FN(tron3) + +struct BurnDriver BurnDrvTron3 = { + "tron3", "tron", "midssio", NULL, "1982", + "Tron (6/17)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tron3RomInfo, tron3RomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo,// Tron3InputInfo, Tron3DIPInfo, + TronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 +}; + + +// Tron (6/15) + +static struct BurnRomInfo tron4RomDesc[] = { + { "pga-615.d2", 0x2000, 0x09d7a95a, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "pgb-615.d3", 0x2000, 0xb454337d, 1 | BRF_PRG | BRF_ESS }, // 1 + { "pgc-615.d4", 0x2000, 0xac1836ff, 1 | BRF_PRG | BRF_ESS }, // 2 + { "pgd-615.d5", 0x2000, 0x1a7bec6d, 1 | BRF_PRG | BRF_ESS }, // 3 + { "pge-615.d6", 0x2000, 0xea198fa8, 1 | BRF_PRG | BRF_ESS }, // 4 + { "pgf-615.d7", 0x2000, 0x790ee743, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "ssi_oa.a7", 0x1000, 0x2cbb332b, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "ssi_ob.a8", 0x1000, 0x1355b7e6, 2 | BRF_PRG | BRF_ESS }, // 7 + { "ssi_oc.a9", 0x1000, 0x6dd4b7c9, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "scpu_bgg.g3", 0x2000, 0x1a9ed2f5, 3 | BRF_GRA }, // 9 gfx1 + { "scpu_bgh.g4", 0x2000, 0x3220f974, 3 | BRF_GRA }, // 10 + + { "vga.e1", 0x2000, 0xbc036d1d, 4 | BRF_GRA }, // 11 gfx2 + { "vgb.dc1", 0x2000, 0x58ee14d3, 4 | BRF_GRA }, // 12 + { "vgc.cb1", 0x2000, 0x3329f9d4, 4 | BRF_GRA }, // 13 + { "vga.a1", 0x2000, 0x9743f873, 4 | BRF_GRA }, // 14 + + { "0066-313bx-xxqx.a12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 15 scpu_pals + { "0066-315bx-xxqx.b12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 16 + { "0066-322bx-xx0x.e3.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 17 + { "0066-316bx-xxqx.g11.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 18 + { "0066-314bx-xxqx.g12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 19 +}; + +STDROMPICKEXT(tron4, tron4, Ssioprom) +STD_ROM_FN(tron4) + +struct BurnDriver BurnDrvTron4 = { + "tron4", "tron", "midssio", NULL, "1982", + "Tron (6/15)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tron4RomInfo, tron4RomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo,//, Tron3InputInfo, Tron3DIPInfo, + TronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 +}; + + +// Tron (Germany) + +static struct BurnRomInfo trongerRomDesc[] = { + { "pro0.d2", 0x2000, 0xba14603d, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "scpu_pgb.d3", 0x2000, 0x063a748f, 1 | BRF_PRG | BRF_ESS }, // 1 + { "scpu_pgc.d4", 0x2000, 0x6ca50365, 1 | BRF_PRG | BRF_ESS }, // 2 + { "scpu_pgd.d5", 0x2000, 0xb5b241c9, 1 | BRF_PRG | BRF_ESS }, // 3 + { "scpu_pge.d6", 0x2000, 0x04597abe, 1 | BRF_PRG | BRF_ESS }, // 4 + { "scpu_pgf.d7", 0x2000, 0x3908e404, 1 | BRF_PRG | BRF_ESS }, // 5 + + { "ssi_0a.a7", 0x1000, 0x765e6eba, 2 | BRF_PRG | BRF_ESS }, // 6 ssio:cpu + { "ssi_0b.a8", 0x1000, 0x1b90ccdd, 2 | BRF_PRG | BRF_ESS }, // 7 + { "ssi_0c.a9", 0x1000, 0x3a4bc629, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "scpu_bgg.g3", 0x2000, 0x1a9ed2f5, 3 | BRF_GRA }, // 9 gfx1 + { "scpu_bgh.g4", 0x2000, 0x3220f974, 3 | BRF_GRA }, // 10 + + { "vga.e1", 0x2000, 0xbc036d1d, 4 | BRF_GRA }, // 11 gfx2 + { "vgb.dc1", 0x2000, 0x58ee14d3, 4 | BRF_GRA }, // 12 + { "vgc.cb1", 0x2000, 0x3329f9d4, 4 | BRF_GRA }, // 13 + { "vga.a1", 0x2000, 0x9743f873, 4 | BRF_GRA }, // 14 + + { "0066-313bx-xxqx.a12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 15 scpu_pals + { "0066-315bx-xxqx.b12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 16 + { "0066-322bx-xx0x.e3.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 17 + { "0066-316bx-xxqx.g11.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 18 + { "0066-314bx-xxqx.g12.bin", 0x0001, 0x00000000, 5 | BRF_NODUMP | BRF_PRG | BRF_ESS }, // 19 +}; + +STDROMPICKEXT(tronger, tronger, Ssioprom) +STD_ROM_FN(tronger) + +struct BurnDriver BurnDrvTronger = { + "tronger", "tron", "midssio", NULL, "1982", + "Tron (Germany)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, trongerRomInfo, trongerRomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo,//, Tron3InputInfo, Tron3DIPInfo, + TronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 480, 512, 3, 4 +}; + + +// Domino Man + +static struct BurnRomInfo dominoRomDesc[] = { + { "dmanpg0.bin", 0x2000, 0x3bf3bb1c, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "dmanpg1.bin", 0x2000, 0x85cf1d69, 1 | BRF_PRG | BRF_ESS }, // 1 + { "dmanpg2.bin", 0x2000, 0x7dd2177a, 1 | BRF_PRG | BRF_ESS }, // 2 + { "dmanpg3.bin", 0x2000, 0xf2e0aa44, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "dm-a7.snd", 0x1000, 0xfa982dcc, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "dm-a8.snd", 0x1000, 0x72839019, 2 | BRF_PRG | BRF_ESS }, // 5 + { "dm-a9.snd", 0x1000, 0xad760da7, 2 | BRF_PRG | BRF_ESS }, // 6 + { "dm-a10.snd", 0x1000, 0x958c7287, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "dmanbg0.bin", 0x2000, 0x9163007f, 3 | BRF_GRA }, // 8 gfx1 + { "dmanbg1.bin", 0x2000, 0x28615c56, 3 | BRF_GRA }, // 9 + + { "dmanfg0.bin", 0x2000, 0x0b1f9f9e, 4 | BRF_GRA }, // 10 gfx2 + { "dmanfg1.bin", 0x2000, 0x16aa4b9b, 4 | BRF_GRA }, // 11 + { "dmanfg2.bin", 0x2000, 0x4a8e76b8, 4 | BRF_GRA }, // 12 + { "dmanfg3.bin", 0x2000, 0x1f39257e, 4 | BRF_GRA }, // 13 +}; + +STDROMPICKEXT(domino, domino, Ssioprom) +STD_ROM_FN(domino) + +static INT32 DominoInit() +{ + return DrvInit(90010); +} + +struct BurnDriver BurnDrvDomino = { + "domino", NULL, "midssio", NULL, "1982", + "Domino Man\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, dominoRomInfo, dominoRomName, NULL, NULL, NULL, NULL, DominoInputInfo, DominoDIPInfo, + DominoInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Wacko + +static struct BurnRomInfo wackoRomDesc[] = { + { "wackocpu.2d", 0x2000, 0xc98e29b6, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "wackocpu.3d", 0x2000, 0x90b89774, 1 | BRF_PRG | BRF_ESS }, // 1 + { "wackocpu.4d", 0x2000, 0x515edff7, 1 | BRF_PRG | BRF_ESS }, // 2 + { "wackocpu.5d", 0x2000, 0x9b01bf32, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "wackosnd.7a", 0x1000, 0x1a58763f, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "wackosnd.8a", 0x1000, 0xa4e3c771, 2 | BRF_PRG | BRF_ESS }, // 5 + { "wackosnd.9a", 0x1000, 0x155ba3dd, 2 | BRF_PRG | BRF_ESS }, // 6 + + { "wackocpu.3g", 0x2000, 0x33160eb1, 3 | BRF_GRA }, // 7 gfx1 + { "wackocpu.4g", 0x2000, 0xdaf37d7c, 3 | BRF_GRA }, // 8 + + { "wackovid.1e", 0x2000, 0xdca59be7, 4 | BRF_GRA }, // 9 gfx2 + { "wackovid.1d", 0x2000, 0xa02f1672, 4 | BRF_GRA }, // 10 + { "wackovid.1b", 0x2000, 0x7d899790, 4 | BRF_GRA }, // 11 + { "wackovid.1a", 0x2000, 0x080be3ad, 4 | BRF_GRA }, // 12 +}; + +STDROMPICKEXT(wacko, wacko, Ssioprom) +STD_ROM_FN(wacko) + +static void wacko_op4_write(UINT8, UINT8 data) +{ + input_playernum = data & 1; +} + +static UINT8 wacko_ip1_read(UINT8) +{ + return BurnTrackballRead(input_playernum, 0); +} + +static UINT8 wacko_ip2_read(UINT8) +{ + return BurnTrackballRead(input_playernum, 1); +} + +static INT32 WackoInit() +{ + INT32 nRet = DrvInit(90010); + + if (!nRet) { + is_wacko = 1; + ssio_set_custom_input(1, 0xff, wacko_ip1_read); + ssio_set_custom_input(2, 0xff, wacko_ip2_read); + ssio_set_custom_output(4, 0x01, wacko_op4_write); + } + + return nRet; +} + +struct BurnDriver BurnDrvWacko = { + "wacko", NULL, "ssio", NULL, "1982", + "Wacko\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, wackoRomInfo, wackoRomName, NULL, NULL, NULL, NULL, WackoInputInfo, WackoDIPInfo, + WackoInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Two Tigers (dedicated) + +static struct BurnRomInfo twotigerRomDesc[] = { + { "cpu_d2", 0x2000, 0xa682ed24, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "cpu_d3", 0x2000, 0x5b48fde9, 1 | BRF_PRG | BRF_ESS }, // 1 + { "cpu_d4", 0x2000, 0xf1ab8c4d, 1 | BRF_PRG | BRF_ESS }, // 2 + { "cpu_d5", 0x2000, 0xd7129900, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "ssio_a7", 0x1000, 0x64ddc16c, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "ssio_a8", 0x1000, 0xc3467612, 2 | BRF_PRG | BRF_ESS }, // 5 + { "ssio_a9", 0x1000, 0xc50f7b2d, 2 | BRF_PRG | BRF_ESS }, // 6 + + { "2tgrbg0.bin", 0x2000, 0x52f69068, 3 | BRF_GRA }, // 7 gfx1 + { "2tgrbg1.bin", 0x2000, 0x758d4f7d, 3 | BRF_GRA }, // 8 + + { "vid_d1", 0x2000, 0xda5f49da, 4 | BRF_GRA }, // 9 gfx2 + { "vid_c1", 0x2000, 0x62ed737b, 4 | BRF_GRA }, // 10 + { "vid_b1", 0x2000, 0x0939921e, 4 | BRF_GRA }, // 11 + { "vid_a1", 0x2000, 0xef515824, 4 | BRF_GRA }, // 12 +}; + +STDROMPICKEXT(twotiger, twotiger, Ssioprom) +STD_ROM_FN(twotiger) + +static struct BurnSampleInfo TwotigerSampleDesc[] = { + { "left", SAMPLE_NOLOOP }, + { "right", SAMPLE_NOLOOP }, + { "", 0 } +}; + +STD_SAMPLE_PICK(Twotiger) +STD_SAMPLE_FN(Twotiger) + +static void twotiger_op4_write(UINT8, UINT8 data) +{ + if (~data & 2) { + BurnSamplePause(0); + BurnSamplePause(1); + } + else if (!BurnSampleGetStatus(0)) { + BurnSampleResume(0); + BurnSampleResume(1); + } +} + +static INT32 TwotigerInit() +{ + INT32 nRet = DrvInit(90010); + + if (nRet == 0) + { + is_twotiger = 1; + BurnSampleSetRoute(0, BURN_SND_SAMPLE_ROUTE_1, 0.50, BURN_SND_ROUTE_LEFT); + BurnSampleSetRoute(0, BURN_SND_SAMPLE_ROUTE_2, 0.50, BURN_SND_ROUTE_LEFT); + BurnSampleSetRoute(1, BURN_SND_SAMPLE_ROUTE_1, 0.50, BURN_SND_ROUTE_RIGHT); + BurnSampleSetRoute(1, BURN_SND_SAMPLE_ROUTE_2, 0.50, BURN_SND_ROUTE_RIGHT); + ssio_set_custom_output(4, 0xff, twotiger_op4_write); + ZetOpen(0); + ZetUnmapMemory(0xe800, 0xefff, MAP_RAM); + ZetUnmapMemory(0xf800, 0xffff, MAP_RAM); + ZetSetWriteHandler(twotiger_vidram_write); + ZetSetReadHandler(twotiger_vidram_read); + ZetClose(); + } + + return nRet; +} + +struct BurnDriver BurnDrvTwotiger = { + "twotiger", NULL, "midssio", "twotiger", "1984", + "Two Tigers (dedicated)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, twotigerRomInfo, twotigerRomName, NULL, NULL, TwotigerSampleInfo, TwotigerSampleName, TwotigerInputInfo, TwotigerDIPInfo, + TwotigerInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Two Tigers (Tron conversion) + +static struct BurnRomInfo twotigercRomDesc[] = { + { "2tgrpg0.bin", 0x2000, 0xe77a924b, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "2tgrpg1.bin", 0x2000, 0x2699ebdc, 1 | BRF_PRG | BRF_ESS }, // 1 + { "2tgrpg2.bin", 0x2000, 0xb5ca3f17, 1 | BRF_PRG | BRF_ESS }, // 2 + { "2tgrpg3.bin", 0x2000, 0x8aa82049, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "2tgra7.bin", 0x1000, 0x4620d970, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "2tgra8.bin", 0x1000, 0xe95d8cfe, 2 | BRF_PRG | BRF_ESS }, // 5 + { "2tgra9.bin", 0x1000, 0x81e6ce0e, 2 | BRF_PRG | BRF_ESS }, // 6 + + { "2tgrbg0.bin", 0x2000, 0x52f69068, 3 | BRF_GRA }, // 7 gfx1 + { "2tgrbg1.bin", 0x2000, 0x758d4f7d, 3 | BRF_GRA }, // 8 + + { "2tgrfg0.bin", 0x2000, 0x4abf3ca0, 4 | BRF_GRA }, // 9 gfx2 + { "2tgrfg1.bin", 0x2000, 0xfbcaffa5, 4 | BRF_GRA }, // 10 + { "2tgrfg2.bin", 0x2000, 0x08e3e1a6, 4 | BRF_GRA }, // 11 + { "2tgrfg3.bin", 0x2000, 0x9b22697b, 4 | BRF_GRA }, // 12 +}; + +STDROMPICKEXT(twotigerc, twotigerc, Ssioprom) +STD_ROM_FN(twotigerc) + +static INT32 TwotigercInit() +{ + return DrvInit(90010); +} + +struct BurnDriverD BurnDrvTwotigerc = { + "twotigerc", "twotiger", "midssio", NULL, "1984", + "Two Tigers (Tron conversion)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_NOT_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, twotigercRomInfo, twotigercRomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo,//, TwotigrcInputInfo, TwotigrcDIPInfo, + TwotigercInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Tapper (Budweiser, 1/27/84) + +static struct BurnRomInfo tapperRomDesc[] = { + { "tapper_c.p.u._pg_0_1c_1-27-84.1c", 0x4000, 0xbb060bb0, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "tapper_c.p.u._pg_1_2c_1-27-84.2c", 0x4000, 0xfd9acc22, 1 | BRF_PRG | BRF_ESS }, // 1 + { "tapper_c.p.u._pg_2_3c_1-27-84.3c", 0x4000, 0xb3755d41, 1 | BRF_PRG | BRF_ESS }, // 2 + { "tapper_c.p.u._pg_3_4c_1-27-84.4c", 0x2000, 0x77273096, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "tapper_sound_snd_0_a7_12-7-83.a7", 0x1000, 0x0e8bb9d5, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "tapper_sound_snd_1_a8_12-7-83.a8", 0x1000, 0x0cf0e29b, 2 | BRF_PRG | BRF_ESS }, // 5 + { "tapper_sound_snd_2_a9_12-7-83.a9", 0x1000, 0x31eb6dc6, 2 | BRF_PRG | BRF_ESS }, // 6 + { "tapper_sound_snd_3_a10_12-7-83.a10", 0x1000, 0x01a9be6a, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "tapper_c.p.u._bg_1_6f_12-7-83.6f", 0x4000, 0x2a30238c, 3 | BRF_GRA }, // 8 gfx1 + { "tapper_c.p.u._bg_0_5f_12-7-83.5f", 0x4000, 0x394ab576, 3 | BRF_GRA }, // 9 + + { "tapper_video_fg_1_a7_12-7-83.a7", 0x4000, 0x32509011, 4 | BRF_GRA }, // 10 gfx2 + { "tapper_video_fg_0_a8_12-7-83.a8", 0x4000, 0x8412c808, 4 | BRF_GRA }, // 11 + { "tapper_video_fg_3_a5_12-7-83.a5", 0x4000, 0x818fffd4, 4 | BRF_GRA }, // 12 + { "tapper_video_fg_2_a6_12-7-83.a6", 0x4000, 0x67e37690, 4 | BRF_GRA }, // 13 + { "tapper_video_fg_5_a3_12-7-83.a3", 0x4000, 0x800f7c8a, 4 | BRF_GRA }, // 14 + { "tapper_video_fg_4_a4_12-7-83.a4", 0x4000, 0x32674ee6, 4 | BRF_GRA }, // 15 + { "tapper_video_fg_7_a1_12-7-83.a1", 0x4000, 0x070b4c81, 4 | BRF_GRA }, // 16 + { "tapper_video_fg_6_a2_12-7-83.a2", 0x4000, 0xa37aef36, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(tapper, tapper, Ssioprom) +STD_ROM_FN(tapper) + +static INT32 TapperInit() +{ + return DrvInit(91490); +} + +struct BurnDriver BurnDrvTapper = { + "tapper", NULL, "midssio", NULL, "1983", + "Tapper (Budweiser, 1/27/84)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tapperRomInfo, tapperRomName, NULL, NULL, NULL, NULL, TapperInputInfo, TapperDIPInfo, + TapperInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Tapper (Budweiser, 1/27/84 - Alternate graphics) + +static struct BurnRomInfo tappergRomDesc[] = { + { "tapper_c.p.u._pg_0_1c_1-27-84.1c", 0x4000, 0xbb060bb0, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "tapper_c.p.u._pg_1_2c_1-27-84.2c", 0x4000, 0xfd9acc22, 1 | BRF_PRG | BRF_ESS }, // 1 + { "tapper_c.p.u._pg_2_3c_1-27-84.3c", 0x4000, 0xb3755d41, 1 | BRF_PRG | BRF_ESS }, // 2 + { "tapper_c.p.u._pg_3_4c_1-27-84.4c", 0x2000, 0x77273096, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "tapper_sound_snd_0_a7_12-7-83.a7", 0x1000, 0x0e8bb9d5, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "tapper_sound_snd_1_a8_12-7-83.a8", 0x1000, 0x0cf0e29b, 2 | BRF_PRG | BRF_ESS }, // 5 + { "tapper_sound_snd_2_a9_12-7-83.a9", 0x1000, 0x31eb6dc6, 2 | BRF_PRG | BRF_ESS }, // 6 + { "tapper_sound_snd_3_a10_12-7-83.a10", 0x1000, 0x01a9be6a, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "tapper_c.p.u._bg_1_6f_12-7-83.6f", 0x4000, 0x2a30238c, 3 | BRF_GRA }, // 8 gfx1 + { "tapper_c.p.u._bg_0_5f_12-7-83.5f", 0x4000, 0x394ab576, 3 | BRF_GRA }, // 9 + + { "fg1_a7.128", 0x4000, 0xbac70b69, 4 | BRF_GRA }, // 10 gfx2 + { "fg0_a8.128", 0x4000, 0xc300925d, 4 | BRF_GRA }, // 11 + { "fg3_a5.128", 0x4000, 0xecff6c23, 4 | BRF_GRA }, // 12 + { "fg2_a6.128", 0x4000, 0xa4f2d1be, 4 | BRF_GRA }, // 13 + { "fg5_a3.128", 0x4000, 0x16ce38cb, 4 | BRF_GRA }, // 14 + { "fg4_a4.128", 0x4000, 0x082a4059, 4 | BRF_GRA }, // 15 + { "fg7_a1.128", 0x4000, 0x3b476abe, 4 | BRF_GRA }, // 16 + { "fg6_a2.128", 0x4000, 0x6717264c, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(tapperg, tapperg, Ssioprom) +STD_ROM_FN(tapperg) + +struct BurnDriver BurnDrvTapperg = { + "tapperg", "tapper", "midssio", NULL, "1983", + "Tapper (Budweiser, 1/27/84 - Alternate graphics)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tappergRomInfo, tappergRomName, NULL, NULL, NULL, NULL, TapperInputInfo, TapperDIPInfo, + TapperInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Tapper (Budweiser, 12/9/83) + +static struct BurnRomInfo tapperaRomDesc[] = { + { "tapper_c.p.u._pg_0_1c_12-9-83.1c", 0x4000, 0x496a8e04, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "tapper_c.p.u._pg_1_2c_12-9-83.2c", 0x4000, 0xe79c4b0c, 1 | BRF_PRG | BRF_ESS }, // 1 + { "tapper_c.p.u._pg_2_3c_12-9-83.3c", 0x4000, 0x3034ccf0, 1 | BRF_PRG | BRF_ESS }, // 2 + { "tapper_c.p.u._pg_3_4c_12-9-83.4c", 0x2000, 0x2dc99e05, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "tapper_sound_snd_0_a7_12-7-83.a7", 0x1000, 0x0e8bb9d5, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "tapper_sound_snd_1_a8_12-7-83.a8", 0x1000, 0x0cf0e29b, 2 | BRF_PRG | BRF_ESS }, // 5 + { "tapper_sound_snd_2_a9_12-7-83.a9", 0x1000, 0x31eb6dc6, 2 | BRF_PRG | BRF_ESS }, // 6 + { "tapper_sound_snd_3_a10_12-7-83.a10", 0x1000, 0x01a9be6a, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "tapper_c.p.u._bg_1_6f_12-7-83.6f", 0x4000, 0x2a30238c, 3 | BRF_GRA }, // 8 gfx1 + { "tapper_c.p.u._bg_0_5f_12-7-83.5f", 0x4000, 0x394ab576, 3 | BRF_GRA }, // 9 + + { "tapper_video_fg_1_a7_12-7-83.a7", 0x4000, 0x32509011, 4 | BRF_GRA }, // 10 gfx2 + { "tapper_video_fg_0_a8_12-7-83.a8", 0x4000, 0x8412c808, 4 | BRF_GRA }, // 11 + { "tapper_video_fg_3_a5_12-7-83.a5", 0x4000, 0x818fffd4, 4 | BRF_GRA }, // 12 + { "tapper_video_fg_2_a6_12-7-83.a6", 0x4000, 0x67e37690, 4 | BRF_GRA }, // 13 + { "tapper_video_fg_5_a3_12-7-83.a3", 0x4000, 0x800f7c8a, 4 | BRF_GRA }, // 14 + { "tapper_video_fg_4_a4_12-7-83.a4", 0x4000, 0x32674ee6, 4 | BRF_GRA }, // 15 + { "tapper_video_fg_7_a1_12-7-83.a1", 0x4000, 0x070b4c81, 4 | BRF_GRA }, // 16 + { "tapper_video_fg_6_a2_12-7-83.a2", 0x4000, 0xa37aef36, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(tappera, tappera, Ssioprom) +STD_ROM_FN(tappera) + +struct BurnDriver BurnDrvTappera = { + "tappera", "tapper", "midssio", NULL, "1983", + "Tapper (Budweiser, 12/9/83)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tapperaRomInfo, tapperaRomName, NULL, NULL, NULL, NULL, TapperInputInfo, TapperDIPInfo, + TapperInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Tapper (Budweiser, Date Unknown) + +static struct BurnRomInfo tapperbRomDesc[] = { + { "tapper_c.p.u._pg_0_1c.1c", 0x4000, 0x127171d1, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "tapper_c.p.u._pg_1_2c.1c", 0x4000, 0x9d6a47f7, 1 | BRF_PRG | BRF_ESS }, // 1 + { "tapper_c.p.u._pg_2_3c.3c", 0x4000, 0x3a1f8778, 1 | BRF_PRG | BRF_ESS }, // 2 + { "tapper_c.p.u._pg_3_4c.4c", 0x2000, 0xe8dcdaa4, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "tapper_sound_snd_0_a7_12-7-83.a7", 0x1000, 0x0e8bb9d5, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "tapper_sound_snd_1_a8_12-7-83.a8", 0x1000, 0x0cf0e29b, 2 | BRF_PRG | BRF_ESS }, // 5 + { "tapper_sound_snd_2_a9_12-7-83.a9", 0x1000, 0x31eb6dc6, 2 | BRF_PRG | BRF_ESS }, // 6 + { "tapper_sound_snd_3_a10_12-7-83.a10", 0x1000, 0x01a9be6a, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "tapper_c.p.u._bg_1_6f_12-7-83.6f", 0x4000, 0x2a30238c, 3 | BRF_GRA }, // 8 gfx1 + { "tapper_c.p.u._bg_0_5f_12-7-83.5f", 0x4000, 0x394ab576, 3 | BRF_GRA }, // 9 + + { "tapper_video_fg_1_a7_12-7-83.a7", 0x4000, 0x32509011, 4 | BRF_GRA }, // 10 gfx2 + { "tapper_video_fg_0_a8_12-7-83.a8", 0x4000, 0x8412c808, 4 | BRF_GRA }, // 11 + { "tapper_video_fg_3_a5_12-7-83.a5", 0x4000, 0x818fffd4, 4 | BRF_GRA }, // 12 + { "tapper_video_fg_2_a6_12-7-83.a6", 0x4000, 0x67e37690, 4 | BRF_GRA }, // 13 + { "tapper_video_fg_5_a3_12-7-83.a3", 0x4000, 0x800f7c8a, 4 | BRF_GRA }, // 14 + { "tapper_video_fg_4_a4_12-7-83.a4", 0x4000, 0x32674ee6, 4 | BRF_GRA }, // 15 + { "tapper_video_fg_7_a1_12-7-83.a1", 0x4000, 0x070b4c81, 4 | BRF_GRA }, // 16 + { "tapper_video_fg_6_a2_12-7-83.a2", 0x4000, 0xa37aef36, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(tapperb, tapperb, Ssioprom) +STD_ROM_FN(tapperb) + +struct BurnDriver BurnDrvTapperb = { + "tapperb", "tapper", "midssio", NULL, "1983", + "Tapper (Budweiser, Date Unknown)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, tapperbRomInfo, tapperbRomName, NULL, NULL, NULL, NULL, TapperInputInfo, TapperDIPInfo, + TapperInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Tapper (Suntory) + +static struct BurnRomInfo sutapperRomDesc[] = { + { "epr-5791", 0x4000, 0x87119cc4, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "epr-5792", 0x4000, 0x4c23ad89, 1 | BRF_PRG | BRF_ESS }, // 1 + { "epr-5793", 0x4000, 0xfecbf683, 1 | BRF_PRG | BRF_ESS }, // 2 + { "epr-5794", 0x2000, 0x5bdc1916, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "epr-5788.h11.ic8", 0x1000, 0x5c1d0982, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "epr-5787.h10.ic6", 0x1000, 0x09e74ed8, 2 | BRF_PRG | BRF_ESS }, // 5 + { "epr-5786.h9.ic5", 0x1000, 0xc3e98284, 2 | BRF_PRG | BRF_ESS }, // 6 + { "epr-5785.h7.ic4", 0x1000, 0xced2fd47, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "epr-5790", 0x4000, 0xac1558c1, 3 | BRF_GRA }, // 8 gfx1 + { "epr-5789", 0x4000, 0xfa66cab5, 3 | BRF_GRA }, // 9 + + { "epr-5795", 0x4000, 0x5d987c92, 4 | BRF_GRA }, // 10 gfx2 + { "epr-5796", 0x4000, 0xde5700b4, 4 | BRF_GRA }, // 11 + { "epr-5797", 0x4000, 0xf10a1d05, 4 | BRF_GRA }, // 12 + { "epr-5798", 0x4000, 0x614990cd, 4 | BRF_GRA }, // 13 + { "epr-5799", 0x4000, 0x02c69432, 4 | BRF_GRA }, // 14 + { "epr-5800", 0x4000, 0xebf1f948, 4 | BRF_GRA }, // 15 + { "epr-5801", 0x4000, 0xd70defa7, 4 | BRF_GRA }, // 16 + { "epr-5802", 0x4000, 0xd4f114b9, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(sutapper, sutapper, Ssioprom) +STD_ROM_FN(sutapper) + +struct BurnDriver BurnDrvSutapper = { + "sutapper", "tapper", "midssio", NULL, "1983", + "Tapper (Suntory)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, sutapperRomInfo, sutapperRomName, NULL, NULL, NULL, NULL, TapperInputInfo, TapperDIPInfo, + TapperInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Tapper (Root Beer) + +static struct BurnRomInfo rbtapperRomDesc[] = { + { "rbtpg0.bin", 0x4000, 0x20b9adf4, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "rbtpg1.bin", 0x4000, 0x87e616c2, 1 | BRF_PRG | BRF_ESS }, // 1 + { "rbtpg2.bin", 0x4000, 0x0b332c97, 1 | BRF_PRG | BRF_ESS }, // 2 + { "rbtpg3.bin", 0x2000, 0x698c06f2, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "5788", 0x1000, 0x5c1d0982, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "5787", 0x1000, 0x09e74ed8, 2 | BRF_PRG | BRF_ESS }, // 5 + { "5786", 0x1000, 0xc3e98284, 2 | BRF_PRG | BRF_ESS }, // 6 + { "5785", 0x1000, 0xced2fd47, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "rbtbg1.bin", 0x4000, 0x44dfa483, 3 | BRF_GRA }, // 8 gfx1 + { "rbtbg0.bin", 0x4000, 0x510b13de, 3 | BRF_GRA }, // 9 + + { "rbtfg1.bin", 0x4000, 0x1c0b8791, 4 | BRF_GRA }, // 10 gfx2 + { "rbtfg0.bin", 0x4000, 0xe99f6018, 4 | BRF_GRA }, // 11 + { "rbtfg3.bin", 0x4000, 0x3e725e77, 4 | BRF_GRA }, // 12 + { "rbtfg2.bin", 0x4000, 0x4ee8b624, 4 | BRF_GRA }, // 13 + { "rbtfg5.bin", 0x4000, 0x9eeca46e, 4 | BRF_GRA }, // 14 + { "rbtfg4.bin", 0x4000, 0x8c79e7d7, 4 | BRF_GRA }, // 15 + { "rbtfg7.bin", 0x4000, 0x8dbf0c36, 4 | BRF_GRA }, // 16 + { "rbtfg6.bin", 0x4000, 0x441201a0, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(rbtapper, rbtapper, Ssioprom) +STD_ROM_FN(rbtapper) + +struct BurnDriver BurnDrvRbtapper = { + "rbtapper", "tapper", "midssio", NULL, "1984", + "Tapper (Root Beer)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, rbtapperRomInfo, rbtapperRomName, NULL, NULL, NULL, NULL, TapperInputInfo, TapperDIPInfo, + TapperInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Kozmik Kroozr + +static struct BurnRomInfo kroozrRomDesc[] = { + { "kozmkcpu.2d", 0x2000, 0x61e02045, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "kozmkcpu.3d", 0x2000, 0xcaabed57, 1 | BRF_PRG | BRF_ESS }, // 1 + { "kozmkcpu.4d", 0x2000, 0x2bc83fc7, 1 | BRF_PRG | BRF_ESS }, // 2 + { "kozmkcpu.5d", 0x2000, 0xa0ec38c1, 1 | BRF_PRG | BRF_ESS }, // 3 + { "kozmkcpu.6d", 0x2000, 0x7044f2b6, 1 | BRF_PRG | BRF_ESS }, // 4 + + { "kozmksnd.7a", 0x1000, 0x6736e433, 2 | BRF_PRG | BRF_ESS }, // 5 ssio:cpu + { "kozmksnd.8a", 0x1000, 0xea9cd919, 2 | BRF_PRG | BRF_ESS }, // 6 + { "kozmksnd.9a", 0x1000, 0x9dfa7994, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "kozmkcpu.3g", 0x2000, 0xeda6ed2d, 3 | BRF_GRA }, // 8 gfx1 + { "kozmkcpu.4g", 0x2000, 0xddde894b, 3 | BRF_GRA }, // 9 + + { "kozmkvid.1e", 0x2000, 0xca60e2cc, 4 | BRF_GRA }, // 10 gfx2 + { "kozmkvid.1d", 0x2000, 0x4e23b35b, 4 | BRF_GRA }, // 11 + { "kozmkvid.1b", 0x2000, 0xc6041ba7, 4 | BRF_GRA }, // 12 + { "kozmkvid.1a", 0x2000, 0xb57fb0ff, 4 | BRF_GRA }, // 13 +}; + +STDROMPICKEXT(kroozr, kroozr, Ssioprom) +STD_ROM_FN(kroozr) + +static INT32 KroozrInit() +{ + INT32 nRet = DrvInit(90010); + + if (nRet == 0) + { + has_dial = 1; + is_kroozr = 1; + ssio_set_custom_input(1, 0x7f, kroozr_ip1_read); + } + + return nRet; +} + +struct BurnDriver BurnDrvKroozr = { + "kroozr", NULL, "midssio", NULL, "1982", + "Kozmik Kroozr\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, kroozrRomInfo, kroozrRomName, NULL, NULL, NULL, NULL, KroozrInputInfo, KroozrDIPInfo, + KroozrInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Journey + +static struct BurnRomInfo journeyRomDesc[] = { + { "d2", 0x2000, 0xf2618913, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "d3", 0x2000, 0x2f290d2e, 1 | BRF_PRG | BRF_ESS }, // 1 + { "d4", 0x2000, 0xcc6c0150, 1 | BRF_PRG | BRF_ESS }, // 2 + { "d5", 0x2000, 0xc3023931, 1 | BRF_PRG | BRF_ESS }, // 3 + { "d6", 0x2000, 0x5d445c99, 1 | BRF_PRG | BRF_ESS }, // 4 + + { "a", 0x1000, 0x2524a2aa, 2 | BRF_PRG | BRF_ESS }, // 5 ssio:cpu + { "b", 0x1000, 0xb8e35814, 2 | BRF_PRG | BRF_ESS }, // 6 + { "c", 0x1000, 0x09c488cf, 2 | BRF_PRG | BRF_ESS }, // 7 + { "d", 0x1000, 0x3d627bee, 2 | BRF_PRG | BRF_ESS }, // 8 + + { "g3", 0x2000, 0xc14558de, 3 | BRF_GRA }, // 9 gfx1 + { "g4", 0x2000, 0x9104c1d0, 3 | BRF_GRA }, // 10 + + { "a7", 0x2000, 0x4ca2bb2d, 4 | BRF_GRA }, // 11 gfx2 + { "a8", 0x2000, 0x4fb7925d, 4 | BRF_GRA }, // 12 + { "a5", 0x2000, 0x560c474f, 4 | BRF_GRA }, // 13 + { "a6", 0x2000, 0xb1f31583, 4 | BRF_GRA }, // 14 + { "a3", 0x2000, 0xf295afda, 4 | BRF_GRA }, // 15 + { "a4", 0x2000, 0x765876a7, 4 | BRF_GRA }, // 16 + { "a1", 0x2000, 0x4af986f8, 4 | BRF_GRA }, // 17 + { "a2", 0x2000, 0xb30cd2a7, 4 | BRF_GRA }, // 18 +}; + +STDROMPICKEXT(journey, journey, Ssioprom) +STD_ROM_FN(journey) + +static struct BurnSampleInfo JourneySampleDesc[] = { + { "sepways", SAMPLE_NOLOOP }, + { "", 0 } +}; + +STD_SAMPLE_PICK(Journey) +STD_SAMPLE_FN(Journey) + +static void journey_op4_write(UINT8, UINT8 data) +{ + if ((data & 1) == 0) { + BurnSampleStop(0); + } + else if (!BurnSampleGetStatus(0)) { + BurnSamplePlay(0); + } +} + +static INT32 JourneyInit() +{ + INT32 nRet = DrvInit(91475); + + if (nRet == 0) + { + ssio_set_custom_output(4, 0xff, journey_op4_write); + } + + return nRet; +} + +struct BurnDriver BurnDrvJourney = { + "journey", NULL, "midssio", "journey", "1983", + "Journey\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, journeyRomInfo, journeyRomName, NULL, NULL, JourneySampleInfo, JourneySampleName, JourneyInputInfo, JourneyDIPInfo, + JourneyInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x80, + 480, 512, 3, 4 +}; + + +// Timber + +static struct BurnRomInfo timberRomDesc[] = { + { "timpg0.bin", 0x4000, 0x377032ab, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "timpg1.bin", 0x4000, 0xfd772836, 1 | BRF_PRG | BRF_ESS }, // 1 + { "timpg2.bin", 0x4000, 0x632989f9, 1 | BRF_PRG | BRF_ESS }, // 2 + { "timpg3.bin", 0x2000, 0xdae8a0dc, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "tima7.bin", 0x1000, 0xc615dc3e, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "tima8.bin", 0x1000, 0x83841c87, 2 | BRF_PRG | BRF_ESS }, // 5 + { "tima9.bin", 0x1000, 0x22bcdcd3, 2 | BRF_PRG | BRF_ESS }, // 6 + + { "timbg1.bin", 0x4000, 0xb1cb2651, 3 | BRF_GRA }, // 7 gfx1 + { "timbg0.bin", 0x4000, 0x2ae352c4, 3 | BRF_GRA }, // 8 + + { "timfg1.bin", 0x4000, 0x81de4a73, 4 | BRF_GRA }, // 9 gfx2 + { "timfg0.bin", 0x4000, 0x7f3a4f59, 4 | BRF_GRA }, // 10 + { "timfg3.bin", 0x4000, 0x37c03272, 4 | BRF_GRA }, // 11 + { "timfg2.bin", 0x4000, 0xe2c2885c, 4 | BRF_GRA }, // 12 + { "timfg5.bin", 0x4000, 0xeb636216, 4 | BRF_GRA }, // 13 + { "timfg4.bin", 0x4000, 0xb7105eb7, 4 | BRF_GRA }, // 14 + { "timfg7.bin", 0x4000, 0xd9c27475, 4 | BRF_GRA }, // 15 + { "timfg6.bin", 0x4000, 0x244778e8, 4 | BRF_GRA }, // 16 +}; + +STDROMPICKEXT(timber, timber, Ssioprom) +STD_ROM_FN(timber) + +static INT32 TimberInit() +{ + return DrvInit(91490); +} + +struct BurnDriver BurnDrvTimber = { + "timber", NULL, "midssio", NULL, "1984", + "Timber\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, timberRomInfo, timberRomName, NULL, NULL, NULL, NULL, TimberInputInfo, TimberDIPInfo, + TimberInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Discs of Tron (Upright) + +static struct BurnRomInfo dotronRomDesc[] = { + { "loc-pg0.1c", 0x4000, 0xba0da15f, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "loc-pg1.2c", 0x4000, 0xdc300191, 1 | BRF_PRG | BRF_ESS }, // 1 + { "loc-pg2.3c", 0x4000, 0xab0b3800, 1 | BRF_PRG | BRF_ESS }, // 2 + { "loc-pg1.4c", 0x2000, 0xf98c9f8e, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "sound0.a7", 0x1000, 0x6d39bf19, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "sound1.a8", 0x1000, 0xac872e1d, 2 | BRF_PRG | BRF_ESS }, // 5 + { "sound2.a9", 0x1000, 0xe8ef6519, 2 | BRF_PRG | BRF_ESS }, // 6 + { "sound3.a10", 0x1000, 0x6b5aeb02, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "loc-bg2.6f", 0x2000, 0x40167124, 3 | BRF_GRA }, // 8 gfx1 + { "loc-bg1.5f", 0x2000, 0xbb2d7a5d, 3 | BRF_GRA }, // 9 + + { "loc-g.cp4", 0x2000, 0x57a2b1ff, 4 | BRF_GRA }, // 10 gfx2 + { "loc-h.cp3", 0x2000, 0x3bb4d475, 4 | BRF_GRA }, // 11 + { "loc-e.cp6", 0x2000, 0xce957f1a, 4 | BRF_GRA }, // 12 + { "loc-f.cp5", 0x2000, 0xd26053ce, 4 | BRF_GRA }, // 13 + { "loc-c.cp8", 0x2000, 0xef45d146, 4 | BRF_GRA }, // 14 + { "loc-d.cp7", 0x2000, 0x5e8a3ef3, 4 | BRF_GRA }, // 15 + { "loc-a.cp0", 0x2000, 0xb35f5374, 4 | BRF_GRA }, // 16 + { "loc-b.cp9", 0x2000, 0x565a5c48, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(dotron, dotron, Ssioprom) +STD_ROM_FN(dotron) + +static void dotron_op4_write(UINT8, UINT8 data) +{ + if (has_squak) { + midsat_write(data); + } +} + +static UINT8 dotron_ip1_read(UINT8) +{ + UINT8 tb = (BurnTrackballRead(0, 0) ) & 0x7f; + BurnTrackballUpdate(0); + + return tb; +} + +static UINT8 dotron_ip2_read(UINT8) +{ + return DrvDips[0]; +} + +static INT32 DotronInit() +{ + nScreenFlip = TMAP_FLIPX; + + INT32 nRet = DrvInit(91490); + + if (nRet == 0) + { + is_dotron = 1; + has_dial = 1; + ssio_set_custom_input(1, 0xff, dotron_ip1_read); + ssio_set_custom_input(2, 0x80, dotron_ip2_read); + ssio_set_custom_output(4, 0xff, dotron_op4_write); + } + + return nRet; +} + +static INT32 DotroneInit() +{ + has_squak = 1; + + return DotronInit(); +} + +struct BurnDriver BurnDrvDotron = { + "dotron", NULL, "midssio", NULL, "1983", + "Discs of Tron (Upright)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, dotronRomInfo, dotronRomName, NULL, NULL, NULL, NULL, DotronInputInfo, DotronDIPInfo, + DotronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Discs of Tron (Upright alternate) + +static struct BurnRomInfo dotronaRomDesc[] = { + { "aloc-pg0.1c", 0x4000, 0x40d00195, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "aloc-pg1.2c", 0x4000, 0x5a7d1300, 1 | BRF_PRG | BRF_ESS }, // 1 + { "aloc-pg2.3c", 0x4000, 0xcb89c9be, 1 | BRF_PRG | BRF_ESS }, // 2 + { "aloc-pg1.4c", 0x2000, 0x5098faf4, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "asound0.a7", 0x1000, 0x7fb54293, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "asound1.a8", 0x1000, 0xedef7326, 2 | BRF_PRG | BRF_ESS }, // 5 + { "sound2.a9", 0x1000, 0xe8ef6519, 2 | BRF_PRG | BRF_ESS }, // 6 + { "sound3.a10", 0x1000, 0x6b5aeb02, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "loc-bg2.6f", 0x2000, 0x40167124, 3 | BRF_GRA }, // 8 gfx1 + { "loc-bg1.5f", 0x2000, 0xbb2d7a5d, 3 | BRF_GRA }, // 9 + + { "loc-g.cp4", 0x2000, 0x57a2b1ff, 4 | BRF_GRA }, // 10 gfx2 + { "loc-h.cp3", 0x2000, 0x3bb4d475, 4 | BRF_GRA }, // 11 + { "loc-e.cp6", 0x2000, 0xce957f1a, 4 | BRF_GRA }, // 12 + { "loc-f.cp5", 0x2000, 0xd26053ce, 4 | BRF_GRA }, // 13 + { "loc-c.cp8", 0x2000, 0xef45d146, 4 | BRF_GRA }, // 14 + { "loc-d.cp7", 0x2000, 0x5e8a3ef3, 4 | BRF_GRA }, // 15 + { "loc-a.cp0", 0x2000, 0xb35f5374, 4 | BRF_GRA }, // 16 + { "loc-b.cp9", 0x2000, 0x565a5c48, 4 | BRF_GRA }, // 17 +}; + +STDROMPICKEXT(dotrona, dotrona, Ssioprom) +STD_ROM_FN(dotrona) + +struct BurnDriver BurnDrvDotrona = { + "dotrona", "dotron", "midssio", NULL, "1983", + "Discs of Tron (Upright alternate)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, dotronaRomInfo, dotronaRomName, NULL, NULL, NULL, NULL, DotronInputInfo, DotronDIPInfo, + DotronInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Discs of Tron (Environmental) + +static struct BurnRomInfo dotroneRomDesc[] = { + { "loc-cpu1", 0x4000, 0xeee31b8c, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "loc-cpu2", 0x4000, 0x75ba6ad3, 1 | BRF_PRG | BRF_ESS }, // 1 + { "loc-cpu3", 0x4000, 0x94bb1a0e, 1 | BRF_PRG | BRF_ESS }, // 2 + { "loc-cpu4", 0x2000, 0xc137383c, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "loc-a", 0x1000, 0x2de6a8a8, 2 | BRF_PRG | BRF_ESS }, // 4 ssio:cpu + { "loc-b", 0x1000, 0x4097663e, 2 | BRF_PRG | BRF_ESS }, // 5 + { "loc-c", 0x1000, 0xf576b9e7, 2 | BRF_PRG | BRF_ESS }, // 6 + { "loc-d", 0x1000, 0x74b0059e, 2 | BRF_PRG | BRF_ESS }, // 7 + + { "pre.u3", 0x1000, 0xc3d0f762, 3 | BRF_PRG | BRF_ESS }, // 8 snt:cpu + { "pre.u4", 0x1000, 0x7ca79b43, 3 | BRF_PRG | BRF_ESS }, // 9 + { "pre.u5", 0x1000, 0x24e9618e, 3 | BRF_PRG | BRF_ESS }, // 10 + + { "loc-bg2.6f", 0x2000, 0x40167124, 3 | BRF_GRA }, // 11 gfx1 + { "loc-bg1.5f", 0x2000, 0xbb2d7a5d, 3 | BRF_GRA }, // 12 + + { "loc-g.cp4", 0x2000, 0x57a2b1ff, 4 | BRF_GRA }, // 13 gfx2 + { "loc-h.cp3", 0x2000, 0x3bb4d475, 4 | BRF_GRA }, // 14 + { "loc-e.cp6", 0x2000, 0xce957f1a, 4 | BRF_GRA }, // 15 + { "loc-f.cp5", 0x2000, 0xd26053ce, 4 | BRF_GRA }, // 16 + { "loc-c.cp8", 0x2000, 0xef45d146, 4 | BRF_GRA }, // 17 + { "loc-d.cp7", 0x2000, 0x5e8a3ef3, 4 | BRF_GRA }, // 18 + { "loc-a.cp0", 0x2000, 0xb35f5374, 4 | BRF_GRA }, // 19 + { "loc-b.cp9", 0x2000, 0x565a5c48, 4 | BRF_GRA }, // 20 + +// { "edotlamp.u2", 0x0020, 0xfb58b867, 6 | BRF_GRA }, // 21 proms +}; + +STDROMPICKEXT(dotrone, dotrone, Ssioprom) +STD_ROM_FN(dotrone) + +struct BurnDriver BurnDrvDotrone = { + "dotrone", "dotron", "midssio", NULL, "1983", + "Discs of Tron (Environmental)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, dotroneRomInfo, dotroneRomName, NULL, NULL, NULL, NULL, DotronInputInfo, DotroneDIPInfo, + DotroneInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Demolition Derby + +static struct BurnRomInfo demoderbRomDesc[] = { + { "demo_drby_pro_0", 0x4000, 0xbe7da2f3, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code + { "demo_drby_pro_1", 0x4000, 0xc6f6604c, 1 | BRF_PRG | BRF_ESS }, // 1 + { "demo_drby_pro_2", 0x4000, 0xfa93b9d9, 1 | BRF_PRG | BRF_ESS }, // 2 + { "demo_drby_pro_3", 0x4000, 0x4e964883, 1 | BRF_PRG | BRF_ESS }, // 3 + + { "tcs_u5.bin", 0x2000, 0xeca33b2c, 5 | BRF_PRG | BRF_ESS }, // 4 M6809 Code + { "tcs_u4.bin", 0x2000, 0x3490289a, 5 | BRF_PRG | BRF_ESS }, // 5 + + { "demo_derby_bg_06f.6f", 0x2000, 0xcf80be19, 3 | BRF_GRA }, // 6 Background Tiles + { "demo_derby_bg_15f.5f", 0x2000, 0x4e173e52, 3 | BRF_GRA }, // 7 + + { "demo_derby_fg0_a4.a4", 0x4000, 0xe57a4de6, 4 | BRF_GRA }, // 8 Sprites + { "demo_derby_fg4_a3.a3", 0x4000, 0x55aa667f, 4 | BRF_GRA }, // 9 + { "demo_derby_fg1_a6.a6", 0x4000, 0x70259651, 4 | BRF_GRA }, // 10 + { "demo_derby_fg5_a5.a5", 0x4000, 0x5fe99007, 4 | BRF_GRA }, // 11 + { "demo_derby_fg2_a8.a8", 0x4000, 0x6cab7b95, 4 | BRF_GRA }, // 12 + { "demo_derby_fg6_a7.a7", 0x4000, 0xabfb9a8b, 4 | BRF_GRA }, // 13 + { "demo_derby_fg3_a10.a10", 0x4000, 0x801d9b86, 4 | BRF_GRA }, // 14 + { "demo_derby_fg7_a9.a9", 0x4000, 0x0ec3f60a, 4 | BRF_GRA }, // 15 +}; + +STD_ROM_PICK(demoderb) +STD_ROM_FN(demoderb) + +static void demoderb_op4_write(UINT8, UINT8 data) +{ + if (data & 0x40) input_playernum = 1; + if (data & 0x80) input_playernum = 0; + + //turbo_cheap_squeak(data); +} + +static UINT8 demoderb_ip1_read(UINT8) +{ + UINT8 ipt = DrvInputs[1] & 0x03; + ipt |= (((input_playernum) ? ~BurnTrackballRead(1, 0) : ~BurnTrackballRead(0, 0)) << 2) & 0x3f; + + BurnTrackballUpdate(input_playernum); + + return ipt; +} + +static UINT8 demoderb_ip2_read(UINT8) +{ + UINT8 ipt = DrvInputs[2] & 0x03; + ipt |= (((input_playernum) ? ~BurnTrackballRead(1, 1) : ~BurnTrackballRead(0, 1)) << 2) & 0x3f; + + BurnTrackballUpdate(input_playernum); + + return ipt; +} + +static INT32 DemoderbInit() +{ + INT32 nRet = DrvInit(91490); + + if (nRet == 0) + { + is_demoderb = 1; + ssio_set_custom_input(1, 0xff, demoderb_ip1_read); + ssio_set_custom_input(2, 0xff, demoderb_ip2_read); + ssio_set_custom_output(4, 0xff, demoderb_op4_write); + } + + return nRet; +} + +struct BurnDriver BurnDrvDemoderb = { + "demoderb", NULL, NULL, NULL, "1984", + "Demolition Derby\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, demoderbRomInfo, demoderbRomName, NULL, NULL, NULL, NULL, DemoderbInputInfo, DemoderbDIPInfo, + DemoderbInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// Demolition Derby (cocktail) + +static struct BurnRomInfo demoderbcRomDesc[] = { + { "dd_pro0", 0x4000, 0x8781b367, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "dd_pro1", 0x4000, 0x4c713bfe, 1 | BRF_PRG | BRF_ESS }, // 1 + { "dd_pro2", 0x4000, 0xc2cbd2a4, 1 | BRF_PRG | BRF_ESS }, // 2 + + { "tcs_u5.bin", 0x2000, 0xeca33b2c, 2 | BRF_PRG | BRF_ESS }, // 3 tcs:cpu + { "tcs_u4.bin", 0x2000, 0x3490289a, 2 | BRF_PRG | BRF_ESS }, // 4 + + { "demo_derby_bg_06f.6f", 0x2000, 0xcf80be19, 3 | BRF_GRA }, // 5 gfx1 + { "demo_derby_bg_15f.5f", 0x2000, 0x4e173e52, 3 | BRF_GRA }, // 6 + + { "demo_derby_fg0_a4.a4", 0x4000, 0xe57a4de6, 4 | BRF_GRA }, // 7 gfx2 + { "demo_derby_fg4_a3.a3", 0x4000, 0x55aa667f, 4 | BRF_GRA }, // 8 + { "demo_derby_fg1_a6.a6", 0x4000, 0x70259651, 4 | BRF_GRA }, // 9 + { "demo_derby_fg5_a5.a5", 0x4000, 0x5fe99007, 4 | BRF_GRA }, // 10 + { "demo_derby_fg2_a8.a8", 0x4000, 0x6cab7b95, 4 | BRF_GRA }, // 11 + { "demo_derby_fg6_a7.a7", 0x4000, 0xabfb9a8b, 4 | BRF_GRA }, // 12 + { "demo_derby_fg3_a10.a10", 0x4000, 0x801d9b86, 4 | BRF_GRA }, // 13 + { "demo_derby_fg7_a9.a9", 0x4000, 0x0ec3f60a, 4 | BRF_GRA }, // 14 +}; + +STD_ROM_PICK(demoderbc) +STD_ROM_FN(demoderbc) + +struct BurnDriver BurnDrvDemoderbc = { + "demoderbc", "demoderb", NULL, NULL, "1984", + "Demolition Derby (cocktail)\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, demoderbcRomInfo, demoderbcRomName, NULL, NULL, NULL, NULL, DemoderbInputInfo, DemoderbDIPInfo, + DemoderbInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; + + +// NFL Football + +static struct BurnRomInfo nflfootRomDesc[] = { + { "nflcpupg.1c", 0x4000, 0xd76a7a41, 1 | BRF_PRG | BRF_ESS }, // 0 maincpu + { "nflcpupg.2c", 0x4000, 0x2aa76168, 1 | BRF_PRG | BRF_ESS }, // 1 + { "nflcpupg.3c", 0x4000, 0x5ec01e09, 1 | BRF_PRG | BRF_ESS }, // 2 + + { "nflsnd.a7", 0x1000, 0x1339be2e, 2 | BRF_PRG | BRF_ESS }, // 3 ssio:cpu + { "nflsnd.a8", 0x1000, 0x8630b560, 2 | BRF_PRG | BRF_ESS }, // 4 + { "nflsnd.a9", 0x1000, 0x1e0fe4c8, 2 | BRF_PRG | BRF_ESS }, // 5 + + { "nfl-sqtk-11-15-83.u2", 0x1000, 0xaeddda31, 3 | BRF_PRG | BRF_ESS }, // 6 snt:cpu + { "nfl-sqtk-11-15-83.u3", 0x1000, 0x36229d13, 3 | BRF_PRG | BRF_ESS }, // 7 + { "nfl-sqtk-11-15-83.u4", 0x1000, 0xb202439b, 3 | BRF_PRG | BRF_ESS }, // 8 + { "nfl-sqtk-11-15-83.u5", 0x1000, 0xbbfe4d39, 3 | BRF_PRG | BRF_ESS }, // 9 + + { "ipu-7-9.a2", 0x2000, 0x0e083adb, 4 | BRF_GRA }, // 10 ipu + { "ipu-7-9.a4", 0x2000, 0x5c9c4764, 4 | BRF_GRA }, // 11 + + { "nflcpubg.6f", 0x2000, 0x6d116cd9, 5 | BRF_GRA }, // 12 gfx1 + { "nflcpubg.5f", 0x2000, 0x5f1b0b67, 5 | BRF_GRA }, // 13 + + { "nflvidfg.cp4", 0x2000, 0xeb6b808d, 6 | BRF_GRA }, // 14 gfx2 + { "nflvidfg.cp3", 0x2000, 0xbe21580a, 6 | BRF_GRA }, // 15 + { "nflvidfg.cp6", 0x2000, 0x54a0bff8, 6 | BRF_GRA }, // 16 + { "nflvidfg.cp5", 0x2000, 0x6aeba0ab, 6 | BRF_GRA }, // 17 + { "nflvidfg.cp8", 0x2000, 0x112ee67b, 6 | BRF_GRA }, // 18 + { "nflvidfg.cp7", 0x2000, 0x73f62392, 6 | BRF_GRA }, // 19 + { "nflvidfg.c10", 0x2000, 0x1766dcc7, 6 | BRF_GRA }, // 20 + { "nflvidfg.cp9", 0x2000, 0x46558146, 6 | BRF_GRA }, // 21 +}; + +STDROMPICKEXT(nflfoot, nflfoot, Ssioprom) +STD_ROM_FN(nflfoot) + +static INT32 NflfootInit() +{ + return 1; +} + +struct BurnDriverD BurnDrvNflfoot = { + "nflfoot", NULL, "ssio", NULL, "1983", + "NFL Football\0", NULL, "Bally Midway", "Miscellaneous", + NULL, NULL, NULL, NULL, + BDF_GAME_NOT_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0, + NULL, nflfootRomInfo, nflfootRomName, NULL, NULL, NULL, NULL, TronInputInfo, TronDIPInfo, // NflfootInputInfo, NflfootDIPInfo, + NflfootInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x40, + 512, 480, 4, 3 +}; +