public bool IsChampionAvailable(SmartEntity building)
{
BuildingTypeVO buildingType = building.BuildingComp.BuildingType;
TroopTypeVO troopTypeVO = this.FindChampionTypeIfPlatform(buildingType);
return(troopTypeVO != null && this.PlayerHasChampion(troopTypeVO));
}
public void UpdateBuildingHighlightForPerks(Entity building)
{
if (building == null)
{
return;
}
bool flag = ContractUtils.IsBuildingUpgrading(building);
bool flag2 = ContractUtils.IsBuildingConstructing(building);
if (flag2 | flag)
{
return;
}
PerkManager perkManager = Service.Get <PerkManager>();
IState currentState = Service.Get <GameStateMachine>().CurrentState;
BuildingComponent buildingComp = ((SmartEntity)building).BuildingComp;
if ((currentState is ApplicationLoadState || currentState is HomeState || currentState is EditBaseState || currentState is BaseLayoutToolState) && buildingComp != null)
{
BuildingTypeVO buildingType = buildingComp.BuildingType;
if (perkManager.IsPerkAppliedToBuilding(buildingType))
{
this.entityShaderSwapper.HighlightForPerk(building);
return;
}
bool flag3 = this.entityShaderSwapper.ResetToOriginal(building);
if (flag3)
{
Service.Get <EventManager>().SendEvent(EventId.ShaderResetOnEntity, building);
}
}
}
public void StartClearingSelectedBuilding()
{
Entity 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 text = StringUtils.ToLowerCaseUnderscoreSeperated(buildingType.Type.ToString());
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(text);
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 Dictionary <BuildingTypeVO, int> GetBuildingsUnlockedBy(BuildingTypeVO reqBuilding)
{
Dictionary <BuildingTypeVO, int> dictionary = new Dictionary <BuildingTypeVO, int>();
StaticDataController staticDataController = Service.StaticDataController;
BuildingUpgradeCatalog buildingUpgradeCatalog = Service.BuildingUpgradeCatalog;
foreach (BuildingTypeVO current in staticDataController.GetAll <BuildingTypeVO>())
{
if (current.BuildingRequirement == reqBuilding.Uid || current.BuildingRequirement2 == reqBuilding.Uid)
{
BuildingTypeVO minLevel = buildingUpgradeCatalog.GetMinLevel(current);
BuildingTypeVO buildingTypeVO = (current.Lvl <= minLevel.Lvl) ? null : buildingUpgradeCatalog.GetByLevel(current, current.Lvl - 1);
int num = (buildingTypeVO != null) ? buildingTypeVO.MaxQuantity : 0;
int num2 = current.MaxQuantity - num;
if (num2 > 0)
{
if (dictionary.ContainsKey(minLevel))
{
Dictionary <BuildingTypeVO, int> dictionary2;
BuildingTypeVO key;
(dictionary2 = dictionary)[key = minLevel] = dictionary2[key] + num2;
}
else
{
dictionary.Add(minLevel, num2);
}
}
}
}
return(dictionary);
}
private NotificationObject CreateBuildingNotification(string productUid, int remainingTime, string buildingKey)
{
BuildingTypeVO buildingTypeVO = Service.Get <IDataController>().Get <BuildingTypeVO>(productUid);
string buildingDisplayName = LangUtils.GetBuildingDisplayName(buildingTypeVO);
return(this.CreateSupportNotification(productUid, remainingTime, buildingKey, "notif1", buildingDisplayName, buildingTypeVO.Lvl));
}
public static int GetPerkAdjustSecondsTillFull(BuildingTypeVO buildingVO, float remainingAmountTillFull, uint currentTime, List <ActivatedPerkData> allPerks)
{
int num = 0;
float num2 = ResourceGenerationPerkUtils.BaseCurrencyRate(buildingVO);
if (allPerks != null && allPerks.Count > 0)
{
List <CurrencyPerkEffectDataTO> allCurrencyPerksEffectsActiveDuringTimeWindow = ResourceGenerationPerkUtils.GetAllCurrencyPerksEffectsActiveDuringTimeWindow(buildingVO.Currency, currentTime, currentTime, allPerks);
allCurrencyPerksEffectsActiveDuringTimeWindow.Sort(new Comparison <CurrencyPerkEffectDataTO>(ResourceGenerationPerkUtils.EndTimeCompare));
List <CurrencyPerkEffectDataTO> list = ResourceGenerationPerkUtils.CombineOverlappingPerkEffectsIntoFinalList(allCurrencyPerksEffectsActiveDuringTimeWindow, currentTime, 4294967295u);
int count = list.Count;
int num3 = 0;
while (num3 < count && remainingAmountTillFull > 0f)
{
CurrencyPerkEffectDataTO currencyPerkEffectDataTO = list[num3];
int num4 = currencyPerkEffectDataTO.Duration;
float num5 = (1f + currencyPerkEffectDataTO.RateBonus) * num2;
float num6 = num5 * (float)num4;
if (num6 > remainingAmountTillFull)
{
num6 = remainingAmountTillFull;
num4 = Mathf.FloorToInt(num6 / num5);
}
remainingAmountTillFull -= num6;
num += num4;
num3++;
}
}
if (remainingAmountTillFull > 0f)
{
num += Mathf.FloorToInt(remainingAmountTillFull / num2);
}
return(num);
}
public static void ProcessResouceGenPerkEffectsIntoStorage(List <ActivatedPerkData> allPerks)
{
ISupportController supportController = Service.Get <ISupportController>();
NodeList <GeneratorViewNode> nodeList = Service.Get <EntityController>().GetNodeList <GeneratorViewNode>();
for (GeneratorViewNode generatorViewNode = nodeList.Head; generatorViewNode != null; generatorViewNode = generatorViewNode.Next)
{
BuildingComponent buildingComp = generatorViewNode.BuildingComp;
Building buildingTO = buildingComp.BuildingTO;
BuildingTypeVO buildingType = buildingComp.BuildingType;
Contract contract = supportController.FindCurrentContract(buildingComp.BuildingTO.Key);
if (buildingType.Type == BuildingType.Resource && contract == null)
{
uint time = ServerTime.Time;
uint lastCollectTime = buildingTO.LastCollectTime;
buildingTO.LastCollectTime = time;
int perkAdjustedAccruedCurrency = ResourceGenerationPerkUtils.GetPerkAdjustedAccruedCurrency(buildingType, lastCollectTime, time, allPerks);
buildingTO.CurrentStorage += perkAdjustedAccruedCurrency;
if (buildingTO.CurrentStorage > buildingType.Storage)
{
buildingTO.CurrentStorage = buildingType.Storage;
}
buildingTO.AccruedCurrency = buildingTO.CurrentStorage;
}
}
}
private void UpdateBuildings(FactionType newFaction)
{
StaticDataController staticDataController = Service.StaticDataController;
List <BuildingTypeVO> list = new List <BuildingTypeVO>();
foreach (BuildingTypeVO current in staticDataController.GetAll <BuildingTypeVO>())
{
list.Add(current);
}
List <BuildingTypeVO> arg_69_0 = list;
if (ChooseFactionScreen.< > f__mg$cache0 == null)
{
ChooseFactionScreen.< > f__mg$cache0 = new Comparison <BuildingTypeVO>(GameUtils.SortBuildingByUID);
}
arg_69_0.Sort(ChooseFactionScreen.< > f__mg$cache0);
List <Building> buildings = Service.CurrentPlayer.Map.Buildings;
for (int i = 0; i < buildings.Count; i++)
{
Building building = buildings[i];
BuildingTypeVO buildingTypeVO = staticDataController.Get <BuildingTypeVO>(building.Uid);
if (buildingTypeVO.Faction != FactionType.Neutral)
{
building.Uid = GameUtils.GetEquivalentFromPreSortedList(list, buildingTypeVO, newFaction);
}
}
list.Clear();
list = null;
}
private void RecalculateXP()
{
GamePlayer worldOwner = GameUtils.GetWorldOwner();
Inventory inventory = worldOwner.Inventory;
int num = -worldOwner.CurrentXPAmount;
NodeList <BuildingNode> nodeList = Service.Get <EntityController>().GetNodeList <BuildingNode>();
IDataController dataController = Service.Get <IDataController>();
for (BuildingNode buildingNode = nodeList.Head; buildingNode != null; buildingNode = buildingNode.Next)
{
BuildingTypeVO buildingType = buildingNode.BuildingComp.BuildingType;
if (!ContractUtils.IsBuildingConstructing(buildingNode.Entity))
{
num += buildingType.Xp;
}
}
foreach (TroopTypeVO current in dataController.GetAll <TroopTypeVO>())
{
if (current.PlayerFacing && worldOwner.UnlockedLevels.Troops.GetLevel(current.UpgradeGroup) == current.Lvl && worldOwner.Faction == current.Faction && this.unlockController.IsTroopUnlocked(worldOwner, current))
{
num += current.Xp;
}
}
foreach (SpecialAttackTypeVO current2 in dataController.GetAll <SpecialAttackTypeVO>())
{
if (current2.PlayerFacing && worldOwner.UnlockedLevels.Starships.GetLevel(current2.UpgradeGroup) == current2.Lvl && worldOwner.Faction == current2.Faction && this.unlockController.IsSpecialAttackUnlocked(worldOwner, current2))
{
num += current2.Xp;
}
}
inventory.ModifyXP(num);
}
public static bool CanApplyEffect(PerkEffectVO perkEffectVO, BuildingTypeVO contractBuildingVO)
{
string type = perkEffectVO.Type;
BuildingType perkBuilding = perkEffectVO.PerkBuilding;
return(contractBuildingVO != null && (type == "contractCost" && perkBuilding == contractBuildingVO.Type));
}
private void UpdateShieldRange(int sliderIndex)
{
ShieldController shieldController = Service.Get <ShieldController>();
BuildingUpgradeCatalog buildingUpgradeCatalog = Service.Get <BuildingUpgradeCatalog>();
BuildingTypeVO maxLevel = buildingUpgradeCatalog.GetMaxLevel(this.buildingInfo.UpgradeGroup);
int num = shieldController.PointsToRange[this.buildingInfo.ShieldRangePoints];
int num2 = shieldController.PointsToRange[maxLevel.ShieldRangePoints];
this.sliders[sliderIndex].CurrentSlider.Value = ((num2 == 0) ? 0f : ((float)num / (float)num2));
if (this.useUpgradeGroup)
{
BuildingTypeVO nextLevel = buildingUpgradeCatalog.GetNextLevel(this.buildingInfo);
int num3 = shieldController.PointsToRange[nextLevel.ShieldRangePoints];
this.sliders[sliderIndex].CurrentLabel.Text = this.lang.ThousandsSeparated(num);
this.sliders[sliderIndex].NextLabel.Text = this.lang.Get("PLUS", new object[]
{
this.lang.ThousandsSeparated(num3 - num)
});
this.sliders[sliderIndex].NextSlider.Value = ((num2 == 0) ? 0f : ((float)num3 / (float)num2));
return;
}
this.sliders[sliderIndex].CurrentLabel.Text = this.lang.Get("FRACTION", new object[]
{
this.lang.ThousandsSeparated(num),
this.lang.ThousandsSeparated(num2)
});
}
private bool IsBuildingValid(BuildingTypeVO vo)
{
if (vo.Type == BuildingType.Clearable)
{
return(false);
}
if (this.any)
{
return(true);
}
if (vo.Lvl >= this.level)
{
switch (this.matchType)
{
case ConditionMatchType.Uid:
return(vo.Uid == this.buildingId);
case ConditionMatchType.Id:
return(vo.UpgradeGroup == this.buildingId);
case ConditionMatchType.Type:
return(vo.Type == StringUtils.ParseEnum <BuildingType>(this.buildingId));
}
}
return(false);
}
public void StartChampionRepair(SmartEntity building)
{
BuildingTypeVO buildingType = building.BuildingComp.BuildingType;
this.repairChampionType = this.FindChampionTypeIfPlatform(buildingType);
if (this.repairChampionType == null)
{
return;
}
int credits = this.repairChampionType.Credits;
int materials = this.repairChampionType.Materials;
int contraband = this.repairChampionType.Contraband;
if (credits != 0 || materials != 0 || contraband != 0)
{
string purchaseContext = string.Format("{0}|{1}|{2}|{3}", new object[]
{
StringUtils.ToLowerCaseUnderscoreSeperated(this.repairChampionType.Type.ToString()),
this.repairChampionType.TroopID,
this.repairChampionType.Lvl,
"repair"
});
if (PayMeScreen.ShowIfNotEnoughCurrency(credits, materials, contraband, purchaseContext, new OnScreenModalResult(this.OnPayMeForCurrencyResult)))
{
return;
}
}
if (PayMeScreen.ShowIfNoFreeDroids(new OnScreenModalResult(this.OnPayMeForDroidResult), null))
{
return;
}
this.ConfirmRepair();
}
private void UpgradeChampionToMatchPlatform(SmartEntity building)
{
BuildingTypeVO buildingType = building.BuildingComp.BuildingType;
TroopTypeVO troopTypeVO = this.FindChampionTypeIfPlatform(buildingType);
if (troopTypeVO == null)
{
return;
}
BuildingUpgradeCatalog buildingUpgradeCatalog = Service.Get <BuildingUpgradeCatalog>();
BuildingTypeVO nextLevel = buildingUpgradeCatalog.GetNextLevel(buildingType);
TroopTypeVO troopTypeVO2 = this.FindChampionTypeIfPlatform(nextLevel);
if (troopTypeVO2 == null)
{
return;
}
this.AddChampionToInventoryIfAlive(building, false);
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
UnlockedLevelData.UpgradeTroopsOrStarshipsInventory(currentPlayer.Inventory.Champion, false, troopTypeVO2.UpgradeGroup, troopTypeVO2.Uid);
this.DestroyChampionEntity(troopTypeVO);
if (Service.Get <GameStateMachine>().CurrentState is HomeState)
{
this.CreateChampionEntity(troopTypeVO2, building);
}
}
public static int GetBuildingContractTotalTime(string buildingContractUid, DeliveryType type)
{
if (type == DeliveryType.UpgradeTroop)
{
TroopTypeVO optional = Service.Get <IDataController>().GetOptional <TroopTypeVO>(buildingContractUid);
return(optional.UpgradeTime);
}
if (type == DeliveryType.UpgradeStarship)
{
SpecialAttackTypeVO optional2 = Service.Get <IDataController>().GetOptional <SpecialAttackTypeVO>(buildingContractUid);
return(optional2.UpgradeTime);
}
if (type == DeliveryType.UpgradeEquipment)
{
EquipmentVO optional3 = Service.Get <IDataController>().GetOptional <EquipmentVO>(buildingContractUid);
return(optional3.UpgradeTime);
}
BuildingTypeVO buildingTypeVO = Service.Get <IDataController>().Get <BuildingTypeVO>(buildingContractUid);
switch (type)
{
case DeliveryType.Building:
case DeliveryType.UpgradeBuilding:
case DeliveryType.ClearClearable:
return(buildingTypeVO.Time);
case DeliveryType.SwapBuilding:
return(buildingTypeVO.SwapTime);
}
return(0);
}
private void SetupItemGrid()
{
this.itemGrid = base.GetElement <UXGrid>("UnlockItemsGrid");
this.itemGrid.SetTemplateItem("UnlockItemsTemplate");
BuildingLookupController buildingLookupController = Service.BuildingLookupController;
Dictionary <BuildingTypeVO, int> buildingsUnlockedBy = buildingLookupController.GetBuildingsUnlockedBy(this.headQuarter);
int num = 0;
foreach (KeyValuePair <BuildingTypeVO, int> current in buildingsUnlockedBy)
{
BuildingTypeVO key = current.Key;
int value = current.Value;
if (key.Type == BuildingType.Turret && key.BuildingRequirement != this.headQuarter.Uid)
{
if (num == 0)
{
num = value;
}
}
else
{
string uid = key.Uid;
UXElement item = this.itemGrid.CloneTemplateItem(uid);
UXSprite subElement = this.itemGrid.GetSubElement <UXSprite>(uid, "SpriteItemImage");
ProjectorConfig projectorConfig = ProjectorUtils.GenerateBuildingConfig(key, subElement);
projectorConfig.AnimPreference = AnimationPreference.AnimationPreferred;
ProjectorUtils.GenerateProjector(projectorConfig);
UXLabel subElement2 = this.itemGrid.GetSubElement <UXLabel>(uid, "LabelUnlockCount");
if (key.Type == BuildingType.Turret)
{
subElement2.Visible = false;
}
else
{
subElement2.Text = this.lang.Get("TROOP_MULTIPLIER", new object[]
{
value
});
}
this.itemGrid.AddItem(item, key.Order);
}
}
UXElement item2 = this.itemGrid.CloneTemplateItem("TURRETS");
UXSprite subElement3 = this.itemGrid.GetSubElement <UXSprite>("TURRETS", "SpriteItemImage");
subElement3.Visible = false;
UXLabel subElement4 = this.itemGrid.GetSubElement <UXLabel>("TURRETS", "LabelUnlockCount");
subElement4.Visible = false;
UXLabel subElement5 = this.itemGrid.GetSubElement <UXLabel>("TURRETS", "LabelTurrets");
subElement5.Visible = true;
subElement5.Text = this.lang.Get("HQ_UPGRADE_TURRETS_UNLOCKED", new object[]
{
num
});
this.itemGrid.AddItem(item2, 99999999);
this.itemGrid.RepositionItems();
this.itemGrid.Scroll((this.itemGrid.Count <= 7) ? 0.5f : 0f);
}
public NavigationCenterUpgradeScreen(SmartEntity selectedBuilding, BuildingTypeVO buildingTypeVO, OnScreenModalResult callback) : base(selectedBuilding)
{
this.buildingInfo = buildingTypeVO;
this.callback = callback;
this.tutorialMode = true;
this.useUpgradeGroup = false;
}
private bool CanPlaceAllRewardBuildings(string[] rewardBuildings)
{
bool result = true;
BuildingController buildingController = Service.Get <BuildingController>();
int i = 0;
int num = rewardBuildings.Length;
while (i < num)
{
string[] array = rewardBuildings[i].Split(new char[]
{
':'
});
int num2 = Convert.ToInt32(array[1], CultureInfo.InvariantCulture);
string uid = array[0];
BuildingTypeVO optional = Service.Get <IDataController>().GetOptional <BuildingTypeVO>(uid);
if (optional != null)
{
for (int j = 0; j < num2; j++)
{
if (!buildingController.FoundFirstEmptySpaceFor(optional))
{
result = false;
break;
}
}
}
i++;
}
return(result);
}
public static int GetPerkAdjustedAccruedCurrency(BuildingTypeVO buildingVO, uint startTime, uint endTime, List <ActivatedPerkData> allPerks)
{
int num = 0;
int num2 = (int)(endTime - startTime);
float num3 = ResourceGenerationPerkUtils.BaseCurrencyRate(buildingVO);
if (allPerks != null && allPerks.Count > 0)
{
List <CurrencyPerkEffectDataTO> allCurrencyPerksEffectsActiveDuringTimeWindow = ResourceGenerationPerkUtils.GetAllCurrencyPerksEffectsActiveDuringTimeWindow(buildingVO.Currency, startTime, endTime, allPerks);
allCurrencyPerksEffectsActiveDuringTimeWindow.Sort(new Comparison <CurrencyPerkEffectDataTO>(ResourceGenerationPerkUtils.StartTimeCompare));
List <CurrencyPerkEffectDataTO> list = ResourceGenerationPerkUtils.CombineOverlappingPerkEffectsIntoFinalList(allCurrencyPerksEffectsActiveDuringTimeWindow, startTime, endTime);
int count = list.Count;
int num4 = 0;
while (num4 < count && num2 > 0)
{
CurrencyPerkEffectDataTO currencyPerkEffectDataTO = list[num4];
int num5 = currencyPerkEffectDataTO.Duration;
if (num5 > num2)
{
num5 = num2;
}
float num6 = (1f + currencyPerkEffectDataTO.RateBonus) * num3;
num += Mathf.FloorToInt(num6 * (float)num5);
num2 -= num5;
num4++;
}
}
if (num2 > 0)
{
num += Mathf.FloorToInt(num3 * (float)num2);
}
return(num);
}
private bool IsBuildingValid(BuildingComponent component)
{
BuildingTypeVO buildingType = component.BuildingType;
if (this.any && GameUtils.IsBuildingTypeValidForBattleConditions(component.BuildingType.Type))
{
return(true);
}
if (buildingType.Lvl >= this.level)
{
ConditionMatchType conditionMatchType = this.matchType;
if (conditionMatchType == ConditionMatchType.Uid)
{
return(buildingType.Uid == this.buildingId);
}
if (conditionMatchType == ConditionMatchType.Id)
{
return(buildingType.UpgradeGroup == this.buildingId);
}
if (conditionMatchType == ConditionMatchType.Type)
{
return(buildingType.Type == StringUtils.ParseEnum <BuildingType>(this.buildingId));
}
}
return(false);
}
public int GetBuildingMaxPurchaseQuantity(BuildingTypeVO building, int haveReqBuildingLvl)
{
BuildingTypeVO buildingTypeVO = this.GetBuildingConstructionRequirement(building);
if (buildingTypeVO == null)
{
return(building.MaxQuantity);
}
if (haveReqBuildingLvl >= buildingTypeVO.Lvl || this.HasConstructedBuilding(buildingTypeVO))
{
BuildingUpgradeCatalog buildingUpgradeCatalog = Service.BuildingUpgradeCatalog;
int lvl = buildingUpgradeCatalog.GetMinLevel(building.UpgradeGroup).Lvl;
int lvl2 = buildingUpgradeCatalog.GetMaxLevel(building.UpgradeGroup).Lvl;
for (int i = lvl2; i > lvl; i--)
{
BuildingTypeVO byLevel = buildingUpgradeCatalog.GetByLevel(building.UpgradeGroup, i);
if (byLevel != null)
{
buildingTypeVO = this.GetRequiredBuilding(byLevel.BuildingRequirement);
if (buildingTypeVO == null || haveReqBuildingLvl >= buildingTypeVO.Lvl || this.HasConstructedBuilding(buildingTypeVO))
{
return(byLevel.MaxQuantity);
}
}
}
BuildingTypeVO minLevel = buildingUpgradeCatalog.GetMinLevel(building);
return(minLevel.MaxQuantity);
}
if (Service.UnlockController.HasUnlockedBuildingByReward(building))
{
return(1);
}
return(0);
}
private BoardCell <Entity> CanConnect(Entity wall)
{
if (wall == null)
{
return(null);
}
BuildingComponent buildingComponent = wall.Get <BuildingComponent>();
if (buildingComponent == null)
{
return(null);
}
BuildingTypeVO buildingType = buildingComponent.BuildingType;
if (buildingType == null)
{
return(null);
}
if (buildingType.Connectors == null)
{
return(null);
}
BoardItemComponent boardItemComponent = wall.Get <BoardItemComponent>();
if (boardItemComponent == null)
{
return(null);
}
return(boardItemComponent.BoardItem.CurrentCell);
}
private BuildingTypeVO GetBuildingConstructionRequirement(BuildingTypeVO building)
{
BuildingUpgradeCatalog buildingUpgradeCatalog = Service.BuildingUpgradeCatalog;
BuildingTypeVO minLevel = buildingUpgradeCatalog.GetMinLevel(building);
return(this.GetRequiredBuilding(minLevel.BuildingRequirement));
}
public void UpdateFillStateFX(Entity entity, BuildingTypeVO buildingVO, float currentFullnessPercent, float previousFullnessPercent)
{
float collectNotificationPercentage = this.GetCollectNotificationPercentage(buildingVO);
if (Service.PostBattleRepairController.IsEntityInRepair(entity))
{
if (previousFullnessPercent >= collectNotificationPercentage)
{
Service.FXManager.RemoveAttachedFXFromEntity(entity, "fillState");
}
return;
}
if (currentFullnessPercent == previousFullnessPercent)
{
return;
}
if (currentFullnessPercent >= collectNotificationPercentage && previousFullnessPercent < collectNotificationPercentage)
{
Service.FXManager.CreateAndAttachFXToEntity(entity, buildingVO.FillStateAssetName, "fillState", new FXManager.AttachedFXLoadedCallback(this.OnFillStateLoaded), currentFullnessPercent, false, Vector3.zero);
}
else if (currentFullnessPercent >= collectNotificationPercentage)
{
GameObject attachedGameObject = entity.Get <GameObjectViewComponent>().GetAttachedGameObject("fillState");
if (attachedGameObject != null)
{
this.UpdateFillStateMeshes(attachedGameObject, entity, currentFullnessPercent);
}
}
else if (currentFullnessPercent < collectNotificationPercentage && previousFullnessPercent >= collectNotificationPercentage)
{
Service.FXManager.RemoveAttachedFXFromEntity(entity, "fillState");
}
}
public BuildingController()
{
Service.Set <BuildingController>(this);
this.buildingSelector = new BuildingSelector();
this.buildingMover = new BuildingMover(this.buildingSelector);
this.entityShaderSwapper = new EntityShaderSwapper();
this.purchasingBuilding = false;
this.purchasingStampable = 0;
this.purchasingBuildingType = null;
this.UnstashStampingEnabled = false;
this.stampingCellsX = new int[2];
this.stampingCellsZ = new int[2];
this.ResetStampLocations();
this.edgeRotations = new int[4, 2, 2];
int num = 1;
int num2 = 0;
for (int i = 0; i < 4; i++)
{
this.edgeRotations[i, 0, 0] = num;
this.edgeRotations[i, 0, 1] = -num2;
this.edgeRotations[i, 1, 0] = num2;
this.edgeRotations[i, 1, 1] = num;
int num3 = num;
num = -num2;
num2 = num3;
}
EventManager eventManager = Service.Get <EventManager>();
eventManager.RegisterObserver(this, EventId.BuildingLevelUpgraded, EventPriority.Default);
eventManager.RegisterObserver(this, EventId.BuildingSwapped, EventPriority.Default);
eventManager.RegisterObserver(this, EventId.ClearableCleared, EventPriority.Default);
eventManager.RegisterObserver(this, EventId.ContractCompletedForStoryAction, EventPriority.Default);
eventManager.RegisterObserver(this, EventId.ContractCompleted, EventPriority.Default);
}
public List <ActivatedPerkData> GetPerksAppliedToBuilding(BuildingTypeVO vo)
{
List <ActivatedPerkData> list = new List <ActivatedPerkData>();
StaticDataController staticDataController = Service.StaticDataController;
List <ActivatedPerkData> playerActivatedPerks = this.GetPlayerActivatedPerks();
int i = 0;
int count = playerActivatedPerks.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = playerActivatedPerks[i];
PerkVO perkVO = staticDataController.Get <PerkVO>(activatedPerkData.PerkId);
if (activatedPerkData.EndTime > ServerTime.Time)
{
int j = 0;
int num = perkVO.PerkEffects.Length;
while (j < num)
{
PerkEffectVO perkEffectVO = staticDataController.Get <PerkEffectVO>(perkVO.PerkEffects[j]);
bool flag = this.IsPerkEffectAppliedToBuilding(perkEffectVO, vo);
if (flag)
{
list.Add(activatedPerkData);
break;
}
j++;
}
}
i++;
}
return(list);
}
public bool isOverlapping(Building thisBuilding, BuildingTypeVO buildingType, int x, int z)
{
BuildingTypeVO optional = Service.Get <IDataController>().GetOptional <BuildingTypeVO>(thisBuilding.Uid);
int num = optional.SizeX;
int num2 = optional.SizeY;
int num3 = buildingType.SizeX;
int num4 = buildingType.SizeY;
BuildingType type = optional.Type;
BuildingType type2 = buildingType.Type;
bool flag = type == BuildingType.Wall || type == BuildingType.Trap;
bool flag2 = type2 == BuildingType.Wall || type2 == BuildingType.Trap;
if (!(flag & flag2))
{
if (num == 1 && num2 == 1)
{
num++;
num2++;
}
if (num3 == 1 && num4 == 1)
{
num3++;
num4++;
}
}
return(thisBuilding.X < x + num3 && thisBuilding.X + num > x && thisBuilding.Z < z + num4 && thisBuilding.Z + num2 > z);
}
public static DeliveryType GetDeliveryTypeForTroopContract(BuildingTypeVO building)
{
BuildingType type = building.Type;
switch (type)
{
case BuildingType.Barracks:
return(DeliveryType.Infantry);
case BuildingType.Factory:
return(DeliveryType.Vehicle);
case BuildingType.FleetCommand:
return(DeliveryType.Starship);
case BuildingType.HeroMobilizer:
return(DeliveryType.Hero);
case BuildingType.ChampionPlatform:
return(DeliveryType.Champion);
default:
if (type != BuildingType.Cantina)
{
return(DeliveryType.Invalid);
}
return(DeliveryType.Mercenary);
}
}
private void FinishContract(object result, object cookie)
{
if (this.activeContract == null || result == null)
{
return;
}
int crystalCostToFinishContract = ContractUtils.GetCrystalCostToFinishContract(this.activeContract);
if (!GameUtils.SpendCrystals(crystalCostToFinishContract))
{
return;
}
Service.ISupportController.BuyOutCurrentBuildingContract(this.selectedBuilding, true);
BuildingComponent buildingComp = this.selectedBuilding.BuildingComp;
if (buildingComp != null)
{
BuildingTypeVO buildingType = buildingComp.BuildingType;
if (buildingType != null)
{
int currencyAmount = -crystalCostToFinishContract;
string itemType = StringUtils.ToLowerCaseUnderscoreSeperated(buildingType.Type.ToString());
string buildingID = buildingType.BuildingID;
int itemCount = 1;
string type = "speed_up_upgrade";
string subType = "equipment";
Service.DMOAnalyticsController.LogInAppCurrencyAction(currencyAmount, itemType, buildingID, itemCount, type, subType);
}
}
this.CloseFromResearchScreen();
}
private SupportViewComponentState GetBubbleViewComponentStateBasedOnBuilding(SmartEntity building)
{
SupportViewComponentState result = SupportViewComponentState.Bubble;
if (building == null)
{
return(result);
}
BuildingComponent buildingComp = building.BuildingComp;
if (buildingComp == null)
{
return(result);
}
BuildingTypeVO buildingType = buildingComp.BuildingType;
if (buildingType.Type == BuildingType.HQ)
{
return(SupportViewComponentState.BubbleHQ);
}
if (buildingType.Type == BuildingType.Armory && this.ShouldBadgeArmoryBuilding())
{
result = SupportViewComponentState.BubbleArmoryUpgrade;
}
if (buildingType.Type == BuildingType.TroopResearch && this.ShouldBadgeResearchBuilding())
{
result = SupportViewComponentState.BubbleShardUpgrade;
}
return(result);
}
