private void Client_TurnBegin_CheckKaijuStatus()
{
if (this.Kaiju != null)
{
if (this.Kaiju.IsStunned())
{
if (this.Kaiju.NextTurnToRecoverFromStun > 0 && (this.gameService.Game as global::Game).Turn == this.Kaiju.NextTurnToRecoverFromStun)
{
this.Kaiju.ChangeToWildState();
}
}
else if (this.Kaiju.IsWild() && this.Kaiju.OnArmyMode())
{
global::PlayerController server = this.KaijuEmpire.PlayerControllers.Server;
if (server != null)
{
Region validKaijuRegion = KaijuCouncil.GetValidKaijuRegion();
if (validKaijuRegion == null)
{
Diagnostics.LogWarning("Unable to find suitable region");
return;
}
WorldPosition validKaijuPosition = KaijuCouncil.GetValidKaijuPosition(validKaijuRegion, false);
if (validKaijuPosition == WorldPosition.Zero)
{
Diagnostics.LogWarning("Unable to find suitable position in target region");
return;
}
OrderRelocateKaiju order = new OrderRelocateKaiju(this.Kaiju.GUID, validKaijuPosition);
server.PostOrder(order);
}
}
}
}
private void Client_TurnBegin_CheckIndustryThreshold()
{
if (this.kaijuSpawnTurn == -1 && !this.KaijuEmpire.HasSpawnedAnyKaiju)
{
float totalIndustrySpent = KaijuCouncil.GetTotalIndustrySpent();
float industryNeededToSpawn = this.GetIndustryNeededToSpawn();
Diagnostics.Log("[Kaiju] Total Industry Spent: [{0}]", new object[]
{
totalIndustrySpent
});
if (totalIndustrySpent >= industryNeededToSpawn)
{
this.kaijuSpawnTurn = (this.gameService.Game as global::Game).Turn + Amplitude.Unity.Runtime.Runtime.Registry.GetValue <int>(KaijuCouncil.TurnsToSpawnPath);
if (this.KaijuEmpire.GetPropertyValue(SimulationProperties.SpawnedKaijusGlobalCounter) <= 0f)
{
global::PlayerController server = this.KaijuEmpire.PlayerControllers.Server;
if (server != null)
{
OrderAnnounceFirstKaiju order = new OrderAnnounceFirstKaiju();
server.PostOrder(order);
}
}
}
}
}
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);
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
ArmyAction.FailureFlags.Clear();
Kaiju kaiju = null;
if (parameters != null && parameters.Length != 0)
{
if (parameters[0] is Kaiju)
{
kaiju = (parameters[0] as Kaiju);
}
else if (parameters[0] is KaijuGarrison)
{
kaiju = (parameters[0] as KaijuGarrison).Kaiju;
}
else if (parameters[0] is KaijuArmy)
{
kaiju = (parameters[0] as KaijuArmy).Kaiju;
}
}
if (kaiju != null)
{
OrderTameUnstunnedKaiju order = new OrderTameUnstunnedKaiju(army.Empire.Index, kaiju, army);
Diagnostics.Assert(playerController != null);
playerController.PostOrder(order, out ticket, ticketRaisedEventHandler);
}
}
private void KaijuLostEncounter(Kaiju kaiju, global::Empire stunner, bool setKaijuFree)
{
bool flag = Amplitude.Unity.Runtime.Runtime.Registry.GetValue <bool>("Gameplay/Kaiju/KaijuAutoTameBeforeLoseEncounter", true);
bool relocate = false;
if (setKaijuFree)
{
flag = false;
relocate = true;
}
global::PlayerController server = this.KaijuEmpire.PlayerControllers.Server;
if (kaiju.IsTamed())
{
MajorEmpire majorEmpire = kaiju.MajorEmpire;
if (server != null)
{
OrderUntameKaiju order = new OrderUntameKaiju(kaiju, relocate, stunner.Index, flag);
server.PostOrder(order);
}
}
else if (flag)
{
if (server != null)
{
OrderTameKaiju order2 = new OrderTameKaiju(stunner.Index, kaiju, null);
server.PostOrder(order2);
}
}
else
{
this.Kaiju.ChangeToStunState(stunner);
this.ResetRelocationETA();
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
if (army == null || playerController == null)
{
return;
}
TerraformDevice terraformDevice = null;
if (parameters != null && parameters.Length > 0 && parameters[0] is TerraformDevice)
{
terraformDevice = (parameters[0] as TerraformDevice);
}
List <StaticString> list = new List <StaticString>();
if (terraformDevice == null || !this.CanToggleOverDevice(army, terraformDevice, ref list))
{
return;
}
if (terraformDevice.DismantlingArmy == null)
{
if (army.IsDismantlingDevice)
{
OrderToggleDismantleDevice order = new OrderToggleDismantleDevice(army.Empire.Index, army.GUID, army.DismantlingDeviceTarget, false);
playerController.PostOrder(order, out ticket, ticketRaisedEventHandler);
}
OrderToggleDismantleDevice order2 = new OrderToggleDismantleDevice(army.Empire.Index, army.GUID, terraformDevice.GUID, true);
playerController.PostOrder(order2, out ticket, ticketRaisedEventHandler);
}
else if (terraformDevice.DismantlingArmy == army)
{
OrderToggleDismantleDevice order3 = new OrderToggleDismantleDevice(army.Empire.Index, army.GUID, terraformDevice.GUID, false);
playerController.PostOrder(order3, out ticket, ticketRaisedEventHandler);
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
List <GameEntityGUID> list = new List <GameEntityGUID>();
int num = 0;
PathfindingMovementCapacity pathfindingMovementCapacity = PathfindingMovementCapacity.None;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is Unit)
{
Unit unit = parameters[i] as Unit;
num += (int)unit.GetPropertyValue(SimulationProperties.UnitSlotCount);
list.Add(unit.GUID);
pathfindingMovementCapacity = unit.GenerateContext().MovementCapacities;
}
else
{
if (!(parameters[i] is IEnumerable <Unit>))
{
return;
}
foreach (Unit unit2 in (parameters[i] as IEnumerable <Unit>))
{
num += (int)unit2.GetPropertyValue(SimulationProperties.UnitSlotCount);
list.Add(unit2.GUID);
if (pathfindingMovementCapacity == PathfindingMovementCapacity.None)
{
pathfindingMovementCapacity = unit2.GenerateContext().MovementCapacities;
}
else
{
pathfindingMovementCapacity &= unit2.GenerateContext().MovementCapacities;
}
}
}
}
IGameService service = Services.GetService <IGameService>();
IWorldPositionningService service2 = service.Game.Services.GetService <IWorldPositionningService>();
IPathfindingService service3 = service.Game.Services.GetService <IPathfindingService>();
bool flag = false;
bool flag2 = false;
if (this.CanTransferTo(army, army.WorldPosition, ref flag, ref flag2, service2, num) && this.TransferTo(army, army.WorldPosition, list, service2, playerController, out ticket, ticketRaisedEventHandler))
{
return;
}
for (int j = 0; j < 6; j++)
{
WorldPosition neighbourTile = service2.GetNeighbourTile(army.WorldPosition, (WorldOrientation)j, 1);
if (service3.IsTilePassable(neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0) && service3.IsTransitionPassable(army.WorldPosition, neighbourTile, pathfindingMovementCapacity, (PathfindingFlags)0))
{
if (this.CanTransferTo(army, neighbourTile, ref flag, ref flag2, service2, num) && this.TransferTo(army, neighbourTile, list, service2, playerController, out ticket, ticketRaisedEventHandler))
{
return;
}
}
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
ArmyAction.FailureFlags.Clear();
if (this is IArmyActionWithTargetSelection)
{
PointOfInterest pointOfInterest = null;
if (parameters != null && parameters.Length != 0 && parameters[0] is PointOfInterest)
{
pointOfInterest = (parameters[0] as PointOfInterest);
}
if (pointOfInterest != null)
{
OrderDestroyPointOfInterestImprovement orderDestroyPointOfInterestImprovement = new OrderDestroyPointOfInterestImprovement(army.Empire.Index, pointOfInterest.GUID);
orderDestroyPointOfInterestImprovement.ArmyGUID = army.GUID;
orderDestroyPointOfInterestImprovement.ArmyActionName = this.Name;
orderDestroyPointOfInterestImprovement.NumberOfActionPointsToSpend = base.GetCostInActionPoints();
orderDestroyPointOfInterestImprovement.ArmyActionCooldownDuration = base.ComputeCooldownDuration(army);
Diagnostics.Assert(playerController != null);
playerController.PostOrder(orderDestroyPointOfInterestImprovement, out ticket, ticketRaisedEventHandler);
return;
}
}
else
{
this.ListNearbyPointsOfInterest(army);
this.FilterPointsOfInterest(army, ref ArmyAction.FailureFlags);
if (ArmyAction.FailureFlags.Count == 0 && this.PointsOfInterest.Count > 0)
{
GameEntityGUID[] array = (from enumerator in this.PointsOfInterest
where enumerator.PointOfInterestImprovement != null && enumerator.CreepingNodeGUID == GameEntityGUID.Zero
select enumerator.GUID).ToArray <GameEntityGUID>();
GameEntityGUID[] array2 = (from enumerator in this.PointsOfInterest
where enumerator.CreepingNodeGUID != GameEntityGUID.Zero
select enumerator.CreepingNodeGUID).ToArray <GameEntityGUID>();
for (int i = 0; i < array2.Length; i++)
{
StaticString armyActionName = new StaticString();
if (i == 0 && array.Length == 0)
{
armyActionName = this.Name;
}
OrderDismantleCreepingNodeSucceed order = new OrderDismantleCreepingNodeSucceed(army.Empire.Index, army.GUID, array2[i], armyActionName);
playerController.PostOrder(order);
}
if (array.Length != 0)
{
OrderDestroyPointOfInterestImprovement orderDestroyPointOfInterestImprovement2 = new OrderDestroyPointOfInterestImprovement(army.Empire.Index, array);
orderDestroyPointOfInterestImprovement2.ArmyGUID = army.GUID;
orderDestroyPointOfInterestImprovement2.ArmyActionName = this.Name;
orderDestroyPointOfInterestImprovement2.NumberOfActionPointsToSpend = base.GetCostInActionPoints();
orderDestroyPointOfInterestImprovement2.ArmyActionCooldownDuration = base.ComputeCooldownDuration(army);
Diagnostics.Assert(playerController != null);
playerController.PostOrder(orderDestroyPointOfInterestImprovement2, out ticket, ticketRaisedEventHandler);
}
}
}
}
private void Client_TurnBegin_CheckKaijuSpawn()
{
if ((this.gameService.Game as global::Game).Turn >= this.kaijuSpawnTurn && this.kaijuSpawnTurn > 0 && ((this.gameService.Game as global::Game).Turn - this.kaijuSpawnTurn) % 10 == 0 && !this.KaijuEmpire.HasSpawnedAnyKaiju)
{
global::PlayerController server = this.KaijuEmpire.PlayerControllers.Server;
if (server != null)
{
OrderSpawnKaiju order = new OrderSpawnKaiju(this.KaijuEmpire.Index);
server.PostOrder(order);
}
}
}
public void ServerUntameAllKaijus()
{
global::PlayerController server = base.PlayerControllers.Server;
if (server == null)
{
return;
}
for (int i = this.TamedKaijus.Count - 1; i >= 0; i--)
{
OrderUntameKaiju order = new OrderUntameKaiju(this.TamedKaijus[i], true);
server.PostOrder(order);
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
ArmyAction.FailureFlags.Clear();
if (army is KaijuArmy)
{
KaijuArmy kaijuArmy = army as KaijuArmy;
if (kaijuArmy != null)
{
OrderKaijuChangeMode order = new OrderKaijuChangeMode(kaijuArmy.Kaiju, true, false, true);
Diagnostics.Assert(playerController != null);
playerController.PostOrder(order, out ticket, ticketRaisedEventHandler);
}
}
}
static StackObject *Destroy_9(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
global::PlayerController instance_of_this_method = (global::PlayerController)typeof(global::PlayerController).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
instance_of_this_method.Destroy();
return(__ret);
}
static StackObject *get_ReplicationPlayer_2(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
global::PlayerController instance_of_this_method = (global::PlayerController)typeof(global::PlayerController).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.ReplicationPlayer;
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
if (army == null || playerController == null)
{
return;
}
CreepingNode creepingNode = null;
if (parameters != null && parameters.Length > 0)
{
if (parameters[0] is CreepingNode)
{
creepingNode = (parameters[0] as CreepingNode);
}
if (parameters[0] is Village)
{
PointOfInterest pointOfInterest = (parameters[0] as Village).PointOfInterest;
creepingNode = this.GetCreepingNodeFromPOI(pointOfInterest);
}
else if (parameters[0] is PointOfInterest)
{
PointOfInterest pointOfInterest = parameters[0] as PointOfInterest;
creepingNode = this.GetCreepingNodeFromPOI(pointOfInterest);
}
}
List <StaticString> list = new List <StaticString>();
if (creepingNode == null || !this.CanToggleOverCreepingNode(army, creepingNode, ref list))
{
return;
}
if (creepingNode.DismantlingArmy == null)
{
if (army.IsDismantlingCreepingNode)
{
OrderToggleDismantleCreepingNode order = new OrderToggleDismantleCreepingNode(army.Empire.Index, army.GUID, army.DismantlingCreepingNodeTarget, false);
playerController.PostOrder(order, out ticket, ticketRaisedEventHandler);
}
OrderToggleDismantleCreepingNode order2 = new OrderToggleDismantleCreepingNode(army.Empire.Index, army.GUID, creepingNode.GUID, true);
playerController.PostOrder(order2, out ticket, ticketRaisedEventHandler);
}
else if (creepingNode.DismantlingArmy == army)
{
OrderToggleDismantleCreepingNode order3 = new OrderToggleDismantleCreepingNode(army.Empire.Index, army.GUID, creepingNode.GUID, false);
playerController.PostOrder(order3, out ticket, ticketRaisedEventHandler);
}
}
static StackObject *get_playerUid_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
global::PlayerController instance_of_this_method = (global::PlayerController)typeof(global::PlayerController).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.playerUid;
__ret->ObjectType = ObjectTypes.Long;
*(long *)&__ret->Value = result_of_this_method;
return(__ret + 1);
}
static StackObject *set_playerUid_7(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Int64 @value = *(long *)&ptr_of_this_method->Value;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
global::PlayerController instance_of_this_method = (global::PlayerController)typeof(global::PlayerController).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
instance_of_this_method.playerUid = value;
return(__ret);
}
static StackObject *set_ReplicationPlayer_1(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
EB.Sparx.Player @value = (EB.Sparx.Player) typeof(EB.Sparx.Player).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
global::PlayerController instance_of_this_method = (global::PlayerController)typeof(global::PlayerController).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
instance_of_this_method.ReplicationPlayer = value;
return(__ret);
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
if (parameters.Length != 0)
{
City city = parameters[0] as City;
if (city != null)
{
Diagnostics.Log("Teleporting to {0}", new object[]
{
city.Name
});
OrderTeleportArmyToCity orderTeleportArmyToCity = new OrderTeleportArmyToCity(army.Empire.Index, army.GUID, city.GUID);
orderTeleportArmyToCity.ArmyActionCooldownDuration = base.ComputeCooldownDuration(army);
Diagnostics.Assert(playerController != null);
playerController.PostOrder(orderTeleportArmyToCity, out ticket, ticketRaisedEventHandler);
return;
}
Army army2 = parameters[0] as Army;
if (army2 != null)
{
GameEntityGUID[] array = parameters[1] as GameEntityGUID[];
if (array != null)
{
Diagnostics.Log("Transferring units to {0} by teleport.", new object[]
{
army2.Name
});
OrderTransferUnits order = new OrderTransferUnits(army.Empire.Index, army.GUID, army2.GUID, array, true);
Diagnostics.Assert(playerController != null);
playerController.PostOrder(order, out ticket, ticketRaisedEventHandler);
IEventService service = Services.GetService <IEventService>();
if (service != null)
{
EventUnitsTeleported eventToNotify = new EventUnitsTeleported(army.Empire, array.Length);
service.Notify(eventToNotify);
}
return;
}
}
}
}
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);
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
IGameEntity gameEntity = null;
ArmyAction.FailureFlags.Clear();
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i] is IGameEntity)
{
gameEntity = (parameters[i] as IGameEntity);
break;
}
if (parameters[i] is List <IGameEntity> )
{
List <IGameEntity> list = parameters[i] as List <IGameEntity>;
bool flag = false;
for (int j = 0; j < list.Count; j++)
{
if (this.CanAttackGameEntity(army, list[j], ref flag, ref ArmyAction.FailureFlags))
{
gameEntity = list[j];
break;
}
}
break;
}
}
if (gameEntity != null)
{
DepartmentOfForeignAffairs agency = army.Empire.GetAgency <DepartmentOfForeignAffairs>();
Diagnostics.Assert(agency != null);
if (agency.CanAttack(gameEntity) || army.IsPrivateers)
{
OrderAttack orderAttack = new OrderAttack(army.Empire.Index, army.GUID, gameEntity.GUID);
orderAttack.NumberOfActionPointsToSpend = base.GetCostInActionPoints();
Diagnostics.Assert(playerController != null);
playerController.PostOrder(orderAttack, out ticket, ticketRaisedEventHandler);
}
}
}
private void Client_TurnBegin_SpawnLiceUnit()
{
int turn = (this.GameService.Game as global::Game).Turn;
int maxEraNumber = DepartmentOfScience.GetMaxEraNumber();
if (this.CanSpawnMilitiaUnit() && this.NextTurnToSpawnUnit > 0 && this.NextTurnToSpawnUnit == turn)
{
GameEntityGUID guid = this.KaijuGarrison.GUID;
StaticString name = this.KaijuEmpire.FindLiceDesign(true).Name;
if (this.OnArmyMode() && this.KaijuArmy != null)
{
guid = this.KaijuArmy.GUID;
}
global::PlayerController server = this.Empire.PlayerControllers.Server;
if (server != null)
{
OrderSpawnUnit order = new OrderSpawnUnit(this.Empire.Index, maxEraNumber, false, name, guid, false);
server.PostOrder(order);
}
this.ComputeNextTurnToSpawnUnits(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);
}
ArmyAction.FailureFlags.Clear();
if (pointOfInterest != null)
{
OrderInteractWith orderInteractWith = new OrderInteractWith(army.Empire.Index, army.GUID, this.Name);
orderInteractWith.WorldPosition = army.WorldPosition;
orderInteractWith.Tags.AddTag("Interact");
orderInteractWith.TargetGUID = pointOfInterest.GUID;
orderInteractWith.ArmyActionName = this.Name;
orderInteractWith.NumberOfActionPointsToSpend = base.GetCostInActionPoints();
Diagnostics.Assert(playerController != null);
playerController.PostOrder(orderInteractWith, out ticket, ticketRaisedEventHandler);
}
}
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"
});
}
}
private void UpdatePillageServerSide(PointOfInterest pointOfInterest)
{
float propertyValue = pointOfInterest.GetPropertyValue(SimulationProperties.PillageDefense);
if (propertyValue <= 0f && !pointOfInterest.SimulationObject.Tags.Contains(DepartmentOfDefense.PillageStatusDescriptor))
{
IGameEntity gameEntity = null;
if (this.GameEntityRepositoryService.TryGetValue(pointOfInterest.ArmyPillaging, out gameEntity))
{
Army army = gameEntity as Army;
if (army != null)
{
OrderPillageSucceed orderPillageSucceed = new OrderPillageSucceed(army.Empire.Index, army.GUID, pointOfInterest.GUID);
orderPillageSucceed.ArmyActionName = "ArmyActionPillage";
IPlayerControllerRepositoryControl playerControllerRepositoryControl = this.PlayerControllerRepositoryService as IPlayerControllerRepositoryControl;
if (playerControllerRepositoryControl != null)
{
global::PlayerController playerControllerById = playerControllerRepositoryControl.GetPlayerControllerById("server");
playerControllerById.PostOrder(orderPillageSucceed);
}
}
}
}
}
public void ExecuteCommands(BoosterEffect effect)
{
if (effect.Commands == null || effect.Commands.Length == 0)
{
return;
}
global::PlayerController server = this.empire.PlayerControllers.Server;
if (server == null)
{
return;
}
for (int i = 0; i < effect.Commands.Length; i++)
{
BoosterEffect.Command command = effect.Commands[i];
if (command != null && !string.IsNullOrEmpty(command.Name))
{
List <StaticString> list = new List <StaticString>();
for (int j = 0; j < command.Arguments.Length; j++)
{
list.Add(command.Arguments[j]);
}
string name = command.Name;
if (name != null)
{
if (Booster.< > f__switch$map12 == null)
{
Booster.< > f__switch$map12 = new Dictionary <string, int>(1)
{
{
"CreateUnit",
0
}
};
}
int num;
if (Booster.< > f__switch$map12.TryGetValue(name, out num))
{
if (num == 0)
{
for (int k = 0; k < list.Count; k++)
{
OrderSpawnUnit order = new OrderSpawnUnit(this.empire.Index, 0, true, list[k], this.TargetGUID, command.AllowGarrisonOverflow);
server.PostOrder(order);
if (effect.SimulationDescriptorReferences.Any((SimulationDescriptorReference descriptor) => descriptor.Name == AchievementManager.BattlebornDesignName))
{
IEventService service = Services.GetService <IEventService>();
if (service != null)
{
EventBattlebornCreated eventToNotify = new EventBattlebornCreated(this.empire);
service.Notify(eventToNotify);
}
}
}
goto IL_1A6;
}
}
}
Diagnostics.LogWarning("No process defined for command '{0}'", new object[]
{
command.Name
});
}
IL_1A6 :;
}
}
private bool TransferTo(Army army, WorldPosition worldPosition, List <GameEntityGUID> units, IWorldPositionningService worldPositionningService, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler)
{
Region region = worldPositionningService.GetRegion(worldPosition);
GameEntityGUID gameEntityGUID = GameEntityGUID.Zero;
ticket = null;
if (region.MinorEmpire != null)
{
BarbarianCouncil agency = region.MinorEmpire.GetAgency <BarbarianCouncil>();
if (agency != null)
{
Village villageAt = agency.GetVillageAt(worldPosition);
if (villageAt != null)
{
gameEntityGUID = villageAt.GUID;
}
}
}
if (region.City != null && region.City.Camp != null && gameEntityGUID == GameEntityGUID.Zero && region.City.Camp.WorldPosition == worldPosition)
{
gameEntityGUID = region.City.Camp.GUID;
}
if (region.City != null && gameEntityGUID == GameEntityGUID.Zero)
{
gameEntityGUID = region.City.GUID;
}
if (region.Kaiju != null && region.Kaiju.KaijuGarrison != null && gameEntityGUID == GameEntityGUID.Zero && DepartmentOfScience.IsTechnologyResearched(army.Empire, "TechnologyDefinitionMimics1") && region.Kaiju.KaijuGarrison.WorldPosition == worldPosition)
{
gameEntityGUID = region.Kaiju.KaijuGarrison.GUID;
}
if (gameEntityGUID != GameEntityGUID.Zero)
{
OrderTransferUnits order = new OrderTransferUnits(army.Empire.Index, army.GUID, gameEntityGUID, units.ToArray(), false);
playerController.PostOrder(order, out ticket, ticketRaisedEventHandler);
return(true);
}
return(false);
}
void IDiplomaticTermManagement.ApplyEffects()
{
DiplomaticTermCityExchangeDefinition diplomaticTermCityExchangeDefinition = base.Definition as DiplomaticTermCityExchangeDefinition;
Diagnostics.Assert(diplomaticTermCityExchangeDefinition != null);
Diagnostics.Assert(base.EmpireWhichProvides != null && base.EmpireWhichReceives != null);
DepartmentOfTheInterior agency = base.EmpireWhichProvides.GetAgency <DepartmentOfTheInterior>();
DepartmentOfTheInterior agency2 = base.EmpireWhichReceives.GetAgency <DepartmentOfTheInterior>();
Diagnostics.Assert(agency != null && agency2 != null);
City city = null;
for (int i = 0; i < agency.Cities.Count; i++)
{
City city2 = agency.Cities[i];
if (city2.GUID == this.CityGUID)
{
city = city2;
break;
}
}
if (city == null)
{
Diagnostics.LogError("DiplomaticTermCityExchange.ApplyEffect failed, can't retrieve the city {0} from the empire which provides the term ({1}).", new object[]
{
this.CityGUID,
base.EmpireWhichProvides
});
return;
}
IEventService service = Services.GetService <IEventService>();
if (service == null)
{
Diagnostics.LogError("Failed to retrieve the event service.");
return;
}
bool flag = base.EmpireWhichReceives.SimulationObject.Tags.Contains("FactionTraitCultists9");
bool flag2 = agency2.Cities.Count >= 1;
if (flag && flag2)
{
IGameService service2 = Services.GetService <IGameService>();
IPlayerControllerRepositoryService service3 = service2.Game.Services.GetService <IPlayerControllerRepositoryService>();
IPlayerControllerRepositoryControl playerControllerRepositoryControl = service3 as IPlayerControllerRepositoryControl;
if (playerControllerRepositoryControl != null)
{
global::PlayerController playerControllerById = playerControllerRepositoryControl.GetPlayerControllerById("server");
if (playerControllerById != null)
{
float propertyValue = city.GetPropertyValue(SimulationProperties.Population);
DepartmentOfScience agency3 = base.EmpireWhichReceives.GetAgency <DepartmentOfScience>();
bool flag3 = agency3 != null && agency3.GetTechnologyState("TechnologyDefinitionCultists12") == DepartmentOfScience.ConstructibleElement.State.Researched;
int num = 0;
while ((float)num < propertyValue)
{
OrderBuyoutAndActivateBooster order = new OrderBuyoutAndActivateBooster(base.EmpireWhichReceives.Index, "BoosterIndustry", 0UL, false);
playerControllerById.PostOrder(order);
if (flag3)
{
order = new OrderBuyoutAndActivateBooster(base.EmpireWhichReceives.Index, "BoosterScience", 0UL, false);
playerControllerById.PostOrder(order);
}
num++;
}
OrderDestroyCity order2 = new OrderDestroyCity(city.Empire.Index, city.GUID, true, true, base.EmpireWhichReceives.Index);
playerControllerById.PostOrder(order2);
EventCityRazed eventToNotify = new EventCityRazed(city.Empire, city.Region, base.EmpireWhichReceives, false);
service.Notify(eventToNotify);
}
}
}
else
{
agency.SwapCityOwner(city, base.EmpireWhichReceives);
service.Notify(new EventSwapCity(base.EmpireWhichProvides, city, base.EmpireWhichProvides.Index, base.EmpireWhichReceives.Index, false));
service.Notify(new EventSwapCity(base.EmpireWhichReceives, city, base.EmpireWhichProvides.Index, base.EmpireWhichReceives.Index, false));
}
}
public override void Execute(Army army, global::PlayerController playerController, out Ticket ticket, EventHandler <TicketRaisedEventArgs> ticketRaisedEventHandler, params object[] parameters)
{
ticket = null;
}
public override void Begin(params object[] parameters)
{
base.Begin(parameters);
bool canceled = false;
if (parameters.Length >= 1 && parameters[0] is bool)
{
canceled = (bool)parameters[0];
}
global::PlayerController playerController = base.BattleEncounter.PlayerController;
if (playerController != null)
{
OrderLockEncounterExternalArmies order = new OrderLockEncounterExternalArmies(base.BattleEncounter.EncounterGUID, base.BattleEncounter.ExternalArmies, false);
playerController.PostOrder(order);
for (int i = 0; i < base.BattleEncounter.BattleContenders.Count; i++)
{
BattleContender battleContender = base.BattleEncounter.BattleContenders[i];
if (battleContender.DeadParasitesCount > 0)
{
BattleContender enemyContenderWithAbilityFromContender = base.BattleEncounter.GetEnemyContenderWithAbilityFromContender(battleContender, UnitAbility.ReadonlyParasite);
if (enemyContenderWithAbilityFromContender != null)
{
enemyContenderWithAbilityFromContender.UndeadUnitsToCreateCount += battleContender.DeadParasitesCount;
}
}
}
for (int j = 0; j < base.BattleEncounter.BattleContenders.Count; j++)
{
BattleContender battleContender2 = base.BattleEncounter.BattleContenders[j];
if (battleContender2.Garrison != null && battleContender2.UndeadUnitsToCreateCount > 0)
{
OrderCreateUndeadUnits order2 = new OrderCreateUndeadUnits(battleContender2.Garrison.Empire.Index, battleContender2.UndeadUnitsToCreateCount, battleContender2.Garrison.GUID, base.BattleEncounter.EncounterGUID);
playerController.PostOrder(order2);
}
}
OrderEndEncounter orderEndEncounter = new OrderEndEncounter(base.BattleEncounter.EncounterGUID, canceled);
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
if (ELCPUtilities.UseELCPFortificationPointRuleset)
{
Diagnostics.Assert(service != null);
IEncounterRepositoryService service2 = service.Game.Services.GetService <IEncounterRepositoryService>();
Diagnostics.Assert(service2 != null);
Encounter encounter = null;
if (service2.TryGetValue(base.BattleEncounter.EncounterGUID, out encounter))
{
List <ulong> list = new List <ulong>();
foreach (Contender contender in encounter.Contenders)
{
if (contender.IsTakingPartInBattle)
{
foreach (EncounterUnit encounterUnit in contender.EncounterUnits)
{
if (encounterUnit.IsOnBattlefield)
{
list.Add(encounterUnit.Unit.GUID);
}
}
}
}
orderEndEncounter.GUIDsOnBattlefield = list.ToArray();
}
}
if (base.BattleEncounter is BattleCityAssaultEncounter)
{
orderEndEncounter.DoNotSubtractActionPoints = (base.BattleEncounter as BattleCityAssaultEncounter).IsCityRipeForTheTaking;
}
playerController.PostOrder(orderEndEncounter);
if (base.BattleEncounter is BattleCityAssaultEncounter && base.BattleEncounter.BattleContenders.Count >= 1)
{
BattleCityAssaultEncounter battleCityAssaultEncounter = base.BattleEncounter as BattleCityAssaultEncounter;
IGameEntityRepositoryService service3 = service.Game.Services.GetService <IGameEntityRepositoryService>();
Diagnostics.Assert(service3 != null);
IGameEntity gameEntity = null;
City city = null;
if (service3.TryGetValue(battleCityAssaultEncounter.CityGuid, out gameEntity) && gameEntity is City)
{
city = (gameEntity as City);
}
bool flag = false;
bool flag2 = false;
for (int k = 0; k < base.BattleEncounter.BattleContenders.Count; k++)
{
BattleContender battleContender3 = base.BattleEncounter.BattleContenders[k];
if (battleContender3.IsTakingPartInBattle && !battleContender3.IsDead)
{
if (battleContender3.Garrison.Empire == city.Empire)
{
flag = true;
}
else
{
flag2 = true;
}
}
else if (!battleContender3.IsTakingPartInBattle && battleContender3.Garrison.GUID == city.GUID && battleContender3.Garrison.UnitsCount > 0)
{
flag = true;
}
}
flag |= !flag2;
OrderCityEncounterEnd order3 = new OrderCityEncounterEnd(base.BattleEncounter.BattleContenders[0].Garrison.Empire.Index, base.BattleEncounter.BattleContenders[0].Garrison.GUID, battleCityAssaultEncounter.CityGuid, flag);
playerController.PostOrder(order3);
}
}
}
protected override State Execute(QuestBehaviour questBehaviour, params object[] parameters)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
Diagnostics.Assert(service.Game != null);
global::Empire initiator = questBehaviour.Initiator;
Diagnostics.Assert(initiator.SimulationObject != null);
if (!initiator.SimulationObject.Tags.Contains(global::Empire.TagEmpireEliminated))
{
if (initiator.GetAgency <DepartmentOfDefense>() != null)
{
IEncounterRepositoryService service2 = service.Game.Services.GetService <IEncounterRepositoryService>();
if (service2 != null)
{
IEnumerable <Encounter> enumerable = service2;
if (enumerable != null)
{
List <Encounter> list = new List <Encounter>();
foreach (Encounter encounter in enumerable)
{
if (encounter != null)
{
for (int i = 0; i < encounter.Empires.Count; i++)
{
if (encounter.Empires[i].Index == initiator.Index && encounter.EncounterState != EncounterState.BattleHasEnded)
{
list.Add(encounter);
}
}
}
}
global::Empire.PlayerControllersContainer playerControllers = (initiator as MajorEmpire).PlayerControllers;
if (playerControllers != null && playerControllers.Server != null)
{
for (int j = 0; j < list.Count; j++)
{
Encounter encounter2 = list[j];
OrderEndEncounter order = new OrderEndEncounter(encounter2.GUID, true);
playerControllers.Server.PostOrder(order);
OrderDestroyEncounter order2 = new OrderDestroyEncounter(encounter2.GUID);
playerControllers.Server.PostOrder(order2);
}
}
}
}
}
SimulationDescriptor simulationDescriptor = null;
IDatabase <SimulationDescriptor> database = Databases.GetDatabase <SimulationDescriptor>(false);
if (database != null)
{
database.TryGetValue("EmpireEliminated", out simulationDescriptor);
}
if (simulationDescriptor != null)
{
initiator.AddDescriptor(simulationDescriptor, false);
initiator.Refresh(true);
}
else
{
initiator.SimulationObject.Tags.AddTag(global::Empire.TagEmpireEliminated);
}
}
ISessionService service3 = Services.GetService <ISessionService>();
Diagnostics.Assert(service3 != null && service3.Session != null);
if (service3.Session.IsHosting)
{
service3.Session.SetLobbyData(string.Format("Empire{0}Eliminated", initiator.Index), true, true);
}
IPlayerControllerRepositoryControl playerControllerRepositoryControl = service.Game.Services.GetService <IPlayerControllerRepositoryService>() as IPlayerControllerRepositoryControl;
if (playerControllerRepositoryControl != null)
{
global::PlayerController playerControllerById = playerControllerRepositoryControl.GetPlayerControllerById("server");
if (playerControllerById != null)
{
if (initiator is MajorEmpire)
{
MajorEmpire majorEmpire = initiator as MajorEmpire;
if (majorEmpire.TamedKaijus.Count > 0)
{
majorEmpire.ServerUntameAllKaijus();
}
}
OrderEliminateEmpire order3 = new OrderEliminateEmpire(questBehaviour.Initiator.Index);
playerControllerById.PostOrder(order3);
}
}
return(State.Success);
}
