// 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;
}
}
}
}
}
/// <summary>Calculates the necessary moves to take the specified territories to take.</summary>
/// <param name="maxDeployment">the maximum allowed deployment. If no deployment constraint then put -1.
/// </param>
/// <param name="territoriesToTake">the territories that should be taken this turn.</param>
/// <returns>the necessary moves to take the territories or null if no solution was found.
/// </returns>
public Moves CalculateTakeTerritoriesTask(int maxDeployment, List <BotTerritory> territoriesToTake, BotTerritory.DeploymentType conservativeLevel, string attackSource)
{
var outvar = new Moves();
if (maxDeployment == -1)
{
maxDeployment = int.MaxValue;
}
var stillAvailableDeployment = maxDeployment;
foreach (var missingTerritory in territoriesToTake)
{
var bestNeighborTerritory = GetBestNeighborTerritory(missingTerritory, outvar, territoriesToTake);
var missingTerritoryArmies = missingTerritory.GetArmiesAfterDeploymentAndIncomingAttacks(conservativeLevel);
var neededAttackArmies = missingTerritory.getNeededBreakArmies(missingTerritory.Armies.DefensePower);
//var neededAttackArmies = (int)Math.Round(missingTerritoryArmies.DefensePower / BotState.Settings.OffensiveKillRate);
var missingArmies = GetMissingArmies(bestNeighborTerritory, missingTerritory, outvar, conservativeLevel);
if (missingArmies > stillAvailableDeployment)
{
return(null);
}
if (missingArmies > 0)
{
var pam = new BotOrderDeploy(BotState.Me.ID, bestNeighborTerritory, missingArmies);
outvar.AddOrder(pam);
stillAvailableDeployment -= missingArmies;
}
outvar.AddOrder(new BotOrderAttackTransfer(BotState.Me.ID, bestNeighborTerritory, missingTerritory, new Armies(neededAttackArmies), attackSource));
}
return(outvar);
}
public Moves CalculateOneStepExpandBonusTask(int maxDeployment, BotBonus bonus, bool acceptStackOnly, BotMap workingMap, BotTerritory.DeploymentType conservativeLevel)
{
var outvar = new Moves();
if (maxDeployment == -1)
{
maxDeployment = 1000;
}
var visibleNeutralTerritories = bonus.GetVisibleNeutralTerritories();
var territoriesToRemove = new List <BotTerritory>();
foreach (var territory in visibleNeutralTerritories)
{
if (workingMap.Territories[territory.ID].OwnerPlayerID == BotState.Me.ID)
{
territoriesToRemove.Add(territory);
}
}
visibleNeutralTerritories.RemoveAll(territoriesToRemove);
if (visibleNeutralTerritories.Count == 0)
{
return(null);
}
var sortedNeutralTerritories = BotState.TerritoryValueCalculator.SortExpansionValue(visibleNeutralTerritories);
var territoryToTake = new List <BotTerritory>();
territoryToTake.Add(sortedNeutralTerritories[0]);
var takeTerritoryMoves = CalculateTakeTerritoriesTask(-1, territoryToTake, conservativeLevel, "CalculateOneStepExpandBonusTask");
if (takeTerritoryMoves.GetTotalDeployment() > maxDeployment)
{
if (acceptStackOnly)
{
if (maxDeployment > 0)
{
var territoryToDeploy = takeTerritoryMoves.Orders.OfType <BotOrderDeploy>().First().Territory;
var pam = new BotOrderDeploy(BotState.Me.ID, territoryToDeploy, maxDeployment);
outvar.AddOrder(pam);
return(outvar);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
else
{
outvar = takeTerritoryMoves;
return(outvar);
}
}
/// <param name="opponentTerritory"></param>
/// <param name="maxDeployment"></param>
/// <returns></returns>
public static Moves CalculateAttackTerritoryTask(BotMain state, BotTerritory opponentTerritory, int maxDeployment)
{
var outvar = new Moves();
var ownedNeighbors = opponentTerritory.GetOwnedNeighbors();
var presortedOwnedNeighbors = state.TerritoryValueCalculator.SortDefenseValue(ownedNeighbors
);
var sortedOwnedNeighbors = BotMap.GetOrderedListOfTerritoriesByIdleArmies(
presortedOwnedNeighbors);
// Calculate the attacks
for (var i = 0; i < sortedOwnedNeighbors.Count; i++)
{
var attackingTerritory = sortedOwnedNeighbors[i];
if (i == 0 && maxDeployment > 0)
{
var pam = new BotOrderDeploy(state.Me.ID, attackingTerritory, maxDeployment);
outvar.AddOrder(pam);
if (attackingTerritory.GetIdleArmies().AttackPower + maxDeployment > 1)
{
var atm = new BotOrderAttackTransfer(state.Me.ID, attackingTerritory, opponentTerritory, attackingTerritory.GetIdleArmies().Add(new Armies(maxDeployment)), "AttackTerritoriesTask1");
outvar.AddOrder(atm);
}
}
else
{
if (attackingTerritory.GetIdleArmies().AttackPower > 1)
{
var atm = new BotOrderAttackTransfer(state.Me.ID, attackingTerritory, opponentTerritory, attackingTerritory.GetIdleArmies(), "AttackTerritoriesTask2");
outvar.AddOrder(atm);
}
}
}
// Check if we are killing more or equal armies than the opponent
// double currentOpponentArmies = opponentTerritory.ArmiesAfterDeployment;
var currentOpponentArmies = opponentTerritory.GetArmiesAfterDeploymentAndIncomingAttacks(BotTerritory.DeploymentType.Normal).DefensePower;
double opponentKills = 0;
double ownKills = 0;
foreach (var atm_1 in outvar.Orders.OfType <BotOrderAttackTransfer>())
{
int ourKills = opponentTerritory.getOwnKills(atm_1.Armies.AttackPower, currentOpponentArmies);
//var ourKills = Math.Min(currentOpponentArmies, atm_1.Armies.AttackPower * state.Settings.OffensiveKillRate);
var opponentKillsAttack = Math.Min(atm_1.Armies.AttackPower, currentOpponentArmies * state.Settings.DefenseKillRate);
ownKills += ourKills;
opponentKills += opponentKillsAttack;
currentOpponentArmies = Math.Max(0, currentOpponentArmies - ourKills);
}
if (ownKills >= opponentKills && outvar.Orders.OfType <BotOrderAttackTransfer>().Any())
{
return(outvar);
}
else
{
return(null);
}
}
private Moves CalculateBreakTerritoryMoves(BotTerritory opponentTerritory, int maxDeployment, int opponentDeployment, string source)
{
var outvar = new Moves();
var opponentArmies = opponentTerritory.Armies.DefensePower;
opponentArmies += opponentDeployment;
var neededAttackArmies = opponentTerritory.getNeededBreakArmies(opponentArmies);
//var neededAttackArmies = SharedUtility.Round(opponentArmies / BotState.Settings.OffensiveKillRate);
var ownedNeighbors = opponentTerritory.GetOwnedNeighbors();
var presortedOwnedNeighbors = BotState.TerritoryValueCalculator.SortDefenseValue(ownedNeighbors);
var sortedOwnedNeighbors = BotMap.GetOrderedListOfTerritoriesByIdleArmies(
presortedOwnedNeighbors);
// First deploy and then pull in more territories if necessary.
// First deploy and then pull in more territories if necessary.
var attackedWithSoFar = 0;
for (var i = 0; i < sortedOwnedNeighbors.Count; i++)
{
if (i == 0)
{
var neededDeployment = Math.Max(0, neededAttackArmies - sortedOwnedNeighbors[0].GetIdleArmies().NumArmies);
var totalDeployment = Math.Min(neededDeployment, maxDeployment);
if (totalDeployment > 0)
{
var pam = new BotOrderDeploy(BotState.Me.ID, sortedOwnedNeighbors[0], totalDeployment);
outvar.AddOrder(pam);
}
var attackingArmies = Math.Min(neededAttackArmies, sortedOwnedNeighbors[0].GetIdleArmies().NumArmies + totalDeployment);
outvar.AddOrder(new BotOrderAttackTransfer(BotState.Me.ID, sortedOwnedNeighbors[0], opponentTerritory, new Armies(attackingArmies), source));
attackedWithSoFar += attackingArmies;
}
else
{
// i != 0
var stillNeededArmies = neededAttackArmies - attackedWithSoFar;
if (stillNeededArmies > 0 && sortedOwnedNeighbors[i].GetIdleArmies().NumArmies > 1)
{
var newAttackingArmies = Math.Min(stillNeededArmies, sortedOwnedNeighbors[i].GetIdleArmies().NumArmies);
outvar.AddOrder(new BotOrderAttackTransfer(BotState.Me.ID, sortedOwnedNeighbors[i], opponentTerritory, new Armies(newAttackingArmies), "BreakTerritoryTask2"));
attackedWithSoFar += newAttackingArmies;
}
}
}
if (attackedWithSoFar >= neededAttackArmies)
{
return(outvar);
}
else
{
return(null);
}
}
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);
}
}
}
