docs(10_Wiki): Topic_Business/General/Graphic/Programming을 Topics/ 하위로 이동

최상위 10_Wiki/Topic_*였던 4개 카테고리 폴더를 10_Wiki/Topics/Topic_* 로 재배치.
콘텐츠 변경 없음(순수 폴더 이동) — Topics/ 하위 나머지 폴더는 이미 지난 커밋에서
전부 정리된 상태(잔존 항목은 에이전트 운영 상태 및 사용자가 보존을 요청한
업데이트0615/무제 3.canvas 뿐).
This commit is contained in:
Antigravity Agent
2026-07-05 00:44:01 +09:00
parent e9cbf23ab5
commit 9a135bd19d
6127 changed files with 0 additions and 0 deletions
@@ -0,0 +1,182 @@
---
id: wiki-2026-0508-chef-universe
title: Chef Universe
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Chef Universe, 셰프 유니버스]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [casual-game, hybrid-casual, cooking, monetization-case-study]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: csharp
framework: Unity
---
# Chef Universe
## 매 한 줄
> **"매 hybrid-casual cooking sim 의 monetization-engineered case study"**. 매 Playrix-style narrative meta + Voodoo-style snackable core loop 의 hybrid — 매 2024 SuperPlay / Habby 계열 의 매 representative title 로 매 LTV $35+ / D30 retention 18%+ 의 metrics 의 publish.
## 매 핵심
### 매 게임 구조
- Core loop: 매 timing-based plate-serving mini-game (15-30s session).
- Meta loop: 매 restaurant decoration (match-3 의 puzzle reward 의 currency).
- Narrative: 매 매주 새로운 chef NPC + 매 storyline arc.
### 매 수익화 stack
- Rewarded video (RV): 매 plate-fail retry + 매 2x speed boost — 매 ARPDAU $0.12.
- Interstitial: 매 level transition (frequency cap 60s) — 매 ARPDAU $0.18.
- IAP: 매 starter pack ($2.99 / $4.99 / $9.99) + 매 weekly subscription ($6.99/wk) + 매 cosmetic chef skin.
- Hybrid mix: 매 ad revenue 65% / IAP 35% — 매 hybrid-casual canonical ratio.
### 매 KPI 벤치마크
1. CPI: $1.20-$1.80 (US/Tier 1).
2. D1/D7/D30: 42% / 18% / 9%.
3. LTV (D90): $35 — 매 CPI 대비 19x payback.
4. Ad-IAP cannibalization: ~12% (매 RV-heavy player 의 IAP probability 감소).
## 💻 패턴
### Hybrid-casual ad placement (Unity / LevelPlay)
```csharp
using com.unity3d.mediation;
public class ChefAdManager : MonoBehaviour {
LevelPlayRewardedAd rv;
LevelPlayInterstitialAd inter;
float lastInterTime;
const float INTER_COOLDOWN = 60f;
void Start() {
rv = new LevelPlayRewardedAd("rv_plate_retry");
inter = new LevelPlayInterstitialAd("inter_level_end");
rv.LoadAd();
inter.LoadAd();
}
public void OfferRetry(System.Action<bool> onResult) {
if (!rv.IsAdReady()) { onResult(false); return; }
rv.OnAdRewarded += (_, __) => onResult(true);
rv.OnAdClosed += (_) => { rv.LoadAd(); };
rv.ShowAd();
}
public void TryShowInterstitial() {
if (Time.time - lastInterTime < INTER_COOLDOWN) return;
if (!inter.IsAdReady()) return;
inter.ShowAd();
lastInterTime = Time.time;
inter.OnAdClosed += (_) => inter.LoadAd();
}
}
```
### Starter pack price-test (Remote Config)
```csharp
public class StarterPackOffer {
public static StarterPackOffer Resolve(PlayerProfile p) {
// segment by D1 spend probability (LightGBM model output cached)
var seg = p.spendPropensitySegment; // 0..3
var price = seg switch {
0 => "$0.99", // explore
1 => "$2.99", // entry
2 => "$4.99", // mid
_ => "$9.99", // whale
};
return new StarterPackOffer {
Price = price,
Gems = seg switch { 0 => 100, 1 => 350, 2 => 700, _ => 1800 },
Skin = seg >= 2 ? "chef_gold" : null,
};
}
}
```
### Retention hook — daily streak
```csharp
public class DailyStreakSystem {
public Reward CheckIn(DateTime now, PlayerState s) {
var daysSince = (now.Date - s.lastCheckIn.Date).Days;
if (daysSince == 0) return Reward.None;
s.streak = daysSince == 1 ? s.streak + 1 : 1;
s.lastCheckIn = now;
return s.streak switch {
1 => Reward.Coins(100),
3 => Reward.Energy(5),
7 => Reward.ChefSkin("chef_apron_red"),
14 => Reward.Gems(200),
_ => Reward.Coins(50 * s.streak),
};
}
}
```
### Plate-serving core (timing minigame)
```csharp
public class PlateServingMinigame {
public float ScoreServe(float prepTime, float perfectWindow) {
if (Mathf.Abs(prepTime) <= perfectWindow * 0.5f) return 1.0f;
if (Mathf.Abs(prepTime) <= perfectWindow) return 0.7f;
if (Mathf.Abs(prepTime) <= perfectWindow * 1.5f) return 0.4f;
return 0f; // burnt / wasted
}
}
```
### A/B test analytics (Firebase + BigQuery)
```csharp
public static class ChefAnalytics {
public static void LogPaywall(string variant, string outcome, decimal? price) {
var p = new Dictionary<string, object> {
{ "variant", variant },
{ "outcome", outcome }, // shown | tap | purchase | dismiss
{ "price_usd", price ?? 0 },
{ "session_n", PlayerPrefs.GetInt("session_n") },
};
Firebase.Analytics.FirebaseAnalytics.LogEvent("paywall_event", p.ToFirebaseParams());
}
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Casual (저-engagement) | Ad-heavy (RV + interstitial) |
| Mid-core (high-engagement) | IAP-heavy (battle pass + offers) |
| Hybrid-casual (Chef Universe like) | 60/40 ad/IAP — 매 weekly sub + RV retry |
| Whale segment 검출 후 | Personalized offer (LightGBM segmentation) |
**기본값**: 매 Ad+IAP hybrid 60/40 ratio + weekly subscription + segment-priced starter pack.
## 🔗 Graph
- 부모: [[하이브리드 캐주얼(Hybrid-Casual)]] · [[게임 수익화 모델]]
- 변형: [[하이브리드 수익화(Hybrid Monetization)]]
- 응용: [[라이브옵스(Live-ops)]] · [[Dynamic Pricing]]
- Adjacent: [[고객 유지율(Retention)]] · [[Fortnite]]
## 🤖 LLM 활용
**언제**: 매 hybrid-casual title 의 monetization stack 의 setup / KPI benchmark 의 reference 의 필요할 때.
**언제 X**: 매 mid-core RPG / strategy 의 LTV $100+ tier — 매 다른 stack (battle pass / gacha) 의 사용.
## ❌ 안티패턴
- **Ad spam**: 매 30s 이하 interstitial — 매 D1 retention -8%p collapse.
- **Forced RV without skip**: 매 store policy (Apple Guideline 2.5.6) violation 의 risk.
- **Whale-only economy**: 매 mid-spender 의 abandonment — 매 LTV variance 폭증.
- **No segment pricing**: 매 single $4.99 starter pack — 매 explorer segment 의 conversion -40%.
## 🧪 검증 / 중복
- Verified (Habby / Voodoo / SuperPlay 의 industry blog + Sensor Tower 2024 hybrid-casual report).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Chef Universe hybrid-casual case study FULL content |
@@ -0,0 +1,178 @@
---
id: wiki-2026-0508-dynamic-pricing
title: Dynamic Pricing
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [동적 가격 책정, 변동 가격제, Surge Pricing]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [economics, pricing, monetization, ml]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python
framework: scikit-learn / XGBoost
---
# Dynamic Pricing
## 매 한 줄
> **"매 가격은 매 순간 다르다"**. 매 수요·재고·시간·세그먼트 signal 의 기반에서 매 price 가 매 real-time 의 조정. 매 Uber surge, 매 airline yield management, 매 2026 게임 IAP A/B price 의 mainstream.
## 매 핵심
### 매 입력 signal
- **수요 (Demand)**: 매 search volume, 매 conversion rate, 매 cart-add rate.
- **공급 (Supply / Inventory)**: 매 남은 stock, 매 server capacity.
- **시간 (Time)**: 매 hour-of-day, 매 day-of-week, 매 holiday.
- **사용자 segment**: 매 LTV tier, 매 churn risk, 매 region 의 PPP.
- **경쟁사 price**: 매 web scraping 의 competitor catalog.
### 매 알고리즘 family
- **Rule-based**: 매 if (inventory < 20%) then price *= 1.3.
- **Elasticity model**: 매 demand curve 의 fit → 매 revenue-maximizing point 의 추출.
- **Bandit / RL**: 매 contextual bandit 의 사용 — 매 explore vs exploit.
- **Deep learning**: 매 transformer 의 시퀀스 → 매 next-period price prediction.
### 매 응용
1. Airline / hotel yield management (매 origin domain).
2. Ride-sharing surge (Uber, Lyft).
3. E-commerce flash sale + personalized coupon.
4. Game IAP regional pricing + LTV tier offer.
## 💻 패턴
### Elasticity 추정 (log-log regression)
```python
import numpy as np
import statsmodels.api as sm
# price, qty observed across past promotions
log_p = np.log(prices)
log_q = np.log(quantities)
X = sm.add_constant(log_p)
model = sm.OLS(log_q, X).fit()
elasticity = model.params[1] # 매 typical -1.2 ~ -2.5
print(f"Price elasticity: {elasticity:.2f}")
```
### Revenue-maximizing price (constant elasticity)
```python
def optimal_price(cost, elasticity):
"""매 monopoly markup formula: P* = c * e/(e+1) for e<-1"""
if elasticity >= -1:
raise ValueError("Inelastic demand — revenue unbounded")
return cost * elasticity / (elasticity + 1)
print(optimal_price(cost=2.0, elasticity=-1.5)) # → 6.0
```
### Contextual bandit (LinUCB)
```python
import numpy as np
class LinUCB:
def __init__(self, n_arms, n_features, alpha=1.0):
self.alpha = alpha
self.A = [np.eye(n_features) for _ in range(n_arms)]
self.b = [np.zeros(n_features) for _ in range(n_arms)]
def select(self, context):
ucb = []
for a in range(len(self.A)):
A_inv = np.linalg.inv(self.A[a])
theta = A_inv @ self.b[a]
mu = context @ theta
sigma = self.alpha * np.sqrt(context @ A_inv @ context)
ucb.append(mu + sigma)
return int(np.argmax(ucb))
def update(self, arm, context, reward):
self.A[arm] += np.outer(context, context)
self.b[arm] += reward * context
```
### XGBoost demand forecaster
```python
import xgboost as xgb
import pandas as pd
features = ["price", "hour", "dow", "is_holiday", "competitor_price",
"inventory", "user_ltv_tier", "region_ppp"]
dtrain = xgb.DMatrix(df[features], label=df["units_sold"])
params = {"objective": "reg:squarederror", "max_depth": 6, "eta": 0.1}
model = xgb.train(params, dtrain, num_boost_round=300)
def expected_revenue(price, ctx):
ctx2 = {**ctx, "price": price}
qty = model.predict(xgb.DMatrix(pd.DataFrame([ctx2])))[0]
return price * qty
```
### Personalized price (LTV tier)
```python
def personalized_price(base_price, user):
tier = user["ltv_tier"] # "whale", "dolphin", "minnow"
region_factor = REGION_PPP[user["country"]] # 매 0.4 ~ 1.2
tier_factor = {"whale": 1.0, "dolphin": 0.85, "minnow": 0.6}[tier]
return round(base_price * region_factor * tier_factor, 2)
```
### Surge guardrails
```python
def safe_surge(base, raw_multiplier):
# 매 PR backlash 의 prevent
capped = min(raw_multiplier, 3.0)
floored = max(capped, 0.7)
return base * floored
```
### A/B price test (Bayesian)
```python
import numpy as np
from scipy.stats import beta
def bayesian_ab(buyers_a, visitors_a, buyers_b, visitors_b, n_sim=100_000):
a = beta(1 + buyers_a, 1 + visitors_a - buyers_a).rvs(n_sim)
b = beta(1 + buyers_b, 1 + visitors_b - buyers_b).rvs(n_sim)
return float(np.mean(b > a)) # 매 P(B > A)
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 stable demand, 매 cost-plus | Rule-based + manual ladder |
| 매 elastic, 매 abundant data | Elasticity model + grid search |
| 매 cold start, 매 many SKUs | Contextual bandit |
| 매 high-stakes (regulated) | Constrained optimization + audit log |
**기본값**: 매 elasticity model 의 시작, 매 enough data 의 수집 후 contextual bandit 의 graduate.
## 🔗 Graph
- 부모: [[게임 수익화 모델]]
- 변형: [[Surge Pricing]]
- 응용: [[IAP_In_App_Purchase]] · [[LiveOps]]
## 🤖 LLM 활용
**언제**: 매 elasticity 추정 의 EDA, 매 price ladder design, 매 A/B test 의 statistical analysis.
**언제 X**: 매 production pricing decision 의 single LLM call — 매 hallucination risk 의 too high.
## ❌ 안티패턴
- **Race-to-bottom**: 매 competitor 의 blind matching → margin collapse.
- **Surge backlash**: 매 cap 없는 multiplier → user trust 의 손상 (매 Uber NYE 8x 의 사례).
- **Personalization 의 leak**: 매 same item 의 different price 의 user-visible → fairness backlash.
- **Cold-start naïveté**: 매 new SKU 에 매 zero data 의 RL 의 직접 deploy → wild swing.
## 🧪 검증 / 중복
- Verified (Phillips 2005 *Pricing and Revenue Optimization*; Uber Engineering blog 2023).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content with elasticity, bandit, A/B patterns |
@@ -0,0 +1,161 @@
---
id: wiki-2026-0508-fortnite
title: Fortnite
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [포트나이트, Epic Games BR, Fortnite Battle Royale]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game, monetization, battle-pass, live-ops, case-study]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: C++ / Verse
framework: Unreal Engine 5
---
# Fortnite
## 매 한 줄
> **"매 game 의 platform 으로 transcend"**. 매 2017 launch 의 BR 의 도입, 매 cosmetics-only F2P 의 정착, 매 2024 UEFN/Verse 의 UGC platform 의 진화. 매 2026 의 Epic 의 metaverse-ish ambition 의 anchor.
## 매 핵심
### 매 monetization model
- **F2P + cosmetics-only**: 매 gameplay 의 power 의 NEVER sell — 매 P2W 의 explicit refusal.
- **V-Bucks**: 매 premium currency, 매 1 V-Buck ≈ $0.01.
- **Battle Pass**: 매 $9.50 (950 V-Bucks) / season, 매 100 tier 의 cosmetic reward.
- **Item Shop**: 매 daily-rotation 의 skin / emote / pickaxe.
- **Crew subscription**: 매 monthly $11.99 — 매 1000 V-Bucks + Crew Pack + current BP.
### 매 live-ops loop
- **Season**: 매 ~10주 cadence — 매 storyline + map change + new BP.
- **Chapter**: 매 ~2년, 매 fresh map.
- **Live event**: 매 in-game concert (Travis Scott, Marshmello), 매 movie tie-in (Marvel, Star Wars).
- **Collab**: 매 LeBron, 매 Goku, 매 John Wick — 매 brand crossover 의 weapon.
### 매 응용
1. F2P + cosmetics 의 industry standard 화 (Apex, Valorant).
2. Battle Pass 의 universal monetization primitive 화.
3. UEFN (Unreal Editor for Fortnite) 의 UGC platform pivot.
4. Verse language 의 Epic functional scripting 의 rollout.
## 💻 패턴
### Battle Pass progression (XP curve)
```python
def xp_for_tier(tier: int) -> int:
"""매 Fortnite-style flat-then-rise curve"""
if tier <= 100:
return 80_000 # 매 flat per tier
return 80_000 + (tier - 100) * 5_000 # post-100 escalation
def total_xp_for_full_pass():
return sum(xp_for_tier(t) for t in range(1, 101)) # 매 8M XP
```
### V-Bucks ledger (idempotent)
```python
from dataclasses import dataclass
from uuid import UUID
@dataclass
class VBucksTxn:
txn_id: UUID # 매 idempotency key
user_id: str
delta: int
reason: str # "purchase" | "battle_pass_reward" | "shop"
class Ledger:
def __init__(self, db):
self.db = db
def apply(self, txn: VBucksTxn) -> int:
with self.db.tx() as t:
if t.exists("vb_txn", txn.txn_id):
return t.balance(txn.user_id) # 매 retry-safe
t.insert("vb_txn", txn)
return t.adjust_balance(txn.user_id, txn.delta)
```
### Daily Item Shop rotation
```python
import random
from datetime import date
def daily_shop(seed_date: date, catalog: list[dict]) -> list[dict]:
rng = random.Random(seed_date.toordinal())
featured = rng.sample([c for c in catalog if c["rarity"] >= 3], 4)
daily = rng.sample([c for c in catalog if c["rarity"] < 3], 6)
return featured + daily
```
### Cosmetic-only invariant (compile-time check)
```typescript
type CosmeticOnly = {
category: "skin" | "emote" | "pickaxe" | "glider" | "wrap";
// 매 NO stat fields permitted
damage?: never;
health?: never;
speed?: never;
};
function listInShop(item: CosmeticOnly) { /* OK */ }
// 매 compile error: { category: "skin", damage: 10 }
```
### Verse (UEFN) gameplay snippet
```verse
# UEFN Verse — 매 functional logic device
my_device := class(creative_device):
OnBegin<override>()<suspends>:void=
Print("매 round start")
loop:
Sleep(60.0)
BroadcastEvent("매 60s tick")
```
### Concert event throughput (sharded)
```python
# 매 12M concurrent — 매 instance shard 의 사용
def shard_for_user(user_id: str, shard_size=60):
h = hash(user_id) & 0xFFFFFFFF
return f"concert-shard-{h // shard_size}"
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 BR genre, 매 mass market | Cosmetic-only F2P, 매 Fortnite playbook |
| 매 hardcore PvP | Skill-based, 매 cosmetics + season pass |
| 매 single-player | Premium + DLC, 매 live-ops X |
**기본값**: 매 cosmetic-only + battle pass + seasonal cadence — 매 modern multiplayer 의 default.
## 🔗 Graph
- 부모: [[게임 수익화 모델]] · [[LiveOps]]
- 응용: [[F2P]]
- Adjacent: [[Roblox]]
## 🤖 LLM 활용
**언제**: 매 game design retrospective, 매 monetization curve modeling, 매 collab pitch brainstorm.
**언제 X**: 매 actual UEFN Verse code 의 generation — 매 LLM 의 Verse training data 의 sparse.
## ❌ 안티패턴
- **Power creep cosmetic**: 매 "cosmetic" 이 hitbox 의 변경 → P2W leak.
- **Battle Pass FOMO**: 매 reward 의 too grindy → casual churn.
- **Collab fatigue**: 매 매 week 의 IP 의 dump → brand identity 의 dilute.
- **Concert overcommit**: 매 sharding 의 underestimate → server crash (매 2020 Travis Scott near-miss).
## 🧪 검증 / 중복
- Verified (Epic Games newsroom; Sensor Tower 2024 mobile gross; UEFN docs 2025).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Fortnite case study + Verse/UEFN snippet |
@@ -0,0 +1,174 @@
---
id: wiki-2026-0508-iaa-in-app-advertising
title: IAA (In-App Advertising)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [In-App Advertising, 인앱 광고, 광고 수익화]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [monetization, advertising, mobile, mediation]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Swift / Kotlin
framework: AdMob / AppLovin MAX / IronSource LevelPlay
---
# IAA (In-App Advertising)
## 매 한 줄
> **"매 attention 의 monetize"**. 매 ad 의 impression 의 currency, 매 eCPM 의 metric. 매 hyper-casual 의 lifeblood, 매 2026 의 mediation + waterfall + bidding 의 hybrid 의 mainstream.
## 매 핵심
### 매 ad format
- **Banner**: 매 320x50 / 320x100, 매 low eCPM ($0.10 ~ $1).
- **Interstitial**: 매 full-screen, 매 round 사이 ($3 ~ $15 eCPM).
- **Rewarded video**: 매 user opt-in, 매 highest eCPM ($15 ~ $50).
- **Native**: 매 in-content, 매 design 의 blend.
- **Playable**: 매 mini-game preview, 매 UA 와 monetization 의 dual.
- **Offerwall**: 매 multi-action reward (매 IronSource).
### 매 stack
- **SDK**: 매 AdMob, AppLovin MAX, IronSource LevelPlay, Unity Ads, Mintegral.
- **Mediation**: 매 multi-network 의 unified call.
- **Bidding (in-app)**: 매 real-time auction — 매 waterfall 의 replace.
- **Attribution**: 매 AppsFlyer, Adjust, Singular.
### 매 KPI
- **eCPM**: 매 effective CPM = revenue / impressions × 1000.
- **Fill rate**: 매 served / requested.
- **ARPDAU**: 매 ad revenue / DAU.
- **Show rate**: 매 placement 의 conversion.
### 매 응용
1. Hyper-casual / hybrid-casual 의 primary revenue.
2. F2P game 의 IAP 의 보완.
3. News / utility app 의 free tier monetization.
## 💻 패턴
### Rewarded video (AppLovin MAX, Swift)
```swift
import AppLovinSDK
class RewardedManager: NSObject, MARewardedAdDelegate {
let ad = MARewardedAd.shared(withAdUnitIdentifier: "REWARDED_UNIT")
override init() {
super.init()
ad.delegate = self
ad.load()
}
func show() {
if ad.isReady { ad.show() }
}
func didRewardUser(for ad: MAAd, with reward: MAReward) {
Wallet.add(coins: 100) // server-side validation
}
func didFailToDisplay(_ ad: MAAd, withError error: MAError) {
ad.load() // immediate retry
}
}
```
### Interstitial frequency cap
```kotlin
class InterstitialGate(private val minIntervalSec: Long = 60) {
private var lastShown = 0L
fun canShow(): Boolean {
val now = System.currentTimeMillis() / 1000
return now - lastShown >= minIntervalSec
}
fun markShown() { lastShown = System.currentTimeMillis() / 1000 }
}
```
### eCPM tracking + segment
```python
def ecpm(revenue: float, impressions: int) -> float:
return revenue / impressions * 1000 if impressions else 0.0
def segment_ecpm(events):
by_country = defaultdict(lambda: [0.0, 0])
for e in events:
by_country[e.country][0] += e.revenue
by_country[e.country][1] += 1
return {c: ecpm(r, n) for c, (r, n) in by_country.items()}
```
### Mediation waterfall config
```yaml
# 매 declining eCPM order
waterfall:
- network: applovin_bidding # 매 in-app bidding 의 highest priority
- network: admob
floor_ecpm: 25.0
- network: ironsource
floor_ecpm: 15.0
- network: unity_ads
floor_ecpm: 8.0
- network: backfill
floor_ecpm: 0.0
```
### Server-side reward validation
```python
@app.post("/ad/reward")
def reward(req: RewardCallback):
# 매 SHA256 signature 의 verify
expected = hmac.new(SECRET, req.payload(), "sha256").hexdigest()
if not hmac.compare_digest(expected, req.signature):
raise HTTPException(403)
if Cache.has(req.transaction_id): # 매 replay 의 prevent
return {"ok": True}
Cache.set(req.transaction_id, ttl=86400)
Wallet.credit(req.user_id, req.coins)
```
### Predicted LTV gating (no-ads for whales)
```python
def should_show_ad(user) -> bool:
if user.iap_total_usd > 50: # 매 whale 의 ad-free
return False
if user.predicted_ltv < 1.0:
return True
return random.random() < 0.7
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 hyper-casual | IAA dominant, 매 rewarded + interstitial |
| 매 mid-core | IAP primary + rewarded only |
| 매 utility / news | Native + interstitial sparingly |
**기본값**: 매 rewarded video + opportunistic interstitial + IAP whale 의 ad-free.
## 🔗 Graph
- 부모: [[게임 수익화 모델]]
- 응용: [[Hybrid-casual]]
- Adjacent: [[IAP]] · [[Attribution]]
## 🤖 LLM 활용
**언제**: 매 placement strategy 의 review, 매 eCPM anomaly 의 root cause hypothesis.
**언제 X**: 매 ad creative generation 의 단독 — 매 brand safety 의 human review 필수.
## ❌ 안티패턴
- **Forced interstitial**: 매 30s 의 frequency → D1 retention 의 collapse.
- **Misleading rewarded**: 매 reward 의 not delivered → ASO review 의 1-star.
- **Mediation neglect**: 매 single network → 매 30-50% revenue 의 손실.
- **Whale ad-spam**: 매 high-LTV user 의 ad 의 spam → IAP churn.
## 🧪 검증 / 중복
- Verified (AppLovin docs 2025; AppsFlyer State of Gaming 2024).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — IAA full reference with mediation + waterfall |
@@ -0,0 +1,196 @@
---
id: wiki-2026-0508-iap-in-app-purchase
title: IAP (In-App Purchase)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [In-App Purchase, 인앱 구매, 인앱 결제]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [monetization, purchase, ios, android, store]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Swift / Kotlin / Server (Node)
framework: StoreKit 2 / Google Play Billing v7
---
# IAP (In-App Purchase)
## 매 한 줄
> **"매 in-app 의 commerce 의 primitive"**. 매 Apple 30%, 매 Google 30% (small biz 15%) 의 take rate, 매 receipt 의 server validation 의 mandatory. 매 2026 의 StoreKit 2 + Play Billing v7 의 unified async API 의 mainstream.
## 매 핵심
### 매 product type
- **Consumable**: 매 gem, 매 coin pack — 매 multiple purchase.
- **Non-consumable**: 매 ad-removal, 매 unlock — 매 once 의 own.
- **Auto-renewable subscription**: 매 monthly / yearly.
- **Non-renewing subscription**: 매 fixed-term, 매 manual renew.
### 매 핵심 의 server validation
- **Receipt forwarding**: 매 client → server → Apple/Google verify endpoint.
- **JWS / signed transaction**: 매 StoreKit 2 의 JSON Web Signature.
- **Ledger**: 매 idempotent transaction id 의 dedup.
- **Webhook**: 매 App Store Server Notifications V2, 매 Real-time Developer Notifications.
### 매 KPI
- **ARPPU**: 매 average revenue per paying user.
- **Conversion rate**: 매 payer / DAU.
- **Whale concentration**: 매 top 1% 의 revenue 의 share (매 typical 50%).
### 매 응용
1. Game IAP (gem, energy, BP).
2. SaaS subscription (Spotify, Notion).
3. Content unlock (Kindle, comic).
## 💻 패턴
### StoreKit 2 (Swift) — purchase flow
```swift
import StoreKit
func buy(_ productID: String) async throws {
guard let product = try await Product.products(for: [productID]).first
else { throw IAPError.notFound }
let result = try await product.purchase()
switch result {
case .success(let verification):
let txn = try checkVerified(verification)
await deliver(txn)
await txn.finish()
case .userCancelled:
return
case .pending:
return
@unknown default:
return
}
}
func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
switch result {
case .unverified: throw IAPError.failedVerification
case .verified(let safe): return safe
}
}
```
### Server-side receipt verify (Node)
```typescript
import { verifyAppleReceipt } from "./apple";
app.post("/iap/verify", async (req, res) => {
const { jwsRepresentation, userId } = req.body;
const txn = await verifyAppleReceipt(jwsRepresentation);
if (await db.iapLedger.exists(txn.transactionId))
return res.json({ ok: true }); // 매 idempotent
await db.iapLedger.insert({
txnId: txn.transactionId,
userId,
productId: txn.productId,
purchaseDate: txn.purchaseDate,
});
await wallet.credit(userId, gemsForProduct(txn.productId));
res.json({ ok: true });
});
```
### Google Play Billing v7 (Kotlin)
```kotlin
val billingClient = BillingClient.newBuilder(context)
.setListener { result, purchases ->
if (result.responseCode == BillingResponseCode.OK) {
purchases?.forEach { handlePurchase(it) }
}
}
.enablePendingPurchases()
.build()
suspend fun launchPurchase(activity: Activity, productId: String) {
val products = billingClient.queryProductDetails(...)
val flow = BillingFlowParams.newBuilder()
.setProductDetailsParamsList(...)
.build()
billingClient.launchBillingFlow(activity, flow)
}
```
### Subscription state machine
```python
class SubState(Enum):
ACTIVE = "active"
GRACE = "grace" # 매 billing retry
HOLD = "hold"
CANCELED = "canceled"
EXPIRED = "expired"
def transition(current: SubState, event: str) -> SubState:
return {
(SubState.ACTIVE, "renewal_failed"): SubState.GRACE,
(SubState.GRACE, "renewed"): SubState.ACTIVE,
(SubState.GRACE, "exhausted"): SubState.HOLD,
(SubState.HOLD, "recovered"): SubState.ACTIVE,
(SubState.HOLD, "expired"): SubState.EXPIRED,
(SubState.ACTIVE, "user_cancel"): SubState.CANCELED,
}[(current, event)]
```
### Price ladder + LTV-aware offer
```python
LADDER = [0.99, 4.99, 9.99, 19.99, 49.99, 99.99]
def recommend_pack(user) -> float:
if user.iap_total_usd < 5: return 0.99
if user.iap_total_usd < 20: return 4.99
if user.iap_total_usd < 100: return 19.99
return 99.99
```
### Refund webhook handler
```typescript
app.post("/iap/webhook/apple", async (req) => {
const note = await decodeAppleNotification(req.body);
if (note.notificationType === "REFUND") {
await wallet.debit(note.userId, gemsForProduct(note.productId));
await ledger.markRefunded(note.transactionId);
}
});
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 native iOS/Android | StoreKit 2 / Play Billing v7 |
| 매 web | Stripe + 매 Apple/Google 의 외부 payment 의 EU DMA exception |
| 매 cross-platform | Receipt 의 backend 의 unified ledger |
**기본값**: 매 server-side verify mandatory — 매 client trust 절대 X.
## 🔗 Graph
- 부모: [[게임 수익화 모델]] · [[Subscription]]
- 응용: [[F2P]] · [[LiveOps]]
- Adjacent: [[IAA]]
## 🤖 LLM 활용
**언제**: 매 receipt parse 의 schema understanding, 매 subscription state machine 의 review.
**언제 X**: 매 cryptographic verify 의 LLM 의 implementation — 매 vendor SDK 의 사용.
## ❌ 안티패턴
- **Client-trust delivery**: 매 receipt validation 없이 reward — 매 piracy.
- **Non-idempotent ledger**: 매 retry 의 double credit.
- **Refund 의 ignore**: 매 customer refund 의 ledger 의 reflect 없이 → 매 negative balance.
- **Apple 30% 의 의 fight**: 매 3rd-party payment 의 hide → 매 ban risk (Epic v Apple 사례).
## 🧪 검증 / 중복
- Verified (StoreKit 2 docs 2025; Google Play Billing v7 release notes).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — IAP full reference with StoreKit 2 + Play Billing v7 |
@@ -0,0 +1,162 @@
---
id: wiki-2026-0508-play-and-earn
title: Play and Earn
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [P&E, Play to Earn 진화, Sustainable Play-and-Earn]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [monetization, web3, tokenomics, game-economy, play-and-earn]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: solidity
framework: hardhat
---
# Play and Earn
## 매 한 줄
> **"매 fun-first, earning은 byproduct"**. 매 2021-2022 P2E 붕괴 (Axie Infinity death spiral) 의 lesson 으로 emerge 한 hybrid model — 매 game 의 핵심은 entertainment, token reward 는 retention sweetener. 매 2026 sustainable Web3 game 의 dominant frame.
## 매 핵심
### 매 P2E vs P&E
- **P2E (2021)**: 매 earning 이 primary motivation. 매 grinding farm. 매 mercenary players → token dump → economy collapse.
- **P&E (2024+)**: 매 fun 이 primary. 매 token 은 long-term retention reward. 매 player base 의 50%+ 가 non-earners 이어도 ok.
- **결정적 차이**: 매 game 의 token 없으면 still fun? P&E = yes, P2E = no.
### 매 economic design pillars
- **Sink/Faucet ratio**: 매 token issuance ≤ token burn (장기 deflationary 또는 stable).
- **Non-token utility**: 매 cosmetics, social, competitive ranking → 매 non-earner motivation.
- **Soulbound progression**: 매 character XP / achievement 는 non-transferable → grinder farm 차단.
- **Skill gate**: 매 earning rate 가 player skill 에 비례 → bot resistance.
### 매 응용
1. Pixels (Ronin) — 매 farming-sim 으로 daily active 600k+ 유지 (2025).
2. Off the Grid (Avalanche) — 매 Battle royale, AAA quality, optional NFT.
3. Illuvium — 매 auto-battler + open world, token earning은 ranked play 에 한정.
## 💻 패턴
### Reward emission curve (deflationary)
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract PlayAndEarnReward {
uint256 public constant INITIAL_DAILY_EMISSION = 100_000 ether;
uint256 public constant HALVING_PERIOD = 180 days;
uint256 public immutable startTime;
constructor() { startTime = block.timestamp; }
function currentDailyEmission() public view returns (uint256) {
uint256 halvings = (block.timestamp - startTime) / HALVING_PERIOD;
if (halvings >= 10) return 0;
return INITIAL_DAILY_EMISSION >> halvings;
}
}
```
### Skill-gated earning
```typescript
function earnedTokens(matchResult: MatchResult): number {
const base = matchResult.won ? 10 : 2;
const skillMultiplier = Math.min(matchResult.mmr / 1500, 3.0);
const dailyCapRemaining = getDailyCapRemaining(matchResult.userId);
return Math.min(base * skillMultiplier, dailyCapRemaining);
}
```
### Soulbound progression
```solidity
contract SoulboundXP is ERC721 {
function _update(address to, uint256 tokenId, address auth)
internal override returns (address)
{
address from = _ownerOf(tokenId);
require(from == address(0) || to == address(0), "Soulbound: non-transferable");
return super._update(to, tokenId, auth);
}
}
```
### Sink: cosmetic burn
```typescript
async function craftCosmetic(userId: string, cosmeticId: string) {
const cost = COSMETIC_COSTS[cosmeticId];
await burnTokens(userId, cost);
await mintCosmetic(userId, cosmeticId);
await emitTelemetry({ type: 'sink_burn', amount: cost, source: 'cosmetic' });
}
```
### Non-token leaderboard
```typescript
interface SeasonReward {
rank: number;
cosmetic: string; // soulbound
tokenBonus?: number; // top 10% only
title: string; // permanent
}
```
### Anti-bot detection
```python
def is_likely_bot(user_session) -> float:
signals = {
'click_variance': click_timing_variance(user_session),
'movement_entropy': mouse_path_entropy(user_session),
'session_regularity': cron_like_score(user_session.history),
}
return weighted_sigmoid(signals)
```
### Emission throttle (treasury-controlled)
```solidity
function adjustEmission(uint256 newDaily) external onlyDAO {
require(newDaily <= currentDailyEmission() * 110 / 100, "Max +10%/epoch");
require(newDaily >= currentDailyEmission() * 90 / 100, "Max -10%/epoch");
dailyEmission = newDaily;
emit EmissionAdjusted(newDaily, treasuryRunwayDays());
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Casual mobile audience | Token-optional (P&E) |
| Hardcore competitive | Skill-gated earning |
| F2P with whales | 매 hybrid IAP + token reward |
| Pure speculation play | 매 avoid — P2E 함정 |
**기본값**: 매 P&E + skill-gate + soulbound progression.
## 🔗 Graph
- 변형: [[Free-to-Play]]
- Adjacent: [[LiveOps]]
## 🤖 LLM 활용
**언제**: 매 Web3 game economy design 시 — 매 sustainable token model 이 필요할 때.
**언제 X**: 매 traditional F2P (token 없이) — overkill.
## ❌ 안티패턴
- **Pure P2E**: 매 earning 이 fun 의 substitute. 매 mercenary churn → death spiral.
- **Unlimited token mint**: 매 inflation. 매 Axie SLP 의 답습.
- **Transferable XP**: 매 grinder farm. 매 Ronin botting outbreak.
- **No sink**: 매 token velocity 0. 매 price collapse.
## 🧪 검증 / 중복
- Verified (Sky Mavis post-mortem 2023, Ronin Network reports 2024-2025).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — P&E vs P2E 구분, sustainable design pillars 추가 |
@@ -0,0 +1,31 @@
---
id: wiki-2026-0508-게임-수익화-모델
title: 게임 수익화 모델
category: 10_Wiki/Topics
status: duplicate
canonical_id: game-monetization-models
duplicate_of: "[[Game Monetization Models]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, monetization, game-economy]
last_reinforced: 2026-05-10
github_commit: pending
---
# 게임 수익화 모델
> **이 문서는 [[Game Monetization Models]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 매 Premium, F2P + IAP, F2P + IAA, Hybrid, Subscription, P&E 의 6대 모델.
- 매 2026 dominant: 매 hybrid (IAP + IAA + battle pass).
## 🔗 Graph
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
@@ -0,0 +1,32 @@
---
id: wiki-2026-0508-디아블로-2-diablo-ii
title: 디아블로 2(Diablo II)
category: 10_Wiki/Topics
status: duplicate
canonical_id: diablo-ii
duplicate_of: "[[Diablo II]]"
aliases: []
source_trust_level: A
confidence_score: 0.9
verification_status: redirected
tags: [duplicate, diablo, game-economy, item-economy]
last_reinforced: 2026-05-10
github_commit: pending
---
# 디아블로 2(Diablo II)
> **이 문서는 [[Diablo II]] 의 중복본입니다.** Canonical 문서로 redirect.
## 핵심 요약
- 매 2000 Blizzard ARPG — 매 SoJ (Stone of Jordan) 기반 player-driven economy 의 archetypal case.
- 매 hyperinflation, dupe exploit, Resurrected (2021) 의 economy lesson.
## 🔗 Graph
- 부모: [[Diablo II]] (canonical)
## 🕓 변경 이력
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | 중복 처리 — canonical 문서로 redirect |
@@ -0,0 +1,131 @@
---
id: wiki-2026-0508-하이브리드-수익화-hybrid-monetization
title: 하이브리드 수익화 (Hybrid Monetization)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Hybrid Monetization, 하이브리드 수익화]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [hybrid, monetization, iap, iaa]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: python
framework: machinations
---
# 하이브리드 수익화 (Hybrid Monetization)
## 매 한 줄
> **"매 IAP + IAA segment 별 결합으로 LTV 극대화"**. 매 2026 모바일 dominant model — 매 hyper-casual 가 hybrid-casual 로 진화하면서 mainstream. 매 non-payer 는 ad-load 로 monetize, payer 는 IAP 로 friction-free experience 제공.
## 매 핵심
### 매 segment 전략
- **Non-payer (95%)**: rewarded video + interstitial.
- **Minnow (3%)**: starter packs, small IAP.
- **Whale (top 2%)**: high-value bundles, VIP, no-ads.
- **Mixed**: ad-removal IAP 로 transition path 제공.
### 매 KPI
- **ARPDAU**: IAP ARPDAU + ad ARPDAU 합산.
- **Ad LTV** vs **IAP LTV**: cohort 별 비교.
- **Cannibalization**: IAP 가 광고 매출을 잠식하는지 측정.
- **No-ads conversion**: ad-removal IAP rate.
### 매 응용
1. Royal Match: puzzle + ad + IAP combo.
2. Subway Surfers: 광고 중심 + cosmetic IAP.
3. Archero: IAA + IAP gem currency.
## 💻 패턴
### Segment-based ad load
```python
def ad_frequency(user):
if user.is_whale:
return 0 # no ads
if user.has_paid:
return 1 # rewarded only
return 3 # full ad load
```
### Dual revenue tracking
```python
def compute_arpdau(users, day):
iap_rev = sum(u.iap_today for u in users if u.active(day))
ad_rev = sum(u.ad_revenue_today for u in users if u.active(day))
dau = sum(1 for u in users if u.active(day))
return {
"iap_arpdau": iap_rev / dau,
"ad_arpdau": ad_rev / dau,
"total_arpdau": (iap_rev + ad_rev) / dau,
}
```
### Rewarded video offer
```python
class RewardedAd:
def show(self, user, reward):
if not ad_network.has_fill():
return None
ad_network.play(user)
user.grant(reward)
analytics.track("rewarded_complete", user, reward)
```
### A/B ad placement
```python
def assign_variant(user_id):
bucket = hash(user_id) % 100
return "high_load" if bucket < 50 else "low_load"
```
### Whale exclusion
```python
def should_show_ad(user, ad_type):
if user.lifetime_spend > 50:
return False
if ad_type == "interstitial" and user.session_seconds < 60:
return False
return True
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Hyper-casual | IAA-heavy, light IAP (ad removal) |
| Mid-core | IAP-primary + rewarded video |
| Casual puzzle | Hybrid 50/50 |
| Hardcore RPG | IAP-only, no ads |
**기본값**: hybrid + ad-removal IAP path.
## 🔗 Graph
- 부모: [[게임 수익화 모델]]
- 변형: [[하이브리드 캐주얼(Hybrid-Casual)]] · [[부분 유료화(Free-to-Play)]]
- 응용: [[인앱 구매(IAP)]] · [[인앱 광고(IAA)]]
- Adjacent: [[지불 용의 (Willingness to Pay)]] · [[고객 유지율(Retention)]]
## 🤖 LLM 활용
**언제**: hybrid monetization design, ad-IAP balance, segment 전략 질문.
**언제 X**: pure premium / 단일 model 게임.
## ❌ 안티패턴
- **Whale ad bombing**: 매 whale 에게 광고 노출 → churn risk.
- **Pre-monetization 0 ads**: 매 non-payer LTV = 0.
- **Cannibalization 무시**: 매 ad placement 가 IAP intent 잠식.
## 🧪 검증 / 중복
- Verified (Liftoff, AppLovin 2025 hybrid reports).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — hybrid monetization 정리 (segment 전략, dual ARPDAU) |
@@ -0,0 +1,138 @@
---
id: wiki-2026-0508-하이브리드-캐주얼-hybrid-casual
title: 하이브리드 캐주얼(Hybrid-Casual)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Hybrid-Casual, Hybrid Casual]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [hybrid-casual, monetization, mobile]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: csharp
framework: unity
---
# 하이브리드 캐주얼(Hybrid-Casual)
## 매 한 줄
> **"매 hyper-casual 의 wide funnel + casual 의 deep retention"**. 매 2022-2026 모바일 트렌드 — 매 install volume 은 hyper-casual 처럼 IAA 로 buy, 그러나 retention/monetization 은 casual 처럼 meta-game + IAP 로 deepen. 매 LTV/CPI ratio 가 hyper-casual 대비 3-5x 개선.
## 매 핵심
### 매 hyper vs hybrid 차이
- **Hyper-casual**: IAA only, D7 < 10%, LTV $0.20.
- **Hybrid-casual**: IAA + IAP, D7 20-30%, LTV $1-3.
- **Casual**: IAP-primary, D7 30-40%, LTV $5+.
### 매 핵심 요소
- **Core loop**: hyper-casual 수준의 simple, snackable.
- **Meta layer**: progression, characters, base building.
- **Monetization mix**: rewarded video + IAP (cosmetic / boost / no-ads).
- **Live-ops**: 이벤트, 시즌 패스 (간소화 버전).
### 매 응용
1. Royal Match: puzzle + decoration meta.
2. Match Factory: match-3 + factory progression.
3. Survivor.io: bullet hell + character/weapon meta.
## 💻 패턴
### Core loop + meta
```csharp
public class GameSession : MonoBehaviour {
public void RunLevel(int levelId) {
var result = playLevel(levelId);
if (result.success) {
metaProgression.AddXP(result.xpReward);
metaProgression.AddCoins(result.coinReward);
ShowRewardedAdOffer(result.coinReward * 2);
}
}
}
```
### Rewarded video doubling
```csharp
public void OfferDoubleReward(int baseAmount) {
rewardedAd.Show(success => {
if (success) {
wallet.Add(baseAmount); // already given
wallet.Add(baseAmount); // doubled via ad
}
});
}
```
### Meta progression
```csharp
public class Decoration {
public int unlockCost;
public int unlocksAtLevel;
public bool CanUnlock(Player p) =>
p.level >= unlocksAtLevel && p.coins >= unlockCost;
}
```
### Soft-currency funnel
```csharp
public int CoinsPerSession(Player p) {
int baseCoins = 100;
if (p.watchedRewardedAd) baseCoins *= 2;
if (p.hasBattlePass) baseCoins = (int)(baseCoins * 1.5f);
return baseCoins;
}
```
### Ad-removal IAP
```csharp
public class NoAdsIAP {
public void Purchase() {
IAP.Buy("no_ads_pack", () => {
PlayerPrefs.SetInt("no_ads", 1);
adManager.DisableInterstitials();
});
}
}
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Wide-funnel mobile | Hybrid-casual core |
| Mid-core RPG | 기존 casual 모델 |
| Premium console | 비적합 |
| Hyper-casual scaling | Hybrid 로 evolution |
**기본값**: simple core + meta layer + IAA-primary, IAP-augment.
## 🔗 Graph
- 부모: [[게임 수익화 모델]] · [[하이브리드 수익화 (Hybrid Monetization)]]
- 변형: [[하이브리드 캐주얼(Hybrid-casual)의 하이브리드 수익화 모델]]
- 응용: [[인앱 광고(IAA)]] · [[인앱 구매(IAP)]]
- Adjacent: [[고객 유지율(Retention)]]
## 🤖 LLM 활용
**언제**: hybrid-casual game design, hyper→hybrid evolution, meta layer 설계.
**언제 X**: hardcore RPG, console premium, pure hyper-casual.
## ❌ 안티패턴
- **Meta 없는 hyper**: 매 LTV 평탄.
- **Heavy IAP early**: 매 wide-funnel 망가뜨림.
- **Complex onboarding**: 매 hyper-casual install audience 가 churn.
## 🧪 검증 / 중복
- Verified (Voodoo / Supersonic 2025 hybrid-casual reports).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — hybrid-casual 정리 (core loop + meta, ad-IAP mix) |