ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use nameof in cores

This commit is contained in:
James Groom 2019-03-28 14:18:58 +11:00 committed by GitHub
parent 779975f689
commit 4e91f88af3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
336 changed files with 2574 additions and 2579 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
BizHawk.Emulation.Cores/CPUs/68000/MC68000.cs
View File

@ -193,15 +193,15 @@ namespace BizHawk.Emulation.Cores.Components.M68000
writer.WriteLine();
writer.WriteLine("PC {0:X6}", PC);
writer.WriteLine("InterruptMaskLevel {0}", InterruptMaskLevel);
writer.WriteLine($"{nameof(InterruptMaskLevel)} {InterruptMaskLevel}");
writer.WriteLine("USP {0:X8}", usp);
writer.WriteLine("SSP {0:X8}", ssp);
writer.WriteLine("S {0}", s);
writer.WriteLine("M {0}", m);
writer.WriteLine();
writer.WriteLine("TotalExecutedCycles {0}", TotalExecutedCycles);
writer.WriteLine("PendingCycles {0}", PendingCycles);
writer.WriteLine($"{nameof(TotalExecutedCycles)} {TotalExecutedCycles}");
writer.WriteLine($"{nameof(PendingCycles)} {PendingCycles}");
writer.WriteLine("[/{0}]", id);
}
@ -232,14 +232,14 @@ namespace BizHawk.Emulation.Cores.Components.M68000
else if (args[0] == "A7") A[7].s32 = int.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "PC") PC = int.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "InterruptMaskLevel") InterruptMaskLevel = int.Parse(args[1]);
else if (args[0] == nameof(InterruptMaskLevel)) InterruptMaskLevel = int.Parse(args[1]);
else if (args[0] == "USP") usp = int.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "SSP") ssp = int.Parse(args[1], NumberStyles.HexNumber);
else if (args[0] == "S") s = bool.Parse(args[1]);
else if (args[0] == "M") m = bool.Parse(args[1]);
else if (args[0] == "TotalExecutedCycles") TotalExecutedCycles = int.Parse(args[1]);
else if (args[0] == "PendingCycles") PendingCycles = int.Parse(args[1]);
else if (args[0] == nameof(TotalExecutedCycles)) TotalExecutedCycles = int.Parse(args[1]);
else if (args[0] == nameof(PendingCycles)) PendingCycles = int.Parse(args[1]);
else
Console.WriteLine("Skipping unrecognized identifier " + args[0]);

28
BizHawk.Emulation.Cores/CPUs/CP1610/CP1610.cs
View File

@ -58,21 +58,21 @@ namespace BizHawk.Emulation.Cores.Components.CP1610
public void SyncState(Serializer ser)
{
ser.BeginSection("CP1610");
ser.BeginSection(nameof(CP1610));
ser.Sync("Register", ref Register, false);
ser.Sync("FlagS", ref FlagS);
ser.Sync("FlagC", ref FlagC);
ser.Sync("FlagZ", ref FlagZ);
ser.Sync("FlagO", ref FlagO);
ser.Sync("FlagI", ref FlagI);
ser.Sync("FlagD", ref FlagD);
ser.Sync("IntRM", ref IntRM);
ser.Sync("BusRq", ref BusRq);
ser.Sync("BusAk", ref BusAk);
ser.Sync("BusRq", ref BusRq);
ser.Sync("Interruptible", ref Interruptible);
ser.Sync("Interrupted", ref Interrupted);
ser.Sync(nameof(Register), ref Register, false);
ser.Sync(nameof(FlagS), ref FlagS);
ser.Sync(nameof(FlagC), ref FlagC);
ser.Sync(nameof(FlagZ), ref FlagZ);
ser.Sync(nameof(FlagO), ref FlagO);
ser.Sync(nameof(FlagI), ref FlagI);
ser.Sync(nameof(FlagD), ref FlagD);
ser.Sync(nameof(IntRM), ref IntRM);
ser.Sync(nameof(BusRq), ref BusRq);
ser.Sync(nameof(BusAk), ref BusAk);
ser.Sync(nameof(BusRq), ref BusRq);
ser.Sync(nameof(Interruptible), ref Interruptible);
ser.Sync(nameof(Interrupted), ref Interrupted);
ser.Sync("Toal_executed_cycles", ref TotalExecutedCycles);
ser.Sync("Pending_Cycles", ref PendingCycles);

42
BizHawk.Emulation.Cores/CPUs/HuC6280/HuC6280.cs
View File

@ -70,28 +70,28 @@ namespace BizHawk.Emulation.Cores.Components.H6280
public void SyncState(Serializer ser)
{
ser.BeginSection("HuC6280");
ser.Sync("A", ref A);
ser.Sync("X", ref X);
ser.Sync("Y", ref Y);
ser.Sync("P", ref P);
ser.Sync("PC", ref PC);
ser.Sync("S", ref S);
ser.Sync("MPR", ref MPR, false);
ser.Sync("LagIFlag", ref LagIFlag);
ser.Sync("IRQ1Assert", ref IRQ1Assert);
ser.Sync("IRQ2Assert", ref IRQ2Assert);
ser.Sync("TimerAssert", ref TimerAssert);
ser.Sync("IRQControlByte", ref IRQControlByte);
ser.Sync("IRQNextControlByte", ref IRQNextControlByte);
ser.BeginSection(nameof(HuC6280));
ser.Sync(nameof(A), ref A);
ser.Sync(nameof(X), ref X);
ser.Sync(nameof(Y), ref Y);
ser.Sync(nameof(P), ref P);
ser.Sync(nameof(PC), ref PC);
ser.Sync(nameof(S), ref S);
ser.Sync(nameof(MPR), ref MPR, false);
ser.Sync(nameof(LagIFlag), ref LagIFlag);
ser.Sync(nameof(IRQ1Assert), ref IRQ1Assert);
ser.Sync(nameof(IRQ2Assert), ref IRQ2Assert);
ser.Sync(nameof(TimerAssert), ref TimerAssert);
ser.Sync(nameof(IRQControlByte), ref IRQControlByte);
ser.Sync(nameof(IRQNextControlByte), ref IRQNextControlByte);
ser.Sync("ExecutedCycles", ref TotalExecutedCycles);
ser.Sync("PendingCycles", ref PendingCycles);
ser.Sync("LowSpeed", ref LowSpeed);
ser.Sync("TimerTickCounter", ref TimerTickCounter);
ser.Sync("TimerReloadValue", ref TimerReloadValue);
ser.Sync("TimerValue", ref TimerValue);
ser.Sync("TimerEnabled", ref TimerEnabled);
ser.Sync("InBlockTransfer", ref InBlockTransfer);
ser.Sync(nameof(PendingCycles), ref PendingCycles);
ser.Sync(nameof(LowSpeed), ref LowSpeed);
ser.Sync(nameof(TimerTickCounter), ref TimerTickCounter);
ser.Sync(nameof(TimerReloadValue), ref TimerReloadValue);
ser.Sync(nameof(TimerValue), ref TimerValue);
ser.Sync(nameof(TimerEnabled), ref TimerEnabled);
ser.Sync(nameof(InBlockTransfer), ref InBlockTransfer);
ser.Sync("BTFrom", ref btFrom);
ser.Sync("BTTo", ref btTo);
ser.Sync("BTLen", ref btLen);

36
BizHawk.Emulation.Cores/CPUs/LR35902/LR35902.cs
View File

@ -591,29 +591,29 @@ namespace BizHawk.Emulation.Common.Components.LR35902
public void SyncState(Serializer ser)
{
ser.BeginSection("LR35902");
ser.Sync("Regs", ref Regs, false);
ser.BeginSection(nameof(LR35902));
ser.Sync(nameof(Regs), ref Regs, false);
ser.Sync("IRQ", ref interrupts_enabled);
ser.Sync("I_use", ref I_use);
ser.Sync("skip_once", ref skip_once);
ser.Sync("Halt_bug_2", ref Halt_bug_2);
ser.Sync("Halt_bug_3", ref Halt_bug_3);
ser.Sync(nameof(I_use), ref I_use);
ser.Sync(nameof(skip_once), ref skip_once);
ser.Sync(nameof(Halt_bug_2), ref Halt_bug_2);
ser.Sync(nameof(Halt_bug_3), ref Halt_bug_3);
ser.Sync("Halted", ref halted);
ser.Sync("ExecutedCycles", ref totalExecutedCycles);
ser.Sync("EI_pending", ref EI_pending);
ser.Sync("int_src", ref int_src);
ser.Sync("stop_time", ref stop_time);
ser.Sync("stop_check", ref stop_check);
ser.Sync("is_GBC", ref is_GBC);
ser.Sync(nameof(EI_pending), ref EI_pending);
ser.Sync(nameof(int_src), ref int_src);
ser.Sync(nameof(stop_time), ref stop_time);
ser.Sync(nameof(stop_check), ref stop_check);
ser.Sync(nameof(is_GBC), ref is_GBC);
ser.Sync("instr_pntr", ref instr_pntr);
ser.Sync("cur_instr", ref cur_instr, false);
ser.Sync("CB Preifx", ref CB_prefix);
ser.Sync(nameof(instr_pntr), ref instr_pntr);
ser.Sync(nameof(cur_instr), ref cur_instr, false);
ser.Sync("CB Prefix", ref CB_prefix);
ser.Sync("Stopped", ref stopped);
ser.Sync("opcode", ref opcode);
ser.Sync("jammped", ref jammed);
ser.Sync("LY", ref LY);
ser.Sync("FlagI", ref FlagI);
ser.Sync(nameof(opcode), ref opcode);
ser.Sync(nameof(jammed), ref jammed);
ser.Sync(nameof(LY), ref LY);
ser.Sync(nameof(FlagI), ref FlagI);
ser.EndSection();
}

44
BizHawk.Emulation.Cores/CPUs/MOS 6502X/MOS6502X.cs
View File

@ -126,28 +126,28 @@ namespace BizHawk.Emulation.Cores.Components.M6502
public void SyncState(Serializer ser)
{
ser.BeginSection("MOS6502X");
ser.Sync("A", ref A);
ser.Sync("X", ref X);
ser.Sync("Y", ref Y);
ser.Sync("P", ref P);
ser.Sync("PC", ref PC);
ser.Sync("S", ref S);
ser.Sync("NMI", ref NMI);
ser.Sync("IRQ", ref IRQ);
ser.Sync("RDY", ref RDY);
ser.Sync("TotalExecutedCycles", ref TotalExecutedCycles);
ser.Sync("opcode", ref opcode);
ser.Sync("opcode2", ref opcode2);
ser.Sync("opcode3", ref opcode3);
ser.Sync("ea", ref ea);
ser.Sync("alu_temp", ref alu_temp);
ser.Sync("mi", ref mi);
ser.Sync("iflag_pending", ref iflag_pending);
ser.Sync("interrupt_pending", ref interrupt_pending);
ser.Sync("branch_irq_hack", ref branch_irq_hack);
ser.Sync("rdy_freeze", ref rdy_freeze);
ser.Sync("ext_ppu_cycle", ref ext_ppu_cycle);
ser.BeginSection(nameof(MOS6502X));
ser.Sync(nameof(A), ref A);
ser.Sync(nameof(X), ref X);
ser.Sync(nameof(Y), ref Y);
ser.Sync(nameof(P), ref P);
ser.Sync(nameof(PC), ref PC);
ser.Sync(nameof(S), ref S);
ser.Sync(nameof(NMI), ref NMI);
ser.Sync(nameof(IRQ), ref IRQ);
ser.Sync(nameof(RDY), ref RDY);
ser.Sync(nameof(TotalExecutedCycles), ref TotalExecutedCycles);
ser.Sync(nameof(opcode), ref opcode);
ser.Sync(nameof(opcode2), ref opcode2);
ser.Sync(nameof(opcode3), ref opcode3);
ser.Sync(nameof(ea), ref ea);
ser.Sync(nameof(alu_temp), ref alu_temp);
ser.Sync(nameof(mi), ref mi);
ser.Sync(nameof(iflag_pending), ref iflag_pending);
ser.Sync(nameof(interrupt_pending), ref interrupt_pending);
ser.Sync(nameof(branch_irq_hack), ref branch_irq_hack);
ser.Sync(nameof(rdy_freeze), ref rdy_freeze);
ser.Sync(nameof(ext_ppu_cycle), ref ext_ppu_cycle);
ser.EndSection();
}

46
BizHawk.Emulation.Cores/CPUs/Z80A/Z80A.cs
View File

@ -839,38 +839,38 @@ namespace BizHawk.Emulation.Cores.Components.Z80A
// State Save/Load
public void SyncState(Serializer ser)
{
ser.BeginSection("Z80A");
ser.Sync("Regs", ref Regs, false);
ser.BeginSection(nameof(Z80A));
ser.Sync(nameof(Regs), ref Regs, false);
ser.Sync("NMI", ref nonMaskableInterrupt);
ser.Sync("NMIPending", ref nonMaskableInterruptPending);
ser.Sync("IM", ref interruptMode);
ser.Sync("IFF1", ref iff1);
ser.Sync("IFF2", ref iff2);
ser.Sync("Halted", ref halted);
ser.Sync("I_skip", ref I_skip);
ser.Sync(nameof(I_skip), ref I_skip);
ser.Sync("ExecutedCycles", ref TotalExecutedCycles);
ser.Sync("EI_pending", ref EI_pending);
ser.Sync(nameof(EI_pending), ref EI_pending);
ser.Sync("instr_pntr", ref instr_pntr);
ser.Sync("bus_pntr", ref bus_pntr);
ser.Sync("mem_pntr", ref mem_pntr);
ser.Sync("irq_pntr", ref irq_pntr);
ser.Sync("cur_instr", ref cur_instr, false);
ser.Sync("BUSRQ", ref BUSRQ, false);
ser.Sync("IRQS", ref IRQS);
ser.Sync("MEMRQ", ref MEMRQ, false);
ser.Sync("opcode", ref opcode);
ser.Sync("FlagI", ref FlagI);
ser.Sync("FlagW", ref FlagW);
ser.Sync(nameof(instr_pntr), ref instr_pntr);
ser.Sync(nameof(bus_pntr), ref bus_pntr);
ser.Sync(nameof(mem_pntr), ref mem_pntr);
ser.Sync(nameof(irq_pntr), ref irq_pntr);
ser.Sync(nameof(cur_instr), ref cur_instr, false);
ser.Sync(nameof(BUSRQ), ref BUSRQ, false);
ser.Sync(nameof(IRQS), ref IRQS);
ser.Sync(nameof(MEMRQ), ref MEMRQ, false);
ser.Sync(nameof(opcode), ref opcode);
ser.Sync(nameof(FlagI), ref FlagI);
ser.Sync(nameof(FlagW), ref FlagW);
ser.Sync("NO Preifx", ref NO_prefix);
ser.Sync("CB Preifx", ref CB_prefix);
ser.Sync("IX_prefix", ref IX_prefix);
ser.Sync("IY_prefix", ref IY_prefix);
ser.Sync("IXCB_prefix", ref IXCB_prefix);
ser.Sync("IYCB_prefix", ref IYCB_prefix);
ser.Sync("EXTD_prefix", ref EXTD_prefix);
ser.Sync("PRE_SRC", ref PRE_SRC);
ser.Sync(nameof(NO_prefix), ref NO_prefix);
ser.Sync(nameof(CB_prefix), ref CB_prefix);
ser.Sync(nameof(IX_prefix), ref IX_prefix);
ser.Sync(nameof(IY_prefix), ref IY_prefix);
ser.Sync(nameof(IXCB_prefix), ref IXCB_prefix);
ser.Sync(nameof(IYCB_prefix), ref IYCB_prefix);
ser.Sync(nameof(EXTD_prefix), ref EXTD_prefix);
ser.Sync(nameof(PRE_SRC), ref PRE_SRC);
ser.EndSection();
}

18
BizHawk.Emulation.Cores/Calculator/TI83.IStatable.cs
View File

@ -52,7 +52,7 @@ namespace BizHawk.Emulation.Cores.Calculators
}
_cpu.SyncState(ser);
ser.BeginSection("TI83");
ser.BeginSection(nameof(TI83));
ser.Sync("RAM", ref _ram, false);
ser.Sync("romPageLow3Bits", ref _romPageLow3Bits);
ser.Sync("romPageHighBit", ref _romPageHighBit);
@ -69,14 +69,14 @@ namespace BizHawk.Emulation.Cores.Calculators
ser.Sync("Frame", ref _frame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("IsLag", ref _isLag);
ser.Sync("ON_key_int", ref ON_key_int);
ser.Sync("ON_key_int_EN", ref ON_key_int_EN);
ser.Sync("TIM_1_int", ref TIM_1_int);
ser.Sync("TIM_1_int_EN", ref TIM_1_int_EN);
ser.Sync("TIM_frq", ref TIM_frq);
ser.Sync("TIM_mult", ref TIM_mult);
ser.Sync("TIM_count", ref TIM_count);
ser.Sync("TIM_hit", ref TIM_hit);
ser.Sync(nameof(ON_key_int), ref ON_key_int);
ser.Sync(nameof(ON_key_int_EN), ref ON_key_int_EN);
ser.Sync(nameof(TIM_1_int), ref TIM_1_int);
ser.Sync(nameof(TIM_1_int_EN), ref TIM_1_int_EN);
ser.Sync(nameof(TIM_frq), ref TIM_frq);
ser.Sync(nameof(TIM_mult), ref TIM_mult);
ser.Sync(nameof(TIM_count), ref TIM_count);
ser.Sync(nameof(TIM_hit), ref TIM_hit);
ser.EndSection();

8
BizHawk.Emulation.Cores/Computers/AmstradCPC/AmstradCPC.IStatable.cs
View File

@ -57,10 +57,10 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
if (ser.IsWriter)
{
ser.SyncEnum("_machineType", ref _machineType);
ser.SyncEnum(nameof(_machineType), ref _machineType);
_cpu.SyncState(ser);
ser.BeginSection("AmstradCPC");
ser.BeginSection(nameof(AmstradCPC));
_machine.SyncState(ser);
ser.Sync("Frame", ref _machine.FrameCount);
ser.Sync("LagCount", ref _lagCount);
@ -71,7 +71,7 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
if (ser.IsReader)
{
var tmpM = _machineType;
ser.SyncEnum("_machineType", ref _machineType);
ser.SyncEnum(nameof(_machineType), ref _machineType);
if (tmpM != _machineType && _machineType.ToString() != "72")
{
string msg = "SAVESTATE FAILED TO LOAD!!\n\n";
@ -86,7 +86,7 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
else
{
_cpu.SyncState(ser);
ser.BeginSection("AmstradCPC");
ser.BeginSection(nameof(AmstradCPC));
_machine.SyncState(ser);
ser.Sync("Frame", ref _machine.FrameCount);
ser.Sync("LagCount", ref _lagCount);

18
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Datacorder/DatacorderDevice.cs
View File

@ -824,15 +824,15 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
/// <param name="ser"></param>
public void SyncState(Serializer ser)
{
ser.BeginSection("DatacorderDevice");
ser.Sync("counter", ref counter);
ser.Sync("_currentDataBlockIndex", ref _currentDataBlockIndex);
ser.Sync("_position", ref _position);
ser.Sync("_tapeIsPlaying", ref _tapeIsPlaying);
ser.Sync("_lastCycle", ref _lastCycle);
ser.Sync("_waitEdge", ref _waitEdge);
ser.Sync("currentState", ref currentState);
ser.Sync("TapeMotor", ref tapeMotor);
ser.BeginSection(nameof(DatacorderDevice));
ser.Sync(nameof(counter), ref counter);
ser.Sync(nameof(_currentDataBlockIndex), ref _currentDataBlockIndex);
ser.Sync(nameof(_position), ref _position);
ser.Sync(nameof(_tapeIsPlaying), ref _tapeIsPlaying);
ser.Sync(nameof(_lastCycle), ref _lastCycle);
ser.Sync(nameof(_waitEdge), ref _waitEdge);
ser.Sync(nameof(currentState), ref currentState);
ser.Sync(nameof(tapeMotor), ref tapeMotor);
ser.EndSection();
}

18
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Disk/NECUPD765.Definitions.cs
View File

@ -806,15 +806,15 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
ser.BeginSection("ActiveCmdParams");
ser.Sync("UnitSelect", ref UnitSelect);
ser.Sync("Side", ref Side);
ser.Sync("Cylinder", ref Cylinder);
ser.Sync("Head", ref Head);
ser.Sync("Sector", ref Sector);
ser.Sync("SectorSize", ref SectorSize);
ser.Sync("EOT", ref EOT);
ser.Sync("Gap3Length", ref Gap3Length);
ser.Sync("DTL", ref DTL);
ser.Sync(nameof(UnitSelect), ref UnitSelect);
ser.Sync(nameof(Side), ref Side);
ser.Sync(nameof(Cylinder), ref Cylinder);
ser.Sync(nameof(Head), ref Head);
ser.Sync(nameof(Sector), ref Sector);
ser.Sync(nameof(SectorSize), ref SectorSize);
ser.Sync(nameof(EOT), ref EOT);
ser.Sync(nameof(Gap3Length), ref Gap3Length);
ser.Sync(nameof(DTL), ref DTL);
ser.EndSection();
}

44
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Disk/NECUPD765.FDD.cs
View File

@ -861,28 +861,28 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.Sync("ID", ref ID);
ser.Sync("FLAG_WRITEPROTECT", ref FLAG_WRITEPROTECT);
//ser.Sync("FLAG_DISKCHANGED", ref FLAG_DISKCHANGED);
//ser.Sync("FLAG_RECALIBRATING", ref FLAG_RECALIBRATING);
//ser.Sync("FLAG_SEEK_INTERRUPT", ref FLAG_SEEK_INTERRUPT);
//ser.Sync("IntStatus", ref IntStatus);
//ser.Sync("ST0", ref ST0);
//ser.Sync("RecalibrationCounter", ref RecalibrationCounter);
ser.Sync("SeekCounter", ref SeekCounter);
ser.Sync("SeekStatus", ref SeekStatus);
ser.Sync("SeekAge", ref SeekAge);
ser.Sync("CurrentSide", ref CurrentSide);
//ser.Sync("CurrentTrack", ref CurrentTrack);
ser.Sync("TrackIndex", ref TrackIndex);
ser.Sync("SeekingTrack", ref SeekingTrack);
//ser.Sync("CurrentSector", ref CurrentSector);
ser.Sync("SectorIndex", ref SectorIndex);
//ser.Sync("RAngles", ref RAngles);
//ser.Sync("DataPointer", ref DataPointer);
//ser.SyncEnum("CurrentState", ref CurrentState);
//ser.SyncEnum("SeekState", ref SeekState);
//ser.SyncEnum("SeekIntState", ref SeekIntState);
ser.Sync(nameof(ID), ref ID);
ser.Sync(nameof(FLAG_WRITEPROTECT), ref FLAG_WRITEPROTECT);
//ser.Sync(nameof(FLAG_DISKCHANGED), ref FLAG_DISKCHANGED);
//ser.Sync(nameof(FLAG_RECALIBRATING), ref FLAG_RECALIBRATING);
//ser.Sync(nameof(FLAG_SEEK_INTERRUPT), ref FLAG_SEEK_INTERRUPT);
//ser.Sync(nameof(IntStatus), ref IntStatus);
//ser.Sync(nameof(ST0), ref ST0);
//ser.Sync(nameof(RecalibrationCounter), ref RecalibrationCounter);
ser.Sync(nameof(SeekCounter), ref SeekCounter);
ser.Sync(nameof(SeekStatus), ref SeekStatus);
ser.Sync(nameof(SeekAge), ref SeekAge);
ser.Sync(nameof(CurrentSide), ref CurrentSide);
//ser.Sync(nameof(CurrentTrack), ref CurrentTrack);
ser.Sync(nameof(TrackIndex), ref TrackIndex);
ser.Sync(nameof(SeekingTrack), ref SeekingTrack);
//ser.Sync(nameof(CurrentSector), ref CurrentSector);
ser.Sync(nameof(SectorIndex), ref SectorIndex);
//ser.Sync(nameof(RAngles), ref RAngles);
//ser.Sync(nameof(DataPointer), ref DataPointer);
//ser.SyncEnum(nameof(CurrentState), ref CurrentState);
//ser.SyncEnum(nameof(SeekState), ref SeekState);
//ser.SyncEnum(nameof(SeekIntState), ref SeekIntState);
}
#endregion

76
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Disk/NECUPD765.cs
View File

@ -159,7 +159,7 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
#region FDD
ser.Sync("FDD_FLAG_MOTOR", ref FDD_FLAG_MOTOR);
ser.Sync(nameof(FDD_FLAG_MOTOR), ref FDD_FLAG_MOTOR);
for (int i = 0; i < 4; i++)
{
@ -168,7 +168,7 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
ser.EndSection();
}
ser.Sync("DiskDriveIndex", ref _diskDriveIndex);
ser.Sync(nameof(DiskDriveIndex), ref _diskDriveIndex);
// set active drive
DiskDriveIndex = _diskDriveIndex;
@ -186,55 +186,55 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
#region Controller state
ser.Sync("DriveLight", ref DriveLight);
ser.SyncEnum("ActivePhase", ref ActivePhase);
//ser.SyncEnum("ActiveDirection", ref ActiveDirection);
ser.SyncEnum("ActiveInterrupt", ref ActiveInterrupt);
ser.Sync("CommBuffer", ref CommBuffer, false);
ser.Sync("CommCounter", ref CommCounter);
ser.Sync("ResBuffer", ref ResBuffer, false);
ser.Sync("ExecBuffer", ref ExecBuffer, false);
ser.Sync("ExecCounter", ref ExecCounter);
ser.Sync("ExecLength", ref ExecLength);
ser.Sync("InterruptResultBuffer", ref InterruptResultBuffer, false);
ser.Sync("ResCounter", ref ResCounter);
ser.Sync("ResLength", ref ResLength);
ser.Sync("LastSectorDataWriteByte", ref LastSectorDataWriteByte);
ser.Sync("LastSectorDataReadByte", ref LastSectorDataReadByte);
ser.Sync("LastByteReceived", ref LastByteReceived);
ser.Sync(nameof(DriveLight), ref DriveLight);
ser.SyncEnum(nameof(ActivePhase), ref ActivePhase);
//ser.SyncEnum(nameof(ActiveDirection), ref ActiveDirection);
ser.SyncEnum(nameof(ActiveInterrupt), ref ActiveInterrupt);
ser.Sync(nameof(CommBuffer), ref CommBuffer, false);
ser.Sync(nameof(CommCounter), ref CommCounter);
ser.Sync(nameof(ResBuffer), ref ResBuffer, false);
ser.Sync(nameof(ExecBuffer), ref ExecBuffer, false);
ser.Sync(nameof(ExecCounter), ref ExecCounter);
ser.Sync(nameof(ExecLength), ref ExecLength);
ser.Sync(nameof(InterruptResultBuffer), ref InterruptResultBuffer, false);
ser.Sync(nameof(ResCounter), ref ResCounter);
ser.Sync(nameof(ResLength), ref ResLength);
ser.Sync(nameof(LastSectorDataWriteByte), ref LastSectorDataWriteByte);
ser.Sync(nameof(LastSectorDataReadByte), ref LastSectorDataReadByte);
ser.Sync(nameof(LastByteReceived), ref LastByteReceived);
ser.Sync("_cmdIndex", ref _cmdIndex);
ser.Sync(nameof(_cmdIndex), ref _cmdIndex);
// resync the ActiveCommand
CMDIndex = _cmdIndex;
ActiveCommandParams.SyncState(ser);
ser.Sync("IndexPulseCounter", ref IndexPulseCounter);
//ser.SyncEnum("_activeStatus", ref _activeStatus);
//ser.SyncEnum("_statusRaised", ref _statusRaised);
ser.Sync(nameof(IndexPulseCounter), ref IndexPulseCounter);
//ser.SyncEnum(nameof(_activeStatus), ref _activeStatus);
//ser.SyncEnum(nameof(_statusRaised), ref _statusRaised);
ser.Sync("CMD_FLAG_MT", ref CMD_FLAG_MT);
ser.Sync("CMD_FLAG_MF", ref CMD_FLAG_MF);
ser.Sync("CMD_FLAG_SK", ref CMD_FLAG_SK);
ser.Sync("SRT", ref SRT);
ser.Sync("HUT", ref HUT);
ser.Sync("HLT", ref HLT);
ser.Sync("ND", ref ND);
ser.Sync("SRT_Counter", ref SRT_Counter);
ser.Sync("HUT_Counter", ref HUT_Counter);
ser.Sync("HLT_Counter", ref HLT_Counter);
ser.Sync(nameof(CMD_FLAG_MT), ref CMD_FLAG_MT);
ser.Sync(nameof(CMD_FLAG_MF), ref CMD_FLAG_MF);
ser.Sync(nameof(CMD_FLAG_SK), ref CMD_FLAG_SK);
ser.Sync(nameof(SRT), ref SRT);
ser.Sync(nameof(HUT), ref HUT);
ser.Sync(nameof(HLT), ref HLT);
ser.Sync(nameof(ND), ref ND);
ser.Sync(nameof(SRT_Counter), ref SRT_Counter);
ser.Sync(nameof(HUT_Counter), ref HUT_Counter);
ser.Sync(nameof(HLT_Counter), ref HLT_Counter);
ser.Sync("SectorDelayCounter", ref SectorDelayCounter);
ser.Sync("SectorID", ref SectorID);
ser.Sync(nameof(SectorDelayCounter), ref SectorDelayCounter);
ser.Sync(nameof(SectorID), ref SectorID);
#endregion
#region Timing
ser.Sync("LastCPUCycle", ref LastCPUCycle);
ser.Sync("StatusDelay", ref StatusDelay);
ser.Sync("TickCounter", ref TickCounter);
ser.Sync("DriveCycleCounter", ref DriveCycleCounter);
ser.Sync(nameof(LastCPUCycle), ref LastCPUCycle);
ser.Sync(nameof(StatusDelay), ref StatusDelay);
ser.Sync(nameof(TickCounter), ref TickCounter);
ser.Sync(nameof(DriveCycleCounter), ref DriveCycleCounter);
#endregion

56
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Display/AmstradGateArray.cs
View File

@ -1262,34 +1262,34 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.BeginSection("GateArray");
ser.SyncEnum("ChipType", ref ChipType);
ser.Sync("_PENR", ref _PENR);
ser.Sync("_INKR", ref _INKR);
ser.Sync("_RMR", ref _RMR);
ser.Sync("_RAMR", ref _RAMR);
ser.Sync("ColourRegisters", ref ColourRegisters, false);
ser.Sync("CurrentPen", ref CurrentPen);
ser.Sync("ClockCounter", ref ClockCounter);
ser.Sync("FrameClock", ref FrameClock);
ser.Sync("FrameEnd", ref FrameEnd);
ser.Sync("WaitLine", ref WaitLine);
ser.Sync("_interruptCounter", ref _interruptCounter);
ser.Sync("VSYNCDelay", ref VSYNCDelay);
ser.Sync("ScreenMode", ref ScreenMode);
ser.Sync("HSYNC", ref HSYNC);
//ser.Sync("HSYNC_falling", ref HSYNC_falling);
ser.Sync("HSYNC_counter", ref HSYNC_counter);
ser.Sync("VSYNC", ref VSYNC);
ser.Sync("InterruptRaised", ref InterruptRaised);
ser.Sync("InterruptHoldCounter", ref InterruptHoldCounter);
ser.Sync("_MA", ref _MA);
ser.Sync("IsNewFrame", ref IsNewFrame);
ser.Sync("IsNewLine", ref IsNewLine);
ser.Sync("HCC", ref HCC);
ser.Sync("VLC", ref VLC);
ser.Sync("VideoByte1", ref VideoByte1);
ser.Sync("VideoByte2", ref VideoByte2);
ser.Sync("NextVidRamLine", ref NextVidRamLine, false);
ser.SyncEnum(nameof(ChipType), ref ChipType);
ser.Sync(nameof(_PENR), ref _PENR);
ser.Sync(nameof(_INKR), ref _INKR);
ser.Sync(nameof(_RMR), ref _RMR);
ser.Sync(nameof(_RAMR), ref _RAMR);
ser.Sync(nameof(ColourRegisters), ref ColourRegisters, false);
ser.Sync(nameof(CurrentPen), ref CurrentPen);
ser.Sync(nameof(ClockCounter), ref ClockCounter);
ser.Sync(nameof(FrameClock), ref FrameClock);
ser.Sync(nameof(FrameEnd), ref FrameEnd);
ser.Sync(nameof(WaitLine), ref WaitLine);
ser.Sync(nameof(_interruptCounter), ref _interruptCounter);
ser.Sync(nameof(VSYNCDelay), ref VSYNCDelay);
ser.Sync(nameof(ScreenMode), ref ScreenMode);
ser.Sync(nameof(HSYNC), ref HSYNC);
//ser.Sync(nameof(HSYNC_falling), ref HSYNC_falling);
ser.Sync(nameof(HSYNC_counter), ref HSYNC_counter);
ser.Sync(nameof(VSYNC), ref VSYNC);
ser.Sync(nameof(InterruptRaised), ref InterruptRaised);
ser.Sync(nameof(InterruptHoldCounter), ref InterruptHoldCounter);
ser.Sync(nameof(_MA), ref _MA);
ser.Sync(nameof(IsNewFrame), ref IsNewFrame);
ser.Sync(nameof(IsNewLine), ref IsNewLine);
ser.Sync(nameof(HCC), ref HCC);
ser.Sync(nameof(VLC), ref VLC);
ser.Sync(nameof(VideoByte1), ref VideoByte1);
ser.Sync(nameof(VideoByte2), ref VideoByte2);
ser.Sync(nameof(NextVidRamLine), ref NextVidRamLine, false);
ser.EndSection();
}

36
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Display/CRCT_6845.cs
View File

@ -1182,24 +1182,24 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.BeginSection("CRTC");
ser.SyncEnum("ChipType", ref ChipType);
ser.Sync("HSYNC", ref HSYNC);
ser.Sync("VSYNC", ref VSYNC);
ser.Sync("DISPTMG", ref DISPTMG);
ser.Sync("MA", ref MA);
ser.Sync("CurrentByteAddress", ref CurrentByteAddress);
ser.Sync("ByteCounter", ref ByteCounter);
ser.Sync("Regs", ref Regs, false);
ser.Sync("SelectedRegister", ref SelectedRegister);
ser.Sync("HCC", ref HCC);
ser.Sync("VCC", ref VCC);
ser.Sync("VLC", ref VLC);
ser.Sync("CycleCounter", ref CycleCounter);
ser.Sync("EndOfScreen", ref EndOfScreen);
ser.Sync("HSYNCWidth", ref HSYNCWidth);
ser.Sync("HSYNCCounter", ref HSYNCCounter);
ser.Sync("VSYNCWidth", ref VSYNCWidth);
ser.Sync("VSYNCCounter", ref VSYNCCounter);
ser.SyncEnum(nameof(ChipType), ref ChipType);
ser.Sync(nameof(HSYNC), ref HSYNC);
ser.Sync(nameof(VSYNC), ref VSYNC);
ser.Sync(nameof(DISPTMG), ref DISPTMG);
ser.Sync(nameof(MA), ref MA);
ser.Sync(nameof(CurrentByteAddress), ref CurrentByteAddress);
ser.Sync(nameof(ByteCounter), ref ByteCounter);
ser.Sync(nameof(Regs), ref Regs, false);
ser.Sync(nameof(SelectedRegister), ref SelectedRegister);
ser.Sync(nameof(HCC), ref HCC);
ser.Sync(nameof(VCC), ref VCC);
ser.Sync(nameof(VLC), ref VLC);
ser.Sync(nameof(CycleCounter), ref CycleCounter);
ser.Sync(nameof(EndOfScreen), ref EndOfScreen);
ser.Sync(nameof(HSYNCWidth), ref HSYNCWidth);
ser.Sync(nameof(HSYNCCounter), ref HSYNCCounter);
ser.Sync(nameof(VSYNCWidth), ref VSYNCWidth);
ser.Sync(nameof(VSYNCCounter), ref VSYNCCounter);
ser.EndSection();
}

69
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Display/CRTC6845.cs
View File

@ -2326,44 +2326,39 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.BeginSection("CRCT");
ser.SyncEnum("ChipType", ref ChipType);
ser.Sync("_VSYNC", ref _VSYNC);
ser.Sync("_HSYNC", ref _HSYNC);
ser.Sync("_DISPTMG", ref _DISPTMG);
ser.Sync("_CUDISP", ref _CUDISP);
ser.Sync("_CLK", ref _CLK);
ser.Sync("_RESET", ref _RESET);
ser.Sync("_LPSTB", ref _LPSTB);
ser.Sync("AddressRegister", ref AddressRegister);
ser.Sync("Register", ref Register, false);
ser.Sync("StatusRegister", ref StatusRegister);
ser.Sync("_CharacterCTR", ref _CharacterCTR);
ser.Sync("_HorizontalSyncWidthCTR", ref _HorizontalSyncWidthCTR);
ser.Sync("_LineCTR", ref _LineCTR);
ser.Sync("_RasterCTR", ref _RasterCTR);
ser.Sync("StartAddressLatch)", ref StartAddressLatch);
//ser.Sync("VDisplay", ref VDisplay);
//ser.Sync("HDisplay", ref HDisplay);
ser.Sync("RowSelects", ref RowSelects);
ser.Sync("DISPTMG_Delay_Counter", ref DISPTMG_Delay_Counter);
ser.Sync("CUDISP_Delay_Counter", ref CUDISP_Delay_Counter);
ser.Sync("AsicStatusRegister1", ref AsicStatusRegister1);
ser.Sync("AsicStatusRegister2", ref AsicStatusRegister2);
ser.Sync("LAG_Counter", ref LAG_Counter);
ser.Sync("LAG_Counter_Latch", ref LAG_Counter_Latch);
ser.Sync("LAG_Counter_RowLatch", ref LAG_Counter_RowLatch);
ser.Sync("s_VS", ref s_VS);
ser.Sync("s_HDISP", ref s_VS);
ser.Sync("s_VDISP", ref s_VDISP);
ser.Sync("s_HSYNC", ref s_HSYNC);
ser.Sync("CUR_Field_Counter", ref CUR_Field_Counter);
//ser.Sync("VS", ref VS);
ser.SyncEnum(nameof(ChipType), ref ChipType);
ser.Sync(nameof(_VSYNC), ref _VSYNC);
ser.Sync(nameof(_HSYNC), ref _HSYNC);
ser.Sync(nameof(_DISPTMG), ref _DISPTMG);
ser.Sync(nameof(_CUDISP), ref _CUDISP);
ser.Sync(nameof(_CLK), ref _CLK);
ser.Sync(nameof(_RESET), ref _RESET);
ser.Sync(nameof(_LPSTB), ref _LPSTB);
ser.Sync(nameof(AddressRegister), ref AddressRegister);
ser.Sync(nameof(Register), ref Register, false);
ser.Sync(nameof(StatusRegister), ref StatusRegister);
ser.Sync(nameof(_CharacterCTR), ref _CharacterCTR);
ser.Sync(nameof(_HorizontalSyncWidthCTR), ref _HorizontalSyncWidthCTR);
ser.Sync(nameof(_LineCTR), ref _LineCTR);
ser.Sync(nameof(_RasterCTR), ref _RasterCTR);
ser.Sync(nameof(StartAddressLatch), ref StartAddressLatch);
//ser.Sync(nameof(VDisplay), ref VDisplay);
//ser.Sync(nameof(HDisplay), ref HDisplay);
ser.Sync(nameof(RowSelects), ref RowSelects);
ser.Sync(nameof(DISPTMG_Delay_Counter), ref DISPTMG_Delay_Counter);
ser.Sync(nameof(CUDISP_Delay_Counter), ref CUDISP_Delay_Counter);
ser.Sync(nameof(AsicStatusRegister1), ref AsicStatusRegister1);
ser.Sync(nameof(AsicStatusRegister2), ref AsicStatusRegister2);
ser.Sync(nameof(LAG_Counter), ref LAG_Counter);
ser.Sync(nameof(LAG_Counter_Latch), ref LAG_Counter_Latch);
ser.Sync(nameof(LAG_Counter_RowLatch), ref LAG_Counter_RowLatch);
ser.Sync(nameof(s_VS), ref s_VS);
ser.Sync(nameof(s_HDISP), ref s_VS);
ser.Sync(nameof(s_VDISP), ref s_VDISP);
ser.Sync(nameof(s_HSYNC), ref s_HSYNC);
ser.Sync(nameof(CUR_Field_Counter), ref CUR_Field_Counter);
//ser.Sync(nameof(VS), ref VS);
ser.EndSection();
/*
* int ;
int ;
* */
}
#endregion

4
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/Display/CRTDevice.cs
View File

@ -256,8 +256,8 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
ser.Sync("BufferHeight", ref _bufferHeight);
ser.Sync("VirtualHeight", ref _virtualHeight);
ser.Sync("VirtualWidth", ref _virtualWidth);
ser.Sync("ScreenBuffer", ref ScreenBuffer, false);
ser.Sync("ScanlineCounter", ref ScanlineCounter);
ser.Sync(nameof(ScreenBuffer), ref ScreenBuffer, false);
ser.Sync(nameof(ScanlineCounter), ref ScanlineCounter);
ser.EndSection();
}

