public ConditionSoul(ConditionIds id, ConditionFlags type, int ticks, bool buff = false, uint subId = 0) : base(id, type, ticks, buff, subId) { InternalSoulTicks = 0; SoulTicks = 0; SoulGain = 0; }
public Comparison(ConditionFlags Flags, ConditionComparisonType Operator, byte[] Unused, FormID ComparisonValue) { this.Flags = Flags; this.Operator = Operator; this.Unused = Unused; this.ComparisonValue = ComparisonValue.Clone(); }
public static Condition CreateCondition(ConditionIds id, ConditionFlags type, int ticks, int param = 0, bool buff = false, uint subId = 0) { switch (type) { case ConditionFlags.Poison: case ConditionFlags.Fire: case ConditionFlags.Energy: case ConditionFlags.Drown: case ConditionFlags.Freezing: case ConditionFlags.Dazzled: case ConditionFlags.Cursed: case ConditionFlags.Bleeding: return(new ConditionDamage(id, type, buff, subId)); case ConditionFlags.Haste: case ConditionFlags.Paralyze: return(new ConditionSpeed(id, type, ticks, buff, subId, param)); case ConditionFlags.Invisible: return(new ConditionInvisible(id, type, ticks, buff, subId)); case ConditionFlags.Outfit: return(new ConditionOutfit(id, type, ticks, buff, subId)); case ConditionFlags.Light: return(new ConditionLight(id, type, ticks, buff, subId, (byte)(param & 0xFF), (byte)((param & 0xFF00) >> 8))); case ConditionFlags.Regeneration: return(new ConditionRegeneration(id, type, ticks, buff, subId)); case ConditionFlags.Soul: return(new ConditionSoul(id, type, ticks, buff, subId)); case ConditionFlags.Attributes: return(new ConditionAttributes(id, type, ticks, buff, subId)); case ConditionFlags.SpellCooldown: return(new ConditionSpellCooldown(id, type, ticks, buff, subId)); case ConditionFlags.SpellGroupCooldown: return(new ConditionSpellGroupCooldown(id, type, ticks, buff, subId)); case ConditionFlags.InFight: case ConditionFlags.Drunk: case ConditionFlags.ExhaustWeapon: case ConditionFlags.ExhaustCombat: case ConditionFlags.ExhaustHeal: case ConditionFlags.Muted: case ConditionFlags.ChannelMutedTicks: case ConditionFlags.YellTicks: case ConditionFlags.Pacified: case ConditionFlags.ManaShield: return(new ConditionGeneric(id, type, ticks, buff, subId)); default: return(null); } }
public Comparison() { Flags = new ConditionFlags(); Operator = new ConditionComparisonType(); Unused = new byte[3]; ComparisonValue = 0; }
public Comparison(ConditionFlags Flags, ConditionComparisonType Operator, byte[] Unused, float ComparisonValue) { this.Flags = Flags; this.Operator = Operator; this.Unused = Unused; this.ComparisonValue = ComparisonValue; }
/// <summary> /// <para>Only include methods with the following parameters.</para> /// <para>Calling this will also exclude fields and properties.</para> /// <para>Parameter type inheritance is supported.</para> /// </summary> public MemberFinder HasParameters(Type param1, Type param2) { this.conditionFlags |= ConditionFlags.IsMethod; this.paramTypes.Add(param1); this.paramTypes.Add(param2); return(this); }
public static CombatTypeFlags ConditionToDamageType(ConditionFlags condition) { switch (condition) { case ConditionFlags.Fire: return(CombatTypeFlags.FireDamage); case ConditionFlags.Energy: return(CombatTypeFlags.EnergyDamage); case ConditionFlags.Bleeding: return(CombatTypeFlags.PhysicalDamage); case ConditionFlags.Drown: return(CombatTypeFlags.DrownDamage); case ConditionFlags.Poison: return(CombatTypeFlags.EarthDamage); case ConditionFlags.Freezing: return(CombatTypeFlags.IceDamage); case ConditionFlags.Dazzled: return(CombatTypeFlags.HolyDamage); case ConditionFlags.Cursed: return(CombatTypeFlags.DeathDamage); } return(CombatTypeFlags.None); }
public void TestADC_A_SignFlag() { var rom = AssembleSource($@" org 00h ADC A HLT "); var registers = new CPURegisters(); registers.A = 0x44; var flags = new ConditionFlags() { Carry = true, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); Assert.Equal(0x89, state.Registers.A); Assert.False(state.Flags.Zero); Assert.True(state.Flags.Sign); Assert.False(state.Flags.Parity); Assert.False(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(7 + 4, state.Cycles); Assert.Equal(0x01, state.ProgramCounter); }
private void Reset() { this.returnType = null; this.name = null; this.conditionFlags = ConditionFlags.None; this.paramTypes.Clear(); }
public sealed override bool IsImmune(ConditionFlags condition) { if (HasFlag(PlayerFlags.CannotBeAttacked)) { return(true); } return(base.IsImmune(condition)); }
public void Test_INC_MHL(byte initialValue, byte expectedValue, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h INC (HL) HALT "); var memory = new byte[16 * 1024]; memory[0x2234] = initialValue; var registers = new CPURegisters() { HL = 0x2234, }; var flags = new ConditionFlags() { // Should be affected. HalfCarry = !expectedFlags.HalfCarry, ParityOverflow = !expectedFlags.ParityOverflow, Zero = !expectedFlags.Zero, Sign = !expectedFlags.Sign, // Should be reset. Subtract = true, // Should be unaffected. Carry = false, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, memory, initialState); Assert.Equal(expectedValue, state.Memory[0x2234]); // Should be affected. Assert.Equal(expectedFlags.HalfCarry, state.Flags.HalfCarry); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); Assert.Equal(expectedFlags.ParityOverflow, state.Flags.ParityOverflow); Assert.Equal(expectedFlags.Zero, state.Flags.Zero); // Should be reset. Assert.False(state.Flags.Subtract); // Should be unaffected. Assert.False(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 11, state.Cycles); Assert.Equal(0x01, state.Registers.PC); }
private void Reset() { this.returnType = null; this.returnTypeCanInherit = false; this.returnTypeCanBeConverted = false; this.name = null; this.conditionFlags = ConditionFlags.None; this.paramTypes.Clear(); }
public ConditionSpeed(ConditionIds id, ConditionFlags type, int ticks, bool buff, uint subId, int changeSpeed) : base(id, type, ticks, buff, subId) { SpeedDelta = changeSpeed; MinA = 0.0f; MinB = 0.0f; MaxA = 0.0f; MaxB = 0.0f; }
public void Test_ADD_IY_RR_Carry_HalfCarry(RegisterPair pair, UInt16 iyInitialValue, UInt16 pairInitialValue, UInt16 iyExpectedValue, UInt16 pairExpectedValue) { var rom = AssembleSource($@" org 00h ADD IY, {pair} HALT "); var registers = new CPURegisters() { IY = iyInitialValue, [pair] = pairInitialValue, }; var flags = new ConditionFlags() { // Should be unaffected. Sign = true, Zero = true, ParityOverflow = true, // Should be reset. Subtract = true, // Should be affected. HalfCarry = false, Carry = false, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); Assert.Equal(pairExpectedValue, state.Registers[pair]); Assert.Equal(iyExpectedValue, state.Registers.IY); // Should be unaffected. Assert.True(state.Flags.Sign); Assert.True(state.Flags.Zero); Assert.True(state.Flags.ParityOverflow); // Should be reset. Assert.False(state.Flags.Subtract); // Should be affected. Assert.True(state.Flags.HalfCarry); Assert.True(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 15, state.Cycles); Assert.Equal(0x02, state.Registers.PC); }
public void Test_INC_IYL(byte initialValue, byte expectedValue, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h INC IYL HALT "); var registers = new CPURegisters() { IYH = 0xFF, IYL = initialValue, }; var flags = new ConditionFlags() { // Should be affected. HalfCarry = !expectedFlags.HalfCarry, ParityOverflow = !expectedFlags.ParityOverflow, Zero = !expectedFlags.Zero, Sign = !expectedFlags.Sign, // Should be reset. Subtract = true, // Should be unaffected. Carry = false, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); Assert.Equal(0xFF, state.Registers.IYH); Assert.Equal(expectedValue, state.Registers.IYL); // Should be affected. Assert.Equal(expectedFlags.HalfCarry, state.Flags.HalfCarry); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); Assert.Equal(expectedFlags.ParityOverflow, state.Flags.ParityOverflow); Assert.Equal(expectedFlags.Zero, state.Flags.Zero); // Should be reset. Assert.False(state.Flags.Subtract); // Should be unaffected. Assert.False(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 8, state.Cycles); Assert.Equal(0x02, state.Registers.PC); }
protected Condition(ConditionIds id, ConditionFlags type, int ticks, bool buff = false, uint subId = 0) { SubId = subId; Ticks = ticks; ConditionType = type; Id = id; IsBuff = buff; EndTime = Ticks == -1 ? long.MaxValue : 0; }
public void Test_DAA_Subtraction(byte initialAValue, byte initialBValue, int expectedBcdResult, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h SUB B DAA HALT "); var registers = new CPURegisters() { A = initialAValue, B = initialBValue, }; var flags = new ConditionFlags() { // Affected flags. Zero = !expectedFlags.Zero, Sign = !expectedFlags.Sign, ParityOverflow = !expectedFlags.ParityOverflow, Carry = !expectedFlags.Carry, HalfCarry = !expectedFlags.HalfCarry, // Not affected (can't really test because SUB sets to true). Subtract = false, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); // Ensure these flags were updated. Assert.Equal(expectedFlags.Zero, state.Flags.Zero); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); Assert.Equal(expectedFlags.ParityOverflow, state.Flags.ParityOverflow); Assert.Equal(expectedFlags.Carry, state.Flags.Carry); Assert.Equal(expectedFlags.HalfCarry, state.Flags.HalfCarry); // Ensure this flag was unaffected (it will be affected though because we did a SUB operation). Assert.True(state.Flags.Subtract); // Verify accumulator value. var actualValue = int.Parse(state.Registers.A.ToString("X2")); // Convert hex BCD value to an integer. Assert.Equal(expectedBcdResult, actualValue); Assert.Equal(3, state.Iterations); Assert.Equal(4 + 4 + 4, state.Cycles); Assert.Equal(0x02, state.Registers.PC); }
public void Test_DEC_R(Register register, byte initialValue, byte expectedValue, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h DEC {register} HALT "); var registers = new CPURegisters(); registers[register] = initialValue; var flags = new ConditionFlags() { // Should be affected. HalfCarry = !expectedFlags.HalfCarry, ParityOverflow = !expectedFlags.ParityOverflow, Zero = !expectedFlags.Zero, Sign = !expectedFlags.Sign, // Should be set. Subtract = false, // Should be unaffected. Carry = false, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); Assert.Equal(expectedValue, state.Registers[register]); // Should be affected. Assert.Equal(expectedFlags.HalfCarry, state.Flags.HalfCarry); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); Assert.Equal(expectedFlags.ParityOverflow, state.Flags.ParityOverflow); Assert.Equal(expectedFlags.Zero, state.Flags.Zero); // Should be set. Assert.True(state.Flags.Subtract); // Should be unaffected. Assert.False(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 4, state.Cycles); Assert.Equal(0x01, state.Registers.PC); }
public ConditionRegeneration(ConditionIds id, ConditionFlags type, int ticks, bool buff = false, uint subId = 0) : base(id, type, ticks, buff, subId) { InternalHealthTicks = 0; InternalManaTicks = 0; HealthTicks = 1000; ManaTicks = 1000; HealthGain = 0; ManaGain = 0; }
public void TestSetFromByte(bool expectedSign, bool expectedZero, bool expectedAuxCarry, bool expectedParity, bool expectedCarry, byte flagsAsByte) { var flags = new ConditionFlags(); flags.SetFromByte(flagsAsByte); Assert.Equal(expectedSign, flags.Sign); Assert.Equal(expectedZero, flags.Zero); Assert.Equal(expectedAuxCarry, flags.AuxCarry); Assert.Equal(expectedParity, flags.Parity); Assert.Equal(expectedCarry, flags.Carry); }
public ConditionLight(ConditionIds id, ConditionFlags type, int ticks, bool buff, uint subId, byte lightLevel, byte lightColor) : base(id, type, ticks, buff, subId) { LightInfo = new LightInfo { Level = lightLevel, Color = lightColor }; InternalLightTicks = 0; LightChangeInterval = 0; }
public void Test_CP_IX(int offset, byte initialValue, byte valueToAdd, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h CP (IX {(offset < 0 ? '-' : '+')} {Math.Abs(offset)}) HALT "); var memory = new byte[16 * 1024]; memory[0x2234 + offset] = valueToAdd; var initialState = new CPUConfig() { Registers = new CPURegisters() { A = initialValue, IX = 0x2234, }, Flags = new ConditionFlags() { // Should be affected. Carry = !expectedFlags.Carry, Sign = !expectedFlags.Sign, Zero = !expectedFlags.Zero, // Parity = !expectedFlags.Parity, // Should be set. Subtract = false, // AuxCarry = ??? }, }; var state = Execute(rom, memory, initialState); Assert.Equal(initialValue, state.Registers.A); // Should be affected. Assert.Equal(expectedFlags.Carry, state.Flags.Carry); Assert.Equal(expectedFlags.Zero, state.Flags.Zero); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); // Assert.Equal(expectedFlags.Parity, state.Flags.Parity); // Should be set. Assert.True(state.Flags.Subtract); // Assert.False(state.Flags.AuxCarry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 19, state.Cycles); Assert.Equal(0x03, state.Registers.PC); }
public ConditionAttributes(ConditionIds id, ConditionFlags type, int ticks, bool buff = false, uint subId = 0) : base(id, type, ticks, buff, subId) { CurrentSkill = 0; CurrentStat = 0; const byte arrayLength = (byte)Enums.Stats.Last + 1; Skills = new int[arrayLength]; SkillsPercent = new int[arrayLength]; Stats = new int[arrayLength]; StatsPercent = new int[arrayLength]; }
public void Test_ADD_HL_RR_NoCarry(RegisterPair pair) { var rom = AssembleSource($@" org 00h ADD HL, {pair} HALT "); var registers = new CPURegisters() { HL = 0x1212, [pair] = 0x3434, }; var flags = new ConditionFlags() { Sign = true, Zero = true, HalfCarry = false, ParityOverflow = true, Subtract = true, Carry = false, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); Assert.Equal(0x3434, state.Registers[pair]); Assert.Equal(0x4646, state.Registers.HL); // Ensure these flags remain unchanged. Assert.True(state.Flags.Sign); Assert.True(state.Flags.Zero); Assert.True(state.Flags.ParityOverflow); Assert.False(state.Flags.HalfCarry); Assert.False(state.Flags.Subtract); Assert.False(state.Flags.Carry); // No carry in this case. Assert.False(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 11, state.Cycles); Assert.Equal(0x01, state.Registers.PC); }
public void Test_ADC_HL_NoFlags(RegisterPair sourceRegister, UInt16 initialValue, UInt16 valueToAdd, UInt16 expectedValue, bool initialCarryFlag, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h ADC HL, {sourceRegister} HALT "); var registers = new CPURegisters(); registers.HL = initialValue; registers[sourceRegister] = valueToAdd; var flags = new ConditionFlags() { // Should be affected. Carry = initialCarryFlag, HalfCarry = !expectedFlags.HalfCarry, ParityOverflow = !expectedFlags.ParityOverflow, Zero = !expectedFlags.Zero, Sign = !expectedFlags.Sign, // Should be reset. Subtract = true, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, }; var state = Execute(rom, initialState); Assert.Equal(expectedValue, state.Registers.HL); Assert.Equal(valueToAdd, state.Registers[sourceRegister]); // Should be affected. Assert.Equal(expectedFlags.Carry, state.Flags.Carry); Assert.Equal(expectedFlags.HalfCarry, state.Flags.HalfCarry); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); Assert.Equal(expectedFlags.ParityOverflow, state.Flags.ParityOverflow); Assert.Equal(expectedFlags.Zero, state.Flags.Zero); // Should be reset. Assert.False(state.Flags.Subtract); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 15, state.Cycles); Assert.Equal(0x02, state.Registers.PC); }
public void Test_PUSH_AF() { var rom = AssembleSource($@" org 00h PUSH AF HALT "); // 7 6 5 4 3 2 1 0 // S Z - H - P/V N C // 1 1 0 1 0 1 1 1 // D 7 var flags = new ConditionFlags() { Sign = true, Zero = true, HalfCarry = true, ParityOverflow = true, Subtract = true, Carry = true, }; var initialState = new CPUConfig() { Flags = flags, Registers = new CPURegisters() { SP = 0x3000, A = 0x42, }, }; var state = Execute(rom, initialState); Assert.Equal(0x42, state.Registers.A); Assert.Equal(0x00, state.Memory[0x3000]); Assert.Equal(0x42, state.Memory[0x2FFF]); Assert.Equal(0xD7, state.Memory[0x2FFE]); Assert.Equal(0x2FFE, state.Registers.SP); Assert.True(state.Flags.Sign); Assert.True(state.Flags.Zero); Assert.True(state.Flags.HalfCarry); Assert.True(state.Flags.ParityOverflow); Assert.True(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 11, state.Cycles); Assert.Equal(0x01, state.Registers.PC); }
public void TestPUSH_PSW() { var rom = AssembleSource($@" org 00h PUSH PSW HLT "); var registers = new CPURegisters(); registers.A = 0x42; // 7 6 5 4 3 2 1 0 // S Z 0 A 0 P 1 C // 1 1 0 1 0 1 1 1 // D 7 var flags = new ConditionFlags() { Sign = true, Zero = true, AuxCarry = true, Parity = true, Carry = true, }; var initialState = new CPUConfig() { Registers = registers, Flags = flags, StackPointer = 0x3000, }; var state = Execute(rom, initialState); Assert.Equal(0x42, state.Registers.A); Assert.Equal(0x00, state.Memory[0x3000]); Assert.Equal(0x42, state.Memory[0x2FFF]); Assert.Equal(0xD7, state.Memory[0x2FFE]); Assert.Equal(0x2FFE, state.StackPointer); Assert.True(state.Flags.Sign); Assert.True(state.Flags.Zero); Assert.True(state.Flags.AuxCarry); Assert.True(state.Flags.Parity); Assert.True(state.Flags.Carry); Assert.Equal(2, state.Iterations); Assert.Equal(7 + 11, state.Cycles); Assert.Equal(0x01, state.ProgramCounter); }
public ConditionDamage(ConditionIds id, ConditionFlags type, bool buff = false, uint subId = 0) : base(id, type, 0, buff, subId) { Delayed = false; ForceUpdate = false; Field = false; Owner = 0; MinDamage = 0; MaxDamage = 0; StartDamage = 0; PeriodDamage = 0; PeriodDamageTick = 0; TickInterval = 2000; }
public void Test_CP_IX_Half(bool high, byte initialValue, UInt16 valueToAdd, ConditionFlags expectedFlags) { var rom = AssembleSource($@" org 00h CP {(high ? "IXH" : "IXL")} HALT "); var initialState = new CPUConfig() { Registers = new CPURegisters() { A = initialValue, IX = valueToAdd, }, Flags = new ConditionFlags() { // Should be affected. Carry = !expectedFlags.Carry, Sign = !expectedFlags.Sign, Zero = !expectedFlags.Zero, // Parity = !expectedFlags.Parity, // Should be set. Subtract = false, // AuxCarry = ??? }, }; var state = Execute(rom, initialState); Assert.Equal(initialValue, state.Registers.A); // Should be affected. Assert.Equal(expectedFlags.Carry, state.Flags.Carry); Assert.Equal(expectedFlags.Zero, state.Flags.Zero); Assert.Equal(expectedFlags.Sign, state.Flags.Sign); // Assert.Equal(expectedFlags.Parity, state.Flags.Parity); // Should be set. Assert.True(state.Flags.Subtract); // Assert.False(state.Flags.AuxCarry); Assert.Equal(2, state.Iterations); Assert.Equal(4 + 8, state.Cycles); Assert.Equal(0x02, state.Registers.PC); }
public void TestToByte(bool sign, bool zero, bool auxCarry, bool parity, bool carry, byte expected) { var flags = new ConditionFlags() { Sign = sign, Zero = zero, AuxCarry = auxCarry, Parity = parity, Carry = carry, }; var actual = flags.ToByte(); Assert.Equal(expected, actual); }
void ShootControl() { if (Input.GetKeyDown(this._controller.Fire)) { if (this._flags == ConditionFlags.None) { this._flags = ConditionFlags.Fire; this._shoot.RunForce(); } }else if (Input.GetKeyUp(this._controller.Fire)) { if (this._flags == ConditionFlags.Fire) { this._flags = ConditionFlags.None; _shoot.Fire(); } } if (this._flags != ConditionFlags.Skill) { if (Input.GetKey(this._controller.Up)) NextAngle(true); else if (Input.GetKey(this._controller.Down)) NextAngle(false); } }
void SkillControl() { if (Input.GetKeyDown(this._controller.Skill)) if (this._flags == ConditionFlags.None) this._flags = ConditionFlags.Skill; if (this._flags == ConditionFlags.Skill) { if (Input.GetKeyUp(this._controller.Left)) this._skill.UseSKill(0); else if (Input.GetKeyUp(this._controller.Down)) this._skill.UseSKill(1); else if (Input.GetKeyUp(this._controller.Right)) this._skill.UseSKill(2); if (Input.GetKeyUp(this._controller.Skill)) if (this._flags == ConditionFlags.Skill) this._flags = ConditionFlags.None; } }