Grid 좌표 시스템

using UnityEngine;

// 그리드 구성 요소와 그리드 셰이더를 연결하고 다른 스크립트가 그리드의 데이터에 접근할 수 있게 해주는 클래스
public class GridManager : MonoBehaviour
{
    [SerializeField]
    private Grid grid; 

    [SerializeField]
    private Renderer gridRenderer; 

    [SerializeField]
    private Vector3 gridCellSize;  
    private Vector3 halfGridCellSize; 

    [SerializeField]
    private Vector2Int defaultScale = new Vector2Int(10, 10); 

    // 그리드의 실제 크기를 계산. gridRenderer의 로컬 스케일을 이용해 셀 수를 결정.
    public Vector2Int GridSize =>
        Vector2Int.RoundToInt(
            defaultScale* 
            new Vector2(
                gridRenderer.transform.localScale.x,
                gridRenderer.transform.localScale.z)
            );

    [SerializeField]
    private string cellSizeParameter = "_GridSize", defaultScaleParameter = "_DefaultScale";

    private void Start()
    {
        grid.cellSize = gridCellSize;
        halfGridCellSize = gridCellSize / 2f;

        gridRenderer.material.SetVector(cellSizeParameter, new Vector2(1 / gridCellSize.x, 1 / gridCellSize.z));
        gridRenderer.material.SetVector(defaultScaleParameter, new Vector2(defaultScale.x, defaultScale.y));
    }

    // 월드 좌표를 그리드 셀 좌표로 변환. 엣지 배치의 경우 위치를 보정.
    public Vector3Int GetCellPosition(Vector3 worldPosition, PlacementType placementType)
    {
        if (placementType.IsEdgePlacement())
            worldPosition += halfGridCellSize;  // 엣지 배치인 경우 보정을 위해 셀 크기의 절반을 더함.
        return grid.WorldToCell(worldPosition); // 월드 좌표를 그리드 셀 좌표로 변환.
    }

    // 셀 좌표를 월드 좌표로 변환. 그리드 상에서의 시각적 위치를 결정.
    public Vector3 GetWorldPosition(Vector3Int cellPosition)
    {
        // 그리드가 조금 높게 배치되어 있기 때문에 y값을 빼줌 → 그리드가 바닥 타일 위에 표시되도록
        return grid.CellToWorld(cellPosition);
    }

    // 특정 그리드 셀의 중앙 위치를 계산.
    public Vector3 GetCenterPositionForCell(Vector3Int cellPosition)
    {
        return GetWorldPosition(cellPosition) + halfGridCellSize;
        // 셀 좌표를 월드 좌표로 변환 + 그리드 셀의 중심 위치를 맞추기 위해 그리드 셀 크기의 절반만큼 위치 보정.
    }

    // 그리드를 보이거나 숨기기 위한 기능.
    public void ToggleGrid(bool value)
    {
        gridRenderer.gameObject.SetActive(value);
    }
}

// 배치 유형 타입 => ScriptableObjects를 사용하여 객체를 생성하는 것이 더 좋을 수 있지만, 프로타입에는 열거형도 잘 작동함
public enum PlacementType   
{
    None,
    Floor,
    Wall,
    InWalls,
    NearWallObject,
    FreePlacedObject
}

// 열거형을 사용하면 쉽게 추가 데이터를 더할 수 없는 제한 때문에 확장 메소드가 필요함
// 이 방법으로 열거형을 사용한 각 if/switch문장을 확인하지 않고도 추가 데이터에 안정적으로 접근할 수 있음.
public static class PlacementTypeExtensions
{
    public static bool IsEdgePlacement(this PlacementType placementType)
    => placementType switch
        {
            PlacementType.Wall => true,
            PlacementType.InWalls => true,
            _ => false
        };
    public static bool IsObjectPlacement(this PlacementType placementType)
    => placementType switch
    {
        PlacementType.FreePlacedObject => true,
        PlacementType.NearWallObject => true,
        _ => false
    };
}

using System.Collections.Generic;
using System.Linq;
using UnityEngine;

