1 // FB Alpha Markham / Strength & Skill / Ikki driver module
2 // Based on MAME driver by UKI
3
4 #include "tiles_generic.h"
5 #include "z80_intf.h"
6 #include "sn76496.h"
7
8 static UINT8 *AllMem;
9 static UINT8 *AllRam;
10 static UINT8 *MemEnd;
11 static UINT8 *RamEnd;
12 static UINT8 *DrvZ80ROM0;
13 static UINT8 *DrvZ80ROM1;
14 static UINT8 *DrvGfxROM0;
15 static UINT8 *DrvGfxROM1;
16 static UINT8 *DrvColPROM;
17 static UINT8 *DrvVidPROM;
18 static UINT8 *DrvZ80RAM0;
19 static UINT8 *DrvVidRAM;
20 static UINT8 *DrvSprRAM;
21 static UINT8 *DrvShareRAM;
22 static UINT8 *DrvTransTab;
23 static UINT8 *DrvProtROM;
24
25 static UINT32 *DrvPalette;
26 static UINT8 DrvRecalc;
27
28 static UINT8 *scroll;
29 static INT32 irq_source;
30 static UINT8 scroll_control;
31 static UINT8 flipscreen;
32
33 static UINT8 packet_buffer[2];
34 static UINT8 packet_reset;
35 static UINT8 packet_write_pos;
36
37 static INT32 irq_scanline[4];
38
39 static UINT8 DrvJoy1[8];
40 static UINT8 DrvJoy2[8];
41 static UINT8 DrvJoy3[8];
42 static UINT8 DrvDips[3];
43 static UINT8 DrvInputs[3];
44 static UINT8 DrvReset;
45
46 static struct BurnInputInfo MarkhamInputList[] = {
47 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
48 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 2, "p1 start" },
49 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
50 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
51 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 1, "p1 left" },
52 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 0, "p1 right" },
53 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
54 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
55
56 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
57 {"P2 Start", BIT_DIGITAL, DrvJoy3 + 3, "p2 start" },
58 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
59 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
60 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 1, "p2 left" },
61 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 0, "p2 right" },
62 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
63 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
64
65 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
66 {"Service", BIT_DIGITAL, DrvJoy3 + 7, "service" },
67 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
68 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
69 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
70 };
71
72 STDINPUTINFO(Markham)
73
74 static struct BurnInputInfo StrnskilInputList[] = {
75 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
76 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 2, "p1 start" },
77 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
78 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
79 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 1, "p1 left" },
80 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 0, "p1 right" },
81 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
82 {"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 2" },
83
84 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
85 {"P2 Start", BIT_DIGITAL, DrvJoy3 + 3, "p2 start" },
86 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
87 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
88 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 1, "p2 left" },
89 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 0, "p2 right" },
90 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
91 {"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 2" },
92
93 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
94 {"Service", BIT_DIGITAL, DrvJoy3 + 7, "service" },
95 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
96 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
97 {"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
98 };
99
100 STDINPUTINFO(Strnskil)
101
102 static struct BurnInputInfo BanbamInputList[] = {
103 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
104 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 2, "p1 start" },
105 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
106 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
107 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 1, "p1 left" },
108 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 0, "p1 right" },
109 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
110
111 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
112 {"P2 Start", BIT_DIGITAL, DrvJoy3 + 3, "p2 start" },
113 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
114 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
115 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 1, "p2 left" },
116 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 0, "p2 right" },
117 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
118
119 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
120 {"Service", BIT_DIGITAL, DrvJoy3 + 7, "service" },
121 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
122 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
123 };
124
125 STDINPUTINFO(Banbam)
126
127 static struct BurnInputInfo IkkiInputList[] = {
128 {"P1 Coin", BIT_DIGITAL, DrvJoy3 + 0, "p1 coin" },
129 {"P1 Start", BIT_DIGITAL, DrvJoy3 + 2, "p1 start" },
130 {"P1 Up", BIT_DIGITAL, DrvJoy1 + 2, "p1 up" },
131 {"P1 Down", BIT_DIGITAL, DrvJoy1 + 3, "p1 down" },
132 {"P1 Left", BIT_DIGITAL, DrvJoy1 + 1, "p1 left" },
133 {"P1 Right", BIT_DIGITAL, DrvJoy1 + 0, "p1 right" },
134 {"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 4, "p1 fire 1" },
135
136 {"P2 Coin", BIT_DIGITAL, DrvJoy3 + 1, "p2 coin" },
137 {"P2 Start", BIT_DIGITAL, DrvJoy3 + 3, "p2 start" },
138 {"P2 Up", BIT_DIGITAL, DrvJoy2 + 2, "p2 up" },
139 {"P2 Down", BIT_DIGITAL, DrvJoy2 + 3, "p2 down" },
140 {"P2 Left", BIT_DIGITAL, DrvJoy2 + 1, "p2 left" },
141 {"P2 Right", BIT_DIGITAL, DrvJoy2 + 0, "p2 right" },
142 {"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 4, "p2 fire 1" },
143
144 {"Reset", BIT_DIGITAL, &DrvReset, "reset" },
145 {"Service", BIT_DIGITAL, DrvJoy3 + 7, "service" },
146 {"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
147 {"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
148 };
149
150 STDINPUTINFO(Ikki)
151
152 static struct BurnDIPInfo MarkhamDIPList[]=
153 {
154 {0x12, 0xff, 0xff, 0x02, NULL },
155 {0x13, 0xff, 0xff, 0x7e, NULL },
156 {0x14, 0xff, 0xff, 0x00, NULL },
157
158 {0 , 0xfe, 0 , 2, "Lives" },
159 {0x12, 0x01, 0x01, 0x00, "3" },
160 {0x12, 0x01, 0x01, 0x01, "5" },
161
162 {0 , 0xfe, 0 , 1, "Cabinet" },
163 {0x12, 0x01, 0x02, 0x02, "Upright" },
164 // {0x12, 0x01, 0x02, 0x00, "Cocktail" },
165
166 {0 , 0xfe, 0 , 1, "Flip Screen" },
167 {0x12, 0x01, 0x04, 0x00, "Off" },
168 // {0x12, 0x01, 0x04, 0x04, "On" },
169
170 {0 , 0xfe, 0 , 2, "Coin Chutes" },
171 {0x12, 0x01, 0x08, 0x00, "Individual" },
172 {0x12, 0x01, 0x08, 0x08, "Common" },
173
174 {0 , 0xfe, 0 , 16, "Coin1 / Coin2" },
175 {0x12, 0x01, 0xf0, 0x00, "1C 1C / 1C 1C" },
176 {0x12, 0x01, 0xf0, 0x10, "2C 1C / 2C 1C" },
177 {0x12, 0x01, 0xf0, 0x20, "2C 1C / 1C 3C" },
178 {0x12, 0x01, 0xf0, 0x30, "1C 1C / 1C 2C" },
179 {0x12, 0x01, 0xf0, 0x40, "1C 1C / 1C 3C" },
180 {0x12, 0x01, 0xf0, 0x50, "1C 1C / 1C 4C" },
181 {0x12, 0x01, 0xf0, 0x60, "1C 1C / 1C 5C" },
182 {0x12, 0x01, 0xf0, 0x70, "1C 1C / 1C 6C" },
183 {0x12, 0x01, 0xf0, 0x80, "1C 2C / 1C 2C" },
184 {0x12, 0x01, 0xf0, 0x90, "1C 2C / 1C 4C" },
185 {0x12, 0x01, 0xf0, 0xa0, "1C 2C / 1C 5C" },
186 {0x12, 0x01, 0xf0, 0xb0, "1C 2C / 1C 10C" },
187 {0x12, 0x01, 0xf0, 0xc0, "1C 2C / 1C 11C" },
188 {0x12, 0x01, 0xf0, 0xd0, "1C 2C / 1C 12C" },
189 {0x12, 0x01, 0xf0, 0xe0, "1C 2C / 1C 6C" },
190 {0x12, 0x01, 0xf0, 0xf0, "Free Play" },
191
192 {0 , 0xfe, 0 , 4, "Bonus Life" },
193 {0x13, 0x01, 0x03, 0x00, "None" },
194 {0x13, 0x01, 0x03, 0x01, "20000" },
195 {0x13, 0x01, 0x03, 0x02, "20000, Every 50000" },
196 {0x13, 0x01, 0x03, 0x03, "20000, Every 80000" },
197
198 {0 , 0xfe, 0 , 2, "Demo Sounds" },
199 {0x13, 0x01, 0x04, 0x00, "Off" },
200 {0x13, 0x01, 0x04, 0x04, "On" },
201
202 {0 , 0xfe, 0 , 2, "Freeze" },
203 {0x13, 0x01, 0x80, 0x00, "Off" },
204 {0x13, 0x01, 0x80, 0x80, "On" },
205
206 {0 , 0xfe, 0 , 2, "Service Mode" },
207 {0x14, 0x01, 0x10, 0x00, "Off" },
208 {0x14, 0x01, 0x10, 0x10, "On" },
209 };
210
211 STDDIPINFO(Markham)
212
213 static struct BurnDIPInfo StrnskilDIPList[]=
214 {
215 {0x12, 0xff, 0xff, 0x00, NULL },
216 {0x13, 0xff, 0xff, 0x00, NULL },
217 {0x14, 0xff, 0xff, 0x00, NULL },
218
219 {0 , 0xfe, 0 , 2, "Demo Sounds" },
220 {0x12, 0x01, 0x01, 0x01, "Off" },
221 {0x12, 0x01, 0x01, 0x00, "On" },
222
223 {0 , 0xfe, 0 , 16, "Coin1 / Coin2" },
224 {0x12, 0x01, 0xf0, 0x00, "1C 1C / 1C 1C" },
225 {0x12, 0x01, 0xf0, 0x10, "2C 1C / 2C 1C" },
226 {0x12, 0x01, 0xf0, 0x20, "2C 1C / 1C 3C" },
227 {0x12, 0x01, 0xf0, 0x30, "1C 1C / 1C 2C" },
228 {0x12, 0x01, 0xf0, 0x40, "1C 1C / 1C 3C" },
229 {0x12, 0x01, 0xf0, 0x50, "1C 1C / 1C 4C" },
230 {0x12, 0x01, 0xf0, 0x60, "1C 1C / 1C 5C" },
231 {0x12, 0x01, 0xf0, 0x70, "1C 1C / 1C 6C" },
232 {0x12, 0x01, 0xf0, 0x80, "1C 2C / 1C 2C" },
233 {0x12, 0x01, 0xf0, 0x90, "1C 2C / 1C 4C" },
234 {0x12, 0x01, 0xf0, 0xa0, "1C 2C / 1C 5C" },
235 {0x12, 0x01, 0xf0, 0xb0, "1C 2C / 1C 10C" },
236 {0x12, 0x01, 0xf0, 0xc0, "1C 2C / 1C 11C" },
237 {0x12, 0x01, 0xf0, 0xd0, "1C 2C / 1C 12C" },
238 {0x12, 0x01, 0xf0, 0xe0, "1C 2C / 1C 6C" },
239 {0x12, 0x01, 0xf0, 0xf0, "Free Play" },
240
241 {0 , 0xfe, 0 , 2, "Difficulty" },
242 {0x13, 0x01, 0x01, 0x00, "Normal" },
243 {0x13, 0x01, 0x01, 0x01, "Hard" },
244
245 {0 , 0xfe, 0 , 2, "Freeze" },
246 {0x13, 0x01, 0x80, 0x00, "Off" },
247 {0x13, 0x01, 0x80, 0x80, "On" },
248
249 {0 , 0xfe, 0 , 2, "Service Mode" },
250 {0x14, 0x01, 0x20, 0x00, "Off" },
251 {0x14, 0x01, 0x20, 0x20, "On" },
252 };
253
254 STDDIPINFO(Strnskil)
255
256 static struct BurnDIPInfo BanbamDIPList[]=
257 {
258 {0x10, 0xff, 0xff, 0x02, NULL },
259 {0x11, 0xff, 0xff, 0x70, NULL },
260
261 {0 , 0xfe, 0 , 2, "Lives" },
262 {0x10, 0x01, 0x01, 0x00, "3" },
263 {0x10, 0x01, 0x01, 0x01, "5" },
264
265 {0 , 0xfe, 0 , 1, "Cabinet" },
266 {0x10, 0x01, 0x02, 0x02, "Upright" },
267 // {0x10, 0x01, 0x02, 0x00, "Cocktail" },
268
269 {0 , 0xfe, 0 , 1, "Flip Screen" },
270 {0x10, 0x01, 0x04, 0x00, "Off" },
271 // {0x10, 0x01, 0x04, 0x04, "On" },
272
273 {0 , 0xfe, 0 , 16, "Coin1 / Coin2" },
274 {0x10, 0x01, 0xf0, 0x00, "1C 1C / 1C 1C" },
275 {0x10, 0x01, 0xf0, 0x10, "2C 1C / 2C 1C" },
276 {0x10, 0x01, 0xf0, 0x20, "2C 1C / 1C 3C" },
277 {0x10, 0x01, 0xf0, 0x30, "1C 1C / 1C 2C" },
278 {0x10, 0x01, 0xf0, 0x40, "1C 1C / 1C 3C" },
279 {0x10, 0x01, 0xf0, 0x50, "1C 1C / 1C 4C" },
280 {0x10, 0x01, 0xf0, 0x60, "1C 1C / 1C 5C" },
281 {0x10, 0x01, 0xf0, 0x70, "1C 1C / 1C 6C" },
282 {0x10, 0x01, 0xf0, 0x80, "1C 2C / 1C 2C" },
283 {0x10, 0x01, 0xf0, 0x90, "1C 2C / 1C 4C" },
284 {0x10, 0x01, 0xf0, 0xa0, "1C 2C / 1C 5C" },
285 {0x10, 0x01, 0xf0, 0xb0, "1C 2C / 1C 10C" },
286 {0x10, 0x01, 0xf0, 0xc0, "1C 2C / 1C 11C" },
287 {0x10, 0x01, 0xf0, 0xd0, "1C 2C / 1C 12C" },
288 {0x10, 0x01, 0xf0, 0xe0, "1C 2C / 1C 6C" },
289 {0x10, 0x01, 0xf0, 0xf0, "Free Play" },
290
291 {0 , 0xfe, 0 , 2, "Demo Sounds" },
292 {0x11, 0x01, 0x01, 0x01, "Off" },
293 {0x11, 0x01, 0x01, 0x00, "On" },
294
295 {0 , 0xfe, 0 , 4, "Bonus Life" },
296 {0x11, 0x01, 0x06, 0x00, "20000 50000" },
297 {0x11, 0x01, 0x06, 0x02, "20000 80000" },
298 {0x11, 0x01, 0x06, 0x04, "20000" },
299 {0x11, 0x01, 0x06, 0x06, "None" },
300
301 {0 , 0xfe, 0 , 2, "Second Practice" },
302 {0x11, 0x01, 0x08, 0x08, "Off" },
303 {0x11, 0x01, 0x08, 0x00, "On" },
304
305 {0 , 0xfe, 0 , 2, "Freeze" },
306 {0x11, 0x01, 0x80, 0x00, "Off" },
307 {0x11, 0x01, 0x80, 0x80, "On" },
308 };
309
310 STDDIPINFO(Banbam)
311
312 static struct BurnDIPInfo IkkiDIPList[]=
313 {
314 {0x10, 0xff, 0xff, 0x00, NULL },
315 {0x11, 0xff, 0xff, 0x00, NULL },
316
317 {0 , 0xfe, 0 , 2, "Lives" },
318 {0x10, 0x01, 0x01, 0x00, "3" },
319 {0x10, 0x01, 0x01, 0x01, "5" },
320
321 {0 , 0xfe, 0 , 2, "2 Player Game" },
322 {0x10, 0x01, 0x02, 0x00, "2 Credits" },
323 {0x10, 0x01, 0x02, 0x02, "1 Credit" },
324
325 {0 , 0xfe, 0 , 1, "Flip Screen" },
326 {0x10, 0x01, 0x04, 0x00, "Off" },
327 // {0x10, 0x01, 0x04, 0x04, "On" },
328
329 {0 , 0xfe, 0 , 16, "Coin1 / Coin2" },
330 {0x10, 0x01, 0xf0, 0x00, "1 Coin 1 Credit / 1 Coin 1 Credit " },
331 {0x10, 0x01, 0xf0, 0x10, "2 Coins 1 Credit / 2 Coins 1 Credit " },
332 {0x10, 0x01, 0xf0, 0x20, "2 Coins 1 Credit / 1 Coin 3 Credits" },
333 {0x10, 0x01, 0xf0, 0x30, "1 Coin 1 Credit / 1 Coin 2 Credits" },
334 {0x10, 0x01, 0xf0, 0x40, "1 Coin 1 Credit / 1 Coin 3 Credits" },
335 {0x10, 0x01, 0xf0, 0x50, "1 Coin 1 Credit / 1 Coin 4 Credits" },
336 {0x10, 0x01, 0xf0, 0x60, "1 Coin 1 Credit / 1 Coin 5 Credits" },
337 {0x10, 0x01, 0xf0, 0x70, "1 Coin 1 Credit / 1 Coin 6 Credits" },
338 {0x10, 0x01, 0xf0, 0x80, "1 Coin 2 Credits / 1 Coin 2 Credits" },
339 {0x10, 0x01, 0xf0, 0x90, "1 Coin 2 Credits / 1 Coin 4 Credits" },
340 {0x10, 0x01, 0xf0, 0xa0, "1 Coin 2 Credits / 1 Coin 5 Credits" },
341 {0x10, 0x01, 0xf0, 0xb0, "1 Coin 2 Credits / 1 Coin 10 Credits" },
342 {0x10, 0x01, 0xf0, 0xc0, "1 Coin 2 Credits / 1 Coin 11 Credits" },
343 {0x10, 0x01, 0xf0, 0xd0, "1 Coin 2 Credits / 1 Coin 12 Credits" },
344 {0x10, 0x01, 0xf0, 0xe0, "1 Coin 2 Credits / 1 Coin 6 Credits" },
345 {0x10, 0x01, 0xf0, 0xf0, "Free_Play" },
346
347 {0 , 0xfe, 0 , 2, "Demo Sounds" },
348 {0x11, 0x01, 0x01, 0x01, "Off" },
349 {0x11, 0x01, 0x01, 0x00, "On" },
350
351 {0 , 0xfe, 0 , 4, "Difficulty" },
352 {0x11, 0x01, 0x06, 0x00, "1 (Normal)" },
353 {0x11, 0x01, 0x06, 0x02, "2" },
354 {0x11, 0x01, 0x06, 0x04, "3" },
355 {0x11, 0x01, 0x06, 0x06, "4 (Difficult)" },
356
357 {0 , 0xfe, 0 , 2, "Freeze" },
358 {0x11, 0x01, 0x80, 0x00, "Off" },
359 {0x11, 0x01, 0x80, 0x80, "On" },
360 };
361
STDDIPINFO(Ikki)362 STDDIPINFO(Ikki)
363
364 static void __fastcall markham_main_write(UINT16 address, UINT8 data)
365 {
366 switch (address)
367 {
368 case 0xe00c:
369 scroll[0] = data;
370 return;
371
372 case 0xe00d:
373 scroll[1] = data;
374 return;
375
376 case 0xe00e:
377 flipscreen = data & 1;
378 return;
379 }
380 }
381
markham_main_read(UINT16 address)382 static UINT8 __fastcall markham_main_read(UINT16 address)
383 {
384 switch (address)
385 {
386 case 0xe000:
387 return DrvDips[1];
388
389 case 0xe001:
390 return DrvDips[0];
391
392 case 0xe002:
393 return DrvInputs[0];
394
395 case 0xe003:
396 return DrvInputs[1];
397
398 case 0xe005:
399 return (DrvInputs[2] & ~0x10) | (DrvDips[2] & 0x10);
400 }
401
402 return 0;
403 }
404
banbam_protection_read()405 static UINT8 banbam_protection_read()
406 {
407 UINT8 init = packet_buffer[0] & 0x0f;
408 UINT8 arg = packet_buffer[1] & 0x0f;
409
410 if (packet_reset)
411 {
412 return 0xa5;
413 }
414 else if (init == 0x08 || init == 0x05)
415 {
416 UINT8 comm = packet_buffer[1] & 0xf0;
417
418 switch (comm)
419 {
420 case 0x30:
421 return (DrvProtROM[0x799 + (arg * 4)] & 0xf) | comm;
422
423 case 0x40:
424 return (DrvProtROM[0x7C5 + (arg * 4)] & 0xf) | comm;
425
426 case 0x60:
427 return (BurnRandom() & 0xf) | comm;
428
429 case 0x70:
430 return ((arg + 1) & 0xf) | comm;
431
432 case 0xb0:
433 return ((arg + 3) & 0xf) | comm;
434 }
435
436 return comm;
437 }
438
439 return arg | 0xf0;
440 }
441
banbam_protection_write(UINT8 data)442 static void banbam_protection_write(UINT8 data)
443 {
444 packet_buffer[packet_write_pos & 1] = data;
445 packet_write_pos ^= 1;
446 packet_reset = packet_write_pos;
447 }
448
strnskil_main_write(UINT16 address,UINT8 data)449 static void __fastcall strnskil_main_write(UINT16 address, UINT8 data)
450 {
451 switch (address)
452 {
453 case 0xd808:
454 scroll_control = data >> 5;
455 flipscreen = data & 8;
456 return;
457
458 case 0xd809:
459 return; // nop
460
461 case 0xd80a:
462 case 0xd80b:
463 scroll[address & 1] = data;
464 return;
465
466 case 0xd80d:
467 banbam_protection_write(data);
468 return;
469 }
470 }
471
strnskil_main_read(UINT16 address)472 static UINT8 __fastcall strnskil_main_read(UINT16 address)
473 {
474 switch (address)
475 {
476 case 0xd800:
477 return irq_source;
478
479 case 0xd801:
480 return DrvDips[0];
481
482 case 0xd802:
483 return DrvDips[1];
484
485 case 0xd803:
486 return (DrvInputs[2] & ~0x20) | (DrvDips[2] & 0x20);
487
488 case 0xd804:
489 return DrvInputs[0];
490
491 case 0xd805:
492 return DrvInputs[1];
493
494 case 0xd806:
495 return banbam_protection_read();
496 }
497
498 return 0;
499 }
500
ikki_main_write(UINT16 address,UINT8 data)501 static void __fastcall ikki_main_write(UINT16 address, UINT8 data)
502 {
503 switch (address)
504 {
505 case 0xe008:
506 flipscreen = data & 4;
507 return;
508
509 case 0xe009:
510 return; // coin counter
511
512 case 0xe00a:
513 case 0xe00b:
514 scroll[address & 1] = data;
515 return;
516 }
517 }
518
ikki_main_read(UINT16 address)519 static UINT8 __fastcall ikki_main_read(UINT16 address)
520 {
521 switch (address)
522 {
523 case 0xe000:
524 return irq_source << 1;
525
526 case 0xe001:
527 return DrvDips[0];
528
529 case 0xe002:
530 return DrvDips[1];
531
532 case 0xe003:
533 return DrvInputs[2];
534
535 case 0xe004:
536 return DrvInputs[0];
537
538 case 0xe005:
539 return DrvInputs[1];
540 }
541
542 return 0;
543 }
544
markham_sound_write(UINT16 address,UINT8 data)545 static void __fastcall markham_sound_write(UINT16 address, UINT8 data)
546 {
547 switch (address)
548 {
549 case 0xc000:
550 SN76496Write(0, data);
551 return;
552
553 case 0xc001:
554 SN76496Write(1, data);
555 return;
556 }
557 }
558
strnskil_sound_write(UINT16 address,UINT8 data)559 static void __fastcall strnskil_sound_write(UINT16 address, UINT8 data)
560 {
561 switch (address)
562 {
563 case 0xd801:
564 SN76496Write(0, data);
565 return;
566
567 case 0xd802:
568 SN76496Write(1, data);
569 return;
570 }
571 }
572
tilemap_callback(markham)573 static tilemap_callback( markham )
574 {
575 INT32 attr = DrvVidRAM[offs * 2 + 0];
576
577 TILE_SET_INFO(0, DrvVidRAM[offs * 2 + 1] | ((attr & 0x60) << 3), (attr & 0x1f) | ((attr & 0x80) >> 2), 0);
578 }
579
DrvDoReset()580 static INT32 DrvDoReset()
581 {
582 memset (AllRam, 0, RamEnd - AllRam);
583
584 ZetReset(0);
585 ZetReset(1);
586
587 BurnRandomSetSeed(0x0132013201320132ull);
588
589 irq_source = 0;
590 flipscreen = 0;
591 scroll_control = 0;
592
593 memset (packet_buffer, 0, 2);
594 packet_reset = 0;
595 packet_write_pos = 0;
596
597 return 0;
598 }
599
MemIndex()600 static INT32 MemIndex()
601 {
602 UINT8 *Next; Next = AllMem;
603
604 DrvZ80ROM0 = Next; Next += 0x00a000;
605 DrvZ80ROM1 = Next; Next += 0x006000;
606
607 DrvGfxROM0 = Next; Next += 0x020000;
608 DrvGfxROM1 = Next; Next += 0x020000;
609
610 DrvColPROM = Next; Next += 0x000700;
611 DrvVidPROM = Next; Next += 0x000100;
612
613 DrvProtROM = Next; Next += 0x002000;
614
615 DrvTransTab = Next; Next += 0x000400;
616
617 DrvPalette = (UINT32*)Next; Next += 0x0400 * sizeof(UINT32);
618
619 AllRam = Next;
620
621 DrvZ80RAM0 = Next; Next += 0x000800;
622 DrvVidRAM = Next; Next += 0x000800;
623 DrvSprRAM = Next; Next += 0x000800;
624 DrvShareRAM = Next; Next += 0x000800;
625
626 scroll = Next; Next += 0x000002;
627
628 RamEnd = Next;
629 MemEnd = Next;
630
631 return 0;
632 }
633
DrvGfxDecode(INT32 type)634 static INT32 DrvGfxDecode(INT32 type)
635 {
636 INT32 Plane[3] = { 0x00000, 0x20000, 0x40000 };
637 INT32 XOffs[16] = { STEP8(7,-1), STEP8(128+7,-1) };
638 INT32 YOffs[32] = { STEP16(0,8), STEP16(256, 8) };
639
640 UINT8 *tmp = (UINT8*)BurnMalloc(0xc000);
641 if (tmp == NULL) {
642 return 1;
643 }
644
645 memcpy (tmp, DrvGfxROM0, 0xc000);
646
647 if (type == 0) {
648 GfxDecode(0x0200, 3, 16, 16, Plane, XOffs, YOffs, 0x100, tmp, DrvGfxROM0);
649 } else {
650 GfxDecode(0x0100, 3, 16, 32, Plane, XOffs, YOffs, 0x200, tmp, DrvGfxROM0);
651 }
652
653 memcpy (tmp, DrvGfxROM1, 0xc000);
654
655 GfxDecode(0x0800, 3, 8, 8, Plane, XOffs, YOffs, 0x040, tmp, DrvGfxROM1);
656
657 BurnFree (tmp);
658
659 return 0;
660 }
661
CommonInit(INT32 game)662 static INT32 CommonInit(INT32 game)
663 {
664 AllMem = NULL;
665 MemIndex();
666 INT32 nLen = MemEnd - (UINT8 *)0;
667 if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
668 memset(AllMem, 0, nLen);
669 MemIndex();
670
671 {
672 if (game == 0) // strnskil / guiness
673 {
674 if (BurnLoadRom(DrvZ80ROM0 + 0x0000, 0, 1)) return 1;
675 memcpy (DrvZ80ROM0 + 0x8000, DrvZ80ROM0 + 0x2000, 0x2000);
676 if (BurnLoadRom(DrvZ80ROM0 + 0x2000, 1, 1)) return 1;
677 if (BurnLoadRom(DrvZ80ROM0 + 0x4000, 2, 1)) return 1;
678 if (BurnLoadRom(DrvZ80ROM0 + 0x6000, 3, 1)) return 1;
679
680 if (BurnLoadRom(DrvZ80ROM1 + 0x0000, 4, 1)) return 1;
681 if (BurnLoadRom(DrvZ80ROM1 + 0x2000, 5, 1)) return 1;
682
683 if (BurnLoadRom(DrvGfxROM0 + 0x8000, 6, 1)) return 1;
684 if (BurnLoadRom(DrvGfxROM0 + 0x4000, 7, 1)) return 1;
685 if (BurnLoadRom(DrvGfxROM0 + 0x0000, 8, 1)) return 1;
686
687 if (BurnLoadRom(DrvGfxROM1 + 0x0000, 9, 1)) return 1;
688 if (BurnLoadRom(DrvGfxROM1 + 0x4000, 10, 1)) return 1;
689 if (BurnLoadRom(DrvGfxROM1 + 0x8000, 11, 1)) return 1;
690
691 if (BurnLoadRom(DrvColPROM + 0x0000, 12, 1)) return 1;
692 if (BurnLoadRom(DrvColPROM + 0x0100, 13, 1)) return 1;
693 if (BurnLoadRom(DrvColPROM + 0x0200, 14, 1)) return 1;
694 if (BurnLoadRom(DrvColPROM + 0x0300, 15, 1)) return 1;
695 if (BurnLoadRom(DrvColPROM + 0x0500, 16, 1)) return 1;
696
697 if (BurnLoadRom(DrvVidPROM + 0x0000, 17, 1)) return 1;
698 }
699 else if (game == 1) // pettanp / banbam
700 {
701 if (BurnLoadRom(DrvZ80ROM0 + 0x0000, 0, 1)) return 1;
702 memcpy (DrvZ80ROM0 + 0x8000, DrvZ80ROM0 + 0x2000, 0x2000);
703 if (BurnLoadRom(DrvZ80ROM0 + 0x2000, 1, 1)) return 1;
704 if (BurnLoadRom(DrvZ80ROM0 + 0x4000, 2, 1)) return 1;
705 if (BurnLoadRom(DrvZ80ROM0 + 0x6000, 3, 1)) return 1;
706
707 if (BurnLoadRom(DrvZ80ROM1 + 0x0000, 4, 1)) return 1;
708
709 if (BurnLoadRom(DrvGfxROM0 + 0x8000, 5, 1)) return 1;
710 if (BurnLoadRom(DrvGfxROM0 + 0x4000, 6, 1)) return 1;
711 if (BurnLoadRom(DrvGfxROM0 + 0x0000, 7, 1)) return 1;
712
713 if (BurnLoadRom(DrvGfxROM1 + 0x0000, 8, 1)) return 1;
714 if (BurnLoadRom(DrvGfxROM1 + 0x4000, 9, 1)) return 1;
715 if (BurnLoadRom(DrvGfxROM1 + 0x8000, 10, 1)) return 1;
716
717 if (BurnLoadRom(DrvColPROM + 0x0000, 11, 1)) return 1;
718 if (BurnLoadRom(DrvColPROM + 0x0100, 12, 1)) return 1;
719 if (BurnLoadRom(DrvColPROM + 0x0200, 13, 1)) return 1;
720 if (BurnLoadRom(DrvColPROM + 0x0300, 14, 1)) return 1;
721 if (BurnLoadRom(DrvColPROM + 0x0500, 15, 1)) return 1;
722
723 if (BurnLoadRom(DrvVidPROM + 0x0000, 16, 1)) return 1;
724
725 if (BurnLoadRom(DrvProtROM + 0x0000, 17, 1)) return 1;
726 }
727
728 DrvGfxDecode(0);
729 }
730
731 ZetInit(0);
732 ZetOpen(0);
733 ZetMapMemory(DrvZ80ROM0, 0x0000, 0x9fff, MAP_ROM);
734 ZetMapMemory(DrvZ80RAM0, 0xc000, 0xc7ff, MAP_RAM);
735 ZetMapMemory(DrvShareRAM, 0xc800, 0xcfff, MAP_RAM);
736 ZetMapMemory(DrvVidRAM, 0xd000, 0xd7ff, MAP_RAM);
737 ZetSetWriteHandler(strnskil_main_write);
738 ZetSetReadHandler(strnskil_main_read);
739 ZetClose();
740
741 ZetInit(1);
742 ZetOpen(1);
743 ZetMapMemory(DrvZ80ROM1, 0x0000, 0x5fff, MAP_ROM);
744 ZetMapMemory(DrvSprRAM, 0xc000, 0xc7ff, MAP_RAM);
745 ZetMapMemory(DrvShareRAM, 0xc800, 0xcfff, MAP_RAM);
746 ZetSetWriteHandler(strnskil_sound_write);
747 ZetClose();
748
749 if (game == 0) // strnskil / guiness
750 {
751 SN76489Init(0, 15468000 / 6, 0);
752 SN76489Init(1, 15468000 / 6, 1);
753 }
754 else if (game == 1) // pettanp / banbam
755 {
756 SN76496Init(0, 8000000 / 4, 0);
757 SN76496Init(1, 8000000 / 2, 1);
758 }
759
760 SN76496SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
761 SN76496SetRoute(1, 1.00, BURN_SND_ROUTE_BOTH);
762 SN76496SetBuffered(ZetTotalCycles, 4000000);
763
764 GenericTilesInit();
765 GenericTilemapInit(0, scan_cols_map_scan, markham_map_callback, 8, 8, 32, 32);
766 GenericTilemapSetOffsets(0, -8, -16);
767 GenericTilemapSetScrollRows(0, 32);
768 GenericTilemapSetGfx(0, DrvGfxROM1, 3, 8, 8, 0x10000, 0x200, 0x3f);
769
770 irq_scanline[0] = 96;
771 irq_scanline[1] = 240;
772 irq_scanline[2] = 120;
773 irq_scanline[3] = 240;
774
775 DrvDoReset();
776
777 return 0;
778 }
779
IkkiInit()780 static INT32 IkkiInit()
781 {
782 AllMem = NULL;
783 MemIndex();
784 INT32 nLen = MemEnd - (UINT8 *)0;
785 if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
786 memset(AllMem, 0, nLen);
787 MemIndex();
788
789 {
790 if (BurnLoadRom(DrvZ80ROM0 + 0x0000, 0, 1)) return 1;
791 memcpy (DrvZ80ROM0 + 0x8000, DrvZ80ROM0 + 0x2000, 0x2000);
792 if (BurnLoadRom(DrvZ80ROM0 + 0x2000, 1, 1)) return 1;
793 if (BurnLoadRom(DrvZ80ROM0 + 0x4000, 2, 1)) return 1;
794 if (BurnLoadRom(DrvZ80ROM0 + 0x6000, 3, 1)) return 1;
795
796 if (BurnLoadRom(DrvZ80ROM1 + 0x0000, 4, 1)) return 1;
797
798 if (BurnLoadRom(DrvGfxROM0 + 0x8000, 5, 1)) return 1;
799 if (BurnLoadRom(DrvGfxROM0 + 0x4000, 6, 1)) return 1;
800 if (BurnLoadRom(DrvGfxROM0 + 0x0000, 7, 1)) return 1;
801
802 if (BurnLoadRom(DrvGfxROM1 + 0x8000, 8, 1)) return 1;
803 if (BurnLoadRom(DrvGfxROM1 + 0x4000, 9, 1)) return 1;
804 if (BurnLoadRom(DrvGfxROM1 + 0x0000, 10, 1)) return 1;
805
806 if (BurnLoadRom(DrvColPROM + 0x0000, 11, 1)) return 1;
807 if (BurnLoadRom(DrvColPROM + 0x0100, 12, 1)) return 1;
808 if (BurnLoadRom(DrvColPROM + 0x0200, 13, 1)) return 1;
809 if (BurnLoadRomExt(DrvColPROM + 0x0300, 14, 1, LD_INVERT)) return 1;
810 if (BurnLoadRom(DrvColPROM + 0x0500, 15, 1)) return 1;
811
812 if (BurnLoadRom(DrvVidPROM + 0x0000, 16, 1)) return 1;
813
814 DrvGfxDecode(1);
815 }
816
817 ZetInit(0);
818 ZetOpen(0);
819 ZetMapMemory(DrvZ80ROM0, 0x0000, 0x9fff, MAP_ROM);
820 ZetMapMemory(DrvZ80RAM0, 0xc000, 0xc7ff, MAP_RAM);
821 ZetMapMemory(DrvShareRAM, 0xc800, 0xcfff, MAP_RAM);
822 ZetMapMemory(DrvVidRAM, 0xd000, 0xd7ff, MAP_RAM);
823 ZetSetWriteHandler(ikki_main_write);
824 ZetSetReadHandler(ikki_main_read);
825 ZetClose();
826
827 ZetInit(1);
828 ZetOpen(1);
829 ZetMapMemory(DrvZ80ROM1, 0x0000, 0x1fff, MAP_ROM);
830 ZetMapMemory(DrvSprRAM, 0xc000, 0xc7ff, MAP_RAM);
831 ZetMapMemory(DrvShareRAM, 0xc800, 0xcfff, MAP_RAM);
832 ZetSetWriteHandler(strnskil_sound_write);
833 ZetClose();
834
835 SN76496Init(0, 8000000 / 4, 0);
836 SN76496Init(1, 8000000 / 2, 1);
837 SN76496SetRoute(0, 0.75, BURN_SND_ROUTE_BOTH);
838 SN76496SetRoute(1, 0.75, BURN_SND_ROUTE_BOTH);
839 SN76496SetBuffered(ZetTotalCycles, 4000000);
840
841 GenericTilesInit();
842
843 irq_scanline[0] = 120;
844 irq_scanline[1] = 240;
845 irq_scanline[2] = 12;
846 irq_scanline[3] = 120;
847
848 DrvDoReset();
849
850 return 0;
851 }
852
MarkhamInit()853 static INT32 MarkhamInit()
854 {
855 AllMem = NULL;
856 MemIndex();
857 INT32 nLen = MemEnd - (UINT8 *)0;
858 if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
859 memset(AllMem, 0, nLen);
860 MemIndex();
861
862 {
863 if (BurnLoadRom(DrvZ80ROM0 + 0x00000, 0, 1)) return 1;
864 if (BurnLoadRom(DrvZ80ROM0 + 0x02000, 1, 1)) return 1;
865 if (BurnLoadRom(DrvZ80ROM0 + 0x04000, 2, 1)) return 1;
866
867 if (BurnLoadRom(DrvZ80ROM1 + 0x00000, 3, 1)) return 1;
868 if (BurnLoadRom(DrvZ80ROM1 + 0x04000, 4, 1)) return 1;
869
870 if (BurnLoadRom(DrvGfxROM0 + 0x00000, 7, 1)) return 1;
871 if (BurnLoadRom(DrvGfxROM0 + 0x04000, 6, 1)) return 1;
872 if (BurnLoadRom(DrvGfxROM0 + 0x08000, 5, 1)) return 1;
873
874 if (BurnLoadRom(DrvGfxROM1 + 0x00000, 8, 1)) return 1;
875 if (BurnLoadRom(DrvGfxROM1 + 0x04000, 9, 1)) return 1;
876 if (BurnLoadRom(DrvGfxROM1 + 0x08000, 10, 1)) return 1;
877
878 if (BurnLoadRom(DrvColPROM + 0x00000, 11, 1)) return 1;
879 if (BurnLoadRom(DrvColPROM + 0x00100, 12, 1)) return 1;
880 if (BurnLoadRom(DrvColPROM + 0x00200, 13, 1)) return 1;
881 if (BurnLoadRom(DrvColPROM + 0x00300, 14, 1)) return 1;
882 if (BurnLoadRom(DrvColPROM + 0x00500, 15, 1)) return 1;
883
884 DrvGfxDecode(0);
885 }
886
887 ZetInit(0);
888 ZetOpen(0);
889 ZetMapMemory(DrvZ80ROM0, 0x0000, 0x9fff, MAP_ROM);
890 ZetMapMemory(DrvZ80RAM0, 0xc000, 0xc7ff, MAP_RAM);
891 ZetMapMemory(DrvSprRAM, 0xc800, 0xcfff, MAP_RAM);
892 ZetMapMemory(DrvVidRAM, 0xd000, 0xd7ff, MAP_RAM);
893 ZetMapMemory(DrvShareRAM, 0xd800, 0xdfff, MAP_RAM);
894 ZetSetWriteHandler(markham_main_write);
895 ZetSetReadHandler(markham_main_read);
896 ZetClose();
897
898 ZetInit(1);
899 ZetOpen(1);
900 ZetMapMemory(DrvZ80ROM1, 0x0000, 0x5fff, MAP_ROM);
901 ZetMapMemory(DrvShareRAM, 0x8000, 0x87ff, MAP_RAM);
902 ZetSetWriteHandler(markham_sound_write);
903 ZetClose();
904
905 SN76496Init(0, 4000000, 0);
906 SN76496Init(1, 4000000, 1);
907 SN76496SetRoute(0, 0.75, BURN_SND_ROUTE_BOTH);
908 SN76496SetRoute(1, 0.75, BURN_SND_ROUTE_BOTH);
909 SN76496SetBuffered(ZetTotalCycles, 4000000);
910
911 GenericTilesInit();
912 GenericTilemapInit(0, scan_cols_map_scan, markham_map_callback, 8, 8, 32, 32);
913 GenericTilemapSetOffsets(0, -8, -16);
914 GenericTilemapSetScrollRows(0, 32);
915 GenericTilemapSetGfx(0, DrvGfxROM1, 3, 8, 8, 0x10000, 0x200, 0x3f);
916
917 irq_scanline[0] = 240;
918 irq_scanline[1] = -1;
919 irq_scanline[2] = 240;
920 irq_scanline[3] = -1;
921
922 DrvDoReset();
923
924 return 0;
925 }
926
DrvExit()927 static INT32 DrvExit()
928 {
929 GenericTilesExit();
930 ZetExit();
931 SN76496Exit();
932
933 BurnFree(AllMem);
934
935 return 0;
936 }
937
DrvPaletteInit()938 static void DrvPaletteInit()
939 {
940 for (INT32 i = 0; i < 0x400; i++)
941 {
942 INT32 j = DrvColPROM[i + 0x300];
943 INT32 r = DrvColPROM[j + 0x000] & 0x0f;
944 INT32 g = DrvColPROM[j + 0x100] & 0x0f;
945 INT32 b = DrvColPROM[j + 0x200] & 0x0f;
946
947 DrvPalette[i] = BurnHighCol(r*16+r, g*16+g, b*16+b, 0);
948
949 DrvTransTab[i] = (j == 0) ? 0 : 1;
950 }
951 }
952
draw_sprites()953 static void draw_sprites()
954 {
955 for (INT32 offs = 0x60; offs < 0x100; offs += 4)
956 {
957 INT32 code = DrvSprRAM[offs + 1];
958 INT32 color = DrvSprRAM[offs + 2];
959
960 INT32 sx = DrvSprRAM[offs + 3];
961 INT32 sy = DrvSprRAM[offs + 0];
962 INT32 px, py;
963
964 if (flipscreen == 0)
965 {
966 px = sx - 2;
967 py = 240 - sy;
968 }
969 else
970 {
971 px = 240 - sx;
972 py = sy;
973 }
974
975 px = px & 0xff;
976
977 if (px > 248)
978 px = px - 256;
979
980 RenderTileTranstab(pTransDraw, DrvGfxROM0, code, (color & 0x3f) << 3, 0, px - 8, py - 16, flipscreen, flipscreen, 16, 16, DrvTransTab);
981 }
982 }
983
DrvDraw()984 static INT32 DrvDraw()
985 {
986 if (DrvRecalc) {
987 DrvPaletteInit();
988 DrvRecalc = 0;
989 }
990
991 for (INT32 i = 32/8; i < 128/8; i++) GenericTilemapSetScrollRow(0, i, scroll[0]);
992 for (INT32 i = 128/8; i < 256/8; i++) GenericTilemapSetScrollRow(0, i, scroll[1]);
993
994 // GenericTilemapSetFlip(0, (flipscreen) ? TMAP_FLIPXY : 0);
995 GenericTilemapDraw(0, pTransDraw, -1);
996
997 draw_sprites();
998
999 BurnTransferCopy(DrvPalette);
1000
1001 return 0;
1002 }
1003
StrnskilDraw()1004 static INT32 StrnskilDraw()
1005 {
1006 if (DrvRecalc) {
1007 DrvPaletteInit();
1008 DrvRecalc = 0;
1009 }
1010
1011 for (INT32 row = 0; row < 32; row++)
1012 {
1013 if (scroll_control != 0x07)
1014 {
1015 switch (DrvVidPROM[(scroll_control & 7) * 32 + row])
1016 {
1017 case 2:
1018 GenericTilemapSetScrollRow(0, row, -~scroll[1]);
1019 break;
1020 case 4:
1021 GenericTilemapSetScrollRow(0, row, -~scroll[0]);
1022 break;
1023 }
1024 }
1025 }
1026
1027 BurnTransferClear();
1028
1029 // GenericTilemapSetFlip(0, (flipscreen) ? TMAP_FLIPXY : 0);
1030 if (nBurnLayer & 1) GenericTilemapDraw(0, pTransDraw, -1);
1031
1032 if (nSpriteEnable & 1) draw_sprites();
1033
1034 BurnTransferCopy(DrvPalette);
1035
1036 return 0;
1037 }
1038
ikki_draw_sprites()1039 static void ikki_draw_sprites()
1040 {
1041 for (INT32 offs = 0; offs < 0x800; offs += 4)
1042 {
1043 INT32 sy = DrvSprRAM[offs + 0];
1044 INT32 color = DrvSprRAM[offs + 2] & 0x3f;
1045 INT32 code =(DrvSprRAM[offs + 1] >> 1) | (DrvSprRAM[offs + 2] & 0x80);
1046 INT32 sx = DrvSprRAM[offs + 3];
1047
1048 sy = 224 - sy;
1049 sx &= 0xff;
1050 sy &= 0xff;
1051 if (sx > 248) sx -= 256;
1052 if (sy > 240) sy -= 256;
1053
1054 RenderTileTranstab(pTransDraw, DrvGfxROM0, code, color << 3, 0, sx - 8, sy - 16, flipscreen, flipscreen, 16, 32, DrvTransTab);
1055 }
1056 }
1057
ikki_draw_bg_layer(INT32 prio)1058 static void ikki_draw_bg_layer(INT32 prio)
1059 {
1060 for (INT32 offs = 0; offs < 0x800 / 2; offs++)
1061 {
1062 INT32 x = (offs >> 5) << 3;
1063 INT32 y = (offs & 0x1f) << 3;
1064
1065 INT32 d = DrvVidPROM[x >> 3];
1066
1067 if (d != 0 && d != 0x0d) {
1068 if (prio) continue;
1069 }
1070
1071 INT32 color = DrvVidRAM[offs * 2 + 0];
1072 INT32 code = DrvVidRAM[offs * 2 + 1] + ((color & 0xe0) << 3);
1073 color = (color & 0x1f) | ((color & 0x80) >> 2);
1074
1075 if (d == 0x02 && prio == 0) {
1076 x -= scroll[1];
1077 if (x < 0) x += 176;
1078
1079 y = (y + ~scroll[0]) & 0xff;
1080 }
1081
1082 Render8x8Tile_Clip(pTransDraw, code, x-8, y-16, color, 3, 0x200, DrvGfxROM1);
1083 }
1084 }
1085
IkkiDraw()1086 static INT32 IkkiDraw()
1087 {
1088 if (DrvRecalc) {
1089 DrvPaletteInit();
1090 DrvRecalc = 0;
1091 }
1092
1093 ikki_draw_bg_layer(0);
1094 ikki_draw_sprites();
1095 ikki_draw_bg_layer(1);
1096
1097 BurnTransferCopy(DrvPalette);
1098
1099 return 0;
1100 }
1101
DrvFrame()1102 static INT32 DrvFrame()
1103 {
1104 if (DrvReset) {
1105 DrvDoReset();
1106 }
1107
1108 ZetNewFrame();
1109
1110 {
1111 memset (DrvInputs, 0, 3);
1112
1113 for (INT32 i = 0; i < 8; i++) {
1114 DrvInputs[0] ^= (DrvJoy1[i] & 1) << i;
1115 DrvInputs[1] ^= (DrvJoy2[i] & 1) << i;
1116 DrvInputs[2] ^= (DrvJoy3[i] & 1) << i;
1117 }
1118
1119 if (DrvJoy1[2] && DrvJoy1[3]) DrvInputs[0] &= ~0x0c;
1120 if (DrvJoy1[1] && DrvJoy1[0]) DrvInputs[0] &= ~0x03;
1121 if (DrvJoy2[3] && DrvJoy2[2]) DrvInputs[1] &= ~0x0c;
1122 if (DrvJoy2[1] && DrvJoy2[0]) DrvInputs[1] &= ~0x03;
1123 }
1124
1125 INT32 nInterleave = 262*16;
1126 INT32 nCyclesTotal[2] = { 4000000 / 60, 4000000 / 60 };
1127 INT32 nCyclesDone[2] = { 0, 0 };
1128
1129 for (INT32 i = 0; i < nInterleave; i++)
1130 {
1131 ZetOpen(0);
1132 CPU_RUN(0, Zet);
1133 if (i == irq_scanline[0]*16) { ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD); irq_source = 1; };
1134 if (i == irq_scanline[1]*16) { ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD); irq_source = 0; };
1135 ZetClose();
1136
1137 ZetOpen(1);
1138 CPU_RUN(1, Zet);
1139 if (i == irq_scanline[2]*16) { ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD); };
1140 if (i == irq_scanline[3]*16) { ZetSetIRQLine(0, CPU_IRQSTATUS_HOLD); };
1141 ZetClose();
1142 }
1143
1144 if (pBurnSoundOut) {
1145 SN76496Update(pBurnSoundOut, nBurnSoundLen);
1146 BurnSoundDCFilter();
1147 }
1148
1149 if (pBurnDraw) {
1150 BurnDrvRedraw();
1151 }
1152
1153 return 0;
1154 }
1155
DrvScan(INT32 nAction,INT32 * pnMin)1156 static INT32 DrvScan(INT32 nAction, INT32 *pnMin)
1157 {
1158 struct BurnArea ba;
1159
1160 if (pnMin) {
1161 *pnMin = 0x029707;
1162 }
1163
1164 if (nAction & ACB_VOLATILE) {
1165 memset(&ba, 0, sizeof(ba));
1166
1167 ba.Data = AllRam;
1168 ba.nLen = RamEnd - AllRam;
1169 ba.szName = "All Ram";
1170 BurnAcb(&ba);
1171
1172 ZetScan(nAction);
1173 SN76496Scan(nAction, pnMin);
1174 BurnRandomScan(nAction);
1175
1176 SCAN_VAR(flipscreen);
1177 SCAN_VAR(irq_source);
1178 SCAN_VAR(scroll_control);
1179 SCAN_VAR(packet_buffer);
1180 SCAN_VAR(packet_reset);
1181 SCAN_VAR(packet_write_pos);
1182 }
1183
1184 return 0;
1185 }
1186
1187
1188 // Markham
1189
1190 static struct BurnRomInfo markhamRomDesc[] = {
1191 { "tv3.9", 0x2000, 0x59391637, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1192 { "tvg4.10", 0x2000, 0x1837bcce, 1 | BRF_PRG | BRF_ESS }, // 1
1193 { "tvg5.11", 0x2000, 0x651da602, 1 | BRF_PRG | BRF_ESS }, // 2
1194
1195 { "tvg1.5", 0x2000, 0xc5299766, 2 | BRF_PRG | BRF_ESS }, // 3 Z80 #1 Code
1196 { "tvg2.6", 0x2000, 0xb216300a, 2 | BRF_PRG | BRF_ESS }, // 4
1197
1198 { "tvg6.84", 0x2000, 0xab933ae5, 3 | BRF_GRA }, // 5 Sprites
1199 { "tvg7.85", 0x2000, 0xce8edda7, 3 | BRF_GRA }, // 6
1200 { "tvg8.86", 0x2000, 0x74d1536a, 3 | BRF_GRA }, // 7
1201
1202 { "tvg9.87", 0x2000, 0x42168675, 4 | BRF_GRA }, // 8 Tiles
1203 { "tvg10.88", 0x2000, 0xfa9feb67, 4 | BRF_GRA }, // 9
1204 { "tvg11.89", 0x2000, 0x71f3dd49, 4 | BRF_GRA }, // 10
1205
1206 { "14-3.99", 0x0100, 0x89d09126, 5 | BRF_GRA }, // 11 Color PROMs
1207 { "14-4.100", 0x0100, 0xe1cafe6c, 5 | BRF_GRA }, // 12
1208 { "14-5.101", 0x0100, 0x2d444fa6, 5 | BRF_GRA }, // 13
1209 { "14-1.61", 0x0200, 0x3ad8306d, 5 | BRF_GRA }, // 14
1210 { "14-2.115", 0x0200, 0x12a4f1ff, 5 | BRF_GRA }, // 15
1211 };
1212
1213 STD_ROM_PICK(markham)
1214 STD_ROM_FN(markham)
1215
1216 struct BurnDriver BurnDrvMarkham = {
1217 "markham", NULL, NULL, NULL, "1983",
1218 "Markham\0", NULL, "Sun Electronics", "Miscellaneous",
1219 NULL, NULL, NULL, NULL,
1220 BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_HORSHOOT, 0,
1221 NULL, markhamRomInfo, markhamRomName, NULL, NULL, NULL, NULL, MarkhamInputInfo, MarkhamDIPInfo,
1222 MarkhamInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc, 0x400,
1223 240, 224, 4, 3
1224 };
1225
1226
1227 // Strength & Skill
1228
1229 static struct BurnRomInfo strnskilRomDesc[] = {
1230 { "tvg3.7", 0x4000, 0x31fd793a, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1231 { "tvg4.8", 0x2000, 0xc58315b5, 1 | BRF_PRG | BRF_ESS }, // 1
1232 { "tvg5.9", 0x2000, 0x29e7ded5, 1 | BRF_PRG | BRF_ESS }, // 2
1233 { "tvg6.10", 0x2000, 0x8b126a4b, 1 | BRF_PRG | BRF_ESS }, // 3
1234
1235 { "tvg1.2", 0x2000, 0xb586b753, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 #1 Code
1236 { "tvg2.3", 0x2000, 0x8bd71bb6, 2 | BRF_PRG | BRF_ESS }, // 5
1237
1238 { "tvg7.90", 0x2000, 0xee3bd593, 3 | BRF_GRA }, // 6 Sprites
1239 { "tvg8.92", 0x2000, 0x1b265360, 3 | BRF_GRA }, // 7
1240 { "tvg9.94", 0x2000, 0x776c7ca6, 3 | BRF_GRA }, // 8
1241
1242 { "tvg12.102", 0x2000, 0x68b9d888, 4 | BRF_GRA }, // 9 Tiles
1243 { "tvg11.101", 0x2000, 0x7f2179ff, 4 | BRF_GRA }, // 10
1244 { "tvg10.100", 0x2000, 0x321ad963, 4 | BRF_GRA }, // 11
1245
1246 { "15-3.prm", 0x0100, 0xdbcd3bec, 5 | BRF_GRA }, // 12 Color PROMs
1247 { "15-4.prm", 0x0100, 0x9eb7b6cf, 5 | BRF_GRA }, // 13
1248 { "15-5.prm", 0x0100, 0x9b30a7f3, 5 | BRF_GRA }, // 14
1249 { "15-1.prm", 0x0200, 0xd4f5b3d7, 5 | BRF_GRA }, // 15
1250 { "15-2.prm", 0x0200, 0xcdffede9, 5 | BRF_GRA }, // 16
1251
1252 { "15-6.prm", 0x0100, 0xec4faf5b, 0 | BRF_OPT }, // 17 Scroll Control PROM
1253 };
1254
1255 STD_ROM_PICK(strnskil)
STD_ROM_FN(strnskil)1256 STD_ROM_FN(strnskil)
1257
1258 static INT32 StrnskilInit()
1259 {
1260 return CommonInit(0);
1261 }
1262
1263 struct BurnDriver BurnDrvStrnskil = {
1264 "strnskil", NULL, NULL, NULL, "1984",
1265 "Strength & Skill\0", NULL, "Sun Electronics", "Miscellaneous",
1266 NULL, NULL, NULL, NULL,
1267 BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0,
1268 NULL, strnskilRomInfo, strnskilRomName, NULL, NULL, NULL, NULL, StrnskilInputInfo, StrnskilDIPInfo,
1269 StrnskilInit, DrvExit, DrvFrame, StrnskilDraw, DrvScan, &DrvRecalc, 0x400,
1270 240, 224, 4, 3
1271 };
1272
1273
1274 // The Guiness (Japan)
1275
1276 static struct BurnRomInfo guinessRomDesc[] = {
1277 { "tvg3.15", 0x4000, 0x3a605ad8, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1278 { "tvg4.8", 0x2000, 0xc58315b5, 1 | BRF_PRG | BRF_ESS }, // 1
1279 { "tvg5.9", 0x2000, 0x29e7ded5, 1 | BRF_PRG | BRF_ESS }, // 2
1280 { "tvg6.10", 0x2000, 0x8b126a4b, 1 | BRF_PRG | BRF_ESS }, // 3
1281
1282 { "tvg1.2", 0x2000, 0xb586b753, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 #1 Code
1283 { "tvg2.3", 0x2000, 0x8bd71bb6, 2 | BRF_PRG | BRF_ESS }, // 5
1284
1285 { "tvg7.90", 0x2000, 0xee3bd593, 3 | BRF_GRA }, // 6 Sprites
1286 { "tvg8.92", 0x2000, 0x1b265360, 3 | BRF_GRA }, // 7
1287 { "tvg9.94", 0x2000, 0x776c7ca6, 3 | BRF_GRA }, // 8
1288
1289 { "=tvg12.15", 0x2000, 0xa82c923d, 4 | BRF_GRA }, // 9 Tiles
1290 { "tvg11.15", 0x2000, 0xd432c96f, 4 | BRF_GRA }, // 10
1291 { "tvg10.15", 0x2000, 0xa53959d6, 4 | BRF_GRA }, // 11
1292
1293 { "15-3.prm", 0x0100, 0xdbcd3bec, 5 | BRF_GRA }, // 12 Color PROMs
1294 { "15-4.prm", 0x0100, 0x9eb7b6cf, 5 | BRF_GRA }, // 13
1295 { "15-5.prm", 0x0100, 0x9b30a7f3, 5 | BRF_GRA }, // 14
1296 { "15-1.prm", 0x0200, 0xd4f5b3d7, 5 | BRF_GRA }, // 15
1297 { "15-2.prm", 0x0200, 0xcdffede9, 5 | BRF_GRA }, // 16
1298
1299 { "15-6.prm", 0x0100, 0xec4faf5b, 0 | BRF_OPT }, // 17 Scroll Control PROM
1300 };
1301
1302 STD_ROM_PICK(guiness)
1303 STD_ROM_FN(guiness)
1304
1305 struct BurnDriver BurnDrvGuiness = {
1306 "guiness", "strnskil", NULL, NULL, "1984",
1307 "The Guiness (Japan)\0", NULL, "Sun Electronics", "Miscellaneous",
1308 NULL, NULL, NULL, NULL,
1309 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0,
1310 NULL, guinessRomInfo, guinessRomName, NULL, NULL, NULL, NULL, StrnskilInputInfo, StrnskilDIPInfo,
1311 StrnskilInit, DrvExit, DrvFrame, StrnskilDraw, DrvScan, &DrvRecalc, 0x400,
1312 240, 224, 4, 3
1313 };
1314
1315
1316 // BanBam
1317
1318 static struct BurnRomInfo banbamRomDesc[] = {
1319 { "ban-rom2.ic7", 0x4000, 0xa5aeef6e, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1320 { "ban-rom3.ic8", 0x2000, 0xf91472bf, 1 | BRF_PRG | BRF_ESS }, // 1
1321 { "ban-rom4.ic9", 0x2000, 0x436a09ef, 1 | BRF_PRG | BRF_ESS }, // 2
1322 { "ban-rom5.ic10", 0x2000, 0x45205f86, 1 | BRF_PRG | BRF_ESS }, // 3
1323
1324 { "ban-rom1.ic2", 0x2000, 0xe36009f6, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 #1 Code
1325
1326 { "ban-rom6.ic90", 0x2000, 0x41fc44df, 3 | BRF_GRA }, // 5 Sprites
1327 { "ban-rom7.ic92", 0x2000, 0x8b429c5b, 3 | BRF_GRA }, // 6
1328 { "ban-rom8.ic94", 0x2000, 0x76c02d6b, 3 | BRF_GRA }, // 7
1329
1330 { "ban-rom11.ic102", 0x2000, 0xaa827c57, 4 | BRF_GRA }, // 8 Tiles
1331 { "ban-rom10.ic101", 0x2000, 0x51bd1c5c, 4 | BRF_GRA }, // 9
1332 { "ban-rom9.ic100", 0x2000, 0xc0a5a4c8, 4 | BRF_GRA }, // 10
1333
1334 { "16-3.66", 0x0100, 0xdbcd3bec, 5 | BRF_GRA }, // 11 Color PROMs
1335 { "16-4.67", 0x0100, 0x9eb7b6cf, 5 | BRF_GRA }, // 12
1336 { "16-5.68", 0x0100, 0x9b30a7f3, 5 | BRF_GRA }, // 13
1337 { "16-1.148", 0x0200, 0x777e2770, 5 | BRF_GRA }, // 14
1338 { "16-2.97", 0x0200, 0x7f95d4b2, 5 | BRF_GRA }, // 15
1339
1340 { "16-6.59", 0x0100, 0xec4faf5b, 6 | BRF_GRA }, // 16 Scroll Control PROM
1341
1342 { "ban-rom12.ic2", 0x2000, 0x044bb2f6, 7 | BRF_GRA }, // 17 MB8841 External ROM
1343
1344 { "sun-8212.ic3", 0x0800, 0x8869611e, 8 | BRF_PRG }, // 18 MB8841 Internal ROM
1345 };
1346
1347 STD_ROM_PICK(banbam)
STD_ROM_FN(banbam)1348 STD_ROM_FN(banbam)
1349
1350 static INT32 BanbamInit()
1351 {
1352 return CommonInit(1);
1353 }
1354
1355 struct BurnDriver BurnDrvBanbam = {
1356 "banbam", NULL, NULL, NULL, "1984",
1357 "BanBam\0", NULL, "Sun Electronics", "Miscellaneous",
1358 NULL, NULL, NULL, NULL,
1359 BDF_GAME_WORKING, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0,
1360 NULL, banbamRomInfo, banbamRomName, NULL, NULL, NULL, NULL, BanbamInputInfo, BanbamDIPInfo,
1361 BanbamInit, DrvExit, DrvFrame, StrnskilDraw, DrvScan, &DrvRecalc, 0x400,
1362 240, 224, 4, 3
1363 };
1364
1365
1366 // Pettan Pyuu (Japan)
1367
1368 static struct BurnRomInfo pettanpRomDesc[] = {
1369 { "tvg2-16a.7", 0x4000, 0x4cbbbd01, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1370 { "tvg3-16a.8", 0x2000, 0xaaa0420f, 1 | BRF_PRG | BRF_ESS }, // 1
1371 { "tvg4-16a.9", 0x2000, 0x43306369, 1 | BRF_PRG | BRF_ESS }, // 2
1372 { "tvg5-16a.10", 0x2000, 0xda9c635f, 1 | BRF_PRG | BRF_ESS }, // 3
1373
1374 { "tvg1-16.2", 0x2000, 0xe36009f6, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 #1 Code
1375
1376 { "tvg6-16.90", 0x2000, 0x6905d9d5, 3 | BRF_GRA }, // 5 Sprites
1377 { "tvg7-16.92", 0x2000, 0x40d02bfd, 3 | BRF_GRA }, // 6
1378 { "tvg8-16.94", 0x2000, 0xb18a2244, 3 | BRF_GRA }, // 7
1379
1380 { "tvg11-16.102", 0x2000, 0x327b7a29, 4 | BRF_GRA }, // 8 Tile
1381 { "tvg10-16.101", 0x2000, 0x624ac061, 4 | BRF_GRA }, // 9
1382 { "tvg9-16.100", 0x2000, 0xc477e74c, 4 | BRF_GRA }, // 10
1383
1384 { "16-3.66", 0x0100, 0xdbcd3bec, 5 | BRF_GRA }, // 11 Color PROMs
1385 { "16-4.67", 0x0100, 0x9eb7b6cf, 5 | BRF_GRA }, // 12
1386 { "16-5.68", 0x0100, 0x9b30a7f3, 5 | BRF_GRA }, // 13
1387 { "16-1.148", 0x0200, 0x777e2770, 5 | BRF_GRA }, // 14
1388 { "16-2.97", 0x0200, 0x7f95d4b2, 5 | BRF_GRA }, // 15
1389
1390 { "16-6.59", 0x0100, 0xec4faf5b, 0 | BRF_OPT }, // 16 Scroll Control PROM
1391
1392 { "tvg12-16.2", 0x1000, 0x3abc6ba8, 0 | BRF_OPT }, // 17 MB8841 External ROM
1393
1394 { "sun-8212.ic3", 0x0800, 0x00000000, 0 | BRF_NODUMP | BRF_PRG }, // 18 MB8841 Internal ROM
1395 };
1396
1397 STD_ROM_PICK(pettanp)
1398 STD_ROM_FN(pettanp)
1399
1400 struct BurnDriver BurnDrvPettanp = {
1401 "pettanp", "banbam", NULL, NULL, "1984",
1402 "Pettan Pyuu (Japan)\0", NULL, "Sun Electronics", "Miscellaneous",
1403 NULL, NULL, NULL, NULL,
1404 BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_MISC_PRE90S, GBF_MISC, 0,
1405 NULL, pettanpRomInfo, pettanpRomName, NULL, NULL, NULL, NULL, BanbamInputInfo, BanbamDIPInfo,
1406 BanbamInit, DrvExit, DrvFrame, StrnskilDraw, DrvScan, &DrvRecalc, 0x400,
1407 240, 224, 4, 3
1408 };
1409
1410
1411 // Ikki (Japan)
1412
1413 static struct BurnRomInfo ikkiRomDesc[] = {
1414 { "tvg17_1", 0x4000, 0xcb28167c, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1415 { "tvg17_2", 0x2000, 0x756c7450, 1 | BRF_PRG | BRF_ESS }, // 1
1416 { "tvg17_3", 0x2000, 0x91f0a8b6, 1 | BRF_PRG | BRF_ESS }, // 2
1417 { "tvg17_4", 0x2000, 0x696fcf7d, 1 | BRF_PRG | BRF_ESS }, // 3
1418
1419 { "tvg17_5", 0x2000, 0x22bdb40e, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 #1 Code
1420
1421 { "tvg17_6", 0x4000, 0xdc8aa269, 3 | BRF_GRA }, // 5 Sprites
1422 { "tvg17_7", 0x4000, 0x0e9efeba, 3 | BRF_GRA }, // 6
1423 { "tvg17_8", 0x4000, 0x45c9087a, 3 | BRF_GRA }, // 7
1424
1425 { "tvg17_9", 0x4000, 0xc594f3c5, 4 | BRF_GRA }, // 8 Tiles
1426 { "tvg17_10", 0x4000, 0x2e510b4e, 4 | BRF_GRA }, // 9
1427 { "tvg17_11", 0x4000, 0x35012775, 4 | BRF_GRA }, // 10
1428
1429 { "prom17_3", 0x0100, 0xdbcd3bec, 5 | BRF_GRA }, // 11 Color PROMs
1430 { "prom17_4", 0x0100, 0x9eb7b6cf, 5 | BRF_GRA }, // 12
1431 { "prom17_5", 0x0100, 0x9b30a7f3, 5 | BRF_GRA }, // 13
1432 { "prom17_6", 0x0200, 0x962e619d, 5 | BRF_GRA }, // 14
1433 { "prom17_7", 0x0200, 0xb1f5148c, 5 | BRF_GRA }, // 15
1434
1435 { "prom17_1", 0x0100, 0xca0af30c, 6 | BRF_GRA }, // 16 Video PROM
1436
1437 { "prom17_2", 0x0100, 0xf3c55174, 6 | BRF_OPT }, // 17 Unused PROMs
1438 };
1439
1440 STD_ROM_PICK(ikki)
1441 STD_ROM_FN(ikki)
1442
1443 struct BurnDriver BurnDrvIkki = {
1444 "ikki", NULL, NULL, NULL, "1985",
1445 "Ikki (Japan)\0", NULL, "Sun Electronics", "Miscellaneous",
1446 NULL, NULL, NULL, NULL,
1447 BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_PRE90S, GBF_MAZE | GBF_SCRFIGHT, 0,
1448 NULL, ikkiRomInfo, ikkiRomName, NULL, NULL, NULL, NULL, IkkiInputInfo, IkkiDIPInfo,
1449 IkkiInit, DrvExit, DrvFrame, IkkiDraw, DrvScan, &DrvRecalc, 0x400,
1450 240, 224, 4, 3
1451 };
1452
1453
1454 // Farmers Rebellion
1455
1456 static struct BurnRomInfo farmerRomDesc[] = {
1457 { "tvg-1.10", 0x4000, 0x2c0bd392, 1 | BRF_PRG | BRF_ESS }, // 0 Z80 #0 Code
1458 { "tvg-2.9", 0x2000, 0xb86efe02, 1 | BRF_PRG | BRF_ESS }, // 1
1459 { "tvg-3.8", 0x2000, 0xfd686ff4, 1 | BRF_PRG | BRF_ESS }, // 2
1460 { "tvg-4.7", 0x2000, 0x1415355d, 1 | BRF_PRG | BRF_ESS }, // 3
1461
1462 { "tvg-5.30", 0x2000, 0x22bdb40e, 2 | BRF_PRG | BRF_ESS }, // 4 Z80 #1 Code
1463
1464 { "tvg-6.104", 0x4000, 0xdc8aa269, 3 | BRF_GRA }, // 5 Sprites
1465 { "tvg-7.103", 0x4000, 0x0e9efeba, 3 | BRF_GRA }, // 6
1466 { "tvg-8.102", 0x4000, 0x45c9087a, 3 | BRF_GRA }, // 7
1467
1468 { "tvg17_9", 0x4000, 0xc594f3c5, 4 | BRF_GRA }, // 8 Tiles
1469 { "tvg17_10", 0x4000, 0x2e510b4e, 4 | BRF_GRA }, // 9
1470 { "tvg17_11", 0x4000, 0x35012775, 4 | BRF_GRA }, // 10
1471
1472 { "prom17_3", 0x0100, 0xdbcd3bec, 5 | BRF_GRA }, // 11 Color PROMs
1473 { "prom17_4", 0x0100, 0x9eb7b6cf, 5 | BRF_GRA }, // 12
1474 { "prom17_5", 0x0100, 0x9b30a7f3, 5 | BRF_GRA }, // 13
1475 { "prom17_6", 0x0200, 0x962e619d, 5 | BRF_GRA }, // 14
1476 { "prom17_7", 0x0200, 0xb1f5148c, 5 | BRF_GRA }, // 15
1477
1478 { "prom17_1", 0x0100, 0xca0af30c, 6 | BRF_GRA }, // 16 Video PROM
1479
1480 { "prom17_2", 0x0100, 0xf3c55174, 6 | BRF_OPT }, // 17 Unused PROMs
1481 };
1482
1483 STD_ROM_PICK(farmer)
1484 STD_ROM_FN(farmer)
1485
1486 struct BurnDriver BurnDrvFarmer = {
1487 "farmer", "ikki", NULL, NULL, "1985",
1488 "Farmers Rebellion\0", NULL, "Sun Electronics", "Miscellaneous",
1489 NULL, NULL, NULL, NULL,
1490 BDF_GAME_WORKING | BDF_CLONE | BDF_HISCORE_SUPPORTED, 2, HARDWARE_MISC_PRE90S, GBF_MAZE | GBF_SCRFIGHT, 0,
1491 NULL, farmerRomInfo, farmerRomName, NULL, NULL, NULL, NULL, IkkiInputInfo, IkkiDIPInfo,
1492 IkkiInit, DrvExit, DrvFrame, IkkiDraw, DrvScan, &DrvRecalc, 0x400,
1493 240, 224, 4, 3
1494 };
1495