---
id: wiki-2026-0508-combat-controls-update-feb-2014
title: Combat Controls Update (War Commander, Feb 2014)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [combat controls, hotkey commands, attack-move, hold-position, fire-at-will, micro-management]
duplicate_of: none
source_trust_level: B
confidence_score: 0.85
verification_status: applied
tags: [game-design, rts, war-commander, hotkey, micro-management, npc-ai, balance-patch]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: game design
  applicable_to: [RTS Design, Hotkey Pattern, NPC Stance Design]
---

# Combat Controls Update (Feb 2014)

## 매 한 줄
> **"매 static stance → 매 dynamic command"**. 매 RTS 의 hotkey-driven micro-management. 매 attack-move (A), move (M), stop (S), hold (D), fire-at-will (F), spread (X). 매 modern RTS pattern 의 reference. 매 [[Baiting]] 의 stance 의 base.

## 매 핵심

### 매 6 primary command
| Key | Command | Purpose |
|---|---|---|
| A | Attack-move | 매 fire while moving |
| M | Move | 매 no fire, fast position |
| S | Stop | 매 cancel orders |
| D | Hold Position | 매 fire only in range, stay |
| F | Fire-at-Will | 매 wide aggressive chase |
| X | Spread Units | 매 anti-AoE |

### 매 secondary
- **B**: Enemy Health (toggle).
- **Shift + 0-9**: Group assign.
- **Ctrl + 0-9**: Group select.

### 매 vs 매 old static stance
| Old | New |
|---|---|
| Stand Ground | Hold Position (D) |
| Aggressive | Fire-at-Will (F) |
| Normal (default) | (no key — default) |

→ 매 new 의 movement 시 의 reset.

### 매 design principle
1. **Single-key access**: 매 muscle memory.
2. **Verb-based**: 매 action 의 explicit.
3. **Toggle clarity**: 매 mode 의 visible.
4. **Group control**: 매 large army.
5. **Tactical depth**: 매 baiting / kiting / focus fire.

### 매 modern RTS lineage
- **StarCraft / SC2**: 매 deep micro.
- **Company of Heroes**: 매 squad orders.
- **Total Annihilation**: 매 rich command.
- **Age of Empires**: 매 simpler.

### 매 tactical use case

#### Push (A)
- 매 attack-move 의 advance.
- 매 enemy 의 encounter 의 stop + fire.

#### Reposition (M)
- 매 turret range 의 escape.
- 매 baiting unit 의 lure.

#### Defense (D)
- 매 chokepoint 의 hold.
- 매 anti-bait.

#### Cleanup (F)
- 매 wide patrol.
- 매 mop-up.

#### Anti-AoE (X)
- 매 mortar / heavy 의 incoming.
- 매 disperse.

### 매 design lesson (modern game)
1. **Hotkey 의 grouping**: 매 left hand 의 reach.
2. **Action 의 reversibility** (S 의 cancel).
3. **Stance 의 explicit visualization**.
4. **Default 의 sensible** (Normal).
5. **Group 의 multi-front 의 enable**.

## 💻 패턴 (응용 — RTS command system)

### Command system
```ts
enum CommandType {
  ATTACK_MOVE = 'A',
  MOVE = 'M',
  STOP = 'S',
  HOLD_POSITION = 'D',
  FIRE_AT_WILL = 'F',
}

class Unit {
  command: CommandType = CommandType.NORMAL;
  target: Vec3 | null = null;
  
  setCommand(cmd: CommandType, target?: Vec3) {
    this.command = cmd;
    this.target = target ?? null;
  }
  
  update() {
    switch (this.command) {
      case CommandType.ATTACK_MOVE:
        // 매 move + 매 enemy in range 의 fire
        const enemy = this.findEnemyInRange();
        if (enemy) this.fire(enemy);
        else this.moveTowards(this.target);
        break;
      
      case CommandType.MOVE:
        this.moveTowards(this.target);  // 매 no fire
        break;
      
      case CommandType.HOLD_POSITION:
        // 매 stay + fire 매 in range
        const target = this.findEnemyInRange();
        if (target) this.fire(target);
        break;
      
      case CommandType.FIRE_AT_WILL:
        // 매 wider range, chase
        const remote = this.findEnemyInRange(this.range * 1.5);
        if (remote) {
          this.chase(remote);
          this.fire(remote);
        }
        break;
      
      case CommandType.STOP:
        // 매 cleared
        break;
    }
  }
}
```

