struct FRoomFlags
{
    // 보조 지형 생성 허용 여부
    bool f_secondary_terrain_generation = false;

    // 방 외곽에 불규칙한 변형을 적용할지 여부
    bool f_room_imperfections = false;
};

struct FFloorProperties
{
    // 전체 방·복도 배치 방식
    FloorLayout layout = FloorLayout::LAYOUT_SMALL;

    // 방 생성의 추가 옵션
    FRoomFlags room_flags;
    
    // 막다른 복도를 허용할지 여부
    bool allow_dead_ends = false;

    // 방으로 선택할 셀 수에 영향을 주는 값
    int32 room_density = 7;

    // 셀 사이의 연결을 시도하는 반복 횟수
    int32 floor_connectivity = 24;

    // 기본 연결 이후 추가로 생성할 복도 수
    int32 num_extra_hallways = 0;
};

struct FGridCell
{
    // 생성 대상에서 제외하는 셀인지 여부
    bool is_invalid = false;

    // true면 방, false면 Anchor로 사용할 유효 셀
    bool is_room = false;

    // 복도 연결 처리에 참여했는지 기록하는 상태
    bool is_connected = false;

    // 이웃 셀과의 연결 계획
    bool connected_to_top = false;
    bool connected_to_bottom = false;
    bool connected_to_left = false;
    bool connected_to_right = false;

    // 실제 복도를 만들 때 소비하는 작업용 연결 플래그
    bool should_connect_to_top = false;
    bool should_connect_to_bottom = false;
    bool should_connect_to_left = false;
    bool should_connect_to_right = false;

    // 방 병합에 사용하는 상태
    bool has_been_merged = false;
    bool is_merged = false;
    
    // 셀 안에 생성한 방·Anchor의 범위.
    int32 start_x = 0;
    int32 start_y = 0;
    int32 end_x = 0;
    int32 end_y = 0;
};

struct FTerrainFlags
{
    // 처음에는 벽으로 시작한다.
    TerrainType terrain_type = TerrainType::TERRAIN_WALL;

    // 맵 외곽처럼 통과할 수 없는 벽인지 여부
    bool f_impassable_wall = false;
};

struct FTile
{
    FTerrainFlags terrain_flags;

    // 소속된 방의 번호(0부터 시작). 0xFE(254)는 생성 중인 Anchor, 0xFF(255)는 방에 속하지 않는 타일을 의미한다.
    int32 room_index = 0xFF;
};

void UDungeonGenerator::GenerateBaseFloor(
    int32 columnCount,
    int32 rowCount,
    const FFloorProperties& floorProperties)
{
    // 셀 경계와 기본 상태를 준비한다.
    TArray<int32> columnBoundaries;
    TArray<int32> rowBoundaries;
    BuildCellBoundaries(columnCount, rowCount, columnBoundaries, rowBoundaries);

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    // 방과 Anchor를 배치한다.
    ChooseRoomCells(cells, columnCount, rowCount, floorProperties.room_density);

    CarveRoomsAndAnchors(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, floorProperties.room_flags);

    const int32 cursorColumn = dungeonRand.RandInt(columnCount);
    const int32 cursorRow = dungeonRand.RandInt(rowCount);

    // 연결 계획을 기록한 뒤 실제 복도를 생성한다.
    PlanCellConnections(cells, columnCount, rowCount, cursorColumn, cursorRow, floorProperties);
    CarveCellConnections(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, false);

    RepairUnconnectedCells(cells, columnCount, rowCount, columnBoundaries, rowBoundaries);

    // 이후의 특수 방·장식 처리는 이번 글에서는 생략한다.
}

