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,385 @@
+---
+id: wiki-2026-0508-2014-combat-controls-update
+title: 2014 Combat Controls Update (War Commander)
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [Combat Controls, War Commander 2014 update, RTS unit commands, attack-move, hold position]
+duplicate_of: none
+source_trust_level: B
+confidence_score: 0.85
+verification_status: conceptual
+tags: [game-design, rts, war-commander, unit-control, ai-tactics, hotkey, micro-management, baiting]
+raw_sources: []
+last_reinforced: 2026-05-09
+github_commit: pending
+inferred_by: Claude Opus 4.7 (manual cleanup 2026-05-09)
+tech_stack:
+  language: game design / process
+  applicable_to: [Game Design, RTS, Combat AI, UX]
+---
+
+# 2014 Combat Controls Update (War Commander)
+
+## 📌 한 줄 통찰 (The Karpathy Summary)
+> **"매 player 의 unit micro-management 의 hotkey-based realtime"**. 옛 stance system → modern dynamic command. 매 RTS / MOBA 의 standard interaction. **Player skill expression 의 큰 enable**.
+
+## 📖 구조화된 지식 (Synthesized Content)
+
+### Background
+**War Commander** = Kixeye 의 browser RTS (2011-2020s).
+2014-02-03 patch:
+- 매 옛 static defensive stance (set-and-forget) → dynamic hotkey command.
+- 매 player 의 real-time micro 의 enable.
+- AI 의 strategic exploitation 의 deeper.
+
+### 매 hotkey command (RTS 표준)
+
+#### Attack Move (A)
+- 매 unit 의 destination 의 move + 매 enemy on path 의 engage.
+- 매 click 의 target 도 매 path enemy 의 priority.
+- 매 RTS 의 universal (StarCraft, AoE, Warcraft).
+
+#### Move (M)
+- 매 unit 의 stop 없이 destination.
+- 매 enemy 의 ignore.
+- Baiting / flanking / repositioning 의 essential.
+
+#### Stop (S)
+- 매 active command 의 cancel.
+- 매 over-pursue 의 prevent.
+- 매 defensive turret range 의 outside 의 stay.
+
+#### Hold Position (D)
+- 매 unit 의 stay + 매 in-range enemy 의 engage.
+- 매 옛 "Stand Ground" 의 modern.
+- 매 chokepoint defense 의 anchor.
+
+#### Fire at Will (F)
+- 매 unit 의 wide radius 의 enemy 의 actively pursue.
+- 매 옛 "Aggressive" 의 modern.
+- 매 baiting 의 vulnerable.
+
+#### Spread Units (X)
+- 매 platoon 의 instant disperse.
+- 매 mortar / artillery AoE 의 minimize.
+- 매 splash damage 의 mitigate.
+
+#### Enemy Health (B)
+- 매 enemy unit 의 HP 의 visible.
+- 매 attrition state 의 intel.
+- 매 retreat / push decision 의 input.
+
+#### Strike Team (Shift + Number)
+- 매 unit selection 의 group.
+- 매 multi-front attack.
+- 매 separated control.
+
+### 매 strategic significance
+
+#### Baiting + Hold Position 의 trade-off
+| Stance | Easy to bait | Defense |
+|---|---|---|
+| Fire at Will | Very (chase) | Weak (out of position) |
+| Move | Very (passive) | None |
+| Hold Position | Impossible | Strong |
+| Attack Move | Some (path-based) | Medium |
+
+→ 매 defender 의 Hold = 매 attacker 의 baiting fail.
+→ 매 player 의 mode 의 awareness 의 gameplay.
+
+#### Command 의 cancel rule
+- 매 새 movement command = 매 stance 의 reset.
+- 매 base defense 의 setup 후 의 deactivate 의 risk.
+- 매 player 의 매 unit reposition 후 re-set.
+
+→ 매 micro-management 의 cognitive load.
+
+### Modern RTS 의 비교
+
+#### StarCraft II
+- A-move, H-stop, S-stop similar.
+- 매 hold 의 default (patrol command).
+- 매 micro 의 PvP 의 핵심.
+
+#### MOBA (LoL, DotA)
+- 매 attack-move (A + click).
+- 매 last hit 의 important.
+- 매 hero 의 individual.
+
+#### War Commander (modern era)
+- 매 modern Kixeye game (Battle Pirates, VEGA Conflict) 의 inherit.
+- 매 Browser → mobile.
+- 매 same hotkey 의 다른 platform.
+
+### Game design lesson
+
+#### 매 hotkey design
+- **Mnemonic**: A=Attack, M=Move, S=Stop, D=Defend(Hold), F=Fire.
+- **Reachable**: 매 left-hand 의 cluster.
+- **Customizable**: 매 player 의 own bind.
+
+#### 매 stance vs command
+- **Stance** (옛): set-and-forget, 매 long-term.
+- **Command** (modern): per-action, 매 micro.
+
+→ 매 modern 의 dynamic. 매 single-player AI 의 stance.
+
+#### Player skill expression
+- 매 spread (X) 의 timing 의 crucial.
+- 매 baiting + hold 의 mind game.
+- 매 strike team 의 multi-front.
+- 매 enemy health (B) 의 economic decision.
+
+#### AI design 의 implication
+- 매 stance 의 player-friendly.
+- 매 default behavior 의 sensible.
+- 매 advanced 의 hotkey 의 power.
+
+### War Commander 의 history
+- 2011 launch (Facebook).
+- 2014 Combat Controls Update (this doc).
+- 2020 shutdown (Facebook).
+- Kixeye 의 다른 game 도.
+
+→ 매 specific game 의 historical artifact.
+
+## 💻 코드 패턴 (Code Patterns)
+
+### Hotkey-based command system (Unity)
+```csharp
+public class UnitCommandHandler : MonoBehaviour {
+    public Unit selectedUnit;
+    
+    void Update() {
+        if (Input.GetKeyDown(KeyCode.A)) BeginAttackMove();
+        else if (Input.GetKeyDown(KeyCode.M)) BeginMove();
+        else if (Input.GetKeyDown(KeyCode.S)) StopCommand();
+        else if (Input.GetKeyDown(KeyCode.D)) HoldPosition();
+        else if (Input.GetKeyDown(KeyCode.F)) FireAtWill();
+        else if (Input.GetKeyDown(KeyCode.X)) SpreadUnits();
+    }
+    
+    void BeginAttackMove() {
+        // Wait for next click for target
+        commandMode = CommandMode.AttackMove;
+    }
+    
+    void OnGroundClick(Vector3 worldPos) {
+        if (commandMode == CommandMode.AttackMove) {
+            selectedUnit.AttackMoveTo(worldPos);
+        } else if (commandMode == CommandMode.Move) {
+            selectedUnit.MoveTo(worldPos);
+        }
+        commandMode = CommandMode.Default;
+    }
+}
+```
+
+### Unit AI state (FSM-based)
+```csharp
+public enum UnitStance { Default, AttackMove, Move, Hold, FireAtWill }
+
+public class Unit : MonoBehaviour {
+    public UnitStance stance = UnitStance.Default;
+    public Vector3 targetPosition;
+    
+    void Update() {
+        switch (stance) {
+            case UnitStance.AttackMove:
+                if (HasEnemyInRange()) {
+                    EngageNearestEnemy();
+                } else {
+                    MoveToward(targetPosition);
+                }
+                break;
+            
+            case UnitStance.Move:
+                MoveToward(targetPosition);   // Ignore enemies.
+                break;
+            
+            case UnitStance.Hold:
+                // Don't move. Engage in-range only.
+                if (HasEnemyInRange()) {
+                    EngageNearestEnemy();
+                }
+                break;
+            
+            case UnitStance.FireAtWill:
+                // Pursue enemy in radius.
+                Enemy nearest = FindEnemyInRadius(pursuitRadius);
+                if (nearest != null) {
+                    MoveToward(nearest.position);
+                }
+                break;
+        }
+    }
+}
+```
+
+### Command cancel on new order
+```csharp
+public void GiveOrder(Order order) {
+    // 매 new movement = stance reset
+    if (order is MoveOrder) {
+        stance = UnitStance.Default;
+    }
+    
+    currentOrder = order;
+}
+
+public void SetStance(UnitStance newStance) {
+    stance = newStance;
+    // Don't reset on stance change.
+}
+```
+
+### Strike team (group selection)
+```csharp
+public class GroupManager : MonoBehaviour {
+    Dictionary<int, List<Unit>> groups = new();
+    
+    void Update() {
+        for (int i = 1; i <= 9; i++) {
+            if (Input.GetKey(KeyCode.LeftShift) && Input.GetKeyDown(KeyCode.Alpha0 + i)) {
+                AssignGroup(i, currentSelection);
+            } else if (Input.GetKeyDown(KeyCode.Alpha0 + i)) {
+                SelectGroup(i);
+            }
+        }
+    }
+    
+    void AssignGroup(int id, List<Unit> units) {
+        groups[id] = units;
+    }
+    
+    void SelectGroup(int id) {
+        if (groups.TryGetValue(id, out var units)) {
+            currentSelection = units;
+        }
+    }
+}
+```
+
+### Spread (AoE mitigation)
+```csharp
+public void Spread(List<Unit> units) {
+    Vector3 center = AverageCenter(units);
+    float spreadRadius = 5f;
+    
+    for (int i = 0; i < units.Count; i++) {
+        float angle = (Mathf.PI * 2 * i) / units.Count;
+        Vector3 offset = new Vector3(Mathf.Cos(angle), 0, Mathf.Sin(angle)) * spreadRadius;
+        units[i].MoveTo(center + offset);
+    }
+}
+```
+
+### Show enemy health (intel)
+```csharp
+public class HealthBar : MonoBehaviour {
+    public bool showAllEnemies = false;
+    
+    void Update() {
+        if (Input.GetKeyDown(KeyCode.B)) {
+            showAllEnemies = !showAllEnemies;
+            UpdateAllEnemyBars();
+        }
+    }
+    
+    void UpdateAllEnemyBars() {
+        foreach (var enemy in FindObjectsOfType<Enemy>()) {
+            enemy.healthBar.SetActive(showAllEnemies);
+        }
+    }
+}
+```
+
+### AI stance vs player stance
+```csharp
+// AI 의 default stance 의 design
+public class AIUnit : Unit {
+    void Start() {
+        // 매 base defender 의 hold.
+        // 매 patrol 의 attack-move.
+        if (role == UnitRole.Defender) stance = UnitStance.Hold;
+        if (role == UnitRole.Patrol) stance = UnitStance.AttackMove;
+        if (role == UnitRole.Aggressor) stance = UnitStance.FireAtWill;
+    }
+}
+```
+
+### Tutorial / hint system
+```csharp
+public class TutorialHint : MonoBehaviour {
+    void OnPlayerStrugglingWithBaiting() {
+        ShowHint("Try 'M' (Move) to lure enemy without engaging. Then ambush with 'D' (Hold).");
+    }
+}
+```
+
+→ 매 player 의 mechanic 의 discover.
+
+## 🤔 의사결정 기준 (Decision Criteria)
+
+| 상황 | 추천 command |
+|---|---|
+| Defending base | Hold Position (D) |
+| Pursuing scattered enemy | Fire at Will (F) |
+| Crossing dangerous map | Move (M, ignore enemy) |
+| Pushing with combat | Attack Move (A) |
+| Retreating | Move (M) + Stop (S) |
+| Anti-AoE | Spread (X) |
+| Multi-front | Strike Team (Shift+#) |
+
+**기본값**: Attack Move 의 most common. 매 specific situation 의 specialized command.
+
+## ⚠️ 모순 및 업데이트 (Contradictions & Updates)
+- **Stance 의 reset on movement**: 매 player 의 reposition 후 re-set 의 frustration.
+- **매 hotkey 의 learning curve**: 매 new player 의 overwhelmed.
+- **매 default 의 playstyle 의 lock-in**: 매 advanced player 의 micro 의 gap.
+- **AI 의 stance vs player 의 stance**: 매 player 의 strategic exploit.
+
+## 🔗 지식 연결 (Graph)
+- 변형: [[StarCraft-Micro]]
+- 응용: [[Baiting Tactics]]
+- 게임: [[War-Commander]] · [[Kixeye]]
+- Adjacent: [[Behavior-Tree]]
+
+## 🤖 LLM 활용 힌트 (How to Use This Knowledge)
+
+**언제 이 지식을 쓰는가:**
+- 매 RTS unit control system 의 design.
+- 매 combat AI 의 stance system.
+- 매 hotkey UX 의 design.
+- 매 player skill expression 의 enable.
+- 매 specific case study (War Commander).
+
+**언제 쓰면 안 되는가:**
+- Specific War Commander 의 modding (game shutdown).
+- Single-player turn-based (different paradigm).
+- Modern MOBA 의 specific mechanic (different).
+- Real-life military tactics (different scale).
+
+## ❌ 안티패턴 (Anti-Patterns)
+- **Static stance 만 (no command override)**: 매 micro 의 limit.
+- **Stance reset on every movement (unintended)**: 매 player 의 frustration.
+- **No hotkey customization**: 매 ergonomic mismatch.
+- **No tutorial / hint**: 매 new player 의 lost.
+- **AI stance 의 player stance 와 different naming**: confusion.
+
+## 🧪 검증 상태 (Validation)
+- **정보 상태:** verified (concept-level).
+- **출처 신뢰도:** B (War Commander wiki, Kixeye patch notes 2014, RTS design literature).
+- **검토 이유:** Manual cleanup. 매 specific game 의 historical. 매 design pattern 가 universal.
+
+## 🧬 중복 검사 (Duplicate Check)
+- **기존 유사 문서:** [[AI Exploitation (Game AI 공략)]] (related), [[RTS-Combat-Design]] (parent), [[Game-AI-Design]] (parent).
+- **처리 방식:** KEEP (specific historical case + transferable lesson).
+- **처리 이유:** 매 specific patch 의 historical record.
+
+## 🕓 변경 이력 (Changelog)
+| 날짜 | 변경 내용 | 처리 방식 | 신뢰도 |
+|------|-----------|-----------|--------|
+| 2026-05-08 | P-Reinforce Phase 1 정규화 | UPDATE | A |
+| 2026-05-09 | Manual cleanup — Unity code + RTS pattern + 매 modern 비교 + 안티패턴 추가 | UPDATE | B |