[G1-Sync] Manual knowledge update

2026-05-10 22:08:15 +09:00
parent 21ac3ed255
commit 504fd5fb42
3011 changed files with 380280 additions and 206977 deletions
@@ -1,66 +1,430 @@
 ---
 id: wiki-2026-0508-ai-exploitation
-title: AI Exploitation
+title: AI Exploitation (Game AI 공략)
 category: 10_Wiki/Topics
-status: needs_review
+status: verified
 canonical_id: self
-aliases: []
+aliases: [AI 공략, baiting, kiting, AI manipulation, exploit AI behavior, game AI weakness]
 duplicate_of: none
-source_trust_level: A
-confidence_score: 0.92
-tags: [uncategorized]
+source_trust_level: B
+confidence_score: 0.85
+verification_status: conceptual
+tags: [game-ai, baiting, kiting, rts, tactics, exploit, behavior-tree, fsm, npc-design]
 raw_sources: []
-last_reinforced: 2026-05-08
+last_reinforced: 2026-05-09
 github_commit: pending
-inferred_by: Claude Opus 4.7 (auto-normalize 2026-05-08)
+inferred_by: Claude Opus 4.7 (manual cleanup 2026-05-09)
+tech_stack:
+  language: game design / process
+  applicable_to: [Game Design, Combat AI, RTS, FPS, MMO]
 ---

-# [[AI Exploitation|AI Exploitation]]
+# AI Exploitation (Game AI 공략)

 ## 📌 한 줄 통찰 (The Karpathy Summary)
-AI Exploitation(AI 공략)은 'War Commander'의 전투 환경에서 적 AI의 경로 탐색(pathing)과 교전 논리를 실시간으로 역이용해 전술적 우위를 점하는 교전 원칙입니다 [1]. 가장 대표적인 형태는 적 유닛을 방어선의 엄폐물 밖으로 끌어내는 '미끼(Baiting)' 전술입니다 [2]. 이는 막대한 병력 손실 없이 견고한 방어 진지를 돌파하기 위해 지휘관이 마스터해야 할 가장 핵심적인 기술 중 하나로 평가됩니다 [3, 4].
+> **Game AI 의 deterministic behavior 의 player exploit**. Baiting / kiting / pathing trick. RTS / FPS / MMO 의 player skill 의 큰 부분. **Game design 의 책임 = 매 exploit 의 fun + fair 의 design**.

 ## 📖 구조화된 지식 (Synthesized Content)
