---
id: wiki-2026-0508-덱-빌딩-deck-building
title: 덱 빌딩 (Deck building)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Deck Building, Deckbuilding, 덱빌딩, TCG Deck Construction]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, tcg, ccg, strategy, balance]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: text
  framework: TCG/CCG game design
---

# 덱 빌딩 (Deck building)

## 매 한 줄
> **"매 60장 안에 win condition / mana curve / interaction / consistency 의 balance를 압축하는 행위"**. Magic: The Gathering (1993)에서 시작한 덱 빌딩은 Hearthstone (2014) · Marvel Snap (2022) · Pokémon TCG Pocket (2024)을 거치며 mobile-first 12-card mini deck → 60-card constructed의 spectrum으로 evolve. 2026 현재 LLM-assisted deckbuilder (e.g. Untapped.gg AI Coach)가 meta-aware suggestion을 제공.

## 매 핵심

### 매 4 Pillar of Deck Construction
- **Win Condition**: 매 매치 종료시키는 primary path (combo / aggro burn / control late-game / mill).
- **Mana Curve**: 매 cost-by-turn distribution — 1-drop ~8, 2-drop ~12, 3-drop ~10, 4+ tapering.
- **Consistency**: 매 draw engine + tutor (search effect) — variance 감소.
- **Interaction**: 매 removal + counterspell — 상대 plan 방해.

### 매 Format별 제약
- **Constructed (60+)**: max 4-of (Hearthstone 2-of), banlist 적용.
- **Limited / Draft (40)**: 매 sealed pool에서 on-the-fly 구성.
- **Singleton / Commander (100)**: 매 1-of, 100-card highlander.
- **Marvel Snap (12)**: 매 ultra-compressed — 매 card가 "tech choice".

### 매 응용
1. Pokémon TCG Pocket pack-opening + 20-card deck — onboarding-first design.
2. Slay the Spire roguelike deckbuilder — run마다 deck 점진 구성.
3. MTG Arena Brawl — 60-card singleton + commander.
4. Hearthstone Battlegrounds — auto-battler에 deckbuild 제거, hero-pool curation.

## 💻 패턴

### Mana Curve Validator
```python
from collections import Counter

def validate_curve(deck: list[dict]) -> dict:
    """deck = [{'name': str, 'cmc': int, 'count': int}, ...]"""
    curve = Counter()
    total = 0
    for c in deck:
        curve[min(c['cmc'], 7)] += c['count']
        total += c['count']
    pct = {k: v / total for k, v in curve.items()}
    ideal = {1: 0.13, 2: 0.20, 3: 0.17, 4: 0.13, 5: 0.08, 6: 0.05, 7: 0.04}
    deviation = sum(abs(pct.get(k, 0) - v) for k, v in ideal.items())
    return {'curve': dict(curve), 'total': total, 'deviation': deviation}
```

### Hypergeometric Draw Probability
```python
from math import comb

def draw_at_least_one(copies: int, deck_size: int = 60, draws: int = 7) -> float:
    """Opening hand에 specific card 포함 확률."""
    miss = comb(deck_size - copies, draws) / comb(deck_size, draws)
    return 1 - miss

# 매 4-of in 60: ~40% to see in opening hand
print(draw_at_least_one(4))  # 0.3994
```

### Archetype Classifier (LLM-assisted)
```python
import anthropic

client = anthropic.Anthropic()

def classify_archetype(decklist: list[str]) -> str:
    msg = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=200,
        system="You are an MTG meta analyst. Classify decks as Aggro/Midrange/Control/Combo/Tempo.",
        messages=[{"role": "user", "content": "\n".join(decklist)}],
    )
    return msg.content[0].text
```

### Snap-style 12-Card Synergy Score
```python
def synergy_score(deck: list[str], synergy_graph: dict[tuple, float]) -> float:
    score = 0.0
    for i, a in enumerate(deck):
        for b in deck[i+1:]:
            score += synergy_graph.get((a, b), 0) + synergy_graph.get((b, a), 0)
    return score / len(deck)
```

### Sideboard Optimizer
```python
def optimize_sideboard(main: list[str], meta: dict[str, float],
                      cards: dict[str, dict[str, float]]) -> list[str]:
    """meta = {archetype: weight}, cards[c][archetype] = win_rate_delta."""
    scored = []
    for c, deltas in cards.items():
        if c in main: continue
        ev = sum(meta.get(a, 0) * d for a, d in deltas.items())
        scored.append((ev, c))
    scored.sort(reverse=True)
    return [c for _, c in scored[:15]]
```

### Draft Pick EV
```python
def pick_ev(card: str, picks_so_far: list[str], wheels: dict[str, float]) -> float:
    """Card power × signal × wheel probability."""
    base = card_power(card)
    in_color_bonus = 1.3 if shares_color(card, picks_so_far) else 0.8
    wheel_pen = 1.0 - wheels.get(card, 0) * 0.2  # 매 wheel 가능성 → 후순위
    return base * in_color_bonus * wheel_pen
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Mobile onboarding | 12-card (Snap) or 20-card (Pocket) |
| Competitive depth | 60-card constructed |
| Social play | Commander 100-card singleton |
| Roguelike | Procedural deckbuild (StS) |
| Beginner | Pre-constructed starter |

**기본값**: 60-card constructed with 4-of legality + 15-card sideboard.

## 🔗 Graph
- 부모: [[Game_Design]]
- 변형: [[Draft_Mode]]

## 🤖 LLM 활용
**언제**: meta classification, sideboard suggestion, decklist parse → archetype, beginner coaching.
**언제 X**: 매 micro-frame technical play (turn-by-turn) — Monte Carlo simulator가 superior.

## ❌ 안티패턴
- **Random pile**: 매 win condition 없는 60장 collection.
- **Curve cliff**: 매 mana curve의 4+ slot 비대 → opening hand brick.
- **No interaction**: 매 pure goldfish deck — 상대 plan 무시.
- **Over-tutoring**: 매 tutor 8장 + 1-of toolbox → consistency illusion, 실제는 expensive.

## 🧪 검증 / 중복
- Verified (Frank Karsten *Mana Math*, MTG Pro Tour data 2014-2025).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — TCG/CCG deck construction 4-pillar + format spectrum + 2026 LLM coach 정리 |
