static VIDEO_UPDATE(murogem)
{
int xx,yy,count;
count = 0x000;
fillbitmap(bitmap, 0, cliprect);
for (yy=0;yy<32;yy++)
{
for(xx=0;xx<32;xx++)
{
int tileno = murogem_videoram[count]&0x3f;
int attr = murogem_videoram[count+0x400]&0x0f;
drawgfx(bitmap,machine->gfx[0],tileno,attr,0,0,xx*8,yy*8,cliprect,TRANSPARENCY_PEN,0);
count++;
}
}
return 0;
}
static void canyon_draw_bombs(mame_bitmap *bitmap, const rectangle* cliprect)
{
int i;
for (i = 0; i < 2; i++)
{
int sx = 254 - canyon_videoram[0x3d0 + 2 * i + 0x5];
int sy = 246 - canyon_videoram[0x3d0 + 2 * i + 0xc];
rectangle rect;
rect.min_x = sx;
rect.min_y = sy;
rect.max_x = sx + 1;
rect.max_y = sy + 1;
if (rect.min_x < cliprect->min_x) rect.min_x = cliprect->min_x;
if (rect.min_y < cliprect->min_y) rect.min_y = cliprect->min_y;
if (rect.max_x > cliprect->max_x) rect.max_x = cliprect->max_x;
if (rect.max_y > cliprect->max_y) rect.max_y = cliprect->max_y;
fillbitmap(bitmap, i, &rect);
}
}
static void cgenie_refresh_monitor(mame_bitmap * bitmap, int full_refresh)
{
int i, address, offset, cursor, size, code, x, y;
rectangle r;
if( crt.vertical_displayed == 0 || crt.horizontal_displayed == 0 )
{
fillbitmap(bitmap, Machine->remapped_colortable[0], &Machine->visible_area);
}
else
{
offset = 256 * crt.screen_address_hi + crt.screen_address_lo;
size = crt.horizontal_displayed * crt.vertical_displayed;
cursor = 256 * crt.cursor_address_hi + crt.cursor_address_lo;
if( full_refresh )
{
full_refresh = 0;
fillbitmap(bitmap, Machine->remapped_colortable[0], &Machine->visible_area);
for( i = offset; i < offset + size; i++ )
dirtybuffer[i] = 1;
}
/*
* for every character in the Video RAM, check if it has been modified since
* last time and update it accordingly.
*/
for( address = 0; address < size; address++ )
{
i = (offset + address) & 0x3fff;
x = address % crt.horizontal_displayed + off_x;
y = address / crt.horizontal_displayed;
if( dirtybuffer[i] || (update_all &&
(cleanbuffer[y * 64 + x] != videoram[i] ||
colorbuffer[y * 64 + x] != colorram[i & 0x3ff])) )
{
r.min_x = x * 8;
r.max_x = r.min_x + 7;
r.min_y = y * (crt.scan_lines + 1) + off_y;
r.max_y = r.min_y + crt.scan_lines;
colorbuffer[y * 64 + x] = colorram[i & 0x3ff];
cleanbuffer[y * 64 + x] = videoram[i];
dirtybuffer[i] = 0;
if( graphics )
{
/* get graphics code */
code = videoram[i];
drawgfx(bitmap, Machine->gfx[1], code, 0,
0, 0, r.min_x, r.min_y, &r, TRANSPARENCY_NONE, 0);
}
else
{
/* get character code */
code = videoram[i];
/* translate defined character sets */
code += cgenie_font_offset[(code >> 6) & 3];
drawgfx(bitmap, Machine->gfx[0], code, colorram[i&0x3ff],
0, 0, r.min_x, r.min_y, &r, TRANSPARENCY_NONE, 0);
}
if( i == cursor )
{
rectangle rc;
/* check if cursor turned off */
if( (crt.cursor_top & 0x60) == 0x20 )
continue;
dirtybuffer[i] = 1;
if( (crt.cursor_top & 0x60) == 0x60 )
{
crt.cursor_visible = 1;
}
else
{
crt.cursor_phase++;
crt.cursor_visible = (crt.cursor_phase >> 3) & 1;
}
if( !crt.cursor_visible )
continue;
rc.min_x = r.min_x;
rc.max_x = r.max_x;
rc.min_y = r.min_y + (crt.cursor_top & 15);
rc.max_y = r.min_y + (crt.cursor_bottom & 15);
drawgfx(bitmap, Machine->gfx[0], 0x7f, colorram[i&0x3ff],
0, 0, rc.min_x, rc.min_y, &rc, TRANSPARENCY_NONE, 0);
}
}
}
/***************************************************************************
Draw the game screen in the given osd_bitmap.
Do NOT call osd_update_display() from this function, it will be called by
the main emulation engine.
***************************************************************************/
void gottlieb_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int offs;
/* update palette */
if (palette_recalc())
memset(dirtybuffer, 1, videoram_size);
/* recompute character graphics */
for (offs = 0;offs < Machine->drv->gfxdecodeinfo[0].gfxlayout->total;offs++)
{
if (dirtycharacter[offs])
decodechar(Machine->gfx[0],offs,gottlieb_characterram,Machine->drv->gfxdecodeinfo[0].gfxlayout);
}
/* for every character in the Video RAM, check if it has been modified */
/* since last time and update it accordingly. */
for (offs = videoram_size - 1;offs >= 0;offs--)
{
if (dirtybuffer[offs] || dirtycharacter[videoram[offs]])
{
int sx,sy;
dirtybuffer[offs] = 0;
sx = offs % 32;
sy = offs / 32;
if (hflip) sx = 31 - sx;
if (vflip) sy = 29 - sy;
drawgfx(tmpbitmap,Machine->gfx[0],
videoram[offs],
0,
hflip,vflip,
8*sx,8*sy,
&Machine->visible_area,TRANSPARENCY_NONE,0);
}
}
memset(dirtycharacter,0,MAX_CHARS);
/* copy the character mapped graphics */
if (background_priority)
fillbitmap(bitmap,Machine->pens[0],&Machine->visible_area);
else
copybitmap(bitmap,tmpbitmap,0,0,0,0,&Machine->visible_area,TRANSPARENCY_NONE,0);
/* Draw the sprites. Note that it is important to draw them exactly in this */
/* order, to have the correct priorities. */
for (offs = 0;offs < spriteram_size - 8;offs += 4) /* it seems there's something strange with sprites #62 and #63 */
{
int sx,sy;
/* coordinates hand tuned to make the position correct in Q*Bert Qubes start */
/* of level animation. */
sx = (spriteram[offs + 1]) - 4;
if (hflip) sx = 233 - sx;
sy = (spriteram[offs]) - 13;
if (vflip) sy = 228 - sy;
if (spriteram[offs] || spriteram[offs + 1]) /* needed to avoid garbage on screen */
drawgfx(bitmap,Machine->gfx[1],
(255 ^ spriteram[offs + 2]) + 256 * spritebank,
0,
hflip,vflip,
sx,sy,
&Machine->visible_area,TRANSPARENCY_PEN,0);
}
if (background_priority)
copybitmap(bitmap,tmpbitmap,0,0,0,0,&Machine->visible_area,TRANSPARENCY_COLOR,0);
}
static WRITE16_HANDLER( fifo_clear_w )
{
fillbitmap(sliver_bitmap_fg, 0,0);
fptr=0;
tmp_counter=0;
}
static void draw_sprites(running_machine *machine, mame_bitmap *bitmap, const rectangle *cliprect)
{
int offs;
fillbitmap(priority_bitmap,1,NULL);
for (offs = spriteram_size - 4;offs >= 0;offs -= 4)
{
int sx,sy,flipx,flipy,code,color;
if (machine->gfx[1]->total_elements > 256)
{
/* spriteram
indoor soccer appears to have a slightly different spriteram
format to the other games, allowing a larger number of sprite
tiles
yyyy yyyy xxxx xxxx TX-T pppp tttt tttt
y = ypos
x = xpos
X = x-flip
T = extra tile number bits
p = palette
t = tile number
*/
code = spriteram[offs + 3];
color = spriteram[offs + 2] & 0x0f;
sx = ((spriteram[offs + 1] + 8) & 0xff) - 8;
sy = spriteram[offs];
flipx = spriteram[offs + 2] & 0x40;
flipy = 0;
if (spriteram[offs + 2] & 0x10) code += 0x100;
if (spriteram[offs + 2] & 0x80) code += 0x200;
}
else
{
/* spriteram
this is the standard spriteram layout, used by most games
yyyy yyyy xxxx xxxx YX-p pppp tttt tttt
y = ypos
x = xpos
X = x-flip
Y = y-flip
p = palette
t = tile number
*/
code = spriteram[offs + 3];
color = spriteram[offs + 2] & 0x1f;
sx = ((spriteram[offs + 1] + 8) & 0xff) - 8;
sy = spriteram[offs];
flipx = spriteram[offs + 2] & 0x40;
flipy = spriteram[offs + 2] & 0x80;
}
if (flip_screen)
{
sx = 240 - sx;
sy = 240 - sy;
flipx = !flipx;
flipy = !flipy;
}
/* first draw the sprite, visible */
pdrawgfx(bitmap,machine->gfx[1],
code,
color,
flipx,flipy,
sx,sy,
cliprect,TRANSPARENCY_PENS,0x80ff,
0x00);
/* then draw the mask, behind the background but obscuring following sprites */
pdrawgfx(bitmap,machine->gfx[1],
code,
color,
flipx,flipy,
sx,sy,
cliprect,TRANSPARENCY_PENS,0x7fff,
0x02);
}
}
static VIDEO_UPDATE( cowrace )
{
fillbitmap(bitmap,machine->pens[0],cliprect);
tilemap_draw(bitmap,cliprect, tmap, 0, 0);
return 0;
}
void draw_border(mame_bitmap *bitmap,
int full_refresh, /* Full refresh flag */
int TopBorderLines, /* Border lines before actual screen */
int ScreenLines, /* Screen height in pixels */
int BottomBorderLines, /* Border lines below screen */
int LeftBorderPixels, /* Border pixels to the left of each screen line */
int ScreenPixels, /* Width of actual screen in pixels */
int RightBorderPixels, /* Border pixels to the right of each screen line */
int LeftBorderCycles, /* Cycles taken to draw left border of each scan line */
int ScreenCycles, /* Cycles taken to draw screen data part of each scan line */
int RightBorderCycles, /* Cycles taken to draw right border of each scan line */
int HorizontalRetraceCycles, /* Cycles taken to return to LHS of CRT after each scan line */
int VRetraceTime, /* Cycles taken before start of first border line */
int EventID) /* Event ID of border messages */
{
EVENT_LIST_ITEM *pItem;
int TotalScreenHeight = TopBorderLines+ScreenLines+BottomBorderLines;
int TotalScreenWidth = LeftBorderPixels+ScreenPixels+RightBorderPixels;
int DisplayCyclesPerLine = LeftBorderCycles+ScreenCycles+RightBorderCycles;
int CyclesPerLine = DisplayCyclesPerLine+HorizontalRetraceCycles;
int CyclesSoFar = 0;
int NumItems, CurrItem = 0, NextItem;
int Count, ScrX, NextScrX, ScrY;
rectangle r;
pItem = EventList_GetFirstItem();
NumItems = EventList_NumEvents();
if (NumItems)
{
int CyclesPerFrame = (int)(Machine->drv->cpu[0].cpu_clock / Machine->drv->frames_per_second);
logerror ("Event count = %d, curr cycle = %ld, total cycles = %ld \n", (int) NumItems, (long) TIME_TO_CYCLES(0,cpu_getscanline()*cpu_getscanlineperiod()), (long) CyclesPerFrame);
}
for (Count = 0; Count < NumItems; Count++)
{
logerror ("Event no %05d, ID = %04x, data = %04x, time = %ld\n", Count, pItem[Count].Event_ID, pItem[Count].Event_Data, (long) pItem[Count].Event_Time);
}
/* Find the first and second events with the correct ID */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID))
CurrItem++;
NextItem = CurrItem + 1;
while ((NextItem < NumItems) && (pItem[NextItem].Event_ID != EventID))
NextItem++;
/* Single border colour */
if ((CurrItem < NumItems) && (NextItem >= NumItems))
CurrBorderColor = pItem[CurrItem].Event_Data;
if ((NextItem >= NumItems) && (CurrBorderColor==LastDisplayedBorderColor) && !full_refresh)
{
/* Do nothing if border colour has not changed */
}
else if (NextItem >= NumItems)
{
/* Single border colour - this is not strictly correct as the
colour change may have occurred midway through the frame
or after the last visible border line however the whole
border would be redrawn in the correct colour during the
next frame anyway! */
r.min_x = 0;
r.max_x = TotalScreenWidth-1;
r.min_y = 0;
r.max_y = TopBorderLines-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = 0;
r.max_x = LeftBorderPixels-1;
r.min_y = TopBorderLines;
r.max_y = TopBorderLines+ScreenLines-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = LeftBorderPixels+ScreenPixels;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
r.min_x = 0;
r.max_x = TotalScreenWidth-1;
r.min_y = TopBorderLines+ScreenLines;
r.max_y = TotalScreenHeight-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
logerror ("Setting border colour to %d (Last = %d, Full Refresh = %d)\n", CurrBorderColor, LastDisplayedBorderColor, full_refresh);
LastDisplayedBorderColor = CurrBorderColor;
}
else
{
/* Multiple border colours */
/* Process entries before first displayed line */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= VRetraceTime))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
/* Draw top border */
CyclesSoFar = VRetraceTime;
for (ScrY = 0; ScrY < TopBorderLines; ScrY++)
{
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour on line */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours on a line */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Draw left and right borders next to screen lines */
for (ScrY = TopBorderLines; ScrY < (TopBorderLines+ScreenLines); ScrY++)
{
/* Draw left hand border */
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+LeftBorderCycles)))
{
/* Single colour */
r.max_x = LeftBorderPixels-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)LeftBorderPixels / (float)LeftBorderCycles;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+LeftBorderCycles)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)LeftBorderPixels / (float)LeftBorderCycles;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = LeftBorderPixels-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during screen draw */
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= (CyclesSoFar+LeftBorderCycles+ScreenCycles)))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
/* Draw right hand border */
r.min_x = LeftBorderPixels+ScreenPixels;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours */
ScrX = LeftBorderPixels + ScreenPixels + (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)RightBorderPixels / (float)RightBorderCycles;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = LeftBorderPixels + ScreenPixels + (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)RightBorderPixels / (float)RightBorderCycles;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Draw bottom border */
for (ScrY = TopBorderLines+ScreenLines; ScrY < TotalScreenHeight; ScrY++)
{
r.min_x = 0;
r.min_y = r.max_y = ScrY;
if ((CurrItem >= NumItems) || (pItem[CurrItem].Event_Time >= (CyclesSoFar+DisplayCyclesPerLine)))
{
/* Single colour on line */
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
else
{
/* Multiple colours on a line */
ScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.max_x = ScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time < (CyclesSoFar+DisplayCyclesPerLine)))
{
NextScrX = (int)(pItem[CurrItem].Event_Time - CyclesSoFar) * (float)TotalScreenWidth / (float)DisplayCyclesPerLine;
r.min_x = ScrX;
r.max_x = NextScrX-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
ScrX = NextScrX;
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
r.min_x = ScrX;
r.max_x = TotalScreenWidth-1;
fillbitmap(bitmap, Machine->pens[CurrBorderColor], &r);
}
/* Process colour changes during horizontal retrace */
CyclesSoFar+= CyclesPerLine;
while ((CurrItem < NumItems) && (pItem[CurrItem].Event_Time <= CyclesSoFar))
{
CurrBorderColor = pItem[CurrItem].Event_Data;
do {
CurrItem++;
} while ((CurrItem < NumItems) && (pItem[CurrItem].Event_ID != EventID));
}
}
/* Process colour changes after last displayed line */
while (CurrItem < NumItems)
{
if (pItem[CurrItem].Event_ID == EventID)
CurrBorderColor = pItem[CurrItem].Event_Data;
CurrItem++;
}
/* Set value to ensure redraw on next frame */
LastDisplayedBorderColor = -1;
logerror ("Multi coloured border drawn (last colour = %d)\n", CurrBorderColor);
}
/* Assume all other routines have processed their data from the list */
EventList_Reset();
EventList_SetOffsetStartTime ( TIME_TO_CYCLES(0,cpu_getscanline()*cpu_getscanlineperiod()) );
}
void leprechn_graphics_data_w(int offset,int data)
{
int direction;
if (pending)
{
tmpbitmap->line[pending_y][pending_x] = Machine->pens[pending_color];
rawbitmap[pending_y * screen_width + pending_x] = pending_color;
osd_mark_dirty(pending_x,pending_y,pending_x,pending_y,0);
pending = 0;
}
switch (last_command)
{
// Write Command
case 0x00:
direction = (data & 0xf0) >> 4;
switch (direction)
{
case 0x00:
case 0x04:
case 0x08:
case 0x0c:
break;
case 0x01:
case 0x09:
x++;
break;
case 0x02:
case 0x06:
y++;
break;
case 0x03:
x++;
y++;
break;
case 0x05:
case 0x0d:
x--;
break;
case 0x07:
x--;
y++;
break;
case 0x0a:
case 0x0e:
y--;
break;
case 0x0b:
x++;
y--;
break;
case 0x0f:
x--;
y--;
break;
}
x = x & 0xff;
y = y & 0xff;
pending = 1;
pending_x = x;
pending_y = y;
pending_color = data & 0x0f;
return;
// X Position Write
case 0x08:
x = data;
return;
// Y Position Write
case 0x10:
y = data;
return;
// Clear Bitmap
case 0x18:
fillbitmap(tmpbitmap,Machine->pens[data],0);
memset(rawbitmap, data, screen_width * Machine->drv->screen_height);
osd_mark_dirty(0,0,screen_width-1,Machine->drv->screen_height-1,0);
return;
}
// Just a precaution. Doesn't seem to happen.
if (errorlog) fprintf(errorlog, "Unknown Graphics Command #%2X at %04X\n", last_command, cpu_get_pc());
}
void sprint2_check_collision2(struct osd_bitmap *bitmap)
{
int sx,sy,org_x,org_y;
struct rectangle clip;
int offs;
clip.min_x=0;
clip.max_x=15;
clip.min_y=0;
clip.max_y=7;
/* Clip in relation to the black car. */
org_x=30*8-sprint2_horiz_ram[BLACK_CAR];
org_y=31*8-sprint2_vert_car_ram[BLACK_CAR*2];
fillbitmap(back_vid,Machine->pens[1],&clip);
fillbitmap(grey_cars_vid,Machine->pens[1],&clip);
fillbitmap(white_car_vid,Machine->pens[1],&clip);
fillbitmap(black_car_vid,Machine->pens[1],&clip);
/* Draw the background - a car can overlap up to 6 background squares. */
/* This could be optimized by not drawing all 6 every time. */
offs=((org_y/8)*32) + ((org_x/8)%32);
sx = 8 * (offs % 32)-org_x;
sy = 8 * (offs / 32)-org_y;
drawgfx(back_vid,Machine->gfx[0],
videoram[offs] & 0x3F, (videoram[offs] & 0x80)>>7,
0,0,sx,sy, &clip,TRANSPARENCY_NONE,0);
offs=((org_y/8)*32) + (((org_x+8)/8)%32);
sx = 8 * (offs % 32)-org_x;
sy = 8 * (offs / 32)-org_y;
drawgfx(back_vid,Machine->gfx[0],
videoram[offs] & 0x3F, (videoram[offs] & 0x80)>>7,
0,0,sx,sy, &clip,TRANSPARENCY_NONE,0);
offs=((org_y/8)*32) + (((org_x+16)/8)%32);
sx = 8 * (offs % 32)-org_x;
sy = 8 * (offs / 32)-org_y;
drawgfx(back_vid,Machine->gfx[0],
videoram[offs] & 0x3F, (videoram[offs] & 0x80)>>7,
0,0,sx,sy, &clip,TRANSPARENCY_NONE,0);
offs=(((org_y+8)/8)*32) + ((org_x/8)%32);
sx = 8 * (offs % 32)-org_x;
sy = 8 * (offs / 32)-org_y;
drawgfx(back_vid,Machine->gfx[0],
videoram[offs] & 0x3F, (videoram[offs] & 0x80)>>7,
0,0,sx,sy, &clip,TRANSPARENCY_NONE,0);
offs=(((org_y+8)/8)*32) + (((org_x+8)/8)%32);
sx = 8 * (offs % 32)-org_x;
sy = 8 * (offs / 32)-org_y;
drawgfx(back_vid,Machine->gfx[0],
videoram[offs] & 0x3F, (videoram[offs] & 0x80)>>7,
0,0,sx,sy, &clip,TRANSPARENCY_NONE,0);
offs=(((org_y+8)/8)*32) + (((org_x+16)/8)%32);
sx = 8 * (offs % 32)-org_x;
sy = 8 * (offs / 32)-org_y;
drawgfx(back_vid,Machine->gfx[0],
videoram[offs] & 0x3F, (videoram[offs] & 0x80)>>7,
0,0,sx,sy, &clip,TRANSPARENCY_NONE,0);
/* Grey car 1 */
sx=30*8-sprint2_horiz_ram[GREY_CAR1];
sy=31*8-sprint2_vert_car_ram[GREY_CAR1*2];
sx=sx-org_x;
sy=sy-org_y;
drawgfx(grey_cars_vid,Machine->gfx[1],
(sprint2_vert_car_ram[GREY_CAR1*2+1]>>3), GREY_CAR1,
0,0,sx,sy,&clip,TRANSPARENCY_NONE,0);
/* Grey car 2 */
sx=30*8-sprint2_horiz_ram[GREY_CAR2];
sy=31*8-sprint2_vert_car_ram[GREY_CAR2*2];
sx=sx-org_x;
sy=sy-org_y;
drawgfx(grey_cars_vid,Machine->gfx[1],
(sprint2_vert_car_ram[GREY_CAR2*2+1]>>3), GREY_CAR2,
0,0,sx,sy,&clip,TRANSPARENCY_COLOR,1);
/* White car */
sx=30*8-sprint2_horiz_ram[WHITE_CAR];
sy=31*8-sprint2_vert_car_ram[WHITE_CAR*2];
sx=sx-org_x;
sy=sy-org_y;
drawgfx(white_car_vid,Machine->gfx[1],
(sprint2_vert_car_ram[WHITE_CAR*2+1]>>3), WHITE_CAR,
0,0,sx,sy,&clip,TRANSPARENCY_NONE,0);
/* Black car */
drawgfx(black_car_vid,Machine->gfx[1],
(sprint2_vert_car_ram[BLACK_CAR*2+1]>>3), BLACK_CAR,
0,0,0,0,&clip,TRANSPARENCY_NONE,0);
/* Now check for Collision2 */
for (sy=0;sy<8;sy++)
{
for (sx=0;sx<16;sx++)
{
if (black_car_vid->line[sy][sx]==Machine->pens[0])
{
/* Condition 1 - black car = white car */
if (white_car_vid->line[sy][sx]==Machine->pens[3])
sprint2_collision2_data|=0x40;
/* Condition 2 - black car = grey cars */
if (grey_cars_vid->line[sy][sx]==Machine->pens[2])
sprint2_collision2_data|=0x40;
/* Condition 3 - black car = black playfield (oil) */
if (back_vid->line[sy][sx]==Machine->pens[0])
sprint2_collision2_data|=0x40;
/* Condition 4 - black car = white playfield (track) */
if (back_vid->line[sy][sx]==Machine->pens[3])
sprint2_collision2_data|=0x80;
}
}
}
}
void namcos1_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
{
int i;
struct gfx_object *object;
unsigned short palette_map[MAX_SPRITES+1];
const unsigned char *remapped;
/* update all tilemaps */
#if NAMCOS1_DIRECT_DRAW
if(namcos1_tilemap_used)
{
#endif
for(i=0;i<MAX_PLAYFIELDS;i++)
update_playfield(i);
#if NAMCOS1_DIRECT_DRAW
}
#endif
/* object list (sprite) update */
gfxobj_update();
/* palette resource marking */
palette_init_used_colors();
memset(palette_map, 0, sizeof(palette_map));
for(object=objectlist->first_object ; object!=0 ; object=object->next)
{
if (object->visible)
{
int color = object->color;
if(object->gfx)
{ /* sprite object */
if (sprite_palette_state[color])
{
if (color != 0x7f) namcos1_palette_refresh(16*color, 16*color, 15);
sprite_palette_state[color] = 0;
}
palette_map[color] |= Machine->gfx[2]->pen_usage[object->code];
}
else
{ /* playfield object */
if (tilemap_palette_state[color])
{
namcos1_palette_refresh(128*16+256*color, 128*16+256*playfields[color].color, 256);
#if NAMCOS1_DIRECT_DRAW
if(!namcos1_tilemap_used)
{
/* mark used flag */
memset(&palette_used_colors[color*256+128*16],PALETTE_COLOR_VISIBLE,256);
}
#endif
tilemap_palette_state[color] = 0;
}
}
}
}
for (i = 0; i < MAX_SPRITES; i++)
{
int usage = palette_map[i], j;
if (usage)
{
for (j = 0; j < 15; j++)
if (usage & (1 << j))
palette_used_colors[i * 16 + j] |= PALETTE_COLOR_VISIBLE;
}
}
/* background color */
palette_used_colors[BACKGROUNDCOLOR] |= PALETTE_COLOR_VISIBLE;
if ( ( remapped = palette_recalc() ) )
{
#if NAMCOS1_DIRECT_DRAW
if(namcos1_tilemap_used)
#endif
for (i = 0;i < MAX_PLAYFIELDS;i++)
{
int j;
const unsigned char *remapped_layer = &remapped[128*16+256*i];
for (j = 0;j < 256;j++)
{
if (remapped_layer[j])
{
tilemap_mark_all_pixels_dirty(playfields[i].tilemap);
break;
}
}
}
}
#if NAMCOS1_DIRECT_DRAW
if(namcos1_tilemap_used)
#endif
tilemap_render(ALL_TILEMAPS);
/* background color */
fillbitmap(bitmap,Machine->pens[BACKGROUNDCOLOR],&Machine->visible_area);
/* draw objects (tilemaps and sprites) */
gfxobj_draw(objectlist);
}
static VIDEO_UPDATE(mlanding)
{
fillbitmap(bitmap, get_black_pen(machine), cliprect);
updateChars(machine);
{
int i,dx,dy,j,k,num;
for(i=0;i<0x1000;i+=4)
{
int x,y,code,color;
code=ml_spriteram[i];
x=ml_spriteram[i+1];
y=ml_spriteram[i+2];
color=ml_spriteram[i+3];
dx=x>>11;
dy=y>>11;
dx&=0x1f;
dy&=0x1f;
dx++;
dy++;
x&=0x1ff;
y&=0x1ff;
num=code>>14;
code&=0x1fff;
for(j=0;j<dx;j++)
{
for(k=0;k<dy;k++)
{
//test
if(code)
{
drawgfx(ml_bitmap[num],machine->gfx[0],
code++,
0,
0,0,
x+j*8,y+k*8,
cliprect,TRANSPARENCY_PEN,0);
}
else
{
int xx,yy;
for(yy=0;yy<8;yy++)
for(xx=0;xx<8;xx++)
{
*BITMAP_ADDR16(ml_bitmap[num], y+yy+k*8, x+xx+j*8) = 0; //test only .. ugly
}
}
}
}
}
}
{
int i;
for(i=0;i<7;i++)
{
copybitmap(bitmap,ml_bitmap[i], 0, 0, 0, 0, cliprect, TRANSPARENCY_PEN, 0);
}
}
status_bit=0;
{
/* int i;
for(i=0;i<0x8000;i++)
{
*BITMAP_ADDR16(bitmap, 156+( ml_unk[i]>>8), ml_unk[i]&0xff) = 0x207;
}
*/
}
return 0;
}
