nmk.c

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

   32,
   VIDEO_ROTATE_270 |
   VIDEO_ROTATABLE,
};

struct GAME_MAIN game_task_force_harrier =
{
   task_force_harrier_dirs,
   task_force_harrier_roms,
   nmk_inputs,
   task_force_harrier_dsw,
   NULL,

   LoadTaskForceHarrier,
   ClearTaskForceHarrier,
   &task_force_harrier_video,
   ExecuteNMKFrame,
   "tforceh",
   "Task Force Harrier",
   NULL,
   COMPANY_ID_UPL,
   "UPL-89050",
   1989,
   NULL,
   GAME_SHOOT | GAME_NOT_WORKING,
};

static struct DIR_INFO thunder_dragon_dirs[] =
{
   { "thunder_dragon", },
   { "tdragon", },
   { "thunderd", },
   { NULL, },
};

static struct ROM_INFO thunder_dragon_roms[] =
{
   {      "thund.1", 0x00010000, 0xbf493d74, 0, 0, 0, },
   {      "thund.2", 0x00080000, 0xecfea43e, 0, 0, 0, },
   {      "thund.3", 0x00080000, 0xae6875a8, 0, 0, 0, },
   {      "thund.4", 0x00100000, 0x3eedc2fe, 0, 0, 0, },
   {      "thund.5", 0x00100000, 0xd0bde826, 0, 0, 0, },
   {      "thund.6", 0x00020000, 0xfe365920, 0, 0, 0, },
   {      "thund.7", 0x00020000, 0x52192fe5, 0, 0, 0, },
   {      "thund.8", 0x00020000, 0xedd02831, 0, 0, 0, },
   {           NULL,          0,          0, 0, 0, 0, },
};

struct DSW_DATA dsw_data_thunder_dragon_0[] =
{
   { MSG_SCREEN,              0x01, 0x02 },
   { MSG_NORMAL,              0x01, 0x00 },
   { MSG_INVERT,              0x00, 0x00 },
   { "Language",              0x02, 0x02 },
   { "Japanese",              0x02, 0x00 },
   { "English",               0x00, 0x00 },
   { MSG_DIFFICULTY,          0x0c, 0x04 },
   { MSG_NORMAL,              0x0c, 0x00 },
   { MSG_EASY,                0x08, 0x00 },
   { MSG_HARD,                0x04, 0x00 },
   { MSG_HARDEST,             0x00, 0x00 },
   { "Lives",                 0xC0, 0x04 },
   { "3",                     0xC0, 0x00 },
   { "2",                     0x80, 0x00 },
   { "4",                     0x40, 0x00 },
   { "1",                     0x00, 0x00 },
   { NULL,                    0,    0,   },
};

struct DSW_DATA dsw_data_thunder_dragon_1[] =
{
   { MSG_DEMO_SOUND,          0x02, 0x02 },
   { MSG_OFF,                 0x02, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_COIN1,               0xE0, 0x08 }, // Looks ugly and out of order, but it's correct!
   { MSG_1COIN_1PLAY,         0xE0, 0x00 },
   { MSG_1COIN_2PLAY,         0xC0, 0x00 },
   { MSG_1COIN_3PLAY,         0x40, 0x00 },
   { MSG_1COIN_4PLAY,         0x80, 0x00 },
   { MSG_2COIN_1PLAY,         0x60, 0x00 },
   { MSG_3COIN_1PLAY,         0xA0, 0x00 },
   { MSG_4COIN_1PLAY,         0x20, 0x00 },
   { MSG_FREE_PLAY,              0x00, 0x00 },
   { MSG_COIN2,               0x1C, 0x08 },
   { MSG_1COIN_1PLAY,         0x1C, 0x00 },
   { MSG_1COIN_2PLAY,         0x18, 0x00 },
   { MSG_1COIN_3PLAY,         0x08, 0x00 },
   { MSG_1COIN_4PLAY,         0x10, 0x00 },
   { MSG_2COIN_1PLAY,         0x0c, 0x00 },
   { MSG_3COIN_1PLAY,         0x14, 0x00 },
   { MSG_4COIN_1PLAY,         0x04, 0x00 },
   { MSG_FREE_PLAY,              0x00, 0x00 },
   { NULL,                    0,    0,   },
};

static struct DSW_INFO thunder_dragon_dsw[] =
{
   { 0x010008, 0xFF, dsw_data_thunder_dragon_0 },
   { 0x01000A, 0xFF, dsw_data_thunder_dragon_1 },
   { 0,        0,    NULL,      },
};

static struct VIDEO_INFO thunder_dragon_video =
{
   DrawThunderDragon,
   256,
   224,
   32,
   VIDEO_ROTATE_270 |
   VIDEO_ROTATABLE,
};