2
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/PPI/PPI_8255.cs
View File

@ -455,7 +455,7 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.BeginSection("PPI");
ser.Sync("Regs", ref Regs, false);
ser.Sync(nameof(Regs), ref Regs, false);
ser.EndSection();
}

84
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/SoundOutput/AY38912.cs
View File

@ -827,50 +827,50 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
ser.BeginSection("PSG-AY");
ser.Sync("ActiveFunction", ref ActiveFunction);
ser.Sync(nameof(ActiveFunction), ref ActiveFunction);
ser.Sync("_tStatesPerFrame", ref _tStatesPerFrame);
ser.Sync("_sampleRate", ref _sampleRate);
ser.Sync("_samplesPerFrame", ref _samplesPerFrame);
//ser.Sync("_tStatesPerSample", ref _tStatesPerSample);
ser.Sync("_audioBufferIndex", ref _audioBufferIndex);
ser.Sync("_audioBuffer", ref _audioBuffer, false);
ser.Sync("PortAInput", ref PortAInput);
ser.Sync("PortBInput", ref PortBInput);
ser.Sync(nameof(_tStatesPerFrame), ref _tStatesPerFrame);
ser.Sync(nameof(_sampleRate), ref _sampleRate);
ser.Sync(nameof(_samplesPerFrame), ref _samplesPerFrame);
//ser.Sync(nameof(_tStatesPerSample), ref _tStatesPerSample);
ser.Sync(nameof(_audioBufferIndex), ref _audioBufferIndex);
ser.Sync(nameof(_audioBuffer), ref _audioBuffer, false);
ser.Sync(nameof(PortAInput), ref PortAInput);
ser.Sync(nameof(PortBInput), ref PortBInput);
ser.Sync("_registers", ref _registers, false);
ser.Sync("_activeRegister", ref _activeRegister);
ser.Sync("_bitA", ref _bitA);
ser.Sync("_bitB", ref _bitB);
ser.Sync("_bitC", ref _bitC);
ser.Sync("_eState", ref _eState);
ser.Sync("_eDirection", ref _eDirection);
ser.Sync("_noiseSeed", ref _noiseSeed);
ser.Sync("_bit0", ref _bit0);
ser.Sync("_bit1", ref _bit1);
ser.Sync("_bit2", ref _bit2);
ser.Sync("_bit3", ref _bit3);
ser.Sync("_bit4", ref _bit4);
ser.Sync("_bit5", ref _bit5);
ser.Sync("_bitN", ref _bitN);
ser.Sync("_eMaskA", ref _eMaskA);
ser.Sync("_eMaskB", ref _eMaskB);
ser.Sync("_eMaskC", ref _eMaskC);
ser.Sync("_vA", ref _vA);
ser.Sync("_vB", ref _vB);
ser.Sync("_vC", ref _vC);
ser.Sync("_countA", ref _countA);
ser.Sync("_countB", ref _countB);
ser.Sync("_countC", ref _countC);
ser.Sync("_countE", ref _countE);
ser.Sync("_countN", ref _countN);
ser.Sync("_dividerA", ref _dividerA);
ser.Sync("_dividerB", ref _dividerB);
ser.Sync("_dividerC", ref _dividerC);
ser.Sync("_dividerE", ref _dividerE);
ser.Sync("_dividerN", ref _dividerN);
ser.SyncEnum("_currentPanTab", ref _currentPanTab);
ser.Sync("_volume", ref nullDump);
ser.Sync(nameof(_registers), ref _registers, false);
ser.Sync(nameof(_activeRegister), ref _activeRegister);
ser.Sync(nameof(_bitA), ref _bitA);
ser.Sync(nameof(_bitB), ref _bitB);
ser.Sync(nameof(_bitC), ref _bitC);
ser.Sync(nameof(_eState), ref _eState);
ser.Sync(nameof(_eDirection), ref _eDirection);
ser.Sync(nameof(_noiseSeed), ref _noiseSeed);
ser.Sync(nameof(_bit0), ref _bit0);
ser.Sync(nameof(_bit1), ref _bit1);
ser.Sync(nameof(_bit2), ref _bit2);
ser.Sync(nameof(_bit3), ref _bit3);
ser.Sync(nameof(_bit4), ref _bit4);
ser.Sync(nameof(_bit5), ref _bit5);
ser.Sync(nameof(_bitN), ref _bitN);
ser.Sync(nameof(_eMaskA), ref _eMaskA);
ser.Sync(nameof(_eMaskB), ref _eMaskB);
ser.Sync(nameof(_eMaskC), ref _eMaskC);
ser.Sync(nameof(_vA), ref _vA);
ser.Sync(nameof(_vB), ref _vB);
ser.Sync(nameof(_vC), ref _vC);
ser.Sync(nameof(_countA), ref _countA);
ser.Sync(nameof(_countB), ref _countB);
ser.Sync(nameof(_countC), ref _countC);
ser.Sync(nameof(_countE), ref _countE);
ser.Sync(nameof(_countN), ref _countN);
ser.Sync(nameof(_dividerA), ref _dividerA);
ser.Sync(nameof(_dividerB), ref _dividerB);
ser.Sync(nameof(_dividerC), ref _dividerC);
ser.Sync(nameof(_dividerE), ref _dividerE);
ser.Sync(nameof(_dividerN), ref _dividerN);
ser.SyncEnum(nameof(_currentPanTab), ref _currentPanTab);
ser.Sync(nameof(_volume), ref nullDump);
for (int i = 0; i < 6; i++)
{

8
BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/SoundOutput/Beeper.cs
View File

@ -202,10 +202,10 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.BeginSection("Buzzer");
ser.Sync("_tStatesPerFrame", ref _tStatesPerFrame);
ser.Sync("_sampleRate", ref _sampleRate);
ser.Sync("LastPulse", ref LastPulse);
ser.Sync("LastPulseTState", ref LastPulseTState);
ser.Sync(nameof(_tStatesPerFrame), ref _tStatesPerFrame);
ser.Sync(nameof(_sampleRate), ref _sampleRate);
ser.Sync(nameof(LastPulse), ref LastPulse);
ser.Sync(nameof(LastPulseTState), ref LastPulseTState);
ser.EndSection();
}

