public static void ModifyShiny(PlayMakerFSM shinyFsm, FlingType flingType, AbstractPlacement location, AbstractItem item)
        {
            FsmState pdBool     = shinyFsm.GetState("PD Bool?");
            FsmState charm      = shinyFsm.GetState("Charm?");
            FsmState trinkFlash = shinyFsm.GetState("Trink Flash");

            FsmStateAction checkAction = new RandomizerExecuteLambda(() => shinyFsm.SendEvent(item.IsObtained() ? "COLLECTED" : null));
            FsmStateAction giveAction  = new RandomizerExecuteLambda(() => item.Give(location, Container.Shiny, flingType, shinyFsm.gameObject.transform, message: MessageType.Any, callback: (_) => shinyFsm.SendEvent("GAVE ITEM")));

            // Remove actions that stop shiny from spawning
            pdBool.RemoveActionsOfType <StringCompare>();

            // Change pd bool test to our new bool
            pdBool.RemoveActionsOfType <PlayerDataBoolTest>();
            pdBool.AddAction(checkAction);

            // Charm must be preserved as the entry point for AddYNDialogueToShiny
            charm.ClearTransitions();
            charm.AddTransition("FINISHED", "Trink Flash");

            trinkFlash.ClearTransitions();
            trinkFlash.Actions = new FsmStateAction[]
            {
                trinkFlash.Actions[0], // Audio
                trinkFlash.Actions[1], // Audio
                trinkFlash.Actions[2], // visual effect
                trinkFlash.Actions[3], // hide shiny
                trinkFlash.Actions[4], // pickup animation
                // [5] -- spawn message
                // [6] -- store message text
                // [7] -- store message icon
                giveAction, // give item and await callback
            };
            trinkFlash.AddTransition("GAVE ITEM", "Hero Up");
        }
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            int royalCharmState = PlayerData.instance.GetInt(nameof(PlayerData.royalCharmState));

            if (royalCharmState < 4)
            {
                PlayerData.instance.IncrementInt(nameof(PlayerData.royalCharmState));
            }
            switch (royalCharmState)
            {
            case 1:
                PlayerData.instance.SetBool(nameof(PlayerData.gotCharm_36), true);
                PlayerData.instance.IncrementInt(nameof(PlayerData.charmsOwned));
                break;

            case 2:
                PlayerData.instance.IncrementInt(nameof(PlayerData.royalCharmState));
                break;

            case 4:
                PlayerData.instance.SetBool(nameof(PlayerData.gotShadeCharm), true);
                PlayerData.instance.SetInt(nameof(PlayerData.charmCost_36), 0);
                PlayerData.instance.EquipCharm(36);
                PlayerData.instance.SetBool(nameof(PlayerData.equippedCharm_36), true);
                if (!PlayerData.instance.equippedCharms.Contains(36))
                {
                    PlayerData.instance.equippedCharms.Add(36);
                }
                break;
            }
        }
Exemple #3
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     for (int i = 0; i < amount; i++)
     {
         EventRegister.SendEvent("ADD BLUE HEALTH");
     }
 }
