[UE5 BP] _#3. 언리얼 엔진의 핵심 구조 이해: 에디터, 게임플레이, AI, 레벨 스트리밍

🎯 학습 목표

 

• 언리얼 에디터 인터페이스를 설명할 수 있다.
  • Level Editor의 주요 패널(메뉴 바, 뷰포트, 아웃라이너, 디테일 패널, 콘텐츠 드로어 등)의 역할과 기능을 이해하고,
    각 패널을 활용해 액터를 배치·편집하는 기본 조작 과정을 설명할 수 있다.
• 언리얼 게임플레이 프레임워크의 계층 구조를 이해하고 설명할 수 있다.
  • GameMode → Controller → Pawn → Actor → Component → Camera → HUD(UI)로 이어지는
    게임 실행 흐름을 도식화하고, 각 클래스의 역할과 상호작용 관계를 구체적으로 설명할 수 있다.
• PlayerController와 AIController의 차이와 역할을 구분할 수 있다.
  • PlayerController의 입력 처리 및 카메라 제어 방식과
    AIController의 Behavior Tree 기반 의사결정 구조를 비교하여 설명할 수 있다.
• Behavior Tree와 Blackboard의 작동 원리를 이해하고 구성할 수 있다.
  • Decorator, Task, Service, Observer Aborts 등 주요 노드의 기능을 설명하고,
    AI의 순찰·추격 행동을 구현할 수 있는 기본 트리 구조를 설계할 수 있다.
• 레벨 구조와 스트리밍 방식을 이해하고 적용할 수 있다.
  • Persistent Level과 Streaming Level의 차이를 설명하고,
    Volume 기반 및 Script 기반 Level Streaming을 사용해
    메모리 효율적이고 끊김 없는 월드 로딩 구조를 구성할 수 있다.

 

🧩 1. 주요 구성 요소

엔진을 처음 열면 Level Editor가 열린다.

레벨 에디터는 언리얼 에디터의 핵심 생성 기능을 제공하며, 레벨과 환경을 디자인하고 생성하는 데 사용된다.

구성요소	설명
1. 메뉴 바(Menu Bar) 및 탭 바	- 프로젝트 저장, 새 레벨 생성, 환경 설정 등 에디터 전반의 기능을 제공하는 상단 메뉴 영역 - 창 메뉴에서 에디터의 커스텀 레이아웃을 만들어 사용할 수 있다. - 현재 편집 중인 레벨 에셋의 이름(탭의 이름)
2. 메인 툴바 (Main Toolbar)	자주 사용하는 기능(저장, 실행, 빌드, 플레이 등)을 빠르게 실행할 수 있는 단축 버튼 모음
3. 뷰포트 툴바 (Viewport Toolbar)	오브젝트 이동, 회전, 스케일, 스냅 설정, 뷰 모드 변경 등을 제어하는 툴셋
4. 레벨 뷰포트 (Level Viewport)	- 게임 월드(레벨)를 시각적으로 편집하고 액터를 배치·조작하는 메인 작업 공간 - 뷰포트 레이아웃으로 여러 개의 뷰포트를 여러 타입으로 볼 수 있다. - 액터 선택 시 보이는 기즈모를 통해 이동, 회전, 스케일을 조절할 수 있다. 각 화살표는 축을 나타낸다. (빨강: X, 초록: Y, 파랑: Z)
5. 아웃라이너 (Outliner)	현재 레벨에 존재하는 모든 액터를 계층 구조로 표시하고 관리하는 패널
6. 디테일 패널 (Details Panel)	선택된 액터나 컴포넌트의 속성(위치, 회전, 머티리얼, 물리 등)을 편집하는 영역
7. 콘텐츠 드로어 (Content Drawer)	프로젝트의 모든 에셋(모델, 블루프린트, 사운드 등)을 저장, 관리하는 리소스 탐색 창
8. 하단 툴바 (Bottom Toolbar)	출력 로그, 콘솔, 소스컨트롤 상태 등 개발과 디버깅 관련 정보를 표시하는 영역

