2nd/10_Wiki/Topics/Domain_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 Economy Virtual Economy Design	none	A	0.9	applied	game-design economy monetization simulation		2026-05-10	pending	language framework Python/TypeScript Unity/Unreal/Web3

게임 경제 설계

매 한 줄

"매 faucets × sinks × velocity 의 closed-loop monetary policy". 매 게임 경제는 macroeconomic theory 의 micro-application — currency supply, inflation, time-vs-money trade-off의 deliberate engineering. 2026 standard는 dual-currency (soft/hard) + battle-pass 의 retention engine + LiveOps telemetry loop.

매 핵심

매 핵심 component

• Faucets (currency 의 source): quest reward, daily login, drop, refund.
• Sinks (currency 의 destruction): repair cost, upgrade fee, gacha pull, marketplace tax.
• Currencies: soft (gold, earned) / hard (gems, paid) / event (limited).
• Items: consumable / equipment / cosmetic / progression-gated.

매 monetization model

• F2P + IAP: gacha, battle pass, cosmetic shop.
• Premium + DLC: one-time purchase + expansion.
• Subscription: monthly stipend + perks (FFXIV, WoW).
• Ad-supported: rewarded video, interstitial.
• Web3 / play-to-earn (decline 2024-): NFT, token economy — sustainability issue.

매 응용

1. Genshin Impact 의 Primogem dual-currency + 5-star pity (90 pull).
2. Path of Exile 의 currency-as-crafting (no fixed gold) — Chaos Orb deflation.
3. EVE Online 의 player-driven economy — ISK + PLEX 의 RMT bridge.
4. Fortnite 의 V-Bucks + battle pass + item shop rotation.

💻 패턴

1. Faucet/Sink ledger

from dataclasses import dataclass
from collections import defaultdict

@dataclass
class Transaction:
    user_id: str
    currency: str
    amount: int  # positive = faucet, negative = sink
    source: str  # "quest:daily", "sink:repair", "shop:gacha"
    timestamp: float

def analyze_economy(txs: list[Transaction], window_days=7):
    by_currency = defaultdict(lambda: {'faucet': 0, 'sink': 0})
    for tx in txs:
        key = 'faucet' if tx.amount > 0 else 'sink'
        by_currency[tx.currency][key] += abs(tx.amount)
    for cur, d in by_currency.items():
        net = d['faucet'] - d['sink']
        ratio = d['sink'] / max(d['faucet'], 1)
        print(f"{cur}: net={net}, sink/faucet={ratio:.2%}")
        # Healthy: ratio in [0.85, 1.05]

2. Gacha pity system

class GachaPity:
    def __init__(self, soft_pity=75, hard_pity=90, base_rate=0.006):
        self.soft = soft_pity
        self.hard = hard_pity
        self.base = base_rate
        self.counter = 0

    def pull(self) -> bool:
        self.counter += 1
        if self.counter >= self.hard:
            self.counter = 0
            return True
        rate = self.base
        if self.counter >= self.soft:
            # Linear ramp: 0.6% → 100% over [75, 90]
            rate += (self.counter - self.soft) * (1 - self.base) / (self.hard - self.soft)
        if random.random() < rate:
            self.counter = 0
            return True
        return False

# Expected pulls to 5-star ≈ 62 (Genshin verified)

3. Battle pass progression

type BattlePass = {
  tiers: 100;
  xpPerTier: 1000;
  weeklyXpCap: number;       // anti-burnout
  premiumPrice: 950;          // Primogem-equivalent
  rewardValue: number;        // total reward equiv-currency
};

// Healthy ratio: rewardValue / premiumPrice ∈ [1.5, 3.0]
// Engagement: median user 의 50-70% completion in 70-day cycle.

4. Inflation simulation

import numpy as np

