flstory.c

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

/* K-SYSTEM YM2203 AND DSW ACCESS                                             */
/******************************************************************************/

static UINT8 kiki_ym2203_reg;

// still unused !
static UINT8 FLStoryYM2203Read(UINT16 offset)
{
   //print_debug("YM2203 RB:%04x/?? [%04x]\n", offset, z80pc);

   if((offset&1)==0){
      return 0; //YM2203_status_port_0_r(0);
   }
   else{
      switch(kiki_ym2203_reg){
         case 0x0e: return get_dsw(0);
         case 0x0f: return get_dsw(1);
         default:   return 0; //return YM2203_read_port_0_r(0);
      }
   }
}

static void FLStoryYM2203Write(UINT16 offset, UINT8 data)
{
   //print_debug("YM2203 WB:%04x/%02x [%04x]\n", offset, data, z80pc);

   if((offset&1)==0){
      kiki_ym2203_reg = data;
   }
   else{
      YM2203_control_port_0_w(0,kiki_ym2203_reg);
      YM2203_write_port_0_w(1,data);
   }
}
// end of unused functions !!!
#endif

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

static UINT8 s_byte;
static UINT8 s_stat;

static void FLStorySoundWriteMain(UINT16 offset, UINT8 data)
{
   if((offset&1)==0){
      #ifdef RAINE_DEBUG
      print_debug("Main Sends: %02x\n",data);
      #endif
      s_byte  = data;
      s_stat |= 0x02;
   }
   else{
      #ifdef RAINE_DEBUG
      print_debug("(ERROR) Main Sends Status: %02x\n",data);
      #endif
   }
}

static UINT8 FLStorySoundReadMain(UINT16 offset)
{
   if((offset&1)==0){
      #ifdef RAINE_DEBUG
      print_debug("Main Reads: %02x\n",s_byte);
      #endif
      s_stat &= ~0x02;
      return s_byte;
   }
   else{
      #ifdef RAINE_DEBUG
      print_debug("Main Reads Status: %02x\n",s_stat);
      #endif
      return s_stat;
   }
}

static void FLStorySoundWriteSub(UINT16 offset, UINT8 data)
{
   #ifdef RAINE_DEBUG
   print_debug("Sub Sends: %02x\n",data);
   #endif
   s_byte  = data;
   s_stat |= 0x02;
}

static UINT8 FLStorySoundReadSub(UINT16 offset)
{
   #ifdef RAINE_DEBUG
   print_debug("Sub Reads: %02x\n",s_byte);
   #endif
   s_stat &= ~0x02;
   return s_byte;
}


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

static void DrawNibble0(UINT8 *out, int plane, UINT8 c)
{
   int count, t;

   count = 4;
      do {
         t = c & 1;
         *out = t << plane;
         out++;
         c >>= 1;
      } while(--count);
}

static void DrawNibble(UINT8 *out, int plane, UINT8 c)
{
   int count, t;

   count = 4;
      do {
         t = c & 1;
         *out |= t << plane;
         out++;
         c >>= 1;
      } while(--count);
}

