public override BattleMoveWithTarget SetupMove(Team ownTeam, Team enemyTeam)
{
BattleMoveWithTarget ret;
BattleMove move = BeforeSelectMove();
if (move == null)
{
HumanControlledEnemyMenu menu = new HumanControlledEnemyMenu(_input, _output, _menuFactory);
menu.Build(this, ownTeam, enemyTeam, null);
MenuSelection menuSelection = menu.GetInput();
move = menuSelection.Move;
_selectedTarget = menuSelection.Target;
ret = new BattleMoveWithTarget(menuSelection, this);
}
else
{
ret = new BattleMoveWithTarget(move, _selectedTarget, this);
}
AfterSelectMove(move);
return(ret);
}
public void FirstBattle_BarbarianRunsAway_3TurnsAfterShieldDestroyed()
{
_barbarian.PreBattleSetup(_enemyTeam, _humanTeam, _output, BattleConfigurationSpecialFlag.FirstBarbarianBattle);
BattleMoveWithTarget moveWithTarget = _barbarian.SetupMove(_enemyTeam, _humanTeam);
BattleMove battleMove = moveWithTarget.Move;
MultiTurnBattleMove multiTurnMove = battleMove as MultiTurnBattleMove;
Assert.NotNull(multiTurnMove);
Assert.AreEqual(3, multiTurnMove.Moves.Count);
for (int i = 0; i < 3; ++i)
{
battleMove = multiTurnMove.Moves[i];
if (i < 2)
{
Assert.IsAssignableFrom <DoNothingMove>(battleMove);
}
else
{
Assert.AreEqual(BattleMoveType.Runaway, battleMove.MoveType);
}
}
}
public void BattleMoveQueue_AddOperation_CorrectlyIncreasesCount([Values(1, 3)] int numberOfMovesToAdd)
{
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_testMove, null, null);
List <BattleMoveWithTarget> initializerList = new List <BattleMoveWithTarget>
{
moveWithTarget,
moveWithTarget
};
BattleMoveQueue queue = new BattleMoveQueue(initializerList);
List <BattleMoveWithTarget> movesToAdd = new List <BattleMoveWithTarget>();
for (var i = 0; i < numberOfMovesToAdd; ++i)
{
movesToAdd.Add(moveWithTarget);
}
queue.AddRange(movesToAdd);
int expectedCount = initializerList.Count + numberOfMovesToAdd;
Assert.AreEqual(expectedCount, queue.Count);
}
public void BattleMoveQueue_SortAndPopOperation_ReturnsCorrectMove()
{
TestHumanFighter fighter1 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter2 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter3 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
//sorted order is 2, 3, 1
fighter1.SetSpeed(0);
fighter2.SetSpeed(2);
fighter3.SetSpeed(1);
List <BattleMoveWithTarget> initializerList = new List <BattleMoveWithTarget>
{
new BattleMoveWithTarget(_testMove, fighter1, fighter1),
new BattleMoveWithTarget(_testMove, fighter2, fighter2),
new BattleMoveWithTarget(_testMove, fighter3, fighter3)
};
BattleMoveQueue queue = new BattleMoveQueue(initializerList);
BattleMoveWithTarget firstSortedMove = queue.SortAndPop();
IFighter owner = firstSortedMove.Owner;
Assert.AreEqual(fighter2, owner);
Assert.AreEqual(2, queue.Count);
}
public void Level1ShieldGuy_SelectsAppropriateTarget_ShieldHealingMove([Values(1, 2, 3)] int numberOfAlliesWithDamagedShields)
{
IronBattleShield shield = new IronBattleShield(5, 0, 0);
_shieldGuyTeam.Fighters.ForEach(f => f.SetBattleShield(shield));
for (int i = 0; i < numberOfAlliesWithDamagedShields; ++i)
{
_shieldGuyTeam.Fighters[i].BattleShield.DecrementHealth(1);
}
_chanceService.PushWhichEventsOccur(2);
if (numberOfAlliesWithDamagedShields > 1)
{
_chanceService.PushWhichEventsOccur(numberOfAlliesWithDamagedShields - 1); //Select the target
}
BattleMoveWithTarget moveWithTarget = _level1ShieldGuy.SetupMove(_shieldGuyTeam, _humanTeam);
if (numberOfAlliesWithDamagedShields > 1)
{
double[] lastEventOccursArgs = _chanceService.LastEventOccursArgs;
double chance = 1.0 / numberOfAlliesWithDamagedShields;
Assert.AreEqual(numberOfAlliesWithDamagedShields, lastEventOccursArgs.Length);
for (int i = 0; i < numberOfAlliesWithDamagedShields; ++i)
{
Assert.AreEqual(chance, lastEventOccursArgs[i]);
}
}
Assert.AreEqual(_shieldGuyTeam.Fighters[numberOfAlliesWithDamagedShields - 1], moveWithTarget.Target);
}
public void Level1ShieldGuy_SelectsAppropriateTarget_IronShieldMove([Values(0, 1, 2)] int numberOfAlliesWithShields)
{
for (int i = 0; i < numberOfAlliesWithShields; ++i)
{
_shieldGuyTeam.Fighters[i].SetBattleShield(new IronBattleShield(1, 0, 0));
}
_chanceService.PushWhichEventsOccur(1); //Will select iron shield move
if (numberOfAlliesWithShields < 2)
{
_chanceService.PushWhichEventsOccur(0); //Select the target
}
BattleMoveWithTarget moveWithTarget = _level1ShieldGuy.SetupMove(_shieldGuyTeam, _humanTeam);
double[] lastEventOccursArgs = _chanceService.LastEventOccursArgs;
if (numberOfAlliesWithShields < 2)
{
int numberOfAlliesWithoutShields = 3 - numberOfAlliesWithShields;
double chance = 1.0 / numberOfAlliesWithoutShields;
Assert.AreEqual(numberOfAlliesWithoutShields, lastEventOccursArgs.Length);
for (int i = 0; i < numberOfAlliesWithShields; ++i)
{
Assert.AreEqual(chance, lastEventOccursArgs[i]);
}
}
Assert.AreEqual(_shieldGuyTeam.Fighters[numberOfAlliesWithShields], moveWithTarget.Target);
}
public void BattleMoveQueue_SortOperation_DefaultsBySpeedAndPriority()
{
TestHumanFighter fighter1 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter2 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter3 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter4 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter5 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter6 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter7 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter8 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter9 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter[] expectedOrderedFighters =
{
fighter9, fighter6, fighter3, //the high priority
fighter8, fighter5, fighter2, //the med priority
fighter7, fighter4, fighter1 //the low priority
};
fighter1.SetSpeed(0);
fighter2.SetSpeed(0);
fighter3.SetSpeed(0);
fighter4.SetSpeed(1);
fighter5.SetSpeed(1);
fighter6.SetSpeed(1);
fighter7.SetSpeed(2);
fighter8.SetSpeed(2);
fighter9.SetSpeed(2);
BattleMove lowPriorityMove = new BattleMove("foo", BattleMoveType.DoNothing, TargetType.Self, -1);
BattleMove medPriorityMove = new BattleMove("bar", BattleMoveType.DoNothing, TargetType.Self);
BattleMove highPriorityMove = new BattleMove("baz", BattleMoveType.DoNothing, TargetType.Self, 1);
List <BattleMoveWithTarget> initializerList = new List <BattleMoveWithTarget>
{
new BattleMoveWithTarget(lowPriorityMove, fighter1, fighter1),
new BattleMoveWithTarget(lowPriorityMove, fighter4, fighter4),
new BattleMoveWithTarget(lowPriorityMove, fighter7, fighter7),
new BattleMoveWithTarget(medPriorityMove, fighter2, fighter2),
new BattleMoveWithTarget(medPriorityMove, fighter5, fighter5),
new BattleMoveWithTarget(medPriorityMove, fighter8, fighter8),
new BattleMoveWithTarget(highPriorityMove, fighter3, fighter3),
new BattleMoveWithTarget(highPriorityMove, fighter6, fighter6),
new BattleMoveWithTarget(highPriorityMove, fighter9, fighter9)
};
BattleMoveQueue queue = new BattleMoveQueue(initializerList);
queue.Sort();
for (int i = 0; i < 9; ++i)
{
BattleMoveWithTarget move = queue.Pop();
IFighter owner = move.Owner;
Assert.AreEqual(expectedOrderedFighters[i], owner, $"i: {i}");
}
}
public void FirstBattle_BarbarianDoesNothingWhileEquippedWithShield()
{
_barbarian.PreBattleSetup(_enemyTeam, _humanTeam, _output, BattleConfigurationSpecialFlag.FirstBarbarianBattle);
BattleMoveWithTarget moveWithTarget = _barbarian.GetZeroTurnMove(_enemyTeam, _humanTeam);
ShieldMove move = moveWithTarget.Move as ShieldMove;
_barbarian.SetBattleShield(move?.Shield as BattleShield);
BattleMove battleMove = _barbarian.SelectMove(_enemyTeam, _humanTeam);
Assert.IsAssignableFrom <DoNothingMove>(battleMove);
}
public void GetZeroTurnMove_FirstBattle_IsUnbustableShieldMove()
{
//Arrange
_barbarian.PreBattleSetup(_enemyTeam, _humanTeam, _output, BattleConfigurationSpecialFlag.FirstBarbarianBattle);
//Act
BattleMoveWithTarget moveWithTarget = _barbarian.GetZeroTurnMove(_enemyTeam, _humanTeam);
//Assert
ShieldMove move = moveWithTarget.Move as ShieldMove;
Assert.NotNull(move);
IBattleShield shield = move.Shield;
Assert.AreEqual(1, shield.ShieldBusterDefense);
}
public override void ExecuteMove(BattleManager.BattleManager battleManager, BattleMoveWithTarget move, Team ownTeam, Team enemyTeam, IOutput output)
{
if (move.Move is ShadeAbsorbingMove)
{
Shade target = move.Target as Shade;
AbsorbShade(target);
}
else if (move.Move.MoveType == BattleMoveType.Special && move.Move.Description == "dark energy gather")
{
if (_malevolenceCounter < MaxMalevolenceLevel)
{
_malevolenceCounter++;
}
}
}
public void BattleMoveQueue_AcceptsListInInitializer([Values(1, 3)] int numberOfMovesInInitializerList)
{
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_testMove, null, null);
List <BattleMoveWithTarget> initializerList = new List <BattleMoveWithTarget>();
for (var i = 0; i < numberOfMovesInInitializerList; ++i)
{
initializerList.Add(moveWithTarget);
}
BattleMoveQueue queue = new BattleMoveQueue(initializerList);
Assert.AreEqual(numberOfMovesInInitializerList, queue.Count);
}
public void SealMove_MoreEffectiveForSilverBellThanCopperBell()
{
//arrange
Shade shade = FighterFactory.GetShade(1);
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_prayMove, shade, _fighter);
_chanceService.PushEventsOccur(false, false);
//act
_silverBell.ExecuteMove(moveWithTarget);
_copperBell.ExecuteMove(moveWithTarget);
//assert
List <double> chances = _chanceService.LastChanceVals;
Assert.Greater(chances[0], chances[1]);
}
public void SelectTarget_CorrectlySelectsAlly_TargetTypeSingleAlly()
{
BattleMove targetAllyMove = new BattleMove("foo", BattleMoveType.Spell, TargetType.SingleAlly);
_fighter.SetAvailableMove(targetAllyMove);
_ownTeam = new Team(TestMenuManager.GetTestMenuManager(), _fighter, FighterFactory.GetFighter(FighterType.Fairy, 2), FighterFactory.GetFighter(FighterType.Goblin, 2));
_mockChanceService.PushWhichEventOccurs(0);
BattleMoveWithTarget selectedMove = _fighter.SetupMove(_ownTeam, _singleEnemyTeam);
double[] lastChanceArr = _mockChanceService.LastEventOccursArgs;
Assert.AreEqual(2, lastChanceArr.Length); //will be 1 if it targets the human team, 3 if the fighter included itself
IFighter selectedTarget = selectedMove.Target;
Assert.AreEqual(_ownTeam.Fighters[1], selectedTarget);
}
public void MalevolenceCharge_RemovedFromExecutableMoves_MaximumCharge()
{
List <BattleMove> executableMovesBefore = _shade1.GetExecutableMoves(_humanTeam);
BattleMove chargeMove = executableMovesBefore.First(m => m.MoveType == BattleMoveType.Special);
BattleMoveWithTarget chargeMoveWithTarget = new BattleMoveWithTarget(chargeMove, _shade1, _shade1);
for (var i = 0; i < Shade.MaxMalevolenceLevel; ++i)
{
_shade1.ExecuteMove(_battleManager, chargeMoveWithTarget, _shadeTeam, _humanTeam, _output);
}
List <BattleMove> executableMovesAfter = _shade1.GetExecutableMoves(_humanTeam);
Assert.AreEqual(1, executableMovesBefore.Count - executableMovesAfter.Count);
BattleMove notInAfterList = executableMovesBefore.FirstOrDefault(m => !executableMovesAfter.Contains(m));
Assert.AreEqual(chargeMove, notInAfterList);
}
public void BattleMoveQueue_PopOperation_CorrectlyReturnsNextMove([Values(1, 3)] int numberOfMovesToPop)
{
IFighter fighter1 = TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1, "Jeff");
IFighter fighter2 = TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1, "Jebb");
BattleMoveWithTarget moveWithTarget1 = new BattleMoveWithTarget(_testMove, fighter1, fighter1);
BattleMoveWithTarget moveWithTarget2 = new BattleMoveWithTarget(_testMove, fighter2, fighter2);
List <BattleMoveWithTarget> initializerList = new List <BattleMoveWithTarget>
{
moveWithTarget1,
moveWithTarget2
};
BattleMoveQueue queue = new BattleMoveQueue(initializerList);
Assert.AreEqual(moveWithTarget1, queue.Pop());
Assert.AreEqual(moveWithTarget2, queue.Pop());
}
public void SelfTargetMove_TargetsHumanControlledEnemy_NotInnerFighter()
{
Goblin goblin = (Goblin)FighterFactory.GetFighter(FighterType.Goblin, 1);
_enemyTeam = new Team(_menuManager, goblin);
_fighter.SetEnemy(_enemy);
_ownTeam = new Team(_menuManager, _fighter);
_enemy.SetAvailableMove(new BattleMove("foo", BattleMoveType.Dance, TargetType.Self));
_input.Push("1", "1");
BattleMoveWithTarget ret = _fighter.SetupMove(_ownTeam, _enemyTeam);
Assert.AreEqual(_fighter, ret.Target);
//call me paranoid. I'd rather check
Assert.AreNotEqual(_enemy, ret.Target);
}
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);
}
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);
}
public void ShadeDoesNotTargetFoeAlreadyInflictedWithBlindness()
{
StatusMove darkFogMove = _shade1.GetExecutableMoves(_humanTeam)[_darkFogIndex] as StatusMove;
_humanFighter.AddStatus(darkFogMove?.Status);
Egg blindEgg = new Egg(MagicType.Fire);
blindEgg.AddStatus(darkFogMove?.Status);
Team humanTeam = new Team(TestMenuManager.GetTestMenuManager(), _humanFighter, blindEgg, new Egg(MagicType.Fire));
_chanceService.PushWhichEventOccurs(_darkFogIndex);
BattleMoveWithTarget moveWithTarget = null;
//will throw if multiple targets
Assert.DoesNotThrow(() => moveWithTarget = _shade1.SetupMove(_shadeTeam, humanTeam));
Assert.NotNull(moveWithTarget);
Assert.AreEqual(darkFogMove, moveWithTarget.Move);
Assert.AreEqual(humanTeam.Fighters[2], moveWithTarget.Target);
}
public void BattleMoveQueue_SortOperation_DefaultsBySpeed()
{
TestHumanFighter fighter1 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter2 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
TestHumanFighter fighter3 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
//sorted order is 2, 3, 1
fighter1.SetSpeed(0);
fighter2.SetSpeed(2);
fighter3.SetSpeed(1);
List <BattleMoveWithTarget> initializerList = new List <BattleMoveWithTarget>
{
new BattleMoveWithTarget(_testMove, fighter1, fighter1),
new BattleMoveWithTarget(_testMove, fighter2, fighter2),
new BattleMoveWithTarget(_testMove, fighter3, fighter3)
};
BattleMoveQueue queue = new BattleMoveQueue(initializerList);
queue.Sort();
IFighter owner;
//sorted order is 2, 3, 1
BattleMoveWithTarget firstSortedMove = queue.Pop();
owner = firstSortedMove.Owner;
Assert.AreEqual(fighter2, owner);
BattleMoveWithTarget secondSortedMove = queue.Pop();
owner = secondSortedMove.Owner;
Assert.AreEqual(fighter3, owner);
BattleMoveWithTarget thirdSortedMove = queue.Pop();
owner = thirdSortedMove.Owner;
Assert.AreEqual(fighter1, owner);
}
public void GetInputs_TeamBothHumanAndEnemyFighters_DoesNotGetInputFromDefeatedFighters()
{
TestEnemyFighter fighter3 = (TestEnemyFighter)TestFighterFactory.GetFighter(TestFighterType.TestEnemy, 1);
TestHumanFighter fighter4 = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
Team testTeam = new Team(_menuManager, _enemyPlayer1, _humanPlayer1, fighter3, fighter4);
_enemyPlayer1.PhysicalDamage(_enemyPlayer1.MaxHealth);
_humanPlayer1.PhysicalDamage(_humanPlayer1.MaxHealth);
fighter4.PhysicalDamage(fighter4.MaxHealth);
foreach (ITestFighter fighter in testTeam.Fighters.Cast <ITestFighter>())
{
fighter.SetMove(_basicAttackMove);
fighter.SetMoveTarget(_enemyPlayer1);
}
List <BattleMoveWithTarget> returnedInputs = testTeam.GetInputs(testTeam);
Assert.AreEqual(1, returnedInputs.Count);
BattleMoveWithTarget moveWithTarget = returnedInputs[0];
Assert.AreEqual(fighter3, moveWithTarget.Owner);
}
protected BattleMoveWithTarget ProcessMove(BattleMove move, int index, IFighter fighter, IFighter originalTarget)
{
BattleMoveWithTarget ret;
var multiTurn = move as MultiTurnBattleMove;
if (multiTurn != null)
{
_testFigherMultiTurnSelections[index] = new MultiTurnSelection(fighter, multiTurn, 1,
originalTarget);
var firstMove = multiTurn.Moves[0];
var moveTarget = firstMove.TargetType == TargetType.Self ? fighter : originalTarget;
ret = new BattleMoveWithTarget(move, moveTarget, fighter);
}
else
{
ret = new BattleMoveWithTarget(move, originalTarget, fighter);
}
return(ret);
}
public void SealMove_DifferentEnemyHealthLevels_CorrectlyGeneratesDifferentChanceSuccessRates()
{
double[] expectedChances = { 1.0 / 3, 0.5, 0.65, 0.8 };
TestHumanFighter fighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
for (var i = 0; i < 4; ++i)
{
Shade shade = (Shade)TestFighterFactory.GetFighter(TestFighterType.Shade, 1);
shade.PhysicalDamage(i);
Assert.AreEqual(4, shade.MaxHealth);
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_prayMove, shade, fighter);
_chanceService.PushEventOccurs(true);
//act
_copperBell.ExecuteMove(moveWithTarget);
//assert
Assert.AreEqual(expectedChances[i], _chanceService.LastChanceVals[i],
$"for index value {i}, shade health is {shade.CurrentHealth} out of {shade.MaxHealth}");
}
}
public void AbsorbMove_CorrectlyAbsorbsShadeWhenExecuted()
{
//arrange
_logger.Subscribe(EventType.ShadeAbsorbed, _shade1);
BattleMove shadeAbsorbingTechnique = _shade1.AvailableMoves.FirstOrDefault(m => m is ShadeAbsorbingMove);
BattleMoveWithTarget absorbMoveWithTarget = new BattleMoveWithTarget(shadeAbsorbingTechnique, _shade2, _shade1);
_chanceService.PushWhichEventOccurs(0); //so the absorb method doesn't throw an error
//act
_shade1.ExecuteMove(_battleManager, absorbMoveWithTarget, _shadeTeam, _humanTeam, _output);
//assert
Assert.AreEqual(2, _shade1.ShadeExperience);
List <EventLog> logs = _logger.Logs;
Assert.AreEqual(1, logs.Count);
EventLog log = logs[0];
Assert.AreEqual(_shade1, log.Sender);
Assert.AreEqual(_shade2, (log.E as ShadeAbsorbedEventArgs)?.AbsorbedShade);
Assert.AreEqual(0, _shade2.CurrentHealth);
}
public void SetupMove_CorrectlyHandlesMultiTurnMoves()
{
Goblin goblin = (Goblin)FighterFactory.GetFighter(FighterType.Goblin, 1);
_enemyTeam = new Team(_menuManager, goblin);
MultiTurnBattleMove multiTurnMove =
goblin.AvailableMoves.OfType <MultiTurnBattleMove>().First(am => am.MoveType == BattleMoveType.MultiTurn);
_fighter.SetEnemy(goblin);
_ownTeam = new Team(_menuManager, _fighter);
_input.Push("2", "1");
BattleMoveWithTarget returnedMove = _fighter.SetupMove(_ownTeam, _enemyTeam);
Assert.AreEqual(multiTurnMove, returnedMove.Move);
returnedMove = _fighter.SetupMove(_ownTeam, _enemyTeam);
Assert.AreEqual(multiTurnMove.Moves[1], returnedMove.Move);
}
public void Level1ShieldGuy_SelectsAppropriateTarget_ShieldFortifyingMove([Values(1, 2, 3)] int numberOfAlliesWithShield)
{
int selectedTargetIndex = numberOfAlliesWithShield - 1;
IronBattleShield shield = new IronBattleShield(5, 0, 0);
for (int i = 0; i < numberOfAlliesWithShield; ++i)
{
_shieldGuyTeam.Fighters[i].SetBattleShield(shield);
}
int selectedMoveIndex = numberOfAlliesWithShield == 3 ? 1 : 2;
_chanceService.PushWhichEventsOccur(selectedMoveIndex);
if (numberOfAlliesWithShield > 1)
{
_chanceService.PushWhichEventsOccur(selectedTargetIndex); //Select the target
}
BattleMoveWithTarget moveWithTarget = _level1ShieldGuy.SetupMove(_shieldGuyTeam, _humanTeam);
if (numberOfAlliesWithShield > 1)
{
double[] lastEventOccursArgs = _chanceService.LastEventOccursArgs;
double chance = 1.0 / numberOfAlliesWithShield;
Assert.AreEqual(numberOfAlliesWithShield, lastEventOccursArgs.Length);
for (int i = 0; i < numberOfAlliesWithShield; ++i)
{
Assert.AreEqual(chance, lastEventOccursArgs[i]);
}
}
IFighter expectedTarget = _shieldGuyTeam.Fighters[selectedTargetIndex];
Assert.AreEqual(expectedTarget, moveWithTarget.Target);
}
public void Shade_MoreLikelyToAttackLessLikelyToCharge_TheMoreMalevolenceHasAlreadyBeenCharged()
{
List <double> chargeChances = new List <double>();
List <double> attackChances = new List <double>();
for (var i = 0; i < Shade.MaxMalevolenceLevel; ++i)
{
_chanceService.PushWhichEventOccurs(_malevolenceChargeIndex);
BattleMoveWithTarget moveWithTarget = _shade1.SetupMove(_shadeTeam, _humanTeam);
double[] lastEventOccurs = _chanceService.LastEventOccursArgs;
chargeChances.Add(lastEventOccurs[_malevolenceChargeIndex]);
attackChances.Add(lastEventOccurs[_malevolenceAttackIndex]);
if (i > 0)
{
Assert.Greater(attackChances[i], attackChances[i - 1]);
Assert.Less(chargeChances[i], chargeChances[i - 1]);
}
_shade1.ExecuteMove(_battleManager, moveWithTarget, _shadeTeam, _humanTeam, _output);
}
}
public void CorrectlySealsShade_WhenExecutingPrayMove()
{
Shade shade = (Shade)TestFighterFactory.GetFighter(TestFighterType.Shade, 1);
_logger.Subscribe(EventType.FighterSealed, shade);
TestHumanFighter fighter = (TestHumanFighter)TestFighterFactory.GetFighter(TestFighterType.TestHuman, 1);
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_prayMove, shade, fighter);
_chanceService.PushEventOccurs(true);
//act
_copperBell.ExecuteMove(moveWithTarget);
//assert
Assert.AreEqual(0, shade.CurrentHealth);
List <EventLog> logs = _logger.Logs;
Assert.AreEqual(1, logs.Count);
Assert.AreEqual(EventType.FighterSealed, logs[0].Type);
Assert.AreEqual(shade, logs[0].Sender);
}
public override void ExecuteMove(BattleManager.BattleManager battleManager, BattleMoveWithTarget move, Team ownTeam, Team enemyTeam, IOutput output)
{
if (move.Move.Description == "cast eggs" && !CanCastEggs())
{
var newMove = SelectMove(ownTeam, enemyTeam);
move = new BattleMoveWithTarget(newMove, move.Target, move.Owner);
}
switch (move.Move.Description)
{
case "lay 2 eggs":
LayEgg(ownTeam, output);
LayEgg(ownTeam, output);
break;
case "cast eggs":
CastEggs(battleManager, ownTeam, enemyTeam, output);
break;
default: //"lay egg" is assumed default move
LayEgg(ownTeam, output);
break;
}
}
public void SealMove_DifferentShadeLevels_CorrectlyGeneratesDifferentChanceSuccessRates(
[Range(1, 5)] int shadeLevel, [Range(0, 1)] int damage)
{
double expectedChance = damage == 0 ? 1.0 / 3 : 0.5;
int levelDiff = shadeLevel - 1;
double chanceDecrease = levelDiff * 0.1;
expectedChance = Math.Max(expectedChance - chanceDecrease, 0.1);
Shade shade = FighterFactory.GetShade(1, shadeLevel: shadeLevel);
shade.PhysicalDamage(damage);
BattleMoveWithTarget moveWithTarget = new BattleMoveWithTarget(_prayMove, shade, _fighter);
_chanceService.PushEventOccurs(true);
//act
_copperBell.ExecuteMove(moveWithTarget);
//assert
Assert.AreEqual(expectedChance, _chanceService.LastChanceVals[0]);
}
