예제 #1
0
    private void GiveReward(DailyRewardBundle rewardBundle)
    {
        if (rewardBundle == null)
        {
            return;
        }
        List <DailyReward> list = rewardBundle.GetRewards(RewardSystem.CurrentRewardStatus.PendingRewardLevel);

        if (list == null)
        {
            return;
        }
        for (int i = 0; i < list.Count; i++)
        {
            DailyReward dailyReward      = list[i];
            string      customTypeOfGain = "Odyssey daily reward";
            switch (dailyReward.prize)
            {
            case PrizeType.SuperGlue:
                GameProgress.AddSuperGlue(dailyReward.prizeCount);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperGlueSingle, dailyReward.prizeCount, customTypeOfGain);
                }
                break;

            case PrizeType.SuperMagnet:
                GameProgress.AddSuperMagnet(dailyReward.prizeCount);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperMagnetSingle, dailyReward.prizeCount, customTypeOfGain);
                }
                break;

            case PrizeType.TurboCharge:
                GameProgress.AddTurboCharge(dailyReward.prizeCount);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.TurboChargeSingle, dailyReward.prizeCount, customTypeOfGain);
                }
                break;

            case PrizeType.SuperMechanic:
                GameProgress.AddBluePrints(dailyReward.prizeCount);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.BlueprintSingle, dailyReward.prizeCount, customTypeOfGain);
                }
                break;

            case PrizeType.NightVision:
                GameProgress.AddNightVision(dailyReward.prizeCount);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.NightVisionSingle, dailyReward.prizeCount, customTypeOfGain);
                }
                break;
            }
        }
    }
예제 #2
0
    private void RewardPowerup(LootCrateRewards.Powerup powerup)
    {
        switch (powerup)
        {
        case LootCrateRewards.Powerup.Magnet:
            GameProgress.AddSuperMagnet(1);
            break;

        case LootCrateRewards.Powerup.Superglue:
            GameProgress.AddSuperGlue(1);
            break;

        case LootCrateRewards.Powerup.Turbo:
            GameProgress.AddTurboCharge(1);
            break;

        case LootCrateRewards.Powerup.Supermechanic:
            GameProgress.AddBluePrints(1);
            break;

        case LootCrateRewards.Powerup.NightVision:
            GameProgress.AddNightVision(1);
            break;
        }
    }
예제 #3
0
    public void ClaimReward()
    {
        RewardType currentRewardType  = RewardPigRescuePopup.CurrentRewardType;
        int        currentRewardCount = RewardPigRescuePopup.CurrentRewardCount;

        GameProgress.DeleteKey("PigRescueRewardType", GameProgress.Location.Local);
        GameProgress.DeleteKey("PigRescueRewardCount", GameProgress.Location.Local);
        if (currentRewardType == RewardPigRescuePopup.RewardType.None || currentRewardCount <= 0)
        {
            return;
        }
        switch (currentRewardType)
        {
        case RewardPigRescuePopup.RewardType.Turbo:
            GameProgress.AddTurboCharge(currentRewardCount);
            break;

        case RewardPigRescuePopup.RewardType.Glue:
            GameProgress.AddSuperGlue(currentRewardCount);
            break;

        case RewardPigRescuePopup.RewardType.Magnet:
            GameProgress.AddSuperMagnet(currentRewardCount);
            break;

        case RewardPigRescuePopup.RewardType.Nightvision:
            GameProgress.AddNightVision(currentRewardCount);
            break;

        case RewardPigRescuePopup.RewardType.Supermechanic:
            GameProgress.AddBluePrints(currentRewardCount);
            break;
        }
        base.StartCoroutine(this.ClaimSequence());
    }
예제 #4
0
    private void GiveGift()
    {
        int    num = this.m_random.Next(0, 3);
        string customTypeOfGain = "Branded reward";

        switch (num)
        {
        default:
            if (!WPFMonoBehaviour.levelManager.m_SuperGlueAllowed)
            {
                this.GiveGift();
            }
            else
            {
                this.superGlueButton.SetActive(true);
                GameProgress.AddSuperGlue(1);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperGlueSingle, 1, customTypeOfGain);
                }
            }
            break;

        case 1:
            if (!WPFMonoBehaviour.levelManager.m_TurboChargeAllowed)
            {
                this.GiveGift();
            }
            else
            {
                this.turboChargeButton.SetActive(true);
                GameProgress.AddTurboCharge(1);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.TurboChargeSingle, 1, customTypeOfGain);
                }
            }
            break;

        case 2:
            if (!WPFMonoBehaviour.levelManager.m_SuperMagnetAllowed)
            {
                this.GiveGift();
            }
            else
            {
                this.superMagnetButton.SetActive(true);
                GameProgress.AddSuperMagnet(1);
                if (Singleton <IapManager> .Instance != null)
                {
                    Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperMagnetSingle, 1, customTypeOfGain);
                }
            }
            break;
        }
    }
예제 #5
0
    protected override bool HandleUIEvent(UIEvent data)
    {
        UIEvent.Type type = data.type;
        if (type == UIEvent.Type.ReplayLevel)
        {
            base.StopRunningContraption();
            this.levelManager.SetGameState(LevelManager.GameState.Building);
            return(true);
        }
        if (type != UIEvent.Type.NextLevel && type != UIEvent.Type.LevelSelection)
        {
            return(false);
        }
        if (this.levelManager.gameState != LevelManager.GameState.PausedWhileRunning)
        {
            if (this.levelManager.gameState == LevelManager.GameState.PausedWhileBuilding)
            {
                if (this.levelManager.ContraptionProto.HasSuperGlue)
                {
                    GameProgress.AddSuperGlue(1);
                }
                if (this.levelManager.ContraptionProto.HasSuperMagnet)
                {
                    GameProgress.AddSuperMagnet(1);
                }
                if (this.levelManager.ContraptionProto.HasTurboCharge)
                {
                    GameProgress.AddTurboCharge(1);
                }
                if (this.levelManager.ContraptionProto.HasNightVision)
                {
                    GameProgress.AddNightVision(1);
                }
            }
            else if (this.levelManager.gameState == LevelManager.GameState.Completed)
            {
            }
        }
        if (GameTime.IsPaused())
        {
            GameTime.Pause(false);
        }
        if (data.type == UIEvent.Type.NextLevel)
        {
            CakeRaceMenu.FindNewPlayer = true;
        }
        this.levelManager.SetGameState(LevelManager.GameState.Undefined);
        Singleton <GameManager> .Instance.LoadCakeRaceMenu(true);

        return(true);
    }
