voxel-building-system/Runtime/VoxelBuildingSystem.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using KairoEngine.Chunks;
using KairoEngine.Core;
using KairoEngine.UI;
using Utils = KairoEngine.Utility.Utilities;
using Sirenix.OdinInspector;

namespace KairoEngine.VoxelBuildingSystem
{
    [HideMonoScript]
    public class VoxelBuildingSystem : MonoBehaviour
    {
        public static VoxelBuildingSystem instance;
        public Vector3Int chunkSize = new Vector3Int(16, 16, 16);
        public Vector3Int chunkCount = new Vector3Int(3, 3, 3);
        public Vector3 voxelSize = new Vector3(1f, 1f, 1f);
        public LayerMask layerMask;
        public List<BuildingTemplate> buildingTemplates = new List<BuildingTemplate>();

        public bool debugBlocks = false;
        public GameObject blockVisualPrefab;
        public Transform blockContainer;

        [ReadOnly] public int currentBuildingTemplate;
        [ReadOnly] public int currentRotationIndex;

        [ReadOnly] public VoxelBuildingTool tool = VoxelBuildingTool.Build;

        [ReadOnly] public List<Vector3Int> rotationList = new List<Vector3Int>();
        public ChunkSystem<VoxelBuildData> chunkSystem;
        [HideInInspector] public Dictionary<Vector3Int, BuildingBehaviour> buildings = new Dictionary<Vector3Int, BuildingBehaviour>();
        [HideInInspector] public List<BuildingBehaviour> buildingList = new List<BuildingBehaviour>();
        

        private Vector3 pointerPosition;

        public void CreateVoxelSystem()
        {
            SetupRotationList();
            chunkSystem = new ChunkSystem<VoxelBuildData>(chunkSize, false);
            for (int x = 0; x < chunkCount.x; x++) {
                for (int z = 0; z < chunkCount.z; z++) {
                    for (int y = 0; y < chunkCount.y; y++) {
                        Vector3Int chunkPos = new Vector3Int(x * chunkSize.x, y * chunkSize.y, z * chunkSize.z);
                        chunkSystem.CreateChunk(chunkPos, (Chunk<VoxelBuildData> c, Vector3Int pos) => new VoxelBuildData(pos, -1));
                    }
                }
            }
        }

        void Start() => CreateVoxelSystem();

        void Update()
        {
            pointerPosition = Utils.GetMouseWorldPosition(layerMask.value);
            if(!MouseInputUIBlocker.BlockedByUI)
            {
                switch (tool)
                {
                    case VoxelBuildingTool.Build:
                        if(Input.GetKeyDown(KeyCode.R)) RotateBuilding();
                        if(Input.GetMouseButtonDown(0)) PlaceBuilding(pointerPosition);
                        break;
                    case VoxelBuildingTool.Remove:
                        if(Input.GetMouseButtonDown(0)) RemoveBuilding(pointerPosition);
                        break;
                    default:
                        break;
                }
            }
            if(Input.GetKeyDown(KeyCode.Alpha1)) CycleBuildingTemplate();
        }

        public void RotateBuilding() 
        {
            if(currentRotationIndex < rotationList.Count - 1) currentRotationIndex += 1;
            else currentRotationIndex = 0;
        }
        