---

🎮 Unreal Engine 게임플레이 프레임워크 구조

언리얼 엔진의 게임 프레임워크는 게임 실행 시 생성되는 클래스 간의 계층적 관계를 기반으로 작동한다.

즉, GameMode → Controller → Pawn → Components → Camera → HUD(UI)의 흐름으로 게임 플레이가 구성된다.

---

🧩 1. GameMode (게임모드)

게임 플레이의 규칙과 흐름을 정의하는 핵심 클래스이다.

• 역할
  • 게임의 규칙과 진행 로직을 정의하며, 서버에서만 존재한다.
  • 어떤 Pawn, Controller, HUD 클래스를 사용할지 결정한다.
• 생성 시점
  • 레벨이 로드되고 게임플레이가 초기화될 때 AGameModeBase 인스턴스가 자동 생성된다.
• 구조 상 위치
  • 프레임워크의 루트에 해당하며, 모든 게임 객체의 생성 흐름을 관리한다.

---

👤 2. Controller (플레이어/AI 컨트롤러)

GameMode가 생성한 제어 주체(비물리적 액터)로, Pawn을 빙의(Possess) 하여 움직임과 행동을 제어한다.

• PlayerController
  • 실제 플레이어 입력(키보드, 마우스, 패드 등)을 받아 Pawn을 제어한다.   
    • → 플레이어와 Pawn 사이의 인터페이스(Interface) 역할
  • 카메라 시점, 입력 이벤트, HUD 상호작용 등을 주로 담당한다.
  • 설계 고려사항: PlayerController와 Pawn은 역할이 명확히 구분되어야 한다.
    • 단순한 입력 (예: 기본 이동, 회전 등) → Pawn 내부에서 직접 처리해도 무방
    • 복잡한 입력 흐름 또는 플레이어 교체/리스폰/멀티플레이 환경 → PlayerController에서 처리 권장

      PlayerController → (의사결정) "점프 명령"
                    ↓
      Pawn → (행동 실행) 실제 점프 애니메이션, 물리 처리
      

  • 지속성(Persistence) 차이
    • PlayerController: 게임 내에서 지속적으로 존재
      (플레이어가 죽거나 캐릭터가 교체되어도 계속 유지)
    • Pawn: 휘발성 존재, 리스폰 시 새로 스폰됨
      → 따라서 점수, UI, 입력 상태 등 지속 데이터는 Controller에 보관하는 것이 바람직하다.
    💡 예시
    데스매치 게임에서 플레이어가 사망 후 리스폰될 때
    • Pawn은 새로 생성되지만
    • PlayerController는 동일하게 유지되어 점수·상태값을 유지할 수 있다.
• AIController
  • AIController는 비플레이어 캐릭터(NPC) 를 제어하는 컨트롤러이다.
  • AI의 의사결정(Decision Making) 과 행동(Behavior Execution) 을 분리하여 설계할 수 있게 해주는 핵심 구조이다.
  • AI의 전체 로직은 보통 다음 세 가지 축으로 구성된다:
    • AIController → 의사결정 주체 (비물리적 존재)
    • Pawn → 실제 움직임·공격·탐지 수행 (물리적 존재)
    • Behavior Tree + Blackboard → 고수준 행동 로직(Decision Graph)

    기능	설명
    의사결정 로직 담당	AI의 시야 감지, 목표 탐색, 상태 판단 등 수행
    Pawn 제어	Possess()로 Pawn을 빙의하여 실제 행동 수행
    경로 탐색	NavMesh를 이용한 이동 및 장애물 회피
    Behavior Tree 실행	지정된 Behavior Tree를 구동하여 AI의 행동 흐름 결정

    메서드	설명
    Possess(Pawn*)	특정 Pawn을 제어하기 시작
    UnPossess()	Pawn과의 연결(빙의) 해제
    GetPawn()	현재 제어 중인 Pawn 객체 반환
    SetViewTarget()	카메라 시점 변경 (주로 PlayerController에서 사용)

