public IGameEntity this[GameEntityGUID guid]
{
get
{
return(this.terraformDevices[guid]);
}
}
public QuestBTOrder(StaticString questname, GameEntityGUID targetGUID, float armypower = 1f)
{
this.questName = questname;
this.objectiveGUID = targetGUID;
this.requiredArmyPower = armypower;
this.resourceNeeded = StaticString.Empty;
}
private bool AskForArmy(int numberOfUnits)
{
if (!base.AIDataArmyGUID.IsValid && numberOfUnits > 0 && this.armySpawnTicket == null)
{
PathfindingContext pathfindingContext = new PathfindingContext(this.Camp.City.GUID, this.Camp.City.Empire, this.Camp.City.StandardUnits);
WorldPosition armyPosition;
if (!DepartmentOfTheInterior.TryGetWorldPositionForNewArmyFromCity(this.Camp.City, this.pathfindingService, pathfindingContext, out armyPosition))
{
return(false);
}
if (this.Camp.City.StandardUnits.Count == 0)
{
return(false);
}
numberOfUnits = Mathf.Min(this.Camp.City.StandardUnits.Count, numberOfUnits);
if (numberOfUnits > 0)
{
GameEntityGUID[] array = new GameEntityGUID[numberOfUnits];
for (int i = 0; i < numberOfUnits; i++)
{
array[i] = this.Camp.City.StandardUnits[i].GUID;
}
OrderTransferGarrisonToNewArmy order = new OrderTransferGarrisonToNewArmy(base.Commander.Empire.Index, this.Camp.City.GUID, array, armyPosition, null, false, true, true);
base.Commander.Empire.PlayerControllers.AI.PostOrder(order, out this.armySpawnTicket, null);
}
}
return(false);
}
public void LoadRegionVillages(Region region)
{
if (region == null)
{
return;
}
GameEntityGUID guid = this.GameEntityRepositoryService.GenerateGUID();
SimulationDescriptor descriptor = null;
this.SimulationDescriptorDatabase.TryGetValue("ClassMinorEmpireGarrison", out descriptor);
DepartmentOfIndustry agency = base.Empire.GetAgency <DepartmentOfIndustry>();
SimulationDescriptor value = this.SimulationDescriptorDatabase.GetValue("MinorEmpireVillage");
for (int i = 0; i < region.PointOfInterests.Length; i++)
{
string a;
if (region.PointOfInterests[i].PointOfInterestDefinition.TryGetValue("Type", out a) && a == "Village")
{
guid = this.GameEntityRepositoryService.GenerateGUID();
Village village = new Village(guid)
{
Empire = (base.Empire as global::Empire)
};
village.PointOfInterest = region.PointOfInterests[i];
village.AddDescriptor(descriptor, false);
village.AddDescriptor(value, false);
this.AddVillage(village);
if (agency != null)
{
agency.AddQueueTo <Village>(village);
}
}
}
this.MinorEmpire.GenerateStartingUnits();
}
public IGameEntity this[GameEntityGUID guid]
{
get
{
return(this.mapBoosts[guid]);
}
}
public AIData_Army.AIDataArmyLockState GetArmyLockState()
{
if (AIScheduler.Services == null)
{
return(AIData_Army.AIDataArmyLockState.Free);
}
IAIDataRepositoryAIHelper service = AIScheduler.Services.GetService <IAIDataRepositoryAIHelper>();
if (this.Army != null)
{
GameEntityGUID x = GameEntityGUID.Zero;
for (int i = 0; i < this.Army.StandardUnits.Count; i++)
{
AIData_Unit aidata_Unit;
if (service.TryGetAIData <AIData_Unit>(this.Army.StandardUnits[i].GUID, out aidata_Unit) && aidata_Unit.IsUnitLocked())
{
if (x == GameEntityGUID.Zero)
{
x = aidata_Unit.ReservingGUID;
}
else if (x != aidata_Unit.ReservingGUID)
{
return(AIData_Army.AIDataArmyLockState.Hybrid);
}
}
}
if (x != GameEntityGUID.Zero)
{
return(AIData_Army.AIDataArmyLockState.Locked);
}
}
return(AIData_Army.AIDataArmyLockState.Free);
}
private bool IsMessageValid(CreepingNodeConstructionMessage message)
{
IGameEntity gameEntity = null;
if (!this.gameEntityRepositoryService.TryGetValue(message.PointOfInterestGUID, out gameEntity))
{
return(false);
}
PointOfInterest pointOfInterest = gameEntity as PointOfInterest;
if (pointOfInterest == null || pointOfInterest.CreepingNodeImprovement != null)
{
return(false);
}
for (int i = 0; i < this.validatedMessages.Count; i++)
{
CreepingNodeConstructionMessage creepingNodeConstructionMessage = this.validatedMessages[i];
GameEntityGUID pointOfInterestGUID = message.PointOfInterestGUID;
GameEntityGUID pointOfInterestGUID2 = creepingNodeConstructionMessage.PointOfInterestGUID;
if (pointOfInterestGUID == pointOfInterestGUID2)
{
return(false);
}
}
return(true);
}
private void CancelMessagesFor(int regionIndex, GameEntityGUID kaijuGUID)
{
foreach (GlobalObjectiveMessage message in base.AIEntity.AIPlayer.Blackboard.GetMessages <GlobalObjectiveMessage>(BlackboardLayerID.Empire, (GlobalObjectiveMessage match) => match.RegionIndex == regionIndex && match.SubObjectifGUID == kaijuGUID && match.ObjectiveType == this.ObjectiveType))
{
base.AIEntity.AIPlayer.Blackboard.CancelMessage(message);
}
}
public virtual void ReadXml(XmlReader reader)
{
IDatabase <WorldEffectDefinition> database = Databases.GetDatabase <WorldEffectDefinition>(false);
this.TurnWhenLastBegun = reader.GetAttribute <int>("TurnWhenLastBegun");
reader.ReadStartElement();
int attribute = reader.GetAttribute <int>("Count");
reader.ReadStartElement("WorldEffects");
for (int i = 0; i < attribute; i++)
{
int attribute2 = reader.GetAttribute <int>("EmpireIndex");
GameEntityGUID ownerGUID = reader.GetAttribute <ulong>("OwnerGUID");
WorldPosition position;
position.Row = reader.GetAttribute <short>("Row");
position.Column = reader.GetAttribute <short>("Column");
string attribute3 = reader.GetAttribute("WorldEffectDefinitionName");
reader.ReadStartElement("WorldEffect");
WorldEffectDefinition worldEffectDefinition;
if (database.TryGetValue(attribute3, out worldEffectDefinition))
{
((IWorldEffectService)this).AddWorldEffect(worldEffectDefinition, position, attribute2, ownerGUID, reader);
}
reader.ReadEndElement("WorldEffect");
}
reader.ReadEndElement("WorldEffects");
}
private float ComputeHarassingFitness(GameEntityGUID cityGuid, WorldPosition colossusArmyPosition)
{
float num = 0f;
bool flag = true;
AIData_City aidata_City;
if (this.aiDataRepositoryHelper.TryGetAIData <AIData_City>(cityGuid, out aidata_City))
{
if (!this.departmentOfForeignAffairs.CanBesiegeCity(aidata_City.City))
{
flag = false;
}
if (flag)
{
AIRegionData regionData = this.worldAtlasAIHelper.GetRegionData(base.AIEntity.Empire.Index, aidata_City.City.Region.Index);
if (regionData != null)
{
num = regionData.HarassingScore;
if (colossusArmyPosition.IsValid)
{
float num2 = (float)this.worldPositioningService.GetDistance(aidata_City.City.WorldPosition, colossusArmyPosition);
float num3 = Mathf.Clamp01(num2 / this.averageMaximumMovementPoint / 5f);
num = AILayer.Boost(num, num3 * -0.5f);
}
}
}
}
return(num);
}
public IGameEntity this[GameEntityGUID guid]
{
get
{
return(this.diplomaticContractsByGUID[guid]);
}
}
public CreepingNode(GameEntityGUID guid, global::Empire empire) : base("CreepingNode#" + guid.ToString())
{
this.GUID = guid;
this.Empire = empire;
this.LineOfSightActive = true;
this.LineOfSightDirty = true;
this.DismantlingArmyGUID = GameEntityGUID.Zero;
this.Life = 0f;
this.LastTurnWhenDismantleBegun = 0;
this.eventService = Services.GetService <IEventService>();
Diagnostics.Assert(this.eventService != null);
this.gameService = Services.GetService <IGameService>();
Diagnostics.Assert(this.gameService != null);
this.game = (this.gameService.Game as global::Game);
Diagnostics.Assert(this.game != null);
this.pathfindingService = this.gameService.Game.Services.GetService <IPathfindingService>();
Diagnostics.Assert(this.pathfindingService != null);
this.worldPositionningService = this.gameService.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(this.worldPositionningService != null);
this.simulationDescriptorDatabase = Databases.GetDatabase <SimulationDescriptor>(false);
Diagnostics.Assert(this.simulationDescriptorDatabase != null);
this.departmentOfTheInterior = this.Empire.GetAgency <DepartmentOfTheInterior>();
if (ELCPUtilities.UseELCPCreepingNodeRuleset)
{
SimulationDescriptor descriptor = null;
if (this.simulationDescriptorDatabase.TryGetValue("VanillaNode", out descriptor))
{
base.SimulationObject.AddDescriptor(descriptor);
}
}
this.StoredConstructionCost = new Dictionary <string, float>();
this.ExploitedTiles = new List <WorldPosition>();
}
public SpellUsageTracker(GameEntityGUID encounterGUID, int empireIndex, StaticString spellUsed)
{
this.EncounterGUID = encounterGUID;
this.EmpireIndex = empireIndex;
this.spellsUsed = new List <StaticString>();
this.spellsUsed.Add(spellUsed);
}
public override bool Initialize(QuestBehaviour questBehaviour)
{
City city;
if (this.CityGUID == GameEntityGUID.Zero && !string.IsNullOrEmpty(this.CityVarName) && questBehaviour.TryGetQuestVariableValueByName <City>(this.CityVarName, out city))
{
if (city == null)
{
Diagnostics.LogError("City is null or empty, quest variable (varname: '{0}')", new object[]
{
this.CityVarName
});
return(false);
}
this.CityGUID = city.GUID;
}
ulong num;
if (this.ArmyGuid == 0UL && !string.IsNullOrEmpty(this.ArmyGuidVarName) && questBehaviour.TryGetQuestVariableValueByName <ulong>(this.ArmyGuidVarName, out num))
{
if (num == 0UL)
{
Diagnostics.LogError("QuestBehaviourTreeNode_ConditionCheck_IsArmyAtCity : Army guid is invalid");
return(false);
}
this.ArmyGuid = new GameEntityGUID(num);
}
return(base.Initialize(questBehaviour));
}
public TerraformDevice AddDevice(GameEntityGUID guid, TerraformDeviceDefinition terraformDeviceDefinition, WorldPosition position, global::Empire empire, bool placedByPrivateers)
{
TerraformDevice terraformDevice = new TerraformDevice(empire.Index, guid, position, terraformDeviceDefinition, placedByPrivateers);
IDatabase <SimulationDescriptor> database = Databases.GetDatabase <SimulationDescriptor>(false);
Diagnostics.Assert(database != null);
SimulationDescriptor descriptor = null;
if (database.TryGetValue(TerraformDeviceManager.ClassTerraformDeviceDescriptor, out descriptor))
{
terraformDevice.AddDescriptor(descriptor, false);
}
float propertyValue = terraformDevice.Empire.GetPropertyValue(SimulationProperties.GameSpeedMultiplier);
terraformDevice.Charges = 0f;
terraformDevice.ChargesPerTurn = terraformDeviceDefinition.ChargesPerTurn;
terraformDevice.ChargesToActivate = terraformDeviceDefinition.ChargesToActivate * propertyValue;
terraformDevice.Range = terraformDeviceDefinition.TerraformRange;
terraformDevice.DismantleDefense = (float)terraformDeviceDefinition.DismantleDefense * propertyValue;
empire.AddChild(terraformDevice);
empire.Refresh(false);
this.Register(terraformDevice);
this.worldPositionSimulationEvaluatorService.SetSomethingChangedOnRegion(this.WorldPositionningService.GetRegionIndex(terraformDevice.WorldPosition));
return(terraformDevice);
}
public override void ReadXml(XmlReader reader)
{
int num = reader.ReadVersionAttribute();
base.ReadXml(reader);
GameEntityGUID guid = new GameEntityGUID(reader.GetAttribute <ulong>("GUID"));
Kaiju kaiju = new Kaiju(this.KaijuEmpire, guid);
reader.ReadElementSerializable <Kaiju>(ref kaiju);
if (kaiju != null)
{
this.Kaiju = kaiju;
}
this.relocationETA = reader.ReadElementString <int>("relocationETA");
this.kaijuSpawnTurn = reader.ReadElementString <int>("kaijuSpawnTurn");
this.lastLiceArmySpawnTurn = reader.ReadElementString <int>("lastLiceArmySpawnTurn");
this.liceArmies.Clear();
this.liceArmiesCache = null;
if (num >= 2)
{
int attribute = reader.GetAttribute <int>("liceArmiesCount");
reader.ReadStartElement("liceArmies");
for (int i = 0; i < attribute; i++)
{
this.liceArmies.Add(new GameEntityGUID(reader.ReadElementString <ulong>("liceArmyGUID")));
}
reader.ReadEndElement("liceArmies");
}
}
public void Unregister(GameEntityGUID guid)
{
if (this.mapBoosts.Remove(guid))
{
this.OnMapBoostRepositoryChange(MapBoostRepositoryChangeAction.Remove, guid);
}
this.gameEntityRepositoryService.Unregister(guid);
}
protected MapBoost AddMapBoost(GameEntityGUID guid, MapBoostDefinition mapBoostDefinition, WorldPosition position)
{
MapBoost mapBoost = new MapBoost(guid, position, mapBoostDefinition, this);
this.Register(mapBoost);
this.worldPositionSimulationEvaluatorService.SetSomethingChangedOnRegion(this.worldPositionService.GetRegionIndex(mapBoost.WorldPosition));
return(mapBoost);
}
public DiplomaticContract(GameEntityGUID contractGUID, global::Empire empireWhichInitiated, global::Empire empireWhichReceives) : this()
{
this.GUID = contractGUID;
this.State = DiplomaticContractState.Negotiation;
this.EmpireWhichInitiated = empireWhichInitiated;
this.EmpireWhichProposes = empireWhichInitiated;
this.EmpireWhichReceives = empireWhichReceives;
}
public OrderToggleInfiltration(int empireIndex, GameEntityGUID heroGuid, GameEntityGUID assignmentGuid, bool isAGroundInfiltration, bool isStarting) : base(empireIndex)
{
this.HeroGuid = heroGuid;
this.AssignmentGUID = assignmentGuid;
this.IsAGroundInfiltration = isAGroundInfiltration;
this.IsStarting = isStarting;
this.IgnoreVision = false;
}
public ColossusMission UpdateCityDefenseMission(ColossusMission currentColossusMission, Unit colossus)
{
float fitnessForMission = this.GetFitnessForMission(colossus, ColossusMission.MissionObjective.CityDefense);
WorldPosition worldPosition = WorldPosition.Invalid;
if (colossus.Garrison is IWorldPositionable)
{
worldPosition = (colossus.Garrison as IWorldPositionable).WorldPosition;
}
Region region = this.worldPositioningService.GetRegion(worldPosition);
float num = 0f;
float entityFitness = 0f;
GameEntityGUID targetGuid = GameEntityGUID.Zero;
for (int i = 0; i < this.departmentOfTheInterior.Cities.Count; i++)
{
if (currentColossusMission == null || !(this.departmentOfTheInterior.Cities[i].GUID == currentColossusMission.TargetGuid))
{
if (!this.hasShips)
{
Region region2 = this.worldPositioningService.GetRegion(this.departmentOfTheInterior.Cities[i].WorldPosition);
if (region.ContinentID != region2.ContinentID)
{
goto IL_193;
}
}
float num2 = this.ComputeCityFitness(this.departmentOfTheInterior.Cities[i].GUID, worldPosition);
float num3 = num2 * fitnessForMission;
ColossusMission colossusMissionPerTarget = this.GetColossusMissionPerTarget(this.departmentOfTheInterior.Cities[i].GUID);
if (colossusMissionPerTarget != null && currentColossusMission != null && colossusMissionPerTarget.Objective == currentColossusMission.Objective && num3 < colossusMissionPerTarget.Fitness)
{
num2 *= 0.5f;
num3 *= 0.5f;
}
if (currentColossusMission == null || num3 >= currentColossusMission.Fitness)
{
if (num < num3)
{
num = num3;
targetGuid = this.departmentOfTheInterior.Cities[i].GUID;
}
}
}
IL_193 :;
}
if (targetGuid.IsValid)
{
return(new ColossusMission
{
EntityFitness = entityFitness,
ColossusMissionFitness = fitnessForMission,
TargetGuid = targetGuid,
ColossusGuid = colossus.GUID,
Objective = ColossusMission.MissionObjective.CityDefense
});
}
return(null);
}
public static bool SpellUsage_HasSpellBeenUsed(GameEntityGUID encounterGUID, int empireIndex, StaticString spellUsed)
{
if (!ELCPUtilities.UseELCPSymbiosisBuffs)
{
return(false);
}
ELCPUtilities.SpellUsageTracker spellUsageTracker = ELCPUtilities.spellUsageTracker.Find((ELCPUtilities.SpellUsageTracker s) => s.EncounterGUID == encounterGUID && s.EmpireIndex == empireIndex);
return(spellUsageTracker != null && spellUsageTracker.HasSpellBeenUsed(spellUsed));
}
void IWorldEffectService.RemoveWorldEffectFromOwnerGUID(GameEntityGUID ownerGUID)
{
List <WorldEffect> list = new List <WorldEffect>();
foreach (List <WorldEffect> list2 in this.worldEffects.Values)
{
for (int i = 0; i < list2.Count; i++)
{
if (list2[i].OwnerGUID == ownerGUID)
{
list.Add(list2[i]);
}
}
}
int j = 0;
while (j < list.Count)
{
WorldPosition worldPosition = list[j].WorldPosition;
list[j].Deactivate();
List <WorldEffect> list3 = null;
try
{
list3 = this.worldEffects[worldPosition];
goto IL_D3;
}
catch
{
Diagnostics.LogError("There isn't any effect at the position {0}", new object[]
{
worldPosition.ToString()
});
}
IL_CA:
j++;
continue;
IL_D3:
list3.Remove(list[j]);
if (list3.Count == 0)
{
this.worldEffects.Remove(worldPosition);
}
WorldCircle worldCircle = new WorldCircle(worldPosition, list[j].WorldEffectDefinition.Range);
List <short> list4 = new List <short>();
WorldPosition[] worldPositions = worldCircle.GetWorldPositions(this.WorldPositionningService.World.WorldParameters);
for (int k = 0; k < worldPositions.Length; k++)
{
short regionIndex = this.WorldPositionningService.GetRegionIndex(worldPositions[k]);
if (!list4.Contains(regionIndex))
{
this.WorldPositionSimulationEvaluatorService.SetSomethingChangedOnRegion(regionIndex);
list4.Add(regionIndex);
}
}
goto IL_CA;
}
}
private bool TransferUnits(GameEntityGUID destinationGuid)
{
AIData_Army aidata = this.aiDataRepository.GetAIData <AIData_Army>(base.AIDataArmyGUID);
if (aidata.Army.IsInEncounter || aidata.Army.IsLocked)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer source IsInEncounter or IsLocked");
return(false);
}
IGameEntity gameEntity;
if (!this.gameEntityRepositoryService.TryGetValue(destinationGuid, out gameEntity))
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Destination Guid is not valid");
return(false);
}
IGarrison garrison = gameEntity as IGarrison;
if (garrison == null)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Destination Guid is not a Garrison");
return(false);
}
if (garrison.IsInEncounter)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer destination IsInEncounter");
return(false);
}
if (garrison is Army)
{
Army army = garrison as Army;
if (army.IsLocked)
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer destination IsLocked");
return(false);
}
if (this.worldPositionningService.GetDistance(aidata.Army.WorldPosition, army.WorldPosition) != 1 || !this.pathfindingService.IsTransitionPassable(aidata.Army.WorldPosition, army.WorldPosition, aidata.Army, (PathfindingFlags)0, null))
{
Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] Transfer destination is not valid");
return(false);
}
}
GameEntityGUID[] array = null;
this.ClampUnitToGarrison(garrison, this.UnitGuids, out array);
if (array != null && array.Length != 0)
{
OrderTransferUnits order = new OrderTransferUnits(base.Commander.Empire.Index, base.AIDataArmyGUID, destinationGuid, array, false);
base.Commander.Empire.PlayerControllers.Server.PostOrder(order, out this.currentTicket, new EventHandler <TicketRaisedEventArgs>(this.OrderTransferUnitToArmyTicketRaised));
if (aidata.CommanderMission != this)
{
Diagnostics.LogWarning("LOCKING: [AICommanderMission_RegroupArmyAt] Strange desynchronization between the actual Army CommanderMission and the current CommanderMission");
}
aidata.UnassignCommanderMission();
return(true);
}
return(false);
}
public virtual IEnumerator Initialize(AIEntity aiEntity)
{
if (this.InternalGUID == GameEntityGUID.Zero)
{
this.InternalGUID = AIScheduler.Services.GetService <IAIEntityGUIDAIHelper>().GenerateAIEntityGUID();
}
this.AIEntity = aiEntity;
yield break;
}
public void QuestSetArmy(GameEntityGUID selectedArmyGuid)
{
AIData_Army aidata_Army;
if (this.aiDataRepository.TryGetAIData <AIData_Army>(selectedArmyGuid, out aidata_Army) && aidata_Army.CommanderMission == null)
{
aidata_Army.AssignCommanderMission(this);
this.AIDataArmyGUID = selectedArmyGuid;
}
}
public CreepingNode(GameEntityGUID guid, global::Empire empire, PointOfInterest poi, CreepingNodeImprovementDefinition definition) : this(guid, empire)
{
this.PointOfInterest = poi;
this.NodeDefinition = definition;
this.UpgradeReachedTurn = -1;
this.DismantlingArmyGUID = GameEntityGUID.Zero;
this.Life = 0f;
this.LastTurnWhenDismantleBegun = 0;
this.MaxLife = this.ConstructionTurns * this.NodeDefinition.GrowthPerTurn;
}
private bool GenerateHeroUnitFromHeroDescriptor(GameEntityGUID gameEntityGUID, HeroPool.HeroDescriptor?heroDescriptor, out Unit unit)
{
unit = DepartmentOfDefense.CreateUnitByDesign(gameEntityGUID, heroDescriptor.Value.UnitProfile);
if (unit != null)
{
this.AssignNewUserDefinedName(unit);
return(true);
}
return(false);
}
public static void SpellUsage_UnregisterEncounter(GameEntityGUID encounterGUID)
{
for (int i = 0; i < ELCPUtilities.spellUsageTracker.Count; i++)
{
if (ELCPUtilities.spellUsageTracker[i].EncounterGUID == encounterGUID)
{
ELCPUtilities.spellUsageTracker.RemoveAt(i);
i--;
}
}
}
public District(GameEntityGUID guid) : base("District#" + guid)
{
this.GUID = guid;
this.Level = 0;
this.ResourceOnMigration = string.Empty;
this.lastLineOfSightRange = this.LineOfSightVisionRange;
this.LineOfSightDirty = true;
this.LineOfSightActive = true;
base.Refreshed += this.District_Refreshed;
this.eventService = Services.GetService <IEventService>();
this.eventService.EventRaise += this.EventService_EventRaise;
}
