public static Moves CalculateBreakTerritoryTask(BotMain state, BotTerritory opponentTerritory, int maxDeployment, BotTerritory.DeploymentType conservativeLevel)
{
var outvar = new Moves();
var opponentArmies = opponentTerritory.GetArmiesAfterDeploymentAndIncomingAttacks(conservativeLevel);
var neededAttackArmies = opponentTerritory.getNeededBreakArmies(opponentArmies.DefensePower);
var ownedNeighbors = opponentTerritory.GetOwnedNeighbors();
var presortedOwnedNeighbors = state.TerritoryValueCalculator.SortDefenseValue(ownedNeighbors);
var sortedOwnedNeighbors = BotMap.GetOrderedListOfTerritoriesByIdleArmies(presortedOwnedNeighbors);
var territoryToUse = sortedOwnedNeighbors[0];
var idleArmies = territoryToUse.GetIdleArmies();
var neededDeployment = Math.Max(0, neededAttackArmies - idleArmies.AttackPower);
if (neededDeployment > maxDeployment)
{
return(null);
}
if (neededDeployment > 0)
{
outvar.AddOrder(new BotOrderDeploy(state.Me.ID, territoryToUse, neededDeployment));
}
Armies attackArmies = new Armies(neededAttackArmies);
//var atm = new BotOrderAttackTransfer(state.Me.ID, territoryToUse, opponentTerritory, idleArmies.Add(new Armies(neededDeployment)), "OneHitBreakTerritoryTask");
var atm = new BotOrderAttackTransfer(state.Me.ID, territoryToUse, opponentTerritory, attackArmies, "OneHitBreakTerritoryTask");
outvar.AddOrder(atm);
return(outvar);
}
private Moves CalculateAttackNeutralMoves(BotTerritory neutralTerritory, int maxDeployment)
{
Moves outvar = null;
var neededAttackArmies = neutralTerritory.getNeededBreakArmies(neutralTerritory.Armies.DefensePower);
var ownedNeighbors = neutralTerritory.GetOwnedNeighbors();
var bestNeighbor = ownedNeighbors[0];
foreach (var ownedNeighbor in ownedNeighbors)
{
if (ownedNeighbor.GetIdleArmies().AttackPower > bestNeighbor.GetIdleArmies().ArmiesOrZero)
{
bestNeighbor = ownedNeighbor;
}
}
var neededDeployment = Math.Max(0, neededAttackArmies - bestNeighbor.GetIdleArmies().ArmiesOrZero);
if (neededDeployment <= maxDeployment)
{
outvar = new Moves();
if (neededDeployment > 0)
{
outvar.AddOrder(new BotOrderDeploy(BotState.Me.ID, bestNeighbor, neededDeployment));
}
var atm = new BotOrderAttackTransfer(BotState.Me.ID, bestNeighbor, neutralTerritory, new Armies(neededAttackArmies), "PreventOpponentExpandBonusTask");
// TODO bad?
if (bestNeighbor.GetOpponentNeighbors().Count == 0)
{
atm.Message = AttackMessage.Snipe;
}
outvar.AddOrder(atm);
}
return(outvar);
}
private int GetOpponentNeededDeployment(BotTerritory opponentTerritory)
{
var neededDeployment = 0;
if (opponentTerritory.AttackTerritoryValue < TerritoryValueCalculator.LOWEST_MEDIUM_PRIORITY_VALUE)
{
return(0);
}
var ourAttackingArmies = 0;
foreach (var ownedNeighbor in opponentTerritory.GetOwnedNeighbors())
{
ourAttackingArmies += ownedNeighbor.Armies.AttackPower - BotState.MustStandGuardOneOrZero;
}
if (opponentTerritory.AttackTerritoryValue > TerritoryValueCalculator.LOWEST_HIGH_PRIORITY_VALUE)
{
ourAttackingArmies += 5;
}
// TODO adapt to no luck
neededDeployment = Math.Max(0, (int)Math.Round(ourAttackingArmies * BotState.Settings.OffenseKillRate));
return(neededDeployment);
}
private List <BotTerritory> GetNeighborsWithIdleArmies(BotTerritory territoryToDefend)
{
var unsortedNeighbors = new List <BotTerritory>();
foreach (var ownedNeighbor in territoryToDefend.GetOwnedNeighbors())
{
if (ownedNeighbor.GetOpponentNeighbors().Count == 0 && ownedNeighbor.GetIdleArmies().NumArmies > 0)
{
unsortedNeighbors.Add(ownedNeighbor);
}
}
// Sort according to the amount of idle armies
var outvar = new List <BotTerritory>();
while (unsortedNeighbors.Count != 0)
{
var biggestIdleArmyTerritory = unsortedNeighbors[0];
foreach (var territory in unsortedNeighbors)
{
if (territory.GetIdleArmies().AttackPower > biggestIdleArmyTerritory.GetIdleArmies().AttackPower)
{
biggestIdleArmyTerritory = territory;
}
}
outvar.Add(biggestIdleArmyTerritory);
unsortedNeighbors.Remove(biggestIdleArmyTerritory);
}
return(outvar);
}
/// <remarks>
/// Calculates the highest defense territory value of a bordering territory that the opponent might break from his slippery territory. If there is no such territory then returns -1.
/// </remarks>
/// <param name="opponentTerritory"></param>
/// <returns></returns>
private int GetSlipperyOpponentTerritoryNumber(BotTerritory slipperyOpponentTerritory)
{
List <BotTerritory> territoriesOpponentMightBreak = new List <BotTerritory>();
var opponentIncome = BotState.GetGuessedOpponentIncome(slipperyOpponentTerritory.OwnerPlayerID, BotState.VisibleMap);
var opponentAttackingArmies = opponentIncome + slipperyOpponentTerritory.Armies.AttackPower - BotState.MustStandGuardOneOrZero;
var neededArmiesForDefense = (int)Math.Round(opponentAttackingArmies * BotState.Settings.OffensiveKillRate);
foreach (var ownedNeighbor in slipperyOpponentTerritory.GetOwnedNeighbors())
{
if (ownedNeighbor.GetArmiesAfterDeploymentAndIncomingMoves().DefensePower < neededArmiesForDefense)
{
territoriesOpponentMightBreak.Add(ownedNeighbor);
}
}
var sortedOwnedNeighbors = BotState.TerritoryValueCalculator.SortDefenseValue(territoriesOpponentMightBreak);
if (sortedOwnedNeighbors.Count > 0)
{
return(sortedOwnedNeighbors[0].DefenceTerritoryValue);
}
else
{
return(-1);
}
}
private BotTerritory GetBestNeighborTerritory(BotTerritory missingTerritory, Moves madeExpansionDecisions, List <BotTerritory> territoriesToTake)
{
var ownedNeighbors = missingTerritory.GetOwnedNeighbors();
var presortedOwnedNeighbors = BotState.TerritoryValueCalculator.SortDefenseValueFullReturn
(ownedNeighbors);
var maximumIdleArmies = 0;
// First calculate the maximum amount of armies of an owned neighbor.
foreach (var ownedNeighbbor in presortedOwnedNeighbors)
{
var idleArmies = GetOverflowIdleArmies(ownedNeighbbor, madeExpansionDecisions);
if (idleArmies.NumArmies > maximumIdleArmies)
{
maximumIdleArmies = idleArmies.NumArmies;
}
}
// Second calculate the owned neighbor having the maximum amount of idle armies while having a minimum amount of sill missing neighbors.
var minimumMissingNeighbors = 1000;
BotTerritory outvar = null;
foreach (var ownedNeighbor in presortedOwnedNeighbors)
{
var missingNeighborTerritories = GetStillMissingNeighborTerritories(ownedNeighbor, madeExpansionDecisions, territoriesToTake).Count;
if (GetOverflowIdleArmies(ownedNeighbor, madeExpansionDecisions).NumArmies == maximumIdleArmies && missingNeighborTerritories < minimumMissingNeighbors)
{
outvar = ownedNeighbor;
minimumMissingNeighbors = missingNeighborTerritories;
}
}
if (outvar == null)
{
outvar = presortedOwnedNeighbors[0];
}
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);
}
}
private static int GetAmountOfTerritoriesUnderThreat(BotTerritory threateningTerritory, BotBonus bonus)
{
var outvar = 0;
foreach (var neighbor in threateningTerritory.GetOwnedNeighbors())
{
if (neighbor.Details.PartOfBonuses.Contains(bonus.ID))
{
outvar++;
}
}
return(outvar);
}