• Behavior Tree
  • Behavior Tree는 AI의 의사결정 구조를 시각적 노드 그래프로 표현한 시스템이다.
  • AI가 “어떤 조건에서 어떤 행동을 선택할지” 를 트리 형태로 정의한다.
    ✅ 예시:
    플레이어를 발견하지 못한 경우 → “순찰”
    플레이어를 발견한 경우 → “추격”
  • 기본 구성 요소:

    구성 요소	역할
    Behavior Tree Graph	블루프린트처럼 시각적으로 노드를 연결해 로직 구성
    Blackboard	트리가 참조할 데이터(Key-Value 형태)를 저장
    Decorator	조건문 역할 (블랙보드 값을 기반으로 분기 결정)
    Task	실제 행동(이동, 공격 등)을 수행
    Service	주기적으로 데이터 갱신 (예: 타깃 위치 갱신)

  • 💡 일반적인 워크플로:
    • ① Blackboard 생성 → ② Key 추가 → ③ Behavior Tree 생성 및 연결 → ④ AIController에 트리 실행 로직 작성
  • Behavior Tree 실행 흐름:
    1. AIController가 Pawn을 Possess할 때 Behavior Tree를 실행
    2. Behavior Tree는 왼쪽 → 오른쪽, 위 → 아래 순으로 노드를 평가
    3. Decorator(조건문) 이 참이면 해당 Task(행동) 실행
    4. Service는 지정된 주기로 블랙보드 데이터를 업데이트
    5. Observer Aborts(관찰자 중단) 설정 시 조건 변화 시 즉시 행동 전환
  • Behavior Tree의 특징
    • 🎯 1. 이벤트 주도형 (Event-Driven Architecture)
      • 일반 트리는 매 프레임 조건을 폴링(Polling) 하지만, 언리얼 트리는 이벤트를 리스닝(Listen) 하는 방식으로 작동한다.
      • 조건이 바뀌면 해당 이벤트가 트리를 트리거(Trigger) 한다.
      • 즉, “지속적으로 묻는” 대신 “변화 시 알림 받는” 구조이다.
      • 장점:
        • 불필요한 반복 연산 제거 → 퍼포먼스 향상
        • 변경된 데이터만 추적 가능 → 디버깅 단순화
        • 트리 실행 히스토리도 효율적으로 관리 가능
    • ⚙️ 2. 조건문은 데코레이터 (Decorator-Based Conditions)
      • 전통 트리: 조건문이 리프(Leaf) 노드
      • 언리얼 트리: 조건문이 데코레이터(Decorator) 로 구성
        • 장점:
          • 트리가 직관적이고 읽기 쉬움
          • 모든 리프 노드가 액션(Task) 이므로 “무엇을 하는지” 명확
          • 데코레이터를 이벤트 관찰자로 사용 가능 (Observer 기능 활용)
    • 🔀 3. 동시 행동 처리 (Concurrent Behaviors)
      • 전통 트리에서는 병렬(Parallel) 노드로 여러 행동을 동시에 실행했지만, 언리얼은 단순 병렬(Simple Parallel), 서비스(Service), 관찰자 중단(Observer Aborts) 으로 이를 단순화했다.

        구성 요소	역할
        Simple Parallel Node	“A를 수행하면서 B도 수행” (예: 공격하면서 이동)
        Service	일정 주기로 데이터 업데이트 (예: 타깃 추적)
        Observer Aborts	조건 변화 시 태스크 즉시 중단 (“쥐가 도망치면 고양이 추격 중단”)

      • 장점:
        • 트리 구조 명확 → 읽기 쉽고 디버깅 간단
        • 이벤트 기반 구조 덕분에 최적화 용이
        • 병렬 노드보다 관리 비용 감소
  • 실행 구조:

