galpanic.c

十七种模拟器源代码 非常有用的作课程设计不可缺少的

   // SOUND

   if(!load_rom("pm008e.l", RAM, 0x80000))   return;
   memcpy(ADPCM,RAM,0x40000);
   memcpy(ADPCM+0x40000,RAM,0x80000);

   if(!load_rom("pm007e.u",ADPCM+0xc0000,0x80000))   return;

   ADPCMSetBuffers(((struct ADPCMinterface*)&galpanic_m6295_interface),ADPCM,0x40000);



   // GFX

   if(!load_rom("pm006e.67", RAM, 0x100000)) return;

   tb = ta = 0;
   for(tt=0; tt<8192; tt++){
	for(t=0; t<8; t++){
		GFX[tb+1]	= RAM[ta]&0x0F;
		GFX[tb+0]	=(RAM[ta]&0xF0) >> 4;
		GFX[tb+3]	= RAM[ta+1]&0x0F;
		GFX[tb+2]	=(RAM[ta+1]&0xF0)>>4;
		GFX[tb+5]	= RAM[ta+2]&0x0F;
		GFX[tb+4]	=(RAM[ta+2]&0xF0)>>4;
		GFX[tb+7]	= RAM[ta+3]&0x0F;
		GFX[tb+6]	=(RAM[ta+3]&0xF0)>>4;
		GFX[tb+9]	= RAM[ta+0+32]&0x0F;
		GFX[tb+8]	=(RAM[ta+0+32]&0xF0)>>4;
		GFX[tb+11]	= RAM[ta+1+32]&0x0F;
		GFX[tb+10]	=(RAM[ta+1+32]&0xF0)>>4;
		GFX[tb+13]	= RAM[ta+2+32]&0x0F;
		GFX[tb+12]	=(RAM[ta+2+32]&0xF0)>>4;
		GFX[tb+15]	= RAM[ta+3+32]&0x0F;
		GFX[tb+14]	=(RAM[ta+3+32]&0xF0)>>4;
		tb+=16;
		ta+=4;
	   }
	  ta+=32;
	   for(t=0;t<8;t++){
		GFX[tb+1]	= RAM[ta]&0x0F;
		GFX[tb+0]	=(RAM[ta]&0xF0) >> 4;
		GFX[tb+3]	= RAM[ta+1]&0x0F;
		GFX[tb+2]	=(RAM[ta+1]&0xF0)>>4;
		GFX[tb+5]	= RAM[ta+2]&0x0F;
		GFX[tb+4]	=(RAM[ta+2]&0xF0)>>4;
		GFX[tb+7]	= RAM[ta+3]&0x0F;
		GFX[tb+6]	=(RAM[ta+3]&0xF0)>>4;
		GFX[tb+9]	= RAM[ta+0+32]&0x0F;
		GFX[tb+8]	=(RAM[ta+0+32]&0xF0)>>4;
		GFX[tb+11]	= RAM[ta+1+32]&0x0F;
		GFX[tb+10]	=(RAM[ta+1+32]&0xF0)>>4;
		GFX[tb+13]	= RAM[ta+2+32]&0x0F;
		GFX[tb+12]	=(RAM[ta+2+32]&0xF0)>>4;
		GFX[tb+15]	= RAM[ta+3+32]&0x0F;
		GFX[tb+14]	=(RAM[ta+3+32]&0xF0)>>4;
		tb+=16;
		ta+=4;
	   }
	ta+=32;
	}

  
   GFX_SOLID = make_solid_mask_16x16( GFX, 8192 );


   // RAM
   memset(RAM+0x00000, 0x00, 0x80000);		// game ram
   memset(RAM+0x80000, 0xFF, 0x20000);		// extra raine ram
   memset(RAM+0x100000, 0x00, 0x10000);		// extra fg ram
   memset(RAM+0x110000, 0x00, 0x20000);		// extra bg ram

   // Color Palette
   InitPaletteMap(RAM+0x82000, 0x40, 0x10, 0x8000);
   set_colour_mapper(&col_map_xrrr_rrgg_gggb_bbbb);
   galpanic_closest_colour_init();



  
