1 /******************************************************************************
2
3 Video Hardware for Nichibutsu Mahjong series.
4
5 Driver by Takahiro Nogi <nogi@kt.rim.or.jp> 1999/11/05 -
6 Special thanks to Tatsuyuki Satoh
7
8 ******************************************************************************/
9
10 #include "driver.h"
11 #include "vidhrdw/generic.h"
12
13
14 #define VRAM_MAX 2
15
16 #define RASTER_SCROLL 1
17
18 #define SCANLINE_MIN 0
19 #define SCANLINE_MAX 512
20
21
22 static int sailorws_scrollx[VRAM_MAX], sailorws_scrolly[VRAM_MAX];
23 static unsigned char sailorws_scrollx_tmp[VRAM_MAX][2], sailorws_scrolly_tmp[VRAM_MAX][2];
24 #if RASTER_SCROLL
25 static int sailorws_scrollx_raster[VRAM_MAX][SCANLINE_MAX];
26 static int sailorws_scanline[VRAM_MAX];
27 #endif
28 static int sailorws_drawx[VRAM_MAX], sailorws_drawy[VRAM_MAX];
29 static unsigned char sailorws_drawx_tmp[VRAM_MAX][2], sailorws_drawy_tmp[VRAM_MAX][2];
30 static int sailorws_sizex[VRAM_MAX], sailorws_sizey[VRAM_MAX];
31 static int sailorws_radr[VRAM_MAX];
32 static unsigned char sailorws_radr_tmp[VRAM_MAX][3];
33 static int sailorws_gfxflag[VRAM_MAX];
34 static int sailorws_dispflag[VRAM_MAX];
35 static int sailorws_flipscreen[VRAM_MAX];
36 static int sailorws_highcolor[VRAM_MAX];
37 static int sailorws_transparency[VRAM_MAX];
38 static int sailorws_flipx[VRAM_MAX], sailorws_flipy[VRAM_MAX];
39 static int sailorws_paltblnum;
40 static int sailorws_screen_refresh;
41 static int sailorws_gfxflag2;
42 static int gfxdraw_mode;
43
44 static struct mame_bitmap *sailorws_tmpbitmap0, *sailorws_tmpbitmap1;
45 static unsigned short *sailorws_videoram0, *sailorws_videoram1;
46 static unsigned short *sailorws_videoworkram0, *sailorws_videoworkram1;
47 static unsigned char *sailorws_palette, *mscoutm_palette;
48 static unsigned char *sailorws_paltbl0, *sailorws_paltbl1;
49
50
51 static void sailorws_vramflip(int vram);
52 static void sailorws_gfxdraw(int vram);
53 static void mscoutm_gfxdraw(int vram);
54
55
56 /******************************************************************************
57
58
59 ******************************************************************************/
READ_HANDLER(sailorws_palette_r)60 READ_HANDLER( sailorws_palette_r )
61 {
62 return sailorws_palette[offset];
63 }
64
WRITE_HANDLER(sailorws_palette_w)65 WRITE_HANDLER( sailorws_palette_w )
66 {
67 int r, g, b;
68
69 sailorws_palette[offset] = data;
70
71 if (offset & 1)
72 {
73 offset &= 0x1fe;
74
75 r = ((sailorws_palette[offset + 0] & 0x0f) << 4);
76 g = ((sailorws_palette[offset + 0] & 0xf0) << 0);
77 b = ((sailorws_palette[offset + 1] & 0x0f) << 4);
78
79 r = (r | (r >> 4));
80 g = (g | (g >> 4));
81 b = (b | (b >> 4));
82
83 palette_set_color((offset >> 1), r, g, b);
84 }
85 }
86
READ_HANDLER(mscoutm_palette_r)87 READ_HANDLER( mscoutm_palette_r )
88 {
89 return mscoutm_palette[offset];
90 }
91
WRITE_HANDLER(mscoutm_palette_w)92 WRITE_HANDLER( mscoutm_palette_w )
93 {
94 int r, g, b;
95 int offs_h, offs_l;
96
97 mscoutm_palette[offset] = data;
98
99 offs_h = (offset / 0x0300); /* 0x000, 0x300, 0x600, 0x900*/
100 offs_l = (offset & 0x00ff); /* 0x000 - 0x0ff*/
101
102 r = mscoutm_palette[(0x000 + (offs_h * 0x300) + offs_l)];
103 g = mscoutm_palette[(0x100 + (offs_h * 0x300) + offs_l)];
104 b = mscoutm_palette[(0x200 + (offs_h * 0x300) + offs_l)];
105
106 palette_set_color(((offs_h * 0x100) + offs_l), r, g, b);
107 }
108
109 /******************************************************************************
110
111
112 ******************************************************************************/
sailorws_gfxbusy_r(int vram,int offset)113 int sailorws_gfxbusy_r(int vram, int offset)
114 {
115 return 0xfe;
116 }
117
sailorws_scrollx_w(int vram,int offset,int data)118 void sailorws_scrollx_w(int vram, int offset, int data)
119 {
120 #if RASTER_SCROLL
121 int new_line;
122
123 sailorws_scrollx_tmp[vram][offset] = data;
124
125 if (offset)
126 {
127 sailorws_scrollx[vram] = -((((sailorws_scrollx_tmp[vram][0] + (sailorws_scrollx_tmp[vram][1] << 8)) & 0x1ff) + 0x4e) << 1);
128
129 if (gfxdraw_mode != 2)
130 {
131 /* update line scroll position */
132
133 new_line = cpu_getscanline();
134 if (new_line > SCANLINE_MAX) new_line = SCANLINE_MAX;
135
136 if (sailorws_flipscreen[vram])
137 {
138 for ( ; sailorws_scanline[vram] < new_line; sailorws_scanline[vram]++)
139 {
140 sailorws_scrollx_raster[vram][sailorws_scanline[vram]] = sailorws_scrollx[vram];
141 }
142 }
143 else
144 {
145 for ( ; sailorws_scanline[vram] < new_line; sailorws_scanline[vram]++)
146 {
147 sailorws_scrollx_raster[vram][(sailorws_scanline[vram] ^ 0x1ff)] = sailorws_scrollx[vram];
148 }
149 }
150 }
151 }
152 #else
153 sailorws_scrollx_tmp[vram][offset] = data;
154
155 if (offset)
156 {
157 sailorws_scrollx[vram] = -((((sailorws_scrollx_tmp[vram][0] + (sailorws_scrollx_tmp[vram][1] << 8)) & 0x1ff) + 0x4e) << 1);
158 }
159 #endif
160 }
161
sailorws_scrolly_w(int vram,int offset,int data)162 void sailorws_scrolly_w(int vram, int offset, int data)
163 {
164 sailorws_scrolly_tmp[vram][offset] = data;
165
166 if (offset)
167 {
168 if (sailorws_flipscreen[vram]) sailorws_scrolly[vram] = ((sailorws_scrolly_tmp[vram][0] + (sailorws_scrolly_tmp[vram][1] << 8)) ^ 0x1ff) & 0x1ff;
169 else sailorws_scrolly[vram] = (sailorws_scrolly_tmp[vram][0] + (sailorws_scrolly_tmp[vram][1] << 8) + 1) & 0x1ff;
170 }
171 }
172
sailorws_radr_w(int vram,int offset,int data)173 void sailorws_radr_w(int vram, int offset, int data)
174 {
175 sailorws_radr_tmp[vram][offset] = data;
176
177 if (!offset)
178 {
179 sailorws_radr[vram] = (sailorws_radr_tmp[vram][0] + (sailorws_radr_tmp[vram][1] << 8) + (sailorws_radr_tmp[vram][2] << 16));
180 }
181 }
182
sailorws_gfxflag_w(int vram,int offset,int data)183 void sailorws_gfxflag_w(int vram, int offset, int data)
184 {
185 static int sailorws_flipscreen_old[VRAM_MAX] = { -1, -1 };
186
187 sailorws_gfxflag[vram] = data;
188
189 sailorws_flipx[vram] = (data & 0x01) ? 1 : 0;
190 sailorws_flipy[vram] = (data & 0x02) ? 1 : 0;
191 sailorws_highcolor[vram] = (data & 0x04) ? 1 : 0;
192 /* if (data & 0x08) usrintf_showmessage("Unknown GFX Flag!! (0x08)");*/
193 sailorws_transparency[vram] = (data & 0x10) ? 1 : 0;
194 /* if (data & 0x20) usrintf_showmessage("Unknown GFX Flag!! (0x20)");*/
195 sailorws_flipscreen[vram] = (data & 0x40) ? 0 : 1;
196 sailorws_dispflag[vram] = (data & 0x80) ? 1 : 0;
197
198 if (sailorws_flipscreen[vram] != sailorws_flipscreen_old[vram])
199 {
200 sailorws_screen_refresh = 1;
201 sailorws_flipscreen_old[vram] = sailorws_flipscreen[vram];
202 sailorws_vramflip(vram);
203 }
204 }
205
sailorws_sizex_w(int vram,int offset,int data)206 void sailorws_sizex_w(int vram, int offset, int data)
207 {
208 sailorws_sizex[vram] = data;
209 }
210
sailorws_sizey_w(int vram,int offset,int data)211 void sailorws_sizey_w(int vram, int offset, int data)
212 {
213 sailorws_sizey[vram] = data;
214 }
215
sailorws_drawx_w(int vram,int offset,int data)216 void sailorws_drawx_w(int vram, int offset, int data)
217 {
218 sailorws_drawx_tmp[vram][offset] = data;
219
220 if (offset)
221 {
222 sailorws_drawx[vram] = ((sailorws_drawx_tmp[vram][0] + (sailorws_drawx_tmp[vram][1] << 8)) ^ 0x3ff) & 0x3ff;
223 }
224 }
225
sailorws_drawy_w(int vram,int offset,int data)226 void sailorws_drawy_w(int vram, int offset, int data)
227 {
228 sailorws_drawy_tmp[vram][offset] = data;
229
230 if (offset)
231 {
232 sailorws_drawy[vram] = ((sailorws_drawy_tmp[vram][0] + (sailorws_drawy_tmp[vram][1] << 8)) ^ 0x1ff) & 0x1ff;
233
234 if (gfxdraw_mode == 2) mscoutm_gfxdraw(vram);
235 else sailorws_gfxdraw(vram);
236 }
237 }
238
sailorws_paltblnum_w(int data)239 void sailorws_paltblnum_w(int data)
240 {
241 sailorws_paltblnum = data;
242 }
243
WRITE_HANDLER(sailorws_paltbl_0_w)244 WRITE_HANDLER( sailorws_paltbl_0_w )
245 {
246 sailorws_paltbl0[((sailorws_paltblnum & 0xff) * 0x10) + (offset & 0x0f)] = data;
247 }
248
WRITE_HANDLER(sailorws_paltbl_1_w)249 WRITE_HANDLER( sailorws_paltbl_1_w )
250 {
251 sailorws_paltbl1[((sailorws_paltblnum & 0xff) * 0x10) + (offset & 0x0f)] = data;
252 }
253
sailorws_gfxflag2_w(int data)254 void sailorws_gfxflag2_w(int data)
255 {
256 sailorws_gfxflag2 = data;
257 }
258
sailorws_gfxrom_r(int vram,int offset)259 int sailorws_gfxrom_r(int vram, int offset)
260 {
261 unsigned char *GFXROM = memory_region(REGION_GFX1);
262
263 return GFXROM[sailorws_radr[vram]];
264 }
265
266 /******************************************************************************
267
268
269 ******************************************************************************/
sailorws_vramflip(int vram)270 static void sailorws_vramflip(int vram)
271 {
272 int x, y;
273 unsigned short color1, color2;
274 unsigned short *vidram;
275
276 vidram = vram ? sailorws_videoram1 : sailorws_videoram0;
277
278 for (y = 0; y < (Machine->drv->screen_height / 2); y++)
279 {
280 for (x = 0; x < Machine->drv->screen_width; x++)
281 {
282 color1 = vidram[(y * Machine->drv->screen_width) + x];
283 color2 = vidram[((y ^ 0x1ff) * Machine->drv->screen_width) + (x ^ 0x3ff)];
284 vidram[(y * Machine->drv->screen_width) + x] = color2;
285 vidram[((y ^ 0x1ff) * Machine->drv->screen_width) + (x ^ 0x3ff)] = color1;
286 }
287 }
288
289 if (gfxdraw_mode == 2)
290 {
291 vidram = vram ? sailorws_videoworkram1 : sailorws_videoworkram0;
292
293 for (y = 0; y < (Machine->drv->screen_height / 2); y++)
294 {
295 for (x = 0; x < Machine->drv->screen_width; x++)
296 {
297 color1 = vidram[(y * Machine->drv->screen_width) + x];
298 color2 = vidram[((y ^ 0x1ff) * Machine->drv->screen_width) + (x ^ 0x3ff)];
299 vidram[(y * Machine->drv->screen_width) + x] = color2;
300 vidram[((y ^ 0x1ff) * Machine->drv->screen_width) + (x ^ 0x3ff)] = color1;
301 }
302 }
303 }
304 }
305
sailorws_gfxdraw(int vram)306 static void sailorws_gfxdraw(int vram)
307 {
308 unsigned char *GFX = memory_region(REGION_GFX1);
309
310 int x, y;
311 int dx1, dx2, dy;
312 int startx, starty;
313 int sizex, sizey;
314 int skipx, skipy;
315 int ctrx, ctry;
316 int tflag1, tflag2;
317 unsigned char color, color1, color2;
318 unsigned short drawcolor1, drawcolor2;
319 int gfxaddr;
320
321 if (sailorws_flipx[vram])
322 {
323 sailorws_drawx[vram] -= sailorws_sizex[vram];
324 startx = sailorws_sizex[vram];
325 sizex = (sailorws_sizex[vram] + 1);
326 skipx = -1;
327 }
328 else
329 {
330 sailorws_drawx[vram] = (sailorws_drawx[vram] - sailorws_sizex[vram]);
331 startx = 0;
332 sizex = (sailorws_sizex[vram] + 1);
333 skipx = 1;
334 }
335
336 if (sailorws_flipy[vram])
337 {
338 sailorws_drawy[vram] -= (sailorws_sizey[vram] + 1);
339 starty = sailorws_sizey[vram];
340 sizey = (sailorws_sizey[vram] + 1);
341 skipy = -1;
342 }
343 else
344 {
345 sailorws_drawy[vram] = (sailorws_drawy[vram] - sailorws_sizey[vram] - 1);
346 starty = 0;
347 sizey = (sailorws_sizey[vram] + 1);
348 skipy = 1;
349 }
350
351 gfxaddr = ((sailorws_radr[vram] + 2) & 0x00ffffff);
352
353 Machine->pens[0xff] = 0; /* palette_transparent_pen */
354
355 for (y = starty, ctry = sizey; ctry > 0; y += skipy, ctry--)
356 {
357 for (x = startx, ctrx = sizex; ctrx > 0; x += skipx, ctrx--)
358 {
359 if ((gfxaddr > (memory_region_length(REGION_GFX1) - 1)))
360 {
361 #ifdef MAME_DEBUG
362 usrintf_showmessage("GFXROM ADDRESS OVER!!");
363 #endif
364 gfxaddr = 0;
365 }
366
367 color = GFX[gfxaddr++];
368
369 if (sailorws_flipscreen[vram])
370 {
371 dx1 = (((((sailorws_drawx[vram] + x) * 2) + 0) ^ 0x3ff) & 0x3ff);
372 dx2 = (((((sailorws_drawx[vram] + x) * 2) + 1) ^ 0x3ff) & 0x3ff);
373 dy = (((sailorws_drawy[vram] + y) ^ 0x1ff) & 0x1ff);
374 }
375 else
376 {
377 dx1 = ((((sailorws_drawx[vram] + x) * 2) + 0) & 0x3ff);
378 dx2 = ((((sailorws_drawx[vram] + x) * 2) + 1) & 0x3ff);
379 dy = ((sailorws_drawy[vram] + y) & 0x1ff);
380 }
381
382 if (sailorws_flipx[vram])
383 {
384 /* flip*/
385 color1 = (color & 0xf0) >> 4;
386 color2 = (color & 0x0f) >> 0;
387 }
388 else
389 {
390 /* normal*/
391 color1 = (color & 0x0f) >> 0;
392 color2 = (color & 0xf0) >> 4;
393 }
394
395 if (!vram)
396 {
397 drawcolor1 = sailorws_paltbl0[(sailorws_paltblnum * 0x10) + color1];
398 drawcolor2 = sailorws_paltbl0[(sailorws_paltblnum * 0x10) + color2];
399 }
400 else
401 {
402 drawcolor1 = sailorws_paltbl1[(sailorws_paltblnum * 0x10) + color1];
403 drawcolor2 = sailorws_paltbl1[(sailorws_paltblnum * 0x10) + color2];
404 }
405
406 if (sailorws_transparency[vram])
407 {
408 tflag1 = (drawcolor1 != 0xff) ? 1 : 0;
409 tflag2 = (drawcolor2 != 0xff) ? 1 : 0;
410 }
411 else
412 {
413 tflag1 = 1;
414 tflag2 = 1;
415 }
416
417 if (!vram)
418 {
419 if (tflag1)
420 {
421 sailorws_videoram0[(dy * Machine->drv->screen_width) + dx1] = drawcolor1;
422 plot_pixel(sailorws_tmpbitmap0, dx1, dy, Machine->pens[drawcolor1]);
423 }
424 if (tflag2)
425 {
426 sailorws_videoram0[(dy * Machine->drv->screen_width) + dx2] = drawcolor2;
427 plot_pixel(sailorws_tmpbitmap0, dx2, dy, Machine->pens[drawcolor2]);
428 }
429 }
430 else
431 {
432 if (tflag1)
433 {
434 sailorws_videoram1[(dy * Machine->drv->screen_width) + dx1] = drawcolor1;
435 plot_pixel(sailorws_tmpbitmap1, dx1, dy, Machine->pens[drawcolor1]);
436 }
437 if (tflag2)
438 {
439 sailorws_videoram1[(dy * Machine->drv->screen_width) + dx2] = drawcolor2;
440 plot_pixel(sailorws_tmpbitmap1, dx2, dy, Machine->pens[drawcolor2]);
441 }
442 }
443 }
444 }
445 }
446
mscoutm_gfxdraw(int vram)447 static void mscoutm_gfxdraw(int vram)
448 {
449 unsigned char *GFX = memory_region(REGION_GFX1);
450
451 int x, y;
452 int dx1, dx2, dy;
453 int startx, starty;
454 int sizex, sizey;
455 int skipx, skipy;
456 int ctrx, ctry;
457 int tflag1, tflag2;
458 unsigned char color, color1, color2;
459 unsigned short drawcolor1, drawcolor2;
460 int gfxaddr;
461
462 if (sailorws_highcolor[vram])
463 {
464 /* NB22090 high color mode*/
465 sailorws_sizex[vram] = (GFX[((sailorws_radr[vram] + 0) & 0x00ffffff)] & 0xff);
466 sailorws_sizey[vram] = (GFX[((sailorws_radr[vram] + 1) & 0x00ffffff)] & 0xff);
467 }
468
469 if (sailorws_flipx[vram])
470 {
471 sailorws_drawx[vram] -= sailorws_sizex[vram];
472 startx = sailorws_sizex[vram];
473 sizex = (sailorws_sizex[vram] + 1);
474 skipx = -1;
475 }
476 else
477 {
478 sailorws_drawx[vram] = (sailorws_drawx[vram] - sailorws_sizex[vram]);
479 startx = 0;
480 sizex = (sailorws_sizex[vram] + 1);
481 skipx = 1;
482 }
483
484 if (sailorws_flipy[vram])
485 {
486 sailorws_drawy[vram] -= (sailorws_sizey[vram] + 1);
487 starty = sailorws_sizey[vram];
488 sizey = (sailorws_sizey[vram] + 1);
489 skipy = -1;
490 }
491 else
492 {
493 sailorws_drawy[vram] = (sailorws_drawy[vram] - sailorws_sizey[vram] - 1);
494 starty = 0;
495 sizey = (sailorws_sizey[vram] + 1);
496 skipy = 1;
497 }
498
499 gfxaddr = ((sailorws_radr[vram] + 2) & 0x00ffffff);
500
501 Machine->pens[0x0ff] = 0; /* palette_transparent_pen */
502 Machine->pens[0x1ff] = 0; /* palette_transparent_pen */
503
504 for (y = starty, ctry = sizey; ctry > 0; y += skipy, ctry--)
505 {
506 for (x = startx, ctrx = sizex; ctrx > 0; x += skipx, ctrx--)
507 {
508 if ((gfxaddr > (memory_region_length(REGION_GFX1) - 1)))
509 {
510 #ifdef MAME_DEBUG
511 usrintf_showmessage("GFXROM ADDRESS OVER!!");
512 #endif
513 gfxaddr = 0;
514 }
515
516 color = GFX[gfxaddr++];
517
518 if (sailorws_flipscreen[vram])
519 {
520 dx1 = (((((sailorws_drawx[vram] + x) * 2) + 0) ^ 0x3ff) & 0x3ff);
521 dx2 = (((((sailorws_drawx[vram] + x) * 2) + 1) ^ 0x3ff) & 0x3ff);
522 dy = (((sailorws_drawy[vram] + y) ^ 0x1ff) & 0x1ff);
523 }
524 else
525 {
526 dx1 = ((((sailorws_drawx[vram] + x) * 2) + 0) & 0x3ff);
527 dx2 = ((((sailorws_drawx[vram] + x) * 2) + 1) & 0x3ff);
528 dy = ((sailorws_drawy[vram] + y) & 0x1ff);
529 }
530
531 if (sailorws_flipx[vram])
532 {
533 /* flip*/
534 color1 = (color & 0xf0) >> 4;
535 color2 = (color & 0x0f) >> 0;
536 }
537 else
538 {
539 /* normal*/
540 color1 = (color & 0x0f) >> 0;
541 color2 = (color & 0xf0) >> 4;
542 }
543
544 if (sailorws_highcolor[vram])
545 {
546 /* high color mode*/
547
548 if (sailorws_gfxflag2 & 0xc0)
549 {
550 /* high color mode 1st draw*/
551
552 drawcolor1 = ((color1 & 0x0f) << 0);
553 drawcolor2 = ((color2 & 0x0f) << 0);
554
555 if (!vram)
556 {
557 sailorws_videoworkram0[(dy * Machine->drv->screen_width) + dx1] = drawcolor1;
558 sailorws_videoworkram0[(dy * Machine->drv->screen_width) + dx2] = drawcolor2;
559 }
560 else
561 {
562 sailorws_videoworkram1[(dy * Machine->drv->screen_width) + dx1] = drawcolor1;
563 sailorws_videoworkram1[(dy * Machine->drv->screen_width) + dx2] = drawcolor2;
564 }
565 continue;
566 }
567 else
568 {
569 /* high color mode 2nd draw*/
570
571 drawcolor1 = ((color1 & 0x0f) << 4);
572 drawcolor2 = ((color2 & 0x0f) << 4);
573
574 if (!vram)
575 {
576 drawcolor1 |= sailorws_videoworkram0[(dy * Machine->drv->screen_width) + dx1];
577 drawcolor2 |= sailorws_videoworkram0[(dy * Machine->drv->screen_width) + dx2];
578
579 drawcolor1 += sailorws_paltbl0[(sailorws_paltblnum * 0x10)];
580 drawcolor2 += sailorws_paltbl0[(sailorws_paltblnum * 0x10)];
581 }
582 else
583 {
584 drawcolor1 |= sailorws_videoworkram1[(dy * Machine->drv->screen_width) + dx1];
585 drawcolor2 |= sailorws_videoworkram1[(dy * Machine->drv->screen_width) + dx2];
586
587 drawcolor1 += sailorws_paltbl1[(sailorws_paltblnum * 0x10)];
588 drawcolor2 += sailorws_paltbl1[(sailorws_paltblnum * 0x10)];
589 }
590 }
591 }
592 else
593 {
594 /* normal color mode*/
595
596 if (!vram)
597 {
598 drawcolor1 = sailorws_paltbl0[(sailorws_paltblnum * 0x10) + color1];
599 drawcolor2 = sailorws_paltbl0[(sailorws_paltblnum * 0x10) + color2];
600 }
601 else
602 {
603 drawcolor1 = sailorws_paltbl1[(sailorws_paltblnum * 0x10) + color1];
604 drawcolor2 = sailorws_paltbl1[(sailorws_paltblnum * 0x10) + color2];
605 }
606 }
607
608 if (sailorws_transparency[vram])
609 {
610 tflag1 = (drawcolor1 != 0xff) ? 1 : 0;
611 tflag2 = (drawcolor2 != 0xff) ? 1 : 0;
612 }
613 else
614 {
615 tflag1 = 1;
616 tflag2 = 1;
617 }
618
619 drawcolor1 |= (0x100 * vram);
620 drawcolor2 |= (0x100 * vram);
621
622 if (!vram)
623 {
624 if (tflag1)
625 {
626 sailorws_videoram0[(dy * Machine->drv->screen_width) + dx1] = drawcolor1;
627 plot_pixel(sailorws_tmpbitmap0, dx1, dy, Machine->pens[drawcolor1]);
628 }
629 if (tflag2)
630 {
631 sailorws_videoram0[(dy * Machine->drv->screen_width) + dx2] = drawcolor2;
632 plot_pixel(sailorws_tmpbitmap0, dx2, dy, Machine->pens[drawcolor2]);
633 }
634 }
635 else
636 {
637 if (tflag1)
638 {
639 sailorws_videoram1[(dy * Machine->drv->screen_width) + dx1] = drawcolor1;
640 plot_pixel(sailorws_tmpbitmap1, dx1, dy, Machine->pens[drawcolor1]);
641 }
642 if (tflag2)
643 {
644 sailorws_videoram1[(dy * Machine->drv->screen_width) + dx2] = drawcolor2;
645 plot_pixel(sailorws_tmpbitmap1, dx2, dy, Machine->pens[drawcolor2]);
646 }
647 }
648 }
649 }
650
651 if (sailorws_highcolor[vram])
652 {
653 /* NB22090 high color mode*/
654 sailorws_radr[vram] = gfxaddr;
655 }
656 }
657
658 /******************************************************************************
659
660
661 ******************************************************************************/
WRITE_HANDLER(sailorws_gfxflag_0_w)662 WRITE_HANDLER( sailorws_gfxflag_0_w ) { sailorws_gfxflag_w(0, offset, data); }
WRITE_HANDLER(sailorws_scrollx_0_w)663 WRITE_HANDLER( sailorws_scrollx_0_w ) { sailorws_scrollx_w(0, offset, data); }
WRITE_HANDLER(sailorws_scrolly_0_w)664 WRITE_HANDLER( sailorws_scrolly_0_w ) { sailorws_scrolly_w(0, offset, data); }
WRITE_HANDLER(sailorws_radr_0_w)665 WRITE_HANDLER( sailorws_radr_0_w ) { sailorws_radr_w(0, offset, data); }
WRITE_HANDLER(sailorws_sizex_0_w)666 WRITE_HANDLER( sailorws_sizex_0_w ) { sailorws_sizex_w(0, offset, data); }
WRITE_HANDLER(sailorws_sizey_0_w)667 WRITE_HANDLER( sailorws_sizey_0_w ) { sailorws_sizey_w(0, offset, data); }
WRITE_HANDLER(sailorws_drawx_0_w)668 WRITE_HANDLER( sailorws_drawx_0_w ) { sailorws_drawx_w(0, offset, data); }
WRITE_HANDLER(sailorws_drawy_0_w)669 WRITE_HANDLER( sailorws_drawy_0_w ) { sailorws_drawy_w(0, offset, data); }
670
WRITE_HANDLER(sailorws_gfxflag_1_w)671 WRITE_HANDLER( sailorws_gfxflag_1_w ) { sailorws_gfxflag_w(1, offset, data); }
WRITE_HANDLER(sailorws_scrollx_1_w)672 WRITE_HANDLER( sailorws_scrollx_1_w ) { sailorws_scrollx_w(1, offset, data); }
WRITE_HANDLER(sailorws_scrolly_1_w)673 WRITE_HANDLER( sailorws_scrolly_1_w ) { sailorws_scrolly_w(1, offset, data); }
WRITE_HANDLER(sailorws_radr_1_w)674 WRITE_HANDLER( sailorws_radr_1_w ) { sailorws_radr_w(1, offset, data); }
WRITE_HANDLER(sailorws_sizex_1_w)675 WRITE_HANDLER( sailorws_sizex_1_w ) { sailorws_sizex_w(1, offset, data); }
WRITE_HANDLER(sailorws_sizey_1_w)676 WRITE_HANDLER( sailorws_sizey_1_w ) { sailorws_sizey_w(1, offset, data); }
WRITE_HANDLER(sailorws_drawx_1_w)677 WRITE_HANDLER( sailorws_drawx_1_w ) { sailorws_drawx_w(1, offset, data); }
WRITE_HANDLER(sailorws_drawy_1_w)678 WRITE_HANDLER( sailorws_drawy_1_w ) { sailorws_drawy_w(1, offset, data); }
679
READ_HANDLER(sailorws_gfxbusy_0_r)680 READ_HANDLER( sailorws_gfxbusy_0_r ) { return sailorws_gfxbusy_r(0, offset); }
READ_HANDLER(sailorws_gfxbusy_1_r)681 READ_HANDLER( sailorws_gfxbusy_1_r ) { return sailorws_gfxbusy_r(1, offset); }
READ_HANDLER(sailorws_gfxrom_0_r)682 READ_HANDLER( sailorws_gfxrom_0_r ) { return sailorws_gfxrom_r(0, offset); }
READ_HANDLER(sailorws_gfxrom_1_r)683 READ_HANDLER( sailorws_gfxrom_1_r ) { return sailorws_gfxrom_r(1, offset); }
684
685 /******************************************************************************
686
687
688 ******************************************************************************/
VIDEO_START(sailorws)689 VIDEO_START( sailorws )
690 {
691 if ((sailorws_tmpbitmap0 = auto_bitmap_alloc(Machine->drv->screen_width, Machine->drv->screen_height)) == 0) return 1;
692 if ((sailorws_tmpbitmap1 = auto_bitmap_alloc(Machine->drv->screen_width, Machine->drv->screen_height)) == 0) return 1;
693 if ((sailorws_videoram0 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
694 if ((sailorws_videoram1 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
695 if ((sailorws_palette = auto_malloc(0x200 * sizeof(char))) == 0) return 1;
696 if ((sailorws_paltbl0 = auto_malloc(0x1000 * sizeof(char))) == 0) return 1;
697 if ((sailorws_paltbl1 = auto_malloc(0x1000 * sizeof(char))) == 0) return 1;
698 memset(sailorws_videoram0, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
699 memset(sailorws_videoram1, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
700 #if RASTER_SCROLL
701 sailorws_scanline[0] = sailorws_scanline[1] = SCANLINE_MIN;
702 #endif
703 gfxdraw_mode = 1;
704 return 0;
705 }
706
VIDEO_START(mjkoiura)707 VIDEO_START( mjkoiura )
708 {
709 if ((sailorws_tmpbitmap0 = auto_bitmap_alloc(Machine->drv->screen_width, Machine->drv->screen_height)) == 0) return 1;
710 if ((sailorws_videoram0 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
711 if ((sailorws_palette = auto_malloc(0x200 * sizeof(char))) == 0) return 1;
712 if ((sailorws_paltbl0 = auto_malloc(0x1000 * sizeof(char))) == 0) return 1;
713 memset(sailorws_videoram0, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
714 #if RASTER_SCROLL
715 sailorws_scanline[0] = sailorws_scanline[1] = SCANLINE_MIN;
716 #endif
717 gfxdraw_mode = 0;
718 return 0;
719 }
720
VIDEO_START(mscoutm)721 VIDEO_START( mscoutm )
722 {
723 if ((sailorws_tmpbitmap0 = auto_bitmap_alloc(Machine->drv->screen_width, Machine->drv->screen_height)) == 0) return 1;
724 if ((sailorws_tmpbitmap1 = auto_bitmap_alloc(Machine->drv->screen_width, Machine->drv->screen_height)) == 0) return 1;
725 if ((sailorws_videoram0 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
726 if ((sailorws_videoram1 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
727 if ((sailorws_videoworkram0 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
728 if ((sailorws_videoworkram1 = auto_malloc(Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short))) == 0) return 1;
729 if ((mscoutm_palette = auto_malloc(0xc00 * sizeof(char))) == 0) return 1;
730 if ((sailorws_paltbl0 = auto_malloc(0x1000 * sizeof(char))) == 0) return 1;
731 if ((sailorws_paltbl1 = auto_malloc(0x1000 * sizeof(char))) == 0) return 1;
732 memset(sailorws_videoram0, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
733 memset(sailorws_videoram1, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
734 memset(sailorws_videoworkram0, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
735 memset(sailorws_videoworkram1, 0x0000, (Machine->drv->screen_width * Machine->drv->screen_height * sizeof(short)));
736 gfxdraw_mode = 2;
737 return 0;
738 }
739
740 /******************************************************************************
741
742
743 ******************************************************************************/
VIDEO_UPDATE(sailorws)744 VIDEO_UPDATE( sailorws )
745 {
746 int x, y;
747 unsigned short color;
748
749 if (get_vh_global_attribute_changed() || sailorws_screen_refresh)
750 {
751 sailorws_screen_refresh = 0;
752
753 Machine->pens[0xff] = 0; /* palette_transparent_pen */
754
755 for (y = 0; y < Machine->drv->screen_height; y++)
756 {
757 for (x = 0; x < Machine->drv->screen_width; x++)
758 {
759 color = sailorws_videoram0[(y * Machine->drv->screen_width) + x];
760 plot_pixel(sailorws_tmpbitmap0, x, y, Machine->pens[color]);
761 }
762 }
763 if (gfxdraw_mode)
764 {
765 for (y = 0; y < Machine->drv->screen_height; y++)
766 {
767 for (x = 0; x < Machine->drv->screen_width; x++)
768 {
769 color = sailorws_videoram1[(y * Machine->drv->screen_width) + x];
770 plot_pixel(sailorws_tmpbitmap1, x, y, Machine->pens[color]);
771 }
772 }
773 }
774 }
775
776 #if RASTER_SCROLL
777 {
778 int i;
779
780 for (i = 0; i < 2; i++)
781 {
782 if (sailorws_flipscreen[i])
783 {
784 for ( ; sailorws_scanline[i] < SCANLINE_MAX; sailorws_scanline[i]++)
785 {
786 sailorws_scrollx_raster[i][sailorws_scanline[i]] = sailorws_scrollx[i];
787 }
788 }
789 else
790 {
791 for ( ; sailorws_scanline[i] < SCANLINE_MAX; sailorws_scanline[i]++)
792 {
793 sailorws_scrollx_raster[i][(sailorws_scanline[i] ^ 0x1ff)] = sailorws_scrollx[i];
794 }
795 }
796
797 sailorws_scanline[i] = SCANLINE_MIN;
798 }
799 }
800 #endif
801
802 if (sailorws_dispflag[0])
803 {
804 #if RASTER_SCROLL
805 copyscrollbitmap(bitmap, sailorws_tmpbitmap0, SCANLINE_MAX, sailorws_scrollx_raster[0], 1, &sailorws_scrolly[0], &Machine->visible_area, TRANSPARENCY_NONE, 0);
806 #else
807 copyscrollbitmap(bitmap, sailorws_tmpbitmap0, 1, &sailorws_scrollx[0], 1, &sailorws_scrolly[0], &Machine->visible_area, TRANSPARENCY_NONE, 0);
808 #endif
809 }
810 else
811 {
812 fillbitmap(bitmap, Machine->pens[0x0ff], 0);
813 }
814
815 if (gfxdraw_mode)
816 {
817 if (sailorws_dispflag[1])
818 {
819 #if RASTER_SCROLL
820 copyscrollbitmap(bitmap, sailorws_tmpbitmap1, SCANLINE_MAX, sailorws_scrollx_raster[1], 1, &sailorws_scrolly[1], &Machine->visible_area, TRANSPARENCY_PEN, Machine->pens[0x0ff]);
821 #else
822 copyscrollbitmap(bitmap, sailorws_tmpbitmap1, 1, &sailorws_scrollx[1], 1, &sailorws_scrolly[1], &Machine->visible_area, TRANSPARENCY_PEN, Machine->pens[0x0ff]);
823 #endif
824 }
825 }
826 }
827
VIDEO_UPDATE(mscoutm)828 VIDEO_UPDATE( mscoutm )
829 {
830 int x, y;
831 unsigned short color;
832
833 if (get_vh_global_attribute_changed() || sailorws_screen_refresh)
834 {
835 sailorws_screen_refresh = 0;
836
837 Machine->pens[0x0ff] = 0; /* palette_transparent_pen */
838 Machine->pens[0x1ff] = 0; /* palette_transparent_pen */
839
840 for (y = 0; y < Machine->drv->screen_height; y++)
841 {
842 for (x = 0; x < Machine->drv->screen_width; x++)
843 {
844 color = sailorws_videoram0[(y * Machine->drv->screen_width) + x];
845 plot_pixel(sailorws_tmpbitmap0, x, y, Machine->pens[color]);
846 }
847 }
848 if (gfxdraw_mode)
849 {
850 for (y = 0; y < Machine->drv->screen_height; y++)
851 {
852 for (x = 0; x < Machine->drv->screen_width; x++)
853 {
854 color = sailorws_videoram1[(y * Machine->drv->screen_width) + x];
855 plot_pixel(sailorws_tmpbitmap1, x, y, Machine->pens[color]);
856 }
857 }
858 }
859 }
860
861 if (sailorws_dispflag[0])
862 {
863 copyscrollbitmap(bitmap, sailorws_tmpbitmap0, 1, &sailorws_scrollx[0], 1, &sailorws_scrolly[0], &Machine->visible_area, TRANSPARENCY_NONE, 0);
864 }
865 else
866 {
867 fillbitmap(bitmap, Machine->pens[0x0ff], 0);
868 }
869
870 if (gfxdraw_mode)
871 {
872 if (sailorws_dispflag[1])
873 {
874 copyscrollbitmap(bitmap, sailorws_tmpbitmap1, 1, &sailorws_scrollx[1], 1, &sailorws_scrolly[1], &Machine->visible_area, TRANSPARENCY_PEN, Machine->pens[0x1ff]);
875 }
876 }
877 }
878