flstory.c

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

/******************************************************************************/
/*                                                                            */
/*                 TAITO ?-SYSTEM (C) 1986 TAITO CORPORATION                  */
/*                                                                            */
/*                       Z80+Z80+YM2203 [KIKI KAI KAI]                        */
/*                                                                            */
/******************************************************************************/

#include "gameinc.h"
#include "flstory.h"
#include "tc220ioc.h"
#include "taitosnd.h"
#include "2203intf.h"
#include "decode.h"
#include "sasound.h"		// sample support routines
#ifdef RAINE_DEBUG
#include "debug.h"
#endif

static struct DIR_INFO fairy_land_story_dirs[] =
{
   { "fairy_land_story", },
   { "flstory", },
   { NULL, },
};

static struct ROM_INFO fairy_land_story_roms[] =
{
   {   "cpu-a45.15", 0x00004000, 0xf03fc969, 0, 0, 0, },
   {   "cpu-a45.16", 0x00004000, 0x311aa82e, 0, 0, 0, },
   {   "cpu-a45.17", 0x00004000, 0xa2b5d17d, 0, 0, 0, },
   {       "snd.22", 0x00002000, 0xd58b201d, 0, 0, 0, },
   {       "snd.23", 0x00002000, 0x25e7fd9d, 0, 0, 0, },
   {   "vid-a45.06", 0x00004000, 0xdc856a75, 0, 0, 0, },
   {   "vid-a45.07", 0x00004000, 0xaa4b0762, 0, 0, 0, },
   {   "vid-a45.08", 0x00004000, 0xd0b028ca, 0, 0, 0, },
   {   "vid-a45.09", 0x00004000, 0x8336be58, 0, 0, 0, },
   {   "vid-a45.18", 0x00004000, 0x6f08f69e, 0, 0, 0, },
   {   "vid-a45.19", 0x00004000, 0x2b572dc9, 0, 0, 0, },
   {   "vid-a45.20", 0x00004000, 0x1b0edf34, 0, 0, 0, },
   {   "vid-a45.21", 0x00004000, 0xfc382bd1, 0, 0, 0, },
   {           NULL,          0,          0, 0, 0, 0, },
};

static struct INPUT_INFO fairy_land_story_inputs[] =
{
   { KB_DEF_COIN1,        MSG_COIN1,               0x020005, 0x01, BIT_ACTIVE_1 },
   { KB_DEF_COIN2,        MSG_COIN2,               0x020005, 0x02, BIT_ACTIVE_1 },
   { KB_DEF_TILT,         MSG_TILT,                0x020000, 0x04, BIT_ACTIVE_0 },
   { KB_DEF_SERVICE,      MSG_SERVICE,             0x020000, 0x01, BIT_ACTIVE_0 },

   { KB_DEF_P1_START,     MSG_P1_START,            0x020000, 0x08, BIT_ACTIVE_0 },
   { KB_DEF_P1_UP,        MSG_P1_UP,               0x020001, 0x01, BIT_ACTIVE_0 },
   { KB_DEF_P1_DOWN,      MSG_P1_DOWN,             0x020001, 0x02, BIT_ACTIVE_0 },
   { KB_DEF_P1_LEFT,      MSG_P1_LEFT,             0x020001, 0x08, BIT_ACTIVE_0 },
   { KB_DEF_P1_RIGHT,     MSG_P1_RIGHT,            0x020001, 0x04, BIT_ACTIVE_0 },
   { KB_DEF_P1_B1,        MSG_P1_B1,               0x020001, 0x10, BIT_ACTIVE_0 },
   { KB_DEF_P1_B2,        MSG_P1_B2,               0x020001, 0x20, BIT_ACTIVE_0 },

