1 //////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // Nestopia - NES/Famicom emulator written in C++ 4 // 5 // Copyright (C) 2003-2008 Martin Freij 6 // 7 // This file is part of Nestopia. 8 // 9 // Nestopia is free software; you can redistribute it and/or modify 10 // it under the terms of the GNU General Public License as published by 11 // the Free Software Foundation; either version 2 of the License, or 12 // (at your option) any later version. 13 // 14 // Nestopia is distributed in the hope that it will be useful, 15 // but WITHOUT ANY WARRANTY; without even the implied warranty of 16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 // GNU General Public License for more details. 18 // 19 // You should have received a copy of the GNU General Public License 20 // along with Nestopia; if not, write to the Free Software 21 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 // 23 //////////////////////////////////////////////////////////////////////////////////////// 24 25 #include <cstdio> 26 #include <algorithm> 27 #include "../NstLog.hpp" 28 #include "../NstTimer.hpp" 29 #include "NstBoard.hpp" 30 #include "NstBoardNRom.hpp" 31 #include "NstBoardAxRom.hpp" 32 #include "NstBoardAction53.hpp" 33 #include "NstBoardBxRom.hpp" 34 #include "NstBoardCxRom.hpp" 35 #include "NstBoardDxRom.hpp" 36 #include "NstBoardExRom.hpp" 37 #include "NstBoardFxRom.hpp" 38 #include "NstBoardGxRom.hpp" 39 #include "NstBoardHxRom.hpp" 40 #include "NstBoardJxRom.hpp" 41 #include "NstBoardMxRom.hpp" 42 #include "NstBoardNxRom.hpp" 43 #include "NstBoardPxRom.hpp" 44 #include "NstBoardSxRom.hpp" 45 #include "NstBoardTxRom.hpp" 46 #include "NstBoardUxRom.hpp" 47 #include "NstBoardDiscrete.hpp" 48 #include "NstBoardEvent.hpp" 49 #include "NstBoardFb.hpp" 50 #include "NstBoardQj.hpp" 51 #include "NstBoardZz.hpp" 52 #include "NstBoardAe.hpp" 53 #include "NstBoardAcclaim.hpp" 54 #include "NstBoardAgci.hpp" 55 #include "NstBoardAve.hpp" 56 #include "NstBoardBandai.hpp" 57 #include "NstBoardCaltron.hpp" 58 #include "NstBoardCamerica.hpp" 59 #include "NstBoardCne.hpp" 60 #include "NstBoardCony.hpp" 61 #include "NstBoardDreamtech.hpp" 62 #include "NstBoardFfe.hpp" 63 #include "NstBoardFujiya.hpp" 64 #include "NstBoardFukutake.hpp" 65 #include "NstBoardFutureMedia.hpp" 66 #include "NstBoardGouder.hpp" 67 #include "NstBoardHes.hpp" 68 #include "NstBoardHenggedianzi.hpp" 69 #include "NstBoardHosenkan.hpp" 70 #include "NstBoardInlNsf.hpp" 71 #include "NstBoardIrem.hpp" 72 #include "NstBoardJaleco.hpp" 73 #include "NstBoardJyCompany.hpp" 74 #include "NstBoardKaiser.hpp" 75 #include "NstBoardKasing.hpp" 76 #include "NstBoardKay.hpp" 77 #include "NstBoardKonami.hpp" 78 #include "NstBoardMagicKidGoogoo.hpp" 79 #include "NstBoardMagicSeries.hpp" 80 #include "NstBoardNanjing.hpp" 81 #include "NstBoardNihon.hpp" 82 #include "NstBoardNitra.hpp" 83 #include "NstBoardNtdec.hpp" 84 #include "NstBoardOpenCorp.hpp" 85 #include "NstBoardRcm.hpp" 86 #include "NstBoardRexSoft.hpp" 87 #include "NstBoardRumbleStation.hpp" 88 #include "NstBoardSachen.hpp" 89 #include "NstBoardSomeriTeam.hpp" 90 #include "NstBoardSubor.hpp" 91 #include "NstBoardSunsoft.hpp" 92 #include "NstBoardSuperGame.hpp" 93 #include "NstBoardTaito.hpp" 94 #include "NstBoardTengen.hpp" 95 #include "NstBoardTxc.hpp" 96 #include "NstBoardVsSystem.hpp" 97 #include "NstBoardWaixing.hpp" 98 #include "NstBoardWhirlwind.hpp" 99 #include "NstBoardBenshengBs5.hpp" 100 #include "NstBoardUnlN625092.hpp" 101 #include "NstBoardUnlA9746.hpp" 102 #include "NstBoardUnlCc21.hpp" 103 #include "NstBoardUnlEdu2000.hpp" 104 #include "NstBoardUnlKingOfFighters96.hpp" 105 #include "NstBoardUnlKingOfFighters97.hpp" 106 #include "NstBoardUnlMortalKombat2.hpp" 107 #include "NstBoardUnlSuperFighter3.hpp" 108 #include "NstBoardUnlTf1201.hpp" 109 #include "NstBoardUnlWorldHero.hpp" 110 #include "NstBoardUnlXzy.hpp" 111 #include "NstBoardBtl2708.hpp" 112 #include "NstBoardBtlAx5705.hpp" 113 #include "NstBoardBtl6035052.hpp" 114 #include "NstBoardBtlDragonNinja.hpp" 115 #include "NstBoardBtlGeniusMerioBros.hpp" 116 #include "NstBoardBtlMarioBaby.hpp" 117 #include "NstBoardBtlPikachuY2k.hpp" 118 #include "NstBoardBtlShuiGuanPipe.hpp" 119 #include "NstBoardBtlSmb2a.hpp" 120 #include "NstBoardBtlSmb2b.hpp" 121 #include "NstBoardBtlSmb2c.hpp" 122 #include "NstBoardBtlSmb3.hpp" 123 #include "NstBoardBtlSuperBros11.hpp" 124 #include "NstBoardBtlT230.hpp" 125 #include "NstBoardBtlTobidaseDaisakusen.hpp" 126 #include "NstBoardBmc110in1.hpp" 127 #include "NstBoardBmc1200in1.hpp" 128 #include "NstBoardBmc150in1.hpp" 129 #include "NstBoardBmc15in1.hpp" 130 #include "NstBoardBmc20in1.hpp" 131 #include "NstBoardBmc21in1.hpp" 132 #include "NstBoardBmc22Games.hpp" 133 #include "NstBoardBmc31in1.hpp" 134 #include "NstBoardBmc35in1.hpp" 135 #include "NstBoardBmc36in1.hpp" 136 #include "NstBoardBmc64in1.hpp" 137 #include "NstBoardBmc72in1.hpp" 138 #include "NstBoardBmc76in1.hpp" 139 #include "NstBoardBmc800in1.hpp" 140 #include "NstBoardBmc8157.hpp" 141 #include "NstBoardBmc9999999in1.hpp" 142 #include "NstBoardBmcA65as.hpp" 143 #include "NstBoardBmcBallgames11in1.hpp" 144 #include "NstBoardBmcCtc65.hpp" 145 #include "NstBoardBmcFamily4646B.hpp" 146 #include "NstBoardBmcFk23c.hpp" 147 #include "NstBoardBmcGamestarA.hpp" 148 #include "NstBoardBmcGamestarB.hpp" 149 #include "NstBoardBmcGolden190in1.hpp" 150 #include "NstBoardBmcGoldenCard6in1.hpp" 151 #include "NstBoardBmcGoldenGame260in1.hpp" 152 #include "NstBoardBmcHero.hpp" 153 #include "NstBoardBmcMarioParty7in1.hpp" 154 #include "NstBoardBmcNovelDiamond.hpp" 155 #include "NstBoardBmcCh001.hpp" 156 #include "NstBoardBmcPowerjoy84in1.hpp" 157 #include "NstBoardBmcResetBased4in1.hpp" 158 #include "NstBoardBmcSuper22Games.hpp" 159 #include "NstBoardBmcSuper24in1.hpp" 160 #include "NstBoardBmcSuper40in1.hpp" 161 #include "NstBoardBmcSuper700in1.hpp" 162 #include "NstBoardBmcSuperBig7in1.hpp" 163 #include "NstBoardBmcSuperGun20in1.hpp" 164 #include "NstBoardBmcSuperHiK4in1.hpp" 165 #include "NstBoardBmcSuperHiK300in1.hpp" 166 #include "NstBoardBmcSuperVision16in1.hpp" 167 #include "NstBoardBmcT262.hpp" 168 #include "NstBoardBmcVrc4.hpp" 169 #include "NstBoardBmcVt5201.hpp" 170 #include "NstBoardBmcY2k64in1.hpp" 171 172 namespace Nes 173 { 174 namespace Core 175 { 176 namespace Boards 177 { 178 #ifdef NST_MSVC_OPTIMIZE 179 #pragma optimize("s", on) 180 #endif 181 Type()182 Board::Type::Type() 183 : 184 id (UNKNOWN), 185 nmt (NMT_VERTICAL), 186 chrRam (0), 187 battery (false), 188 wramAuto (false) 189 { 190 } 191 Type(Id i,Ram & prgRom,Ram & chrRom,Nmt n,bool b,bool a)192 Board::Type::Type(Id i,Ram& prgRom,Ram& chrRom,Nmt n,bool b,bool a) 193 : id(i), battery(b) 194 { 195 wramAuto = (a && GetWram() >= SIZE_8K); 196 197 const dword oldPrg = prgRom.Size(); 198 199 prgRom.Set( Ram::ROM, true, false, NST_MIN(oldPrg,GetMaxPrg()) ); 200 prgRom.Mirror( SIZE_16K ); 201 202 if (prgRom.Size() != oldPrg) 203 { 204 NST_DEBUG_MSG("PRG-ROM truncated!"); 205 Log::Flush( "Board: warning, PRG-ROM truncated" NST_LINEBREAK ); 206 } 207 208 switch (dword(id) >> 7 & 0x7) 209 { 210 default: chrRam = 0; break; 211 case CRM_1: chrRam = 1; break; 212 case CRM_2: chrRam = 2; break; 213 case CRM_4: chrRam = 4; break; 214 case CRM_6: chrRam = 6; break; 215 case CRM_8: chrRam = 8; break; 216 case CRM_16: chrRam = 16; break; 217 case CRM_32: chrRam = 32; break; 218 } 219 220 if (chrRam < 8 && chrRom.Empty()) 221 chrRam = 8; 222 223 const dword oldChr = chrRom.Size(); 224 225 chrRom.Set( Ram::ROM, true, false, NST_MIN(oldChr,GetMaxChr()) ); 226 227 if (chrRom.Size()) 228 chrRom.Mirror( SIZE_8K ); 229 230 if (chrRom.Size() != oldChr) 231 { 232 NST_DEBUG_MSG("CHR-ROM truncated!"); 233 Log::Flush( "Board: warning, CHR-ROM truncated" NST_LINEBREAK ); 234 } 235 236 switch (dword(i) >> 4 & 0x7) 237 { 238 case NMT_H: 239 case NMT_V: 240 case NMT_Z: nmt = NMT_CONTROLLED; break; 241 case NMT_1: nmt = NMT_SINGLESCREEN; break; 242 case NMT_2: 243 case NMT_4: nmt = NMT_FOURSCREEN; break; 244 default: nmt = (n == NMT_CONTROLLED ? NMT_VERTICAL : n); break; 245 } 246 } 247 GetMapper() const248 uint Board::Type::GetMapper() const 249 { 250 return dword(id) >> 24; 251 } 252 GetMaxPrg() const253 dword Board::Type::GetMaxPrg() const 254 { 255 return 0x2000UL << (dword(id) >> 20 & 0xF); 256 } 257 GetMaxChr() const258 dword Board::Type::GetMaxChr() const 259 { 260 uint v = dword(id) >> 16 & 0xF; 261 return v ? 0x1000UL << v : 0UL; 262 } 263 GetSavableWram() const264 uint Board::Type::GetSavableWram() const 265 { 266 uint v = dword(id) >> 13 & 0x7; 267 return v ? 0x200U << v : 0UL; 268 } 269 GetNonSavableWram() const270 uint Board::Type::GetNonSavableWram() const 271 { 272 uint v = dword(id) >> 10 & 0x7; 273 return v ? 0x200U << v : 0UL; 274 } 275 GetWram() const276 uint Board::Type::GetWram() const 277 { 278 return GetSavableWram() + GetNonSavableWram(); 279 } 280 GetChrRam() const281 uint Board::Type::GetChrRam() const 282 { 283 return chrRam * SIZE_1K; 284 } 285 GetStartupNmt() const286 Board::Type::Nmt Board::Type::GetStartupNmt() const 287 { 288 switch (static_cast<NmtInit>(dword(id) >> 4 & 0x7)) 289 { 290 case NMT_H: return NMT_HORIZONTAL; 291 case NMT_V: return NMT_VERTICAL; 292 case NMT_Z: 293 case NMT_1: return NMT_SINGLESCREEN; 294 case NMT_2: 295 case NMT_4: return NMT_FOURSCREEN; 296 default: return GetNmt(); 297 } 298 } 299 GetNmtRam() const300 uint Board::Type::GetNmtRam() const 301 { 302 if (nmt == NMT_FOURSCREEN) 303 return (dword(id) >> 4 & 0x7) == NMT_2 ? SIZE_2K : SIZE_4K; 304 else 305 return 0; 306 } 307 GetSavableVram() const308 uint Board::Type::GetSavableVram() const 309 { 310 return 0; 311 } 312 GetNonSavableVram() const313 uint Board::Type::GetNonSavableVram() const 314 { 315 return GetChrRam() + GetNmtRam(); 316 } 317 GetVram() const318 uint Board::Type::GetVram() const 319 { 320 return GetSavableVram() + GetNonSavableVram(); 321 } 322 Board(const Context & context)323 Board::Board(const Context& context) 324 : 325 cpu (*context.cpu), 326 ppu (*context.ppu), 327 chr (context.ppu->GetChrMem()), 328 nmt (context.ppu->GetNmtMem()), 329 vram (Ram::RAM,true,true,context.type.GetVram()), 330 board (context.type) 331 { 332 prg.Source(0).Set( context.prg ); 333 334 if (const uint size = board.GetWram()) 335 { 336 wrk.Source(0).Set( board.GetSavableWram() ? Ram::NVRAM : Ram::RAM, true, true, size ); 337 wrk.Source(0).Fill( 0x00 ); 338 } 339 else 340 { 341 wrk.Source(0).Set( context.prg ); 342 } 343 344 prg.Source(1).Set( wrk.Source(0).Reference() ); 345 wrk.Source(1).Set( prg.Source(0).Reference() ); 346 347 if (const uint size = board.GetChrRam()) 348 chr.Source(1).Set( Ram::RAM, true, true, size, vram.Mem() ); 349 else 350 chr.Source(1).Set( context.chr ); 351 352 if (context.chr.Size()) 353 chr.Source(0).Set( context.chr ); 354 else 355 chr.Source(0).Set( chr.Source(1).Reference() ); 356 357 if (const uint size = board.GetNmtRam()) 358 nmt.Source(1).Set( Ram::RAM, true, true, size, vram.Mem() + board.GetChrRam() ); 359 else 360 nmt.Source(1).Set( chr.Source().Reference() ); 361 362 vram.Fill( 0x00 ); 363 364 if (Log::Available()) 365 { 366 Log log; 367 368 log << "Board: " << context.name << NST_LINEBREAK; 369 log << "Board: " << (context.prg.Size() / SIZE_1K) << "k PRG-ROM" NST_LINEBREAK; 370 371 if (context.chr.Size()) 372 log << "Board: " << (context.chr.Size() / SIZE_1K) << "k CHR-ROM" NST_LINEBREAK; 373 374 if (const uint size = board.GetWram()) 375 log << "Board: " << (size / SIZE_1K) << (board.IsAutoWram() ? "k auto W-RAM" NST_LINEBREAK : "k W-RAM" NST_LINEBREAK); 376 377 if (const uint size = board.GetVram()) 378 log << "Board: " << (size / SIZE_1K) << "k V-RAM" NST_LINEBREAK; 379 } 380 } 381 Reset(const bool hard)382 void Board::Reset(const bool hard) 383 { 384 cpu.Map( 0x4018, 0x5FFF ).Set( this, &Board::Peek_Nop, &Board::Poke_Nop ); 385 386 if (board.GetWram() >= SIZE_8K) 387 cpu.Map( 0x6000, 0x7FFF ).Set( this, &Board::Peek_Wram_6, &Board::Poke_Wram_6 ); 388 else 389 cpu.Map( 0x6000, 0x7FFF ).Set( this, &Board::Peek_Nop, &Board::Poke_Nop ); 390 391 cpu.Map( 0x8000, 0x9FFF ).Set( this, &Board::Peek_Prg_8, &Board::Poke_Nop ); 392 cpu.Map( 0xA000, 0xBFFF ).Set( this, &Board::Peek_Prg_A, &Board::Poke_Nop ); 393 cpu.Map( 0xC000, 0xDFFF ).Set( this, &Board::Peek_Prg_C, &Board::Poke_Nop ); 394 cpu.Map( 0xE000, 0xFFFF ).Set( this, &Board::Peek_Prg_E, &Board::Poke_Nop ); 395 396 if (hard) 397 { 398 wrk.Source().SetSecurity( true, board.GetWram() > 0 ); 399 400 for (uint i=board.GetSavableWram(), n=board.GetWram(); i < n; ++i) 401 *wrk.Source().Mem(i) = (board.IsAutoWram() && i < SIZE_8K) ? (0x6000 + i) >> 8 : 0x00; 402 403 vram.Fill( 0x00 ); 404 405 prg.SwapBanks<SIZE_16K,0x0000>(0U,~0U); 406 chr.SwapBank<SIZE_8K,0x0000>(0); 407 wrk.SwapBank<SIZE_8K,0x0000>(0); 408 409 switch (board.GetStartupNmt()) 410 { 411 case Type::NMT_HORIZONTAL: 412 413 ppu.SetMirroring( Ppu::NMT_H ); 414 break; 415 416 case Type::NMT_VERTICAL: 417 418 ppu.SetMirroring( Ppu::NMT_V ); 419 break; 420 421 case Type::NMT_SINGLESCREEN: 422 423 ppu.SetMirroring( Ppu::NMT_0 ); 424 break; 425 426 case Type::NMT_FOURSCREEN: 427 428 if (board.GetNmtRam() == SIZE_2K) 429 { 430 nmt.Source(0).SwapBank<SIZE_2K,0x0000>(0); 431 nmt.Source(1).SwapBank<SIZE_2K,0x0800>(0); 432 } 433 else 434 { 435 nmt.Source(1).SwapBank<SIZE_4K,0x0000>(0); 436 } 437 break; 438 439 case Type::NMT_CONTROLLED: 440 441 default: 442 break; 443 } 444 } 445 446 SubReset( hard ); 447 } 448 Save(File & file) const449 void Board::Save(File& file) const 450 { 451 if (board.HasBattery() && board.GetSavableWram()) 452 file.Save( File::BATTERY, wrk.Source().Mem(), board.GetSavableWram() ); 453 } 454 Load(File & file)455 void Board::Load(File& file) 456 { 457 if (board.HasBattery() && board.GetSavableWram()) 458 file.Load( File::BATTERY, wrk.Source().Mem(), board.GetSavableWram() ); 459 } 460 SaveState(State::Saver & state,const dword baseChunk) const461 void Board::SaveState(State::Saver& state,const dword baseChunk) const 462 { 463 state.Begin( baseChunk ); 464 465 if (const uint size = board.GetWram()) 466 state.Begin( AsciiId<'W','R','M'>::V ).Compress( wrk.Source().Mem(), size ).End(); 467 468 if (const uint size = board.GetVram()) 469 state.Begin( AsciiId<'V','R','M'>::V ).Compress( vram.Mem(), size ).End(); 470 471 prg.SaveState( state, AsciiId<'P','R','G'>::V ); 472 chr.SaveState( state, AsciiId<'C','H','R'>::V ); 473 nmt.SaveState( state, AsciiId<'N','M','T'>::V ); 474 wrk.SaveState( state, AsciiId<'W','R','K'>::V ); 475 476 SubSave( state ); 477 478 state.End(); 479 } 480 LoadState(State::Loader & state)481 void Board::LoadState(State::Loader& state) 482 { 483 while (const dword chunk = state.Begin()) 484 { 485 switch (chunk) 486 { 487 case AsciiId<'W','R','M'>::V: 488 489 NST_VERIFY( board.GetWram() ); 490 491 if (const uint size = board.GetWram()) 492 state.Uncompress( wrk.Source().Mem(), size ); 493 494 break; 495 496 case AsciiId<'V','R','M'>::V: 497 498 NST_VERIFY( board.GetVram() ); 499 500 if (const uint size = board.GetVram()) 501 state.Uncompress( vram.Mem(), size ); 502 503 break; 504 505 case AsciiId<'P','R','G'>::V: 506 507 prg.LoadState( state ); 508 break; 509 510 case AsciiId<'C','H','R'>::V: 511 512 chr.LoadState( state ); 513 break; 514 515 case AsciiId<'N','M','T'>::V: 516 517 nmt.LoadState( state ); 518 break; 519 520 case AsciiId<'W','R','K'>::V: 521 522 wrk.LoadState( state ); 523 break; 524 525 default: 526 527 SubLoad( state, chunk ); 528 break; 529 } 530 531 state.End(); 532 } 533 } 534 Map(uint a,uint b,PrgSwap8k0) const535 void Board::Map( uint a,uint b,PrgSwap8k0 ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_8k_0 ); } Map(uint a,uint b,PrgSwap8k1) const536 void Board::Map( uint a,uint b,PrgSwap8k1 ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_8k_1 ); } Map(uint a,uint b,PrgSwap8k2) const537 void Board::Map( uint a,uint b,PrgSwap8k2 ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_8k_2 ); } Map(uint a,uint b,PrgSwap8k3) const538 void Board::Map( uint a,uint b,PrgSwap8k3 ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_8k_3 ); } Map(uint a,uint b,PrgSwap16k0) const539 void Board::Map( uint a,uint b,PrgSwap16k0 ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_16k_0 ); } Map(uint a,uint b,PrgSwap16k1) const540 void Board::Map( uint a,uint b,PrgSwap16k1 ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_16k_1 ); } Map(uint a,uint b,PrgSwap32k) const541 void Board::Map( uint a,uint b,PrgSwap32k ) const { cpu.Map(a,b).Set( &Board::Poke_Prg_32k ); } Map(uint a,uint b,ChrSwap1k0) const542 void Board::Map( uint a,uint b,ChrSwap1k0 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_0 ); } Map(uint a,uint b,ChrSwap1k1) const543 void Board::Map( uint a,uint b,ChrSwap1k1 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_1 ); } Map(uint a,uint b,ChrSwap1k2) const544 void Board::Map( uint a,uint b,ChrSwap1k2 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_2 ); } Map(uint a,uint b,ChrSwap1k3) const545 void Board::Map( uint a,uint b,ChrSwap1k3 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_3 ); } Map(uint a,uint b,ChrSwap1k4) const546 void Board::Map( uint a,uint b,ChrSwap1k4 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_4 ); } Map(uint a,uint b,ChrSwap1k5) const547 void Board::Map( uint a,uint b,ChrSwap1k5 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_5 ); } Map(uint a,uint b,ChrSwap1k6) const548 void Board::Map( uint a,uint b,ChrSwap1k6 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_6 ); } Map(uint a,uint b,ChrSwap1k7) const549 void Board::Map( uint a,uint b,ChrSwap1k7 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_1k_7 ); } Map(uint a,uint b,ChrSwap2k0) const550 void Board::Map( uint a,uint b,ChrSwap2k0 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_2k_0 ); } Map(uint a,uint b,ChrSwap2k1) const551 void Board::Map( uint a,uint b,ChrSwap2k1 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_2k_1 ); } Map(uint a,uint b,ChrSwap2k2) const552 void Board::Map( uint a,uint b,ChrSwap2k2 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_2k_2 ); } Map(uint a,uint b,ChrSwap2k3) const553 void Board::Map( uint a,uint b,ChrSwap2k3 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_2k_3 ); } Map(uint a,uint b,ChrSwap4k0) const554 void Board::Map( uint a,uint b,ChrSwap4k0 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_4k_0 ); } Map(uint a,uint b,ChrSwap4k1) const555 void Board::Map( uint a,uint b,ChrSwap4k1 ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_4k_1 ); } Map(uint a,uint b,ChrSwap8k) const556 void Board::Map( uint a,uint b,ChrSwap8k ) const { cpu.Map(a,b).Set( &Board::Poke_Chr_8k ); } Map(uint a,uint b,NmtSwapHv) const557 void Board::Map( uint a,uint b,NmtSwapHv ) const { cpu.Map(a,b).Set( &Board::Poke_Nmt_Hv ); } Map(uint a,uint b,NmtSwapVh) const558 void Board::Map( uint a,uint b,NmtSwapVh ) const { cpu.Map(a,b).Set( &Board::Poke_Nmt_Vh ); } Map(uint a,uint b,NmtSwapVh01) const559 void Board::Map( uint a,uint b,NmtSwapVh01 ) const { cpu.Map(a,b).Set( &Board::Poke_Nmt_Vh01 ); } Map(uint a,uint b,NmtSwapHv01) const560 void Board::Map( uint a,uint b,NmtSwapHv01 ) const { cpu.Map(a,b).Set( &Board::Poke_Nmt_Hv01 ); } Map(uint a,uint b,NopPeek) const561 void Board::Map( uint a,uint b,NopPeek ) const { cpu.Map(a,b).Set( &Board::Peek_Nop ); } Map(uint a,uint b,NopPoke) const562 void Board::Map( uint a,uint b,NopPoke ) const { cpu.Map(a,b).Set( &Board::Poke_Nop ); } 563 Map(PrgSwap8k0Bc) const564 void Board::Map( PrgSwap8k0Bc ) const { cpu.Map(0x8000,0xFFFF).Set( &Board::Poke_Prg_8k_0_bc ); } Map(PrgSwap16k0Bc) const565 void Board::Map( PrgSwap16k0Bc ) const { cpu.Map(0x8000,0xFFFF).Set( &Board::Poke_Prg_16k_0_bc ); } Map(PrgSwap32kBc) const566 void Board::Map( PrgSwap32kBc ) const { cpu.Map(0x8000,0xFFFF).Set( &Board::Poke_Prg_32k_bc ); } Map(ChrSwap4k1Bc) const567 void Board::Map( ChrSwap4k1Bc ) const { cpu.Map(0x8000,0xFFFF).Set( &Board::Poke_Chr_4k_1_bc ); } Map(ChrSwap8kBc) const568 void Board::Map( ChrSwap8kBc ) const { cpu.Map(0x8000,0xFFFF).Set( &Board::Poke_Chr_8k_bc ); } 569 Map(uint a,uint b,NopPeekPoke) const570 void Board::Map(uint a,uint b,NopPeekPoke) const 571 { 572 cpu.Map(a,b).Set( &Board::Peek_Nop, &Board::Poke_Nop ); 573 } 574 575 #ifdef NST_MSVC_OPTIMIZE 576 #pragma optimize("", on) 577 #endif 578 NES_PEEK_A(Board,Prg_8)579 NES_PEEK_A(Board,Prg_8) { return prg[0][address - 0x8000]; } NES_PEEK_A(Board,Prg_A)580 NES_PEEK_A(Board,Prg_A) { return prg[1][address - 0xA000]; } NES_PEEK_A(Board,Prg_C)581 NES_PEEK_A(Board,Prg_C) { return prg[2][address - 0xC000]; } NES_PEEK_A(Board,Prg_E)582 NES_PEEK_A(Board,Prg_E) { return prg[3][address - 0xE000]; } 583 NES_POKE_D(Board,Prg_8k_0)584 NES_POKE_D(Board,Prg_8k_0) { prg.SwapBank<SIZE_8K,0x0000>( data ); } NES_POKE_D(Board,Prg_8k_1)585 NES_POKE_D(Board,Prg_8k_1) { prg.SwapBank<SIZE_8K,0x2000>( data ); } NES_POKE_D(Board,Prg_8k_2)586 NES_POKE_D(Board,Prg_8k_2) { prg.SwapBank<SIZE_8K,0x4000>( data ); } NES_POKE_D(Board,Prg_8k_3)587 NES_POKE_D(Board,Prg_8k_3) { prg.SwapBank<SIZE_8K,0x6000>( data ); } NES_POKE_D(Board,Prg_16k_0)588 NES_POKE_D(Board,Prg_16k_0) { prg.SwapBank<SIZE_16K,0x0000>( data ); } NES_POKE_D(Board,Prg_16k_1)589 NES_POKE_D(Board,Prg_16k_1) { prg.SwapBank<SIZE_16K,0x4000>( data ); } NES_POKE_D(Board,Prg_32k)590 NES_POKE_D(Board,Prg_32k) { prg.SwapBank<SIZE_32K,0x0000>( data ); } 591 NES_POKE_D(Board,Chr_1k_0)592 NES_POKE_D(Board,Chr_1k_0) { ppu.Update(); chr.SwapBank<SIZE_1K,0x0000>( data ); } NES_POKE_D(Board,Chr_1k_1)593 NES_POKE_D(Board,Chr_1k_1) { ppu.Update(); chr.SwapBank<SIZE_1K,0x0400>( data ); } NES_POKE_D(Board,Chr_1k_2)594 NES_POKE_D(Board,Chr_1k_2) { ppu.Update(); chr.SwapBank<SIZE_1K,0x0800>( data ); } NES_POKE_D(Board,Chr_1k_3)595 NES_POKE_D(Board,Chr_1k_3) { ppu.Update(); chr.SwapBank<SIZE_1K,0x0C00>( data ); } NES_POKE_D(Board,Chr_1k_4)596 NES_POKE_D(Board,Chr_1k_4) { ppu.Update(); chr.SwapBank<SIZE_1K,0x1000>( data ); } NES_POKE_D(Board,Chr_1k_5)597 NES_POKE_D(Board,Chr_1k_5) { ppu.Update(); chr.SwapBank<SIZE_1K,0x1400>( data ); } NES_POKE_D(Board,Chr_1k_6)598 NES_POKE_D(Board,Chr_1k_6) { ppu.Update(); chr.SwapBank<SIZE_1K,0x1800>( data ); } NES_POKE_D(Board,Chr_1k_7)599 NES_POKE_D(Board,Chr_1k_7) { ppu.Update(); chr.SwapBank<SIZE_1K,0x1C00>( data ); } NES_POKE_D(Board,Chr_2k_0)600 NES_POKE_D(Board,Chr_2k_0) { ppu.Update(); chr.SwapBank<SIZE_2K,0x0000>( data ); } NES_POKE_D(Board,Chr_2k_1)601 NES_POKE_D(Board,Chr_2k_1) { ppu.Update(); chr.SwapBank<SIZE_2K,0x0800>( data ); } NES_POKE_D(Board,Chr_2k_2)602 NES_POKE_D(Board,Chr_2k_2) { ppu.Update(); chr.SwapBank<SIZE_2K,0x1000>( data ); } NES_POKE_D(Board,Chr_2k_3)603 NES_POKE_D(Board,Chr_2k_3) { ppu.Update(); chr.SwapBank<SIZE_2K,0x1800>( data ); } NES_POKE_D(Board,Chr_4k_0)604 NES_POKE_D(Board,Chr_4k_0) { ppu.Update(); chr.SwapBank<SIZE_4K,0x0000>( data ); } NES_POKE_D(Board,Chr_4k_1)605 NES_POKE_D(Board,Chr_4k_1) { ppu.Update(); chr.SwapBank<SIZE_4K,0x1000>( data ); } NES_POKE_D(Board,Chr_8k)606 NES_POKE_D(Board,Chr_8k) { ppu.Update(); chr.SwapBank<SIZE_8K,0x0000>( data ); } 607 GetBusData(uint address,uint data) const608 uint Board::GetBusData(uint address,uint data) const 609 { 610 NST_VERIFY( data == prg.Peek(address & 0x7FFF) ); 611 return data & prg.Peek(address & 0x7FFF); 612 } 613 NES_POKE_AD(Board,Prg_8k_0_bc)614 NES_POKE_AD(Board,Prg_8k_0_bc) 615 { 616 prg.SwapBank<SIZE_8K,0x0000>( GetBusData(address,data) ); 617 } 618 NES_POKE_AD(Board,Prg_16k_0_bc)619 NES_POKE_AD(Board,Prg_16k_0_bc) 620 { 621 prg.SwapBank<SIZE_16K,0x0000>( GetBusData(address,data) ); 622 } 623 NES_POKE_AD(Board,Prg_32k_bc)624 NES_POKE_AD(Board,Prg_32k_bc) 625 { 626 prg.SwapBank<SIZE_32K,0x0000>( GetBusData(address,data) ); 627 } 628 NES_POKE_AD(Board,Chr_4k_1_bc)629 NES_POKE_AD(Board,Chr_4k_1_bc) 630 { 631 ppu.Update(); 632 chr.SwapBank<SIZE_4K,0x1000>( GetBusData(address,data) ); 633 } 634 NES_POKE_AD(Board,Chr_8k_bc)635 NES_POKE_AD(Board,Chr_8k_bc) 636 { 637 ppu.Update(); 638 chr.SwapBank<SIZE_8K,0x0000>( GetBusData(address,data) ); 639 } 640 NES_POKE_AD(Board,Wram_6)641 NES_POKE_AD(Board,Wram_6) 642 { 643 NST_VERIFY( wrk.Writable(0) ); 644 645 if (wrk.Writable(0)) 646 wrk[0][address - 0x6000] = data; 647 } 648 NES_PEEK_A(Board,Wram_6)649 NES_PEEK_A(Board,Wram_6) 650 { 651 NST_VERIFY( wrk.Readable(0) ); 652 return wrk.Readable(0) ? wrk[0][address - 0x6000] : (address >> 8); 653 } 654 NES_POKE_D(Board,Nmt_Hv)655 NES_POKE_D(Board,Nmt_Hv) 656 { 657 NST_VERIFY( data <= 0x1 ); 658 ppu.SetMirroring( (data & 0x1) ? Ppu::NMT_H : Ppu::NMT_V ); 659 } 660 NES_POKE_D(Board,Nmt_Vh)661 NES_POKE_D(Board,Nmt_Vh) 662 { 663 NST_VERIFY( data <= 0x1 ); 664 ppu.SetMirroring( (data & 0x1) ? Ppu::NMT_V : Ppu::NMT_H ); 665 } 666 NES_POKE_D(Board,Nmt_Vh01)667 NES_POKE_D(Board,Nmt_Vh01) 668 { 669 NST_VERIFY( data <= 0x3 ); 670 671 static const byte lut[4][4] = 672 { 673 {0,1,0,1}, 674 {0,0,1,1}, 675 {0,0,0,0}, 676 {1,1,1,1} 677 }; 678 679 ppu.SetMirroring( lut[data & 0x3] ); 680 } 681 NES_POKE_D(Board,Nmt_Hv01)682 NES_POKE_D(Board,Nmt_Hv01) 683 { 684 NST_VERIFY( data <= 0x3 ); 685 686 static const byte lut[4][4] = 687 { 688 {0,0,1,1}, 689 {0,1,0,1}, 690 {0,0,0,0}, 691 {1,1,1,1} 692 }; 693 694 ppu.SetMirroring( lut[data & 0x3] ); 695 } 696 NES_POKE(Board,Nop)697 NES_POKE(Board,Nop) 698 { 699 NST_DEBUG_MSG("write ignored!"); 700 } 701 NES_PEEK_A(Board,Nop)702 NES_PEEK_A(Board,Nop) 703 { 704 NST_DEBUG_MSG("read ignored!"); 705 return address >> 8; 706 } 707 708 #ifdef NST_MSVC_OPTIMIZE 709 #pragma optimize("s", on) 710 #endif 711 Context(Cpu * c,Apu * a,Ppu * p,Ram & pr,Ram & cr,const Ram & t,Type::Nmt n,bool wb,bool mb,Chips & h)712 Board::Context::Context 713 ( 714 Cpu* c, 715 Apu* a, 716 Ppu* p, 717 Ram& pr, 718 Ram& cr, 719 const Ram& t, 720 Type::Nmt n, 721 bool wb, 722 bool mb, 723 Chips& h 724 ) 725 : 726 name (""), 727 cpu (c), 728 apu (a), 729 ppu (p), 730 prg (pr), 731 chr (cr), 732 trainer (t), 733 nmt (n), 734 chips (h), 735 wramBattery (wb), 736 mmcBattery (mb) 737 { 738 } 739 740 struct Board::Context::Element 741 { 742 cstring name; 743 dword id; 744 745 struct Less 746 { operator ()Nes::Core::Boards::Board::Context::Element::Less747 bool operator () (const Element& a,const Element& b) const 748 { 749 return Core::StringCompare( a.name, b.name ) < 0; 750 } 751 operator ()Nes::Core::Boards::Board::Context::Element::Less752 bool operator () (const Element& a,wcstring b) const 753 { 754 return Core::StringCompare( a.name, b ) < 0; 755 } 756 operator ()Nes::Core::Boards::Board::Context::Element::Less757 bool operator () (wcstring a,const Element& b) const 758 { 759 return Core::StringCompare( b.name, a ) >= 0; 760 } 761 }; 762 }; 763 DetectBoard(wcstring string,const dword wram)764 bool Board::Context::DetectBoard(wcstring string,const dword wram) 765 { 766 static const Element lut[] = 767 { 768 { "ACCLAIM-AOROM", Type::STD_AOROM }, 769 { "ACCLAIM-MC-ACC", Type::ACCLAIM_MCACC }, 770 { "ACCLAIM-TLROM", Type::STD_TLROM }, 771 { "AGCI-47516", Type::DISCRETE_74_377 }, 772 { "AGCI-50282", Type::AGCI_50282 }, 773 { "AVE-74*161", Type::UNL_CXROM }, 774 { "AVE-MB-91", Type::AVE_MB_91 }, 775 { "AVE-NINA-01", Type::AVE_NINA001 }, 776 { "AVE-NINA-02", Type::AVE_NINA002 }, 777 { "AVE-NINA-03", Type::AVE_NINA03 }, 778 { "AVE-NINA-06", Type::AVE_NINA06 }, 779 { "AVE-NINA-07", Type::AVE_NINA07 }, 780 { "BANDAI-74*161/161/32", Type::DISCRETE_74_161_161_32_A }, 781 { "BANDAI-CNROM", Type::STD_CNROM }, 782 { "BANDAI-FCG-1", Type::BANDAI_FCG1 }, 783 { "BANDAI-FCG-2", Type::BANDAI_FCG2 }, 784 { "BANDAI-GNROM", Type::STD_GNROM }, 785 { "BANDAI-JUMP2", Type::BANDAI_BAJUMP2 }, 786 { "BANDAI-LZ93D50+24C01", Type::BANDAI_LZ93D50_24C01 }, 787 { "BANDAI-LZ93D50+24C02", Type::BANDAI_LZ93D50_24C02 }, 788 { "BANDAI-NROM-128", Type::STD_NROM }, 789 { "BANDAI-NROM-256", Type::STD_NROM }, 790 { "BANDAI-PT-554", Type::BANDAI_AEROBICSSTUDIO }, 791 { "BMC-190IN1", Type::BMC_GOLDEN_190IN1 }, 792 { "BMC-42IN1RESETSWITCH", Type::BMC_SUPER_22GAMES }, 793 { "BMC-64IN1NOREPEAT", Type::BMC_Y2K_64IN1 }, 794 { "BMC-70IN1", Type::BMC_GAME_800IN1 }, 795 { "BMC-70IN1B", Type::BMC_GAME_800IN1 }, 796 { "BMC-8157", Type::BMC_8157 }, 797 { "BMC-A65AS", Type::BMC_A65AS }, 798 { "BMC-BS-5", Type::BENSHENG_BS5 }, 799 { "BMC-D1038", Type::BMC_VT5201 }, 800 { "BMC-FK23C", Type::BMC_FKC23C }, 801 { "BMC-GHOSTBUSTERS63IN1", Type::BMC_CTC65 }, 802 { "BMC-GS-2004", Type::RCM_GS2004 }, 803 { "BMC-GS-2013", Type::RCM_GS2013 }, 804 { "BMC-NOVELDIAMOND9999999IN1", Type::BMC_NOVELDIAMOND }, 805 { "BMC-SUPER24IN1SC03", Type::BMC_SUPER_24IN1 }, 806 { "BMC-SUPERHIK8IN1", Type::BMC_HERO }, 807 { "BMC-SUPERVISION16IN1", Type::BMC_SUPERVISION_16IN1 }, 808 { "BMC-T-262", Type::BMC_T262 }, 809 { "BMC-WS", Type::BMC_SUPER_40IN1 }, 810 { "BTL-MARIO1-MALEE2", Type::BTL_GENIUSMERIOBROS }, 811 { "CAMERICA-ALGN", Type::CAMERICA_ALGNV11 }, 812 { "CAMERICA-ALGQ", Type::CAMERICA_ALGQV11 }, 813 { "CAMERICA-BF9093", Type::CAMERICA_BF9093 }, 814 { "CAMERICA-BF9096", Type::CAMERICA_BF9096 }, 815 { "CAMERICA-BF9097", Type::CAMERICA_BF9097 }, 816 { "CAMERICA-GAMEGENIE", Type::STD_NROM }, 817 { "COLORDREAMS-74*377", Type::DISCRETE_74_377 }, 818 { "DREAMTECH01", Type::DREAMTECH_01 }, 819 { "HVC-AMROM", Type::STD_AMROM }, 820 { "HVC-AN1ROM", Type::STD_AN1ROM }, 821 { "HVC-ANROM", Type::STD_ANROM }, 822 { "HVC-AOROM", Type::STD_AOROM }, 823 { "HVC-BNROM", Type::STD_BNROM }, 824 { "HVC-CNROM", Type::STD_CNROM }, 825 { "HVC-CPROM", Type::STD_CPROM }, 826 { "HVC-DE1ROM", Type::STD_DE1ROM }, 827 { "HVC-DEROM", Type::STD_DEROM }, 828 { "HVC-DRROM", Type::STD_DRROM }, 829 { "HVC-EKROM", Type::STD_EKROM }, 830 { "HVC-ELROM", Type::STD_ELROM }, 831 { "HVC-ETROM", Type::STD_ETROM }, 832 { "HVC-EWROM", Type::STD_EWROM }, 833 { "HVC-FAMILYBASIC", Type::CUSTOM_FB02 }, 834 { "HVC-FJROM", Type::STD_FJROM }, 835 { "HVC-FKROM", Type::STD_FKROM }, 836 { "HVC-GNROM", Type::STD_GNROM }, 837 { "HVC-HKROM", Type::STD_HKROM }, 838 { "HVC-HROM", Type::STD_NROM }, 839 { "HVC-JLROM", Type::STD_JLROM }, 840 { "HVC-JSROM", Type::STD_JSROM }, 841 { "HVC-MHROM", Type::STD_MHROM }, 842 { "HVC-NROM", Type::STD_NROM }, 843 { "HVC-NROM-128", Type::STD_NROM }, 844 { "HVC-NROM-256", Type::STD_NROM }, 845 { "HVC-NTBROM", Type::STD_NTBROM }, 846 { "HVC-PEEOROM", Type::STD_PEEOROM }, 847 { "HVC-PNROM", Type::STD_PNROM }, 848 { "HVC-RROM", Type::STD_NROM }, 849 { "HVC-RROM-128", Type::STD_NROM }, 850 { "HVC-SAROM", Type::STD_SAROM }, 851 { "HVC-SBROM", Type::STD_SBROM }, 852 { "HVC-SC1ROM", Type::STD_SCROM }, 853 { "HVC-SCROM", Type::STD_SCROM }, 854 { "HVC-SEROM", Type::STD_SEROM }, 855 { "HVC-SF1ROM", Type::STD_SFROM }, 856 { "HVC-SFROM", Type::STD_SFROM }, 857 { "HVC-SGROM", Type::STD_SGROM }, 858 { "HVC-SH1ROM", Type::STD_SHROM }, 859 { "HVC-SHROM", Type::STD_SHROM }, 860 { "HVC-SJROM", Type::STD_SJROM }, 861 { "HVC-SKROM", Type::STD_SKROM }, 862 { "HVC-SL1ROM", Type::STD_SLROM }, 863 { "HVC-SL2ROM", Type::STD_SLROM }, 864 { "HVC-SL3ROM", Type::STD_SLROM }, 865 { "HVC-SLROM", Type::STD_SLROM }, 866 { "HVC-SLRROM", Type::STD_SLROM }, 867 { "HVC-SNROM", Type::STD_SNROM }, 868 { "HVC-SOROM", Type::STD_SOROM }, 869 { "HVC-SROM", Type::STD_NROM }, 870 { "HVC-STROM", Type::STD_NROM }, 871 { "HVC-SUROM", Type::STD_SUROM }, 872 { "HVC-SXROM", Type::STD_SXROM }, 873 { "HVC-TBROM", Type::STD_TBROM }, 874 { "HVC-TEROM", Type::STD_TEROM }, 875 { "HVC-TFROM", Type::STD_TFROM }, 876 { "HVC-TGROM", Type::STD_TGROM }, 877 { "HVC-TKROM", Type::STD_TKROM }, 878 { "HVC-TKSROM", Type::STD_TKSROM }, 879 { "HVC-TL1ROM", Type::STD_TLROM }, 880 { "HVC-TL2ROM", Type::STD_TLROM }, 881 { "HVC-TLROM", Type::STD_TLROM }, 882 { "HVC-TLSROM", Type::STD_TLSROM }, 883 { "HVC-TNROM", Type::STD_TNROM }, 884 { "HVC-TQROM", Type::STD_TQROM }, 885 { "HVC-TR1ROM", Type::STD_TR1ROM }, 886 { "HVC-TSROM", Type::STD_TSROM }, 887 { "HVC-TVROM", Type::STD_TVROM }, 888 { "HVC-UN1ROM", Type::STD_UN1ROM }, 889 { "HVC-UNROM", Type::STD_UNROM }, 890 { "HVC-UOROM", Type::STD_UOROM }, 891 { "IREM-74*161/161/21/138", Type::IREM_LROG017 }, 892 { "IREM-BNROM", Type::STD_BNROM }, 893 { "IREM-G101", Type::IREM_G101A_0 }, 894 { "IREM-G101-A", Type::IREM_G101A_0 }, 895 { "IREM-G101-B", Type::IREM_G101B_0 }, 896 { "IREM-HOLYDIVER", Type::IREM_HOLYDIVER }, 897 { "IREM-NROM-128", Type::STD_NROM }, 898 { "IREM-NROM-256", Type::STD_NROM }, 899 { "IREM-UNROM", Type::STD_UNROM }, 900 { "JALECO-JF-01", Type::JALECO_JF01 }, 901 { "JALECO-JF-02", Type::JALECO_JF02 }, 902 { "JALECO-JF-03", Type::JALECO_JF03 }, 903 { "JALECO-JF-04", Type::JALECO_JF04 }, 904 { "JALECO-JF-05", Type::JALECO_JF05 }, 905 { "JALECO-JF-06", Type::JALECO_JF06 }, 906 { "JALECO-JF-07", Type::JALECO_JF07 }, 907 { "JALECO-JF-08", Type::JALECO_JF08 }, 908 { "JALECO-JF-09", Type::JALECO_JF09 }, 909 { "JALECO-JF-10", Type::JALECO_JF10 }, 910 { "JALECO-JF-11", Type::JALECO_JF11 }, 911 { "JALECO-JF-12", Type::JALECO_JF12 }, 912 { "JALECO-JF-13", Type::JALECO_JF13 }, 913 { "JALECO-JF-14", Type::JALECO_JF14 }, 914 { "JALECO-JF-15", Type::JALECO_JF15 }, 915 { "JALECO-JF-16", Type::JALECO_JF16 }, 916 { "JALECO-JF-17", Type::JALECO_JF17 }, 917 { "JALECO-JF-18", Type::JALECO_JF18 }, 918 { "JALECO-JF-19", Type::JALECO_JF19 }, 919 { "JALECO-JF-20", Type::JALECO_JF20 }, 920 { "JALECO-JF-21", Type::JALECO_JF21 }, 921 { "JALECO-JF-22", Type::JALECO_JF22 }, 922 { "JALECO-JF-23", Type::JALECO_JF23 }, 923 { "JALECO-JF-24", Type::JALECO_JF24 }, 924 { "JALECO-JF-25", Type::JALECO_JF25 }, 925 { "JALECO-JF-26", Type::JALECO_JF26 }, 926 { "JALECO-JF-27", Type::JALECO_JF27 }, 927 { "JALECO-JF-28", Type::JALECO_JF28 }, 928 { "JALECO-JF-29", Type::JALECO_JF29 }, 929 { "JALECO-JF-30", Type::JALECO_JF30 }, 930 { "JALECO-JF-31", Type::JALECO_JF31 }, 931 { "JALECO-JF-32", Type::JALECO_JF32 }, 932 { "JALECO-JF-33", Type::JALECO_JF33 }, 933 { "JALECO-JF-34", Type::JALECO_JF34 }, 934 { "JALECO-JF-35", Type::JALECO_JF35 }, 935 { "JALECO-JF-36", Type::JALECO_JF36 }, 936 { "JALECO-JF-37", Type::JALECO_JF37 }, 937 { "JALECO-JF-38", Type::JALECO_JF38 }, 938 { "JALECO-JF-39", Type::JALECO_JF39 }, 939 { "JALECO-JF-40", Type::JALECO_JF40 }, 940 { "JALECO-JF-41", Type::JALECO_JF41 }, 941 { "KONAMI-74*139/74", Type::DISCRETE_74_139_74 }, 942 { "KONAMI-CNROM", Type::STD_CNROM }, 943 { "KONAMI-NROM-128", Type::STD_NROM }, 944 { "KONAMI-SLROM", Type::STD_SLROM }, 945 { "KONAMI-TLROM", Type::STD_TLROM }, 946 { "KONAMI-UNROM", Type::STD_UNROM }, 947 { "KONAMI-VRC-1", Type::KONAMI_VRC1 }, 948 { "KONAMI-VRC-2", Type::KONAMI_VRC2 }, 949 { "KONAMI-VRC-3", Type::KONAMI_VRC3 }, 950 { "KONAMI-VRC-4", Type::KONAMI_VRC4_0 }, 951 { "KONAMI-VRC-6", Type::KONAMI_VRC6_0 }, 952 { "KONAMI-VRC-7", Type::KONAMI_VRC7_0 }, 953 { "KS7031", Type::KAISER_KS7031 }, 954 { "MLT-ACTION52", Type::AE_STD }, 955 { "MLT-CALTRON6IN1", Type::CALTRON_6IN1 }, 956 { "MLT-MAXI15", Type::AVE_D1012 }, 957 { "NAMCOT-163", Type::NAMCOT_163_0 }, 958 { "NAMCOT-175", Type::NAMCOT_175 }, 959 { "NAMCOT-340", Type::NAMCOT_340 }, 960 { "NAMCOT-3301", Type::STD_NROM }, 961 { "NAMCOT-3302", Type::STD_NROM }, 962 { "NAMCOT-3303", Type::STD_NROM }, 963 { "NAMCOT-3305", Type::STD_NROM }, 964 { "NAMCOT-3311", Type::STD_NROM }, 965 { "NAMCOT-3401", Type::STD_DE1ROM }, 966 { "NAMCOT-3405", Type::STD_DE1ROM }, 967 { "NAMCOT-3406", Type::STD_DE1ROM }, 968 { "NAMCOT-3407", Type::STD_DE1ROM }, 969 { "NAMCOT-3411", Type::STD_NROM }, 970 { "NAMCOT-3413", Type::STD_DE1ROM }, 971 { "NAMCOT-3414", Type::STD_DE1ROM }, 972 { "NAMCOT-3415", Type::STD_DE1ROM }, 973 { "NAMCOT-3416", Type::STD_DE1ROM }, 974 { "NAMCOT-3417", Type::STD_DE1ROM }, 975 { "NAMCOT-3425", Type::NAMCOT_3425 }, 976 { "NAMCOT-3433", Type::NAMCOT_3433 }, 977 { "NAMCOT-3443", Type::NAMCOT_3443 }, 978 { "NAMCOT-3446", Type::NAMCOT_3446 }, 979 { "NAMCOT-3451", Type::STD_DE1ROM }, 980 { "NES-AMROM", Type::STD_AMROM }, 981 { "NES-AN1ROM", Type::STD_AN1ROM }, 982 { "NES-ANROM", Type::STD_ANROM }, 983 { "NES-AOROM", Type::STD_AOROM }, 984 { "NES-B4", Type::STD_TLROM }, 985 { "NES-BNROM", Type::STD_BNROM }, 986 { "NES-BTR", Type::CUSTOM_BTR }, 987 { "NES-CNROM", Type::STD_CNROM }, 988 { "NES-CPROM", Type::STD_CPROM }, 989 { "NES-DE1ROM", Type::STD_DE1ROM }, 990 { "NES-DEROM", Type::STD_DEROM }, 991 { "NES-DRROM", Type::STD_DRROM }, 992 { "NES-EKROM", Type::STD_EKROM }, 993 { "NES-ELROM", Type::STD_ELROM }, 994 { "NES-ETROM", Type::STD_ETROM }, 995 { "NES-EVENT", Type::CUSTOM_EVENT }, 996 { "NES-EWROM", Type::STD_EWROM }, 997 { "NES-FJROM", Type::STD_FJROM }, 998 { "NES-FKROM", Type::STD_FKROM }, 999 { "NES-GNROM", Type::STD_GNROM }, 1000 { "NES-HKROM", Type::STD_HKROM }, 1001 { "NES-HROM", Type::STD_NROM }, 1002 { "NES-JLROM", Type::STD_JLROM }, 1003 { "NES-JSROM", Type::STD_JSROM }, 1004 { "NES-MHROM", Type::STD_MHROM }, 1005 { "NES-NROM", Type::STD_NROM }, 1006 { "NES-NROM-128", Type::STD_NROM }, 1007 { "NES-NROM-256", Type::STD_NROM }, 1008 { "NES-NTBROM", Type::STD_NTBROM }, 1009 { "NES-PEEOROM", Type::STD_PEEOROM }, 1010 { "NES-PNROM", Type::STD_PNROM }, 1011 { "NES-QJ", Type::CUSTOM_QJ }, 1012 { "NES-RROM", Type::STD_NROM }, 1013 { "NES-RROM-128", Type::STD_NROM }, 1014 { "NES-SAROM", Type::STD_SAROM }, 1015 { "NES-SBROM", Type::STD_SBROM }, 1016 { "NES-SC1ROM", Type::STD_SCROM }, 1017 { "NES-SCROM", Type::STD_SCROM }, 1018 { "NES-SEROM", Type::STD_SEROM }, 1019 { "NES-SF1ROM", Type::STD_SFROM }, 1020 { "NES-SFROM", Type::STD_SFROM }, 1021 { "NES-SGROM", Type::STD_SGROM }, 1022 { "NES-SH1ROM", Type::STD_SHROM }, 1023 { "NES-SHROM", Type::STD_SHROM }, 1024 { "NES-SJROM", Type::STD_SJROM }, 1025 { "NES-SKROM", Type::STD_SKROM }, 1026 { "NES-SL1ROM", Type::STD_SLROM }, 1027 { "NES-SL2ROM", Type::STD_SLROM }, 1028 { "NES-SL3ROM", Type::STD_SLROM }, 1029 { "NES-SLROM", Type::STD_SLROM }, 1030 { "NES-SLRROM", Type::STD_SLROM }, 1031 { "NES-SNROM", Type::STD_SNROM }, 1032 { "NES-SOROM", Type::STD_SOROM }, 1033 { "NES-SROM", Type::STD_NROM }, 1034 { "NES-STROM", Type::STD_NROM }, 1035 { "NES-SUROM", Type::STD_SUROM }, 1036 { "NES-SXROM", Type::STD_SXROM }, 1037 { "NES-TBROM", Type::STD_TBROM }, 1038 { "NES-TEROM", Type::STD_TEROM }, 1039 { "NES-TFROM", Type::STD_TFROM }, 1040 { "NES-TGROM", Type::STD_TGROM }, 1041 { "NES-TKROM", Type::STD_TKROM }, 1042 { "NES-TKSROM", Type::STD_TKSROM }, 1043 { "NES-TL1ROM", Type::STD_TLROM }, 1044 { "NES-TL2ROM", Type::STD_TLROM }, 1045 { "NES-TLROM", Type::STD_TLROM }, 1046 { "NES-TLSROM", Type::STD_TLSROM }, 1047 { "NES-TNROM", Type::STD_TNROM }, 1048 { "NES-TQROM", Type::STD_TQROM }, 1049 { "NES-TR1ROM", Type::STD_TR1ROM }, 1050 { "NES-TSROM", Type::STD_TSROM }, 1051 { "NES-TVROM", Type::STD_TVROM }, 1052 { "NES-UN1ROM", Type::STD_UN1ROM }, 1053 { "NES-UNROM", Type::STD_UNROM }, 1054 { "NES-UOROM", Type::STD_UOROM }, 1055 { "NES-WH", Type::CUSTOM_WH }, 1056 { "NTDEC-N715062", Type::NTDEC_N715062 }, 1057 { "PAL-MH", Type::STD_MHROM }, 1058 { "PAL-ZZ", Type::CUSTOM_ZZ }, 1059 { "SACHEN-8259A", Type::SACHEN_8259A }, 1060 { "SACHEN-8259B", Type::SACHEN_8259B }, 1061 { "SACHEN-8259C", Type::SACHEN_8259C }, 1062 { "SACHEN-8259D", Type::SACHEN_8259D }, 1063 { "SACHEN-CNROM", Type::STD_CXROM }, 1064 { "SETA-NROM-128", Type::STD_NROM }, 1065 { "SUNSOFT-1", Type::SUNSOFT_1 }, 1066 { "SUNSOFT-2", Type::SUNSOFT_2B }, 1067 { "SUNSOFT-3", Type::SUNSOFT_3 }, 1068 { "SUNSOFT-4", Type::SUNSOFT_4_0 }, 1069 { "SUNSOFT-5B", Type::SUNSOFT_5B_0 }, 1070 { "SUNSOFT-FME-7", Type::SUNSOFT_FME7_0 }, 1071 { "SUNSOFT-NROM-256", Type::STD_NROM }, 1072 { "TAITO-74*139/74", Type::DISCRETE_74_139_74 }, 1073 { "TAITO-74*161/161/32", Type::DISCRETE_74_161_161_32_A }, 1074 { "TAITO-CNROM", Type::STD_CNROM }, 1075 { "TAITO-NROM-128", Type::STD_NROM }, 1076 { "TAITO-NROM-256", Type::STD_NROM }, 1077 { "TAITO-TC0190FMC", Type::TAITO_TC0190FMC }, 1078 { "TAITO-TC0190FMC+PAL16R4", Type::TAITO_TC0190FMC_PAL16R4 }, 1079 { "TAITO-UNROM", Type::STD_UNROM }, 1080 { "TAITO-X1-005", Type::TAITO_X1005 }, 1081 { "TAITO-X1-017", Type::TAITO_X1017 }, 1082 { "TENGEN-800002", Type::TENGEN_800002 }, 1083 { "TENGEN-800003", Type::STD_NROM }, 1084 { "TENGEN-800004", Type::TENGEN_800004 }, 1085 { "TENGEN-800008", Type::TENGEN_800008 }, 1086 { "TENGEN-800030", Type::TENGEN_800030 }, 1087 { "TENGEN-800032", Type::TENGEN_800032 }, 1088 { "TENGEN-800037", Type::TENGEN_800037 }, 1089 { "TENGEN-800042", Type::TENGEN_800042 }, 1090 { "UNL-22211", Type::TXC_22211A }, 1091 { "UNL-603-5052", Type::BTL_6035052 }, 1092 { "UNL-8237", Type::SUPERGAME_POCAHONTAS2 }, 1093 { "UNL-A9746", Type::UNL_A9746 }, 1094 { "UNL-AX5705", Type::BTL_AX5705 }, 1095 { "UNL-CC-21", Type::UNL_CC21 }, 1096 { "UNL-EDU2000", Type::UNL_EDU2000 }, 1097 { "UNL-H2288", Type::KAY_H2288 }, 1098 { "UNL-KOF97", Type::UNL_KINGOFFIGHTERS97 }, 1099 { "UNL-KS7031", Type::KAISER_KS7031 }, 1100 { "UNL-KS7032", Type::KAISER_KS7032 }, 1101 { "UNL-N625092", Type::UNL_N625092 }, 1102 { "UNL-SA-0036", Type::SACHEN_SA0036 }, 1103 { "UNL-SA-0037", Type::SACHEN_SA0037 }, 1104 { "UNL-SA-016-1M", Type::SACHEN_SA0161M }, 1105 { "UNL-SA-72007", Type::SACHEN_SA72007 }, 1106 { "UNL-SA-72008", Type::SACHEN_SA72008 }, 1107 { "UNL-SA-NROM", Type::SACHEN_TCA01 }, 1108 { "UNL-SACHEN-74LS374N", Type::SACHEN_74_374B }, 1109 { "UNL-SACHEN-8259A", Type::SACHEN_8259A }, 1110 { "UNL-SACHEN-8259B", Type::SACHEN_8259B }, 1111 { "UNL-SACHEN-8259C", Type::SACHEN_8259C }, 1112 { "UNL-SACHEN-8259D", Type::SACHEN_8259D }, 1113 { "UNL-SHERO", Type::SACHEN_STREETHEROES }, 1114 { "UNL-SL1632", Type::REXSOFT_SL1632 }, 1115 { "UNL-SMB2J", Type::BTL_SMB2_C }, 1116 { "UNL-T-230", Type::BTL_T230 }, 1117 { "UNL-TC-U01-1.5M", Type::SACHEN_TCU01 }, 1118 { "UNL-TEK90", Type::JYCOMPANY_TYPE_A }, 1119 { "UNL-TF1201", Type::UNL_TF1201 }, 1120 { "VIRGIN-SNROM", Type::STD_SNROM } 1121 }; 1122 1123 #ifdef NST_DEBUG 1124 for (uint i=1; i < sizeof(array(lut)); ++i) 1125 NST_ASSERT( Element::Less()( lut[i-1], lut[i] ) ); 1126 #endif 1127 1128 const Element* const result = std::lower_bound 1129 ( 1130 lut, 1131 lut + sizeof(array(lut)), 1132 string, 1133 Element::Less() 1134 ); 1135 1136 if (result == lut+sizeof(array(lut)) || Core::StringCompare( result->name, string ) != 0) 1137 return false; 1138 1139 name = result->name; 1140 Type::Id id = static_cast<Type::Id>(result->id); 1141 1142 switch (id) 1143 { 1144 case Type::STD_NTBROM: 1145 1146 if (prg.Size() > SIZE_128K) 1147 id = Type::SUNSOFT_DCS; 1148 1149 break; 1150 1151 case Type::CUSTOM_FB02: 1152 1153 if (wram == 0) 1154 { 1155 id = Type::STD_NROM; 1156 } 1157 else if (wram > SIZE_2K) 1158 { 1159 id = Type::CUSTOM_FB04; 1160 } 1161 break; 1162 1163 case Type::DISCRETE_74_161_161_32_A: 1164 1165 if (nmt != Type::NMT_VERTICAL && nmt != Type::NMT_HORIZONTAL) 1166 id = Type::DISCRETE_74_161_161_32_B; 1167 1168 break; 1169 1170 case Type::SUNSOFT_2B: 1171 1172 if (nmt == Type::NMT_VERTICAL || nmt == Type::NMT_HORIZONTAL) 1173 id = Type::SUNSOFT_2A; 1174 1175 break; 1176 1177 case Type::SUNSOFT_4_0: 1178 1179 if (prg.Size() > SIZE_128K) 1180 { 1181 id = Type::SUNSOFT_DCS; 1182 } 1183 else if (wram) 1184 { 1185 id = Type::SUNSOFT_4_1; 1186 } 1187 break; 1188 1189 case Type::NAMCOT_163_0: 1190 1191 if (mmcBattery) 1192 { 1193 id = (wram ? Type::NAMCOT_163_S_1 : Type::NAMCOT_163_S_0); 1194 } 1195 else if (wram) 1196 { 1197 id = Type::NAMCOT_163_1; 1198 } 1199 break; 1200 1201 default: 1202 1203 if (wram) 1204 { 1205 if (id == Type::KONAMI_VRC4_0) { id = (wram > SIZE_2K ? Type::KONAMI_VRC4_2 : Type::KONAMI_VRC4_1); } 1206 else if (id == Type::KONAMI_VRC6_0) { id = Type::KONAMI_VRC6_1; } 1207 else if (id == Type::KONAMI_VRC7_0) { id = Type::KONAMI_VRC7_1; } 1208 else if (id == Type::IREM_G101A_0) { id = Type::IREM_G101A_1; } 1209 else if (id == Type::IREM_G101B_0) { id = Type::IREM_G101B_1; } 1210 else if (id == Type::SUNSOFT_FME7_0) { id = Type::SUNSOFT_FME7_1; } 1211 else if (id == Type::SUNSOFT_5B_0) { id = Type::SUNSOFT_5B_1; } 1212 } 1213 break; 1214 } 1215 1216 type = Type( id, prg, chr, nmt, wramBattery || mmcBattery, false ); 1217 1218 return true; 1219 } 1220 DetectBoard(const byte mapper,const byte submapper,const dword chrRam,const dword wram,bool wramAuto)1221 bool Board::Context::DetectBoard(const byte mapper,const byte submapper,const dword chrRam,const dword wram,bool wramAuto) 1222 { 1223 Type::Id id; 1224 1225 const dword prg = this->prg.Size(); 1226 const dword chr = this->chr.Size(); 1227 1228 bool useWramAuto = false; 1229 1230 if (wram) 1231 { 1232 wramAuto = false; 1233 } 1234 else if (wramAuto) 1235 { 1236 wramAuto = false; 1237 useWramAuto = true; 1238 } 1239 1240 switch (mapper) 1241 { 1242 case 0: 1243 1244 if ((prg < SIZE_32K && prg != SIZE_16K) || !chr || wram >= SIZE_8K || (nmt != Type::NMT_HORIZONTAL && nmt != Type::NMT_VERTICAL)) 1245 { 1246 name = "NROM (non-standard)"; 1247 id = Type::UNL_NROM; 1248 } 1249 else if (wram && wramBattery) 1250 { 1251 if (wram > SIZE_2K) 1252 { 1253 name = "FB-04"; 1254 id = Type::CUSTOM_FB04; 1255 } 1256 else 1257 { 1258 name = "FB-02"; 1259 id = Type::CUSTOM_FB02; 1260 } 1261 } 1262 else 1263 { 1264 if (prg == SIZE_16K) 1265 name = "NROM-128"; 1266 else 1267 name = "NROM-256"; 1268 1269 id = Type::STD_NROM; 1270 } 1271 break; 1272 1273 case 155: 1274 1275 chips.Add(L"MMC1A"); 1276 1277 case 1: 1278 1279 if (prg == SIZE_64K && (chr == SIZE_16K || chr == SIZE_32K || chr == SIZE_64K) && wram <= SIZE_8K) 1280 { 1281 if (wram || useWramAuto) 1282 { 1283 wramAuto = useWramAuto; 1284 name = "SAROM"; 1285 id = Type::STD_SAROM; 1286 } 1287 else 1288 { 1289 name = "SBROM"; 1290 id = Type::STD_SBROM; 1291 } 1292 } 1293 else if (prg == SIZE_64K && chr >= SIZE_128K && !wram && !useWramAuto) 1294 { 1295 name = "SCROM"; 1296 id = Type::STD_SCROM; 1297 } 1298 else if (prg == SIZE_32K && (chr == SIZE_16K || chr == SIZE_32K || chr == SIZE_64K) && !wram && !useWramAuto) 1299 { 1300 name = "SEROM"; 1301 id = Type::STD_SEROM; 1302 } 1303 else if ((prg == SIZE_128K || prg == SIZE_256K) && (chr == SIZE_16K || chr == SIZE_32K || chr == SIZE_64K) && wram <= SIZE_8K) 1304 { 1305 if (wram || useWramAuto) 1306 { 1307 wramAuto = useWramAuto; 1308 name = "SJROM"; 1309 id = Type::STD_SJROM; 1310 } 1311 else 1312 { 1313 name = "SFROM"; 1314 id = Type::STD_SFROM; 1315 } 1316 } 1317 else if ((prg == SIZE_128K || prg == SIZE_256K) && !chr && wram <= SIZE_16K) 1318 { 1319 if (wram > SIZE_8K) 1320 { 1321 name = "SOROM"; 1322 id = Type::STD_SOROM; 1323 } 1324 else if (wram || useWramAuto) 1325 { 1326 wramAuto = useWramAuto; 1327 name = "SNROM"; 1328 id = Type::STD_SNROM; 1329 } 1330 else 1331 { 1332 name = "SGROM"; 1333 id = Type::STD_SGROM; 1334 } 1335 } 1336 else if (prg == SIZE_32K && chr == SIZE_128K && !wram && !useWramAuto) 1337 { 1338 name = "SHROM"; 1339 id = Type::STD_SHROM; 1340 } 1341 else if ((prg == SIZE_128K || prg == SIZE_256K) && chr == SIZE_128K && wram <= SIZE_8K) 1342 { 1343 if (wram || useWramAuto) 1344 { 1345 wramAuto = useWramAuto; 1346 name = "SKROM"; 1347 id = Type::STD_SKROM; 1348 } 1349 else 1350 { 1351 name = "SLROM"; 1352 id = Type::STD_SLROM; 1353 } 1354 } 1355 else if ((prg == SIZE_64K || prg == SIZE_128K || prg == SIZE_256K) && chr == SIZE_128K && !wram && !useWramAuto) 1356 { 1357 name = "SL1ROM"; 1358 id = Type::STD_SLROM; 1359 } 1360 else if (prg >= SIZE_512K && !chr && wram < SIZE_32K) 1361 { 1362 name = "SUROM"; 1363 id = Type::STD_SUROM; 1364 } 1365 else if ((prg == SIZE_128K || prg == SIZE_256K || prg >= SIZE_512K) && !chr && wram >= SIZE_32K) 1366 { 1367 name = "SXROM"; 1368 id = Type::STD_SXROM; 1369 } 1370 else 1371 { 1372 name = "SxROM (non-standard)"; 1373 1374 if (wram || useWramAuto) 1375 { 1376 wramAuto = useWramAuto; 1377 id = Type::STD_SKROM; 1378 } 1379 else 1380 { 1381 id = Type::STD_SLROM; 1382 } 1383 } 1384 break; 1385 1386 case 2: 1387 1388 if (!chr && !wram && (nmt == Type::NMT_HORIZONTAL || nmt == Type::NMT_VERTICAL)) 1389 { 1390 if (prg == SIZE_128K) 1391 { 1392 name = "UNROM"; 1393 id = Type::STD_UXROM; 1394 break; 1395 } 1396 else if (prg == SIZE_256K) 1397 { 1398 name = "UOROM"; 1399 id = Type::STD_UXROM; 1400 break; 1401 } 1402 } 1403 1404 name = "UxROM (non-standard)"; 1405 id = Type::UNL_UXROM; 1406 break; 1407 1408 case 185: 1409 1410 if (!this->prg.PinsDefined()) 1411 return false; 1412 1413 case 3: 1414 1415 if ((prg != SIZE_16K && prg != SIZE_32K) || (chr != SIZE_8K && chr != SIZE_16K && chr != SIZE_32K) || (nmt != Type::NMT_HORIZONTAL && nmt != Type::NMT_VERTICAL)) 1416 { 1417 name = "CxROM (non-standard)"; 1418 id = Type::UNL_CXROM; 1419 } 1420 else if (wram) 1421 { 1422 name = "X79B"; 1423 id = Type::CUSTOM_X79B; 1424 } 1425 else 1426 { 1427 name = "CNROM"; 1428 id = Type::STD_CXROM; 1429 } 1430 break; 1431 1432 case 4: 1433 1434 if (submapper == 1) 1435 { // StarTropics/Zoda's Revenge - might not be correct 1436 chips.Add(L"MMC6B"); 1437 name = "NES-HKROM"; 1438 id = Type::STD_HKROM; 1439 break; 1440 } 1441 1442 if (submapper == 3) 1443 { 1444 name = "ACCLAIM-MC-ACC"; 1445 id = Type::ACCLAIM_MCACC; 1446 break; 1447 } 1448 1449 if (chrRam == 32) 1450 { 1451 name = "UNL-MMC3BIGCHRRAM"; 1452 id = Type::UNL_MMC3BIGCHRRAM; 1453 break; 1454 } 1455 1456 if (nmt == Type::NMT_FOURSCREEN) 1457 { 1458 if (prg == SIZE_64K && (chr == SIZE_32K || chr == SIZE_64K) && !wram && !useWramAuto) 1459 { 1460 name = "TVROM"; 1461 id = Type::STD_TVROM; 1462 } 1463 else if ((prg == SIZE_128K || prg == SIZE_256K || prg >= SIZE_512K) && chr == SIZE_64K && !wram && !useWramAuto) 1464 { 1465 name = "TR1ROM"; 1466 id = Type::STD_TR1ROM; 1467 } 1468 else 1469 { 1470 name = "TxROM (non-standard)"; 1471 wramAuto = useWramAuto; 1472 id = Type::UNL_TRXROM; 1473 } 1474 } 1475 else 1476 { 1477 if (prg == SIZE_32K && (chr == SIZE_32K || chr == SIZE_64K) && !wram && !useWramAuto) 1478 { 1479 name = "TEROM"; 1480 id = Type::STD_TEROM; 1481 } 1482 else if (prg == SIZE_64K && (chr == SIZE_32K || chr == SIZE_64K) && !wram && !useWramAuto) 1483 { 1484 name = "TBROM"; 1485 id = Type::STD_TBROM; 1486 } 1487 else if ((prg == SIZE_128K || prg == SIZE_256K || prg >= SIZE_512K) && (chr == SIZE_32K || chr == SIZE_64K) && !wram && !useWramAuto) 1488 { 1489 name = "TFROM"; 1490 id = Type::STD_TFROM; 1491 } 1492 else if ((prg == SIZE_128K || prg == SIZE_256K || prg >= SIZE_512K) && !chr) 1493 { 1494 if (wram || useWramAuto) 1495 { 1496 wramAuto = useWramAuto; 1497 name = "TNROM"; 1498 id = Type::STD_TNROM; 1499 } 1500 else 1501 { 1502 name = "TGROM"; 1503 id = Type::STD_TGROM; 1504 } 1505 } 1506 else if ((prg == SIZE_128K || prg == SIZE_256K || prg >= SIZE_512K) && (chr == SIZE_128K || chr >= SIZE_256K)) 1507 { 1508 if (wram || useWramAuto) 1509 { 1510 wramAuto = useWramAuto; 1511 1512 if (wramBattery) 1513 { 1514 name = "TKROM"; 1515 id = Type::STD_TKROM; 1516 } 1517 else 1518 { 1519 name = "TSROM"; 1520 id = Type::STD_TSROM; 1521 } 1522 } 1523 else 1524 { 1525 name = "TLROM"; 1526 id = Type::STD_TLROM; 1527 } 1528 } 1529 else 1530 { 1531 name = "TxROM (non-standard)"; 1532 1533 if (wram || useWramAuto) 1534 { 1535 wramAuto = useWramAuto; 1536 id = Type::STD_TKROM; 1537 } 1538 else 1539 { 1540 id = Type::STD_TLROM; 1541 } 1542 } 1543 } 1544 break; 1545 1546 case 5: 1547 1548 if 1549 ( 1550 (prg == SIZE_128K || prg == SIZE_256K || prg == SIZE_512K) && 1551 (chr == SIZE_128K || chr == SIZE_256K || chr == SIZE_512K) && 1552 (wram <= SIZE_32K) 1553 ) 1554 { 1555 if (wram > SIZE_16K) 1556 { 1557 name = "EWROM"; 1558 id = Type::STD_EWROM; 1559 } 1560 else if (wram > SIZE_8K) 1561 { 1562 name = "ETROM"; 1563 id = Type::STD_ETROM; 1564 } 1565 else if (wram || useWramAuto) 1566 { 1567 wramAuto = useWramAuto; 1568 name = "EKROM"; 1569 id = Type::STD_EKROM; 1570 } 1571 else 1572 { 1573 name = "ELROM"; 1574 id = Type::STD_ELROM; 1575 } 1576 } 1577 else 1578 { 1579 name = "ExROM (non-standard)"; 1580 1581 if (wram > SIZE_40K) 1582 { 1583 id = Type::STD_EXROM_5; 1584 } 1585 else if (wram > SIZE_32K) 1586 { 1587 id = Type::STD_EXROM_4; 1588 } 1589 else if (wram > SIZE_16K) 1590 { 1591 id = Type::STD_EXROM_3; 1592 } 1593 else if (wram > SIZE_8K) 1594 { 1595 id = Type::STD_EXROM_2; 1596 } 1597 else if (wram || useWramAuto) 1598 { 1599 wramAuto = useWramAuto; 1600 id = Type::STD_EXROM_1; 1601 } 1602 else 1603 { 1604 id = Type::STD_EXROM_0; 1605 } 1606 } 1607 break; 1608 1609 case 6: 1610 1611 name = "FFE F4xxx / F3xxx (a)"; 1612 id = Type::CUSTOM_FFE4; 1613 break; 1614 1615 case 7: 1616 1617 if (!chr && !wram) 1618 { 1619 if (prg == SIZE_256K) 1620 { 1621 name = "AOROM"; 1622 id = Type::STD_AOROM; 1623 break; 1624 } 1625 else if (prg == SIZE_128K) 1626 { 1627 name = "ANROM"; 1628 id = Type::STD_ANROM; 1629 break; 1630 } 1631 else if (prg == SIZE_64K) 1632 { 1633 name = "AN1ROM"; 1634 id = Type::STD_AN1ROM; 1635 break; 1636 } 1637 } 1638 1639 name = "AxROM (non-standard)"; 1640 id = Type::UNL_AXROM; 1641 break; 1642 1643 case 8: 1644 1645 name = "FFE F3xxx (b)"; 1646 id = Type::CUSTOM_FFE3; 1647 break; 1648 1649 case 9: 1650 1651 if (prg < SIZE_128K || (chr < SIZE_128K && chr != SIZE_8K && chr != SIZE_16K && chr != SIZE_32K && chr != SIZE_64K)) 1652 { 1653 name = "PxROM (non-standard)"; 1654 id = Type::STD_PNROM; 1655 } 1656 else if (wram && wramBattery) 1657 { 1658 name = "PNROM PC10"; 1659 id = Type::STD_PNROM_PC10; 1660 } 1661 else 1662 { 1663 name = "PNROM / PEEOROM"; 1664 id = Type::STD_PNROM; 1665 } 1666 break; 1667 1668 case 10: 1669 1670 if (chr == SIZE_8K || chr == SIZE_16K || chr == SIZE_32K || chr == SIZE_64K || chr >= SIZE_128K) 1671 { 1672 if (prg == SIZE_128K) 1673 { 1674 name = "FJROM"; 1675 id = Type::STD_FJROM; 1676 break; 1677 } 1678 else if (prg >= SIZE_256K) 1679 { 1680 name = "FKROM"; 1681 id = Type::STD_FKROM; 1682 break; 1683 } 1684 } 1685 1686 name = "FxROM (non-standard)"; 1687 id = Type::STD_FKROM; 1688 break; 1689 1690 case 11: 1691 1692 name = "COLORDREAMS 74*377"; 1693 id = Type::DISCRETE_74_377; 1694 break; 1695 1696 case 12: 1697 1698 name = "REX DBZ5"; 1699 id = Type::REXSOFT_DBZ5; 1700 break; 1701 1702 case 13: 1703 1704 name = "CPROM"; 1705 id = Type::STD_CPROM; 1706 break; 1707 1708 case 14: 1709 1710 name = "SOMERITEAM SL-1632"; 1711 id = Type::REXSOFT_SL1632; 1712 break; 1713 1714 case 15: 1715 1716 name = "WAIXING / BMC CONTRA 100-IN-1"; 1717 1718 if (wram || useWramAuto) 1719 { 1720 wramAuto = useWramAuto; 1721 id = Type::WAIXING_PS2_1; 1722 } 1723 else 1724 { 1725 id = Type::WAIXING_PS2_0; 1726 } 1727 break; 1728 1729 case 16: 1730 1731 if (!wram && prg <= SIZE_256K) 1732 { 1733 name = "BANDAI LZ93D50 +24C02"; 1734 id = Type::BANDAI_LZ93D50_24C02; 1735 break; 1736 } 1737 1738 case 153: 1739 1740 if (prg == SIZE_512K) 1741 { 1742 name = "BANDAI BA-JUMP2"; 1743 id = Type::BANDAI_BAJUMP2; 1744 } 1745 else 1746 { 1747 name = "BANDAI FCG-1/FCG-2"; 1748 id = Type::BANDAI_FCG1; 1749 } 1750 break; 1751 1752 case 17: 1753 1754 name = "FFE F8xxx / SMxxxx"; 1755 id = Type::CUSTOM_FFE8; 1756 break; 1757 1758 case 18: 1759 1760 name = "JALECO SS88006"; 1761 id = Type::JALECO_SS88006; 1762 break; 1763 1764 case 19: 1765 1766 name = "NAMCOT 163"; 1767 1768 if (wram || useWramAuto) 1769 { 1770 wramAuto = useWramAuto; 1771 1772 if (mmcBattery) 1773 id = Type::NAMCOT_163_S_1; 1774 else 1775 id = Type::NAMCOT_163_1; 1776 } 1777 else 1778 { 1779 if (mmcBattery) 1780 id = Type::NAMCOT_163_S_0; 1781 else 1782 id = Type::NAMCOT_163_0; 1783 } 1784 break; 1785 1786 case 21: 1787 1788 if (submapper == 1) 1789 { 1790 Chips::Type& chip = chips.Add(L"Konami VRC IV"); 1791 1792 chip.Pin(3) = L"PRG A2"; 1793 chip.Pin(4) = L"PRG A1"; 1794 1795 name = "KONAMI VRC4"; 1796 id = Type::KONAMI_VRC4_0; 1797 } 1798 case 25: 1799 1800 if (submapper == 2) 1801 { // The correct board is VRC2 but the functionality is implemented in the VRC4 code currently 1802 Chips::Type& chip = chips.Add(L"Konami VRC IV"); 1803 chip.Pin(3) = L"PRG A0"; 1804 chip.Pin(4) = L"PRG A1"; 1805 1806 name = "KONAMI VRC2"; 1807 id = Type::KONAMI_VRC4_2; 1808 break; 1809 } 1810 1811 if (!this->chips.Has(L"Konami VRC IV")) 1812 return false; 1813 1814 name = "KONAMI VRC4"; 1815 id = Type::KONAMI_VRC4_2; 1816 break; 1817 1818 case 22: 1819 1820 if (!this->chips.Has(L"Konami VRC II")) 1821 { 1822 Chips::Type& chip = chips.Add(L"Konami VRC II"); 1823 1824 chip.Pin(3) = L"PRG A0"; 1825 chip.Pin(4) = L"PRG A1"; 1826 chip.Pin(21) = (chr >= SIZE_256K ? L"CHR A17" : L"NC"); 1827 chip.Pin(22) = L"CHR A15"; 1828 chip.Pin(23) = L"CHR A10"; 1829 chip.Pin(24) = L"CHR A12"; 1830 chip.Pin(25) = L"CHR A13"; 1831 chip.Pin(26) = L"CHR A11"; 1832 chip.Pin(27) = L"CHR A14"; 1833 chip.Pin(28) = L"CHR A16"; 1834 } 1835 1836 name = "KONAMI VRC2"; 1837 id = Type::KONAMI_VRC2; 1838 break; 1839 1840 case 23: 1841 1842 if (submapper == 2) 1843 { 1844 Chips::Type& chip = chips.Add(L"Konami VRC IV"); 1845 1846 chip.Pin(3) = L"PRG A3"; 1847 chip.Pin(4) = L"PRG A2"; 1848 1849 name = "KONAMI VRC4"; 1850 id = Type::KONAMI_VRC4_0; 1851 } 1852 else if (submapper == 3) 1853 { 1854 name = "KONAMI VRC2"; 1855 id = Type::KONAMI_VRC2; 1856 break; 1857 } 1858 1859 if (prg >= SIZE_512K) 1860 { 1861 if (!this->chips.Has(L"Konami VRC IV")) 1862 { 1863 Chips::Type& chip = chips.Add(L"Konami VRC IV"); 1864 1865 chip.Pin(3) = L"PRG A3"; 1866 chip.Pin(4) = L"PRG A2"; 1867 } 1868 1869 name = "BMC VRC4"; 1870 id = Type::BMC_VRC4; 1871 } 1872 else if (this->chips.Has(L"Konami VRC II")) 1873 { 1874 name = "KONAMI VRC2"; 1875 id = Type::KONAMI_VRC2; 1876 } 1877 else if (this->chips.Has(L"Konami VRC IV")) 1878 { 1879 name = "KONAMI VRC4"; 1880 id = Type::KONAMI_VRC4_2; 1881 } 1882 else 1883 { 1884 return false; 1885 } 1886 break; 1887 1888 case 24: 1889 case 26: 1890 1891 if (!this->chips.Has(L"Konami VRC VI")) 1892 { 1893 Chips::Type& chip = chips.Add(L"Konami VRC VI"); 1894 1895 if (mapper == 24) 1896 { 1897 chip.Pin(9) = L"PRG A1"; 1898 chip.Pin(10) = L"PRG A0"; 1899 1900 name = "KONAMI VRC6 (a)"; 1901 } 1902 else 1903 { 1904 chip.Pin(9) = L"PRG A0"; 1905 chip.Pin(10) = L"PRG A1"; 1906 1907 name = "KONAMI VRC6 (b)"; 1908 } 1909 } 1910 1911 if (wram || useWramAuto) 1912 { 1913 wramAuto = useWramAuto; 1914 id = Type::KONAMI_VRC6_1; 1915 } 1916 else 1917 { 1918 id = Type::KONAMI_VRC6_0; 1919 } 1920 break; 1921 1922 case 27: 1923 1924 name = "UNL WORLDHERO"; 1925 id = Type::UNL_WORLDHERO; 1926 break; 1927 1928 case 28: 1929 1930 name = "ACTION 53"; 1931 id = Type::ACTION53; 1932 break; 1933 1934 case 30: 1935 1936 name = "UNROM 512"; 1937 id = Type::STD_UNROM512; 1938 break; 1939 1940 case 31: 1941 1942 name = "INLNSF"; 1943 id = Type::INLNSF; 1944 break; 1945 1946 case 32: 1947 1948 name = "IREM G-101"; 1949 1950 if (submapper == 1) 1951 { 1952 id = Type::IREM_G101B_0; 1953 break; 1954 } 1955 1956 if (wram || useWramAuto) 1957 { 1958 wramAuto = useWramAuto; 1959 id = Type::IREM_G101A_1; 1960 } 1961 else 1962 { 1963 id = Type::IREM_G101A_0; 1964 } 1965 break; 1966 1967 case 33: 1968 1969 name = "TAITO TC0190FMC"; 1970 id = Type::TAITO_TC0190FMC; 1971 break; 1972 1973 case 34: 1974 1975 if (chr) 1976 { 1977 name = "AVE NINA-001"; 1978 id = Type::AVE_NINA001; 1979 } 1980 else if (prg == SIZE_128K && !wram && (nmt == Type::NMT_HORIZONTAL || nmt == Type::NMT_VERTICAL)) 1981 { 1982 name = "BNROM"; 1983 id = Type::STD_BNROM; 1984 } 1985 else 1986 { 1987 name = "BxROM (non-standard)"; 1988 id = Type::UNL_BXROM; 1989 } 1990 break; 1991 1992 case 36: 1993 1994 name = "TXC 01-22000-400"; 1995 id = Type::TXC_POLICEMAN; 1996 break; 1997 1998 case 37: 1999 2000 name = "ZZ"; 2001 id = Type::CUSTOM_ZZ; 2002 break; 2003 2004 case 38: 2005 2006 name = "BIT CORP 74*161/138"; 2007 id = Type::DISCRETE_74_161_138; 2008 break; 2009 2010 case 39: 2011 2012 name = "STUDY & GAME 32-IN-1"; 2013 id = Type::SUBOR_STUDYNGAME; 2014 break; 2015 2016 case 40: 2017 2018 name = "BTL SMB2 (a)"; 2019 id = Type::BTL_SMB2_A; 2020 break; 2021 2022 case 41: 2023 2024 name = "CALTRON 6-IN-1"; 2025 id = Type::CALTRON_6IN1; 2026 break; 2027 2028 case 42: 2029 2030 if (chr) 2031 { 2032 name = "BTL UPA"; 2033 id = Type::BTL_MARIOBABY; 2034 } 2035 else 2036 { 2037 name = "BTL AI SENSHI NICOL"; 2038 id = Type::BTL_AISENSHINICOL; 2039 } 2040 break; 2041 2042 case 43: 2043 2044 name = "BTL SMB2 (c)"; 2045 id = Type::BTL_SMB2_C; 2046 break; 2047 2048 case 44: 2049 2050 name = "BMC SUPERBIG 7-IN-1"; 2051 id = Type::BMC_SUPERBIG_7IN1; 2052 break; 2053 2054 case 45: 2055 2056 name = "BMC SUPER/HERO X-IN-1"; 2057 id = Type::BMC_HERO; 2058 break; 2059 2060 case 46: 2061 2062 name = "RUMBLESTATION 15-IN-1"; 2063 id = Type::CUSTOM_RUMBLESTATION; 2064 break; 2065 2066 case 47: 2067 2068 name = "QJ"; 2069 id = Type::CUSTOM_QJ; 2070 break; 2071 2072 case 48: 2073 2074 name = "TAITO TC0190FMC +PAL16R4"; 2075 id = Type::TAITO_TC0190FMC_PAL16R4; 2076 break; 2077 2078 case 49: 2079 2080 name = "BMC SUPERHIK 4-IN-1"; 2081 id = Type::BMC_SUPERHIK_4IN1; 2082 break; 2083 2084 case 50: 2085 2086 name = "BTL SMB2 (b)"; 2087 id = Type::BTL_SMB2_B; 2088 break; 2089 2090 case 51: 2091 2092 name = "BMC 11-IN-1 BALLGAMES"; 2093 id = Type::BMC_BALLGAMES_11IN1; 2094 break; 2095 2096 case 52: 2097 2098 name = "BMC MARIOPARTY 7-IN-1"; 2099 id = Type::BMC_MARIOPARTY_7IN1; 2100 break; 2101 2102 case 53: 2103 2104 name = "BMC SUPERVISION 16-IN-1"; 2105 id = Type::BMC_SUPERVISION_16IN1; 2106 break; 2107 2108 case 54: 2109 2110 name = "BMC NOVELDIAMOND 9999999-IN-1"; 2111 id = Type::BMC_NOVELDIAMOND; 2112 break; 2113 2114 case 55: 2115 2116 name = "BTL GENIUS MERIO BROS"; 2117 id = Type::BTL_GENIUSMERIOBROS; 2118 break; 2119 2120 case 56: 2121 2122 name = "KAISER KS-202"; 2123 id = Type::KAISER_KS202; 2124 break; 2125 2126 case 57: 2127 2128 name = "BMC GAMESTAR (a)"; 2129 id = Type::BMC_GKA; 2130 break; 2131 2132 case 58: 2133 2134 name = "BMC GAMESTAR (b)"; 2135 id = Type::BMC_GKB; 2136 break; 2137 2138 case 60: 2139 2140 if (prg == SIZE_64K && chr == SIZE_32K) 2141 { 2142 name = "BMC RESETBASED 4-IN-1"; 2143 id = Type::BMC_RESETBASED_4IN1; 2144 } 2145 else 2146 { 2147 name = "BMC VT5201"; 2148 id = Type::BMC_VT5201; 2149 } 2150 break; 2151 2152 case 61: 2153 2154 name = "TXC / BMC 20-IN-1"; 2155 id = Type::RCM_TETRISFAMILY; 2156 break; 2157 2158 case 62: 2159 2160 name = "BMC SUPER 700-IN-1"; 2161 id = Type::BMC_SUPER_700IN1; 2162 break; 2163 2164 case 63: 2165 2166 name = "BMC CH-001"; 2167 id = Type::BMC_CH001; 2168 break; 2169 2170 case 64: 2171 2172 name = "TENGEN 800032"; 2173 id = Type::TENGEN_800032; 2174 break; 2175 2176 case 65: 2177 2178 name = "IREM H-3001"; 2179 id = Type::IREM_H3001; 2180 break; 2181 2182 case 66: 2183 2184 if ((chr == SIZE_8K || chr == SIZE_16K || chr == SIZE_32K) && !wram && (nmt == Type::NMT_HORIZONTAL || nmt == Type::NMT_VERTICAL)) 2185 { 2186 if (prg == SIZE_64K) 2187 { 2188 name = "GNROM / MHROM"; 2189 id = Type::STD_GNROM; 2190 break; 2191 } 2192 else if (prg == SIZE_32K || prg == SIZE_128K) 2193 { 2194 name = "GNROM"; 2195 id = Type::STD_GNROM; 2196 break; 2197 } 2198 } 2199 2200 name = "GxROM (non-standard)"; 2201 id = Type::UNL_GXROM; 2202 break; 2203 2204 case 67: 2205 2206 name = "SUNSOFT 3"; 2207 id = Type::SUNSOFT_3; 2208 break; 2209 2210 case 68: 2211 2212 if (submapper == 1) 2213 { 2214 name = "SUNSOFT DCS"; 2215 id = Type::SUNSOFT_DCS; 2216 break; 2217 } 2218 2219 if (prg > SIZE_128K) 2220 { 2221 name = "SUNSOFT DCS"; 2222 id = Type::SUNSOFT_DCS; 2223 } 2224 else 2225 { 2226 name = "SUNSOFT 4"; 2227 2228 if (wram || useWramAuto) 2229 { 2230 wramAuto = useWramAuto; 2231 id = Type::SUNSOFT_4_1; 2232 } 2233 else 2234 { 2235 id = Type::SUNSOFT_4_0; 2236 } 2237 } 2238 break; 2239 2240 case 69: 2241 2242 name = "SUNSOFT 5B/FME7"; 2243 2244 if (wram || useWramAuto) 2245 { 2246 wramAuto = useWramAuto; 2247 id = Type::SUNSOFT_5B_1; 2248 } 2249 else 2250 { 2251 id = Type::SUNSOFT_5B_0; 2252 } 2253 break; 2254 2255 case 70: 2256 2257 name = "74*161/161/32 (a)"; 2258 id = Type::DISCRETE_74_161_161_32_A; 2259 break; 2260 2261 case 71: 2262 2263 if (submapper == 1) 2264 { 2265 name = "CAMERICA BF9097"; 2266 id = Type::CAMERICA_BF9097; 2267 break; 2268 } 2269 2270 if (prg >= SIZE_256K) 2271 { 2272 name = "CAMERICA BF9093"; 2273 id = Type::CAMERICA_BF9093; 2274 } 2275 else 2276 { 2277 name = "CAMERICA BF9093/BF9097"; 2278 id = Type::CAMERICA_BF909X; 2279 } 2280 break; 2281 2282 case 72: 2283 2284 name = "JALECO JF-26/28"; 2285 id = Type::JALECO_JF26; 2286 break; 2287 2288 case 73: 2289 2290 name = "KONAMI VRC3"; 2291 id = Type::KONAMI_VRC3; 2292 break; 2293 2294 case 74: 2295 2296 name = "WAIXING (a)"; 2297 id = Type::WAIXING_TYPE_A; 2298 break; 2299 2300 case 75: 2301 2302 name = "KONAMI VRC1 / JALECO JF-22"; 2303 id = Type::KONAMI_VRC1; 2304 break; 2305 2306 case 76: 2307 2308 name = "NAMCOT 3446"; 2309 id = Type::NAMCOT_3446; 2310 break; 2311 2312 case 77: 2313 2314 name = "IREM 74*161/161/21/138"; 2315 id = Type::IREM_LROG017; 2316 break; 2317 2318 case 78: 2319 2320 if (submapper == 1) 2321 { 2322 name = "JALECO JF-16"; 2323 id = Type::JALECO_JF16; 2324 break; 2325 } 2326 2327 if (submapper == 3) 2328 { 2329 name = "IREM-HOLYDIVER"; 2330 id = Type::IREM_HOLYDIVER; 2331 break; 2332 } 2333 2334 name = "JALECO JF-16"; 2335 id = Type::JALECO_JF16; 2336 break; 2337 2338 case 79: 2339 2340 name = "AVE NINA-03 / NINA-06 / MB-91"; 2341 id = Type::AVE_NINA06; 2342 break; 2343 2344 case 80: 2345 2346 name = "TAITO X1-005 (a)"; 2347 id = Type::TAITO_X1005; 2348 break; 2349 2350 case 82: 2351 2352 name = "TAITO X1-017"; 2353 id = Type::TAITO_X1017; 2354 break; 2355 2356 case 83: 2357 2358 if (prg >= SIZE_1024K || chr >= SIZE_1024K) 2359 { 2360 name = "BMC DRAGONBALLPARTY 4-IN-1"; 2361 id = Type::BMC_DRAGONBOLLPARTY; 2362 } 2363 else 2364 { 2365 name = "CONY"; 2366 id = Type::CONY_STD; 2367 } 2368 break; 2369 2370 case 85: 2371 2372 name = "KONAMI VRC7"; 2373 2374 if (wram || useWramAuto) 2375 { 2376 wramAuto = useWramAuto; 2377 id = Type::KONAMI_VRC7_1; 2378 } 2379 else 2380 { 2381 id = Type::KONAMI_VRC7_0; 2382 } 2383 break; 2384 2385 case 86: 2386 2387 name = "JALECO JF-13"; 2388 id = Type::JALECO_JF13; 2389 break; 2390 2391 case 87: 2392 2393 name = "74*139/74"; 2394 id = Type::DISCRETE_74_139_74; 2395 break; 2396 2397 case 88: 2398 2399 if (nmt == Type::NMT_HORIZONTAL) 2400 { 2401 name = "NAMCOT 3433"; 2402 id = Type::NAMCOT_3433; 2403 } 2404 else 2405 { 2406 name = "NAMCOT 3443"; 2407 id = Type::NAMCOT_3443; 2408 } 2409 break; 2410 2411 case 89: 2412 2413 name = "SUNSOFT 2 (b)"; 2414 id = Type::SUNSOFT_2B; 2415 break; 2416 2417 case 90: 2418 2419 name = "J.Y.COMPANY (a)"; 2420 id = Type::JYCOMPANY_TYPE_A; 2421 break; 2422 2423 case 91: 2424 2425 name = "UNL MK2/SF3/SMKR"; 2426 id = Type::UNL_MORTALKOMBAT2; 2427 break; 2428 2429 case 92: 2430 2431 name = "JALECO JF-21"; 2432 id = Type::JALECO_JF21; 2433 break; 2434 2435 case 93: 2436 2437 name = "SUNSOFT 2 (a)"; 2438 id = Type::SUNSOFT_2A; 2439 break; 2440 2441 case 94: 2442 2443 name = "UN1ROM"; 2444 id = Type::STD_UN1ROM; 2445 break; 2446 2447 case 95: 2448 2449 name = "NAMCOT 3425"; 2450 id = Type::NAMCOT_3425; 2451 break; 2452 2453 case 96: 2454 2455 name = "BANDAI OEKAKIDS"; 2456 id = Type::BANDAI_OEKAKIDS; 2457 break; 2458 2459 case 97: 2460 2461 name = "IREM KAIKETSU"; 2462 id = Type::IREM_KAIKETSU; 2463 break; 2464 2465 case 99: 2466 2467 name = "VS.SYSTEM"; 2468 2469 if (wram || useWramAuto) 2470 { 2471 wramAuto = useWramAuto; 2472 id = Type::CUSTOM_VSSYSTEM_1; 2473 } 2474 else 2475 { 2476 id = Type::CUSTOM_VSSYSTEM_0; 2477 } 2478 break; 2479 2480 case 103: 2481 2482 name = "BTL 2708"; 2483 id = Type::BTL_2708; 2484 break; 2485 2486 case 104: 2487 2488 name = "BIC PEGASUS GOLDEN FIVE"; 2489 id = Type::CAMERICA_GOLDENFIVE; 2490 break; 2491 2492 case 105: 2493 2494 name = "EVENT"; 2495 id = Type::CUSTOM_EVENT; 2496 break; 2497 2498 case 106: 2499 2500 name = "BTL SMB3"; 2501 id = Type::BTL_SMB3; 2502 break; 2503 2504 case 107: 2505 2506 name = "MAGICSERIES"; 2507 id = Type::MAGICSERIES_MAGICDRAGON; 2508 break; 2509 2510 case 108: 2511 2512 name = "WHIRLWIND 2706"; 2513 id = Type::WHIRLWIND_2706; 2514 break; 2515 2516 case 112: 2517 2518 name = "NTDEC / ASDER"; 2519 2520 if (wram || useWramAuto) 2521 { 2522 wramAuto = useWramAuto; 2523 id = Type::NTDEC_ASDER_1; 2524 } 2525 else 2526 { 2527 id = Type::NTDEC_ASDER_0; 2528 } 2529 break; 2530 2531 case 113: 2532 2533 name = "HES"; 2534 id = Type::HES_STD; 2535 break; 2536 2537 case 114: 2538 2539 name = "SUPERGAME LIONKING"; 2540 id = Type::SUPERGAME_LIONKING; 2541 break; 2542 2543 case 115: 2544 2545 name = "KASING"; 2546 id = Type::KASING_STD; 2547 break; 2548 2549 case 116: 2550 2551 name = "SOMERITEAM SL-12"; 2552 id = Type::SOMERITEAM_SL12; 2553 break; 2554 2555 case 117: 2556 2557 name = "FUTUREMEDIA"; 2558 id = Type::FUTUREMEDIA_STD; 2559 break; 2560 2561 case 118: 2562 2563 if (wram || useWramAuto) 2564 { 2565 wramAuto = useWramAuto; 2566 name = "TKSROM"; 2567 id = Type::STD_TKSROM; 2568 } 2569 else 2570 { 2571 name = "TLSROM"; 2572 id = Type::STD_TLSROM; 2573 } 2574 break; 2575 2576 case 119: 2577 2578 name = "TQROM"; 2579 id = Type::STD_TQROM; 2580 break; 2581 2582 case 120: 2583 2584 name = "BTL TOBIDASE DAISAKUSEN"; 2585 id = Type::BTL_TOBIDASEDAISAKUSEN; 2586 break; 2587 2588 case 121: 2589 2590 name = "K PANDAPRINCE"; 2591 id = Type::KAY_PANDAPRINCE; 2592 break; 2593 2594 case 123: 2595 2596 name = "K H2288"; 2597 id = Type::KAY_H2288; 2598 break; 2599 2600 case 126: 2601 2602 name = "BMC POWERJOY 84-IN-1"; 2603 id = Type::BMC_POWERJOY_84IN1; 2604 break; 2605 2606 case 132: 2607 2608 name = "TXC 22211 (a)"; 2609 id = Type::TXC_22211A; 2610 break; 2611 2612 case 133: 2613 2614 name = "SACHEN SA72008"; 2615 id = Type::SACHEN_SA72008; 2616 break; 2617 2618 case 134: 2619 2620 name = "BMC FAMILY 4646B"; 2621 id = Type::BMC_FAMILY_4646B; 2622 break; 2623 2624 case 136: 2625 2626 name = "SACHEN TCU02"; 2627 id = Type::SACHEN_TCU02; 2628 break; 2629 2630 case 137: 2631 2632 name = "SACHEN 8259D"; 2633 id = Type::SACHEN_8259D; 2634 break; 2635 2636 case 138: 2637 2638 name = "SACHEN 8259B"; 2639 id = Type::SACHEN_8259B; 2640 break; 2641 2642 case 139: 2643 2644 name = "SACHEN 8259C"; 2645 id = Type::SACHEN_8259C; 2646 break; 2647 2648 case 140: 2649 2650 name = "JALECO JF-11/12/14"; 2651 id = Type::JALECO_JF14; 2652 break; 2653 2654 case 141: 2655 2656 name = "SACHEN 8259A"; 2657 id = Type::SACHEN_8259A; 2658 break; 2659 2660 case 142: 2661 2662 name = "KAISER KS-7032"; 2663 id = Type::KAISER_KS7032; 2664 break; 2665 2666 case 143: 2667 2668 name = "SACHEN TCA01"; 2669 id = Type::SACHEN_TCA01; 2670 break; 2671 2672 case 144: 2673 2674 name = "AGCI 50282"; 2675 id = Type::AGCI_50282; 2676 break; 2677 2678 case 145: 2679 2680 name = "SACHEN SA72007"; 2681 id = Type::SACHEN_SA72007; 2682 break; 2683 2684 case 146: 2685 2686 name = "SACHEN SA0161M"; 2687 id = Type::SACHEN_SA0161M; 2688 break; 2689 2690 case 147: 2691 2692 name = "SACHEN TCU01"; 2693 id = Type::SACHEN_TCU01; 2694 break; 2695 2696 case 148: 2697 2698 name = "AVE 74*161 / SACHEN SA0037"; 2699 id = Type::SACHEN_SA0037; 2700 break; 2701 2702 case 149: 2703 2704 name = "SACHEN SA0036"; 2705 id = Type::SACHEN_SA0036; 2706 break; 2707 2708 case 150: 2709 2710 name = "SACHEN 74*374 (b)"; 2711 id = Type::SACHEN_74_374B; 2712 break; 2713 2714 case 151: 2715 2716 name = "KONAMI VS.SYSTEM"; 2717 id = Type::KONAMI_VSSYSTEM; 2718 break; 2719 2720 case 152: 2721 2722 name = "74*161/161/32 (b)"; 2723 id = Type::DISCRETE_74_161_161_32_B; 2724 break; 2725 2726 case 154: 2727 2728 name = "NAMCOT 108/109/118"; 2729 id = Type::NAMCOT_34XX; 2730 break; 2731 2732 case 156: 2733 2734 name = "DAOU 306"; 2735 id = Type::OPENCORP_DAOU306; 2736 break; 2737 2738 case 157: 2739 2740 name = "BANDAI DATACH JOINT SYSTEM"; 2741 id = Type::BANDAI_DATACH; 2742 break; 2743 2744 case 158: 2745 2746 name = "TENGEN 800037"; 2747 id = Type::TENGEN_800037; 2748 break; 2749 2750 case 159: 2751 2752 name = "BANDAI LZ93D50 +24C01"; 2753 id = Type::BANDAI_LZ93D50_24C01; 2754 break; 2755 2756 case 163: 2757 2758 name = "NANJING"; 2759 id = Type::NANJING_STD; 2760 break; 2761 2762 case 164: 2763 2764 name = "WAIXING FFV"; 2765 2766 if (wram || useWramAuto) 2767 { 2768 wramAuto = useWramAuto; 2769 id = Type::WAIXING_FFV_1; 2770 } 2771 else 2772 { 2773 id = Type::WAIXING_FFV_0; 2774 } 2775 break; 2776 2777 case 165: 2778 2779 name = "WAIXING SH2"; 2780 2781 if (wram || useWramAuto) 2782 { 2783 wramAuto = useWramAuto; 2784 id = Type::WAIXING_SH2_1; 2785 } 2786 else 2787 { 2788 id = Type::WAIXING_SH2_0; 2789 } 2790 break; 2791 2792 case 166: 2793 2794 name = "SUBOR (b)"; 2795 id = Type::SUBOR_TYPE1; 2796 break; 2797 2798 case 167: 2799 2800 name = "SUBOR (a)"; 2801 id = Type::SUBOR_TYPE0; 2802 break; 2803 2804 case 170: 2805 2806 name = "FUJIYA NROM +SECURITY"; 2807 id = Type::FUJIYA_STD; 2808 break; 2809 2810 case 171: 2811 2812 name = "KAISER KS-7058"; 2813 id = Type::KAISER_KS7058; 2814 break; 2815 2816 case 172: 2817 2818 name = "IDEA-TEK 22211"; 2819 id = Type::TXC_22211B; 2820 break; 2821 2822 case 173: 2823 2824 name = "NEI-HU 22211"; 2825 id = Type::TXC_22211C; 2826 break; 2827 2828 case 175: 2829 2830 name = "KAISER KS-7022"; 2831 id = Type::KAISER_KS7022; 2832 break; 2833 2834 case 176: 2835 2836 name = "XIAO ZHUAN YUAN"; 2837 id = Type::UNL_XZY; 2838 break; 2839 2840 case 177: 2841 2842 name = "HENGGEDIANZI"; 2843 id = Type::HENGEDIANZI_STD; 2844 break; 2845 2846 case 178: 2847 2848 name = "WAIXING SAN GUO ZHONG LIE ZHUAN"; 2849 id = Type::WAIXING_SGZLZ; 2850 break; 2851 2852 case 179: 2853 2854 name = "HENGGEDIANZI XING HE ZHAN SHI"; 2855 id = Type::HENGEDIANZI_XJZB; 2856 break; 2857 2858 case 180: 2859 2860 if (!chr && !wram && (nmt == Type::NMT_HORIZONTAL || nmt == Type::NMT_VERTICAL) && prg == SIZE_128K) 2861 { 2862 name = "NIHON UNROM M5"; 2863 id = Type::NIHON_UNROM_M5; 2864 break; 2865 } 2866 2867 name = "UxROM-AND (non-standard)"; 2868 id = Type::UNL_UXROM_M5; 2869 break; 2870 2871 case 182: 2872 2873 name = "HOSENKAN ELECTRONICS"; 2874 id = Type::HOSENKAN_STD; 2875 break; 2876 2877 case 183: 2878 2879 name = "BTL SHUI GUAN PIPE"; 2880 id = Type::BTL_SHUIGUANPIPE; 2881 break; 2882 2883 case 184: 2884 2885 name = "SUNSOFT 1"; 2886 id = Type::SUNSOFT_1; 2887 break; 2888 2889 case 186: 2890 2891 name = "SBX"; 2892 id = Type::FUKUTAKE_SBX; 2893 break; 2894 2895 case 187: 2896 2897 name = "UNL SF3/KOF96"; 2898 id = Type::UNL_KINGOFFIGHTERS96; 2899 break; 2900 2901 case 188: 2902 2903 name = "BANDAI KARAOKESTUDIO"; 2904 id = Type::BANDAI_KARAOKESTUDIO; 2905 break; 2906 2907 case 189: 2908 2909 name = "YOKOSOFT / TXC"; 2910 id = Type::TXC_TW; 2911 break; 2912 2913 case 190: 2914 2915 name = "MAGICKIDGOOGOO"; 2916 id = Type::MAGICKIDGOOGOO; 2917 break; 2918 2919 case 191: 2920 2921 name = "WAIXING (b)"; 2922 id = Type::WAIXING_TYPE_B; 2923 break; 2924 2925 case 192: 2926 2927 name = "WAIXING (c)"; 2928 id = Type::WAIXING_TYPE_C; 2929 break; 2930 2931 case 193: 2932 2933 name = "NTDEC / MEGA SOFT"; 2934 id = Type::NTDEC_FIGHTINGHERO; 2935 break; 2936 2937 case 194: 2938 2939 name = "WAIXING (d)"; 2940 id = Type::WAIXING_TYPE_D; 2941 break; 2942 2943 case 195: 2944 2945 name = "WAIXING (e)"; 2946 id = Type::WAIXING_TYPE_E; 2947 break; 2948 2949 case 196: 2950 2951 name = "BTL SUPER BROS 11"; 2952 id = Type::BTL_SUPERBROS11; 2953 break; 2954 2955 case 197: 2956 2957 name = "HD-1047-A/AX5202P"; 2958 id = Type::UNL_SUPERFIGHTER3; 2959 break; 2960 2961 case 198: 2962 2963 name = "WAIXING (f)"; 2964 id = Type::WAIXING_TYPE_F; 2965 break; 2966 2967 case 199: 2968 2969 name = "WAIXING (g)"; 2970 id = Type::WAIXING_TYPE_G; 2971 break; 2972 2973 case 200: 2974 2975 name = "BMC 1200/36-IN-1"; 2976 id = Type::BMC_36IN1; 2977 break; 2978 2979 case 201: 2980 2981 name = "BMC 21/8-IN-1"; 2982 id = Type::BMC_21IN1; 2983 break; 2984 2985 case 202: 2986 2987 name = "BMC 150-IN-1"; 2988 id = Type::BMC_150IN1; 2989 break; 2990 2991 case 203: 2992 2993 name = "BMC 35-IN-1"; 2994 id = Type::BMC_35IN1; 2995 break; 2996 2997 case 204: 2998 2999 name = "BMC 64-IN-1"; 3000 id = Type::BMC_64IN1; 3001 break; 3002 3003 case 205: 3004 3005 name = "BMC 15/3-IN-1"; 3006 id = Type::BMC_15IN1; 3007 break; 3008 3009 case 206: 3010 3011 if (nmt == Type::NMT_FOURSCREEN) 3012 { 3013 name = "DRROM"; 3014 id = Type::STD_DRROM; 3015 } 3016 else if (prg >= SIZE_128K) 3017 { 3018 name = "DE1ROM / NAMCOT 34xx"; 3019 id = Type::STD_DE1ROM; 3020 } 3021 else 3022 { 3023 name = "DEROM / TENGEN MIMIC-1 / NAMCOT 34xx"; 3024 id = Type::STD_DEROM; 3025 } 3026 break; 3027 3028 case 207: 3029 { 3030 Chips::Type& chip = chips.Add(L"X1-005"); 3031 3032 chip.Pin(17) = L"CIRAM A10"; 3033 chip.Pin(31) = L"NC"; 3034 3035 name = "TAITO X1-005 (b)"; 3036 id = Type::TAITO_X1005; 3037 break; 3038 } 3039 3040 case 208: 3041 3042 name = "GOUDER 37017"; 3043 id = Type::GOUDER_37017; 3044 break; 3045 3046 case 209: 3047 3048 name = "J.Y.COMPANY (b)"; 3049 id = Type::JYCOMPANY_TYPE_B; 3050 break; 3051 3052 case 210: 3053 3054 if (submapper == 1) 3055 { 3056 name = "NAMCOT-175"; 3057 id = Type::NAMCOT_175; 3058 break; 3059 } 3060 3061 if (submapper == 2) 3062 { 3063 name = "NAMCOT-340"; 3064 id = Type::NAMCOT_340; 3065 break; 3066 } 3067 3068 if (!this->chips.Has(L"175")) 3069 { 3070 name = "NAMCOT-340"; 3071 id = Type::NAMCOT_340; 3072 } 3073 else 3074 { 3075 name = "NAMCOT-175"; 3076 id = Type::NAMCOT_175; 3077 } 3078 break; 3079 3080 case 211: 3081 3082 name = "J.Y.COMPANY (c)"; 3083 id = Type::JYCOMPANY_TYPE_C; 3084 break; 3085 3086 case 212: 3087 3088 name = "BMC SUPERHIK 300-IN-1"; 3089 id = Type::BMC_SUPERHIK_300IN1; 3090 break; 3091 3092 case 213: 3093 3094 name = "BMC 9999999-IN-1"; 3095 id = Type::BMC_9999999IN1; 3096 break; 3097 3098 case 214: 3099 3100 name = "BMC SUPERGUN 20-IN-1"; 3101 id = Type::BMC_SUPERGUN_20IN1; 3102 break; 3103 3104 case 215: 3105 3106 if (prg == SIZE_256K && chr == SIZE_512K) 3107 { 3108 name = "SUPERGAME MK3E"; 3109 id = Type::SUPERGAME_MK3E; 3110 } 3111 else 3112 { 3113 name = "SUPERGAME BOOGERMAN"; 3114 id = Type::SUPERGAME_BOOGERMAN; 3115 } 3116 break; 3117 3118 case 216: 3119 3120 name = "RCM GS-2015"; 3121 id = Type::RCM_GS2015; 3122 break; 3123 3124 case 217: 3125 3126 name = "BMC SPC009"; 3127 id = Type::BMC_GOLDENCARD_6IN1; 3128 break; 3129 3130 case 219: 3131 3132 name = "UNL A9746"; 3133 id = Type::UNL_A9746; 3134 break; 3135 3136 case 221: 3137 3138 name = "UNL N625092"; 3139 id = Type::UNL_N625092; 3140 break; 3141 3142 case 222: 3143 3144 name = "BTL DRAGON NINJA"; 3145 id = Type::BTL_DRAGONNINJA; 3146 break; 3147 3148 case 223: 3149 3150 name = "WAIXING TANG MU LI XIAN JI"; 3151 id = Type::WAIXING_TYPE_I; 3152 break; 3153 3154 case 224: 3155 3156 name = "WAIXING YING XIONG CHUAN QI"; 3157 id = Type::WAIXING_TYPE_J; 3158 break; 3159 3160 case 225: 3161 3162 name = "BMC 58/64/72-IN-1"; 3163 id = Type::BMC_72IN1; 3164 break; 3165 3166 case 226: 3167 3168 if (prg == SIZE_1024K) 3169 { 3170 name = "BMC SUPER 42-IN-1"; 3171 id = Type::BMC_SUPER_42IN1; 3172 } 3173 else 3174 { 3175 name = "BMC 76-IN-1"; 3176 id = Type::BMC_76IN1; 3177 } 3178 break; 3179 3180 case 227: 3181 3182 name = "BMC 1200-IN-1"; 3183 id = Type::BMC_1200IN1; 3184 break; 3185 3186 case 228: 3187 3188 name = "ACTIVE ENTERTAINMENT"; 3189 id = Type::AE_STD; 3190 break; 3191 3192 case 229: 3193 3194 name = "BMC 31-IN-1"; 3195 id = Type::BMC_31IN1; 3196 break; 3197 3198 case 230: 3199 3200 name = "BMC SUPER 22 GAMES / 20-IN-1"; 3201 id = Type::BMC_22GAMES; 3202 break; 3203 3204 case 231: 3205 3206 name = "BMC 20-IN-1"; 3207 id = Type::BMC_20IN1; 3208 break; 3209 3210 case 232: 3211 3212 name = "CAMERICA BF9096"; 3213 id = Type::CAMERICA_BF9096; 3214 break; 3215 3216 case 233: 3217 3218 name = "BMC SUPER 22 GAMES"; 3219 id = Type::BMC_SUPER_22GAMES; 3220 break; 3221 3222 case 234: 3223 3224 name = "AVE D-1012"; 3225 id = Type::AVE_D1012; 3226 break; 3227 3228 case 235: 3229 3230 if (prg <= SIZE_2048K) 3231 { 3232 name = "GOLDENGAME 150-IN-1"; 3233 id = Type::BMC_GOLDENGAME_150IN1; 3234 } 3235 else 3236 { 3237 name = "GOLDENGAME 260-IN-1"; 3238 id = Type::BMC_GOLDENGAME_260IN1; 3239 } 3240 break; 3241 3242 case 236: 3243 3244 name = "BMC 70/800-IN-1"; 3245 id = Type::BMC_GAME_800IN1; 3246 break; 3247 3248 case 240: 3249 3250 name = "CNE SHLZ"; 3251 id = Type::CNE_SHLZ; 3252 break; 3253 3254 case 241: 3255 3256 name = "MXMDHTWO / TXC"; 3257 id = Type::TXC_MXMDHTWO; 3258 break; 3259 3260 case 242: 3261 3262 if (nmt == Type::NMT_CONTROLLED) 3263 { 3264 name = "WAIXING ZS"; 3265 id = Type::WAIXING_ZS; 3266 } 3267 else 3268 { 3269 name = "WAIXING DQVII"; 3270 id = Type::WAIXING_DQVII; 3271 } 3272 break; 3273 3274 case 243: 3275 3276 name = "SACHEN 74*374 (a)"; 3277 id = Type::SACHEN_74_374A; 3278 break; 3279 3280 case 244: 3281 3282 name = "CNE DECATHLON"; 3283 id = Type::CNE_DECATHLON; 3284 break; 3285 3286 case 245: 3287 3288 name = "WAIXING (h)"; 3289 id = Type::WAIXING_TYPE_H; 3290 break; 3291 3292 case 246: 3293 3294 name = "CNE PHONE SERM BERM"; 3295 id = Type::CNE_PSB; 3296 break; 3297 3298 case 249: 3299 3300 name = "WAIXING +SECURITY"; 3301 3302 if (wram || useWramAuto) 3303 { 3304 wramAuto = useWramAuto; 3305 id = Type::WAIXING_SECURITY_1; 3306 } 3307 else 3308 { 3309 id = Type::WAIXING_SECURITY_0; 3310 } 3311 break; 3312 3313 case 250: 3314 3315 name = "NITRA"; 3316 id = Type::NITRA_TDA; 3317 break; 3318 3319 case 252: 3320 3321 name = "WAIXING SAN GUO ZHI"; 3322 id = Type::WAIXING_SGZ; 3323 break; 3324 3325 case 254: 3326 3327 name = "BTL PIKACHU Y2K"; 3328 id = Type::BTL_PIKACHUY2K; 3329 break; 3330 3331 case 255: 3332 3333 name = "BMC 110/115-IN-1"; 3334 id = Type::BMC_110IN1; 3335 break; 3336 3337 default: 3338 3339 return false; 3340 } 3341 3342 type = Type( id, this->prg, this->chr, nmt, wramBattery || mmcBattery, wramAuto ); 3343 3344 return true; 3345 } 3346 Create(const Context & c)3347 Board* Board::Create(const Context& c) 3348 { 3349 switch (c.type.GetId()) 3350 { 3351 case Type::STD_NROM : 3352 case Type::UNL_NROM : return new NRom(c); 3353 case Type::STD_AMROM : 3354 case Type::STD_ANROM : 3355 case Type::STD_AN1ROM : 3356 case Type::STD_AOROM : 3357 case Type::UNL_AXROM : return new AxRom(c); 3358 case Type::STD_BNROM : 3359 case Type::UNL_BXROM : return new BxRom(c); 3360 case Type::STD_CNROM : 3361 case Type::STD_CXROM : 3362 case Type::UNL_CXROM : return new CnRom(c); 3363 case Type::STD_CPROM : return new CpRom(c); 3364 case Type::STD_DEROM : 3365 case Type::STD_DE1ROM : 3366 case Type::STD_DRROM : return new DxRom(c); 3367 case Type::STD_EKROM : 3368 case Type::STD_ELROM : 3369 case Type::STD_ETROM : 3370 case Type::STD_EWROM : 3371 case Type::STD_EXROM_0 : 3372 case Type::STD_EXROM_1 : 3373 case Type::STD_EXROM_2 : 3374 case Type::STD_EXROM_3 : 3375 case Type::STD_EXROM_4 : 3376 case Type::STD_EXROM_5 : return new ExRom(c); 3377 case Type::STD_FJROM : 3378 case Type::STD_FKROM : return new FxRom(c); 3379 case Type::STD_GNROM : 3380 case Type::UNL_GXROM : return new GxRom(c); 3381 case Type::STD_MHROM : return new MxRom(c); 3382 case Type::STD_HKROM : return new HxRom(c); 3383 case Type::STD_JLROM : 3384 case Type::STD_JSROM : return new JxRom(c); 3385 case Type::STD_NTBROM : return new NxRom(c); 3386 case Type::STD_PEEOROM : 3387 case Type::STD_PNROM : 3388 case Type::STD_PNROM_PC10 : return new PxRom(c); 3389 case Type::STD_SAROM : 3390 case Type::STD_SBROM : 3391 case Type::STD_SCROM : 3392 case Type::STD_SEROM : 3393 case Type::STD_SFROM : 3394 case Type::STD_SGROM : 3395 case Type::STD_SHROM : 3396 case Type::STD_SJROM : 3397 case Type::STD_SKROM : 3398 case Type::STD_SLROM : 3399 case Type::STD_SNROM : 3400 case Type::STD_SOROM : 3401 case Type::STD_SUROM : 3402 case Type::STD_SXROM : return new SxRom(c); 3403 case Type::STD_TBROM : 3404 case Type::STD_TEROM : 3405 case Type::STD_TFROM : 3406 case Type::STD_TGROM : 3407 case Type::STD_TKROM : 3408 case Type::STD_TLROM : 3409 case Type::STD_TNROM : 3410 case Type::STD_TR1ROM : 3411 case Type::STD_TSROM : 3412 case Type::STD_TVROM : 3413 case Type::UNL_MMC3BIGCHRRAM : 3414 case Type::UNL_TRXROM : return new TxRom (c); 3415 case Type::STD_TLSROM : return new TlsRom (c); 3416 case Type::STD_TKSROM : return new TksRom (c); 3417 case Type::STD_TQROM : return new TqRom (c); 3418 case Type::STD_UNROM : 3419 case Type::STD_UN1ROM : 3420 case Type::STD_UOROM : 3421 case Type::STD_UXROM : 3422 case Type::STD_UNROM512 : 3423 case Type::UNL_UXROM : return new UxRom(c); 3424 case Type::DISCRETE_74_377 : return new Discrete::Ic74x377(c); 3425 case Type::DISCRETE_74_139_74 : return new Discrete::Ic74x139x74(c); 3426 case Type::DISCRETE_74_161_138 : return new Discrete::Ic74x161x138(c); 3427 case Type::DISCRETE_74_161_161_32_A : 3428 case Type::DISCRETE_74_161_161_32_B : return new Discrete::Ic74x161x161x32(c); 3429 case Type::CUSTOM_B4 : return new TxRom(c); 3430 case Type::CUSTOM_BTR : return new JxRom(c); 3431 case Type::CUSTOM_EVENT : return new Boards::Event(c); 3432 case Type::CUSTOM_FFE3 : 3433 case Type::CUSTOM_FFE4 : 3434 case Type::CUSTOM_FFE8 : return new Ffe(c); 3435 case Type::CUSTOM_FB02 : 3436 case Type::CUSTOM_FB04 : return new Fb(c); 3437 case Type::CUSTOM_RUMBLESTATION : return new RumbleStation(c); 3438 case Type::CUSTOM_QJ : return new Qj(c); 3439 case Type::CUSTOM_VSSYSTEM_0 : 3440 case Type::CUSTOM_VSSYSTEM_1 : return new VsSystem(c); 3441 case Type::CUSTOM_WH : return new SxRom(c); 3442 case Type::CUSTOM_X79B : return new CnRom(c); 3443 case Type::CUSTOM_ZZ : return new Zz(c); 3444 case Type::ACCLAIM_MCACC : return new Acclaim::McAcc(c); 3445 case Type::ACTION53 : return new Action53(c); 3446 case Type::AE_STD : return new Ae::Standard(c); 3447 case Type::AGCI_50282 : return new Agci::A50282(c); 3448 case Type::AVE_MB_91 : return new Ave::Mb91(c); 3449 case Type::AVE_NINA001 : return new Ave::Nina001(c); 3450 case Type::AVE_NINA002 : return new Ave::Nina002(c); 3451 case Type::AVE_NINA03 : return new Ave::Nina03(c); 3452 case Type::AVE_NINA06 : return new Ave::Nina06(c); 3453 case Type::AVE_NINA07 : return new Ave::Nina07(c); 3454 case Type::AVE_D1012 : return new Ave::D1012(c); 3455 case Type::BANDAI_FCG1 : return new Bandai::Fcg1(c); 3456 case Type::BANDAI_FCG2 : return new Bandai::Fcg2(c); 3457 case Type::BANDAI_BAJUMP2 : return new Bandai::Lz93d50(c); 3458 case Type::BANDAI_LZ93D50_24C01 : 3459 case Type::BANDAI_LZ93D50_24C02 : return new Bandai::Lz93d50Ex(c); 3460 case Type::BANDAI_DATACH : return new Bandai::Datach(c); 3461 case Type::BANDAI_KARAOKESTUDIO : return new Bandai::KaraokeStudio(c); 3462 case Type::BANDAI_AEROBICSSTUDIO : return new Bandai::AerobicsStudio(c); 3463 case Type::BANDAI_OEKAKIDS : return new Bandai::OekaKids(c); 3464 case Type::BMC_BALLGAMES_11IN1 : return new Bmc::Ballgames11in1(c); 3465 case Type::BMC_A65AS : return new Bmc::A65as(c); 3466 case Type::BMC_CTC65 : return new Bmc::Ctc65(c); 3467 case Type::BMC_DRAGONBOLLPARTY : return new Cony::Standard(c); 3468 case Type::BMC_110IN1 : return new Bmc::B110in1(c); 3469 case Type::BMC_1200IN1 : return new Bmc::B1200in1(c); 3470 case Type::BMC_150IN1 : return new Bmc::B150in1(c); 3471 case Type::BMC_15IN1 : return new Bmc::B15in1(c); 3472 case Type::BMC_20IN1 : return new Bmc::B20in1(c); 3473 case Type::BMC_21IN1 : return new Bmc::B21in1(c); 3474 case Type::BMC_22GAMES : return new Bmc::B22Games(c); 3475 case Type::BMC_31IN1 : return new Bmc::B31in1(c); 3476 case Type::BMC_35IN1 : return new Bmc::B35in1(c); 3477 case Type::BMC_36IN1 : return new Bmc::B36in1(c); 3478 case Type::BMC_64IN1 : return new Bmc::B64in1(c); 3479 case Type::BMC_72IN1 : return new Bmc::B72in1(c); 3480 case Type::BMC_76IN1 : 3481 case Type::BMC_SUPER_42IN1 : return new Bmc::B76in1(c); 3482 case Type::BMC_8157 : return new Bmc::B8157(c); 3483 case Type::BMC_9999999IN1 : return new Bmc::B9999999in1(c); 3484 case Type::BMC_FAMILY_4646B : return new Bmc::Family4646B(c); 3485 case Type::BMC_FKC23C : return new Bmc::Fk23c(c); 3486 case Type::BMC_GAME_800IN1 : return new Bmc::Game800in1(c); 3487 case Type::BMC_GOLDEN_190IN1 : return new Bmc::Golden190in1(c); 3488 case Type::BMC_GOLDENGAME_150IN1 : 3489 case Type::BMC_GOLDENGAME_260IN1 : return new Bmc::GoldenGame260in1(c); 3490 case Type::BMC_GOLDENCARD_6IN1 : return new Bmc::GoldenCard6in1(c); 3491 case Type::BMC_GKA : return new Bmc::GamestarA(c); 3492 case Type::BMC_GKB : return new Bmc::GamestarB(c); 3493 case Type::BMC_HERO : return new Bmc::Hero(c); 3494 case Type::BMC_MARIOPARTY_7IN1 : return new Bmc::MarioParty7in1(c); 3495 case Type::BMC_NOVELDIAMOND : return new Bmc::NovelDiamond(c); 3496 case Type::BMC_CH001 : return new Bmc::Ch001(c); 3497 case Type::BMC_POWERJOY_84IN1 : return new Bmc::Powerjoy84in1(c); 3498 case Type::BMC_RESETBASED_4IN1 : return new Bmc::ResetBased4in1(c); 3499 case Type::BMC_VT5201 : return new Bmc::Vt5201(c); 3500 case Type::BMC_SUPER_24IN1 : return new Bmc::Super24in1(c); 3501 case Type::BMC_SUPER_22GAMES : return new Bmc::Super22Games(c); 3502 case Type::BMC_SUPER_40IN1 : return new Bmc::Super40in1(c); 3503 case Type::BMC_SUPER_700IN1 : return new Bmc::Super700in1(c); 3504 case Type::BMC_SUPERBIG_7IN1 : return new Bmc::SuperBig7in1(c); 3505 case Type::BMC_SUPERGUN_20IN1 : return new Bmc::SuperGun20in1(c); 3506 case Type::BMC_SUPERHIK_4IN1 : return new Bmc::SuperHiK4in1(c); 3507 case Type::BMC_SUPERHIK_300IN1 : return new Bmc::SuperHiK300in1(c); 3508 case Type::BMC_SUPERVISION_16IN1 : return new Bmc::SuperVision16in1(c); 3509 case Type::BMC_T262 : return new Bmc::T262(c); 3510 case Type::BMC_VRC4 : return new Bmc::Vrc4(c); 3511 case Type::BMC_Y2K_64IN1 : return new Bmc::Y2k64in1(c); 3512 case Type::BTL_AISENSHINICOL : 3513 case Type::BTL_MARIOBABY : return new Btl::MarioBaby(c); 3514 case Type::BTL_2708 : return new Btl::B2708(c); 3515 case Type::BTL_AX5705 : return new Btl::Ax5705(c); 3516 case Type::BTL_6035052 : return new Btl::B6035052(c); 3517 case Type::BTL_DRAGONNINJA : return new Btl::DragonNinja(c); 3518 case Type::BTL_GENIUSMERIOBROS : return new Btl::GeniusMerioBros(c); 3519 case Type::BTL_SHUIGUANPIPE : return new Btl::ShuiGuanPipe(c); 3520 case Type::BTL_PIKACHUY2K : return new Btl::PikachuY2k(c); 3521 case Type::BTL_SMB2_A : return new Btl::Smb2a(c); 3522 case Type::BTL_SMB2_B : return new Btl::Smb2b(c); 3523 case Type::BTL_SMB2_C : return new Btl::Smb2c(c); 3524 case Type::BTL_SMB3 : return new Btl::Smb3(c); 3525 case Type::BTL_SUPERBROS11 : return new Btl::SuperBros11(c); 3526 case Type::BTL_T230 : return new Btl::T230(c); 3527 case Type::BTL_TOBIDASEDAISAKUSEN : return new Btl::TobidaseDaisakusen(c); 3528 case Type::CAMERICA_BF9093 : return new Camerica::Bf9093(c); 3529 case Type::CAMERICA_BF9096 : return new Camerica::Bf9096(c); 3530 case Type::CAMERICA_BF9097 : 3531 case Type::CAMERICA_BF909X : return new Camerica::Bf9097(c); 3532 case Type::CAMERICA_ALGNV11 : return new Camerica::Algnv11(c); 3533 case Type::CAMERICA_ALGQV11 : return new Camerica::Algqv11(c); 3534 case Type::CAMERICA_GOLDENFIVE : return new Camerica::GoldenFive(c); 3535 case Type::CALTRON_6IN1 : return new Caltron::Mc6in1(c); 3536 case Type::CNE_SHLZ : return new Cne::Shlz(c); 3537 case Type::CNE_DECATHLON : return new Cne::Decathlon(c); 3538 case Type::CNE_PSB : return new Cne::Psb(c); 3539 case Type::CONY_STD : return new Cony::Standard(c); 3540 case Type::DREAMTECH_01 : return new DreamTech::D01(c); 3541 case Type::FUTUREMEDIA_STD : return new FutureMedia::Standard(c); 3542 case Type::FUJIYA_STD : return new Fujiya::Standard(c); 3543 case Type::FUKUTAKE_SBX : return new Fukutake::Sbx(c); 3544 case Type::GOUDER_37017 : return new Gouder::G37017(c); 3545 case Type::HES_STD : return new Hes::Standard(c); 3546 case Type::BENSHENG_BS5 : return new Bensheng::Bs5(c); 3547 case Type::HENGEDIANZI_STD : return new Hengedianzi::Standard(c); 3548 case Type::HENGEDIANZI_XJZB : return new Hengedianzi::Xjzb(c); 3549 case Type::HOSENKAN_STD : return new Hosenkan::Standard(c); 3550 case Type::INLNSF : return new InlNsf(c); 3551 case Type::IREM_G101A_0 : 3552 case Type::IREM_G101A_1 : 3553 case Type::IREM_G101B_0 : 3554 case Type::IREM_G101B_1 : return new Irem::G101(c); 3555 case Type::IREM_H3001 : return new Irem::H3001(c); 3556 case Type::IREM_LROG017 : return new Irem::Lrog017(c); 3557 case Type::IREM_HOLYDIVER : return new Irem::HolyDiver(c); 3558 case Type::IREM_KAIKETSU : return new Irem::Kaiketsu(c); 3559 case Type::JALECO_JF01 : return new Jaleco::Jf01(c); 3560 case Type::JALECO_JF02 : return new Jaleco::Jf02(c); 3561 case Type::JALECO_JF03 : return new Jaleco::Jf03(c); 3562 case Type::JALECO_JF04 : return new Jaleco::Jf04(c); 3563 case Type::JALECO_JF05 : return new Jaleco::Jf05(c); 3564 case Type::JALECO_JF06 : return new Jaleco::Jf06(c); 3565 case Type::JALECO_JF07 : return new Jaleco::Jf07(c); 3566 case Type::JALECO_JF08 : return new Jaleco::Jf08(c); 3567 case Type::JALECO_JF09 : return new Jaleco::Jf09(c); 3568 case Type::JALECO_JF10 : return new Jaleco::Jf10(c); 3569 case Type::JALECO_JF11 : return new Jaleco::Jf11(c); 3570 case Type::JALECO_JF12 : return new Jaleco::Jf12(c); 3571 case Type::JALECO_JF13 : return new Jaleco::Jf13(c); 3572 case Type::JALECO_JF14 : return new Jaleco::Jf14(c); 3573 case Type::JALECO_JF15 : return new Jaleco::Jf15(c); 3574 case Type::JALECO_JF16 : return new Jaleco::Jf16(c); 3575 case Type::JALECO_JF17 : return new Jaleco::Jf17(c); 3576 case Type::JALECO_JF18 : return new Jaleco::Jf18(c); 3577 case Type::JALECO_JF19 : return new Jaleco::Jf19(c); 3578 case Type::JALECO_JF20 : return new Jaleco::Jf20(c); 3579 case Type::JALECO_JF21 : return new Jaleco::Jf21(c); 3580 case Type::JALECO_JF22 : return new Jaleco::Jf22(c); 3581 case Type::JALECO_JF23 : return new Jaleco::Jf23(c); 3582 case Type::JALECO_JF24 : return new Jaleco::Jf24(c); 3583 case Type::JALECO_JF25 : return new Jaleco::Jf25(c); 3584 case Type::JALECO_JF26 : return new Jaleco::Jf26(c); 3585 case Type::JALECO_JF27 : return new Jaleco::Jf27(c); 3586 case Type::JALECO_JF28 : return new Jaleco::Jf28(c); 3587 case Type::JALECO_JF29 : return new Jaleco::Jf29(c); 3588 case Type::JALECO_JF30 : return new Jaleco::Jf30(c); 3589 case Type::JALECO_JF31 : return new Jaleco::Jf31(c); 3590 case Type::JALECO_JF32 : return new Jaleco::Jf32(c); 3591 case Type::JALECO_JF33 : return new Jaleco::Jf33(c); 3592 case Type::JALECO_JF34 : return new Jaleco::Jf34(c); 3593 case Type::JALECO_JF35 : return new Jaleco::Jf35(c); 3594 case Type::JALECO_JF36 : return new Jaleco::Jf36(c); 3595 case Type::JALECO_JF37 : return new Jaleco::Jf37(c); 3596 case Type::JALECO_JF38 : return new Jaleco::Jf38(c); 3597 case Type::JALECO_JF39 : return new Jaleco::Jf39(c); 3598 case Type::JALECO_JF40 : return new Jaleco::Jf40(c); 3599 case Type::JALECO_JF41 : return new Jaleco::Jf41(c); 3600 case Type::JALECO_SS88006 : return new Jaleco::Ss88006(c); 3601 case Type::JYCOMPANY_TYPE_A : 3602 case Type::JYCOMPANY_TYPE_B : 3603 case Type::JYCOMPANY_TYPE_C : return new JyCompany::Standard(c); 3604 case Type::KAISER_KS202 : return new Kaiser::Ks202(c); 3605 case Type::KAISER_KS7022 : return new Kaiser::Ks7022(c); 3606 case Type::KAISER_KS7031 : return new Kaiser::Ks7031(c); 3607 case Type::KAISER_KS7032 : return new Kaiser::Ks7032(c); 3608 case Type::KAISER_KS7058 : return new Kaiser::Ks7058(c); 3609 case Type::KASING_STD : return new Kasing::Standard(c); 3610 case Type::KAY_H2288 : return new Kay::H2288(c); 3611 case Type::KAY_PANDAPRINCE : return new Kay::PandaPrince(c); 3612 case Type::KONAMI_VRC1 : return new Konami::Vrc1(c); 3613 case Type::KONAMI_VRC2 : return new Konami::Vrc2(c); 3614 case Type::KONAMI_VRC3 : return new Konami::Vrc3(c); 3615 case Type::KONAMI_VRC4_0 : 3616 case Type::KONAMI_VRC4_1 : 3617 case Type::KONAMI_VRC4_2 : return new Konami::Vrc4(c); 3618 case Type::KONAMI_VRC6_0 : 3619 case Type::KONAMI_VRC6_1 : return new Konami::Vrc6(c); 3620 case Type::KONAMI_VRC7_0 : 3621 case Type::KONAMI_VRC7_1 : return new Konami::Vrc7(c); 3622 case Type::KONAMI_VSSYSTEM : return new Konami::VsSystem(c); 3623 case Type::MAGICKIDGOOGOO : return new MagicKidGoogoo(c); 3624 case Type::MAGICSERIES_MAGICDRAGON : return new MagicSeries::MagicDragon(c); 3625 case Type::NAMCOT_3425 : return new Namcot::N3425(c); 3626 case Type::NAMCOT_3433 : return new Namcot::N3433(c); 3627 case Type::NAMCOT_3443 : return new Namcot::N3443(c); 3628 case Type::NAMCOT_3446 : return new Namcot::N3446(c); 3629 case Type::NAMCOT_34XX : return new Namcot::N34xx(c); 3630 case Type::NAMCOT_163_0 : 3631 case Type::NAMCOT_163_1 : 3632 case Type::NAMCOT_163_S_0 : 3633 case Type::NAMCOT_163_S_1 : return new Namcot::N163(c); 3634 case Type::NAMCOT_340 : 3635 case Type::NAMCOT_175 : return new Namcot::N175(c); 3636 case Type::NANJING_STD : return new Nanjing::Standard(c); 3637 case Type::UNL_UXROM_M5 : 3638 case Type::NIHON_UNROM_M5 : return new Nihon::UnRomM5(c); 3639 case Type::NITRA_TDA : return new Nitra::Tda(c); 3640 case Type::NTDEC_N715062 : return new Ntdec::N715062(c); 3641 case Type::NTDEC_ASDER_0 : 3642 case Type::NTDEC_ASDER_1 : return new Ntdec::Asder(c); 3643 case Type::NTDEC_FIGHTINGHERO : return new Ntdec::FightingHero(c); 3644 case Type::OPENCORP_DAOU306 : return new OpenCorp::Daou306(c); 3645 case Type::REXSOFT_SL1632 : return new RexSoft::Sl1632(c); 3646 case Type::REXSOFT_DBZ5 : return new RexSoft::Dbz5(c); 3647 case Type::RCM_GS2013 : return new Rcm::Gs2013(c); 3648 case Type::RCM_GS2015 : return new Rcm::Gs2015(c); 3649 case Type::RCM_GS2004 : return new Rcm::Gs2004(c); 3650 case Type::RCM_TETRISFAMILY : return new Rcm::TetrisFamily(c); 3651 case Type::SACHEN_8259A : 3652 case Type::SACHEN_8259B : 3653 case Type::SACHEN_8259C : 3654 case Type::SACHEN_8259D : return new Sachen::S8259(c); 3655 case Type::SACHEN_TCA01 : return new Sachen::Tca01(c); 3656 case Type::SACHEN_TCU01 : return new Sachen::Tcu01(c); 3657 case Type::SACHEN_TCU02 : return new Sachen::Tcu02(c); 3658 case Type::SACHEN_SA0036 : return new Sachen::Sa0036(c); 3659 case Type::SACHEN_SA0037 : return new Sachen::Sa0037(c); 3660 case Type::SACHEN_SA0161M : return new Sachen::Sa0161m(c); 3661 case Type::SACHEN_SA72007 : return new Sachen::Sa72007(c); 3662 case Type::SACHEN_SA72008 : return new Sachen::Sa72008(c); 3663 case Type::SACHEN_74_374A : return new Sachen::S74x374a(c); 3664 case Type::SACHEN_74_374B : return new Sachen::S74x374b(c); 3665 case Type::SACHEN_STREETHEROES : return new Sachen::StreetHeroes(c); 3666 case Type::SOMERITEAM_SL12 : return new SomeriTeam::Sl12(c); 3667 case Type::SUBOR_TYPE0 : return new Subor::Type0(c); 3668 case Type::SUBOR_TYPE1 : return new Subor::Type1(c); 3669 case Type::SUBOR_STUDYNGAME : return new Subor::StudyNGame(c); 3670 case Type::SUNSOFT_1 : return new Sunsoft::S1(c); 3671 case Type::SUNSOFT_2A : return new Sunsoft::S2a(c); 3672 case Type::SUNSOFT_2B : return new Sunsoft::S2b(c); 3673 case Type::SUNSOFT_3 : return new Sunsoft::S3(c); 3674 case Type::SUNSOFT_4_0 : 3675 case Type::SUNSOFT_4_1 : return new Sunsoft::S4(c); 3676 case Type::SUNSOFT_5B_0 : 3677 case Type::SUNSOFT_5B_1 : return new Sunsoft::S5b(c); 3678 case Type::SUNSOFT_DCS : return new Sunsoft::Dcs(c); 3679 case Type::SUNSOFT_FME7_0 : 3680 case Type::SUNSOFT_FME7_1 : return new Sunsoft::Fme7(c); 3681 case Type::SUPERGAME_LIONKING : return new SuperGame::LionKing(c); 3682 case Type::SUPERGAME_BOOGERMAN : return new SuperGame::Boogerman(c); 3683 case Type::SUPERGAME_MK3E : return new SuperGame::Mk3e(c); 3684 case Type::SUPERGAME_POCAHONTAS2 : return new SuperGame::Pocahontas2(c); 3685 case Type::TAITO_TC0190FMC : return new Taito::Tc0190fmc(c); 3686 case Type::TAITO_TC0190FMC_PAL16R4 : return new Taito::Tc0190fmcPal16r4(c); 3687 case Type::TAITO_X1005 : return new Taito::X1005(c); 3688 case Type::TAITO_X1017 : return new Taito::X1017(c); 3689 case Type::TENGEN_800002 : return new Tengen::T800002(c); 3690 case Type::TENGEN_800004 : return new Tengen::T800004(c); 3691 case Type::TENGEN_800008 : return new Tengen::T800008(c); 3692 case Type::TENGEN_800030 : return new Tengen::T800030(c); 3693 case Type::TENGEN_800032 : return new Tengen::T800032(c); 3694 case Type::TENGEN_800037 : return new Tengen::T800037(c); 3695 case Type::TENGEN_800042 : return new Tengen::T800042(c); 3696 case Type::TXC_22211A : return new Txc::T22211A(c); 3697 case Type::TXC_22211B : return new Txc::T22211B(c); 3698 case Type::TXC_22211C : return new Txc::T22211C(c); 3699 case Type::TXC_MXMDHTWO : return new Txc::Mxmdhtwo(c); 3700 case Type::TXC_POLICEMAN : return new Txc::Policeman(c); 3701 case Type::TXC_TW : return new Txc::Tw(c); 3702 case Type::UNL_A9746 : return new Unlicensed::A9746(c); 3703 case Type::UNL_CC21 : return new Unlicensed::Cc21(c); 3704 case Type::UNL_EDU2000 : return new Unlicensed::Edu2000(c); 3705 case Type::UNL_KINGOFFIGHTERS96 : return new Unlicensed::KingOfFighters96(c); 3706 case Type::UNL_KINGOFFIGHTERS97 : return new Unlicensed::KingOfFighters97(c); 3707 case Type::UNL_MORTALKOMBAT2 : return new Unlicensed::MortalKombat2(c); 3708 case Type::UNL_N625092 : return new Unlicensed::N625092(c); 3709 case Type::UNL_SUPERFIGHTER3 : return new Unlicensed::SuperFighter3(c); 3710 case Type::UNL_TF1201 : return new Unlicensed::Tf1201(c); 3711 case Type::UNL_WORLDHERO : return new Unlicensed::WorldHero(c); 3712 case Type::UNL_XZY : return new Unlicensed::Xzy(c); 3713 case Type::WAIXING_PS2_0 : 3714 case Type::WAIXING_PS2_1 : return new Waixing::Ps2(c); 3715 case Type::WAIXING_TYPE_A : return new Waixing::TypeA(c); 3716 case Type::WAIXING_TYPE_B : return new Waixing::TypeB(c); 3717 case Type::WAIXING_TYPE_C : return new Waixing::TypeC(c); 3718 case Type::WAIXING_TYPE_D : return new Waixing::TypeD(c); 3719 case Type::WAIXING_TYPE_E : return new Waixing::TypeE(c); 3720 case Type::WAIXING_TYPE_F : return new Waixing::TypeF(c); 3721 case Type::WAIXING_TYPE_G : return new Waixing::TypeG(c); 3722 case Type::WAIXING_TYPE_H : return new Waixing::TypeH(c); 3723 case Type::WAIXING_TYPE_I : return new Waixing::TypeI(c); 3724 case Type::WAIXING_TYPE_J : return new Waixing::TypeJ(c); 3725 case Type::WAIXING_FFV_0 : 3726 case Type::WAIXING_FFV_1 : return new Waixing::Ffv(c); 3727 case Type::WAIXING_SH2_0 : 3728 case Type::WAIXING_SH2_1 : return new Waixing::Sh2(c); 3729 case Type::WAIXING_ZS : return new Waixing::Zs(c); 3730 case Type::WAIXING_DQVII : return new Waixing::Dqv7(c); 3731 case Type::WAIXING_SGZ : return new Waixing::Sgz(c); 3732 case Type::WAIXING_SGZLZ : return new Waixing::Sgzlz(c); 3733 case Type::WAIXING_SECURITY_0 : 3734 case Type::WAIXING_SECURITY_1 : return new Waixing::Security(c); 3735 case Type::WHIRLWIND_2706 : return new Whirlwind::W2706(c); 3736 case Type::UNKNOWN : default: break; 3737 } 3738 3739 return NULL; 3740 } 3741 Destroy(Board * board)3742 void Board::Destroy(Board* board) 3743 { 3744 delete board; 3745 } 3746 3747 #ifdef NST_MSVC_OPTIMIZE 3748 #pragma optimize("", on) 3749 #endif 3750 } 3751 } 3752 } 3753