public void AttackIsSafe_AttackingEnemyRegion_ReturnsFalse()
{
var fromRegion = _gameState.AddRegion(_myName, 2);
var toRegion = _gameState.AddRegion(TestGameState.EnemyName, 2);
fromRegion.Neighbors.Add(toRegion);
var result = BattleAnalysis.AttackIsSafe(fromRegion, 1, toRegion, toRegion.Armies, _myName, 0.90f);
Assert.IsFalse(result);
}
public void SimulateBattle_Attackers10Defenders10Threshold90_()
{
var result = BattleAnalysis.AnalyzeBattle(0.90f, 10, 10);
Assert.AreEqual(4, result.AttackerRemainingArmies);
Assert.AreEqual(5, result.AttackerRemainingArmiesHigh);
Assert.AreEqual(1, result.AttackerRemainingArmiesLow);
Assert.AreEqual(4, result.DefenderRemainingArmies);
Assert.AreEqual(7, result.DefenderRemainingArmiesHigh);
Assert.AreEqual(2, result.DefenderRemainingArmiesLow);
}
public void AttackIsSafe_AttackingNeutralRegion_ReturnsTrue()
{
var fromRegion = _gameState.AddRegion(_myName, 2);
var toRegion = _gameState.AddRegion(Constants.NeutralPlayerName, 2);
fromRegion.Neighbors.Add(toRegion);
var result = BattleAnalysis.AttackIsSafe(fromRegion, 1, toRegion, toRegion.Armies, _myName, 0.90f);
Assert.IsTrue(result);
}
public void SimulateBattle_Attackers10Defenders5Threshold75_()
{
var result = BattleAnalysis.AnalyzeBattle(0.75f, 5, 10);
Assert.AreEqual(7, result.AttackerRemainingArmies);
Assert.AreEqual(8, result.AttackerRemainingArmiesHigh);
Assert.AreEqual(5, result.AttackerRemainingArmiesLow);
Assert.AreEqual(0, result.DefenderRemainingArmies);
Assert.AreEqual(1, result.DefenderRemainingArmiesHigh);
Assert.AreEqual(0, result.DefenderRemainingArmiesLow);
}
public void DetermineMaximumSafeAttack_AttackingEnemyRegionWithNeighbors_Returns0()
{
var fromRegion = _gameState.AddRegion(_myName, 2);
var toRegion = _gameState.AddRegion(TestGameState.EnemyName, 2);
var neighbor2 = _gameState.AddRegion(Constants.NeutralPlayerName, 2);
var neighbor3 = _gameState.AddRegion(Constants.NeutralPlayerName, 2);
fromRegion.Neighbors.Add(toRegion);
fromRegion.Neighbors.Add(neighbor2);
fromRegion.Neighbors.Add(neighbor3);
var result = BattleAnalysis.DetermineMaximumSafeAttack(fromRegion, toRegion, TestGameState.MyPlayerName, 0.9f);
Assert.AreEqual(0, result);
}
public void AttackIsSafe_AttackingEnemyRegionWithNeighbors_ReturnsTrue()
{
var fromRegion = _gameState.AddRegion(_myName, 2);
var toRegion = _gameState.AddRegion(TestGameState.EnemyName, 2);
var neighbor2 = _gameState.AddRegion(Constants.NeutralPlayerName, 2);
var neighbor3 = _gameState.AddRegion(Constants.NeutralPlayerName, 2);
fromRegion.Neighbors.Add(toRegion);
fromRegion.Neighbors.Add(neighbor2);
fromRegion.Neighbors.Add(neighbor3);
var result = BattleAnalysis.AttackIsSafe(fromRegion, 1, toRegion, toRegion.Armies, _myName, 0.90f);
Assert.IsFalse(result);
}
private static int PlaceOffensiveArmies(int armiesLeft, GameState state, List <PlaceArmiesMove> placeArmiesMoves)
{
if (armiesLeft == 0)
{
return(armiesLeft);
}
foreach (var targetRegion in StrategicMap.UncontrolledRegionsByValue)
{
foreach (var offensiveRegion in targetRegion.Neighbors)
{
if (offensiveRegion.PlayerName == GameState.MyPlayerName)
{
BattleResult result = BattleAnalysis.AnalyzeBattle(confidence, targetRegion.Armies, offensiveRegion.Armies + armiesLeft);
if (result.AttackerExpectedToWinAtAll())
{
if (offensiveRegion.Armies > Constants.DeadlockThreshold && armiesLeft > 1)
{
armiesLeft = PlaceFailSafeArmy(offensiveRegion, 1, armiesLeft, placeArmiesMoves);
}
placeArmiesMoves.Add(new PlaceArmiesMove(GameState.MyPlayerName, offensiveRegion, armiesLeft));
armiesLeft = 0;
}
}
if (armiesLeft == 0)
{
break;
}
}
if (armiesLeft == 0)
{
break;
}
}
if (armiesLeft > 0)
{
PlaceRemainingArmies(armiesLeft, placeArmiesMoves);
armiesLeft = 0;
}
return(armiesLeft);
}
private static void ConsiderAttacks(Region fromRegion, List <Region> neighbors, List <AttackTransferMove> attackTransferMoves, ConditionalAttackList conditionalAttacks)
{
neighbors.Sort((a, b) => b.StrategicValue.CompareTo(a.StrategicValue));
Region conditionalAttackTarget = null;
foreach (var toRegion in neighbors)
{
if (toRegion.PlayerName != GameState.MyPlayerName)
{
var attackingArmies = BattleAnalysis.DetermineMaximumSafeAttack(fromRegion, toRegion, GameState.MyPlayerName, _confidence);
// it's not safe to attack this guy alone, but if we have armies left and others will attack too, maybe it will be
if (attackingArmies == 0 && conditionalAttackTarget == null)
{
conditionalAttackTarget = toRegion;
}
// don't attack with just one army, it's pretty much always a waste
if (attackingArmies > 1)
{
attackTransferMoves.Add(new AttackTransferMove(GameState.MyPlayerName, fromRegion, toRegion, attackingArmies));
fromRegion.Armies -= attackingArmies; // TODO: this isn't entirely true - maybe revisit it in the future
}
}
if (fromRegion.Armies <= 1)
{
break;
}
}
if (fromRegion.Armies > 2 && conditionalAttackTarget != null)
{
conditionalAttacks.Add(fromRegion, conditionalAttackTarget, fromRegion.Armies - 1);
}
}
public void MaximumArmiesNecessaryToConquer_Attackers24Defenders1Threshold99_()
{
var result = BattleAnalysis.MaximumArmiesNecessaryToConquer(0.99f, 1, 24);
Assert.AreEqual(6, result);
}