void LoadFLStory(void)
{
   int ta,tb;
   UINT8 *TMP;

   romset=0;
   Z80BankCount=0x20000/0x4000;
   mcu_enable=0;

   RAMSize=0x10000+0x10000+0x10+0x200;

   if(!(ROM=AllocateMem(0x20000+0x8000))) return;

   ROM2 = ROM+0x20000;

   if(!(RAM=AllocateMem(RAMSize))) return;

   RAM2       = RAM+0x10000;
   RAM_INPUT  = RAM+0x10000+0x10000;
   RAM_COLOUR = RAM+0x10000+0x10000+0x10;

   if(!load_rom("cpu-a45.15",ROM+0x00000,0x04000)) return;	// Z80 MAIN ROM
   if(!load_rom("cpu-a45.16",ROM+0x04000,0x04000)) return;	// Z80 MAIN ROM
   if(!load_rom("cpu-a45.17",ROM+0x08000,0x04000)) return;	// Z80 MAIN ROM

   // BAD HW

   ROM[0xBF59]=0xC9;

   // BAD ROM

   ROM[0xBFFA]=0xC9;

   // BAD SOUND PCB

   ROM[0x021A]=0x00;
   ROM[0x021B]=0x00;
   ROM[0x021C]=0x00;

   // BAD IO

   ROM[0x0225]=0x00;
   ROM[0x0226]=0x00;
   ROM[0x0227]=0x00;

   // Skip Idle Z80
   // -------------
/*
   ROM[0x485a]=0xC9;  // RET

   ROM[0x04FF]=0xC3;  // JP 005D
   ROM[0x0500]=0x5D;  //
   ROM[0x0501]=0x00;  //

   ROM[0x005D]=0x3A;  //
   ROM[0x005E]=0x90;  //
   ROM[0x005F]=0xDA;  //
   ROM[0x0060]=0xD3;  // OUTA (AAh)
   ROM[0x0061]=0xAA;  //

   SetStopZ80BMode2(0x0502);
*/
   memset(RAM+0x00000, 0x00, 0x10000);
   memcpy(RAM, ROM, 0x8000+0x4000);

   AddZ80BROMBase(RAM, 0x0038, 0x0066);

   AddZ80BReadByte(0x0000, 0xBFFF, NULL,			NULL);	// Z80 ROM
   AddZ80BReadByte(0xC000, 0xC7FF, NULL,			NULL);	// BG0 RAM
   AddZ80BReadByte(0xD400, 0xD401, FLStorySoundReadMain,	NULL);	// SOUND COMM
   //AddZ80BReadByte(0xDC00, 0xDCBF, NULL,			NULL);	// ?
   AddZ80BReadByte(0xDD00, 0xDEFF, NULL,			NULL);	// ?
   AddZ80BReadByte(0xE000, 0xE7FF, NULL,			NULL);	// WORK RAM
   AddZ80BReadByte(0x0000, 0xFFFF, DefBadReadZ80,		NULL);	// <bad reads>
   AddZ80BReadByte(-1, -1, NULL, NULL);

   AddZ80BWriteByte(0xC000, 0xC7FF, NULL,			NULL);	// BG0 RAM
   AddZ80BWriteByte(0xD400, 0xD401, FLStorySoundWriteMain,	NULL);	// SOUND COMM
   AddZ80BWriteByte(0xDC00, 0xDCBF, NULL,			NULL);	// ?
   AddZ80BWriteByte(0xDD00, 0xDEFF, NULL,			NULL);	// ?
   AddZ80BWriteByte(0xE000, 0xE7FF, NULL,			NULL);	// WORK RAM
   AddZ80BWriteByte(0x0000, 0xFFFF, DefBadWriteZ80,		NULL);	// <bad writes>
   AddZ80BWriteByte(-1, -1, NULL, NULL);

   AddZ80BReadPort(0x00, 0xFF, DefBadReadZ80,			NULL);	// <bad reads>
   AddZ80BReadPort(-1, -1, NULL, NULL);

   AddZ80BWritePort(0xAA, 0xAA, StopZ80BMode2,			NULL);	// Trap Idle Z80
   AddZ80BWritePort(0x00, 0xFF, DefBadWriteZ80,			NULL);	// <bad reads>
   AddZ80BWritePort(-1, -1, NULL, NULL);

   AddZ80BInit();

   if(!load_rom("snd.22",ROM2+0x0000,0x2000)) return;		// Z80 SUB ROM
   if(!load_rom("snd.23",ROM2+0x2000,0x2000)) return;		// Z80 SUB ROM

   // Skip Idle Z80
   // -------------

   ROM2[0x0167]=0xD3;  // OUTA (AAh)
   ROM2[0x0168]=0xAA;  //

   SetStopZ80CMode2(0x0160);

   memset(RAM2+0x00000, 0x00, 0x10000);
   memcpy(RAM2, ROM2, 0x4000);

   AddZ80CROMBase(RAM2, 0x0038, 0x0066);

   AddZ80CReadByte(0x0000, 0x3FFF, NULL,			NULL);	// Z80 ROM
   AddZ80CReadByte(0xC000, 0xC7FF, NULL,			NULL);	// WORK RAM
   AddZ80CReadByte(0xD800, 0xD800, FLStorySoundReadSub,		NULL);	// SOUND COMM
   AddZ80CReadByte(0x0000, 0xFFFF, DefBadReadZ80,		NULL);	// <bad reads>
   AddZ80CReadByte(-1, -1, NULL, NULL);

   AddZ80CWriteByte(0xC000, 0xC7FF, NULL,			NULL);	// WORK RAM
   AddZ80CWriteByte(0xD800, 0xD800, FLStorySoundWriteSub,	NULL);	// SOUND COMM
   AddZ80CWriteByte(0x0000, 0xFFFF, DefBadWriteZ80,		NULL);	// <bad writes>
   AddZ80CWriteByte(-1, -1, NULL, NULL);

   AddZ80CReadPort(0x00, 0xFF, DefBadReadZ80,			NULL);	// <bad reads>
   AddZ80CReadPort(-1, -1, NULL, NULL);

   AddZ80CWritePort(0xAA, 0xAA, StopZ80CMode2,			NULL);	// Trap Idle Z80
   AddZ80CWritePort(0x00, 0xFF, DefBadWriteZ80,			NULL);	// <bad reads>
   AddZ80CWritePort(-1, -1, NULL, NULL);

   AddZ80CInit();

   /*-----------------------*/

   if(!(GFX=AllocateMem(0x040000))) return;
   if(!(TMP=AllocateMem(0x020000))) return;

   tb=0;
   if(!load_rom("vid-a45.06", TMP+0x00000, 0x04000)) return;
   if(!load_rom("vid-a45.08", TMP+0x04000, 0x04000)) return;
   if(!load_rom("vid-a45.20", TMP+0x08000, 0x04000)) return;
   if(!load_rom("vid-a45.18", TMP+0x0C000, 0x04000)) return;
   if(!load_rom("vid-a45.07", TMP+0x10000, 0x04000)) return;
   if(!load_rom("vid-a45.09", TMP+0x14000, 0x04000)) return;
   if(!load_rom("vid-a45.21", TMP+0x18000, 0x04000)) return;
   if(!load_rom("vid-a45.19", TMP+0x1C000, 0x04000)) return;
   for(ta=0;ta<0x10000;ta+=2,tb+=8){
      DrawNibble0(&GFX[tb+0],0, (UINT8) (TMP[ta+0x00000]&15) );
      DrawNibble (&GFX[tb+0],1, (UINT8) (TMP[ta+0x00000]>>4) );
      DrawNibble (&GFX[tb+0],2, (UINT8) (TMP[ta+0x10000]&15) );
      DrawNibble (&GFX[tb+0],3, (UINT8) (TMP[ta+0x10000]>>4) );
      DrawNibble0(&GFX[tb+4],0, (UINT8) (TMP[ta+0x00001]&15) );
      DrawNibble (&GFX[tb+4],1, (UINT8) (TMP[ta+0x00001]>>4) );
      DrawNibble (&GFX[tb+4],2, (UINT8) (TMP[ta+0x10001]&15) );
      DrawNibble (&GFX[tb+4],3, (UINT8) (TMP[ta+0x10001]>>4) );
   }

   FreeMem(TMP);
/*
   Rotate8x8(GFX,0x1000);
   Flip8x8_Y(GFX,0x1000);
*/
}

