---
id: wiki-2026-0508-support-insulated
title: Support Insulated
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Combined Arms Support, Insulated Support, Force Protection Support]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [military-strategy, combined-arms, game-balance, systems-design]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: conceptual
  framework: 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)
```python
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)
```python
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)
```yaml
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)
```python
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]] · [[Game-Balance]]
- 변형: [[Synergy]] · [[Force-Multiplier]]
- 응용: [[Bulkhead-Pattern]] · [[Circuit-Breaker]]
- Adjacent: [[Defense-In-Depth]] · [[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 |