예제 #6
0
파일: GameMode.cs 프로젝트: mrdivdiz/bpvita
    protected void LoadContraptionFromSlot(int slotIndex)
    {
        if (this.ContraptionProto)
        {
            if (this.ContraptionProto.HasTurboCharge)
            {
                GameProgress.AddTurboCharge(1);
                EventManager.Send(new InGameBuildMenu.ApplyTurboChargeEvent(GameProgress.TurboChargeCount(), false));
            }
            if (this.ContraptionProto.HasNightVision)
            {
                GameProgress.AddNightVision(1);
                EventManager.Send(new InGameBuildMenu.ApplyNightVisionEvent(GameProgress.NightVisionCount(), false));
            }
            if (this.ContraptionProto.HasSuperGlue)
            {
                GameProgress.AddSuperGlue(1);
                EventManager.Send(new InGameBuildMenu.ApplySuperGlueEvent(GameProgress.SuperGlueCount(), false));
            }
            if (this.ContraptionProto.HasSuperMagnet)
            {
                GameProgress.AddSuperMagnet(1);
                EventManager.Send(new InGameBuildMenu.ApplySuperMagnetEvent(GameProgress.SuperMagnetCount(), false));
            }
            foreach (BasePart basePart in this.ContraptionProto.Parts)
            {
                this.ContraptionProto.DataSet.AddPart(basePart.m_coordX, basePart.m_coordY, (int)basePart.m_partType, basePart.customPartIndex, basePart.m_gridRotation, basePart.m_flipped);
            }
            this.ContraptionProto.SaveContraption(this.GetCurrentContraptionName());
            this.levelManager.ConstructionUI.ClearContraption();
            this.Destroy(this.ContraptionProto.gameObject);
            this.ContraptionProto = null;
        }
        this.CurrentContraptionIndex = slotIndex;
        Vector3 position = (!this.levelStart) ? Vector3.zero : this.levelStart.transform.position;

        if (this.gameData.m_contraptionPrefab)
        {
            Transform transform = UnityEngine.Object.Instantiate(this.gameData.m_contraptionPrefab, position, Quaternion.identity);
            this.ContraptionProto = transform.GetComponent <Contraption>();
        }
        this.levelManager.ConstructionUI.SetCurrentContraption();
        this.BuildContraption(WPFPrefs.LoadContraptionDataset(this.GetCurrentContraptionName()));
        foreach (ConstructionUI.PartDesc partDesc in this.levelManager.ConstructionUI.PartDescriptors)
        {
            EventManager.Send(new PartCountChanged(partDesc.part.m_partType, partDesc.CurrentCount));
        }
        this.levelManager.ConstructionUI.SetMoveButtonStates();
        this.levelManager.SetGameState(LevelManager.GameState.Building);
    }
예제 #7
0
    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);
        }
    }
