refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게 [공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류. 문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인). - Topic_Programming → Domain_Programming (내부 구조 보존) - Topic_Graphic → Domain_Design - Topic_Business → Domain_Product - Topic_General → Domain_General - _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning), Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing) - 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서) - 빈 폴더 정리 (memory/procedures) - 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -0,0 +1,177 @@
+---
+id: wiki-2026-0508-유닛-상성-unit-counters
+title: 유닛 상성(Unit Counters)
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [Unit Counters, RPS, Rock-Paper-Scissors, 상성 시스템]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.9
+verification_status: applied
+tags: [game-design, rts, balance, counter-system, unit-design]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: GameDesign
+  framework: RTS/Strategy
+---
+
+# 유닛 상성(Unit Counters)
+
+## 매 한 줄
+> **"매 unit 의 의 hard counter 의 soft counter 의 의 — 의 dominant strategy 의 의 prevent."**. RTS / autobattler 의 의 fundamental balance mechanism — StarCraft (1998) 의 marine-vulture-tank triangle 의 origin. 매 2026 의 modern (StarCraft 2, Age of Empires IV, Stormgate) 의 의 hard counter 의 의 soft counter (10-30% damage modifier) + positioning + tech tree 의 의 의 의 layered counter system 의 의.
+
+## 매 핵심
+
+### 매 counter 의 의 type
+- **Hard counter**: 2-3x damage multiplier, 거의 항상 win (예: marauder vs immortal).
+- **Soft counter**: 10-30% advantage, micro 의 의 outplay 의 의 (예: zealot vs marine 의 surround).
+- **Tech counter**: late-game unit 의 early unit 의 의 (예: battlecruiser vs marine).
+- **Composition counter**: 의 single unit 의 의 army composition 의 의 counter.
+
+### 매 design 원칙
+- **Transitivity 의 X**: A→B→C→A — 의 dominant strategy 의 의.
+- **Asymmetric counter**: 매 race / faction 의 의 counter 의 의 의 (variety).
+- **Counter visibility**: 매 player 의 의 의 counter 의 의 의 의 (UI tooltip + tutorial).
+- **Cost-effectiveness**: counter unit 의 의 cheaper or 의 powerful — 매 reaction 의 의 reward.
+
+### 매 응용
+1. RTS — StarCraft 2, AoE IV, Stormgate.
+2. Autobattler — TFT, Hearthstone Battlegrounds (trait synergy + counter).
+3. MOBA — counter pick at draft phase (Dota 2, LoL).
+4. Tower defense — armor type 의 damage type 의 의.
+
+## 💻 패턴
+
+### Damage type matrix (AoE-style)
+```python
+# 매 attack type × armor type → multiplier
+DAMAGE_MATRIX = {
+    ('pierce', 'light'):   1.5,
+    ('pierce', 'heavy'):   0.5,
+    ('crush',  'building'): 2.0,
+    ('crush',  'light'):   0.8,
+    ('melee',  'light'):   1.0,
+    ('melee',  'heavy'):   1.2,
+}
+
+def compute_damage(attack_type, armor_type, base_dmg, armor_value):
+    mult = DAMAGE_MATRIX.get((attack_type, armor_type), 1.0)
+    return max(1, base_dmg * mult - armor_value)
+```
+
+### StarCraft 2-style attribute system
+```python
+# 매 unit 의 의 attribute (Light/Armored/Biological/Mechanical/Massive/Psionic)
+class Unit:
+    name: str
+    attributes: set[str]
+    hp: int
+    armor: int
+
+class Weapon:
+    base_damage: int
+    bonus: dict[str, int]  # +damage vs attribute
+
+    def damage_against(self, target: Unit) -> int:
+        bonus = sum(b for attr, b in self.bonus.items() if attr in target.attributes)
+        return max(0, self.base_damage + bonus - target.armor)
+
+# 예: Marauder = +10 vs Armored
+marauder_weapon = Weapon(base_damage=10, bonus={'Armored': 10})
+```
+
+### Soft counter via positioning (range / micro)
+```python
+# 매 ranged 의 의 melee 의 의 soft counter — 의 micro 의 의 kite
+def kite_dps(unit_range, target_speed, unit_speed, weapon_dps):
+    if unit_speed <= target_speed:
+        return weapon_dps * 0.3  # caught
+    # kite efficiency — range 의 의 의 의 의 의
+    efficiency = min(1.0, unit_range / 5.0)
+    return weapon_dps * efficiency
+```
+
+### Counter graph validation (no transitive dominator)
+```python
+import networkx as nx
+
+def has_dominant(counters: dict[str, list[str]]) -> bool:
+    """Check if any unit hard-counters all others (cycle-free dominator)."""
+    G = nx.DiGraph()
+    for unit, beats in counters.items():
+        for b in beats:
+            G.add_edge(unit, b)
+    # 매 unit 의 의 의 의 의 unit 의 의 — out_degree == n-1
+    n = len(counters)
+    return any(G.out_degree(u) == n - 1 for u in G.nodes)
+
+# 매 healthy: cyclic — A>B>C>A
+counters = {'marine': ['zealot'], 'zealot': ['zergling'], 'zergling': ['marine']}
+assert not has_dominant(counters)
+```
+
+### Composition score (army-vs-army)
+```python
+def composition_score(army_a: list[Unit], army_b: list[Unit]) -> float:
+    """매 simulate matchup 의 의 expected value."""
+    score = 0.0
+    for ua in army_a:
+        # 매 ua 의 의 best target in army_b
+        best_dmg = max(ua.weapon.damage_against(ub) for ub in army_b)
+        score += best_dmg * ua.attack_speed
+    return score
+```
+
+### TFT-style trait synergy (autobattler)
+```python
+TRAITS = {
+    'Mage':    {3: 1.3, 6: 1.6, 9: 2.0},  # spell power multiplier
+    'Bruiser': {2: 100, 4: 250, 6: 500},  # bonus HP
+}
+
+def active_traits(team: list[Unit]) -> dict[str, int]:
+    counts = {}
+    for u in team:
+        for t in u.traits:
+            counts[t] = counts.get(t, 0) + 1
+    # 매 threshold 의 의 의 의 active tier
+    return {t: max([k for k in TRAITS[t] if k <= c], default=0) for t, c in counts.items()}
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| Classic RTS (clear roles) | Hard counter triangle (rock-paper-scissors) |
+| Skill-expressive RTS | Soft counter + positioning + micro |
+| Autobattler | Trait synergy + composition counter |
+| MOBA | Counter pick at draft + lane matchup |
+| Tower defense | Damage type × armor type matrix |
+| New game prototyping | Start hard counter → playtest → soften |
+
+**기본값**: 매 2-3 hard counter relations + soft counter (positioning, range, speed) layered.
+
+## 🔗 Graph
+
+## 🤖 LLM 활용
+**언제**: counter matrix prototyping, balance proposal generation, transitivity validation script.
+**언제 X**: actual playtesting (의 telemetry + human playtester 의 의 의), competitive meta analysis (의 dataset 의 의).
+
+## ❌ 안티패턴
+- **Hard counter only**: 매 game 의 의 rock-paper-scissors 의 의 — skill expression 의 의.
+- **Hidden counter**: tooltip 의 의 — player 의 의 reverse-engineer 의.
+- **Dominant unit**: 의 unit 의 의 의 unit 의 hard counter — meta 의 collapse.
+- **No counter at all (homogeneous units)**: 매 player choice 의 의 의 의 의 의.
+- **Symmetric mirror only**: 매 race / faction 의 의 의 — variety 의 의.
+
+## 🧪 검증 / 중복
+- Verified (StarCraft 2 design talks, AoE IV balance patches, Riot Games TFT design).
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — RTS unit counter system + 의 의 |