Initial Commit

Customs/Appliances/Decorations/GrassBunny.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.Decorations
+{
+    public class GrassBunny : GenericDecorationAppliance
+    {
+        public override string UniqueNameID => "GrassBunny";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GrassBunny").AssignMaterialsByNames();
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.GrassBunny;
+    }
+}

Customs/Appliances/Decorations/MountedCarrots.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.Decorations
+{
+    public class MountedCarrots : GenericDecorationAppliance
+    {
+        public override string UniqueNameID => "MountedCarrots";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("MountedCarrots").AssignMaterialsByNames();
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            new CMustHaveWall()
+        };
+        public override OccupancyLayer Layer => OccupancyLayer.Wall;
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.MountedCarrots;
+    }
+}

Customs/Appliances/DyeProvider.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances
+{
+    public class DyeProvider : CustomAppliance
+    {
+        public override string UniqueNameID => "DyeProvider";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("DyeProvider").AssignMaterialsByNames();
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            KitchenPropertiesUtils.GetUnlimitedCItemProvider(GDOReferences.RedDye.ID),
+            new CVariableProvider
+            {
+                Current = 0,
+                Provide1 = GDOReferences.RedDye.ID,
+                Provide2 = GDOReferences.GreenDye.ID,
+                Provide3 = GDOReferences.BlueDye.ID
+            }
+        };
+
+        public override bool SellOnlyAsDuplicate => true;
+        public override bool IsPurchasable => true;
+        public override PriceTier PriceTier => PriceTier.Medium;
+        public override ShoppingTags ShoppingTags => ShoppingTags.Cooking | ShoppingTags.Misc;
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.DyeProvider;
+        
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            VariableProviderView variableProviderView = gameDataObject.Prefab.AddComponent<VariableProviderView>();
+            variableProviderView.Animator = gameDataObject.Prefab.GetComponent<Animator>();
+            gameDataObject.Prefab.GetChild("Bottles/BlueDyeBottle").AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Bottles/BlueDyeBottle/Octagon");
+            gameDataObject.Prefab.GetChild("Bottles/GreenDyeBottle").AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Bottles/GreenDyeBottle/Square");
+            gameDataObject.Prefab.GetChild("Bottles/RedDyeBottle").AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Bottles/RedDyeBottle/Circle");
+        }
+    }
+}

Customs/Appliances/EggBasketProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances
+{
+    public class EggBasketProvider : CustomAppliance
+    {
+        public override string UniqueNameID => "EggBasketProvider";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggBasketProvider").AssignMaterialsByNames();
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            new CItemHolder(),
+            new CItemProvider
+            {
+                Item = GDOReferences.EggBasket.ID,
+                Available = 1,
+                Maximum = 1,
+                PreventReturns = true,
+                AutoPlaceOnHolder = true
+            }
+        };
+
+        public override bool SellOnlyAsDuplicate => true;
+        public override bool IsPurchasable => true;
+        public override PriceTier PriceTier => PriceTier.Medium;
+        public override ShoppingTags ShoppingTags => ShoppingTags.Cooking | ShoppingTags.Misc;
+        public override List<Process> RequiresProcessForShop => new List<Process>
+        {
+            GDOReferences.SearchBush
+        };
+        
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.EggBasketProvider;
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+
+            HoldPointContainer holdPointContainer = gameDataObject.Prefab.AddComponent<HoldPointContainer>();
+            LimitedItemSourceView limitedItemSourceView = gameDataObject.Prefab.AddComponent<LimitedItemSourceView>();
+
+            holdPointContainer.HoldPoint = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            
+            limitedItemSourceView.HeldItemPosition = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            limitedItemSourceView.Items = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("HoldPoint/EggBasket")
+            };
+        }
+    }
+}

Customs/Appliances/EggMouldProvider.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances
+{
+    public class EggMouldProvider : CustomAppliance
+    {
+        public override string UniqueNameID => "EggMouldProvider";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggMouldProvider").AssignMaterialsByNames();
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            new CItemHolder(),
+            new CItemProvider
+            {
+                Item = GDOReferences.EggMould.ID,
+                Available = 1,
+                Maximum = 1,
+                PreventReturns = true,
+                AutoPlaceOnHolder = true
+            }
+        };
+
+        public override bool SellOnlyAsDuplicate => true;
+        public override bool IsPurchasable => true;
+        public override PriceTier PriceTier => PriceTier.Medium;
+        public override ShoppingTags ShoppingTags => ShoppingTags.Cooking | ShoppingTags.Misc;
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.EggMouldProvider;
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+
+            HoldPointContainer holdPointContainer = gameDataObject.Prefab.AddComponent<HoldPointContainer>();
+            LimitedItemSourceView limitedItemSourceView = gameDataObject.Prefab.AddComponent<LimitedItemSourceView>();
+
+            holdPointContainer.HoldPoint = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            
+            limitedItemSourceView.HeldItemPosition = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            limitedItemSourceView.Items = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("HoldPoint/EggMould")
+            };
+        }
+    }
+}

Customs/Appliances/GenerousBunnies.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Appliances
+{
+    public class GenerousBunnies : CustomAppliance
+    {
+        public override string UniqueNameID => "GenerousBunnies";
+        public override bool IsPurchasable => false;
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.GenerousBunnies;
+    }
+}

Customs/Appliances/HotCrossBunsProvider.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances
+{
+    public class HotCrossBunsProvider : GenericProvider
+    {
+        public override Item ProvidedItem => GDOReferences.RawHotCrossBun;
+        public override string UniqueNameID => "HotCrossBunsProvider";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("HotCrossBunsProvider").AssignMaterialsByNames();
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.HotCrossBunsProvider;
+    }
+}

Customs/Appliances/SceneAppliances/Bush.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Easter2025.Views;
+using Easter2025.Views.Local;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using Shapes;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.SceneAppliances
+{
+    public class Bush : GenericSceneAppliance
+    {
+        public override string UniqueNameID => "Bush";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("VanillaBush").AssignMaterialsByNames();
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            new CEggBush(),
+            new CCanHideItem(),
+            new CItemHolder(),
+            new CImmovable(),
+            new CTakesDuration
+            {
+                Total = 1,
+                Manual = true,
+                Mode = InteractionMode.Items
+            },
+            new CDisplayDuration
+            {
+                Process = GDOReferences.SearchBush.ID
+            }
+        };
+
+        public override bool IsNonInteractive => false;
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            HoldPointContainer holdPointContainer = gameDataObject.Prefab.AddComponent<HoldPointContainer>();
+            holdPointContainer.HoldPoint = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            BushView bushView = gameDataObject.Prefab.AddComponent<BushView>();
+            bushView.Animator = gameDataObject.Prefab.GetComponentInChildren<Animator>();
+        }
+    }
+}

Customs/Appliances/SceneAppliances/EasterGround.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.SceneAppliances
+{
+    public class EasterGround : GenericSceneAppliance
+    {
+        public override string UniqueNameID => "EasterGround";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EasterGround").AssignMaterialsByNames();
+    }
+}

Customs/Appliances/SceneAppliances/EasterTree.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Views.Local;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.SceneAppliances
+{
+    public class EasterTree : GenericSceneAppliance
+    {
+        public override string UniqueNameID => "EasterTree";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EasterTree").AssignMaterialsByNames();
+        
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            EggPileView eggPileView = Prefab.AddComponent<EggPileView>();
+            eggPileView.EggContainers = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("Eggs/Egg Container 1"),
+                gameDataObject.Prefab.GetChild("Eggs/Egg Container 2"),
+                gameDataObject.Prefab.GetChild("Eggs/Egg Container 3"),
+                gameDataObject.Prefab.GetChild("Eggs/Egg Container 4"),
+                gameDataObject.Prefab.GetChild("Eggs/Egg Container 5"),
+                gameDataObject.Prefab.GetChild("Eggs/Egg Container 6"),
+            };
+            base.OnRegister(gameDataObject);
+        }
+    }
+}

Customs/Appliances/SceneAppliances/EggCobblestone.cs

@@ -0,0 +1,30 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Views.Local;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.SceneAppliances
+{
+    public class EggCobblestone : GenericSceneAppliance
+    {
+        public override string UniqueNameID => "EggCobblestone";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggCobblestone").AssignMaterialsByNames();
+        
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            RandomRotationView randomRotationView = gameDataObject.Prefab.AddComponent<RandomRotationView>();
+            randomRotationView.Container = gameDataObject.Prefab.GetChild("Container");
+            randomRotationView.min = 0;
+            randomRotationView.max = 360;
+            
+            
+            RandomPlacementView randomPlacementView = gameDataObject.Prefab.AddComponent<RandomPlacementView>();
+            randomPlacementView.Container = gameDataObject.Prefab.GetChild("Container");
+            randomPlacementView.min = new(-0.1f,0,-0.1f);
+            randomPlacementView.max = new (0.1f,0,0.1f);
+        }
+    }
+}

Customs/Appliances/SceneAppliances/EggPile.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Views.Local;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances.SceneAppliances
+{
+    public class EggPile : GenericSceneAppliance
+    {
+        public override string UniqueNameID => "EggPile";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggPile").AssignMaterialsByNames();
+        
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            EggPileView eggPileView = gameDataObject.Prefab.AddComponent<EggPileView>();
+            eggPileView.EggContainers = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("EggContainer/Egg_1"),
+                gameDataObject.Prefab.GetChild("EggContainer/Egg_2"),
+                gameDataObject.Prefab.GetChild("EggContainer/Egg_3"),
+            };
+            
+            RandomRotationView randomRotationView = gameDataObject.Prefab.AddComponent<RandomRotationView>();
+            randomRotationView.Container = gameDataObject.Prefab.GetChild("EggContainer");
+        }
+    }
+}

Customs/Appliances/WrapperProvider.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Appliances
+{
+    public class WrapperProvider : CustomAppliance
+    {
+        public override string UniqueNameID => "WrapperProvider";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("WrapperProvider").AssignMaterialsByNames();
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            new CItemHolder(),
+            new CItemProvider
+            {
+                Item = GDOReferences.WrapperRoll.ID,
+                Available = 1,
+                Maximum = 1,
+                PreventReturns = true,
+                AutoPlaceOnHolder = true
+            }
+        };
+
+        public override bool SellOnlyAsDuplicate => true;
+        public override bool IsPurchasable => true;
+        public override PriceTier PriceTier => PriceTier.Medium;
+        public override ShoppingTags ShoppingTags => ShoppingTags.Cooking | ShoppingTags.Misc;
+        public override List<(Locale, ApplianceInfo)> InfoList => CenteralLang.Appliances.WrapperProvider;
+
+        public override void OnRegister(Appliance gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+
+            HoldPointContainer holdPointContainer = gameDataObject.Prefab.AddComponent<HoldPointContainer>();
+            LimitedItemSourceView limitedItemSourceView = gameDataObject.Prefab.AddComponent<LimitedItemSourceView>();
+
+            holdPointContainer.HoldPoint = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            
+            limitedItemSourceView.HeldItemPosition = gameDataObject.Prefab.GetChild("HoldPoint").transform;
+            limitedItemSourceView.Items = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("HoldPoint/WrapperRoll")
+            };
+        }
+    }
+}

Customs/Decor/EggWallpaper.cs