void UDungeonGenerator::BuildCellBoundaries(
    int32 columnCount,
    int32 rowCount,
    TArray<int32>& columnBoundaries,
    TArray<int32>& rowBoundaries) const
{
    columnBoundaries.Empty();
    rowBoundaries.Empty();

    // 전체 타일 맵의 크기로 셀 간격을 구한다.
    const int32 cellWidth = FLOOR_MAX_X / columnCount;
    const int32 cellHeight = FLOOR_MAX_Y / rowCount;

    // 셀 수보다 경계 좌표를 하나 더 저장한다.
    for (int32 column = 0; column <= columnCount; ++column)
    {
        columnBoundaries.Add(column * cellWidth);
    }

    for (int32 row = 0; row <= rowCount; ++row)
    {
        rowBoundaries.Add(row * cellHeight);
    }
}

TArray<TArray<FGridCell>> UDungeonGenerator::CreateCellGrid(
    int32 columnCount,
    int32 rowCount)
{
    TArray<TArray<FGridCell>> cells;
    cells.SetNum(15);

    // 셀 정보를 저장할 15 × 15 배열을 준비한다.
    for (int32 column = 0; column < 15; ++column)
    {
        cells[column].SetNum(15);

        for (int32 row = 0; row < 15; ++row)
        {
            cells[column][row] = FGridCell();
        }
    }

    // 이번 층에서 사용할 범위의 셀 상태를 설정한다.
    for (int32 column = 0; column < columnCount; ++column)
    {
        for (int32 row = 0; row < rowCount; ++row)
        {
            // Small은 오른쪽 절반을 생성 대상에서 제외한다.
            if (statusData.floor_size == FloorSize::FLOOR_SIZE_SMALL &&
                column >= FMath::FloorToInt(
                    static_cast<float>(columnCount) / 2.0f))
            {
                cells[column][row].is_invalid = true;
            }
            // Medium은 오른쪽 약 1/4을 생성 대상에서 제외한다.
            else if (statusData.floor_size == FloorSize::FLOOR_SIZE_MEDIUM &&
                column >= FMath::FloorToInt(
                    (3.0f * static_cast<float>(columnCount)) / 4.0f))
            {
                cells[column][row].is_invalid = true;
            }
            else
            {
                cells[column][row].is_invalid = false;
            }

            // 우선 방 후보로 설정한다.
            cells[column][row].is_room = true;
        }
    }

    return cells;
}

void UDungeonGenerator::ChooseRoomCells(
    TArray<TArray<FGridCell>>& cells,
    int32 columnCount,
    int32 rowCount,
    int32 requestedRoomCount)
{
    const int32 cellCount = columnCount * rowCount;

    // 1. 방 후보 수만큼 true, 나머지는 false로 준비한다.
    TArray<bool> roomChoices;
    roomChoices.Init(false, cellCount);

    for (int32 index = 0;
         index < requestedRoomCount && index < cellCount;
         ++index)
    {
        roomChoices[index] = true;
    }

    // 2. 두 위치의 값을 교환하며 배치를 섞는다.
    for (int32 attempt = 0; attempt < 64; ++attempt)
    {
        const int32 firstIndex = dungeonRand.RandInt(cellCount);
        const int32 secondIndex = dungeonRand.RandInt(cellCount);

        const bool previousChoice = roomChoices[firstIndex];
        roomChoices[firstIndex] = roomChoices[secondIndex];
        roomChoices[secondIndex] = previousChoice;
    }

    // 3. 유효한 셀에 방 또는 Anchor 역할을 배정한다.
    int32 choiceIndex = 0;
    statusData.num_rooms = 0;

    for (int32 column = 0; column < columnCount; ++column)
    {
        for (int32 row = 0; row < rowCount; ++row)
        {
            FGridCell& cell = cells[column][row];

            if (cell.is_invalid)
            {
                continue;
            }

            cell.is_room = roomChoices[choiceIndex];
            choiceIndex++;

            if (cell.is_room)
            {
                statusData.num_rooms++;
            }
        }
    }
}