/*
 *  StarScream Stuff follows
 */

   ByteSwap(ROM,0x400000);
   ByteSwap(RAM,0x100000);

   AddMemFetch(0x000000, 0x3FFFFF, ROM);				// 68000 ROM
   AddMemFetch(-1, -1, NULL);

   AddReadByte(0x000000, 0x3FFFFF, NULL, ROM+0x000000);			// MRA16_ROM
   AddReadByte(0x400000, 0x400001, OKIM6295_status_0_r, NULL);  	      // ADPCM CHANNEL A
   AddReadByte(0x500000, 0x51FFFF, NULL, RAM+0x000000);			// MRA16_RAM
   AddReadByte(0x520000, 0x53FFFF, NULL, RAM+0x020000);			// MRA16_RAM
   AddReadByte(0x600000, 0x6007FF, NULL, RAM+0x040000);                 // MRA16_RAM
   AddReadByte(0x700000, 0x7047FF, NULL, RAM+0x060000);                 // MRA16_RAM
   AddReadByte(0x800000, 0x800001, NULL, RAM+0x080000);			// input_port_0_word_r
   AddReadByte(0x800002, 0x800003, NULL, RAM+0x080002);			// input_port_1_word_r
   AddReadByte(0x800004, 0x800005, NULL, RAM+0x080004);			// input_port_2_word_r
   AddReadByte(0x000000, 0xFFFFFF, DefBadReadByte, NULL);		// <Bad Reads>
   AddReadByte(-1, -1, NULL, NULL);


   AddReadWord(0x000000, 0x3FFFFF, NULL, ROM+0x000000);			// MRA16_ROM
   AddReadWord(0x400000, 0x400001, OKIM6295_status_0_r, NULL);  	      // ADPCM CHANNEL A
   AddReadWord(0x500000, 0x51FFFF, NULL, RAM+0x000000);			// MRA16_RAM
   AddReadWord(0x520000, 0x53FFFF, NULL, RAM+0x020000);			// MRA16_RAM
   AddReadWord(0x600000, 0x6007FF, NULL, RAM+0x040000);                 // MRA16_RAM
   AddReadWord(0x700000, 0x7047FF, NULL, RAM+0x060000);                 // MRA16_RAM
   AddReadWord(0x800000, 0x800001, NULL, RAM+0x080000);			// input_port_0_word_r
   AddReadWord(0x800002, 0x800003, NULL, RAM+0x080002);			// input_port_1_word_r
   AddReadWord(0x800004, 0x800005, NULL, RAM+0x080004);			// input_port_2_word_r
   AddReadWord(0x000000, 0xFFFFFF, DefBadReadByte, NULL);			// <Bad Reads>
   AddReadWord(-1, -1, NULL, NULL);

   AddWriteByte(0x000000, 0x3FFFFF, NULL, ROM+0x000000);			// MWA16_ROM
   AddWriteByte(0x400000, 0x400001, OKIM6295_data_0_w, NULL);		// ADPCM CHANNEL A
   AddWriteByte(0x500000, 0x51FFFF, galpanic_fg_write_b, NULL);		// MWA16_RAM (video ram)
   AddWriteByte(0x520000, 0x53FFFF, galpanic_bg_write_b, NULL);		// MWA16_RAM (video + work ram)
   AddWriteByte(0x600000, 0x6007FF, NULL, RAM+0x040000);			// MWA16_RAM (palette ram)
   AddWriteByte(0x700000, 0x7047FF, NULL, RAM+0x060000);			// MWA16_RAM (sprite ram)
   AddWriteByte(0x900000, 0x900001, M6295_A_WriteBank_68k, NULL);    	// ADPCM BANKSWITCH
   AddWriteByte(0xa00000, 0xa00001, NULL, RAM+0x80006);			// ???
   AddWriteByte(0xb00000, 0xb00001, NULL, RAM+0x80008);			// ???
   AddWriteByte(0xc00000, 0xc00001, NULL, RAM+0x8000A);			// ???
   AddWriteByte(0x000000, 0xFFFFFF, DefBadWriteByte, NULL);			// <Bad Writes>
   AddWriteByte(-1, -1, NULL, NULL);


   AddWriteWord(0x000000, 0x3FFFFF, NULL, ROM+0x000000);			// MWA16_ROM
   AddWriteWord(0x400000, 0x400001, OKIM6295_data_0_w, NULL);		// ADPCM CHANNEL A
   AddWriteWord(0x500000, 0x51FFFF, galpanic_fg_write_w, NULL);		// MWA16_RAM (fg_video ram)
   if(display_cfg.bpp != 8)
	   AddWriteWord(0x520000, 0x53FFFF, galpanic_bg_write_w, NULL);		// MWA16_RAM (bg_video + work ram)
   else
	   AddWriteWord(0x520000, 0x53FFFF, galpanic_bg_write_8_w, NULL);		// MWA16_RAM (bg_video + work ram)
   AddWriteWord(0x600000, 0x6007FF, galpanic_Palette_Write, NULL);	// MWA16_RAM (palette ram)
   AddWriteWord(0x700000, 0x7047FF, NULL, RAM+0x060000);			// MWA16_RAM (sprite ram)
   AddWriteWord(0x900000, 0x900001, M6295_A_WriteBank_68k, NULL);		// ADPCM BANKSWITCH
   AddWriteWord(0xa00000, 0xa00001, NULL, RAM+0x80006);			// ???
   AddWriteWord(0xb00000, 0xb00001, NULL, RAM+0x80008);			// ???
   AddWriteWord(0xc00000, 0xc00001, NULL, RAM+0x8000A);			// ???
   AddWriteWord(0x000000, 0xFFFFFF, DefBadWriteByte, NULL);			// <Bad Writes>
   AddWriteWord(-1, -1, NULL, NULL);


   AddInitMemory();	// Set Starscream mem pointers...
}