@@ -0,0 +1,17 @@
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Decor
+{
+    public class EggWallpaper : CustomDecor
+    {
+        public override string UniqueNameID => "EggWallpaper";
+        public override Material Material => MaterialUtils.GetCustomMaterial("EggWallpaper");
+        public override Appliance ApplicatorAppliance => GDOReferences.WallpaperApplicator;
+        public override LayoutMaterialType Type => LayoutMaterialType.Wallpaper;
+        public override bool IsAvailable => false;
+    }
+}

Customs/Decor/GalaxyEggsWallpaper.cs

@@ -0,0 +1,17 @@
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Decor
+{
+    public class GalaxyEggsWallpaper : CustomDecor
+    {
+        public override string UniqueNameID => "GalaxyEggsWallpaper";
+        public override Material Material => MaterialUtils.GetCustomMaterial("Galaxy Eggs");
+        public override Appliance ApplicatorAppliance => GDOReferences.WallpaperApplicator;
+        public override LayoutMaterialType Type => LayoutMaterialType.Wallpaper;
+        public override bool IsAvailable => false;
+    }
+}

Customs/Dishes/DishCremeEgg.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class DishCremeEgg : CustomDish
+    {
+        public override string UniqueNameID => "DishCremeEgg";
+        public override UnlockGroup UnlockGroup => UnlockGroup.Dish;
+        public override CardType CardType => CardType.Default;
+        public override DishCustomerChange CustomerMultiplier => DishCustomerChange.SmallDecrease;
+        public override DishType Type => DishType.Dessert;
+        public override int Difficulty => 3;
+
+        public override List<string> StartingNameSet => new()
+        {
+            "Gooey Goodness",
+            "Egg-streme Indulgence",
+            "Cracked and Packed",
+            "The Yolk of Luxury",
+            "What the Fudge?!",
+        };
+
+        public override HashSet<Item> MinimumIngredients => new()
+        {
+            GDOReferences.Sugar,
+            GDOReferences.Milk,
+            GDOReferences.Chocolate,
+            GDOReferences.Butter,
+            GDOReferences.EggMould,
+            GDOReferences.Pot,
+            GDOReferences.WrapperRoll,
+        };
+
+        public override HashSet<Process> RequiredProcesses => new()
+        {
+            GDOReferences.SteepTea,
+            GDOReferences.Chop,
+            GDOReferences.Knead,
+        };
+        
+        public override List<Dish> AlsoAddRecipes => new List<Dish>
+        {
+            GDOReferences.RecipeCremeFilling
+        };
+
+        public override GameObject IconPrefab => Mod.Bundle.LoadAsset<GameObject>("CremeEggIcon").AssignMaterialsByNames();
+
+        public override bool IsMainThatDoesNotNeedPlates => true;
+
+        public override List<Dish.MenuItem> ResultingMenuItems => new()
+        {
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.WrappedCremeEgg,
+                Phase = MenuPhase.Dessert,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            }
+        };
+
+        public override List<Unlock> HardcodedRequirements => new List<Unlock>
+        {
+            GDOReferences.DishDyedEggs
+        };
+
+        public override bool IsAvailableAsLobbyOption => Mod.ENABLE_ADDITIONAL_LOBBY_DISHES;
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.CremeEgg;
+
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.CremeEgg;
+    }
+}

Customs/Dishes/DishDevilledEggs.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class DishDevilledEggs : CustomDish
+    {
+        public override string UniqueNameID => "DishDevilledEggs";
+        public override UnlockGroup UnlockGroup => UnlockGroup.Dish;
+        public override CardType CardType => CardType.Default;
+        public override DishCustomerChange CustomerMultiplier => DishCustomerChange.SmallDecrease;
+        public override DishType Type => DishType.Side;
+        public override int Difficulty => 2;
+
+        public override List<string> StartingNameSet => new()
+        {
+            "Eggsorcist Kitchen",
+            "Hell’s Yolks",
+            "Crack Me If You Can",
+            "Boil and Trouble",
+            "Wickedly Whisked",
+        };
+
+        public override HashSet<Item> MinimumIngredients => new()
+        {
+            GDOReferences.Pot,
+            GDOReferences.Water,
+            GDOReferences.Egg,
+            GDOReferences.Oil,
+        };
+
+        public override HashSet<Process> RequiredProcesses => new()
+        {
+            GDOReferences.Cook,
+            GDOReferences.Chop,
+        };
+        
+        public override List<Dish> AlsoAddRecipes => new List<Dish>
+        {
+            GDOReferences.RecipeMayonnaise
+        };
+
+        public override GameObject IconPrefab => Mod.Bundle.LoadAsset<GameObject>("DevilledEggsIcon").AssignMaterialsByNames();
+
+        public override List<Dish.MenuItem> ResultingMenuItems => new()
+        {
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.DevilledEgg,
+                Phase = MenuPhase.Side,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            }
+        };
+
+        public override List<Unlock> HardcodedRequirements => new List<Unlock>
+        {
+            GDOReferences.DishDyedEggs
+        };
+
+        public override bool IsAvailableAsLobbyOption => Mod.ENABLE_ADDITIONAL_LOBBY_DISHES; 
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.DevilledEggs;
+
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.DevilledEggs;
+    }
+}

Customs/Dishes/DishDyedEggs.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class DishDyedEggs : CustomDish
+    {
+        public override string UniqueNameID => "DishDyedEggs";
+        public override UnlockGroup UnlockGroup => UnlockGroup.Dish;
+        public override CardType CardType => CardType.Default;
+        public override DishCustomerChange CustomerMultiplier => DishCustomerChange.SmallDecrease;
+        public override DishType Type => DishType.Base;
+        public override int Difficulty => 2;
+
+        public override List<string> StartingNameSet => new()
+        {
+            "Cracked & Colored",
+            "Egg-streme Makeover",
+            "Pastel & Protein",
+            "Yolk and Dye",
+            "Hue's Hungry?",
+        };
+
+        public override HashSet<Item> MinimumIngredients => new()
+        {
+            GDOReferences.Pot,
+            GDOReferences.Water,
+            GDOReferences.Egg,
+            GDOReferences.RedDye,
+            GDOReferences.GreenDye,
+            GDOReferences.BlueDye,
+        };
+
+        public override HashSet<Process> RequiredProcesses => new()
+        {
+            GDOReferences.Cook,
+        };
+
+        public override GameObject IconPrefab => Mod.Bundle.LoadAsset<GameObject>("DyedEggsIcon").AssignMaterialsByNames();
+
+        public override bool IsMainThatDoesNotNeedPlates => true;
+
+        public override List<Dish.MenuItem> ResultingMenuItems => new()
+        {
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.RedEgg,
+                Phase = MenuPhase.Main,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            },
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.GreenEgg,
+                Phase = MenuPhase.Main,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            },
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.BlueEgg,
+                Phase = MenuPhase.Main,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            }
+        };
+
+        public override bool IsAvailableAsLobbyOption => true; 
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.DyedEggs;
+
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.DyedEggs;
+    }
+}

Customs/Dishes/DishEasterBread.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class DishEasterBread : CustomDish
+    {
+        public override string UniqueNameID => "DishEasterBread";
+        public override UnlockGroup UnlockGroup => UnlockGroup.Dish;
+        public override CardType CardType => CardType.Default;
+        public override DishCustomerChange CustomerMultiplier => DishCustomerChange.SmallDecrease;
+        public override DishType Type => DishType.Dessert;
+        public override int Difficulty => 1;
+
+        public override List<string> StartingNameSet => new()
+        {
+            "",
+            "",
+            "",
+            "",
+            "",
+        };
+
+        public override HashSet<Item> MinimumIngredients => new()
+        {
+            GDOReferences.Pot,
+            GDOReferences.Water,
+            GDOReferences.Egg,
+            GDOReferences.Flour,
+        };
+
+        public override HashSet<Process> RequiredProcesses => new()
+        {
+            GDOReferences.Cook
+        };
+
+        public override GameObject IconPrefab => Mod.Bundle.LoadAsset<GameObject>("EasterBreadIcon").AssignMaterialsByNames();
+
+        public override List<Dish.MenuItem> ResultingMenuItems => new()
+        {
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.EasterBread,
+                Phase = MenuPhase.Dessert,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            }
+        };
+
+        public override List<Unlock> HardcodedRequirements => new List<Unlock>
+        {
+            GDOReferences.DishDyedEggs
+        };
+
+        public override bool IsAvailableAsLobbyOption => Mod.ENABLE_ADDITIONAL_LOBBY_DISHES;
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.EasterBread;
+
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.EasterBread;
+    }
+}

Customs/Dishes/DishHotCrossBun.cs

@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class DishHotCrossBun : CustomDish
+    {
+        public override string UniqueNameID => "DishHotCrossBun";
+        public override UnlockGroup UnlockGroup => UnlockGroup.Dish;
+        public override CardType CardType => CardType.Default;
+        public override DishCustomerChange CustomerMultiplier => DishCustomerChange.SmallDecrease;
+        public override DishType Type => DishType.Starter;
+        public override int Difficulty => 1;
+
+        public override List<string> StartingNameSet => new()
+        {
+            "Bun Intended",
+            "Too Hot to Cross",
+            "Criss Cross Delish",
+            "Bun Appétit",
+            "Rise and Cross",
+        };
+
+        public override HashSet<Item> MinimumIngredients => new()
+        {
+            GDOReferences.RawHotCrossBun,
+            GDOReferences.Butter,
+        };
+
+        public override HashSet<Process> RequiredProcesses => new()
+        {
+            GDOReferences.Cook,
+            GDOReferences.Chop,
+        };
+
+        public override GameObject IconPrefab => Mod.Bundle.LoadAsset<GameObject>("HotCrossBunIcon").AssignMaterialsByNames();
+
+        public override List<Dish.MenuItem> ResultingMenuItems => new()
+        {
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.HotCrossBun,
+                Phase = MenuPhase.Starter,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            }
+        };
+
+        public override List<Unlock> HardcodedRequirements => new List<Unlock>
+        {
+            GDOReferences.DishDyedEggs
+        };
+
+        public override bool IsAvailableAsLobbyOption => Mod.ENABLE_ADDITIONAL_LOBBY_DISHES;
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.HotCrossBuns;
+
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.HotCrossBuns;
+    }
+}

Customs/Dishes/DishPlasticEggs.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class DishPlasticEggs : CustomDish
+    {
+        public override string UniqueNameID => "DishPlasticEggs";
+        public override UnlockGroup UnlockGroup => UnlockGroup.Dish;
+        public override CardType CardType => CardType.Default;
+        public override DishCustomerChange CustomerMultiplier => DishCustomerChange.SmallDecrease;
+        public override DishType Type => DishType.Starter;
+        public override int Difficulty => 1;
+
+        public override List<Dish.MenuItem> ResultingMenuItems => new()
+        {
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.PinkPlasticEgg,
+                Phase = MenuPhase.Starter,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            },
+            
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.OrangePlasticEgg,
+                Phase = MenuPhase.Starter,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            },
+            
+            new Dish.MenuItem
+            {
+                Item = GDOReferences.YellowPlasticEgg,
+                Phase = MenuPhase.Starter,
+                Weight = 1,
+                DynamicMenuType = DynamicMenuType.Static,
+                DynamicMenuIngredient = null
+            }
+        };
+
+        public override bool IsUnlockable => false;
+        
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.PlasticEggs;
+
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.PlasticEggs;
+    }
+}