void UDungeonGenerator::CarveRoomsAndAnchors(
    TArray<TArray<FGridCell>>& cells,
    int32 columnCount,
    int32 rowCount,
    const TArray<int32>& columnBoundaries,
    const TArray<int32>& rowBoundaries,
    const FRoomFlags& roomFlags)
{
    int32 roomId = 0;

    for (int32 row = 0; row < rowCount; ++row)
    {
        for (int32 column = 0; column < columnCount; ++column)
        {
            FGridCell& cell = cells[column][row];

            if (cell.is_invalid)
            {
                continue;
            }

            // 현재 셀의 왼쪽·위쪽 좌표와 가로·세로 길이
            const int32 cellStartX = columnBoundaries[column];
            const int32 cellStartY = rowBoundaries[row];

            const int32 cellWidth = columnBoundaries[column + 1] - cellStartX;
            const int32 cellHeight = rowBoundaries[row + 1] - cellStartY;

            // 셀 경계에 여백을 남기기 위한 크기 계산 기준
            const int32 availableWidth = cellWidth - 4;
            const int32 availableHeight = cellHeight - 3;

            if (!cell.is_room)
            {
                // Anchor 위치 선택에 사용할 추가 여백
                const int32 leftInset = column == 0 ? 1 : 2;
                const int32 rightInset = column == columnCount - 1 ? 2 : 4;
                const int32 topInset = row == 0 ? 1 : 2;
                const int32 bottomInset = row == rowCount - 1 ? 2 : 4;

                const int32 anchorX = dungeonRand.RandRange(
                    cellStartX + 2 + leftInset,
                    cellStartX + 2 + availableWidth - rightInset);

                const int32 anchorY = dungeonRand.RandRange(
                    cellStartY + 2 + topInset,
                    cellStartY + 2 + availableHeight - bottomInset);

                // Anchor는 한 칸짜리 바닥으로 기록한다.
                cell.start_x = anchorX;
                cell.start_y = anchorY;
                cell.end_x = anchorX + 1;
                cell.end_y = anchorY + 1;

                FTile& anchorTile = dungeonData.list_tiles[anchorX][anchorY];
                anchorTile.terrain_flags.terrain_type = TerrainType::TERRAIN_NORMAL;
                
                // Anchor는 계산한 위치 한 칸을 일반 바닥으로 만들고, 방과 구분하기 위해 `room_index`에 `0xFE`를 기록한다.
                anchorTile.room_index = 0xFE;

                continue;
            }

            // 1. 셀 안에 들어갈 방의 가로·세로 크기를 선택한다.
            int32 roomWidth = dungeonRand.RandRange(5, availableWidth);
            int32 roomHeight = dungeonRand.RandRange(4, availableHeight);

            // 2-1. 범위가 허용하면 크기를 홀수로 조정한다.
            // 정수에 | 1을 적용하면 짝수는 1 증가하고 홀수는 유지된다.
            if ((roomWidth | 1) < availableWidth)
            {
                roomWidth |= 1;
            }

            if ((roomHeight | 1) < availableHeight)
            {
                roomHeight |= 1;
            }

            // 2-2. 어느 한쪽이 다른 쪽의 1.5배를 넘으면 줄인다.
            if (roomWidth > FMath::FloorToInt(roomHeight * 1.5f))
            {
                roomWidth = FMath::FloorToInt(roomHeight * 1.5f);
            }

            if (roomHeight > FMath::FloorToInt(roomWidth * 1.5f))
            {
                roomHeight = FMath::FloorToInt(roomWidth * 1.5f);
            }

            // 3. 남은 공간 안에서 방의 시작 위치를 선택한다.
            // 셀의 왼쪽·위쪽 경계에서 기본적으로 두 칸을 띄운다.
            const int32 roomStartX =
                cellStartX + 2 +
                dungeonRand.RandInt(availableWidth - roomWidth);

            const int32 roomStartY =
                cellStartY + 2 +
                dungeonRand.RandInt(availableHeight - roomHeight);

            const int32 roomEndX = roomStartX + roomWidth;
            const int32 roomEndY = roomStartY + roomHeight;

            // 이후 복도 생성에서 사용할 방의 범위를 저장한다.
            cell.start_x = roomStartX;
            cell.start_y = roomStartY;
            cell.end_x = roomEndX;
            cell.end_y = roomEndY;

            // 4. 방 영역을 바닥으로 바꾸고 같은 방 번호를 기록한다.
            // 끝 좌표는 포함하지 않는다.
            for (int32 tileX = roomStartX; tileX < roomEndX; ++tileX)
            {
                for (int32 tileY = roomStartY; tileY < roomEndY; ++tileY)
                {
                    FTile& tile = dungeonData.list_tiles[tileX][tileY];
                    tile.terrain_flags.terrain_type = TerrainType::TERRAIN_NORMAL;
                    tile.room_index = roomId;
                }
            }

            roomId++;
        }
    }
}