void ClearGalPanic(void)
{
}



void ExecuteGalPanicFrame(void)
{
   cpu_execute_cycles(CPU_68K_0, CPU_FRAME_MHz(8,60));	// M68000 8MHz (60fps)
   cpu_interrupt(CPU_68K_0, 3);					// int3 drives the game
   cpu_interrupt(CPU_68K_0, 5);					// int5 updates palette
}



void DrawGalPanic_Error(){
   clear_game_screen(0);
   print_ingame(60, "Unsupported video-mode. Please use 8 or 16 bit only!");
}



void DrawGalPanic_16(void)
{

   int offs;
   int sx,sy,x,y,scx,scy;
   int code,color,flipx,flipy,attr1,attr2;
   UINT8 *map;
   UINT8 *line;
   UINT8 *video,*video_bg1,*video_bg2;


   ClearPaletteMap();
   clear_game_screen(0);

	//-----------------------------------------------------------------------------
	// VIDEO
	//-----------------------------------------------------------------------------
	MAP_PALETTE_MAPPED_NEW(0, 256, map);

	video 	= VIDEO_FG+16;
	video_bg1	= VIDEO_BG+16;
	video_bg2	= VIDEO_BG+16+0x10000;

	// draw 256 lines high
	for(y=256; y!=0; y--){

		line = GameBitmap->line[y+32]+32;

		// draw 240 pixels wide
		// (we are skipping the first 16 pixels since they are not used).

		for(x=240;x!=0; x--){
			
			if( *(VIDEO_ALPHA + (*video))==0 ){
				// draw foreground
				*line++ = map[(( *video) << 1)];
				*line++ = map[(((*video) << 1)+1)];
			}
			else{

				// draw background
				*line++ = *(video_bg1);
				*line++ = *(video_bg2);
				}
			video++;
			video_bg1++;
			video_bg2++;
		}
		video+=16;
		video_bg1+=16;
		video_bg2+=16;
	}




	//-----------------------------------------------------------------------------
	// SPRITES
	//-----------------------------------------------------------------------------
	sx = sy = 0;
	for(offs=0; offs<18432/2; offs+=16){

		attr2		= RAM_VIDEO_SPR[offs + (7<<1)];
		code		= RAM_VIDEO_SPR[offs + (6<<1)] + ((attr2 & 0x1f) << 8);

		attr1		= RAM_VIDEO_SPR[offs + (3<<1)];
		x		= RAM_VIDEO_SPR[offs + (4<<1)] - ((attr1 & 0x01) << 8);
		y		= RAM_VIDEO_SPR[offs + (5<<1)] + ((attr1 & 0x02) << 7);

		// bit 0 [offs + 0] is used but I don't know what for

		if (attr1 & 0x04){	// Multi sprite
			sx += x;
			sy += y;
		}else{			// Single sprite
			sx = x;
			sy = y;
		}
			
		flipx		= attr2 & 0x80;
		flipy		= attr2 & 0x40;
		color = 16+((attr1 & 0xf0) >> 4);

		if(GFX_SOLID[code]){

			// Need to convert location to screen coordinate..
			// The original game has a rotated screen.
			scx = 256-sy;
			scy = sx+32;

			if( scx>0 && scy>0 && scx<288 && scy<288){
				// set palette
      		      MAP_PALETTE_MAPPED_NEW(color, 16, map);
				// draw palette				
				if(GFX_SOLID[code]==1){			// Some pixels; trans
      	      		switch(attr2&0xC0){
      	            	   case 0x00: Draw16x16_Trans_Mapped_16(&GFX[code<<8], scx, scy, map);        break;
	            	         case 0x40: Draw16x16_Trans_Mapped_16_FlipY(&GFX[code<<8], scx, scy, map);  break;
      	            	   case 0x80: Draw16x16_Trans_Mapped_16_FlipX(&GFX[code<<8], scx, scy, map);  break;
	      	               case 0xC0: Draw16x16_Trans_Mapped_16_FlipXY(&GFX[code<<8], scx, scy, map); break;
					}
	      	      } else{						// all pixels; solid
	            	      switch(attr2&0xC0){
      	            	   case 0x00: Draw16x16_Mapped_16(&GFX[code<<8], scx, scy, map);        break;
	            	         case 0x40: Draw16x16_Mapped_16_FlipY(&GFX[code<<8], scx, scy, map);  break;
      	            	   case 0x80: Draw16x16_Mapped_16_FlipX(&GFX[code<<8], scx, scy, map);  break;
	      	               case 0xC0: Draw16x16_Mapped_16_FlipXY(&GFX[code<<8], scx, scy, map); break;
					}
				}
			}
		}
	}
}


