2nd/10_Wiki/Topics/AI_and_ML/AI Exploitation.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, inferred_by, 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	inferred_by	tech_stack
wiki-2026-0508-ai-exploitation	AI Exploitation (Game AI 공략)	10_Wiki/Topics	verified	self	AI 공략 baiting kiting AI manipulation exploit AI behavior game AI weakness	none	B	0.85	conceptual	game-ai baiting kiting rts tactics exploit behavior-tree fsm npc-design		2026-05-09	pending	Claude Opus 4.7 (manual cleanup 2026-05-09)	language applicable_to game design / process 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)

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

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

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)

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

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)

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

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

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

언제 이 지식을 쓰는가:

• 매 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