public void FlagUtils_TestAll()
{
Assert.IsTrue(FlagUtils.GetOrder(0x08) == 3);
Assert.IsTrue(FlagUtils.GetOrder(0x01) == 0);
Assert.IsTrue(FlagUtils.GetMask(0) == 1);
Assert.IsTrue(FlagUtils.GetMask(2) == 4);
int test1 = 0x1010;
Assert.IsTrue(FlagUtils.GetBit(test1, 0x1000) == true);
Assert.AreEqual(FlagUtils.GetBit(test1, 0x0100), false);
Assert.AreEqual(FlagUtils.GetBit(test1, 0x0010), true);
test1 = FlagUtils.SetBit(test1, 0x0100, true);
Assert.AreEqual(test1, 0x1110);
test1 = FlagUtils.SetBit(test1, 0x1000, false);
Assert.AreEqual(test1, 0x0110);
int test2 = 0x1055;
Assert.AreEqual(FlagUtils.GetBits(test2, 0x00f0), 5);
Assert.AreEqual(FlagUtils.GetBits(test2, 0x000f), 5);
test2 = FlagUtils.SetBits(test2, 0x00f0, 6);
Assert.AreEqual(test2, 0x1065);
test2 = FlagUtils.SetBits(test2, 0x000f, 8);
Assert.AreEqual(test2, 0x1068);
}
public void ShiftRightLogic(ref byte target, ref byte flags)
{
bool carry = (target & 1) > 0;
target = (byte)(target >> 1);
FlagUtils.SetFlags(ref flags, target == 0, false, false, carry);
}
public void ShiftLeftArithmetic(ref byte target, ref byte flags)
{
bool setCarry = (target & 0x80) > 0;
target = (byte)((target << 1) & 0xFF);
FlagUtils.SetFlags(ref flags, target == 0, false, false, setCarry);
}
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 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 JumpToAddressConditional(ushort address, ref ushort pc, Flag flag, bool condition, byte flags)
{
if (FlagUtils.GetFlag(flag, flags) == condition)
{
JumpToAddress(address, ref pc);
}
}
/// <summary>
/// Creates a stream for writing an extracted file to the filesystem.
/// </summary>
/// <param name="relativePath">A path relative to the archive's root.</param>
/// <param name="executable"><see langword="true"/> if the file's executable bit is set; <see langword="false"/> otherwise.</param>
/// <returns>A stream for writing the extracted file.</returns>
protected FileStream OpenFileWriteStream([NotNull] string relativePath, bool executable = false)
{
CancellationToken.ThrowIfCancellationRequested();
string fullPath = CombinePath(relativePath);
string directoryPath = Path.GetDirectoryName(fullPath);
if (directoryPath != null && !Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
bool alreadyExists = File.Exists(fullPath);
var stream = File.Create(fullPath);
// If a symlink is overwritten by a normal file, remove the symlink flag
if (alreadyExists)
{
string flagRelativePath = string.IsNullOrEmpty(Destination) ? relativePath : Path.Combine(Destination, relativePath);
FlagUtils.Remove(Path.Combine(TargetDir, FlagUtils.SymlinkFile), flagRelativePath);
}
if (executable)
{
SetExecutableBit(relativePath);
}
else if (alreadyExists)
{
RemoveExecutableBit(relativePath); // If an executable file is overwritten by a non-executable file, remove the xbit flag
}
return(stream);
}
public void ShiftRightArithmetic(ref byte target, ref byte flags)
{
byte msb = (byte)(target & 0x80);
bool setCarry = (target & 1) > 0;
target = (byte)((target >> 1) | msb);
FlagUtils.SetFlags(ref flags, target == 0, false, false, setCarry);
}
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 Swap(ref byte register, ref byte flags)
{
int lower = register & 0xF;
int higher = register & 0xF0;
register = (byte)(higher >> 4 | lower << 4);
FlagUtils.SetFlags(ref flags, register == 0, false, false, false);
}
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 Xor(ref byte to, byte value, ref byte flags)
{
to = (byte)(to ^ value);
FlagUtils.SetFlags(ref flags,
to == 0,
false,
false,
false);
}
public void Increment(ref byte target, ref byte flags)
{
byte origValue = target;
target++;
FlagUtils.SetFlag(Flag.Z, target == 0, ref flags);
FlagUtils.SetFlag(Flag.N, false, ref flags);
FlagUtils.SetFlag(Flag.H, (origValue & 0x0F) + 1 > 0x0F, ref flags);
}
public void And(ref byte to, byte value, ref byte flags)
{
to = (byte)(to & value);
FlagUtils.SetFlags(ref flags,
to == 0,
false,
true,
false);
}
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 Decrement(ref byte target, ref byte flags)
{
byte origValue = target;
target--;
FlagUtils.SetFlag(Flag.Z, target == 0, ref flags);
FlagUtils.SetFlag(Flag.N, true, ref flags);
FlagUtils.SetFlag(Flag.H, (origValue & 0x0F) < 1, ref flags);
}
public void PopWithFlags(ref byte valueHigh, ref byte valueLow, ref ushort pointer, ref byte flags)
{
Pop(ref valueHigh, ref valueLow, ref pointer);
FlagUtils.SetFlags(ref flags,
valueLow.IsBitSet(7),
valueLow.IsBitSet(6),
valueLow.IsBitSet(5),
valueLow.IsBitSet(4));
flags = (byte)(flags & 0xF0);
}
public void Compare(byte to, byte value, ref byte flags)
{
byte result = (byte)((to - value) & 0xFF);
FlagUtils.SetFlags(ref flags,
result == 0,
true,
(to & 0x0F) < (value & 0x0F),
to < value);
}
public void SetFlagTest()
{
byte flags = 0b01110000;
FlagUtils.SetFlags(ref flags,
true,
true,
true,
true);
Assert.Equal(0b11110000, flags);
}
void Retarget()
{
List <GameObject> flags = FlagUtils.FindAllEnemyFlags(transform.parent);
if (flags.Count > 0)
{
// get random index in filtered array
int index = Random.Range(0, flags.Count);
targetPos = flags[index].transform.position;
InfoBox.PrependLine("Retarget successful: " + index + " / " + flags.Count);
}
}
public void DecrementInMemory(byte addrHigh, byte addrLow, ref byte flags)
{
ushort address = BitUtils.BytesToUshort(addrHigh, addrLow);
byte origValue = memory.ReadByte(address);
TickEvent?.Invoke();
memory.WriteByte(address, (byte)(origValue - 1));
FlagUtils.SetFlag(Flag.Z, (byte)(origValue - 1) == 0, ref flags);
FlagUtils.SetFlag(Flag.N, true, ref flags);
FlagUtils.SetFlag(Flag.H, (origValue & 0x0F) < 1, ref flags);
TickEvent?.Invoke();
}
public void ResetFlagsTest()
{
byte flags = 0b01010000;
FlagUtils.SetFlags(ref flags,
false,
false,
false,
false);
Assert.Equal(0b00000000, flags);
}
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 AddSigned(ref ushort to, byte value, ref byte flags)
{
ushort originalValue = to;
sbyte valueSigned = unchecked ((sbyte)value);
to = (ushort)(to + valueSigned);
FlagUtils.SetFlag(Flag.Z, false, ref flags);
FlagUtils.SetFlag(Flag.N, false, ref flags);
FlagUtils.SetFlag(Flag.H, (originalValue & 0x0F) + (value & 0x0F) > 0x0F, ref flags);
FlagUtils.SetFlag(Flag.C, (originalValue & 0xFF) + value > 0xFF, ref flags);
TickEvent?.Invoke();
TickEvent?.Invoke();
}
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));
}
/// <summary>
/// Determines whether a file is executable.
/// </summary>
protected bool IsExecutable([NotNull] string path)
{
#region Sanity checks
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
#endregion
return
(FileUtils.IsExecutable(path) ||
FlagUtils.GetFiles(FlagUtils.XbitFile, BaseDirectory.FullName).Contains(path));
}
public void Add(ref byte toHigh, ref byte toLow, byte valueHigh, byte valueLow, ref byte flags)
{
ushort to = BitUtils.BytesToUshort(toHigh, toLow);
ushort value = BitUtils.BytesToUshort(valueHigh, valueLow);
ushort result = (ushort)((to + value) & 0xFFFF);
toHigh = BitUtils.MostSignificantByte(result);
toLow = BitUtils.LeastSignificantByte(result);
// Zero flag is not affected
FlagUtils.SetFlag(Flag.N, false, ref flags);
FlagUtils.SetFlag(Flag.H, (to & 0xFFF) + (value & 0xFFF) > 0xFFF, ref flags);
FlagUtils.SetFlag(Flag.C, to + value > 0xFFFF, ref flags);
TickEvent?.Invoke();
}
public void RotateRight(ref byte register, ref byte flags, bool alwaysResetZero)
{
bool setCarry = register.IsBitSet(0);
register = (byte)((register >> 1) | (setCarry ? 1 << 7 : 0));
if (alwaysResetZero)
{
FlagUtils.SetFlags(ref flags, false, false, false, setCarry);
}
else
{
FlagUtils.SetFlags(ref flags, register == 0, false, false, setCarry);
}
}
public void LoadAdjusted(ref byte destHigh, ref byte destLow, ushort value, byte addValue, ref byte flags)
{
ushort originalValue = value;
sbyte signed = unchecked ((sbyte)addValue);
FlagUtils.SetFlag(Flag.C, ((originalValue & 0xFF) + addValue) > 0xFF, ref flags);
FlagUtils.SetFlag(Flag.H, (originalValue & 0x0F) + (addValue & 0x0F) > 0xF, ref flags);
ushort result = (ushort)(value + signed);
destHigh = BitUtils.MostSignificantByte(result);
destLow = BitUtils.LeastSignificantByte(result);
FlagUtils.SetFlag(Flag.Z, false, ref flags);
FlagUtils.SetFlag(Flag.N, false, ref flags);
TickEvent?.Invoke();
}