Customs/Dishes/RecipeCremeFilling.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class RecipeCremeFilling : CustomDish
+    {
+        public override string UniqueNameID => "RecipeCremeFilling";
+        public override DishType Type => DishType.Base;
+        public override int Difficulty => 1;
+
+        public override bool IsUnlockable => false;
+        
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.RecipeCremeFilling;
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.RecipeCremeFilling;
+    }
+}

Customs/Dishes/RecipeMayonnaise.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Dishes
+{
+    public class RecipeMayonnaise : CustomDish
+    {
+        public override string UniqueNameID => "RecipeMayonnaise";
+        public override DishType Type => DishType.Base;
+        public override int Difficulty => 1;
+
+        public override bool IsUnlockable => false;
+        
+        public override List<(Locale, UnlockInfo)> InfoList => CenteralLang.Unlocks.RecipeMayonnaise;
+        public override Dictionary<Locale, string> Recipe => CenteralLang.Recipes.RecipeMayonnaise;
+    }
+}

Customs/Generics/GenericDecorationAppliance.cs

@@ -0,0 +1,12 @@
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Generics
+{
+    public abstract class GenericDecorationAppliance : CustomAppliance
+    {
+        public override bool IsPurchasable => false;
+        public override ShoppingTags ShoppingTags => ShoppingTags.Decoration;
+        public override PriceTier PriceTier => PriceTier.Free;
+    }
+}

Customs/Generics/GenericPlatedDish.cs

@@ -0,0 +1,13 @@
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Generics
+{
+    public abstract class GenericPlatedDish : CustomItemGroup
+    {
+        public override Item DisposesTo => GDOReferences.Plate;
+        public override Item DirtiesTo => GDOReferences.PlateDirty;
+        public override bool CanContainSide => true;
+    }
+}

Customs/Generics/GenericProvider.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+
+namespace Easter2025.Customs.Generics
+{
+    public abstract class GenericProvider : CustomAppliance
+    {
+        public abstract Item ProvidedItem { get; }
+
+        public override List<IApplianceProperty> Properties => new()
+        {
+            KitchenPropertiesUtils.GetUnlimitedCItemProvider(ProvidedItem.ID)
+        };
+
+        public override bool SellOnlyAsDuplicate => true;
+        public override bool IsPurchasable => true;
+        public override PriceTier PriceTier => PriceTier.Medium;
+        public override ShoppingTags ShoppingTags => ShoppingTags.Cooking | ShoppingTags.Misc;
+    }
+}

Customs/Generics/GenericSceneAppliance.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Generics
+{
+    public abstract class GenericSceneAppliance : CustomAppliance
+    {
+        public override List<IApplianceProperty> Properties => new List<IApplianceProperty>
+        {
+            new CImmovable(),
+            new CStatic()
+        };
+
+        public override bool IsNonInteractive => true;
+        public override bool IsPurchasable => false;
+        public override bool PreventSale => false;
+    }
+}

Customs/Generics/GenericStackableItem.cs

@@ -0,0 +1,10 @@
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Generics
+{
+    public abstract class GenericStackableItem : CustomItem
+    {
+        public override ItemStorage ItemStorageFlags => ItemStorage.StackableFood;
+    }
+}

Customs/Generics/GenericStackableItemGroup.cs

@@ -0,0 +1,10 @@
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Generics
+{
+    public abstract class GenericStackableItemGroup : CustomItemGroup
+    {
+        public override ItemStorage ItemStorageFlags => ItemStorage.StackableFood;
+    }
+}

Customs/ItemGroups/BlueDevilledEgg.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class BlueDevilledEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "BlueDevilledEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueDevilledEgg").AssignMaterialsByNames();
+        public override bool IsMergeableSide => true;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.BlueDeYolkedSlicedEgg,
+                    GDOReferences.MixedEggYolk
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+    }
+}

Customs/ItemGroups/BlueEgg.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Easter2025.Views;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class BlueEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "BlueEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueEgg").AssignMaterialsByNames();
+        public override Item DirtiesTo => GDOReferences.BlueShell;
+        public override List<ItemGroupView.ColourBlindLabel> Labels => new List<ItemGroupView.ColourBlindLabel>
+        {
+            new ItemGroupView.ColourBlindLabel
+            {
+                Item = GDOReferences.BlueDye,
+                Text = "B"
+            }
+        };
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.BlueSlicedEgg
+            }
+        };
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CEggBasket.CanPlaceInBasket(),
+            new CEgg()
+        };
+
+        public override ItemValue ItemValue => ItemValue.SideMedium;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.BlueDye,
+                    GDOReferences.BoiledEgg
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override void OnRegister(ItemGroup gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Octagon");
+            TootieEggs tootieEggsView = gameDataObject.Prefab.AddComponent<TootieEggs>();
+            tootieEggsView.TootieEgg = gameDataObject.Prefab.GetChild("TootieEgg");
+            tootieEggsView.NormalEgg = gameDataObject.Prefab.GetChild("Egg_1");
+            gameDataObject.Prefab.GetChild("TootieEgg").SetActive(false);
+        }
+    }
+}

Customs/ItemGroups/BlueRawEasterBread.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class BlueRawEasterBread : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "BlueRawEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueRawEasterBread").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.BlueEgg,
+                    GDOReferences.Dough
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.BlueEasterBread
+            }
+        };
+    }
+}

Customs/ItemGroups/CremeEgg.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class CremeEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "CremeEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CremeEgg").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.FilledHalfEgg,
+                    GDOReferences.FilledHalfEgg
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+    }
+}

Customs/ItemGroups/DevilledEgg.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class DevilledEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "DevilledEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("DevilledEgg").AssignMaterialsByNames();
+        public override bool IsMergeableSide => true;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.DeYolkedSlicedEgg,
+                    GDOReferences.MixedEggYolk
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item> SatisfiedBy => new List<Item>
+        {
+            GDOReferences.DevilledEgg,
+            GDOReferences.RedDevilledEgg,
+            GDOReferences.GreenDevilledEgg,
+            GDOReferences.BlueDevilledEgg,
+        };
+    }
+}

Customs/ItemGroups/FilledEggMould.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class FilledEggMould : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "FilledEggMould";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("FilledEggMould").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.EggMould,
+                    GDOReferences.ChocolateMelted
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override Item.ItemProcess AutomaticItemProcess => new Item.ItemProcess
+        {
+            Process = GDOReferences.SteepTea,
+            Duration = 1,
+            Result = GDOReferences.PreppedEggMould,
+        };
+
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.SteepTea,
+                Duration = 1,
+                Result = GDOReferences.PreppedEggMould,
+            }
+        };
+    }
+}

Customs/ItemGroups/FilledHalfEgg.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class FilledHalfEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "FilledHalfEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("FilledHalfEgg").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.HalfEgg,
+                    GDOReferences.CremeFilling
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+    }
+}

Customs/ItemGroups/GreenDevilledEgg.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class GreenDevilledEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "GreenDevilledEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenDevilledEgg").AssignMaterialsByNames();
+        public override bool IsMergeableSide => true;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.GreenDeYolkedSlicedEgg,
+                    GDOReferences.MixedEggYolk
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+    }
+}

Customs/ItemGroups/GreenEgg.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Easter2025.Views;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class GreenEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "GreenEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenEgg").AssignMaterialsByNames();
+        public override Item DirtiesTo => GDOReferences.GreenShell;
+        public override List<ItemGroupView.ColourBlindLabel> Labels => new List<ItemGroupView.ColourBlindLabel>
+        {
+            new ItemGroupView.ColourBlindLabel
+            {
+                Item = GDOReferences.GreenDye,
+                Text = "G"
+            }
+        };
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.GreenSlicedEgg
+            }
+        };
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CEggBasket.CanPlaceInBasket(),
+            new CEgg()
+        };
+
+        public override ItemValue ItemValue => ItemValue.SideMedium;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.GreenDye,
+                    GDOReferences.BoiledEgg
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override void OnRegister(ItemGroup gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Square");
+            TootieEggs tootieEggsView = gameDataObject.Prefab.AddComponent<TootieEggs>();
+            tootieEggsView.TootieEgg = gameDataObject.Prefab.GetChild("TootieEgg");
+            tootieEggsView.NormalEgg = gameDataObject.Prefab.GetChild("Egg_1");
+            gameDataObject.Prefab.GetChild("TootieEgg").SetActive(false);
+        }
+    }
+}

Customs/ItemGroups/GreenRawEasterBread.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class GreenRawEasterBread : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "GreenRawEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenRawEasterBread").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.GreenEgg,
+                    GDOReferences.Dough
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.GreenEasterBread
+            }
+        };
+    }
+}

Customs/ItemGroups/HotCrossBun.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class HotCrossBun : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "HotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("HotCrossBun").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.CutCookedHotCrossBun,
+                    GDOReferences.Butter
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+        public override ItemValue ItemValue => ItemValue.Small;
+
+        public override void OnRegister(ItemGroup gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            if (gameDataObject.Prefab.TryGetComponent(out ItemGroupView itemGroupView))
+            {
+                itemGroupView.ComponentGroups = new List<ItemGroupView.ComponentGroup>
+                {
+                    new()
+                    {
+                        Item = GDOReferences.CutCookedHotCrossBun,
+                        Objects = new List<GameObject>
+                        {
+                            gameDataObject.Prefab.GetChild("Hot Cross Bun Split/Top"),
+                            gameDataObject.Prefab.GetChild("Hot Cross Bun Split/Bottom")
+                        },
+                        DrawAll = true
+                    },
+                    new()
+                    {
+                        Item = GDOReferences.Butter,
+                        GameObject = gameDataObject.Prefab.GetChild("Butter")
+                    }
+                };
+            }
+        }
+    }
+}

Customs/ItemGroups/MixedEggYolk.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class MixedEggYolk : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "MixedEggYolk";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("MixedEggYolk").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.Mayonnaise,
+                    GDOReferences.EggYolk
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+    }
+}

Customs/ItemGroups/RawCremeFillingPot.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class RawCremeFillingPot : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "RawCremeFillingPot";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RawCremeFillingPot").AssignMaterialsByNames();
+        public override Item DisposesTo => GDOReferences.Pot;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.Pot,
+                    GDOReferences.Milk
+                },
+                IsMandatory = true,
+                Min = 2,
+                Max = 2
+            },
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.Butter,
+                    GDOReferences.Sugar,
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 5f,
+                Result = GDOReferences.CookedCremeFillingPot
+            }
+        };
+
+        public override void OnRegister(ItemGroup gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            if (gameDataObject.Prefab.TryGetComponent(out ItemGroupView itemGroupView))
+            {
+                itemGroupView.ComponentGroups = new List<ItemGroupView.ComponentGroup>
+                {
+                    new()
+                    {
+                        Item = GDOReferences.Butter,
+                        GameObject = gameDataObject.Prefab.GetChild("Butter")
+                    },
+                    new()
+                    {
+                        Item = GDOReferences.Sugar,
+                        GameObject = gameDataObject.Prefab.GetChild("Sugar")
+                    }
+                };
+            }
+        }
+    }
+}