void DrawGalPanic_8(void)
{

   int offs;
   int sx,sy,x,y,scx,scy;
   int code,color,flipx,flipy,attr1,attr2;
   int col_lo, col_hi;
   UINT8 *map;
   UINT8 *line;
   UINT8 *video;


   ClearPaletteMap();
   clear_game_screen(0);

	//-----------------------------------------------------------------------------
	// VIDEO
	//-----------------------------------------------------------------------------
	MAP_PALETTE_MAPPED_NEW(0, 512, map);
	col_hi = col_lo = 0;
	video = VIDEO_FG+16;
	// draw 256 lines high
	for(y=256; y!=0; y--){

		line = GameBitmap->line[y+32]+16;

		// draw 240 pixels wide
		// (we are skipping the first 16 pixels since they are not used).

		for(x=240;x!=0; x--){
			
			if( *(VIDEO_ALPHA + (*video))==0 ){
				// draw foreground
				*line++ = map[*video];
			}
			else{
				// draw background
				col_lo = *(video+0x10000);
//				col_hi = *(video+0x20000);
//				*line++ = map[((col_hi << 8) | (col_lo)) & 0x1FF];
				*line++ = map[col_lo + 256];
				}
			video++;
		}
		video+=16;
	}




	//-----------------------------------------------------------------------------
	// SPRITES
	//-----------------------------------------------------------------------------
	sx = sy = 0;
	for(offs=0; offs<18432/2; offs+=16){

		attr2		= RAM_VIDEO_SPR[offs + (7<<1)];
		code		= RAM_VIDEO_SPR[offs + (6<<1)] + ((attr2 & 0x1f) << 8);

		attr1		= RAM_VIDEO_SPR[offs + (3<<1)];
		x		= RAM_VIDEO_SPR[offs + (4<<1)] - ((attr1 & 0x01) << 8);
		y		= RAM_VIDEO_SPR[offs + (5<<1)] + ((attr1 & 0x02) << 7);

		// bit 0 [offs + 0] is used but I don't know what for

		if (attr1 & 0x04){	// Multi sprite
			sx += x;
			sy += y;
		}else{			// Single sprite
			sx = x;
			sy = y;
		}
			
		flipx		= attr2 & 0x80;
		flipy		= attr2 & 0x40;
		color = 16+((attr1 & 0xf0) >> 4);

		if(GFX_SOLID[code]){

			// Need to convert location to screen coordinate..
			// The original game has a rotated screen.
			scx = 256-sy;
			scy = sx+32;

			if( scx>0 && scy>0 && scx<288 && scy<288){
				// set palette
      		      MAP_PALETTE_MAPPED_NEW(color, 16, map);
			
				// draw palette				
				if(GFX_SOLID[code]==1){			// Some pixels; trans
      	      		switch(attr2&0xC0){
      	            	   case 0x00: Draw16x16_Trans_Mapped(&GFX[code<<8], scx, scy, map);        break;
	            	         case 0x40: Draw16x16_Trans_Mapped_FlipY(&GFX[code<<8], scx, scy, map);  break;
      	            	   case 0x80: Draw16x16_Trans_Mapped_FlipX(&GFX[code<<8], scx, scy, map);  break;
	      	               case 0xC0: Draw16x16_Trans_Mapped_FlipXY(&GFX[code<<8], scx, scy, map); break;
					}
	      	      } else{						// all pixels; solid
	            	      switch(attr2&0xC0){
      	            	   case 0x00: Draw16x16_Mapped(&GFX[code<<8], scx, scy, map);        break;
	            	         case 0x40: Draw16x16_Mapped_FlipY(&GFX[code<<8], scx, scy, map);  break;
      	            	   case 0x80: Draw16x16_Mapped_FlipX(&GFX[code<<8], scx, scy, map);  break;
	      	               case 0xC0: Draw16x16_Mapped_FlipXY(&GFX[code<<8], scx, scy, map); break;
					}
				}
			}
		}
	}
}


