2nd/10_Wiki/Topics/AI_and_ML/Combat Controls Update (Feb 2014).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

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

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)

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*)

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

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)

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

# 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