Customs/ItemGroups/RawEasterBread.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class RawEasterBread : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "RawEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RawEasterBread").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.BoiledEgg,
+                    GDOReferences.Dough
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.EasterBread
+            }
+        };
+    }
+}

Customs/ItemGroups/RawEggPot.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class RawEggPot : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "RawEggPot";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RawEggPot").AssignMaterialsByNames();
+        public override Item DisposesTo => GDOReferences.Pot;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.Pot,
+                    GDOReferences.Water
+                },
+                IsMandatory = true,
+                Min = 2,
+                Max = 2
+            },
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.Egg,
+                    GDOReferences.Egg,
+                    GDOReferences.Egg,
+                },
+                Min = 3,
+                Max = 3
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.BoiledEggPot
+            }
+        };
+
+        public override void OnRegister(ItemGroup gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            if (gameDataObject.Prefab.TryGetComponent(out ItemGroupView itemGroupView))
+            {
+                itemGroupView.ComponentGroups = new List<ItemGroupView.ComponentGroup>
+                {
+                    new()
+                    {
+                        Item = GDOReferences.Egg,
+                        Objects = new List<GameObject>
+                        {
+                            gameDataObject.Prefab.GetChild("Egg1"),
+                            gameDataObject.Prefab.GetChild("Egg2"),
+                            gameDataObject.Prefab.GetChild("Egg3"),
+                        }
+                    }
+                };
+            }
+        }
+    }
+}

Customs/ItemGroups/RedDevilledEgg.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class RedDevilledEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "RedDevilledEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedDevilledEgg").AssignMaterialsByNames();
+        public override bool IsMergeableSide => true;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.RedDeYolkedSlicedEgg,
+                    GDOReferences.MixedEggYolk
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+    }
+}

Customs/ItemGroups/RedEgg.cs

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Easter2025.Views;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class RedEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "RedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedEgg").AssignMaterialsByNames();
+        public override Item DirtiesTo => GDOReferences.RedShell;
+        public override List<ItemGroupView.ColourBlindLabel> Labels => new List<ItemGroupView.ColourBlindLabel>
+        {
+            new ItemGroupView.ColourBlindLabel
+            {
+                Item = GDOReferences.RedDye,
+                Text = "R"
+            }
+        };
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.RedSlicedEgg
+            }
+        };
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CEggBasket.CanPlaceInBasket(),
+            new CEgg()
+        };
+
+        public override ItemValue ItemValue => ItemValue.SideMedium;
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.RedDye,
+                    GDOReferences.BoiledEgg
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override void OnRegister(ItemGroup gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Circle");
+            TootieEggs tootieEggsView = gameDataObject.Prefab.AddComponent<TootieEggs>();
+            tootieEggsView.TootieEgg = gameDataObject.Prefab.GetChild("TootieEgg");
+            tootieEggsView.NormalEgg = gameDataObject.Prefab.GetChild("Egg_1");
+            gameDataObject.Prefab.GetChild("TootieEgg").SetActive(false);
+        }
+    }
+}

Customs/ItemGroups/RedRawEasterBread.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class RedRawEasterBread : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "RedRawEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedRawEasterBread").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.RedEgg,
+                    GDOReferences.Dough
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.RedEasterBread
+            }
+        };
+    }
+}

Customs/ItemGroups/UnwrappedCremeEgg.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.ItemGroups
+{
+    public class UnwrappedCremeEgg : GenericStackableItemGroup
+    {
+        public override string UniqueNameID => "UnwrappedCremeEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("UnwrappedCremeEgg").AssignMaterialsByNames();
+
+        public override List<ItemGroup.ItemSet> Sets => new()
+        {
+            new ItemGroup.ItemSet
+            {
+                Items = new List<Item>
+                {
+                    GDOReferences.CremeEgg,
+                    GDOReferences.Wrapper
+                },
+                Min = 2,
+                Max = 2
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Knead,
+                Duration = 1,
+                Result = GDOReferences.WrappedCremeEgg
+            }
+        };
+    }
+}

Customs/Items/BlueDeYolkedSlicedEgg.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BlueDeYolkedSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "BlueDeYolkedSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueDeYolkedSlicedEgg").AssignMaterialsByNames();
+    }
+}

Customs/Items/BlueDye.cs

@@ -0,0 +1,24 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BlueDye : GenericStackableItem
+    {
+        public override string UniqueNameID => "BlueDye";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueDye").AssignMaterialsByNames();
+        public override Appliance DedicatedProvider => GDOReferences.DyeProvider;
+        public override string ColourBlindTag => "B";
+
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Octagon");
+        }
+    }
+}

Customs/Items/BlueEasterBread.cs

@@ -0,0 +1,14 @@
+using Easter2025.Customs.Generics;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BlueEasterBread : GenericStackableItem
+    {
+        public override string UniqueNameID => "BlueEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueEasterBread").AssignMaterialsByNames();
+        public override ItemValue ItemValue => ItemValue.Small;
+    }
+}

Customs/Items/BlueShell.cs

@@ -0,0 +1,13 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BlueShell : GenericStackableItem
+    {
+        public override string UniqueNameID => "BlueShell";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueShell").AssignMaterialsByNames();
+    }
+}

Customs/Items/BlueSlicedEgg.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BlueSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "BlueSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BlueSlicedEgg").AssignMaterialsByNames();
+        public override int SplitCount => 1;
+        public override Item SplitSubItem => GDOReferences.EggYolk;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.BlueDeYolkedSlicedEgg };
+    }
+}

Customs/Items/BoiledEgg.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BoiledEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "BoiledEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BoiledEgg").AssignMaterialsByNames();
+        public override List<Item.ItemProcess> Processes => new List<Item.ItemProcess>
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.SlicedEgg
+            }
+        };
+    }
+}

Customs/Items/BoiledEggPot.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BoiledEggPot : CustomItem
+    {
+        public override string UniqueNameID => "BoiledEggPot";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BoiledEggPot").AssignMaterialsByNames();
+        public override Item DisposesTo => GDOReferences.Pot;
+        public override Item SplitSubItem => GDOReferences.BoiledEgg;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.Pot};
+        public override int SplitCount => 3;
+        
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            ObjectsSplittableView objectsSplittableView = gameDataObject.Prefab.AddComponent<ObjectsSplittableView>();
+            FieldInfo objectsInfo = ReflectionUtils.GetField<ObjectsSplittableView>("Objects");
+            List<GameObject> objects = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("Egg1"),
+                gameDataObject.Prefab.GetChild("Egg2"),
+                gameDataObject.Prefab.GetChild("Egg3")
+            };
+            objectsInfo.SetValue(objectsSplittableView, objects);
+        }
+    }
+}

Customs/Items/BurnedHotCrossBun.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class BurnedHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "BurnedHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("BurnedHotCrossBun").AssignMaterialsByNames();
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.CutBurnedHotCrossBun
+            }
+        };
+    }
+}

Customs/Items/CookedCremeFillingPot.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class CookedCremeFillingPot : CustomItem
+    {
+        public override string UniqueNameID => "CookedCremeFillingPot";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CookedCremeFillingPot").AssignMaterialsByNames();
+        public override Item DisposesTo => GDOReferences.Pot;
+        public override Item SplitSubItem => GDOReferences.CremeFilling;
+        public override bool PreventExplicitSplit => true;
+        public override bool AllowSplitMerging => true;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.Pot};
+        public override int SplitCount => 10;
+    }
+}

Customs/Items/CookedHotCrossBun.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using Unity.Collections;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class CookedHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "CookedHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CookedHotCrossBun").AssignMaterialsByNames();
+        public override Appliance DedicatedProvider => GDOReferences.HotCrossBunsProvider;
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CHiddenBurnProcess
+            {
+                Result = new FixedListInt64
+                {
+                    GDOReferences.FlamingHotCrossBun.ID
+                },
+                BurnableSurfaces = new FixedListInt64
+                {
+                    ApplianceReferences.Hob,
+                    ApplianceReferences.HobDanger,
+                    ApplianceReferences.HobSafe,
+                    ApplianceReferences.HobStarting,
+                },
+                BurnTimeInSeconds = 15
+            }
+        };
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.CutCookedHotCrossBun
+            }
+        };
+    }
+}

Customs/Items/CremeFilling.cs

@@ -0,0 +1,15 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class CremeFilling : GenericStackableItem
+    {
+        public override string UniqueNameID => "CremeFilling";
+    }
+}

Customs/Items/CutBurnedHotCrossBun.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class CutBurnedHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "CutBurnedHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CutBurnedHotCrossBun").AssignMaterialsByNames();
+    }
+}

Customs/Items/CutCookedHotCrossBun.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using Unity.Collections;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class CutCookedHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "CutCookedHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CutCookedHotCrossBun").AssignMaterialsByNames();
+        
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CHiddenBurnProcess
+            {
+                Result = new FixedListInt64
+                {
+                    GDOReferences.CutFlamingHotCrossBun.ID
+                },
+                BurnableSurfaces = new FixedListInt64
+                {
+                    ApplianceReferences.Hob,
+                    ApplianceReferences.HobDanger,
+                    ApplianceReferences.HobSafe,
+                    ApplianceReferences.HobStarting,
+                },
+                BurnTimeInSeconds = 15
+            }
+        };
+    }
+}

Customs/Items/CutFlamingHotCrossBun.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Easter2025.Views.Local;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+using UnityEngine.VFX;
+
+namespace Easter2025.Customs.Items
+{
+    public class CutFlamingHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "CutFlamingHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CutFlamingHotCrossBun").AssignMaterialsByNames().AssignVFXByNames();
+        // public override bool IsIndisposable => true;
+
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CCanTriggerOrbs()
+        };
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Clean,
+                Duration = 1,
+                Result = GDOReferences.CutBurnedHotCrossBun
+            }
+        };
+
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<FlamingView>().Fire = gameDataObject.Prefab.GetComponentInChildren<VisualEffect>();
+        }
+    }
+}

Customs/Items/CutRawHotCrossBun.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class CutRawHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "CutRawHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("CutRawHotCrossBun").AssignMaterialsByNames();
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.CutCookedHotCrossBun
+            }
+        };
+    }
+}

Customs/Items/DeYolkedSlicedEgg.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class DeYolkedSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "DeYolkedSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("DeYolkedSlicedEgg").AssignMaterialsByNames();
+    }
+}

Customs/Items/EasterBread.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class EasterBread : GenericStackableItem
+    {
+        public override string UniqueNameID => "EasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EasterBread").AssignMaterialsByNames();
+        public override ItemValue ItemValue => ItemValue.Small;
+        public override string ColourBlindTag => "E";
+
+        public override List<Item> SatisfiedBy => new List<Item>
+        {
+            GDOReferences.EasterBread,
+            GDOReferences.RedEasterBread,
+            GDOReferences.GreenEasterBread,
+            GDOReferences.BlueEasterBread,
+        };
+    }
+}

