refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게 [공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류. 문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인). - Topic_Programming → Domain_Programming (내부 구조 보존) - Topic_Graphic → Domain_Design - Topic_Business → Domain_Product - Topic_General → Domain_General - _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning), Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing) - 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서) - 빈 폴더 정리 (memory/procedures) - 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -0,0 +1,212 @@
+---
+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 |