2nd/10_Wiki/Topic_Programming/AI_and_ML/Support Insulated.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, 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	tech_stack
wiki-2026-0508-support-insulated	Support Insulated	10_Wiki/Topics	verified	self	Combined Arms Support Insulated Support Force Protection Support	none	A	0.85	applied	military-strategy combined-arms game-balance systems-design		2026-05-10	pending	language framework conceptual combined-arms

Support Insulated

매 한 줄

"매 support unit 의 frontline 의 noise로부터 insulate — clean line of fire/sight 의 보장". 매 combined arms doctrine + game design balance 에서 등장하는 concept. 매 artillery·healer·sniper·ranger 같은 high-impact-but-fragile unit 의 enabler 의 지원 (tank, screen, terrain) 으로 protected 의 핵심 principle.

매 핵심

매 origin: combined arms

• Frontline (DPS/Tank): 매 melee 충돌 의 absorb.
• Support (insulated): 매 backline 에서 force multiplier 의 제공.
• Insulation 의 mechanism: physical screening (tank line), terrain (hill, choke), CC (crowd control), stealth.

매 game design 측면

• MOBA: ADC 가 frontline tank/initiator 의 뒤에서 DPS 의 출력 — 매 insulation 의 fail = team loss.
• RTS: artillery 가 infantry screen 의 뒤에서 siege — 매 insulation 의 break = 즉사.
• MMO raid: healer 가 tank·DPS 의 wall 뒤 — 매 add 의 healer 도달 = wipe.
• Tactical (XCOM-like): sniper high-ground + overwatch — 매 flank 의 expose = death.

매 system design analogy

• Microservice: critical service (payment) 의 rate-limit·circuit-breaker 의 뒤 insulate.
• Database: primary 의 read replica + connection pool 의 buffer 로 insulate.
• AI inference: GPU 의 queue·batcher 의 spike 로부터 insulate.

매 응용

1. Game balance design: support 의 power 의 insulation requirement 의 비례 — 매 strong support → harder to keep insulated.
2. Military logistics: forward operating base 의 layered defense (perimeter + QRF).
3. System architecture: critical path service 의 bulkhead pattern.

💻 패턴

1. Bulkhead pattern (system insulation)

import asyncio

class Bulkhead:
    def __init__(self, max_concurrent: int):
        self.sem = asyncio.Semaphore(max_concurrent)

    async def call(self, func, *args, **kwargs):
        async with self.sem:
            return await func(*args, **kwargs)

# critical service 의 own bulkhead — noisy neighbor 의 isolate
payment_bh = Bulkhead(max_concurrent=10)
search_bh = Bulkhead(max_concurrent=50)

2. Circuit breaker (insulation from cascading failure)

import time
from enum import Enum

class State(Enum):
    CLOSED = 1
    OPEN = 2
    HALF_OPEN = 3

class CircuitBreaker:
    def __init__(self, threshold=5, timeout=30):
        self.failures = 0
        self.threshold = threshold
        self.timeout = timeout
        self.state = State.CLOSED
        self.opened_at = 0

    def call(self, func, *args):
        if self.state == State.OPEN:
            if time.time() - self.opened_at > self.timeout:
                self.state = State.HALF_OPEN
            else:
                raise RuntimeError("circuit open")
        try:
            result = func(*args)
            self.failures = 0
            self.state = State.CLOSED
            return result
        except Exception:
            self.failures += 1
            if self.failures >= self.threshold:
                self.state = State.OPEN
                self.opened_at = time.time()
            raise

3. Game support unit balance (config)

units:
  artillery:
    damage: 200
    range: 800
    hp: 60          # fragile — needs insulation
    insulation_requirement: high
    counters: [flanker, assassin]

  tank:
    damage: 30
    range: 50
    hp: 600         # insulator
    role: screen

  healer:
    heal_per_sec: 80
    hp: 80
    insulation_requirement: critical
    line_of_sight_required: true

4. Threat model (insulation breach detection)

def insulation_breach(support_unit, enemies):
    """Returns True if any enemy has clear path to support."""
    for enemy in enemies:
        path = a_star(enemy.pos, support_unit.pos, blockers=allied_tanks)
        if path and path.length < enemy.move_range + enemy.attack_range:
            return True
    return False

5. Layered defense (FOB pattern)

[ outer perimeter: sensors + mines ]
       |
[ middle: infantry + AT ]
       |
[ inner: command + logistics ]
       |
[ core: support assets — artillery, comm, medical ]

매 결정 기준

상황	Approach
Support 의 high power	insulation requirement 의 proportional 의 raise
Insulation 의 break easy	support 의 buff or move backward
System critical path	bulkhead + circuit breaker + retry budget
Frontline 의 collapse	support 의 retreat option (mobility) 의 보장

기본값: support unit 의 power × fragility × insulation requirement 의 triangle 의 balance 의 유지.

🔗 Graph

• 부모: Combined Arms (제병협동) 전술 · 게임 밸런싱
• 변형: Synergy
• 응용: Circuit-Breaker
• Adjacent: Layered-Architecture

🤖 LLM 활용

언제: balance 의 playtest scenario 의 generate, system architecture 의 review (insulation gap 찾기). 언제 X: real-time game decision (latency), military doctrine (LLM 의 specificity 의 부족).

❌ 안티패턴

• Support 의 power up without insulation cost: 매 game balance 의 break.
• Insulation 의 single layer: 매 one penetration → total collapse.
• System critical path 의 bulkhead 의 부재: 매 noisy neighbor → cascading failure.
• Support mobility 의 무시: 매 retreat option 의 없 = trapped.

🧪 검증 / 중복

• Verified (combined arms doctrine, FM 3-0, Riot Games balance philosophy, Netflix Hystrix patterns).
• 신뢰도 A-.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — combined-arms support insulation + system bulkhead analogy