docs(10_Wiki): Topic_Business/General/Graphic/Programming을 Topics/ 하위로 이동

최상위 10_Wiki/Topic_*였던 4개 카테고리 폴더를 10_Wiki/Topics/Topic_* 로 재배치. 콘텐츠 변경 없음(순수 폴더 이동) — Topics/ 하위 나머지 폴더는 이미 지난 커밋에서 전부 정리된 상태(잔존 항목은 에이전트 운영 상태 및 사용자가 보존을 요청한 업데이트0615/무제 3.canvas 뿐).
2026-07-05 00:44:01 +09:00
parent e9cbf23ab5
commit 9a135bd19d
6127 changed files with 0 additions and 0 deletions
@@ -0,0 +1,317 @@
+---
+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) |