2nd/10_Wiki/Topics/Game_Design/Player-Experience-Modeling.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-player-experience-modeling	Player Experience Modeling	10_Wiki/Topics	verified	self	PXM Player Modeling Affective Game Design Experience Metrics	none	A	0.9	applied	game-research player-modeling ux telemetry affective-computing		2026-05-10	pending	language framework design-pattern ML-game-analytics

Player Experience Modeling

매 한 줄

"매 Player Experience Modeling은 매 quantitative + qualitative methods 로 매 player 의 매 internal state (engagement, frustration, flow) 의 매 model". 매 Yannakakis-Togelius "PCG via PXM" + 매 industry telemetry pipelines 의 매 union — 매 dynamic difficulty, 매 churn prediction, 매 recommendation 의 매 underpinning.

매 핵심

매 Dimensions of Experience

• Engagement: 매 session length, 매 click rate, 매 retention.
• Flow (Csikszentmihalyi): 매 challenge ↔ skill balance.
• Frustration: 매 fail-rate spikes, 매 rage-quit signals.
• Curiosity: 매 exploration breadth, 매 novel-action rate.
• Affect: 매 facial / biosignal (eye-tracking, GSR) — 매 lab-only.

매 Modeling Approaches

1. Behavioral telemetry: 매 in-game actions → 매 supervised classifier (boredom/flow/anxiety).
2. Self-report: 매 PENS / GEQ questionnaires.
3. Physiological: 매 GSR, EEG, eye-tracking.
4. Multimodal fusion: 매 매 above 의 매 ensemble.

매 응용

1. EA / Riot 의 churn prediction.
2. Niantic / Pokémon GO 의 매 difficulty pacing.
3. 매 PCG (procedural content gen) 의 매 player-driven adaptation.

💻 패턴

Flow-channel modeling (challenge vs skill)

import numpy as np

class FlowEstimator:
    def __init__(self):
        self.skill_history = []
        self.challenge_history = []

    def update(self, level_difficulty: float, success: bool, time_taken: float):
        # Skill: rolling estimate of player ability
        if success:
            self.skill_history.append(level_difficulty + (1.0 / (1 + time_taken)))
        else:
            self.skill_history.append(level_difficulty - 0.5)
        self.challenge_history.append(level_difficulty)

    def in_flow(self) -> bool:
        # Flow when |challenge - skill| < threshold
        skill = np.mean(self.skill_history[-10:])
        challenge = np.mean(self.challenge_history[-10:])
        return abs(challenge - skill) < 0.2

Behavioral telemetry pipeline

interface PlayerEvent {
  userId: string;
  ts: number;
  type: 'click' | 'move' | 'fail' | 'success' | 'pause' | 'quit';
  meta: any;
}

class TelemetryAggregator {
  windows: Map<string, PlayerEvent[]> = new Map();

  ingest(evt: PlayerEvent) {
    const arr = this.windows.get(evt.userId) ?? [];
    arr.push(evt);
    // 5-minute rolling window
    const cutoff = evt.ts - 300_000;
    this.windows.set(evt.userId, arr.filter(e => e.ts > cutoff));
  }

  features(userId: string) {
    const arr = this.windows.get(userId) ?? [];
    return {
      eventRate: arr.length / 300,
      failRate: arr.filter(e => e.type === 'fail').length / Math.max(1, arr.length),
      pauseCount: arr.filter(e => e.type === 'pause').length,
      sessionLen: arr.length > 0 ? arr[arr.length - 1].ts - arr[0].ts : 0
    };
  }
}

Frustration classifier (gradient-boosted)

import lightgbm as lgb
import pandas as pd

# Features = aggregated telemetry; label = self-reported frustration (0/1)
df = load_labeled_sessions()
X = df[['fail_rate', 'retry_count', 'pause_avg_dur', 'click_intensity', 'time_on_failure']]
y = df['frustrated_label']