void ClearFLStory(void)
{
   #ifdef RAINE_DEBUG
      save_debug("RAM.BIN", RAM, RAMSize, 0);
      save_debug("GFX.BIN", GFX, 0x040000, 0);
   #endif
}


void ExecuteFLStoryFrame(void)
{
/*
   static int coin_toggle_a,coin_toggle_b;

   // ----- MCU hacks -----

   if((RAM_INPUT[5]&0x01)!=0){
      if(coin_toggle_a==0){
         coin_toggle_a=1;
         RAM[0xE801]++;
      }
   }
   else{
      coin_toggle_a=0;
   }

   if((RAM_INPUT[5]&0x02)!=0){
      if(coin_toggle_b==0){
         coin_toggle_b=1;
         RAM[0xE801]++;
      }
   }
   else{
      coin_toggle_b=0;
   }

   // ---------------------
*/
   cpu_execute_cycles(CPU_Z80_1, CPU_FRAME_MHz(6,60));	// Main Z80 6MHz (60fps)
   #ifdef RAINE_DEBUG
      print_debug("Z80PC_MAIN:%04x\n",z80pc);
   #endif
   cpu_interrupt(CPU_Z80_1, 0x38);

   cpu_execute_cycles(CPU_Z80_2, CPU_FRAME_MHz(4,60));	// Sub Z80 4MHz (60fps)
   #ifdef RAINE_DEBUG
      print_debug("Z80PC_SUB:%04x\n",z80pc);
   #endif
   cpu_interrupt(CPU_Z80_2, 0x38);
   //if((s_stat&0x02)!=0) cpu_int_nmi(CPU_Z80_2);
}

