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); }