1 // Based on MAME driver by David Graves
2
3 #include "tiles_generic.h"
4 #include "m68000_intf.h"
5 #include "z80_intf.h"
6 #include "taito.h"
7 #include "taito_ic.h"
8 #include "burn_ym2610.h"
9 #include "eeprom.h"
10 #include "burn_gun.h"
11 #include "burn_shift.h"
12
13 static INT32 Sci;
14 static INT32 SciSpriteFrame;
15 static INT32 TaitoZINT6timer = 0;
16 static INT32 bUseShifter = 0;
17 static INT32 bUseGun = 0;
18
19 static double TaitoZYM2610Route1MasterVol;
20 static double TaitoZYM2610Route2MasterVol;
21
22 #ifdef BUILD_A68K
23 static bool bUseAsm68KCoreOldValue = false;
24 #endif
25
26 #define A(a, b, c, d) {a, b, (UINT8*)(c), d}
27
28 static struct BurnInputInfo AquajackInputList[] =
29 {
30 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "p1 coin" },
31 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort1 + 3, "p1 start" },
32 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "p2 coin" },
33
34 {"Up" , BIT_DIGITAL , TC0220IOCInputPort1 + 0, "p1 up" },
35 {"Down" , BIT_DIGITAL , TC0220IOCInputPort1 + 3, "p1 down" },
36 {"Left" , BIT_DIGITAL , TC0220IOCInputPort1 + 1, "p1 left" },
37 {"Right" , BIT_DIGITAL , TC0220IOCInputPort1 + 2, "p1 right" },
38 {"Jump" , BIT_DIGITAL , TC0220IOCInputPort1 + 5, "p1 fire 1" },
39 {"Accelerate" , BIT_DIGITAL , TC0220IOCInputPort0 + 1, "p1 fire 2" },
40 {"Vulcan" , BIT_DIGITAL , TC0220IOCInputPort1 + 6, "p1 fire 3" },
41 {"Missile" , BIT_DIGITAL , TC0220IOCInputPort1 + 4, "p1 fire 4" },
42
43 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
44 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "service" },
45 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort0 + 5, "tilt" },
46 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
47 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
48 };
49
50 STDINPUTINFO(Aquajack)
51
52 static struct BurnInputInfo BsharkInputList[] =
53 {
54 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 1, "p1 coin" },
55 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 0, "p1 start" },
56 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 0, "p2 coin" },
57 {"Start 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 1, "p2 start" },
58
59 A("Crosshair X" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
60 A("Crosshair Y" , BIT_ANALOG_REL, &TaitoAnalogPort1 , "p1 y-axis" ),
61 {"Fire 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 6, "p1 fire 1" },
62 {"Fire 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 7, "p1 fire 2" },
63
64 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
65 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "service" },
66 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "tilt" },
67 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
68 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
69 };
70
71 STDINPUTINFO(Bshark)
72
73 static struct BurnInputInfo BsharkjjsInputList[] =
74 {
75 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 1, "p1 coin" },
76 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 0, "p1 start" },
77 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 0, "p2 coin" },
78 {"Start 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 1, "p2 start" },
79
80 {"Up" , BIT_DIGITAL , TC0220IOCInputPort2 + 2, "p1 up" },
81 {"Down" , BIT_DIGITAL , TC0220IOCInputPort2 + 3, "p1 down" },
82 {"Left" , BIT_DIGITAL , TC0220IOCInputPort2 + 5, "p1 left" },
83 {"Right" , BIT_DIGITAL , TC0220IOCInputPort2 + 4, "p1 right" },
84 {"Fire 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 6, "p1 fire 1" },
85 {"Fire 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 7, "p1 fire 2" },
86
87 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
88 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "service" },
89 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "tilt" },
90 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
91 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
92 };
93
94 STDINPUTINFO(Bsharkjjs)
95
96 static struct BurnInputInfo ChasehqInputList[] =
97 {
98 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "p1 coin" },
99 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort1 + 3, "p1 start" },
100 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "p2 coin" },
101
102 A("Steering" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
103 {"Brake" , BIT_DIGITAL , TC0220IOCInputPort0 + 5, "p1 fire 1" },
104 {"Accelerate" , BIT_DIGITAL , TC0220IOCInputPort1 + 5, "p1 fire 2" },
105 {"Turbo" , BIT_DIGITAL , TC0220IOCInputPort1 + 0, "p1 fire 3" },
106 {"Gear" , BIT_DIGITAL , TC0220IOCInputPort1 + 4, "p1 fire 4" },
107
108 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
109 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "service" },
110 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort1 + 1, "tilt" },
111 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
112 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
113 };
114
115 STDINPUTINFO(Chasehq)
116
117 static struct BurnInputInfo ContcircInputList[] =
118 {
119 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "p1 coin" },
120 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort1 + 3, "p1 start" },
121 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "p2 coin" },
122
123 A("Steering" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
124 {"Brake" , BIT_DIGITAL , TC0220IOCInputPort1 + 7, "p1 fire 1" },
125 {"Accelerate" , BIT_DIGITAL , TC0220IOCInputPort0 + 7, "p1 fire 2" },
126 {"Gear" , BIT_DIGITAL , TC0220IOCInputPort1 + 4, "p1 fire 3" },
127 {"Brake 2" , BIT_DIGITAL , TC0220IOCInputPort1 + 5, "p1 fire 4" },
128 {"Brake 3" , BIT_DIGITAL , TC0220IOCInputPort1 + 6, "p1 fire 5" },
129 {"Accelerate 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 5, "p1 fire 6" },
130 {"Accelerate 3" , BIT_DIGITAL , TC0220IOCInputPort0 + 6, "p1 fire 7" },
131
132 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
133 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "service" },
134 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort1 + 2, "tilt" },
135 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
136 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
137 };
138
139 STDINPUTINFO(Contcirc)
140
141 static struct BurnInputInfo DblaxleInputList[] =
142 {
143 {"Coin 1" , BIT_DIGITAL , TC0510NIOInputPort0 + 2, "p1 coin" },
144 {"Start 1" , BIT_DIGITAL , TC0510NIOInputPort1 + 3, "p1 start" },
145 {"Coin 2" , BIT_DIGITAL , TC0510NIOInputPort0 + 3, "p2 coin" },
146
147 A("Steering" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
148 {"Brake" , BIT_DIGITAL , TC0510NIOInputPort0 + 5, "p1 fire 1" },
149 {"Accelerate" , BIT_DIGITAL , TC0510NIOInputPort1 + 5, "p1 fire 2" },
150 {"Nitro" , BIT_DIGITAL , TC0510NIOInputPort1 + 0, "p1 fire 3" },
151 {"Gear" , BIT_DIGITAL , TC0510NIOInputPort0 + 1, "p1 fire 4" },
152 {"Reverse" , BIT_DIGITAL , TC0510NIOInputPort0 + 7, "p1 fire 5" },
153 {"Centre" , BIT_DIGITAL , TC0510NIOInputPort1 + 2, "p1 fire 6" },
154
155 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
156 {"Service" , BIT_DIGITAL , TC0510NIOInputPort0 + 4, "service" },
157 {"Tilt" , BIT_DIGITAL , TC0510NIOInputPort1 + 1, "tilt" },
158 {"Dip 1" , BIT_DIPSWITCH , TC0510NIODip + 0 , "dip" },
159 {"Dip 2" , BIT_DIPSWITCH , TC0510NIODip + 1 , "dip" },
160 };
161
162 STDINPUTINFO(Dblaxle)
163
164 static struct BurnInputInfo EnforceInputList[] =
165 {
166 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "p1 coin" },
167 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort1 + 3, "p1 start" },
168 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "p2 coin" },
169
170 {"Up" , BIT_DIGITAL , TC0220IOCInputPort0 + 5, "p1 up" },
171 {"Down" , BIT_DIGITAL , TC0220IOCInputPort0 + 6, "p1 down" },
172 {"Left" , BIT_DIGITAL , TC0220IOCInputPort0 + 7, "p1 left" },
173 {"Right" , BIT_DIGITAL , TC0220IOCInputPort1 + 7, "p1 right" },
174 {"Laser" , BIT_DIGITAL , TC0220IOCInputPort1 + 0, "p1 fire 1" },
175 {"Bomb" , BIT_DIGITAL , TC0220IOCInputPort1 + 1, "p1 fire 2" },
176
177 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
178 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "service" },
179 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort1 + 2, "tilt" },
180 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
181 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
182 };
183
184 STDINPUTINFO(Enforce)
185
186 static struct BurnInputInfo NightstrInputList[] =
187 {
188 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 5, "p1 coin" },
189 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 0, "p1 start" },
190 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "p2 coin" },
191 {"Start 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 1, "p2 start" },
192
193 A("Stick X" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
194 A("Stick Y" , BIT_ANALOG_REL, &TaitoAnalogPort1 , "p1 y-axis" ),
195 {"Fire 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 6, "p1 fire 1" },
196 {"Fire 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 7, "p1 fire 2" },
197
198 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
199 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 6, "service" },
200 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort0 + 7, "tilt" },
201 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
202 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
203 };
204
205 STDINPUTINFO(Nightstr)
206
207 static struct BurnInputInfo RacingbInputList[] =
208 {
209 {"Coin 1" , BIT_DIGITAL , TC0510NIOInputPort0 + 2, "p1 coin" },
210 {"Start 1" , BIT_DIGITAL , TC0510NIOInputPort1 + 3, "p1 start" },
211 {"Coin 2" , BIT_DIGITAL , TC0510NIOInputPort0 + 3, "p2 coin" },
212
213 A("Steering" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
214 {"Brake" , BIT_DIGITAL , TC0510NIOInputPort0 + 5, "p1 fire 1" },
215 {"Accelerate" , BIT_DIGITAL , TC0510NIOInputPort1 + 5, "p1 fire 2" },
216 {"Pit In" , BIT_DIGITAL , TC0510NIOInputPort1 + 0, "p1 fire 3" },
217 {"Gear" , BIT_DIGITAL , TC0510NIOInputPort0 + 1, "p1 fire 4" },
218 {"Centre" , BIT_DIGITAL , TC0510NIOInputPort1 + 2, "p1 fire 5" },
219
220 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
221 {"Service" , BIT_DIGITAL , TC0510NIOInputPort0 + 4, "service" },
222 {"Dip 1" , BIT_DIPSWITCH , TC0510NIODip + 0 , "dip" },
223 {"Dip 2" , BIT_DIPSWITCH , TC0510NIODip + 1 , "dip" },
224 };
225
226 STDINPUTINFO(Racingb)
227
228 static struct BurnInputInfo SciInputList[] =
229 {
230 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "p1 coin" },
231 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort1 + 3, "p1 start" },
232 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "p2 coin" },
233
234 A("Steering" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "p1 x-axis" ),
235 {"Brake" , BIT_DIGITAL , TC0220IOCInputPort0 + 5, "p1 fire 1" },
236 {"Accelerate" , BIT_DIGITAL , TC0220IOCInputPort1 + 5, "p1 fire 2" },
237 {"Fire" , BIT_DIGITAL , TC0220IOCInputPort0 + 1, "p1 fire 3" },
238 {"Turbo" , BIT_DIGITAL , TC0220IOCInputPort1 + 0, "p1 fire 4" },
239 {"Gear" , BIT_DIGITAL , TC0220IOCInputPort1 + 4, "p1 fire 5" },
240 {"Centre" , BIT_DIGITAL , TC0220IOCInputPort1 + 2, "p1 fire 6" },
241
242 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
243 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "service" },
244 {"Tilt" , BIT_DIGITAL , TC0220IOCInputPort1 + 1, "tilt" },
245 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
246 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
247 };
248
249 STDINPUTINFO(Sci)
250
251 static struct BurnInputInfo SpacegunInputList[] =
252 {
253 {"Coin 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 3, "p1 coin" },
254 {"Start 1" , BIT_DIGITAL , TC0220IOCInputPort0 + 6, "p1 start" },
255 {"Coin 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 2, "p2 coin" },
256 {"Start 2" , BIT_DIGITAL , TC0220IOCInputPort0 + 7, "p2 start" },
257
258 A("P1 Gun X" , BIT_ANALOG_REL, &TaitoAnalogPort0 , "mouse x-axis" ),
259 A("P1 Gun Y" , BIT_ANALOG_REL, &TaitoAnalogPort1 , "mouse y-axis" ),
260 {"P1 Fire 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 0, "mouse button 1" },
261 {"P1 Fire 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 2, "mouse button 2" },
262 {"P1 Fire 3" , BIT_DIGITAL , TC0220IOCInputPort0 + 0, "p1 fire 1" },
263
264 A("P2 Gun X" , BIT_ANALOG_REL, &TaitoAnalogPort2 , "p2 x-axis" ),
265 A("P2 Gun Y" , BIT_ANALOG_REL, &TaitoAnalogPort3 , "p2 y-axis" ),
266 {"P2 Fire 1" , BIT_DIGITAL , TC0220IOCInputPort2 + 1, "p2 fire 1" },
267 {"P2 Fire 2" , BIT_DIGITAL , TC0220IOCInputPort2 + 3, "p2 fire 2" },
268 {"P2 Fire 3" , BIT_DIGITAL , TC0220IOCInputPort0 + 1, "p2 fire 3" },
269
270 {"Reset" , BIT_DIGITAL , &TaitoReset , "reset" },
271 {"Service" , BIT_DIGITAL , TC0220IOCInputPort0 + 4, "service" },
272 {"Dip 1" , BIT_DIPSWITCH , TC0220IOCDip + 0 , "dip" },
273 {"Dip 2" , BIT_DIPSWITCH , TC0220IOCDip + 1 , "dip" },
274 };
275
STDINPUTINFO(Spacegun)276 STDINPUTINFO(Spacegun)
277
278 #undef A
279
280 static void AquajackMakeInputs()
281 {
282 // Reset Inputs
283 TC0220IOCInput[0] = 0xff;
284 TC0220IOCInput[1] = 0xff;
285 TC0220IOCInput[2] = 0xff;
286
287 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
288 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
289 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] -= 0x04;
290 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] -= 0x08;
291 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
292 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
293 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
294 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
295
296 if (TC0220IOCInputPort1[0]) TC0220IOCInput[1] -= 0x01;
297 if (TC0220IOCInputPort1[1]) TC0220IOCInput[1] -= 0x02;
298 if (TC0220IOCInputPort1[2]) TC0220IOCInput[1] -= 0x04;
299 if (TC0220IOCInputPort1[3]) TC0220IOCInput[1] -= 0x08;
300 if (TC0220IOCInputPort1[4]) TC0220IOCInput[1] -= 0x10;
301 if (TC0220IOCInputPort1[5]) TC0220IOCInput[1] -= 0x20;
302 if (TC0220IOCInputPort1[6]) TC0220IOCInput[1] -= 0x40;
303 if (TC0220IOCInputPort1[7]) TC0220IOCInput[1] -= 0x80;
304 }
305
BsharkMakeInputs()306 static void BsharkMakeInputs()
307 {
308 // Reset Inputs
309 TC0220IOCInput[0] = 0xff;
310 TC0220IOCInput[1] = 0xff;
311 TC0220IOCInput[2] = 0xff;
312
313 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
314 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
315 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] -= 0x04;
316 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] -= 0x08;
317 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
318 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
319 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
320 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
321
322 if (TC0220IOCInputPort2[0]) TC0220IOCInput[2] -= 0x01;
323 if (TC0220IOCInputPort2[1]) TC0220IOCInput[2] -= 0x02;
324 if (TC0220IOCInputPort2[2]) TC0220IOCInput[2] -= 0x04;
325 if (TC0220IOCInputPort2[3]) TC0220IOCInput[2] -= 0x08;
326 if (TC0220IOCInputPort2[4]) TC0220IOCInput[2] -= 0x10;
327 if (TC0220IOCInputPort2[5]) TC0220IOCInput[2] -= 0x20;
328 if (TC0220IOCInputPort2[6]) TC0220IOCInput[2] -= 0x40;
329 if (TC0220IOCInputPort2[7]) TC0220IOCInput[2] -= 0x80;
330 }
331
ChasehqMakeInputs()332 static void ChasehqMakeInputs()
333 {
334 // Reset Inputs
335 TC0220IOCInput[0] = 0xf3;
336 TC0220IOCInput[1] = 0xef;
337 TC0220IOCInput[2] = 0xff;
338
339 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
340 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
341 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] |= 0x04;
342 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] |= 0x08;
343 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
344 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
345 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
346 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
347
348 if (TC0220IOCInputPort1[0]) TC0220IOCInput[1] -= 0x01;
349 if (TC0220IOCInputPort1[1]) TC0220IOCInput[1] -= 0x02;
350 if (TC0220IOCInputPort1[2]) TC0220IOCInput[1] -= 0x04;
351 if (TC0220IOCInputPort1[3]) TC0220IOCInput[1] -= 0x08;
352 TC0220IOCInput[1] |= (BurnShiftInputCheckToggle(TC0220IOCInputPort1[4]) ? 0x00 : 0x10);
353 if (TC0220IOCInputPort1[5]) TC0220IOCInput[1] -= 0x20;
354 if (TC0220IOCInputPort1[6]) TC0220IOCInput[1] -= 0x40;
355 if (TC0220IOCInputPort1[7]) TC0220IOCInput[1] -= 0x80;
356 }
357
ContcircMakeInputs()358 static void ContcircMakeInputs()
359 {
360 // Reset Inputs
361 TC0220IOCInput[0] = 0x13;
362 TC0220IOCInput[1] = 0x0f;
363 TC0220IOCInput[2] = 0xff;
364
365 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
366 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
367 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] |= 0x04;
368 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] |= 0x08;
369 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
370 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] |= 0x20;
371 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] |= 0x40;
372 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] |= 0x80;
373
374 if (TC0220IOCInputPort1[0]) TC0220IOCInput[1] -= 0x01;
375 if (TC0220IOCInputPort1[1]) TC0220IOCInput[1] -= 0x02;
376 if (TC0220IOCInputPort1[2]) TC0220IOCInput[1] -= 0x04;
377 if (TC0220IOCInputPort1[3]) TC0220IOCInput[1] -= 0x08;
378 TC0220IOCInput[1] |= (BurnShiftInputCheckToggle(TC0220IOCInputPort1[4]) ? 0x00 : 0x10);
379 if (TC0220IOCInputPort1[5]) TC0220IOCInput[1] |= 0x20;
380 if (TC0220IOCInputPort1[6]) TC0220IOCInput[1] |= 0x40;
381 if (TC0220IOCInputPort1[7]) TC0220IOCInput[1] |= 0x80;
382 }
383
DblaxleMakeInputs()384 static void DblaxleMakeInputs() // and racingb
385 {
386 // Reset Inputs
387 TC0510NIOInput[0] = 0xff;
388 TC0510NIOInput[1] = 0xff;
389 TC0510NIOInput[2] = 0xff;
390
391 if (TC0510NIOInputPort0[0]) TC0510NIOInput[0] -= 0x01;
392 TC0510NIOInput[0] -= (BurnShiftInputCheckToggle(TC0510NIOInputPort0[1]) ? 0x00 : 0x02);
393 if (TC0510NIOInputPort0[2]) TC0510NIOInput[0] -= 0x04;
394 if (TC0510NIOInputPort0[3]) TC0510NIOInput[0] -= 0x08;
395 if (TC0510NIOInputPort0[4]) TC0510NIOInput[0] -= 0x10;
396 if (TC0510NIOInputPort0[5]) TC0510NIOInput[0] -= 0x20;
397 if (TC0510NIOInputPort0[6]) TC0510NIOInput[0] -= 0x40;
398 if (TC0510NIOInputPort0[7]) TC0510NIOInput[0] -= 0x80;
399
400 if (TC0510NIOInputPort1[0]) TC0510NIOInput[1] -= 0x01;
401 if (TC0510NIOInputPort1[1]) TC0510NIOInput[1] -= 0x02;
402 if (TC0510NIOInputPort1[2]) TC0510NIOInput[1] -= 0x04;
403 if (TC0510NIOInputPort1[3]) TC0510NIOInput[1] -= 0x08;
404 if (TC0510NIOInputPort1[4]) TC0510NIOInput[1] -= 0x10;
405 if (TC0510NIOInputPort1[5]) TC0510NIOInput[1] -= 0x20;
406 if (TC0510NIOInputPort1[6]) TC0510NIOInput[1] -= 0x40;
407 if (TC0510NIOInputPort1[7]) TC0510NIOInput[1] -= 0x80;
408 }
409
EnforceMakeInputs()410 static void EnforceMakeInputs()
411 {
412 // Reset Inputs
413 TC0220IOCInput[0] = 0xf3;
414 TC0220IOCInput[1] = 0xff;
415 TC0220IOCInput[2] = 0xff;
416
417 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
418 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
419 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] |= 0x04;
420 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] |= 0x08;
421 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
422 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
423 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
424 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
425
426 if (TC0220IOCInputPort1[0]) TC0220IOCInput[1] -= 0x01;
427 if (TC0220IOCInputPort1[1]) TC0220IOCInput[1] -= 0x02;
428 if (TC0220IOCInputPort1[2]) TC0220IOCInput[1] -= 0x04;
429 if (TC0220IOCInputPort1[3]) TC0220IOCInput[1] -= 0x08;
430 if (TC0220IOCInputPort1[4]) TC0220IOCInput[1] -= 0x10;
431 if (TC0220IOCInputPort1[5]) TC0220IOCInput[1] -= 0x20;
432 if (TC0220IOCInputPort1[6]) TC0220IOCInput[1] -= 0x40;
433 if (TC0220IOCInputPort1[7]) TC0220IOCInput[1] -= 0x80;
434 }
435
NightstrMakeInputs()436 static void NightstrMakeInputs()
437 {
438 // Reset Inputs
439 TC0220IOCInput[0] = 0xff;
440 TC0220IOCInput[1] = 0xff;
441 TC0220IOCInput[2] = 0xff;
442
443 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
444 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
445 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] -= 0x04;
446 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] -= 0x08;
447 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
448 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
449 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
450 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
451
452 if (TC0220IOCInputPort2[0]) TC0220IOCInput[2] -= 0x01;
453 if (TC0220IOCInputPort2[1]) TC0220IOCInput[2] -= 0x02;
454 if (TC0220IOCInputPort2[2]) TC0220IOCInput[2] -= 0x04;
455 if (TC0220IOCInputPort2[3]) TC0220IOCInput[2] -= 0x08;
456 if (TC0220IOCInputPort2[4]) TC0220IOCInput[2] -= 0x10;
457 if (TC0220IOCInputPort2[5]) TC0220IOCInput[2] -= 0x20;
458 if (TC0220IOCInputPort2[6]) TC0220IOCInput[2] -= 0x40;
459 if (TC0220IOCInputPort2[7]) TC0220IOCInput[2] -= 0x80;
460 }
461
SciMakeInputs()462 static void SciMakeInputs()
463 {
464 // Reset Inputs
465 TC0220IOCInput[0] = 0xff;
466 TC0220IOCInput[1] = 0xef;
467 TC0220IOCInput[2] = 0xff;
468
469 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
470 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
471 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] -= 0x04;
472 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] -= 0x08;
473 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
474 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
475 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
476 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
477
478 if (TC0220IOCInputPort1[0]) TC0220IOCInput[1] -= 0x01;
479 if (TC0220IOCInputPort1[1]) TC0220IOCInput[1] -= 0x02;
480 if (TC0220IOCInputPort1[2]) TC0220IOCInput[1] -= 0x04;
481 if (TC0220IOCInputPort1[3]) TC0220IOCInput[1] -= 0x08;
482 TC0220IOCInput[1] |= (BurnShiftInputCheckToggle(TC0220IOCInputPort1[4]) ? 0x00 : 0x10);
483 if (TC0220IOCInputPort1[5]) TC0220IOCInput[1] -= 0x20;
484 if (TC0220IOCInputPort1[6]) TC0220IOCInput[1] -= 0x40;
485 if (TC0220IOCInputPort1[7]) TC0220IOCInput[1] -= 0x80;
486 }
487
SpacegunMakeInputs()488 static void SpacegunMakeInputs()
489 {
490 // Reset Inputs
491 TC0220IOCInput[0] = 0xff;
492 TC0220IOCInput[1] = 0xff;
493 TC0220IOCInput[2] = 0xff;
494
495 if (TC0220IOCInputPort0[0]) TC0220IOCInput[0] -= 0x01;
496 if (TC0220IOCInputPort0[1]) TC0220IOCInput[0] -= 0x02;
497 if (TC0220IOCInputPort0[2]) TC0220IOCInput[0] -= 0x04;
498 if (TC0220IOCInputPort0[3]) TC0220IOCInput[0] -= 0x08;
499 if (TC0220IOCInputPort0[4]) TC0220IOCInput[0] -= 0x10;
500 if (TC0220IOCInputPort0[5]) TC0220IOCInput[0] -= 0x20;
501 if (TC0220IOCInputPort0[6]) TC0220IOCInput[0] -= 0x40;
502 if (TC0220IOCInputPort0[7]) TC0220IOCInput[0] -= 0x80;
503
504 if (TC0220IOCInputPort2[0]) TC0220IOCInput[2] -= 0x01;
505 if (TC0220IOCInputPort2[1]) TC0220IOCInput[2] -= 0x02;
506 if (TC0220IOCInputPort2[2]) TC0220IOCInput[2] -= 0x04;
507 if (TC0220IOCInputPort2[3]) TC0220IOCInput[2] -= 0x08;
508 if (TC0220IOCInputPort2[4]) TC0220IOCInput[2] -= 0x10;
509 if (TC0220IOCInputPort2[5]) TC0220IOCInput[2] -= 0x20;
510 if (TC0220IOCInputPort2[6]) TC0220IOCInput[2] -= 0x40;
511 if (TC0220IOCInputPort2[7]) TC0220IOCInput[2] -= 0x80;
512
513 BurnGunMakeInputs(0, (INT16)TaitoAnalogPort0, (INT16)TaitoAnalogPort1);
514 BurnGunMakeInputs(1, (INT16)TaitoAnalogPort2, (INT16)TaitoAnalogPort3);
515 }
516
517 static struct BurnDIPInfo AquajackDIPList[]=
518 {
519 // Default Values
520 {0x0e, 0xff, 0xff, 0x7f, NULL },
521 {0x0f, 0xff, 0xff, 0xff, NULL },
522
523 // Dip 1
524 {0 , 0xfe, 0 , 2 , "Cabinet" },
525 {0x0e, 0x01, 0x80, 0x80, "Cockpit" },
526 {0x0e, 0x01, 0x80, 0x00, "Upright" },
527
528 {0 , 0xfe, 0 , 2 , "Service Mode" },
529 {0x0e, 0x01, 0x20, 0x20, "Off" },
530 {0x0e, 0x01, 0x20, 0x00, "On" },
531
532 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
533 {0x0e, 0x01, 0x10, 0x00, "Off" },
534 {0x0e, 0x01, 0x10, 0x10, "On" },
535
536 {0 , 0xfe, 0 , 4 , "Coin A" },
537 {0x0e, 0x01, 0x0c, 0x00, "4 Coins 1 Credit" },
538 {0x0e, 0x01, 0x0c, 0x08, "3 Coins 1 Credit" },
539 {0x0e, 0x01, 0x0c, 0x04, "2 Coins 1 Credit" },
540 {0x0e, 0x01, 0x0c, 0x0c, "1 Coin 1 Credit" },
541
542 {0 , 0xfe, 0 , 4 , "Coin B" },
543 {0x0e, 0x01, 0x03, 0x03, "1 Coin 2 Credits" },
544 {0x0e, 0x01, 0x03, 0x01, "1 Coin 3 Credits" },
545 {0x0e, 0x01, 0x03, 0x02, "1 Coin 4 Credits" },
546 {0x0e, 0x01, 0x03, 0x00, "1 Coin 6 Credits" },
547
548 // Dip 2
549 {0 , 0xfe, 0 , 4 , "Difficulty" },
550 {0x0f, 0x01, 0xc0, 0x40, "Easy" },
551 {0x0f, 0x01, 0xc0, 0xc0, "Normal" },
552 {0x0f, 0x01, 0xc0, 0x80, "Hard" },
553 {0x0f, 0x01, 0xc0, 0x00, "Hardest" },
554
555 {0 , 0xfe, 0 , 4 , "Bonus Life" },
556 {0x0f, 0x01, 0x30, 0x00, "30000" },
557 {0x0f, 0x01, 0x30, 0x30, "50000" },
558 {0x0f, 0x01, 0x30, 0x10, "80000" },
559 {0x0f, 0x01, 0x30, 0x20, "100000" },
560
561 {0 , 0xfe, 0 , 4 , "Lives" },
562 {0x0f, 0x01, 0x0c, 0x08, "1" },
563 {0x0f, 0x01, 0x0c, 0x04, "2" },
564 {0x0f, 0x01, 0x0c, 0x0c, "3" },
565 {0x0f, 0x01, 0x0c, 0x00, "5" },
566 };
567
568 STDDIPINFO(Aquajack)
569
570 static struct BurnDIPInfo AquajackjDIPList[]=
571 {
572 // Default Values
573 {0x0e, 0xff, 0xff, 0x7f, NULL },
574 {0x0f, 0xff, 0xff, 0xff, NULL },
575
576 // Dip 1
577 {0 , 0xfe, 0 , 2 , "Cabinet" },
578 {0x0e, 0x01, 0x80, 0x80, "Cockpit" },
579 {0x0e, 0x01, 0x80, 0x00, "Upright" },
580
581 {0 , 0xfe, 0 , 2 , "Service Mode" },
582 {0x0e, 0x01, 0x20, 0x20, "Off" },
583 {0x0e, 0x01, 0x20, 0x00, "On" },
584
585 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
586 {0x0e, 0x01, 0x10, 0x00, "Off" },
587 {0x0e, 0x01, 0x10, 0x10, "On" },
588
589 {0 , 0xfe, 0 , 4 , "Coin A" },
590 {0x0e, 0x01, 0x0c, 0x08, "2 Coins 1 Credit" },
591 {0x0e, 0x01, 0x0c, 0x0c, "1 Coin 1 Credit" },
592 {0x0e, 0x01, 0x0c, 0x00, "2 Coins 3 Credits" },
593 {0x0e, 0x01, 0x0c, 0x04, "1 Coin 2 Credits" },
594
595 {0 , 0xfe, 0 , 4 , "Coin B" },
596 {0x0e, 0x01, 0x03, 0x02, "2 Coins 1 Credit" },
597 {0x0e, 0x01, 0x03, 0x03, "1 Coin 1 Credit" },
598 {0x0e, 0x01, 0x03, 0x00, "2 Coins 3 Credits" },
599 {0x0e, 0x01, 0x03, 0x01, "1 Coin 2 Credits" },
600
601 // Dip 2
602 {0 , 0xfe, 0 , 4 , "Difficulty" },
603 {0x0f, 0x01, 0xc0, 0x40, "Easy" },
604 {0x0f, 0x01, 0xc0, 0xc0, "Normal" },
605 {0x0f, 0x01, 0xc0, 0x80, "Hard" },
606 {0x0f, 0x01, 0xc0, 0x00, "Hardest" },
607
608 {0 , 0xfe, 0 , 4 , "Bonus Life" },
609 {0x0f, 0x01, 0x30, 0x00, "30000" },
610 {0x0f, 0x01, 0x30, 0x30, "50000" },
611 {0x0f, 0x01, 0x30, 0x10, "80000" },
612 {0x0f, 0x01, 0x30, 0x20, "100000" },
613
614 {0 , 0xfe, 0 , 4 , "Lives" },
615 {0x0f, 0x01, 0x0c, 0x08, "1" },
616 {0x0f, 0x01, 0x0c, 0x04, "2" },
617 {0x0f, 0x01, 0x0c, 0x0c, "3" },
618 {0x0f, 0x01, 0x0c, 0x00, "5" },
619 };
620
621 STDDIPINFO(Aquajackj)
622
623 static struct BurnDIPInfo BsharkDIPList[]=
624 {
625 // Default Values
626 {0x0b, 0xff, 0xff, 0xff, NULL },
627 {0x0c, 0xff, 0xff, 0xf7, NULL },
628
629 // Dip 1
630 {0 , 0xfe, 0 , 2 , "Mirror Screen" },
631 {0x0b, 0x01, 0x01, 0x01, "Off" },
632 {0x0b, 0x01, 0x01, 0x00, "On" },
633
634 {0 , 0xfe, 0 , 2 , "Service Mode" },
635 {0x0b, 0x01, 0x04, 0x04, "Off" },
636 {0x0b, 0x01, 0x04, 0x00, "On" },
637
638 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
639 {0x0b, 0x01, 0x08, 0x00, "Off" },
640 {0x0b, 0x01, 0x08, 0x08, "On" },
641
642 {0 , 0xfe, 0 , 4 , "Coin A" },
643 {0x0b, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
644 {0x0b, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
645 {0x0b, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
646 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
647
648 {0 , 0xfe, 0 , 4 , "Coin B" },
649 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
650 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
651 {0x0b, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
652 {0x0b, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
653
654 // Dip 2
655 {0 , 0xfe, 0 , 4 , "Difficulty" },
656 {0x0c, 0x01, 0x03, 0x02, "Easy" },
657 {0x0c, 0x01, 0x03, 0x03, "Normal" },
658 {0x0c, 0x01, 0x03, 0x01, "Hard" },
659 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
660
661 {0 , 0xfe, 0 , 4 , "Speed of Sight" },
662 {0x0c, 0x01, 0x0c, 0x0c, "Slow" },
663 {0x0c, 0x01, 0x0c, 0x08, "Medium" },
664 {0x0c, 0x01, 0x0c, 0x04, "Fast" },
665 {0x0c, 0x01, 0x0c, 0x00, "Fastest" },
666 };
667
668 STDDIPINFO(Bshark)
669
670 static struct BurnDIPInfo BsharkjDIPList[]=
671 {
672 // Default Values
673 {0x0b, 0xff, 0xff, 0xff, NULL },
674 {0x0c, 0xff, 0xff, 0xf7, NULL },
675
676 // Dip 1
677 {0 , 0xfe, 0 , 2 , "Mirror Screen" },
678 {0x0b, 0x01, 0x01, 0x01, "Off" },
679 {0x0b, 0x01, 0x01, 0x00, "On" },
680
681 {0 , 0xfe, 0 , 2 , "Service Mode" },
682 {0x0b, 0x01, 0x04, 0x04, "Off" },
683 {0x0b, 0x01, 0x04, 0x00, "On" },
684
685 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
686 {0x0b, 0x01, 0x08, 0x00, "Off" },
687 {0x0b, 0x01, 0x08, 0x08, "On" },
688
689 {0 , 0xfe, 0 , 4 , "Coin A" },
690 {0x0b, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
691 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
692 {0x0b, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
693 {0x0b, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
694
695 {0 , 0xfe, 0 , 4 , "Coin B" },
696 {0x0b, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
697 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
698 {0x0b, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
699 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
700
701 // Dip 2
702 {0 , 0xfe, 0 , 4 , "Difficulty" },
703 {0x0c, 0x01, 0x03, 0x02, "Easy" },
704 {0x0c, 0x01, 0x03, 0x03, "Normal" },
705 {0x0c, 0x01, 0x03, 0x01, "Hard" },
706 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
707
708 {0 , 0xfe, 0 , 4 , "Speed of Sight" },
709 {0x0c, 0x01, 0x0c, 0x0c, "Slow" },
710 {0x0c, 0x01, 0x0c, 0x08, "Medium" },
711 {0x0c, 0x01, 0x0c, 0x04, "Fast" },
712 {0x0c, 0x01, 0x0c, 0x00, "Fastest" },
713 };
714
715 STDDIPINFO(Bsharkj)
716
717 static struct BurnDIPInfo BsharkjjsDIPList[]=
718 {
719 // Default Values
720 {0x0d, 0xff, 0xff, 0xff, NULL },
721 {0x0e, 0xff, 0xff, 0xf7, NULL },
722
723 // Dip 1
724 {0 , 0xfe, 0 , 2 , "Mirror Screen" },
725 {0x0d, 0x01, 0x01, 0x01, "Off" },
726 {0x0d, 0x01, 0x01, 0x00, "On" },
727
728 {0 , 0xfe, 0 , 2 , "Service Mode" },
729 {0x0d, 0x01, 0x04, 0x04, "Off" },
730 {0x0d, 0x01, 0x04, 0x00, "On" },
731
732 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
733 {0x0d, 0x01, 0x08, 0x00, "Off" },
734 {0x0d, 0x01, 0x08, 0x08, "On" },
735
736 {0 , 0xfe, 0 , 4 , "Coin A" },
737 {0x0d, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
738 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
739 {0x0d, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
740 {0x0d, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
741
742 {0 , 0xfe, 0 , 4 , "Coin B" },
743 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
744 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
745 {0x0d, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
746 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
747
748 // Dip 2
749 {0 , 0xfe, 0 , 4 , "Difficulty" },
750 {0x0e, 0x01, 0x03, 0x02, "Easy" },
751 {0x0e, 0x01, 0x03, 0x03, "Normal" },
752 {0x0e, 0x01, 0x03, 0x01, "Hard" },
753 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
754
755 {0 , 0xfe, 0 , 4 , "Speed of Sight" },
756 {0x0e, 0x01, 0x0c, 0x0c, "Slow" },
757 {0x0e, 0x01, 0x0c, 0x08, "Medium" },
758 {0x0e, 0x01, 0x0c, 0x04, "Fast" },
759 {0x0e, 0x01, 0x0c, 0x00, "Fastest" },
760 };
761
762 STDDIPINFO(Bsharkjjs)
763
764 static struct BurnDIPInfo BsharkuDIPList[]=
765 {
766 // Default Values
767 {0x0b, 0xff, 0xff, 0xff, NULL },
768 {0x0c, 0xff, 0xff, 0xf7, NULL },
769
770 // Dip 1
771 {0 , 0xfe, 0 , 2 , "Mirror Screen" },
772 {0x0b, 0x01, 0x01, 0x01, "Off" },
773 {0x0b, 0x01, 0x01, 0x00, "On" },
774
775 {0 , 0xfe, 0 , 2 , "Service Mode" },
776 {0x0b, 0x01, 0x04, 0x04, "Off" },
777 {0x0b, 0x01, 0x04, 0x00, "On" },
778
779 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
780 {0x0b, 0x01, 0x08, 0x00, "Off" },
781 {0x0b, 0x01, 0x08, 0x08, "On" },
782
783 {0 , 0xfe, 0 , 4 , "Coinage" },
784 {0x0b, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
785 {0x0b, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
786 {0x0b, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
787 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
788
789 {0 , 0xfe, 0 , 4 , "Price to Continue" },
790 {0x0b, 0x01, 0xc0, 0x00, "3 Coins 1 Credit" },
791 {0x0b, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
792 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 1 Credit" },
793 {0x0b, 0x01, 0xc0, 0xc0, "Same as Start" },
794
795 // Dip 2
796 {0 , 0xfe, 0 , 4 , "Difficulty" },
797 {0x0c, 0x01, 0x03, 0x02, "Easy" },
798 {0x0c, 0x01, 0x03, 0x03, "Normal" },
799 {0x0c, 0x01, 0x03, 0x01, "Hard" },
800 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
801
802 {0 , 0xfe, 0 , 4 , "Speed of Sight" },
803 {0x0c, 0x01, 0x0c, 0x0c, "Slow" },
804 {0x0c, 0x01, 0x0c, 0x08, "Medium" },
805 {0x0c, 0x01, 0x0c, 0x04, "Fast" },
806 {0x0c, 0x01, 0x0c, 0x00, "Fastest" },
807 };
808
809 STDDIPINFO(Bsharku)
810
811 static struct BurnDIPInfo ChasehqDIPList[]=
812 {
813 // Default Values
814 {0x0b, 0xff, 0xff, 0xff, NULL },
815 {0x0c, 0xff, 0xff, 0xff, NULL },
816
817 // Dip 1
818 {0 , 0xfe, 0 , 4 , "Cabinet" },
819 {0x0b, 0x01, 0x03, 0x03, "Upright / Steering Lock" },
820 {0x0b, 0x01, 0x03, 0x02, "Upright / No Steering Lock" },
821 {0x0b, 0x01, 0x03, 0x01, "Full Throttle Convert, Cockpit" },
822 {0x0b, 0x01, 0x03, 0x00, "Full Throttle Convert, Deluxe" },
823
824 {0 , 0xfe, 0 , 2 , "Service Mode" },
825 {0x0b, 0x01, 0x04, 0x04, "Off" },
826 {0x0b, 0x01, 0x04, 0x00, "On" },
827
828 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
829 {0x0b, 0x01, 0x08, 0x00, "Off" },
830 {0x0b, 0x01, 0x08, 0x08, "On" },
831
832 {0 , 0xfe, 0 , 4 , "Coin A" },
833 {0x0b, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
834 {0x0b, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
835 {0x0b, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
836 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
837
838 {0 , 0xfe, 0 , 4 , "Coin B" },
839 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
840 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
841 {0x0b, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
842 {0x0b, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
843
844 // Dip 2
845 {0 , 0xfe, 0 , 4 , "Difficulty" },
846 {0x0c, 0x01, 0x03, 0x02, "Easy" },
847 {0x0c, 0x01, 0x03, 0x03, "Normal" },
848 {0x0c, 0x01, 0x03, 0x01, "Hard" },
849 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
850
851 {0 , 0xfe, 0 , 4 , "Timer Setting" },
852 {0x0c, 0x01, 0x0c, 0x08, "70 Seconds" },
853 {0x0c, 0x01, 0x0c, 0x04, "65 Seconds" },
854 {0x0c, 0x01, 0x0c, 0x0c, "60 Seconds" },
855 {0x0c, 0x01, 0x0c, 0x00, "55 Seconds" },
856
857 {0 , 0xfe, 0 , 2 , "Turbos Stocked" },
858 {0x0c, 0x01, 0x10, 0x10, "3" },
859 {0x0c, 0x01, 0x10, 0x00, "5" },
860
861 {0 , 0xfe, 0 , 2 , "Discounted Continue Play" },
862 {0x0c, 0x01, 0x20, 0x20, "Off" },
863 {0x0c, 0x01, 0x20, 0x00, "On" },
864
865 {0 , 0xfe, 0 , 2 , "Damage Cleared at Continue" },
866 {0x0c, 0x01, 0x40, 0x00, "Off" },
867 {0x0c, 0x01, 0x40, 0x40, "On" },
868
869 {0 , 0xfe, 0 , 2 , "Allow Continue" },
870 {0x0c, 0x01, 0x80, 0x00, "Off" },
871 {0x0c, 0x01, 0x80, 0x80, "On" },
872 };
873
874 STDDIPINFO(Chasehq)
875
876 static struct BurnDIPInfo ChasehqjDIPList[]=
877 {
878 // Default Values
879 {0x0b, 0xff, 0xff, 0xff, NULL },
880 {0x0c, 0xff, 0xff, 0xff, NULL },
881
882 // Dip 1
883 {0 , 0xfe, 0 , 4 , "Cabinet" },
884 {0x0b, 0x01, 0x03, 0x03, "Upright / Steering Lock" },
885 {0x0b, 0x01, 0x03, 0x02, "Upright / No Steering Lock" },
886 {0x0b, 0x01, 0x03, 0x01, "Full Throttle Convert, Cockpit" },
887 {0x0b, 0x01, 0x03, 0x00, "Full Throttle Convert, Deluxe" },
888
889 {0 , 0xfe, 0 , 2 , "Service Mode" },
890 {0x0b, 0x01, 0x04, 0x04, "Off" },
891 {0x0b, 0x01, 0x04, 0x00, "On" },
892
893 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
894 {0x0b, 0x01, 0x08, 0x00, "Off" },
895 {0x0b, 0x01, 0x08, 0x08, "On" },
896
897 {0 , 0xfe, 0 , 4 , "Coin A" },
898 {0x0b, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
899 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
900 {0x0b, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
901 {0x0b, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
902
903 {0 , 0xfe, 0 , 4 , "Coin B" },
904 {0x0b, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
905 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
906 {0x0b, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
907 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
908
909 // Dip 2
910 {0 , 0xfe, 0 , 4 , "Difficulty" },
911 {0x0c, 0x01, 0x03, 0x02, "Easy" },
912 {0x0c, 0x01, 0x03, 0x03, "Normal" },
913 {0x0c, 0x01, 0x03, 0x01, "Hard" },
914 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
915
916 {0 , 0xfe, 0 , 4 , "Timer Setting" },
917 {0x0c, 0x01, 0x0c, 0x08, "70 Seconds" },
918 {0x0c, 0x01, 0x0c, 0x04, "65 Seconds" },
919 {0x0c, 0x01, 0x0c, 0x0c, "60 Seconds" },
920 {0x0c, 0x01, 0x0c, 0x00, "55 Seconds" },
921
922 {0 , 0xfe, 0 , 2 , "Turbos Stocked" },
923 {0x0c, 0x01, 0x10, 0x10, "3" },
924 {0x0c, 0x01, 0x10, 0x00, "5" },
925
926 {0 , 0xfe, 0 , 2 , "Discounted Continue Play" },
927 {0x0c, 0x01, 0x20, 0x20, "Off" },
928 {0x0c, 0x01, 0x20, 0x00, "On" },
929
930 {0 , 0xfe, 0 , 2 , "Damage Cleared at Continue" },
931 {0x0c, 0x01, 0x40, 0x00, "Off" },
932 {0x0c, 0x01, 0x40, 0x40, "On" },
933
934 {0 , 0xfe, 0 , 2 , "Allow Continue" },
935 {0x0c, 0x01, 0x80, 0x00, "Off" },
936 {0x0c, 0x01, 0x80, 0x80, "On" },
937 };
938
939 STDDIPINFO(Chasehqj)
940
941 static struct BurnDIPInfo ContcircDIPList[]=
942 {
943 // Default Values
944 {0x0e, 0xff, 0xff, 0xff, NULL },
945 {0x0f, 0xff, 0xff, 0xdf, NULL },
946
947 // Dip 1
948 {0 , 0xfe, 0 , 2 , "Cabinet" },
949 {0x0e, 0x01, 0x01, 0x01, "Upright" },
950 {0x0e, 0x01, 0x01, 0x00, "Cockpit" },
951
952 {0 , 0xfe, 0 , 2 , "Service Mode" },
953 {0x0e, 0x01, 0x04, 0x04, "Off" },
954 {0x0e, 0x01, 0x04, 0x00, "On" },
955
956 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
957 {0x0e, 0x01, 0x08, 0x00, "Off" },
958 {0x0e, 0x01, 0x08, 0x08, "On" },
959
960 {0 , 0xfe, 0 , 4 , "Coin A" },
961 {0x0e, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
962 {0x0e, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
963 {0x0e, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
964 {0x0e, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
965
966 {0 , 0xfe, 0 , 4 , "Coin B" },
967 {0x0e, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
968 {0x0e, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
969 {0x0e, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
970 {0x0e, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
971
972 // Dip 2
973 {0 , 0xfe, 0 , 4 , "Difficulty 1 (time/speed)" },
974 {0x0f, 0x01, 0x03, 0x02, "Easy" },
975 {0x0f, 0x01, 0x03, 0x03, "Normal" },
976 {0x0f, 0x01, 0x03, 0x01, "Hard" },
977 {0x0f, 0x01, 0x03, 0x00, "Hardest" },
978
979 {0 , 0xfe, 0 , 4 , "Difficulty 2 (other cars)" },
980 {0x0f, 0x01, 0x0c, 0x08, "Easy" },
981 {0x0f, 0x01, 0x0c, 0x0c, "Normal" },
982 {0x0f, 0x01, 0x0c, 0x04, "Hard" },
983 {0x0f, 0x01, 0x0c, 0x00, "Hardest" },
984
985 {0 , 0xfe, 0 , 2 , "Steering Wheel" },
986 {0x0f, 0x01, 0x10, 0x10, "Free" },
987 {0x0f, 0x01, 0x10, 0x00, "Locked" },
988
989 {0 , 0xfe, 0 , 2 , "3D Effects" },
990 {0x0f, 0x01, 0x20, 0x00, "Off" },
991 {0x0f, 0x01, 0x20, 0x20, "On" },
992 };
993
994 STDDIPINFO(Contcirc)
995
996 static struct BurnDIPInfo ContcircuDIPList[]=
997 {
998 // Default Values
999 {0x0e, 0xff, 0xff, 0xff, NULL },
1000 {0x0f, 0xff, 0xff, 0xdf, NULL },
1001
1002 // Dip 1
1003 {0 , 0xfe, 0 , 2 , "Cabinet" },
1004 {0x0e, 0x01, 0x01, 0x01, "Upright" },
1005 {0x0e, 0x01, 0x01, 0x00, "Cockpit" },
1006
1007 {0 , 0xfe, 0 , 2 , "Service Mode" },
1008 {0x0e, 0x01, 0x04, 0x04, "Off" },
1009 {0x0e, 0x01, 0x04, 0x00, "On" },
1010
1011 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1012 {0x0e, 0x01, 0x08, 0x00, "Off" },
1013 {0x0e, 0x01, 0x08, 0x08, "On" },
1014
1015 {0 , 0xfe, 0 , 4 , "Coin A" },
1016 {0x0e, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1017 {0x0e, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1018 {0x0e, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1019 {0x0e, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1020
1021 {0 , 0xfe, 0 , 4 , "Coin B" },
1022 {0x0e, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1023 {0x0e, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1024 {0x0e, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1025 {0x0e, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1026
1027 // Dip 2
1028 {0 , 0xfe, 0 , 4 , "Difficulty 1 (time/speed)" },
1029 {0x0f, 0x01, 0x03, 0x02, "Easy" },
1030 {0x0f, 0x01, 0x03, 0x03, "Normal" },
1031 {0x0f, 0x01, 0x03, 0x01, "Hard" },
1032 {0x0f, 0x01, 0x03, 0x00, "Hardest" },
1033
1034 {0 , 0xfe, 0 , 4 , "Difficulty 2 (other cars)" },
1035 {0x0f, 0x01, 0x0c, 0x08, "Easy" },
1036 {0x0f, 0x01, 0x0c, 0x0c, "Normal" },
1037 {0x0f, 0x01, 0x0c, 0x04, "Hard" },
1038 {0x0f, 0x01, 0x0c, 0x00, "Hardest" },
1039
1040 {0 , 0xfe, 0 , 2 , "Steering Wheel" },
1041 {0x0f, 0x01, 0x10, 0x10, "Free" },
1042 {0x0f, 0x01, 0x10, 0x00, "Locked" },
1043
1044 {0 , 0xfe, 0 , 2 , "3D Effects" },
1045 {0x0f, 0x01, 0x20, 0x00, "Off" },
1046 {0x0f, 0x01, 0x20, 0x20, "On" },
1047 };
1048
1049 STDDIPINFO(Contcircu)
1050
1051 static struct BurnDIPInfo ContcircjDIPList[]=
1052 {
1053 // Default Values
1054 {0x0e, 0xff, 0xff, 0xff, NULL },
1055 {0x0f, 0xff, 0xff, 0xdf, NULL },
1056
1057 // Dip 1
1058 {0 , 0xfe, 0 , 2 , "Cabinet" },
1059 {0x0e, 0x01, 0x01, 0x01, "Upright" },
1060 {0x0e, 0x01, 0x01, 0x00, "Cockpit" },
1061
1062 {0 , 0xfe, 0 , 2 , "Service Mode" },
1063 {0x0e, 0x01, 0x04, 0x04, "Off" },
1064 {0x0e, 0x01, 0x04, 0x00, "On" },
1065
1066 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1067 {0x0e, 0x01, 0x08, 0x00, "Off" },
1068 {0x0e, 0x01, 0x08, 0x08, "On" },
1069
1070 {0 , 0xfe, 0 , 4 , "Coin A" },
1071 {0x0e, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1072 {0x0e, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1073 {0x0e, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1074 {0x0e, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1075
1076 {0 , 0xfe, 0 , 4 , "Coin B" },
1077 {0x0e, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1078 {0x0e, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1079 {0x0e, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1080 {0x0e, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1081
1082 // Dip 2
1083 {0 , 0xfe, 0 , 4 , "Difficulty 1 (time/speed)" },
1084 {0x0f, 0x01, 0x03, 0x02, "Easy" },
1085 {0x0f, 0x01, 0x03, 0x03, "Normal" },
1086 {0x0f, 0x01, 0x03, 0x01, "Hard" },
1087 {0x0f, 0x01, 0x03, 0x00, "Hardest" },
1088
1089 {0 , 0xfe, 0 , 4 , "Difficulty 2 (other cars)" },
1090 {0x0f, 0x01, 0x0c, 0x08, "Easy" },
1091 {0x0f, 0x01, 0x0c, 0x0c, "Normal" },
1092 {0x0f, 0x01, 0x0c, 0x04, "Hard" },
1093 {0x0f, 0x01, 0x0c, 0x00, "Hardest" },
1094
1095 {0 , 0xfe, 0 , 2 , "Steering Wheel" },
1096 {0x0f, 0x01, 0x10, 0x10, "Free" },
1097 {0x0f, 0x01, 0x10, 0x00, "Locked" },
1098 };
1099
1100 STDDIPINFO(Contcircj)
1101
1102 static struct BurnDIPInfo DblaxleDIPList[]= // Side by Side linkable versions
1103 {
1104 // Default Values
1105 {0x0d, 0xff, 0xff, 0xff, NULL },
1106 {0x0e, 0xff, 0xff, 0xfb, NULL },
1107
1108 // Dip 1
1109 {0 , 0xfe, 0 , 2 , "Gear Shift" },
1110 {0x0d, 0x01, 0x02, 0x02, "Normal" },
1111 {0x0d, 0x01, 0x02, 0x00, "Inverted" },
1112
1113 {0 , 0xfe, 0 , 2 , "Service Mode" },
1114 {0x0d, 0x01, 0x04, 0x04, "Off" },
1115 {0x0d, 0x01, 0x04, 0x00, "On" },
1116
1117 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1118 {0x0d, 0x01, 0x08, 0x00, "Off" },
1119 {0x0d, 0x01, 0x08, 0x08, "On" },
1120
1121 {0 , 0xfe, 0 , 4 , "Coin A" },
1122 {0x0d, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1123 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1124 {0x0d, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1125 {0x0d, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1126
1127 {0 , 0xfe, 0 , 4 , "Coin B" },
1128 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1129 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1130 {0x0d, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1131 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1132
1133 // Dip 2
1134 {0 , 0xfe, 0 , 4 , "Difficulty" },
1135 {0x0e, 0x01, 0x03, 0x02, "Easy" },
1136 {0x0e, 0x01, 0x03, 0x03, "Normal" },
1137 {0x0e, 0x01, 0x03, 0x01, "Hard" },
1138 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
1139
1140 {0 , 0xfe, 0 , 2 , "Multi-machine hookup" },
1141 {0x0e, 0x01, 0x04, 0x00, "Off" },
1142 {0x0e, 0x01, 0x04, 0x04, "On" },
1143
1144 {0 , 0xfe, 0 , 2 , "Player Truck" },
1145 {0x0e, 0x01, 0x08, 0x08, "Red" },
1146 {0x0e, 0x01, 0x08, 0x00, "Blue" },
1147
1148 {0 , 0xfe, 0 , 2 , "Reverse" },
1149 {0x0e, 0x01, 0x10, 0x10, "Normal" },
1150 {0x0e, 0x01, 0x10, 0x00, "Inverted" },
1151 };
1152
1153 STDDIPINFO(Dblaxle)
1154
1155 static struct BurnDIPInfo DblaxlesDIPList[]= // Single player versions
1156 {
1157 // Default Values
1158 {0x0d, 0xff, 0xff, 0xff, NULL },
1159 {0x0e, 0xff, 0xff, 0xfb, NULL },
1160
1161 // Dip 1
1162 {0 , 0xfe, 0 , 2 , "Handle Pulse" },
1163 {0x0d, 0x01, 0x01, 0x01, "Normal" },
1164 {0x0d, 0x01, 0x01, 0x00, "Fast" },
1165
1166 {0 , 0xfe, 0 , 2 , "Gear Shift" },
1167 {0x0d, 0x01, 0x02, 0x02, "Normal" },
1168 {0x0d, 0x01, 0x02, 0x00, "Inverted" },
1169
1170 {0 , 0xfe, 0 , 2 , "Service Mode" },
1171 {0x0d, 0x01, 0x04, 0x04, "Off" },
1172 {0x0d, 0x01, 0x04, 0x00, "On" },
1173
1174 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1175 {0x0d, 0x01, 0x08, 0x00, "Off" },
1176 {0x0d, 0x01, 0x08, 0x08, "On" },
1177
1178 {0 , 0xfe, 0 , 4 , "Coin A" },
1179 {0x0d, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1180 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1181 {0x0d, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1182 {0x0d, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1183
1184 {0 , 0xfe, 0 , 4 , "Coin B" },
1185 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1186 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1187 {0x0d, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1188 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1189
1190 // Dip 2
1191 {0 , 0xfe, 0 , 4 , "Difficulty" },
1192 {0x0e, 0x01, 0x03, 0x02, "Easy" },
1193 {0x0e, 0x01, 0x03, 0x03, "Normal" },
1194 {0x0e, 0x01, 0x03, 0x01, "Hard" },
1195 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
1196
1197 {0 , 0xfe, 0 , 2 , "Back Gear" },
1198 {0x0e, 0x01, 0x04, 0x04, "Normal" },
1199 {0x0e, 0x01, 0x04, 0x00, "No Back Gear" },
1200
1201 {0 , 0xfe, 0 , 2 , "Vibration Mode" },
1202 {0x0e, 0x01, 0x08, 0x08, "Partial Vibration" },
1203 {0x0e, 0x01, 0x08, 0x00, "All The Time Vibration" },
1204
1205 {0 , 0xfe, 0 , 2 , "Steering Wheel Vibration" },
1206 {0x0e, 0x01, 0x10, 0x00, "Off" },
1207 {0x0e, 0x01, 0x10, 0x10, "On" },
1208
1209 {0 , 0xfe, 0 , 2 , "Select Round" },
1210 {0x0e, 0x01, 0x20, 0x00, "Off" },
1211 {0x0e, 0x01, 0x20, 0x20, "On" },
1212
1213 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1214 {0x0e, 0x01, 0x40, 0x00, "Off" },
1215 {0x0e, 0x01, 0x40, 0x40, "On" },
1216
1217 {0 , 0xfe, 0 , 2 , "Buy-In" },
1218 {0x0e, 0x01, 0x80, 0x00, "Off" },
1219 {0x0e, 0x01, 0x80, 0x80, "On" },
1220 };
1221
1222 STDDIPINFO(Dblaxles)
1223
1224 static struct BurnDIPInfo PwheelsjDIPList[]=
1225 {
1226 // Default Values
1227 {0x0d, 0xff, 0xff, 0xff, NULL },
1228 {0x0e, 0xff, 0xff, 0xfb, NULL },
1229
1230 // Dip 1
1231 {0 , 0xfe, 0 , 2 , "Gear Shift" },
1232 {0x0d, 0x01, 0x02, 0x02, "Normal" },
1233 {0x0d, 0x01, 0x02, 0x00, "Inverted" },
1234
1235 {0 , 0xfe, 0 , 2 , "Service Mode" },
1236 {0x0d, 0x01, 0x04, 0x04, "Off" },
1237 {0x0d, 0x01, 0x04, 0x00, "On" },
1238
1239 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1240 {0x0d, 0x01, 0x08, 0x00, "Off" },
1241 {0x0d, 0x01, 0x08, 0x08, "On" },
1242
1243 {0 , 0xfe, 0 , 4 , "Coin A" },
1244 {0x0d, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1245 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1246 {0x0d, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1247 {0x0d, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1248
1249 {0 , 0xfe, 0 , 4 , "Coin B" },
1250 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1251 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1252 {0x0d, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1253 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1254
1255 // Dip 2
1256 {0 , 0xfe, 0 , 4 , "Difficulty" },
1257 {0x0e, 0x01, 0x03, 0x02, "Easy" },
1258 {0x0e, 0x01, 0x03, 0x03, "Normal" },
1259 {0x0e, 0x01, 0x03, 0x01, "Hard" },
1260 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
1261
1262 {0 , 0xfe, 0 , 2 , "Multi-machine hookup" },
1263 {0x0e, 0x01, 0x04, 0x00, "Off" },
1264 {0x0e, 0x01, 0x04, 0x04, "On" },
1265
1266 {0 , 0xfe, 0 , 2 , "Player Truck" },
1267 {0x0e, 0x01, 0x08, 0x08, "Red" },
1268 {0x0e, 0x01, 0x08, 0x00, "Blue" },
1269
1270 {0 , 0xfe, 0 , 2 , "Reverse" },
1271 {0x0e, 0x01, 0x10, 0x10, "Normal" },
1272 {0x0e, 0x01, 0x10, 0x00, "Inverted" },
1273 };
1274
1275 STDDIPINFO(Pwheelsj)
1276
1277 static struct BurnDIPInfo EnforceDIPList[]=
1278 {
1279 // Default Values
1280 {0x0c, 0xff, 0xff, 0xff, NULL },
1281 {0x0d, 0xff, 0xff, 0xef, NULL },
1282
1283 // Dip 1
1284 {0 , 0xfe, 0 , 2 , "Service Mode" },
1285 {0x0c, 0x01, 0x04, 0x04, "Off" },
1286 {0x0c, 0x01, 0x04, 0x00, "On" },
1287
1288 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1289 {0x0c, 0x01, 0x08, 0x00, "Off" },
1290 {0x0c, 0x01, 0x08, 0x08, "On" },
1291
1292 {0 , 0xfe, 0 , 4 , "Coin A" },
1293 {0x0c, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1294 {0x0c, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1295 {0x0c, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1296 {0x0c, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1297
1298 {0 , 0xfe, 0 , 4 , "Coin B" },
1299 {0x0c, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1300 {0x0c, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1301 {0x0c, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1302 {0x0c, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1303
1304 // Dip 2
1305 {0 , 0xfe, 0 , 2 , "Background Scenery" },
1306 {0x0d, 0x01, 0x10, 0x10, "Crazy Scolling" },
1307 {0x0d, 0x01, 0x10, 0x00, "Normal" },
1308 };
1309
1310 STDDIPINFO(Enforce)
1311
1312 static struct BurnDIPInfo EnforcejDIPList[]=
1313 {
1314 // Default Values
1315 {0x0c, 0xff, 0xff, 0xff, NULL },
1316 {0x0d, 0xff, 0xff, 0xef, NULL },
1317
1318 // Dip 1
1319 {0 , 0xfe, 0 , 2 , "Service Mode" },
1320 {0x0c, 0x01, 0x04, 0x04, "Off" },
1321 {0x0c, 0x01, 0x04, 0x00, "On" },
1322
1323 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1324 {0x0c, 0x01, 0x08, 0x00, "Off" },
1325 {0x0c, 0x01, 0x08, 0x08, "On" },
1326
1327 {0 , 0xfe, 0 , 4 , "Coin A" },
1328 {0x0c, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1329 {0x0c, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1330 {0x0c, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1331 {0x0c, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1332
1333 {0 , 0xfe, 0 , 4 , "Coin B" },
1334 {0x0c, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1335 {0x0c, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1336 {0x0c, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1337 {0x0c, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1338
1339 // Dip 2
1340 {0 , 0xfe, 0 , 2 , "Background Scenery" },
1341 {0x0d, 0x01, 0x10, 0x10, "Crazy Scrolling" },
1342 {0x0d, 0x01, 0x10, 0x00, "Normal" },
1343 };
1344
1345 STDDIPINFO(Enforcej)
1346
1347 static struct BurnDIPInfo EnforcejaDIPList[]=
1348 {
1349 // Default Values
1350 {0x0c, 0xff, 0xff, 0xff, NULL },
1351 {0x0d, 0xff, 0xff, 0xff, NULL },
1352
1353 // Dip 1
1354 {0 , 0xfe, 0 , 2 , "Service Mode" },
1355 {0x0c, 0x01, 0x04, 0x04, "Off" },
1356 {0x0c, 0x01, 0x04, 0x00, "On" },
1357
1358 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1359 {0x0c, 0x01, 0x08, 0x00, "Off" },
1360 {0x0c, 0x01, 0x08, 0x08, "On" },
1361
1362 {0 , 0xfe, 0 , 4 , "Coin A" },
1363 {0x0c, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1364 {0x0c, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1365 {0x0c, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1366 {0x0c, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1367
1368 {0 , 0xfe, 0 , 4 , "Coin B" },
1369 {0x0c, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1370 {0x0c, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1371 {0x0c, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1372 {0x0c, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1373
1374 // Dip 2
1375 {0 , 0xfe, 0 , 4 , "3D Effects" },
1376 {0x0d, 0x01, 0x30, 0x30, "Off" },
1377 {0x0d, 0x01, 0x30, 0x20, "On" },
1378 {0x0d, 0x01, 0x30, 0x10, "In Game Only" },
1379 {0x0d, 0x01, 0x30, 0x00, "In Game Only" },
1380 };
1381
1382 STDDIPINFO(Enforceja)
1383
1384 static struct BurnDIPInfo NightstrDIPList[]=
1385 {
1386 // Default Values
1387 {0x0b, 0xff, 0xff, 0xfe, NULL },
1388 {0x0c, 0xff, 0xff, 0xff, NULL },
1389
1390 // Dip 1
1391 {0 , 0xfe, 0 , 2 , "Cabinet" },
1392 {0x0b, 0x01, 0x01, 0x01, "Cockpit" },
1393 {0x0b, 0x01, 0x01, 0x00, "Upright" },
1394
1395 {0 , 0xfe, 0 , 2 , "Service Mode" },
1396 {0x0b, 0x01, 0x04, 0x04, "Off" },
1397 {0x0b, 0x01, 0x04, 0x00, "On" },
1398
1399 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1400 {0x0b, 0x01, 0x08, 0x00, "Off" },
1401 {0x0b, 0x01, 0x08, 0x08, "On" },
1402
1403 {0 , 0xfe, 0 , 4 , "Coin A" },
1404 {0x0b, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1405 {0x0b, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1406 {0x0b, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1407 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1408
1409 {0 , 0xfe, 0 , 4 , "Coin B" },
1410 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
1411 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
1412 {0x0b, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
1413 {0x0b, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
1414
1415 // Dip 2
1416 {0 , 0xfe, 0 , 4 , "Difficulty" },
1417 {0x0c, 0x01, 0x03, 0x02, "Easy" },
1418 {0x0c, 0x01, 0x03, 0x03, "Normal" },
1419 {0x0c, 0x01, 0x03, 0x01, "Hard" },
1420 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
1421
1422 {0 , 0xfe, 0 , 4 , "Bonus Shields" },
1423 {0x0c, 0x01, 0x0c, 0x08, "3" },
1424 {0x0c, 0x01, 0x0c, 0x04, "2" },
1425 {0x0c, 0x01, 0x0c, 0x0c, "1" },
1426 {0x0c, 0x01, 0x0c, 0x00, "None" },
1427
1428 {0 , 0xfe, 0 , 4 , "Shields" },
1429 {0x0c, 0x01, 0x30, 0x00, "3" },
1430 {0x0c, 0x01, 0x30, 0x10, "4" },
1431 {0x0c, 0x01, 0x30, 0x30, "5" },
1432 {0x0c, 0x01, 0x30, 0x20, "6" },
1433
1434 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1435 {0x0c, 0x01, 0x40, 0x00, "Off" },
1436 {0x0c, 0x01, 0x40, 0x40, "On" },
1437
1438 {0 , 0xfe, 0 , 2 , "Trigger Turbo" },
1439 {0x0c, 0x01, 0x80, 0x80, "7 shots / seconds" },
1440 {0x0c, 0x01, 0x80, 0x00, "10 shots / seconds" },
1441 };
1442
1443 STDDIPINFO(Nightstr)
1444
1445 static struct BurnDIPInfo NightstrjDIPList[]=
1446 {
1447 // Default Values
1448 {0x0b, 0xff, 0xff, 0xfe, NULL },
1449 {0x0c, 0xff, 0xff, 0xff, NULL },
1450
1451 // Dip 1
1452 {0 , 0xfe, 0 , 2 , "Cabinet" },
1453 {0x0b, 0x01, 0x01, 0x01, "Cockpit" },
1454 {0x0b, 0x01, 0x01, 0x00, "Upright" },
1455
1456 {0 , 0xfe, 0 , 2 , "Service Mode" },
1457 {0x0b, 0x01, 0x04, 0x04, "Off" },
1458 {0x0b, 0x01, 0x04, 0x00, "On" },
1459
1460 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1461 {0x0b, 0x01, 0x08, 0x00, "Off" },
1462 {0x0b, 0x01, 0x08, 0x08, "On" },
1463
1464 {0 , 0xfe, 0 , 4 , "Coin A" },
1465 {0x0b, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1466 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1467 {0x0b, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1468 {0x0b, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1469
1470 {0 , 0xfe, 0 , 4 , "Coin B" },
1471 {0x0b, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1472 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1473 {0x0b, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1474 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1475
1476 // Dip 2
1477 {0 , 0xfe, 0 , 4 , "Difficulty" },
1478 {0x0c, 0x01, 0x03, 0x02, "Easy" },
1479 {0x0c, 0x01, 0x03, 0x03, "Normal" },
1480 {0x0c, 0x01, 0x03, 0x01, "Hard" },
1481 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
1482
1483 {0 , 0xfe, 0 , 4 , "Bonus Shields" },
1484 {0x0c, 0x01, 0x0c, 0x08, "3" },
1485 {0x0c, 0x01, 0x0c, 0x04, "2" },
1486 {0x0c, 0x01, 0x0c, 0x0c, "1" },
1487 {0x0c, 0x01, 0x0c, 0x00, "None" },
1488
1489 {0 , 0xfe, 0 , 4 , "Shields" },
1490 {0x0c, 0x01, 0x30, 0x00, "3" },
1491 {0x0c, 0x01, 0x30, 0x10, "4" },
1492 {0x0c, 0x01, 0x30, 0x30, "5" },
1493 {0x0c, 0x01, 0x30, 0x20, "6" },
1494
1495 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1496 {0x0c, 0x01, 0x40, 0x00, "Off" },
1497 {0x0c, 0x01, 0x40, 0x40, "On" },
1498
1499 {0 , 0xfe, 0 , 2 , "Trigger Turbo" },
1500 {0x0c, 0x01, 0x80, 0x80, "7 shots / seconds" },
1501 {0x0c, 0x01, 0x80, 0x00, "10 shots / seconds" },
1502 };
1503
1504 STDDIPINFO(Nightstrj)
1505
1506
1507 static struct BurnDIPInfo NightstruDIPList[]=
1508 {
1509 // Default Values
1510 {0x0b, 0xff, 0xff, 0xfe, NULL },
1511 {0x0c, 0xff, 0xff, 0xff, NULL },
1512
1513 // Dip 1
1514 {0 , 0xfe, 0 , 2 , "Cabinet" },
1515 {0x0b, 0x01, 0x01, 0x01, "Cockpit" },
1516 {0x0b, 0x01, 0x01, 0x00, "Upright" },
1517
1518 {0 , 0xfe, 0 , 2 , "Service Mode" },
1519 {0x0b, 0x01, 0x04, 0x04, "Off" },
1520 {0x0b, 0x01, 0x04, 0x00, "On" },
1521
1522 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1523 {0x0b, 0x01, 0x08, 0x00, "Off" },
1524 {0x0b, 0x01, 0x08, 0x08, "On" },
1525
1526 {0 , 0xfe, 0 , 4 , "Coinage" },
1527 {0x0b, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1528 {0x0b, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1529 {0x0b, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1530 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1531
1532 {0 , 0xfe, 0 , 4 , "Price to Continue" },
1533 {0x0b, 0x01, 0xc0, 0x00, "3 Coins 1 Credit" },
1534 {0x0b, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1535 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 1 Credit" },
1536 {0x0b, 0x01, 0xc0, 0xc0, "Same as Start" },
1537
1538 // Dip 2
1539 {0 , 0xfe, 0 , 4 , "Difficulty" },
1540 {0x0c, 0x01, 0x03, 0x02, "Easy" },
1541 {0x0c, 0x01, 0x03, 0x03, "Normal" },
1542 {0x0c, 0x01, 0x03, 0x01, "Hard" },
1543 {0x0c, 0x01, 0x03, 0x00, "Hardest" },
1544
1545 {0 , 0xfe, 0 , 4 , "Bonus Shields" },
1546 {0x0c, 0x01, 0x0c, 0x08, "3" },
1547 {0x0c, 0x01, 0x0c, 0x04, "2" },
1548 {0x0c, 0x01, 0x0c, 0x0c, "1" },
1549 {0x0c, 0x01, 0x0c, 0x00, "None" },
1550
1551 {0 , 0xfe, 0 , 4 , "Shields" },
1552 {0x0c, 0x01, 0x30, 0x00, "3" },
1553 {0x0c, 0x01, 0x30, 0x10, "4" },
1554 {0x0c, 0x01, 0x30, 0x30, "5" },
1555 {0x0c, 0x01, 0x30, 0x20, "6" },
1556
1557 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1558 {0x0c, 0x01, 0x40, 0x00, "Off" },
1559 {0x0c, 0x01, 0x40, 0x40, "On" },
1560
1561 {0 , 0xfe, 0 , 2 , "Trigger Turbo" },
1562 {0x0c, 0x01, 0x80, 0x80, "7 shots / seconds" },
1563 {0x0c, 0x01, 0x80, 0x00, "10 shots / seconds" },
1564 };
1565
1566 STDDIPINFO(Nightstru)
1567
1568 static struct BurnDIPInfo RacingbDIPList[]=
1569 {
1570 // Default Values
1571 {0x0b, 0xff, 0xff, 0xff, NULL },
1572 {0x0c, 0xff, 0xff, 0xff, NULL },
1573
1574 // Dip 1
1575 {0 , 0xfe, 0 , 2 , "Cabinet" },
1576 {0x0b, 0x01, 0x01, 0x00, "Type 0" },
1577 {0x0b, 0x01, 0x01, 0x01, "Type 1" },
1578
1579 {0 , 0xfe, 0 , 2 , "Service Mode" },
1580 {0x0b, 0x01, 0x04, 0x04, "Off" },
1581 {0x0b, 0x01, 0x04, 0x00, "On" },
1582
1583 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1584 {0x0b, 0x01, 0x08, 0x00, "Off" },
1585 {0x0b, 0x01, 0x08, 0x08, "On" },
1586
1587 {0 , 0xfe, 0 , 4 , "Coin A" },
1588 {0x0b, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1589 {0x0b, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1590 {0x0b, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1591 {0x0b, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1592
1593 {0 , 0xfe, 0 , 4 , "Coin B" },
1594 {0x0b, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
1595 {0x0b, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
1596 {0x0b, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
1597 {0x0b, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
1598
1599 // Dip 2
1600 {0 , 0xfe, 0 , 2 , "Steering Wheel Range" },
1601 {0x0c, 0x01, 0x04, 0x04, "Normal" },
1602 {0x0c, 0x01, 0x04, 0x00, "High" },
1603
1604 {0 , 0xfe, 0 , 2 , "Steering Wheel Type" },
1605 {0x0c, 0x01, 0x08, 0x00, "Free" },
1606 {0x0c, 0x01, 0x08, 0x08, "Locked" },
1607
1608 {0 , 0xfe, 0 , 2 , "Network" },
1609 {0x0c, 0x01, 0x10, 0x10, "Off" },
1610 {0x0c, 0x01, 0x10, 0x00, "On" },
1611
1612 {0 , 0xfe, 0 , 4 , "Player Car" },
1613 {0x0c, 0x01, 0x60, 0x60, "Red" },
1614 {0x0c, 0x01, 0x60, 0x40, "Blue" },
1615 {0x0c, 0x01, 0x60, 0x20, "Green" },
1616 {0x0c, 0x01, 0x60, 0x00, "Yellow" },
1617 };
1618
1619 STDDIPINFO(Racingb)
1620
1621 static struct BurnDIPInfo SciDIPList[]=
1622 {
1623 // Default Values
1624 {0x0d, 0xff, 0xff, 0xfe, NULL },
1625 {0x0e, 0xff, 0xff, 0xff, NULL },
1626
1627 // Dip 1
1628 {0 , 0xfe, 0 , 2 , "Cabinet" },
1629 {0x0d, 0x01, 0x01, 0x01, "Cockpit" },
1630 {0x0d, 0x01, 0x01, 0x00, "Upright" },
1631
1632 {0 , 0xfe, 0 , 2 , "Service Mode" },
1633 {0x0d, 0x01, 0x04, 0x04, "Off" },
1634 {0x0d, 0x01, 0x04, 0x00, "On" },
1635
1636 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1637 {0x0d, 0x01, 0x08, 0x00, "Off" },
1638 {0x0d, 0x01, 0x08, 0x08, "On" },
1639
1640 {0 , 0xfe, 0 , 4 , "Coin A" },
1641 {0x0d, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1642 {0x0d, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1643 {0x0d, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1644 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1645
1646 {0 , 0xfe, 0 , 4 , "Coin B" },
1647 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
1648 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
1649 {0x0d, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
1650 {0x0d, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
1651
1652 // Dip 2
1653 {0 , 0xfe, 0 , 4 , "Difficulty" },
1654 {0x0e, 0x01, 0x03, 0x02, "Easy" },
1655 {0x0e, 0x01, 0x03, 0x03, "Normal" },
1656 {0x0e, 0x01, 0x03, 0x01, "Hard" },
1657 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
1658
1659 {0 , 0xfe, 0 , 4 , "Timer Setting" },
1660 {0x0e, 0x01, 0x0c, 0x08, "70 Seconds" },
1661 {0x0e, 0x01, 0x0c, 0x04, "65 Seconds" },
1662 {0x0e, 0x01, 0x0c, 0x0c, "60 Seconds" },
1663 {0x0e, 0x01, 0x0c, 0x00, "55 Seconds" },
1664
1665 {0 , 0xfe, 0 , 2 , "Turbos Stocked" },
1666 {0x0e, 0x01, 0x10, 0x10, "3" },
1667 {0x0e, 0x01, 0x10, 0x00, "5" },
1668
1669 {0 , 0xfe, 0 , 2 , "Steering Radius" },
1670 {0x0e, 0x01, 0x20, 0x00, "270 Degree" },
1671 {0x0e, 0x01, 0x20, 0x20, "360 Degree" },
1672
1673 {0 , 0xfe, 0 , 2 , "Damage Cleared at Continue" },
1674 {0x0e, 0x01, 0x40, 0x00, "Off" },
1675 {0x0e, 0x01, 0x40, 0x40, "On" },
1676
1677 {0 , 0xfe, 0 , 2 , "Siren Volume" },
1678 {0x0e, 0x01, 0x80, 0x80, "Normal" },
1679 {0x0e, 0x01, 0x80, 0x00, "Low" },
1680 };
1681
1682 STDDIPINFO(Sci)
1683
1684 static struct BurnDIPInfo ScijDIPList[]=
1685 {
1686 // Default Values
1687 {0x0d, 0xff, 0xff, 0xfe, NULL },
1688 {0x0e, 0xff, 0xff, 0xff, NULL },
1689
1690 // Dip 1
1691 {0 , 0xfe, 0 , 2 , "Cabinet" },
1692 {0x0d, 0x01, 0x01, 0x01, "Cockpit" },
1693 {0x0d, 0x01, 0x01, 0x00, "Upright" },
1694
1695 {0 , 0xfe, 0 , 2 , "Service Mode" },
1696 {0x0d, 0x01, 0x04, 0x04, "Off" },
1697 {0x0d, 0x01, 0x04, 0x00, "On" },
1698
1699 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1700 {0x0d, 0x01, 0x08, 0x00, "Off" },
1701 {0x0d, 0x01, 0x08, 0x08, "On" },
1702
1703 {0 , 0xfe, 0 , 4 , "Coin A" },
1704 {0x0d, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1705 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1706 {0x0d, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1707 {0x0d, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1708
1709 {0 , 0xfe, 0 , 4 , "Coin B" },
1710 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1711 {0x0d, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1712 {0x0d, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1713 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1714
1715 // Dip 2
1716 {0 , 0xfe, 0 , 4 , "Difficulty" },
1717 {0x0e, 0x01, 0x03, 0x02, "Easy" },
1718 {0x0e, 0x01, 0x03, 0x03, "Normal" },
1719 {0x0e, 0x01, 0x03, 0x01, "Hard" },
1720 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
1721
1722 {0 , 0xfe, 0 , 4 , "Timer Setting" },
1723 {0x0e, 0x01, 0x0c, 0x08, "70 Seconds" },
1724 {0x0e, 0x01, 0x0c, 0x04, "65 Seconds" },
1725 {0x0e, 0x01, 0x0c, 0x0c, "60 Seconds" },
1726 {0x0e, 0x01, 0x0c, 0x00, "55 Seconds" },
1727
1728 {0 , 0xfe, 0 , 2 , "Turbos Stocked" },
1729 {0x0e, 0x01, 0x10, 0x10, "3" },
1730 {0x0e, 0x01, 0x10, 0x00, "5" },
1731
1732 {0 , 0xfe, 0 , 2 , "Steering Radius" },
1733 {0x0e, 0x01, 0x20, 0x00, "270 Degree" },
1734 {0x0e, 0x01, 0x20, 0x20, "360 Degree" },
1735
1736 {0 , 0xfe, 0 , 2 , "Damage Cleared at Continue" },
1737 {0x0e, 0x01, 0x40, 0x00, "Off" },
1738 {0x0e, 0x01, 0x40, 0x40, "On" },
1739
1740 {0 , 0xfe, 0 , 2 , "Siren Volume" },
1741 {0x0e, 0x01, 0x80, 0x80, "Normal" },
1742 {0x0e, 0x01, 0x80, 0x00, "Low" },
1743 };
1744
1745 STDDIPINFO(Scij)
1746
1747 static struct BurnDIPInfo SciuDIPList[]=
1748 {
1749 // Default Values
1750 {0x0d, 0xff, 0xff, 0xfe, NULL },
1751 {0x0e, 0xff, 0xff, 0xff, NULL },
1752
1753 // Dip 1
1754 {0 , 0xfe, 0 , 2 , "Cabinet" },
1755 {0x0d, 0x01, 0x01, 0x01, "Cockpit" },
1756 {0x0d, 0x01, 0x01, 0x00, "Upright" },
1757
1758 {0 , 0xfe, 0 , 2 , "Service Mode" },
1759 {0x0d, 0x01, 0x04, 0x04, "Off" },
1760 {0x0d, 0x01, 0x04, 0x00, "On" },
1761
1762 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1763 {0x0d, 0x01, 0x08, 0x00, "Off" },
1764 {0x0d, 0x01, 0x08, 0x08, "On" },
1765
1766 {0 , 0xfe, 0 , 4 , "Coinage" },
1767 {0x0d, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1768 {0x0d, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1769 {0x0d, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1770 {0x0d, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1771
1772 {0 , 0xfe, 0 , 4 , "Price to Continue" },
1773 {0x0d, 0x01, 0xc0, 0x00, "3 Coins 1 Credit" },
1774 {0x0d, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1775 {0x0d, 0x01, 0xc0, 0x80, "1 Coin 1 Credit" },
1776 {0x0d, 0x01, 0xc0, 0xc0, "Same as Start" },
1777
1778 // Dip 2
1779 {0 , 0xfe, 0 , 4 , "Difficulty" },
1780 {0x0e, 0x01, 0x03, 0x02, "Easy" },
1781 {0x0e, 0x01, 0x03, 0x03, "Normal" },
1782 {0x0e, 0x01, 0x03, 0x01, "Hard" },
1783 {0x0e, 0x01, 0x03, 0x00, "Hardest" },
1784
1785 {0 , 0xfe, 0 , 4 , "Timer Setting" },
1786 {0x0e, 0x01, 0x0c, 0x08, "70 Seconds" },
1787 {0x0e, 0x01, 0x0c, 0x04, "65 Seconds" },
1788 {0x0e, 0x01, 0x0c, 0x0c, "60 Seconds" },
1789 {0x0e, 0x01, 0x0c, 0x00, "55 Seconds" },
1790
1791 {0 , 0xfe, 0 , 2 , "Turbos Stocked" },
1792 {0x0e, 0x01, 0x10, 0x10, "3" },
1793 {0x0e, 0x01, 0x10, 0x00, "5" },
1794
1795 {0 , 0xfe, 0 , 2 , "Steering Radius" },
1796 {0x0e, 0x01, 0x20, 0x00, "270 Degree" },
1797 {0x0e, 0x01, 0x20, 0x20, "360 Degree" },
1798
1799 {0 , 0xfe, 0 , 2 , "Damage Cleared at Continue" },
1800 {0x0e, 0x01, 0x40, 0x00, "Off" },
1801 {0x0e, 0x01, 0x40, 0x40, "On" },
1802
1803 {0 , 0xfe, 0 , 2 , "Siren Volume" },
1804 {0x0e, 0x01, 0x80, 0x80, "Normal" },
1805 {0x0e, 0x01, 0x80, 0x00, "Low" },
1806 };
1807
1808 STDDIPINFO(Sciu)
1809
1810 static struct BurnDIPInfo SpacegunDIPList[]=
1811 {
1812 // Default Values
1813 {0x10, 0xff, 0xff, 0xff, NULL },
1814 {0x11, 0xff, 0xff, 0xff, NULL },
1815
1816 // Dip 1
1817 {0 , 0xfe, 0 , 2 , "Always have gunsight power up" },
1818 {0x10, 0x01, 0x02, 0x02, "Off" },
1819 {0x10, 0x01, 0x02, 0x00, "On" },
1820
1821 {0 , 0xfe, 0 , 2 , "Service Mode" },
1822 {0x10, 0x01, 0x04, 0x04, "Off" },
1823 {0x10, 0x01, 0x04, 0x00, "On" },
1824
1825 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1826 {0x10, 0x01, 0x08, 0x00, "Off" },
1827 {0x10, 0x01, 0x08, 0x08, "On" },
1828
1829 {0 , 0xfe, 0 , 4 , "Coin A" },
1830 {0x10, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1831 {0x10, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1832 {0x10, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1833 {0x10, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1834
1835 {0 , 0xfe, 0 , 4 , "Coin B" },
1836 {0x10, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
1837 {0x10, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
1838 {0x10, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
1839 {0x10, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
1840
1841 // Dip 2
1842 {0 , 0xfe, 0 , 4 , "Difficulty" },
1843 {0x11, 0x01, 0x03, 0x02, "Easy" },
1844 {0x11, 0x01, 0x03, 0x03, "Normal" },
1845 {0x11, 0x01, 0x03, 0x01, "Hard" },
1846 {0x11, 0x01, 0x03, 0x00, "Hardest" },
1847
1848 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1849 {0x11, 0x01, 0x40, 0x00, "Off" },
1850 {0x11, 0x01, 0x40, 0x40, "On" },
1851
1852 {0 , 0xfe, 0 , 2 , "Disable Pedal" },
1853 {0x11, 0x01, 0x80, 0x80, "Off" },
1854 {0x11, 0x01, 0x80, 0x00, "On" },
1855 };
1856
1857 STDDIPINFO(Spacegun)
1858
1859 static struct BurnDIPInfo SpacegunjDIPList[]=
1860 {
1861 // Default Values
1862 {0x10, 0xff, 0xff, 0xff, NULL },
1863 {0x11, 0xff, 0xff, 0xff, NULL },
1864
1865 // Dip 1
1866 {0 , 0xfe, 0 , 2 , "Always have gunsight power up" },
1867 {0x10, 0x01, 0x02, 0x02, "Off" },
1868 {0x10, 0x01, 0x02, 0x00, "On" },
1869
1870 {0 , 0xfe, 0 , 2 , "Service Mode" },
1871 {0x10, 0x01, 0x04, 0x04, "Off" },
1872 {0x10, 0x01, 0x04, 0x00, "On" },
1873
1874 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1875 {0x10, 0x01, 0x08, 0x00, "Off" },
1876 {0x10, 0x01, 0x08, 0x08, "On" },
1877
1878 {0 , 0xfe, 0 , 4 , "Coin A" },
1879 {0x10, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
1880 {0x10, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1881 {0x10, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
1882 {0x10, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
1883
1884 {0 , 0xfe, 0 , 4 , "Coin B" },
1885 {0x10, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1886 {0x10, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
1887 {0x10, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
1888 {0x10, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
1889
1890 // Dip 2
1891 {0 , 0xfe, 0 , 4 , "Difficulty" },
1892 {0x11, 0x01, 0x03, 0x02, "Easy" },
1893 {0x11, 0x01, 0x03, 0x03, "Normal" },
1894 {0x11, 0x01, 0x03, 0x01, "Hard" },
1895 {0x11, 0x01, 0x03, 0x00, "Hardest" },
1896
1897 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1898 {0x11, 0x01, 0x40, 0x00, "Off" },
1899 {0x11, 0x01, 0x40, 0x40, "On" },
1900
1901 {0 , 0xfe, 0 , 2 , "Disable Pedal" },
1902 {0x11, 0x01, 0x80, 0x80, "Off" },
1903 {0x11, 0x01, 0x80, 0x00, "On" },
1904 };
1905
1906 STDDIPINFO(Spacegunj)
1907
1908 static struct BurnDIPInfo SpacegunuDIPList[]=
1909 {
1910 // Default Values
1911 {0x10, 0xff, 0xff, 0xff, NULL },
1912 {0x11, 0xff, 0xff, 0xff, NULL },
1913
1914 // Dip 1
1915 {0 , 0xfe, 0 , 2 , "Always have gunsight power up" },
1916 {0x10, 0x01, 0x02, 0x02, "Off" },
1917 {0x10, 0x01, 0x02, 0x00, "On" },
1918
1919 {0 , 0xfe, 0 , 2 , "Service Mode" },
1920 {0x10, 0x01, 0x04, 0x04, "Off" },
1921 {0x10, 0x01, 0x04, 0x00, "On" },
1922
1923 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
1924 {0x10, 0x01, 0x08, 0x00, "Off" },
1925 {0x10, 0x01, 0x08, 0x08, "On" },
1926
1927 {0 , 0xfe, 0 , 4 , "Coinage" },
1928 {0x10, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
1929 {0x10, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
1930 {0x10, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
1931 {0x10, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
1932
1933 {0 , 0xfe, 0 , 4 , "Price to Continue" },
1934 {0x10, 0x01, 0xc0, 0x00, "3 Coins 1 Credit" },
1935 {0x10, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
1936 {0x10, 0x01, 0xc0, 0x80, "1 Coin 1 Credit" },
1937 {0x10, 0x01, 0xc0, 0xc0, "Same as Start" },
1938
1939 // Dip 2
1940 {0 , 0xfe, 0 , 4 , "Difficulty" },
1941 {0x11, 0x01, 0x03, 0x02, "Easy" },
1942 {0x11, 0x01, 0x03, 0x03, "Normal" },
1943 {0x11, 0x01, 0x03, 0x01, "Hard" },
1944 {0x11, 0x01, 0x03, 0x00, "Hardest" },
1945
1946 {0 , 0xfe, 0 , 2 , "Allow Continue" },
1947 {0x11, 0x01, 0x40, 0x00, "Off" },
1948 {0x11, 0x01, 0x40, 0x40, "On" },
1949
1950 {0 , 0xfe, 0 , 2 , "Disable Pedal" },
1951 {0x11, 0x01, 0x80, 0x80, "Off" },
1952 {0x11, 0x01, 0x80, 0x00, "On" },
1953 };
1954
1955 STDDIPINFO(Spacegunu)
1956
1957 static struct BurnRomInfo AquajackRomDesc[] = {
1958 { "b77-22.ic31", 0x20000, 0x67400dde, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
1959 { "b77-26.ic17", 0x20000, 0xcd4d0969, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
1960
1961 { "b77-24.ic69", 0x20000, 0x95e643ed, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
1962 { "b77-23.ic67", 0x20000, 0x395a7d1c, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
1963
1964 { "b77-20.ic54", 0x10000, 0x84ba54b7, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
1965
1966 { "b77-05.ic105", 0x80000, 0x7238f0ff, BRF_GRA | TAITO_CHARS },
1967
1968 { "b77-04.ic16", 0x80000, 0xbed0be6c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
1969 { "b77-03.ic15", 0x80000, 0x9a3030a7, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
1970 { "b77-02.ic14", 0x80000, 0xdaea0d2e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
1971 { "b77-01.ic13", 0x80000, 0xcdab000d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
1972
1973 { "b77-07.ic33", 0x80000, 0x7db1fc5e, BRF_GRA | TAITO_ROAD },
1974
1975 { "b77-06.ic39", 0x80000, 0xce2aed00, BRF_GRA | TAITO_SPRITEMAP },
1976
1977 { "b77-09.ic58", 0x80000, 0x948e5ad9, BRF_SND | TAITO_YM2610A },
1978
1979 { "b77-08.ic57", 0x80000, 0x119b9485, BRF_SND | TAITO_YM2610B },
1980
1981 { "b77-17.ic1", 0x00100, 0xfbf81f30, BRF_OPT },
1982 { "b77-18.ic37", 0x00100, 0x7b7d8ff4, BRF_OPT },
1983 };
1984
1985 STD_ROM_PICK(Aquajack)
1986 STD_ROM_FN(Aquajack)
1987
1988 static struct BurnRomInfo AquajackuRomDesc[] = {
1989 { "b77-22.ic31", 0x20000, 0x67400dde, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
1990 { "b77-25.ic17", 0x20000, 0xba4a39ff, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
1991
1992 { "b77-24.ic69", 0x20000, 0x95e643ed, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
1993 { "b77-23.ic67", 0x20000, 0x395a7d1c, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
1994
1995 { "b77-20.ic54", 0x10000, 0x84ba54b7, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
1996
1997 { "b77-05.ic105", 0x80000, 0x7238f0ff, BRF_GRA | TAITO_CHARS },
1998
1999 { "b77-04.ic16", 0x80000, 0xbed0be6c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2000 { "b77-03.ic15", 0x80000, 0x9a3030a7, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2001 { "b77-02.ic14", 0x80000, 0xdaea0d2e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2002 { "b77-01.ic13", 0x80000, 0xcdab000d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2003
2004 { "b77-07.ic33", 0x80000, 0x7db1fc5e, BRF_GRA | TAITO_ROAD },
2005
2006 { "b77-06.ic39", 0x80000, 0xce2aed00, BRF_GRA | TAITO_SPRITEMAP },
2007
2008 { "b77-09.ic58", 0x80000, 0x948e5ad9, BRF_SND | TAITO_YM2610A },
2009
2010 { "b77-08.ic57", 0x80000, 0x119b9485, BRF_SND | TAITO_YM2610B },
2011
2012 { "b77-17.ic1", 0x00100, 0xfbf81f30, BRF_OPT },
2013 { "b77-18.ic37", 0x00100, 0x7b7d8ff4, BRF_OPT },
2014 };
2015
2016 STD_ROM_PICK(Aquajacku)
2017 STD_ROM_FN(Aquajacku)
2018
2019 static struct BurnRomInfo AquajackjRomDesc[] = {
2020 { "b77-22.ic31", 0x20000, 0x67400dde, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2021 { "b77-21.ic17", 0x20000, 0x23436845, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2022
2023 { "b77-24.ic69", 0x20000, 0x95e643ed, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2024 { "b77-23.ic67", 0x20000, 0x395a7d1c, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2025
2026 { "b77-20.ic54", 0x10000, 0x84ba54b7, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2027
2028 { "b77-05.ic105", 0x80000, 0x7238f0ff, BRF_GRA | TAITO_CHARS },
2029
2030 { "b77-04.ic16", 0x80000, 0xbed0be6c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2031 { "b77-03.ic15", 0x80000, 0x9a3030a7, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2032 { "b77-02.ic14", 0x80000, 0xdaea0d2e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2033 { "b77-01.ic13", 0x80000, 0xcdab000d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2034
2035 { "b77-07.ic33", 0x80000, 0x7db1fc5e, BRF_GRA | TAITO_ROAD },
2036
2037 { "b77-06.ic39", 0x80000, 0xce2aed00, BRF_GRA | TAITO_SPRITEMAP },
2038
2039 { "b77-09.ic58", 0x80000, 0x948e5ad9, BRF_SND | TAITO_YM2610A },
2040
2041 { "b77-08.ic57", 0x80000, 0x119b9485, BRF_SND | TAITO_YM2610B },
2042
2043 { "b77-17.ic1", 0x00100, 0xfbf81f30, BRF_OPT },
2044 { "b77-18.ic37", 0x00100, 0x7b7d8ff4, BRF_OPT },
2045 };
2046
2047 STD_ROM_PICK(Aquajackj)
2048 STD_ROM_FN(Aquajackj)
2049
2050 static struct BurnRomInfo BsharkRomDesc[] = {
2051 { "c34_71.98", 0x20000, 0xdf1fa629, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2052 { "c34_69.75", 0x20000, 0xa54c137a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2053 { "c34_70.97", 0x20000, 0xd77d81e2, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2054 { "c34_68.74", 0x20000, 0x4e374ce2, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2055
2056 { "c34_74.128", 0x20000, 0x6869fa99, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2057 { "c34_72.112", 0x20000, 0xc09c0f91, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2058 { "c34_75.129", 0x20000, 0x6ba65542, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2059 { "c34_73.113", 0x20000, 0xf2fe62b5, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2060
2061 { "c34_05.3", 0x80000, 0x596b83da, BRF_GRA | TAITO_CHARS },
2062
2063 { "c34_04.17", 0x80000, 0x2446b0da, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2064 { "c34_03.16", 0x80000, 0xa18eab78, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2065 { "c34_02.15", 0x80000, 0x8488ba10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2066 { "c34_01.14", 0x80000, 0x3ebe8c63, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2067
2068 { "c34_07.42", 0x80000, 0xedb07808, BRF_GRA | TAITO_ROAD },
2069
2070 { "c34_06.12", 0x80000, 0xd200b6eb, BRF_GRA | TAITO_SPRITEMAP },
2071
2072 { "c34_08.127", 0x80000, 0x89a30450, BRF_SND | TAITO_YM2610A },
2073
2074 { "c34_09.126", 0x80000, 0x39d12b50, BRF_SND | TAITO_YM2610B },
2075
2076 { "c34_18.22", 0x10000, 0x7245a6f6, BRF_OPT },
2077 { "c34_19.72", 0x00100, 0x2ee9c404, BRF_OPT },
2078 { "c34_20.89", 0x00100, 0xfbf81f30, BRF_OPT },
2079 { "c34_21.7", 0x00400, 0x10728853, BRF_OPT },
2080 { "c34_22.8", 0x00400, 0x643e8bfc, BRF_OPT },
2081 };
2082
2083 STD_ROM_PICK(Bshark)
2084 STD_ROM_FN(Bshark)
2085
2086 static struct BurnRomInfo BsharkjRomDesc[] = {
2087 { "c34_71.98", 0x20000, 0xdf1fa629, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2088 { "c34_69.75", 0x20000, 0xa54c137a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2089 { "c34_70.97", 0x20000, 0xd77d81e2, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2090 { "c34_66.74", 0x20000, 0xa0392dce, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2091
2092 { "c34_74.128", 0x20000, 0x6869fa99, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2093 { "c34_72.112", 0x20000, 0xc09c0f91, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2094 { "c34_75.129", 0x20000, 0x6ba65542, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2095 { "c34_73.113", 0x20000, 0xf2fe62b5, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2096
2097 { "c34_05.3", 0x80000, 0x596b83da, BRF_GRA | TAITO_CHARS },
2098
2099 { "c34_04.17", 0x80000, 0x2446b0da, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2100 { "c34_03.16", 0x80000, 0xa18eab78, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2101 { "c34_02.15", 0x80000, 0x8488ba10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2102 { "c34_01.14", 0x80000, 0x3ebe8c63, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2103
2104 { "c34_07.42", 0x80000, 0xedb07808, BRF_GRA | TAITO_ROAD },
2105
2106 { "c34_06.12", 0x80000, 0xd200b6eb, BRF_GRA | TAITO_SPRITEMAP },
2107
2108 { "c34_08.127", 0x80000, 0x89a30450, BRF_SND | TAITO_YM2610A },
2109
2110 { "c34_09.126", 0x80000, 0x39d12b50, BRF_SND | TAITO_YM2610B },
2111
2112 { "c34_18.22", 0x10000, 0x7245a6f6, BRF_OPT },
2113 { "c34_19.72", 0x00100, 0x2ee9c404, BRF_OPT },
2114 { "c34_20.89", 0x00100, 0xfbf81f30, BRF_OPT },
2115 { "c34_21.7", 0x00400, 0x10728853, BRF_OPT },
2116 { "c34_22.8", 0x00400, 0x643e8bfc, BRF_OPT },
2117 };
2118
2119 STD_ROM_PICK(Bsharkj)
2120 STD_ROM_FN(Bsharkj)
2121
2122 static struct BurnRomInfo BsharkjjsRomDesc[] = {
2123 { "c34_79.98", 0x20000, 0xbc3f2e93, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2124 { "c34_77.75", 0x20000, 0x917916d0, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2125 { "c34_78.97", 0x20000, 0xf2fcc880, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2126 { "c34_76.74", 0x20000, 0xde97fac0, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2127
2128 { "c34_82.128", 0x20000, 0x6869fa99, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2129 { "c34_80.112", 0x20000, 0xe1783eb4, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2130 { "c34_83.129", 0x20000, 0xeec0b364, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2131 { "c34_81.113", 0x20000, 0x23ce6bcf, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2132
2133 { "c34_05.3", 0x80000, 0x596b83da, BRF_GRA | TAITO_CHARS },
2134
2135 { "c34_04.17", 0x80000, 0x2446b0da, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2136 { "c34_03.16", 0x80000, 0xa18eab78, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2137 { "c34_02.15", 0x80000, 0x8488ba10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2138 { "c34_01.14", 0x80000, 0x3ebe8c63, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2139
2140 { "c34_07.42", 0x80000, 0xedb07808, BRF_GRA | TAITO_ROAD },
2141
2142 { "c34_06.12", 0x80000, 0xd200b6eb, BRF_GRA | TAITO_SPRITEMAP },
2143
2144 { "c34_08.127", 0x80000, 0x89a30450, BRF_SND | TAITO_YM2610A },
2145
2146 { "c34_09.126", 0x80000, 0x39d12b50, BRF_SND | TAITO_YM2610B },
2147
2148 { "c34_18.22", 0x10000, 0x7245a6f6, BRF_OPT },
2149 { "c34_19.72", 0x00100, 0x2ee9c404, BRF_OPT },
2150 { "c34_20.89", 0x00100, 0xfbf81f30, BRF_OPT },
2151 { "c34_21.7", 0x00400, 0x10728853, BRF_OPT },
2152 { "c34_22.8", 0x00400, 0x643e8bfc, BRF_OPT },
2153 };
2154
2155 STD_ROM_PICK(Bsharkjjs)
2156 STD_ROM_FN(Bsharkjjs)
2157
2158 static struct BurnRomInfo BsharkuRomDesc[] = {
2159 { "c34_71.98", 0x20000, 0xdf1fa629, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2160 { "c34_69.75", 0x20000, 0xa54c137a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2161 { "c34_70.97", 0x20000, 0xd77d81e2, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2162 { "c34_67.74", 0x20000, 0x39307c74, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2163
2164 { "c34_74.128", 0x20000, 0x6869fa99, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2165 { "c34_72.112", 0x20000, 0xc09c0f91, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2166 { "c34_75.129", 0x20000, 0x6ba65542, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2167 { "c34_73.113", 0x20000, 0xf2fe62b5, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2168
2169 { "c34_05.3", 0x80000, 0x596b83da, BRF_GRA | TAITO_CHARS },
2170
2171 { "c34_04.17", 0x80000, 0x2446b0da, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2172 { "c34_03.16", 0x80000, 0xa18eab78, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2173 { "c34_02.15", 0x80000, 0x8488ba10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2174 { "c34_01.14", 0x80000, 0x3ebe8c63, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2175
2176 { "c34_07.42", 0x80000, 0xedb07808, BRF_GRA | TAITO_ROAD },
2177
2178 { "c34_06.12", 0x80000, 0xd200b6eb, BRF_GRA | TAITO_SPRITEMAP },
2179
2180 { "c34_08.127", 0x80000, 0x89a30450, BRF_SND | TAITO_YM2610A },
2181
2182 { "c34_09.126", 0x80000, 0x39d12b50, BRF_SND | TAITO_YM2610B },
2183
2184 { "c34_18.22", 0x10000, 0x7245a6f6, BRF_OPT },
2185 { "c34_19.72", 0x00100, 0x2ee9c404, BRF_OPT },
2186 { "c34_20.89", 0x00100, 0xfbf81f30, BRF_OPT },
2187 { "c34_21.7", 0x00400, 0x10728853, BRF_OPT },
2188 { "c34_22.8", 0x00400, 0x643e8bfc, BRF_OPT },
2189 };
2190
2191 STD_ROM_PICK(Bsharku)
2192 STD_ROM_FN(Bsharku)
2193
2194 static struct BurnRomInfo ChasehqRomDesc[] = {
2195 { "b52-130.36", 0x20000, 0x4e7beb46, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2196 { "b52-136.29", 0x20000, 0x2f414df0, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2197 { "b52-131.37", 0x20000, 0xaa945d83, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2198 { "b52-129.30", 0x20000, 0x0eaebc08, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2199
2200 { "b52-132.39", 0x10000, 0xa2f54789, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2201 { "b52-133.55", 0x10000, 0x12232f95, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2202
2203 { "b52-137.51", 0x10000, 0x37abb74a, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2204
2205 { "b52-29.27", 0x80000, 0x8366d27c, BRF_GRA | TAITO_CHARS},
2206
2207 { "b52-34.5", 0x80000, 0x7d8dce36, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2208 { "b52-35.7", 0x80000, 0x78eeec0d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2209 { "b52-36.9", 0x80000, 0x61e89e91, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2210 { "b52-37.11", 0x80000, 0xf02e47b9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2211
2212 { "b52-30.4", 0x80000, 0x1b8cc647, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2213 { "b52-31.6", 0x80000, 0xf1998e20, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2214 { "b52-32.8", 0x80000, 0x8620780c, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2215 { "b52-33.10", 0x80000, 0xe6f4b8c4, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2216
2217 { "b52-28.4", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
2218
2219 { "b52-38.34", 0x80000, 0x5b5bf7f6, BRF_GRA | TAITO_SPRITEMAP },
2220
2221 { "b52-115.71", 0x80000, 0x4e117e93, BRF_SND | TAITO_YM2610A },
2222 { "b52-114.72", 0x80000, 0x3a73d6b1, BRF_SND | TAITO_YM2610A },
2223 { "b52-113.73", 0x80000, 0x2c6a3a05, BRF_SND | TAITO_YM2610A },
2224
2225 { "b52-116.70", 0x80000, 0xad46983c, BRF_SND | TAITO_YM2610B },
2226
2227 { "27c256.ic17", 0x08000, 0xe52dfee1, BRF_OPT },
2228
2229 { "b52-01.7", 0x00100, 0x89719d17, BRF_OPT },
2230 { "b52-03.135", 0x00400, 0xa3f8490d, BRF_OPT },
2231 { "b52-06.24", 0x00100, 0xfbf81f30, BRF_OPT },
2232 { "b52-18.93", 0x00100, 0x60bdaf1a, BRF_OPT },
2233 { "b52-18a", 0x00100, 0x6271be0d, BRF_OPT },
2234 { "b52-49.68", 0x02000, 0x60dd2ed1, BRF_OPT },
2235 { "b52-50.66", 0x10000, 0xc189781c, BRF_OPT },
2236 { "b52-51.65", 0x10000, 0x30cc1f79, BRF_OPT },
2237 { "b52-126.136", 0x00400, 0xfa2f840e, BRF_OPT },
2238 { "b52-127.156", 0x00400, 0x77682a4f, BRF_OPT },
2239
2240 { "pal20l8b-b52-17.ic18", 0x00144, 0x4851316d, BRF_OPT },
2241 { "pal20l8b-b52-17.ic16", 0x00144, 0x4851316d, BRF_OPT },
2242 { "pal20l8b-b52-17.ic53", 0x00144, 0x4851316d, BRF_OPT },
2243 { "pal20l8b-b52-17.ic55", 0x00144, 0x4851316d, BRF_OPT },
2244 { "pal16l8b-b52-19.ic33", 0x00104, 0x3ba292dc, BRF_OPT },
2245 { "pal16l8b-b52-20.ic35", 0x00104, 0xbd39ad73, BRF_OPT },
2246 { "pal16l8b-b52-21.ic51", 0x00104, 0x2fe76aa4, BRF_OPT },
2247 { "pal20l8b-b52-25.ic123", 0x00144, 0x372b632d, BRF_OPT },
2248 { "pal20l8b-b52-26.ic15", 0x00144, 0xd94f2bc2, BRF_OPT },
2249 { "pal20l8b-b52-26.ic18", 0x00144, 0xd94f2bc2, BRF_OPT },
2250 { "pal20l8b-b52-26.ic52", 0x00144, 0xd94f2bc2, BRF_OPT },
2251 { "pal20l8b-b52-26.ic54", 0x00144, 0xd94f2bc2, BRF_OPT },
2252 { "pal20l8b-b52-27.ic64", 0x00144, 0x61c2ab26, BRF_OPT },
2253 { "pal20l8b-b52-118.ic20", 0x00144, 0x9c5fe4af, BRF_OPT },
2254 { "pal20l8b-b52-119.ic21", 0x00144, 0x8b8e2106, BRF_OPT },
2255 { "pal16l8b-b52-120.ic56", 0x00104, 0x3e7effa0, BRF_OPT },
2256 { "pal20l8b-b52-121.ic57", 0x00144, 0x7056fd1d, BRF_OPT },
2257 { "pal16l8b-b52-122.ic124", 0x00104, 0x04c0fb04, BRF_OPT },
2258 { "pal16l8b-b52-123.ic125", 0x00104, 0x3865d1c8, BRF_OPT },
2259 { "pal16l8b-b52-124.ic180", 0x00104, 0xd448a25a, BRF_OPT },
2260 { "pal16l8b-b52-125.ic112", 0x00104, 0x7628c557, BRF_OPT },
2261 };
2262
2263 STD_ROM_PICK(Chasehq)
2264 STD_ROM_FN(Chasehq)
2265
2266 static struct BurnRomInfo ChasehqjRomDesc[] = {
2267 { "b52-140.36", 0x20000, 0xc1298a4b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2268 { "b52-139.29", 0x20000, 0x997f732e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2269 { "b52-131.37", 0x20000, 0xaa945d83, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2270 { "b52-129.30", 0x20000, 0x0eaebc08, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2271
2272 { "b52-132.39", 0x10000, 0xa2f54789, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2273 { "b52-133.55", 0x10000, 0x12232f95, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2274
2275 { "b52-134.51", 0x10000, 0x91faac7f, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2276
2277 { "b52-29.27", 0x80000, 0x8366d27c, BRF_GRA | TAITO_CHARS },
2278
2279 { "b52-34.5", 0x80000, 0x7d8dce36, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2280 { "b52-35.7", 0x80000, 0x78eeec0d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2281 { "b52-36.9", 0x80000, 0x61e89e91, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2282 { "b52-37.11", 0x80000, 0xf02e47b9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2283
2284 { "b52-30.4", 0x80000, 0x1b8cc647, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2285 { "b52-31.6", 0x80000, 0xf1998e20, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2286 { "b52-32.8", 0x80000, 0x8620780c, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2287 { "b52-33.10", 0x80000, 0xe6f4b8c4, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2288
2289 { "b52-28.4", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
2290
2291 { "b52-38.34", 0x80000, 0x5b5bf7f6, BRF_GRA | TAITO_SPRITEMAP },
2292
2293 { "b52-41.71", 0x80000, 0x8204880c, BRF_SND | TAITO_YM2610A },
2294 { "b52-40.72", 0x80000, 0xf0551055, BRF_SND | TAITO_YM2610A },
2295 { "b52-39.73", 0x80000, 0xac9cbbd3, BRF_SND | TAITO_YM2610A },
2296
2297 { "b52-42.70", 0x80000, 0x6e617df1, BRF_SND | TAITO_YM2610B },
2298
2299 { "27c256.ic17", 0x08000, 0xe52dfee1, BRF_OPT },
2300
2301 { "b52-01.7", 0x00100, 0x89719d17, BRF_OPT },
2302 { "b52-03.135", 0x00400, 0xa3f8490d, BRF_OPT },
2303 { "b52-06.24", 0x00100, 0xfbf81f30, BRF_OPT },
2304 { "b52-18.93", 0x00100, 0x60bdaf1a, BRF_OPT },
2305 { "b52-18a", 0x00100, 0x6271be0d, BRF_OPT },
2306 { "b52-49.68", 0x02000, 0x60dd2ed1, BRF_OPT },
2307 { "b52-50.66", 0x10000, 0xc189781c, BRF_OPT },
2308 { "b52-51.65", 0x10000, 0x30cc1f79, BRF_OPT },
2309 { "b52-126.136", 0x00400, 0xfa2f840e, BRF_OPT },
2310 { "b52-127.156", 0x00400, 0x77682a4f, BRF_OPT },
2311
2312 { "pal20l8b-b52-17.ic18", 0x00144, 0x4851316d, BRF_OPT },
2313 { "pal20l8b-b52-17.ic16", 0x00144, 0x4851316d, BRF_OPT },
2314 { "pal20l8b-b52-17.ic53", 0x00144, 0x4851316d, BRF_OPT },
2315 { "pal20l8b-b52-17.ic55", 0x00144, 0x4851316d, BRF_OPT },
2316 { "pal16l8b-b52-19.ic33", 0x00104, 0x3ba292dc, BRF_OPT },
2317 { "pal16l8b-b52-20.ic35", 0x00104, 0xbd39ad73, BRF_OPT },
2318 { "pal16l8b-b52-21.ic51", 0x00104, 0x2fe76aa4, BRF_OPT },
2319 { "pal20l8b-b52-25.ic123", 0x00144, 0x372b632d, BRF_OPT },
2320 { "pal20l8b-b52-26.ic15", 0x00144, 0xd94f2bc2, BRF_OPT },
2321 { "pal20l8b-b52-26.ic18", 0x00144, 0xd94f2bc2, BRF_OPT },
2322 { "pal20l8b-b52-26.ic52", 0x00144, 0xd94f2bc2, BRF_OPT },
2323 { "pal20l8b-b52-26.ic54", 0x00144, 0xd94f2bc2, BRF_OPT },
2324 { "pal20l8b-b52-27.ic64", 0x00144, 0x61c2ab26, BRF_OPT },
2325 { "pal20l8b-b52-118.ic20", 0x00144, 0x9c5fe4af, BRF_OPT },
2326 { "pal20l8b-b52-119.ic21", 0x00144, 0x8b8e2106, BRF_OPT },
2327 { "pal16l8b-b52-120.ic56", 0x00104, 0x3e7effa0, BRF_OPT },
2328 { "pal20l8b-b52-121.ic57", 0x00144, 0x7056fd1d, BRF_OPT },
2329 { "pal16l8b-b52-122.ic124", 0x00104, 0x04c0fb04, BRF_OPT },
2330 { "pal16l8b-b52-123.ic125", 0x00104, 0x3865d1c8, BRF_OPT },
2331 { "pal16l8b-b52-124.ic180", 0x00104, 0xd448a25a, BRF_OPT },
2332 { "pal16l8b-b52-125.ic112", 0x00104, 0x7628c557, BRF_OPT },
2333 };
2334
2335 STD_ROM_PICK(Chasehqj)
2336 STD_ROM_FN(Chasehqj)
2337
2338 static struct BurnRomInfo ChasehqjuRomDesc[] = {
2339 { "b52-130.36", 0x20000, 0x4e7beb46, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2340 { "b52-128.29", 0x20000, 0xc14f2cdc, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2341 { "b52-131.37", 0x20000, 0xaa945d83, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2342 { "b52-129.30", 0x20000, 0x0eaebc08, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2343
2344 { "b52-132.39", 0x10000, 0xa2f54789, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2345 { "b52-133.55", 0x10000, 0x12232f95, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2346
2347 { "b52-134.51", 0x10000, 0x91faac7f, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2348
2349 { "b52-29.27", 0x80000, 0x8366d27c, BRF_GRA | TAITO_CHARS },
2350
2351 { "b52-34.5", 0x80000, 0x7d8dce36, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2352 { "b52-35.7", 0x80000, 0x78eeec0d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2353 { "b52-36.9", 0x80000, 0x61e89e91, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2354 { "b52-37.11", 0x80000, 0xf02e47b9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2355
2356 { "b52-30.4", 0x80000, 0x1b8cc647, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2357 { "b52-31.6", 0x80000, 0xf1998e20, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2358 { "b52-32.8", 0x80000, 0x8620780c, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2359 { "b52-33.10", 0x80000, 0xe6f4b8c4, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2360
2361 { "b52-28.4", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
2362
2363 { "b52-38.34", 0x80000, 0x5b5bf7f6, BRF_GRA | TAITO_SPRITEMAP },
2364
2365 { "b52-41.71", 0x80000, 0x8204880c, BRF_SND | TAITO_YM2610A },
2366 { "b52-40.72", 0x80000, 0xf0551055, BRF_SND | TAITO_YM2610A },
2367 { "b52-39.73", 0x80000, 0xac9cbbd3, BRF_SND | TAITO_YM2610A },
2368
2369 { "b52-42.70", 0x80000, 0x6e617df1, BRF_SND | TAITO_YM2610B },
2370
2371 { "b52-01.7", 0x00100, 0x89719d17, BRF_OPT },
2372 { "b52-03.135", 0x00400, 0xa3f8490d, BRF_OPT },
2373 { "b52-06.24", 0x00100, 0xfbf81f30, BRF_OPT },
2374 { "b52-18.93", 0x00100, 0x60bdaf1a, BRF_OPT },
2375 { "b52-18a", 0x00100, 0x6271be0d, BRF_OPT },
2376 { "b52-49.68", 0x02000, 0x60dd2ed1, BRF_OPT },
2377 { "b52-50.66", 0x10000, 0xc189781c, BRF_OPT },
2378 { "b52-51.65", 0x10000, 0x30cc1f79, BRF_OPT },
2379 { "b52-126.136", 0x00400, 0xfa2f840e, BRF_OPT },
2380 { "b52-127.156", 0x00400, 0x77682a4f, BRF_OPT },
2381
2382 { "pal20l8b-b52-17.ic18", 0x00144, 0x4851316d, BRF_OPT },
2383 { "pal20l8b-b52-17.ic16", 0x00144, 0x4851316d, BRF_OPT },
2384 { "pal20l8b-b52-17.ic53", 0x00144, 0x4851316d, BRF_OPT },
2385 { "pal20l8b-b52-17.ic55", 0x00144, 0x4851316d, BRF_OPT },
2386 { "pal16l8b-b52-19.ic33", 0x00104, 0x3ba292dc, BRF_OPT },
2387 { "pal16l8b-b52-20.ic35", 0x00104, 0xbd39ad73, BRF_OPT },
2388 { "pal16l8b-b52-21.ic51", 0x00104, 0x2fe76aa4, BRF_OPT },
2389 { "pal20l8b-b52-25.ic123", 0x00144, 0x372b632d, BRF_OPT },
2390 { "pal20l8b-b52-26.ic15", 0x00144, 0xd94f2bc2, BRF_OPT },
2391 { "pal20l8b-b52-26.ic18", 0x00144, 0xd94f2bc2, BRF_OPT },
2392 { "pal20l8b-b52-26.ic52", 0x00144, 0xd94f2bc2, BRF_OPT },
2393 { "pal20l8b-b52-26.ic54", 0x00144, 0xd94f2bc2, BRF_OPT },
2394 { "pal20l8b-b52-27.ic64", 0x00144, 0x61c2ab26, BRF_OPT },
2395 { "pal20l8b-b52-118.ic20", 0x00144, 0x9c5fe4af, BRF_OPT },
2396 { "pal20l8b-b52-119.ic21", 0x00144, 0x8b8e2106, BRF_OPT },
2397 { "pal16l8b-b52-120.ic56", 0x00104, 0x3e7effa0, BRF_OPT },
2398 { "pal20l8b-b52-121.ic57", 0x00144, 0x7056fd1d, BRF_OPT },
2399 { "pal16l8b-b52-122.ic124", 0x00104, 0x04c0fb04, BRF_OPT },
2400 { "pal16l8b-b52-123.ic125", 0x00104, 0x3865d1c8, BRF_OPT },
2401 { "pal16l8b-b52-124.ic180", 0x00104, 0xd448a25a, BRF_OPT },
2402 { "pal16l8b-b52-125.ic112", 0x00104, 0x7628c557, BRF_OPT },
2403 };
2404
2405 STD_ROM_PICK(Chasehqju)
2406 STD_ROM_FN(Chasehqju)
2407
2408 static struct BurnRomInfo ChasehquRomDesc[] = {
2409 { "b52-138.36", 0x20000, 0x8b71fe51, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2410 { "b52-135.29", 0x20000, 0x5ba56a7c, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2411 { "b52-131.37", 0x20000, 0xaa945d83, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2412 { "b52-129.30", 0x20000, 0x0eaebc08, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2413
2414 { "b52-132.39", 0x10000, 0xa2f54789, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2415 { "b52-133.55", 0x10000, 0x12232f95, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2416
2417 { "b52-137.51", 0x10000, 0x37abb74a, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2418
2419 { "b52-29.27", 0x80000, 0x8366d27c, BRF_GRA | TAITO_CHARS},
2420
2421 { "b52-34.5", 0x80000, 0x7d8dce36, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2422 { "b52-35.7", 0x80000, 0x78eeec0d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2423 { "b52-36.9", 0x80000, 0x61e89e91, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2424 { "b52-37.11", 0x80000, 0xf02e47b9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2425
2426 { "b52-30.4", 0x80000, 0x1b8cc647, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2427 { "b52-31.6", 0x80000, 0xf1998e20, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2428 { "b52-32.8", 0x80000, 0x8620780c, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2429 { "b52-33.10", 0x80000, 0xe6f4b8c4, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2430
2431 { "b52-28.4", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
2432
2433 { "b52-38.34", 0x80000, 0x5b5bf7f6, BRF_GRA | TAITO_SPRITEMAP },
2434
2435 { "b52-115.71", 0x80000, 0x4e117e93, BRF_SND | TAITO_YM2610A },
2436 { "b52-114.72", 0x80000, 0x3a73d6b1, BRF_SND | TAITO_YM2610A },
2437 { "b52-113.73", 0x80000, 0x2c6a3a05, BRF_SND | TAITO_YM2610A },
2438
2439 { "b52-116.70", 0x80000, 0xad46983c, BRF_SND | TAITO_YM2610B },
2440
2441 { "27c256.ic17", 0x08000, 0xe52dfee1, BRF_OPT },
2442
2443 { "b52-01.7", 0x00100, 0x89719d17, BRF_OPT },
2444 { "b52-03.135", 0x00400, 0xa3f8490d, BRF_OPT },
2445 { "b52-06.24", 0x00100, 0xfbf81f30, BRF_OPT },
2446 { "b52-18.93", 0x00100, 0x60bdaf1a, BRF_OPT },
2447 { "b52-18a", 0x00100, 0x6271be0d, BRF_OPT },
2448 { "b52-49.68", 0x02000, 0x60dd2ed1, BRF_OPT },
2449 { "b52-50.66", 0x10000, 0xc189781c, BRF_OPT },
2450 { "b52-51.65", 0x10000, 0x30cc1f79, BRF_OPT },
2451 { "b52-126.136", 0x00400, 0xfa2f840e, BRF_OPT },
2452 { "b52-127.156", 0x00400, 0x77682a4f, BRF_OPT },
2453
2454 { "pal20l8b-b52-17.ic18", 0x00144, 0x4851316d, BRF_OPT },
2455 { "pal20l8b-b52-17.ic16", 0x00144, 0x4851316d, BRF_OPT },
2456 { "pal20l8b-b52-17.ic53", 0x00144, 0x4851316d, BRF_OPT },
2457 { "pal20l8b-b52-17.ic55", 0x00144, 0x4851316d, BRF_OPT },
2458 { "pal16l8b-b52-19.ic33", 0x00104, 0x3ba292dc, BRF_OPT },
2459 { "pal16l8b-b52-20.ic35", 0x00104, 0xbd39ad73, BRF_OPT },
2460 { "pal16l8b-b52-21.ic51", 0x00104, 0x2fe76aa4, BRF_OPT },
2461 { "pal20l8b-b52-25.ic123", 0x00144, 0x372b632d, BRF_OPT },
2462 { "pal20l8b-b52-26.ic15", 0x00144, 0xd94f2bc2, BRF_OPT },
2463 { "pal20l8b-b52-26.ic18", 0x00144, 0xd94f2bc2, BRF_OPT },
2464 { "pal20l8b-b52-26.ic52", 0x00144, 0xd94f2bc2, BRF_OPT },
2465 { "pal20l8b-b52-26.ic54", 0x00144, 0xd94f2bc2, BRF_OPT },
2466 { "pal20l8b-b52-27.ic64", 0x00144, 0x61c2ab26, BRF_OPT },
2467 { "pal20l8b-b52-118.ic20", 0x00144, 0x9c5fe4af, BRF_OPT },
2468 { "pal20l8b-b52-119.ic21", 0x00144, 0x8b8e2106, BRF_OPT },
2469 { "pal16l8b-b52-120.ic56", 0x00104, 0x3e7effa0, BRF_OPT },
2470 { "pal20l8b-b52-121.ic57", 0x00144, 0x7056fd1d, BRF_OPT },
2471 { "pal16l8b-b52-122.ic124", 0x00104, 0x04c0fb04, BRF_OPT },
2472 { "pal16l8b-b52-123.ic125", 0x00104, 0x3865d1c8, BRF_OPT },
2473 { "pal16l8b-b52-124.ic180", 0x00104, 0xd448a25a, BRF_OPT },
2474 { "pal16l8b-b52-125.ic112", 0x00104, 0x7628c557, BRF_OPT },
2475 };
2476
2477 STD_ROM_PICK(Chasehqu)
2478 STD_ROM_FN(Chasehqu)
2479
2480 static struct BurnRomInfo ContcircRomDesc[] = {
2481 { "b33-ww.ic25", 0x20000, 0xf5c92e42, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2482 { "b33-xx.ic26", 0x20000, 0xe7c1d1fa, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2483
2484 { "b33-yy.ic35", 0x20000, 0x16522f2d, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2485 { "cc_36.bin", 0x20000, 0xa1732ea5, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2486
2487 { "b33-30.11", 0x10000, 0xd8746234, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2488
2489 { "b33-02.57", 0x80000, 0xf6fb3ba2, BRF_GRA | TAITO_CHARS },
2490
2491 { "b33-06", 0x80000, 0x2cb40599, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2492 { "b33-05", 0x80000, 0xbddf9eea, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2493 { "b33-04", 0x80000, 0x8df866a2, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2494 { "b33-03", 0x80000, 0x4f6c36d9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2495
2496 { "b33-01.3", 0x80000, 0xf11f2be8, BRF_GRA | TAITO_ROAD },
2497
2498 { "b33-07.64", 0x80000, 0x151e1f52, BRF_GRA | TAITO_SPRITEMAP },
2499
2500 { "b33-09.18", 0x80000, 0x1e6724b5, BRF_SND | TAITO_YM2610A },
2501 { "b33-10.17", 0x80000, 0xe9ce03ab, BRF_SND | TAITO_YM2610A },
2502
2503 { "b33-08.19", 0x80000, 0xcaa1c4c8, BRF_SND | TAITO_YM2610B },
2504
2505 { "b14-30.97", 0x10000, 0xdccb0c7f, BRF_OPT },
2506 { "b14-31.50", 0x02000, 0x5c6b013d, BRF_OPT },
2507 { "b33-17.16", 0x00100, 0x7b7d8ff4, BRF_OPT },
2508 { "b33-18.17", 0x00100, 0xfbf81f30, BRF_OPT },
2509 };
2510
2511 STD_ROM_PICK(Contcirc)
2512 STD_ROM_FN(Contcirc)
2513
2514 static struct BurnRomInfo ContcircuRomDesc[] = {
2515 { "b33-ww.ic25", 0x20000, 0xf5c92e42, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2516 { "b33-xx.ic26", 0x20000, 0xe7c1d1fa, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2517
2518 { "b33-yy.ic35", 0x20000, 0x16522f2d, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2519 { "b33-zz.ic36", 0x20000, 0xd6741e33, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2520
2521 { "b33-30.11", 0x10000, 0xd8746234, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2522
2523 { "b33-02.57", 0x80000, 0xf6fb3ba2, BRF_GRA | TAITO_CHARS },
2524
2525 { "b33-06", 0x80000, 0x2cb40599, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2526 { "b33-05", 0x80000, 0xbddf9eea, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2527 { "b33-04", 0x80000, 0x8df866a2, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2528 { "b33-03", 0x80000, 0x4f6c36d9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2529
2530 { "b33-01.3", 0x80000, 0xf11f2be8, BRF_GRA | TAITO_ROAD },
2531
2532 { "b33-07.64", 0x80000, 0x151e1f52, BRF_GRA | TAITO_SPRITEMAP },
2533
2534 { "b33-09.18", 0x80000, 0x1e6724b5, BRF_SND | TAITO_YM2610A },
2535 { "b33-10.17", 0x80000, 0xe9ce03ab, BRF_SND | TAITO_YM2610A },
2536
2537 { "b33-08.19", 0x80000, 0xcaa1c4c8, BRF_SND | TAITO_YM2610B },
2538
2539 { "b14-30.97", 0x10000, 0xdccb0c7f, BRF_OPT },
2540 { "b14-31.50", 0x02000, 0x5c6b013d, BRF_OPT },
2541 { "b33-17.16", 0x00100, 0x7b7d8ff4, BRF_OPT },
2542 { "b33-18.17", 0x00100, 0xfbf81f30, BRF_OPT },
2543 };
2544
2545 STD_ROM_PICK(Contcircu)
2546 STD_ROM_FN(Contcircu)
2547
2548 static struct BurnRomInfo ContcircuaRomDesc[] = {
2549 { "b33-34.ic25", 0x20000, 0xe1e016c1, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2550 { "b33-33.ic26", 0x20000, 0xf539d44b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2551
2552 { "b33-21-2.ic35", 0x20000, 0x2723f9e3, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2553 { "b33-31-1.ic36", 0x20000, 0x438431f7, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2554
2555 { "b33-30.11", 0x10000, 0xd8746234, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2556
2557 { "b33-02.57", 0x80000, 0xf6fb3ba2, BRF_GRA | TAITO_CHARS },
2558
2559 { "b33-06", 0x80000, 0x2cb40599, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2560 { "b33-05", 0x80000, 0xbddf9eea, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2561 { "b33-04", 0x80000, 0x8df866a2, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2562 { "b33-03", 0x80000, 0x4f6c36d9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2563
2564 { "b33-01.3", 0x80000, 0xf11f2be8, BRF_GRA | TAITO_ROAD },
2565
2566 { "b33-07.64", 0x80000, 0x151e1f52, BRF_GRA | TAITO_SPRITEMAP },
2567
2568 { "b33-09.18", 0x80000, 0x1e6724b5, BRF_SND | TAITO_YM2610A },
2569 { "b33-10.17", 0x80000, 0xe9ce03ab, BRF_SND | TAITO_YM2610A },
2570
2571 { "b33-08.19", 0x80000, 0xcaa1c4c8, BRF_SND | TAITO_YM2610B },
2572
2573 { "b14-30.97", 0x10000, 0xdccb0c7f, BRF_OPT },
2574 { "b14-31.50", 0x02000, 0x5c6b013d, BRF_OPT },
2575 { "b33-17.16", 0x00100, 0x7b7d8ff4, BRF_OPT },
2576 { "b33-18.17", 0x00100, 0xfbf81f30, BRF_OPT },
2577 };
2578
2579 STD_ROM_PICK(Contcircua)
2580 STD_ROM_FN(Contcircua)
2581
2582 static struct BurnRomInfo ContcircjRomDesc[] = {
2583 { "b33-19.ic25", 0x20000, 0xb85360c8, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2584 { "b33-20.ic26", 0x20000, 0x9f88378b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2585
2586 { "b33-21-2.ic35", 0x20000, 0x2723f9e3, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2587 { "b33-22-2.ic36", 0x20000, 0xda8d604d, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2588
2589 { "b33-30.11", 0x10000, 0xd8746234, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2590
2591 { "b33-02.57", 0x80000, 0xf6fb3ba2, BRF_GRA | TAITO_CHARS },
2592
2593 { "b33-06", 0x80000, 0x2cb40599, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2594 { "b33-05", 0x80000, 0xbddf9eea, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2595 { "b33-04", 0x80000, 0x8df866a2, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2596 { "b33-03", 0x80000, 0x4f6c36d9, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2597
2598 { "b33-01.3", 0x80000, 0xf11f2be8, BRF_GRA | TAITO_ROAD },
2599
2600 { "b33-07.64", 0x80000, 0x151e1f52, BRF_GRA | TAITO_SPRITEMAP },
2601
2602 { "b33-09.18", 0x80000, 0x1e6724b5, BRF_SND | TAITO_YM2610A },
2603 { "b33-10.17", 0x80000, 0xe9ce03ab, BRF_SND | TAITO_YM2610A },
2604
2605 { "b33-08.19", 0x80000, 0xcaa1c4c8, BRF_SND | TAITO_YM2610B },
2606
2607 { "b14-30.97", 0x10000, 0xdccb0c7f, BRF_OPT },
2608 { "b14-31.50", 0x02000, 0x5c6b013d, BRF_OPT },
2609 { "b33-17.16", 0x00100, 0x7b7d8ff4, BRF_OPT },
2610 { "b33-18.17", 0x00100, 0xfbf81f30, BRF_OPT },
2611 };
2612
2613 STD_ROM_PICK(Contcircj)
2614 STD_ROM_FN(Contcircj)
2615
2616 static struct BurnRomInfo DblaxleRomDesc[] = {
2617 /* Manual refers to this version as the "Version Without Communication" */
2618 { "c78_49-1.2", 0x020000, 0xa6f0c631, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2619 { "c78_51-1.4", 0x020000, 0xef24e83b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2620 { "c78_50-1.3", 0x020000, 0x8b0440f4, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2621 { "c78_53-1.5", 0x020000, 0x2bb91763, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2622
2623 { "c78-30-1.35", 0x020000, 0x026aac18, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2624 { "c78-31-1.36", 0x020000, 0x67ce23e8, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2625
2626 { "c78-34.c42", 0x020000, 0xf2186943, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2627
2628 { "c78-10.12", 0x080000, 0x44b1897c, BRF_GRA | TAITO_CHARS_BYTESWAP },
2629 { "c78-11.11", 0x080000, 0x7db3d4a3, BRF_GRA | TAITO_CHARS_BYTESWAP },
2630
2631 { "c78-08.25", 0x100000, 0x6c725211, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2632 { "c78-07.33", 0x100000, 0x9da00d5b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2633 { "c78-06.23", 0x100000, 0x8309e91b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2634 { "c78-05.31", 0x100000, 0x90001f68, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2635
2636 { "c78-09.12", 0x080000, 0x0dbde6f5, BRF_GRA | TAITO_ROAD },
2637
2638 { "c78-04.3", 0x080000, 0xcc1aa37c, BRF_GRA | TAITO_SPRITEMAP },
2639
2640 { "c78-12.33", 0x100000, 0xb0267404, BRF_SND | TAITO_YM2610A },
2641 { "c78-13.46", 0x080000, 0x1b363aa2, BRF_SND | TAITO_YM2610A },
2642
2643 { "c78-14.31", 0x080000, 0x9cad4dfb, BRF_SND | TAITO_YM2610B },
2644
2645 { "c78-25.15", 0x010000, 0x7245a6f6, BRF_OPT },
2646 { "c78-15.22", 0x000100, 0xfbf81f30, BRF_OPT },
2647 { "c78-21.74", 0x000100, 0x2926bf27, BRF_OPT },
2648 { "c84-10.16", 0x000400, 0x643e8bfc, BRF_OPT },
2649 { "c84-11.17", 0x000400, 0x10728853, BRF_OPT },
2650 };
2651
2652 STD_ROM_PICK(Dblaxle)
2653 STD_ROM_FN(Dblaxle)
2654
2655 static struct BurnRomInfo DblaxleuRomDesc[] = {
2656 /* Manual refers to this version as the "Version Without Communication" */
2657 { "c78_49+.2", 0x020000, 0x3bb0344a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2658 { "c78_51+.4", 0x020000, 0x918176cb, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2659 { "c78_50+.3", 0x020000, 0x5a12e2bb, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2660 { "c78_53+.5", 0x020000, 0x62f910d4, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2661
2662 { "c78-30+.35", 0x020000, 0xf73b3ce1, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2663 { "c78-31+.36", 0x020000, 0x4639adee, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2664
2665 { "c78-34.c42", 0x020000, 0xf2186943, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2666
2667 { "c78-10.12", 0x080000, 0x44b1897c, BRF_GRA | TAITO_CHARS_BYTESWAP },
2668 { "c78-11.11", 0x080000, 0x7db3d4a3, BRF_GRA | TAITO_CHARS_BYTESWAP },
2669
2670 { "c78-08.25", 0x100000, 0x6c725211, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2671 { "c78-07.33", 0x100000, 0x9da00d5b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2672 { "c78-06.23", 0x100000, 0x8309e91b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2673 { "c78-05.31", 0x100000, 0x90001f68, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2674
2675 { "c78-09.12", 0x080000, 0x0dbde6f5, BRF_GRA | TAITO_ROAD },
2676
2677 { "c78-04.3", 0x080000, 0xcc1aa37c, BRF_GRA | TAITO_SPRITEMAP },
2678
2679 { "c78-12.33", 0x100000, 0xb0267404, BRF_SND | TAITO_YM2610A },
2680 { "c78-13.46", 0x080000, 0x1b363aa2, BRF_SND | TAITO_YM2610A },
2681
2682 { "c78-14.31", 0x080000, 0x9cad4dfb, BRF_SND | TAITO_YM2610B },
2683
2684 { "c78-25.15", 0x010000, 0x7245a6f6, BRF_OPT },
2685 { "c78-15.22", 0x000100, 0xfbf81f30, BRF_OPT },
2686 { "c78-21.74", 0x000100, 0x2926bf27, BRF_OPT },
2687 { "c84-10.16", 0x000400, 0x643e8bfc, BRF_OPT },
2688 { "c84-11.17", 0x000400, 0x10728853, BRF_OPT },
2689 };
2690
2691 STD_ROM_PICK(Dblaxleu)
2692 STD_ROM_FN(Dblaxleu)
2693
2694 static struct BurnRomInfo DblaxleulRomDesc[] = {
2695 /* Side by side linkable version */
2696 { "c78_41-1.2", 0x020000, 0xcf297fe4, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2697 { "c78_43-1.4", 0x020000, 0x38a8bad6, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2698 { "c78_42-1.3", 0x020000, 0x4124ab2b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2699 { "c78_44-1.5", 0x020000, 0x50a55b6e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2700
2701 { "c78-30-1.35", 0x020000, 0x026aac18, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2702 { "c78-31-1.36", 0x020000, 0x67ce23e8, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2703
2704 { "c78-34.c42", 0x020000, 0xf2186943, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2705
2706 { "c78-10.12", 0x080000, 0x44b1897c, BRF_GRA | TAITO_CHARS_BYTESWAP },
2707 { "c78-11.11", 0x080000, 0x7db3d4a3, BRF_GRA | TAITO_CHARS_BYTESWAP },
2708
2709 { "c78-08.25", 0x100000, 0x6c725211, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2710 { "c78-07.33", 0x100000, 0x9da00d5b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2711 { "c78-06.23", 0x100000, 0x8309e91b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2712 { "c78-05.31", 0x100000, 0x90001f68, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2713
2714 { "c78-09.12", 0x080000, 0x0dbde6f5, BRF_GRA | TAITO_ROAD },
2715
2716 { "c78-04.3", 0x080000, 0xcc1aa37c, BRF_GRA | TAITO_SPRITEMAP },
2717
2718 { "c78-12.33", 0x100000, 0xb0267404, BRF_SND | TAITO_YM2610A },
2719 { "c78-13.46", 0x080000, 0x1b363aa2, BRF_SND | TAITO_YM2610A },
2720
2721 { "c78-14.31", 0x080000, 0x9cad4dfb, BRF_SND | TAITO_YM2610B },
2722
2723 { "c78-25.15", 0x010000, 0x7245a6f6, BRF_OPT },
2724 { "c78-15.22", 0x000100, 0xfbf81f30, BRF_OPT },
2725 { "c78-21.74", 0x000100, 0x2926bf27, BRF_OPT },
2726 { "c84-10.16", 0x000400, 0x643e8bfc, BRF_OPT },
2727 { "c84-11.17", 0x000400, 0x10728853, BRF_OPT },
2728 };
2729
2730 STD_ROM_PICK(Dblaxleul)
2731 STD_ROM_FN(Dblaxleul)
2732
2733 static struct BurnRomInfo PwheelsjRomDesc[] = {
2734 /* Side by side linkable version */
2735 { "c78_26-2.2", 0x020000, 0x25c8eb2e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2736 { "c78_28-2.4", 0x020000, 0xa9500eb1, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2737 { "c78_27-2.3", 0x020000, 0x08d2cffb, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2738 { "c78_29-2.5", 0x020000, 0xe1608004, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2739
2740 { "c78-30-1.35", 0x020000, 0x026aac18, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2741 { "c78-31-1.36", 0x020000, 0x67ce23e8, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2742
2743 { "c78-32.42", 0x020000, 0x1494199c, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2744
2745 { "c78-10.12", 0x080000, 0x44b1897c, BRF_GRA | TAITO_CHARS_BYTESWAP },
2746 { "c78-11.11", 0x080000, 0x7db3d4a3, BRF_GRA | TAITO_CHARS_BYTESWAP },
2747
2748 { "c78-08.25", 0x100000, 0x6c725211, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2749 { "c78-07.33", 0x100000, 0x9da00d5b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2750 { "c78-06.23", 0x100000, 0x8309e91b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2751 { "c78-05.31", 0x100000, 0x90001f68, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2752
2753 { "c78-09.12", 0x080000, 0x0dbde6f5, BRF_GRA | TAITO_ROAD },
2754
2755 { "c78-04.3", 0x080000, 0xcc1aa37c, BRF_GRA | TAITO_SPRITEMAP },
2756
2757 { "c78-01.33", 0x100000, 0x90ff1e72, BRF_SND | TAITO_YM2610A },
2758 { "c78-02.46", 0x080000, 0x8882d2b7, BRF_SND | TAITO_YM2610A },
2759
2760 { "c78-03.31", 0x080000, 0x9b926a2f, BRF_SND | TAITO_YM2610B },
2761
2762 { "c78-25.15", 0x010000, 0x7245a6f6, BRF_OPT },
2763 { "c78-15.22", 0x000100, 0xfbf81f30, BRF_OPT },
2764 { "c78-21.74", 0x000100, 0x2926bf27, BRF_OPT },
2765 { "c84-10.16", 0x000400, 0x643e8bfc, BRF_OPT },
2766 { "c84-11.17", 0x000400, 0x10728853, BRF_OPT },
2767 };
2768
2769 STD_ROM_PICK(Pwheelsj)
2770 STD_ROM_FN(Pwheelsj)
2771
2772 static struct BurnRomInfo EnforceRomDesc[] = {
2773 { "b58-38.27", 0x20000, 0xa1aa0191, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2774 { "b58-36.19", 0x20000, 0x40f43da3, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2775
2776 { "b58-37.26", 0x20000, 0xe823c85c, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2777 { "b58-35.18", 0x20000, 0x8b3ceb12, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2778
2779 { "b58-32.41", 0x10000, 0xf3fd8eca, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2780
2781 { "b58-09.13", 0x80000, 0x9ffd5b31, BRF_GRA | TAITO_CHARS },
2782
2783 { "b58-04.7", 0x80000, 0x9482f08d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2784 { "b58-03.6", 0x80000, 0x158bc440, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2785 { "b58-02.2", 0x80000, 0x6a6e307c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2786 { "b58-01.1", 0x80000, 0x01e9f0a8, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2787
2788 { "b58-06.116", 0x80000, 0xb3495d70, BRF_GRA | TAITO_ROAD },
2789
2790 { "b58-05.71", 0x80000, 0xd1f4991b, BRF_GRA | TAITO_SPRITEMAP },
2791
2792 { "b58-07.11", 0x80000, 0xeeb5ba08, BRF_SND | TAITO_YM2610A },
2793 { "b58-08.12", 0x80000, 0x049243cf, BRF_SND | TAITO_YM2610A },
2794
2795 { "b58-10.14", 0x80000, 0xedce0cc1, BRF_SND | TAITO_YM2610B },
2796
2797 { "b58-26.104", 0x10000, 0xdccb0c7f, BRF_OPT },
2798 { "b58-27.56", 0x02000, 0x5c6b013d, BRF_OPT },
2799 { "b58-23.52", 0x00100, 0x7b7d8ff4, BRF_OPT },
2800 { "b58-24.51", 0x00100, 0xfbf81f30, BRF_OPT },
2801 { "b58-25.75", 0x00100, 0xde547342, BRF_OPT },
2802 };
2803
2804 STD_ROM_PICK(Enforce)
2805 STD_ROM_FN(Enforce)
2806
2807 static struct BurnRomInfo EnforcejRomDesc[] = {
2808 { "b58-17.27", 0x20000, 0xa1aa0191, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2809 { "b58-19.19", 0x20000, 0x40f43da3, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2810
2811 { "b58-16.26", 0x20000, 0xe823c85c, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2812 { "b58-18.18", 0x20000, 0x65328a3e, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2813
2814 { "b58-32.41", 0x10000, 0xf3fd8eca, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2815
2816 { "b58-09.13", 0x80000, 0x9ffd5b31, BRF_GRA | TAITO_CHARS },
2817
2818 { "b58-04.7", 0x80000, 0x9482f08d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2819 { "b58-03.6", 0x80000, 0x158bc440, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2820 { "b58-02.2", 0x80000, 0x6a6e307c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2821 { "b58-01.1", 0x80000, 0x01e9f0a8, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2822
2823 { "b58-06.116", 0x80000, 0xb3495d70, BRF_GRA | TAITO_ROAD },
2824
2825 { "b58-05.71", 0x80000, 0xd1f4991b, BRF_GRA | TAITO_SPRITEMAP },
2826
2827 { "b58-07.11", 0x80000, 0xeeb5ba08, BRF_SND | TAITO_YM2610A },
2828 { "b58-08.12", 0x80000, 0x049243cf, BRF_SND | TAITO_YM2610A },
2829
2830 { "b58-10.14", 0x80000, 0xedce0cc1, BRF_SND | TAITO_YM2610B },
2831
2832 { "b58-26.104", 0x10000, 0xdccb0c7f, BRF_OPT },
2833 { "b58-27.56", 0x02000, 0x5c6b013d, BRF_OPT },
2834 { "b58-23.52", 0x00100, 0x7b7d8ff4, BRF_OPT },
2835 { "b58-24.51", 0x00100, 0xfbf81f30, BRF_OPT },
2836 { "b58-25.75", 0x00100, 0xde547342, BRF_OPT },
2837 };
2838
2839 STD_ROM_PICK(Enforcej)
2840 STD_ROM_FN(Enforcej)
2841
2842 static struct BurnRomInfo EnforcejaRomDesc[] = {
2843 { "b58-31.27", 0x20000, 0xd686e371, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2844 { "b58-30.19", 0x20000, 0xcd73c0d8, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2845
2846 { "b58-29.26", 0x20000, 0x8482a4e4, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2847 { "b58-28.18", 0x20000, 0x9735e2b1, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2848
2849 { "b58-32.41", 0x10000, 0xf3fd8eca, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2850
2851 { "b58-09.13", 0x80000, 0x9ffd5b31, BRF_GRA | TAITO_CHARS },
2852
2853 { "b58-04.7", 0x80000, 0x9482f08d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2854 { "b58-03.6", 0x80000, 0x158bc440, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2855 { "b58-02.2", 0x80000, 0x6a6e307c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2856 { "b58-01.1", 0x80000, 0x01e9f0a8, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2857
2858 { "b58-06.116", 0x80000, 0xb3495d70, BRF_GRA | TAITO_ROAD },
2859
2860 { "b58-05.71", 0x80000, 0xd1f4991b, BRF_GRA | TAITO_SPRITEMAP },
2861
2862 { "b58-07.11", 0x80000, 0xeeb5ba08, BRF_SND | TAITO_YM2610A },
2863 { "b58-08.12", 0x80000, 0x049243cf, BRF_SND | TAITO_YM2610A },
2864
2865 { "b58-10.14", 0x80000, 0xedce0cc1, BRF_SND | TAITO_YM2610B },
2866
2867 { "b58-26.104", 0x10000, 0xdccb0c7f, BRF_OPT },
2868 { "b58-27.56", 0x02000, 0x5c6b013d, BRF_OPT },
2869 { "b58-23.52", 0x00100, 0x7b7d8ff4, BRF_OPT },
2870 { "b58-24.51", 0x00100, 0xfbf81f30, BRF_OPT },
2871 { "b58-25.75", 0x00100, 0xde547342, BRF_OPT },
2872 };
2873
2874 STD_ROM_PICK(Enforceja)
2875 STD_ROM_FN(Enforceja)
2876
2877 static struct BurnRomInfo NightstrRomDesc[] = {
2878 { "b91-45.bin", 0x20000, 0x7ad63421, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2879 { "b91-44.bin", 0x20000, 0x4bc30adf, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2880 { "b91-43.bin", 0x20000, 0x3e6f727a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2881 { "b91-47.bin", 0x20000, 0x9f778e03, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2882
2883 { "b91-39.bin", 0x20000, 0x725b23ae, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2884 { "b91-40.bin", 0x20000, 0x81fb364d, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2885
2886 { "b91-41.bin", 0x20000, 0x2694bb42, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2887
2888 { "b91-11.bin", 0x80000, 0xfff8ce31, BRF_GRA | TAITO_CHARS },
2889
2890 { "b91-04.bin", 0x80000, 0x8ca1970d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2891 { "b91-03.bin", 0x80000, 0xcd5fed39, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2892 { "b91-02.bin", 0x80000, 0x457c64b8, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2893 { "b91-01.bin", 0x80000, 0x3731d94f, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2894
2895 { "b91-08.bin", 0x80000, 0x66f35c34, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2896 { "b91-07.bin", 0x80000, 0x4d8ec6cf, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2897 { "b91-06.bin", 0x80000, 0xa34dc839, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2898 { "b91-05.bin", 0x80000, 0x5e72ac90, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2899
2900 { "b91-10.bin", 0x80000, 0x1d8f05b4, BRF_GRA | TAITO_ROAD },
2901
2902 { "b91-09.bin", 0x80000, 0x5f247ca2, BRF_GRA | TAITO_SPRITEMAP },
2903
2904 { "b91-13.bin", 0x80000, 0x8c7bf0f5, BRF_SND | TAITO_YM2610A },
2905 { "b91-12.bin", 0x80000, 0xda77c7af, BRF_SND | TAITO_YM2610A },
2906
2907 { "b91-14.bin", 0x80000, 0x6bc314d3, BRF_SND | TAITO_YM2610B },
2908
2909 { "b91-26.bin", 0x00400, 0x77682a4f, BRF_OPT },
2910 { "b91-27.bin", 0x00400, 0xa3f8490d, BRF_OPT },
2911 { "b91-28.bin", 0x00400, 0xfa2f840e, BRF_OPT },
2912 { "b91-29.bin", 0x02000, 0xad685be8, BRF_OPT },
2913 { "b91-30.bin", 0x10000, 0x30cc1f79, BRF_OPT },
2914 { "b91-31.bin", 0x10000, 0xc189781c, BRF_OPT },
2915 { "b91-32.bin", 0x00100, 0xfbf81f30, BRF_OPT },
2916 { "b91-33.bin", 0x00100, 0x89719d17, BRF_OPT },
2917 };
2918
2919 STD_ROM_PICK(Nightstr)
2920 STD_ROM_FN(Nightstr)
2921
2922 static struct BurnRomInfo NightstrjRomDesc[] = {
2923 { "b91-45.bin", 0x20000, 0x7ad63421, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2924 { "b91-44.bin", 0x20000, 0x4bc30adf, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2925 { "b91-43.bin", 0x20000, 0x3e6f727a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2926 { "b91-42.bin", 0x20000, 0x7179ef2f, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2927
2928 { "b91-39.bin", 0x20000, 0x725b23ae, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2929 { "b91-40.bin", 0x20000, 0x81fb364d, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2930
2931 { "b91-41.bin", 0x20000, 0x2694bb42, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2932
2933 { "b91-11.bin", 0x80000, 0xfff8ce31, BRF_GRA | TAITO_CHARS },
2934
2935 { "b91-04.bin", 0x80000, 0x8ca1970d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2936 { "b91-03.bin", 0x80000, 0xcd5fed39, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2937 { "b91-02.bin", 0x80000, 0x457c64b8, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2938 { "b91-01.bin", 0x80000, 0x3731d94f, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2939
2940 { "b91-08.bin", 0x80000, 0x66f35c34, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2941 { "b91-07.bin", 0x80000, 0x4d8ec6cf, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2942 { "b91-06.bin", 0x80000, 0xa34dc839, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2943 { "b91-05.bin", 0x80000, 0x5e72ac90, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2944
2945 { "b91-10.bin", 0x80000, 0x1d8f05b4, BRF_GRA | TAITO_ROAD },
2946
2947 { "b91-09.bin", 0x80000, 0x5f247ca2, BRF_GRA | TAITO_SPRITEMAP },
2948
2949 { "b91-13.bin", 0x80000, 0x8c7bf0f5, BRF_SND | TAITO_YM2610A },
2950 { "b91-12.bin", 0x80000, 0xda77c7af, BRF_SND | TAITO_YM2610A },
2951
2952 { "b91-14.bin", 0x80000, 0x6bc314d3, BRF_SND | TAITO_YM2610B },
2953
2954 { "b91-26.bin", 0x00400, 0x77682a4f, BRF_OPT },
2955 { "b91-27.bin", 0x00400, 0xa3f8490d, BRF_OPT },
2956 { "b91-28.bin", 0x00400, 0xfa2f840e, BRF_OPT },
2957 { "b91-29.bin", 0x02000, 0xad685be8, BRF_OPT },
2958 { "b91-30.bin", 0x10000, 0x30cc1f79, BRF_OPT },
2959 { "b91-31.bin", 0x10000, 0xc189781c, BRF_OPT },
2960 { "b91-32.bin", 0x00100, 0xfbf81f30, BRF_OPT },
2961 { "b91-33.bin", 0x00100, 0x89719d17, BRF_OPT },
2962 };
2963
2964 STD_ROM_PICK(Nightstrj)
2965 STD_ROM_FN(Nightstrj)
2966
2967 static struct BurnRomInfo NightstruRomDesc[] = {
2968 { "b91-45.bin", 0x20000, 0x7ad63421, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2969 { "b91-44.bin", 0x20000, 0x4bc30adf, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2970 { "b91-43.bin", 0x20000, 0x3e6f727a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2971 { "b91-46.bin", 0x20000, 0xe870be95, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
2972
2973 { "b91-39.bin", 0x20000, 0x725b23ae, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2974 { "b91-40.bin", 0x20000, 0x81fb364d, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
2975
2976 { "b91-41.bin", 0x20000, 0x2694bb42, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
2977
2978 { "b91-11.bin", 0x80000, 0xfff8ce31, BRF_GRA | TAITO_CHARS },
2979
2980 { "b91-04.bin", 0x80000, 0x8ca1970d, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2981 { "b91-03.bin", 0x80000, 0xcd5fed39, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2982 { "b91-02.bin", 0x80000, 0x457c64b8, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2983 { "b91-01.bin", 0x80000, 0x3731d94f, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
2984
2985 { "b91-08.bin", 0x80000, 0x66f35c34, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2986 { "b91-07.bin", 0x80000, 0x4d8ec6cf, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2987 { "b91-06.bin", 0x80000, 0xa34dc839, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2988 { "b91-05.bin", 0x80000, 0x5e72ac90, BRF_GRA | TAITO_SPRITESB_BYTESWAP32 },
2989
2990 { "b91-10.bin", 0x80000, 0x1d8f05b4, BRF_GRA | TAITO_ROAD },
2991
2992 { "b91-09.bin", 0x80000, 0x5f247ca2, BRF_GRA | TAITO_SPRITEMAP },
2993
2994 { "b91-13.bin", 0x80000, 0x8c7bf0f5, BRF_SND | TAITO_YM2610A },
2995 { "b91-12.bin", 0x80000, 0xda77c7af, BRF_SND | TAITO_YM2610A },
2996
2997 { "b91-14.bin", 0x80000, 0x6bc314d3, BRF_SND | TAITO_YM2610B },
2998
2999 { "b91-26.bin", 0x00400, 0x77682a4f, BRF_OPT },
3000 { "b91-27.bin", 0x00400, 0xa3f8490d, BRF_OPT },
3001 { "b91-28.bin", 0x00400, 0xfa2f840e, BRF_OPT },
3002 { "b91-29.bin", 0x02000, 0xad685be8, BRF_OPT },
3003 { "b91-30.bin", 0x10000, 0x30cc1f79, BRF_OPT },
3004 { "b91-31.bin", 0x10000, 0xc189781c, BRF_OPT },
3005 { "b91-32.bin", 0x00100, 0xfbf81f30, BRF_OPT },
3006 { "b91-33.bin", 0x00100, 0x89719d17, BRF_OPT },
3007 };
3008
3009 STD_ROM_PICK(Nightstru)
3010 STD_ROM_FN(Nightstru)
3011
3012 static struct BurnRomInfo RacingbRomDesc[] = {
3013 { "c84-110.3", 0x020000, 0x119a8d3b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3014 { "c84-111.5", 0x020000, 0x1f095692, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3015 { "c84-104.2", 0x020000, 0x37077fc6, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3016 { "c84-103.4", 0x020000, 0x4ca1d1c2, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3017
3018 { "c84-99.35", 0x020000, 0x24778f40, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3019 { "c84-100.36", 0x020000, 0x2b99258a, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3020
3021 { "c84-101.42", 0x020000, 0x9322106e, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3022
3023 { "c84-90.12", 0x080000, 0x83ee0e8d, BRF_GRA | TAITO_CHARS_BYTESWAP },
3024 { "c84-89.11", 0x080000, 0xaae43c87, BRF_GRA | TAITO_CHARS_BYTESWAP },
3025
3026 { "c84-92.25", 0x100000, 0x56e8fd55, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3027 { "c84-94.33", 0x100000, 0x6117c19b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3028 { "c84-91.23", 0x100000, 0xb1b0146c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3029 { "c84-93.31", 0x100000, 0x8837bb4e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3030
3031 { "c84-84.12", 0x080000, 0x34dc486b, BRF_GRA | TAITO_ROAD },
3032
3033 { "c84-88.3", 0x080000, 0xedd1f49c, BRF_GRA | TAITO_SPRITEMAP },
3034
3035 { "c84-86.33", 0x100000, 0x98d9771e, BRF_SND | TAITO_YM2610A },
3036 { "c84-87.46", 0x080000, 0x9c1dd80c, BRF_SND | TAITO_YM2610A },
3037
3038 { "c84-85.31", 0x080000, 0x24cd838d, BRF_SND | TAITO_YM2610B },
3039
3040 { "c84-19.15", 0x010000, 0x7245a6f6, BRF_OPT },
3041 { "c84-07.22", 0x000100, 0x95a15c77, BRF_OPT },
3042 { "c84-09.74", 0x000100, 0x71217472, BRF_OPT },
3043 { "c84-10.16", 0x000400, 0x643e8bfc, BRF_OPT },
3044 { "c84-11.17", 0x000400, 0x10728853, BRF_OPT },
3045 };
3046
3047 STD_ROM_PICK(Racingb)
3048 STD_ROM_FN(Racingb)
3049
3050 static struct BurnRomInfo RacingbjRomDesc[] = {
3051 { "c84-107.ic3", 0x020000, 0x520aa110, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3052 { "c84-109.ic5", 0x020000, 0x7ec710de, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3053 { "c84-104.2", 0x020000, 0x37077fc6, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3054 { "c84-108.ic4", 0x020000, 0xa2afb0ee, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3055
3056 { "c84-99.35", 0x020000, 0x24778f40, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3057 { "c84-100.36", 0x020000, 0x2b99258a, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3058
3059 { "c84-101.42", 0x020000, 0x9322106e, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3060
3061 { "c84-90.12", 0x080000, 0x83ee0e8d, BRF_GRA | TAITO_CHARS_BYTESWAP },
3062 { "c84-89.11", 0x080000, 0xaae43c87, BRF_GRA | TAITO_CHARS_BYTESWAP },
3063
3064 { "c84-92.25", 0x100000, 0x56e8fd55, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3065 { "c84-94.33", 0x100000, 0x6117c19b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3066 { "c84-91.23", 0x100000, 0xb1b0146c, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3067 { "c84-93.31", 0x100000, 0x8837bb4e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3068
3069 { "c84-84.12", 0x080000, 0x34dc486b, BRF_GRA | TAITO_ROAD },
3070
3071 { "c84-88.3", 0x080000, 0xedd1f49c, BRF_GRA | TAITO_SPRITEMAP },
3072
3073 { "c84-86.33", 0x100000, 0x98d9771e, BRF_SND | TAITO_YM2610A },
3074 { "c84-87.46", 0x080000, 0x9c1dd80c, BRF_SND | TAITO_YM2610A },
3075
3076 { "c84-85.31", 0x080000, 0x24cd838d, BRF_SND | TAITO_YM2610B },
3077
3078 { "c84-19.15", 0x010000, 0x7245a6f6, BRF_OPT },
3079 { "c84-07.22", 0x000100, 0x95a15c77, BRF_OPT },
3080 { "c84-09.74", 0x000100, 0x71217472, BRF_OPT },
3081 { "c84-10.16", 0x000400, 0x643e8bfc, BRF_OPT },
3082 { "c84-11.17", 0x000400, 0x10728853, BRF_OPT },
3083 };
3084
3085 STD_ROM_PICK(Racingbj)
3086 STD_ROM_FN(Racingbj)
3087
3088 static struct BurnRomInfo SciRomDesc[] = {
3089 { "c09-37.43", 0x20000, 0x0fecea17, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3090 { "c09-38.40", 0x20000, 0xe46ebd9b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3091 { "c09-42.38", 0x20000, 0xf4404f87, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3092 { "c09-39.41", 0x20000, 0xde87bcb9, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3093
3094 { "c09-33.6", 0x10000, 0xcf4e6c5b, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3095 { "c09-32.5", 0x10000, 0xa4713719, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3096
3097 { "c09-34.31", 0x20000, 0xa21b3151, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3098
3099 { "c09-05.16", 0x80000, 0x890b38f0, BRF_GRA | TAITO_CHARS },
3100
3101 { "c09-04.52", 0x80000, 0x2cbb3c9b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3102 { "c09-02.53", 0x80000, 0xa83a0389, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3103 { "c09-03.54", 0x80000, 0xa31d0e80, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3104 { "c09-01.55", 0x80000, 0x64bfea10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3105
3106 { "c09-07.15", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
3107
3108 { "c09-06.37", 0x80000, 0x12df6d7b, BRF_GRA | TAITO_SPRITEMAP },
3109
3110 { "c09-14.42", 0x80000, 0xad78bf46, BRF_SND | TAITO_YM2610A },
3111 { "c09-13.43", 0x80000, 0xd57c41d3, BRF_SND | TAITO_YM2610A },
3112 { "c09-12.44", 0x80000, 0x56c99fa5, BRF_SND | TAITO_YM2610A },
3113
3114 { "c09-15.29", 0x80000, 0xe63b9095, BRF_SND | TAITO_YM2610B },
3115
3116 { "c09-16.17", 0x10000, 0x7245a6f6, BRF_OPT },
3117 { "c09-17.24", 0x00400, 0x10728853, BRF_OPT },
3118 { "c09-18.25", 0x00400, 0x643e8bfc, BRF_OPT },
3119 { "c09-20.71", 0x00100, 0xcd8ffd80, BRF_OPT },
3120 { "c09-23.14", 0x00100, 0xfbf81f30, BRF_OPT },
3121
3122 { "c09-19_pal16l8b.ic67", 0x00104, 0xa0608442, BRF_OPT },
3123 { "c09-21_pal20l8b.ic2", 0x00144, 0x583f9214, BRF_OPT },
3124 { "c09-22_pal16l8b.ic3", 0x00104, 0xb506d7a7, BRF_OPT },
3125 { "c09-24_pal20l8b.ic22", 0x00144, 0x2ff83694, BRF_OPT },
3126 { "c09-25_pal20l8b.ic25", 0x00144, 0xc69bf3fc, BRF_OPT },
3127 { "c09-26_pal16l8b.ic26", 0x00104, 0x36a8eb27, BRF_OPT },
3128 };
3129
3130 STD_ROM_PICK(Sci)
3131 STD_ROM_FN(Sci)
3132
3133 static struct BurnRomInfo SciaRomDesc[] = {
3134 { "c09-28.43", 0x20000, 0x630dbaad, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3135 { "c09-30.40", 0x20000, 0x68b1a97d, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3136 { "c09-36.38", 0x20000, 0x59e47cba, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3137 { "c09-31.41", 0x20000, 0x962b1fbf, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3138
3139 { "c09-33.6", 0x10000, 0xcf4e6c5b, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3140 { "c09-32.5", 0x10000, 0xa4713719, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3141
3142 { "c09-34.31", 0x20000, 0xa21b3151, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3143
3144 { "c09-05.16", 0x80000, 0x890b38f0, BRF_GRA | TAITO_CHARS },
3145
3146 { "c09-04.52", 0x80000, 0x2cbb3c9b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3147 { "c09-02.53", 0x80000, 0xa83a0389, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3148 { "c09-03.54", 0x80000, 0xa31d0e80, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3149 { "c09-01.55", 0x80000, 0x64bfea10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3150
3151 { "c09-07.15", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
3152
3153 { "c09-06.37", 0x80000, 0x12df6d7b, BRF_GRA | TAITO_SPRITEMAP },
3154
3155 { "c09-14.42", 0x80000, 0xad78bf46, BRF_SND | TAITO_YM2610A },
3156 { "c09-13.43", 0x80000, 0xd57c41d3, BRF_SND | TAITO_YM2610A },
3157 { "c09-12.44", 0x80000, 0x56c99fa5, BRF_SND | TAITO_YM2610A },
3158
3159 { "c09-15.29", 0x80000, 0xe63b9095, BRF_SND | TAITO_YM2610B },
3160
3161 { "c09-16.17", 0x10000, 0x7245a6f6, BRF_OPT },
3162 { "c09-17.24", 0x00400, 0x10728853, BRF_OPT },
3163 { "c09-18.25", 0x00400, 0x643e8bfc, BRF_OPT },
3164 { "c09-20.71", 0x00100, 0xcd8ffd80, BRF_OPT },
3165 { "c09-23.14", 0x00100, 0xfbf81f30, BRF_OPT },
3166
3167 { "c09-19_pal16l8b.ic67", 0x00104, 0xa0608442, BRF_OPT },
3168 { "c09-21_pal20l8b.ic2", 0x00144, 0x583f9214, BRF_OPT },
3169 { "c09-22_pal16l8b.ic3", 0x00104, 0xb506d7a7, BRF_OPT },
3170 { "c09-24_pal20l8b.ic22", 0x00144, 0x2ff83694, BRF_OPT },
3171 { "c09-25_pal20l8b.ic25", 0x00144, 0xc69bf3fc, BRF_OPT },
3172 { "c09-26_pal16l8b.ic26", 0x00104, 0x36a8eb27, BRF_OPT },
3173 };
3174
3175 STD_ROM_PICK(Scia)
3176 STD_ROM_FN(Scia)
3177
3178 static struct BurnRomInfo ScijRomDesc[] = {
3179 { "c09-37.43", 0x20000, 0x0fecea17, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3180 { "c09-38.40", 0x20000, 0xe46ebd9b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3181 { "c09-40.38", 0x20000, 0x1a4e2eab, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3182 { "c09-39.41", 0x20000, 0xde87bcb9, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3183
3184 { "c09-33.6", 0x10000, 0xcf4e6c5b, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3185 { "c09-32.5", 0x10000, 0xa4713719, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3186
3187 { "c09-27.31", 0x20000, 0xcd161dca, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3188
3189 { "c09-05.16", 0x80000, 0x890b38f0, BRF_GRA | TAITO_CHARS },
3190
3191 { "c09-04.52", 0x80000, 0x2cbb3c9b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3192 { "c09-02.53", 0x80000, 0xa83a0389, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3193 { "c09-03.54", 0x80000, 0xa31d0e80, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3194 { "c09-01.55", 0x80000, 0x64bfea10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3195
3196 { "c09-07.15", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
3197
3198 { "c09-06.37", 0x80000, 0x12df6d7b, BRF_GRA | TAITO_SPRITEMAP },
3199
3200 { "c09-10.42", 0x80000, 0xad78bf46, BRF_SND | TAITO_YM2610A },
3201 { "c09-09.43", 0x80000, 0x6a655c00, BRF_SND | TAITO_YM2610A },
3202 { "c09-08.44", 0x80000, 0x7ddfc316, BRF_SND | TAITO_YM2610A },
3203
3204 { "c09-11.29", 0x80000, 0x6b1a11e1, BRF_SND | TAITO_YM2610B },
3205
3206 { "c09-16.17", 0x10000, 0x7245a6f6, BRF_OPT },
3207 { "c09-17.24", 0x00400, 0x10728853, BRF_OPT },
3208 { "c09-18.25", 0x00400, 0x643e8bfc, BRF_OPT },
3209 { "c09-20.71", 0x00100, 0xcd8ffd80, BRF_OPT },
3210 { "c09-23.14", 0x00100, 0xfbf81f30, BRF_OPT },
3211
3212 { "c09-19_pal16l8b.ic67", 0x00104, 0xa0608442, BRF_OPT },
3213 { "c09-21_pal20l8b.ic2", 0x00144, 0x583f9214, BRF_OPT },
3214 { "c09-22_pal16l8b.ic3", 0x00104, 0xb506d7a7, BRF_OPT },
3215 { "c09-24_pal20l8b.ic22", 0x00144, 0x2ff83694, BRF_OPT },
3216 { "c09-25_pal20l8b.ic25", 0x00144, 0xc69bf3fc, BRF_OPT },
3217 { "c09-26_pal16l8b.ic26", 0x00104, 0x36a8eb27, BRF_OPT },
3218 };
3219
3220 STD_ROM_PICK(Scij)
3221 STD_ROM_FN(Scij)
3222
3223 static struct BurnRomInfo SciuRomDesc[] = {
3224 { "c09-43.43", 0x20000, 0x20a9343e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3225 { "c09-44.40", 0x20000, 0x7524338a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3226 { "c09-41.38", 0x20000, 0x83477f11, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3227 { "c09-39.41", 0x20000, 0xde87bcb9, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3228
3229 { "c09-33.6", 0x10000, 0xcf4e6c5b, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3230 { "c09-32.5", 0x10000, 0xa4713719, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3231
3232 { "c09-34.31", 0x20000, 0xa21b3151, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3233
3234 { "c09-05.16", 0x80000, 0x890b38f0, BRF_GRA | TAITO_CHARS },
3235
3236 { "c09-04.52", 0x80000, 0x2cbb3c9b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3237 { "c09-02.53", 0x80000, 0xa83a0389, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3238 { "c09-03.54", 0x80000, 0xa31d0e80, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3239 { "c09-01.55", 0x80000, 0x64bfea10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3240
3241 { "c09-07.15", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
3242
3243 { "c09-06.37", 0x80000, 0x12df6d7b, BRF_GRA | TAITO_SPRITEMAP },
3244
3245 { "c09-14.42", 0x80000, 0xad78bf46, BRF_SND | TAITO_YM2610A },
3246 { "c09-13.43", 0x80000, 0xd57c41d3, BRF_SND | TAITO_YM2610A },
3247 { "c09-12.44", 0x80000, 0x56c99fa5, BRF_SND | TAITO_YM2610A },
3248
3249 { "c09-15.29", 0x80000, 0xe63b9095, BRF_SND | TAITO_YM2610B },
3250
3251 { "c09-16.17", 0x10000, 0x7245a6f6, BRF_OPT },
3252 { "c09-17.24", 0x00400, 0x10728853, BRF_OPT },
3253 { "c09-18.25", 0x00400, 0x643e8bfc, BRF_OPT },
3254 { "c09-20.71", 0x00100, 0xcd8ffd80, BRF_OPT },
3255 { "c09-23.14", 0x00100, 0xfbf81f30, BRF_OPT },
3256
3257 { "c09-19_pal16l8b.ic67", 0x00104, 0xa0608442, BRF_OPT },
3258 { "c09-21_pal20l8b.ic2", 0x00144, 0x583f9214, BRF_OPT },
3259 { "c09-22_pal16l8b.ic3", 0x00104, 0xb506d7a7, BRF_OPT },
3260 { "c09-24_pal20l8b.ic22", 0x00144, 0x2ff83694, BRF_OPT },
3261 { "c09-25_pal20l8b.ic25", 0x00144, 0xc69bf3fc, BRF_OPT },
3262 { "c09-26_pal16l8b.ic26", 0x00104, 0x36a8eb27, BRF_OPT },
3263 };
3264
3265 STD_ROM_PICK(Sciu)
3266 STD_ROM_FN(Sciu)
3267
3268 static struct BurnRomInfo ScinRomDesc[] = {
3269 { "ic37.37", 0x20000, 0x33fb159c, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3270 { "ic40.38", 0x20000, 0x657df3f2, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3271 { "ic38.42", 0x20000, 0x0a09b90b, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3272 { "ic41.39", 0x20000, 0x43167b2a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3273
3274 { "c09-33.6", 0x10000, 0xcf4e6c5b, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3275 { "c09-32.5", 0x10000, 0xa4713719, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3276
3277 { "c09-34.31", 0x20000, 0xa21b3151, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
3278
3279 { "c09-05.16", 0x80000, 0x890b38f0, BRF_GRA | TAITO_CHARS },
3280
3281 { "c09-04.52", 0x80000, 0x2cbb3c9b, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3282 { "c09-02.53", 0x80000, 0xa83a0389, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3283 { "c09-03.54", 0x80000, 0xa31d0e80, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3284 { "c09-01.55", 0x80000, 0x64bfea10, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3285
3286 { "c09-07.15", 0x80000, 0x963bc82b, BRF_GRA | TAITO_ROAD },
3287
3288 { "c09-06.37", 0x80000, 0x12df6d7b, BRF_GRA | TAITO_SPRITEMAP },
3289
3290 { "c09-14.42", 0x80000, 0xad78bf46, BRF_SND | TAITO_YM2610A },
3291 { "c09-13.43", 0x80000, 0xd57c41d3, BRF_SND | TAITO_YM2610A },
3292 { "c09-12.44", 0x80000, 0x56c99fa5, BRF_SND | TAITO_YM2610A },
3293
3294 { "c09-15.29", 0x80000, 0xe63b9095, BRF_SND | TAITO_YM2610B },
3295
3296 { "c09-16.17", 0x10000, 0x7245a6f6, BRF_OPT },
3297 { "c09-17.24", 0x00400, 0x10728853, BRF_OPT },
3298 { "c09-18.25", 0x00400, 0x643e8bfc, BRF_OPT },
3299 { "c09-20.71", 0x00100, 0xcd8ffd80, BRF_OPT },
3300 { "c09-23.14", 0x00100, 0xfbf81f30, BRF_OPT },
3301
3302 { "c09-19_pal16l8b.ic67", 0x00104, 0xa0608442, BRF_OPT },
3303 { "c09-21_pal20l8b.ic2", 0x00144, 0x583f9214, BRF_OPT },
3304 { "c09-22_pal16l8b.ic3", 0x00104, 0xb506d7a7, BRF_OPT },
3305 { "c09-24_pal20l8b.ic22", 0x00144, 0x2ff83694, BRF_OPT },
3306 { "c09-25_pal20l8b.ic25", 0x00144, 0xc69bf3fc, BRF_OPT },
3307 { "c09-26_pal16l8b.ic26", 0x00104, 0x36a8eb27, BRF_OPT },
3308 };
3309
3310 STD_ROM_PICK(Scin)
3311 STD_ROM_FN(Scin)
3312
3313 static struct BurnRomInfo SpacegunRomDesc[] = {
3314 { "c57-18.62", 0x020000, 0x19d7d52e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3315 { "c57-20.74", 0x020000, 0x2e58253f, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3316 { "c57-17.59", 0x020000, 0xe197edb8, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3317 { "c57-22.73", 0x020000, 0x5855fde3, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3318
3319 { "c57-15+.27", 0x020000, 0xb36eb8f1, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3320 { "c57-16+.29", 0x020000, 0xbfb5d1e7, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3321
3322 { "c57-06.52", 0x080000, 0x4ebadd5b, BRF_GRA | TAITO_CHARS },
3323
3324 { "c57-01.25", 0x100000, 0xf901b04e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3325 { "c57-02.24", 0x100000, 0x21ee4633, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3326 { "c57-03.12", 0x100000, 0xfafca86f, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3327 { "c57-04.11", 0x100000, 0xa9787090, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3328
3329 { "c57-05.36", 0x080000, 0x6a70eb2e, BRF_GRA | TAITO_SPRITEMAP },
3330
3331 { "c57-07.76", 0x080000, 0xad653dc1, BRF_SND | TAITO_YM2610A },
3332
3333 { "c57-08.75", 0x080000, 0x22593550, BRF_SND | TAITO_YM2610B },
3334
3335 { "pal16l8-c57-09.9", 0x000104, 0xea93161e, BRF_OPT },
3336 { "pal20l8-c57-10.47", 0x000144, 0x3ee56888, BRF_OPT },
3337 { "pal16l8-c57-11.48", 0x000104, 0x6bb4372e, BRF_OPT },
3338 { "pal20l8-c57-12.61", 0x000144, 0xdebddb13, BRF_OPT },
3339 { "pal16l8-c57-13.72", 0x000104, 0x1369f23e, BRF_OPT },
3340 { "pal16r4-c57-14.96", 0x000104, 0x75e1bf61, BRF_OPT },
3341
3342 };
3343
3344 STD_ROM_PICK(Spacegun)
3345 STD_ROM_FN(Spacegun)
3346
3347 static struct BurnRomInfo SpacegunuRomDesc[] = {
3348 { "c57-18.62", 0x020000, 0x19d7d52e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3349 { "c57-20.74", 0x020000, 0x2e58253f, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3350 { "c57-17.59", 0x020000, 0xe197edb8, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3351 { "c57-21.73", 0x020000, 0x2f52cd75, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3352
3353 { "c57-15+.27", 0x020000, 0xb36eb8f1, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3354 { "c57-16+.29", 0x020000, 0xbfb5d1e7, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3355
3356 { "c57-06.52", 0x080000, 0x4ebadd5b, BRF_GRA | TAITO_CHARS },
3357
3358 { "c57-01.25", 0x100000, 0xf901b04e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3359 { "c57-02.24", 0x100000, 0x21ee4633, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3360 { "c57-03.12", 0x100000, 0xfafca86f, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3361 { "c57-04.11", 0x100000, 0xa9787090, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3362
3363 { "c57-05.36", 0x080000, 0x6a70eb2e, BRF_GRA | TAITO_SPRITEMAP },
3364
3365 { "c57-07.76", 0x080000, 0xad653dc1, BRF_SND | TAITO_YM2610A },
3366
3367 { "c57-08.75", 0x080000, 0x22593550, BRF_SND | TAITO_YM2610B },
3368
3369 { "pal16l8-c57-09.9", 0x000104, 0xea93161e, BRF_OPT },
3370 { "pal20l8-c57-10.47", 0x000144, 0x3ee56888, BRF_OPT },
3371 { "pal16l8-c57-11.48", 0x000104, 0x6bb4372e, BRF_OPT },
3372 { "pal20l8-c57-12.61", 0x000144, 0xdebddb13, BRF_OPT },
3373 { "pal16l8-c57-13.72", 0x000104, 0x1369f23e, BRF_OPT },
3374 { "pal16r4-c57-14.96", 0x000104, 0x75e1bf61, BRF_OPT },
3375
3376 };
3377
3378 STD_ROM_PICK(Spacegunu)
3379 STD_ROM_FN(Spacegunu)
3380
3381 static struct BurnRomInfo SpacegunjRomDesc[] = {
3382 { "c57-18+.62", 0x020000, 0xc648c093, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3383 { "c57-20+.74", 0x020000, 0x4de524f6, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3384 { "c57-17.59", 0x020000, 0xe197edb8, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3385 { "c57-19.73", 0x020000, 0xc15cac59, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
3386
3387 { "c57-15+.27", 0x020000, 0xb36eb8f1, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3388 { "c57-16+.29", 0x020000, 0xbfb5d1e7, BRF_ESS | BRF_PRG | TAITO_68KROM2_BYTESWAP },
3389
3390 { "c57-06.52", 0x080000, 0x4ebadd5b, BRF_GRA | TAITO_CHARS },
3391
3392 { "c57-01.25", 0x100000, 0xf901b04e, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3393 { "c57-02.24", 0x100000, 0x21ee4633, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3394 { "c57-03.12", 0x100000, 0xfafca86f, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3395 { "c57-04.11", 0x100000, 0xa9787090, BRF_GRA | TAITO_SPRITESA_BYTESWAP32 },
3396
3397 { "c57-05.36", 0x080000, 0x6a70eb2e, BRF_GRA | TAITO_SPRITEMAP },
3398
3399 { "c57-07.76", 0x080000, 0xad653dc1, BRF_SND | TAITO_YM2610A },
3400
3401 { "c57-08.75", 0x080000, 0x22593550, BRF_SND | TAITO_YM2610B },
3402
3403 { "pal16l8-c57-09.9", 0x000104, 0xea93161e, BRF_OPT },
3404 { "pal20l8-c57-10.47", 0x000144, 0x3ee56888, BRF_OPT },
3405 { "pal16l8-c57-11.48", 0x000104, 0x6bb4372e, BRF_OPT },
3406 { "pal20l8-c57-12.61", 0x000144, 0xdebddb13, BRF_OPT },
3407 { "pal16l8-c57-13.72", 0x000104, 0x1369f23e, BRF_OPT },
3408 { "pal16r4-c57-14.96", 0x000104, 0x75e1bf61, BRF_OPT },
3409
3410 };
3411
3412 STD_ROM_PICK(Spacegunj)
STD_ROM_FN(Spacegunj)3413 STD_ROM_FN(Spacegunj)
3414
3415 static INT32 MemIndex()
3416 {
3417 UINT8 *Next; Next = TaitoMem;
3418
3419 Taito68KRom1 = Next; Next += Taito68KRom1Size;
3420 Taito68KRom2 = Next; Next += Taito68KRom2Size;
3421 TaitoZ80Rom1 = Next; Next += TaitoZ80Rom1Size;
3422 TaitoSpriteMapRom = Next; Next += TaitoSpriteMapRomSize;
3423 TaitoYM2610ARom = Next; Next += TaitoYM2610ARomSize;
3424 TaitoYM2610BRom = Next; Next += TaitoYM2610BRomSize;
3425
3426 TaitoRamStart = Next;
3427
3428 Taito68KRam1 = Next; Next += 0x10000;
3429 Taito68KRam2 = Next; Next += 0x08000;
3430 TaitoSharedRam = Next; Next += 0x10000;
3431 TaitoZ80Ram1 = Next; Next += 0x02000;
3432 TaitoSpriteRam = Next; Next += 0x04000;
3433 TaitoPaletteRam = Next; Next += 0x02000;
3434
3435 TaitoRamEnd = Next;
3436
3437 TaitoChars = Next; Next += TaitoNumChar * TaitoCharWidth * TaitoCharHeight;
3438 TaitoSpritesA = Next; Next += TaitoNumSpriteA * TaitoSpriteAWidth * TaitoSpriteAHeight;
3439 TaitoSpritesB = Next; Next += TaitoNumSpriteB * TaitoSpriteBWidth * TaitoSpriteBHeight;
3440 TaitoPalette = (UINT32*)Next; Next += 0x01000 * sizeof(UINT32);
3441 TaitoPriorityMap = Next; Next += nScreenWidth * nScreenHeight;
3442
3443 TaitoMemEnd = Next;
3444
3445 return 0;
3446 }
3447
TaitoZDoReset()3448 static INT32 TaitoZDoReset()
3449 {
3450 TaitoDoReset();
3451
3452 if (bUseShifter)
3453 BurnShiftReset();
3454
3455 SciSpriteFrame = 0;
3456
3457 HiscoreReset();
3458
3459 return 0;
3460 }
3461
TaitoZCpuAReset(UINT16 d)3462 static void TaitoZCpuAReset(UINT16 d)
3463 {
3464 TaitoCpuACtrl = d;
3465 if (!(TaitoCpuACtrl & 1)) {
3466 SekReset(1);
3467 }
3468 }
3469
Aquajack68K1WriteByte(UINT32 a,UINT8 d)3470 static void __fastcall Aquajack68K1WriteByte(UINT32 a, UINT8 d)
3471 {
3472 TC0100SCN0ByteWrite_Map(0xa00000, 0xa0ffff)
3473
3474 switch (a) {
3475 default: {
3476 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
3477 }
3478 }
3479 }
3480
Aquajack68K1WriteWord(UINT32 a,UINT16 d)3481 static void __fastcall Aquajack68K1WriteWord(UINT32 a, UINT16 d)
3482 {
3483 TC0100SCN0WordWrite_Map(0xa00000, 0xa0ffff)
3484 TC0100SCN0CtrlWordWrite_Map(0xa20000)
3485
3486 switch (a) {
3487 case 0x200000: {
3488 TaitoZCpuAReset(d);
3489 return;
3490 }
3491
3492 case 0x300000:
3493 case 0x300002: {
3494 TC0110PCRStep1WordWrite(0, (a - 0x300000) >> 1, d);
3495 return;
3496 }
3497
3498 default: {
3499 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
3500 }
3501 }
3502 }
3503
Aquajack68K2ReadByte(UINT32 a)3504 static UINT8 __fastcall Aquajack68K2ReadByte(UINT32 a)
3505 {
3506 TC0220IOCHalfWordRead_Map(0x200000)
3507
3508 switch (a) {
3509 case 0x300003: {
3510 return TC0140SYTCommRead();
3511 }
3512
3513 default: {
3514 bprintf(PRINT_NORMAL, _T("68K #2 Read byte => %06X\n"), a);
3515 }
3516 }
3517
3518 return 0;
3519 }
3520
Aquajack68K2ReadWord(UINT32 a)3521 static UINT16 __fastcall Aquajack68K2ReadWord(UINT32 a)
3522 {
3523 TC0220IOCHalfWordRead_Map(0x200000)
3524
3525 switch (a) {
3526 case 0x900000:
3527 case 0x900002:
3528 case 0x900004:
3529 case 0x900006: {
3530 // nop
3531 return 0;
3532 }
3533
3534 default: {
3535 bprintf(PRINT_NORMAL, _T("68K #2 Read word => %06X\n"), a);
3536 }
3537 }
3538
3539 return 0;
3540 }
3541
Aquajack68K2WriteWord(UINT32 a,UINT16 d)3542 static void __fastcall Aquajack68K2WriteWord(UINT32 a, UINT16 d)
3543 {
3544 TC0220IOCHalfWordWrite_Map(0x200000)
3545
3546 switch (a) {
3547 case 0x300000: {
3548 TC0140SYTPortWrite(d & 0xff);
3549 return;
3550 }
3551
3552 case 0x300002: {
3553 TC0140SYTCommWrite(d & 0xff);
3554 return;
3555 }
3556
3557 case 0x900000:
3558 case 0x900002:
3559 case 0x900004:
3560 case 0x900006: {
3561 // nop
3562 return;
3563 }
3564
3565 default: {
3566 bprintf(PRINT_NORMAL, _T("68K #2 Write word => %06X, %04X\n"), a, d);
3567 }
3568 }
3569 }
3570
BsharkStickRead(INT32 Offset)3571 static UINT8 BsharkStickRead(INT32 Offset)
3572 {
3573 switch (Offset) {
3574 case 0x00: {
3575 return ProcessAnalog(TaitoAnalogPort0, 1, 1, 0x34, 0xcc);
3576 }
3577
3578 case 0x01: {
3579 return 0x80;
3580 }
3581
3582 case 0x02: {
3583 return ProcessAnalog(TaitoAnalogPort1, 0, 1, 0x34, 0xcc);
3584 }
3585
3586 case 0x03: {
3587 return 0x80;
3588 }
3589 }
3590
3591 return 0;
3592 }
3593
Bshark68K1ReadByte(UINT32 a)3594 static UINT8 __fastcall Bshark68K1ReadByte(UINT32 a)
3595 {
3596 TC0220IOCHalfWordRead_Map(0x400000)
3597
3598 switch (a) {
3599 case 0x800001:
3600 case 0x800003:
3601 case 0x800005:
3602 case 0x800007: {
3603 return BsharkStickRead((a - 0x800000) >> 1);
3604 }
3605
3606
3607 default: {
3608 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
3609 }
3610 }
3611
3612 return 0;
3613 }
3614
Bshark68K1WriteByte(UINT32 a,UINT8 d)3615 static void __fastcall Bshark68K1WriteByte(UINT32 a, UINT8 d)
3616 {
3617 TC0220IOCHalfWordWrite_Map(0x400000)
3618 TC0100SCN0ByteWrite_Map(0xd00000, 0xd0ffff)
3619
3620 switch (a) {
3621 default: {
3622 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
3623 }
3624 }
3625 }
3626
Bshark68K1WriteWord(UINT32 a,UINT16 d)3627 static void __fastcall Bshark68K1WriteWord(UINT32 a, UINT16 d)
3628 {
3629 TC0220IOCHalfWordWrite_Map(0x400000)
3630 TC0100SCN0WordWrite_Map(0xd00000, 0xd0ffff)
3631 TC0100SCN0CtrlWordWrite_Map(0xd20000)
3632
3633 switch (a) {
3634 case 0x600000: {
3635 TaitoZCpuAReset(d);
3636 return;
3637 }
3638
3639 case 0x800000:
3640 case 0x800002:
3641 case 0x800004:
3642 case 0x800006: {
3643 TaitoZINT6timer = SekTotalCycles();
3644 return;
3645 }
3646
3647 default: {
3648 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
3649 }
3650 }
3651 }
3652
Bshark68K2ReadWord(UINT32 a)3653 static UINT16 __fastcall Bshark68K2ReadWord(UINT32 a)
3654 {
3655 switch (a) {
3656 case 0x40000a: {
3657 // ???
3658 return 0;
3659 }
3660
3661 case 0x600000: {
3662 return BurnYM2610Read(0);
3663 }
3664
3665 case 0x600004: {
3666 return BurnYM2610Read(2);
3667 }
3668
3669 default: {
3670 bprintf(PRINT_NORMAL, _T("68K #2 Read word => %06X\n"), a);
3671 }
3672 }
3673
3674 return 0;
3675 }
3676
Bshark68K2WriteWord(UINT32 a,UINT16 d)3677 static void __fastcall Bshark68K2WriteWord(UINT32 a, UINT16 d)
3678 {
3679 switch (a) {
3680 case 0x400000:
3681 case 0x400002:
3682 case 0x400004:
3683 case 0x400006:
3684 case 0x400008: {
3685 // nop
3686 return;
3687 }
3688
3689 case 0x600000: {
3690 BurnYM2610Write(0, d & 0xff);
3691 return;
3692 }
3693
3694 case 0x600002: {
3695 BurnYM2610Write(1, d & 0xff);
3696 return;
3697 }
3698
3699 case 0x600004: {
3700 BurnYM2610Write(2, d & 0xff);
3701 return;
3702 }
3703
3704 case 0x600006: {
3705 BurnYM2610Write(3, d & 0xff);
3706 return;
3707 }
3708
3709 case 0x60000c:
3710 case 0x60000e: {
3711 // nop
3712 return;
3713 }
3714
3715 default: {
3716 bprintf(PRINT_NORMAL, _T("68K #2 Write word => %06X, %04X\n"), a, d);
3717 }
3718 }
3719 }
3720
ChasehqInputBypassRead()3721 static UINT8 ChasehqInputBypassRead()
3722 {
3723 UINT8 Port = TC0220IOCPortRead();
3724
3725 INT32 Steer = 0xFF80 + ProcessAnalog(TaitoAnalogPort0, 0, 1, 0x20, 0xe0);
3726
3727 switch (Port) {
3728 case 0x08:
3729 case 0x09:
3730 case 0x0a:
3731 case 0x0b: {
3732 return 0xff;
3733 }
3734
3735 case 0x0c: {
3736 return Steer & 0xff;
3737 }
3738
3739 case 0x0d: {
3740 return Steer >> 8;
3741 }
3742
3743 default: {
3744 return TC0220IOCPortRegRead();
3745 }
3746 }
3747 }
3748
Chasehq68K1ReadByte(UINT32 a)3749 static UINT8 __fastcall Chasehq68K1ReadByte(UINT32 a)
3750 {
3751 switch (a) {
3752 case 0x400001: {
3753 return ChasehqInputBypassRead();
3754 }
3755
3756 case 0x820003: {
3757 return TC0140SYTCommRead();
3758 }
3759
3760 default: {
3761 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
3762 }
3763 }
3764
3765 return 0;
3766 }
3767
Chasehq68K1WriteByte(UINT32 a,UINT8 d)3768 static void __fastcall Chasehq68K1WriteByte(UINT32 a, UINT8 d)
3769 {
3770 TC0100SCN0ByteWrite_Map(0xc00000, 0xc0ffff)
3771
3772 switch (a) {
3773 case 0x400001: {
3774 TC0220IOCHalfWordPortRegWrite(d);
3775 return;
3776 }
3777
3778 case 0x400003: {
3779 TC0220IOCHalfWordPortWrite(d);
3780 return;
3781 }
3782
3783 case 0x800001: {
3784 TaitoZCpuAReset(d);
3785 return;
3786 }
3787
3788 case 0x820001: {
3789 TC0140SYTPortWrite(d);
3790 return;
3791 }
3792
3793 case 0x820003: {
3794 TC0140SYTCommWrite(d);
3795 return;
3796 }
3797
3798 default: {
3799 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
3800 }
3801 }
3802 }
3803
Chasehq68K1ReadWord(UINT32 a)3804 static UINT16 __fastcall Chasehq68K1ReadWord(UINT32 a)
3805 {
3806 switch (a) {
3807 case 0x400002: {
3808 return TC0220IOCHalfWordPortRead();
3809 }
3810
3811 case 0xa00002: {
3812 return TC0110PCRWordRead(0);
3813 }
3814
3815 default: {
3816 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
3817 }
3818 }
3819
3820 return 0;
3821 }
3822
Chasehq68K1WriteWord(UINT32 a,UINT16 d)3823 static void __fastcall Chasehq68K1WriteWord(UINT32 a, UINT16 d)
3824 {
3825 TC0100SCN0WordWrite_Map(0xc00000, 0xc0ffff)
3826 TC0100SCN0CtrlWordWrite_Map(0xc20000)
3827
3828 switch (a) {
3829 case 0x400000: {
3830 TC0220IOCHalfWordPortRegWrite(d);
3831 return;
3832 }
3833
3834 case 0x400002: {
3835 TC0220IOCHalfWordPortWrite(d);
3836 return;
3837 }
3838
3839 case 0xa00000:
3840 case 0xa00002: {
3841 TC0110PCRStep1WordWrite(0, (a - 0xa00000) >> 1, d);
3842 return;
3843 }
3844
3845 default: {
3846 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
3847 }
3848 }
3849 }
3850
ContcircInputBypassRead()3851 static UINT8 ContcircInputBypassRead()
3852 {
3853 UINT8 Port = TC0220IOCPortRead();
3854
3855 INT32 Steer = 0xFF80 + ProcessAnalog(TaitoAnalogPort0, 1, 1, 0x20, 0xe0);
3856
3857 switch (Port) {
3858 case 0x08: {
3859 return Steer & 0xff;
3860 }
3861
3862 case 0x09: {
3863 return Steer >> 8;
3864 }
3865
3866 default: {
3867 return TC0220IOCPortRegRead();
3868 }
3869 }
3870 }
3871
Contcirc68K1WriteByte(UINT32 a,UINT8 d)3872 static void __fastcall Contcirc68K1WriteByte(UINT32 a, UINT8 d)
3873 {
3874 TC0100SCN0ByteWrite_Map(0x200000, 0x20ffff)
3875
3876 switch (a) {
3877 default: {
3878 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
3879 }
3880 }
3881 }
3882
Contcirc68K1WriteWord(UINT32 a,UINT16 d)3883 static void __fastcall Contcirc68K1WriteWord(UINT32 a, UINT16 d)
3884 {
3885 TC0100SCN0WordWrite_Map(0x200000, 0x20ffff)
3886 TC0100SCN0CtrlWordWrite_Map(0x220000)
3887
3888 switch (a) {
3889 case 0x090000: {
3890 TaitoRoadPalBank = (d & 0xc0) >> 6;
3891 TaitoZCpuAReset(d);
3892 return;
3893 }
3894
3895 case 0x100000:
3896 case 0x100002: {
3897 TC0110PCRStep1RBSwapWordWrite(0, (a - 0x100000) >> 1, d);
3898 return;
3899 }
3900
3901 default: {
3902 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
3903 }
3904 }
3905 }
3906
Contcirc68K2ReadByte(UINT32 a)3907 static UINT8 __fastcall Contcirc68K2ReadByte(UINT32 a)
3908 {
3909 switch (a) {
3910 case 0x100001: {
3911 return ContcircInputBypassRead();
3912 }
3913
3914 default: {
3915 bprintf(PRINT_NORMAL, _T("68K #2 Read byte => %06X\n"), a);
3916 }
3917 }
3918
3919 return 0;
3920 }
3921
Contcirc68K2WriteByte(UINT32 a,UINT8 d)3922 static void __fastcall Contcirc68K2WriteByte(UINT32 a, UINT8 d)
3923 {
3924 switch (a) {
3925 case 0x100001: {
3926 TC0220IOCHalfWordPortRegWrite(d);
3927 return;
3928 }
3929
3930 default: {
3931 bprintf(PRINT_NORMAL, _T("68K #2 Write byte => %06X, %02X\n"), a, d);
3932 }
3933 }
3934 }
3935
Contcirc68K2ReadWord(UINT32 a)3936 static UINT16 __fastcall Contcirc68K2ReadWord(UINT32 a)
3937 {
3938 switch (a) {
3939 case 0x100000: {
3940 return ContcircInputBypassRead();
3941 }
3942
3943 case 0x100002: {
3944 return TC0220IOCHalfWordPortRead();
3945 }
3946
3947 case 0x200002: {
3948 return TC0140SYTCommRead();
3949 }
3950
3951 default: {
3952 bprintf(PRINT_NORMAL, _T("68K #2 Read word => %06X\n"), a);
3953 }
3954 }
3955
3956 return 0;
3957 }
3958
Contcirc68K2WriteWord(UINT32 a,UINT16 d)3959 static void __fastcall Contcirc68K2WriteWord(UINT32 a, UINT16 d)
3960 {
3961 switch (a) {
3962 case 0x100000: {
3963 TC0220IOCHalfWordPortRegWrite(d);
3964 return;
3965 }
3966
3967 case 0x100002: {
3968 TC0220IOCHalfWordPortWrite(d);
3969 return;
3970 }
3971
3972 case 0x200000: {
3973 TC0140SYTPortWrite(d & 0xff);
3974 return;
3975 }
3976
3977 case 0x200002: {
3978 TC0140SYTCommWrite(d & 0xff);
3979 return;
3980 }
3981
3982 default: {
3983 bprintf(PRINT_NORMAL, _T("68K #2 Write word => %06X, %04X\n"), a, d);
3984 }
3985 }
3986 }
3987
DblaxleSteerRead(INT32 Offset)3988 static UINT16 DblaxleSteerRead(INT32 Offset)
3989 {
3990 INT32 Steer = 0xFF80 + ProcessAnalog(TaitoAnalogPort0, 0, 1, 0x40, 0xc0);
3991
3992 switch (Offset) {
3993 case 0x04: {
3994 return Steer >> 8;
3995 }
3996
3997 case 0x05: {
3998 return Steer & 0xff;
3999 }
4000 }
4001
4002 return 0x00;
4003 }
4004
Dblaxle68K1ReadByte(UINT32 a)4005 static UINT8 __fastcall Dblaxle68K1ReadByte(UINT32 a)
4006 {
4007 TC0510NIOHalfWordSwapRead_Map(0x400000)
4008
4009 switch (a) {
4010 case 0x620003: {
4011 return TC0140SYTCommRead();
4012 }
4013
4014 default: {
4015 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
4016 }
4017 }
4018
4019 return 0;
4020 }
4021
Dblaxle68K1WriteByte(UINT32 a,UINT8 d)4022 static void __fastcall Dblaxle68K1WriteByte(UINT32 a, UINT8 d)
4023 {
4024 TC0510NIOHalfWordSwapWrite_Map(0x400000)
4025
4026 switch (a) {
4027 case 0x600001: {
4028 TaitoZCpuAReset(d);
4029 return;
4030 }
4031
4032 case 0x620001: {
4033 TC0140SYTPortWrite(d);
4034 return;
4035 }
4036
4037 case 0x620003: {
4038 TC0140SYTCommWrite(d);
4039 return;
4040 }
4041
4042 default: {
4043 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
4044 }
4045 }
4046 }
4047
Dblaxle68K1ReadWord(UINT32 a)4048 static UINT16 __fastcall Dblaxle68K1ReadWord(UINT32 a)
4049 {
4050 TC0510NIOHalfWordSwapRead_Map(0x400000)
4051
4052 switch (a) {
4053 case 0x400018:
4054 case 0x40001a: {
4055 return DblaxleSteerRead((a - 0x400010) >> 1);
4056 }
4057
4058 default: {
4059 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
4060 }
4061 }
4062
4063 return 0;
4064 }
4065
Dblaxle68K1WriteWord(UINT32 a,UINT16 d)4066 static void __fastcall Dblaxle68K1WriteWord(UINT32 a, UINT16 d)
4067 {
4068 TC0510NIOHalfWordSwapWrite_Map(0x400000)
4069 TC0480SCPCtrlWordWrite_Map(0xa30000)
4070
4071 switch (a) {
4072 case 0xc08000: {
4073 return;
4074 }
4075
4076 default: {
4077 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
4078 }
4079 }
4080 }
4081
Enforce68K1WriteByte(UINT32 a,UINT8 d)4082 static void __fastcall Enforce68K1WriteByte(UINT32 a, UINT8 d)
4083 {
4084 TC0100SCN0ByteWrite_Map(0x600000, 0x60ffff)
4085
4086 switch (a) {
4087 default: {
4088 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
4089 }
4090 }
4091 }
4092
Enforce68K1ReadWord(UINT32 a)4093 static UINT16 __fastcall Enforce68K1ReadWord(UINT32 a)
4094 {
4095 switch (a) {
4096 case 0x500002: {
4097 return TC0110PCRWordRead(0);
4098 }
4099
4100 default: {
4101 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
4102 }
4103 }
4104
4105 return 0;
4106 }
4107
Enforce68K1WriteWord(UINT32 a,UINT16 d)4108 static void __fastcall Enforce68K1WriteWord(UINT32 a, UINT16 d)
4109 {
4110 TC0100SCN0WordWrite_Map(0x600000, 0x60ffff)
4111 TC0100SCN0CtrlWordWrite_Map(0x620000)
4112
4113 switch (a) {
4114 case 0x200000: {
4115 TaitoZCpuAReset(d);
4116 return;
4117 }
4118
4119 case 0x500000:
4120 case 0x500002: {
4121 TC0110PCRStep1RBSwapWordWrite(0, (a - 0x500000) >> 1, d);
4122 return;
4123 }
4124
4125 default: {
4126 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
4127 }
4128 }
4129 }
4130
Enforce68K2ReadByte(UINT32 a)4131 static UINT8 __fastcall Enforce68K2ReadByte(UINT32 a)
4132 {
4133 switch (a) {
4134 case 0x300001: {
4135 return TC0220IOCPortRegRead();
4136 }
4137
4138 default: {
4139 bprintf(PRINT_NORMAL, _T("68K #2 Read byte => %06X\n"), a);
4140 }
4141 }
4142
4143 return 0;
4144 }
4145
Enforce68K2WriteByte(UINT32 a,UINT8 d)4146 static void __fastcall Enforce68K2WriteByte(UINT32 a, UINT8 d)
4147 {
4148 switch (a) {
4149 case 0x300001: {
4150 TC0220IOCHalfWordPortRegWrite(d);
4151 return;
4152 }
4153
4154 default: {
4155 bprintf(PRINT_NORMAL, _T("68K #2 Write byte => %06X, %02X\n"), a, d);
4156 }
4157 }
4158 }
4159
Enforce68K2ReadWord(UINT32 a)4160 static UINT16 __fastcall Enforce68K2ReadWord(UINT32 a)
4161 {
4162 switch (a) {
4163 case 0x200002: {
4164 return TC0140SYTCommRead();
4165 }
4166
4167 case 0x300000: {
4168 return TC0220IOCPortRegRead();
4169 }
4170
4171 case 0x300002: {
4172 return TC0220IOCHalfWordPortRead();
4173 }
4174
4175 default: {
4176 bprintf(PRINT_NORMAL, _T("68K #2 Read word => %06X\n"), a);
4177 }
4178 }
4179
4180 return 0;
4181 }
4182
Enforce68K2WriteWord(UINT32 a,UINT16 d)4183 static void __fastcall Enforce68K2WriteWord(UINT32 a, UINT16 d)
4184 {
4185 switch (a) {
4186 case 0x200000: {
4187 TC0140SYTPortWrite(d & 0xff);
4188 return;
4189 }
4190
4191 case 0x200002: {
4192 TC0140SYTCommWrite(d & 0xff);
4193 return;
4194 }
4195
4196 case 0x300000: {
4197 TC0220IOCHalfWordPortRegWrite(d);
4198 return;
4199 }
4200
4201 case 0x300002: {
4202 TC0220IOCHalfWordPortWrite(d);
4203 return;
4204 }
4205
4206 default: {
4207 bprintf(PRINT_NORMAL, _T("68K #2 Write word => %06X, %04X\n"), a, d);
4208 }
4209 }
4210 }
4211
4212 static const UINT8 nightstr_stick[128]=
4213 {
4214 0xb8,0xb9,0xba,0xbb,0xbc,0xbd,0xbe,0xbf,0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
4215 0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,
4216 0xd8,0xd9,0xda,0xdb,0xdc,0xdd,0xde,0xdf,0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,
4217 0xe8,0x00,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,
4218 0x26,0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0x34,0x35,
4219 0x36,0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,
4220 0x46,0x47,0x48,0x49,0xb8
4221 };
4222
NightstrStickRead(INT32 Offset)4223 static UINT8 NightstrStickRead(INT32 Offset)
4224 {
4225 switch (Offset) { // p0: 3f - be p1: bf - 40
4226 case 0x00: {
4227 UINT8 Temp = ProcessAnalog(TaitoAnalogPort0, 0, 0, 0x00, 0xff);
4228 //bprintf(0, _T("Port0-temp[%X] scaled[%X]\n"), Temp, Temp2);
4229 return nightstr_stick[(Temp * 0x64) / 0x100];
4230 }
4231
4232 case 0x01: {
4233 UINT8 Temp = ProcessAnalog(TaitoAnalogPort1, 1, 0, 0x00, 0xff);
4234 return nightstr_stick[(Temp * 0x64) / 0x100];
4235 }
4236
4237 case 0x02: {
4238 return 0xff;
4239 }
4240
4241 case 0x03: {
4242 return 0xff;
4243 }
4244 }
4245
4246 return 0xff;
4247 }
4248
Nightstr68K1ReadByte(UINT32 a)4249 static UINT8 __fastcall Nightstr68K1ReadByte(UINT32 a)
4250 {
4251 TC0220IOCHalfWordRead_Map(0x400000)
4252
4253 switch (a) {
4254 case 0xe40001:
4255 case 0xe40003:
4256 case 0xe40005:
4257 case 0xe40007: {
4258 return NightstrStickRead((a - 0xe40000) >> 1);
4259 }
4260
4261 default: {
4262 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
4263 }
4264 }
4265
4266 return 0;
4267 }
4268
Nightstr68K1WriteByte(UINT32 a,UINT8 d)4269 static void __fastcall Nightstr68K1WriteByte(UINT32 a, UINT8 d)
4270 {
4271 TC0220IOCHalfWordWrite_Map(0x400000)
4272 TC0100SCN0ByteWrite_Map(0xc00000, 0xc0ffff)
4273
4274 switch (a) {
4275 case 0xe00000:
4276 case 0xe00008:
4277 case 0xe00010: {
4278 // nop
4279 return;
4280 }
4281
4282 default: {
4283 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
4284 }
4285 }
4286 }
4287
Nightstr68K1ReadWord(UINT32 a)4288 static UINT16 __fastcall Nightstr68K1ReadWord(UINT32 a)
4289 {
4290 switch (a) {
4291 case 0x820002: {
4292 return TC0140SYTCommRead();
4293 }
4294
4295 case 0xa00002: {
4296 return TC0110PCRWordRead(0);
4297 }
4298
4299 default: {
4300 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
4301 }
4302 }
4303
4304 return 0;
4305 }
4306
Nightstr68K1WriteWord(UINT32 a,UINT16 d)4307 static void __fastcall Nightstr68K1WriteWord(UINT32 a, UINT16 d)
4308 {
4309 TC0220IOCHalfWordWrite_Map(0x400000)
4310 TC0100SCN0WordWrite_Map(0xc00000, 0xc0ffff)
4311 TC0100SCN0CtrlWordWrite_Map(0xc20000)
4312
4313 switch (a) {
4314 case 0x800000: {
4315 TaitoZCpuAReset(d);
4316 return;
4317 }
4318
4319 case 0x820000: {
4320 TC0140SYTPortWrite(d & 0xff);
4321 return;
4322 }
4323
4324 case 0x820002: {
4325 TC0140SYTCommWrite(d & 0xff);
4326 return;
4327 }
4328
4329 case 0xa00000:
4330 case 0xa00002: {
4331 TC0110PCRStep1WordWrite(0, (a - 0xa00000) >> 1, d);
4332 return;
4333 }
4334
4335 case 0xe00000:
4336 case 0xe00008:
4337 case 0xe00010: {
4338 // nop
4339 return;
4340 }
4341
4342 case 0xe40000:
4343 case 0xe40002:
4344 case 0xe40004:
4345 case 0xe40006:
4346 case 0xe40008:
4347 case 0xe4000a:
4348 case 0xe4000c:
4349 case 0xe4000e: {
4350 TaitoZINT6timer = SekTotalCycles();
4351 return;
4352 }
4353
4354 default: {
4355 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
4356 }
4357 }
4358 }
4359
Racingb68K1ReadByte(UINT32 a)4360 static UINT8 __fastcall Racingb68K1ReadByte(UINT32 a)
4361 {
4362 TC0510NIOHalfWordSwapRead_Map(0x300000)
4363
4364 switch (a) {
4365 case 0x300019:
4366 case 0x30001b: {
4367 return DblaxleSteerRead((a - 0x300010) >> 1);
4368 }
4369
4370 case 0x520003: {
4371 return TC0140SYTCommRead();
4372 }
4373
4374 default: {
4375 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
4376 }
4377 }
4378
4379 return 0;
4380 }
4381
Racingb68K1WriteByte(UINT32 a,UINT8 d)4382 static void __fastcall Racingb68K1WriteByte(UINT32 a, UINT8 d)
4383 {
4384 TC0510NIOHalfWordSwapWrite_Map(0x300000)
4385
4386 switch (a) {
4387 case 0x500002: {
4388 TaitoZCpuAReset(d);
4389 return;
4390 }
4391
4392 case 0x520001: {
4393 TC0140SYTPortWrite(d);
4394 return;
4395 }
4396
4397 case 0x520003: {
4398 TC0140SYTCommWrite(d);
4399 return;
4400 }
4401
4402 case 0xb08000: {
4403 SciSpriteFrame = d;
4404 return;
4405 }
4406
4407 default: {
4408 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
4409 }
4410 }
4411 }
4412
Racingb68K1ReadWord(UINT32 a)4413 static UINT16 __fastcall Racingb68K1ReadWord(UINT32 a)
4414 {
4415 switch (a) {
4416 default: {
4417 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
4418 }
4419 }
4420
4421 return 0;
4422 }
4423
Racingb68K1WriteWord(UINT32 a,UINT16 d)4424 static void __fastcall Racingb68K1WriteWord(UINT32 a, UINT16 d)
4425 {
4426 TC0510NIOHalfWordSwapWrite_Map(0x300000)
4427 TC0480SCPCtrlWordWrite_Map(0x930000)
4428
4429 switch (a) {
4430 default: {
4431 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
4432 }
4433 }
4434 }
4435
SciSteerRead(INT32 Offset)4436 static UINT8 SciSteerRead(INT32 Offset)
4437 {
4438 INT32 Steer = 0xFF80 + ProcessAnalog(TaitoAnalogPort0, 0, 1, 0x20, 0xe0);
4439
4440 switch (Offset) {
4441 case 0x04: {
4442 return Steer & 0xff;
4443 }
4444
4445 case 0x05: {
4446 return (Steer & 0xff00) >> 8;
4447 }
4448 }
4449
4450 return 0xff;
4451 }
4452
Sci68K1ReadByte(UINT32 a)4453 static UINT8 __fastcall Sci68K1ReadByte(UINT32 a)
4454 {
4455 TC0220IOCHalfWordRead_Map(0x200000)
4456
4457 switch (a) {
4458 case 0x200019:
4459 case 0x20001b: {
4460 return SciSteerRead((a - 0x200010) >> 1);
4461 }
4462
4463 default: {
4464 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
4465 }
4466 }
4467
4468 return 0;
4469 }
4470
Sci68K1WriteByte(UINT32 a,UINT8 d)4471 static void __fastcall Sci68K1WriteByte(UINT32 a, UINT8 d)
4472 {
4473 TC0220IOCHalfWordWrite_Map(0x200000)
4474 TC0100SCN0ByteWrite_Map(0xa00000, 0xa0ffff)
4475
4476 switch (a) {
4477 case 0x400001: {
4478 TaitoZCpuAReset(d);
4479 return;
4480 }
4481
4482 case 0x420001: {
4483 TC0140SYTPortWrite(d);
4484 return;
4485 }
4486
4487 case 0x420003: {
4488 TC0140SYTCommWrite(d);
4489 return;
4490 }
4491
4492 case 0xc08000: {
4493 SciSpriteFrame = d;
4494 return;
4495 }
4496
4497 default: {
4498 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
4499 }
4500 }
4501 }
4502
Sci68K1WriteWord(UINT32 a,UINT16 d)4503 static void __fastcall Sci68K1WriteWord(UINT32 a, UINT16 d)
4504 {
4505 TC0100SCN0WordWrite_Map(0xa00000, 0xa0ffff)
4506 TC0100SCN0CtrlWordWrite_Map(0xa20000)
4507
4508 switch (a) {
4509 default: {
4510 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
4511 }
4512 }
4513 }
4514
4515 static const UINT8 spacegun_default_eeprom[128]=
4516 {
4517 0x00,0x00,0x00,0xff,0x00,0x01,0x41,0x41,0x00,0x00,0x00,0xff,0x00,0x00,0xf0,0xf0,
4518 0x00,0x00,0x00,0xff,0x00,0x01,0x41,0x41,0x00,0x00,0x00,0xff,0x00,0x00,0xf0,0xf0,
4519 0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x01,0x40,0x00,0x00,0x00,0xf0,0x00,
4520 0x00,0x01,0x42,0x85,0x00,0x00,0xf1,0xe3,0x00,0x01,0x40,0x00,0x00,0x00,0xf0,0x00,
4521 0x00,0x01,0x42,0x85,0x00,0x00,0xf1,0xe3,0xcc,0xcb,0xff,0xff,0xff,0xff,0xff,0xff,
4522 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
4523 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
4524 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
4525 };
4526
4527 static const eeprom_interface spacegun_eeprom_intf =
4528 {
4529 6, /* address bits */
4530 16, /* data bits */
4531 "0110", /* read command */
4532 "0101", /* write command */
4533 "0111", /* erase command */
4534 "0100000000", /* lock command */
4535 "0100111111", /* unlock command */
4536 0, /* multi-read disabled */
4537 1 /* reset delay */
4538 };
4539
SpacegunInputBypassRead(INT32 Offset)4540 static UINT8 SpacegunInputBypassRead(INT32 Offset)
4541 {
4542 switch (Offset) {
4543 case 0x03: {
4544 return (EEPROMRead() & 1) << 7;
4545 }
4546
4547 default: {
4548 return TC0220IOCRead(Offset);
4549 }
4550 }
4551
4552 return 0;
4553 }
4554
SpacegunInputBypassWrite(INT32 Offset,UINT16 Data)4555 static void SpacegunInputBypassWrite(INT32 Offset, UINT16 Data)
4556 {
4557 switch (Offset) {
4558 case 0x03: {
4559 EEPROMWrite(Data & 0x20, Data & 0x10, Data & 0x40);
4560 return;
4561 }
4562
4563 default: {
4564 TC0220IOCWrite(Offset, Data & 0xff);
4565 }
4566 }
4567 }
4568
Spacegun68K1WriteByte(UINT32 a,UINT8 d)4569 static void __fastcall Spacegun68K1WriteByte(UINT32 a, UINT8 d)
4570 {
4571 TC0100SCN0ByteWrite_Map(0x900000, 0x90ffff)
4572
4573 switch (a) {
4574 default: {
4575 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
4576 }
4577 }
4578 }
4579
Spacegun68K1ReadWord(UINT32 a)4580 static UINT16 __fastcall Spacegun68K1ReadWord(UINT32 a)
4581 {
4582 switch (a) {
4583 case 0xb00002: {
4584 return TC0110PCRWordRead(0);
4585 }
4586
4587 default: {
4588 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
4589 }
4590 }
4591
4592 return 0;
4593 }
4594
Spacegun68K1WriteWord(UINT32 a,UINT16 d)4595 static void __fastcall Spacegun68K1WriteWord(UINT32 a, UINT16 d)
4596 {
4597 TC0100SCN0WordWrite_Map(0x900000, 0x90ffff)
4598 TC0100SCN0CtrlWordWrite_Map(0x920000)
4599
4600 switch (a) {
4601 case 0xb00000:
4602 case 0xb00002: {
4603 TC0110PCRStep1RBSwapWordWrite(0, (a - 0xb00000) >> 1, d);
4604 return;
4605 }
4606
4607 default: {
4608 bprintf(PRINT_NORMAL, _T("68K #1 Write word => %06X, %04X\n"), a, d);
4609 }
4610 }
4611 }
4612
Spacegun68K2ReadByte(UINT32 a)4613 static UINT8 __fastcall Spacegun68K2ReadByte(UINT32 a)
4614 {
4615 switch (a) {
4616 case 0xc0000d: {
4617 // nop
4618 return 0;
4619 }
4620
4621 case 0xf00001: {
4622 return ~BurnGunReturnX(0);
4623 }
4624
4625 case 0xf00003: {
4626 return BurnGunReturnY(0);
4627 }
4628
4629 case 0xf00005: {
4630 return ~BurnGunReturnX(1);
4631 }
4632
4633 case 0xf00007: {
4634 return BurnGunReturnY(1);
4635 }
4636
4637 default: {
4638 bprintf(PRINT_NORMAL, _T("68K #2 Read byte => %06X\n"), a);
4639 }
4640 }
4641
4642 return 0;
4643 }
4644
Spacegun68K2WriteByte(UINT32 a,UINT8 d)4645 static void __fastcall Spacegun68K2WriteByte(UINT32 a, UINT8 d)
4646 {
4647 switch (a) {
4648 case 0x800008: {
4649 SpacegunInputBypassWrite((a - 0x800000) >> 1, d);
4650 return;
4651 }
4652
4653 case 0xc0000d: {
4654 // nop
4655 return;
4656 }
4657
4658 case 0xe00001: {
4659 // ???
4660 return;
4661 }
4662
4663 default: {
4664 bprintf(PRINT_NORMAL, _T("68K #2 Write byte => %06X, %02X\n"), a, d);
4665 }
4666 }
4667 }
4668
Spacegun68K2ReadWord(UINT32 a)4669 static UINT16 __fastcall Spacegun68K2ReadWord(UINT32 a)
4670 {
4671 switch (a) {
4672 case 0x800000:
4673 case 0x800002:
4674 case 0x800004:
4675 case 0x800006:
4676 case 0x800008:
4677 case 0x80000a:
4678 case 0x80000c:
4679 case 0x80000e: {
4680 return SpacegunInputBypassRead((a - 0x800000) >> 1);
4681 }
4682
4683 case 0xc00000: {
4684 return BurnYM2610Read(0);
4685 }
4686
4687 default: {
4688 bprintf(PRINT_NORMAL, _T("68K #2 Read word => %06X\n"), a);
4689 }
4690 }
4691
4692 return 0;
4693 }
4694
Spacegun68K2WriteWord(UINT32 a,UINT16 d)4695 static void __fastcall Spacegun68K2WriteWord(UINT32 a, UINT16 d)
4696 {
4697 switch (a) {
4698 case 0x800000:
4699 case 0x800002:
4700 case 0x800004:
4701 case 0x800006:
4702 case 0x800008:
4703 case 0x80000a:
4704 case 0x80000c:
4705 case 0x80000e: {
4706 SpacegunInputBypassWrite((a - 0x800000) >> 1, d);
4707 return;
4708 }
4709
4710 case 0xc00000: {
4711 BurnYM2610Write(0, d & 0xff);
4712 return;
4713 }
4714
4715 case 0xc00002: {
4716 BurnYM2610Write(1, d & 0xff);
4717 return;
4718 }
4719
4720 case 0xc00004: {
4721 BurnYM2610Write(2, d & 0xff);
4722 return;
4723 }
4724
4725 case 0xc00006: {
4726 BurnYM2610Write(3, d & 0xff);
4727 return;
4728 }
4729
4730 case 0xc20000:
4731 case 0xc20002:
4732 case 0xc20004:
4733 case 0xc20006: {
4734 // ???
4735 return;
4736 }
4737
4738 case 0xf00000:
4739 case 0xf00002:
4740 case 0xf00004:
4741 case 0xf00006: {
4742 SekSetIRQLine(5, CPU_IRQSTATUS_AUTO);
4743 return;
4744 }
4745
4746 default: {
4747 bprintf(PRINT_NORMAL, _T("68K #2 Write word => %06X, %04X\n"), a, d);
4748 }
4749 }
4750 }
4751
TaitoZZ80Read(UINT16 a)4752 static UINT8 __fastcall TaitoZZ80Read(UINT16 a)
4753 {
4754 switch (a) {
4755 case 0xe000: {
4756 return BurnYM2610Read(0);
4757 }
4758
4759 case 0xe001: {
4760 return BurnYM2610Read(1);
4761 }
4762
4763 case 0xe002: {
4764 return BurnYM2610Read(2);
4765 }
4766
4767 case 0xe200: {
4768 // NOP
4769 return 0;
4770 }
4771
4772 case 0xe201: {
4773 return TC0140SYTSlaveCommRead();
4774 }
4775
4776 case 0xea00: {
4777 // NOP
4778 return 0;
4779 }
4780
4781 default: {
4782 bprintf(PRINT_NORMAL, _T("Z80 Read => %04X\n"), a);
4783 }
4784 }
4785
4786 return 0;
4787 }
4788
TaitoZZ80Write(UINT16 a,UINT8 d)4789 static void __fastcall TaitoZZ80Write(UINT16 a, UINT8 d)
4790 {
4791 switch (a) {
4792 case 0xe000: {
4793 BurnYM2610Write(0, d);
4794 return;
4795 }
4796
4797 case 0xe001: {
4798 BurnYM2610Write(1, d);
4799 return;
4800 }
4801
4802 case 0xe002: {
4803 BurnYM2610Write(2, d);
4804 return;
4805 }
4806
4807 case 0xe003: {
4808 BurnYM2610Write(3, d);
4809 return;
4810 }
4811
4812 case 0xe200: {
4813 TC0140SYTSlavePortWrite(d);
4814 return;
4815 }
4816
4817 case 0xe201: {
4818 TC0140SYTSlaveCommWrite(d);
4819 return;
4820 }
4821
4822 case 0xe400: {
4823 BurnYM2610SetRightVolume(BURN_SND_YM2610_YM2610_ROUTE_1, TaitoZYM2610Route1MasterVol * d / 255.0);
4824 return;
4825 }
4826
4827 case 0xe401: {
4828 BurnYM2610SetLeftVolume(BURN_SND_YM2610_YM2610_ROUTE_1, TaitoZYM2610Route1MasterVol * d / 255.0);
4829 return;
4830 }
4831
4832 case 0xe402: {
4833 BurnYM2610SetRightVolume(BURN_SND_YM2610_YM2610_ROUTE_2, TaitoZYM2610Route1MasterVol * d / 255.0);
4834 return;
4835 }
4836
4837 case 0xe403: {
4838 BurnYM2610SetLeftVolume(BURN_SND_YM2610_YM2610_ROUTE_2, TaitoZYM2610Route1MasterVol * d / 255.0);
4839 return;
4840 }
4841
4842 case 0xe600: {
4843 return;
4844 }
4845
4846 case 0xee00: {
4847 return;
4848 }
4849
4850 case 0xf000: {
4851 return;
4852 }
4853
4854 case 0xf200: {
4855 TaitoZ80Bank = (d - 1) & 7;
4856 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
4857 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
4858 return;
4859 }
4860
4861 default: {
4862 bprintf(PRINT_NORMAL, _T("Z80 Write => %04X, %02X\n"), a, d);
4863 }
4864 }
4865 }
4866
4867 static INT32 CharPlaneOffsets[4] = { 0, 1, 2, 3 };
4868 static INT32 CharXOffsets[8] = { 8, 12, 0, 4, 24, 28, 16, 20 };
4869 static INT32 CharYOffsets[8] = { 0, 32, 64, 96, 128, 160, 192, 224 };
4870 static INT32 DblaxleCharPlaneOffsets[4] = { 0, 1, 2, 3 };
4871 static INT32 DblaxleCharXOffsets[16] = { 4, 0, 20, 16, 12, 8, 28, 24, 36, 32, 52, 48, 44, 40, 60, 56 };
4872 static INT32 DblaxleCharYOffsets[16] = { 0, 64, 128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960 };
4873 static INT32 SpritePlaneOffsets[4] = { 0, 8, 16, 24 };
4874 static INT32 SpriteXOffsets[16] = { 32, 33, 34, 35, 36, 37, 38, 39, 0, 1, 2, 3, 4, 5, 6, 7 };
4875 static INT32 SpriteYOffsets[16] = { 0, 64, 128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960 };
4876 static INT32 Sprite16x8YOffsets[8] = { 0, 64, 128, 192, 256, 320, 384, 448 };
4877
TaitoZFMIRQHandler(INT32,INT32 nStatus)4878 static void TaitoZFMIRQHandler(INT32, INT32 nStatus)
4879 {
4880 ZetSetIRQLine(0, (nStatus) ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE);
4881 }
4882
TaitoZZ80Init()4883 static void TaitoZZ80Init()
4884 {
4885 // Setup the Z80 emulation
4886 ZetInit(0);
4887 ZetOpen(0);
4888 ZetSetReadHandler(TaitoZZ80Read);
4889 ZetSetWriteHandler(TaitoZZ80Write);
4890 ZetMapArea(0x0000, 0x3fff, 0, TaitoZ80Rom1 );
4891 ZetMapArea(0x0000, 0x3fff, 2, TaitoZ80Rom1 );
4892 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 );
4893 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 );
4894 ZetMapArea(0xc000, 0xdfff, 0, TaitoZ80Ram1 );
4895 ZetMapArea(0xc000, 0xdfff, 1, TaitoZ80Ram1 );
4896 ZetMapArea(0xc000, 0xdfff, 2, TaitoZ80Ram1 );
4897 ZetClose();
4898
4899 TaitoNumZ80s = 1;
4900 }
4901
4902 #ifdef BUILD_A68K
SwitchToMusashi()4903 static void SwitchToMusashi()
4904 {
4905 if (bBurnUseASMCPUEmulation) {
4906 #if 1 && defined FBNEO_DEBUG
4907 bprintf(PRINT_NORMAL, _T("Switching to Musashi 68000 core\n"));
4908 #endif
4909 bUseAsm68KCoreOldValue = bBurnUseASMCPUEmulation;
4910 bBurnUseASMCPUEmulation = false;
4911 }
4912 }
4913 #endif
4914
AquajackInit()4915 static INT32 AquajackInit()
4916 {
4917 INT32 nLen;
4918
4919 TaitoCharModulo = 0x100;
4920 TaitoCharNumPlanes = 4;
4921 TaitoCharWidth = 8;
4922 TaitoCharHeight = 8;
4923 TaitoCharPlaneOffsets = CharPlaneOffsets;
4924 TaitoCharXOffsets = CharXOffsets;
4925 TaitoCharYOffsets = CharYOffsets;
4926 TaitoNumChar = 0x4000;
4927
4928 TaitoSpriteAModulo = 0x200;
4929 TaitoSpriteANumPlanes = 4;
4930 TaitoSpriteAWidth = 16;
4931 TaitoSpriteAHeight = 8;
4932 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
4933 TaitoSpriteAXOffsets = SpriteXOffsets;
4934 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
4935 TaitoNumSpriteA = 0x8000;
4936
4937 TaitoNum68Ks = 2;
4938 TaitoNumZ80s = 1;
4939 TaitoNumYM2610 = 1;
4940
4941 TaitoLoadRoms(0);
4942
4943 // Allocate and Blank all required memory
4944 TaitoMem = NULL;
4945 MemIndex();
4946 nLen = TaitoMemEnd - (UINT8 *)0;
4947 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
4948 memset(TaitoMem, 0, nLen);
4949 MemIndex();
4950
4951 GenericTilesInit();
4952
4953 TC0100SCNInit(0, TaitoNumChar, 0, 8, 0, NULL);
4954 TC0110PCRInit(1, 0x1000);
4955 TC0150RODInit(TaitoRoadRomSize, 0);
4956 TC0140SYTInit(0);
4957 TC0220IOCInit();
4958
4959 if (TaitoLoadRoms(1)) return 1;
4960
4961 #ifdef BUILD_A68K
4962 SwitchToMusashi();
4963 #endif
4964
4965 // Setup the 68000 emulation
4966 SekInit(0, 0x68000);
4967 SekOpen(0);
4968 SekMapMemory(Taito68KRom1 , 0x000000, 0x03ffff, MAP_ROM);
4969 SekMapMemory(Taito68KRam1 , 0x100000, 0x103fff, MAP_RAM);
4970 SekMapMemory(TaitoSharedRam , 0x104000, 0x107fff, MAP_RAM);
4971 SekMapMemory(TC0150RODRam , 0x800000, 0x801fff, MAP_RAM);
4972 SekMapMemory(TC0100SCNRam[0] , 0xa00000, 0xa0ffff, MAP_READ);
4973 SekMapMemory(TaitoSpriteRam , 0xc40000, 0xc403ff, MAP_RAM);
4974 SekSetWriteByteHandler(0, Aquajack68K1WriteByte);
4975 SekSetWriteWordHandler(0, Aquajack68K1WriteWord);
4976 SekClose();
4977
4978 SekInit(1, 0x68000);
4979 SekOpen(1);
4980 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
4981 SekMapMemory(Taito68KRam2 , 0x100000, 0x103fff, MAP_RAM);
4982 SekMapMemory(TaitoSharedRam , 0x104000, 0x107fff, MAP_RAM);
4983 SekSetReadWordHandler(0, Aquajack68K2ReadWord);
4984 SekSetWriteWordHandler(0, Aquajack68K2WriteWord);
4985 SekSetReadByteHandler(0, Aquajack68K2ReadByte);
4986 SekClose();
4987
4988 TaitoZZ80Init();
4989
4990 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
4991 BurnTimerAttachZet(16000000 / 4);
4992 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
4993 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
4994 TaitoZYM2610Route1MasterVol = 2.00;
4995 TaitoZYM2610Route2MasterVol = 2.00;
4996 bYM2610UseSeperateVolumes = 1;
4997
4998 TaitoMakeInputsFunction = AquajackMakeInputs;
4999 TaitoIrqLine = 4;
5000 TaitoFrameInterleave = 500;
5001
5002 nTaitoCyclesTotal[0] = 12000000 / 60;
5003 nTaitoCyclesTotal[1] = 12000000 / 60;
5004 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5005
5006 // Reset the driver
5007 TaitoZDoReset();
5008
5009 return 0;
5010 }
5011
BsharkInit()5012 static INT32 BsharkInit()
5013 {
5014 INT32 nLen;
5015
5016 Sci = 1;
5017
5018 TaitoCharModulo = 0x100;
5019 TaitoCharNumPlanes = 4;
5020 TaitoCharWidth = 8;
5021 TaitoCharHeight = 8;
5022 TaitoCharPlaneOffsets = CharPlaneOffsets;
5023 TaitoCharXOffsets = CharXOffsets;
5024 TaitoCharYOffsets = CharYOffsets;
5025 TaitoNumChar = 0x4000;
5026
5027 TaitoSpriteAModulo = 0x200;
5028 TaitoSpriteANumPlanes = 4;
5029 TaitoSpriteAWidth = 16;
5030 TaitoSpriteAHeight = 8;
5031 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5032 TaitoSpriteAXOffsets = SpriteXOffsets;
5033 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5034 TaitoNumSpriteA = 0x8000;
5035
5036 TaitoNum68Ks = 2;
5037 TaitoNumYM2610 = 1;
5038
5039 TaitoLoadRoms(0);
5040
5041 // Allocate and Blank all required memory
5042 TaitoMem = NULL;
5043 MemIndex();
5044 nLen = TaitoMemEnd - (UINT8 *)0;
5045 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5046 memset(TaitoMem, 0, nLen);
5047 MemIndex();
5048
5049 GenericTilesInit();
5050
5051 TC0100SCNInit(0, TaitoNumChar, 0, 8, 1, NULL);
5052 TC0150RODInit(TaitoRoadRomSize, 1);
5053 TC0220IOCInit();
5054
5055 if (TaitoLoadRoms(1)) return 1;
5056
5057 #ifdef BUILD_A68K
5058 SwitchToMusashi();
5059 #endif
5060
5061 // Setup the 68000 emulation
5062 SekInit(0, 0x68000);
5063 SekOpen(0);
5064 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5065 SekMapMemory(Taito68KRam1 , 0x100000, 0x10ffff, MAP_RAM);
5066 SekMapMemory(TaitoSharedRam , 0x110000, 0x113fff, MAP_RAM);
5067 SekMapMemory(TaitoPaletteRam , 0xa00000, 0xa01fff, MAP_RAM);
5068 SekMapMemory(TaitoSpriteRam , 0xc00000, 0xc00fff, MAP_RAM);
5069 SekMapMemory(TC0100SCNRam[0] , 0xd00000, 0xd0ffff, MAP_READ);
5070 SekSetWriteWordHandler(0, Bshark68K1WriteWord);
5071 SekSetReadByteHandler(0, Bshark68K1ReadByte);
5072 SekSetWriteByteHandler(0, Bshark68K1WriteByte);
5073 SekClose();
5074
5075 SekInit(1, 0x68000);
5076 SekOpen(1);
5077 SekMapMemory(Taito68KRom2 , 0x000000, 0x07ffff, MAP_ROM);
5078 SekMapMemory(Taito68KRam2 , 0x108000, 0x10bfff, MAP_RAM);
5079 SekMapMemory(TaitoSharedRam , 0x110000, 0x113fff, MAP_RAM);
5080 SekMapMemory(TC0150RODRam , 0x800000, 0x801fff, MAP_RAM);
5081 SekSetReadWordHandler(0, Bshark68K2ReadWord);
5082 SekSetWriteWordHandler(0, Bshark68K2WriteWord);
5083 SekClose();
5084
5085 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, NULL, 0);
5086 BurnTimerAttachSek(12000000);
5087 BurnYM2610SetRoute(BURN_SND_YM2610_YM2610_ROUTE_1, 1.00, BURN_SND_ROUTE_BOTH);
5088 BurnYM2610SetRoute(BURN_SND_YM2610_YM2610_ROUTE_2, 1.00, BURN_SND_ROUTE_BOTH);
5089 BurnYM2610SetRoute(BURN_SND_YM2610_AY8910_ROUTE, 0.25, BURN_SND_ROUTE_BOTH);
5090
5091 TaitoMakeInputsFunction = BsharkMakeInputs;
5092 TaitoIrqLine = 4;
5093 TaitoFrameInterleave = 271;
5094 TaitoFlipScreenX = 1;
5095
5096 nTaitoCyclesTotal[0] = 12000000 / 60;
5097 nTaitoCyclesTotal[1] = 12000000 / 60;
5098
5099 // Reset the driver
5100 TaitoZDoReset();
5101
5102 return 0;
5103 }
5104
TaitoZSetupShifter()5105 static void TaitoZSetupShifter()
5106 {
5107 bUseShifter = 1;
5108 BurnShiftInitDefault();
5109 }
5110
ChasehqInit()5111 static INT32 ChasehqInit()
5112 {
5113 INT32 nLen;
5114
5115 TaitoCharModulo = 0x100;
5116 TaitoCharNumPlanes = 4;
5117 TaitoCharWidth = 8;
5118 TaitoCharHeight = 8;
5119 TaitoCharPlaneOffsets = CharPlaneOffsets;
5120 TaitoCharXOffsets = CharXOffsets;
5121 TaitoCharYOffsets = CharYOffsets;
5122 TaitoNumChar = 0x4000;
5123
5124 TaitoSpriteAModulo = 0x400;
5125 TaitoSpriteANumPlanes = 4;
5126 TaitoSpriteAWidth = 16;
5127 TaitoSpriteAHeight = 16;
5128 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5129 TaitoSpriteAXOffsets = SpriteXOffsets;
5130 TaitoSpriteAYOffsets = SpriteYOffsets;
5131 TaitoNumSpriteA = 0x4000;
5132
5133 TaitoSpriteBModulo = 0x400;
5134 TaitoSpriteBNumPlanes = 4;
5135 TaitoSpriteBWidth = 16;
5136 TaitoSpriteBHeight = 16;
5137 TaitoSpriteBPlaneOffsets = SpritePlaneOffsets;
5138 TaitoSpriteBXOffsets = SpriteXOffsets;
5139 TaitoSpriteBYOffsets = SpriteYOffsets;
5140 TaitoNumSpriteB = 0x4000;
5141
5142 TaitoNum68Ks = 2;
5143 TaitoNumZ80s = 1;
5144 TaitoNumYM2610 = 1;
5145
5146 TaitoLoadRoms(0);
5147
5148 GenericTilesInit();
5149
5150 // Allocate and Blank all required memory
5151 TaitoMem = NULL;
5152 MemIndex();
5153 nLen = TaitoMemEnd - (UINT8 *)0;
5154 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5155 memset(TaitoMem, 0, nLen);
5156 MemIndex();
5157
5158 // This block must be before TaitoLoadRoms(1) - or else!
5159 TC0100SCNInit(0, TaitoNumChar, 0, 8, 0, TaitoPriorityMap);
5160 TC0110PCRInit(1, 0x1000);
5161 TC0150RODInit(TaitoRoadRomSize, 0);
5162 TC0150RODSetPriMap(TaitoPriorityMap);
5163 TC0140SYTInit(0);
5164 TC0220IOCInit();
5165
5166 if (TaitoLoadRoms(1)) return 1;
5167
5168 #ifdef BUILD_A68K
5169 SwitchToMusashi();
5170 #endif
5171
5172 // Setup the 68000 emulation
5173 SekInit(0, 0x68000);
5174 SekOpen(0);
5175 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5176 SekMapMemory(Taito68KRam1 , 0x100000, 0x107fff, MAP_RAM);
5177 SekMapMemory(TaitoSharedRam , 0x108000, 0x10bfff, MAP_RAM);
5178 SekMapMemory(TC0100SCNRam[0] , 0xc00000, 0xc0ffff, MAP_READ);
5179 SekMapMemory(TaitoSpriteRam , 0xd00000, 0xd007ff, MAP_RAM);
5180 SekSetReadWordHandler(0, Chasehq68K1ReadWord);
5181 SekSetWriteWordHandler(0, Chasehq68K1WriteWord);
5182 SekSetReadByteHandler(0, Chasehq68K1ReadByte);
5183 SekSetWriteByteHandler(0, Chasehq68K1WriteByte);
5184 SekClose();
5185
5186 SekInit(1, 0x68000);
5187 SekOpen(1);
5188 SekMapMemory(Taito68KRom2 , 0x000000, 0x01ffff, MAP_ROM);
5189 SekMapMemory(Taito68KRam2 , 0x100000, 0x103fff, MAP_RAM);
5190 SekMapMemory(TaitoSharedRam , 0x108000, 0x10bfff, MAP_RAM);
5191 SekMapMemory(TC0150RODRam , 0x800000, 0x801fff, MAP_RAM);
5192 SekClose();
5193
5194 TaitoZZ80Init();
5195
5196 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5197 BurnTimerAttachZet(16000000 / 4);
5198 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.20);
5199 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.20);
5200 TaitoZYM2610Route1MasterVol = 1.00;
5201 TaitoZYM2610Route2MasterVol = 1.00;
5202 bYM2610UseSeperateVolumes = 1;
5203
5204 TaitoMakeInputsFunction = ChasehqMakeInputs;
5205 TaitoIrqLine = 4;
5206 TaitoFrameInterleave = 100;
5207
5208 nTaitoCyclesTotal[0] = 12000000 / 60;
5209 nTaitoCyclesTotal[1] = 12000000 / 60;
5210 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5211
5212 TaitoZSetupShifter();
5213
5214 // Reset the driver
5215 TaitoZDoReset();
5216
5217 return 0;
5218 }
5219
ContcircInit()5220 static INT32 ContcircInit()
5221 {
5222 INT32 nLen;
5223
5224 TaitoCharModulo = 0x100;
5225 TaitoCharNumPlanes = 4;
5226 TaitoCharWidth = 8;
5227 TaitoCharHeight = 8;
5228 TaitoCharPlaneOffsets = CharPlaneOffsets;
5229 TaitoCharXOffsets = CharXOffsets;
5230 TaitoCharYOffsets = CharYOffsets;
5231 TaitoNumChar = 0x4000;
5232
5233 TaitoSpriteAModulo = 0x200;
5234 TaitoSpriteANumPlanes = 4;
5235 TaitoSpriteAWidth = 16;
5236 TaitoSpriteAHeight = 8;
5237 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5238 TaitoSpriteAXOffsets = SpriteXOffsets;
5239 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5240 TaitoNumSpriteA = 0x8000;
5241
5242 TaitoNum68Ks = 2;
5243 TaitoNumZ80s = 1;
5244 TaitoNumYM2610 = 1;
5245
5246 TaitoLoadRoms(0);
5247
5248 // Allocate and Blank all required memory
5249 TaitoMem = NULL;
5250 MemIndex();
5251 nLen = TaitoMemEnd - (UINT8 *)0;
5252 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5253 memset(TaitoMem, 0, nLen);
5254 MemIndex();
5255
5256 GenericTilesInit();
5257
5258 TC0100SCNInit(0, TaitoNumChar, 0, 16, 0, NULL);
5259 TC0110PCRInit(1, 0x1000);
5260 TC0150RODInit(TaitoRoadRomSize, 0);
5261 TC0140SYTInit(0);
5262 TC0220IOCInit();
5263
5264 if (TaitoLoadRoms(1)) return 1;
5265
5266 #ifdef BUILD_A68K
5267 SwitchToMusashi();
5268 #endif
5269
5270 // Setup the 68000 emulation
5271 SekInit(0, 0x68000);
5272 SekOpen(0);
5273 SekMapMemory(Taito68KRom1 , 0x000000, 0x03ffff, MAP_ROM);
5274 SekMapMemory(Taito68KRam1 , 0x080000, 0x083fff, MAP_RAM);
5275 SekMapMemory(TaitoSharedRam , 0x084000, 0x087fff, MAP_RAM);
5276 SekMapMemory(TC0100SCNRam[0] , 0x200000, 0x20ffff, MAP_READ);
5277 SekMapMemory(TC0150RODRam , 0x300000, 0x301fff, MAP_RAM);
5278 SekMapMemory(TaitoSpriteRam , 0x400000, 0x4006ff, MAP_RAM);
5279 SekSetWriteByteHandler(0, Contcirc68K1WriteByte);
5280 SekSetWriteWordHandler(0, Contcirc68K1WriteWord);
5281 SekClose();
5282
5283 SekInit(1, 0x68000);
5284 SekOpen(1);
5285 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
5286 SekMapMemory(Taito68KRam2 , 0x080000, 0x083fff, MAP_RAM);
5287 SekMapMemory(TaitoSharedRam , 0x084000, 0x087fff, MAP_RAM);
5288 SekSetReadWordHandler(0, Contcirc68K2ReadWord);
5289 SekSetWriteWordHandler(0, Contcirc68K2WriteWord);
5290 SekSetReadByteHandler(0, Contcirc68K2ReadByte);
5291 SekSetWriteByteHandler(0, Contcirc68K2WriteByte);
5292 SekClose();
5293
5294 TaitoZZ80Init();
5295
5296 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5297 BurnTimerAttachZet(16000000 / 4);
5298 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.05);
5299 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.05);
5300 TaitoZYM2610Route1MasterVol = 2.00;
5301 TaitoZYM2610Route2MasterVol = 2.00;
5302 bYM2610UseSeperateVolumes = 1;
5303
5304 TaitoMakeInputsFunction = ContcircMakeInputs;
5305 TaitoIrqLine = 6;
5306 TaitoFrameInterleave = 100;
5307
5308 nTaitoCyclesTotal[0] = 12000000 / 60;
5309 nTaitoCyclesTotal[1] = 12000000 / 60;
5310 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5311
5312 TaitoZSetupShifter();
5313
5314 // Reset the driver
5315 TaitoZDoReset();
5316
5317 return 0;
5318 }
5319
DblaxleInit()5320 static INT32 DblaxleInit()
5321 {
5322 INT32 nLen;
5323
5324 TaitoCharModulo = 0x400;
5325 TaitoCharNumPlanes = 4;
5326 TaitoCharWidth = 16;
5327 TaitoCharHeight = 16;
5328 TaitoCharPlaneOffsets = DblaxleCharPlaneOffsets;
5329 TaitoCharXOffsets = DblaxleCharXOffsets;
5330 TaitoCharYOffsets = DblaxleCharYOffsets;
5331 TaitoNumChar = 0x2000;
5332
5333 TaitoSpriteAModulo = 0x200;
5334 TaitoSpriteANumPlanes = 4;
5335 TaitoSpriteAWidth = 16;
5336 TaitoSpriteAHeight = 8;
5337 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5338 TaitoSpriteAXOffsets = SpriteXOffsets;
5339 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5340 TaitoNumSpriteA = 0x10000;
5341
5342 TaitoNum68Ks = 2;
5343 TaitoNumZ80s = 1;
5344 TaitoNumYM2610 = 1;
5345
5346 TaitoLoadRoms(0);
5347
5348 // Allocate and Blank all required memory
5349 TaitoMem = NULL;
5350 MemIndex();
5351 nLen = TaitoMemEnd - (UINT8 *)0;
5352 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5353 memset(TaitoMem, 0, nLen);
5354 MemIndex();
5355
5356 TC0150RODInit(TaitoRoadRomSize, 0);
5357 TC0480SCPInit(TaitoNumChar, 0, 0x21, 8, 4, 0, 0);
5358 TC0140SYTInit(0);
5359 TC0510NIOInit();
5360
5361 if (TaitoLoadRoms(1)) return 1;
5362
5363 #ifdef BUILD_A68K
5364 SwitchToMusashi();
5365 #endif
5366
5367 // Setup the 68000 emulation
5368 SekInit(0, 0x68000);
5369 SekOpen(0);
5370 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5371 SekMapMemory(Taito68KRam1 , 0x200000, 0x203fff, MAP_RAM);
5372 SekMapMemory(TaitoSharedRam , 0x210000, 0x21ffff, MAP_RAM);
5373 SekMapMemory(TaitoPaletteRam , 0x800000, 0x801fff, MAP_RAM);
5374 SekMapMemory(TC0480SCPRam , 0x900000, 0x90ffff, MAP_RAM);
5375 SekMapMemory(TC0480SCPRam , 0xa00000, 0xa0ffff, MAP_RAM);
5376 SekMapMemory(TaitoSpriteRam , 0xc00000, 0xc03fff, MAP_RAM);
5377 SekSetReadWordHandler(0, Dblaxle68K1ReadWord);
5378 SekSetWriteWordHandler(0, Dblaxle68K1WriteWord);
5379 SekSetReadByteHandler(0, Dblaxle68K1ReadByte);
5380 SekSetWriteByteHandler(0, Dblaxle68K1WriteByte);
5381 SekClose();
5382
5383 SekInit(1, 0x68000);
5384 SekOpen(1);
5385 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
5386 SekMapMemory(Taito68KRam2 , 0x100000, 0x103fff, MAP_RAM);
5387 SekMapMemory(TaitoSharedRam , 0x110000, 0x11ffff, MAP_RAM);
5388 SekMapMemory(TC0150RODRam , 0x300000, 0x301fff, MAP_RAM);
5389 SekClose();
5390
5391 TaitoZZ80Init();
5392
5393 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5394 BurnTimerAttachZet(16000000 / 4);
5395 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
5396 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
5397 TaitoZYM2610Route1MasterVol = 8.00;
5398 TaitoZYM2610Route2MasterVol = 8.00;
5399 bYM2610UseSeperateVolumes = 1;
5400
5401 TaitoMakeInputsFunction = DblaxleMakeInputs;
5402 TaitoIrqLine = 4;
5403 TaitoFrameInterleave = 100;
5404
5405 nTaitoCyclesTotal[0] = 16000000 / 60;
5406 nTaitoCyclesTotal[1] = 16000000 / 60;
5407 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5408
5409 GenericTilesInit();
5410
5411 TaitoZSetupShifter();
5412
5413 // Reset the driver
5414 TaitoZDoReset();
5415
5416 return 0;
5417 }
5418
EnforceInit()5419 static INT32 EnforceInit()
5420 {
5421 INT32 nLen;
5422
5423 TaitoCharModulo = 0x100;
5424 TaitoCharNumPlanes = 4;
5425 TaitoCharWidth = 8;
5426 TaitoCharHeight = 8;
5427 TaitoCharPlaneOffsets = CharPlaneOffsets;
5428 TaitoCharXOffsets = CharXOffsets;
5429 TaitoCharYOffsets = CharYOffsets;
5430 TaitoNumChar = 0x4000;
5431
5432 TaitoSpriteAModulo = 0x200;
5433 TaitoSpriteANumPlanes = 4;
5434 TaitoSpriteAWidth = 16;
5435 TaitoSpriteAHeight = 8;
5436 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5437 TaitoSpriteAXOffsets = SpriteXOffsets;
5438 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5439 TaitoNumSpriteA = 0x8000;
5440
5441 TaitoNum68Ks = 2;
5442 TaitoNumZ80s = 1;
5443 TaitoNumYM2610 = 1;
5444
5445 TaitoLoadRoms(0);
5446
5447 // Allocate and Blank all required memory
5448 TaitoMem = NULL;
5449 MemIndex();
5450 nLen = TaitoMemEnd - (UINT8 *)0;
5451 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5452 memset(TaitoMem, 0, nLen);
5453 MemIndex();
5454
5455 GenericTilesInit();
5456
5457 TC0100SCNInit(0, TaitoNumChar, 0, 16, 0, NULL);
5458 TC0110PCRInit(1, 0x1000);
5459 TC0150RODInit(TaitoRoadRomSize, 0);
5460 TC0140SYTInit(0);
5461 TC0220IOCInit();
5462
5463 if (TaitoLoadRoms(1)) return 1;
5464
5465 #ifdef BUILD_A68K
5466 SwitchToMusashi();
5467 #endif
5468
5469 // Setup the 68000 emulation
5470 SekInit(0, 0x68000);
5471 SekOpen(0);
5472 SekMapMemory(Taito68KRom1 , 0x000000, 0x03ffff, MAP_ROM);
5473 SekMapMemory(Taito68KRam1 , 0x100000, 0x103fff, MAP_RAM);
5474 SekMapMemory(TaitoSharedRam , 0x104000, 0x107fff, MAP_RAM);
5475 SekMapMemory(TaitoSpriteRam , 0x300000, 0x3006ff, MAP_RAM);
5476 SekMapMemory(TC0150RODRam , 0x400000, 0x401fff, MAP_RAM);
5477 SekMapMemory(TC0100SCNRam[0] , 0x600000, 0x60ffff, MAP_READ);
5478 SekSetWriteByteHandler(0, Enforce68K1WriteByte);
5479 SekSetReadWordHandler(0, Enforce68K1ReadWord);
5480 SekSetWriteWordHandler(0, Enforce68K1WriteWord);
5481 SekClose();
5482
5483 SekInit(1, 0x68000);
5484 SekOpen(1);
5485 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
5486 SekMapMemory(Taito68KRam2 , 0x100000, 0x103fff, MAP_RAM);
5487 SekMapMemory(TaitoSharedRam , 0x104000, 0x107fff, MAP_RAM);
5488 SekSetReadWordHandler(0, Enforce68K2ReadWord);
5489 SekSetWriteWordHandler(0, Enforce68K2WriteWord);
5490 SekSetReadByteHandler(0, Enforce68K2ReadByte);
5491 SekSetWriteByteHandler(0, Enforce68K2WriteByte);
5492 SekClose();
5493
5494 TaitoZZ80Init();
5495
5496 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5497 BurnTimerAttachZet(16000000 / 4);
5498 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.20);
5499 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.20);
5500 TaitoZYM2610Route1MasterVol = 20.00;
5501 TaitoZYM2610Route2MasterVol = 20.00;
5502 bYM2610UseSeperateVolumes = 1;
5503
5504 TaitoMakeInputsFunction = EnforceMakeInputs;
5505 TaitoIrqLine = 6;
5506 TaitoFrameInterleave = 100;
5507
5508 nTaitoCyclesTotal[0] = 12000000 / 60;
5509 nTaitoCyclesTotal[1] = 12000000 / 60;
5510 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5511
5512 // Reset the driver
5513 TaitoZDoReset();
5514
5515 return 0;
5516 }
5517
NightstrInit()5518 static INT32 NightstrInit()
5519 {
5520 INT32 nLen;
5521
5522 TaitoCharModulo = 0x100;
5523 TaitoCharNumPlanes = 4;
5524 TaitoCharWidth = 8;
5525 TaitoCharHeight = 8;
5526 TaitoCharPlaneOffsets = CharPlaneOffsets;
5527 TaitoCharXOffsets = CharXOffsets;
5528 TaitoCharYOffsets = CharYOffsets;
5529 TaitoNumChar = 0x4000;
5530
5531 TaitoSpriteAModulo = 0x400;
5532 TaitoSpriteANumPlanes = 4;
5533 TaitoSpriteAWidth = 16;
5534 TaitoSpriteAHeight = 16;
5535 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5536 TaitoSpriteAXOffsets = SpriteXOffsets;
5537 TaitoSpriteAYOffsets = SpriteYOffsets;
5538 TaitoNumSpriteA = 0x4000;
5539
5540 TaitoSpriteBModulo = 0x400;
5541 TaitoSpriteBNumPlanes = 4;
5542 TaitoSpriteBWidth = 16;
5543 TaitoSpriteBHeight = 16;
5544 TaitoSpriteBPlaneOffsets = SpritePlaneOffsets;
5545 TaitoSpriteBXOffsets = SpriteXOffsets;
5546 TaitoSpriteBYOffsets = SpriteYOffsets;
5547 TaitoNumSpriteB = 0x4000;
5548
5549 TaitoNum68Ks = 2;
5550 TaitoNumZ80s = 1;
5551 TaitoNumYM2610 = 1;
5552
5553 GenericTilesInit();
5554
5555 TaitoLoadRoms(0);
5556
5557 // Allocate and Blank all required memory
5558 TaitoMem = NULL;
5559 MemIndex();
5560 nLen = TaitoMemEnd - (UINT8 *)0;
5561 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5562 memset(TaitoMem, 0, nLen);
5563 MemIndex();
5564
5565 TC0100SCNInit(0, TaitoNumChar, 0, 8, 0, TaitoPriorityMap);
5566 TC0110PCRInit(1, 0x1000);
5567 TC0150RODInit(TaitoRoadRomSize, 0);
5568 TC0150RODSetPriMap(TaitoPriorityMap);
5569 TC0140SYTInit(0);
5570 TC0220IOCInit();
5571
5572 if (TaitoLoadRoms(1)) return 1;
5573
5574 #ifdef BUILD_A68K
5575 SwitchToMusashi();
5576 #endif
5577
5578 // Setup the 68000 emulation
5579 SekInit(0, 0x68000);
5580 SekOpen(0);
5581 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5582 SekMapMemory(Taito68KRam1 , 0x100000, 0x10ffff, MAP_RAM);
5583 SekMapMemory(TaitoSharedRam , 0x110000, 0x113fff, MAP_RAM);
5584 SekMapMemory(TC0100SCNRam[0] , 0xc00000, 0xc0ffff, MAP_READ);
5585 SekMapMemory(TaitoSpriteRam , 0xd00000, 0xd007ff, MAP_RAM);
5586 SekSetReadWordHandler(0, Nightstr68K1ReadWord);
5587 SekSetWriteWordHandler(0, Nightstr68K1WriteWord);
5588 SekSetReadByteHandler(0, Nightstr68K1ReadByte);
5589 SekSetWriteByteHandler(0, Nightstr68K1WriteByte);
5590 SekClose();
5591
5592 SekInit(1, 0x68000);
5593 SekOpen(1);
5594 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
5595 SekMapMemory(Taito68KRam2 , 0x100000, 0x103fff, MAP_RAM);
5596 SekMapMemory(TaitoSharedRam , 0x104000, 0x107fff, MAP_RAM);
5597 SekMapMemory(TC0150RODRam , 0x800000, 0x801fff, MAP_RAM);
5598 SekClose();
5599
5600 TaitoZZ80Init();
5601
5602 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5603 BurnTimerAttachZet(16000000 / 4);
5604 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.20);
5605 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.20);
5606 TaitoZYM2610Route1MasterVol = 1.00;
5607 TaitoZYM2610Route2MasterVol = 1.00;
5608 bYM2610UseSeperateVolumes = 1;
5609
5610 TaitoMakeInputsFunction = NightstrMakeInputs;
5611 TaitoIrqLine = 4;
5612 TaitoFrameInterleave = 100;
5613
5614 nTaitoCyclesTotal[0] = 12000000 / 60;
5615 nTaitoCyclesTotal[1] = 12000000 / 60;
5616 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5617
5618 // Reset the driver
5619 TaitoZDoReset();
5620
5621 return 0;
5622 }
5623
RacingbInit()5624 static INT32 RacingbInit()
5625 {
5626 INT32 nLen;
5627
5628 Sci = 1;
5629
5630 TaitoCharModulo = 0x400;
5631 TaitoCharNumPlanes = 4;
5632 TaitoCharWidth = 16;
5633 TaitoCharHeight = 16;
5634 TaitoCharPlaneOffsets = DblaxleCharPlaneOffsets;
5635 TaitoCharXOffsets = DblaxleCharXOffsets;
5636 TaitoCharYOffsets = DblaxleCharYOffsets;
5637 TaitoNumChar = 0x2000;
5638
5639 TaitoSpriteAModulo = 0x200;
5640 TaitoSpriteANumPlanes = 4;
5641 TaitoSpriteAWidth = 16;
5642 TaitoSpriteAHeight = 8;
5643 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5644 TaitoSpriteAXOffsets = SpriteXOffsets;
5645 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5646 TaitoNumSpriteA = 0x10000;
5647
5648 TaitoNum68Ks = 2;
5649 TaitoNumZ80s = 1;
5650 TaitoNumYM2610 = 1;
5651
5652 TaitoLoadRoms(0);
5653
5654 // Allocate and Blank all required memory
5655 TaitoMem = NULL;
5656 MemIndex();
5657 nLen = TaitoMemEnd - (UINT8 *)0;
5658 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5659 memset(TaitoMem, 0, nLen);
5660 MemIndex();
5661
5662 TC0150RODInit(TaitoRoadRomSize, 0);
5663 TC0480SCPInit(TaitoNumChar, 0, 0x1f, 8, 4, 0, 0);
5664 TC0140SYTInit(0);
5665 TC0510NIOInit();
5666
5667 if (TaitoLoadRoms(1)) return 1;
5668
5669 #ifdef BUILD_A68K
5670 SwitchToMusashi();
5671 #endif
5672
5673 // Setup the 68000 emulation
5674 SekInit(0, 0x68000);
5675 SekOpen(0);
5676 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5677 SekMapMemory(Taito68KRam1 , 0x100000, 0x103fff, MAP_RAM);
5678 SekMapMemory(TaitoSharedRam , 0x110000, 0x11ffff, MAP_RAM);
5679 SekMapMemory(TaitoPaletteRam , 0x700000, 0x701fff, MAP_RAM);
5680 SekMapMemory(TC0480SCPRam , 0x900000, 0x90ffff, MAP_RAM);
5681 SekMapMemory(TaitoSpriteRam , 0xb00000, 0xb03fff, MAP_RAM);
5682 SekSetReadWordHandler(0, Racingb68K1ReadWord);
5683 SekSetWriteWordHandler(0, Racingb68K1WriteWord);
5684 SekSetReadByteHandler(0, Racingb68K1ReadByte);
5685 SekSetWriteByteHandler(0, Racingb68K1WriteByte);
5686 SekClose();
5687
5688 SekInit(1, 0x68000);
5689 SekOpen(1);
5690 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
5691 SekMapMemory(Taito68KRam2 , 0x400000, 0x403fff, MAP_RAM);
5692 SekMapMemory(TaitoSharedRam , 0x410000, 0x41ffff, MAP_RAM);
5693 SekMapMemory(TC0150RODRam , 0xa00000, 0xa01fff, MAP_RAM);
5694 SekClose();
5695
5696 TaitoZZ80Init();
5697
5698 BurnYM2610Init(32000000 / 4, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5699 BurnTimerAttachZet(32000000 / 8);
5700 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
5701 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
5702 TaitoZYM2610Route1MasterVol = 8.00;
5703 TaitoZYM2610Route2MasterVol = 8.00;
5704 bYM2610UseSeperateVolumes = 1;
5705
5706 TaitoMakeInputsFunction = DblaxleMakeInputs;
5707 TaitoIrqLine = 4;
5708 TaitoFrameInterleave = 100;
5709
5710 nTaitoCyclesTotal[0] = 16000000 / 60;
5711 nTaitoCyclesTotal[1] = 16000000 / 60;
5712 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5713
5714 GenericTilesInit();
5715
5716 TaitoZSetupShifter();
5717
5718 // Reset the driver
5719 TaitoZDoReset();
5720
5721 return 0;
5722 }
5723
SciInit()5724 static INT32 SciInit()
5725 {
5726 INT32 nLen;
5727
5728 Sci = 1;
5729
5730 TaitoCharModulo = 0x100;
5731 TaitoCharNumPlanes = 4;
5732 TaitoCharWidth = 8;
5733 TaitoCharHeight = 8;
5734 TaitoCharPlaneOffsets = CharPlaneOffsets;
5735 TaitoCharXOffsets = CharXOffsets;
5736 TaitoCharYOffsets = CharYOffsets;
5737 TaitoNumChar = 0x4000;
5738
5739 TaitoSpriteAModulo = 0x200;
5740 TaitoSpriteANumPlanes = 4;
5741 TaitoSpriteAWidth = 16;
5742 TaitoSpriteAHeight = 8;
5743 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5744 TaitoSpriteAXOffsets = SpriteXOffsets;
5745 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5746 TaitoNumSpriteA = 0x8000;
5747
5748 TaitoNum68Ks = 2;
5749 TaitoNumZ80s = 1;
5750 TaitoNumYM2610 = 1;
5751
5752 GenericTilesInit();
5753
5754 TaitoLoadRoms(0);
5755
5756 // Allocate and Blank all required memory
5757 TaitoMem = NULL;
5758 MemIndex();
5759 nLen = TaitoMemEnd - (UINT8 *)0;
5760 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5761 memset(TaitoMem, 0, nLen);
5762 MemIndex();
5763
5764 TC0100SCNInit(0, TaitoNumChar, 0, 8, 0, TaitoPriorityMap);
5765 TC0150RODInit(TaitoRoadRomSize, 0);
5766 TC0150RODSetPriMap(TaitoPriorityMap);
5767 TC0140SYTInit(0);
5768 TC0220IOCInit();
5769
5770 if (TaitoLoadRoms(1)) return 1;
5771
5772 #ifdef BUILD_A68K
5773 SwitchToMusashi();
5774 #endif
5775
5776 // Setup the 68000 emulation
5777 SekInit(0, 0x68000);
5778 SekOpen(0);
5779 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5780 SekMapMemory(Taito68KRam1 , 0x100000, 0x107fff, MAP_RAM);
5781 SekMapMemory(TaitoSharedRam , 0x108000, 0x10bfff, MAP_RAM);
5782 SekMapMemory(TaitoPaletteRam , 0x800000, 0x801fff, MAP_RAM);
5783 SekMapMemory(TC0100SCNRam[0] , 0xa00000, 0xa0ffff, MAP_READ);
5784 SekMapMemory(TaitoSpriteRam , 0xc00000, 0xc03fff, MAP_RAM);
5785 SekSetWriteWordHandler(0, Sci68K1WriteWord);
5786 SekSetReadByteHandler(0, Sci68K1ReadByte);
5787 SekSetWriteByteHandler(0, Sci68K1WriteByte);
5788 SekClose();
5789
5790 SekInit(1, 0x68000);
5791 SekOpen(1);
5792 SekMapMemory(Taito68KRom2 , 0x000000, 0x01ffff, MAP_ROM);
5793 SekMapMemory(Taito68KRam2 , 0x200000, 0x203fff, MAP_RAM);
5794 SekMapMemory(TaitoSharedRam , 0x208000, 0x20bfff, MAP_RAM);
5795 SekMapMemory(TC0150RODRam , 0xa00000, 0xa01fff, MAP_RAM);
5796 SekClose();
5797
5798 TaitoZZ80Init();
5799
5800 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, &TaitoZFMIRQHandler, 0);
5801 BurnTimerAttachZet(16000000 / 4);
5802 BurnYM2610SetLeftVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
5803 BurnYM2610SetRightVolume(BURN_SND_YM2610_AY8910_ROUTE, 0.25);
5804 TaitoZYM2610Route1MasterVol = 1.00;
5805 TaitoZYM2610Route2MasterVol = 1.00;
5806 bYM2610UseSeperateVolumes = 1;
5807
5808 TaitoMakeInputsFunction = SciMakeInputs;
5809 TaitoIrqLine = 4;
5810 TaitoFrameInterleave = 100;
5811
5812 nTaitoCyclesTotal[0] = 12000000 / 60;
5813 nTaitoCyclesTotal[1] = 12000000 / 60;
5814 nTaitoCyclesTotal[2] = (16000000 / 4) / 60;
5815
5816 TaitoZSetupShifter();
5817
5818 // Reset the driver
5819 TaitoZDoReset();
5820
5821 return 0;
5822 }
5823
SpacegunInit()5824 static INT32 SpacegunInit()
5825 {
5826 INT32 nLen;
5827
5828 TaitoCharModulo = 0x100;
5829 TaitoCharNumPlanes = 4;
5830 TaitoCharWidth = 8;
5831 TaitoCharHeight = 8;
5832 TaitoCharPlaneOffsets = CharPlaneOffsets;
5833 TaitoCharXOffsets = CharXOffsets;
5834 TaitoCharYOffsets = CharYOffsets;
5835 TaitoNumChar = 0x4000;
5836
5837 TaitoSpriteAModulo = 0x200;
5838 TaitoSpriteANumPlanes = 4;
5839 TaitoSpriteAWidth = 16;
5840 TaitoSpriteAHeight = 8;
5841 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
5842 TaitoSpriteAXOffsets = SpriteXOffsets;
5843 TaitoSpriteAYOffsets = Sprite16x8YOffsets;
5844 TaitoNumSpriteA = 0x10000;
5845
5846 TaitoNum68Ks = 2;
5847 TaitoNumYM2610 = 1;
5848
5849 TaitoLoadRoms(0);
5850
5851 // Allocate and Blank all required memory
5852 TaitoMem = NULL;
5853 MemIndex();
5854 nLen = TaitoMemEnd - (UINT8 *)0;
5855 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
5856 memset(TaitoMem, 0, nLen);
5857 MemIndex();
5858
5859 GenericTilesInit();
5860
5861 TC0100SCNInit(0, TaitoNumChar, 4, 8, 1, NULL);
5862 TC0110PCRInit(1, 0x1000);
5863 TC0220IOCInit();
5864
5865 if (TaitoLoadRoms(1)) return 1;
5866
5867 #ifdef BUILD_A68K
5868 SwitchToMusashi();
5869 #endif
5870
5871 // Setup the 68000 emulation
5872 SekInit(0, 0x68000);
5873 SekOpen(0);
5874 SekMapMemory(Taito68KRom1 , 0x000000, 0x07ffff, MAP_ROM);
5875 SekMapMemory(Taito68KRam1 , 0x30c000, 0x30ffff, MAP_RAM);
5876 SekMapMemory(TaitoSharedRam , 0x310000, 0x31ffff, MAP_RAM);
5877 SekMapMemory(TaitoSpriteRam , 0x500000, 0x5005ff, MAP_RAM);
5878 SekMapMemory(TC0100SCNRam[0] , 0x900000, 0x90ffff, MAP_READ);
5879 SekSetReadWordHandler(0, Spacegun68K1ReadWord);
5880 SekSetWriteWordHandler(0, Spacegun68K1WriteWord);
5881 SekSetWriteByteHandler(0, Spacegun68K1WriteByte);
5882 SekClose();
5883
5884 SekInit(1, 0x68000);
5885 SekOpen(1);
5886 SekMapMemory(Taito68KRom2 , 0x000000, 0x03ffff, MAP_ROM);
5887 SekMapMemory(Taito68KRam2 , 0x20c000, 0x20ffff, MAP_RAM);
5888 SekMapMemory(TaitoSharedRam , 0x210000, 0x21ffff, MAP_RAM);
5889 SekSetReadWordHandler(0, Spacegun68K2ReadWord);
5890 SekSetWriteWordHandler(0, Spacegun68K2WriteWord);
5891 SekSetReadByteHandler(0, Spacegun68K2ReadByte);
5892 SekSetWriteByteHandler(0, Spacegun68K2WriteByte);
5893 SekClose();
5894
5895 BurnYM2610Init(16000000 / 2, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, NULL, 0);
5896 BurnTimerAttachSek(16000000);
5897 BurnYM2610SetRoute(BURN_SND_YM2610_YM2610_ROUTE_1, 1.00, BURN_SND_ROUTE_BOTH);
5898 BurnYM2610SetRoute(BURN_SND_YM2610_YM2610_ROUTE_2, 1.00, BURN_SND_ROUTE_BOTH);
5899 BurnYM2610SetRoute(BURN_SND_YM2610_AY8910_ROUTE, 0.25, BURN_SND_ROUTE_BOTH);
5900
5901 EEPROMInit(&spacegun_eeprom_intf);
5902 if (!EEPROMAvailable()) EEPROMFill(spacegun_default_eeprom, 0, 128);
5903
5904 TaitoMakeInputsFunction = SpacegunMakeInputs;
5905 TaitoIrqLine = 4;
5906 TaitoFrameInterleave = 100;
5907 TaitoFlipScreenX = 1;
5908 TaitoNumEEPROM = 1;
5909
5910 nTaitoCyclesTotal[0] = 16000000 / 60;
5911 nTaitoCyclesTotal[1] = 16000000 / 60;
5912
5913 BurnGunInit(2, true);
5914 bUseGun = 1;
5915
5916 // Reset the driver
5917 TaitoZDoReset();
5918
5919 return 0;
5920 }
5921
TaitoZExit()5922 static INT32 TaitoZExit()
5923 {
5924 TaitoExit();
5925
5926 SciSpriteFrame = 0;
5927 Sci = 0;
5928 TaitoZINT6timer = 0;
5929
5930 //if (bUseGun)
5931 // BurnGunExit(); // exit's in TaitoExit() above!
5932 bUseGun = 0;
5933
5934 if (bUseShifter)
5935 BurnShiftExit();
5936 bUseShifter = 0;
5937
5938 #ifdef BUILD_A68K
5939 // Switch back CPU core if needed
5940 if (bUseAsm68KCoreOldValue) {
5941 #if 1 && defined FBNEO_DEBUG
5942 bprintf(PRINT_NORMAL, _T("Switching back to A68K core\n"));
5943 #endif
5944 bUseAsm68KCoreOldValue = false;
5945 bBurnUseASMCPUEmulation = true;
5946 }
5947 #endif
5948
5949 return 0;
5950 }
5951
pal5bit(UINT8 bits)5952 static inline UINT8 pal5bit(UINT8 bits)
5953 {
5954 bits &= 0x1f;
5955 return (bits << 3) | (bits >> 2);
5956 }
5957
CalcCol(UINT16 nColour)5958 inline static UINT32 CalcCol(UINT16 nColour)
5959 {
5960 INT32 r, g, b;
5961
5962 r = pal5bit(BURN_ENDIAN_SWAP_INT16(nColour) >> 0);
5963 g = pal5bit(BURN_ENDIAN_SWAP_INT16(nColour) >> 5);
5964 b = pal5bit(BURN_ENDIAN_SWAP_INT16(nColour) >> 10);
5965
5966 return BurnHighCol(r, g, b, 0);
5967 }
5968
TaitoZCalcPalette()5969 static void TaitoZCalcPalette()
5970 {
5971 INT32 i;
5972 UINT16* ps;
5973 UINT32* pd;
5974
5975 for (i = 0, ps = (UINT16*)TaitoPaletteRam, pd = TaitoPalette; i < 0x1000; i++, ps++, pd++) {
5976 *pd = CalcCol(*ps);
5977 }
5978 }
5979
RenderSpriteZoom(INT32 Code,INT32 sx,INT32 sy,INT32 Colour,INT32 xFlip,INT32 yFlip,INT32 xScale,INT32 yScale,UINT8 * pSource)5980 static void RenderSpriteZoom(INT32 Code, INT32 sx, INT32 sy, INT32 Colour, INT32 xFlip, INT32 yFlip, INT32 xScale, INT32 yScale, UINT8* pSource)
5981 {
5982 // We can use sprite A for sizes, etc. as only Chase HQ uses sprite B and it has the same sizes and count
5983
5984 UINT8 *SourceBase = pSource + ((Code % TaitoNumSpriteA) * TaitoSpriteAWidth * TaitoSpriteAHeight);
5985
5986 INT32 SpriteScreenHeight = (yScale * TaitoSpriteAHeight + 0x8000) >> 16;
5987 INT32 SpriteScreenWidth = (xScale * TaitoSpriteAWidth + 0x8000) >> 16;
5988
5989 Colour = 0x10 * (Colour % 0x100);
5990
5991 if (TaitoFlipScreenX) {
5992 xFlip = !xFlip;
5993 sx = 320 - sx - (xScale >> 12);
5994 }
5995
5996 if (SpriteScreenWidth && SpriteScreenHeight) {
5997 INT32 dx = (TaitoSpriteAWidth << 16) / SpriteScreenWidth;
5998 INT32 dy = (TaitoSpriteAHeight << 16) / SpriteScreenHeight;
5999
6000 INT32 ex = sx + SpriteScreenWidth;
6001 INT32 ey = sy + SpriteScreenHeight;
6002
6003 INT32 xIndexBase;
6004 INT32 yIndex;
6005
6006 if (xFlip) {
6007 xIndexBase = (SpriteScreenWidth - 1) * dx;
6008 dx = -dx;
6009 } else {
6010 xIndexBase = 0;
6011 }
6012
6013 if (yFlip) {
6014 yIndex = (SpriteScreenHeight - 1) * dy;
6015 dy = -dy;
6016 } else {
6017 yIndex = 0;
6018 }
6019
6020 if (sx < 0) {
6021 INT32 Pixels = 0 - sx;
6022 sx += Pixels;
6023 xIndexBase += Pixels * dx;
6024 }
6025
6026 if (sy < 0) {
6027 INT32 Pixels = 0 - sy;
6028 sy += Pixels;
6029 yIndex += Pixels * dy;
6030 }
6031
6032 if (ex > nScreenWidth) {
6033 INT32 Pixels = ex - nScreenWidth;
6034 ex -= Pixels;
6035 }
6036
6037 if (ey > nScreenHeight) {
6038 INT32 Pixels = ey - nScreenHeight;
6039 ey -= Pixels;
6040 }
6041
6042 if (ex > sx) {
6043 INT32 y;
6044
6045 for (y = sy; y < ey; y++) {
6046 UINT8 *Source = SourceBase + ((yIndex >> 16) * TaitoSpriteAWidth);
6047 UINT16* pPixel = pTransDraw + (y * nScreenWidth);
6048
6049 INT32 x, xIndex = xIndexBase;
6050 for (x = sx; x < ex; x++) {
6051 INT32 c = Source[xIndex >> 16];
6052 if (c != 0) {
6053 pPixel[x] = c | Colour;
6054 }
6055 xIndex += dx;
6056 }
6057
6058 yIndex += dy;
6059 }
6060 }
6061 }
6062 }
6063
RenderSpriteZoomPri(INT32 Code,INT32 sx,INT32 sy,INT32 Colour,INT32 xFlip,INT32 yFlip,INT32 xScale,INT32 yScale,UINT8 * pSource,INT32 Priority)6064 static void RenderSpriteZoomPri(INT32 Code, INT32 sx, INT32 sy, INT32 Colour, INT32 xFlip, INT32 yFlip, INT32 xScale, INT32 yScale, UINT8* pSource, INT32 Priority)
6065 {
6066 // We can use sprite A for sizes, etc. as only Chase HQ uses sprite B and it has the same sizes and count
6067
6068 UINT8 *SourceBase = pSource + ((Code % TaitoNumSpriteA) * TaitoSpriteAWidth * TaitoSpriteAHeight);
6069
6070 INT32 SpriteScreenHeight = (yScale * TaitoSpriteAHeight + 0x8000) >> 16;
6071 INT32 SpriteScreenWidth = (xScale * TaitoSpriteAWidth + 0x8000) >> 16;
6072
6073 Colour = 0x10 * (Colour % 0x100);
6074
6075 Priority |= 1 << 31;
6076
6077 if (TaitoFlipScreenX) {
6078 xFlip = !xFlip;
6079 sx = 320 - sx - (xScale >> 12);
6080 }
6081
6082 if (SpriteScreenWidth && SpriteScreenHeight) {
6083 INT32 dx = (TaitoSpriteAWidth << 16) / SpriteScreenWidth;
6084 INT32 dy = (TaitoSpriteAHeight << 16) / SpriteScreenHeight;
6085
6086 INT32 ex = sx + SpriteScreenWidth;
6087 INT32 ey = sy + SpriteScreenHeight;
6088
6089 INT32 xIndexBase;
6090 INT32 yIndex;
6091
6092 if (xFlip) {
6093 xIndexBase = (SpriteScreenWidth - 1) * dx;
6094 dx = -dx;
6095 } else {
6096 xIndexBase = 0;
6097 }
6098
6099 if (yFlip) {
6100 yIndex = (SpriteScreenHeight - 1) * dy;
6101 dy = -dy;
6102 } else {
6103 yIndex = 0;
6104 }
6105
6106 if (sx < 0) {
6107 INT32 Pixels = 0 - sx;
6108 sx += Pixels;
6109 xIndexBase += Pixels * dx;
6110 }
6111
6112 if (sy < 0) {
6113 INT32 Pixels = 0 - sy;
6114 sy += Pixels;
6115 yIndex += Pixels * dy;
6116 }
6117
6118 if (ex > nScreenWidth) {
6119 INT32 Pixels = ex - nScreenWidth;
6120 ex -= Pixels;
6121 }
6122
6123 if (ey > nScreenHeight) {
6124 INT32 Pixels = ey - nScreenHeight;
6125 ey -= Pixels;
6126 }
6127
6128 if (ex > sx) {
6129 INT32 y;
6130
6131 for (y = sy; y < ey; y++) {
6132 UINT8 *Source = SourceBase + ((yIndex >> 16) * TaitoSpriteAWidth);
6133 UINT16* pPixel = pTransDraw + (y * nScreenWidth);
6134 UINT8 *pPri = TaitoPriorityMap + (y * nScreenWidth);
6135
6136 INT32 x, xIndex = xIndexBase;
6137 for (x = sx; x < ex; x++) {
6138 INT32 c = Source[xIndex >> 16];
6139 if (c != 0) {
6140 if ((Priority & (1 << pPri[x])) == 0) {
6141 pPixel[x] = c | Colour;
6142 }
6143 pPri[x] = 0x1f;
6144 }
6145 xIndex += dx;
6146 }
6147
6148 yIndex += dy;
6149 }
6150 }
6151 }
6152 }
6153
AquajackRenderSprites(INT32 PriorityDraw)6154 static void AquajackRenderSprites(INT32 PriorityDraw)
6155 {
6156 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6157 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6158 INT32 Offset, Data, Tile, Colour, xFlip, yFlip;
6159 INT32 x, y, Priority, xCur, yCur;
6160 INT32 xZoom, yZoom, zx, zy;
6161 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6162
6163 for (Offset = 0x200 - 4; Offset >= 0; Offset -= 4) {
6164 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6165 Priority = (Data & 0x8000) >> 15;
6166
6167 if (Priority != 0 && Priority != 1) bprintf(PRINT_NORMAL, _T("Unused Priority %x\n"), Priority);
6168 if (Priority != PriorityDraw) continue;
6169
6170 xFlip = (Data & 0x4000) >> 14;
6171 x = Data & 0x1ff;
6172
6173 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6174 yFlip = (Data & 0x8000) >> 15;
6175 Tile = Data & 0x1fff;
6176 if (!Tile) continue;
6177
6178 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6179 yZoom = (Data & 0x7e00) >> 9;
6180 y = Data & 0x1ff;
6181
6182 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6183 Colour = (Data & 0xff00) >> 8;
6184 xZoom = (Data & 0x3f);
6185
6186 MapOffset = Tile << 5;
6187
6188 xZoom += 1;
6189 yZoom += 1;
6190
6191 y += 3;
6192
6193 if (x > 0x140) x -= 0x200;
6194 if (y > 0x140) y -= 0x200;
6195
6196 for (SpriteChunk = 0; SpriteChunk < 32; SpriteChunk++) {
6197 k = SpriteChunk % 4;
6198 j = SpriteChunk / 4;
6199
6200 px = xFlip ? (3 - k) : k;
6201 py = yFlip ? (7 - j) : j;
6202
6203 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 2)]);
6204 Code &= (TaitoNumSpriteA - 1);
6205
6206 xCur = x + ((k * xZoom) / 4);
6207 yCur = y + ((j * yZoom) / 8);
6208
6209 zx = x + (((k + 1) * xZoom) / 4) - xCur;
6210 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6211
6212 yCur -= 16;
6213
6214 RenderSpriteZoom(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 13, TaitoSpritesA);
6215 }
6216
6217
6218 }
6219 }
6220
BsharkRenderSprites(INT32 PriorityDraw,INT32 yOffset,INT32 SpriteRamSize)6221 static void BsharkRenderSprites(INT32 PriorityDraw, INT32 yOffset, INT32 SpriteRamSize)
6222 {
6223 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6224 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6225 INT32 Offset, Data, Tile, Colour, xFlip, yFlip;
6226 INT32 x, y, Priority, xCur, yCur;
6227 INT32 xZoom, yZoom, zx, zy;
6228 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6229
6230 for (Offset = 0; Offset < SpriteRamSize - 4; Offset += 4) {
6231 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6232 Priority = (Data & 0x8000) >> 15;
6233
6234 if (Priority != 0 && Priority != 1) bprintf(PRINT_NORMAL, _T("Unused Priority %x\n"), Priority);
6235 if (Priority != PriorityDraw) continue;
6236
6237 Colour = (Data & 0x7f80) >> 7;
6238 xZoom = (Data & 0x3f);
6239
6240 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6241 Tile = Data & 0x1fff;
6242 if (!Tile) continue;
6243
6244 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6245 yZoom = (Data & 0x7e00) >> 9;
6246 y = Data & 0x1ff;
6247
6248 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6249 yFlip = (Data & 0x8000) >> 15;
6250 xFlip = (Data & 0x4000) >> 14;
6251 x = Data & 0x1ff;
6252
6253 MapOffset = Tile << 5;
6254
6255 xZoom += 1;
6256 yZoom += 1;
6257
6258 y += yOffset;
6259 y += (64 - yZoom);
6260
6261 if (x > 0x140) x -= 0x200;
6262 if (y > 0x140) y -= 0x200;
6263
6264 for (SpriteChunk = 0; SpriteChunk < 32; SpriteChunk++) {
6265 k = SpriteChunk % 4;
6266 j = SpriteChunk / 4;
6267
6268 px = xFlip ? (3 - k) : k;
6269 py = yFlip ? (7 - j) : j;
6270
6271 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 2)]);
6272 Code &= (TaitoNumSpriteA - 1);
6273
6274 xCur = x + ((k * xZoom) / 4);
6275 yCur = y + ((j * yZoom) / 8);
6276
6277 zx = x + (((k + 1) * xZoom) / 4) - xCur;
6278 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6279
6280 yCur -= 16;
6281
6282 RenderSpriteZoom(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 13, TaitoSpritesA);
6283 }
6284
6285 }
6286 }
6287
ChasehqRenderSprites()6288 static void ChasehqRenderSprites()
6289 {
6290 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6291 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6292 INT32 Offset, Data, Tile, Colour, xFlip, yFlip;
6293 INT32 x, y, Priority, xCur, yCur;
6294 INT32 xZoom, yZoom, zx, zy;
6295 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6296 const INT32 primasks[2] = { 0xf0, 0xfc };
6297
6298 for (Offset = 0x400-4; Offset >= 0; Offset -= 4) {
6299 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6300 Priority = (Data & 0x8000) >> 15;
6301
6302 Colour = (Data & 0x7f80) >> 7;
6303 xZoom = (Data & 0x7f);
6304
6305 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6306 Tile = Data & 0x7ff;
6307 if (!Tile) continue;
6308
6309 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6310 yZoom = (Data & 0xfe00) >> 9;
6311 y = Data & 0x1ff;
6312
6313 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6314 yFlip = (Data & 0x8000) >> 15;
6315 xFlip = (Data & 0x4000) >> 14;
6316 x = Data & 0x1ff;
6317
6318 xZoom += 1;
6319 yZoom += 1;
6320
6321 y += 7;
6322 y += (128 - yZoom);
6323
6324 if (x > 0x140) x -= 0x200;
6325 if (y > 0x140) y -= 0x200;
6326
6327 if ((xZoom - 1) & 0x40) {
6328 MapOffset = Tile << 6;
6329
6330 for (SpriteChunk = 0; SpriteChunk < 64; SpriteChunk++) {
6331 j = SpriteChunk / 8;
6332 k = SpriteChunk % 8;
6333
6334 px = xFlip ? (7 - k) : k;
6335 py = yFlip ? (7 - j) : j;
6336
6337 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 3)]);
6338 Code &= (TaitoNumSpriteA - 1);
6339
6340 xCur = x + ((k * xZoom) / 8);
6341 yCur = y + ((j * yZoom) / 8);
6342
6343 zx = x + (((k + 1) * xZoom) / 8) - xCur;
6344 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6345
6346 yCur -= 16;
6347
6348 RenderSpriteZoomPri(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 12, TaitoSpritesA, primasks[Priority]);
6349 }
6350 } else if ((xZoom - 1) & 0x20) {
6351 MapOffset = (Tile << 5) + 0x20000;
6352
6353 for (SpriteChunk = 0; SpriteChunk < 32; SpriteChunk++) {
6354 j = SpriteChunk / 4;
6355 k = SpriteChunk % 4;
6356
6357 px = xFlip ? (3 - k) : k;
6358 py = yFlip ? (7 - j) : j;
6359
6360 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 2)]);
6361 Code &= (TaitoNumSpriteB - 1);
6362
6363 xCur = x + ((k * xZoom) / 4);
6364 yCur = y + ((j * yZoom) / 8);
6365
6366 zx = x + (((k + 1) * xZoom) / 4) - xCur;
6367 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6368
6369 yCur -= 16;
6370
6371 RenderSpriteZoomPri(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 12, TaitoSpritesB, primasks[Priority]);
6372 }
6373 } else if (!((xZoom - 1) & 0x60)) {
6374 MapOffset = (Tile << 4) + 0x30000;
6375
6376 for (SpriteChunk = 0; SpriteChunk < 16; SpriteChunk++) {
6377 j = SpriteChunk / 2;
6378 k = SpriteChunk % 2;
6379
6380 px = xFlip ? (1 - k) : k;
6381 py = yFlip ? (7 - j) : j;
6382
6383 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 1)]);
6384 Code &= (TaitoNumSpriteB - 1);
6385
6386 xCur = x + ((k * xZoom) / 2);
6387 yCur = y + ((j * yZoom) / 8);
6388
6389 zx = x + (((k + 1) * xZoom) / 2) - xCur;
6390 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6391
6392 yCur -= 16;
6393
6394 RenderSpriteZoomPri(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 12, TaitoSpritesB, primasks[Priority]);
6395 }
6396 }
6397 }
6398 }
6399
ContcircRenderSprites(INT32 PriorityDraw,INT32 VisibleYOffset)6400 static void ContcircRenderSprites(INT32 PriorityDraw, INT32 VisibleYOffset)
6401 {
6402 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6403 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6404 INT32 Offset, Data, Tile, Colour, xFlip, yFlip;
6405 INT32 x, y, Priority, xCur, yCur;
6406 INT32 xZoom, yZoom, zx, zy;
6407 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6408
6409 for (Offset = 0x380 - 4; Offset >= 0; Offset -= 4) {
6410 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6411 Priority = (Data & 0x8000) >> 15;
6412
6413 if (Priority != 0 && Priority != 1) bprintf(PRINT_NORMAL, _T("Unused Priority %x\n"), Priority);
6414 if (Priority != PriorityDraw) continue;
6415
6416 xFlip = (Data & 0x4000) >> 14;
6417 yFlip = (Data & 0x2000) >> 13;
6418 x = Data & 0x1ff;
6419
6420 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6421 Tile = Data & 0x7ff;
6422 if (!Tile) continue;
6423
6424 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6425 yZoom = (Data & 0xfe00) >> 9;
6426 y = Data & 0x1ff;
6427
6428 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6429 Colour = (Data & 0xff00) >> 8;
6430 xZoom = (Data & 0x7f);
6431
6432 MapOffset = Tile << 7;
6433
6434 xZoom += 1;
6435 yZoom += 1;
6436
6437 y += 5;
6438 y += ( 128 - yZoom);
6439
6440 if (x > 0x140) x -= 0x200;
6441 if (y > 0x140) y -= 0x200;
6442
6443 for (SpriteChunk = 0; SpriteChunk < 128; SpriteChunk++) {
6444 k = SpriteChunk % 8;
6445 j = SpriteChunk / 8;
6446
6447 px = xFlip ? (7 - k) : k;
6448 py = yFlip ? (15 - j) : j;
6449
6450 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 3)]);
6451 Code &= (TaitoNumSpriteA - 1);
6452
6453 xCur = x + ((k * xZoom) / 8);
6454 yCur = y + ((j * yZoom) / 16);
6455
6456 zx = x + (((k + 1) * xZoom) / 8) - xCur;
6457 zy = y + (((j + 1) * yZoom) / 16) - yCur;
6458
6459 yCur -= VisibleYOffset;
6460
6461 RenderSpriteZoom(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 13, TaitoSpritesA);
6462 }
6463 }
6464 }
6465
SciRenderSprites(INT32 PriorityDraw,INT32 yOffs)6466 static void SciRenderSprites(INT32 PriorityDraw, INT32 yOffs)
6467 {
6468 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6469 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6470 INT32 Offset, StartOffs, Data, Tile, Colour, xFlip, yFlip;
6471 INT32 x, y, Priority, xCur, yCur;
6472 INT32 xZoom, yZoom, zx, zy;
6473 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6474
6475 StartOffs = (SciSpriteFrame & 1) ? 0x800 : 0;
6476
6477 for (Offset = StartOffs; Offset < StartOffs + 0x800; Offset += 4) {
6478 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6479 Priority = (Data & 0x8000) >> 15;
6480
6481 if (Priority != 0 && Priority != 1) bprintf(PRINT_NORMAL, _T("Unused Priority %x\n"), Priority);
6482 if (Priority != PriorityDraw) continue;
6483
6484 Colour = (Data & 0x7f80) >> 7;
6485 xZoom = (Data & 0x3f);
6486
6487 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6488 Tile = Data & 0x1fff;
6489 if (!Tile) continue;
6490
6491 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6492 yZoom = (Data & 0x7e00) >> 9;
6493 y = Data & 0x1ff;
6494
6495 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6496 yFlip = (Data & 0x8000) >> 15;
6497 xFlip = (Data & 0x4000) >> 14;
6498 x = Data & 0x1ff;
6499
6500 MapOffset = Tile << 5;
6501
6502 xZoom += 1;
6503 yZoom += 1;
6504
6505 y += yOffs;
6506 y += (64 - yZoom);
6507
6508 if (x > 0x140) x -= 0x200;
6509 if (y > 0x140) y -= 0x200;
6510
6511 for (SpriteChunk = 0; SpriteChunk < 32; SpriteChunk++) {
6512 k = SpriteChunk % 4;
6513 j = SpriteChunk / 4;
6514
6515 px = xFlip ? (3-k) : k;
6516 py = yFlip ? (7-j) : j;
6517
6518 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 2)]);
6519 Code &= (TaitoNumSpriteA - 1);
6520
6521 xCur = x + ((k * xZoom) / 4);
6522 yCur = y + ((j * yZoom) / 8);
6523
6524 zx = x + (((k + 1) * xZoom) / 4) - xCur;
6525 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6526
6527 yCur -= 16;
6528
6529 RenderSpriteZoom(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 13, TaitoSpritesA);
6530 }
6531 }
6532 }
6533
SciRenderSpritesPrio(INT32 yOffs)6534 static void SciRenderSpritesPrio(INT32 yOffs)
6535 {
6536 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6537 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6538 INT32 Offset, StartOffs, Data, Tile, Colour, xFlip, yFlip;
6539 INT32 x, y, Priority, xCur, yCur;
6540 INT32 xZoom, yZoom, zx, zy;
6541 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6542 const INT32 primasks[2] = { 0xf0, 0xfc };
6543
6544 StartOffs = (SciSpriteFrame & 1) ? 0x800 : 0;
6545 //StartOffs = 0x800 - StartOffs;
6546
6547 for (Offset = (StartOffs + 0x800 - 4); Offset >= StartOffs; Offset -= 4) {
6548 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6549 Priority = (Data & 0x8000) >> 15;
6550
6551 Colour = (Data & 0x7f80) >> 7;
6552 xZoom = (Data & 0x3f);
6553
6554 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6555 Tile = Data & 0x1fff;
6556 if (!Tile) continue;
6557
6558 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6559 yZoom = (Data & 0x7e00) >> 9;
6560 y = Data & 0x1ff;
6561
6562 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6563 yFlip = (Data & 0x8000) >> 15;
6564 xFlip = (Data & 0x4000) >> 14;
6565 x = Data & 0x1ff;
6566
6567 MapOffset = Tile << 5;
6568
6569 xZoom += 1;
6570 yZoom += 1;
6571
6572 y += yOffs;
6573 y += (64 - yZoom);
6574
6575 if (x > 0x140) x -= 0x200;
6576 if (y > 0x140) y -= 0x200;
6577
6578 for (SpriteChunk = 0; SpriteChunk < 32; SpriteChunk++) {
6579 k = SpriteChunk % 4;
6580 j = SpriteChunk / 4;
6581
6582 px = xFlip ? (3-k) : k;
6583 py = yFlip ? (7-j) : j;
6584
6585 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 2)]);
6586 Code &= (TaitoNumSpriteA - 1);
6587
6588 xCur = x + ((k * xZoom) / 4);
6589 yCur = y + ((j * yZoom) / 8);
6590
6591 zx = x + (((k + 1) * xZoom) / 4) - xCur;
6592 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6593
6594 yCur -= 16;
6595
6596 RenderSpriteZoomPri(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 13, TaitoSpritesA, primasks[Priority]);
6597 }
6598 }
6599 }
6600
SpacegunRenderSprites(INT32 PriorityDraw)6601 static void SpacegunRenderSprites(INT32 PriorityDraw)
6602 {
6603 UINT16 *SpriteMap = (UINT16*)TaitoSpriteMapRom;
6604 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
6605 INT32 Offset, Data, Tile, Colour, xFlip, yFlip;
6606 INT32 x, y, Priority, xCur, yCur;
6607 INT32 xZoom, yZoom, zx, zy;
6608 INT32 SpriteChunk, MapOffset, Code, j, k, px, py;
6609
6610 for (Offset = 0x300 - 4; Offset >= 0; Offset -= 4) {
6611 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 1]);
6612 Priority = (Data & 0x8000) >> 15;
6613
6614 if (Priority != 0 && Priority != 1) bprintf(PRINT_NORMAL, _T("Unused Priority %x\n"), Priority);
6615 if (Priority != PriorityDraw) continue;
6616
6617 xFlip = (Data & 0x4000) >> 14;
6618 x = Data & 0x1ff;
6619
6620 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 3]);
6621 yFlip = (Data & 0x8000) >> 15;
6622 Tile = Data & 0x1fff;
6623 if (!Tile) continue;
6624
6625 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 0]);
6626 yZoom = (Data & 0xfe00) >> 9;
6627 y = Data & 0x1ff;
6628
6629 Data = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset + 2]);
6630 Colour = (Data & 0xff00) >> 8;
6631 xZoom = (Data & 0x7f);
6632
6633 MapOffset = Tile << 5;
6634
6635 xZoom += 1;
6636 yZoom += 1;
6637
6638 y += 4;
6639
6640 if (x > 0x140) x -= 0x200;
6641 if (y > 0x140) y -= 0x200;
6642
6643 for (SpriteChunk = 0; SpriteChunk < 32; SpriteChunk++) {
6644 k = SpriteChunk % 4;
6645 j = SpriteChunk / 4;
6646
6647 px = xFlip ? (3 - k) : k;
6648 py = yFlip ? (7 - j) : j;
6649
6650 Code = BURN_ENDIAN_SWAP_INT16(SpriteMap[MapOffset + px + (py << 2)]);
6651 Code &= (TaitoNumSpriteA - 1);
6652
6653 xCur = x + ((k * xZoom) / 4);
6654 yCur = y + ((j * yZoom) / 8);
6655
6656 zx = x + (((k + 1) * xZoom) / 4) - xCur;
6657 zy = y + (((j + 1) * yZoom) / 8) - yCur;
6658
6659 yCur -= 16;
6660
6661 RenderSpriteZoom(Code, xCur, yCur, Colour, xFlip, yFlip, zx << 12, zy << 13, TaitoSpritesA);
6662 }
6663
6664 }
6665 }
6666
AquajackDraw()6667 static INT32 AquajackDraw()
6668 {
6669 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6670 BurnTransferClear();
6671
6672 TC0110PCRRecalcPaletteStep1();
6673
6674 if (TC0100SCNBottomLayer(0)) {
6675 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 1, TaitoChars);
6676 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6677 } else {
6678 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 1, TaitoChars);
6679 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6680 }
6681
6682 AquajackRenderSprites(1);
6683
6684 TC0150RODDraw(-1, 0, 2, 1, 1, 2);
6685
6686 AquajackRenderSprites(0);
6687
6688 if (!(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6689 BurnTransferCopy(TC0110PCRPalette);
6690
6691 return 0;
6692 }
6693
BsharkDraw()6694 static INT32 BsharkDraw()
6695 {
6696 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6697
6698 BurnTransferClear();
6699 TaitoZCalcPalette();
6700
6701 if (TC0100SCNBottomLayer(0)) {
6702 if (nBurnLayer & 2 && !(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 1, TaitoChars);
6703 if (nBurnLayer & 1 && !(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6704 } else {
6705 if (nBurnLayer & 1 && !(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 1, TaitoChars);
6706 if (nBurnLayer & 2 && !(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6707 }
6708
6709 if (nSpriteEnable & 1) BsharkRenderSprites(1, 8, 0x800);
6710
6711 if (nBurnLayer & 4) TC0150RODDraw(-1, 0xc0, 0, 1, 1, 2);
6712
6713 if (nSpriteEnable & 2) BsharkRenderSprites(0, 8, 0x800);
6714
6715 if (nBurnLayer & 8 && !(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6716 BurnTransferCopy(TaitoPalette);
6717
6718 return 0;
6719 }
6720
ChasehqDraw()6721 static INT32 ChasehqDraw()
6722 {
6723 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6724
6725 BurnTransferClear();
6726 TC0110PCRRecalcPaletteStep1();
6727
6728 memset(TaitoPriorityMap, 0, nScreenWidth * nScreenHeight);
6729
6730 if (TC0100SCNBottomLayer(0)) {
6731 if (!(Disable & 0x02)) if (nBurnLayer & 1) TC0100SCNRenderFgLayer(0, 1, TaitoChars, 0);
6732 if (!(Disable & 0x01)) if (nBurnLayer & 2) TC0100SCNRenderBgLayer(0, 0, TaitoChars, 1);
6733 } else {
6734 if (!(Disable & 0x01)) if (nBurnLayer & 1) TC0100SCNRenderBgLayer(0, 1, TaitoChars, 0);
6735 if (!(Disable & 0x02)) if (nBurnLayer & 2) TC0100SCNRenderFgLayer(0, 0, TaitoChars, 1);
6736 }
6737 if (nBurnLayer & 4) TC0150RODDraw(-1, 0xc0, 0, 0, 1, 2);
6738
6739 if (nBurnLayer & 8) if (!(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6740
6741 if (nSpriteEnable & 1) ChasehqRenderSprites();
6742
6743 BurnTransferCopy(TC0110PCRPalette);
6744 if (bUseShifter) BurnShiftRender();
6745
6746 return 0;
6747 }
6748
ContcircDraw()6749 static INT32 ContcircDraw()
6750 {
6751 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6752
6753 BurnTransferClear();
6754 TC0110PCRRecalcPaletteStep1RBSwap();
6755
6756 if (TC0100SCNBottomLayer(0)) {
6757 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6758 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6759 } else {
6760 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6761 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6762 }
6763
6764 ContcircRenderSprites(1, 24);
6765
6766 TC0150RODDraw(-3 + 8, TaitoRoadPalBank << 6, 1, 0, 1, 2);
6767
6768 ContcircRenderSprites(0, 24);
6769
6770 if (!(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6771 BurnTransferCopy(TC0110PCRPalette);
6772 BurnShiftRender();
6773
6774 return 0;
6775 }
6776
EnforceDraw()6777 static INT32 EnforceDraw()
6778 {
6779 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6780
6781 BurnTransferClear();
6782 TC0110PCRRecalcPaletteStep1RBSwap();
6783
6784 if (TC0100SCNBottomLayer(0)) {
6785 if (nBurnLayer & 2 && !(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6786 if (nBurnLayer & 1 && !(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6787 } else {
6788 if (nBurnLayer & 1 && !(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6789 if (nBurnLayer & 2 && !(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6790 }
6791
6792 if (nSpriteEnable & 1) ContcircRenderSprites(1, 24);
6793
6794 if (nBurnLayer & 4) TC0150RODDraw(-3 + 8, 0xc0, 1, 0, 1, 2);
6795
6796 if (nSpriteEnable & 2) ContcircRenderSprites(0, 24);
6797
6798 if (nBurnLayer & 8 && !(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6799 BurnTransferCopy(TC0110PCRPalette);
6800
6801 return 0;
6802 }
6803
DblaxleDraw()6804 static INT32 DblaxleDraw()
6805 {
6806 UINT8 Layer[4];
6807 UINT16 Priority = TC0480SCPGetBgPriority();
6808
6809 Layer[0] = (Priority & 0xf000) >> 12;
6810 Layer[1] = (Priority & 0x0f00) >> 8;
6811 Layer[2] = (Priority & 0x00f0) >> 4;
6812 Layer[3] = (Priority & 0x000f) >> 0;
6813
6814 BurnTransferClear();
6815 TaitoZCalcPalette();
6816
6817 TC0480SCPTilemapRender(Layer[0], 1, TaitoChars);
6818 TC0480SCPTilemapRender(Layer[1], 0, TaitoChars);
6819 TC0480SCPTilemapRender(Layer[2], 0, TaitoChars);
6820
6821 BsharkRenderSprites(1, 7, 0x2000);
6822
6823 TC0150RODDraw(-1, 0xc0, 0, 0, 1, 2);
6824
6825 BsharkRenderSprites(0, 7, 0x2000);
6826
6827 TC0480SCPTilemapRender(Layer[3], 0, TaitoChars);
6828
6829 TC0480SCPRenderCharLayer();
6830 BurnTransferCopy(TaitoPalette);
6831 BurnShiftRender();
6832
6833 return 0;
6834 }
6835
RacingbDraw()6836 static INT32 RacingbDraw()
6837 {
6838 UINT8 Layer[4];
6839 UINT16 Priority = TC0480SCPGetBgPriority();
6840
6841 Layer[0] = (Priority & 0xf000) >> 12;
6842 Layer[1] = (Priority & 0x0f00) >> 8;
6843 Layer[2] = (Priority & 0x00f0) >> 4;
6844 Layer[3] = (Priority & 0x000f) >> 0;
6845
6846 BurnTransferClear();
6847 TaitoZCalcPalette();
6848
6849 TC0480SCPTilemapRender(Layer[0], 1, TaitoChars);
6850 TC0480SCPTilemapRender(Layer[1], 0, TaitoChars);
6851 SciRenderSprites(1, 7);
6852 TC0480SCPTilemapRender(Layer[2], 0, TaitoChars);
6853 TC0480SCPTilemapRender(Layer[3], 0, TaitoChars);
6854 TC0150RODDraw(-1, 0xc0, 0, 0, 1, 2);
6855 SciRenderSprites(0, 7);
6856 TC0480SCPRenderCharLayer();
6857 BurnTransferCopy(TaitoPalette);
6858 BurnShiftRender();
6859
6860 return 0;
6861 }
6862
SciDraw()6863 static INT32 SciDraw()
6864 {
6865 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6866
6867 BurnTransferClear();
6868 TaitoZCalcPalette();
6869
6870 memset(TaitoPriorityMap, 0, nScreenWidth * nScreenHeight);
6871
6872 if (TC0100SCNBottomLayer(0)) {
6873 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 1, TaitoChars, 0);
6874 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars, 1);
6875 } else {
6876 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 1, TaitoChars, 0);
6877 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars, 1);
6878 }
6879
6880 TC0150RODDraw(-1, 0xc0, 0, 0, 1, 2);
6881
6882 if (!(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6883
6884 SciRenderSpritesPrio(6);
6885
6886 BurnTransferCopy(TaitoPalette);
6887 BurnShiftRender();
6888
6889 return 0;
6890 }
6891
SpacegunDraw()6892 static INT32 SpacegunDraw()
6893 {
6894 INT32 Disable = TC0100SCNCtrl[0][6] & 0xf7;
6895
6896 BurnTransferClear();
6897 TC0110PCRRecalcPaletteStep1RBSwap();
6898
6899 if (TC0100SCNBottomLayer(0)) {
6900 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 1, TaitoChars);
6901 SpacegunRenderSprites(1);
6902 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 0, TaitoChars);
6903 } else {
6904 if (!(Disable & 0x01)) TC0100SCNRenderBgLayer(0, 1, TaitoChars);
6905 SpacegunRenderSprites(1);
6906 if (!(Disable & 0x02)) TC0100SCNRenderFgLayer(0, 0, TaitoChars);
6907 }
6908
6909 SpacegunRenderSprites(0);
6910
6911 if (!(Disable & 0x04)) TC0100SCNRenderCharLayer(0);
6912 BurnTransferCopy(TC0110PCRPalette);
6913
6914 for (INT32 i = 0; i < nBurnGunNumPlayers; i++) {
6915 BurnGunDrawTarget(i, BurnGunX[i] >> 8, BurnGunY[i] >> 8);
6916 }
6917
6918 return 0;
6919 }
6920
TaitoZFrame()6921 static INT32 TaitoZFrame()
6922 {
6923 INT32 nInterleave = TaitoFrameInterleave;
6924 INT32 nVBlankIRQFire = (INT32)(((double)270 / 271) * TaitoFrameInterleave);
6925
6926 if (TaitoReset) TaitoZDoReset();
6927
6928 TaitoMakeInputsFunction();
6929
6930 nTaitoCyclesDone[0] = nTaitoCyclesDone[1] = nTaitoCyclesDone[2] = 0;
6931
6932 SekNewFrame();
6933 if (TaitoNumZ80s) ZetNewFrame();
6934
6935 for (INT32 i = 0; i < nInterleave; i++) {
6936 INT32 nCurrentCPU, nNext;
6937
6938 // Run 68000 #1
6939 nCurrentCPU = 0;
6940 SekOpen(0);
6941 if (TaitoNumZ80s) {
6942 nNext = (i + 1) * nTaitoCyclesTotal[nCurrentCPU] / nInterleave;
6943 nTaitoCyclesSegment = nNext - nTaitoCyclesDone[nCurrentCPU];
6944 nTaitoCyclesDone[nCurrentCPU] += SekRun(nTaitoCyclesSegment);
6945 } else {
6946 BurnTimerUpdate((i + 1) * (nTaitoCyclesTotal[nCurrentCPU] / nInterleave));
6947 }
6948 if (i == 10 && Sci && ((GetCurrentFrame() & 1) == 0)) SekSetIRQLine(6, CPU_IRQSTATUS_AUTO);
6949 if (TaitoZINT6timer && (SekTotalCycles() >= (TaitoZINT6timer + 10000))) {
6950 SekSetIRQLine(6, CPU_IRQSTATUS_AUTO);
6951 TaitoZINT6timer = 0;
6952 }
6953 if (i == nVBlankIRQFire) SekSetIRQLine(TaitoIrqLine, CPU_IRQSTATUS_AUTO);
6954 SekClose();
6955
6956 // Run 68000 #2
6957 if (TaitoCpuACtrl & 0x01) {
6958 nCurrentCPU = 1;
6959 SekOpen(1);
6960 nNext = (i + 1) * nTaitoCyclesTotal[nCurrentCPU] / nInterleave;
6961 nTaitoCyclesSegment = nNext - nTaitoCyclesDone[nCurrentCPU];
6962 nTaitoCyclesDone[nCurrentCPU] += SekRun(nTaitoCyclesSegment);
6963 if (i == nVBlankIRQFire) SekSetIRQLine(TaitoIrqLine, CPU_IRQSTATUS_AUTO);
6964 SekClose();
6965 }
6966
6967 if (TaitoNumZ80s) {
6968 ZetOpen(0);
6969 BurnTimerUpdate((i + 1) * (nTaitoCyclesTotal[2] / nInterleave));
6970 ZetClose();
6971 }
6972 }
6973
6974 if (TaitoNumZ80s) {
6975 ZetOpen(0);
6976 BurnTimerEndFrame(nTaitoCyclesTotal[2]);
6977 if (pBurnSoundOut) BurnYM2610Update(pBurnSoundOut, nBurnSoundLen);
6978 ZetClose();
6979 } else {
6980 SekOpen(0);
6981 BurnTimerEndFrame(nTaitoCyclesTotal[0]);
6982 if (pBurnSoundOut) BurnYM2610Update(pBurnSoundOut, nBurnSoundLen);
6983 SekClose();
6984 }
6985
6986 if (pBurnDraw) BurnDrvRedraw();
6987
6988 return 0;
6989 }
6990
TaitoZScan(INT32 nAction,INT32 * pnMin)6991 static INT32 TaitoZScan(INT32 nAction, INT32 *pnMin)
6992 {
6993 struct BurnArea ba;
6994
6995 if (pnMin != NULL) { // Return minimum compatible version
6996 *pnMin = 0x029674;
6997 }
6998
6999 if (nAction & ACB_MEMORY_RAM) {
7000 memset(&ba, 0, sizeof(ba));
7001 ba.Data = TaitoRamStart;
7002 ba.nLen = TaitoRamEnd-TaitoRamStart;
7003 ba.szName = "All Ram";
7004 BurnAcb(&ba);
7005 }
7006
7007 TaitoICScan(nAction);
7008
7009 if (nAction & ACB_DRIVER_DATA) {
7010 SekScan(nAction);
7011 if (TaitoNumZ80s) ZetScan(nAction);
7012
7013 BurnYM2610Scan(nAction, pnMin);
7014
7015 if (TaitoNumEEPROM) {
7016 EEPROMScan(nAction, pnMin);
7017 }
7018
7019 if (bUseGun)
7020 BurnGunScan();
7021
7022 if (bUseShifter)
7023 BurnShiftScan(nAction);
7024
7025 SCAN_VAR(TaitoAnalogPort0);
7026 SCAN_VAR(TaitoAnalogPort1);
7027 SCAN_VAR(TaitoAnalogPort2);
7028 SCAN_VAR(TaitoAnalogPort3);
7029 SCAN_VAR(TaitoInput);
7030 SCAN_VAR(TaitoCpuACtrl);
7031 SCAN_VAR(TaitoZ80Bank);
7032 SCAN_VAR(SciSpriteFrame);
7033 SCAN_VAR(TaitoRoadPalBank);
7034 SCAN_VAR(nTaitoCyclesDone);
7035 SCAN_VAR(nTaitoCyclesSegment);
7036 }
7037
7038 if (nAction & ACB_WRITE) {
7039 if (TaitoNumZ80s) {
7040 ZetOpen(0);
7041 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
7042 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
7043 ZetClose();
7044 }
7045 }
7046
7047 return 0;
7048 }
7049
7050 struct BurnDriver BurnDrvAquajack = {
7051 "aquajack", NULL, NULL, NULL, "1990",
7052 "Aquajack (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7053 NULL, NULL, NULL, NULL,
7054 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7055 NULL, AquajackRomInfo, AquajackRomName, NULL, NULL, NULL, NULL, AquajackInputInfo, AquajackDIPInfo,
7056 AquajackInit, TaitoZExit, TaitoZFrame, AquajackDraw, TaitoZScan,
7057 NULL, 0x1000, 320, 240, 4, 3
7058 };
7059
7060 struct BurnDriver BurnDrvAquajackj = {
7061 "aquajackj", "aquajack", NULL, NULL, "1990",
7062 "Aquajack (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7063 NULL, NULL, NULL, NULL,
7064 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7065 NULL, AquajackjRomInfo, AquajackjRomName, NULL, NULL, NULL, NULL, AquajackInputInfo, AquajackjDIPInfo,
7066 AquajackInit, TaitoZExit, TaitoZFrame, AquajackDraw, TaitoZScan,
7067 NULL, 0x1000, 320, 240, 4, 3
7068 };
7069
7070 struct BurnDriver BurnDrvAquajacku = {
7071 "aquajacku", "aquajack", NULL, NULL, "1990",
7072 "Aquajack (US)\0", NULL, "Taito Corporation", "Taito Z",
7073 NULL, NULL, NULL, NULL,
7074 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7075 NULL, AquajackuRomInfo, AquajackuRomName, NULL, NULL, NULL, NULL, AquajackInputInfo, AquajackjDIPInfo,
7076 AquajackInit, TaitoZExit, TaitoZFrame, AquajackDraw, TaitoZScan,
7077 NULL, 0x1000, 320, 240, 4, 3
7078 };
7079
7080 struct BurnDriver BurnDrvBshark = {
7081 "bshark", NULL, NULL, NULL, "1989",
7082 "Battle Shark (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7083 NULL, NULL, NULL, NULL,
7084 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7085 NULL, BsharkRomInfo, BsharkRomName, NULL, NULL, NULL, NULL, BsharkInputInfo, BsharkDIPInfo,
7086 BsharkInit, TaitoZExit, TaitoZFrame, BsharkDraw, TaitoZScan,
7087 NULL, 0x1000, 320, 240, 4, 3
7088 };
7089
7090 struct BurnDriver BurnDrvBsharkj = {
7091 "bsharkj", "bshark", NULL, NULL, "1989",
7092 "Battle Shark (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7093 NULL, NULL, NULL, NULL,
7094 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7095 NULL, BsharkjRomInfo, BsharkjRomName, NULL, NULL, NULL, NULL, BsharkInputInfo, BsharkjDIPInfo,
7096 BsharkInit, TaitoZExit, TaitoZFrame, BsharkDraw, TaitoZScan,
7097 NULL, 0x1000, 320, 240, 4, 3
7098 };
7099
7100 struct BurnDriver BurnDrvBsharkjjs = {
7101 "bsharkjjs", "bshark", NULL, NULL, "1989",
7102 "Battle Shark (Japan, Joystick)\0", NULL, "Taito Corporation", "Taito Z",
7103 NULL, NULL, NULL, NULL,
7104 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7105 NULL, BsharkjjsRomInfo, BsharkjjsRomName, NULL, NULL, NULL, NULL, BsharkjjsInputInfo, BsharkjjsDIPInfo,
7106 BsharkInit, TaitoZExit, TaitoZFrame, BsharkDraw, TaitoZScan,
7107 NULL, 0x1000, 320, 240, 4, 3
7108 };
7109
7110 struct BurnDriver BurnDrvBsharku = {
7111 "bsharku", "bshark", NULL, NULL, "1989",
7112 "Battle Shark (US)\0", NULL, "Taito America Corporation", "Taito Z",
7113 NULL, NULL, NULL, NULL,
7114 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7115 NULL, BsharkuRomInfo, BsharkuRomName, NULL, NULL, NULL, NULL, BsharkInputInfo, BsharkuDIPInfo,
7116 BsharkInit, TaitoZExit, TaitoZFrame, BsharkDraw, TaitoZScan,
7117 NULL, 0x1000, 320, 240, 4, 3
7118 };
7119
7120 struct BurnDriver BurnDrvChasehq = {
7121 "chasehq", NULL, NULL, NULL, "1988",
7122 "Chase H.Q. (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7123 NULL, NULL, NULL, NULL,
7124 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7125 NULL, ChasehqRomInfo, ChasehqRomName, NULL, NULL, NULL, NULL, ChasehqInputInfo, ChasehqDIPInfo,
7126 ChasehqInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7127 NULL, 0x1000, 320, 240, 4, 3
7128 };
7129
7130 struct BurnDriver BurnDrvChasehqj = {
7131 "chasehqj", "chasehq", NULL, NULL, "1988",
7132 "Chase H.Q. (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7133 NULL, NULL, NULL, NULL,
7134 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7135 NULL, ChasehqjRomInfo, ChasehqjRomName, NULL, NULL, NULL, NULL, ChasehqInputInfo, ChasehqjDIPInfo,
7136 ChasehqInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7137 NULL, 0x1000, 320, 240, 4, 3
7138 };
7139
7140 struct BurnDriver BurnDrvChasehqju = {
7141 "chasehqju", "chasehq", NULL, NULL, "1988",
7142 "Chase H.Q. (Japan UP)\0", NULL, "Taito Corporation", "Taito Z",
7143 NULL, NULL, NULL, NULL,
7144 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7145 NULL, ChasehqjuRomInfo, ChasehqjuRomName, NULL, NULL, NULL, NULL, ChasehqInputInfo, ChasehqjDIPInfo,
7146 ChasehqInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7147 NULL, 0x1000, 320, 240, 4, 3
7148 };
7149
7150 struct BurnDriver BurnDrvChasehqu = {
7151 "chasehqu", "chasehq", NULL, NULL, "1988",
7152 "Chase H.Q. (US)\0", NULL, "Taito America Corporation", "Taito Z",
7153 NULL, NULL, NULL, NULL,
7154 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7155 NULL, ChasehquRomInfo, ChasehquRomName, NULL, NULL, NULL, NULL, ChasehqInputInfo, ChasehqDIPInfo,
7156 ChasehqInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7157 NULL, 0x1000, 320, 240, 4, 3
7158 };
7159
7160 struct BurnDriver BurnDrvContcirc = {
7161 "contcirc", NULL, NULL, NULL, "1987",
7162 "Continental Circus (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7163 NULL, NULL, NULL, NULL,
7164 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7165 NULL, ContcircRomInfo, ContcircRomName, NULL, NULL, NULL, NULL, ContcircInputInfo, ContcircDIPInfo,
7166 ContcircInit, TaitoZExit, TaitoZFrame, ContcircDraw, TaitoZScan,
7167 NULL, 0x1000, 320, 224, 4, 3
7168 };
7169
7170 struct BurnDriver BurnDrvContcircu = {
7171 "contcircu", "contcirc", NULL, NULL, "1987",
7172 "Continental Circus (US set 1)\0", NULL, "Taito America Corporation", "Taito Z",
7173 NULL, NULL, NULL, NULL,
7174 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7175 NULL, ContcircuRomInfo, ContcircuRomName, NULL, NULL, NULL, NULL, ContcircInputInfo, ContcircuDIPInfo,
7176 ContcircInit, TaitoZExit, TaitoZFrame, ContcircDraw, TaitoZScan,
7177 NULL, 0x1000, 320, 224, 4, 3
7178 };
7179
7180 struct BurnDriver BurnDrvContcircua = {
7181 "contcircua", "contcirc", NULL, NULL, "1987",
7182 "Continental Circus (US set 2)\0", "3D Effect cannot be disabled, use US Set 1 instead!", "Taito America Corporation", "Taito Z",
7183 NULL, NULL, NULL, NULL,
7184 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7185 NULL, ContcircuaRomInfo, ContcircuaRomName, NULL, NULL, NULL, NULL, ContcircInputInfo, ContcircjDIPInfo,
7186 ContcircInit, TaitoZExit, TaitoZFrame, ContcircDraw, TaitoZScan,
7187 NULL, 0x1000, 320, 224, 4, 3
7188 };
7189
7190 struct BurnDriver BurnDrvContcircj = {
7191 "contcircj", "contcirc", NULL, NULL, "1987",
7192 "Continental Circus (Japan)\0", "3D Effect cannot be disabled, use World romset instead!", "Taito Corporation", "Taito Z",
7193 NULL, NULL, NULL, NULL,
7194 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7195 NULL, ContcircjRomInfo, ContcircjRomName, NULL, NULL, NULL, NULL, ContcircInputInfo, ContcircjDIPInfo,
7196 ContcircInit, TaitoZExit, TaitoZFrame, ContcircDraw, TaitoZScan,
7197 NULL, 0x1000, 320, 224, 4, 3
7198 };
7199
7200 struct BurnDriver BurnDrvDblaxle = {
7201 "dblaxle", NULL, NULL, NULL, "1991",
7202 "Double Axle (US, Rev 1)\0", NULL, "Taito America Corporation", "Taito Z",
7203 NULL, NULL, NULL, NULL,
7204 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7205 NULL, DblaxleRomInfo, DblaxleRomName, NULL, NULL, NULL, NULL, DblaxleInputInfo, DblaxlesDIPInfo,
7206 DblaxleInit, TaitoZExit, TaitoZFrame, DblaxleDraw, TaitoZScan,
7207 NULL, 0x1000, 320, 240, 4, 3
7208 };
7209
7210 struct BurnDriver BurnDrvDblaxleu = {
7211 "dblaxleu", "dblaxle", NULL, NULL, "1991",
7212 "Double Axle (US)\0", NULL, "Taito America Corporation", "Taito Z",
7213 NULL, NULL, NULL, NULL,
7214 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7215 NULL, DblaxleuRomInfo, DblaxleuRomName, NULL, NULL, NULL, NULL, DblaxleInputInfo, DblaxlesDIPInfo,
7216 DblaxleInit, TaitoZExit, TaitoZFrame, DblaxleDraw, TaitoZScan,
7217 NULL, 0x1000, 320, 240, 4, 3
7218 };
7219
7220 struct BurnDriver BurnDrvDblaxleul = {
7221 "dblaxleul", "dblaxle", NULL, NULL, "1991",
7222 "Double Axle (US, Rev 1, Linkable)\0", NULL, "Taito America Corporation", "Taito Z",
7223 NULL, NULL, NULL, NULL,
7224 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7225 NULL, DblaxleulRomInfo, DblaxleulRomName, NULL, NULL, NULL, NULL, DblaxleInputInfo, DblaxleDIPInfo,
7226 DblaxleInit, TaitoZExit, TaitoZFrame, DblaxleDraw, TaitoZScan,
7227 NULL, 0x1000, 320, 240, 4, 3
7228 };
7229
7230 struct BurnDriver BurnDrvPwheelsj = {
7231 "pwheelsj", "dblaxle", NULL, NULL, "1991",
7232 "Power Wheels (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7233 NULL, NULL, NULL, NULL,
7234 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7235 NULL, PwheelsjRomInfo, PwheelsjRomName, NULL, NULL, NULL, NULL, DblaxleInputInfo, PwheelsjDIPInfo,
7236 DblaxleInit, TaitoZExit, TaitoZFrame, DblaxleDraw, TaitoZScan,
7237 NULL, 0x1000, 320, 240, 4, 3
7238 };
7239
7240 struct BurnDriver BurnDrvEnforce = {
7241 "enforce", NULL, NULL, NULL, "1988",
7242 "Enforce (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7243 NULL, NULL, NULL, NULL,
7244 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7245 NULL, EnforceRomInfo, EnforceRomName, NULL, NULL, NULL, NULL, EnforceInputInfo, EnforceDIPInfo,
7246 EnforceInit, TaitoZExit, TaitoZFrame, EnforceDraw, TaitoZScan,
7247 NULL, 0x1000, 320, 224, 4, 3
7248 };
7249
7250 struct BurnDriver BurnDrvEnforcej = {
7251 "enforcej", "enforce", NULL, NULL, "1988",
7252 "Enforce (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7253 NULL, NULL, NULL, NULL,
7254 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7255 NULL, EnforcejRomInfo, EnforcejRomName, NULL, NULL, NULL, NULL, EnforceInputInfo, EnforcejDIPInfo,
7256 EnforceInit, TaitoZExit, TaitoZFrame, EnforceDraw, TaitoZScan,
7257 NULL, 0x1000, 320, 224, 4, 3
7258 };
7259
7260 struct BurnDriver BurnDrvEnforceja = {
7261 "enforceja", "enforce", NULL, NULL, "1988",
7262 "Enforce (Japan, Analog Controls)\0", NULL, "Taito Corporation", "Taito Z",
7263 NULL, NULL, NULL, NULL,
7264 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7265 NULL, EnforcejaRomInfo, EnforcejaRomName, NULL, NULL, NULL, NULL, EnforceInputInfo, EnforcejaDIPInfo,
7266 EnforceInit, TaitoZExit, TaitoZFrame, EnforceDraw, TaitoZScan,
7267 NULL, 0x1000, 320, 224, 4, 3
7268 };
7269
7270 struct BurnDriver BurnDrvNightstr = {
7271 "nightstr", NULL, NULL, NULL, "1989",
7272 "Night Striker (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7273 NULL, NULL, NULL, NULL,
7274 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7275 NULL, NightstrRomInfo, NightstrRomName, NULL, NULL, NULL, NULL, NightstrInputInfo, NightstrDIPInfo,
7276 NightstrInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7277 NULL, 0x1000, 320, 240, 4, 3
7278 };
7279
7280 struct BurnDriver BurnDrvNightstrj = {
7281 "nightstrj", "nightstr", NULL, NULL, "1989",
7282 "Night Striker (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7283 NULL, NULL, NULL, NULL,
7284 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7285 NULL, NightstrjRomInfo, NightstrjRomName, NULL, NULL, NULL, NULL, NightstrInputInfo, NightstrjDIPInfo,
7286 NightstrInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7287 NULL, 0x1000, 320, 240, 4, 3
7288 };
7289
7290 struct BurnDriver BurnDrvNightstru = {
7291 "nightstru", "nightstr", NULL, NULL, "1989",
7292 "Night Striker (US)\0", NULL, "Taito America Corporation", "Taito Z",
7293 NULL, NULL, NULL, NULL,
7294 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7295 NULL, NightstruRomInfo, NightstruRomName, NULL, NULL, NULL, NULL, NightstrInputInfo, NightstruDIPInfo,
7296 NightstrInit, TaitoZExit, TaitoZFrame, ChasehqDraw, TaitoZScan,
7297 NULL, 0x1000, 320, 240, 4, 3
7298 };
7299
7300 struct BurnDriver BurnDrvRacingb = {
7301 "racingb", NULL, NULL, NULL, "1991",
7302 "Racing Beat (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7303 NULL, NULL, NULL, NULL,
7304 BDF_GAME_WORKING, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7305 NULL, RacingbRomInfo, RacingbRomName, NULL, NULL, NULL, NULL, RacingbInputInfo, RacingbDIPInfo,
7306 RacingbInit, TaitoZExit, TaitoZFrame, RacingbDraw, TaitoZScan,
7307 NULL, 0x1000, 320, 240, 4, 3
7308 };
7309
7310 struct BurnDriver BurnDrvRacingbj = {
7311 "racingbj", "racingb", NULL, NULL, "1991",
7312 "Racing Beat (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7313 NULL, NULL, NULL, NULL,
7314 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7315 NULL, RacingbjRomInfo, RacingbjRomName, NULL, NULL, NULL, NULL, RacingbInputInfo, RacingbDIPInfo,
7316 RacingbInit, TaitoZExit, TaitoZFrame, RacingbDraw, TaitoZScan,
7317 NULL, 0x1000, 320, 240, 4, 3
7318 };
7319
7320 struct BurnDriver BurnDrvSci = {
7321 "sci", NULL, NULL, NULL, "1989",
7322 "Special Criminal Investigation (World set 1)\0", NULL, "Taito Corporation Japan", "Taito Z",
7323 NULL, NULL, NULL, NULL,
7324 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7325 NULL, SciRomInfo, SciRomName, NULL, NULL, NULL, NULL, SciInputInfo, SciDIPInfo,
7326 SciInit, TaitoZExit, TaitoZFrame, SciDraw, TaitoZScan,
7327 NULL, 0x1000, 320, 240, 4, 3
7328 };
7329
7330 struct BurnDriver BurnDrvScia = {
7331 "scia", "sci", NULL, NULL, "1989",
7332 "Special Criminal Investigation (World set 2)\0", NULL, "Taito Corporation Japan", "Taito Z",
7333 NULL, NULL, NULL, NULL,
7334 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7335 NULL, SciaRomInfo, SciaRomName, NULL, NULL, NULL, NULL, SciInputInfo, SciDIPInfo,
7336 SciInit, TaitoZExit, TaitoZFrame, SciDraw, TaitoZScan,
7337 NULL, 0x1000, 320, 240, 4, 3
7338 };
7339
7340 struct BurnDriver BurnDrvScij = {
7341 "scij", "sci", NULL, NULL, "1989",
7342 "Special Criminal Investigation (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7343 NULL, NULL, NULL, NULL,
7344 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7345 NULL, ScijRomInfo, ScijRomName, NULL, NULL, NULL, NULL, SciInputInfo, ScijDIPInfo,
7346 SciInit, TaitoZExit, TaitoZFrame, SciDraw, TaitoZScan,
7347 NULL, 0x1000, 320, 240, 4, 3
7348 };
7349
7350 struct BurnDriver BurnDrvSciu = {
7351 "sciu", "sci", NULL, NULL, "1989",
7352 "Special Criminal Investigation (US)\0", NULL, "Taito America Corporation", "Taito Z",
7353 NULL, NULL, NULL, NULL,
7354 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7355 NULL, SciuRomInfo, SciuRomName, NULL, NULL, NULL, NULL, SciInputInfo, SciuDIPInfo,
7356 SciInit, TaitoZExit, TaitoZFrame, SciDraw, TaitoZScan,
7357 NULL, 0x1000, 320, 240, 4, 3
7358 };
7359
7360 struct BurnDriver BurnDrvScin = {
7361 "scin", "sci", NULL, NULL, "1989",
7362 "Super Special Criminal Investigation (Negro Torino hack)\0", NULL, "hack (Negro Torino)", "Taito Z",
7363 NULL, NULL, NULL, NULL,
7364 BDF_GAME_WORKING | BDF_CLONE | BDF_BOOTLEG | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_RACING, 0,
7365 NULL, ScinRomInfo, ScinRomName, NULL, NULL, NULL, NULL, SciInputInfo, SciDIPInfo,
7366 SciInit, TaitoZExit, TaitoZFrame, SciDraw, TaitoZScan,
7367 NULL, 0x1000, 320, 240, 4, 3
7368 };
7369
7370 struct BurnDriver BurnDrvSpacegun = {
7371 "spacegun", NULL, NULL, NULL, "1990",
7372 "Space Gun (World)\0", NULL, "Taito Corporation Japan", "Taito Z",
7373 NULL, NULL, NULL, NULL,
7374 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7375 NULL, SpacegunRomInfo, SpacegunRomName, NULL, NULL, NULL, NULL, SpacegunInputInfo, SpacegunDIPInfo,
7376 SpacegunInit, TaitoZExit, TaitoZFrame, SpacegunDraw, TaitoZScan,
7377 NULL, 0x1000, 320, 240, 4, 3
7378 };
7379
7380 struct BurnDriver BurnDrvSpacegunj = {
7381 "spacegunj", "spacegun", NULL, NULL, "1990",
7382 "Space Gun (Japan)\0", NULL, "Taito Corporation", "Taito Z",
7383 NULL, NULL, NULL, NULL,
7384 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7385 NULL, SpacegunjRomInfo, SpacegunjRomName, NULL, NULL, NULL, NULL, SpacegunInputInfo, SpacegunjDIPInfo,
7386 SpacegunInit, TaitoZExit, TaitoZFrame, SpacegunDraw, TaitoZScan,
7387 NULL, 0x1000, 320, 240, 4, 3
7388 };
7389
7390 struct BurnDriver BurnDrvSpacegunu = {
7391 "spacegunu", "spacegun", NULL, NULL, "1990",
7392 "Space Gun (US)\0", NULL, "Taito America Corporation", "Taito Z",
7393 NULL, NULL, NULL, NULL,
7394 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_TAITO_TAITOZ, GBF_SHOOT, 0,
7395 NULL, SpacegunuRomInfo, SpacegunuRomName, NULL, NULL, NULL, NULL, SpacegunInputInfo, SpacegunuDIPInfo,
7396 SpacegunInit, TaitoZExit, TaitoZFrame, SpacegunDraw, TaitoZScan,
7397 NULL, 0x1000, 320, 240, 4, 3
7398 };
7399