def simulate_inflation(faucet_rate, sink_rate, initial_supply, days=365):
    supply = [initial_supply]
    for d in range(days):
        new = supply[-1] + faucet_rate - sink_rate
        supply.append(max(0, new))
    # CPI-equivalent: track price of standard basket
    return np.array(supply)

# Target: weekly inflation < 2%, annual < 50%

5. Whale vs F2P parity check

def progression_gap(whale_spend_usd, f2p_hours):
    whale_progress = whale_spend_usd * SPEND_TO_PROGRESS  # currency conversion
    f2p_progress = f2p_hours * GRIND_RATE
    return whale_progress / max(f2p_progress, 1)

# Healthy: ratio < 5x for "fair F2P"; ratio > 50x → P2W backlash

6. Marketplace tax (sink design)

def list_item(seller_id, item, price):
    listing_fee = price * 0.05  # 5% upfront sink
    deduct_currency(seller_id, listing_fee)
    create_listing(item, price)

def buy_item(buyer_id, listing):
    market_tax = listing.price * 0.10  # 10% sink on sale
    seller_receives = listing.price - market_tax
    transfer(buyer_id, listing.seller, seller_receives)
    burn_currency(market_tax)  # explicit sink

7. Dynamic pricing (event-aware)

def event_price(base_price, demand_multiplier, scarcity):
    # demand from telemetry; scarcity 0..1
    return round(base_price * demand_multiplier * (1 + scarcity))

# Limited-time skin: scarcity=1 → 2x base price acceptable

8. Cohort LTV calculation

def cohort_ltv(cohort_users, days=180):
    revenue = sum(u.total_spend(days) for u in cohort_users)
    return revenue / len(cohort_users)

# Segments: whale (>$100/mo), dolphin ($10-100), minnow (<$10), F2P ($0)
# Healthy mobile F2P: top 1% generate 50%+ revenue (Pareto)

9. Engagement-monetization correlation

import scipy.stats as stats
# Avoid extracting from disengaged users
session_minutes = [...]
spend_usd = [...]
r, p = stats.pearsonr(session_minutes, spend_usd)
# Healthy: r > 0.3 (engagement → spend), not r < 0 (whale-only burn)

매 결정 기준

상황	Approach
Mobile F2P	Dual-currency + gacha + battle pass + soft pity
MMO	Marketplace + crafting sinks + subscription
Premium PC	Cosmetic shop + DLC, no gacha
Competitive esport	No P2W, cosmetic-only monetization
Live service	LiveOps event cycle + battle pass + limited shop
Web3 (caution)	Dual-token + sustainable yield (rare success)

기본값: dual-currency + 70-day battle pass + 90-pull pity + 5-10% marketplace tax sink + telemetry-driven LiveOps.

🔗 Graph

• 부모: Game_Design · Monetization
• 응용: Game_Balancing · LiveOps · Player_Retention
• Adjacent: Behavioral_Economics · Pareto_Distribution

🤖 LLM 활용

언제: gacha rate sheet 설계 검토, sink/faucet ledger anomaly detection, balance hypothesis brainstorming. 언제 X: 최종 monetization decision (regulatory + ethical 의 designer judgment), 미성년자 gacha disclosure (법적 의무).

❌ 안티패턴

• Pay-to-win (competitive): F2P churn + whale-only retention 의 short-lived.
• Inflation neglect: faucet > sink 의 무관심 → currency 의 worthless.
• Hidden gacha rates: 법적 risk (China, Korea 의 mandated disclosure).
• No spending limits: 미성년자 protection 의 lack — refund + lawsuit.
• Predatory FOMO: limited-time + dark pattern 의 abuse — brand damage.
• Currency proliferation: 5+ currency 의 player confusion.
• No data telemetry: economy 의 blind tuning — disaster.

🧪 검증 / 중복

• Verified (GDC talks 2022-2025, Riot/miHoYo/Supercell economy postmortems, Deconstructor of Fun analyses).
• 신뢰도 A.

🕓 Changelog

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