2nd/10_Wiki/Topics/Domain_Programming/AI_and_ML/유닛 상성(Unit Counters).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-유닛-상성-unit-counters	유닛 상성(Unit Counters)	10_Wiki/Topics	verified	self	Unit Counters RPS Rock-Paper-Scissors 상성 시스템	none	A	0.9	applied	game-design rts balance counter-system unit-design		2026-05-10	pending	language framework GameDesign 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)

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

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

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

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)

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)

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 + 의 의