### Group control (Shift + N)
```ts
class GroupManager {
  groups: Map<number, Set<Unit>> = new Map();
  
  assign(num: number, units: Unit[]) {
    this.groups.set(num, new Set(units));
  }
  
  select(num: number): Unit[] {
    return [...(this.groups.get(num) ?? [])];
  }
}

// 매 keyboard handler
function onKeydown(e: KeyboardEvent, selected: Unit[]) {
  if (e.shiftKey && /^\d$/.test(e.key)) {
    groupManager.assign(+e.key, selected);
  } else if (/^\d$/.test(e.key)) {
    selectAll(groupManager.select(+e.key));
  }
}
```

### Attack-move pathing (A*)
```python
def attack_move_path(unit, target, world):
    """매 path along + 매 fire 의 enemy."""
    path = a_star(unit.position, target, world.grid)
    
    while unit.position != target:
        # 매 매 step 의 fire check
        enemies_in_range = world.enemies_within(unit.position, unit.range)
        if enemies_in_range:
            unit.stop_movement()
            unit.fire(closest(enemies_in_range))
            if not enemies_in_range_after_fire():
                unit.resume_path(path)
        else:
            unit.step(path)
```

### Stance 의 visual indicator
```tsx
function UnitIndicator({ unit }) {
  const stanceColor = {
    'attack_move': 'red',
    'move': 'blue',
    'hold': 'orange',
    'fire_at_will': 'purple',
    'normal': 'white',
  }[unit.command];
  
  return (
    <div style={{ borderColor: stanceColor }}>
      <span>{unit.command}</span>
    </div>
  );
}
```

### Spread formation (X key)
```python
def spread_units(units, center, min_distance=3):
    """매 AoE 의 minimize."""
    new_positions = []
    for unit in units:
        # 매 lloyd's algorithm-like
        for _ in range(10):
            random_offset = Vec3.random() * (min_distance * 2)
            candidate = center + random_offset
            if all(candidate.distance(p) >= min_distance for p in new_positions):
                new_positions.append(candidate)
                break
        else:
            # 매 fallback
            new_positions.append(center + Vec3.random() * min_distance * 3)
    
    for unit, pos in zip(units, new_positions):
        unit.setCommand(CommandType.MOVE, pos)
```

### Hotkey config
```yaml
# game-config.yml
hotkeys:
  move: 'M'
  attack_move: 'A'
  stop: 'S'
  hold_position: 'D'
  fire_at_will: 'F'
  spread: 'X'
  enemy_health_toggle: 'B'
  group_assign: 'Shift+0-9'
  group_select: '0-9'

discoverability:
  show_hint_on_first_play: true
  context_menu_items: 'all 6 command'
```

## 🤔 결정 기준
| 상황 | Command |
|---|---|
| Push 전선 | A (attack-move) |
| Reposition / bait | M (move) |
| Defense chokepoint | D (hold) |
| Patrol / mop-up | F (fire-at-will) |
| AoE incoming | X (spread) |
| Cancel / reset | S (stop) |
| Multi-front | Group + Shift+N |

**기본값**: 매 single-key + visible stance + default Normal.

## 🔗 Graph
- 부모: [[Game-Design]]
- 변형: [[Behavior-Tree]]
- 응용: [[Baiting]] · [[Pursuit-Logic]] · [[War-Commander]]
- Adjacent: [[Boss-Orchestration-and-Gimmick-Management]] · [[Cognitive-Evaluation-Theory]] (mastery)

## 🤖 LLM 활용
**언제**: 매 RTS design. 매 hotkey UX. 매 unit AI stance.
**언제 X**: 매 turn-based (다른 paradigm).

## ❌ 안티패턴
- **No hotkey**: 매 mouse 의 only — 매 slow.
- **Hotkey 의 right hand**: 매 mouse 의 conflict.
- **Stance 의 invisible**: 매 confusion.
- **Default 의 wrong**: 매 player 의 X-by-default.
- **No group**: 매 large army 의 micro X.

## 🧪 검증 / 중복
- Verified (War Commander patch notes Feb 2014, RTS design literature).
- 신뢰도 B.
- Related: [[Baiting]] · [[Combat-AI]] · [[Boss-Orchestration-and-Gimmick-Management]] · [[Game-Design]].

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-04-27 | Auto-mapped |
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 6 command + 매 attack-move pathing + group + spread code |