---
id: wiki-2026-0508-위험과-보상-구조-structures-of-risks-an
title: 위험과 보상 구조(Structures of Risks and Rewards)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [R&R Structures, Risk-Reward Patterns, 위험보상 패턴]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, encounter-design, structures, patterns]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: unity-csharp
---

# 위험과 보상 구조(Structures of Risks and Rewards)

## 매 한 줄
> **"매 R&R curve 매 abstract — 매 structure 매 concrete encounter shape"**. 매 [[위험과 보상(Risks and Rewards)]] 매 principle, 매 이 문서 매 player 의 의 hand 의 의 의 매 actual concrete pattern (gauntlet, fork, escalator, sandbox, push-your-luck) 의 catalog.

## 매 핵심

### 매 8 canonical structures
1. **매 Fork**: 매 safe path vs risky path 매 simultaneous offer.
2. **매 Gauntlet**: 매 escalating difficulty 매 reward 매 cumulative.
3. **매 Push-your-luck**: 매 stop / continue 매 explicit player choice.
4. **매 Sandbox / pick-your-stakes**: 매 player 매 difficulty modifier 의 pre-select.
5. **매 Investment**: 매 upfront cost (resource / time) 의 future return 매 trade.
6. **매 Bluff / commit**: 매 hidden information 매 reveal 매 risk.
7. **매 Time pressure**: 매 fast-but-risky vs slow-but-safe.
8. **매 Wager**: 매 player 매 reward 의 size 의 dial.

### 매 structure selection axes
- **explicit vs emergent**: 매 player 매 risk 의 conscious choice 매 가능?
- **front-loaded vs back-loaded**: 매 risk 매 paid upfront 매 / 매 outcome 의 reveal 매 시?
- **bounded vs unbounded escalation**: 매 ceiling 매 존재?
- **reversible vs commit**: 매 mid-encounter back-out 매 가능?

### 매 응용
1. 매 Slay the Spire elite encounter = Fork (skip vs fight).
2. 매 Dead Cells 의 boss biome = Gauntlet (door choice + accumulated curse).
3. 매 Balatro 의 stake selection = Sandbox.
4. 매 Hades 의 boon rarity gamble = Push-your-luck (use coin reroll).
5. 매 Tarkov raid timer = Time pressure.

## 💻 패턴

### Fork structure
```typescript
type Path = { name: string; difficulty: number; reward: Reward };
type Reward = { gold: number; item?: string; rare?: boolean };

class Fork {
  paths: Path[];
  pick(idx: number): Reward {
    const p = this.paths[idx];
    return this.resolve(p);
  }
  resolve(p: Path): Reward {
    const success = Math.random() > p.difficulty * 0.5;
    return success ? p.reward : { gold: 0 };
  }
}

const fork = new Fork();
fork.paths = [
  { name: "safe",  difficulty: 0.2, reward: { gold: 50 } },
  { name: "risky", difficulty: 0.7, reward: { gold: 250, rare: true } },
];
```

### Gauntlet (escalating)
```typescript
class Gauntlet {
  rooms: number;
  cumulativeReward = 0;
  cumulativeDamage = 0;
  step(roomIdx: number) {
    const difficulty = 1 + roomIdx * 0.3;
    const damage = Math.random() * difficulty * 10;
    const reward = 50 * Math.pow(1.4, roomIdx);
    this.cumulativeDamage += damage;
    this.cumulativeReward += reward;
    return { reward, damage, total: this.cumulativeReward };
  }
}
```

### Push-your-luck
```typescript
class PushYourLuck {
  pot = 100;
  bustP = 0.1;
  step() {
    this.bustP += 0.08;
    if (Math.random() < this.bustP) {
      return { state: "BUST", payout: 0 };
    }
    this.pot *= 1.5;
    return { state: "CONTINUE", pot: this.pot, bustP: this.bustP };
  }
  cashOut() { return { state: "CASHED", payout: this.pot }; }
}
```

### Sandbox (pre-select stakes)
```csharp
public class StakeConfig {
    public List<string> Modifiers = new();
    public int RewardMultiplier = 1;
}
public class StakePicker {
    public StakeConfig Build(List<string> picked) {
        return new StakeConfig {
            Modifiers = picked,
            RewardMultiplier = 1 + picked.Count
        };
    }
}
// Player commits BEFORE encounter; no mid-fight escape
```

### Investment structure
```typescript
class Investment {
  spend(amount: number, projectId: string): Promise<number> {
    // Resource committed now; outcome resolves later
    return new Promise(resolve => {
      const success = Math.random() < 0.6;
      const payout = success ? amount * 2.5 : 0;
      setTimeout(() => resolve(payout), 5000); // delayed reveal
    });
  }
}
```

### Time pressure
```typescript
class TimedRaid {
  start = Date.now();
  loot = 0;
  loop() {
    const elapsed = (Date.now() - this.start) / 1000;
    const extractRisk = Math.min(0.05 + elapsed * 0.01, 0.9);
    // Each tick: more loot, but rising chance of PvP encounter
    this.loot += 10;
    return { loot: this.loot, extractRisk };
  }
}
```

## 매 결정 기준
| 상황 | 적합 structure |
|---|---|
| 매 quick decision moment | Fork |
| 매 sustained tension session | Gauntlet |
| 매 explicit gambling feel | Push-your-luck |
| 매 customizable difficulty | Sandbox |
| 매 strategic depth | Investment |
| 매 PvP / multiplayer | Bluff, Time pressure |

**기본값**: 매 game type 의 의 의 1-2 structure 매 main + 매 1 secondary 의 layer.

## 🔗 Graph
- 부모: [[위험과 보상(Risks and Rewards)]] · [[Encounter Design]]
- 변형: [[Roguelike Run Modifiers]] · [[Push-Your-Luck]]
- 응용: [[핀치 포인트(Pinch Point)]] · [[Boss Design]] · [[Dungeon Pacing]]
- Adjacent: [[Choice Architecture]] · [[Decision Theory]]

## 🤖 LLM 활용
**언제**: 매 specific encounter / room / level 의 design 시 매 concrete pattern 의 select.
**언제 X**: 매 high-level economy 의 의 design — 매 [[위험과 보상(Risks and Rewards)]] 의 의 abstract level 의 의 사용.

## ❌ 안티패턴
- **매 single structure overuse**: 매 모든 encounter 매 same pattern → 매 fatigue.
- **매 commit without information**: 매 sandbox stake 매 picker 매 modifier effect 매 unknown 시 매 frustrating.
- **매 false fork**: 매 Fork 매 path 매 EV 매 동일 시 매 meaningless choice.

## 🧪 검증 / 중복
- Verified (Schell, Costikyan *Uncertainty in Games*, GDC talks on roguelike encounter design).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 8 canonical structures + working code per structure |