public static Moves CalculateGuessedOpponentTakeOverMoves(BotMain state, List <BotTerritory> territories, PlayerIDType opponentID, bool doesOpponentDeploy, BotTerritory.DeploymentType conservativeLevel)
{
var opponentIncome = state.Settings.MinimumArmyBonus;
if (conservativeLevel == BotTerritory.DeploymentType.Conservative)
{
opponentIncome = state.GetGuessedOpponentIncome(opponentID, state.VisibleMap);
}
var ownedTerritories = territories.Where(o => o.OwnerPlayerID == state.Me.ID).ToList();
var opponentAttacks = CalculateMinimumOpponentMoves(state, opponentID, ownedTerritories, conservativeLevel);
if (opponentAttacks.GetTotalDeployment() > opponentIncome)
{
return(null);
}
if (doesOpponentDeploy)
{
var remainingOpponentIncome = opponentIncome - opponentAttacks.GetTotalDeployment();
while (remainingOpponentIncome > 0 && opponentAttacks.Orders.OfType <BotOrderAttackTransfer>().Any())
{
foreach (var atm in opponentAttacks.Orders.OfType <BotOrderAttackTransfer>())
{
atm.Armies = atm.Armies.Add(new Armies(1));
remainingOpponentIncome--;
if (remainingOpponentIncome == 0)
{
break;
}
}
}
}
return(opponentAttacks);
}
/// <summary>Tries to find an attack move to make the support move obsolete.</summary>
private BotOrderAttackTransfer GetSubstituteMove(BotOrderAttackTransfer supportMove, BotMap movesMap, List <BotOrder> unhandledMoves)
{
var territoryToDefend = supportMove.To;
var mmTerritoryToDefend = movesMap.Territories[territoryToDefend.ID];
if (mmTerritoryToDefend.GetOpponentNeighbors().Count > 1)
{
return(null);
}
var mmOpponentTerritory = mmTerritoryToDefend.GetOpponentNeighbors()[0];
foreach (var unhandledMove in unhandledMoves.OfType <BotOrderAttackTransfer>())
{
if (unhandledMove.To.ID == mmOpponentTerritory.ID)
{
if (!CanOpponentAttackTerritory(mmOpponentTerritory.OwnerPlayerID, unhandledMove.From))
{
if (unhandledMove.Armies.AttackPower * BotState.Settings.OffensiveKillRate > mmOpponentTerritory.Armies.DefensePower + BotState.GetGuessedOpponentIncome(mmOpponentTerritory.OwnerPlayerID, BotState.VisibleMap) + 3)
{
return(unhandledMove);
}
}
}
}
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);
}
}
}
private static bool IsRiskyAttackPresent(BotMain state, Moves movesSoFar)
{
foreach (var atm in movesSoFar.Orders.OfType <BotOrderAttackTransfer>())
{
if (state.IsOpponent(atm.To.OwnerPlayerID))
{
var attackingArmies = atm.Armies;
var maxOpponentArmies = atm.To.Armies.Add(new Armies(state.GetGuessedOpponentIncome(atm.To.OwnerPlayerID, state.VisibleMap)));
if (attackingArmies.AttackPower > 1 && attackingArmies.AttackPower * state.Settings.OffensiveKillRate <= maxOpponentArmies.DefensePower * state.Settings.DefensiveKillRate)
{
return(true);
}
}
}
return(false);
}
private static int CalculateAmountOfSafeMoves(BotMain state, Moves movesSoFar)
{
var outvar = 0;
foreach (var atm in movesSoFar.Orders.OfType <BotOrderAttackTransfer>())
{
if (atm.Armies.AttackPower <= 1 || state.IsOpponent(atm.To.OwnerPlayerID))
{
outvar++;
}
else
{
var maxOpponentArmies = atm.To.Armies.Add(new Armies(state.GetGuessedOpponentIncome(atm.To.OwnerPlayerID, state.VisibleMap)));
var attackingArmies = atm.Armies;
if (attackingArmies.AttackPower * state.Settings.OffensiveKillRate > maxOpponentArmies.DefensePower * state.Settings.DefensiveKillRate)
{
outvar++;
}
}
}
return(outvar);
}
/// <summary>Returns the needed moves to defend the territory.</summary>
/// <remarks>
/// Returns the needed moves to defend the territory. If not possible then returns null. If no defense needed returns
/// empty moves. First tries to fulfill the needed armies with background armies.
/// </remarks>
/// <param name="territoryToDefend"></param>
/// <param name="maxDeployment"></param>
/// <returns></returns>
public Moves CalculateDefendTerritoryTask(BotTerritory territoryToDefend, int maxDeployment, bool useBackgroundArmies, BotTerritory.DeploymentType lowerConservativeLevel, BotTerritory.DeploymentType upperConservativeLevel)
{
var outvar = new Moves();
var oppNeighbors = territoryToDefend.GetOpponentNeighbors();
if (oppNeighbors.Count == 0)
{
return(null);
}
var maxOpponentDeployment = oppNeighbors.Select(o => o.OwnerPlayerID).Distinct().Max(o => BotState.GetGuessedOpponentIncome(o, BotState.VisibleMap));
for (var i = 0; i < maxOpponentDeployment; i++)
{
var defendMoves = CalculateDefendTerritoryMoves(territoryToDefend, maxDeployment, useBackgroundArmies, i, lowerConservativeLevel, upperConservativeLevel);
if (defendMoves != null)
{
outvar = defendMoves;
}
else
{
return(outvar);
}
}
return(null);
}
