ame: D.TOP_PLANE.name, kind: 'top' };
    if (pc.plane && pc.plane.indexOf('upper:') === 0) {
      var u = D.upperRealmById(pc.plane.slice(6));
      if (u) return { name: u.name, kind: 'upper', upper: u };
    }
    return { name: pc.world ? pc.world.name : '下界', kind: 'lower' };
  };

  /* ---------- 身份词条解释 ---------- */
  D.IDENTITY_GLOSSARY = {
    '游方僧': '没有固定寺院的僧人。靠化缘与替人做法事过活，走到哪算哪，不受宗门管，也没人护着。',
    '散修': '没有宗门、没有传承、没有靠山的修士。自由，但也意味着受伤没人治、死了没人埋。',
    '散修老怪': '在散修里熬了很多年的人。这个称呼说的是资历与手段，不是岁数。',
    '器物': '不是血肉之躯，是被人做出来的一具身体。做过什么、被谁丢下，往往记不全。',
    '妖族': '非人族血脉。在人族地界是二等生灵，出城要令牌，犯事罪加一等。',
    '诡异': '不属于这一界的东西。你在的时候，周围的规则会轻微地不对。',
    '人族': '血肉之躯，最常见，也最不受限——没有天赋，也没有诅咒。',
    '宗门弃徒': '被逐出师门的人。旧同门见面不认，旧仇家见面会笑。',
    '皇朝帝王': '一国之主。有兵、有税、有史官，也有无数人等着你死。',
    '药王': '炼丹、识药到极处的人。修士求你，凡人也求你，求你的人未必盼你好。',
    '掌门': '一宗之主。听着风光，其实是替全宗背因果的那个人。',
    '气运之子': '天道偏爱的那一个。奇遇会自己找上门，代价是所有人都想分你的气运。',
    '重生者': '死过一次，又从更早的某一天醒来。你知道一些还没发生的事。',
    '穿越者': '从另一个世界来的。你知道一些这个世界不该有人知道的事。',
    '系统绑定': '身上多了一个只有你能看见的东西，它给你任务，也给你代价。',
    '路人甲': '没有来历、没有故事的人。这既是保护，也是限制。',
    '背景板': '站在故事之外的人。你看见很多，参与很少。',
    '被夺舍之人': '身体里还住着另一个人的残识。它安静，但没有走。',
    '天道弃子': '天道不再看你。厄运不需要理由，好运也不需要。',
    '被放逐之人': '被赶出某地、某宗、某国的人。回去就是死罪。',
    '叛徒': '从原来那一方反出来的人。旧同伴见你会动手，新同伴也不会全信你。',
    '经验包': '别人拿来垫脚的称呼。意思是：你的故事不会太长，但会成全别人的故事。',
    '工具人': '别人需要你的时候你在，不需要的时候你不存在。',
    '炮灰': '冲在最前面、死得最早的那一批人。',
    '器灵转世': '你曾经是一件器物里的灵，如今有了人的身体。器物时代的记忆还在。',
    '剑修': '以剑入道的人。剑在人在，剑断人未必断。',
    '丹师': '以炼丹为业的人。修士求你，也防你。',
    '邪修': '走偏门的修士。功法快，代价大，正道见你就杀。',
    '魔修': '以魔气修行的人。不强求善恶，只强求活着。',
    '旁白': '你不参与故事，你只是把故事讲出来的人。',
    '商人': '做买卖的人。在修仙界，商人比修士更懂人心，也更懂什么时候该闭嘴。',
    '外神眷属': '你身上有外神留下的东西。它不常说话，但它一直在看。',
    '弑神者': '你杀过一个被称作神的东西。这件事没人敢提，但所有人都记得。',
    '凡人': '没有修为的普通人。活得短，但看得多。',
    '修士': '以修行求长生的人。走得远，但大多死在中途。'
  };
  D.explainIdentity = function (kind, term) {
    var t = String(term || '');
    if (D.IDENTITY_GLOSSARY[t]) return D.IDENTITY_GLOSSARY[t];
    if (kind === 'birth') {
      if (/人/.test(t)) return '血肉之躯，最常见，也最不受限。';
      if (/身|躯|体/.test(t)) return '你这具身体不是父母生的，是被人做出来或改出来的。';
      return '不是寻常出身。这件事在哪儿都瞒不住，也让你少了一些顾忌。';
    }
    if (kind === 'plight') {
      if (t.charAt(0) === '被') return '有人（或某种力量）正在对你做「' + t.slice(1) + '」这件事，你暂时摆脱不了。';
      if (t.indexOf('正在') === 0) return '你正处在「' + t.slice(2) + '」的过程里，还没走完。';
      if (t.indexOf('刚刚') === 0) return '「' + t.slice(2) + '」刚刚发生，余波还在，别人已经知道了。';
      if (t.indexOf('即将') === 0) return '「' + t.slice(2) + '」就快到了，你挡不住，只能准备。';
      return '这是你现在站的位置：' + t + '。';
    }
    if (kind === 'status') {
      if (/徒|子|孙|弟子/.test(t)) return '「' + t + '」是你在某个门派或势力里的位置。位置意味着靠山，也意味着管束。';
      if (/王|帝|皇|主|尊|圣/.test(t)) return '「' + t + '」是别人对你的尊称，通常意味着你手里有别人想要的东西。';
      if (/修|道|僧|尼|姑/.test(t)) return '「' + t + '」说的是你靠什么修行、靠什么吃饭。';
      return '「' + t + '」是这一带对你的称呼。它不解释你的过去，只说明别人怎么看你。';
    }
    if (kind === 'tag') {
      if (/经验|工具|炮灰|路人|背景|旁白|垫脚/.test(t)) return '这是个不太好听的称呼：在别人眼里，你是用来铺路的。';
      if (/之子|之女|之人|之身|之体/.test(t)) return '这是别人给你的一个说法：' + t + '。它不一定准确，但足够让陌生人对你多看一眼。';
      return '别人这样叫你，通常是因为你身上有一件藏不住的事。';
    }
    return '这是你的一个标签：' + t + '。';
  };

  /* ---------- 自创修炼体系 ---------- */
  D.CUSTOM_KEY = 'ddwj_custom_sys_v1';
  D.registerCustomSystem = function (sys) {
    if (!sys || !sys.ladder || sys.ladder.length !== 11) return null;
    D.SYSTEMS = D.SYSTEMS.filter(function (s) { return s.id !== 'custom'; });
    var full = {
      id: 'custom', name: sys.name || '自创体系', short: '创', upper: sys.upper || '自创上界',
      color: '#c6a86a', desc: sys.desc || '你自己写下的一条路。名字是你定的，规矩也是你定的。',
      custom: true, ladder: sys.ladder
    };
    D.SYSTEMS.push(full);
    return full;
  };
  D.loadCustomSystem = function () {
    try {
      var s = JSON.parse(localStorage.getItem(D.CUSTOM_KEY) || 'null');
      if (s && s.ladder && s.ladder.length === 11) D.registerCustomSystem(s);
    } catch (e) {}
  };
  D.saveCustomSystem = function (sys) {
    try { localStorage.setItem(D.CUSTOM_KEY, JSON.stringify(sys)); } catch (e) {}
    return D.registerCustomSystem(sys);
  };
  D.loadCustomSystem();

})();

</script>
<script>

/* ============================================================
   大道无界 —— 叙事外接层（LLM）
   设计原则：LLM 只负责"把已发生的事实写成叙事"，不参与规则判定。
   任何数值、得失、生死、因果都由本地引擎先算定，LLM 无权改动。
   两种接法：
     direct —— 浏览器直连 OpenAI 兼容接口，密钥存在本机 localStorage
     proxy  —— 浏览器只连代理，密钥放在服务端（tools/serve.js 或 Worker）
   ============================================================ */