예제 #8
0
    protected override bool HandleUIEvent(UIEvent data)
    {
        switch (data.type)
        {
        case UIEvent.Type.Building:
            this.levelManager.ConstructionUI.transform.position   = this.levelManager.StartingPosition;
            this.levelManager.ContraptionProto.transform.position = this.levelManager.StartingPosition;
            this.levelManager.ConstructionUI.CheckUnlockedParts();
            break;

        case UIEvent.Type.LevelSelection:
            if (this.levelManager.gameState == LevelManager.GameState.PausedWhileBuilding)
            {
                if (this.levelManager.ContraptionProto.HasSuperGlue)
                {
                    GameProgress.AddSuperGlue(1);
                }
                if (this.levelManager.ContraptionProto.HasSuperMagnet)
                {
                    GameProgress.AddSuperMagnet(1);
                }
                if (this.levelManager.ContraptionProto.HasTurboCharge)
                {
                    GameProgress.AddTurboCharge(1);
                }
                if (this.levelManager.ContraptionProto.HasNightVision)
                {
                    GameProgress.AddNightVision(1);
                }
            }
            break;

        case UIEvent.Type.NextLevel:
            break;

        case UIEvent.Type.Pause:
            break;

        case UIEvent.Type.Blueprint:
            if (GameProgress.GetBool("PermanentBlueprint", false, GameProgress.Location.Local, null))
            {
                if (this.levelManager.m_threeStarContraption.Count == 1)
                {
                    GameProgress.SetBool(Singleton <GameManager> .Instance.CurrentSceneName + "_autobuild_available", true, GameProgress.Location.Local);
                }
                this.levelManager.SetGameState(LevelManager.GameState.AutoBuilding);
            }
            break;

        case UIEvent.Type.ReplayLevel:
            break;

        case UIEvent.Type.ContinueFromPause:
            break;

        case UIEvent.Type.CloseMechanicInfo:
            this.levelManager.SetGameState(LevelManager.GameState.Building);
            break;

        case UIEvent.Type.CloseMechanicInfoAndUseMechanic:
            this.levelManager.SetGameState(LevelManager.GameState.Building);
            Singleton <GuiManager> .Instance.IsEnabled = false;
            this.levelManager.UseBlueprint             = true;
            break;

        case UIEvent.Type.SuperBlueprint:
            if (this.levelManager.SuperBluePrintsAllowed && this.levelManager.m_threeStarContraption.Count > 0 && this.levelManager.gameState == LevelManager.GameState.Building && WPFMonoBehaviour.ingameCamera.IsShowingBuildGrid(1f))
            {
                bool flag = GameProgress.GetBool(Singleton <GameManager> .Instance.CurrentSceneName + "_autobuild_available", false, GameProgress.Location.Local, null);
                int  num  = GameProgress.BluePrintCount();
                if (num == 0 && !flag)
                {
                    Singleton <GuiManager> .Instance.IsEnabled = true;
                    this.levelManager.ShowPurchaseDialog(IapManager.InAppPurchaseItemType.BlueprintSingle);
                }
                else
                {
                    if (!flag && num > 0)
                    {
                        GameProgress.SetBluePrintCount(--num);
                        GameProgress.SetBool(Singleton <GameManager> .Instance.CurrentSceneName + "_autobuild_available", true, GameProgress.Location.Local);
                        flag = true;
                        GameProgress.Save();
                        EventManager.Send(new InGameBuildMenu.AutoBuildEvent(num, true));
                    }
                    GameObject superBuildSelection = this.levelManager.InGameGUI.BuildMenu.SuperBuildSelection;
                    if (flag && !superBuildSelection.gameObject.activeSelf)
                    {
                        GameObject autoBuildButton = this.levelManager.InGameGUI.BuildMenu.AutoBuildButton;
                        autoBuildButton.SetActive(false);
                        superBuildSelection.SetActive(true);
                    }
                    if (flag)
                    {
                        EventManager.Send(new UIEvent(UIEvent.Type.RotateSuperBluePrints));
                    }
                }
            }
            break;

        case UIEvent.Type.RotateSuperBluePrints:
        {
            int    count = this.levelManager.m_threeStarContraption.Count;
            string text  = "ABCDEFGH";
            this.levelManager.CurrentSuperBluePrint++;
            if (this.levelManager.CurrentSuperBluePrint >= count)
            {
                this.levelManager.CurrentSuperBluePrint = 0;
            }
            GameObject superBuildSelection2 = this.levelManager.InGameGUI.BuildMenu.SuperBuildSelection;
            if (superBuildSelection2 != null)
            {
                Transform transform  = superBuildSelection2.transform.Find("AmountText");
                Transform transform2 = superBuildSelection2.transform.Find("AmountTextShadow");
                if (transform.GetComponent <TextMesh>().text == string.Empty)
                {
                    this.levelManager.CurrentSuperBluePrint = 0;
                }
                transform.GetComponent <TextMesh>().text  = text[this.levelManager.CurrentSuperBluePrint].ToString();
                transform2.GetComponent <TextMesh>().text = text[this.levelManager.CurrentSuperBluePrint].ToString();
            }
            this.levelManager.SetGameState(LevelManager.GameState.SuperAutoBuilding);
            if (!this.levelManager.FirstTime)
            {
                this.levelManager.FastBuilding = true;
            }
            else
            {
                this.levelManager.FirstTime = false;
            }
            break;
        }

        case UIEvent.Type.CloseMechanicInfoAndUseSuperMechanic:
            this.levelManager.SetGameState(LevelManager.GameState.Building);
            if (this.levelManager.SuperBluePrintsAllowed && this.levelManager.m_threeStarContraption.Count > 0)
            {
                Singleton <GuiManager> .Instance.IsEnabled = false;
                this.levelManager.UseSuperBlueprint        = true;
            }
            else
            {
                Singleton <GuiManager> .Instance.IsEnabled = true;
            }
            break;
        }
        return(false);
    }
