1 // FB Alpha Seta driver module
2 // Based on MAME driver by Luca Elia
3
4 #include "tiles_generic.h"
5 #include "m68000_intf.h"
6 #include "z80_intf.h"
7 #include "m6502_intf.h"
8 #include "burn_ym2612.h"
9 #include "burn_ym3812.h"
10 #include "burn_ym2203.h"
11 #include "burn_gun.h"
12 #include "msm6295.h"
13 #include "x1010.h"
14
15 /*
16 To do:
17 flipscreen support
18 jockeyc needs work...
19 */
20
21 #define NOIRQ2 0x80
22 #define SET_IRQLINES(vblank, irq2) (((vblank) << 8) | (irq2))
23 #define SPRITE_BUFFER 1
24 #define NO_SPRITE_BUFFER 0
25 #define SET_GFX_DECODE(n0, n1, n2) n0, n1, n2
26
27 static UINT8 *AllMem = NULL;
28 static UINT8 *MemEnd = NULL;
29 static UINT8 *AllRam = NULL;
30 static UINT8 *RamEnd = NULL;
31 static UINT8 *Drv68KROM = NULL;
32 static UINT8 *DrvSubROM = NULL;
33 static UINT8 *DrvGfxROM0 = NULL;
34 static UINT8 *DrvGfxROM1 = NULL;
35 static UINT8 *DrvGfxROM2 = NULL;
36 static UINT8 *DrvColPROM = NULL;
37 static UINT8 *DrvSndROM = NULL;
38 static UINT8 *Drv68KRAM = NULL;
39 static UINT8 *Drv68KRAM2 = NULL;
40 static UINT8 *Drv68KRAM3 = NULL;
41 static UINT8 *DrvSubRAM = NULL;
42 static UINT8 *DrvShareRAM = NULL;
43 static UINT8 *DrvNVRAM = NULL;
44 static UINT8 *DrvPalRAM = NULL;
45 static UINT8 *DrvSprRAM0 = NULL;
46 static UINT8 *DrvSprRAM1 = NULL;
47 static UINT8 *DrvVidRAM0 = NULL;
48 static UINT8 *DrvVidRAM1 = NULL;
49 static UINT8 *DrvVIDCTRLRAM0 = NULL;
50 static UINT8 *DrvVIDCTRLRAM1 = NULL;
51 static UINT8 *DrvVideoRegs = NULL;
52
53 static UINT32 *Palette = NULL;
54 static UINT32 *DrvPalette = NULL;
55 static UINT8 DrvRecalc;
56
57 static UINT8 soundlatch = 0;
58 static UINT8 soundlatch2 = 0;
59
60 static UINT8 *tilebank = NULL;
61 static UINT32 *tile_offset = NULL;
62
63 // allow us to override generic rom loading
64 static INT32 (*pRomLoadCallback)(INT32 bLoad) = NULL;
65
66 static INT32 cpuspeed = 0;
67 static INT32 irqtype = 0;
68 static INT32 buffer_sprites = 0;
69 static INT32 DrvROMLen[5] = { 0, 0, 0, 0, 0 };
70 static INT32 DrvGfxMask[3] = { 0, 0, 0 };
71 static UINT8 *DrvGfxTransMask[3] = { NULL, NULL, NULL };
72 static INT32 VideoOffsets[3][2] = { { 0, 0 }, { 0, 0 }, { 0, 0 } };
73 static INT32 ColorOffsets[3] = { 0, 0, 0 };
74 static INT32 ColorDepths[3];
75 static INT32 twineagle = 0;
76 static INT32 daiohc = 0; // lazy fix - disable writes to alternate scroll write offsets
77 static INT32 usclssic = 0;
78 static INT32 oisipuzl_hack = 0; // 32px sprite offset
79 static INT32 refresh_rate = 6000;
80
81 static INT32 seta_samples_bank = 0;
82 static INT32 usclssic_port_select = 0;
83 static INT32 gun_input_bit = 0;
84 static INT32 gun_input_src = 0;
85 static INT32 flipflop = 0;
86
87 static INT32 watchdog_enable = 0; // not dynamic (config @ game init)
88 static INT32 watchdog = 0;
89 static INT32 flipscreen;
90 static INT32 m65c02_mode = 0; // not dynamic (config @ game init)
91 static INT32 m65c02_bank = 0;
92 static INT32 sub_ctrl_data = 0;
93 static INT32 has_2203 = 0;
94 static INT32 has_z80 = 0;
95
96 static INT32 DrvAxis[4];
97 static UINT16 DrvAnalogInput[4];
98 static UINT8 DrvJoy1[16];
99 static UINT8 DrvJoy2[16];
100 static UINT8 DrvJoy3[16];
101 static UINT8 DrvJoy4[16];
102 static UINT8 DrvJoy5[16];
103 static UINT8 DrvJoy6[16];
104 static UINT8 DrvJoy7[16];
105 static UINT8 DrvDips[7];
106 static UINT16 DrvInputs[7];
107 static UINT8 DrvReset;
108
109 // trackball stuff for Krazy Bowl & usclssic
110 static INT32 trackball_mode = 0;
111 static INT16 DrvAnalogPort0 = 0;
112 static INT16 DrvAnalogPort1 = 0;
113 static INT16 DrvAnalogPort2 = 0;
114 static INT16 DrvAnalogPort3 = 0;
115 static UINT32 track_x = 0;
116 static UINT32 track_y = 0;
117 static INT32 track_x_last = 0;
118 static INT32 track_y_last = 0;
119 static UINT32 track_x2 = 0;
120 static UINT32 track_y2 = 0;
121 static INT32 track_x2_last = 0;
122 static INT32 track_y2_last = 0;
123
124 // Rotation stuff! -dink
125 static UINT8 DrvFakeInput[6] = {0, 0, 0, 0, 0, 0};
126 static UINT8 nRotateHoldInput[2] = {0, 0};
127 static INT32 nRotate[2] = {0, 0};
128 static INT32 nRotateTarget[2] = {0, 0};
129 static INT32 nRotateTry[2] = {0, 0};
130 static UINT32 nRotateTime[2] = {0, 0};
131 static UINT8 game_rotates = 0;
132 static UINT8 clear_opposites = 0;
133
134 #define A(a, b, c, d) { a, b, (UINT8*)(c), d }
135
136 static struct BurnInputInfo QzkklogyInputList[] = {
137 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
138 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
139 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 2, "p1 fire 1" },
140 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 3, "p1 fire 2" },
141 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 0, "p1 fire 3" },
142 {"P1 Button 4", BIT_DIGITAL, DrvJoy1 + 1, "p1 fire 4" },
143 {"P1 Button 5", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 5" },
144
145 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
146 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
147 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 2, "p2 fire 1" },
148 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 3, "p2 fire 2" },
149 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 0, "p2 fire 3" },
150 {"P2 Button 4", BIT_DIGITAL, DrvJoy2 + 1, "p2 fire 4" },
151
152 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
153 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
154 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
155 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
156 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
157 };
158
159 STDINPUTINFO(Qzkklogy)
160
161 static struct BurnInputInfo DrgnunitInputList[] = {
162 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
163 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
164 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
165 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
166 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
167 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
168 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
169 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
170 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
171
172 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
173 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
174 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
175 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
176 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
177 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
178 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
179 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
180 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
181
182 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
183 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
184 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
185 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
186 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
187 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
188 };
189
190 STDINPUTINFO(Drgnunit)
191
192 static struct BurnInputInfo StgInputList[] = {
193 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
194 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
195 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
196 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
197 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
198 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
199 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
200 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
201 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
202
203 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
204 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
205 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
206 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
207 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
208 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
209 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
210 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
211
212 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
213 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
214 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
215 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
216 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
217 };
218
219 STDINPUTINFO(Stg)
220
221 static struct BurnInputInfo Qzkklgy2InputList[] = {
222 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
223 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
224 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 2, "p1 fire 1" },
225 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 3, "p1 fire 2" },
226 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 0, "p1 fire 3" },
227 {"P1 Button 4", BIT_DIGITAL, DrvJoy1 + 1, "p1 fire 4" },
228
229 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
230 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
231 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 2, "p2 fire 1" },
232 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 3, "p2 fire 2" },
233 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 0, "p2 fire 3" },
234 {"P2 Button 4", BIT_DIGITAL, DrvJoy2 + 1, "p2 fire 4" },
235
236 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
237 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
238 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
239 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
240 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
241 };
242
243 STDINPUTINFO(Qzkklgy2)
244
245 static struct BurnInputInfo DaiohInputList[] = {
246 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
247 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
248 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
249 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
250 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
251 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
252 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
253 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
254 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
255 {"P1 Button 4", BIT_DIGITAL, DrvJoy4 + 0, "p1 fire 4" },
256 {"P1 Button 5", BIT_DIGITAL, DrvJoy4 + 1, "p1 fire 5" },
257 {"P1 Button 6", BIT_DIGITAL, DrvJoy4 + 2, "p1 fire 6" },
258
259 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
260 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
261 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
262 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
263 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
264 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
265 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
266 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
267 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
268 {"P2 Button 4", BIT_DIGITAL, DrvJoy4 + 3, "p2 fire 4" },
269 {"P2 Button 5", BIT_DIGITAL, DrvJoy4 + 4, "p2 fire 5" },
270 {"P2 Button 6", BIT_DIGITAL, DrvJoy4 + 5, "p2 fire 6" },
271
272 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
273 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
274 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
275 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
276 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
277 };
278
279 STDINPUTINFO(Daioh)
280
281 static struct BurnInputInfo RezonInputList[] = {
282 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
283 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
284 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
285 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
286 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
287 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
288 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
289 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
290 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
291
292 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
293 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
294 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
295 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
296 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
297 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
298 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
299 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
300 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
301
302 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
303 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
304 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
305 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
306 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
307 };
308
309 STDINPUTINFO(Rezon)
310
311 static struct BurnInputInfo EightfrcInputList[] = {
312 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
313 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
314 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
315 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
316 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
317 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
318 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
319 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
320
321 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
322 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
323 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
324 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
325 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
326 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
327 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
328 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
329
330 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
331 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
332 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
333 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
334 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
335 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
336 };
337
338 STDINPUTINFO(Eightfrc)
339
340 static struct BurnInputInfo WrofaeroInputList[] = {
341 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
342 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
343 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
344 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
345 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
346 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
347 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
348 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
349 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
350
351 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
352 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
353 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
354 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
355 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
356 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
357 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
358 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
359 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
360
361 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
362 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
363 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
364 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
365 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
366 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
367 };
368
369 STDINPUTINFO(Wrofaero)
370
371 static struct BurnInputInfo ZingzipInputList[] = {
372 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
373 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
374 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
375 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
376 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
377 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
378 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
379 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
380
381 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
382 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
383 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
384 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
385 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
386 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
387 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
388
389 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
390 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
391 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
392 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
393 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
394 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
395 };
396
397 STDINPUTINFO(Zingzip)
398
399 static struct BurnInputInfo MsgundamInputList[] = {
400 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
401 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
402 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
403 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
404 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
405 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
406 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
407 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
408
409 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
410 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
411 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
412 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
413 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
414 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
415 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
416 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
417
418 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
419 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
420 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
421 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
422 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
423 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
424 };
425
426 STDINPUTINFO(Msgundam)
427
428 static struct BurnInputInfo KamenridInputList[] = {
429 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
430 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
431 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
432 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
433 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
434 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
435 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
436 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
437
438 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
439 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
440 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
441 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
442 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
443 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
444 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
445 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
446
447 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
448 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
449 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
450 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
451 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
452 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
453 };
454
455 STDINPUTINFO(Kamenrid)
456
457 static struct BurnInputInfo MadsharkInputList[] = {
458 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
459 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
460 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
461 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
462 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
463 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
464 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
465 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
466
467 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
468 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
469 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
470 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
471 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
472 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
473 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
474 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
475
476 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
477 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
478 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
479 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
480 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
481 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
482 };
483
484 STDINPUTINFO(Madshark)
485
486 static struct BurnInputInfo WitsInputList[] = {
487 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
488 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
489 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
490 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
491 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
492 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
493 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
494 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
495
496 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
497 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
498 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
499 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
500 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
501 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
502 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
503 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
504
505 {"P3 Start", BIT_DIGITAL, DrvJoy4 + 7, "p3 start" },
506 {"P3 Up", BIT_DIGITAL, DrvJoy4 + 2, "p3 up" },
507 {"P3 Down", BIT_DIGITAL, DrvJoy4 + 3, "p3 down" },
508 {"P3 Left", BIT_DIGITAL, DrvJoy4 + 0, "p3 left" },
509 {"P3 Right", BIT_DIGITAL, DrvJoy4 + 1, "p3 right" },
510 {"P3 Button 1", BIT_DIGITAL, DrvJoy4 + 4, "p3 fire 1" },
511 {"P3 Button 2", BIT_DIGITAL, DrvJoy4 + 5, "p3 fire 2" },
512
513 {"P4 Start", BIT_DIGITAL, DrvJoy5 + 7, "p4 start" },
514 {"P4 Up", BIT_DIGITAL, DrvJoy5 + 2, "p4 up" },
515 {"P4 Down", BIT_DIGITAL, DrvJoy5 + 3, "p4 down" },
516 {"P4 Left", BIT_DIGITAL, DrvJoy5 + 0, "p4 left" },
517 {"P4 Right", BIT_DIGITAL, DrvJoy5 + 1, "p4 right" },
518 {"P4 Button 1", BIT_DIGITAL, DrvJoy5 + 4, "p4 fire 1" },
519 {"P4 Button 2", BIT_DIGITAL, DrvJoy5 + 5, "p4 fire 2" },
520
521 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
522 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
523 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
524 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
525 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
526 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
527 };
528
529 STDINPUTINFO(Wits)
530
531 static struct BurnInputInfo ThunderlInputList[] = {
532 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
533 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
534 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
535 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
536 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
537 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
538 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
539 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
540
541 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
542 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
543 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
544 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
545 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
546 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
547 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
548 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
549
550 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
551 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
552 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
553 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
554 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
555 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
556 };
557
558 STDINPUTINFO(Thunderl)
559
560 static struct BurnInputInfo AtehateInputList[] = {
561 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
562 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
563 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 2, "p1 fire 1" },
564 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 3, "p1 fire 2" },
565 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 0, "p1 fire 3" },
566 {"P1 Button 4", BIT_DIGITAL, DrvJoy1 + 1, "p1 fire 4" },
567
568 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
569 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
570 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 2, "p2 fire 1" },
571 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 3, "p2 fire 2" },
572 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 0, "p2 fire 3" },
573 {"P2 Button 4", BIT_DIGITAL, DrvJoy2 + 1, "p2 fire 4" },
574
575 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
576 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
577 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
578 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
579 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
580 };
581
582 STDINPUTINFO(Atehate)
583
584 static struct BurnInputInfo BlockcarInputList[] = {
585 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
586 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
587 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
588 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
589 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
590 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
591 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
592 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
593
594 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
595 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
596 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
597 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
598 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
599 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
600 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
601 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
602
603 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
604 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
605 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
606 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
607 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
608 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
609 };
610
611 STDINPUTINFO(Blockcar)
612
613 static struct BurnInputInfo GundharaInputList[] = {
614 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
615 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
616 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
617 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
618 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
619 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
620 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
621 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
622 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
623
624 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
625 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
626 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
627 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
628 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
629 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
630 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
631 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
632 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
633
634 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
635 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
636 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
637 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
638 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
639 };
640
641 STDINPUTINFO(Gundhara)
642
643 static struct BurnInputInfo BlandiaInputList[] = {
644 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
645 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
646 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
647 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
648 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
649 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
650 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
651 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
652 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
653
654 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
655 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
656 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
657 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
658 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
659 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
660 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
661 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
662 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
663
664 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
665 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
666 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
667 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
668 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
669 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
670 };
671
672 STDINPUTINFO(Blandia)
673
674 static struct BurnInputInfo OisipuzlInputList[] = {
675 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
676 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
677 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
678 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
679 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
680 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
681 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
682 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
683
684 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
685 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
686 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
687 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
688 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
689 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
690 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
691
692 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
693 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
694 {"Service", BIT_DIGITAL, DrvJoy3 + 3, "service" },
695 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
696 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
697 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
698 };
699
700 STDINPUTINFO(Oisipuzl)
701
702 static struct BurnInputInfo PairloveInputList[] = {
703 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
704 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
705 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
706 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
707 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
708 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
709 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
710 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
711
712 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
713 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
714 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
715 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
716 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
717 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
718 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
719 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
720
721 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
722 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
723 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt" },
724 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
725 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
726 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
727 };
728
729 STDINPUTINFO(Pairlove)
730
731 static struct BurnInputInfo OrbsInputList[] = {
732 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
733 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
734 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
735 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
736 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
737 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
738 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
739
740 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
741 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
742 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
743 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
744 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
745 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
746 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
747
748 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
749 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
750 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
751 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
752 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
753 };
754
755 STDINPUTINFO(Orbs)
756
757 static struct BurnInputInfo KeroppiInputList[] = {
758 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
759 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
760
761 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
762 {"Service", BIT_DIGITAL, DrvJoy2 + 2, "service" },
763 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
764 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
765 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
766 };
767
768 STDINPUTINFO(Keroppi)
769
770 static struct BurnInputInfo JjsquawkInputList[] = {
771 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
772 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
773 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
774 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
775 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
776 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
777 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
778 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
779
780 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
781 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
782 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
783 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
784 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
785 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
786 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
787 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
788
789 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
790 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
791 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
792 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
793 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
794 };
795
796 STDINPUTINFO(Jjsquawk)
797
798 static struct BurnInputInfo ExtdwnhlInputList[] = {
799 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
800 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
801 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
802 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
803 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
804
805 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
806 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
807 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
808 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
809 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
810
811 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
812 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
813 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
814 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
815 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
816 };
817
818 STDINPUTINFO(Extdwnhl)
819
820 static struct BurnInputInfo KrzybowlInputList[] = {
821 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
822 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
823 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
824 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
825 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
826 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
827 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
828 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
829 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
830
831 A("P1 Trackball X", BIT_ANALOG_REL, &DrvAnalogPort0,"p1 x-axis"),
832 A("P1 Trackball Y", BIT_ANALOG_REL, &DrvAnalogPort1,"p1 y-axis"),
833
834 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
835 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
836 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
837 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
838 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
839 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
840 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
841 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
842 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
843
844 A("P2 Trackball X", BIT_ANALOG_REL, &DrvAnalogPort2,"p2 x-axis"),
845 A("P2 Trackball Y", BIT_ANALOG_REL, &DrvAnalogPort3,"p2 y-axis"),
846
847 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
848 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
849 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
850 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
851 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
852 };
853
854 STDINPUTINFO(Krzybowl)
855
856 static struct BurnInputInfo UtoukondInputList[] = {
857 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
858 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
859 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
860 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
861 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
862 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
863 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
864 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
865 {"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 3" },
866
867 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
868 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
869 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
870 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
871 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
872 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
873 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
874 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
875 {"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 3" },
876
877 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
878 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
879 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
880 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
881 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
882 };
883
884 STDINPUTINFO(Utoukond)
885
886 static struct BurnInputInfo TndrcadeInputList[] = {
887 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
888 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 2, "p1 start" },
889 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
890 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
891 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
892 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
893 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
894 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
895
896 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
897 {"P2 Start", BIT_DIGITAL, DrvJoy3 + 3, "p2 start" },
898 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
899 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
900 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
901 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
902 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
903 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
904
905 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
906 {"Service", BIT_DIGITAL, DrvJoy3 + 4, "service" },
907 {"Tilt", BIT_DIGITAL, DrvJoy3 + 5, "tilt"},
908 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
909 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
910 };
911
912 STDINPUTINFO(Tndrcade)
913
914 static struct BurnInputInfo DowntownInputList[] = {
915 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 7, "p1 coin" },
916 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
917 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 0, "p1 up" },
918 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 1, "p1 down" },
919 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 2, "p1 left" },
920 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 3, "p1 right" },
921 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
922 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
923 {"P1 Button 3 (rotate)", BIT_DIGITAL, DrvFakeInput + 4, "p1 fire 3" },
924
925 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 6, "p2 coin" },
926 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
927 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 0, "p2 up" },
928 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 1, "p2 down" },
929 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 2, "p2 left" },
930 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 3, "p2 right" },
931 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
932 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
933 {"P2 Button 3 (rotate)", BIT_DIGITAL, DrvFakeInput + 5, "p2 fire 3" },
934
935 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
936 {"Service", BIT_DIGITAL, DrvJoy3 + 5, "service" },
937 {"Tilt", BIT_DIGITAL, DrvJoy3 + 4, "tilt"},
938 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
939 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
940 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
941 };
942
943 STDINPUTINFO(Downtown)
944
945 static struct BurnInputInfo MetafoxInputList[] = {
946 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 7, "p1 coin" },
947 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
948 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 0, "p1 up" },
949 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 1, "p1 down" },
950 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 2, "p1 left" },
951 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 3, "p1 right" },
952 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
953 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
954
955 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 6, "p2 coin" },
956 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
957 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 0, "p2 up" },
958 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 1, "p2 down" },
959 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 2, "p2 left" },
960 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 3, "p2 right" },
961 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
962 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
963
964 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
965 {"Service", BIT_DIGITAL, DrvJoy3 + 5, "service" },
966 {"Tilt", BIT_DIGITAL, DrvJoy3 + 4, "tilt"},
967 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
968 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
969 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
970 };
971
972 STDINPUTINFO(Metafox)
973
974 static struct BurnInputInfo ZombraidInputList[] = {
975 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
976 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
977 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "mouse button 1" },
978 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "mouse button 2" },
979 A("P1 Right / left", BIT_ANALOG_REL, DrvAxis + 0, "mouse x-axis"),
980 A("P1 Up / Down", BIT_ANALOG_REL, DrvAxis + 1, "mouse y-axis"),
981
982 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
983 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
984 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
985 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
986 A("P2 Right / left", BIT_ANALOG_REL, DrvAxis + 2, "p2 x-axis"),
987 A("P2 Up / Down", BIT_ANALOG_REL, DrvAxis + 3, "p2 y-axis"),
988
989 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
990 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
991 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
992 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
993 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
994 };
995
996 STDINPUTINFO(Zombraid)
997
998 static struct BurnInputInfo KiwameInputList[] = {
999 {"Coin 1", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" },
1000 {"Coin 2", BIT_DIGITAL, DrvJoy1 + 1, "p2 coin" },
1001 {"Start", BIT_DIGITAL, DrvJoy4 + 5, "p1 start" },
1002 {"P1 A", BIT_DIGITAL, DrvJoy4 + 0, "mah a" },
1003 {"P1 B", BIT_DIGITAL, DrvJoy3 + 0, "mah b" },
1004 {"P1 C", BIT_DIGITAL, DrvJoy5 + 0, "mah c" },
1005 {"P1 D", BIT_DIGITAL, DrvJoy6 + 0, "mah d" },
1006 {"P1 E", BIT_DIGITAL, DrvJoy4 + 1, "mah e" },
1007 {"P1 F", BIT_DIGITAL, DrvJoy2 + 3, "mah f" },
1008 {"P1 G", BIT_DIGITAL, DrvJoy5 + 1, "mah g" },
1009 {"P1 H", BIT_DIGITAL, DrvJoy6 + 1, "mah h" },
1010 {"P1 I", BIT_DIGITAL, DrvJoy4 + 2, "mah i" },
1011 {"P1 J", BIT_DIGITAL, DrvJoy3 + 2, "mah j" },
1012 {"P1 K", BIT_DIGITAL, DrvJoy4 + 4, "mah k" },
1013 {"P1 L", BIT_DIGITAL, DrvJoy2 + 0, "mah l" },
1014 {"P1 M", BIT_DIGITAL, DrvJoy4 + 3, "mah m" },
1015 {"P1 N", BIT_DIGITAL, DrvJoy3 + 3, "mah n" },
1016 {"P1 Pon", BIT_DIGITAL, DrvJoy6 + 3, "mah pon" },
1017 {"P1 Chi", BIT_DIGITAL, DrvJoy5 + 3, "mah chi" },
1018 {"P1 Kan", BIT_DIGITAL, DrvJoy4 + 4, "mah kan" },
1019 {"P1 Ron", BIT_DIGITAL, DrvJoy5 + 4, "mah ron" },
1020 {"P1 Reach", BIT_DIGITAL, DrvJoy3 + 4, "mah reach" },
1021 {"P1 Flip Flip",BIT_DIGITAL, DrvJoy2 + 3, "mah ff" },
1022
1023 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1024 {"Service", BIT_DIGITAL, DrvJoy1 + 2, "service" },
1025 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1026 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1027 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1028 };
1029
1030 STDINPUTINFO(Kiwame)
1031
1032 static struct BurnInputInfo SokonukeInputList[] = {
1033 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
1034 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
1035 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
1036 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
1037 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
1038 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
1039 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
1040
1041 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
1042 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
1043 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
1044 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
1045 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
1046 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
1047 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
1048
1049 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1050 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
1051 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1052 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1053 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1054 };
1055
1056 STDINPUTINFO(Sokonuke)
1057
1058 static struct BurnInputInfo NeobattlInputList[] = {
1059 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
1060 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
1061 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
1062 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
1063 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
1064 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
1065 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
1066
1067 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
1068 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
1069 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
1070 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
1071 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
1072 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
1073 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
1074
1075 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1076 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
1077 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
1078 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1079 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1080 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1081 };
1082
1083 STDINPUTINFO(Neobattl)
1084
1085 static struct BurnInputInfo UmanclubInputList[] = {
1086 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
1087 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
1088 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
1089 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
1090 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
1091 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
1092 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
1093 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
1094
1095 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
1096 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
1097 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
1098 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
1099 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
1100 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
1101 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
1102 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
1103
1104 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1105 {"Service", BIT_DIGITAL, DrvJoy3 + 2, "service" },
1106 {"Tilt", BIT_DIGITAL, DrvJoy3 + 3, "tilt"},
1107 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1108 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1109 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1110 };
1111
1112 STDINPUTINFO(Umanclub)
1113
1114 static struct BurnInputInfo TwineaglInputList[] = {
1115 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
1116 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 2, "p1 start" },
1117 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
1118 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
1119 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 0, "p1 left" },
1120 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 1, "p1 right" },
1121 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
1122 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
1123
1124 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
1125 {"P2 Start", BIT_DIGITAL, DrvJoy3 + 3, "p2 start" },
1126 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
1127 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
1128 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 0, "p2 left" },
1129 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 1, "p2 right" },
1130 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
1131 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
1132
1133 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1134 {"Service", BIT_DIGITAL, DrvJoy3 + 4, "service" },
1135 {"Tilt", BIT_DIGITAL, DrvJoy3 + 5, "tilt"},
1136 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1137 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1138 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1139 };
1140
1141 STDINPUTINFO(Twineagl)
1142
1143 static struct BurnInputInfo CrazyfgtInputList[] = {
1144 {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 0, "p1 coin" },
1145 {"P1 top-left", BIT_DIGITAL, DrvJoy2 + 2, "p1 fire 1" },
1146 {"P1 top-center", BIT_DIGITAL, DrvJoy2 + 0, "p1 fire 2" },
1147 {"P1 top-right", BIT_DIGITAL, DrvJoy2 + 4, "p1 fire 3" },
1148 {"P1 bottom-left", BIT_DIGITAL, DrvJoy2 + 3, "p1 fire 4" },
1149 {"P1 bottom-center",BIT_DIGITAL, DrvJoy2 + 1, "p1 fire 5" },
1150 {"P1 bottom-right", BIT_DIGITAL, DrvJoy2 + 5, "p1 fire 6" },
1151
1152 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1153 {"Service", BIT_DIGITAL, DrvJoy2 + 7, "service" },
1154 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1155 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1156 };
1157
1158 STDINPUTINFO(Crazyfgt)
1159
1160 static struct BurnInputInfo Calibr50InputList[] = {
1161 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 7, "p1 coin" },
1162 {"P1 Start", BIT_DIGITAL, DrvJoy1 + 7, "p1 start" },
1163 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 0, "p1 up" },
1164 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 1, "p1 down" },
1165 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 2, "p1 left" },
1166 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 3, "p1 right" },
1167 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
1168 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
1169 {"P1 Button 3 (rotate)", BIT_DIGITAL, DrvFakeInput + 4, "p1 fire 3" },
1170
1171 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 6, "p2 coin" },
1172 {"P2 Start", BIT_DIGITAL, DrvJoy2 + 7, "p2 start" },
1173 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 0, "p2 up" },
1174 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 1, "p2 down" },
1175 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 2, "p2 left" },
1176 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 3, "p2 right" },
1177 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
1178 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
1179 {"P2 Button 3 (rotate)", BIT_DIGITAL, DrvFakeInput + 5, "p2 fire 3" },
1180
1181 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1182 {"Service", BIT_DIGITAL, DrvJoy3 + 5, "service" },
1183 {"Tilt", BIT_DIGITAL, DrvJoy3 + 4, "tilt"},
1184 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1185 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1186 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1187 };
1188
1189 STDINPUTINFO(Calibr50)
1190
1191 static struct BurnInputInfo UsclssicInputList[] = {
1192 {"P1 Coin", BIT_DIGITAL, DrvJoy1 + 4, "p1 coin" },
1193 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 14, "p1 start" },
1194 {"P1 Button 1", BIT_DIGITAL, DrvJoy3 + 13, "p1 fire 1" },
1195
1196 A("P1 Trackball X", BIT_ANALOG_REL, &DrvAnalogPort0,"p1 x-axis"),
1197 A("P1 Trackball Y", BIT_ANALOG_REL, &DrvAnalogPort1,"p1 y-axis"),
1198
1199 {"P2 Coin", BIT_DIGITAL, DrvJoy1 + 5, "p2 coin" },
1200 {"P2 Start", BIT_DIGITAL, DrvJoy5 + 14, "p2 start" },
1201 {"P2 Button 1", BIT_DIGITAL, DrvJoy5 + 13, "p2 fire 1" },
1202
1203 A("P2 Trackball X", BIT_ANALOG_REL, &DrvAnalogPort2,"p2 x-axis"),
1204 A("P2 Trackball Y", BIT_ANALOG_REL, &DrvAnalogPort3,"p2 y-axis"),
1205
1206 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1207 {"Service", BIT_DIGITAL, DrvJoy1 + 6, "service" },
1208 {"Tilt", BIT_DIGITAL, DrvJoy1 + 7, "tilt" },
1209 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1210 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1211 };
1212
1213 STDINPUTINFO(Usclssic)
1214
1215 static struct BurnInputInfo JockeycInputList[] = {
1216 {"P1 A Coin", BIT_DIGITAL, DrvJoy1 + 5, "p1 coin" },
1217 {"P1 B Coin", BIT_DIGITAL, DrvJoy1 + 4, "p3 coin" },
1218 {"P1 Start", BIT_DIGITAL, DrvJoy4 + 3, "p1 start" },
1219 {"P1 Bet 1", BIT_DIGITAL, DrvJoy3 + 0, "p1 bet 1" },
1220 {"P1 Bet 2", BIT_DIGITAL, DrvJoy3 + 1, "p1 bet 2" },
1221 {"P1 Bet 3", BIT_DIGITAL, DrvJoy3 + 2, "p1 bet 3" },
1222 {"P1 Bet 4", BIT_DIGITAL, DrvJoy3 + 3, "p1 bet 4" },
1223 {"P1 Bet 5", BIT_DIGITAL, DrvJoy3 + 4, "p1 bet 5" },
1224 {"P1 Bet 6", BIT_DIGITAL, DrvJoy4 + 0, "p1 bet 6" },
1225 {"P1 Bet 1-2", BIT_DIGITAL, DrvJoy5 + 0, "p1 bet 1-2" },
1226 {"P1 Bet 1-3", BIT_DIGITAL, DrvJoy5 + 1, "p1 bet 1-3" },
1227 {"P1 Bet 1-4", BIT_DIGITAL, DrvJoy5 + 2, "p1 bet 1-4" },
1228 {"P1 Bet 1-5", BIT_DIGITAL, DrvJoy5 + 3, "p1 bet 1-5" },
1229 {"P1 Bet 1-6", BIT_DIGITAL, DrvJoy5 + 4, "p1 bet 1-6" },
1230 {"P1 Bet 2-3", BIT_DIGITAL, DrvJoy6 + 0, "p1 bet 2-3" },
1231 {"P1 Bet 2-4", BIT_DIGITAL, DrvJoy6 + 1, "p1 bet 2-4" },
1232 {"P1 Bet 2-5", BIT_DIGITAL, DrvJoy6 + 2, "p1 bet 2-5" },
1233 {"P1 Bet 2-6", BIT_DIGITAL, DrvJoy6 + 3, "p1 bet 2-6" },
1234 {"P1 Bet 3-4", BIT_DIGITAL, DrvJoy6 + 4, "p1 bet 3-4" },
1235 {"P1 Bet 3-5", BIT_DIGITAL, DrvJoy7 + 0, "p1 bet 3-5" },
1236 {"P1 Bet 3-6", BIT_DIGITAL, DrvJoy7 + 1, "p1 bet 3-6" },
1237 {"P1 Bet 4-5", BIT_DIGITAL, DrvJoy7 + 2, "p1 bet 4-5" },
1238 {"P1 Bet 4-6", BIT_DIGITAL, DrvJoy7 + 3, "p1 bet 4-6" },
1239 {"P1 Bet 5-6", BIT_DIGITAL, DrvJoy7 + 4, "p1 bet 5-6" },
1240 {"P1 Collect", BIT_DIGITAL, DrvJoy4 + 1, "p1 collect" },
1241 {"P1 Credit", BIT_DIGITAL, DrvJoy4 + 2, "p1 credit" },
1242 {"P1 Cancel", BIT_DIGITAL, DrvJoy4 + 4, "p1 cancel" },
1243
1244 {"P2 A Coin", BIT_DIGITAL, DrvJoy1 + 13, "p2 coin" },
1245 {"P2 B Coin", BIT_DIGITAL, DrvJoy1 + 12, "p4 coin" },
1246 {"P2 Start", BIT_DIGITAL, DrvJoy4 + 11, "p2 start" },
1247 {"P2 Bet 1", BIT_DIGITAL, DrvJoy3 + 8, "p2 bet 1" },
1248 {"P2 Bet 2", BIT_DIGITAL, DrvJoy3 + 9, "p2 bet 2" },
1249 {"P2 Bet 3", BIT_DIGITAL, DrvJoy3 + 10, "p2 bet 3" },
1250 {"P2 Bet 4", BIT_DIGITAL, DrvJoy3 + 11, "p2 bet 4" },
1251 {"P2 Bet 5", BIT_DIGITAL, DrvJoy3 + 12, "p2 bet 5" },
1252 {"P2 Bet 6", BIT_DIGITAL, DrvJoy4 + 8, "p2 bet 6" },
1253 {"P2 Bet 1-2", BIT_DIGITAL, DrvJoy5 + 8, "p2 bet 1-2" },
1254 {"P2 Bet 1-3", BIT_DIGITAL, DrvJoy5 + 9, "p2 bet 1-3" },
1255 {"P2 Bet 1-4", BIT_DIGITAL, DrvJoy5 + 10, "p2 bet 1-4" },
1256 {"P2 Bet 1-5", BIT_DIGITAL, DrvJoy5 + 11, "p2 bet 1-5" },
1257 {"P2 Bet 1-6", BIT_DIGITAL, DrvJoy5 + 12, "p2 bet 1-6" },
1258 {"P2 Bet 2-3", BIT_DIGITAL, DrvJoy6 + 8, "p2 bet 2-3" },
1259 {"P2 Bet 2-4", BIT_DIGITAL, DrvJoy6 + 9, "p2 bet 2-4" },
1260 {"P2 Bet 2-5", BIT_DIGITAL, DrvJoy6 + 10, "p2 bet 2-5" },
1261 {"P2 Bet 2-6", BIT_DIGITAL, DrvJoy6 + 11, "p2 bet 2-6" },
1262 {"P2 Bet 3-4", BIT_DIGITAL, DrvJoy6 + 12, "p2 bet 3-4" },
1263 {"P2 Bet 3-5", BIT_DIGITAL, DrvJoy7 + 8, "p2 bet 3-5" },
1264 {"P2 Bet 3-6", BIT_DIGITAL, DrvJoy7 + 9, "p2 bet 3-6" },
1265 {"P2 Bet 4-5", BIT_DIGITAL, DrvJoy7 + 10, "p2 bet 4-5" },
1266 {"P2 Bet 4-6", BIT_DIGITAL, DrvJoy7 + 11, "p2 bet 4-6" },
1267 {"P2 Bet 5-6", BIT_DIGITAL, DrvJoy7 + 12, "p2 bet 5-6" },
1268 {"P2 Collect", BIT_DIGITAL, DrvJoy4 + 9, "p2 collect" },
1269 {"P2 Credit", BIT_DIGITAL, DrvJoy4 + 10, "p2 credit" },
1270 {"P2 Cancel", BIT_DIGITAL, DrvJoy4 + 12, "p2 cancel" },
1271
1272 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
1273 {"Service", BIT_DIGITAL, DrvJoy2 + 14, "service" },
1274 {"Service", BIT_DIGITAL, DrvJoy2 + 0, "service" },
1275 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
1276 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
1277 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
1278 {"Dip D", BIT_DIPSWITCH, DrvDips + 3, "dip" },
1279 {"Dip E", BIT_DIPSWITCH, DrvDips + 4, "dip" },
1280 {"Dip F", BIT_DIPSWITCH, DrvDips + 5, "dip" },
1281 {"Dip 10", BIT_DIPSWITCH, DrvDips + 6, "dip" },
1282 };
1283
1284 STDINPUTINFO(Jockeyc)
1285
1286 #undef A
1287
1288 static struct BurnDIPInfo CrazyfgtDIPList[]=
1289 {
1290 {0x09, 0xff, 0xff, 0x3f, NULL },
1291 {0x0a, 0xff, 0xff, 0xff, NULL },
1292
1293 {0 , 0xfe, 0 , 8, "Coin A" },
1294 {0x09, 0x01, 0x07, 0x00, "4 Coins 1 Credits" },
1295 {0x09, 0x01, 0x07, 0x01, "3 Coins 1 Credits" },
1296 {0x09, 0x01, 0x07, 0x02, "2 Coins 1 Credits" },
1297 {0x09, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
1298 {0x09, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
1299 {0x09, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
1300 {0x09, 0x01, 0x07, 0x04, "1 Coin 4 Credits" },
1301 {0x09, 0x01, 0x07, 0x03, "1 Coin 5 Credits" },
1302
1303 {0 , 0xfe, 0 , 8, "Coin B" },
1304 {0x09, 0x01, 0x38, 0x00, "4 Coins 1 Credits" },
1305 {0x09, 0x01, 0x38, 0x08, "3 Coins 1 Credits" },
1306 {0x09, 0x01, 0x38, 0x10, "2 Coins 1 Credits" },
1307 {0x09, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
1308 {0x09, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
1309 {0x09, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
1310 {0x09, 0x01, 0x38, 0x20, "1 Coin 4 Credits" },
1311 {0x09, 0x01, 0x38, 0x18, "1 Coin 5 Credits" },
1312
1313 {0 , 0xfe, 0 , 4, "Unknown" },
1314 {0x09, 0x01, 0xc0, 0xc0, "5" },
1315 {0x09, 0x01, 0xc0, 0x80, "10" },
1316 {0x09, 0x01, 0xc0, 0x40, "15" },
1317 {0x09, 0x01, 0xc0, 0x00, "20" },
1318
1319 {0 , 0xfe, 0 , 2, "Service Mode" },
1320 {0x0a, 0x01, 0x01, 0x01, "Off" },
1321 {0x0a, 0x01, 0x01, 0x00, "On" },
1322
1323 {0 , 0xfe, 0 , 4, "Difficulty?" },
1324 {0x0a, 0x01, 0x0c, 0x0c, "0" },
1325 {0x0a, 0x01, 0x0c, 0x08, "1" },
1326 {0x0a, 0x01, 0x0c, 0x04, "2" },
1327 {0x0a, 0x01, 0x0c, 0x00, "3" },
1328
1329 {0 , 0xfe, 0 , 4, "Energy" },
1330 {0x0a, 0x01, 0x30, 0x10, "24" },
1331 {0x0a, 0x01, 0x30, 0x20, "32" },
1332 {0x0a, 0x01, 0x30, 0x30, "48" },
1333 {0x0a, 0x01, 0x30, 0x00, "100" },
1334
1335 {0 , 0xfe, 0 , 4, "Bonus?" },
1336 {0x0a, 0x01, 0xc0, 0xc0, "0" },
1337 {0x0a, 0x01, 0xc0, 0x80, "1" },
1338 {0x0a, 0x01, 0xc0, 0x40, "2" },
1339 {0x0a, 0x01, 0xc0, 0x00, "3" },
1340 };
1341
1342 STDDIPINFO(Crazyfgt)
1343
1344
1345 static struct BurnDIPInfo UsclssicDIPList[]=
1346 {
1347 {0x0d, 0xff, 0xff, 0xff, NULL },
1348 {0x0e, 0xff, 0xff, 0xfe, NULL },
1349
1350 {0 , 0xfe, 0 , 2, "Credits For 9-Hole" },
1351 {0x0d, 0x01, 0x01, 0x01, "2" },
1352 {0x0d, 0x01, 0x01, 0x00, "3" },
1353
1354 {0 , 0xfe, 0 , 2, "Game Type" },
1355 {0x0d, 0x01, 0x02, 0x02, "Domestic" },
1356 {0x0d, 0x01, 0x02, 0x00, "Foreign" },
1357
1358 {0 , 0xfe, 0 , 4, "Lives" },
1359 {0x0d, 0x01, 0x0c, 0x04, "1" },
1360 {0x0d, 0x01, 0x0c, 0x08, "2" },
1361 {0x0d, 0x01, 0x0c, 0x0c, "3" },
1362 {0x0d, 0x01, 0x0c, 0x00, "4" },
1363
1364 {0 , 0xfe, 0 , 4, "Coin A" },
1365 {0x0d, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1366 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1367 {0x0d, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1368 {0x0d, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1369
1370 {0 , 0xfe, 0 , 4, "Coin B" },
1371 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1372 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1373 {0x0d, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1374 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1375
1376 {0 , 0xfe, 0 , 2, "Cabinet" },
1377 {0x0e, 0x01, 0x01, 0x00, "Upright" },
1378 {0x0e, 0x01, 0x01, 0x01, "Cocktail" },
1379
1380 {0 , 0xfe, 0 , 2, "Flip Screen" },
1381 {0x0e, 0x01, 0x02, 0x02, "Off" },
1382 {0x0e, 0x01, 0x02, 0x00, "On" },
1383
1384 {0 , 0xfe, 0 , 2, "Service Mode" },
1385 {0x0e, 0x01, 0x04, 0x04, "Off" },
1386 {0x0e, 0x01, 0x04, 0x00, "On" },
1387
1388 {0 , 0xfe, 0 , 8, "Flight Distance" },
1389 {0x0e, 0x01, 0x38, 0x38, "Normal" },
1390 {0x0e, 0x01, 0x38, 0x30, "-30 Yards" },
1391 {0x0e, 0x01, 0x38, 0x28, "+10 Yards" },
1392 {0x0e, 0x01, 0x38, 0x20, "+20 Yards" },
1393 {0x0e, 0x01, 0x38, 0x18, "+30 Yards" },
1394 {0x0e, 0x01, 0x38, 0x10, "+40 Yards" },
1395 {0x0e, 0x01, 0x38, 0x08, "+50 Yards" },
1396 {0x0e, 0x01, 0x38, 0x00, "+60 Yards" },
1397
1398 {0 , 0xfe, 0 , 4, "Licensed To" },
1399 {0x0e, 0x01, 0xc0, 0xc0, "Romstar" },
1400 {0x0e, 0x01, 0xc0, 0x80, "None (Japan)" },
1401 {0x0e, 0x01, 0xc0, 0x40, "Taito" },
1402 {0x0e, 0x01, 0xc0, 0x00, "Taito America" },
1403 };
1404
1405 STDDIPINFO(Usclssic)
1406
1407
1408 static struct BurnDIPInfo Calibr50DIPList[]=
1409 {
1410 {0x15, 0xff, 0xff, 0xfe, NULL },
1411 {0x16, 0xff, 0xff, 0xfd, NULL },
1412 {0x17, 0xff, 0xff, 0xff, NULL },
1413
1414 {0 , 0xfe, 0 , 2, "Licensed To" },
1415 {0x15, 0x01, 0x01, 0x01, "Romstar" },
1416 {0x15, 0x01, 0x01, 0x00, "None (Japan)" },
1417
1418 {0 , 0xfe, 0 , 2, "Flip Screen" },
1419 {0x15, 0x01, 0x02, 0x02, "Off" },
1420 {0x15, 0x01, 0x02, 0x00, "On" },
1421
1422 {0 , 0xfe, 0 , 2, "Service Mode" },
1423 {0x15, 0x01, 0x04, 0x04, "Off" },
1424 {0x15, 0x01, 0x04, 0x00, "On" },
1425
1426 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1427 {0x15, 0x01, 0x08, 0x00, "Off" },
1428 {0x15, 0x01, 0x08, 0x08, "On" },
1429
1430 {0 , 0xfe, 0 , 4, "Coin A" },
1431 {0x15, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1432 {0x15, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1433 {0x15, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1434 {0x15, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1435
1436 {0 , 0xfe, 0 , 4, "Coin B" },
1437 {0x15, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1438 {0x15, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1439 {0x15, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1440 {0x15, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1441
1442 {0 , 0xfe, 0 , 4, "Difficulty" },
1443 {0x16, 0x01, 0x03, 0x03, "Easiest" },
1444 {0x16, 0x01, 0x03, 0x02, "Easy" },
1445 {0x16, 0x01, 0x03, 0x01, "Normal" },
1446 {0x16, 0x01, 0x03, 0x00, "Hard" },
1447
1448 {0 , 0xfe, 0 , 2, "Score Digits" },
1449 {0x16, 0x01, 0x04, 0x04, "7" },
1450 {0x16, 0x01, 0x04, 0x00, "3" },
1451
1452 {0 , 0xfe, 0 , 2, "Lives" },
1453 {0x16, 0x01, 0x08, 0x08, "3" },
1454 {0x16, 0x01, 0x08, 0x00, "4" },
1455
1456 {0 , 0xfe, 0 , 2, "Display Score" },
1457 {0x16, 0x01, 0x10, 0x00, "Off" },
1458 {0x16, 0x01, 0x10, 0x10, "On" },
1459
1460 {0 , 0xfe, 0 , 2, "Erase Backup Ram" },
1461 {0x16, 0x01, 0x20, 0x00, "Off" },
1462 {0x16, 0x01, 0x20, 0x20, "On" },
1463
1464 {0 , 0xfe, 0 , 2, "Licensed To" },
1465 {0x16, 0x01, 0x40, 0x40, "Taito America" },
1466 {0x16, 0x01, 0x40, 0x00, "Taito" },
1467 };
1468
1469 STDDIPINFO(Calibr50)
1470
1471 static struct BurnDIPInfo TwineaglDIPList[]=
1472 {
1473 {0x13, 0xff, 0xff, 0xf7, NULL },
1474 {0x14, 0xff, 0xff, 0xf3, NULL },
1475 {0x15, 0xff, 0xff, 0xff, NULL },
1476
1477 {0 , 0xfe, 0 , 2, "Copyright" },
1478 {0x13, 0x01, 0x01, 0x01, "Taito" },
1479 {0x13, 0x01, 0x01, 0x00, "Taito America (Romstar license)" },
1480
1481 {0 , 0xfe, 0 , 2, "Flip Screen" },
1482 {0x13, 0x01, 0x02, 0x02, "Off" },
1483 {0x13, 0x01, 0x02, 0x00, "On" },
1484
1485 {0 , 0xfe, 0 , 2, "Service Mode" },
1486 {0x13, 0x01, 0x04, 0x04, "Off" },
1487 {0x13, 0x01, 0x04, 0x00, "On" },
1488
1489 {0 , 0xfe, 0 , 2, "Cabinet" },
1490 {0x13, 0x01, 0x08, 0x00, "Upright" },
1491 {0x13, 0x01, 0x08, 0x08, "Cocktail" },
1492
1493 {0 , 0xfe, 0 , 4, "Coin A" },
1494 {0x13, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1495 {0x13, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1496 {0x13, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1497 {0x13, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1498
1499 {0 , 0xfe, 0 , 4, "Coin B" },
1500 {0x13, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1501 {0x13, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1502 {0x13, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1503 {0x13, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1504
1505 {0 , 0xfe, 0 , 4, "Difficulty" },
1506 {0x14, 0x01, 0x03, 0x03, "Normal" },
1507 {0x14, 0x01, 0x03, 0x02, "Easy" },
1508 {0x14, 0x01, 0x03, 0x01, "Hard" },
1509 {0x14, 0x01, 0x03, 0x00, "Hardest" },
1510
1511 {0 , 0xfe, 0 , 4, "Bonus Life" },
1512 {0x14, 0x01, 0x0c, 0x0c, "Never" },
1513 {0x14, 0x01, 0x0c, 0x08, "500K Only" },
1514 {0x14, 0x01, 0x0c, 0x04, "1000K Only" },
1515 {0x14, 0x01, 0x0c, 0x00, "500K, Every 1500K" },
1516
1517 {0 , 0xfe, 0 , 4, "Lives" },
1518 {0x14, 0x01, 0x30, 0x10, "1" },
1519 {0x14, 0x01, 0x30, 0x00, "2" },
1520 {0x14, 0x01, 0x30, 0x30, "3" },
1521 {0x14, 0x01, 0x30, 0x20, "5" },
1522
1523 {0 , 0xfe, 0 , 2, "Copyright" },
1524 {0x14, 0x01, 0x40, 0x40, "Seta (Taito license)" },
1525 {0x14, 0x01, 0x40, 0x40, "Taito America" },
1526
1527 {0 , 0xfe, 0 , 2, "Coinage Type" },
1528 {0x14, 0x01, 0x80, 0x80, "1" },
1529 {0x14, 0x01, 0x80, 0x00, "2" },
1530 };
1531
1532 STDDIPINFO(Twineagl)
1533
1534 static struct BurnDIPInfo KiwameDIPList[]=
1535 {
1536 {0x19, 0xff, 0xff, 0xff, NULL },
1537 {0x1a, 0xff, 0xff, 0xff, NULL },
1538 {0x1b, 0xff, 0xff, 0xff, NULL },
1539
1540 {0 , 0xfe, 0 , 8, "Coin A" },
1541 {0x19, 0x01, 0x07, 0x01, "4 Coins 1 Credits" },
1542 {0x19, 0x01, 0x07, 0x02, "3 Coins 1 Credits" },
1543 {0x19, 0x01, 0x07, 0x04, "2 Coins 1 Credits" },
1544 {0x19, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
1545 {0x19, 0x01, 0x07, 0x03, "2 Coins 3 Credits" },
1546 {0x19, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
1547 {0x19, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
1548 {0x19, 0x01, 0x07, 0x00, "Free Play" },
1549
1550 {0 , 0xfe, 0 , 8, "Coin B" },
1551 {0x19, 0x01, 0x38, 0x08, "4 Coins 1 Credits" },
1552 {0x19, 0x01, 0x38, 0x10, "3 Coins 1 Credits" },
1553 {0x19, 0x01, 0x38, 0x20, "2 Coins 1 Credits" },
1554 {0x19, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
1555 {0x19, 0x01, 0x38, 0x18, "2 Coins 3 Credits" },
1556 {0x19, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
1557 {0x19, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
1558 {0x19, 0x01, 0x38, 0x00, "Free Play" },
1559
1560 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1561 {0x19, 0x01, 0x40, 0x00, "Off" },
1562 {0x19, 0x01, 0x40, 0x40, "On" },
1563
1564 {0 , 0xfe, 0 , 2, "Player's TSUMO" },
1565 {0x19, 0x01, 0x80, 0x80, "Manual" },
1566 {0x19, 0x01, 0x80, 0x00, "Auto" },
1567
1568 {0 , 0xfe, 0 , 2, "Flip Screen" },
1569 {0x1a, 0x01, 0x01, 0x01, "Off" },
1570 {0x1a, 0x01, 0x01, 0x00, "On" },
1571
1572 {0 , 0xfe, 0 , 2, "Service Mode" },
1573 {0x1a, 0x01, 0x02, 0x02, "Off" },
1574 {0x1a, 0x01, 0x02, 0x00, "On" },
1575
1576 {0 , 0xfe, 0 , 8, "Difficulty" },
1577 {0x1a, 0x01, 0x1c, 0x1c, "None" },
1578 {0x1a, 0x01, 0x1c, 0x18, "Prelim 1" },
1579 {0x1a, 0x01, 0x1c, 0x14, "Prelim 2" },
1580 {0x1a, 0x01, 0x1c, 0x10, "Final 1" },
1581 {0x1a, 0x01, 0x1c, 0x0c, "Final 2" },
1582 {0x1a, 0x01, 0x1c, 0x08, "Final 3" },
1583 {0x1a, 0x01, 0x1c, 0x04, "Qrt Final" },
1584 {0x1a, 0x01, 0x1c, 0x00, "SemiFinal" },
1585
1586 {0 , 0xfe, 0 , 8, "Points Gap" },
1587 {0x1a, 0x01, 0xe0, 0xe0, "None" },
1588 {0x1a, 0x01, 0xe0, 0xc0, "+6000" },
1589 {0x1a, 0x01, 0xe0, 0xa0, "+4000" },
1590 {0x1a, 0x01, 0xe0, 0x80, "+2000" },
1591 {0x1a, 0x01, 0xe0, 0x60, "-2000" },
1592 {0x1a, 0x01, 0xe0, 0x40, "-4000" },
1593 {0x1a, 0x01, 0xe0, 0x20, "-6000" },
1594 {0x1a, 0x01, 0xe0, 0x00, "-8000" },
1595 };
1596
1597 STDDIPINFO(Kiwame)
1598
1599 static struct BurnDIPInfo MetafoxDIPList[]=
1600 {
1601 {0x13, 0xff, 0xff, 0xff, NULL },
1602 {0x14, 0xff, 0xff, 0xb1, NULL },
1603 {0x15, 0xff, 0xff, 0xff, NULL },
1604
1605 {0 , 0xfe, 0 , 2, "Licensed To" },
1606 {0x13, 0x01, 0x01, 0x01, "Jordan" },
1607 {0x13, 0x01, 0x01, 0x00, "Taito America" },
1608
1609 {0 , 0xfe, 0 , 2, "Flip Screen" },
1610 {0x13, 0x01, 0x02, 0x02, "Off" },
1611 {0x13, 0x01, 0x02, 0x00, "On" },
1612
1613 {0 , 0xfe, 0 , 2, "Service Mode" },
1614 {0x13, 0x01, 0x04, 0x04, "Off" },
1615 {0x13, 0x01, 0x04, 0x00, "On" },
1616
1617 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1618 {0x13, 0x01, 0x08, 0x00, "Off" },
1619 {0x13, 0x01, 0x08, 0x08, "On" },
1620
1621 {0 , 0xfe, 0 , 4, "Coin A" },
1622 {0x13, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1623 {0x13, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1624 {0x13, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1625 {0x13, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1626
1627 {0 , 0xfe, 0 , 4, "Coin B" },
1628 {0x13, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1629 {0x13, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1630 {0x13, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1631 {0x13, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1632
1633 {0 , 0xfe, 0 , 4, "Difficulty" },
1634 {0x14, 0x01, 0x03, 0x03, "Normal" },
1635 {0x14, 0x01, 0x03, 0x02, "Easy" },
1636 {0x14, 0x01, 0x03, 0x01, "Hard" },
1637 {0x14, 0x01, 0x03, 0x00, "Hardest" },
1638
1639 {0 , 0xfe, 0 , 4, "Bonus Life" },
1640 {0x14, 0x01, 0x0c, 0x0c, "None" },
1641 {0x14, 0x01, 0x0c, 0x08, "60K Only" },
1642 {0x14, 0x01, 0x0c, 0x00, "60k & 90k" },
1643 {0x14, 0x01, 0x0c, 0x04, "90K Only" },
1644
1645 {0 , 0xfe, 0 , 4, "Lives" },
1646 {0x14, 0x01, 0x30, 0x10, "1" },
1647 {0x14, 0x01, 0x30, 0x00, "2" },
1648 {0x14, 0x01, 0x30, 0x30, "3" },
1649 {0x14, 0x01, 0x30, 0x20, "5" },
1650
1651 {0 , 0xfe, 0 , 2, "Licensed To" },
1652 {0x14, 0x01, 0x40, 0x40, "Romstar" },
1653 {0x14, 0x01, 0x40, 0x00, "Taito" },
1654
1655 {0 , 0xfe, 0 , 2, "Coinage Type" },
1656 {0x14, 0x01, 0x80, 0x80, "1" },
1657 {0x14, 0x01, 0x80, 0x00, "2" },
1658 };
1659
1660 STDDIPINFO(Metafox)
1661
1662 static struct BurnDIPInfo ArbalestDIPList[]=
1663 {
1664 {0x13, 0xff, 0xff, 0xff, NULL },
1665 {0x14, 0xff, 0xff, 0xbf, NULL },
1666 {0x15, 0xff, 0xff, 0xff, NULL },
1667
1668 {0 , 0xfe, 0 , 2, "Licensed To" },
1669 {0x13, 0x01, 0x01, 0x00, "Taito" },
1670 {0x13, 0x01, 0x01, 0x01, "Jordan" },
1671
1672 {0 , 0xfe, 0 , 2, "Flip Screen" },
1673 {0x13, 0x01, 0x02, 0x02, "Off" },
1674 {0x13, 0x01, 0x02, 0x00, "On" },
1675
1676 {0 , 0xfe, 0 , 2, "Service Mode" },
1677 {0x13, 0x01, 0x04, 0x04, "Off" },
1678 {0x13, 0x01, 0x04, 0x00, "On" },
1679
1680 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1681 {0x13, 0x01, 0x08, 0x00, "Off" },
1682 {0x13, 0x01, 0x08, 0x08, "On" },
1683
1684 {0 , 0xfe, 0 , 4, "Coin A" },
1685 {0x13, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1686 {0x13, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1687 {0x13, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1688 {0x13, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1689
1690 {0 , 0xfe, 0 , 4, "Coin B" },
1691 {0x13, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1692 {0x13, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1693 {0x13, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1694 {0x13, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1695
1696 {0 , 0xfe, 0 , 4, "Difficulty" },
1697 {0x14, 0x01, 0x03, 0x03, "Easy" },
1698 {0x14, 0x01, 0x03, 0x02, "Hard" },
1699 {0x14, 0x01, 0x03, 0x01, "Harder" },
1700 {0x14, 0x01, 0x03, 0x00, "Hardest" },
1701
1702 {0 , 0xfe, 0 , 4, "Bonus Life" },
1703 {0x14, 0x01, 0x0c, 0x0c, "Never" },
1704 {0x14, 0x01, 0x0c, 0x08, "300k Only" },
1705 {0x14, 0x01, 0x0c, 0x04, "600k Only" },
1706 {0x14, 0x01, 0x0c, 0x00, "300k & 600k" },
1707
1708 {0 , 0xfe, 0 , 4, "Lives" },
1709 {0x14, 0x01, 0x30, 0x10, "1" },
1710 {0x14, 0x01, 0x30, 0x00, "2" },
1711 {0x14, 0x01, 0x30, 0x30, "3" },
1712 {0x14, 0x01, 0x30, 0x20, "5" },
1713
1714 {0 , 0xfe, 0 , 1, "Licensed To" },
1715 {0x14, 0x01, 0x40, 0x40, "Romstar" },
1716
1717 {0 , 0xfe, 0 , 2, "Coinage Type" },
1718 {0x14, 0x01, 0x80, 0x80, "1" },
1719 {0x14, 0x01, 0x80, 0x00, "2" },
1720 };
1721
1722 STDDIPINFO(Arbalest)
1723
1724 static struct BurnDIPInfo DowntownDIPList[]=
1725 {
1726 {0x15, 0xff, 0xff, 0xf6, NULL },
1727 {0x16, 0xff, 0xff, 0xbd, NULL },
1728 {0x17, 0xff, 0xff, 0xff, NULL },
1729
1730 {0 , 0xfe, 0 , 2, "Sales" },
1731 {0x15, 0x01, 0x01, 0x01, "Japan Only" },
1732 {0x15, 0x01, 0x01, 0x00, "World" },
1733
1734 {0 , 0xfe, 0 , 2, "Flip Screen" },
1735 {0x15, 0x01, 0x02, 0x02, "Off" },
1736 {0x15, 0x01, 0x02, 0x00, "On" },
1737
1738 {0 , 0xfe, 0 , 2, "Service Mode" },
1739 {0x15, 0x01, 0x04, 0x04, "Off" },
1740 {0x15, 0x01, 0x04, 0x00, "On" },
1741
1742 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1743 {0x15, 0x01, 0x08, 0x08, "Off" },
1744 {0x15, 0x01, 0x08, 0x00, "On" },
1745
1746 {0 , 0xfe, 0 , 4, "Coin A" },
1747 {0x15, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1748 {0x15, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1749 {0x15, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1750 {0x15, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1751
1752 {0 , 0xfe, 0 , 4, "Coin B" },
1753 {0x15, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1754 {0x15, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1755 {0x15, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1756 {0x15, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1757
1758 {0 , 0xfe, 0 , 4, "Difficulty" },
1759 {0x16, 0x01, 0x03, 0x02, "Easy" },
1760 {0x16, 0x01, 0x03, 0x03, "Normal" },
1761 {0x16, 0x01, 0x03, 0x01, "Hard" },
1762 {0x16, 0x01, 0x03, 0x00, "Hardest" },
1763
1764 {0 , 0xfe, 0 , 4, "Bonus Life" },
1765 {0x16, 0x01, 0x0c, 0x0c, "Never" },
1766 {0x16, 0x01, 0x0c, 0x08, "50K Only" },
1767 {0x16, 0x01, 0x0c, 0x04, "100K Only" },
1768 {0x16, 0x01, 0x0c, 0x00, "50K, Every 150K" },
1769
1770 {0 , 0xfe, 0 , 4, "Lives" },
1771 {0x16, 0x01, 0x30, 0x10, "2" },
1772 {0x16, 0x01, 0x30, 0x30, "3" },
1773 {0x16, 0x01, 0x30, 0x00, "4" },
1774 {0x16, 0x01, 0x30, 0x20, "5" },
1775
1776 {0 , 0xfe, 0 , 2, "World License" },
1777 {0x16, 0x01, 0x40, 0x40, "Romstar" },
1778 {0x16, 0x01, 0x40, 0x00, "Taito" },
1779
1780 {0 , 0xfe, 0 , 2, "Coinage Type" },
1781 {0x16, 0x01, 0x80, 0x80, "1" },
1782 {0x16, 0x01, 0x80, 0x00, "2" },
1783 };
1784
1785 STDDIPINFO(Downtown)
1786
1787 static struct BurnDIPInfo TndrcadeDIPList[]=
1788 {
1789 {0x13, 0xff, 0xff, 0x7f, NULL },
1790 {0x14, 0xff, 0xff, 0xf7, NULL },
1791
1792 {0 , 0xfe, 0 , 4, "Difficulty" },
1793 {0x13, 0x01, 0x03, 0x02, "Easy" },
1794 {0x13, 0x01, 0x03, 0x03, "Normal" },
1795 {0x13, 0x01, 0x03, 0x01, "Hard" },
1796 {0x13, 0x01, 0x03, 0x00, "Hardest" },
1797
1798 {0 , 0xfe, 0 , 4, "Bonus Life" },
1799 {0x13, 0x01, 0x0c, 0x0c, "50K Only" },
1800 {0x13, 0x01, 0x0c, 0x04, "50K, Every 150K" },
1801 {0x13, 0x01, 0x0c, 0x00, "70K, Every 200K" },
1802 {0x13, 0x01, 0x0c, 0x08, "100K Only" },
1803
1804 {0 , 0xfe, 0 , 4, "Lives" },
1805 {0x13, 0x01, 0x30, 0x10, "1" },
1806 {0x13, 0x01, 0x30, 0x00, "2" },
1807 {0x13, 0x01, 0x30, 0x30, "3" },
1808 {0x13, 0x01, 0x30, 0x20, "5" },
1809
1810 {0 , 0xfe, 0 , 2, "Allow Continue" },
1811 {0x13, 0x01, 0x40, 0x00, "Off" },
1812 {0x13, 0x01, 0x40, 0x40, "On" },
1813
1814 {0 , 0xfe, 0 , 2, "Licensed To" },
1815 {0x13, 0x01, 0x80, 0x80, "Taito America Corp." },
1816 {0x13, 0x01, 0x80, 0x00, "Taito Corp. Japan" },
1817
1818 {0 , 0xfe, 0 , 2, "Title" },
1819 {0x14, 0x01, 0x01, 0x01, "Thundercade" },
1820 {0x14, 0x01, 0x01, 0x00, "Twin Formation" },
1821
1822 {0 , 0xfe, 0 , 2, "Flip Screen" },
1823 {0x14, 0x01, 0x02, 0x02, "Off" },
1824 {0x14, 0x01, 0x02, 0x00, "On" },
1825
1826 {0 , 0xfe, 0 , 2, "Service Mode" },
1827 {0x14, 0x01, 0x04, 0x04, "Off" },
1828 {0x14, 0x01, 0x04, 0x00, "On" },
1829
1830 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1831 {0x14, 0x01, 0x08, 0x08, "Off" },
1832 {0x14, 0x01, 0x08, 0x00, "On" },
1833
1834 {0 , 0xfe, 0 , 4, "Coin A" },
1835 {0x14, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1836 {0x14, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1837 {0x14, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1838 {0x14, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1839
1840 {0 , 0xfe, 0 , 4, "Coin B" },
1841 {0x14, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1842 {0x14, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1843 {0x14, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1844 {0x14, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1845 };
1846
1847 STDDIPINFO(Tndrcade)
1848
1849 static struct BurnDIPInfo TndrcadjDIPList[]=
1850 {
1851 {0x13, 0xff, 0xff, 0xff, NULL },
1852 {0x14, 0xff, 0xff, 0xf7, NULL },
1853
1854 {0 , 0xfe, 0 , 4, "Difficulty" },
1855 {0x13, 0x01, 0x03, 0x02, "Easy" },
1856 {0x13, 0x01, 0x03, 0x03, "Normal" },
1857 {0x13, 0x01, 0x03, 0x01, "Hard" },
1858 {0x13, 0x01, 0x03, 0x00, "Hardest" },
1859
1860 {0 , 0xfe, 0 , 4, "Bonus Life" },
1861 {0x13, 0x01, 0x0c, 0x0c, "50K Only" },
1862 {0x13, 0x01, 0x0c, 0x04, "50K, Every 150K" },
1863 {0x13, 0x01, 0x0c, 0x00, "70K, Every 200K" },
1864 {0x13, 0x01, 0x0c, 0x08, "100K Only" },
1865
1866 {0 , 0xfe, 0 , 4, "Lives" },
1867 {0x13, 0x01, 0x30, 0x10, "1" },
1868 {0x13, 0x01, 0x30, 0x00, "2" },
1869 {0x13, 0x01, 0x30, 0x30, "3" },
1870 {0x13, 0x01, 0x30, 0x20, "5" },
1871
1872 {0 , 0xfe, 0 , 2, "Allow Continue" },
1873 {0x13, 0x01, 0x40, 0x00, "Off" },
1874 {0x13, 0x01, 0x40, 0x40, "On" },
1875
1876 {0 , 0xfe, 0 , 2, "Free Play" },
1877 {0x13, 0x01, 0x80, 0x80, "Off" },
1878 {0x13, 0x01, 0x80, 0x00, "On" },
1879
1880 {0 , 0xfe, 0 , 2, "Invulnerability" },
1881 {0x14, 0x01, 0x01, 0x01, "Off" },
1882 {0x14, 0x01, 0x01, 0x00, "On" },
1883
1884 {0 , 0xfe, 0 , 2, "Flip Screen" },
1885 {0x14, 0x01, 0x02, 0x02, "Off" },
1886 {0x14, 0x01, 0x02, 0x00, "On" },
1887
1888 {0 , 0xfe, 0 , 2, "Service Mode" },
1889 {0x14, 0x01, 0x04, 0x04, "Off" },
1890 {0x14, 0x01, 0x04, 0x00, "On" },
1891
1892 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1893 {0x14, 0x01, 0x08, 0x08, "Off" },
1894 {0x14, 0x01, 0x08, 0x00, "On" },
1895
1896 {0 , 0xfe, 0 , 4, "Coin A" },
1897 {0x14, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
1898 {0x14, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
1899 {0x14, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1900 {0x14, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1901
1902 {0 , 0xfe, 0 , 4, "Coin B" },
1903 {0x14, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
1904 {0x14, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
1905 {0x14, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1906 {0x14, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1907 };
1908
1909 STDDIPINFO(Tndrcadj)
1910
1911 static struct BurnDIPInfo UtoukondDIPList[]=
1912 {
1913 {0x14, 0xff, 0xff, 0xff, NULL },
1914 {0x15, 0xff, 0xff, 0xff, NULL },
1915 {0x16, 0xff, 0xff, 0xff, NULL },
1916
1917 {0 , 0xfe, 0 , 16, "Coin A" },
1918 {0x14, 0x01, 0x0f, 0x02, "4 Coins 1 Credits" },
1919 {0x14, 0x01, 0x0f, 0x05, "3 Coins 1 Credits" },
1920 {0x14, 0x01, 0x0f, 0x08, "2 Coins 1 Credits" },
1921 {0x14, 0x01, 0x0f, 0x04, "3 Coins 2 Credits" },
1922 {0x14, 0x01, 0x0f, 0x01, "4 Coins 3 Credits" },
1923 {0x14, 0x01, 0x0f, 0x0f, "1 Coin 1 Credits" },
1924 {0x14, 0x01, 0x0f, 0x03, "3 Coins 4 Credits" },
1925 {0x14, 0x01, 0x0f, 0x07, "2 Coins 3 Credits" },
1926 {0x14, 0x01, 0x0f, 0x0e, "1 Coin 2 Credits" },
1927 {0x14, 0x01, 0x0f, 0x06, "2 Coins 5 Credits" },
1928 {0x14, 0x01, 0x0f, 0x0d, "1 Coin 3 Credits" },
1929 {0x14, 0x01, 0x0f, 0x0c, "1 Coin 4 Credits" },
1930 {0x14, 0x01, 0x0f, 0x0b, "1 Coin 5 Credits" },
1931 {0x14, 0x01, 0x0f, 0x0a, "1 Coin 6 Credits" },
1932 {0x14, 0x01, 0x0f, 0x09, "1 Coin 7 Credits" },
1933 {0x14, 0x01, 0x0f, 0x00, "Free Play" },
1934
1935 {0 , 0xfe, 0 , 16, "Coin B" },
1936 {0x14, 0x01, 0xf0, 0x20, "4 Coins 1 Credits" },
1937 {0x14, 0x01, 0xf0, 0x50, "3 Coins 1 Credits" },
1938 {0x14, 0x01, 0xf0, 0x80, "2 Coins 1 Credits" },
1939 {0x14, 0x01, 0xf0, 0x00, "5 Coins 3 Credits" },
1940 {0x14, 0x01, 0xf0, 0x40, "3 Coins 2 Credits" },
1941 {0x14, 0x01, 0xf0, 0x10, "4 Coins 3 Credits" },
1942 {0x14, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
1943 {0x14, 0x01, 0xf0, 0x30, "3 Coins 4 Credits" },
1944 {0x14, 0x01, 0xf0, 0x70, "2 Coins 3 Credits" },
1945 {0x14, 0x01, 0xf0, 0xe0, "1 Coin 2 Credits" },
1946 {0x14, 0x01, 0xf0, 0x60, "2 Coins 5 Credits" },
1947 {0x14, 0x01, 0xf0, 0xd0, "1 Coin 3 Credits" },
1948 {0x14, 0x01, 0xf0, 0xc0, "1 Coin 4 Credits" },
1949 {0x14, 0x01, 0xf0, 0xb0, "1 Coin 5 Credits" },
1950 {0x14, 0x01, 0xf0, 0xa0, "1 Coin 6 Credits" },
1951 {0x14, 0x01, 0xf0, 0x90, "1 Coin 7 Credits" },
1952
1953 {0 , 0xfe, 0 , 4, "Lives" },
1954 {0x15, 0x01, 0x03, 0x00, "1" },
1955 {0x15, 0x01, 0x03, 0x02, "2" },
1956 {0x15, 0x01, 0x03, 0x03, "3" },
1957 {0x15, 0x01, 0x03, 0x01, "4" },
1958
1959 {0 , 0xfe, 0 , 4, "Difficulty" },
1960 {0x15, 0x01, 0x0c, 0x08, "Easy" },
1961 {0x15, 0x01, 0x0c, 0x0c, "Normal" },
1962 {0x15, 0x01, 0x0c, 0x04, "Hard" },
1963 {0x15, 0x01, 0x0c, 0x00, "Hardest" },
1964
1965 {0 , 0xfe, 0 , 2, "Flip Screen" },
1966 {0x15, 0x01, 0x10, 0x10, "Off" },
1967 {0x15, 0x01, 0x10, 0x00, "On" },
1968
1969 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1970 {0x15, 0x01, 0x20, 0x00, "Off" },
1971 {0x15, 0x01, 0x20, 0x20, "On" },
1972
1973 {0 , 0xfe, 0 , 2, "Bonus Life" },
1974 {0x15, 0x01, 0x40, 0x40, "100k" },
1975 {0x15, 0x01, 0x40, 0x00, "150k" },
1976
1977 {0 , 0xfe, 0 , 2, "Service Mode" },
1978 {0x15, 0x01, 0x80, 0x80, "Off" },
1979 {0x15, 0x01, 0x80, 0x00, "On" },
1980 };
1981
1982 STDDIPINFO(Utoukond)
1983
1984 static struct BurnDIPInfo KrzybowlDIPList[]=
1985 {
1986 {0x18, 0xff, 0xff, 0xff, NULL },
1987 {0x19, 0xff, 0xff, 0xff, NULL },
1988 {0x1a, 0xff, 0xff, 0xff, NULL },
1989
1990 {0 , 0xfe, 0 , 2, "Flip Screen" },
1991 {0x18, 0x01, 0x01, 0x01, "Off" },
1992 {0x18, 0x01, 0x01, 0x00, "On" },
1993
1994 {0 , 0xfe, 0 , 2, "Demo Sounds" },
1995 {0x18, 0x01, 0x02, 0x00, "Off" },
1996 {0x18, 0x01, 0x02, 0x02, "On" },
1997
1998 {0 , 0xfe, 0 , 4, "Difficulty" },
1999 {0x18, 0x01, 0x0c, 0x08, "Easy" },
2000 {0x18, 0x01, 0x0c, 0x0c, "Normal" },
2001 {0x18, 0x01, 0x0c, 0x04, "Hard" },
2002 {0x18, 0x01, 0x0c, 0x00, "Hardest" },
2003
2004 {0 , 0xfe, 0 , 2, "Frames" },
2005 {0x18, 0x01, 0x10, 0x10, "10" },
2006 {0x18, 0x01, 0x10, 0x00, "5" },
2007
2008 {0 , 0xfe, 0 , 2, "Cabinet" },
2009 {0x18, 0x01, 0x20, 0x20, "Upright" },
2010 {0x18, 0x01, 0x20, 0x00, "Cocktail" },
2011
2012 {0 , 0xfe, 0 , 2, "Controls" },
2013 {0x18, 0x01, 0x40, 0x40, "Trackball" },
2014 {0x18, 0x01, 0x40, 0x00, "Joystick" },
2015
2016 {0 , 0xfe, 0 , 2, "Service Mode" },
2017 {0x18, 0x01, 0x80, 0x80, "Off" },
2018 {0x18, 0x01, 0x80, 0x00, "On" },
2019
2020 {0 , 0xfe, 0 , 8, "Coin A" },
2021 {0x19, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
2022 {0x19, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
2023 {0x19, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2024 {0x19, 0x01, 0x07, 0x04, "1 Coin 2 Credits" },
2025 {0x19, 0x01, 0x07, 0x03, "1 Coin 3 Credits" },
2026 {0x19, 0x01, 0x07, 0x02, "1 Coin 4 Credits" },
2027 {0x19, 0x01, 0x07, 0x01, "1 Coin 5 Credits" },
2028 {0x19, 0x01, 0x07, 0x00, "1 Coin 6 Credits" },
2029
2030 {0 , 0xfe, 0 , 8, "Coin B" },
2031 {0x19, 0x01, 0x38, 0x28, "3 Coins 1 Credits" },
2032 {0x19, 0x01, 0x38, 0x30, "2 Coins 1 Credits" },
2033 {0x19, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2034 {0x19, 0x01, 0x38, 0x20, "1 Coin 2 Credits" },
2035 {0x19, 0x01, 0x38, 0x18, "1 Coin 3 Credits" },
2036 {0x19, 0x01, 0x38, 0x10, "1 Coin 4 Credits" },
2037 {0x19, 0x01, 0x38, 0x08, "1 Coin 5 Credits" },
2038 {0x19, 0x01, 0x38, 0x00, "1 Coin 6 Credits" },
2039
2040 {0 , 0xfe, 0 , 2, "Force Coinage" },
2041 {0x19, 0x01, 0x40, 0x40, "No" },
2042 {0x19, 0x01, 0x40, 0x00, "2 Coins 1 Credits" },
2043 };
2044
2045 STDDIPINFO(Krzybowl)
2046
2047 static struct BurnDIPInfo ExtdwnhlDIPList[]=
2048 {
2049 {0x0c, 0xff, 0xff, 0xff, NULL },
2050 {0x0d, 0xff, 0xff, 0xff, NULL },
2051 {0x0e, 0xff, 0xff, 0xff, NULL },
2052
2053 {0 , 0xfe, 0 , 2, "Flip Screen" },
2054 {0x0c, 0x01, 0x01, 0x01, "Off" },
2055 {0x0c, 0x01, 0x01, 0x00, "On" },
2056
2057 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2058 {0x0c, 0x01, 0x02, 0x00, "Off" },
2059 {0x0c, 0x01, 0x02, 0x02, "On" },
2060
2061 {0 , 0xfe, 0 , 4, "Difficulty" },
2062 {0x0c, 0x01, 0x0c, 0x08, "Easy" },
2063 {0x0c, 0x01, 0x0c, 0x0c, "Normal" },
2064 {0x0c, 0x01, 0x0c, 0x04, "Hard" },
2065 {0x0c, 0x01, 0x0c, 0x00, "Hardest" },
2066
2067 {0 , 0xfe, 0 , 2, "Free Play" },
2068 {0x0c, 0x01, 0x10, 0x10, "Off" },
2069 {0x0c, 0x01, 0x10, 0x00, "On" },
2070
2071 {0 , 0xfe, 0 , 2, "Cabinet" },
2072 {0x0c, 0x01, 0x20, 0x20, "Upright" },
2073 {0x0c, 0x01, 0x20, 0x00, "Cocktail" },
2074
2075 {0 , 0xfe, 0 , 2, "Controls" },
2076 {0x0c, 0x01, 0x40, 0x40, "2" },
2077 {0x0c, 0x01, 0x40, 0x00, "1" },
2078
2079 {0 , 0xfe, 0 , 2, "Service Mode" },
2080 {0x0c, 0x01, 0x80, 0x80, "Off" },
2081 {0x0c, 0x01, 0x80, 0x00, "On" },
2082
2083 {0 , 0xfe, 0 , 8, "Coin A" },
2084 {0x0d, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
2085 {0x0d, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
2086 {0x0d, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2087 {0x0d, 0x01, 0x07, 0x04, "1 Coin 2 Credits" },
2088 {0x0d, 0x01, 0x07, 0x03, "1 Coin 3 Credits" },
2089 {0x0d, 0x01, 0x07, 0x02, "1 Coin 4 Credits" },
2090 {0x0d, 0x01, 0x07, 0x01, "1 Coin 5 Credits" },
2091 {0x0d, 0x01, 0x07, 0x00, "1 Coin 6 Credits" },
2092
2093 {0 , 0xfe, 0 , 8, "Coin B" },
2094 {0x0d, 0x01, 0x38, 0x28, "3 Coins 1 Credits" },
2095 {0x0d, 0x01, 0x38, 0x30, "2 Coins 1 Credits" },
2096 {0x0d, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2097 {0x0d, 0x01, 0x38, 0x20, "1 Coin 2 Credits" },
2098 {0x0d, 0x01, 0x38, 0x18, "1 Coin 3 Credits" },
2099 {0x0d, 0x01, 0x38, 0x10, "1 Coin 4 Credits" },
2100 {0x0d, 0x01, 0x38, 0x08, "1 Coin 5 Credits" },
2101 {0x0d, 0x01, 0x38, 0x00, "1 Coin 6 Credits" },
2102
2103 {0 , 0xfe, 0 , 2, "Continue Coin" },
2104 {0x0d, 0x01, 0x40, 0x40, "Normal: Start 1C / Continue 1C" },
2105 {0x0d, 0x01, 0x40, 0x00, "Half Continue: Start 2C / Continue 1C" },
2106
2107 {0 , 0xfe, 0 , 2, "Game Mode" },
2108 {0x0d, 0x01, 0x80, 0x80, "Finals Only" },
2109 {0x0d, 0x01, 0x80, 0x00, "Semi-Finals & Finals" },
2110
2111 {0 , 0xfe, 0 , 2, "Service Mode (No Toggle)" },
2112 {0x0e, 0x01, 0x08, 0x08, "Off" },
2113 {0x0e, 0x01, 0x08, 0x00, "On" },
2114
2115 {0 , 0xfe, 0 , 3, "Country" },
2116 {0x0e, 0x01, 0x30, 0x30, "World" },
2117 {0x0e, 0x01, 0x30, 0x10, "USA" },
2118 {0x0e, 0x01, 0x30, 0x00, "Japan" },
2119 };
2120
2121 STDDIPINFO(Extdwnhl)
2122
2123 static struct BurnDIPInfo SokonukeDIPList[]=
2124 {
2125 {0x10, 0xff, 0xff, 0xff, NULL },
2126 {0x11, 0xff, 0xff, 0xff, NULL },
2127 {0x12, 0xff, 0xff, 0xff, NULL },
2128
2129 {0 , 0xfe, 0 , 2, "Flip Screen" },
2130 {0x10, 0x01, 0x01, 0x01, "Off" },
2131 {0x10, 0x01, 0x01, 0x00, "On" },
2132
2133 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2134 {0x10, 0x01, 0x02, 0x00, "Off" },
2135 {0x10, 0x01, 0x02, 0x02, "On" },
2136
2137 {0 , 0xfe, 0 , 4, "Difficulty" },
2138 {0x10, 0x01, 0x0c, 0x08, "Easy" },
2139 {0x10, 0x01, 0x0c, 0x0c, "Normal" },
2140 {0x10, 0x01, 0x0c, 0x04, "Hard" },
2141 {0x10, 0x01, 0x0c, 0x00, "Hardest" },
2142
2143 {0 , 0xfe, 0 , 2, "Free Play" },
2144 {0x10, 0x01, 0x10, 0x10, "Off" },
2145 {0x10, 0x01, 0x10, 0x00, "On" },
2146
2147 {0 , 0xfe, 0 , 2, "Service Mode" },
2148 {0x10, 0x01, 0x80, 0x80, "Off" },
2149 {0x10, 0x01, 0x80, 0x00, "On" },
2150
2151 {0 , 0xfe, 0 , 8, "Coin A" },
2152 {0x11, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
2153 {0x11, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
2154 {0x11, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2155 {0x11, 0x01, 0x07, 0x04, "1 Coin 2 Credits" },
2156 {0x11, 0x01, 0x07, 0x03, "1 Coin 3 Credits" },
2157 {0x11, 0x01, 0x07, 0x02, "1 Coin 4 Credits" },
2158 {0x11, 0x01, 0x07, 0x01, "1 Coin 5 Credits" },
2159 {0x11, 0x01, 0x07, 0x00, "1 Coin 6 Credits" },
2160
2161 {0 , 0xfe, 0 , 8, "Coin B" },
2162 {0x11, 0x01, 0x38, 0x28, "3 Coins 1 Credits" },
2163 {0x11, 0x01, 0x38, 0x30, "2 Coins 1 Credits" },
2164 {0x11, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2165 {0x11, 0x01, 0x38, 0x20, "1 Coin 2 Credits" },
2166 {0x11, 0x01, 0x38, 0x18, "1 Coin 3 Credits" },
2167 {0x11, 0x01, 0x38, 0x10, "1 Coin 4 Credits" },
2168 {0x11, 0x01, 0x38, 0x08, "1 Coin 5 Credits" },
2169 {0x11, 0x01, 0x38, 0x00, "1 Coin 6 Credits" },
2170
2171 {0 , 0xfe, 0 , 2, "Cheap Continue" },
2172 {0x11, 0x01, 0x40, 0x40, "No" },
2173 {0x11, 0x01, 0x40, 0x00, "Yes" },
2174
2175 {0 , 0xfe, 0 , 2, "Service Mode" },
2176 {0x12, 0x01, 0x08, 0x08, "Off" },
2177 {0x12, 0x01, 0x08, 0x00, "On" },
2178 };
2179
2180 STDDIPINFO(Sokonuke)
2181
2182 static struct BurnDIPInfo JjsquawkDIPList[]=
2183 {
2184 {0x12, 0xff, 0xff, 0xbf, NULL },
2185 {0x13, 0xff, 0xff, 0xef, NULL },
2186 {0x14, 0xff, 0xff, 0xff, NULL },
2187
2188 {0 , 0xfe, 0 , 8, "Coin A" },
2189 {0x12, 0x01, 0x07, 0x01, "4 Coins 1 Credits" },
2190 {0x12, 0x01, 0x07, 0x02, "3 Coins 1 Credits" },
2191 {0x12, 0x01, 0x07, 0x04, "2 Coins 1 Credits" },
2192 {0x12, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2193 {0x12, 0x01, 0x07, 0x03, "2 Coins 3 Credits" },
2194 {0x12, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
2195 {0x12, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
2196 {0x12, 0x01, 0x07, 0x00, "Free Play" },
2197
2198 {0 , 0xfe, 0 , 8, "Coin B" },
2199 {0x12, 0x01, 0x38, 0x08, "4 Coins 1 Credits" },
2200 {0x12, 0x01, 0x38, 0x10, "3 Coins 1 Credits" },
2201 {0x12, 0x01, 0x38, 0x20, "2 Coins 1 Credits" },
2202 {0x12, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2203 {0x12, 0x01, 0x38, 0x18, "2 Coins 3 Credits" },
2204 {0x12, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
2205 {0x12, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
2206 {0x12, 0x01, 0x38, 0x00, "Free Play" },
2207
2208 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2209 {0x12, 0x01, 0x40, 0x40, "Off" },
2210 {0x12, 0x01, 0x40, 0x00, "On" },
2211
2212 {0 , 0xfe, 0 , 2, "Flip Screen" },
2213 {0x13, 0x01, 0x01, 0x01, "Off" },
2214 {0x13, 0x01, 0x01, 0x00, "On" },
2215
2216 {0 , 0xfe, 0 , 2, "Service Mode" },
2217 {0x13, 0x01, 0x02, 0x02, "Off" },
2218 {0x13, 0x01, 0x02, 0x00, "On" },
2219
2220 {0 , 0xfe, 0 , 4, "Difficulty" },
2221 {0x13, 0x01, 0x0c, 0x08, "Easy" },
2222 {0x13, 0x01, 0x0c, 0x0c, "Normal" },
2223 {0x13, 0x01, 0x0c, 0x04, "Hard" },
2224 {0x13, 0x01, 0x0c, 0x00, "Hardest" },
2225
2226 {0 , 0xfe, 0 , 4, "Energy" },
2227 {0x13, 0x01, 0x30, 0x20, "2" },
2228 {0x13, 0x01, 0x30, 0x30, "3" },
2229 {0x13, 0x01, 0x30, 0x10, "4" },
2230 {0x13, 0x01, 0x30, 0x00, "5" },
2231
2232 {0 , 0xfe, 0 , 4, "Bonus Life" },
2233 {0x13, 0x01, 0xc0, 0x80, "20K, Every 100K" },
2234 {0x13, 0x01, 0xc0, 0xc0, "50K, Every 200K" },
2235 {0x13, 0x01, 0xc0, 0x40, "70K, 200K Only" },
2236 {0x13, 0x01, 0xc0, 0x00, "100K Only" },
2237 };
2238
2239 STDDIPINFO(Jjsquawk)
2240
2241 static struct BurnDIPInfo KeroppiDIPList[]=
2242 {
2243 {0x04, 0xff, 0xff, 0xff, NULL },
2244 {0x05, 0xff, 0xff, 0xbf, NULL },
2245 {0x06, 0xff, 0xff, 0xff, NULL },
2246
2247 {0 , 0xfe, 0 , 8, "Difficulty" },
2248 {0x04, 0x01, 0x07, 0x03, "1" },
2249 {0x04, 0x01, 0x07, 0x05, "2" },
2250 {0x04, 0x01, 0x07, 0x01, "3" },
2251 {0x04, 0x01, 0x07, 0x07, "4" },
2252 {0x04, 0x01, 0x07, 0x06, "5" },
2253 {0x04, 0x01, 0x07, 0x02, "6" },
2254 {0x04, 0x01, 0x07, 0x04, "7" },
2255 {0x04, 0x01, 0x07, 0x00, "8" },
2256
2257 {0 , 0xfe, 0 , 8, "Game Select" },
2258 {0x04, 0x01, 0x38, 0x38, "No. 1,2,3" },
2259 {0x04, 0x01, 0x38, 0x30, "No. 1" },
2260 {0x04, 0x01, 0x38, 0x28, "No. 2,3" },
2261 {0x04, 0x01, 0x38, 0x20, "No. 3" },
2262 {0x04, 0x01, 0x38, 0x18, "No. 1,2" },
2263 {0x04, 0x01, 0x38, 0x10, "No. 2" },
2264 {0x04, 0x01, 0x38, 0x08, "No. 1,3" },
2265 {0x04, 0x01, 0x38, 0x00, "No. 1,2,3" },
2266
2267 {0 , 0xfe, 0 , 8, "Coin A" },
2268 {0x05, 0x01, 0x07, 0x00, "5 Coins 1 Credits" },
2269 {0x05, 0x01, 0x07, 0x04, "4 Coins 1 Credits" },
2270 {0x05, 0x01, 0x07, 0x02, "3 Coins 1 Credits" },
2271 {0x05, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
2272 {0x05, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2273 {0x05, 0x01, 0x07, 0x03, "1 Coin 2 Credits" },
2274 {0x05, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
2275 {0x05, 0x01, 0x07, 0x01, "1 Coin 4 Credits" },
2276
2277 {0 , 0xfe, 0 , 2, "Free Play" },
2278 {0x05, 0x01, 0x20, 0x20, "Off" },
2279 {0x05, 0x01, 0x20, 0x00, "On" },
2280
2281 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2282 {0x05, 0x01, 0x40, 0x40, "Off" },
2283 {0x05, 0x01, 0x40, 0x00, "On" },
2284
2285 {0 , 0xfe, 0 , 2, "Service Mode" },
2286 {0x05, 0x01, 0x80, 0x80, "Off" },
2287 {0x05, 0x01, 0x80, 0x00, "On" },
2288 };
2289
2290 STDDIPINFO(Keroppi)
2291
2292 static struct BurnDIPInfo OrbsDIPList[]=
2293 {
2294 {0x10, 0xff, 0xff, 0xff, NULL },
2295 {0x11, 0xff, 0xff, 0xff, NULL },
2296 {0x12, 0xff, 0xff, 0xff, NULL },
2297
2298 {0 , 0xfe, 0 , 2, "Flip Screen" },
2299 {0x10, 0x01, 0x01, 0x01, "Off" },
2300 {0x10, 0x01, 0x01, 0x00, "On" },
2301
2302 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2303 {0x10, 0x01, 0x02, 0x00, "Off" },
2304 {0x10, 0x01, 0x02, 0x02, "On" },
2305
2306 {0 , 0xfe, 0 , 4, "Difficulty" },
2307 {0x10, 0x01, 0x0c, 0x08, "Easy" },
2308 {0x10, 0x01, 0x0c, 0x0c, "Normal" },
2309 {0x10, 0x01, 0x0c, 0x04, "Hard" },
2310 {0x10, 0x01, 0x0c, 0x00, "Hardest" },
2311
2312 {0 , 0xfe, 0 , 2, "Stock" },
2313 {0x10, 0x01, 0x10, 0x10, "1" },
2314 {0x10, 0x01, 0x10, 0x00, "2" },
2315
2316 {0 , 0xfe, 0 , 2, "Level Select" },
2317 {0x10, 0x01, 0x20, 0x20, "Off" },
2318 {0x10, 0x01, 0x20, 0x00, "On" },
2319
2320 {0 , 0xfe, 0 , 2, "Timer speed" },
2321 {0x10, 0x01, 0x40, 0x40, "Normal" },
2322 {0x10, 0x01, 0x40, 0x00, "Fast" },
2323
2324 {0 , 0xfe, 0 , 2, "Service Mode" },
2325 {0x10, 0x01, 0x80, 0x80, "Off" },
2326 {0x10, 0x01, 0x80, 0x00, "On" },
2327
2328 {0 , 0xfe, 0 , 8, "Coin A" },
2329 {0x11, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
2330 {0x11, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
2331 {0x11, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2332 {0x11, 0x01, 0x07, 0x04, "1 Coin 2 Credits" },
2333 {0x11, 0x01, 0x07, 0x03, "1 Coin 3 Credits" },
2334 {0x11, 0x01, 0x07, 0x02, "1 Coin 4 Credits" },
2335 {0x11, 0x01, 0x07, 0x01, "1 Coin 5 Credits" },
2336 {0x11, 0x01, 0x07, 0x00, "1 Coin 6 Credits" },
2337
2338 {0 , 0xfe, 0 , 8, "Coin B" },
2339 {0x11, 0x01, 0x38, 0x28, "3 Coins 1 Credits" },
2340 {0x11, 0x01, 0x38, 0x30, "2 Coins 1 Credits" },
2341 {0x11, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2342 {0x11, 0x01, 0x38, 0x20, "1 Coin 2 Credits" },
2343 {0x11, 0x01, 0x38, 0x18, "1 Coin 3 Credits" },
2344 {0x11, 0x01, 0x38, 0x10, "1 Coin 4 Credits" },
2345 {0x11, 0x01, 0x38, 0x08, "1 Coin 5 Credits" },
2346 {0x11, 0x01, 0x38, 0x00, "1 Coin 6 Credits" },
2347
2348 {0 , 0xfe, 0 , 2, "Force Coinage (Half)" },
2349 {0x11, 0x01, 0x40, 0x40, "No" },
2350 {0x11, 0x01, 0x40, 0x00, "2 Coins 1 Credits" },
2351 };
2352
2353 STDDIPINFO(Orbs)
2354
2355 static struct BurnDIPInfo PairloveDIPList[]=
2356 {
2357 {0x13, 0xff, 0xff, 0xfd, NULL },
2358 {0x14, 0xff, 0xff, 0xff, NULL },
2359 {0x15, 0xff, 0xff, 0xff, NULL },
2360
2361 {0 , 0xfe, 0 , 2, "Flip Screen" },
2362 {0x13, 0x01, 0x01, 0x01, "Off" },
2363 {0x13, 0x01, 0x01, 0x00, "On" },
2364
2365 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2366 {0x13, 0x01, 0x02, 0x02, "Off" },
2367 {0x13, 0x01, 0x02, 0x00, "On" },
2368
2369 {0 , 0xfe, 0 , 2, "Service Mode" },
2370 {0x13, 0x01, 0x80, 0x80, "Off" },
2371 {0x13, 0x01, 0x80, 0x00, "On" },
2372
2373 {0 , 0xfe, 0 , 4, "Difficulty" },
2374 {0x14, 0x01, 0x0c, 0x08, "Easy" },
2375 {0x14, 0x01, 0x0c, 0x0c, "Normal" },
2376 {0x14, 0x01, 0x0c, 0x04, "Hard" },
2377 {0x14, 0x01, 0x0c, 0x00, "Hardest" },
2378
2379 {0 , 0xfe, 0 , 16, "Coinage" },
2380 {0x14, 0x01, 0xf0, 0xa0, "6 Coins 1 Credits" },
2381 {0x14, 0x01, 0xf0, 0xb0, "5 Coins 1 Credits" },
2382 {0x14, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
2383 {0x14, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
2384 {0x14, 0x01, 0xf0, 0x10, "8 Coins 3 Credits" },
2385 {0x14, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
2386 {0x14, 0x01, 0xf0, 0x20, "5 Coins 3 Credits" },
2387 {0x14, 0x01, 0xf0, 0x30, "3 Coins 2 Credits" },
2388 {0x14, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
2389 {0x14, 0x01, 0xf0, 0x40, "2 Coins 3 Credits" },
2390 {0x14, 0x01, 0xf0, 0x90, "1 Coin 2 Credits" },
2391 {0x14, 0x01, 0xf0, 0x80, "1 Coin 3 Credits" },
2392 {0x14, 0x01, 0xf0, 0x70, "1 Coin 4 Credits" },
2393 {0x14, 0x01, 0xf0, 0x60, "1 Coin 5 Credits" },
2394 {0x14, 0x01, 0xf0, 0x50, "1 Coin 6 Credits" },
2395 {0x14, 0x01, 0xf0, 0x00, "Free Play" },
2396 };
2397
2398 STDDIPINFO(Pairlove)
2399
2400 static struct BurnDIPInfo OisipuzlDIPList[]=
2401 {
2402 {0x12, 0xff, 0xff, 0xfb, NULL },
2403 {0x13, 0xff, 0xff, 0xff, NULL },
2404 {0x14, 0xff, 0xff, 0xff, NULL },
2405
2406 {0 , 0xfe, 0 , 4, "Difficulty" },
2407 {0x12, 0x01, 0x03, 0x02, "Easy" },
2408 {0x12, 0x01, 0x03, 0x03, "Normal" },
2409 {0x12, 0x01, 0x03, 0x01, "Hard" },
2410 {0x12, 0x01, 0x03, 0x00, "Hardest" },
2411
2412 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2413 {0x12, 0x01, 0x04, 0x04, "Off" },
2414 {0x12, 0x01, 0x04, 0x00, "On" },
2415
2416 {0 , 0xfe, 0 , 2, "Service Mode" },
2417 {0x12, 0x01, 0x80, 0x80, "Off" },
2418 {0x12, 0x01, 0x80, 0x00, "On" },
2419
2420 {0 , 0xfe, 0 , 8, "Coin A" },
2421 {0x13, 0x01, 0x07, 0x00, "5 Coins 1 Credits" },
2422 {0x13, 0x01, 0x07, 0x01, "4 Coins 1 Credits" },
2423 {0x13, 0x01, 0x07, 0x02, "3 Coins 1 Credits" },
2424 {0x13, 0x01, 0x07, 0x03, "2 Coins 1 Credits" },
2425 {0x13, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2426 {0x13, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
2427 {0x13, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
2428 {0x13, 0x01, 0x07, 0x04, "1 Coin 4 Credits" },
2429
2430 {0 , 0xfe, 0 , 8, "Coin B" },
2431 {0x13, 0x01, 0x38, 0x00, "5 Coins 1 Credits" },
2432 {0x13, 0x01, 0x38, 0x08, "4 Coins 1 Credits" },
2433 {0x13, 0x01, 0x38, 0x10, "3 Coins 1 Credits" },
2434 {0x13, 0x01, 0x38, 0x18, "2 Coins 1 Credits" },
2435 {0x13, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2436 {0x13, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
2437 {0x13, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
2438 {0x13, 0x01, 0x38, 0x20, "1 Coin 4 Credits" },
2439 };
2440
2441 STDDIPINFO(Oisipuzl)
2442
2443 static struct BurnDIPInfo BlandiaDIPList[]=
2444 {
2445 {0x15, 0xff, 0xff, 0xff, NULL },
2446 {0x16, 0xff, 0xff, 0xff, NULL },
2447 {0x17, 0xff, 0xff, 0xff, NULL },
2448
2449 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2450 {0x15, 0x01, 0x01, 0x00, "Off" },
2451 {0x15, 0x01, 0x01, 0x01, "On" },
2452
2453 {0 , 0xfe, 0 , 2, "Coinage Type" },
2454 {0x15, 0x01, 0x02, 0x02, "1" },
2455 {0x15, 0x01, 0x02, 0x00, "2" },
2456
2457 {0 , 0xfe, 0 , 8, "Coin A" },
2458 {0x15, 0x01, 0x1c, 0x10, "3 Coins 1 Credits" },
2459 {0x15, 0x01, 0x1c, 0x0c, "2 Coins 1 Credits" },
2460 {0x15, 0x01, 0x1c, 0x1c, "1 Coin 1 Credits" },
2461 {0x15, 0x01, 0x1c, 0x04, "2 Coins 3 Credits" },
2462 {0x15, 0x01, 0x1c, 0x18, "1 Coin 2 Credits" },
2463 {0x15, 0x01, 0x1c, 0x08, "2 Coins 5 Credits" },
2464 {0x15, 0x01, 0x1c, 0x14, "1 Coin 3 Credits" },
2465 {0x15, 0x01, 0x1c, 0x00, "Free Play" },
2466
2467 {0 , 0xfe, 0 , 8, "Coin B" },
2468 {0x15, 0x01, 0xe0, 0xe0, "1 Coin 1 Credits" },
2469 {0x15, 0x01, 0xe0, 0x60, "2 Coins 4 Credits" },
2470 {0x15, 0x01, 0xe0, 0xc0, "1 Coin 2 Credits" },
2471 {0x15, 0x01, 0xe0, 0x80, "3 Coins/7 Credits" },
2472 {0x15, 0x01, 0xe0, 0x20, "2 Coins 5 Credits" },
2473 {0x15, 0x01, 0xe0, 0x40, "2 Coins 6 Credits" },
2474 {0x15, 0x01, 0xe0, 0xa0, "1 Coin 3 Credits" },
2475 {0x15, 0x01, 0xe0, 0x00, "Free Play" },
2476
2477 {0 , 0xfe, 0 , 4, "Lives" },
2478 {0x16, 0x01, 0x03, 0x02, "1" },
2479 {0x16, 0x01, 0x03, 0x03, "2" },
2480 {0x16, 0x01, 0x03, 0x01, "3" },
2481 {0x16, 0x01, 0x03, 0x00, "4" },
2482
2483 {0 , 0xfe, 0 , 4, "Difficulty" },
2484 {0x16, 0x01, 0x0c, 0x08, "Easy" },
2485 {0x16, 0x01, 0x0c, 0x0c, "Normal" },
2486 {0x16, 0x01, 0x0c, 0x04, "Hard" },
2487 {0x16, 0x01, 0x0c, 0x00, "Hardest" },
2488
2489 {0 , 0xfe, 0 , 2, "2 Player Game" },
2490 {0x16, 0x01, 0x10, 0x10, "2 Credits" },
2491 {0x16, 0x01, 0x10, 0x00, "1 Credit" },
2492
2493 {0 , 0xfe, 0 , 2, "Continue" },
2494 {0x16, 0x01, 0x20, 0x20, "1 Credit" },
2495 {0x16, 0x01, 0x20, 0x00, "1 Coin" },
2496
2497 {0 , 0xfe, 0 , 2, "Flip Screen" },
2498 {0x16, 0x01, 0x40, 0x40, "Off" },
2499 {0x16, 0x01, 0x40, 0x00, "On" },
2500
2501 {0 , 0xfe, 0 , 2, "Service Mode" },
2502 {0x16, 0x01, 0x80, 0x80, "Off" },
2503 {0x16, 0x01, 0x80, 0x00, "On" },
2504 };
2505
2506 STDDIPINFO(Blandia)
2507
2508 static struct BurnDIPInfo GundharaDIPList[]=
2509 {
2510 {0x14, 0xff, 0xff, 0xff, NULL },
2511 {0x15, 0xff, 0xff, 0xff, NULL },
2512 {0x16, 0xff, 0xff, 0xff, NULL },
2513
2514 {0 , 0xfe, 0 , 16, "Coin A" },
2515 {0x14, 0x01, 0x0f, 0x02, "4 Coins 1 Credits" },
2516 {0x14, 0x01, 0x0f, 0x05, "3 Coins 1 Credits" },
2517 {0x14, 0x01, 0x0f, 0x08, "2 Coins 1 Credits" },
2518 {0x14, 0x01, 0x0f, 0x04, "3 Coins 2 Credits" },
2519 {0x14, 0x01, 0x0f, 0x01, "4 Coins 3 Credits" },
2520 {0x14, 0x01, 0x0f, 0x0f, "1 Coin 1 Credits" },
2521 {0x14, 0x01, 0x0f, 0x03, "3 Coins 4 Credits" },
2522 {0x14, 0x01, 0x0f, 0x07, "2 Coins 3 Credits" },
2523 {0x14, 0x01, 0x0f, 0x0e, "1 Coin 2 Credits" },
2524 {0x14, 0x01, 0x0f, 0x06, "2 Coins 5 Credits" },
2525 {0x14, 0x01, 0x0f, 0x0d, "1 Coin 3 Credits" },
2526 {0x14, 0x01, 0x0f, 0x0c, "1 Coin 4 Credits" },
2527 {0x14, 0x01, 0x0f, 0x0b, "1 Coin 5 Credits" },
2528 {0x14, 0x01, 0x0f, 0x0a, "1 Coin 6 Credits" },
2529 {0x14, 0x01, 0x0f, 0x09, "1 Coin 7 Credits" },
2530 {0x14, 0x01, 0x0f, 0x00, "Free Play" },
2531
2532 {0 , 0xfe, 0 , 4, "Coin B" },
2533 {0x14, 0x01, 0x30, 0x00, "3 Coins 1 Credits" },
2534 {0x14, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
2535 {0x14, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
2536 {0x14, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
2537
2538 {0 , 0xfe, 0 , 2, "Language" },
2539 {0x14, 0x01, 0xc0, 0xc0, "Japanese" },
2540 {0x14, 0x01, 0xc0, 0x00, "English" },
2541
2542 {0 , 0xfe, 0 , 4, "Difficulty" },
2543 {0x15, 0x01, 0x03, 0x02, "Easy" },
2544 {0x15, 0x01, 0x03, 0x03, "Normal" },
2545 {0x15, 0x01, 0x03, 0x01, "Hard" },
2546 {0x15, 0x01, 0x03, 0x00, "Hardest" },
2547
2548 {0 , 0xfe, 0 , 4, "Lives" },
2549 {0x15, 0x01, 0x0c, 0x08, "1" },
2550 {0x15, 0x01, 0x0c, 0x0c, "2" },
2551 {0x15, 0x01, 0x0c, 0x04, "3" },
2552 {0x15, 0x01, 0x0c, 0x00, "4" },
2553
2554 {0 , 0xfe, 0 , 4, "Bonus Life" },
2555 {0x15, 0x01, 0x30, 0x30, "200K" },
2556 {0x15, 0x01, 0x30, 0x20, "200K, Every 200K" },
2557 {0x15, 0x01, 0x30, 0x10, "400K" },
2558 {0x15, 0x01, 0x30, 0x00, "None" },
2559
2560 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2561 {0x15, 0x01, 0x40, 0x00, "Off" },
2562 {0x15, 0x01, 0x40, 0x40, "On" },
2563
2564 {0 , 0xfe, 0 , 2, "Service Mode" },
2565 {0x15, 0x01, 0x80, 0x80, "Off" },
2566 {0x15, 0x01, 0x80, 0x00, "On" },
2567
2568 {0 , 0xfe, 0 , 2, "Service Mode" },
2569 {0x16, 0x01, 0x08, 0x08, "Off" },
2570 {0x16, 0x01, 0x08, 0x00, "On" },
2571 };
2572
2573 STDDIPINFO(Gundhara)
2574
2575 static struct BurnDIPInfo AtehateDIPList[]=
2576 {
2577 {0x0e, 0xff, 0xff, 0xff, NULL },
2578 {0x0f, 0xff, 0xff, 0xff, NULL },
2579 {0x10, 0xff, 0xff, 0xff, NULL },
2580
2581 {0 , 0xfe, 0 , 8, "Coin A" },
2582 {0x0e, 0x01, 0x07, 0x01, "4 Coins 1 Credits" },
2583 {0x0e, 0x01, 0x07, 0x02, "3 Coins 1 Credits" },
2584 {0x0e, 0x01, 0x07, 0x04, "2 Coins 1 Credits" },
2585 {0x0e, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2586 {0x0e, 0x01, 0x07, 0x03, "2 Coins 3 Credits" },
2587 {0x0e, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
2588 {0x0e, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
2589 {0x0e, 0x01, 0x07, 0x00, "Free Play" },
2590
2591 {0 , 0xfe, 0 , 8, "Coin B" },
2592 {0x0e, 0x01, 0x38, 0x08, "4 Coins 1 Credits" },
2593 {0x0e, 0x01, 0x38, 0x10, "3 Coins 1 Credits" },
2594 {0x0e, 0x01, 0x38, 0x20, "2 Coins 1 Credits" },
2595 {0x0e, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2596 {0x0e, 0x01, 0x38, 0x18, "2 Coins 3 Credits" },
2597 {0x0e, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
2598 {0x0e, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
2599 {0x0e, 0x01, 0x38, 0x00, "Free Play" },
2600
2601 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2602 {0x0e, 0x01, 0x40, 0x00, "Off" },
2603 {0x0e, 0x01, 0x40, 0x40, "On" },
2604
2605 {0 , 0xfe, 0 , 2, "Flip Screen" },
2606 {0x0f, 0x01, 0x01, 0x01, "Off" },
2607 {0x0f, 0x01, 0x01, 0x00, "On" },
2608
2609 {0 , 0xfe, 0 , 2, "Service Mode" },
2610 {0x0f, 0x01, 0x02, 0x02, "Off" },
2611 {0x0f, 0x01, 0x02, 0x00, "On" },
2612
2613 {0 , 0xfe, 0 , 4, "Difficulty" },
2614 {0x0f, 0x01, 0x0c, 0x08, "Easy" },
2615 {0x0f, 0x01, 0x0c, 0x0c, "Normal" },
2616 {0x0f, 0x01, 0x0c, 0x04, "Hard" },
2617 {0x0f, 0x01, 0x0c, 0x00, "Hardest" },
2618
2619 {0 , 0xfe, 0 , 4, "Lives" },
2620 {0x0f, 0x01, 0x30, 0x00, "2" },
2621 {0x0f, 0x01, 0x30, 0x30, "3" },
2622 {0x0f, 0x01, 0x30, 0x10, "4" },
2623 {0x0f, 0x01, 0x30, 0x20, "5" },
2624
2625 {0 , 0xfe, 0 , 4, "Bonus Life" },
2626 {0x0f, 0x01, 0xc0, 0xc0, "None" },
2627 {0x0f, 0x01, 0xc0, 0x00, "20K Only" },
2628 {0x0f, 0x01, 0xc0, 0x80, "20K, Every 30K" },
2629 {0x0f, 0x01, 0xc0, 0x40, "30K, Every 40K" },
2630 };
2631
2632 STDDIPINFO(Atehate)
2633
2634 static struct BurnDIPInfo ThunderlDIPList[]=
2635 {
2636 {0x13, 0xff, 0xff, 0xff, NULL },
2637 {0x14, 0xff, 0xff, 0xe9, NULL },
2638 {0x15, 0xff, 0xff, 0xef, NULL },
2639
2640 {0 , 0xfe, 0 , 16, "Coin A" },
2641 {0x13, 0x01, 0x0f, 0x0c, "4 Coins 1 Credits" },
2642 {0x13, 0x01, 0x0f, 0x0d, "3 Coins 1 Credits" },
2643 {0x13, 0x01, 0x0f, 0x08, "4 Coins 2 Credits" },
2644 {0x13, 0x01, 0x0f, 0x0e, "2 Coins 1 Credits" },
2645 {0x13, 0x01, 0x0f, 0x09, "3 Coins 2 Credits" },
2646 {0x13, 0x01, 0x0f, 0x04, "4 Coins 3 Credits" },
2647 {0x13, 0x01, 0x0f, 0x00, "4 Coins 4 Credits" },
2648 {0x13, 0x01, 0x0f, 0x05, "3 Coins 3 Credits" },
2649 {0x13, 0x01, 0x0f, 0x0a, "2 Coins 2 Credits" },
2650 {0x13, 0x01, 0x0f, 0x0f, "1 Coin 1 Credits" },
2651 {0x13, 0x01, 0x0f, 0x01, "3 Coins 4 Credits" },
2652 {0x13, 0x01, 0x0f, 0x06, "2 Coins 3 Credits" },
2653 {0x13, 0x01, 0x0f, 0x02, "2 Coins 4 Credits" },
2654 {0x13, 0x01, 0x0f, 0x0b, "1 Coin 2 Credits" },
2655 {0x13, 0x01, 0x0f, 0x07, "1 Coin 3 Credits" },
2656 {0x13, 0x01, 0x0f, 0x03, "1 Coin 4 Credits" },
2657
2658 {0 , 0xfe, 0 , 16, "Coin B" },
2659 {0x13, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
2660 {0x13, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
2661 {0x13, 0x01, 0xf0, 0x80, "4 Coins 2 Credits" },
2662 {0x13, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
2663 {0x13, 0x01, 0xf0, 0x90, "3 Coins 2 Credits" },
2664 {0x13, 0x01, 0xf0, 0x40, "4 Coins 3 Credits" },
2665 {0x13, 0x01, 0xf0, 0x00, "4 Coins 4 Credits" },
2666 {0x13, 0x01, 0xf0, 0x50, "3 Coins 3 Credits" },
2667 {0x13, 0x01, 0xf0, 0xa0, "2 Coins 2 Credits" },
2668 {0x13, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
2669 {0x13, 0x01, 0xf0, 0x10, "3 Coins 4 Credits" },
2670 {0x13, 0x01, 0xf0, 0x60, "2 Coins 3 Credits" },
2671 {0x13, 0x01, 0xf0, 0x20, "2 Coins 4 Credits" },
2672 {0x13, 0x01, 0xf0, 0xb0, "1 Coin 2 Credits" },
2673 {0x13, 0x01, 0xf0, 0x70, "1 Coin 3 Credits" },
2674 {0x13, 0x01, 0xf0, 0x30, "1 Coin 4 Credits" },
2675
2676 {0 , 0xfe, 0 , 2, "Service Mode" },
2677 {0x14, 0x01, 0x01, 0x01, "Off" },
2678 {0x14, 0x01, 0x01, 0x00, "On" },
2679
2680 {0 , 0xfe, 0 , 2, "Flip Screen" },
2681 {0x14, 0x01, 0x02, 0x00, "Off" },
2682 {0x14, 0x01, 0x02, 0x02, "On" },
2683
2684 {0 , 0xfe, 0 , 2, "Cabinet" },
2685 {0x14, 0x01, 0x04, 0x00, "Upright" },
2686 {0x14, 0x01, 0x04, 0x04, "Cocktail" },
2687
2688 {0 , 0xfe, 0 , 2, "Controls" },
2689 {0x14, 0x01, 0x08, 0x08, "2" },
2690 {0x14, 0x01, 0x08, 0x00, "1" },
2691
2692 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2693 {0x14, 0x01, 0x10, 0x10, "Off" },
2694 {0x14, 0x01, 0x10, 0x00, "On" },
2695
2696 {0 , 0xfe, 0 , 2, "Lives" },
2697 {0x14, 0x01, 0x20, 0x20, "3" },
2698 {0x14, 0x01, 0x20, 0x00, "2" },
2699
2700 {0 , 0xfe, 0 , 4, "Difficulty" },
2701 {0x14, 0x01, 0xc0, 0x80, "Easy" },
2702 {0x14, 0x01, 0xc0, 0xc0, "Normal" },
2703 {0x14, 0x01, 0xc0, 0x40, "Hard" },
2704 {0x14, 0x01, 0xc0, 0x00, "Hardest" },
2705
2706 {0 , 0xfe, 0 , 2, "Force 1 Life" },
2707 {0x15, 0x01, 0x10, 0x00, "Off" },
2708 {0x15, 0x01, 0x10, 0x10, "On" },
2709
2710 {0 , 0xfe, 0 , 5, "Copyright" },
2711 {0x15, 0x01, 0xe0, 0x80, "Romstar" },
2712 {0x15, 0x01, 0xe0, 0xc0, "Seta (Romstar License)"},
2713 {0x15, 0x01, 0xe0, 0xe0, "Seta (Visco License)" },
2714 {0x15, 0x01, 0xe0, 0xa0, "Visco" },
2715 {0x15, 0x01, 0xe0, 0x60, "None" },
2716 };
2717
2718 STDDIPINFO(Thunderl)
2719
2720 static struct BurnDIPInfo WitsDIPList[]=
2721 {
2722 {0x21, 0xff, 0xff, 0xff, NULL },
2723 {0x22, 0xff, 0xff, 0xff, NULL },
2724 {0x23, 0xff, 0xff, 0x7f, NULL },
2725
2726 {0 , 0xfe, 0 , 4, "Difficulty" },
2727 {0x21, 0x01, 0x03, 0x02, "Easy" },
2728 {0x21, 0x01, 0x03, 0x03, "Normal" },
2729 {0x21, 0x01, 0x03, 0x01, "Hard" },
2730 {0x21, 0x01, 0x03, 0x00, "Hardest" },
2731
2732 {0 , 0xfe, 0 , 4, "Bonus Life" },
2733 {0x21, 0x01, 0x0c, 0x08, "150k, 350k" },
2734 {0x21, 0x01, 0x0c, 0x0c, "200k, 500k" },
2735 {0x21, 0x01, 0x0c, 0x04, "300k, 600k" },
2736 {0x21, 0x01, 0x0c, 0x00, "400k" },
2737
2738 {0 , 0xfe, 0 , 4, "Lives" },
2739 {0x21, 0x01, 0x30, 0x00, "1" },
2740 {0x21, 0x01, 0x30, 0x10, "2" },
2741 {0x21, 0x01, 0x30, 0x30, "3" },
2742 {0x21, 0x01, 0x30, 0x20, "5" },
2743
2744 {0 , 0xfe, 0 , 2, "Play Mode" },
2745 {0x21, 0x01, 0x40, 0x40, "2 Players" },
2746 {0x21, 0x01, 0x40, 0x00, "4 Players" },
2747
2748 {0 , 0xfe, 0 , 2, "CPU Player During Multi-Player Game" },
2749 {0x21, 0x01, 0x80, 0x00, "No" },
2750 {0x21, 0x01, 0x80, 0x80, "Yes" },
2751
2752 {0 , 0xfe, 0 , 2, "Cabinet" },
2753 {0x22, 0x01, 0x01, 0x01, "Upright" },
2754 {0x22, 0x01, 0x01, 0x00, "Cocktail" },
2755
2756 {0 , 0xfe, 0 , 2, "Flip Screen" },
2757 {0x22, 0x01, 0x02, 0x02, "Off" },
2758 {0x22, 0x01, 0x02, 0x00, "On" },
2759
2760 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2761 {0x22, 0x01, 0x04, 0x04, "Every 3rd Loop" },
2762 {0x22, 0x01, 0x04, 0x00, "Every 7th Loop" },
2763
2764 {0 , 0xfe, 0 , 2, "Service Mode" },
2765 {0x22, 0x01, 0x08, 0x08, "Off" },
2766 {0x22, 0x01, 0x08, 0x00, "On" },
2767
2768 {0 , 0xfe, 0 , 4, "Coin A" },
2769 {0x22, 0x01, 0x30, 0x00, "4 Coins 1 Credits" },
2770 {0x22, 0x01, 0x30, 0x10, "3 Coins 1 Credits" },
2771 {0x22, 0x01, 0x30, 0x20, "2 Coins 1 Credits" },
2772 {0x22, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
2773
2774 {0 , 0xfe, 0 , 4, "Coin B" },
2775 {0x22, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
2776 {0x22, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
2777 {0x22, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
2778 {0x22, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
2779
2780 {0 , 0xfe, 0 , 4, "License" },
2781 {0x23, 0x01, 0xc0, 0xc0, "Romstar" },
2782 {0x23, 0x01, 0xc0, 0x80, "Seta U.S.A" },
2783 {0x23, 0x01, 0xc0, 0x40, "Visco (Japan Only)" },
2784 {0x23, 0x01, 0xc0, 0x00, "Athena (Japan Only)" },
2785 };
2786
2787 STDDIPINFO(Wits)
2788
2789 static struct BurnDIPInfo MadsharkDIPList[]=
2790 {
2791 {0x13, 0xff, 0xff, 0xff, NULL },
2792 {0x14, 0xff, 0xff, 0xff, NULL },
2793 {0x15, 0xff, 0xff, 0x7f, NULL },
2794
2795 {0 , 0xfe, 0 , 2, "Flip Screen" },
2796 {0x13, 0x01, 0x01, 0x01, "Off" },
2797 {0x13, 0x01, 0x01, 0x00, "On" },
2798
2799 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2800 {0x13, 0x01, 0x02, 0x00, "Off" },
2801 {0x13, 0x01, 0x02, 0x02, "On" },
2802
2803 {0 , 0xfe, 0 , 4, "Bonus Life" },
2804 {0x13, 0x01, 0x18, 0x18, "1000k" },
2805 {0x13, 0x01, 0x18, 0x08, "1000k 2000k" },
2806 {0x13, 0x01, 0x18, 0x10, "1500k 3000k" },
2807 {0x13, 0x01, 0x18, 0x00, "No" },
2808
2809 {0 , 0xfe, 0 , 4, "Difficulty" },
2810 {0x13, 0x01, 0x60, 0x40, "Easy" },
2811 {0x13, 0x01, 0x60, 0x60, "Normal" },
2812 {0x13, 0x01, 0x60, 0x20, "Hard" },
2813 {0x13, 0x01, 0x60, 0x00, "Hardest" },
2814
2815 {0 , 0xfe, 0 , 2, "Service Mode" },
2816 {0x13, 0x01, 0x80, 0x80, "Off" },
2817 {0x13, 0x01, 0x80, 0x00, "On" },
2818
2819 {0 , 0xfe, 0 , 4, "Lives" },
2820 {0x14, 0x01, 0x03, 0x02, "2" },
2821 {0x14, 0x01, 0x03, 0x03, "3" },
2822 {0x14, 0x01, 0x03, 0x01, "4" },
2823 {0x14, 0x01, 0x03, 0x00, "5" },
2824
2825 {0 , 0xfe, 0 , 8, "Coin A" },
2826 {0x14, 0x01, 0x1c, 0x04, "4 Coins 1 Credits" },
2827 {0x14, 0x01, 0x1c, 0x08, "3 Coins 1 Credits" },
2828 {0x14, 0x01, 0x1c, 0x10, "2 Coins 1 Credits" },
2829 {0x14, 0x01, 0x1c, 0x1c, "1 Coin 1 Credits" },
2830 {0x14, 0x01, 0x1c, 0x0c, "2 Coins 3 Credits" },
2831 {0x14, 0x01, 0x1c, 0x18, "1 Coin 2 Credits" },
2832 {0x14, 0x01, 0x1c, 0x14, "1 Coin 3 Credits" },
2833 {0x14, 0x01, 0x1c, 0x00, "1 Coin 4 Credits" },
2834
2835 {0 , 0xfe, 0 , 8, "Coin A" },
2836 {0x14, 0x01, 0xe0, 0x20, "4 Coins 1 Credits" },
2837 {0x14, 0x01, 0xe0, 0x40, "3 Coins 1 Credits" },
2838 {0x14, 0x01, 0xe0, 0x80, "2 Coins 1 Credits" },
2839 {0x14, 0x01, 0xe0, 0xe0, "1 Coin 1 Credits" },
2840 {0x14, 0x01, 0xe0, 0x60, "2 Coins 3 Credits" },
2841 {0x14, 0x01, 0xe0, 0xc0, "1 Coin 2 Credits" },
2842 {0x14, 0x01, 0xe0, 0xa0, "1 Coin 3 Credits" },
2843 {0x14, 0x01, 0xe0, 0x00, "1 Coin 4 Credits" },
2844
2845 {0 , 0xfe, 0 , 2, "Country" },
2846 {0x15, 0x01, 0x80, 0x80, "Japan" },
2847 {0x15, 0x01, 0x80, 0x00, "World" },
2848 };
2849
2850 STDDIPINFO(Madshark)
2851
2852 static struct BurnDIPInfo MsgundamDIPList[]=
2853 {
2854 {0x13, 0xff, 0xff, 0xff, NULL },
2855 {0x14, 0xff, 0xff, 0xff, NULL },
2856 {0x15, 0xff, 0xff, 0xff, NULL },
2857
2858 {0 , 0xfe, 0 , 8, "Coin A" },
2859 {0x13, 0x01, 0x07, 0x00, "4 Coins 1 Credits" },
2860 {0x13, 0x01, 0x07, 0x01, "3 Coins 1 Credits" },
2861 {0x13, 0x01, 0x07, 0x02, "2 Coins 1 Credits" },
2862 {0x13, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2863 {0x13, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
2864 {0x13, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
2865 {0x13, 0x01, 0x07, 0x03, "1 Coin 4 Credits" },
2866 {0x13, 0x01, 0x07, 0x04, "1 Coin 5 Credits" },
2867
2868 {0 , 0xfe, 0 , 8, "Coin B" },
2869 {0x13, 0x01, 0x38, 0x00, "4 Coins 1 Credits" },
2870 {0x13, 0x01, 0x38, 0x08, "3 Coins 1 Credits" },
2871 {0x13, 0x01, 0x38, 0x10, "2 Coins 1 Credits" },
2872 {0x13, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2873 {0x13, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
2874 {0x13, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
2875 {0x13, 0x01, 0x38, 0x18, "1 Coin 4 Credits" },
2876 {0x13, 0x01, 0x38, 0x20, "1 Coin 5 Credits" },
2877
2878 {0 , 0xfe, 0 , 2, "Free Play" },
2879 {0x13, 0x01, 0x80, 0x80, "Off" },
2880 {0x13, 0x01, 0x80, 0x00, "On" },
2881
2882 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2883 {0x14, 0x01, 0x01, 0x00, "Off" },
2884 {0x14, 0x01, 0x01, 0x01, "On" },
2885
2886 {0 , 0xfe, 0 , 4, "Difficulty" },
2887 {0x14, 0x01, 0x06, 0x04, "Easy" },
2888 {0x14, 0x01, 0x06, 0x06, "Normal" },
2889 {0x14, 0x01, 0x06, 0x02, "Hard" },
2890 {0x14, 0x01, 0x06, 0x00, "Hardest" },
2891
2892 {0 , 0xfe, 0 , 2, "Flip Screen" },
2893 {0x14, 0x01, 0x10, 0x10, "Off" },
2894 {0x14, 0x01, 0x10, 0x00, "On" },
2895
2896 {0 , 0xfe, 0 , 2, "Memory Check" },
2897 {0x14, 0x01, 0x20, 0x20, "Off" },
2898 {0x14, 0x01, 0x20, 0x00, "On" },
2899
2900 {0 , 0xfe, 0 , 2, "Service Mode" },
2901 {0x14, 0x01, 0x80, 0x80, "Off" },
2902 {0x14, 0x01, 0x80, 0x00, "On" },
2903
2904 {0 , 0xfe, 0 , 2, "Language" },
2905 {0x15, 0x01, 0x80, 0x80, "English" },
2906 {0x15, 0x01, 0x80, 0x00, "Japanese" },
2907 };
2908
2909 STDDIPINFO(Msgundam)
2910
2911 static struct BurnDIPInfo Msgunda1DIPList[]=
2912 {
2913 {0x13, 0xff, 0xff, 0xff, NULL },
2914 {0x14, 0xff, 0xff, 0xff, NULL },
2915 {0x15, 0xff, 0xff, 0x7f, NULL },
2916
2917 {0 , 0xfe, 0 , 8, "Coin A" },
2918 {0x13, 0x01, 0x07, 0x00, "4 Coins 1 Credits" },
2919 {0x13, 0x01, 0x07, 0x01, "3 Coins 1 Credits" },
2920 {0x13, 0x01, 0x07, 0x02, "2 Coins 1 Credits" },
2921 {0x13, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
2922 {0x13, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
2923 {0x13, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
2924 {0x13, 0x01, 0x07, 0x03, "1 Coin 4 Credits" },
2925 {0x13, 0x01, 0x07, 0x04, "1 Coin 5 Credits" },
2926
2927 {0 , 0xfe, 0 , 8, "Coin B" },
2928 {0x13, 0x01, 0x38, 0x00, "4 Coins 1 Credits" },
2929 {0x13, 0x01, 0x38, 0x08, "3 Coins 1 Credits" },
2930 {0x13, 0x01, 0x38, 0x10, "2 Coins 1 Credits" },
2931 {0x13, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
2932 {0x13, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
2933 {0x13, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
2934 {0x13, 0x01, 0x38, 0x18, "1 Coin 4 Credits" },
2935 {0x13, 0x01, 0x38, 0x20, "1 Coin 5 Credits" },
2936
2937 {0 , 0xfe, 0 , 2, "Free Play" },
2938 {0x13, 0x01, 0x80, 0x80, "Off" },
2939 {0x13, 0x01, 0x80, 0x00, "On" },
2940
2941 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2942 {0x14, 0x01, 0x01, 0x00, "Off" },
2943 {0x14, 0x01, 0x01, 0x01, "On" },
2944
2945 {0 , 0xfe, 0 , 4, "Difficulty" },
2946 {0x14, 0x01, 0x06, 0x04, "Easy" },
2947 {0x14, 0x01, 0x06, 0x06, "Normal" },
2948 {0x14, 0x01, 0x06, 0x02, "Hard" },
2949 {0x14, 0x01, 0x06, 0x00, "Hardest" },
2950
2951 {0 , 0xfe, 0 , 2, "Flip Screen" },
2952 {0x14, 0x01, 0x10, 0x10, "Off" },
2953 {0x14, 0x01, 0x10, 0x00, "On" },
2954
2955 {0 , 0xfe, 0 , 2, "Memory Check" },
2956 {0x14, 0x01, 0x20, 0x20, "Off" },
2957 {0x14, 0x01, 0x20, 0x00, "On" },
2958
2959 {0 , 0xfe, 0 , 2, "Service Mode" },
2960 {0x14, 0x01, 0x80, 0x80, "Off" },
2961 {0x14, 0x01, 0x80, 0x00, "On" },
2962
2963 {0 , 0xfe, 0 , 1, "Language" },
2964 {0x15, 0x01, 0x80, 0x00, "Japanese" },
2965 };
2966
2967 STDDIPINFO(Msgunda1)
2968
2969 static struct BurnDIPInfo ZingzipDIPList[]=
2970 {
2971 {0x12, 0xff, 0xff, 0xff, NULL },
2972 {0x13, 0xff, 0xff, 0xff, NULL },
2973 {0x14, 0xff, 0xff, 0xff, NULL },
2974
2975 {0 , 0xfe, 0 , 2, "Flip Screen" },
2976 {0x12, 0x01, 0x01, 0x01, "Off" },
2977 {0x12, 0x01, 0x01, 0x00, "On" },
2978
2979 {0 , 0xfe, 0 , 2, "Demo Sounds" },
2980 {0x12, 0x01, 0x02, 0x00, "Off" },
2981 {0x12, 0x01, 0x02, 0x02, "On" },
2982
2983 {0 , 0xfe, 0 , 2, "Service Mode" },
2984 {0x12, 0x01, 0x80, 0x80, "Off" },
2985 {0x12, 0x01, 0x80, 0x00, "On" },
2986
2987 {0 , 0xfe, 0 , 4, "Lives" },
2988 {0x13, 0x01, 0x03, 0x02, "2" },
2989 {0x13, 0x01, 0x03, 0x03, "3" },
2990 {0x13, 0x01, 0x03, 0x01, "4" },
2991 {0x13, 0x01, 0x03, 0x00, "5" },
2992
2993 {0 , 0xfe, 0 , 4, "Difficulty" },
2994 {0x13, 0x01, 0x0c, 0x08, "Easy" },
2995 {0x13, 0x01, 0x0c, 0x0c, "Normal" },
2996 {0x13, 0x01, 0x0c, 0x04, "Hard" },
2997 {0x13, 0x01, 0x0c, 0x00, "Hardest" },
2998
2999 {0 , 0xfe, 0 , 16, "Coinage" },
3000 {0x13, 0x01, 0xf0, 0xa0, "6 Coins 1 Credits" },
3001 {0x13, 0x01, 0xf0, 0xb0, "5 Coins 1 Credits" },
3002 {0x13, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
3003 {0x13, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
3004 {0x13, 0x01, 0xf0, 0x10, "8 Coins 3 Credits" },
3005 {0x13, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
3006 {0x13, 0x01, 0xf0, 0x20, "5 Coins 3 Credits" },
3007 {0x13, 0x01, 0xf0, 0x30, "3 Coins 2 Credits" },
3008 {0x13, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
3009 {0x13, 0x01, 0xf0, 0x40, "2 Coins 3 Credits" },
3010 {0x13, 0x01, 0xf0, 0x90, "1 Coin 2 Credits" },
3011 {0x13, 0x01, 0xf0, 0x80, "1 Coin 3 Credits" },
3012 {0x13, 0x01, 0xf0, 0x70, "1 Coin 4 Credits" },
3013 {0x13, 0x01, 0xf0, 0x60, "1 Coin 5 Credits" },
3014 {0x13, 0x01, 0xf0, 0x50, "1 Coin 6 Credits" },
3015 {0x13, 0x01, 0xf0, 0x00, "Free Play" },
3016 };
3017
3018 STDDIPINFO(Zingzip)
3019
3020 static struct BurnDIPInfo WrofaeroDIPList[]=
3021 {
3022 {0x15, 0xff, 0xff, 0xff, NULL },
3023 {0x16, 0xff, 0xff, 0xff, NULL },
3024 {0x17, 0xff, 0xff, 0xff, NULL },
3025
3026 {0 , 0xfe, 0 , 2, "Flip Screen" },
3027 {0x15, 0x01, 0x01, 0x01, "Off" },
3028 {0x15, 0x01, 0x01, 0x00, "On" },
3029
3030 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3031 {0x15, 0x01, 0x02, 0x00, "Off" },
3032 {0x15, 0x01, 0x02, 0x02, "On" },
3033
3034 {0 , 0xfe, 0 , 2, "Stage & Weapon Select"},
3035 {0x15, 0x01, 0x08, 0x08, "Off" },
3036 {0x15, 0x01, 0x08, 0x00, "On" },
3037
3038 {0 , 0xfe, 0 , 2, "Service Mode" },
3039 {0x15, 0x01, 0x80, 0x80, "Off" },
3040 {0x15, 0x01, 0x80, 0x00, "On" },
3041
3042 {0 , 0xfe, 0 , 4, "Lives" },
3043 {0x16, 0x01, 0x03, 0x02, "2" },
3044 {0x16, 0x01, 0x03, 0x03, "3" },
3045 {0x16, 0x01, 0x03, 0x01, "4" },
3046 {0x16, 0x01, 0x03, 0x00, "5" },
3047
3048 {0 , 0xfe, 0 , 4, "Difficulty" },
3049 {0x16, 0x01, 0x0c, 0x08, "Easy" },
3050 {0x16, 0x01, 0x0c, 0x0c, "Normal" },
3051 {0x16, 0x01, 0x0c, 0x04, "Hard" },
3052 {0x16, 0x01, 0x0c, 0x00, "Hardest" },
3053
3054 {0 , 0xfe, 0 , 16, "Coinage" },
3055 {0x16, 0x01, 0xf0, 0xa0, "6 Coins 1 Credits" },
3056 {0x16, 0x01, 0xf0, 0xb0, "5 Coins 1 Credits" },
3057 {0x16, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
3058 {0x16, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
3059 {0x16, 0x01, 0xf0, 0x10, "8 Coins 3 Credits" },
3060 {0x16, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
3061 {0x16, 0x01, 0xf0, 0x20, "5 Coins 3 Credits" },
3062 {0x16, 0x01, 0xf0, 0x30, "3 Coins 2 Credits" },
3063 {0x16, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
3064 {0x16, 0x01, 0xf0, 0x40, "2 Coins 3 Credits" },
3065 {0x16, 0x01, 0xf0, 0x90, "1 Coin 2 Credits" },
3066 {0x16, 0x01, 0xf0, 0x80, "1 Coin 3 Credits" },
3067 {0x16, 0x01, 0xf0, 0x70, "1 Coin 4 Credits" },
3068 {0x16, 0x01, 0xf0, 0x60, "1 Coin 5 Credits" },
3069 {0x16, 0x01, 0xf0, 0x50, "1 Coin 6 Credits" },
3070 {0x16, 0x01, 0xf0, 0x00, "Free Play" },
3071 };
3072
3073 STDDIPINFO(Wrofaero)
3074
3075 static struct BurnDIPInfo EightfrcDIPList[]=
3076 {
3077 {0x13, 0xff, 0xff, 0xff, NULL },
3078 {0x14, 0xff, 0xff, 0x7b, NULL },
3079 {0x15, 0xff, 0xff, 0xff, NULL },
3080
3081 {0 , 0xfe, 0 , 8, "Coin A" },
3082 {0x13, 0x01, 0x07, 0x04, "4 Coins 1 Credits" },
3083 {0x13, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
3084 {0x13, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
3085 {0x13, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
3086 {0x13, 0x01, 0x07, 0x03, "1 Coin 2 Credits" },
3087 {0x13, 0x01, 0x07, 0x02, "1 Coin 3 Credits" },
3088 {0x13, 0x01, 0x07, 0x01, "1 Coin 4 Credits" },
3089 {0x13, 0x01, 0x07, 0x00, "Free Play" },
3090
3091 {0 , 0xfe, 0 , 8, "Coin B" },
3092 {0x13, 0x01, 0x38, 0x20, "4 Coins 1 Credits" },
3093 {0x13, 0x01, 0x38, 0x28, "3 Coins 1 Credits" },
3094 {0x13, 0x01, 0x38, 0x30, "2 Coins 1 Credits" },
3095 {0x13, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
3096 {0x13, 0x01, 0x38, 0x18, "1 Coin 2 Credits" },
3097 {0x13, 0x01, 0x38, 0x10, "1 Coin 3 Credits" },
3098 {0x13, 0x01, 0x38, 0x08, "1 Coin 4 Credits" },
3099 {0x13, 0x01, 0x38, 0x00, "Free Play" },
3100
3101 {0 , 0xfe, 0 , 2, "Shared Credits" },
3102 {0x13, 0x01, 0x40, 0x00, "Off" },
3103 {0x13, 0x01, 0x40, 0x40, "On" },
3104
3105 {0 , 0xfe, 0 , 2, "Credits To Start" },
3106 {0x13, 0x01, 0x80, 0x80, "1" },
3107 {0x13, 0x01, 0x80, 0x00, "2" },
3108
3109 {0 , 0xfe, 0 , 2, "Service Mode" },
3110 {0x14, 0x01, 0x01, 0x01, "Off" },
3111 {0x14, 0x01, 0x01, 0x00, "On" },
3112
3113 {0 , 0xfe, 0 , 2, "Flip Screen" },
3114 {0x14, 0x01, 0x02, 0x02, "Off" },
3115 {0x14, 0x01, 0x02, 0x00, "On" },
3116
3117 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3118 {0x14, 0x01, 0x04, 0x04, "Off" },
3119 {0x14, 0x01, 0x04, 0x00, "On" },
3120
3121 {0 , 0xfe, 0 , 4, "Difficulty" },
3122 {0x14, 0x01, 0x18, 0x10, "Easy" },
3123 {0x14, 0x01, 0x18, 0x18, "Normal" },
3124 {0x14, 0x01, 0x18, 0x08, "Hard" },
3125 {0x14, 0x01, 0x18, 0x00, "Hardest" },
3126
3127 {0 , 0xfe, 0 , 4, "Lives" },
3128 {0x14, 0x01, 0x60, 0x40, "2" },
3129 {0x14, 0x01, 0x60, 0x60, "3" },
3130 {0x14, 0x01, 0x60, 0x20, "4" },
3131 {0x14, 0x01, 0x60, 0x00, "5" },
3132
3133 {0 , 0xfe, 0 , 2, "Language" },
3134 {0x14, 0x01, 0x80, 0x00, "English" },
3135 {0x14, 0x01, 0x80, 0x80, "Japanese" },
3136 };
3137
3138 STDDIPINFO(Eightfrc)
3139
3140 static struct BurnDIPInfo RezonDIPList[]=
3141 {
3142 {0x14, 0xff, 0xff, 0xff, NULL },
3143 {0x15, 0xff, 0xff, 0xff, NULL },
3144 {0x16, 0xff, 0xff, 0xff, NULL },
3145
3146 {0 , 0xfe, 0 , 2, "Flip Screen" },
3147 {0x14, 0x01, 0x01, 0x01, "Off" },
3148 {0x14, 0x01, 0x01, 0x00, "On" },
3149
3150 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3151 {0x14, 0x01, 0x02, 0x00, "Off" },
3152 {0x14, 0x01, 0x02, 0x02, "On" },
3153
3154 {0 , 0xfe, 0 , 3, "Cabinet" },
3155 {0x14, 0x01, 0x18, 0x00, "Upright 1 Controller" },
3156 {0x14, 0x01, 0x18, 0x18, "Upright 2 Controllers"},
3157 {0x14, 0x01, 0x18, 0x08, "Cocktail" },
3158
3159 {0 , 0xfe, 0 , 2, "Service Mode" },
3160 {0x14, 0x01, 0x80, 0x80, "Off" },
3161 {0x14, 0x01, 0x80, 0x00, "On" },
3162
3163 {0 , 0xfe, 0 , 4, "Lives" },
3164 {0x15, 0x01, 0x03, 0x02, "2" },
3165 {0x15, 0x01, 0x03, 0x03, "3" },
3166 {0x15, 0x01, 0x03, 0x01, "4" },
3167 {0x15, 0x01, 0x03, 0x00, "5" },
3168
3169 {0 , 0xfe, 0 , 4, "Difficulty" },
3170 {0x15, 0x01, 0x0c, 0x08, "Easy" },
3171 {0x15, 0x01, 0x0c, 0x0c, "Normal" },
3172 {0x15, 0x01, 0x0c, 0x04, "Hard" },
3173 {0x15, 0x01, 0x0c, 0x00, "Hardest" },
3174
3175 {0 , 0xfe, 0 , 16, "Coinage" },
3176 {0x15, 0x01, 0xf0, 0xa0, "6 Coins 1 Credits" },
3177 {0x15, 0x01, 0xf0, 0xb0, "5 Coins 1 Credits" },
3178 {0x15, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
3179 {0x15, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
3180 {0x15, 0x01, 0xf0, 0x10, "8 Coins 3 Credits" },
3181 {0x15, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
3182 {0x15, 0x01, 0xf0, 0x20, "5 Coins 3 Credits" },
3183 {0x15, 0x01, 0xf0, 0x30, "3 Coins 2 Credits" },
3184 {0x15, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
3185 {0x15, 0x01, 0xf0, 0x40, "2 Coins 3 Credits" },
3186 {0x15, 0x01, 0xf0, 0x90, "1 Coin 2 Credits" },
3187 {0x15, 0x01, 0xf0, 0x80, "1 Coin 3 Credits" },
3188 {0x15, 0x01, 0xf0, 0x70, "1 Coin 4 Credits" },
3189 {0x15, 0x01, 0xf0, 0x60, "1 Coin 5 Credits" },
3190 {0x15, 0x01, 0xf0, 0x50, "1 Coin 6 Credits" },
3191 {0x15, 0x01, 0xf0, 0x00, "Free Play" },
3192
3193 {0 , 0xfe, 0 , 2, "Service Mode" },
3194 {0x16, 0x01, 0x08, 0x08, "Off" },
3195 {0x16, 0x01, 0x08, 0x00, "On" },
3196
3197 {0 , 0xfe, 0 , 2, "Taito Logo" },
3198 {0x16, 0x01, 0x10, 0x00, "Off" },
3199 {0x16, 0x01, 0x10, 0x10, "On" },
3200 };
3201
3202 STDDIPINFO(Rezon)
3203
3204 static struct BurnDIPInfo Qzkklgy2DIPList[]=
3205 {
3206 {0x0e, 0xff, 0xff, 0xff, NULL },
3207 {0x0f, 0xff, 0xff, 0xff, NULL },
3208 {0x10, 0xff, 0xff, 0xff, NULL },
3209
3210 {0 , 0xfe, 0 , 2, "Highlight Right Answer" },
3211 {0x0e, 0x01, 0x04, 0x04, "Off" },
3212 {0x0e, 0x01, 0x04, 0x00, "On" },
3213
3214 {0 , 0xfe, 0 , 2, "Skip Real DAT Rom Check?" },
3215 {0x0e, 0x01, 0x08, 0x08, "Off" },
3216 {0x0e, 0x01, 0x08, 0x00, "On" },
3217
3218 {0 , 0xfe, 0 , 2, "Service Mode" },
3219 {0x0f, 0x01, 0x20, 0x20, "Off" },
3220 {0x0f, 0x01, 0x20, 0x00, "On" },
3221
3222 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3223 {0x0e, 0x01, 0x40, 0x00, "Off" },
3224 {0x0e, 0x01, 0x40, 0x40, "On" },
3225
3226 {0 , 0xfe, 0 , 2, "Flip Screen" },
3227 {0x0e, 0x01, 0x80, 0x80, "Off" },
3228 {0x0e, 0x01, 0x80, 0x00, "On" },
3229
3230 {0 , 0xfe, 0 , 8, "Coinage" },
3231 {0x0f, 0x01, 0x07, 0x04, "4 Coins 1 Credits" },
3232 {0x0f, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
3233 {0x0f, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
3234 {0x0f, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
3235 {0x0f, 0x01, 0x07, 0x00, "2 Coins 3 Credits" },
3236 {0x0f, 0x01, 0x07, 0x03, "1 Coin 2 Credits" },
3237 {0x0f, 0x01, 0x07, 0x02, "1 Coin 3 Credits" },
3238 {0x0f, 0x01, 0x07, 0x01, "1 Coin 4 Credits" },
3239
3240 {0 , 0xfe, 0 , 2, "Free Play" },
3241 {0x0f, 0x01, 0x08, 0x08, "Off" },
3242 {0x0f, 0x01, 0x08, 0x00, "On" },
3243
3244 {0 , 0xfe, 0 , 4, "Difficulty" },
3245 {0x0f, 0x01, 0x30, 0x30, "Easy" },
3246 {0x0f, 0x01, 0x30, 0x20, "Normal" },
3247 {0x0f, 0x01, 0x30, 0x10, "Hard" },
3248 {0x0f, 0x01, 0x30, 0x00, "Hardest" },
3249
3250 {0 , 0xfe, 0 , 4, "Lives" },
3251 {0x0f, 0x01, 0xc0, 0x80, "2" },
3252 {0x0f, 0x01, 0xc0, 0xc0, "3" },
3253 {0x0f, 0x01, 0xc0, 0x40, "4" },
3254 {0x0f, 0x01, 0xc0, 0x00, "5" },
3255 };
3256
3257 STDDIPINFO(Qzkklgy2)
3258
3259 static struct BurnDIPInfo QzkklogyDIPList[]=
3260 {
3261 {0x0f, 0xff, 0xff, 0xff, NULL },
3262 {0x10, 0xff, 0xff, 0xff, NULL },
3263 {0x11, 0xff, 0xff, 0xff, NULL },
3264
3265 {0 , 0xfe, 0 , 2, "Highlight Right Answer" },
3266 {0x0f, 0x01, 0x04, 0x04, "Off" },
3267 {0x0f, 0x01, 0x04, 0x00, "On" },
3268
3269 {0 , 0xfe, 0 , 2, "Service Mode" },
3270 {0x0f, 0x01, 0x20, 0x20, "Off" },
3271 {0x0f, 0x01, 0x20, 0x00, "On" },
3272
3273 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3274 {0x0f, 0x01, 0x40, 0x00, "Off" },
3275 {0x0f, 0x01, 0x40, 0x40, "On" },
3276
3277 {0 , 0xfe, 0 , 2, "Flip Screen" },
3278 {0x0f, 0x01, 0x80, 0x80, "Off" },
3279 {0x0f, 0x01, 0x80, 0x00, "On" },
3280
3281 {0 , 0xfe, 0 , 8, "Coin A" },
3282 {0x10, 0x01, 0x07, 0x04, "4 Coins 1 Credits" },
3283 {0x10, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
3284 {0x10, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
3285 {0x10, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
3286 {0x10, 0x01, 0x07, 0x01, "2 Coins 3 Credits" },
3287 {0x10, 0x01, 0x07, 0x03, "1 Coin 2 Credits" },
3288 {0x10, 0x01, 0x07, 0x02, "1 Coin 3 Credits" },
3289 {0x10, 0x01, 0x07, 0x00, "Free Play" },
3290
3291 {0 , 0xfe, 0 , 4, "Difficulty" },
3292 {0x10, 0x01, 0x30, 0x20, "Easy" },
3293 {0x10, 0x01, 0x30, 0x30, "Normal" },
3294 {0x10, 0x01, 0x30, 0x10, "Hard" },
3295 {0x10, 0x01, 0x30, 0x00, "Very Hard" },
3296
3297 {0 , 0xfe, 0 , 4, "Lives" },
3298 {0x10, 0x01, 0xc0, 0x80, "2" },
3299 {0x10, 0x01, 0xc0, 0xc0, "3" },
3300 {0x10, 0x01, 0xc0, 0x40, "4" },
3301 {0x10, 0x01, 0xc0, 0x00, "5" },
3302 };
3303
3304 STDDIPINFO(Qzkklogy)
3305
3306 static struct BurnDIPInfo StgDIPList[]=
3307 {
3308 {0x13, 0xff, 0xff, 0xff, NULL },
3309 {0x14, 0xff, 0xff, 0xff, NULL },
3310 {0x15, 0xff, 0xff, 0xff, NULL },
3311
3312 {0 , 0xfe, 0 , 4, "Difficulty" },
3313 {0x13, 0x01, 0x03, 0x02, "Easy" },
3314 {0x13, 0x01, 0x03, 0x03, "Normal" },
3315 {0x13, 0x01, 0x03, 0x01, "Hard" },
3316 {0x13, 0x01, 0x03, 0x00, "Hardest" },
3317
3318 {0 , 0xfe, 0 , 4, "Lives" },
3319 {0x13, 0x01, 0x30, 0x10, "1" },
3320 {0x13, 0x01, 0x30, 0x00, "2" },
3321 {0x13, 0x01, 0x30, 0x30, "3" },
3322 {0x13, 0x01, 0x30, 0x20, "5" },
3323
3324 {0 , 0xfe, 0 , 4, "Flip Screen" },
3325 {0x14, 0x01, 0x02, 0x02, "Off" },
3326 {0x14, 0x01, 0x02, 0x00, "On" },
3327
3328 {0 , 0xfe, 0 , 2, "Service Mode" },
3329 {0x14, 0x01, 0x04, 0x04, "Off" },
3330 {0x14, 0x01, 0x04, 0x00, "On" },
3331
3332 {0 , 0xfe, 0 , 4, "Coin A" },
3333 {0x14, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
3334 {0x14, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
3335 {0x14, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
3336 {0x14, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
3337
3338 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3339 {0x14, 0x01, 0x40, 0x00, "Off" },
3340 {0x14, 0x01, 0x40, 0x40, "On" },
3341 };
3342
3343 STDDIPINFO(Stg)
3344
3345 static struct BurnDIPInfo DrgnunitDIPList[]=
3346 {
3347 {0x15, 0xff, 0xff, 0xfe, NULL },
3348 {0x16, 0xff, 0xff, 0xff, NULL },
3349 {0x17, 0xff, 0xff, 0xff, NULL },
3350
3351 {0 , 0xfe, 0 , 4, "Difficulty" },
3352 {0x15, 0x01, 0x03, 0x03, "Easy" },
3353 {0x15, 0x01, 0x03, 0x02, "Normal" },
3354 {0x15, 0x01, 0x03, 0x01, "Hard" },
3355 {0x15, 0x01, 0x03, 0x00, "Hardest" },
3356
3357 {0 , 0xfe, 0 , 4, "Bonus Life" },
3358 {0x15, 0x01, 0x0c, 0x08, "150K, Every 300K" },
3359 {0x15, 0x01, 0x0c, 0x0c, "200K, Every 400K" },
3360 {0x15, 0x01, 0x0c, 0x04, "300K, Every 500K" },
3361 {0x15, 0x01, 0x0c, 0x00, "400K Only" },
3362
3363 {0 , 0xfe, 0 , 4, "Lives" },
3364 {0x15, 0x01, 0x30, 0x00, "1" },
3365 {0x15, 0x01, 0x30, 0x10, "2" },
3366 {0x15, 0x01, 0x30, 0x30, "3" },
3367 {0x15, 0x01, 0x30, 0x20, "5" },
3368
3369 {0 , 0xfe, 0 , 2, "Flip Screen" },
3370 {0x16, 0x01, 0x02, 0x02, "Off" },
3371 {0x16, 0x01, 0x02, 0x00, "On" },
3372
3373 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3374 {0x16, 0x01, 0x04, 0x04, "1 of 4 Scenes" },
3375 {0x16, 0x01, 0x04, 0x00, "1 of 8 Scenes" },
3376
3377 {0 , 0xfe, 0 , 2, "Service Mode" },
3378 {0x16, 0x01, 0x08, 0x08, "Off" },
3379 {0x16, 0x01, 0x08, 0x00, "On" },
3380
3381 {0 , 0xfe, 0 , 4, "Coin A" },
3382 {0x16, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
3383 {0x16, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
3384 {0x16, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
3385 {0x16, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
3386
3387 {0 , 0xfe, 0 , 4, "Coin B" },
3388 {0x16, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
3389 {0x16, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
3390 {0x16, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
3391 {0x16, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
3392
3393 {0 , 0xfe, 0 , 2, "Coinage Type" },
3394 {0x17, 0x01, 0x10, 0x10, "1" },
3395 {0x17, 0x01, 0x10, 0x00, "2" },
3396
3397 {0 , 0xfe, 0 , 2, "Title" },
3398 {0x17, 0x01, 0x20, 0x20, "Dragon Unit" },
3399 {0x17, 0x01, 0x20, 0x00, "Castle of Dragon" },
3400
3401 {0 , 0xfe, 0 , 4, "(C) / License" },
3402 {0x17, 0x01, 0xc0, 0xc0, "Athena (Japan)" },
3403 {0x17, 0x01, 0xc0, 0x80, "Athena / Taito (Japan)" },
3404 {0x17, 0x01, 0xc0, 0x40, "Seta USA / Taito America" },
3405 {0x17, 0x01, 0xc0, 0x00, "Seta USA / Romstar" },
3406 };
3407
3408 STDDIPINFO(Drgnunit)
3409
3410 static struct BurnDIPInfo DaiohDIPList[]=
3411 {
3412 {0x1a, 0xff, 0xff, 0x7f, NULL },
3413 {0x1b, 0xff, 0xff, 0xff, NULL },
3414 {0x1c, 0xff, 0xff, 0xff, NULL },
3415
3416 {0 , 0xfe, 0 , 8, "Coin A" },
3417 {0x1a, 0x01, 0x07, 0x01, "4 Coins 1 Credits" },
3418 {0x1a, 0x01, 0x07, 0x02, "3 Coins 1 Credits" },
3419 {0x1a, 0x01, 0x07, 0x04, "2 Coins 1 Credits" },
3420 {0x1a, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
3421 {0x1a, 0x01, 0x07, 0x03, "2 Coins 3 Credits" },
3422 {0x1a, 0x01, 0x07, 0x06, "1 Coin 2 Credits" },
3423 {0x1a, 0x01, 0x07, 0x05, "1 Coin 3 Credits" },
3424 {0x1a, 0x01, 0x07, 0x00, "Free Play" },
3425
3426 {0 , 0xfe, 0 , 8, "Coin B" },
3427 {0x1a, 0x01, 0x38, 0x08, "4 Coins 1 Credits" },
3428 {0x1a, 0x01, 0x38, 0x10, "3 Coins 1 Credits" },
3429 {0x1a, 0x01, 0x38, 0x20, "2 Coins 1 Credits" },
3430 {0x1a, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
3431 {0x1a, 0x01, 0x38, 0x18, "2 Coins 3 Credits" },
3432 {0x1a, 0x01, 0x38, 0x30, "1 Coin 2 Credits" },
3433 {0x1a, 0x01, 0x38, 0x28, "1 Coin 3 Credits" },
3434 {0x1a, 0x01, 0x38, 0x00, "Free Play" },
3435
3436 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3437 {0x1a, 0x01, 0x40, 0x00, "Off" },
3438 {0x1a, 0x01, 0x40, 0x40, "On" },
3439
3440 {0 , 0xfe, 0 , 2, "Auto Shot" },
3441 {0x1a, 0x01, 0x80, 0x80, "Off" },
3442 {0x1a, 0x01, 0x80, 0x00, "On" },
3443
3444 {0 , 0xfe, 0 , 2, "Flip Screen" },
3445 {0x1b, 0x01, 0x01, 0x01, "Off" },
3446 {0x1b, 0x01, 0x01, 0x00, "On" },
3447
3448 {0 , 0xfe, 0 , 2, "Service Mode" },
3449 {0x1b, 0x01, 0x02, 0x02, "Off" },
3450 {0x1b, 0x01, 0x02, 0x00, "On" },
3451
3452 {0 , 0xfe, 0 , 4, "Difficulty" },
3453 {0x1b, 0x01, 0x0c, 0x08, "Easy" },
3454 {0x1b, 0x01, 0x0c, 0x0c, "Normal" },
3455 {0x1b, 0x01, 0x0c, 0x04, "Hard" },
3456 {0x1b, 0x01, 0x0c, 0x00, "Hardest" },
3457
3458 {0 , 0xfe, 0 , 4, "Lives" },
3459 {0x1b, 0x01, 0x30, 0x00, "1" },
3460 {0x1b, 0x01, 0x30, 0x10, "2" },
3461 {0x1b, 0x01, 0x30, 0x30, "3" },
3462 {0x1b, 0x01, 0x30, 0x20, "5" },
3463
3464 {0 , 0xfe, 0 , 4, "Bonus Life" },
3465 {0x1b, 0x01, 0xc0, 0x80, "300k and every 800k" },
3466 {0x1b, 0x01, 0xc0, 0xc0, "500k and every 1000k" },
3467 {0x1b, 0x01, 0xc0, 0x40, "800k and 2000k only" },
3468 {0x1b, 0x01, 0xc0, 0x00, "1000k Only" },
3469
3470 {0 , 0xfe, 0 , 2, "Country" },
3471 {0x1c, 0x01, 0x80, 0x80, "USA (6 buttons)" },
3472 {0x1c, 0x01, 0x80, 0x00, "Japan (2 buttons)" },
3473 };
3474
3475 STDDIPINFO(Daioh)
3476
3477 static struct BurnDIPInfo NeobattlDIPList[]=
3478 {
3479 {0x11, 0xff, 0xff, 0xff, NULL },
3480 {0x12, 0xff, 0xff, 0xff, NULL },
3481 {0x13, 0xff, 0xff, 0xff, NULL },
3482
3483 {0 , 0xfe, 0 , 2, "Flip Screen" },
3484 {0x11, 0x01, 0x01, 0x01, "Off" },
3485 {0x11, 0x01, 0x01, 0x00, "On" },
3486
3487 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3488 {0x11, 0x01, 0x02, 0x00, "Off" },
3489 {0x11, 0x01, 0x02, 0x02, "On" },
3490
3491 {0 , 0xfe, 0 , 2, "Stage Select" },
3492 {0x11, 0x01, 0x08, 0x08, "Off" },
3493 {0x11, 0x01, 0x08, 0x00, "On" },
3494
3495 {0 , 0xfe, 0 , 2, "Service Mode" },
3496 {0x11, 0x01, 0x80, 0x80, "Off" },
3497 {0x11, 0x01, 0x80, 0x00, "On" },
3498
3499 {0 , 0xfe, 0 , 4, "Lives" },
3500 {0x12, 0x01, 0x03, 0x02, "1" },
3501 {0x12, 0x01, 0x03, 0x03, "2" },
3502 {0x12, 0x01, 0x03, 0x01, "3" },
3503 {0x12, 0x01, 0x03, 0x00, "4" },
3504
3505 {0 , 0xfe, 0 , 4, "Difficulty" },
3506 {0x12, 0x01, 0x0c, 0x08, "Easy" },
3507 {0x12, 0x01, 0x0c, 0x0c, "Normal" },
3508 {0x12, 0x01, 0x0c, 0x04, "Hard" },
3509 {0x12, 0x01, 0x0c, 0x00, "Hardest" },
3510
3511 {0 , 0xfe, 0 , 16, "Coinage" },
3512 {0x12, 0x01, 0xf0, 0xa0, "6 Coins 1 Credits" },
3513 {0x12, 0x01, 0xf0, 0xb0, "5 Coins 1 Credits" },
3514 {0x12, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
3515 {0x12, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
3516 {0x12, 0x01, 0xf0, 0x10, "8 Coins 3 Credits" },
3517 {0x12, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
3518 {0x12, 0x01, 0xf0, 0x20, "5 Coins 3 Credits" },
3519 {0x12, 0x01, 0xf0, 0x30, "3 Coins 2 Credits" },
3520 {0x12, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
3521 {0x12, 0x01, 0xf0, 0x40, "2 Coins 3 Credits" },
3522 {0x12, 0x01, 0xf0, 0x90, "1 Coin 2 Credits" },
3523 {0x12, 0x01, 0xf0, 0x80, "1 Coin 3 Credits" },
3524 {0x12, 0x01, 0xf0, 0x70, "1 Coin 4 Credits" },
3525 {0x12, 0x01, 0xf0, 0x60, "1 Coin 5 Credits" },
3526 {0x12, 0x01, 0xf0, 0x50, "1 Coin 6 Credits" },
3527 {0x12, 0x01, 0xf0, 0x00, "Free Play" },
3528 };
3529
3530 STDDIPINFO(Neobattl)
3531
3532 static struct BurnDIPInfo UmanclubDIPList[]=
3533 {
3534 {0x13, 0xff, 0xff, 0xff, NULL },
3535 {0x14, 0xff, 0xff, 0xff, NULL },
3536 {0x15, 0xff, 0xff, 0xff, NULL },
3537
3538 {0 , 0xfe, 0 , 2, "Flip Screen" },
3539 {0x13, 0x01, 0x01, 0x01, "Off" },
3540 {0x13, 0x01, 0x01, 0x00, "On" },
3541
3542 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3543 {0x13, 0x01, 0x02, 0x00, "Off" },
3544 {0x13, 0x01, 0x02, 0x02, "On" },
3545
3546 {0 , 0xfe, 0 , 2, "Stage Select" },
3547 {0x13, 0x01, 0x08, 0x08, "Off" },
3548 {0x13, 0x01, 0x08, 0x00, "On" },
3549
3550 {0 , 0xfe, 0 , 2, "Service Mode" },
3551 {0x13, 0x01, 0x80, 0x80, "Off" },
3552 {0x13, 0x01, 0x80, 0x00, "On" },
3553
3554 {0 , 0xfe, 0 , 4, "Lives" },
3555 {0x14, 0x01, 0x03, 0x02, "1" },
3556 {0x14, 0x01, 0x03, 0x03, "2" },
3557 {0x14, 0x01, 0x03, 0x01, "3" },
3558 {0x14, 0x01, 0x03, 0x00, "4" },
3559
3560 {0 , 0xfe, 0 , 4, "Difficulty" },
3561 {0x14, 0x01, 0x0c, 0x08, "Easy" },
3562 {0x14, 0x01, 0x0c, 0x0c, "Normal" },
3563 {0x14, 0x01, 0x0c, 0x04, "Hard" },
3564 {0x14, 0x01, 0x0c, 0x00, "Hardest" },
3565
3566 {0 , 0xfe, 0 , 16, "Coinage" },
3567 {0x14, 0x01, 0xf0, 0xa0, "6 Coins 1 Credits" },
3568 {0x14, 0x01, 0xf0, 0xb0, "5 Coins 1 Credits" },
3569 {0x14, 0x01, 0xf0, 0xc0, "4 Coins 1 Credits" },
3570 {0x14, 0x01, 0xf0, 0xd0, "3 Coins 1 Credits" },
3571 {0x14, 0x01, 0xf0, 0x10, "8 Coins 3 Credits" },
3572 {0x14, 0x01, 0xf0, 0xe0, "2 Coins 1 Credits" },
3573 {0x14, 0x01, 0xf0, 0x20, "5 Coins 3 Credits" },
3574 {0x14, 0x01, 0xf0, 0x30, "3 Coins 2 Credits" },
3575 {0x14, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
3576 {0x14, 0x01, 0xf0, 0x40, "2 Coins 3 Credits" },
3577 {0x14, 0x01, 0xf0, 0x90, "1 Coin 2 Credits" },
3578 {0x14, 0x01, 0xf0, 0x80, "1 Coin 3 Credits" },
3579 {0x14, 0x01, 0xf0, 0x70, "1 Coin 4 Credits" },
3580 {0x14, 0x01, 0xf0, 0x60, "1 Coin 5 Credits" },
3581 {0x14, 0x01, 0xf0, 0x50, "1 Coin 6 Credits" },
3582 {0x14, 0x01, 0xf0, 0x00, "Free Play" },
3583 };
3584
3585 STDDIPINFO(Umanclub)
3586
3587 static struct BurnDIPInfo KamenridDIPList[]=
3588 {
3589 {0x13, 0xff, 0xff, 0xff, NULL },
3590 {0x14, 0xff, 0xff, 0xff, NULL },
3591 {0x15, 0xff, 0xff, 0xff, NULL },
3592
3593 {0 , 0xfe, 0 , 2, "Service Mode" },
3594 {0x13, 0x01, 0x01, 0x01, "Off" },
3595 {0x13, 0x01, 0x01, 0x00, "On" },
3596
3597 {0 , 0xfe, 0 , 2, "Intro Music" },
3598 {0x13, 0x01, 0x40, 0x00, "Off" },
3599 {0x13, 0x01, 0x40, 0x40, "On" },
3600
3601 {0 , 0xfe, 0 , 2, "Flip Screen" },
3602 {0x13, 0x01, 0x80, 0x80, "Off" },
3603 {0x13, 0x01, 0x80, 0x00, "On" },
3604
3605 {0 , 0xfe, 0 , 16, "Coinage" },
3606 {0x14, 0x01, 0x0f, 0x05, "6 Coins 1 Credits" },
3607 {0x14, 0x01, 0x0f, 0x0d, "5 Coins 1 Credits" },
3608 {0x14, 0x01, 0x0f, 0x03, "4 Coins 1 Credits" },
3609 {0x14, 0x01, 0x0f, 0x0b, "3 Coins 1 Credits" },
3610 {0x14, 0x01, 0x0f, 0x08, "8 Coins 3 Credits" },
3611 {0x14, 0x01, 0x0f, 0x07, "2 Coins 1 Credits" },
3612 {0x14, 0x01, 0x0f, 0x04, "5 Coins 3 Credits" },
3613 {0x14, 0x01, 0x0f, 0x0c, "3 Coins 2 Credits" },
3614 {0x14, 0x01, 0x0f, 0x0f, "1 Coin 1 Credits" },
3615 {0x14, 0x01, 0x0f, 0x02, "2 Coins 3 Credits" },
3616 {0x14, 0x01, 0x0f, 0x09, "1 Coin 2 Credits" },
3617 {0x14, 0x01, 0x0f, 0x01, "1 Coin 3 Credits" },
3618 {0x14, 0x01, 0x0f, 0x0e, "1 Coin 4 Credits" },
3619 {0x14, 0x01, 0x0f, 0x06, "1 Coin 5 Credits" },
3620 {0x14, 0x01, 0x0f, 0x0a, "1 Coin 6 Credits" },
3621 {0x14, 0x01, 0x0f, 0x00, "Free Play" },
3622
3623 {0 , 0xfe, 0 , 4, "Difficulty" },
3624 {0x14, 0x01, 0x30, 0x10, "Easy" },
3625 {0x14, 0x01, 0x30, 0x30, "Normal" },
3626 {0x14, 0x01, 0x30, 0x20, "Hard" },
3627 {0x14, 0x01, 0x30, 0x00, "Hardest" },
3628
3629 {0 , 0xfe, 0 , 2, "Country" },
3630 {0x15, 0x01, 0x80, 0x80, "USA" },
3631 {0x15, 0x01, 0x80, 0x00, "Japan" },
3632 };
3633
3634 STDDIPINFO(Kamenrid)
3635
3636 static struct BurnDIPInfo BlockcarDIPList[]=
3637 {
3638 {0x13, 0xff, 0xff, 0xff, NULL },
3639 {0x14, 0xff, 0xff, 0xff, NULL },
3640 {0x15, 0xff, 0xff, 0xff, NULL },
3641
3642 {0 , 0xfe, 0 , 4, "Difficulty" },
3643 {0x13, 0x01, 0x03, 0x02, "Easy" },
3644 {0x13, 0x01, 0x03, 0x03, "Normal" },
3645 {0x13, 0x01, 0x03, 0x01, "Hard" },
3646 {0x13, 0x01, 0x03, 0x00, "Hardest" },
3647
3648 {0 , 0xfe, 0 , 4, "Bonus Life" },
3649 {0x13, 0x01, 0x0c, 0x0c, "20K, Every 50K" },
3650 {0x13, 0x01, 0x0c, 0x04, "20K, Every 70K" },
3651 {0x13, 0x01, 0x0c, 0x08, "30K, Every 60K" },
3652 {0x13, 0x01, 0x0c, 0x00, "30K, Every 90K" },
3653
3654 {0 , 0xfe, 0 , 4, "Lives" },
3655 {0x13, 0x01, 0x30, 0x00, "1" },
3656 {0x13, 0x01, 0x30, 0x30, "2" },
3657 {0x13, 0x01, 0x30, 0x20, "3" },
3658 {0x13, 0x01, 0x30, 0x10, "4" },
3659
3660 {0 , 0xfe, 0 , 2, "Free Play" },
3661 {0x13, 0x01, 0x80, 0x80, "Off" },
3662 {0x13, 0x01, 0x80, 0x00, "On" },
3663
3664 {0 , 0xfe, 0 , 2, "Flip Screen" },
3665 {0x14, 0x01, 0x02, 0x02, "Off" },
3666 {0x14, 0x01, 0x02, 0x00, "On" },
3667
3668 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3669 {0x14, 0x01, 0x04, 0x00, "Off" },
3670 {0x14, 0x01, 0x04, 0x04, "On" },
3671
3672 {0 , 0xfe, 0 , 4, "Coin A" },
3673 {0x14, 0x01, 0x30, 0x10, "2 Coins 1 Credits" },
3674 {0x14, 0x01, 0x30, 0x30, "1 Coin 1 Credits" },
3675 {0x14, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
3676 {0x14, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
3677
3678 {0 , 0xfe, 0 , 4, "Coin B" },
3679 {0x14, 0x01, 0xc0, 0x40, "2 Coins 1 Credits" },
3680 {0x14, 0x01, 0xc0, 0xc0, "1 Coin 1 Credits" },
3681 {0x14, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
3682 {0x14, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
3683
3684 {0 , 0xfe, 0 , 2, "Title" },
3685 {0x15, 0x01, 0x10, 0x10, "Thunder & Lightning 2" },
3686 {0x15, 0x01, 0x10, 0x00, "Block Carnival" },
3687 };
3688
3689 STDDIPINFO(Blockcar)
3690
3691 static struct BurnDIPInfo ZombraidDIPList[]=
3692 {
3693 {0x0e, 0xff, 0xff, 0xfd, NULL },
3694 {0x0f, 0xff, 0xff, 0xff, NULL },
3695 {0x10, 0xff, 0xff, 0xff, NULL },
3696
3697 {0 , 0xfe, 0 , 2, "Vertical Screen Flip" },
3698 {0x0e, 0x01, 0x01, 0x01, "Off" },
3699 {0x0e, 0x01, 0x01, 0x00, "On" },
3700
3701 {0 , 0xfe, 0 , 2, "Horizontal Screen Flip" },
3702 {0x0e, 0x01, 0x02, 0x00, "Off" },
3703 {0x0e, 0x01, 0x02, 0x02, "On" },
3704
3705 {0 , 0xfe, 0 , 2, "Demo Sounds" },
3706 {0x0e, 0x01, 0x04, 0x00, "Off" },
3707 {0x0e, 0x01, 0x04, 0x04, "On" },
3708
3709 {0 , 0xfe, 0 , 4, "Difficulty" },
3710 {0x0e, 0x01, 0x18, 0x10, "Easy" },
3711 {0x0e, 0x01, 0x18, 0x18, "Normal" },
3712 {0x0e, 0x01, 0x18, 0x08, "Hard" },
3713 {0x0e, 0x01, 0x18, 0x00, "Hardest" },
3714
3715 {0 , 0xfe, 0 , 2, "Allow Continue" },
3716 {0x0e, 0x01, 0x20, 0x00, "Off" },
3717 {0x0e, 0x01, 0x20, 0x20, "On" },
3718
3719 {0 , 0xfe, 0 , 2, "Service Mode" },
3720 {0x0e, 0x01, 0x80, 0x80, "Off" },
3721 {0x0e, 0x01, 0x80, 0x00, "On" },
3722
3723 {0 , 0xfe, 0 , 8, "Coin A" },
3724 {0x0f, 0x01, 0x07, 0x05, "3 Coins 1 Credits" },
3725 {0x0f, 0x01, 0x07, 0x06, "2 Coins 1 Credits" },
3726 {0x0f, 0x01, 0x07, 0x07, "1 Coin 1 Credits" },
3727 {0x0f, 0x01, 0x07, 0x04, "1 Coin 2 Credits" },
3728 {0x0f, 0x01, 0x07, 0x03, "1 Coin 3 Credits" },
3729 {0x0f, 0x01, 0x07, 0x02, "1 Coin 4 Credits" },
3730 {0x0f, 0x01, 0x07, 0x01, "1 Coin 5 Credits" },
3731 {0x0f, 0x01, 0x07, 0x00, "1 Coin 6 Credits" },
3732
3733 {0 , 0xfe, 0 , 8, "Coin B" },
3734 {0x0f, 0x01, 0x38, 0x28, "3 Coins 1 Credits" },
3735 {0x0f, 0x01, 0x38, 0x30, "2 Coins 1 Credits" },
3736 {0x0f, 0x01, 0x38, 0x38, "1 Coin 1 Credits" },
3737 {0x0f, 0x01, 0x38, 0x20, "1 Coin 2 Credits" },
3738 {0x0f, 0x01, 0x38, 0x18, "1 Coin 3 Credits" },
3739 {0x0f, 0x01, 0x38, 0x10, "1 Coin 4 Credits" },
3740 {0x0f, 0x01, 0x38, 0x08, "1 Coin 5 Credits" },
3741 {0x0f, 0x01, 0x38, 0x00, "1 Coin 6 Credits" },
3742
3743 {0 , 0xfe, 0 , 2, "2 Coins to Start, 1 to Continue" },
3744 {0x0f, 0x01, 0x40, 0x40, "No" },
3745 {0x0f, 0x01, 0x40, 0x00, "Yes" },
3746 };
3747
3748 STDDIPINFO(Zombraid)
3749
3750 static struct BurnDIPInfo JockeycDIPList[]=
3751 {
3752 {0x39, 0xff, 0xff, 0xff, NULL },
3753 {0x3a, 0xff, 0xff, 0xff, NULL },
3754 {0x3b, 0xff, 0xff, 0xff, NULL },
3755
3756 {0x3c, 0xff, 0xff, 0xff, NULL },
3757 {0x3d, 0xff, 0xff, 0xff, NULL },
3758 {0x3e, 0xff, 0xff, 0xff, NULL },
3759 {0x3f, 0xff, 0xff, 0xff, NULL },
3760
3761 // dip1
3762 {0 , 0xfe, 0 , 3, "Max Bet" },
3763 {0x39, 0x01, 0x03, 0x03, "10" },
3764 {0x39, 0x01, 0x03, 0x02, "20" },
3765 {0x39, 0x01, 0x03, 0x01, "99" },
3766
3767 {0 , 0xfe, 0 , 8, "Coinage" },
3768 {0x39, 0x01, 0x1c, 0x1c, "1 Coin 1 Credits" },
3769 {0x39, 0x01, 0x1c, 0x18, "1 Coin 2 Credits" },
3770 {0x39, 0x01, 0x1c, 0x14, "1 Coin 3 Credits" },
3771 {0x39, 0x01, 0x1c, 0x10, "1 Coin 4 Credits" },
3772 {0x39, 0x01, 0x1c, 0x0c, "1 Coin 5 Credits" },
3773 {0x39, 0x01, 0x1c, 0x08, "1 Coin/10 Credits" },
3774 {0x39, 0x01, 0x1c, 0x04, "1 Coin/20 Credits" },
3775 {0x39, 0x01, 0x1c, 0x00, "1 Coin/50 Credits" },
3776
3777 // dip2-3
3778 {0 , 0xfe, 0 , 4, "Betting Clock Speed" },
3779 {0x3a, 0x01, 0x18, 0x18, "Slowest" },
3780 {0x3a, 0x01, 0x18, 0x10, "Slower" },
3781 {0x3a, 0x01, 0x18, 0x08, "Faster" },
3782 {0x3a, 0x01, 0x18, 0x00, "Fastest" },
3783
3784 {0 , 0xfe, 0 , 16, "Payout Rate" },
3785 {0x3b, 0x01, 0x01, 0x01, "80%" },
3786 {0x3b, 0x01, 0x01, 0x01, "81%" },
3787 {0x3b, 0x01, 0x01, 0x01, "82%" },
3788 {0x3b, 0x01, 0x01, 0x01, "83%" },
3789 {0x3b, 0x01, 0x01, 0x01, "84%" },
3790 {0x3b, 0x01, 0x01, 0x01, "85%" },
3791 {0x3b, 0x01, 0x01, 0x01, "86%" },
3792 {0x3b, 0x01, 0x01, 0x01, "87%" },
3793 {0x3b, 0x01, 0x01, 0xe0, "88%" },
3794 {0x3b, 0x01, 0x01, 0xc0, "89%" },
3795 {0x3b, 0x01, 0x01, 0xa0, "90%" },
3796 {0x3b, 0x01, 0x01, 0x80, "91%" },
3797 {0x3b, 0x01, 0x01, 0x60, "92%" },
3798 {0x3b, 0x01, 0x01, 0x40, "93%" },
3799 {0x3b, 0x01, 0x01, 0x20, "94%" },
3800 {0x3b, 0x01, 0x01, 0x00, "95%" },
3801
3802 {0 , 0xfe, 0 , 2, "Payout" },
3803 {0x3b, 0x01, 0x04, 0x00, "Off" },
3804 {0x3b, 0x01, 0x04, 0x04, "On" },
3805
3806 {0 , 0xfe, 0 , 2, "Horses" },
3807 {0x3b, 0x01, 0x08, 0x08, "Random" },
3808 {0x3b, 0x01, 0x08, 0x00, "Cyclic" },
3809
3810 {0 , 0xfe, 0 , 2, "Higher Odds" },
3811 {0x3b, 0x01, 0x10, 0x10, "Off" },
3812 {0x3b, 0x01, 0x10, 0x00, "On" },
3813
3814 // overlay on p1/p2
3815 {0 , 0xfe, 0 , 2, "Coin Drop - 1P" },
3816 {0x3c, 0x01, 0x01, 0x01, "Off" },
3817 {0x3c, 0x01, 0x01, 0x00, "On" },
3818
3819 {0 , 0xfe, 0 , 2, "Hopper Overflow - 1P" },
3820 {0x3c, 0x01, 0x02, 0x02, "Off" },
3821 {0x3c, 0x01, 0x02, 0x00, "On" },
3822
3823 {0 , 0xfe, 0 , 2, "Coin Out" },
3824 {0x3c, 0x01, 0x04, 0x00, "Off" },
3825 {0x3c, 0x01, 0x04, 0x04, "On" },
3826
3827 {0 , 0xfe, 0 , 2, "Att Pay - 1P" },
3828 {0x3c, 0x01, 0x08, 0x08, "Off" },
3829 {0x3c, 0x01, 0x08, 0x00, "On" },
3830
3831 {0 , 0xfe, 0 , 2, "Coin Sense 2 - 1P" },
3832 {0x3c, 0x01, 0x40, 0x40, "Off" },
3833 {0x3c, 0x01, 0x40, 0x00, "On" },
3834
3835 {0 , 0xfe, 0 , 2, "Coin Sense 1 - 1P" },
3836 {0x3c, 0x01, 0x80, 0x80, "Off" },
3837 {0x3c, 0x01, 0x80, 0x00, "On" },
3838
3839 {0 , 0xfe, 0 , 2, "Coin Drop - 2P" },
3840 {0x3d, 0x01, 0x01, 0x01, "Off" },
3841 {0x3d, 0x01, 0x01, 0x00, "On" },
3842
3843 {0 , 0xfe, 0 , 2, "Sel Sense" },
3844 {0x3d, 0x01, 0x02, 0x02, "Off" },
3845 {0x3d, 0x01, 0x02, 0x00, "On" },
3846
3847 {0 , 0xfe, 0 , 2, "Att Pay - 2P" },
3848 {0x3d, 0x01, 0x08, 0x08, "Off" },
3849 {0x3d, 0x01, 0x08, 0x00, "On" },
3850
3851 {0 , 0xfe, 0 , 2, "Coin Sense 2 - 2P" },
3852 {0x3d, 0x01, 0x40, 0x40, "Off" },
3853 {0x3d, 0x01, 0x40, 0x00, "On" },
3854
3855 {0 , 0xfe, 0 , 2, "Coin Sense 1 - 2P" },
3856 {0x3d, 0x01, 0x80, 0x80, "Off" },
3857 {0x3d, 0x01, 0x80, 0x00, "On" },
3858
3859 // p2
3860 {0 , 0xfe, 0 , 2, "SYSTEM" },
3861 {0x3e, 0x01, 0x02, 0x02, "Off" },
3862 {0x3e, 0x01, 0x02, 0x00, "On" },
3863
3864 {0 , 0xfe, 0 , 2, "Tilt" },
3865 {0x3e, 0x01, 0x08, 0x08, "Off" },
3866 {0x3e, 0x01, 0x08, 0x00, "On" },
3867
3868 {0 , 0xfe, 0 , 2, "Special Test Mode Item?" },
3869 {0x3f, 0x01, 0x04, 0x04, "Off" },
3870 {0x3f, 0x01, 0x04, 0x00, "On" },
3871
3872 {0 , 0xfe, 0 , 2, "Call SW" },
3873 {0x3f, 0x01, 0x08, 0x08, "Off" },
3874 {0x3f, 0x01, 0x08, 0x00, "On" },
3875
3876 {0 , 0xfe, 0 , 2, "Service Mode" },
3877 {0x3f, 0x01, 0x10, 0x10, "Off" },
3878 {0x3f, 0x01, 0x10, 0x00, "On" },
3879
3880 {0 , 0xfe, 0 , 2, "Analyzer" },
3881 {0x3f, 0x01, 0x20, 0x20, "Off" },
3882 {0x3f, 0x01, 0x20, 0x00, "On" },
3883 };
3884
3885 STDDIPINFO(Jockeyc)
3886
3887 // d_seta2.cpp
3888 //void __fastcall setaSoundRegWriteByte(UINT32 sekAddress, UINT8 byteValue);
3889 void __fastcall setaSoundRegWriteWord(UINT32 sekAddress, UINT16 wordValue);
3890 //UINT8 __fastcall setaSoundRegReadByte(UINT32 sekAddress);
3891 UINT16 __fastcall setaSoundRegReadWord(UINT32 sekAddress);
3892
3893 // these should probably be moved to x1010.cpp
setaSoundRegReadByte(UINT32 sekAddress)3894 static UINT8 __fastcall setaSoundRegReadByte(UINT32 sekAddress)
3895 {
3896 if (~sekAddress & 1) {
3897 return x1_010_chip->HI_WORD_BUF[(sekAddress & 0x3fff) >> 1];
3898 } else {
3899 return x1010_sound_read_word((sekAddress & 0x3fff) >> 1);
3900 }
3901 }
3902
setaSoundRegWriteByte(UINT32 sekAddress,UINT8 byteValue)3903 static void __fastcall setaSoundRegWriteByte(UINT32 sekAddress, UINT8 byteValue)
3904 {
3905 UINT32 offset = (sekAddress & 0x00003fff) >> 1;
3906 INT32 channel, reg;
3907
3908 if (~sekAddress & 1) {
3909 x1_010_chip->HI_WORD_BUF[ offset ] = byteValue;
3910 } else {
3911 offset ^= x1_010_chip->address;
3912 channel = offset / sizeof(X1_010_CHANNEL);
3913 reg = offset % sizeof(X1_010_CHANNEL);
3914
3915 if (channel < SETA_NUM_CHANNELS && reg == 0 && (x1_010_chip->reg[offset] & 1) == 0 && (byteValue&1) != 0) {
3916 x1_010_chip->smp_offset[channel] = 0;
3917 x1_010_chip->env_offset[channel] = 0;
3918 }
3919 x1_010_chip->reg[offset] = byteValue;
3920 }
3921 }
3922
setaSoundRegWriteByte8bit(UINT32 sekAddress,UINT8 byteValue)3923 static void __fastcall setaSoundRegWriteByte8bit(UINT32 sekAddress, UINT8 byteValue)
3924 {
3925 UINT32 offset = (sekAddress & 0x00003fff);
3926 INT32 channel, reg;
3927 //bprintf(0, _T("8bit addy %X offset %X byte %X. "), x1_010_chip->address, offset, byteValue);
3928 offset ^= x1_010_chip->address;
3929 channel = offset / sizeof(X1_010_CHANNEL);
3930 reg = offset % sizeof(X1_010_CHANNEL);
3931
3932 if (channel < SETA_NUM_CHANNELS && reg == 0 && (x1_010_chip->reg[offset] & 1) == 0 && (byteValue&1) != 0) {
3933 x1_010_chip->smp_offset[channel] = 0;
3934 x1_010_chip->env_offset[channel] = 0;
3935 }
3936 x1_010_chip->reg[offset] = byteValue;
3937 }
3938
set_pcm_bank(INT32 data)3939 static void set_pcm_bank(INT32 data)
3940 {
3941 INT32 new_bank = (data >> 3) & 0x07;
3942
3943 if (new_bank != seta_samples_bank)
3944 {
3945 INT32 samples_len = DrvROMLen[3];
3946 //bprintf(0, _T("seta_samples_bank[%X] new_bank[%X] samples_len[%x]\n"), seta_samples_bank, new_bank, samples_len);
3947 seta_samples_bank = data;
3948
3949 if (samples_len == 0x240000 || samples_len == 0x1c0000 || samples_len == 0x80000) // eightfrc, blandia
3950 {
3951 INT32 addr = 0x40000 * new_bank;
3952 if (new_bank >= 3) addr += 0x40000;
3953
3954 if ((samples_len > 0x100000) && ((addr + 0x40000) <= samples_len)) {
3955 memcpy(DrvSndROM + 0xc0000, DrvSndROM + addr, 0x40000);
3956 }
3957 }
3958 else if (samples_len == 0x400000) // zombraid
3959 {
3960 if (new_bank == 0) new_bank = 1;
3961 INT32 addr = 0x80000 * new_bank;
3962 if (new_bank > 0) addr += 0x80000;
3963
3964 memcpy (DrvSndROM + 0x80000, DrvSndROM + addr, 0x80000);
3965 }
3966 }
3967 }
3968
3969 //-----------------------------------------------------------------------------------------------------------------------------------
3970 // macros
3971
3972 #define SetaVidRAMCtrlWriteWord(num, base) \
3973 if ((address >= (base + 0)) && address <= (base + 5)) { \
3974 *((UINT16*)(DrvVIDCTRLRAM##num + (address & 0x06))) = BURN_ENDIAN_SWAP_INT16(data); \
3975 return; \
3976 }
3977
3978 #define SetaVidRAMCtrlWriteByte(num, base) \
3979 if ((address >= (base + 0)) && (address <= (base + 5))) { \
3980 DrvVIDCTRLRAM##num[(address & 0x07)^1] = data; \
3981 return; \
3982 }
3983
3984 #define SetVidRAMRegsWriteWord(base) \
3985 if ((address >= (base + 0)) && (address <= (base + 5))) { \
3986 *((UINT16*)(DrvVideoRegs + (address & 0x06))) = BURN_ENDIAN_SWAP_INT16(data); \
3987 if ((address - base) == 0) x1010Enable(data & 0x20); \
3988 if ((address - base) == 2) set_pcm_bank(data); \
3989 return; \
3990 }
3991
3992 #define SetVidRAMRegsWriteByte(base) \
3993 if ((address >= (base + 0)) && (address <= (base + 5))) { \
3994 DrvVideoRegs[(address & 0x07)^1] = data; \
3995 return; \
3996 }
3997
3998 #define SetaReadDips(base) \
3999 if (address >= (base + 0) && address <= (base + 3)) { \
4000 return DrvDips[((address - base)/2)^1]; \
4001 }
4002
4003 //-----------------------------------------------------------------------------------------------------------------------------------
4004 // drgnunit
4005
drgnunit_read_word(UINT32 address)4006 static UINT16 __fastcall drgnunit_read_word(UINT32 address)
4007 {
4008 SetaReadDips(0x600000)
4009
4010 switch (address)
4011 {
4012 case 0xb00000:
4013 return DrvInputs[0];
4014
4015 case 0xb00002:
4016 return DrvInputs[1];
4017
4018 case 0xb00004:
4019 return DrvInputs[2]^0xff^DrvDips[2];
4020 }
4021
4022 return 0;
4023 }
4024
drgnunit_read_byte(UINT32 address)4025 static UINT8 __fastcall drgnunit_read_byte(UINT32 address)
4026 {
4027 SetaReadDips(0x600000)
4028
4029 switch (address)
4030 {
4031 case 0xb00000:
4032 case 0xb00001:
4033 return DrvInputs[0];
4034
4035 case 0xb00002:
4036 case 0xb00003:
4037 return DrvInputs[1];
4038
4039 case 0xb00004:
4040 case 0xb00005:
4041 return DrvInputs[2]^0xff^DrvDips[2];
4042 }
4043
4044 return 0;
4045 }
4046
drgnunit_write_word(UINT32 address,UINT16 data)4047 static void __fastcall drgnunit_write_word(UINT32 address, UINT16 data)
4048 {
4049 SetaVidRAMCtrlWriteWord(0, 0x800000)
4050
4051 SetVidRAMRegsWriteWord(0x500000)
4052 }
4053
drgnunit_write_byte(UINT32 address,UINT8 data)4054 static void __fastcall drgnunit_write_byte(UINT32 address, UINT8 data)
4055 {
4056 SetaVidRAMCtrlWriteByte(0, 0x800000)
4057
4058 SetVidRAMRegsWriteByte(0x500000)
4059 }
4060
4061 //-----------------------------------------------------------------------------------------------------------------------------------
4062 // thunderl, wits
4063
thunderl_read_word(UINT32 address)4064 static UINT16 __fastcall thunderl_read_word(UINT32 address)
4065 {
4066 SetaReadDips(0x600000)
4067
4068 switch (address)
4069 {
4070 case 0xb00000:
4071 case 0xb00001:
4072 return DrvInputs[0];
4073
4074 case 0xb00002:
4075 case 0xb00003:
4076 return DrvInputs[1];
4077
4078 case 0xb00004:
4079 case 0xb00005:
4080 return DrvInputs[2]^0xff^DrvDips[2];
4081
4082 case 0xb00008:
4083 case 0xb00009:
4084 return DrvInputs[3];
4085
4086 case 0xb0000a:
4087 case 0xb0000b:
4088 return DrvInputs[4];
4089
4090 case 0xb0000c:
4091 case 0xb0000d:
4092 return 0x00dd;// thunderl_prot
4093 }
4094
4095 return 0;
4096 }
4097
thunderl_read_byte(UINT32 address)4098 static UINT8 __fastcall thunderl_read_byte(UINT32 address)
4099 {
4100 SetaReadDips(0x600000)
4101
4102 switch (address)
4103 {
4104 case 0xb00000:
4105 case 0xb00001:
4106 return DrvInputs[0];
4107
4108 case 0xb00002:
4109 case 0xb00003:
4110 return DrvInputs[1];
4111
4112 case 0xb00004:
4113 case 0xb00005:
4114 return DrvInputs[2]^0xff^DrvDips[2];
4115
4116 case 0xb00008:
4117 case 0xb00009:
4118 return DrvInputs[3];
4119
4120 case 0xb0000a:
4121 case 0xb0000b:
4122 return DrvInputs[4];
4123
4124 case 0xb0000c:
4125 case 0xb0000d:
4126 return 0xdd;// thunderl_prot
4127 }
4128
4129 return 0;
4130 }
4131
thunderl_write_word(UINT32 address,UINT16 data)4132 static void __fastcall thunderl_write_word(UINT32 address, UINT16 data)
4133 {
4134 SetVidRAMRegsWriteWord(0x500000)
4135 }
4136
thunderl_write_byte(UINT32 address,UINT8 data)4137 static void __fastcall thunderl_write_byte(UINT32 address, UINT8 data)
4138 {
4139 SetVidRAMRegsWriteByte(0x500000)
4140 }
4141
4142 //-----------------------------------------------------------------------------------------------------------------------------------
4143 // daioh
4144
daioh_read_word(UINT32 address)4145 static UINT16 __fastcall daioh_read_word(UINT32 address)
4146 {
4147 SetaReadDips(0x300000)
4148 SetaReadDips(0x400008)
4149 SetaReadDips(0x600000)
4150
4151 switch (address)
4152 {
4153 case 0x400000:
4154 return DrvInputs[0];
4155
4156 case 0x400002:
4157 return DrvInputs[1];
4158
4159 case 0x400004:
4160 return DrvInputs[2]^0xff^DrvDips[2];
4161
4162 case 0x40000c:
4163 watchdog = 0;
4164 return 0xff;
4165
4166 case 0x500006:
4167 return DrvInputs[3];
4168 }
4169
4170 return 0;
4171 }
4172
daioh_read_byte(UINT32 address)4173 static UINT8 __fastcall daioh_read_byte(UINT32 address)
4174 {
4175 SetaReadDips(0x300000)
4176 SetaReadDips(0x400008)
4177 SetaReadDips(0x600000)
4178
4179 switch (address)
4180 {
4181 case 0x400000:
4182 case 0x400001:
4183 return DrvInputs[0];
4184
4185 case 0x400002:
4186 case 0x400003:
4187 return DrvInputs[1];
4188
4189 case 0x400004:
4190 case 0x400005:
4191 return DrvInputs[2]^0xff^DrvDips[2];
4192
4193 case 0x40000c:
4194 case 0x40000d:
4195 watchdog = 0;
4196 return 0xff;
4197
4198 case 0x500006:
4199 case 0x500007:
4200 return DrvInputs[3];
4201 }
4202
4203 return 0;
4204 }
4205
daioh_write_word(UINT32 address,UINT16 data)4206 static void __fastcall daioh_write_word(UINT32 address, UINT16 data)
4207 {
4208 SetVidRAMRegsWriteWord(0x500000)
4209
4210 SetaVidRAMCtrlWriteWord(0, 0x900000) // blandiap
4211 if (!daiohc) {
4212 SetaVidRAMCtrlWriteWord(0, 0x908000) // jjsquawkb
4213 SetaVidRAMCtrlWriteWord(0, 0xa00000) // blandia
4214 }
4215
4216 SetaVidRAMCtrlWriteWord(1, 0x980000) // blandiap
4217 if (!daiohc) {
4218 SetaVidRAMCtrlWriteWord(1, 0x909000) // jjsquawkb
4219 SetaVidRAMCtrlWriteWord(1, 0xa80000) // blandia
4220 }
4221
4222 switch (address)
4223 {
4224 case 0x400000:
4225 case 0x40000c:
4226 watchdog = 0;
4227 return;
4228 }
4229 }
4230
daioh_write_byte(UINT32 address,UINT8 data)4231 static void __fastcall daioh_write_byte(UINT32 address, UINT8 data)
4232 {
4233 SetVidRAMRegsWriteByte(0x500000)
4234
4235 SetaVidRAMCtrlWriteByte(0, 0x900000) // blandiap
4236 if (!daiohc) {
4237 SetaVidRAMCtrlWriteByte(0, 0x908000) // jjsquawkb
4238 SetaVidRAMCtrlWriteByte(0, 0xa00000) // blandia
4239 }
4240
4241 SetaVidRAMCtrlWriteByte(1, 0x980000) // blandiap
4242 if (!daiohc) {
4243 SetaVidRAMCtrlWriteByte(1, 0x909000) // jjsquawkb
4244 SetaVidRAMCtrlWriteByte(1, 0xa80000) // blandia
4245 }
4246
4247 switch (address)
4248 {
4249 case 0x400000:
4250 case 0x400001:
4251 case 0x40000c:
4252 case 0x40000d:
4253 watchdog = 0;
4254 return;
4255 }
4256 }
4257
4258 //-----------------------------------------------------------------------------------------------------------------------------------
4259 // msgundam
4260
msgundam_write_word(UINT32 address,UINT16 data)4261 static void __fastcall msgundam_write_word(UINT32 address, UINT16 data)
4262 {
4263 SetaVidRAMCtrlWriteWord(0, 0xb00000)
4264 SetaVidRAMCtrlWriteWord(1, 0xb80000)
4265
4266 switch (address)
4267 {
4268 case 0x500000:
4269 case 0x500001:
4270 *((UINT16*)(DrvVideoRegs + 0)) = data;
4271 return;
4272 case 0x500002:
4273 case 0x500003:
4274 *((UINT16*)(DrvVideoRegs + 4)) = data;
4275 return;
4276
4277 case 0x500004:
4278 case 0x500005:
4279 *((UINT16*)(DrvVideoRegs + 2)) = data;
4280 return;
4281 }
4282 }
4283
msgundam_write_byte(UINT32 address,UINT8 data)4284 static void __fastcall msgundam_write_byte(UINT32 address, UINT8 data)
4285 {
4286 SetaVidRAMCtrlWriteByte(0, 0xb00000)
4287 SetaVidRAMCtrlWriteByte(1, 0xb80000)
4288
4289 switch (address)
4290 {
4291 case 0x500000:
4292 case 0x500001:
4293 DrvVideoRegs[(~address & 0x01) | 0] = data;
4294 return;
4295
4296 case 0x500002:
4297 case 0x500003:
4298 DrvVideoRegs[(~address & 0x01) | 4] = data;
4299 return;
4300
4301 case 0x500004:
4302 case 0x500005:
4303 DrvVideoRegs[(~address & 0x01) | 2] = data;
4304 // seta_vregs_w
4305 return;
4306 }
4307 }
4308
4309 //-----------------------------------------------------------------------------------------------------------------------------------
4310 // kamenrid
4311
kamenrid_read_word(UINT32 address)4312 static UINT16 __fastcall kamenrid_read_word(UINT32 address)
4313 {
4314 SetaReadDips(0x500004)
4315
4316 switch (address)
4317 {
4318 case 0x500000:
4319 return DrvInputs[0];
4320
4321 case 0x500002:
4322 return DrvInputs[1];
4323
4324 case 0x500008:
4325 return DrvInputs[2]^0xff^DrvDips[2];
4326
4327 case 0x50000c:
4328 return 0xffff; // watchdog
4329 }
4330
4331 return 0;
4332 }
4333
kamenrid_read_byte(UINT32 address)4334 static UINT8 __fastcall kamenrid_read_byte(UINT32 address)
4335 {
4336 SetaReadDips(0x500004)
4337
4338 switch (address)
4339 {
4340 case 0x500000:
4341 case 0x500001:
4342 return DrvInputs[0];
4343
4344 case 0x500002:
4345 case 0x500003:
4346 return DrvInputs[1];
4347
4348 case 0x500008:
4349 case 0x500009:
4350 return DrvInputs[2]^0xff^DrvDips[2];
4351
4352 case 0x50000c:
4353 case 0x50000d:
4354 return 0xff; // watchdog
4355 }
4356
4357 return 0;
4358 }
4359
4360 //-----------------------------------------------------------------------------------------------------------------------------------
4361 // krzybowl, madshark
4362
trackball_input_tick()4363 static void trackball_input_tick() // krzybowl, usclssic
4364 {
4365 INT32 padx = ProcessAnalog(DrvAnalogPort0, 1, 1, 0x01, 0xff) - 0x7f;
4366 if (padx > 0 && padx < 8) padx = 0;
4367
4368 if (usclssic) {
4369 padx /= 16;
4370 track_x -= padx;
4371 if (padx) track_x_last = padx;
4372 if (!padx) {
4373 track_x = 0; track_x_last = 0; // PORT_RESET
4374 }
4375 } else { // krzybowl
4376 track_x += padx;
4377 }
4378
4379 INT32 pady = ProcessAnalog(DrvAnalogPort1, 1, 1, 0x01, 0xff) - 0x7f;
4380 if (pady > 0 && pady < 8) pady = 0;
4381 if (usclssic) {
4382 pady /= 16;
4383 track_y -= pady;
4384 if (pady) track_y_last = pady;
4385 if (!pady) {
4386 track_y = 0; track_y_last = 0; // PORT_RESET
4387 }
4388 } else { // krzybowl
4389 track_y += pady;
4390 }
4391
4392 padx = ProcessAnalog(DrvAnalogPort2, 1, 1, 0x01, 0xff) - 0x7f;
4393 if (padx > 0 && padx < 8) padx = 0;
4394
4395 if (usclssic) {
4396 padx /= 16;
4397 track_x2 -= padx;
4398 if (padx) track_x2_last = padx;
4399 if (!padx) {
4400 track_x2 = 0; track_x2_last = 0; // PORT_RESET
4401 }
4402 } else { // krzybowl
4403 track_x2 += padx;
4404 }
4405
4406 pady = ProcessAnalog(DrvAnalogPort3, 1, 1, 0x01, 0xff) - 0x7f;
4407 if (pady > 0 && pady < 8) pady = 0;
4408 if (usclssic) {
4409 pady /= 16;
4410 track_y2 -= pady;
4411 if (pady) track_y2_last = pady;
4412 if (!pady) {
4413 track_y2 = 0; track_y2_last = 0; // PORT_RESET
4414 }
4415 } else { // krzybowl
4416 track_y2 += pady;
4417 }
4418 }
4419
krzybowl_input_read(INT32 offset)4420 static UINT16 krzybowl_input_read(INT32 offset)
4421 {
4422 INT32 dir1x = track_x & 0xfff;
4423 INT32 dir1y = track_y & 0xfff;
4424 INT32 dir2x = track_x2 & 0xfff;
4425 INT32 dir2y = track_y2 & 0xfff;
4426
4427 switch (offset / 2)
4428 {
4429 case 0x0/2: return dir1x & 0xff;
4430 case 0x2/2: return dir1x >> 8;
4431 case 0x4/2: return dir1y & 0xff;
4432 case 0x6/2: return dir1y >> 8;
4433 case 0x8/2: return dir2x & 0xff;
4434 case 0xa/2: return dir2x >> 8;
4435 case 0xc/2: return dir2y & 0xff;
4436 case 0xe/2: return dir2y >> 8;
4437 }
4438
4439 return 0;
4440 }
4441
madshark_read_word(UINT32 address)4442 static UINT16 __fastcall madshark_read_word(UINT32 address)
4443 {
4444 SetaReadDips(0x300000)
4445 SetaReadDips(0x500008)
4446
4447 switch (address)
4448 {
4449 case 0x500000:
4450 return DrvInputs[0];
4451
4452 case 0x500002:
4453 return DrvInputs[1];
4454
4455 case 0x500004:
4456 return DrvInputs[2]^0xff^DrvDips[2];
4457
4458 case 0x50000c:
4459 watchdog = 0;
4460 return 0xffff;
4461 }
4462
4463 if ((address & ~0x00000f) == 0x600000) {
4464 return krzybowl_input_read(address&0xf);
4465 }
4466
4467 return 0;
4468 }
4469
madshark_read_byte(UINT32 address)4470 static UINT8 __fastcall madshark_read_byte(UINT32 address)
4471 {
4472 SetaReadDips(0x300000)
4473 SetaReadDips(0x500008)
4474
4475 switch (address)
4476 {
4477 case 0x500000:
4478 return DrvInputs[0] >> 8;
4479 case 0x500001:
4480 return DrvInputs[0] & 0xff;
4481
4482 case 0x500002:
4483 return DrvInputs[1] >> 8;
4484 case 0x500003:
4485 return DrvInputs[1] & 0xff;
4486
4487 case 0x500004:
4488 case 0x500005:
4489 return DrvInputs[2]^0xff^DrvDips[2];
4490
4491 case 0x50000c:
4492 case 0x50000d:
4493 watchdog = 0;
4494 return 0xff;
4495 }
4496
4497 if ((address & ~0x00000f) == 0x600000) {
4498 return krzybowl_input_read(address&0xf);
4499 }
4500
4501 return 0;
4502 }
4503
madshark_write_word(UINT32 address,UINT16 data)4504 static void __fastcall madshark_write_word(UINT32 address, UINT16 data)
4505 {
4506 SetVidRAMRegsWriteWord(0x600000)
4507 SetaVidRAMCtrlWriteWord(0, 0x900000)
4508 SetaVidRAMCtrlWriteWord(1, 0x980000)
4509
4510 switch (address)
4511 {
4512 case 0x50000c:
4513 watchdog = 0;
4514 return;
4515 }
4516 }
4517
madshark_write_byte(UINT32 address,UINT8 data)4518 static void __fastcall madshark_write_byte(UINT32 address, UINT8 data)
4519 {
4520 SetVidRAMRegsWriteByte(0x600000)
4521 SetaVidRAMCtrlWriteByte(0, 0x900000)
4522 SetaVidRAMCtrlWriteByte(1, 0x980000)
4523
4524 switch (address)
4525 {
4526 case 0x50000c:
4527 case 0x50000d:
4528 watchdog = 0;
4529 return;
4530 }
4531 }
4532
4533 //-----------------------------------------------------------------------------------------------------------------------------------
4534 // keroppi, pairlove
4535
4536 static INT32 keroppi_prize_hop = 0;
4537 static INT32 keroppi_protection_count = 0;
4538 static INT32 keroppi_timer_frame = -1;
4539 static const UINT16 keroppi_protection_word[] = {
4540 0x0000,
4541 0x0000, 0x0000, 0x0000,
4542 0x2000, 0x2000, 0x2000,
4543 0x2000, 0x2000, 0x2000,
4544 0x0400, 0x0400, 0x0400,
4545 0x0000, 0x0000, 0x0000
4546 };
4547
4548 static UINT16 pairslove_protram[0x100];
4549 static UINT16 pairslove_protram_old[0x100];
4550
keroppi_pairslove_scan()4551 static void keroppi_pairslove_scan()
4552 {
4553 SCAN_VAR(keroppi_prize_hop);
4554 SCAN_VAR(keroppi_protection_count);
4555 SCAN_VAR(keroppi_timer_frame);
4556 SCAN_VAR(pairslove_protram);
4557 SCAN_VAR(pairslove_protram_old);
4558 }
4559
pairlove_read_word(UINT32 address)4560 static UINT16 __fastcall pairlove_read_word(UINT32 address)
4561 {
4562 SetaReadDips(0x300000)
4563
4564 switch (address)
4565 {
4566 case 0x100000: { // keroppi
4567 INT32 res = keroppi_protection_word[keroppi_protection_count];
4568 keroppi_protection_count++;
4569 if (keroppi_protection_count > 15) keroppi_protection_count = 15;
4570 return res;
4571 }
4572
4573 case 0x200000: // keroppi
4574 keroppi_protection_count = 0;
4575 return 0x00;
4576
4577 case 0x500000:
4578 return DrvInputs[0];
4579
4580 case 0x500002:
4581 return DrvInputs[1];
4582
4583 case 0x500004: {
4584 INT32 res = DrvInputs[2]^0xff^DrvDips[2];
4585
4586 if (keroppi_prize_hop == 1 && keroppi_timer_frame != -1) {
4587 if ((GetCurrentFrame() - keroppi_timer_frame) >= 3) {
4588 keroppi_prize_hop = 2;
4589 keroppi_timer_frame = - 1;
4590 }
4591 }
4592
4593 if (keroppi_prize_hop == 2) {
4594 res &= ~0x0002;
4595 keroppi_prize_hop = 0;
4596 }
4597 return res;
4598 }
4599 }
4600
4601 if ((address & 0xfffffe00) == 0x900000) {
4602 INT32 offset = (address & 0x1ff) / 2;
4603
4604 INT32 retdata = pairslove_protram[offset];
4605 pairslove_protram[offset]=pairslove_protram_old[offset];
4606 return retdata;
4607 }
4608
4609 return 0;
4610 }
4611
pairlove_read_byte(UINT32 address)4612 static UINT8 __fastcall pairlove_read_byte(UINT32 address)
4613 {
4614 SetaReadDips(0x300000)
4615
4616 switch (address)
4617 {
4618 case 0x100000: // keroppi
4619 case 0x100001: {
4620 INT32 res = keroppi_protection_word[keroppi_protection_count];
4621 keroppi_protection_count++;
4622 if (keroppi_protection_count > 15) keroppi_protection_count = 15;
4623 return res;
4624 }
4625
4626 case 0x200000:
4627 case 0x200001: // keroppi
4628 keroppi_protection_count = 0;
4629 return 0x00;
4630
4631 case 0x500000:
4632 case 0x500001:
4633 return DrvInputs[0];
4634
4635 case 0x500002:
4636 case 0x500003:
4637 return DrvInputs[1];
4638
4639 case 0x500004:
4640 case 0x500005: {
4641 INT32 res = DrvInputs[2]^0xff^DrvDips[2];
4642
4643 if (keroppi_prize_hop == 1 && keroppi_timer_frame != -1) {
4644 if ((GetCurrentFrame() - keroppi_timer_frame) >= 3) {
4645 keroppi_prize_hop = 2;
4646 keroppi_timer_frame = -1;
4647 }
4648 }
4649
4650 if (keroppi_prize_hop == 2) {
4651 res &= ~0x0002;
4652 keroppi_prize_hop = 0;
4653 }
4654 return res;
4655 }
4656 }
4657
4658 if ((address & 0xfffffe00) == 0x900000) {
4659 INT32 offset = (address & 0x1ff) / 2;
4660 INT32 retdata = pairslove_protram[offset];
4661 pairslove_protram[offset]=pairslove_protram_old[offset];
4662 return retdata;
4663 }
4664
4665 return 0;
4666 }
4667
pairlove_write_word(UINT32 address,UINT16 data)4668 static void __fastcall pairlove_write_word(UINT32 address, UINT16 data)
4669 {
4670 SetVidRAMRegsWriteWord(0x400000)
4671
4672 switch (address)
4673 {
4674 case 0x900002: // keroppi
4675 if ((data & 0x0010) && !keroppi_prize_hop) {
4676 keroppi_prize_hop = 1;
4677 keroppi_timer_frame = GetCurrentFrame();
4678 }
4679 break; // for pairslove prot
4680 }
4681
4682 if ((address & 0xfffffe00) == 0x900000) {
4683 INT32 offset = (address & 0x1ff) / 2;
4684 pairslove_protram_old[offset]=pairslove_protram[offset];
4685 pairslove_protram[offset]=data;
4686 return;
4687 }
4688 }
4689
pairlove_write_byte(UINT32 address,UINT8 data)4690 static void __fastcall pairlove_write_byte(UINT32 address, UINT8 data)
4691 {
4692 SetVidRAMRegsWriteByte(0x400000)
4693
4694 switch (address)
4695 {
4696 case 0x900002:
4697 case 0x900003: // keroppi
4698 if ((data & 0x0010) && !keroppi_prize_hop) {
4699 keroppi_prize_hop = 1;
4700 keroppi_timer_frame = GetCurrentFrame();
4701 }
4702 break; // for pairslove prot
4703 }
4704
4705 if ((address & 0xfffffe00) == 0x900000) {
4706 INT32 offset = (address & 0x1ff) / 2;
4707 pairslove_protram_old[offset]=pairslove_protram[offset];
4708 pairslove_protram[offset]=data;
4709 return;
4710 }
4711 }
4712
4713 //-----------------------------------------------------------------------------------------------------------------------------------
4714 // downtown, metafox, twineagl, arbelester
4715
downtown_write_word(UINT32 address,UINT16 data)4716 static void __fastcall downtown_write_word(UINT32 address, UINT16 data)
4717 {
4718 SetaVidRAMCtrlWriteWord(0, 0x800000)
4719
4720 switch (address)
4721 {
4722 case 0x400000:
4723 case 0x400002:
4724 case 0x400004:
4725 case 0x400006:
4726 // tilebank[(address & 6) / 2] = data;
4727 return;
4728
4729 case 0xa00000:
4730 case 0xa00002:
4731 case 0xa00004:
4732 case 0xa00006: bprintf(0, _T("sub ctrlW unimpl. %X\n"), address);
4733 // sub_ctrl_w
4734 return;
4735 }
4736 }
4737
sub_ctrl_w(INT32 offset,UINT8 data)4738 static void sub_ctrl_w(INT32 offset, UINT8 data)
4739 {
4740 switch(offset)
4741 {
4742 case 0: // bit 0: reset sub cpu?
4743 {
4744 if ( !(sub_ctrl_data & 1) && (data & 1) )
4745 {
4746 M6502Open(0);
4747 M6502Reset();
4748 M6502Close();
4749 }
4750 sub_ctrl_data = data;
4751 }
4752 break;
4753
4754 case 2: // ?
4755 break;
4756
4757 case 4: // not sure
4758 soundlatch = data;
4759 break;
4760
4761 case 6: // not sure
4762 soundlatch2 = data;
4763 break;
4764 }
4765 }
4766
downtown_write_byte(UINT32 address,UINT8 data)4767 static void __fastcall downtown_write_byte(UINT32 address, UINT8 data)
4768 {
4769 SetaVidRAMCtrlWriteByte(0, 0x800000)
4770
4771 switch (address)
4772 {
4773 case 0x400000:
4774 case 0x400001:
4775 case 0x400002:
4776 case 0x400003:
4777 case 0x400004:
4778 case 0x400005:
4779 case 0x400006:
4780 case 0x400007:
4781 tilebank[(address & 6) / 2] = data;
4782 return;
4783
4784 case 0xa00000:
4785 case 0xa00001:
4786 case 0xa00002:
4787 case 0xa00003:
4788 case 0xa00004:
4789 case 0xa00005:
4790 case 0xa00006:
4791 case 0xa00007:
4792 sub_ctrl_w((address&6), data);
4793 return;
4794 }
4795 }
4796
4797 //-----------------------------------------------------------------------------------------------------------------------------------
4798 // kiwame
4799
kiwame_inputs_read(INT32 offset)4800 static INT32 kiwame_inputs_read(INT32 offset)
4801 {
4802 INT32 i;
4803 INT32 row_select = DrvNVRAM[0x10b];
4804
4805 for (i = 0; i < 5; i++)
4806 if (row_select & (1 << i)) break;
4807
4808 switch (offset)
4809 {
4810 case 0: return DrvInputs[i+1];
4811 case 4: return DrvInputs[0]^0xff^DrvDips[2];
4812 case 2:
4813 case 8: return 0xffff;
4814 }
4815
4816 return 0;
4817 }
4818
kiwame_read_word(UINT32 address)4819 static UINT16 __fastcall kiwame_read_word(UINT32 address)
4820 {
4821 switch (address)
4822 {
4823 case 0xe00000:
4824 return DrvDips[1];
4825
4826 case 0xe00002:
4827 return DrvDips[0];
4828 }
4829
4830 if ((address & 0xfffff0) == 0xd00000) {
4831 return kiwame_inputs_read(address & 0x0e);
4832 }
4833 if ((address & 0xfffc00) == 0xfffc00) {
4834 return DrvNVRAM[(address & 0x3fe)];
4835 }
4836
4837 return 0;
4838 }
4839
kiwame_read_byte(UINT32 address)4840 static UINT8 __fastcall kiwame_read_byte(UINT32 address)
4841 {
4842 switch (address)
4843 {
4844 case 0xe00000:
4845 case 0xe00001:
4846 return DrvDips[1];
4847
4848 case 0xe00002:
4849 case 0xe00003:
4850 return DrvDips[0];
4851 }
4852
4853 if ((address & 0xfffff0) == 0xd00000) {
4854 return kiwame_inputs_read(address & 0x0e);
4855 }
4856
4857 if ((address & 0xfffc01) == 0xfffc01) {
4858 return DrvNVRAM[(address & 0x3fe)];
4859 }
4860
4861 return 0;
4862 }
4863
4864 //-----------------------------------------------------------------------------------------------------------------------------------
4865 // zombraid gun handler
4866
zombraid_gun_read()4867 static INT32 zombraid_gun_read()
4868 {
4869 return (DrvAnalogInput[gun_input_src] >> gun_input_bit) & 1;
4870 }
4871
zombraid_gun_write(INT32 data)4872 static void zombraid_gun_write(INT32 data)
4873 {
4874 static INT32 bit_count = 0, old_clock = 0;
4875
4876 if(data&4) { bit_count = 0; return; } // Reset
4877
4878 if((data&1) == old_clock) return; // No change
4879
4880 if (old_clock == 0) // Rising edge
4881 {
4882 switch (bit_count)
4883 {
4884 case 0:
4885 case 1: // Starting sequence 2,3,2,3. Other inputs?
4886 break;
4887
4888 case 2: // First bit of source
4889 gun_input_src = (gun_input_src&2) | (data>>1);
4890 break;
4891
4892 case 3: // Second bit of source
4893 gun_input_src = (gun_input_src&1) | (data&2);
4894 break;
4895
4896 default:
4897 // "Player1_Gun_Recoil", (data & 0x10)>>4
4898 // "Player2_Gun_Recoil", (data & 0x08)>>3
4899 gun_input_bit = bit_count - 4;
4900 gun_input_bit = 8 - gun_input_bit; // Reverse order
4901 break;
4902 }
4903 bit_count++;
4904 }
4905
4906 old_clock = data & 1;
4907 }
4908
zombraid_gun_write_word(UINT32 address,UINT16 data)4909 static void __fastcall zombraid_gun_write_word(UINT32 address, UINT16 data)
4910 {
4911 if ((address & ~1) == 0xf00000) zombraid_gun_write(data);
4912 }
4913
zombraid_gun_write_byte(UINT32 address,UINT8 data)4914 static void __fastcall zombraid_gun_write_byte(UINT32 address, UINT8 data)
4915 {
4916 if ((address & ~1) == 0xf00000) zombraid_gun_write(data);
4917 }
4918
zombraid_gun_read_word(UINT32)4919 static UINT16 __fastcall zombraid_gun_read_word(UINT32 )
4920 {
4921 return zombraid_gun_read();
4922 }
4923
zombraid_gun_read_byte(UINT32)4924 static UINT8 __fastcall zombraid_gun_read_byte(UINT32 )
4925 {
4926 return zombraid_gun_read();
4927 }
4928
4929 //-----------------------------------------------------------------------------------------------------------------------------------
4930 // utoukond sound handler
4931
utoukond_sound_write(UINT16 address,UINT8 data)4932 static void __fastcall utoukond_sound_write(UINT16 address, UINT8 data)
4933 {
4934 if (address >= 0xf000) { // x1_010
4935 setaSoundRegWriteByte8bit(address & 0xfff, data);
4936 return;
4937 }
4938 }
4939
utoukond_sound_read(UINT16 address)4940 static UINT8 __fastcall utoukond_sound_read(UINT16 address)
4941 {
4942 if (address >= 0xf000) {
4943 return x1010_sound_read(address & 0xfff);
4944 }
4945 return 0;
4946 }
4947
utoukond_sound_write_port(UINT16 port,UINT8 data)4948 static void __fastcall utoukond_sound_write_port(UINT16 port, UINT8 data)
4949 {
4950 switch (port & 0xff)
4951 {
4952 case 0x00:
4953 case 0x01:
4954 case 0x02:
4955 case 0x03:
4956 BurnYM3438Write(0, port & 3, data);
4957 return;
4958 }
4959 }
4960
utoukond_sound_read_port(UINT16 port)4961 static UINT8 __fastcall utoukond_sound_read_port(UINT16 port)
4962 {
4963 switch (port & 0xff)
4964 {
4965 case 0x00:
4966 case 0x01:
4967 case 0x02:
4968 case 0x03:
4969 return BurnYM3438Read(0, port & 3);// right?
4970
4971 case 0xc0:
4972 ZetSetIRQLine(0, CPU_IRQSTATUS_NONE);
4973 return soundlatch;
4974 }
4975
4976 return 0;
4977 }
4978
4979 //-----------------------------------------------------------------------------------------------------------------------------------
4980 // wiggie / superbar sound handler
4981
wiggie_sound_write_word(UINT32 a,UINT16 d)4982 static void __fastcall wiggie_sound_write_word(UINT32 a, UINT16 d)
4983 {
4984 bprintf(0, _T("sww %X:%X."),a,d);
4985
4986 }
4987
wiggie_sound_write_byte(UINT32 address,UINT8 data)4988 static void __fastcall wiggie_sound_write_byte(UINT32 address, UINT8 data)
4989 {
4990 soundlatch = data;
4991 ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD);
4992 }
4993
wiggie_sound_write(UINT16 address,UINT8 data)4994 static void __fastcall wiggie_sound_write(UINT16 address, UINT8 data)
4995 {
4996 switch (address)
4997 {
4998 case 0x9800:
4999 MSM6295Write(0, data);
5000 return;
5001 }
5002 }
5003
wiggie_sound_read(UINT16 address)5004 static UINT8 __fastcall wiggie_sound_read(UINT16 address)
5005 {
5006 switch (address)
5007 {
5008 case 0x9800:
5009 return MSM6295Read(0);
5010
5011 case 0xa000:
5012 ZetSetIRQLine(0, CPU_IRQSTATUS_NONE);
5013 return soundlatch;
5014 }
5015
5016 return 0;
5017 }
5018
5019 //-----------------------------------------------------------------------------------------------------------------------------------
5020 // usclssic
5021
usclssic_write_word(UINT32 address,UINT16 data)5022 static void __fastcall usclssic_write_word(UINT32 address, UINT16 data)
5023 {
5024 SetaVidRAMCtrlWriteWord(0, 0xa00000)
5025
5026 switch (address)
5027 {
5028 case 0xb40000:
5029 usclssic_port_select = (data & 0x40) >> 6;
5030 tile_offset[0] = (data & 0x10) << 10;
5031 // coin lockout too...
5032 return;
5033
5034 case 0xb40010:
5035 soundlatch = data;
5036 M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
5037 SekRunEnd();
5038 return;
5039
5040 case 0xb40018:
5041 watchdog = 0;
5042 return;
5043 }
5044 }
5045
usclssic_write_byte(UINT32 address,UINT8 data)5046 static void __fastcall usclssic_write_byte(UINT32 address, UINT8 data)
5047 {
5048 SetaVidRAMCtrlWriteByte(0, 0xa00000)
5049
5050 switch (address)
5051 {
5052 case 0xb40000:
5053 case 0xb40001:
5054 usclssic_port_select = (data & 0x40) >> 6;
5055 tile_offset[0] = (data & 0x10) << 10;
5056 // coin lockout too...
5057 return;
5058
5059 //case 0xb40010:
5060 case 0xb40011:
5061 soundlatch = data;
5062 M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
5063 SekRunEnd();
5064 return;
5065
5066 case 0xb40018:
5067 case 0xb40019:
5068 watchdog = 0;
5069 return;
5070 }
5071 }
5072
uclssic_trackball_read(INT32 offset)5073 static UINT8 uclssic_trackball_read(INT32 offset)
5074 {
5075 UINT16 start_vals[2] = { 0xf000, 0x9000 };
5076 if (!usclssic_port_select) {
5077 start_vals[0] |= track_x&0xfff;
5078 start_vals[1] |= track_y&0xfff;
5079 } else {
5080 start_vals[0] |= track_x2&0xfff;
5081 start_vals[1] |= track_y2&0xfff;
5082 }
5083
5084 UINT16 ret = DrvInputs[1 + ((offset & 4)/4) + (usclssic_port_select * 2)] ^ start_vals[(offset / 4) & 1];
5085
5086 if (offset & 2) ret >>= 8;
5087
5088 return ret ^ 0xff;
5089 }
5090
usclssic_read_word(UINT32 address)5091 static UINT16 __fastcall usclssic_read_word(UINT32 address)
5092 {
5093 switch (address)
5094 {
5095 case 0xb40000:
5096 case 0xb40002:
5097 case 0xb40004:
5098 case 0xb40006:
5099 return uclssic_trackball_read(address);
5100
5101 case 0xb40010:
5102 return (DrvInputs[0] ^ 0xf0) | 0x0f;
5103
5104 case 0xb40018:
5105 return DrvDips[1] & 0x0f;
5106
5107 case 0xb4001a:
5108 return DrvDips[1] >> 4;
5109
5110 case 0xb4001c:
5111 return DrvDips[0] & 0x0f;
5112
5113 case 0xb4001e:
5114 return DrvDips[0] >> 4;
5115 }
5116
5117 return 0;
5118 }
5119
usclssic_read_byte(UINT32 address)5120 static UINT8 __fastcall usclssic_read_byte(UINT32 address)
5121 {
5122 switch (address)
5123 {
5124 case 0xb40000:
5125 case 0xb40001:
5126 case 0xb40002:
5127 case 0xb40003:
5128 case 0xb40004:
5129 case 0xb40005:
5130 case 0xb40006:
5131 case 0xb40007:
5132 return uclssic_trackball_read(address);
5133
5134 //case 0xb40010:
5135 case 0xb40011:
5136 return (DrvInputs[0] ^ 0xf0) | 0x0f;
5137
5138 case 0xb40018:
5139 case 0xb40019:
5140 return DrvDips[1] & 0x0f;
5141
5142 case 0xb4001a:
5143 case 0xb4001b:
5144 return DrvDips[1] >> 4;
5145
5146 case 0xb4001c:
5147 case 0xb4001d:
5148 return DrvDips[0] & 0x0f;
5149
5150 case 0xb4001e:
5151 case 0xb4001f:
5152 return DrvDips[0] >> 4;
5153 }
5154
5155 return 0;
5156 }
5157
5158 //-----------------------------------------------------------------------------------------------------------------------------------
5159 // calibr50
5160
5161 // Rotation-handler code
5162
RotateReset()5163 static void RotateReset() {
5164 for (INT32 playernum = 0; playernum < 2; playernum++) {
5165 nRotate[playernum] = 0; // start out pointing straight up (0=up)
5166 nRotateTarget[playernum] = -1;
5167 nRotateTime[playernum] = 0;
5168 nRotateHoldInput[0] = nRotateHoldInput[1] = 0;
5169 }
5170 }
5171
RotationTimer(void)5172 static UINT32 RotationTimer(void) {
5173 return nCurrentFrame;
5174 }
5175
RotateRight(INT32 * v)5176 static void RotateRight(INT32 *v) {
5177 if (game_rotates == 2) { // downtown mode
5178 (*v)-=1;
5179 if (*v < 0) *v = 0xb;
5180 } else { // calibr50 mode
5181 (*v)-=4;
5182 if (*v < 0) *v = 0x3c;
5183 }
5184 }
5185
RotateLeft(INT32 * v)5186 static void RotateLeft(INT32 *v) {
5187 if (game_rotates == 2) { // downtown mode
5188 (*v)+=1;
5189 if (*v > 0xb) *v = 0;
5190 } else { // calibr50 mode
5191 (*v)+=4;
5192 if (*v > 0x3c) *v = 0;
5193 }
5194 }
5195
Joy2Rotate(UINT8 * joy)5196 static UINT8 Joy2Rotate(UINT8 *joy) { // ugly code, but the effect is awesome. -dink
5197 if (joy[0] && joy[2]) return 7; // up left
5198 if (joy[0] && joy[3]) return 1; // up right
5199
5200 if (joy[1] && joy[2]) return 5; // down left
5201 if (joy[1] && joy[3]) return 3; // down right
5202
5203 if (joy[0]) return 0; // up
5204 if (joy[1]) return 4; // down
5205 if (joy[2]) return 6; // left
5206 if (joy[3]) return 2; // right
5207
5208 return 0xff;
5209 }
5210
dialRotation(INT32 playernum)5211 static int dialRotation(INT32 playernum) {
5212 // p1 = 0, p2 = 1
5213 UINT8 player[2] = { 0, 0 };
5214 static UINT8 lastplayer[2][2] = { { 0, 0 }, { 0, 0 } };
5215
5216 if ((playernum != 0) && (playernum != 1)) {
5217 bprintf(PRINT_NORMAL, _T("Strange Rotation address => %06X\n"), playernum);
5218 return 0;
5219 }
5220 if (playernum == 0) {
5221 player[0] = DrvFakeInput[0]; player[1] = DrvFakeInput[1];
5222 }
5223 if (playernum == 1) {
5224 player[0] = DrvFakeInput[2]; player[1] = DrvFakeInput[3];
5225 }
5226
5227 if (player[0] && (player[0] != lastplayer[playernum][0] || (RotationTimer() > nRotateTime[playernum]+0xf))) {
5228 RotateLeft(&nRotate[playernum]);
5229 bprintf(PRINT_NORMAL, _T("Player %d Rotate Left => %06X\n"), playernum+1, nRotate[playernum]);
5230 nRotateTime[playernum] = RotationTimer();
5231 nRotateTarget[playernum] = -1;
5232 }
5233
5234 if (player[1] && (player[1] != lastplayer[playernum][1] || (RotationTimer() > nRotateTime[playernum]+0xf))) {
5235 RotateRight(&nRotate[playernum]);
5236 bprintf(PRINT_NORMAL, _T("Player %d Rotate Right => %06X\n"), playernum+1, nRotate[playernum]);
5237 nRotateTime[playernum] = RotationTimer();
5238 nRotateTarget[playernum] = -1;
5239 }
5240
5241 lastplayer[playernum][0] = player[0];
5242 lastplayer[playernum][1] = player[1];
5243
5244 return (nRotate[playernum]);
5245 }
5246
5247 static UINT8 *rotate_gunpos[2] = {NULL, NULL};
5248 static UINT8 rotate_gunpos_multiplier = 1;
5249
5250 // Gun-rotation memory locations - do not remove this tag. - dink :)
5251 // game p1 p2 clockwise value in memory multiplier
5252 // downtown 0xffef90+1 0xfefd0+1 0 1 2 3 4 5 6 7 1
5253 //
5254 // calibr50 0xff2500+3 0xff2520+7 0 1 2 3 4 5 6 7 8 9 a b c d e f 2
5255 // ff4ede = 0xff = onplane
5256 // a00010 a00014 = plane rotate regs MMIO INPUTS DUMBASS
5257 // p1 ff0e69 p2 ff0e89? rotate reg.
5258
RotateSetGunPosRAM(UINT8 * p1,UINT8 * p2,UINT8 multiplier)5259 static void RotateSetGunPosRAM(UINT8 *p1, UINT8 *p2, UINT8 multiplier) {
5260 rotate_gunpos[0] = p1;
5261 rotate_gunpos[1] = p2;
5262 rotate_gunpos_multiplier = multiplier;
5263 }
5264
get_distance(INT32 from,INT32 to)5265 static INT32 get_distance(INT32 from, INT32 to) {
5266 // this function finds the shortest way to get from "from" to "to", wrapping at 0 and 7
5267 INT32 countA = 0;
5268 INT32 countB = 0;
5269 INT32 fromtmp = from;// / rotate_gunpos_multiplier;
5270 INT32 totmp = to;// / rotate_gunpos_multiplier;
5271
5272 while (1) {
5273 fromtmp++;
5274 countA++;
5275 if(fromtmp>((game_rotates == 2) ? 0x7 : 0xf)) fromtmp = 0;
5276 if(fromtmp == totmp || countA > 32) break;
5277 }
5278
5279 fromtmp = from;// / rotate_gunpos_multiplier;
5280 totmp = to;// / rotate_gunpos_multiplier;
5281
5282 while (1) {
5283 fromtmp--;
5284 countB++;
5285 if(fromtmp<0) fromtmp = ((game_rotates == 2) ? 0x7 : 0xf);
5286 if(fromtmp == totmp || countB > 32) break;
5287 }
5288
5289 if (countA > countB) {
5290 return 1; // go negative
5291 } else {
5292 return 0; // go positive
5293 }
5294 }
5295
RotateDoTick()5296 static void RotateDoTick() {
5297 // since the game only allows for 1 rotation every other frame, we have to
5298 // do this.
5299 if (nCurrentFrame&1) return;
5300
5301 if (game_rotates == 1) { // calibr50 switcheroo
5302 if (Drv68KRAM[0x4ede] == 0xff) {
5303 // P1/P2 in the airplane
5304 RotateSetGunPosRAM(Drv68KRAM + (0x0e69-1), Drv68KRAM + (0x0e89-1), 2);
5305 } else {
5306 // P1/P2 normal.
5307 RotateSetGunPosRAM(Drv68KRAM + (0x2503-1), Drv68KRAM + (0x2527-1), 2);
5308 }
5309 }
5310
5311 for (INT32 i = 0; i < 2; i++) {
5312 if (rotate_gunpos[i] && (nRotateTarget[i] != -1) && (nRotateTarget[i] != (*rotate_gunpos[i] & 0xff))) {
5313 if (get_distance(nRotateTarget[i], *rotate_gunpos[i] & 0x0f)) {
5314 RotateLeft(&nRotate[i]); // ++
5315 } else {
5316 RotateRight(&nRotate[i]); // --
5317 }
5318 bprintf(0, _T("p%X target %X mempos %X nRotate %X try %X.\n"), i, nRotateTarget[0], *rotate_gunpos[0] & 0xff, nRotate[0], nRotateTry[i]);
5319 nRotateTry[i]++;
5320 if (nRotateTry[i] > 0xf) nRotateTarget[i] = -1; // don't get stuck in a loop if something goes horribly wrong here.
5321 } else {
5322 nRotateTarget[i] = -1;
5323 }
5324 }
5325 }
5326
SuperJoy2Rotate()5327 static void SuperJoy2Rotate() {
5328 for (INT32 i = 0; i < 2; i++) { // p1 = 0, p2 = 1
5329 if (DrvFakeInput[4 + i]) { // rotate-button had been pressed
5330 UINT8 rot = Joy2Rotate(((!i) ? &DrvJoy1[0] : &DrvJoy2[0]));
5331 if (rot != 0xff) {
5332 //bprintf(0, _T("joy2rotate[%x] = %X\n"), i, rot);
5333 nRotateTarget[i] = rot * rotate_gunpos_multiplier;
5334 }
5335 //DrvInput[i] &= ~0xf; // cancel out directionals since they are used to rotate here.
5336 DrvInputs[i] = (DrvInputs[i] & ~0xf) | (nRotateHoldInput[i] & 0xf); // for midnight resistance! be able to duck + change direction of gun.
5337 nRotateTry[i] = 0;
5338 } else { // cache joystick UDLR if the rotate button isn't pressed.
5339 // This feature is for Midnight Resistance, if you are crawling on the
5340 // ground and need to rotate your gun WITHOUT getting up.
5341 nRotateHoldInput[i] = DrvInputs[i];
5342 }
5343 }
5344
5345 RotateDoTick();
5346 }
5347
5348 // end Rotation-handler
5349
calibr50_input_read(INT32 offset)5350 static UINT16 calibr50_input_read(INT32 offset)
5351 {
5352 INT32 dir1 = dialRotation(0); // analog port
5353 INT32 dir2 = dialRotation(1); // analog port
5354
5355 switch (offset & 0x1e)
5356 {
5357 case 0x00: return DrvInputs[0]; // p1
5358 case 0x02: return DrvInputs[1]; // p2
5359 case 0x08: return DrvInputs[2]^0xff^DrvDips[2]; // Coins
5360 case 0x10: return (dir1 & 0xff); // lower 8 bits of p1 rotation
5361 case 0x12: return (dir1 >> 8); // upper 4 bits of p1 rotation
5362 case 0x14: return (dir2 & 0xff); // lower 8 bits of p2 rotation
5363 case 0x16: return (dir2 >> 8); // upper 4 bits of p2 rotation
5364 case 0x18: return 0xffff; // ? (value's read but not used)
5365 }
5366
5367 return 0;
5368 }
5369
calibr50_read_word(UINT32 address)5370 static UINT16 __fastcall calibr50_read_word(UINT32 address)
5371 {
5372 switch (address)
5373 {
5374 case 0x400000:
5375 case 0x400001:
5376 watchdog = 0;
5377 return 0xffff;
5378 }
5379
5380 if ((address & 0xfffffe0) == 0xa00000) {
5381 return calibr50_input_read(address);
5382 }
5383
5384 SetaReadDips(0x600000)
5385
5386 return 0;
5387 }
5388
calibr50_read_byte(UINT32 address)5389 static UINT8 __fastcall calibr50_read_byte(UINT32 address)
5390 {
5391 switch (address)
5392 {
5393 case 0x400000:
5394 case 0x400001:
5395 watchdog = 0;
5396 return 0xff;
5397
5398 case 0xb00000:
5399 case 0xb00001:
5400 return soundlatch2;
5401 }
5402
5403 if ((address & 0xfffffe0) == 0xa00000) {
5404 return calibr50_input_read(address) >> ((~address & 1) << 3);
5405 }
5406
5407 SetaReadDips(0x600000)
5408
5409 return 0;
5410 }
5411
calibr50_write_word(UINT32 address,UINT16 data)5412 static void __fastcall calibr50_write_word(UINT32 address, UINT16 data)
5413 {
5414 SetaVidRAMCtrlWriteWord(0, 0x800000)
5415
5416 if ((address & ~1) == 0xb00000) {
5417 soundlatch = data;
5418
5419 M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
5420 SekRunEnd();
5421
5422 return;
5423 }
5424 //bprintf(0, _T("ww: %X."), address);
5425 }
5426
calibr50_write_byte(UINT32 address,UINT8 data)5427 static void __fastcall calibr50_write_byte(UINT32 address, UINT8 data)
5428 {
5429 SetaVidRAMCtrlWriteByte(0, 0x800000)
5430
5431 if ((address & ~1) == 0xb00000) {
5432 soundlatch = data;
5433
5434 M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
5435 SekRunEnd();
5436
5437 return;
5438 }
5439 //bprintf(0, _T("wb: %X."), address);
5440 }
5441
5442 //-----------------------------------------------------------------------------------------------------------------------------------
5443 // downtown protection handler, m65c02 simulation (metafox, arbelester)
5444
5445 static UINT8 *downtown_protram;
5446
downtown_prot_read(UINT32 address)5447 static UINT8 __fastcall downtown_prot_read(UINT32 address)
5448 {
5449 if (downtown_protram[0xf8] == 0xa3) {
5450 if (address >= 0x200100 && address <= 0x20010b) {
5451 char *waltz = "WALTZ0";
5452 return waltz[(address & 0x0f) / 2];
5453 }
5454 }
5455
5456 return downtown_protram[(address & 0x1ff)^1];
5457 }
5458
5459 // twineagle, downtown, calibr50, tndrcade, arbalester, metafox etc. uses these below
5460
twineagl_sharedram_read_byte(UINT32 address)5461 static UINT8 __fastcall twineagl_sharedram_read_byte(UINT32 address)
5462 {
5463 return DrvShareRAM[(address&0xfff)>>1];
5464 }
5465
twineagl_sharedram_read_word(UINT32 address)5466 static UINT16 __fastcall twineagl_sharedram_read_word(UINT32 address)
5467 {
5468 return DrvShareRAM[(address&0xfff)>>1]&0xff;
5469 }
5470
twineagl_sharedram_write_word(UINT32 address,UINT16 data)5471 static void __fastcall twineagl_sharedram_write_word(UINT32 address, UINT16 data)
5472 {
5473 DrvShareRAM[(address&0xfff)>>1] = data&0xff;
5474 }
5475
twineagl_sharedram_write_byte(UINT32 address,UINT8 data)5476 static void __fastcall twineagl_sharedram_write_byte(UINT32 address, UINT8 data)
5477 {
5478 DrvShareRAM[(address&0xfff)>>1] = data;
5479 }
5480
5481
5482 //-----------------------------------------------------------------------------------------------------------------------------------
5483 // crazy fight
5484
crazyfgt_read_word(UINT32 address)5485 static UINT16 __fastcall crazyfgt_read_word(UINT32 address)
5486 {
5487 switch (address)
5488 {
5489 case 0x610000:
5490 case 0x610001:
5491 return DrvInputs[0];
5492
5493 case 0x610002:
5494 case 0x610003:
5495 return 0xffff;
5496
5497 case 0x610004:
5498 case 0x610005:
5499 return DrvInputs[1];
5500 }
5501
5502 SetaReadDips(0x630000)
5503
5504 return 0;
5505 }
5506
crazyfgt_read_byte(UINT32 address)5507 static UINT8 __fastcall crazyfgt_read_byte(UINT32 address)
5508 {
5509 switch (address)
5510 {
5511 case 0x610000:
5512 case 0x610001:
5513 return DrvInputs[0];
5514
5515 case 0x610002:
5516 case 0x610003:
5517 return 0xff;
5518
5519 case 0x610004:
5520 case 0x610005:
5521 return DrvInputs[1];
5522 }
5523
5524 SetaReadDips(0x630000)
5525
5526 return 0;
5527 }
5528
crazyfgt_write_byte(UINT32 address,UINT8 data)5529 static void __fastcall crazyfgt_write_byte(UINT32 address, UINT8 data)
5530 {
5531 SetaVidRAMCtrlWriteByte(1, 0x900000)
5532 SetaVidRAMCtrlWriteByte(0, 0x980000)
5533
5534 switch (address)
5535 {
5536 case 0x650001:
5537 case 0x650003:
5538 BurnYM3812Write(0, (address & 2) >> 1, data);
5539 return;
5540
5541 case 0x658000:
5542 case 0x658001:
5543 MSM6295Write(0, data);
5544 return;
5545 }
5546 }
5547
crazyfgt_write_word(UINT32 address,UINT16 data)5548 static void __fastcall crazyfgt_write_word(UINT32 address, UINT16 data)
5549 {
5550 SetaVidRAMCtrlWriteWord(1, 0x900000)
5551 SetaVidRAMCtrlWriteWord(0, 0x980000)
5552
5553 switch (address)
5554 {
5555 case 0x650000:
5556 case 0x650002:
5557 BurnYM3812Write(0, (address & 2) >> 1, data);
5558 return;
5559
5560 case 0x658000:
5561 case 0x658001:
5562 MSM6295Write(0, data);
5563 return;
5564
5565 case 0x620002: // nop
5566 return;
5567 }
5568 }
5569
5570
5571 //-----------------------------------------------------------------------------------------------------------------------------------
5572 // 68k initializers
5573
drgnunit68kInit()5574 static void drgnunit68kInit()
5575 {
5576 SekInit(0, 0x68000);
5577 SekOpen(0);
5578 SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, MAP_ROM);
5579 SekMapMemory(DrvPalRAM, 0x700000, 0x7003ff, MAP_RAM);
5580 SekMapMemory(DrvVidRAM0, 0x900000, 0x903fff, MAP_RAM);
5581 SekMapMemory(DrvSprRAM0, 0xd00000, 0xd00607 | 0x7ff, MAP_RAM);
5582 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe03fff, MAP_RAM);
5583 SekMapMemory(Drv68KRAM, 0xf00000, 0xf0ffff, MAP_RAM);
5584 SekMapMemory(Drv68KRAM + 0x0010000, 0xffc000, 0xffffff, MAP_RAM);
5585 SekSetWriteWordHandler(0, drgnunit_write_word);
5586 SekSetWriteByteHandler(0, drgnunit_write_byte);
5587 SekSetReadWordHandler(0, drgnunit_read_word);
5588 SekSetReadByteHandler(0, drgnunit_read_byte);
5589
5590 SekMapHandler(1, 0x100000, 0x103fff, MAP_READ | MAP_WRITE);
5591 SekSetReadWordHandler (1, setaSoundRegReadWord);
5592 SekSetReadByteHandler (1, setaSoundRegReadByte);
5593 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5594 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5595 SekClose();
5596 }
5597
daioh68kInit()5598 static void daioh68kInit()
5599 {
5600 SekInit(0, 0x68000);
5601 SekOpen(0);
5602 SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
5603 SekMapMemory(Drv68KRAM, 0x100000, 0x10ffff, MAP_RAM);
5604 SekMapMemory(Drv68KRAM + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5605 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5606 SekMapMemory(Drv68KRAM2, 0x701000, 0x70ffff, MAP_RAM);
5607 SekMapMemory(DrvVidRAM0, 0x800000, 0x80ffff, MAP_RAM);
5608 SekMapMemory(DrvVidRAM1, 0x880000, 0x88ffff, MAP_RAM);
5609 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5610 SekMapMemory(Drv68KRAM + 0x0020000, 0xa80000, 0xa803ff, MAP_WRITE); // nop out
5611 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb13fff, MAP_RAM);
5612 SekSetWriteWordHandler(0, daioh_write_word);
5613 SekSetWriteByteHandler(0, daioh_write_byte);
5614 SekSetReadWordHandler(0, daioh_read_word);
5615 SekSetReadByteHandler(0, daioh_read_byte);
5616
5617 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5618 SekSetReadWordHandler (1, setaSoundRegReadWord);
5619 SekSetReadByteHandler (1, setaSoundRegReadByte);
5620 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5621 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5622 SekClose();
5623 }
5624
daiohp68kInit()5625 static void daiohp68kInit()
5626 {
5627 SekInit(0, 0x68000);
5628 SekOpen(0);
5629 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
5630 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
5631 SekMapMemory(Drv68KRAM + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5632 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5633 SekMapMemory(Drv68KRAM2, 0x701000, 0x70ffff, MAP_RAM);
5634 SekMapMemory(DrvVidRAM0, 0x800000, 0x80ffff, MAP_RAM);
5635 SekMapMemory(DrvVidRAM1, 0x880000, 0x88ffff, MAP_RAM);
5636 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5637 SekMapMemory(Drv68KRAM + 0x0020000, 0xa80000, 0xa803ff, MAP_WRITE); // nop out
5638 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb13fff, MAP_RAM);
5639 SekSetWriteWordHandler(0, daioh_write_word);
5640 SekSetWriteByteHandler(0, daioh_write_byte);
5641 SekSetReadWordHandler(0, daioh_read_word);
5642 SekSetReadByteHandler(0, daioh_read_byte);
5643
5644 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5645 SekSetReadWordHandler (1, setaSoundRegReadWord);
5646 SekSetReadByteHandler (1, setaSoundRegReadByte);
5647 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5648 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5649 SekClose();
5650 }
5651
wrofaero68kInit()5652 static void wrofaero68kInit()
5653 {
5654 SekInit(0, 0x68000);
5655 SekOpen(0);
5656 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
5657 SekMapMemory(Drv68KRAM, 0x200000, 0x21ffff, MAP_RAM);
5658 SekMapMemory(Drv68KRAM2, 0x300000, 0x30ffff, MAP_RAM);
5659 SekMapMemory(Drv68KRAM2 + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5660 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5661 SekMapMemory(Drv68KRAM2 + 0x0011000, 0x701000, 0x70ffff, MAP_RAM);
5662 SekMapMemory(DrvVidRAM0, 0x800000, 0x80ffff, MAP_RAM);
5663 SekMapMemory(DrvVidRAM1, 0x880000, 0x88ffff, MAP_RAM);
5664 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5665 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb13fff, MAP_RAM);
5666 SekSetWriteWordHandler(0, daioh_write_word);
5667 SekSetWriteByteHandler(0, daioh_write_byte);
5668 SekSetReadWordHandler(0, daioh_read_word);
5669 SekSetReadByteHandler(0, daioh_read_byte);
5670
5671 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5672 SekSetReadWordHandler (1, setaSoundRegReadWord);
5673 SekSetReadByteHandler (1, setaSoundRegReadByte);
5674 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5675 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5676 SekClose();
5677 }
5678
msgundam68kInit()5679 static void msgundam68kInit()
5680 {
5681 SekInit(0, 0x68000);
5682 SekOpen(0);
5683 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
5684
5685 for (INT32 i = 0; i < 0x80000; i+=0x10000) // mirrored
5686 SekMapMemory(Drv68KRAM, 0x200000+i, 0x20ffff+i, MAP_RAM);
5687
5688 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5689 SekMapMemory(DrvSprRAM0, 0x800000, 0x800607 | 0x7ff, MAP_RAM);
5690 SekMapMemory(DrvSprRAM1, 0x900000, 0x903fff, MAP_RAM);
5691
5692 SekMapMemory(DrvVidRAM0, 0xa00000, 0xa0ffff, MAP_RAM);
5693 SekMapMemory(DrvVidRAM1, 0xa80000, 0xa8ffff, MAP_RAM);
5694 SekSetWriteWordHandler(0, msgundam_write_word);
5695 SekSetWriteByteHandler(0, msgundam_write_byte);
5696 SekSetReadWordHandler(0, daioh_read_word);
5697 SekSetReadByteHandler(0, daioh_read_byte);
5698
5699 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5700 SekSetReadWordHandler (1, setaSoundRegReadWord);
5701 SekSetReadByteHandler (1, setaSoundRegReadByte);
5702 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5703 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5704 SekClose();
5705 }
5706
umanclub68kInit()5707 static void umanclub68kInit()
5708 {
5709 SekInit(0, 0x68000);
5710 SekOpen(0);
5711 SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
5712 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
5713 SekMapMemory(DrvPalRAM, 0x300000, 0x300fff, MAP_RAM);
5714 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5715 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb03fff, MAP_RAM);
5716 SekSetWriteWordHandler(0, daioh_write_word);
5717 SekSetWriteByteHandler(0, daioh_write_byte);
5718 SekSetReadWordHandler(0, daioh_read_word);
5719 SekSetReadByteHandler(0, daioh_read_byte);
5720
5721 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5722 SekSetReadWordHandler (1, setaSoundRegReadWord);
5723 SekSetReadByteHandler (1, setaSoundRegReadByte);
5724 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5725 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5726 SekClose();
5727 }
5728
kamenrid68kInit()5729 static void kamenrid68kInit()
5730 {
5731 SekInit(0, 0x68000);
5732 SekOpen(0);
5733 SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
5734 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
5735 SekMapMemory(Drv68KRAM2 + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5736 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5737 SekMapMemory(Drv68KRAM2 + 0x0011000, 0x701000, 0x703fff, MAP_RAM);
5738 SekMapMemory(DrvVidRAM0, 0x800000, 0x807fff, MAP_RAM);
5739 SekMapMemory(DrvVidRAM1, 0x880000, 0x887fff, MAP_RAM);
5740 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5741 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb07fff, MAP_RAM);
5742 SekSetWriteWordHandler(0, madshark_write_word);
5743 SekSetWriteByteHandler(0, madshark_write_byte);
5744 SekSetReadWordHandler(0, kamenrid_read_word);
5745 SekSetReadByteHandler(0, kamenrid_read_byte);
5746
5747 SekMapHandler(1, 0xd00000, 0xd03fff, MAP_READ | MAP_WRITE);
5748 SekSetReadWordHandler (1, setaSoundRegReadWord);
5749 SekSetReadByteHandler (1, setaSoundRegReadByte);
5750 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5751 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5752 SekClose();
5753
5754 {
5755 DrvGfxROM2 = DrvGfxROM1 + 0x80000;
5756 DrvROMLen[2] = DrvROMLen[1] = DrvROMLen[1] / 2;
5757 memcpy (DrvGfxROM2, DrvGfxROM1 + 0x40000, 0x40000);
5758 }
5759 }
5760
madshark68kInit()5761 static void madshark68kInit()
5762 {
5763 SekInit(0, 0x68000);
5764 SekOpen(0);
5765 SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
5766 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
5767 SekMapMemory(Drv68KRAM2 + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5768 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5769 SekMapMemory(Drv68KRAM2 + 0x0011000, 0x701000, 0x703fff, MAP_RAM);
5770 SekMapMemory(DrvVidRAM0, 0x800000, 0x807fff, MAP_RAM);
5771 SekMapMemory(DrvVidRAM1, 0x880000, 0x887fff, MAP_RAM);
5772 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5773 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb07fff, MAP_RAM);
5774 SekSetWriteWordHandler(0, madshark_write_word);
5775 SekSetWriteByteHandler(0, madshark_write_byte);
5776 SekSetReadWordHandler(0, madshark_read_word);
5777 SekSetReadByteHandler(0, madshark_read_byte);
5778
5779 SekMapHandler(1, 0xd00000, 0xd03fff, MAP_READ | MAP_WRITE);
5780 SekSetReadWordHandler (1, setaSoundRegReadWord);
5781 SekSetReadByteHandler (1, setaSoundRegReadByte);
5782 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5783 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5784 SekClose();
5785
5786 {
5787 DrvGfxROM2 = (UINT8*)BurnMalloc(0x200000);
5788 DrvROMLen[1] = DrvROMLen[2] = 0x200000;
5789
5790 memcpy (DrvGfxROM0 + 0x200000, DrvGfxROM0 + 0x000000, 0x100000);
5791 memmove (DrvGfxROM0 + 0x000000, DrvGfxROM0 + 0x100000, 0x200000); // dink??
5792
5793 memcpy (DrvGfxROM2 + 0x000000, DrvGfxROM1 + 0x100000, 0x100000);
5794 memcpy (DrvGfxROM2 + 0x100000, DrvGfxROM1 + 0x300000, 0x100000);
5795 memcpy (DrvGfxROM1 + 0x100000, DrvGfxROM1 + 0x200000, 0x100000);
5796 }
5797 }
5798
thunderl68kInit()5799 static void thunderl68kInit()
5800 {
5801 SekInit(0, 0x68000);
5802 SekOpen(0);
5803 SekMapMemory(Drv68KROM, 0x000000, 0x00ffff, MAP_ROM);
5804 SekMapMemory(DrvPalRAM, 0x700000, 0x700fff, MAP_RAM);
5805 SekMapMemory(DrvSprRAM0, 0xd00000, 0xd00607 | 0x7ff, MAP_RAM);
5806 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe07fff, MAP_RAM);
5807 SekMapMemory(Drv68KRAM, 0xffc000, 0xffffff, MAP_RAM);
5808 SekSetWriteWordHandler(0, thunderl_write_word);
5809 SekSetWriteByteHandler(0, thunderl_write_byte);
5810 SekSetReadWordHandler(0, thunderl_read_word);
5811 SekSetReadByteHandler(0, thunderl_read_byte);
5812
5813 SekMapHandler(1, 0x100000, 0x103fff, MAP_READ | MAP_WRITE);
5814 SekSetReadWordHandler (1, setaSoundRegReadWord);
5815 SekSetReadByteHandler (1, setaSoundRegReadByte);
5816 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5817 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5818 SekClose();
5819 }
5820
atehate68kInit()5821 static void atehate68kInit()
5822 {
5823 SekInit(0, 0x68000);
5824 SekOpen(0);
5825 SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
5826 SekMapMemory(DrvPalRAM, 0x700000, 0x700fff, MAP_RAM);
5827 SekMapMemory(Drv68KRAM, 0x900000, 0x9fffff, MAP_RAM);
5828 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5829 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe03fff, MAP_RAM);
5830 SekSetWriteWordHandler(0, thunderl_write_word);
5831 SekSetWriteByteHandler(0, thunderl_write_byte);
5832 SekSetReadWordHandler(0, thunderl_read_word);
5833 SekSetReadByteHandler(0, thunderl_read_byte);
5834
5835 SekMapHandler(1, 0x100000, 0x103fff, MAP_READ | MAP_WRITE);
5836 SekSetReadWordHandler (1, setaSoundRegReadWord);
5837 SekSetReadByteHandler (1, setaSoundRegReadByte);
5838 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5839 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5840 SekClose();
5841 }
5842
blockcar68kInit()5843 static void blockcar68kInit()
5844 {
5845 SekInit(0, 0x68000);
5846 SekOpen(0);
5847 SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
5848 SekMapMemory(DrvPalRAM, 0xb00000, 0xb00fff, MAP_RAM);
5849 SekMapMemory(DrvSprRAM1, 0xc00000, 0xc03fff, MAP_RAM);
5850 SekMapMemory(DrvSprRAM0, 0xe00000, 0xe00607 | 0x7ff, MAP_RAM);
5851 SekMapMemory(Drv68KRAM, 0xf00000, 0xf05fff, MAP_RAM);
5852 SekSetWriteWordHandler(0, thunderl_write_word);
5853 SekSetWriteByteHandler(0, thunderl_write_byte);
5854 SekSetReadWordHandler(0, madshark_read_word);
5855 SekSetReadByteHandler(0, madshark_read_byte);
5856
5857 SekMapHandler(1, 0xa00000, 0xa03fff, MAP_READ | MAP_WRITE);
5858 SekSetReadWordHandler (1, setaSoundRegReadWord);
5859 SekSetReadByteHandler (1, setaSoundRegReadByte);
5860 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5861 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5862 SekClose();
5863
5864 memcpy (DrvSndROM + 0x80000, DrvSndROM, 0x80000);
5865 }
5866
zombraid68kInit()5867 static void zombraid68kInit()
5868 {
5869 wrofaero68kInit();
5870
5871 SekOpen(0);
5872 SekMapHandler(2, 0xf00000, 0xf00003, MAP_READ | MAP_WRITE);
5873 SekSetReadWordHandler (2, zombraid_gun_read_word);
5874 SekSetReadByteHandler (2, zombraid_gun_read_byte);
5875 SekSetWriteWordHandler(2, zombraid_gun_write_word);
5876 SekSetWriteByteHandler(2, zombraid_gun_write_byte);
5877 SekClose();
5878
5879 memmove (DrvSndROM + 0x100000, DrvSndROM + 0x080000, 0x380000);
5880 }
5881
BlandiaGfxRearrange()5882 static void BlandiaGfxRearrange()
5883 {
5884 INT32 rom_size = DrvROMLen[1];
5885 UINT8 *buf = (UINT8*)BurnMalloc(rom_size);
5886
5887 UINT8 *rom = DrvGfxROM1 + 0x40000;
5888
5889 if (rom_size == 0x100000) memmove (rom, rom + 0x40000, 0x80000); // blandia dink??
5890
5891 for (INT32 rpos = 0; rpos < 0x80000/2; rpos++) {
5892 buf[rpos+0x40000] = rom[rpos*2];
5893 buf[rpos] = rom[rpos*2+1];
5894 }
5895
5896 memcpy (rom, buf, 0x80000);
5897
5898 rom = DrvGfxROM2 + 0x40000;
5899
5900 if (rom_size == 0x100000) memmove (rom, rom + 0x40000, 0x80000); // blandia dink??
5901
5902 for (INT32 rpos = 0; rpos < 0x80000/2; rpos++) {
5903 buf[rpos+0x40000] = rom[rpos*2];
5904 buf[rpos] = rom[rpos*2+1];
5905 }
5906
5907 memcpy (rom, buf, 0x80000);
5908
5909 DrvROMLen[1] = DrvROMLen[2] = 0xc0000;
5910
5911 BurnFree (buf);
5912 }
5913
blandia68kInit()5914 static void blandia68kInit()
5915 {
5916 SekInit(0, 0x68000);
5917 SekOpen(0);
5918 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
5919 SekMapMemory(Drv68KRAM, 0x200000, 0x21ffff, MAP_RAM);
5920 SekMapMemory(Drv68KRAM2, 0x300000, 0x30ffff, MAP_RAM);
5921 SekMapMemory(Drv68KRAM2 + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5922 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5923 SekMapMemory(Drv68KRAM2 + 0x0011000, 0x701000, 0x70ffff, MAP_RAM);
5924 SekMapMemory(DrvSprRAM0, 0x800000, 0x800607 | 0x7ff, MAP_RAM);
5925 SekMapMemory(DrvSprRAM1, 0x900000, 0x903fff, MAP_RAM);
5926 SekMapMemory(DrvVidRAM0, 0xb00000, 0xb0ffff, MAP_RAM);
5927 SekMapMemory(DrvVidRAM1, 0xb80000, 0xb8ffff, MAP_RAM);
5928 SekSetWriteWordHandler(0, daioh_write_word);
5929 SekSetWriteByteHandler(0, daioh_write_byte);
5930 SekSetReadWordHandler(0, daioh_read_word);
5931 SekSetReadByteHandler(0, daioh_read_byte);
5932
5933 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5934 SekSetReadWordHandler (1, setaSoundRegReadWord);
5935 SekSetReadByteHandler (1, setaSoundRegReadByte);
5936 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5937 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5938 SekClose();
5939
5940 memmove (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x100000);
5941 memmove (DrvSndROM + 0x100000, DrvSndROM + 0x0c0000, 0x0c0000);
5942
5943 BlandiaGfxRearrange();
5944 }
5945
blandiap68kInit()5946 static void blandiap68kInit()
5947 {
5948 SekInit(0, 0x68000);
5949 SekOpen(0);
5950 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
5951 SekMapMemory(Drv68KRAM, 0x200000, 0x21ffff, MAP_RAM);
5952 SekMapMemory(Drv68KRAM2, 0x300000, 0x30ffff, MAP_RAM);
5953 SekMapMemory(Drv68KRAM2 + 0x0010000, 0x700000, 0x7003ff, MAP_RAM);
5954 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
5955 SekMapMemory(Drv68KRAM2 + 0x0011000, 0x701000, 0x70ffff, MAP_RAM);
5956 SekMapMemory(DrvVidRAM0, 0x800000, 0x80ffff, MAP_RAM);
5957 SekMapMemory(DrvVidRAM1, 0x880000, 0x88ffff, MAP_RAM);
5958 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
5959 SekMapMemory(Drv68KRAM + 0x0020000, 0xa80000, 0xa803ff, MAP_WRITE); //nop
5960 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb03fff, MAP_RAM);
5961 SekSetWriteWordHandler(0, daioh_write_word);
5962 SekSetWriteByteHandler(0, daioh_write_byte);
5963 SekSetReadWordHandler(0, daioh_read_word);
5964 SekSetReadByteHandler(0, daioh_read_byte);
5965
5966 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
5967 SekSetReadWordHandler (1, setaSoundRegReadWord);
5968 SekSetReadByteHandler (1, setaSoundRegReadByte);
5969 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
5970 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
5971 SekClose();
5972
5973 memmove (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x100000);
5974
5975 // set up sound banks...
5976 {
5977 UINT8 *tmp = (UINT8*)BurnMalloc(0x240000);
5978
5979 INT32 offsets[16] = {
5980 0x000000, 0x140000, 0x020000, 0x160000,
5981 0x040000, 0x180000, 0x060000, 0x1a0000,
5982 0x080000, 0x1c0000, 0x0a0000, 0x1e0000,
5983 0x100000, 0x200000, 0x120000, 0x220000
5984 };
5985
5986 for (INT32 i = 0; i < 16; i++) {
5987 memcpy (tmp + offsets[i], DrvSndROM + (i * 0x020000), 0x020000);
5988 }
5989
5990 memcpy (DrvSndROM, tmp, 0x240000);
5991
5992 BurnFree (tmp);
5993 }
5994 }
5995
oisipuzl68kInit()5996 static void oisipuzl68kInit()
5997 {
5998 SekInit(0, 0x68000);
5999 SekOpen(0);
6000 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
6001 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
6002 SekMapMemory(DrvVidRAM0, 0x800000, 0x803fff, MAP_RAM);
6003 SekMapMemory(DrvVidRAM1, 0x880000, 0x883fff, MAP_RAM);
6004 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
6005 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb03fff, MAP_RAM);
6006 SekMapMemory(DrvPalRAM, 0xc00400, 0xc00fff, MAP_RAM);
6007 SekSetWriteWordHandler(0, daioh_write_word);
6008 SekSetWriteByteHandler(0, daioh_write_byte);
6009 SekSetReadWordHandler(0, daioh_read_word);
6010 SekSetReadByteHandler(0, daioh_read_byte);
6011
6012 SekMapHandler(1, 0x700000, 0x703fff, MAP_READ | MAP_WRITE);
6013 SekSetReadWordHandler (1, setaSoundRegReadWord);
6014 SekSetReadByteHandler (1, setaSoundRegReadByte);
6015 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6016 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6017 SekClose();
6018 }
6019
pairlove68kInit()6020 static void pairlove68kInit()
6021 {
6022 SekInit(0, 0x68000);
6023 SekOpen(0);
6024 SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
6025 SekMapMemory(DrvNVRAM, 0x800000, 0x8001ff, MAP_RAM);
6026 SekMapMemory(DrvPalRAM, 0xb00000, 0xb00fff, MAP_RAM);
6027 SekMapMemory(DrvSprRAM1, 0xc00000, 0xc03fff, MAP_RAM);
6028 SekMapMemory(DrvSprRAM0, 0xe00000, 0xe00607 | 0x7ff, MAP_RAM);
6029 SekMapMemory(Drv68KRAM, 0xf00000, 0xf0ffff, MAP_RAM);
6030 SekSetWriteWordHandler(0, pairlove_write_word);
6031 SekSetWriteByteHandler(0, pairlove_write_byte);
6032 SekSetReadWordHandler(0, pairlove_read_word);
6033 SekSetReadByteHandler(0, pairlove_read_byte);
6034
6035 SekMapHandler(1, 0xa00000, 0xa03fff, MAP_READ | MAP_WRITE);
6036 SekSetReadWordHandler (1, setaSoundRegReadWord);
6037 SekSetReadByteHandler (1, setaSoundRegReadByte);
6038 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6039 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6040 SekClose();
6041 }
6042
jjsquawkb68kInit()6043 static void jjsquawkb68kInit()
6044 {
6045 SekInit(0, 0x68000);
6046 SekOpen(0);
6047 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
6048 SekMapMemory(Drv68KRAM, 0x200000, 0x21ffff, MAP_RAM);
6049 SekMapMemory(Drv68KRAM2, 0x300000, 0x30ffff, MAP_RAM);
6050 SekMapMemory(Drv68KRAM2 + 0x0010000, 0x700000, 0x70b3ff, MAP_RAM);
6051 SekMapMemory(DrvPalRAM, 0x70b400, 0x70bfff, MAP_RAM);
6052 SekMapMemory(Drv68KRAM2 + 0x001c000, 0x70c000, 0x70ffff, MAP_RAM);
6053 SekMapMemory(DrvVidRAM0, 0x800000, 0x803fff, MAP_RAM);
6054 SekMapMemory(DrvVidRAM1, 0x804000, 0x807fff, MAP_RAM);
6055 SekMapMemory(DrvVidRAM1 + 0x4000, 0x884000, 0x88ffff, MAP_RAM);
6056 SekMapMemory(DrvSprRAM0, 0xa0a000, 0xa0a607 | 0x7ff, MAP_RAM);
6057 SekMapMemory(DrvSprRAM1, 0xb0c000, 0xb0ffff, MAP_RAM);
6058 SekSetWriteWordHandler(0, daioh_write_word);
6059 SekSetWriteByteHandler(0, daioh_write_byte);
6060 SekSetReadWordHandler(0, daioh_read_word);
6061 SekSetReadByteHandler(0, daioh_read_byte);
6062
6063 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
6064 SekSetReadWordHandler (1, setaSoundRegReadWord);
6065 SekSetReadByteHandler (1, setaSoundRegReadByte);
6066 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6067 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6068 SekClose();
6069
6070 BurnLoadRom(Drv68KROM + 0x0000000, 0, 1);
6071 BurnLoadRom(Drv68KROM + 0x0100000, 1, 1);
6072
6073 DrvGfxROM2 = DrvGfxROM1 + 0x400000;
6074 DrvROMLen[1] = DrvROMLen[2] = 0x200000;
6075
6076 memcpy (DrvGfxROM2 + 0x000000, DrvGfxROM1 + 0x100000, 0x100000);
6077 memcpy (DrvGfxROM2 + 0x100000, DrvGfxROM1 + 0x300000, 0x100000);
6078 memcpy (DrvGfxROM1 + 0x100000, DrvGfxROM1 + 0x200000, 0x100000);
6079 }
6080
extdwnhl68kInit()6081 static void extdwnhl68kInit()
6082 {
6083 SekInit(0, 0x68000);
6084 SekOpen(0);
6085 SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
6086 SekMapMemory(Drv68KRAM, 0x200000, 0x23ffff, MAP_RAM);
6087 SekMapMemory(DrvPalRAM, 0x600400, 0x600fff, MAP_RAM);
6088 SekMapMemory(Drv68KRAM2, 0x601000, 0x610bff, MAP_RAM);
6089 SekMapMemory(DrvVidRAM0, 0x800000, 0x80ffff, MAP_RAM);
6090 SekMapMemory(DrvVidRAM1, 0x880000, 0x88ffff, MAP_RAM);
6091 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
6092 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb13fff, MAP_RAM);
6093 SekSetWriteWordHandler(0, daioh_write_word);
6094 SekSetWriteByteHandler(0, daioh_write_byte);
6095 SekSetReadWordHandler(0, daioh_read_word);
6096 SekSetReadByteHandler(0, daioh_read_byte);
6097
6098 SekMapHandler(1, 0xe00000, 0xe03fff, MAP_READ | MAP_WRITE);
6099 SekSetReadWordHandler (1, setaSoundRegReadWord);
6100 SekSetReadByteHandler (1, setaSoundRegReadByte);
6101 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6102 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6103 SekClose();
6104
6105 memcpy (DrvSndROM + 0x100000, DrvSndROM + 0x000000, 0x080000); // temp storage
6106
6107 // swap halves of sound rom (extdwnhl & sokonuke)
6108 memcpy (DrvSndROM + 0x000000, DrvSndROM + 0x080000, 0x080000);
6109 memcpy (DrvSndROM + 0x080000, DrvSndROM + 0x100000, 0x080000);
6110 }
6111
krzybowl68kInit()6112 static void krzybowl68kInit()
6113 {
6114 SekInit(0, 0x68000);
6115 SekOpen(0);
6116 SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
6117 SekMapMemory(DrvNVRAM, 0x800000, 0x8001ff, MAP_RAM);
6118 SekMapMemory(DrvPalRAM, 0xb00000, 0xb003ff, MAP_RAM);
6119 SekMapMemory(DrvSprRAM1, 0xc00000, 0xc03fff, MAP_RAM);
6120 SekMapMemory(DrvSprRAM0, 0xe00000, 0xe00607 | 0x7ff, MAP_RAM);
6121 SekMapMemory(Drv68KRAM, 0xf00000, 0xf0ffff, MAP_RAM);
6122 SekSetWriteWordHandler(0, thunderl_write_word);
6123 SekSetWriteByteHandler(0, thunderl_write_byte);
6124 SekSetReadWordHandler(0, madshark_read_word);
6125 SekSetReadByteHandler(0, madshark_read_byte);
6126
6127 SekMapHandler(1, 0xa00000, 0xa03fff, MAP_READ | MAP_WRITE);
6128 SekSetReadWordHandler (1, setaSoundRegReadWord);
6129 SekSetReadByteHandler (1, setaSoundRegReadByte);
6130 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6131 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6132 SekClose();
6133 }
6134
triplfun_sound_write_byte(UINT32 address,UINT8 data)6135 static void __fastcall triplfun_sound_write_byte(UINT32 address, UINT8 data)
6136 {
6137 if ((address & ~1) == 0x500006) {
6138 MSM6295Write(0, data);
6139 }
6140 }
6141
triplfun_sound_read_byte(UINT32)6142 static UINT8 __fastcall triplfun_sound_read_byte(UINT32)
6143 {
6144 return MSM6295Read(0);
6145 }
6146
triplfun68kInit()6147 static void triplfun68kInit()
6148 {
6149 oisipuzl68kInit();
6150
6151 SekOpen(0);
6152 SekMapHandler(2, 0x500006, 0x500007, MAP_READ | MAP_WRITE);
6153 // SekSetReadWordHandler (2, triplfun_sound_read_word);
6154 SekSetReadByteHandler (2, triplfun_sound_read_byte);
6155 // SekSetWriteWordHandler(2, triplfun_sound_write_word);
6156 SekSetWriteByteHandler(2, triplfun_sound_write_byte);
6157 SekClose();
6158
6159 MSM6295Exit(0);
6160 MSM6295Init(0, 792000 / 132, 0);
6161 MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
6162
6163 memcpy (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x080000);
6164 memset (Drv68KROM + 0x080000, 0, 0x080000);
6165 }
6166
utoukond68kInit()6167 static void utoukond68kInit()
6168 {
6169 SekInit(0, 0x68000);
6170 SekOpen(0);
6171 SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
6172 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
6173 SekMapMemory(DrvPalRAM, 0x700400, 0x700fff, MAP_RAM);
6174 SekMapMemory(DrvVidRAM0, 0x800000, 0x803fff, MAP_RAM);
6175 SekMapMemory(DrvVidRAM1, 0x880000, 0x883fff, MAP_RAM);
6176 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
6177 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb03fff, MAP_RAM);
6178 SekSetWriteWordHandler(0, daioh_write_word);
6179 SekSetWriteByteHandler(0, daioh_write_byte);
6180 SekSetReadWordHandler(0, daioh_read_word);
6181 SekSetReadByteHandler(0, daioh_read_byte);
6182
6183 SekMapHandler(1, 0xc00000, 0xc00001, MAP_WRITE);
6184 SekSetWriteWordHandler(1, wiggie_sound_write_word);
6185 SekSetWriteByteHandler(1, wiggie_sound_write_byte);
6186 SekClose();
6187
6188 has_z80 = 1;
6189 ZetInit(0);
6190 ZetOpen(0);
6191 ZetMapArea(0x0000, 0xdfff, 0, DrvSubROM);
6192 ZetMapArea(0x0000, 0xdfff, 2, DrvSubROM);
6193 ZetMapArea(0xe000, 0xefff, 0, DrvSubRAM);
6194 ZetMapArea(0xe000, 0xefff, 1, DrvSubRAM);
6195 ZetMapArea(0xe000, 0xefff, 2, DrvSubRAM);
6196 ZetSetWriteHandler(utoukond_sound_write);
6197 ZetSetReadHandler(utoukond_sound_read);
6198 ZetSetOutHandler(utoukond_sound_write_port);
6199 ZetSetInHandler(utoukond_sound_read_port);
6200 ZetClose();
6201
6202 for (INT32 i = 0; i < 0x400000; i++) DrvGfxROM0[i] ^= 0xff;
6203 }
6204
Wiggie68kDecode()6205 static void Wiggie68kDecode()
6206 {
6207 UINT8 *tmp = Drv68KRAM;
6208
6209 for (INT32 i = 0; i < 0x20000; i+=16) {
6210 for (INT32 j = 0; j < 16; j++) {
6211 tmp[j] = Drv68KROM[i+((j & 1) | ((j & 2) << 2) | ((j & 0x0c) >> 1))];
6212 }
6213 memcpy (Drv68KROM + i, tmp, 0x10);
6214 }
6215 }
6216
wiggie68kInit()6217 static void wiggie68kInit()
6218 {
6219 thunderl68kInit();
6220
6221 SekOpen(0);
6222 SekMapMemory(Drv68KRAM + 0x80000, 0x100000, 0x103fff, MAP_READ); // nop
6223
6224 SekMapHandler(2, 0xb00008, 0xb00009, MAP_WRITE);
6225 SekSetWriteWordHandler(2, wiggie_sound_write_word);
6226 SekSetWriteByteHandler(2, wiggie_sound_write_byte);
6227 SekClose();
6228
6229 Wiggie68kDecode();
6230
6231 has_z80 = 1;
6232 ZetInit(0);
6233 ZetOpen(0);
6234 ZetMapArea(0x0000, 0x7fff, 0, DrvSubROM);
6235 ZetMapArea(0x0000, 0x7fff, 2, DrvSubROM);
6236 ZetMapArea(0x8000, 0x87ff, 0, DrvSubRAM);
6237 ZetMapArea(0x8000, 0x87ff, 1, DrvSubRAM);
6238 ZetMapArea(0x8000, 0x87ff, 2, DrvSubRAM);
6239 ZetSetWriteHandler(wiggie_sound_write);
6240 ZetSetReadHandler(wiggie_sound_read);
6241 ZetClose();
6242 }
6243
downtown_input_read(INT32 offset)6244 static UINT16 downtown_input_read(INT32 offset)
6245 {
6246 INT32 dir1 = dialRotation(0); // analog port
6247 INT32 dir2 = dialRotation(1); // analog port
6248
6249 dir1 = (~ (0x800 >> dir1)) & 0xfff;
6250 dir2 = (~ (0x800 >> dir2)) & 0xfff;
6251
6252 switch (offset)
6253 {
6254 case 0: return (DrvInputs[2] & 0xf0) + (dir1 >> 8); // upper 4 bits of p1 rotation + coins
6255 case 1: return (dir1 & 0xff); // lower 8 bits of p1 rotation
6256 case 2: return DrvInputs[0]; // p1
6257 case 3: return 0xff; // ?
6258 case 4: return (dir2 >> 8); // upper 4 bits of p2 rotation + ?
6259 case 5: return (dir2 & 0xff); // lower 8 bits of p2 rotation
6260 case 6: return DrvInputs[1]; // p2
6261 case 7: return 0xff; // ?
6262 }
6263
6264 return 0;
6265 }
6266
m65c02_sub_bankswitch(UINT8 d)6267 static void m65c02_sub_bankswitch(UINT8 d)
6268 {
6269 m65c02_bank = d;
6270
6271 M6502MapMemory(DrvSubROM + 0xc000 + ((m65c02_bank >> 4) * 0x4000), 0x8000, 0xbfff, MAP_ROM);
6272 }
6273
downtown_sub_write(UINT16 address,UINT8 data)6274 static void downtown_sub_write(UINT16 address, UINT8 data)
6275 {
6276 switch (address)
6277 {
6278 case 0x1000:
6279 m65c02_sub_bankswitch(data);
6280 return;
6281 }
6282 }
6283
downtown_sub_read(UINT16 address)6284 static UINT8 downtown_sub_read(UINT16 address)
6285 {
6286 switch (address)
6287 {
6288 case 0x0800: return soundlatch;
6289 case 0x0801: return soundlatch2;
6290 case 0x1000:
6291 case 0x1001:
6292 case 0x1002:
6293 case 0x1003:
6294 case 0x1004:
6295 case 0x1005:
6296 case 0x1006:
6297 case 0x1007: return downtown_input_read(address&7);
6298 }
6299
6300 return 0;
6301 }
6302
downtown68kInit()6303 static void downtown68kInit()
6304 {
6305 downtown_protram = DrvNVRAM;
6306
6307 memset(DrvNVRAM, 0xff, 0x400);
6308
6309 SekInit(0, 0x68000);
6310 SekOpen(0);
6311 SekMapMemory(Drv68KROM, 0x000000, 0x09ffff, MAP_ROM);
6312 SekMapMemory(DrvPalRAM, 0x700000, 0x7003ff, MAP_RAM);
6313 SekMapMemory(DrvVidRAM0, 0x900000, 0x903fff, MAP_RAM);
6314 SekMapMemory(DrvSprRAM0, 0xd00000, 0xd00607 | 0x7ff, MAP_RAM);
6315 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe03fff, MAP_RAM);
6316 SekMapMemory(Drv68KRAM, 0xf00000, 0xffffff, MAP_RAM);
6317 SekSetWriteWordHandler(0, downtown_write_word);
6318 SekSetWriteByteHandler(0, downtown_write_byte);
6319 SekSetReadWordHandler(0, daioh_read_word);
6320 SekSetReadByteHandler(0, daioh_read_byte);
6321
6322 SekMapHandler(1, 0x100000, 0x103fff, MAP_READ | MAP_WRITE);
6323 SekSetReadWordHandler (1, setaSoundRegReadWord);
6324 SekSetReadByteHandler (1, setaSoundRegReadByte);
6325 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6326 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6327
6328 SekMapMemory(downtown_protram, 0x200000, 0x2003ff, MAP_WRITE);
6329 SekMapHandler(2, 0x200000, 0x2003ff, MAP_READ);
6330 SekSetReadByteHandler (2, downtown_prot_read);
6331
6332 SekMapHandler(3, 0xb00000, 0xb00fff, MAP_READ | MAP_WRITE);
6333 SekSetReadByteHandler (3, twineagl_sharedram_read_byte);
6334 SekSetReadWordHandler (3, twineagl_sharedram_read_word);
6335 SekSetWriteWordHandler(3, twineagl_sharedram_write_word);
6336 SekSetWriteByteHandler(3, twineagl_sharedram_write_byte);
6337 SekClose();
6338
6339 if (strstr(BurnDrvGetTextA(DRV_NAME), "downtown")) {
6340 BurnLoadRom(DrvSubROM + 0x0004000, 4, 1);
6341 BurnLoadRom(DrvSubROM + 0x000c000, 4, 1);
6342
6343 M6502Init(0, TYPE_M65C02);
6344 M6502Open(0);
6345 M6502MapMemory(DrvSubRAM, 0x0000, 0x01ff, MAP_RAM);
6346 M6502MapMemory(DrvShareRAM, 0x5000, 0x57ff, MAP_RAM);
6347 M6502MapMemory(DrvSubROM + 0x7000, 0x7000, 0x7fff, MAP_ROM);
6348 M6502MapMemory(DrvSubROM + 0xc000, 0x8000, 0xbfff, MAP_ROM); // bank default
6349 M6502MapMemory(DrvSubROM + 0xc000, 0xc000, 0xffff, MAP_ROM);
6350 M6502SetWriteHandler(downtown_sub_write);
6351 M6502SetReadHandler(downtown_sub_read);
6352 M6502Close();
6353 m65c02_mode = 1;
6354
6355 game_rotates = 2; // 2 == downtown mode.
6356 RotateSetGunPosRAM(Drv68KRAM + (0xfef90+1), Drv68KRAM + (0xfefd0+1), 1);
6357 }
6358 }
6359
metafox_sub_read(UINT16 address)6360 static UINT8 metafox_sub_read(UINT16 address)
6361 {
6362 switch (address)
6363 {
6364 case 0x0800: return soundlatch;
6365 case 0x0801: return soundlatch2;
6366 case 0x1000: return DrvInputs[2];
6367 case 0x1002: return DrvInputs[0];
6368 case 0x1006: return DrvInputs[1];
6369 }
6370
6371 return 0;
6372 }
6373
metafox68kInit()6374 static void metafox68kInit()
6375 {
6376 downtown68kInit();
6377
6378 SekOpen(0);
6379 SekMapHandler(3, 0xb00000, 0xb00fff, MAP_READ | MAP_WRITE);
6380 SekSetReadByteHandler (3, twineagl_sharedram_read_byte);
6381 SekSetReadWordHandler (3, twineagl_sharedram_read_word);
6382 SekSetWriteWordHandler(3, twineagl_sharedram_write_word);
6383 SekSetWriteByteHandler(3, twineagl_sharedram_write_byte);
6384 SekClose();
6385
6386 if (X1010_Arbalester_Mode) {
6387 BurnLoadRom(DrvSubROM + 0x0006000, 2, 1);
6388 memcpy(DrvSubROM + 0x000a000, DrvSubROM + 0x0006000, 0x4000);
6389 memcpy(DrvSubROM + 0x000e000, DrvSubROM + 0x0006000, 0x2000);
6390 } else {
6391 BurnLoadRom(DrvSubROM + 0x0006000, 4, 1);
6392 memcpy(DrvSubROM + 0x0008000, DrvSubROM + 0x0006000, 0x2000);
6393 memcpy(DrvSubROM + 0x000a000, DrvSubROM + 0x0006000, 0x2000);
6394 memcpy(DrvSubROM + 0x000c000, DrvSubROM + 0x0006000, 0x2000);
6395 memcpy(DrvSubROM + 0x000e000, DrvSubROM + 0x0006000, 0x2000);
6396 }
6397
6398 M6502Init(0, TYPE_M65C02);
6399 M6502Open(0);
6400 M6502MapMemory(DrvSubRAM, 0x0000, 0x01ff, MAP_RAM);
6401 M6502MapMemory(DrvShareRAM, 0x5000, 0x57ff, MAP_RAM);
6402 M6502MapMemory(DrvSubROM + 0x7000, 0x7000, 0x7fff, MAP_ROM);
6403 M6502MapMemory(DrvSubROM + 0xc000, 0x8000, 0xbfff, MAP_ROM); // bank default
6404 M6502MapMemory(DrvSubROM + 0xc000, 0xc000, 0xffff, MAP_ROM);
6405 M6502SetWriteHandler(downtown_sub_write);
6406 M6502SetReadHandler(metafox_sub_read);
6407 M6502Close();
6408 m65c02_mode = 1;
6409
6410 }
6411
tndrcade_sub_write(UINT16 address,UINT8 data)6412 static void tndrcade_sub_write(UINT16 address, UINT8 data)
6413 {
6414 switch (address)
6415 {
6416 case 0x2000: BurnYM2203Write(0, 0, data); return;
6417 case 0x2001: BurnYM2203Write(0, 1, data); return;
6418 case 0x3000: BurnYM3812Write(0, 0, data); return;
6419 case 0x3001: BurnYM3812Write(0, 1, data); return;
6420 case 0x1000: m65c02_sub_bankswitch(data); return;
6421 }
6422 }
6423
tndrcade_sub_read(UINT16 address)6424 static UINT8 tndrcade_sub_read(UINT16 address)
6425 {
6426 switch (address)
6427 {
6428 case 0x0800: return 0xff;
6429 case 0x1000: return DrvInputs[0];
6430 case 0x1001: return DrvInputs[1];
6431 case 0x1002: return DrvInputs[2];
6432 case 0x2000: return BurnYM2203Read(0, 0);
6433 case 0x2001: return BurnYM2203Read(0, 1);
6434 }
6435
6436 return 0;
6437 }
6438
tndrcade68kInit()6439 static void tndrcade68kInit()
6440 {
6441 SekInit(0, 0x68000);
6442 SekOpen(0);
6443 SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
6444 SekMapMemory(DrvPalRAM, 0x380000, 0x3803ff, MAP_RAM);
6445 SekMapMemory(DrvSprRAM0, 0x600000, 0x600607 | 0x7ff, MAP_RAM);
6446 SekMapMemory(DrvShareRAM, 0xa00000, 0xa00fff, MAP_WRITE); // m65c02 not emulated, simulate instead
6447 SekMapMemory(DrvSprRAM1, 0xc00000, 0xc03fff, MAP_RAM);
6448 SekMapMemory(Drv68KRAM, 0xe00000, 0xe03fff, MAP_RAM);
6449 SekMapMemory(Drv68KRAM, 0xffc000, 0xffffff, MAP_RAM);
6450
6451 SekMapHandler(3, 0xa00000, 0xa00fff, MAP_READ | MAP_WRITE);
6452 SekSetReadByteHandler (3, twineagl_sharedram_read_byte);
6453 SekSetReadWordHandler (3, twineagl_sharedram_read_word);
6454 SekSetWriteWordHandler(3, twineagl_sharedram_write_word);
6455 SekSetWriteByteHandler(3, twineagl_sharedram_write_byte);
6456 SekClose();
6457
6458 BurnLoadRom(DrvSubROM + 0x0004000, 4, 1);
6459 BurnLoadRom(DrvSubROM + 0x000c000, 4, 1);
6460
6461 M6502Init(0, TYPE_M65C02);
6462 M6502Open(0);
6463 M6502MapMemory(DrvSubRAM, 0x0000, 0x01ff, MAP_RAM);
6464 M6502MapMemory(DrvShareRAM, 0x5000, 0x57ff, MAP_RAM);
6465 M6502MapMemory(DrvSubROM + 0x6000, 0x6000, 0x7fff, MAP_ROM);
6466 //M6502MapMemory(DrvSubROM + 0xc000, 0x8000, 0xbfff, MAP_ROM); // bank default
6467 M6502MapMemory(DrvSubROM + 0xc000, 0xc000, 0xffff, MAP_ROM);
6468 M6502SetWriteHandler(tndrcade_sub_write);
6469 M6502SetReadHandler(tndrcade_sub_read);
6470 M6502Close();
6471 m65c02_mode = 1;
6472
6473 }
6474
kiwame68kInit()6475 static void kiwame68kInit()
6476 {
6477 SekInit(0, 0x68000);
6478 SekOpen(0);
6479 SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
6480 SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
6481 SekMapMemory(DrvSprRAM1, 0x800000, 0x803fff, MAP_RAM);
6482 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
6483 SekMapMemory(DrvPalRAM, 0xb00000, 0xb003ff, MAP_RAM);
6484 SekMapMemory(DrvNVRAM, 0xfffc00, 0xffffff, MAP_WRITE);
6485
6486 SekSetReadWordHandler(0, kiwame_read_word);
6487 SekSetReadByteHandler(0, kiwame_read_byte);
6488
6489 SekMapHandler(1, 0xc00000, 0xc03fff, MAP_READ | MAP_WRITE);
6490 SekSetReadWordHandler (1, setaSoundRegReadWord);
6491 SekSetReadByteHandler (1, setaSoundRegReadByte);
6492 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
6493 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
6494 SekClose();
6495
6496 {
6497 // give the game proper vectors
6498 *((UINT16 *)(Drv68KROM + 0x00064)) = 0x0000;
6499 *((UINT16 *)(Drv68KROM + 0x00066)) = 0x0dca;
6500
6501 // get past backup ram error
6502 // the game never actually tests it before failing??
6503 *((UINT16 *)(Drv68KROM + 0x136d2)) = 0x6052;
6504 }
6505 }
6506
twineagle_extram_read_byte(UINT32 address)6507 static UINT8 __fastcall twineagle_extram_read_byte(UINT32 address)
6508 {
6509 return DrvNVRAM[address & 0x3fe];
6510 }
6511
twineagl_sub_read(UINT16 address)6512 static UINT8 twineagl_sub_read(UINT16 address)
6513 {
6514 switch (address)
6515 {
6516 case 0x0800: return soundlatch;
6517 case 0x0801: return soundlatch2;
6518 case 0x1000: return DrvInputs[0];
6519 case 0x1001: return DrvInputs[1];
6520 case 0x1002: return DrvInputs[2];
6521 }
6522
6523 return 0;
6524 }
6525
twineagle68kInit()6526 static void twineagle68kInit()
6527 {
6528 downtown68kInit();
6529
6530 SekOpen(0);
6531 SekMapMemory(DrvNVRAM, 0x200000, 0x2003ff, MAP_WRITE);
6532 SekMapHandler(2, 0x200000, 0x2003ff, MAP_READ);
6533 SekSetReadByteHandler (2, twineagle_extram_read_byte);
6534
6535 SekMapHandler(3, 0xb00000, 0xb00fff, MAP_READ | MAP_WRITE);
6536 SekSetReadByteHandler (3, twineagl_sharedram_read_byte);
6537 SekSetReadWordHandler (3, twineagl_sharedram_read_word);
6538 SekSetWriteWordHandler(3, twineagl_sharedram_write_word);
6539 SekSetWriteByteHandler(3, twineagl_sharedram_write_byte);
6540 SekClose();
6541
6542 BurnByteswap(Drv68KROM, 0x80000);
6543
6544 BurnLoadRom(DrvSubROM + 0x0006000, 1, 1);
6545 memcpy(DrvSubROM + 0x0008000, DrvSubROM + 0x0006000, 0x2000);
6546 memcpy(DrvSubROM + 0x000a000, DrvSubROM + 0x0006000, 0x2000);
6547 memcpy(DrvSubROM + 0x000c000, DrvSubROM + 0x0006000, 0x2000);
6548 memcpy(DrvSubROM + 0x000e000, DrvSubROM + 0x0006000, 0x2000);
6549
6550 M6502Init(0, TYPE_M65C02);
6551 M6502Open(0);
6552 M6502MapMemory(DrvSubRAM, 0x0000, 0x01ff, MAP_RAM);
6553 M6502MapMemory(DrvShareRAM, 0x5000, 0x57ff, MAP_RAM);
6554 M6502MapMemory(DrvSubROM + 0x7000, 0x7000, 0x7fff, MAP_ROM);
6555 M6502MapMemory(DrvSubROM + 0xc000, 0x8000, 0xbfff, MAP_ROM); // bank default
6556 M6502MapMemory(DrvSubROM + 0xc000, 0xc000, 0xffff, MAP_ROM);
6557 M6502SetWriteHandler(downtown_sub_write);
6558 M6502SetReadHandler(twineagl_sub_read);
6559 M6502Close();
6560 m65c02_mode = 1;
6561 }
6562
crazyfgt68kInit()6563 static void crazyfgt68kInit()
6564 {
6565 SekInit(0, 0x68000);
6566 SekOpen(0);
6567 SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
6568 SekMapMemory(Drv68KRAM, 0x400000, 0x40ffff, MAP_RAM);
6569 SekMapMemory(DrvPalRAM, 0x640400, 0x640fff, MAP_RAM);
6570 SekMapMemory(DrvVidRAM1, 0x800000, 0x803fff, MAP_RAM);
6571 SekMapMemory(DrvVidRAM0, 0x880000, 0x883fff, MAP_RAM);
6572 SekMapMemory(DrvSprRAM0, 0xa00000, 0xa00607 | 0x7ff, MAP_RAM);
6573 SekMapMemory(DrvSprRAM1, 0xb00000, 0xb03fff, MAP_RAM);
6574 SekSetWriteWordHandler(0, crazyfgt_write_word);
6575 SekSetWriteByteHandler(0, crazyfgt_write_byte);
6576 SekSetReadWordHandler(0, crazyfgt_read_word);
6577 SekSetReadByteHandler(0, crazyfgt_read_byte);
6578 SekClose();
6579
6580 MSM6295Exit(0);
6581 MSM6295Init(0, 4433619 / 4 / MSM6295_PIN7_HIGH, 1);
6582 MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
6583 MSM6295SetBank(0, DrvSndROM, 0, 0x3ffff);
6584
6585 // Patch protection
6586 *((UINT16*)(Drv68KROM + 0x1078)) = 0x4e71;
6587
6588 BlandiaGfxRearrange(); // fix bg tiles
6589 }
6590
calibr50_sub_write(UINT16 address,UINT8 data)6591 static void calibr50_sub_write(UINT16 address, UINT8 data)
6592 {
6593 if (address <= 0x1fff) { // x1_010
6594 setaSoundRegWriteByte8bit(address, data);
6595 return;
6596 }
6597
6598 switch (address)
6599 {
6600 case 0x4000:
6601 m65c02_sub_bankswitch(data);
6602 return;
6603
6604 case 0xc000:
6605 {
6606 soundlatch2 = data;
6607 M6502ReleaseSlice();
6608 return;
6609 }
6610 }
6611 }
6612
calibr50_sub_read(UINT16 address)6613 static UINT8 calibr50_sub_read(UINT16 address)
6614 {
6615 if (address <= 0x1fff) { // x1_010
6616 return x1010_sound_read(address);
6617 }
6618
6619 switch (address)
6620 {
6621 case 0x4000: {
6622 return soundlatch;
6623 }
6624 }
6625
6626 return 0;
6627 }
6628
calibr5068kInit()6629 static void calibr5068kInit()
6630 {
6631 SekInit(0, 0x68000);
6632 SekOpen(0);
6633 SekMapMemory(Drv68KROM, 0x000000, 0x09ffff, MAP_ROM);
6634 SekMapMemory(Drv68KRAM2, 0x200000, 0x200fff, MAP_RAM);
6635 SekMapMemory(Drv68KRAM3, 0xc00000, 0xc000ff, MAP_RAM);
6636 SekMapMemory(DrvPalRAM, 0x700000, 0x7003ff, MAP_RAM);
6637 SekMapMemory(DrvVidRAM0, 0x900000, 0x904fff, MAP_RAM);
6638 SekMapMemory(DrvSprRAM0, 0xd00000, 0xd00607 | 0x7ff, MAP_RAM);
6639 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe03fff, MAP_RAM);
6640 SekMapMemory(Drv68KRAM, 0xff0000, 0xffffff, MAP_RAM);
6641 SekSetWriteWordHandler(0, calibr50_write_word);
6642 SekSetWriteByteHandler(0, calibr50_write_byte);
6643 SekSetReadWordHandler(0, calibr50_read_word);
6644 SekSetReadByteHandler(0, calibr50_read_byte);
6645 SekClose();
6646
6647 // m65c02 sound...
6648 M6502Init(0, TYPE_M65C02);
6649 M6502Open(0);
6650 M6502MapMemory(DrvSubROM, 0xC000, 0xffff, MAP_ROM);
6651 M6502MapMemory(DrvSubROM + 0x4000, 0x8000, 0xbfff, MAP_ROM);
6652 BurnLoadRom(DrvSubROM + 0x4000, 4, 1);
6653 BurnLoadRom(DrvSubROM + 0xc000, 4, 1);
6654 M6502SetWriteHandler(calibr50_sub_write);
6655 M6502SetReadHandler(calibr50_sub_read);
6656 M6502Close();
6657 m65c02_mode = 1;
6658
6659 RotateSetGunPosRAM(Drv68KRAM + (0x2503-1), Drv68KRAM + (0x2527-1), 2);
6660 game_rotates = 1;
6661 }
6662
usclssic68kInit()6663 static void usclssic68kInit()
6664 {
6665 SekInit(0, 0x68000);
6666 SekOpen(0);
6667 SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
6668 SekMapMemory(DrvSprRAM0, 0x800000, 0x800607 | 0x7ff, MAP_RAM);
6669 SekMapMemory(DrvPalRAM, 0xb00000, 0xb003ff, MAP_RAM);
6670 SekMapMemory(DrvSprRAM1, 0xc00000, 0xc03fff, MAP_RAM);
6671 SekMapMemory(DrvVidRAM0, 0xd00000, 0xd04fff, MAP_RAM);
6672 SekMapMemory(Drv68KRAM2, 0xe00000, 0xe00fff, MAP_RAM);
6673 SekMapMemory(Drv68KRAM, 0xff0000, 0xffffff, MAP_RAM);
6674 SekSetWriteWordHandler(0, usclssic_write_word);
6675 SekSetWriteByteHandler(0, usclssic_write_byte);
6676 SekSetReadWordHandler(0, usclssic_read_word);
6677 SekSetReadByteHandler(0, usclssic_read_byte);
6678 SekClose();
6679
6680 // m65c02 sound...
6681 M6502Init(0, TYPE_M65C02);
6682 M6502Open(0);
6683 M6502MapMemory(DrvSubROM, 0xC000, 0xffff, MAP_ROM);
6684 M6502MapMemory(DrvSubROM + 0x4000, 0x8000, 0xbfff, MAP_ROM);
6685 BurnLoadRom(DrvSubROM + 0x4000, 4, 1);
6686 BurnLoadRom(DrvSubROM + 0xc000, 4, 1);
6687 M6502SetWriteHandler(calibr50_sub_write);
6688 M6502SetReadHandler(calibr50_sub_read);
6689 M6502Close();
6690 m65c02_mode = 1;
6691 }
6692
6693 //-----------------------------------------------------------------------------------------------------------------------------------
6694
DrvFMIRQHandler(INT32,INT32 nStatus)6695 static void DrvFMIRQHandler(INT32, INT32 nStatus)
6696 {
6697 ZetSetIRQLine(0x20, (nStatus) ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE);
6698 }
6699
DrvYM2203ReadPortA(UINT32)6700 static UINT8 DrvYM2203ReadPortA(UINT32)
6701 {
6702 return DrvDips[1];
6703 }
6704
DrvYM2203ReadPortB(UINT32)6705 static UINT8 DrvYM2203ReadPortB(UINT32)
6706 {
6707 return DrvDips[0];
6708 }
6709
DrvGfxDecode(INT32 type,UINT8 * gfx,INT32 num)6710 static INT32 DrvGfxDecode(INT32 type, UINT8 *gfx, INT32 num)
6711 {
6712 DrvGfxTransMask[num] = NULL;
6713
6714 INT32 len = DrvROMLen[num];
6715 if (DrvROMLen[num] == 0) DrvGfxMask[num] = 1; // no divide by 0
6716 if (len == 0 || type == -1) return 0;
6717
6718 INT32 Plane0[4] = { ((len * 8) / 2) + 8, ((len * 8) / 2) + 0, 8, 0 };
6719 INT32 XOffs0[16] = { 0,1,2,3,4,5,6,7, 128,129,130,131,132,133,134,135 };
6720 INT32 YOffs0[16] = { 0*16,1*16,2*16,3*16,4*16,5*16,6*16,7*16, 16*16,17*16,18*16,19*16,20*16,21*16,22*16,23*16 };
6721
6722 INT32 Plane1[4] = { 0, 4, ((len * 8) / 2) + 0, ((len * 8) / 2) + 4 };
6723 INT32 Plane1a[6] = { (((len * 8) / 3) * 0) + 0, (((len * 8) / 3) * 0) + 4, (((len * 8) / 3) * 1) + 0, (((len * 8) / 3) * 1) + 4, (((len * 8) / 3) * 2) + 0, (((len * 8) / 3) * 2) + 4 };
6724 INT32 XOffs1[16] = { 128+64,128+65,128+66,128+67, 128+0,128+1,128+2,128+3, 8*8+0,8*8+1,8*8+2,8*8+3, 0,1,2,3 };
6725 INT32 YOffs1[16] = { 0*8,1*8,2*8,3*8,4*8,5*8,6*8,7*8, 32*8,33*8,34*8,35*8,36*8,37*8,38*8,39*8 };
6726
6727 INT32 Plane2[6] = { ((len * 8) / 2)+0*4, ((len * 8) / 2)+1*4, 2*4,3*4,0*4,1*4 };
6728 INT32 XOffs2[16] = { 256+128,256+129,256+130,256+131, 256+0,256+1,256+2,256+3, 128,129,130,131, 0,1,2,3 };
6729 INT32 YOffs2[16] = { 0*16,1*16,2*16,3*16,4*16,5*16,6*16,7*16, 32*16,33*16,34*16,35*16,36*16,37*16,38*16,39*16 };
6730
6731 INT32 Plane3[4] = { ((len * 8) / 4) * 0, ((len * 8) / 4) * 1, ((len * 8) / 4) * 2, ((len * 8) / 4) * 3 };
6732 INT32 XOffs3[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 64, 65, 66, 67, 68, 69, 70, 71 };
6733 INT32 YOffs3[16] = { 0, 8, 16, 24, 32, 40, 48, 56, 128+0, 128+8, 128+16, 128+24, 128+32, 128+40, 128+48, 128+56 };
6734 INT32 YOffs3a[16]= { 0*8, 16*8, 4*8, 20*8, 2*8, 18*8, 6*8, 22*8, 1*8, 17*8, 5*8, 21*8, 3*8, 19*8, 7*8, 23*8 }; // wiggie
6735 INT32 YOffs3b[16]= { 0*8, 2*8, 16*8, 18*8, 1*8, 3*8, 17*8, 19*8, 4*8, 6*8, 20*8, 22*8, 5*8, 7*8,21*8, 23*8 }; // superbar
6736
6737 UINT8 *tmp = (UINT8*)BurnMalloc(len);
6738 if (tmp == NULL) {
6739 return 1;
6740 }
6741
6742 memcpy (tmp, gfx, len);
6743
6744 switch (type)
6745 {
6746 case 0: // layout_planes_2roms
6747 GfxDecode((len * 2) / (16 * 16), 4, 16, 16, Plane0, XOffs0, YOffs0, 0x200, tmp, gfx);
6748 DrvGfxMask[num] = (len * 2) / (16 * 16);
6749 ColorDepths[num] = 4;
6750 break;
6751
6752 case 1: // layout_planes_2roms_split
6753 GfxDecode((len * 2) / (16 * 16), 4, 16, 16, Plane1, XOffs1, YOffs1, 0x200, tmp, gfx);
6754 DrvGfxMask[num] = (len * 2) / (16 * 16);
6755 ColorDepths[num] = 4;
6756 break;
6757
6758 case 2: // layout_packed
6759 GfxDecode((len * 2) / (16 * 16), 4, 16, 16, Plane2 + 2, XOffs2, YOffs2, 0x400, tmp, gfx);
6760 DrvGfxMask[num] = (len * 2) / (16 * 16);
6761 ColorDepths[num] = 4;
6762 break;
6763
6764 case 3: // layout_packed_6bits_2roms
6765 GfxDecode((len * 1) / (16 * 16), 6, 16, 16, Plane2 + 0, XOffs2, YOffs2, 0x400, tmp, gfx);
6766 DrvGfxMask[num] = (len * 1) / (16 * 16);
6767 ColorDepths[num] = 6; //handled like 4
6768 break;
6769
6770 case 4: // layout_packed_6bits_3roms
6771 GfxDecode(((len * 8)/6) / (16 * 16), 6, 16, 16, Plane1a, XOffs1, YOffs1, 0x200, tmp, gfx);
6772 DrvGfxMask[num] = ((len * 8)/6) / (16 * 16);
6773 ColorDepths[num] = 6; //handled like 4
6774 break;
6775
6776 case 5: // layout_planes
6777 GfxDecode((len * 2) / (16 * 16), 4, 16, 16, Plane3, XOffs3, YOffs3 , 0x100, tmp, gfx);
6778 DrvGfxMask[num] = (len * 2) / (16 * 16);
6779 ColorDepths[num] = 4;
6780 break;
6781
6782 case 6: // wiggie_layout
6783 GfxDecode((len * 2) / (16 * 16), 4, 16, 16, Plane3, XOffs3, YOffs3a, 0x100, tmp, gfx);
6784 DrvGfxMask[num] = (len * 2) / (16 * 16);
6785 ColorDepths[num] = 4;
6786 break;
6787
6788 case 7: // superbar_layout
6789 GfxDecode((len * 2) / (16 * 16), 4, 16, 16, Plane3, XOffs3, YOffs3b, 0x100, tmp, gfx);
6790 DrvGfxMask[num] = (len * 2) / (16 * 16);
6791 ColorDepths[num] = 4;
6792 break;
6793 }
6794
6795 BurnFree (tmp);
6796
6797 {
6798 INT32 size = DrvGfxMask[num];
6799
6800 DrvGfxTransMask[num] = (UINT8*)BurnMalloc(size);
6801
6802 for (INT32 i = 0; i < size << 8; i += (1 << 8)) {
6803 DrvGfxTransMask[num][i >> 8] = 1; // transparent
6804 for (INT32 j = 0; j < (1 << 8); j++) {
6805 if (gfx[i + j]) {
6806 DrvGfxTransMask[num][i >> 8] = 0;
6807 break;
6808 }
6809 }
6810 }
6811 }
6812
6813 return 0;
6814 }
6815
DrvLoadRoms(INT32 bload)6816 static INT32 DrvLoadRoms(INT32 bload)
6817 {
6818 char* pRomName;
6819 struct BurnRomInfo ri, rh;
6820
6821 UINT8 *LoadPrg[2] = { Drv68KROM, DrvSubROM };
6822 UINT8 *LoadGfx[5] = { DrvGfxROM0, DrvGfxROM1, DrvGfxROM2, DrvSndROM, DrvColPROM };
6823
6824 for (INT32 i = 0; !BurnDrvGetRomName(&pRomName, i, 0); i++) {
6825
6826 BurnDrvGetRomInfo(&ri, i + 0);
6827 BurnDrvGetRomInfo(&rh, i + 1);
6828
6829 if ((ri.nType & 7) < 3 && (ri.nType & 7)) {
6830 INT32 type = (ri.nType - 1) & 1;
6831
6832 if ((rh.nType & 7) == 1 && (rh.nLen == ri.nLen)) {
6833 if (bload) if (BurnLoadRom(LoadPrg[type] + 0, i + 1, 2)) return 1;
6834 if (bload) if (BurnLoadRom(LoadPrg[type] + 1, i + 0, 2)) return 1;
6835 LoadPrg[type] += ri.nLen * 2;
6836 i++; // loading two roms
6837 } else {
6838 if (bload) if (BurnLoadRom(LoadPrg[type], i, 1)) return 1;
6839 LoadPrg[type] += ri.nLen;
6840 }
6841 continue;
6842 }
6843
6844 if ((ri.nType & 7) == 3 || (ri.nType & 7) == 4 || (ri.nType & 7) == 5 || (ri.nType & 7) == 6 || (ri.nType & 7) == 7) { // gfx, snd, colprom
6845 INT32 type = (ri.nType & 7) - 3;
6846
6847 if (ri.nType & 8) { // interleaved...
6848 if (bload) if (BurnLoadRom(LoadGfx[type] + 0, i + 0, 2)) return 1;
6849
6850 if ((ri.nType & 16) == 0) { // zingzap
6851 if (bload) if (BurnLoadRom(LoadGfx[type] + 1, i + 1, 2)) return 1;
6852 i++;
6853 }
6854
6855 LoadGfx[type] += ri.nLen * 2;
6856 } else {
6857 if (bload) if (BurnLoadRom(LoadGfx[type], i, 1)) return 1;
6858 LoadGfx[type] += ri.nLen;
6859 }
6860
6861 continue;
6862 }
6863 }
6864
6865 if (bload == 0) {
6866 DrvROMLen[0] = LoadGfx[0] - DrvGfxROM0;
6867 DrvROMLen[1] = LoadGfx[1] - DrvGfxROM1;
6868 DrvROMLen[2] = LoadGfx[2] - DrvGfxROM2;
6869 DrvROMLen[3] = LoadGfx[3] - DrvSndROM;
6870 DrvROMLen[4] = LoadGfx[4] - DrvColPROM;
6871 }
6872
6873 return 0;
6874 }
6875
DrvDoReset(INT32 ram)6876 static INT32 DrvDoReset(INT32 ram)
6877 {
6878 if (ram) memset (AllRam, 0, RamEnd - AllRam);
6879
6880 SekOpen(0);
6881 SekReset();
6882 SekClose();
6883
6884 if (has_z80) {
6885 ZetOpen(0); // wiggie, utoukond, superbar
6886 ZetReset();
6887 ZetClose();
6888 }
6889
6890 if (m65c02_mode) {
6891 M6502Open(0);
6892 M6502Reset();
6893 m65c02_sub_bankswitch(0);
6894 M6502Close();
6895 soundlatch = 0;
6896 soundlatch2 = 0;
6897 sub_ctrl_data = 0;
6898 }
6899
6900 x1010Reset();
6901 MSM6295Reset(0);
6902 BurnYM3438Reset();
6903 BurnYM3812Reset();
6904 if (has_2203) {
6905 BurnYM2203Reset();
6906 }
6907
6908 if (game_rotates)
6909 RotateReset();
6910
6911 HiscoreReset();
6912
6913 watchdog = 0;
6914
6915 return 0;
6916 }
6917
MemIndex()6918 static INT32 MemIndex()
6919 {
6920 UINT8 *Next; Next = AllMem;
6921
6922 Drv68KROM = Next; Next += 0x200000;
6923 DrvSubROM = Next; Next += 0x050000;
6924
6925 DrvGfxROM2 = Next; Next += DrvROMLen[2] * 2;
6926 DrvGfxROM1 = Next; Next += DrvROMLen[1] * 2;
6927 DrvGfxROM0 = Next; Next += DrvROMLen[0] * 2;
6928
6929 DrvColPROM = Next; Next += 0x000800;
6930
6931 MSM6295ROM = Next;
6932 X1010SNDROM = Next;
6933 DrvSndROM = Next; Next += DrvROMLen[3] + 0x200000; // for banking
6934
6935 Palette = (UINT32*)Next; Next += BurnDrvGetPaletteEntries() * sizeof(UINT32);
6936 DrvPalette = (UINT32*)Next; Next += BurnDrvGetPaletteEntries() * sizeof(UINT32);
6937
6938 DrvNVRAM = Next; Next += 0x000400;
6939
6940 AllRam = Next;
6941
6942 Drv68KRAM = Next; Next += 0x100000;
6943 Drv68KRAM2 = Next; Next += 0x020000;
6944 Drv68KRAM3 = Next; Next += 0x001000;
6945 DrvSubRAM = Next; Next += 0x004000;
6946 DrvPalRAM = Next; Next += 0x001000;
6947 DrvSprRAM0 = Next; Next += 0x000800;
6948 DrvSprRAM1 = Next; Next += 0x014000;
6949
6950 DrvVidRAM0 = Next; Next += 0x010000;
6951 DrvVIDCTRLRAM0 = Next; Next += 0x000008;
6952
6953 DrvVidRAM1 = Next; Next += 0x010000;
6954 DrvVIDCTRLRAM1 = Next; Next += 0x000008;
6955
6956 DrvVideoRegs = Next; Next += 0x000008;
6957
6958 tilebank = Next; Next += 0x000004;
6959 tile_offset = (UINT32*)Next; Next += 0x000001 * sizeof(UINT32);
6960
6961 DrvShareRAM = Next; Next += 0x001000;
6962
6963 RamEnd = Next;
6964 MemEnd = Next;
6965
6966 return 0;
6967 }
6968
DrvSetVideoOffsets(INT32 spritex,INT32 spritex_flipped,INT32 tilesx,INT32 tilesx_flipped)6969 static void DrvSetVideoOffsets(INT32 spritex, INT32 spritex_flipped, INT32 tilesx, INT32 tilesx_flipped)
6970 {
6971 VideoOffsets[0][0] = spritex;
6972 VideoOffsets[0][1] = spritex_flipped;
6973 VideoOffsets[1][0] = tilesx;
6974 VideoOffsets[1][1] = tilesx_flipped;
6975 }
6976
DrvSetColorOffsets(INT32 gfx0,INT32 gfx1,INT32 gfx2)6977 static void DrvSetColorOffsets(INT32 gfx0, INT32 gfx1, INT32 gfx2)
6978 {
6979 ColorOffsets[0] = gfx0;
6980 ColorOffsets[1] = gfx1;
6981 ColorOffsets[2] = gfx2;
6982 }
6983
DrvSetDefaultColorTable()6984 static void DrvSetDefaultColorTable()
6985 {
6986 for (INT32 i = 0; i < BurnDrvGetPaletteEntries(); i++) {
6987 Palette[i] = i;
6988 }
6989 }
6990
zingzapSetColorTable()6991 static void zingzapSetColorTable()
6992 {
6993 for (INT32 color = 0; color < 0x20; color++) {
6994 for (INT32 pen = 0; pen < 0x40; pen++) {
6995 Palette[0x400 + ((color << 6) | pen)] = 0x400 + (((color << 4) + pen) & 0x1ff);
6996 }
6997 }
6998 }
6999
jjsquawkSetColorTable()7000 static void jjsquawkSetColorTable()
7001 {
7002 for (INT32 color = 0; color < 0x20; color++) {
7003 for (INT32 pen = 0; pen < 0x40; pen++) {
7004 Palette[0x200 + ((color << 6) | pen)] = 0x400 + (((color << 4) + pen) & 0x1ff);
7005 Palette[0xa00 + ((color << 6) | pen)] = 0x200 + (((color << 4) + pen) & 0x1ff);
7006 }
7007 }
7008 }
7009
gundharaSetColorTable()7010 static void gundharaSetColorTable()
7011 {
7012 for (INT32 color = 0; color < 0x20; color++) {
7013 for (INT32 pen = 0; pen < 0x40; pen++) {
7014 Palette[0x200 + ((color << 6) | pen)] = 0x400 + ((((color & ~3) << 4) + pen) & 0x1ff);
7015 Palette[0xa00 + ((color << 6) | pen)] = 0x200 + ((((color & ~3) << 4) + pen) & 0x1ff);
7016 }
7017 }
7018 }
7019
blandiaSetColorTable()7020 static void blandiaSetColorTable()
7021 {
7022 for (INT32 color = 0; color < 0x20; color++) {
7023 for (INT32 pen = 0; pen < 0x40; pen++) {
7024 Palette[0x200 + ((color << 6) | pen)] = 0x200 + ((color << 4) | (pen & 0x0f));
7025 Palette[0xa00 + ((color << 6) | pen)] = 0x400 + pen;
7026 }
7027 }
7028 }
7029
usclssicSetColorTable()7030 static void usclssicSetColorTable()
7031 {
7032 memcpy (DrvColPROM + 0x600, DrvColPROM + 0x000, 0x200);
7033 // memcpy (DrvColPROM + 0x200, DrvColPROM + 0x200, 0x200);
7034
7035 for (INT32 color = 0; color < BurnDrvGetPaletteEntries(); color++) {
7036 Palette[color] = color;
7037 }
7038
7039 for (INT32 color = 0; color < 0x20; color++) {
7040 for (INT32 pen = 0; pen < 0x40; pen++) {
7041 Palette[0x200 + ((color << 6) | pen)] = 0x200 + ((((color & ~3) << 4) + pen) & 0x1ff);
7042 Palette[0xA00 + ((color << 6) | pen)] = 0x200 + ((((color & ~3) << 4) + pen) & 0x1ff);
7043 }
7044 }
7045 }
7046
DrvInit(void (* p68kInit)(),INT32 cpu_speed,INT32 irq_type,INT32 spr_buffer,INT32 gfxtype0,INT32 gfxtype1,INT32 gfxtype2)7047 static INT32 DrvInit(void (*p68kInit)(), INT32 cpu_speed, INT32 irq_type, INT32 spr_buffer, INT32 gfxtype0, INT32 gfxtype1, INT32 gfxtype2)
7048 {
7049 BurnSetRefreshRate((1.00 * refresh_rate)/100);
7050
7051 if (pRomLoadCallback) {
7052 pRomLoadCallback(0);
7053 } else {
7054 DrvLoadRoms(0);
7055 }
7056
7057 BurnAllocMemIndex();
7058
7059 if (pRomLoadCallback) {
7060 if (pRomLoadCallback(1)) return 1;
7061 } else {
7062 if (DrvLoadRoms(1)) return 1;
7063 }
7064
7065 // make sure these are initialized so that we can use common routines
7066 MSM6295Init(0, 1000000 / 132, 0);
7067 MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
7068
7069 if (p68kInit) {
7070 p68kInit();
7071 }
7072
7073 DrvGfxDecode(gfxtype0, DrvGfxROM0, 0);
7074 DrvGfxDecode(gfxtype1, DrvGfxROM1, 1);
7075 DrvGfxDecode(gfxtype2, DrvGfxROM2, 2);
7076
7077 cpuspeed = cpu_speed;
7078 irqtype = irq_type;
7079 buffer_sprites = spr_buffer;
7080
7081 if ((strstr(BurnDrvGetTextA(DRV_NAME), "calibr50")) || (strstr(BurnDrvGetTextA(DRV_NAME), "usclssic"))) {
7082 x1010_sound_init(16000000, 0x1000);
7083 } else {
7084 x1010_sound_init(16000000, 0x0000);
7085 }
7086 x1010_set_route(BURN_SND_X1010_ROUTE_2, 1.00, BURN_SND_ROUTE_RIGHT);
7087 x1010_set_route(BURN_SND_X1010_ROUTE_1, 1.00, BURN_SND_ROUTE_LEFT);
7088
7089 if (strstr(BurnDrvGetTextA(DRV_NAME), "madshark") || strstr(BurnDrvGetTextA(DRV_NAME), "gundhara"))
7090 x1010_set_route(BURN_SND_X1010_ROUTE_1, 1.00, BURN_SND_ROUTE_BOTH);
7091
7092 if (strstr(BurnDrvGetTextA(DRV_NAME), "kamenrid") || strstr(BurnDrvGetTextA(DRV_NAME), "wrofaero") || strstr(BurnDrvGetTextA(DRV_NAME), "sokonuke"))
7093 x1010_set_route(BURN_SND_X1010_ROUTE_2, 1.00, BURN_SND_ROUTE_BOTH);
7094
7095 if (strstr(BurnDrvGetTextA(DRV_NAME), "tndrcade"))
7096 has_2203 = 1;
7097
7098 BurnYM3812Init(1, 4000000, NULL, 0);
7099 BurnTimerAttachYM3812(&SekConfig, 16000000);
7100 BurnYM3812SetRoute(0, BURN_SND_YM3812_ROUTE, (has_2203) ? 2.00 : 1.00, BURN_SND_ROUTE_BOTH); // tndrcade (has_2203) needs louder fm3812
7101
7102 BurnYM3438Init(1, 16000000/4, &DrvFMIRQHandler, 1);
7103 if (has_z80) {
7104 BurnTimerAttach(&ZetConfig, 4000000);
7105 }
7106 BurnYM3438SetRoute(0, BURN_SND_YM3438_YM3438_ROUTE_1, 0.30, BURN_SND_ROUTE_LEFT);
7107 BurnYM3438SetRoute(0, BURN_SND_YM3438_YM3438_ROUTE_2, 0.30, BURN_SND_ROUTE_RIGHT);
7108
7109 if (has_2203) {
7110 BurnYM2203Init(1, 4000000, NULL, 1);
7111 BurnYM2203SetPorts(0, &DrvYM2203ReadPortA, &DrvYM2203ReadPortB, NULL, NULL);
7112 BurnYM2203SetAllRoutes(0, 2.00, BURN_SND_ROUTE_BOTH);
7113 BurnTimerAttach(&M6502Config, 2000000);
7114 }
7115
7116 GenericTilesInit();
7117
7118 DrvSetDefaultColorTable();
7119
7120 flipflop = 0;
7121
7122 VideoOffsets[2][0] = ((256 - nScreenHeight) / 2); // adjust for screen height
7123 VideoOffsets[2][1] = VideoOffsets[2][0];
7124
7125 BurnGunInit(2, true);
7126
7127 DrvDoReset(1);
7128
7129 return 0;
7130 }
7131
DrvExit()7132 static INT32 DrvExit()
7133 {
7134 pRomLoadCallback = NULL;
7135
7136 GenericTilesExit();
7137
7138 DrvGfxROM0 = NULL;
7139 DrvGfxROM1 = NULL;
7140 DrvGfxROM2 = NULL;
7141
7142 DrvSetColorOffsets(0, 0, 0);
7143 DrvSetVideoOffsets(0, 0, 0, 0);
7144
7145 SekExit();
7146
7147 if (has_z80) {
7148 ZetExit();
7149 }
7150
7151 if (m65c02_mode) {
7152 M6502Exit();
7153 m65c02_mode = 0;
7154 }
7155
7156 BurnGunExit();
7157
7158 x1010_exit();
7159 BurnYM3438Exit();
7160 BurnYM3812Exit();
7161 if (has_2203) {
7162 BurnYM2203Exit();
7163 }
7164
7165 MSM6295Exit(0);
7166 MSM6295ROM = NULL;
7167
7168 BurnFreeMemIndex();
7169
7170 oisipuzl_hack = 0;
7171 twineagle = 0;
7172 daiohc = 0;
7173 watchdog_enable = 0;
7174 refresh_rate = 6000;
7175 game_rotates = 0;
7176 clear_opposites = 0;
7177 has_2203 = 0;
7178 has_z80 = 0;
7179 trackball_mode = 0;
7180 usclssic = 0;
7181
7182 BurnFree (DrvGfxTransMask[0]);
7183 BurnFree (DrvGfxTransMask[2]);
7184 BurnFree (DrvGfxTransMask[1]);
7185
7186 return 0;
7187 }
7188
DrvColors(INT32 i,INT32 pal)7189 static inline void DrvColors(INT32 i, INT32 pal)
7190 {
7191 INT32 r = (pal >> 10) & 0x1f;
7192 INT32 g = (pal >> 5) & 0x1f;
7193 INT32 b = (pal >> 0) & 0x1f;
7194
7195 r = (r << 3) | (r >> 2);
7196 g = (g << 3) | (g >> 2);
7197 b = (b << 3) | (b >> 2);
7198
7199 DrvPalette[i] = BurnHighCol(r, g, b, 0);
7200 }
7201
DrvPaletteRecalc()7202 static void DrvPaletteRecalc()
7203 {
7204 UINT16 *p = (UINT16*)DrvPalRAM;
7205
7206 if (DrvROMLen[4] && DrvROMLen[4] > 1) { // usclassic color prom
7207 memcpy (DrvColPROM + 0x400, DrvPalRAM, 0x200);
7208 memcpy (DrvColPROM + 0x000, DrvPalRAM + 0x200, 0x200);
7209 p = (UINT16*)DrvColPROM;
7210 }
7211
7212 for (INT32 i = 0; i < BurnDrvGetPaletteEntries(); i++) {
7213 DrvColors(i, BURN_ENDIAN_SWAP_INT16(p[Palette[i]]));
7214 }
7215 }
7216
draw_sprites_map()7217 static void draw_sprites_map()
7218 {
7219 UINT16 *spriteram16 = (UINT16*)DrvSprRAM0;
7220
7221 INT32 ctrl = BURN_ENDIAN_SWAP_INT16(spriteram16[0x600/2]);
7222 INT32 ctrl2 = BURN_ENDIAN_SWAP_INT16(spriteram16[0x602/2]);
7223
7224 INT32 flip = ctrl & 0x40;
7225 INT32 numcol = ctrl2 & 0x0f;
7226
7227 UINT16 *src = ((UINT16*)DrvSprRAM1) + ( ((ctrl2 ^ (~ctrl2<<1)) & 0x40) ? 0x2000/2 : 0 );
7228
7229 INT32 upper = ( BURN_ENDIAN_SWAP_INT16(spriteram16[ 0x604/2 ]) & 0xFF ) +( BURN_ENDIAN_SWAP_INT16(spriteram16[ 0x606/2 ]) & 0xFF ) * 256;
7230
7231 INT32 col0 = 0;
7232 switch (ctrl & 0x0f)
7233 {
7234 case 0x01: col0 = 0x4; break; // krzybowl
7235 case 0x06: col0 = 0x8; break; // kiwame
7236 }
7237
7238 INT32 xoffs = 0;
7239 INT32 yoffs = flip ? 1 : -1;
7240
7241 if (numcol == 1) numcol = 16;
7242
7243 for (INT32 col = 0 ; col < numcol; col++)
7244 {
7245 INT32 x = BURN_ENDIAN_SWAP_INT16(spriteram16[(col * 0x20 + 0x408)/2]) & 0xff;
7246 INT32 y = BURN_ENDIAN_SWAP_INT16(spriteram16[(col * 0x20 + 0x400)/2]) & 0xff;
7247
7248 for (INT32 offs = 0; offs < 0x20; offs++)
7249 {
7250 INT32 code = BURN_ENDIAN_SWAP_INT16(src[((col+col0)&0xf) * 0x40/2 + offs + 0x800/2]);
7251 INT32 color = BURN_ENDIAN_SWAP_INT16(src[((col+col0)&0xf) * 0x40/2 + offs + 0xc00/2]);
7252
7253 INT32 flipx = code & 0x8000;
7254 INT32 flipy = code & 0x4000;
7255
7256 INT32 bank = (color & 0x0600) >> 9;
7257
7258 INT32 sx = x + xoffs + (offs & 1) * 16;
7259 INT32 sy = -(y + yoffs) + (offs / 2) * 16;
7260
7261 if (upper & (1 << col)) sx += 256;
7262
7263 if (flip) {
7264 sy = 0xf0 - sy;
7265 flipx = !flipx;
7266 flipy = !flipy;
7267 }
7268
7269 color = (color >> 11) & 0x1f;
7270 code = ((code & 0x3fff) + (bank * 0x4000)) % DrvGfxMask[0];
7271
7272 if (DrvGfxTransMask[0][code]) continue;
7273
7274 sx = ((sx + 0x10) & 0x1ff) - 0x10;
7275 sy = ((sy + 8) & 0x0ff) - 8;
7276 sy = ((sy+16-VideoOffsets[2][0])&0xff)-16;
7277
7278 Draw16x16MaskTile(pTransDraw, code, sx, sy, flipx, flipy, color, ColorDepths[0], 0, 0, DrvGfxROM0);
7279 }
7280 }
7281 }
7282
draw_sprites()7283 static void draw_sprites()
7284 {
7285 if (~nSpriteEnable & 1) return;
7286
7287 UINT16 *spriteram16 = (UINT16*)DrvSprRAM0;
7288
7289 INT32 ctrl = BURN_ENDIAN_SWAP_INT16(spriteram16[ 0x600/2 ]);
7290 INT32 ctrl2 = BURN_ENDIAN_SWAP_INT16(spriteram16[ 0x602/2 ]);
7291
7292 INT32 flip = ctrl & 0x40;
7293
7294 UINT16 *src = ((UINT16*)DrvSprRAM1) + ( ((ctrl2 ^ (~ctrl2<<1)) & 0x40) ? 0x2000/2 : 0 );
7295
7296 draw_sprites_map();
7297
7298 INT32 yoffs = oisipuzl_hack ? 32 : 0;
7299 INT32 xoffs = VideoOffsets[0][flip ? 1 : 0];
7300
7301 for (INT32 offs = (0x400-2)/2 ; offs >= 0; offs -= 1)
7302 {
7303 int code = BURN_ENDIAN_SWAP_INT16(src[offs + 0x000/2]);
7304 int sx = BURN_ENDIAN_SWAP_INT16(src[offs + 0x400/2]);
7305
7306 int sy = BURN_ENDIAN_SWAP_INT16(spriteram16[offs + 0x000/2]) & 0xff;
7307
7308 int flipx = code & 0x8000;
7309 int flipy = code & 0x4000;
7310
7311 INT32 bank = (sx & 0x0600) >> 9;
7312 INT32 color = (sx >> 11) & 0x1f;
7313
7314 if (flip)
7315 {
7316 sy = (0x100 - nScreenHeight) + 0xf0 - sy;
7317 flipx = !flipx;
7318 flipy = !flipy;
7319 }
7320
7321 code = ((code & 0x3fff) + (bank * 0x4000)) % DrvGfxMask[0];
7322
7323 if (DrvGfxTransMask[0][code]) continue;
7324
7325 sx = ((sx + xoffs + 0x10) & 0x1ff) - 0x10;
7326 sy = ((((0xf0 - sy) - (-2) + 8)) & 0x0ff) - 8;
7327 sy = ((yoffs+sy+16-VideoOffsets[2][0])&0xff)-16;
7328
7329 Draw16x16MaskTile(pTransDraw, code, sx, sy, flipx, flipy, color, ColorDepths[0], 0, ColorOffsets[0], DrvGfxROM0);
7330 }
7331 }
7332
draw_layer(UINT8 * ram,UINT8 * gfx,INT32 num,INT32 opaque,INT32 scrollx,INT32 scrolly)7333 static void draw_layer(UINT8 *ram, UINT8 *gfx, INT32 num, INT32 opaque, INT32 scrollx, INT32 scrolly)
7334 {
7335 INT32 mask = DrvGfxMask[num];
7336 INT32 depth = ColorDepths[num];
7337 INT32 color_offset = ColorOffsets[num];
7338
7339 scrollx = scrollx & 0x3ff; // offsets added in seta_update()
7340 scrolly = (scrolly + VideoOffsets[2][0]) & 0x1ff;
7341
7342 UINT16 *vram = (UINT16*)ram;
7343
7344 for (INT32 offs = 0; offs < 64 * 32; offs++)
7345 {
7346 INT32 sx = (offs & 0x3f) << 4;
7347 INT32 sy = (offs >> 6) << 4;
7348
7349 sx -= scrollx;
7350 if (sx < -15) sx += 0x400;
7351 sy -= scrolly;
7352 if (sy < -15) sy += 0x200;
7353
7354 if (sx >= nScreenWidth || sy >= nScreenHeight) continue;
7355
7356 INT32 attr = BURN_ENDIAN_SWAP_INT16(vram[offs + 0x000]);
7357 INT32 color = BURN_ENDIAN_SWAP_INT16(vram[offs + 0x800]) & 0x001f;
7358
7359 INT32 code = (attr & 0x3fff) + tile_offset[0];
7360
7361 if (twineagle) {
7362 if ((code & 0x3e00) == 0x3e00) {
7363 code = (code & 0x007f) | ((tilebank[(code & 0x0180) >> 7] >> 1) << 7);
7364 }
7365 }
7366
7367 code %= mask;
7368
7369 if (!opaque) {
7370 if (DrvGfxTransMask[num][code]) continue;
7371 }
7372
7373 INT32 flipx = attr & 0x8000;
7374 INT32 flipy = attr & 0x4000;
7375
7376 if (flipscreen) {
7377 sx = (nScreenWidth - 16) - sx;
7378 sy = (nScreenHeight - 16) - sy;
7379 flipx ^= 0x8000;
7380 flipy ^= 0x4000;
7381 }
7382
7383 if (opaque) {
7384 Draw16x16Tile(pTransDraw, code, sx, sy, flipx, flipy, color, depth, color_offset, gfx);
7385 } else {
7386 Draw16x16MaskTile(pTransDraw, code, sx, sy, flipx, flipy, color, depth, 0, color_offset, gfx);
7387 }
7388 }
7389 }
7390
seta_update(INT32 enable_tilemap2,INT32 tmap_flip)7391 static void seta_update(INT32 enable_tilemap2, INT32 tmap_flip)
7392 {
7393 INT32 layer_enable = ~0; // start all layers enabled...
7394
7395 INT32 order = 0;
7396 flipscreen = 0; //(DrvSprRAM0[0x601] & 0x40) >> 6; // disabled for now...
7397 flipscreen ^= tmap_flip;
7398
7399 INT32 visible = (nScreenHeight - 1);
7400
7401 UINT16 *vctrl0 = (UINT16*)DrvVIDCTRLRAM0;
7402 UINT16 *vctrl1 = (UINT16*)DrvVIDCTRLRAM1;
7403
7404 INT32 x_0 = BURN_ENDIAN_SWAP_INT16(vctrl0[0]);
7405 INT32 y_0 = BURN_ENDIAN_SWAP_INT16(vctrl0[1]);
7406 INT32 en0 = BURN_ENDIAN_SWAP_INT16(vctrl0[2]);
7407
7408 INT32 x_1 = BURN_ENDIAN_SWAP_INT16(vctrl1[0]);
7409 INT32 y_1 = BURN_ENDIAN_SWAP_INT16(vctrl1[1]);
7410 INT32 en1 = BURN_ENDIAN_SWAP_INT16(vctrl1[2]);
7411
7412 x_0 += 0x10 - VideoOffsets[1][flipscreen ? 1 : 0];
7413 y_0 -= (256 - visible)/2;
7414 if (flipscreen)
7415 {
7416 x_0 = -x_0 - 512;
7417 y_0 = y_0 - visible;
7418 }
7419
7420 if (enable_tilemap2)
7421 {
7422 x_1 += 0x10 - VideoOffsets[1][flipscreen ? 1 : 0];
7423 y_1 -= (256 - visible)/2;
7424 if (flipscreen)
7425 {
7426 x_1 = -x_1 - 512;
7427 y_1 = y_1 - visible;
7428 }
7429
7430 order = BURN_ENDIAN_SWAP_INT16(*((UINT16*)(DrvVideoRegs + 2)));
7431 }
7432
7433 if ( en0 & 0x08) layer_enable &= ~0x01;
7434 if (~en0 & 0x08) layer_enable &= ~0x02;
7435 if ( en1 & 0x08) layer_enable &= ~0x04;
7436 if (~en1 & 0x08) layer_enable &= ~0x08;
7437 if (enable_tilemap2 == 0) layer_enable &= ~0x0c;
7438
7439 layer_enable &= nBurnLayer;
7440
7441 BurnTransferClear();
7442
7443 if (order & 1)
7444 {
7445 if (layer_enable & 0x04) draw_layer(DrvVidRAM1 + 0x0000, DrvGfxROM2, 2, 1, x_1, y_1);
7446 if (layer_enable & 0x08) draw_layer(DrvVidRAM1 + 0x2000, DrvGfxROM2, 2, 1, x_1, y_1);
7447
7448 if ((order & 2) == 2) draw_sprites();
7449
7450 if (layer_enable & 0x01) draw_layer(DrvVidRAM0 + 0x0000, DrvGfxROM1, 1, 0, x_0, y_0);
7451 if (layer_enable & 0x02) draw_layer(DrvVidRAM0 + 0x2000, DrvGfxROM1, 1, 0, x_0, y_0);
7452
7453 if ((order & 2) == 0) draw_sprites();
7454 }
7455 else
7456 {
7457 if (layer_enable & 0x01) draw_layer(DrvVidRAM0 + 0x0000, DrvGfxROM1, 1, 1, x_0, y_0);
7458 if (layer_enable & 0x02) draw_layer(DrvVidRAM0 + 0x2000, DrvGfxROM1, 1, 1, x_0, y_0);
7459
7460 if ((order & 2) == 2) draw_sprites();
7461
7462 if (layer_enable & 0x04) draw_layer(DrvVidRAM1 + 0x0000, DrvGfxROM2, 2, 0, x_1, y_1);
7463 if (layer_enable & 0x08) draw_layer(DrvVidRAM1 + 0x2000, DrvGfxROM2, 2, 0, x_1, y_1);
7464
7465 if ((order & 2) == 0) draw_sprites();
7466 }
7467 }
7468
setaNoLayersDraw()7469 static INT32 setaNoLayersDraw()
7470 {
7471 DrvPaletteRecalc();
7472
7473 BurnTransferClear();
7474
7475 draw_sprites();
7476
7477 BurnTransferCopy(DrvPalette);
7478
7479 return 0;
7480 }
7481
seta1layerDraw()7482 static INT32 seta1layerDraw()
7483 {
7484 DrvPaletteRecalc();
7485
7486 seta_update(0, 0);
7487
7488 BurnTransferCopy(DrvPalette);
7489
7490 return 0;
7491 }
7492
seta2layerDraw()7493 static INT32 seta2layerDraw()
7494 {
7495 DrvPaletteRecalc();
7496
7497 seta_update(1, 0);
7498
7499 BurnTransferCopy(DrvPalette);
7500
7501 return 0;
7502 }
7503
zombraidDraw()7504 static INT32 zombraidDraw()
7505 {
7506 seta2layerDraw();
7507
7508 BurnGunDrawTargets();
7509
7510 return 0;
7511 }
7512
seta2layerFlippedDraw()7513 static INT32 seta2layerFlippedDraw()
7514 {
7515 DrvPaletteRecalc();
7516
7517 seta_update(1, 0);
7518
7519 BurnTransferCopy(DrvPalette);
7520
7521 return 0;
7522 }
7523
irq_generator(INT32 loop)7524 static void irq_generator(INT32 loop)
7525 {
7526 if (loop != 4 && loop != 9) return;
7527
7528 loop = (loop / 5) & 1;
7529
7530 INT32 line = (irqtype >> (loop * 8)) & 0xff;
7531 if (line & 0x80) return;
7532
7533 SekSetIRQLine(line, CPU_IRQSTATUS_AUTO);
7534 }
7535
sprite_buffer()7536 static void sprite_buffer()
7537 {
7538 if ((DrvSprRAM0[0x602] & 0x20) == 0)
7539 {
7540 if (DrvSprRAM0[0x602] & 0x40) {
7541 memcpy (DrvSprRAM1 + 0x0000, DrvSprRAM1 + 0x2000, 0x2000);
7542 } else {
7543 memcpy (DrvSprRAM1 + 0x2000, DrvSprRAM1 + 0x0000, 0x2000);
7544 }
7545 }
7546 }
7547
ClearOppositesActiveLow(UINT8 * nJoystickInputs)7548 inline void ClearOppositesActiveLow(UINT8* nJoystickInputs)
7549 {
7550 if ((*nJoystickInputs & 0x03) == 0x00) {
7551 *nJoystickInputs |= 0x03;
7552 }
7553 if ((*nJoystickInputs & 0x0c) == 0x00) {
7554 *nJoystickInputs |= 0x0c;
7555 }
7556 }
7557
DrvCommonFrame(void (* pFrameCallback)())7558 static INT32 DrvCommonFrame(void (*pFrameCallback)())
7559 {
7560 if (DrvReset) {
7561 DrvDoReset(1);
7562 }
7563
7564 if (watchdog_enable) {
7565 watchdog++;
7566 if (watchdog >= 180) {
7567 DrvDoReset(0);
7568 }
7569 }
7570
7571 {
7572 memset (DrvInputs, 0xff, 7 * sizeof(UINT16));
7573 for (INT32 i = 0; i < 16; i++) {
7574 DrvInputs[0] ^= (DrvJoy1[i] & 1) << i;
7575 DrvInputs[1] ^= (DrvJoy2[i] & 1) << i;
7576 DrvInputs[2] ^= (DrvJoy3[i] & 1) << i;
7577 DrvInputs[3] ^= (DrvJoy4[i] & 1) << i;
7578 DrvInputs[4] ^= (DrvJoy5[i] & 1) << i;
7579 DrvInputs[5] ^= (DrvJoy6[i] & 1) << i;
7580 DrvInputs[6] ^= (DrvJoy7[i] & 1) << i;
7581 }
7582
7583 if (clear_opposites) {
7584 ClearOppositesActiveLow((UINT8*)&DrvInputs[0]);
7585 ClearOppositesActiveLow((UINT8*)&DrvInputs[1]);
7586 }
7587
7588 if (game_rotates) {
7589 SuperJoy2Rotate();
7590 }
7591
7592 if (trackball_mode) trackball_input_tick();
7593
7594 BurnGunMakeInputs(0, (INT16)DrvAxis[0], (INT16)DrvAxis[1]); // zombraid
7595 BurnGunMakeInputs(1, (INT16)DrvAxis[2], (INT16)DrvAxis[3]);
7596
7597 float xRatio = (float)128 / 384;
7598 float yRatio = (float)96 / 224;
7599
7600 for (INT32 i = 0; i < 2; i++) {
7601 INT32 x = BurnGunX[i] >> 8;
7602 INT32 y = BurnGunY[i] >> 8;
7603
7604 x = (INT32)(x * xRatio);
7605 y = (INT32)(y * yRatio);
7606
7607 x -= 0xbe;
7608 y += 0x48;
7609
7610 DrvAnalogInput[0 + (i * 2)] = (UINT8)~x;
7611 DrvAnalogInput[1 + (i * 2)] = (UINT8)y;
7612 }
7613 }
7614
7615 pFrameCallback();
7616
7617 if (pBurnDraw) {
7618 BurnDrvRedraw();
7619 }
7620
7621 if (buffer_sprites) {
7622 sprite_buffer();
7623 }
7624
7625 return 0;
7626 }
7627
Drv68kmsgundam()7628 static void Drv68kmsgundam()
7629 {
7630 INT32 nInterleave = 10;
7631 INT32 nCyclesTotal[1] = { (cpuspeed * 100) / refresh_rate };
7632 INT32 nCyclesDone[1] = { 0 };
7633
7634 SekOpen(0);
7635
7636 for (INT32 i = 0; i < nInterleave; i++)
7637 {
7638 CPU_RUN(0, Sek);
7639
7640 if (i == 4 && nCurrentFrame & 2)
7641 SekSetIRQLine(4, CPU_IRQSTATUS_AUTO);
7642
7643 if (i == (nInterleave - 1))
7644 SekSetIRQLine(2, CPU_IRQSTATUS_AUTO);
7645 }
7646
7647 SekClose();
7648
7649 if (pBurnSoundOut) {
7650 x1010_sound_update();
7651 }
7652 }
7653
Drv68kNoSubFrameCallback()7654 static void Drv68kNoSubFrameCallback()
7655 {
7656 INT32 nInterleave = 10;
7657 INT32 nCyclesTotal[1] = { (cpuspeed * 100) / refresh_rate };
7658 INT32 nCyclesDone[1] = { 0 };
7659
7660 SekOpen(0);
7661
7662 for (INT32 i = 0; i < nInterleave; i++)
7663 {
7664 CPU_RUN(0, Sek);
7665
7666 irq_generator(i);
7667 }
7668
7669 SekClose();
7670
7671 if (pBurnSoundOut) {
7672 x1010_sound_update();
7673 }
7674 }
7675
DrvFrame()7676 static INT32 DrvFrame()
7677 {
7678 return DrvCommonFrame(Drv68kNoSubFrameCallback);
7679 }
7680
DrvFrameMsgundam()7681 static INT32 DrvFrameMsgundam()
7682 {
7683 return DrvCommonFrame(Drv68kmsgundam);
7684 }
7685
Drv68k_Calibr50_FrameCallback()7686 static void Drv68k_Calibr50_FrameCallback()
7687 {
7688 INT32 nInterleave = 256;
7689 INT32 nCyclesTotal[2] = { (8000000 * 100) / refresh_rate, (2000000 * 100) / refresh_rate}; //(cpuspeed * 100) / refresh_rate, ((cpuspeed/4) * 100) / refresh_rate};
7690 INT32 nCyclesDone[2] = { 0, 0 };
7691
7692 SekOpen(0);
7693 M6502Open(0);
7694
7695 for (INT32 i = 0; i < nInterleave; i++)
7696 {
7697 CPU_RUN(0, Sek);
7698
7699 if (i == 240) SekSetIRQLine(2, CPU_IRQSTATUS_AUTO);
7700 if ((i%64) == 63) SekSetIRQLine(4, CPU_IRQSTATUS_AUTO);
7701
7702 CPU_RUN(1, M6502);
7703 if (usclssic) {
7704 if (i == 240) M6502SetIRQLine(0, CPU_IRQSTATUS_HOLD);
7705 } else {// calibr50
7706 if ((i%64) == 63) M6502SetIRQLine(0, CPU_IRQSTATUS_AUTO);
7707 }
7708 }
7709
7710 SekClose();
7711 M6502Close();
7712
7713 if (pBurnSoundOut) {
7714 x1010_sound_update();
7715 }
7716 }
7717
Drv68k_KM_FrameCallback()7718 static void Drv68k_KM_FrameCallback() // kamenrid & madshark
7719 {
7720 INT32 nInterleave = 10;
7721 INT32 nCyclesTotal[1] = { (cpuspeed * 100) / refresh_rate };
7722 INT32 nCyclesDone[1] = { 0 };
7723
7724 SekOpen(0);
7725
7726 for (INT32 i = 0; i < nInterleave; i++)
7727 {
7728 CPU_RUN(0, Sek);
7729
7730 if (i & 1 && i == 1) SekSetIRQLine(2, CPU_IRQSTATUS_AUTO);
7731 }
7732
7733 if (flipflop==0) { // IRQ4 is fired every other frame
7734 SekSetIRQLine(4, CPU_IRQSTATUS_AUTO);
7735 flipflop=1;
7736 } else {
7737 flipflop=0;
7738 }
7739
7740 SekClose();
7741
7742 if (pBurnSoundOut) {
7743 x1010_sound_update();
7744 }
7745 }
7746
Drv68k_Twineagl_FrameCallback()7747 static void Drv68k_Twineagl_FrameCallback()
7748 {
7749 INT32 nInterleave = 10;
7750 INT32 nCyclesTotal[2] = { (cpuspeed * 100) / refresh_rate, (2000000 * 100) / refresh_rate };
7751 INT32 nCyclesDone[2] = { 0, 0 };
7752
7753 for (INT32 i = 0; i < nInterleave; i++)
7754 {
7755 SekOpen(0);
7756 CPU_RUN(0, Sek);
7757 irq_generator(i);
7758 SekClose();
7759
7760 M6502Open(0);
7761 CPU_RUN(1, M6502);
7762 if (i == 4) M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
7763 if (i == 9) M6502SetIRQLine(0, CPU_IRQSTATUS_AUTO);
7764 M6502Close();
7765 }
7766
7767 if (pBurnSoundOut) {
7768 x1010_sound_update();
7769 }
7770 }
7771
Drv68k_Downtown_FrameCallback()7772 static void Drv68k_Downtown_FrameCallback()
7773 {
7774 INT32 nInterleave = 10;
7775 INT32 nCyclesTotal[2] = { (cpuspeed * 100) / refresh_rate, (2000000 * 100) / refresh_rate };
7776 INT32 nCyclesDone[2] = { 0, 0 };
7777
7778 for (INT32 i = 0; i < nInterleave; i++)
7779 {
7780 SekOpen(0);
7781 CPU_RUN(0, Sek);
7782 irq_generator(i);
7783 SekClose();
7784
7785 M6502Open(0);
7786 CPU_RUN(1, M6502);
7787 if (i == 4) M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
7788 if (i == 9) M6502SetIRQLine(0, CPU_IRQSTATUS_AUTO);
7789 M6502Close();
7790 }
7791
7792 if (pBurnSoundOut) {
7793 x1010_sound_update();
7794 }
7795 }
7796
Drv68k_Tndrcade_FrameCallback()7797 static void Drv68k_Tndrcade_FrameCallback()
7798 {
7799 INT32 nInterleave = 16;
7800 INT32 nCyclesTotal[2] = { (cpuspeed * 100) / refresh_rate, (2000000 * 100) / refresh_rate };
7801
7802 SekNewFrame();
7803 M6502NewFrame();
7804
7805 SekOpen(0);
7806 M6502Open(0);
7807
7808 for (INT32 i = 0; i < nInterleave; i++)
7809 {
7810 BurnTimerUpdateYM3812((i+1) * (nCyclesTotal[0] / nInterleave));
7811 if (i == (nInterleave-1)) SekSetIRQLine(2, CPU_IRQSTATUS_AUTO);
7812
7813 BurnTimerUpdate((i+1) * (nCyclesTotal[1] / nInterleave));
7814 if (i == 4) M6502SetIRQLine(0x20, CPU_IRQSTATUS_AUTO);
7815 M6502SetIRQLine(0, CPU_IRQSTATUS_AUTO);
7816 }
7817
7818 BurnTimerEndFrameYM3812(nCyclesTotal[0]);
7819 BurnTimerEndFrame(nCyclesTotal[1]);
7820 SekClose();
7821 M6502Close();
7822
7823 if (pBurnSoundOut) {
7824 SekOpen(0);
7825 BurnYM3812Update(pBurnSoundOut, nBurnSoundLen);
7826 SekClose();
7827 M6502Open(0);
7828 BurnYM2203Update(pBurnSoundOut, nBurnSoundLen);
7829 M6502Close();
7830 }
7831 }
7832
DrvKMFrame()7833 static INT32 DrvKMFrame()
7834 {
7835 return DrvCommonFrame(Drv68k_KM_FrameCallback);
7836 }
7837
DrvCalibr50Frame()7838 static INT32 DrvCalibr50Frame()
7839 {
7840 return DrvCommonFrame(Drv68k_Calibr50_FrameCallback);
7841 }
7842
DrvTwineaglFrame()7843 static INT32 DrvTwineaglFrame()
7844 {
7845 return DrvCommonFrame(Drv68k_Twineagl_FrameCallback);
7846 }
7847
DrvDowntownFrame()7848 static INT32 DrvDowntownFrame()
7849 {
7850 return DrvCommonFrame(Drv68k_Downtown_FrameCallback);
7851 }
7852
DrvTndrcadeFrame()7853 static INT32 DrvTndrcadeFrame()
7854 {
7855 return DrvCommonFrame(Drv68k_Tndrcade_FrameCallback);
7856 }
7857
Drv68kNoSubM6295FrameCallback()7858 static void Drv68kNoSubM6295FrameCallback()
7859 {
7860 INT32 nInterleave = 10;
7861 INT32 nCyclesTotal[1] = { (cpuspeed * 100) / refresh_rate };
7862 INT32 nCyclesDone[1] = { 0 };
7863
7864 SekOpen(0);
7865
7866 for (INT32 i = 0; i < nInterleave; i++)
7867 {
7868 CPU_RUN(0, Sek);
7869
7870 irq_generator(i);
7871 }
7872
7873 SekClose();
7874
7875 if (pBurnSoundOut) {
7876 MSM6295Render(0, pBurnSoundOut, nBurnSoundLen);
7877 }
7878 }
7879
DrvM6295Frame()7880 static INT32 DrvM6295Frame()
7881 {
7882 return DrvCommonFrame(Drv68kNoSubM6295FrameCallback);
7883 }
7884
Drv68kZ80M6295FrameCallback()7885 static void Drv68kZ80M6295FrameCallback()
7886 {
7887 INT32 nInterleave = 10;
7888 INT32 nCyclesTotal[2] = { (cpuspeed * 100) / refresh_rate, (4000000 * 100) / refresh_rate };
7889 INT32 nCyclesDone[2] = { 0, 0 };
7890
7891 SekOpen(0);
7892 ZetOpen(0);
7893
7894 for (INT32 i = 0; i < nInterleave; i++)
7895 {
7896 CPU_RUN(0, Sek);
7897 CPU_RUN(1, Zet);
7898
7899 irq_generator(i);
7900 }
7901
7902 ZetClose();
7903 SekClose();
7904
7905 if (pBurnSoundOut) {
7906 MSM6295Render(0, pBurnSoundOut, nBurnSoundLen);
7907 }
7908 }
7909
DrvZ80M6295Frame()7910 static INT32 DrvZ80M6295Frame()
7911 {
7912 return DrvCommonFrame(Drv68kZ80M6295FrameCallback);
7913 }
7914
7915
Drv68kZ80YM3438FrameCallback()7916 static void Drv68kZ80YM3438FrameCallback()
7917 {
7918 INT32 nInterleave = 10;
7919 INT32 nCyclesTotal[2] = { (cpuspeed * 100) / refresh_rate, (4000000 * 100) / refresh_rate };
7920 INT32 nCyclesDone[2] = { 0, 0 };
7921
7922 ZetNewFrame();
7923
7924 SekOpen(0);
7925 ZetOpen(0);
7926
7927 for (INT32 i = 0; i < nInterleave; i++)
7928 {
7929 CPU_RUN(0, Sek);
7930 CPU_RUN_TIMER(1);
7931
7932 irq_generator(i);
7933 }
7934
7935 if (pBurnSoundOut) {
7936 x1010_sound_update();
7937 BurnYM3438Update(pBurnSoundOut, nBurnSoundLen);
7938 }
7939
7940 ZetClose();
7941 SekClose();
7942
7943 }
7944
Drv68kZ80YM3438Frame()7945 static INT32 Drv68kZ80YM3438Frame()
7946 {
7947 return DrvCommonFrame(Drv68kZ80YM3438FrameCallback);
7948 }
7949
CrazyfghtFrameCallback()7950 static void CrazyfghtFrameCallback()
7951 {
7952 SekNewFrame();
7953
7954 INT32 nInterleave = 256;
7955 INT32 nCyclesTotal[1] = { (cpuspeed * 100) / refresh_rate };
7956
7957 SekOpen(0);
7958
7959 for (INT32 i = 0; i < nInterleave; i++)
7960 {
7961 BurnTimerUpdateYM3812((i+1) * (nCyclesTotal[0] / nInterleave));
7962
7963 if ((i % 48) == 0) {
7964 SekSetIRQLine(2, CPU_IRQSTATUS_AUTO);
7965 }
7966
7967 if (i == 240) {
7968 SekSetIRQLine(1, CPU_IRQSTATUS_AUTO);
7969 }
7970 }
7971
7972 BurnTimerEndFrameYM3812(nCyclesTotal[0]);
7973
7974 if (pBurnSoundOut) {
7975 BurnYM3812Update(pBurnSoundOut, nBurnSoundLen);
7976 MSM6295Render(pBurnSoundOut, nBurnSoundLen);
7977 }
7978
7979 SekClose();
7980 }
7981
CrazyfgtFrame()7982 static INT32 CrazyfgtFrame()
7983 {
7984 return DrvCommonFrame(CrazyfghtFrameCallback);
7985 }
7986
7987
DrvScan(INT32 nAction,INT32 * pnMin)7988 static INT32 DrvScan(INT32 nAction, INT32 *pnMin)
7989 {
7990 struct BurnArea ba;
7991
7992 if (pnMin != NULL) {
7993 *pnMin = 0x029708;
7994 }
7995
7996 if (nAction & ACB_MEMORY_RAM) {
7997 memset(&ba, 0, sizeof(ba));
7998 ba.Data = AllRam;
7999 ba.nLen = RamEnd-AllRam;
8000 ba.szName = "All Ram";
8001 BurnAcb(&ba);
8002 }
8003
8004 if (nAction & ACB_NVRAM) {
8005 memset(&ba, 0, sizeof(ba));
8006 ba.Data = DrvNVRAM;
8007 ba.nLen = 0x400;
8008 ba.szName = "NV Ram";
8009 BurnAcb(&ba);
8010 }
8011
8012 if (nAction & ACB_DRIVER_DATA) {
8013 SekScan(nAction);
8014
8015 if (has_z80) {
8016 ZetScan(nAction);
8017 }
8018
8019 if (m65c02_mode) {
8020 M6502Scan(nAction);
8021 }
8022
8023 x1010_scan(nAction, pnMin);
8024 BurnYM3812Scan(nAction, pnMin);
8025 BurnYM3438Scan(nAction, pnMin);
8026 if (has_2203) {
8027 BurnYM2203Scan(nAction, pnMin);
8028 }
8029 MSM6295Scan(nAction, pnMin);
8030
8031 SCAN_VAR(soundlatch);
8032 SCAN_VAR(soundlatch2);
8033
8034 SCAN_VAR(watchdog);
8035 SCAN_VAR(flipscreen);
8036 SCAN_VAR(seta_samples_bank);
8037 SCAN_VAR(usclssic_port_select);
8038 SCAN_VAR(gun_input_bit);
8039 SCAN_VAR(gun_input_src);
8040 SCAN_VAR(m65c02_bank);
8041 SCAN_VAR(sub_ctrl_data);
8042 SCAN_VAR(flipflop);
8043
8044 if (trackball_mode) {
8045 SCAN_VAR(track_x);
8046 SCAN_VAR(track_y);
8047 SCAN_VAR(track_x_last);
8048 SCAN_VAR(track_y_last);
8049 SCAN_VAR(track_x2);
8050 SCAN_VAR(track_y2);
8051 SCAN_VAR(track_x2_last);
8052 SCAN_VAR(track_y2_last);
8053 }
8054 if (game_rotates) {
8055 SCAN_VAR(nRotateHoldInput);
8056 SCAN_VAR(nRotate);
8057 SCAN_VAR(nRotateTarget);
8058 SCAN_VAR(nRotateTry);
8059 SCAN_VAR(nRotateTime);
8060 }
8061 keroppi_pairslove_scan();
8062 }
8063
8064 if (nAction & ACB_WRITE) {
8065 INT32 tmpbank = seta_samples_bank;
8066 seta_samples_bank = -1;
8067 set_pcm_bank(tmpbank);
8068
8069 if (m65c02_mode) {
8070 M6502Open(0);
8071 m65c02_sub_bankswitch(m65c02_bank);
8072 M6502Close();
8073 }
8074 if (game_rotates) {
8075 nRotateTime[0] = nRotateTime[1] = 0;
8076 }
8077 }
8078
8079 return 0;
8080 }
8081
8082
8083 //-----------------------------------------------------------------------------------------------------------------
8084 // Nonworking games...
8085
8086 // Visco Roulette
8087
8088 static struct BurnRomInfo setaroulRomDesc[] = {
8089 { "uf1-002.u14", 0x10000, 0xb3a622b0, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8090 { "uf1-003.u16", 0x10000, 0xa6afd769, 0x01 | BRF_PRG | BRF_ESS }, // 1
8091
8092 { "uf0-005.u3", 0x08000, 0x383c2d57, 0x03 | BRF_GRA }, // 2 Sprites
8093 { "uf0-006.u4", 0x08000, 0x90c9dae6, 0x03 | BRF_GRA }, // 3
8094 { "uf0-007.u5", 0x08000, 0xe72c3dba, 0x03 | BRF_GRA }, // 4
8095 { "uf0-008.u6", 0x08000, 0xe198e602, 0x03 | BRF_GRA }, // 5
8096
8097 { "uf0-010.u15", 0x80000, 0x0af13a56, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
8098 { "uf0-009.u13", 0x80000, 0x20f2d7f5, 0x04 | BRF_GRA }, // 7
8099 { "uf0-012.u29", 0x80000, 0xcba2a6b7, 0x04 | BRF_GRA }, // 8
8100 { "uf0-011.u22", 0x80000, 0xaf60adf9, 0x04 | BRF_GRA }, // 9
8101 { "uf0-014.u38", 0x80000, 0xda2bd4e4, 0x04 | BRF_GRA }, // 10
8102 { "uf0-013.u37", 0x80000, 0x645ec3c3, 0x04 | BRF_GRA }, // 11
8103 { "uf0-015.u40", 0x80000, 0x11dc19fa, 0x04 | BRF_GRA }, // 12
8104 { "uf0-016.u48", 0x80000, 0x10f99fa8, 0x04 | BRF_GRA }, // 13
8105
8106 { "uf1-004.u52", 0x20000, 0x6638054d, 0x06 | BRF_SND }, // 14 x1-010 Samples
8107
8108 { "uf0-017.u50", 0x00200, 0xbf50c303, 0x00 | BRF_GRA }, // 15 Color Proms
8109 { "uf0-018.u51", 0x00200, 0x1c584d5f, 0x00 | BRF_GRA }, // 16
8110 };
8111
8112 STD_ROM_PICK(setaroul)
STD_ROM_FN(setaroul)8113 STD_ROM_FN(setaroul)
8114
8115 static INT32 NotWorkingInit()
8116 {
8117 return 1;
8118 }
8119
8120 struct BurnDriverD BurnDrvSetaroul = {
8121 "setaroul", NULL, NULL, NULL, "198?",
8122 "Visco Roulette\0", NULL, "Seta / Visco", "Seta",
8123 NULL, NULL, NULL, NULL,
8124 BDF_GAME_NOT_WORKING | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_CASINO, 0,
8125 NULL, setaroulRomInfo, setaroulRomName, NULL, NULL, NULL, NULL, DrgnunitInputInfo, NULL,
8126 NotWorkingInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0,
8127 240, 384, 3, 4
8128 };
8129
8130
8131 // International Toote (Germany)
8132
8133 static struct BurnRomInfo inttooteRomDesc[] = {
8134 { "p523.v01_horse_prog_2.002", 0x10000, 0x6ce6f1ad, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8135 { "p523.v01_horse_prog_1.003", 0x10000, 0x921fcff5, 0x01 | BRF_PRG | BRF_ESS }, // 1
8136 { "ya_002_001.u18", 0x80000, 0xdd108016, 0x01 | BRF_PRG | BRF_ESS }, // 2
8137
8138 { "ya_011_004.u10", 0x80000, 0xeb74d2e0, 0x03 | BRF_GRA }, // 3 Sprites
8139 { "ya_011_005.u17", 0x80000, 0x4a6c804b, 0x03 | BRF_GRA }, // 4
8140 { "ya_011_006.u22", 0x80000, 0xbfae01a5, 0x03 | BRF_GRA }, // 5
8141 { "ya_011_007.u27", 0x80000, 0x2dc7a294, 0x03 | BRF_GRA }, // 6
8142 { "p523.v01_horse_fore_1.u135", 0x10000, 0x3a75df30, 0x00 | BRF_GRA }, // 7
8143 { "p523.v01_horse_fore_2.u134", 0x10000, 0x26fb0339, 0x00 | BRF_GRA }, // 8
8144 { "p523.v01_horse_fore_3.u133", 0x10000, 0xc38596af, 0x00 | BRF_GRA }, // 9
8145 { "p523.v01_horse_fore_4.u132", 0x10000, 0x64ef345e, 0x00 | BRF_GRA }, // 10
8146
8147 { "ya_011_008.u35", 0x40000, 0x4b890f83, 0x04 | BRF_GRA }, // 11 Layer 1 tiles
8148 { "p523.v01_horse_back_1.u137", 0x20000, 0x39b221ea, 0x04 | BRF_GRA }, // 12
8149 { "ya_011_009.u41", 0x40000, 0xcaa5e3c1, 0x04 | BRF_GRA }, // 13
8150 { "p523.v01_horse_back_2.u136", 0x20000, 0x9c5e32a0, 0x04 | BRF_GRA }, // 14
8151
8152 { "ya_011_013.u71", 0x80000, 0x2bccaf47, 0x06 | BRF_SND }, // 17 x1-010 Samples
8153 { "ya_011_012.u64", 0x80000, 0xa8015ce6, 0x06 | BRF_SND }, // 18
8154
8155 { "ya-010.prom", 0x00200, 0x778094b3, 0x00 | BRF_GRA }, // 15 Color Proms
8156 { "ya-011.prom", 0x00200, 0xbd4fe2f6, 0x00 | BRF_GRA }, // 16
8157 };
8158
8159 STD_ROM_PICK(inttoote)
8160 STD_ROM_FN(inttoote)
8161
8162 #if 0
8163 static void inttoote68kInit()
8164 {
8165 SekInit(0, 0x68000);
8166 SekOpen(0);
8167 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
8168 SekMapMemory(DrvVidRAM0, 0xb00000, 0xb07fff, MAP_RAM);
8169 SekMapMemory(DrvSprRAM0, 0xd00000, 0xd00607 | 0x7ff, MAP_RAM);
8170 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe03fff, MAP_RAM);
8171 SekMapMemory(Drv68KRAM, 0xffc000, 0xffffff, MAP_RAM);
8172
8173
8174 SekMapHandler(1, 0x900000, 0x903fff, MAP_READ | MAP_WRITE);
8175 SekSetReadWordHandler (1, setaSoundRegReadWord);
8176 SekSetReadByteHandler (1, setaSoundRegReadByte);
8177 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
8178 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
8179 SekClose();
8180
8181
8182 BurnLoadRom(DrvGfxROM0 + 0x070000, 7, 1);
8183 BurnLoadRom(DrvGfxROM0 + 0x0f0000, 8, 1);
8184 BurnLoadRom(DrvGfxROM0 + 0x170000, 9, 1);
8185 BurnLoadRom(DrvGfxROM0 + 0x1f0000, 10, 1);
8186 }
8187
8188 static INT32 inttooteInit()
8189 {
8190 DrvSetColorOffsets(0, 0, 0);
8191 DrvSetVideoOffsets(1, 1, -1, -1);
8192
8193 return DrvInit(inttoote68kInit, 16000000, SET_IRQLINES(0x80, 0x80) /* Custom */, NO_SPRITE_BUFFER, SET_GFX_DECODE(5, 1, -1));
8194 }
8195 #endif
8196
8197 struct BurnDriverD BurnDrvInttoote = {
8198 "inttoote", "jockeyc", NULL, NULL, "1998",
8199 "International Toote (Germany)\0", NULL, "Coinmaster", "Seta",
8200 NULL, NULL, NULL, NULL,
8201 BDF_GAME_NOT_WORKING | BDF_CLONE, 2, HARDWARE_SETA1, GBF_CASINO, 0,
8202 NULL, inttooteRomInfo, inttooteRomName, NULL, NULL, NULL, NULL, DrgnunitInputInfo, NULL,
8203 NotWorkingInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0,
8204 384, 240, 4, 3
8205 };
8206
8207
8208 // International Toote II (World?)
8209
8210 static struct BurnRomInfo inttooteaRomDesc[] = {
8211 { "p387.v01_horse_prog_2.002", 0x10000, 0x1ced885e, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8212 { "p387.v01_horse_prog_1.003", 0x10000, 0xe24592af, 0x01 | BRF_PRG | BRF_ESS }, // 1
8213 { "ya_002_001.u18", 0x80000, 0xdd108016, 0x01 | BRF_PRG | BRF_ESS }, // 2
8214
8215 { "ya_011_004.u10", 0x80000, 0xeb74d2e0, 0x03 | BRF_GRA }, // 3 Sprites
8216 { "ya_011_005.u17", 0x80000, 0x4a6c804b, 0x03 | BRF_GRA }, // 4
8217 { "ya_011_006.u22", 0x80000, 0xbfae01a5, 0x03 | BRF_GRA }, // 5
8218 { "ya_011_007.u27", 0x80000, 0x2dc7a294, 0x03 | BRF_GRA }, // 6
8219 { "p523.v01_horse_fore_1.u135", 0x10000, 0x3a75df30, 0x00 | BRF_GRA }, // 7
8220 { "p523.v01_horse_fore_2.u134", 0x10000, 0x26fb0339, 0x00 | BRF_GRA }, // 8
8221 { "p523.v01_horse_fore_3.u133", 0x10000, 0xc38596af, 0x00 | BRF_GRA }, // 9
8222 { "p523.v01_horse_fore_4.u132", 0x10000, 0x64ef345e, 0x00 | BRF_GRA }, // 10
8223
8224 { "ya_011_008.u35", 0x40000, 0x4b890f83, 0x04 | BRF_GRA }, // 11 Layer 1 tiles
8225 { "p523.v01_horse_back_1.u137", 0x20000, 0x39b221ea, 0x04 | BRF_GRA }, // 12
8226 { "ya_011_009.u41", 0x40000, 0xcaa5e3c1, 0x04 | BRF_GRA }, // 13
8227 { "p523.v01_horse_back_2.u136", 0x20000, 0x9c5e32a0, 0x04 | BRF_GRA }, // 14
8228
8229 { "ya_011_013.u71", 0x80000, 0x2bccaf47, 0x06 | BRF_SND }, // 17 x1-010 Samples
8230 { "ya_011_012.u64", 0x80000, 0xa8015ce6, 0x06 | BRF_SND }, // 18
8231
8232 { "ya-010.prom", 0x00200, 0x778094b3, 0x00 | BRF_GRA }, // 15 Color Proms
8233 { "ya-011.prom", 0x00200, 0xbd4fe2f6, 0x00 | BRF_GRA }, // 16
8234 };
8235
8236 STD_ROM_PICK(inttootea)
8237 STD_ROM_FN(inttootea)
8238
8239 struct BurnDriverD BurnDrvInttootea = {
8240 "inttootea", "jockeyc", NULL, NULL, "1993",
8241 "International Toote II (World?)\0", NULL, "Coinmaster", "Seta",
8242 NULL, NULL, NULL, NULL,
8243 BDF_GAME_NOT_WORKING | BDF_CLONE, 2, HARDWARE_SETA1, GBF_CASINO, 0,
8244 NULL, inttooteaRomInfo, inttooteaRomName, NULL, NULL, NULL, NULL, DrgnunitInputInfo, NULL,
8245 NotWorkingInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0,
8246 384, 240, 4, 3
8247 };
8248
8249
8250 //-----------------------------------------------------------------------------------------------------------------
8251 // Working games
8252
8253
8254 // Dragon Unit / Castle of Dragon
8255
8256 static struct BurnRomInfo drgnunitRomDesc[] = {
8257 { "prg-e.bin", 0x20000, 0x728447df, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8258 { "prg-o.bin", 0x20000, 0xb2f58ecf, 0x01 | BRF_PRG | BRF_ESS }, // 1
8259
8260 { "obj-2.bin", 0x20000, 0xd7f6ab5a, 0x0b | BRF_GRA }, // 2 Sprites
8261 { "obj-1.bin", 0x20000, 0x53a95b13, 0x0b | BRF_GRA }, // 3
8262 { "obj-6.bin", 0x20000, 0x80b801f7, 0x0b | BRF_GRA }, // 4
8263 { "obj-5.bin", 0x20000, 0x6b87bc20, 0x0b | BRF_GRA }, // 5
8264 { "obj-4.bin", 0x20000, 0x60d17771, 0x0b | BRF_GRA }, // 6
8265 { "obj-3.bin", 0x20000, 0x0bccd4d5, 0x0b | BRF_GRA }, // 7
8266 { "obj-8.bin", 0x20000, 0x826c1543, 0x0b | BRF_GRA }, // 8
8267 { "obj-7.bin", 0x20000, 0xcbaa7f6a, 0x0b | BRF_GRA }, // 9
8268
8269 { "scr-1o.bin", 0x20000, 0x671525db, 0x04 | BRF_GRA }, // 10 Layer 1 tiles
8270 { "scr-2o.bin", 0x20000, 0x2a3f2ed8, 0x04 | BRF_GRA }, // 11
8271 { "scr-3o.bin", 0x20000, 0x4d33a92d, 0x04 | BRF_GRA }, // 12
8272 { "scr-4o.bin", 0x20000, 0x79a0aa61, 0x04 | BRF_GRA }, // 13
8273 { "scr-1e.bin", 0x20000, 0xdc9cd8c9, 0x04 | BRF_GRA }, // 14
8274 { "scr-2e.bin", 0x20000, 0xb6126b41, 0x04 | BRF_GRA }, // 15
8275 { "scr-3e.bin", 0x20000, 0x1592b8c2, 0x04 | BRF_GRA }, // 16
8276 { "scr-4e.bin", 0x20000, 0x8201681c, 0x04 | BRF_GRA }, // 17
8277
8278 { "snd-1.bin", 0x20000, 0x8f47bd0d, 0x06 | BRF_SND }, // 18 x1-010 Samples
8279 { "snd-2.bin", 0x20000, 0x65c40ef5, 0x06 | BRF_SND }, // 19
8280 { "snd-3.bin", 0x20000, 0x71fbd54e, 0x06 | BRF_SND }, // 20
8281 { "snd-4.bin", 0x20000, 0xac50133f, 0x06 | BRF_SND }, // 21
8282 { "snd-5.bin", 0x20000, 0x70652f2c, 0x06 | BRF_SND }, // 22
8283 { "snd-6.bin", 0x20000, 0x10a1039d, 0x06 | BRF_SND }, // 23
8284 { "snd-7.bin", 0x20000, 0xdecbc8b0, 0x06 | BRF_SND }, // 24
8285 { "snd-8.bin", 0x20000, 0x3ac51bee, 0x06 | BRF_SND }, // 25
8286 };
8287
8288 STD_ROM_PICK(drgnunit)
STD_ROM_FN(drgnunit)8289 STD_ROM_FN(drgnunit)
8290
8291 static INT32 drgnunitInit()
8292 {
8293 DrvSetColorOffsets(0, 0, 0);
8294 DrvSetVideoOffsets(2, 2, -2, -2);
8295
8296 return DrvInit(drgnunit68kInit, 8000000, SET_IRQLINES(1, 2), SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
8297 }
8298
8299 struct BurnDriver BurnDrvDrgnunit = {
8300 "drgnunit", NULL, NULL, NULL, "1989",
8301 "Dragon Unit / Castle of Dragon\0", NULL, "Seta", "Seta",
8302 NULL, NULL, NULL, NULL,
8303 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_SCRFIGHT, 0,
8304 NULL, drgnunitRomInfo, drgnunitRomName, NULL, NULL, NULL, NULL, DrgnunitInputInfo, DrgnunitDIPInfo,
8305 drgnunitInit, DrvExit, DrvFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
8306 384, 240, 4, 3
8307 };
8308
8309
8310 // Quiz Kokology
8311
8312 static struct BurnRomInfo qzkklogyRomDesc[] = {
8313 { "3.u27", 0x20000, 0xb8c27cde, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8314 { "1.u9", 0x20000, 0xce01cd54, 0x01 | BRF_PRG | BRF_ESS }, // 1
8315 { "4.u33", 0x20000, 0x4f5c554c, 0x01 | BRF_PRG | BRF_ESS }, // 2
8316 { "2.u17", 0x20000, 0x65fa1b8d, 0x01 | BRF_PRG | BRF_ESS }, // 3
8317
8318 { "t2709u32.u32", 0x80000, 0x900f196c, 0x03 | BRF_GRA }, // 4 Sprites
8319 { "t2709u26.u26", 0x80000, 0x416ac849, 0x03 | BRF_GRA }, // 5
8320
8321 { "t2709u42.u39", 0x80000, 0x194d5704, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
8322 { "t2709u39.u42", 0x80000, 0x6f95a76d, 0x04 | BRF_GRA }, // 7
8323
8324 { "t2709u47.u47", 0x80000, 0x0ebdad40, 0x06 | BRF_SND }, // 8 x1-010 Samples
8325 { "t2709u55.u55", 0x80000, 0x43960c68, 0x06 | BRF_SND }, // 9
8326 };
8327
8328 STD_ROM_PICK(qzkklogy)
STD_ROM_FN(qzkklogy)8329 STD_ROM_FN(qzkklogy)
8330
8331 static INT32 qzkklogyInit()
8332 {
8333 DrvSetColorOffsets(0, 0, 0);
8334 DrvSetVideoOffsets(1, 1, -1, -1);
8335
8336 return DrvInit(drgnunit68kInit, 8000000, SET_IRQLINES(1, 2), SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
8337 }
8338
8339 struct BurnDriver BurnDrvQzkklogy = {
8340 "qzkklogy", NULL, NULL, NULL, "1992",
8341 "Quiz Kokology\0", NULL, "Tecmo", "Seta",
8342 NULL, NULL, NULL, NULL,
8343 BDF_GAME_WORKING, 2, HARDWARE_SETA1, GBF_QUIZ, 0,
8344 NULL, qzkklogyRomInfo, qzkklogyRomName, NULL, NULL, NULL, NULL, QzkklogyInputInfo, QzkklogyDIPInfo,
8345 qzkklogyInit, DrvExit, DrvFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
8346 384, 240, 4, 3
8347 };
8348
8349
8350 // Strike Gunner S.T.G
8351
8352 static struct BurnRomInfo stgRomDesc[] = {
8353 { "att01003.u27", 0x20000, 0x7a640a93, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8354 { "att01001.u9", 0x20000, 0x4fa88ad3, 0x01 | BRF_PRG | BRF_ESS }, // 1
8355 { "att01004.u33", 0x20000, 0xbbd45ca1, 0x01 | BRF_PRG | BRF_ESS }, // 2
8356 { "att01002.u17", 0x20000, 0x2f8fd80c, 0x01 | BRF_PRG | BRF_ESS }, // 3
8357
8358 { "att01006.u32", 0x80000, 0x6ad78ea2, 0x03 | BRF_GRA }, // 4 Sprites
8359 { "att01005.u26", 0x80000, 0xa347ff00, 0x03 | BRF_GRA }, // 5
8360
8361 { "att01008.u39", 0x80000, 0x20c47457, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
8362 { "att01007.u42", 0x80000, 0xac975544, 0x04 | BRF_GRA }, // 7
8363
8364 { "att01009.u47", 0x80000, 0x4276b58d, 0x06 | BRF_SND }, // 8 x1-010 Samples
8365 { "att01010.u55", 0x80000, 0xfffb2f53, 0x06 | BRF_SND }, // 9
8366 };
8367
8368 STD_ROM_PICK(stg)
STD_ROM_FN(stg)8369 STD_ROM_FN(stg)
8370
8371 static INT32 stgInit()
8372 {
8373 DrvSetColorOffsets(0, 0, 0);
8374 DrvSetVideoOffsets(0, 0, -2, -2);
8375
8376 return DrvInit(drgnunit68kInit, 8000000, SET_IRQLINES(2, 1), SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
8377 }
8378
8379 struct BurnDriver BurnDrvStg = {
8380 "stg", NULL, NULL, NULL, "1991",
8381 "Strike Gunner S.T.G\0", NULL, "Athena / Tecmo", "Seta",
8382 NULL, NULL, NULL, NULL,
8383 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8384 NULL, stgRomInfo, stgRomName, NULL, NULL, NULL, NULL, StgInputInfo, StgDIPInfo,
8385 stgInit, DrvExit, DrvFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
8386 240, 384, 3, 4
8387 };
8388
8389
8390 // Quiz Kokology 2
8391
8392 static struct BurnRomInfo qzkklgy2RomDesc[] = {
8393 { "fn001001.106", 0x080000, 0x7bf8eb17, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8394 { "fn001003.107", 0x040000, 0xee6ef111, 0x01 | BRF_PRG | BRF_ESS }, // 1
8395
8396 { "fn001004.100", 0x100000, 0x5ba139a2, 0x03 | BRF_GRA }, // 2 Sprites
8397
8398 { "fn001005.104", 0x200000, 0x95726a63, 0x04 | BRF_GRA }, // 3 Layer 1 tiles
8399
8400 { "fn001006.105", 0x100000, 0x83f201e6, 0x06 | BRF_SND }, // 4 x1-010 Samples
8401 };
8402
8403 STD_ROM_PICK(qzkklgy2)
STD_ROM_FN(qzkklgy2)8404 STD_ROM_FN(qzkklgy2)
8405
8406 static INT32 qzkklgy2Init()
8407 {
8408 DrvSetColorOffsets(0, 0, 0);
8409 DrvSetVideoOffsets(0, 0, -1, -3);
8410
8411 return DrvInit(drgnunit68kInit, 16000000, SET_IRQLINES(1, 2), SPRITE_BUFFER, SET_GFX_DECODE(0, 2, -1));
8412 }
8413
8414 struct BurnDriver BurnDrvQzkklgy2 = {
8415 "qzkklgy2", NULL, NULL, NULL, "1993",
8416 "Quiz Kokology 2\0", NULL, "Tecmo", "Seta",
8417 NULL, NULL, NULL, NULL,
8418 BDF_GAME_WORKING, 2, HARDWARE_SETA1, GBF_QUIZ, 0,
8419 NULL, qzkklgy2RomInfo, qzkklgy2RomName, NULL, NULL, NULL, NULL, Qzkklgy2InputInfo, Qzkklgy2DIPInfo,
8420 qzkklgy2Init, DrvExit, DrvFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
8421 384, 240, 4, 3
8422 };
8423
8424
8425 /*
8426 The changes between the set daioh and daioha are very minimal, the main game effects are:
8427
8428 - Fixes the crashing bug in the US version caused by pressing Shot1 and Shot2 in weird orders and timings.
8429 - 1UP, and 2UPs no longer spawn "randomly". (Only the fixed extend items exist, and the 1UPs from score)
8430 - After picking up a max powerup, a 1UP or a 2UP, daoiha sets the "item timer" to a random value.
8431 daioh always sets it to 0x7F.
8432 - The powerups spawned from picking up an additional max powerup are no longer random, but feeds from the
8433 original "spawn item" function (thus, it advances the "item timer")
8434
8435 So it's a bug fix version which also makes the game a little harder by limiting the spawning of 1ups
8436 */
8437
8438 // Daioh
8439
8440 static struct BurnRomInfo daiohRomDesc[] = {
8441 { "fg001001.u3", 0x080000, 0xe1ef3007, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8442 { "fg001002.u4", 0x080000, 0x5e3481f9, 0x01 | BRF_PRG | BRF_ESS }, // 1
8443
8444 { "fg-001-004", 0x100000, 0x9ab0533e, 0x03 | BRF_GRA }, // 2 Sprites
8445 { "fg-001-003", 0x100000, 0x1c9d51e2, 0x03 | BRF_GRA }, // 3
8446
8447 { "fg-001-005", 0x200000, 0xc25159b9, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8448
8449 { "fg-001-006", 0x200000, 0x2052c39a, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
8450
8451 { "fg-001-007", 0x100000, 0x4a2fe9e0, 0x06 | BRF_SND }, // 6 x1-010 Samples
8452
8453 { "fg-008.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7 plds
8454 { "fg-009.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8
8455 { "fg-010.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
8456 { "fg-011.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8457 { "fg-012.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8458 };
8459
8460 STD_ROM_PICK(daioh)
STD_ROM_FN(daioh)8461 STD_ROM_FN(daioh)
8462
8463 static INT32 daiohInit()
8464 {
8465 DrvSetVideoOffsets(0, 0, -1, -1);
8466 DrvSetColorOffsets(0, 0x400, 0x200);
8467
8468 return DrvInit(daioh68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
8469 }
8470
8471 struct BurnDriver BurnDrvDaioh = {
8472 "daioh", NULL, NULL, NULL, "1993",
8473 "Daioh\0", NULL, "Athena", "Seta",
8474 NULL, NULL, NULL, NULL,
8475 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8476 NULL, daiohRomInfo, daiohRomName, NULL, NULL, NULL, NULL, DaiohInputInfo, DaiohDIPInfo,
8477 daiohInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8478 240, 384, 3, 4
8479 };
8480
8481
8482 // Daioh (earlier)
8483
8484 static struct BurnRomInfo daiohaRomDesc[] = {
8485 { "fg-001-001.u3", 0x080000, 0x104ae74a, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8486 { "fg-001-002.u4", 0x080000, 0xe39a4e67, 0x01 | BRF_PRG | BRF_ESS }, // 1
8487
8488 { "fg-001-004", 0x100000, 0x9ab0533e, 0x03 | BRF_GRA }, // 2 Sprites
8489 { "fg-001-003", 0x100000, 0x1c9d51e2, 0x03 | BRF_GRA }, // 3
8490
8491 { "fg-001-005", 0x200000, 0xc25159b9, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8492
8493 { "fg-001-006", 0x200000, 0x2052c39a, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
8494
8495 { "fg-001-007", 0x100000, 0x4a2fe9e0, 0x06 | BRF_SND }, // 6 x1-010 Samples
8496
8497 { "fg-008.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7 plds
8498 { "fg-009.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8
8499 { "fg-010.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
8500 { "fg-011.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8501 { "fg-012.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8502 };
8503
8504 STD_ROM_PICK(daioha)
8505 STD_ROM_FN(daioha)
8506
8507 struct BurnDriver BurnDrvDaioha = {
8508 "daioha", "daioh", NULL, NULL, "1993",
8509 "Daioh (earlier)\0", NULL, "Athena", "Seta",
8510 NULL, NULL, NULL, NULL,
8511 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8512 NULL, daiohaRomInfo, daiohaRomName, NULL, NULL, NULL, NULL, DaiohInputInfo, DaiohDIPInfo,
8513 daiohInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8514 240, 384, 3, 4
8515 };
8516
8517
8518 // Daioh (prototype)
8519
8520 static struct BurnRomInfo daiohpRomDesc[] = {
8521 { "prg_even.u3", 0x040000, 0x3c97b976, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8522 { "prg_odd.u4", 0x040000, 0xaed2b87e, 0x01 | BRF_PRG | BRF_ESS }, // 1
8523 { "data_even.u103", 0x040000, 0xe07776ef, 0x01 | BRF_PRG | BRF_ESS }, // 2
8524 { "data_odd.u102", 0x040000, 0xb75b9a5c, 0x01 | BRF_PRG | BRF_ESS }, // 3
8525
8526 { "obj_2.u146", 0x040000, 0x77560a03, 0x03 | BRF_GRA }, // 4 Sprites
8527 { "obj_6.u147", 0x040000, 0x081f5fb1, 0x03 | BRF_GRA }, // 5
8528 { "obj_3.u144", 0x040000, 0xd33ca640, 0x03 | BRF_GRA }, // 6
8529 { "obj_7.u145", 0x040000, 0xe878ac92, 0x03 | BRF_GRA }, // 7
8530 { "obj_0.u142", 0x040000, 0x78f45582, 0x03 | BRF_GRA }, // 8
8531 { "obj_4.u143", 0x040000, 0xd387de72, 0x03 | BRF_GRA }, // 9
8532 { "obj_1.u140", 0x040000, 0x8ff6c5a9, 0x03 | BRF_GRA }, // 10
8533 { "obj_5.u141", 0x040000, 0x6a671757, 0x03 | BRF_GRA }, // 11
8534
8535 { "bg1_1.u150", 0x080000, 0xd5793a2f, 0x04 | BRF_GRA }, // 12 Layer 1 tiles
8536 { "bg1_3.u151", 0x080000, 0x6456fae1, 0x04 | BRF_GRA }, // 13
8537 { "bg1_0.u148", 0x080000, 0xbec48d7a, 0x04 | BRF_GRA }, // 14
8538 { "bg1_2.u149", 0x080000, 0x5e674c30, 0x04 | BRF_GRA }, // 15
8539
8540 { "bg2_1.u166", 0x080000, 0x9274123b, 0x05 | BRF_GRA }, // 16 Layer 2 tiles
8541 { "bg2_3.u167", 0x080000, 0xd3d68aa1, 0x05 | BRF_GRA }, // 17
8542 { "bg2_0.u164", 0x080000, 0x7e46a10e, 0x05 | BRF_GRA }, // 18
8543 { "bg2_2.u165", 0x080000, 0x3119189b, 0x05 | BRF_GRA }, // 19
8544
8545 { "snd0.u156", 0x020000, 0x4d253547, 0x06 | BRF_SND }, // 20 x1-010 Samples
8546 { "snd1.u157", 0x020000, 0x79b56e22, 0x06 | BRF_SND }, // 21
8547 { "snd2.u158", 0x020000, 0xbc8de02a, 0x06 | BRF_SND }, // 22
8548 { "snd3.u159", 0x020000, 0x939777fd, 0x06 | BRF_SND }, // 23
8549 { "snd4.u160", 0x020000, 0x7b97716d, 0x06 | BRF_SND }, // 24
8550 { "snd5.u161", 0x020000, 0x294e1cc9, 0x06 | BRF_SND }, // 25
8551 { "snd6.u162", 0x020000, 0xecab073b, 0x06 | BRF_SND }, // 26
8552 { "snd7.u163", 0x020000, 0x1b7ea768, 0x06 | BRF_SND }, // 27
8553
8554 { "con1x.u35", 0x000104, 0xce8b57d9, 0x00 | BRF_OPT }, // 28 Pals
8555 { "con2x.u36", 0x000104, 0x0b18db9e, 0x00 | BRF_OPT }, // 29
8556 { "dec1x.u14", 0x000104, 0xd197abfe, 0x00 | BRF_OPT }, // 30
8557 { "dec2x.u206", 0x000104, 0x35afbba8, 0x00 | BRF_OPT }, // 31
8558 { "pcon2.u110", 0x000104, 0x082882c2, 0x00 | BRF_OPT }, // 32
8559 { "sc.u116", 0x000104, 0xe57bfde9, 0x00 | BRF_OPT }, // 33
8560
8561 { "fa-011.u50", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 34 plds
8562 { "fa-012.u51", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 35
8563 { "fa-013.u52", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 36
8564 { "fa-014.u53", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 37
8565 { "fa-015.u54", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 38
8566 };
8567
8568 STD_ROM_PICK(daiohp)
STD_ROM_FN(daiohp)8569 STD_ROM_FN(daiohp)
8570
8571 static INT32 daiohpInit()
8572 {
8573 DrvSetVideoOffsets(1, 1, -1, -1);
8574 DrvSetColorOffsets(0, 0x400, 0x200);
8575
8576 INT32 nRet = DrvInit(daiohp68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(5, 1, 1));
8577
8578 if (nRet == 0) {
8579 memcpy (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x080000);
8580 memcpy (Drv68KROM + 0x180000, Drv68KROM + 0x080000, 0x080000);
8581 memcpy (Drv68KROM + 0x080000, Drv68KROM + 0x000000, 0x080000);
8582 }
8583
8584 return nRet;
8585 }
8586
8587 struct BurnDriver BurnDrvDaiohp = {
8588 "daiohp", "daioh", NULL, NULL, "1993",
8589 "Daioh (prototype)\0", NULL, "Athena", "Seta",
8590 NULL, NULL, NULL, NULL,
8591 BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8592 NULL, daiohpRomInfo, daiohpRomName, NULL, NULL, NULL, NULL, DaiohInputInfo, DaiohDIPInfo,
8593 daiohpInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8594 240, 384, 3, 4
8595 };
8596
8597
8598 // Daioh (93111A PCB conversion)
8599 /* Found on a 93111A PCB - same PCB as War of Areo & J. J. Squawkers */
8600
8601 static struct BurnRomInfo daiohcRomDesc[] = {
8602 { "15.u3", 0x080000, 0x14616abb, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8603 { "14.u4", 0x080000, 0xa029f991, 0x01 | BRF_PRG | BRF_ESS }, // 1
8604
8605 { "9.u9", 0x080000, 0x4444cbd4, 0x03 | BRF_GRA }, // 2 Sprites
8606 { "10.u10", 0x080000, 0x1d88d20b, 0x03 | BRF_GRA }, // 3
8607 { "11.u11", 0x080000, 0x3e41de61, 0x03 | BRF_GRA }, // 4
8608 { "12.u12", 0x080000, 0xf35e3341, 0x03 | BRF_GRA }, // 5
8609
8610 { "5.u5", 0x080000, 0xaaa5e41e, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
8611 { "6.u6", 0x080000, 0x9ad8b4b4, 0x04 | BRF_GRA }, // 7
8612 { "7.u7", 0x080000, 0xbabf194a, 0x04 | BRF_GRA }, // 8
8613 { "8.u8", 0x080000, 0x2db65290, 0x04 | BRF_GRA }, // 9
8614
8615 { "1.u1", 0x080000, 0x30f81f99, 0x05 | BRF_GRA }, // 10 Layer 2 tiles
8616 { "2.u2", 0x080000, 0x3b3e0f4e, 0x05 | BRF_GRA }, // 11
8617 { "3.u3", 0x080000, 0xc5eef1c1, 0x05 | BRF_GRA }, // 12
8618 { "4.u4", 0x080000, 0x851115b6, 0x05 | BRF_GRA }, // 13
8619
8620 { "data.u69", 0x080000, 0x21e4f093, 0x06 | BRF_SND }, // 14 x1-010 Samples
8621 { "data.u70", 0x080000, 0x593c3c58, 0x06 | BRF_SND }, // 15
8622
8623 { "gal.u14", 0x000117, 0xb972b479, 0x00 | BRF_OPT }, // 16 Gals
8624 };
8625
8626 STD_ROM_PICK(daiohc)
STD_ROM_FN(daiohc)8627 STD_ROM_FN(daiohc)
8628
8629 static INT32 daiohcInit()
8630 {
8631 daiohc = 1;
8632 DrvSetVideoOffsets(0, 0, 0, 0);
8633 DrvSetColorOffsets(0, 0x400, 0x200);
8634
8635 INT32 nRet = DrvInit(wrofaero68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
8636
8637 if (nRet == 0) {
8638 memcpy (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x080000);
8639 memset (Drv68KROM + 0x080000, 0, 0x080000);
8640 }
8641
8642 return nRet;
8643 }
8644
8645 struct BurnDriver BurnDrvDaiohc = {
8646 "daiohc", "daioh", NULL, NULL, "1993",
8647 "Daioh (93111A PCB conversion)\0", NULL, "Athena", "Seta",
8648 NULL, NULL, NULL, NULL,
8649 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8650 NULL, daiohcRomInfo, daiohcRomName, NULL, NULL, NULL, NULL, DaiohInputInfo, DaiohDIPInfo,
8651 daiohcInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8652 240, 384, 3, 4
8653 };
8654
8655
8656 // Rezon
8657
8658 static struct BurnRomInfo rezonRomDesc[] = {
8659 { "us001001.u3", 0x020000, 0xab923052, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8660 { "us001002.u4", 0x020000, 0x3dafa0d5, 0x01 | BRF_PRG | BRF_ESS }, // 1
8661 { "us001004.103", 0x020000, 0x54871c7c, 0x01 | BRF_PRG | BRF_ESS }, // 2
8662 { "us001003.102", 0x020000, 0x1ac3d272, 0x01 | BRF_PRG | BRF_ESS }, // 3
8663
8664 { "us001006.u64", 0x080000, 0xa4916e96, 0x03 | BRF_GRA }, // 4 Sprites
8665 { "us001005.u63", 0x080000, 0xe6251ebc, 0x03 | BRF_GRA }, // 5
8666
8667 { "us001007.u66", 0x080000, 0x3760b935, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
8668
8669 { "us001008.u68", 0x080000, 0x0ab73910, 0x05 | BRF_GRA }, // 7 Layer 2 tiles
8670
8671 { "us001009.u70", 0x100000, 0x0d7d2e2b, 0x06 | BRF_SND }, // 8 x1-010 Samples
8672
8673 { "us-010.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9 plds
8674 { "us-011.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8675 { "us-012.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8676 { "us-013.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 12
8677 };
8678
8679 STD_ROM_PICK(rezon)
STD_ROM_FN(rezon)8680 STD_ROM_FN(rezon)
8681
8682 static INT32 rezonInit()
8683 {
8684 DrvSetVideoOffsets(0, 0, -2, -2);
8685 DrvSetColorOffsets(0, 0x400, 0x200);
8686
8687 INT32 nRet = DrvInit(wrofaero68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
8688
8689 if (nRet == 0) {
8690 memcpy (Drv68KROM + 0x100000, Drv68KROM + 0x040000, 0x040000);
8691 memset (Drv68KROM + 0x040000, 0, 0x40000);
8692 BurnByteswap(DrvSndROM, 0x100000);
8693 }
8694
8695 return nRet;
8696 }
8697
8698 struct BurnDriver BurnDrvRezon = {
8699 "rezon", NULL, NULL, NULL, "1991",
8700 "Rezon\0", NULL, "Allumer", "Seta",
8701 NULL, NULL, NULL, NULL,
8702 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_HORSHOOT, 0,
8703 NULL, rezonRomInfo, rezonRomName, NULL, NULL, NULL, NULL, RezonInputInfo, RezonDIPInfo,
8704 rezonInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8705 384, 240, 4, 3
8706 };
8707
8708 /* note the ONLY byte that changes is the year, 1992 instead of 1991. The actual license is controlled by a jumper but
8709 since Taito released the game in 1992 this is the Taito version and we hardcode the jumper in the input ports */
8710
8711 // Rezon (Taito)
8712
8713 static struct BurnRomInfo rezontRomDesc[] = {
8714 { "us001001.u3", 0x020000, 0xab923052, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8715 { "rezon_1_p.u4", 0x020000, 0x9ed32f8c, 0x01 | BRF_PRG | BRF_ESS }, // 1
8716 { "us001004.103", 0x020000, 0x54871c7c, 0x01 | BRF_PRG | BRF_ESS }, // 2
8717 { "us001003.102", 0x020000, 0x1ac3d272, 0x01 | BRF_PRG | BRF_ESS }, // 3
8718
8719 { "us001006.u64", 0x080000, 0xa4916e96, 0x03 | BRF_GRA }, // 4 Sprites
8720 { "us001005.u63", 0x080000, 0xe6251ebc, 0x03 | BRF_GRA }, // 5
8721
8722 { "us001007.u66", 0x080000, 0x3760b935, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
8723
8724 { "us001008.u68", 0x080000, 0x0ab73910, 0x05 | BRF_GRA }, // 7 Layer 2 tiles
8725
8726 { "us001009.u70", 0x100000, 0x0d7d2e2b, 0x06 | BRF_SND }, // 8 x1-010 Samples
8727
8728 { "us-010.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9 plds
8729 { "us-011.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8730 { "us-012.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8731 { "us-013.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 12
8732 };
8733
8734 STD_ROM_PICK(rezont)
8735 STD_ROM_FN(rezont)
8736
8737 struct BurnDriver BurnDrvRezont = {
8738 "rezont", "rezon", NULL, NULL, "1992",
8739 "Rezon (Taito)\0", NULL, "Allumer (Taito license)", "Seta",
8740 NULL, NULL, NULL, NULL,
8741 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_HORSHOOT, 0,
8742 NULL, rezontRomInfo, rezontRomName, NULL, NULL, NULL, NULL, RezonInputInfo, RezonDIPInfo,
8743 rezonInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8744 384, 240, 4, 3
8745 };
8746
8747
8748 // Eight Forces
8749
8750 static struct BurnRomInfo eightfrcRomDesc[] = {
8751 { "uy2-u4.u3", 0x040000, 0xf1f249c5, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8752 { "uy2-u3.u4", 0x040000, 0x6f2d8618, 0x01 | BRF_PRG | BRF_ESS }, // 1
8753
8754 { "u64.bin", 0x080000, 0xf561ff2e, 0x03 | BRF_GRA }, // 2 Sprites
8755 { "u63.bin", 0x080000, 0x4c3f8366, 0x03 | BRF_GRA }, // 3
8756
8757 { "u66.bin", 0x100000, 0x6fad2b7f, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8758
8759 { "u68.bin", 0x100000, 0xc17aad22, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
8760
8761 { "u70.bin", 0x100000, 0xdfdb67a3, 0x06 | BRF_SND }, // 6 x1-010 Samples
8762 { "u69.bin", 0x100000, 0x82ec08f1, 0x06 | BRF_SND }, // 7
8763
8764 { "uy-012.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8 plds
8765 { "uy-013.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
8766 { "uy-014.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8767 { "uy-015.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8768 { "uy-016.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 12
8769 { "uy-017.u116", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 13
8770 };
8771
8772 STD_ROM_PICK(eightfrc)
STD_ROM_FN(eightfrc)8773 STD_ROM_FN(eightfrc)
8774
8775 static INT32 eightfrcInit()
8776 {
8777 DrvSetVideoOffsets(3, 4, 0, 0);
8778 DrvSetColorOffsets(0, 0x400, 0x200);
8779
8780 INT32 nRet = DrvInit(wrofaero68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
8781
8782 if (nRet == 0) {
8783 // Update sample length to include the banked section that was skipped (0xc0000 - 0xfffff)
8784 DrvROMLen[3] = 0x240000;
8785 memmove(DrvSndROM + 0x100000, DrvSndROM + 0x0c0000, 0x140000); // sound banks (memcpy fails because of overlap!)
8786 x1010_set_route(BURN_SND_X1010_ROUTE_2, 2.00, BURN_SND_ROUTE_RIGHT);
8787 x1010_set_route(BURN_SND_X1010_ROUTE_1, 2.00, BURN_SND_ROUTE_LEFT);
8788 }
8789
8790 return nRet;
8791 }
8792
8793 struct BurnDriver BurnDrvEightfrc = {
8794 "eightfrc", NULL, NULL, NULL, "1994",
8795 "Eight Forces\0", NULL, "Tecmo", "Seta",
8796 NULL, NULL, NULL, NULL,
8797 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8798 NULL, eightfrcRomInfo, eightfrcRomName, NULL, NULL, NULL, NULL, EightfrcInputInfo, EightfrcDIPInfo,
8799 eightfrcInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8800 224, 384, 3, 4
8801 };
8802
8803
8804 // War of Aero - Project MEIOU
8805
8806 static struct BurnRomInfo wrofaeroRomDesc[] = {
8807 { "u3.bin", 0x40000, 0x9b896a97, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8808 { "u4.bin", 0x40000, 0xdda84846, 0x01 | BRF_PRG | BRF_ESS }, // 1
8809
8810 { "u64.bin", 0x80000, 0xf06ccd78, 0x03 | BRF_GRA }, // 2 Sprites
8811 { "u63.bin", 0x80000, 0x2a602a1b, 0x03 | BRF_GRA }, // 3
8812
8813 { "u66.bin", 0x80000, 0xc9fc6a0c, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8814
8815 { "u68.bin", 0x80000, 0x25c0c483, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
8816
8817 { "u69.bin", 0x80000, 0x957ecd41, 0x06 | BRF_SND }, // 6 x1-010 Samples
8818 { "u70.bin", 0x80000, 0x8d756fdf, 0x06 | BRF_SND }, // 7
8819 };
8820
8821 STD_ROM_PICK(wrofaero)
STD_ROM_FN(wrofaero)8822 STD_ROM_FN(wrofaero)
8823
8824 static INT32 wrofaeroInit()
8825 {
8826 DrvSetVideoOffsets(0, 0, 0, 0);
8827 DrvSetColorOffsets(0, 0x400, 0x200);
8828
8829 return DrvInit(wrofaero68kInit, 16000000, SET_IRQLINES(2, 4), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
8830 }
8831
8832 struct BurnDriver BurnDrvWrofaero = {
8833 "wrofaero", NULL, NULL, NULL, "1993",
8834 "War of Aero - Project MEIOU\0", NULL, "Yang Cheng", "Seta",
8835 NULL, NULL, NULL, NULL,
8836 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8837 NULL, wrofaeroRomInfo, wrofaeroRomName, NULL, NULL, NULL, NULL, WrofaeroInputInfo, WrofaeroDIPInfo,
8838 wrofaeroInit, DrvExit, DrvKMFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8839 240, 384, 3, 4
8840 };
8841
8842
8843 // Zing Zing Zip
8844
8845 static struct BurnRomInfo zingzipRomDesc[] = {
8846 { "uy001001.3", 0x040000, 0x1a1687ec, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8847 { "uy001002.4", 0x040000, 0x62e3b0c4, 0x01 | BRF_PRG | BRF_ESS }, // 1
8848
8849 { "uy001006.64", 0x080000, 0x46e4a7d8, 0x03 | BRF_GRA }, // 2 Sprites
8850 { "uy001005.63", 0x080000, 0x4aac128e, 0x03 | BRF_GRA }, // 3
8851
8852 { "uy001008.66", 0x100000, 0x1dff7c4b, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8853 { "uy001007.65", 0x080000, 0xec5b3ab9, 0x1c | BRF_GRA }, // 5
8854
8855 { "uy001010.68", 0x100000, 0xbdbcdf03, 0x05 | BRF_GRA }, // 6 Layer 2 tiles
8856
8857 { "uy001011.70", 0x100000, 0xbd845f55, 0x06 | BRF_SND }, // 7 x1-010 Samples
8858
8859 { "uy-012.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8 plds
8860 { "uy-013.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
8861 { "uy-014.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8862 { "uy-015.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8863 { "uy-016.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 12
8864 };
8865
8866 STD_ROM_PICK(zingzip)
STD_ROM_FN(zingzip)8867 STD_ROM_FN(zingzip)
8868
8869 static INT32 zingzipInit()
8870 {
8871 DrvSetVideoOffsets(0, 0, -1, -2);
8872 DrvSetColorOffsets(0, 0x400, 0x200);
8873
8874 INT32 nRet = DrvInit(wrofaero68kInit, 16000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 2));
8875
8876 if (nRet == 0) {
8877 zingzapSetColorTable();
8878 }
8879
8880 return nRet;
8881 }
8882
8883 struct BurnDriver BurnDrvZingzip = {
8884 "zingzip", NULL, NULL, NULL, "1992",
8885 "Zing Zing Zip\0", NULL, "Allumer + Tecmo", "Seta",
8886 NULL, NULL, NULL, NULL,
8887 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
8888 NULL, zingzipRomInfo, zingzipRomName, NULL, NULL, NULL, NULL, ZingzipInputInfo, ZingzipDIPInfo,
8889 zingzipInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0xc00,
8890 240, 384, 3, 4
8891 };
8892
8893
8894 // Mobile Suit Gundam
8895
8896 static struct BurnRomInfo msgundamRomDesc[] = {
8897 { "fa003002.u25", 0x080000, 0x1cc72d4c, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8898 { "fa001001.u20", 0x100000, 0xfca139d0, 0x01 | BRF_PRG | BRF_ESS }, // 1
8899
8900 { "fa001008.u21", 0x200000, 0xe7accf48, 0x03 | BRF_GRA }, // 2 Sprites
8901 { "fa001007.u22", 0x200000, 0x793198a6, 0x03 | BRF_GRA }, // 3
8902
8903 { "fa001006.u23", 0x100000, 0x3b60365c, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8904
8905 { "fa001005.u24", 0x080000, 0x8cd7ff86, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
8906
8907 { "fa001004.u26", 0x100000, 0xb965f07c, 0x06 | BRF_SND }, // 6 x1-010 Samples
8908 };
8909
8910 STD_ROM_PICK(msgundam)
STD_ROM_FN(msgundam)8911 STD_ROM_FN(msgundam)
8912
8913 static INT32 msgundamInit()
8914 {
8915 refresh_rate = 5666; // 56.66 hz
8916 DrvSetVideoOffsets(0, 0, -2, -2);
8917 DrvSetColorOffsets(0, 0x400, 0x200);
8918
8919 INT32 nRet = DrvInit(msgundam68kInit, 16000000, SET_IRQLINES(4, 2), SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
8920
8921 if (nRet == 0) {
8922 memmove (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x100000);
8923 memset(Drv68KROM + 0x080000, 0, 0x080000);
8924 }
8925
8926 return nRet;
8927 }
8928
8929 struct BurnDriver BurnDrvMsgundam = {
8930 "msgundam", NULL, NULL, NULL, "1993",
8931 "Mobile Suit Gundam\0", NULL, "Banpresto", "Seta",
8932 NULL, NULL, NULL, NULL,
8933 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VSFIGHT, 0,
8934 NULL, msgundamRomInfo, msgundamRomName, NULL, NULL, NULL, NULL, MsgundamInputInfo, MsgundamDIPInfo,
8935 msgundamInit, DrvExit, DrvFrameMsgundam, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8936 384, 240, 4, 3
8937 };
8938
8939
8940 // Mobile Suit Gundam (Japan)
8941
8942 static struct BurnRomInfo msgundam1RomDesc[] = {
8943 { "fa002002.u25", 0x080000, 0xdee3b083, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8944 { "fa001001.u20", 0x100000, 0xfca139d0, 0x01 | BRF_PRG | BRF_ESS }, // 1
8945
8946 { "fa001008.u21", 0x200000, 0xe7accf48, 0x03 | BRF_GRA }, // 2 Sprites
8947 { "fa001007.u22", 0x200000, 0x793198a6, 0x03 | BRF_GRA }, // 3
8948
8949 { "fa001006.u23", 0x100000, 0x3b60365c, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
8950
8951 { "fa001005.u24", 0x080000, 0x8cd7ff86, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
8952
8953 { "fa001004.u26", 0x100000, 0xb965f07c, 0x06 | BRF_SND }, // 6 x1-010 Samples
8954
8955 { "fa-011.u50", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7 plds
8956 { "fa-012.u51", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8
8957 { "fa-013.u52", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
8958 { "fa-014.u53", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
8959 { "fa-015.u54", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
8960 };
8961
8962 STD_ROM_PICK(msgundam1)
8963 STD_ROM_FN(msgundam1)
8964
8965 struct BurnDriver BurnDrvMsgundam1 = {
8966 "msgundam1", "msgundam", NULL, NULL, "1993",
8967 "Mobile Suit Gundam (Japan)\0", NULL, "Banpresto", "Seta",
8968 NULL, NULL, NULL, NULL,
8969 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VSFIGHT, 0,
8970 NULL, msgundam1RomInfo, msgundam1RomName, NULL, NULL, NULL, NULL, MsgundamInputInfo, Msgunda1DIPInfo,
8971 msgundamInit, DrvExit, DrvFrameMsgundam, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
8972 384, 240, 4, 3
8973 };
8974
8975
8976 // SD Gundam Neo Battling (Japan)
8977
8978 static struct BurnRomInfo neobattlRomDesc[] = {
8979 { "bp923001.u45", 0x020000, 0x0d0aeb73, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
8980 { "bp923002.u46", 0x020000, 0x9731fbbc, 0x01 | BRF_PRG | BRF_ESS }, // 1
8981
8982 { "bp923-003.u15", 0x080000, 0x91ca98a1, 0x03 | BRF_GRA }, // 2 Sprites
8983 { "bp923-004.u9", 0x080000, 0x15c678e3, 0x03 | BRF_GRA }, // 3
8984
8985 { "bp923-005.u4", 0x100000, 0x7c0e37be, 0x06 | BRF_SND }, // 4 x1-010 Samples
8986
8987 { "bp923-007.u37", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 5 plds
8988 { "bp923-008.u38", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 6
8989 };
8990
8991 STD_ROM_PICK(neobattl)
STD_ROM_FN(neobattl)8992 STD_ROM_FN(neobattl)
8993
8994 static INT32 umanclubInit()
8995 {
8996 DrvSetVideoOffsets(0, 0, 0, 0);
8997 DrvSetColorOffsets(0, 0, 0);
8998
8999 return DrvInit(umanclub68kInit, 16000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
9000 }
9001
9002 struct BurnDriver BurnDrvNeobattl = {
9003 "neobattl", NULL, NULL, NULL, "1992",
9004 "SD Gundam Neo Battling (Japan)\0", NULL, "Banpresto / Sotsu Agency. Sunrise", "Seta",
9005 NULL, NULL, NULL, NULL,
9006 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
9007 NULL, neobattlRomInfo, neobattlRomName, NULL, NULL, NULL, NULL, NeobattlInputInfo, NeobattlDIPInfo,
9008 umanclubInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9009 240, 384, 3, 4
9010 };
9011
9012
9013 // Ultraman Club - Tatakae! Ultraman Kyoudai!!
9014
9015 static struct BurnRomInfo umanclubRomDesc[] = {
9016 { "uw001006.u48", 0x020000, 0x3dae1e9d, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9017 { "uw001007.u49", 0x020000, 0x5c21e702, 0x01 | BRF_PRG | BRF_ESS }, // 1
9018
9019 { "bp-u-002.u2", 0x080000, 0x936cbaaa, 0x03 | BRF_GRA }, // 2 Sprites
9020 { "bp-u-001.u1", 0x080000, 0x87813c48, 0x03 | BRF_GRA }, // 3
9021
9022 { "uw003.u13", 0x100000, 0xe2f718eb, 0x06 | BRF_SND }, // 4 x1-010 Samples
9023 };
9024
9025 STD_ROM_PICK(umanclub)
9026 STD_ROM_FN(umanclub)
9027
9028 struct BurnDriver BurnDrvUmanclub = {
9029 "umanclub", NULL, NULL, NULL, "1992",
9030 "Ultraman Club - Tatakae! Ultraman Kyoudai!!\0", NULL, "Banpresto / Tsuburaya Productions", "Seta",
9031 NULL, NULL, NULL, NULL,
9032 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_SHOOT, 0,
9033 NULL, umanclubRomInfo, umanclubRomName, NULL, NULL, NULL, NULL, UmanclubInputInfo, UmanclubDIPInfo,
9034 umanclubInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9035 384, 240, 4, 3
9036 };
9037
9038
9039 // Masked Riders Club Battle Race
9040
9041 static struct BurnRomInfo kamenridRomDesc[] = {
9042 { "fj001003.25", 0x080000, 0x9b65d1b9, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9043
9044 { "fj001005.21", 0x100000, 0x5d031333, 0x03 | BRF_GRA }, // 1 Sprites
9045 { "fj001006.22", 0x100000, 0xcf28eb78, 0x03 | BRF_GRA }, // 2
9046
9047 { "fj001007.152", 0x080000, 0xd9ffe80b, 0x04 | BRF_GRA }, // 3 user1
9048
9049 { "fj001008.26", 0x100000, 0x45e2b329, 0x06 | BRF_SND }, // 4 x1-010 Samples
9050 };
9051
9052 STD_ROM_PICK(kamenrid)
STD_ROM_FN(kamenrid)9053 STD_ROM_FN(kamenrid)
9054
9055 static INT32 kamenridInit()
9056 {
9057 DrvSetVideoOffsets(0, 0, -2, -2);
9058 DrvSetColorOffsets(0, 0x400, 0x200);
9059
9060 return DrvInit(kamenrid68kInit, 16000000, SET_IRQLINES(2, 4/*2, NOIRQ2*/), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
9061 }
9062
9063 struct BurnDriver BurnDrvKamenrid = {
9064 "kamenrid", NULL, NULL, NULL, "1993",
9065 "Masked Riders Club Battle Race\0", NULL, "Banpresto / Toei", "Seta",
9066 NULL, NULL, NULL, NULL,
9067 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_RACING, 0,
9068 NULL, kamenridRomInfo, kamenridRomName, NULL, NULL, NULL, NULL, KamenridInputInfo, KamenridDIPInfo,
9069 kamenridInit, DrvExit, DrvKMFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
9070 384, 240, 4, 3
9071 };
9072
9073
9074 // Mad Shark
9075
9076 static struct BurnRomInfo madsharkRomDesc[] = {
9077 { "fq001002.201", 0x080000, 0x4286a811, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9078 { "fq001001.200", 0x080000, 0x38bfa0ad, 0x01 | BRF_PRG | BRF_ESS }, // 1
9079
9080 { "fq001004.202", 0x200000, 0xe56a1b5e, 0x03 | BRF_GRA }, // 2 Sprites
9081
9082 { "fq001006.152", 0x200000, 0x3bc5e8e4, 0x04 | BRF_GRA }, // 3 user1
9083 { "fq001005.205", 0x100000, 0x5f6c6d4a, 0x1c | BRF_GRA }, // 4
9084
9085 { "fq001007.26", 0x100000, 0xe4b33c13, 0x06 | BRF_SND }, // 5 x1-010 Samples
9086 };
9087
9088 STD_ROM_PICK(madshark)
STD_ROM_FN(madshark)9089 STD_ROM_FN(madshark)
9090
9091 static INT32 madsharkInit()
9092 {
9093 DrvSetVideoOffsets(0, 0, 0, 0);
9094 DrvSetColorOffsets(0, 0x200, 0xa00);
9095
9096 INT32 nRet = DrvInit(madshark68kInit, 16000000, SET_IRQLINES(4, 2/*2, NOIRQ2*/), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
9097
9098 if (nRet == 0) {
9099 jjsquawkSetColorTable();
9100 }
9101
9102 return nRet;
9103 }
9104
madsharkExit()9105 static INT32 madsharkExit()
9106 {
9107 BurnFree (DrvGfxROM2);
9108
9109 return DrvExit();
9110 }
9111
9112 struct BurnDriver BurnDrvMadshark = {
9113 "madshark", NULL, NULL, NULL, "1993",
9114 "Mad Shark\0", NULL, "Allumer", "Seta",
9115 NULL, NULL, NULL, NULL,
9116 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
9117 NULL, madsharkRomInfo, madsharkRomName, NULL, NULL, NULL, NULL, MadsharkInputInfo, MadsharkDIPInfo,
9118 madsharkInit, madsharkExit, DrvKMFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
9119 224, 384, 3, 4
9120 };
9121
9122
9123 // Wit's (Japan)
9124
9125 static struct BurnRomInfo witsRomDesc[] = {
9126 { "un001001.u1", 0x08000, 0x416c567e, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9127 { "un001002.u4", 0x08000, 0x497a3fa6, 0x01 | BRF_PRG | BRF_ESS }, // 1
9128
9129 { "un001008.7l", 0x20000, 0x1d5d0b2b, 0x0b | BRF_GRA }, // 2 Sprites
9130 { "un001007.5l", 0x20000, 0x9e1e6d51, 0x0b | BRF_GRA }, // 3
9131 { "un001006.4l", 0x20000, 0x98a980d4, 0x0b | BRF_GRA }, // 4
9132 { "un001005.2l", 0x20000, 0x6f2ce3c0, 0x0b | BRF_GRA }, // 5
9133
9134 { "un001004.12a", 0x20000, 0xa15ff938, 0x06 | BRF_SND }, // 6 x1-010 Samples
9135 { "un001003.10a", 0x20000, 0x3f4b9e55, 0x06 | BRF_SND }, // 7
9136 };
9137
9138 STD_ROM_PICK(wits)
STD_ROM_FN(wits)9139 STD_ROM_FN(wits)
9140
9141 static INT32 witsInit()
9142 {
9143 DrvSetVideoOffsets(0, 0, 0, 0);
9144 DrvSetColorOffsets(0, 0, 0);
9145
9146 return DrvInit(thunderl68kInit, 8000000, SET_IRQLINES(2, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
9147 }
9148
9149 struct BurnDriver BurnDrvWits = {
9150 "wits", NULL, NULL, NULL, "1989",
9151 "Wit's (Japan)\0", NULL, "Athena (Visco license)", "Seta",
9152 NULL, NULL, NULL, NULL,
9153 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 4, HARDWARE_SETA1, GBF_MAZE, 0,
9154 NULL, witsRomInfo, witsRomName, NULL, NULL, NULL, NULL, WitsInputInfo, WitsDIPInfo,
9155 witsInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9156 384, 240, 4, 3
9157 };
9158
9159
9160 // Thunder & Lightning
9161
9162 static struct BurnRomInfo thunderlRomDesc[] = {
9163 { "m4", 0x08000, 0x1e6b9462, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9164 { "m5", 0x08000, 0x7e82793e, 0x01 | BRF_PRG | BRF_ESS }, // 1
9165
9166 { "t17", 0x20000, 0x599a632a, 0x0b | BRF_GRA }, // 2 Sprites
9167 { "t16", 0x20000, 0x3aeef91c, 0x0b | BRF_GRA }, // 3
9168 { "t15", 0x20000, 0xb97a7b56, 0x0b | BRF_GRA }, // 4
9169 { "t14", 0x20000, 0x79c707be, 0x0b | BRF_GRA }, // 5
9170
9171 { "r28", 0x80000, 0xa043615d, 0x06 | BRF_SND }, // 6 x1-010 Samples
9172 { "r27", 0x80000, 0xcb8425a3, 0x06 | BRF_SND }, // 7
9173 };
9174
9175 STD_ROM_PICK(thunderl)
9176 STD_ROM_FN(thunderl)
9177
9178 struct BurnDriver BurnDrvThunderl = {
9179 "thunderl", NULL, NULL, NULL, "1990",
9180 "Thunder & Lightning\0", NULL, "Seta", "Seta",
9181 NULL, NULL, NULL, NULL,
9182 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_BREAKOUT, 0,
9183 NULL, thunderlRomInfo, thunderlRomName, NULL, NULL, NULL, NULL, ThunderlInputInfo, ThunderlDIPInfo,
9184 witsInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9185 240, 384, 3, 4
9186 };
9187
9188
9189 // Athena no Hatena ?
9190
9191 static struct BurnRomInfo atehateRomDesc[] = {
9192 { "fs001001.evn", 0x080000, 0x4af1f273, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9193 { "fs001002.odd", 0x080000, 0xc7ca7a85, 0x01 | BRF_PRG | BRF_ESS }, // 1
9194
9195 { "fs001003.gfx", 0x200000, 0x8b17e431, 0x03 | BRF_GRA }, // 2 Sprites
9196
9197 { "fs001004.pcm", 0x100000, 0xf9344ce5, 0x06 | BRF_SND }, // 3 x1-010 Samples
9198 };
9199
9200 STD_ROM_PICK(atehate)
STD_ROM_FN(atehate)9201 STD_ROM_FN(atehate)
9202
9203 static INT32 atehateInit()
9204 {
9205 DrvSetVideoOffsets(0, 0, 0, 0);
9206 DrvSetColorOffsets(0, 0, 0);
9207
9208 return DrvInit(atehate68kInit, 16000000, SET_IRQLINES(2, 1), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
9209 }
9210
9211 struct BurnDriver BurnDrvAtehate = {
9212 "atehate", NULL, NULL, NULL, "1993",
9213 "Athena no Hatena ?\0", NULL, "Athena", "Seta",
9214 NULL, NULL, NULL, NULL,
9215 BDF_GAME_WORKING, 2, HARDWARE_SETA1, GBF_QUIZ, 0,
9216 NULL, atehateRomInfo, atehateRomName, NULL, NULL, NULL, NULL, AtehateInputInfo, AtehateDIPInfo,
9217 atehateInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9218 384, 240, 4, 3
9219 };
9220
9221
9222 // Block Carnival / Thunder & Lightning 2
9223
9224 static struct BurnRomInfo blockcarRomDesc[] = {
9225 { "u1.a1", 0x20000, 0x4313fb00, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9226 { "u4.a3", 0x20000, 0x2237196d, 0x01 | BRF_PRG | BRF_ESS }, // 1
9227
9228 { "bl-chr-0.j3", 0x80000, 0xa33300ca, 0x03 | BRF_GRA }, // 2 Sprites
9229 { "bl-chr-1.l3", 0x80000, 0x563de808, 0x03 | BRF_GRA }, // 3
9230
9231 { "bl-snd-0.a13", 0x80000, 0xa92dabaf, 0x06 | BRF_SND }, // 4 x1-010 Samples
9232 };
9233
9234 STD_ROM_PICK(blockcar)
STD_ROM_FN(blockcar)9235 STD_ROM_FN(blockcar)
9236
9237 static INT32 blockcarInit()
9238 {
9239 DrvSetVideoOffsets(0, 0, 0, 0);
9240 DrvSetColorOffsets(0, 0, 0);
9241
9242 return DrvInit(blockcar68kInit, 8000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
9243 }
9244
9245 struct BurnDriver BurnDrvBlockcar = {
9246 "blockcar", NULL, NULL, NULL, "1992",
9247 "Block Carnival / Thunder & Lightning 2\0", NULL, "Visco", "Seta",
9248 NULL, NULL, NULL, NULL,
9249 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_ORIENTATION_FLIPPED | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_BREAKOUT, 0,
9250 NULL, blockcarRomInfo, blockcarRomName, NULL, NULL, NULL, NULL, BlockcarInputInfo, BlockcarDIPInfo,
9251 blockcarInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9252 240, 384, 3, 4
9253 };
9254
9255
9256 // Zombie Raid (9/28/95, US)
9257
9258 static struct BurnRomInfo zombraidRomDesc[] = {
9259 { "fy001003.3", 0x080000, 0x0b34b8f7, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9260 { "fy001004.4", 0x080000, 0x71bfeb1a, 0x01 | BRF_PRG | BRF_ESS }, // 1
9261 { "fy001002.103", 0x080000, 0x313fd68f, 0x01 | BRF_PRG | BRF_ESS }, // 2
9262 { "fy001001.102", 0x080000, 0xa0f61f13, 0x01 | BRF_PRG | BRF_ESS }, // 3
9263
9264 { "fy001006.200", 0x200000, 0xe9ae99f7, 0x03 | BRF_GRA }, // 4 Sprites
9265
9266 { "fy001008.66", 0x200000, 0x73d7b0e1, 0x04 | BRF_GRA }, // 5 Layer 1 tiles
9267 { "fy001007.65", 0x100000, 0xb2fc2c81, 0x1c | BRF_GRA }, // 6
9268
9269 { "fy001010.68", 0x200000, 0x8b40ed7a, 0x05 | BRF_GRA }, // 7 Layer 2 tiles
9270 { "fy001009.67", 0x100000, 0x6bcca641, 0x1d | BRF_GRA }, // 8
9271
9272 { "fy001012.b", 0x200000, 0xfd30e102, 0x06 | BRF_SND }, // 9 x1-010 Samples
9273 { "fy001011.a", 0x200000, 0xe3c431de, 0x06 | BRF_SND }, // 10
9274
9275 { "nvram.bin", 0x010000, 0x1a4b2ee8, 0x00 | BRF_OPT },
9276
9277 { "fy-001.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11 plds
9278 { "fy-002.u116", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 12
9279 { "fy-003.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 13
9280 { "fy-004.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 14
9281 { "fy-005.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 15
9282 { "fy-006.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 16
9283 };
9284
9285 STD_ROM_PICK(zombraid)
STD_ROM_FN(zombraid)9286 STD_ROM_FN(zombraid)
9287
9288 static INT32 zombraidInit()
9289 {
9290 DrvSetVideoOffsets(0, 0, -2, -2);
9291 DrvSetColorOffsets(0, 0x200, 0xa00);
9292
9293 INT32 nRet = DrvInit(zombraid68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
9294
9295 if (nRet == 0) {
9296 gundharaSetColorTable();
9297 }
9298
9299 return nRet;
9300 }
9301
9302 struct BurnDriver BurnDrvZombraid = {
9303 "zombraid", NULL, NULL, NULL, "1995",
9304 "Zombie Raid (9/28/95, US)\0", NULL, "American Sammy", "Seta",
9305 NULL, NULL, NULL, NULL,
9306 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_SHOOT, 0,
9307 NULL, zombraidRomInfo, zombraidRomName, NULL, NULL, NULL, NULL, ZombraidInputInfo, ZombraidDIPInfo,
9308 zombraidInit, DrvExit, DrvFrame, zombraidDraw, DrvScan, &DrvRecalc, 0x1200,
9309 384, 240, 4, 3
9310 };
9311
9312
9313 // Zombie Raid (9/28/95, US, prototype PCB)
9314 /* Prototype or test board version. Data matches released MASK rom version */
9315
9316 static struct BurnRomInfo zombraidpRomDesc[] = {
9317 { "u3_master_usa_prg_e_l_dd28.u3", 0x080000, 0x0b34b8f7, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9318 { "u4_master_usa_prg_o_l_5e2b.u4", 0x080000, 0x71bfeb1a, 0x01 | BRF_PRG | BRF_ESS }, // 1
9319 { "u103_master_usa_prg_e_h_789e.u103", 0x080000, 0x313fd68f, 0x01 | BRF_PRG | BRF_ESS }, // 2
9320 { "u102_master_usa_prg_o_h_1f25.u102", 0x080000, 0xa0f61f13, 0x01 | BRF_PRG | BRF_ESS }, // 3
9321
9322 { "u142_master_obj_00_1bb3.u142", 0x040000, 0xed6c8541, 0x0b | BRF_GRA }, // 4 Sprites
9323 { "obj_01", 0x040000, 0xa423620e, 0x0b | BRF_GRA }, // 5
9324 { "u143_master_obj_04_b5aa.u143", 0x040000, 0x1242670d, 0x0b | BRF_GRA }, // 6
9325 { "obj_05", 0x040000, 0x57fe3e97, 0x0b | BRF_GRA }, // 7
9326 { "u146_master_obj_02_6cc6.u146", 0x040000, 0x7562ee1b, 0x0b | BRF_GRA }, // 8
9327 { "u144_master_obj_03_1cb5.u144", 0x040000, 0xa83040f1, 0x0b | BRF_GRA }, // 9
9328 { "u147_master_obj_06_c3d8.u147", 0x040000, 0xa32c3da8, 0x0b | BRF_GRA }, // 10
9329 { "u145_master_obj_07_8ad4.u145", 0x040000, 0x8071f0b6, 0x0b | BRF_GRA }, // 11
9330
9331 { "u148_master_scn_1-0_3ef8.u148", 0x080000, 0x7d722f2a, 0x1c | BRF_GRA }, // 12 Layer 1 tiles
9332 { "u150_master_scn_1-1_89a6.u150", 0x080000, 0x3c62a8af, 0x1c | BRF_GRA }, // 13
9333 { "u149_master_scn_1-3_71bb.u149", 0x080000, 0x70d6af7f, 0x1c | BRF_GRA }, // 14
9334 { "u151_master_scn_1-4_872e.u151", 0x080000, 0x83ef4d5f, 0x1c | BRF_GRA }, // 15
9335 { "u154_master_scn_1-2_0f4b.u154", 0x080000, 0x0a1d647c, 0x1c | BRF_GRA }, // 16
9336 { "u155_master_scn_1-5_daef.u155", 0x080000, 0x2508f67f, 0x1c | BRF_GRA }, // 17
9337
9338 { "u164_master_scn_2-0_e79c.u164", 0x080000, 0xf8c89062, 0x1d | BRF_GRA }, // 18 Layer 2 tiles
9339 { "u166_master_scn_2-1_0b75.u166", 0x080000, 0x4d7a72d5, 0x1d | BRF_GRA }, // 19
9340 { "u165_master_scn_2-3_be68.u165", 0x080000, 0x8aaaef08, 0x1d | BRF_GRA }, // 20
9341 { "u167_master_scn_2-4_c515.u167", 0x080000, 0xd22ff5c1, 0x1d | BRF_GRA }, // 21
9342 { "u152_master_scn_2-2_c00e.u152", 0x080000, 0x0870ad58, 0x1d | BRF_GRA }, // 22
9343 { "u153_master_scn_2-5_e1da.u153", 0x080000, 0x814ac66a, 0x1d | BRF_GRA }, // 23
9344
9345 { "u156_master_snd_0_f630.u156", 0x080000, 0xbfc467bd, 0x06 | BRF_SND }, // 24 x1-010 Samples
9346 { "u157_master_snd_1_c20a.u157", 0x080000, 0xb449a8ba, 0x06 | BRF_SND }, // 25
9347 { "u158_master_snd_2_5c69.u158", 0x080000, 0xed6de791, 0x06 | BRF_SND }, // 26
9348 { "u159_master_snd_3_0727.u159", 0x080000, 0x794cec21, 0x06 | BRF_SND }, // 27
9349 { "u160_master_snd_4_5a70.u160", 0x080000, 0xe81ace66, 0x06 | BRF_SND }, // 28
9350 { "u161_master_snd_5_599c.u161", 0x080000, 0x1793dd13, 0x06 | BRF_SND }, // 29
9351 { "u162_master_snd_6_6d2e.u162", 0x080000, 0x2ece241f, 0x06 | BRF_SND }, // 30
9352 { "u163_master_snd_7_c733.u163", 0x080000, 0xd90f78b2, 0x06 | BRF_SND }, // 31
9353
9354 { "nvram.bin", 0x010000, 0x1a4b2ee8, 0x00 | BRF_OPT },
9355 };
9356
9357 STD_ROM_PICK(zombraidp)
STD_ROM_FN(zombraidp)9358 STD_ROM_FN(zombraidp)
9359
9360 static INT32 zombraidpRomCallback(INT32 bLoad)
9361 {
9362 if (!bLoad)
9363 {
9364 DrvROMLen[0] = 0x200000; // gfx0
9365 DrvROMLen[1] = 0x400000; // gfx1
9366 DrvROMLen[2] = 0x400000; // gfx2
9367 DrvROMLen[3] = 0x480000; // sound rom
9368 }
9369 else
9370 {
9371 if (BurnLoadRom(Drv68KROM + 0x000001, 0, 2)) return 1;
9372 if (BurnLoadRom(Drv68KROM + 0x000000, 1, 2)) return 1;
9373 if (BurnLoadRom(Drv68KROM + 0x100001, 2, 2)) return 1;
9374 if (BurnLoadRom(Drv68KROM + 0x100000, 3, 2)) return 1;
9375
9376 if (BurnLoadRom(DrvGfxROM0 + 0x000001, 4, 2)) return 1;
9377 if (BurnLoadRom(DrvGfxROM0 + 0x000000, 5, 2)) return 1;
9378 if (BurnLoadRom(DrvGfxROM0 + 0x080001, 6, 2)) return 1;
9379 if (BurnLoadRom(DrvGfxROM0 + 0x080000, 7, 2)) return 1;
9380 if (BurnLoadRom(DrvGfxROM0 + 0x100001, 8, 2)) return 1;
9381 if (BurnLoadRom(DrvGfxROM0 + 0x100000, 9, 2)) return 1;
9382 if (BurnLoadRom(DrvGfxROM0 + 0x180001, 10, 2)) return 1;
9383 if (BurnLoadRom(DrvGfxROM0 + 0x180000, 11, 2)) return 1;
9384
9385 if (BurnLoadRom(DrvGfxROM1 + 0x000000, 12, 2)) return 1;
9386 if (BurnLoadRom(DrvGfxROM1 + 0x000001, 13, 2)) return 1;
9387 if (BurnLoadRom(DrvGfxROM1 + 0x100000, 14, 2)) return 1;
9388 if (BurnLoadRom(DrvGfxROM1 + 0x100001, 15, 2)) return 1;
9389 if (BurnLoadRom(DrvGfxROM1 + 0x200000, 16, 2)) return 1;
9390 if (BurnLoadRom(DrvGfxROM1 + 0x300000, 17, 2)) return 1;
9391
9392 if (BurnLoadRom(DrvGfxROM2 + 0x000000, 18, 2)) return 1;
9393 if (BurnLoadRom(DrvGfxROM2 + 0x000001, 19, 2)) return 1;
9394 if (BurnLoadRom(DrvGfxROM2 + 0x100000, 20, 2)) return 1;
9395 if (BurnLoadRom(DrvGfxROM2 + 0x100001, 21, 2)) return 1;
9396 if (BurnLoadRom(DrvGfxROM2 + 0x200000, 22, 2)) return 1;
9397 if (BurnLoadRom(DrvGfxROM2 + 0x300000, 23, 2)) return 1;
9398
9399 if (BurnLoadRom(DrvSndROM + 0x000000, 24, 1)) return 1;
9400 if (BurnLoadRom(DrvSndROM + 0x080000, 25, 1)) return 1;
9401 if (BurnLoadRom(DrvSndROM + 0x100000, 26, 1)) return 1;
9402 if (BurnLoadRom(DrvSndROM + 0x180000, 27, 1)) return 1;
9403 if (BurnLoadRom(DrvSndROM + 0x200000, 28, 1)) return 1;
9404 if (BurnLoadRom(DrvSndROM + 0x280000, 29, 1)) return 1;
9405 if (BurnLoadRom(DrvSndROM + 0x300000, 30, 1)) return 1;
9406 if (BurnLoadRom(DrvSndROM + 0x380000, 31, 1)) return 1;
9407 }
9408
9409 return 0;
9410 }
9411
zombraidpInit()9412 static INT32 zombraidpInit()
9413 {
9414 DrvSetVideoOffsets(0, 0, -2, -2);
9415 DrvSetColorOffsets(0, 0x200, 0xa00);
9416
9417 pRomLoadCallback = zombraidpRomCallback;
9418
9419 INT32 nRet = DrvInit(zombraid68kInit, 16000000, SET_IRQLINES(2, 4), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
9420
9421 if (nRet == 0) {
9422 gundharaSetColorTable();
9423 }
9424
9425 return nRet;
9426 }
9427
9428 struct BurnDriver BurnDrvZombraidp = {
9429 "zombraidp", "zombraid", NULL, NULL, "1995",
9430 "Zombie Raid (9/28/95, US, prototype PCB)\0", NULL, "American Sammy", "Seta",
9431 NULL, NULL, NULL, NULL,
9432 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_SHOOT, 0,
9433 NULL, zombraidpRomInfo, zombraidpRomName, NULL, NULL, NULL, NULL, ZombraidInputInfo, ZombraidDIPInfo,
9434 zombraidpInit, DrvExit, DrvFrame, zombraidDraw, DrvScan, &DrvRecalc, 0x1200,
9435 384, 240, 4, 3
9436 };
9437
9438
9439 // Zombie Raid (9/28/95, Japan, prototype PCB)
9440 /* Prototype or test board version. Data matches released MASK rom version */
9441
9442 static struct BurnRomInfo zombraidpjRomDesc[] = {
9443 { "u3_master_usa_prg_e_l_dd28.u3", 0x080000, 0x0b34b8f7, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9444 { "u4_master_jpn_prg_o_l_5e2c.u4", 0x080000, 0x3cb6bdf0, 0x01 | BRF_PRG | BRF_ESS }, // 1
9445 { "u103_master_usa_prg_e_h_789e.u103", 0x080000, 0x313fd68f, 0x01 | BRF_PRG | BRF_ESS }, // 2
9446 { "u102_master_usa_prg_o_h_1f25.u102", 0x080000, 0xa0f61f13, 0x01 | BRF_PRG | BRF_ESS }, // 3
9447
9448 { "u142_master_obj_00_1bb3.u142", 0x040000, 0xed6c8541, 0x0b | BRF_GRA }, // 4 Sprites
9449 { "obj_01", 0x040000, 0xa423620e, 0x0b | BRF_GRA }, // 5
9450 { "u143_master_obj_04_b5aa.u143", 0x040000, 0x1242670d, 0x0b | BRF_GRA }, // 6
9451 { "obj_05", 0x040000, 0x57fe3e97, 0x0b | BRF_GRA }, // 7
9452 { "u146_master_obj_02_6cc6.u146", 0x040000, 0x7562ee1b, 0x0b | BRF_GRA }, // 8
9453 { "u144_master_obj_03_1cb5.u144", 0x040000, 0xa83040f1, 0x0b | BRF_GRA }, // 9
9454 { "u147_master_obj_06_c3d8.u147", 0x040000, 0xa32c3da8, 0x0b | BRF_GRA }, // 10
9455 { "u145_master_obj_07_8ad4.u145", 0x040000, 0x8071f0b6, 0x0b | BRF_GRA }, // 11
9456
9457 { "u148_master_scn_1-0_3ef8.u148", 0x080000, 0x7d722f2a, 0x1c | BRF_GRA }, // 12 Layer 1 tiles
9458 { "u150_master_scn_1-1_89a6.u150", 0x080000, 0x3c62a8af, 0x1c | BRF_GRA }, // 13
9459 { "u149_master_scn_1-3_71bb.u149", 0x080000, 0x70d6af7f, 0x1c | BRF_GRA }, // 14
9460 { "u151_master_scn_1-4_872e.u151", 0x080000, 0x83ef4d5f, 0x1c | BRF_GRA }, // 15
9461 { "u154_master_scn_1-2_0f4b.u154", 0x080000, 0x0a1d647c, 0x1c | BRF_GRA }, // 16
9462 { "u155_master_scn_1-5_daef.u155", 0x080000, 0x2508f67f, 0x1c | BRF_GRA }, // 17
9463
9464 { "u164_master_scn_2-0_e79c.u164", 0x080000, 0xf8c89062, 0x1d | BRF_GRA }, // 18 Layer 2 tiles
9465 { "u166_master_scn_2-1_0b75.u166", 0x080000, 0x4d7a72d5, 0x1d | BRF_GRA }, // 19
9466 { "u165_master_scn_2-3_be68.u165", 0x080000, 0x8aaaef08, 0x1d | BRF_GRA }, // 20
9467 { "u167_master_scn_2-4_c515.u167", 0x080000, 0xd22ff5c1, 0x1d | BRF_GRA }, // 21
9468 { "u152_master_scn_2-2_c00e.u152", 0x080000, 0x0870ad58, 0x1d | BRF_GRA }, // 22
9469 { "u153_master_scn_2-5_e1da.u153", 0x080000, 0x814ac66a, 0x1d | BRF_GRA }, // 23
9470
9471 { "u156_master_snd_0_f630.u156", 0x080000, 0xbfc467bd, 0x06 | BRF_SND }, // 24 x1-010 Samples
9472 { "u157_master_snd_1_c20a.u157", 0x080000, 0xb449a8ba, 0x06 | BRF_SND }, // 25
9473 { "u158_master_snd_2_5c69.u158", 0x080000, 0xed6de791, 0x06 | BRF_SND }, // 26
9474 { "u159_master_snd_3_0727.u159", 0x080000, 0x794cec21, 0x06 | BRF_SND }, // 27
9475 { "u160_master_snd_4_5a70.u160", 0x080000, 0xe81ace66, 0x06 | BRF_SND }, // 28
9476 { "u161_master_snd_5_599c.u161", 0x080000, 0x1793dd13, 0x06 | BRF_SND }, // 29
9477 { "u162_master_snd_6_6d2e.u162", 0x080000, 0x2ece241f, 0x06 | BRF_SND }, // 30
9478 { "u163_master_snd_7_c733.u163", 0x080000, 0xd90f78b2, 0x06 | BRF_SND }, // 31
9479
9480 { "nvram.bin", 0x010000, 0x1a4b2ee8, 0x00 | BRF_OPT },
9481 };
9482
9483 STD_ROM_PICK(zombraidpj)
9484 STD_ROM_FN(zombraidpj)
9485
9486 struct BurnDriver BurnDrvZombraidpj = {
9487 "zombraidpj", "zombraid", NULL, NULL, "1995",
9488 "Zombie Raid (9/28/95, Japan, prototype PCB)\0", NULL, "Sammy Industries Co.,Ltd.", "Seta",
9489 NULL, NULL, NULL, NULL,
9490 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_SHOOT, 0,
9491 NULL, zombraidpjRomInfo, zombraidpjRomName, NULL, NULL, NULL, NULL, ZombraidInputInfo, ZombraidDIPInfo,
9492 zombraidpInit, DrvExit, DrvFrame, zombraidDraw, DrvScan, &DrvRecalc, 0x1200,
9493 384, 240, 4, 3
9494 };
9495
9496
9497 // Gundhara
9498
9499 static struct BurnRomInfo gundharaRomDesc[] = {
9500 { "bpgh-003.u3", 0x080000, 0x14e9970a, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9501 { "bpgh-004.u4", 0x080000, 0x96dfc658, 0x01 | BRF_PRG | BRF_ESS }, // 1
9502 { "bpgh-002.103", 0x080000, 0x312f58e2, 0x01 | BRF_PRG | BRF_ESS }, // 2
9503 { "bpgh-001.102", 0x080000, 0x8d23a23c, 0x01 | BRF_PRG | BRF_ESS }, // 3
9504
9505 { "bpgh-008.u64", 0x200000, 0x7ed9d272, 0x03 | BRF_GRA }, // 4 Sprites
9506 { "bpgh-006.201", 0x200000, 0x5a81411d, 0x03 | BRF_GRA }, // 5
9507 { "bpgh-007.u63", 0x200000, 0xaa49ce7b, 0x03 | BRF_GRA }, // 6
9508 { "bpgh-005.200", 0x200000, 0x74138266, 0x03 | BRF_GRA }, // 7
9509
9510 { "bpgh-010.u66", 0x100000, 0xb742f0b8, 0x04 | BRF_GRA }, // 8 Layer 1 tiles
9511 { "bpgh-009.u65", 0x080000, 0xb768e666, 0x1c | BRF_GRA }, // 9
9512
9513 { "bpgh-012.u68", 0x200000, 0xedfda595, 0x05 | BRF_GRA }, // 10 Layer 2 tiles
9514 { "bpgh-011.u67", 0x100000, 0x49aff270, 0x1d | BRF_GRA }, // 11
9515
9516 { "bpgh-013.u70", 0x100000, 0x0fa5d503, 0x06 | BRF_SND }, // 12 x1-010 Samples
9517
9518 { "fx-001.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 13 plds
9519 { "fx-002.u116", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 14
9520 { "fx-003.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 15
9521 { "fx-004.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 16
9522 { "fx-005.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
9523 { "fx-006.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
9524 };
9525
9526 STD_ROM_PICK(gundhara)
STD_ROM_FN(gundhara)9527 STD_ROM_FN(gundhara)
9528
9529 static void gundhara68kInit()
9530 {
9531 wrofaero68kInit();
9532
9533 // swap halves of sound rom
9534 memcpy (DrvSndROM + 0x100000, DrvSndROM + 0x000000, 0x080000); // temp storage
9535
9536 memcpy (DrvSndROM + 0x000000, DrvSndROM + 0x080000, 0x080000);
9537 memcpy (DrvSndROM + 0x080000, DrvSndROM + 0x100000, 0x080000);
9538 }
9539
gundharaInit()9540 static INT32 gundharaInit()
9541 {
9542 DrvSetVideoOffsets(0, 0, 0, 0);
9543 DrvSetColorOffsets(0, 0x200, 0xa00);
9544
9545 INT32 nRet = DrvInit(gundhara68kInit, 16000000, SET_IRQLINES(2, 4), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
9546
9547 if (nRet == 0) {
9548 gundharaSetColorTable();
9549 }
9550
9551 return nRet;
9552 }
9553
9554 struct BurnDriver BurnDrvGundhara = {
9555 "gundhara", NULL, NULL, NULL, "1995",
9556 "Gundhara\0", NULL, "Banpresto", "Seta",
9557 NULL, NULL, NULL, NULL,
9558 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_RUNGUN, 0,
9559 NULL, gundharaRomInfo, gundharaRomName, NULL, NULL, NULL, NULL, GundharaInputInfo, GundharaDIPInfo,
9560 gundharaInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
9561 240, 384, 3, 4
9562 };
9563
9564
9565 // Gundhara (Chinese, bootleg?)
9566
9567 static struct BurnRomInfo gundharacRomDesc[] = {
9568 { "4.u3", 0x080000, 0x14e9970a, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9569 { "2.u4", 0x080000, 0x96dfc658, 0x01 | BRF_PRG | BRF_ESS }, // 1
9570 { "3.u103", 0x080000, 0x312f58e2, 0x01 | BRF_PRG | BRF_ESS }, // 2
9571 { "1.u102", 0x080000, 0x8d23a23c, 0x01 | BRF_PRG | BRF_ESS }, // 3
9572
9573 { "19.u140", 0x080000, 0x32d92c28, 0x0b | BRF_GRA }, // 4 Sprites
9574 { "23.u142", 0x080000, 0xff44db9b, 0x0b | BRF_GRA }, // 5
9575 { "21.u141", 0x080000, 0x1901dc08, 0x0b | BRF_GRA }, // 6
9576 { "25.u143", 0x080000, 0x877289a2, 0x0b | BRF_GRA }, // 7
9577 { "18.u140-b", 0x080000, 0x4f023fb0, 0x0b | BRF_GRA }, // 8
9578 { "22.u142-b", 0x080000, 0x6f3fe7e7, 0x0b | BRF_GRA }, // 9
9579 { "20.u141-b", 0x080000, 0x7f1932e0, 0x0b | BRF_GRA }, // 10
9580 { "24.u143-b", 0x080000, 0x066a2e2b, 0x0b | BRF_GRA }, // 11
9581 { "9.u144", 0x080000, 0x6b4a531f, 0x0b | BRF_GRA }, // 12
9582 { "13.u146", 0x080000, 0x45be3df4, 0x0b | BRF_GRA }, // 13
9583 { "11.u145", 0x080000, 0xf5210aa5, 0x0b | BRF_GRA }, // 14
9584 { "15.u147", 0x080000, 0x17003119, 0x0b | BRF_GRA }, // 15
9585 { "8.u144-b", 0x080000, 0xad9d9338, 0x0b | BRF_GRA }, // 16
9586 { "12.u146-b", 0x080000, 0x0fd4c062, 0x0b | BRF_GRA }, // 17
9587 { "10.u145-b", 0x080000, 0x7c5d12b9, 0x0b | BRF_GRA }, // 18
9588 { "14.u147-b", 0x080000, 0x5a8af50f, 0x0b | BRF_GRA }, // 19
9589
9590 { "5.u148", 0x080000, 0x0c740f9b, 0x1c | BRF_GRA }, // 20 Layer 1 tiles
9591 { "6.u150", 0x080000, 0xba60eb98, 0x1c | BRF_GRA }, // 21
9592 { "7.u154", 0x080000, 0xb768e666, 0x1c | BRF_GRA }, // 22
9593
9594 { "26.u164", 0x080000, 0xbe3ccaba, 0x1d | BRF_GRA }, // 23 Layer 2 tiles
9595 { "28.u166", 0x080000, 0x8a650a4e, 0x1d | BRF_GRA }, // 24
9596 { "27.u165", 0x080000, 0x47994ff0, 0x1d | BRF_GRA }, // 25
9597 { "29.u167", 0x080000, 0x453c3d3f, 0x1d | BRF_GRA }, // 26
9598 { "16.u152", 0x080000, 0x5ccc500b, 0x1d | BRF_GRA }, // 27
9599 { "17.u153", 0x080000, 0x5586d086, 0x1d | BRF_GRA }, // 28
9600
9601 { "30.u69", 0x080000, 0x3111a98a, 0x06 | BRF_SND }, // 29 x1-010 Samples
9602 { "31.u70", 0x080000, 0x30cb2524, 0x06 | BRF_SND }, // 30
9603 };
9604
9605 STD_ROM_PICK(gundharac)
STD_ROM_FN(gundharac)9606 STD_ROM_FN(gundharac)
9607
9608 static INT32 gundharacRomCallback(INT32 bLoad)
9609 {
9610 if (!bLoad)
9611 {
9612 DrvROMLen[0] = 0x800000; // gfx0
9613 DrvROMLen[1] = 0x200000; // gfx1
9614 DrvROMLen[2] = 0x400000; // gfx2
9615 DrvROMLen[3] = 0x100000; // sound rom
9616 }
9617 else
9618 {
9619 if (BurnLoadRom(Drv68KROM + 0x000001, 0, 2)) return 1;
9620 if (BurnLoadRom(Drv68KROM + 0x000000, 1, 2)) return 1;
9621 if (BurnLoadRom(Drv68KROM + 0x100001, 2, 2)) return 1;
9622 if (BurnLoadRom(Drv68KROM + 0x100000, 3, 2)) return 1;
9623
9624 if (BurnLoadRom(DrvGfxROM0 + 0x000000, 4, 2)) return 1;
9625 if (BurnLoadRom(DrvGfxROM0 + 0x000001, 5, 2)) return 1;
9626 if (BurnLoadRom(DrvGfxROM0 + 0x100000, 6, 2)) return 1;
9627 if (BurnLoadRom(DrvGfxROM0 + 0x100001, 7, 2)) return 1;
9628 if (BurnLoadRom(DrvGfxROM0 + 0x200000, 8, 2)) return 1;
9629 if (BurnLoadRom(DrvGfxROM0 + 0x200001, 9, 2)) return 1;
9630 if (BurnLoadRom(DrvGfxROM0 + 0x300000, 10, 2)) return 1;
9631 if (BurnLoadRom(DrvGfxROM0 + 0x300001, 11, 2)) return 1;
9632 if (BurnLoadRom(DrvGfxROM0 + 0x400000, 12, 2)) return 1;
9633 if (BurnLoadRom(DrvGfxROM0 + 0x400001, 13, 2)) return 1;
9634 if (BurnLoadRom(DrvGfxROM0 + 0x500000, 14, 2)) return 1;
9635 if (BurnLoadRom(DrvGfxROM0 + 0x500001, 15, 2)) return 1;
9636 if (BurnLoadRom(DrvGfxROM0 + 0x600000, 16, 2)) return 1;
9637 if (BurnLoadRom(DrvGfxROM0 + 0x600001, 17, 2)) return 1;
9638 if (BurnLoadRom(DrvGfxROM0 + 0x700000, 18, 2)) return 1;
9639 if (BurnLoadRom(DrvGfxROM0 + 0x700001, 19, 2)) return 1;
9640
9641 if (BurnLoadRom(DrvGfxROM1 + 0x000000, 20, 2)) return 1;
9642 if (BurnLoadRom(DrvGfxROM1 + 0x000001, 21, 2)) return 1;
9643 if (BurnLoadRom(DrvGfxROM1 + 0x100000, 22, 2)) return 1;
9644
9645 if (BurnLoadRom(DrvGfxROM2 + 0x000000, 23, 2)) return 1;
9646 if (BurnLoadRom(DrvGfxROM2 + 0x000001, 24, 2)) return 1;
9647 if (BurnLoadRom(DrvGfxROM2 + 0x100000, 25, 2)) return 1;
9648 if (BurnLoadRom(DrvGfxROM2 + 0x100001, 26, 2)) return 1;
9649 if (BurnLoadRom(DrvGfxROM2 + 0x200000, 27, 2)) return 1;
9650 if (BurnLoadRom(DrvGfxROM2 + 0x300000, 28, 2)) return 1;
9651
9652 if (BurnLoadRom(DrvSndROM + 0x080000, 29, 1)) return 1;
9653 if (BurnLoadRom(DrvSndROM + 0x000000, 30, 1)) return 1;
9654 }
9655
9656 return 0;
9657 }
9658
gundharacInit()9659 static INT32 gundharacInit()
9660 {
9661 DrvSetVideoOffsets(0, 0, -2, -2);
9662 DrvSetColorOffsets(0, 0x200, 0xa00);
9663
9664 pRomLoadCallback = gundharacRomCallback;
9665
9666 INT32 nRet = DrvInit(gundhara68kInit, 16000000, SET_IRQLINES(2, 4), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
9667
9668 if (nRet == 0) {
9669 gundharaSetColorTable();
9670 }
9671
9672 return nRet;
9673 }
9674
9675 struct BurnDriver BurnDrvGundharac = {
9676 "gundharac", "gundhara", NULL, NULL, "1995",
9677 "Gundhara (Chinese, bootleg?)\0", NULL, "Banpresto", "Seta",
9678 NULL, NULL, NULL, NULL,
9679 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_RUNGUN, 0,
9680 NULL, gundharacRomInfo, gundharacRomName, NULL, NULL, NULL, NULL, GundharaInputInfo, GundharaDIPInfo,
9681 gundharacInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
9682 240, 384, 3, 4
9683 };
9684
9685
9686 // Blandia
9687
9688 static struct BurnRomInfo blandiaRomDesc[] = {
9689 { "ux001001.u3", 0x040000, 0x2376a1f3, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9690 { "ux001002.u4", 0x040000, 0xb915e172, 0x01 | BRF_PRG | BRF_ESS }, // 1
9691 { "ux001003.u202", 0x100000, 0x98052c63, 0x01 | BRF_PRG | BRF_ESS }, // 2
9692
9693 { "ux001008.u64", 0x100000, 0x413647b6, 0x03 | BRF_GRA }, // 6
9694 { "ux001007.u201", 0x100000, 0x4440fdd1, 0x03 | BRF_GRA }, // 4
9695 { "ux001006.u63", 0x100000, 0xabc01cf7, 0x03 | BRF_GRA }, // 5
9696 { "ux001005.u200", 0x100000, 0xbea0c4a5, 0x03 | BRF_GRA }, // 3 Sprites
9697
9698 { "ux001009.u65", 0x080000, 0xbc6f6aea, 0x04 | BRF_GRA }, // 7 Layer 1 tiles
9699 { "ux001010.u66", 0x080000, 0xbd7f7614, 0x04 | BRF_GRA }, // 8
9700
9701 { "ux001011.u67", 0x080000, 0x5efe0397, 0x05 | BRF_GRA }, // 9 Layer 2 tiles
9702 { "ux001012.u068", 0x080000, 0xf29959f6, 0x05 | BRF_GRA }, // 10
9703
9704 { "ux001013.u69", 0x100000, 0x5cd273cd, 0x06 | BRF_SND }, // 11 x1-010 Samples
9705 { "ux001014.u70", 0x080000, 0x86b49b4e, 0x06 | BRF_SND }, // 12
9706
9707 { "ux-015.u206", 0x000117, 0x08cddbdd, 0x00 | BRF_OPT }, // 13 plds
9708 { "ux-016.u116", 0x000117, 0x9734f1af, 0x00 | BRF_OPT }, // 14
9709 { "ux-017.u14", 0x000117, 0x9e95d8d5, 0x00 | BRF_OPT }, // 15
9710 { "ux-018.u35", 0x000117, 0xc9579473, 0x00 | BRF_OPT }, // 16
9711 { "ux-019.u36", 0x000117, 0xd85c359d, 0x00 | BRF_OPT }, // 17
9712 { "ux-020.u76", 0x000117, 0x116278bf, 0x00 | BRF_OPT }, // 15
9713 };
9714
9715 STD_ROM_PICK(blandia)
STD_ROM_FN(blandia)9716 STD_ROM_FN(blandia)
9717
9718 static INT32 blandiaInit()
9719 {
9720 DrvSetVideoOffsets(0, 0, 0, 0);
9721 DrvSetColorOffsets(0, 0xa00, 0x200);
9722
9723 INT32 nRet = DrvInit(blandia68kInit, 16000000, SET_IRQLINES(2, 4), SPRITE_BUFFER, SET_GFX_DECODE(0, 4, 4));
9724
9725 if (nRet == 0) {
9726 // Update sample length to include the banked section that was skipped (0xc0000 - 0xfffff)
9727 DrvROMLen[3] = 0x1c0000;
9728 blandiaSetColorTable();
9729 }
9730
9731 return nRet;
9732 }
9733
9734 struct BurnDriver BurnDrvBlandia = {
9735 "blandia", NULL, NULL, NULL, "1992",
9736 "Blandia\0", NULL, "Allumer", "Seta",
9737 NULL, NULL, NULL, NULL,
9738 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VSFIGHT, 0,
9739 NULL, blandiaRomInfo, blandiaRomName, NULL, NULL, NULL, NULL, BlandiaInputInfo, BlandiaDIPInfo,
9740 blandiaInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
9741 384, 240, 4, 3
9742 };
9743
9744
9745 // Blandia (prototype)
9746
9747 static struct BurnRomInfo blandiapRomDesc[] = {
9748 { "prg-even.bin", 0x40000, 0x7ecd30e8, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9749 { "prg-odd.bin", 0x40000, 0x42b86c15, 0x01 | BRF_PRG | BRF_ESS }, // 1
9750 { "tbl0.bin", 0x80000, 0x69b79eb8, 0x01 | BRF_PRG | BRF_ESS }, // 2
9751 { "tbl1.bin", 0x80000, 0xcf2fd350, 0x01 | BRF_PRG | BRF_ESS }, // 3
9752
9753 { "o-1.bin", 0x80000, 0x4c67b7f0, 0x0b | BRF_GRA }, // 4 Sprites
9754 { "o-0.bin", 0x80000, 0x5e7b8555, 0x0b | BRF_GRA }, // 5
9755 { "o-5.bin", 0x80000, 0x40bee78b, 0x0b | BRF_GRA }, // 6
9756 { "o-4.bin", 0x80000, 0x7c634784, 0x0b | BRF_GRA }, // 7
9757 { "o-3.bin", 0x80000, 0x387fc7c4, 0x0b | BRF_GRA }, // 8
9758 { "o-2.bin", 0x80000, 0xc669bb49, 0x0b | BRF_GRA }, // 9
9759 { "o-7.bin", 0x80000, 0xfc77b04a, 0x0b | BRF_GRA }, // 10
9760 { "o-6.bin", 0x80000, 0x92882943, 0x0b | BRF_GRA }, // 11
9761
9762 { "v1-2.bin", 0x20000, 0xd524735e, 0x04 | BRF_GRA }, // 12 Layer 1 tiles
9763 { "v1-5.bin", 0x20000, 0xeb440cdb, 0x04 | BRF_GRA }, // 13
9764 { "v1-1.bin", 0x20000, 0x09bdf75f, 0x04 | BRF_GRA }, // 14
9765 { "v1-4.bin", 0x20000, 0x803911e5, 0x04 | BRF_GRA }, // 15
9766 { "v1-0.bin", 0x20000, 0x73617548, 0x04 | BRF_GRA }, // 16
9767 { "v1-3.bin", 0x20000, 0x7f18e4fb, 0x04 | BRF_GRA }, // 17
9768
9769 { "v2-2.bin", 0x20000, 0xc4f15638, 0x05 | BRF_GRA }, // 18 Layer 2 tiles
9770 { "v2-5.bin", 0x20000, 0xc2e57622, 0x05 | BRF_GRA }, // 19
9771 { "v2-1.bin", 0x20000, 0xc4f15638, 0x05 | BRF_GRA }, // 20
9772 { "v2-4.bin", 0x20000, 0x16ec2130, 0x05 | BRF_GRA }, // 21
9773 { "v2-0.bin", 0x20000, 0x5b05eba9, 0x05 | BRF_GRA }, // 22
9774 { "v2-3.bin", 0x20000, 0x80ad0c3b, 0x05 | BRF_GRA }, // 23
9775
9776 { "s-0.bin", 0x40000, 0xa5fde408, 0x06 | BRF_SND }, // 24 x1-010 Samples
9777 { "s-1.bin", 0x40000, 0x3083f9c4, 0x06 | BRF_SND }, // 25
9778 { "s-2.bin", 0x40000, 0xa591c9ef, 0x06 | BRF_SND }, // 26
9779 { "s-3.bin", 0x40000, 0x68826c9d, 0x06 | BRF_SND }, // 27
9780 { "s-4.bin", 0x40000, 0x1c7dc8c2, 0x06 | BRF_SND }, // 28
9781 { "s-5.bin", 0x40000, 0x4bb0146a, 0x06 | BRF_SND }, // 29
9782 { "s-6.bin", 0x40000, 0x9f8f34ee, 0x06 | BRF_SND }, // 30
9783 { "s-7.bin", 0x40000, 0xe077dd39, 0x06 | BRF_SND }, // 31
9784
9785 { "ux-015.u206", 0x00104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 32 plds
9786 { "ux-016.u116", 0x00104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 33
9787 };
9788
9789 STD_ROM_PICK(blandiap)
STD_ROM_FN(blandiap)9790 STD_ROM_FN(blandiap)
9791
9792 static INT32 blandiapInit()
9793 {
9794 DrvSetVideoOffsets(0, 8, -2, 6);
9795 DrvSetColorOffsets(0, 0xa00, 0x200);
9796
9797 INT32 nRet = DrvInit(blandiap68kInit, 16000000, SET_IRQLINES(2, 4), SPRITE_BUFFER, SET_GFX_DECODE(0, 4, 4));
9798
9799 if (nRet == 0) {
9800 blandiaSetColorTable();
9801 }
9802
9803 return nRet;
9804 }
9805
9806 struct BurnDriver BurnDrvBlandiap = {
9807 "blandiap", "blandia", NULL, NULL, "1992",
9808 "Blandia (prototype)\0", NULL, "Allumer", "Seta",
9809 NULL, NULL, NULL, NULL,
9810 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VSFIGHT, 0,
9811 NULL, blandiapRomInfo, blandiapRomName, NULL, NULL, NULL, NULL, BlandiaInputInfo, BlandiaDIPInfo,
9812 blandiapInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
9813 384, 240, 4, 3
9814 };
9815
9816
9817 // Oishii Puzzle Ha Irimasenka
9818
9819 static struct BurnRomInfo oisipuzlRomDesc[] = {
9820 { "ss1u200.v10", 0x80000, 0xf5e53baf, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9821 { "ss1u201.v10", 0x80000, 0x7a7ff5ae, 0x01 | BRF_PRG | BRF_ESS }, // 1
9822
9823 { "ss1u306.v10", 0x80000, 0xce43a754, 0x03 | BRF_GRA }, // 2 Sprites
9824 { "ss1u307.v10", 0x80000, 0x2170b7ec, 0x03 | BRF_GRA }, // 3
9825 { "ss1u304.v10", 0x80000, 0x546ab541, 0x03 | BRF_GRA }, // 4
9826 { "ss1u305.v10", 0x80000, 0x2a33e08b, 0x03 | BRF_GRA }, // 5
9827
9828 { "ss1u23.v10", 0x80000, 0x9fa60901, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
9829 { "ss1u24.v10", 0x80000, 0xc10eb4b3, 0x04 | BRF_GRA }, // 7
9830
9831 { "ss1u25.v10", 0x80000, 0x56840728, 0x05 | BRF_GRA }, // 8 Layer 2 tiles
9832
9833 { "ss1u26.v10", 0x80000, 0xd452336b, 0x06 | BRF_SND }, // 9 x1-010 Samples
9834 { "ss1u27.v10", 0x80000, 0x17fe921d, 0x06 | BRF_SND }, // 10
9835 };
9836
9837 STD_ROM_PICK(oisipuzl)
STD_ROM_FN(oisipuzl)9838 STD_ROM_FN(oisipuzl)
9839
9840 static INT32 oisipuzlInit()
9841 {
9842 oisipuzl_hack = 1; // 32 pixel offset for sprites???
9843 watchdog_enable = 1; // needs a reset before it will boot
9844
9845 DrvSetVideoOffsets(1, 1, -1, -1);
9846 DrvSetColorOffsets(0, 0x400, 0x200);
9847
9848 INT32 nRet = DrvInit(oisipuzl68kInit, 16000000, (2 << 8) | (1 << 0), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
9849
9850 if (nRet == 0)
9851 {
9852 memset (Drv68KROM, 0, 0x200000);
9853
9854 if (BurnLoadRom(Drv68KROM + 0x000000, 0, 1)) return 1;
9855 if (BurnLoadRom(Drv68KROM + 0x100000, 1, 1)) return 1;
9856
9857 for (INT32 i = 0; i < 0x400000; i++) DrvGfxROM0[i] ^= 0x0f; // invert
9858 }
9859
9860 return nRet;
9861 }
9862
9863 struct BurnDriver BurnDrvOisipuzl = {
9864 "oisipuzl", NULL, NULL, NULL, "1993",
9865 "Oishii Puzzle Ha Irimasenka\0", NULL, "Sunsoft / Atlus", "Seta",
9866 NULL, NULL, NULL, NULL,
9867 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_MINIGAMES, 0,
9868 NULL, oisipuzlRomInfo, oisipuzlRomName, NULL, NULL, NULL, NULL, OisipuzlInputInfo, OisipuzlDIPInfo,
9869 oisipuzlInit, DrvExit, DrvFrame, seta2layerFlippedDraw, DrvScan, &DrvRecalc, 0x600,
9870 320, 224, 4, 3
9871 };
9872
9873
9874 // Triple Fun
9875
9876 static struct BurnRomInfo triplfunRomDesc[] = {
9877 { "05.bin", 0x80000, 0x06eb3821, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9878 { "04.bin", 0x80000, 0x37a5c46e, 0x01 | BRF_PRG | BRF_ESS }, // 1
9879
9880 { "09.bin", 0x80000, 0x98cc8ca5, 0x0b | BRF_GRA }, // 2 Sprites
9881 { "08.bin", 0x80000, 0x63a8f10f, 0x0b | BRF_GRA }, // 3
9882 { "11.bin", 0x80000, 0x276ef724, 0x0b | BRF_GRA }, // 4
9883 { "10.bin", 0x80000, 0x20b0f282, 0x0b | BRF_GRA }, // 5
9884
9885 { "02.bin", 0x80000, 0x4c0d1068, 0x0c | BRF_GRA }, // 6 Layer 1 tiles
9886 { "03.bin", 0x80000, 0xdba94e18, 0x0c | BRF_GRA }, // 7
9887
9888 { "06.bin", 0x40000, 0x8944bb72, 0x0d | BRF_GRA }, // 8 Layer 2 tiles
9889 { "07.bin", 0x40000, 0x934a5d91, 0x0d | BRF_GRA }, // 9
9890
9891 { "01.bin", 0x40000, 0xc186a930, 0x06 | BRF_SND }, // 10 OKI M6295 Samples
9892 };
9893
9894 STD_ROM_PICK(triplfun)
STD_ROM_FN(triplfun)9895 STD_ROM_FN(triplfun)
9896
9897 static INT32 triplfunInit()
9898 {
9899 oisipuzl_hack = 1;
9900 DrvSetVideoOffsets(0, 0, -1, -1);
9901 DrvSetColorOffsets(0, 0x400, 0x200);
9902
9903 return DrvInit(triplfun68kInit, 16000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
9904 }
9905
9906 struct BurnDriver BurnDrvTriplfun = {
9907 "triplfun", "oisipuzl", NULL, NULL, "1993",
9908 "Triple Fun\0", NULL, "bootleg", "Seta",
9909 NULL, NULL, NULL, NULL,
9910 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_MINIGAMES, 0,
9911 NULL, triplfunRomInfo, triplfunRomName, NULL, NULL, NULL, NULL, OisipuzlInputInfo, OisipuzlDIPInfo,
9912 triplfunInit, DrvExit, DrvM6295Frame, seta2layerFlippedDraw, DrvScan, &DrvRecalc, 0x600,
9913 320, 224, 4, 3
9914 };
9915
9916
9917 // Pairs Love
9918
9919 static struct BurnRomInfo pairloveRomDesc[] = {
9920 { "ut2-001-001.1a", 0x10000, 0x083338b7, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9921 { "ut2-001-002.3a", 0x10000, 0x39d88aae, 0x01 | BRF_PRG | BRF_ESS }, // 1
9922
9923 { "ut2-001-004.5j", 0x80000, 0xfdc47b26, 0x03 | BRF_GRA }, // 2 Sprites
9924 { "ut2-001-005.5l", 0x80000, 0x076f94a2, 0x03 | BRF_GRA }, // 3
9925
9926 { "ut2-001-003.12a", 0x80000, 0x900219a9, 0x06 | BRF_SND }, // 4 x1-010 Samples
9927 };
9928
9929 STD_ROM_PICK(pairlove)
STD_ROM_FN(pairlove)9930 STD_ROM_FN(pairlove)
9931
9932 static INT32 pairloveInit()
9933 {
9934 DrvSetVideoOffsets(0, 0, 0, 0);
9935 DrvSetColorOffsets(0, 0, 0);
9936
9937 INT32 nRet = DrvInit(pairlove68kInit, 8000000, SET_IRQLINES(2, 1), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
9938
9939 if (nRet == 0) {
9940 memcpy (DrvSndROM + 0x80000, DrvSndROM, 0x80000);
9941 }
9942
9943 return nRet;
9944 }
9945
9946 struct BurnDriver BurnDrvPairlove = {
9947 "pairlove", NULL, NULL, NULL, "1991",
9948 "Pairs Love\0", NULL, "Athena", "Seta",
9949 NULL, NULL, NULL, NULL,
9950 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PUZZLE, 0,
9951 NULL, pairloveRomInfo, pairloveRomName, NULL, NULL, NULL, NULL, PairloveInputInfo, PairloveDIPInfo,
9952 pairloveInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9953 240, 384, 3, 4
9954 };
9955
9956
9957 // Orbs (10/7/94 prototype?)
9958
9959 static struct BurnRomInfo orbsRomDesc[] = {
9960 { "orbs.u10", 0x80000, 0x10f079c8, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9961 { "orbs.u9", 0x80000, 0xf269d16f, 0x01 | BRF_PRG | BRF_ESS }, // 1
9962
9963 { "orbs.u14", 0x80000, 0x1cc76541, 0x03 | BRF_GRA }, // 2 Sprites
9964 { "orbs.u13", 0x80000, 0x784bdc1a, 0x03 | BRF_GRA }, // 3
9965 { "orbs.u12", 0x80000, 0xb8c352c2, 0x03 | BRF_GRA }, // 4
9966 { "orbs.u11", 0x80000, 0x58cb38ba, 0x03 | BRF_GRA }, // 5
9967
9968 { "orbs.u15", 0x80000, 0xbc0e9fe3, 0x06 | BRF_SND }, // 6 x1-010 Samples
9969 { "orbs.u16", 0x80000, 0xaecd8373, 0x06 | BRF_SND }, // 7
9970 };
9971
9972 STD_ROM_PICK(orbs)
STD_ROM_FN(orbs)9973 STD_ROM_FN(orbs)
9974
9975 static INT32 orbsInit()
9976 {
9977 DrvSetVideoOffsets(0, 0, 0, 0);
9978 DrvSetColorOffsets(0, 0, 0);
9979
9980 return DrvInit(pairlove68kInit, 7159090, SET_IRQLINES(2, 1), NO_SPRITE_BUFFER, SET_GFX_DECODE(5, -1, -1));
9981 }
9982
9983 struct BurnDriver BurnDrvOrbs = {
9984 "orbs", NULL, NULL, NULL, "1994",
9985 "Orbs (10/7/94 prototype?)\0", NULL, "American Sammy", "Seta",
9986 NULL, NULL, NULL, NULL,
9987 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PUZZLE, 0,
9988 NULL, orbsRomInfo, orbsRomName, NULL, NULL, NULL, NULL, OrbsInputInfo, OrbsDIPInfo,
9989 orbsInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
9990 320, 240, 4, 3
9991 };
9992
9993
9994 // Kero Kero Keroppi's Let's Play Together (USA, Version 2.0)
9995
9996 static struct BurnRomInfo keroppiRomDesc[] = {
9997 { "keroppi jr. code =u10= v1.0.u10", 0x40000, 0x1fc2e895, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
9998 { "keroppi jr. code =u9= v1.0.u9", 0x40000, 0xe0599e7b, 0x01 | BRF_PRG | BRF_ESS }, // 1
9999
10000 { "keroppi jr. chr=u11= v1.0.u11", 0x80000, 0x74148c23, 0x03 | BRF_GRA }, // 2
10001 { "keroppi jr. chr=u12= v1.0.u12", 0x80000, 0x6f4dae98, 0x03 | BRF_GRA }, // 3
10002
10003 { "keroppi jr. snd =u15= v1.0.u15", 0x80000, 0xc98dacf0, 0x06 | BRF_SND }, // 4 x1-010 Samples
10004 { "keroppi jr. snd =u16= v1.0.u16", 0x80000, 0xd61e5a32, 0x06 | BRF_SND }, // 5
10005 };
10006
10007 STD_ROM_PICK(keroppi)
STD_ROM_FN(keroppi)10008 STD_ROM_FN(keroppi)
10009
10010 static INT32 keroppiInit()
10011 {
10012 DrvSetVideoOffsets(0, 0, 0, 0);
10013 DrvSetColorOffsets(0, 0, 0);
10014
10015 return DrvInit(pairlove68kInit, 7159090, SET_IRQLINES(2, 1), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
10016 }
10017
10018 struct BurnDriver BurnDrvKeroppi = {
10019 "keroppi", NULL, NULL, NULL, "1995",
10020 "Kero Kero Keroppi's Let's Play Together (USA, Version 2.0)\0", NULL, "American Sammy", "Seta",
10021 NULL, NULL, NULL, NULL,
10022 BDF_GAME_WORKING, 1, HARDWARE_SETA1, GBF_MINIGAMES, 0,
10023 NULL, keroppiRomInfo, keroppiRomName, NULL, NULL, NULL, NULL, KeroppiInputInfo, KeroppiDIPInfo,
10024 keroppiInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10025 320, 240, 4, 3
10026 };
10027
10028 // Kero Kero Keroppi no Issyoni Asobou (Japan)
10029
10030 static struct BurnRomInfo keroppijRomDesc[] = {
10031 { "ft-001-001.u10", 0x80000, 0x37861e7d, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10032 { "ft-001-002.u9", 0x80000, 0xf531d4ef, 0x01 | BRF_PRG | BRF_ESS }, // 1
10033
10034 { "ft-001-003.u14", 0x80000, 0x62fb22fb, 0x03 | BRF_GRA }, // 2 Sprites
10035 { "ft-001-004.u13", 0x80000, 0x69908c98, 0x03 | BRF_GRA }, // 3
10036 { "ft-001-005.u12", 0x80000, 0xde6432a8, 0x03 | BRF_GRA }, // 4
10037 { "ft-001-006.u11", 0x80000, 0x9c500eae, 0x03 | BRF_GRA }, // 5
10038
10039 { "ft-001-007.u15", 0x80000, 0xc98dacf0, 0x06 | BRF_SND }, // 6 x1-010 Samples
10040 { "ft-001-008.u16", 0x80000, 0xb9c4b637, 0x06 | BRF_SND }, // 7
10041 };
10042
10043 STD_ROM_PICK(keroppij)
10044 STD_ROM_FN(keroppij)
10045
10046 struct BurnDriver BurnDrvKeroppij = {
10047 "keroppij", "keroppi", NULL, NULL, "1993",
10048 "Kero Kero Keroppi no Issyoni Asobou (Japan)\0", NULL, "Sammy Industries", "Seta",
10049 NULL, NULL, NULL, NULL,
10050 BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_SETA1, GBF_MINIGAMES, 0,
10051 NULL, keroppijRomInfo, keroppijRomName, NULL, NULL, NULL, NULL, KeroppiInputInfo, KeroppiDIPInfo,
10052 orbsInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10053 320, 240, 4, 3
10054 };
10055
10056
10057 // J. J. Squawkers
10058
10059 static struct BurnRomInfo jjsquawkRomDesc[] = {
10060 { "fe2002001.u3", 0x80000, 0x7b9af960, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10061 { "fe2002002.u4", 0x80000, 0x47dd71a3, 0x01 | BRF_PRG | BRF_ESS }, // 1
10062
10063 { "fe2001009", 0x80000, 0x27441cd3, 0x03 | BRF_GRA }, // 2 Sprites
10064 { "fe2001010", 0x80000, 0xca2b42c4, 0x03 | BRF_GRA }, // 3
10065 { "fe2001007", 0x80000, 0x62c45658, 0x03 | BRF_GRA }, // 4
10066 { "fe2001008", 0x80000, 0x2690c57b, 0x03 | BRF_GRA }, // 5
10067
10068 { "fe2001011", 0x80000, 0x98b9f4b4, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
10069 { "fe2001012", 0x80000, 0xd4aa916c, 0x04 | BRF_GRA }, // 7
10070 { "fe2001003", 0x80000, 0xa5a35caf, 0x1c | BRF_GRA }, // 8
10071
10072 { "fe2001014", 0x80000, 0x274bbb48, 0x05 | BRF_GRA }, // 9 Layer 2 tiles
10073 { "fe2001013", 0x80000, 0x51e29871, 0x05 | BRF_GRA }, // 10
10074 { "fe2001004", 0x80000, 0xa235488e, 0x1d | BRF_GRA }, // 11
10075
10076 { "fe2001005.u69", 0x80000, 0xd99f2879, 0x06 | BRF_SND }, // 12 x1-010 Samples
10077 { "fe2001006.u70", 0x80000, 0x9df1e478, 0x06 | BRF_SND }, // 13
10078
10079 { "m-009.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 14 plds
10080 { "m-010.u116", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 15
10081 { "m2-011.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 16
10082 { "m-012.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 17
10083 { "m-013.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 18
10084 { "m-014.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 19
10085 };
10086
10087 STD_ROM_PICK(jjsquawk)
STD_ROM_FN(jjsquawk)10088 STD_ROM_FN(jjsquawk)
10089
10090 static INT32 jjsquawkInit()
10091 {
10092 DrvSetVideoOffsets(1, 1, -1, -1);
10093 DrvSetColorOffsets(0, 0x200, 0xa00);
10094
10095 INT32 nRet = DrvInit(wrofaero68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
10096
10097 if (nRet == 0) {
10098 jjsquawkSetColorTable();
10099
10100 memcpy (Drv68KROM + 0x100000, Drv68KROM + 0x080000, 0x080000);
10101 memset (Drv68KROM + 0x080000, 0, 0x080000);
10102 }
10103
10104 return nRet;
10105 }
10106
10107 struct BurnDriver BurnDrvJjsquawk = {
10108 "jjsquawk", NULL, NULL, NULL, "1993",
10109 "J. J. Squawkers\0", NULL, "Athena / Able", "Seta",
10110 NULL, NULL, NULL, NULL,
10111 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PLATFORM, 0,
10112 NULL, jjsquawkRomInfo, jjsquawkRomName, NULL, NULL, NULL, NULL, JjsquawkInputInfo, JjsquawkDIPInfo,
10113 jjsquawkInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
10114 384, 240, 4, 3
10115 };
10116
10117
10118 // J. J. Squawkers (older)
10119 /* Official 93111A PCB missing version sticker */
10120
10121 static struct BurnRomInfo jjsquawkoRomDesc[] = {
10122 { "fe2001001.u3", 0x80000, 0x921c9762, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10123 { "fe2001002.u4", 0x80000, 0x0227a2be, 0x01 | BRF_PRG | BRF_ESS }, // 1
10124
10125 { "fe2001009", 0x80000, 0x27441cd3, 0x03 | BRF_GRA }, // 2 Sprites
10126 { "fe2001010", 0x80000, 0xca2b42c4, 0x03 | BRF_GRA }, // 3
10127 { "fe2001007", 0x80000, 0x62c45658, 0x03 | BRF_GRA }, // 4
10128 { "fe2001008", 0x80000, 0x2690c57b, 0x03 | BRF_GRA }, // 5
10129
10130 { "fe2001011", 0x80000, 0x98b9f4b4, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
10131 { "fe2001012", 0x80000, 0xd4aa916c, 0x04 | BRF_GRA }, // 7
10132 { "fe2001003", 0x80000, 0xa5a35caf, 0x1c | BRF_GRA }, // 8
10133
10134 { "fe2001014", 0x80000, 0x274bbb48, 0x05 | BRF_GRA }, // 9 Layer 2 tiles
10135 { "fe2001013", 0x80000, 0x51e29871, 0x05 | BRF_GRA }, // 10
10136 { "fe2001004", 0x80000, 0xa235488e, 0x1d | BRF_GRA }, // 11
10137
10138 { "fe2001005.u69", 0x80000, 0xd99f2879, 0x06 | BRF_SND }, // 12 x1-010 Samples
10139 { "fe2001006.u70", 0x80000, 0x9df1e478, 0x06 | BRF_SND }, // 13
10140
10141 { "m-009.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 14 plds
10142 { "m-010.u116", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 15
10143 { "m2-011.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 16
10144 { "m-012.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 17
10145 { "m-013.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 18
10146 { "m-014.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 19
10147 };
10148
10149 STD_ROM_PICK(jjsquawko)
10150 STD_ROM_FN(jjsquawko)
10151
10152 struct BurnDriver BurnDrvJjsquawko = {
10153 "jjsquawko", "jjsquawk", NULL, NULL, "1993",
10154 "J. J. Squawkers (older)\0", NULL, "Athena / Able", "Seta",
10155 NULL, NULL, NULL, NULL,
10156 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PLATFORM, 0,
10157 NULL, jjsquawkoRomInfo, jjsquawkoRomName, NULL, NULL, NULL, NULL, JjsquawkInputInfo, JjsquawkDIPInfo,
10158 jjsquawkInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
10159 384, 240, 4, 3
10160 };
10161
10162
10163 // J. J. Squawkers (bootleg)
10164
10165 static struct BurnRomInfo jjsquawkbRomDesc[] = {
10166 { "3", 0x080000, 0xafd5bd07, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10167 { "2", 0x080000, 0x740a7366, 0x01 | BRF_PRG | BRF_ESS }, // 1
10168
10169 { "4.bin", 0x200000, 0x969502f7, 0x03 | BRF_GRA }, // 2 Sprites
10170 { "2.bin", 0x200000, 0x765253d1, 0x03 | BRF_GRA }, // 3
10171
10172 { "3.bin", 0x200000, 0xb1e3a4bb, 0x04 | BRF_GRA }, // 4 Layer 1 tiles
10173 { "1.bin", 0x200000, 0xa5d37cf7, 0x04 | BRF_GRA }, // 5
10174
10175 { "1", 0x100000, 0x181a55b8, 0x06 | BRF_SND }, // 6 x1-010 Samples
10176
10177 { "fj-111.u50", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7 plds
10178 { "fj-012.u51", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8
10179 { "fj-013.u52", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
10180 { "fj-014.u53", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
10181 { "fj-015.u54", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
10182 };
10183
10184 STD_ROM_PICK(jjsquawkb)
STD_ROM_FN(jjsquawkb)10185 STD_ROM_FN(jjsquawkb)
10186
10187 static INT32 jjsquawkbInit()
10188 {
10189 DrvSetVideoOffsets(1, 1, -1, -1);
10190 DrvSetColorOffsets(0, 0x200, 0xa00);
10191
10192 INT32 nRet = DrvInit(jjsquawkb68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 3));
10193
10194 if (nRet == 0) {
10195 jjsquawkSetColorTable();
10196 }
10197
10198 return nRet;
10199 }
10200
10201 struct BurnDriver BurnDrvJjsquawkb = {
10202 "jjsquawkb", "jjsquawk", NULL, NULL, "1999",
10203 "J. J. Squawkers (bootleg)\0", NULL, "bootleg", "Seta",
10204 NULL, NULL, NULL, NULL,
10205 BDF_GAME_WORKING | BDF_CLONE | BDF_BOOTLEG | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PLATFORM, 0,
10206 NULL, jjsquawkbRomInfo, jjsquawkbRomName, NULL, NULL, NULL, NULL, JjsquawkInputInfo, JjsquawkDIPInfo,
10207 jjsquawkbInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
10208 384, 240, 4, 3
10209 };
10210
10211
10212 // J. J. Squawkers (bootleg, Blandia conversion)
10213 /* PCB was P0-078A, which was a Blandia board converted to JJ Squawkers.
10214 No labels on any of the ROMs. Apparently based on jjsquawko set. */
10215
10216 static struct BurnRomInfo jjsquawkb2RomDesc[] = {
10217 { "u3.3a", 0x080000, 0xf94c913b, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10218 { "u4.4a", 0x080000, 0x0227a2be, 0x01 | BRF_PRG | BRF_ESS }, // 1
10219
10220 { "u64.3l", 0x100000, 0x11d8713a, 0x03 | BRF_GRA }, // 2 Sprites // jj-rom9 + jj-rom10
10221 { "u63.2l", 0x100000, 0x7a385ef0, 0x03 | BRF_GRA }, // 3 // jj-rom7 + jj-rom8
10222
10223 { "u66.5l", 0x100000, 0xbbaf40c5, 0x04 | BRF_GRA }, // 4 Layer 1 tiles // jj-rom11 + jj-rom12
10224 { "u65.4l", 0x080000, 0xa5a35caf, 0x1c | BRF_GRA }, // 5 // jj-rom3.040
10225
10226 { "u68.7l", 0x100000, 0xae9ae01f, 0x05 | BRF_GRA }, // 9 Layer 2 tiles // jj-rom14 + jj-rom13
10227 { "u67.6l", 0x080000, 0xa235488e, 0x1d | BRF_GRA }, // 10 // jj-rom4.040
10228
10229 { "u70.10l", 0x100000, 0x181a55b8, 0x06 | BRF_SND }, // 11 x1-010 Samples // jj-rom5.040 + jj-rom6.040
10230 };
10231
10232 STD_ROM_PICK(jjsquawkb2)
10233 STD_ROM_FN(jjsquawkb2)
10234
10235 struct BurnDriver BurnDrvJjsquawkb2 = {
10236 "jjsquawkb2", "jjsquawk", NULL, NULL, "1999",
10237 "J. J. Squawkers (bootleg, Blandia conversion)\0", NULL, "bootleg", "Seta",
10238 NULL, NULL, NULL, NULL,
10239 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PLATFORM, 0,
10240 NULL, jjsquawkb2RomInfo, jjsquawkb2RomName, NULL, NULL, NULL, NULL, JjsquawkInputInfo, JjsquawkDIPInfo,
10241 jjsquawkInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
10242 384, 240, 4, 3
10243 };
10244
10245
10246 // Extreme Downhill (v1.5)
10247
10248 static struct BurnRomInfo extdwnhlRomDesc[] = {
10249 { "fw001002.201", 0x080000, 0x24d21924, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10250 { "fw001001.200", 0x080000, 0xfb12a28b, 0x01 | BRF_PRG | BRF_ESS }, // 1
10251
10252 { "fw001003.202", 0x200000, 0xac9b31d5, 0x03 | BRF_GRA }, // 2 Sprites
10253
10254 { "fw001004.206", 0x200000, 0x0dcb1d72, 0x04 | BRF_GRA }, // 3 Layer 1 tiles
10255 { "fw001005.205", 0x100000, 0x5c33b2f1, 0x1c | BRF_GRA }, // 4
10256
10257 { "fw001006.152", 0x200000, 0xd00e8ddd, 0x05 | BRF_GRA }, // 5 Layer 2 tiles
10258
10259 { "fw001007.026", 0x100000, 0x16d84d7a, 0x06 | BRF_SND }, // 6 x1-010 Samples
10260
10261 { "fw-001.u50", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7 plds
10262 { "fw-002.u51", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8
10263 { "fw-003.u52", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
10264 { "fw-004.u53", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
10265 { "fw-005.u54", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11
10266 };
10267
10268 STD_ROM_PICK(extdwnhl)
STD_ROM_FN(extdwnhl)10269 STD_ROM_FN(extdwnhl)
10270
10271 static INT32 extdwnhlInit()
10272 {
10273 watchdog_enable = 1;
10274
10275 DrvSetVideoOffsets(0, 0, -2, -2);
10276 DrvSetColorOffsets(0, 0x400, 0x200);
10277
10278 INT32 nRet = DrvInit(extdwnhl68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 3, 2));
10279
10280 if (nRet == 0) {
10281 zingzapSetColorTable();
10282 if (DrvGfxTransMask[2] == NULL) {
10283 DrvGfxTransMask[2] = DrvGfxTransMask[1]; // sokonuke fix
10284 }
10285 }
10286
10287 return nRet;
10288 }
10289
10290 struct BurnDriver BurnDrvExtdwnhl = {
10291 "extdwnhl", NULL, NULL, NULL, "1995",
10292 "Extreme Downhill (v1.5)\0", NULL, "Sammy Industries Japan", "Seta",
10293 NULL, NULL, NULL, NULL,
10294 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_RACING, 0,
10295 NULL, extdwnhlRomInfo, extdwnhlRomName, NULL, NULL, NULL, NULL, ExtdwnhlInputInfo, ExtdwnhlDIPInfo,
10296 extdwnhlInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
10297 320, 240, 4, 3
10298 };
10299
10300
10301 // Sokonuke Taisen Game (Japan)
10302
10303 static struct BurnRomInfo sokonukeRomDesc[] = {
10304 { "001-001.bin", 0x080000, 0x9d0aa3ca, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10305 { "001-002.bin", 0x080000, 0x96f2ef5f, 0x01 | BRF_PRG | BRF_ESS }, // 1
10306
10307 { "001-003.bin", 0x200000, 0xab9ba897, 0x03 | BRF_GRA }, // 2 Sprites
10308
10309 { "001-004.bin", 0x100000, 0x34ca3540, 0x04 | BRF_GRA }, // 3 Layer 1 tiles
10310 { "001-005.bin", 0x080000, 0x2b95d68d, 0x1c | BRF_GRA }, // 4
10311
10312 { "001-006.bin", 0x100000, 0xecfac767, 0x06 | BRF_SND }, // 5 x1-010 Samples
10313
10314 { "fw-001.u50", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 6 plds
10315 { "fw-002.u51", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7
10316 { "fw-003.u52", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 8
10317 { "fw-004.u53", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 9
10318 { "fw-005.u54", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 10
10319 };
10320
10321 STD_ROM_PICK(sokonuke)
10322 STD_ROM_FN(sokonuke)
10323
10324 struct BurnDriver BurnDrvSokonuke = {
10325 "sokonuke", NULL, NULL, NULL, "1995",
10326 "Sokonuke Taisen Game (Japan)\0", NULL, "Sammy Industries", "Seta",
10327 NULL, NULL, NULL, NULL,
10328 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_PLATFORM, 0,
10329 NULL, sokonukeRomInfo, sokonukeRomName, NULL, NULL, NULL, NULL, SokonukeInputInfo, SokonukeDIPInfo,
10330 extdwnhlInit, DrvExit, DrvFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
10331 320, 240, 4, 3
10332 };
10333
10334
10335 // Krazy Bowl
10336
10337 static struct BurnRomInfo krzybowlRomDesc[] = {
10338 { "fv001.002", 0x40000, 0x8c03c75f, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10339 { "fv001.001", 0x40000, 0xf0630beb, 0x01 | BRF_PRG | BRF_ESS }, // 1
10340
10341 { "fv001.003", 0x80000, 0x7de22749, 0x03 | BRF_GRA }, // 2 Sprites
10342 { "fv001.004", 0x80000, 0xc7d2fe32, 0x03 | BRF_GRA }, // 3
10343
10344 { "fv001.005", 0x80000, 0x5e206062, 0x06 | BRF_SND }, // 4 x1-010 Samples
10345 { "fv001.006", 0x80000, 0x572a15e7, 0x06 | BRF_SND }, // 5
10346
10347 { "fv-007.u22", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 6 plds
10348 { "fv-008.u23", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 7
10349 };
10350
10351 STD_ROM_PICK(krzybowl)
STD_ROM_FN(krzybowl)10352 STD_ROM_FN(krzybowl)
10353
10354 static INT32 krzybowlInit()
10355 {
10356 DrvSetVideoOffsets(0, 0, 0, 0);
10357 DrvSetColorOffsets(0, 0, 0);
10358 trackball_mode = 1;
10359
10360 INT32 rc = DrvInit(krzybowl68kInit, 16000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
10361
10362 VideoOffsets[2][0] = 8;
10363
10364 return rc;
10365 }
10366
10367 struct BurnDriver BurnDrvKrzybowl = {
10368 "krzybowl", NULL, NULL, NULL, "1994",
10369 "Krazy Bowl\0", NULL, "American Sammy", "Seta",
10370 NULL, NULL, NULL, NULL,
10371 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_SPORTSMISC, 0,
10372 NULL, krzybowlRomInfo, krzybowlRomName, NULL, NULL, NULL, NULL, KrzybowlInputInfo, KrzybowlDIPInfo,
10373 krzybowlInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10374 232, 320, 3, 4
10375 };
10376
10377
10378 // Wiggie Waggie
10379 // hack of Thunder & Lightning
10380
10381 static struct BurnRomInfo wiggieRomDesc[] = {
10382 { "wiggie.e19", 0x10000, 0x24b58f16, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10383 { "wiggie.e21", 0x10000, 0x83ba6edb, 0x01 | BRF_PRG | BRF_ESS }, // 1
10384
10385 { "wiggie.a5", 0x10000, 0x8078d77b, 0x02 | BRF_PRG | BRF_ESS }, // 2 Z80 Code
10386
10387 { "wiggie.j16", 0x20000, 0x4fb40b8a, 0x03 | BRF_GRA }, // 3 Sprites
10388 { "wiggie.j18", 0x20000, 0xebc418e9, 0x03 | BRF_GRA }, // 4
10389 { "wiggie.j20", 0x20000, 0xc073501b, 0x03 | BRF_GRA }, // 5
10390 { "wiggie.j21", 0x20000, 0x22f6fa39, 0x03 | BRF_GRA }, // 6
10391
10392 { "wiggie.d1", 0x40000, 0x27fbe12a, 0x06 | BRF_SND }, // 7 OKI M6295 Samples
10393 };
10394
10395 STD_ROM_PICK(wiggie)
STD_ROM_FN(wiggie)10396 STD_ROM_FN(wiggie)
10397
10398 static INT32 wiggieInit()
10399 {
10400 DrvSetVideoOffsets(0, 0, 0, 0);
10401 DrvSetColorOffsets(0, 0, 0);
10402
10403 return DrvInit(wiggie68kInit, 16000000 / 2, SET_IRQLINES(2, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(6, -1, -1));
10404 }
10405
10406 struct BurnDriver BurnDrvWiggie = {
10407 "wiggie", NULL, NULL, NULL, "1994",
10408 "Wiggie Waggie\0", NULL, "Promat", "Seta",
10409 NULL, NULL, NULL, NULL,
10410 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_BREAKOUT, 0,
10411 NULL, wiggieRomInfo, wiggieRomName, NULL, NULL, NULL, NULL, ThunderlInputInfo, ThunderlDIPInfo,
10412 wiggieInit, DrvExit, DrvZ80M6295Frame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10413 240, 384, 3, 4
10414 };
10415
10416
10417 // Super Bar
10418 // hack of Thunder & Lightning
10419
10420 static struct BurnRomInfo superbarRomDesc[] = {
10421 { "promat_512-1.e19", 0x10000, 0xcc7f9e87, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10422 { "promat_512-2.e21", 0x10000, 0x5e8c7231, 0x01 | BRF_PRG | BRF_ESS }, // 1
10423
10424 { "promat.a5", 0x10000, 0x8078d77b, 0x02 | BRF_PRG | BRF_ESS }, // 2 Z80 Code
10425
10426 { "promat_1m-4.j16", 0x20000, 0x43dbc99f, 0x03 | BRF_GRA }, // 3 Sprites
10427 { "promat_1m-5.j18", 0x20000, 0xc09344b0, 0x03 | BRF_GRA }, // 4
10428 { "promat_1m-6.j20", 0x20000, 0x7d83f8ba, 0x03 | BRF_GRA }, // 5
10429 { "promat_1m-7.j21", 0x20000, 0x734df92a, 0x03 | BRF_GRA }, // 6
10430
10431 { "promat_2m-1.d1", 0x40000, 0x27fbe12a, 0x06 | BRF_SND }, // 7 OKI M6295 Samples
10432 };
10433
10434 STD_ROM_PICK(superbar)
STD_ROM_FN(superbar)10435 STD_ROM_FN(superbar)
10436
10437 static INT32 superbarInit()
10438 {
10439 DrvSetVideoOffsets(0, 0, 0, 0);
10440 DrvSetColorOffsets(0, 0, 0);
10441
10442 return DrvInit(wiggie68kInit, 8000000, SET_IRQLINES(2, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(7, -1, -1));
10443 }
10444
10445 struct BurnDriver BurnDrvSuperbar = {
10446 "superbar", "wiggie", NULL, NULL, "1994",
10447 "Super Bar\0", NULL, "Promat", "Seta",
10448 NULL, NULL, NULL, NULL,
10449 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_BREAKOUT, 0,
10450 NULL, superbarRomInfo, superbarRomName, NULL, NULL, NULL, NULL, ThunderlInputInfo, ThunderlDIPInfo,
10451 superbarInit, DrvExit, DrvZ80M6295Frame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10452 240, 384, 3, 4
10453 };
10454
10455
10456 // Ultra Toukon Densetsu (Japan)
10457
10458 static struct BurnRomInfo utoukondRomDesc[] = {
10459 { "93uta010.3", 0x080000, 0xc486ef5e, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10460 { "93uta011.4", 0x080000, 0x978978f7, 0x01 | BRF_PRG | BRF_ESS }, // 1
10461
10462 { "93uta009.112", 0x010000, 0x67f18483, 0x02 | BRF_PRG | BRF_ESS }, // 2 Z80 Code
10463
10464 { "93uta04.64", 0x100000, 0x9cba0538, 0x03 | BRF_GRA }, // 3 Sprites
10465 { "93uta02.201", 0x100000, 0x884fedfa, 0x03 | BRF_GRA }, // 4
10466 { "93uta03.63", 0x100000, 0x818484a5, 0x03 | BRF_GRA }, // 5
10467 { "93uta01.200", 0x100000, 0x364de841, 0x03 | BRF_GRA }, // 6
10468
10469 { "93uta05.66", 0x100000, 0x5e640bfb, 0x04 | BRF_GRA }, // 7 Layer 1 tiles
10470
10471 { "93uta07.68", 0x100000, 0x67bdd036, 0x05 | BRF_GRA }, // 8 Layer 2 tiles
10472 { "93uta06.67", 0x100000, 0x294c26e4, 0x05 | BRF_GRA }, // 9
10473
10474 { "93uta08.69", 0x100000, 0x3d50bbcd, 0x06 | BRF_SND }, // 10 x1-010 Samples
10475
10476 { "93ut-a12.u206", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 11 plds
10477 { "93ut-a13.u14", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 12
10478 { "93ut-a14.u35", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 13
10479 { "93ut-a15.u36", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 14
10480 { "93ut-a16.u110", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 15
10481 { "93ut-a17.u76", 0x000104, 0x00000000, 0x00 | BRF_OPT | BRF_NODUMP }, // 16
10482 };
10483
10484 STD_ROM_PICK(utoukond)
STD_ROM_FN(utoukond)10485 STD_ROM_FN(utoukond)
10486
10487 static INT32 utoukondInit()
10488 {
10489 DrvSetVideoOffsets(0, 0, -2, 0);
10490 DrvSetColorOffsets(0, 0x400, 0x200);
10491
10492 return DrvInit(utoukond68kInit, 16000000, SET_IRQLINES(2, 1), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 2, 2));
10493 }
10494
10495 struct BurnDriver BurnDrvUtoukond = {
10496 "utoukond", NULL, NULL, NULL, "1993",
10497 "Ultra Toukon Densetsu (Japan)\0", NULL, "Banpresto / Tsuburaya Productions", "Seta",
10498 NULL, NULL, NULL, NULL,
10499 BDF_GAME_WORKING, 2, HARDWARE_SETA1, GBF_VSFIGHT, 0,
10500 NULL, utoukondRomInfo, utoukondRomName, NULL, NULL, NULL, NULL, UtoukondInputInfo, UtoukondDIPInfo,
10501 utoukondInit, DrvExit, Drv68kZ80YM3438Frame, seta2layerDraw, DrvScan, &DrvRecalc, 0x600,
10502 384, 224, 4, 3
10503 };
10504
10505
10506 // DownTown / Mokugeki (Set 1)
10507
10508 static struct BurnRomInfo downtownRomDesc[] = {
10509 { "ud2-001-000.3c", 0x40000, 0xf1965260, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10510 { "ud2-001-003.11c", 0x40000, 0xe7d5fa5f, 0x01 | BRF_PRG | BRF_ESS }, // 1
10511 { "ud2001002.9b", 0x10000, 0xa300e3ac, 0x01 | BRF_PRG | BRF_ESS }, // 2
10512 { "ud2001001.8b", 0x10000, 0xd2918094, 0x01 | BRF_PRG | BRF_ESS }, // 3
10513
10514 { "ud2-002-004.17c", 0x40000, 0xbbd538b1, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10515
10516 { "ud2-001-005-t01.2n", 0x80000, 0x77e6d249, 0x0b | BRF_GRA }, // 5 Sprites
10517 { "ud2-001-006-t02.3n", 0x80000, 0x6e381bf2, 0x0b | BRF_GRA }, // 6
10518 { "ud2-001-007-t03.5n", 0x80000, 0x737b4971, 0x0b | BRF_GRA }, // 7
10519 { "ud2-001-008-t04.6n", 0x80000, 0x99b9d757, 0x0b | BRF_GRA }, // 8
10520
10521 { "ud2-001-009-t05.8n", 0x80000, 0xaee6c581, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
10522 { "ud2-001-010-t06.9n", 0x80000, 0x3d399d54, 0x04 | BRF_GRA }, // 10
10523
10524 { "ud2-001-011-t07.14n", 0x80000, 0x9c9ff69f, 0x06 | BRF_SND }, // 11 x1-010 Samples
10525 };
10526
10527 STD_ROM_PICK(downtown)
STD_ROM_FN(downtown)10528 STD_ROM_FN(downtown)
10529
10530 static INT32 downtownInit()
10531 {
10532 refresh_rate = 5742; // 57.42 hz
10533 DrvSetVideoOffsets(0, 0, -1, 0);
10534 DrvSetColorOffsets(0, 0, 0);
10535
10536 INT32 nRet = DrvInit(downtown68kInit, 8000000, SET_IRQLINES(1, 2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
10537
10538 return nRet;
10539 }
10540
10541 struct BurnDriver BurnDrvDowntown = {
10542 "downtown", NULL, NULL, NULL, "1989",
10543 "DownTown / Mokugeki (Set 1)\0", NULL, "Seta", "Seta",
10544 NULL, NULL, NULL, NULL,
10545 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_SCRFIGHT, 0,
10546 NULL, downtownRomInfo, downtownRomName, NULL, NULL, NULL, NULL, DowntownInputInfo, DowntownDIPInfo,
10547 downtownInit, DrvExit, DrvDowntownFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10548 224, 384, 3, 4
10549 };
10550
10551
10552 // DownTown / Mokugeki (Set 2)
10553
10554 static struct BurnRomInfo downtown2RomDesc[] = {
10555 { "ud2-001-000.3c", 0x40000, 0xf1965260, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10556 { "ud2-001-003.11c", 0x40000, 0xe7d5fa5f, 0x01 | BRF_PRG | BRF_ESS }, // 1
10557 { "ud2000002.9b", 0x10000, 0xca976b24, 0x01 | BRF_PRG | BRF_ESS }, // 2
10558 { "ud2000001.8b", 0x10000, 0x1708aebd, 0x01 | BRF_PRG | BRF_ESS }, // 3
10559
10560 { "ud2-002-004.17c", 0x40000, 0xbbd538b1, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10561
10562 { "ud2-001-005-t01.2n", 0x80000, 0x77e6d249, 0x0b | BRF_GRA }, // 5 Sprites
10563 { "ud2-001-006-t02.3n", 0x80000, 0x6e381bf2, 0x0b | BRF_GRA }, // 6
10564 { "ud2-001-007-t03.5n", 0x80000, 0x737b4971, 0x0b | BRF_GRA }, // 7
10565 { "ud2-001-008-t04.6n", 0x80000, 0x99b9d757, 0x0b | BRF_GRA }, // 8
10566
10567 { "ud2-001-009-t05.8n", 0x80000, 0xaee6c581, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
10568 { "ud2-001-010-t06.9n", 0x80000, 0x3d399d54, 0x04 | BRF_GRA }, // 10
10569
10570 { "ud2-001-011-t07.14n", 0x80000, 0x9c9ff69f, 0x06 | BRF_SND }, // 11 x1-010 Samples
10571 };
10572
10573 STD_ROM_PICK(downtown2)
10574 STD_ROM_FN(downtown2)
10575
10576 struct BurnDriver BurnDrvDowntown2 = {
10577 "downtown2", "downtown", NULL, NULL, "1989",
10578 "DownTown / Mokugeki (Set 2)\0", NULL, "Seta", "Seta",
10579 NULL, NULL, NULL, NULL,
10580 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_SCRFIGHT, 0,
10581 NULL, downtown2RomInfo, downtown2RomName, NULL, NULL, NULL, NULL, DowntownInputInfo, DowntownDIPInfo,
10582 downtownInit, DrvExit, DrvDowntownFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10583 224, 384, 3, 4
10584 };
10585
10586
10587 // DownTown / Mokugeki (Joystick Hack)
10588
10589 static struct BurnRomInfo downtownjRomDesc[] = {
10590 { "ud2-001-000.3c", 0x40000, 0xf1965260, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10591 { "ud2-001-003.11c", 0x40000, 0xe7d5fa5f, 0x01 | BRF_PRG | BRF_ESS }, // 1
10592 { "u37.9b", 0x10000, 0x73047657, 0x01 | BRF_PRG | BRF_ESS }, // 2
10593 { "u31.8b", 0x10000, 0x6a050240, 0x01 | BRF_PRG | BRF_ESS }, // 3
10594
10595 { "ud2-002-004.17c", 0x40000, 0xbbd538b1, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10596
10597 { "ud2-001-005-t01.2n", 0x80000, 0x77e6d249, 0x0b | BRF_GRA }, // 5 Sprites
10598 { "ud2-001-006-t02.3n", 0x80000, 0x6e381bf2, 0x0b | BRF_GRA }, // 6
10599 { "ud2-001-007-t03.5n", 0x80000, 0x737b4971, 0x0b | BRF_GRA }, // 7
10600 { "ud2-001-008-t04.6n", 0x80000, 0x99b9d757, 0x0b | BRF_GRA }, // 8
10601
10602 { "ud2-001-009-t05.8n", 0x80000, 0xaee6c581, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
10603 { "ud2-001-010-t06.9n", 0x80000, 0x3d399d54, 0x04 | BRF_GRA }, // 10
10604
10605 { "ud2-001-011-t07.14n", 0x80000, 0x9c9ff69f, 0x06 | BRF_SND }, // 11 x1-010 Samples
10606 };
10607
10608 STD_ROM_PICK(downtownj)
10609 STD_ROM_FN(downtownj)
10610
10611 struct BurnDriver BurnDrvDowntownj = {
10612 "downtownj", "downtown", NULL, NULL, "1989",
10613 "DownTown / Mokugeki (Joystick Hack)\0", NULL, "Seta", "Seta",
10614 NULL, NULL, NULL, NULL,
10615 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_SCRFIGHT, 0,
10616 NULL, downtownjRomInfo, downtownjRomName, NULL, NULL, NULL, NULL, DowntownInputInfo, DowntownDIPInfo,
10617 downtownInit, DrvExit, DrvDowntownFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10618 224, 384, 3, 4
10619 };
10620
10621
10622 // DownTown / Mokugeki (prototype)
10623
10624 static struct BurnRomInfo downtownpRomDesc[] = {
10625 { "ud2-001-000.3c", 0x40000, 0xf1965260, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10626 { "ud2-001-003.11c", 0x40000, 0xe7d5fa5f, 0x01 | BRF_PRG | BRF_ESS }, // 1
10627 { "ud2_even_v061.9b", 0x10000, 0x251d6552, 0x01 | BRF_PRG | BRF_ESS }, // 2
10628 { "ud2_odd_v061.8b", 0x10000, 0x6394a7c0, 0x01 | BRF_PRG | BRF_ESS }, // 3
10629
10630 { "ud2-002-004.17c", 0x40000, 0xbbd538b1, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10631
10632 { "ud2-001-005-t01.2n", 0x80000, 0x77e6d249, 0x0b | BRF_GRA }, // 5 Sprites
10633 { "ud2-001-006-t02.3n", 0x80000, 0x6e381bf2, 0x0b | BRF_GRA }, // 6
10634 { "ud2-001-007-t03.5n", 0x80000, 0x737b4971, 0x0b | BRF_GRA }, // 7
10635 { "ud2-001-008-t04.6n", 0x80000, 0x99b9d757, 0x0b | BRF_GRA }, // 8
10636
10637 { "ud2-001-009-t05.8n", 0x80000, 0xaee6c581, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
10638 { "ud2-001-010-t06.9n", 0x80000, 0x3d399d54, 0x04 | BRF_GRA }, // 10
10639
10640 { "ud2-001-011-t07.14n", 0x80000, 0x9c9ff69f, 0x06 | BRF_SND }, // 11 x1-010 Samples
10641 };
10642
10643 STD_ROM_PICK(downtownp)
10644 STD_ROM_FN(downtownp)
10645
10646 struct BurnDriver BurnDrvDowntownp = {
10647 "downtownp", "downtown", NULL, NULL, "1989",
10648 "DownTown / Mokugeki (prototype)\0", NULL, "Seta", "Seta",
10649 NULL, NULL, NULL, NULL,
10650 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_SCRFIGHT, 0,
10651 NULL, downtownpRomInfo, downtownpRomName, NULL, NULL, NULL, NULL, DowntownInputInfo, DowntownDIPInfo,
10652 downtownInit, DrvExit, DrvDowntownFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10653 224, 384, 3, 4
10654 };
10655
10656
10657 // Thundercade / Twin Formation
10658
10659 static struct BurnRomInfo tndrcadeRomDesc[] = {
10660 { "ua0-4.u19", 0x20000, 0x73bd63eb, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10661 { "ua0-2.u17", 0x20000, 0xe96194b1, 0x01 | BRF_PRG | BRF_ESS }, // 1
10662 { "ua0-3.u18", 0x20000, 0x0a7b1c41, 0x01 | BRF_PRG | BRF_ESS }, // 2
10663 { "ua0-1.u16", 0x20000, 0xfa906626, 0x01 | BRF_PRG | BRF_ESS }, // 3
10664
10665 { "ua10-5.u24", 0x20000, 0x8eff6122, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10666
10667 { "ua0-10.u12", 0x40000, 0xaa7b6757, 0x03 | BRF_GRA }, // 5 Sprites
10668 { "ua0-11.u13", 0x40000, 0x11eaf931, 0x03 | BRF_GRA }, // 6
10669 { "ua0-12.u14", 0x40000, 0x00b5381c, 0x03 | BRF_GRA }, // 7
10670 { "ua0-13.u15", 0x40000, 0x8f9a0ed3, 0x03 | BRF_GRA }, // 8
10671 { "ua0-6.u8", 0x40000, 0x14ecc7bb, 0x03 | BRF_GRA }, // 9
10672 { "ua0-7.u9", 0x40000, 0xff1a4e68, 0x03 | BRF_GRA }, // 10
10673 { "ua0-8.u10", 0x40000, 0x936e1884, 0x03 | BRF_GRA }, // 11
10674 { "ua0-9.u11", 0x40000, 0xe812371c, 0x03 | BRF_GRA }, // 12
10675 };
10676
10677 STD_ROM_PICK(tndrcade)
STD_ROM_FN(tndrcade)10678 STD_ROM_FN(tndrcade)
10679
10680 static INT32 tndrcadeInit()
10681 {
10682 DrvSetVideoOffsets(-1, 0, 0, 0);
10683 DrvSetColorOffsets(0, 0, 0);
10684
10685 oisipuzl_hack = 1;
10686
10687 return DrvInit(tndrcade68kInit, 8000000, SET_IRQLINES(2, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, -1, -1));
10688 }
10689
10690 struct BurnDriver BurnDrvTndrcade = {
10691 "tndrcade", NULL, NULL, NULL, "1987",
10692 "Thundercade / Twin Formation\0", NULL, "Seta (Taito license)", "Seta",
10693 NULL, NULL, NULL, NULL,
10694 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
10695 NULL, tndrcadeRomInfo, tndrcadeRomName, NULL, NULL, NULL, NULL, TndrcadeInputInfo, TndrcadeDIPInfo,
10696 tndrcadeInit, DrvExit, DrvTndrcadeFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10697 224, 384, 3, 4
10698 };
10699
10700
10701 // Tokusyu Butai U.A.G. (Japan)
10702
10703 static struct BurnRomInfo tndrcadejRomDesc[] = {
10704 { "ua0-4.u19", 0x20000, 0x73bd63eb, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10705 { "ua0-2.u17", 0x20000, 0xe96194b1, 0x01 | BRF_PRG | BRF_ESS }, // 1
10706 { "ua0-3.u18", 0x20000, 0x0a7b1c41, 0x01 | BRF_PRG | BRF_ESS }, // 2
10707 { "ua0-1.u16", 0x20000, 0xfa906626, 0x01 | BRF_PRG | BRF_ESS }, // 3
10708
10709 { "thcade5.u24", 0x20000, 0x8cb9df7b, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10710
10711 { "ua0-10.u12", 0x40000, 0xaa7b6757, 0x03 | BRF_GRA }, // 5 Sprites
10712 { "ua0-11.u13", 0x40000, 0x11eaf931, 0x03 | BRF_GRA }, // 6
10713 { "ua0-12.u14", 0x40000, 0x00b5381c, 0x03 | BRF_GRA }, // 7
10714 { "ua0-13.u15", 0x40000, 0x8f9a0ed3, 0x03 | BRF_GRA }, // 8
10715 { "ua0-6.u8", 0x40000, 0x14ecc7bb, 0x03 | BRF_GRA }, // 9
10716 { "ua0-7.u9", 0x40000, 0xff1a4e68, 0x03 | BRF_GRA }, // 10
10717 { "ua0-8.u10", 0x40000, 0x936e1884, 0x03 | BRF_GRA }, // 11
10718 { "ua0-9.u11", 0x40000, 0xe812371c, 0x03 | BRF_GRA }, // 12
10719 };
10720
10721 STD_ROM_PICK(tndrcadej)
10722 STD_ROM_FN(tndrcadej)
10723
10724 struct BurnDriver BurnDrvTndrcadej = {
10725 "tndrcadej", "tndrcade", NULL, NULL, "1987",
10726 "Tokusyu Butai U.A.G. (Japan)\0", NULL, "Seta (Taito license)", "Seta",
10727 NULL, NULL, NULL, NULL,
10728 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
10729 NULL, tndrcadejRomInfo, tndrcadejRomName, NULL, NULL, NULL, NULL, TndrcadeInputInfo, TndrcadjDIPInfo,
10730 tndrcadeInit, DrvExit, DrvTndrcadeFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10731 224, 384, 3, 4
10732 };
10733
10734
10735 // Arbalester
10736
10737 static struct BurnRomInfo arbalestRomDesc[] = {
10738 { "uk-001-003", 0x40000, 0xee878a2c, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10739 { "uk-001-004", 0x40000, 0x902bb4e3, 0x01 | BRF_PRG | BRF_ESS }, // 1
10740
10741 /* Label is correct, 1st & 2nd halves identical is correct. Chip is a 27128 - Verified on 2 different PCBs */
10742 { "uk6005", 0x04000, 0x48c73a4a, 0x02 | BRF_PRG | BRF_ESS }, // 2 M65c02 Code
10743
10744 { "uk001.06", 0x40000, 0x11c75746, 0x0b | BRF_GRA }, // 3 Sprites
10745 { "uk001.07", 0x40000, 0x01b166c7, 0x0b | BRF_GRA }, // 4
10746 { "uk001.08", 0x40000, 0x78d60ba3, 0x0b | BRF_GRA }, // 5
10747 { "uk001.09", 0x40000, 0xb4748ae0, 0x0b | BRF_GRA }, // 6
10748
10749 { "uk-001-010-t26", 0x80000, 0xc1e2f823, 0x04 | BRF_GRA }, // 7 Layer 1 tiles
10750 { "uk-001-011-t27", 0x80000, 0x09dfe56a, 0x04 | BRF_GRA }, // 8
10751 { "uk-001-012-t28", 0x80000, 0x818a4085, 0x04 | BRF_GRA }, // 9
10752 { "uk-001-013-t29", 0x80000, 0x771fa164, 0x04 | BRF_GRA }, // 10
10753
10754 { "uk-001-015-t31", 0x80000, 0xce9df5dd, 0x06 | BRF_SND }, // 11 x1-010 Samples
10755 { "uk-001-014-t30", 0x80000, 0x016b844a, 0x06 | BRF_SND }, // 12
10756 };
10757
10758 STD_ROM_PICK(arbalest)
STD_ROM_FN(arbalest)10759 STD_ROM_FN(arbalest)
10760
10761 static INT32 arbalestInit()
10762 {
10763 INT32 rc = 0;
10764 DrvSetVideoOffsets(0, 1, -2, -1);
10765 DrvSetColorOffsets(0, 0, 0);
10766 X1010_Arbalester_Mode = 1;
10767 rc = DrvInit(metafox68kInit, 8000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
10768
10769 if (!rc) clear_opposites = 1;
10770
10771 return rc;
10772 }
10773
10774 struct BurnDriver BurnDrvArbalest = {
10775 "arbalest", NULL, NULL, NULL, "1989",
10776 "Arbalester\0", NULL, "Seta", "Seta",
10777 NULL, NULL, NULL, NULL,
10778 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
10779 NULL, arbalestRomInfo, arbalestRomName, NULL, NULL, NULL, NULL, MetafoxInputInfo, ArbalestDIPInfo,
10780 arbalestInit, DrvExit, DrvTwineaglFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10781 224, 384, 3, 4
10782 };
10783
10784
10785 // Meta Fox
10786
10787 static struct BurnRomInfo metafoxRomDesc[] = {
10788 { "p1003161", 0x40000, 0x4fd6e6a1, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10789 { "p1004162", 0x40000, 0xb6356c9a, 0x01 | BRF_PRG | BRF_ESS }, // 1
10790 { "up001002", 0x10000, 0xce91c987, 0x01 | BRF_PRG | BRF_ESS }, // 2
10791 { "up001001", 0x10000, 0x0db7a505, 0x01 | BRF_PRG | BRF_ESS }, // 3
10792
10793 { "up001005", 0x02000, 0x2ac5e3e3, 0x02 | BRF_PRG | BRF_ESS }, // 4 m65c02 Code
10794
10795 { "p1006163", 0x40000, 0x80f69c7c, 0x0b | BRF_GRA }, // 5 Sprites
10796 { "p1007164", 0x40000, 0xd137e1a3, 0x0b | BRF_GRA }, // 6
10797 { "p1008165", 0x40000, 0x57494f2b, 0x0b | BRF_GRA }, // 7
10798 { "p1009166", 0x40000, 0x8344afd2, 0x0b | BRF_GRA }, // 8
10799
10800 { "up001010", 0x80000, 0xbfbab472, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
10801 { "up001011", 0x80000, 0x26cea381, 0x04 | BRF_GRA }, // 10
10802 { "up001012", 0x80000, 0xfed2c5f9, 0x04 | BRF_GRA }, // 11
10803 { "up001013", 0x80000, 0xadabf9ea, 0x04 | BRF_GRA }, // 12
10804
10805 { "up001015", 0x80000, 0x2e20e39f, 0x06 | BRF_SND }, // 13 x1-010 Samples
10806 { "up001014", 0x80000, 0xfca6315e, 0x06 | BRF_SND }, // 14
10807 };
10808
10809 STD_ROM_PICK(metafox)
STD_ROM_FN(metafox)10810 STD_ROM_FN(metafox)
10811
10812 static void __fastcall metafox_protection_write_byte(UINT32 address, UINT8 data)
10813 {
10814 Drv68KRAM2[(address / 2) & 0x1fff] = data;
10815 }
10816
metafox_protection_read_byte(UINT32 address)10817 static UINT8 __fastcall metafox_protection_read_byte(UINT32 address)
10818 {
10819 switch (address & 0x3ffe)
10820 {
10821 case 0x0000: // 21c001
10822 return Drv68KRAM2[0x0101/2];
10823
10824 case 0x1000: // 21d001
10825 return Drv68KRAM2[0x10a1/2];
10826
10827 case 0x2000: // 21e001
10828 return Drv68KRAM2[0x2149/2];
10829 }
10830
10831 return Drv68KRAM2[(address / 2) & 0x1fff];
10832 }
10833
metafox_protection_install()10834 static void metafox_protection_install()
10835 {
10836 SekOpen(0);
10837 SekMapHandler(4, 0x21c000, 0x21ffff, MAP_READ | MAP_WRITE);
10838 SekSetReadByteHandler (4, metafox_protection_read_byte);
10839 SekSetWriteByteHandler(4, metafox_protection_write_byte);
10840 SekClose();
10841 }
10842
metafoxInit()10843 static INT32 metafoxInit()
10844 {
10845 DrvSetVideoOffsets(0, 0, 16, -19);
10846 DrvSetColorOffsets(0, 0, 0);
10847
10848 INT32 nRet = DrvInit(metafox68kInit, 8000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
10849
10850 if (nRet == 0) {
10851 clear_opposites = 1;
10852 metafox_protection_install();
10853 }
10854
10855 return nRet;
10856 }
10857
10858 struct BurnDriver BurnDrvMetafox = {
10859 "metafox", NULL, NULL, NULL, "1989",
10860 "Meta Fox\0", NULL, "Seta", "Seta",
10861 NULL, NULL, NULL, NULL,
10862 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
10863 NULL, metafoxRomInfo, metafoxRomName, NULL, NULL, NULL, NULL, MetafoxInputInfo, MetafoxDIPInfo,
10864 metafoxInit, DrvExit, DrvTwineaglFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10865 224, 384, 3, 4
10866 };
10867
10868
10869 // Pro Mahjong Kiwame
10870
10871 static struct BurnRomInfo kiwameRomDesc[] = {
10872 { "fp001001.bin", 0x40000, 0x31b17e39, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10873 { "fp001002.bin", 0x40000, 0x5a6e2efb, 0x01 | BRF_PRG | BRF_ESS }, // 1
10874
10875 { "fp001003.bin", 0x80000, 0x0f904421, 0x03 | BRF_GRA }, // 2 Sprites
10876
10877 { "fp001006.bin", 0x80000, 0x96cf395d, 0x06 | BRF_SND }, // 3 x1-010 Samples
10878 { "fp001005.bin", 0x80000, 0x65b5fe9a, 0x06 | BRF_SND }, // 4
10879
10880 { "nvram.bin", 0x10000, 0x1f719400, 0x00 | BRF_OPT }, // 5
10881 };
10882
10883 STD_ROM_PICK(kiwame)
STD_ROM_FN(kiwame)10884 STD_ROM_FN(kiwame)
10885
10886 static INT32 kiwameInit()
10887 {
10888 DrvSetVideoOffsets(0, -16, 0, 0);
10889 DrvSetColorOffsets(0, 0, 0);
10890
10891 return DrvInit(kiwame68kInit, 16000000, SET_IRQLINES(1, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
10892 }
10893
10894 struct BurnDriverD BurnDrvKiwame = {
10895 "kiwame", NULL, NULL, NULL, "1994",
10896 "Pro Mahjong Kiwame\0", NULL, "Athena", "Seta",
10897 NULL, NULL, NULL, NULL,
10898 BDF_GAME_NOT_WORKING, 2, HARDWARE_SETA1, GBF_MAHJONG, 0,
10899 NULL, kiwameRomInfo, kiwameRomName, NULL, NULL, NULL, NULL, KiwameInputInfo, KiwameDIPInfo,
10900 kiwameInit, DrvExit, DrvFrame, setaNoLayersDraw, DrvScan, &DrvRecalc, 0x200,
10901 448, 240, 4, 3
10902 };
10903
10904
10905 // Twin Eagle - Revenge Joe's Brother
10906
10907 static struct BurnRomInfo twineaglRomDesc[] = {
10908 { "ua2-1", 0x80000, 0x5c3fe531, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10909
10910 { "ua2-2", 0x02000, 0x783ca84e, 0x02 | BRF_PRG | BRF_ESS }, // 1 M65c02 Code
10911
10912 { "ua2-4", 0x40000, 0x8b7532d6, 0x0b | BRF_GRA }, // 2 Sprites
10913 { "ua2-3", 0x40000, 0x1124417a, 0x0b | BRF_GRA }, // 3
10914 { "ua2-6", 0x40000, 0x99d8dbba, 0x0b | BRF_GRA }, // 4
10915 { "ua2-5", 0x40000, 0x6e450d28, 0x0b | BRF_GRA }, // 5
10916
10917 { "ua2-8", 0x80000, 0x7d3a8d73, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
10918 { "ua2-10", 0x80000, 0x5bbe1f56, 0x04 | BRF_GRA }, // 7
10919 { "ua2-7", 0x80000, 0xfce56907, 0x04 | BRF_GRA }, // 8
10920 { "ua2-9", 0x80000, 0xa451eae9, 0x04 | BRF_GRA }, // 9
10921
10922 { "ua2-11", 0x80000, 0x624e6057, 0x06 | BRF_SND }, // 10 x1-010 Samples
10923 { "ua2-12", 0x80000, 0x3068ff64, 0x06 | BRF_SND }, // 11
10924 };
10925
10926 STD_ROM_PICK(twineagl)
STD_ROM_FN(twineagl)10927 STD_ROM_FN(twineagl)
10928
10929 static INT32 twineaglInit()
10930 {
10931 twineagle = 1;
10932
10933 DrvSetVideoOffsets(0, 0, 0, -3);
10934 DrvSetColorOffsets(0, 0, 0);
10935 clear_opposites = 1;
10936
10937 return DrvInit(twineagle68kInit, 8000000, SET_IRQLINES(3, NOIRQ2), NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
10938 }
10939
10940 struct BurnDriver BurnDrvTwineagl = {
10941 "twineagl", NULL, NULL, NULL, "1988",
10942 "Twin Eagle - Revenge Joe's Brother\0", NULL, "Seta (Taito license)", "Seta",
10943 NULL, NULL, NULL, NULL,
10944 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL | BDF_HISCORE_SUPPORTED, 2, HARDWARE_SETA1, GBF_VERSHOOT, 0,
10945 NULL, twineaglRomInfo, twineaglRomName, NULL, NULL, NULL, NULL, TwineaglInputInfo, TwineaglDIPInfo,
10946 twineaglInit, DrvExit, DrvTwineaglFrame /*DrvM65c02Frame*/, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
10947 224, 384, 3, 4
10948 };
10949
10950
10951 // U.S. Classic
10952
10953 static struct BurnRomInfo usclssicRomDesc[] = {
10954 { "ue2001.u20", 0x20000, 0x18b41421, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
10955 { "ue2000.u14", 0x20000, 0x69454bc2, 0x01 | BRF_PRG | BRF_ESS }, // 1
10956 { "ue2002.u22", 0x20000, 0xa7bbe248, 0x01 | BRF_PRG | BRF_ESS }, // 2
10957 { "ue2003.u30", 0x20000, 0x29601906, 0x01 | BRF_PRG | BRF_ESS }, // 3
10958
10959 { "ue002u61.004", 0x40000, 0x476e9f60, 0x02 | BRF_PRG | BRF_ESS }, // 4 M65c02 Code
10960
10961 { "ue001009.119", 0x80000, 0xdc065204, 0x0b | BRF_GRA }, // 5 Sprites
10962 { "ue001008.118", 0x80000, 0x5947d9b5, 0x0b | BRF_GRA }, // 6
10963 { "ue001007.117", 0x80000, 0xb48a885c, 0x0b | BRF_GRA }, // 7
10964 { "ue001006.116", 0x80000, 0xa6ab6ef4, 0x0b | BRF_GRA }, // 8
10965
10966 { "ue001010.120", 0x80000, 0xdd683031, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
10967 { "ue001011.121", 0x80000, 0x0e27bc49, 0x04 | BRF_GRA }, // 10
10968 { "ue001012.122", 0x80000, 0x961dfcdc, 0x04 | BRF_GRA }, // 11
10969 { "ue001013.123", 0x80000, 0x03e9eb79, 0x04 | BRF_GRA }, // 12
10970 { "ue001014.124", 0x80000, 0x9576ace7, 0x04 | BRF_GRA }, // 13
10971 { "ue001015.125", 0x80000, 0x631d6eb1, 0x04 | BRF_GRA }, // 14
10972 { "ue001016.126", 0x80000, 0xf44a8686, 0x04 | BRF_GRA }, // 15
10973 { "ue001017.127", 0x80000, 0x7f568258, 0x04 | BRF_GRA }, // 16
10974 { "ue001018.128", 0x80000, 0x4bd98f23, 0x04 | BRF_GRA }, // 17
10975 { "ue001019.129", 0x80000, 0x6d9f5a33, 0x04 | BRF_GRA }, // 18
10976 { "ue001020.130", 0x80000, 0xbc07403f, 0x04 | BRF_GRA }, // 19
10977 { "ue001021.131", 0x80000, 0x98c03efd, 0x04 | BRF_GRA }, // 20
10978
10979 { "ue001005.132", 0x80000, 0xc5fea37c, 0x06 | BRF_SND }, // 21 x1-010 Samples
10980
10981 { "ue1-023.prm", 0x00200, 0xa13192a4, 0x0f | BRF_GRA }, // 22 Color PROMs
10982 { "ue1-022.prm", 0x00200, 0x1a23129e, 0x0f | BRF_GRA }, // 23
10983 };
10984
10985 STD_ROM_PICK(usclssic)
STD_ROM_FN(usclssic)10986 STD_ROM_FN(usclssic)
10987
10988 static INT32 usclssicInit()
10989 {
10990 watchdog_enable = 1;
10991 DrvSetColorOffsets(0, 0x200, 0);
10992 DrvSetVideoOffsets(1, 2, 0, -1);
10993 trackball_mode = 1; // for trackball
10994 usclssic = 1;
10995
10996 INT32 nRet = DrvInit(usclssic68kInit, 8000000, SET_IRQLINES(0x80, 0x80) /*custom*/, NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 4, -1));
10997
10998 if (nRet == 0) {
10999 usclssicSetColorTable();
11000 }
11001
11002 return nRet;
11003 }
11004
11005 struct BurnDriver BurnDrvUsclssic = {
11006 "usclssic", NULL, NULL, NULL, "1989",
11007 "U.S. Classic\0", NULL, "Seta", "Seta",
11008 NULL, NULL, NULL, NULL,
11009 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_SPORTSMISC, 0,
11010 NULL, usclssicRomInfo, usclssicRomName, NULL, NULL, NULL, NULL, UsclssicInputInfo, UsclssicDIPInfo,
11011 usclssicInit, DrvExit, DrvCalibr50Frame, seta1layerDraw, DrvScan, &DrvRecalc, 0x1200,
11012 240, 384, 3, 4
11013 };
11014
11015
11016 // Caliber 50
11017
11018 static struct BurnRomInfo calibr50RomDesc[] = {
11019 { "uh002001.u45", 0x40000, 0xeb92e7ed, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
11020 { "uh002004.u41", 0x40000, 0x5a0ed31e, 0x01 | BRF_PRG | BRF_ESS }, // 1
11021 { "uh001003.9a", 0x10000, 0x0d30d09f, 0x01 | BRF_PRG | BRF_ESS }, // 2
11022 { "uh001002.7a", 0x10000, 0x7aecc3f9, 0x01 | BRF_PRG | BRF_ESS }, // 3
11023
11024 { "uh001005.u61", 0x40000, 0x4a54c085, 0x02 | BRF_PRG | BRF_ESS }, // 4 m65c02 Code
11025
11026 { "uh001006.ux2", 0x80000, 0xfff52f91, 0x0b | BRF_GRA }, // 5 Sprites
11027 { "uh001007.ux1", 0x80000, 0xb6c19f71, 0x0b | BRF_GRA }, // 6
11028 { "uh001008.ux6", 0x80000, 0x7aae07ef, 0x0b | BRF_GRA }, // 7
11029 { "uh001009.ux0", 0x80000, 0xf85da2c5, 0x0b | BRF_GRA }, // 8
11030
11031 { "uh001010.u3x", 0x80000, 0xf986577a, 0x04 | BRF_GRA }, // 9 Layer 1 tiles
11032 { "uh001011.u50", 0x80000, 0x08620052, 0x04 | BRF_GRA }, // 10
11033
11034 { "uh001013.u60", 0x80000, 0x09ec0df6, 0x06 | BRF_SND }, // 11 x1-010 Samples
11035 { "uh001012.u46", 0x80000, 0xbb996547, 0x06 | BRF_SND }, // 12
11036 };
11037
11038 STD_ROM_PICK(calibr50)
STD_ROM_FN(calibr50)11039 STD_ROM_FN(calibr50)
11040
11041 static INT32 calibr50Init()
11042 {
11043 refresh_rate = 5742; // 57.42 hz
11044 watchdog_enable = 1;
11045 DrvSetColorOffsets(0, 0, 0);
11046 DrvSetVideoOffsets(-1, 2, -3, -2);
11047
11048 INT32 nRet = DrvInit(calibr5068kInit, 8000000, SET_IRQLINES(0x80, 0x80) /*custom*/, NO_SPRITE_BUFFER, SET_GFX_DECODE(0, 1, -1));
11049
11050 return nRet;
11051 }
11052
11053 struct BurnDriver BurnDrvCalibr50 = {
11054 "calibr50", NULL, NULL, NULL, "1989",
11055 "Caliber 50\0", NULL, "Athena / Seta", "Seta",
11056 NULL, NULL, NULL, NULL,
11057 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_SETA1, GBF_RUNGUN, 0,
11058 NULL, calibr50RomInfo, calibr50RomName, NULL, NULL, NULL, NULL, Calibr50InputInfo, Calibr50DIPInfo,
11059 calibr50Init, DrvExit, DrvCalibr50Frame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
11060 240, 384, 3, 4
11061 };
11062
11063
11064 // Crazy Fight
11065
11066 static struct BurnRomInfo crazyfgtRomDesc[] = {
11067 { "rom.u3", 0x40000, 0xbf333e75, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
11068 { "rom.u4", 0x40000, 0x505e9d47, 0x01 | BRF_PRG | BRF_ESS }, // 1
11069
11070 { "rom.u228", 0x80000, 0x7181618e, 0x03 | BRF_GRA }, // 2 Sprites
11071 { "rom.u227", 0x80000, 0x7905b5f2, 0x03 | BRF_GRA }, // 3
11072 { "rom.u226", 0x80000, 0xef210e34, 0x03 | BRF_GRA }, // 4
11073 { "rom.u225", 0x80000, 0x451b4419, 0x03 | BRF_GRA }, // 5
11074
11075 { "rom.u67", 0x40000, 0xec8c6831, 0x04 | BRF_GRA }, // 6 Layer 1 tiles
11076 { "rom.u68", 0x80000, 0x2124312e, 0x04 | BRF_GRA }, // 7
11077
11078 { "rom.u65", 0x40000, 0x58448231, 0x05 | BRF_GRA }, // 8 Layer 2 tiles
11079 { "rom.u66", 0x80000, 0xc6f7735b, 0x05 | BRF_GRA }, // 9
11080
11081 { "rom.u85", 0x40000, 0x7b95d0bb, 0x06 | BRF_SND }, // 10 OKI M6295 Samples
11082 };
11083
11084 STD_ROM_PICK(crazyfgt)
STD_ROM_FN(crazyfgt)11085 STD_ROM_FN(crazyfgt)
11086
11087 static INT32 crazyfgtInit()
11088 {
11089 DrvSetColorOffsets(0, 0xa00, 0x200);
11090 DrvSetVideoOffsets(8, 0, 6, 0);
11091
11092 INT32 nRet = DrvInit(crazyfgt68kInit, 16000000, SET_IRQLINES(0x80, 0x80) /*custom*/, NO_SPRITE_BUFFER, SET_GFX_DECODE(5, 4, 4));
11093
11094 if (nRet == 0) {
11095 gundharaSetColorTable();
11096 }
11097
11098 return nRet;
11099 }
11100
11101 struct BurnDriver BurnDrvCrazyfgt = {
11102 "crazyfgt", NULL, NULL, NULL, "1996",
11103 "Crazy Fight\0", NULL, "Subsino", "Seta",
11104 NULL, NULL, NULL, NULL,
11105 BDF_GAME_WORKING, 2, HARDWARE_SETA1, GBF_SHOOT, 0,
11106 NULL, crazyfgtRomInfo, crazyfgtRomName, NULL, NULL, NULL, NULL, CrazyfgtInputInfo, CrazyfgtDIPInfo,
11107 crazyfgtInit, DrvExit, CrazyfgtFrame, seta2layerDraw, DrvScan, &DrvRecalc, 0x1200,
11108 384, 224, 4, 3
11109 };
11110
11111
11112 //----------------------------------------------------------------------------------------------------------
11113 // should be moved into its own file
11114
11115 static UINT8 msm6242_reg[3];
11116 static time_t msm6242_hold_time;
11117
msm6242_read(UINT32 offset)11118 UINT8 msm6242_read(UINT32 offset)
11119 {
11120 tm *systime;
11121
11122 if (msm6242_reg[0] & 1) {
11123 systime = localtime(&msm6242_hold_time);
11124 } else {
11125 time_t curtime = time(NULL);
11126 systime = localtime(&curtime);
11127 }
11128
11129 switch (offset)
11130 {
11131 case 0x00: return systime->tm_sec % 10;
11132 case 0x01: return systime->tm_sec / 10;
11133 case 0x02: return systime->tm_min % 10;
11134 case 0x03: return systime->tm_min / 10;
11135 case 0x04:
11136 case 0x05:
11137 {
11138 INT32 hour = systime->tm_hour, pm = 0;
11139
11140 if ((msm6242_reg[2] & 0x04) == 0) // 12 hour mode?
11141 {
11142 if (hour >= 12) pm = 1;
11143 hour %= 12;
11144 if (hour == 0) hour = 12;
11145 }
11146
11147 if (offset == 0x04) return hour % 10;
11148
11149 return (hour / 10) | (pm <<2);
11150 }
11151
11152 case 0x06: return systime->tm_mday % 10;
11153 case 0x07: return systime->tm_mday / 10;
11154 case 0x08: return (systime->tm_mon+1) % 10;
11155 case 0x09: return (systime->tm_mon+1) / 10;
11156 case 0x0a: return systime->tm_year % 10;
11157 case 0x0b: return (systime->tm_year % 100) / 10;
11158 case 0x0c: return systime->tm_wday;
11159 case 0x0d: return msm6242_reg[0];
11160 case 0x0e: return msm6242_reg[1];
11161 case 0x0f: return msm6242_reg[2];
11162 }
11163
11164 return 0;
11165 }
11166
msm6242_write(UINT32 offset,UINT8 data)11167 void msm6242_write(UINT32 offset, UINT8 data)
11168 {
11169 if (offset == 0x0d) {
11170 msm6242_reg[0] = data & 0x0f;
11171 if (data & 1) msm6242_hold_time = time(NULL);
11172 } else if (offset == 0x0e) {
11173 msm6242_reg[1] = data & 0x0f;
11174 } else if (offset == 0x0f) {
11175 if ((data ^ msm6242_reg[2]) & 0x04) {
11176 msm6242_reg[2] = (msm6242_reg[2] & 0x04) | (data & ~0x04);
11177
11178 if (msm6242_reg[2] & 1) msm6242_reg[2] = (msm6242_reg[2] & ~0x04) | (data & 0x04);
11179 } else {
11180 msm6242_reg[2] = data & 0x0f;
11181 }
11182 }
11183 }
11184
msm6242_reset()11185 void msm6242_reset()
11186 {
11187 memset (msm6242_reg, 0, 3);
11188 msm6242_hold_time = time(NULL);
11189 }
11190
11191 //--------------------------------------------------------------------------------------------------------------------
11192
jockeyc_dsw_read(INT32 offset)11193 static UINT16 jockeyc_dsw_read(INT32 offset)
11194 {
11195 INT32 dip2 = DrvDips[1] | (DrvDips[2] << 8);
11196 INT32 shift = offset << 2;
11197
11198 return ((((DrvDips[0] >> shift) & 0xf)) << 0) | ((((dip2 >> shift) & 0xf)) << 4) | ((((dip2 >> (shift+8)) & 0xf)) << 8);
11199 }
11200
jockeyc_read_word(UINT32 address)11201 UINT16 __fastcall jockeyc_read_word(UINT32 address)
11202 {
11203 switch (address)
11204 {
11205 case 0x200000:
11206 case 0x200001: {
11207 INT32 i;
11208 for (i = 3; i < 8; i++) {
11209 if (usclssic_port_select & (1 << i)) return DrvInputs[(i - 3) + 2];
11210 }
11211 return 0xffff;
11212 }
11213
11214 case 0x200002:
11215 case 0x200003:
11216 return DrvInputs[0];
11217
11218 case 0x200010:
11219 case 0x200011:
11220 return DrvInputs[1] & 0x7fff;
11221
11222 case 0x500000:
11223 case 0x500001:
11224 case 0x500002:
11225 case 0x500003:
11226 return jockeyc_dsw_read(address & 2);
11227
11228 case 0x600000:
11229 case 0x600001:
11230 case 0x600002:
11231 case 0x600003:
11232 return ~0;
11233 }
11234
11235 if ((address & 0xfffffe0) == 0x800000) {
11236 return msm6242_read((address & 0x1e) / 2);
11237 }
11238
11239 return 0;
11240 }
11241
jockeyc_read_byte(UINT32 address)11242 UINT8 __fastcall jockeyc_read_byte(UINT32 address)
11243 {
11244 switch (address)
11245 {
11246 case 0x200000:
11247 case 0x200001: {
11248 INT32 i;
11249 for (i = 3; i < 8; i++) {
11250 if (usclssic_port_select & (1 << i)) return DrvInputs[(i - 3) + 2];
11251 }
11252 return 0xff;
11253 }
11254
11255 case 0x200002:
11256 return DrvInputs[0] >> 8;
11257
11258 case 0x200003:
11259 return DrvInputs[0];
11260
11261 case 0x200010:
11262 return (DrvInputs[1] >> 8) & 0x7f;
11263
11264 case 0x200011:
11265 return DrvInputs[1];
11266
11267 case 0x500000:
11268 case 0x500001:
11269 case 0x500002:
11270 case 0x500003:
11271 return jockeyc_dsw_read(address & 2);
11272
11273 case 0x600000:
11274 case 0x600001:
11275 case 0x600002:
11276 case 0x600003:
11277 return ~0;
11278 }
11279
11280 if ((address & 0xfffffe0) == 0x800000) {
11281 return msm6242_read((address & 0x1e) / 2);
11282 }
11283
11284 return 0;
11285 }
11286
jockeyc_write_word(UINT32 address,UINT16 data)11287 void __fastcall jockeyc_write_word(UINT32 address, UINT16 data)
11288 {
11289 SetaVidRAMCtrlWriteWord(0, 0xa00000)
11290
11291 switch (address)
11292 {
11293 case 0x200000:
11294 case 0x200001:
11295 usclssic_port_select = data & 0xf8;
11296 return;
11297
11298 case 0x300000:
11299 case 0x300001:
11300 watchdog = 0;
11301 return;
11302 }
11303
11304 if ((address & 0xfffffe0) == 0x800000) {
11305 msm6242_write((address & 0x1e) / 2, data);
11306 return;
11307 }
11308 }
11309
jockeyc_write_byte(UINT32 address,UINT8 data)11310 void __fastcall jockeyc_write_byte(UINT32 address, UINT8 data)
11311 {
11312 SetaVidRAMCtrlWriteByte(0, 0xa00000)
11313
11314 switch (address)
11315 {
11316 case 0x200000:
11317 case 0x200001:
11318 usclssic_port_select = data & 0xf8;
11319 return;
11320
11321 case 0x300000:
11322 case 0x300001:
11323 watchdog = 0;
11324 return;
11325 }
11326
11327 if ((address & 0xfffffe0) == 0x800000) {
11328 msm6242_write((address & 0x1e) / 2, data);
11329 return;
11330
11331 }
11332 }
11333
jockeyc68kInit()11334 static void jockeyc68kInit()
11335 {
11336 SekInit(0, 0x68000);
11337 SekOpen(0);
11338 SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
11339 SekMapMemory(DrvVidRAM0, 0xb00000, 0xb07fff, MAP_RAM);
11340 SekMapMemory(DrvSprRAM0, 0xd00000, 0xd00607 | 0x7ff, MAP_RAM);
11341 SekMapMemory(DrvSprRAM1, 0xe00000, 0xe03fff, MAP_RAM);
11342 SekMapMemory(Drv68KRAM, 0xffc000, 0xffffff, MAP_RAM);
11343 SekSetWriteWordHandler(0, jockeyc_write_word);
11344 SekSetWriteByteHandler(0, jockeyc_write_byte);
11345 SekSetReadWordHandler(0, jockeyc_read_word);
11346 SekSetReadByteHandler(0, jockeyc_read_byte);
11347
11348 SekMapHandler(1, 0x900000, 0x903fff, MAP_READ | MAP_WRITE);
11349 SekSetReadWordHandler (1, setaSoundRegReadWord);
11350 SekSetReadByteHandler (1, setaSoundRegReadByte);
11351 SekSetWriteWordHandler(1, setaSoundRegWriteWord);
11352 SekSetWriteByteHandler(1, setaSoundRegWriteByte);
11353 SekClose();
11354
11355 memcpy (Drv68KROM + 0x100000, Drv68KROM + 0x020000, 0x080000);
11356 memset (Drv68KROM + 0x020000, 0xff, 0x60000);
11357 memset (Drv68KROM + 0x180000, 0xff, 0x80000);
11358
11359 memmove (DrvGfxROM1 + 0x60000, DrvGfxROM1 + 0x40000, 0x40000);
11360 memset (DrvGfxROM1 + 0x40000, 0, 0x20000);
11361 memset (DrvGfxROM1 + 0xa0000, 0, 0x20000);
11362
11363 DrvROMLen[4] = 1; // force use of pal ram
11364
11365 msm6242_reset();
11366 }
11367
jockeycInit()11368 static INT32 jockeycInit()
11369 {
11370 watchdog_enable = 1;
11371 DrvSetColorOffsets(0, 0, 0);
11372 DrvSetVideoOffsets(0, 0, 0, 0);
11373
11374 return DrvInit(jockeyc68kInit, 16000000, SET_IRQLINES(0x80, 0x80) /*custom*/, NO_SPRITE_BUFFER, SET_GFX_DECODE(5, 1, -1));
11375 }
11376
jockeycFrameCallback()11377 static void jockeycFrameCallback()
11378 {
11379 DrvInputs[0] ^= 0xffff;
11380 DrvInputs[0] ^= DrvDips[3] | (DrvDips[4] << 8);
11381 DrvInputs[1] ^= 0xffff;
11382 DrvInputs[1] ^= DrvDips[5] | (DrvDips[6] << 8);
11383
11384 INT32 nInterleave = 10;
11385 INT32 nCyclesTotal[1] = { cpuspeed / 60 };
11386 INT32 nCyclesDone[1] = { 0 };
11387
11388 INT32 irqs[10] = { 4, 1, 2, 6, 6, 6, 6, 6, 6, 6 };
11389
11390 SekOpen(0);
11391
11392 for (INT32 i = 0; i < nInterleave; i++)
11393 {
11394 CPU_RUN(0, Sek);
11395
11396 SekSetIRQLine(irqs[9-i], CPU_IRQSTATUS_AUTO); // ?
11397 }
11398
11399 SekClose();
11400
11401 if (pBurnSoundOut) {
11402 x1010_sound_update();
11403 }
11404 }
11405
jockeycFrame()11406 static INT32 jockeycFrame()
11407 {
11408 return DrvCommonFrame(jockeycFrameCallback);
11409 }
11410
11411
11412 // Jockey Club
11413
11414 static struct BurnRomInfo jockeycRomDesc[] = {
11415 { "ya_007_002.u23", 0x10000, 0xc499bf4d, 0x01 | BRF_PRG | BRF_ESS }, // 0 68k Code
11416 { "ya_007_003.u33", 0x10000, 0xe7b0677e, 0x01 | BRF_PRG | BRF_ESS }, // 1
11417 { "ya-002-001.u18", 0x80000, 0xdd108016, 0x01 | BRF_PRG | BRF_ESS }, // 2
11418
11419 { "ya-001-004-t74.u10", 0x80000, 0xeb74d2e0, 0x03 | BRF_GRA }, // 3 Sprites
11420 { "ya-001-005-t75.u17", 0x80000, 0x4a6c804b, 0x03 | BRF_GRA }, // 4
11421 { "ya-001-006-t76.u22", 0x80000, 0xbfae01a5, 0x03 | BRF_GRA }, // 5
11422 { "ya-001-007-t77.u27", 0x80000, 0x2dc7a294, 0x03 | BRF_GRA }, // 6
11423
11424 { "ya-001-008-t59.u35", 0x40000, 0x4b890f83, 0x04 | BRF_GRA }, // 7 Layer 1 tiles
11425 { "ya-001-009-t60.u41", 0x40000, 0xcaa5e3c1, 0x04 | BRF_GRA }, // 8
11426 // double this so that we can use the graphics decoding routines...
11427 { "ya-001-009-t60.u41", 0x40000, 0xcaa5e3c1, 0x04 | BRF_GRA }, // 9
11428
11429 { "ya-001-013.u71", 0x80000, 0x2bccaf47, 0x06 | BRF_SND }, // 10 x1snd
11430 { "ya-001-012.u64", 0x80000, 0xa8015ce6, 0x06 | BRF_SND }, // 11
11431
11432 { "ya1-011.prom", 0x00200, 0xbd4fe2f6, 0x0f | BRF_GRA }, // 13
11433 { "ya1-010.prom", 0x00200, 0x778094b3, 0x0f | BRF_GRA }, // 12 Color PROMs
11434 };
11435
11436 STD_ROM_PICK(jockeyc)
11437 STD_ROM_FN(jockeyc)
11438
11439 struct BurnDriverD BurnDrvJockeyc = {
11440 "jockeyc", NULL, NULL, NULL, "1990",
11441 "Jockey Club\0", NULL, "[Seta] (Visco license)", "Seta",
11442 NULL, NULL, NULL, NULL,
11443 BDF_GAME_NOT_WORKING, 2, HARDWARE_SETA1, GBF_SPORTSMISC, 0,
11444 NULL, jockeycRomInfo, jockeycRomName, NULL, NULL, NULL, NULL, JockeycInputInfo, JockeycDIPInfo,
11445 jockeycInit, DrvExit, jockeycFrame, seta1layerDraw, DrvScan, &DrvRecalc, 0x200,
11446 384, 240, 4, 3
11447 };
11448