void UDungeonGenerator::PlanCellConnections(
    TArray<TArray<FGridCell>>& cells,
    int32 columnCount,
    int32 rowCount,
    int32 cursorColumn,
    int32 cursorRow,
    const FFloorProperties& floorProperties)
{
    // 무작위 연결 방향을 선택한다.
    // 현재 셀을 다음 방향의 셀과 연결한다:
    // 0: 동
    // 1: 북
    // 2: 서
    // 3: 남
    CardinalDirection direction = static_cast<CardinalDirection>(dungeonRand.RandInt(4));

    // floor_connectivity 횟수만큼 현재 셀을 다른 Grid Cell과 연결 시도
    for (int32 step = 0; step < floorProperties.floor_connectivity; ++step)
    {
        // 절반의 분기에서는 방향을 새로 뽑고, 나머지에서는 유지한다.

        const int32 directionChoice = dungeonRand.RandInt(8);
        const CardinalDirection candidateDirection = static_cast<CardinalDirection>(dungeonRand.RandInt(4));

        if (directionChoice < 4)
        {
            // 새로운 방향으로 섞는다.
            direction = candidateDirection;
        }

        // 방향이 경계 바깥으로 향하지 않도록 보정
        // 그 경우 반시계 방향으로 회전
        bool ok = false;
        while (!ok)
        {
            switch (direction)
            {
            case CardinalDirection::DIR_RIGHT:
                ok = cursorColumn < columnCount - 1;
                break;
            case CardinalDirection::DIR_UP:
                ok = cursorRow > 0;
                break;
            case CardinalDirection::DIR_LEFT:
                ok = cursorColumn > 0;
                break;
            case CardinalDirection::DIR_DOWN:
                ok = cursorRow < rowCount - 1;
                break;
            }

            if (!ok)
            {
                // 반시계 방향 회전
                direction = static_cast<CardinalDirection>((static_cast<int32>(direction) + 1) % 4);
            }
        }

        // 연결을 설정하고, 그 방향으로 이동한다.
        if (direction == CardinalDirection::DIR_RIGHT && !cells[cursorColumn + 1][cursorRow].is_invalid)
        {
            cells[cursorColumn][cursorRow].connected_to_right = true;
            cells[cursorColumn + 1][cursorRow].connected_to_left = true;
            cursorColumn++;
        }
        else if (direction == CardinalDirection::DIR_UP && !cells[cursorColumn][cursorRow - 1].is_invalid)
        {
            cells[cursorColumn][cursorRow].connected_to_top = true;
            cells[cursorColumn][cursorRow - 1].connected_to_bottom = true;
            cursorRow--;
        }
        else if (direction == CardinalDirection::DIR_LEFT && !cells[cursorColumn - 1][cursorRow].is_invalid)
        {
            cells[cursorColumn][cursorRow].connected_to_left = true;
            cells[cursorColumn - 1][cursorRow].connected_to_right = true;
            cursorColumn--;
        }
        else if (direction == CardinalDirection::DIR_DOWN && !cells[cursorColumn][cursorRow + 1].is_invalid)
        {
            cells[cursorColumn][cursorRow].connected_to_bottom = true;
            cells[cursorColumn][cursorRow + 1].connected_to_top = true;
            cursorRow++;
        }
    }
}

