private void DoPostInvasionDefense(MilitaryTask Task)
{
--this.defenseTurns;
if (this.defenseTurns <= 0)
{
Task.EndTask();
}
else
{
switch (this.TaskStep)
{
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.AO, MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.findAveragePosition(), Task.AO)), Vector2.Normalize(Task.AO - this.findAveragePosition()));
using (List<Ship>.Enumerator enumerator = this.Ships.GetEnumerator())
{
while (enumerator.MoveNext())
enumerator.Current.GetAI().HasPriorityOrder = true;
break;
}
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 flag2 = 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)
flag2 = false;
int num = ship.InCombat ? 1 : 0;
if (!flag2)
break;
}
}
if (!flag2)
break;
this.TaskStep = 2;
this.FormationWarpTo(Task.AO, MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.findAveragePosition(), Task.AO)), Vector2.Normalize(Task.AO - this.findAveragePosition()));
using (List<Ship>.Enumerator enumerator = this.Ships.GetEnumerator())
{
while (enumerator.MoveNext())
enumerator.Current.GetAI().HasPriorityOrder = true;
break;
}
case 2:
bool flag3 = false;
if ((double)Vector2.Distance(this.findAveragePosition(), Task.AO) < 15000.0)
{
foreach (Ship ship in (List<Ship>)this.Ships)
{
lock (ship)
{
if (ship.InCombat)
{
flag3 = true;
ship.HyperspaceReturn();
ship.GetAI().OrderQueue.Clear();
break;
}
}
}
}
if (!flag3 && (double)Vector2.Distance(this.findAveragePosition(), Task.AO) >= 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.loyalty != this.Owner && (ship1.loyalty.isFaction || this.Owner.GetRelations()[ship1.loyalty].AtWar || this.Owner.isFaction) && (!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)
{
if ((double)Vector2.Distance(this.findAveragePosition(), Task.AO) <= 10000.0)
break;
this.FormationWarpTo(Task.AO, 0.0f, new Vector2(0.0f, -1f));
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 (IEnumerable<Ship>)Enumerable.OrderByDescending<Ship, int>((IEnumerable<Ship>)this.EnemyClumpsDict[Enumerable.First<Vector2>((IEnumerable<Vector2>)orderedEnumerable2)], (Func<Ship, int>)(ship => ship.Size)))
{
float num = 0.0f;
foreach (Ship ship in (IEnumerable<Ship>)Enumerable.OrderByDescending<Ship, int>((IEnumerable<Ship>)this.Ships, (Func<Ship, int>)(ship => ship.Size)))
{
if (!list4.Contains(ship) && ((double)num == 0.0 || (double)num < (double)toAttack.GetStrength()))
{
ship.GetAI().OrderAttackSpecificTarget(toAttack);
ship.GetAI().Intercepting = true;
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);
ship.GetAI().Intercepting = true;
}
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 (weapon.BombTroopDamage_Max <= 0)
{
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.649999976158142 * (double)num5 && (double)num1 <= 0.100000001490116 * (double)num2)
{
this.TaskStep = 5;
break;
}
else
{
bool flag4 = false;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.InCombat)
{
flag4 = true;
break;
}
}
if (!flag4)
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 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 DoCohesiveClearAreaOfEnemies(MilitaryTask Task)
{
switch (this.TaskStep)
{
case 0:
this.TaskStep = 1;
this.DoCohesiveClearAreaOfEnemies(Task);
break;
case 1:
List<ThreatMatrix.Pin> list1 = new List<ThreatMatrix.Pin>();
Dictionary<ThreatMatrix.Pin, float> dictionary1 = new Dictionary<ThreatMatrix.Pin, float>();
foreach (KeyValuePair<Guid, ThreatMatrix.Pin> keyValuePair1 in this.Owner.GetGSAI().ThreatMatrix.Pins)
{
if (!(keyValuePair1.Value.EmpireName == this.Owner.data.Traits.Name) && (EmpireManager.GetEmpireByName(keyValuePair1.Value.EmpireName).isFaction || this.Owner.GetRelations()[EmpireManager.GetEmpireByName(keyValuePair1.Value.EmpireName)].AtWar) && (!list1.Contains(keyValuePair1.Value) && (double)Vector2.Distance(keyValuePair1.Value.Position, Task.AO) < (double)Task.AORadius))
{
dictionary1.Add(keyValuePair1.Value, keyValuePair1.Value.Strength);
list1.Add(keyValuePair1.Value);
foreach (KeyValuePair<Guid, ThreatMatrix.Pin> keyValuePair2 in this.Owner.GetGSAI().ThreatMatrix.Pins)
{
if (!(keyValuePair2.Value.EmpireName == this.Owner.data.Traits.Name) && keyValuePair2.Value.EmpireName == keyValuePair1.Value.EmpireName && ((double)Vector2.Distance(keyValuePair1.Value.Position, keyValuePair2.Value.Position) < 150000.0 && !list1.Contains(keyValuePair2.Value)))
{
Dictionary<ThreatMatrix.Pin, float> dictionary2;
ThreatMatrix.Pin index;
(dictionary2 = dictionary1)[index = keyValuePair1.Value] = dictionary2[index] + keyValuePair2.Value.Strength;
}
}
}
}
float strength = this.GetStrength();
this.targetPosition = Vector2.Zero;
foreach (KeyValuePair<ThreatMatrix.Pin, float> keyValuePair in dictionary1)
{
if ((double)strength > (double)keyValuePair.Value * 1.35000002384186 && (double)keyValuePair.Value > 750.0)
this.targetPosition = keyValuePair.Key.Position;
}
if (this.targetPosition != Vector2.Zero)
{
Vector2 fvec = Vector2.Normalize(Task.AO - this.targetPosition);
this.FormationWarpTo(this.targetPosition, Math.Abs(MathHelper.ToRadians(HelperFunctions.findAngleToTarget(this.targetPosition, Task.AO))), fvec);
this.TaskStep = 2;
break;
}
else
{
this.Task.EndTask();
break;
}
case 2:
if ((double)this.Owner.GetGSAI().ThreatMatrix.PingRadarStr(this.targetPosition, 20000f, this.Owner) == 0.0)
{
this.TaskStep = 1;
break;
}
else
{
if ((double)Vector2.Distance(this.targetPosition, this.findAveragePosition()) >= 25000.0)
break;
this.TaskStep = 3;
break;
}
case 3:
this.EnemyClumpsDict.Clear();
List<Ship> list2 = new List<Ship>();
Vector2 averagePosition = this.findAveragePosition();
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.loyalty != this.Owner && (ship1.loyalty.isFaction || this.Owner.GetRelations()[ship1.loyalty].AtWar) && (!list2.Contains(ship1) && (double)Vector2.Distance(ship1.Center, averagePosition) < 50000.0 && !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)
{
Task.EndTask();
break;
}
else
{
List<Vector2> list3 = new List<Vector2>();
foreach (KeyValuePair<Vector2, List<Ship>> keyValuePair in this.EnemyClumpsDict)
list3.Add(keyValuePair.Key);
IOrderedEnumerable<Vector2> orderedEnumerable = 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>)orderedEnumerable)])
{
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 flag = false;
foreach (Ship ship in (List<Ship>)this.Ships)
{
if (!ship.GetAI().BadGuysNear || ship.isInDeepSpace)
{
flag = true;
break;
}
}
if (!flag)
break;
this.TaskStep = 3;
break;
}
case 5:
foreach (Ship ship in (List<Ship>)this.Ships)
ship.GetAI().OrderResupplyNearest();
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)
{
Task.EndTask();
return;
}
else
{
ship.GetAI().HasPriorityOrder = true;
num6 += ship.Ordinance;
num7 += ship.OrdinanceMax;
}
}
if ((double)num6 != (double)num7)
break;
this.TaskStep = 1;
break;
}
}