void DrawFLStory(void)
{
   int x,y,code,ta;
   int zz,zzz,zzzz,x16,y16;
/*
   if(RefreshBuffers){

   for(zz=0;zz<0x200;zz+=2){
   ta=ReadWord(&RAM_COLOUR[zz]);
   pal[zz>>1].r=(ta&0x0F00)>>6;
   pal[zz>>1].g=(ta&0x00F0)>>2;
   pal[zz>>1].b=(ta&0x000F)<<2;
   }

   }

   // BG0
   // ---

   MAKE_SCROLL_256x256_2_8(
      16+(ReadWord(&RAM[0xD500])),
      16-(ReadWord(&RAM[0xD502]))
   );

   START_SCROLL_256x256_2_8_FLIPY(32,32,224,240);

      code = ReadWord(&RAM[0xCD00+zz])&0x1FFF;

      Draw8x8(&GFX[code<<6], x, y, (ReadWord(&RAM[0xCD00+zz])>>9)&0x70);

   END_SCROLL_256x256_2_8();

   //for(zz=0xD548;zz<0xD658;zz+=4){
   for(zz=0xD500;zz<0xD7FF;zz+=4){
      x = RAM[zz+0];
      ofs = RAM[zz+1];
      if((x!=0)||(ofs!=0)){
         rx = 8;
         ry = 2;

         ofs = ((ofs<<7) | (ofs>>1)) & 0x0FF0;

         CHAIN = RAM+0xC000+ofs;

         ta=0;

         while((ReadWord(&CHAIN[ta])==0)&&(ta<16)){
            rx--;
            ta+=2;
         }

         for(ryy=0;ryy<ry;ryy++){

         CHAIN_2 = CHAIN + 0x0E;

            y = (RAM[zz+2]+(ryy<<3)+16)&0x1FF;
            x = (RAM[zz+0]+16)&0x1FF;

            for(rxx=0;rxx<rx;rxx++){

               if((x>24)&&(y>24)&&(x<224+32)&&(y<240+32)){

                  code = ReadWord(&CHAIN_2[0])&0x1FFF;

                  Draw8x8_Trans(&GFX[code<<6], x, y, (ReadWord(&CHAIN_2[0])>>9)&0x70);

               }
               CHAIN_2 -= 2;
               x+=8;
            }
            CHAIN = CHAIN + 0x40;
         }
      }
   }
*/

   for(zz=0;zz<0x200;zz+=2){
   ta=ReadWord(&RAM[zz+0xDD00]);
   pal[zz>>1].r=(ta&0x0F00)>>6;
   pal[zz>>1].g=(ta&0x00F0)>>2;
   pal[zz>>1].b=(ta&0x000F)<<2;
   }

   // BG1/FG0
   // -------

   MAKE_SCROLL_256x256_2_8(
      0,
      0
   );

   START_SCROLL_256x256_2_8_R180(32,32,256,256);

      ta = ReadWord(&RAM[0xC000+zz]);

      code = (ta&0xFF) | ((ta>>6)&0x0300);

      switch(ta&0x0800){
      case 0x0800: Draw8x8(&GFX[code<<6], x, y, (ta>>6)&0x00);       break;
      case 0x0000: Draw8x8_FlipY(&GFX[code<<6], x, y, (ta>>6)&0x00); break;
      }

   END_SCROLL_256x256_2_8();

   pal[0].b=63;
}

/*

C000-C7FF - BG0
---------------

- 64 bytes/line
- 256x256 size

-----+--------+---------------
Byte | Bit(s) | Use
-----[phone]+---------------
  0  |xx......| Tile (8-9)?
  0  |....x...| Flip Y Axis
  1  |xxxxxxxx| Tile (0-7)
-----+--------+---------------


D500-D7FF - CTRL DATA
---------------------

- 4 bytes/sprite
- D500 BG0 scroll (sprite?)

-----+--------+---------------
Byte | Bit(s) | Use
-----[phone]+---------------
  0  |xxxxxxxx| Sprite X (low)
  1  |xxx.....| Offset (low)
  1  |...xxxxx| Offset (high)
  2  |xxxxxxxx| Sprite Y (low)
-----+--------+---------------


*/