---
id: wiki-2026-0508-rise-of-kingdoms
title: Rise of Kingdoms
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [RoK, ROK, 만국각성, Rise of Civilizations]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, mobile, 4X, F2P, monetization, live-ops]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Unity/C#
  framework: mobile MMO 4X
---

# Rise of Kingdoms

## 매 한 줄
> **"매 mobile-native 4X MMO — 매 server-as-game-world."**. Lilith Games 의 2018 release (originally Rise of Civilizations), 매 seamless world map 의 하나 server 의 thousands 의 players 의 simultaneous interact, 매 modern mobile 4X (State of Survival, Top War, Last War) 의 template 의 establishing.

## 매 핵심

### 매 design pillars
- **Seamless world map** — pinch-zoom continuous, 의 X tile-screen.
- **Civilization choice** — 11 civs (Rome, China, Korea, ...), unique commander + bonus.
- **Real-time march** — armies physically traverse map; ambush possible.
- **Alliance warfare** — KvK (Kingdom vs Kingdom) cross-server events.
- **Commander gacha** — RPG-style hero collection layered on 4X.

### 매 monetization layers
- Speedups (time skip currency).
- Resource bundles.
- Commander sculptures (gacha duplicates).
- VIP / pass progression.
- Whale-targeted "More than Gems" packs ($99+).

### 매 응용
1. F2P 4X mobile design reference.
2. Live-ops cadence model (KvK every 60 days, season pass).
3. Cross-server matchmaking architecture.
4. Mobile MMO retention case study.

## 💻 패턴

### March Time Calculation
```csharp
public static TimeSpan CalcMarchTime(Vector2 from, Vector2 to,
                                     float baseSpeed, float speedBuff) {
    float dist = Vector2.Distance(from, to);
    float effectiveSpeed = baseSpeed * (1f + speedBuff);
    return TimeSpan.FromSeconds(dist / effectiveSpeed);
}
```

### Commander Skill Tree
```csharp
public class CommanderSkill {
    public string Id;
    public int Level;       // 1..5
    public int MaxLevel = 5;
    public int[] CostPerLevel = { 0, 100, 300, 700, 1500, 3000 };

    public bool TryUpgrade(ref int sculptures) {
        if (Level >= MaxLevel) return false;
        int cost = CostPerLevel[Level + 1];
        if (sculptures < cost) return false;
        sculptures -= cost;
        Level++;
        return true;
    }
}
```

### Server (Kingdom) Tick Loop
```python
async def kingdom_tick(kingdom_id: int, dt_ms: int):
    """매 기본 simulation tick: resources, marches, buildings."""
    await update_resource_production(kingdom_id, dt_ms)
    await advance_marches(kingdom_id, dt_ms)
    await tick_building_queues(kingdom_id, dt_ms)
    await tick_research_queue(kingdom_id, dt_ms)
    await broadcast_chat_messages(kingdom_id)
```

### KvK Match-Making
```python
def matchmake_kvk(kingdoms: list[dict], group_size=8) -> list[list[int]]:
    """Sort by power, snake-draft into groups for parity."""
    sorted_k = sorted(kingdoms, key=lambda k: -k["power"])
    groups = [[] for _ in range(group_size)]
    for i, k in enumerate(sorted_k):
        idx = i % group_size if (i // group_size) % 2 == 0 \
              else group_size - 1 - (i % group_size)
        groups[idx].append(k["id"])
    return groups
```

### Speedup Inventory
```csharp
public class SpeedupInventory {
    public Dictionary<int, int> ByMinutes = new();   // 1, 5, 15, 60, 480, 1440

    public TimeSpan TotalAvailable() {
        long mins = 0;
        foreach (var (m, c) in ByMinutes) mins += (long)m * c;
        return TimeSpan.FromMinutes(mins);
    }

    public bool Apply(TimeSpan needed) {
        // greedy largest-first
        long remaining = (long)needed.TotalMinutes;
        foreach (var m in ByMinutes.Keys.OrderByDescending(x => x)) {
            int use = (int)Math.Min(ByMinutes[m], remaining / m);
            ByMinutes[m] -= use;
            remaining -= (long)use * m;
            if (remaining <= 0) return true;
        }
        return false;
    }
}
```

### Alliance Help Buff
```python
def alliance_help_reduction(active_helpers: int, building_time_s: int,
                            per_help_pct: float = 0.01,
                            cap_pct: float = 0.10) -> int:
    reduction = min(active_helpers * per_help_pct, cap_pct)
    return int(building_time_s * (1 - reduction))
```

### Whale Cohort Analytics
```python
def whale_cohort(payments: list[dict], threshold_usd=1000):
    by_user = {}
    for p in payments:
        by_user.setdefault(p["user_id"], 0)
        by_user[p["user_id"]] += p["amount_usd"]
    whales = {u: amt for u, amt in by_user.items() if amt >= threshold_usd}
    return {
        "whale_count": len(whales),
        "whale_revenue_share": sum(whales.values()) / sum(by_user.values()),
        "whale_arpu": sum(whales.values()) / max(len(whales), 1),
    }
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| New mobile 4X design | RoK/ToS 매 reference, 매 seamless map 의 default |
| Cross-server PvP | Power-tiered KvK matchmaking |
| F2P retention slump | Add commander gacha layer + season pass |
| Whale dependency too high | Add mid-spender bundles + battle pass |
| Server population decline | Migration / merger system |

**기본값**: 매 RoK template — seamless map + civ + commander gacha + alliance + KvK — 매 2026 mobile 4X 의 baseline.

## 🔗 Graph
- 부모: [[Game Design]] · [[Mobile Game Monetization]]
- 변형: [[State of Survival]] · [[Top War]] · [[Last War]]
- 응용: [[Live Ops Strategy]] · [[Gacha Design]] · [[Alliance Warfare]]
- Adjacent: [[4X Strategy]] · [[F2P Economy]] · [[KvK Matchmaking]]

## 🤖 LLM 활용
**언제**: NPC dialogue generation, alliance chat translation, in-game tutorial copy, customer support automation.
**언제 X**: 매 economy balance simulation 의 LLM 의 X — Monte Carlo + manual review 의 use; live game decision 의 LLM 의 unilateral 의 X.

## ❌ 안티패턴
- **Pay-to-win without skill**: pure spend 의 win 의 churn 의 mid-spender.
- **No KvK reset**: 매 stale top alliance 의 server 의 dominate → newcomer 의 X.
- **Speedup hoarding**: bundle 의 cheap speedups 의 inflation 의.
- **Commander power creep**: new commanders 의 obsolete 의 old whales 의 spend → backlash.
- **Single-server design**: cross-server event 의 X — 매 long-term retention 의 핵심 의 missing.

## 🧪 검증 / 중복
- Verified (Lilith Games official, Sensor Tower 2024/25 mobile reports).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — RoK design template + monetization patterns |