예제 #9
0
    private void OnGUI()
    {
        if (!this.skinInitialized)
        {
            this.cheatSkin = GUI.skin;
            float dpi = Screen.dpi;
            if (dpi > 1f)
            {
                this.cheatSkin.label.fontSize  = Mathf.FloorToInt(0.1f * dpi + 2f);
                this.cheatSkin.button.fontSize = Mathf.FloorToInt(0.1f * dpi + 2f);
            }
            else
            {
                this.cheatSkin.label.fontSize  = Mathf.FloorToInt(15f);
                this.cheatSkin.button.fontSize = Mathf.FloorToInt(15f);
            }
            this.cheatSkin.button.wordWrap             = true;
            GUI.skin.verticalScrollbar.fixedWidth      = (float)Screen.width * 0.05f;
            GUI.skin.verticalScrollbarThumb.fixedWidth = (float)Screen.width * 0.05f;
            this.skinInitialized = true;
        }
        this.scrollbarPosition = GUILayout.BeginScrollView(this.scrollbarPosition, new GUILayoutOption[]
        {
            GUILayout.Width((float)Screen.width),
            GUILayout.Height((float)Screen.height - (float)Screen.height * 0.1f)
        });
        this.BeginGrid();
        int gameModeIndex = UserSettings.GetInt("game_mode", 0);

        if (gameModeIndex >= 0 && gameModeIndex < CheatsUtility.gameModeNames.Count)
        {
            this.DrawButton("Toggle game mode:\n" + CheatsUtility.gameModeNames[gameModeIndex], delegate
            {
                gameModeIndex++;
                if (gameModeIndex >= CheatsUtility.gameModeNames.Count)
                {
                    gameModeIndex = 0;
                }
                if (gameModeIndex == 0)
                {
                    UserSettings.DeleteKey("game_mode");
                }
                else
                {
                    UserSettings.SetInt("game_mode", gameModeIndex);
                }
            });
        }
        this.DrawButton("Reset progress", delegate
        {
            GameProgress.DeleteAll();
            GameProgress.InitializeGameProgressData();
            GameProgress.Save();
            UserSettings.DeleteAll();
            UserSettings.Save();
            if (Singleton <DailyChallenge> .IsInstantiated() && Singleton <DailyChallenge> .Instance.Initialized)
            {
                Singleton <DailyChallenge> .Instance.ForceNewChallenge();
            }
        });
        this.DrawButton("1-star all levels", delegate
        {
            foreach (Episode episode in WPFMonoBehaviour.gameData.m_episodeLevels)
            {
                for (int i = 0; i < episode.LevelInfos.Count; i++)
                {
                    this.SetStarsCompletion(episode.LevelInfos[i], 1);
                }
            }
        });
        this.DrawButton("3-stars all but one", delegate
        {
            foreach (Episode episode in WPFMonoBehaviour.gameData.m_episodeLevels)
            {
                int num = UnityEngine.Random.Range(0, episode.LevelInfos.Count - 3);
                for (int i = 0; i < episode.LevelInfos.Count - 2; i++)
                {
                    if (i != num)
                    {
                        this.SetStarsCompletion(episode.LevelInfos[i], 3);
                    }
                }
            }
        });
        this.DrawButton("3-stars all", delegate
        {
            foreach (Episode episode in WPFMonoBehaviour.gameData.m_episodeLevels)
            {
                for (int i = 0; i < episode.LevelInfos.Count; i++)
                {
                    this.SetStarsCompletion(episode.LevelInfos[i], 3);
                }
            }
        });
        this.DrawButton("Sandbox all starboxes", delegate
        {
            foreach (SandboxLevels.LevelData levelData in WPFMonoBehaviour.gameData.m_sandboxLevels.Levels)
            {
                for (int i = 0; i < levelData.m_starBoxCount; i++)
                {
                    if (i < 10)
                    {
                        GameProgress.AddSandboxStar(levelData.SceneName, "StarBox0" + i, false);
                    }
                    else
                    {
                        GameProgress.AddSandboxStar(levelData.SceneName, "StarBox" + i, false);
                    }
                }
            }
        });
        this.DrawButton("Unlimited Sandbox Parts", delegate
        {
            IEnumerator enumerator = Enum.GetValues(typeof(BasePart.PartType)).GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    object obj = enumerator.Current;
                    BasePart.PartType partType = (BasePart.PartType)obj;
                    if (partType != BasePart.PartType.Unknown && partType != BasePart.PartType.ObsoleteWheel && partType != BasePart.PartType.JetEngine)
                    {
                        int sandboxPartCount = GameProgress.GetSandboxPartCount(partType);
                        GameProgress.AddSandboxParts(partType, 99 - sandboxPartCount, false);
                    }
                }
            }
            finally
            {
                IDisposable disposable;
                if ((disposable = (enumerator as IDisposable)) != null)
                {
                    disposable.Dispose();
                }
            }
        });
        if (Application.targetFrameRate == 60)
        {
            this.DrawButton("Set low target FPS", delegate
            {
                Application.targetFrameRate = 25;
            });
        }
        else
        {
            this.DrawButton("Set default target FPS", delegate
            {
                Application.targetFrameRate = 60;
            });
        }
        this.DrawButton("Unlock all levels", delegate
        {
            GameProgress.SetBool("UnlockAllLevels", true, GameProgress.Location.Local);
        });
        this.DrawButton("Restore IAPs", delegate
        {
            Singleton <IapManager> .Instance.RestorePurchasedItems();
        });
        this.DrawButton("Reset IAPs", delegate
        {
            GameProgress.SetBool("ResetIAPs", true, GameProgress.Location.Local);
        });
        this.DrawButton("Add 10 Autobuilds", delegate
        {
            GameProgress.AddBluePrints(10);
        });
        this.DrawButton("Add Wooden crate", delegate
        {
            GameProgress.AddLootcrate(LootCrateType.Wood, 1);
        });
        this.DrawButton("Add Metal crate", delegate
        {
            GameProgress.AddLootcrate(LootCrateType.Metal, 1);
        });
        this.DrawButton("Add Golden crate", delegate
        {
            GameProgress.AddLootcrate(LootCrateType.Gold, 1);
        });
        this.DrawButton("Add 10 Glue, Magnet, Turbo and NightVision", delegate
        {
            GameProgress.AddSuperGlue(10);
            GameProgress.AddSuperMagnet(10);
            GameProgress.AddTurboCharge(10);
            GameProgress.AddNightVision(10);
        });
        this.DrawButton("Unlock all sandboxes", delegate
        {
            GameProgress.UnlockButton("EpisodeButtonSandbox");
            foreach (SandboxLevels.LevelData levelData in WPFMonoBehaviour.gameData.m_sandboxLevels.Levels)
            {
                if (!(levelData.m_identifier == "S-F") && !(levelData.m_identifier == "S-M"))
                {
                    GameProgress.SetSandboxUnlocked(levelData.m_identifier, true);
                }
            }
        });
        this.DrawButton("Unlock Field of Dreams", delegate
        {
            GameProgress.SetSandboxUnlocked("S-F", true);
        });
        this.DrawButton("Unlock Little Pig Adventure", delegate
        {
            GameProgress.SetSandboxUnlocked("S-M", true);
        });
        this.DrawButton("Unlock iOS Full version", delegate
        {
            GameProgress.SetFullVersionUnlocked(true);
        });
        this.DrawButton("Mimic 1.8.0 install version. Game needs to be restarted.", delegate
        {
            GameProgress.SetString("InstallVersion", "1.8.0", GameProgress.Location.Local);
            GameProgress.DeleteKey("LastKnownVersion", GameProgress.Location.Local);
        });
        this.DrawButton("Unlock & 3-star Race Levels except for last", delegate
        {
            List <RaceLevels.LevelData> levels = WPFMonoBehaviour.gameData.m_raceLevels.Levels;
            for (int i = 0; i < levels.Count - 1; i++)
            {
                GameProgress.SetInt(levels[i].m_identifier + "_stars", 3, GameProgress.Location.Local);
                GameProgress.SetBestTime(levels[i].SceneName, 10f);
                GameProgress.SetRaceLevelUnlocked(levels[i].m_identifier, true);
            }
        });
        this.DrawButton("Add some desserts", delegate
        {
            int count = WPFMonoBehaviour.gameData.m_desserts.Count;
            int num   = UnityEngine.Random.Range(1, count);
            for (int i = 0; i < num; i++)
            {
                string name = WPFMonoBehaviour.gameData.m_desserts[UnityEngine.Random.Range(0, count)].name;
                GameProgress.AddDesserts(name, UnityEngine.Random.Range(1, 6));
            }
        });
        this.DrawButton("Enable basic mechanic", delegate
        {
            GameProgress.SetBool("PermanentBlueprint", true, GameProgress.Location.Local);
        });
        this.DrawButton("Test Force Update. You must relaunch the app manually", delegate
        {
            GameProgress.SetInt(CheatsUtility.versionStatusCheat, 3, GameProgress.Location.Local);
        });
        this.DrawButton("Test Optional Update. You must relaunch the app manually", delegate
        {
            GameProgress.SetInt(CheatsUtility.versionStatusCheat, 1, GameProgress.Location.Local);
        });
        this.DrawButton("Unlock All Free Levels", delegate
        {
            GameProgress.SetBool("UnlockAllFreeLevels", true, GameProgress.Location.Local);
        });
        if (Singleton <RewardSystem> .IsInstantiated())
        {
            string text = "Reward Timer Toggle\nReward time / Reset time\n";
            switch (Singleton <RewardSystem> .Instance.GetTimerMode())
            {
            case 0:
                text += "24h / 48h";
                break;

            case 1:
                text += "15m / 30m";
                break;

            case 2:
                text += "5m / 15m";
                break;

            case 3:
                text += "1m / 1m 15s";
                break;

            case 4:
                text += "5s / 10s";
                break;
            }
            this.DrawButton(text, delegate
            {
                Singleton <RewardSystem> .Instance.ChangeTimerMode();
            });
        }
        this.DrawButton("Reset snout intro", delegate
        {
            GameProgress.SetInt("show_count_snout_intro", 0, GameProgress.Location.Local);
        });
        this.DrawButton("Add 1000 snout coins", delegate
        {
            GameProgress.AddSnoutCoins(1000);
        });
        this.DrawButton("Add 100 scrap", delegate
        {
            GameProgress.AddScrap(100);
        });
        this.DrawButton("Unlock all custom parts", delegate
        {
            this.UnlockParts(BasePart.PartTier.Common);
            this.UnlockParts(BasePart.PartTier.Rare);
            this.UnlockParts(BasePart.PartTier.Epic);
            this.UnlockParts(BasePart.PartTier.Legendary);
        });
        this.DrawButton("Unlock all Common parts", delegate
        {
            this.UnlockParts(BasePart.PartTier.Common);
        });
        this.DrawButton("Unlock all Rare parts", delegate
        {
            this.UnlockParts(BasePart.PartTier.Rare);
        });
        this.DrawButton("Unlock all Epic parts", delegate
        {
            this.UnlockParts(BasePart.PartTier.Epic);
        });
        this.DrawButton("Unlock all Legendary parts", delegate
        {
            this.UnlockParts(BasePart.PartTier.Legendary);
        });
        this.DrawButton("Unlock all craftable items", delegate
        {
            this.UnlockParts(BasePart.PartTier.Common, CustomizationManager.PartFlags.Locked | CustomizationManager.PartFlags.Craftable);
            this.UnlockParts(BasePart.PartTier.Rare, CustomizationManager.PartFlags.Locked | CustomizationManager.PartFlags.Craftable);
            this.UnlockParts(BasePart.PartTier.Epic, CustomizationManager.PartFlags.Locked | CustomizationManager.PartFlags.Craftable);
            this.UnlockParts(BasePart.PartTier.Legendary, CustomizationManager.PartFlags.Locked | CustomizationManager.PartFlags.Craftable);
        });
        this.DrawButton("Reset Workshop Tutorial", delegate
        {
            GameProgress.DeleteKey("Workshop_Tutorial", GameProgress.Location.Local);
        });
        this.DrawButton("Reset Crate Craze popup", delegate
        {
            GameProgress.SetBool("CrateCrazeSale_shown", false, GameProgress.Location.Local);
        });
        bool processPurchases = GameProgress.GetBool("Process_purchases", true, GameProgress.Location.Local, null);

        this.DrawButton((!processPurchases) ? "Don't process purchases" : "Do process purchases", delegate
        {
            GameProgress.SetBool("Process_purchases", !processPurchases, GameProgress.Location.Local);
        });
        this.DrawButton("CRASH CLIENT", delegate
        {
            string text2 = null;
            text2        = text2.ToString();
        });
        this.DrawButton("Force Garbage Collection", delegate
        {
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
        });
        bool fastNotifications = GameProgress.GetBool("fast_notifications", false, GameProgress.Location.Local, null);

        this.DrawButton((!fastNotifications) ? "Use faster notification schedule" : "Use realtime notification schedule", delegate
        {
            GameProgress.SetBool("fast_notifications", !fastNotifications, GameProgress.Location.Local);
        });
        if (GameProgress.HasKey("notification_clicked", GameProgress.Location.Local, null))
        {
            this.DrawButton("Clicked notification:\n" + GameProgress.GetString("notification_clicked", "null", GameProgress.Location.Local, null), null);
        }
        this.DrawButton("Clear PlayerPrefs", delegate
        {
            PlayerPrefs.DeleteAll();
        });
        this.DrawButton("Get all but one customizations", delegate
        {
            for (int i = 1; i < 4; i++)
            {
                List <BasePart> allTierParts = CustomizationManager.GetAllTierParts((BasePart.PartTier)i, CustomizationManager.PartFlags.Locked | CustomizationManager.PartFlags.Craftable | CustomizationManager.PartFlags.Rewardable);
                for (int j = 0; j < allTierParts.Count - 1; j++)
                {
                    CustomizationManager.UnlockPart(allTierParts[j], "Cheat");
                }
            }
        });
        this.DrawButton("Reset level to 1", delegate
        {
            GameProgress.SetInt("player_level", 1, GameProgress.Location.Local);
            GameProgress.SetInt("player_experience", 0, GameProgress.Location.Local);
            GameProgress.SetInt("player_pending_experience", -1, GameProgress.Location.Local);
        });
        this.DrawButton("Set level to 5", delegate
        {
            GameProgress.SetInt("player_level", 5, GameProgress.Location.Local);
            GameProgress.SetInt("player_experience", 0, GameProgress.Location.Local);
            GameProgress.SetInt("player_pending_experience", -1, GameProgress.Location.Local);
        });
        this.DrawButton("Force local game configuration '" + GameProgress.GetBool("ForceLocalGameConfiguration", false, GameProgress.Location.Local, null) + "' (requires restart)", delegate
        {
        });
        if (GameProgress.HasKey("cup_advance_cheat", GameProgress.Location.Local, null))
        {
            this.DrawButton(string.Concat(new object[]
            {
                "Current cup:\n",
                CakeRaceMenu.GetCurrentLeaderboardCup().ToString(),
                "\nNext cup:\n",
                (PlayFabLeaderboard.Leaderboard)GameProgress.GetInt("cup_advance_cheat", 1, GameProgress.Location.Local, null)
            }), delegate
            {
            });
            int rankCheat = GameProgress.GetInt("cup_rank_cheat", 0, GameProgress.Location.Local, null);
            this.DrawButton((!GameProgress.HasKey("cup_rank_cheat", GameProgress.Location.Local, null)) ? "Enable rank cheat" : ("Current Rank:\n" + rankCheat.ToString() + "\nLower rank?"), delegate
            {
                switch (rankCheat)
                {
                case 1:
                case 2:
                    break;

                case 3:
                    rankCheat = 5;
                    goto IL_E6;

                default:
                    if (rankCheat == 50)
                    {
                        rankCheat = 100;
                        goto IL_E6;
                    }
                    if (rankCheat == 100)
                    {
                        rankCheat = 250;
                        goto IL_E6;
                    }
                    if (rankCheat == 250)
                    {
                        rankCheat = 500;
                        goto IL_E6;
                    }
                    if (rankCheat != 500)
                    {
                        rankCheat = 1;
                        goto IL_E6;
                    }
                    break;

                case 5:
                    rankCheat = 10;
                    goto IL_E6;

                case 10:
                    rankCheat = 50;
                    goto IL_E6;
                }
                rankCheat++;
                IL_E6:
                GameProgress.SetInt("cup_rank_cheat", rankCheat, GameProgress.Location.Local);
            });
        }
        else
        {
            this.DrawButton("Current cup:\n" + CakeRaceMenu.GetCurrentLeaderboardCup().ToString() + "\nAdvance to next Cup", delegate
            {
                int value = (int)(1 + CakeRaceMenu.GetCurrentLeaderboardCup());
                value     = Mathf.Clamp(value, (int)PlayFabLeaderboard.LowestCup(), (int)PlayFabLeaderboard.HighestCup());
                GameProgress.SetInt("cup_advance_cheat", value, GameProgress.Location.Local);
                if (GameProgress.HasKey("cup_rank_cheat", GameProgress.Location.Local, null))
                {
                    GameProgress.DeleteKey("cup_rank_cheat", GameProgress.Location.Local);
                }
            });
        }
        this.DrawButton("Reset cup cheats", delegate
        {
            if (GameProgress.HasKey("cup_advance_cheat", GameProgress.Location.Local, null))
            {
                GameProgress.DeleteKey("cup_advance_cheat", GameProgress.Location.Local);
            }
            if (GameProgress.HasKey("cup_rank_cheat", GameProgress.Location.Local, null))
            {
                GameProgress.DeleteKey("cup_rank_cheat", GameProgress.Location.Local);
            }
            GameProgress.SetInt("cake_race_current_cup", CakeRaceMenu.GetCupIndexFromPlayerLevel(), GameProgress.Location.Local);
        });
        int leaderboardTestAmount = GameProgress.GetInt("cheat_leaderboard_test", -1, GameProgress.Location.Local, null);

        if (leaderboardTestAmount < 0)
        {
            this.DrawButton("Generate test leaderboard", delegate
            {
                GameProgress.SetInt("cheat_leaderboard_test", 0, GameProgress.Location.Local);
            });
        }
        else
        {
            this.DrawButton("Test leaderboard amount:\n" + leaderboardTestAmount.ToString(), delegate
            {
                switch (leaderboardTestAmount)
                {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                    break;

                case 5:
                    leaderboardTestAmount = 8;
                    goto IL_1D7;

                default:
                    switch (leaderboardTestAmount)
                    {
                    case 500:
                    case 501:
                    case 502:
                        break;

                    default:
                        if (leaderboardTestAmount == 25)
                        {
                            leaderboardTestAmount = 50;
                            goto IL_1D7;
                        }
                        if (leaderboardTestAmount == 50)
                        {
                            leaderboardTestAmount = 75;
                            goto IL_1D7;
                        }
                        if (leaderboardTestAmount == 75)
                        {
                            leaderboardTestAmount = 100;
                            goto IL_1D7;
                        }
                        if (leaderboardTestAmount == 100)
                        {
                            leaderboardTestAmount = 175;
                            goto IL_1D7;
                        }
                        if (leaderboardTestAmount == 175)
                        {
                            leaderboardTestAmount = 250;
                            goto IL_1D7;
                        }
                        if (leaderboardTestAmount == 250)
                        {
                            leaderboardTestAmount = 425;
                            goto IL_1D7;
                        }
                        if (leaderboardTestAmount != 425)
                        {
                            leaderboardTestAmount = 0;
                            goto IL_1D7;
                        }
                        leaderboardTestAmount = 500;
                        goto IL_1D7;
                    }
                    break;

                case 8:
                    leaderboardTestAmount = 10;
                    goto IL_1D7;

                case 10:
                    leaderboardTestAmount = 25;
                    goto IL_1D7;
                }
                leaderboardTestAmount++;
                IL_1D7:
                GameProgress.SetInt("cheat_leaderboard_test", leaderboardTestAmount, GameProgress.Location.Local);
            });
            int leaderboardRankCheat = GameProgress.GetInt("cheat_leaderboard_test_local_rank", -1, GameProgress.Location.Local, null);
            this.DrawButton("Cheat player rank: " + (leaderboardRankCheat + 1), delegate
            {
                switch (leaderboardRankCheat + 1)
                {
                case 0:
                    leaderboardRankCheat = 0;
                    break;

                case 1:
                    leaderboardRankCheat = 1;
                    break;

                case 2:
                    leaderboardRankCheat = 2;
                    break;

                case 3:
                    leaderboardRankCheat = 3;
                    break;

                case 4:
                    leaderboardRankCheat = 4;
                    break;

                case 5:
                    leaderboardRankCheat = 9;
                    break;

                default:
                    if (leaderboardRankCheat != 24)
                    {
                        if (leaderboardRankCheat != 49)
                        {
                            if (leaderboardRankCheat != 149)
                            {
                                if (leaderboardRankCheat != 499)
                                {
                                    if (leaderboardRankCheat != 999)
                                    {
                                        if (leaderboardRankCheat != 9999)
                                        {
                                            if (leaderboardRankCheat == 99999)
                                            {
                                                leaderboardRankCheat = -1;
                                            }
                                        }
                                        else
                                        {
                                            leaderboardRankCheat = 99999;
                                        }
                                    }
                                    else
                                    {
                                        leaderboardRankCheat = 9999;
                                    }
                                }
                                else
                                {
                                    leaderboardRankCheat = 999;
                                }
                            }
                            else
                            {
                                leaderboardRankCheat = 499;
                            }
                        }
                        else
                        {
                            leaderboardRankCheat = 149;
                        }
                    }
                    else
                    {
                        leaderboardRankCheat = 49;
                    }
                    break;

                case 10:
                    leaderboardRankCheat = 24;
                    break;
                }
                GameProgress.SetInt("cheat_leaderboard_test_local_rank", leaderboardRankCheat, GameProgress.Location.Local);
            });
            this.DrawButton("Clear test leaderboard", delegate
            {
                GameProgress.DeleteKey("cheat_leaderboard_test", GameProgress.Location.Local);
                GameProgress.DeleteKey("cheat_leaderboard_test_local_rank", GameProgress.Location.Local);
            });
        }
        this.DrawButton("Reset alien machine", delegate
        {
            if (GameProgress.HasKey("AlienCraftingMachineShown", GameProgress.Location.Local, null))
            {
                GameProgress.DeleteKey("AlienCraftingMachineShown", GameProgress.Location.Local);
            }
        });
        this.DrawButton("Reset Cake Race unlock", delegate
        {
            if (GameProgress.HasKey("CakeRaceUnlockShown", GameProgress.Location.Local, null))
            {
                GameProgress.SetBool("CakeRaceUnlockShown", false, GameProgress.Location.Local);
            }
            if (GameProgress.HasKey("UnlockShown_CakeRaceButton", GameProgress.Location.Local, null))
            {
                GameProgress.SetBool("UnlockShown_CakeRaceButton", false, GameProgress.Location.Local);
            }
        });
        this.DrawButton("Skip cake race tutorial", delegate
        {
            int @int = GameProgress.GetInt("cake_race_total_wins", 0, GameProgress.Location.Local, null);
            if (@int < 7)
            {
                GameProgress.SetInt("cake_race_total_wins", 7, GameProgress.Location.Local);
            }
        });
        this.EndGrid();
        GUILayout.EndScrollView();
        GUI.Label(new Rect((float)Screen.width * 0.9f, (float)Screen.height * 0.93f, (float)Screen.width * 0.1f, (float)Screen.height * 0.1f), string.Concat(new string[]
        {
            "Debug \n(v",
            Singleton <BuildCustomizationLoader> .Instance.ApplicationVersion,
            " - ",
            Singleton <BuildCustomizationLoader> .Instance.SVNRevisionNumber,
            ")"
        }));
        if (GUI.Button(new Rect((float)Screen.width * 0.2f, (float)Screen.height * 0.92f, (float)Screen.width * 0.6f, (float)Screen.height * 0.08f), "Back to Main Menu"))
        {
            GameProgress.Save();
            PlayerPrefs.Save();
            Singleton <GameManager> .Instance.LoadMainMenu(false);
        }
        GUI.skin = null;
    }
