taito.c

这个是延伸mame的在wince平台下的游戏模拟器的代码

/***************************************************************************

  vidhrdw.c

  Functions to emulate the video hardware of the machine.

***************************************************************************/

#include "driver.h"
#include "vidhrdw/generic.h"



unsigned char *taito_videoram2,*taito_videoram3;
unsigned char *taito_characterram;
unsigned char *taito_scrollx1,*taito_scrollx2,*taito_scrollx3;
unsigned char *taito_scrolly1,*taito_scrolly2,*taito_scrolly3;
unsigned char *taito_colscrolly1,*taito_colscrolly2,*taito_colscrolly3;
unsigned char *taito_gfxpointer;
unsigned char *taito_colorbank,*taito_video_priority;
static unsigned char *dirtybuffer2,*dirtybuffer3;
static struct osd_bitmap *tmpbitmap2,*tmpbitmap3;
static unsigned char dirtycharacter1[256],dirtycharacter2[256];
static unsigned char dirtysprite1[64],dirtysprite2[64];
static int taito_video_enable;
static int flipscreen[2];



/***************************************************************************

  Convert the color PROMs into a more useable format.

  The Taito games don't have a color PROM. They use RAM to dynamically
  create the palette. The resolution is 9 bit (3 bits per gun).

  The RAM is connected to the RGB output this way:

  bit 0 -- inverter -- 220 ohm resistor  -- RED
  bit 7 -- inverter -- 470 ohm resistor  -- RED
        -- inverter -- 1  kohm resistor  -- RED
        -- inverter -- 220 ohm resistor  -- GREEN
        -- inverter -- 470 ohm resistor  -- GREEN
        -- inverter -- 1  kohm resistor  -- GREEN
        -- inverter -- 220 ohm resistor  -- BLUE
        -- inverter -- 470 ohm resistor  -- BLUE
  bit 0 -- inverter -- 1  kohm resistor  -- BLUE

***************************************************************************/
void taito_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
{
	int i;
	#define TOTAL_COLORS(gfxn) (Machine->gfx[gfxn]->total_colors * Machine->gfx[gfxn]->color_granularity)
	#define COLOR(gfxn,offs) (colortable[Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + offs])


	/* all gfx elements use the same palette */
	for (i = 0;i < 64;i++)
	{
		COLOR(0,i) = i;
		/* we create both a "normal" lookup table and one where pen 0 is */
		/* always mapped to color 0. This is needed for transparency. */
		if (i % 8 == 0) COLOR(0,i + 64) = 0;
		else COLOR(0,i + 64) = i;
	}
}



void taito_paletteram_w(int offset,int data)
{
	int bit0,bit1,bit2;
	int r,g,b,val;


	paletteram[offset] = data;

	/* red component */
	val = paletteram[offset | 1];
	bit0 = (~val >> 6) & 0x01;
	bit1 = (~val >> 7) & 0x01;
	val = paletteram[offset & ~1];
	bit2 = (~val >> 0) & 0x01;
	r = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;

	/* green component */
	val = paletteram[offset | 1];
	bit0 = (~val >> 3) & 0x01;
	bit1 = (~val >> 4) & 0x01;
	bit2 = (~val >> 5) & 0x01;
	g = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;

	/* blue component */
	val = paletteram[offset | 1];
	bit0 = (~val >> 0) & 0x01;
	bit1 = (~val >> 1) & 0x01;
	bit2 = (~val >> 2) & 0x01;
	b = 0x21 * bit0 + 0x47 * bit1 + 0x97 * bit2;

	palette_change_color(offset / 2,r,g,b);
}