AIController
          ├── Possess(Pawn)
          │                 └── RunBehaviorTree(TreeAsset)
          │                 ├── Blackboard(Key-Value 저장소)
          │                 ├── Composite (Selector / Sequence)
          │                 │               ├── Decorator (조건문)
          │                 │               ├── Service (정기 업데이트)
          │                 │               └── Task (행동 수행)
          │                 └── Observer (조건 변화 감시)

💡 Controller는 비물리적 존재, Pawn은 행동 실행자이다.
AIController는 명령을 내리고, Pawn은 그 명령을 실제 월드에서 수행한다.

---

🚶 3. Pawn / Character (제어 가능한 물리 객체)

컨트롤러가 빙의하여 조작할 수 있는 물리적 액터(Actor의 하위 클래스) 이다.

• Pawn
  • 플레이어나 AI의 물리적 표현(Physical Representation)
  • 컨트롤러와 1:1 관계로 연결된다.
• Character (Pawn의 하위 클래스)
  • 걷기, 점프, 중력 등 기본 이동 로직이 내장된 Pawn의 확장 버전이다.
  • CharacterMovementComponent가 이동을 담당한다.

💡 Pawn은 “움직이는 객체”, Controller는 “움직이게 하는 존재”이다.

---

🧱 4. Actor (액터) & Actor Components

언리얼 월드에 직접 배치(Place) 하거나 런타임에 스폰(Spawn) 가능한 기본 단위 클래스이다.

• Actor
  • 모든 오브젝트의 기본 클래스
  • 이동, 렌더링, 물리 충돌 등을 담당하는 Actor Component를 포함한다.
  • 네트워크 리플리케이션(프로퍼티·함수 동기화)을 지원한다.
• Actor Components
  • 액터의 행동을 정의하는 부품 단위 (예: Movement, Mesh, Collision, Audio 등)
  • 여러 컴포넌트를 조합해 하나의 액터를 구성한다.

---

🎥 5. Camera (카메라)

플레이어가 월드를 어떤 시점(View) 으로 바라보는지 정의한다.

• 역할
  • PlayerController가 카메라 클래스를 지정하고, CameraActor를 인스턴스화하여 시야를 관리한다.
  • 카메라 위치와 회전은 Pawn(또는 Character)의 위치를 기반으로 계산된다.
• 시점 구성
  • Controller → CameraManager → CameraActor → ViewTarget 구조로 연결되어 플레이어의 시야가 화면에 렌더링된다.

---

🧭 6. HUD / UI (사용자 인터페이스)

플레이어에게 게임 상태 정보를 표시하고 상호작용을 제공한다.

• HUD (Head-Up Display)
  • 체력, 탄약, 점수 등 게임 정보 표시
  • GameMode 또는 PlayerController에 의해 초기화
• UI (UMG Widget)
  • 메뉴, 버튼 등 상호작용 가능한 위젯 기반 인터페이스

💡 HUD와 UI는 PlayerController를 통해 입력 이벤트를 받아 게임 내부 로직으로 전달된다.

---

⏱ 7. Gameplay Timer (게임플레이 타이머)

게임 내에서 일정 시간 후 함수 실행이나 주기적 이벤트를 처리하는 시스템이다.

• 역할
  • 일정 시간 경과 후 특정 함수를 호출 (SetTimer, ClearTimer)
  • 예: 폭탄 카운트다운, 체력 회복 쿨타임, 점수 증가 주기

---

🧩 8. Modular Gameplay Plugin (모듈형 게임플레이 플러그인)

게임의 기능을 독립된 모듈 단위로 구성하기 위한 확장 구조이다.

• 역할
  • 프로젝트 내부 기능을 분리하여 관리
  • 기능 간 의존성 최소화 및 유지보수성 향상
• 예시
  • “인벤토리 시스템”, “퀘스트 시스템”, “AI 확장 기능” 등을 개별 플러그인으로 구현

2. Unreal Engine 게임 프레임워크 구조 관계 흐름