48
BizHawk.Emulation.Cores/Computers/AmstradCPC/Machine/CPCBase.cs
View File

@ -319,29 +319,29 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public void SyncState(Serializer ser)
{
ser.BeginSection("CPCMachine");
ser.Sync("FrameCompleted", ref FrameCompleted);
ser.Sync("OverFlow", ref OverFlow);
ser.Sync("FrameCount", ref FrameCount);
ser.Sync("_frameCycles", ref _frameCycles);
ser.Sync("inputRead", ref inputRead);
ser.Sync("LastFrameStartCPUTick", ref LastFrameStartCPUTick);
ser.Sync("ROMLower", ref ROMLower, false);
ser.Sync("ROM0", ref ROM0, false);
ser.Sync("ROM7", ref ROM7, false);
ser.Sync("RAM0", ref RAM0, false);
ser.Sync("RAM1", ref RAM1, false);
ser.Sync("RAM2", ref RAM2, false);
ser.Sync("RAM3", ref RAM3, false);
ser.Sync("RAM4", ref RAM4, false);
ser.Sync("RAM5", ref RAM5, false);
ser.Sync("RAM6", ref RAM6, false);
ser.Sync("RAM7", ref RAM7, false);
ser.Sync(nameof(FrameCompleted), ref FrameCompleted);
ser.Sync(nameof(OverFlow), ref OverFlow);
ser.Sync(nameof(FrameCount), ref FrameCount);
ser.Sync(nameof(_frameCycles), ref _frameCycles);
ser.Sync(nameof(inputRead), ref inputRead);
ser.Sync(nameof(LastFrameStartCPUTick), ref LastFrameStartCPUTick);
ser.Sync(nameof(ROMLower), ref ROMLower, false);
ser.Sync(nameof(ROM0), ref ROM0, false);
ser.Sync(nameof(ROM7), ref ROM7, false);
ser.Sync(nameof(RAM0), ref RAM0, false);
ser.Sync(nameof(RAM1), ref RAM1, false);
ser.Sync(nameof(RAM2), ref RAM2, false);
ser.Sync(nameof(RAM3), ref RAM3, false);
ser.Sync(nameof(RAM4), ref RAM4, false);
ser.Sync(nameof(RAM5), ref RAM5, false);
ser.Sync(nameof(RAM6), ref RAM6, false);
ser.Sync(nameof(RAM7), ref RAM7, false);
ser.Sync("UpperROMPosition", ref UpperROMPosition);
ser.Sync("UpperROMPaged", ref UpperROMPaged);
ser.Sync("LowerROMPaged", ref LowerROMPaged);
ser.Sync("RAMConfig", ref RAMConfig);
ser.Sync("RAM64KBank", ref RAM64KBank);
ser.Sync(nameof(UpperROMPosition), ref UpperROMPosition);
ser.Sync(nameof(UpperROMPaged), ref UpperROMPaged);
ser.Sync(nameof(LowerROMPaged), ref LowerROMPaged);
ser.Sync(nameof(RAMConfig), ref RAMConfig);
ser.Sync(nameof(RAM64KBank), ref RAM64KBank);
CRCT.SyncState(ser);
//CRT.SyncState(ser);
@ -350,13 +350,13 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
TapeBuzzer.SyncState(ser);
AYDevice.SyncState(ser);
ser.Sync("tapeMediaIndex", ref tapeMediaIndex);
ser.Sync(nameof(tapeMediaIndex), ref tapeMediaIndex);
if (ser.IsReader)
TapeMediaIndex = tapeMediaIndex;
TapeDevice.SyncState(ser);
ser.Sync("diskMediaIndex", ref diskMediaIndex);
ser.Sync(nameof(diskMediaIndex), ref diskMediaIndex);
if (ser.IsReader)
DiskMediaIndex = diskMediaIndex;

14
BizHawk.Emulation.Cores/Computers/AmstradCPC/Media/Disk/CPCExtendedFloppyDisk.cs
View File

@ -236,20 +236,20 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
ser.BeginSection("Plus3FloppyDisk");
ser.Sync("CylinderCount", ref CylinderCount);
ser.Sync("SideCount", ref SideCount);
ser.Sync("BytesPerTrack", ref BytesPerTrack);
ser.Sync("WriteProtected", ref WriteProtected);
ser.SyncEnum("Protection", ref Protection);
ser.Sync(nameof(CylinderCount), ref CylinderCount);
ser.Sync(nameof(SideCount), ref SideCount);
ser.Sync(nameof(BytesPerTrack), ref BytesPerTrack);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
ser.SyncEnum(nameof(Protection), ref Protection);
ser.Sync("DirtyData", ref DirtyData);
ser.Sync(nameof(DirtyData), ref DirtyData);
if (DirtyData)
{
}
// sync deterministic track and sector counters
ser.Sync(" _randomCounter", ref _randomCounter);
ser.Sync(nameof( _randomCounter), ref _randomCounter);
RandomCounter = _randomCounter;
ser.EndSection();

12
BizHawk.Emulation.Cores/Computers/AmstradCPC/Media/Disk/CPCFloppyDisk.cs
View File

@ -223,13 +223,13 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
ser.BeginSection("Plus3FloppyDisk");
ser.Sync("CylinderCount", ref CylinderCount);
ser.Sync("SideCount", ref SideCount);
ser.Sync("BytesPerTrack", ref BytesPerTrack);
ser.Sync("WriteProtected", ref WriteProtected);
ser.SyncEnum("Protection", ref Protection);
ser.Sync(nameof(CylinderCount), ref CylinderCount);
ser.Sync(nameof(SideCount), ref SideCount);
ser.Sync(nameof(BytesPerTrack), ref BytesPerTrack);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
ser.SyncEnum(nameof(Protection), ref Protection);
ser.Sync("DirtyData", ref DirtyData);
ser.Sync(nameof(DirtyData), ref DirtyData);
if (DirtyData)
{

10
BizHawk.Emulation.Cores/Computers/AmstradCPC/Media/Tape/TapeDataBlock.cs
View File

@ -172,11 +172,11 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
ser.BeginSection("DataBlock" + blockPosition);
ser.Sync("_blockID", ref _blockID);
//ser.SyncFixedString("_blockDescription", ref _blockDescription, 200);
ser.SyncEnum("_blockType", ref _blockType);
ser.Sync("_blockData", ref _blockData, true);
ser.SyncEnum("_command", ref _command);
ser.Sync(nameof(_blockID), ref _blockID);
//ser.SyncFixedString(nameof(_blockDescription), ref _blockDescription, 200);
ser.SyncEnum(nameof(_blockType), ref _blockType);
ser.Sync(nameof(_blockData), ref _blockData, true);
ser.SyncEnum(nameof(_command), ref _command);
int[] tempArray = null;

8
BizHawk.Emulation.Cores/Computers/AppleII/AppleII.IStatable.cs
View File

@ -41,13 +41,13 @@ namespace BizHawk.Emulation.Cores.Computers.AppleII
{
// this is much faster than other possibilities for serialization
w.WriteStartObject();
w.WritePropertyName("Frame");
w.WritePropertyName(nameof(Frame));
w.WriteValue(Frame);
w.WritePropertyName("LagCount");
w.WritePropertyName(nameof(LagCount));
w.WriteValue(LagCount);
w.WritePropertyName("IsLagFrame");
w.WritePropertyName(nameof(IsLagFrame));
w.WriteValue(IsLagFrame);
w.WritePropertyName("CurrentDisk");
w.WritePropertyName(nameof(CurrentDisk));
w.WriteValue(CurrentDisk);
w.WritePropertyName("PreviousDiskPressed");
w.WriteValue(_prevPressed);

10
BizHawk.Emulation.Cores/Computers/Commodore64/C64.IStatable.cs
View File

@ -43,11 +43,11 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64
private void SyncState(Serializer ser)
{
ser.BeginSection("core");
ser.Sync("_frameCycles", ref _frameCycles);
ser.Sync("Frame", ref _frame);
ser.Sync("IsLagFrame", ref _isLagFrame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("CurrentDisk", ref _currentDisk);
ser.Sync(nameof(_frameCycles), ref _frameCycles);
ser.Sync(nameof(Frame), ref _frame);
ser.Sync(nameof(IsLagFrame), ref _isLagFrame);
ser.Sync(nameof(LagCount), ref _lagCount);
ser.Sync(nameof(CurrentDisk), ref _currentDisk);
ser.Sync("PreviousDiskPressed", ref _prevPressed);
ser.Sync("NextDiskPressed", ref _nextPressed);
ser.BeginSection("Board");

48
BizHawk.Emulation.Cores/Computers/Commodore64/C64.Motherboard.cs
View File

@ -278,83 +278,83 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64
public void SyncState(Serializer ser)
{
ser.BeginSection("Cia0");
ser.BeginSection(nameof(Cia0));
Cia0.SyncState(ser);
ser.EndSection();
ser.BeginSection("Cia1");
ser.BeginSection(nameof(Cia1));
Cia1.SyncState(ser);
ser.EndSection();
ser.BeginSection("ColorRam");
ser.BeginSection(nameof(ColorRam));
ColorRam.SyncState(ser);
ser.EndSection();
ser.BeginSection("Cpu");
ser.BeginSection(nameof(Cpu));
Cpu.SyncState(ser);
ser.EndSection();
ser.BeginSection("Pla");
ser.BeginSection(nameof(Pla));
Pla.SyncState(ser);
ser.EndSection();
ser.BeginSection("Ram");
ser.BeginSection(nameof(Ram));
Ram.SyncState(ser);
ser.EndSection();
ser.BeginSection("Sid");
ser.BeginSection(nameof(Sid));
Sid.SyncState(ser);
ser.EndSection();
ser.BeginSection("Vic");
ser.BeginSection(nameof(Vic));
Vic.SyncState(ser);
ser.EndSection();
if (CartPort.IsConnected)
{
ser.BeginSection("CartPort");
ser.BeginSection(nameof(CartPort));
CartPort.SyncState(ser);
ser.EndSection();
}
ser.BeginSection("Cassette");
ser.BeginSection(nameof(Cassette));
Cassette.SyncState(ser);
ser.EndSection();
ser.BeginSection("Serial");
ser.BeginSection(nameof(Serial));
Serial.SyncState(ser);
ser.EndSection();
if (TapeDrive != null) // TODO: a tape object is already in a nested class, is it the same reference? do we need this?
{
ser.BeginSection("TapeDrive");
ser.BeginSection(nameof(TapeDrive));
TapeDrive.SyncState(ser);
ser.EndSection();
}
ser.BeginSection("User");
ser.BeginSection(nameof(User));
User.SyncState(ser);
ser.EndSection();
if (DiskDrive != null) // TODO: a disk object is already in a nested class, is it the same reference? do we need this?
{
ser.BeginSection("DiskDrive");
ser.BeginSection(nameof(DiskDrive));
DiskDrive.SyncState(ser);
ser.EndSection();
}
ser.Sync("Bus", ref Bus);
ser.Sync("InputRead", ref InputRead);
ser.Sync("Irq", ref Irq);
ser.Sync("Nmi", ref Nmi);
ser.Sync(nameof(Bus), ref Bus);
ser.Sync(nameof(InputRead), ref InputRead);
ser.Sync(nameof(Irq), ref Irq);
ser.Sync(nameof(Nmi), ref Nmi);
ser.Sync("_lastReadVicAddress", ref _lastReadVicAddress);
ser.Sync("_lastReadVicData", ref _lastReadVicData);
ser.Sync("_vicBank", ref _vicBank);
ser.Sync(nameof(_lastReadVicAddress), ref _lastReadVicAddress);
ser.Sync(nameof(_lastReadVicData), ref _lastReadVicData);
ser.Sync(nameof(_vicBank), ref _vicBank);
ser.Sync("_joystickPressed", ref _joystickPressed, useNull: false);
ser.Sync("_keyboardPressed", ref _keyboardPressed, useNull: false);
ser.Sync("_restorePressed", ref _restorePressed);
ser.Sync(nameof(_joystickPressed), ref _joystickPressed, useNull: false);
ser.Sync(nameof(_keyboardPressed), ref _keyboardPressed, useNull: false);
ser.Sync(nameof(_restorePressed), ref _restorePressed);
}
}
}

14
BizHawk.Emulation.Cores/Computers/Commodore64/Cartridge/CartridgeDevice.cs
View File

@ -229,14 +229,14 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.Cartridge
public virtual void SyncState(Serializer ser)
{
ser.Sync("pinExRom", ref pinExRom);
ser.Sync("pinGame", ref pinGame);
ser.Sync("pinIRQ", ref pinIRQ);
ser.Sync("pinNMI", ref pinNMI);
ser.Sync("pinReset", ref pinReset);
ser.Sync(nameof(pinExRom), ref pinExRom);
ser.Sync(nameof(pinGame), ref pinGame);
ser.Sync(nameof(pinIRQ), ref pinIRQ);
ser.Sync(nameof(pinNMI), ref pinNMI);
ser.Sync(nameof(pinReset), ref pinReset);
ser.Sync("_driveLightEnabled", ref _driveLightEnabled);
ser.Sync("_driveLightOn", ref _driveLightOn);
ser.Sync(nameof(_driveLightEnabled), ref _driveLightEnabled);
ser.Sync(nameof(_driveLightOn), ref _driveLightOn);
}
public bool Valid => validCartridge;

4
BizHawk.Emulation.Cores/Computers/Commodore64/Cartridge/CartridgePort.cs
View File

@ -127,9 +127,9 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.Cartridge
public void SyncState(Serializer ser)
{
ser.Sync("_connected", ref _connected);
ser.Sync(nameof(_connected), ref _connected);
ser.BeginSection("CartridgeDevice");
ser.BeginSection(nameof(CartridgeDevice));
_cartridgeDevice.SyncState(ser);
ser.EndSection();
}

4
BizHawk.Emulation.Cores/Computers/Commodore64/Cartridge/Mapper000F.cs
View File

@ -133,8 +133,8 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.Cartridge
public override void SyncState(Serializer ser)
{
ser.Sync("_bankMask", ref _bankMask);
ser.Sync("_bankNumber", ref _bankNumber);
ser.Sync(nameof(_bankMask), ref _bankMask);
ser.Sync(nameof(_bankNumber), ref _bankNumber);
base.SyncState(ser);
if (ser.IsReader)
{

2
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Chip2114.cs
View File

@ -42,7 +42,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_ram", ref _ram, useNull: false);
ser.Sync(nameof(_ram), ref _ram, useNull: false);
}
public void Write(int addr, int val)

2
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Chip4864.cs
View File

@ -48,7 +48,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_ram", ref _ram, useNull: false);
ser.Sync(nameof(_ram), ref _ram, useNull: false);
}
public void Write(int addr, int val)

8
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Chip6510.cs
View File

@ -219,14 +219,14 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
_cpu.SyncState(ser);
ser.EndSection();
ser.Sync("_pinNmiLast", ref _pinNmiLast);
ser.Sync(nameof(_pinNmiLast), ref _pinNmiLast);
ser.BeginSection("_port");
ser.BeginSection(nameof(_port));
_port.SyncState(ser);
ser.EndSection();
ser.Sync("_thisNmi", ref _thisNmi);
ser.Sync("LagCycles", ref LagCycles);
ser.Sync(nameof(_thisNmi), ref _thisNmi);
ser.Sync(nameof(LagCycles), ref LagCycles);
}
public void Write(int addr, int val)

28
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Chip90611401.cs
View File

@ -307,20 +307,20 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_p24", ref _p24);
ser.Sync("_p25", ref _p25);
ser.Sync("_p26", ref _p26);
ser.Sync("_p27", ref _p27);
ser.Sync("_p28", ref _p28);
ser.Sync("_loram", ref _loram);
ser.Sync("_hiram", ref _hiram);
ser.Sync("_game", ref _game);
ser.Sync("_exrom", ref _exrom);
ser.Sync("_charen", ref _charen);
ser.Sync("_a15", ref _a15);
ser.Sync("_a14", ref _a14);
ser.Sync("_a13", ref _a13);
ser.Sync("_a12", ref _a12);
ser.Sync(nameof(_p24), ref _p24);
ser.Sync(nameof(_p25), ref _p25);
ser.Sync(nameof(_p26), ref _p26);
ser.Sync(nameof(_p27), ref _p27);
ser.Sync(nameof(_p28), ref _p28);
ser.Sync(nameof(_loram), ref _loram);
ser.Sync(nameof(_hiram), ref _hiram);
ser.Sync(nameof(_game), ref _game);
ser.Sync(nameof(_exrom), ref _exrom);
ser.Sync(nameof(_charen), ref _charen);
ser.Sync(nameof(_a15), ref _a15);
ser.Sync(nameof(_a14), ref _a14);
ser.Sync(nameof(_a13), ref _a13);
ser.Sync(nameof(_a12), ref _a12);
}
public int VicRead(int addr)

88
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Cia.cs
View File

@ -533,51 +533,51 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("DelayedInterrupts", ref DelayedInterrupts);
ser.Sync("_pra", ref _pra);
ser.Sync("_prb", ref _prb);
ser.Sync("_ddra", ref _ddra);
ser.Sync("_ddrb", ref _ddrb);
ser.Sync("_ta", ref _ta);
ser.Sync("_tb", ref _tb);
ser.Sync("_latcha", ref _latcha);
ser.Sync("_latchb", ref _latchb);
ser.Sync("_tod10Ths", ref _tod10Ths);
ser.Sync("_todSec", ref _todSec);
ser.Sync("_todMin", ref _todMin);
ser.Sync("_todHr", ref _todHr);
ser.Sync("_latch10Ths", ref _latch10Ths);
ser.Sync("_latchSec", ref _latchSec);
ser.Sync("_latchMin", ref _latchMin);
ser.Sync("_latchHr", ref _latchHr);
ser.Sync("_alm10Ths", ref _alm10Ths);
ser.Sync("_almSec", ref _almSec);
ser.Sync("_almMin", ref _almMin);
ser.Sync("_almHr", ref _almHr);
ser.Sync("_sdr", ref _sdr);
ser.Sync("_icr", ref _icr);
ser.Sync("_cra", ref _cra);
ser.Sync("_crb", ref _crb);
ser.Sync("_intMask", ref _intMask);
ser.Sync("_todLatch", ref _todLatch);
ser.Sync("_taCntPhi2", ref _taCntPhi2);
ser.Sync("_taCntCnt", ref _taCntCnt);
ser.Sync("_tbCntPhi2", ref _tbCntPhi2);
ser.Sync("_tbCntTa", ref _tbCntTa);
ser.Sync("_tbCntCnt", ref _tbCntCnt);
ser.Sync("_taIrqNextCycle", ref _taIrqNextCycle);
ser.Sync("_taPrb6NegativeNextCycle", ref _taPrb6NegativeNextCycle);
ser.Sync("_tbIrqNextCycle", ref _tbIrqNextCycle);
ser.Sync("_tbPrb7NegativeNextCycle", ref _tbPrb7NegativeNextCycle);
ser.Sync("_hasNewCra", ref _hasNewCra);
ser.Sync("_hasNewCrb", ref _hasNewCrb);
ser.SyncEnum("_taState", ref _taState);
ser.SyncEnum("_tbState", ref _tbState);
ser.Sync("_newCra", ref _newCra);
ser.Sync("_newCrb", ref _newCrb);
ser.Sync("_flagLatch", ref _flagLatch);
ser.Sync(nameof(DelayedInterrupts), ref DelayedInterrupts);
ser.Sync(nameof(_pra), ref _pra);
ser.Sync(nameof(_prb), ref _prb);
ser.Sync(nameof(_ddra), ref _ddra);
ser.Sync(nameof(_ddrb), ref _ddrb);
ser.Sync(nameof(_ta), ref _ta);
ser.Sync(nameof(_tb), ref _tb);
ser.Sync(nameof(_latcha), ref _latcha);
ser.Sync(nameof(_latchb), ref _latchb);
ser.Sync(nameof(_tod10Ths), ref _tod10Ths);
ser.Sync(nameof(_todSec), ref _todSec);
ser.Sync(nameof(_todMin), ref _todMin);
ser.Sync(nameof(_todHr), ref _todHr);
ser.Sync(nameof(_latch10Ths), ref _latch10Ths);
ser.Sync(nameof(_latchSec), ref _latchSec);
ser.Sync(nameof(_latchMin), ref _latchMin);
ser.Sync(nameof(_latchHr), ref _latchHr);
ser.Sync(nameof(_alm10Ths), ref _alm10Ths);
ser.Sync(nameof(_almSec), ref _almSec);
ser.Sync(nameof(_almMin), ref _almMin);
ser.Sync(nameof(_almHr), ref _almHr);
ser.Sync(nameof(_sdr), ref _sdr);
ser.Sync(nameof(_icr), ref _icr);
ser.Sync(nameof(_cra), ref _cra);
ser.Sync(nameof(_crb), ref _crb);
ser.Sync(nameof(_intMask), ref _intMask);
ser.Sync(nameof(_todLatch), ref _todLatch);
ser.Sync(nameof(_taCntPhi2), ref _taCntPhi2);
ser.Sync(nameof(_taCntCnt), ref _taCntCnt);
ser.Sync(nameof(_tbCntPhi2), ref _tbCntPhi2);
ser.Sync(nameof(_tbCntTa), ref _tbCntTa);
ser.Sync(nameof(_tbCntCnt), ref _tbCntCnt);
ser.Sync(nameof(_taIrqNextCycle), ref _taIrqNextCycle);
ser.Sync(nameof(_taPrb6NegativeNextCycle), ref _taPrb6NegativeNextCycle);
ser.Sync(nameof(_tbIrqNextCycle), ref _tbIrqNextCycle);
ser.Sync(nameof(_tbPrb7NegativeNextCycle), ref _tbPrb7NegativeNextCycle);
ser.Sync(nameof(_hasNewCra), ref _hasNewCra);
ser.Sync(nameof(_hasNewCrb), ref _hasNewCrb);
ser.SyncEnum(nameof(_taState), ref _taState);
ser.SyncEnum(nameof(_tbState), ref _tbState);
ser.Sync(nameof(_newCra), ref _newCra);
ser.Sync(nameof(_newCrb), ref _newCrb);
ser.Sync(nameof(_flagLatch), ref _flagLatch);
ser.Sync("_todCounter", ref _todCounter);
ser.Sync(nameof(_todCounter), ref _todCounter);
}
}
}

