1 // Based on MAME drivers by Howie Cohen, Yochizo
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_ym2151.h"
9 #include "burn_ym2610.h"
10
11 static struct BurnInputInfo SupermanInputList[]=
12 {
13 {"P1 Coin" , BIT_DIGITAL, TaitoInputPort2 + 0, "p1 coin" },
14 {"P1 Start" , BIT_DIGITAL, TaitoInputPort0 + 7, "p1 start" },
15 {"P1 Up" , BIT_DIGITAL, TaitoInputPort0 + 0, "p1 up" },
16 {"P1 Down" , BIT_DIGITAL, TaitoInputPort0 + 1, "p1 down" },
17 {"P1 Left" , BIT_DIGITAL, TaitoInputPort0 + 2, "p1 left" },
18 {"P1 Right" , BIT_DIGITAL, TaitoInputPort0 + 3, "p1 right" },
19 {"P1 Button 1" , BIT_DIGITAL, TaitoInputPort0 + 4, "p1 fire 1" },
20 {"P1 Button 2" , BIT_DIGITAL, TaitoInputPort0 + 5, "p1 fire 2" },
21
22 {"P2 Coin" , BIT_DIGITAL, TaitoInputPort2 + 1, "p2 coin" },
23 {"P2 Start" , BIT_DIGITAL, TaitoInputPort1 + 7, "p2 start" },
24 {"P2 Up" , BIT_DIGITAL, TaitoInputPort1 + 0, "p2 up" },
25 {"P2 Down" , BIT_DIGITAL, TaitoInputPort1 + 1, "p2 down" },
26 {"P2 Left" , BIT_DIGITAL, TaitoInputPort1 + 2, "p2 left" },
27 {"P2 Right" , BIT_DIGITAL, TaitoInputPort1 + 3, "p2 right" },
28 {"P2 Button 1" , BIT_DIGITAL, TaitoInputPort1 + 4, "p2 fire 1" },
29 {"P2 Button 2" , BIT_DIGITAL, TaitoInputPort1 + 5, "p2 fire 2" },
30
31 {"Reset" , BIT_DIGITAL, &TaitoReset , "reset" },
32 {"Service" , BIT_DIGITAL, TaitoInputPort2 + 2, "service" },
33 {"Tilt" , BIT_DIGITAL, TaitoInputPort2 + 7, "tilt" },
34 {"Dip 1" , BIT_DIPSWITCH, TaitoDip + 0 , "dip" },
35 {"Dip 2" , BIT_DIPSWITCH, TaitoDip + 1 , "dip" },
36 };
37
38 STDINPUTINFO(Superman)
39
40 static struct BurnInputInfo TwinhawkInputList[]=
41 {
42 {"P1 Coin" , BIT_DIGITAL, TaitoInputPort2 + 0, "p1 coin" },
43 {"P1 Start" , BIT_DIGITAL, TaitoInputPort0 + 7, "p1 start" },
44 {"P1 Up" , BIT_DIGITAL, TaitoInputPort0 + 0, "p1 up" },
45 {"P1 Down" , BIT_DIGITAL, TaitoInputPort0 + 1, "p1 down" },
46 {"P1 Left" , BIT_DIGITAL, TaitoInputPort0 + 2, "p1 left" },
47 {"P1 Right" , BIT_DIGITAL, TaitoInputPort0 + 3, "p1 right" },
48 {"P1 Button 1" , BIT_DIGITAL, TaitoInputPort0 + 4, "p1 fire 1" },
49 {"P1 Button 2" , BIT_DIGITAL, TaitoInputPort0 + 5, "p1 fire 2" },
50 {"P1 Button 3" , BIT_DIGITAL, TaitoInputPort0 + 6, "p1 fire 3" },
51
52 {"P2 Coin" , BIT_DIGITAL, TaitoInputPort2 + 1, "p2 coin" },
53 {"P2 Start" , BIT_DIGITAL, TaitoInputPort1 + 7, "p2 start" },
54 {"P2 Up" , BIT_DIGITAL, TaitoInputPort1 + 0, "p2 up" },
55 {"P2 Down" , BIT_DIGITAL, TaitoInputPort1 + 1, "p2 down" },
56 {"P2 Left" , BIT_DIGITAL, TaitoInputPort1 + 2, "p2 left" },
57 {"P2 Right" , BIT_DIGITAL, TaitoInputPort1 + 3, "p2 right" },
58 {"P2 Button 1" , BIT_DIGITAL, TaitoInputPort1 + 4, "p2 fire 1" },
59 {"P2 Button 2" , BIT_DIGITAL, TaitoInputPort1 + 5, "p2 fire 2" },
60 {"P2 Button 3" , BIT_DIGITAL, TaitoInputPort1 + 6, "p2 fire 3" },
61
62 {"Reset" , BIT_DIGITAL, &TaitoReset , "reset" },
63 {"Service" , BIT_DIGITAL, TaitoInputPort2 + 2, "service" },
64 {"Tilt" , BIT_DIGITAL, TaitoInputPort2 + 3, "tilt" },
65 {"Dip 1" , BIT_DIPSWITCH, TaitoDip + 0 , "dip" },
66 {"Dip 2" , BIT_DIPSWITCH, TaitoDip + 1 , "dip" },
67 };
68
STDINPUTINFO(Twinhawk)69 STDINPUTINFO(Twinhawk)
70
71 static void TaitoXMakeInputs()
72 {
73 TaitoInput[0] = TaitoInput[1] = TaitoInput[2] = 0xff;
74
75 for (INT32 i = 0; i < 8; i++) {
76 TaitoInput[0] -= (TaitoInputPort0[i] & 1) << i;
77 TaitoInput[1] -= (TaitoInputPort1[i] & 1) << i;
78 TaitoInput[2] -= (TaitoInputPort2[i] & 1) << i;
79 }
80
81 if (cchip_active) {
82 cchip_loadports(TaitoInput[0], TaitoInput[1], 0, TaitoInput[2]);
83 }
84 }
85
86 static struct BurnDIPInfo BallbrosDIPList[]=
87 {
88 // Default Values
89 {0x15, 0xff, 0xff, 0xdf, NULL },
90 {0x16, 0xff, 0xff, 0x86, NULL },
91
92 // Dip 1
93 {0 , 0xfe, 0 , 4 , "Coin A" },
94 {0x15, 0x01, 0x03, 0x01, "2 Coins 1 Credit" },
95 {0x15, 0x01, 0x03, 0x03, "1 Coin 1 Credit" },
96 {0x15, 0x01, 0x03, 0x00, "2 Coins 3 Credits" },
97 {0x15, 0x01, 0x03, 0x02, "1 Coin 2 Credits" },
98
99 {0 , 0xfe, 0 , 4 , "Coin B" },
100 {0x15, 0x01, 0x0c, 0x04, "2 Coins 1 Credit" },
101 {0x15, 0x01, 0x0c, 0x0c, "1 Coin 1 Credit" },
102 {0x15, 0x01, 0x0c, 0x00, "2 Coins 3 Credits" },
103 {0x15, 0x01, 0x0c, 0x08, "1 Coin 2 Credits" },
104
105 {0 , 0xfe, 0 , 4 , "Difficulty" },
106 {0x15, 0x01, 0x60, 0x60, "Easy" },
107 {0x15, 0x01, 0x60, 0x40, "Medium" },
108 {0x15, 0x01, 0x60, 0x20, "Hard" },
109 {0x15, 0x01, 0x60, 0x00, "Hardest" },
110
111 // Dip 2
112 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
113 {0x16, 0x01, 0x01, 0x01, "Off" },
114 {0x16, 0x01, 0x01, 0x00, "On" },
115
116 {0 , 0xfe, 0 , 2 , "Flip Screen" },
117 {0x16, 0x01, 0x02, 0x02, "Off" },
118 {0x16, 0x01, 0x02, 0x00, "On" },
119
120 {0 , 0xfe, 0 , 2 , "Allow Continue" },
121 {0x16, 0x01, 0x04, 0x00, "Off" },
122 {0x16, 0x01, 0x04, 0x04, "On" },
123
124 {0 , 0xfe, 0 , 2 , "Language" },
125 {0x16, 0x01, 0x20, 0x00, "English" },
126 {0x16, 0x01, 0x20, 0x20, "Japanese" },
127
128 {0 , 0xfe, 0 , 2 , "Colour Change" },
129 {0x16, 0x01, 0x40, 0x00, "Less" },
130 {0x16, 0x01, 0x40, 0x40, "More" },
131
132 {0 , 0xfe, 0 , 2 , "Service Mode" },
133 {0x16, 0x01, 0x80, 0x80, "Off" },
134 {0x16, 0x01, 0x80, 0x00, "On" },
135 };
136
137 STDDIPINFO(Ballbros)
138
139 static struct BurnDIPInfo GigandesDIPList[]=
140 {
141 // Default Values
142 {0x15, 0xff, 0xff, 0xdf, NULL },
143 {0x16, 0xff, 0xff, 0x98, NULL },
144
145 // Dip 1
146 {0 , 0xfe, 0 , 4 , "Coin A" },
147 {0x15, 0x01, 0x03, 0x01, "2 Coins 1 Credit" },
148 {0x15, 0x01, 0x03, 0x03, "1 Coin 1 Credit" },
149 {0x15, 0x01, 0x03, 0x00, "2 Coins 3 Credits" },
150 {0x15, 0x01, 0x03, 0x02, "1 Coin 2 Credits" },
151
152 {0 , 0xfe, 0 , 4 , "Coin B" },
153 {0x15, 0x01, 0x0c, 0x04, "2 Coins 1 Credit" },
154 {0x15, 0x01, 0x0c, 0x0c, "1 Coin 1 Credit" },
155 {0x15, 0x01, 0x0c, 0x00, "2 Coins 3 Credits" },
156 {0x15, 0x01, 0x0c, 0x08, "1 Coin 2 Credits" },
157
158 {0 , 0xfe, 0 , 4 , "Difficulty" },
159 {0x15, 0x01, 0x60, 0x60, "Easy" },
160 {0x15, 0x01, 0x60, 0x40, "Medium" },
161 {0x15, 0x01, 0x60, 0x20, "Hard" },
162 {0x15, 0x01, 0x60, 0x00, "Hardest" },
163
164 {0 , 0xfe, 0 , 2 , "Debug Mode" },
165 {0x15, 0x01, 0x80, 0x80, "Off" },
166 {0x15, 0x01, 0x80, 0x00, "On" },
167
168 // Dip 2
169 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
170 {0x16, 0x01, 0x01, 0x01, "Off" },
171 {0x16, 0x01, 0x01, 0x00, "On" },
172
173 {0 , 0xfe, 0 , 2 , "Flip Screen" },
174 {0x16, 0x01, 0x02, 0x00, "Off" },
175 {0x16, 0x01, 0x02, 0x02, "On" },
176
177 {0 , 0xfe, 0 , 2 , "Allow Continue" },
178 {0x16, 0x01, 0x04, 0x04, "Off" },
179 {0x16, 0x01, 0x04, 0x00, "On" },
180
181 {0 , 0xfe, 0 , 4 , "Lives" },
182 {0x16, 0x01, 0x18, 0x18, "3" },
183 {0x16, 0x01, 0x18, 0x10, "4" },
184 {0x16, 0x01, 0x18, 0x08, "5" },
185 {0x16, 0x01, 0x18, 0x00, "6" },
186
187 {0 , 0xfe, 0 , 2 , "Controls" },
188 {0x16, 0x01, 0x20, 0x20, "Single" },
189 {0x16, 0x01, 0x20, 0x00, "Dual" },
190
191 {0 , 0xfe, 0 , 2 , "Language" },
192 {0x16, 0x01, 0x40, 0x00, "English" },
193 {0x16, 0x01, 0x40, 0x40, "Japanese" },
194
195 {0 , 0xfe, 0 , 2 , "Service Mode" },
196 {0x16, 0x01, 0x80, 0x80, "Off" },
197 {0x16, 0x01, 0x80, 0x00, "On" },
198 };
199
200 STDDIPINFO(Gigandes)
201
202 static struct BurnDIPInfo KyustrkrDIPList[]=
203 {
204 // Default Values
205 {0x15, 0xff, 0xff, 0xdf, NULL },
206 {0x16, 0xff, 0xff, 0x80, NULL },
207
208 // Dip 1
209 {0 , 0xfe, 0 , 4 , "Coin A" },
210 {0x15, 0x01, 0x03, 0x01, "2 Coins 1 Credit" },
211 {0x15, 0x01, 0x03, 0x03, "1 Coin 1 Credit" },
212 {0x15, 0x01, 0x03, 0x00, "2 Coins 3 Credits" },
213 {0x15, 0x01, 0x03, 0x02, "1 Coin 2 Credits" },
214
215 {0 , 0xfe, 0 , 4 , "Coin B" },
216 {0x15, 0x01, 0x0c, 0x04, "2 Coins 1 Credit" },
217 {0x15, 0x01, 0x0c, 0x0c, "1 Coin 1 Credit" },
218 {0x15, 0x01, 0x0c, 0x00, "2 Coins 3 Credits" },
219 {0x15, 0x01, 0x0c, 0x08, "1 Coin 2 Credits" },
220
221 {0 , 0xfe, 0 , 4 , "Difficulty" },
222 {0x15, 0x01, 0x60, 0x60, "Easy" },
223 {0x15, 0x01, 0x60, 0x40, "Medium" },
224 {0x15, 0x01, 0x60, 0x20, "Hard" },
225 {0x15, 0x01, 0x60, 0x00, "Hardest" },
226
227 {0 , 0xfe, 0 , 2 , "Debug Mode" },
228 {0x15, 0x01, 0x80, 0x80, "Off" },
229 {0x15, 0x01, 0x80, 0x00, "On" },
230
231 // Dip 2
232 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
233 {0x16, 0x01, 0x01, 0x01, "Off" },
234 {0x16, 0x01, 0x01, 0x00, "On" },
235
236 {0 , 0xfe, 0 , 2 , "Flip Screen" },
237 {0x16, 0x01, 0x02, 0x00, "Off" },
238 {0x16, 0x01, 0x02, 0x02, "On" },
239
240 {0 , 0xfe, 0 , 2 , "Allow Continue" },
241 {0x16, 0x01, 0x04, 0x04, "Off" },
242 {0x16, 0x01, 0x04, 0x00, "On" },
243
244 {0 , 0xfe, 0 , 4 , "Lives" },
245 {0x16, 0x01, 0x18, 0x18, "3" },
246 {0x16, 0x01, 0x18, 0x10, "4" },
247 {0x16, 0x01, 0x18, 0x08, "5" },
248 {0x16, 0x01, 0x18, 0x00, "6" },
249
250 {0 , 0xfe, 0 , 2 , "Controls" },
251 {0x16, 0x01, 0x20, 0x20, "Single" },
252 {0x16, 0x01, 0x20, 0x00, "Dual" },
253
254 {0 , 0xfe, 0 , 2 , "Language" },
255 {0x16, 0x01, 0x40, 0x00, "English" },
256 {0x16, 0x01, 0x40, 0x40, "Japanese" },
257
258 {0 , 0xfe, 0 , 2 , "Service Mode" },
259 {0x16, 0x01, 0x80, 0x80, "Off" },
260 {0x16, 0x01, 0x80, 0x00, "On" },
261 };
262
263 STDDIPINFO(Kyustrkr)
264
265 static struct BurnDIPInfo SupermanDIPList[]=
266 {
267 // Default Values
268 {0x13, 0xff, 0xff, 0xff, NULL },
269 {0x14, 0xff, 0xff, 0xff, NULL },
270
271 // Dip 1
272 {0 , 0xfe, 0 , 2 , "Flip Screen" },
273 {0x13, 0x01, 0x02, 0x02, "Off" },
274 {0x13, 0x01, 0x02, 0x00, "On" },
275
276 {0 , 0xfe, 0 , 2 , "Service Mode" },
277 {0x13, 0x01, 0x04, 0x04, "Off" },
278 {0x13, 0x01, 0x04, 0x00, "On" },
279
280 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
281 {0x13, 0x01, 0x08, 0x00, "Off" },
282 {0x13, 0x01, 0x08, 0x08, "On" },
283
284 {0 , 0xfe, 0 , 4 , "Coin A" },
285 {0x13, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
286 {0x13, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
287 {0x13, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
288 {0x13, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
289
290 {0 , 0xfe, 0 , 4 , "Coin B" },
291 {0x13, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
292 {0x13, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
293 {0x13, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
294 {0x13, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
295
296 // Dip 2
297 {0 , 0xfe, 0 , 4 , "Difficulty" },
298 {0x14, 0x01, 0x03, 0x02, "Easy" },
299 {0x14, 0x01, 0x03, 0x03, "Medium" },
300 {0x14, 0x01, 0x03, 0x01, "Hard" },
301 {0x14, 0x01, 0x03, 0x00, "Hardest" },
302
303 {0 , 0xfe, 0 , 4 , "Lives" },
304 {0x14, 0x01, 0x30, 0x20, "2" },
305 {0x14, 0x01, 0x30, 0x30, "3" },
306 {0x14, 0x01, 0x30, 0x10, "4" },
307 {0x14, 0x01, 0x30, 0x00, "5" },
308 };
309
310 STDDIPINFO(Superman)
311
312 static struct BurnDIPInfo SupermanuDIPList[]=
313 {
314 // Default Values
315 {0x13, 0xff, 0xff, 0xff, NULL },
316 {0x14, 0xff, 0xff, 0xff, NULL },
317
318 // Dip 1
319 {0 , 0xfe, 0 , 2 , "Flip Screen" },
320 {0x13, 0x01, 0x02, 0x02, "Off" },
321 {0x13, 0x01, 0x02, 0x00, "On" },
322
323 {0 , 0xfe, 0 , 2 , "Service Mode" },
324 {0x13, 0x01, 0x04, 0x04, "Off" },
325 {0x13, 0x01, 0x04, 0x00, "On" },
326
327 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
328 {0x13, 0x01, 0x08, 0x00, "Off" },
329 {0x13, 0x01, 0x08, 0x08, "On" },
330
331 {0 , 0xfe, 0 , 4 , "Coinage" },
332 {0x13, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
333 {0x13, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
334 {0x13, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
335 {0x13, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
336
337 {0 , 0xfe, 0 , 4 , "Price to Continue" },
338 {0x13, 0x01, 0xc0, 0x00, "3 Coins 2 Credit" },
339 {0x13, 0x01, 0xc0, 0x40, "2 Coins 3 Credit" },
340 {0x13, 0x01, 0xc0, 0x80, "1 Coin 1 Credit" },
341 {0x13, 0x01, 0xc0, 0xc0, "Same as Start" },
342
343 // Dip 2
344 {0 , 0xfe, 0 , 4 , "Difficulty" },
345 {0x14, 0x01, 0x03, 0x02, "Easy" },
346 {0x14, 0x01, 0x03, 0x03, "Medium" },
347 {0x14, 0x01, 0x03, 0x01, "Hard" },
348 {0x14, 0x01, 0x03, 0x00, "Hardest" },
349
350 {0 , 0xfe, 0 , 4 , "Lives" },
351 {0x14, 0x01, 0x30, 0x20, "2" },
352 {0x14, 0x01, 0x30, 0x30, "3" },
353 {0x14, 0x01, 0x30, 0x10, "4" },
354 {0x14, 0x01, 0x30, 0x00, "5" },
355 };
356
357 STDDIPINFO(Supermanu)
358
359 static struct BurnDIPInfo SupermanjDIPList[]=
360 {
361 // Default Values
362 {0x13, 0xff, 0xff, 0xff, NULL },
363 {0x14, 0xff, 0xff, 0xff, NULL },
364
365 // Dip 1
366 {0 , 0xfe, 0 , 2 , "Flip Screen" },
367 {0x13, 0x01, 0x02, 0x02, "Off" },
368 {0x13, 0x01, 0x02, 0x00, "On" },
369
370 {0 , 0xfe, 0 , 2 , "Service Mode" },
371 {0x13, 0x01, 0x04, 0x04, "Off" },
372 {0x13, 0x01, 0x04, 0x00, "On" },
373
374 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
375 {0x13, 0x01, 0x08, 0x00, "Off" },
376 {0x13, 0x01, 0x08, 0x08, "On" },
377
378 {0 , 0xfe, 0 , 4 , "Coin A" },
379 {0x13, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
380 {0x13, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
381 {0x13, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
382 {0x13, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
383
384 {0 , 0xfe, 0 , 4 , "Coin B" },
385 {0x13, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
386 {0x13, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
387 {0x13, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
388 {0x13, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
389
390 // Dip 2
391 {0 , 0xfe, 0 , 4 , "Difficulty" },
392 {0x14, 0x01, 0x03, 0x02, "Easy" },
393 {0x14, 0x01, 0x03, 0x03, "Medium" },
394 {0x14, 0x01, 0x03, 0x01, "Hard" },
395 {0x14, 0x01, 0x03, 0x00, "Hardest" },
396
397 {0 , 0xfe, 0 , 4 , "Lives" },
398 {0x14, 0x01, 0x30, 0x20, "2" },
399 {0x14, 0x01, 0x30, 0x30, "3" },
400 {0x14, 0x01, 0x30, 0x10, "4" },
401 {0x14, 0x01, 0x30, 0x00, "5" },
402 };
403
404 STDDIPINFO(Supermanj)
405
406
407 static struct BurnDIPInfo TwinhawkDIPList[]=
408 {
409 // Default Values
410 {0x15, 0xff, 0xff, 0xff, NULL },
411 {0x16, 0xff, 0xff, 0x7f, NULL },
412
413 // Dip 1
414 {0 , 0xfe, 0 , 2 , "Flip Screen" },
415 {0x15, 0x01, 0x02, 0x02, "Off" },
416 {0x15, 0x01, 0x02, 0x00, "On" },
417
418 {0 , 0xfe, 0 , 2 , "Service Mode" },
419 {0x15, 0x01, 0x04, 0x04, "Off" },
420 {0x15, 0x01, 0x04, 0x00, "On" },
421
422 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
423 {0x15, 0x01, 0x08, 0x00, "Off" },
424 {0x15, 0x01, 0x08, 0x08, "On" },
425
426 {0 , 0xfe, 0 , 4 , "Coin A" },
427 {0x15, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
428 {0x15, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
429 {0x15, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
430 {0x15, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
431
432 {0 , 0xfe, 0 , 4 , "Coin B" },
433 {0x15, 0x01, 0xc0, 0xc0, "1 Coin 2 Credits" },
434 {0x15, 0x01, 0xc0, 0x80, "1 Coin 3 Credits" },
435 {0x15, 0x01, 0xc0, 0x40, "1 Coin 4 Credits" },
436 {0x15, 0x01, 0xc0, 0x00, "1 Coin 6 Credits" },
437
438 // Dip 2
439 {0 , 0xfe, 0 , 4 , "Difficulty" },
440 {0x16, 0x01, 0x03, 0x02, "Easy" },
441 {0x16, 0x01, 0x03, 0x03, "Medium" },
442 {0x16, 0x01, 0x03, 0x01, "Hard" },
443 {0x16, 0x01, 0x03, 0x00, "Hardest" },
444
445 {0 , 0xfe, 0 , 4 , "Bonus Life" },
446 {0x16, 0x01, 0x0c, 0x0c, "50k and every 150k" },
447 {0x16, 0x01, 0x0c, 0x08, "70k and every 200k" },
448 {0x16, 0x01, 0x0c, 0x04, "50k only" },
449 {0x16, 0x01, 0x0c, 0x00, "100k only" },
450
451 {0 , 0xfe, 0 , 4 , "Lives" },
452 {0x16, 0x01, 0x30, 0x00, "2" },
453 {0x16, 0x01, 0x30, 0x30, "3" },
454 {0x16, 0x01, 0x30, 0x10, "4" },
455 {0x16, 0x01, 0x30, 0x20, "5" },
456
457 {0 , 0xfe, 0 , 2 , "Allow Continue" },
458 {0x16, 0x01, 0x80, 0x80, "Off" },
459 {0x16, 0x01, 0x80, 0x00, "On" },
460 };
461
462 STDDIPINFO(Twinhawk)
463
464 static struct BurnDIPInfo TwinhawkuDIPList[]=
465 {
466 // Default Values
467 {0x15, 0xff, 0xff, 0xff, NULL },
468 {0x16, 0xff, 0xff, 0x7f, NULL },
469
470 // Dip 1
471 {0 , 0xfe, 0 , 2 , "Flip Screen" },
472 {0x15, 0x01, 0x02, 0x02, "Off" },
473 {0x15, 0x01, 0x02, 0x00, "On" },
474
475 {0 , 0xfe, 0 , 2 , "Service Mode" },
476 {0x15, 0x01, 0x04, 0x04, "Off" },
477 {0x15, 0x01, 0x04, 0x00, "On" },
478
479 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
480 {0x15, 0x01, 0x08, 0x00, "Off" },
481 {0x15, 0x01, 0x08, 0x08, "On" },
482
483 {0 , 0xfe, 0 , 4 , "Coin A" },
484 {0x15, 0x01, 0x30, 0x00, "4 Coins 1 Credit" },
485 {0x15, 0x01, 0x30, 0x10, "3 Coins 1 Credit" },
486 {0x15, 0x01, 0x30, 0x20, "2 Coins 1 Credit" },
487 {0x15, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
488
489 {0 , 0xfe, 0 , 4 , "Coin B" },
490 {0x15, 0x01, 0xc0, 0x00, "4 Coins 1 Credit" },
491 {0x15, 0x01, 0xc0, 0x40, "3 Coins 1 Credit" },
492 {0x15, 0x01, 0xc0, 0x80, "2 Coins 1 Credit" },
493 {0x15, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
494
495 // Dip 2
496 {0 , 0xfe, 0 , 4 , "Difficulty" },
497 {0x16, 0x01, 0x03, 0x02, "Easy" },
498 {0x16, 0x01, 0x03, 0x03, "Medium" },
499 {0x16, 0x01, 0x03, 0x01, "Hard" },
500 {0x16, 0x01, 0x03, 0x00, "Hardest" },
501
502 {0 , 0xfe, 0 , 4 , "Bonus Life" },
503 {0x16, 0x01, 0x0c, 0x0c, "50k and every 150k" },
504 {0x16, 0x01, 0x0c, 0x08, "70k and every 200k" },
505 {0x16, 0x01, 0x0c, 0x04, "50k only" },
506 {0x16, 0x01, 0x0c, 0x00, "100k only" },
507
508 {0 , 0xfe, 0 , 4 , "Lives" },
509 {0x16, 0x01, 0x30, 0x00, "2" },
510 {0x16, 0x01, 0x30, 0x30, "3" },
511 {0x16, 0x01, 0x30, 0x10, "4" },
512 {0x16, 0x01, 0x30, 0x20, "5" },
513
514 {0 , 0xfe, 0 , 2 , "Allow Continue" },
515 {0x16, 0x01, 0x80, 0x80, "Off" },
516 {0x16, 0x01, 0x80, 0x00, "On" },
517 };
518
519 STDDIPINFO(Twinhawku)
520
521 static struct BurnDIPInfo DaisenpuDIPList[]=
522 {
523 // Default Values
524 {0x15, 0xff, 0xff, 0xfe, NULL },
525 {0x16, 0xff, 0xff, 0x7f, NULL },
526
527 // Dip 1
528 {0 , 0xfe, 0 , 2 , "Cabinet" },
529 {0x15, 0x01, 0x01, 0x00, "Upright" },
530 {0x15, 0x01, 0x01, 0x01, "Cocktail" },
531
532 {0 , 0xfe, 0 , 2 , "Flip Screen" },
533 {0x15, 0x01, 0x02, 0x02, "Off" },
534 {0x15, 0x01, 0x02, 0x00, "On" },
535
536 {0 , 0xfe, 0 , 2 , "Service Mode" },
537 {0x15, 0x01, 0x04, 0x04, "Off" },
538 {0x15, 0x01, 0x04, 0x00, "On" },
539
540 {0 , 0xfe, 0 , 2 , "Demo Sounds" },
541 {0x15, 0x01, 0x08, 0x00, "Off" },
542 {0x15, 0x01, 0x08, 0x08, "On" },
543
544 {0 , 0xfe, 0 , 4 , "Coin A" },
545 {0x15, 0x01, 0x30, 0x10, "2 Coins 1 Credit" },
546 {0x15, 0x01, 0x30, 0x30, "1 Coin 1 Credit" },
547 {0x15, 0x01, 0x30, 0x00, "2 Coins 3 Credits" },
548 {0x15, 0x01, 0x30, 0x20, "1 Coin 2 Credits" },
549
550 {0 , 0xfe, 0 , 4 , "Coin B" },
551 {0x15, 0x01, 0xc0, 0x40, "2 Coins 1 Credit" },
552 {0x15, 0x01, 0xc0, 0xc0, "1 Coin 1 Credit" },
553 {0x15, 0x01, 0xc0, 0x00, "2 Coins 3 Credits" },
554 {0x15, 0x01, 0xc0, 0x80, "1 Coin 2 Credits" },
555
556 // Dip 2
557 {0 , 0xfe, 0 , 4 , "Difficulty" },
558 {0x16, 0x01, 0x03, 0x02, "Easy" },
559 {0x16, 0x01, 0x03, 0x03, "Medium" },
560 {0x16, 0x01, 0x03, 0x01, "Hard" },
561 {0x16, 0x01, 0x03, 0x00, "Hardest" },
562
563 {0 , 0xfe, 0 , 4 , "Bonus Life" },
564 {0x16, 0x01, 0x0c, 0x08, "50k and every 150k" },
565 {0x16, 0x01, 0x0c, 0x0c, "70k and every 200k" },
566 {0x16, 0x01, 0x0c, 0x04, "100k only" },
567 {0x16, 0x01, 0x0c, 0x00, "None" },
568
569 {0 , 0xfe, 0 , 4 , "Lives" },
570 {0x16, 0x01, 0x30, 0x00, "2" },
571 {0x16, 0x01, 0x30, 0x30, "3" },
572 {0x16, 0x01, 0x30, 0x10, "4" },
573 {0x16, 0x01, 0x30, 0x20, "5" },
574
575 {0 , 0xfe, 0 , 2 , "Allow Continue" },
576 {0x16, 0x01, 0x80, 0x80, "Off" },
577 {0x16, 0x01, 0x80, 0x00, "On" },
578 };
579
580 STDDIPINFO(Daisenpu)
581
582 // Taito C-Chip BIOS
583 static struct BurnRomInfo emptyRomDesc[] = {
584 { "", 0, 0, 0 },
585 };
586
587 static struct BurnRomInfo cchipRomDesc[] = {
588 #if !defined ROM_VERIFY
589 { "cchip_upd78c11.bin", 0x01000, 0x43021521, BRF_BIOS | TAITO_CCHIP_BIOS},
590 #endif
591 };
592
593 static struct BurnRomInfo BallbrosRomDesc[] = {
594 { "10a", 0x20000, 0x4af0e858, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
595 { "5a", 0x20000, 0x0b983a69, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
596
597 { "8d", 0x10000, 0xd1c515af, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
598
599 { "3", 0x20000, 0xec3e0537, BRF_GRA | TAITO_SPRITESA },
600 { "2", 0x20000, 0xbb441717, BRF_GRA | TAITO_SPRITESA },
601 { "1", 0x20000, 0x8196d624, BRF_GRA | TAITO_SPRITESA },
602 { "0", 0x20000, 0x1cc584e5, BRF_GRA | TAITO_SPRITESA },
603
604 { "east-11", 0x80000, 0x92111f96, BRF_SND | TAITO_YM2610A },
605 { "east-10", 0x80000, 0xca0ac419, BRF_SND | TAITO_YM2610B },
606 };
607
608 STD_ROM_PICK(Ballbros)
609 STD_ROM_FN(Ballbros)
610
611 static struct BurnRomInfo GigandesRomDesc[] = {
612 { "east_1.10a", 0x20000, 0xae74e4e5, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
613 { "east_3.5a", 0x20000, 0x8bcf2116, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
614 { "east_2.8a", 0x20000, 0xdd94b4d0, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
615 { "east_4.3a", 0x20000, 0xa647310a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
616
617 { "east_5.17d", 0x10000, 0xb24ab5f4, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
618
619 { "east_8.3f", 0x80000, 0x75eece28, BRF_GRA | TAITO_SPRITESA },
620 { "east_7.3h", 0x80000, 0xb179a76a, BRF_GRA | TAITO_SPRITESA },
621 { "east_9.3j", 0x80000, 0x5c5e6898, BRF_GRA | TAITO_SPRITESA },
622 { "east_6.3k", 0x80000, 0x52db30e9, BRF_GRA | TAITO_SPRITESA },
623
624 { "east-11.16f", 0x80000, 0x92111f96, BRF_SND | TAITO_YM2610A },
625 { "east-10.16e", 0x80000, 0xca0ac419, BRF_SND | TAITO_YM2610B },
626 };
627
628 STD_ROM_PICK(Gigandes)
629 STD_ROM_FN(Gigandes)
630
631 static struct BurnRomInfo GigandesaRomDesc[] = {
632 { "east-1.10a", 0x20000, 0x290c50e0, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
633 { "east-3.5a", 0x20000, 0x9cef82af, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
634 { "east_2.8a", 0x20000, 0xdd94b4d0, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
635 { "east_4.3a", 0x20000, 0xa647310a, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
636
637 { "east_5.17d", 0x10000, 0xb24ab5f4, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
638
639 { "east_8.3f", 0x80000, 0x75eece28, BRF_GRA | TAITO_SPRITESA },
640 { "east_7.3h", 0x80000, 0xb179a76a, BRF_GRA | TAITO_SPRITESA },
641 { "east_9.3j", 0x80000, 0x5c5e6898, BRF_GRA | TAITO_SPRITESA },
642 { "east_6.3k", 0x80000, 0x52db30e9, BRF_GRA | TAITO_SPRITESA },
643
644 { "east-11.16f", 0x80000, 0x92111f96, BRF_SND | TAITO_YM2610A },
645 { "east-10.16e", 0x80000, 0xca0ac419, BRF_SND | TAITO_YM2610B },
646 };
647
648 STD_ROM_PICK(Gigandesa)
649 STD_ROM_FN(Gigandesa)
650
651 static struct BurnRomInfo KyustrkrRomDesc[] = {
652 { "pe.9a", 0x20000, 0x082b5f96, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
653 { "po.4a", 0x20000, 0x0100361e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
654
655 { "ic.18d", 0x10000, 0x92cfb788, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
656
657 { "m-8-3.u3", 0x20000, 0x1c4084e6, BRF_GRA | TAITO_SPRITESA },
658 { "m-8-2.u4", 0x20000, 0xada21c4d, BRF_GRA | TAITO_SPRITESA },
659 { "m-8-1.u5", 0x20000, 0x9d95aad6, BRF_GRA | TAITO_SPRITESA },
660 { "m-8-0.u6", 0x20000, 0x0dfb6ed3, BRF_GRA | TAITO_SPRITESA },
661
662 { "m-8-5.u2", 0x20000, 0xd9d90e0a, BRF_SND | TAITO_YM2610A },
663 { "m-8-4.u1", 0x20000, 0xd3f6047a, BRF_SND | TAITO_YM2610B },
664 };
665
666 STD_ROM_PICK(Kyustrkr)
667 STD_ROM_FN(Kyustrkr)
668
669 static struct BurnRomInfo SupermanRomDesc[] = {
670 { "b61_09.a10", 0x20000, 0x640f1d58, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
671 { "b61_07.a5", 0x20000, 0xfddb9953, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
672 { "b61_08.a8", 0x20000, 0x79fc028e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
673 { "b61_13.a3", 0x20000, 0x9f446a44, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
674
675 { "b61_10.d18", 0x10000, 0x6efe79e8, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
676
677 { "b61-14.f1", 0x80000, 0x89368c3e, BRF_GRA | TAITO_SPRITESA },
678 { "b61-15.h1", 0x80000, 0x910cc4f9, BRF_GRA | TAITO_SPRITESA },
679 { "b61-16.j1", 0x80000, 0x3622ed2f, BRF_GRA | TAITO_SPRITESA },
680 { "b61-17.k1", 0x80000, 0xc34f27e0, BRF_GRA | TAITO_SPRITESA },
681
682 { "b61-01.e18", 0x80000, 0x3cf99786, BRF_SND | TAITO_YM2610B },
683
684 { "b61_11.m11", 0x02000, 0x3bc5d44b, BRF_ESS | BRF_PRG | TAITO_CCHIP_EEPROM },
685 };
686
687 STDROMPICKEXT(Superman, Superman, cchip)
688 STD_ROM_FN(Superman)
689
690 static struct BurnRomInfo SupermanuRomDesc[] = {
691 { "b61_09.a10", 0x20000, 0x640f1d58, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
692 { "b61_07.a5", 0x20000, 0xfddb9953, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
693 { "b61_08.a8", 0x20000, 0x79fc028e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
694 { "b61_12.a3", 0x20000, 0x064d3bfe, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
695
696 { "b61_10.d18", 0x10000, 0x6efe79e8, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
697
698 { "b61-14.f1", 0x80000, 0x89368c3e, BRF_GRA | TAITO_SPRITESA },
699 { "b61-15.h1", 0x80000, 0x910cc4f9, BRF_GRA | TAITO_SPRITESA },
700 { "b61-16.j1", 0x80000, 0x3622ed2f, BRF_GRA | TAITO_SPRITESA },
701 { "b61-17.k1", 0x80000, 0xc34f27e0, BRF_GRA | TAITO_SPRITESA },
702
703 { "b61-01.e18", 0x80000, 0x3cf99786, BRF_SND | TAITO_YM2610B },
704
705 { "b61_11.m11", 0x02000, 0x3bc5d44b, BRF_ESS | BRF_PRG | TAITO_CCHIP_EEPROM },
706 };
707
708 STDROMPICKEXT(Supermanu, Supermanu, cchip)
709 STD_ROM_FN(Supermanu)
710
711 static struct BurnRomInfo SupermanjRomDesc[] = {
712 { "b61_09.a10", 0x20000, 0x640f1d58, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
713 { "b61_07.a5", 0x20000, 0xfddb9953, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
714 { "b61_08.a8", 0x20000, 0x79fc028e, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
715 { "b61_06.a3", 0x20000, 0x714a0b68, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
716
717 { "b61_10.d18", 0x10000, 0x6efe79e8, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
718
719 { "b61-14.f1", 0x80000, 0x89368c3e, BRF_GRA | TAITO_SPRITESA },
720 { "b61-15.h1", 0x80000, 0x910cc4f9, BRF_GRA | TAITO_SPRITESA },
721 { "b61-16.j1", 0x80000, 0x3622ed2f, BRF_GRA | TAITO_SPRITESA },
722 { "b61-17.k1", 0x80000, 0xc34f27e0, BRF_GRA | TAITO_SPRITESA },
723
724 { "b61-01.e18", 0x80000, 0x3cf99786, BRF_SND | TAITO_YM2610B },
725
726 { "b61_11.m11", 0x02000, 0x3bc5d44b, BRF_ESS | BRF_PRG | TAITO_CCHIP_EEPROM },
727 };
728
729 STDROMPICKEXT(Supermanj, Supermanj, cchip)
730 STD_ROM_FN(Supermanj)
731
732 static struct BurnRomInfo TwinhawkRomDesc[] = {
733 { "b87-11.u7", 0x20000, 0xfc84a399, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
734 { "b87-10.u5", 0x20000, 0x17181706, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
735
736 { "b87-07.13e", 0x08000, 0xe2e0efa0, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
737
738 { "b87-02.3h", 0x80000, 0x89ad43a0, BRF_GRA | TAITO_SPRITESA },
739 { "b87-01.3f", 0x80000, 0x81e82ae1, BRF_GRA | TAITO_SPRITESA },
740 { "b87-04.3k", 0x80000, 0x958434b6, BRF_GRA | TAITO_SPRITESA },
741 { "b87-03.3j", 0x80000, 0xce155ae0, BRF_GRA | TAITO_SPRITESA },
742
743 };
744
745 STD_ROM_PICK(Twinhawk)
746 STD_ROM_FN(Twinhawk)
747
748 static struct BurnRomInfo TwinhawkuRomDesc[] = {
749 { "b87-09.u7", 0x20000, 0x7e6267c7, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
750 { "b87-08.u5", 0x20000, 0x31d9916f, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
751
752 { "b87-07.13e", 0x08000, 0xe2e0efa0, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
753
754 { "b87-02.3h", 0x80000, 0x89ad43a0, BRF_GRA | TAITO_SPRITESA },
755 { "b87-01.3f", 0x80000, 0x81e82ae1, BRF_GRA | TAITO_SPRITESA },
756 { "b87-04.3k", 0x80000, 0x958434b6, BRF_GRA | TAITO_SPRITESA },
757 { "b87-03.3j", 0x80000, 0xce155ae0, BRF_GRA | TAITO_SPRITESA },
758
759 };
760
761 STD_ROM_PICK(Twinhawku)
762 STD_ROM_FN(Twinhawku)
763
764 static struct BurnRomInfo DaisenpuRomDesc[] = {
765 { "b87-06.u7", 0x20000, 0xcf236100, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
766 { "b87-05.u5", 0x20000, 0x7f15edc7, BRF_ESS | BRF_PRG | TAITO_68KROM1_BYTESWAP },
767
768 { "b87-07.13e", 0x08000, 0xe2e0efa0, BRF_ESS | BRF_PRG | TAITO_Z80ROM1 },
769
770 { "b87-02.3h", 0x80000, 0x89ad43a0, BRF_GRA | TAITO_SPRITESA },
771 { "b87-01.3f", 0x80000, 0x81e82ae1, BRF_GRA | TAITO_SPRITESA },
772 { "b87-04.3k", 0x80000, 0x958434b6, BRF_GRA | TAITO_SPRITESA },
773 { "b87-03.3j", 0x80000, 0xce155ae0, BRF_GRA | TAITO_SPRITESA },
774
775 };
776
777 STD_ROM_PICK(Daisenpu)
STD_ROM_FN(Daisenpu)778 STD_ROM_FN(Daisenpu)
779
780 static INT32 MemIndex()
781 {
782 UINT8 *Next; Next = TaitoMem;
783
784 Taito68KRom1 = Next; Next += Taito68KRom1Size;
785 TaitoZ80Rom1 = Next; Next += TaitoZ80Rom1Size;
786 TaitoYM2610ARom = Next; Next += TaitoYM2610ARomSize;
787 TaitoYM2610BRom = Next; Next += TaitoYM2610BRomSize;
788
789 cchip_rom = Next; Next += TaitoCCHIPBIOSSize;
790 cchip_eeprom = Next; Next += TaitoCCHIPEEPROMSize;
791
792 TaitoRamStart = Next;
793
794 Taito68KRam1 = Next; Next += 0x004000;
795 TaitoZ80Ram1 = Next; Next += 0x002000;
796 TaitoPaletteRam = Next; Next += 0x001000;
797 TaitoSpriteRam = Next; Next += 0x000800;
798 TaitoSpriteRam2 = Next; Next += 0x004000;
799
800 TaitoRamEnd = Next;
801
802 TaitoSpritesA = Next; Next += TaitoNumSpriteA * TaitoSpriteAWidth * TaitoSpriteAHeight;
803 TaitoPalette = (UINT32*)Next; Next += 0x00800 * sizeof(UINT32);
804
805 TaitoMemEnd = Next;
806
807 return 0;
808 }
809
TaitoX68KReadByte(UINT32 a)810 UINT8 __fastcall TaitoX68KReadByte(UINT32 a)
811 {
812 if (cchip_active) {
813 CCHIP_READ(0x900000)
814 }
815
816 switch (a) {
817 case 0x500001: {
818 return TaitoDip[0] & 0x0f;
819 }
820
821 case 0x500003: {
822 return (TaitoDip[0] & 0xf0) >> 4;
823 }
824
825 case 0x500005: {
826 return TaitoDip[1] & 0x0f;
827 }
828
829 case 0x500007: {
830 return (TaitoDip[1] & 0xf0) >> 4;
831 }
832
833 case 0x800003: {
834 return TC0140SYTCommRead();
835 }
836
837 case 0x900001: {
838 return TaitoInput[0];
839 }
840
841 case 0x900003: {
842 return TaitoInput[1];
843 }
844
845 case 0x900005: {
846 return TaitoInput[2];
847 }
848
849 default: {
850 bprintf(PRINT_NORMAL, _T("68K #1 Read byte => %06X\n"), a);
851 }
852 }
853
854 return 0;
855 }
856
TaitoX68KWriteByte(UINT32 a,UINT8 d)857 void __fastcall TaitoX68KWriteByte(UINT32 a, UINT8 d)
858 {
859 if (cchip_active) {
860 CCHIP_WRITE(0x900000)
861 }
862
863 switch (a) {
864 case 0x300000:
865 case 0x300001: {
866 //???
867 return;
868 }
869
870 case 0x400000:
871 case 0x400001: {
872 //nop
873 return;
874 }
875
876 case 0x600000:
877 case 0x600001: {
878 //nop
879 return;
880 }
881
882 case 0x700000:
883 case 0x700001: {
884 //nop
885 return;
886 }
887
888 case 0x800001: {
889 TC0140SYTPortWrite(d);
890 return;
891 }
892
893 case 0x800003: {
894 TC0140SYTCommWrite(d);
895 return;
896 }
897
898 case 0x900009: {
899 //coin counter/lockout etc.
900 return;
901 }
902
903 case 0xc00000:
904 case 0xc00001: {
905 //???
906 return;
907 }
908
909 default: {
910 bprintf(PRINT_NORMAL, _T("68K #1 Write byte => %06X, %02X\n"), a, d);
911 }
912 }
913 }
914
TaitoX68KReadWord(UINT32 a)915 UINT16 __fastcall TaitoX68KReadWord(UINT32 a)
916 {
917 switch (a) {
918 case 0x500000: {
919 return TaitoDip[0] & 0x0f;
920 }
921
922 case 0x500002: {
923 return (TaitoDip[0] & 0xf0) >> 4;
924 }
925
926 case 0x500004: {
927 return TaitoDip[1] & 0x0f;
928 }
929
930 case 0x500006: {
931 return (TaitoDip[1] & 0xf0) >> 4;
932 }
933
934 default: {
935 bprintf(PRINT_NORMAL, _T("68K #1 Read word => %06X\n"), a);
936 }
937 }
938
939 return 0;
940 }
941
TaitoXZ80Read(UINT16 a)942 UINT8 __fastcall TaitoXZ80Read(UINT16 a)
943 {
944 switch (a) {
945 case 0xe000: {
946 return BurnYM2610Read(0);
947 }
948
949 case 0xe001: {
950 return BurnYM2610Read(1);
951 }
952
953 case 0xe002: {
954 return BurnYM2610Read(2);
955 }
956
957 case 0xe201: {
958 return TC0140SYTSlaveCommRead();
959 }
960
961 default: {
962 bprintf(PRINT_NORMAL, _T("Z80 Read => %04X\n"), a);
963 }
964 }
965
966 return 0;
967 }
968
TaitoXZ80Write(UINT16 a,UINT8 d)969 void __fastcall TaitoXZ80Write(UINT16 a, UINT8 d)
970 {
971 switch (a) {
972 case 0xe000: {
973 BurnYM2610Write(0, d);
974 return;
975 }
976
977 case 0xe001: {
978 BurnYM2610Write(1, d);
979 return;
980 }
981
982 case 0xe002: {
983 BurnYM2610Write(2, d);
984 return;
985 }
986
987 case 0xe003: {
988 BurnYM2610Write(3, d);
989 return;
990 }
991
992 case 0xe200: {
993 TC0140SYTSlavePortWrite(d);
994 return;
995 }
996
997 case 0xe201: {
998 TC0140SYTSlaveCommWrite(d);
999 return;
1000 }
1001
1002 case 0xe400:
1003 case 0xe401:
1004 case 0xe402:
1005 case 0xe403: {
1006 //nop
1007 return;
1008 }
1009
1010 case 0xe600: {
1011 //???
1012 return;
1013 }
1014
1015 case 0xee00: {
1016 //nop
1017 return;
1018 }
1019
1020 case 0xf000: {
1021 //nop
1022 return;
1023 }
1024
1025 case 0xf200: {
1026 TaitoZ80Bank = (d - 1) & 3;
1027 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
1028 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
1029 return;
1030 }
1031
1032 default: {
1033 bprintf(PRINT_NORMAL, _T("Z80 Write => %04X, %02X\n"), a, d);
1034 }
1035 }
1036 }
1037
TwinhawkZ80Read(UINT16 a)1038 UINT8 __fastcall TwinhawkZ80Read(UINT16 a)
1039 {
1040 switch (a) {
1041 case 0xe001: {
1042 return BurnYM2151Read();
1043 }
1044
1045 case 0xe201: {
1046 return TC0140SYTSlaveCommRead();
1047 }
1048
1049 default: {
1050 bprintf(PRINT_NORMAL, _T("Z80 Read => %04X\n"), a);
1051 }
1052 }
1053
1054 return 0;
1055 }
1056
TwinhawkZ80Write(UINT16 a,UINT8 d)1057 void __fastcall TwinhawkZ80Write(UINT16 a, UINT8 d)
1058 {
1059 switch (a) {
1060 case 0xe000: {
1061 BurnYM2151SelectRegister(d);
1062 return;
1063 }
1064
1065 case 0xe001: {
1066 BurnYM2151WriteRegister(d);
1067 return;
1068 }
1069
1070 case 0xe200: {
1071 TC0140SYTSlavePortWrite(d);
1072 return;
1073 }
1074
1075 case 0xe201: {
1076 TC0140SYTSlaveCommWrite(d);
1077 return;
1078 }
1079
1080 case 0xf200: {
1081 TaitoZ80Bank = (d - 1) & 3;
1082 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
1083 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
1084 return;
1085 }
1086
1087 default: {
1088 bprintf(PRINT_NORMAL, _T("Z80 Write => %04X, %02X\n"), a, d);
1089 }
1090 }
1091 }
1092
TaitoXFMIRQHandler(INT32,INT32 nStatus)1093 static void TaitoXFMIRQHandler(INT32, INT32 nStatus)
1094 {
1095 ZetSetIRQLine(0, (nStatus) ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE);
1096 }
1097
TaitoXYM2151IRQHandler(INT32 Irq)1098 static void TaitoXYM2151IRQHandler(INT32 Irq)
1099 {
1100 ZetSetIRQLine(0, (Irq) ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE);
1101 }
1102
1103 static INT32 SpritePlaneOffsets[4] = { 0x800008, 0x800000, 8, 0 };
1104 static INT32 SpriteXOffsets[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 128, 129, 130, 131, 132, 133, 134, 135 };
1105 static INT32 SpriteYOffsets[16] = { 0, 16, 32, 48, 64, 80, 96, 112, 256, 272, 288, 304, 320, 336, 352, 368 };
1106 static INT32 BallbrosPlaneOffsets[4] = { 0x300000, 0x200000, 0x100000, 0 };
1107 static INT32 BallbrosXOffsets[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 64, 65, 66, 67, 68, 69, 70, 71 };
1108 static INT32 BallbrosYOffsets[16] = { 0, 8, 16, 24, 32, 40, 48, 56, 128, 136, 144, 152, 160, 168, 176, 184 };
1109
TaitoXInit(INT32 nSoundType)1110 static INT32 TaitoXInit(INT32 nSoundType)
1111 {
1112 INT32 nLen;
1113
1114 TaitoNum68Ks = 1;
1115 TaitoNumZ80s = 1;
1116 if (nSoundType == 1) {
1117 TaitoNumYM2151 = 1;
1118 } else {
1119 TaitoNumYM2610 = 1;
1120 }
1121
1122 TaitoLoadRoms(0);
1123
1124 // Allocate and Blank all required memory
1125 TaitoMem = NULL;
1126 MemIndex();
1127 nLen = TaitoMemEnd - (UINT8 *)0;
1128 if ((TaitoMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
1129 memset(TaitoMem, 0, nLen);
1130 MemIndex();
1131
1132 if (TaitoLoadRoms(1)) return 1;
1133
1134 TC0140SYTInit(0);
1135
1136 // Setup the 68000 emulation
1137 SekInit(0, 0x68000);
1138 SekOpen(0);
1139 SekMapMemory(Taito68KRom1 , 0x000000, Taito68KRom1Size - 1, MAP_ROM);
1140 SekMapMemory(TaitoPaletteRam , 0xb00000, 0xb00fff, MAP_RAM);
1141 SekMapMemory(TaitoSpriteRam , 0xd00000, 0xd007ff, MAP_RAM);
1142 SekMapMemory(TaitoSpriteRam2 , 0xe00000, 0xe03fff, MAP_RAM);
1143 SekMapMemory(Taito68KRam1 , 0xf00000, 0xf03fff, MAP_RAM);
1144 SekSetReadByteHandler(0, TaitoX68KReadByte);
1145 SekSetWriteByteHandler(0, TaitoX68KWriteByte);
1146 SekSetReadWordHandler(0, TaitoX68KReadWord);
1147 SekClose();
1148
1149 // Setup the Z80 emulation
1150 ZetInit(0);
1151 ZetOpen(0);
1152 if (nSoundType == 1) {
1153 ZetSetReadHandler(TwinhawkZ80Read);
1154 ZetSetWriteHandler(TwinhawkZ80Write);
1155 } else {
1156 ZetSetReadHandler(TaitoXZ80Read);
1157 ZetSetWriteHandler(TaitoXZ80Write);
1158 }
1159 ZetMapArea(0x0000, 0x3fff, 0, TaitoZ80Rom1 );
1160 ZetMapArea(0x0000, 0x3fff, 2, TaitoZ80Rom1 );
1161 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 );
1162 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 );
1163 ZetMapArea(0xc000, 0xdfff, 0, TaitoZ80Ram1 );
1164 ZetMapArea(0xc000, 0xdfff, 1, TaitoZ80Ram1 );
1165 ZetMapArea(0xc000, 0xdfff, 2, TaitoZ80Ram1 );
1166 ZetClose();
1167
1168 if (nSoundType == 1) {
1169 BurnYM2151Init(4000000);
1170 BurnYM2151SetIrqHandler(&TaitoXYM2151IRQHandler);
1171 BurnYM2151SetRoute(BURN_SND_YM2151_YM2151_ROUTE_1, 0.45, BURN_SND_ROUTE_LEFT);
1172 BurnYM2151SetRoute(BURN_SND_YM2151_YM2151_ROUTE_2, 0.45, BURN_SND_ROUTE_RIGHT);
1173 } else {
1174 if (nSoundType == 2) {
1175 BurnYM2610Init(8000000, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, NULL, 0);
1176 } else {
1177 BurnYM2610Init(8000000, TaitoYM2610BRom, (INT32*)&TaitoYM2610BRomSize, TaitoYM2610ARom, (INT32*)&TaitoYM2610ARomSize, &TaitoXFMIRQHandler, 0);
1178 }
1179 BurnTimerAttachZet(4000000);
1180 BurnYM2610SetRoute(BURN_SND_YM2610_YM2610_ROUTE_1, 1.00, BURN_SND_ROUTE_LEFT);
1181 BurnYM2610SetRoute(BURN_SND_YM2610_YM2610_ROUTE_2, 1.00, BURN_SND_ROUTE_RIGHT);
1182 BurnYM2610SetRoute(BURN_SND_YM2610_AY8910_ROUTE, 0.25, BURN_SND_ROUTE_BOTH);
1183 }
1184
1185 GenericTilesInit();
1186
1187 nTaitoCyclesTotal[0] = (8000000) / 60;
1188 nTaitoCyclesTotal[1] = (4000000) / 60;
1189
1190 if (nScreenHeight == 224) TaitoYOffset = 16;
1191 if (nScreenHeight == 240) TaitoYOffset = 8;
1192 TaitoIrqLine = 2;
1193
1194 TaitoDoReset();
1195
1196 return 0;
1197 }
1198
BallbrosInit()1199 static INT32 BallbrosInit()
1200 {
1201 TaitoSpriteAModulo = 0x100;
1202 TaitoSpriteANumPlanes = 4;
1203 TaitoSpriteAWidth = 16;
1204 TaitoSpriteAHeight = 16;
1205 TaitoSpriteAPlaneOffsets = BallbrosPlaneOffsets;
1206 TaitoSpriteAXOffsets = BallbrosXOffsets;
1207 TaitoSpriteAYOffsets = BallbrosYOffsets;
1208 TaitoNumSpriteA = 0x1000;
1209
1210 return TaitoXInit(2);
1211 }
1212
GigandesInit()1213 static INT32 GigandesInit()
1214 {
1215 TaitoSpriteAModulo = 0x200;
1216 TaitoSpriteANumPlanes = 4;
1217 TaitoSpriteAWidth = 16;
1218 TaitoSpriteAHeight = 16;
1219 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
1220 TaitoSpriteAXOffsets = SpriteXOffsets;
1221 TaitoSpriteAYOffsets = SpriteYOffsets;
1222 TaitoNumSpriteA = 0x4000;
1223
1224 return TaitoXInit(2);
1225 }
1226
SupermanInit()1227 static INT32 SupermanInit()
1228 {
1229 INT32 nRet;
1230
1231 TaitoSpriteAModulo = 0x200;
1232 TaitoSpriteANumPlanes = 4;
1233 TaitoSpriteAWidth = 16;
1234 TaitoSpriteAHeight = 16;
1235 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
1236 TaitoSpriteAXOffsets = SpriteXOffsets;
1237 TaitoSpriteAYOffsets = SpriteYOffsets;
1238 TaitoNumSpriteA = 0x4000;
1239
1240 nRet = TaitoXInit(0);
1241
1242 cchip_init();
1243
1244 TaitoIrqLine = 6;
1245
1246 return nRet;
1247 }
1248
TwinhawkInit()1249 static INT32 TwinhawkInit()
1250 {
1251 TaitoSpriteAModulo = 0x200;
1252 TaitoSpriteANumPlanes = 4;
1253 TaitoSpriteAWidth = 16;
1254 TaitoSpriteAHeight = 16;
1255 TaitoSpriteAPlaneOffsets = SpritePlaneOffsets;
1256 TaitoSpriteAXOffsets = SpriteXOffsets;
1257 TaitoSpriteAYOffsets = SpriteYOffsets;
1258 TaitoNumSpriteA = 0x4000;
1259
1260 return TaitoXInit(1);
1261 }
1262
TaitoXExit()1263 static INT32 TaitoXExit()
1264 {
1265 return TaitoExit();
1266 }
1267
pal5bit(UINT8 bits)1268 static inline UINT8 pal5bit(UINT8 bits)
1269 {
1270 bits &= 0x1f;
1271 return (bits << 3) | (bits >> 2);
1272 }
1273
CalcCol(UINT16 nColour)1274 inline static UINT32 CalcCol(UINT16 nColour)
1275 {
1276 INT32 r, g, b;
1277
1278 r = pal5bit(BURN_ENDIAN_SWAP_INT16(nColour) >> 10);
1279 g = pal5bit(BURN_ENDIAN_SWAP_INT16(nColour) >> 5);
1280 b = pal5bit(BURN_ENDIAN_SWAP_INT16(nColour) >> 0);
1281
1282 return BurnHighCol(r, g, b, 0);
1283 }
1284
TaitoXCalcPalette()1285 static void TaitoXCalcPalette()
1286 {
1287 INT32 i;
1288 UINT16* ps;
1289 UINT32* pd;
1290
1291 for (i = 0, ps = (UINT16*)TaitoPaletteRam, pd = TaitoPalette; i < 0x0800; i++, ps++, pd++) {
1292 *pd = CalcCol(*ps);
1293 }
1294 }
1295
TaitoXDrawBgSprites()1296 static void TaitoXDrawBgSprites()
1297 {
1298 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
1299 UINT16 *SpriteRam2 = (UINT16*)TaitoSpriteRam2;
1300
1301 INT32 Offs, Col, x, y, Code, Colour, xFlip, yFlip, sx, sy, yOffs;
1302
1303 INT32 Ctrl = BURN_ENDIAN_SWAP_INT16(SpriteRam[0x300]);
1304 INT32 Ctrl2 = BURN_ENDIAN_SWAP_INT16(SpriteRam[0x301]);
1305
1306 INT32 Flip = Ctrl & 0x40;
1307 INT32 NumCol = Ctrl2 & 0x000f;
1308
1309 UINT16 *src = SpriteRam2 + (((Ctrl2 ^ (~Ctrl2 << 1)) & 0x40) ? 0x1000 : 0 );
1310
1311 INT32 Upper = (BURN_ENDIAN_SWAP_INT16(SpriteRam[0x302]) & 0xff) + (BURN_ENDIAN_SWAP_INT16(SpriteRam[0x303]) & 0xff) * 256;
1312 INT32 Col0;
1313 switch (Ctrl & 0x0f) {
1314 case 0x01: Col0 = 0x4; break;
1315 case 0x06: Col0 = 0x8; break;
1316
1317 default: Col0 = 0x0;
1318 }
1319
1320 yOffs = Flip ? 1 : -1;
1321
1322 if (NumCol == 1) NumCol = 16;
1323
1324 for (Col = 0; Col < NumCol; Col++) {
1325 x = BURN_ENDIAN_SWAP_INT16(SpriteRam[(Col * 0x20 + 0x08 + 0x400) / 2]) & 0xff;
1326 y = BURN_ENDIAN_SWAP_INT16(SpriteRam[(Col * 0x20 + 0x00 + 0x400) / 2]) & 0xff;
1327
1328 for (Offs = 0; Offs < 0x20; Offs++) {
1329 Code = BURN_ENDIAN_SWAP_INT16(src[((Col + Col0) & 0x0f) * 0x20 + Offs + 0x400]);
1330 Colour = BURN_ENDIAN_SWAP_INT16(src[((Col + Col0) & 0x0f) * 0x20 + Offs + 0x600]);
1331
1332 xFlip = Code & 0x8000;
1333 yFlip = Code & 0x4000;
1334
1335 sx = x + (Offs & 1) * 16;
1336 sy = -(y + yOffs) + (Offs / 2) * 16;
1337
1338 if (Upper & (1 << Col)) sx += 256;
1339
1340 if (Flip) {
1341 sy = 0xf0 - sy;
1342 xFlip = !xFlip;
1343 yFlip = !yFlip;
1344 }
1345
1346 Colour = (Colour >> (16 - 5)) % 0x100;
1347 Code &= (TaitoNumSpriteA - 1);
1348
1349 sx = ((sx + 16) & 0x1ff) - 16;
1350 sy = ((sy + 8) & 0xff) - 8;
1351
1352 sy -= TaitoYOffset;
1353
1354 if (sx > 16 && sx < (nScreenWidth - 16) && sy > 16 && sy < (nScreenHeight - 16)) {
1355 if (xFlip) {
1356 if (yFlip) {
1357 Render16x16Tile_Mask_FlipXY(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1358 } else {
1359 Render16x16Tile_Mask_FlipX(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1360 }
1361 } else {
1362 if (yFlip) {
1363 Render16x16Tile_Mask_FlipY(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1364 } else {
1365 Render16x16Tile_Mask(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1366 }
1367 }
1368 } else {
1369 if (xFlip) {
1370 if (yFlip) {
1371 Render16x16Tile_Mask_FlipXY_Clip(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1372 } else {
1373 Render16x16Tile_Mask_FlipX_Clip(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1374 }
1375 } else {
1376 if (yFlip) {
1377 Render16x16Tile_Mask_FlipY_Clip(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1378 } else {
1379 Render16x16Tile_Mask_Clip(pTransDraw, Code, sx, sy, Colour, 4, 0, 0, TaitoSpritesA);
1380 }
1381 }
1382 }
1383 }
1384 }
1385 }
1386
TaitoXDrawSprites()1387 static void TaitoXDrawSprites()
1388 {
1389 UINT16 *SpriteRam = (UINT16*)TaitoSpriteRam;
1390 UINT16 *SpriteRam2 = (UINT16*)TaitoSpriteRam2;
1391
1392 INT32 Offset, Code, x, y, xFlip, yFlip, Colour;
1393 INT32 Ctrl = BURN_ENDIAN_SWAP_INT16(SpriteRam[0x300]);
1394 INT32 Ctrl2 = BURN_ENDIAN_SWAP_INT16(SpriteRam[0x301]);
1395 INT32 Flip = Ctrl & 0x40;
1396 UINT16 *src = SpriteRam2 + (((Ctrl2 ^ (~Ctrl2 << 1)) & 0x40) ? 0x1000 : 0);
1397
1398 for (Offset = (0x400 - 2) / 2; Offset >= 0; Offset-- ) {
1399 Code = BURN_ENDIAN_SWAP_INT16(src[Offset]);
1400 x = BURN_ENDIAN_SWAP_INT16(src[Offset + 0x200]);
1401 y = BURN_ENDIAN_SWAP_INT16(SpriteRam[Offset]) & 0xff;
1402 xFlip = Code & 0x8000;
1403 yFlip = Code & 0x4000;
1404
1405 Colour = (x >> (16 - 5) ) % 0x100;
1406
1407 Code &= (TaitoNumSpriteA - 1);
1408
1409 if (Flip) {
1410 y = 0xf0 - y;
1411 xFlip = !xFlip;
1412 yFlip = !yFlip;
1413 }
1414
1415 y = 0xf0 - y;
1416 x = ((x + 16) & 0x1ff) - 16;
1417 y = ((y + 8) & 0xff) - 8;
1418
1419 y -= TaitoYOffset - 2;
1420
1421 if (x > 16 && x < (nScreenWidth - 16) && y > 16 && y < (nScreenHeight - 16)) {
1422 if (xFlip) {
1423 if (yFlip) {
1424 Render16x16Tile_Mask_FlipXY(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1425 } else {
1426 Render16x16Tile_Mask_FlipX(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1427 }
1428 } else {
1429 if (yFlip) {
1430 Render16x16Tile_Mask_FlipY(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1431 } else {
1432 Render16x16Tile_Mask(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1433 }
1434 }
1435 } else {
1436 if (xFlip) {
1437 if (yFlip) {
1438 Render16x16Tile_Mask_FlipXY_Clip(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1439 } else {
1440 Render16x16Tile_Mask_FlipX_Clip(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1441 }
1442 } else {
1443 if (yFlip) {
1444 Render16x16Tile_Mask_FlipY_Clip(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1445 } else {
1446 Render16x16Tile_Mask_Clip(pTransDraw, Code, x, y, Colour, 4, 0, 0, TaitoSpritesA);
1447 }
1448 }
1449 }
1450 }
1451
1452 }
1453
TaitoXDraw()1454 static INT32 TaitoXDraw()
1455 {
1456 TaitoXCalcPalette();
1457
1458 for (INT32 i = 0; i < nScreenHeight * nScreenWidth; i++) {
1459 pTransDraw[i] = 0x1f0;
1460 }
1461
1462 TaitoXDrawBgSprites();
1463 TaitoXDrawSprites();
1464 BurnTransferCopy(TaitoPalette);
1465
1466 return 0;
1467 }
1468
TaitoXFrame()1469 static INT32 TaitoXFrame()
1470 {
1471 INT32 nInterleave = 10;
1472
1473 if (TaitoReset) TaitoDoReset();
1474
1475 TaitoXMakeInputs();
1476
1477 nTaitoCyclesDone[0] = nTaitoCyclesDone[1] = 0;
1478
1479 SekNewFrame();
1480 ZetNewFrame();
1481
1482 for (INT32 i = 0; i < nInterleave; i++) {
1483 INT32 nCurrentCPU, nNext;
1484
1485 nCurrentCPU = 0;
1486 SekOpen(nCurrentCPU);
1487 nNext = (i + 1) * nTaitoCyclesTotal[nCurrentCPU] / nInterleave;
1488 nTaitoCyclesSegment = nNext - nTaitoCyclesDone[nCurrentCPU];
1489 nTaitoCyclesDone[nCurrentCPU] += SekRun(nTaitoCyclesSegment);
1490 if (i == (nInterleave - 1)) SekSetIRQLine(TaitoIrqLine, CPU_IRQSTATUS_AUTO);
1491 SekClose();
1492
1493 nCurrentCPU = 1;
1494 ZetOpen(0);
1495 BurnTimerUpdate(i * (nTaitoCyclesTotal[1] / nInterleave));
1496 ZetClose();
1497
1498 if (cchip_active) { // superman
1499 cchip_run(8000000 / 60 / nInterleave);
1500 if (i == (nInterleave - 1)) cchip_interrupt();
1501 }
1502 }
1503
1504 ZetOpen(0);
1505 BurnTimerEndFrame(nTaitoCyclesTotal[1]);
1506 if (pBurnSoundOut) {
1507 BurnYM2610Update(pBurnSoundOut, nBurnSoundLen);
1508 }
1509 ZetClose();
1510
1511 if (pBurnDraw) TaitoXDraw();
1512
1513 return 0;
1514 }
1515
TwinhawkFrame()1516 static INT32 TwinhawkFrame()
1517 {
1518 INT32 nInterleave = 10;
1519 INT32 nSoundBufferPos = 0;
1520
1521 if (TaitoReset) TaitoDoReset();
1522
1523 TaitoXMakeInputs();
1524
1525 nTaitoCyclesDone[0] = nTaitoCyclesDone[1] = 0;
1526
1527 SekNewFrame();
1528 ZetNewFrame();
1529
1530 for (INT32 i = 0; i < nInterleave; i++) {
1531 INT32 nCurrentCPU, nNext;
1532
1533 // Run 68000
1534 nCurrentCPU = 0;
1535 SekOpen(0);
1536 nNext = (i + 1) * nTaitoCyclesTotal[nCurrentCPU] / nInterleave;
1537 nTaitoCyclesSegment = nNext - nTaitoCyclesDone[nCurrentCPU];
1538 nTaitoCyclesDone[nCurrentCPU] += SekRun(nTaitoCyclesSegment);
1539 if (i == 9) SekSetIRQLine(2, CPU_IRQSTATUS_AUTO);
1540 SekClose();
1541
1542 // Run Z80
1543 nCurrentCPU = 1;
1544 ZetOpen(0);
1545 nNext = (i + 1) * nTaitoCyclesTotal[nCurrentCPU] / nInterleave;
1546 nTaitoCyclesSegment = nNext - nTaitoCyclesDone[nCurrentCPU];
1547 nTaitoCyclesSegment = ZetRun(nTaitoCyclesSegment);
1548 nTaitoCyclesDone[nCurrentCPU] += nTaitoCyclesSegment;
1549 ZetClose();
1550
1551 // Render sound segment
1552 if (pBurnSoundOut) {
1553 INT32 nSegmentLength = nBurnSoundLen / nInterleave;
1554 INT16* pSoundBuf = pBurnSoundOut + (nSoundBufferPos << 1);
1555 ZetOpen(0);
1556 BurnYM2151Render(pSoundBuf, nSegmentLength);
1557 ZetClose();
1558 nSoundBufferPos += nSegmentLength;
1559 }
1560 }
1561
1562 // Make sure the buffer is entirely filled.
1563 if (pBurnSoundOut) {
1564 INT32 nSegmentLength = nBurnSoundLen - nSoundBufferPos;
1565 INT16* pSoundBuf = pBurnSoundOut + (nSoundBufferPos << 1);
1566 if (nSegmentLength) {
1567 ZetOpen(0);
1568 BurnYM2151Render(pSoundBuf, nSegmentLength);
1569 ZetClose();
1570 }
1571 }
1572
1573 if (pBurnDraw) TaitoXDraw();
1574
1575 return 0;
1576 }
1577
TaitoXScan(INT32 nAction,INT32 * pnMin)1578 static INT32 TaitoXScan(INT32 nAction, INT32 *pnMin)
1579 {
1580 struct BurnArea ba;
1581
1582 if (pnMin != NULL) { // Return minimum compatible version
1583 *pnMin = 0x029683;
1584 }
1585
1586 if (nAction & ACB_MEMORY_RAM) {
1587 memset(&ba, 0, sizeof(ba));
1588 ba.Data = TaitoRamStart;
1589 ba.nLen = TaitoRamEnd-TaitoRamStart;
1590 ba.szName = "All Ram";
1591 BurnAcb(&ba);
1592 }
1593
1594 TaitoICScan(nAction);
1595
1596 if (nAction & ACB_DRIVER_DATA) {
1597 SekScan(nAction);
1598 ZetScan(nAction);
1599
1600 if (TaitoNumYM2610) BurnYM2610Scan(nAction, pnMin);
1601 if (TaitoNumYM2151) BurnYM2151Scan(nAction, pnMin);
1602
1603 SCAN_VAR(TaitoInput);
1604 SCAN_VAR(TaitoZ80Bank);
1605 SCAN_VAR(TaitoSoundLatch);
1606 SCAN_VAR(nTaitoCyclesDone);
1607 SCAN_VAR(nTaitoCyclesSegment);
1608 }
1609
1610 if (nAction & ACB_WRITE) {
1611 ZetOpen(0);
1612 ZetMapArea(0x4000, 0x7fff, 0, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
1613 ZetMapArea(0x4000, 0x7fff, 2, TaitoZ80Rom1 + 0x4000 + (TaitoZ80Bank * 0x4000));
1614 ZetClose();
1615 }
1616
1617 return 0;
1618 }
1619
1620 struct BurnDriver BurnDrvBallbros = {
1621 "ballbros", NULL, NULL, NULL, "1992",
1622 "Balloon Brothers\0", NULL, "East Technology", "Taito X",
1623 NULL, NULL, NULL, NULL,
1624 BDF_GAME_WORKING, 2, HARDWARE_TAITO_TAITOX, GBF_PUZZLE, 0,
1625 NULL, BallbrosRomInfo, BallbrosRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, BallbrosDIPInfo,
1626 BallbrosInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1627 NULL, 0x800, 384, 240, 4, 3
1628 };
1629
1630 struct BurnDriver BurnDrvGigandes = {
1631 "gigandes", NULL, NULL, NULL, "1989",
1632 "Gigandes\0", NULL, "East Technology", "Taito X",
1633 NULL, NULL, NULL, NULL,
1634 BDF_GAME_WORKING, 2, HARDWARE_TAITO_TAITOX, GBF_HORSHOOT, 0,
1635 NULL, GigandesRomInfo, GigandesRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, GigandesDIPInfo,
1636 GigandesInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1637 NULL, 0x800, 384, 240, 4, 3
1638 };
1639
1640 struct BurnDriver BurnDrvGigandesa = {
1641 "gigandesa", "gigandes", NULL, NULL, "1989",
1642 "Gigandes (earlier)\0", NULL, "East Technology", "Taito X",
1643 NULL, NULL, NULL, NULL,
1644 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_TAITO_TAITOX, GBF_HORSHOOT, 0,
1645 NULL, GigandesaRomInfo, GigandesaRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, GigandesDIPInfo,
1646 GigandesInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1647 NULL, 0x800, 384, 240, 4, 3
1648 };
1649
1650 struct BurnDriver BurnDrvKyustrkr = {
1651 "kyustrkr", NULL, NULL, NULL, "1989",
1652 "Last Striker / Kyuukyoku no Striker\0", NULL, "East Technology", "Taito X",
1653 L"Last Striker\0Final \u7A76\u6975 \u306E Striker\0", NULL, NULL, NULL,
1654 BDF_GAME_WORKING | BDF_ORIENTATION_FLIPPED, 2, HARDWARE_TAITO_TAITOX, GBF_SPORTSFOOTBALL, 0,
1655 NULL, KyustrkrRomInfo, KyustrkrRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, KyustrkrDIPInfo,
1656 BallbrosInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1657 NULL, 0x800, 384, 240, 4, 3
1658 };
1659
1660 struct BurnDriver BurnDrvSuperman = {
1661 "superman", NULL, "cchip", NULL, "1988",
1662 "Superman (World)\0", NULL, "Taito Corporation", "Taito X",
1663 NULL, NULL, NULL, NULL,
1664 BDF_GAME_WORKING, 2, HARDWARE_TAITO_TAITOX, GBF_SCRFIGHT, 0,
1665 NULL, SupermanRomInfo, SupermanRomName, NULL, NULL, NULL, NULL, SupermanInputInfo, SupermanDIPInfo,
1666 SupermanInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1667 NULL, 0x800, 384, 240, 4, 3
1668 };
1669
1670 struct BurnDriver BurnDrvSupermanu = {
1671 "supermanu", "superman", "cchip", NULL, "1988",
1672 "Superman (US)\0", NULL, "Taito Corporation", "Taito X",
1673 NULL, NULL, NULL, NULL,
1674 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_TAITO_TAITOX, GBF_SCRFIGHT, 0,
1675 NULL, SupermanuRomInfo, SupermanuRomName, NULL, NULL, NULL, NULL, SupermanInputInfo, SupermanuDIPInfo,
1676 SupermanInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1677 NULL, 0x800, 384, 240, 4, 3
1678 };
1679
1680 struct BurnDriver BurnDrvSupermanj = {
1681 "supermanj", "superman", "cchip", NULL, "1988",
1682 "Superman (Japan)\0", NULL, "Taito Corporation", "Taito X",
1683 NULL, NULL, NULL, NULL,
1684 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_TAITO_TAITOX, GBF_SCRFIGHT, 0,
1685 NULL, SupermanjRomInfo, SupermanjRomName, NULL, NULL, NULL, NULL, SupermanInputInfo, SupermanjDIPInfo,
1686 SupermanInit, TaitoXExit, TaitoXFrame, TaitoXDraw, TaitoXScan,
1687 NULL, 0x800, 384, 240, 4, 3
1688 };
1689
1690 struct BurnDriver BurnDrvTwinhawk = {
1691 "twinhawk", NULL, NULL, NULL, "1989",
1692 "Twin Hawk (World)\0", NULL, "Taito Corporation Japan", "Taito X",
1693 NULL, NULL, NULL, NULL,
1694 BDF_GAME_WORKING | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_TAITO_TAITOX, GBF_VERSHOOT, 0,
1695 NULL, TwinhawkRomInfo, TwinhawkRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, TwinhawkDIPInfo,
1696 TwinhawkInit, TaitoXExit, TwinhawkFrame, TaitoXDraw, TaitoXScan,
1697 NULL, 0x800, 224, 384, 3, 4
1698 };
1699
1700 struct BurnDriver BurnDrvTwinhawku = {
1701 "twinhawku", "twinhawk", NULL, NULL, "1989",
1702 "Twin Hawk (US)\0", NULL, "Taito America Corporation", "Taito X",
1703 NULL, NULL, NULL, NULL,
1704 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_TAITO_TAITOX, GBF_VERSHOOT, 0,
1705 NULL, TwinhawkuRomInfo, TwinhawkuRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, TwinhawkuDIPInfo,
1706 TwinhawkInit, TaitoXExit, TwinhawkFrame, TaitoXDraw, TaitoXScan,
1707 NULL, 0x800, 224, 384, 3, 4
1708 };
1709
1710 struct BurnDriver BurnDrvDaisenpu = {
1711 "daisenpu", "twinhawk", NULL, NULL, "1989",
1712 "Daisenpu (Japan)\0", NULL, "Taito Corporation", "Taito X",
1713 L"\u5927\u65CB\u98A8 (Japan)\0Daisenpu\0", NULL, NULL, NULL,
1714 BDF_GAME_WORKING | BDF_CLONE | BDF_ORIENTATION_VERTICAL, 2, HARDWARE_TAITO_TAITOX, GBF_VERSHOOT, 0,
1715 NULL, DaisenpuRomInfo, DaisenpuRomName, NULL, NULL, NULL, NULL, TwinhawkInputInfo, DaisenpuDIPInfo,
1716 TwinhawkInit, TaitoXExit, TwinhawkFrame, TaitoXDraw, TaitoXScan,
1717 NULL, 0x800, 224, 384, 3, 4
1718 };
1719