public void CastEggs_Level2Spells([Range(0, 2)] int level2EggIndex)
{
Tuple <MagicType, string> eggCombo = _level2Eggs[level2EggIndex];
string spellName = eggCombo.Item2;
MagicType spellType = eggCombo.Item1;
Spell spell = SpellFactory.GetSpell(spellName);
int damage = spell.Power + _chicken.MagicStrength;
_hero.SetMove(_doNothingMove, 4);
_hero.SetMove(_runawayMove);
_hero.SetMoveTarget(_hero);
_sidekick.SetHealth(damage + 1);
_sidekick.SetMove(_doNothingMove);
_sidekick.SetMoveTarget(_sidekick);
int typeIndex = Globals.EggMagicTypes.ToList().IndexOf(spellType);
_chanceService.PushWhichEventsOccur(typeIndex, typeIndex, (typeIndex + 1) % 3, 1); //the 3 egg types and targetting the sidekick
_battleManager.SuppressBattleIntroAndOutroMessages();
_battleManager.Battle(_humanTeam, _enemyTeam);
var outputs = _output.GetOutputs();
Assert.AreEqual(5, outputs.Length); // 1 for each egg lay, 1 for actual attack, 1 to output how much damage the fighter took
Assert.AreEqual(_castPrefix + spellName + "!\n", outputs[3].Message);
Assert.AreEqual(1, _sidekick.CurrentHealth);
}
public void CastSpell_CorrectlyReflectsSpells([Values(MagicType.Fire, MagicType.Ice, MagicType.Lightning)] MagicType spellType,
[Values(true, false)] bool reflectAll)
{
const int spellCost = 5;
const int spellPower = 5;
const int expectedRemainingHealth = 100 - spellPower;
Spell spell = new Spell("foo", spellType, SpellType.Attack, TargetType.SingleEnemy, spellCost, spellPower);
BattleMove runawayMove = MoveFactory.Get(BattleMoveType.Runaway);
MagicType reflectType = reflectAll ? MagicType.All : spellType;
ReflectStatus status = new ReflectStatus(1, reflectType);
_human.SetHealth(100);
_human.SetMana(spellCost);
_human.SetMagicStrength(0);
_human.SetMagicBonus(spellType, 0);
_human.SetMagicResistance(0);
_human.SetResistanceBonus(spellType, 0);
_human.AddSpell(spell);
_human.SetMove(spell, 1);
_human.SetMove(runawayMove);
_human.SetMoveTarget(_enemy);
_enemy.AddStatus(status);
_enemy.SetHealth(100);
_battleManager.Battle(_humanTeam, _enemyTeam);
Assert.AreEqual(_enemy.MaxHealth, _enemy.CurrentHealth, "enemy should still have full health, the spell should have been reflected!");
Assert.AreEqual(expectedRemainingHealth, _human.CurrentHealth, "the human should have lost 5 health from being hit by their own spell!");
}
public void MalevolenceCharge_CorrectlyRaisesMalevolenceAttackPower()
{
TestHumanFighter fighter2 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
_humanFighter.SetHealth(100);
fighter2.SetHealth(100);
Team shadeTeam = new Team(TestMenuManager.GetTestMenuManager(), _shade1, _shade2);
Team humanTeam = new Team(_menuManager, _humanFighter, fighter2);
_humanFighter.SetMove(_doNothingMove, 3);
_humanFighter.SetMove(_runawayMove);
fighter2.SetMove(_doNothingMove);
_chanceService.PushWhichEventsOccur(_malevolenceAttackIndex, 0, _malevolenceChargeIndex); //first round, _shade1 attacks HumanFighter1, _shade2 charges
_chanceService.PushWhichEventsOccur(_malevolenceChargeIndex, _malevolenceChargeIndex); //second round, both shades charge
_chanceService.PushWhichEventsOccur(_malevolenceChargeIndex, _malevolenceAttackIndex, 1); //third round, _shade1 charges again, _shade2 attacks
_chanceService.PushAttackHitsNotCrit(2);
_battleManager.Battle(humanTeam, shadeTeam);
int fighter1Damage = _humanFighter.MaxHealth - _humanFighter.CurrentHealth;
int fighter2Damage = fighter2.MaxHealth - fighter2.CurrentHealth;
Assert.Greater(fighter2Damage, fighter1Damage);
}
public void MessageDisplayed_OnFighterHealed([Values(5, 10, 25)] int healAmount, [Values] bool shouldTryToOverheal)
{
//arrange
_humanPlayer1.SetHealth(100, shouldTryToOverheal ? 99 : 1);
_humanPlayer1.SetMove(_doNothingMove);
_humanPlayer2.SetMove(_doNothingMove);
_humanTeam.SetDeathsOnRoundEndEvent();
_enemyPlayer1.SetMove(_doNothingMove);
_enemyPlayer2.SetMove(_doNothingMove);
_humanPlayer1.TurnEnded += delegate { _humanPlayer1.Heal(healAmount); };
//Act
_battleManager.Battle(_humanTeam, _enemyTeam);
//Assert
MockOutputMessage[] outputs = _output.GetOutputs();
int expectedHealAmount = shouldTryToOverheal ? 1 : healAmount;
string expectedMessage = $"{_humanPlayer1.DisplayName} was healed for {expectedHealAmount} HP!\n";
MockOutputMessage output = outputs.FirstOrDefault(o => o.Message == expectedMessage);
Assert.NotNull(output);
}
public void ConditionalDanceMove_ExecutesAppropriateEffectWhenDanceInEffect([Values(DanceEffectType.Fire, DanceEffectType.Danger)] DanceEffectType danceEffectType)
{
_testTechnique.ClearEffects();
_testTechnique.SetDanceEffect(danceEffectType);
RestorationBattleMoveEffect conditionalHealEffect = GetRestoreHealthEffect(danceEffectType);
AttackBattleMove attackWithHeal = new AttackBattleMove("foo", TargetType.SingleEnemy, 100, 0, effects: conditionalHealEffect);
_human2.SetMove(_testTechnique, 1);
_human2.SetSpeed(1);
_human1.SetHealth(100, 10);
_human1.SetMove(attackWithHeal, 1);
_chanceService.PushEventsOccur(true, false); //attack hits, is not crit
_human1.SetStrength(_enemy1.MaxHealth);
_human1.SetMoveTarget(_enemy1);
_enemyTeam = new Team(_menuManager, _enemy1);
_enemy1.SetDefense(0);
_enemy1.SetMove(_doNothingMove);
_enemy1.SetMoveTarget(_enemy1);
_battleManager.Battle(_humanTeam, _enemyTeam);
Assert.AreEqual(20, _human1.CurrentHealth, "Human1 should have regained 10 HP when the attack was successful and the dance effect was active");
}
public void CorrectlyKeysOffOwnersHealth([Values(10, 50)] int maxHealth)
{
_owner.SetHealth(maxHealth);
_menu.Build(_owner, _ownerTeam, _enemyTeam, null);
_input.Push($"{maxHealth}", $"{maxHealth - 1}");
NumberInputMenuSelection selection = _menu.GetInput() as NumberInputMenuSelection;
Assert.AreEqual(maxHealth - 1, selection?.Number);
}
public void DamageMethod_AppropriatelyRaisesEvents_WhenFighterSurvives()
{
_fighter.SetHealth(5);
_fighter.PhysicalDamage(2);
var logs = _logger.Logs;
Assert.AreEqual(1, logs.Count);
Assert.AreEqual(EventType.DamageTaken, logs[0].Type);
Assert.AreEqual(_fighter, logs[0].Sender);
var e = logs[0].E as PhysicalDamageTakenEventArgs;
Assert.NotNull(e);
Assert.AreEqual(2, e.Damage);
}
public void Setup()
{
_fighter = new TestHumanFighter("Hero", 1);
_fighter.SetHealth(FighterHealth);
_fighter.SetMana(FighterMana);
_fighter.SetStrength(FighterAttack);
_fighter.SetDefense(FighterDefense);
_fighter.SetSpeed(FighterSpeed);
_fighter.SetEvade(FighterEvade);
_fighter.SetLuck(FighterLuck);
_factoryFighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "Ted");
_factoryFighter.AddSpell(SpellFactory.GetSpell(MagicType.Fire, 1));
_enemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "enemy");
_armoredEnemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "armored");
_superArmoredEnemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "super armored");
_input = new MockInput();
_output = new MockOutput();
_menuManager = new TestMenuManager(_input, _output);
_chanceService = new MockChanceService();
_battleManager = new TestBattleManager(_chanceService, _input, _output);
var humanTeam = new Team(_menuManager, _fighter);
_battleManager.SetHumanTeam(humanTeam);
var enemyTeam = new Team(_menuManager, _enemy);
_battleManager.SetEnemyTeam(enemyTeam);
_battleManager.SetConfig(new BattleManagerBattleConfiguration());
}
public void RestoreHealthEffect_AppropriatelyExecuted_AttackHits()
{
int initialHealth = 100 - _restoreHealthEffect.Percentage;
_human.SetHealth(100, initialHealth);
_human.SetMana(100, 0);
_human.SetMove(_attackWithRestoreHealthEffect);
_human.SetMoveTarget(_enemy);
_chanceService.PushEventsOccur(true, false); //attack hits, not a crit
_enemy.SetMove(_doNothingMove);
_enemy.SetMoveTarget(_enemy);
_battleManager.Battle(_humanTeam, _enemyTeam);
Assert.AreEqual(_human.MaxHealth, _human.CurrentHealth, "humman player's health should have been restored when the attack hit!");
Assert.AreEqual(0, _human.CurrentMana, "humman player's mana should have been unaffected by the restore effect!");
}
public void TestHumanFighter_CorrectlyDies_SetDeathOnTurnEndEventCalled()
{
_fighter.SetHealth(100);
_fighter.SetDeathOnTurnEndEvent();
Assert.AreEqual(100, _fighter.CurrentHealth);
_fighter.OnTurnEnded(new TurnEndedEventArgs(_fighter));
Assert.AreEqual(0, _fighter.CurrentHealth);
}
public void DoesNotCounter_MagicAttacks()
{
Spell fireball = new Spell("fire", MagicType.Fire, SpellType.Attack, TargetType.SingleEnemy, 0, 1);
_humanFighter.AddStatus(_status);
_humanFighter.SetHealth(_enemy.MagicStrength + fireball.Power + 1);
_humanFighter.SetMove(_doNothing, 1);
_humanFighter.SetMove(_runawayMove);
_enemy.AddSpell(fireball);
_enemy.SetMove(fireball);
_battleManager.Battle(_humanTeam, _enemyTeam);
Assert.AreEqual(1, _humanFighter.CurrentHealth);
Assert.AreEqual(_enemy.MaxHealth, _enemy.CurrentHealth);
}
public void CorrectlyRaisesMoveExecutorsMaxHealth_ByShadeLevel_DominatingMoveSucceeds([Range(1, 4)] int shadeLevel)
{
Shade shade = FighterFactory.GetShade(1, shadeLevel: shadeLevel);
TestHumanFighter fighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
const int initialMaxHealth = 10;
fighter.SetHealth(initialMaxHealth);
BattleMoveWithTargetAndNumberInput moveWithTarget = new BattleMoveWithTargetAndNumberInput(_bloodMove, shade, fighter, 1);
_chanceService.PushEventOccurs(true);
//act
_copperBell.ExecuteMove(moveWithTarget);
//assert
int expectedMaxHealth = initialMaxHealth + shadeLevel;
Assert.AreEqual(expectedMaxHealth, fighter.MaxHealth);
}
public void SetUp()
{
_input = new MockInput();
_output = new MockOutput();
_chanceService = new MockChanceService();
_menuManager = new TestMenuManager(_input, _output, new MenuFactory());
_battleManager = new BattleManager(_chanceService, _input, _output);
_shadeGrouping = new ShadeFighterGrouping(_chanceService, new Shade(1, _chanceService, 1), new Shade(1, _chanceService, 1), new Shade(1, _chanceService, 1));
_shadeTeam = new Team(TestMenuManager.GetTestMenuManager(), _shadeGrouping);
_humanFighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
_humanFighter.SetHealth(5);
_humanFighter.SetSpeed(_shadeTeam.Fighters[0].Speed + 1);
_humanTeam = new TestTeam(_menuManager, _humanFighter);
_enemy = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
_enemyTeam = new Team(TestMenuManager.GetTestMenuManager(), _enemy);
}
public void StatusesRemoved_OnRoundEnd()
{
StatMultiplierStatus boostDefenseStatus = new StatMultiplierStatus(1, StatType.Defense, 2);
_humanFighter.SetDefense(1);
_humanFighter.SetHealth(1);
_humanFighter.AddStatus(boostDefenseStatus);
_humanFighter.SetMove(_doNothing, 1);
_humanFighter.SetMove(_runawayMove);
_enemy.SetMove(_basicAttackMove);
_enemy.SetMoveTarget(_humanFighter);
_enemy.SetStrength(2);
_chanceService.PushEventsOccur(true, false);
_battleManager.Battle(_humanTeam, _enemyTeam);
Assert.AreEqual(1, _humanFighter.CurrentHealth);
}
public void CorrectlyHealsMoveExecutor_SealingMoveSucceeds()
{
Shade shade = (Shade)TestFighterFactory.GetFighter(TestFighterType.Shade, 1);
_logger.Subscribe(EventType.FighterSealed, shade);
TestHumanFighter fighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
fighter.SetHealth(10, 9);
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_prayMove, shade, fighter);
_chanceService.PushEventOccurs(true);
Assert.AreNotEqual(fighter.MaxHealth, fighter.CurrentHealth);
//act
_copperBell.ExecuteMove(moveWithTarget);
//assert
Assert.AreEqual(fighter.MaxHealth, fighter.CurrentHealth);
}