8
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/LatchedPort.cs
View File

@ -37,8 +37,8 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("Direction", ref Direction);
ser.Sync("Latch", ref Latch);
ser.Sync(nameof(Direction), ref Direction);
ser.Sync(nameof(Latch), ref Latch);
}
}
@ -78,8 +78,8 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("Direction", ref Direction);
ser.Sync("Latch", ref Latch);
ser.Sync(nameof(Direction), ref Direction);
ser.Sync(nameof(Latch), ref Latch);
}
}
}

26
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Sid.Envelope.cs
View File

@ -235,19 +235,19 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_attack", ref _attack);
ser.Sync("_decay", ref _decay);
ser.Sync("_delay", ref _delay);
ser.Sync("_envCounter", ref _envCounter);
ser.Sync("_expCounter", ref _expCounter);
ser.Sync("_expPeriod", ref _expPeriod);
ser.Sync("_freeze", ref _freeze);
ser.Sync("_lfsr", ref _lfsr);
ser.Sync("_gate", ref _gate);
ser.Sync("_rate", ref _rate);
ser.Sync("_release", ref _release);
ser.Sync("_state", ref _state);
ser.Sync("_sustain", ref _sustain);
ser.Sync(nameof(_attack), ref _attack);
ser.Sync(nameof(_decay), ref _decay);
ser.Sync(nameof(_delay), ref _delay);
ser.Sync(nameof(_envCounter), ref _envCounter);
ser.Sync(nameof(_expCounter), ref _expCounter);
ser.Sync(nameof(_expPeriod), ref _expPeriod);
ser.Sync(nameof(_freeze), ref _freeze);
ser.Sync(nameof(_lfsr), ref _lfsr);
ser.Sync(nameof(_gate), ref _gate);
ser.Sync(nameof(_rate), ref _rate);
ser.Sync(nameof(_release), ref _release);
ser.Sync(nameof(_state), ref _state);
ser.Sync(nameof(_sustain), ref _sustain);
}
// ------------------------------------

48
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Sid.Voice.cs
View File

@ -276,30 +276,30 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
// ------------------------------------
public void SyncState(Serializer ser)
{
ser.Sync("_accBits", ref _accBits);
ser.Sync("_accNext", ref _accNext);
ser.Sync("_accumulator", ref _accumulator);
ser.Sync("_controlTestPrev", ref _controlTestPrev);
ser.Sync("_controlWavePrev", ref _controlWavePrev);
ser.Sync("_delay", ref _delay);
ser.Sync("_floatOutputTtl", ref _floatOutputTtl);
ser.Sync("_frequency", ref _frequency);
ser.Sync("_msbRising", ref _msbRising);
ser.Sync("_noise", ref _noise);
ser.Sync("_noNoise", ref _noNoise);
ser.Sync("_noNoiseOrNoise", ref _noNoiseOrNoise);
ser.Sync("_noPulse", ref _noPulse);
ser.Sync("_output", ref _output);
ser.Sync("_pulse", ref _pulse);
ser.Sync("_pulseWidth", ref _pulseWidth);
ser.Sync("_ringMod", ref _ringMod);
ser.Sync("_ringMsbMask", ref _ringMsbMask);
ser.Sync("_shiftRegister", ref _shiftRegister);
ser.Sync("_shiftRegisterReset", ref _shiftRegisterReset);
ser.Sync("_sync", ref _sync);
ser.Sync("_test", ref _test);
ser.Sync("_waveform", ref _waveform);
ser.Sync("_waveformIndex", ref _waveformIndex);
ser.Sync(nameof(_accBits), ref _accBits);
ser.Sync(nameof(_accNext), ref _accNext);
ser.Sync(nameof(_accumulator), ref _accumulator);
ser.Sync(nameof(_controlTestPrev), ref _controlTestPrev);
ser.Sync(nameof(_controlWavePrev), ref _controlWavePrev);
ser.Sync(nameof(_delay), ref _delay);
ser.Sync(nameof(_floatOutputTtl), ref _floatOutputTtl);
ser.Sync(nameof(_frequency), ref _frequency);
ser.Sync(nameof(_msbRising), ref _msbRising);
ser.Sync(nameof(_noise), ref _noise);
ser.Sync(nameof(_noNoise), ref _noNoise);
ser.Sync(nameof(_noNoiseOrNoise), ref _noNoiseOrNoise);
ser.Sync(nameof(_noPulse), ref _noPulse);
ser.Sync(nameof(_output), ref _output);
ser.Sync(nameof(_pulse), ref _pulse);
ser.Sync(nameof(_pulseWidth), ref _pulseWidth);
ser.Sync(nameof(_ringMod), ref _ringMod);
ser.Sync(nameof(_ringMsbMask), ref _ringMsbMask);
ser.Sync(nameof(_shiftRegister), ref _shiftRegister);
ser.Sync(nameof(_shiftRegisterReset), ref _shiftRegisterReset);
ser.Sync(nameof(_sync), ref _sync);
ser.Sync(nameof(_test), ref _test);
ser.Sync(nameof(_waveform), ref _waveform);
ser.Sync(nameof(_waveformIndex), ref _waveformIndex);
_wave = _waveTable[_waveform & 0x07];
}

42
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Sid.cs
View File

@ -331,12 +331,12 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_databus", ref _databus);
ser.Sync("_cachedCycles", ref _cachedCycles);
ser.Sync("_disableVoice3", ref _disableVoice3);
ser.Sync("_envelopeOutput0", ref _envelopeOutput0);
ser.Sync("_envelopeOutput1", ref _envelopeOutput1);
ser.Sync("_envelopeOutput2", ref _envelopeOutput2);
ser.Sync(nameof(_databus), ref _databus);
ser.Sync(nameof(_cachedCycles), ref _cachedCycles);
ser.Sync(nameof(_disableVoice3), ref _disableVoice3);
ser.Sync(nameof(_envelopeOutput0), ref _envelopeOutput0);
ser.Sync(nameof(_envelopeOutput1), ref _envelopeOutput1);
ser.Sync(nameof(_envelopeOutput2), ref _envelopeOutput2);
for (int i = 0; i < _envelopes.Length; i++)
{
@ -345,20 +345,20 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
ser.EndSection();
}
ser.Sync("_filterEnable", ref _filterEnable, useNull: false);
ser.Sync("_filterFrequency", ref _filterFrequency);
ser.Sync("_filterResonance", ref _filterResonance);
ser.Sync("_filterSelectBandPass", ref _filterSelectBandPass);
ser.Sync("_filterSelectLoPass", ref _filterSelectLoPass);
ser.Sync("_filterSelectHiPass", ref _filterSelectHiPass);
ser.Sync("_mixer", ref _mixer);
ser.Sync("_potCounter", ref _potCounter);
ser.Sync("_potX", ref _potX);
ser.Sync("_potY", ref _potY);
ser.Sync("_sample", ref _sample);
ser.Sync("_voiceOutput0", ref _voiceOutput0);
ser.Sync("_voiceOutput1", ref _voiceOutput1);
ser.Sync("_voiceOutput2", ref _voiceOutput2);
ser.Sync(nameof(_filterEnable), ref _filterEnable, useNull: false);
ser.Sync(nameof(_filterFrequency), ref _filterFrequency);
ser.Sync(nameof(_filterResonance), ref _filterResonance);
ser.Sync(nameof(_filterSelectBandPass), ref _filterSelectBandPass);
ser.Sync(nameof(_filterSelectLoPass), ref _filterSelectLoPass);
ser.Sync(nameof(_filterSelectHiPass), ref _filterSelectHiPass);
ser.Sync(nameof(_mixer), ref _mixer);
ser.Sync(nameof(_potCounter), ref _potCounter);
ser.Sync(nameof(_potX), ref _potX);
ser.Sync(nameof(_potY), ref _potY);
ser.Sync(nameof(_sample), ref _sample);
ser.Sync(nameof(_voiceOutput0), ref _voiceOutput0);
ser.Sync(nameof(_voiceOutput1), ref _voiceOutput1);
ser.Sync(nameof(_voiceOutput2), ref _voiceOutput2);
for (int i = 0; i < _voices.Length; i++)
{
@ -367,7 +367,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
ser.EndSection();
}
ser.Sync("_volume", ref _volume);
ser.Sync(nameof(_volume), ref _volume);
}
}
}

2
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Via.Port.cs
View File

@ -127,7 +127,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_driveNumber", ref _driveNumber);
ser.Sync(nameof(_driveNumber), ref _driveNumber);
}
}
}

42
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Vic.Sprite.cs
View File

@ -54,27 +54,27 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("CollideData", ref CollideData);
ser.Sync("CollideSprite", ref CollideSprite);
ser.Sync("Color", ref Color);
ser.Sync("Display", ref Display);
ser.Sync("Dma", ref Dma);
ser.Sync("Enable", ref Enable);
ser.Sync("Loaded", ref Loaded);
ser.Sync("Mc", ref Mc);
ser.Sync("Mcbase", ref Mcbase);
ser.Sync("Multicolor", ref Multicolor);
ser.Sync("MulticolorCrunch", ref MulticolorCrunch);
ser.Sync("Pointer", ref Pointer);
ser.Sync("Priority", ref Priority);
ser.Sync("ShiftEnable", ref ShiftEnable);
ser.Sync("Sr", ref Sr);
ser.Sync("X", ref X);
ser.Sync("XCrunch", ref XCrunch);
ser.Sync("XExpand", ref XExpand);
ser.Sync("Y", ref Y);
ser.Sync("YCrunch", ref YCrunch);
ser.Sync("YExpand", ref YExpand);
ser.Sync(nameof(CollideData), ref CollideData);
ser.Sync(nameof(CollideSprite), ref CollideSprite);
ser.Sync(nameof(Color), ref Color);
ser.Sync(nameof(Display), ref Display);
ser.Sync(nameof(Dma), ref Dma);
ser.Sync(nameof(Enable), ref Enable);
ser.Sync(nameof(Loaded), ref Loaded);
ser.Sync(nameof(Mc), ref Mc);
ser.Sync(nameof(Mcbase), ref Mcbase);
ser.Sync(nameof(Multicolor), ref Multicolor);
ser.Sync(nameof(MulticolorCrunch), ref MulticolorCrunch);
ser.Sync(nameof(Pointer), ref Pointer);
ser.Sync(nameof(Priority), ref Priority);
ser.Sync(nameof(ShiftEnable), ref ShiftEnable);
ser.Sync(nameof(Sr), ref Sr);
ser.Sync(nameof(X), ref X);
ser.Sync(nameof(XCrunch), ref XCrunch);
ser.Sync(nameof(XExpand), ref XExpand);
ser.Sync(nameof(Y), ref Y);
ser.Sync(nameof(YCrunch), ref YCrunch);
ser.Sync(nameof(YExpand), ref YExpand);
}
}
}

152
BizHawk.Emulation.Cores/Computers/Commodore64/MOS/Vic.State.cs
View File

