private void EventService_EventRaise(object sender, EventRaiseEventArgs eventArgs)
{
EventEmpireEliminated eventEmpireEliminated = eventArgs.RaisedEvent as EventEmpireEliminated;
if (eventEmpireEliminated == null)
{
return;
}
Amplitude.Unity.Game.Empire eliminatedEmpire = eventEmpireEliminated.EliminatedEmpire;
DepartmentOfForeignAffairs agency = eliminatedEmpire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
for (int i = 0; i < this.majorEmpires.Length; i++)
{
global::Empire empire = this.majorEmpires[i];
if (i != eliminatedEmpire.Index)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empire);
Diagnostics.Assert(diplomaticRelation != null && diplomaticRelation.State != null);
if (diplomaticRelation.State.Name != DiplomaticRelationState.Names.Dead)
{
OrderChangeDiplomaticRelationState order = new OrderChangeDiplomaticRelationState(eliminatedEmpire.Index, i, DiplomaticRelationState.Names.Dead);
this.PlayerController.PostOrder(order);
}
}
}
}
public void ComputeContinentOccupation(global::Empire empire, int continentID, out int numberOfAlliesOnContinent, out int numberOfEnnemiesOnContinent)
{
numberOfAlliesOnContinent = 0;
numberOfEnnemiesOnContinent = 0;
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
int[] regionList = this.world.Continents[continentID].RegionList;
for (int i = 0; i < regionList.Length; i++)
{
Region region = this.world.Regions[i];
if (region.City != null)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(region.City.Empire);
if (diplomaticRelation.State != null)
{
if (diplomaticRelation.State.Name == DiplomaticRelationState.Names.War || diplomaticRelation.State.Name == DiplomaticRelationState.Names.ColdWar || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Truce)
{
numberOfEnnemiesOnContinent++;
}
if (diplomaticRelation.State.Name == DiplomaticRelationState.Names.Peace || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Alliance)
{
numberOfAlliesOnContinent++;
}
}
}
}
}
public override State CheckCondition(QuestBehaviour questBehaviour, GameEvent gameEvent, params object[] parameters)
{
if (this.RegionIndex != -1)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
global::Game game = service.Game as global::Game;
if (game == null)
{
return(State.Failure);
}
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
global::Empire empire;
if (gameEvent != null)
{
empire = (gameEvent.Empire as global::Empire);
}
else
{
empire = questBehaviour.Initiator;
}
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
for (int i = 0; i < game.Empires.Length; i++)
{
if (i != empire.Index && (this.IgnoredEmpiresIndex == null || !this.IgnoredEmpiresIndex.Contains(i)))
{
global::Empire empire2 = game.Empires[i];
bool flag;
if (empire2 is MajorEmpire)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empire2);
Diagnostics.Assert(diplomaticRelation != null);
Diagnostics.Assert(diplomaticRelation.State != null);
flag = (diplomaticRelation.State.Name == DiplomaticRelationState.Names.ColdWar || diplomaticRelation.State.Name == DiplomaticRelationState.Names.War || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Unknown);
}
else
{
flag = true;
}
if (flag)
{
DepartmentOfDefense agency2 = empire2.GetAgency <DepartmentOfDefense>();
for (int j = 0; j < agency2.Armies.Count; j++)
{
if ((this.IncludeNaval || !agency2.Armies[j].IsNaval) && (int)service2.GetRegionIndex(agency2.Armies[j].WorldPosition) == this.RegionIndex)
{
return(State.Success);
}
}
}
}
}
}
return(State.Failure);
}
private void DgDipRelation_CellEditEnding(object sender, DataGridCellEditEndingEventArgs e)
{
DiplomaticRelation relation = list[e.Row.GetIndex()] as DiplomaticRelation;
if (e.Column.DisplayIndex == 1)
{
bool b = int.TryParse((e.EditingElement as TextBox).Text, out int n);
relation.Relation = n;
}
else if (e.Column.DisplayIndex == 2)
{
bool b = int.TryParse((e.EditingElement as TextBox).Text, out int k);
relation.Truce = k;
}
}
public static bool IsKnownByLookingPlayer(Empire empire, Empire empireLooking)
{
if (empire.Index == empireLooking.Index)
{
return(true);
}
DepartmentOfForeignAffairs agency = empireLooking.GetAgency <DepartmentOfForeignAffairs>();
if (agency != null)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empire);
return(diplomaticRelation != null && diplomaticRelation.State != null && diplomaticRelation.State.Name != DiplomaticRelationState.Names.Unknown);
}
return(false);
}
private bool CanToggleOverDevice(Army army, TerraformDevice device, ref List <StaticString> failureFlags)
{
if (army == null || device == null || device.Empire == army.Empire)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if (device.DismantlingArmy != null)
{
if (device.DismantlingArmy == army)
{
return(true);
}
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
else
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
Army armyAtPosition = service2.GetArmyAtPosition(device.WorldPosition);
if (device != null && device.DismantlingArmy == null && armyAtPosition != null && device.Empire.Index != army.Empire.Index)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if (device.Empire != army.Empire && army.Empire is MajorEmpire && !(device.Empire is LesserEmpire))
{
DiplomaticRelation diplomaticRelation = army.Empire.GetAgency <DepartmentOfForeignAffairs>().DiplomaticRelations[device.Empire.Index];
if (diplomaticRelation != null && diplomaticRelation.State != null && (diplomaticRelation.State.Name == DiplomaticRelationState.Names.Alliance || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Peace))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
}
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
Diagnostics.Assert(service3 != null);
PathfindingFlags flags = PathfindingFlags.IgnoreArmies | PathfindingFlags.IgnoreOtherEmpireDistrict | PathfindingFlags.IgnoreDiplomacy | PathfindingFlags.IgnoreFogOfWar | PathfindingFlags.IgnoreSieges | PathfindingFlags.IgnoreKaijuGarrisons;
if (!service3.IsTransitionPassable(army.WorldPosition, device.WorldPosition, army, flags, null))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
return(true);
}
}
private void UpdateBorderStatusOfRegion(global::Empire empire, Region region, AIRegionData regionData)
{
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
regionData.BorderWithEnnemy = 0;
regionData.BorderWithAllied = 0;
regionData.BorderWithMe = 0;
regionData.BorderWithNeutral = 0;
regionData.OverallBorderSize = 0;
for (int i = 0; i < regionData.BorderByEmpireIndex.Length; i++)
{
regionData.BorderByEmpireIndex[i] = 0;
}
for (int j = 0; j < region.Borders.Length; j++)
{
int num = region.Borders[j].WorldPositions.Length;
regionData.OverallBorderSize += num;
Region region2 = this.worldPositionService.GetRegion(region.Borders[j].NeighbourRegionIndex);
global::Empire owner = region2.Owner;
if (owner != null && owner is MajorEmpire)
{
regionData.BorderByEmpireIndex[owner.Index] += num;
if (owner == empire)
{
regionData.BorderWithMe += num;
}
else if (agency != null)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(owner);
if (diplomaticRelation.State.Name == DiplomaticRelationState.Names.ColdWar || diplomaticRelation.State.Name == DiplomaticRelationState.Names.War)
{
regionData.BorderWithEnnemy += num;
}
else
{
regionData.BorderWithAllied += num;
}
}
}
else
{
regionData.BorderWithNeutral += num;
}
}
}
private void dg_ItemsSourceChanged(object sender, EventArgs e)
{
if (!settingUp)
{
scen.DiplomaticRelations.Clear();
foreach (DataRow dr in dt.Rows)
{
DiplomaticRelation relation = new DiplomaticRelation();
relation.RelationFaction1ID = (int)dr["势力1ID"];
relation.RelationFaction2ID = (int)dr["势力2ID"];
relation.Relation = (int)dr["外交关系"];
relation.Truce = (int)dr["停战天数"];
scen.DiplomaticRelations.AddDiplomaticRelation(relation);
}
initdt();
MainWindow.pasting = false;
}
}
protected bool MayEndureRetaliationAnotherTurn(BaseNavyArmy army)
{
Army army2 = army.Garrison as Army;
if (army2 != null && army2.IsPrivateers)
{
return(true);
}
District district = this.worldPositionService.GetDistrict(army.Garrison.WorldPosition);
if (district != null)
{
if (district.City.Empire == army.Garrison.Empire)
{
return(true);
}
float propertyValue = district.City.GetPropertyValue(SimulationProperties.DefensivePower);
float propertyValue2 = district.City.GetPropertyValue(SimulationProperties.CoastalDefensivePower);
if (propertyValue + propertyValue2 <= 0f)
{
return(true);
}
DepartmentOfForeignAffairs agency = district.City.Empire.GetAgency <DepartmentOfForeignAffairs>();
if (agency != null)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(army.Garrison.Empire);
if (diplomaticRelation != null && diplomaticRelation.HasActiveAbility(DiplomaticAbilityDefinition.ImmuneToDefensiveImprovements))
{
return(true);
}
}
float num = (propertyValue + propertyValue2) / (float)army.Garrison.UnitsCount;
foreach (Unit unit in army.Garrison.Units)
{
float propertyValue3 = unit.GetPropertyValue(SimulationProperties.Health);
if (propertyValue3 - num < num * 2f)
{
return(false);
}
}
return(true);
}
return(true);
}
protected bool HasOtherEmpireClosedTheirBorders()
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
Diagnostics.Assert(service.Game != null);
Diagnostics.Assert(service.Game is global::Game);
global::Game game = service.Game as global::Game;
Diagnostics.Assert(game.Empires.Length > this.DiplomaticRelation.OtherEmpireIndex);
global::Empire empire = (service.Game as global::Game).Empires[this.DiplomaticRelation.OtherEmpireIndex];
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(this.Empire);
Diagnostics.Assert(diplomaticRelation != null);
return(diplomaticRelation.HasActiveAbility(DiplomaticAbilityDefinition.CloseBorders));
}
private List <IWorldPositionable> Execute_GetVillages(AIBehaviorTree aiBehaviorTree, Army army, IGameService gameService, List <IWorldPositionable> unfilteredTargetList)
{
List <IWorldPositionable> list = new List <IWorldPositionable>();
for (int i = 0; i < unfilteredTargetList.Count; i++)
{
PointOfInterest pointOfInterest = unfilteredTargetList[i] as PointOfInterest;
if (pointOfInterest != null && !(pointOfInterest.Type != "Village") && pointOfInterest.Region != null && pointOfInterest.Region.MinorEmpire != null)
{
BarbarianCouncil agency = pointOfInterest.Region.MinorEmpire.GetAgency <BarbarianCouncil>();
if (agency != null)
{
Village villageAt = agency.GetVillageAt(pointOfInterest.WorldPosition);
if (villageAt != null && !villageAt.HasBeenPacified && this.TypeOfDiplomaticRelation != "VillageConvert" && pointOfInterest.PointOfInterestImprovement != null && !villageAt.HasBeenInfected)
{
list.Add(villageAt);
}
else if (this.TypeOfDiplomaticRelation == "VillageConvert" && army.Empire is MajorEmpire && army.Empire.SimulationObject.Tags.Contains(AILayer_Village.TagConversionTrait) && villageAt.HasBeenPacified && DepartmentOfTheInterior.IsArmyAbleToConvert(army, true) && !villageAt.HasBeenConverted && !villageAt.HasBeenInfected)
{
DepartmentOfForeignAffairs agency2 = aiBehaviorTree.AICommander.Empire.GetAgency <DepartmentOfForeignAffairs>();
City city = villageAt.Region.City;
if (city != null && city.Empire != aiBehaviorTree.AICommander.Empire)
{
DiplomaticRelation diplomaticRelation = agency2.GetDiplomaticRelation(city.Empire);
if (diplomaticRelation == null || diplomaticRelation.State.Name != DiplomaticRelationState.Names.War || (diplomaticRelation.State.Name == DiplomaticRelationState.Names.War && pointOfInterest.PointOfInterestImprovement == null))
{
goto IL_1FB;
}
}
float num;
army.Empire.GetAgency <DepartmentOfTheTreasury>().TryGetResourceStockValue(army.Empire.SimulationObject, DepartmentOfTheTreasury.Resources.EmpirePoint, out num, false);
if (AILayer_Village.GetVillageConversionCost(army.Empire as MajorEmpire, villageAt) * 2f < num)
{
list.Add(villageAt);
}
}
}
}
IL_1FB :;
}
return(list);
}
private bool CanToggleOverCreepingNode(Army army, CreepingNode creepingNode, ref List <StaticString> failureFlags)
{
if (army == null || creepingNode == null || creepingNode.Empire == army.Empire)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if (creepingNode.DismantlingArmy != null)
{
if (creepingNode.DismantlingArmy == army)
{
return(true);
}
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
else
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
Diagnostics.Assert(service2 != null);
Army armyAtPosition = service2.GetArmyAtPosition(creepingNode.WorldPosition);
if (creepingNode != null && creepingNode.DismantlingArmy == null && armyAtPosition != null && creepingNode.Empire.Index != army.Empire.Index)
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
if (creepingNode.Empire != army.Empire && army.Empire is MajorEmpire)
{
DiplomaticRelation diplomaticRelation = army.Empire.GetAgency <DepartmentOfForeignAffairs>().DiplomaticRelations[creepingNode.Empire.Index];
if (diplomaticRelation != null && diplomaticRelation.State != null && (diplomaticRelation.State.Name == DiplomaticRelationState.Names.Alliance || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Peace || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Truce))
{
failureFlags.Add(ArmyAction.NoCanDoWhileHidden);
return(false);
}
}
return(true);
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
PointOfInterest pointOfInterest = null;
if (parameters != null && parameters.Length != 0 && parameters[0] is PointOfInterest)
{
pointOfInterest = (parameters[0] as PointOfInterest);
}
else if (parameters != null && parameters.Length != 0 && parameters[0] is Village)
{
pointOfInterest = (parameters[0] as Village).PointOfInterest;
}
DepartmentOfForeignAffairs agency = army.Empire.GetAgency <DepartmentOfForeignAffairs>();
DiplomaticRelation diplomaticRelation = null;
if (pointOfInterest != null && pointOfInterest.Empire != null)
{
diplomaticRelation = agency.GetDiplomaticRelation(pointOfInterest.Empire);
}
ArmyAction.FailureFlags.Clear();
if (diplomaticRelation == null || diplomaticRelation.State == null || diplomaticRelation.State.Name != DiplomaticRelationState.Names.Alliance)
{
OrderConvertVillage orderConvertVillage = new OrderConvertVillage(army.Empire.Index, army.GUID, pointOfInterest.WorldPosition);
orderConvertVillage.NumberOfActionPointsToSpend = base.GetCostInActionPoints();
Diagnostics.Assert(playerController != null);
playerController.PostOrder(orderConvertVillage, out ticket, ticketRaisedEventHandler);
}
else if (pointOfInterest != null && pointOfInterest.Empire != null && pointOfInterest.Empire is MajorEmpire)
{
IGuiService service = Services.GetService <IGuiService>();
service.GetGuiPanel <WarDeclarationModalPanel>().Show(new object[]
{
pointOfInterest.Empire,
"Convert"
});
}
}
public List <DiplomaticRelationScore.ModifiersData> GetPriceModifiers()
{
List <DiplomaticRelationScore.ModifiersData> list = new List <DiplomaticRelationScore.ModifiersData>();
global::Empire payingEmpire = this.GetPayingEmpire();
Diagnostics.Assert(payingEmpire != null);
global::Empire empire = (payingEmpire != this.Term.EmpireWhichProvides) ? this.Term.EmpireWhichProvides : this.Term.EmpireWhichReceives;
Diagnostics.Assert(empire != null);
DepartmentOfForeignAffairs agency = payingEmpire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empire);
foreach (DiplomaticRelationScore.ModifiersData modifiersData in diplomaticRelation.DiplomaticRelationScore.MofifiersDatas)
{
if (this.TermGuiElement != null && this.TermGuiElement.PriceModifierCategories.Contains(modifiersData.Category) && Mathf.Abs(modifiersData.TotalValue) > 0.1f)
{
list.Add(modifiersData);
}
}
return(list);
}
public bool HasRetaliationFor(WorldPosition position, global::Empire empire = null)
{
GridMap <byte> gridMap = this.world.Atlas.GetMap(WorldAtlas.Maps.DefensiveTower) as GridMap <byte>;
Diagnostics.Assert(gridMap != null);
byte b = gridMap.GetValue(position);
if (empire != null)
{
b &= (byte)(~(byte)empire.Bits);
}
if (b != 0)
{
if (empire == null)
{
return(true);
}
DepartmentOfForeignAffairs agency = empire.GetAgency <DepartmentOfForeignAffairs>();
if (agency == null)
{
return(true);
}
for (int i = 0; i < base.Game.Empires.Length; i++)
{
global::Empire empire2 = base.Game.Empires[i];
if (((int)b & empire2.Bits) != 0)
{
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empire2);
if (diplomaticRelation == null || !diplomaticRelation.HasActiveAbility(DiplomaticAbilityDefinition.ImmuneToDefensiveImprovements))
{
return(true);
}
}
}
}
return(false);
}
private void Dt_RowChanged(object sender, DataRowChangeEventArgs e)
{
try
{
if (!settingUp && !MainWindow.pasting)
{
scen.DiplomaticRelations.Clear();
foreach (DataRow dr in dt.Rows)
{
DiplomaticRelation relation = new DiplomaticRelation();
relation.RelationFaction1ID = (int)dr["势力1ID"];
relation.RelationFaction2ID = (int)dr["势力2ID"];
relation.Relation = (int)dr["外交关系"];
relation.Truce = (int)dr["停战天数"];
scen.DiplomaticRelations.AddDiplomaticRelation(relation);
}
initdt();
}
}
catch (Exception ex)
{
MessageBox.Show("資料輸入錯誤。" + ex.Message);
}
}
public static List <GuiElement> GetFilteredDiplomaticAbilityGuiElements(global::Empire thisEmpire, global::Empire otherEmpire)
{
IGuiPanelHelper guiPanelHelper = Services.GetService <global::IGuiService>().GuiPanelHelper;
Diagnostics.Assert(guiPanelHelper != null, "Unable to access GuiPanelHelper");
DepartmentOfForeignAffairs agency = thisEmpire.GetAgency <DepartmentOfForeignAffairs>();
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(otherEmpire);
List <GuiElement> list = new List <GuiElement>();
bool flag = false;
bool flag2 = false;
ReadOnlyCollection <DiplomaticAbility> diplomaticAbilities = diplomaticRelation.DiplomaticAbilities;
GuiElement item;
for (int i = 0; i < diplomaticAbilities.Count; i++)
{
StaticString name = diplomaticAbilities[i].Name;
if (name == DiplomaticAbilityDefinition.CloseBorders && !thisEmpire.SimulationObject.Tags.Contains("SeasonEffectDiplomacy1"))
{
flag = true;
}
else if (diplomaticAbilities[i].IsActive)
{
IDownloadableContentService service = Services.GetService <IDownloadableContentService>();
if (!(name == DiplomaticAbilityDefinition.ImmuneToDefensiveImprovements) || service.IsShared(DownloadableContent13.ReadOnlyName))
{
if (guiPanelHelper.TryGetGuiElement("DiplomaticAbility" + name, out item))
{
list.Add(item);
}
}
}
}
DepartmentOfForeignAffairs agency2 = otherEmpire.GetAgency <DepartmentOfForeignAffairs>();
DiplomaticRelation diplomaticRelation2 = agency2.GetDiplomaticRelation(thisEmpire);
if (diplomaticRelation2.HasActiveAbility(DiplomaticAbilityDefinition.CloseBorders) && !otherEmpire.SimulationObject.Tags.Contains("SeasonEffectDiplomacy1"))
{
flag2 = true;
}
if (flag && flag2)
{
if (guiPanelHelper.TryGetGuiElement("DiplomaticAbilityMutualCloseBorders", out item))
{
list.Add(item);
}
}
else if (flag)
{
if (guiPanelHelper.TryGetGuiElement("DiplomaticAbilityPersonaNonGrata", out item))
{
list.Add(item);
}
}
else if (flag2 && guiPanelHelper.TryGetGuiElement("DiplomaticAbilityLockedOut", out item))
{
list.Add(item);
}
if (diplomaticRelation2.HasActiveAbility(DiplomaticAbilityDefinition.MarketBan) && guiPanelHelper.TryGetGuiElement("DiplomaticAbilityMarketBanner", out item))
{
list.Add(item);
}
return(list);
}
public override void PopulateMission()
{
if (this.IsMissionFinished())
{
return;
}
Region region = this.worldPositionningService.GetRegion(base.RegionIndex);
Tags tags = new Tags();
tags.AddTag(base.Category.ToString());
if (this.CurrentWarStep == AICommander_WarWithObjective.WarSteps.GoingToFrontier)
{
DepartmentOfForeignAffairs agency = base.Empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
DiplomaticRelation diplomaticRelation = agency.DiplomaticRelations[region.City.Empire.Index];
if (diplomaticRelation != null && diplomaticRelation.State.Name == DiplomaticRelationState.Names.War)
{
this.CurrentWarStep = AICommander_WarWithObjective.WarSteps.BeSiegingCity;
AICommanderMission aicommanderMission = base.Missions.Find((AICommanderMission match) => match is AICommanderMission_FrontierHarass);
if (aicommanderMission != null)
{
this.CancelMission(aicommanderMission);
}
}
}
if (this.NeedPrivateersHarrasementMission && this.CurrentWarStep == AICommander_WarWithObjective.WarSteps.GoingToFrontier)
{
int num = base.Missions.Count((AICommanderMission match) => match is AICommanderMission_PrivateersHarass);
if (num < 6)
{
tags.AddTag("PrivateersHarass");
for (int i = num; i < 6; i++)
{
base.PopulationFirstMissionFromCategory(tags, new object[]
{
region.City
});
}
tags.RemoveTag("PrivateersHarass");
}
}
else
{
AICommanderMission aicommanderMission2 = base.Missions.Find((AICommanderMission match) => match is AICommanderMission_PrivateersHarass);
if (aicommanderMission2 != null)
{
this.CancelMission(aicommanderMission2);
}
}
AICommander_WarWithObjective.WarSteps currentWarStep = this.CurrentWarStep;
if (currentWarStep != AICommander_WarWithObjective.WarSteps.GoingToFrontier)
{
if (currentWarStep != AICommander_WarWithObjective.WarSteps.BeSiegingCity)
{
Diagnostics.LogError(string.Format("[AICommander_WarWithObjective] Unknow war step", this.CurrentWarStep.ToString()));
return;
}
this.PopulateBesiegingCityMission(tags, region);
if (region.City.Camp != null)
{
this.PopulateAttackCampMission(tags, region);
return;
}
List <AICommanderMission> list = base.Missions.FindAll((AICommanderMission match) => match is AICommanderMission_AttackCampDefault);
if (list.Count > 0)
{
for (int j = 0; j < list.Count; j++)
{
this.CancelMission(list[j]);
}
return;
}
}
else if (!base.Missions.Exists((AICommanderMission match) => match is AICommanderMission_FrontierHarass))
{
tags.AddTag("FrontierHarass");
base.PopulationFirstMissionFromCategory(tags, new object[]
{
region
});
}
}
private void RefreshVisibility()
{
Diagnostics.Assert(this.majorEmpires != null);
for (int i = 0; i < this.majorEmpires.Length; i++)
{
Diagnostics.Assert(this.empireExplorationBits != null && this.empireVibilityBits != null && this.lastEmpireExplorationBits != null);
Diagnostics.Assert(this.empireDetectionBits != null);
this.lastEmpireExplorationBits[i] = this.empireExplorationBits[i];
this.empireExplorationBits[i] = this.majorEmpires[i].Bits;
this.empireVibilityBits[i] = this.majorEmpires[i].Bits;
this.empireDetectionBits[i] = this.majorEmpires[i].Bits;
DepartmentOfForeignAffairs agency = this.majorEmpires[i].GetAgency <DepartmentOfForeignAffairs>();
for (int j = 0; j < this.majorEmpires.Length; j++)
{
if (j != i)
{
bool flag = false;
bool flag2 = false;
bool flag3 = false;
DepartmentOfScience agency2 = this.majorEmpires[j].GetAgency <DepartmentOfScience>();
Diagnostics.Assert(agency2 != null);
if (agency2.GetTechnologyState(this.technologyDefinitionDrakkenEndQuestReward) == DepartmentOfScience.ConstructibleElement.State.Researched)
{
flag2 = true;
flag3 = true;
}
else if (agency2.GetTechnologyState(this.technologyDefinitionDrakkenVisionDuringFirstTurn) == DepartmentOfScience.ConstructibleElement.State.Researched && base.Game.Turn == 0)
{
flag2 = true;
flag = true;
flag3 = true;
}
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(this.majorEmpires[j]);
if (diplomaticRelation != null)
{
flag |= (diplomaticRelation.HasActiveAbility(DiplomaticAbilityDefinition.MapExchange) || (ELCPUtilities.SpectatorMode && this.majorEmpires[j].ELCPIsEliminated));
flag2 |= diplomaticRelation.HasActiveAbility(DiplomaticAbilityDefinition.VisionExchange);
}
if (this.EnableDetection)
{
StaticString tag = this.stealVisionFromEmpireTags[i];
if (this.majorEmpires[j].SimulationObject.Tags.Contains(tag))
{
flag2 = true;
flag3 = true;
}
}
if (flag2)
{
this.empireVibilityBits[i] |= this.majorEmpires[j].Bits;
}
if (flag)
{
this.empireExplorationBits[i] |= this.majorEmpires[j].Bits;
}
if (flag3)
{
this.empireDetectionBits[i] |= this.majorEmpires[j].Bits;
}
if (flag2 || flag || flag3)
{
if ((this.NeedRefreshBits & this.majorEmpires[j].Bits) != 0)
{
this.NeedRefreshBits |= 1 << i;
}
if ((this.NeedRefreshBits & this.majorEmpires[i].Bits) != 0)
{
this.NeedRefreshBits |= 1 << j;
}
}
}
}
}
for (int k = 0; k < this.majorEmpires.Length; k++)
{
MajorEmpire majorEmpire = this.majorEmpires[k];
Diagnostics.Assert(this.empireExplorationBits != null && this.lastEmpireExplorationBits != null);
if (this.lastEmpireExplorationBits[k] != this.empireExplorationBits[k])
{
Diagnostics.Assert(this.explorationMap != null && this.explorationMap.Data != null);
for (int l = 0; l < this.explorationMap.Data.Length; l++)
{
if ((this.explorationMap.Data[l] & (short)majorEmpire.Bits) != 0)
{
short[] data = this.explorationMap.Data;
int num = l;
int num2 = num;
data[num2] |= (short)this.empireExplorationBits[k];
}
}
}
}
short num3 = Convert.ToInt16(~this.NeedRefreshBits);
for (int m = 0; m < this.publicVisibilityMap.Data.Length; m++)
{
short[] data2 = this.publicVisibilityMap.Data;
int num4 = m;
int num5 = num4;
data2[num5] &= num3;
short[] data3 = this.privateVisibilityMap.Data;
int num6 = m;
int num7 = num6;
data3[num7] &= num3;
if (this.EnableDetection)
{
short[] data4 = this.publicDetectionMap.Data;
int num8 = m;
int num9 = num8;
data4[num9] &= num3;
short[] data5 = this.privateDetectionMap.Data;
int num10 = m;
int num11 = num10;
data5[num11] &= num3;
}
}
for (int n = 0; n < this.gameEntities.Count; n++)
{
this.RefreshLineOfSight(this.gameEntities[n], this.NeedRefreshBits);
}
for (int num12 = 0; num12 < this.visibilityProviders.Count; num12++)
{
this.RefreshLineOfSight(this.visibilityProviders[num12], this.NeedRefreshBits);
}
this.NeedRefreshBits = 0;
}
private void BtSave_Click(object sender, RoutedEventArgs e)
{
if (faction.Leader == null)
{
MessageBox.Show("势力君主为空");
}
else if (capitaltemp == null)
{
MessageBox.Show("势力首都为空");
}
else if (architectureListtemp.Count == 0 || architectureListtemp == null)
{
MessageBox.Show("势力首都为空");
}
else if (baseMilitaryKindstemp.MilitaryKinds.Count == 0 || baseMilitaryKindstemp == null)
{
MessageBox.Show("势力兵种为空");
}
else
{
faction.Name = txname.Text;
this.faction.Leader = leadertemp;
faction.LeaderID = leadertemp == null ? -1 : faction.Leader.ID;
this.faction.Prince = princetemp;
faction.PrinceID = princetemp == null ? -1 : faction.Prince.ID;
this.faction.Capital = capitaltemp;
faction.CapitalID = capitaltemp == null ? -1 : faction.Capital.ID;
faction.ColorIndex = coloridtemp;
this.faction.Name = txname.Text;
this.faction.TechniquePoint = int.Parse(txTechniquePoint.Text);
this.faction.Reputation = int.Parse(txReputation.Text);
this.faction.chaotinggongxiandu = int.Parse(txgongxiandu.Text);
this.faction.guanjue = guanjuezhitemp;
this.faction.UpgradingTechnique = cmUpingTec.SelectedIndex;
this.faction.UpgradingDaysLeft = int.Parse(txleftdays.Text);
this.faction.IsAlien = (bool)cbIsAlien.IsChecked;
this.faction.NotPlayerSelectable = (bool)cbNoPSelectable.IsChecked;
foreach (Architecture a in faction.Architectures)
{
if (!architectureListtemp.GameObjects.Contains(a))
{
a.BelongedFaction = null;
}
}
foreach (Architecture a in architectureListtemp)
{
if (a.BelongedFaction != null && a.BelongedFaction != faction)
{
a.BelongedFaction.Architectures.Remove(a);
a.BelongedFaction.ArchitecturesString = a.BelongedFaction.Architectures.SaveToString();
if (a == a.BelongedFaction.Capital)
{
a.BelongedFaction.Capital = null;
a.BelongedFaction.CapitalID = -1;
}
}
a.BelongedFaction = faction;
}
faction.Architectures = architectureListtemp;
faction.ArchitecturesString = faction.Architectures.SaveToString();
faction.BaseMilitaryKinds = baseMilitaryKindstemp;
faction.BaseMilitaryKindsString = faction.BaseMilitaryKinds.SaveToString();
faction.AvailableTechniques = availableTechniquestemp;
faction.AvailableTechniquesString = faction.AvailableTechniques.SaveToString();
if (edit)
{
scen.DiplomaticRelations.RemoveDiplomaticRelationByFactionID(faction.ID);
}
foreach (DataRow dr in dt.Rows)
{
DiplomaticRelation relation = new DiplomaticRelation();
relation.RelationFaction1ID = faction.ID;
relation.RelationFaction2ID = (int)dr["ID"];
relation.Relation = (int)dr["关系"];
relation.Truce = (int)dr["停战"];
scen.DiplomaticRelations.AddDiplomaticRelation(relation);
}
if (!edit)
{
scen.Factions.Add(faction);
}
this.Close();
}
}
public void RefreshContent(Player player, Empire playerEmpire, IGuiPanelHelper helper)
{
GuiEmpire guiEmpire = new GuiEmpire(player.Empire);
this.EmpireIcon.Image = guiEmpire.GetImageTexture(global::GuiPanel.IconSize.LogoSmall, playerEmpire);
this.EmpireIcon.TintColor = guiEmpire.Color;
AgeUtils.TruncateString(player.LocalizedName, this.EmpireLeader, out this.temp, '.');
this.EmpireLeader.Text = this.temp;
this.EmpireLeader.TintColor = player.Empire.Color;
float value = 0f;
MajorEmpire majorEmpire = player.Empire as MajorEmpire;
if (majorEmpire != null)
{
Diagnostics.Assert(majorEmpire.GameScores != null);
GameScore gameScore = null;
if (majorEmpire.GameScores.TryGetValue(GameScores.Names.GlobalScore, out gameScore))
{
value = gameScore.Value;
}
}
bool flag = false;
ISessionService service = Services.GetService <ISessionService>();
Diagnostics.Assert(service != null && service.Session != null);
string lobbyData = service.Session.GetLobbyData <string>(EmpireInfo.EmpireInfoAccessibility, "Default");
switch ((int)Enum.Parse(typeof(EmpireInfo.Accessibility), lobbyData))
{
case 0:
flag = true;
break;
case 1:
if (player.Empire == playerEmpire)
{
flag = true;
}
else if (playerEmpire.GetAgency <DepartmentOfForeignAffairs>().GetDiplomaticRelation(player.Empire).State.Name == DiplomaticRelationState.Names.Dead)
{
flag = true;
}
break;
case 2:
if (player.Empire == playerEmpire)
{
flag = true;
}
else
{
DepartmentOfIntelligence agency = playerEmpire.GetAgency <DepartmentOfIntelligence>();
if (agency != null && agency.IsEmpireInfiltrated(player.Empire))
{
flag = true;
}
else if (playerEmpire.GetAgency <DepartmentOfForeignAffairs>().GetDiplomaticRelation(player.Empire).State.Name == DiplomaticRelationState.Names.Dead)
{
flag = true;
}
}
break;
default:
flag = true;
break;
}
if (flag || !(playerEmpire is MajorEmpire) || (playerEmpire as MajorEmpire).IsEliminated)
{
this.EmpireScore.Text = GuiFormater.FormatGui(value, false, false, false, 1);
}
else
{
this.EmpireScore.Text = "???";
}
this.EmpireScore.TintColor = player.Empire.Color;
if (player.Empire == playerEmpire)
{
this.EmpireDiplomacy.Text = "-";
this.EmpireDiplomacy.TintColor = player.Empire.Color;
}
else
{
DepartmentOfForeignAffairs agency2 = playerEmpire.GetAgency <DepartmentOfForeignAffairs>();
if (agency2 != null)
{
DiplomaticRelation diplomaticRelation = agency2.GetDiplomaticRelation(player.Empire);
GuiElement guiElement;
if (helper.TryGetGuiElement(diplomaticRelation.State.Name, out guiElement))
{
AgeUtils.TruncateString(AgeLocalizer.Instance.LocalizeString(guiElement.Title), this.EmpireDiplomacy, out this.temp, '.');
this.EmpireDiplomacy.Text = this.temp;
this.EmpireDiplomacy.TintColor = player.Empire.Color;
}
if (player.Empire.IsControlledByAI)
{
if (diplomaticRelation.State.Name == DiplomaticRelationState.Names.Unknown)
{
AgeUtils.TruncateString(AgeLocalizer.Instance.LocalizeString(guiElement.Title), this.EmpireDiplomacy, out this.temp, '.');
this.EmpireLeader.Text = this.temp;
}
else
{
AgeUtils.TruncateString(player.Empire.LocalizedName, this.EmpireLeader, out this.temp, '.');
this.EmpireLeader.Text = this.temp;
}
}
}
}
string key = string.Empty;
this.EmpireStatus.Text = string.Empty;
PlayerHelper.ComputePlayerState(ref player);
key = string.Format("%PlayerState_{0}", player.State);
string src = string.Empty;
if (player.Type == PlayerType.Human && service.Session.SessionMode != SessionMode.Single)
{
src = string.Format("{0} ({1:0.}ms)", AgeLocalizer.Instance.LocalizeString(key), player.Latency * 1000.0);
}
else
{
src = AgeLocalizer.Instance.LocalizeString(key);
}
AgeUtils.TruncateString(src, this.EmpireStatus, out this.temp, '.');
AgePrimitiveLabel empireStatus = this.EmpireStatus;
empireStatus.Text = empireStatus.Text + this.temp + "\n";
this.EmpireStatus.Text = this.EmpireStatus.Text.TrimEnd(new char[]
{
'\n'
});
this.EmpireStatus.TintColor = player.Empire.Color;
}
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);
}
void IDiplomacyControl.OnServerBeginTurn()
{
this.firstBeginTurnDone = true;
if (this.majorEmpires == null)
{
return;
}
while (this.visibilityControllerRefreshedArgs.Count > 0)
{
KeyValuePair <object, VisibilityRefreshedEventArgs> keyValuePair = this.visibilityControllerRefreshedArgs.Dequeue();
this.OnVisibityRefreshed(keyValuePair.Key, keyValuePair.Value);
}
int turn = base.Game.Turn;
for (int i = 0; i < this.majorEmpires.Length; i++)
{
MajorEmpire majorEmpire = this.majorEmpires[i] as MajorEmpire;
DepartmentOfForeignAffairs agency = majorEmpire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
for (int j = i + 1; j < this.majorEmpires.Length; j++)
{
MajorEmpire majorEmpire2 = this.majorEmpires[j] as MajorEmpire;
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(majorEmpire2);
Diagnostics.Assert(diplomaticRelation != null && diplomaticRelation.State != null);
if (majorEmpire.IsSpectator || majorEmpire.ELCPIsEliminated || majorEmpire2.IsSpectator || majorEmpire2.ELCPIsEliminated)
{
if (diplomaticRelation.State.Name != DiplomaticRelationState.Names.Dead)
{
OrderChangeDiplomaticRelationState order = new OrderChangeDiplomaticRelationState(this.majorEmpires[i].Index, majorEmpire2.Index, DiplomaticRelationState.Names.Dead);
this.PlayerController.PostOrder(order);
}
}
else
{
DiplomaticRelationState.Transition automaticTransition = diplomaticRelation.State.AutomaticTransition;
if (automaticTransition != null && automaticTransition.GetRemainingTurns(diplomaticRelation) <= 0)
{
OrderChangeDiplomaticRelationState order2 = new OrderChangeDiplomaticRelationState(i, j, automaticTransition.DestinationState);
this.PlayerController.PostOrder(order2);
}
}
}
}
bool[][] array = new bool[this.majorEmpires.Length][];
for (int k = 0; k < this.majorEmpires.Length; k++)
{
array[k] = new bool[this.majorEmpires.Length];
}
Diagnostics.Assert(this.diplomaticContracts != null);
for (int l = 0; l < this.diplomaticContracts.Count; l++)
{
DiplomaticContract diplomaticContract = this.diplomaticContracts[l];
Diagnostics.Assert(diplomaticContract != null);
if (diplomaticContract.EmpireWhichInitiated.Index >= array.Length || diplomaticContract.EmpireWhichReceives.Index >= array[diplomaticContract.EmpireWhichInitiated.Index].Length)
{
Diagnostics.Assert(false, "ELCP: Unexpected EmpireIndex {0}", new object[]
{
diplomaticContract.ToString()
});
}
else
{
if (diplomaticContract.State == DiplomaticContractState.Proposed && turn > diplomaticContract.TurnAtTheBeginningOfTheState)
{
OrderChangeDiplomaticContractState order3 = new OrderChangeDiplomaticContractState(diplomaticContract, DiplomaticContractState.Refused);
this.PlayerController.PostOrder(order3);
}
if (diplomaticContract.State == DiplomaticContractState.Negotiation && turn > diplomaticContract.TurnAtTheBeginningOfTheState)
{
if (diplomaticContract.EmpireWhichInitiated != diplomaticContract.EmpireWhichProposes || diplomaticContract.ContractRevisionNumber > 0 || array[diplomaticContract.EmpireWhichInitiated.Index][diplomaticContract.EmpireWhichReceives.Index])
{
DiplomaticContractState newState = DiplomaticContractState.Refused;
OrderChangeDiplomaticContractState order4 = new OrderChangeDiplomaticContractState(diplomaticContract, newState);
this.PlayerController.PostOrder(order4);
}
else
{
array[diplomaticContract.EmpireWhichInitiated.Index][diplomaticContract.EmpireWhichReceives.Index] = true;
}
}
}
}
}
private WorldPosition CheckMetting(global::Empire empireA, global::Empire empireB)
{
Diagnostics.Assert(empireA != null && empireB != null);
if (empireA.Index == empireB.Index)
{
return(WorldPosition.Invalid);
}
DepartmentOfForeignAffairs agency = empireA.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
DiplomaticRelation diplomaticRelation = agency.GetDiplomaticRelation(empireB);
if (diplomaticRelation == null || diplomaticRelation.State == null || diplomaticRelation.State.Name != DiplomaticRelationState.Names.Unknown)
{
return(WorldPosition.Invalid);
}
DepartmentOfDefense agency2 = empireB.GetAgency <DepartmentOfDefense>();
DepartmentOfTheInterior agency3 = empireB.GetAgency <DepartmentOfTheInterior>();
DepartmentOfScience agency4 = empireA.GetAgency <DepartmentOfScience>();
Diagnostics.Assert(agency4 != null);
if (agency2 != null && agency3 != null && agency4.GetTechnologyState(this.technologyDefinitionDrakkenVisionDuringFirstTurn) == DepartmentOfScience.ConstructibleElement.State.Researched)
{
WorldPosition worldPosition = WorldPosition.Invalid;
if (agency3.Cities.Count > 0)
{
worldPosition = agency3.Cities[0].WorldPosition;
}
else if (agency2.Armies.Count > 0)
{
worldPosition = agency2.Armies[0].WorldPosition;
}
if (worldPosition != WorldPosition.Invalid)
{
return(worldPosition);
}
}
if (agency2 != null)
{
ReadOnlyCollection <Army> armies = agency2.Armies;
for (int i = 0; i < armies.Count; i++)
{
Army army = armies[i];
if (!army.IsPrivateers)
{
if (this.visibilityService.IsWorldPositionVisibleFor(army.WorldPosition, empireA))
{
if (!army.IsCamouflaged || this.visibilityService.IsWorldPositionDetectedFor(army.WorldPosition, empireA))
{
return(army.WorldPosition);
}
}
}
}
}
if (agency3 != null)
{
ReadOnlyCollection <City> cities = agency3.Cities;
for (int j = 0; j < cities.Count; j++)
{
ReadOnlyCollection <District> districts = cities[j].Districts;
for (int k = 0; k < districts.Count; k++)
{
if (this.visibilityService.IsWorldPositionVisibleFor(districts[k].WorldPosition, empireA))
{
return(districts[k].WorldPosition);
}
}
}
}
if (agency3 != null)
{
MajorEmpire majorEmpire = empireB as MajorEmpire;
if (majorEmpire != null)
{
for (int l = 0; l < majorEmpire.ConvertedVillages.Count; l++)
{
if (this.visibilityService.IsWorldPositionVisibleFor(majorEmpire.ConvertedVillages[l].WorldPosition, empireA))
{
return(majorEmpire.ConvertedVillages[l].WorldPosition);
}
}
}
}
if (agency3 != null)
{
for (int m = 0; m < agency3.OccupiedFortresses.Count; m++)
{
if (this.visibilityService.IsWorldPositionVisibleFor(agency3.OccupiedFortresses[m].WorldPosition, empireA))
{
return(agency3.OccupiedFortresses[m].WorldPosition);
}
}
}
if (agency3 != null)
{
for (int n = 0; n < agency3.Camps.Count; n++)
{
if (this.visibilityService.IsWorldPositionVisibleFor(agency3.Camps[n].WorldPosition, empireA))
{
return(agency3.Camps[n].WorldPosition);
}
}
}
if (agency3 != null)
{
for (int num = 0; num < agency3.TamedKaijuGarrisons.Count; num++)
{
if (this.visibilityService.IsWorldPositionVisibleFor(agency3.TamedKaijuGarrisons[num].WorldPosition, empireA))
{
return(agency3.TamedKaijuGarrisons[num].WorldPosition);
}
}
}
return(WorldPosition.Invalid);
}
public override void RefreshMission()
{
base.RefreshMission();
if (this.IsMissionFinished())
{
return;
}
this.NeedPrivateersHarrasementMission = false;
MajorEmpire majorEmpire = base.Empire as MajorEmpire;
if (majorEmpire != null)
{
Region region2 = this.worldPositionningService.GetRegion(base.RegionIndex);
DepartmentOfForeignAffairs agency = base.Empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
DiplomaticRelation diplomaticRelation = agency.DiplomaticRelations[region2.City.Empire.Index];
if (diplomaticRelation != null && diplomaticRelation.State.Name == DiplomaticRelationState.Names.War)
{
this.NeedPrivateersHarrasementMission = false;
}
else
{
this.NeedPrivateersHarrasementMission = (majorEmpire.SimulationObject.Tags.Contains(AILayer_War.TagNoWarTrait) && this.departmentOfScience.CanCreatePrivateers());
}
}
if (base.Missions.Count != 0)
{
Region region = this.worldPositionningService.GetRegion(base.RegionIndex);
switch (this.CurrentWarStep)
{
case AICommander_WarWithObjective.WarSteps.GoingToFrontier:
{
DepartmentOfForeignAffairs agency2 = base.Empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency2 != null);
DiplomaticRelation diplomaticRelation2 = agency2.DiplomaticRelations[region.City.Empire.Index];
if (diplomaticRelation2.State == null)
{
Diagnostics.LogError("[AICommander_WarWithObjective] DiplomaticRelation is null");
return;
}
AICommanderMission_FrontierHarass aicommanderMission_FrontierHarass = base.Missions.Find((AICommanderMission match) => match is AICommanderMission_FrontierHarass) as AICommanderMission_FrontierHarass;
if (aicommanderMission_FrontierHarass != null && aicommanderMission_FrontierHarass.Completion != AICommanderMission.AICommanderMissionCompletion.Fail && aicommanderMission_FrontierHarass.Completion != AICommanderMission.AICommanderMissionCompletion.Interrupted && aicommanderMission_FrontierHarass.Completion != AICommanderMission.AICommanderMissionCompletion.Cancelled && aicommanderMission_FrontierHarass.ArrivedToDestination())
{
if (diplomaticRelation2.State.Name == DiplomaticRelationState.Names.War)
{
if (this.aiDataRepository.GetAIData <AIData_Army>(aicommanderMission_FrontierHarass.AIDataArmyGUID) == null)
{
aicommanderMission_FrontierHarass.Interrupt();
}
else
{
base.ForceArmyGUID = aicommanderMission_FrontierHarass.AIDataArmyGUID;
this.CurrentWarStep = AICommander_WarWithObjective.WarSteps.BeSiegingCity;
this.CancelMission(aicommanderMission_FrontierHarass);
}
}
else
{
WantedDiplomaticRelationStateMessage wantedDiplomaticRelationStateMessage = base.AIPlayer.Blackboard.FindFirst <WantedDiplomaticRelationStateMessage>(BlackboardLayerID.Empire, (WantedDiplomaticRelationStateMessage message) => message.OpponentEmpireIndex == region.City.Empire.Index);
if (wantedDiplomaticRelationStateMessage == null)
{
Diagnostics.LogWarning("[AICommander_WarWithObjective] No WantedDiplomaticRelationStateMessage found");
}
else if (wantedDiplomaticRelationStateMessage.WantedDiplomaticRelationStateName == DiplomaticRelationState.Names.War)
{
wantedDiplomaticRelationStateMessage.CurrentWarStatusType = AILayer_War.WarStatusType.Ready;
}
}
}
break;
}
case AICommander_WarWithObjective.WarSteps.BeSiegingCity:
this.BesiegeCityProcessor(region);
break;
case AICommander_WarWithObjective.WarSteps.AttackingCity:
{
AICommanderMission aicommanderMission = base.Missions.Find((AICommanderMission match) => match is AICommanderMission_AttackCityDefault);
if (aicommanderMission != null)
{
base.ForceArmyGUID = aicommanderMission.AIDataArmyGUID;
this.CancelMission(aicommanderMission);
}
this.CurrentWarStep = AICommander_WarWithObjective.WarSteps.BeSiegingCity;
break;
}
default:
Diagnostics.LogError(string.Format("[AICommander_WarWithObjective] Unknow war step", this.CurrentWarStep.ToString()));
break;
}
}
this.PopulateMission();
this.EvaluateMission();
base.PromoteMission();
}
public void RefreshContent()
{
if (this.City == null)
{
return;
}
if (this.City.Empire == null)
{
return;
}
if (this.GuiEmpire.Index != this.City.Empire.Index)
{
if (this.guiEmpire == null)
{
this.Unbind();
return;
}
this.GuiEmpire = new GuiEmpire(this.City.Empire);
DepartmentOfIndustry agency = this.City.Empire.GetAgency <DepartmentOfIndustry>();
this.ConstructionQueue = agency.GetConstructionQueue(this.City);
}
if (this.GuiEmpire != null)
{
this.FactionBackground.TintColor = this.GuiEmpire.Color;
this.PopulationSymbol.TintColor = this.GuiEmpire.Color;
this.FactionSymbol.TintColor = this.GuiEmpire.Color;
this.PinLine.TintColor = this.GuiEmpire.Color;
this.PopulationNumber.Text = GuiFormater.FormatGui(this.City.GetPropertyValue(SimulationProperties.Population), false, false, false, 1);
this.FactionSymbol.Image = this.GuiEmpire.GuiFaction.GetImageTexture(global::GuiPanel.IconSize.LogoSmall, true);
}
string content = "%CityCurrentConstructionDescription";
if (this.City.IsInfected)
{
this.PanelSpying.Visible = false;
this.PanelOvergrownCity.Visible = true;
this.AgeTransform.Height = this.ModifierPosition.EndHeight;
if (this.GuiPreviousEmpire == null)
{
this.GuiPreviousEmpire = new GuiEmpire(this.City.LastNonInfectedOwner);
}
if (this.GuiPreviousEmpire != null)
{
this.PreviousEmpireFactionIcon.TintColor = this.GuiPreviousEmpire.Color;
this.PreviousEmpireFactionIcon.Image = this.GuiPreviousEmpire.GuiFaction.GetImageTexture(global::GuiPanel.IconSize.LogoSmall, true);
this.PreviousEmpireFactionTooltip.Class = "Descriptor";
this.PreviousEmpireFactionTooltip.ClientData = this.GuiEmpire.Empire;
Faction faction = this.GuiPreviousEmpire.Empire.Faction;
if (faction != null)
{
new List <string>();
foreach (SimulationDescriptor simulationDescriptor in faction.GetIntegrationDescriptors())
{
this.PreviousEmpireFactionTooltip.Content = simulationDescriptor.Name;
}
}
}
if (this.ConstructionQueue.PendingConstructions.Count > 0)
{
Construction construction = this.ConstructionQueue.Peek();
if (construction.ConstructibleElement.SubCategory == "SubCategoryAssimilation" && construction.ConstructibleElement.Name != "CityConstructibleActionInfectedRaze")
{
content = "%IntegratingFactionUnderConstructionDescription";
}
}
}
this.ConstructionGroup.AgeTooltip.Content = content;
this.RefreshCityName();
DepartmentOfIntelligence agency2 = this.playerControllerRepository.ActivePlayerController.Empire.GetAgency <DepartmentOfIntelligence>();
bool flag = this.playerControllerRepository.ActivePlayerController.Empire.SimulationObject.Tags.Contains(global::Empire.TagEmpireEliminated);
if (flag && ELCPUtilities.SpectatorSpyFocus >= 0)
{
agency2 = this.game.Empires[ELCPUtilities.SpectatorSpyFocus].GetAgency <DepartmentOfIntelligence>();
}
Unit hero = null;
InfiltrationProcessus.InfiltrationState infiltrationState = InfiltrationProcessus.InfiltrationState.None;
bool flag2 = false;
if (this.playerControllerRepository != null)
{
if (this.City.Empire == this.playerControllerRepository.ActivePlayerController.Empire)
{
flag2 = true;
}
else if (this.PanelSpying.Visible && agency2 != null && agency2.TryGetSpyOnGarrison(this.City, out hero, out infiltrationState) && infiltrationState == InfiltrationProcessus.InfiltrationState.Infiltrated)
{
flag2 = true;
}
else if (flag)
{
flag2 = true;
}
}
if (!flag2)
{
if (this.City.Empire == null)
{
this.CompetitorTitle.Text = string.Empty;
}
else
{
DiplomaticRelation diplomaticRelation = this.playerControllerRepository.ActivePlayerController.Empire.GetAgency <DepartmentOfForeignAffairs>().GetDiplomaticRelation(this.City.Empire);
Diagnostics.Assert(diplomaticRelation != null);
if (diplomaticRelation.State != null && diplomaticRelation.State.Name == DiplomaticRelationState.Names.Alliance)
{
AgeUtils.TruncateString(AgeLocalizer.Instance.LocalizeString("%CityLabelAlliedTitle"), this.CompetitorTitle, out this.temp, '.');
this.CompetitorTitle.Text = this.temp;
}
else if (diplomaticRelation.State != null && diplomaticRelation.State.Name == DiplomaticRelationState.Names.Peace)
{
AgeUtils.TruncateString(AgeLocalizer.Instance.LocalizeString("%CityLabelFriendlyTitle"), this.CompetitorTitle, out this.temp, '.');
this.CompetitorTitle.Text = this.temp;
}
else
{
AgeUtils.TruncateString(AgeLocalizer.Instance.LocalizeString("%CityLabelEnemyTitle"), this.CompetitorTitle, out this.temp, '.');
this.CompetitorTitle.Text = this.temp;
}
}
}
this.SelectionButton.AgeTransform.Enable = flag2;
this.PlayerSpecificGroup.Visible = flag2;
this.CompetitorSpecificGroup.Visible = !flag2;
float propertyValue = this.City.GetPropertyValue(SimulationProperties.CityDefensePoint);
float propertyValue2 = this.City.GetPropertyValue(SimulationProperties.MaximumCityDefensePoint);
float propertyValue3 = this.City.GetPropertyValue(SimulationProperties.CityDefensePointRecoveryPerTurn);
float propertyValue4 = this.City.GetPropertyValue(SimulationProperties.Ownership);
Diagnostics.Assert(this.UnitNumber != null);
Diagnostics.Assert(this.City.StandardUnits != null);
int num = (this.City.Militia == null) ? 0 : this.City.Militia.StandardUnits.Count;
this.UnitNumber.Text = GuiFormater.FormatGui(this.City.StandardUnits.Count + num);
this.DefenseNumber.Text = GuiFormater.FormatStock(propertyValue, SimulationProperties.CityDefensePoint, 0, true);
float propertyValue5 = this.City.GetPropertyValue(SimulationProperties.DefensivePower);
this.DefenseGroup.AgeTooltip.Content = AgeLocalizer.Instance.LocalizeString("%CityDefenseDescription");
this.DefenseIcon.Image = AgeManager.Instance.FindDynamicTexture("fortificationCityLabel", false);
if (propertyValue5 > 0f)
{
this.DefenseGroup.AgeTooltip.Content = AgeLocalizer.Instance.LocalizeString("%CityDefenseWithDefensivePowerDescription").Replace("$DefensivePowerValue", GuiFormater.FormatGui(propertyValue5, false, true, false, 1));
this.DefenseIcon.Image = AgeManager.Instance.FindDynamicTexture("retaliationCityLabel", false);
}
this.DefenseGroup.AgeTooltip.Content = this.DefenseGroup.AgeTooltip.Content.Replace("$CityDefenseValue", GuiFormater.FormatGui(propertyValue, false, true, false, 1));
if (propertyValue4 < 1f && !this.City.IsInfected)
{
this.OwnershipPercentage.AgeTransform.Visible = true;
this.OwnershipPercentage.Text = GuiFormater.FormatGui(propertyValue4, true, false, false, 1);
}
else
{
this.OwnershipPercentage.AgeTransform.Visible = false;
}
if (this.City.BesiegingEmpire != null || this.City.BesiegingSeafaringArmies.Count != 0 || this.City.IsUnderEarthquake)
{
float num2 = DepartmentOfTheInterior.GetBesiegingPower(this.City, true);
num2 += DepartmentOfTheInterior.GetCityPointEarthquakeDamage(this.City);
this.DefenseTendency.Text = "(" + GuiFormater.FormatGui(-num2, false, true, true, 1) + ")";
}
else if (propertyValue < propertyValue2)
{
this.DefenseTendency.Text = "(" + GuiFormater.FormatGui(propertyValue3, false, true, true, 1) + ")";
}
else
{
this.DefenseTendency.Text = string.Empty;
}
if (flag2)
{
Construction construction2 = null;
if (this.ConstructionQueue != null)
{
construction2 = this.ConstructionQueue.Peek();
}
if (this.City.IsInfected && construction2 == null)
{
this.PlayerSpecificGroup.Visible = false;
}
if (construction2 != null)
{
IImageFeatureProvider imageFeatureProvider = construction2.ConstructibleElement as IImageFeatureProvider;
GuiElement guiElement;
if (imageFeatureProvider != null)
{
Texture2D image;
if (imageFeatureProvider.TryGetTextureFromIcon(global::GuiPanel.IconSize.Small, out image))
{
this.ConstructionImage.Image = image;
}
}
else if (this.guiPanelHelper.TryGetGuiElement(construction2.ConstructibleElement.Name, out guiElement))
{
Texture2D image2;
if (this.guiPanelHelper.TryGetTextureFromIcon(guiElement, global::GuiPanel.IconSize.Small, out image2))
{
this.ConstructionImage.Image = image2;
}
}
else
{
this.ConstructionImage.Image = null;
}
CityLabel.emptyList.Clear();
int b;
float num3;
float num4;
bool flag3;
QueueGuiItem.GetConstructionTurnInfos(this.City, construction2, CityLabel.emptyList, out b, out num3, out num4, out flag3);
int numberOfTurn = Mathf.Max(1, b);
this.ConstructionTurns.Text = QueueGuiItem.FormatNumberOfTurns(numberOfTurn);
}
else
{
this.ConstructionImage.Image = this.NoConstructionTexture;
this.ConstructionTurns.Text = "%EmptyConstructionTitle";
}
}
if (this.PanelSpying.Visible && this.playerControllerRepository != null && agency2 != null)
{
float value = this.City.GetPropertyValue(SimulationProperties.CityAntiSpy) * 0.01f;
this.AntiSpyValue.Text = GuiFormater.FormatGui(value, true, true, false, 0);
this.HeroGroup.Visible = false;
this.SpyingEffectsGroup.Visible = false;
this.AssignSpyButton.AgeTransform.Visible = false;
if (this.City.Empire != this.playerControllerRepository.ActivePlayerController.Empire)
{
if (infiltrationState != InfiltrationProcessus.InfiltrationState.None)
{
this.HeroGroup.Visible = true;
this.HeroCard.Bind(hero, this.playerControllerRepository.ActivePlayerController.Empire as global::Empire, null);
this.HeroCard.RefreshContent(false, false);
if (this.HeroCard.GuiHero != null)
{
AgeTooltip ageTooltip = this.HeroCard.HeroPortrait.AgeTransform.AgeTooltip;
if (ageTooltip != null)
{
ageTooltip.Class = "Unit";
ageTooltip.ClientData = this.HeroCard.GuiHero;
ageTooltip.Content = this.HeroCard.GuiHero.Title;
}
}
if (infiltrationState == InfiltrationProcessus.InfiltrationState.Infiltrated)
{
this.InfiltrationTurnSymbol.AgeTransform.Visible = false;
this.InfiltrationTurnValue.AgeTransform.Visible = false;
this.HeroCard.AgeTransform.Alpha = 1f;
this.SpyingEffectsGroup.Visible = true;
}
else
{
this.HeroCard.AgeTransform.Alpha = 0.75f;
this.InfiltrationTurnSymbol.AgeTransform.Visible = true;
this.InfiltrationTurnValue.AgeTransform.Visible = true;
int value2 = DepartmentOfIntelligence.InfiltrationRemainingTurns(hero);
this.InfiltrationTurnValue.Text = GuiFormater.FormatGui(value2);
}
}
else if (!flag)
{
this.AssignSpyButton.AgeTransform.Visible = true;
float value3 = 0f;
this.failures.Clear();
bool flag4 = agency2.CanBeInfiltrate(this.City, out value3, this.failures);
bool flag5 = agency2.Empire.GetAgency <DepartmentOfEducation>().Heroes.Count < 1;
if (flag5)
{
flag4 = false;
}
this.AssignSpyButton.AgeTransform.Enable = flag4;
global::IGuiService service = Services.GetService <global::IGuiService>();
string str = string.Empty;
if (this.failures.Contains(DepartmentOfIntelligence.InfiltrationTargetFailureNotAffordable))
{
str = "#c52222#";
}
string arg = str + GuiFormater.FormatGui(value3, false, true, false, 0) + service.FormatSymbol(this.infiltrationCostResourceName);
string format = AgeLocalizer.Instance.LocalizeString("%EspionageLabelAssignSpyTitle");
this.AssignTitle.Text = string.Format(format, arg);
AgeTooltip ageTooltip2 = this.AssignSpyButton.AgeTransform.AgeTooltip;
if (ageTooltip2)
{
if (flag4)
{
ageTooltip2.Content = "%EspionageLabelAssignSpyDescription";
}
else if (flag5)
{
ageTooltip2.Content = "%EspionageLabelAssignSpyNoHeroesDescription";
}
else if (this.failures.Contains(DepartmentOfIntelligence.InfiltrationTargetFailureNotVisible))
{
ageTooltip2.Content = "%EspionageLabelAssignSpyNoVisibilityDescription";
}
else if (this.failures.Contains(DepartmentOfIntelligence.InfiltrationTargetFailureSiege))
{
ageTooltip2.Content = "%EspionageLabelAssignSpyUnderSiegeDescription";
}
else if (this.failures.Contains(DepartmentOfIntelligence.InfiltrationTargetFailureNotAffordable))
{
ageTooltip2.Content = "%EspionageLabelAssignSpyNotAffordableDescription";
}
else if (this.failures.Contains(DepartmentOfIntelligence.InfiltrationTargetFailureAlreadyInfiltrated))
{
ageTooltip2.Content = "%EspionageLabelAssignSpyAlreadyInfiltratedDescription";
}
else if (this.failures.Contains(DepartmentOfIntelligence.InfiltrationTargetFailureCityInfected))
{
ageTooltip2.Content = "%EspionageLabelAssignSpyCityInfectedDescription";
}
}
}
}
}
bool flag6 = false;
List <Kaiju> list = new List <Kaiju>();
foreach (RegionalEffect regionalEffect in this.city.GetRegionalEffects())
{
IRegionalEffectsProviderGameEntity regionalEffectsProviderGameEntity = null;
if (this.regionalEffectsService.TryGetEffectOwner(regionalEffect.GUID, out regionalEffectsProviderGameEntity) && regionalEffectsProviderGameEntity.GetRegionalEffectsProviderContext().SimulationObject.Tags.Contains("ClassKaiju"))
{
flag6 = true;
if (regionalEffectsProviderGameEntity is Kaiju)
{
Kaiju item = regionalEffectsProviderGameEntity as Kaiju;
if (!list.Contains(item))
{
list.Add(item);
}
}
}
}
if (flag6)
{
AgeTransform ageTransform = this.KaijuIcon.AgeTransform;
ageTransform.Visible = true;
ageTransform.Enable = true;
this.PopulationGroup.PercentBottom = 100f - (ageTransform.Height + ageTransform.PixelMarginBottom) / ageTransform.GetParent().Height * 100f;
KaijuInfluenceInCityTooltipData clientData = new KaijuInfluenceInCityTooltipData(this.City, list);
this.KaijuIcon.AgeTransform.AgeTooltip.Content = "%CityKaijuAffectedDescription";
this.KaijuIcon.AgeTransform.AgeTooltip.Class = "Kaijus";
this.KaijuIcon.AgeTransform.AgeTooltip.ClientData = clientData;
return;
}
this.KaijuIcon.AgeTransform.Visible = false;
this.KaijuIcon.AgeTransform.Enable = false;
this.PopulationGroup.PercentBottom = 100f;
}
protected override void RefreshObjectives(StaticString context, StaticString pass)
{
base.RefreshObjectives(context, pass);
base.GatherObjectives(AICommanderMissionDefinition.AICommanderCategory.Defense.ToString(), ref this.globalObjectiveMessages);
base.ValidateMessages(ref this.globalObjectiveMessages);
AILayer_War layer = base.AIEntity.GetLayer <AILayer_War>();
base.GlobalPriority.Reset();
AILayer_Strategy layer2 = base.AIEntity.GetLayer <AILayer_Strategy>();
base.GlobalPriority.Add(layer2.StrategicNetwork.GetAgentValue("InternalMilitary"), "Strategic Network 'InternalMilitary'", new object[0]);
AILayer_ArmyManagement layer3 = base.AIEntity.GetLayer <AILayer_ArmyManagement>();
float worldColonizationRatio = this.worldAtlasHelper.GetWorldColonizationRatio(base.AIEntity.Empire);
bool flag = layer.WantWarWithSomoeone() || layer.NumberOfWar > 0;
City mainCity = this.departmentOfTheInterior.MainCity;
bool flag2 = false;
if (this.departmentOfTheInterior.NonInfectedCities.Count < 4)
{
List <IGarrison> list = new List <IGarrison>();
list.AddRange(this.departmentOfDefense.Armies.ToList <Army>().FindAll((Army match) => !match.IsSeafaring && !match.IsSettler && match.UnitsCount > 3).Cast <IGarrison>());
if (list.Count > 1)
{
flag2 = true;
}
}
for (int i = 0; i < this.departmentOfTheInterior.Cities.Count; i++)
{
City city = this.departmentOfTheInterior.Cities[i];
if (this.IsObjectiveValid(AICommanderMissionDefinition.AICommanderCategory.Defense.ToString(), city.Region.Index, true))
{
GlobalObjectiveMessage globalObjectiveMessage = this.globalObjectiveMessages.Find((GlobalObjectiveMessage match) => match.RegionIndex == city.Region.Index);
if (globalObjectiveMessage == null)
{
globalObjectiveMessage = base.GenerateObjective(city.Region.Index);
globalObjectiveMessage.LocalPriority = new HeuristicValue(0f);
this.globalObjectiveMessages.Add(globalObjectiveMessage);
}
globalObjectiveMessage.TimeOut = 1;
globalObjectiveMessage.LocalPriority.Reset();
if (flag2 && city == mainCity)
{
bool flag3 = !AILayer_Military.AreaIsSave(city.WorldPosition, 15, this.departmentOfForeignAffairs, false, false);
if (!flag3)
{
foreach (Region region in this.worldPositionningService.GetNeighbourRegions(city.Region, false, false))
{
if (region.IsLand && region.Owner is MajorEmpire)
{
DiplomaticRelation diplomaticRelation = this.departmentOfForeignAffairs.GetDiplomaticRelation(region.Owner);
if (diplomaticRelation.State.Name == DiplomaticRelationState.Names.War || diplomaticRelation.State.Name == DiplomaticRelationState.Names.ColdWar || diplomaticRelation.State.Name == DiplomaticRelationState.Names.Truce)
{
flag3 = true;
break;
}
}
}
}
if (flag3)
{
globalObjectiveMessage.LocalPriority = new HeuristicValue(1f);
globalObjectiveMessage.GlobalPriority = new HeuristicValue(1f);
}
}
else
{
globalObjectiveMessage.GlobalPriority = base.GlobalPriority;
AICommanderWithObjective aicommanderWithObjective = layer3.FindCommander(globalObjectiveMessage);
if (aicommanderWithObjective != null && aicommanderWithObjective is AICommander_Defense)
{
AICommander_Defense aicommander_Defense = aicommanderWithObjective as AICommander_Defense;
globalObjectiveMessage.LocalPriority.Add(AILayer_Military.GetCityDefenseLocalPriority(city, this.unitRatioBoost, aicommander_Defense.ComputeCurrentUnitInDefense()), "CityDefenseLocalPriority", new object[0]);
}
else
{
globalObjectiveMessage.LocalPriority.Add(AILayer_Military.GetCityDefenseLocalPriority(city, this.unitRatioBoost, -1), "CityDefenseLocalPriority", new object[0]);
}
HeuristicValue heuristicValue = new HeuristicValue(0f);
heuristicValue.Add(worldColonizationRatio, "colonization ratio", new object[0]);
heuristicValue.Multiply(0.2f, "(constant)", new object[0]);
globalObjectiveMessage.LocalPriority.Boost(heuristicValue, "Colonization boost", new object[0]);
if (flag)
{
globalObjectiveMessage.LocalPriority.Boost(0.3f, "Want war", new object[0]);
}
AIData_City aidata_City;
if (this.aiDataRepositoryAIHelper.TryGetAIData <AIData_City>(city.GUID, out aidata_City) && aidata_City.IsAtWarBorder)
{
globalObjectiveMessage.LocalPriority.Boost(0.3f, "War border", new object[0]);
}
if ((float)this.endTurnService.Turn < this.unitInGarrisonTurnLimit)
{
globalObjectiveMessage.LocalPriority.Boost(-0.3f, "turn under 'unitInGarrisonTurnLimit' ({0})", new object[]
{
this.unitInGarrisonTurnLimit
});
}
}
}
}
MajorEmpire majorEmpire = base.AIEntity.Empire as MajorEmpire;
if (majorEmpire == null || majorEmpire.ConvertedVillages.Count == 0)
{
return;
}
if (mainCity == null)
{
return;
}
float num = AILayer_Military.GetCityDefenseLocalPriority(mainCity, this.unitRatioBoost, AICommanderMission_Garrison.SimulatedUnitsCount);
num *= this.villageDefenseRatioDeboost;
num *= base.GlobalPriority;
for (int k = 0; k < this.VillageDOFPriority.Count; k++)
{
this.VillageDOFPriority[k].Reset();
}
float num2 = 0f;
for (int l = 0; l < majorEmpire.ConvertedVillages.Count; l++)
{
Village village = majorEmpire.ConvertedVillages[l];
AILayer_Military.VillageDefensePriority villageDefensePriority = this.VillageDOFPriority.Find((AILayer_Military.VillageDefensePriority match) => match.Village.GUID == village.GUID);
if (villageDefensePriority == null)
{
villageDefensePriority = new AILayer_Military.VillageDefensePriority();
villageDefensePriority.Reset();
villageDefensePriority.Village = village;
this.VillageDOFPriority.Add(villageDefensePriority);
}
villageDefensePriority.ToDelete = false;
villageDefensePriority.FirstUnitPriority = num;
float num3 = (float)this.worldPositionningService.GetDistance(village.WorldPosition, mainCity.WorldPosition);
villageDefensePriority.DistanceToMainCity = num3;
if (num3 > num2)
{
num2 = num3;
}
}
for (int m = this.VillageDOFPriority.Count - 1; m >= 0; m--)
{
AILayer_Military.VillageDefensePriority villageDefensePriority2 = this.VillageDOFPriority[m];
if (villageDefensePriority2.ToDelete)
{
this.VillageDOFPriority.Remove(villageDefensePriority2);
}
else
{
float num4 = villageDefensePriority2.DistanceToMainCity / num2;
if (majorEmpire.ConvertedVillages.Count > 1)
{
villageDefensePriority2.FirstUnitPriority = AILayer.Boost(villageDefensePriority2.FirstUnitPriority, num4 * -0.1f);
}
}
}
}
private void ScoreWatchtowerNodes()
{
City[] knownCities = this.GetKnownCities(false);
List <float> list = new List <float>();
for (int i = 0; i < this.availableNodes.Count; i++)
{
AILayer_CreepingNode.EvaluableCreepingNode evaluableCreepingNode = this.availableNodes[i];
if (evaluableCreepingNode.pointOfInterest.Type != "WatchTower")
{
list.Add(0f);
}
else
{
float num = float.MaxValue;
int num2 = 0;
for (int j = 0; j < knownCities.Length; j++)
{
City city = knownCities[j];
float num3 = (float)this.worldPositionningService.GetDistance(evaluableCreepingNode.pointOfInterest.WorldPosition, city.WorldPosition);
if (num3 < num)
{
num = num3;
num2 = j;
}
}
float num4 = 0f;
if (knownCities.Length != 0)
{
num4 = 1f / num;
DiplomaticRelation diplomaticRelation = knownCities[num2].Empire.GetAgency <DepartmentOfForeignAffairs>().GetDiplomaticRelation(base.AIEntity.Empire);
if (diplomaticRelation != null)
{
string a = diplomaticRelation.State.Name;
if (!(a == "DiplomaticRelationStateWar"))
{
if (!(a == "DiplomaticRelationStateTruce"))
{
if (!(a == "DiplomaticRelationStateColdWar"))
{
if (!(a == "DiplomaticRelationStatePeace"))
{
if (!(a == "DiplomaticRelationStateAlliance"))
{
num4 *= 0f;
}
else
{
num4 *= this.TowerMultiplierForAlliance;
}
}
else
{
num4 *= this.TowerMultiplierForPeace;
}
}
else
{
num4 *= this.TowerMultiplierForColdWar;
}
}
else
{
num4 *= this.TowerMultiplierForTruce;
}
}
else
{
num4 *= this.TowerMultiplierForWar;
}
}
}
list.Add(num4);
}
}
if (list.Count > 0)
{
float num5 = list.Min();
float num6 = list.Max();
for (int k = 0; k < list.Count; k++)
{
if (!(this.availableNodes[k].pointOfInterest.Type != "WatchTower"))
{
float num7 = (num5 == num6) ? this.NormalizationFailSafeValue : Mathf.InverseLerp(num5, num6, list[k]);
float score = this.availableNodes[k].score;
float boostFactor = num7 * this.TowersWeight;
this.availableNodes[k].score = AILayer.Boost(score, boostFactor);
}
}
}
}
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 void SetContent(MajorEmpire empire, VictoryCondition victoryCondition, PlayerController playerController, int victoryRank)
{
this.Comparable = 0f;
bool flag = true;
if (empire != playerController.Empire && !playerController.Empire.SimulationObject.Tags.Contains(Empire.TagEmpireEliminated))
{
flag = false;
Diagnostics.Assert(playerController.Empire != null);
EmpireInfo.Accessibility lastAccessibilityLevel = EmpireInfo.LastAccessibilityLevel;
if (lastAccessibilityLevel != EmpireInfo.Accessibility.Default)
{
if (lastAccessibilityLevel == EmpireInfo.Accessibility.Partial)
{
DepartmentOfIntelligence agency = playerController.Empire.GetAgency <DepartmentOfIntelligence>();
if (agency != null && agency.IsEmpireInfiltrated(empire))
{
flag = true;
}
}
}
else
{
DepartmentOfForeignAffairs agency2 = playerController.Empire.GetAgency <DepartmentOfForeignAffairs>();
if (agency2 != null)
{
DiplomaticRelation diplomaticRelation = agency2.GetDiplomaticRelation(empire);
flag |= (diplomaticRelation != null && diplomaticRelation.State != null && diplomaticRelation.State.Name != DiplomaticRelationState.Names.Unknown);
}
if (!flag)
{
DepartmentOfIntelligence agency3 = playerController.Empire.GetAgency <DepartmentOfIntelligence>();
if (agency3 != null && agency3.IsEmpireInfiltrated(empire))
{
flag = true;
}
}
}
}
if (!empire.VictoryConditionStatuses.ContainsKey(victoryCondition.Name) || !flag)
{
base.GetComponent <AgeTransform>().Visible = false;
return;
}
base.GetComponent <AgeTransform>().Visible = true;
this.format = AgeLocalizer.Instance.LocalizeString(victoryCondition.Progression.Format);
for (int i = 0; i < victoryCondition.Progression.Vars.Length; i++)
{
if (this.format.Contains(victoryCondition.Progression.Vars[i].Name))
{
this.varName = "$" + victoryCondition.Progression.Vars[i].Name;
this.format = this.format.Replace(this.varName, GuiFormater.FormatGui(empire.VictoryConditionStatuses[victoryCondition.Name].Variables[i], victoryCondition.Progression.Vars[i].Name == "Ratio", false, false, 0));
}
if (victoryCondition.Progression.Vars[i].Name == victoryCondition.Progression.SortVariable)
{
this.Comparable = empire.VictoryConditionStatuses[victoryCondition.Name].Variables[i];
}
}
this.Title.Text = empire.LocalizedName;
this.Value.Text = this.format;
this.Value.AgeTransform.Width = this.Value.Font.ComputeTextWidth(this.Value.Text, false, false);
this.Title.AgeTransform.PixelMarginRight = this.Value.AgeTransform.PixelMarginRight + this.Value.AgeTransform.PixelMarginLeft + this.Value.AgeTransform.Width;
this.Title.TintColor = empire.Color;
this.Value.TintColor = empire.Color;
if (empire == playerController.Empire)
{
this.TitleModifier.StartDelay = 0.3f * (float)victoryRank;
this.TitleModifier.StartAnimation();
return;
}
this.TitleModifier.Reset();
this.Title.AgeTransform.Alpha = 1f;
}
