.#cps1.c.1.17

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

    return cps1_game_config->cpsb_value;

   /* some games use as a protection check the ability to do 16-bit multiplies */
   /* with a 32-bit result, by writing the factors to two ports and reading the */
   /* result from two other ports. */
   if (offset && offset == cps1_game_config->mult_result_lo/2)
      return (cps1_output[cps1_game_config->mult_factor1/2] *
            cps1_output[cps1_game_config->mult_factor2/2]) & 0xffff;
   if (offset && offset == cps1_game_config->mult_result_hi/2)
      return (cps1_output[cps1_game_config->mult_factor1/2] *
            cps1_output[cps1_game_config->mult_factor2/2]) >> 16;

   /* Pang 3 EEPROM interface */
   if (cps1_game_config->kludge == 5 && offset == 0x7a/2)
      return cps1_eeprom_port_r(0);

   return cps1_output[offset];
}

static void protection_ww(UINT32 offset, UINT16 data)
{
   /* Pang 3 EEPROM interface */
   if (cps1_game_config->kludge == 5 && offset == 0x7a/2)
   {
      cps1_eeprom_port_w(0,data);
      return;
   }

   cps1_output[offset] = data;
   //data = COMBINE_DATA(&cps1_output[offset]);

#ifdef MAME_DEBUG
if (cps1_game_config->control_reg && offset == cps1_game_config->control_reg/2 && data != 0x3f)
   usrintf_showmessage("control_reg = %04x",data);
#endif
}

static void cps1_ioc_wb(UINT32 offset, UINT8 data)
{
   offset &= 0x1FF;
   if (offset == 0x189) {
     //fprintf(stderr,"sound_fade time %x\n",data);
     cps1_sound_fade_timer = data;
   } else if (offset == 0x181) {
     //fprintf(stderr,"latch %x\n",data);
     latch = data;
   }
}

static void cps1_ioc_ww(UINT32 offset, UINT16 data)
{
   offset &= 0x1FF;
   if (offset == 0x188) {
     cps1_sound_fade_timer = data & 0xff;
   } else if (offset == 0x180) {
     //fprintf(stderr,"latch %x\n",data);
     latch = data & 0xff;
   } else if (offset >= 0x100)
      protection_ww((offset - 0x100)>>1, data);
}

static UINT8 cps1_ioc_rb(UINT32 offset)
{
   offset &= 0x1FF;
   if (offset >= 0x18 && offset <= 0x22) {
     UINT8 input;
     offset = (offset - 0x18) & 0xfe;
     input = input_buffer[offset];
     //fprintf(stderr,"read input %x,%x\n",offset,input);
     
     return input;
   } else if (offset >= 0x100) {
     int ret = protection_rw((offset - 0x100)>>1);
     if (offset & 1) return ret>>8;
     else return ret & 0xff;
   }
   return 0xFF;
}

static UINT16 cps1_ioc_rw(UINT32 offset)
{
   offset &= 0x1FF;
   if(offset < 0x100) {
     if (offset >= 0x18 && offset<=0x22) {
       UINT8 input;
       offset = (offset - 0x18) & 0xfe;
       input = input_buffer[offset];
       return input | (input << 8);
     }
     if (offset == 0 || offset == 0x10)
       fprintf(stderr,"port0_rw\n");
     
     return 0xFFFF;
   } else
      return protection_rw((offset - 0x100)>>1);
}

void cps1_reset_handler(void)
{
#ifdef RAINE_DEBUG
   print_debug("cps1_reset_handler()\n");
#endif
}

static UINT8 *RAM_SCROLL1,*RAM_SCROLL2,*RAM_SCROLL3;

static int layer_id_data[4];

static char *layer_id_name[4] =
{
   "OBJECT", "SCROLL1", "SCROLL2", "SCROLL3",
};

