Files

T

Antigravity Agent f8b21af4be Wiki cleanup: error-doc removal, dedup merge, link normalization

10_Wiki/Topics 대규모 정리:
- 오류 캡처/미완성 stub 문서 227개 제거
- 교차폴더 중복 43클러스터 병합 (63파일 → redirect)
- 링크명 정규화: 깨진 링크 수정·redirect 직결·개념 매핑 ~2,400건
- 카테고리 MOC 6개 신규 생성
- Graph 섹션 미해결 related-keyword 링크 10,058건 제거

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

2026-05-20 23:52:15 +09:00

6.1 KiB

Raw Blame History

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

title

위험과 보상 구조(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

매 Fork: 매 safe path vs risky path 매 simultaneous offer.
매 Gauntlet: 매 escalating difficulty 매 reward 매 cumulative.
매 Push-your-luck: 매 stop / continue 매 explicit player choice.
매 Sandbox / pick-your-stakes: 매 player 매 difficulty modifier 의 pre-select.
매 Investment: 매 upfront cost (resource / time) 의 future return 매 trade.
매 Bluff / commit: 매 hidden information 매 reveal 매 risk.
매 Time pressure: 매 fast-but-risky vs slow-but-safe.
매 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 매 가능?

매 응용

매 Slay the Spire elite encounter = Fork (skip vs fight).
매 Dead Cells 의 boss biome = Gauntlet (door choice + accumulated curse).
매 Balatro 의 stake selection = Sandbox.
매 Hades 의 boon rarity gamble = Push-your-luck (use coin reroll).
매 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

6.1 KiB Raw Blame History