   { KB_DEF_P2_START,     MSG_P2_START,            0x020000, 0x10, BIT_ACTIVE_0 },
   { KB_DEF_P2_UP,        MSG_P2_UP,               0x020002, 0x01, BIT_ACTIVE_0 },
   { KB_DEF_P2_DOWN,      MSG_P2_DOWN,             0x020002, 0x02, BIT_ACTIVE_0 },
   { KB_DEF_P2_LEFT,      MSG_P2_LEFT,             0x020002, 0x08, BIT_ACTIVE_0 },
   { KB_DEF_P2_RIGHT,     MSG_P2_RIGHT,            0x020002, 0x04, BIT_ACTIVE_0 },
   { KB_DEF_P2_B1,        MSG_P2_B1,               0x020002, 0x10, BIT_ACTIVE_0 },
   { KB_DEF_P2_B2,        MSG_P2_B2,               0x020002, 0x20, BIT_ACTIVE_0 },

   { 0,                   NULL,                    0,        0,    0            },
};

static struct DSW_DATA dsw_data_fairy_land_story_0[] =
{
   { MSG_DSWA_BIT1,           0x01, 0x02 },
   { MSG_OFF,                 0x01, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_DSWA_BIT2,           0x02, 0x02 },
   { MSG_OFF,                 0x02, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_TEST_MODE,           0x04, 0x02 },
   { MSG_OFF,                 0x04, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_DEMO_SOUND,          0x08, 0x02 },
   { MSG_ON,                  0x08, 0x00 },
   { MSG_OFF,                 0x00, 0x00 },
   { MSG_DSWA_BIT5,           0x10, 0x02 },
   { MSG_OFF,                 0x10, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_DSWA_BIT6,           0x20, 0x02 },
   { MSG_OFF,                 0x20, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_DSWA_BIT7,           0x40, 0x02 },
   { MSG_OFF,                 0x40, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { MSG_DSWA_BIT8,           0x80, 0x02 },
   { MSG_OFF,                 0x80, 0x00 },
   { MSG_ON,                  0x00, 0x00 },
   { NULL,                    0,    0,   },
};

static struct DSW_INFO fairy_land_story_dsw[] =
{
   { 0x020003, 0xFF, dsw_data_fairy_land_story_0 },
   { 0x020004, 0xFF, dsw_data_default_1 },
   { 0,        0,    NULL,      },
};

static struct VIDEO_INFO fairy_land_story_video =
{
   DrawFLStory,
   256,
   256,
   32,
   VIDEO_ROTATE_NORMAL,
};

static struct YM2203interface ym2203_interface =
{
   1,
   4000000,
   { 0x00ff20c0 },
   {0},
   {0},
   {0},
   {0},
   {NULL}
};

static struct SOUND_INFO fairy_land_story_sound[] =
{
   { SOUND_YM2203,  &ym2203_interface,    },
   { 0,             NULL,                 },
};

struct GAME_MAIN game_fairy_land_story =
{
   fairy_land_story_dirs,
   fairy_land_story_roms,
   fairy_land_story_inputs,
   fairy_land_story_dsw,
   NULL,

