14.1 各平台榜单结构

{
  "version": 1,
  "game": "merge-island",
  "observedAt": "2026-10",
  "note": "海外各平台榜单结构的可机读配置。口径是「公开可观察机制」的建模假设（观察时点 2026-10，非实测）：把各平台榜单的「排序信号」与「信号权重」整理成可机读的矩阵，不是任何平台后台的真实排序公式。signals 是六个可观察排序信号：playthrough=完播/通关、retention=D1 留存、session=单次时长、shares=分享、installs=安装、revenue=收入。每个平台一行，weights 六项之和恒 1000（千分比）；chartModel 是榜单口径（engagement 参与型 / click 点击型 / distribution 分发型 / store 商店型）；updateHours=榜单更新间隔小时、windowDays=统计窗口天数。candidates 是候选游戏在各信号上的取值（0–1000）。score(game,platform)=floor(Σ signal×weight/1000)。真实榜单排序与推荐机制需真实业务环境，命令行不可复现（X）。全整数，无浮点。",
  "signals": ["playthrough", "retention", "session", "shares", "installs", "revenue"],
  "platforms": [
    { "id": "poki", "name": "Poki", "chartModel": "engagement", "updateHours": 24, "windowDays": 30, "weights": { "playthrough": 280, "retention": 240, "session": 220, "shares": 120, "installs": 80, "revenue": 60 } },
    { "id": "crazygames", "name": "CrazyGames", "chartModel": "engagement", "updateHours": 24, "windowDays": 30, "weights": { "playthrough": 300, "retention": 230, "session": 200, "shares": 130, "installs": 80, "revenue": 60 } },
    { "id": "y8", "name": "Y8", "chartModel": "click", "updateHours": 12, "windowDays": 14, "weights": { "playthrough": 380, "retention": 170, "session": 120, "shares": 180, "installs": 100, "revenue": 50 } },
    { "id": "gamedist", "name": "GameDistribution", "chartModel": "distribution", "updateHours": 24, "windowDays": 30, "weights": { "playthrough": 180, "retention": 140, "session": 130, "shares": 100, "installs": 350, "revenue": 100 } },
    { "id": "appstore", "name": "App Store", "chartModel": "store", "updateHours": 3, "windowDays": 7, "weights": { "playthrough": 120, "retention": 180, "session": 150, "shares": 80, "installs": 250, "revenue": 220 } },
    { "id": "yt_playables", "name": "YouTube Playables", "chartModel": "engagement", "updateHours": 6, "windowDays": 21, "weights": { "playthrough": 200, "retention": 260, "session": 300, "shares": 140, "installs": 60, "revenue": 40 } }
  ],
  "candidates": [
    { "id": "merge-island", "name": "合成小岛", "signals": { "playthrough": 620, "retention": 540, "session": 700, "shares": 480, "installs": 300, "revenue": 260 } },
    { "id": "merge-farm", "name": "合成农场", "signals": { "playthrough": 700, "retention": 500, "session": 650, "shares": 520, "installs": 320, "revenue": 280 } },
    { "id": "idle-fish", "name": "放置钓鱼", "signals": { "playthrough": 560, "retention": 620, "session": 760, "shares": 300, "installs": 260, "revenue": 420 } },
    { "id": "puzzle-blocks", "name": "方块消除", "signals": { "playthrough": 780, "retention": 430, "session": 380, "shares": 350, "installs": 400, "revenue": 250 } },
    { "id": "bubble-pop", "name": "泡泡爆破", "signals": { "playthrough": 820, "retention": 400, "session": 340, "shares": 260, "installs": 380, "revenue": 220 } },
    { "id": "merge-dragon", "name": "合成龙岛", "signals": { "playthrough": 600, "retention": 580, "session": 680, "shares": 620, "installs": 280, "revenue": 360 } }
  ]
}

#!/usr/bin/env python3
# file: sim/g14_rank_scan.py
# tier: D
# verify: /opt/homebrew/bin/python3 sim/g14_rank_scan.py --config config/ --out out/
"""海外各平台榜单结构扫描（D 层：配置表 lint + 参考排序）。

读 config/g14_rank_structure.json，做两件事：

  1) lint：每个平台 weights 六项之和必须恒 1000；signals 与 candidates 的信号键必须对齐。
  2) 参考排序：对每个平台，按 score = floor(Σ signal×weight/1000) 给候选游戏打分排序，
     取 top-1，并算出信号集中度（dominant signal = 权重最大的信号）。

口径：榜单排序信号与权重是「公开可观察机制」口径的建模假设（观察时点 2026-10），
不是任何平台后台的真实排序公式；真实榜单排序与推荐机制需真实业务环境，命令行不可复现（X）。
与 core/src/g14/rank.ts 逐位等价，故 digest 逐字符一致。产出 out/g14_rank_scan.json + .csv。
全整数、地板除，无浮点。
"""
from __future__ import annotations

