Files

T

koriweb d8a80f6272 chore(wiki): dangling 링크 canonical 정규화 (768파일/1200건)

이름만 다른(표기 변형) [[위키링크]]를 대상 문서의 canonical 제목으로 치환해
끊겼던 1,200개 링크를 연결. 제목/파일명 정규화 일치만 적용하고 별칭 매칭은
과병합 위험으로 제외(애매성 가드). 원본은 _link_reconcile_backup/ 에 백업.
도구: Datacollect/scripts/link_reconcile_apply.mjs

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

2026-06-08 12:24:15 +09:00

6.1 KiB

Raw Blame History

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

title

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.

매 응용

Game balance design: support 의 power 의 insulation requirement 의 비례 — 매 strong support → harder to keep insulated.
Military logistics: forward operating base 의 layered defense (perimeter + QRF).
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

🤖 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

6.1 KiB Raw Blame History Unescape Escape