void UDungeonGenerator::CarveCellConnections(
    TArray<TArray<FGridCell>>& cells,
    int32 columnCount,
    int32 rowCount,
    const TArray<int32>& columnBoundaries,
    const TArray<int32>& rowBoundaries,
    bool disableRoomMerging)
{
    // ... 셀 순회, 연결 플래그 복사와 검증, 출구 좌표 선택은 생략한다.
    // cellColumn·cellRow는 현재 셀, corridorStartX는 미리 고른 출구 x 좌표다.

    if (cells[cellColumn][cellRow].should_connect_to_top)
    {
        // 위 셀과 연결
        if (!cells[cellColumn][cellRow - 1].is_invalid)
        {
            if (!cells[cellColumn][cellRow - 1].is_room)
            {
                // 앵커면 중앙 x 사용
                corridorEndX = cells[cellColumn][cellRow - 1].start_x;
            }
            else
            {
                // 방이면 내부 x 선택
                corridorEndX = dungeonRand.RandRange(
                    cells[cellColumn][cellRow - 1].start_x + 1,
                    cells[cellColumn][cellRow - 1].end_x - 1);
            }

            CarveCorridor(
                corridorStartX,
                cells[cellColumn][cellRow].start_y,
                corridorEndX,
                cells[cellColumn][cellRow - 1].end_y - 1,
                true,
                columnBoundaries[cellColumn],
                rowBoundaries[cellRow]);
        }

        cells[cellColumn][cellRow].should_connect_to_top = false;
        cells[cellColumn][cellRow - 1].should_connect_to_bottom = false;
        cells[cellColumn][cellRow].is_connected = true;
        cells[cellColumn][cellRow - 1].is_connected = true;
    }

    // ... 나머지 방향 연결과 조건부 방 병합은 생략한다.
}

void UDungeonGenerator::RepairUnconnectedCells(
    TArray<TArray<FGridCell>>& cells,
    int32 columnCount,
    int32 rowCount,
    const TArray<int32>& columnBoundaries,
    const TArray<int32>& rowBoundaries)
{
    // ... 연결되지 않은 방과 위쪽의 연결된 셀을 찾는 부분은 생략한다.
    // roomExitX·roomExitY와 corridorStartX는 앞에서 계산한 출구·입구 좌표다.

    CarveCorridor(
        roomExitX,
        cells[cellColumn][cellRow].start_y,
        corridorStartX,
        cells[cellColumn][cellRow - 1].end_y - 1,
        true,
        columnBoundaries[cellColumn],
        rowBoundaries[cellRow]);

    cells[cellColumn][cellRow].is_connected = true;
    cells[cellColumn][cellRow].connected_to_top = true;
    cells[cellColumn][cellRow - 1].connected_to_bottom = true;

    // ... 나머지 방향의 추가 연결과 고립된 셀 제거는 생략한다.
}

void UDungeonGenerator::GenerateLineFloor(
    const FFloorProperties& floorProperties)
{
    const int32 columnCount = 5;
    const int32 rowCount = 1;

    TArray<int32> columnBoundaries = {0, 11, 22, 33, 44, 56};
    TArray<int32> rowBoundaries = {4, 15};

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    ChooseRoomCells(cells, columnCount, rowCount, floorProperties.room_density);
    CarveRoomsAndAnchors(
        cells,
        columnCount,
        rowCount,
        columnBoundaries,
        rowBoundaries,
        floorProperties.room_flags);

    const int32 cursorColumn = dungeonRand.RandInt(columnCount);
    const int32 cursorRow = dungeonRand.RandInt(rowCount);

    PlanCellConnections(cells, columnCount, rowCount, cursorColumn, cursorRow, floorProperties);
    CarveCellConnections(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, true);

    RepairUnconnectedCells(cells, columnCount, rowCount, columnBoundaries, rowBoundaries);

    ...
}