struct GAME_MAIN game_thunder_dragon =
{
   thunder_dragon_dirs,
   thunder_dragon_roms,
   nmk_inputs,
   thunder_dragon_dsw,
   NULL,

   LoadThunderDragon,
   ClearThunderDragon,
   &thunder_dragon_video,
   ExecuteNMKFrame,
   "tdragon",
   "Thunder Dragon",
   "棆棿",
   COMPANY_ID_NMK,
   NULL,
   1991,
   NULL,
   GAME_SHOOT,
};

static struct DIR_INFO thunder_dragon_bl_dirs[] =
{
   { "thunder_dragon_bl", },
   { "thndrdbl", },
   { "tdragonb", },
   { "thunderd", },
   { ROMOF("tdragon"), },
   { CLONEOF("tdragon"), },
   { NULL, },
};

static struct ROM_INFO thunder_dragon_bl_roms[] =
{
   {    "td_01.bin", 0x00010000, 0xf6f6c4bf, 0, 0, 0, },
   {    "td_02.bin", 0x00010000, 0x99ee7505, 0, 0, 0, },
   {    "td_03.bin", 0x00020000, 0x2fa1aa04, 0, 0, 0, },
   {    "td_04.bin", 0x00020000, 0xe8a62d3e, 0, 0, 0, },
   {    "td_06.bin", 0x00080000, 0xc1be8a4d, 0, 0, 0, },
   {    "td_07.bin", 0x00080000, 0x2c3e371f, 0, 0, 0, },
   {    "td_08.bin", 0x00020000, 0x5144dc69, 0, 0, 0, },
   {    "td_09.bin", 0x00080000, 0xb6e074eb, 0, 0, 0, },
   {    "td_10.bin", 0x00080000, 0xbfd0ec5d, 0, 0, 0, },
   {           NULL,          0,          0, 0, 0, 0, },
};

/*
static struct YM3812interface ym3812_interface =
{
   1,		// 1 chip
   3000000,	// 3 MHz  (emu only)
   { 255 },	// Volume (emu only)
   { NULL }
};

static struct SOUND_INFO thunder_dragon_bl_sound[] =
{
   { SOUND_YM3812,  &ym3812_interface,    },
   { 0,             NULL,                 },
};
*/

struct GAME_MAIN game_thunder_dragon_bl =
{
   thunder_dragon_bl_dirs,
   thunder_dragon_bl_roms,
   nmk_inputs,
   thunder_dragon_dsw,
   NULL,

   LoadThunderDragonBl,
   ClearThunderDragonBl,
   &thunder_dragon_video,
   ExecuteNMKFrame,
   "tdragonb",
   "Thunder Dragon (bootleg)",
   "棆棿 (bootleg)",
   COMPANY_ID_BOOTLEG,
   NULL,
   1991,
   NULL, // Sound does not work and triggers loads of warnings !!!
   //   thunder_dragon_bl_sound,
   GAME_SHOOT,
};

static int scr_x;
static int scr_y;

static UINT8 *RAM_COL;

static UINT8 *GFX_FG0;
static UINT8 *FG0_Mask;

static UINT8 *GFX_SPR;
static UINT8 *SPR_Mask;

static UINT8 *GFX_BG1;
static UINT8 *BG1_Mask;

static UINT8 *GFX_BG0;
static UINT8 *BG0_Mask;

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

static int sport;

static void WriteSound68k(UINT32 address, UINT8 data)
{
   if(data&0xFF){
   sport=data&0xFF;
   #ifdef RAINE_DEBUG
      print_debug("68000 Sends:%02x\n",data);
   #endif
   cpu_int_nmi(CPU_Z80_0);
   }
}

static UINT16 TDSoundReadZ80(UINT16 offset)
{
   UINT8 ta;

   switch(offset&0x1F){
      case 0x08:		// YM3812 TimerA/B
         return 0x60;
      break;
      case 0x10:
      case 0x11:
      case 0x12:
      //   return 0xFE;
      //break;
      case 0x13:
         #ifdef RAINE_DEBUG
         print_debug("Z80 Receives:%02x\n",sport);
         #endif
         ta = sport;
         sport = 0;
         return ta;
      break;
      default:
         ta = 0xFF;
      break;
   }

   #ifdef RAINE_DEBUG
   print_debug("Z80Read:%04x,%02x [%04x]\n",offset,ta,z80pc);
   #endif
   return ta;
}

static void TDSoundWriteZ80(UINT16 offset, UINT8 data)
{
   switch(offset&0x1F){
      case 0x08:
      case 0x09:
         YM3812WriteZ80( (UINT16) (offset&1), data);
      break;
      default:
         #ifdef RAINE_DEBUG
         print_debug("Z80Write:%04x,%02x [%04x]\n",offset,data,z80pc);
         #endif
      break;
   }
}

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

