public LootCrateRewardQueueElement(LootCrateType _lootCrateType, LootCrate.AnalyticData _data, int _xp)
{
this.lootCrateType = _lootCrateType;
this.data = _data;
this.isRewarded = false;
this.xp = _xp;
}
private bool LoadDefaultProgram(string rawData)
{
Hashtable hashtable;
if (this.DecodeJson(rawData, out hashtable))
{
this.defaultProgram = new Dictionary <DayOfWeek, LootCrateType[]>();
IEnumerator enumerator = hashtable.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
DayOfWeek key = (DayOfWeek)int.Parse(obj as string);
ArrayList arrayList = hashtable[obj] as ArrayList;
LootCrateType[] array = new LootCrateType[arrayList.Count];
for (int i = 0; i < arrayList.Count; i++)
{
array[i] = (LootCrateType)Convert.ChangeType(arrayList[i], typeof(int));
}
this.defaultProgram.Add(key, array);
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
return(true);
}
return(false);
}
private static void Initialize(string rawData)
{
Hashtable hashtable = MiniJSON.jsonDecode(rawData) as Hashtable;
ArrayList arrayList = hashtable["data"] as ArrayList;
int num = Enum.GetNames(typeof(LootCrateType)).Length - 1;
IEnumerator enumerator = arrayList.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
Hashtable data = (Hashtable)obj;
Slot slot = new Slot(data);
for (int i = 0; i < num; i++)
{
LootCrateType lootCrateType = (LootCrateType)i;
if (slot.ForLootCrate(lootCrateType))
{
LootCrateRewards.Slots[lootCrateType].Add(slot);
}
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
LootCrateRewards.initialized = true;
}
public static void InformCrateOpened(string identifier, LootCrateType crateType)
{
if (LootCrateSlots.instance != null)
{
LootCrateSlots.instance.ShowFullBubble(LootCrateSlots.AreSlotsFull());
}
}
public void SetRewards(LootCrateType crateType, int snoutCoins)
{
TextMeshHelper.UpdateTextMeshes(this.coinRewardLabel, snoutCoins.ToString(), false);
for (int i = 0; i < this.rewardCrateContainer.childCount; i++)
{
Transform child = this.rewardCrateContainer.GetChild(i);
child.gameObject.SetActive(child.name.Equals(crateType.ToString()));
}
}
public static GameObject GetCratePrefab(LootCrateType crateType)
{
GameObject[] array = WPFMonoBehaviour.gameData.m_lootCrateLargeIcons.ToArray();
if (crateType >= LootCrateType.Wood && crateType < (LootCrateType)array.Length)
{
return(array[(int)crateType]);
}
return(null);
}
public static LootCrateType GetSeasonCrateReward(int cupIndex, int rank)
{
LootCrateType result = LootCrateType.None;
if (rank > 0 && rank <= 5 && Singleton <GameConfigurationManager> .Instance.HasValue("cake_race_cup_crate_rewards", cupIndex.ToString()))
{
result = (LootCrateType)Singleton <GameConfigurationManager> .Instance.GetValue <int>("cake_race_cup_crate_rewards", cupIndex.ToString());
}
return(result);
}
private void SpawnCrateIcon(LootCrateType type)
{
GameObject go = LootCrateGraphicSpawner.CreateCrateSilhouette(type, base.transform, Vector3.zero, Vector3.one, Quaternion.identity);
LayerHelper.SetLayer(go, base.gameObject.layer, true);
GameObject go2 = LootCrateGraphicSpawner.CreateCrateSmall(type, base.transform, Vector3.back * 0.1f, Vector3.one, Quaternion.identity);
LayerHelper.SetLayer(go2, base.gameObject.layer, true);
this.shine.SetActive(true);
}
public static void InformCrateUnlocked(string identifier, LootCrateType crateType, int snoutCoinCost = 0)
{
if (GameProgress.GetString("LootCrateSlotOpening", string.Empty, GameProgress.Location.Local, null).Equals(identifier))
{
GameProgress.DeleteKey("LootCrateSlotOpening", GameProgress.Location.Local);
}
if (LootCrateSlots.instance != null)
{
LootCrateSlots.instance.SendLootCrateUnlockedFlurryEvent(crateType, snoutCoinCost, "default");
}
}
public void Init(LootCrateType crateType)
{
this.openIndex = -1;
this.hitCounter = 0;
this.collider.enabled = true;
this.lootCrateType = crateType;
int num = (int)this.lootCrateType;
this.skeletonAnimation.initialSkinName = this.skinNames[num];
this.skeletonAnimation.Initialize(true);
this.skeletonAnimation.state.Event -= this.OnAnimationEvent;
this.skeletonAnimation.state.Event += this.OnAnimationEvent;
}
public static SlotRewards[] GetRandomRewards(LootCrateType type)
{
if (type == LootCrateType.None)
{
return(null);
}
SlotRewards[] array = new SlotRewards[LootCrateRewards.Slots[type].Count];
for (int i = 0; i < LootCrateRewards.Slots[type].Count; i++)
{
array[i] = LootCrateRewards.Slots[type][i].GetRewards();
}
return(array);
}
private void GetPossibleLevels(LootCrateType type, out List <ChallengeInfo> unlockedLevels, out List <ChallengeInfo> lockedLevels1, out List <ChallengeInfo> lockedLevels2, out List <ChallengeInfo> unlockedJokerLevels, out List <ChallengeInfo> lockedJokerLevels)
{
int num = this.challengeConfigs.MaxUnlockDistance1(type);
int num2 = this.challengeConfigs.MaxUnlockDistance2(type);
unlockedLevels = new List <ChallengeInfo>();
lockedLevels1 = new List <ChallengeInfo>();
lockedLevels2 = new List <ChallengeInfo>();
unlockedJokerLevels = new List <ChallengeInfo>();
lockedJokerLevels = new List <ChallengeInfo>();
if (!this.FirstChallengeCollected && !this.IsDailyChallenge(0, 0, 0))
{
unlockedLevels.Add(new ChallengeInfo(LevelInfo.GetLevelNames(0)[0], 0, 0));
return;
}
for (int i = 0; i < 6; i++)
{
List <string> levelNames = LevelInfo.GetLevelNames(i);
int num3 = 0;
for (int j = 0; j < levelNames.Count; j++)
{
if (LevelInfo.IsStarLevel(i, j) && LevelInfo.IsLevelUnlocked(i, j))
{
unlockedJokerLevels.Add(new ChallengeInfo(levelNames[j], i, j));
}
else if (LevelInfo.IsStarLevel(i, j) && !LevelInfo.IsLevelUnlocked(i, j))
{
num3++;
lockedJokerLevels.Add(new ChallengeInfo(levelNames[j], i, j));
}
else if (LevelInfo.IsLevelUnlocked(i, j))
{
unlockedLevels.Add(new ChallengeInfo(levelNames[j], i, j));
}
else if (num3 < num)
{
num3++;
lockedLevels1.Add(new ChallengeInfo(levelNames[j], i, j));
}
else
{
num3++;
lockedLevels2.Add(new ChallengeInfo(levelNames[j], i, j));
}
if (num3 >= num && num3 >= num2)
{
break;
}
}
}
}
public static int GetSnoutCoinPrice(LootCrateType crateType, float timeLeft)
{
string valueKey = crateType.ToString();
int num = 0;
if (Singleton <GameConfigurationManager> .Instance.HasValue("lootcrate_open_hour_rates", valueKey))
{
num = Singleton <GameConfigurationManager> .Instance.GetValue <int>("lootcrate_open_hour_rates", valueKey);
}
if (num <= 0)
{
num = 15;
}
return((int)Mathf.Clamp((float)num * (timeLeft / 3600f), 2f, 9999f));
}
public void SetRewards(LootCrateType crateType, int coinAmount)
{
for (int i = 0; i < this.crateIcons.Length; i++)
{
if (this.crateIcons[i] != null)
{
this.crateIcons[i].SetActive(crateType != LootCrateType.None && i == Mathf.Clamp((int)crateType, 0, 6));
}
}
if (this.coinPrizeContainer != null)
{
TextMeshHelper.UpdateTextMeshes(this.coinPrizeLabel, coinAmount.ToString(), false);
this.coinPrizeContainer.gameObject.SetActive(coinAmount > 0);
}
}
public UnlockLootCrateSlotDialog ShowNoFreeSlotsDialog(LootCrateType crateType, TextDialog.OnConfirm onConfirm)
{
if (WPFMonoBehaviour.gameData.m_noFreeCrateSlotsPopup == null)
{
return(null);
}
UnlockLootCrateSlotDialog component = UnityEngine.Object.Instantiate <GameObject>(WPFMonoBehaviour.gameData.m_noFreeCrateSlotsPopup).GetComponent <UnlockLootCrateSlotDialog>();
component.Open();
component.SetOnConfirm(onConfirm);
int openTimeForCrate = LootCrateSlots.GetOpenTimeForCrate(crateType);
component.InitPopup(LootCrateSlot.GetSnoutCoinPrice(crateType, (float)openTimeForCrate), openTimeForCrate, LootCrateSlots.GetCratePrefab(crateType), crateType);
return(component);
}
public int MaxUnlockDistance2(LootCrateType type)
{
switch (type)
{
case LootCrateType.Wood:
case LootCrateType.Bronze:
return(this.maxUnlockDistance2[LootCrateType.Metal]);
case LootCrateType.Metal:
case LootCrateType.Gold:
case LootCrateType.Marble:
return(this.maxUnlockDistance2[LootCrateType.Gold]);
default:
return(this.maxUnlockDistance2[LootCrateType.Wood]);
}
}
public static List <Tuple <Reward, BasePart.PartTier> > MinimumRewards(LootCrateType type)
{
List <Tuple <Reward, BasePart.PartTier> > list = new List <Tuple <Reward, BasePart.PartTier> >();
if (!LootCrateRewards.initialized)
{
return(list);
}
List <Slot> list2 = LootCrateRewards.slots[type];
for (int i = 0; i < list2.Count; i++)
{
list.Add(list2[i].MinimumReward());
}
list.Sort(new RewardSorter <Tuple <Reward, BasePart.PartTier> >());
return(list);
}
public float GetLockedJokerLevelChanche(LootCrateType type)
{
switch (type)
{
case LootCrateType.Wood:
case LootCrateType.Bronze:
return(this.lockedJokerLevelChance[LootCrateType.Metal]);
case LootCrateType.Metal:
case LootCrateType.Gold:
case LootCrateType.Marble:
return(this.lockedJokerLevelChance[LootCrateType.Gold]);
default:
return(this.lockedJokerLevelChance[LootCrateType.Wood]);
}
}
public void Initialize(bool isNew, int index, LootCrateType crateType)
{
this.FindComponents();
this.index = index;
this.crateType = crateType;
this.identifier = LootCrateSlot.GetSlotIdentifier(index);
this.hasTimer = false;
if (isNew)
{
LootCrateSlots.AddLootCrateToSlot(index, crateType);
this.ChangeState(LootCrateSlot.State.Inactive);
}
else
{
this.TryRecover();
}
}
public static LootCrateOpenDialog SpawnLootCrateOpeningDialog(LootCrateType crateType, int amount, Camera hudCamera, Dialog.OnClose onClose, AnalyticData data)
{
if (Singleton <GameManager> .Instance.GetGameState() == GameManager.GameState.Undefined)
{
return(null);
}
LootCrateOpenDialog lootCrateOpenDialog = LootCrateOpenDialog.CreateLootCrateOpenDialog();
if (lootCrateOpenDialog != null && hudCamera != null)
{
lootCrateOpenDialog.transform.position = hudCamera.transform.position + Vector3.forward * 2.5f;
lootCrateOpenDialog.gameObject.SetActive(true);
lootCrateOpenDialog.onClose += onClose;
lootCrateOpenDialog.AddLootCrate(crateType, amount, data, false, 0);
}
return(lootCrateOpenDialog);
}
public static void AddLootCrateToFreeSlot(LootCrateType crateType)
{
for (int i = 0; i < LootCrateSlots.SlotsAvailable; i++)
{
if (!LootCrateSlots.IsSlotOccupied(i))
{
LootCrateSlots.AddLootCrateToSlot(i, crateType);
int num = GameProgress.GetInt("loot_crates_added_to_slots", 0, GameProgress.Location.Local, null);
GameProgress.SetInt("loot_crates_added_to_slots", ++num, GameProgress.Location.Local);
if (LootCrateSlots.instance != null)
{
LootCrateSlots.instance.ShowFullBubble(LootCrateSlots.AreSlotsFull());
}
return;
}
}
LootCrateSlots.overflowCrateType = crateType;
}
public void ShowUnlockDialog(LootCrateType crateType, int price, int timeLeft, TextDialog.OnConfirm onConfirm, UnlockLootCrateSlotDialog.UnlockType unlockType)
{
if (Singleton <BuildCustomizationLoader> .Instance.IsOdyssey)
{
return;
}
if (this.unlockCrateSlotDialogPrefab == null)
{
return;
}
if (this.unlockCrateSlotDialog == null)
{
this.unlockCrateSlotDialog = UnityEngine.Object.Instantiate <GameObject>(this.unlockCrateSlotDialogPrefab).GetComponent <UnlockLootCrateSlotDialog>();
}
this.unlockCrateSlotDialog.Open();
this.unlockCrateSlotDialog.SetInfoLabel(unlockType);
this.unlockCrateSlotDialog.SetOnConfirm(onConfirm);
this.unlockCrateSlotDialog.InitPopup(price, timeLeft, LootCrateSlots.GetCratePrefab(crateType), crateType);
}
public static GameObject CreateCrateSmall(LootCrateType type, Transform parent, Vector3 localPosition, Vector3 localScale, Quaternion localRotation)
{
if (LootCrateGraphicSpawner.Instance == null)
{
return(null);
}
GameObject prefab;
switch (type)
{
case LootCrateType.Wood:
prefab = LootCrateGraphicSpawner.Instance.woodCrateSmall;
break;
case LootCrateType.Metal:
prefab = LootCrateGraphicSpawner.Instance.metalCrateSmall;
break;
case LootCrateType.Gold:
prefab = LootCrateGraphicSpawner.Instance.goldCrateSmall;
break;
case LootCrateType.Cardboard:
prefab = LootCrateGraphicSpawner.Instance.cardboardCrateSmall;
break;
case LootCrateType.Glass:
prefab = LootCrateGraphicSpawner.Instance.glassCrateSmall;
break;
case LootCrateType.Bronze:
prefab = LootCrateGraphicSpawner.Instance.bronzeCrateSmall;
break;
case LootCrateType.Marble:
prefab = LootCrateGraphicSpawner.Instance.marbleCrateSmall;
break;
default:
return(null);
}
return(LootCrateGraphicSpawner.CreateObject(prefab, parent, localPosition, localScale, localRotation));
}
private void Awake()
{
LootCrateSlots.instance = this;
List <LootCrateSlot> list = new List <LootCrateSlot>();
for (int i = 0; i < this.slotCount; i++)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.lootCrateSlotPrefab);
if (gameObject != null)
{
gameObject.name = string.Format("Slot{0}", i + 1);
gameObject.transform.parent = base.transform;
LootCrateSlot component = gameObject.GetComponent <LootCrateSlot>();
component.Initialize(false, i, LootCrateType.None);
list.Add(component);
}
}
this.slots = list.ToArray();
LootCrateSlots.SlotsAvailable = this.slots.Length;
GridLayout component2 = base.GetComponent <GridLayout>();
component2.UpdateLayout();
if (this.slotsFullBubble != null)
{
this.slotsFullBubble.transform.position = this.slots[this.slotCount - 1].transform.position;
}
this.ShowFullBubble(LootCrateSlots.AreSlotsFull());
if (LootCrateSlots.overflowCrateType != LootCrateType.None)
{
LootCrateType crateType = LootCrateSlots.overflowCrateType;
this.unlockCrateSlotDialog = this.ShowNoFreeSlotsDialog(crateType, delegate
{
if (this.unlockCrateSlotDialog != null && GameProgress.UseSnoutCoins(this.unlockCrateSlotDialog.SnoutCoinPrice))
{
Singleton <AudioManager> .Instance.Spawn2dOneShotEffect(WPFMonoBehaviour.gameData.commonAudioCollection.snoutCoinUse);
LootCrate.SpawnLootCrateOpeningDialog(crateType, 1, WPFMonoBehaviour.hudCamera, null, new LootCrate.AnalyticData("CakeRaceOverflowUnlock", this.unlockCrateSlotDialog.SnoutCoinPrice.ToString(), LootCrate.AdWatched.NotApplicaple));
this.SendLootCrateUnlockedFlurryEvent(crateType, this.unlockCrateSlotDialog.SnoutCoinPrice, "overflow");
}
});
LootCrateSlots.overflowCrateType = LootCrateType.None;
}
}
public static int GetOpenTimeForCrate(LootCrateType crateType)
{
string valueKey = crateType.ToString();
if (Singleton <GameConfigurationManager> .Instance.HasValue("lootcrate_open_times", valueKey))
{
int value = Singleton <GameConfigurationManager> .Instance.GetValue <int>("lootcrate_open_times", valueKey);
if (value > 0)
{
return(value);
}
}
switch (crateType)
{
case LootCrateType.Wood:
return(LootCrateSlots.HoursToSeconds(8f));
case LootCrateType.Metal:
return(LootCrateSlots.HoursToSeconds(24f));
case LootCrateType.Gold:
return(LootCrateSlots.HoursToSeconds(48f));
case LootCrateType.Cardboard:
return(LootCrateSlots.HoursToSeconds(2f));
case LootCrateType.Glass:
return(LootCrateSlots.HoursToSeconds(4f));
case LootCrateType.Bronze:
return(LootCrateSlots.HoursToSeconds(16f));
case LootCrateType.Marble:
return(LootCrateSlots.HoursToSeconds(28f));
default:
return(LootCrateSlots.HoursToSeconds(72f));
}
}
private bool LoadSpecialDays(string rawData)
{
if (string.IsNullOrEmpty(rawData))
{
return(true);
}
Hashtable hashtable;
if (this.DecodeJson(rawData, out hashtable))
{
this.specialDays = new Dictionary <DateTime, LootCrateType[]>();
IEnumerator enumerator = hashtable.Keys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
DateTime key = new DateTime(long.Parse(obj as string));
ArrayList arrayList = hashtable[obj] as ArrayList;
LootCrateType[] array = new LootCrateType[arrayList.Count];
for (int i = 0; i < arrayList.Count; i++)
{
array[i] = (LootCrateType)Convert.ChangeType(arrayList[i], typeof(int));
}
this.specialDays.Add(key, array);
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
return(true);
}
return(false);
}
public void ChangeLootCrate()
{
LootCrateType lootCrateType = Singleton <DailyChallenge> .Instance.TodaysLootCrate(0);
if (lootCrateType != LootCrateType.Wood)
{
if (lootCrateType != LootCrateType.Metal)
{
if (lootCrateType == LootCrateType.Gold)
{
Singleton <DailyChallenge> .Instance.SetDailyLootCrate(LootCrateType.Wood);
}
}
else
{
Singleton <DailyChallenge> .Instance.SetDailyLootCrate(LootCrateType.Gold);
}
}
else
{
Singleton <DailyChallenge> .Instance.SetDailyLootCrate(LootCrateType.Metal);
}
}
public void SetCrateRankAndReward(LootCrateType crateType, int rank, int reward)
{
this.reward = reward;
Localizer.LocaleParameters localeParameters = Singleton <Localizer> .Instance.Resolve(this.rankLocalizationKey, null);
TextMeshHelper.UpdateTextMeshes(this.rankLabel, string.Format(localeParameters.translation, rank), false);
TextMeshHelper.Wrap(this.rankLabel, 15);
Localizer.LocaleParameters localeParameters2 = Singleton <Localizer> .Instance.Resolve(this.snoutRewardLocalizationKey, null);
TextMeshHelper.UpdateTextMeshes(this.rewardLabel, string.Format(localeParameters2.translation, reward), false);
TextMeshSpriteIcons.EnsureSpriteIcon(this.rewardLabel);
TextMeshHelper.Wrap(this.rewardLabel, 15);
this.lootCrate.gameObject.SetActive(crateType != LootCrateType.None);
this.barrelContainer.SetActive(crateType == LootCrateType.None);
if (crateType != LootCrateType.None)
{
this.lootCrate.initialSkinName = crateType.ToString();
this.lootCrate.Initialize(true);
this.lootCrate.state.SetAnimation(0, "Idle", true);
this.lootCrate.Update(Time.deltaTime);
}
this.SetLoading(false);
}
public void InitPopup(int price, int secondsLeft, GameObject cratePrefab, LootCrateType lootCrate)
{
this.currentCrateType = lootCrate;
this.SnoutCoinPrice = price;
if (this.priceLabel)
{
TextMesh[] componentsInChildren = this.priceLabel.gameObject.GetComponentsInChildren <TextMesh>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].text = string.Format("[snout] {0}", this.SnoutCoinPrice);
TextMeshSpriteIcons.EnsureSpriteIcon(componentsInChildren[i]);
}
}
string formattedTimeFromSeconds = LootCrateSlot.GetFormattedTimeFromSeconds(secondsLeft);
if (this.timerLabel)
{
TextMesh[] componentsInChildren2 = this.timerLabel.gameObject.GetComponentsInChildren <TextMesh>();
TextMeshHelper.UpdateTextMeshes(componentsInChildren2, formattedTimeFromSeconds, false);
}
if (this.unlockNowControls != null)
{
Transform transform = this.unlockNowControls.transform.Find("StartUnlockButton/TimeLabel");
if (transform != null)
{
TextMesh[] componentsInChildren3 = transform.gameObject.GetComponentsInChildren <TextMesh>();
TextMeshHelper.UpdateTextMeshes(componentsInChildren3, formattedTimeFromSeconds, false);
}
}
if (this.skeletonAnimation)
{
this.skeletonAnimation.initialSkinName = lootCrate.ToString();
this.skeletonAnimation.Initialize(true);
this.skeletonAnimation.state.AddAnimation(0, "Idle", true, 0f);
}
this.InitRewardItems(lootCrate);
}
private void RewardCrate(int rewardIndex)
{
LootCrateType lootCrateType = LootCrateType.Cardboard;
if (Singleton <GameConfigurationManager> .Instance.HasValue("cake_race", "loot_crates"))
{
string[] array = Singleton <GameConfigurationManager> .Instance.GetValue <string>("cake_race", "loot_crates").Split(new char[]
{
','
});
int num = rewardIndex % array.Length;
int num2;
if (array != null && array.Length > 0 && num >= 0 && int.TryParse(array[num], out num2))
{
lootCrateType = (LootCrateType)num2;
}
}
CakeRaceMode.CurrentRewardCrate = lootCrateType;
if (lootCrateType != LootCrateType.None)
{
LootCrateSlots.AddLootCrateToFreeSlot(lootCrateType);
}
}
