2nd/10_Wiki/Topic_Programming/Frontend/게임 밸런싱.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-게임-밸런싱	게임 밸런싱	10_Wiki/Topics	verified	self	Game Balancing 밸런스 디자인	none	A	0.9	applied	game-design balancing simulation		2026-05-10	pending	language framework Python/TypeScript Unity/Unreal/web

게임 밸런싱

매 한 줄

"매 fairness × engagement × progression의 quantitative tuning loop". 게임 밸런싱은 단순 number tweak이 아닌, player skill curve와 reward schedule을 데이터 기반으로 calibrate하는 systems engineering이다. 2026 현업은 telemetry-driven A/B + LLM-assisted simulation으로 cycle을 일/주 단위로 단축한다.

매 핵심

매 밸런싱 차원

• Power balance: weapon/character/spell 의 win-rate convergence to ~50%.
• Resource economy: gold/XP/material 의 inflation/sink ratio.
• Difficulty curve: time-to-mastery 의 monotonic with checkpoints.
• Matchmaking: MMR/Elo/Glicko-2 — skill variance bounded.

매 측정 지표

• Win rate, pick rate, ban rate (MOBA/FGC).
• Time-to-kill (TTK), DPS, EHP (effective HP).
• Retention D1/D7/D30, session length, churn at level X.
• Gini coefficient of resource distribution.

매 응용

1. League of Legends 의 patch cycle (2-week) — champion winrate band [47%, 53%].
2. Hearthstone 의 nerf/buff 의 telemetry-driven (Vicious Syndicate stats).
3. Slay the Spire 의 Monte Carlo simulation 의 deck balance.
4. Destiny 2 의 sandbox team 의 sandbox tuning (Bungie quarterly).

💻 패턴

1. Win-rate convergence target

# Bayesian winrate estimate with prior
import numpy as np
from scipy.stats import beta

def champion_winrate(wins, losses, prior_a=50, prior_b=50):
    a = prior_a + wins
    b = prior_b + losses
    mean = a / (a + b)
    ci_low, ci_high = beta.ppf([0.025, 0.975], a, b)
    return mean, (ci_low, ci_high)

# Patch decision: nerf if CI bound > 0.53
mean, (lo, hi) = champion_winrate(wins=12500, losses=10800)
needs_nerf = lo > 0.53

2. DPS / TTK calculation

def time_to_kill(damage_per_shot, fire_rate_hz, target_hp, armor=0):
    effective_dps = damage_per_shot * fire_rate_hz * (1 - armor)
    return target_hp / effective_dps

# Weapon balance check: TTK in [0.4s, 1.2s] band
for w in weapons:
    ttk = time_to_kill(w.dmg, w.rpm/60, target_hp=200, armor=0.1)
    assert 0.4 <= ttk <= 1.2, f"{w.name} TTK={ttk:.2f}s out of band"

3. Resource economy faucet/sink

type Economy = { faucets: number; sinks: number; supply: number };

function inflationRate(econ: Economy, dt: number): number {
  const net = econ.faucets - econ.sinks;
  return net / econ.supply / dt; // per-day inflation
}

// Target: |inflation| < 0.02 per week (2%)

4. Monte Carlo deck simulation

def simulate_deck(deck, opponents, n_runs=10000):
    wins = 0
    for _ in range(n_runs):
        opp = random.choice(opponents)
        result = play_match(deck, opp)
        wins += result == "win"
    return wins / n_runs

# Auto-balance: card value = marginal winrate Δ when included

5. Elo / Glicko-2 matchmaking

def glicko2_update(rating, rd, opponents):
    # rd = rating deviation; volatility tracked separately
    g = lambda phi: 1 / math.sqrt(1 + 3 * phi**2 / math.pi**2)
    # ... (full Glicko-2 spec)
    return new_rating, new_rd

6. Difficulty curve fitting

import numpy as np
# Player completion rate per level
levels = np.arange(1, 51)
completion = np.array([...])  # telemetry
# Target: monotonic decrease, no cliff > 15% drop
diff = np.diff(completion)
cliffs = np.where(diff < -0.15)[0]
# cliffs → level redesign candidates

7. A/B test with CUPED variance reduction

def cuped_estimate(treatment_y, control_y, treatment_x, control_x):
    # x = pre-experiment covariate (e.g., D7 retention)
    theta = np.cov(np.concatenate([treatment_y, control_y]),
                   np.concatenate([treatment_x, control_x]))[0,1] / \
            np.var(np.concatenate([treatment_x, control_x]))
    adj_t = treatment_y - theta * treatment_x
    adj_c = control_y - theta * control_x
    return adj_t.mean() - adj_c.mean()

8. LLM-assisted balance review (2026)

# Claude Opus 4.7 의 patch note review
prompt = f"""
Patch diff:
{diff}

Telemetry (last 7d): {telemetry_json}

Identify:
1. Champions exceeding [47%, 53%] winrate band.
2. Hidden interactions (item × champion synergy outliers).
3. Risk score (1-10) per change.
"""
review = claude.messages.create(model="claude-opus-4-7", ...)

매 결정 기준

상황	Approach
Competitive PvP	Winrate convergence + telemetry-driven nerf cycle
Single-player	Difficulty curve + retention cliff analysis
Gacha/F2P	Whale vs F2P parity + pity timer math
Esports patch	2-week cycle + pro-play meta watch
New release	Closed beta MC sim + open beta A/B

기본값: telemetry → Bayesian winrate → 2-week patch cycle 의 [47%, 53%] band.

🔗 Graph

• 부모: Game_Design

🤖 LLM 활용

언제: patch note generation, telemetry anomaly detection, balance hypothesis brainstorming, sim scenario writing. 언제 X: 최종 numerical tuning (designer judgment + playtesting 의 X-able), competitive integrity decision.

❌ 안티패턴

• Whale-only balancing: F2P player 의 churn 의 무시.
• Knee-jerk nerf: 1-day data 의 over-react — sample size 의 부족.
• Symmetric balance obsession: asymmetric design 의 intentional 의 flatten의 X.
• Nerf-only meta: power creep 의 reverse — fun 의 erosion.
• Ignoring rank-stratified data: bronze 와 challenger 의 winrate 의 different — aggregate 의 misleading.

🧪 검증 / 중복

• Verified (Riot Games engineering blog, GDC talks 2023-2025, Vicious Syndicate).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — game balancing full content with patterns