┌───────────────────┐
│                      Game Framework                       │
└───────────────────┘
                 │
                 ▼
        ┌──────────┐
        │   GameModeBase       │
        └──────────┘
           │   서버 전용
           │   (게임 규칙 / 흐름 관리)
           │
           ├── 관리: 어떤 Pawn을 사용할지 지정
           ├── 관리: 어떤 Controller를 생성할지 지정
           ├── 관리: UI(HUD)와 GameState 초기화
           ▼
┌─────────┐
│  GameStateBase     │   ← 게임 진행 상태, 점수, 라운드 등 공용 데이터
└─────────┘
                 │
────────────────────────────────────────────
                 │
                 ▼
┌──────────────────┐        ┌──────────────────┐
│ PlayerController                                           │        │  AIController                                                 │
└──────────────────┘        └──────────────────┘
     │ (입력 / 시점 관리)                                                          │ (AI 로직 관리)
     │                                                                                       │
     │ Possess()                                                                    │ Possess()
     ▼                                                                                        ▼
┌────────────────────────┐
│                           Pawn                                                             │
│  (플레이어나 AI가 제어하는 물리적 존재)                                 │
│  ┌────────────────────┐       │
│  │                     Components                                      │      │
│  │  ├── MovementComponent (이동)               │      │
│  │  ├── MeshComponent (시각적 모델)             │      │
│  │  ├── CollisionComponent (충돌)                   │      │
│  │  └── AudioComponent (소리 재생)                │      │
│  └────────────────────┘      │
└────────────────────────┘
     │
     └─>     Character (Pawn의 하위 클래스, 보행/점프 등 내장)
                     └─ MovementComponent가 캐릭터 이동 로직 담당

───────────────────────────────────────────
카메라 및 시점 제어 흐름
───────────────────────────────────────────
 PlayerController
     │
     ├── CameraManager 생성 및 제어
     │                 ↓
     │         CameraActor 인스턴스화
     │                 ↓
     │         ViewTarget = Pawn
     │                 ↓
     └── 최종 시점(Camera View)을 플레이어 화면에 렌더링

────────────────────────────────────────────
UI 및 상호작용 흐름
────────────────────────────────────────────
 GameModeBase
     │
     └── HUD (Head-Up Display) / UMG Widget 초기화
                         │
                         └── UI에서 PlayerController에 이벤트 전달
                                             └── Controller → Pawn 액션 수행

────────────────────────────────────────────
시간 및 비동기 이벤트
────────────────────────────────────────────
 TimerManager
     │
     └── 일정 시간 후 함수 실행 (예: 3초 후 폭발, 5초마다 점수 체크)

────────────────────────────────────────────
모듈형 구조 (기능 확장)
────────────────────────────────────────────
 Modular Gameplay Plugin
     │
     ├── 독립적인 게임 기능 모듈 추가
     └── 다른 시스템과의 종속성 최소화

---

3. 레벨의 개념과 구조

3-1. 메인 레벨과 서브 레벨

레벨은 게임이 진행되는 맵, 장면(Scene) 또는 무대(Stage)를 말한다.

언리얼에서는 하나의 레벨을 Persistent Level(메인 레벨)로 두고, 필요한 경우 Sub-Level(서브 레벨)을 추가로 불러와서 사용할 수 있다.

• 지형, 조명, 인테리어 등 특정 기능적 구분을 위해 레벨을 여러 개로 나눌 수 있음

3-2. Level Streaming

🧭 1. 개요 (Overview)

Level Streaming은 플레이 중에 필요한 시점에만 레벨 데이터를 로드(Load) 또는 언로드(Unload) 하여 메모리 사용량과 성능을 효율적으로 관리하는 기술이다.
특히 대규모 오픈월드나 시점 전환이 많은 게임에서 필수적인 기능으로, 플레이어가 끊김 없이 하나의 거대한 세계를 탐험하는 경험을 제공한다.

---

🏗️ 2. 핵심 구성 요소 (Core Components)

2.1 퍼시스턴트 레벨 (Persistent Level)