Exemple #4
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.SetBool(nameof(PlayerData.openedTown), true);
     PlayerData.instance.SetBool(nameof(PlayerData.openedTownBuilding), true);
     if (GameManager.instance.sceneName == "Room_Town_Stag_Station")
     {
         UnityEngine.GameObject.Find("Station Door").LocateFSM("Control").SendEvent("ACTIVATE");
     }
 }
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.SetBool(nameof(PlayerData.instance.gotCharm_40), true);
     PlayerData.instance.SetBool(nameof(PlayerData.nightmareLanternAppeared), true);
     PlayerData.instance.SetBool(nameof(PlayerData.nightmareLanternLit), true);
     PlayerData.instance.SetBool(nameof(PlayerData.troupeInTown), true);
     PlayerData.instance.SetBool(nameof(PlayerData.divineInTown), true);
     PlayerData.instance.SetBool(nameof(PlayerData.metGrimm), true);
     PlayerData.instance.SetInt(nameof(PlayerData.flamesRequired), 3);
     PlayerData.instance.SetInt(nameof(PlayerData.grimmChildLevel), 1);
 }
        public static void ModifyGeoRock(PlayMakerFSM rockFsm, FlingType flingType, AbstractPlacement location, IEnumerable <AbstractItem> items)
        {
            GameObject rock = rockFsm.gameObject;

            FsmState init   = rockFsm.GetState("Initiate");
            FsmState hit    = rockFsm.GetState("Hit");
            FsmState payout = rockFsm.GetState("Destroy");
            FsmState broken = rockFsm.GetState("Broken");

            FsmStateAction checkAction = new RandomizerExecuteLambda(() => rockFsm.SendEvent(location.HasVisited() ? "BROKEN" : null));

            init.RemoveActionsOfType <IntCompare>();
            init.AddAction(checkAction);

            hit.ClearTransitions();
            hit.AddTransition("HIT", "Pause Frame");
            hit.AddTransition("FINISHED", "Pause Frame");
            hit.RemoveActionsOfType <FlingObjectsFromGlobalPool>();

            var payoutAction = payout.GetActionOfType <FlingObjectsFromGlobalPool>();

            payoutAction.spawnMin.Value = 0;
            payoutAction.spawnMax.Value = 0;

            GameObject itemParent = new GameObject("item");

            itemParent.transform.SetParent(rock.transform);
            itemParent.transform.position      = rock.transform.position;
            itemParent.transform.localPosition = Vector3.zero;
            itemParent.SetActive(true);

            FsmStateAction spawnShinies = new ActivateAllChildren {
                gameObject = new FsmGameObject {
                    Value = itemParent,
                }, activate = true
            };

            payout.AddAction(spawnShinies);
            broken.AddAction(spawnShinies);

            foreach (AbstractItem item in items)
            {
                if (item.GiveEarly(Container.GeoRock))
                {
                    FsmStateAction giveAction = new RandomizerExecuteLambda(() => item.Give(location, Container.GeoRock, flingType, rockFsm.gameObject.transform, message: MessageType.None));
                    payout.AddAction(giveAction);
                }
                else
                {
                    GameObject shiny = ShinyUtility.MakeNewShiny(location, item);
                    ShinyUtility.PutShinyInContainer(itemParent, shiny);
                }
            }
        }
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            switch (fling)
            {
            case FlingType.DirectDeposit:
                HeroController.instance.AddGeo(amount);
                break;

            default:
                FsmStateActions.RandomizerAddGeo.SpawnGeo(amount, false, fling, transform);
                break;
            }
        }
Exemple #8
0
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            switch (dreamer)
            {
            case DreamerType.Lurien:
                PlayerData.instance.SetBool(nameof(PlayerData.lurienDefeated), true);
                PlayerData.instance.SetBool(nameof(PlayerData.maskBrokenLurien), true);
                break;

            case DreamerType.Monomon:
                PlayerData.instance.SetBool(nameof(PlayerData.monomonDefeated), true);
                PlayerData.instance.SetBool(nameof(PlayerData.maskBrokenMonomon), true);
                break;

            case DreamerType.Herrah:
                PlayerData.instance.SetBool(nameof(PlayerData.hegemolDefeated), true);
                PlayerData.instance.SetBool(nameof(PlayerData.maskBrokenHegemol), true);
                break;
            }
            if (PlayerData.instance.GetInt(nameof(PlayerData.guardiansDefeated)) == 0)
            {
                PlayerData.instance.SetBool(nameof(PlayerData.hornetFountainEncounter), true);
                PlayerData.instance.SetBool(nameof(PlayerData.marmOutside), true);
                PlayerData.instance.SetBool(nameof(PlayerData.crossroadsInfected), true);
            }
            if (PlayerData.instance.GetInt(nameof(PlayerData.guardiansDefeated)) == 2)
            {
                PlayerData.instance.SetBool(nameof(PlayerData.dungDefenderSleeping), true);
                PlayerData.instance.IncrementInt(nameof(PlayerData.brettaState));
                PlayerData.instance.IncrementInt(nameof(PlayerData.mrMushroomState));
                PlayerData.instance.SetBool(nameof(PlayerData.corniferAtHome), true);
                PlayerData.instance.SetBool(nameof(PlayerData.metIselda), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_cityLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_abyssLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_cliffsLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_crossroadsLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_deepnestLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_fogCanyonLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_fungalWastesLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_greenpathLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_minesLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_outskirtsLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_royalGardensLeft), true);
                PlayerData.instance.SetBool(nameof(PlayerData.corn_waterwaysLeft), true);
            }
            if (PlayerData.instance.guardiansDefeated < 3)
            {
                PlayerData.instance.IncrementInt(nameof(PlayerData.guardiansDefeated));
            }
        }
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            PlayerData.instance.SetBool(nameof(PlayerData.hasCharm), true);
            PlayerData.instance.SetBool($"gotCharm_{charmNum}", true);
            PlayerData.instance.IncrementInt(nameof(PlayerData.charmsOwned));
            PlayerData.instance.SetBool($"equippedCharm_{charmNum}", true);
            PlayerData.instance.EquipCharm(charmNum);

            PlayerData.instance.CalculateNotchesUsed();
            if (PlayerData.instance.GetInt(nameof(PlayerData.charmSlotsFilled)) > PlayerData.instance.GetInt(nameof(PlayerData.charmSlots)))
            {
                PlayerData.instance.SetBool(nameof(PlayerData.overcharmed), true);
            }
        }
