protected void DefendOnwedPlanets() { foreach (Planet onwedPlanet in OrderedListOfAttackedPlanets(1)) { #region Try defend any owned planets. bool shouldDefend = onwedPlanet.IsUnderAttack && !onwedPlanet.WinningArmadaIsMine; if (shouldDefend) { AttackPlan defensePlan = BuildDefensePlan(onwedPlanet, 1000); if (onwedPlanet.IsLost) { foreach (var route in onwedPlanet.Routes) { if (route.DistanceInTurns <= onwedPlanet.LastAttackTurn.TurnsFromNow) { Planet target = route.Destination; if (target.IsNeutral && target.MaxDesertersAllowed < onwedPlanet.NumShips) { currentUniverse.MakeMove(onwedPlanet, target, onwedPlanet.NumShips); break; } } else { break; } } //Recapture it the planet provides good resource. if (onwedPlanet.GrowthRate > 2) { currentUniverse.AddToWishList(onwedPlanet); } } else { foreach (AttackPlanParticipant armada in defensePlan.Participants) { currentUniverse.MakeMove(armada.Source, defensePlan.Target, armada.Source.AttackForce); armada.Source.AttackMovesAllowed = false; armada.Source.CreateTurnPredictions(); } onwedPlanet.AttackMovesAllowed = false; onwedPlanet.CreateTurnPredictions(); } } else { } #endregion } }
protected bool ExecutePlans(AttackPlan sweetPlan) { bool movemade = false; foreach (AttackPlanParticipant attacker in sweetPlan.Participants) { Planet agressor = attacker.Source; agressor.IsInAttackQueue = attacker.ScheduledTurn > 0; if (attacker.ScheduledTurn <= 0) { if (attacker.DefendersTurn.Owner != 1 || sweetPlan.DominationMove) { if (agressor.IsMine) { int ships = attacker.AttackersTurn.NumShips; if (!sweetPlan.Target.IsMine) { ships = Math.Min(attacker.DefendersTurn.NumShips + 1, ships); } ships = Math.Min(ships, agressor.AttackForce); currentUniverse.MakeMove(agressor, sweetPlan.Target, ships); movemade = true; agressor.CreateTurnPredictions(); } } } else { //attacker.Source.MaxDesertersAllowed = 0; } attacker.ScheduledTurn--; } if (sweetPlan.Target.IsMine || sweetPlan.Participants.Count == 0) { foreach (AttackPlanParticipant attacker in sweetPlan.Participants) { attacker.Source.IsInAttackQueue = false; } attackQueue.Remove(sweetPlan); } sweetPlan.Target.AttackMovesAllowed = false; return(movemade); }
protected void DefendNeutralPlanets(int maxTurnLookahead) { foreach (Planet neutralPlanet in OrderedListOfAttackedPlanets(0)) { #region Try defend any owned planets. //if we have ships invested, protect investment, bool shouldDefend = neutralPlanet.IsUnderAttack && !neutralPlanet.WinningArmadaIsMine && !neutralPlanet.DoesNotChangeOwner; if (shouldDefend) { AttackPlan defensePlan = BuildDefensePlan(neutralPlanet, maxTurnLookahead); if (!neutralPlanet.IsLost) { foreach (AttackPlanParticipant armada in defensePlan.Participants) { currentUniverse.MakeMove(armada.Source, defensePlan.Target, armada.Source.AttackForce); } neutralPlanet.AttackMovesAllowed = false; } } #endregion } }
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); }
protected abstract void CreateAttackPlanForOwnedPlanet(AttackPlan attack, Route attackRoute, PlanetaryTravelRoute planetTravelMap, ref bool continueRoute);
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 AttackPlan BuildDefensePlan(Planet planetUnderAttack, int maxTurnLookAhead) { AttackPlan defensePlan = new AttackPlan(); defensePlan.Target = planetUnderAttack; defensePlan.Reason = "Defense"; planetUnderAttack.IsLost = !planetUnderAttack.WinningArmadaIsMine; PlanetTurn turn = planetUnderAttack.TurnPrediction.FirstTurn; int defenseRequired = 0; if (turn != null) { //this is weird, we are in no danger of losing the planet still this method was called. Abort. if (planetUnderAttack.WinningArmadaIsMine) { return(defensePlan); } //the next turns tells me how many ships I needed, only works if my fleet was not the winning fleet. //that's why the previous exit. defenseRequired = planetUnderAttack.TurnPrediction[turn.TurnsFromNow + 1].NumShips + 1; } else { // So apparently I did not lose ownership of the planet, which means I never did own it. //see if we can block the attack. turn = planetUnderAttack.TurnPrediction.FirstTurn; defenseRequired = turn.NumShips; } int armadaVictoryTurn = turn.TurnsFromNow; //if we want to recapture the planet the next turn how many ships do we need. //Since the enemy gets reinforces immediately after a capture, we are at a -GrowthRate disadvantage. int maxWorthItDistance; switch (planetUnderAttack.GrowthRate) { case 0: case 1: maxWorthItDistance = 5; break; case 2: maxWorthItDistance = 10; break; case 3: case 4: maxWorthItDistance = 15; break; default: maxWorthItDistance = 25; break; } //defend, remember, it's sorted on distance so the closest planets are considered first. foreach (Route route in planetUnderAttack.Routes) { if (route.DistanceInTurns <= Math.Min(maxTurnLookAhead, maxWorthItDistance)) { //look for planet with defense capability Planet defender = route.Destination; if (defender.IsMine && planetUnderAttack.PlanetID != defender.PlanetID) { //is it close enough to contribute to the defense? int defenseTravelTime = (route.DistanceInTurns - 1); if (defenseTravelTime <= armadaVictoryTurn + 1) { //How many ships can we use int maxDelivarableShips = defender.AttackForce; if (defender.DoesNotChangeOwner) { int turnIndex = Math.Max(armadaVictoryTurn - defenseTravelTime, 0); maxDelivarableShips = defender.TurnPrediction[turnIndex].NumShips; } if (maxDelivarableShips > 0) { int prevRequired = defenseRequired; defenseRequired -= maxDelivarableShips; if (defender.NumShips > 0) { defensePlan.Enabled = true; int shipCount; if (defenseRequired > -1) { shipCount = Math.Min(defender.AttackForce, defender.NumShips); defensePlan.AddParticipant(defender, null, shipCount); } else { shipCount = Math.Min(Math.Min(defender.AttackForce, defender.NumShips), prevRequired); defensePlan.AddParticipant(defender, null, shipCount); break; } } } } } } } if (defenseRequired < 0) { planetUnderAttack.DoesNotChangeOwner = true; planetUnderAttack.AttackMovesAllowed = false; planetUnderAttack.IsLost = false; } //Planet is lost, no defense plan. if (planetUnderAttack.IsLost) { defensePlan.Participants.Clear(); } return(defensePlan); }
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); //} }