public void SetupNametables(Mirroring mirroring)
{
// Sorts nametable mirroring! :)
switch (mirroring)
{
case Mirroring.Horizontal:
logicalNametables[0] = physicalNametables[0];
logicalNametables[1] = physicalNametables[0];
logicalNametables[2] = physicalNametables[1];
logicalNametables[3] = physicalNametables[2];
break;
case Mirroring.Vertical:
logicalNametables[0] = physicalNametables[0];
logicalNametables[1] = physicalNametables[1];
logicalNametables[2] = physicalNametables[0];
logicalNametables[3] = physicalNametables[1];
break;
case Mirroring.None:
logicalNametables[0] = physicalNametables[0];
logicalNametables[1] = physicalNametables[1];
logicalNametables[2] = physicalNametables[2];
logicalNametables[3] = physicalNametables[3];
break;
default:
throw new NotImplementedException();
}
}
public override void Initialize(string sha1, byte[] prg_dump, byte[] chr_dump, byte[] trainer_dump, Mirroring defaultMirroring)
{
base.Initialize(sha1, prg_dump, chr_dump, trainer_dump, defaultMirroring);
InitializeSoundMixTable();
channel_sq1 = new MMC5SqrSoundChannel();
channel_sq2 = new MMC5SqrSoundChannel();
channel_pcm = new MMC5PcmSoundChannel();
}
public void LoadNesData(NesEngine _engine)
{
#region CPU
_regA = _engine.Cpu.REG_A;
_regX = _engine.Cpu.REG_X;
_regY = _engine.Cpu.REG_Y;
_regS = _engine.Cpu.REG_S;
_regPc = _engine.Cpu.REG_PC;
_flagN = _engine.Cpu.Flag_N;
_flagV = _engine.Cpu.Flag_V;
_flagB = _engine.Cpu.Flag_B;
_flagD = _engine.Cpu.Flag_D;
_flagI = _engine.Cpu.Flag_I;
_flagZ = _engine.Cpu.Flag_Z;
_flagC = _engine.Cpu.Flag_C;
CycleCounter = _engine.Cpu.CycleCounter;
_cyclesPerScanline = _engine.Cpu.CyclesPerScanline;
_opCode = _engine.Cpu.OpCode;
_prevPc = _engine.Cpu.PrevPc;
#endregion
#region MEMORY
_ram = _engine.Memory.Ram;
_sram = _engine.Memory.SRam;
_joyData1 = _engine.Memory.JoyData1;
_joyData2 = _engine.Memory.JoyData2;
_joyStrobe = _engine.Memory.JoyStrobe;
#endregion
#region CART
if (_engine.Memory.Map.Cartridge.ChrPages == 0)
_chr = _engine.Memory.Map.Cartridge.Chr;
_mirroring = _engine.Memory.Map.Cartridge.Mirroring;
_saveRAMPresent = _engine.Memory.Map.Cartridge.IsSaveRam;
_isVram = _engine.Memory.Map.Cartridge.IsVram;
_mirroringBase = _engine.Memory.Map.Cartridge.MirroringBase;
#endregion
#region _map
CurrentPRGRomPage = _engine.Memory.Map.CurrentPrgRomPage;
CurrentChrRomPage = _engine.Memory.Map.CurrentChrRomPage;
#endregion
#region PPU
_sprram = _engine.Ppu.SprRam;
_vram = _engine.Ppu.VRam;
_currentScanLine = _engine.Ppu.CurrentScanLine;
_vramAddress = _engine.Ppu.VRamAddress;
_sprite0Hit = _engine.Ppu.Sprite0Hit;
_spriteCrossed = _engine.Ppu.SpriteCrossed;
_scanlinesPerFrame = _engine.Ppu.ScanlinesPerFrame;
_scanlineOfVblank = _engine.Ppu.ScanlineOfVblank;
_fps = _engine.Ppu.Fps;
_vblank = _engine.Ppu.VBlank;
_vramReadBuffer = _engine.Ppu.VRamReadBuffer;
_noLimiter = _engine.Ppu.NoLimiter;
/*2000*/
_executeNMIonVBlank = _engine.Ppu.ExecuteNMIonVBlank;
_spriteSize = _engine.Ppu.SpriteSize;
_patternTableAddressBackground = _engine.Ppu.PatternTableAddressBackground;
_patternTableAddress8X8Sprites = _engine.Ppu.PatternTableAddress8X8Sprites;
_vramAddressIncrement = _engine.Ppu.VRamAddressIncrement;
_reloadBits2000 = _engine.Ppu.ReloadBits2000;
/*2001*/
_colorEmphasis = _engine.Ppu.ColorEmphasis;
_spriteVisibility = _engine.Ppu.SpriteVisibility;
_backgroundVisibility = _engine.Ppu.BackgroundVisibility;
_spriteClipping = _engine.Ppu.SpriteClipping;
_backgroundClipping = _engine.Ppu.BackgroundClipping;
_monochromeMode = _engine.Ppu.MonochromeMode;
/*2003*/
_spriteRamAddress = _engine.Ppu.SpriteRamAddress;
/*2005,2006*/
_ppuToggle = _engine.Ppu.PpuToggle;
_vramTemp = _engine.Ppu.VRamTemp;
/*Draw stuff*/
_hScroll = _engine.Ppu.HScroll;
_vScroll = _engine.Ppu.VScroll;
_vBits = _engine.Ppu.VBits;
_tileY = _engine.Ppu.TileY;
#endregion
#region APU
_FrameCounter = _engine.Apu._FrameCounter;
_PAL = _engine.Apu._PAL;
DMCIRQPending = _engine.Apu.DMCIRQPending;
FrameIRQEnabled = _engine.Apu.FrameIRQEnabled;
FrameIRQPending = _engine.Apu.FrameIRQPending;
_engine.Apu.DMC.SaveState(this);
_engine.Apu.NOIZE.SaveState(this);
_engine.Apu.RECT1.SaveState(this);
_engine.Apu.RECT2.SaveState(this);
_engine.Apu.TRIANGLE.SaveState(this);
_engine.Apu.VRC6PULSE1.SaveState(this);
_engine.Apu.VRC6PULSE2.SaveState(this);
_engine.Apu.VRC6SAWTOOTH.SaveState(this);
#endregion
#region Mappers
//MAPPER 1
if (_engine.Memory.Map.Cartridge.MapperNo == 1)
{
var map1 = (Mapper01) _engine.Memory.Map.CurrentMapper;
mapper1_register8000BitPosition = map1.Mapper1Register8000BitPosition;
mapper1_registerA000BitPosition = map1.Mapper1RegisterA000BitPosition;
mapper1_registerC000BitPosition = map1.Mapper1RegisterC000BitPosition;
mapper1_registerE000BitPosition = map1.Mapper1RegisterE000BitPosition;
mapper1_register8000Value = map1.Mapper1Register8000Value;
mapper1_registerA000Value = map1.Mapper1RegisterA000Value;
mapper1_registerC000Value = map1.Mapper1RegisterC000Value;
mapper1_registerE000Value = map1.Mapper1RegisterE000Value;
mapper1_mirroringFlag = map1.Mapper1MirroringFlag;
mapper1_onePageMirroring = map1.Mapper1OnePageMirroring;
mapper1_prgSwitchingArea = map1.Mapper1PRGSwitchingArea;
mapper1_prgSwitchingSize = map1.Mapper1PRGSwitchingSize;
mapper1_vromSwitchingSize = map1.Mapper1VromSwitchingSize;
}
//MAPPER 4
if (_engine.Memory.Map.Cartridge.MapperNo == 4)
{
var map4 = (Mapper04) _engine.Memory.Map.CurrentMapper;
mapper4_commandNumber = map4.Mapper4CommandNumber;
mapper4_prgAddressSelect = map4.Mapper4PRGAddressSelect;
mapper4_chrAddressSelect = map4.Mapper4ChrAddressSelect;
mapper4_timer_irq_enabled = map4.TimerIrqEnabled;
mapper4_timer_irq_count = map4.TimerIrqCount;
mapper4_timer_irq_reload = map4.TimerIrqReload;
}
//MAPPER 5
if (_engine.Memory.Map.Cartridge.MapperNo == 5)
{
var map5 = (Mapper05) _engine.Memory.Map.CurrentMapper;
mapper5_prgBankSize = map5.Mapper5PRGBankSize;
mapper5_chrBankSize = map5.Mapper5ChrBankSize;
mapper5_scanlineSplit = map5.Mapper5ScanlineSplit;
mapper5_splitIrqEnabled = map5.Mapper5SplitIrqEnabled;
}
//MAPPER 6
if (_engine.Memory.Map.Cartridge.MapperNo == 6)
{
var map6 = (Mapper06) _engine.Memory.Map.CurrentMapper;
mapper6_IRQEnabled = map6.IRQEnabled;
mapper6_irq_counter = map6.irq_counter;
}
//MAPPER 8
if (_engine.Memory.Map.Cartridge.MapperNo == 8)
{
var map8 = (Mapper08) _engine.Memory.Map.CurrentMapper;
mapper8_IRQEnabled = map8.IRQEnabled;
mapper8_irq_counter = map8.irq_counter;
}
//MAPPER 9
if (_engine.Memory.Map.Cartridge.MapperNo == 9)
{
var map9 = (Mapper09) _engine.Memory.Map.CurrentMapper;
mapper9_latch1 = map9.latch1;
mapper9_latch2 = map9.latch2;
mapper9_latch1data1 = map9.latch1data1;
mapper9_latch1data2 = map9.latch1data2;
mapper9_latch2data1 = map9.latch2data1;
mapper9_latch2data2 = map9.latch2data2;
}
//MAPPER 10
if (_engine.Memory.Map.Cartridge.MapperNo == 10)
{
var map10 = (Mapper10) _engine.Memory.Map.CurrentMapper;
mapper10_latch1 = map10.Latch1;
mapper10_latch2 = map10.Latch2;
mapper10_latch1data1 = map10.Latch1Data1;
mapper10_latch1data2 = map10.Latch1Data2;
mapper10_latch2data1 = map10.Latch2Data1;
mapper10_latch2data2 = map10.Latch2Data2;
}
//MAPPER 16
if (_engine.Memory.Map.Cartridge.MapperNo == 16)
{
var map16 = (Mapper16) _engine.Memory.Map.CurrentMapper;
timer_irq_counter_16 = map16.timer_irq_counter_16;
timer_irq_Latch_16 = map16.timer_irq_Latch_16;
timer_irq_enabled = map16.timer_irq_enabled;
}
//MAPPER 17
if (_engine.Memory.Map.Cartridge.MapperNo == 17)
{
var map17 = (Mapper17) _engine.Memory.Map.CurrentMapper;
mapper17_IRQEnabled = map17.IRQEnabled;
mapper17_irq_counter = map17.irq_counter;
}
//MAPPER 18
if (_engine.Memory.Map.Cartridge.MapperNo == 18)
{
var map18 = (Mapper18) _engine.Memory.Map.CurrentMapper;
Mapper18_Timer = map18.Mapper18_Timer;
Mapper18_latch = map18.Mapper18_latch;
mapper18_control = map18.mapper18_control;
Mapper18_IRQWidth = map18.Mapper18_IRQWidth;
Mapper18_timer_irq_enabled = map18.timer_irq_enabled;
Mapper18_x = map18.x;
}
//MAPPER 19
if (_engine.Memory.Map.Cartridge.MapperNo == 19)
{
var map19 = (Mapper19) _engine.Memory.Map.CurrentMapper;
Mapper19_VROMRAMfor0000 = map19.VROMRAMfor0000;
Mapper19_VROMRAMfor1000 = map19.VROMRAMfor1000;
Mapper19_irq_counter = map19.irq_counter;
Mapper19_IRQEnabled = map19.IRQEnabled;
}
//MAPPER 21
if (_engine.Memory.Map.Cartridge.MapperNo == 21)
{
var map21 = (Mapper21) _engine.Memory.Map.CurrentMapper;
Mapper21_PRGMode = map21.PRGMode;
Mapper21_REG = map21.REG;
Mapper21_irq_latch = map21.IrqLatch;
Mapper21_irq_enable = map21.IrqEnable;
Mapper21_irq_counter = map21.IrqCounter;
Mapper21_irq_clock = map21.IrqClock;
}
//MAPPER 23
if (_engine.Memory.Map.Cartridge.MapperNo == 23)
{
var map23 = (Mapper23) _engine.Memory.Map.CurrentMapper;
Mapper23_PRGMode = map23.PRGMode;
Mapper23_REG = map23.REG;
Mapper23_irq_latch = map23.IrqLatch;
Mapper23_irq_enable = map23.IrqEnable;
Mapper23_irq_counter = map23.IrqCounter;
Mapper23_irq_clock = map23.IrqClock;
}
//MAPPER 24
if (_engine.Memory.Map.Cartridge.MapperNo == 24)
{
var map24 = (Mapper24) _engine.Memory.Map.CurrentMapper;
Mapper24_irq_latch = map24.irq_latch;
Mapper24_irq_enable = map24.irq_enable;
Mapper24_irq_counter = map24.irq_counter;
Mapper24_irq_clock = map24.irq_clock;
}
//MAPPER 225
if (_engine.Memory.Map.Cartridge.MapperNo == 225)
{
var map225 = (Mapper225255) _engine.Memory.Map.CurrentMapper;
Mapper225_reg0 = map225.Mapper225_reg0;
Mapper225_reg1 = map225.Mapper225_reg1;
Mapper225_reg2 = map225.Mapper225_reg2;
Mapper225_reg3 = map225.Mapper225_reg3;
}
//MAPPER 32
if (_engine.Memory.Map.Cartridge.MapperNo == 32)
{
var map32 = (Mapper32) _engine.Memory.Map.CurrentMapper;
mapper32SwitchingMode = map32.mapper32SwitchingMode;
}
//MAPPER 33
if (_engine.Memory.Map.Cartridge.MapperNo == 33)
{
var map33 = (Mapper33) _engine.Memory.Map.CurrentMapper;
mapper33_type1 = map33.Type1;
mapper33_IRQCounter = map33.IrqCounter;
mapper33_IRQEabled = map33.IrqEabled;
}
//MAPPER 41
if (_engine.Memory.Map.Cartridge.MapperNo == 41)
{
var map41 = (Mapper41) _engine.Memory.Map.CurrentMapper;
Mapper41_CHR_Low = map41.Mapper41_CHR_Low;
Mapper41_CHR_High = map41.Mapper41_CHR_High;
}
//MAPPER 64
if (_engine.Memory.Map.Cartridge.MapperNo == 64)
{
var map64 = (Mapper64) _engine.Memory.Map.CurrentMapper;
mapper64_commandNumber = map64.Mapper64CommandNumber;
mapper64_prgAddressSelect = map64.Mapper64PrgAddressSelect;
mapper64_chrAddressSelect = map64.Mapper64ChrAddressSelect;
}
//MAPPER 65
if (_engine.Memory.Map.Cartridge.MapperNo == 65)
{
var map65 = (Mapper65) _engine.Memory.Map.CurrentMapper;
mapper65_timer_irq_counter_65 = map65.timer_irq_counter_65;
mapper65_timer_irq_Latch_65 = map65.timer_irq_Latch_65;
mapper65_timer_irq_enabled = map65.timer_irq_enabled;
}
//MAPPER 69
if (_engine.Memory.Map.Cartridge.MapperNo == 69)
{
var map69 = (Mapper69) _engine.Memory.Map.CurrentMapper;
mapper69_reg = map69.reg;
mapper69_timer_irq_counter_69 = map69.timer_irq_counter_69;
mapper69_timer_irq_enabled = map69.timer_irq_enabled;
}
//MAPPER 91
if (_engine.Memory.Map.Cartridge.MapperNo == 91)
{
var map91 = (Mapper91) _engine.Memory.Map.CurrentMapper;
mapper91_IRQEnabled = map91.IRQEnabled;
mapper91_IRQCount = map91.IRQCount;
}
#endregion
}
public override void Initialize(string sha1, byte[] prg_dump, byte[] chr_dump, byte[] trainer_dump, Mirroring defaultMirroring)
{
base.Initialize(sha1, prg_dump, chr_dump, trainer_dump, defaultMirroring);
InitializeSoundMixTable();
}
protected void SwitchNMT(Mirroring mirroring)
{
SwitchNMT((byte)mirroring);
}
/// <summary>
/// Initialize the board
/// </summary>
/// <param name="sha1">The rom sha1 calculated without the header</param>
/// <param name="prg_dump">The prg data dump.</param>
/// <param name="chr_dump">The chr data dump</param>
/// <param name="trainer_dump">The trainer data dump.</param>
/// <param name="defaultMirroring">The default mirroring as defined in rom.</param>
public virtual void Initialize(string sha1, byte[] prg_dump, byte[] chr_dump, byte[] trainer_dump, Mirroring defaultMirroring)
{
RomSHA1 = sha1;
// Find on DB
GameInfo = NesCartDatabase.Find(sha1, out IsGameFoundOnDB);
//set cart info
if (GameInfo.Cartridges != null)
{
foreach (NesCartDatabaseCartridgeInfo cartinf in GameInfo.Cartridges)
if (cartinf.SHA1.ToLower() == sha1.ToLower())
{
GameCartInfo = cartinf;
break;
}
}
BoardType = "N/A";
BoardPCB = "N/A";
this.Chips = new List<string>();
if (IsGameFoundOnDB)
{
Console.WriteLine("Game found in Database !!");
Console.WriteLine("> Game name: " + GameInfo.Game_Name);
Console.WriteLine("> Game alt name: " + GameInfo.Game_AltName);
BoardType = GameCartInfo.Board_Type;
Console.WriteLine("> Board Type: " + BoardType);
BoardPCB = GameCartInfo.Board_Pcb;
Console.WriteLine("> Board Pcb: " + BoardPCB);
// Chips ... important for some boards
if (GameCartInfo.chip_type != null)
for (int i = 0; i < GameCartInfo.chip_type.Count; i++)
{
Console.WriteLine(string.Format("> CHIP {0}: {1}", (i + 1).ToString(),
GameCartInfo.chip_type[i]));
this.Chips.Add(GameCartInfo.chip_type[i]);
}
}
// Mirroring
this.default_mirroring = defaultMirroring;
nmt_banks = new byte[4][]
{
new byte[0x0400], new byte[0x0400], new byte[0x0400], new byte[0x0400]
/*Only 2 nmt banks should be used in normal state*/
};
nmt_indexes = new int[4];
SwitchNMT(defaultMirroring);
// PRG data ***********************************************
List<BankInfo> prgBanks = new List<BankInfo>(GetPRGRAM());
prg_rom_bank_offset = prgBanks.Count;
prgBanks.AddRange(GetPRGROM(prg_dump));
SRAMSaveRequired = false;
prg_banks = new byte[prgBanks.Count][];
prg_enable = new bool[prgBanks.Count];
prg_isram = new bool[prgBanks.Count];
prg_writable = new bool[prgBanks.Count];
prg_battery = new bool[prgBanks.Count];
for (int i = 0; i < prgBanks.Count; i++)
{
prg_banks[i] = prgBanks[i].DATA;
prg_enable[i] = prgBanks[i].Enabled;
prg_writable[i] = prgBanks[i].Writable;
prg_isram[i] = prgBanks[i].IsRAM;
prg_battery[i] = prgBanks[i].IsBattery;
if (!SRAMSaveRequired)
{
if (prg_battery[i])
SRAMSaveRequired = true;
}
}
prg_indexes = new int[5];
// ********************************************************
// Trainer ************************************************
// Put trainer at first ram bank.
if (trainer_dump != null)
{
if (trainer_dump.Length > 0)
{
for (int i = 0; i < prgBanks.Count; i++)
{
if (prg_isram[i])
{
trainer_dump.CopyTo(prg_banks[i], 0x1000);
break;
}
}
}
}
// ********************************************************
// CHR data ***********************************************
List<BankInfo> chrBanks = new List<BankInfo>(GetCHRRAM());
chr_rom_bank_offset = chrBanks.Count;
chrBanks.AddRange(GetCHRROM(chr_dump));
chr_banks = new byte[chrBanks.Count][];
chr_enable = new bool[chrBanks.Count];
chr_isram = new bool[chrBanks.Count];
chr_writable = new bool[chrBanks.Count];
for (int i = 0; i < chrBanks.Count; i++)
{
chr_banks[i] = chrBanks[i].DATA;
chr_enable[i] = chrBanks[i].Enabled;
chr_writable[i] = chrBanks[i].Writable;
chr_isram[i] = chrBanks[i].IsRAM;
}
chr_indexes = new int[8];
// ********************************************************
}
public Mapper002(byte[] prgRom, byte[] chrRom, Mirroring mirroring) : base(prgRom, chrRom, mirroring)
{
m_FinalBankOffset = PrgRom.Length - 0x4000 - 0xc000;
m_BankCount = PrgRom.Length / 0x4000;
}
protected Mapper(byte[] prgRom, byte[] chrRom, Mirroring mirroring)
{
PrgRom = prgRom;
ChrRom = EnsureArray(chrRom, 0x2000);
Mirroring = mirroring;
}
public Mapper066(byte[] prgRom, byte[] chrRom, Mirroring mirroring) : base(prgRom, chrRom, mirroring)
{
}
public override void Initialize(string sha1, byte[] prg_dump, byte[] chr_dump, byte[] trainer_dump, Mirroring defaultMirroring)
{
base.Initialize(sha1, prg_dump, chr_dump, trainer_dump, defaultMirroring);
InitializeSoundMixTable();
channel_sq1 = new MMC5SqrSoundChannel();
channel_sq2 = new MMC5SqrSoundChannel();
channel_pcm = new MMC5PcmSoundChannel();
}