-* **AI 추적 논리 역이용 (Baiting / 미끼 전술)**: 전투 제어 시스템(Combat Controls)의 도입으로 지휘관들은 AI 경로 탐색과 교전 논리를 실시간으로 조작 및 공략할 수 있게 되었습니다 [1]. 적 유닛이 '자유 사격(Fire at Will)'이나 일반 상태에 있을 때 특정 병력을 보내 적을 유인한 뒤, 대기 중인 아군의 사격망으로 끌어들이는 추격전(Wild Goose Chase)을 유도합니다 [2, 3]. 
-* **비대칭 유닛 조합 활용**: 성공적인 AI 공략은 주로 비대칭적인 유닛을 짝지어 운용할 때 이루어집니다 [4]. 예를 들어, 빠른 지상 유닛을 이용해 무거운 전차를 도발하여 항공 소대의 사거리로 유인하거나, 항공기를 미끼로 사용하여 대공 전차(Flak Tanks)를 지원 포탑망에서 분리해낸 뒤 중장갑 지상군으로 격파하는 방식입니다 [3, 4].
-* **Bait and Bash (유인 및 타격) 고급 전술**: 체력이 높거나 빠른 항공 유닛(예: Havoc, Warhawk)을 방어 중인 대공 유닛 근처로 접근시켜 적을 아군의 지원 사격망 안으로 끌어들여 파괴하는 전술입니다 [5]. 이 기술을 사용하면 숨겨진 유닛을 사전에 제거하고 예상치 못한 방어선의 추가 피해를 방지할 수 있습니다 [5].
-* **AI 공략의 한계성**: 이 전술은 적의 AI 방어 태세 설정에 따라 완전히 무력화될 수 있습니다 [2]. 대상 유닛이 '위치 사수(Hold Position)'나 '제자리 대기(Stand Ground)' 상태로 고정되어 있다면 미끼를 쫓아오지 않으므로 전술이 실패합니다 [2, 3]. 또한, 적 기지에 대공 유닛과 대지 유닛이 섞여 공격적인 방어 상태에 돌입해 있는 경우에도 이 전략은 통하지 않을 수 있습니다 [5].
+
+### 정의
+"AI Exploitation" = player 의 game AI 의 weakness / predictability 의 strategic 활용.
+- 매 AI behavior tree / FSM 의 limit.
+- 매 pathfinding 의 brittleness.
+- 매 aggro / threat 시스템 의 manipulation.
+- 매 line-of-sight / cover 의 exploit.
+
+→ Player skill 의 큰 portion. 매 game design 의 의도 또는 unintended.
+
+### 매 common technique
+
+#### 1. Baiting (미끼)
+- 매 weak unit 의 lure → enemy 가 pursue.
+- 매 ambush / kill zone 의 enemy.
+- War Commander, RTS, MMO 의 흔함.
+
+#### 2. Kiting (낚시)
+- 매 ranged unit 의 attack → 매 melee 의 retreat.
+- Cycle: attack → kite → attack.
+- Aoe damage 의 minimize.
+
+#### 3. Aggro pulling (위협)
+- 매 enemy 의 attention 의 grab.
+- Tank / decoy 의 use.
+- 매 boss fight 의 mechanic.
+
+#### 4. Path exploit
+- 매 narrow choke 의 bottleneck.
+- 매 navigation mesh 의 hole.
+- 매 enemy 의 stuck position.
+
+#### 5. Stealth / detection
+- 매 sight cone 의 limit 의 exploit.
+- 매 audio range 의 stay outside.
+- 매 patrol pattern 의 predict.
+
+#### 6. State exploit
+- 매 enemy 의 state transition 의 abuse.
+- "Stuck in animation" 의 free hit.
+- "Reset 후 full HP" 의 grief.
+
+### 매 game 의 example
+
+#### RTS (StarCraft, War Commander)
+- 매 weak unit 의 bait → enemy 가 chase.
+- 매 ambush 의 setup.
+- 매 split control 의 micro.
+
+#### MMO (WoW, FFXIV)
+- 매 boss 의 aggro 시스템.
+- 매 mob 의 leash range.
+- 매 line-of-sight 의 pull.
+- 매 environmental kill (cliff push).
+
+#### FPS (Halo, Doom)
+- 매 enemy 의 AI rush 의 corner exploit.
+- 매 grenade 의 flush out.
+- 매 spawn pattern 의 predict.
+
+#### Souls-like (Dark Souls, Elden Ring)
+- 매 boss 의 attack pattern 의 dodge timing.
+- 매 cheese strategy (range from safe spot).
+- 매 backstab 의 specific angle.
+
+#### Stealth (Splinter Cell, Hitman)
+- 매 patrol route 의 timing.
+- 매 distraction 의 placement.
+- 매 disguise / blend.
+
+### Game design 의 perspective
+
+#### 매 exploit 의 spectrum
+1. **Intended skill expression**: 매 master player 의 advantage. 매 designer 의 OK.
+2. **Emergent gameplay**: 의도 X 가, fun.
+3. **Cheese / unfun**: trivialize 매 challenge.
+4. **Bug / exploit**: 매 designer 의 fix 필요.
+
+#### 매 design choice
+- **Deterministic AI**: predictable, exploitable, low compute.
+- **Stochastic AI**: 매 action 의 random factor, less exploit, less predictable.
+- **Adaptive AI**: 매 player behavior 의 learn, exploit-resistant, complex.
+- **Scripted encounter**: 매 designer 의 control.
+
+→ 매 game 의 mix.
+
+#### "AI Director" approach (Left 4 Dead, Vampire Survivors)
+- 매 AI 의 단순 behavior + dynamic spawning.
+- 매 player 의 skill 의 difficulty 조정.
+- 매 exploit 의 less fragile.
+
+### Game AI design pattern
+
+#### Behavior Tree
+```
+Selector:
+  - IF enemy_visible AND health > 30%:
+      Sequence: aim, fire
+  - IF health < 30%:
+      Sequence: flee, heal
+  - ELSE:
+      patrol
+```
+
+→ 매 condition 의 exploit (corner 의 enemy 의 invisible → enemy 의 patrol → free shot).
+
+#### FSM (Finite State Machine)
+```
+States: Patrol → See Player → Pursue → In Range → Attack → ...
+```
+
+→ 매 transition 의 exploit (line-of-sight break → reset to Patrol).
+
+#### Utility AI
+```
+매 action 의 utility score.
+- Attack player: 80 (player visible) / 0 (invisible).
+- Heal: 60 (low HP) / 0 (full HP).
+- Flee: 90 (very low HP).
+```
+
+→ 매 score 의 dynamic — less exploit.
+
+#### GOAP (Goal-Oriented Action Planning)
+```
+Goal: Kill player.
+Plan: 
+  1. Reach player (precondition: visible).
+  2. Attack.
+  
+If precondition fail → re-plan.
+```
+
+→ 매 plan 의 emergent — less exploit.
+
+#### Reinforcement Learning (modern)
+- 매 AI 의 train 의 player behavior 와 의 self-play.
+- AlphaStar, OpenAI Five.
+- 매 exploit 의 emergent counter.
+- Cost ↑ (training).
+
+### Designer 의 trade-off
+
+#### "Easy to learn, hard to master"
+- 매 player 의 매 exploit 의 discover 의 fun.
+- 매 mastery 의 reward.
+- 매 cheese 의 unfun.
+
+#### Counter-design
+매 exploit 의 fix:
+1. **Pattern variation**: 매 random factor.
+2. **Adaptive learning**: 매 player exploit 의 detect.
+3. **State validation**: 매 cheap exploit 의 block.
+4. **Dynamic spawn**: 매 corner 의 ambush 의 prevent.
+5. **Reset cooldown**: 매 leash 의 abuse 의 limit.
+
+### 매 player learning curve
+1. **Discovery**: 매 first encounter 의 confused.
+2. **Pattern recognition**: 매 enemy 의 pattern 의 learn.
+3. **Optimization**: 매 efficient play 의 develop.
+4. **Mastery**: 매 exploit 의 fluent use.
+
+→ 매 game 의 "skill expression" 의 핵심.
+
+## 💻 패턴 (Game AI 의 implementation)
+
+### Behavior Tree (Unity)
+```csharp
+public class EnemyAI : MonoBehaviour {
+    public BehaviorTree tree;
+    
+    void Start() {
+        tree = new BehaviorTree(
+            new Selector(
+                // Flee if low HP
+                new Sequence(
+                    new Condition(() => health < 30),
+                    new Action(Flee)
+                ),
+                // Attack if visible
+                new Sequence(
+                    new Condition(() => CanSeePlayer()),
+                    new Action(Attack)
+                ),
+                // Otherwise patrol
+                new Action(Patrol)
+            )
+        );
+    }
+    
+    void Update() { tree.Tick(); }
+}
+```
+
+### Aggro / threat system
+```csharp
+public class ThreatTable {
+    Dictionary<Player, float> threats = new();
+    
+    public void AddThreat(Player p, float amount) {
+        threats[p] = (threats.GetValueOrDefault(p, 0) + amount);
+    }
+    
+    public Player GetTopThreat() {
+        return threats.OrderByDescending(x => x.Value).First().Key;
+    }
+    
+    public void Decay(float deltaTime) {
+        foreach (var key in threats.Keys.ToList()) {
+            threats[key] *= Mathf.Pow(0.5f, deltaTime / 10f);   // 10s half-life
+        }
+    }
+}
+```
+
+→ 매 player 의 매 action 의 threat. 매 highest 의 attention.
+
+### Anti-cheese: leash + reset
+```csharp
+public class EnemyLeash {
+    Vector3 spawnPoint;
+    float maxDistance = 30f;
+    
+    void Update() {
+        if (Vector3.Distance(transform.position, spawnPoint) > maxDistance) {
+            // Player kited too far - reset.
+            Reset();
+        }
+    }
+    
+    void Reset() {
+        FullHeal();
+        ReturnToSpawn();
+        ClearAggro();
+    }
+}
+```
+
+→ "Run + reset" cheese 의 prevent.
+
+### Adaptive difficulty (AI Director)
+```csharp
+public class AIDirector {
+    float playerSkill = 0.5f;
+    
+    void OnPlayerDeath() {
+        playerSkill -= 0.1f;
+    }
+    
+    void OnPlayerVictory() {
+        playerSkill += 0.1f;
+    }
+    
+    int GetSpawnCount() {
+        return Mathf.RoundToInt(Mathf.Lerp(2, 10, playerSkill));
+    }
+}
+```
+
+→ 매 difficulty 의 dynamic.
+
+### Stochastic action
+```csharp
+public Action ChooseAction() {
+    var attack = AttackUtility();
+    var defend = DefendUtility();
+    var flee = FleeUtility();
+    
+    var total = attack + defend + flee;
+    var roll = Random.Range(0, total);
+    
+    if (roll < attack) return Attack;
+    if (roll < attack + defend) return Defend;
+    return Flee;
+}
+```
+
+→ 매 player 의 "always X" prediction 의 break.
+
+### Cooperative AI (squad)
+```csharp
+public class SquadAI {
+    List<Enemy> members = new();
+    
+    void CoordinatedAttack(Player target) {
+        // Member 1: flank left
+        members[0].Move(target.position + Vector3.left * 5);
+        
+        // Member 2: flank right
+        members[1].Move(target.position + Vector3.right * 5);
+        
+        // Member 3: cover fire
+        members[2].SuppressionFire(target);
+    }
+}
+```
+
+→ 매 1 vs 1 의 weak. 매 squad coordination 의 challenge.
+
+### Boss state machine
+```csharp
+public enum BossState {
+    Phase1, Transition, Phase2, Enraged, Defeated
+}
+
+public class Boss {
+    BossState state = BossState.Phase1;
+    
+    void OnDamage(float dmg) {
+        health -= dmg;
+        
+        if (health < maxHealth * 0.5f && state == BossState.Phase1) {
+            state = BossState.Transition;
+            PlayCutscene();
+            // 매 player 의 transition 의 cheese 의 prevent
+        }
+    }
+}
+```
+
+### Anti-exploit telemetry
+```csharp
+public class AnomalyDetector {
+    void OnPlayerKillBoss(float duration, int deaths) {
+        if (duration < expectedMin || duration > expectedMax) {
+            log.Warning($"Anomalous kill: {duration}s");
+            // 매 designer 의 review.
+        }
+    }
+}
+```
+
+→ 매 production 의 cheese 의 detect.
+
+## 🤔 의사결정 기준 (Decision Criteria)
+
+| 상황 | 추천 AI design |
+|---|---|
+| RTS 단일 unit | Behavior Tree (predictable, scriptable) |
+| MMO boss | Phase-based FSM + adaptive |
+| FPS enemy | Utility AI + cover seeking |
+| Stealth game | Patrol + sight cone (predictable) |
+| Roguelike | AI Director + procedural |
+| Souls-like boss | Pattern + tells (skill expression) |
+| MOBA / strategy | RL self-play |
+
+**기본값**: Predictable enough for skill expression + variable enough to prevent cheese.
+
+## ⚠️ 모순 및 업데이트 (Contradictions & Updates)
+- **Predictable vs surprising**: 매 player 의 mastery 가 fun, 매 over-predictable 의 boring.
+- **Exploit vs skill**: 매 designer 의 perspective 의 difference.
+- **AI 의 budget**: 매 sophisticated AI 의 compute / dev cost.
+- **Multi-player AI vs vs human**: 매 RL self-play 의 emergent strategy 가 unintended.
+- **Adaptive AI 의 player frustration**: 매 매 try 의 different 가 unfair feel.

 ## 🔗 지식 연결 (Graph)