Exemple #10
0
        public void SwapJewels(Vector2 Touch, FlingType flingType)
        {
            if (GridMoving)
            {
                return;
            }
            playerTouch = true;
            int X = TouchX(Touch), Y = TouchY(Touch);

            try
            {
                switch (flingType)
                {
                case FlingType.Top:
                    if (Y <= 0)
                    {
                        break;
                    }
                    SwapTwoJewels(X, Y, X, Y - 1);
                    break;

                case FlingType.Right:
                    if (X >= width - 1)
                    {
                        break;
                    }
                    SwapTwoJewels(X, Y, X + 1, Y);
                    break;

                case FlingType.Bot:
                    if (Y >= height - 1)
                    {
                        break;
                    }
                    SwapTwoJewels(X, Y, X, Y + 1);
                    break;

                case FlingType.Left:
                    if (X <= 0)
                    {
                        break;
                    }
                    SwapTwoJewels(X, Y, X - 1, Y);
                    break;
                }
            }
            catch { }
        }
        public static void ModifyBottleFsm(GameObject jar, FlingType flingType, AbstractPlacement location, IEnumerable <AbstractItem> items)
        {
            PlayMakerFSM fsm      = jar.LocateFSM("Bottle Control");
            FsmState     init     = fsm.GetState("Init");
            FsmState     shatter  = fsm.GetState("Shatter");
            FsmState     activate = fsm.GetState("Activate");

            init.RemoveActionsOfType <BoolTest>();
            shatter.RemoveActionsOfType <IncrementPlayerDataInt>();
            shatter.RemoveActionsOfType <SendMessage>();

            FsmStateAction checkAction = new RandomizerExecuteLambda(() => fsm.SendEvent(location.HasVisited() ? "ACTIVATE" : null));

            init.AddFirstAction(checkAction);

            GameObject itemParent = new GameObject("item");

            itemParent.transform.SetParent(jar.transform);
            itemParent.transform.position      = jar.transform.position;
            itemParent.transform.localPosition = Vector3.zero;
            itemParent.SetActive(true);

            FsmStateAction spawnShinies = new ActivateAllChildren {
                gameObject = new FsmGameObject {
                    Value = itemParent,
                }, activate = true
            };
            FsmStateAction removeParent = new RandomizerExecuteLambda(() => itemParent.transform.parent = null);

            shatter.AddAction(spawnShinies);
            activate.AddFirstAction(removeParent); // activate has a destroy all children action
            activate.AddFirstAction(spawnShinies);

            foreach (AbstractItem item in items)
            {
                if (item.GiveEarly(Container.GrubJar))
                {
                    FsmStateAction giveAction = new RandomizerExecuteLambda(() => item.Give(location, Container.GrubJar, flingType, jar.transform, MessageType.Corner));
                    shatter.AddAction(giveAction);
                }
                else
                {
                    GameObject shiny = ShinyUtility.MakeNewShiny(location, item);
                    ShinyUtility.PutShinyInContainer(itemParent, shiny);
                }
            }
        }
