[랜덤 타워 디펜스] Day 3 Waypoint 생성 및 몬스터 이동 구현

오늘의 구현 목표

1. Path 타일 기반으로 Waypoint 생성
2. 몬스터 이동 시스템 1차 구현

• 기존 GridManager에 Waypoint를 만들어주는 함수 구현
• 만들어 둔 PathTile을 순서대로 가져와서 이동가능한 Waypoint로 구현

using UnityEngine;
using System.Collections.Generic;
 
public class GridManager : MonoBehaviour
{
    public static GridManager Instance { get; private set; }
 
    public int width = 16;
    public int height = 12;
    public float cellSize = 1f;
 
    public GameObject buildablePrefab;
    public GameObject pathPrefab;
 
    public Transform tileParent;
 
    [Header("Path Tiles")] public List<Vector2Int> pathTiles = new List<Vector2Int>();
 
    [Header("Waypoints")] public List<Transform> waypoints = new List<Transform>();
 
    private GridTile[,] tiles;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Debug.LogWarning("여러 개의 GridManager가 씬에 있습니다.");
        }
 
        Instance = this;
 
        GenerateGrid();
        GenerateWaypoints();
    }
 
    private void GenerateGrid()
    {
        tiles = new GridTile[width, height];
 
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                Vector2Int pos = new Vector2Int(x, y);
                bool isPath = pathTiles.Contains(pos);
 
                GameObject prefab = isPath ? pathPrefab : buildablePrefab;
                TileType tileType = isPath ? TileType.Path : TileType.Buildable;
 
                CreateTile(pos, prefab, tileType);
            }
        }
    }
 
    private void CreateTile(Vector2Int gridPos, GameObject prefab, TileType tileType)
    {
        Vector3 worldPos = new Vector3(gridPos.x * cellSize, 0f, gridPos.y * cellSize);
 
        GameObject obj = Instantiate(prefab, worldPos, Quaternion.identity, tileParent);
 
        GridTile tile = obj.GetComponent<GridTile>();
        if (tile == null)
        {
            tile = obj.AddComponent<GridTile>();
        }
 
        tile.Init(gridPos, tileType);
 
        tiles[gridPos.x, gridPos.y] = tile;
    }
 
    private void GenerateWaypoints()
    {
        waypoints.Clear();
 
        if (tiles == null)
        {
            Debug.LogError("타일이 아직 생성되지 않았습니다. GenerateGrid 이후에 호출해야 합니다.");
            return;
        }
 
        foreach (Vector2Int gridPos in pathTiles)
        {
            if (gridPos.x < 0 || gridPos.x >= width || gridPos.y < 0 || gridPos.y >= height)
            {
                Debug.LogWarning($"PathTile {gridPos} 좌표가 Grid 범위를 벗어났습니다.");
                continue;
            }
 
            GridTile tile = tiles[gridPos.x, gridPos.y];
            if (tile == null)
            {
                Debug.LogWarning($"PathTile {gridPos} 위치에 타일이 없습니다.");
                continue;
            }
 
            waypoints.Add(tile.transform);
        }
 
        if (waypoints.Count == 0)
        {
            Debug.LogWarning("Waypoint가 하나도 생성되지 않았습니다. pathTiles를 확인하세요.");
        }
    }
 
    public Transform GetWaypoint(int index)
    {
        if (index < 0 || index >= waypoints.Count)
            return null;
 
        return waypoints[index];
    }
    
    public int WaypointCount => waypoints.Count;
    
    #if UNITY_EDITOR
        private void OnDrawGizmosSelected()
        {
            if (pathTiles == null || pathTiles.Count == 0)
                return;
    
            Gizmos.color = Color.yellow;
    
            Vector3 prevPos = Vector3.zero;
            bool hasPrev = false;
    
            foreach (Vector2Int gridPos in pathTiles)
            {
                Vector3 worldPos = new Vector3(gridPos.x * cellSize, 0f, gridPos.y * cellSize);
                Vector3 drawPos = worldPos + Vector3.up * 0.3f;
    
                Gizmos.DrawSphere(drawPos, 0.1f);
    
                if (hasPrev)
                {
                    Gizmos.DrawLine(prevPos, drawPos);
                }
    
                prevPos = drawPos;
                hasPrev = true;
            }
        }
    #endif
}

 

 

몬스터가 Waypoint를 따라 이동하도록 구현

using UnityEngine;
 
public class MonsterAI : MonoBehaviour
{
    [Header("Move Settings")]
    [SerializeField] private float moveSpeed = 2f;
    [SerializeField] private float stoppingDistance = 0.05f;
 
    private int _currentIndex = 0;
    private Transform _currentTarget;
 
    private void Start()
    {
        if (GridManager.Instance == null)
        {
            Debug.LogError("GridManager 인스턴스가 없습니다.");
            enabled = false;
            return;
        }
 
        if (GridManager.Instance.WaypointCount == 0)
        {
            Debug.LogError("Waypoint가 하나도 없습니다. pathTiles를 설정했는지 확인하세요.");
            enabled = false;
            return;
        }
        
        Transform startPoint = GridManager.Instance.GetWaypoint(0);
        transform.position = startPoint.position;
        
        _currentIndex = 1;
        SetNextTarget();
    }
 
    private void Update()
    {
        MoveAlongPath();
    }
 
    private void MoveAlongPath()
    {
        if (_currentTarget == null)
            return;
 
        Vector3 targetPos = _currentTarget.position;
        Vector3 dir = targetPos - transform.position;
        
        dir.y = 0f;
 
        float distanceToTarget = dir.magnitude;
        float moveThisFrame = moveSpeed * Time.deltaTime;
        
        if (distanceToTarget <= moveThisFrame + stoppingDistance)
        {
            _currentIndex++;
            SetNextTarget();
            return;
        }
 
        Vector3 move = dir.normalized * moveThisFrame;
        transform.position += move;
        
        if (dir.sqrMagnitude > 0.0001f)
        {
            transform.rotation = Quaternion.LookRotation(dir);
        }
    }
 
    private void SetNextTarget()
    {
        if (_currentIndex >= GridManager.Instance.WaypointCount)
        {
            ReachGoal();
            return;
        }
 
        _currentTarget = GridManager.Instance.GetWaypoint(_currentIndex);
    }
 
    private void ReachGoal()
    {
        Destroy(gameObject);
    }
}
 

 

결과물