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);
}
public Boolean IsFirstTurnBonus(BotBonus bonus)
{
Boolean isFirstTurnBonus = false;
if (bonus.Amount != 3 || IsInefficientBonus(bonus) || IsWastelandedBonus(bonus))
{
return(isFirstTurnBonus);
}
foreach (var terr in bonus.Territories)
{
if (terr.Armies.NumArmies != 0)
{
continue;
}
if (NumberOfBonusTerrNeighbours(terr) == 3)
{
foreach (var adjBonusTerr in terr.Neighbors)
{
if (ContainsTerritory(bonus, adjBonusTerr))
{
foreach (var adjTerr in adjBonusTerr.Neighbors)
{
if (!ContainsTerritory(bonus, adjTerr) && adjTerr.Armies.NumArmies == 0 && !IsInefficientBonus(adjTerr.Bonuses[0]) && !IsWastelandedBonus(adjTerr.Bonuses[0]))
{
return(true);
}
}
}
}
}
else
{
ArrayList coveredTerritories = new ArrayList();
foreach (var adjTerr in terr.Neighbors)
{
if (ContainsTerritory(bonus, adjTerr))
{
coveredTerritories.Add(adjTerr);
}
}
foreach (var bonusTerr in bonus.Territories)
{
if (!coveredTerritories.Contains(bonusTerr) && bonusTerr.Armies.NumArmies != 0)
{
foreach (var adjTerr in bonusTerr.Neighbors)
{
if (adjTerr.Armies.NumArmies == 0 && !IsInefficientBonus(adjTerr.Bonuses[0]) && !IsWastelandedBonus(adjTerr.Bonuses[0]))
{
goto CONTINUELOOP;
}
}
return(isFirstTurnBonus);
}
CONTINUELOOP :;
}
isFirstTurnBonus = true;
}
}
return(isFirstTurnBonus);
}
public void AddExtraValueForFirstTurnBonus(BotBonus bonus)
{
bonus.ExpansionValue += bonus.ExpansionValue * 0.5;
}
/// <summary>
/// Calculates the needed moves to push the opponent out of a Bonus that has no neutrals in it.
/// </summary>
/// <param name="maxDeployment"></param>
/// <param name="Bonus"></param>
/// <returns></returns>
public static Moves CalculateTakeBonusOverTask(BotMain state, int maxDeployment, BotBonus bonus, BotTerritory.DeploymentType conservativeLevel)
{
var opponentTerritories = bonus.GetVisibleOpponentTerritories();
return(state.TakeTerritoriesTaskCalculator.CalculateTakeTerritoriesTask(maxDeployment, opponentTerritories, conservativeLevel, "TakeBonusOverTask"));
}
private Boolean IsInefficientBonus(BotBonus bonus)
{
return(bonus.Territories.Count != bonus.Amount + 1);
}
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 int GetAdjustedFactor(BotBonus bonus)
{
var adjustedFactor = Math.Max(bonus.PreventTakeOverValue, Math.Max(bonus.TakeOverValue, Math.Max(bonus.AttackValue, bonus.DefenseValue)));
return(adjustedFactor);
}
public Boolean IsFirstTurnBonus(BotBonus bonus)
{
if (bonus.Amount != 3 || IsInefficientBonus(bonus) || IsWastelandedBonus(bonus))
{
return(false);
}
IDictionary <BotTerritory, int> pickTerritories = new Dictionary <BotTerritory, int>();
pickTerritories.Add(adjacentPickTerritories[0], NumberOfBonusTerrNeighbours(adjacentPickTerritories[0], mainBonus));
if (NumberOfBonusTerrNeighbours(mainPick, mainBonus) == 3)
{
foreach (var adjBonusTerr in mainPick.Neighbors)
{
if (ContainsTerritory(bonus, adjBonusTerr))
{
foreach (var adjTerr in adjBonusTerr.Neighbors)
{
if (!ContainsTerritory(bonus, adjTerr) && adjTerr.Armies.NumArmies == 0)
{
if (!pickTerritories.ContainsKey(adjTerr))
{
pickTerritories.Add(adjTerr, 0);
supportFTBPick.Add(adjTerr);
}
pickTerritories[adjTerr]++;
}
}
}
}
}
else
{
ArrayList uncoveredTerritories = new ArrayList(Except(mainBonus, mainPick.Neighbors));
uncoveredTerritories.Remove(mainPick);
foreach (BotTerritory terr in uncoveredTerritories)
{
foreach (BotTerritory adjTerr in terr.Neighbors)
{
if (adjTerr.Armies.NumArmies == 0 && adjTerr != mainPick)
{
if (!pickTerritories.ContainsKey(adjTerr))
{
pickTerritories.Add(adjTerr, 0);
}
pickTerritories[adjTerr]++;
}
}
}
foreach (KeyValuePair <BotTerritory, int> pair in pickTerritories)
{
if (pair.Value == uncoveredTerritories.Count)
{
supportFTBPick.Add(pair.Key);
}
}
}
for (int i = 0; i < supportFTBPick.Count; i++)
{
if (IsWastelandedBonus(supportFTBPick[i].Bonuses[0]) || IsInefficientBonus(supportFTBPick[i].Bonuses[0]) || supportFTBPick[i].Bonuses[0].Details.Name.Equals("Caucasus") || supportFTBPick[i].Bonuses[0].Details.Name.Equals("West China"))
{
supportFTBPick.RemoveAt(i--);
}
}
//////////////////////////////////////////////////////////
return(supportFTBPick.Count > 0);
}
private int VisCount(BotBonus s)
{
return s.Territories.Count - UnvisCount(s);
}
// TODO
public static Dictionary <BotTerritory, int> GetClosestTerritoryToOpponentBonus(BotMain state, BotMap mapToUse, BotBonus opponentBonus)
{
List <BotTerritory> Territories = opponentBonus.Territories;
var annotadedTerritories = CalculateDistances(mapToUse, Territories, null);
var minDistance = 1000;
BotTerritory minDistanceTerritory = null;
foreach (var territory in annotadedTerritories.Keys)
{
var territoryDistance = annotadedTerritories[territory];
if (territory.OwnerPlayerID == state.Me.ID && territoryDistance < minDistance)
{
minDistance = annotadedTerritories[territory];
minDistanceTerritory = territory;
}
}
Dictionary <BotTerritory, int> returnTerritory = new Dictionary <BotTerritory, int>();
returnTerritory.Add(minDistanceTerritory, minDistance);
return(returnTerritory);
}
private double GetBonusScore(Edge e, BotBonus bonus)
{
var end = e.End;
var score = 0.0;
if (end.OwnerPlayerID == TerritoryStanding.NeutralPlayerID)
{
score += (double)bonus.ArmiesReward * (double)end.Armies / (double)bonus.GuessedArmiesNotOwnedByUs;
if (bonus.GuessedArmiesNotOwnedByUs >= 7)
{
score *= 0.7 - ((bonus.GuessedArmiesNotOwnedByUs - 7) * 0.05);
}
if (bonus.ArmiesToNeutralsRatio < 0.3)
{
score *= 0.35;
}
if (!bonus.IsSafe())
{
score *= 0.65;
if (bonus.GuessedArmiesNotOwnedByUs > 4) //TODO
{
score *= 0.25;
}
}
if (bonus.ArmiesReward > 0 /*&& !bonus.HasWasteland()*/ && bonus.IsSafe())
{
// && end.getBonus().getSize() <= 4
score *= 1.1;
if (bonus.Territories.Count <= 4 && bonus.ArmiesReward >= 2 && bonus.GuessedArmiesNotOwnedByUs < Bot.MyIncome.Total) //TODO
{
score *= 1.3;
}
}
if (Analyzer.SoonBeOwned(bonus) && bonus.ArmiesReward > 1 && end.Armies < 4) //TODO
{
if (Bot.NumberOfTurns == 0)
{
score += 0.10 * bonus.ArmiesReward;
}
else
{
score += 0.20 * bonus.ArmiesReward / bonus.Territories.Count;
}
}
// dumpSet.add(e);
foreach (var neighbor in end.Neighbors)
{
var nb = neighbor.Bonuses.Where(b => Analyzer.MightBeOwned(b) && b.IsUnvisible() && b.ArmiesReward > 1);
if (end.Armies < 4 && nb.Any())
{
// && !neighbor.getBonus().hasWasteland()
var modifier = 0.25 * nb.Sum(o => o.ArmiesReward);
//if (neighbor.Bonus.HasWasteland())
// modifier *= 0.7; //TODO: Check the desirability of this bonus and adjust accordingly here
score += modifier;
DumpSet.Add(e.ID, e);
break;
}
}
// score += 0.05 * neighbor.getBonus().getArmiesReward();
// Tie Break
foreach (var neighbor_1 in end.Neighbors)
{
if (neighbor_1.Bonuses.Any(b => b.MightBeOwnedByOpponent()))
{
score += 0.03;
}
else
{
if (!neighbor_1.IsVisible)
{
//if (!neighbor_1.Bonus.HasWasteland())
// score += 0.02;
//else
score += 0.01;
}
else
{
if (Bot.NumberOfTurns == 0 && Bot.IsOpponent(neighbor_1.OwnerPlayerID))
{
score += 0.02;
}
}
}
}
}
else
{
if (Bot.IsOpponent(end.OwnerPlayerID))
{
score += bonus.ArmiesReward * 1.0 / Math.Max(1, bonus.GuessedArmiesNotOwnedByUs);
if (Analyzer.SoonBeOwned(bonus) /*&& !bonus.HasWasteland()*/)
{
if (Analyzer.MightBeOwned(bonus))
{
score += 0.8 * bonus.ArmiesReward;
if (bonus.ArmiesReward > 1)
{
DumpSet.Add(e.ID, e);
}
}
else
{
score += 0.1 * bonus.ArmiesReward;
}
}
else
{
if (bonus.MightBeOwnedByOpponent())
{
score += 0.1 * bonus.ArmiesReward;
}
}
if (end.GetBestAdjacentBonus().GuessedArmiesNotOwnedByUs <= 0 && e.Start.Bonuses.Any(b => b.ID == end.GetBestAdjacentBonus().ID))
{
score += (double)end.GetBestAdjacentBonus().ArmiesReward / bonus.GuessedArmiesNotOwnedByUs;
}
foreach (var neighborBonus in end.Neighbors.Where(o => o.OwnerPlayerID != Bot.Me.ID).SelectMany(o => o.Bonuses).Where(o => o.ID != bonus.ID && Analyzer.MightBeOwned(o)))
{
score += neighborBonus.ArmiesReward * 0.03;
}
}
else
{
if (end.IsFoothold())
{
score += 0.5 * bonus.ArmiesReward;
foreach (var r in bonus.Territories)
{
if (r.IsVisible && Bot.IsOpponent(r.OwnerPlayerID))
{
score += bonus.ArmiesReward * 0.5 / bonus.Territories.Count;
}
}
}
if (end.GetStrongestNearestEnemy() > 0 && bonus.GuessedArmiesNotOwnedByUs <= 0)
{
var count = 0;
foreach (var territory in bonus.Territories)
{
if (territory.OwnerPlayerID == Bot.Me.ID && territory.GetStrongestNearestEnemy() > 0)
{
count++;
}
}
score += 1.2 * bonus.ArmiesReward / Math.Max(1, count);
}
foreach (var fromPath in end.GetFromPaths())
{
if (fromPath.End.OwnerPlayerID == TerritoryStanding.NeutralPlayerID)
{
score += 0.1 * GetScore(fromPath);
}
else
{
if (Bot.IsOpponent(fromPath.End.OwnerPlayerID))
{
score += 0.4 * GetScore(fromPath);
}
}
}
if (end.GetStrongestNearestEnemy() > 0)
{
score += 2 * bonus.ArmiesReward * bonus.ArmiesToNeutralsRatio / bonus.Territories.Count;
}
}
}
return(score);
}
public bool SoonBeOwned(BotBonus bonus)
{
var mine = 0;
var his = 0;
var neutral = 0;
var unvis = 0;
foreach (var r in bonus.Territories)
{
if (r.IsVisible)
{
if (r.OwnerPlayerID == Bot.Me.ID)
{
mine++;
}
else
{
if (Bot.IsOpponent(r.OwnerPlayerID))
{
his++;
}
else
{
neutral++;
}
}
}
else
{
unvis++;
}
}
if (mine > 0)
{
return(false); //???
}
if (neutral > 2 || neutral > bonus.Territories.Count / 2)
{
return(false);
}
if (BonusBuckets[bonus.ID] + 4 < BonusCosts[bonus.ID])
{
return(false);
}
// EXPERIMENTAL:
var bonusList = new List <BotBonus>();
foreach (var tmp in Bot.BotMap.Bonuses.Values)
{
if (VisCount(tmp) <= 1 && !MightBeOwned(tmp))
{
bonusList.Add(tmp);
}
}
var eval = new BonusComparator(this);
foreach (var tmp_1 in bonusList)
{
if (eval.Compare(bonus, tmp_1) > 0)
{
return(false);
}
}
return(true);
}
private static bool AreWeAlreadyMovingInDirection(BotBonus opponentBonus, BotMap visibleMap, BotMap workingMap)
{
var alreadyMovingInDirection = false;
return(alreadyMovingInDirection);
}