Customs/Items/EggBasket.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class EggBasket : CustomItem
+    {
+        public override string UniqueNameID => "EggBasket";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggBasket").AssignMaterialsByNames();
+        public override bool IsIndisposable => true;
+        public override int MaxOrderSharers => 3;
+
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CToolStorage
+            {
+                Capacity = 3
+            },
+            new CEquippableTool
+            {
+                CanHoldItems = false
+            },
+            new CEggBasket()
+        };
+
+
+
+        public override void OnRegister(Item item)
+        {
+            List<GameObject> storage = new List<GameObject>
+            {
+                GameObjectUtils.GetChildObject(item.Prefab, "HoldPoint1"),
+                GameObjectUtils.GetChildObject(item.Prefab, "HoldPoint2"),
+                GameObjectUtils.GetChildObject(item.Prefab, "HoldPoint3")
+            };
+            ItemVariableStorageView obj = item.Prefab.AddComponent<ItemVariableStorageView>();
+            obj.Storage = storage;
+        }
+    }
+}

Customs/Items/EggMould.cs

@@ -0,0 +1,16 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class EggMould : GenericStackableItem
+    {
+        public override string UniqueNameID => "EggMould";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggMould").AssignMaterialsByNames();
+        public override bool IsIndisposable => true;
+        public override Appliance DedicatedProvider => GDOReferences.EggMouldProvider;
+    }
+}

Customs/Items/EggYolk.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class EggYolk : GenericStackableItem
+    {
+        public override string UniqueNameID => "EggYolk";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EggYolk").AssignMaterialsByNames();
+    }
+}

Customs/Items/FlamingHotCrossBun.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Easter2025.Views.Local;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+using UnityEngine.VFX;
+
+namespace Easter2025.Customs.Items
+{
+    public class FlamingHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "FlamingHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("FlamingHotCrossBun").AssignMaterialsByNames().AssignVFXByNames();
+        // public override bool IsIndisposable => true;
+
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CCanTriggerOrbs()
+        };
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.CutFlamingHotCrossBun
+            },
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Clean,
+                Duration = 1,
+                Result = GDOReferences.BurnedHotCrossBun
+            }
+        };
+
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<FlamingView>().Fire = gameDataObject.Prefab.GetComponentInChildren<VisualEffect>();
+        }
+    }
+}

Customs/Items/GreenDeYolkedSlicedEgg.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class GreenDeYolkedSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "GreenDeYolkedSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenDeYolkedSlicedEgg").AssignMaterialsByNames();
+    }
+}

Customs/Items/GreenDye.cs

@@ -0,0 +1,24 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class GreenDye : GenericStackableItem
+    {
+        public override string UniqueNameID => "GreenDye";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenDye").AssignMaterialsByNames();
+        public override Appliance DedicatedProvider => GDOReferences.DyeProvider;
+        public override string ColourBlindTag => "G";
+
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Square");
+        }
+    }
+}

Customs/Items/GreenEasterBread.cs

@@ -0,0 +1,14 @@
+using Easter2025.Customs.Generics;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class GreenEasterBread : GenericStackableItem
+    {
+        public override string UniqueNameID => "GreenEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenEasterBread").AssignMaterialsByNames();
+        public override ItemValue ItemValue => ItemValue.Small;
+    }
+}

Customs/Items/GreenShell.cs

@@ -0,0 +1,13 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class GreenShell : GenericStackableItem
+    {
+        public override string UniqueNameID => "GreenShell";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenShell").AssignMaterialsByNames();
+    }
+}

Customs/Items/GreenSlicedEgg.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class GreenSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "GreenSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("GreenSlicedEgg").AssignMaterialsByNames();
+        public override int SplitCount => 1;
+        public override Item SplitSubItem => GDOReferences.EggYolk;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.GreenDeYolkedSlicedEgg };
+    }
+}

Customs/Items/HalfEgg.cs

@@ -0,0 +1,15 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class HalfEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "HalfEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("HalfEgg").AssignMaterialsByNames();
+    }
+}

Customs/Items/OrangePlasticEgg.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class OrangePlasticEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "OrangePlasticEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("OrangePlasticEgg").AssignMaterialsByNames();
+        public override string ColourBlindTag => "O";
+        public override ItemValue ItemValue => ItemValue.SideSmall;
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CHidableItem(),
+            new CEggBasket.CanPlaceInBasket()
+        };
+    }
+}

Customs/Items/PinkPlasticEgg.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class PinkPlasticEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "PinkPlasticEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("PinkPlasticEgg").AssignMaterialsByNames();
+        public override string ColourBlindTag => "P";
+        public override ItemValue ItemValue => ItemValue.SideSmall;
+
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CHidableItem(),
+            new CEggBasket.CanPlaceInBasket()
+        };
+    }
+}

Customs/Items/PreppedEggMould.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class PreppedEggMould : CustomItem
+    {
+        public override string UniqueNameID => "PreppedEggMould";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("PreppedEggMould").AssignMaterialsByNames();
+        public override Item DisposesTo => GDOReferences.EggMould;
+        public override Item SplitSubItem => GDOReferences.HalfEgg;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.EggMould };
+        public override int SplitCount => 10;
+        
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            ObjectsSplittableView objectsSplittableView = gameDataObject.Prefab.AddComponent<ObjectsSplittableView>();
+            FieldInfo objectsInfo = ReflectionUtils.GetField<ObjectsSplittableView>("Objects");
+            List<GameObject> objects = new List<GameObject>
+            {
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg1"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg2"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg3"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg4"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg5"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg6"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg7"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg8"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg9"),
+                gameDataObject.Prefab.GetChild("Eggs/HalfEgg10"),
+            };
+            objectsInfo.SetValue(objectsSplittableView, objects);
+        }
+    }
+}

Customs/Items/RawHotCrossBun.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class RawHotCrossBun : GenericStackableItem
+    {
+        public override string UniqueNameID => "RawHotCrossBun";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RawHotCrossBun").AssignMaterialsByNames();
+        public override Appliance DedicatedProvider => GDOReferences.HotCrossBunsProvider;
+
+        public override List<Item.ItemProcess> Processes => new()
+        {
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Chop,
+                Duration = 1,
+                Result = GDOReferences.CutRawHotCrossBun
+            },
+            new Item.ItemProcess
+            {
+                Process = GDOReferences.Cook,
+                Duration = 1,
+                Result = GDOReferences.CookedHotCrossBun
+            }
+        };
+    }
+}

Customs/Items/RedDeYolkedSlicedEgg.cs

@@ -0,0 +1,12 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class RedDeYolkedSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "RedDeYolkedSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedDeYolkedSlicedEgg").AssignMaterialsByNames();
+    }
+}

Customs/Items/RedDye.cs

@@ -0,0 +1,24 @@
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class RedDye : GenericStackableItem
+    {
+        public override string UniqueNameID => "RedDye";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedDye").AssignMaterialsByNames();
+        public override Appliance DedicatedProvider => GDOReferences.DyeProvider;
+        public override string ColourBlindTag => "R";
+
+        public override void OnRegister(Item gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            gameDataObject.Prefab.AddComponent<ColourBlindMode>().Element = gameDataObject.Prefab.GetChild("Circle");
+        }
+    }
+}

Customs/Items/RedEasterBread.cs

@@ -0,0 +1,14 @@
+using Easter2025.Customs.Generics;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class RedEasterBread : GenericStackableItem
+    {
+        public override string UniqueNameID => "RedEasterBread";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedEasterBread").AssignMaterialsByNames();
+        public override ItemValue ItemValue => ItemValue.Small;
+    }
+}

Customs/Items/RedShell.cs

@@ -0,0 +1,13 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class RedShell : GenericStackableItem
+    {
+        public override string UniqueNameID => "RedShell";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedShell").AssignMaterialsByNames();
+    }
+}

Customs/Items/RedSlicedEgg.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class RedSlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "RedSlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("RedSlicedEgg").AssignMaterialsByNames();
+        public override int SplitCount => 1;
+        public override Item SplitSubItem => GDOReferences.EggYolk;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.RedDeYolkedSlicedEgg };
+    }
+}

Customs/Items/SlicedEgg.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class SlicedEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "SlicedEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("SlicedEgg").AssignMaterialsByNames();
+        public override int SplitCount => 1;
+        public override Item SplitSubItem => GDOReferences.EggYolk;
+        public override List<Item> SplitDepletedItems => new List<Item> { GDOReferences.DeYolkedSlicedEgg };
+    }
+}

Customs/Items/WrappedCremeEgg.cs

@@ -0,0 +1,13 @@
+using Easter2025.Customs.Generics;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class WrappedCremeEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "WrappedCremeEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("WrappedCremeEgg").AssignMaterialsByNames();
+        public override string ColourBlindTag => "C";
+    }
+}

Customs/Items/Wrapper.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class Wrapper : GenericStackableItem
+    {
+        public override string UniqueNameID => "Wrapper";
+    }
+}

Customs/Items/WrapperRoll.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using Easter2025.Customs.Generics;
+using Easter2025.Utilies;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class WrapperRoll : GenericStackableItem
+    {
+        public override string UniqueNameID => "WrapperRoll";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("WrapperRoll").AssignMaterialsByNames();
+        public override int SplitCount => 999;
+        public override bool AllowSplitMerging => true;
+        public override bool PreventExplicitSplit => true;
+        public override Item SplitSubItem => GDOReferences.Wrapper;
+        public override Appliance DedicatedProvider => GDOReferences.WrapperProvider;
+    }
+}

Customs/Items/YellowPlasticEgg.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using Easter2025.Components;
+using Easter2025.Customs.Generics;
+using KitchenData;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.Items
+{
+    public class YellowPlasticEgg : GenericStackableItem
+    {
+        public override string UniqueNameID => "YellowPlasticEgg";
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("YellowPlasticEgg").AssignMaterialsByNames();
+        public override string ColourBlindTag => "Y";
+        public override ItemValue ItemValue => ItemValue.SideSmall;
+        public override List<IItemProperty> Properties => new List<IItemProperty>
+        {
+            new CHidableItem(),
+            new CEggBasket.CanPlaceInBasket()
+        };
+    }
+}

Customs/LayoutProfiles/BunnyLayout.cs

