Added basic building placement check

Runtime/BuildingBlueprintController.cs

@@ -12,15 +12,15 @@ namespace KairoEngine.VoxelBuildingSystem
 
         private void Start() {
             RefreshVisual();
-            GenericEvents.StartListening("OnSelectedChanged", OnSelectedChanged);
+            GenericEvents.StartListening("OnBuildingTemplateChanged", OnBuildingTemplateChanged);
         }
 
         private void OnDisable()
         {
-            GenericEvents.StopListening("OnSelectedChanged", OnSelectedChanged);
+            GenericEvents.StopListening("OnBuildingTemplateChanged", OnBuildingTemplateChanged);
         }
 
-        private void OnSelectedChanged() {
+        private void OnBuildingTemplateChanged() {
             RefreshVisual();
         }
 

Runtime/VoxelBuildData.cs

@@ -8,11 +8,13 @@ namespace KairoEngine.VoxelBuildingSystem
     {
         public Vector3Int pos;
         public int buildingIndex;
+        public int buildingTemplateIndex;
 
-        public VoxelBuildData(Vector3Int pos, int buildingIndex = 0)
+        public VoxelBuildData(Vector3Int pos, int buildingIndex = -1, int buildingTemplateIndex = -1)
         {
             this.pos = pos;
             this.buildingIndex = buildingIndex;
+            this.buildingTemplateIndex = buildingTemplateIndex;
         }
     }
 }

Runtime/VoxelBuildingSystem.cs

@@ -18,11 +18,13 @@ namespace KairoEngine.VoxelBuildingSystem
         public Vector3 voxelSize = new Vector3(1f, 1f, 1f);
         public LayerMask layerMask;
         public List<BuildingTemplate> buildingTemplates = new List<BuildingTemplate>();
+        [ReadOnly] public int currentBuildingTemplate;
 
-        public VoxelBuildingTool tool = VoxelBuildingTool.Build;
-        private ChunkSystem<VoxelBuildData> chunkSystem;
+        [ReadOnly] public VoxelBuildingTool tool = VoxelBuildingTool.Build;
+        public ChunkSystem<VoxelBuildData> chunkSystem;
         [HideInInspector] public Dictionary<Vector3Int, BuildingBehaviour> buildings = new Dictionary<Vector3Int, BuildingBehaviour>();
-        [HideInInspector] public int currentBuildingTemplate;
+        [HideInInspector] public List<BuildingBehaviour> buildingList = new List<BuildingBehaviour>();
+        
 
         private Vector3 pointerPosition;
 
@@ -39,6 +41,8 @@ namespace KairoEngine.VoxelBuildingSystem
             }
         }
 
+        void Start() => CreateVoxelSystem();
+
         void Update()
         {
             pointerPosition = Utils.GetMouseWorldPosition(layerMask.value);
@@ -57,16 +61,52 @@ namespace KairoEngine.VoxelBuildingSystem
                         break;
                 }
             }
+            if(Input.GetKeyDown(KeyCode.Alpha1)) CycleBuildingTemplate();
         }
 
         public void RotateBuilding() {}
         
         public void PlaceBuilding(Vector3 pos) 
         {
-            Vector3 voxelPos = GetMouseWorldSnappedPosition();
-            Transform newBuilding = Instantiate(buildingTemplates[currentBuildingTemplate].prefab, voxelPos, this.transform.rotation, this.transform);
+            Vector3 worldPos = GetMouseWorldSnappedPosition();
+            Vector3Int voxelPos = FindVoxelPosition(pointerPosition);
+            if(!CanPlaceBuilding(voxelPos, currentBuildingTemplate)) return;
+            Transform newBuilding = Instantiate(buildingTemplates[currentBuildingTemplate].prefab, worldPos, this.transform.rotation, this.transform);
+            BuildingBehaviour buildingBehaviour = newBuilding.GetComponent<BuildingBehaviour>();
+            if(buildingBehaviour == null)
+            {
+                Debug.LogError($"Building prefab has no BuildingBehaviour component! Cannot place building", newBuilding);
+                Destroy(newBuilding);
+                return;
+            }
+            buildingBehaviour.origin = voxelPos;
+            buildings.Add(voxelPos, buildingBehaviour);
+            buildingList.Add(buildingBehaviour);
+            List<Vector3Int> voxelPositions = GetBuildingVoxelList(voxelPos, currentBuildingTemplate);
+            for (int i = 0; i < voxelPositions.Count; i++)
+            {
+                VoxelBuildData block = chunkSystem.GetBlock(voxelPositions[i]);
+                block.buildingIndex = buildingList.Count - 1;
+                block.buildingTemplateIndex = currentBuildingTemplate;
+                chunkSystem.SetBlock(voxelPositions[i], block);
+            }
         } 
 
+        public bool CanPlaceBuilding(Vector3Int voxelPos, int buildingTemplateIndex)
+        {
+            List<Vector3Int> voxelPositions = GetBuildingVoxelList(voxelPos, buildingTemplateIndex);
+            for (int i = 0; i < voxelPositions.Count; i++)
+            {
+                VoxelBuildData block = chunkSystem.GetBlock(voxelPositions[i]);
+                if(block.buildingIndex != -1) 
+                {
+                    Debug.Log("Cannot place building, place is occupied.");
+                    return false;
+                }
+            }
+            return true;
+        }
+
         public void RemoveBuilding(Vector3 pos) {}
 
         public Vector3Int FindVoxelPosition(Vector3 pos)
@@ -75,6 +115,34 @@ namespace KairoEngine.VoxelBuildingSystem
         }
 
         public Vector3 GetMouseWorldSnappedPosition() => (Vector3)FindVoxelPosition(pointerPosition);
+
+        public void CycleBuildingTemplate()
+        {
+            if(currentBuildingTemplate < buildingTemplates.Count - 1) currentBuildingTemplate += 1;
+            else currentBuildingTemplate = 0;
+            GenericEvents.Trigger("OnBuildingTemplateChanged");
+            Debug.Log($"Changing current building template to {currentBuildingTemplate}");
+        }
+
+        public List<Vector3Int> GetBuildingVoxelList(Vector3Int offset, int buildingTemplateId) 
+        { 
+            BuildingTemplate template = buildingTemplates[buildingTemplateId];
+            List<Vector3Int> positionList = new List<Vector3Int>();
+            for(int x = 0; x < template.size.x; x++)
+            {
+                for (int y = 0; y < template.size.y; y++)
+                {
+                    for (int z = 0; z < template.size.z; z++)
+                    {
+                        Vector3Int pos = new Vector3Int(offset.x + x, offset.y + y, offset.z + z);
+                        positionList.Add(pos);
+                        Debug.Log(pos);
+                    }
+                }
+            }
+            Debug.Log($"{positionList.Count} voxel positions found for building \"{buildingTemplates[buildingTemplateId].title}\"");
+            return positionList;
+        }
         
     }