예제 #10
0
    private FeedingPrize.PrizeType GiveReward(GameObject dessert)
    {
        FeedingPrize.PrizeType result = FeedingPrize.PrizeType.None;
        int num = GameProgress.EatenDessertsCount();

        if (UnityEngine.Random.value < this.m_PrizeProbability || num <= 1 || dessert.name == "GoldenCake")
        {
            FeedingPrize feedingPrize;
            if (num <= 1)
            {
                feedingPrize = null;
                foreach (FeedingPrize x in this.m_FeedingPrizes)
                {
                    if (x.type == FeedingPrize.PrizeType.SuperGlue)
                    {
                        feedingPrize = x;
                        break;
                    }
                }
            }
            else
            {
                feedingPrize = this.SelectFeedingPrize();
            }
            FeedingPrize feedingPrize2 = feedingPrize;
            if (dessert.name == "GoldenCake" && feedingPrize2.type == FeedingPrize.PrizeType.Junk)
            {
                feedingPrize2 = this.m_FeedingPrizes[1];
            }
            if (feedingPrize2 != null)
            {
                if (feedingPrize2.type != FeedingPrize.PrizeType.Junk && feedingPrize2.type != FeedingPrize.PrizeType.None)
                {
                    GameObject gameObject = this.m_Reward.transform.Find("Offset/AnimationNode").gameObject;
                    if (gameObject.transform.childCount > 0)
                    {
                        UnityEngine.Object.Destroy(gameObject.transform.GetChild(0).gameObject);
                    }
                    GameObject gameObject2 = UnityEngine.Object.Instantiate <GameObject>(feedingPrize2.icon, gameObject.transform.position, gameObject.transform.rotation);
                    gameObject2.transform.parent     = gameObject.transform;
                    gameObject2.transform.localScale = Vector3.one * feedingPrize2.iconScale;
                    CurrencyParticleBurst burst = null;
                    string text = "King Pig feeding prize";
                    switch (feedingPrize2.type)
                    {
                    case FeedingPrize.PrizeType.SuperGlue:
                        GameProgress.AddSuperGlue(1);
                        if (Singleton <IapManager> .Instance != null)
                        {
                            Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperGlueSingle, 1, text);
                        }
                        break;

                    case FeedingPrize.PrizeType.SuperMagnet:
                        GameProgress.AddSuperMagnet(1);
                        if (Singleton <IapManager> .Instance != null)
                        {
                            Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.SuperMagnetSingle, 1, text);
                        }
                        break;

                    case FeedingPrize.PrizeType.TurboCharge:
                        GameProgress.AddTurboCharge(1);
                        if (Singleton <IapManager> .Instance != null)
                        {
                            Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.TurboChargeSingle, 1, text);
                        }
                        break;

                    case FeedingPrize.PrizeType.SuperMechanic:
                        GameProgress.AddBluePrints(1);
                        if (Singleton <IapManager> .Instance != null)
                        {
                            Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.BlueprintSingle, 1, text);
                        }
                        break;

                    case FeedingPrize.PrizeType.NightVision:
                        GameProgress.AddNightVision(1);
                        if (Singleton <IapManager> .Instance != null)
                        {
                            Singleton <IapManager> .Instance.SendFlurryInventoryGainEvent(IapManager.InAppPurchaseItemType.NightVisionSingle, 1, text);
                        }
                        break;

                    case FeedingPrize.PrizeType.SnoutCoins:
                    {
                        int value = Singleton <GameConfigurationManager> .Instance.GetValue <int>("king_pig_snout_reward", "min");

                        int value2 = Singleton <GameConfigurationManager> .Instance.GetValue <int>("king_pig_snout_reward", "max");

                        int num2 = UnityEngine.Random.Range(value, value2 + 1);
                        if (num2 > 0)
                        {
                            if (Singleton <DoubleRewardManager> .Instance.HasDoubleReward)
                            {
                                num2 *= 2;
                            }
                            GameProgress.AddSnoutCoins(num2);
                            GameObject gameObject3 = GameObject.FindGameObjectWithTag("KingPigMouth");
                            if (gameObject3 != null)
                            {
                                Camera main   = Camera.main;
                                Camera camera = Singleton <GuiManager> .Instance.FindCamera();

                                if (main == null || camera == null)
                                {
                                    break;
                                }
                                Vector3 a = gameObject3.transform.position * (1f / main.orthographicSize);
                                gameObject2.transform.parent   = null;
                                gameObject2.transform.position = a * camera.orthographicSize;
                            }
                            burst = gameObject2.GetComponent <CurrencyParticleBurst>();
                            if (burst != null)
                            {
                                burst.SetBurst(num2, 10f, true);
                            }
                        }
                        break;
                    }

                    case FeedingPrize.PrizeType.Scrap:
                    {
                        int value3 = Singleton <GameConfigurationManager> .Instance.GetValue <int>("king_pig_scrap_reward", "min");

                        int value4 = Singleton <GameConfigurationManager> .Instance.GetValue <int>("king_pig_scrap_reward", "max");

                        int num3 = UnityEngine.Random.Range(value3, value4 + 1);
                        if (num3 > 0)
                        {
                            GameProgress.AddScrap(num3);
                            GameObject gameObject4 = GameObject.FindGameObjectWithTag("KingPigMouth");
                            if (gameObject4 != null)
                            {
                                Camera main2   = Camera.main;
                                Camera camera2 = Singleton <GuiManager> .Instance.FindCamera();

                                if (main2 == null || camera2 == null)
                                {
                                    break;
                                }
                                Vector3 a2 = gameObject4.transform.position * (1f / main2.orthographicSize);
                                gameObject2.transform.parent   = null;
                                gameObject2.transform.position = a2 * camera2.orthographicSize;
                            }
                            burst = gameObject2.GetComponent <CurrencyParticleBurst>();
                            if (burst != null)
                            {
                                burst.SetBurst(num3, 10f, true);
                            }
                        }
                        break;
                    }
                    }
                    if (feedingPrize2.type == FeedingPrize.PrizeType.SnoutCoins || feedingPrize2.type == FeedingPrize.PrizeType.Scrap)
                    {
                        this.DelayAction(delegate
                        {
                            if (burst != null)
                            {
                                burst.Burst();
                            }
                        }, 1.3f);
                    }
                    else
                    {
                        this.DelayAction(delegate
                        {
                            this.m_Reward.SetActive(true);
                        }, this.m_GrowDuration);
                    }
                    if (PlayerProgressBar.Instance != null && Singleton <PlayerProgress> .IsInstantiated())
                    {
                        GameObject gameObject5 = GameObject.FindGameObjectWithTag("KingPigMouth");
                        Vector3    vector      = gameObject5.transform.position * (1f / this.m_mainCam.orthographicSize);
                        vector *= this.m_hudCam.orthographicSize;
                        PlayerProgressBar.Instance.DelayUpdate();
                        int amount = Singleton <PlayerProgress> .Instance.AddExperience(PlayerProgress.ExperienceType.KingBurp);

                        PlayerProgressBar.Instance.AddParticles(vector, amount, 1.3f, 0f, null);
                    }
                    if (Singleton <SocialGameManager> .IsInstantiated())
                    {
                        Singleton <SocialGameManager> .Instance.ReportAchievementProgress("grp.KINGS_FAVORITE", 100.0);
                    }
                }
                result = feedingPrize2.type;
            }
        }
        return(result);
    }