@ -160,71 +160,71 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
public void SyncState(Serializer ser)
{
ser.Sync("_cyclesExecuted", ref _cyclesExecuted);
ser.Sync("_parseIsSprCrunch", ref _parseIsSprCrunch);
ser.Sync("_srSync", ref _srSync);
ser.Sync("_srColorSync", ref _srColorSync);
ser.Sync("_srColorIndexLatch", ref _srColorIndexLatch);
ser.Sync("_videoMode", ref _videoMode);
ser.Sync("_borderOnShiftReg", ref _borderOnShiftReg);
ser.Sync("_backgroundColor0", ref _backgroundColor0);
ser.Sync("_backgroundColor1", ref _backgroundColor1);
ser.Sync("_backgroundColor2", ref _backgroundColor2);
ser.Sync("_backgroundColor3", ref _backgroundColor3);
ser.Sync("_baCount", ref _baCount);
ser.Sync("_badline", ref _badline);
ser.Sync("_badlineEnable", ref _badlineEnable);
ser.Sync("_bitmapMode", ref _bitmapMode);
ser.Sync("_borderB", ref _borderB);
ser.Sync("_borderCheckLEnable", ref _borderCheckLEnable);
ser.Sync("_borderCheckREnable", ref _borderCheckREnable);
ser.Sync("_borderColor", ref _borderColor);
ser.Sync("_borderL", ref _borderL);
ser.Sync("_borderOnMain", ref _borderOnMain);
ser.Sync("_borderOnVertical", ref _borderOnVertical);
ser.Sync("_borderR", ref _borderR);
ser.Sync("_borderT", ref _borderT);
ser.Sync("_bufferC", ref _bufferC, useNull: false);
ser.Sync("_bufferG", ref _bufferG, useNull: false);
ser.Sync("_cycle", ref _cycle);
ser.Sync("_cycleIndex", ref _cycleIndex);
ser.Sync("_columnSelect", ref _columnSelect);
ser.Sync("_dataC", ref _dataC);
ser.Sync("_dataG", ref _dataG);
ser.Sync("_displayEnable", ref _displayEnable);
ser.Sync("_displayC", ref _displayC);
ser.Sync("_enableIntLightPen", ref _enableIntLightPen);
ser.Sync("_enableIntRaster", ref _enableIntRaster);
ser.Sync("_enableIntSpriteCollision", ref _enableIntSpriteCollision);
ser.Sync("_enableIntSpriteDataCollision", ref _enableIntSpriteDataCollision);
ser.Sync("_extraColorMode", ref _extraColorMode);
ser.Sync("_extraColorModeBuffer", ref _extraColorModeBuffer);
ser.Sync("_idle", ref _idle);
ser.Sync("_intLightPen", ref _intLightPen);
ser.Sync("_intRaster", ref _intRaster);
ser.Sync("_intSpriteCollision", ref _intSpriteCollision);
ser.Sync("_intSpriteDataCollision", ref _intSpriteDataCollision);
ser.Sync("_lightPenX", ref _lightPenX);
ser.Sync("_lightPenY", ref _lightPenY);
ser.Sync("_multicolorMode", ref _multicolorMode);
ser.Sync("_pinAec", ref _pinAec);
ser.Sync("_pinBa", ref _pinBa);
ser.Sync("_pinIrq", ref _pinIrq);
ser.Sync("_pointerCb", ref _pointerCb);
ser.Sync("_pointerVm", ref _pointerVm);
ser.Sync("_rasterInterruptLine", ref _rasterInterruptLine);
ser.Sync("_rasterInterruptTriggered", ref _rasterInterruptTriggered);
ser.Sync("_rasterLine", ref _rasterLine);
ser.Sync("_rasterX", ref _rasterX);
ser.Sync("_rasterXHold", ref _rasterXHold);
ser.Sync("_rc", ref _rc);
ser.Sync("_refreshCounter", ref _refreshCounter);
ser.Sync("_renderEnabled", ref _renderEnabled);
ser.Sync("_rowSelect", ref _rowSelect);
ser.Sync("_spriteBackgroundCollisionClearPending", ref _spriteBackgroundCollisionClearPending);
ser.Sync("_spriteSpriteCollisionClearPending", ref _spriteSpriteCollisionClearPending);
ser.Sync("_spriteMulticolor0", ref _spriteMulticolor0);
ser.Sync("_spriteMulticolor1", ref _spriteMulticolor1);
ser.Sync(nameof(_cyclesExecuted), ref _cyclesExecuted);
ser.Sync(nameof(_parseIsSprCrunch), ref _parseIsSprCrunch);
ser.Sync(nameof(_srSync), ref _srSync);
ser.Sync(nameof(_srColorSync), ref _srColorSync);
ser.Sync(nameof(_srColorIndexLatch), ref _srColorIndexLatch);
ser.Sync(nameof(_videoMode), ref _videoMode);
ser.Sync(nameof(_borderOnShiftReg), ref _borderOnShiftReg);
ser.Sync(nameof(_backgroundColor0), ref _backgroundColor0);
ser.Sync(nameof(_backgroundColor1), ref _backgroundColor1);
ser.Sync(nameof(_backgroundColor2), ref _backgroundColor2);
ser.Sync(nameof(_backgroundColor3), ref _backgroundColor3);
ser.Sync(nameof(_baCount), ref _baCount);
ser.Sync(nameof(_badline), ref _badline);
ser.Sync(nameof(_badlineEnable), ref _badlineEnable);
ser.Sync(nameof(_bitmapMode), ref _bitmapMode);
ser.Sync(nameof(_borderB), ref _borderB);
ser.Sync(nameof(_borderCheckLEnable), ref _borderCheckLEnable);
ser.Sync(nameof(_borderCheckREnable), ref _borderCheckREnable);
ser.Sync(nameof(_borderColor), ref _borderColor);
ser.Sync(nameof(_borderL), ref _borderL);
ser.Sync(nameof(_borderOnMain), ref _borderOnMain);
ser.Sync(nameof(_borderOnVertical), ref _borderOnVertical);
ser.Sync(nameof(_borderR), ref _borderR);
ser.Sync(nameof(_borderT), ref _borderT);
ser.Sync(nameof(_bufferC), ref _bufferC, useNull: false);
ser.Sync(nameof(_bufferG), ref _bufferG, useNull: false);
ser.Sync(nameof(_cycle), ref _cycle);
ser.Sync(nameof(_cycleIndex), ref _cycleIndex);
ser.Sync(nameof(_columnSelect), ref _columnSelect);
ser.Sync(nameof(_dataC), ref _dataC);
ser.Sync(nameof(_dataG), ref _dataG);
ser.Sync(nameof(_displayEnable), ref _displayEnable);
ser.Sync(nameof(_displayC), ref _displayC);
ser.Sync(nameof(_enableIntLightPen), ref _enableIntLightPen);
ser.Sync(nameof(_enableIntRaster), ref _enableIntRaster);
ser.Sync(nameof(_enableIntSpriteCollision), ref _enableIntSpriteCollision);
ser.Sync(nameof(_enableIntSpriteDataCollision), ref _enableIntSpriteDataCollision);
ser.Sync(nameof(_extraColorMode), ref _extraColorMode);
ser.Sync(nameof(_extraColorModeBuffer), ref _extraColorModeBuffer);
ser.Sync(nameof(_idle), ref _idle);
ser.Sync(nameof(_intLightPen), ref _intLightPen);
ser.Sync(nameof(_intRaster), ref _intRaster);
ser.Sync(nameof(_intSpriteCollision), ref _intSpriteCollision);
ser.Sync(nameof(_intSpriteDataCollision), ref _intSpriteDataCollision);
ser.Sync(nameof(_lightPenX), ref _lightPenX);
ser.Sync(nameof(_lightPenY), ref _lightPenY);
ser.Sync(nameof(_multicolorMode), ref _multicolorMode);
ser.Sync(nameof(_pinAec), ref _pinAec);
ser.Sync(nameof(_pinBa), ref _pinBa);
ser.Sync(nameof(_pinIrq), ref _pinIrq);
ser.Sync(nameof(_pointerCb), ref _pointerCb);
ser.Sync(nameof(_pointerVm), ref _pointerVm);
ser.Sync(nameof(_rasterInterruptLine), ref _rasterInterruptLine);
ser.Sync(nameof(_rasterInterruptTriggered), ref _rasterInterruptTriggered);
ser.Sync(nameof(_rasterLine), ref _rasterLine);
ser.Sync(nameof(_rasterX), ref _rasterX);
ser.Sync(nameof(_rasterXHold), ref _rasterXHold);
ser.Sync(nameof(_rc), ref _rc);
ser.Sync(nameof(_refreshCounter), ref _refreshCounter);
ser.Sync(nameof(_renderEnabled), ref _renderEnabled);
ser.Sync(nameof(_rowSelect), ref _rowSelect);
ser.Sync(nameof(_spriteBackgroundCollisionClearPending), ref _spriteBackgroundCollisionClearPending);
ser.Sync(nameof(_spriteSpriteCollisionClearPending), ref _spriteSpriteCollisionClearPending);
ser.Sync(nameof(_spriteMulticolor0), ref _spriteMulticolor0);
ser.Sync(nameof(_spriteMulticolor1), ref _spriteMulticolor1);
for (int i = 0; i < _sprites.Length; i++)
{
@ -233,17 +233,17 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.MOS
ser.EndSection();
}
ser.Sync("_sr", ref _sr);
ser.Sync("_vc", ref _vc);
ser.Sync("_vcbase", ref _vcbase);
ser.Sync("_vmli", ref _vmli);
ser.Sync("_xScroll", ref _xScroll);
ser.Sync("_yScroll", ref _yScroll);
ser.Sync("_bufOffset", ref _bufOffset);
ser.Sync("_pixBuffer", ref _pixBuffer, useNull: false);
ser.Sync("_pixBufferIndex", ref _pixBufferIndex);
ser.Sync("_pixBorderBuffer", ref _pixBorderBuffer, useNull: false);
ser.Sync("_pixBufferBorderIndex", ref _pixBufferBorderIndex);
ser.Sync(nameof(_sr), ref _sr);
ser.Sync(nameof(_vc), ref _vc);
ser.Sync(nameof(_vcbase), ref _vcbase);
ser.Sync(nameof(_vmli), ref _vmli);
ser.Sync(nameof(_xScroll), ref _xScroll);
ser.Sync(nameof(_yScroll), ref _yScroll);
ser.Sync(nameof(_bufOffset), ref _bufOffset);
ser.Sync(nameof(_pixBuffer), ref _pixBuffer, useNull: false);
ser.Sync(nameof(_pixBufferIndex), ref _pixBufferIndex);
ser.Sync(nameof(_pixBorderBuffer), ref _pixBorderBuffer, useNull: false);
ser.Sync(nameof(_pixBufferBorderIndex), ref _pixBufferBorderIndex);
if (ser.IsReader)
{

2
BizHawk.Emulation.Cores/Computers/Commodore64/Media/Disk.cs
View File

@ -167,7 +167,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.Media
public void SyncState(Serializer ser)
{
ser.Sync("WriteProtected", ref WriteProtected);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
// Currently nothing actually writes to _tracks and so it is always the same as _originalMedia
// So commenting out this (very slow) code for now

2
BizHawk.Emulation.Cores/Computers/Commodore64/User/UserPort.cs
View File

@ -69,7 +69,7 @@ namespace BizHawk.Emulation.Cores.Computers.Commodore64.User
public void SyncState(Serializer ser)
{
ser.Sync("_connected", ref _connected);
ser.Sync(nameof(_connected), ref _connected);
_device?.SyncState(ser);
}
}

26
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Datacorder/DatacorderDevice.cs
View File

@ -983,19 +983,19 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
/// <param name="ser"></param>
public void SyncState(Serializer ser)
{
ser.BeginSection("DatacorderDevice");
ser.Sync("counter", ref counter);
ser.Sync("_currentDataBlockIndex", ref _currentDataBlockIndex);
ser.Sync("_position", ref _position);
ser.Sync("_tapeIsPlaying", ref _tapeIsPlaying);
ser.Sync("_lastCycle", ref _lastCycle);
ser.Sync("_waitEdge", ref _waitEdge);
ser.Sync("currentState", ref currentState);
ser.Sync("_lastINCycle", ref _lastINCycle);
ser.Sync("_monitorCount", ref _monitorCount);
ser.Sync("_monitorTimeOut", ref _monitorTimeOut);
ser.Sync("_monitorLastPC", ref _monitorLastPC);
ser.Sync("_monitorLastRegs", ref _monitorLastRegs, false);
ser.BeginSection(nameof(DatacorderDevice));
ser.Sync(nameof(counter), ref counter);
ser.Sync(nameof(_currentDataBlockIndex), ref _currentDataBlockIndex);
ser.Sync(nameof(_position), ref _position);
ser.Sync(nameof(_tapeIsPlaying), ref _tapeIsPlaying);
ser.Sync(nameof(_lastCycle), ref _lastCycle);
ser.Sync(nameof(_waitEdge), ref _waitEdge);
ser.Sync(nameof(currentState), ref currentState);
ser.Sync(nameof(_lastINCycle), ref _lastINCycle);
ser.Sync(nameof(_monitorCount), ref _monitorCount);
ser.Sync(nameof(_monitorTimeOut), ref _monitorTimeOut);
ser.Sync(nameof(_monitorLastPC), ref _monitorLastPC);
ser.Sync(nameof(_monitorLastRegs), ref _monitorLastRegs, false);
ser.EndSection();
}

18
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Disk/NECUPD765.Definitions.cs
View File

@ -806,15 +806,15 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("ActiveCmdParams");
ser.Sync("UnitSelect", ref UnitSelect);
ser.Sync("Side", ref Side);
ser.Sync("Cylinder", ref Cylinder);
ser.Sync("Head", ref Head);
ser.Sync("Sector", ref Sector);
ser.Sync("SectorSize", ref SectorSize);
ser.Sync("EOT", ref EOT);
ser.Sync("Gap3Length", ref Gap3Length);
ser.Sync("DTL", ref DTL);
ser.Sync(nameof(UnitSelect), ref UnitSelect);
ser.Sync(nameof(Side), ref Side);
ser.Sync(nameof(Cylinder), ref Cylinder);
ser.Sync(nameof(Head), ref Head);
ser.Sync(nameof(Sector), ref Sector);
ser.Sync(nameof(SectorSize), ref SectorSize);
ser.Sync(nameof(EOT), ref EOT);
ser.Sync(nameof(Gap3Length), ref Gap3Length);
ser.Sync(nameof(DTL), ref DTL);
ser.EndSection();
}

44
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Disk/NECUPD765.FDD.cs
View File

@ -869,28 +869,28 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
public void SyncState(Serializer ser)
{
ser.Sync("ID", ref ID);
ser.Sync("FLAG_WRITEPROTECT", ref FLAG_WRITEPROTECT);
//ser.Sync("FLAG_DISKCHANGED", ref FLAG_DISKCHANGED);
//ser.Sync("FLAG_RECALIBRATING", ref FLAG_RECALIBRATING);
//ser.Sync("FLAG_SEEK_INTERRUPT", ref FLAG_SEEK_INTERRUPT);
//ser.Sync("IntStatus", ref IntStatus);
//ser.Sync("ST0", ref ST0);
//ser.Sync("RecalibrationCounter", ref RecalibrationCounter);
ser.Sync("SeekCounter", ref SeekCounter);
ser.Sync("SeekStatus", ref SeekStatus);
ser.Sync("SeekAge", ref SeekAge);
ser.Sync("CurrentSide", ref CurrentSide);
//ser.Sync("CurrentTrack", ref CurrentTrack);
ser.Sync("TrackIndex", ref TrackIndex);
ser.Sync("SeekingTrack", ref SeekingTrack);
//ser.Sync("CurrentSector", ref CurrentSector);
ser.Sync("SectorIndex", ref SectorIndex);
//ser.Sync("RAngles", ref RAngles);
//ser.Sync("DataPointer", ref DataPointer);
//ser.SyncEnum("CurrentState", ref CurrentState);
//ser.SyncEnum("SeekState", ref SeekState);
//ser.SyncEnum("SeekIntState", ref SeekIntState);
ser.Sync(nameof(ID), ref ID);
ser.Sync(nameof(FLAG_WRITEPROTECT), ref FLAG_WRITEPROTECT);
//ser.Sync(nameof(FLAG_DISKCHANGED), ref FLAG_DISKCHANGED);
//ser.Sync(nameof(FLAG_RECALIBRATING), ref FLAG_RECALIBRATING);
//ser.Sync(nameof(FLAG_SEEK_INTERRUPT), ref FLAG_SEEK_INTERRUPT);
//ser.Sync(nameof(IntStatus), ref IntStatus);
//ser.Sync(nameof(ST0), ref ST0);
//ser.Sync(nameof(RecalibrationCounter), ref RecalibrationCounter);
ser.Sync(nameof(SeekCounter), ref SeekCounter);
ser.Sync(nameof(SeekStatus), ref SeekStatus);
ser.Sync(nameof(SeekAge), ref SeekAge);
ser.Sync(nameof(CurrentSide), ref CurrentSide);
//ser.Sync(nameof(CurrentTrack), ref CurrentTrack);
ser.Sync(nameof(TrackIndex), ref TrackIndex);
ser.Sync(nameof(SeekingTrack), ref SeekingTrack);
//ser.Sync(nameof(CurrentSector), ref CurrentSector);
ser.Sync(nameof(SectorIndex), ref SectorIndex);
//ser.Sync(nameof(RAngles), ref RAngles);
//ser.Sync(nameof(DataPointer), ref DataPointer);
//ser.SyncEnum(nameof(CurrentState), ref CurrentState);
//ser.SyncEnum(nameof(SeekState), ref SeekState);
//ser.SyncEnum(nameof(SeekIntState), ref SeekIntState);
}
#endregion

76
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Disk/NECUPD765.cs
View File

@ -159,7 +159,7 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
#region FDD
ser.Sync("FDD_FLAG_MOTOR", ref FDD_FLAG_MOTOR);
ser.Sync(nameof(FDD_FLAG_MOTOR), ref FDD_FLAG_MOTOR);
for (int i = 0; i < 4; i++)
{
@ -168,7 +168,7 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
ser.EndSection();
}
ser.Sync("DiskDriveIndex", ref _diskDriveIndex);
ser.Sync(nameof(DiskDriveIndex), ref _diskDriveIndex);
// set active drive
DiskDriveIndex = _diskDriveIndex;
@ -186,55 +186,55 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
#region Controller state
ser.Sync("DriveLight", ref DriveLight);
ser.SyncEnum("ActivePhase", ref ActivePhase);
//ser.SyncEnum("ActiveDirection", ref ActiveDirection);
ser.SyncEnum("ActiveInterrupt", ref ActiveInterrupt);
ser.Sync("CommBuffer", ref CommBuffer, false);
ser.Sync("CommCounter", ref CommCounter);
ser.Sync("ResBuffer", ref ResBuffer, false);
ser.Sync("ExecBuffer", ref ExecBuffer, false);
ser.Sync("ExecCounter", ref ExecCounter);
ser.Sync("ExecLength", ref ExecLength);
ser.Sync("InterruptResultBuffer", ref InterruptResultBuffer, false);
ser.Sync("ResCounter", ref ResCounter);
ser.Sync("ResLength", ref ResLength);
ser.Sync("LastSectorDataWriteByte", ref LastSectorDataWriteByte);
ser.Sync("LastSectorDataReadByte", ref LastSectorDataReadByte);
ser.Sync("LastByteReceived", ref LastByteReceived);
ser.Sync(nameof(DriveLight), ref DriveLight);
ser.SyncEnum(nameof(ActivePhase), ref ActivePhase);
//ser.SyncEnum(nameof(ActiveDirection), ref ActiveDirection);
ser.SyncEnum(nameof(ActiveInterrupt), ref ActiveInterrupt);
ser.Sync(nameof(CommBuffer), ref CommBuffer, false);
ser.Sync(nameof(CommCounter), ref CommCounter);
ser.Sync(nameof(ResBuffer), ref ResBuffer, false);
ser.Sync(nameof(ExecBuffer), ref ExecBuffer, false);
ser.Sync(nameof(ExecCounter), ref ExecCounter);
ser.Sync(nameof(ExecLength), ref ExecLength);
ser.Sync(nameof(InterruptResultBuffer), ref InterruptResultBuffer, false);
ser.Sync(nameof(ResCounter), ref ResCounter);
ser.Sync(nameof(ResLength), ref ResLength);
ser.Sync(nameof(LastSectorDataWriteByte), ref LastSectorDataWriteByte);
ser.Sync(nameof(LastSectorDataReadByte), ref LastSectorDataReadByte);
ser.Sync(nameof(LastByteReceived), ref LastByteReceived);
ser.Sync("_cmdIndex", ref _cmdIndex);
ser.Sync(nameof(_cmdIndex), ref _cmdIndex);
// resync the ActiveCommand
CMDIndex = _cmdIndex;
ActiveCommandParams.SyncState(ser);
ser.Sync("IndexPulseCounter", ref IndexPulseCounter);
//ser.SyncEnum("_activeStatus", ref _activeStatus);
//ser.SyncEnum("_statusRaised", ref _statusRaised);
ser.Sync(nameof(IndexPulseCounter), ref IndexPulseCounter);
//ser.SyncEnum(nameof(_activeStatus), ref _activeStatus);
//ser.SyncEnum(nameof(_statusRaised), ref _statusRaised);
ser.Sync("CMD_FLAG_MT", ref CMD_FLAG_MT);
ser.Sync("CMD_FLAG_MF", ref CMD_FLAG_MF);
ser.Sync("CMD_FLAG_SK", ref CMD_FLAG_SK);
ser.Sync("SRT", ref SRT);
ser.Sync("HUT", ref HUT);
ser.Sync("HLT", ref HLT);
ser.Sync("ND", ref ND);
ser.Sync("SRT_Counter", ref SRT_Counter);
ser.Sync("HUT_Counter", ref HUT_Counter);
ser.Sync("HLT_Counter", ref HLT_Counter);
ser.Sync(nameof(CMD_FLAG_MT), ref CMD_FLAG_MT);
ser.Sync(nameof(CMD_FLAG_MF), ref CMD_FLAG_MF);
ser.Sync(nameof(CMD_FLAG_SK), ref CMD_FLAG_SK);
ser.Sync(nameof(SRT), ref SRT);
ser.Sync(nameof(HUT), ref HUT);
ser.Sync(nameof(HLT), ref HLT);
ser.Sync(nameof(ND), ref ND);
ser.Sync(nameof(SRT_Counter), ref SRT_Counter);
ser.Sync(nameof(HUT_Counter), ref HUT_Counter);
ser.Sync(nameof(HLT_Counter), ref HLT_Counter);
ser.Sync("SectorDelayCounter", ref SectorDelayCounter);
ser.Sync("SectorID", ref SectorID);
ser.Sync(nameof(SectorDelayCounter), ref SectorDelayCounter);
ser.Sync(nameof(SectorID), ref SectorID);
#endregion
#region Timing
ser.Sync("LastCPUCycle", ref LastCPUCycle);
ser.Sync("StatusDelay", ref StatusDelay);
ser.Sync("TickCounter", ref TickCounter);
ser.Sync("DriveCycleCounter", ref DriveCycleCounter);
ser.Sync(nameof(LastCPUCycle), ref LastCPUCycle);
ser.Sync(nameof(StatusDelay), ref StatusDelay);
ser.Sync(nameof(TickCounter), ref TickCounter);
ser.Sync(nameof(DriveCycleCounter), ref DriveCycleCounter);
#endregion

4
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/Input/StandardKeyboard.cs
View File

@ -278,8 +278,8 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
public void SyncState(Serializer ser)
{
ser.BeginSection("Keyboard");
ser.Sync("LineStatus", ref LineStatus, false);
ser.Sync("_keyLine", ref _keyLine, false);
ser.Sync(nameof(LineStatus), ref LineStatus, false);
ser.Sync(nameof(_keyLine), ref _keyLine, false);
ser.EndSection();
}
}

78
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/SoundOuput/AY38912.cs
View File

