static void Postfix(CookingStation __instance, ZNetView ___m_nview) { if (!modEnabled.Value || !___m_nview.IsValid() || !___m_nview.IsOwner() || !EffectArea.IsPointInsideArea(__instance.transform.position, EffectArea.Type.Burning, 0.25f)) { return; } for (int i = 0; i < __instance.m_slots.Length; i++) { string itemName = ___m_nview.GetZDO().GetString("slot" + i, ""); float num = ___m_nview.GetZDO().GetFloat("slot" + i, 0f); if (itemName != "" && itemName != __instance.m_overCookedItem.name && itemName != null) { CookingStation.ItemConversion itemConversion = Traverse.Create(__instance).Method("GetItemConversion", new object[] { itemName }).GetValue <CookingStation.ItemConversion>(); if (num > itemConversion.m_cookTime && itemName == itemConversion.m_to.name) { if (autoPop.Value) { Traverse.Create(__instance).Method("SpawnItem", new object[] { itemName }).GetValue(); ___m_nview.GetZDO().Set("slot" + i, ""); ___m_nview.GetZDO().Set("slot" + i, 0f); ___m_nview.InvokeRPC(ZNetView.Everybody, "SetSlotVisual", new object[] { i, "" }); } else if (preventBurning.Value) { ___m_nview.GetZDO().Set("slot" + i, itemConversion.m_cookTime); } } } } }
private CookingStation GetClosest() { var stations = COMPONENT_DATABASE.RetrieveComponents <CookingStation>(); if (stations.Count == 0) { return(null); } CookingStation closest = null; float closestDist = float.MaxValue; foreach (var tree in stations) { float dist = (tree.gameObject.transform.position - transform.position).magnitude; if (dist < closestDist) { closest = (CookingStation)tree; closestDist = dist; } } return(closest); }
public static void Postfix(ref List <GameObject> __result, ref CookingStation __instance) { if (!Settings.Instance.Kitchen.IncludeRoom) { return; } ModifyKitchenResultUnits(ref __result, ref __instance); }
private void Update() { if (Input.GetKeyDown(KeyCode.F) && isTriggered) { bool showWarningMsg = false; // If in restaurant scene, check for any current food before transiting Scene currScene = SceneManager.GetActiveScene(); if (currScene.name == "TestRestaurant") { //Check if any leftover food CookingStation cookingStation = GameObject.Find("Recipe Controller").GetComponent <CookingStation>(); GameObject[] spawnFoodAreas = cookingStation.spawnFoodAreas; for (int i = 0; i < spawnFoodAreas.Length; i++) { if (spawnFoodAreas[i].transform.childCount != 0) { showWarningMsg = true; break; } } // If there if leftover food, show warning message // Else, let player transit if (showWarningMsg) { UIController uiController = GameObject.Find("UI Controller").GetComponent <UIController>(); uiController.ShowConfirmLeaveNotifPanel(); } else { if (enableGameSave) { saveGameDataSystem.SaveGameData((int)sceneIndex); } LoadScene(); } } else // in dungeon { if (enableGameSave) { saveGameDataSystem.SaveGameData((int)sceneIndex); } LoadScene(); } /* * Debug.Log("Player can transit"); * if (enableGameSave) * { * saveGameDataSystem.SaveGameData(sceneIndex); * } * LoadScene(); */ } }
private IEnumerator UpdateUIData(CookingStation cookingStation) { HighlightButton(); while (_UISlotData.Ingredient != null && (cookingStation.State == CookingStation.CookingStationState.AVAILABLE || cookingStation.State == CookingStation.CookingStationState.NOT_VISIBLE_TO_LOCAL_PLAYER)) { yield return(null); } DeHighlightButton(); }
private static bool GetHoverText(CookingStation __instance, ref string __result) { if (Main.timeLeftStyleCookingStation.Value == 0) { return(true); } return(Patches.HoverText.PatchCookingStation(__instance, ref __result)); }
private void Awake() { _CookingStation = GetComponentInParent <CookingStation>(); _StateImage = GetComponent <SpriteRenderer>(); _Animator = GetComponent <Animator>(); // Initial sprite update _DefaultCookingStationIcon = _StateImage.sprite; UpdateUI(); }
private void OnHeroNearCookingStation(object data) { CookingStation cookingStation = (CookingStation)data; // Check if the ingredient is compatible and the station is available if (_UISlotData.Ingredient != null && _UISlotData.Ingredient.CheckIfCompatible(cookingStation.CookingStepPerformed)) { StartCoroutine(UpdateUIData(cookingStation)); } }
public override void SetTarget() { var closest = GetClosest(); if (closest != null) { m_TargetStation = closest; target = m_TargetStation.transform; } }
static bool Prefix(ref CookingStation __instance, ref ZNetView ___m_nview, Humanoid user, bool hold) { if (hold) { return(false); } Traverse t_cookingStation = Traverse.Create(__instance); ZDO zdo = ___m_nview.GetZDO(); for (int slot = 0; slot < __instance.m_slots.Length; ++slot) { string itemName = zdo.GetString(nameof(slot) + slot); bool isItemDone = t_cookingStation.Method("IsItemDone", itemName).GetValue <bool>(); if (itemName != "" && itemName != __instance.m_overCookedItem.name && isItemDone) { JustAnotherCookingSkill.raiseCookingSkill(user, JustAnotherCookingSkill.cookingStaticExperienceGain.Value * 0.5f); string qualityPrefix = JustAnotherCookingSkill.getQualityBasedOnSkill(user); // check if such object exist string qualifyMealName = qualityPrefix + itemName; if (Prefab.Cache.GetPrefab <ItemDrop>(qualifyMealName) == null) { Log.LogError($"No object registered for qualify meal: {qualifyMealName}"); return(true); } // instead of processing normal food, we spawn qualified variant MethodInfo method = __instance.GetType().GetMethod("SpawnItem"); if (method == null) { Log.LogError("Method SpawnItem does not exist on type CookingStation"); return(true); } method.Invoke(__instance, new object[] { qualifyMealName }); zdo.Set("slot" + slot, ""); ___m_nview.InvokeRPC(ZNetView.Everybody, "SetSlotVisual", new object[] { slot, "" }); // Unfortunately we replace this hook totally and extra modifications will conflict on those. I gonna find better way return(false); } } return(true); }
public void Cook(int playerWhoIsCooking, CookingStation cookingStation, SO_Tag cookingStepPerformed) { cookingStation.Use(this); MinionStartedCookingEvent.Invoke(); // Recording the task performed CookingStationStepsPerformed.Add(cookingStepPerformed); CookingStationStepsToPerform.Remove(cookingStepPerformed); // Listening to cooked event cookingStation.StationInCoolDownEvent.AddListener(OnIngredientCooked); GetCooked(); }
private static void ModifyKitchenResultUnits(ref List <GameObject> __result, ref CookingStation __instance) { if (!Settings.Instance.Kitchen.IncludeRoom) { return; } if (RoomTypes_AllModded.IsInTheRoom(__instance, RoomTypeKitchenData.RoomId) && Settings.Instance.Kitchen.Bonus.HasValue) { foreach (GameObject go in __result) { go.GetComponent <PrimaryElement>().Units *= (1 + Settings.Instance.Kitchen.Bonus.Value); } } }
public void Cook(IngredientMinion ingredient, CookingPot cookingPot) { // Cooking the ingredient bool ingredientCooked = _TargetCookingStation.Use(ingredient); // Setting target cooking station to null _TargetCookingStation = null; // Updating ui and inventory only on the local machine if (IsLocal && ingredientCooked) { RemoveIngredientFromInventory(ingredient); // Telling the UI that something has happened to some ingredient, so that they update themselves _IngredientModifiedEvent.Invoke(null); } }
static void Postfix(CookingStation __instance, ZNetView ___m_nview) { Traverse traverse = Traverse.Create(__instance); if (!modEnabled.Value || !___m_nview.IsValid() || !___m_nview.IsOwner() || (__instance.m_requireFire && !traverse.Method("IsFireLit").GetValue <bool>()) || (__instance.m_useFuel && traverse.Method("GetFuel").GetValue <float>() <= 0f)) { return; } //Dbgl($"Updating {__instance.name}"); for (int i = 0; i < __instance.m_slots.Length; i++) { string itemName = ___m_nview.GetZDO().GetString("slot" + i, ""); float cookedTime = ___m_nview.GetZDO().GetFloat("slot" + i, 0f); int status = ___m_nview.GetZDO().GetInt("slotstatus" + i, 0); if (itemName == "") { continue; } CookingStation.ItemConversion itemConversion = traverse.Method("GetItemConversion", new object[] { itemName }).GetValue <CookingStation.ItemConversion>(); //Dbgl($"Updating slot {i} {cookedTime}/{itemConversion.m_cookTime} {status}"); if (itemName != "" && status != 2) { //Dbgl($"Updating slot {i} {itemName} {cookedTime}"); if (itemConversion != null && cookedTime > itemConversion.m_cookTime && itemName == itemConversion.m_to.name) { if (autoPop.Value) { Dbgl($"Popping {__instance.name} slot {i} {itemName}"); Traverse.Create(__instance).Method("SpawnItem", new object[] { itemName, i, __instance.m_slots[i].position }).GetValue(); ___m_nview.GetZDO().Set("slot" + i, ""); ___m_nview.GetZDO().Set("slot" + i, 0f); ___m_nview.InvokeRPC(ZNetView.Everybody, "SetSlotVisual", new object[] { i, "" }); } else if (preventBurning.Value) { ___m_nview.GetZDO().Set("slot" + i, itemConversion.m_cookTime); } } } } }
public static bool Prefix(CookingStation __instance, string name) { var itemPrefab = ObjectDB.instance.GetItemPrefab(name); var itemDrop = itemPrefab.GetComponent <ItemDrop>(); if (itemDrop != null) { itemDrop.m_itemData = new ExtendedItemData(itemDrop.m_itemData); } var pos = __instance.transform.position + Vector3.up * __instance.m_spawnOffset; var quaternion = Quaternion.Euler(0.0f, Random.Range(0, 360), 0.0f); var position = pos; var rotation = quaternion; var newObject = Object.Instantiate(itemPrefab, position, rotation); newObject.GetComponent <Rigidbody>().velocity = Vector3.up * __instance.m_spawnForce; __instance.m_pickEffector.Create(pos, Quaternion.identity); return(false); }
public void Resume() { mainPauseButtons.SetActive(true); optionButtons.SetActive(false); pauseMenuUI.SetActive(false); Time.timeScale = 1f; isGamePaused = false; Scene currScene = SceneManager.GetActiveScene(); if (currScene.name == "TestRestaurant") { CookingStation cookingStation = GameObject.Find("Recipe Controller").GetComponent <CookingStation>(); if (cookingStation.isCooking == true) { cookingStation.DisableMovementOfPlayer(); } } }
public override void ConfigureBuildingTemplate(GameObject go, Tag prefab_tag) { go.AddOrGet <BuildingComplete>().isManuallyOperated = true; CookingStation cookingStation = go.AddOrGet <CookingStation>(); cookingStation.resultState = ComplexFabricator.ResultState.Heated; cookingStation.heatedTemperature = 368.15f; go.AddOrGet <FabricatorIngredientStatusManager>(); go.AddOrGet <CopyBuildingSettings>(); go.AddOrGet <ComplexFabricatorWorkable>().overrideAnims = new KAnimFile[1] { Assets.GetAnim("anim_interacts_cookstation_kanim") }; cookingStation.sideScreenStyle = ComplexFabricatorSideScreen.StyleSetting.ListQueueHybrid; Prioritizable.AddRef(go); go.AddOrGet <DropAllWorkable>(); ConfigureRecipes(); go.AddOrGetDef <PoweredController.Def>(); BuildingTemplates.CreateComplexFabricatorStorage(go, cookingStation); }
private static ItemDrop.ItemData PullCookableItemFromNearbyChests(CookingStation station) { if (station.GetFreeSlot() == -1) { return(null); } Stopwatch delta = GameObjectAssistant.GetStopwatch(station.gameObject); int lookupInterval = Helper.Clamp(Configuration.Current.CraftFromChest.lookupInterval, 1, 10) * 1000; if (!delta.IsRunning || delta.ElapsedMilliseconds > lookupInterval) { nearbyChests = InventoryAssistant.GetNearbyChests(station.gameObject, Helper.Clamp(Configuration.Current.CraftFromChest.range, 1, 50), !Configuration.Current.CraftFromChest.ignorePrivateAreaCheck); delta.Restart(); } foreach (CookingStation.ItemConversion itemConversion in station.m_conversion) { ItemDrop.ItemData itemData = itemConversion.m_from.m_itemData; foreach (Container c in nearbyChests) { if (c.GetInventory().HaveItem(itemData.m_shared.m_name)) { // Remove one item from chest InventoryAssistant.RemoveItemFromChest(c, itemData); // Instantiate cookabled GameObject GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(itemConversion.m_from.gameObject.name); ZNetView.m_forceDisableInit = true; GameObject cookabledItem = UnityEngine.Object.Instantiate <GameObject>(itemPrefab); ZNetView.m_forceDisableInit = false; return(cookabledItem.GetComponent <ItemDrop>().m_itemData); } } } return(null); }
public static bool PatchCookingStation(CookingStation cookingStation, ref string hoverText) { if (cookingStation.m_nview.IsOwner() && cookingStation.IsFireLit()) { string cookingItems = ""; int items = 0; for (int i = 0; i < cookingStation.m_slots.Length; i++) { cookingStation.GetSlot(i, out string text, out float num); if (text != "" && text != cookingStation.m_overCookedItem.name) { CookingStation.ItemConversion itemConversion = cookingStation.GetItemConversion(text); if (text != null) { items++; if (num > itemConversion.m_cookTime) // Item overCooking { string time = Main.timeLeftStyleCookingStation.Value == 1 ? $"{num / (itemConversion.m_cookTime * 2f):P0}" : Helpers.TimeString(itemConversion.m_cookTime * 2f - num); cookingItems += $"\n{cookingStation.m_overCookedItem.GetHoverName()}: <color={overCookColor}>{time}</color>"; } else { string time = Main.timeLeftStyleCookingStation.Value == 1 ? $"{num / itemConversion.m_cookTime:P0}" : Helpers.TimeString(itemConversion.m_cookTime - num); cookingItems += $"\n{itemConversion.m_to.GetHoverName()}: {time}"; } } } } if (items > 0) { hoverText = items >= cookingStation.m_slots.Length ? Localization.instance.Localize($"{cookingStation.m_name}{cookingItems}") : Localization.instance.Localize($"{cookingStation.m_name}\n{_cookItem}\n{_selectItem}{cookingItems}"); return(false); // Overwrite games default string } } return(true); }
static void Prefix(ref CookingStation __instance, ref ZNetView ___m_nview, Humanoid user, bool hold) { if (hold) { return; } Traverse t_cookingStation = Traverse.Create(__instance); ZDO zdo = ___m_nview.GetZDO(); for (int slot = 0; slot < __instance.m_slots.Length; ++slot) { string itemName = zdo.GetString(nameof(slot) + slot); bool isItemDone = t_cookingStation.Method("IsItemDone", itemName).GetValue <bool>(); if (itemName != "" && itemName != __instance.m_overCookedItem.name && isItemDone) { ((Player)user).RaiseSkill((Skills.SkillType)COOKING_SKILL_ID, configCookingStationXPIncrease.Value * 0.75f); //Log($"[Removed Cooked Item from Cook Station] Increase Cooking Skill by {configCookingStationXPIncrease.Value * 0.75f}"); break; } } }
static void Postfix(CookingStation __instance, ref ItemDrop.ItemData __result) { Dbgl($"looking for cookable"); if (!AllowByKey() || __result != null || !((bool)typeof(CookingStation).GetMethod("IsFireLit", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { })) || ((int)typeof(CookingStation).GetMethod("GetFreeSlot", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { })) == -1) { return; } Dbgl($"missing cookable in player inventory"); List <Container> nearbyContainers = GetNearbyContainers(__instance.transform.position); foreach (CookingStation.ItemConversion itemConversion in __instance.m_conversion) { foreach (Container c in nearbyContainers) { ItemDrop.ItemData item = c.GetInventory().GetItem(itemConversion.m_from.m_itemData.m_shared.m_name); if (item != null) { if (oreDisallowTypes.Value.Split(',').Contains(item.m_dropPrefab.name)) { Dbgl($"container at {c.transform.position} has {item.m_stack} {item.m_dropPrefab.name} but it's forbidden by config"); continue; } Dbgl($"container at {c.transform.position} has {item.m_stack} {item.m_dropPrefab.name}, taking one"); __result = item; c.GetInventory().RemoveItem(itemConversion.m_from.m_itemData.m_shared.m_name, 1); typeof(Container).GetMethod("Save", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c, new object[] { }); typeof(Inventory).GetMethod("Changed", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(c.GetInventory(), new object[] { }); return; } } } }
private IEnumerator MovingToNode(Vector3 positionToMoveTo) { _Mover.SetDestination(positionToMoveTo); while (Vector3.Distance(transform.position, _TargetNode.SpotToStandIn.position) >= _MinimumDistanceBeforeStoppingFromNode) { yield return(null); } _TargetCookingStation = _TargetNode.GetComponent <CookingStation>(); if (_TargetCookingStation != null) { // Invoking the near cooking station event only if the hero is controlled locally if (IsLocal) { _HeroNearCookingStationEvent.Invoke(_TargetCookingStation); } _TargetCookingStation.PickUpCookedFood(OwnerID, IsLocal); } //_Mover.StopMoving(); _TargetNode = null; }
static void Prefix(CookingStation __instance) { if (!modEnabled.Value) { return; } int count = __instance.m_slots.Length; List <Transform> newSlots = new List <Transform>(__instance.m_slots); float target = Mathf.RoundToInt(count * slotMultiplier.Value); Dbgl($"Cooking station {__instance.name} awake. Slots {count}, target {target}"); while (count < target) { bool neg = true; List <Transform> currentSlots = new List <Transform>(newSlots); int off = 0; for (int i = 0; i <= currentSlots.Count; i++) { int idx = currentSlots.Count / 2 - 1 + (neg ? -off : off); Transform a = null; Transform b = null; if (idx >= 0) { a = currentSlots[idx]; // 0, 1, -1, 2 } if (idx < currentSlots.Count - 1) { b = currentSlots[idx + 1]; // 1, 2, 0, 3 } Transform c; if (a == null) { c = Instantiate(b, b.parent); c.position = b.position * 2 - Vector3.Lerp(b.position, currentSlots[idx + 2].position, 0.5f); newSlots.Insert(0, c); } else if (b == null) { c = Instantiate(a, a.parent); c.position = a.position * 2 - Vector3.Lerp(a.position, currentSlots[idx - 1].position, 0.5f); newSlots.Add(c); } else { c = Instantiate(a, a.parent); c.position = Vector3.Lerp(a.position, b.position, 0.5f); newSlots.Insert(idx + 1, c); } count++; if (count >= target) { break; } neg = !neg; if (i % 2 == 0) { off++; } } } Dbgl($"New number of slots {newSlots.Count}"); for (int i = 0; i < newSlots.Count; i++) { newSlots[i].name = "slot" + i; } __instance.m_slots = newSlots.ToArray(); }
protected override void DoReset() { m_TargetStation = null; m_Cooked = false; m_StartTime = 0f; }
private static void GenerateReferenceLists() { //Start surfing through all items foreach (GameObject go in ObjectDB.instance.m_items) { //Add to reference lists if not in their already MyReferences.TryAddToItemList(go); ItemDrop id = go.GetComponent <ItemDrop>(); if (id != null) { //var s = id.m_itemData.m_shared; //Log.LogMessage($"{id.name},{s.m_weight},{s.m_attackForce}"); ParticleSystemRenderer ps = go.GetComponent <ParticleSystemRenderer>(); if (ps != null) { if (!MyReferences.listOfMaterials.ContainsKey("item_particle".GetStableHashCode())) { MyReferences.TryAddToMaterialList(ps.sharedMaterial, "item_particle"); } } var shared = id.m_itemData.m_shared; //Start looking for weapon effects (fx, sfx, vfx) if (shared.m_itemType == ItemDrop.ItemData.ItemType.OneHandedWeapon || shared.m_itemType == ItemDrop.ItemData.ItemType.TwoHandedWeapon || shared.m_itemType == ItemDrop.ItemData.ItemType.Bow) { if (!MyReferences.listOfMaterials.ContainsKey("club_trail".GetStableHashCode())) { Transform thing = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(go.transform, "attach"); if (thing != null) { thing = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(thing, "equiped"); if (thing != null) { Transform trail = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(thing, "trail"); if (trail != null) { MeleeWeaponTrail mwt = trail.gameObject.GetComponent <MeleeWeaponTrail>(); MyReferences.TryAddToMaterialList(mwt._material, "club_trail"); } } } } MyReferences.TryExtractEffectsFromItemDropShared(shared); } //Check to see if item can also build things if (shared.m_buildPieces != null) { var pieceTable = shared.m_buildPieces.m_pieces; if (pieceTable != null) { foreach (var pieceTableItem in pieceTable) { MyReferences.TryAddToPieceList(pieceTableItem); //One off capture of a station extension's line effect StationExtension stationExtension = pieceTableItem.GetComponent <StationExtension>(); if (stationExtension != null && !MyReferences.listOfEffects.ContainsKey(stationExtension.m_connectionPrefab.name.GetStableHashCode())) { MyReferences.listOfEffects.Add(stationExtension.m_connectionPrefab.name.GetStableHashCode(), stationExtension.m_connectionPrefab); } //Collect this for items and pieces, for proper referencing CraftingStation craftingStation = pieceTableItem.GetComponent <CraftingStation>(); if (craftingStation != null && !MyReferences.listOfCraftingStations.ContainsKey(pieceTableItem.name.GetStableHashCode())) { MyReferences.listOfCraftingStations.Add(pieceTableItem.name.GetStableHashCode(), craftingStation); } CookingStation cookingStation = pieceTableItem.GetComponent <CookingStation>(); if (cookingStation != null && !MyReferences.listOfCookingStations.ContainsKey(pieceTableItem.name.GetStableHashCode())) { MyReferences.listOfCookingStations.Add(pieceTableItem.name.GetStableHashCode(), cookingStation); } //Extracting any Piece Placement Effects var PieceScript = pieceTableItem.GetComponent <Piece>(); if (PieceScript != null) { ExtractEffectsFromPiece(PieceScript.m_placeEffect); } //Extracting WearNTear effects var WearNTearScript = pieceTableItem.GetComponent <WearNTear>(); if (WearNTearScript != null) { ExtractEffectsFromPiece(WearNTearScript.m_destroyedEffect); ExtractEffectsFromPiece(WearNTearScript.m_hitEffect); ExtractEffectsFromPiece(WearNTearScript.m_switchEffect); } } } } } } }
static void Prefix(CookingStation __instance, ref ParticleSystem[] ___m_burntPS, ref ParticleSystem[] ___m_donePS, ref ParticleSystem[] ___m_ps, ref AudioSource[] ___m_as) { if (!modEnabled.Value) { return; } if (cookTimeMultiplier.Value != 1f) { for (int i = 0; i < __instance.m_conversion.Count; i++) { __instance.m_conversion[i].m_cookTime *= cookTimeMultiplier.Value; } } int count = __instance.m_slots.Length; List <Transform> newSlots = new List <Transform>(__instance.m_slots); Transform burnt = null; Transform done = null; float target = Mathf.RoundToInt(count * slotMultiplier.Value); Dbgl($"Cooking station {__instance.name} awake. Slots {count}, target {target}"); while (count < target) { bool neg = true; List <Transform> currentSlots = new List <Transform>(newSlots); int off = 0; for (int i = 0; i <= currentSlots.Count; i++) { int idx = currentSlots.Count / 2 - 1 + (neg ? -off : off); Transform a = null; Transform b = null; if (idx >= 0) { a = currentSlots[idx]; // 0, 1, -1, 2 } if (idx < currentSlots.Count - 1) { b = currentSlots[idx + 1]; // 1, 2, 0, 3 } Transform c; if (a == null) { c = Instantiate(b, b.parent); c.position = b.position * 2 - Vector3.Lerp(b.position, currentSlots[idx + 2].position, 0.5f); newSlots.Insert(0, c); } else if (b == null) { c = Instantiate(a, a.parent); c.position = a.position * 2 - Vector3.Lerp(a.position, currentSlots[idx - 1].position, 0.5f); newSlots.Add(c); } else { c = Instantiate(a, a.parent); c.position = Vector3.Lerp(a.position, b.position, 0.5f); newSlots.Insert(idx + 1, c); } count++; if (count >= target) { break; } neg = !neg; if (i % 2 == 0) { off++; } } } Dbgl($"New number of slots {newSlots.Count}"); for (int i = 0; i < newSlots.Count; i++) { newSlots[i].name = "slot" + i; } __instance.m_slots = newSlots.ToArray(); ___m_ps = new ParticleSystem[__instance.m_slots.Length]; ___m_as = new AudioSource[__instance.m_slots.Length]; List <ParticleSystem> oldBurnt = new List <ParticleSystem>(___m_burntPS); List <ParticleSystem> oldDone = new List <ParticleSystem>(___m_donePS); if (___m_burntPS.Length != 0) { Dbgl("setting burnt"); burnt = ___m_burntPS[0].transform; ___m_burntPS = new ParticleSystem[__instance.m_slots.Length]; } if (___m_donePS.Length != 0) { Dbgl("setting done"); done = ___m_donePS[0].transform; ___m_donePS = new ParticleSystem[__instance.m_slots.Length]; } for (int i = 0; i < __instance.m_slots.Length; i++) { ___m_ps[i] = __instance.m_slots[i].GetComponent <ParticleSystem>(); ___m_as[i] = __instance.m_slots[i].GetComponent <AudioSource>(); if (burnt) { ___m_burntPS[i] = Instantiate(burnt, burnt.parent).GetComponent <ParticleSystem>(); ___m_burntPS[i].name = "burnt" + i; ___m_burntPS[i].transform.localPosition = __instance.m_slots[i].localPosition; ParticleSystem.EmissionModule emissionModule = ___m_burntPS[i].emission; emissionModule.enabled = false; } if (done) { ___m_donePS[i] = Instantiate(done, done.parent).GetComponent <ParticleSystem>(); ___m_donePS[i].name = "done" + i; ___m_donePS[i].transform.localPosition = __instance.m_slots[i].localPosition; ParticleSystem.EmissionModule emissionModule = ___m_donePS[i].emission; emissionModule.enabled = false; } } foreach (var ps in oldBurnt) { Destroy(ps.gameObject); } foreach (var ps in oldDone) { Destroy(ps.gameObject); } }