---
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]] (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 |