window.LLM = (function () {
  'use strict';

  var KEY = 'ddwj_llm_v2';
  var DEFAULTS = {
    enabled: false,
    mode: 'direct',                 /* direct | proxy */
    base: 'https://api.deepseek.com/v1',
    model: 'deepseek-chat',
    key: '',
    proxy: '',
    proxyToken: '',
    temperature: 0.95,
    maxTokens: 700,
    freq: 'major',                  /* every | major */
    timeout: 45000,
    lastModel: '',
    lastError: ''
  };

  function cfg() {
    try {
      var o = JSON.parse(localStorage.getItem(KEY) || '{}');
      var out = {};
      for (var k in DEFAULTS) out[k] = (k in o) ? o[k] : DEFAULTS[k];
      return out;
    } catch (e) {
      var d = {}; for (var k2 in DEFAULTS) d[k2] = DEFAULTS[k2]; return d;
    }
  }
  function save(patch) {
    var o = cfg();
    for (var k in (patch || {})) o[k] = patch[k];
    try { localStorage.setItem(KEY, JSON.stringify(o)); } catch (e) {}
    return o;
  }
  function available() {
    var c = cfg();
    if (!c.enabled) return false;
    if (c.mode === 'proxy') return !!(c.proxy && c.proxy.trim());
    return !!(c.base && c.base.trim() && c.key && c.key.trim());
  }
  function endpoint(c) {
    if (c.mode === 'proxy') return c.proxy.trim().replace(/\/+$/, '');
    return c.base.trim().replace(/\/+$/, '') + '/chat/completions';
  }
  function headers(c) {
    var h = { 'Content-Type': 'application/json' };
    if (c.mode === 'proxy') {
      if (c.proxyToken) h['X-Proxy-Token'] = c.proxyToken;
    } else if (c.key) {
      h['Authorization'] = 'Bearer ' + c.key.trim();
    }
    return h;
  }

  /* ---------- 底层调用 ---------- */
  async function chat(messages, opts) {
    var c = cfg();
    if (!available()) return { ok: false, error: '未配置叙事引擎' };
    opts = opts || {};
    var body = {
      model: opts.model || c.model,
      messages: messages,
      temperature: (opts.temperature != null ? opts.temperature : c.temperature),
      max_tokens: opts.maxTokens || c.maxTokens,
      stream: false
    };
    var ctrl = new AbortController();
    var timer = setTimeout(function () { ctrl.abort(); }, c.timeout || 45000);
    try {
      var r = await fetch(endpoint(c), {
        method: 'POST',
        headers: headers(c),
        body: JSON.stringify(body),
        signal: ctrl.signal
      });
      var raw = await r.text();
      var data = null;
      try { data = JSON.parse(raw); } catch (e) {}
      if (!r.ok) {
        var msg = (data && data.error && (data.error.message || data.error)) || (raw || '').slice(0, 200) || ('HTTP ' + r.status);
        save({ lastError: String(msg) });
        return { ok: false, status: r.status, error: String(msg) };
      }
      if (!data) {
        save({ lastError: '返回不是 JSON' });
        return { ok: false, error: '返回不是 JSON' };
      }
      var text = data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
      if (!text) {
        save({ lastError: '返回中没有文本' });
        return { ok: false, error: '返回中没有文本' };
      }
      save({ lastModel: body.model, lastError: '' });
      return { ok: true, text: String(text), usage: data.usage || null, model: body.model };
    } catch (e) {
      var em = (e && e.name === 'AbortError') ? '请求超时' : (e && e.message) || '网络错误';
      save({ lastError: em });
      return { ok: false, error: em };
    } finally {
      clearTimeout(timer);
    }
  }

  /* ---------- 提示词 ---------- */
  var SYSTEM = [
    '你是《大道无界》的叙事者，负责把"已经发生的事实"写成第二人称（你）的中文修仙小说片段。',
    '铁律：',
    '1. 事实高于文采。数值、得失、生死、伤势、因果、人物关系必须以给定事实为准，不得增加、减少或改写。不得凭空给予机缘、物品、好感或境界。',
    '2. 不得解释规则，不得出现游戏术语（血量、属性、数值、系统、任务、面板、AI），不得出现现代词汇与网络用语。',
    '3. 不写内心独白式的总结，不写"他明白了""从此以后"这类收束句；情绪用动作、物件、环境传达。',
    '4. 180 到 320 字，2 到 4 段，每段 2 到 4 句。不写标题，不写小标题，不用 Markdown，不用括号注释。',
    '5. 结尾停在一个具体的细节或未解的悬念上，不要升华，不要点题。',
    '只输出正文。'
  ].join('\n');

  function buildMessages(ctx) {
    var facts = [
      '世界：' + (ctx.world || '') + '（' + (ctx.worldTag || '') + '）',
      '时代：' + (ctx.era || ''),
      '境界：' + (ctx.realm || '') + '｜年龄 ' + (ctx.age || '') + ' / 寿元 ' + (ctx.life || ''),
      '地点：' + (ctx.place || ''),
      '行动：' + (ctx.action || ''),
      '本地推演（事实骨架，可润色不可增删）：' + (ctx.facts || ''),
      '数值变化：' + (ctx.settle || '无'),
      '当前因果：' + (ctx.karma || '无'),
      '在场人物：' + (ctx.npc || '无'),
      '大劫阶段：' + (ctx.stage || ''),
      '状态：' + (ctx.state || '')
    ].join('\n');
    return [
      { role: 'system', content: SYSTEM },
      { role: 'user', content: facts + '\n\n按上述事实写这一段。' }
    ];
  }

  /* ---------- 对外 ---------- */
  async function narrate(ctx) {
    var c = cfg();
    var r = await chat(buildMessages(ctx), { temperature: c.temperature, maxTokens: c.maxTokens });
    if (r.ok) r.text = clean(r.text);
    return r;
  }
  function clean(t) {
    var s = String(t || '')
      .replace(/```[\s\S]*?```/g, '')
      .replace(/<[^>]+>/g, '')
      .replace(/^\s*#+\s*/gm, '')
      .replace(/\*\*/g, '')
      .replace(/\r/g, '')
      .trim();
    if (s.length > 1400) s = s.slice(0, 1400) + '…';
    return s;
  }
  async function test() {
    var r = await chat([{ role: 'user', content: '只回复两个字：可用' }], { maxTokens: 16, temperature: 0 });
    return r;
  }

  return {
    cfg: cfg, save: save, available: available, narrate: narrate, test: test,
    clean: clean, buildMessages: buildMessages, DEFAULTS: DEFAULTS
  };
})();

</script>
<script>

/* ============================================================
   大道无界 —— 叙事引擎（文笔控制协议 第四章）
   职责：岁月史书生成、感官细节、白描、金句、风闻、世界级叙事
   SECTION: narrative
   ============================================================ */
window.NARR = (function () {
  'use strict';
  var D = window.DATA;

  /* ---------- 工具 ---------- */
  function pick(rng, arr) { return arr[Math.floor(rng() * arr.length) % arr.length]; }
  function pickN(rng, arr, n) {
    var c = arr.slice(), out = [];
    while (out.length < n && c.length) out.push(c.splice(Math.floor(rng() * c.length), 1)[0]);
    return out;
  }
  function fill(t, map) {
    if (t == null) return '';
    if (typeof t !== 'string') t = (t.txt || t.text || t.desc || String(t));
    return t.replace(/\{(\w+)\}/g, function (_, k) { return (k in map && map[k] != null) ? map[k] : ''; });
  }
  /* 感官词去重池：单局内尽量不重复 */
  function sensePool(ctx) {
    var keys = Object.keys(D.SENSES);
    var used = ctx.usedSenses || (ctx.usedSenses = {});
    var out = [];
    keys.forEach(function (k) {
      var avail = D.SENSES[k].filter(function (w) { return used[w] !== 1; });
      if (avail.length < 3) { D.SENSES[k].forEach(function (w) { used[w] = 0; }); avail = D.SENSES[k].slice(); }
      out.push({ kind: k, words: avail });
    });
    return out;
  }
  function takeSense(pool, ctx, kind) {
    var p = pool.filter(function (x) { return x.kind === kind; })[0] || pool[0];
    var w = p.words.splice(Math.floor(Math.random() * p.words.length), 1)[0];
    if (w) ctx.usedSenses[w] = 1;
    return { kind: kind, word: w || '' };
  }

  /* SECTION: golden 金句生成器（公式：物象/动作 + 因果逻辑 + 升华留白） */
  function golden(ctx) {
    ctx.goldenCache = ctx.goldenCache || [];
    var bank = D.GOLDEN_BANK || [];
    if (!bank.length) return '';
    var obj = D.GOLDEN_OBJ ? D.GOLDEN_OBJ[ctx.rng_i % D.GOLDEN_OBJ.length] : '';
    ctx.rng_i = (ctx.rng_i * 31 + 7) % 100000;
    var s = '';
    var tangible = /剑|刀|丹|瓶|符|石|碑|井|环|茶|信|纸|镜|骨|匣|玉|炉|灯|印|绳|钟|门|碗|盏/.test(obj);
    for (var i = 0; i < 20; i++) {
      var tpl = bank[Math.floor(Math.random() * bank.length)];
      if (tpl.indexOf('{obj}') >= 0 && !tangible) continue;
      s = tpl.indexOf('{obj}') >= 0 ? fill(tpl, { obj: obj }) : tpl;
      if (ctx.goldenCache.indexOf(s) < 0) break;
    }
    if (!s) s = bank[0];
    ctx.goldenCache.push(s);
    if (ctx.goldenCache.length > 40) ctx.goldenCache.shift();
    return s;
  }

  /* SECTION: baimiao 白描句（禁止直接陈述情绪） */
  function baimiaoBank(obj) {
    var o = String(obj || '那件事');
    var concrete = /剑|刀|丹|瓶|符|石|碑|井|环|茶|信|纸|镜|骨|匣|玉|炉|灯|印|绳/.test(o);
    return concrete ? (D.BAIMIAO_CONCRETE || D.BAIMIAO) : (D.BAIMIAO_SAFE || D.BAIMIAO);
  }

  function baimiao(obj) {
    var o = String(obj || '那件事');
    var bank = baimiaoBank(o);
    var t = bank[Math.floor(Math.random() * bank.length)];
    /* 第二人称叙事：白描里的"他"指向玩家本人 */
    return fill(t, { obj: o }).replace(/他/g, '你');
  }

  /* SECTION: scene 场景段落构造
     原则：一句只写一件事。句子由完整模板 + 名词性物象拼成，
     不做"形容词随机灌入"，避免出现"苦涩的气息""嗡鸣的石头"这类病句。 */
  function uniqLine(ctx, bank, map) {
    ctx.sentCache = ctx.sentCache || [];
    if (!bank || !bank.length) return '';
    for (var i = 0; i < 12; i++) {
      var s = fill(bank[Math.floor(Math.random() * bank.length)], map || {});
      if (ctx.sentCache.indexOf(s) < 0) { ctx.sentCache.push(s); if (ctx.sentCache.length > 60) ctx.sentCache.shift(); return s; }
    }
    return fill(bank[0], map || {});
  }

  function scenePara(ctx, kind, subject) {
    var bank = (D.SCENE_BANK && (D.SCENE_BANK[kind] || D.SCENE_BANK.time)) || [];
    var props = (D.SCENE_PROPS && (D.SCENE_PROPS[kind] || D.SCENE_PROPS.time)) || ['门'];
    if (!bank.length) return '';
    var prop = props[Math.floor(Math.random() * props.length)];
    var s = uniqLine(ctx, bank, { place: ctx.place || '此处', time: ctx.timeStr || '', prop: prop });
    if (subject && Math.random() < 0.4) s += '你看着' + subject + '，没有动。';
    return s;
  }

  /* SECTION: chronicle 岁月史书
     结构：一处场景 → 发生了什么（引擎给的具体过程）→ 这件事的落点 →
           代价 / 未解 / 他人视角 → 白描 → 金句。
     不再用随机场景段凑字数：那会让整段读起来像词库打翻在地。 */
  function chronicle(ctx) {
    var paras = [];
    var scene = scenePara(ctx, ctx.kind, ctx.subject);
    if (scene) paras.push(scene);

    /* ② 事件主体（引擎生成的具体过程，权重最高） */
    var ev = ctx.event || {};
    if (ctx.resultTxt) paras.push(ctx.resultTxt);
    else {
      if (ev.lead) paras.push(ev.lead);
      if (ev.body) paras.push(ev.body);
      if (ev.after) paras.push(ev.after);
    }

    /* ③ 落点：这个行为在世界上留下了什么 */
    var cons = (D.CONSEQUENCE && (D.CONSEQUENCE[ctx.kind] || D.CONSEQUENCE.default)) || [];
    if (cons.length) paras.push(uniqLine(ctx, cons));

    /* ④ 代价 */
    if (ctx.costTxt) paras.push(/[。！？]$/.test(ctx.costTxt) ? ctx.costTxt : ctx.costTxt + '。');

    /* ⑤ 未解之谜 */
    if (ctx.blank) paras.push(ctx.blank);

    /* ⑥ 他人视角：优先用世界 TICK 的真实回响 */
    if (ctx.echo) {
      ctx.sentCache = ctx.sentCache || [];
      String(ctx.echo).split('。').map(function (s) { return s.trim(); }).filter(Boolean).slice(0, 3).forEach(function (c) {
        if (ctx.sentCache.indexOf(c) >= 0) return;
        ctx.sentCache.push(c);
        paras.push(c + '。');
      });
    }
    else if (D.CHORUS && Math.random() < 0.55) paras.push(uniqLine(ctx, D.CHORUS, { place: ctx.place }));

    /* ⑦ 白描（禁止直接陈述情绪），单局内不重复 */
    if (ctx.baideObj && Math.random() < 0.7) {
      var bm = uniqLine(ctx, baimiaoBank(ctx.baideObj), { obj: ctx.baideObj });
      if (bm) paras.push(bm.replace(/他/g, '你'));
    }

    /* ⑧ 若这一段太短，补一句同场景的另一件事（而非堆形容词） */
    if (totalLen(paras) < 180) {
      var extra = scenePara(ctx, Math.random() < 0.5 ? ctx.kind : 'time', null);
      if (extra) paras.push(extra);
    }

    /* ⑨ 金句收尾 */
    var g = golden(ctx);
    paras.push('<span class="golden">「' + g + '」</span>');

    return { html: paras.filter(Boolean).map(function (p) { return '<p>' + p + '</p>'; }).join(''), senses: 3, golden: g };
  }
  function totalLen(arr) {
    return arr.reduce(function (a, b) { return a + String(b || '').replace(/<[^>]+>/g, '').length; }, 0);
  }

  /* SECTION: rumor 修仙界风闻（真假概率 + 来源标注） */
  function makeRumor(G) {
    var rng = G.rng;
    var tpl = D.RUMOR_TPL[Math.floor(rng() * D.RUMOR_TPL.length)];
    var trust = D.RUMOR_TRUST[Math.floor(rng() * D.RUMOR_TRUST.length)];
    var pct = trust.range[0] + Math.floor(rng() * (trust.range[1] - trust.range[0] + 1));
    var src = D.RUMOR_SRC[Math.floor(rng() * D.RUMOR_SRC.length)];
    var txt = fill(tpl, {
      place: G.place(), faction: G.factionName(), realm: D.REALMS[Math.min(D.REALMS.length - 1, 3 + Math.floor(rng() * 4))].name
    });
    /* 真值：与可信度相关但不等同 */
    var real = rng() * 100 < pct + (rng() * 20 - 10);
    return {
      text: txt, trust: trust.name, trustCls: trust.cls, pct: pct, source: src,
      real: real, turn: G.turn, kind: '风闻', read: false,
      hint: trust.desc
    };
  }

  /* 大事件预告（每十回合强制推送，必须模糊、不确定、禁精确倒计时） */
  function makeBigForecast(G) {
    var rng = G.rng;
    var tpl = D.BIG_EVENT_TPL[Math.floor(rng() * D.BIG_EVENT_TPL.length)];
    var trust = D.RUMOR_TRUST[Math.floor(rng() * 3)];
    var pct = trust.range[0] + Math.floor(rng() * (trust.range[1] - trust.range[0] + 1));
    return {
      text: fill(tpl.txt, { place: G.place(), faction: G.factionName() }),
      trust: trust.name, trustCls: trust.cls, pct: pct,
      source: D.RUMOR_SRC[Math.floor(rng() * D.RUMOR_SRC.length)],
      real: rng() < 0.62, turn: G.turn, kind: '大事件预告', big: true,
      eventType: tpl.kind, weight: tpl.weight,
      dueTurn: G.turn + 20 + Math.floor(rng() * 40),
      hint: '预告禁止精确倒计时；这条可能是真的，也可能是有人故意放的。'
    };
  }

  /* SECTION: world-narrative 世界级叙事（大事件触发时，禁止主角视角独占） */
  function worldNarrative(G, ev) {
    var rng = G.rng;
    var place = G.place(), fac = G.factionName(), fac2 = G.factionName();
    while (fac2 === fac) fac2 = G.factionName();
    var lines = [];
    lines.push('<p class="wn-lead">【世界级叙事·' + ev.kind + '】</p>');
    lines.push('<p>' + pick(rng, [
      '那一日，' + place + '的天没有亮透。',
      '那一日，' + place + '起了雾，雾一直没散。',
      '那一日，' + place + '很安静，安静得不对。',
      '那一日的风是从' + place + '那边来的，带着灰。'
    ]) + '从山脊望出去，能看见' + fac + '的方向起了烟。烟升得很直，直得不像是烧出来的。' +
      pick(rng, ['风把烟压回了山头。', '烟在半空停住，然后散了。', '烟一直升到看不见为止。']) + '</p>');
    lines.push('<p>各方的反应几乎在同一刻发生：' + fac + '封了山门，护山大阵亮了三天三夜；' + fac2 + '把在外历练的弟子全部召回，召回令上盖的是掌门的血印；' + '凡人的城池开始征粮，征粮的告示贴到了土地庙的门板上，' + '庙里的和尚把告示撕了，第二天和尚不见了，告示又贴回来了。</p>');
    var npcLine = G.topNpcFor(ev.kind);
    if (npcLine) lines.push('<p>' + npcLine + '</p>');
    lines.push('<p>天象随之而变：' + pick(rng, ['灵气潮汐倒灌，三日不散', '连续七夜有红光横过北天', '地脉震荡，井水一夜之间降了三尺', '所有法器同时鸣响了一次，只一次', '界海的壁垒薄得能看见对面的影子']) + '。</p>');
    lines.push('<p>这件事的后果会持续很多年。' + pick(rng, [
      '后来的人们把这一年叫做"' + ev.kind + '之年"。',
      '此后的坊市上，' + place + '出产的东西没人敢收，也没人敢不收。',
      '史书写了一行，凡人记了一辈子，修士们假装没发生。',
      '有一批人在这一年死了，有一批人在这一年才真正活过来。'
    ]) + '</p>');
    if (G.pc && G.karmas && G.karmas.some(function (k) { return k.status === 'active' && k.strength >= 7; })) {
      lines.push('<p class="wn-you">而你，被卷了进去。不是因为你重要，是因为你正好站在那里，而你身上有几条线，另一头正好系在这件事上。</p>');
    }
    return lines.join('');
  }

  /* SECTION: montage 岁月蒙太奇 / 岁月如梭叙事 */
  function montage(G, years, settle) {
    var lines = [];
    lines.push('<p class="wn-lead">【岁月如梭·' + years + '年】</p>');
    lines.push('<p>' + [
      '时间在这里不按回合走。窗外的树落了' + years + '次叶，石阶上的苔痕淡了又深，你掌心的茧换了几层。',
      years + '年。这个数字说出来很短。你自己知道它有多长。',
      '你数过很多次日子，' + years + '年这个数，数到最后会失去意义。',
      '窗纸换了三次，屋顶修过两回。这些事你都没有亲手做，但你都看见了。'
    ][Math.floor(Math.random() * 4)] + '</p>');
    if (settle.npcChanges && settle.npcChanges.length) {
      lines.push('<p>这些年里，有人变了：</p><ul class="settle-list">' +
        settle.npcChanges.slice(0, 6).map(function (x) { return '<li>' + x + '</li>'; }).join('') + '</ul>');
    }
    if (settle.deaths && settle.deaths.length) {
      lines.push('<p>也有人没能走到今天：</p><ul class="settle-list death-list">' +
        settle.deaths.map(function (x) { return '<li>' + x + '</li>'; }).join('') + '</ul>');
    }
    if (settle.foreshadow && settle.foreshadow.length) {
      lines.push('<p>有些约定期限到了：</p><ul class="settle-list">' +
        settle.foreshadow.map(function (x) { return '<li>' + x + '</li>'; }).join('') + '</ul>');
    }
    lines.push('<p class="wn-brief">' + settle.brief + '</p>');
    return lines.join('');
  }

  /* SECTION: ember 余炽线（高潮后缓冲） */
  function ember(G, days) {
    var place = G.place();
    var lines = [];
    lines.push('<p class="ember-lead">【余炽·第 ' + days + ' 日】</p>');
    var bank = [
      '伤口在愈合。痒从骨头缝里往外冒，比痛更难忍。你把布条重新缠了一遍，缠到第三圈的时候手停住了——不是因为痛。',
      place + '的早晨很安静。你坐在门槛上，看远处有人在挑水，挑得很慢，桶里的水晃出来，在地上画了一条线。',
      '空气里有股味道，散不干净。坊市上疗伤的丹药涨了三成，卖丹的说是供不应求，买丹的没力气反驳。',
      '新来的弟子在山门外站着，眼睛里的东西你认得——是恐惧，压着，没敢露出来。你从他身边走过，没有说话。',
      '这几天没有人来找你。这很好，也不好。你把剑擦了一遍，又擦了一遍，第三遍的时候发现剑上其实没有东西。',
      '山下有人在议论。议论的内容有三个版本，其中两个和你有关，都不对。你没有下去解释。',
      '你把窗子推开一条缝。外面的天和昨天一样，云走得很快，快得像在赶什么事情。',
      '饭是冷的。你还是吃完了，吃得很慢。吃完之后你坐了一会儿，什么也没想。',
      '有人在门上留了一样东西，用布包着。你没有立刻打开。到了晚上，你还是没有打开。',
      '你数了数身上的伤，数到第五处的时候停了下来。第五处不疼了，这才是问题。'
    ];
    var seen = G.emberSeen = G.emberSeen || [];
    var avail = bank.filter(function (b) { return seen.indexOf(b) < 0; });
    if (!avail.length) { G.emberSeen = []; avail = bank; }
    var line = avail[Math.floor(Math.random() * avail.length)];
    G.emberSeen.push(line);
    lines.push('<p>' + line + '</p>');
    var bm = baimiao(pick(Math.random, ['那把剑', '那只空丹瓶', '墙上多出来的裂纹', '自己手背上的旧疤']));
    lines.push('<p>' + bm + '</p>');
    return lines.join('');
  }

  /* SECTION: bullet 子弹时间（关键战斗/顿悟/生死一瞬） */
  function bullet(G, txt) {
    return '<div class="bullet-time"><p class="bt-lead">【子弹时间】</p><p>' + txt + '</p></div>';
  }

  /* SECTION: monitor 天道监察叙事 */
  function monitorTxt(lv) {
    var m = D.MONITOR[lv] || D.MONITOR[0];
    var bank = {
      L1: '你没有感觉到什么。只是抬头的时候，天上有一片云的形状，和你昨天见过的那片一样。',
      L2: '后颈的汗毛立起来了。不是风，是一种被看着的感觉，从很高的地方，很有耐心地看下来。',
      L3: '香炉里的灰自己塌了一角。你听见了一声极轻的、类似秤杆归零的声音。',
      L4: '天空没有变色，也没有雷。这正是最不好的地方——它连警告都懒得给了。',
      L5: '你周围的一切开始变得不真实，像有人在很远的地方，用一根手指，按住了这一页纸。'
    };
    return { lv: m.lv, name: m.name, txt: bank[m.lv] || bank.L1 };
  }

  /* SECTION: backlash 天道反噬叙事 */
  function backlashTxt(level) {
    var bank = {
      micro: '行动失败了。你伸手去够那样东西，指尖离它还有半寸，半寸之间什么都没有了。资源散了一半，识海里亮起一行不属于你的字：【天道警示】。',
      mid: '你自己的力回来了。同样的角度、同样的力道，从反方向撞进来。你听见自己的肋骨发出一声闷响，道心上落了一层擦不掉的东西。',
      big: '某条你早已忘记的因果线突然绷直了。它一直在走，只是走得很慢。现在它到了。'
    };
    return bank[level] || bank.micro;
  }

  /* SECTION: 第三方截胡 */
  function interceptTxt(npc, thing) {
    var bank = [
      npc + '比你早到了半炷香。他看见你的时候没有意外，只是把' + thing + '收进了袖子，然后说："道友来得也巧。"',
      '你赶到时，' + thing + '已经不在原处了。地上的脚印是新的，方向你认得——那是' + npc + '的步子，他走路总是右脚重一点。',
      npc + '站在' + thing + '前面，背对着你。他没有回头，说："我知道你想要。我也想要。所以我们得谈谈，或者打一场。"',
      '有人比你更有资格拿这样东西。' + npc + '说这句话的时候，手里握着一块和你那块一模一样的信物。'
    ];
    return bank[Math.floor(Math.random() * bank.length)];
  }

  /* SECTION: 境界突破叙事 */
  function breakthroughTxt(realmName, sub, quality) {
    var q = quality >= 0.9 ? '天道在这一刻认真看了你一眼。' : (quality >= 0.6 ? '不算圆满，但确实过去了。' : '勉强算成，代价记在账上。');
    return '【突破·' + realmName + (sub ? ' ' + sub + '层' : '') + '】' + q;
  }

  /* SECTION: 死亡叙事 */
  function deathTxt(form, years) {
    var bank = {
      zhuanshi: '你活了' + years + '年。最后看见的东西不是光，是一张脸。然后那张脸也散了。',
      huagui: '你没有走。你站在自己的尸体旁边看了很久，然后发现阳光照不到你。',
      chenggui2: '疼过之后就不疼了。你低头看自己的手，手上多了不该有的东西。你想起来了：你以前处理过很多这样的。',
      rudao: '肉身先散，然后是神魂，然后是"你"这个概念。散完之后，风里多了一点什么。',
      guixu: '什么都没有留下。这是唯一真正干净的选择。'
    };
    return bank[form] || bank.zhuanshi;
  }

  /* SECTION: NPC 记忆回响（铁律四：记忆必须有声） */
  function npcMemoryTxt(npc, mem) {
    var bank = [
      npc.name + '握着你的手，眼眶微红："' + mem.summary + '……老夫至今记得。"',
      '"' + mem.summary + '。" ' + npc.name + '把茶盏放下，放得很轻，"这件事我一直没跟别人提过。"',
      npc.name + '看着你，看了很久，然后说："你可能不记得了。' + mem.summary + '。"',
      '"' + mem.summary + '，" ' + npc.name + '笑了一下，笑得不太自然，"这些年我总想起那天。"'
    ];
    return bank[Math.floor(Math.random() * bank.length)];
  }

  /* SECTION: 百艺反馈四段式 */
  function artFeedback(art, result, detail) {
    var proc = {
      '炼丹术': '炉火从橘红转青，药香先是' + pick(Math.random, ['清苦', '腥甜', '焦糊', '回甘']) + '，然后变成一种说不上来的味道。你数着火候，第七转的时候手稳了一下。',
      '炼器术': '锤落下去的节奏是七七四十九，第十四锤的时候金属发出' + pick(Math.random, ['金石交击', '一声闷响', '类似叹息的声音']) + '。淬火的水汽冲上来，糊了你半张脸。',
      '阵法术': '阵纹从中心往外走，走到第三个节点的时候停了一下。你补了一笔，它才继续。地上的石粉被灵气吹出一个圈。',
      '符箓术': '笔尖压住纸面的时候，符纸自己吸了墨。你画的最后一笔比前面所有笔都慢，慢到能听见纸纤维断裂的声音。',
      '御兽术': '它没有看你。它看的是你身后。过了很久，它把头低下去，低到你能看见它颈后的旧伤。',
      '机关术': '齿轮咬合的声音从里面传出来，一下，两下，然后停住。你把机核往里推了一寸，它重新转起来，转得比刚才顺。',
      '寻龙堪舆术': '罗盘的针抖了三抖，指向一个不该有东西的方向。你蹲下去，把手掌贴在地上，地是温的。',
      '商道': '秤星停在一个位置，对方的眼神在秤和你的脸之间来回。你没有说话，把货单往前推了一寸。',
      '医道': '指尖搭在腕上，脉象' + pick(Math.random, ['浮而散', '沉如石', '乱得像有人在里面走']) + '。你收了手，在方子上划掉了一味药。',
      '剑道': '剑没有出鞘。你只是站着，站了很久，然后对面的人后退了半步。',
      '诡道': '你听见它说话了。它用的不是声音，是直接在你识海里写字。字写得很难看。'
    };
    var res = {
      great: '【大成功】' + (detail || '') + ' 产出超出了你自己的预期，这东西拿出去会有人问你在哪学的。',
      ok: '【成功】' + (detail || '') + ' 符合预期，不多也不少。',
      barely: '【勉强成功】' + (detail || '') + ' 成品有瑕疵。瑕疵在第三道纹上，只有你自己看得出来——暂时。',
      fail: '【失败】材料毁了。' + (detail || '') + ' 炉子/器台/阵盘上留下一道洗不掉的痕。',
      greatfail: '【大失败】' + (detail || '') + ' 不只是失败。有东西被惊动了。'
    };
    var world = pick(Math.random, [
      '外面的风停了一瞬。',
      '远处有人抬头看了一眼你这个方向。',
      '地上留下一道' + pick(Math.random, ['暗红', '青绿', '几何状', '灰白']) + '的痕，短时间不会消。',
      '灵气往这边聚了一下，又散开。',
      '什么都没发生。这反而让人不安。'
    ]);
    return { proc: proc[art] || proc['炼丹术'], res: res[result] || res.ok, world: world };
  }

  /* SECTION: 道心冲突三级叙事模板 */
  function conflictTxt(level) {
    return {
      1: '你感到心中某根弦微微拨动，似有回响，又似错觉。炉火忽明忽暗了一下。',
      2: '两道意念在识海中激烈碰撞，你感到头痛欲裂，眼前浮现两个截然不同的身影。手抖了，咒诀念错了一个字。',
      3: '你的道心出现了一道裂缝，道蕴从裂缝中泄漏，你感到某种根本性的东西正在碎裂。天上有异象，路过的人都停下来了。'
    }[level] || '';
  }

  /* SECTION: 代价叙事模板 */
  function costTxt(level, what) {
    var lv = D.COST_LEVELS[level] || D.COST_LEVELS[0];
    var t = lv.txt[Math.floor(Math.random() * lv.txt.length)];
    return '【代价·' + lv.name + '】' + t + (what ? '——' + what : '');
  }

  /* SECTION: 自由输入解析反馈 */
  function freeParseReply(verb, obj, verdict) {
    if (verdict === 'reject') return '天道推演：这个行动超出了你当前的境界与处境。不是不许你做，是你现在做不到——你连它的门槛在哪里都看不见。';
    if (verdict === 'cost') return '天道推演：可以做。但你得先回答一个问题——你打算用什么来换。';
    return '天道推演：语义已解析。核心行为「' + (verb || '未知') + '」，对象「' + (obj || '未知') + '」。开始掷骰。';
  }

  /* SECTION: opening 第一章
     目标：读完这一段，玩家必须能回答三个问题——我是谁、我在哪、我接下来要做什么。
     顺序：定场 → 身份 → 世界/时代 → 代价 → 因果 → 眼前劫数 → 家底 → 可走的路 → 悬念。 */
  function openingChapter(G, opts) {
    var pc = G.pc, o = G.opening, r = G.rng || Math.random;
    var trib = o.tribulation || {};
    var place = trib.place || pc.lastPlace || '此地';
    if (!pc.lastPlace) pc.lastPlace = place;
    var hour = ['子时', '丑时', '寅时', '卯时', '辰时', '黄昏', '入夜', '五更'][Math.floor(r() * 8)];
    var paras = [];

    paras.push(fill(D.CHAPTER_OPENINGS[Math.floor(r() * D.CHAPTER_OPENINGS.length)], { place: place, hour: hour }));

    /* 我是谁 */
    var id = o.identity;
    var bRaw = String(id.birth || '');
    var line = '你是' + id.status + ((/(身|躯|体)$/.test(bRaw)) ? ('，' + bRaw + '。') : ('，' + bRaw + '之身。'));
    var birthNote = (function (b) {
      if (/器物|器灵/.test(b)) return '你不是血肉之躯——这具身体是被人做出来的，做它的人你从没见过。';
      if (/妖|诡|魔|麒麟|龙族|凤|兽/.test(b)) return '你不是人族，这件事瞒不住，也不必瞒。';
      if (/(身|躯|体)$/.test(b)) return '你这具身体不是血肉养出来的，疼起来的时候你才确定它还是你的。';
      if (/鬼|亡|魂/.test(b)) return '你早就死过一次，只是还没散干净。';
      if (/仙|神/.test(b)) return '你的血里有点不该属于凡人的东西。';
      if (/人/.test(b)) return '';
      return '你的出身在这一带不多见，别人一眼就能看出来。';
    })(String(id.birth || ''));
    if (birthNote) line += birthNote;
    if (/老怪|老祖|老魔|尊者|真君|大能/.test(String(id.status || '')) && pc.age < 40) {
      line += '「' + id.status + '」是别人叫出来的名号，不是你的岁数——你今年才' + Math.round(pc.age) + '岁。';
    }
    if (id.tag && id.tag !== '路人甲' && id.tag !== '背景板') line += '旁人提起你，会加一句“' + id.tag + '”。';
    line += '你现在的处境是——' + id.plight + '。这不是一句形容，是你脚下这三尺地。';
    if (/仙|圣|帝|祖|佛|皇|真人|大罗/.test(String(id.status || ''))) {
      line += '这个名号是别人叫出来的，也可能是你自己撑着的；按修为算，你现在只是' + D.REALMS[pc.realmIdx].name + '。';
    }
    if (pc.origin && pc.origin.desc) line += '你的来路：' + pc.origin.name + '。' + pc.origin.desc;
    paras.push(line);
    if (pc.bio && pc.bio.past) paras.push('往前数几年：' + pc.bio.past + '这件事你没有跟这里的人提过。');
    var sys0 = D.systemOf(pc);
    paras.push('你走的是' + sys0.name + '一途。' + sys0.desc + '你眼下停在「' + D.realmNameOf(pc, pc.realmIdx) + '」——' + D.realmDescOf(pc, pc.realmIdx));

    /* 我在哪 */
    paras.push('这里是' + pc.world.name + '，' + pc.world.tag + '。' + pc.world.desc);
    var eraBits = (o.era.desc || []).filter(Boolean).slice(0, 2).join('；');
    paras.push('你落脚的这一带，眼下是' + o.era.name + '：' + eraBits + '。还有几件事压在这一带头顶：' +
      o.states.map(function (s) { return s.name; }).join('、') +
      '。它们不是背景——你今天出门遇到的人，说话做事都带着它们的影子。');

    /* 这一带谁说话算数 */
    var facs = (G.factions || []).slice(0, 2);
    if (facs.length) {
      var facLine = '这一带说话算数的是' + facs.map(function (f) { return f.name + '（' + f.kind + '）'; }).join('与') + '。' + (facs[0].desc || '');
      var names = (G.npcs || []).slice(0, 3).map(function (n) { return n.fullName; });
      if (names.length) facLine += '你在路上听过几个名字：' + names.join('、') + '——还没打过交道，但名字已经进账了。';
      paras.push(facLine);
    }
    if (pc.bio && pc.bio.why) paras.push('你为什么在这里——' + pc.bio.why + '这个问题你问过自己不止一次，每次的答案都不太一样。');

    /* 代价 */
    var costs = (o.costs || []).map(function (c) { return c.txt; }).join('；');
    var flaws = (G.activeFlaws ? G.activeFlaws() : []).map(function (f) { return f.name; });
    if (costs || flaws.length) {
      paras.push('你身上背着代价：' + (costs || '') + (costs && flaws.length ? '；' : '') +
        (flaws.length ? '还有' + flaws.join('、') : '') +
        '。这些东西会真的发作，不是纸上的设定——血咒逢月圆索取，债务到日子催收，宿敌会自己找上门。');
    }

    /* 因果 */
    if (o.karmas && o.karmas.length) {
      paras.push('有些线早就系上了，你今天才看见它：' + o.karmas.map(function (k) {
        return '【' + k.name + '】' + (k.surface || k.desc || '');
      }).join(' '));
    }

    /* 眼前 */
    if (trib.txt) paras.push('眼下最要紧的是这件事——' + trib.txt + '你没有多少时间犹豫。');

    /* 家底 */
    var inj = D.INJURY_TYPES.filter(function (t) { return (pc.injury[t] || 0) > 0; })
      .map(function (t) { return t + '·' + D.INJURY_LEVELS[pc.injury[t]]; });
    paras.push('你现在的底子：' + D.REALMS[pc.realmIdx].name + '，' + Math.round(pc.age) + '岁，寿元约' +
      Math.round(pc.lifeMax) + '；身上' + Math.round(pc.money) + '枚灵石，精力' +
      (pc.energy >= 60 ? '还算够用' : pc.energy >= 25 ? '不多了' : '快见底') + '；' +
      (inj.length ? '道伤在' + inj.join('、') + '。' : '身上没有明显的伤。') +
      ((pc.items || []).length ? '随身的物件有' + pc.items.length + '件。' : '你身上没什么值钱的东西。'));

    /* 接下来做什么 */
    var dirs = (opts || []).filter(function (x) { return !x.free; }).slice(0, 3).map(function (x) {
      var t = String(x.text || '').replace(/^[^：:]{1,8}[：:]/, '').trim();
      return t.length > 36 ? t.slice(0, 36) + '…' : t;
    });
    if (dirs.length >= 2) {
      paras.push('你面前摆着几条路：你可以' + dirs[0] + '；也可以' + dirs[1] +
        (dirs[2] ? '；再或者，' + dirs[2] : '') + '。选哪条都不会有提示音告诉你对错——这是修仙界。');
    }

    paras.push(D.CHAPTER_HOOKS[Math.floor(r() * D.CHAPTER_HOOKS.length)]);

    var g = golden({ goldenCache: G.goldenCache || [], rng_i: (G.turn || 0) * 17 + 11 });
    return {
      title: (D.CHAPTER_TITLES || {})[trib.kind] || ('第一章 · ' + place),
      place: place,
      paras: paras.filter(Boolean),
      golden: g,
      plain: paras.filter(Boolean).join('\n\n')
    };
  }

  return {
    pick: pick, pickN: pickN, fill: fill, golden: golden, baimiao: baimiao,
    chronicle: chronicle, makeRumor: makeRumor, makeBigForecast: makeBigForecast,
    worldNarrative: worldNarrative, montage: montage, ember: ember, bullet: bullet,
    monitorTxt: monitorTxt, backlashTxt: backlashTxt, interceptTxt: interceptTxt,
    breakthroughTxt: breakthroughTxt, deathTxt: deathTxt, npcMemoryTxt: npcMemoryTxt,
    artFeedback: artFeedback, conflictTxt: conflictTxt, costTxt: costTxt,
    freeParseReply: freeParseReply, takeSense: takeSense, sensePool: sensePool,
    scenePara: scenePara, totalLen: totalLen, openingChapter: openingChapter
  };
})();


</script>
<script>

/* ============================================================
   大道无界 —— 天道引擎（核心规则推演层）
   对应文档：第一/二/三章全部系统
   本地确定性推演，不依赖任何外部 AI 接口
   SECTION: engine
   ============================================================ */
window.ENGINE = (function () {
  'use strict';
  var D = window.DATA, N = window.NARR;

  /* ---------- 随机 ---------- */
  function mulberry32(a) {
    return function () {
      a |= 0; a = a + 0x6D2B79F5 | 0;
      var t = Math.imul(a ^ a >>> 15, 1 | a);
      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
      return ((t ^ t >>> 14) >>> 0) / 4294967296;
    };
  }
  function clamp(v, a, b) { return v < a ? a : (v > b ? b : v); }
  function chance(r, p) { return r() < p; }

  /* ============================================================
     SECTION: game 主游戏对象
     ============================================================ */
  function Game(seed) {
    this.seed = seed || (Date.now() & 0x7fffffff);
    this.rng = mulberry32(this.seed);
    this.seedChain = [this.seed];
    this.turn = 0;
    this.year = 0;
    this.stage = 0;              /* 大劫九阶段 */
    this.pc = null;
    this.npcs = [];
    this.factions = [];
    this.karmas = [];
    this.foreshadow = [];        /* 未解伏笔 */
    this.rumors = [];
    this.bigEvents = [];         /* 大事件日历 */
    this.ticks = [];             /* 世界 TICK 日志 */
    this.settlements = [];       /* 因果结算表 */
    this.prices = {};
    this.priceHist = [];
    this.log = [];
    this.usedSenses = {};
    this.goldenCache = [];
    this.openFingerprints = [];  /* 开档防重复 */
    this.field = null;           /* 当前行为场 */
    this.brands = [];            /* 世界刻印 */
    this.daotitles = [];         /* 万古道碑 */
    this.mode = 'solo';
    this.rebellionCounter = 0;   /* 连续违背境界次数 → 天道反噬 */
    this.emberDue = 0;           /* 余炽线剩余 */
    this.highStreak = 0;         /* 连续高压回合 */
    this.worldBrand = null;
    this.daoLineage = null;      /* 道统 */
    this.over = false;
    this.overReason = '';
    this.nctx = { usedSenses: this.usedSenses, goldenCache: this.goldenCache, rng_i: 1 };
  }

  Game.prototype.sensePool = function () { return N.sensePool(this.nctx); };

  /* ---------- 通用取词 ---------- */
  Game.prototype.place = function () { return D.PLACES[Math.floor(this.rng() * D.PLACES.length)]; };
  Game.prototype.factionName = function () {
    if (this.factions && this.factions.length && chance(this.rng, 0.7)) return this.factions[Math.floor(this.rng() * this.factions.length)].name;
    return D.FACTION_TPL[Math.floor(this.rng() * D.FACTION_TPL.length)].n;
  };

  /* ============================================================
     SECTION: openfile 开档生成算法（V17 六步）
     ============================================================ */
  Game.prototype.genFingerprint = function (o) {
    return [o.identity.status, o.era.name, o.states.map(function (s) { return s.id; }).sort().join('+')].join('|');
  };

  Game.prototype.openFile = function (cfg) {
    /* cfg: {mode:'random'|'semi'|'keyword'|'custom', world, tianzi, origin, linggen, talents[], six{}, daohao, gender, age, goal, keywords[], custom} */
    var r = this.rng, tries = 0, o;
    do {
      o = this._buildOpening(cfg);
      tries++;
    } while (this.openFingerprints.indexOf(this.genFingerprint(o)) >= 0 && tries < 12);
    this.openFingerprints.push(this.genFingerprint(o));

    /* ---- 角色对象 ---- */
    var tz = cfg.tianzi || D.TIANZI[1];
    var lg = cfg.linggen;
    if (!lg || lg.id === 'random') {
      var pool = D.LINGGEN.filter(function (x) {
        return x.id !== 'random' && x.cat !== 'shenpin' && x.group !== '神品' && x.mult != null;
      });
      lg = pool[Math.floor(r() * pool.length)];
    }
    var og = cfg.origin;
    if (!og || og.id === 'random') og = D.ORIGINS.filter(function (x) { return x.id !== 'random'; })[Math.floor(r() * (D.ORIGINS.length - 1))];

    var realmIdx = 0, realmSub = 0;
    (cfg.talents || []).forEach(function (t) { if (t.effect && t.effect.startRealm) realmIdx = t.effect.startRealm; });

    var lifeMax = D.REALMS[realmIdx].life + (tz.mult - 1) * 20;
    var pc = {
      name: cfg.daohao || this._genName(),
      gender: cfg.gender || '男',
      age: cfg.age || 16,
      lifeMax: Math.max(20, Math.round(lifeMax)),
      race: o.identity.birth,
      status: o.identity.status,
      tag: o.identity.tag,
      plight: o.identity.plight,
      world: cfg.world || D.WORLDS[0],
      tianzi: tz,
      linggen: lg,
      origin: og,
      talents: cfg.talents || [],
      six: cfg.six || { '根骨': 3, '灵性': 3, '悟性': 3, '气运': 3, '魅力': 3, '心性': 3 },
      goal: cfg.goal || D.GOALS[3],
      realmIdx: realmIdx, realmSub: realmSub,
      qi: 0, qiNeed: D.REALMS[Math.min(realmIdx + 1, D.REALMS.length - 1)].need || 60,
      daoyun: 20 + Math.round(tz.mult * 10),
      hp: 100, hpMax: 100,
      money: 100,
      injury: { '肉身': 0, '神魂': 0, '因果': 0, '道基': 0 },
      pollution: 0,
      monitor: 0,
      costLevel: 0,
      bp: {},            /* 道途行为积分 */
      bpStage: {},
      bpLast: {},
      silent: {},
      arts: {},          /* 百艺 {id:{bp, level}} */
      items: [],
      bonds: {},
      reputation: 0,     /* 声誉场 */
      combat: 0,
      lastCultivate: -99,
      deathCount: 0,
      tabooUsed: [],
      daoTitle: null,
      lineage: cfg.keywords ? cfg.keywords.join('·') : null,
      freeCount: 0,
      energy: 100, energyMax: 100,
      timeLeft: 0        /* 本回合剩余时间单位 */
    };
    /* 六司：先天快照 + 后天增减槽（后天可增减，可突破初始上限） */
    pc.sixBase = {}; pc.sixBonus = {};
    for (var _sk in pc.six) { pc.sixBase[_sk] = pc.six[_sk]; pc.sixBonus[_sk] = 0; }
    /* 天资/灵根/天赋修正 */
    pc.cultMult = tz.mult * (lg.mult || 1);
    pc.luckFlat = (pc.six['气运'] - 3) * 4;
    pc.breakMult = 1;
    pc.tribMult = 1;
    pc.monitor = 0;
    pc.artMult = 1;
    pc.bondCap = 4;
    (cfg.talents || []).forEach(function (t) {
      var e = t.effect || {};
      if (e.luckFlat) pc.luckFlat += e.luckFlat;
      if (e.cultMult) pc.cultMult *= e.cultMult;
      if (e.breakMult) pc.breakMult *= e.breakMult;
      if (e.tribMult) pc.tribMult *= e.tribMult;
      if (e.monitor != null) pc.monitor = Math.max(pc.monitor, e.monitor);
      if (e.pollution) pc.pollution = Math.max(pc.pollution, e.pollution);
      if (e.artMult) pc.artMult *= e.artMult;
      if (e.bondCap) pc.bondCap = Math.min(pc.bondCap, e.bondCap);
      if (e.reputation) pc.reputation += e.reputation;
      if (e.life) pc.lifeMax = e.life;
      if (e.lifeMult) pc.lifeMult = e.lifeMult;
      if (e.daoInjury) for (var k in e.daoInjury) pc.injury[k] = Math.max(pc.injury[k], e.daoInjury[k]);
      if (e.art && !pc.arts[e.art]) pc.arts[e.art] = { bp: 0, level: 0 };
      if (e.money) pc.money += e.money;
      if (e.item) pc.items.push({ n: e.item, lv: 1 });
      if (e.gongfa) pc.gongfa = e.gongfa;
      if (e.noCombat) pc.noCombat = true;
      if (e.readMind) pc.readMind = true;
      if (e.system) pc.hasSystem = true;
      if (e.mindShield) pc.mindShield = true;
      if (e.crack) pc.crack = true;
    });
    if (og.grant) {
      var g = og.grant;
      if (g.six) for (var sk in g.six) pc.six[sk] = clamp((pc.six[sk] || 3) + g.six[sk], 1, D.SIX_MAX);
      if (g.money) pc.money += g.money;
      if (g.art && !pc.arts[g.art]) pc.arts[g.art] = { bp: 0, level: 0 };
      if (g.item) pc.items.push({ n: g.item, lv: 1 });
      if (g.gongfa) pc.gongfa = g.gongfa;
      if (g.pollution) pc.pollution = Math.max(pc.pollution, g.pollution);
      if (g.daoInjury) for (var dk in g.daoInjury) pc.injury[dk] = Math.max(pc.injury[dk], g.daoInjury[dk]);
      if (g.dao) pc.daoBias = g.dao;
    }
    /* 世界状态修正 */
    var qi = pc.world.qi;
    o.states.forEach(function (s) {
      var f = s.fx || {};
      if (f.qi) qi += f.qi;
      if (f.breakMult) pc.breakMult *= f.breakMult;
      if (f.tribMult) pc.tribMult *= f.tribMult;
      if (f.pollutionRate) pc.pollRate = (pc.pollRate || 0) + f.pollutionRate;
      if (f.noTrib) pc.noTrib = true;
    });
    pc.worldQi = qi;
    pc.hpMax = 80 + pc.six['根骨'] * 12 + D.REALMS[pc.realmIdx].base * 0.6;
    pc.hp = pc.hpMax;
    pc.combat = this.calcPower(pc);
    pc.timeLeft = 3;
    /* 人物生平：开局生成一次，侧栏可读，也供第一章使用 */
    var bioKind = (o.tribulation && o.tribulation.kind) || '';
    var whyPool = (D.WHY_HERE && (D.WHY_HERE[bioKind] || D.WHY_HERE['_'])) || [];
    pc.bio = {
      birth: o.identity.birth,
      originName: og ? og.name : '',
      originDesc: og ? og.desc : '',
      tag: o.identity.tag,
      plight: o.identity.plight,
      place: (o.tribulation && o.tribulation.place) || '',
      world: pc.world.name,
      why: whyPool.length ? whyPool[Math.floor(r() * whyPool.length)] : '你到这里，是为了活下去。',
      past: (D.BIO_PAST || [''])[Math.floor(r() * (D.BIO_PAST || ['']).length)],
      secret: (D.BIO_SECRET || [''])[Math.floor(r() * (D.BIO_SECRET || ['']).length)]
    };

    pc.systemId = (cfg.systemId && D.systemById(cfg.systemId).id) || (pc.world && pc.world.defaultSystem) || 'qi';
    pc.plane = 'lower';
    D.__activeSystem = pc.systemId;
    this.pc = pc;
    this.opening = o;
    this.year = 0;
    this.turn = 0;
    this.stage = 0;
    this._initWorld(o);
    this._initPrices();
    return o;
  };

  Game.prototype._genName = function () {
    var r = this.rng;
    return D.NPC_SUR[Math.floor(r() * D.NPC_SUR.length)] +
      D.NPC_GIVEN[Math.floor(r() * D.NPC_GIVEN.length)] +
      (chance(r, 0.5) ? D.NPC_GIVEN2[Math.floor(r() * D.NPC_GIVEN2.length)] : '');
  };

  /* 六步开档算法 */
  Game.prototype._buildOpening = function (cfg) {
    var r = this.rng;
    /* 第一步：世界基底 —— 时代四维编织 */
    var era = this._weaveEra(cfg);
    /* 世界状态 2~3 个叠加 + 逻辑自洽校验 */
    var states = this._pickStates(cfg, era);

    /* 第二步：身份四维动态组合 */
    var identity;
    if (cfg.mode === 'custom' && cfg.custom) {
      identity = { birth: cfg.custom.birth || '人族', status: cfg.custom.status || '散修', tag: cfg.custom.tag || '无名', plight: cfg.custom.plight || '身陷绝境', custom: true, text: cfg.custom.text };
    } else if (cfg.mode === 'keyword' && cfg.keywords && cfg.keywords.length) {
      identity = this._identityFromKeywords(cfg.keywords);
    } else {
      identity = {
        birth: D.IDENTITY_DIMS.birth[Math.floor(r() * D.IDENTITY_DIMS.birth.length)],
        status: D.IDENTITY_DIMS.status[Math.floor(r() * D.IDENTITY_DIMS.status.length)],
        tag: D.IDENTITY_DIMS.tag[Math.floor(r() * D.IDENTITY_DIMS.tag.length)],
        plight: D.IDENTITY_DIMS.plight[Math.floor(r() * D.IDENTITY_DIMS.plight.length)]
      };
    }
    /* 反套路元素：强制至少一个 */
    var anti = this._antiTrope(identity, era);
    identity.antiText = anti[0];

    /* 第四步前置：先天代价（禁止跳过代价） */
    var costs = [];
    var costN = 1 + (identity.tag === '气运之子' || identity.tag === '天生道体' ? 1 : 0) + (chance(r, 0.35) ? 1 : 0);
    var cp = D.INNATE_COSTS.slice();
    for (var i = 0; i < costN; i++) costs.push(cp.splice(Math.floor(r() * cp.length), 1)[0]);

    /* 第三步：因果线 1~3 条，部分隐藏真实面目 */
    var karmas = [];
    var kn = 1 + Math.floor(r() * 3);
    var kp = D.KARMA_POOL.slice();
    if (cfg.origin && cfg.origin.grant && cfg.origin.grant.karma) {
      var forced = kp.filter(function (x) { return x.name === cfg.origin.grant.karma; })[0];
      if (forced) { karmas.push(forced); kp.splice(kp.indexOf(forced), 1); kn--; }
    }
    for (var j = 0; j < kn && kp.length; j++) {
      karmas.push(kp.splice(Math.floor(r() * kp.length), 1)[0]);
    }
    karmas = karmas.map(function (k, idx) {
      var hiddenReal = k.hidden && chance(r, 0.6);
      return {
        id: k.id + '_' + idx, name: k.name, level: k.level, power: k.power,
        trigger: k.trigger, endings: k.endings, desc: k.desc,
        surface: hiddenReal ? this._surfaceMask(k) : null,
        realRevealed: !hiddenReal,
        relatedNpc: null, strength: k.power, status: 'active',
        createdTurn: 0, dueTurn: chance(r, 0.4) ? 30 + Math.floor(r() * 90) : null,
        inherited: false
      };
    }, this);

    /* 眼前劫数 */
    var trib = this._makeTribulation(identity, era, states);

    /* 第四步：开局场景（≥300字，≥2感官，白描，悬念，2~3行动方向） */
    var scene = this._writeOpeningScene(identity, era, states, costs, karmas, trib, cfg);

    return {
      identity: identity, era: era, states: states, costs: costs,
      karmas: karmas, tribulation: trib, scene: scene, anti: anti,
      fingerprint: null
    };
  };

  Game.prototype._weaveEra = function (cfg) {
    var r = this.rng;
    var law = D.ERA_DIMS.law[Math.floor(r() * D.ERA_DIMS.law.length)];
    var res = D.ERA_DIMS.resource[Math.floor(r() * D.ERA_DIMS.resource.length)];
    var cri = D.ERA_DIMS.crisis[Math.floor(r() * D.ERA_DIMS.crisis.length)];
    var pow = D.ERA_DIMS.power[Math.floor(r() * D.ERA_DIMS.power.length)];
    /* 组合校验：矛盾则调整 */
    var conflict = null;
    if ((law.k === '法则失效' && pow.k === '秩序井然')) { pow = D.ERA_DIMS.power.filter(function (x) { return x.k === '群龙无首'; })[0] || pow; conflict = '法则失效与秩序井然矛盾，已调整为群龙无首'; }
    if ((res.k === '资源匮乏' && pow.k === '商道凌驾')) { pow = D.ERA_DIMS.power.filter(function (x) { return x.k === '世家垄断'; })[0] || pow; conflict = '资源匮乏下商道难以凌驾，已调整为世家垄断'; }
    var name = law.k.slice(0, 2) + cri.k.slice(0, 2) + '之世';
    var nameBank = {
      '法则残缺+诡异横行': '末法诡劫时代', '法则完整+万族争霸': '诸天争锋盛世',
      '资源工业化+法则重写中': '机械飞升纪元', '法则失效+外神渗透': '天弃时代',
      '法则严苛+天道监视': '天律时代', '资源被污染+诡异横行': '浊世',
      '资源重置中+大劫酝酿': '余烬时代'
    };
    var key = law.k + '+' + cri.k;
    if (nameBank[key]) name = nameBank[key];
    else name = law.k.replace('法则', '') + cri.k.replace('横行', '').replace('争霸', '') + '之世';
    return {
      name: name, law: law, res: res, cri: cri, pow: pow, conflict: conflict,
      lawMult: law.v, resMult: res.v, dangerMult: cri.v, orderMult: pow.v,
      desc: [law.txt, res.txt, cri.txt, pow.txt]
    };
  };

  Game.prototype._pickStates = function (cfg, era) {
    var r = this.rng, out = [], pool = D.WORLD_STATES.slice();
    /* 世界自带状态优先 */
    if (cfg.world && cfg.world.states) {
      cfg.world.states.forEach(function (sn) {
        var s = pool.filter(function (x) { return x.name === sn; })[0];
        if (s) { out.push(s); pool.splice(pool.indexOf(s), 1); }
      });
    }
    var n = Math.max(2, Math.min(3, out.length + 1 + Math.floor(r() * 2)));
    var guard = 0;
    while (out.length < n && pool.length && guard < 40) {
      guard++;
      var s2 = pool[Math.floor(r() * pool.length)];
      /* 逻辑自洽校验：互斥不可共存 */
      var bad = false;
      D.STATE_EXCLUSIVE.forEach(function (pair) {
        if (pair.indexOf(s2.id) >= 0) {
          out.forEach(function (o) { if (pair.indexOf(o.id) >= 0) bad = true; });
        }
      });
      if (era.law.k === '法则严苛' && s2.id === 'shuimian') bad = true;
      if (era.res.k === '资源充沛' && s2.id === 'tongshuo') bad = true;
      if (bad) { pool.splice(pool.indexOf(s2), 1); continue; }
      out.push(s2); pool.splice(pool.indexOf(s2), 1);
    }
    return out.slice(0, 3);
  };

  Game.prototype._antiTrope = function (identity, era) {
    /* 强制反套路：天才+盛世+灵气充沛+天命之子 组合禁止 */
    var anti = [];
    if (identity.tag === '气运之子' && era.res.v >= 1.1) { anti.push('你是气运之子，但生在资源匮乏的年头，天道给的偏爱你未必接得住'); }
    if (identity.tag === '天生道体' && era.law.k === '法则失效') { anti.push('你天生道体，但天道已经不管事了——没人给你降福，也没人给你降劫'); }
    if (identity.status === '宗门弃徒' && era.pow.k === '秩序井然') { anti.push('秩序井然的时代，被逐出宗门意味着你连当恶人的资格都没有'); }
    if (identity.birth === '器物' && era.pow.k === '财阀割据') { anti.push('你是一件器物成了人形，而这个时代把一切都标了价'); }
    if (!anti.length) {
      var bank = [
        '你看起来像个天才，但你的天资有一处说不清的缺口',
        '你出身微末，却握着一件不属于你这个层级的东西',
        '你处在盛世，但你所在的那一隅正在烂掉',
        '你身负大气运，但气运的账单已经寄出',
        '你什么都不特殊——这在这个时代反而最危险'
      ];
      anti.push(bank[Math.floor(this.rng() * bank.length)]);
    }
    return anti;
  };

  /* 关键词开档：关键词必须在因果网中有明确锚点 */
  Game.prototype._identityFromKeywords = function (kws) {
    var r = this.rng;
    var kwText = kws.join(' ');
    var pick = function (arr, fallback) {
      for (var i = 0; i < arr.length; i++) if (kwText.indexOf(arr[i]) >= 0) return arr[i];
      return fallback;
    };
    /* 出身维度锚定 */
    var birth = D.IDENTITY_DIMS.birth[Math.floor(r() * D.IDENTITY_DIMS.birth.length)];
    if (/妖|兽|狐|龙/.test(kwText)) birth = '妖族';
    else if (/器|剑灵|物灵|刀/.test(kwText)) birth = '器物';
    else if (/诡|鬼|邪|尸/.test(kwText)) birth = '诡异';
    else if (/穿越|现代|地球|都市/.test(kwText)) birth = '跨界者';
    /* 社会地位锚定 */
    var status = pick(D.IDENTITY_DIMS.status, D.IDENTITY_DIMS.status[Math.floor(r() * D.IDENTITY_DIMS.status.length)]);
    if (/剑/.test(kwText) && status !== '剑客') status = '宗门弃徒';
    if (/商|账|钱/.test(kwText)) status = '账房';
    if (/医|丹|药/.test(kwText)) status = '药师';
    /* 特殊标签锚定 */
    var tag = pick(D.IDENTITY_DIMS.tag, D.IDENTITY_DIMS.tag[Math.floor(r() * D.IDENTITY_DIMS.tag.length)]);
    if (/重生|重来|上辈子/.test(kwText)) tag = '重生者';
    else if (/失忆|忘/.test(kwText)) tag = '被遗忘之人';
    else if (/系统|面板/.test(kwText)) tag = '系统宿主';
    else if (/天命|气运/.test(kwText)) tag = '气运之子';
    /* 初始困境锚定 */
    var plight = pick(D.IDENTITY_DIMS.plight, D.IDENTITY_DIMS.plight[Math.floor(r() * D.IDENTITY_DIMS.plight.length)]);
    if (/复仇|报仇|仇/.test(kwText)) plight = '被追杀';
    else if (/囚|牢|困/.test(kwText)) plight = '被囚禁';
    else if (/背叛|叛/.test(kwText)) plight = '被背叛';
    return { birth: birth, status: status, tag: tag, plight: plight, keywords: kws };
  };

  Game.prototype._surfaceMask = function (k) {
    var bank = {
      '救命之恩': '一个陌生人在你快死时救了你，分文未取。',
      '气运之争': '你总觉得自己运气不错，好得不太正常。',
      '血脉之咒': '你身上有块胎记，形状每月变一点。',
      '轮回之缘': '你反复梦见一张脸，醒来只记得对方在哭。',
      '井中之物': '谷里那口井，你从小就不许靠近。',
      '被注视者': '最近总有人在你门口站着，看见你就走。',
      '背叛之约': '有人每月给你送一笔钱，从不说是谁。',
      '宿命之敌': '有个名字你莫名熟悉，却想不起在哪听过。',
      '天道之契': '你偶尔能听见很远的地方有人在说话。',
      '账簿之谜': '库房里有本账，上面的字每天都不一样。'
    };
    return bank[k.name] || '有些线头你看得见，但拽不动，也不知道另一头系着什么。';
  };

  Game.prototype._makeTribulation = function (identity, era, states) {
    var r = this.rng;
    var place = this.place(), fac = this.factionName();
    var bank = [
      { txt: '三日后是「血月祭」，' + place + '历代守者的冤魂将集体索祭。你需要在祭典前找到出路，否则你就是下一个祭品。', days: 3, kind: '祭典' },
      { txt: fac + '的年度盘点即将开始，你负责的那批货里，有一件账上没有的东西。', days: 7, kind: '盘点' },
      { txt: '追杀你的人已经在路上。三拨，走的是三条不同的路，最快的一拨还有五日。', days: 5, kind: '追杀' },
      { txt: place + '的灵脉正在枯竭，七日之后彻底断流。断了以后，这里的人活不过一个冬天。', days: 7, kind: '灵脉' },
      { txt: '有人在' + place + '设了一场局，局的名字叫"论道"，实际上是分赃。你被列在了名单上——至于是分的那份还是被分的那份，还不知道。', days: 10, kind: '论道' },
      { txt: '你身上的东西开始发作了。第一次是昨夜，第二次不会太久。', days: 4, kind: '发作' },
      { txt: fac + '与另一方的谈判破裂了，破裂的消息还没传开。你比所有人早知道三天。', days: 3, kind: '战争' }
    ];
    var t = bank[Math.floor(r() * bank.length)];
    return { txt: t.txt, dueTurn: t.days, kind: t.kind, resolved: false, place: place };
  };

  /* 第四步：开局场景叙事（≥300字，≥2感官，白描，留悬念，引出2~3行动方向） */
  Game.prototype._writeOpeningScene = function (id, era, states, costs, karmas, trib, cfg) {
    var r = this.rng;
    var place = trib.place || this.place();
    var pool = this.sensePool();
    var s1 = N.takeSense(pool, this.nctx, '视觉');
    var s2 = N.takeSense(pool, this.nctx, '听觉');
    var s3 = N.takeSense(pool, this.nctx, ['嗅觉', '触觉', '味觉'][Math.floor(r() * 3)]);
    var s4 = N.takeSense(pool, this.nctx, '心觉');
    var opener = D.OPENING_SCENES[Math.floor(r() * D.OPENING_SCENES.length)];
    var hour = ['子时', '丑时', '寅时', '卯时', '黄昏', '入夜', '五更', '正午'][Math.floor(r() * 8)];
    var weather = ['下着雨', '起了雾', '风很大', '没有风', '落着灰一样的雪', '闷热得像要出事', '天上一颗星也没有'][Math.floor(r() * 7)];

    var paras = [];
    paras.push(opener.txt);
    paras.push(hour + '，' + place + '，' + weather + '。' +
      '你面前的' + ['一扇门', '一口井', '一面墙', '一张桌', '一块碑', '一具棺'][Math.floor(r() * 6)] + s1.word + '，' +
      '远处有' + s2.word + '的动静，一阵一阵。空气里是' + s3.word + '，' +
      (s3.kind === '嗅觉' ? '吸进去，肺里发凉。' : '从' + ['掌心', '后颈', '脚底', '齿间'][Math.floor(r() * 4)] + '漫上来。'));

    /* 身份交代（不用说明书口吻） */
    paras.push('你是' + id.birth + '，' + id.status + '。' +
      (id.tag !== '路人甲' && id.tag !== '背景板' ? '旁人提起你时，会加上一句：' + id.tag + '。' : '旁人不提起你。') +
      '此刻你的处境是——' + id.plight + '。' +
      '这不是简介，这是你现在正站着的地方。');

    /* 时代与世界状态 */
    paras.push('这是' + era.name + '。' + era.desc[0] + '；' + era.desc[1] + '。' +
      states.map(function (s) { return s.name; }).join('、') + '——这三件事叠在一起，就是你现在呼吸的空气。');

    /* 反套路 */
    paras.push('有一件事不太对：' + id.antiText);

    /* 先天代价 */
    paras.push('而你身上还背着：' + costs.map(function (c) { return c.txt; }).join('；') + '。' +
      '天道从不白给。它给你的每一样东西，都在别的地方扣了回去。');

    /* 因果线（隐藏的只显示表象） */
    var kLines = karmas.map(function (k) {
      return k.surface ? '·【' + k.name + '·表象】' + k.surface : '·【' + k.name + '】' + k.desc;
    });
    paras.push('有些线已经系在你身上了：\n' + kLines.join('\n'));

    /* 眼前劫数 */
    paras.push('【眼前劫数】' + trib.txt);

    /* 白描 + 心觉 */
    paras.push(N.baimiao(['那块碑', '手里的半块玉简', '那口井', '自己的手', '门上的铜环'][Math.floor(r() * 5)]));
    paras.push(s4.word + '。你没有说话，也没有动，只是站在那里，站了很久，久到' +
      ['雨停了', '雾散了', '远处的动静没有了', '天开始发白', '你自己的影子换了方向'][Math.floor(r() * 5)] + '。');

    /* 悬念 */
    paras.push('还有一件事你没想明白：' +
      ['为什么偏偏是今天。', '为什么那个人看你的眼神，像是在确认一件早就知道的事。',
        '为什么你手里这样东西，是温的。', '为什么你记得一件不可能记得的事。',
        '为什么这里所有人都假装那口井不存在。'][Math.floor(r() * 5)]);

    var txt = paras.join('\n');
    /* 字数保障 */
    var guard = 0;
    while (N.totalLen([txt]) < 340 && guard < 5) {
      txt += '\n' + N.scenePara({ sensePool: pool, usedSenses: this.usedSenses, place: place, timeStr: hour, rng_i: 1 }, 'explore', null);
      guard++;
    }
    txt += '\n\n「' + N.golden({ goldenCache: this.goldenCache, rng_i: 7 }) + '」';
    return txt;
  };

  /* ============================================================
     SECTION: world-init 世界初始化（势力 / NPC / 伏笔）
     ============================================================ */
  Game.prototype._initWorld = function (o) {
    var r = this.rng;
    /* 势力：取 5~7 个，动态改写状态 */
    var fp = D.FACTION_TPL.slice();
    this.factions = [];
    var fn = 5 + Math.floor(r() * 3);
    for (var i = 0; i < fn && fp.length; i++) {
      var f = fp.splice(Math.floor(r() * fp.length), 1)[0];
      this.factions.push({
        id: 'f' + i, name: f.n, kind: f.kind, align: f.align, desc: f.desc,
        power: 30 + Math.floor(r() * 70), territory: this.place(),
        relation: {}, warWith: null, controlPrice: null, alive: true
      });
    }
    /* 势力关系与战争线 */
    this.factions.forEach(function (f) {
      this.factions.forEach(function (g) {
        if (f === g) return;
        var v = Math.floor(r() * 200) - 100;
        if (f.align === '正' && g.align === '邪') v -= 50;
        if (f.align === '邪' && g.align === '正') v -= 50;
        if (f.align === g.align && f.align !== '未知') v += 30;
        f.relation[g.id] = v;
      }, this);
    }, this);
    /* 挑一场正在酝酿的战争 */
    if (this.factions.length >= 2) {
      var a = this.factions[Math.floor(r() * this.factions.length)];
      var b = this.factions[Math.floor(r() * this.factions.length)];
      if (a !== b && a.relation[b.id] < -30) { a.warWith = b.id; b.warWith = a.id; this.warPair = [a.id, b.id]; }
    }

    /* 重要 NPC：8~12 位，六要素齐备 */
    this.npcs = [];
    var nn = 8 + Math.floor(r() * 5);
    for (var j = 0; j < nn; j++) this.npcs.push(this._makeNpc(j, o));
    /* 因果线绑定 NPC */
    o.karmas.forEach(function (k) {
      var cand = this.npcs.filter(function (n) { return n.alive; });
      if (cand.length) k.relatedNpc = cand[Math.floor(r() * cand.length)].id;
    }, this);
    this.karmas = o.karmas.map(function (k) {
      k.createdTurn = 0;
      return k;
    });
    /* 气运之子 1~3 名 */
    var qy = 1 + Math.floor(r() * 3);
    for (var q = 0; q < qy && q < this.npcs.length; q++) {
      var idx = Math.floor(r() * this.npcs.length);
      if (!this.npcs[idx].isQiyun) { this.npcs[idx].isQiyun = true; this.npcs[idx].luck = 60 + Math.floor(r() * 40); this.npcs[idx].realmIdx = Math.min(D.REALMS.length - 2, 2 + Math.floor(r() * 4)); }
    }
    /* 初始伏笔 */
    this.foreshadow = o.karmas.map(function (k, i) {
      return { id: 'fs' + i, text: k.name, level: k.level, trigger: k.trigger, dueTurn: k.dueTurn, karmaId: k.id, resolved: false };
    });
    if (o.tribulation.dueTurn) this.foreshadow.push({ id: 'fs_trib', text: o.tribulation.kind + '：' + o.tribulation.txt, level: '个人级', trigger: '时间到期', dueTurn: o.tribulation.dueTurn, resolved: false });
    /* 初始大事件日历（未来 100 回合） */
    this.bigEvents = [];
    for (var b2 = 0; b2 < 3; b2++) {
      var tpl = D.BIG_EVENT_TPL[Math.floor(r() * D.BIG_EVENT_TPL.length)];
      this.bigEvents.push({
        id: 'be' + b2, kind: tpl.kind, turn: 30 + b2 * 40 + Math.floor(r() * 25),
        desc: N.fill(tpl.txt, { place: this.place(), faction: this.factionName() }),
        done: false, weight: tpl.weight
      });
    }
    this.bigEvents.sort(function (x, y) { return x.turn - y.turn; });
    /* 初始风闻 2 条 */
    this.rumors = [N.makeRumor(this), N.makeRumor(this)];
  };

  Game.prototype._makeNpc = function (i, o) {
    var r = this.rng;
    var name = this._genName();
    var title = D.NPC_TITLE[Math.floor(r() * D.NPC_TITLE.length)];
    var fac = this.factions.length ? this.factions[Math.floor(r() * this.factions.length)] : null;
    var realmIdx = Math.floor(r() * 5);
    var personality = ['谨慎', '贪婪', '重义', '阴狠', '沉默', '话多', '偏执', '洒脱', '怯懦', '狂傲'][Math.floor(r() * 10)];
    var goal = ['突破下一境界', '为家人报仇', '守住现在的地位', '找到一样东西', '活过今年', '建立自己的道统', '还清一笔债', '看着某个人死'][Math.floor(r() * 8)];
    var npc = {
      id: 'n' + i, name: name, title: title, fullName: title + '·' + name,
      faction: fac ? fac.id : null, factionName: fac ? fac.name : '无门无派',
      realmIdx: realmIdx, systemId: (this.pc && this.pc.world && this.pc.world.defaultSystem) || 'qi', age: 20 + Math.floor(r() * 300), lifeMax: D.REALMS[realmIdx].life,
      personality: personality, goal: goal, isQiyun: false, luck: Math.floor(r() * 40),
      hiddenMotive: ['他想要的东西和你想要的是同一样', '他在替别人看着你', '他欠了一笔不能说的债', '他知道那口井的秘密', '他其实是来杀你的，但还没下定决心', '他在等一个能继承他东西的人'][Math.floor(r() * 6)],
      motiveRevealed: false,
      alive: true, deathTurn: null, deathWay: null,
      memory: [],          /* 记忆条目 */
      att: {},             /* 态度六象 */
      bond: 0,             /* 羁绊深度索引 */
      betrayalBase: personality === '阴狠' ? 0.35 : (personality === '重义' ? 0.05 : 0.15),
      power: 0, talkSpread: personality === '话多' ? 1.6 : (personality === '沉默' ? 0.5 : 1.0),
      status: D.NPC_TITLE[Math.floor(r() * D.NPC_TITLE.length)],
      actionLog: [],
      met: false
    };
    D.ATTITUDES.forEach(function (a) { npc.att[a] = 0; });
    npc.att['漠视'] = 40 + Math.floor(r() * 40);
    /* 初始态度受出身/口碑影响 */
    if (o && o.identity) {
      if (o.identity.plight === '被追杀') npc.att['忌惮'] += 10;
      if (o.identity.status === '宗门弃徒' && npc.faction) npc.att['漠视'] += 20;
    }
    npc.power = this._npcPower(npc);
    return npc;
  };
  Game.prototype._npcPower = function (n) {
    return Math.round(D.REALMS[n.realmIdx].base * (0.85 + this.rng() * 0.3) * (1 + n.realmIdx * 0.05));
  };

  /* ============================================================
     SECTION: power 战力天花板与合理性校验
     ============================================================ */
  Game.prototype.calcPower = function (pc) {
    var base = D.REALMS[pc.realmIdx].base * (1 + pc.realmSub * 0.08);
    var six = pc.six;
    var m = 1 + (six['根骨'] - 3) * 0.03 + (six['灵性'] - 3) * 0.04 + (six['悟性'] - 3) * 0.02;
    /* 道蕴 / 道途加成 */
    var daoBonus = 0;
    for (var k in pc.bp) {
      var st = pc.bpStage[k] || 0;
      daoBonus += st * 0.06;
    }
    /* 法宝 */
    var itemBonus = pc.items.reduce(function (a, it) { return a + (it.lv || 1) * 0.04; }, 0);
    /* 道伤与污染扣减 */
    var injPen = 0;
    for (var t in pc.injury) injPen += pc.injury[t] * 0.08;
    var polPen = pc.pollution * 0.05;
    /* 寿元阶段 */
    var ls = this.lifespanStage(pc);
    var p = base * m * (1 + daoBonus + itemBonus) * (1 - injPen - polPen) * ls.fx.power;
    if (pc.noCombat) p *= 0.35;
    /* 同境界战力差距不超过 30%（铁律） */
    var lo = D.REALMS[pc.realmIdx].base * 0.85, hi = D.REALMS[pc.realmIdx].base * 1.15 * (1 + pc.realmSub * 0.08);
    if (pc.realmIdx > 0) p = clamp(p, lo * 0.6, hi * 1.35);
    return Math.max(1, Math.round(p));
  };

  /* ============================================================
     SECTION: six 六司增减（先天百分比加成 + 后天可改）
     ============================================================ */
  /* 某项六司对某一维度的百分比加成（每点系数见 D.SIX_PER_POINT） */
  Game.prototype.sixBonusPct = function (pc, key) {
    var per = (D.SIX_PER_POINT && D.SIX_PER_POINT[key]) || 0.02;
    return (pc.six[key] || 0) * per;
  };
  /* 后天增减六司：可突破初始上限 10，硬上限 15；下限 1 */
  Game.prototype.modSix = function (key, delta, reason) {
    var pc = this.pc;
    if (!(key in pc.six)) return { ok: false, msg: '没有「' + key + '」这项六司。' };
    var hardMax = D.SIX_HARD_MAX || 15;
    var before = pc.six[key];
    var after = clamp(before + delta, 1, hardMax);
    if (after === before) return { ok: false, msg: '「' + key + '」已达' + (delta > 0 ? '硬上限 ' + hardMax : '下限 1') + '，无法再' + (delta > 0 ? '提升' : '下降') + '。' };
    pc.six[key] = after;
    pc.sixBonus[key] = (pc.sixBonus[key] || 0) + (after - before);
    pc.combat = this.calcPower(pc);
    /* 气运直接影响 luckFlat */
    if (key === '气运') pc.luckFlat = (pc.six['气运'] - 3) * 4 + ((pc.luckFlatExtra) || 0);
    return { ok: true, key: key, before: before, after: after, delta: after - before, reason: reason || '' };
  };
  /* 天道点淬炼六司：+1，可突破初始上限 */
  Game.prototype.forgeSix = function (key) {
    var pc = this.pc;
    var cost = 20;
    if ((pc.tianPoints || 0) < cost) return { ok: false, msg: '天道点不足：淬炼一项六司需要 ' + cost + ' 点，你有 ' + (pc.tianPoints || 0) + '。' };
    var r = this.modSix(key, 1, '天道点淬炼');
    if (!r.ok) return r;
    pc.tianPoints -= cost;
    pc.sixForged = (pc.sixForged || 0) + 1;
    return { ok: true, msg: '【淬炼六司】' + key + ' ' + r.before + ' → ' + r.after + (r.after > 10 ? '（已突破初始上限，天道记了一笔）' : '') + '。改上去的东西，也可能被改回来。', key: key };
  };

  Game.prototype.lifespanStage = function (pc) {    var ratio = pc.age / pc.lifeMax;
    var mult = pc.lifeMult || 1;
    ratio = ratio / mult;
    for (var i = 0; i < D.LIFESPAN.length; i++) {
      if (ratio >= D.LIFESPAN[i].pct[0] && ratio < D.LIFESPAN[i].pct[1]) return D.LIFESPAN[i];
    }
    return D.LIFESPAN[D.LIFESPAN.length - 1];
  };

  /* 越阶挑战校验：必须有明确代价或条件 */
  Game.prototype.checkChallenge = function (pc, targetPower) {
    var gap = targetPower / Math.max(1, pc.combat);
    if (gap <= 1.15) return { ok: true, note: '势均力敌。' };
    if (gap <= 1.6) return { ok: true, cost: '越阶挑战', note: '你可以打，但赢了也要躺三个月。', pen: 0.25 };
    if (gap <= 2.5) return { ok: true, cost: '重大代价', note: '这是拿命换。你需要一个条件：地利、法宝、或者一个愿意替你死的人。', pen: 0.5, needCond: true };
    return { ok: false, note: '差距太大。这不是勇气的问题，是物理法则。天道不允许你赢——强行出手会触发天道修正：强制降阶、道基受损、因果反噬。', pen: 1 };
  };

  /* ============================================================
     SECTION: dice 因果掷骰（五级结果 + 监察惩罚）
     ============================================================ */
  Game.prototype.dice = function (baseRate, opts) {
    opts = opts || {};
    var pc = this.pc, r = this.rng;
    var rate = baseRate;
    /* 天道监察惩罚 */
    var mon = D.MONITOR[clamp((opts.monitor != null ? opts.monitor : pc.monitor) || 0, 0, 5)];
    rate -= mon.pen;
    /* 气运 */
    rate += (pc.luckFlat || 0) / 200;
    if (pc.six['气运']) rate += (pc.six['气运'] - 3) * 0.015;
    /* 悟性 / 相关属性 */
    if (opts.attr && pc.six[opts.attr]) rate += (pc.six[opts.attr] - 3) * 0.02;
    /* 道伤 */
    for (var k in pc.injury) rate -= pc.injury[k] * 0.04;
    /* 污染 */
    rate -= pc.pollution * 0.03;
    /* 世界状态 */
    if (opts.worldFx) rate *= opts.worldFx;
    /* 行为场 */
    if (this.field && this.field.bonus) rate += this.field.bonus;
    rate = clamp(rate, 0.02, 0.98);
    var roll = r();
    var res;
    if (roll < rate * 0.12) res = 'great';
    else if (roll < rate * 0.75) res = 'ok';
    else if (roll < rate) res = 'barely';
    else if (roll < rate + (1 - rate) * 0.82) res = 'fail';
    else res = 'greatfail';
    return { rate: rate, roll: roll, result: res, monitor: mon };
  };

  /* ============================================================
     SECTION: tick 世界 TICK（每回合≥3件后台事件）
     ============================================================ */
  Game.prototype.worldTick = function (silent) {
    var r = this.rng, out = [], pc = this.pc;
    var types = ['NPC行动', '势力变动', '资源刷新', '因果触发', '天象变化', '界域异动'];
    /* 铁律：每回合后台自动推进至少三件玩家未知事件 */
    var guard = 0;
    while (out.length < 3 && guard < 24) {
      guard++;
      var t = types[Math.floor(r() * types.length)];
      var ev = this._oneTick(t);
      if (ev) { out.push(ev); this.ticks.unshift(ev); }
    }
    /* 额外事件（超出下限的部分，让世界更热闹） */
    var extra = Math.floor(r() * 3);
    for (var i = 0; i < extra; i++) {
      var t2 = types[Math.floor(r() * types.length)];
      var ev2 = this._oneTick(t2);
      if (ev2) { out.push(ev2); this.ticks.unshift(ev2); }
    }
    /* 兜底：无论世界多冷清，天道每回合至少推进三件事 */
    var FB = [
      '远处的灵气流向变了，变得很轻微，只有专门留意的人才察觉。',
      '有人在' + this.place() + '立了一块新碑，碑上没有名字。',
      '一封信在几个势力之间转了一圈，最后谁也没承认收到过。',
      '某处地脉跳了一下，跳得很轻，像睡着了的人翻了个身。',
      '坊市上多了一个新摊子，摊主谁也不认识，收摊之后没人记得他卖过什么。',
      '天上有一群鸟改了道，改得很整齐，像是被什么指挥着。',
      '一口老井的水位降了半尺，井边的人说是旱，但今年雨水不少。',
      '有个孩子在' + this.place() + '说了一句没人听懂的话，说完就忘了自己说过。',
      '某位闭关很久的人洞府外的禁制闪了一下，只闪了一下。',
      '一批来路不明的灵石流进了市场，成色很好，好得不像这个年头该有的。'
    ];
    var fguard = 0;
    while (out.length < 3 && fguard < 6) {
      var fe = { type: '世界自转', text: FB[Math.floor(r() * FB.length)], hidden: true };
      out.push(fe); this.ticks.unshift(fe); fguard++;
    }
    this.ticks = this.ticks.slice(0, 120);
    return out;
  };

  Game.prototype._oneTick = function (type) {
    var r = this.rng, pc = this.pc;
    var alive = this.npcs.filter(function (n) { return n.alive; });
    var f = this.factions.filter(function (x) { return x.alive; });
    switch (type) {
      case 'NPC行动': {
        if (!alive.length) return null;
        var n = alive[Math.floor(r() * alive.length)];
        /* 决策优先级：生存 > 目标 > 关系 > 利益 > 性格 */
        var act;
        if (n.age > n.lifeMax * 0.9) act = '开始安排后事，把东西分给了三个人';
        else if (n.hpLow) act = '躲起来养伤，谁都不见';
        else if (n.goal === '突破下一境界' && r() < 0.5) {
          if (chance(r, 0.18 + n.luck / 500)) {
            n.realmIdx = Math.min(D.REALMS.length - 2, n.realmIdx + 1); n.power = this._npcPower(n);
            act = '突破了 ' + D.REALMS[n.realmIdx].name + '，' + n.factionName + '为此摆了三天的酒';
          } else act = '闭关冲境失败，出关时瘦了一圈';
        }
        else if (n.goal === '为家人报仇') act = '又去查了一次那件事，查到一条新线索，也惊动了不该惊动的人';
        else if (n.goal === '守住现在的地位') act = '在门派里挤走了一个同僚，理由找得很体面';
        else if (n.goal === '找到一样东西') act = '动身去了' + this.place() + '，没有告诉任何人';
        else if (n.goal === '活过今年') act = '把住处换了第三个地方';
        else if (n.goal === '还清一笔债') act = '又还了一部分，债主说还差很多';
        else act = '按自己的性子做了一件别人看不懂的事';
        n.actionLog.unshift({ turn: this.turn, act: act });
        n.actionLog = n.actionLog.slice(0, 8);
        /* NPC 对玩家的态度自然演变 */
        if (n.met && n.att['仇恨'] > 30) { n.att['仇恨'] = Math.max(0, n.att['仇恨'] - 1); }
        if (n.met && n.att['感恩'] > 20) { n.att['感恩'] = Math.min(100, n.att['感恩'] + 1); }
        return { type: type, text: n.fullName + ' ' + act + '。（' + n.factionName + '）', npc: n.id, hidden: !n.met };
      }
      case '势力变动': {
        if (!f.length) return null;
        var fa = f[Math.floor(r() * f.length)];
        var bank = [
          '调整了外门弟子的资源配额，配额降了一成，没人敢公开抱怨',
          '换了一位长老，换的理由是"闭关"，但没人在洞府外见过他',
          '与另一方开始互通商路，商路上第一批货是兵器',
          '封了三处矿脉，说是"检修"',
          '开了一次全宗大会，会开了七天，出来的时候有人的脸色不对',
          '召回了所有在外弟子，召回令用的是最高等级的印记',
          '把某位弟子逐出了师门，公告贴在山门外，被雨泡烂了一半'
        ];
        var act = bank[Math.floor(r() * bank.length)];
        fa.power = clamp(fa.power + Math.floor(r() * 11) - 5, 5, 100);
        return { type: type, text: fa.name + ' ' + act + '。', faction: fa.id };
      }
      case '资源刷新': {
        var bank2 = [
          this.place() + '新发现一处小型灵脉，三家势力已经开始往那边派人',
          '一批' + ['低阶灵药', '灵矿', '符纸', '妖兽材料'][Math.floor(r() * 4)] + '流入坊市，价格短暂松动',
          this.place() + '的旧矿挖空了，挖矿的人开始往别处走',
          '有人在河底捞出一件东西，捞出来的人第二天就把它卖了，卖得很便宜',
          '一株百年灵植被人摘了，摘的人没留下痕迹，只留下一个坑'
        ];
        var txt = bank2[Math.floor(r() * bank2.length)];
        /* 影响价格 */
        var keys = Object.keys(this.prices);
        if (keys.length) {
          var k2 = keys[Math.floor(r() * keys.length)];
          var d = 1 + (r() * 0.16 - 0.08);
          this.prices[k2] = Math.max(1, Math.round(this.prices[k2] * d));
        }
        return { type: type, text: txt + '。' };
      }
      case '因果触发': {
        var ks = this.karmas.filter(function (k) { return k.status === 'active'; });
        if (!ks.length) return null;
        var kk = ks[Math.floor(r() * ks.length)];
        var delta = Math.floor(r() * 5) - 2;
        kk.strength = clamp(kk.strength + delta, 1, 20);
        var bank3 = delta > 0
          ? '【' + kk.name + '】这条线又紧了紧。有些事你没做，但它自己在走。'
          : delta < 0
            ? '【' + kk.name + '】似乎松了一点。也可能是你的错觉。'
            : '【' + kk.name + '】没有动静。没有动静也是一种动静——它只是在等。';
        return { type: type, text: bank3, karma: kk.id, visible: kk.realRevealed };
      }
      case '天象变化': {
        var bank4 = [
          '夜里有流星坠向' + this.place() + '，坠得很慢，慢得不像流星',
          '连续三日无风，灵气凝滞，修士们普遍觉得修炼效率下降',
          '月亮缺一块，缺的地方是方的',
          '天边出现了一道虹，虹只有一头',
          '所有的水面在同一时刻起了波纹，没有风',
          '天上那片云七天没有动过，形状也没有变过'
        ];
        return { type: type, text: bank4[Math.floor(r() * bank4.length)] + '。' };
      }
      case '界域异动': {
        var bank5 = [
          '界海潮汐涨了一次，跨界传送的成功率短暂下降',
          this.place() + '附近出现了一道空间裂缝，缝里传出的声音不像这个世界的',
          '有修士报告说自己在原地走了三天，第三步才走出来',
          '界域壁垒薄了一处，薄的那个位置正好在一座凡人城池上方',
          '某处地脉改了道，改得很突然，沿河的井一夜之间全干了'
        ];
        var txt5 = bank5[Math.floor(r() * bank5.length)];
        if (chance(r, 0.25)) {
          pc.pollution = clamp(pc.pollution + (r() < 0.5 ? 0 : 0), 0, 4);
        }
        return { type: type, text: txt5 + '。' };
      }
    }
    return null;
  };

  /* ============================================================
     SECTION: stage 大事件日历与大劫阶段
     ============================================================ */
  Game.prototype.advanceStage = function () {
    var out = [];
    for (var i = D.TRIBULATION.length - 1; i >= 0; i--) {
      if (this.turn >= D.TRIBULATION[i].turn && this.stage < i) {
        this.stage = i;
        out.push(D.TRIBULATION[i]);
      }
    }
    /* 放入待领取队列：无论从回合还是岁月如梭推进，界面都能取到并展示 */
    if (out.length) {
      this.pendingStages = (this.pendingStages || []).concat(out);
      return out;
    }
    return out;
  };

  /* 领取待展示的大劫阶段推进（取走后清空，避免重复展示） */
  Game.prototype.takeStages = function () {
    var q = this.pendingStages || [];
    this.pendingStages = [];
    return q;
  };

  Game.prototype.checkBigEvents = function () {
    var fired = [];
    this.bigEvents.forEach(function (e) {
      if (!e.done && this.turn >= e.turn) { e.done = true; fired.push(e); }
    }, this);
    if (fired.length) this.pendingBig = (this.pendingBig || []).concat(fired);
    return fired;
  };

  /* 领取待展示的大事件（取走后清空，触发世界级叙事） */
  Game.prototype.takeBigEvents = function () {
    var q = this.pendingBig || [];
    this.pendingBig = [];
    return q;
  };

  /* ============================================================
     SECTION: foreshadow 伏笔到期检查
     ============================================================ */
  Game.prototype.checkForeshadow = function () {
    var due = [];
    this.foreshadow.forEach(function (f) {
      if (!f.resolved && f.dueTurn != null && this.turn >= f.dueTurn) { f.resolved = true; due.push(f); }
    }, this);
    return due;
  };

  /* 记忆压缩（每十回合）：日常级>30回合降背景，个人级>50回合强制触发或废弃 */
  Game.prototype.compressMemory = function () {
    var out = [];
    this.foreshadow.forEach(function (f) {
      if (f.resolved) return;
      var age = this.turn - (f.createdTurn || 0);
      if (f.level === '日常级' && age > 30) { f.level = '背景设定'; out.push('伏笔「' + f.text + '」因三十回合未触发，降级为背景设定。'); }
      else if (f.level === '个人级' && age > 50) {
        if (chance(this.rng, 0.5)) { f.resolved = true; out.push('伏笔「' + f.text + '」超过五十回合未触发，强制触发。'); f.forceFire = true; }
        else { f.resolved = true; f.discarded = true; out.push('伏笔「' + f.text + '」超过五十回合未触发，已废弃。它没有发生，这本身也是一种结果。'); }
      }
    }, this);
    /* 天道级与因果级永不压缩，仅做摘要保留 */
    return out;
  };

  /* ============================================================
     SECTION: npc NPC 自主行动 / 记忆 / 口碑
     ============================================================ */
  Game.prototype.npc = function (id) {
    return this.npcs.filter(function (n) { return n.id === id; })[0] || null;
  };

  /* 记忆条目：[时间戳][事件类型][摘要][影响][优先级] */
  Game.prototype.npcRemember = function (npc, type, summary, impact, level) {
    if (!npc) return;
    npc.memory.unshift({ turn: this.turn, type: type, summary: summary, impact: impact, level: level || '日常级', fuzzy: 0 });
    npc.memory = npc.memory.slice(0, 30);
    npc.met = true;
  };

  Game.prototype.npcAttitude = function (npc, dim, delta, reason) {
    if (!npc) return;
    npc.att[dim] = clamp((npc.att[dim] || 0) + delta, 0, 100);
    npc.met = true;
    if (reason) this.npcRemember(npc, '态度变化', reason, dim + (delta > 0 ? '+' : '') + delta, delta >= 20 ? '因果级' : '个人级');
    /* 口碑传播 */
    if (Math.abs(delta) >= 15) this.spreadRumorAbout(npc, dim, delta, reason);
  };

  Game.prototype.spreadRumorAbout = function (npc, dim, delta, reason) {
    var spread = npc.talkSpread * (1 + (npc.realmIdx * 0.2)) * (Math.abs(delta) / 30);
    var repDelta = 0;
    if (dim === '仇恨' || dim === '忌惮') repDelta = -Math.round(6 * spread);
    if (dim === '感恩' || dim === '敬畏') repDelta = Math.round(6 * spread);
    this.pc.reputation = clamp((this.pc.reputation || 0) + repDelta, -100, 100);
    /* 传播到同势力 NPC */
    if (npc.faction) {
      this.npcs.forEach(function (n) {
        if (n === npc || !n.alive || n.faction !== npc.faction) return;
        var d2 = dim === '仇恨' ? '仇恨' : dim;
        n.att[d2] = clamp((n.att[d2] || 0) + Math.round(delta * 0.35 * spread / 2), 0, 100);
        if (dim === '仇恨') n.att['忌惮'] = clamp((n.att['忌惮'] || 0) + 5, 0, 100);
      }, this);
    }
    this.lastSpread = { from: npc.fullName, dim: dim, rep: repDelta };
  };

  /* 记忆衰减（每回合结算） */
  Game.prototype.decayMemory = function () {
    this.npcs.forEach(function (n) {
      n.memory.forEach(function (m) {
        var age = this.turn - m.turn;
        if (m.level === '日常级') {
          if (age > 100) m.fuzzy = 1;
          else if (age > 50) m.fuzzy = 0.5;
        } else if (m.level === '个人级' && age > 100) m.fuzzy = 0.3;
      }, this);
      n.memory = n.memory.filter(function (m) { return !(m.level === '日常级' && m.fuzzy >= 1); });
    }, this);
  };

  /* NPC 死亡判定 */
  Game.prototype.npcDeathCheck = function (n, cause) {
    if (!n.alive) return false;
    n.alive = false; n.deathTurn = this.turn; n.deathWay = cause;
    this.obituary = this.obituary || [];
    this.obituary.unshift({ name: n.fullName, turn: this.turn, way: cause, age: n.age });
    return true;
  };

  Game.prototype.deathNarrative = function (n) {
    var r = this.rng;
    var bank = [
      n.fullName + '死于' + n.deathWay + '。' + (n.age) + '岁。消息传回来的时候是' + ['清晨', '半夜', '黄昏'][Math.floor(r() * 3)] + '，送信的人身上还带着路上的土。',
      n.fullName + '没有活过这一年。' + n.deathWay + '。' + '他死的时候身边' + ['没有人', '只有一个人', '有很多人，但没有一个是他想见的'][Math.floor(r() * 3)] + '。',
      '关于' + n.fullName + '的死，有三个版本。' + n.deathWay + '是其中一个，可能是最不准的那个。'
    ];
    var txt = bank[Math.floor(r() * bank.length)];
    /* 对周围 NPC 的影响（口碑传播） */
    var aff = this.npcs.filter(function (x) { return x.alive && x.faction === n.faction && x.id !== n.id; });
    if (aff.length) txt += ' ' + aff.slice(0, 2).map(function (a) { return a.fullName; }).join('、') + '听说了这件事，' + ['没有说话', '说了很多话', '当天就动身了'][Math.floor(r() * 3)] + '。';
    return txt;
  };

  Game.prototype.topNpcFor = function (kind) {
    var alive = this.npcs.filter(function (n) { return n.alive; });
    if (!alive.length) return '';
    var r = this.rng;
    var lines = [];
    for (var i = 0; i < Math.min(3, alive.length); i++) {
      var n = alive[Math.floor(r() * alive.length)];
      var act = {
        '地脉异动': n.fullName + '带着罗盘去了震中，回来的时候罗盘不见了，人也不太行',
        '势力开战': n.fullName + '被征召了，他把自己的剑交给了一个不认识的人',
        '天象大变': n.fullName + '看了三夜的天，第四天开始收拾行李',
        '界海大潮': n.fullName + '买下了所有能买到的船票，然后一张也没用',
        '古物出世': n.fullName + '去了那个地方，去得很早，早到没人相信他能活着回来',
        '诡异渗透': n.fullName + '把自己关在屋子里七天，出来的时候，认识他的人都说他变了'
      }[kind] || n.fullName + '做了他能做的事，做得不够';
      lines.push(act);
    }
    return lines.join('；') + '。';
  };

  /* ============================================================
     SECTION: economy 经济系统（每十回合更新价格表）
     ============================================================ */
  Game.prototype._initPrices = function () {
    this.prices = {};
    D.MARKET.forEach(function (cat) {
      cat.items.forEach(function (it) { this.prices[it.n] = it.p; }, this);
    }, this);
    this.basePrices = JSON.parse(JSON.stringify(this.prices));
  };

  Game.prototype.updatePrices = function () {
    var r = this.rng;
    var reason = [];
    var st = this.opening.states.map(function (s) { return s.id; });
    var trib = D.TRIBULATION[this.stage];
    D.MARKET.forEach(function (cat) {
      cat.items.forEach(function (it) {
        var mult = 1;
        /* ① 世界状态 */
        if (st.indexOf('tongshuo') >= 0) { if (cat.cat === '灵石' || cat.cat === '丹药') { mult *= 1.25; reason.push('灵气通缩：灵石与丹药价值上升'); } }
        if (st.indexOf('tongzhang') >= 0) { if (cat.cat === '法宝') { mult *= 0.75; reason.push('灵气通胀：法宝跌价'); } }
        if (st.indexOf('suandao') >= 0 && cat.cat === '灵石') mult *= 0.85;
        /* ② 大劫阶段 */
        if (trib.fx && trib.fx.price) { mult *= trib.fx.price; reason.push('大劫进入' + trib.name + '期：物资普涨'); }
        if (this.stage >= 3 && (cat.cat === '丹药' || cat.cat === '符箓')) { mult *= 1.3; reason.push('战时：救命物资溢价'); }
        /* ③ 势力战争 */
        if (this.warPair && (cat.cat === '法宝' || cat.cat === '符箓')) { mult *= 1.2; reason.push('势力开战：军用物资飙升'); }
        /* ④ 灵气浓度 */
        var qi = this.pc.worldQi;
        if (qi < 0.8 && (cat.cat === '丹药' || cat.cat === '药材')) { mult *= 1.25; reason.push('低灵气区域：修炼物资稀缺'); }
        if (qi > 1.2 && (cat.cat === '材料')) { mult *= 1.15; reason.push('高灵气区域：炼器炼丹材料需求大'); }
        /* 声誉影响 */
        mult *= (1 - (this.pc.reputation || 0) / 500);
        /* 随机扰动（须有因果解释，故幅度受限） */
        mult *= 0.95 + r() * 0.1;
        var np = Math.max(1, Math.round(this.basePrices[it.n] * mult));
        this.prices[it.n] = np;
      }, this);
    }, this);
    /* 去重理由 */
    var seen = {};
    reason = reason.filter(function (x) { if (seen[x]) return false; seen[x] = 1; return true; });
    this.priceHist.unshift({ turn: this.turn, prices: JSON.parse(JSON.stringify(this.prices)), reason: reason.slice(0, 4) });
    this.priceHist = this.priceHist.slice(0, 12);
    return reason.slice(0, 4);
  };

  /* 经商判定：运输风险 / 市场影响 / 引来觊觎 / 口碑影响 */
  Game.prototype.trade = function (itemName, qty, buy) {
    var r = this.rng, pc = this.pc;
    var price = this.prices[itemName] || 10;
    /* 市场影响：大量买卖改变当地价格 */
    var impact = qty * price;
    var log = [];
    if (buy) {
      var cost = price * qty;
      if (pc.money < cost) return { ok: false, msg: '灵石不够。你手里有 ' + Math.floor(pc.money) + '，这批货要 ' + cost + '。' };
      pc.money -= cost;
      pc.items.push({ n: itemName, lv: 1, qty: qty, buyPrice: price });
      if (impact > 500) { this.prices[itemName] = Math.round(price * 1.08); log.push('你买得太多，当地价格上浮了 8%（' + price + ' → ' + this.prices[itemName] + '）。'); }
      log.push('购入 ' + itemName + ' ×' + qty + '，花掉 ' + cost + ' 灵石。');
    } else {
      var own = pc.items.filter(function (it) { return it.n === itemName && it.qty; });
      var have = own.reduce(function (a, b) { return a + (b.qty || 0); }, 0);
      if (have < qty) return { ok: false, msg: '你没有这么多 ' + itemName + '（持有 ' + have + '）。' };
      /* 运输风险 */
      var risk = 0.06 + this.stage * 0.02 + (this.warPair ? 0.06 : 0);
      var lost = 0;
      if (chance(r, risk)) { lost = Math.max(1, Math.floor(qty * (0.2 + r() * 0.4))); log.push('路上遇了' + ['劫修', '妖兽', '一场天灾', '一队"征税"的宗门弟子'][Math.floor(r() * 4)] + '，损失了 ' + lost + ' 件货。'); }
      var sellQty = qty - lost;
      var gain = Math.round(price * sellQty * (1 - (pc.reputation < 0 ? 0.1 : 0)));
      pc.money += gain;
      var remain = qty;
      pc.items.forEach(function (it) {
        if (it.n === itemName && it.qty && remain > 0) { var d = Math.min(it.qty, remain); it.qty -= d; remain -= d; }
      });
      pc.items = pc.items.filter(function (it) { return !(it.n === itemName && (!it.qty || it.qty <= 0)); });
      if (impact > 500) { this.prices[itemName] = Math.max(1, Math.round(price * 0.92)); log.push('你卖得太多，当地价格下跌了 8%（' + price + ' → ' + this.prices[itemName] + '）。'); }
      log.push('售出 ' + itemName + ' ×' + sellQty + '，进账 ' + gain + ' 灵石。');
      /* 引来觊觎 */
      if (gain > 800) {
        var ev = ['商会派人来"谈了谈"商税，你交了一笔', '有人在暗巷里等你，你没走那条路，但你知道下次不一定躲得开', '一家正道宗门以"扰乱市场"为由记下了你的名字'][Math.floor(r() * 3)];
        log.push('大额交易引来了注意：' + ev + '。');
        pc.reputation = clamp(pc.reputation - 3, -100, 100);
        if (chance(r, 0.35)) { pc.money -= Math.round(gain * 0.12); log.push('被抽走了一笔说不清名目的钱。'); }
      }
      /* 口碑影响 */
      if (sellQty > 0) {
        pc.reputation = clamp(pc.reputation + (gain > 1000 ? 2 : 1), -100, 100);
        if (!pc.arts['商道']) pc.arts['商道'] = { bp: 0, level: 0 };
        this.addArtBp('商道', 1 + Math.min(3, gain / 2000));
      }
    }
    return { ok: true, msg: log.join(' '), log: log };
  };

  /* ============================================================
     SECTION: behavior 行为塑道（BP / 道途 / 道痕）
     ============================================================ */
  Game.prototype.addBp = function (pathKey, amount, why) {
    var pc = this.pc;
    if (!pc.bp[pathKey]) { pc.bp[pathKey] = 0; pc.bpStage[pathKey] = 0; pc.bpLast[pathKey] = this.turn; }
    pc.bp[pathKey] = Math.max(0, pc.bp[pathKey] + amount);
    pc.bpLast[pathKey] = this.turn;
    /* 阶跃临界点 */
    var st = 0, events = [];
    for (var i = 0; i < D.BP_STAGES.length; i++) if (pc.bp[pathKey] >= D.BP_STAGES[i]) st = i + 1;
    if (st > (pc.bpStage[pathKey] || 0)) {
      for (var s2 = (pc.bpStage[pathKey] || 0) + 1; s2 <= st; s2++) {
        events.push({ stage: s2, name: D.BP_STAGE_NAMES[s2 - 1], path: pathKey });
      }
      pc.bpStage[pathKey] = st;
    }
    /* 道痕生成 */
    if (amount >= 1.5) this.addDaoTrace(pathKey, amount, why);
    /* 矛盾检测：道心冲突 */
    var conf = this.detectConflict(pathKey);
    return { events: events, conflict: conf };
  };

  Game.prototype.detectConflict = function (pathKey) {
    var pc = this.pc;
    /* 找出对立道途 */
    var oppose = { '杀': '医', '医': '杀', '佛': '魔', '魔': '佛', '情': '无', '无': '情' };
    var keys = Object.keys(pc.bp);
    var mismatch = 0;
    keys.forEach(function (k) {
      var p = D.DAO_PATHS.filter(function (x) { return x.key === k; })[0];
      if (!p) return;
      var opp = oppose[p.key];
      if (opp && k !== pathKey) {
        var a = pc.bp[p.key] || 0, b = pc.bp[pathKey] || 0;
        if (a > 10 && b > 10) mismatch = Math.max(mismatch, Math.min(100, Math.abs(a - b) / Math.max(a, b) * 100 + Math.min(a, b) / Math.max(a, b) * 60));
      }
    });
    pc.conflictPct = Math.round(mismatch);
    if (mismatch >= 90) return { level: 3, txt: N.conflictTxt(3), pen: 0.3 };
    if (mismatch >= 60) return { level: 2, txt: N.conflictTxt(2), pen: 0.15 };
    if (mismatch >= 30) return { level: 1, txt: N.conflictTxt(1), pen: 0.05 };
    return null;
  };

  Game.prototype.addDaoTrace = function (pathKey, amount, why) {
    this.daoTraces = this.daoTraces || [];
    var p = D.DAO_PATHS.filter(function (x) { return x.key === pathKey; })[0] || { id: pathKey, color: '#888' };
    var colorMap = { '杀': '暗红色雾气', '医': '绿色光点', '阵': '几何光纹', '剑': '一线银痕', '丹': '一缕不散的药香', '器': '金属冷却的裂纹', '商': '一枚被磨平的秤星', '诡': '一层说不上来的湿' };
    var tr = { turn: this.turn, path: p.id, color: colorMap[pathKey] || '一层淡淡的痕', strength: amount, place: this.place(), why: why || '' };
    /* 模因变异 */
    if (this.opening && this.opening.states.some(function (s) { return s.id === 'guixiu' || s.id === 'wuran'; }) && chance(this.rng, 0.2)) {
      tr.mutant = pathKey === '杀' ? '血煞痕' : (pathKey === '医' ? '冥生痕' : '异变道痕');
    }
    this.daoTraces.unshift(tr);
    this.daoTraces = this.daoTraces.slice(0, 40);
    /* 模因捕食者 */
    var strong = this.daoTraces.filter(function (x) { return x.strength >= 3; }).length;
    if (strong >= 5 && chance(this.rng, 0.25)) {
      this.pendingThreat = { kind: '模因捕食者', txt: '你留下的道痕太浓了。有东西沿着它过来了——它不吃人，它吃"痕"，但吃的时候连带着吃别的。' };
    }
    return tr;
  };

  /* 百艺 BP 与阶跃 */
  Game.prototype.addArtBp = function (artId, amount) {
    var pc = this.pc;
    if (!pc.arts[artId]) pc.arts[artId] = { bp: 0, level: 0, last: this.turn };
    var a = pc.arts[artId];
    a.bp += amount;
    a.last = this.turn;
    var lv = 0;
    for (var i = 0; i < D.ART_BP_STAGES.length; i++) if (a.bp >= D.ART_BP_STAGES[i]) lv = i + 1;
    var jumped = lv > a.level;
    if (jumped) a.level = lv;
    /* 融合道途检测 */
    var fusion = this.detectFusion();
    var artDef = D.ARTS.filter(function (x) { return x.id === artId; })[0];
    var lvName = lv === 0 ? '未入门' : ((artDef && artDef.levels ? artDef.levels[lv - 1] : null) || ['习艺', '悟艺', '化艺', '创艺', '道艺'][lv - 1]);
    return { jumped: jumped, level: lv, levelName: lvName, fusion: fusion };
  };

  Game.prototype.detectFusion = function () {
    var pc = this.pc, out = null;
    var high = Object.keys(pc.arts).filter(function (k) { return (pc.arts[k].bp || 0) >= D.ART_BP_STAGES[1]; });
    if (high.length >= 2) {
      var map = { '炼丹术+炼器术': '丹器双修', '阵法术+符箓术': '符阵师', '医道+杀道': '生死道', '炼丹术+符箓术': '丹符', '御兽术+机关术': '兽机关', '寻龙堪舆术+阵法术': '风水大阵' };
      for (var i = 0; i < high.length; i++) for (var j = i + 1; j < high.length; j++) {
        var k1 = [high[i], high[j]].sort().join('+');
        if (map[k1]) { out = { name: map[k1], from: [high[i], high[j]] }; pc.fusionDao = out.name; break; }
      }
    }
    return out;
  };

  /* BP 衰减（每日 5%） */
  Game.prototype.decayBp = function () {
    var pc = this.pc, logs = [];
    for (var k in pc.bp) {
      var idle = this.turn - (pc.bpLast[k] || 0);
      if (idle > 30) {
        var before = pc.bp[k];
        pc.bp[k] = Math.max(0, pc.bp[k] * 0.95);
        if (before - pc.bp[k] > 0.5) logs.push('【' + k + '】道蕴稀释了 ' + Math.round(before - pc.bp[k]) + ' 点（三十日未行此事）。');
      }
    }
    for (var a in pc.arts) {
      var idle2 = this.turn - (pc.arts[a].last || 0);
      if (idle2 > 30) {
        var b2 = pc.arts[a].bp;
        pc.arts[a].bp = Math.max(0, b2 * 0.95);
        if (b2 - pc.arts[a].bp > 1) logs.push('【百艺·' + a + '】技艺退化了。拳不离手，曲不离口。');
      }
    }
    /* 道途寂灭：超过 100 回合无相关行为 */
    for (var k3 in pc.bp) {
      if (this.turn - (pc.bpLast[k3] || 0) > 100 && !pc.silent[k3]) {
        pc.silent = pc.silent || {};
        pc.silent[k3] = true;
        logs.push('【道途寂灭】' + k3 + ' 进入寂灭状态，所有加成消失。它没有死，只是被封存了。');
      }
    }
    return logs;
  };

  /* ============================================================
     SECTION: monitor 天道监察与禁忌
     ============================================================ */
  Game.prototype.raiseMonitor = function (lv, why) {
    var pc = this.pc;
    var before = pc.monitor;
    pc.monitor = clamp(Math.max(pc.monitor, lv), 0, 5);
    if (pc.monitor > before) {
      return { raised: true, from: before, to: pc.monitor, txt: N.monitorTxt(pc.monitor), why: why };
    }
    return { raised: false, lv: pc.monitor };
  };

  Game.prototype.useTaboo = function (tabooId) {
    var pc = this.pc, t = D.TABOOS.filter(function (x) { return x.id === tabooId; })[0];
    if (!t) return null;
    pc.tabooUsed.push({ id: t.id, turn: this.turn });
    var m = this.raiseMonitor(t.monitor, t.name);
    if (!pc.arts[t.art] && t.art) pc.arts[t.art] = { bp: 0, level: 0 };
    pc.tabooPower = (pc.tabooPower || 1) * t.power;
    pc.daoBias = t.dao;
    return { taboo: t, monitor: m };
  };

  /* 天道反噬（连续三次违背境界认

<script defer data-domain="html.cafe" src="https://milkymouse.com/js/script.js"></script>