public void JumpToAddressConditional(ushort address, ref ushort pc, Flag flag, bool condition, byte flags)
{
if (FlagUtils.GetFlag(flag, flags) == condition)
{
JumpToAddress(address, ref pc);
}
}
public void CallConditional(ushort address, ref ushort sp, ref ushort pc, Flag flag, bool condition, byte flags)
{
if (FlagUtils.GetFlag(flag, flags) == condition)
{
Call(address, ref sp, ref pc);
}
}
public void JumpRelativeConditional(byte value, ref ushort pc, Flag flag, bool condition, byte flags)
{
if (FlagUtils.GetFlag(flag, flags) == condition)
{
JumpRelative(value, ref pc);
}
}
public void DecimalAdjust(ref byte register, ref byte flags)
{
bool subtract = FlagUtils.GetFlag(Flag.N, flags);
bool carry = FlagUtils.GetFlag(Flag.C, flags);
bool halfCarry = FlagUtils.GetFlag(Flag.H, flags);
if (subtract)
{
if (carry)
{
register -= 0x60;
}
if (halfCarry)
{
register -= 0x6;
}
}
else
{
if (register > 0x99 || carry)
{
register += 0x60;
FlagUtils.SetFlag(Flag.C, true, ref flags);
}
if ((register & 0xF) > 0x9 || halfCarry)
{
register += 0x6;
}
}
FlagUtils.SetFlag(Flag.Z, register == 0x00, ref flags);
FlagUtils.SetFlag(Flag.H, false, ref flags);
}
public void ReturnConditional(ref ushort sp, ref ushort pc, Flag flag, bool condition, byte flags)
{
TickEvent?.Invoke();
if (FlagUtils.GetFlag(flag, flags) == condition)
{
Return(ref sp, ref pc);
}
}
public void RotateRightThroughCarry(ref byte register, ref byte flags, bool alwaysResetZero)
{
int carry = FlagUtils.GetFlag(Flag.C, flags) ? 0x80 : 0x0;
bool setCarry = register.IsBitSet(0);
register = (byte)((register >> 1) | carry);
FlagUtils.SetFlags(ref flags, !alwaysResetZero && register == 0, false, false, setCarry);
}
public void GetFlagTest()
{
byte flags = 0b01010000;
Assert.False(FlagUtils.GetFlag(Flag.Z, flags));
Assert.True(FlagUtils.GetFlag(Flag.N, flags));
Assert.False(FlagUtils.GetFlag(Flag.H, flags));
Assert.True(FlagUtils.GetFlag(Flag.C, flags));
}
public void Subtract(ref byte from, byte value, ref byte flags, bool subtractCarryFlag = false)
{
int additionalValue = subtractCarryFlag && FlagUtils.GetFlag(Flag.C, flags) ? 1 : 0;
byte origValue = from;
int newValue = from - value - additionalValue;
from = (byte)(newValue & 0xFF);
FlagUtils.SetFlags(ref flags,
from == 0,
true,
(origValue & 0x0F) - (value & 0xF) - (additionalValue & 0xF) < 0,
origValue < (value + additionalValue));
}
public void Add(ref byte to, byte value, ref byte flags, bool addCarryFlag = false)
{
int additionalValue = addCarryFlag && FlagUtils.GetFlag(Flag.C, flags) ? 1 : 0;
byte origValue = to;
int newValue = to + value + additionalValue;
to = (byte)(newValue & 0xFF);
FlagUtils.SetFlags(ref flags,
to == 0,
false,
(origValue & 0x0F) + (value & 0x0F) + additionalValue > 0x0F,
newValue > 0xFF);
}
public void RotateLeftThroughCarry(ref byte register, ref byte flags, bool alwaysResetZero)
{
bool setCarry = register.IsBitSet(7);
RotateLeft(ref register, FlagUtils.GetFlag(Flag.C, flags));
if (alwaysResetZero)
{
FlagUtils.SetFlag(Flag.Z, false, ref flags);
}
else
{
FlagUtils.SetFlag(Flag.Z, register == 0, ref flags);
}
FlagUtils.SetFlag(Flag.N, false, ref flags);
FlagUtils.SetFlag(Flag.H, false, ref flags);
FlagUtils.SetFlag(Flag.C, setCarry, ref flags);
}
private void PrintRegisterSection()
{
string border = "|".PadRight(4);
Console.SetCursorPosition(leftSectionWidth, 4);
Console.WriteLine($"{border}Registers:");
Console.SetCursorPosition(leftSectionWidth, 5);
Console.WriteLine(border);
Console.SetCursorPosition(leftSectionWidth, 6);
Console.WriteLine($"{border}PC: 0x{cpu.PC:X4}");
Console.SetCursorPosition(leftSectionWidth, 7);
Console.WriteLine($"{border}SP: 0x{cpu.SP:X4}");
Console.SetCursorPosition(leftSectionWidth, 8);
Console.WriteLine(border);
Console.SetCursorPosition(leftSectionWidth, 9);
Console.WriteLine($"{border}A: 0x{cpu.A:X2} F: 0x{cpu.F:X2}");
Console.SetCursorPosition(leftSectionWidth, 10);
Console.WriteLine($"{border}B: 0x{cpu.B:X2} C: 0x{cpu.C:X2}");
Console.SetCursorPosition(leftSectionWidth, 11);
Console.WriteLine($"{border}D: 0x{cpu.D:X2} E: 0x{cpu.E:X2}");
Console.SetCursorPosition(leftSectionWidth, 12);
Console.WriteLine($"{border}H: 0x{cpu.H:x2} L: 0x{cpu.L:x2}");
Console.SetCursorPosition(leftSectionWidth, 13);
Console.WriteLine(border);
Console.SetCursorPosition(leftSectionWidth, 14);
Console.WriteLine($"{border}Flags:");
Console.SetCursorPosition(leftSectionWidth, 15);
Console.WriteLine($"{border}Z: {(FlagUtils.GetFlag(Flag.Z, cpu.F) ? "1" : "0")} N: {(FlagUtils.GetFlag(Flag.N, cpu.F) ? "1" : "0")}");
Console.SetCursorPosition(leftSectionWidth, 16);
Console.WriteLine($"{border}H: { (FlagUtils.GetFlag(Flag.H, cpu.F) ? "1" : "0")} C: { (FlagUtils.GetFlag(Flag.C, cpu.F) ? "1" : "0")}");
Console.SetCursorPosition(leftSectionWidth, 17);
Console.WriteLine($"{border}DIV: 0x{ memory.ReadByte(0xFF04):X2} TIMA: 0x{ memory.ReadByte(0xFF05):X2}");
}
public void ComplementCarry(ref byte flags)
{
FlagUtils.SetFlag(Flag.C, !FlagUtils.GetFlag(Flag.C, flags), ref flags);
FlagUtils.SetFlag(Flag.H, false, ref flags);
FlagUtils.SetFlag(Flag.N, false, ref flags);
}
