public void OnForceShiftCB(GameObject obj)
{
if (this.Garrison != null)
{
DepartmentOfScience agency = this.Garrison.Empire.GetAgency <DepartmentOfScience>();
if (agency == null || agency.GetTechnologyState("TechnologyDefinitionOrbUnlock17WinterShifters") != DepartmentOfScience.ConstructibleElement.State.Researched)
{
return;
}
List <Unit> list = new List <Unit>(this.selectedUnits);
list.RemoveAll((Unit unit) => !unit.IsShifter() || !unit.IsInCurrentSeasonForm());
if (list.Count > 0)
{
OrderForceShiftUnits order = new OrderForceShiftUnits(this.Garrison.Empire.Index, list.ToArray());
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
Ticket ticket;
service.ActivePlayerController.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OnOrderResponse));
EventForceShift eventToNotify = new EventForceShift(this.Garrison.Empire, list.Count, true);
IEventService service2 = Services.GetService <IEventService>();
if (service2 != null)
{
service2.Notify(eventToNotify);
}
}
}
}
private void QueueResearch()
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service2 != null)
{
if (this.TechnologyDefinition.HasTechnologyFlag(DepartmentOfScience.ConstructibleElement.TechnologyFlag.KaijuUnlock))
{
OrderQueueKaijuResearch order = new OrderQueueKaijuResearch(this.empire.Index, this.TechnologyDefinition);
Ticket ticket;
service2.ActivePlayerController.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OnOrderResponse));
return;
}
OrderQueueResearch orderQueueResearch = new OrderQueueResearch(this.empire.Index, this.TechnologyDefinition);
if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
{
orderQueueResearch.InsertAtFirstPlace = true;
}
Ticket ticket2;
service2.ActivePlayerController.PostOrder(orderQueueResearch, out ticket2, new EventHandler <TicketRaisedEventArgs>(this.OnOrderResponse));
}
}
protected override IEnumerator OnShow(params object[] parameters)
{
yield return(base.OnShow(parameters));
IPlayerControllerRepositoryService playerControllerRepositoryService = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.interactionsAllowed = playerControllerRepositoryService.ActivePlayerController.CanSendOrders();
if (parameters.Length > 0)
{
this.selectionValidatedClient = (parameters[0] as GameObject);
}
if (parameters.Length > 1)
{
this.destination = (parameters[1] as IGarrison);
}
this.isASpySelection = false;
if (parameters.Length > 2)
{
this.isASpySelection = (bool)parameters[2];
}
IPlayerControllerRepositoryService playerControllerRepository = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.CurrentHero = null;
this.Bind(playerControllerRepository.ActivePlayerController.Empire as global::Empire);
this.RefreshContent();
yield break;
}
private void SpawnArmy()
{
IGameService service = Services.GetService <IGameService>();
if (service.Game == null)
{
return;
}
if (WorldCursor.HighlightedWorldPosition.IsValid)
{
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
string value = Amplitude.Unity.Runtime.Runtime.Registry.GetValue <string>("Debug/GodCursor/SpawnArmy", string.Empty);
int index = service2.ActivePlayerController.Empire.Index;
if (string.IsNullOrEmpty(value))
{
return;
}
string[] array = value.Split(new char[]
{
','
});
if (array.Length == 0)
{
return;
}
StaticString[] unitDesignsByName = Array.ConvertAll <string, StaticString>(array, (string input) => input);
OrderSpawnArmy orderSpawnArmy = new OrderSpawnArmy(index, WorldCursor.HighlightedWorldPosition, unitDesignsByName);
service2.ActivePlayerController.PostOrder(orderSpawnArmy);
Diagnostics.Log("Posting order: {0}.", new object[]
{
orderSpawnArmy.ToString()
});
}
}
public virtual void Bind(IGarrison garrison, IGarrison militia = null, GameObject parent = null)
{
this.Unbind();
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.IsOtherEmpire = (service.ActivePlayerController.Empire != garrison.Empire);
this.Garrison = garrison;
this.Militia = militia;
this.guiUnits.Clear();
for (int i = 0; i < this.Garrison.StandardUnits.Count; i++)
{
this.guiUnits.Add(new GuiUnit(this.Garrison.StandardUnits[i], null));
}
if (this.Militia != null)
{
for (int j = 0; j < this.Militia.StandardUnits.Count; j++)
{
this.guiUnits.Add(new GuiUnit(this.Militia.StandardUnits[j], null));
}
}
this.DepartmentOfTheTreasury = this.Garrison.Empire.GetAgency <DepartmentOfTheTreasury>();
this.DepartmentOfScience = this.Garrison.Empire.GetAgency <DepartmentOfScience>();
Diagnostics.Assert(this.Garrison.Empire != null, "Garrison has not assigned Empire");
this.departmentOfDefense = this.Garrison.Empire.GetAgency <DepartmentOfDefense>();
this.departmentOfTheInterior = this.Garrison.Empire.GetAgency <DepartmentOfTheInterior>();
this.parent = parent;
}
private void SpawnMinorArmy()
{
IGameService service = Services.GetService <IGameService>();
if (service.Game == null)
{
return;
}
if (WorldCursor.HighlightedWorldPosition.IsValid && WorldCursor.HighlightedRegion.MinorEmpire != null)
{
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
UnitDesign unitDesign = WorldCursor.HighlightedRegion.MinorEmpire.GetAgency <DepartmentOfDefense>().UnitDesignDatabase.UserDefinedUnitDesigns[0];
List <StaticString> list = new List <StaticString>();
for (int i = 0; i < 3; i++)
{
list.Add(unitDesign.Name);
}
OrderSpawnArmy orderSpawnArmy = new OrderSpawnArmy(WorldCursor.HighlightedRegion.MinorEmpire.Index, WorldCursor.HighlightedWorldPosition, list.ToArray());
service2.ActivePlayerController.PostOrder(orderSpawnArmy);
Diagnostics.Log("Posting order: {0}.", new object[]
{
orderSpawnArmy.ToString()
});
}
}
protected override IEnumerator OnShow(params object[] parameters)
{
yield return(base.OnShow(parameters));
if (this.SaveMode)
{
this.PanelTitle.Text = "%SaveGamePanelTitle";
int turn = (base.Game as Game).Turn;
this.TextInputLabel.Text = string.Format("New Save Title - Turn {0}", turn + 1);
IPlayerControllerRepositoryService playerControllerRepositoryService = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (playerControllerRepositoryService != null)
{
string factionName = (!TutorialManager.IsActivated) ? (playerControllerRepositoryService.ActivePlayerController.Empire as Empire).Faction.LocalizedName : AgeLocalizer.Instance.LocalizeString("%TutorialSaveName");
this.TextInputLabel.Text = string.Format(AgeLocalizer.Instance.LocalizeString("%SaveFileFormat"), factionName, turn + 1);
}
this.LoadButton.Visible = false;
this.SaveButton.Visible = true;
this.TextInput.AgeTransform.Enable = true;
AgeManager.Instance.FocusedControl = this.TextInput;
}
else
{
this.PanelTitle.Text = "%LoadGamePanelTitle";
this.TextInputLabel.Text = string.Empty;
this.LoadButton.Visible = true;
this.LoadButton.Enable = false;
this.SaveButton.Visible = false;
this.TextInput.AgeTransform.Enable = false;
}
this.DeleteButton.Enable = false;
this.GameSaveDescriptor = null;
this.SortsContainer.SetContent(this.SaveLineSlotPrefab, "LoadSaveGame", null);
this.RefreshContent();
yield break;
}
public override IEnumerator BindServices(IServiceContainer serviceContainer)
{
yield return(base.BindService <IGameEntityRepositoryService>(serviceContainer, delegate(IGameEntityRepositoryService service)
{
this.GameEntityRepositoryService = service;
}));
yield return(base.BindService <IPlayerControllerRepositoryService>(serviceContainer, delegate(IPlayerControllerRepositoryService service)
{
this.PlayerControllerRepositoryService = service;
}));
yield return(base.BindService <IVisibilityService>(serviceContainer, delegate(IVisibilityService service)
{
this.VisibilityService = service;
}));
serviceContainer.AddService <IWorldPositionningService>(this);
yield return(base.BindService <IPillarService>(serviceContainer, delegate(IPillarService service)
{
this.PillarService = service;
}));
yield return(base.BindService <ITerraformDeviceService>(serviceContainer, delegate(ITerraformDeviceService service)
{
this.TerraformDeviceService = service;
}));
yield break;
}
public void TryRelocateKaijuOrResetETA()
{
global::PlayerController server = this.KaijuEmpire.PlayerControllers.Server;
Region validKaijuRegion = KaijuCouncil.GetValidKaijuRegion();
if (validKaijuRegion == null)
{
if (this.Kaiju != null)
{
this.ResetRelocationETA();
}
Diagnostics.LogWarning("Unable to find suitable region. Reset Kaiju ETA!");
return;
}
WorldPosition validKaijuPosition = KaijuCouncil.GetValidKaijuPosition(validKaijuRegion, false);
if (validKaijuPosition == WorldPosition.Zero)
{
if (this.Kaiju != null)
{
this.ResetRelocationETA();
}
Diagnostics.LogWarning("Unable to find suitable position in target region. Reset Kaiju ETA.");
return;
}
if (server != null && this.Kaiju != null && this.Kaiju.OnGarrisonMode() && this.Kaiju.IsWild())
{
IPlayerControllerRepositoryService service = this.gameService.Game.Services.GetService <IPlayerControllerRepositoryService>();
OrderRelocateKaiju order = new OrderRelocateKaiju(this.Kaiju.GUID, validKaijuPosition);
server.PostOrder(order);
}
}
protected override IEnumerator OnShow(params object[] parameters)
{
yield return(base.OnShow(parameters));
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.interactionsAllowed = service.ActivePlayerController.CanSendOrders();
this.previousCursor = AgeManager.Instance.Cursor;
this.WorkerGroupsTable.Enable = true;
this.updateDrag = true;
UnityCoroutine.StartCoroutine(this, this.UpdateDrag(), null);
base.GuiService.GetGuiPanel <WorkersDragPanel>().Hide(true);
if (this.City != null)
{
base.NeedRefresh = true;
}
if (this.BoostersEnumerator == null)
{
bool highDefinition = AgeUtils.HighDefinition;
AgeUtils.HighDefinition = false;
GameEmpireScreen guiPanel = base.GuiService.GetGuiPanel <GameEmpireScreen>();
this.BoostersEnumerator = UnityEngine.Object.Instantiate <BoosterEnumerator>(guiPanel.BoostersEnumerator);
AgeUtils.HighDefinition = highDefinition;
}
yield break;
}
private IEnumerator RunAsync()
{
IPlayerControllerRepositoryService playerControllerRepositoryService = base.GameServer.Game.GetService <IPlayerControllerRepositoryService>();
if (playerControllerRepositoryService != null)
{
for (int index = 0; index < base.GameServer.Game.Empires.Length; index++)
{
PlayerController playerController = new PlayerController(base.GameServer)
{
Empire = base.GameServer.Game.Empires[index],
PlayerID = base.GameServer.Game.Empires[index].PlayerID
};
playerControllerRepositoryService.Register(playerController);
base.GameServer.Game.Empires[index].PlayerControllers.Server = playerController;
}
}
if (playerControllerRepositoryService != null)
{
PlayerController playerController2 = new PlayerController(base.GameServer)
{
PlayerID = "server"
};
playerControllerRepositoryService.Register(playerController2);
}
base.GameServer.BindMajorEmpires();
Diagnostics.Assert(base.GameServer != null);
Diagnostics.Assert(base.GameServer.Session != null);
switch (base.GameServer.Session.SessionMode)
{
case SessionMode.Private:
case SessionMode.Protected:
case SessionMode.Public:
{
IGameSerializationService gameSerializationService = Services.GetService <IGameSerializationService>();
if (gameSerializationService != null && gameSerializationService.GameSaveDescriptor == null)
{
Diagnostics.Log("Performing a quick save for the clients to download...");
string title = "%QuickSaveFileName";
string outputFileName = System.IO.Path.Combine(Amplitude.Unity.Framework.Application.TempDirectory, "Quicksave.sav");
yield return(gameSerializationService.SaveGameAsync(title, outputFileName, GameSaveOptions.QuickSave));
}
yield return(this.SynchronizeOnClientConnections());
break;
}
}
while (!base.VerifyGameClientStateSynchronization <GameClientState_GameLaunchedAndReady>())
{
base.RespondToDownloadGameRequests();
yield return(null);
}
yield break;
}
public void EmptyConstructionQueueForEmpire(Empire empire)
{
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
ConstructionQueue constructionQueueForEmpire = this.GetConstructionQueueForEmpire(empire);
for (int i = constructionQueueForEmpire.Length - 1; i >= 0; i--)
{
Construction construction = constructionQueueForEmpire.PeekAt(i);
OrderCancelKaijuResearch order = new OrderCancelKaijuResearch(empire.Index, construction.GUID);
service.ActivePlayerController.PostOrder(order);
}
}
private void ConfirmAssignment(object sender, MessagePanelResultEventArgs e)
{
if (e.Result == MessagePanelResult.Yes && this.selectedHero != null)
{
IGameService service = Services.GetService <IGameService>();
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
OrderChangeHeroAssignment order = new OrderChangeHeroAssignment(this.Army.Empire.Index, this.selectedHero.GUID, this.Army.GUID);
Ticket ticket;
service2.ActivePlayerController.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OnOrderResponse));
}
this.selectedHero = null;
}
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;
}
private void ForceUnlockTechnology()
{
IGameService service = Services.GetService <IGameService>();
if (service != null && service.Game != null)
{
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service2 != null && service2.ActivePlayerController != null)
{
OrderForceUnlockTechnology order = new OrderForceUnlockTechnology(service2.ActivePlayerController.Empire.Index, this.TechnologyDefinition.Name);
service2.ActivePlayerController.PostOrder(order);
}
}
}
private void OnChangeWeatherPresetCB(GameObject gameObject)
{
IPlayerControllerRepositoryService service = base.GameService.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service != null)
{
string presetName = string.Empty;
if (this.WeatherControlDroplist.SelectedItem > 0)
{
presetName = this.presetNames[this.WeatherControlDroplist.SelectedItem - 1];
}
OrderActivateWeatherControl order = new OrderActivateWeatherControl(service.ActivePlayerController.Empire.Index, presetName);
service.ActivePlayerController.PostOrder(order);
}
}
protected override IEnumerator OnLoadGame()
{
yield return(base.OnLoadGame());
IPlayerControllerRepositoryService playerControllerRepository = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
while (playerControllerRepository.ActivePlayerController == null)
{
yield return(null);
}
this.PlayerController = playerControllerRepository.ActivePlayerController;
this.allItems = Databases.GetDatabase <ItemDefinition>(false).GetValues();
this.refreshForgeItemDelegate = new AgeTransform.RefreshTableItem <ItemDefinition>(this.RefreshForgeItem);
yield break;
}
public void OnImmolateCB(GameObject obj)
{
if (this.Garrison != null)
{
List <Unit> list = new List <Unit>(this.selectedUnits);
list.RemoveAll((Unit unit) => !unit.IsImmolableUnit() || unit.IsAlreadyImmolated());
if (list.Count > 0)
{
OrderImmolateUnits order = new OrderImmolateUnits(this.Garrison.Empire.Index, list.ToArray());
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
Ticket ticket;
service.ActivePlayerController.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OnOrderResponse));
}
}
}
private void PostOrderBuyoutAndActivateBooster(GameEntityGUID targetGUID)
{
IGameService service = Services.GetService <IGameService>();
if (service != null && service.Game != null)
{
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service2 != null && service2.ActivePlayerController != null)
{
OrderBuyoutAndActivateBooster orderBuyoutAndActivateBooster = new OrderBuyoutAndActivateBooster(service2.ActivePlayerController.Empire.Index, this.guiStackedBooster.BoosterDefinition.Name, this.guiStackedBooster.GetFirstAvailableVaultBooster().GUID, false);
orderBuyoutAndActivateBooster.TargetGUID = targetGUID;
service2.ActivePlayerController.PostOrder(orderBuyoutAndActivateBooster);
Services.GetService <IAudioEventService>().Play2DEvent("Gui/Interface/BoosterStockPile");
}
}
}
protected override IEnumerator OnShow(params object[] parameters)
{
while (Amplitude.Unity.Gui.GuiModalPanel.GuiModalManager.CurrentModalPanel != null)
{
Amplitude.Unity.Gui.GuiModalPanel.GuiModalManager.CurrentModalPanel.Hide(false);
yield return(null);
}
yield return(base.OnShow(parameters));
Diagnostics.Assert(parameters != null & parameters.Length > 0);
this.GuiNotificationGameEnded = (parameters[0] as GuiNotificationGameEnded);
IPlayerControllerRepositoryService playerControllerRepository = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
Diagnostics.Assert(playerControllerRepository != null && playerControllerRepository.ActivePlayerController != null);
this.RefreshContent();
yield break;
}
private void EndTurnService_GameClientStateChange(object sender, GameClientStateChangeEventArgs e)
{
if (base.IsVisible && base.Game != null && this.Empire != null)
{
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
bool flag = service.ActivePlayerController.CanSendOrders();
if (this.interactionsAllowed != flag)
{
this.interactionsAllowed = flag;
this.RefreshButtons();
if (!this.interactionsAllowed && MessagePanel.Instance.IsVisible)
{
MessagePanel.Instance.Hide(false);
}
}
}
}
private void ChangeArmyNameIfValid()
{
if (this.Army == null)
{
return;
}
if (this.ValidateArmyName())
{
Order order = new OrderChangeEntityUserDefinedName(this.Army.Empire.Index, this.Army.GUID, this.ArmyNameLabel.Text.Trim());
IPlayerControllerRepositoryService service = this.parent.Game.Services.GetService <IPlayerControllerRepositoryService>();
Diagnostics.Assert(service != null);
service.ActivePlayerController.PostOrder(order);
}
else
{
this.ArmyNameLabel.Text = this.Army.LocalizedName;
}
}
public GuiNotificationEncounter()
{
base.Priority = Amplitude.Unity.Gui.GuiNotification.GuiNotificationPriority.Urgent;
this.autoshow = Services.GetService <IGuiNotificationSettingsService>().AutoPopupNotificationEncounter;
base.GuiNotificationPanelType = typeof(NotificationPanelEncounterSetup);
this.guiElementName = EventEncounterStateChange.Name;
this.Encounter = null;
this.EncounterGUID = GameEntityGUID.Zero;
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null && service.Game != null);
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
Diagnostics.Assert(service2 != null);
this.activePlayerController = service2.ActivePlayerController;
Diagnostics.Assert(this.activePlayerController != null && this.activePlayerController.Empire != null);
this.notificationItem = null;
}
private void SpawnCity()
{
IGameService service = Services.GetService <IGameService>();
if (service.Game == null)
{
return;
}
if (WorldCursor.HighlightedWorldPosition.IsValid)
{
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
OrderCreateCity orderCreateCity = new OrderCreateCity(service2.ActivePlayerController.Empire.Index, WorldCursor.HighlightedWorldPosition);
service2.ActivePlayerController.PostOrder(orderCreateCity);
Diagnostics.Log("Posting order: {0}.", new object[]
{
orderCreateCity.ToString()
});
}
}
protected override IEnumerator OnShow(params object[] parameters)
{
IPropertyEffectFeatureProvider propertyEffectFeatureProvider = this.context as IPropertyEffectFeatureProvider;
if (this.context is OrbCostTooltipData)
{
propertyEffectFeatureProvider = (this.context as OrbCostTooltipData).Context;
this.Value.Text = string.Empty;
}
if (propertyEffectFeatureProvider != null)
{
SimulationObject simulationObject = propertyEffectFeatureProvider.GetSimulationObject();
float propertyValue = simulationObject.GetPropertyValue("NumberOfPastWinters");
float num = simulationObject.GetPropertyValue("PrayerCostByTurnsSinceSeasonStart") * simulationObject.GetPropertyValue("NumberOfTurnsSinceSummerStart");
List <EffectDescription> list = new List <EffectDescription>();
if (propertyValue > 0f)
{
string toStringOverride = AgeLocalizer.Instance.LocalizeString("%FeatureOrbCostFromPastWinters").Replace("$Value", propertyValue.ToString());
list.Add(new EffectDescription(toStringOverride));
}
if (num > 0f)
{
string toStringOverride2 = AgeLocalizer.Instance.LocalizeString("%FeatureOrbCostFromTurns").Replace("$Value", num.ToString());
list.Add(new EffectDescription(toStringOverride2));
}
this.EffectMapper.LoadEffects(list, true);
float num2 = 0f;
IGameService service = Services.GetService <IGameService>();
if (service != null)
{
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
ISeasonService service3 = service.Game.Services.GetService <ISeasonService>();
if (service3 != null && service2 != null)
{
num2 = service3.ComputePrayerOrbCost(service2.ActivePlayerController.Empire as global::Empire);
}
}
this.Value.Text = num2.ToString() + base.GuiService.FormatSymbol(DepartmentOfTheTreasury.Resources.Orb);
}
yield return(base.OnShow(parameters));
yield break;
}
protected override IEnumerator OnShow(params object[] parameters)
{
IPlayerControllerRepositoryService playerControllerRepositoryService = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.ResetPropertyValues();
WorldPosition worldPosition = (WorldPosition)this.context;
this.stringBuilder.Length = 0;
if (worldPosition.IsValid)
{
World world = ((global::Game)base.GameService.Game).World;
WorldCircle worldCircle = new WorldCircle(worldPosition, 1);
WorldPosition[] worldPositions = worldCircle.GetWorldPositions(this.worldPositionningService.World.WorldParameters);
List <WorldPosition> filteredPositions = new List <WorldPosition>(worldPositions);
for (int positionIndex = filteredPositions.Count - 1; positionIndex >= 0; positionIndex--)
{
TerrainTypeMapping terrainTypeMapping = null;
if (!world.TryGetTerraformMapping(worldPositions[positionIndex], out terrainTypeMapping))
{
filteredPositions.RemoveAt(positionIndex);
}
}
for (int index = 0; index < filteredPositions.Count; index++)
{
this.FillWorldPositionEffects(playerControllerRepositoryService.ActivePlayerController.Empire, filteredPositions[index], false);
}
this.FillOutputString(ref this.stringBuilder);
this.OldResult.Text = this.stringBuilder.ToString();
this.ResetPropertyValues();
this.stringBuilder.Length = 0;
for (int index2 = 0; index2 < filteredPositions.Count; index2++)
{
this.FillWorldPositionEffects(playerControllerRepositoryService.ActivePlayerController.Empire, filteredPositions[index2], true);
}
this.FillOutputString(ref this.stringBuilder);
this.NewResult.Text = this.stringBuilder.ToString();
this.OldResultNotAffected.Visible = (filteredPositions.Count == 0);
this.NewResultNotAffected.Visible = (filteredPositions.Count == 0);
}
yield return(base.OnShow(parameters));
yield break;
}
public void Bind(IPlayerControllerRepositoryService playerControllerRepositoryService, Army army, ArmyAction armyAction, AgeTransform anchor, GameObject client, int index, UnitListPanel unitListPanel)
{
IGameService service = Services.GetService <IGameService>();
if (service == null || service.Game == null || this.PlayerControllerRepositoryService != null || this.Army != null || this.ArmyAction != null || this.SeasonService != null)
{
this.Unbind();
}
this.unitListPanel = unitListPanel;
this.SeasonService = service.Game.Services.GetService <ISeasonService>();
if (this.SeasonService != null)
{
this.SeasonService.SeasonChange += this.SeasonService_SeasonChange;
}
this.CursorService = Services.GetService <ICursorService>();
this.PlayerControllerRepositoryService = playerControllerRepositoryService;
this.Army = army;
this.ArmyAction = armyAction;
this.Client = client;
this.ActionToggle.AgeTransform.Visible = (armyAction is IArmyActionWithToggle);
this.ActionButton.AgeTransform.Visible = !(armyAction is IArmyActionWithToggle);
this.ModifierSector.Reset();
this.ModifierSector.GetComponent <AgePrimitiveSector>().MaxAngle = 0f;
this.ActionImage.Image = null;
this.ModifierSector.Reset();
IGuiPanelHelper guiPanelHelper = Services.GetService <global::IGuiService>().GuiPanelHelper;
Diagnostics.Assert(guiPanelHelper != null, "Unable to access GuiPanelHelper");
GuiElement guiElement;
Texture2D image;
if (guiPanelHelper.TryGetGuiElement(armyAction.Name, out guiElement) && guiPanelHelper.TryGetTextureFromIcon(guiElement, global::GuiPanel.IconSize.Small, out image))
{
this.ActionImage.Image = image;
}
this.AgeTransform.AgeTooltip.Anchor = anchor;
if (this.ArmyAction is IArmyActionWithUnitSelection)
{
this.unitListPanel.SelectionChange += this.UnitListPanel_SelectionChange;
}
this.RefreshCanExecute();
}
private void ValidateHeroChoice(Unit hero)
{
IGameService service = Services.GetService <IGameService>();
IPlayerControllerRepositoryService service2 = service.Game.Services.GetService <IPlayerControllerRepositoryService>();
this.AgeTransform.Enable = false;
this.selectedHero = hero;
if (this.Army.IsPrivateers)
{
string message = string.Format(AgeLocalizer.Instance.LocalizeString("%ConfirmHeroAssignmentToPrivateers"), new object[0]);
MessagePanel.Instance.Show(message, string.Empty, MessagePanelButtons.YesNo, new MessagePanel.EventHandler(this.ConfirmAssignment), MessagePanelType.IMPORTANT, new MessagePanelButton[0]);
}
else
{
OrderChangeHeroAssignment order = new OrderChangeHeroAssignment(this.Army.Empire.Index, hero.GUID, this.Army.GUID);
Ticket ticket;
service2.ActivePlayerController.PostOrder(order, out ticket, new EventHandler <TicketRaisedEventArgs>(this.OnOrderResponse));
this.selectedHero = null;
}
}
protected override void ELCPSendServerMessage(int type, string command)
{
if (this.GameClient == null)
{
return;
}
type = Mathf.Clamp(type, 0, 4);
if (command.StartsWith("%"))
{
command = AgeLocalizer.Instance.LocalizeString(command);
}
ISteamService service = Services.GetService <ISteamService>();
IGameService service2 = Services.GetService <IGameService>();
string text = string.Empty;
if (service2 != null)
{
IPlayerControllerRepositoryService service3 = service2.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service3 != null)
{
global::PlayerController activePlayerController = service3.ActivePlayerController;
if (activePlayerController != null)
{
text = (activePlayerController.Empire as global::Empire).Color.GetAgeCompatibleColorCode(true);
if (service != null && service.IsSteamRunning)
{
text += Steamworks.SteamAPI.SteamFriends.GetFriendPersonaName(service.SteamUser.SteamID);
}
else
{
text += (activePlayerController.Empire as global::Empire).LocalizedName;
}
text += "#REVERT#: ";
text = AgeLocalizer.Instance.LocalizeString(text);
}
}
}
Message message = new GameClientChatMessage((ChatMessageType)type, text + command);
this.GameClient.SendMessageToServer(ref message);
}
private void EndTurnService_GameClientStateChange(object sender, GameClientStateChangeEventArgs e)
{
if (base.IsVisible && base.Game != null)
{
IPlayerControllerRepositoryService service = base.Game.Services.GetService <IPlayerControllerRepositoryService>();
if (service == null)
{
return;
}
bool flag = service.ActivePlayerController.CanSendOrders();
if (this.interactionsAllowed != flag)
{
this.interactionsAllowed = flag;
WorkersDragPanel guiPanel = base.GuiService.GetGuiPanel <WorkersDragPanel>();
if (!this.interactionsAllowed && guiPanel.DragInProgress && guiPanel.DragMoved)
{
guiPanel.CancelDrag();
}
base.NeedRefresh = true;
}
}
}
