// ----------------------------------------------------------------
// Initialize
// ----------------------------------------------------------------
public void Initialize(Room _myRoom, CrateData data)
{
base.BaseGroundInitialize(_myRoom, data);
hitsUntilBreak = data.hitsUntilBreak;
numCoinsInMe = data.numCoinsInMe;
}
private void ScheduleCrateExpireBadgeUpdate()
{
ViewTimerManager viewTimerManager = Service.Get <ViewTimerManager>();
uint time = ServerTime.Time;
if (this.expireBadgeTimerId != 0u)
{
viewTimerManager.KillViewTimer(this.expireBadgeTimerId);
}
if (!Service.IsSet <CurrentPlayer>())
{
return;
}
CrateData crateSoonestToExpire = this.GetCrateSoonestToExpire(time);
if (crateSoonestToExpire == null)
{
return;
}
uint expiresTimeStamp = crateSoonestToExpire.ExpiresTimeStamp;
uint num = expiresTimeStamp - time;
if (num <= 432000u)
{
this.expireBadgeTimerId = viewTimerManager.CreateViewTimer(num, false, new TimerDelegate(this.UpdateBadgesAfterCrateExpire), null);
}
}
private int SortCrateListByExpiration(UXElement a, UXElement b)
{
PrizeInventoryItemTag prizeInventoryItemTag = (PrizeInventoryItemTag)a.Tag;
CrateData crateData = this.cp.Prizes.Crates.Available[prizeInventoryItemTag.PrizeID];
PrizeInventoryItemTag prizeInventoryItemTag2 = (PrizeInventoryItemTag)b.Tag;
CrateData crateData2 = this.cp.Prizes.Crates.Available[prizeInventoryItemTag2.PrizeID];
if (!crateData.DoesExpire && !crateData2.DoesExpire)
{
return(0);
}
if (!crateData.DoesExpire)
{
return(1);
}
if (!crateData2.DoesExpire)
{
return(-1);
}
int num = (int)(crateData.ExpiresTimeStamp - crateData2.ExpiresTimeStamp);
if (num < 0)
{
return(-1);
}
if (num > 0)
{
return(1);
}
return(0);
}
private void ScheduleCrateExpireToast()
{
ViewTimerManager viewTimerManager = Service.Get <ViewTimerManager>();
uint num = (uint)(GameConstants.CRATE_EXPIRATION_WARNING_TOAST * 60);
uint time = ServerTime.Time;
uint afterTime = time + num;
if (this.expireToastTimerId != 0u)
{
viewTimerManager.KillViewTimer(this.expireToastTimerId);
}
if (!Service.IsSet <CurrentPlayer>())
{
return;
}
CrateData crateSoonestToExpire = this.GetCrateSoonestToExpire(afterTime);
if (crateSoonestToExpire == null)
{
return;
}
uint num2 = crateSoonestToExpire.ExpiresTimeStamp - num;
uint num3 = num2 - time;
if (num3 <= 432000u)
{
this.nextCrateExpireTime = crateSoonestToExpire.ExpiresTimeStamp;
this.expireToastTimerId = viewTimerManager.CreateViewTimer(num3, false, new TimerDelegate(this.AttemptShowCrateExpireToast), null);
}
}
private void SpawnExtraVanillaLoot(LootContainer container)
{
CrateData data = null;
int min = Convert.ToInt16(Config["ExtraLoot", "ExtraItemsMin"]);
int max = Convert.ToInt16(Config["ExtraLoot", "ExtraItemsMax"]);
int maxRarity = Convert.ToInt16(Config["ExtraLoot", "MaxRarity"]);
if (Crates.list.TryGetValue(container.ShortPrefabName.ToString(), out data) && data != null)
{
min += data.minExtraItems;
max += data.maxExtraItems;
}
int itemsToGive = UnityEngine.Random.Range(min, max);
int tempCapacity = container.inventory.capacity;
container.inventory.capacity = MAX_LOOT_CONTAINER_SLOTS;
container.inventorySlots = MAX_LOOT_CONTAINER_SLOTS;
SpawnItem(container, itemsToGive);
int fcapacity = Math.Max(tempCapacity, container.inventory.itemList.Count());
container.inventory.capacity = fcapacity;
container.inventorySlots = fcapacity;
}
public void OnViewClockTime(float dt)
{
int i = 0;
int count = this.itemGrid.Count;
while (i < count)
{
PrizeInventoryItemTag prizeInventoryItemTag = (PrizeInventoryItemTag)this.itemGrid.GetItem(i).Tag;
if (prizeInventoryItemTag.PrizeType == PrizeType.Crate)
{
CrateData crateData = this.cp.Prizes.Crates.Available[prizeInventoryItemTag.PrizeID];
if (crateData.DoesExpire)
{
if (crateData.ExpiresTimeStamp <= ServerTime.Time)
{
this.SetupCurTabElements();
return;
}
UXLabel subElement = this.itemGrid.GetSubElement <UXLabel>(prizeInventoryItemTag.PrizeID, "LabelItemExpiration");
UXUtils.SetCrateExpirationTimerLabel(crateData, subElement, this.lang);
}
}
i++;
}
}
public InventoryCrateCollectionScreen(InventoryCrateAnimation parent, CrateData crateData) : base("gui_supply_crate_celebration")
{
base.IsAlwaysOnTop = true;
this.crateData = crateData;
this.parent = parent;
this.pbarDelayTimerId = 0u;
}
// ----------------------------------------------------------------
// Initialize
// ----------------------------------------------------------------
public Crate(Board _boardRef, CrateData _data)
{
base.InitializeAsBoardOccupant(_boardRef, _data);
IsDimple = GameUtils.CopyBoolArray(_data.isDimple);
DoAutoMove = _data.doAutoMove;
AutoMoveDir = _data.autoMoveDir;
}
private void AddCrate(CrateData data)
{
Crate prop = new Crate(this, data);
allObjects.Add(prop);
objectsAddedThisMove.Add(prop);
}
private void SpawnExtraVanillaLoot(LootContainer container)
{
CrateData data = null;
int min = Convert.ToInt16(Config["ExtraLoot", "ExtraItemsMin"]);
int max = Convert.ToInt16(Config["ExtraLoot", "ExtraItemsMax"]);
if (Crates.list.TryGetValue(container.ShortPrefabName.ToString(), out data) && data != null)
{
min += data.minExtraItems;
max += data.maxExtraItems;
}
int itemsToGive = UnityEngine.Random.Range(min, max);
int tempCapacity = container.inventory.capacity;
container.inventory.capacity = MAX_LOOT_CONTAINER_SLOTS;
container.inventorySlots = MAX_LOOT_CONTAINER_SLOTS;
//Puts("subspawn length: " + container.lootDefinition.subSpawn.Length + " " + container + " give: " + itemsToGive + " min/max: " + Convert.ToInt16(Config["ExtraLoot", "ExtraItemsMin"]) + "/" + Convert.ToInt16(Config["ExtraLoot", "ExtraItemsMax"]));
//Puts("itemsToGive: " + itemsToGive + " min/max: " + min + "/" + max + " - " + container);
SpawnItem(container, itemsToGive);
int fcapacity = Math.Max(tempCapacity, container.inventory.itemList.Count());
container.inventory.capacity = fcapacity;
container.inventorySlots = fcapacity;
}
public static CrateInfoModalScreen CreateForInventory(CrateData crateData)
{
return(new CrateInfoModalScreen(crateData.CrateId, crateData.PlanetId, crateData.HQLevel)
{
crateData = crateData,
ModalReason = CrateInfoReason.Reason_Inventory_Open
});
}
public static CrateInfoModalScreen CreateForInventory(CrateData crateData)
{
return(new CrateInfoModalScreen(crateData.CrateId, crateData.PlanetId, crateData.HQLevel, Service.CurrentPlayer.Faction, ArmoryUtils.PlayerHasArmory())
{
crateData = crateData,
ModalReason = CrateInfoReason.Reason_Inventory_Open
});
}
public void ClaimCallback(CrateDataResponse response, object cookie)
{
if (response.CrateDataTO != null)
{
CrateData crateDataTO = response.CrateDataTO;
List <string> resolvedSupplyIdList = GameUtils.GetResolvedSupplyIdList(crateDataTO);
Service.InventoryCrateRewardController.GrantInventoryCrateReward(resolvedSupplyIdList, response.CrateDataTO);
}
}
void AddCrateData(int col, int row, int dimpleCorner, bool doAutoMove)
{
bool[] isDimple = new bool[Corners.NumCorners];
isDimple[dimpleCorner] = true;
CrateData newData = new CrateData(new BoardPos(col, row), isDimple, doAutoMove, Vector2Int.zero);
allObjectDatas.Add(newData);
SetOccupantInBoard(newData);
}
private void OnRewardSuccess(ClaimMobileConnectorAdsRewardResponse response, object cookie)
{
if (response.CrateDataTO != null)
{
ProcessingScreen.Show();
Service.EventManager.SendEvent(EventId.OpeningEpisodeTaskCrate, null);
CrateData crateDataTO = response.CrateDataTO;
List <string> resolvedSupplyIdList = GameUtils.GetResolvedSupplyIdList(crateDataTO);
Service.InventoryCrateRewardController.GrantInventoryCrateReward(resolvedSupplyIdList, crateDataTO);
}
}
public override ISerializable FromObject(object obj)
{
Dictionary <string, object> dictionary = obj as Dictionary <string, object>;
if (dictionary == null)
{
return(this);
}
this.CrateDataTO = new CrateData();
this.CrateDataTO.FromObject(dictionary);
return(this);
}
// ----------------------------------------------------------------
// Serializing
// ----------------------------------------------------------------
override public PropData ToData()
{
CrateData data = new CrateData {
pos = pos,
size = Size(),
hitsUntilBreak = hitsUntilBreak,
numCoinsInMe = numCoinsInMe,
travelMind = new TravelMindData(travelMind),
};
return(data);
}
public CrateData GetDailyCrateIfAvailable()
{
CrateData crateData = null;
foreach (CrateData current in this.Available.Values)
{
if (current.Context == "daily" && !current.Claimed && (crateData == null || current.ReceivedTimeStamp > crateData.ReceivedTimeStamp))
{
crateData = current;
}
}
return(crateData);
}
private UXElement CreateTileWithPrizeInfo(string id, int count, PrizeType prizeType)
{
string title = null;
string description = null;
DeployableShardUnlockController deployableShardUnlockController = Service.DeployableShardUnlockController;
IGeometryVO geometryVO = TimedEventPrizeUtils.GetFinalUnitFromPrize(prizeType, id);
int quality = 0;
switch (prizeType)
{
case PrizeType.Currency:
title = this.lang.Get(id.ToUpper(), new object[0]);
geometryVO = UXUtils.GetDefaultCurrencyIconVO(id);
break;
case PrizeType.Infantry:
case PrizeType.Hero:
case PrizeType.Vehicle:
case PrizeType.Mercenary:
{
TroopTypeVO troopTypeVO = (TroopTypeVO)geometryVO;
quality = deployableShardUnlockController.GetUpgradeQualityForDeployable(troopTypeVO);
title = LangUtils.GetTroopDisplayName(troopTypeVO);
description = LangUtils.GetTroopDescription(troopTypeVO);
break;
}
case PrizeType.SpecialAttack:
{
SpecialAttackTypeVO specialAttackTypeVO = (SpecialAttackTypeVO)geometryVO;
quality = deployableShardUnlockController.GetUpgradeQualityForDeployable(specialAttackTypeVO);
title = LangUtils.GetStarshipDisplayName(specialAttackTypeVO);
description = LangUtils.GetStarshipDescription(specialAttackTypeVO);
break;
}
case PrizeType.Crate:
{
CrateData crateData = this.cp.Prizes.Crates.Available[id];
string crateDisplayName = LangUtils.GetCrateDisplayName(crateData.CrateId);
title = this.lang.Get("CRATE_INVENTORY_CRATE_TITLE", new object[]
{
LangUtils.GetPlanetDisplayName(crateData.PlanetId),
crateDisplayName
});
geometryVO = Service.StaticDataController.Get <CrateVO>(crateData.CrateId);
break;
}
}
return(this.CreateInventoryGridItem(id, prizeType, title, description, count, geometryVO, quality));
}
private void ParseDataObjectIntoAvailable(object obj)
{
Dictionary <string, object> dictionary = obj as Dictionary <string, object>;
if (dictionary != null)
{
foreach (KeyValuePair <string, object> current in dictionary)
{
CrateData crateData = new CrateData();
crateData.FromObject(current.Value);
this.Available.Add(current.Key, crateData);
}
}
}
public static void SetCrateExpirationTimerLabel(CrateData crate, UXLabel expirationLabel, Lang lang)
{
if (!crate.DoesExpire)
{
expirationLabel.Text = lang.Get("CRATE_INVENTORY_CRATE_NO_EXPIRATION_TIMER", new object[0]);
expirationLabel.TextColor = UXUtils.COLOR_CRATE_EXPIRE_LABEL_NORMAL;
}
else
{
int thresholdSeconds = GameConstants.CRATE_INVENTORY_EXPIRATION_TIMER_WARNING * 60;
CountdownControl countdownControl = new CountdownControl(expirationLabel, lang.Get("CRATE_INVENTORY_CRATE_EXPIRATION_TIMER", new object[0]), (int)crate.ExpiresTimeStamp);
countdownControl.SetThreshold(thresholdSeconds, UXUtils.COLOR_CRATE_EXPIRE_LABEL_WARNING);
}
}
private CrateData GetCrateSoonestToExpire(uint afterTime)
{
InventoryCrates crates = Service.Get <CurrentPlayer>().Prizes.Crates;
CrateData crateData = null;
foreach (CrateData current in crates.Available.Values)
{
if (current.DoesExpire && current.ExpiresTimeStamp >= afterTime && (crateData == null || crateData.ExpiresTimeStamp > current.ExpiresTimeStamp))
{
crateData = current;
}
}
return(crateData);
}
public override ISerializable FromObject(object obj)
{
bool flag = true;
Dictionary <string, object> dictionary = obj as Dictionary <string, object>;
Dictionary <string, object> dictionary2 = dictionary["iap"] as Dictionary <string, object>;
Dictionary <string, object> dictionary3 = null;
bool isPromo = (bool)dictionary["isPromo"];
string currencyCode = "USD";
double price = 0.0;
string uid = "";
double num = 1.0;
string offerUid = null;
if (dictionary.ContainsKey("sale"))
{
dictionary3 = (dictionary["sale"] as Dictionary <string, object>);
}
if (dictionary3 != null && dictionary3.ContainsKey("bonusMultiplier"))
{
num = Convert.ToDouble(dictionary3["bonusMultiplier"], CultureInfo.InvariantCulture);
if (flag)
{
Service.Get <StaRTSLogger>().Debug("MoneyReceiptVerifyResponse: Bonus Multiplier: " + num);
}
}
if (dictionary2.ContainsKey("uid"))
{
uid = (dictionary2["uid"] as string);
}
if (dictionary2.ContainsKey("price"))
{
price = Convert.ToDouble(dictionary2["price"], CultureInfo.InvariantCulture);
}
if (dictionary.ContainsKey("targetedOffer"))
{
offerUid = (dictionary["targetedOffer"] as string);
}
if (dictionary.ContainsKey("crateData"))
{
this.crateDataTO = new CrateData();
this.crateDataTO.FromObject(dictionary["crateData"]);
}
KochavaPlugin.FireEvent("paymentAction", "1");
KochavaPlugin.FireEvent("revenueAmount", price.ToString());
if (this.Status == 0u)
{
Service.Get <InAppPurchaseController>().HandleReceiptVerificationResponse(uid, this.TransactionId, currencyCode, price, num, isPromo, offerUid, this.crateDataTO);
}
return(this);
}
private void AddCrates(List <UXElement> list)
{
uint time = ServerTime.Time;
foreach (KeyValuePair <string, CrateData> current in this.cp.Prizes.Crates.Available)
{
CrateData value = current.Value;
if (!value.Claimed && (!value.DoesExpire || value.ExpiresTimeStamp > time))
{
UXElement item = this.CreateTileWithPrizeInfo(current.Key, 1, PrizeType.Crate);
list.Add(item);
}
}
list.Sort(new Comparison <UXElement>(this.SortCrateListByExpiration));
}
public void HandleTargetedOfferSuccess(CrateData crateDataTO, TargetedBundleVO offerVO)
{
if (crateDataTO != null)
{
Service.Get <EventManager>().SendEvent(EventId.OpeningPurchasedCrate, null);
List <string> resolvedSupplyIdList = GameUtils.GetResolvedSupplyIdList(crateDataTO);
Service.Get <InventoryCrateRewardController>().GrantInventoryCrateReward(resolvedSupplyIdList, crateDataTO);
this.LogTargetedBundleBI("purchase_complete", offerVO);
}
else
{
TargetedBundleRewardedConfirmScreen screen = new TargetedBundleRewardedConfirmScreen(offerVO);
Service.Get <ScreenController>().AddScreen(screen);
}
this.ResetOffer();
}
private bool IsLootContainerEnabled(LootContainer container)
{
CrateData data = null;
if (!Crates.list.TryGetValue(container.ShortPrefabName.ToString(), out data) || data == null)
{
if (Convert.ToBoolean(Config["_Settings", "ReportMissingConfigCrates"]))
{
Puts("Auto added " + container.ShortPrefabName.ToString() + " to config.");
}
Crates.list.Add(container.ShortPrefabName.ToString(), new CrateData());
Config["LootContainersEnabled"] = Crates;
SaveConfig();
}
return(data != null && data.enabled);
}
public override ISerializable FromObject(object obj)
{
CurrentPlayer currentPlayer = Service.CurrentPlayer;
Dictionary <string, object> dictionary = obj as Dictionary <string, object>;
if (dictionary.ContainsKey("crateData"))
{
object obj2 = dictionary["crateData"];
this.CrateDataTO = new CrateData();
this.CrateDataTO.FromObject(obj2);
}
if (dictionary.ContainsKey("mcaInfo"))
{
object rawMCAInfo = dictionary["mcaInfo"];
currentPlayer.UpdateMobileConnectorAdsInfo(rawMCAInfo);
}
return(this);
}
public override ISerializable FromObject(object obj)
{
Dictionary <string, object> dictionary = obj as Dictionary <string, object>;
if (dictionary.ContainsKey("episodeProgressInfo"))
{
object rawEpisodeProgressInfo = dictionary["episodeProgressInfo"];
CurrentPlayer currentPlayer = Service.CurrentPlayer;
currentPlayer.UpdateEpisodeProgressInfo(rawEpisodeProgressInfo);
}
if (dictionary.ContainsKey("crateData"))
{
object obj2 = dictionary["crateData"];
this.CrateDataTO = new CrateData();
this.CrateDataTO.FromObject(obj2);
}
Service.EpisodeController.ForceRefreshState();
return(this);
}
private void OnTileClicked(UXButton button)
{
PrizeInventoryItemTag prizeInventoryItemTag = button.Tag as PrizeInventoryItemTag;
if (prizeInventoryItemTag.InfoLabel.Visible)
{
prizeInventoryItemTag.InfoLabel.Visible = false;
prizeInventoryItemTag.MainElement.Visible = true;
return;
}
if (prizeInventoryItemTag.PrizeType == PrizeType.None)
{
Service.Get <EventManager>().SendEvent(EventId.InventoryCrateStoreOpen, prizeInventoryItemTag.IconAssetName);
Service.Get <ScreenController>().CloseAll();
GameUtils.OpenStoreTreasureTab();
return;
}
if (prizeInventoryItemTag.PrizeType == PrizeType.Crate)
{
button.Enabled = false;
CrateData crateData = this.cp.Prizes.Crates.Available[prizeInventoryItemTag.PrizeID];
GameUtils.OpenInventoryCrateModal(crateData, new OnScreenModalResult(this.OnCrateInfoModalClosed));
Service.Get <EventManager>().SendEvent(EventId.InventoryCrateTapped, crateData.CrateId + "|" + crateData.UId);
return;
}
int num = TimedEventPrizeUtils.TransferPrizeFromInventory(prizeInventoryItemTag.PrizeType, prizeInventoryItemTag.PrizeID);
if (num > 0)
{
prizeInventoryItemTag.CountLabel.Text = string.Format("x{0}", new object[]
{
num
});
}
else if (num == 0)
{
this.itemGrid.RemoveItem(prizeInventoryItemTag.TileElement);
base.DestroyElement(prizeInventoryItemTag.TileElement);
this.itemGrid.RepositionItems();
}
this.ToggleEmptyTabMessage();
}
private NotificationObject GetInventoryCrateExpirationNotification()
{
uint time = ServerTime.Time;
CurrentPlayer currentPlayer = Service.Get <CurrentPlayer>();
InventoryCrates crates = currentPlayer.Prizes.Crates;
uint num = (uint)(GameConstants.CRATE_EXPIRATION_WARNING_NOTIF * 60);
uint cRATE_EXPIRATION_WARNING_NOTIF_MINIMUM = (uint)GameConstants.CRATE_EXPIRATION_WARNING_NOTIF_MINIMUM;
CrateData nextInventoryCrateToExpire = GameUtils.GetNextInventoryCrateToExpire(crates, time + cRATE_EXPIRATION_WARNING_NOTIF_MINIMUM);
if (nextInventoryCrateToExpire == null)
{
return(null);
}
uint expiresTimeStamp = nextInventoryCrateToExpire.ExpiresTimeStamp;
uint num2 = expiresTimeStamp - time;
if (num2 > num)
{
num2 -= num;
if (num2 < num)
{
num2 = num;
}
}
else
{
num2 = 10u;
}
string text = "crate_expiration_warning";
NotificationTypeVO notificationTypeVO = Service.Get <IDataController>().Get <NotificationTypeVO>(text);
string id = "notif_" + text;
string message = this.lang.Get(id, new object[0]);
string inProgressMessage = this.lang.Get("notif_" + text + "_progress", new object[0]);
DateTime time2 = DateTime.get_Now().AddSeconds(num2);
if (!this.CheckValidNotificationTime(notificationTypeVO, time2))
{
return(null);
}
return(new NotificationObject(text, inProgressMessage, message, notificationTypeVO.SoundName, time2, text, text));
}
