맵 만들기

전체 코드

 class Board
 {
     public enum TileType
     {
         Empty, // 빈 공간
         Wall,  // 벽
     }
     const char CIRCLE = '\u25cf'; // 유니코드 문자로 ● (검은색 원)을 출력하기 위한 상수. 맵 타일을 표시하는 데 사용됨.
     public TileType[,] _tile; // 2차원 배열로 맵의 각 타일의 상태를 저장.
     public int _size; // 맵의 크기. NxN 크기를 나타냄.
                       // 맵 초기화 메서드. 맵의 크기를 받아 타일을 생성하고 초기화.
     public void Initialize(int size)
     {
         _tile = new TileType[size, size]; // 맵의 크기(size x size)만큼의 2차원 배열 생성.
         _size = size; // 맵 크기 설정.
         for (int y = 0; y < _size; y++) // 행을 순회.
         {
             for (int x = 0; x < _size; x++) // 열을 순회.
             {
                 // 맵의 테두리를 벽으로 설정.
                 if (x == 0 || x == _size - 1 || y == 0 || y == _size - 1)
                 {
                     _tile[y, x] = TileType.Wall; // 벽 타일 설정.
                 }
                 else
                 {
                     _tile[y, x] = TileType.Empty; // 나머지 내부 공간은 빈 타일로 설정.
                 }
             }
         }
     }
     // 맵을 화면에 출력하는 메서드.
     public void Render()
     {
         ConsoleColor prevColor = Console.ForegroundColor; // 현재 콘솔의 글자색을 저장.
         for (int y = 0; y < _size; y++) // 행 순회.
         {
             for (int x = 0; x < _size; x++) // 열 순회.
             {
                 Console.ForegroundColor = GetTileColor(_tile[y, x]); // 현재 타일의 색을 설정.
                 Console.Write(CIRCLE); // ● 문자 출력.
             }
             Console.WriteLine(); // 한 행이 끝나면 다음 줄로 이동.
         }
         Console.ForegroundColor = prevColor; // 이전 색상으로 복원.
     }

     // 타일의 종류에 따라 콘솔 글자색을 반환하는 메서드.
     ConsoleColor GetTileColor(TileType type)
     {
         switch (type)
         {
             case TileType.Empty:
                 return ConsoleColor.Green; // 빈 공간은 초록색.
             case TileType.Wall:
                 return ConsoleColor.Red; // 벽은 빨간색.
             default:
                 return ConsoleColor.Green; // 기본값으로 초록색 반환.
         }
     }
 }
 
 class Program
{
    static void Main(string[] args)
    {

        // Board 클래스의 인스턴스를 생성하고 맵을 초기화.
        Board board = new Board();
        board.Initialize(25); // 맵의 크기를 25x25로 설정.
        Console.CursorVisible = false; // 콘솔의 커서를 숨김. 깔끔한 화면 출력.

        const int MAX_TICK = 1000 / 30; // 초당 30프레임을 유지하기 위한 최대 틱. (1초 / 30프레임)

        int lastTick = 0; // 마지막 프레임이 실행된 시간을 저장.

        // 메인 게임 루프
        while (true)
        {
            #region 프레임 관리
            // 프레임 시간 관리 (FPS 관리)
            // 현재 시간을 가져와서 지난 프레임 시간과 비교하여, 일정 시간이 지나지 않았다면 다음 루프를 건너뜀.
            int currentTick = System.Environment.TickCount; // 현재 시간을 밀리초 단위로 가져옴.
            int elapsedTick = currentTick - lastTick; // 지난 프레임 이후 경과 시간 계산.

            // 만약 경과 시간이 설정한 프레임 간격(MAX_TICK)보다 작다면 루프를 건너뜀.
            if (elapsedTick < MAX_TICK)
            {
                continue; // 일정 시간이 지나지 않았으므로 이번 루프는 건너뜀.
            }

            lastTick = currentTick; // 마지막 프레임 시간을 현재 시간으로 갱신.

            #endregion

            // 입력 처리 부분 (현재는 구현되어 있지 않음).
            // 사용자 입력: 키보드, 마우스 등.

            // 게임 로직 처리 부분 (현재는 구현되어 있지 않음).
            // AI 및 게임 내 로직 처리.

            // 렌더링: 화면에 그려주는 단계.
            Console.SetCursorPosition(0, 0); // 콘솔 출력 위치를 맨 위로 이동하여 화면을 새로 그리도록 함.
            board.Render(); // 맵을 그리는 메서드 호출
        }
    }
}

