2nd/10_Wiki/Topics/AI_and_ML/Boss-Orchestration-and-Gimmick-Management.md

---
id: wiki-2026-0508-boss-orchestration-gimmick
title: Boss Orchestration & Gimmick Management
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [boss design, multi-phase boss, gimmick, telegraphing, attack pattern, boss AI]
duplicate_of: none
source_trust_level: B
confidence_score: 0.85
verification_status: applied
tags: [game-design, boss, gimmick, telegraphing, behavior-tree, pattern, multi-phase, npc-ai]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: TypeScript
  framework: Game engine (custom / Unity / Godot)
---

# Boss Orchestration & Gimmick Management

## 📌 한 줄 통찰
> **"매 boss = 매 HP 의 X — 매 sequence + gimmick"**. 매 multi-part + multi-phase + telegraph + recovery window 의 fight feel. 매 player 의 skill expression 의 platform. 매 modern game 의 highlight moment.

## 📖 핵심

### 매 multi-part architecture
- 매 boss = 매 N 개 part (head, arm, core).
- 매 part 별 HP + defense.
- 매 dependency tree (shield → core).
- 매 visual state (texture swap + effect).
- 매 collision per part.

### 매 phase
- 매 HP threshold (75%, 50%, 25%).
- 매 enrage timer.
- 매 environmental change.
- 매 new attack 추가.
- 매 음악 transition.

### 매 gimmick
1. **Phase-triggered**: 매 HP 의 따라.
2. **Environmental hazard**: 매 laser, 매 falling debris.
3. **Adds (summon)**: 매 minion 의 추가 spawn.
4. **Mechanic check**: 매 player 의 specific mechanic 의 force.
5. **Enrage**: 매 timer 후 의 instant kill.

### 매 ExecutePattern() 의 step
1. **Selection**: 매 weighted random / state-based.
2. **Telegraph**: 1-2 sec 의 warning (visual + audio).
3. **Execution**: 매 attack 의 spawn.
4. **Recovery**: 매 stun / idle (player 의 DPS window).

### 매 telegraphing 의 design
- **Visual**: 매 charging glow, 매 ground marker, 매 windup animation.
- **Audio**: 매 distinct sound cue.
- **Duration**: 매 difficulty 의 따라 (0.5-2 sec).
- **Read time**: 매 player 의 react 의 가능.

### 매 attack pattern type
- **Aimed**: 매 player 의 location.
- **Pattern**: 매 fixed (memorize).
- **Random spread**: 매 reaction.
- **Predictive**: 매 player 의 movement 의 lead.
- **AOE**: 매 area.
- **Beam**: 매 sweeping.

### 매 boss 의 fairness
- **Telegraph 의 always**: 매 unavoidable X.
- **Attack 의 escapable**: 매 dodge / block 가능.
- **Pattern 의 readable**: 매 learn-able.
- **Heal 의 limited**: 매 frustration X.
- **Phase 의 progressive**: 매 escalation.

### 매 modern reference
- **Souls / Elden Ring**: 매 telegraph + recovery + animation cancel.
- **Monster Hunter**: 매 part destruction.
- **Devil May Cry**: 매 stylish + multi-phase.
- **Touhou**: 매 bullet pattern.
- **Final Fantasy 14**: 매 mechanic check.

### 매 difficulty scaling
- **HP**: 매 simple 가 매 boring 가능.
- **Damage**: 매 punish ↑.
- **Phase 의 add**: 매 best.
- **Telegraph 의 shorten**: 매 frustrating 위험.
- **Adds 의 추가**: 매 best.

## 💻 패턴

### Multi-part boss (TypeScript)
```ts
class BossPart {
  hp: number;
  maxHp: number;
  defense: number;
  destroyed = false;
  
  takeDamage(amount: number, parent: Boss) {
    if (this.destroyed) return;
    const dealt = Math.max(1, amount - this.defense);
    this.hp -= dealt;
    if (this.hp <= 0) {
      this.destroyed = true;
      parent.onPartDestroyed(this);
    }
  }
}

class Boss {
  parts: Map<string, BossPart> = new Map();
  
  onPartDestroyed(part: BossPart) {
    this.spawnDestructionEffect(part.position);
    if (part.id === 'shield') {
      this.parts.get('core')!.invulnerable = false;
    }
    this.checkPhaseTransition();
  }
}
```

### Phase machine
```ts
class BossPhaseManager {
  phases = [
    { threshold: 1.0, name: 'phase1', patterns: ['attack_a', 'attack_b'] },
    { threshold: 0.66, name: 'phase2', patterns: ['attack_a', 'attack_b', 'attack_c', 'gimmick_1'] },
    { threshold: 0.33, name: 'phase3', patterns: ['attack_b', 'attack_c', 'gimmick_2', 'enrage'] },
  ];
  
  current = this.phases[0];
  
  update(boss: Boss) {
    const hpRatio = boss.hp / boss.maxHp;
    const next = this.phases.find(p => hpRatio < p.threshold && p !== this.current);
    if (next) this.transitionTo(next, boss);
  }
  
  transitionTo(next: Phase, boss: Boss) {
    boss.playAnimation('phase_transition');
    boss.invulnerable = true;
    this.spawnEnvironmentalChange();
    setTimeout(() => {
      boss.invulnerable = false;
      this.current = next;
    }, 2000);
  }
}
```