void UDungeonGenerator::GenerateCrossFloor(
    const FFloorProperties& floorProperties)
{
    const int32 columnCount = 3;
    const int32 rowCount = 3;

    TArray<int32> columnBoundaries = {11, 22, 33, 44};
    TArray<int32> rowBoundaries = {2, 11, 20, 30};

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    // 모든 셀을 방으로 설정
    for (int32 cellColumn = 0; cellColumn < columnCount; cellColumn++)
    {
        for (int32 cellRow = 0; cellRow < rowCount; cellRow++)
        {
            cells[cellColumn][cellRow].is_room = true;
        }
    }

    // 모서리 invalid
    cells[0][0].is_invalid = true;
    cells[0][rowCount - 1].is_invalid = true;
    cells[columnCount - 1][0].is_invalid = true;
    cells[columnCount - 1][rowCount - 1].is_invalid = true;

    CarveRoomsAndAnchors(
        cells,
        columnCount,
        rowCount,
        columnBoundaries,
        rowBoundaries,
        floorProperties.room_flags);

    cells[1][0].connected_to_bottom = true;
    cells[1][1].connected_to_top = true;
    cells[1][1].connected_to_bottom = true;
    cells[1][2].connected_to_top = true;
    cells[0][1].connected_to_right = true;
    cells[1][1].connected_to_left = true;
    cells[1][1].connected_to_right = true;
    cells[2][1].connected_to_left = true;

    CarveCellConnections(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, true);

    RepairUnconnectedCells(cells, columnCount, rowCount, columnBoundaries, rowBoundaries);

    ...
}

void UDungeonGenerator::GenerateBeetleFloor(
    const FFloorProperties& floorProperties)
{
    const int32 columnCount = 3;
    const int32 rowCount = 3;

    TArray<int32> columnBoundaries = {5, 15, 35, 50};
    TArray<int32> rowBoundaries = {2, 11, 20, 30};

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    // 모든 셀을 방으로 설정
    for (int32 cellColumn = 0; cellColumn < columnCount; cellColumn++)
    {
        for (int32 cellRow = 0; cellRow < rowCount; cellRow++)
        {
            cells[cellColumn][cellRow].is_room = true;
        }
    }

    CarveRoomsAndAnchors(
        cells,
        columnCount,
        rowCount,
        columnBoundaries,
        rowBoundaries,
        floorProperties.room_flags);

    // 같은 행의 방들을 연결
    for (int32 cellRow = 0; cellRow < rowCount; cellRow++)
    {
        cells[0][cellRow].connected_to_right = true;
        cells[1][cellRow].connected_to_left = true;
        cells[1][cellRow].connected_to_right = true;
        cells[2][cellRow].connected_to_left = true;
    }

    CarveCellConnections(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, true);

    // 중앙 열을 하나의 큰 방으로 병합
    MergeRoomsInColumn(1, 0, 1, cells);
    MergeRoomsInColumn(1, 0, 2, cells);

    RepairUnconnectedCells(cells, columnCount, rowCount, columnBoundaries, rowBoundaries);

    // 이후의 특수 방·추가 복도·장식 처리는 생략한다.
}

void UDungeonGenerator::GenerateOuterRingFloor(
    const FFloorProperties& floorProperties)
{
    const int32 columnCount = 6;
    const int32 rowCount = 4;

    TArray<int32> columnBoundaries = {0, 5, 16, 28, 39, 51, 56};
    TArray<int32> rowBoundaries = {2, 7, 16, 25, 30};

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    // 바깥 고리를 방이 아니도록 표시
    for (int32 cellColumn = 0; cellColumn < columnCount; cellColumn++)
    {
        cells[cellColumn][0].is_room = false;
        cells[cellColumn][rowCount - 1].is_room = false;
    }

    for (int32 cellRow = 0; cellRow < rowCount; cellRow++)
    {
        cells[0][cellRow].is_room = false;
        cells[columnCount - 1][cellRow].is_room = false;
    }

    // 안쪽은 방으로 표시
    for (int32 cellColumn = 1; cellColumn < columnCount - 1; cellColumn++)
    {
        for (int32 cellRow = 1; cellRow < rowCount - 1; cellRow++)
        {
            cells[cellColumn][cellRow].is_room = true;
        }
    }

    ...
}