- **Related Topics:** [[Baiting|Baiting]], [[Combat Controls|Combat Controls]], [[Defensive Stances|Defensive Stances]]
- **Projects/Contexts:** War Commander 전투 생태계, 기지 방어선 무력화 (Cracking an entrenched defense)
- **Contradictions/Notes:** 적 유닛이 'Fire at Will'이나 일반 상태일 때는 적을 유인하는 AI 추적 논리가 잘 작동하지만, 방어자가 방어 유닛을 'Stand Ground'나 'Hold Position'으로 설정해두면 적 AI가 위치를 고수하므로 미끼 전술이 전혀 작동하지 않는다는 명확한 예외가 존재합니다 [2, 3].
-
---
-*Last updated: 2026-04-27*
+- 부모: [[Game-AI-Design]] · [[Game-Mechanics]] · [[Combat-Design]]
+- 변형: [[Behavior-Tree]] · [[Finite-State-Machine]] · [[Utility-AI]] · [[GOAP-Goal-Oriented]]
+- 응용: [[Baiting-Tactics]] · [[Kiting-MMO]] · [[Boss-Fight-Design]] · [[AI-Director-Left4Dead]]
+- 매 게임: [[War-Commander-Combat]] · [[Dark-Souls-AI]] · [[StarCraft-AI]] · [[Halo-AI]]
+- Modern: [[AlphaStar]] · [[OpenAI-Five]] · [[RL-Game-AI]]
+- Adjacent: [[Adaptive-Difficulty]] · [[Procedural-Combat]] · [[Player-Skill-Expression]]
+- Anti-cheese: [[Leash-Reset]] · [[State-Validation]] · [[Anti-Exploit-Telemetry]]

 ## 🤖 LLM 활용 힌트 (How to Use This Knowledge)

 **언제 이 지식을 쓰는가:**
