2nd/10_Wiki/Topics/Domain_General/From_Other/위험과 보상 구조(Structures of Risks and Rewards).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-위험과-보상-구조-structures-of-risks-an	위험과 보상 구조(Structures of Risks and Rewards)	10_Wiki/Topics	verified	self	R&R Structures Risk-Reward Patterns 위험보상 패턴	none	A	0.9	applied	game-design encounter-design structures patterns		2026-05-10	pending	language framework typescript 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

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)

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

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)

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

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

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)
• 응용: 핀치 포인트(Pinch Point) · Boss Design
• 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