void UDungeonGenerator::GenerateCrossroadsFloor(
    const FFloorProperties& floorProperties)
{
    const int32 columnCount = 5;
    const int32 rowCount = 4;

    TArray<int32> columnBoundaries = {0, 11, 22, 33, 44, 56};
    TArray<int32> rowBoundaries = {1, 9, 16, 23, 31};

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    // 바깥 고리를 방으로 표시
    for (int32 cellColumn = 0; cellColumn < columnCount; cellColumn++)
    {
        cells[cellColumn][0].is_room = true;
        cells[cellColumn][rowCount - 1].is_room = true;
    }

    for (int32 cellRow = 0; cellRow < rowCount; cellRow++)
    {
        cells[0][cellRow].is_room = true;
        cells[columnCount - 1][cellRow].is_room = true;
    }

    // 안쪽은 복도로 표시
    for (int32 cellColumn = 1; cellColumn < columnCount - 1; cellColumn++)
    {
        for (int32 cellRow = 1; cellRow < rowCount - 1; cellRow++)
        {
            cells[cellColumn][cellRow].is_room = false;
        }
    }

    // 코너는 invalid
    cells[0][0].is_invalid = true;
    cells[0][rowCount - 1].is_invalid = true;
    cells[columnCount - 1][0].is_invalid = true;
    cells[columnCount - 1][rowCount - 1].is_invalid = true;

    // ... 각 셀의 방·Anchor 타일을 생성하는 부분은 생략한다.

    for (int32 cellColumn = 1; cellColumn < columnCount - 1; cellColumn++)
    {
        for (int32 cellRow = 0; cellRow < rowCount - 1; cellRow++)
        {
            cells[cellColumn][cellRow].connected_to_bottom = true;
            cells[cellColumn][cellRow + 1].connected_to_top = true;
        }
    }

    for (int32 cellColumn = 0; cellColumn < columnCount - 1; cellColumn++)
    {
        for (int32 cellRow = 1; cellRow < rowCount - 1; cellRow++)
        {
            cells[cellColumn][cellRow].connected_to_right = true;
            cells[cellColumn + 1][cellRow].connected_to_left = true;
        }
    }

    CarveCellConnections(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, true);

    RepairUnconnectedCells(cells, columnCount, rowCount, columnBoundaries, rowBoundaries);

    // 이후의 특수 방·장식 처리는 생략한다.
}

void UDungeonGenerator::GenerateOuterRoomsFloor(
    int32 columnCount,
    int32 rowCount,
    const FFloorProperties& floorProperties)
{
    TArray<int32> columnBoundaries;
    TArray<int32> rowBoundaries;
    BuildCellBoundaries(columnCount, rowCount, columnBoundaries, rowBoundaries);

    grid_cell_start_x = columnBoundaries;
    grid_cell_start_y = rowBoundaries;

    TArray<TArray<FGridCell>> cells = CreateCellGrid(columnCount, rowCount);

    // 모든 셀을 방으로 설정
    for (int32 cellColumn = 0; cellColumn < columnCount; cellColumn++)
    {
        for (int32 cellRow = 0; cellRow < rowCount; cellRow++)
        {
            cells[cellColumn][cellRow].is_room = true;
        }
    }

    // 내부 셀은 invalid
    for (int32 cellColumn = 1; cellColumn < columnCount - 1; cellColumn++)
    {
        for (int32 cellRow = 1; cellRow < rowCount - 1; cellRow++)
        {
            cells[cellColumn][cellRow].is_invalid = true;
        }
    }

    CarveRoomsAndAnchors(
        cells,
        columnCount,
        rowCount,
        columnBoundaries,
        rowBoundaries,
        floorProperties.room_flags);

    // ... 외곽 연결 플래그를 설정하는 분기는 생략한다.

    CarveCellConnections(cells, columnCount, rowCount, columnBoundaries, rowBoundaries, false);
    RepairUnconnectedCells(cells, columnCount, rowCount, columnBoundaries, rowBoundaries);

    // 이후의 특수 방·장식 처리는 생략한다.
}