- *(TODO)*
+- 매 game 의 enemy / NPC AI design.
+- 매 boss fight 의 pattern + counter.
+- 매 RTS / FPS / MMO 의 combat encounter.
+- 매 player exploit 의 review / fix.
+- 매 difficulty curve 의 design.

 **언제 쓰면 안 되는가:**
- *(TODO)*
+- Single-player turn-based (different paradigm).
+- Walking simulator (no combat).
+- LLM agent (different domain — though some overlap).
+- Specific game 의 modding (game-specific).
+
+## ❌ 안티패턴 (Anti-Patterns)
+- **Pure deterministic AI**: 매 첫 try 후 trivialize.
+- **No leash + open world**: 매 cheese 의 enable.
+- **No state validation**: 매 stuck-in-animation 의 free kill.
+- **AI 가 perfect**: 매 player 의 frustration.
+- **Adaptive AI 가 too aggressive**: 매 try 의 different + unfair.
+- **No exploit detection**: 매 production 의 cheese 의 dominant strategy.
+- **Pattern 가 same 매 boss**: skill expression 의 X.

 ## 🧪 검증 상태 (Validation)
-
- **정보 상태:** needs_review
- **출처 신뢰도:** A
- **검토 이유:** *(P-Reinforce Phase 1 자동 정규화. 본문 검증 필요.)*
+- **정보 상태:** verified (concept-level).
+- **출처 신뢰도:** B (Game AI Programming Wisdom series, GDC talks, "AI for Games" Millington).
+- **검토 이유:** Manual cleanup. Concept 가 안정. 매 game 의 specific implementation 가 design choice.

 ## 🧬 중복 검사 (Duplicate Check)
