public void WarriorClass_Level1_CorrectlySetsUpSelectMove_NoAttackBoost()
{
_chanceService.PushWhichEventOccurs(0);
List <BattleMove> availableMoves = _level1Warrior.AvailableMoves;
int attackIndex = availableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Attack);
int evadeIndex = availableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Status && (bm as StatusMove)?.Status is AutoEvadeStatus);
int attackBoostIndex = availableMoves.FindIndex(bm => bm.MoveType == BattleMoveType.Status && (bm as StatusMove)?.Status is StatMultiplierStatus);
_level1Warrior.SelectMove(_warriorTeam, _humanTeam);
double[] chances = _chanceService.LastEventOccursArgs;
Assert.AreEqual(0.25, chances[attackIndex]);
Assert.AreEqual(0.25, chances[evadeIndex]);
Assert.AreEqual(0.5, chances[attackBoostIndex]);
}
public void SelectMove_ShouldReturnAttack_TwoEnemies()
{
_mockChanceService.PushWhichEventOccurs(0);
var selectedMove = _fighter.SetupMove(_ownTeam, _doubleEnemyTeam);
Assert.AreEqual(BattleMoveType.Attack, selectedMove.Move.MoveType);
Assert.AreEqual("attack", selectedMove.Move.Description);
Assert.AreEqual(_enemy1, selectedMove.Target);
_mockChanceService.PushWhichEventOccurs(1);
selectedMove = _fighter.SetupMove(_ownTeam, _doubleEnemyTeam);
Assert.AreEqual(BattleMoveType.Attack, selectedMove.Move.MoveType);
Assert.AreEqual("attack", selectedMove.Move.Description);
Assert.AreEqual(_enemy2, selectedMove.Target);
}
public void FighterFactory_CorrectlyRandomizesEggType_IfNoneSpecified()
{
TestFighterFactory.SetChanceService(_chanceService);
_chanceService.PushWhichEventOccurs(0);
Egg egg = (Egg)FighterFactory.GetFighter(FighterType.Egg, 1);
Assert.AreEqual(Globals.EggMagicTypes[0], egg.MagicType);
}
public void ZombieRevivesAfterDying()
{
//Will Revive after 1 round, excluding the round it was killed
_mockChanceService.PushWhichEventOccurs(0);
_zombie.PhysicalDamage(_zombie.MaxHealth);
//zombies will not revive the same turn they had died
//TODO: change this to OnRoundEnd
_zombie.OnTurnEnded(new TurnEndedEventArgs(_zombie));
Assert.IsFalse(_zombie.IsAlive());
_zombie.OnTurnEnded(new TurnEndedEventArgs(_zombie));
Assert.IsTrue(_zombie.IsAlive());
}
public void GetTeam_AssignsAppropriateNumberOfEnemiesToTeam([Values(1, 2, 3, 4)] int numEnemies)
{
//push logic for determining how many fighters will be in the enemy team, driven by SubRegion configuration
_chanceService.PushWhichEventOccurs(0);
Type[] types = { typeof(Goblin), typeof(Fairy), typeof(Golem), typeof(Ogre) };
for (var i = 0; i < numEnemies; ++i)
{
_chanceService.PushWhichEventOccurs(i);
}
SubRegion subRegion = new SubRegion(WorldSubRegion.Fields, 1, new [] { new ChanceEvent <int>(numEnemies, 1) },
new[] { FighterType.Goblin, FighterType.Fairy, FighterType.Golem, FighterType.Ogre }, null);
_enemyTeam = _teamFactory.GetTeam(subRegion);
Assert.AreEqual(numEnemies, _enemyTeam.Fighters.Count);
for (var i = 0; i < numEnemies; ++i)
{
var enemy = _enemyTeam.Fighters[i];
Assert.AreEqual(types[i], enemy.GetType());
}
}
public void CorrectNumberOfBattlesBeforeBoss([Range(1, 3)] int numberBattles)
{
TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Barbarian, 5), new EnemyConfiguration(FighterType.ShieldGuy, 2), new EnemyConfiguration(FighterType.ShieldGuy, 3));
SubRegion subRegion = new SubRegion(WorldSubRegion.Fields, numberBattles, new[] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg },
new BattlefieldConfiguration(bossConfiguration));
SubRegion[] subRegions = { subRegion };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
for (int i = 0; i < numberBattles; ++i)
{
Team team = GetSingleEnemyTeam();
_teamFactory.PushTeams(team);
_chanceService.PushWhichEventOccurs(0);
}
_regionManager = GetRegionManager();
IFighter target = TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
target.PhysicalDamage(target.MaxHealth);
_humanFighter1.SetMove(_basicAttackMove, numberBattles);
_humanFighter1.SetMoveTarget(target);
_chanceService.PushAttackHitsNotCrit(numberBattles);
_humanFighter1.SetMove(_runawayMove);
_humanFighter2.SetMove(_doNothingMove);
_chanceService.PushWhichEventsOccur(0, 0, 0, 0, 0, 0); //used for when the bosses are selecting their moves
_regionManager.Battle(_battleManager, _humanTeam);
List <Team> enemyTeams = _battleManager.GetAllEnemyTeams();
Assert.AreEqual(numberBattles + 1, enemyTeams.Count);
Team bossTeam = enemyTeams[numberBattles];
Assert.AreEqual(3, bossTeam.Fighters.Count);
Assert.True(bossTeam.Fighters.Exists(f => f is Barbarian && f.Level == 5));
Assert.True(bossTeam.Fighters.Exists(f => f is ShieldGuy && f.Level == 2));
Assert.True(bossTeam.Fighters.Exists(f => f is ShieldGuy && f.Level == 3));
}
public void BattleCorrectlyEnds_AllShadesSealed([Range(1, 3)] int numberShades)
{
List <Bell> bells = GetBells(BellType.Copper);
List <Shade> shades = new List <Shade>();
int chargeMoveIndex = -1;
for (int i = numberShades; i > 0; --i)
{
shades.Add(new Shade(1, _chanceService, 1));
}
ShadeFighterGrouping shadeGrouping = new ShadeFighterGrouping(_chanceService, shades.ToArray());
_shadeTeam = new Team(TestMenuManager.GetTestMenuManager(), shadeGrouping);
chargeMoveIndex =
shades[0].GetExecutableMoves(_humanTeam).FindIndex(am => am.MoveType == BattleMoveType.Special);
for (int i = numberShades; i > 0; --i)
{
_input.Push("special", "pray copper", "1");
_chanceService.PushEventOccurs(true); //sealing is successful
for (int j = i; j > 0; --j)
{
_chanceService.PushWhichEventOccurs(chargeMoveIndex);
}
}
//act
BattleEndStatus battleEndStatus = _battleManager.Battle(_humanTeam, _shadeTeam, bells.Cast <TerrainInteractable>().ToList());
Assert.AreEqual(BattleEndStatus.Victory, battleEndStatus);
}
public void GetGroupingCorrectlyReturnsShadeGrouping_LevelRange([Range(1, 3)] int minLevel, [Range(1, 3)] int levelDiff)
{
//Arrange
int maxLevel = minLevel + levelDiff;
int numberFighters = levelDiff + 1;
ShadeGroupingConfiguration config = new ShadeGroupingConfiguration(numberFighters, minLevel, maxLevel);
for (int i = 0; i < numberFighters; ++i)
{
_chanceService.PushWhichEventOccurs(i);
}
//Act
ShadeFighterGrouping grouping = _factory.GetGrouping(config) as ShadeFighterGrouping;
//Assert
Assert.NotNull(grouping);
List <Shade> shades = grouping.GetShades();
for (int i = 0; i < numberFighters; ++i)
{
Assert.AreEqual(minLevel + i, shades[i].Level);
}
}
public void EnemyTeam_TestGetInputs()
{
var count = _enemyTeam.Fighters.Count;
for (var i = 0; i < count; ++i)
{
_chanceService.PushWhichEventOccurs(0);
}
var moves = _enemyTeam.GetInputs(_humanTeam);
Assert.AreEqual(count, moves.Count);
for (var i = 0; i < count; ++i)
{
Assert.AreEqual(BattleMoveType.Attack, moves[i].Move.MoveType);
Assert.AreEqual(_humanTeam.Fighters[0], moves[i].Target);
Assert.AreEqual(_enemyTeam.Fighters[i], moves[i].Owner);
}
}
public void LayEgg_CorrectlyAddsEggsToEnemyTeam()
{
_chanceService.PushWhichEventOccurs(0);
Assert.AreEqual(1, _enemyTeam.Fighters.Count);
var move = _chicken.SetupMove(_enemyTeam, _humanTeam);
_chicken.ExecuteMove(_battleManager, move, _enemyTeam, _humanTeam, _output);
Assert.AreEqual(2, _enemyTeam.Fighters.Count);
var egg = _enemyTeam.Fighters[1];
Assert.IsAssignableFrom <Egg>(egg);
Assert.AreEqual(MagicType.Fire, ((Egg)egg).MagicType);
var outputs = _output.GetOutputs();
Assert.AreEqual(1, outputs.Length);
Assert.AreEqual($"{_chicken.DisplayName} laid a fire egg!\n", outputs[0].Message);
}
public void ShadeCorrectlyTargetsShade_AbsorbMove()
{
//arrange
_chanceService.PushWhichEventOccurs(_absorptionMoveIndex);
Team mixedTeam = new Team(TestMenuManager.GetTestMenuManager(), _shade1, _shade2,
FighterFactory.GetFighter(FighterType.Fairy, 1),
FighterFactory.GetFighter(FighterType.Goblin, 1),
FighterFactory.GetFighter(FighterType.Golem, 1),
FighterFactory.GetFighter(FighterType.Ogre, 1));
//act
BattleMoveWithTarget moveWithTarget = null;
//will throw if the filters do not appropriately filter out all non shades
Assert.DoesNotThrow(() => moveWithTarget = _shade1.SetupMove(mixedTeam, _humanTeam));
//assert
Assert.True(moveWithTarget.Move is ShadeAbsorbingMove);
Assert.AreEqual(_shade2, moveWithTarget.Target);
}