public EatResponse OnEvent(EventId id, object cookie)
{
if (id == EventId.TroopPlacedOnBoard && base.IsEventValidForBattleObjective())
{
SmartEntity smartEntity = (SmartEntity)cookie;
TroopComponent troopComponent = smartEntity.Get <TroopComponent>();
TeamComponent teamComponent = smartEntity.Get <TeamComponent>();
if (teamComponent != null && teamComponent.TeamType == TeamType.Attacker && troopComponent != null && troopComponent.TroopType.TroopID == this.troopId)
{
this.parent.Progress(this, 1);
}
}
return(EatResponse.NotEaten);
}
private bool ShouldAttackAlternateTarget(ShooterComponent shooterComp, Entity alternateTarget)
{
if (alternateTarget == null)
{
return(false);
}
BuildingComponent buildingComponent = alternateTarget.Get <BuildingComponent>();
TransformComponent transformComponent = alternateTarget.Get <TransformComponent>();
if (buildingComponent == null || buildingComponent.BuildingType == null || transformComponent == null)
{
return(false);
}
if (buildingComponent.BuildingType.Type == BuildingType.Blocker)
{
return(false);
}
if (buildingComponent.BuildingType.Type != BuildingType.Wall)
{
return(true);
}
SmartEntity primaryTarget = this.GetPrimaryTarget(shooterComp);
return(primaryTarget != null && primaryTarget.Get <TransformComponent>() != null);
}
public bool TryCollectCurrencyOnSelection(SmartEntity entity)
{
if (!(Service.GameStateMachine.CurrentState is HomeState))
{
return(false);
}
if (Service.PostBattleRepairController.IsEntityInRepair(entity))
{
return(false);
}
if (ContractUtils.IsBuildingConstructing(entity) || ContractUtils.IsBuildingUpgrading(entity))
{
return(false);
}
if (!this.IsGeneratorThresholdMet(entity))
{
return(false);
}
if (!this.CanStoreCollectionAmountFromGenerator(entity))
{
BuildingComponent buildingComponent = entity.Get <BuildingComponent>();
CurrencyType currency = buildingComponent.BuildingType.Currency;
this.HandleUnableToCollect(currency);
return(false);
}
this.CollectCurrency(entity);
return(true);
}
public void StartClearingSelectedBuilding()
{
SmartEntity selectedBuilding = this.buildingSelector.SelectedBuilding;
BuildingTypeVO buildingType = selectedBuilding.Get <BuildingComponent>().BuildingType;
if (buildingType.Type == BuildingType.Clearable)
{
int credits = buildingType.Credits;
int materials = buildingType.Materials;
int contraband = buildingType.Contraband;
string value = StringUtils.ToLowerCaseUnderscoreSeperated(buildingType.Type.ToString());
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(value);
stringBuilder.Append("|");
stringBuilder.Append(buildingType.BuildingID);
stringBuilder.Append("|");
stringBuilder.Append(buildingType.SizeX * buildingType.SizeY);
if (PayMeScreen.ShowIfNotEnoughCurrency(credits, materials, contraband, stringBuilder.ToString(), new OnScreenModalResult(this.OnPayMeForCurrencyResult)))
{
return;
}
if (PayMeScreen.ShowIfNoFreeDroids(new OnScreenModalResult(this.OnPayMeForDroidResult), selectedBuilding))
{
return;
}
this.ConfirmClearingBuilding(selectedBuilding);
}
}
public bool IsPositionUnderShield(int boardX, int boardZ, SmartEntity shieldGenerator, out float distSq)
{
TransformComponent transformComponent = shieldGenerator.Get <TransformComponent>();
distSq = (float)GameUtils.SquaredDistance(boardX, boardZ, transformComponent.CenterGridX(), transformComponent.CenterGridZ());
return(distSq <= (float)shieldGenerator.ShieldGeneratorComp.RadiusSquared);
}
public BoardCell OnLowerLiftedBuilding(SmartEntity building, int x, int z, bool confirmPurchase, ref BuildingTypeVO stampBuilding, string tag)
{
BoardCell boardCell;
if (this.purchasingBuilding)
{
this.purchasingBuilding = false;
if (!confirmPurchase)
{
this.ResetStampLocations();
Service.EventManager.SendEvent(EventId.BuildingPurchaseCanceled, null);
return(null);
}
BuildingTypeVO buildingType = building.Get <BuildingComponent>().BuildingType;
int credits = buildingType.Credits;
int materials = buildingType.Materials;
int contraband = buildingType.Contraband;
GameUtils.SpendCurrency(credits, materials, contraband, false);
Service.EventManager.SendEvent(EventId.BuildingPurchaseConfirmed, null);
boardCell = Service.WorldController.AddBuildingHelper(building, x, z, false);
if (boardCell != null)
{
BuildingComponent buildingComponent = building.Get <BuildingComponent>();
Service.CurrentPlayer.Map.Buildings.Add(buildingComponent.BuildingTO);
if (this.purchasingStampable == 0)
{
Service.ISupportController.StartBuildingConstruct(buildingType, building, x, z, tag);
Service.EventManager.SendEvent(EventId.BuildingPurchaseSuccess, building);
}
else
{
Service.EventManager.SendEvent(EventId.BuildingPurchaseSuccess, building);
Service.ISupportController.InstantBuildingConstruct(buildingType, building, x, z, tag);
if (--this.purchasingStampable > 0)
{
stampBuilding = this.purchasingBuildingType;
this.SaveLastStampLocation(boardCell.X, boardCell.Z);
}
}
}
}
else
{
boardCell = Service.WorldController.MoveBuildingWithinBoard(building, x, z);
}
return(boardCell);
}
public void StashBuilding(SmartEntity buildingEntity, bool allowRevert)
{
BuildingComponent buildingComponent = buildingEntity.Get <BuildingComponent>();
if (buildingComponent.BuildingType.Type == BuildingType.Clearable)
{
Service.Logger.Warn("BLT: Can't stash clearable: " + buildingComponent.BuildingTO.Key + ":" + buildingComponent.BuildingTO.Uid);
return;
}
string uid = buildingComponent.BuildingTO.Uid;
if (this.stashedBuildingMap == null)
{
this.stashedBuildingMap = new Dictionary <string, List <SmartEntity> >();
}
if (!this.stashedBuildingMap.ContainsKey(uid))
{
this.stashedBuildingMap.Add(uid, new List <SmartEntity>());
}
List <SmartEntity> list = this.stashedBuildingMap[uid];
if (!list.Contains(buildingEntity))
{
list.Add(buildingEntity);
}
GameObjectViewComponent gameObjectViewComp = buildingEntity.GameObjectViewComp;
if (gameObjectViewComp != null)
{
TransformComponent transformComp = buildingEntity.TransformComp;
gameObjectViewComp.SetXYZ(Units.BoardToWorldX(transformComp.CenterX()), -1000f, Units.BoardToWorldZ(transformComp.CenterZ()));
}
if (buildingEntity.HealthViewComp != null)
{
HealthViewComponent healthViewComponent = buildingEntity.Get <HealthViewComponent>();
healthViewComponent.TeardownElements();
}
Service.EventManager.SendEvent(EventId.UserStashedBuilding, buildingEntity);
Service.BoardController.RemoveEntity(buildingEntity, true);
Service.EventManager.SendEvent(EventId.EntityDestroyed, buildingEntity.ID);
Service.EventManager.SendEvent(EventId.BuildingMovedOnBoard, buildingEntity);
Service.BuildingController.DisableUnstashStampingState();
if (allowRevert)
{
this.ShouldRevertMap = true;
}
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id == EventId.TroopPlacedOnBoard)
{
if (this.IsEventValidForGoal())
{
SmartEntity smartEntity = (SmartEntity)cookie;
TroopComponent troopComponent = smartEntity.Get <TroopComponent>();
TeamComponent teamComponent = smartEntity.Get <TeamComponent>();
SpawnComponent spawnComponent = smartEntity.Get <SpawnComponent>();
if (teamComponent != null && teamComponent.TeamType == TeamType.Attacker && troopComponent != null && troopComponent.TroopType.TroopID == this.troopId && (spawnComponent == null || !spawnComponent.IsSummoned()))
{
this.parent.Progress(this, 1);
}
}
}
return(EatResponse.NotEaten);
}
private void LiftSelectedBuilding(SmartEntity buildingInSelection, bool sendLiftedEvent, bool clearPreviousAnchorPos)
{
this.lifted = true;
if (buildingInSelection == this.buildingSelector.SelectedBuilding)
{
Service.UXController.HUD.ShowContextButtons(buildingInSelection);
}
Vector3 grabPoint = this.buildingSelector.GrabPoint;
BoardItemComponent boardItemComponent = buildingInSelection.Get <BoardItemComponent>();
if (boardItemComponent.BoardItem.Filter == CollisionFilters.BUILDING)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.BUILDING_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.TRAP)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.TRAP_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.WALL)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.WALL_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.BLOCKER)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.BLOCKER_GHOST;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.PLATFORM)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.PLATFORM_GHOST;
}
this.canOccupy = true;
if (clearPreviousAnchorPos)
{
this.ClearPreviousAnchors();
}
TransformComponent transformComp = this.buildingSelector.SelectedBuilding.TransformComp;
Vector3 worldGroundPosition = new Vector3(Units.BoardToWorldX(transformComp.X), 0f, Units.BoardToWorldZ(transformComp.Z));
if (sendLiftedEvent)
{
Service.EventManager.SendEvent(EventId.UserLiftedBuilding, buildingInSelection);
Service.EventManager.SendEvent(EventId.UserLiftedBuildingAudio, buildingInSelection);
}
float num;
float num2;
EditBaseController.BuildingBoardToWorld(this.buildingSelector.SelectedBuilding, 0, 0, out num, out num2);
worldGroundPosition.x += num + grabPoint.x;
worldGroundPosition.z += num2 + grabPoint.z;
this.MoveLiftedBuilding(buildingInSelection, worldGroundPosition);
Service.EntityViewManager.SetCollider(buildingInSelection, false);
this.buildingSelector.ApplySelectedEffect(buildingInSelection);
Service.BuildingTooltipController.HideBuildingTooltip(buildingInSelection);
}
public static void ShowModal(SmartEntity selectedBuilding, OnScreenModalResult onModalResult, object modalResultCookie)
{
Contract contract = Service.ISupportController.FindCurrentContract(selectedBuilding.Get <BuildingComponent>().BuildingTO.Key);
if (contract == null)
{
return;
}
FinishNowScreen screen = FinishNowScreen.CreateFinishNowScreen(selectedBuilding, contract, false, onModalResult, modalResultCookie);
Service.ScreenController.AddScreen(screen);
}
public WallUpgradeScreen(SmartEntity selectedBuilding) : base(selectedBuilding)
{
this.useUpgradeGroup = true;
this.currentWallLevel = this.buildingInfo.Lvl;
this.wallsOfSameLevel = new List <SmartEntity>();
string key = selectedBuilding.Get <BuildingComponent>().BuildingTO.Key;
NodeList <WallNode> wallNodeList = Service.BuildingLookupController.WallNodeList;
for (WallNode wallNode = wallNodeList.Head; wallNode != null; wallNode = wallNode.Next)
{
if (wallNode.BuildingComp.BuildingTO.Key != key && wallNode.BuildingComp.BuildingType.Lvl == this.currentWallLevel)
{
this.wallsOfSameLevel.Add((SmartEntity)wallNode.Entity);
}
}
this.allWallSameLevelCount = this.wallsOfSameLevel.Count + 1;
}
public static void AddTroopToStarportVisually(SmartEntity starport, TroopTypeVO troop)
{
if (starport != null && starport.BuildingComp != null && troop != null)
{
float num = StorageSpreadUtils.GetStarportFullnessPercent(starport);
int storage = starport.Get <BuildingComponent>().BuildingType.Storage;
num += (float)troop.Size / (float)storage;
if (num > 1f)
{
StorageSpreadUtils.UpdateAllStarportFullnessMeters();
}
else
{
StorageSpreadUtils.SetStarportFullnessPercent(starport, num);
}
}
}
private bool LowerLiftedBuildingHelper(SmartEntity buildingInSelection, DropKind dropKind, bool affectBoard, bool sendLoweredEvent, bool playLoweredSound, bool showContextButtons, string tag)
{
this.lifted = false;
this.moved = false;
BuildingTypeVO buildingTypeVO = null;
int num = 0;
int num2 = 0;
if ((this.canOccupy || dropKind != DropKind.JustDrop) && this.prevValidBoardAnchorX.ContainsKey(buildingInSelection) && this.prevValidBoardAnchorZ.ContainsKey(buildingInSelection))
{
num = this.prevValidBoardAnchorX[buildingInSelection];
num2 = this.prevValidBoardAnchorZ[buildingInSelection];
}
else if (this.prevValidBoardAnchorX.ContainsKey(buildingInSelection) && this.prevValidBoardAnchorZ.ContainsKey(buildingInSelection))
{
num = this.prevValidBoardAnchorX[buildingInSelection];
num2 = this.prevValidBoardAnchorZ[buildingInSelection];
}
else if (this.buildingSelector.AdditionalSelectedBuildings.Count == 0)
{
if (buildingInSelection != null)
{
Service.Logger.Warn("Something went wrong placing " + buildingInSelection.ToString() + " we should not be hitting this case where prevValidBoardAnchorX and prevValidBoardAnchorZ do not contain buildingInSelection");
}
else
{
Service.Logger.Warn("Something went wrong, we should not be hitting this case where prevValidBoardAnchorX and prevValidBoardAnchorZ do not contain buildingInSelection");
}
}
if (affectBoard)
{
BoardCell boardCell = this.buildingController.OnLowerLiftedBuilding(buildingInSelection, num, num2, dropKind == DropKind.ConfirmPurchase, ref buildingTypeVO, tag);
if (boardCell == null)
{
this.buildingSelector.DeselectSelectedBuilding();
Service.EventManager.SendEvent(EventId.UserLoweredBuilding, buildingInSelection);
this.DestroyBuilding(buildingInSelection);
return(false);
}
BoardItemComponent boardItemComponent = buildingInSelection.Get <BoardItemComponent>();
if (boardItemComponent.BoardItem.Filter == CollisionFilters.BUILDING_GHOST)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.BUILDING;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.TRAP_GHOST)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.TRAP;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.WALL_GHOST)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.WALL;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.BLOCKER_GHOST)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.BLOCKER;
}
else if (boardItemComponent.BoardItem.Filter == CollisionFilters.PLATFORM_GHOST)
{
boardItemComponent.BoardItem.Filter = CollisionFilters.PLATFORM;
}
else
{
Service.Logger.ErrorFormat("LowerLiftedBuilding : Unexpected filter type {0}", new object[]
{
boardItemComponent.BoardItem.Filter
});
boardItemComponent.BoardItem.Filter = CollisionFilters.BUILDING;
}
num = boardCell.X;
num2 = boardCell.Z;
}
else
{
float x;
float z;
EditBaseController.BuildingBoardToWorld(this.buildingSelector.SelectedBuilding, num, num2, out x, out z);
Vector3 worldGroundPosition = new Vector3(x, 0f, z);
worldGroundPosition.x += this.buildingSelector.GrabPoint.x;
worldGroundPosition.z += this.buildingSelector.GrabPoint.z;
this.MoveLiftedBuilding(this.buildingSelector.SelectedBuilding, worldGroundPosition);
}
GameObjectViewComponent gameObjectViewComponent = buildingInSelection.Get <GameObjectViewComponent>();
if (gameObjectViewComponent != null)
{
TransformComponent transformComponent = buildingInSelection.Get <TransformComponent>();
gameObjectViewComponent.SetXYZ(Units.BoardToWorldX(transformComponent.CenterX()), 0f, Units.BoardToWorldZ(transformComponent.CenterZ()));
}
Service.EntityViewManager.SetCollider(buildingInSelection, true);
if (sendLoweredEvent)
{
Service.EventManager.SendEvent(EventId.UserLoweredBuilding, buildingInSelection);
}
if (playLoweredSound)
{
Service.EventManager.SendEvent(EventId.UserLoweredBuildingAudio, buildingInSelection);
}
this.buildingSelector.ApplySelectedEffect(buildingInSelection);
if (buildingTypeVO != null)
{
this.buildingController.StartPurchaseBuilding(buildingTypeVO, -1);
}
else if (showContextButtons)
{
Service.UXController.HUD.ShowContextButtons(buildingInSelection);
}
Service.BuildingTooltipController.EnsureBuildingTooltip(buildingInSelection);
return(true);
}
private void LowerLiftedBuilding(DropKind dropKind, bool affectBoard, bool sendLoweredEvent, bool playLoweredSound, bool showContextButtons)
{
SmartEntity selectedBuilding = this.buildingSelector.SelectedBuilding;
if (selectedBuilding == null)
{
this.lifted = false;
this.moved = false;
return;
}
UXController uXController = Service.UXController;
if (dropKind != DropKind.JustDrop)
{
uXController.MiscElementsManager.HideConfirmGroup();
}
if (affectBoard && dropKind == DropKind.ConfirmPurchase)
{
BuildingTypeVO buildingType = selectedBuilding.BuildingComp.BuildingType;
int credits = buildingType.Credits;
int materials = buildingType.Materials;
int contraband = buildingType.Contraband;
string value = StringUtils.ToLowerCaseUnderscoreSeperated(buildingType.Type.ToString());
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(value);
stringBuilder.Append("|");
stringBuilder.Append(buildingType.BuildingID);
stringBuilder.Append("|");
stringBuilder.Append(buildingType.Lvl);
if (PayMeScreen.ShowIfNotEnoughCurrency(credits, materials, contraband, stringBuilder.ToString(), new OnScreenModalResult(this.OnPayMeForCurrencyResult)))
{
return;
}
if (buildingType.Type != BuildingType.DroidHut && PayMeScreen.ShowIfNoFreeDroids(new OnScreenModalResult(this.OnPayMeForDroidResult), null))
{
return;
}
if (buildingType.Type == BuildingType.NavigationCenter && buildingType.Lvl == 1)
{
Service.UXController.HUD.InitialNavigationCenterPlanetSelect(selectedBuilding, buildingType, new OnScreenModalResult(this.OnPickPlanetResult));
return;
}
}
BuildingTypeVO buildingType2 = selectedBuilding.Get <BuildingComponent>().BuildingType;
if (buildingType2.Time == 0 && dropKind != DropKind.JustDrop)
{
showContextButtons = false;
}
if (dropKind != DropKind.JustDrop)
{
uXController.HUD.ToggleExitEditModeButton(true);
}
this.canOccupy = this.EntireSelectionIsPlaceable();
if (!this.canOccupy)
{
this.LiftSelectedBuilding(selectedBuilding, false, false);
int i = 0;
int count = this.buildingSelector.AdditionalSelectedBuildings.Count;
while (i < count)
{
this.LiftSelectedBuilding(this.buildingSelector.AdditionalSelectedBuildings[i], false, false);
i++;
}
}
bool flag = !this.LowerLiftedBuildingHelper(selectedBuilding, dropKind, affectBoard, sendLoweredEvent, playLoweredSound, showContextButtons, string.Empty);
int j = 0;
int count2 = this.buildingSelector.AdditionalSelectedBuildings.Count;
while (j < count2)
{
this.LowerLiftedBuildingHelper(this.buildingSelector.AdditionalSelectedBuildings[j], dropKind, affectBoard, false, false, false, string.Empty);
j++;
}
if (sendLoweredEvent)
{
for (int k = 0; k < this.buildingSelector.AdditionalSelectedBuildings.Count; k++)
{
Service.EventManager.SendEvent(EventId.UserLoweredBuilding, this.buildingSelector.AdditionalSelectedBuildings[k]);
}
Service.EventManager.SendEvent(EventId.UserLoweredBuilding, flag ? null : selectedBuilding);
}
if (affectBoard && dropKind == DropKind.JustDrop && this.ShouldSaveAfterEveryMove())
{
BuildingMultiMoveRequest buildingMultiMoveRequest = new BuildingMultiMoveRequest();
buildingMultiMoveRequest.PositionMap = new PositionMap();
Position position = new Position();
position.X = selectedBuilding.Get <TransformComponent>().X;
position.Z = selectedBuilding.Get <TransformComponent>().Z;
buildingMultiMoveRequest.PositionMap.AddPosition(selectedBuilding.Get <BuildingComponent>().BuildingTO.Key, position);
for (int l = 0; l < this.buildingSelector.AdditionalSelectedBuildings.Count; l++)
{
Entity entity = this.buildingSelector.AdditionalSelectedBuildings[l];
position = new Position();
position.X = entity.Get <TransformComponent>().X;
position.Z = entity.Get <TransformComponent>().Z;
buildingMultiMoveRequest.PositionMap.AddPosition(entity.Get <BuildingComponent>().BuildingTO.Key, position);
}
BuildingMultiMoveCommand command = new BuildingMultiMoveCommand(buildingMultiMoveRequest);
Service.ServerAPI.Sync(command);
}
if (dropKind == DropKind.ConfirmPurchase || dropKind == DropKind.CancelPurchase)
{
Service.EventManager.SendEvent(EventId.BuildingPurchaseModeEnded, null);
}
}
private void OnAssetSuccess(object asset, object cookie)
{
GameObject gameObject = (GameObject)asset;
ShuttleAnim shuttleAnim = (ShuttleAnim)cookie;
shuttleAnim.GameObj = gameObject;
SmartEntity smartEntity = (SmartEntity)shuttleAnim.Starport;
if (this.shuttles.ContainsKey(smartEntity))
{
shuttleAnim.Anim = gameObject.GetComponent <Animation>();
GameObjectViewComponent gameObjectViewComponent = smartEntity.Get <GameObjectViewComponent>();
Transform transform = gameObject.transform;
AssetMeshDataMonoBehaviour component;
if (shuttleAnim.IsContrabandShuttle)
{
bool flag = shuttleAnim.Percentage < 1f || shuttleAnim.State == ShuttleState.Landing || shuttleAnim.State == ShuttleState.Idle;
if (smartEntity.GameObjectViewComp == null || smartEntity.GameObjectViewComp.MainGameObject == null)
{
this.UnloadShuttle(shuttleAnim);
StorageSpreadUtils.UpdateAllStarportFullnessMeters();
return;
}
component = smartEntity.GameObjectViewComp.MainGameObject.GetComponent <AssetMeshDataMonoBehaviour>();
for (int i = 0; i < component.OtherGameObjects.Count; i++)
{
if (component.OtherGameObjects[i].name.Contains("locator_vehicle"))
{
transform.position = component.OtherGameObjects[i].transform.position;
break;
}
}
if (flag)
{
this.AnimateContrabandShuttle(shuttleAnim, shuttleAnim.Percentage);
}
}
else if (shuttleAnim.IsArmoryShuttle)
{
if (smartEntity.GameObjectViewComp == null || smartEntity.GameObjectViewComp.MainGameObject == null)
{
this.UnloadShuttle(shuttleAnim);
return;
}
transform.position = gameObjectViewComponent.MainTransform.position;
this.AnimateArmoryShuttle(shuttleAnim);
}
else
{
transform.position = gameObjectViewComponent.MainTransform.position;
this.AnimateShuttle(shuttleAnim, shuttleAnim.Percentage);
}
transform.rotation = Quaternion.AngleAxis(-90f, Vector3.up);
component = gameObject.GetComponent <AssetMeshDataMonoBehaviour>();
if (component != null && component.OtherGameObjects != null)
{
shuttleAnim.ShadowGameObject = component.ShadowGameObject;
for (int j = 0; j < component.OtherGameObjects.Count; j++)
{
if (component.OtherGameObjects[j].name.Contains("center_of_mass"))
{
shuttleAnim.CenterOfMass = component.OtherGameObjects[j];
break;
}
}
}
if (shuttleAnim.ShadowGameObject != null)
{
shuttleAnim.ShadowMaterial = UnityUtils.EnsureMaterialCopy(shuttleAnim.ShadowGameObject.GetComponent <Renderer>());
shuttleAnim.ShadowMaterial.shader = Service.Get <AssetManager>().Shaders.GetShader("TransportShadow");
}
}
else
{
this.UnloadShuttle(shuttleAnim);
}
StorageSpreadUtils.UpdateAllStarportFullnessMeters();
}
public EatResponse OnEvent(EventId id, object cookie)
{
switch (id)
{
case EventId.BuildingLevelUpgraded:
case EventId.BuildingSwapped:
{
SmartEntity entity = (cookie as ContractEventData).Entity;
if (entity != null)
{
bool flag = this.buildingSelector.IsPartOfSelection(entity);
if (entity != null && flag)
{
this.buildingSelector.DeselectSelectedBuilding();
}
SmartEntity smartEntity = this.ReplaceBuildingAfterTOChange(entity);
if (flag && smartEntity != null)
{
this.buildingSelector.SelectBuilding(smartEntity, Vector3.zero);
}
Service.AchievementController.TryUnlockAchievementById(AchievementType.BuildingLevel, smartEntity.Get <BuildingComponent>().BuildingType.Uid);
this.CheckStarportFullness(smartEntity);
}
break;
}
case EventId.BuildingConstructed:
this.CheckStarportFullness(((ContractEventData)cookie).Entity);
break;
default:
if (id != EventId.ContractCompleted)
{
if (id != EventId.ContractCompletedForStoryAction)
{
if (id == EventId.ClearableCleared)
{
Entity entity2 = (cookie as ContractEventData).Entity;
if (entity2 != null && this.buildingSelector.SelectedBuilding == entity2)
{
this.buildingSelector.DeselectSelectedBuilding();
}
Service.EntityFactory.DestroyEntity(entity2, true, true);
}
}
else
{
ContractTO contractTO = (ContractTO)cookie;
if (contractTO.ContractType == ContractType.Upgrade)
{
BuildingTypeVO buildingTypeVO = Service.StaticDataController.Get <BuildingTypeVO>(contractTO.Uid);
if (buildingTypeVO.Type == BuildingType.HQ)
{
this.OnHQUpgraded();
}
}
}
}
else
{
ContractEventData contractEventData = cookie as ContractEventData;
ContractType contractType = contractEventData.Contract.ContractTO.ContractType;
if (contractType == ContractType.Upgrade || contractType == ContractType.Build)
{
BuildingTypeVO buildingTypeVO2 = Service.StaticDataController.Get <BuildingTypeVO>(contractEventData.Contract.ProductUid);
if (buildingTypeVO2.Type == BuildingType.NavigationCenter)
{
Service.CurrentPlayer.AddUnlockedPlanet(contractEventData.Contract.Tag);
}
if (buildingTypeVO2.Type == BuildingType.HQ && buildingTypeVO2.Lvl >= GameConstants.OBJECTIVES_UNLOCKED)
{
Service.ObjectiveManager.RefreshFromServer();
}
}
}
break;
}
return(EatResponse.NotEaten);
}
public void UnstashBuildingByUID(string buildingUID, bool returnToOriginalPosition, bool stampable, bool panToBuilding, bool playLoweredSound)
{
if (this.stashedBuildingMap == null)
{
return;
}
if (!this.stashedBuildingMap.ContainsKey(buildingUID) || this.stashedBuildingMap[buildingUID].Count < 1)
{
Service.Logger.Error("Can't unstash! No buildings of : " + buildingUID + " currently stashed");
return;
}
List <SmartEntity> list = this.stashedBuildingMap[buildingUID];
SmartEntity smartEntity = list[0];
BuildingComponent buildingComp = smartEntity.BuildingComp;
bool flag = false;
if (stampable && this.IsBuildingStampable(smartEntity))
{
flag = true;
}
Position pos = null;
if (returnToOriginalPosition)
{
pos = this.lastSavedMap.GetPosition(buildingComp.BuildingTO.Key);
if (flag)
{
flag = false;
Service.Logger.Warn("No stamping while reverting!!");
}
}
BuildingController buildingController = Service.BuildingController;
GameObjectViewComponent gameObjectViewComponent = smartEntity.Get <GameObjectViewComponent>();
TransformComponent transformComponent = smartEntity.Get <TransformComponent>();
if (gameObjectViewComponent != null)
{
gameObjectViewComponent.SetXYZ(Units.BoardToWorldX(transformComponent.CenterX()), 0f, Units.BoardToWorldZ(transformComponent.CenterZ()));
}
if (smartEntity.Has <HealthViewComponent>())
{
HealthViewComponent healthViewComponent = smartEntity.Get <HealthViewComponent>();
healthViewComponent.SetupElements();
}
List <SmartEntity> list2 = this.stashedBuildingMap[buildingUID];
if (list2.Contains(smartEntity))
{
list2.Remove(smartEntity);
if (!buildingController.PositionUnstashedBuilding(smartEntity, pos, flag, panToBuilding, playLoweredSound))
{
Service.Logger.ErrorFormat("Unable to place building from stash. Building {0} {1}", new object[]
{
smartEntity.Get <BuildingComponent>().BuildingTO.Key,
smartEntity.Get <BuildingComponent>().BuildingType.Uid
});
Service.UXController.MiscElementsManager.ShowPlayerInstructionsError(Service.Lang.Get("NO_VALID_POSITION_FOR_UNSTASH", new object[0]));
this.StashBuilding(smartEntity);
}
}
}