Exemple #12
0
        public void Give(AbstractPlacement location, Container container, FlingType fling, Transform transform, MessageType message, Action <AbstractItem> callback = null)
        {
            AbstractItem Item = this;

            obtained         = true;
            location.visited = true;

            Item.GiveImmediate(container, fling, transform);
            if (Item.UIDef != null)
            {
                Item.UIDef.SendMessage(message, () => callback?.Invoke(Item));
            }
            else
            {
                callback?.Invoke(Item);
            }
        }
        public static void ModifyChest(PlayMakerFSM chestFsm, FlingType flingType, AbstractPlacement location, IEnumerable <AbstractItem> items)
        {
            FsmState init       = chestFsm.GetState("Init");
            FsmState spawnItems = chestFsm.GetState("Spawn Items");

            FsmStateAction checkAction = new RandomizerExecuteLambda(() => chestFsm.SendEvent(location.HasVisited() ? "ACTIVATE" : null));

            init.RemoveActionsOfType <BoolTest>();
            init.AddAction(checkAction);

            // Destroy any existing shinies in the chest
            GameObject itemParent = chestFsm.gameObject.transform.Find("Item").gameObject;

            foreach (Transform t in itemParent.transform)
            {
                UnityEngine.Object.Destroy(t.gameObject);
            }

            // Remove pre-existing geo from chest
            foreach (FlingObjectsFromGlobalPool fling in spawnItems.GetActionsOfType <FlingObjectsFromGlobalPool>())
            {
                fling.spawnMin = 0;
                fling.spawnMax = 0;
            }

            // Need to check SpawnFromPool action too because of Mantis Lords chest
            foreach (SpawnFromPool spawn in spawnItems.GetActionsOfType <SpawnFromPool>())
            {
                spawn.spawnMin = 0;
                spawn.spawnMax = 0;
            }

            foreach (AbstractItem item in items)
            {
                if (item.GiveEarly(Container.Chest))
                {
                    spawnItems.AddAction(new RandomizerExecuteLambda(() => item.Give(location, Container.Chest, flingType, chestFsm.gameObject.transform, MessageType.Corner)));
                }
                else
                {
                    GameObject shiny = ShinyUtility.MakeNewShiny(location, item);
                    ShinyUtility.PutShinyInContainer(itemParent, shiny);
                }
            }
        }
Exemple #14
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     if (container == Container.Shop)
     {
         return;
     }
     AudioSource.PlayClipAtPoint(ObjectCache.LoreSound,
                                 new Vector3(
                                     Camera.main.transform.position.x - 2,
                                     Camera.main.transform.position.y,
                                     Camera.main.transform.position.z + 2
                                     ));
     AudioSource.PlayClipAtPoint(ObjectCache.LoreSound,
                                 new Vector3(
                                     Camera.main.transform.position.x + 2,
                                     Camera.main.transform.position.y,
                                     Camera.main.transform.position.z + 2
                                     ));
 }
