public void SetOwner(MajorEmpire ownerEmpire)
{
this.MajorEmpire = ownerEmpire;
this.KaijuArmy.Empire = ownerEmpire;
this.KaijuGarrison.Empire = ownerEmpire;
this.tamedTurn = (this.GameService.Game as global::Game).Turn;
}
private float GetWonderProgress(MajorEmpire empire)
{
DepartmentOfTheInterior agency = empire.GetAgency <DepartmentOfTheInterior>();
DepartmentOfIndustry agency2 = empire.GetAgency <DepartmentOfIndustry>();
float num = 0f;
for (int i = 0; i < agency.Cities.Count; i++)
{
Construction construction = agency2.GetConstructionQueue(agency.Cities[i]).Get((Construction x) => x.ConstructibleElement.SubCategory == "SubCategoryVictory");
if (construction != null)
{
for (int j = 0; j < construction.CurrentConstructionStock.Length; j++)
{
if (construction.CurrentConstructionStock[j].PropertyName == "Production")
{
float stock = construction.CurrentConstructionStock[j].Stock;
if (stock > 0f)
{
float num2 = stock / DepartmentOfTheTreasury.GetProductionCostWithBonus(agency.Cities[i], construction.ConstructibleElement, "Production");
if (num2 > num)
{
num = num2;
}
}
}
}
}
}
return(num);
}
public void ChangeToTamedState(MajorEmpire majorEmpire)
{
if (this.IsWild())
{
SimulationDescriptor value = this.SimulationDescriptorDatabase.GetValue(Kaiju.KaijuStatusWild);
base.RemoveDescriptor(value);
}
else if (this.IsStunned())
{
SimulationDescriptor value2 = this.SimulationDescriptorDatabase.GetValue(Kaiju.KaijuStatusStunned);
base.RemoveDescriptor(value2);
}
SimulationDescriptor value3 = this.SimulationDescriptorDatabase.GetValue(Kaiju.KaijuStatusTamed);
base.AddDescriptor(value3, false);
this.Refresh(false);
this.ComputeNextTurnToSpawnUnits(false);
this.KaijuGarrison.CallRefreshAppliedRegionEffects();
this.KaijuArmy.OnTamed();
EventKaijuTamed eventToNotify = new EventKaijuTamed(this.majorEmpire, this);
this.EventService.Notify(eventToNotify);
foreach (global::Empire empire in (this.gameService.Game as global::Game).Empires)
{
if (empire is MajorEmpire && empire != this.majorEmpire)
{
this.eventService.Notify(new GlobalEventKaijuTamed(empire, this));
}
}
}
private void KaijuLostEncounter(Kaiju kaiju, global::Empire stunner, bool setKaijuFree)
{
bool flag = Amplitude.Unity.Runtime.Runtime.Registry.GetValue <bool>("Gameplay/Kaiju/KaijuAutoTameBeforeLoseEncounter", true);
bool relocate = false;
if (setKaijuFree)
{
flag = false;
relocate = true;
}
global::PlayerController server = this.KaijuEmpire.PlayerControllers.Server;
if (kaiju.IsTamed())
{
MajorEmpire majorEmpire = kaiju.MajorEmpire;
if (server != null)
{
OrderUntameKaiju order = new OrderUntameKaiju(kaiju, relocate, stunner.Index, flag);
server.PostOrder(order);
}
}
else if (flag)
{
if (server != null)
{
OrderTameKaiju order2 = new OrderTameKaiju(stunner.Index, kaiju, null);
server.PostOrder(order2);
}
}
else
{
this.Kaiju.ChangeToStunState(stunner);
this.ResetRelocationETA();
}
}
public override void UpdateRole()
{
base.Role = BaseNavyArmy.ArmyRole.Forteress;
this.WantToKeepArmyFitness.Reset();
NavyRegionData navyRegionData = base.Commander.RegionData as NavyRegionData;
this.WantToKeepArmyFitness.Add(0.3f, "constant", new object[0]);
if (navyRegionData.NumberOfWaterEnemy > 0)
{
HeuristicValue heuristicValue = new HeuristicValue(0f);
heuristicValue.Add((float)navyRegionData.NumberOfWaterEnemy, "Number of enemy water region around.", new object[0]);
heuristicValue.Multiply(0.1f, "boost constant", new object[0]);
heuristicValue.Min(0.5f, "Avoid too big factor!", new object[0]);
this.WantToKeepArmyFitness.Boost(heuristicValue, "Water region owned by enemy around.", new object[0]);
}
if (navyRegionData.NumberOfEnemyCityOnTheBorder > 0)
{
this.WantToKeepArmyFitness.Boost(0.2f, "Enemy city in the region.", new object[0]);
}
if (navyRegionData.EnemyNavalPower > 0f)
{
this.WantToKeepArmyFitness.Boost(0.9f, "Enemy roaming in the region.", new object[0]);
}
MajorEmpire occupant = this.Fortress.Occupant;
if (occupant != null && !AILayer_Military.AreaIsSave(this.Fortress.WorldPosition, 10, occupant.GetAgency <DepartmentOfForeignAffairs>(), true))
{
this.WantToKeepArmyFitness.Boost(0.9f, "Enemy roaming in the region.", new object[0]);
}
}
private List <Kaiju> GetFilterKaijuTargets(bool includeTamedKaijus)
{
List <Kaiju> list = new List <Kaiju>();
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
foreach (global::Empire empire in (service.Game as global::Game).Empires)
{
if (empire is KaijuEmpire)
{
KaijuEmpire kaijuEmpire = empire as KaijuEmpire;
if (kaijuEmpire != null && kaijuEmpire.Region != null)
{
KaijuCouncil agency = kaijuEmpire.GetAgency <KaijuCouncil>();
if (agency != null && agency.Kaiju != null)
{
list.Add(agency.Kaiju);
}
}
}
else if (includeTamedKaijus && empire is MajorEmpire && empire.Index != base.AIEntity.Empire.Index)
{
MajorEmpire majorEmpire = empire as MajorEmpire;
foreach (Kaiju item in majorEmpire.TamedKaijus)
{
if (!this.departmentOfForeignAffairs.IsFriend(majorEmpire))
{
list.Add(item);
}
}
}
}
return(list);
}
public void AddConvertVillageOnLoad(Village village, MajorEmpire converter)
{
if (converter == null)
{
throw new ArgumentNullException("converter");
}
SimulationDescriptor value = this.SimulationDescriptorDatabase.GetValue(BarbarianCouncil.VillageStatusConverted);
village.SwapDescriptor(value);
if (!village.HasBeenConverted)
{
if (village.HasBeenPacified)
{
village.HasBeenPacified = false;
}
SimulationDescriptor value2 = this.SimulationDescriptorDatabase.GetValue(Village.ConvertedVillage);
if (value2 != null)
{
Diagnostics.Assert(village.PointOfInterest != null);
village.PointOfInterest.SwapDescriptor(value2);
village.SwapDescriptor(value2);
}
village.Converter = converter;
if (village.Converter.ConvertedVillages != null && village.Converter.ConvertedVillages.Contains(village))
{
village.Converter.AddChild(village);
}
DepartmentOfTheInterior.GenerateFIMSEForConvertedVillage(village.Converter, village.PointOfInterest);
}
}
public static ConstructionCost[] GetConvertionCost(MajorEmpire majorEmpire, Village village)
{
Diagnostics.Assert(majorEmpire != null);
Diagnostics.Assert(village.PointOfInterest != null);
float num;
if (village.PointOfInterest.PointOfInterestImprovement == null)
{
num = village.GetPropertyValue(SimulationProperties.ConvertDestructedCost);
}
else if (!village.Region.IsRegionColonized() || village.Region.Owner == majorEmpire || village.Region.Owner == null || !(village.Region.Owner is MajorEmpire))
{
num = village.GetPropertyValue(SimulationProperties.ConvertNeutralCost);
}
else
{
num = village.GetPropertyValue(SimulationProperties.ConvertHostileCost);
}
num += num * (float)majorEmpire.ConvertedVillages.Count;
float propertyValue = majorEmpire.GetPropertyValue(SimulationProperties.ConvertVillageMultiplier);
if (propertyValue > 0f)
{
num *= propertyValue;
}
return(new ConstructionCost[]
{
new ConstructionCost(DepartmentOfTheTreasury.Resources.EmpirePoint, (float)Math.Floor((double)num), true, false)
});
}
private void OnVisibityRefreshed(object sender, VisibilityRefreshedEventArgs args)
{
MajorEmpire majorEmpire = args.Empire as MajorEmpire;
if (majorEmpire == null)
{
return;
}
DepartmentOfScience agency = majorEmpire.GetAgency <DepartmentOfScience>();
for (int i = 0; i < this.majorEmpires.Length; i++)
{
global::Empire empire = this.majorEmpires[i];
if (majorEmpire.Index != empire.Index)
{
WorldPosition worldPosition = this.CheckMetting(majorEmpire, empire);
if (worldPosition != WorldPosition.Invalid)
{
WorldPosition worldPosition2 = this.CheckMetting(empire, majorEmpire);
if (worldPosition2 != WorldPosition.Invalid)
{
this.OnEmpireSymetricDiscovery(majorEmpire, empire, worldPosition, worldPosition2);
}
else if (agency.GetTechnologyState(this.technologyDefinitionDrakkenVisionDuringFirstTurn) == DepartmentOfScience.ConstructibleElement.State.Researched)
{
this.OnEmpireAsymetricDiscovery(majorEmpire, empire, worldPosition);
}
}
}
}
}
private void RefreshLineOfSight(IVisibilityArea visibilityArea, int needRefreshBits)
{
MajorEmpire majorEmpire = visibilityArea.Empire as MajorEmpire;
if (majorEmpire == null)
{
if (visibilityArea.VisibilityDirty && visibilityArea.Empire != null)
{
visibilityArea.VisibilityDirty = false;
}
return;
}
if ((needRefreshBits & majorEmpire.Bits) != majorEmpire.Bits)
{
return;
}
visibilityArea.VisibilityDirty = false;
foreach (WorldPosition worldPosition in visibilityArea.VisibleWorldPositions)
{
if (worldPosition.IsValid && worldPosition.Row < this.world.WorldParameters.Rows && worldPosition.Column < this.world.WorldParameters.Columns)
{
this.SetWorldPositionAsVisible(worldPosition, majorEmpire, 0, visibilityArea.VisibilityAccessibilityLevel);
if (ELCPUtilities.SpectatorMode)
{
foreach (int num in ELCPUtilities.EliminatedEmpireIndices)
{
this.SetWorldPositionAsVisible(worldPosition, base.Game.Empires[num], 0, visibilityArea.VisibilityAccessibilityLevel);
}
}
}
}
}
public WorldPosition GetRandomValidArmyPosition(Village village)
{
WorldOrientation orientation = (WorldOrientation)this.random.Next(0, 6);
WorldPosition result = WorldPosition.Invalid;
for (int i = 0; i < 6; i++)
{
WorldOrientation direction = orientation.Rotate(i);
WorldPosition neighbourg = this.worldPositionningService.GetNeighbourTile(village.WorldPosition, direction, 1);
int regionIndex = (int)this.worldPositionningService.GetRegionIndex(neighbourg);
if (regionIndex == village.Region.Index)
{
if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourg, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water))
{
global::Empire[] empires = (this.GameService.Game as global::Game).Empires;
int j = 0;
while (j < empires.Length)
{
global::Empire empire = empires[j];
if (!(empire is KaijuEmpire))
{
goto IL_106;
}
KaijuEmpire kaijuEmpire = empire as KaijuEmpire;
if (kaijuEmpire == null)
{
goto IL_106;
}
KaijuCouncil agency = kaijuEmpire.GetAgency <KaijuCouncil>();
if (agency == null || agency.Kaiju == null || !(agency.Kaiju.WorldPosition == neighbourg))
{
goto IL_106;
}
IL_145:
j++;
continue;
IL_106:
if (!(empire is MajorEmpire))
{
goto IL_145;
}
MajorEmpire majorEmpire = empire as MajorEmpire;
if (majorEmpire == null || majorEmpire.TamedKaijus.Any((Kaiju m) => m.WorldPosition == neighbourg))
{
goto IL_145;
}
goto IL_145;
}
District district = this.worldPositionningService.GetDistrict(neighbourg);
if (district == null || !District.IsACityTile(district))
{
result = neighbourg;
break;
}
}
}
}
return(result);
}
private void CreateEmpireFilters(List <global::Empire> empiresToSelect = null)
{
if (empiresToSelect != null && empiresToSelect.Count == 1 && empiresToSelect[0] == base.Empire)
{
empiresToSelect.Clear();
}
this.empireToFilter.Clear();
DepartmentOfIntelligence agency = base.Empire.GetAgency <DepartmentOfIntelligence>();
bool flag = DepartmentOfTheInterior.CanSeeAllExchangeTransactions(base.Empire);
global::Game game = base.Game as global::Game;
for (int i = 0; i < game.Empires.Length; i++)
{
MajorEmpire majorEmpire = game.Empires[i] as MajorEmpire;
if (majorEmpire != null)
{
if (base.Empire.Index == majorEmpire.Index)
{
this.empireToFilter.Add(majorEmpire);
}
else if (!majorEmpire.IsEliminated)
{
DepartmentOfScience agency2 = majorEmpire.GetAgency <DepartmentOfScience>();
if (agency2.CanTradeHeroes(true) || agency2.CanTradeUnits(true) || agency2.CanTradeResourcesAndBoosters(true))
{
if (flag)
{
this.empireToFilter.Add(majorEmpire);
}
else if (agency != null && agency.IsEmpireInfiltrated(majorEmpire))
{
this.empireToFilter.Add(majorEmpire);
}
}
}
}
}
this.empireFilterWidth = Mathf.Floor((this.EmpireFiltersContainer.Width - this.EmpireFiltersContainer.HorizontalSpacing * (float)(this.empireToFilter.Count - 1)) / (float)this.empireToFilter.Count);
this.EmpireFiltersContainer.ReserveChildren(this.empireToFilter.Count, this.EmpireFilterPrefab, "EmpireFilterToggle");
this.EmpireFiltersContainer.RefreshChildrenIList <global::Empire>(this.empireToFilter, new AgeTransform.RefreshTableItem <global::Empire>(this.SetupEmpireFilterToggle), true, false);
this.EmpireFiltersContainer.ArrangeChildren();
if (empiresToSelect != null && empiresToSelect.Count > 0)
{
this.SetEmpiresToShow(empiresToSelect);
}
else
{
this.SetEmpiresToShow(this.empireToFilter);
}
AgeTooltip ageTooltip = this.EmpireFilterPrefab.GetComponent <AgeTransform>().AgeTooltip;
if (ageTooltip != null)
{
ageTooltip.Content = "%MarketplaceEmpireFilterDescription";
}
}
public override void RefreshContent()
{
base.RefreshContent();
if (base.Empire == null)
{
return;
}
if (this.diplomaticRelationsViewport != null)
{
this.diplomaticRelationsViewport.Refresh();
}
float num = 0f;
float num2 = 1f;
MajorEmpire majorEmpire = base.Empire as MajorEmpire;
if (majorEmpire.VictoryConditionStatuses.ContainsKey("Diplomacy") && ELCPUtilities.UseELCPPeacePointRulseset)
{
this.DiplomaticScoreContainer.Visible = true;
num = base.Empire.GetPropertyValue("EmpirePeacePointStock");
float propertyValue = base.Empire.GetPropertyValue("PeacePointBucketStock");
float value = Mathf.Min(propertyValue, base.Empire.GetPropertyValue("TreatyPeacePointPerTurn"));
float propertyValue2 = base.Empire.GetPropertyValue("NetEmpirePeacePoint");
this.DiplomaticScore.Text = AgeLocalizer.Instance.LocalizeString("%ELCPDiplomacyScreenDiplomaticScoreFormat").Replace("$BucketValue", GuiFormater.FormatGui(propertyValue, false, false, false, 0));
this.DiplomaticScore.Text = this.DiplomaticScore.Text.Replace("$BucketNet", GuiFormater.FormatGui(value, false, false, false, 0));
this.DiplomaticScore.Text = this.DiplomaticScore.Text.Replace("$PPValue", GuiFormater.FormatGui(num, false, false, false, 0));
this.DiplomaticScore.Text = this.DiplomaticScore.Text.Replace("$PPNet", GuiFormater.FormatGui(propertyValue2, false, false, false, 0));
this.DiplomaticScore.Alignement = AgeTextAnchor.LowerCenter;
this.victoryService = base.Game.Services.GetService <IVictoryManagementService>();
foreach (VictoryCondition victoryCondition in this.victoryService.VictoryConditionsFilteredThisGame)
{
if (victoryCondition.Name == "Diplomacy")
{
for (int i = 0; i < victoryCondition.Progression.Vars.Length; i++)
{
if (victoryCondition.Progression.Vars[i].Name == "TargetValue")
{
num2 = majorEmpire.VictoryConditionStatuses["Diplomacy"].Variables[i];
}
}
if (this.DiplomaticScoreContainer.AgeTooltip != null)
{
this.DiplomaticScoreContainer.AgeTooltip.Content = AgeLocalizer.Instance.LocalizeString("%VictoryConditionDiplomacyDescription").Replace("$TargetValue", GuiFormater.FormatGui(num2, false, false, false, 0));
}
}
}
this.DiplomaticGauge.Visible = false;
this.DiplomaticGauge.GetParent().Visible = false;
this.DiplomaticGauge.PercentRight = Mathf.Clamp(100f * (num / num2), 0f, 100f);
return;
}
this.DiplomaticScoreContainer.Visible = false;
}
public void SetContent(MajorEmpire majorEmpire)
{
this.MajorEmpire = majorEmpire;
Diagnostics.Assert(this.MajorEmpire != null);
this.GuiFaction = new GuiFaction(this.MajorEmpire.Faction);
IGameService service = Services.GetService <IGameService>();
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.ActivePlayerEmpire = (service2.ActivePlayerController.Empire as global::Empire);
ISessionService service3 = Services.GetService <ISessionService>();
this.Session = (service3.Session as global::Session);
this.HighlightCircle.Visible = false;
}
public bool CheckAgainstQuestInitiatorFilter(QuestBehaviour questBehavior, GameEvent e, QuestInitiatorFilter questInitiatorFilter)
{
Diagnostics.Assert(questBehavior.Initiator is MajorEmpire);
MajorEmpire majorEmpire = e.Empire as MajorEmpire;
MajorEmpire majorEmpire2 = questBehavior.Initiator as MajorEmpire;
switch (questInitiatorFilter)
{
case QuestInitiatorFilter.AllEmpires:
return(true);
case QuestInitiatorFilter.Allies:
{
if (majorEmpire == null)
{
return(false);
}
bool bits = majorEmpire.Bits != 0;
int bits2 = majorEmpire2.Bits;
if (((bits ? 1 : 0) & bits2) != 0)
{
return(true);
}
break;
}
case QuestInitiatorFilter.Empire:
if (e.Empire.Index == questBehavior.Initiator.Index)
{
return(true);
}
break;
case QuestInitiatorFilter.Enemies:
if (e.Empire.Index != questBehavior.Initiator.Index)
{
return(true);
}
break;
case QuestInitiatorFilter.OtherEmpires:
if (e.Empire.Index != questBehavior.Initiator.Index)
{
return(true);
}
break;
}
return(false);
}
public void NotifyVisibilityHasChanged(Empire empire)
{
if (empire == null)
{
throw new ArgumentNullException("empire");
}
MajorEmpire majorEmpire = empire as MajorEmpire;
if (majorEmpire == null)
{
return;
}
this.NeedRefreshBits |= majorEmpire.Bits;
this.OnVisibilityRefreshed(empire);
}
public bool IsWorldPositionExploredFor(WorldPosition worldPosition, Empire empire)
{
if (!worldPosition.IsValid)
{
return(false);
}
MajorEmpire majorEmpire = empire as MajorEmpire;
if (majorEmpire == null)
{
return(true);
}
short value = this.explorationMap.GetValue(worldPosition);
return(((int)value & majorEmpire.Bits) == majorEmpire.Bits);
}
private float GetAttitudeValue(StaticString modifierName, AIHeuristicAnalyser.Context debugContext)
{
float num = 0f;
IGameService service = Services.GetService <IGameService>();
global::Game game = service.Game as global::Game;
for (int i = 0; i < game.Empires.Length; i++)
{
MajorEmpire majorEmpire = game.Empires[i] as MajorEmpire;
if (majorEmpire != null && majorEmpire.Index != base.AIEntity.Empire.Index)
{
AILayer_Attitude.Attitude attitude = this.aiLayerAttitude.GetAttitude(majorEmpire);
num = Mathf.Max(num, attitude.Score.GetNormalizedScoreByName(modifierName));
}
}
return(num);
}
private void PostOrderGetAIDiplomaticTermsEvaluation()
{
MajorEmpire majorEmpire = this.selectedEmpire as MajorEmpire;
MajorEmpire majorEmpire2 = base.Empire as MajorEmpire;
if (majorEmpire == null || majorEmpire2 == null)
{
return;
}
List <DiplomaticTerm> list = new List <DiplomaticTerm>();
DepartmentOfForeignAffairs.GetAllAvailableDiplomaticTerm(this.DiplomaticContract, base.Empire, this.SelectedEmpire, ref list);
DepartmentOfForeignAffairs.GetAllAvailableDiplomaticTerm(this.DiplomaticContract, this.SelectedEmpire, base.Empire, ref list);
OrderGetAIDiplomaticTermEvaluation order = new OrderGetAIDiplomaticTermEvaluation(majorEmpire, majorEmpire2, list.ToArray());
Ticket ticket;
base.PlayerController.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OnPostOrderGetAIDiplomaticTermsEvaluationResponse));
}
private void CheckForEliminations(IVictoryManagementService victoryManagementService)
{
foreach (Empire empire in base.GameServer.Game.Empires)
{
MajorEmpire majorEmpire = empire as MajorEmpire;
if (majorEmpire == null)
{
break;
}
if (majorEmpire.SimulationObject.Tags.Contains(Empire.TagEmpireEliminated))
{
foreach (Empire empire2 in base.GameServer.Game.Empires)
{
empire2.OnEmpireEliminated(majorEmpire, true);
}
}
}
}
public void MajorEmpireTameKaiju(MajorEmpire owner, bool clearMilitias = false)
{
if (owner == null)
{
throw new ArgumentNullException("Empire trying to tame Kaiju is null");
}
if (clearMilitias)
{
this.Kaiju.ClearMilitias();
}
this.departmentOfDefense.RemoveArmy(this.Kaiju.KaijuArmy, false);
this.Kaiju.SetOwner(owner);
owner.AddTamedKaiju(this.Kaiju);
this.Kaiju.ChangeToTamedState(owner);
this.KaijuEmpire.RemoveKaiju(this.Kaiju);
this.KaijuEmpire.Refresh(false);
this.Kaiju = null;
}
public bool TryGetMajorEmpireAIPlayer(MajorEmpire majorEmpire, out AIPlayer_MajorEmpire aiPlayerMajorEmpire)
{
if (majorEmpire == null)
{
throw new ArgumentNullException("majorEmpire");
}
aiPlayerMajorEmpire = null;
Diagnostics.Assert(this.aiPlayerMajorEmpires != null);
for (int i = 0; i < this.aiPlayerMajorEmpires.Count; i++)
{
AIPlayer_MajorEmpire aiplayer_MajorEmpire = this.aiPlayerMajorEmpires[i];
Diagnostics.Assert(aiplayer_MajorEmpire != null && aiplayer_MajorEmpire.MajorEmpire != null);
if (aiplayer_MajorEmpire.MajorEmpire.Index == majorEmpire.Index)
{
aiPlayerMajorEmpire = aiplayer_MajorEmpire;
return(true);
}
}
return(false);
}
public void ConvertVillage(Village village, MajorEmpire converter)
{
if (converter == null)
{
throw new ArgumentNullException("converter");
}
SimulationDescriptor value = this.SimulationDescriptorDatabase.GetValue(BarbarianCouncil.VillageStatusConverted);
village.SwapDescriptor(value);
if (!village.HasBeenConverted)
{
if (village.HasBeenPacified)
{
village.HasBeenPacified = false;
}
SimulationDescriptor value2 = this.SimulationDescriptorDatabase.GetValue(Village.ConvertedVillage);
if (value2 != null)
{
Diagnostics.Assert(village.PointOfInterest != null);
village.PointOfInterest.SwapDescriptor(value2);
village.SwapDescriptor(value2);
}
for (int i = village.StandardUnits.Count - 1; i >= 0; i--)
{
Unit unit = village.StandardUnits[i];
this.GameEntityRepositoryService.Unregister(unit);
village.RemoveUnit(unit);
unit.Dispose();
}
village.Converter = converter;
village.ConvertedUnitSpawnTurn = (this.GameService.Game as global::Game).Turn + village.GetConvertedUnitProductionTimer();
EventVillageConverted eventToNotify = new EventVillageConverted(converter, village);
this.EventService.Notify(eventToNotify);
if (village.Converter.ConvertedVillages != null)
{
Diagnostics.Assert(!village.Converter.ConvertedVillages.Contains(village));
village.Converter.AddConvertedVillage(village);
}
DepartmentOfTheInterior.GenerateFIMSEForConvertedVillage(village.Converter, village.PointOfInterest);
}
}
public static string FormatDiplomaticInteraction(string interactionType, MajorEmpire empire)
{
string text = "%DiplomaticInteraction" + interactionType;
ILocalizationService service = Services.GetService <ILocalizationService>();
string text2 = empire.Faction.Affinity.Name.ToString();
if (text2.StartsWith("Affinity") && text2.Length > 8)
{
text2 = text2.Substring(8);
}
string text3 = service.Localize(text + "_" + text2);
if (string.IsNullOrEmpty(text3))
{
text3 = service.Localize(text);
if (string.IsNullOrEmpty(text3))
{
text3 = text;
}
}
return(text3);
}
public bool IsWorldPositionDetectedFor(WorldPosition worldPosition, Empire empire)
{
if (!this.EnableDetection)
{
return(false);
}
if (!worldPosition.IsValid)
{
return(false);
}
MajorEmpire majorEmpire = empire as MajorEmpire;
if (majorEmpire == null)
{
return(true);
}
short num = 0;
num |= this.publicDetectionMap.GetValue(worldPosition);
num |= this.privateDetectionMap.GetValue(worldPosition);
return(((int)num & majorEmpire.Bits) != 0);
}
public void RemoveOwner(int instigatorEmpireIndex = -1)
{
MajorEmpire majorEmpire = this.MajorEmpire;
if (majorEmpire != null)
{
int takenFromEmpire = this.PreviousOwnerIndex;
this.previousOwnerIndex = majorEmpire.Index;
majorEmpire.RemoveTamedKaiju(this);
this.ReleaseKaijuArmyActions();
this.MajorEmpire = null;
this.KaijuArmy.Empire = this.KaijuEmpire;
this.KaijuGarrison.Empire = this.KaijuEmpire;
EventKaijuLost.KaijuLostReason kaijuLostReason = EventKaijuLost.KaijuLostReason.FREE;
if (instigatorEmpireIndex != -1)
{
kaijuLostReason = EventKaijuLost.KaijuLostReason.STUN;
this.previousStunnerIndex = instigatorEmpireIndex;
this.previousStunnedTurn = (this.GameService.Game as global::Game).Turn;
}
this.EventService.Notify(new EventKaijuLost(majorEmpire, this, instigatorEmpireIndex, kaijuLostReason, takenFromEmpire));
}
}
void IVictoryManagementService.CheckForAlerts(int turn)
{
if (turn < 0 || this.HasAlreadyWon)
{
return;
}
Diagnostics.Assert(this.InterpreterContext != null);
Snapshot snapshot = null;
IGameStatisticsManagementService service = Services.GetService <IGameStatisticsManagementService>();
if (service != null && service.Snapshot != null)
{
string name = string.Format("Turn #{0}", turn);
if (!service.Snapshot.TryGetSnapshot(name, out snapshot))
{
Diagnostics.LogWarning("Skipping check because snapshot is missing (turn: {0}).", new object[]
{
turn
});
return;
}
if (snapshot != null)
{
foreach (KeyValuePair <string, float> keyValuePair in snapshot.KeyValuePairs)
{
this.InterpreterContext.Register(keyValuePair.Key, keyValuePair.Value);
}
}
}
Diagnostics.Assert(base.Game != null);
this.InterpreterContext.Register("Turn", base.Game.Turn);
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
for (int i = 0; i < base.Game.Empires.Length; i++)
{
MajorEmpire majorEmpire = base.Game.Empires[i] as MajorEmpire;
if (majorEmpire == null)
{
break;
}
num++;
num3++;
if (majorEmpire.SimulationObject.Tags.Contains(Empire.TagEmpireEliminated))
{
num2++;
num3--;
}
else
{
for (int j = 0; j < this.simulationPathNumberOfMainCities.Length; j++)
{
num4 += (int)this.simulationPathNumberOfMainCities[j].CountValidatedObjects(majorEmpire);
}
DepartmentOfTheInterior agency = majorEmpire.GetAgency <DepartmentOfTheInterior>();
if (agency != null)
{
num5 += agency.Cities.Count;
}
}
}
this.InterpreterContext.Register("NumberOfMajorEmpires", num);
this.InterpreterContext.Register("NumberOfMajorEmpiresEliminated", num2);
this.InterpreterContext.Register("NumberOfMajorEmpiresLeft", num3);
this.InterpreterContext.Register("NumberOfMainCitiesLeft", num4);
this.InterpreterContext.Register("NumberOfCitiesLeft", num5);
for (int k = 0; k < base.Game.Empires.Length; k++)
{
MajorEmpire majorEmpire2 = base.Game.Empires[k] as MajorEmpire;
if (majorEmpire2 == null)
{
break;
}
if (snapshot != null)
{
Snapshot snapshot2 = snapshot.TakeSnapshot(majorEmpire2.Name);
if (snapshot2 != null)
{
foreach (KeyValuePair <string, float> keyValuePair2 in snapshot2.KeyValuePairs)
{
this.InterpreterContext.Register(keyValuePair2.Key, keyValuePair2.Value);
}
}
}
try
{
int num6 = 0;
for (int l = 0; l < this.simulationPathNumberOfMainCities.Length; l++)
{
num6 += (int)this.simulationPathNumberOfMainCities[l].CountValidatedObjects(majorEmpire2);
}
this.InterpreterContext.Register("NumberOfMainCities", num6);
this.InterpreterContext.Register("VictoryWonderProgress", this.GetWonderProgress(majorEmpire2));
majorEmpire2.SimulationObject.AddChild(this.InterpreterContext.SimulationObject);
foreach (VictoryCondition victoryCondition in this.VictoryConditionsFilteredThisGame)
{
if (majorEmpire2.VictoryConditionStatuses != null)
{
MajorEmpire.VictoryConditionStatus victoryConditionStatus;
if (!majorEmpire2.VictoryConditionStatuses.TryGetValue(victoryCondition.Name, out victoryConditionStatus))
{
victoryConditionStatus = new MajorEmpire.VictoryConditionStatus();
majorEmpire2.VictoryConditionStatuses.Add(victoryCondition.Name, victoryConditionStatus);
}
if (victoryCondition.Alerts != null)
{
if (victoryConditionStatus.LastTurnWhenAlertWasTriggered == null || victoryConditionStatus.LastTurnWhenAlertWasTriggered.Length != victoryCondition.Alerts.Length)
{
victoryConditionStatus.LastTurnWhenAlertWasTriggered = new int[victoryCondition.Alerts.Length];
}
for (int m = 0; m < victoryCondition.Alerts.Length; m++)
{
VictoryCondition.Alert alert = victoryCondition.Alerts[m];
if (alert != null && (victoryConditionStatus.LastTurnWhenAlertWasTriggered[m] == 0 || (victoryConditionStatus.LastTurnWhenAlertWasTriggered[m] < 0 && alert.Repeat)))
{
if (alert.Evaluate(this.InterpreterContext))
{
victoryConditionStatus.LastTurnWhenAlertWasTriggered[m] = base.Game.Turn;
}
else if (victoryConditionStatus.LastTurnWhenAlertWasTriggered[m] > 0)
{
victoryConditionStatus.LastTurnWhenAlertWasTriggered[m] = -victoryConditionStatus.LastTurnWhenAlertWasTriggered[m];
}
}
}
}
if (victoryCondition.Progression != null)
{
if (victoryConditionStatus.Variables == null || victoryConditionStatus.Variables.Length != victoryCondition.Progression.Vars.Length)
{
victoryConditionStatus.Variables = new float[victoryCondition.Progression.Vars.Length];
}
for (int n = 0; n < victoryCondition.Progression.Vars.Length; n++)
{
victoryConditionStatus.Variables[n] = victoryCondition.Progression.Vars[n].Evaluate(this.InterpreterContext);
}
}
}
}
}
catch
{
}
finally
{
majorEmpire2.SimulationObject.RemoveChild(this.InterpreterContext.SimulationObject);
}
}
for (int num7 = 0; num7 < base.Game.Empires.Length; num7++)
{
MajorEmpire majorEmpire3 = base.Game.Empires[num7] as MajorEmpire;
if (majorEmpire3 == null)
{
break;
}
foreach (VictoryCondition victoryCondition2 in this.VictoryConditionsFilteredThisGame)
{
MajorEmpire.VictoryConditionStatus victoryConditionStatus2;
if (victoryCondition2.Alerts != null && majorEmpire3.VictoryConditionStatuses != null && majorEmpire3.VictoryConditionStatuses.TryGetValue(victoryCondition2.Name, out victoryConditionStatus2))
{
for (int num8 = 0; num8 < victoryCondition2.Alerts.Length; num8++)
{
if (victoryConditionStatus2.LastTurnWhenAlertWasTriggered != null && num8 < victoryConditionStatus2.LastTurnWhenAlertWasTriggered.Length && victoryConditionStatus2.LastTurnWhenAlertWasTriggered[num8] >= base.Game.Turn && victoryCondition2.Alerts[num8] != null)
{
EventVictoryConditionAlert eventToNotify = new EventVictoryConditionAlert(majorEmpire3, victoryCondition2, victoryConditionStatus2, num8);
this.EventService.Notify(eventToNotify);
}
}
}
}
}
}
void IVictoryManagementService.CheckForVictoryConditions(int turn)
{
if (turn <= this.TurnWhenVictoryConditionsWereLastChecked)
{
Diagnostics.Log("Skipping check because victory conditions have already been already checked for (turn: {0}, last checked: {1}).", new object[]
{
turn,
this.TurnWhenVictoryConditionsWereLastChecked
});
return;
}
this.TurnWhenVictoryConditionsWereLastChecked = turn;
this.VictoryConditionsRaisedThisTurn.Clear();
Diagnostics.Assert(this.InterpreterContext != null);
Snapshot snapshot = null;
IGameStatisticsManagementService service = Services.GetService <IGameStatisticsManagementService>();
if (service != null && service.Snapshot != null)
{
string name = string.Format("Turn #{0}", turn);
if (!service.Snapshot.TryGetSnapshot(name, out snapshot))
{
Diagnostics.LogWarning("Skipping check because snapshot is missing (turn: {0}, last checked: {1}).", new object[]
{
turn,
this.TurnWhenVictoryConditionsWereLastChecked
});
return;
}
if (snapshot != null)
{
foreach (KeyValuePair <string, float> keyValuePair in snapshot.KeyValuePairs)
{
this.InterpreterContext.Register(keyValuePair.Key, keyValuePair.Value);
}
}
}
Diagnostics.Assert(base.Game != null);
this.InterpreterContext.Register("Turn", base.Game.Turn);
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
for (int i = 0; i < base.Game.Empires.Length; i++)
{
MajorEmpire majorEmpire = base.Game.Empires[i] as MajorEmpire;
if (majorEmpire == null)
{
break;
}
num++;
num3++;
if (majorEmpire.SimulationObject.Tags.Contains(Empire.TagEmpireEliminated))
{
num2++;
num3--;
}
else
{
for (int j = 0; j < this.simulationPathNumberOfMainCities.Length; j++)
{
num4 += (int)this.simulationPathNumberOfMainCities[j].CountValidatedObjects(majorEmpire);
}
DepartmentOfTheInterior agency = majorEmpire.GetAgency <DepartmentOfTheInterior>();
if (agency != null)
{
num5 += agency.Cities.Count;
}
}
}
this.InterpreterContext.Register("NumberOfMajorEmpires", num);
this.InterpreterContext.Register("NumberOfMajorEmpiresEliminated", num2);
this.InterpreterContext.Register("NumberOfMajorEmpiresLeft", num3);
this.InterpreterContext.Register("NumberOfMainCitiesLeft", num4);
this.InterpreterContext.Register("NumberOfCitiesLeft", num5);
for (int k = 0; k < base.Game.Empires.Length; k++)
{
MajorEmpire majorEmpire2 = base.Game.Empires[k] as MajorEmpire;
if (majorEmpire2 == null)
{
break;
}
if (snapshot != null)
{
Snapshot snapshot2 = snapshot.TakeSnapshot(majorEmpire2.Name);
if (snapshot2 != null)
{
foreach (KeyValuePair <string, float> keyValuePair2 in snapshot2.KeyValuePairs)
{
this.InterpreterContext.Register(keyValuePair2.Key, keyValuePair2.Value);
}
}
}
try
{
int num6 = 0;
for (int l = 0; l < this.simulationPathNumberOfMainCities.Length; l++)
{
num6 += (int)this.simulationPathNumberOfMainCities[l].CountValidatedObjects(majorEmpire2);
}
this.InterpreterContext.Register("NumberOfMainCities", num6);
majorEmpire2.SimulationObject.AddChild(this.InterpreterContext.SimulationObject);
bool flag = false;
VictoryCondition victoryCondition = null;
foreach (VictoryCondition victoryCondition2 in this.VictoryConditionsFilteredThisGame)
{
if (victoryCondition2.Evaluate(new object[]
{
this.InterpreterContext
}))
{
if (victoryCondition2.Name == "Shared")
{
victoryCondition = victoryCondition2;
}
else if (!majorEmpire2.SimulationObject.Tags.Contains(Empire.TagEmpireEliminated))
{
this.OnVictoryConditionRaised(new VictoryConditionRaisedEventArgs(victoryCondition2, majorEmpire2));
flag = true;
}
}
}
if (victoryCondition != null && flag)
{
DepartmentOfForeignAffairs agency2 = majorEmpire2.GetAgency <DepartmentOfForeignAffairs>();
if (agency2 != null && agency2.DiplomaticRelations != null)
{
foreach (Empire empire in base.Game.Empires)
{
if (empire != majorEmpire2)
{
DiplomaticRelation diplomaticRelation = agency2.GetDiplomaticRelation(empire);
if (diplomaticRelation != null && diplomaticRelation.State != null && diplomaticRelation.State.Name == DiplomaticRelationState.Names.Alliance)
{
this.OnVictoryConditionRaised(new VictoryConditionRaisedEventArgs(victoryCondition, empire));
}
}
}
}
}
}
catch
{
}
finally
{
majorEmpire2.SimulationObject.RemoveChild(this.InterpreterContext.SimulationObject);
}
}
}
public static EmpireInfo Read(Amplitude.Unity.Session.Session session, int empireIndex)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
if (empireIndex < 0)
{
throw new IndexOutOfRangeException("Empire index must be a positive integer.");
}
if (empireIndex == 0)
{
try
{
string lobbyData = session.GetLobbyData <string>(EmpireInfo.EmpireInfoAccessibility, null);
EmpireInfo.LastAccessibilityLevel = (EmpireInfo.Accessibility)((int)Enum.Parse(typeof(EmpireInfo.Accessibility), lobbyData));
}
catch
{
EmpireInfo.LastAccessibilityLevel = EmpireInfo.Accessibility.Default;
}
}
string x = string.Format("Empire{0}", empireIndex);
string lobbyData2 = session.GetLobbyData <string>(x, null);
if (string.IsNullOrEmpty(lobbyData2))
{
return(null);
}
string x2 = string.Format("Faction{0}", empireIndex);
string x3 = string.Format("Color{0}", empireIndex);
string lobbyData3 = session.GetLobbyData <string>(x2, null);
string lobbyData4 = session.GetLobbyData <string>(x3, null);
EmpireInfo empireInfo = new EmpireInfo();
empireInfo.EmpireIndex = empireIndex;
empireInfo.EmpireName = "Empire#" + empireIndex;
empireInfo.Faction = Faction.Decode(lobbyData3);
empireInfo.FactionColor = Color.white;
empireInfo.Players = lobbyData2;
string value = Amplitude.Unity.Framework.Application.Registry.GetValue <string>("Settings/UI/EmpireColorPalette", "Standard");
IDatabase <Palette> database = Databases.GetDatabase <Palette>(false);
Palette palette;
if (database != null && database.TryGetValue(value, out palette))
{
if (palette.Colors == null || palette.Colors.Length == 0)
{
Diagnostics.LogError("Invalid color palette (name: '{0}').", new object[]
{
value
});
}
else
{
try
{
int num = int.Parse(lobbyData4);
empireInfo.FactionColor = palette.Colors[num];
}
catch
{
Diagnostics.LogError("Failed to retrieve faction color from palette (palette name: '{0}', color index: '{1}').", new object[]
{
value,
lobbyData4
});
}
}
}
string lobbyData5 = session.GetLobbyData <string>(VictoryCondition.ReadOnlyVictory, null);
if (!string.IsNullOrEmpty(lobbyData5))
{
IDatabase <VictoryCondition> database2 = Databases.GetDatabase <VictoryCondition>(false);
if (database2 != null)
{
char[] separator = new char[]
{
'&'
};
string[] array = lobbyData5.Split(separator, StringSplitOptions.RemoveEmptyEntries);
if (array.Length != 0)
{
List <VictoryCondition> list = new List <VictoryCondition>();
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string[] array3 = array2[i].Split(Amplitude.String.Separators, StringSplitOptions.RemoveEmptyEntries);
int j = 1;
while (j < array3.Length)
{
int num2;
if (int.TryParse(array3[j], out num2) && num2 == empireIndex)
{
VictoryCondition item;
if (database2.TryGetValue(array3[0], out item))
{
list.Add(item);
break;
}
break;
}
else
{
j++;
}
}
}
empireInfo.VictoryConditions = list.ToArray();
}
}
else
{
Diagnostics.LogError("Unable to retrieve the database of victory conditions.");
}
}
ILocalizationService service = Services.GetService <ILocalizationService>();
empireInfo.LocalizedName = string.Empty;
string[] array4 = lobbyData2.Split(Amplitude.String.Separators, StringSplitOptions.RemoveEmptyEntries);
for (int k = 0; k < array4.Length; k++)
{
if (service != null)
{
if (array4[k].StartsWith("AI"))
{
if (empireInfo.Faction.Name == "FactionELCPSpectator")
{
empireInfo.LocalizedName = AgeLocalizer.Instance.LocalizeString("%NotificationEncounterParticipationModeSpectatorTitle");
}
else
{
empireInfo.LocalizedName = MajorEmpire.GenerateAIName(empireInfo.Faction.Affinity.Name, empireInfo.EmpireIndex);
}
}
else
{
Steamworks.SteamID steamID = new Steamworks.SteamID(Convert.ToUInt64(array4[k], 16));
string newValue = AgeLocalizer.Instance.LocalizeString("%DefaultPlayerName");
if (Steamworks.SteamAPI.IsSteamRunning)
{
newValue = Steamworks.SteamAPI.SteamFriends.GetFriendPersonaName(steamID);
}
string name = (empireInfo.LocalizedName.Length != 0) ? "%EmpireNameFormatAdditionnalHuman" : "%EmpireNameFormatHuman";
EmpireInfo empireInfo2 = empireInfo;
empireInfo2.LocalizedName += service.Localize(name).ToString().Replace("$PlayerName", newValue);
}
}
}
empireInfo.IsActiveOrLocalPlayer = false;
empireInfo.EmpireEliminated = false;
empireInfo.EmpireExplorationBits = 0;
empireInfo.EmpireInfiltrationBits = 0;
IGameService service2 = Services.GetService <IGameService>();
if (service2 != null && service2.Game != null)
{
IPlayerControllerRepositoryService service3 = service2.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service3 != null && service3.ActivePlayerController != null && service3.ActivePlayerController.Empire != null)
{
empireInfo.IsActiveOrLocalPlayer = (service3.ActivePlayerController.Empire.Index == empireIndex);
}
else
{
Steamworks.SteamUser steamUser = Steamworks.SteamAPI.SteamUser;
if (steamUser != null)
{
empireInfo.IsActiveOrLocalPlayer = empireInfo.Players.Contains(steamUser.SteamID.ToString());
}
}
global::Game game = service2.Game as global::Game;
if (game != null && game.Empires != null)
{
MajorEmpire majorEmpire = game.Empires[empireIndex] as MajorEmpire;
if (majorEmpire.IsEliminated)
{
empireInfo.EmpireEliminated = true;
}
empireInfo.AlliedIndexList = new List <int>();
for (int l = 0; l < game.Empires.Length; l++)
{
MajorEmpire majorEmpire2 = game.Empires[l] as MajorEmpire;
if (majorEmpire2 == null)
{
break;
}
if (majorEmpire2.Index == empireIndex)
{
empireInfo.EmpireExplorationBits |= 1 << empireIndex;
empireInfo.EmpireInfiltrationBits |= 1 << empireIndex;
}
else
{
DepartmentOfForeignAffairs agency = majorEmpire2.GetAgency <DepartmentOfForeignAffairs>();
if (agency != null)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(majorEmpire);
if (diplomaticRelation != null && diplomaticRelation.State != null && diplomaticRelation.State.Name != DiplomaticRelationState.Names.Unknown)
{
empireInfo.EmpireExplorationBits |= 1 << majorEmpire2.Index;
if (diplomaticRelation.State.Name == DiplomaticRelationState.Names.Alliance)
{
empireInfo.AlliedIndexList.Add(majorEmpire2.Index);
}
}
}
DepartmentOfIntelligence agency2 = majorEmpire2.GetAgency <DepartmentOfIntelligence>();
if (agency2 != null && agency2.IsEmpireInfiltrated(majorEmpire))
{
empireInfo.EmpireInfiltrationBits |= 1 << majorEmpire2.Index;
}
}
}
}
}
return(empireInfo);
}
public bool TryGetListOfTargetInRange(Army inputArmy, int targetEmpireIndex, bool addPointsOfInterest, int regionRestriction, ref List <IWorldPositionable> targetList)
{
if (targetList == null)
{
targetList = new List <IWorldPositionable>();
}
if (inputArmy == null || inputArmy.Empire == null)
{
return(false);
}
DepartmentOfForeignAffairs departmentOfForeignAffairs = null;
bool flag = inputArmy.Empire is MinorEmpire;
bool flag2 = inputArmy.Empire is NavalEmpire;
if (!flag && !flag2)
{
departmentOfForeignAffairs = inputArmy.Empire.GetAgency <DepartmentOfForeignAffairs>();
}
if (addPointsOfInterest)
{
for (int i = 0; i < this.World.Regions.Length; i++)
{
for (int j = 0; j < this.World.Regions[i].PointOfInterests.Length; j++)
{
PointOfInterest pointOfInterest = this.World.Regions[i].PointOfInterests[j];
if (this.GetDistance(pointOfInterest.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == pointOfInterest.Region.Index))
{
targetList.Add(pointOfInterest);
}
}
}
}
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
global::Game game = service.Game as global::Game;
for (int k = 0; k < game.Empires.Length; k++)
{
global::Empire empire = game.Empires[k];
if (((!flag && !flag2) || empire is MajorEmpire) && (targetEmpireIndex == -1 || targetEmpireIndex == k))
{
DepartmentOfDefense agency = empire.GetAgency <DepartmentOfDefense>();
if (agency != null)
{
int l = 0;
while (l < agency.Armies.Count)
{
Army army = agency.Armies[l];
if (flag || flag2)
{
if (!army.IsPrivateers)
{
bool flag3 = false;
for (int m = 0; m < army.StandardUnits.Count; m++)
{
if (army.StandardUnits[m].SimulationObject.Tags.Contains(WorldPositionning.FriendlyBannerDescriptor))
{
flag3 = true;
}
}
if ((army.Hero == null || !army.Hero.IsSkillUnlocked(WorldPositionning.FriendlyBannerSkill)) && !flag3)
{
int distance = this.GetDistance(army.WorldPosition, inputArmy.WorldPosition);
float propertyValue = inputArmy.GetPropertyValue(SimulationProperties.DetectionRange);
if (!army.IsCamouflaged)
{
goto IL_240;
}
if ((float)distance <= propertyValue)
{
goto IL_240;
}
}
}
}
else if (army.Empire == inputArmy.Empire || !army.IsCamouflaged || this.VisibilityService.IsWorldPositionDetectedFor(army.WorldPosition, inputArmy.Empire))
{
goto IL_240;
}
IL_238:
l++;
continue;
IL_240:
if (this.GetDistance(army.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == (int)this.GetRegionIndex(army.WorldPosition)))
{
targetList.Add(army);
goto IL_238;
}
goto IL_238;
}
}
if (empire is MajorEmpire)
{
DepartmentOfTheInterior agency2 = empire.GetAgency <DepartmentOfTheInterior>();
if (agency2 != null)
{
for (int n = 0; n < agency2.Cities.Count; n++)
{
City city = agency2.Cities[n];
if ((city.Empire == inputArmy.Empire || flag || flag2 || departmentOfForeignAffairs == null || departmentOfForeignAffairs.CanAttack(city)) && this.GetDistance(city.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == city.Region.Index))
{
targetList.Add(city);
}
}
for (int num = 0; num < agency2.Camps.Count; num++)
{
Camp camp = agency2.Camps[num];
if ((camp.Empire == inputArmy.Empire || flag || flag2 || departmentOfForeignAffairs == null || departmentOfForeignAffairs.CanAttack(camp)) && this.GetDistance(camp.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == camp.City.Region.Index))
{
targetList.Add(camp);
}
}
}
MajorEmpire majorEmpire = empire as MajorEmpire;
for (int num2 = 0; num2 < majorEmpire.ConvertedVillages.Count; num2++)
{
Village village = majorEmpire.ConvertedVillages[num2];
if ((flag || flag2 || departmentOfForeignAffairs == null || departmentOfForeignAffairs.CanAttack(village)) && this.GetDistance(village.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == village.Region.Index))
{
targetList.Add(village);
}
}
}
else if (empire is MinorEmpire)
{
BarbarianCouncil agency3 = empire.GetAgency <BarbarianCouncil>();
if (agency3 != null)
{
for (int num3 = 0; num3 < agency3.Villages.Count; num3++)
{
Village village2 = agency3.Villages[num3];
if ((flag || flag2 || departmentOfForeignAffairs == null || departmentOfForeignAffairs.CanAttack(village2)) && this.GetDistance(village2.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == village2.Region.Index))
{
targetList.Add(village2);
}
}
}
}
else if (empire is NavalEmpire)
{
PirateCouncil agency4 = empire.GetAgency <PirateCouncil>();
if (agency4 != null)
{
for (int num4 = 0; num4 < agency4.Fortresses.Count; num4++)
{
Fortress fortress = agency4.Fortresses[num4];
if ((flag || flag2 || departmentOfForeignAffairs == null || departmentOfForeignAffairs.CanAttack(fortress)) && this.GetDistance(fortress.WorldPosition, inputArmy.WorldPosition) <= inputArmy.LineOfSightVisionRange && (regionRestriction == -1 || regionRestriction == fortress.Region.Index))
{
targetList.Add(fortress);
}
}
}
}
}
}
return(targetList.Count != 0);
}