void load_cps1(void)
{
   UINT32 ta,size;
   UINT32 *dest;
   int i,j,size_code;
   UINT8 *cps1_gfx;
   
   RAMSize=0x80000+0x10000;
   
   if(!(RAM=AllocateMem(RAMSize))) return;
     
   cps1_gfxram = RAM+0x010000;
   Z80ROM=load_region[REGION_ROM2];
   Z80RAM=RAM+0x80000;

   memset(Z80RAM, 0x00, 0x8000);
   
   AddZ80AROMBase(Z80ROM, 0x0038, 0x0066);

   AddZ80AReadByte(0x0000, 0x7fFF, NULL, Z80ROM+0x0000); // Z80 ROM/RAM
   AddZ80AReadByte(0x8000, 0xbfff, read_banked, NULL); // bank
   AddZ80AReadByte(0xd000, 0xd7ff, NULL, Z80RAM);
   AddZ80AReadByte(0xf001, 0xf001, YM2151_status_port_0_r, NULL);
   AddZ80AReadByte(0xf002, 0xf002, OKIM6295_status_0_r, NULL);
   AddZ80AReadByte(0xf008, 0xf008, NULL, &latch);
   AddZ80AReadByte(0xf00a, 0xf00a, NULL, &cps1_sound_fade_timer);
   AddZ80AReadByte(0x0000, 0xFFFF, DefBadReadZ80,               NULL);
   AddZ80AReadByte(    -1,     -1, NULL,                        NULL);

   AddZ80AWriteByte(0xd000, 0xd7FF, NULL,                       Z80RAM);
   AddZ80AWriteByte(0xf000, 0xf000, YM2151_register_port_0_w,   NULL);
   AddZ80AWriteByte(0xf001, 0xf001, YM2151_data_port_0_w,   NULL);
   AddZ80AWriteByte(0xf002, 0xf002, OKIM6295_data_0_w,   NULL);
   AddZ80AWriteByte(0xf004, 0xf004, cps1_set_bank,   NULL);
   AddZ80AWriteByte(0x0000, 0xFFFF, DefBadWriteZ80,             NULL);
   AddZ80AWriteByte(    -1,     -1, NULL,                       NULL);

/*      AddTaitoSoundBanking(load_region[REGION_ROM2], */
/*         get_region_size(REGION_ROM2)); */
/*      TaitoSoundSetBank(0,0); */
    cps1_set_bank(0,0);
   // No ports !
   AddZ80AReadPort(0x00, 0xFF, DefBadReadZ80,           NULL);
   AddZ80AReadPort(  -1,   -1, NULL,                    NULL);

   AddZ80AWritePort(0xAA, 0xAA, StopZ80Mode2,           NULL);
   AddZ80AWritePort(0x00, 0xFF, DefBadWriteZ80,         NULL);
   AddZ80AWritePort(  -1,   -1, NULL,                   NULL);

   AddZ80AInit();

   RAM_SPR = RAM+0x004000;
   GFX_SPR = load_region[REGION_GFX1];
   size = get_region_size(REGION_GFX1); // size of packed region

   if (is_current_game("pang3") || is_current_game("pang3j")) {
     // pang3 arrives in a wrong format because of the rom_continue...
     // luckily it's a little rom, we can fix it here with no big overhead...
     UINT8 *tmp;
     int n;
     tmp = AllocateMem(size);

     for (n=0; n<0x100000/2; n++){
       WriteWord(&tmp[n<<3],ReadWord(&GFX_SPR[n<<1]));
       WriteWord(&tmp[(n<<3)+2],ReadWord(&GFX_SPR[(n<<1)+0x200000]));
       WriteWord(&tmp[(n<<3)+4],ReadWord(&GFX_SPR[(n<<1)+0x100000]));
       WriteWord(&tmp[(n<<3)+6],ReadWord(&GFX_SPR[(n<<1)+0x300000]));
     }
     memcpy(GFX_SPR,tmp,size);
     
     FreeMem(tmp);
     EEPROM_init(&pang3_eeprom_interface);
     load_eeprom();
   }
   
   save_file("gfx.bin",GFX_SPR,size);
   cps1_gfx = GFX_SPR;
   
	for (i = 0;i < size/4;i++)
	{
		UINT32 src = cps1_gfx[4*i] + (cps1_gfx[4*i+1]<<8) + (cps1_gfx[4*i+2]<<16) + (cps1_gfx[4*i+3]<<24);
		UINT32 dwval = 0;
		int penusage = 0;

		for (j = 0;j < 8;j++)
		{
			int n = 0;
			UINT32 mask = (0x80808080 >> j) & src;

			if (mask & 0x000000ff) n |= 1;
			if (mask & 0x0000ff00) n |= 2;
			if (mask & 0x00ff0000) n |= 4;
			if (mask & 0xff000000) n |= 8;

			dwval |= n << (j * 4);
			penusage |= 1 << n;
		}
		cps1_gfx[4*i  ] = dwval>>0;
		cps1_gfx[4*i+1] = dwval>>8;
		cps1_gfx[4*i+2] = dwval>>16;
		cps1_gfx[4*i+3] = dwval>>24;
		
	}

	
   GFX_SPR16 = AllocateMem(size*2);
   if (!GFX_SPR16) return;
   
   for(ta=0;ta<size;ta++)
   {
      GFX_SPR[ta] ^= 0xff;
   // Unpack 16x16 sprites (and 32x32)
	  GFX_SPR16[(ta<<1)] = GFX_SPR[ta] & 0xf;
	  GFX_SPR16[(ta<<1)+1] = GFX_SPR[ta] >> 4;
   }

   /* Need to separate 32x32 sprites for rotation... */
   /* This is a terrible waste of memory, but at least it allows more speed */
   GFX_SPR32 = AllocateMem(size*2);
   /* We could avoid copying the whole buffer if we knew where the 32x32 */
   /* sprites are in the buffer. But we know that only once the game has */
   /* started... */
   if (!GFX_SPR32) return;
   memcpy(GFX_SPR32,GFX_SPR16,size*2);
   
   /* rebuild 8x8 sprites */
   GFX_SPR = AllocateMem(size);
   dest= (UINT32*)GFX_SPR;
   
   for (ta=8; ta <size*2; ta+=16) {
     *dest++ = ReadLong(&GFX_SPR16[ta]);
     *dest++ = ReadLong(&GFX_SPR16[ta+4]);
   }
   
   max_sprites = size*2 / 0x100;
   max_sprites8= size / 0x40;
   max_sprites32=max_sprites/4;
   
   GFX_SPR_SOLID = make_solid_mask_8x8(GFX_SPR, max_sprites8);
   GFX_SPR_SOLID16 = make_solid_mask_16x16(GFX_SPR16, max_sprites);
   GFX_SPR_SOLID32 = make_solid_mask_32x32(GFX_SPR32, max_sprites32);
       
   layer_id_data[0] = add_layer_info(layer_id_name[0]);
   layer_id_data[1] = add_layer_info(layer_id_name[1]);
   layer_id_data[2] = add_layer_info(layer_id_name[2]);
   layer_id_data[3] = add_layer_info(layer_id_name[3]);

   memset(RAM+0x00000,0x00,0x80000);
   //memset(RAM+0x00000,0xFF,0x00000);
/*
   // fix checksum

   WriteLong68k(&ROM[0x008EE],0x4E714E71);
   WriteLong68k(&ROM[0x008FE],0x4E714E71);

   // speed hack

   WriteLong68k(&ROM[0x003BA],0x027C7BFF);
   WriteLong68k(&ROM[0x003BE],0x13FC0000);
   WriteLong68k(&ROM[0x003C2],0x00AA0000);

   WriteLong68k(&ROM[0x00436],0x027C7AFF);
   WriteLong68k(&ROM[0x0043A],0x13FC0000);
   WriteLong68k(&ROM[0x0043E],0x00AA0000);

   WriteLong68k(&ROM[0x0045E],0x027C79FF);
   WriteLong68k(&ROM[0x00462],0x13FC0000);
   WriteLong68k(&ROM[0x00466],0x00AA0000);
*/

   cps1_init_machine();

/*
 *  StarScream Main 68000 Setup
 */
   size_code = get_region_size(REGION_ROM1);
   
   ByteSwap(ROM, size_code );
   ByteSwap(RAM,0x080000);
   save_file("rom.bin",ROM,size_code);

   AddResetHandler(&cps1_reset_handler);

   AddMemFetch(0x000000, size_code-1, ROM+0x000000-0x000000);
   AddMemFetch(-1, -1, NULL);

   AddReadBW(0x800000, 0x800001, NULL, &input_buffer[4*2]); // port 4 (ctrl)
   AddReadBW(0x800010, 0x800011, NULL, &input_buffer[4*2]); // port 4 (ctrl)
   
   AddReadBW(0x000000, size_code-1, NULL, ROM+0x000000);                 // 68000 ROM
   AddRWBW(0xFF0000, 0xFFFFFF, NULL, RAM+0x000000);                 // 68000 RAM
   AddRWBW(0x900000, 0x92FFFF, NULL, cps1_gfxram);                 // 68000 RAM
   AddReadByte(0x800000, 0x8001FF, cps1_ioc_rb, NULL);                  // IOC
   AddReadByte(0x000000, 0xFFFFFF, DefBadReadByte, NULL);               // <Bad Reads>
   AddReadByte(-1, -1, NULL, NULL);

   AddReadWord(0x800000, 0x8001FF, cps1_ioc_rw, NULL);                  // IOC
   AddReadWord(0xf1c006, 0xf1c007, cps1_eeprom_port_r, NULL); // eeprom
   AddReadWord(0x000000, 0xFFFFFF, DefBadReadWord, NULL);               // <Bad Reads>
   AddReadWord(-1, -1, NULL, NULL);

   AddWriteByte(0x800000, 0x8001FF, cps1_ioc_wb, NULL);                 // IOC
   AddWriteByte(0xAA0000, 0xAA0001, Stop68000, NULL);                   // Trap Idle 68000
   AddWriteByte(0x000000, 0xFFFFFF, DefBadWriteByte, NULL);             // <Bad Writes>
   AddWriteByte(-1, -1, NULL, NULL);

   AddWriteWord(0x800000, 0x8001FF, cps1_ioc_ww, NULL);                 // IOC
   AddWriteWord(0xf1c006, 0xf1c007, cps1_eeprom_port_w, NULL);
   AddWriteWord(0x000000, 0xFFFFFF, DefBadWriteWord, NULL);             // <Bad Writes>
   AddWriteWord(-1, -1, NULL, NULL);

   AddInitMemory();     // Set Starscream mem pointers...
   RAM_SCROLL1 = NULL; // Init after the 1st frame...

}