model = lgb.LGBMClassifier(n_estimators=200, max_depth=6)
model.fit(X, y)

# Inference — surface DDA intervention if predicted frustration > 0.7
def maybe_intervene(features):
    p = model.predict_proba([features])[0][1]
    return 'OFFER_HINT' if p > 0.7 else None

Dynamic Difficulty Adjustment (DDA)

// Use PXM signals to adjust next-level difficulty
function pickNextDifficulty(skill: number, frustration: number, boredom: number): number {
  let target = skill;
  if (frustration > 0.7) target -= 0.3; // ease up
  if (boredom > 0.7)     target += 0.3; // spice up
  return Math.max(0.1, Math.min(1.0, target));
}

Churn prediction (LSTM on session sequences)

import torch.nn as nn

class ChurnLSTM(nn.Module):
    def __init__(self, n_features=20, hidden=64):
        super().__init__()
        self.lstm = nn.LSTM(n_features, hidden, batch_first=True)
        self.fc = nn.Linear(hidden, 1)

    def forward(self, x):
        # x: (batch, seq_len_sessions, n_features)
        h, _ = self.lstm(x)
        return torch.sigmoid(self.fc(h[:, -1, :]))

# Predict probability user will quit within 7 days

GEQ (Game Experience Questionnaire) score aggregator

# In-game post-session survey -> 7 PXM dimensions
GEQ_DIMENSIONS = [
    'competence', 'sensory_immersion', 'flow', 'tension',
    'challenge', 'negative_affect', 'positive_affect'
]

def score_geq(responses: dict[str, int]) -> dict[str, float]:
    # Each dimension is the average of its constituent items (5-point Likert)
    scores = {}
    for dim in GEQ_DIMENSIONS:
        items = GEQ_ITEMS[dim]
        scores[dim] = sum(responses[i] for i in items) / len(items)
    return scores

Multimodal fusion (telemetry + GSR)

# Concatenate behavioral + biosignal features for inference
def fused_inference(behavioral_feats, gsr_signal):
    behavior_emb = behavior_model(behavioral_feats)
    physio_emb = gsr_cnn(gsr_signal)
    fused = torch.cat([behavior_emb, physio_emb], dim=-1)
    return fusion_classifier(fused)  # outputs (engagement, flow, frustration)

매 결정 기준

상황	Approach
Mobile game live-ops	매 telemetry-only PXM (매 GSR 의 매 unavailable)
Lab UX research	매 multimodal (telemetry + GSR + eye-track)
DDA implementation	매 frustration/boredom classifier + 매 difficulty PID
Churn prediction	매 LSTM on session sequences

기본값: 매 telemetry-feature pipeline + 매 GBDT classifier + 매 GEQ post-session survey — 매 industry-grade PXM stack.

🔗 Graph

• 부모: Gamification-Theory · Procedural Rhetoric (In Gaming)
• 변형: Algorithmic Rhetoric · Data-Driven Personalization
• 응용: Roguelike Procedural Generation · Live Operations (LiveOps)
• Adjacent: McKinsey Problem Solving Test (PST) · Magic-Circle · 사용자 참여도(Player Engagement)

🤖 LLM 활용

언제: 매 game-analytics pipeline design, 매 DDA modeling, 매 churn-prediction architecture, 매 PXM research method selection. 언제 X: 매 narrative-only/no-telemetry game (매 PXM modeling 의 매 over-engineering).

❌ 안티패턴

• Self-report only: 매 매 small-N + 매 social-desirability bias.
• Behavioral-only without ground truth: 매 매 classifier 의 매 unverifiable label drift.
• One-shot DDA: 매 매 single signal 의 매 overreact — 매 rolling window 의 매 use.

🧪 검증 / 중복

• Verified (Yannakakis & Togelius "Artificial Intelligence and Games" 2018, GEQ IJsselsteijn 2013, Riot Games churn-prediction tech blog 2022).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — PXM dimensions + telemetry/DDA/churn ML patterns