Exemple #15
0
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            PlayerData.instance.SetBool(nameof(PlayerData.vesselFragmentCollected), true);
            int count = PlayerData.instance.GetInt(nameof(PlayerData.vesselFragments)) + amount;

            for (; count > 2; count -= 3)
            {
                HeroController.instance.AddToMaxMPReserve(33);
                PlayMakerFSM.BroadcastEvent("NEW SOUL ORB");
            }
            switch (count)
            {
            case 0 when PlayerData.instance.GetInt(nameof(PlayerData.MPReserveMax)) == PlayerData.instance.GetInt(nameof(PlayerData.MPReserveCap)):
                PlayerData.instance.SetInt(nameof(PlayerData.vesselFragments), 3);

                break;

            default:
                PlayerData.instance.SetInt(nameof(PlayerData.vesselFragments), count);
                break;
            }
        }
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            PlayerData.instance.IncrementInt(nameof(PlayerData.grubsCollected));
            if (container == Container.GrubJar)
            {
                return;
            }

            int clipIndex = new System.Random().Next(2);

            AudioSource.PlayClipAtPoint(ObjectCache.GrubCries[clipIndex],
                                        new Vector3(
                                            Camera.main.transform.position.x - 2,
                                            Camera.main.transform.position.y,
                                            Camera.main.transform.position.z + 2
                                            ));
            AudioSource.PlayClipAtPoint(ObjectCache.GrubCries[clipIndex],
                                        new Vector3(
                                            Camera.main.transform.position.x + 2,
                                            Camera.main.transform.position.y,
                                            Camera.main.transform.position.z + 2
                                            ));
        }
        public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
        {
            PlayerData.instance.SetBool(nameof(PlayerData.heartPieceCollected), true);
            int count = PlayerData.instance.GetInt(nameof(PlayerData.heartPieces)) + amount;

            for (; count > 3; count -= 4)
            {
                HeroController.instance.AddToMaxHealth(1);
                PlayMakerFSM.BroadcastEvent("MAX HP UP");
                PlayMakerFSM.BroadcastEvent("HERO HEALED FULL");
            }

            switch (count)
            {
            case 0 when PlayerData.instance.GetInt(nameof(PlayerData.maxHealthBase)) == PlayerData.instance.GetInt(nameof(PlayerData.maxHealthCap)):
                PlayerData.instance.SetInt(nameof(PlayerData.heartPieces), 4);

                break;

            default:
                PlayerData.instance.SetInt(nameof(PlayerData.heartPieces), count);
                break;
            }
        }
Exemple #18
0
 public abstract void GiveImmediate(Container container, FlingType fling, Transform transform);
Exemple #19
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     HeroController.instance.AddGeo(amount);
 }
Exemple #20
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.IntAdd(fieldName, amount);
 }
Exemple #21
0
        public static void SpawnGeo(int _count, bool _minimize, FlingType fling, Transform _transform)
        {
            int smallNum;
            int medNum;
            int largeNum;

            if (!_minimize)
            {
                Random random = new Random();

                smallNum  = random.Next(0, _count / 10);
                _count   -= smallNum;
                largeNum  = random.Next(_count / (GEO_VALUE_LARGE * 2), _count / GEO_VALUE_LARGE + 1);
                _count   -= largeNum * GEO_VALUE_LARGE;
                medNum    = _count / GEO_VALUE_MEDIUM;
                _count   -= medNum * 5;
                smallNum += _count;
            }
            else
            {
                largeNum = _count / GEO_VALUE_LARGE;
                _count  -= largeNum * GEO_VALUE_LARGE;
                medNum   = _count / GEO_VALUE_MEDIUM;
                _count  -= medNum * GEO_VALUE_MEDIUM;
                smallNum = _count;
            }

            GameObject smallPrefab  = ObjectCache.SmallGeo;
            GameObject mediumPrefab = ObjectCache.MediumGeo;
            GameObject largePrefab  = ObjectCache.LargeGeo;

            // Workaround because Spawn extension is slightly broken
            Object.Destroy(smallPrefab.Spawn());
            Object.Destroy(mediumPrefab.Spawn());
            Object.Destroy(largePrefab.Spawn());

            smallPrefab.SetActive(true);
            mediumPrefab.SetActive(true);
            largePrefab.SetActive(true);

            FlingUtils.Config flingConfig = new FlingUtils.Config
            {
                Prefab    = smallPrefab,
                AmountMin = smallNum,
                AmountMax = smallNum,
                SpeedMin  = 15f,
                SpeedMax  = 30f,
                AngleMin  = 80f,
                AngleMax  = 115f
            };

            if (smallNum > 0)
            {
                FlingUtils.SpawnAndFling(flingConfig, _transform, new Vector3(0f, 0f, 0f));
            }

            if (medNum > 0)
            {
                flingConfig.Prefab    = mediumPrefab;
                flingConfig.AmountMin = flingConfig.AmountMax = medNum;
                FlingUtils.SpawnAndFling(flingConfig, _transform, new Vector3(0f, 0f, 0f));
            }

            if (largeNum > 0)
            {
                flingConfig.Prefab    = largePrefab;
                flingConfig.AmountMin = flingConfig.AmountMax = largeNum;
                FlingUtils.SpawnAndFling(flingConfig, _transform, new Vector3(0f, 0f, 0f));
            }

            if (fling == FlingType.StraightUp)
            {
                flingConfig.AngleMin = 90;
                flingConfig.AngleMax = 90;
            }

            smallPrefab.SetActive(false);
            mediumPrefab.SetActive(false);
            largePrefab.SetActive(false);
        }