@ -768,46 +768,46 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("PSG-AY");
ser.Sync("_tStatesPerFrame", ref _tStatesPerFrame);
ser.Sync("_sampleRate", ref _sampleRate);
ser.Sync("_samplesPerFrame", ref _samplesPerFrame);
ser.Sync("_tStatesPerSample", ref _tStatesPerSample);
ser.Sync("_audioBufferIndex", ref _audioBufferIndex);
ser.Sync("_audioBuffer", ref _audioBuffer, false);
ser.Sync(nameof(_tStatesPerFrame), ref _tStatesPerFrame);
ser.Sync(nameof(_sampleRate), ref _sampleRate);
ser.Sync(nameof(_samplesPerFrame), ref _samplesPerFrame);
ser.Sync(nameof(_tStatesPerSample), ref _tStatesPerSample);
ser.Sync(nameof(_audioBufferIndex), ref _audioBufferIndex);
ser.Sync(nameof(_audioBuffer), ref _audioBuffer, false);
ser.Sync("_registers", ref _registers, false);
ser.Sync("_activeRegister", ref _activeRegister);
ser.Sync("_bitA", ref _bitA);
ser.Sync("_bitB", ref _bitB);
ser.Sync("_bitC", ref _bitC);
ser.Sync("_eState", ref _eState);
ser.Sync("_eDirection", ref _eDirection);
ser.Sync("_noiseSeed", ref _noiseSeed);
ser.Sync("_bit0", ref _bit0);
ser.Sync("_bit1", ref _bit1);
ser.Sync("_bit2", ref _bit2);
ser.Sync("_bit3", ref _bit3);
ser.Sync("_bit4", ref _bit4);
ser.Sync("_bit5", ref _bit5);
ser.Sync("_bitN", ref _bitN);
ser.Sync("_eMaskA", ref _eMaskA);
ser.Sync("_eMaskB", ref _eMaskB);
ser.Sync("_eMaskC", ref _eMaskC);
ser.Sync("_vA", ref _vA);
ser.Sync("_vB", ref _vB);
ser.Sync("_vC", ref _vC);
ser.Sync("_countA", ref _countA);
ser.Sync("_countB", ref _countB);
ser.Sync("_countC", ref _countC);
ser.Sync("_countE", ref _countE);
ser.Sync("_countN", ref _countN);
ser.Sync("_dividerA", ref _dividerA);
ser.Sync("_dividerB", ref _dividerB);
ser.Sync("_dividerC", ref _dividerC);
ser.Sync("_dividerE", ref _dividerE);
ser.Sync("_dividerN", ref _dividerN);
ser.SyncEnum("_currentPanTab", ref _currentPanTab);
ser.Sync("_volume", ref nullDump);
ser.Sync(nameof(_registers), ref _registers, false);
ser.Sync(nameof(_activeRegister), ref _activeRegister);
ser.Sync(nameof(_bitA), ref _bitA);
ser.Sync(nameof(_bitB), ref _bitB);
ser.Sync(nameof(_bitC), ref _bitC);
ser.Sync(nameof(_eState), ref _eState);
ser.Sync(nameof(_eDirection), ref _eDirection);
ser.Sync(nameof(_noiseSeed), ref _noiseSeed);
ser.Sync(nameof(_bit0), ref _bit0);
ser.Sync(nameof(_bit1), ref _bit1);
ser.Sync(nameof(_bit2), ref _bit2);
ser.Sync(nameof(_bit3), ref _bit3);
ser.Sync(nameof(_bit4), ref _bit4);
ser.Sync(nameof(_bit5), ref _bit5);
ser.Sync(nameof(_bitN), ref _bitN);
ser.Sync(nameof(_eMaskA), ref _eMaskA);
ser.Sync(nameof(_eMaskB), ref _eMaskB);
ser.Sync(nameof(_eMaskC), ref _eMaskC);
ser.Sync(nameof(_vA), ref _vA);
ser.Sync(nameof(_vB), ref _vB);
ser.Sync(nameof(_vC), ref _vC);
ser.Sync(nameof(_countA), ref _countA);
ser.Sync(nameof(_countB), ref _countB);
ser.Sync(nameof(_countC), ref _countC);
ser.Sync(nameof(_countE), ref _countE);
ser.Sync(nameof(_countN), ref _countN);
ser.Sync(nameof(_dividerA), ref _dividerA);
ser.Sync(nameof(_dividerB), ref _dividerB);
ser.Sync(nameof(_dividerC), ref _dividerC);
ser.Sync(nameof(_dividerE), ref _dividerE);
ser.Sync(nameof(_dividerN), ref _dividerN);
ser.SyncEnum(nameof(_currentPanTab), ref _currentPanTab);
ser.Sync(nameof(_volume), ref nullDump);
for (int i = 0; i < 6; i++)
{

8
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Hardware/SoundOuput/Beeper.cs
View File

@ -204,10 +204,10 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
public void SyncState(Serializer ser)
{
ser.BeginSection("Buzzer");
ser.Sync("_tStatesPerFrame", ref _tStatesPerFrame);
ser.Sync("_sampleRate", ref _sampleRate);
ser.Sync("LastPulse", ref LastPulse);
ser.Sync("LastPulseTState", ref LastPulseTState);
ser.Sync(nameof(_tStatesPerFrame), ref _tStatesPerFrame);
ser.Sync(nameof(_sampleRate), ref _sampleRate);
ser.Sync(nameof(LastPulse), ref LastPulse);
ser.Sync(nameof(LastPulseTState), ref LastPulseTState);
ser.EndSection();
}

6
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/CPUMonitor.cs
View File

@ -398,9 +398,9 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
public void SyncState(Serializer ser)
{
ser.BeginSection("CPUMonitor");
ser.Sync("lastPortAddr", ref lastPortAddr);
ser.Sync("NextMemReadContended", ref NextMemReadContended);
ser.BeginSection(nameof(CPUMonitor));
ser.Sync(nameof(lastPortAddr), ref lastPortAddr);
ser.Sync(nameof(NextMemReadContended), ref NextMemReadContended);
ser.EndSection();
}

60
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/SpectrumBase.cs
View File

@ -321,34 +321,34 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
public void SyncState(Serializer ser)
{
ser.BeginSection("ZXMachine");
ser.Sync("FrameCompleted", ref FrameCompleted);
ser.Sync("OverFlow", ref OverFlow);
ser.Sync("FrameCount", ref FrameCount);
ser.Sync("_frameCycles", ref _frameCycles);
ser.Sync("inputRead", ref inputRead);
ser.Sync("LastFrameStartCPUTick", ref LastFrameStartCPUTick);
ser.Sync("LastULAOutByte", ref LastULAOutByte);
ser.Sync("ROM0", ref ROM0, false);
ser.Sync("ROM1", ref ROM1, false);
ser.Sync("ROM2", ref ROM2, false);
ser.Sync("ROM3", ref ROM3, false);
ser.Sync("RAM0", ref RAM0, false);
ser.Sync("RAM1", ref RAM1, false);
ser.Sync("RAM2", ref RAM2, false);
ser.Sync("RAM3", ref RAM3, false);
ser.Sync("RAM4", ref RAM4, false);
ser.Sync("RAM5", ref RAM5, false);
ser.Sync("RAM6", ref RAM6, false);
ser.Sync("RAM7", ref RAM7, false);
ser.Sync("ROMPaged", ref ROMPaged);
ser.Sync("SHADOWPaged", ref SHADOWPaged);
ser.Sync("RAMPaged", ref RAMPaged);
ser.Sync("PagingDisabled", ref PagingDisabled);
ser.Sync("SpecialPagingMode", ref SpecialPagingMode);
ser.Sync("PagingConfiguration", ref PagingConfiguration);
ser.Sync("ROMhigh", ref ROMhigh);
ser.Sync("ROMlow", ref ROMlow);
ser.Sync("LastContendedReadByte", ref LastContendedReadByte);
ser.Sync(nameof(FrameCompleted), ref FrameCompleted);
ser.Sync(nameof(OverFlow), ref OverFlow);
ser.Sync(nameof(FrameCount), ref FrameCount);
ser.Sync(nameof(_frameCycles), ref _frameCycles);
ser.Sync(nameof(inputRead), ref inputRead);
ser.Sync(nameof(LastFrameStartCPUTick), ref LastFrameStartCPUTick);
ser.Sync(nameof(LastULAOutByte), ref LastULAOutByte);
ser.Sync(nameof(ROM0), ref ROM0, false);
ser.Sync(nameof(ROM1), ref ROM1, false);
ser.Sync(nameof(ROM2), ref ROM2, false);
ser.Sync(nameof(ROM3), ref ROM3, false);
ser.Sync(nameof(RAM0), ref RAM0, false);
ser.Sync(nameof(RAM1), ref RAM1, false);
ser.Sync(nameof(RAM2), ref RAM2, false);
ser.Sync(nameof(RAM3), ref RAM3, false);
ser.Sync(nameof(RAM4), ref RAM4, false);
ser.Sync(nameof(RAM5), ref RAM5, false);
ser.Sync(nameof(RAM6), ref RAM6, false);
ser.Sync(nameof(RAM7), ref RAM7, false);
ser.Sync(nameof(ROMPaged), ref ROMPaged);
ser.Sync(nameof(SHADOWPaged), ref SHADOWPaged);
ser.Sync(nameof(RAMPaged), ref RAMPaged);
ser.Sync(nameof(PagingDisabled), ref PagingDisabled);
ser.Sync(nameof(SpecialPagingMode), ref SpecialPagingMode);
ser.Sync(nameof(PagingConfiguration), ref PagingConfiguration);
ser.Sync(nameof(ROMhigh), ref ROMhigh);
ser.Sync(nameof(ROMlow), ref ROMlow);
ser.Sync(nameof(LastContendedReadByte), ref LastContendedReadByte);
KeyboardDevice.SyncState(ser);
BuzzerDevice.SyncState(ser);
@ -362,7 +362,7 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
((AY38912)AYDevice as AY38912).PanningConfiguration = Spectrum.Settings.AYPanConfig;
}
ser.Sync("tapeMediaIndex", ref tapeMediaIndex);
ser.Sync(nameof(tapeMediaIndex), ref tapeMediaIndex);
if (ser.IsReader)
{
IsLoadState = true;
@ -373,7 +373,7 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
TapeDevice.SyncState(ser);
ser.Sync("diskMediaIndex", ref diskMediaIndex);
ser.Sync(nameof(diskMediaIndex), ref diskMediaIndex);
if (ser.IsReader)
{
IsLoadState = true;

40
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Machine/ULA.cs
View File

@ -1035,29 +1035,29 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
public void SyncState(Serializer ser)
{
ser.BeginSection("ULA");
ser.BeginSection(nameof(ULA));
if (ScreenBuffer != null)
ser.Sync("ScreenBuffer", ref ScreenBuffer, false);
ser.Sync("BorderColor", ref BorderColor);
ser.Sync("LastTState", ref LastTState);
ser.Sync("flashOn", ref flashOn);
ser.Sync("fetchB1", ref fetchB1);
ser.Sync("fetchA1", ref fetchA1);
ser.Sync("fetchB2", ref fetchB2);
ser.Sync("fetchA2", ref fetchA2);
ser.Sync("ink", ref ink);
ser.Sync("paper", ref paper);
ser.Sync("fetchBorder", ref fetchBorder);
ser.Sync("bright", ref bright);
ser.Sync("flash", ref flash);
ser.Sync("palPaper", ref palPaper);
ser.Sync("palInk", ref palInk);
ser.Sync(nameof(ScreenBuffer), ref ScreenBuffer, false);
ser.Sync(nameof(BorderColor), ref BorderColor);
ser.Sync(nameof(LastTState), ref LastTState);
ser.Sync(nameof(flashOn), ref flashOn);
ser.Sync(nameof(fetchB1), ref fetchB1);
ser.Sync(nameof(fetchA1), ref fetchA1);
ser.Sync(nameof(fetchB2), ref fetchB2);
ser.Sync(nameof(fetchA2), ref fetchA2);
ser.Sync(nameof(ink), ref ink);
ser.Sync(nameof(paper), ref paper);
ser.Sync(nameof(fetchBorder), ref fetchBorder);
ser.Sync(nameof(bright), ref bright);
ser.Sync(nameof(flash), ref flash);
ser.Sync(nameof(palPaper), ref palPaper);
ser.Sync(nameof(palInk), ref palInk);
ser.Sync("LastULATick", ref LastULATick);
ser.Sync("ULACycleCounter", ref ULACycleCounter);
ser.Sync("FrameEnd", ref FrameEnd);
ser.Sync(nameof(LastULATick), ref LastULATick);
ser.Sync(nameof(ULACycleCounter), ref ULACycleCounter);
ser.Sync(nameof(FrameEnd), ref FrameEnd);
ser.Sync("InterruptRaised", ref InterruptRaised);
ser.Sync(nameof(InterruptRaised), ref InterruptRaised);
ser.EndSection();
}

14
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Disk/CPCFormat/CPCExtendedFloppyDisk.cs
View File

@ -247,20 +247,20 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("Plus3FloppyDisk");
ser.Sync("CylinderCount", ref CylinderCount);
ser.Sync("SideCount", ref SideCount);
ser.Sync("BytesPerTrack", ref BytesPerTrack);
ser.Sync("WriteProtected", ref WriteProtected);
ser.SyncEnum("Protection", ref Protection);
ser.Sync(nameof(CylinderCount), ref CylinderCount);
ser.Sync(nameof(SideCount), ref SideCount);
ser.Sync(nameof(BytesPerTrack), ref BytesPerTrack);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
ser.SyncEnum(nameof(Protection), ref Protection);
ser.Sync("DirtyData", ref DirtyData);
ser.Sync(nameof(DirtyData), ref DirtyData);
if (DirtyData)
{
}
// sync deterministic track and sector counters
ser.Sync(" _randomCounter", ref _randomCounter);
ser.Sync(nameof( _randomCounter), ref _randomCounter);
RandomCounter = _randomCounter;
ser.EndSection();

12
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Disk/CPCFormat/CPCFloppyDisk.cs
View File

@ -241,13 +241,13 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("Plus3FloppyDisk");
ser.Sync("CylinderCount", ref CylinderCount);
ser.Sync("SideCount", ref SideCount);
ser.Sync("BytesPerTrack", ref BytesPerTrack);
ser.Sync("WriteProtected", ref WriteProtected);
ser.SyncEnum("Protection", ref Protection);
ser.Sync(nameof(CylinderCount), ref CylinderCount);
ser.Sync(nameof(SideCount), ref SideCount);
ser.Sync(nameof(BytesPerTrack), ref BytesPerTrack);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
ser.SyncEnum(nameof(Protection), ref Protection);
ser.Sync("DirtyData", ref DirtyData);
ser.Sync(nameof(DirtyData), ref DirtyData);
if (DirtyData)
{

14
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Disk/IPFFormat/IPFFloppyDisk.cs
View File

@ -439,20 +439,20 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("Plus3FloppyDisk");
ser.Sync("CylinderCount", ref CylinderCount);
ser.Sync("SideCount", ref SideCount);
ser.Sync("BytesPerTrack", ref BytesPerTrack);
ser.Sync("WriteProtected", ref WriteProtected);
ser.SyncEnum("Protection", ref Protection);
ser.Sync(nameof(CylinderCount), ref CylinderCount);
ser.Sync(nameof(SideCount), ref SideCount);
ser.Sync(nameof(BytesPerTrack), ref BytesPerTrack);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
ser.SyncEnum(nameof(Protection), ref Protection);
ser.Sync("DirtyData", ref DirtyData);
ser.Sync(nameof(DirtyData), ref DirtyData);
if (DirtyData)
{
}
// sync deterministic track and sector counters
ser.Sync(" _randomCounter", ref _randomCounter);
ser.Sync(nameof( _randomCounter), ref _randomCounter);
RandomCounter = _randomCounter;
ser.EndSection();

14
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Disk/UDIFormat/UDI1_0FloppyDisk.cs
View File

@ -195,20 +195,20 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("Plus3FloppyDisk");
ser.Sync("CylinderCount", ref CylinderCount);
ser.Sync("SideCount", ref SideCount);
ser.Sync("BytesPerTrack", ref BytesPerTrack);
ser.Sync("WriteProtected", ref WriteProtected);
ser.SyncEnum("Protection", ref Protection);
ser.Sync(nameof(CylinderCount), ref CylinderCount);
ser.Sync(nameof(SideCount), ref SideCount);
ser.Sync(nameof(BytesPerTrack), ref BytesPerTrack);
ser.Sync(nameof(WriteProtected), ref WriteProtected);
ser.SyncEnum(nameof(Protection), ref Protection);
ser.Sync("DirtyData", ref DirtyData);
ser.Sync(nameof(DirtyData), ref DirtyData);
if (DirtyData)
{
}
// sync deterministic track and sector counters
ser.Sync(" _randomCounter", ref _randomCounter);
ser.Sync(nameof( _randomCounter), ref _randomCounter);
RandomCounter = _randomCounter;
ser.EndSection();

10
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/Media/Tape/TapeDataBlock.cs
View File

@ -173,11 +173,11 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
{
ser.BeginSection("DataBlock" + blockPosition);
ser.Sync("_blockID", ref _blockID);
//ser.SyncFixedString("_blockDescription", ref _blockDescription, 200);
ser.SyncEnum("_blockType", ref _blockType);
ser.Sync("_blockData", ref _blockData, true);
ser.SyncEnum("_command", ref _command);
ser.Sync(nameof(_blockID), ref _blockID);
//ser.SyncFixedString(nameof(_blockDescription), ref _blockDescription, 200);
ser.SyncEnum(nameof(_blockType), ref _blockType);
ser.Sync(nameof(_blockData), ref _blockData, true);
ser.SyncEnum(nameof(_command), ref _command);
int[] tempArray = null;

8
BizHawk.Emulation.Cores/Computers/SinclairSpectrum/ZXSpectrum.IStatable.cs
View File

@ -56,10 +56,10 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
if (ser.IsWriter)
{
ser.SyncEnum("_machineType", ref _machineType);
ser.SyncEnum(nameof(_machineType), ref _machineType);
_cpu.SyncState(ser);
ser.BeginSection("ZXSpectrum");
ser.BeginSection(nameof(ZXSpectrum));
_machine.SyncState(ser);
ser.Sync("Frame", ref _machine.FrameCount);
ser.Sync("LagCount", ref _lagCount);
@ -70,7 +70,7 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
if (ser.IsReader)
{
var tmpM = _machineType;
ser.SyncEnum("_machineType", ref _machineType);
ser.SyncEnum(nameof(_machineType), ref _machineType);
if (tmpM != _machineType && _machineType.ToString() != "72")
{
string msg = "SAVESTATE FAILED TO LOAD!!\n\n";
@ -85,7 +85,7 @@ namespace BizHawk.Emulation.Cores.Computers.SinclairSpectrum
else
{
_cpu.SyncState(ser);
ser.BeginSection("ZXSpectrum");
ser.BeginSection(nameof(ZXSpectrum));
_machine.SyncState(ser);
ser.Sync("Frame", ref _machine.FrameCount);
ser.Sync("LagCount", ref _lagCount);

4
BizHawk.Emulation.Cores/Consoles/Atari/2600/Atari2600.IStatable.cs
View File

@ -46,12 +46,12 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
ser.Sync("Lag", ref _lagcount);
ser.Sync("Frame", ref _frame);
ser.Sync("IsLag", ref _islag);
ser.Sync("cyc_counter", ref cyc_counter);
ser.Sync(nameof(cyc_counter), ref cyc_counter);
ser.Sync("leftDifficultySwitchPressed", ref _leftDifficultySwitchPressed);
ser.Sync("rightDifficultySwitchPressed", ref _rightDifficultySwitchPressed);
ser.Sync("leftDifficultySwitchHeld", ref _leftDifficultySwitchHeld);
ser.Sync("rightDifficultySwitchHeld", ref _rightDifficultySwitchHeld);
ser.Sync("unselect_reset", ref unselect_reset);
ser.Sync(nameof(unselect_reset), ref unselect_reset);
_tia.SyncState(ser);
_m6532.SyncState(ser);

4
BizHawk.Emulation.Cores/Consoles/Atari/2600/Atari2600ControllerDeck.cs
View File

@ -66,11 +66,11 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
public void SyncState(Serializer ser)
{
ser.BeginSection("Port1");
ser.BeginSection(nameof(Port1));
Port1.SyncState(ser);
ser.EndSection();
ser.BeginSection("Port2");
ser.BeginSection(nameof(Port2));
Port2.SyncState(ser);
ser.EndSection();
}

2
BizHawk.Emulation.Cores/Consoles/Atari/2600/M6532.cs
View File

@ -178,7 +178,7 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
public void SyncState(Serializer ser)
{
ser.BeginSection("M6532");
ser.BeginSection(nameof(M6532));
ser.Sync("ddra", ref _ddRa);
ser.Sync("ddrb", ref _ddRb);
ser.Sync("OutputA", ref _outputA);

20
BizHawk.Emulation.Cores/Consoles/Atari/2600/Tia/Tia.Audio.cs
View File

@ -196,16 +196,16 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
public void SyncState(Serializer ser)
{
ser.Sync("AUDC", ref AUDC);
ser.Sync("AUDF", ref AUDF);
ser.Sync("AUDV", ref AUDV);
ser.Sync("sr1", ref sr1);
ser.Sync("sr3", ref sr3);
ser.Sync("sr4", ref sr4);
ser.Sync("sr5", ref sr5);
ser.Sync("sr9", ref sr9);
ser.Sync("freqcnt", ref freqcnt);
ser.Sync("on", ref on);
ser.Sync(nameof(AUDC), ref AUDC);
ser.Sync(nameof(AUDF), ref AUDF);
ser.Sync(nameof(AUDV), ref AUDV);
ser.Sync(nameof(sr1), ref sr1);
ser.Sync(nameof(sr3), ref sr3);
ser.Sync(nameof(sr4), ref sr4);
ser.Sync(nameof(sr5), ref sr5);
ser.Sync(nameof(sr9), ref sr9);
ser.Sync(nameof(freqcnt), ref freqcnt);
ser.Sync(nameof(on), ref on);
}
}
}

2
BizHawk.Emulation.Cores/Consoles/Atari/2600/Tia/Tia.BallData.cs
View File

@ -47,7 +47,7 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
ser.Sync("denabled", ref Denabled);
ser.Sync("delay", ref Delay);
ser.Sync("size", ref Size);
ser.Sync("HM", ref HM);
ser.Sync(nameof(HM), ref HM);
ser.Sync("hPosCnt", ref HPosCnt);
ser.Sync("collisions", ref Collisions);
ser.EndSection();

2
BizHawk.Emulation.Cores/Consoles/Atari/2600/Tia/Tia.PlayerData.cs
View File

@ -179,7 +179,7 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
ser.Sync("hPosCnt", ref HPosCnt);
ser.Sync("scanCnt", ref ScanCnt);
ser.Sync("scanCntInit", ref ScanCntInit);
ser.Sync("HM", ref HM);
ser.Sync(nameof(HM), ref HM);
ser.Sync("reflect", ref Reflect);
ser.Sync("delay", ref Delay);
ser.Sync("nusiz", ref Nusiz);

8
BizHawk.Emulation.Cores/Consoles/Atari/2600/Tia/Tia.SyncState.cs
View File

@ -6,7 +6,7 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
{
public void SyncState(Serializer ser)
{
ser.BeginSection("TIA");
ser.BeginSection(nameof(TIA));
_ball.SyncState(ser);
_hmove.SyncState(ser);
ser.Sync("hsyncCnt", ref _hsyncCnt);
@ -57,7 +57,7 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
ser.Sync("PRG1_val", ref _prg1Val);
ser.Sync("Ticks", ref _doTicks);
ser.Sync("hmove_cnt_up", ref hmove_cnt_up);
ser.Sync(nameof(hmove_cnt_up), ref hmove_cnt_up);
ser.Sync("VBlankDelay", ref _vblankDelay);
ser.Sync("VBlankValue", ref _vblankValue);
@ -69,8 +69,8 @@ namespace BizHawk.Emulation.Cores.Atari.Atari2600
ser.Sync("vblankEnabled", ref _vblankEnabled);
ser.Sync("vsyncEnabled", ref _vsyncEnabled);
ser.Sync("CurrentScanLine", ref _currentScanLine);
ser.Sync("AudioClocks", ref AudioClocks);
ser.Sync("New_Frame", ref New_Frame);
ser.Sync(nameof(AudioClocks), ref AudioClocks);
ser.Sync(nameof(New_Frame), ref New_Frame);
ser.BeginSection("Player0");
_player0.SyncState(ser);

50
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/A7800Hawk.IStatable.cs
View File

@ -53,38 +53,38 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
ser.Sync("IsLag", ref _islag);
_controllerDeck.SyncState(ser);
ser.Sync("A7800_control_register", ref A7800_control_register);
ser.Sync("_isPAL", ref _isPAL);
ser.Sync(nameof(A7800_control_register), ref A7800_control_register);
ser.Sync(nameof(_isPAL), ref _isPAL);
ser.Sync("Maria_regs", ref Maria_regs, false);
ser.Sync("RAM", ref RAM, false);
ser.Sync("RAM_6532", ref RAM_6532, false);
ser.Sync("hs_bios_mem", ref hs_bios_mem, false);
ser.Sync(nameof(Maria_regs), ref Maria_regs, false);
ser.Sync(nameof(RAM), ref RAM, false);
ser.Sync(nameof(RAM_6532), ref RAM_6532, false);
ser.Sync(nameof(hs_bios_mem), ref hs_bios_mem, false);
ser.Sync("cycle", ref cycle);
ser.Sync("cpu_cycle", ref cpu_cycle);
ser.Sync("cpu_is_haltable", ref cpu_is_haltable);
ser.Sync("cpu_is_halted", ref cpu_is_halted);
ser.Sync("cpu_halt_pending", ref cpu_halt_pending);
ser.Sync("cpu_resume_pending", ref cpu_resume_pending);
ser.Sync(nameof(cycle), ref cycle);
ser.Sync(nameof(cpu_cycle), ref cpu_cycle);
ser.Sync(nameof(cpu_is_haltable), ref cpu_is_haltable);
ser.Sync(nameof(cpu_is_halted), ref cpu_is_halted);
ser.Sync(nameof(cpu_halt_pending), ref cpu_halt_pending);
ser.Sync(nameof(cpu_resume_pending), ref cpu_resume_pending);
ser.Sync("slow_access", ref slow_access);
ser.Sync("slow_access", ref slow_countdown);
ser.Sync(nameof(slow_access), ref slow_access);
ser.Sync(nameof(slow_access), ref slow_countdown);
ser.Sync("small flag", ref small_flag);
ser.Sync("pal kara", ref PAL_Kara);
ser.Sync("Cart RAM", ref cart_RAM);
ser.Sync("is_pokey", ref is_pokey);
ser.Sync("left_toggle", ref left_toggle);
ser.Sync("right_toggle", ref right_toggle);
ser.Sync("left_was_pressed", ref left_was_pressed);
ser.Sync("right_was_pressed", ref right_was_pressed);
ser.Sync(nameof(is_pokey), ref is_pokey);
ser.Sync(nameof(left_toggle), ref left_toggle);
ser.Sync(nameof(right_toggle), ref right_toggle);
ser.Sync(nameof(left_was_pressed), ref left_was_pressed);
ser.Sync(nameof(right_was_pressed), ref right_was_pressed);
ser.Sync("temp_s_tia", ref temp_s_tia);
ser.Sync("temp_s_pokey", ref temp_s_pokey);
ser.Sync("samp_l", ref samp_l);
ser.Sync("samp_c", ref samp_c);
ser.Sync("master_audio_clock", ref master_audio_clock);
ser.Sync("temp", ref temp);
ser.Sync(nameof(temp_s_tia), ref temp_s_tia);
ser.Sync(nameof(temp_s_pokey), ref temp_s_pokey);
ser.Sync(nameof(samp_l), ref samp_l);
ser.Sync(nameof(samp_c), ref samp_c);
ser.Sync(nameof(master_audio_clock), ref master_audio_clock);
ser.Sync(nameof(temp), ref temp);
ser.EndSection();
}

4
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/A7800HawkControllerDeck.cs
View File

@ -104,11 +104,11 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
public void SyncState(Serializer ser)
{
ser.BeginSection("Port1");
ser.BeginSection(nameof(Port1));
Port1.SyncState(ser);
ser.EndSection();
ser.BeginSection("Port2");
ser.BeginSection(nameof(Port2));
Port2.SyncState(ser);
ser.EndSection();
}

2
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/M6532.cs
View File

@ -196,7 +196,7 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
public void SyncState(Serializer ser)
{
ser.BeginSection("M6532");
ser.BeginSection(nameof(M6532));
ser.Sync("ddra", ref _ddRa);
ser.Sync("ddrb", ref _ddRb);
ser.Sync("OutputA", ref _outputA);

2
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/Mappers/MapperFractalus.cs
View File

@ -102,7 +102,7 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
public override void SyncState(Serializer ser)
{
ser.Sync("RAM", ref RAM, false);
ser.Sync(nameof(RAM), ref RAM, false);
}
}
}

2
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/Mappers/MapperSG.cs
View File

@ -167,7 +167,7 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
public override void SyncState(Serializer ser)
{
ser.Sync("Bank", ref bank);
ser.Sync("RAM", ref RAM, false);
ser.Sync(nameof(RAM), ref RAM, false);
}
}
}

4
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/Maria.cs
View File

@ -698,9 +698,9 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
// also since DMA is always killed at scanline boundaries, most related check variables are also not needed
public void SyncState(Serializer ser)
{
ser.BeginSection("Maria");
ser.BeginSection(nameof(Maria));
ser.Sync("GFX_index", ref GFX_index);
ser.Sync(nameof(GFX_index), ref GFX_index);
ser.EndSection();
}

26
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/Pokey.cs
View File

@ -311,21 +311,21 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
public void SyncState(Serializer ser)
{
ser.BeginSection("Pokey");
ser.BeginSection(nameof(Pokey));
ser.Sync("Regs", ref Regs, false);
ser.Sync(nameof(Regs), ref Regs, false);
ser.Sync("poly4", ref poly4);
ser.Sync("poly5", ref poly5);
ser.Sync("poly9", ref poly9);
ser.Sync("poly17", ref poly17);
ser.Sync("ch_div", ref ch_div, false);
ser.Sync("inc_ch", ref inc_ch, false);
ser.Sync("ch_out", ref ch_out, false);
ser.Sync("ch_src", ref ch_src, false);
ser.Sync("ch_vol", ref ch_vol, false);
ser.Sync("high_pass_1", ref high_pass_1);
ser.Sync("high_pass_2", ref high_pass_2);
ser.Sync(nameof(poly4), ref poly4);
ser.Sync(nameof(poly5), ref poly5);
ser.Sync(nameof(poly9), ref poly9);
ser.Sync(nameof(poly17), ref poly17);
ser.Sync(nameof(ch_div), ref ch_div, false);
ser.Sync(nameof(inc_ch), ref inc_ch, false);
ser.Sync(nameof(ch_out), ref ch_out, false);
ser.Sync(nameof(ch_src), ref ch_src, false);
ser.Sync(nameof(ch_vol), ref ch_vol, false);
ser.Sync(nameof(high_pass_1), ref high_pass_1);
ser.Sync(nameof(high_pass_2), ref high_pass_2);
ser.EndSection();
}

20
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/TIA_Sound/Tia.Audio.cs
View File

@ -196,16 +196,16 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
public void SyncState(Serializer ser)
{
ser.Sync("AUDC", ref AUDC);
ser.Sync("AUDF", ref AUDF);
ser.Sync("AUDV", ref AUDV);
ser.Sync("sr1", ref sr1);
ser.Sync("sr3", ref sr3);
ser.Sync("sr4", ref sr4);
ser.Sync("sr5", ref sr5);
ser.Sync("sr9", ref sr9);
ser.Sync("freqcnt", ref freqcnt);
ser.Sync("on", ref on);
ser.Sync(nameof(AUDC), ref AUDC);
ser.Sync(nameof(AUDF), ref AUDF);
ser.Sync(nameof(AUDV), ref AUDV);
ser.Sync(nameof(sr1), ref sr1);
ser.Sync(nameof(sr3), ref sr3);
ser.Sync(nameof(sr4), ref sr4);
ser.Sync(nameof(sr5), ref sr5);
ser.Sync(nameof(sr9), ref sr9);
ser.Sync(nameof(freqcnt), ref freqcnt);
ser.Sync(nameof(on), ref on);
}
}
}

4
BizHawk.Emulation.Cores/Consoles/Atari/A7800Hawk/TIA_Sound/Tia.SyncState.cs
View File

@ -6,7 +6,7 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
{
public void SyncState(Serializer ser)
{
ser.BeginSection("TIA");
ser.BeginSection(nameof(TIA));
ser.Sync("hsyncCnt", ref _hsyncCnt);
@ -19,7 +19,7 @@ namespace BizHawk.Emulation.Cores.Atari.A7800Hawk
// states were always taken at frame boundaries
ser.Sync("capChargeStart", ref _capChargeStart);
ser.Sync("capCharging", ref _capCharging);
ser.Sync("AudioClocks", ref AudioClocks);
ser.Sync(nameof(AudioClocks), ref AudioClocks);
ser.Sync("FrameStartCycles", ref _frameStartCycles);
ser.Sync("FrameEndCycles", ref _frameEndCycles);

4
BizHawk.Emulation.Cores/Consoles/Atari/lynx/Lynx.IStatable.cs
View File

@ -40,7 +40,7 @@ namespace BizHawk.Emulation.Cores.Atari.Lynx
{
if (!LibLynx.BinStateSave(Core, _savebuff, _savebuff.Length))
{
throw new InvalidOperationException("Core's BinStateSave() returned false!");
throw new InvalidOperationException($"Core's {nameof(LibLynx.BinStateSave)}() returned false!");
}
writer.Write(_savebuff.Length);
@ -63,7 +63,7 @@ namespace BizHawk.Emulation.Cores.Atari.Lynx
reader.Read(_savebuff, 0, length);
if (!LibLynx.BinStateLoad(Core, _savebuff, _savebuff.Length))
{
throw new InvalidOperationException("Core's BinStateLoad() returned false!");
throw new InvalidOperationException($"Core's {nameof(LibLynx.BinStateLoad)}() returned false!");
}
// other variables

28
BizHawk.Emulation.Cores/Consoles/Coleco/AY_3_8910_SGM.cs
View File

@ -65,21 +65,21 @@ namespace BizHawk.Emulation.Cores.ColecoVision
{
ser.BeginSection("PSG");
ser.Sync("Register", ref Register, false);
ser.Sync(nameof(Register), ref Register, false);
ser.Sync("psg_clock", ref psg_clock);
ser.Sync("clock_A", ref clock_A);
ser.Sync("clock_B", ref clock_B);
ser.Sync("clock_C", ref clock_C);
ser.Sync("noise_clock", ref noise_clock);
ser.Sync("env_clock", ref env_clock);
ser.Sync("A_up", ref A_up);
ser.Sync("B_up", ref B_up);
ser.Sync("C_up", ref C_up);
ser.Sync("noise", ref noise);
ser.Sync("env_E", ref env_E);
ser.Sync("E_up_down", ref E_up_down);
ser.Sync("port_sel", ref port_sel);
ser.Sync(nameof(psg_clock), ref psg_clock);
ser.Sync(nameof(clock_A), ref clock_A);
ser.Sync(nameof(clock_B), ref clock_B);
ser.Sync(nameof(clock_C), ref clock_C);
ser.Sync(nameof(noise_clock), ref noise_clock);
ser.Sync(nameof(env_clock), ref env_clock);
ser.Sync(nameof(A_up), ref A_up);
ser.Sync(nameof(B_up), ref B_up);
ser.Sync(nameof(C_up), ref C_up);
ser.Sync(nameof(noise), ref noise);
ser.Sync(nameof(env_E), ref env_E);
ser.Sync(nameof(E_up_down), ref E_up_down);
ser.Sync(nameof(port_sel), ref port_sel);
sync_psg_state();

8
BizHawk.Emulation.Cores/Consoles/Coleco/ColecoControllerDeck.cs
View File

@ -68,13 +68,13 @@ namespace BizHawk.Emulation.Cores.ColecoVision
public void SyncState(Serializer ser)
{
ser.BeginSection("Port1");
ser.BeginSection(nameof(Port1));
Port1.SyncState(ser);
ser.Sync("temp_wheel1", ref temp_wheel1);
ser.Sync(nameof(temp_wheel1), ref temp_wheel1);
ser.EndSection();
ser.BeginSection("Port2");
ser.Sync("temp_wheel2", ref temp_wheel2);
ser.BeginSection(nameof(Port2));
ser.Sync(nameof(temp_wheel2), ref temp_wheel2);
Port2.SyncState(ser);
ser.EndSection();
}

8
BizHawk.Emulation.Cores/Consoles/Coleco/ColecoVision.IStatable.cs
View File

@ -58,15 +58,15 @@ namespace BizHawk.Emulation.Cores.ColecoVision
PSG.SyncState(ser);
SGM_sound.SyncState(ser);
ser.Sync("UseSGM", ref use_SGM);
ser.Sync("is_MC", ref is_MC);
ser.Sync("MC_bank", ref MC_bank);
ser.Sync(nameof(is_MC), ref is_MC);
ser.Sync(nameof(MC_bank), ref MC_bank);
ser.Sync("EnableSGMhigh", ref enable_SGM_high);
ser.Sync("EnableSGMlow", ref enable_SGM_low);
ser.Sync("Port_0x53", ref port_0x53);
ser.Sync("Port_0x7F", ref port_0x7F);
ser.Sync("RAM", ref _ram, false);
ser.Sync("SGM_high_RAM", ref SGM_high_RAM, false);
ser.Sync("SGM_low_RAM", ref SGM_low_RAM, false);
ser.Sync(nameof(SGM_high_RAM), ref SGM_high_RAM, false);
ser.Sync(nameof(SGM_low_RAM), ref SGM_low_RAM, false);
ser.Sync("Frame", ref _frame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("IsLag", ref _isLag);

26
BizHawk.Emulation.Cores/Consoles/Coleco/SN76489col.cs
View File

@ -53,28 +53,28 @@ namespace BizHawk.Emulation.Cores.ColecoVision
{
ser.BeginSection("SN76489");
ser.Sync("Chan_vol", ref Chan_vol, false);
ser.Sync("Chan_tone", ref Chan_tone, false);
ser.Sync(nameof(Chan_vol), ref Chan_vol, false);
ser.Sync(nameof(Chan_tone), ref Chan_tone, false);
ser.Sync("Chan_sel", ref chan_sel);
ser.Sync("vol_tone", ref vol_tone);
ser.Sync("noise_type", ref noise_type);
ser.Sync("noise_rate", ref noise_rate);
ser.Sync(nameof(vol_tone), ref vol_tone);
ser.Sync(nameof(noise_type), ref noise_type);
ser.Sync(nameof(noise_rate), ref noise_rate);
ser.Sync("Clock_A", ref clock_A);
ser.Sync("Clock_B", ref clock_B);
ser.Sync("Clock_C", ref clock_C);
ser.Sync("noise_clock", ref noise_clock);
ser.Sync("noise_bit", ref noise_bit);
ser.Sync(nameof(noise_clock), ref noise_clock);
ser.Sync(nameof(noise_bit), ref noise_bit);
ser.Sync("psg_clock", ref psg_clock);
ser.Sync(nameof(psg_clock), ref psg_clock);
ser.Sync("A_up", ref A_up);
ser.Sync("B_up", ref B_up);
ser.Sync("C_up", ref C_up);
ser.Sync("noise", ref noise);
ser.Sync(nameof(A_up), ref A_up);
ser.Sync(nameof(B_up), ref B_up);
ser.Sync(nameof(C_up), ref C_up);
ser.Sync(nameof(noise), ref noise);
ser.Sync("current_sample", ref current_sample);
ser.Sync(nameof(current_sample), ref current_sample);
ser.EndSection();
}

8
BizHawk.Emulation.Cores/Consoles/Coleco/TMS9918A.cs
View File

@ -511,13 +511,13 @@ namespace BizHawk.Emulation.Cores.ColecoVision
public void SyncState(Serializer ser)
{
ser.BeginSection("VDP");
ser.Sync("StatusByte", ref StatusByte);
ser.Sync(nameof(StatusByte), ref StatusByte);
ser.Sync("WaitingForLatchByte", ref VdpWaitingForLatchByte);
ser.Sync("Latch", ref VdpLatch);
ser.Sync("ReadBuffer", ref VdpBuffer);
ser.Sync("VdpAddress", ref VdpAddress);
ser.Sync("Registers", ref Registers, false);
ser.Sync("VRAM", ref VRAM, false);
ser.Sync(nameof(VdpAddress), ref VdpAddress);
ser.Sync(nameof(Registers), ref Registers, false);
ser.Sync(nameof(VRAM), ref VRAM, false);
ser.EndSection();
if (ser.IsReader)

2
BizHawk.Emulation.Cores/Consoles/Intellivision/Cartridge.cs
View File

@ -23,7 +23,7 @@ namespace BizHawk.Emulation.Cores.Intellivision
ser.BeginSection("Cart");
ser.Sync("mapper", ref _mapper);
ser.Sync("Cart_Ram", ref Cart_Ram, false);
ser.Sync(nameof(Cart_Ram), ref Cart_Ram, false);
ser.EndSection();
}

4
BizHawk.Emulation.Cores/Consoles/Intellivision/Controllers/IntellivisionControllerDeck.cs
View File

@ -59,11 +59,11 @@ namespace BizHawk.Emulation.Cores.Intellivision
public void SyncState(Serializer ser)
{
ser.BeginSection("Port1");
ser.BeginSection(nameof(Port1));
Port1.SyncState(ser);
ser.EndSection();
ser.BeginSection("Port2");
ser.BeginSection(nameof(Port2));
Port2.SyncState(ser);
ser.EndSection();
}

14
BizHawk.Emulation.Cores/Consoles/Intellivision/Intellivision.IStatable.cs
View File

@ -43,16 +43,16 @@ namespace BizHawk.Emulation.Cores.Intellivision
private void SyncState(Serializer ser)
{
int version = 1;
ser.BeginSection("Intellivision");
ser.Sync("version", ref version);
ser.BeginSection(nameof(Intellivision));
ser.Sync(nameof(version), ref version);
ser.Sync("Frame", ref _frame);
ser.Sync("stic_row", ref _sticRow);
ser.Sync("ScratchpadRam", ref ScratchpadRam, false);
ser.Sync("SystemRam", ref SystemRam, false);
ser.Sync("ExecutiveRom", ref ExecutiveRom, false);
ser.Sync("GraphicsRom", ref GraphicsRom, false);
ser.Sync("GraphicsRam", ref GraphicsRam, false);
ser.Sync(nameof(ScratchpadRam), ref ScratchpadRam, false);
ser.Sync(nameof(SystemRam), ref SystemRam, false);
ser.Sync(nameof(ExecutiveRom), ref ExecutiveRom, false);
ser.Sync(nameof(GraphicsRom), ref GraphicsRom, false);
ser.Sync(nameof(GraphicsRam), ref GraphicsRam, false);
ser.Sync("islag", ref _islag);
ser.Sync("lagcount", ref _lagcount);

28
BizHawk.Emulation.Cores/Consoles/Intellivision/PSG.cs
View File

@ -118,24 +118,24 @@ namespace BizHawk.Emulation.Cores.Intellivision
public void SyncState(Serializer ser)
{
ser.BeginSection("PSG");
ser.BeginSection(nameof(PSG));
ser.Sync("Register", ref Register, false);
ser.Sync(nameof(Register), ref Register, false);
ser.Sync("Toal_executed_cycles", ref TotalExecutedCycles);
ser.Sync("Pending_Cycles", ref PendingCycles);
ser.Sync("psg_clock", ref psg_clock);
ser.Sync("clock_A", ref clock_A);
ser.Sync("clock_B", ref clock_B);
ser.Sync("clock_C", ref clock_C);
ser.Sync("noise_clock", ref noise_clock);
ser.Sync("env_clock", ref env_clock);
ser.Sync("A_up", ref A_up);
ser.Sync("B_up", ref B_up);
ser.Sync("C_up", ref C_up);
ser.Sync("noise", ref noise);
ser.Sync("env_E", ref env_E);
ser.Sync("E_up_down", ref E_up_down);
ser.Sync(nameof(psg_clock), ref psg_clock);
ser.Sync(nameof(clock_A), ref clock_A);
ser.Sync(nameof(clock_B), ref clock_B);
ser.Sync(nameof(clock_C), ref clock_C);
ser.Sync(nameof(noise_clock), ref noise_clock);
ser.Sync(nameof(env_clock), ref env_clock);
ser.Sync(nameof(A_up), ref A_up);
ser.Sync(nameof(B_up), ref B_up);
ser.Sync(nameof(C_up), ref C_up);
ser.Sync(nameof(noise), ref noise);
ser.Sync(nameof(env_E), ref env_E);
ser.Sync(nameof(E_up_down), ref E_up_down);
sync_psg_state();

16
BizHawk.Emulation.Cores/Consoles/Intellivision/STIC.cs
View File

@ -30,15 +30,15 @@ namespace BizHawk.Emulation.Cores.Intellivision
public void SyncState(Serializer ser)
{
ser.BeginSection("STIC");
ser.BeginSection(nameof(STIC));
ser.Sync("Sr1", ref Sr1);
ser.Sync("Sr2", ref Sr2);
ser.Sync("Sst", ref Sst);
ser.Sync("active_display", ref active_display);
ser.Sync("in_vb_1", ref in_vb_1);
ser.Sync("in_vb_2", ref in_vb_2);
ser.Sync("Fgbg", ref Fgbg);
ser.Sync(nameof(Sr1), ref Sr1);
ser.Sync(nameof(Sr2), ref Sr2);
ser.Sync(nameof(Sst), ref Sst);
ser.Sync(nameof(active_display), ref active_display);
ser.Sync(nameof(in_vb_1), ref in_vb_1);
ser.Sync(nameof(in_vb_2), ref in_vb_2);
ser.Sync(nameof(Fgbg), ref Fgbg);
ser.Sync("Toal_executed_cycles", ref TotalExecutedCycles);
ser.Sync("Pending_Cycles", ref PendingCycles);
ser.Sync("Registers", ref Register, false);

2
BizHawk.Emulation.Cores/Consoles/Magnavox/O2Em.cs
View File

@ -39,7 +39,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Magnavox
if (!_core.Init(rom, rom.Length, bios, bios.Length))
throw new InvalidOperationException("Init() failed");
throw new InvalidOperationException($"{nameof(_core.Init)}() failed");
PostInit();
}

2
BizHawk.Emulation.Cores/Consoles/Nintendo/GBA/MGBAHawk.cs
View File

@ -40,7 +40,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
_core = LibmGBA.BizCreate(bios, file, file.Length, GetOverrideInfo(game), skipBios);
if (_core == IntPtr.Zero)
{
throw new InvalidOperationException("BizCreate() returned NULL! Bad BIOS? and/or ROM?");
throw new InvalidOperationException($"{nameof(LibmGBA.BizCreate)}() returned NULL! Bad BIOS? and/or ROM?");
}
try

4
BizHawk.Emulation.Cores/Consoles/Nintendo/GBA/VBANext.ISaveRam.cs
View File

@ -12,7 +12,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
var data = new byte[LibVBANext.SaveRamSize(Core)];
if (!LibVBANext.SaveRamSave(Core, data, data.Length))
{
throw new InvalidOperationException("SaveRamSave() failed!");
throw new InvalidOperationException($"{nameof(LibVBANext.SaveRamSave)}() failed!");
}
return data;
@ -23,7 +23,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
// internally, we try to salvage bad-sized saverams
if (!LibVBANext.SaveRamLoad(Core, data, data.Length))
{
throw new InvalidOperationException("SaveRamLoad() failed!");
throw new InvalidOperationException($"{nameof(LibVBANext.SaveRamLoad)}() failed!");
}
}
}

4
BizHawk.Emulation.Cores/Consoles/Nintendo/GBA/VBANext.IStatable.cs
View File

@ -39,7 +39,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
public void SaveStateBinary(BinaryWriter writer)
{
if (!LibVBANext.BinStateSave(Core, _savebuff, _savebuff.Length))
throw new InvalidOperationException("Core's BinStateSave() returned false!");
throw new InvalidOperationException($"Core's {nameof(LibVBANext.BinStateSave)}() returned false!");
writer.Write(_savebuff.Length);
writer.Write(_savebuff);
@ -56,7 +56,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
throw new InvalidOperationException("Save buffer size mismatch!");
reader.Read(_savebuff, 0, length);
if (!LibVBANext.BinStateLoad(Core, _savebuff, _savebuff.Length))
throw new InvalidOperationException("Core's BinStateLoad() returned false!");
throw new InvalidOperationException($"Core's {nameof(LibVBANext.BinStateLoad)}() returned false!");
// other variables
IsLagFrame = reader.ReadBoolean();

4
BizHawk.Emulation.Cores/Consoles/Nintendo/GBA/VBANext.cs
View File

@ -57,11 +57,11 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBA
Core = LibVBANext.Create();
if (Core == IntPtr.Zero)
throw new InvalidOperationException("Create() returned nullptr!");
throw new InvalidOperationException($"{nameof(LibVBANext.Create)}() returned nullptr!");
try
{
if (!LibVBANext.LoadRom(Core, file, (uint)file.Length, biosfile, (uint)biosfile.Length, FES))
throw new InvalidOperationException("LoadRom() returned false!");
throw new InvalidOperationException($"{nameof(LibVBANext.LoadRom)}() returned false!");
Tracer = new TraceBuffer()
{

186
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/Audio.cs
View File

@ -950,113 +950,113 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public void SyncState(Serializer ser)
{
ser.Sync("Audio_Regs", ref Audio_Regs, false);
ser.Sync(nameof(Audio_Regs), ref Audio_Regs, false);
ser.Sync("Wave_Ram", ref Wave_RAM, false);
ser.Sync("SQ1_vol_done", ref SQ1_vol_done);
ser.Sync("SQ1_calc_done", ref SQ1_calc_done);
ser.Sync("SQ1_swp_enable", ref SQ1_swp_enable);
ser.Sync(nameof(SQ1_vol_done), ref SQ1_vol_done);
ser.Sync(nameof(SQ1_calc_done), ref SQ1_calc_done);
ser.Sync(nameof(SQ1_swp_enable), ref SQ1_swp_enable);
ser.Sync("SQ1_length_counter", ref SQ1_len_cntr);
ser.Sync("SQ1_enable", ref SQ1_enable);
ser.Sync("SQ1_vol_state", ref SQ1_vol_state);
ser.Sync("SQ1_duty_cntr", ref SQ1_duty_cntr);
ser.Sync("SQ1_frq_shadow", ref SQ1_frq_shadow);
ser.Sync("SQ1_intl_cntr", ref SQ1_intl_cntr);
ser.Sync("SQ1_vol_per", ref SQ1_vol_per);
ser.Sync("SQ1_intl_swp_cnt", ref SQ1_intl_swp_cnt);
ser.Sync("SQ1_len_cntr", ref SQ1_len_cntr);
ser.Sync("SQ1_negate", ref SQ1_negate);
ser.Sync("SQ1_trigger", ref SQ1_trigger);
ser.Sync("SQ1_len_en", ref SQ1_len_en);
ser.Sync("SQ1_env_add", ref SQ1_env_add);
ser.Sync("SQ1_shift", ref SQ1_shift);
ser.Sync("SQ1_duty", ref SQ1_duty);
ser.Sync("SQ1_st_vol", ref SQ1_st_vol);
ser.Sync("SQ1_per", ref SQ1_per);
ser.Sync("SQ1_swp_prd", ref SQ1_swp_prd);
ser.Sync("SQ1_frq", ref SQ1_frq);
ser.Sync("SQ1_length", ref SQ1_length);
ser.Sync("SQ1_output", ref SQ1_output);
ser.Sync(nameof(SQ1_enable), ref SQ1_enable);
ser.Sync(nameof(SQ1_vol_state), ref SQ1_vol_state);
ser.Sync(nameof(SQ1_duty_cntr), ref SQ1_duty_cntr);
ser.Sync(nameof(SQ1_frq_shadow), ref SQ1_frq_shadow);
ser.Sync(nameof(SQ1_intl_cntr), ref SQ1_intl_cntr);
ser.Sync(nameof(SQ1_vol_per), ref SQ1_vol_per);
ser.Sync(nameof(SQ1_intl_swp_cnt), ref SQ1_intl_swp_cnt);
ser.Sync(nameof(SQ1_len_cntr), ref SQ1_len_cntr);
ser.Sync(nameof(SQ1_negate), ref SQ1_negate);
ser.Sync(nameof(SQ1_trigger), ref SQ1_trigger);
ser.Sync(nameof(SQ1_len_en), ref SQ1_len_en);
ser.Sync(nameof(SQ1_env_add), ref SQ1_env_add);
ser.Sync(nameof(SQ1_shift), ref SQ1_shift);
ser.Sync(nameof(SQ1_duty), ref SQ1_duty);
ser.Sync(nameof(SQ1_st_vol), ref SQ1_st_vol);
ser.Sync(nameof(SQ1_per), ref SQ1_per);
ser.Sync(nameof(SQ1_swp_prd), ref SQ1_swp_prd);
ser.Sync(nameof(SQ1_frq), ref SQ1_frq);
ser.Sync(nameof(SQ1_length), ref SQ1_length);
ser.Sync(nameof(SQ1_output), ref SQ1_output);
ser.Sync("SQ2_vol_done", ref SQ2_vol_done);
ser.Sync(nameof(SQ2_vol_done), ref SQ2_vol_done);
ser.Sync("SQ2_length_counter", ref SQ2_len_cntr);
ser.Sync("SQ2_enable", ref SQ2_enable);
ser.Sync("SQ2_vol_state", ref SQ2_vol_state);
ser.Sync("SQ2_duty_cntr", ref SQ2_duty_cntr);
ser.Sync("SQ2_intl_cntr", ref SQ2_intl_cntr);
ser.Sync("SQ2_vol_per", ref SQ2_vol_per);
ser.Sync("SQ2_len_cntr", ref SQ2_len_cntr);
ser.Sync("SQ2_trigger", ref SQ2_trigger);
ser.Sync("SQ2_len_en", ref SQ2_len_en);
ser.Sync("SQ2_env_add", ref SQ2_env_add);
ser.Sync("SQ2_duty", ref SQ2_duty);
ser.Sync("SQ2_st_vol", ref SQ2_st_vol);
ser.Sync("SQ2_per", ref SQ2_per);
ser.Sync("SQ2_frq", ref SQ2_frq);
ser.Sync("SQ2_length", ref SQ2_length);
ser.Sync("SQ2_output", ref SQ2_output);
ser.Sync(nameof(SQ2_enable), ref SQ2_enable);
ser.Sync(nameof(SQ2_vol_state), ref SQ2_vol_state);
ser.Sync(nameof(SQ2_duty_cntr), ref SQ2_duty_cntr);
ser.Sync(nameof(SQ2_intl_cntr), ref SQ2_intl_cntr);
ser.Sync(nameof(SQ2_vol_per), ref SQ2_vol_per);
ser.Sync(nameof(SQ2_len_cntr), ref SQ2_len_cntr);
ser.Sync(nameof(SQ2_trigger), ref SQ2_trigger);
ser.Sync(nameof(SQ2_len_en), ref SQ2_len_en);
ser.Sync(nameof(SQ2_env_add), ref SQ2_env_add);
ser.Sync(nameof(SQ2_duty), ref SQ2_duty);
ser.Sync(nameof(SQ2_st_vol), ref SQ2_st_vol);
ser.Sync(nameof(SQ2_per), ref SQ2_per);
ser.Sync(nameof(SQ2_frq), ref SQ2_frq);
ser.Sync(nameof(SQ2_length), ref SQ2_length);
ser.Sync(nameof(SQ2_output), ref SQ2_output);
ser.Sync("WAVE_can_get", ref WAVE_can_get);
ser.Sync(nameof(WAVE_can_get), ref WAVE_can_get);
ser.Sync("WAVE_length_counter", ref WAVE_len_cntr);
ser.Sync("WAVE_enable", ref WAVE_enable);
ser.Sync("WAVE_wave_cntr", ref WAVE_wave_cntr);
ser.Sync("WAVE_intl_cntr", ref WAVE_intl_cntr);
ser.Sync("WAVE_len_cntr", ref WAVE_len_cntr);
ser.Sync("WAVE_DAC_pow", ref WAVE_DAC_pow);
ser.Sync("WAVE_trigger", ref WAVE_trigger);
ser.Sync("WAVE_len_en", ref WAVE_len_en);
ser.Sync("WAVE_vol_code", ref WAVE_vol_code);
ser.Sync("WAVE_frq", ref WAVE_frq);
ser.Sync("WAVE_length", ref WAVE_length);
ser.Sync("WAVE_output", ref WAVE_output);
ser.Sync(nameof(WAVE_enable), ref WAVE_enable);
ser.Sync(nameof(WAVE_wave_cntr), ref WAVE_wave_cntr);
ser.Sync(nameof(WAVE_intl_cntr), ref WAVE_intl_cntr);
ser.Sync(nameof(WAVE_len_cntr), ref WAVE_len_cntr);
ser.Sync(nameof(WAVE_DAC_pow), ref WAVE_DAC_pow);
ser.Sync(nameof(WAVE_trigger), ref WAVE_trigger);
ser.Sync(nameof(WAVE_len_en), ref WAVE_len_en);
ser.Sync(nameof(WAVE_vol_code), ref WAVE_vol_code);
ser.Sync(nameof(WAVE_frq), ref WAVE_frq);
ser.Sync(nameof(WAVE_length), ref WAVE_length);
ser.Sync(nameof(WAVE_output), ref WAVE_output);
ser.Sync("NOISE_vol_done", ref NOISE_vol_done);
ser.Sync(nameof(NOISE_vol_done), ref NOISE_vol_done);
ser.Sync("NOISE_length_counter", ref NOISE_len_cntr);
ser.Sync("NOISE_enable", ref NOISE_enable);
ser.Sync("NOISE_vol_state", ref NOISE_vol_state);
ser.Sync("NOISE_intl_cntr", ref NOISE_intl_cntr);
ser.Sync("NOISE_vol_per", ref NOISE_vol_per);
ser.Sync("NOISE_LFSR", ref NOISE_LFSR);
ser.Sync("NOISE_len_cntr", ref NOISE_len_cntr);
ser.Sync("NOISE_wdth_md", ref NOISE_wdth_md);
ser.Sync("NOISE_trigger", ref NOISE_trigger);
ser.Sync("NOISE_len_en", ref NOISE_len_en);
ser.Sync("NOISE_env_add", ref NOISE_env_add);
ser.Sync("NOISE_clk_shft", ref NOISE_clk_shft);
ser.Sync("NOISE_div_code", ref NOISE_div_code);
ser.Sync("NOISE_st_vol", ref NOISE_st_vol);
ser.Sync("NOISE_per", ref NOISE_per);
ser.Sync("NOISE_length", ref NOISE_length);
ser.Sync("NOISE_output", ref NOISE_output);
ser.Sync(nameof(NOISE_enable), ref NOISE_enable);
ser.Sync(nameof(NOISE_vol_state), ref NOISE_vol_state);
ser.Sync(nameof(NOISE_intl_cntr), ref NOISE_intl_cntr);
ser.Sync(nameof(NOISE_vol_per), ref NOISE_vol_per);
ser.Sync(nameof(NOISE_LFSR), ref NOISE_LFSR);
ser.Sync(nameof(NOISE_len_cntr), ref NOISE_len_cntr);
ser.Sync(nameof(NOISE_wdth_md), ref NOISE_wdth_md);
ser.Sync(nameof(NOISE_trigger), ref NOISE_trigger);
ser.Sync(nameof(NOISE_len_en), ref NOISE_len_en);
ser.Sync(nameof(NOISE_env_add), ref NOISE_env_add);
ser.Sync(nameof(NOISE_clk_shft), ref NOISE_clk_shft);
ser.Sync(nameof(NOISE_div_code), ref NOISE_div_code);
ser.Sync(nameof(NOISE_st_vol), ref NOISE_st_vol);
ser.Sync(nameof(NOISE_per), ref NOISE_per);
ser.Sync(nameof(NOISE_length), ref NOISE_length);
ser.Sync(nameof(NOISE_output), ref NOISE_output);
ser.Sync("sequencer_len", ref sequencer_len);
ser.Sync("sequencer_vol", ref sequencer_vol);
ser.Sync("sequencer_swp", ref sequencer_swp);
ser.Sync("timer_bit_old", ref timer_bit_old);
ser.Sync(nameof(sequencer_len), ref sequencer_len);
ser.Sync(nameof(sequencer_vol), ref sequencer_vol);
ser.Sync(nameof(sequencer_swp), ref sequencer_swp);
ser.Sync(nameof(timer_bit_old), ref timer_bit_old);
ser.Sync("master_audio_clock", ref master_audio_clock);
ser.Sync(nameof(master_audio_clock), ref master_audio_clock);
ser.Sync("sample", ref sample);
ser.Sync("latched_sample_L", ref latched_sample_L);
ser.Sync("latched_sample_R", ref latched_sample_R);
ser.Sync(nameof(sample), ref sample);
ser.Sync(nameof(latched_sample_L), ref latched_sample_L);
ser.Sync(nameof(latched_sample_R), ref latched_sample_R);
ser.Sync("AUD_CTRL_vin_L_en", ref AUD_CTRL_vin_L_en);
ser.Sync("AUD_CTRL_vin_R_en", ref AUD_CTRL_vin_R_en);
ser.Sync("AUD_CTRL_sq1_L_en", ref AUD_CTRL_sq1_L_en);
ser.Sync("AUD_CTRL_sq2_L_en", ref AUD_CTRL_sq2_L_en);
ser.Sync("AUD_CTRL_wave_L_en", ref AUD_CTRL_wave_L_en);
ser.Sync("AUD_CTRL_noise_L_en", ref AUD_CTRL_noise_L_en);
ser.Sync("AUD_CTRL_sq1_R_en", ref AUD_CTRL_sq1_R_en);
ser.Sync("AUD_CTRL_sq2_R_en", ref AUD_CTRL_sq2_R_en);
ser.Sync("AUD_CTRL_wave_R_en", ref AUD_CTRL_wave_R_en);
ser.Sync("AUD_CTRL_noise_R_en", ref AUD_CTRL_noise_R_en);
ser.Sync("AUD_CTRL_power", ref AUD_CTRL_power);
ser.Sync("AUD_CTRL_vol_L", ref AUD_CTRL_vol_L);
ser.Sync("AUD_CTRL_vol_R", ref AUD_CTRL_vol_R);
ser.Sync(nameof(AUD_CTRL_vin_L_en), ref AUD_CTRL_vin_L_en);
ser.Sync(nameof(AUD_CTRL_vin_R_en), ref AUD_CTRL_vin_R_en);
ser.Sync(nameof(AUD_CTRL_sq1_L_en), ref AUD_CTRL_sq1_L_en);
ser.Sync(nameof(AUD_CTRL_sq2_L_en), ref AUD_CTRL_sq2_L_en);
ser.Sync(nameof(AUD_CTRL_wave_L_en), ref AUD_CTRL_wave_L_en);
ser.Sync(nameof(AUD_CTRL_noise_L_en), ref AUD_CTRL_noise_L_en);
ser.Sync(nameof(AUD_CTRL_sq1_R_en), ref AUD_CTRL_sq1_R_en);
ser.Sync(nameof(AUD_CTRL_sq2_R_en), ref AUD_CTRL_sq2_R_en);
ser.Sync(nameof(AUD_CTRL_wave_R_en), ref AUD_CTRL_wave_R_en);
ser.Sync(nameof(AUD_CTRL_noise_R_en), ref AUD_CTRL_noise_R_en);
ser.Sync(nameof(AUD_CTRL_power), ref AUD_CTRL_power);
ser.Sync(nameof(AUD_CTRL_vol_L), ref AUD_CTRL_vol_L);
ser.Sync(nameof(AUD_CTRL_vol_R), ref AUD_CTRL_vol_R);
ser.Sync("WAVE_output_decay", ref WAVE_output_decay);
ser.Sync("WAVE_output_decay_L", ref WAVE_output_decay_L);
ser.Sync("WAVE_output_decay_R", ref WAVE_output_decay_R);
ser.Sync(nameof(WAVE_output_decay), ref WAVE_output_decay);
ser.Sync(nameof(WAVE_output_decay_L), ref WAVE_output_decay_L);
ser.Sync(nameof(WAVE_output_decay_R), ref WAVE_output_decay_R);
}
public byte Read_NR52()

50
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/GBC_PPU.cs
View File

@ -1532,34 +1532,34 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
{
ser.Sync("pal_transfer_byte", ref BG_transfer_byte);
ser.Sync("spr_transfer_byte", ref OBJ_transfer_byte);
ser.Sync("HDMA_src_hi", ref HDMA_src_hi);
ser.Sync("HDMA_src_lo", ref HDMA_src_lo);
ser.Sync("HDMA_dest_hi", ref HDMA_dest_hi);
ser.Sync("HDMA_dest_lo", ref HDMA_dest_lo);
ser.Sync("HDMA_tick", ref HDMA_tick);
ser.Sync("HDMA_byte", ref HDMA_byte);
ser.Sync(nameof(HDMA_src_hi), ref HDMA_src_hi);
ser.Sync(nameof(HDMA_src_lo), ref HDMA_src_lo);
ser.Sync(nameof(HDMA_dest_hi), ref HDMA_dest_hi);
ser.Sync(nameof(HDMA_dest_lo), ref HDMA_dest_lo);
ser.Sync(nameof(HDMA_tick), ref HDMA_tick);
ser.Sync(nameof(HDMA_byte), ref HDMA_byte);
ser.Sync("VRAM_sel", ref VRAM_sel);
ser.Sync("BG_V_flip", ref BG_V_flip);
ser.Sync("HDMA_mode", ref HDMA_mode);
ser.Sync("cur_DMA_src", ref cur_DMA_src);
ser.Sync("cur_DMA_dest", ref cur_DMA_dest);
ser.Sync("HDMA_length", ref HDMA_length);
ser.Sync("HDMA_countdown", ref HDMA_countdown);
ser.Sync("HBL_HDMA_count", ref HBL_HDMA_count);
ser.Sync("last_HBL", ref last_HBL);
ser.Sync("HBL_HDMA_go", ref HBL_HDMA_go);
ser.Sync("HBL_test", ref HBL_test);
ser.Sync(nameof(VRAM_sel), ref VRAM_sel);
ser.Sync(nameof(BG_V_flip), ref BG_V_flip);
ser.Sync(nameof(HDMA_mode), ref HDMA_mode);
ser.Sync(nameof(cur_DMA_src), ref cur_DMA_src);
ser.Sync(nameof(cur_DMA_dest), ref cur_DMA_dest);
ser.Sync(nameof(HDMA_length), ref HDMA_length);
ser.Sync(nameof(HDMA_countdown), ref HDMA_countdown);
ser.Sync(nameof(HBL_HDMA_count), ref HBL_HDMA_count);
ser.Sync(nameof(last_HBL), ref last_HBL);
ser.Sync(nameof(HBL_HDMA_go), ref HBL_HDMA_go);
ser.Sync(nameof(HBL_test), ref HBL_test);
ser.Sync("BG_bytes", ref BG_bytes, false);
ser.Sync("OBJ_bytes", ref OBJ_bytes, false);
ser.Sync("BG_bytes_inc", ref BG_bytes_inc);
ser.Sync("OBJ_bytes_inc", ref OBJ_bytes_inc);
ser.Sync("BG_bytes_index", ref BG_bytes_index);
ser.Sync("OBJ_bytes_index", ref OBJ_bytes_index);
ser.Sync(nameof(BG_bytes), ref BG_bytes, false);
ser.Sync(nameof(OBJ_bytes), ref OBJ_bytes, false);
ser.Sync(nameof(BG_bytes_inc), ref BG_bytes_inc);
ser.Sync(nameof(OBJ_bytes_inc), ref OBJ_bytes_inc);
ser.Sync(nameof(BG_bytes_index), ref BG_bytes_index);
ser.Sync(nameof(OBJ_bytes_index), ref OBJ_bytes_index);
ser.Sync("LYC_t", ref LYC_t);
ser.Sync("LYC_cd", ref LYC_cd);
ser.Sync(nameof(LYC_t), ref LYC_t);
ser.Sync(nameof(LYC_cd), ref LYC_cd);
base.SyncState(ser);
}

68
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/GBHawk.IStatable.cs
View File

@ -55,56 +55,56 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
audio.SyncState(ser);
ser.BeginSection("Gameboy");
ser.Sync("core", ref core, false);
ser.Sync(nameof(core), ref core, false);
ser.Sync("Lag", ref _lagcount);
ser.Sync("Frame", ref _frame);
ser.Sync("IsLag", ref _islag);
_controllerDeck.SyncState(ser);
ser.Sync("controller_state", ref controller_state);
ser.Sync("Acc_X_state", ref Acc_X_state);
ser.Sync("Acc_Y_state", ref Acc_Y_state);
ser.Sync("in_vblank", ref in_vblank);
ser.Sync("in_vblank_old", ref in_vblank_old);
ser.Sync("vblank_rise", ref vblank_rise);
ser.Sync("GB_bios_register", ref GB_bios_register);
ser.Sync("input_register", ref input_register);
ser.Sync(nameof(controller_state), ref controller_state);
ser.Sync(nameof(Acc_X_state), ref Acc_X_state);
ser.Sync(nameof(Acc_Y_state), ref Acc_Y_state);
ser.Sync(nameof(in_vblank), ref in_vblank);
ser.Sync(nameof(in_vblank_old), ref in_vblank_old);
ser.Sync(nameof(vblank_rise), ref vblank_rise);
ser.Sync(nameof(GB_bios_register), ref GB_bios_register);
ser.Sync(nameof(input_register), ref input_register);
ser.Sync("REG_FFFF", ref REG_FFFF);
ser.Sync("REG_FF0F", ref REG_FF0F);
ser.Sync("REG_FF0F_OLD", ref REG_FF0F_OLD);
ser.Sync(nameof(REG_FFFF), ref REG_FFFF);
ser.Sync(nameof(REG_FF0F), ref REG_FF0F);
ser.Sync(nameof(REG_FF0F_OLD), ref REG_FF0F_OLD);
// memory domains
ser.Sync("RAM", ref RAM, false);
ser.Sync("ZP_RAM", ref ZP_RAM, false);
ser.Sync("VRAM", ref VRAM, false);
ser.Sync("OAM", ref OAM, false);
ser.Sync(nameof(RAM), ref RAM, false);
ser.Sync(nameof(ZP_RAM), ref ZP_RAM, false);
ser.Sync(nameof(VRAM), ref VRAM, false);
ser.Sync(nameof(OAM), ref OAM, false);
ser.Sync("_bios", ref _bios, false);
ser.Sync(nameof(_bios), ref _bios, false);
ser.Sync("RAM_Bank", ref RAM_Bank);
ser.Sync("VRAM_Bank", ref VRAM_Bank);
ser.Sync("is_GBC", ref is_GBC);
ser.Sync("GBC_compat", ref GBC_compat);
ser.Sync("double_speed", ref double_speed);
ser.Sync("speed_switch", ref speed_switch);
ser.Sync("HDMA_transfer", ref HDMA_transfer);
ser.Sync(nameof(RAM_Bank), ref RAM_Bank);
ser.Sync(nameof(VRAM_Bank), ref VRAM_Bank);
ser.Sync(nameof(is_GBC), ref is_GBC);
ser.Sync(nameof(GBC_compat), ref GBC_compat);
ser.Sync(nameof(double_speed), ref double_speed);
ser.Sync(nameof(speed_switch), ref speed_switch);
ser.Sync(nameof(HDMA_transfer), ref HDMA_transfer);
ser.Sync("undoc_6C", ref undoc_6C);
ser.Sync("undoc_72", ref undoc_72);
ser.Sync("undoc_73", ref undoc_73);
ser.Sync("undoc_74", ref undoc_74);
ser.Sync("undoc_75", ref undoc_75);
ser.Sync("undoc_76", ref undoc_76);
ser.Sync("undoc_77", ref undoc_77);
ser.Sync(nameof(undoc_6C), ref undoc_6C);
ser.Sync(nameof(undoc_72), ref undoc_72);
ser.Sync(nameof(undoc_73), ref undoc_73);
ser.Sync(nameof(undoc_74), ref undoc_74);
ser.Sync(nameof(undoc_75), ref undoc_75);
ser.Sync(nameof(undoc_76), ref undoc_76);
ser.Sync(nameof(undoc_77), ref undoc_77);
ser.Sync("Use_MT", ref Use_MT);
ser.Sync("addr_access", ref addr_access);
ser.Sync(nameof(Use_MT), ref Use_MT);
ser.Sync(nameof(addr_access), ref addr_access);
// probably a better way to do this
if (cart_RAM != null)
{
ser.Sync("cart_RAM", ref cart_RAM, false);
ser.Sync(nameof(cart_RAM), ref cart_RAM, false);
}
ser.EndSection();

2
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/GBHawkControllerDeck.cs
View File

@ -50,7 +50,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public void SyncState(Serializer ser)
{
ser.BeginSection("Port1");
ser.BeginSection(nameof(Port1));
Port1.SyncState(ser);
ser.EndSection();
}

2
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/GBHawkControllers.cs
View File

@ -211,7 +211,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public void SyncState(Serializer ser)
{
// since we need rate of change of angle, need to savestate them
ser.Sync("theta", ref theta);
ser.Sync(nameof(theta), ref theta);
}
}
}

12
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/Mappers/Mapper_HuC1.cs
View File

@ -179,12 +179,12 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public override void SyncState(Serializer ser)
{
ser.Sync("ROM_Bank", ref ROM_bank);
ser.Sync("ROM_Mask", ref ROM_mask);
ser.Sync("RAM_Bank", ref RAM_bank);
ser.Sync("RAM_Mask", ref RAM_mask);
ser.Sync("RAM_enable", ref RAM_enable);
ser.Sync("IR_signal", ref IR_signal);
ser.Sync(nameof(ROM_bank), ref ROM_bank);
ser.Sync(nameof(ROM_mask), ref ROM_mask);
ser.Sync(nameof(RAM_bank), ref RAM_bank);
ser.Sync(nameof(RAM_mask), ref RAM_mask);
ser.Sync(nameof(RAM_enable), ref RAM_enable);
ser.Sync(nameof(IR_signal), ref IR_signal);
}
}
}

28
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/Mappers/Mapper_HuC3.cs
View File

@ -284,20 +284,20 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public override void SyncState(Serializer ser)
{
ser.Sync("ROM_Bank", ref ROM_bank);
ser.Sync("ROM_Mask", ref ROM_mask);
ser.Sync("RAM_Bank", ref RAM_bank);
ser.Sync("RAM_Mask", ref RAM_mask);
ser.Sync("RAM_enable", ref RAM_enable);
ser.Sync("IR_signal", ref IR_signal);
ser.Sync("control", ref control);
ser.Sync("chip_read", ref chip_read);
ser.Sync("timer_read", ref timer_read);
ser.Sync("time_val_shift", ref time_val_shift);
ser.Sync("time", ref time);
ser.Sync("RTC_timer", ref RTC_timer);
ser.Sync("RTC_low_clock", ref RTC_low_clock);
ser.Sync("RTC_seconds", ref RTC_seconds);
ser.Sync(nameof(ROM_bank), ref ROM_bank);
ser.Sync(nameof(ROM_mask), ref ROM_mask);
ser.Sync(nameof(RAM_bank), ref RAM_bank);
ser.Sync(nameof(RAM_mask), ref RAM_mask);
ser.Sync(nameof(RAM_enable), ref RAM_enable);
ser.Sync(nameof(IR_signal), ref IR_signal);
ser.Sync(nameof(control), ref control);
ser.Sync(nameof(chip_read), ref chip_read);
ser.Sync(nameof(timer_read), ref timer_read);
ser.Sync(nameof(time_val_shift), ref time_val_shift);
ser.Sync(nameof(time), ref time);
ser.Sync(nameof(RTC_timer), ref RTC_timer);
ser.Sync(nameof(RTC_low_clock), ref RTC_low_clock);
ser.Sync(nameof(RTC_seconds), ref RTC_seconds);
}
}
}

12
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/Mappers/Mapper_MBC1.cs
View File

@ -185,12 +185,12 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public override void SyncState(Serializer ser)
{
ser.Sync("ROM_Bank", ref ROM_bank);
ser.Sync("ROM_Mask", ref ROM_mask);
ser.Sync("RAM_Bank", ref RAM_bank);
ser.Sync("RAM_Mask", ref RAM_mask);
ser.Sync("RAM_enable", ref RAM_enable);
ser.Sync("sel_mode", ref sel_mode);
ser.Sync(nameof(ROM_bank), ref ROM_bank);
ser.Sync(nameof(ROM_mask), ref ROM_mask);
ser.Sync(nameof(RAM_bank), ref RAM_bank);
ser.Sync(nameof(RAM_mask), ref RAM_mask);
ser.Sync(nameof(RAM_enable), ref RAM_enable);
ser.Sync(nameof(sel_mode), ref sel_mode);
}
}
}

12
BizHawk.Emulation.Cores/Consoles/Nintendo/GBHawk/Mappers/Mapper_MBC1_Multi.cs
View File

@ -181,12 +181,12 @@ namespace BizHawk.Emulation.Cores.Nintendo.GBHawk
public override void SyncState(Serializer ser)
{
ser.Sync("ROM_Bank", ref ROM_bank);
ser.Sync("ROM_Mask", ref ROM_mask);
ser.Sync("RAM_Bank", ref RAM_bank);
ser.Sync("RAM_Mask", ref RAM_mask);
ser.Sync("RAM_enable", ref RAM_enable);
ser.Sync("sel_mode", ref sel_mode);
ser.Sync(nameof(ROM_bank), ref ROM_bank);
ser.Sync(nameof(ROM_mask), ref ROM_mask);
ser.Sync(nameof(RAM_bank), ref RAM_bank);
ser.Sync(nameof(RAM_mask), ref RAM_mask);
ser.Sync(nameof(RAM_enable), ref RAM_enable);
ser.Sync(nameof(sel_mode), ref sel_mode);
}
}
}

Some files were not shown because too many files have changed in this diff Show More