@@ -0,0 +1,160 @@
+using System.Collections.Generic;
+using Kitchen.Layouts;
+using Kitchen.Layouts.Modules;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using UnityEngine;
+using CustomSettingsAndLayouts;
+using Easter2025.Customs.RestaurantSettings;
+
+namespace Easter2025.Customs.LayoutProfiles
+{
+    public class BunnyLayout : CustomLayoutProfile
+    {
+        public override string UniqueNameID => "BunnyLayout";
+        public override LayoutGraph Graph => GenerateLayout(UniqueNameID);
+        public override int MaximumTables => 3;
+        public override List<GameDataObject> RequiredAppliances => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).RequiredAppliances;
+        public override GameDataObject Table => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).Table;
+        public override GameDataObject Counter => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).Counter;
+
+        public override Appliance ExternalBin => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).ExternalBin;
+
+        // This script was generated by Layout Builder
+        public static LayoutGraph GenerateLayout(string graphName)
+        {
+            // Creating the graph
+
+            LayoutGraph graph = ScriptableObject.CreateInstance<LayoutGraph>();
+
+            // Creating all the nodes
+
+            RecentreLayout RecentreLayout0 = ScriptableObject.CreateInstance<RecentreLayout>();
+            NewFromTexture NewFromTexture0 = ScriptableObject.CreateInstance<NewFromTexture>();
+            FindAllFeatures FindAllFeatures0 = ScriptableObject.CreateInstance<FindAllFeatures>();
+            FilterByRoom FilterByRoom0 = ScriptableObject.CreateInstance<FilterByRoom>();
+            FilterOnePerPair FilterOnePerPair0 = ScriptableObject.CreateInstance<FilterOnePerPair>();
+            CreateFrontDoor CreateFrontDoor0 = ScriptableObject.CreateInstance<CreateFrontDoor>();
+            FilterByRoom FilterByRoom1 = ScriptableObject.CreateInstance<FilterByRoom>();
+            Output Output0 = ScriptableObject.CreateInstance<Output>();
+            RequireAccessible RequireAccessible0 = ScriptableObject.CreateInstance<RequireAccessible>();
+            AppendFeatures AppendFeatures0 = ScriptableObject.CreateInstance<AppendFeatures>();
+            AppendFeatures AppendFeatures1 = ScriptableObject.CreateInstance<AppendFeatures>();
+            SwitchFeatures SwitchFeatures0 = ScriptableObject.CreateInstance<SwitchFeatures>();
+
+            // Setting all the values
+
+            RecentreLayout0.FixSeed = 0;
+            RecentreLayout0.position = new Vector2(-500f, 488);
+            NewFromTexture0.SourceTexture = ResourceUtils.LoadTextureFromBase64("iVBORw0KGgoAAAANSUhEUgAAAA4AAAARCAYAAADtyJ2fAAAAeklEQVQoFcVSQQ7AIAiD/f/PDpAi0UTDPAwzq0ClQ4ncGlHTD/sFm8R0uLHiTBCn+ZGUCeZjYp5JSA5yqoKY4pM3lfUPxPiXik5pzp3UUlWppuJsGir1DeyMIz8W/eHsSIh1shNPlUAC8mVzcE4FP1/HbXMg8tSkcR0vsCgaGOy4qGgAAAAASUVORK5CYII=");
+            NewFromTexture0.Map = new List<NewFromTexture.ColorRoom>();
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom0 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom0.Color = new Color(0f, 0f, 0f, 0f);
+            NewFromTexture0_colorRoom0.Room = new Room(-1616784683, RoomType.NoRoom);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom0);
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom1 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom1.Color = new Color(1f, 0f, 0f, 1f);
+            NewFromTexture0_colorRoom1.Room = new Room(-794953739, RoomType.Kitchen);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom1);
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom2 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom2.Color = new Color(0f, 0f, 1f, 1f);
+            NewFromTexture0_colorRoom2.Room = new Room(1686145292, RoomType.Dining);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom2);
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom3 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom3.Color = new Color(0f, 1f, 0f, 1f);
+            NewFromTexture0_colorRoom3.Room = new Room(1773383595, RoomType.Kitchen);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom3);
+            NewFromTexture0.FixSeed = 0;
+            NewFromTexture0.position = new Vector2(-1150f, 488);
+            FindAllFeatures0.Feature = FeatureType.Door;
+            FindAllFeatures0.FixSeed = 0;
+            FindAllFeatures0.position = new Vector2(-287f, 738);
+            FilterByRoom0.RemoveMode = false;
+            FilterByRoom0.Type1 = RoomType.Kitchen;
+            FilterByRoom0.FilterSecond = true;
+            FilterByRoom0.Type2 = RoomType.Dining;
+            FilterByRoom0.FixSeed = 0;
+            FilterByRoom0.position = new Vector2(-87f, 738);
+            FilterOnePerPair0.FixSeed = 0;
+            FilterOnePerPair0.position = new Vector2(263f, 738);
+            CreateFrontDoor0.Type = RoomType.Dining;
+            CreateFrontDoor0.ForceFirstHalf = true;
+            CreateFrontDoor0.FixSeed = 0;
+            CreateFrontDoor0.position = new Vector2(-275f, 488);
+            FilterByRoom1.RemoveMode = false;
+            FilterByRoom1.Type1 = RoomType.Kitchen;
+            FilterByRoom1.FilterSecond = true;
+            FilterByRoom1.Type2 = RoomType.Dining;
+            FilterByRoom1.FixSeed = 0;
+            FilterByRoom1.position = new Vector2(-87f, 988);
+            Output0.FixSeed = 0;
+            Output0.position = new Vector2(1286f, 500);
+            RequireAccessible0.AllowGardens = false;
+            RequireAccessible0.ResultStatus = true;
+            RequireAccessible0.FixSeed = 0;
+            RequireAccessible0.position = new Vector2(948f, 500);
+            AppendFeatures0.FixSeed = 0;
+            AppendFeatures0.position = new Vector2(463f, 500);
+            AppendFeatures1.FixSeed = 0;
+            AppendFeatures1.position = new Vector2(673f, 500);
+            SwitchFeatures0.SetToFeature = FeatureType.Hatch;
+            SwitchFeatures0.FixSeed = 0;
+            SwitchFeatures0.position = new Vector2(248f, 988);
+
+            // Connecting all the nodes
+
+            RecentreLayout0.GetPort("Input").Connect(NewFromTexture0.GetPort("Output"));
+            FindAllFeatures0.GetPort("Input").Connect(RecentreLayout0.GetPort("Output"));
+            FilterByRoom0.GetPort("Input").Connect(FindAllFeatures0.GetPort("Output"));
+            FilterOnePerPair0.GetPort("Input").Connect(FilterByRoom0.GetPort("Output"));
+            CreateFrontDoor0.GetPort("Input").Connect(RecentreLayout0.GetPort("Output"));
+            FilterByRoom1.GetPort("Input").Connect(FindAllFeatures0.GetPort("Output"));
+            Output0.GetPort("Input").Connect(RequireAccessible0.GetPort("Output"));
+            RequireAccessible0.GetPort("Input").Connect(AppendFeatures1.GetPort("Output"));
+            AppendFeatures0.GetPort("AppendFrom").Connect(FilterOnePerPair0.GetPort("Output"));
+            AppendFeatures0.GetPort("Input").Connect(CreateFrontDoor0.GetPort("Output"));
+            AppendFeatures1.GetPort("AppendFrom").Connect(SwitchFeatures0.GetPort("Output"));
+            AppendFeatures1.GetPort("Input").Connect(AppendFeatures0.GetPort("Output"));
+            SwitchFeatures0.GetPort("Input").Connect(FilterByRoom1.GetPort("Output"));
+
+            // Adding all the nodes to the graph and setting the graph
+
+            graph.nodes.Add(RecentreLayout0);
+            RecentreLayout0.graph = graph;
+            graph.nodes.Add(NewFromTexture0);
+            NewFromTexture0.graph = graph;
+            graph.nodes.Add(FindAllFeatures0);
+            FindAllFeatures0.graph = graph;
+            graph.nodes.Add(FilterByRoom0);
+            FilterByRoom0.graph = graph;
+            graph.nodes.Add(FilterOnePerPair0);
+            FilterOnePerPair0.graph = graph;
+            graph.nodes.Add(CreateFrontDoor0);
+            CreateFrontDoor0.graph = graph;
+            graph.nodes.Add(FilterByRoom1);
+            FilterByRoom1.graph = graph;
+            graph.nodes.Add(Output0);
+            Output0.graph = graph;
+            graph.nodes.Add(RequireAccessible0);
+            RequireAccessible0.graph = graph;
+            graph.nodes.Add(AppendFeatures0);
+            AppendFeatures0.graph = graph;
+            graph.nodes.Add(AppendFeatures1);
+            AppendFeatures1.graph = graph;
+            graph.nodes.Add(SwitchFeatures0);
+            SwitchFeatures0.graph = graph;
+            graph.name = graphName;
+
+            return graph;
+        }
+
+
+        public override void OnRegister(LayoutProfile gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            Registry.AddSettingLayout((RestaurantSetting)GDOUtils.GetCustomGameDataObject<Easter2025Setting>().GameDataObject, gameDataObject);
+        }
+    }
+}

