public List <ActivatedPerkData> GetPlayerPerksInState(PerkState state)
{
List <ActivatedPerkData> playerActivatedPerks = this.GetPlayerActivatedPerks();
List <ActivatedPerkData> list = new List <ActivatedPerkData>();
if (playerActivatedPerks != null)
{
int i = 0;
int count = playerActivatedPerks.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = playerActivatedPerks[i];
if (state == PerkState.Active && this.IsPerkActive(activatedPerkData))
{
list.Add(activatedPerkData);
}
else if (state == PerkState.Cooldown && this.IsPerkInCooldown(activatedPerkData))
{
list.Add(activatedPerkData);
}
else if (state == PerkState.Expired && this.IsPerkExpired(activatedPerkData))
{
list.Add(activatedPerkData);
}
i++;
}
}
return(list);
}
private void CleanupExpiredPlayerPerks()
{
StaticDataController staticDataController = Service.StaticDataController;
List <ActivatedPerkData> playerActivatedPerks = this.GetPlayerActivatedPerks();
Dictionary <string, uint> playerPerkGroupCooldowns = this.GetPlayerPerkGroupCooldowns();
ResourceGenerationPerkUtils.ProcessResouceGenPerkEffectsIntoStorage(this.GetPlayerActivatedPerks());
List <ActivatedPerkData> list = new List <ActivatedPerkData>();
int i = 0;
int count = playerActivatedPerks.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = playerActivatedPerks[i];
if (this.IsPerkExpired(activatedPerkData.PerkId))
{
PerkVO perkVO = staticDataController.Get <PerkVO>(activatedPerkData.PerkId);
string perkGroup = perkVO.PerkGroup;
if (playerPerkGroupCooldowns.ContainsKey(perkGroup))
{
playerPerkGroupCooldowns.Remove(perkGroup);
}
list.Add(playerActivatedPerks[i]);
}
i++;
}
int j = 0;
int count2 = list.Count;
while (j < count2)
{
playerActivatedPerks.Remove(list[j]);
j++;
}
}
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 void PurchaseCooldownSkip(string perkId)
{
StaticDataController staticDataController = Service.StaticDataController;
string perkGroup = staticDataController.Get <PerkVO>(perkId).PerkGroup;
ActivatedPerkData playerPerkForGroup = this.GetPlayerPerkForGroup(perkGroup);
if (this.IsPerkInCooldown(playerPerkForGroup))
{
Dictionary <string, uint> playerPerkGroupCooldowns = this.GetPlayerPerkGroupCooldowns();
uint seconds = playerPerkGroupCooldowns[perkGroup] - ServerTime.Time;
int crystals = GameUtils.SecondsToCrystalsForPerk((int)seconds);
if (!GameUtils.SpendCrystals(crystals))
{
return;
}
ProcessingScreen.Show();
PlayerPerkSkipCooldownRequest request = new PlayerPerkSkipCooldownRequest(playerPerkForGroup.PerkId);
PlayerPerkSkipCooldownCommand command = new PlayerPerkSkipCooldownCommand(request);
Service.ServerAPI.Sync(command);
}
else
{
Service.Logger.WarnFormat("Perk {0} is no longer in cooldown, skipping purchase", new object[]
{
playerPerkForGroup.PerkId
});
}
}
private void UpdatePerkTimer(UXElement item)
{
ActivatedPerkData activatedPerkData = (ActivatedPerkData)item.Tag;
UXLabel subElement = this.perksGrid.GetSubElement <UXLabel>(activatedPerkData.PerkId, "LabelTimerModalActivePerks");
int num = (int)(activatedPerkData.EndTime - ServerTime.Time);
if (num < 1)
{
this.needsPerkStateRefresh = true;
}
string text = LangUtils.FormatTime((long)num);
subElement.Text = text;
}
public List <string> GetPlayerPerkIdsInState(PerkState state)
{
List <ActivatedPerkData> playerPerksInState = this.GetPlayerPerksInState(state);
List <string> list = new List <string>();
int i = 0;
int count = playerPerksInState.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = playerPerksInState[i];
list.Add(activatedPerkData.PerkId);
i++;
}
return(list);
}
public bool CancelPlayerPerk(string perkId)
{
ActivatedPerkData playerPerk = this.GetPlayerPerk(perkId);
Dictionary <string, uint> playerPerkGroupCooldowns = this.GetPlayerPerkGroupCooldowns();
StaticDataController staticDataController = Service.StaticDataController;
PerkVO perkVO = staticDataController.Get <PerkVO>(perkId);
string perkGroup = perkVO.PerkGroup;
if (playerPerk == null)
{
this.logger.ErrorFormat("Cannot cancel non existant perk, perkId : {0}", new object[]
{
perkId
});
return(false);
}
if (!this.IsPerkActive(playerPerk))
{
this.logger.ErrorFormat("Cannot cancel non active perk, perkId : {0}", new object[]
{
perkId
});
return(false);
}
if (playerPerkGroupCooldowns == null || !playerPerkGroupCooldowns.ContainsKey(perkGroup))
{
this.logger.ErrorFormat("Perk Cooldown group doesn't exist for perkId: {0}, PerkGroup: {1}", new object[]
{
perkId,
perkGroup
});
return(false);
}
uint time = ServerTime.Time;
playerPerk.EndTime = time;
int num = perkVO.CooldownDurationMinutes * 60;
uint value = time + (uint)num;
playerPerkGroupCooldowns[perkGroup] = value;
Service.EventManager.SendEvent(EventId.ActivePerksUpdated, null);
PlayerPerkCancelRequest request = new PlayerPerkCancelRequest(perkId);
PlayerPerkCancelCommand command = new PlayerPerkCancelCommand(request);
Service.ServerAPI.Sync(command);
return(true);
}
private static List <CurrencyPerkEffectDataTO> GetAllCurrencyPerksEffectsActiveDuringTimeWindow(CurrencyType type, uint startTime, uint endTime, List <ActivatedPerkData> allPerks)
{
IDataController dataController = Service.Get <IDataController>();
List <CurrencyPerkEffectDataTO> result = new List <CurrencyPerkEffectDataTO>();
int count = allPerks.Count;
for (int i = 0; i < count; i++)
{
ActivatedPerkData activatedPerkData = allPerks[i];
if (ResourceGenerationPerkUtils.IsPerkActiveDuringTimeWindow(activatedPerkData, startTime, endTime))
{
PerkVO perkData = dataController.Get <PerkVO>(activatedPerkData.PerkId);
ResourceGenerationPerkUtils.AddEffectsOfMatchingCurrencyType(perkData, type, activatedPerkData.StartTime, activatedPerkData.EndTime, ref result);
}
}
return(result);
}
public ActivatedPerkData GetPlayerPerk(string perkId)
{
List <ActivatedPerkData> playerActivatedPerks = this.GetPlayerActivatedPerks();
int i = 0;
int count = playerActivatedPerks.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = playerActivatedPerks[i];
if (activatedPerkData.PerkId == perkId)
{
return(activatedPerkData);
}
i++;
}
return(null);
}
private void AddPerkToGrid(ActivatedPerkData perkData)
{
string perkId = perkData.PerkId;
PerkViewController perkViewController = Service.PerkViewController;
PerkVO perkVO = Service.StaticDataController.Get <PerkVO>(perkId);
UXElement uXElement = this.perksGrid.CloneTemplateItem(perkId);
uXElement.Tag = perkData;
UXLabel subElement = this.perksGrid.GetSubElement <UXLabel>(perkId, "LabelPerkTitleModalActivePerks");
subElement.Text = perkViewController.GetPerkNameForGroup(perkVO.PerkGroup);
UXTexture subElement2 = this.perksGrid.GetSubElement <UXTexture>(perkId, "TexturePerkArtModalActivePerks");
perkViewController.SetPerkImage(subElement2, perkVO);
UXLabel subElement3 = this.perksGrid.GetSubElement <UXLabel>(perkId, "LabelPerkLvlModalActivePerks");
subElement3.Text = StringUtils.GetRomanNumeral(perkVO.PerkTier);
UXLabel subElement4 = this.perksGrid.GetSubElement <UXLabel>(perkId, "ItemLabelModalActivePerks");
subElement4.Visible = false;
UXGrid subElement5 = this.perksGrid.GetSubElement <UXGrid>(perkId, "GridSubModalActivePerks");
subElement5.SetTemplateItem("ItemLabelModalActivePerks");
subElement5.Clear();
PerkManager perkManager = Service.PerkManager;
int i = 0;
int num = perkVO.PerkEffects.Length;
while (i < num)
{
string text = perkVO.PerkEffects[i];
PerkEffectVO perkEffectVO = Service.StaticDataController.Get <PerkEffectVO>(text);
UXLabel uXLabel = (UXLabel)subElement5.CloneTemplateItem(text);
uXLabel.Text = this.lang.Get(perkEffectVO.StatStringId, new object[0]) + Service.PerkViewController.GetFormattedValueBasedOnEffectType(perkEffectVO, null);
if (!perkManager.IsPerkEffectAppliedToBuilding(perkEffectVO, this.buildingVO))
{
uXLabel.TextColor = UXUtils.COLOR_PERK_EFFECT_NOT_APPLIED;
}
subElement5.AddItem(uXLabel, i);
i++;
}
this.UpdatePerkTimer(uXElement);
this.perksGrid.AddItem(uXElement, 1);
}
public bool IsPerkInCooldown(ActivatedPerkData playerPerk)
{
if (playerPerk == null)
{
return(false);
}
StaticDataController staticDataController = Service.StaticDataController;
PerkVO perkVO = staticDataController.Get <PerkVO>(playerPerk.PerkId);
string perkGroup = perkVO.PerkGroup;
Dictionary <string, uint> playerPerkGroupCooldowns = this.GetPlayerPerkGroupCooldowns();
if (playerPerkGroupCooldowns == null || !playerPerkGroupCooldowns.ContainsKey(perkGroup))
{
return(false);
}
uint endTime = playerPerk.EndTime;
uint num = playerPerkGroupCooldowns[perkGroup];
uint time = ServerTime.Time;
return(endTime <= time && num > time);
}
public uint GetMaxActivationTimeRemaining(Entity building)
{
BuildingComponent buildingComp = ((SmartEntity)building).BuildingComp;
BuildingTypeVO buildingType = buildingComp.BuildingType;
List <ActivatedPerkData> perksAppliedToBuilding = this.GetPerksAppliedToBuilding(buildingType);
uint num = 0u;
int i = 0;
int count = perksAppliedToBuilding.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = perksAppliedToBuilding[i];
uint num2 = activatedPerkData.EndTime - ServerTime.Time;
if (activatedPerkData.EndTime > ServerTime.Time && num < num2)
{
num = num2;
}
i++;
}
return(num);
}
public ActivatedPerkData GetPlayerPerkForGroup(string perkGroupId)
{
List <ActivatedPerkData> playerActivatedPerks = this.GetPlayerActivatedPerks();
if (playerActivatedPerks == null)
{
return(null);
}
StaticDataController staticDataController = Service.StaticDataController;
int i = 0;
int count = playerActivatedPerks.Count;
while (i < count)
{
ActivatedPerkData activatedPerkData = playerActivatedPerks[i];
PerkVO perkVO = staticDataController.Get <PerkVO>(activatedPerkData.PerkId);
if (perkGroupId == perkVO.PerkGroup)
{
return(activatedPerkData);
}
i++;
}
return(null);
}
public bool ActivatePlayerPerk(string targetPerkId, Dictionary <string, string> availablePerks, string guildLevelUid)
{
StaticDataController staticDataController = Service.StaticDataController;
PerkVO perkVO = staticDataController.Get <PerkVO>(targetPerkId);
string perkGroup = perkVO.PerkGroup;
if (!this.HasEmptyPerkActivationSlot(guildLevelUid))
{
return(false);
}
if (availablePerks == null || !availablePerks.ContainsValue(targetPerkId))
{
string message = "Perk not activated, not in available perks, perkId: " + targetPerkId;
this.logger.ErrorFormat(message, new object[0]);
return(false);
}
List <ActivatedPerkData> playerActivatedPerks = this.GetPlayerActivatedPerks();
Dictionary <string, uint> playerPerkGroupCooldowns = this.GetPlayerPerkGroupCooldowns();
if (this.IsPerkActive(targetPerkId))
{
ActivatedPerkData playerPerk = this.GetPlayerPerk(targetPerkId);
string message2 = string.Concat(new object[]
{
"Perk not activated, perk already active, perkId: ",
targetPerkId,
" startTime: ",
playerPerk.StartTime,
" endTime: ",
playerPerk.EndTime
});
this.logger.ErrorFormat(message2, new object[0]);
return(false);
}
if (this.IsPerkInCooldown(targetPerkId))
{
ActivatedPerkData playerPerk2 = this.GetPlayerPerk(targetPerkId);
string message3 = string.Concat(new object[]
{
"Perk not activated, perk in cooldown, perkId: ",
targetPerkId,
" startTime: ",
playerPerk2.StartTime,
" endTime: ",
playerPerk2.EndTime,
" cooldownEndTime: ",
playerPerkGroupCooldowns[perkGroup]
});
this.logger.ErrorFormat(message3, new object[0]);
return(false);
}
this.CleanupExpiredPlayerPerks();
if (this.HasPlayerActivatedFirstPerk())
{
GameUtils.SpendHQScaledCurrency(perkVO.ActivationCost, false);
}
uint time = ServerTime.Time;
int num = perkVO.ActiveDurationMinutes * 60;
uint num2 = time + (uint)num;
int num3 = perkVO.CooldownDurationMinutes * 60;
uint value = num2 + (uint)num3;
playerActivatedPerks.Add(new ActivatedPerkData
{
PerkId = targetPerkId,
StartTime = time,
EndTime = num2
});
playerPerkGroupCooldowns[perkGroup] = value;
Service.EventManager.SendEvent(EventId.ActivePerksUpdated, null);
PlayerPerkActivateRequest request = new PlayerPerkActivateRequest(targetPerkId);
PlayerPerkActivateCommand command = new PlayerPerkActivateCommand(request);
Service.ServerAPI.Sync(command);
return(true);
}
public bool IsPerkGroupExpired(string perkGroupId)
{
ActivatedPerkData playerPerkForGroup = this.GetPlayerPerkForGroup(perkGroupId);
return(this.IsPerkExpired(playerPerkForGroup));
}
public bool IsPerkExpired(string perkId)
{
ActivatedPerkData playerPerk = this.GetPlayerPerk(perkId);
return(this.IsPerkExpired(playerPerk));
}
public bool IsPerkActive(ActivatedPerkData perk)
{
uint time = ServerTime.Time;
return(perk != null && perk.StartTime <= time && perk.EndTime > time);
}
public bool IsPerkInCooldown(string perkId)
{
ActivatedPerkData playerPerk = this.GetPlayerPerk(perkId);
return(this.IsPerkInCooldown(playerPerk));
}
public bool IsPerkGroupInCooldown(string perkGroupId)
{
ActivatedPerkData playerPerkForGroup = this.GetPlayerPerkForGroup(perkGroupId);
return(this.IsPerkInCooldown(playerPerkForGroup));
}
private static bool IsPerkActiveDuringTimeWindow(ActivatedPerkData perk, uint startTime, uint endTime)
{
return(perk.StartTime <= endTime && perk.EndTime > startTime);
}
public bool IsPerkExpired(ActivatedPerkData playerPerk)
{
return(playerPerk != null && (!this.IsPerkActive(playerPerk) && !this.IsPerkInCooldown(playerPerk)));
}
protected override void InitUI()
{
base.InitUI();
Lang lang = Service.Get <Lang>();
PerkViewController perkViewController = Service.Get <PerkViewController>();
PerkManager perkManager = Service.Get <PerkManager>();
Squad currentSquad = Service.Get <SquadController>().StateManager.GetCurrentSquad();
if (currentSquad == null)
{
return;
}
Dictionary <string, string> available = currentSquad.Perks.Available;
int level = currentSquad.Level;
int squadLevelUnlock = this.targetPerkVO.SquadLevelUnlock;
UXButton element = this.squadScreen.GetElement <UXButton>("BtnContinuePerkUpgradeCeleb");
element.Visible = false;
UXLabel element2 = this.squadScreen.GetElement <UXLabel>("LabelModalTitlePerks");
element2.Text = lang.Get("PERK_ACTIVATE_POPUP_TITLE", new object[]
{
perkViewController.GetPerkNameForGroup(this.targetPerkVO.PerkGroup),
this.targetPerkVO.PerkTier
});
UXLabel element3 = this.squadScreen.GetElement <UXLabel>("LabelModalStoryPerks");
element3.Text = perkViewController.GetPerkDescForGroup(this.targetPerkVO.PerkGroup);
perkViewController.SetupStatGridForPerk(this.targetPerkVO, this.statGrid, "TemplateModalStatsPerks", "LabelModalStatsInfoPerks", "LabelModalStatsValuePerks", false);
UXTexture element4 = this.squadScreen.GetElement <UXTexture>("TexturePerkArtModalCardPerks");
perkViewController.SetPerkImage(element4, this.targetPerkVO);
this.activationTimerLabel = this.squadScreen.GetElement <UXLabel>("LabelTickerModalPerks");
UXButton element5 = this.squadScreen.GetElement <UXButton>("BtnModalOneCurrencyPerks");
UXButton element6 = this.squadScreen.GetElement <UXButton>("BtnModalTwoCurrencyPerks");
this.activationTimerLabel.Visible = false;
element5.Visible = false;
element6.Visible = false;
bool flag = !available.ContainsKey(this.targetPerkVO.PerkGroup);
if (flag)
{
bool flag2 = perkManager.IsPerkLevelLocked(this.targetPerkVO, level);
if (flag2)
{
UXLabel element7 = this.squadScreen.GetElement <UXLabel>("LabelPrimaryLvlLockedModalPerks");
UXLabel element8 = this.squadScreen.GetElement <UXLabel>("LabelSquadLvlLockedModalPerks");
UXLabel element9 = this.squadScreen.GetElement <UXLabel>("LabelSecondaryLvlLockedModalPerks");
element7.Text = lang.Get("PERK_UPGRADE_POPUP_LVL_REQ", new object[0]);
element8.Text = squadLevelUnlock.ToString();
element9.Text = lang.Get("PERK_UPGRADE_POPUP_LVL_REQ2", new object[0]);
this.levelLockedGroup.Visible = true;
}
else
{
UXLabel element10 = this.squadScreen.GetElement <UXLabel>("LabelPrimaryRepLockedModalPerks");
this.repLockedGroup.Visible = true;
element10.Text = lang.Get("PERK_ACTIVATE_POPUP_REP_REQ", new object[0]);
}
}
if (this.isActivation && !flag)
{
Dictionary <string, int> hQScaledCostForPlayer = GameUtils.GetHQScaledCostForPlayer(this.targetPerkVO.ActivationCost);
int count = hQScaledCostForPlayer.Count;
bool flag3 = count == 2;
element5.Visible = !flag3;
element6.Visible = flag3;
UXButton uXButton = flag3 ? element6 : element5;
uXButton.OnClicked = new UXButtonClickedDelegate(this.OnActivateButtonClicked);
this.rootInfoView.Visible = true;
string[] costElementNames = flag3 ? SquadScreenActivationInfoView.dualCostElementNames : SquadScreenActivationInfoView.singleCostElementNames;
UXUtils.SetupMultiCostElements(this.squadScreen, costElementNames, null, this.targetPerkVO.ActivationCost, count);
this.rootInfoView.Visible = false;
}
if (perkManager.IsPerkActive(this.targetPerkVO.Uid))
{
this.activatedPerkData = Service.Get <PerkManager>().GetPlayerPerk(this.targetPerkVO.Uid);
if (this.activatedPerkData != null)
{
this.activationTimerLabel.Visible = true;
this.UpdateActivationTimeRemaining();
Service.Get <ViewTimeEngine>().RegisterClockTimeObserver(this, 1f);
}
}
}
private void RefreshActivePerksGrid()
{
if (this.activePerksGrid == null)
{
this.activePerksGrid = this.screen.GetElement <UXGrid>("GridActSlotsPerks");
this.activePerksGrid.SetTemplateItem("TemplateActSlotPerks");
}
this.activePerkTimerLabels.Clear();
IDataController dataController = Service.Get <IDataController>();
Lang lang = Service.Get <Lang>();
PerkManager perkManager = Service.Get <PerkManager>();
List <ActivatedPerkData> playerActivePerks = perkManager.GetPlayerActivePerks();
Squad currentSquad = Service.Get <SquadController>().StateManager.GetCurrentSquad();
if (currentSquad == null)
{
return;
}
string squadLevelUIDFromSquad = GameUtils.GetSquadLevelUIDFromSquad(currentSquad);
int availableSlotsCount = perkManager.GetAvailableSlotsCount(squadLevelUIDFromSquad);
int squadLevelMax = perkManager.SquadLevelMax;
List <UXElement> list = new List <UXElement>();
int num = -1;
int i = 1;
int num2 = 0;
while (i <= squadLevelMax)
{
string squadLevelUIDFromLevel = GameUtils.GetSquadLevelUIDFromLevel(i);
SquadLevelVO squadLevelVO = dataController.Get <SquadLevelVO>(squadLevelUIDFromLevel);
int slots = squadLevelVO.Slots;
if (num != slots)
{
bool flag = slots > availableSlotsCount;
bool flag2 = num2 < playerActivePerks.Count && !flag;
int level = squadLevelVO.Level;
string itemUid = "PerkSlot_" + slots.ToString();
UXElement uXElement = base.FetchPerkGridItem(this.activePerksGrid, itemUid);
UXElement subElement = this.activePerksGrid.GetSubElement <UXElement>(itemUid, "AvailableSlotGroupPerks");
UXLabel subElement2 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelAvActSlotPerks");
UXElement subElement3 = this.activePerksGrid.GetSubElement <UXElement>(itemUid, "ActivatedSlotGroupPerks");
UXElement subElement4 = this.activePerksGrid.GetSubElement <UXElement>(itemUid, "LockedSlotGroupPerks");
UXLabel subElement5 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelPerkTitleActSlotPerks");
UXLabel subElement6 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelPerkLvlActSlotPerks");
UXLabel subElement7 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelPerkMessageTimerActSlotPerks");
UXLabel subElement8 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelPerkTimerActSlotPerks");
UXButton subElement9 = this.activePerksGrid.GetSubElement <UXButton>(itemUid, "BtnRemoveActSlotPerks");
UXTexture subElement10 = this.activePerksGrid.GetSubElement <UXTexture>(itemUid, "TexturePerkArtActSlotPerks");
UXButton uXButton = uXElement as UXButton;
if (flag)
{
uXButton.Enabled = false;
subElement.Visible = false;
subElement4.Visible = true;
subElement3.Visible = false;
subElement9.Visible = false;
UXLabel subElement11 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelSquadLvlLockedSlotPerks");
subElement11.Text = level.ToString();
UXLabel subElement12 = this.activePerksGrid.GetSubElement <UXLabel>(itemUid, "LabelSquadLvlLockedSlotPerks");
subElement12.Text = lang.Get("PERK_ACTIVATE_UPGRADE_CARD_LVL_REQ", new object[]
{
level
});
}
else if (flag2)
{
subElement.Visible = false;
subElement4.Visible = false;
subElement3.Visible = true;
subElement9.Visible = true;
ActivatedPerkData activatedPerkData = playerActivePerks[num2++];
string perkId = activatedPerkData.PerkId;
PerkViewController perkViewController = Service.Get <PerkViewController>();
PerkVO perkVO = dataController.Get <PerkVO>(perkId);
subElement5.Text = perkViewController.GetPerkNameForGroup(perkVO.PerkGroup);
subElement6.Text = StringUtils.GetRomanNumeral(perkVO.PerkTier);
perkViewController.SetPerkImage(subElement10, perkVO);
subElement7.Text = lang.Get("PERK_ACTIVE_SLOT_ACTIVE_TIMER_DESC", new object[0]);
this.UpdateLabelTimeRemaining(subElement8, lang, "PERK_ACTIVE_SLOT_ACTIVE_TIMER", activatedPerkData.EndTime);
subElement8.Tag = activatedPerkData;
this.activePerkTimerLabels.Add(subElement8);
uXButton.Enabled = true;
uXButton.Tag = perkVO;
uXButton.OnClicked = new UXButtonClickedDelegate(this.OnPerkSlotButtonClicked);
subElement9.Tag = perkId;
subElement9.Visible = true;
subElement9.OnClicked = new UXButtonClickedDelegate(this.OnRemoveButtonClicked);
}
else
{
uXButton.Enabled = false;
subElement4.Visible = false;
subElement3.Visible = false;
subElement9.Visible = false;
subElement.Visible = true;
subElement2.Text = lang.Get("PERK_ACTIVE_SLOT_TITLE", new object[0]);
}
list.Add(uXElement);
num = slots;
}
i++;
}
this.activePerksGrid.ClearWithoutDestroy();
int j = 0;
int count = list.Count;
while (j < count)
{
this.activePerksGrid.AddItem(list[j], j);
j++;
}
this.activePerksGrid.RepositionItems();
list.Clear();
}