import argparse
import csv
import json
import os

WEIGHT_SUM = 1000


def score(signals: dict, weights: dict) -> int:
    """与 core/src/g14/rank.ts 的 score 逐位等价的加权分（0–1000，整数地板除）。"""
    acc = 0
    for k, w in weights.items():
        acc += signals[k] * w
    return acc // WEIGHT_SUM


def dominant_signal(weights: dict) -> str:
    """权重最大的排序信号；max 稳定取首个最大值（按 weights 插入顺序）。"""
    return max(weights, key=lambda k: weights[k])


def rank(cfg: dict, platform: dict) -> list[dict]:
    rows = [{"id": c["id"], "name": c["name"], "score": score(c["signals"], platform["weights"])}
            for c in cfg["candidates"]]
    # 分数降序，同分按 id 升序（稳定 tie-break）
    return sorted(rows, key=lambda r: (-r["score"], r["id"]))


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="config/")
    ap.add_argument("--out", default="out/")
    a = ap.parse_args()
    with open(os.path.join(a.config, "g14_rank_structure.json"), encoding="utf-8") as f:
        cfg = json.load(f)

    signals = cfg["signals"]
    # ---- lint ----
    lint_errs = []
    for p in cfg["platforms"]:
        s = sum(p["weights"].get(k, 0) for k in signals)
        if s != WEIGHT_SUM:
            lint_errs.append(f'{p["id"]} 权重和 {s} != {WEIGHT_SUM}')
        if set(p["weights"]) != set(signals):
            lint_errs.append(f'{p["id"]} 信号键与 signals 不一致')
    for c in cfg["candidates"]:
        if set(c["signals"]) != set(signals):
            lint_errs.append(f'{c["id"]} 信号键与 signals 不一致')

    # ---- 参考排序 ----
    per_platform = []
    for p in cfg["platforms"]:
        order = rank(cfg, p)
        per_platform.append({
            "id": p["id"], "name": p["name"], "chartModel": p["chartModel"],
            "updateHours": p["updateHours"], "windowDays": p["windowDays"],
            "dominantSignal": dominant_signal(p["weights"]),
            "topId": order[0]["id"], "topName": order[0]["name"], "topScore": order[0]["score"],
            "order": [{"id": r["id"], "score": r["score"]} for r in order],
        })
    digest = "|".join(f'{r["id"]}:{r["topId"]}:{r["topScore"]}' for r in per_platform)

    os.makedirs(a.out, exist_ok=True)
    with open(os.path.join(a.out, "g14_rank_scan.csv"), "w", encoding="utf-8", newline="") as f:
        w = csv.writer(f)
        w.writerow(["platform", "name", "chartModel", "dominantSignal", "candidate", "score", "rank"])
        for r in per_platform:
            for i, o in enumerate(r["order"]):
                w.writerow([r["id"], r["name"], r["chartModel"], r["dominantSignal"],
                            o["id"], o["score"], i + 1])
    rep = {"version": cfg["version"], "game": cfg["game"], "observedAt": cfg["observedAt"],
           "signals": signals, "platformCount": len(per_platform),
           "candidateCount": len(cfg["candidates"]), "lintErrors": lint_errs,
           "platforms": per_platform, "digest": digest}
    with open(os.path.join(a.out, "g14_rank_scan.json"), "w", encoding="utf-8") as f:
        json.dump(rep, f, ensure_ascii=False, indent=2)
    print(json.dumps({"digest": digest, "lintErrors": lint_errs,
                      "platforms": [{"id": r["id"], "chartModel": r["chartModel"],
                                     "dominantSignal": r["dominantSignal"],
                                     "topId": r["topId"], "topScore": r["topScore"]}
                                    for r in per_platform]}, ensure_ascii=False, indent=2))
    return 1 if lint_errs else 0


if __name__ == "__main__":
    raise SystemExit(main())

digest = poki:merge-dragon:575|crazygames:merge-dragon:574|y8:merge-farm:568|gamedist:merge-dragon:473|appstore:merge-dragon:477|yt_playables:merge-dragon:592