• 전체 월드의 ‘메인 레벨’ 역할을 하는 마스터 레벨
• 어떤 서브레벨(Streaming Level)을 로드하거나 언로드할지 제어하는 중심 레벨
• 퍼시스턴트 레벨 자체는 항상 로드된 상태로 유지되며, 하위 스트리밍 레벨의 로딩 상태를 관리한다.

2.2 스트리밍 레벨 (Streaming Level)

• 퍼시스턴트 레벨에 추가로 로드되는 서브레벨
• 각 스트리밍 레벨은 독립적으로 로드/언로드 가능
• 2가지 스트리밍 유형
  1. Always Loaded : 항상 로드됨 (퍼시스턴트 레벨과 함께 유지)
  2. Blueprint Controlled : 블루프린트 또는 C++ 로직으로 로드/언로드 제어
• 아티스트/디자이너 간 병렬 작업 시, 하나의 월드를 여러 서브레벨로 나누어 효율적으로 협업 가능

---

⚙️ 3. 스트리밍 방식 (Streaming Methods)

3.1 볼륨 기반 스트리밍 (Volume-Based Streaming)

• Level Streaming Volume을 이용해 카메라 위치(또는 플레이어 뷰포인트)에 따라 자동으로 레벨 로드/언로드를 수행한다.
• ✅ 장점
  • 스크립트 작성 없이 직관적으로 설정 가능
  • 스트리밍 영역 크기만 조정해도 로딩 타이밍을 쉽게 변경 가능
  • 에디터에서도 프리뷰 지원 (뷰포트 카메라 위치에 따라 자동 표시/숨김)
• 📘 작동 방식
  • 뷰포인트가 볼륨 내부 → 레벨 로드
  • 뷰포인트가 볼륨 외부 → 레벨 언로드

3.2 스크립트 기반 스트리밍 (Script-Based Streaming)

• 블루프린트 또는 C++ 코드를 이용해 세밀하게 제어하는 방식
• 🔹 주요 함수:
  • Load Stream Level : 지정한 레벨을 메모리에 로드
  • Unload Stream Level : 지정한 레벨을 언로드
  • Get Streaming Level : 특정 스트리밍 레벨의 상태를 조회·제어
  • Create Instance : 레벨의 인스턴스 복제 및 프로시저럴 생성 지원
• 🚀 활용 예시
  • 잠긴 문이 열릴 때 해당 구역의 서브레벨을 로드
  • 랜덤 지형이나 던전 구조를 동적으로 생성하는 프로시저럴 시스템 구현
• 레벨 전환(Load/Travel)
  • 게임 진행 상황에 따라 새로운 레벨로 전환이 필요할 때, 블루프린트 혹은 C++ 함수를 통해 다른 레벨을 로드한다.

BeginPlay(레벨 시작) → 3초 딜레이 → Lvl_ThirdPerson 로 이동하는 로직

---

🧩 4. 활용 구조 (Practical Workflow)

구성 요소	역할	제어 방식
Persistent Level	전체 월드 관리	항상 로드됨
Streaming Level	서브 지역, 구역 단위 콘텐츠	Always Loaded / Blueprint
Level Streaming Volume	위치 기반 자동 로드	뷰포인트 위치
Blueprint / C++	조건 기반 동적 로드	함수 호출 방식

---

🌍 5. 기대 효과 (Benefits)

• ✅ 성능 최적화: 불필요한 리소스 메모리에서 제거
• ✅ 로딩 체감 감소: Seamless World 구현 가능
• ✅ 협업 효율 향상: 팀 단위 레벨 분리 작업
• ✅ 확장성 확보: 프로시저럴/동적 콘텐츠 생성에 유용

---

🧠 6. 핵심 요약 (Key Takeaways)

• Level Streaming은 “필요한 시점에만 필요한 레벨을 로드한다”는 단순하지만 강력한 원리로,
  오픈월드·멀티레벨 게임의 끊김 없는 경험과 메모리 효율성을 모두 달성하게 해주는 핵심 기술이다.