void clear_cps1(void)
{
   if (is_current_game("pang3") || is_current_game("pang3j")) {
     save_eeprom();
   }
   #ifdef RAINE_DEBUG
      save_debug("ROM.bin",ROM,get_region_size(REGION_ROM1),1);
      save_debug("RAM.bin",RAM,0x080000,1);
   #endif
}

#define SLICES 4
#define Z80_FRAME CPU_FRAME_MHz(4,60)/SLICES

void execute_cps1_frame(void)
{
  int n;
  cpu_execute_cycles(CPU_68K_0, CPU_FRAME_MHz(10,60));       // Main 68000
   #ifdef RAINE_DEBUG
      print_debug("PC:%06x SR:%04x\n", s68000context.pc, s68000context.sr);
   #endif
   cpu_interrupt(CPU_68K_0, 2);

   if (RaineSoundCard) {
     for (n=0; n< SLICES; n++) {
       cpu_execute_cycles(CPU_Z80_0, Z80_FRAME );        // Sound Z80
#ifdef RAINE_DEBUG
       print_debug("Z80:%04x\n",z80pc);
#endif
       cpu_interrupt(CPU_Z80_0, 0x38);
     }
   }
}

void execute_sf2_frame(void)
{
  int n;
  cpu_execute_cycles(CPU_68K_0, CPU_FRAME_MHz(12,60));       // Main 68000
   #ifdef RAINE_DEBUG
      print_debug("PC:%06x SR:%04x\n", s68000context.pc, s68000context.sr);
   #endif
   cpu_interrupt(CPU_68K_0, 2);

   if (RaineSoundCard) {
     for (n=0; n< SLICES; n++) {
       cpu_execute_cycles(CPU_Z80_0, Z80_FRAME );        // Sound Z80
#ifdef RAINE_DEBUG
       print_debug("Z80:%04x\n",z80pc);
#endif
       cpu_interrupt(CPU_Z80_0, 0x38);
     }
   }
}