### Pattern selection (weighted)
```ts
class BossAIService {
  private recentPatterns: string[] = [];
  
  selectPattern(boss: Boss, player: Player): string {
    const available = boss.currentPhase.patterns;
    
    const weights = available.map(p => {
      let w = 1.0;
      // 매 distance-based
      const dist = boss.distance(player);
      if (p === 'melee_slam' && dist > 5) w *= 0.1;
      if (p === 'ranged_volley' && dist < 3) w *= 0.3;
      // 매 anti-repetition
      if (this.recentPatterns.slice(-2).includes(p)) w *= 0.3;
      // 매 cooldown
      if (boss.patternCooldown(p) > 0) w = 0;
      return w;
    });
    
    const chosen = weightedRandom(available, weights);
    this.recentPatterns.push(chosen);
    if (this.recentPatterns.length > 5) this.recentPatterns.shift();
    return chosen;
  }
}
```

### Telegraph (warning system)
```ts
async function executePattern(boss: Boss, pattern: AttackPattern, player: Player) {
  // 1. Telegraph
  const telegraph = pattern.getTelegraph(boss, player);
  showVisual(telegraph.visual);
  playAudio(telegraph.audio);
  
  // 2. Wait (player 의 react time)
  await sleep(pattern.telegraphDuration);
  
  // 3. Execute
  boss.playAnimation(pattern.animation);
  await sleep(pattern.windupDuration);
  pattern.spawn(boss, player);
  
  // 4. Recovery (DPS window)
  boss.state = 'recovering';
  await sleep(pattern.recoveryDuration);
  boss.state = 'active';
}
```

### Environmental hazard
```ts
class LaserGridGimmick {
  intervalMs = 3000;
  laserColumns = 8;
  
  start(scene: Scene) {
    this.handle = setInterval(() => {
      const cols = Array.from({ length: this.laserColumns }, (_, i) => i);
      const safeIdx = Math.floor(Math.random() * cols.length);
      
      // 매 telegraph 1 sec
      cols.forEach(c => {
        if (c !== safeIdx) showWarning(scene, c);
      });
      
      setTimeout(() => {
        cols.forEach(c => {
          if (c !== safeIdx) fireLaser(scene, c);
        });
      }, 1000);
    }, this.intervalMs);
  }
  
  stop() { clearInterval(this.handle); }
}
```

### Enrage timer
```ts
class EnrageTimer {
  remaining = 300_000;  // 5 min
  
  update(dt: number, boss: Boss) {
    this.remaining -= dt;
    if (this.remaining <= 0 && boss.phase !== 'enrage') {
      boss.transitionTo('enrage');
      boss.damageMultiplier = 3.0;
      showMessage('ENRAGED');
    }
    if (this.remaining < 30_000) {
      // 매 30 sec 의 warning
      showCountdown(Math.ceil(this.remaining / 1000));
    }
  }
}
```

### Add summon
```ts
class AddSummonGimmick {
  hpThreshold = 0.5;
  triggered = false;
  
  update(boss: Boss) {
    if (boss.hp / boss.maxHp < this.hpThreshold && !this.triggered) {
      this.triggered = true;
      boss.invulnerable = true;
      
      // 매 N 의 minion spawn
      for (let i = 0; i < 4; i++) {
        spawnMinion(boss.position.add(randomOffset(10)));
      }
      
      // 매 모든 minion 의 dead 까지 invulnerable
      setInterval(() => {
        if (countAliveMinion() === 0) boss.invulnerable = false;
      }, 1000);
    }
  }
}
```

## 🤔 결정 기준
| 상황 | Approach |
|---|---|
| Action / Souls-like | Multi-part + telegraph + recovery |
| Bullet hell | Pattern memorize + spread |
| MMO raid | Mechanic check + DPS window |
| Mobile | Simple gimmick + readable |
| Speedrun-friendly | Predictable pattern |
| Casual | Low damage + clear telegraph |

**기본값**: 매 multi-phase + 매 telegraph + 매 recovery + 매 fairness.

## 🔗 Graph
- 부모: [[Game-Design]]
- 변형: [[Multi-Phase-Boss]] · [[Bullet-Hell]]
- Adjacent: [[Behavior-Tree]] · [[Baiting]]

## 🤖 LLM 활용
**언제**: 매 boss design. 매 encounter scripting. 매 multi-phase logic. 매 NPC AI service.
**언제 X**: 매 simple enemy (overkill). 매 narrative-only.

## ❌ 안티패턴
- **No telegraph**: 매 unfair.
- **HP sponge**: 매 boring.
- **Repeat same pattern**: 매 predictable.
- **No recovery window**: 매 player DPS X.
- **No phase change**: 매 monotonous.
- **Random unavoidable hit**: 매 frustration.
- **Enrage too short**: 매 panic.

## 🧪 검증 / 중복
- Verified (Souls / FF14 / MH design analysis).
- 신뢰도 B.
- Related: [[Combat-AI]] · [[Behavior-Tree]] · [[Pursuit-Logic]] · [[Baiting]].

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — multi-part + phase + telegraph + 매 TS code (BossPart, AI service, gimmick) |