public Amplitude.Unity.Game.Orders.Order CreateArmyFromMixedArmy(BaseNavyArmy army)
{
if (!this.IsMixed(army))
{
return(null);
}
if (!base.HasMovementLeft(army))
{
return(null);
}
WorldPosition armyPosition = WorldPosition.Invalid;
PathfindingMovementCapacity movementCapacity = PathfindingMovementCapacity.Water;
for (int i = 0; i < 6; i++)
{
WorldPosition neighbourTile = this.worldPositionService.GetNeighbourTile(army.Garrison.WorldPosition, (WorldOrientation)i, 1);
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourTile, movementCapacity))
{
armyPosition = neighbourTile;
break;
}
}
bool flag = false;
List <GameEntityGUID> list = new List <GameEntityGUID>();
for (int j = 0; j < army.Garrison.StandardUnits.Count; j++)
{
if (flag == army.Garrison.StandardUnits[j].IsSeafaring)
{
list.Add(army.Garrison.StandardUnits[j].GUID);
}
}
return(new OrderTransferGarrisonToNewArmy(army.Garrison.Empire.Index, army.Garrison.GUID, list.ToArray(), armyPosition, null, false, true, true));
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
List <GameEntityGUID> list = new List <GameEntityGUID>();
int num = 0;
PathfindingMovementCapacity pathfindingMovementCapacity = PathfindingMovementCapacity.None;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is Unit)
{
Unit unit = parameters[i] as Unit;
num += (int)unit.GetPropertyValue(SimulationProperties.UnitSlotCount);
list.Add(unit.GUID);
pathfindingMovementCapacity = unit.GenerateContext().MovementCapacities;
}
else
{
if (!(parameters[i] is IEnumerable <Unit>))
{
return;
}
foreach (Unit unit2 in (parameters[i] as IEnumerable <Unit>))
{
num += (int)unit2.GetPropertyValue(SimulationProperties.UnitSlotCount);
list.Add(unit2.GUID);
if (pathfindingMovementCapacity == PathfindingMovementCapacity.None)
{
pathfindingMovementCapacity = unit2.GenerateContext().MovementCapacities;
}
else
{
pathfindingMovementCapacity &= unit2.GenerateContext().MovementCapacities;
}
}
}
}
IGameService service = Services.GetService <IGameService>();
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
bool flag = false;
bool flag2 = false;
if (this.CanTransferTo(army, army.WorldPosition, ref flag, ref flag2, service2, num) && this.TransferTo(army, army.WorldPosition, list, service2, playerController, out ticket, ticketRaisedEventHandler))
{
return;
}
for (int j = 0; j < 6; j++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(army.WorldPosition, (WorldOrientation)j, 1);
if (service3.IsTilePassable(neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0) && service3.IsTransitionPassable(army.WorldPosition, neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0))
{
if (this.CanTransferTo(army, neighbourTile, ref flag, ref flag2, service2, num) && this.TransferTo(army, neighbourTile, list, service2, playerController, out ticket, ticketRaisedEventHandler))
{
return;
}
}
}
}
public OrderUpdateCadastralMapClient(int empireIndex, City city, PathfindingMovementCapacity pathfindingMovementCapacity, CadastralMapOperation operation) : base(empireIndex)
{
if (city == null)
{
throw new ArgumentNullException("city");
}
this.CityGameEntityGUID = city.GUID;
this.PathfindingMovementCapacity = pathfindingMovementCapacity;
this.Operation = operation;
}
public bool IsWorldPositionObstructingVision(WorldPosition observerPosition, WorldPosition tilePosition, int observerHeight, bool ignoreFog)
{
if (!observerPosition.IsValid || !tilePosition.IsValid)
{
return(true);
}
Diagnostics.Assert(this.elevationMap != null);
if ((int)observerPosition.Row >= this.elevationMap.Height || (int)observerPosition.Column >= this.elevationMap.Width || (int)tilePosition.Row >= this.elevationMap.Height || (int)tilePosition.Column >= this.elevationMap.Width)
{
return(true);
}
sbyte b = this.elevationMap.GetValue(tilePosition);
PathfindingMovementCapacity tileMovementCapacity = this.pathfindingService.GetTileMovementCapacity(observerPosition, (PathfindingFlags)0);
bool flag = tileMovementCapacity == PathfindingMovementCapacity.Water || tileMovementCapacity == PathfindingMovementCapacity.FrozenWater;
sbyte b2 = (!flag) ? this.elevationMap.GetValue(observerPosition) : this.waterHeightMap.GetValue(observerPosition);
if (this.ridgeMap.GetValue(tilePosition))
{
b = (sbyte)((int)b + (int)this.ridgeHeight);
}
IWorldPositionningService service = base.Game.GetService <IWorldPositionningService>();
if (service == null)
{
return(false);
}
Region region = service.GetRegion(tilePosition);
if (region != null && region.IsWasteland)
{
b = (sbyte)((int)b + (int)this.wastelandHeight);
}
if ((int)b - (int)b2 > observerHeight)
{
return(true);
}
if (service.GetDistance(tilePosition, observerPosition) <= 1)
{
return(false);
}
if (this.weatherService == null)
{
return(false);
}
if (region != null && region.IsOcean && !ignoreFog)
{
WeatherDefinition weatherDefinitionAtPosition = this.weatherService.GetWeatherDefinitionAtPosition(tilePosition);
if (weatherDefinitionAtPosition != null && weatherDefinitionAtPosition.ObstructVisibility)
{
return(true);
}
}
return(false);
}
public void OverridePathfindingCost(WorldPosition worldPosition, PathfindingMovementCapacity movementCapacity, ref float cost)
{
int weatherValueAtPosition = (int)this.GetWeatherValueAtPosition(worldPosition);
if (weatherValueAtPosition == 0)
{
return;
}
WeatherDefinition weatherDefinition = null;
for (int i = 0; i < this.weatherDefinitions.Length; i++)
{
if (this.weatherDefinitions[i].Value == weatherValueAtPosition)
{
weatherDefinition = this.weatherDefinitions[i];
break;
}
}
if (weatherDefinition == null)
{
Diagnostics.LogError("In OverrideCostByWeatherEffectsPathfindingRule, Fail getting weather definition.");
return;
}
PathfindingRule rule = weatherDefinition.GetRule();
if (rule == null)
{
return;
}
if ((movementCapacity & PathfindingMovementCapacity.Water) == PathfindingMovementCapacity.None)
{
cost = float.PositiveInfinity;
}
else
{
int currentTileHeigh = (int)this.worldPositionService.GetTerrainHeight(worldPosition);
cost = rule.GetCost(movementCapacity, currentTileHeigh);
}
}
public void ComputeFarestPositionInList(WorldPosition[] listOfPosition, WorldPosition origin, PathfindingMovementCapacity pathfindingCapacity, out WorldPosition final)
{
WorldPosition worldPosition = WorldPosition.Invalid;
if (listOfPosition.Length > 0)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
float num = 0f;
for (int i = 0; i < listOfPosition.Length; i++)
{
if (service3.IsTilePassable(listOfPosition[i], pathfindingCapacity, (PathfindingFlags)0) && service3.IsTileStopable(listOfPosition[i], pathfindingCapacity, (PathfindingFlags)0))
{
float num2 = (float)service2.GetDistance(listOfPosition[i], origin);
if (num2 > num)
{
worldPosition = listOfPosition[i];
num = num2;
}
}
}
}
final = worldPosition;
}
private void ELCPDisconnect(Region Region, PathfindingMovementCapacity movementCapacity, bool cityAboutToBeDestroyed)
{
Diagnostics.Assert(this.roads != null);
Diagnostics.Assert(Region != null);
List <ushort> list = new List <ushort>();
List <short> list2 = new List <short>();
for (int i = 0; i < this.roads.Count; i++)
{
if (this.roads[i] != null && (Region.Index == (int)this.roads[i].FromRegion || Region.Index == (int)this.roads[i].ToRegion))
{
list2.AddOnce(this.roads[i].FromRegion);
list2.AddOnce(this.roads[i].ToRegion);
if (!cityAboutToBeDestroyed && (movementCapacity & PathfindingMovementCapacity.Ground) == PathfindingMovementCapacity.Ground)
{
short regionIndex = this.roads[i].ToRegion;
if ((int)this.roads[i].ToRegion == Region.Index)
{
regionIndex = this.roads[i].FromRegion;
}
Region region = this.WorldPositionningService.GetRegion((int)regionIndex);
if (region != null)
{
Diagnostics.Assert(region.City != null);
Diagnostics.Assert(region.City.CadastralMap != null);
if ((region.City.CadastralMap.ConnectedMovementCapacity & PathfindingMovementCapacity.Ground) == PathfindingMovementCapacity.Ground)
{
if (this.RoadModified != null)
{
this.RoadModified(this, new RoadEventArgs((ushort)i, this.roads[i]));
goto IL_1AF;
}
goto IL_1AF;
}
}
}
this.roads[i].PathfindingMovementCapacity &= ~movementCapacity;
if (this.roads[i].PathfindingMovementCapacity == PathfindingMovementCapacity.None)
{
list.Add((ushort)i);
((ICadasterService)this).Unregister((ushort)i);
Diagnostics.Assert(this.roads[i] == null);
}
}
IL_1AF :;
}
list2.Remove((short)Region.Index);
if (list2.Count > 0)
{
Diagnostics.Assert(this.WorldPositionningService != null);
for (int j = 0; j < list2.Count; j++)
{
Region region2 = this.WorldPositionningService.GetRegion((int)list2[j]);
if (region2 != null && region2.City != null && region2.City.CadastralMap.Roads != null)
{
List <ushort> list3 = region2.City.CadastralMap.Roads.Except(list).ToList <ushort>();
region2.City.CadastralMap.Roads = list3;
}
}
}
}
ushort[] ICadasterService.Connect(City city, PathfindingMovementCapacity movementCapacity, bool proxied)
{
if (city == null)
{
throw new ArgumentNullException("city");
}
if ((movementCapacity & PathfindingMovementCapacity.Water) == PathfindingMovementCapacity.Water)
{
StaticString type = new StaticString("DistrictImprovement");
StaticString y = new StaticString("DistrictImprovementDocks");
WorldPosition start = WorldPosition.Invalid;
for (int i = 0; i < city.Districts.Count; i++)
{
District district = city.Districts[i];
if (district.Type == DistrictType.Improvement && district.GetDescriptorNameFromType(type) == y)
{
start = district.WorldPosition;
break;
}
}
if (!start.IsValid)
{
return(null);
}
DepartmentOfForeignAffairs agency = city.Empire.GetAgency <DepartmentOfForeignAffairs>();
this.OceanPathfindingWorldContext.RegionIndexList.Clear();
this.OceanPathfindingWorldContext.RegionIndexList.Add((int)this.WorldPositionningService.GetRegionIndex(city.WorldPosition));
for (int j = 0; j < city.Region.Borders.Length; j++)
{
Region region = this.WorldPositionningService.GetRegion(city.Region.Borders[j].NeighbourRegionIndex);
if (region.Owner == null || !(region.Owner is MajorEmpire) || region.Owner.Index == city.Empire.Index || agency.GetDiplomaticRelation(region.Owner).HasActiveAbility(DiplomaticAbilityDefinition.TradeRoute))
{
this.OceanPathfindingWorldContext.RegionIndexList.Add(city.Region.Borders[j].NeighbourRegionIndex);
}
}
Diagnostics.Assert(city.CadastralMap != null);
Diagnostics.Assert((city.CadastralMap.ConnectedMovementCapacity & PathfindingMovementCapacity.Water) == PathfindingMovementCapacity.Water);
List <ushort> list = new List <ushort>();
List <Region> list2 = new List <Region>();
List <Region> list3 = new List <Region>();
list3.Add(city.Region);
int k = 0;
int l = 2;
while (l > 0)
{
l--;
list2.AddRange(list3);
list3.Clear();
while (k < list2.Count)
{
Region region2 = list2[k];
for (int m = 0; m < region2.Borders.Length; m++)
{
short regionIndex = (short)region2.Borders[m].NeighbourRegionIndex;
Region region3 = this.WorldPositionningService.GetRegion((int)regionIndex);
if (region3 != null && !list2.Contains(region3))
{
if (region3.City != null)
{
Diagnostics.Assert(region3.City.CadastralMap != null);
if ((region3.City.CadastralMap.ConnectedMovementCapacity & PathfindingMovementCapacity.Water) == PathfindingMovementCapacity.Water)
{
for (int n = 0; n < region3.City.Districts.Count; n++)
{
District district2 = region3.City.Districts[n];
if (district2.Type == DistrictType.Improvement && district2.GetDescriptorNameFromType(type) == y)
{
PathfindingFlags pathfindingFlags = PathfindingFlags.IgnoreAll;
pathfindingFlags &= ~PathfindingFlags.IgnoreMovementCapacities;
pathfindingFlags &= ~PathfindingFlags.IgnorePOI;
PathfindingContext pathfindingContext = new PathfindingContext(GameEntityGUID.Zero, city.Empire, PathfindingMovementCapacity.Water);
pathfindingContext.RefreshProperties(1f, 1f, false, false, 1f, 1f);
bool flag = false;
if (!this.OceanPathfindingWorldContext.RegionIndexList.Contains(region2.Borders[m].NeighbourRegionIndex))
{
flag = true;
this.OceanPathfindingWorldContext.RegionIndexList.Add(region2.Borders[m].NeighbourRegionIndex);
}
PathfindingResult pathfindingResult = this.PathfindingService.FindPath(pathfindingContext, start, district2.WorldPosition, PathfindingManager.RequestMode.Default, this.OceanPathfindingWorldContext, pathfindingFlags, null);
if (flag)
{
this.OceanPathfindingWorldContext.RegionIndexList.Remove(region2.Borders[m].NeighbourRegionIndex);
}
if (pathfindingResult == null)
{
pathfindingResult = this.PathfindingService.FindPath(pathfindingContext, start, district2.WorldPosition, PathfindingManager.RequestMode.Default, null, pathfindingFlags, null);
}
if (pathfindingResult != null)
{
ushort item = this.Reserve(new Road
{
FromRegion = (short)city.Region.Index,
ToRegion = (short)region3.Index,
WorldPositions = pathfindingResult.GetCompletePath().ToArray <WorldPosition>(),
PathfindingMovementCapacity = PathfindingMovementCapacity.Water
});
list.Add(item);
}
}
}
}
}
if (region3.IsOcean)
{
list3.AddOnce(region3);
}
else
{
list2.Insert(k, region3);
k++;
}
}
}
k++;
}
}
this.OceanPathfindingWorldContext.RegionIndexList.Clear();
return(list.ToArray());
}
else
{
if (city.Region.Borders != null)
{
List <ushort> list4 = new List <ushort>();
for (int num = 0; num < city.Region.Borders.Length; num++)
{
short regionIndex2 = (short)city.Region.Borders[num].NeighbourRegionIndex;
Region region4 = this.WorldPositionningService.GetRegion((int)regionIndex2);
if (region4 != null && region4.City != null)
{
if (proxied)
{
if ((movementCapacity & PathfindingMovementCapacity.Ground) != PathfindingMovementCapacity.Ground)
{
goto IL_75D;
}
Diagnostics.Assert(region4.City.CadastralMap != null);
if ((region4.City.CadastralMap.ConnectedMovementCapacity & PathfindingMovementCapacity.Ground) != PathfindingMovementCapacity.Ground)
{
goto IL_75D;
}
}
bool flag2 = false;
if (region4.City.CadastralMap.Roads != null)
{
for (int num2 = 0; num2 < region4.City.CadastralMap.Roads.Count; num2++)
{
ushort num3 = region4.City.CadastralMap.Roads[num2];
Road road = this.roads[(int)num3];
if (road != null && (city.Region.Index == (int)road.FromRegion || city.Region.Index == (int)road.ToRegion) && (road.PathfindingMovementCapacity & movementCapacity) != PathfindingMovementCapacity.None)
{
if (this.RoadModified != null)
{
this.RoadModified(this, new RoadEventArgs(num3, road));
}
flag2 = true;
list4.Add(num3);
}
}
}
if (!flag2)
{
PathfindingFlags pathfindingFlags2 = PathfindingFlags.IgnoreAll;
pathfindingFlags2 &= ~PathfindingFlags.IgnoreMovementCapacities;
pathfindingFlags2 &= ~PathfindingFlags.IgnorePOI;
pathfindingFlags2 &= ~PathfindingFlags.IgnoreRoad;
PathfindingContext pathfindingContext2 = new PathfindingContext(GameEntityGUID.Zero, city.Empire, movementCapacity);
pathfindingContext2.RefreshProperties(1f, 1f, false, false, 1f, 1f);
pathfindingContext2.RemoveMovementCapacity(PathfindingMovementCapacity.FrozenWater);
Diagnostics.Assert(this.pathfindingWorldContext != null && this.pathfindingWorldContext.RegionIndexList != null && this.pathfindingWorldContext.RegionIndexList.Count == 2);
this.pathfindingWorldContext.RegionIndexList[0] = (int)this.WorldPositionningService.GetRegionIndex(city.WorldPosition);
this.pathfindingWorldContext.RegionIndexList[1] = (int)this.WorldPositionningService.GetRegionIndex(region4.City.WorldPosition);
PathfindingResult pathfindingResult2 = this.PathfindingService.FindPath(pathfindingContext2, city.WorldPosition, region4.City.WorldPosition, PathfindingManager.RequestMode.Default, this.pathfindingWorldContext, pathfindingFlags2, null);
if (pathfindingResult2 == null)
{
pathfindingFlags2 |= PathfindingFlags.IgnorePOI;
pathfindingResult2 = this.PathfindingService.FindPath(pathfindingContext2, city.WorldPosition, region4.City.WorldPosition, PathfindingManager.RequestMode.Default, this.pathfindingWorldContext, pathfindingFlags2, null);
}
if (pathfindingResult2 != null)
{
ushort item2 = this.Reserve(new Road
{
FromRegion = (short)city.Region.Index,
ToRegion = (short)region4.Index,
WorldPositions = pathfindingResult2.GetCompletePath().ToList <WorldPosition>().ToArray(),
PathfindingMovementCapacity = movementCapacity
});
list4.Add(item2);
}
}
}
IL_75D :;
}
return(list4.ToArray());
}
return(null);
}
}
public override bool CanExecute(Army army, ref List <StaticString> failureFlags, params object[] parameters)
{
if (!base.CanExecute(army, ref failureFlags, parameters))
{
return(false);
}
if (army.HasCatspaw)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
int num = 0;
int num2 = 0;
float num3 = float.MaxValue;
bool flag = false;
PathfindingMovementCapacity pathfindingMovementCapacity = PathfindingMovementCapacity.None;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is Unit)
{
Unit unit = parameters[i] as Unit;
if (unit.UnitDesign != null && unit.UnitDesign.Tags.Contains(DownloadableContent9.TagSolitary))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if ((unit.UnitDesign != null && unit.UnitDesign.Tags.Contains(Kaiju.LiceUnitTag)) || unit.UnitDesign.Tags.Contains(Kaiju.MonsterUnitTag))
{
flag = true;
}
if (unit.SimulationObject.Tags.Contains(DownloadableContent16.SeafaringUnit))
{
failureFlags.Add(ArmyAction.NoCanDoWhileSeafaring);
return(false);
}
num2 += (int)unit.GetPropertyValue(SimulationProperties.UnitSlotCount);
num++;
pathfindingMovementCapacity = unit.GenerateContext().MovementCapacities;
}
else
{
if (!(parameters[i] is IEnumerable <Unit>))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
foreach (Unit unit2 in (parameters[i] as IEnumerable <Unit>))
{
if (unit2.Garrison == null)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if (unit2.UnitDesign != null && unit2.UnitDesign.Tags.Contains(DownloadableContent9.TagSolitary))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if ((unit2.UnitDesign != null && unit2.UnitDesign.Tags.Contains(Kaiju.LiceUnitTag)) || unit2.UnitDesign.Tags.Contains(Kaiju.MonsterUnitTag))
{
flag = true;
}
if (unit2.SimulationObject.Tags.Contains(DownloadableContent16.SeafaringUnit))
{
if (!failureFlags.Contains(ArmyAction.NoCanDoWhileSeafaring))
{
failureFlags.Add(ArmyAction.NoCanDoWhileSeafaring);
}
}
else
{
num2 += (int)unit2.GetPropertyValue(SimulationProperties.UnitSlotCount);
num++;
float propertyValue = unit2.GetPropertyValue(SimulationProperties.Movement);
if (propertyValue < num3)
{
num3 = propertyValue;
}
if (pathfindingMovementCapacity == PathfindingMovementCapacity.None)
{
pathfindingMovementCapacity = unit2.GenerateContext().MovementCapacities;
}
else
{
pathfindingMovementCapacity &= unit2.GenerateContext().MovementCapacities;
}
}
}
}
}
if (failureFlags.Contains(ArmyAction.NoCanDoWhileSeafaring))
{
if (num == 0)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
}
return(false);
}
if (num == 0)
{
failureFlags.Add(ArmyAction_TransferUnits.NoUnitSelectedForTransfer);
return(false);
}
if (num3 == 0f)
{
failureFlags.Add(ArmyAction_TransferUnits.NotEnoughMovementToTransfer);
return(false);
}
if (flag)
{
failureFlags.Add(ArmyAction_TransferUnits.UntransferableUnitSelectedForTransfer);
return(false);
}
IGameService service = Services.GetService <IGameService>();
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
bool flag2 = false;
bool flag3 = false;
if (this.CanTransferTo(army, army.WorldPosition, ref flag2, ref flag3, service2, num2))
{
return(true);
}
for (int j = 0; j < 6; j++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(army.WorldPosition, (WorldOrientation)j, 1);
if (service3.IsTilePassable(neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0) && service3.IsTransitionPassable(army.WorldPosition, neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0))
{
if (this.CanTransferTo(army, neighbourTile, ref flag2, ref flag3, service2, num2))
{
return(true);
}
}
}
if (flag2 || flag3)
{
failureFlags.Add(ArmyAction_TransferUnits.NotEnoughSlotsInNeighbouringGarrisonForTransfer);
}
else
{
failureFlags.Add(ArmyAction_TransferUnits.NoNeighbouringCityAvailable);
}
return(false);
}
protected void SpawnArmy(QuestBehaviour questBehaviour)
{
if (!string.IsNullOrEmpty(this.ArmyDroplist))
{
IGameService service = Services.GetService <IGameService>();
if (service == null || service.Game == null)
{
Diagnostics.LogError("Failed to retrieve the game service.");
return;
}
global::Game game = service.Game as global::Game;
if (game == null)
{
Diagnostics.LogError("Failed to cast gameService.Game to Game.");
return;
}
IDatabase <Droplist> database = Databases.GetDatabase <Droplist>(false);
if (database == null)
{
return;
}
string text = this.ArmyDroplist;
if (this.ArmyDroplistSuffix != string.Empty)
{
text = text + "_" + this.ArmyDroplistSuffix;
}
Droplist droplist;
if (!database.TryGetValue(text, out droplist))
{
Diagnostics.LogError("Cannot retrieve drop list '{0}' in quest definition '{1}'", new object[]
{
text,
questBehaviour.Quest.QuestDefinition.Name
});
return;
}
if (!string.IsNullOrEmpty(this.EmpireArmyOwnerVarName))
{
global::Empire empire = null;
object obj;
if (questBehaviour.TryGetQuestVariableValueByName <object>(this.EmpireArmyOwnerVarName, out obj))
{
if (obj is global::Empire)
{
empire = (obj as global::Empire);
}
else if (obj is int)
{
empire = game.Empires[(int)obj];
}
if (empire != null)
{
this.EmpireArmyOwner = empire;
}
}
}
global::Empire empire2 = this.EmpireArmyOwner;
if (empire2 == null || empire2 is LesserEmpire || this.UseBehaviorInitiatorEmpire)
{
empire2 = questBehaviour.Initiator;
}
if (this.UseBehaviorInitiatorEmpire)
{
this.EmpireArmyOwner = questBehaviour.Initiator;
}
if (this.EmpireArmyOwner is MajorEmpire && (this.EmpireArmyOwner as MajorEmpire).ELCPIsEliminated)
{
return;
}
Droplist droplist2;
DroppableArmyDefinition droppableArmyDefinition = droplist.Pick(empire2, out droplist2, new object[0]) as DroppableArmyDefinition;
if (droppableArmyDefinition != null)
{
int num = 0;
if (this.ScaleWithMaxEra)
{
num = DepartmentOfScience.GetMaxEraNumber() - 1;
}
int val = 0;
IDatabase <AnimationCurve> database2 = Databases.GetDatabase <AnimationCurve>(false);
AnimationCurve animationCurve;
if (database2 != null && database2.TryGetValue(QuestBehaviourTreeNode_Action_SpawnArmy.questUnitLevelEvolution, out animationCurve))
{
float propertyValue = questBehaviour.Initiator.GetPropertyValue(SimulationProperties.GameSpeedMultiplier);
val = (int)animationCurve.EvaluateWithScaledAxis((float)game.Turn, propertyValue, 1f);
val = Math.Max(0, Math.Min(100, val));
}
num = Math.Max(num, val);
StaticString[] array = Array.ConvertAll <string, StaticString>(droppableArmyDefinition.UnitDesigns, (string input) => input);
bool flag = false;
IDatabase <UnitDesign> database3 = Databases.GetDatabase <UnitDesign>(false);
for (int i = 0; i < array.Length; i++)
{
UnitDesign unitDesign;
if (database3.TryGetValue(array[i], out unitDesign) && unitDesign != null && unitDesign.Tags.Contains(DownloadableContent16.TagSeafaring))
{
flag = true;
break;
}
}
IEnumerable <WorldPosition> enumerable = null;
questBehaviour.TryGetQuestVariableValueByName <WorldPosition>(this.ForbiddenSpawnLocationVarName, out enumerable);
List <WorldPosition> list = this.SpawnLocations.ToList <WorldPosition>().Randomize(null);
IWorldPositionningService service2 = game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = game.Services.GetService <IPathfindingService>();
Diagnostics.Assert(service2 != null);
WorldPosition worldPosition = WorldPosition.Invalid;
if (!questBehaviour.Quest.QuestDefinition.IsGlobal)
{
PathfindingMovementCapacity pathfindingMovementCapacity = PathfindingMovementCapacity.Water;
if (!flag)
{
pathfindingMovementCapacity |= PathfindingMovementCapacity.Ground;
}
for (int j = 0; j < list.Count; j++)
{
WorldPosition worldPosition2 = list[j];
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(worldPosition2, pathfindingMovementCapacity))
{
if (enumerable != null)
{
if (enumerable.Contains(worldPosition2))
{
goto IL_330;
}
this.AddPositionToForbiddenSpawnPosition(questBehaviour, worldPosition2);
}
worldPosition = worldPosition2;
break;
}
IL_330 :;
}
if (!service3.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water, PathfindingFlags.IgnoreFogOfWar))
{
worldPosition = WorldPosition.Invalid;
}
if (!worldPosition.IsValid && list.Count > 0)
{
List <WorldPosition> list2 = new List <WorldPosition>();
Queue <WorldPosition> queue = new Queue <WorldPosition>();
worldPosition = list[0];
bool flag2 = false;
if (worldPosition.IsValid)
{
flag2 = service2.IsWaterTile(worldPosition);
}
do
{
if (queue.Count > 0)
{
worldPosition = queue.Dequeue();
}
for (int k = 0; k < 6; k++)
{
WorldPosition neighbourTileFullCyclic = service2.GetNeighbourTileFullCyclic(worldPosition, (WorldOrientation)k, 1);
if (!list2.Contains(neighbourTileFullCyclic) && list2.Count < 19)
{
queue.Enqueue(neighbourTileFullCyclic);
list2.Add(neighbourTileFullCyclic);
}
}
if (!DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(worldPosition, pathfindingMovementCapacity) || !service3.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water, PathfindingFlags.IgnoreFogOfWar) || flag2 != service2.IsWaterTile(worldPosition))
{
worldPosition = WorldPosition.Invalid;
}
}while (worldPosition == WorldPosition.Invalid && queue.Count > 0);
}
if (!worldPosition.IsValid)
{
string format = "Cannot find a valid position to spawn on: {0}";
object[] array2 = new object[1];
array2[0] = string.Join(",", list.Select(delegate(WorldPosition position)
{
WorldPosition worldPosition3 = position;
return(worldPosition3.ToString());
}).ToArray <string>());
Diagnostics.LogError(format, array2);
return;
}
}
OrderSpawnArmy orderSpawnArmy;
if (worldPosition.IsValid)
{
list.Clear();
list.Add(worldPosition);
WorldOrientation worldOrientation = WorldOrientation.East;
for (int l = 0; l < 6; l++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(worldPosition, worldOrientation, 1);
bool flag3 = flag == service2.IsWaterTile(neighbourTile);
if (neighbourTile.IsValid && flag3 && service3.IsTileStopable(worldPosition, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water, PathfindingFlags.IgnoreFogOfWar))
{
list.Add(neighbourTile);
}
worldOrientation = worldOrientation.Rotate(1);
}
orderSpawnArmy = new OrderSpawnArmy(this.EmpireArmyOwner.Index, list.ToArray(), num, true, this.CanMoveOnSpawn, true, questBehaviour.Quest.QuestDefinition.IsGlobal || this.ForceGlobalArmySymbol, array);
}
else
{
orderSpawnArmy = new OrderSpawnArmy(this.EmpireArmyOwner.Index, list.ToArray(), num, true, this.CanMoveOnSpawn, true, questBehaviour.Quest.QuestDefinition.IsGlobal || this.ForceGlobalArmySymbol, array);
}
orderSpawnArmy.GameEntityGUID = this.ArmyGUID;
Diagnostics.Log("Posting order: {0} at {1}", new object[]
{
orderSpawnArmy.ToString(),
worldPosition
});
if (!string.IsNullOrEmpty(this.TransferResourceName) && this.TransferResourceAmount > 0)
{
Ticket ticket;
this.EmpireArmyOwner.PlayerControllers.Server.PostOrder(orderSpawnArmy, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OrderSpawnArmy_TicketRaised));
return;
}
this.EmpireArmyOwner.PlayerControllers.Server.PostOrder(orderSpawnArmy);
}
}
}
public override bool CanExecute(Army army, ref List <StaticString> failureFlags, params object[] parameters)
{
if (!base.CanExecute(army, ref failureFlags, parameters))
{
return(false);
}
if (army.HasCatspaw)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
int num = 0;
int num2 = 0;
float num3 = float.MaxValue;
bool flag = false;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is Unit)
{
Unit unit = parameters[i] as Unit;
if (unit.UnitDesign != null && unit.UnitDesign.Tags.Contains(DownloadableContent9.TagSolitary))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if ((unit.UnitDesign != null && unit.UnitDesign.Tags.Contains(Kaiju.LiceUnitTag)) || unit.UnitDesign.Tags.Contains(Kaiju.MonsterUnitTag))
{
flag = true;
}
num2 += (int)unit.GetPropertyValue(SimulationProperties.UnitSlotCount);
num++;
}
else
{
if (!(parameters[i] is IEnumerable <Unit>))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
foreach (Unit unit2 in (parameters[i] as IEnumerable <Unit>))
{
if (unit2.UnitDesign != null && unit2.UnitDesign.Tags.Contains(DownloadableContent9.TagSolitary))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if ((unit2.UnitDesign != null && unit2.UnitDesign.Tags.Contains(Kaiju.LiceUnitTag)) || unit2.UnitDesign.Tags.Contains(Kaiju.MonsterUnitTag))
{
flag = true;
}
num2 += (int)unit2.GetPropertyValue(SimulationProperties.UnitSlotCount);
num++;
float propertyValue = unit2.GetPropertyValue(SimulationProperties.Movement);
if (propertyValue < num3)
{
num3 = propertyValue;
}
}
}
}
if (num == 0)
{
failureFlags.Add(ArmyAction_TransferUnits.NoUnitSelectedForTransfer);
return(false);
}
if (num3 == 0f)
{
failureFlags.Add(ArmyAction_TransferUnits.NotEnoughMovementToTransfer);
return(false);
}
if (flag)
{
failureFlags.Add(ArmyAction_TransferUnits.UntransferableUnitSelectedForTransfer);
return(false);
}
IGameService service = Services.GetService <IGameService>();
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
bool flag2 = false;
bool flag3 = false;
PathfindingMovementCapacity pathfindingMovementCapacity = army.GenerateContext().MovementCapacities;
for (int j = 0; j < parameters.Length; j++)
{
if (parameters[j] is Unit)
{
pathfindingMovementCapacity = (parameters[j] as Unit).GenerateContext().MovementCapacities;
}
else if (parameters[j] is IEnumerable <Unit> )
{
pathfindingMovementCapacity = PathfindingMovementCapacity.All;
foreach (Unit unit3 in (parameters[j] as IEnumerable <Unit>))
{
if (unit3.Garrison != null)
{
pathfindingMovementCapacity &= unit3.GenerateContext().MovementCapacities;
}
}
}
}
for (int k = 0; k < 6; k++)
{
bool flag4 = false;
WorldPosition neighbourTile = service2.GetNeighbourTile(army.WorldPosition, (WorldOrientation)k, 1);
if (service3.IsTilePassable(neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0) && service3.IsTransitionPassable(army.WorldPosition, neighbourTile, army, PathfindingFlags.IgnoreArmies, null) && service3.IsTileStopable(neighbourTile, pathfindingMovementCapacity, PathfindingFlags.IgnoreArmies))
{
Region region = service2.GetRegion(neighbourTile);
if (region.City != null && this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.Army)
{
for (int l = 0; l < region.City.Districts.Count; l++)
{
if (region.City.Districts[l].Type != DistrictType.Exploitation && neighbourTile == region.City.Districts[l].WorldPosition)
{
if (this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.Army)
{
if (num2 + region.City.CurrentUnitSlot <= region.City.MaximumUnitSlot)
{
return(true);
}
flag2 = true;
}
flag4 = true;
break;
}
}
}
if (this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.Army && flag2)
{
failureFlags.Add(ArmyAction_TransferUnits.NotEnoughSlotsInNeighbouringGarrisonForTransfer);
}
Army armyAtPosition = service2.GetArmyAtPosition(neighbourTile);
if (armyAtPosition != null && this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.City && armyAtPosition.Empire == army.Empire && !armyAtPosition.HasCatspaw)
{
if (armyAtPosition.SimulationObject.Tags.Contains(KaijuArmy.ClassKaijuArmy) && !DepartmentOfScience.IsTechnologyResearched(army.Empire, "TechnologyDefinitionMimics1"))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if (num2 + armyAtPosition.CurrentUnitSlot <= armyAtPosition.MaximumUnitSlot)
{
return(true);
}
flag3 = true;
}
else if (!flag4 && this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.City && armyAtPosition == null && num != army.StandardUnits.Count && service3.IsTileStopable(neighbourTile, army, (PathfindingFlags)0, null))
{
return(true);
}
}
}
if (this.AllowedTransferTarget > ArmyAction_TransferUnits.AllowedTransferTargetType.City && flag3)
{
failureFlags.Add(ArmyAction_TransferUnits.NotEnoughSlotsInNeighbouringArmyForTransfer);
}
if (this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.Army)
{
failureFlags.Add(ArmyAction_TransferUnits.NoNeighbouringCityAvailable);
}
if (this.AllowedTransferTarget != ArmyAction_TransferUnits.AllowedTransferTargetType.City)
{
failureFlags.Add(ArmyAction_TransferUnits.NoNeighbouringArmyAvailable);
}
ArmyAction_TransferUnits.AllowedTransferTargetType allowedTransferTarget = this.AllowedTransferTarget;
return(false);
}