void DrawGalPanic(void){
   switch(display_cfg.bpp){
      case 8:
         DrawGalPanic_8();
      break;
      case 15:
         DrawGalPanic_16();
      break;
      case 16:
         DrawGalPanic_16();
      break;
	default:
	   DrawGalPanic_Error();
	break;
   }
}



/******************************************************************************/
/*                                                                            */
/*                     CLOSEST MATCHING COLOUR ROUTINE                        */
/*                                                                            */
/*	( Ripped from "palette.c" and modified to suit this game better )		*/
/*													*/
/******************************************************************************/

static UINT32 gal_col_diff[128*3]; 

void galpanic_closest_colour_init(void)
{
   int i;
   for(i=1; i<64; i++){
      int k = i * i;
      gal_col_diff[0  +i] = gal_col_diff[0  +128-i] = k * (59 * 59);
      gal_col_diff[128+i] = gal_col_diff[128+128-i] = k * (30 * 30);
      gal_col_diff[256+i] = gal_col_diff[256+128-i] = k * (11 * 11);
   }
}

/*
Find the best fitting colour from the dynamic palette (512 colours)
*/

UINT16 galpanic_closest_colour(int r, int g, int b)
{
   int i, coldiff, lowest, bestfit, color;
   RGB rgb;

   bestfit = 0;
   lowest = 0xFFFF;

   // Let's choose from only colors in the range of 384 to 512.
   // We know that these colors stay static during the game
   // so it's a good idea to take one of them.
   i = 256+128;

   do{
	color = (VIDEO_PAL[i<<1]) | ((VIDEO_PAL[(i<<1)+1])<<8);
	rgb.r = (color >> 10) & 0x1F;
	rgb.g = (color >> 5)  & 0x1F;
	rgb.b = (color >> 0)  & 0x1F;

      coldiff = (gal_col_diff + 0) [ (rgb.g - g) & 0x7F ];
      if (coldiff < lowest) {
	 coldiff += (gal_col_diff + 128) [ (rgb.r - r) & 0x7F ];
	 if (coldiff < lowest) {
	    coldiff += (gal_col_diff + 256) [ (rgb.b - b) & 0x7F ];
	    if (coldiff < lowest) {
	       bestfit = i;
	       if (coldiff == 0)
		  return bestfit;
	       lowest = coldiff;
	    }
	 }
      }
      i++;
   }while(i<512);

   return bestfit;
}