Exemple #22
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.SetBool($"foundTrinket{trinketNum}", true);
     PlayerData.instance.IncrementInt($"trinket{trinketNum}");
 }
Exemple #23
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.IntAdd(nameof(PlayerData.dreamOrbs), amount);
     EventRegister.SendEvent("DREAM ORB COLLECT");
 }
Exemple #24
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.SetBool(nameof(PlayerData.hasMap), true);
     PlayerData.instance.SetBool(nameof(PlayerData.openedMapperShop), true);
     PlayerData.instance.SetBool(fieldName, true);
 }
Exemple #25
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.SetBool(nameof(PlayerData.hasCharm), true);
     PlayerData.instance.SetBool(fieldName, true);
     PlayerData.instance.IncrementInt(nameof(PlayerData.charmsOwned));
 }
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     PlayerData.instance.SetBool(fieldName, true);
 }
Exemple #27
0
 public override void GiveImmediate(Container container, FlingType fling, UnityEngine.Transform transform)
 {
     HeroController.instance.AddMPCharge(soul);
 }
Exemple #28
0
        public override void GiveImmediate(Container container, FlingType fling, Transform transform)
        {
            if (fling == FlingType.DirectDeposit)
            {
                HeroController.instance.AddGeo(amount);
                return;
            }

            int smallNum;
            int medNum;
            int largeNum;

            if (amount < 70)
            {
                smallNum = amount;
                medNum   = 0;
                largeNum = 0;
            }
            else if (amount < 425)
            {
                medNum   = amount / 5;
                smallNum = amount - 5 * medNum;
                largeNum = 0;
            }
            else
            {
                largeNum = amount / 25;
                medNum   = (amount - largeNum * 25) / 5;
                smallNum = amount - largeNum * 25 - medNum * 5;
            }

            GameObject smallPrefab  = ObjectCache.SmallGeo;
            GameObject mediumPrefab = ObjectCache.MediumGeo;
            GameObject largePrefab  = ObjectCache.LargeGeo;

            // Workaround because Spawn extension is slightly broken
            GameObject.Destroy(smallPrefab.Spawn());
            GameObject.Destroy(mediumPrefab.Spawn());
            GameObject.Destroy(largePrefab.Spawn());

            smallPrefab.SetActive(true);
            mediumPrefab.SetActive(true);
            largePrefab.SetActive(true);

            FlingUtils.Config flingConfig = new FlingUtils.Config
            {
                Prefab    = smallPrefab,
                AmountMin = smallNum,
                AmountMax = smallNum,
                SpeedMin  = 15f,
                SpeedMax  = 30f,
                AngleMin  = 80f,
                AngleMax  = 115f
            };

            if (smallNum > 0)
            {
                FlingUtils.SpawnAndFling(flingConfig, transform, new Vector3(0f, 0f, 0f));
            }

            if (medNum > 0)
            {
                flingConfig.Prefab    = mediumPrefab;
                flingConfig.AmountMin = flingConfig.AmountMax = medNum;
                FlingUtils.SpawnAndFling(flingConfig, transform, new Vector3(0f, 0f, 0f));
            }

            if (largeNum > 0)
            {
                flingConfig.Prefab    = largePrefab;
                flingConfig.AmountMin = flingConfig.AmountMax = largeNum;
                FlingUtils.SpawnAndFling(flingConfig, transform, new Vector3(0f, 0f, 0f));
            }

            if (fling == FlingType.StraightUp)
            {
                flingConfig.AngleMin = 90;
                flingConfig.AngleMax = 90;
            }

            smallPrefab.SetActive(false);
            mediumPrefab.SetActive(false);
            largePrefab.SetActive(false);
        }