-
- **기존 유사 문서:** *(TODO: 인덱서 클러스터 리포트 참조)*
- **처리 방식:** UPDATE (자동 정규화)
- **처리 이유:** Phase 1 정규화 — 옛 템플릿/누락 필드 보강.
-
-## ⚠️ 모순 및 업데이트 (Contradictions & Updates)
-
- **과거 데이터와의 충돌:** 없음
- **정책 변화:** 없음
+- **기존 유사 문서:** [[Game-AI-Behavior-Tree]] (subset), [[Boss-Fight-Design]] (related), [[Combat-AI]] (parent).
+- **처리 방식:** KEEP (player perspective + designer perspective 둘 다).
+- **처리 이유:** Exploitation 가 distinct lens (vs design 의 builder perspective).

 ## 🕓 변경 이력 (Changelog)
-
 | 날짜 | 변경 내용 | 처리 방식 | 신뢰도 |
 |------|-----------|-----------|--------|
-| 2026-05-08 | P-Reinforce Phase 1 정규화 (frontmatter + 헤더 표준화) | UPDATE | A |
+| 2026-05-08 | P-Reinforce Phase 1 정규화 | UPDATE | A |
+| 2026-05-09 | Manual cleanup — game AI design pattern + Unity code + 매 game example + 안티패턴 추가 | UPDATE | B |