게임의 적 AI를 튜닝하는 데 몇 주를 보냈지만, 플레이테스터들은 여전히 "예측 가능하다"거나 "단조롭다"고 평가하곤 합니다. 전투가 적응형 듀얼이 아니라 반복적인 퍼즐을 푸는 것처럼 느껴지기 때문입니다. 이것이 현대 액션 게임의 핵심 과제입니다. 즉, 스크립트된 느낌이 아니라 지능적이고 반응적인 느낌을 주는 AI를 만드는 것입니다.
최근 갓 오브 워 라그나로크(God of War Ragnarök)와 같은 타이틀은 이 기준을 한 단계 높였습니다. 플레이어는 자신의 전술을 학습하고, 공격을 조율하며, 전략적 적응을 강요하는 적을 기대합니다. 기존의 유한 상태 기계(FSM) 방식은 한계에 다다르고 있습니다. 이와 동시에, 접근 가능한 머신러닝 라이브러리(TensorFlow.js, PyTorch)와 더 빨라진 하드웨어 덕분에 머신러닝(ML)은 연구실을 벗어나 실제 게임 개발 툴킷으로 들어왔습니다.
이러한 변화는 개발자가 이전에는 불가능했던 AI 행동의 프로토타입을 이제 제작할 수 있음을 의미합니다. 하룻밤 사이에 시스템 전체를 교체하는 것이 아니라, 적의 반응 타이밍이나 공격 패턴 선택과 같은 특정 메커니즘을 경량 모델로 보강하는 것입니다. 목표는 설계의 복잡성을 기하급수적으로 늘리지 않으면서도 더 풍부하고 역동적인 게임플레이를 구현하는 것입니다.
상태 머신에서 행동 정책 네트워크로
전통적인 게임 AI는 종종 계층적 상태 머신에 의존합니다. 적은 `대기(Idle)`, `추격(Chase)`, `공격(Attack)`, `도주(Flee)`와 같은 상태를 가지며, 조건(거리, 체력)에 따라 상태가 전이됩니다. 이 방식은 명확하고 디버깅이 쉽지만, 복잡한 행동을 구현하기에는 다루기 힘들어집니다. 적이 공격하는 척 페인트를 쓰거나 플레이어의 방어에 따라 콤보를 조정하는 등의 미묘한 차이를 추가하려면 상태와 전이의 수가 폭발적으로 늘어나야 합니다.
더 유연한 접근 방식은 신경망을 행동 정책(behavioral policy)으로 사용하는 것입니다. 네트워크는 현재 게임 상태(플레이어와의 거리, 적의 체력, 쿨다운 상태)를 입력으로 받아 가능한 행동들에 대한 확률 분포를 출력합니다. 이 모델은 수동으로 코딩하기 어려운 미묘하고 상황에 따른 행동을 학습할 수 있습니다.
단순한 스파르타 전사 적 캐릭터를 예로 들어보겠습니다. "플레이어가 사거리 안에 있으면 공격한다"는 하드코딩된 규칙 대신, 더 풍부한 맥락을 바탕으로 일련의 행동 중에서 선택하도록 네트워크를 훈련할 수 있습니다. 아래는 PyTorch를 사용하여 이러한 정책 네트워크를 정의하는 간소화된 예시입니다.
import torch
import torch.nn as nn
import torch.nn.functional as F
class CombatPolicyNetwork(nn.Module):
"""전투 행동 선택을 위한 단순 정책 네트워크"""
def __init__(self, state_dim, action_dim):
super().__init__()
self.fc1 = nn.Linear(state_dim, 128)
self.fc2 = nn.Linear(128, 64)
self.action_head = nn.Linear(64, action_dim) # 각 행동에 대한 로짓(Logits)
self.value_head = nn.Linear(64, 1) # 선택 사항: 상태 가치 추정
def forward(self, state_tensor):
x = F.relu(self.fc1(state_tensor))
x = F.relu(self.fc2(x))
action_logits = self.action_head(x)
state_value = self.value_head(x)
return action_logits, state_value
# 예시 사용 및 행동 선택
state_dim = 10 # 예: [거리, 플레이어_체력, 적_체력, 스테미나, ...]
action_dim = 6 # 예: [약공격, 강공격, 방어, 회피, 도발, 특수기]
policy_net = CombatPolicyNetwork(state_dim, action_dim)
# 게임 상태 시뮬레이션
current_state = torch.randn(1, state_dim) # 실제로는 정규화된 값 사용
action_logits, _ = policy_net(current_state)
# 확률 분포에서 행동 샘플링
action_probs = F.softmax(action_logits, dim=-1)
action_dist = torch.distributions.Categorical(action_probs)
chosen_action = action_dist.sample() # 이 확률성은 예측 불가능함을 더해줍니다
print(f"선택된 행동 인덱스: {chosen_action.item()}")
핵심 장점은 확률적 샘플링(`action_dist.sample()`)에 있습니다. 이는 자연스러운 변화를 만들어냅니다. AI가 항상 수학적으로 "최선"인 행동만 고르는 것이 아니라, 인간의 망설임이나 스타일을 모방하게 됩니다. 이러한 네트워크를 훈련하려면 수동적 행동에는 벌을 주고 성공적인 타격에는 보상을 주는 정교한 보상 설계가 필요하며, 주로 강화 학습(RL)이 사용됩니다.
성능 및 통합 시 주의사항
매 프레임마다 추론(Inference)을 실행하는 것은 비용이 많이 듭니다. 여러 적의 상태 평가를 배치(Batch)로 처리하거나, 추론 빈도를 낮추고(예: 5프레임마다) 결과를 캐싱하는 것이 좋습니다. 실제 서비스용으로는 PyTorch 모델을 ONNX나 TorchScript로 변환하여 성능을 높이고 C++ 게임 엔진에 더 쉽게 통합할 수 있도록 하세요.
반응형 적을 위한 플레이어 의도 예측
갓 오브 워 전투의 특징 중 하나는 적들이 크레토스의 위치와 무기 선택에 어떻게 반응하는가입니다. 이를 분류 문제로 모델링할 수 있습니다. 즉, 최근 플레이어 상태 데이터가 주어졌을 때 플레이어가 다음에 무엇을 할 가능성이 높은가? 적이 적절한 타이밍에 회피하거나 방어하면 플레이어는 매우 반응성이 좋다고 느끼게 됩니다.
여기에는 지도 학습(Supervised learning)이 사용됩니다. 플레이테스트에서 수집하거나 기존 AI를 통해 시뮬레이션한 플레이어 행동 데이터셋이 필요합니다. 모델은 플레이어가 체력이 낮을 때 물러나거나 패링 성공 후 돌진하는 것과 같은 패턴을 학습합니다. 그러면 적은 선제적으로 방어 행동을 취할 수 있습니다.
다음은 최근 플레이어 상태 시퀀스를 모델링하고 다음 행동을 예측하기 위해 소형 순환 신경망(GRU)을 사용하는 간소화된 예시입니다.
import torch
from torch import nn
class PlayerIntentPredictor(nn.Module):
"""상태 프레임 시퀀스로부터 다음 플레이어 행동 예측"""
def __init__(self, input_features, hidden_size, num_player_actions):
super().__init__()
self.gru = nn.GRU(input_features, hidden_size, batch_first=True)
self.classifier = nn.Linear(hidden_size, num_player_actions)
def forward(self, state_sequence):
# state_sequence 형태: (batch_size, sequence_length, input_features)
gru_out, _ = self.gru(state_sequence)
# 마지막 타임 스텝의 출력 사용
last_step_out = gru_out[:, -1, :]
logits = self.classifier(last_step_out)
return logits
# 예시: 플레이어 데이터의 마지막 10프레임으로 예측
input_features = 7 # 예: [x_좌표, z_좌표, 속도, 무기_장착_여부, ...]
sequence_length = 10
hidden_size = 32
num_player_actions = 5 # 예: [공격, 방어, 구르기, 마법, 아이템]
predictor = PlayerIntentPredictor(input_features, hidden_size, num_player_actions)
# 1개 시퀀스(최근 10프레임) 배치 시뮬레이션
batch_state_seq = torch.randn(1, sequence_length, input_features)
prediction_logits = predictor(batch_state_seq)
predicted_action = torch.argmax(prediction_logits, dim=-1)
print(f"예측된 플레이어 행동 인덱스: {predicted_action.item()}")
# 적 AI는 이제 이를 활용하여 '공격'이 예측될 경우 선제적으로 방어할 수 있습니다.
진짜 과제는 지연 시간(Latency)입니다. 적이 반응 애니메이션을 시작할 수 있도록 충분히 일찍 예측해야 합니다. 이는 보통 200~300ms 앞을 예측해야 함을 의미합니다. 훈련 데이터는 현재 행동이 아니라, 몇 프레임 후에 플레이어가 실제로 취한 행동으로 라벨링되어야 합니다. 이 오프셋을 잘못 판단하면 적이 당신이 하려는 행동이 아니라 이미 한 행동에 반응하게 됩니다.
학습된 컨트롤러를 통한 절차적 애니메이션 블렌딩
완벽한 행동 선택이 이루어지더라도 움직임이 로봇처럼 보일 수 있습니다. 갓 오브 워의 캐릭터들은 무게감과 운동량을 가지고 움직입니다. 절차적 애니메이션(발 위치를 위한 역운동학 등)이 도움이 되지만, 애니메이션 사이를 부드럽게 블렌딩하는 것은 어렵습니다. 머신러닝은 통합된 컨트롤러를 만들 수 있습니다.
Phase-Functioned Neural Networks와 같은 연구는 네트워크가 상태(캐릭터 속도, 방향, 지형)와 위상 변수로부터 직접 뼈대 회전값을 출력하여 이음새 없는 이동을 가능하게 하는 방법을 보여주었습니다. 전체 구현은 복잡하지만, 소형 네트워크를 사용하여 애니메이션 블렌드 가중치를 결정하는 더 간단한 개념을 살펴볼 수 있습니다.
하드코딩된 블렌드 트리 대신, 네트워크가 원하는 이동 벡터, 현재 애니메이션 위상, 캐릭터 상태를 분석하여 걷기, 달리기, 스트레이프(strafe) 애니메이션에 대한 최적의 가중치를 생성할 수 있습니다. 이를 통해 전투 대기 상태에서 질주로의 전환과 같이 상황에 더 적합하고 매끄러운 전이가 가능해집니다.
import torch
import torch.nn as nn
class AnimationBlendNetwork(nn.Module):
"""애니메이션 클립 세트에 대한 블렌드 가중치 결정"""
def __init__(self, state_dim, num_clips):
super().__init__()
self.net = nn.Sequential(
nn.Linear(state_dim, 64),
nn.ReLU(),
nn.Linear(64, 32),
nn.ReLU(),
nn.Linear(32, num_clips),
nn.Softmax(dim=-1) # 합계가 1.0이 되는 가중치 출력
)
def forward(self, state):
return self.net(state)
# 상태 및 클립 정의
state_dim = 8 # [속도_x, 속도_z, 속력, 전투_중_여부, 스테미나, ...]
num_clips = 4 # [전투_대기, 전진_걷기, 좌_스트레이프, 우_스트레이프]
blend_net = AnimationBlendNetwork(state_dim, num_clips)
# 게임 루프 예시 (개념적)
def update_animation_blend(current_state_tensor):
blend_weights = blend_net(current_state_tensor)
# blend_weights는 [0.1, 0.7, 0.1, 0.1]과 같은 텐서입니다.
# 이 가중치를 애니메이션 시스템으로 보내 클립을 블렌딩합니다.
return blend_weights.detach().numpy() # PyTorch 외부 사용을 위해 분리
# 실제로는 상태를 전처리(정규화)하고, 팝핑 현상을 방지하기 위해
# 몇 프레임에 걸쳐 가중치 출력을 부드럽게 처리할 수 있습니다.
여기서 주요 성능 고려 사항은 이 네트워크가 모든 캐릭터에 대해 매 프레임 실행된다는 점입니다. 네트워크를 매우 작고 빠르게 유지하세요. 훈련 후 모델을 양자화(Quantize)하여 32비트 부동 소수점 대신 8비트 정수를 사용하도록 하세요. 이를 통해 품질 저하를 최소화하면서 추론 시간과 메모리 사용량을 약 75% 줄일 수 있으며, 이는 콘솔이나 모바일 타겟에서 매우 중요합니다.
강화 학습을 통한 난이도 밸런싱
고정된 난이도(쉬움, 보통, 어려움)는 투박한 도구입니다. 현대의 플레이어들은 게임이 속임수를 쓰는 느낌이 아니라 공정하게 느껴지는 동적 난이도 조절(DDA)을 기대합니다. 강화 학습을 통해 실시간으로 파라미터를 미세 조정하는 AI "매니저"를 훈련할 수 있습니다.
매니저의 목표는 승리가 아니라 플레이어의 몰입도를 극대화하는 것입니다. 매니저는 적의 공격성 쿨다운, 데미지 스케일링, 스폰율과 같은 레버를 제어합니다. 플레이어 상태에 따라 보상 신호를 받습니다. 플레이어가 너무 빨리 죽으면(너무 어려움) 작은 음의 보상을, 도전에 전혀 직면하지 않고 풀체력을 유지하면(너무 쉬움) 작은 음의 보상을, 그리고 플레이어의 체력이 중간 범위에서 오르내리는 "몰입(Flow)" 기간에는 양의 보상을 받습니다.
이 매니저를 훈련하려면 "플레이어 봇"이 있는 시뮬레이션 환경이 필요합니다. 실제 플레이어를 대상으로 훈련할 수는 없기 때문입니다. 코드 구조는 일반적인 RL 문제와 유사하지만, 액션 공간은 연속적입니다(수치 파라미터 조정).
# Stable-Baselines3를 사용한 난이도 매니저 개념 개요
import gym
from gym import spaces
import numpy as np
from stable_baselines3 import PPO
class DifficultyTuningEnv(gym.Env):
"""게임 난이도 조절을 위한 커스텀 환경"""
def __init__(self):
super().__init__()
# 액션: [데미지_배율, 적_체력_보너스, 스폰율]과 같은 파라미터 조정
self.action_space = spaces.Box(low=-1.0, high=1.0, shape=(3,), dtype=np.float32)
# 관찰: [플레이어_체력, 최근_1분간_사망_횟수, 교전_지속_시간, ...]
self.observation_space = spaces.Box(low=0.0, high=1.0, shape=(5,), dtype=np.float32)
# ... 내부 상태 초기화
def step(self, action):
# 1. 시뮬레이션에서 게임 파라미터에 액션 적용
# 2. 시뮬레이션된 게임/플레이어 봇 진행
# 3. 보상 계산
# 플레이어 체력이 0.3에서 0.7 사이일 때 높은 보상(몰입 중)
# 플레이어 사망 또는 풀체력의 지루함에 대해 음의 보상
# 4. 관찰값, 보상, 종료 여부, 정보 반환
# ... 구현 세부 사항
return observation, reward, done, {}
def reset(self):
# 시뮬레이션 상태 초기화
return observation
# 매니저 AI 훈련
env = DifficultyTuningEnv()
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=100000)
model.save("difficulty_manager")
# 저장된 모델은 게임 내에서 로드되어 파라미터 조정값을 출력할 수 있습니다.
가장 큰 함정은 "재미"와 일치하는 보상 함수를 설계하는 것입니다. 플레이어의 체력을 정확히 50%로 유지하는 것에 보상을 준다면, 매니저는 답답할 정도로 완벽하게 균형 잡힌 지루한 게임을 만들 수 있습니다. 보상은 변화와 회복의 순간을 장려해야 합니다. 훈련된 행동은 항상 인간 플레이테스터와 함께 검증하세요. RL 에이전트는 보상 정의의 허점을 어떻게든 찾아내어 악용할 것이기 때문입니다.
애니메이션 블렌드 네트워크나 단일 적의 도발/페인트 행동과 같이 중요도가 낮은 시스템에 작고 훈련된 ML 모델을 통합하는 것부터 시작해 보세요. 유연성 때문에 프로토타이핑에는 PyTorch를 사용하되, 유니티(Unity)나 언리얼(Unreal) 같은 엔진에서의 성능을 위해 ONNX로 내보낼 계획을 세우세요. 목표는 완전히 자율적인 AI가 아니라, ML을 강력한 도구로 활용하여 살아있는 것처럼 느껴지는 더 정교하고 반응적이며 놀라운 게임 메커니즘을 만드는 것입니다. 모델의 정확도가 아니라, 플레이테스터로부터 "패턴을 찾았다"는 말 대신 "저 적은 정말 영리하게 느껴진다"는 평가를 받는 것을 성공의 척도로 삼으십시오.
