// TODO weitermachen
private void DeleteBadTransferMoves(Moves movesSoFar)
{
var interestingTransfers = new List <BotOrderAttackTransfer>();
foreach (var atm in movesSoFar.Orders.OfType <BotOrderAttackTransfer>())
{
if (atm.Armies.AttackPower > 1 && atm.To.OwnerPlayerID == BotState.Me.ID && atm.From.GetTotalDeployment(BotTerritory.DeploymentType.Normal) > 0)
{
interestingTransfers.Add(atm);
}
}
foreach (var atm_1 in interestingTransfers)
{
var deploymentToShift = Math.Min(atm_1.From.GetTotalDeployment(BotTerritory.DeploymentType.Normal), atm_1.Armies.AttackPower);
atm_1.Armies = atm_1.Armies.Subtract(new Armies(deploymentToShift));
var pam = new BotOrderDeploy(BotState.Me.ID, atm_1.To, deploymentToShift);
MovesCommitter.CommittPlaceArmiesMove(pam);
movesSoFar.AddOrder(pam);
foreach (var oldDeployment in atm_1.From.GetDeployment(BotTerritory.DeploymentType.Normal))
{
while (deploymentToShift > 0)
{
if (oldDeployment.Armies > 0)
{
deploymentToShift--;
oldDeployment.Armies = oldDeployment.Armies - 1;
}
else
{
break;
}
}
}
}
}
private void CalculateJoinInAttacksMoves(Moves moves)
{
var joinInAttackMoves = JoinInAttacksTask.CalculateJoinInAttacksTask(BotState);
MovesCommitter.CommittMoves(BotState, joinInAttackMoves);
moves.MergeMoves(joinInAttackMoves);
}
private void CalculateDelayMoves(Moves moves)
{
var maxMovesBeforeRiskyAttack = 7;
var minMovesBeforeRiskyAttack = 1;
var delayMoves = DelayTask.CalculateDelayTask(BotState, moves, maxMovesBeforeRiskyAttack,
minMovesBeforeRiskyAttack);
MovesCommitter.CommittMoves(BotState, delayMoves);
moves.MergeMoves(delayMoves);
}
private void CalculateFlankBonusMoves(Moves moves)
{
var maxDeployment = BotState.MyIncome.Total - moves.GetTotalDeployment();
var flankBonusMoves = FlankBonusTask.CalculateFlankBonusTask(BotState, maxDeployment);
if (flankBonusMoves != null)
{
MovesCommitter.CommittMoves(BotState, flankBonusMoves);
moves.MergeMoves(flankBonusMoves);
}
}
private void CalculateMoveIdleArmiesMoves(Moves moves)
{
var idleArmiesMoves = MoveIdleArmiesTask.CalculateMoveIdleArmiesTask(BotState);
MovesCommitter.CommittMoves(BotState, idleArmiesMoves);
moves.MergeMoves(idleArmiesMoves);
var idleExpansionArmiesMoves = MoveIdleArmiesTask.CalculateMoveIdleExpansionArmiesTask(BotState);
MovesCommitter.CommittMoves(BotState, idleExpansionArmiesMoves);
moves.MergeMoves(idleExpansionArmiesMoves);
}
private void CalculateNoPlanTryoutAttackMoves(Moves moves)
{
var foundMove = true;
while (foundMove)
{
foundMove = false;
var tryoutAttackMoves = NoPlanTryoutAttackTask.CalculateNoPlanTryoutAttackTask(BotState, false, true, true);
if (tryoutAttackMoves != null)
{
foundMove = true;
MovesCommitter.CommittMoves(BotState, tryoutAttackMoves);
moves.MergeMoves(tryoutAttackMoves);
}
}
}
public void StoreOpponentDeployment()
{
var lastVisibleMap = BotState.LastVisibleMapX;
foreach (GamePlayer opponent in BotState.Opponents)
{
List <GameOrderDeploy> opponentDeployments = BotState.PrevTurn.Where(o => o.PlayerID == opponent.ID).OfType <GameOrderDeploy>().ToList();
foreach (GameOrderDeploy opponentDeployment in opponentDeployments)
{
BotTerritory lwmTerritory = lastVisibleMap.Territories[opponentDeployment.DeployOn];
if (lwmTerritory.IsVisible)
{
MovesCommitter.CommittPlaceArmiesMove(new BotOrderDeploy(lwmTerritory.OwnerPlayerID, lwmTerritory, opponentDeployment.NumArmies));
}
}
}
}
private void CalculateNoPlanCleanupMoves(Moves moves)
{
// The cleanup deployment
var armiesToDeploy = BotState.MyIncome.Total - moves.GetTotalDeployment();
var cleanupDeploymentMoves = NoPlanCleanupTask.CalculateNoPlanCleanupDeploymentTask(BotState, armiesToDeploy, moves);
MovesCommitter.CommittMoves(BotState, cleanupDeploymentMoves);
moves.MergeMoves(cleanupDeploymentMoves);
CalculateMoveIdleArmiesMoves(moves);
// The cleanup expansion moves. We need here already the distance to the opponent border
BotState.ExpansionMapUpdater.UpdateExpansionMap();
DistanceCalculator.CalculateDistanceToOpponentBorderCare3(BotState.ExpansionMap, BotState.VisibleMap);
var cleanupExpansionMoves = NoPlanCleanupTask.CalculateNoPlanCleanupExpansionTask(BotState, moves);
MovesCommitter.CommittMoves(BotState, cleanupExpansionMoves);
moves.MergeMoves(cleanupExpansionMoves);
}
private void CalculateSnipeBonusMoves(Moves moves)
{
var maxDeployment = BotState.MyIncome.Total - moves.GetTotalDeployment();
var bestSnipableBonus = BotState.PreventOpponentExpandBonusTask.GetBestBonusToPrevent(BotState.VisibleMap, BotState.WorkingMap);
if (bestSnipableBonus == null)
{
return;
}
var snipeBonusMoves = BotState.PreventOpponentExpandBonusTask.CalculatePreventOpponentExpandBonusTaskk(bestSnipableBonus, maxDeployment, BotState.VisibleMap, BotState.WorkingMap);
if (snipeBonusMoves != null)
{
MovesCommitter.CommittMoves(BotState, snipeBonusMoves);
moves.MergeMoves(snipeBonusMoves);
}
}
private void CalculateNoPlanAttackTerritoriesMoves(Moves moves)
{
var foundAnAttack = true;
while (foundAnAttack)
{
var maxDeployment = BotState.MyIncome.Total - moves.GetTotalDeployment();
var unplannedAttackMoves = NoPlanAttackBestTerritoryTask.CalculateNoPlanAttackBestTerritoryTask
(BotState, maxDeployment);
if (unplannedAttackMoves == null)
{
foundAnAttack = false;
}
else
{
MovesCommitter.CommittMoves(BotState, unplannedAttackMoves);
moves.MergeMoves(unplannedAttackMoves);
}
}
}
public void GuessOpponentDeployment(PlayerIDType opponentID)
{
Assert.Fatal(BotState.NumberOfTurns != -1);
if (BotState.NumberOfTurns == 0)
{
foreach (var vmTerritory in BotState.VisibleMap.OpponentTerritories(opponentID))
{
var armies = BotState.Settings.MinimumArmyBonus;
MovesCommitter.CommittPlaceArmiesMove(new BotOrderDeploy(opponentID, vmTerritory, armies));
}
}
else
{
foreach (var vmTerritory1 in BotState.VisibleMap.OpponentTerritories(opponentID))
{
var lvmTerritory = BotState.LastVisibleMapX.Territories[vmTerritory1.ID];
var guessedOpponentDeployment = 0;
if (lvmTerritory.IsVisible && lvmTerritory.OwnerPlayerID == opponentID)
{
var opponentIncome = BotState.GetGuessedOpponentIncome(opponentID, BotState.VisibleMap);
guessedOpponentDeployment = Math.Min(lvmTerritory.GetTotalDeployment(BotTerritory.DeploymentType.Normal), opponentIncome);
if (HasDeploymentReasonDisapeared(lvmTerritory, vmTerritory1))
{
var boundDeployment = GetBoundOpponentDeployment(opponentID, vmTerritory1);
var maxDeployment = BotState.GetGuessedOpponentIncome(opponentID, BotState.VisibleMap) - boundDeployment;
guessedOpponentDeployment = Math.Min(5, maxDeployment);
}
}
else
{
var boundDeployment = GetBoundOpponentDeployment(opponentID, vmTerritory1);
var maxDeployment = BotState.GetGuessedOpponentIncome(opponentID, BotState.VisibleMap) - boundDeployment;
guessedOpponentDeployment = Math.Max(1, Math.Min(5, maxDeployment));
}
var pam = new BotOrderDeploy(opponentID, vmTerritory1, guessedOpponentDeployment);
MovesCommitter.CommittPlaceArmiesMove(pam);
var conservativePam = new BotOrderDeploy(opponentID, vmTerritory1, BotState.GetGuessedOpponentIncome(opponentID, BotState.VisibleMap));
MovesCommitter.CommittPlaceArmiesMove(conservativePam, BotTerritory.DeploymentType.Conservative);
}
}
}
public void CalculateExpansionMoves(Moves moves)
{
var armiesForExpansion = Math.Min(BotState.Settings.MinimumArmyBonus, BotState.MyIncome.Total - moves.GetTotalDeployment());
var armiesForTakeOver = BotState.MyIncome.Total - moves.GetTotalDeployment();
if (BotState.VisibleMap.GetOpponentBorderingTerritories().Count == 0)
{
armiesForExpansion = BotState.MyIncome.Total - moves.GetTotalDeployment();
}
AddValueToImmediateBonuses(armiesForTakeOver);
var sortedAccessibleBonuses = BotState.BonusExpansionValueCalculator.SortAccessibleBonuses(BotState.VisibleMap);
var bonusesThatCanBeTaken = GetBonusesThatCanBeTaken(armiesForTakeOver);
var takenOverBonuses = new List <BotBonus>();
var armiesUsedForTakeOver = 0;
// calculate the moves for the bonuses that can be immediately taken
foreach (var bonus in sortedAccessibleBonuses)
{
if (bonusesThatCanBeTaken.Contains(bonus))
{
var expansionMoves = BotState.TakeTerritoriesTaskCalculator.CalculateTakeTerritoriesTask(armiesForTakeOver, bonus.GetNotOwnedTerritories(), BotTerritory.DeploymentType.Normal, "MovesCalculator.CalculateExpansionMoves");
MovesCommitter.CommittMoves(BotState, expansionMoves);
moves.MergeMoves(expansionMoves);
armiesForTakeOver -= expansionMoves.GetTotalDeployment();
bonusesThatCanBeTaken = GetBonusesThatCanBeTaken(armiesForTakeOver);
takenOverBonuses.Add(bonus);
armiesUsedForTakeOver += expansionMoves.GetTotalDeployment();
}
else
{
break;
}
}
var isExpandingAfterTakeOverSmart = IsExpandingAfterTakeOverSmart();
var opponentBorderPresent = BotState.VisibleMap.GetOpponentBorderingTerritories().Count > 0;
armiesForExpansion = Math.Max(0, armiesForExpansion - armiesUsedForTakeOver);
if (takenOverBonuses.Count == 0 || isExpandingAfterTakeOverSmart)
{
BotBonus bonusToExpand = null;
foreach (var bonus in sortedAccessibleBonuses)
{
if (!takenOverBonuses.Contains(bonus))
{
var condition1 = bonus.GetVisibleNeutralTerritories().Count > 0;
var condition2 = bonus.Amount > 0;
var condition3 = !opponentBorderPresent || bonus.ExpansionValueCategory > 0;
if (condition1 && condition2 && condition3)
{
bonusToExpand = bonus;
break;
}
}
}
if (bonusToExpand == null)
{
return;
}
var foundMoves = true;
var firstStep = true;
while (foundMoves)
{
BotState.BonusValueCalculator.CalculateBonusValues(BotState.WorkingMap, BotState.VisibleMap);
foundMoves = false;
if (firstStep == false)
{
if (bonusToExpand.ExpansionValueCategory == 0)
{
return;
}
if (opponentBorderPresent)
{
armiesForExpansion = 0;
}
if (bonusToExpand.GetOpponentNeighbors().Count > 0)
{
return;
}
}
Moves oneStepMoves = null;
if (!opponentBorderPresent)
{
oneStepMoves = BotState.TakeTerritoriesTaskCalculator.CalculateOneStepExpandBonusTask(armiesForExpansion, bonusToExpand, true, BotState.WorkingMap, BotTerritory.DeploymentType.Normal);
}
else
{
oneStepMoves = BotState.TakeTerritoriesTaskCalculator.CalculateOneStepExpandBonusTask(armiesForExpansion, bonusToExpand, false, BotState.WorkingMap, BotTerritory.DeploymentType.Normal);
}
if (oneStepMoves != null)
{
firstStep = false;
armiesForExpansion -= oneStepMoves.GetTotalDeployment();
MovesCommitter.CommittMoves(BotState, oneStepMoves);
moves.MergeMoves(oneStepMoves);
foundMoves = true;
}
}
}
}
private void CalculateXBonusMoves(Moves moves, BotTerritory.DeploymentType lowerBoundConservative, BotTerritory.DeploymentType upperBoundConservative)
{
var solutionFound = true;
var alreadyHandledBonuses = new List <BotBonus>();
while (solutionFound)
{
solutionFound = false;
BotState.BonusValueCalculator.CalculateBonusValues(BotState.WorkingMap, BotState.VisibleMap);
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
var bonusesToX = BotState.BonusValueCalculator.GetSortedBonusesAdjustedFactor(BotState.VisibleMap);
bonusesToX.RemoveAll(alreadyHandledBonuses);
foreach (var bonus in bonusesToX)
{
alreadyHandledBonuses.Add(bonus);
var stillAvailableDeployment = BotState.MyIncome.Total - moves.GetTotalDeployment();
var plan = BotState.BonusValueCalculator.GetPlanForBonus(bonus);
if (plan == BonusPlan.Break)
{
var visibleTerritories = bonus.GetVisibleOpponentTerritories();
var breakBonusMoves = BreakTerritoriesTask.CalculateBreakTerritoriesTask(BotState, visibleTerritories, stillAvailableDeployment, lowerBoundConservative, upperBoundConservative);
if (breakBonusMoves != null)
{
MovesCommitter.CommittMoves(BotState, breakBonusMoves);
moves.MergeMoves(breakBonusMoves);
solutionFound = true;
break;
}
}
else if (plan == BonusPlan.Defend)
{
var defendBonusMoves = DefendBonusTask.CalculateDefendBonusTask(BotState, bonus, stillAvailableDeployment, false, (BotTerritory.DeploymentType)Math.Max(1, (int)lowerBoundConservative), (BotTerritory.DeploymentType)Math.Max(1, (int)upperBoundConservative));
if (defendBonusMoves != null)
{
MovesCommitter.CommittMoves(BotState, defendBonusMoves);
moves.MergeMoves(defendBonusMoves);
solutionFound = true;
break;
}
}
else if (plan == BonusPlan.TakeOver)
{
var takeOverMoves = TakeBonusOverTask.CalculateTakeBonusOverTask(BotState, stillAvailableDeployment, bonus, lowerBoundConservative);
if (takeOverMoves != null)
{
MovesCommitter.CommittMoves(BotState, takeOverMoves);
moves.MergeMoves(takeOverMoves);
solutionFound = true;
break;
}
}
else if (plan == BonusPlan.PreventTakeOver && bonus.PreventTakeOverOpponent.HasValue)
{
var preventTakeOverMoves = PreventBonusTask.CalculatePreventBonusTask(BotState, bonus, bonus.PreventTakeOverOpponent.Value, stillAvailableDeployment, lowerBoundConservative);
MovesCommitter.CommittMoves(BotState, preventTakeOverMoves);
moves.MergeMoves(preventTakeOverMoves);
solutionFound = true;
break;
}
else
{
throw new Exception("Unexpected plan");
}
}
}
}
public void CalculateMoves()
{
CalculatedMoves = new Moves();
var movesSoFar = new Moves();
PlayCardsTask.PlayCards(BotState, movesSoFar);
AILog.Log("Starting armies: " + BotState.MyIncome.Total);
CalculateXBonusMoves(movesSoFar, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Normal);
AILog.Log("Armies used after calculateXBonusMoves type 1: " + movesSoFar.GetTotalDeployment());
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
CalculateXBonusMoves(movesSoFar, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Conservative);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
CalculateXBonusMoves(movesSoFar, BotTerritory.DeploymentType.Conservative, BotTerritory.DeploymentType.Conservative);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateXBonusMoves type 2: " + movesSoFar.GetTotalDeployment());
CalculateSnipeBonusMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateSnipeBonusMoves: " + movesSoFar.GetTotalDeployment());
CalculateXBonusMoves(movesSoFar, 0, BotTerritory.DeploymentType.Normal);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
BotState.ExpansionTask.CalculateExpansionMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateExpansionMoves: " + movesSoFar.GetTotalDeployment());
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateNoPlanBreakDefendMoves(movesSoFar, false, false, true, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Normal);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateNoPlanBreakDefendMoves1: " + movesSoFar.GetTotalDeployment());
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateNoPlanBreakDefendMoves(movesSoFar, false, true, false, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Normal);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateNoPlanBreakDefendMoves: " + movesSoFar.GetTotalDeployment());
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateNoPlanBreakDefendMoves(movesSoFar, false, false, true, BotTerritory.DeploymentType.Conservative, BotTerritory.DeploymentType.Conservative);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateNoPlanBreakDefendMoves(movesSoFar, false, true, true, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Conservative);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateFlankBonusMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateFlankBonusMoves: " + movesSoFar.GetTotalDeployment());
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateNoPlanBreakDefendMoves(movesSoFar, true, false, false, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Normal);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.WorkingMap);
CalculateNoPlanBreakDefendMoves(movesSoFar, true, false, false, BotTerritory.DeploymentType.Normal, BotTerritory.DeploymentType.Conservative);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.VisibleMap);
CalculateNoPlanAttackTerritoriesMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after calculateNoPlanAttackTerritoriesMoves2: " + movesSoFar.GetTotalDeployment());
BotState.TerritoryValueCalculator.CalculateTerritoryValues(BotState.VisibleMap, BotState.VisibleMap);
CalculateMoveIdleArmiesMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
CalculateJoinInAttacksMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
var supportTransferMoves = TransferMovesChooser.CalculateJoinStackMoves(BotState);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
MovesCommitter.CommittMoves(BotState, supportTransferMoves);
movesSoFar.MergeMoves(supportTransferMoves);
CalculateNoPlanCleanupMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
CalculateMoveIdleArmiesMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
CalculateJoinInAttacksMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
CalculateNoPlanTryoutAttackMoves(movesSoFar);
BotState.DeleteBadMovesTask.CalculateDeleteBadMovesTask(movesSoFar);
AILog.Log("Armies used after all moves done: " + movesSoFar.GetTotalDeployment());
BotState.MapUpdater.UpdateMap(BotState.WorkingMap);
DistanceCalculator.CalculateDistanceToBorder(BotState, BotState.VisibleMap, BotState.WorkingMap);
BotState.ExpansionMapUpdater.UpdateExpansionMap();
DistanceCalculator.CalculateDistanceToUnimportantTerritories(BotState.ExpansionMap, BotState.VisibleMap);
DistanceCalculator.CalculateDistanceToImportantExpansionTerritories(BotState.ExpansionMap, BotState.VisibleMap);
DistanceCalculator.CalculateDistanceToOpponentBorderCare3(BotState.ExpansionMap, BotState.VisibleMap);
foreach (BotBonus emBonus in BotState.ExpansionMap.Bonuses.Values)
{
emBonus.ExpansionValue = BotState.VisibleMap.Bonuses[emBonus.ID].ExpansionValue;
}
DistanceCalculator.CalculateDistanceToHighlyImportantExpansionTerritories(BotState.ExpansionMap, BotState.VisibleMap);
DistanceCalculator.CalculateDistanceToOpponentBorderCare4(BotState.ExpansionMap, BotState.VisibleMap);
var transferMoves = TransferMovesChooser.CalculateTransferMoves2(BotState);
MovesCommitter.CommittMoves(BotState, transferMoves);
movesSoFar.MergeMoves(transferMoves);
CalculateDelayMoves(movesSoFar);
MovesCleaner.CleanupMoves(BotState, movesSoFar);
movesSoFar = BotState.MovesScheduler2.ScheduleMoves(movesSoFar);
CalculatedMoves = movesSoFar;
}
private void CalculateNoPlanBreakDefendMoves(Moves moves, bool lowImportance, bool mediumImportance, bool highImportance, BotTerritory.DeploymentType lowerConservative, BotTerritory.DeploymentType upperConservative)
{
List <BotTerritory> territoriesToDefend = new List <BotTerritory>();
foreach (var territory in BotState.VisibleMap.GetOwnedTerritories())
{
var importance = territory.DefenceTerritoryValue;
var lowImportant = importance < TerritoryValueCalculator.LOWEST_MEDIUM_PRIORITY_VALUE;
var mediumImportant = importance < TerritoryValueCalculator.LOWEST_HIGH_PRIORITY_VALUE && importance >= TerritoryValueCalculator.LOWEST_MEDIUM_PRIORITY_VALUE;
var highImportant = importance >= TerritoryValueCalculator.LOWEST_HIGH_PRIORITY_VALUE;
if ((lowImportance && lowImportant) || (mediumImportance && mediumImportant) || (highImportance && highImportant))
{
territoriesToDefend.Add(territory);
}
}
var possibleTerritoriesToAttack = new List <BotTerritory>();
foreach (var opponentTerritory in BotState.VisibleMap.Territories.Values.Where(o => o.IsVisible &&
BotState.IsOpponent(o.OwnerPlayerID)))
{
var wmOpponentTerritory = BotState.WorkingMap.Territories[opponentTerritory.ID];
if (BotState.IsOpponent(wmOpponentTerritory.OwnerPlayerID))
{
possibleTerritoriesToAttack.Add(opponentTerritory);
}
}
var territoriesToAttack = new List <BotTerritory>();
foreach (var territory_1 in possibleTerritoriesToAttack)
{
var importance = territory_1.AttackTerritoryValue;
var lowImportant = importance < TerritoryValueCalculator.LOWEST_MEDIUM_PRIORITY_VALUE;
var mediumImportant = importance < TerritoryValueCalculator.LOWEST_HIGH_PRIORITY_VALUE && importance >= TerritoryValueCalculator.LOWEST_MEDIUM_PRIORITY_VALUE;
var highImportant = importance >= TerritoryValueCalculator.LOWEST_HIGH_PRIORITY_VALUE;
if ((lowImportance && lowImportant) || (mediumImportance && mediumImportant) || (highImportance && highImportant))
{
territoriesToAttack.Add(territory_1);
}
}
var combinedTerritories = new List <BotTerritory>();
combinedTerritories.AddRange(territoriesToDefend);
combinedTerritories.AddRange(territoriesToAttack);
var sortedTerritories = BotState.TerritoryValueCalculator.SortTerritoriesAttackDefense(combinedTerritories);
foreach (var territory_2 in sortedTerritories)
{
var maxDeployment = BotState.MyIncome.Total - moves.GetTotalDeployment();
Moves defendBreakMoves = null;
if (territory_2.OwnerPlayerID == BotState.Me.ID)
{
defendBreakMoves = BotState.DefendTerritoryTask.CalculateDefendTerritoryTask(territory_2, maxDeployment, true, lowerConservative, upperConservative);
}
else
{
defendBreakMoves = BotState.BreakTerritoryTask.CalculateBreakTerritoryTask(territory_2, maxDeployment, lowerConservative, upperConservative, "CalculateNoPlanBreakDefendMoves");
}
if (defendBreakMoves != null)
{
MovesCommitter.CommittMoves(BotState, defendBreakMoves);
moves.MergeMoves(defendBreakMoves);
}
}
}