        public void PlaceBuilding(Vector3 pos) 
        {
            Vector3Int buildingPos = GetMouseBuildingPosition();
            Vector3Int voxelPos = GetMouseVoxelPosition();
            Vector3Int buildingRotation = rotationList[currentRotationIndex];
            if(!CanPlaceBuilding(voxelPos, currentBuildingTemplate, currentRotationIndex, true)) return;
            Quaternion rotation = Quaternion.Euler(buildingRotation.x, buildingRotation.y, buildingRotation.z);
            Transform newBuilding = Instantiate(buildingTemplates[currentBuildingTemplate].prefab, voxelPos, 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, currentRotationIndex);
            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);
                if(debugBlocks) Instantiate(blockVisualPrefab, voxelPositions[i], new Quaternion(), blockContainer);
            }
        } 

        public bool CanPlaceBuilding(Vector3Int voxelPos, int buildingTemplateIndex, int buildingRotationIndex = 0, bool debug = false)
        {
            List<Vector3Int> voxelPositions = GetBuildingVoxelList(voxelPos, buildingTemplateIndex, buildingRotationIndex);
            for (int i = 0; i < voxelPositions.Count; i++)
            {
                VoxelBuildData block = chunkSystem.GetBlock(voxelPositions[i]);
                if(block.buildingIndex != -1) 
                {
                    if(debug) Debug.Log("Cannot place building, place is occupied.");
                    return false;
                }
            }
            return true;
        }

        public void RemoveBuilding(Vector3 pos) {}

        public Vector3Int FindVoxelPosition(Vector3 pos)
        {
            return new Vector3Int(Mathf.FloorToInt(pos.x/voxelSize.x), Mathf.FloorToInt(pos.y/voxelSize.y), Mathf.FloorToInt(pos.z/voxelSize.z));
        }

        public Vector3 GetMouseWorldSnappedPosition() => (Vector3)FindVoxelPosition(pointerPosition);
        public Vector3Int GetMouseVoxelPosition() => FindVoxelPosition(pointerPosition);

        public Vector3Int GetMouseBuildingPosition()
        {
            Vector3Int voxelPos = FindVoxelPosition(pointerPosition);
            Vector3Int rotationOffset = GetRotationOffset(currentRotationIndex, buildingTemplates[currentBuildingTemplate].size);
            return voxelPos + rotationOffset;
        }

        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, int buildingRotationIndex = 0) 
        { 
            BuildingTemplate template = buildingTemplates[buildingTemplateId];
            List<Vector3Int> positionList = new List<Vector3Int>();
            Vector3Int rotationOffset = GetRotationOffset(buildingRotationIndex, template.size);
            switch (buildingRotationIndex)
            {
                default:
                case 0:
                case 2:
                    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 + rotationOffset.x + x, offset.y + rotationOffset.y + y, offset.z + rotationOffset.z + z);
                                positionList.Add(pos);
                            }
                        }
                    }
                    break;
                case 1:
                case 3:
                    for(int x = 0; x < template.size.z; x++)
                    {
                        for (int y = 0; y < template.size.y; y++)
                        {
                            for (int z = 0; z < template.size.x; z++)
                            {
                                Vector3Int pos = new Vector3Int(offset.x + rotationOffset.x + x, offset.y + rotationOffset.y + y, offset.z + rotationOffset.z + z);
                                positionList.Add(pos);
                            }
                        }
                    }
                    break;
            }
            
            //Debug.Log($"{positionList.Count} voxel positions found for building \"{buildingTemplates[buildingTemplateId].title}\"");
            return positionList;
        }

        private void SetupRotationList()
        {
            rotationList = new List<Vector3Int>
            {
                new Vector3Int(0, 0, 0),
                new Vector3Int(0, 90, 0),
                new Vector3Int(0, 180, 0),
                new Vector3Int(0, 270, 0)
            };
        }

        public Vector3Int GetRotationOffset(int rotationIndex, Vector3Int size) 
        { 
            switch (rotationIndex)
            {
                default:
                case 0:  return new Vector3Int(0, 0, 0);
                case 1:  return new Vector3Int(0, 0, -size.x);
                case 2:  return new Vector3Int(-size.x, 0, -size.z);
                case 3:  return new Vector3Int(-size.z, 0, 0);
            }
        }
        
        public Vector3Int GetConnectorPositionOffset(VoxelConnectorData connector, Vector3Int size, int rotationIndex)
        {
            Vector3Int pos = connector.position;
            switch (rotationIndex)
            {
                default:
                case 0:  return connector.position;
                case 1:  return new Vector3Int(pos.z, pos.y, (pos.x * -1) + size.x - 1);
                case 2:  return new Vector3Int((pos.x * -1) + size.x - 1, pos.y, (pos.z * -1) + size.z - 1);
                case 3:  return new Vector3Int((pos.z * -1) + size.z - 1, pos.y, pos.x);
            }
            // switch (connector.direction)
            // {
            //     default:
            //     case TargetDirection.Back:  return connector.position;
            //     case TargetDirection.Left:  return new Vector3Int(pos.z, pos.y, (pos.x * -1) + size.x - 1);
            //     case TargetDirection.Front:    return new Vector3Int((pos.x * -1) + size.x - 1, pos.y, (pos.z * -1) + size.z - 1);
            //     case TargetDirection.Right: return new Vector3Int((pos.z * -1) + size.z - 1, pos.y, pos.x);
            //     case TargetDirection.Up:  return new Vector3Int(pos.x, (pos.y * -1) + size.y - 1, pos.z);
            //     case TargetDirection.Down:  return new Vector3Int(pos.x, pos.y * -1, pos.z);
            // }
        }

        public Vector3Int GetPositionOffsetFromDirection(int rotationIndex, VoxelConnectorData connector)
        {
            switch (rotationIndex)
            {
                default:
                case 0:  
                    switch (connector.direction)
                    {
                        default:
                        case TargetDirection.Down:  return new Vector3Int(0, 0, -1);
                        case TargetDirection.Left:  return new Vector3Int(-1, 0, 0);
                        case TargetDirection.Up:    return new Vector3Int(0, 0, 1);
                        case TargetDirection.Right: return new Vector3Int(1, 0, 0);
                    }
                case 1:  
                    switch (connector.direction)
                    {
                        default:
                        case TargetDirection.Down:  return new Vector3Int(-1, 0, 0);
                        case TargetDirection.Left:  return new Vector3Int(0, 0, 1);
                        case TargetDirection.Up:    return new Vector3Int(1, 0, 0);
                        case TargetDirection.Right: return new Vector3Int(0, 0, -1);
                    }
                case 2:    
                    switch (connector.direction)
                    {
                        default:
                        case TargetDirection.Down:  return new Vector3Int(0, 0, 1);
                        case TargetDirection.Left:  return new Vector3Int(1, 0, 0);
                        case TargetDirection.Up:    return new Vector3Int(0, 0, -1);
                        case TargetDirection.Right: return new Vector3Int(-1, 0, 0);
                    }
                case 3: 
                    switch (connector.direction)
                    {
                        default:
                        case TargetDirection.Down:  return new Vector3Int(1, 0, 0);
                        case TargetDirection.Left:  return new Vector3Int(0, 0, -1);
                        case TargetDirection.Up:    return new Vector3Int(-1, 0, 0);
                        case TargetDirection.Right: return new Vector3Int(0, 0, 1);
                    }
            }
        }

    }

    public enum VoxelBuildingTool
    {
        None,
        Build,
        Remove
    }
}