public static List <BasePart> GetCustomParts(BasePart.PartType type, bool onlyLocked = false)
{
List <BasePart> list = new List <BasePart>();
List <CustomPartInfo> customParts = WPFMonoBehaviour.gameData.m_customParts;
for (int i = 0; i < customParts.Count; i++)
{
if (customParts[i].PartType == type)
{
for (int j = 0; j < customParts[i].PartList.Count; j++)
{
if (onlyLocked && !CustomizationManager.IsPartUnlocked(customParts[i].PartList[j]))
{
list.Add(customParts[i].PartList[j]);
}
else if (!onlyLocked)
{
list.Add(customParts[i].PartList[j]);
}
}
break;
}
}
return(list);
}
public static int GetUnlockedPartCount(bool useTier = false, BasePart.PartTier tier = BasePart.PartTier.Common)
{
int num = 0;
if (!useTier)
{
num = CustomizationManager.cachedUnlockedPartCount;
}
if (num < 0 || useTier)
{
num = 0;
List <CustomPartInfo> customParts = WPFMonoBehaviour.gameData.m_customParts;
for (int i = 0; i < customParts.Count; i++)
{
if (customParts[i] != null && customParts[i].PartList != null && customParts[i].PartList.Count != 0)
{
for (int j = 0; j < customParts[i].PartList.Count; j++)
{
if (CustomizationManager.IsPartUnlocked(customParts[i].PartList[j]) && (!useTier || (useTier && customParts[i].PartList[j].m_partTier == tier)))
{
num++;
}
}
}
}
}
if (!useTier)
{
CustomizationManager.cachedUnlockedPartCount = num;
}
return(num);
}
private void CheckDuplicateParts()
{
ConfigData config = Singleton <GameConfigurationManager> .Instance.GetConfig("part_salvage_rewards");
for (int i = 0; i < this.m_rewards.Length; i++)
{
if (CustomizationManager.IsPartUnlocked(this.m_rewards[i].PartReward))
{
int amount = int.Parse(config[this.m_rewards[i].PartReward.m_partTier.ToString()]);
this.m_rewards[i] = new LootWheelRewards.LootWheelReward(amount, this.m_rewards[i].SingleValue, LootWheelRewards.RewardType.Scrap);
}
}
}
public void InitButtons(PartListing partListing, Action <BasePart.PartType> onButtonPressed)
{
this.cachedPartListing = partListing;
this.onButtonPressed = onButtonPressed;
if (this.initButtonsDone)
{
return;
}
if (this.customPartWidget != null)
{
Transform transform = this.cachedPartListing.transform.Find("Close");
if (transform)
{
this.customPartWidget.closeButton = transform.GetComponent <Button>();
}
}
for (int i = 0; i < Enum.GetNames(typeof(BasePart.PartType)).Length; i++)
{
for (int j = 0; j < Enum.GetNames(typeof(BasePart.PartTier)).Length; j++)
{
BasePart.PartType partType = (BasePart.PartType)i;
List <GameObject> partTierInstances = this.cachedPartListing.GetPartTierInstances(partType, (BasePart.PartTier)j);
if (partTierInstances != null)
{
for (int k = 0; k < partTierInstances.Count; k++)
{
bool enabled = j == 0;
int customPartIndex = WPFMonoBehaviour.gameData.GetCustomPartIndex(partType, partTierInstances[k].name);
if (j > 0)
{
enabled = CustomizationManager.IsPartUnlocked(WPFMonoBehaviour.gameData.GetCustomPart(partType, customPartIndex));
}
BoxCollider component = partTierInstances[k].GetComponent <BoxCollider>();
if (component != null)
{
component.enabled = enabled;
Button component2 = partTierInstances[k].GetComponent <Button>();
component2.MethodToCall.SetMethod(this, "CustomButtonPressed", new object[]
{
i,
customPartIndex
});
}
}
}
}
}
this.cachedPartListing.CreateSelectionIcons();
this.initButtonsDone = true;
}
public static void UnlockPart(BasePart part, string unlockType)
{
if (CustomizationManager.IsPartUnlocked(part))
{
return;
}
CustomizationManager.cachedUnlockedPartCount = -1;
GameProgress.SetBool(part.name, true, GameProgress.Location.Local);
CustomizationManager.SetPartNew(part, true);
CustomizationManager.SetPartUsed(part, false);
CustomizationManager.CheckUnlockPartAchievements();
if (CustomizationManager.OnPartUnlocked != null)
{
CustomizationManager.OnPartUnlocked(part);
}
}
public static int UnlockablesLeft()
{
int num = 0;
if (!AlienCustomizationManager.s_initialized)
{
return(0);
}
for (int i = 0; i < AlienCustomizationManager.s_unlockOrder.Count; i++)
{
if (!CustomizationManager.IsPartUnlocked(AlienCustomizationManager.s_unlockOrder[i]))
{
num++;
}
}
return(num);
}
public static bool GetNextUnlockable(out BasePart part)
{
part = null;
if (!AlienCustomizationManager.s_initialized)
{
return(false);
}
for (int i = 0; i < AlienCustomizationManager.s_unlockOrder.Count; i++)
{
if (!CustomizationManager.IsPartUnlocked(AlienCustomizationManager.s_unlockOrder[i]))
{
part = AlienCustomizationManager.s_unlockOrder[i];
break;
}
}
return(part != null);
}
private static bool HasPartFlags(BasePart part, PartFlags flags)
{
if (part == null)
{
return(false);
}
PartFlags partFlags = CustomizationManager.PartFlags.None;
if (!CustomizationManager.IsPartUnlocked(part))
{
partFlags |= CustomizationManager.PartFlags.Locked;
}
if (part.craftable)
{
partFlags |= CustomizationManager.PartFlags.Craftable;
}
if (part.lootCrateReward)
{
partFlags |= CustomizationManager.PartFlags.Rewardable;
}
return((partFlags & flags) == flags);
}
public void AddLootCrate(LootCrateType lootCrateType, int amount, LootCrate.AnalyticData data, bool fromQueue = false, int xp = 0)
{
if (this.lootcrateRewardQueue == null)
{
this.lootcrateRewardQueue = new Queue <LootCrateRewardQueueElement>();
}
if (this.lootCrateAnimation != null)
{
if (this.lootCrateAnimationInstance == null)
{
this.lootCrateAnimationInstance = UnityEngine.Object.Instantiate <GameObject>(this.lootCrateAnimation, Vector3.up * 1000f, Quaternion.identity);
}
else
{
this.lootCrateAnimationInstance.SetActive(true);
}
this.lootCrateAnimationInstance.transform.parent = base.transform;
LootCrateRewardQueueElement lootCrateRewardQueueElement = null;
if (!fromQueue)
{
bool flag = this.lootcrateRewardQueue.Count == 0;
for (int i = 0; i < amount; i++)
{
lootCrateRewardQueueElement = new LootCrateRewardQueueElement(lootCrateType, data, xp);
this.lootcrateRewardQueue.Enqueue(lootCrateRewardQueueElement);
}
if (!flag)
{
return;
}
}
else
{
lootCrateRewardQueueElement = this.lootcrateRewardQueue.Peek();
}
this.closeButton.SetActive(false);
this.closeButtonGfx.SetActive(false);
this.crateOpened = false;
LootCrateRewards.SlotRewards[] randomRewards = LootCrateRewards.GetRandomRewards(lootCrateType);
if (randomRewards == null)
{
return;
}
int num = 0;
LootCrateButton componentInChildren = this.lootCrateAnimationInstance.GetComponentInChildren <LootCrateButton>();
componentInChildren.GainedXP = lootCrateRewardQueueElement.xp;
componentInChildren.Init(lootCrateType);
LootCrateButton lootCrateButton = componentInChildren;
lootCrateButton.onOpeningDone = (Action)Delegate.Combine(lootCrateButton.onOpeningDone, new Action(delegate()
{
base.StartCoroutine(this.CrateOpened());
}));
base.StartCoroutine(this.DelayIntro(componentInChildren, Vector3.forward * -1f));
List <BasePart> list = new List <BasePart>();
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
int num7 = 0;
List <int> list2 = new List <int>();
for (int j = 0; j < randomRewards.Length; j++)
{
int num8 = UnityEngine.Random.Range(0, randomRewards.Length);
int num9 = randomRewards.Length;
while (list2.Contains(num8) && num9 >= 0)
{
if (++num8 >= randomRewards.Length)
{
num8 = 0;
}
num9--;
}
if (num9 >= 0)
{
list2.Add(num8);
LootCrateRewards.SlotRewards reward = randomRewards[num8];
LootCrateRewards.Reward type = reward.Type;
switch (type)
{
case LootCrateRewards.Reward.Part:
{
bool isDuplicatePart = false;
int num10 = 0;
int num11 = 10;
BasePart randomLootCrateRewardPartFromTier;
do
{
randomLootCrateRewardPartFromTier = CustomizationManager.GetRandomLootCrateRewardPartFromTier(reward.PartTier, false);
num11--;
}while (list.Contains(randomLootCrateRewardPartFromTier) && num11 > 0);
list.Add(randomLootCrateRewardPartFromTier);
if (CustomizationManager.IsPartUnlocked(randomLootCrateRewardPartFromTier))
{
num10 = Singleton <GameConfigurationManager> .Instance.GetValue <int>("part_salvage_rewards", randomLootCrateRewardPartFromTier.m_partTier.ToString());
GameProgress.AddScrap(num10);
num2 += num10;
num7++;
isDuplicatePart = true;
}
else
{
CustomizationManager.UnlockPart(randomLootCrateRewardPartFromTier, lootCrateType.ToString() + "_crate");
}
componentInChildren.SetIcon(num, randomLootCrateRewardPartFromTier.m_constructionIconSprite.gameObject, string.Empty, (int)reward.PartTier, isDuplicatePart, true);
componentInChildren.SetScrapIcon(num, this.scrapIcons[0], num10.ToString());
BasePart.PartTier partTier = reward.PartTier;
if (partTier != BasePart.PartTier.Common)
{
if (partTier != BasePart.PartTier.Rare)
{
if (partTier == BasePart.PartTier.Epic)
{
num6++;
}
}
else
{
num5++;
}
}
else
{
num4++;
}
break;
}
case LootCrateRewards.Reward.Powerup:
{
GameObject iconPrefab = this.powerUpIcons[reward.Powerup - LootCrateRewards.Powerup.Magnet];
string customTypeOfGain = lootCrateType.ToString() + " crate";
switch (reward.Powerup)
{
case LootCrateRewards.Powerup.Magnet:
GameProgress.AddSuperMagnet(1);
if (Singleton <IapManager> .Instance != null)
{
Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperMagnetSingle, 1, customTypeOfGain);
}
break;
case LootCrateRewards.Powerup.Superglue:
GameProgress.AddSuperGlue(1);
if (Singleton <IapManager> .Instance != null)
{
Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperGlueSingle, 1, customTypeOfGain);
}
break;
case LootCrateRewards.Powerup.Turbo:
GameProgress.AddTurboCharge(1);
if (Singleton <IapManager> .Instance != null)
{
Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.TurboChargeSingle, 1, customTypeOfGain);
}
break;
case LootCrateRewards.Powerup.Supermechanic:
GameProgress.AddBluePrints(1);
if (Singleton <IapManager> .Instance != null)
{
Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.BlueprintSingle, 1, customTypeOfGain);
}
break;
case LootCrateRewards.Powerup.NightVision:
GameProgress.AddNightVision(1);
if (Singleton <IapManager> .Instance != null)
{
Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.NightVisionSingle, 1, customTypeOfGain);
}
break;
}
componentInChildren.SetIcon(num, iconPrefab, string.Empty, 0, false, true);
break;
}
case LootCrateRewards.Reward.Dessert:
if (reward.GoldenCupcake)
{
GameObject gameObject = WPFMonoBehaviour.gameData.m_desserts[WPFMonoBehaviour.gameData.m_desserts.Count - 1];
Dessert component = gameObject.GetComponent <Dessert>();
GameProgress.AddDesserts(component.saveId, 1);
componentInChildren.SetIcon(num, this.dessertIcons[1], string.Empty, 0, false, true);
}
else
{
GameObject gameObject2 = WPFMonoBehaviour.gameData.m_desserts[UnityEngine.Random.Range(0, WPFMonoBehaviour.gameData.m_desserts.Count - 1)];
Dessert component2 = gameObject2.GetComponent <Dessert>();
GameProgress.AddDesserts(component2.saveId, reward.Desserts);
componentInChildren.SetIcon(num, this.dessertIcons[0], reward.Desserts.ToString(), 0, false, true);
}
num3 += reward.Desserts;
break;
case LootCrateRewards.Reward.Scrap:
{
GameProgress.AddScrap(reward.Scrap);
num2 += reward.Scrap;
GameObject scrapRewardContainer = componentInChildren.SetIcon(num, this.scrapIcons[0], reward.Scrap.ToString(), 0, false, true);
LootRewardElement component3 = scrapRewardContainer.GetComponent <LootRewardElement>();
if (component3 != null)
{
LootRewardElement lootRewardElement = component3;
lootRewardElement.onRewardOpened = (Action)Delegate.Combine(lootRewardElement.onRewardOpened, new Action(delegate()
{
ScrapButton.Instance.AddParticles(scrapRewardContainer, reward.Scrap, 0f, (float)reward.Scrap);
}));
}
break;
}
case LootCrateRewards.Reward.Coin:
{
GameProgress.AddSnoutCoins(reward.Coins);
GameObject coinRewardContainer = componentInChildren.SetIcon(num, this.coinIcons[0], reward.Coins.ToString(), 0, false, true);
LootRewardElement component4 = coinRewardContainer.GetComponent <LootRewardElement>();
if (component4 != null)
{
LootRewardElement lootRewardElement2 = component4;
lootRewardElement2.onRewardOpened = (Action)Delegate.Combine(lootRewardElement2.onRewardOpened, new Action(delegate()
{
SnoutButton.Instance.AddParticles(coinRewardContainer, reward.Scrap, 0f, (float)reward.Scrap);
}));
}
break;
}
}
num++;
}
}
if (lootCrateRewardQueueElement != null && num > 0)
{
lootCrateRewardQueueElement.SetRewarded();
int @int = GameProgress.GetInt(lootCrateType.ToString() + "_crates_collected", 0, GameProgress.Location.Local, null);
GameProgress.SetInt(lootCrateType.ToString() + "_crates_collected", @int + 1, GameProgress.Location.Local);
}
EventManager.Send(new LootCrateDelivered(lootCrateType));
int value = GameProgress.GetInt("Total_parts_scrapped", 0, GameProgress.Location.Local, null) + num7;
GameProgress.SetInt("Total_parts_scrapped", value, GameProgress.Location.Local);
int value2 = GameProgress.GetInt("Total_parts_received", 0, GameProgress.Location.Local, null) + num4 + num5 + num6;
GameProgress.SetInt("Total_parts_received", value2, GameProgress.Location.Local);
}
}
private void CreatePartIcons(PartData data, float xPos, Transform parent, List <GameObject> newButtons)
{
for (int i = 0; i < this.PartTierCount - 1; i++)
{
for (int j = 0; j < data.RowWidth(); j++)
{
int index = j;
Vector3 localPosition = new Vector3(xPos + (float)index * this.horizontalPadding, (float)(this.PartTierCount / 2) - (float)i * this.verticalPadding + this.verticalPadding);
localPosition.y += ((i != 0) ? 0f : this.firstRowPadding);
BasePart.PartTier tier = (BasePart.PartTier)i;
bool flag;
if (tier == BasePart.PartTier.Epic)
{
flag = (index < data.PartCount(tier) || data.PartCount(BasePart.PartTier.Legendary) > 0);
if (index >= data.PartCount(tier))
{
index -= data.PartCount(tier);
tier = BasePart.PartTier.Legendary;
}
}
else
{
flag = (index < data.PartCount(tier));
}
if (!this.columns.Contains(localPosition.x))
{
this.columns.Add(localPosition.x);
}
if (flag)
{
GameObject bg = UnityEngine.Object.Instantiate <GameObject>(this.GetIconBackground(tier));
bg.transform.parent = parent;
bg.transform.localPosition = localPosition;
Sprite icon2 = data.GetIcon(tier, index);
GameObject icon = null;
if (icon2 != null)
{
icon = UnityEngine.Object.Instantiate <GameObject>(icon2.gameObject);
icon.transform.parent = bg.transform;
icon.transform.localPosition = new Vector3(0f, 0f, -0.1f);
icon.transform.localScale = Vector3.one * this.iconScale;
}
if (tier != BasePart.PartTier.Regular)
{
this.ToGray(bg, !CustomizationManager.IsPartUnlocked(data.parts[tier][index]));
}
if (this.IsKingsFavorite(data.parts[tier][index]))
{
GameObject gameObject;
this.AddKingsFavoriteTag(bg, out gameObject);
}
GameObject item;
if (CustomizationManager.IsPartNew(data.parts[tier][index]) && this.AddNewContentTag(bg, out item))
{
newButtons.Add(item);
}
data.AddPartRoot(tier, bg);
Button button = bg.GetComponentInChildren <Button>();
GameObjectEvents gameObjectEvents = bg.AddComponent <GameObjectEvents>();
GameObjectEvents gameObjectEvents2 = gameObjectEvents;
gameObjectEvents2.OnEnabled = (Action <bool>) Delegate.Combine(gameObjectEvents2.OnEnabled, new Action <bool>(delegate(bool enabled)
{
if (enabled)
{
if (this.IsKingsFavorite(data.parts[tier][index]))
{
GameObject gameObject2;
this.AddKingsFavoriteTag(bg, out gameObject2);
}
else
{
this.ClearKingsFavoriteTag(bg);
}
if (tier != BasePart.PartTier.Regular)
{
bool flag2 = CustomizationManager.IsPartUnlocked(data.parts[tier][index]);
this.ToGray(bg, !flag2);
Collider component = bg.GetComponent <Collider>();
component.enabled = flag2;
button.enabled = flag2;
if (tier == BasePart.PartTier.Legendary)
{
if (icon)
{
icon.SetActive(flag2);
}
bg.transform.Find("QuestionMark").gameObject.SetActive(!flag2);
}
int lastUsedPartIndex = CustomizationManager.GetLastUsedPartIndex(data.PartType);
data.UpdateSelectionIcon(this.gameData.GetCustomPart(data.PartType, lastUsedPartIndex).name);
if (CustomizationManager.IsPartNew(data.parts[tier][index]))
{
GameObject item2;
if (this.AddNewContentTag(bg, out item2))
{
newButtons.Add(item2);
}
}
else
{
this.ClearNewTags(bg);
}
}
}
}));
GameObjectEvents gameObjectEvents3 = gameObjectEvents;
gameObjectEvents3.OnVisible = (Action <bool>) Delegate.Combine(gameObjectEvents3.OnVisible, new Action <bool>(delegate(bool visible)
{
button.enabled = visible;
}));
this.SetSortingLayer(bg, this.sortingLayer);
}
}
}
}
private static void CheckUnlockPartAchievements()
{
if (!Singleton <SocialGameManager> .IsInstantiated())
{
return;
}
bool flag = false;
int common = 0;
int rare = 0;
int epic = 0;
List <BasePart> allTierParts = CustomizationManager.GetAllTierParts(BasePart.PartTier.Common, CustomizationManager.PartFlags.None);
List <BasePart> allTierParts2 = CustomizationManager.GetAllTierParts(BasePart.PartTier.Rare, CustomizationManager.PartFlags.None);
List <BasePart> allTierParts3 = CustomizationManager.GetAllTierParts(BasePart.PartTier.Epic, CustomizationManager.PartFlags.None);
foreach (BasePart basePart in allTierParts)
{
if (CustomizationManager.IsPartUnlocked(basePart))
{
common++;
if (basePart.tags != null && basePart.tags.Contains("Gold"))
{
flag = true;
}
}
}
foreach (BasePart basePart2 in allTierParts2)
{
if (CustomizationManager.IsPartUnlocked(basePart2))
{
rare++;
if (basePart2.tags != null && basePart2.tags.Contains("Gold"))
{
flag = true;
}
}
}
foreach (BasePart basePart3 in allTierParts3)
{
if (CustomizationManager.IsPartUnlocked(basePart3))
{
epic++;
if (basePart3.tags != null && basePart3.tags.Contains("Gold"))
{
flag = true;
}
}
}
if (common > 0)
{
Singleton <SocialGameManager> .Instance.TryReportAchievementProgress("grp.COMMON_COLLECTOR", 100.0, (int limit) => common >= limit);
}
if (rare > 0)
{
Singleton <SocialGameManager> .Instance.TryReportAchievementProgress("grp.RARE_COLLECTOR", 100.0, (int limit) => rare >= limit);
}
if (epic > 0)
{
Singleton <SocialGameManager> .Instance.TryReportAchievementProgress("grp.EPIC_COLLECTOR", 100.0, (int limit) => epic >= limit);
}
if (flag)
{
Singleton <SocialGameManager> .Instance.ReportAchievementProgress("grp.GET_GOLDEN_PART", 100.0);
}
}
