---
id: wiki-2026-0508-ai-exploitation
title: AI Exploitation (Game AI 공략)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [AI 공략, baiting, kiting, AI manipulation, exploit AI behavior, game AI weakness]
duplicate_of: none
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-09
github_commit: pending
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 (Game AI 공략)

## 📌 한 줄 통찰 (The Karpathy Summary)
> **Game AI 의 deterministic behavior 의 player exploit**. Baiting / kiting / pathing trick. RTS / FPS / MMO 의 player skill 의 큰 부분. **Game design 의 책임 = 매 exploit 의 fun + fair 의 design**.

## 📖 구조화된 지식 (Synthesized Content)

### 정의
"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)
- 부모: [[Game-Mechanics]]
- 변형: [[Behavior-Tree]]
- 응용: [[Baiting Tactics]]
- 매 게임: [[War-Commander-Combat]]
- Adjacent: [[Adaptive-Difficulty]]

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

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

**언제 쓰면 안 되는가:**
- 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)
- **정보 상태:** 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)
- **기존 유사 문서:** [[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 정규화 | UPDATE | A |
| 2026-05-09 | Manual cleanup — game AI design pattern + Unity code + 매 game example + 안티패턴 추가 | UPDATE | B |