// file: core/src/g14/rank.ts
// tier: P
// verify: node --test 'core/test/g14_*.test.ts'
//
// 海外各平台榜单结构内核：与 sim/g14_rank_scan.py 逐位等价的 TypeScript 对偶实现。
// 读同一份 config/g14_rank_structure.json；全整数、无浮点、无随机、禁 Math.random。
// score(game,platform) = floor(Σ signal×weight/1000)；排序降序、同分按 id 升序。

export const WEIGHT_SUM = 1000;

export interface RawPlatform {
  readonly id: string; readonly name: string; readonly chartModel: string;
  readonly updateHours: number; readonly windowDays: number;
  readonly weights: Readonly<Record<string, number>>;
}
export interface RawCandidate {
  readonly id: string; readonly name: string;
  readonly signals: Readonly<Record<string, number>>;
}
export interface RankConfig {
  readonly version: number; readonly game: string; readonly observedAt: string;
  readonly signals: readonly string[];
  readonly platforms: readonly RawPlatform[]; readonly candidates: readonly RawCandidate[];
}
export interface RankedGame { readonly id: string; readonly name: string; readonly score: number }
export interface PlatformRank {
  readonly id: string; readonly name: string; readonly chartModel: string;
  readonly dominantSignal: string; readonly topId: string; readonly topScore: number;
  readonly order: readonly RankedGame[];
}

/** 加权分（0–1000，整数地板除）：与 sim/g14_rank_scan.py 的 score 逐位等价。 */
export function score(signals: Readonly<Record<string, number>>, weights: Readonly<Record<string, number>>): number {
  let acc = 0;
  for (const k of Object.keys(weights)) acc += signals[k] * weights[k];
  return Math.floor(acc / WEIGHT_SUM);
}

/** 权重最大的排序信号；并列时按 Object.keys 顺序取首个（与 Python dict 插入顺序一致）。 */
export function dominantSignal(weights: Readonly<Record<string, number>>): string {
  let best = ""; let bestW = -1;
  for (const k of Object.keys(weights)) {
    if (weights[k] > bestW) { best = k; bestW = weights[k]; }
  }
  return best;
}

/** 对单个平台排序：分数降序、同分 id 升序。 */
export function rank(cfg: RankConfig, platform: RawPlatform): RankedGame[] {
  const rows = cfg.candidates.map((c) => ({ id: c.id, name: c.name, score: score(c.signals, platform.weights) }));
  rows.sort((a, b) => (b.score - a.score) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
  return rows;
}

/** 全平台排序结果。 */
export function rankAll(cfg: RankConfig): PlatformRank[] {
  return cfg.platforms.map((p) => {
    const order = rank(cfg, p);
    return { id: p.id, name: p.name, chartModel: p.chartModel,
      dominantSignal: dominantSignal(p.weights), topId: order[0].id, topScore: order[0].score, order };
  });
}

/** 配置 lint：每个平台权重和必须恒 1000，信号键必须对齐。返回错误列表（空为通过）。 */
export function lint(cfg: RankConfig): string[] {
  const errs: string[] = [];
  for (const p of cfg.platforms) {
    let s = 0;
    for (const k of cfg.signals) s += p.weights[k] ?? 0;
    if (s !== WEIGHT_SUM) errs.push(`${p.id} 权重和 ${s} != ${WEIGHT_SUM}`);
    for (const k of cfg.signals) if (!(k in p.weights)) errs.push(`${p.id} 缺信号 ${k}`);
  }
  for (const c of cfg.candidates) for (const k of cfg.signals) if (!(k in c.signals)) errs.push(`${c.id} 缺信号 ${k}`);
  return errs;
}

/** 跨语言对拍摘要：与 sim/g14_rank_scan.py 的 digest 逐字符一致。 */
export function digest(cfg: RankConfig): string {
  return rankAll(cfg).map((r) => `${r.id}:${r.topId}:${r.topScore}`).join("|");
}

✔ 跨语言一致：TS 排序摘要 == Python 金标准
✔ 权重 lint 通过：每平台六项之和恒 1000，信号键对齐
✔ 可复现：两次排序结果逐位相同
✔ 口径决定谁上榜：点击型 Y8 的 top-1 与参与型平台不同
✔ 主导信号随榜单口径变：参与型看 playthrough/session，商店型看 installs
✔ 加权分与手工算一致：合成小岛在 Poki 上 = floor(Σ signal×weight/1000)
ℹ tests 6 / pass 6 / fail 0