static UINT8 input_mode;

WRITE_HANDLER( bjtwin_oki6295_bankswitch_w )
{
  if ((data & 0x00ff0000) == 0)
	{
	  switch (offset&0xf)
		{
			case 0x00:	OKIM6295_set_bank_base(0, 0, (data & 0x0f) * 0x10000);	break;
			case 0x02:	OKIM6295_set_bank_base(0, 1, (data & 0x0f) * 0x10000);	break;
			case 0x04:	OKIM6295_set_bank_base(0, 2, (data & 0x0f) * 0x10000);	break;
			case 0x06:	OKIM6295_set_bank_base(0, 3, (data & 0x0f) * 0x10000);	break;
			case 0x08:	OKIM6295_set_bank_base(1, 0, (data & 0x0f) * 0x10000);	break;
			case 0x0a:	OKIM6295_set_bank_base(1, 1, (data & 0x0f) * 0x10000);	break;
			case 0x0c:	OKIM6295_set_bank_base(1, 2, (data & 0x0f) * 0x10000);	break;
			case 0x0e:	OKIM6295_set_bank_base(1, 3, (data & 0x0f) * 0x10000);	break;
		}
	}
}

static void NMKVideoWW(UINT32 addr, UINT16 data)
{
   static UINT8 command[2];
   addr &= 0x7FFF;

   WriteWord(&RAM[0x10000+addr],data);

   if((addr>=0x4000)&&(addr<0x4100)){

   data &= 0x00FF;

   switch(addr){
      case 0x4000:
         if(!(command[0]&0x80)){
            command[0] = 0x80;
         }
         else{
            if(data&0x80){
               command[0] = data&0x7F;
               data &= ~0x60;
            }
         }
	 //fprintf(stderr,"BAD\n");
	 OKIM6295_data_0_w(0,data & 0xff);
         //M6295buffer_request(0,data&0xFF);
      break;
      case 0x4010:
         if(!(command[1]&0x80)){
            command[1] = 0x80;
         }
         else{
            if(data&0x80){
               command[1] = data&0x7F;
               data &= ~0x60;
            }
         }
	 //fprintf(stderr,"BAD\n");
	 OKIM6295_data_1_w(1,data & 0xff);
         //M6295buffer_request(1,data&0xFF);
      break;
      default:
	if (addr>=0x4020 && addr<=0x402f)
	  bjtwin_oki6295_bankswitch_w(addr,data);
	  //PCMROM[((addr&0x0008)>>3)*0x100000+((addr&0x0006)>>1)*0x10000]=data&0xf;
	//m6295_bank[(addr&0x0008)>>3][(addr&0x0006)>>1] = data & 0x0F;
      break;
   }

   }
   if(romset==6){
      if(addr==0x001E){
               #ifdef RAINE_DEBUG
               print_ingame(60,"sound_write:%04x",data);
               print_debug("sound_write:%04x\n",data);
               #endif
               WriteSound68k(addr, (UINT8) (data&0xFF) );
      }
   }
}

static void NMKVideoWB(UINT32 addr, UINT8 data)
{
   addr &= 0x7FFF;

   RAM[0x10000+(addr^1)]=data;

   if(romset==4){
      if(addr==0x0013){
         switch(data&0x1F){
            case 0x11:
               input_mode = 0;
            break;
            case 0x12:
               input_mode = 1;
            break;
            case 0x13:
               input_mode = 2;
            break;
            case 0x14:
               input_mode = 3;
            break;
            default:
               #ifdef RAINE_DEBUG
               print_debug("input_write:%02x\n",data&0x1F);
               #endif
            break;
         }
      }
   }
   if(romset==6){
      if(addr==0x001F){
               #ifdef RAINE_DEBUG
               print_ingame(60,"sound_write:%02x",data);
               print_debug("sound_write:%02x\n",data);
               #endif
               WriteSound68k(addr, (UINT8) (data&0xFF) );
      }
   }
}

static UINT16 NMKVideoRW(UINT32 addr)
{
   addr&=0x7FFF;

   if(romset==4){
      if(addr==0x0002){
         switch(input_mode){
            case 0:
               return ~ReadWord(&RAM[0x10004]);	// DSW
            break;
            case 1:
               return ~ReadWord(&RAM[0x10002]);	// PLAYER
            break;
            case 2:
               return ~ReadWord(&RAM[0x10000]);	// COIN
            break;
            case 3:
               return ~ReadWord(&RAM[0x10002]);	// PLAYER
            break;
            default:
               return 0;
            break;
         }
      }
   }

   switch(addr){
      case 0x4000:
	//fprintf(stderr,"BAD\n");
	return OKIM6295_status_0_r( 0 );
	//return M6295buffer_status(0);
         //return 0;
      break;