11.1 消耗槽与养成消耗

# file: sim/ch11_sink_slots.py
# tier: S
# verify: python3 sim/ch11_sink_slots.py --config config/ --out out/
"""消耗槽盘点与养成回本时间：只读 buildings.json，算出各建筑各等级的升级成本表，
再用资源相对价值把「成本」与「产出」折算到同一单位，算边际/累计回本时间。只做消耗侧。
产出 out/ch11_sink_slots.json / ch11_upgrade_cost.csv / ch11_sink_inventory.csv / ch11_payback.svg"""
import argparse, csv, json, os, xml.etree.ElementTree as ET

C = ["#1f6feb", "#d97706", "#059669", "#9333ea"]

def load(d, n):
    with open(os.path.join(d, f"{n}.json"), encoding="utf-8") as f:
        return json.load(f)

def out_at(b, lv):
    return (b["outputBase"] * b["outputGrowthNum"] ** (lv - 1)) // b["outputGrowthDen"] ** (lv - 1)

def cost_at(b, lv):
    n, d = b["upgradeCostGrowthNum"] ** (lv - 1), b["upgradeCostGrowthDen"] ** (lv - 1)
    return {r: v * n // d for r, v in b["upgradeCostBase"].items()}

def tech_at(t, lv):
    n, d = t["growthNum"] ** (lv - 1), t["growthDen"] ** (lv - 1)
    return {r: v * n // d for r, v in t["costBase"].items()}

def cval(cost, val):
    return sum(v * val.get(r, 1) for r, v in cost.items())

def rows_of(buildings, val):
    rows = []
    for b in buildings["buildings"]:
        cum = 0
        for lv in range(1, b["maxLevel"]):
            cv = cval(cost_at(b, lv), val); cum += cv
            v = val[b["resource"]]; o1, o2 = out_at(b, lv) * v, out_at(b, lv + 1) * v
            rows.append({"building": b["id"], "resource": b["resource"], "level": lv, "toLevel": lv + 1,
                         "costWood": cost_at(b, lv).get("wood", 0), "costStone": cost_at(b, lv).get("stone", 0),
                         "costValue": cv, "outputPerHour": out_at(b, lv + 1), "outputValue": o2,
                         "marginalPaybackHours": cv // (o2 - o1) if o2 > o1 else -1,
                         "cumulativeCostValue": cum, "cumulativePaybackHours": cum // o2 if o2 else -1})
    return rows

def inventory(cfg, buildings):
    val, ref = cfg["resourceValue"], cfg["referenceDay"]
    daily = 0
    for b in buildings["buildings"]:
        daily += cval(cost_at(b, cfg["referenceLevels"][b["id"]]), val)
    tech = cval(tech_at(cfg["tech"], cfg["referenceTechLevel"]), val)
    def lin(base, count):
        return cval({r: v * count for r, v in base.items()}, val)
    return [("building-upgrade", daily), ("tech-research", tech),
            ("troop-training", lin(cfg["unitCost"], ref["trainUnits"])),
            ("march-supply", lin(cfg["marchPerHour"], ref["marchHours"])),
            ("healing", lin(cfg["healPerWounded"], ref["healWounded"])),
            ("trade-tax", ref["tradesPerDay"] * ref["tradeAvgValue"] * ref["taxPct"] // 100)]

def draw(path, rows):
    by = {}
    for r in rows:
        by.setdefault(r["building"], []).append(r["marginalPaybackHours"])
    hi = max(v for ys in by.values() for v in ys); W, H, pl, pt, pb, pr = 720, 320, 64, 28, 48, 24
    iw, ih = W - pl - pr, H - pt - pb
    svg = ET.Element("svg", {"xmlns": "http://www.w3.org/2000/svg", "viewBox": f"0 0 {W} {H}"})
    ET.SubElement(svg, "rect", {"width": str(W), "height": str(H), "fill": "#fff"})
    ET.SubElement(svg, "text", {"x": str(pl), "y": "18", "font-size": "14"}).text = "边际回本时间（小时）随等级变化"
    ET.SubElement(svg, "line", {"x1": str(pl), "y1": str(pt), "x2": str(pl), "y2": str(H - pb), "stroke": "#cbd5e1"})
    ET.SubElement(svg, "line", {"x1": str(pl), "y1": str(H - pb), "x2": str(W - pr), "y2": str(H - pb), "stroke": "#cbd5e1"})
    for i, (name, ys) in enumerate(by.items()):
        n = max(len(ys) - 1, 1)
        pts = " ".join(f"{pl + iw * j / n:.1f},{pt + ih * (1 - v / hi):.1f}" for j, v in enumerate(ys))
        ET.SubElement(svg, "polyline", {"points": pts, "fill": "none", "stroke": C[i % 4], "stroke-width": "2"})
        ET.SubElement(svg, "text", {"x": str(pl + 10 + i * 140), "y": str(H - pb + 22), "font-size": "12", "fill": C[i % 4]}).text = name
    os.makedirs(os.path.dirname(path), exist_ok=True)
    ET.ElementTree(svg).write(path, encoding="utf-8", xml_declaration=True)

def main():
    ap = argparse.ArgumentParser(); ap.add_argument("--config", default="config/"); ap.add_argument("--out", default="out/")
    a = ap.parse_args()
    cfg, bl = load(a.config, "ch11_sinks"), load(a.config, "buildings")
    rows, inv = rows_of(bl, cfg["resourceValue"]), inventory(cfg, bl)
    os.makedirs(a.out, exist_ok=True)
    cols = list(rows[0])
    with open(os.path.join(a.out, "ch11_upgrade_cost.csv"), "w", encoding="utf-8", newline="") as f:
        w = csv.writer(f); w.writerow(cols); [w.writerow([r[c] for c in cols]) for r in rows]
    with open(os.path.join(a.out, "ch11_sink_inventory.csv"), "w", encoding="utf-8", newline="") as f:
        w = csv.writer(f); w.writerow(["sink", "dailyValue"]); [w.writerow([k, v]) for k, v in inv]
    ly = [r for r in rows if r["building"] == "lumberyard"]
    summary = {"version": 1, "buildings": len(bl["buildings"]), "levelsPerBuilding": bl["buildings"][0]["maxLevel"] - 1,
               "lumberyardPaybackFirst": ly[0]["marginalPaybackHours"], "lumberyardPaybackLast": ly[-1]["marginalPaybackHours"],
               "sinkInventory": dict(inv), "totalDailyValue": sum(v for _, v in inv)}
    with open(os.path.join(a.out, "ch11_sink_slots.json"), "w", encoding="utf-8") as f:
        json.dump(summary, f, ensure_ascii=False, indent=2)
    draw(os.path.join(a.out, "ch11_payback.svg"), rows)
    print(json.dumps(summary, ensure_ascii=False))

if __name__ == "__main__":
    main()

// file: proto/src/ch11_sinks.ts
// tier: P
// verify: node --test 'proto/**/*.test.ts'
// 与 sim/ch11_sink_slots.py 同构：读同一份 buildings.json + ch11_sinks.json，
// 用 BigInt 整数幂算出升级成本表与回本时间，结果与 Python 侧逐位一致。

import { loadConfig, outputAtLevel, upgradeCostAtLevel, type BuildingDef } from "./core.ts";

interface SinksConfig {
  resourceValue: Record<string, number>;
  referenceLevels: Record<string, number>;
  referenceTechLevel: number;
  referenceDay: Record<string, number>;
  unitCost: Record<string, number>;
  marchPerHour: Record<string, number>;
  healPerWounded: Record<string, number>;
  tech: { maxLevel: number; costBase: Record<string, number>; growthNum: number; growthDen: number };
}

const cfg = () => loadConfig<SinksConfig>("ch11_sinks");

function ipow(base: number, exp: number): bigint {
  let acc = 1n; const b = BigInt(base);
  for (let i = 0; i < exp; i++) acc *= b;
  return acc;
}

function cval(cost: Record<string, number>, value: Record<string, number>): number {
  let s = 0;
  for (const [r, v] of Object.entries(cost)) s += v * (value[r] ?? 1);
  return s;
}

function techAt(t: SinksConfig["tech"], level: number): Record<string, number> {
  const n = ipow(t.growthNum, level - 1), d = ipow(t.growthDen, level - 1);
  const out: Record<string, number> = {};
  for (const [r, v] of Object.entries(t.costBase)) out[r] = Number((BigInt(v) * n) / d);
  return out;
}

export interface PaybackRow {
  building: string; level: number; costValue: number; outputPerHour: number;
  marginalPaybackHours: number; cumulativeCostValue: number; cumulativePaybackHours: number;
}

export function paybackRows(): PaybackRow[] {
  const c = cfg(), value = c.resourceValue;
  const rows: PaybackRow[] = [];
  for (const b of loadConfig<{ buildings: BuildingDef[] }>("buildings").buildings) {
    let cum = 0;
    for (let level = 1; level < b.maxLevel; level++) {
      const cv = cval(upgradeCostAtLevel(b, level), value); cum += cv;
      const v = value[b.resource] ?? 1;
      const o1 = outputAtLevel(b, level) * v, o2 = outputAtLevel(b, level + 1) * v;
      rows.push({
        building: b.id, level, costValue: cv, outputPerHour: outputAtLevel(b, level + 1),
        marginalPaybackHours: o2 > o1 ? Math.floor(cv / (o2 - o1)) : -1,
        cumulativeCostValue: cum, cumulativePaybackHours: o2 ? Math.floor(cum / o2) : -1,
      });
    }
  }
  return rows;
}

export function sinkInventory(): Record<string, number> {
  const c = cfg(), value = c.resourceValue, ref = c.referenceDay;
  const lin = (base: Record<string, number>, count: number) =>
    cval(Object.fromEntries(Object.entries(base).map(([r, v]) => [r, v * count])), value);
  let building = 0;
  for (const b of loadConfig<{ buildings: BuildingDef[] }>("buildings").buildings) {
    building += cval(upgradeCostAtLevel(b, c.referenceLevels[b.id] ?? 1), value);
  }
  return {
    "building-upgrade": building,
    "tech-research": cval(techAt(c.tech, c.referenceTechLevel), value),
    "troop-training": lin(c.unitCost, ref.trainUnits),
    "march-supply": lin(c.marchPerHour, ref.marchHours),
    "healing": lin(c.healPerWounded, ref.healWounded),
    "trade-tax": Math.floor((ref.tradesPerDay * ref.tradeAvgValue * ref.taxPct) / 100),
  };
}