📜 코드 분석

1️⃣ Program.Main() - 메인 게임 루프

static void Main(string[] args)
{
    // 1️⃣ Board 객체를 생성하고, 25x25 크기의 미로를 초기화
    Board board = new Board();
    board.Initialize(25);

    // 2️⃣ 커서 숨기기 (콘솔에서 커서 깜빡임 제거)
    Console.CursorVisible = false;

    // 3️⃣ 프레임 고정 (30 FPS)
    const int MAX_TICK = 1000 / 30;
    int lastTick = 0;

    // 4️⃣ 메인 게임 루프 실행
    while (true)
    {
        #region 프레임 관리
        int currentTick = System.Environment.TickCount;
        int elapsedTick = currentTick - lastTick;

        if (elapsedTick < MAX_TICK)
            continue;

        lastTick = currentTick;
        #endregion

        // 5️⃣ 입력 처리 (현재 없음)
        // 사용자 입력 (키보드 등)

        // 6️⃣ 게임 로직 처리 (현재 없음)
        // AI 동작, 충돌 처리 등

        // 7️⃣ 화면 렌더링 (미로 출력)
        Console.SetCursorPosition(0, 0);
        board.Render();
    }
}

✅ Main()의 핵심 개념

1. Board 객체를 초기화하여 25x25 크기의 미로를 생성.
2. 콘솔 커서를 숨김 → 깔끔한 화면 유지.
3. 프레임 고정 (30 FPS) → TickCount를 이용해 일정 속도 유지.
4. 입력/로직/렌더링 순서대로 실행.
5. 화면을 갱신할 때 SetCursorPosition(0, 0)을 사용해 화면을 지우지 않고 덮어쓰기.

---

2️⃣ Board 클래스

미로를 관리하는 핵심 클래스로, 2D 배열을 사용하여 미로를 저장하고 출력합니다.

class Board
{
    private const char TILE_WALL = '■'; // 벽 (빨간색)
    private const char TILE_PATH = '●'; // 길 (초록색)
    private int size;
    private int[,] _map;

    public void Initialize(int size)
    {
        this.size = size;
        _map = new int[size, size];

        for (int y = 0; y < size; y++)
        {
            for (int x = 0; x < size; x++)
            {
                // 가장자리는 벽(1), 내부는 길(0)
                if (x == 0 || y == 0 || x == size - 1 || y == size - 1)
                    _map[y, x] = 1; // 벽
                else
                    _map[y, x] = 0; // 길
            }
        }
    }

    public void Render()
    {
        // 원래 콘솔 색상 저장
        ConsoleColor defaultColor = Console.ForegroundColor;

        for (int y = 0; y < size; y++)
        {
            for (int x = 0; x < size; x++)
            {
                // 색상 설정
                if (_map[y, x] == 1)
                    Console.ForegroundColor = ConsoleColor.Red; // 벽
                else
                    Console.ForegroundColor = ConsoleColor.Green; // 길

                Console.Write(TILE_PATH); // ● 출력
            }
            Console.WriteLine();
        }

        // 원래 콘솔 색상으로 복구
        Console.ForegroundColor = defaultColor;
    }
}

---

✅ 2D 배열을 사용한 미로 구현

• _map[y, x] → 0이면 길(●), 1이면 벽(■).
• Initialize(size): 2D 배열을 초기화하고 가장자리는 벽(1), 내부는 길(0)로 설정.
• Render(): 콘솔 색상을 설정하여 벽(빨간색), 길(초록색)을 출력.

---