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;
}
}
