private void DoGlassPlanet(MilitaryTask Task)
{
if (Task.GetTargetPlanet().Owner == this.Owner || Task.GetTargetPlanet().Owner == null)
Task.EndTask();
else if (Task.GetTargetPlanet().Owner != null & Task.GetTargetPlanet().Owner != this.Owner && !Task.GetTargetPlanet().Owner.GetRelations()[this.Owner].AtWar)
{
Task.EndTask();
}
else
{
switch (this.TaskStep)
{
case 0:
List<Planet> list1 = new List<Planet>();
foreach (Planet planet in this.Owner.GetPlanets())
{
if (planet.HasShipyard)
list1.Add(planet);
}
IOrderedEnumerable<Planet> orderedEnumerable1 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list1, (Func<Planet, float>)(planet => Vector2.Distance(Task.AO, planet.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable1) <= 0)
break;
Vector2 fVec = Vector2.Normalize(Task.AO - Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position);
Vector2 vector2 = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position;
this.MoveToNow(vector2, Math.Abs(MathHelper.ToRadians(HelperFunctions.findAngleToTarget(vector2, Task.AO))), fVec);
this.TaskStep = 1;
break;
case 1:
bool flag = true;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.disabled && ship.hasCommand && ship.Active)
{
if ((double)Vector2.Distance(ship.Center, this.Position + ship.FleetOffset) > 15000.0)
flag = false;
int num = ship.InCombat ? 1 : 0;
if (!flag)
break;
}
}
if (!flag)
break;
Vector2 MovePosition = Task.GetTargetPlanet().Position + Vector2.Normalize(this.findAveragePosition() - Task.GetTargetPlanet().Position) * 150000f;
this.Position = MovePosition;
this.FormationWarpTo(MovePosition, MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.findAveragePosition(), Task.AO)), Vector2.Normalize(Task.AO - this.findAveragePosition()));
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().HasPriorityOrder = true;
this.TaskStep = 2;
break;
case 2:
if (Task.WaitForCommand && (double)this.Owner.GetGSAI().ThreatMatrix.PingRadarStr(Task.GetTargetPlanet().Position, 30000f, this.Owner) > 250.0)
break;
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().OrderBombardPlanet(Task.GetTargetPlanet());
this.TaskStep = 4;
break;
case 4:
float num1 = 0.0f;
float num2 = 0.0f;
float num3 = 0.0f;
float num4 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
num1 += ship.Ordinance;
num2 += ship.OrdinanceMax;
foreach (Weapon weapon in ship.Weapons)
{
if ((double)weapon.OrdinanceRequiredToFire > 0.0)
num3 = weapon.DamageAmount / weapon.fireDelay;
if ((double)weapon.PowerRequiredToFire > 0.0)
num4 = weapon.DamageAmount / weapon.fireDelay;
}
}
float num5 = num3 + num4;
if ((double)num3 >= 0.5 * (double)num5 && (double)num1 <= 0.100000001490116 * (double)num2)
{
this.TaskStep = 5;
break;
}
else
{
this.TaskStep = 2;
break;
}
case 5:
List<Planet> list2 = new List<Planet>();
foreach (Planet planet in this.Owner.GetPlanets())
{
if (planet.HasShipyard)
list2.Add(planet);
}
IOrderedEnumerable<Planet> orderedEnumerable2 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list2, (Func<Planet, float>)(p => Vector2.Distance(this.Position, p.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable2) <= 0)
break;
this.Position = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable2).Position;
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().OrderResupply(Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable2), true);
this.TaskStep = 6;
break;
case 6:
float num6 = 0.0f;
float num7 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (ship.GetAI().State != AIState.Resupply)
{
this.TaskStep = 5;
return;
}
else
{
ship.GetAI().HasPriorityOrder = true;
num6 += ship.Ordinance;
num7 += ship.OrdinanceMax;
}
}
if ((double)num6 != (double)num7)
break;
this.TaskStep = 0;
break;
}
}
}
private void DoClaimDefense(MilitaryTask Task)
{
switch (this.TaskStep)
{
case 0:
List<Planet> list1 = new List<Planet>();
foreach (Planet planet in this.Owner.GetPlanets())
{
if (planet.HasShipyard)
list1.Add(planet);
}
IOrderedEnumerable<Planet> orderedEnumerable1 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list1, (Func<Planet, float>)(planet => Vector2.Distance(Task.AO, planet.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable1) <= 0)
break;
Vector2 fVec = Vector2.Normalize(Task.GetTargetPlanet().Position - Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position);
Vector2 vector2 = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position;
this.MoveToNow(vector2, Math.Abs(MathHelper.ToRadians(HelperFunctions.findAngleToTarget(vector2, Task.GetTargetPlanet().Position))), fVec);
this.TaskStep = 1;
break;
case 1:
bool flag1 = true;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.disabled && ship.hasCommand && ship.Active)
{
if ((double)Vector2.Distance(ship.Center, this.Position + ship.FleetOffset) > 5000.0)
flag1 = false;
int num = ship.InCombat ? 1 : 0;
if (!flag1)
break;
}
}
if (!flag1)
break;
this.TaskStep = 2;
this.FormationWarpTo(Task.GetTargetPlanet().Position, MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.findAveragePosition(), Task.GetTargetPlanet().Position)), Vector2.Normalize(Task.GetTargetPlanet().Position - this.findAveragePosition()));
using (List<Ship>.Enumerator enumerator = this.Ships.GetEnumerator())
{
while (enumerator.MoveNext())
enumerator.Current.GetAI().HasPriorityOrder = true;
break;
}
case 2:
bool flag2 = false;
if ((double)Vector2.Distance(this.findAveragePosition(), Task.GetTargetPlanet().Position) < 15000.0)
{
foreach (Ship ship in (List<Ship>)this.Ships)
{
lock (ship)
{
if (ship.InCombat)
{
flag2 = true;
ship.HyperspaceReturn();
ship.GetAI().OrderQueue.Clear();
break;
}
}
}
}
if (!flag2 && (double)Vector2.Distance(this.findAveragePosition(), Task.GetTargetPlanet().Position) >= 5000.0)
break;
this.TaskStep = 3;
break;
case 3:
this.EnemyClumpsDict.Clear();
List<Ship> list2 = new List<Ship>();
List<GameplayObject> nearby1 = UniverseScreen.ShipSpatialManager.GetNearby(this.Position);
for (int index1 = 0; index1 < nearby1.Count; ++index1)
{
Ship ship1 = nearby1[index1] as Ship;
if (ship1 != null)
{
ship1.GetAI().HasPriorityOrder = false;
if (ship1.loyalty != this.Owner && (ship1.loyalty.isFaction || this.Owner.GetRelations()[ship1.loyalty].AtWar || ship1.isColonyShip && !this.Owner.GetRelations()[ship1.loyalty].Treaty_NAPact) && (!list2.Contains(ship1) && (double)Vector2.Distance(ship1.Center, Task.GetTargetPlanet().Position) < (double)Task.AORadius && !this.EnemyClumpsDict.ContainsKey(ship1.Center)))
{
this.EnemyClumpsDict.Add(ship1.Center, new List<Ship>());
this.EnemyClumpsDict[ship1.Center].Add(ship1);
list2.Add(ship1);
List<GameplayObject> nearby2 = UniverseScreen.ShipSpatialManager.GetNearby(this.Position);
for (int index2 = 0; index2 < nearby2.Count; ++index2)
{
Ship ship2 = nearby2[index2] as Ship;
if (ship2 != null && ship2.loyalty != this.Owner && (ship2.loyalty == ship1.loyalty && (double)Vector2.Distance(ship1.Center, ship2.Center) < 10000.0) && !list2.Contains(ship2))
this.EnemyClumpsDict[ship1.Center].Add(ship2);
}
}
}
}
if (this.EnemyClumpsDict.Count == 0)
{
using (List<Ship>.Enumerator enumerator = this.Ships.GetEnumerator())
{
while (enumerator.MoveNext())
{
Ship current = enumerator.Current;
if (!(current.GetAI().State == AIState.Orbit ))
current.GetAI().OrderOrbitPlanet(Task.GetTargetPlanet());
else if (current.GetAI().State == AIState.Orbit && (current.GetAI().OrbitTarget == null || current.GetAI().OrbitTarget != null && current.GetAI().OrbitTarget != Task.GetTargetPlanet()))
current.GetAI().OrderOrbitPlanet(Task.GetTargetPlanet());
}
break;
}
}
else
{
List<Vector2> list3 = new List<Vector2>();
foreach (KeyValuePair<Vector2, List<Ship>> keyValuePair in this.EnemyClumpsDict)
list3.Add(keyValuePair.Key);
IOrderedEnumerable<Vector2> orderedEnumerable2 = Enumerable.OrderBy<Vector2, float>((IEnumerable<Vector2>)list3, (Func<Vector2, float>)(clumpPos => Vector2.Distance(this.findAveragePosition(), clumpPos)));
List<Ship> list4 = new List<Ship>();
foreach (Ship toAttack in this.EnemyClumpsDict[Enumerable.First<Vector2>((IEnumerable<Vector2>)orderedEnumerable2)])
{
float num = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!list4.Contains(ship) && ((double)num == 0.0 || (double)num < (double)toAttack.GetStrength()))
{
ship.GetAI().Intercepting = true;
ship.GetAI().OrderAttackSpecificTarget(toAttack);
list4.Add(ship);
num += ship.GetStrength();
}
}
}
List<Ship> list5 = new List<Ship>();
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!list4.Contains(ship))
list5.Add(ship);
}
foreach (Ship ship in list5)
{
ship.GetAI().Intercepting = true;
ship.GetAI().OrderAttackSpecificTarget(list4[0].GetAI().Target as Ship);
}
this.TaskStep = 4;
break;
}
case 4:
float num1 = 0.0f;
float num2 = 0.0f;
float num3 = 0.0f;
float num4 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
num1 += ship.Ordinance;
num2 += ship.OrdinanceMax;
foreach (Weapon weapon in ship.Weapons)
{
if ((double)weapon.OrdinanceRequiredToFire > 0.0)
num3 = weapon.DamageAmount / weapon.fireDelay;
if ((double)weapon.PowerRequiredToFire > 0.0)
num4 = weapon.DamageAmount / weapon.fireDelay;
}
}
float num5 = num3 + num4;
if ((double)num3 >= 0.5 * (double)num5 && (double)num1 <= 0.100000001490116 * (double)num2)
{
this.TaskStep = 5;
break;
}
else
{
bool flag3 = false;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.InCombat)
{
flag3 = true;
break;
}
}
if (!flag3)
break;
this.TaskStep = 3;
break;
}
case 5:
List<Planet> list6 = new List<Planet>();
foreach (Planet planet in this.Owner.GetPlanets())
{
if (planet.HasShipyard)
list6.Add(planet);
}
IOrderedEnumerable<Planet> orderedEnumerable3 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list6, (Func<Planet, float>)(p => Vector2.Distance(this.Position, p.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable3) <= 0)
break;
this.Position = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable3).Position;
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().OrderResupply(Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable3), true);
this.TaskStep = 6;
break;
case 6:
float num6 = 0.0f;
float num7 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
ship.GetAI().HasPriorityOrder = true;
num6 += ship.Ordinance;
num7 += ship.OrdinanceMax;
}
if ((double)num6 != (double)num7)
break;
this.TaskStep = 0;
break;
}
}
private void DoExplorePlanet(MilitaryTask Task)
{
bool flag1 = true;
foreach (Building building in Task.GetTargetPlanet().BuildingList)
{
if (!string.IsNullOrEmpty(building.EventTriggerUID))
{
flag1 = false;
break;
}
}
bool flag2 = false;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (ship.TroopList.Count > 0)
flag2 = true;
}
foreach (PlanetGridSquare planetGridSquare in Task.GetTargetPlanet().TilesList)
{
if (planetGridSquare.TroopsHere.Count > 0 && planetGridSquare.TroopsHere[0].GetOwner() == this.Owner)
{
flag2 = true;
break;
}
}
if (flag1 || !flag2 || Task.GetTargetPlanet().Owner != null)
{
Task.EndTask();
}
else
{
switch (this.TaskStep)
{
case 0:
List<Planet> list1 = new List<Planet>();
foreach (Planet planet in this.Owner.GetPlanets())
{
if (planet.HasShipyard)
list1.Add(planet);
}
IOrderedEnumerable<Planet> orderedEnumerable1 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list1, (Func<Planet, float>)(planet => Vector2.Distance(Task.AO, planet.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable1) <= 0)
break;
Vector2 fVec = Vector2.Normalize(Task.AO - Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position);
Vector2 vector2 = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position;
this.MoveToNow(vector2, Math.Abs(MathHelper.ToRadians(HelperFunctions.findAngleToTarget(vector2, Task.AO))), fVec);
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().HasPriorityOrder = true;
this.TaskStep = 1;
break;
case 1:
bool flag3 = true;
bool flag4 = false;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.disabled && ship.hasCommand && ship.Active)
{
if ((double)Vector2.Distance(ship.Center, this.Position + ship.FleetOffset) > 5000.0)
flag3 = false;
if (ship.InCombat)
flag4 = true;
if (!flag3)
break;
}
}
if (!flag3 && !flag4)
break;
this.TaskStep = 2;
Vector2 MovePosition = Task.GetTargetPlanet().Position + Vector2.Normalize(this.findAveragePosition() - Task.GetTargetPlanet().Position) * 50000f;
this.Position = MovePosition;
this.FormationWarpTo(MovePosition, MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.findAveragePosition(), Task.AO)), Vector2.Normalize(Task.AO - this.findAveragePosition()));
break;
case 2:
bool flag5 = true;
foreach (Ship ship in (List<Ship>)this.Ships)
{
ship.GetAI().HasPriorityOrder = false;
if (!ship.disabled && ship.hasCommand && ship.Active)
{
if ((double)Vector2.Distance(ship.Center, this.Position + ship.FleetOffset) > 5000.0)
flag5 = false;
if (!flag5)
break;
}
}
if (!flag5)
break;
foreach (Ship ship in (List<Ship>)this.Ships)
{
ship.GetAI().State = AIState.HoldPosition;
if (ship.Role == "troop")
ship.GetAI().HoldPosition();
}
this.InterceptorDict.Clear();
this.TaskStep = 3;
break;
case 3:
this.EnemyClumpsDict.Clear();
List<Ship> list2 = new List<Ship>();
List<GameplayObject> nearby1 = UniverseScreen.ShipSpatialManager.GetNearby(this.Position);
for (int index1 = 0; index1 < nearby1.Count; ++index1)
{
Ship ship1 = nearby1[index1] as Ship;
if (ship1 != null)
{
ship1.GetAI().HasPriorityOrder = false;
if (ship1.loyalty != this.Owner && (ship1.loyalty.isFaction || this.Owner.GetRelations()[ship1.loyalty].AtWar) && (!list2.Contains(ship1) && (double)Vector2.Distance(ship1.Center, Task.AO) < (double)Task.AORadius && !this.EnemyClumpsDict.ContainsKey(ship1.Center)))
{
this.EnemyClumpsDict.Add(ship1.Center, new List<Ship>());
this.EnemyClumpsDict[ship1.Center].Add(ship1);
list2.Add(ship1);
List<GameplayObject> nearby2 = UniverseScreen.ShipSpatialManager.GetNearby(this.Position);
for (int index2 = 0; index2 < nearby2.Count; ++index2)
{
Ship ship2 = nearby2[index2] as Ship;
if (ship2 != null && ship2.loyalty != this.Owner && (ship2.loyalty == ship1.loyalty && (double)Vector2.Distance(ship1.Center, ship2.Center) < 10000.0) && !list2.Contains(ship2))
this.EnemyClumpsDict[ship1.Center].Add(ship2);
}
}
}
}
if (this.EnemyClumpsDict.Count == 0)
{
this.TaskStep = 5;
break;
}
else
{
List<Vector2> list3 = new List<Vector2>();
foreach (KeyValuePair<Vector2, List<Ship>> keyValuePair in this.EnemyClumpsDict)
list3.Add(keyValuePair.Key);
IOrderedEnumerable<Vector2> orderedEnumerable2 = Enumerable.OrderBy<Vector2, float>((IEnumerable<Vector2>)list3, (Func<Vector2, float>)(clumpPos => Vector2.Distance(this.findAveragePosition(), clumpPos)));
List<Ship> list4 = new List<Ship>();
foreach (Ship toAttack in this.EnemyClumpsDict[Enumerable.First<Vector2>((IEnumerable<Vector2>)orderedEnumerable2)])
{
float num = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!list4.Contains(ship) && ((double)num == 0.0 || (double)num < (double)toAttack.GetStrength()))
{
ship.GetAI().Intercepting = true;
ship.GetAI().OrderAttackSpecificTarget(toAttack);
list4.Add(ship);
num += ship.GetStrength();
}
}
}
List<Ship> list5 = new List<Ship>();
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!list4.Contains(ship))
list5.Add(ship);
}
foreach (Ship ship in list5)
ship.GetAI().OrderAttackSpecificTarget(list4[0].GetAI().Target as Ship);
this.TaskStep = 4;
if (this.InterceptorDict.Count != 0)
break;
this.TaskStep = 4;
break;
}
case 4:
float num1 = 0.0f;
float num2 = 0.0f;
float num3 = 0.0f;
float num4 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
num1 += ship.Ordinance;
num2 += ship.OrdinanceMax;
foreach (Weapon weapon in ship.Weapons)
{
if ((double)weapon.OrdinanceRequiredToFire > 0.0)
num3 = weapon.DamageAmount / weapon.fireDelay;
if ((double)weapon.PowerRequiredToFire > 0.0)
num4 = weapon.DamageAmount / weapon.fireDelay;
}
}
float num5 = num3 + num4;
if ((double)num3 >= 0.5 * (double)num5 && (double)num1 <= 0.100000001490116 * (double)num2)
{
this.TaskStep = 5;
break;
}
else
{
bool flag6 = false;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.InCombat)
{
flag6 = true;
break;
}
}
if (!flag6)
break;
this.TaskStep = 3;
break;
}
case 5:
foreach (Ship ship in (List<Ship>)this.Ships)
{
ship.GetAI().Intercepting = true;
ship.GetAI().OrderLandAllTroops(Task.GetTargetPlanet());
}
this.Position = Task.GetTargetPlanet().Position;
this.AssembleFleet(this.facing, Vector2.Normalize(this.Position - this.findAveragePosition()));
break;
}
}
}
private void DoAssaultPlanet(MilitaryTask Task)
{
if (Task.GetTargetPlanet().Owner == this.Owner || Task.GetTargetPlanet().Owner == null || Task.GetTargetPlanet().Owner != null && !this.Owner.GetRelations()[Task.GetTargetPlanet().Owner].AtWar)
{
if (Task.GetTargetPlanet().Owner == this.Owner)
{
MilitaryTask militaryTask = new MilitaryTask();
militaryTask.AO = Task.GetTargetPlanet().Position;
militaryTask.AORadius = 50000f;
militaryTask.WhichFleet = Task.WhichFleet;
militaryTask.SetEmpire(this.Owner);
militaryTask.type = MilitaryTask.TaskType.DefendPostInvasion;
this.Owner.GetGSAI().TaskList.QueuePendingRemoval(Task);
this.Task = militaryTask;
lock (GlobalStats.TaskLocker)
this.Owner.GetGSAI().TaskList.Add(Task);
}
else
Task.EndTask();
}
else
{
float num1 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
num1 += ship.GetStrength();
if ((double)num1 == 0.0)
Task.EndTask();
int num2 = 0;
int num3 = 0;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if ((double)ship.GetStrength() > 0.0)
++num3;
num2 += ship.TroopList.Count;
}
if (num2 == 0)
{
foreach (Troop troop in Task.GetTargetPlanet().TroopsHere)
{
if (troop.GetOwner() == this.Owner)
++num2;
}
}
if (num2 == 0 || num3 == 0)
{
if (num3 == 0)
Task.IsCoreFleetTask = false;
Task.EndTask();
this.Task = (MilitaryTask)null;
this.TaskStep = 0;
}
else
{
switch (this.TaskStep)
{
case 0:
List<Planet> list1 = new List<Planet>();
this.Owner.GetPlanets().thisLock.EnterReadLock();
foreach (Planet planet in this.Owner.GetPlanets().OrderBy(combat=> combat.ParentSystem.DangerTimer))
{
if (planet.HasShipyard )
list1.Add(planet);
}
this.Owner.GetPlanets().thisLock.ExitReadLock();
IOrderedEnumerable<Planet> orderedEnumerable1 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list1, (Func<Planet, float>)(planet => Vector2.Distance(Task.AO, planet.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable1) > 0)
{
Vector2 fVec = Vector2.Normalize(Task.AO - Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position);
Vector2 vector2 = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable1).Position;
this.MoveToNow(vector2, Math.Abs(MathHelper.ToRadians(HelperFunctions.findAngleToTarget(vector2, Task.AO))), fVec);
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().HasPriorityOrder = true;
this.TaskStep = 1;
break;
}
else
{
Task.EndTask();
break;
}
case 1:
bool flag1 = true;
this.Ships.thisLock.EnterReadLock();
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.disabled && ship.hasCommand && ship.Active)
{
if ((double)Vector2.Distance(ship.Center, this.Position + ship.FleetOffset) > 5000.0)
{
flag1 = false;
this.Ships.thisLock.ExitReadLock();
}
else if (ship.GetAI().BadGuysNear)
{
this.Ships.thisLock.ExitReadLock();
Task.EndTask();
flag1 = false;
}
int num4 = ship.InCombat ? 1 : 0;
if (!flag1)
break;
}
}
if (!flag1)
break;
this.Ships.thisLock.ExitReadLock();
this.TaskStep = 2;
Vector2 MovePosition = Task.GetTargetPlanet().Position + Vector2.Normalize(this.findAveragePosition() - Task.GetTargetPlanet().Position) * 125000f;
this.Position = MovePosition;
this.FormationWarpTo(MovePosition, MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.findAveragePosition(), Task.AO)), Vector2.Normalize(Task.AO - this.findAveragePosition()));
break;
case 2:
bool flag2 = true;
this.Ships.thisLock.EnterReadLock();
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.disabled && ship.hasCommand && ship.Active)
{
if ((double)Vector2.Distance(ship.Center, this.Position + ship.FleetOffset) > 25000.0)
flag2 = false;
if (!flag2)
break;
}
}
this.Ships.thisLock.ExitReadLock();
if (!flag2)
break;
this.Ships.thisLock.EnterReadLock();
foreach (Ship ship in (List<Ship>)this.Ships)
{
ship.GetAI().HasPriorityOrder = false;
ship.GetAI().State = AIState.HoldPosition;
if (ship.BombBays.Count > 0)
ship.GetAI().OrderBombardPlanet(Task.GetTargetPlanet());
else if (ship.Role == "troop")
ship.GetAI().HoldPosition();
}
this.Ships.thisLock.ExitReadLock();
this.InterceptorDict.Clear();
this.TaskStep = 3;
break;
case 3:
float num5 = 0.0f;
float num6 = 0.0f;
float num7 = 0.0f;
float num8 = 0.0f;
this.Ships.thisLock.EnterReadLock();
foreach (Ship ship in (List<Ship>)this.Ships)
{
num5 += ship.Ordinance;
num6 += ship.OrdinanceMax;
foreach (Weapon weapon in ship.Weapons)
{
if ((double)weapon.OrdinanceRequiredToFire > 0.0)
num7 = weapon.DamageAmount / weapon.fireDelay;
if ((double)weapon.PowerRequiredToFire > 0.0)
num8 = weapon.DamageAmount / weapon.fireDelay;
}
}
this.Ships.thisLock.ExitReadLock();
float num9 = num7 + num8;
if ((double)num7 >= 0.5 * (double)num9 && (double)num5 <= 0.100000001490116 * (double)num6)
{
this.TaskStep = 5;
break;
}
else
{
foreach (Ship key in (List<Ship>)Task.GetTargetPlanet().system.ShipList)
{
if (key.loyalty != this.Owner && (key.loyalty.isFaction || this.Owner.GetRelations()[key.loyalty].AtWar) && ((double)Vector2.Distance(key.Center, Task.GetTargetPlanet().Position) < 15000.0 && !this.InterceptorDict.ContainsKey(key)))
this.InterceptorDict.Add(key, new List<Ship>());
}
List<Ship> list2 = new List<Ship>();
foreach (KeyValuePair<Ship, List<Ship>> keyValuePair in this.InterceptorDict)
{
List<Ship> list3 = new List<Ship>();
if ((double)Vector2.Distance(keyValuePair.Key.Center, Task.GetTargetPlanet().Position) > 20000.0 || !keyValuePair.Key.Active)
{
list2.Add(keyValuePair.Key);
foreach (Ship ship in keyValuePair.Value)
{
lock (ship)
{
ship.GetAI().OrderQueue.Clear();
ship.GetAI().Intercepting = false;
ship.GetAI().OrderOrbitPlanet(Task.GetTargetPlanet());
ship.GetAI().State = AIState.AwaitingOrders;
ship.GetAI().Intercepting = false;
}
}
}
foreach (Ship ship in keyValuePair.Value)
{
if (!ship.Active)
list3.Add(ship);
}
foreach (Ship ship in list3)
keyValuePair.Value.Remove(ship);
}
foreach (Ship key in list2)
this.InterceptorDict.Remove(key);
foreach (KeyValuePair<Ship, List<Ship>> keyValuePair1 in this.InterceptorDict)
{
List<Ship> list3 = new List<Ship>();
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (ship.Role != "troop")
list3.Add(ship);
}
List<Ship> list4 = new List<Ship>();
foreach (KeyValuePair<Ship, List<Ship>> keyValuePair2 in this.InterceptorDict)
{
list4.Add(keyValuePair2.Key);
foreach (Ship ship in keyValuePair2.Value)
list3.Remove(ship);
}
foreach (Ship toAttack in (IEnumerable<Ship>)Enumerable.OrderByDescending<Ship, float>((IEnumerable<Ship>)list4, (Func<Ship, float>)(ship => ship.GetStrength())))
{
IOrderedEnumerable<Ship> orderedEnumerable2 = Enumerable.OrderByDescending<Ship, float>((IEnumerable<Ship>)list3, (Func<Ship, float>)(ship => ship.GetStrength()));
float num4 = 0.0f;
foreach (Ship ship in (IEnumerable<Ship>)orderedEnumerable2)
{
if ((double)num4 != 0.0)
{
if ((double)num4 >= (double)toAttack.GetStrength() * 1.5)
break;
}
ship.GetAI().Intercepting = true;
list3.Remove(ship);
ship.GetAI().OrderAttackSpecificTarget(toAttack);
this.InterceptorDict[toAttack].Add(ship);
num4 += ship.GetStrength();
}
}
}
if (this.InterceptorDict.Count == 0 || (double)this.Owner.GetGSAI().ThreatMatrix.PingRadarStr(Task.GetTargetPlanet().Position, 25000f, this.Owner) < 500.0)
this.TaskStep = 4;
lock (GlobalStats.TaskLocker)
{
this.Owner.GetGSAI().TaskList.thisLock.EnterReadLock();
using (List<MilitaryTask>.Enumerator resource_0 = this.Owner.GetGSAI().TaskList.GetEnumerator())
{
while (resource_0.MoveNext())
{
MilitaryTask local_43 = resource_0.Current;
if (local_43.WaitForCommand && local_43.GetTargetPlanet() != null && local_43.GetTargetPlanet() == Task.GetTargetPlanet())
local_43.WaitForCommand = false;
}
this.Owner.GetGSAI().TaskList.thisLock.ExitReadLock();
break;
}
this.Owner.GetGSAI().TaskList.thisLock.ExitReadLock();
}
}
case 4:
int num10 = 0;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (ship.BombBays.Count > 0 && (double)ship.Ordinance / (double)ship.OrdinanceMax > 0.200000002980232)
{
num10 += ship.BombBays.Count;
ship.GetAI().OrderBombardPlanet(Task.GetTargetPlanet());
}
}
float num11 = 0.0f;
float num12 = 0.0f;
float num13 = 0.0f;
float num14 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
num11 += ship.Ordinance;
num12 += ship.OrdinanceMax;
foreach (Weapon weapon in ship.Weapons)
{
if ((double)weapon.OrdinanceRequiredToFire > 0.0)
num13 = weapon.DamageAmount / weapon.fireDelay;
if ((double)weapon.PowerRequiredToFire > 0.0)
num14 = weapon.DamageAmount / weapon.fireDelay;
}
}
float num15 = num13 + num14;
if ((double)num13 >= 0.5 * (double)num15 && (double)num11 <= 0.100000001490116 * (double)num12)
{
this.TaskStep = 5;
break;
}
else
{
bool flag3 = true;
float groundStrOfPlanet = this.GetGroundStrOfPlanet(Task.GetTargetPlanet());
float num4 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
foreach (Troop troop in ship.TroopList)
num4 += (float)troop.Strength;
}
if ((double)num4 > (double)groundStrOfPlanet || num10 < 6)
{
flag3 = true;
}
else
{
int num16 = 0;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (ship.BombBays.Count > 0)
{
++num16;
if ((double)ship.Ordinance / (double)ship.OrdinanceMax > 0.200000002980232)
{
flag3 = false;
break;
}
}
}
if (num16 == 0)
flag3 = true;
}
if (flag3)
{
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (ship.BombBays.Count > 0)
{
ship.GetAI().State = AIState.AwaitingOrders;
ship.GetAI().OrderQueue.Clear();
}
}
this.Position = Task.GetTargetPlanet().Position;
this.AssembleFleet(this.facing, Vector2.Normalize(this.Position - this.findAveragePosition()));
using (List<Ship>.Enumerator enumerator = this.Ships.GetEnumerator())
{
while (enumerator.MoveNext())
enumerator.Current.GetAI().OrderLandAllTroops(Task.GetTargetPlanet());
break;
}
}
else
{
this.Ships.thisLock.EnterReadLock();
using (List<Ship>.Enumerator enumerator = this.Ships.GetEnumerator())
{
while (enumerator.MoveNext())
{
Ship current = enumerator.Current;
if (current.BombBays.Count > 0)
current.GetAI().OrderBombardPlanet(Task.GetTargetPlanet());
}
this.Ships.thisLock.ExitReadLock();
break;
}
this.Ships.thisLock.ExitReadLock();
}
}
case 5:
List<Planet> list5 = new List<Planet>();
this.Owner.GetPlanets().thisLock.EnterReadLock();
foreach (Planet planet in this.Owner.GetPlanets())
{
if (planet.HasShipyard)
list5.Add(planet);
}
this.Owner.GetPlanets().thisLock.ExitReadLock();
IOrderedEnumerable<Planet> orderedEnumerable3 = Enumerable.OrderBy<Planet, float>((IEnumerable<Planet>)list5, (Func<Planet, float>)(p => Vector2.Distance(this.Position, p.Position)));
if (Enumerable.Count<Planet>((IEnumerable<Planet>)orderedEnumerable3) > 0)
{
this.Position = Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable3).Position;
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().OrderResupply(Enumerable.First<Planet>((IEnumerable<Planet>)orderedEnumerable3), true);
this.TaskStep = 6;
break;
}
else
{
Task.EndTask();
break;
}
case 6:
float num17 = 0.0f;
float num18 = 0.0f;
foreach (Ship ship in (List<Ship>)this.Ships)
{
ship.GetAI().HasPriorityOrder = true;
num17 += ship.Ordinance;
num18 += ship.OrdinanceMax;
}
if ((double)num17 < (double)num18 * 0.899999976158142)
break;
this.TaskStep = 0;
break;
}
}
}
}
