---
id: wiki-2026-0508-player-experience-modeling
title: Player Experience Modeling
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [PXM, Player Modeling, Affective Game Design, Experience Metrics]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-research, player-modeling, ux, telemetry, affective-computing]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: design-pattern
  framework: 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)
```python
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
```typescript
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)
```python
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)
```typescript
// 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)
```python
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
```python
# 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)
```python
# 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|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 |
