public void SkillsCanApplyEffectWithDelay()
{
Skill skill = Factory.TestDelayedSkill;
TestEffectEngine effectEngine = new TestEffectEngine();
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithSkills(skill.Yield()).WithCT(Time.ActionAmount));
SkillEngine engine = new SkillEngine(effectEngine);
state = engine.ApplyTargettedSkill(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])), state);
Assert.Empty(effectEngine.ActionsUsed);
Assert.Contains(state.DelayedActions, x => x.SourceSkill.Skill.CosmeticName == skill.CosmeticName);
Assert.Equal(50, state.DelayedActions[0].CT);
Assert.True(state.Party[0].IsCasting);
CastingInfo castingInfo = state.Party[0].Casting;
Assert.Equal(state.Party[0].Skills[0], castingInfo.Skill);
Assert.Equal(skill.Delay, castingInfo.Duration);
Assert.Equal(0, castingInfo.StartingTick);
Assert.Equal(-50, state.Party[0].CT);
}
public void CooldownDisappearsAfterTime()
{
Skill skill = Factory.TestSkillCooldown;
TestEffectEngine effectEngine = new TestEffectEngine();
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithSkills(skill.Yield()));
SkillEngine skillEngine = new SkillEngine(effectEngine);
state = skillEngine.ApplyTargettedSkill(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])), state);
GameEngine engine = Factory.CreateGameEngine(state, skillEngine: skillEngine);
Assert.False(engine.CurrentState.Party[0].Skills[0].Available);
for (int i = 0; i < Time.ActionAmount; ++i)
{
engine.Process();
}
Assert.DoesNotContain(engine.CurrentState.DelayedActions, x => x.TargetAction.Action.Type == ActionType.Cooldown);
Assert.True(engine.CurrentState.Party[0].Skills[0].Available);
}
public static void RemoveFromTargetting(Entity target, TargettingInfo tI)
{
if (!targetting.ContainsKey(target))
{
targetting.Add(target, new List <TargettingInfo> ());
}
targetting[target].Remove(tI);
}
public void DamageSkillDamages()
{
GameState state = GetDefaultEffectState();
EffectEngine effectEngine = Factory.EffectEngine;
TargettedAction damageAction = new TargettedAction(Factory.DamageAction, TargettingInfo.From(state.Party[0], state.Enemies[0]));
state = effectEngine.Apply(damageAction, state);
Assert.Equal(0, state.Enemies[0].Health.Current);
}
public static void AddToTargetting(Entity target, TargettingInfo tI)
{
if (!targetting.ContainsKey(target))
{
targetting.Add(target, new List <TargettingInfo> ());
}
targetting[target].Add(tI);
// Have AI Controller process new targetter next update cycle
updateTargettingsOf = target;
}
public void EffectsCanBeOfMultipleTypes()
{
GameState state = GetDefaultEffectState();
Action multiAction = new Action(ActionType.Damage | ActionType.Effect, 200, "Burning");
TargettedAction targettedAction = new TargettedAction(multiAction, TargettingInfo.From(state.Party[0], state.Enemies[0]));
EffectEngine effectEngine = Factory.EffectEngine;
state = effectEngine.Apply(targettedAction, state);
Assert.Equal(0, state.Enemies[0].Health.Current);
Assert.True(state.Enemies[0].HasEffect("Burning"));
}
public void HandleKeyDown(string character)
{
switch (character)
{
case "D1":
if (!TargettingEnabled)
{
EnableTargetting(TargettingType.Player, p => Console.WriteLine($"One - {p}"));
}
break;
case "D2":
if (!TargettingEnabled)
{
EnableTargetting(TargettingType.Enemy, p => Console.WriteLine($"Two - {p}"));
}
break;
case "D3":
if (!TargettingEnabled)
{
EnableTargetting(TargettingType.Both, p => Console.WriteLine($"Three - {p}"));
}
break;
case "Up":
HandleDirection(Direction.North);
break;
case "Down":
HandleDirection(Direction.South);
break;
case "Left":
HandleDirection(Direction.West);
break;
case "Right":
HandleDirection(Direction.East);
break;
case "Return":
if (TargettingEnabled)
{
CombatView.DisableTargetting();
TargetInfo.Fire(CombatView.CurrentTarget);
TargetInfo = null;
}
break;
}
}
public void SkillsCanApplyEffectDirectly()
{
Skill skill = Factory.TestSkill;
TestEffectEngine effectEngine = new TestEffectEngine();
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithSkills(skill.Yield()).WithCT(Time.ActionAmount));
SkillEngine engine = new SkillEngine(effectEngine);
state = engine.ApplyTargettedSkill(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])), state);
Assert.False(state.Party[0].IsCasting);
Assert.Single(effectEngine.ActionsUsed);
Assert.Equal(0, state.Party[0].CT);
}
public void DelayedEffectApplies()
{
GameState state = GetDefaultEffectState();
TargettedAction damageAction = new TargettedAction(Factory.DamageAction, TargettingInfo.From(state.Party[0], state.Enemies[0]));
state = state.WithDelayedActions(DelayedAction.Create(damageAction).WithCT(90).Yield());
bool delayedEffectFired = false;
GameEngine engine = Factory.CreateDefaultGameEngine(state);
engine.DelayedActions += (o, e) => delayedEffectFired = true;
for (int i = 0; i < 10; ++i)
{
engine.Process();
}
Assert.Equal(0, engine.CurrentState.Enemies[0].Health.Current);
Assert.True(delayedEffectFired);
}
static void TargetLossTestCore(Func <GameState, GameState> testProc, int expectedHealth)
{
GameState state = GetDefaultEffectState();
TargettedAction damageAction = new TargettedAction(Factory.DamageAction, TargettingInfo.From(state.Party[0], state.Enemies[0]));
state = state.WithDelayedActions(DelayedAction.Create(damageAction).WithCT(90).Yield());
state = testProc(state);
GameEngine engine = Factory.CreateDefaultGameEngine(state);
for (int i = 0; i < 10; ++i)
{
engine.Process();
}
if (expectedHealth != -1)
{
Assert.Equal(expectedHealth, engine.CurrentState.Enemies[0].Health.Current);
}
}
public void CooldownPreventsReuse()
{
Skill skill = Factory.TestSkillCooldown;
TestEffectEngine effectEngine = new TestEffectEngine();
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithSkills(skill.Yield()));
SkillEngine engine = new SkillEngine(effectEngine);
state = engine.ApplyTargettedSkill(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])), state);
Assert.Single(state.DelayedActions);
Assert.Contains(state.DelayedActions, x => x.TargetAction.Action.Type == ActionType.Cooldown);
Assert.False(state.Party[0].Skills[0].Available);
Assert.Equal(25, state.DelayedActions[0].CT);
Assert.Throws <InvalidOperationException> (() => engine.ApplyTargettedSkill(new TargettedSkill(state.Party[0].Skills[0], TargettingInfo.Self(state.Party[0])), state));
}
public void ActiveCharacterCanUseSkill()
{
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithCT(Time.ActionAmount));
state = state.WithActivePlayerID(state.Party[0].ID);
Skill skill = Factory.TestSkill;
TestSkillEngine skillEngine = new TestSkillEngine();
GameEngine engine = Factory.CreateGameEngine(state, skillEngine: skillEngine);
Skill skillReportedUsed = null;
engine.SkillUsed += (o, s) => skillReportedUsed = s.Skill;
engine.ProcessActivePlayerAction(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])));
Assert.Single(skillEngine.SkillsUsed);
Assert.Contains(skillEngine.SkillsUsed, x => x.ID == skill.ID);
Assert.Equal(skillReportedUsed, skillEngine.SkillsUsed.First());
}
public void SkillCasting_RemovingCasting_WhenComplete()
{
Skill skill = Factory.TestDelayedSkill;
TestEffectEngine effectEngine = new TestEffectEngine();
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithSkills(skill.Yield()).WithCT(Time.ActionAmount));
SkillEngine skillEngine = new SkillEngine(effectEngine);
state = skillEngine.ApplyTargettedSkill(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])), state);
Assert.True(state.Party[0].IsCasting);
GameEngine engine = Factory.CreateGameEngine(state, skillEngine: skillEngine);
for (int i = 0; i < Time.ActionAmount; ++i)
{
engine.Process();
}
Assert.False(engine.CurrentState.Party[0].IsCasting);
}
public void CharacterBehavior_ReturnsSkill_GivenToSkillEngine()
{
GameState state = Factory.DefaultGameState;
state = state.UpdateCharacter(state.Party[0].WithCT(99));
Skill skill = Factory.TestSkill;
TestCharacterBehavior characterBehavior = new TestCharacterBehavior();
characterBehavior.SkillToReturn = new TargettedSkill(skill, TargettingInfo.Self(state.Party[0]));
TestSkillEngine skillEngine = new TestSkillEngine();
GameEngine engine = Factory.CreateGameEngine(state, characterBehavior, skillEngine);
Skill skillReportedUsed = null;
engine.SkillUsed += (o, s) => skillReportedUsed = s.Skill;
engine.Process();
Assert.Single(skillEngine.SkillsUsed);
Assert.Contains(skillEngine.SkillsUsed, x => x.ID == skill.ID);
Assert.Equal(skillReportedUsed, skillEngine.SkillsUsed.First());
}
public void StatusEffectSkill_AddsEffect_AndRemovesAfterDuration()
{
GameState state = GetDefaultEffectState();
TargettedAction statusAction = new TargettedAction(Factory.StatusEffectAction, TargettingInfo.From(state.Party[0], state.Enemies[0]));
EffectEngine effectEngine = Factory.EffectEngine;
state = effectEngine.Apply(statusAction, state);
Assert.True(state.Enemies[0].HasEffect("Chilled"));
Assert.Single(state.DelayedActions);
Assert.Contains(state.DelayedActions, x => x.TargetAction.Action.Type == ActionType.RemoveEffect && x.TargetAction.Action.EffectName == "Chilled");
GameEngine engine = Factory.CreateGameEngine(state, effectEngine: effectEngine);
for (int i = 0; i < Time.ActionAmount; ++i)
{
engine.Process();
}
Assert.False(engine.CurrentState.Enemies[0].HasEffect("Chilled"));
Assert.Empty(engine.CurrentState.DelayedActions);
}
void EnableTargetting(TargettingType type, Action <int> action)
{
TargetInfo = new TargettingInfo(type, action);
CombatView.EnableTargetting(type);
}
public void SkillFailsIfInvokerDoesNotHave()
{
Skill skill = Factory.TestSkill;
TestEffectEngine effectEngine = new TestEffectEngine();
GameState state = Factory.DefaultGameState;
SkillEngine engine = new SkillEngine(effectEngine);
Assert.Throws <InvalidOperationException> (() => engine.ApplyTargettedSkill(new TargettedSkill(skill, TargettingInfo.Self(state.Party[0])), state));
}
public void MultipleStatusEffectApplications_ExtendDuration()
{
GameState state = GetDefaultEffectState();
TargettedAction statusAction = new TargettedAction(Factory.StatusEffectAction, TargettingInfo.From(state.Party[0], state.Enemies[0]));
EffectEngine effectEngine = Factory.EffectEngine;
state = effectEngine.Apply(statusAction, state);
state = effectEngine.Apply(statusAction, state);
Assert.True(state.Enemies[0].HasEffect("Chilled"));
Assert.Single(state.DelayedActions);
Assert.True(state.DelayedActions[0].TargetAction.Action.Type == ActionType.RemoveEffect);
Assert.True(state.DelayedActions[0].TargetAction.Action.EffectName == "Chilled");
// Two Time.ActionAmount total (100 -> 0 -> -100)
Assert.True(state.DelayedActions[0].CT == -Time.ActionAmount);
}
