public static Moves CalculateBonusRunMoves(BotBonus opponentBonus, int maxDeployment
, BotMap visibleMap, BotMap workingMap)
{
var outvar = new Moves();
return(outvar);
}
public static void PrintTerritories(BotMap map, BotMain BotState)
{
List <BotTerritory> territories = map.Territories.Values.ToList();
//List<BotTerritory> opponentTerritories = territories.Where(o => o.OwnerPlayerID == BotState.Opponents.First().ID).ToList();
AILog.Log("Debug", "Territories:");
foreach (BotTerritory territory in territories)
{
string player = "fog";
if (territory.OwnerPlayerID == TerritoryStanding.NeutralPlayerID)
{
player = "neutral";
}
else if (territory.OwnerPlayerID == BotState.Me.ID)
{
player = "Me";
}
else if (territory.OwnerPlayerID == BotState.Opponents.First().ID)
{
player = "opponent";
}
AILog.Log("Debug", territory.Details.Name + ": (" + player + " | " + territory.IsOwnershipHeuristic + ") --> " + territory.Armies.AttackPower);
}
}
private void CalculatePreventValue(BotBonus bonus, BotMap mapToWriteIn)
{
var ownedTerritories = bonus.GetOwnedTerritories();
var ownArmies = 0;
foreach (var ownedTerritory in ownedTerritories)
{
ownArmies += ownedTerritory.Armies.DefensePower;
}
GamePlayer maxOpponent = null;
int maxPreventValue = int.MinValue;
foreach (var opponent in BotState.Opponents)
{
var val = CalculatePreventValue(bonus, ownedTerritories, opponent, ownArmies);
if (val > maxPreventValue)
{
maxPreventValue = val;
maxOpponent = opponent;
}
}
if (maxOpponent != null)
{
var b = mapToWriteIn.Bonuses[bonus.ID];
b.PreventTakeOverValue = maxPreventValue;
b.PreventTakeOverOpponent = maxOpponent.ID;
}
}
/// <param name="state"></param>
/// <param name="toTerritories"></param>
/// <param name="blockedTerritories">blocked territories. Insert null here if not needed.</param>
/// <returns></returns>
public static Dictionary <BotTerritory, int> CalculateDistances(BotMap mapToUse, List <BotTerritory> toTerritories, List <BotTerritory> blockedTerritories)
{
var outvar = new Dictionary <BotTerritory, int>();
foreach (var territory in mapToUse.Territories.Values)
{
if (toTerritories.Contains(territory))
{
outvar.Add(territory, 0);
}
else
{
outvar.Add(territory, int.MaxValue);
}
}
// Now do the real stuff
var hasSomethingChanged = true;
while (hasSomethingChanged)
{
hasSomethingChanged = false;
foreach (var territory_1 in mapToUse.Territories.Values)
{
var closestNeighbor = GetClosestNeighborToTargetTerritories(territory_1, outvar, blockedTerritories);
if (outvar[closestNeighbor] < outvar[territory_1] && outvar[territory_1] != outvar[closestNeighbor] + 1)
{
outvar[territory_1] = outvar[closestNeighbor] + 1;
hasSomethingChanged = true;
}
}
}
return(outvar);
}
/// <param name="mapToUse">visible map</param>
/// <returns>Only returns the Bonuses with an adjusted factor of > 0.</returns>
public List <BotBonus> GetSortedBonusesAdjustedFactor(BotMap mapToUse)
{
var outvar = new List <BotBonus>();
var copy = new List <BotBonus>();
foreach (BotBonus bonus in mapToUse.Bonuses.Values)
{
if (GetAdjustedFactor(bonus) > 0)
{
copy.Add(bonus);
}
}
while (!copy.IsEmpty())
{
var bestBonus = copy[0];
foreach (BotBonus bonus_1 in copy)
{
if (GetAdjustedFactor(bonus_1) > GetAdjustedFactor(bestBonus))
{
bestBonus = bonus_1;
}
}
copy.Remove(bestBonus);
outvar.Add(bestBonus);
}
return(outvar);
}
public List <BotBonus> SortAccessibleBonuses(BotMap mapToUse)
{
var copy = new List <BotBonus>();
copy.AddRange(mapToUse.Bonuses.Values);
List <BotBonus> outvar = new List <BotBonus>();
while (copy.Count != 0)
{
var highestPrioBonus = copy[0];
foreach (BotBonus bonus in copy)
{
if (bonus.GetExpansionValue() > highestPrioBonus.GetExpansionValue())
{
highestPrioBonus = bonus;
}
}
copy.Remove(highestPrioBonus);
outvar.Add(highestPrioBonus);
}
// Remove the non accessible Bonuses
List <BotBonus> nonAccessibleBonuses = new List <BotBonus>();
foreach (BotBonus bonus_1 in mapToUse.Bonuses.Values)
{
if (bonus_1.GetOwnedTerritoriesAndNeighbors().Count == 0)
{
nonAccessibleBonuses.Add(bonus_1);
}
}
//outvar.RemoveAll(nonAccessibleBonuses);
outvar.RemoveAll(i => nonAccessibleBonuses.Contains(i));
return(outvar);
}
/// <summary>Classifies the Bonus according to the intel from the temporaryMap.
/// </summary>
/// <remarks>
/// Classifies the Bonus according to the intel from the temporaryMap. However the results of the classification aren't written to the temporary map but to the visible map.
/// </remarks>
/// <param name="temporaryMap"></param>
public void ClassifyBonuses(BotMap temporaryMap, BotMap mapToWriteIn)
{
foreach (var bonus in temporaryMap.Bonuses.Values)
{
bonus.SetMyExpansionValueHeuristic();
// Categorize the expansion values. Possible values are 0 = rubbish and 1 = good
var toMuchNeutrals = false;
var neutralArmies = bonus.NeutralArmies.DefensePower;
if (neutralArmies > 28)
{
toMuchNeutrals = true;
}
else if (neutralArmies >= 4 * (bonus.Amount + 2))
{
toMuchNeutrals = true;
}
if (bonus.IsOwnedByMyself() || bonus.Amount == 0 || bonus.ContainsOpponentPresence() || bonus.ContainsTeammatePresence() || toMuchNeutrals)
{
mapToWriteIn.Bonuses[bonus.ID].ExpansionValueCategory = 0;
}
else
{
mapToWriteIn.Bonuses[bonus.ID].ExpansionValueCategory = 1;
}
}
}
private void RemoveFogAccordingToPickingState()
{
if (BotState.DistributionStanding == null)
{
return; //auto-dist game, skip
}
BotMap pickingStageMap = BotMap.FromStanding(BotState, BotState.DistributionStanding);
BotMap visibleMap = BotState.VisibleMap;
// territories in distribution have first 0 neutrals in the lvMap
List <TerritoryIDType> pickableTerritories = BotState.DistributionStanding.Territories.Values.
Where(o => o.OwnerPlayerID == TerritoryStanding.AvailableForDistribution).
Select(o => o.ID).ToList();
foreach (BotTerritory vmTerritory in visibleMap.Territories.Values.Where(territory => territory.OwnerPlayerID == TerritoryStanding.FogPlayerID))
{
BotTerritory lvmTerritory = pickingStageMap.Territories[vmTerritory.ID];
vmTerritory.OwnerPlayerID = TerritoryStanding.NeutralPlayerID;
if (pickableTerritories.Contains(vmTerritory.ID))
{
vmTerritory.Armies = new Armies(BotState.Settings.InitialNeutralsInDistribution);
}
else
{
vmTerritory.Armies = new Armies(lvmTerritory.Armies.NumArmies);
}
}
}
/// <summary>Calculates the expansion territory value for a territory.</summary>
/// <remarks>Calculates the expansion territory value for a territory.</remarks>
/// <param name="territory">the territory which can be part of an arbitrary map</param>
/// <param name="mapToWriteIn">the map in which the calculated territory value is to be inserted
/// </param>
private void CalculateExpansionTerritoryValue(BotTerritory territory, BotMap mapToWriteIn)
{
var currentValue = 0;
var neighborsWithinBonus = territory.GetNeighborsWithinSameBonus();
// Add 1000 for each unknown neighbor within the same Bonus
foreach (var neighbor in neighborsWithinBonus)
{
if (neighbor.OwnerPlayerID == TerritoryStanding.NeutralPlayerID && neighbor.GetOwnedNeighbors().Count == 0)
{
currentValue += 1000;
}
}
// Add 100 for each neighbor within the same Bonus
foreach (var neighbor_1 in neighborsWithinBonus)
{
if (neighbor_1.OwnerPlayerID == TerritoryStanding.NeutralPlayerID)
{
currentValue += 100;
}
}
// Add 10 for each opponent neighbor
currentValue += 10 * territory.GetOpponentNeighbors().Count;
// Add 1 for each neutral neighbor in another Bonus
foreach (var neighbor_2 in territory.Neighbors)
{
if (neighbor_2.OwnerPlayerID == TerritoryStanding.NeutralPlayerID && !neighborsWithinBonus.Contains(neighbor_2))
{
currentValue += 1;
}
}
mapToWriteIn.Territories[territory.ID].ExpansionTerritoryValue = currentValue;
}
/// <summary>Calculates the flanking value</summary>
/// <param name="territory">the territory neutral territory (from the mapToUse) I guess</param>
/// <param name="mapToWriteIn">visible map</param>
/// <param name="mapToUse">map with already made move decisions</param>
private void CalculateFlankingValue(BotTerritory territory, BotMap mapToWriteIn, BotMap mapToUse)
{
var neighbors = territory.Neighbors;
var bonusNeighborTerritories = new List <BotTerritory>();
foreach (var neighbor in neighbors)
{
if (!neighbor.IsVisible && neighbor.Bonuses.Any(b => b.IsOwnedByAnyOpponent() && !IsBonusAlreadyFlanked(b)))
{
bonusNeighborTerritories.Add(neighbor);
}
}
// TODO develop more complex algorithm also with already made decisions
var flankingValue = 0;
foreach (var bonusNeighborTerritory in bonusNeighborTerritories)
{
flankingValue += bonusNeighborTerritory.Bonuses.Sum(b => b.Amount);
}
var territoryToWriteIn = mapToWriteIn.Territories[territory.ID];
territoryToWriteIn.FlankingTerritoryValue = flankingValue;
}
public List <TerritoryIDType> GetPicks()
{
if (BotState.Map.IsScenarioDistribution(BotState.Settings.DistributionModeID))
{
var us = BotState.Map.GetTerritoriesForScenario(BotState.Settings.DistributionModeID, BotState.Me.ScenarioID);
us.RandomizeOrder();
return(us);
}
int maxPicks = BotState.Settings.LimitDistributionTerritories == 0 ? BotState.Map.Territories.Count : (BotState.Settings.LimitDistributionTerritories * BotState.Players.Count(o => o.Value.State == GamePlayerState.Playing));
var pickableTerritories = BotState.DistributionStanding.Territories.Values.Where(o => o.OwnerPlayerID == TerritoryStanding.AvailableForDistribution).Select(o => o.ID).ToList();
var weights = pickableTerritories.ToDictionary(o => o, terrID =>
{
var map = BotMap.FromStanding(BotState, BotState.DistributionStanding);
map.Territories[terrID].OwnerPlayerID = BotState.Me.ID;
BotBonus bonus = map.Territories[terrID].Bonuses[0];
bonus.SetMyExpansionValueHeuristic();
double r = bonus.ExpansionValue;
return(r);
});
var ret = weights.OrderByDescending(o => o.Value).Take(maxPicks).Select(o => o.Key).Distinct().ToList();
return(ret);
}
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);
}
public static void PrintTerritoryValues(BotMap map, BotMain BotState)
{
//AILog.Log("Debug", "Territory attack values:");
//foreach (BotTerritory territory in map.Territories.Values)
//{
// if (territory.IsVisible && BotState.IsOpponent(territory.OwnerPlayerID))
// {
// AILog.Log("Debug", territory.Details.Name + ": " + territory.AttackTerritoryValue);
// }
//}
//AILog.Log("Debug", "Territory expansion values:");
//foreach (BotTerritory territory in map.Territories.Values)
//{
// if (territory.IsVisible && territory.OwnerPlayerID == TerritoryStanding.NeutralPlayerID)
// {
// AILog.Log("Debug", territory.Details.Name + ": " + territory.ExpansionTerritoryValue);
// }
//}
//AILog.Log("Debug", "Territory defend values:");
//foreach (BotTerritory territory in map.Territories.Values)
//{
// if (territory.OwnerPlayerID == BotState.Me.ID && territory.GetOpponentNeighbors().Count > 0)
// {
// AILog.Log("Debug", territory.Details.Name + ": " + territory.DefenceTerritoryValue);
// }
//}
}
private void CalculateAttackValue(BotBonus bonus, BotMap mapToWriteIn)
{
var armiesReward = bonus.Amount;
var ownedNeighbors = bonus.GetOwnedNeighborTerritories();
var amountOwnedNeighbors = ownedNeighbors.Count;
var territoriesUnderAttack = bonus.GetVisibleOpponentTerritories();
var amountTerritoriesUnderAttack = territoriesUnderAttack.Count;
var opponentArmies = 0;
foreach (var opponentTerritory in territoriesUnderAttack)
{
opponentArmies += opponentTerritory.Armies.DefensePower;
}
var ownArmies = 0;
foreach (var ownedNeighbor in ownedNeighbors)
{
ownArmies += ownedNeighbor.GetIdleArmies().AttackPower;
}
var opponentNeighbors = bonus.GetOpponentNeighbors().Count;
var attackValue = 0;
attackValue += armiesReward * 10000;
attackValue += opponentArmies * -1;
attackValue += ownArmies * 3;
attackValue += amountOwnedNeighbors * 100;
attackValue += opponentNeighbors * 1;
attackValue += amountTerritoriesUnderAttack * 1000;
attackValue *= BonusAttackFactor;
var bonusToWriteIn = mapToWriteIn.Bonuses[bonus.ID];
bonusToWriteIn.AttackValue = attackValue;
}
/// <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);
}
}
public BotStarter(ILog log, IBotStarterSettings settings)
{
this.log = log;
this.settings = settings;
map = File.ReadAllText(settings.BotFile).FromJson <BotMap>();
defaultStateFn = () => new State()
{
CurrentRoom = map.Rooms.First()
};
}
public static PathNode ShortestPath(BotMap map, List <BotTerritory> sources, BotTerritory destination)
{
PathNode bestPath = ShortestPath(map, sources[0], destination);
foreach (BotTerritory source in sources)
{
PathNode temp = ShortestPath(map, source, destination);
bestPath = bestPath.minDistance < temp.minDistance ? bestPath : temp;
}
return(bestPath);
}
private void Awake()
{
if (!_darwin)
{
_darwin = FindObjectOfType <MapDarwin>();
}
if (!_mapDisplayer)
{
_mapDisplayer = FindObjectOfType <BotMap>();
}
}
public bool IsComboBonus(BotBonus bonus, BotMap map)
{
if (bonus.Amount > 4 || IsInefficientBonus(bonus) || IsWastelandedBonus(bonus))
{
return(false);
}
ComboBonuses temp = new ComboBonuses(bonus, map);
return(temp.isCombo);
}
public string FormatPathOutput(BotMap map)
{
string formatted = "";
foreach (TerritoryIDType terrId in minPath)
{
formatted += map.Territories[terrId].Details.Name + " => ";
}
formatted += map.Territories[territory].Details.Name;
return(formatted);
}
public static void printExpandBonusValues(BotMap map, BotMain BotState)
{
//AILog.Log("Debug", "Bonus expansion values:");
//foreach (BotBonus bonus in map.Bonuses.Values)
//{
// if (bonus.GetOwnedTerritoriesAndNeighbors().Count > 0 && !bonus.IsOwnedByMyself())
// {
// AILog.Log("Debug", bonus.Details.Name + ": " + bonus.GetExpansionValue());
// }
//}
}
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 static void CalculateDirectDistanceToOpponentTerritories(BotMap mapToUse, BotMap mapToWriteIn)
{
var opponentTerritories = mapToUse.AllOpponentTerritories;
var annotadedTerritories = CalculateDistances(mapToUse, opponentTerritories, null);
foreach (var territory in annotadedTerritories.Keys)
{
var territoryDistance = annotadedTerritories[territory];
var territoryToWriteIn = mapToWriteIn.Territories[territory.ID];
territoryToWriteIn.DirectDistanceToOpponentBorder = territoryDistance;
}
}
public static void PrintGuessedDeployment(BotMap map, BotMain BotState)
{
//AILog.Log("Debug", "Guessed deployment:");
//foreach (BotTerritory territory in map.Territories.Values)
//{
// if (territory.IsVisible && BotState.IsOpponent(territory.OwnerPlayerID))
// {
// AILog.Log("Debug", territory.Details.Name + ": " + territory.GetTotalDeployment(BotTerritory.DeploymentType.Normal) + " | " + territory.GetTotalDeployment(BotTerritory.DeploymentType.Conservative));
// }
//}
}
public BotBonus GetBestBonusToPrevent(BotMap visibleMap, BotMap movesMap)
{
var possiblePreventableBonuses = new List <BotBonus>();
foreach (var bonus in visibleMap.Bonuses.Values)
{
if (IsPreventingUseful(visibleMap, movesMap, bonus))
{
possiblePreventableBonuses.Add(bonus);
}
}
var ourInterestingBonuses = GetOurInterestingBonuses();
var ourMaxReward = 0;
foreach (var ourBonus in ourInterestingBonuses)
{
if (ourBonus.Amount > ourMaxReward)
{
ourMaxReward = ourBonus.Amount;
}
}
var opponentMaxReward = 0;
BotBonus bestOpponentBonus = null;
foreach (var opponentBonus in possiblePreventableBonuses)
{
if (opponentBonus.Amount > opponentMaxReward)
{
bestOpponentBonus = opponentBonus;
opponentMaxReward = opponentBonus.Amount;
}
else if (opponentBonus.Amount == opponentMaxReward && opponentBonus.NeutralArmies.DefensePower < bestOpponentBonus.NeutralArmies.DefensePower)
{
bestOpponentBonus = opponentBonus;
}
}
foreach (var bonus in possiblePreventableBonuses)
{
if (bonus != bestOpponentBonus && bonus.Amount == bestOpponentBonus.Amount && bonus.NeutralArmies.DefensePower == bestOpponentBonus.NeutralArmies.DefensePower)
{
return(null);
}
}
if (opponentMaxReward > ourMaxReward)
{
return(bestOpponentBonus);
}
else
{
return(null);
}
}
/// <summary>Updates the working map according to the move input</summary>
/// <param name="attackTransferMove"></param>
public void UpdateMap(BotOrderAttackTransfer attackTransferMove, BotMap mapToUpdate, BotTerritory.DeploymentType conservativeLevel)
{
var toTerritoryID = attackTransferMove.To.ID;
var wmTerritory = BotState.WorkingMap.Territories[toTerritoryID];
var vmTerritory = BotState.VisibleMap.Territories[toTerritoryID];
var toBeKilledArmies = vmTerritory.GetArmiesAfterDeployment(BotTerritory.DeploymentType.Normal);
var attackingArmies = vmTerritory.GetIncomingArmies();
if (vmTerritory.getOwnKills(attackingArmies.AttackPower, toBeKilledArmies.DefensePower) >= toBeKilledArmies.DefensePower)
{
wmTerritory.OwnerPlayerID = BotState.Me.ID;
}
}
/// <summary>Care3Spots</summary>
/// <param name="mapToUse"></param>
public static void CalculateDistanceToOpponentBorderCare3(BotMap mapToUse, BotMap mapToWriteIn)
{
var opponentTerritories = mapToUse.AllOpponentTerritories;
var blockedTerritories = mapToUse.GetNeutralTerritories();
var annotadedTerritories = CalculateDistances(mapToUse, opponentTerritories, blockedTerritories);
foreach (var territory in annotadedTerritories.Keys)
{
var territoryDistance = annotadedTerritories[territory];
var territoryToWriteIn = mapToWriteIn.Territories[territory.ID];
territoryToWriteIn.DistanceToOpponentBorder = territoryDistance;
}
}
public static void PrintAllTerritories(BotMain state, BotMap map)
{
AILog.Log("Debug", "Territories:");
foreach (var territory in map.Territories.Values)
{
var id = territory.ID;
var player = territory.OwnerPlayerID;
var armies = territory.Armies;
var ownershipHeuristic = territory.IsOwnershipHeuristic;
var deployment = territory.GetTotalDeployment(BotTerritory.DeploymentType.Normal);
AILog.Log("Debug", " - Territory " + id + " (" + player + " | " + armies + " | " + ownershipHeuristic + " | " + deployment + ")");
}
}
private void OnValidate()
{
if (!_genetic)
{
_genetic = FindObjectOfType <MapDarwin>();
}
if (_botMap)
{
_botMap = FindObjectOfType <BotMap>();
}
if (!_interface)
{
_interface = FindObjectOfType <InterfaceDisplay>();
}
}
public ComboBonuses(BotBonus mainBonus, BotMap map)
{
this.mainBonus = mainBonus;
mainPick = GetMainBonusPick(mainBonus);
adjacentPickTerritories.Add(mainPick);
PopulateAdjacentPickList();
RemoveDuplicates(ref adjacentPickTerritories);
PopulateComboSupportPicks();
RemoveDuplicates(ref supportComboPick);
isFTB = IsFirstTurnBonus(mainBonus);
RemoveDuplicates(ref supportFTBPick);
isCounterable = adjacentPickTerritories.Count > 2 ? true : false;
isCombo = !isFTB && supportComboPick.Count > 0 && !IsManyTurnBonus();
isEfficient = !IsInefficientBonus(mainBonus) && IsEfficientCombo();
ReorderPicks();
RemoveDuplicates(ref adjacentPickTerritories);
}
