private static int GetTroopTarget(GameInformation gameInformation, Country country)
{
var enemies = gameInformation.GetAdjacentCountriesWithDifferentOwner(country).ToList();
if (enemies.Count == 0) return country.IsContinentGateway() ? 4 : 2;
if (enemies.Count == 1) return enemies[0].NumberOfTroops + 3;
return enemies.Sum(x => x.NumberOfTroops) + 1;
}
public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
{
if (attackRolls.Count(x => x > 3) > 1)
return 1;
return 2;
}
public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
{
if (attackRolls.Count == 3)
{
var dangerlevel = 0;
if (attackRolls[0] >= 5)
{
dangerlevel++;
}
if (attackRolls[1] >= 5)
{
dangerlevel++;
}
if (attackRolls[2] >= 5)
{
dangerlevel++;
}
if (dangerlevel >= 2)
{
return 1;
}
return 2;
}
else
{
var dangerlevel = 0;
if (attackRolls[0] >= 5)
{
dangerlevel++;
}
// bug here, there can be only 1 attack roll
// Remco: added check for attack roll count
if (attackRolls.Count>1 && attackRolls[1] >= 5)
{
dangerlevel++;
}
if (dangerlevel >= 2)
{
return 1;
}
return 2;
}
}
/// <summary>
/// Adds attack info to the analysis, but only if there is a chance for success
/// </summary>
private void AddAttack(TurnManager turnManager, RiskAnalysis analysis, Country friendly, Country enemy)
{
var minDefenders = 2;
if (friendly.NumberOfTroops > minDefenders+1 && friendly.NumberOfTroops > enemy.NumberOfTroops )
{
analysis.Attacks.Add(new Attack(turnManager)
{
FromCountry = friendly,
ToCountry = enemy,
Troops = friendly.NumberOfTroops - minDefenders,
});
}
}
public void AddDeployAction(Country country, int addedTroops)
{
var existingDeployActions =
gameManager.Actions.Where(x => x is DeployAction).Cast<DeployAction>();
var existingActionThisTurn =
existingDeployActions.FirstOrDefault(x => x.CountryToDeploy == country && x.ShowOnMap);
if (existingActionThisTurn != null)
{
existingActionThisTurn.NumberOfAddedTroops += addedTroops;
}
else
{
gameManager.Actions.Add(new DeployAction
{
CountryToDeploy = country,
NumberOfAddedTroops = addedTroops,
Player = gameManager.CurrentPlayer,
ShowOnMap = true
});
}
}
public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
{
return 2;
}
/// <summary>
/// Returns true if the country is important to defend.
/// for example :
/// - losing it would destroy a continent troop bonus.
/// - it's an attack launch site
/// - it's a deployment site
/// - it's involved in a move.
/// The analyzer determines which countries are important.
/// </summary>
public bool IsImportant(Country country)
{
return ImportantCountries.Contains(country);
}
public int GetDefenceRolls(List<int> attackRolls, Country countryToDefend)
{
const int minNumberOfDefenders = 1;
var maxNumberofDefenders = Math.Min(countryToDefend.NumberOfTroops, 2);
if (IsImportant(countryToDefend))
{
return maxNumberofDefenders;
}
// more defence rolls than attack rolls increase the chances for a succesfull defence
if (attackRolls.Count < countryToDefend.NumberOfTroops)
{
return maxNumberofDefenders;
}
// make defeat take longer by dragging out the attack.
return minNumberOfDefenders;
}
public int Defend(TurnManager turnManager, List<int> attackRolls, Country countryToDefend)
{
var analysis = riskAnalyzer.Analyze(turnManager);
return analysis.GetDefenceRolls(attackRolls, countryToDefend);
}
public void AddMoveAction(Country country, Country countryToMoveTo, int numberOfTroops)
{
gameManager.Actions.Add(new MoveAction
{
Country = country,
CountryToMoveTo = countryToMoveTo,
NumberOfTroopsToMove = numberOfTroops,
Player = gameManager.CurrentPlayer
});
}
private Country GetMostImportantSurroundingCountry(TurnManager turnManager, Country country)
{
return
country.AdjacentCountries.ToList()
.Where(c => c.Owner == this)
.OrderBy(c => GetCountryScore(turnManager, c))
.Last();
}
public void MoveTroops(Country country, Country countryToMoveTo, int numberOfTroops)
{
ValidatePlayer();
if (gameManager.CurrentPhase != EPhase.Move) throw new RiskException("Its not the move phase");
if (country.Owner != player) throw new RiskException("Troops can only be moved from owned countries");
if (countryToMoveTo.Owner != player) throw new RiskException("Troops can only be moved to owned countries");
if (!country.AdjacentCountries.Contains(countryToMoveTo))
throw new RiskException("Countries must be adjacent to move");
if (country.NumberOfTroops - numberOfTroops < 1) throw new RiskException("Not enough troops on country");
if (gameManager.TroopsToMove - numberOfTroops < 0)
throw new RiskException(string.Format("unable to move {0} troops, only {1} moves left", numberOfTroops,
gameManager.TroopsToMove));
if (numberOfTroops < 1) throw new RiskException("Unable to move less then 1 troop");
gameManager.TroopsToMove -= numberOfTroops;
country.NumberOfTroops -= numberOfTroops;
countryToMoveTo.NumberOfTroops += numberOfTroops;
new ActionLogger(gameManager).AddMoveAction(country, countryToMoveTo, numberOfTroops);
}
private int GetNumberOfTotalEnemyTroupsForCountry(Country country)
{
var numberOfEnemies =
gameInformation.GetAdjacentCountriesWithDifferentOwner(country).Sum(x => x.NumberOfTroops);
return numberOfEnemies;
}
private double GetDefensiveRateForCountry(Country country, int numberOfTotalEnemyTroopsForCountry)
{
return (double) country.NumberOfTroops/numberOfTotalEnemyTroopsForCountry;
}
public PossibleAttack(Country myCountry, Country victim, int troops)
{
MyCountry = myCountry;
Victim = victim;
NumberOfTroops = troops;
}
private void MoveTroopsToSurroundingCountries(TurnManager turnManager, Country country)
{
turnManager.MoveTroops(country, GetMostImportantSurroundingCountry(turnManager, country), 1);
}
private bool IsLastEnemyInContinent(TurnManager turnManager, Country country)
{
var victimContinent = country.Continent;
var info = turnManager.GetGameInfo();
var myCountriesInContinent =
info.GetAllCountriesOwnedByPlayer(this).Count(c => c.Continent == country.Continent);
var allCountriesInContinent = info.GetAllCountries().Count(c => c.Continent == country.Continent);
return (allCountriesInContinent - myCountriesInContinent) == 1;
}
private Country GetRandomAdjacentCountryToAttack(TurnManager turnManager, Country country)
{
var adjacentCountries =
turnManager.GetGameInfo().GetAdjacentCountriesWithDifferentOwner(country);
return adjacentCountries[r.Next(0, adjacentCountries.Count - 1)];
}
public void DeployTroops(Country country, int numberOfTroops)
{
ValidatePlayer();
if (gameManager.CurrentPhase != EPhase.Deploy) throw new RiskException("Its not the deploy phase");
if (country.Owner != player) throw new RiskException("Troops can only be deployed on owned countries");
if (gameManager.TroopsToDeploy - numberOfTroops < 0)
throw new RiskException("Unable to deploy more troops than given");
gameManager.TroopsToDeploy -= numberOfTroops;
country.NumberOfTroops += numberOfTroops;
new ActionLogger(gameManager).AddDeployAction(country, numberOfTroops);
}
private double GetCountryScore(TurnManager turnManager, Country country)
{
var NumberOfPotentialTroopsFromContinent = 0;
var StaticValue = 0;
var SurroundingFriendlyCountries = 0;
var SurroundingEnemyCountries = 0;
var SurroundingFriendlyTroops = 0;
var SurroundingEnemyTroops = 0;
var average = AverageTroopsPerCountry(turnManager);
if (country.NumberOfTroops > (1.5 * average))
{
return 0;
}
SurroundingFriendlyCountries = country.AdjacentCountries.ToList().Where(c => c.Owner == this).Count();
SurroundingEnemyCountries = country.AdjacentCountries.Count - SurroundingFriendlyCountries;
if (SurroundingFriendlyCountries == country.AdjacentCountries.Count)
{
return 0;
}
switch (country.Continent)
{
case EContinent.NorthAmerica:
NumberOfPotentialTroopsFromContinent = 4;
break;
case EContinent.SouthAmerica:
NumberOfPotentialTroopsFromContinent = 4;
break;
case EContinent.Africa:
NumberOfPotentialTroopsFromContinent = 4;
break;
case EContinent.Europe:
NumberOfPotentialTroopsFromContinent = 4;
break;
case EContinent.Asia:
NumberOfPotentialTroopsFromContinent = 4;
break;
case EContinent.Australia:
NumberOfPotentialTroopsFromContinent = 3;
break;
default:
break;
}
var belowAverage = average - country.NumberOfTroops;
var rate = NumberOfPotentialTroopsFromContinent * 1 +
StaticValue * 1 +
SurroundingEnemyTroops * 1 -
SurroundingFriendlyTroops * 1 +
SurroundingEnemyCountries * 1 -
SurroundingFriendlyCountries * 1 +
belowAverage * 2;
return rate;
}
public bool Attack(Country country, Country countryToAttack, int numberOftroopsToAttackWith)
{
ValidatePlayer();
if (gameManager.CurrentPhase != EPhase.Attack) throw new RiskException("Its not the attack phase");
if (country.Owner != player) throw new RiskException("Attacks can only start from a owned country");
if (countryToAttack.Owner == player) throw new RiskException("Can't attack a owned country");
if (!country.AdjacentCountries.Contains(countryToAttack))
throw new RiskException("Countries must be adjacent to attack");
if (country.NumberOfTroops - numberOftroopsToAttackWith < 1)
throw new RiskException("Not enough troops on country");
country.NumberOfTroops -= numberOftroopsToAttackWith;
var attackAction = new AttackAction
{
Player = country.Owner,
Country = country,
CountryToAttack = countryToAttack,
DefendingPlayer = countryToAttack.Owner,
Attackers = numberOftroopsToAttackWith,
Defenders = countryToAttack.NumberOfTroops
};
var totalDeadDefenders = 0;
var totalDeadAttackers = 0;
do
{
var numberOfAttackDiceRolls = Math.Min(3, numberOftroopsToAttackWith);
var attackRolls = gameManager.GetDiceRolls(numberOfAttackDiceRolls);
int numberOfDiceToDefendWith;
try
{
var defenceTurnManager = gameManager.GetTurnManager(countryToAttack.Owner);
numberOfDiceToDefendWith = countryToAttack.Owner.Defend(defenceTurnManager, attackRolls.GetRange(0, attackRolls.Count), countryToAttack);
if (numberOfDiceToDefendWith > 2 || numberOfDiceToDefendWith < 1 ||
countryToAttack.NumberOfTroops == 1)
{
numberOfDiceToDefendWith = 1;
}
}
catch (Exception e)
{
new ActionLogger(gameManager).AddException(e, countryToAttack.Owner);
numberOfDiceToDefendWith = 1;
}
var defendRolls = gameManager.GetDiceRolls(numberOfDiceToDefendWith);
var rollsToCheck = attackRolls.Count > 1 && defendRolls.Count > 1 ? 2 : 1;
var deadAttackers = 0;
var deadDefenders = 0;
for (var i = 0; i < rollsToCheck; i++)
{
var highestAttackRoll = attackRolls.OrderByDescending(roll => roll).First();
attackRolls.Remove(highestAttackRoll);
var highestDefendRoll = defendRolls.OrderByDescending(roll => roll).First();
defendRolls.Remove(highestDefendRoll);
if (highestAttackRoll > highestDefendRoll)
{
deadDefenders++;
}
else
{
deadAttackers++;
}
}
countryToAttack.NumberOfTroops -= deadDefenders;
numberOftroopsToAttackWith -= deadAttackers;
totalDeadAttackers += deadAttackers;
totalDeadDefenders += deadDefenders;
} while (numberOftroopsToAttackWith > 0 && countryToAttack.NumberOfTroops > 0);
attackAction.DeadAttackers = totalDeadAttackers;
attackAction.DeadDefenders = totalDeadDefenders;
attackAction.AttackSucceeded = countryToAttack.NumberOfTroops == 0;
gameManager.Actions.Add(attackAction);
if (countryToAttack.NumberOfTroops == 0)
{
countryToAttack.Owner = country.Owner;
countryToAttack.NumberOfTroops = numberOftroopsToAttackWith;
return true;
}
return false;
}
public List<Country> GetAdjacentCountriesWithSameOwner(Country country)
{
return country.AdjacentCountries.Where(adjacentCountry => adjacentCountry.Owner == country.Owner).ToList();
}