static UINT16 oldx,oldy,oldx2,oldy2;

static void render_scroll1() 
{
   int offs,offsy,offsx,sx,sy,code,n,colour,x,y;
   static int scrlxrough,scrlyrough,ytop;
   UINT16 scroll1x = cps1_output[CPS1_SCROLL1_SCROLLX];
   UINT16 scroll1y = cps1_output[CPS1_SCROLL1_SCROLLY];   
   UINT8 *map;

   if (oldx != scroll1x || oldy != scroll1y) {
     scrlxrough=(scroll1x>>3)+4;
     scrlyrough=(scroll1y>>3);
     ytop=-(scroll1y&0x07)+16;

     //fprintf(stderr,"scroll1x %x %x\n",scroll1x,scroll1y);
     oldx = scroll1x;
     oldy = scroll1y;
   }
   
   /* After a bit of fight with the MAKE_SCROLL_xxx macros, I gave up and took the mame method : */
   /* the good old for loops. At least you know where you are everytime !!! */

   /* Here is SCROLL1. Maybe the sprites should be before ? */

   
   sx=-(scroll1x&0x07);
   for (x=0; x<0x35; x++)
     {
       sy=ytop;
       offsx=((scrlxrough+x)*0x80)&0x1fff;
       n=scrlyrough;
       for (y=0; y<0x20; y++,n++)
	 {
	   
	   offsy=( (n&0x1f)*4 | ((n&0x20)*0x100)) & 0x3fff;
	   offs=offsy+offsx;
	   offs &= 0x3fff;
		
	   code  =ReadWord(&RAM_SCROLL1[offs]) + base1;
	   colour=ReadWord(&RAM_SCROLL1[(offs+2)]);

	   if (code < max_sprites8 && GFX_SPR_SOLID[code] &&
	       code != spacechar) {
	       
	   //if (code != 0x5420)
	     //fprintf(stderr,"%d,%d,%x\n",sx,sy,code);
	     MAP_PALETTE_MAPPED_NEW(
				    (colour&0x1F) | 0x20,
				    16,
				    map
				    );
	     if (GFX_SPR_SOLID[code]==1) // Some pixels transp
	       Draw8x8_Trans_Mapped_flip_Rot(&GFX_SPR[code<<6],sx,sy,map,(colour & 0x60)>>5);
	     else // all solid
	       Draw8x8_Mapped_flip_Rot(&GFX_SPR[code<<6],sx,sy,map,(colour & 0x60)>>5);
	   } 
	   sy+=8;