Initial Commit

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;
+        }
+    }
+}