// A* 알고리즘 및 GridData 구조에서 데이터를 찾거나 확인해야 하는 기타 알고리즘을 위한 함수들
public static class GridSelectionHelper
{
    public static IEnumerable<int> MoveMinToMaxInclusive(int minVal, int maxVal, int step)
    {
        for (int i = minVal; i <= maxVal; i += step)
        {
            yield return i;
        }
    }

    public static IEnumerable<int> MoveMaxToMinInclusive(int minVal, int maxVal, int step)
    {
        for (int i = maxVal; i >= minVal; i -= step)
        {
            yield return i;
        }
    }

    // A*를 사용하는 객체의 크기가 1x1이라고 가정
    public static List<Vector3Int> AStar(Vector3Int startPos, Vector3Int endPos, PlacementGridData placementData)
    {
        List<Vector3Int> path = new();
        List<Vector3Int> openList = new();
        Dictionary<Vector3Int, Vector3Int> childParentDictionary = new();
        Dictionary<Vector3Int,int> costDictionary = new();

        openList.Add(startPos);
        costDictionary[startPos] = ManhattanDistance(startPos, endPos);

        Vector3Int currentPosition = startPos;

        if(placementData.IsCellAt(endPos) == false)
            return new List<Vector3Int>();

        while(openList.Count > 0)
        {
            // 비용을 기준으로 정렬하여 가장 효율적인 경로 탐색
            openList = openList.OrderBy(x => costDictionary[x]).ToList();
            currentPosition = openList[0];
            openList.RemoveAt(0);

            // 목적지에 도달했을 때의 처리
            if (currentPosition == endPos)
            {
                //get patern
                //currentPosition = childParentDictionary[currentPosition];
                //path.Add(endPos);

                // 경로 역추적(부모 노드를 따라 시작점까지 이동)
                while (currentPosition != startPos)
                {
                    path.Add(currentPosition);
                    currentPosition = childParentDictionary[currentPosition];
                }
                path.Add(startPos);
                path.Reverse(); // 시작점에서 끝점 순서가 되도록 뒤집기
                break;
            }

            // 계속해서 탐색이 필요한 경우의 처리
            List<Vector3Int> neighbours = FindNeighbours(currentPosition, placementData);
            foreach (var neighbourposition in neighbours)
            {
                if (costDictionary.ContainsKey(neighbourposition))
                    continue;
                childParentDictionary[neighbourposition] = currentPosition;
                costDictionary[neighbourposition] = ManhattanDistance(neighbourposition, endPos);
                if (openList.Contains(neighbourposition) == false)
                    openList.Add(neighbourposition);
            }
        }
        return path;
    }

    private static List<Vector3Int> FindNeighbours(Vector3Int currentPosition, PlacementGridData placementData)
    {
        List<Vector3Int> neighbours = new();
        foreach (var direction in Directions)
        {
            Vector3Int tempPos = currentPosition + direction;
            if (placementData.IsCellAt(tempPos))
            {
                neighbours.Add(tempPos);
            }
        }
        return neighbours;
    }

    private static int ManhattanDistance(Vector3Int startPoint, Vector3Int endPoint)
    { 
        // 맨해튼 거리 계산 (격자 기반 이동에서 주로 사용)
        return Mathf.Abs(startPoint.x - endPoint.x) + Mathf.Abs(startPoint.z - endPoint.z);
    }

    internal static List<Quaternion> CalculateRotation(List<Vector3Int> gridPositions)
    {
        List<Quaternion> returnValues = new();
        for (int i = 0; i < gridPositions.Count-1; i++)
        {
            Vector3Int direction = gridPositions[i+1] - gridPositions[i];
            // 이동 방향에 따른 회전값 계산
            returnValues.Add(Quaternion.Euler(0,Mathf.RoundToInt(Vector3.SignedAngle(Vector3.right, direction,Vector3.up)),0));
        }
        return returnValues;
    }

    // 상하좌우 이동 방향 정의
    public static List<Vector3Int> Directions = new()
    {
        new Vector3Int(1,0,0),  // 우
        new Vector3Int(-1,0,0), // 좌
        new Vector3Int(0,0,1),  // 전
        new Vector3Int(0,0,-1)  // 후
    };
}