public void CreateTurnPredictionsForPlanet(Planet planet)
{
int planetID = planet.PlanetID;
GrowthRate = planet.GrowthRate;
ResetStats();
PlanetTurn lastCalculatedTurn = this[0];
lastCalculatedTurn.SetValues(planet.Owner, planet.NumShips);
planet.LastAttackTurn = lastCalculatedTurn;
PlanetTurn currentCalculatingTurn = lastCalculatedTurn.Next;
planet.MaxDesertersAllowed = planet.NumShips;
planet.ShipsRequiredToSurviveAttack = planet.NumShips;
planet.DoesNotChangeOwner = true;
int currentTurn = 1;
if (planetID == 15)
{
}
if (planet.Armada.Count > 0)
{
planet.IdleForThisNumberOfTurns = 0;
foreach (var turn in planet.FleetArrivalByTurnsRemaining)
{
do
{
lastCalculatedTurn = currentCalculatingTurn;
currentCalculatingTurn = GrowTurn(GrowthRate, currentCalculatingTurn);
} while (currentTurn++ < turn.Key);
LastAttackTurn = lastCalculatedTurn;
bool survived = Universe.FightBattleAndOwnerSurvived(lastCalculatedTurn, turn);
if (lastCalculatedTurn.IsMine)
{
planet.MaxDesertersAllowed = Math.Min(planet.MaxDesertersAllowed, lastCalculatedTurn.NumShips);
}
if (!survived)
{
planet.DoesNotChangeOwner = false;
}
}
}
while (currentCalculatingTurn != null)
{
lastCalculatedTurn = currentCalculatingTurn;
currentCalculatingTurn = GrowTurn(GrowthRate, currentCalculatingTurn);
}
planet.WinningArmadaIsMine = lastCalculatedTurn.Owner == 1;
//int lastTurn = planet.FleetArrivalByTurnsRemaining.Last().Key;
//lastAttackTurn = this[lastTurn];
//for (int turnNumber = 1; turnNumber <= lastTurn; turnNumber++)
//{
// lastCalculatedTurn = this[turnNumber];
// calc.Grow();
// lastCalculatedTurn.SetValues(calc.Owner, calc.NumShips);
// if (Universe.FightBattle(calc, turnNumber))
// {
// lastCalculatedTurn.SetValues(calc.Owner, calc.NumShips);
// planet.LastAttackTurn = lastCalculatedTurn;
// if (calc.IsMine)
// {
// planet.MaxDesertersAllowed = Math.Min(planet.MaxDesertersAllowed, calc.NumShips);
// }
// if (calc.IsEnemy)
// {
// planet.ShipsRequiredToSurviveAttack = Math.Max(planet.MaxDesertersAllowed, calc.NumShips + 1);
// }
// if (calc.IsNeutral)
// {
// planet.ShipsRequiredToSurviveAttack = Math.Min(planet.ShipsRequiredToSurviveAttack, calc.NumShips + 1);
// }
// }
// else
// {
// lastCalculatedTurn.SetValues(calc.Owner, calc.NumShips);
// }
// if (!calc.DoesNotChangeOwner)
// {
// planet.DoesNotChangeOwner = false;
// }
//}
}
public List <AttackPlan> BuildActionPlan(Universe uni)
{
currentUniverse = uni;
StartOfTurn();
DefendOnwedPlanets();
DefendNeutralPlanets(MaxTurnLookaheadForNeutralDefense);
ProcessAttackQueue();
List <AttackPlan> battleplan = new List <AttackPlan>();
foreach (Planet onwedPlanet in currentUniverse.Me.Planets.Where(OwnedPlanetCanSendAttackForce))
{
if (SourcePlanetSelected(onwedPlanet))
{
var planetTravelMap = onwedPlanet.Routes;
if (PlanetRouteSelected(onwedPlanet, planetTravelMap))
{
bool continueRoute = true;
AttackPlan attack = new AttackPlan();
foreach (Route route in SortRoutesForBattlePlanCreation(planetTravelMap))
{
Planet hostile = route.Destination;
if (!hostile.IsMine)
{
attack.Target = hostile;
attack.Enabled = false;
attack.Strategy = GetType().Name;
attack.Reason = "CreateAttackPlanForOwnedPlanet";
CreateAttackPlanForOwnedPlanet(attack, route, planetTravelMap, ref continueRoute);
if (attack.Enabled)
{
if (onwedPlanet.IdleForThisNumberOfTurns >= 15)
{
attack.Sweetness += onwedPlanet.IdleForThisNumberOfTurns;
}
battleplan.Add(attack);
attack = new AttackPlan();
}
}
if (!continueRoute)
{
break;
}
}
}
PlanetRouteDeSelected(onwedPlanet, planetTravelMap);
}
}
if (!TakeGamble_DoNotCountOutgoingShipsForOneTurn)
{
//attack planets for all fleets in transit
foreach (Planet planet in uni.All.Planets)
{
if (!(planet.IsLost || planet.Armada.Count == 0))
{
foreach (Fleet attackforce in planet.Armada)
{
if (attackforce.IsMine)
{
planet.RemoveShips(attackforce.NumShips);
}
}
}
}
}
TakeGamble_DoNotCountOutgoingShipsForOneTurn = false;
return(battleplan);
}
public void DoTurn(Universe uni)
{
currentUniverse = uni;
ProcessAttackQueue();
bool attackMade = false;
int sumAttackForce = 0;
Dictionary <Planet, PlanetTurn> possibleTargets = new Dictionary <Planet, PlanetTurn>();
foreach (var planet in CanUseInAtttack())
{
sumAttackForce += planet.AttackForce;
possibleTargets.Clear();
PlanetTurn attackTurn = planet.TurnPrediction[0];
//find planets that can be attacked with this planets force.
foreach (var route in planet.Routes
.Where(target => IsNotEventuallyMine(target.Destination) &&
target.Destination.GrowthRate > 0))
{
PlanetTurn state = route.Destination.TurnPrediction[route.DistanceInTurns + 1];
if (state.Owner != 1 && state.NumShips < planet.AttackForce)
{
possibleTargets.Add(route.Destination, state);
}
}
// from the list find the planets from which I have most to gain or which are nearest.
if (Universe.TurnCount < 3)
{
foreach (var item in possibleTargets.OrderBy(
target => - target.Key.GrowthRate)
.ThenBy(target => target.Value.NumShips))
{
if (planet.IsNeutral)
{
if (planet.AttackForce > item.Value.NumShips)
{
AttackPlan plan = new AttackPlan();
plan.Enabled = true;
plan.AddParticipant(planet, attackTurn, item.Value);
plan.Target = item.Key;
attackMade = true;
ExecutePlans(plan);
}
else
{
break;
}
}
}
}
else
{
foreach (var item in possibleTargets.OrderBy(
target => - ((target.Key.IsNeutral ? 2 : 0) + target.Key.GrowthRate) / currentUniverse.Me.ShipOnPlanetFocus.Delta(target.Key)))
{
if (planet.AttackForce > item.Value.NumShips)
{
AttackPlan plan = new AttackPlan();
plan.Enabled = true;
plan.AddParticipant(planet, attackTurn, item.Value);
plan.Target = item.Key;
attackMade = true;
ExecutePlans(plan);
}
else
{
break;
}
}
}
}
var centerPlanet = currentUniverse.Me.Planets
.OrderBy(item => Universe.Center.Delta(item)
+ currentUniverse.Enemy.ShipOnPlanetFocus.Delta(item)).FirstOrDefault();
if (centerPlanet != null)
{
int supportCount = 0;
foreach (var planet in CanUseInAtttack())
{
if (centerPlanet != planet)
{
supportCount++;
currentUniverse.MakeMove(planet, centerPlanet, Math.Min(planet.AttackForce, 2));
}
}
}
if (!attackMade)
{
int targetOwnerId = 0;
if (!currentUniverse.IsDominating)
{
if (rnd.NextDouble() > currentUniverse.Neutral.Planets.Count / (currentUniverse.Enemy.Planets.Count + 0.1))
{
targetOwnerId = 2;
}
}
else
{
targetOwnerId = 2;
}
var target = currentUniverse.Planets.Values
.Where(planet => planet.LastAttackTurn.NumShips < sumAttackForce - planet.GrowthRate * 2 &&
IsNotEventuallyMine(planet) &&
planet.GrowthRate > 1 &&
planet.Owner == targetOwnerId
)
.OrderBy(planet => - ((planet.GrowthRate + Math.Sqrt(planet.NumShips)) / 3) * 3)
.ThenBy(planet => currentUniverse.Me.ShipOnPlanetFocus.Delta(planet))
.FirstOrDefault();
if (target != null)
{
AttackPlan plan = new AttackPlan();
plan.Enabled = true;
plan.Target = target;
foreach (var planet in CanUseInAtttack())
{
plan.AddParticipant(planet, planet.TurnPrediction[0], target.TurnPrediction[0]);
}
attackMade = true;
ExecutePlans(plan);
}
}
if (!attackMade && sumAttackForce > 100)
{
AttackPlan plan = new AttackPlan();
plan.Enabled = true;
plan.DominationMove = true;
plan.Target = centerPlanet;
foreach (var planet in CanUseInAtttack().Where(item => item != centerPlanet))
{
plan.AddParticipant(planet, planet.TurnPrediction[0], centerPlanet.TurnPrediction[0]);
}
attackMade = true;
ExecutePlans(plan);
}
}
private bool SortAndMakeMoves(Universe uni, List <AttackPlan> sweetnesses)
{
return(MakeSweetestMoves(uni, sweetnesses.OrderBy(item => - item.Sweetness)));
}
public void DoTurn(Universe uni)
{
currentUniverse = uni;
ProcessAttackQueue();
bool attackMade = false;
int sumAttackForce = 0;
List <AttackPlan> possibleTargets = new List <AttackPlan>();
foreach (var planet in CanUseInAtttack())
{
sumAttackForce += planet.AttackForce;
//possibleTargets.Clear();
PlanetTurn attackTurn = planet.TurnPrediction[0];
PlanetTurn highestStateTakeOver = new PlanetTurn(0);
//find planets that can be attacked with this planets force, from which I have most to gain
foreach (var route in planet.Routes
.Where(target => IsNotEventuallyMine(target.Destination) &&
target.Destination.GrowthRate > 0))
{
PlanetTurn stateTakeOver = null;
PlanetTurn destinationState = route.DestinationStateOnArrival;
PlanetTurn startAttackOnRun = attackTurn;
if (!destinationState.IsMine)
{
AttackPlan plan = new AttackPlan();
if (planet.AttackForce > destinationState.NumShips)
{
stateTakeOver = route.Destination.CalcMaxGainUsingThisManyShips(planet, route.DistanceInTurns, destinationState.NumShips + 5);
plan.Enabled = true;
}
else
{
do
{
destinationState = destinationState.Next;
startAttackOnRun = startAttackOnRun.Next;
} while (destinationState != null &&
startAttackOnRun.NumShips < destinationState.NumShips);
plan.Enabled = destinationState != null && startAttackOnRun != null;
if (plan.Enabled)
{
stateTakeOver = route.Destination.CalcMaxGainUsingThisManyShips(planet, destinationState.TurnsFromNow, startAttackOnRun.NumShips);
}
}
if (plan.Enabled)
{
plan.AddParticipant(planet, startAttackOnRun, destinationState);
plan.Target = route.Destination;
plan.Enabled = true;
plan.Sweetness = stateTakeOver.NumShips;
possibleTargets.Add(plan);
highestStateTakeOver = stateTakeOver;
}
}
//PlanetTurn fullAttackState = planet.TurnPrediction.CalcMaxGainUsingThisManyShips(destinationState, planet.AttackForce, TurnPrediction);
//planet.TurnPrediction.FindCheapestTakeOverPoint(destinationState.TurnsFromNow, TurnPrediction);
}
}
foreach (AttackPlan plan in possibleTargets.OrderBy(item => - item.Sweetness).Take(10))
{
ExecutePlans(plan);
}
var centerPlanet = currentUniverse.Me.Planets
.OrderBy(item => Universe.Center.Delta(item)).FirstOrDefault();
if (centerPlanet != null)
{
int supportCount = 0;
foreach (var planet in CanUseInAtttack())
{
if (centerPlanet != planet)
{
supportCount++;
currentUniverse.MakeMove(planet, centerPlanet, Math.Min(planet.AttackForce, 2));
}
}
}
//if (!attackMade)
//{
// int targetOwnerId = 0;
// if (!currentUniverse.IsDominating)
// {
// if (rnd.NextDouble() > currentUniverse.Neutral.Planets.Count / (currentUniverse.Enemy.Planets.Count + 0.1))
// {
// targetOwnerId = 2;
// }
// }
// else
// {
// targetOwnerId = 2;
// }
// var target = currentUniverse.Planets.Values
// .Where(planet => planet.LastAttackTurn.NumShips < sumAttackForce - planet.GrowthRate * 2
// && IsNotEventuallyMine(planet)
// && planet.GrowthRate > 1
// && planet.Owner == targetOwnerId
// )
// .OrderBy(planet => -((planet.GrowthRate + Math.Sqrt(planet.NumShips)) / 3) * 3)
// .ThenBy(planet => currentUniverse.Me.ShipOnPlanetFocus.Delta(planet))
// .FirstOrDefault();
// if (target != null)
// {
// AttackPlan plan = new AttackPlan();
// plan.Enabled = true;
// plan.Target = target;
// foreach (var planet in CanUseInAtttack())
// {
// plan.AddParticipant(planet, planet.TurnPrediction[0], target.TurnPrediction[0]);
// }
// attackMade = true;
// ExecutePlans(plan);
// }
//}
//if (!attackMade && sumAttackForce > 100)
//{
// AttackPlan plan = new AttackPlan();
// plan.Enabled = true;
// plan.DominationMove = true;
// plan.Target = centerPlanet;
// foreach (var planet in CanUseInAtttack().Where(item => item != centerPlanet))
// {
// plan.AddParticipant(planet, planet.TurnPrediction[0], centerPlanet.TurnPrediction[0]);
// }
// attackMade = true;
// ExecutePlans(plan);
//}
}
