2nd/10_Wiki/Topics/AI_and_ML/Rise of Kingdoms.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-rise-of-kingdoms	Rise of Kingdoms	10_Wiki/Topics	verified	self	RoK ROK 만국각성 Rise of Civilizations	none	A	0.9	applied	game-design mobile 4X F2P monetization live-ops		2026-05-10	pending	language framework Unity/C# 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

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

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

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

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

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

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

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
• Adjacent: 4X Strategy

🤖 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