Customs/LayoutProfiles/Decorators/EasterDiningDecorator.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Linq;
+using Easter2025.Utilies;
+using Kitchen;
+using Kitchen.Layouts;
+using KitchenLib.References;
+using UnityEngine;
+
+namespace Easter2025.Customs.LayoutProfiles.Decorators
+{
+    public class EasterDiningDecorator : Decorator
+    {
+        private List<LayoutPosition> used_positions = new List<LayoutPosition>();
+        public override bool Decorate(Room room)
+        {
+            List<CLayoutAppliancePlacement> bushesToAdd = new List<CLayoutAppliancePlacement>();
+            List<CLayoutAppliancePlacement> tablesToAdd = new List<CLayoutAppliancePlacement>();
+            int minBushes = 3;
+            int maxBushes = 5;
+            List<LayoutPosition> ShuffledPositions = (from r in Blueprint.TilesOfRoom(room) orderby UnityEngine.Random.value select r).ToList();
+            
+            for (int i = 0; i < 8; i++)
+            {
+                if (FindValidPlacementLocation(ShuffledPositions, out LayoutPosition result, 10))
+                {
+                    if (Random.value < 0.5f)
+                    {
+                        if (bushesToAdd.Count < maxBushes)
+                        {
+                            bushesToAdd.Add(new CLayoutAppliancePlacement
+                            {
+                                Position = result,
+                                Appliance = GDOReferences.Bush.ID,
+                                Rotation = new Quaternion(0, Random.Range(0, 360), 0, 0)
+                            });
+                            used_positions.Add(result);
+                            foreach (LayoutPosition position in LayoutHelpers.AllNearby)
+                            {
+                                used_positions.Add(result + position);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (tablesToAdd.Count < Profile.MaximumTables)
+                        {
+                            tablesToAdd.Add(new CLayoutAppliancePlacement
+                            {
+                                Position = result,
+                                Appliance = Profile.Table.ID,
+                                Rotation = Quaternion.identity
+                            });
+                            used_positions.Add(result);
+                            foreach (LayoutPosition position in LayoutHelpers.AllNearby)
+                            {
+                                used_positions.Add(result + position);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (bushesToAdd.Count > maxBushes || bushesToAdd.Count <= minBushes || tablesToAdd.Count > Profile.MaximumTables) return false;
+            
+            foreach (var decoration in bushesToAdd)
+            {
+                Decorations.Add(decoration);
+            }
+            foreach (var decoration in tablesToAdd)
+            {
+                Decorations.Add(decoration);
+            }
+
+            return true;
+
+        }
+
+        private bool FindValidPlacementLocation(List<LayoutPosition> positions, out LayoutPosition result, int attempts = 5)
+        {
+            result = default;
+            if (attempts < 0) return false;
+            LayoutPosition randomPosition = positions[Random.Range(0, positions.Count)];
+            if (!used_positions.Contains(randomPosition) && !Blueprint.HasFeature(randomPosition) && Blueprint.IsTileOpenSpace(randomPosition))
+            {
+                result = randomPosition;
+                return true;
+            }
+            
+            return FindValidPlacementLocation(positions, out result, attempts - 1);
+        }
+    }
+}

Customs/LayoutProfiles/Decorators/EasterKitchenDecorator.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Kitchen;
+using Kitchen.Layouts;
+using KitchenData;
+using UnityEngine;
+
+namespace Easter2025.Customs.LayoutProfiles.Decorators
+{
+    public class EasterKitchenDecorator : Decorator
+    {
+        public override bool Decorate(Room room)
+        {
+            Queue<GameDataObject> queue = new Queue<GameDataObject>(Profile.RequiredAppliances);
+            List<Vector3> used_tiles = new List<Vector3>(Decorations.Select((CLayoutAppliancePlacement d) => d.Position));
+            HashSet<LayoutPosition> room_tiles = Blueprint.TilesOfRoom(room);
+            foreach (LayoutPosition item in room_tiles)
+            {
+                if (Blueprint.HasFeature(item, FeatureType.Hatch))
+                {
+                    Decorations.Add(new CLayoutAppliancePlacement
+                    {
+                        Appliance = Profile.Counter.ID,
+                        Position = item,
+                        Rotation = FindWallRotation(item)
+                    });
+                    used_tiles.Add(item);
+                }
+            }
+
+            int counter = 0;
+            var internalWalls = GetInternalWalls(room).Where(x => !used_tiles.Contains(x)).ToList();
+            
+            LayoutPosition layoutPosition = next_tile(Kitchen.RandomExtensions.Random(GetInternalWalls(room).Where(x => !used_tiles.Contains(x)).ToList()));
+            while (queue.Count > 0)
+            {
+                if (used_tiles.Contains(internalWalls[counter]) || Blueprint.HasFeature(internalWalls[counter], FeatureType.Door))
+                {
+                    counter++;
+                    continue;
+                }
+
+                Decorations.Add(new CLayoutAppliancePlacement
+                {
+                    Appliance = queue.Dequeue().ID,
+                    Position = internalWalls[counter],
+                    Rotation = FindWallRotation(internalWalls[counter])
+                });
+                used_tiles.Add(internalWalls[counter]);
+                counter++;
+            }
+            return true;
+            LayoutPosition next_tile(LayoutPosition tile)
+            {
+                foreach (LayoutPosition item2 in Blueprint.AdjacentInRoom(tile).Concat(room_tiles))
+                {
+                    if (Blueprint.IsTileAccessible(item2) && !used_tiles.Contains(item2))
+                    {
+                        used_tiles.Add(item2);
+                        return item2;
+                    }
+                }
+                throw new LayoutFailureException("Not enough spaces to place kitchen equipment");
+                
+            }
+        }
+
+        private List<LayoutPosition> GetInternalWalls(Room room)
+        {
+            List<LayoutPosition> walls = new List<LayoutPosition>();
+            var room_tiles = Blueprint.TilesOfRoom(room);
+            foreach (var tile in room_tiles)
+            {
+                foreach (var walltile in Blueprint.GetWalls(tile))
+                {
+                    walls.Add(tile);
+                }
+            }
+
+            return walls;
+        }
+
+        private Quaternion FindWallRotation(LayoutPosition pos)
+        {
+            Room room = Blueprint[pos];
+            foreach (LayoutPosition layoutPosition in LayoutHelpers.Directions)
+            {
+                LayoutPosition layoutPosition2 = layoutPosition + pos;
+                if (Blueprint[layoutPosition2].ID != room.ID)
+                {
+                    return Quaternion.LookRotation(new Vector3(layoutPosition.x, 0f, layoutPosition.y), Vector3.up);
+                }
+            }
+
+            return Quaternion.identity;
+        }
+    }
+}

Customs/LayoutProfiles/GardenBunnyLayout.cs

@@ -0,0 +1,160 @@
+using System.Collections.Generic;
+using Kitchen.Layouts;
+using Kitchen.Layouts.Modules;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using UnityEngine;
+using CustomSettingsAndLayouts;
+using Easter2025.Customs.RestaurantSettings;
+
+namespace Easter2025.Customs.LayoutProfiles
+{
+    public class GardenBunnyLayout : CustomLayoutProfile
+    {
+        public override string UniqueNameID => "GardenBunnyLayout";
+        public override LayoutGraph Graph => GenerateLayout(UniqueNameID);
+        public override int MaximumTables => 3;
+        public override List<GameDataObject> RequiredAppliances => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).RequiredAppliances;
+        public override GameDataObject Table => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).Table;
+        public override GameDataObject Counter => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).Counter;
+
+        public override Appliance ExternalBin => ((LayoutProfile)GDOUtils.GetExistingGDO(LayoutProfileReferences.DinerLayout)).ExternalBin;
+
+// This script was generated by Layout Builder
+        public static LayoutGraph GenerateLayout(string graphName)
+        {
+            // Creating the graph
+
+            LayoutGraph graph = ScriptableObject.CreateInstance<LayoutGraph>();
+
+            // Creating all the nodes
+
+            RecentreLayout RecentreLayout0 = ScriptableObject.CreateInstance<RecentreLayout>();
+            NewFromTexture NewFromTexture0 = ScriptableObject.CreateInstance<NewFromTexture>();
+            FindAllFeatures FindAllFeatures0 = ScriptableObject.CreateInstance<FindAllFeatures>();
+            FilterByRoom FilterByRoom0 = ScriptableObject.CreateInstance<FilterByRoom>();
+            FilterOnePerPair FilterOnePerPair0 = ScriptableObject.CreateInstance<FilterOnePerPair>();
+            CreateFrontDoor CreateFrontDoor0 = ScriptableObject.CreateInstance<CreateFrontDoor>();
+            FilterByRoom FilterByRoom1 = ScriptableObject.CreateInstance<FilterByRoom>();
+            Output Output0 = ScriptableObject.CreateInstance<Output>();
+            AppendFeatures AppendFeatures0 = ScriptableObject.CreateInstance<AppendFeatures>();
+            AppendFeatures AppendFeatures1 = ScriptableObject.CreateInstance<AppendFeatures>();
+            SwitchFeatures SwitchFeatures0 = ScriptableObject.CreateInstance<SwitchFeatures>();
+            RequireAccessible RequireAccessible0 = ScriptableObject.CreateInstance<RequireAccessible>();
+
+            // Setting all the values
+
+            RecentreLayout0.FixSeed = 0;
+            RecentreLayout0.position = new Vector2(-512f, 488);
+            NewFromTexture0.SourceTexture = ResourceUtils.LoadTextureFromBase64("iVBORw0KGgoAAAANSUhEUgAAAA4AAAARCAYAAADtyJ2fAAAAeklEQVQoFcVSQQ7AIAiD/f/PDpAi0UTDPAwzq0ClQ4ncGlHTD/sFm8R0uLHiTBCn+ZGUCeZjYp5JSA5yqoKY4pM3lfUPxPiXik5pzp3UUlWppuJsGir1DeyMIz8W/eHsSIh1shNPlUAC8mVzcE4FP1/HbXMg8tSkcR0vsCgaGOy4qGgAAAAASUVORK5CYII=");
+            NewFromTexture0.Map = new List<NewFromTexture.ColorRoom>();
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom0 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom0.Color = new Color(0f, 0f, 0f, 0f);
+            NewFromTexture0_colorRoom0.Room = new Room(-1616784683, RoomType.NoRoom);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom0);
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom1 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom1.Color = new Color(1f, 0f, 0f, 1f);
+            NewFromTexture0_colorRoom1.Room = new Room(-794953739, RoomType.Kitchen);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom1);
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom2 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom2.Color = new Color(0f, 0f, 1f, 1f);
+            NewFromTexture0_colorRoom2.Room = new Room(1686145292, RoomType.Garden);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom2);
+            NewFromTexture.ColorRoom NewFromTexture0_colorRoom3 = new NewFromTexture.ColorRoom();
+            NewFromTexture0_colorRoom3.Color = new Color(0f, 1f, 0f, 1f);
+            NewFromTexture0_colorRoom3.Room = new Room(1773383595, RoomType.Kitchen);
+            NewFromTexture0.Map.Add(NewFromTexture0_colorRoom3);
+            NewFromTexture0.FixSeed = 0;
+            NewFromTexture0.position = new Vector2(-1162f, 488);
+            FindAllFeatures0.Feature = FeatureType.Door;
+            FindAllFeatures0.FixSeed = 0;
+            FindAllFeatures0.position = new Vector2(-300f, 738);
+            FilterByRoom0.RemoveMode = false;
+            FilterByRoom0.Type1 = RoomType.Kitchen;
+            FilterByRoom0.FilterSecond = true;
+            FilterByRoom0.Type2 = RoomType.Garden;
+            FilterByRoom0.FixSeed = 0;
+            FilterByRoom0.position = new Vector2(-100f, 738);
+            FilterOnePerPair0.FixSeed = 0;
+            FilterOnePerPair0.position = new Vector2(250f, 738);
+            CreateFrontDoor0.Type = RoomType.Garden;
+            CreateFrontDoor0.ForceFirstHalf = true;
+            CreateFrontDoor0.FixSeed = 0;
+            CreateFrontDoor0.position = new Vector2(-287f, 488);
+            FilterByRoom1.RemoveMode = false;
+            FilterByRoom1.Type1 = RoomType.Kitchen;
+            FilterByRoom1.FilterSecond = true;
+            FilterByRoom1.Type2 = RoomType.Garden;
+            FilterByRoom1.FixSeed = 0;
+            FilterByRoom1.position = new Vector2(-100f, 988);
+            Output0.FixSeed = 0;
+            Output0.position = new Vector2(1275f, 500);
+            AppendFeatures0.FixSeed = 0;
+            AppendFeatures0.position = new Vector2(450f, 500);
+            AppendFeatures1.FixSeed = 0;
+            AppendFeatures1.position = new Vector2(663f, 500);
+            SwitchFeatures0.SetToFeature = FeatureType.Hatch;
+            SwitchFeatures0.FixSeed = 0;
+            SwitchFeatures0.position = new Vector2(238f, 988);
+            RequireAccessible0.AllowGardens = true;
+            RequireAccessible0.ResultStatus = true;
+            RequireAccessible0.FixSeed = 0;
+            RequireAccessible0.position = new Vector2(938f, 500);
+
+            // Connecting all the nodes
+
+            RecentreLayout0.GetPort("Input").Connect(NewFromTexture0.GetPort("Output"));
+            FindAllFeatures0.GetPort("Input").Connect(RecentreLayout0.GetPort("Output"));
+            FilterByRoom0.GetPort("Input").Connect(FindAllFeatures0.GetPort("Output"));
+            FilterOnePerPair0.GetPort("Input").Connect(FilterByRoom0.GetPort("Output"));
+            CreateFrontDoor0.GetPort("Input").Connect(RecentreLayout0.GetPort("Output"));
+            FilterByRoom1.GetPort("Input").Connect(FindAllFeatures0.GetPort("Output"));
+            Output0.GetPort("Input").Connect(RequireAccessible0.GetPort("Output"));
+            AppendFeatures0.GetPort("AppendFrom").Connect(FilterOnePerPair0.GetPort("Output"));
+            AppendFeatures0.GetPort("Input").Connect(CreateFrontDoor0.GetPort("Output"));
+            AppendFeatures1.GetPort("AppendFrom").Connect(SwitchFeatures0.GetPort("Output"));
+            AppendFeatures1.GetPort("Input").Connect(AppendFeatures0.GetPort("Output"));
+            SwitchFeatures0.GetPort("Input").Connect(FilterByRoom1.GetPort("Output"));
+            RequireAccessible0.GetPort("Input").Connect(AppendFeatures1.GetPort("Output"));
+
+            // Adding all the nodes to the graph and setting the graph
+
+            graph.nodes.Add(RecentreLayout0);
+            RecentreLayout0.graph = graph;
+            graph.nodes.Add(NewFromTexture0);
+            NewFromTexture0.graph = graph;
+            graph.nodes.Add(FindAllFeatures0);
+            FindAllFeatures0.graph = graph;
+            graph.nodes.Add(FilterByRoom0);
+            FilterByRoom0.graph = graph;
+            graph.nodes.Add(FilterOnePerPair0);
+            FilterOnePerPair0.graph = graph;
+            graph.nodes.Add(CreateFrontDoor0);
+            CreateFrontDoor0.graph = graph;
+            graph.nodes.Add(FilterByRoom1);
+            FilterByRoom1.graph = graph;
+            graph.nodes.Add(Output0);
+            Output0.graph = graph;
+            graph.nodes.Add(AppendFeatures0);
+            AppendFeatures0.graph = graph;
+            graph.nodes.Add(AppendFeatures1);
+            AppendFeatures1.graph = graph;
+            graph.nodes.Add(SwitchFeatures0);
+            SwitchFeatures0.graph = graph;
+            graph.nodes.Add(RequireAccessible0);
+            RequireAccessible0.graph = graph;
+            graph.name = graphName;
+
+            return graph;
+        }
+
+
+        public override void OnRegister(LayoutProfile gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            Registry.AddSettingLayout((RestaurantSetting)GDOUtils.GetCustomGameDataObject<Easter2025GardenSetting>().GameDataObject, gameDataObject);
+        }
+    }
+}

Customs/PlayerCosmetics/BunnyTail.cs

@@ -0,0 +1,22 @@
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.PlayerCosmetics
+{
+    public class BunnyTail : CustomPlayerCosmetic
+    {
+        public override string UniqueNameID => "BunnyTail";
+        public override CosmeticType CosmeticType => CosmeticType.Outfit;
+        public override GameObject Visual => Mod.Bundle.LoadAsset<GameObject>("BunnyTail").AssignMaterialsByNames();
+        public override bool BlockHats => false;
+
+        public override void OnRegister(PlayerCosmetic gameDataObject)
+        {
+            PlayerOutfitComponent playerOutfitComponent = gameDataObject.Visual.AddComponent<PlayerOutfitComponent>();
+            playerOutfitComponent.Renderers.Add(GameObjectUtils.GetChildObject(gameDataObject.Visual, "Icosphere").GetComponent<SkinnedMeshRenderer>());
+        }
+    }
+}

Customs/Processes/SearchBush.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using KitchenData;
+using KitchenLib.Customs;
+
+namespace Easter2025.Customs.Processes
+{
+    public class SearchBush : CustomProcess
+    {
+        public override string UniqueNameID => "SearchBush";
+        public override List<(Locale, ProcessInfo)> InfoList => new List<(Locale, ProcessInfo)>
+        {
+            (Locale.English, new ProcessInfo
+            {
+                Name = "SearchBush",
+                Icon = "<sprite name=\"Search\">"
+            })
+        };
+    }
+}

Customs/RestaurantSettings/Decorators/EasterDecorator.cs

@@ -0,0 +1,112 @@
+using System.Collections.Generic;
+using Kitchen;
+using Kitchen.Layouts;
+using KitchenData;
+using KitchenLib.References;
+using UnityEngine;
+
+namespace Easter2025.Customs.RestaurantSettings.Decorators
+{
+    public class EasterDecorator : Decorator
+    {
+        public override bool Decorate(Room room)
+        {
+	        if (Configuration is not DecorationsConfiguration decorationsConfiguration) return false;
+	        Bounds bounds = Blueprint.GetBounds();
+	        Vector3 frontDoor = Blueprint.GetFrontDoor();
+	        NewPiece(decorationsConfiguration.Ground, 0f, 0f);
+	        
+	        // Decorate Top and Bottom
+
+	        for (float x = bounds.min.x - xDifference; x < bounds.max.x + xDifference; x++)
+	        {
+		        for (float y = bounds.min.y - yDifference; y < bounds.max.y + yDifference; y++)
+		        {
+			        if (!(x > bounds.min.x - (decorationsConfiguration.BorderSpacing + 1)) || !(x < bounds.max.x + (decorationsConfiguration.BorderSpacing + 1)) || !(y > bounds.min.y - (decorationsConfiguration.BorderSpacing + 1)) || !(y < bounds.max.y + (decorationsConfiguration.BorderSpacing + 1)))
+			        {
+				        if (y > bounds.min.y)
+				        {
+					        foreach (var scatter in decorationsConfiguration.Scatters)
+					        {
+						        if (Random.value < scatter.Probability)
+						        {
+							        NewPiece(scatter.Appliance, x, y);
+							        break;
+						        }
+					        }
+				        }
+			        }
+		        }
+	        }
+	        
+	        if (decorationsConfiguration.Cobblestone != null)
+	        {
+		        for (float num3 = PathStartLocation; num3 <= frontDoor.x; num3 += 0.8f)
+		        {
+			        NewPiece(decorationsConfiguration.Cobblestone, num3, bounds.min.y - 1.2f);
+		        }
+	        }
+
+
+	        if (decorationsConfiguration.FrontBorder != null)
+	        {
+		        for (float num4 = bounds.min.x; num4 <= bounds.max.x; num4 += decorationsConfiguration.BorderSpacing)
+		        {
+			        if (Mathf.Abs(num4 - frontDoor.x) >= 0.7f && Blueprint[(int)num4, (int)bounds.min.y].Type != RoomType.Garden)
+			        {
+				        NewPiece(decorationsConfiguration.FrontBorder, num4, bounds.min.y - 0.7f);
+			        }
+		        }
+	        }
+
+
+	        for (float num5 = bounds.min.x - 1f; num5 <= bounds.max.x + 1f; num5 += 1f)
+	        {
+		        NewPiece(AssetReference.OutdoorMovementBlocker, num5, bounds.min.y - 3f);
+	        }
+
+
+	        float num6 = ((frontDoor.x < 3f) ? (frontDoor.x + 1f) : (frontDoor.x - 1f));
+
+
+	        NewPiece(AssetReference.Nameplate, num6, bounds.min.y - 1f);
+	        NewPiece(AssetReference.OutdoorMovementBlocker, bounds.min.x - 1f, bounds.min.y - 1f);
+	        NewPiece(AssetReference.OutdoorMovementBlocker, bounds.min.x - 1f, bounds.min.y - 2f);
+
+	        NewPiece(AssetReference.OutdoorMovementBlocker, bounds.max.x + 1f, bounds.min.y - 1f);
+	        NewPiece(AssetReference.OutdoorMovementBlocker, bounds.max.x + 1f, bounds.min.y - 2f);
+	        NewPiece(Profile.ExternalBin, frontDoor.x, frontDoor.z - 3f);
+	        
+	        
+	        return true;
+        }
+
+        private int PathStartLocation = -20;
+        private int xDifference = 15;
+        private int yDifference = 6;
+
+        public class DecorationsConfiguration : IDecorationConfiguration
+        {
+	        public IDecorator Decorator => new EasterDecorator();
+
+	        public List<Scatter> Scatters;
+
+	        public Appliance Cobblestone;
+
+	        public Appliance FrontBorder;
+
+	        public float BorderSpacing;
+
+	        public Appliance Ground;
+
+	        public bool OnlyDecorateLowerHalf;
+
+	        public struct Scatter
+	        {
+		        public float Probability;
+
+		        public Appliance Appliance;
+	        }
+        }
+    }
+}

Customs/RestaurantSettings/Easter2025GardenSetting.cs

@@ -0,0 +1,57 @@
+using CustomSettingsAndLayouts;
+using System.Collections.Generic;
+using Easter2025.Customs.RestaurantSettings.Decorators;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Customs.RestaurantSettings
+{
+    public class Easter2025GardenSetting : CustomRestaurantSetting
+    {
+        public override string UniqueNameID => "Easter2025GardenSetting";
+        public override WeatherMode WeatherMode => WeatherMode.None;
+
+        public override List<IDecorationConfiguration> Decorators => new List<IDecorationConfiguration>
+        {
+            new EasterDecorator.DecorationsConfiguration
+            {
+                Cobblestone = GDOReferences.EggCobblestone,
+                Ground = GDOReferences.EasterGround,
+                BorderSpacing = 1,
+                Scatters = new List<EasterDecorator.DecorationsConfiguration.Scatter>
+                {
+                    new()
+                    {
+                        Appliance = GDOReferences.EasterTree,
+                        Probability = 0.05f
+                    },
+                    new()
+                    {
+                        Appliance = GDOReferences.EggPile,
+                        Probability = 0.05f
+                    }
+                }
+            }
+        };
+
+        public override UnlockPack UnlockPack { get; protected set; }
+
+        public override Unlock StartingUnlock => GDOReferences.DishPlasticEggs;
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EasterSettingSnowglobe").AssignMaterialsByNames();
+        public override bool AlwaysLight => true;
+
+        public override List<(Locale, BasicInfo)> InfoList => CenteralLang.RestaurantSettings.Easter2025GardenSetting;
+
+
+        public override void OnRegister(RestaurantSetting gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            Registry.GrantCustomSetting(gameDataObject);
+        }
+    }
+}

Customs/RestaurantSettings/Easter2025Setting.cs

@@ -0,0 +1,58 @@
+using CustomSettingsAndLayouts;
+using System.Collections.Generic;
+using Easter2025.Customs.RestaurantSettings.Decorators;
+using Easter2025.Utilies;
+using Kitchen;
+using KitchenData;
+using KitchenLib.Customs;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using TwitchLib.Api.Helix.Models.Entitlements.GetDropsEntitlements;
+using UnityEngine;
+
+namespace Easter2025.Customs.RestaurantSettings
+{
+    public class Easter2025Setting : CustomRestaurantSetting
+    {
+        public override string UniqueNameID => "Easter2025Setting";
+        public override WeatherMode WeatherMode => WeatherMode.None;
+
+        public override List<IDecorationConfiguration> Decorators => new List<IDecorationConfiguration>
+        {
+            new EasterDecorator.DecorationsConfiguration
+            {
+                Cobblestone = GDOReferences.EggCobblestone,
+                Ground = GDOReferences.EasterGround,
+                BorderSpacing = 1,
+                Scatters = new List<EasterDecorator.DecorationsConfiguration.Scatter>
+                {
+                    new()
+                    {
+                        Appliance = GDOReferences.EasterTree,
+                        Probability = 0.05f
+                    },
+                    new()
+                    {
+                        Appliance = GDOReferences.EggPile,
+                        Probability = 0.05f
+                    }
+                }
+            }
+        };
+
+        public override UnlockPack UnlockPack { get; protected set; }
+
+        public override Unlock StartingUnlock => GDOReferences.DishPlasticEggs; 
+        public override GameObject Prefab => Mod.Bundle.LoadAsset<GameObject>("EasterSettingSnowglobe").AssignMaterialsByNames();
+        public override bool AlwaysLight => true;
+
+        public override List<(Locale, BasicInfo)> InfoList => CenteralLang.RestaurantSettings.Easter2025Setting;
+
+
+        public override void OnRegister(RestaurantSetting gameDataObject)
+        {
+            base.OnRegister(gameDataObject);
+            Registry.GrantCustomSetting(gameDataObject);
+        }
+    }
+}