   LoadFLStory,
   ClearFLStory,
   &fairy_land_story_video,
   ExecuteFLStoryFrame,
   "flstory",
   "Fairy Land Story",
   NULL,
   COMPANY_ID_TAITO,
   "A45",
   1985,
   fairy_land_story_sound,
   GAME_PLATFORM | GAME_NOT_WORKING,
};

static int romset;

static UINT8 *RAM2;
static UINT8 *ROM2;
static UINT8 *RAM_INPUT;
static UINT8 *RAM_COLOUR;

/* static int spr_mask; */
/* static int tile_mask; */

/*

0000-BFFF BASE ROM
C000-C7FF BG0 RAM
D400-D401 SOUND COMM
DC00-DCBF MCU?
DD00-DEFF ?
E000-E7FF WORK RAM

---

0000-3FFF BASE ROM
C000-C7FF WORK RAM
D800-D800 SOUND COMM

Supported romsets:

0 - A45 - Fairyland Story       - 1985 - ?-System

Todo:

- Many things.

*/

/******************************************************************************/
/* L-SYSTEM Z80 ROM BANKING                                                   */
/******************************************************************************/

static UINT8 Z80Bank;
static UINT8 Z80BankCount;

static UINT8 bank_map[8] =
{
   4,5,6,7,2,3,0,1,
};

void FLStoryBankWrite(UINT16 offset, UINT8 data)
{
   /*#ifdef RAINE_DEBUG
   print_debug("MAIN Bank: %02x [%04x]\n", data, z80pc);
   #endif*/

   if(bank_map[data&7] != Z80Bank){
      Z80Bank = bank_map[data&7];
      memcpy(RAM+0x8000, ROM+(Z80Bank<<14), 0x4000);
   }
}

static UINT8 *ROM_BANK[0x20];
//static UINT8 *ROM_BANK_2[0x20];

void FLStoryNewBankWrite(UINT16 offset, UINT8 data)
{
   /*#ifdef RAINE_DEBUG
   print_debug("MAIN Bank: %02x [%04x]\n", data, z80pc);
   #endif*/

   if(data != Z80Bank){
      if(data<Z80BankCount){
         Z80Bank = data;
         Z80BSetBank( ROM_BANK[Z80Bank] );
      }
      else{
#ifdef RAINE_DEBUG
         print_debug("ROM Bank out of range: %02x [%04x]\n", data, z80pc);
#endif
      }
   }
}

#if 0
// unused !
static UINT16 FLStoryBankRead(UINT16 offset)
{
   return Z80Bank;
}
#endif

/******************************************************************************/
/* K-SYSTEM COMMON RAM                                                        */
/******************************************************************************/

#if 0
// unused !
static void FLStoryCommonRAMWrite(UINT16 offset, UINT8 data)
{
   RAM[0xC000+(offset&0x1FFF)] = data;
}

static UINT8 FLStoryCommonRAMRead(UINT16 offset)
{
   return RAM[0xC000+(offset&0x1FFF)];
}
#endif

/******************************************************************************/
/* K-SYSTEM MCU RAM                                                           */
/******************************************************************************/

static int mcu_enable;

#if 0
// Unused !!!
static void FLStoryMCUWrite(UINT16 offset, UINT8 data)
{
   offset&=0xFF;

   #ifdef RAINE_DEBUG
   print_debug("MCU Write: %02x:%02x [%04x]\n", offset, data, z80pc);
   #endif

   if(mcu_enable!=0){

   switch(offset){
      case 0x01:		// [CREDIT COUNTER] Used by MCU in credit handling
         RAM[offset+0xE800] = data;
      break;
      case 0x0B:		// [DSW A WRITE] Used by MCU in credit handling
         RAM[offset+0xE800] = data;
      break;
      case 0x0C:		// [DSW B WRITE] Used by MCU in credit handling
         RAM[offset+0xE800] = data;
      break;
      case 0x18:		// [LIVES WRITE] CURRENT PLAYER (0x00 - 0x03)
         RAM[offset+0xE800] = data;
      break;
      case 0x19:		// [????? WRITE] CURRENT PLAYER
         RAM[offset+0xE800] = data;
      break;
      case 0x1A:		// [????? WRITE] CURRENT PLAYER
         RAM[offset+0xE800] = data;
      break;
      case 0x90:		// [?????]
      case 0x91:		// [?????]
      case 0x92:		// [?????]
      case 0x93:		// [?????]
      case 0x94:		// [?????]
      case 0x95:		// [?????]
      case 0x96:		// [?????]
      case 0x97:		// [?????]
         RAM[offset+0xE800] = data;
      break;
      case 0xE0:		// [????? WRITE] SOMETHING
         RAM[offset+0xE800] = data;
      break;
      case 0xE1:		// [?????]
      case 0xE2:		// [?????]
      case 0xE3:		// [?????]
      case 0xE4:		// [?????]
      case 0xE5:		// [?????]
      case 0xE6:		// [?????]
      case 0xE7:		// [?????]
      case 0xE8:		// [?????]
      case 0xE9:		// [?????]
      case 0xEA:		// [?????]
      case 0xEB:		// [?????]
      case 0xEC:		// [?????]
      case 0xED:		// [?????]
      case 0xEE:		// [?????]
      case 0xEF:		// [?????]
         RAM[offset+0xE800] = data;
      break;
      default:
         RAM[offset+0xE800] = data;
      break;
   }

   }
   else{

   RAM[offset+0xE800] = data;

   }
}

static UINT8 FLStoryMCURead(UINT16 offset)
{
   offset&=0xFF;

   #ifdef RAINE_DEBUG
   print_debug("MCU Read: %02x:?? [%04x]\n", offset, z80pc);
   #endif

   if(mcu_enable!=0){

   switch(offset){
      case 0x01:		// [CREDIT COUNTER]
         return RAM[offset+0xE800];
      break;
      case 0x02:		// [P1 INPUT]
         return RAM_INPUT[1];
      break;
      case 0x03:		// [P2 INPUT]
         return RAM_INPUT[2];
      break;
      case 0x04:		// [COIN INPUT]
         return RAM_INPUT[5];
      break;
      case 0x05:		// [I/O OK RESPONSE] 0x01 = ERROR
         return 0x00;
      break;
      case 0x06:
         return 0xff;
      break;
      case 0x07:
         return 0x03;
      break;
      case 0x0a:
         if(key[KEY_H]) return 0x03;
         else return 0x00;
         //return RAM[offset+0xE800];	//0x01;
      break;
      case 0x0d:
         return RAM[offset+0xE800];	//0x01;
      break;
      case 0x18:		// [LIVES] CURRENT PLAYER (0x00 - 0x03) (OR CURRENT PLAYER? 0/1 = P1/P2???)
         return RAM[offset+0xE800];
      break;
      case 0x19:		// [?????] CURRENT PLAYER
         return RAM[offset+0xE800];
      break;
      case 0x1A:		// [?????] CURRENT PLAYER
         return RAM[offset+0xE800];
      break;
      case 0x1B:		// [INPUT] CURRENT PLAYER (P1/P2)
         return RAM_INPUT[1];
      break;
      case 0x90:		// [?????]
      case 0x91:		// [?????]
      case 0x92:		// [?????]
      case 0x93:		// [?????]
      case 0x94:		// [?????]
      case 0x95:		// [?????]
      case 0x96:		// [?????]
      case 0x97:		// [?????]
         return RAM[offset+0xE800];
      break;
      case 0xD0:
         return 0xFF;
      break;
      case 0xE0:		// [?????] 8x = READY  0x = WAITING
         return RAM[offset+0xE800] | 0x80;
      break;
      case 0xE1:		// [?????]
      case 0xE2:		// [?????]
      case 0xE3:		// [?????]
      case 0xE4:		// [?????]
      case 0xE5:		// [?????]
      case 0xE6:		// [?????]
      case 0xE7:		// [?????]
      case 0xE8:		// [?????]
      case 0xE9:		// [?????]
      case 0xEA:		// [?????]
      case 0xEB:		// [?????]
      case 0xEC:		// [?????]
      case 0xED:		// [?????]
      case 0xEE:		// [?????]
      case 0xEF:		// [?????]
         return RAM[offset+0xE800];
      break;
      case 0xF1:
         return 0xb3;
      break;
      case 0xF0:
         return 0xff;
      break;
      default:
         return 0x00;
      break;
   }

   }
   else{

   return RAM[offset+0xE800];

   }
}

static void FLStoryF008Write(UINT16 offset, UINT8 data)
{
   #ifdef RAINE_DEBUG
   print_debug("??? Write: %04x:%02x [%04x]\n", offset, data, z80pc);
   #endif

   // Just a hack for the MCU

   if(data==0x1E) mcu_enable = 1;
   else mcu_enable = 0;
}

static void FLStoryF018Write(UINT16 offset, UINT8 data)
{
}

/******************************************************************************/
/* K-SYSTEM INPUT RAM                                                         */
/******************************************************************************/

static void FLStoryInputWrite(UINT16 offset, UINT8 data)
{
   #ifdef RAINE_DEBUG
   print_debug("Input Write: %04x:%02x [%04x]\n", offset, data, z80pc);
   #endif
}

static UINT8 FLStoryInputRead(UINT16 offset)
{
   return RAM_INPUT[0];
}

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