/***************************************************************************

  Start the video hardware emulation.

***************************************************************************/
int taito_vh_start(void)
{
	if (generic_vh_start() != 0)
		return 1;

	if ((dirtybuffer2 = malloc(videoram_size)) == 0)
	{
		generic_vh_stop();
		return 1;
	}
	memset(dirtybuffer2,1,videoram_size);

	if ((dirtybuffer3 = malloc(videoram_size)) == 0)
	{
		free(dirtybuffer2);
		generic_vh_stop();
		return 1;
	}
	memset(dirtybuffer3,1,videoram_size);

	if ((tmpbitmap2 = osd_create_bitmap(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
	{
		free(dirtybuffer3);
		free(dirtybuffer2);
		generic_vh_stop();
		return 1;
	}

	if ((tmpbitmap3 = osd_create_bitmap(Machine->drv->screen_width,Machine->drv->screen_height)) == 0)
	{
		osd_free_bitmap(tmpbitmap2);
		free(dirtybuffer3);
		free(dirtybuffer2);
		generic_vh_stop();
		return 1;
	}

	flipscreen[0] = flipscreen[1] = 0;

	return 0;
}



/***************************************************************************

  Stop the video hardware emulation.

***************************************************************************/
void taito_vh_stop(void)
{
	osd_free_bitmap(tmpbitmap3);
	osd_free_bitmap(tmpbitmap2);
	free(dirtybuffer3);
	free(dirtybuffer2);
	generic_vh_stop();
}



int taito_gfxrom_r(int offset)
{
	int offs;


	offs = taito_gfxpointer[0]+taito_gfxpointer[1]*256;

	taito_gfxpointer[0]++;
	if (taito_gfxpointer[0] == 0) taito_gfxpointer[1]++;

	if (offs < 0x8000)
		return Machine->memory_region[2][offs];
	else return 0;
}



void taito_videoram2_w(int offset,int data)
{
	if (taito_videoram2[offset] != data)
	{
		dirtybuffer2[offset] = 1;

		taito_videoram2[offset] = data;
	}
}



void taito_videoram3_w(int offset,int data)
{
	if (taito_videoram3[offset] != data)
	{
		dirtybuffer3[offset] = 1;

		taito_videoram3[offset] = data;
	}
}



void taito_colorbank_w(int offset,int data)
{
	if (taito_colorbank[offset] != data)
	{
		memset(dirtybuffer,1,videoram_size);
		memset(dirtybuffer2,1,videoram_size);
		memset(dirtybuffer3,1,videoram_size);

		taito_colorbank[offset] = data;
	}
}



void taito_videoenable_w(int offset,int data)
{
	if (taito_video_enable != data)
	{
		if ((taito_video_enable & 3) != (data & 3))
		{
			flipscreen[0] = data & 1;
			flipscreen[1] = data & 2;

			memset(dirtybuffer,1,videoram_size);
			memset(dirtybuffer2,1,videoram_size);
			memset(dirtybuffer3,1,videoram_size);
		}

		taito_video_enable = data;
	}
}



void taito_characterram_w(int offset,int data)
{
	if (taito_characterram[offset] != data)
	{
		if (offset < 0x1800)
		{
			dirtycharacter1[(offset / 8) & 0xff] = 1;
			dirtysprite1[(offset / 32) & 0x3f] = 1;
		}
		else
		{
			dirtycharacter2[(offset / 8) & 0xff] = 1;
			dirtysprite2[(offset / 32) & 0x3f] = 1;
		}

		taito_characterram[offset] = data;
	}
}


/***************************************************************************

  As if the hardware weren't complicated enough, it also has built-in
  collision detection.

  For Alpine Ski, hack offset 1 to return collision half of the time. Otherwise
  offset 3 will be ignored, because all collision detection registers are read
  and copied by the game in order, then the values checked, starting with offset 1.

***************************************************************************/
int taito_collision_detection_r(int offset)
{
	static int alternate_hack = 0;
	extern struct GameDriver frontlin_driver;
	extern struct GameDriver alpine_driver;
	extern struct GameDriver alpinea_driver;

	if (Machine->gamedrv == &alpine_driver || Machine->gamedrv == &alpinea_driver)
	{
		if (offset == 1)	/* simulate collision with other skiers, snowmobile */
			if ((alternate_hack ^= 1) == 1)
				return 0x0f;
		if (offset == 3)	/* simulate collision with rocks, trees, ice, flags, points */
				return 0x0f;
	}
	else if (Machine->gamedrv == &frontlin_driver && (offset == 1 || offset == 2))
		return 0xff;	/* simulate collision for Front Line */

	return 0;
}


void taito_collision_detection_w(int offset,int data)
{
}



/***************************************************************************

  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.