mirror of
https://github.com/Shu-Ying/noname-shuying.git
synced 2026-10-23 00:00:00 +08:00
整合
This commit is contained in:
@@ -0,0 +1,180 @@
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
const camps = new Set(["ally", "enemy", "neutral"]);
|
||||
export const campPresets = Object.freeze({ ally: { enabled: true }, enemy: { enabled: true }, neutral: { enabled: false } });
|
||||
const events = new Set(["battleStart", "roundStart", "turnStart", "turnEnd", "state"]);
|
||||
const checks = new Set(["hp", "hand", "alive", "linked", "turnedOver", "camp"]);
|
||||
const numeric = value => Number.isInteger(value) && value >= 0 && value <= 99;
|
||||
const assert = (condition, message) => { if (!condition) throw new Error("梦三关卡配置：" + message); };
|
||||
|
||||
export function validateBattlePlan(plan) {
|
||||
assert(plan && Array.isArray(plan.units) && Array.isArray(plan.rules), "units/rules 必须为数组");
|
||||
assert(plan.units.length > 0 && plan.units.length <= 7 && plan.rules.length <= 32, "初始单位或规则数量越界");
|
||||
const ids = new Set(["player"]), ruleIds = new Set();
|
||||
const unit = spec => {
|
||||
assert(spec && typeof spec.id === "string" && /^[\w.-]+$/.test(spec.id) && !ids.has(spec.id), "单位 ID 无效或重复");
|
||||
ids.add(spec.id);
|
||||
assert(ids.size <= 8, "单场累计最多 8 个席位（含主角及后续援军）");
|
||||
assert(typeof spec.character === "string" && spec.character.length > 0 && camps.has(spec.camp), "武将或阵营无效");
|
||||
assert(spec.camp !== "neutral", "中立预设尚未启用");
|
||||
assert(spec.tier == null || ["normal", "elite", "boss"].includes(spec.tier), "怪物阶级无效");
|
||||
assert(spec.deck == null || (Array.isArray(spec.deck) && spec.deck.length > 0 && spec.deck.every(entry =>
|
||||
typeof entry === "string" && Boolean(entry) || entry && typeof entry.name === "string" && Boolean(entry.name) &&
|
||||
(entry.suit == null || ["spade", "heart", "club", "diamond"].includes(entry.suit)) &&
|
||||
(entry.number == null || Number.isInteger(entry.number) && entry.number >= 1 && entry.number <= 13))), "怪物专属牌堆无效");
|
||||
for (const key of ["hand", "hp", "maxHp"]) if (spec[key] != null) assert(numeric(spec[key]), key + " 越界");
|
||||
if (spec.hp != null) assert(spec.hp > 0, "初始体力必须大于 0");
|
||||
if (spec.maxHp != null) assert(spec.maxHp > 0 && (spec.hp == null || spec.hp <= spec.maxHp), "初始体力上限无效");
|
||||
assert(spec.inheritSkills == null || typeof spec.inheritSkills === "boolean", "inheritSkills 必须为布尔值");
|
||||
assert(spec.after == null || typeof spec.after === "string", "after 必须是单位 ID");
|
||||
assert(spec.equipment == null || (Array.isArray(spec.equipment) && spec.equipment.length <= 5), "equipment 无效");
|
||||
for (const card of spec.equipment || []) {
|
||||
assert(card && typeof card.name === "string" && card.name.length > 0, "初始装备名称无效");
|
||||
assert(["spade", "heart", "club", "diamond"].includes(card.suit), "初始装备花色无效");
|
||||
assert(Number.isInteger(card.number) && card.number >= 1 && card.number <= 13, "初始装备点数无效");
|
||||
}
|
||||
assert(spec.skills == null || (Array.isArray(spec.skills) && spec.skills.every(s => typeof s === "string")), "skills 无效");
|
||||
};
|
||||
plan.units.forEach(unit);
|
||||
for (const rule of plan.rules) {
|
||||
assert(rule && typeof rule.id === "string" && !ruleIds.has(rule.id), "规则 ID 重复或无效"); ruleIds.add(rule.id);
|
||||
assert(rule.when && events.has(rule.when.event || "state"), "触发时机无效");
|
||||
assert(rule.blocksVictory == null || typeof rule.blocksVictory === "boolean", "blocksVictory 必须为布尔值");
|
||||
assert(rule.when.round == null || (numeric(rule.when.round) && rule.when.round > 0), "轮数无效");
|
||||
assert(rule.when.actorTurns == null || (rule.when.event === "turnEnd" && rule.when.actor && numeric(rule.when.actorTurns) && rule.when.actorTurns > 0), "actorTurns 仅用于指定角色的回合结束");
|
||||
assert(rule.when.turn == null || (numeric(rule.when.turn) && rule.when.turn > 0), "回合数无效");
|
||||
assert(Array.isArray(rule.effects) && rule.effects.length > 0 && rule.effects.length <= 16, "效果列表无效");
|
||||
for (const effect of rule.effects) {
|
||||
assert(["spawn", "draw", "recover", "maxHp", "skill", "camp", "dialogue", "discardEquipment"].includes(effect.type), "未知效果");
|
||||
if (effect.type === "spawn") unit(effect.unit);
|
||||
else if (effect.type === "dialogue") {
|
||||
assert(Array.isArray(effect.lines) && effect.lines.every(line => line && ["character", "narrator", "sound", "choice"].includes(line.type) && typeof line.text === "string" && line.text.trim() && (line.type !== "character" || typeof line.character === "string") && (line.type !== "choice" || (/^story\.[\w.]+$/.test(line.flag || "") && Array.isArray(line.choices) && line.choices.length >= 1 && (line.defaultChoice == null || line.choices.some(choice => choice.id === line.defaultChoice))))), "dialogue 台词无效");
|
||||
}
|
||||
else {
|
||||
assert(typeof effect.target === "string", "效果缺少目标 ID");
|
||||
if (["draw", "recover", "maxHp"].includes(effect.type)) assert(numeric(effect.amount) && effect.amount > 0, "效果数值无效");
|
||||
if (effect.type === "discardEquipment") assert(typeof effect.name === "string" && effect.name.length > 0, "弃置装备名称无效");
|
||||
if (effect.type === "skill") assert(typeof effect.skill === "string" && effect.skill.length > 0, "技能 ID 无效");
|
||||
if (effect.type === "camp") assert(["ally", "enemy"].includes(effect.camp) && effect.target !== "player", "阵营无效或试图改变主角阵营");
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const rule of plan.rules) {
|
||||
assert(rule.when.actor == null || ids.has(rule.when.actor), "行动角色 ID 无效");
|
||||
assert(rule.when.all == null || (Array.isArray(rule.when.all) && rule.when.all.length <= 16), "条件列表无效");
|
||||
for (const condition of rule.when.all || []) {
|
||||
assert(ids.has(condition.unit) && checks.has(condition.field), "条件单位或字段无效");
|
||||
if (["hp", "hand"].includes(condition.field)) assert(["eq", "gte", "lte"].includes(condition.op) && numeric(condition.value), "数值比较无效");
|
||||
else if (condition.field === "camp") assert(camps.has(condition.value), "阵营条件无效");
|
||||
else assert(typeof condition.value === "boolean", "状态条件必须为布尔值");
|
||||
}
|
||||
for (const effect of rule.effects) if (!["spawn", "dialogue"].includes(effect.type)) assert(ids.has(effect.target), "效果目标不存在");
|
||||
}
|
||||
for (const spec of [...plan.units, ...plan.rules.flatMap(r => r.effects.filter(e => e.type === "spawn").map(e => e.unit))]) {
|
||||
assert(spec.after == null || (ids.has(spec.after) && spec.after !== spec.id), "after 席位目标无效");
|
||||
}
|
||||
return plan;
|
||||
}
|
||||
|
||||
export function grantSupport(run, rewardId, spec) {
|
||||
const supports = run.player.supports ||= [];
|
||||
const battles = spec.battles ?? -1;
|
||||
assert(battles === -1 || (Number.isInteger(battles) && battles > 0 && battles <= 99), "支援持续场数无效");
|
||||
// One support per source; repeated permanent items do not clone the same helper.
|
||||
const existing = supports.find(s => s.rewardId === rewardId);
|
||||
if (existing) { existing.battles = existing.battles === -1 || battles === -1 ? -1 : Math.min(99, existing.battles + battles); return; }
|
||||
const number = (run.supportSequence || 0) + 1;
|
||||
run.supportSequence = number;
|
||||
supports.push({ id: `support_${number}`, rewardId, category: spec.category || "item", unit: copy(spec.unit), battles });
|
||||
}
|
||||
|
||||
export function buildBattlePlan(encounter, run) {
|
||||
const plan = copy(encounter.battlePlan || {
|
||||
units: [{ id: "enemy_1", character: encounter.enemy, camp: "enemy", tier: encounter.tier || "normal", hand: 4 }], rules: [],
|
||||
});
|
||||
plan.rules ||= [];
|
||||
// Consumed only in the battle's run snapshot; the existing settlement commits it atomically.
|
||||
for (const support of run.player.supports || []) {
|
||||
if (support.battles === 0) continue;
|
||||
assert(support.battles === -1 || (Number.isInteger(support.battles) && support.battles > 0), "支援持续场数无效");
|
||||
plan.units.push({ ...copy(support.unit), id: support.id });
|
||||
}
|
||||
validateBattlePlan(plan);
|
||||
return plan;
|
||||
}
|
||||
|
||||
export function consumeSupports(run) {
|
||||
run.player.supports = (run.player.supports || []).map(s => ({ ...s, battles: s.battles > 0 ? s.battles - 1 : s.battles })).filter(s => s.battles !== 0);
|
||||
}
|
||||
|
||||
export function createBattleDirector(plan, adapters) {
|
||||
validateBattlePlan(plan);
|
||||
const units = new Map(), fired = new Set(), completedTurns = new Map(), seenPhases = new WeakSet();
|
||||
let round = 0, turn = 0, actor = null, ready = false, running = false, disposed = false;
|
||||
const compare = (actual, op, value) => op === "gte" ? actual >= value : op === "lte" ? actual <= value : actual === value;
|
||||
function matches(when, event) {
|
||||
if ((when.event || "state") !== event) return false;
|
||||
if (when.round != null && round < when.round) return false;
|
||||
if (when.turn != null && turn < when.turn) return false;
|
||||
if (when.actorTurns != null && (completedTurns.get(actor) || 0) < when.actorTurns) return false;
|
||||
if (when.actor != null && units.get(when.actor) !== actor) return false;
|
||||
return (when.all || []).every(condition => {
|
||||
const player = units.get(condition.unit);
|
||||
if (!player) return false;
|
||||
const state = adapters.state(player);
|
||||
return compare(state[condition.field], condition.op || "eq", condition.value);
|
||||
});
|
||||
}
|
||||
async function evaluate(event = "state") {
|
||||
if (!ready || disposed || running) return;
|
||||
running = true;
|
||||
try {
|
||||
// Every rule runs once per battle; marking before effects prevents recursive triggers.
|
||||
for (let pass = 0; pass <= plan.rules.length; pass++) {
|
||||
let changed = false;
|
||||
for (const rule of plan.rules) {
|
||||
if (disposed || !adapters.active()) return;
|
||||
if (fired.has(rule.id) || !matches(rule.when, event)) continue;
|
||||
fired.add(rule.id); changed = true;
|
||||
for (const effect of rule.effects) {
|
||||
if (disposed || !adapters.active()) return;
|
||||
if (effect.type === "dialogue") await adapters.dialogue(effect.lines);
|
||||
else if (effect.type === "spawn") {
|
||||
const anchor = effect.unit.after == null ? null : units.get(effect.unit.after);
|
||||
if (effect.unit.after != null && !anchor) throw new Error("支援席位目标尚未登场：" + effect.unit.after);
|
||||
units.set(effect.unit.id, await adapters.spawn(effect.unit, anchor));
|
||||
}
|
||||
else {
|
||||
const target = units.get(effect.target);
|
||||
if (target && adapters.state(target).alive) await adapters.effect(target, effect);
|
||||
}
|
||||
}
|
||||
adapters.log(rule.name || rule.id);
|
||||
}
|
||||
if (!changed) break;
|
||||
}
|
||||
} finally { running = false; }
|
||||
}
|
||||
return {
|
||||
bind(id, player) { if (units.has(id)) throw new Error("Duplicate battle unit: " + id); units.set(id, player); },
|
||||
async start() { ready = true; await evaluate("battleStart"); await evaluate("state"); },
|
||||
async beforeTurn(player) {
|
||||
turn++; actor = player;
|
||||
if (player === units.get("player")) { round++; await evaluate("roundStart"); }
|
||||
await evaluate("turnStart"); await evaluate("state");
|
||||
},
|
||||
async afterTurn(player, phase) {
|
||||
if (!ready || disposed || !adapters.active()) return;
|
||||
if (phase && seenPhases.has(phase)) return;
|
||||
if (phase) seenPhases.add(phase);
|
||||
actor = player;
|
||||
completedTurns.set(player, (completedTurns.get(player) || 0) + 1);
|
||||
await evaluate("turnEnd"); await evaluate("state");
|
||||
},
|
||||
evaluate,
|
||||
get ready() { return ready; },
|
||||
get busy() { return running; },
|
||||
get pendingEnemies() { return plan.rules.some(rule => rule.blocksVictory && !fired.has(rule.id) && rule.effects.some(e => (e.type === "spawn" && e.unit.camp === "enemy") || (e.type === "camp" && e.camp === "enemy"))); },
|
||||
get defeatedEnemies() { return [...units.values()].filter(p => { const s = adapters.state(p); return s.camp === "enemy" && !s.alive; }).length; },
|
||||
dispose() { disposed = true; units.clear(); },
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
// Candidate external coordinator. Finish callbacks return a boolean, NEVER a drain promise.
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
export function createBattleFlow({settlement, chooseReward, showMap, showEnding, quiesce, releaseSkills = async () => {}, presentVictory = async () => {}}) {
|
||||
let state = "map", active = null, work = null, job = null, error = null;
|
||||
async function drive() {
|
||||
try {
|
||||
state = "draining";
|
||||
await active.session.drain();
|
||||
// Allow mode-start/parent frames and foreign pauses to unwind; never resume them.
|
||||
await quiesce();
|
||||
if (!job.pending) job.pending = await settlement.prepare(job.input);
|
||||
if (job.pending.outcome === "victory" && !job.victoryPresented) {
|
||||
await presentVictory(copy(job.pending));
|
||||
job.victoryPresented = true;
|
||||
}
|
||||
if (job.pending.state !== "chosen") {
|
||||
state = "choosing";
|
||||
if (!job.hasChoice) {
|
||||
job.choiceId = job.pending.outcome === "defeat" || !job.pending.choices.length ? null : await chooseReward(copy(job.pending.choices));
|
||||
if (job.pending.outcome !== "defeat" && job.pending.choices.length && !job.pending.choices.some(c => c.id === job.choiceId)) throw new Error("Invalid reward selection");
|
||||
job.hasChoice = true;
|
||||
}
|
||||
job.pending = await settlement.choose(job.input.run.runId, job.pending.id, job.choiceId);
|
||||
}
|
||||
if (!job.committed) {
|
||||
state = "committing";
|
||||
job.committed = await settlement.commit(job.input.run.runId, job.pending.id);
|
||||
}
|
||||
if (!job.skillsReleased) {
|
||||
state = "releasingSkills";
|
||||
await releaseSkills();
|
||||
job.skillsReleased = true;
|
||||
await quiesce();
|
||||
}
|
||||
state = "cleaning";
|
||||
await active.session.dispose(); // Failed cleanup retry does NOT replay a committed reward.
|
||||
await quiesce();
|
||||
if (!job.delivered) {
|
||||
state = "presenting";
|
||||
if (job.committed.route === "map") job.nextNode = await showMap(copy(job.committed.run));
|
||||
else await showEnding(job.committed.route, copy(job.committed.run));
|
||||
job.delivered = true;
|
||||
}
|
||||
state = job.committed.route === "map" ? "map" : "ended";
|
||||
return {...copy(job.committed), nextNode:copy(job.nextNode ?? null)};
|
||||
} catch (cause) {
|
||||
error = cause; state = "retryable"; throw cause;
|
||||
}
|
||||
}
|
||||
function launch() {
|
||||
error = null; state = "draining";
|
||||
work = Promise.resolve().then(drive);
|
||||
// The engine callback is fire-and-forget; keep failure observable without unhandled rejection.
|
||||
work.catch(() => {});
|
||||
}
|
||||
return Object.freeze({
|
||||
get state() { return state; },
|
||||
get error() { return error; },
|
||||
async enterBattle({session, run, node, encounter, start}) {
|
||||
if (state !== "map") throw new Error("Map handoff not ready");
|
||||
if (run.battleFlow?.pending) throw new Error("Resume pending settlement before battle");
|
||||
const saved = settlement.readRun();
|
||||
if (!saved || saved.runId !== run.runId || saved.revision !== run.revision) throw new Error("Stale battle input");
|
||||
state = "starting";
|
||||
try {
|
||||
await quiesce();
|
||||
active = {session, run, node:copy(node), encounter:copy(encounter)};job = null;work = null;
|
||||
// start MUST schedule only; it must not await the battle root's completion.
|
||||
state = "battle"; start();
|
||||
} catch (cause) { state = "blocked"; error = cause; throw cause; }
|
||||
},
|
||||
requestFinish({session, hp, outcome = "victory", defeatedEnemies = 1}) {
|
||||
if (state !== "battle" || session !== active.session) return false;
|
||||
if (!["victory", "defeat"].includes(outcome)) throw new Error("Unknown outcome");
|
||||
if (!Number.isInteger(defeatedEnemies) || defeatedEnemies < 0) throw new Error("Invalid defeated enemy count");
|
||||
job = {input:{run:copy(active.run),node:copy(active.node),encounter:{...copy(active.encounter),defeatedEnemies},hp,outcome}};
|
||||
state = "stopping";
|
||||
active.session.requestStop();
|
||||
launch();
|
||||
return true; // No game.pause/resume: stop loop, let current body unwind, then open rewards.
|
||||
},
|
||||
resumePending({session}) {
|
||||
if (state !== "map") throw new Error("Cannot resume during another operation");
|
||||
const run = settlement.readRun(), item = run?.battleFlow?.pending;
|
||||
if (!item) throw new Error("No durable pending settlement");
|
||||
active = {session};
|
||||
job = {input:{run}, pending:copy(item)};
|
||||
state = "stopping"; session.requestStop(); launch(); return work;
|
||||
},
|
||||
retry() {
|
||||
if (state !== "retryable") throw new Error("No failed settlement to retry");
|
||||
launch(); return work;
|
||||
},
|
||||
wait() { if (!work) throw new Error("No settlement requested"); return work; },
|
||||
});
|
||||
}
|
||||
|
||||
// Run outside engine events. No busy poll, no global queue clearing, no pause ownership guessing.
|
||||
export async function quiesceEngine({eventManager, pauseManager}, nextTask = () => new Promise(resolve => setTimeout(resolve, 0))) {
|
||||
await nextTask();
|
||||
await pauseManager.waitPause();
|
||||
if (eventManager.eventStack.length || eventManager.tempEvent) throw new Error("Engine event stack is not idle");
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
// Track only the turn created by this battle's cooperative loop.
|
||||
const battleTurns = new WeakMap();
|
||||
const turnStages = new Set(["phase", "phaseZhunbei", "phaseJudge", "phaseDraw", "phaseUse", "phaseDiscard", "phaseJieshu"]);
|
||||
|
||||
export function stopBattleTurn(session, eventManager) {
|
||||
const turn = battleTurns.get(session);
|
||||
if (!turn) return;
|
||||
const belongsToTurn = event => {
|
||||
const seen = new Set();
|
||||
while (event && !seen.has(event)) {
|
||||
if (event === turn) return true;
|
||||
seen.add(event);
|
||||
event = event.parent;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
// Finish phase controllers, not the card/damage/death events currently resolving.
|
||||
// Those events must unwind before the session can safely dispose players.
|
||||
for (const event of eventManager.eventStack.slice().reverse()) {
|
||||
if (turnStages.has(event.name) && belongsToTurn(event)) event.finish();
|
||||
}
|
||||
turn.finish();
|
||||
}
|
||||
|
||||
// Candidate derived from local engine phaseLoop; no global replacement.
|
||||
export async function runPhaseLoop(event, player, session, { game, lib, _status, get, beforeTurn = async () => {} }) {
|
||||
let num = 1;
|
||||
let current = player;
|
||||
while (session.active && !event.finished && current.getSeatNum() === 0) {
|
||||
current.setSeatNum(num);
|
||||
current = current.next;
|
||||
num++;
|
||||
}
|
||||
while (session.active && !event.finished) {
|
||||
if (game.players.includes(event.player)) {
|
||||
await beforeTurn(event.player);
|
||||
if (!session.active || event.finished) return;
|
||||
lib.onphase.forEach((i) => i());
|
||||
if (!session.active || event.finished) return;
|
||||
const phase = event.player.phase();
|
||||
battleTurns.set(session, phase);
|
||||
try {
|
||||
event.next.remove(phase);
|
||||
let isRoundEnd = false;
|
||||
if (lib.onround.every((i) => i(phase, event.player))) {
|
||||
isRoundEnd = _status.roundSkipped;
|
||||
if (_status.isRoundFilter) {
|
||||
isRoundEnd = _status.isRoundFilter(phase, event.player);
|
||||
} else if (_status.seatNumSettled) {
|
||||
const seatNum = event.player.getSeatNum();
|
||||
if (seatNum != 0) {
|
||||
if (get.itemtype(_status.lastPhasedPlayer) != "player" || seatNum < _status.lastPhasedPlayer.getSeatNum()) {
|
||||
isRoundEnd = true;
|
||||
}
|
||||
}
|
||||
} else if (event.player == _status.roundStart) {
|
||||
isRoundEnd = true;
|
||||
}
|
||||
if (isRoundEnd && _status.globalHistory.some((i) => i.isRound)) {
|
||||
game.log();
|
||||
await event.trigger("roundEnd");
|
||||
}
|
||||
}
|
||||
if (!session.active || event.finished) { phase.finish(); return; }
|
||||
event.next.push(phase);
|
||||
await phase;
|
||||
} finally {
|
||||
if (battleTurns.get(session) === phase) battleTurns.delete(session);
|
||||
}
|
||||
}
|
||||
if (!session.active || event.finished) return;
|
||||
await event.trigger("phaseOver");
|
||||
if (!session.active || event.finished) return;
|
||||
const findNext = (current2) => {
|
||||
const players = game.players.slice(0).concat(game.dead).sort((a, b) => parseInt(a.dataset.position) - parseInt(b.dataset.position));
|
||||
const position = parseInt(current2.dataset.position);
|
||||
for (const player2 of players) {
|
||||
if (parseInt(player2.dataset.position) > position) {
|
||||
return player2;
|
||||
}
|
||||
}
|
||||
return players[0];
|
||||
};
|
||||
event.player = findNext(event.player);
|
||||
if (!event.player) return;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
// Exclusive battle resources. Never clear arbitrary global queues or arbitrary timers.
|
||||
export function createBattleResources(session, {game, ui, _status}) {
|
||||
const cards = new Set(), nodes = new Map(), fields = [];
|
||||
const containers = () => [ui.arena, ui.control, ui.sidebar, ui.cardPile, ui.discardPile, ui.ordering, ui.special].filter(Boolean);
|
||||
const children = () => new Map(containers().map(parent => [parent, new Set(parent.childNodes)]));
|
||||
const before = children();
|
||||
const uiKeys = ["me","handcards1Container","handcards2Container","handcards1","handcards2"];
|
||||
const uiBefore = new Map(uiKeys.map(key => [key,Object.getOwnPropertyDescriptor(ui,key)]));
|
||||
function field(object, key, value) {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(object, key);
|
||||
object[key] = value;
|
||||
fields.push({object,key,value,descriptor});
|
||||
return value;
|
||||
}
|
||||
// Install before root.start so global history cannot retain the finished battle tree.
|
||||
field(_status, "globalHistory", [{cardMove:[],custom:[],useCard:[],changeHp:[],everything:[]}]);
|
||||
field(_status, "cardtag", Object.fromEntries(Object.keys(_status.cardtag || {}).map(key => [key,[]])));
|
||||
const counters = {phaseNumber:game.phaseNumber, roundNumber:game.roundNumber};
|
||||
game.phaseNumber = 0; game.roundNumber = 0;
|
||||
session.ownResource({}, () => {
|
||||
for (const card of cards) card.remove();
|
||||
for (const [node,parent] of nodes) if (node.parentNode === parent) node.remove();
|
||||
for (const {object,key,value,descriptor} of fields.reverse()) {
|
||||
if (object[key] !== value) continue; // A replacement owned by another subsystem survives.
|
||||
if (descriptor) Object.defineProperty(object,key,descriptor); else delete object[key];
|
||||
}
|
||||
game.phaseNumber = counters.phaseNumber; game.roundNumber = counters.roundNumber;
|
||||
});
|
||||
return Object.freeze({
|
||||
field,
|
||||
card(card) { cards.add(card); return card; },
|
||||
capturePreparedArena() {
|
||||
for (const key of uiKeys) {
|
||||
const descriptor = uiBefore.get(key);
|
||||
if (ui[key] !== descriptor?.value) fields.push({object:ui,key,value:ui[key],descriptor});
|
||||
}
|
||||
// Call synchronously after prepareArena, with onfree already drained.
|
||||
for (const parent of containers()) {
|
||||
const prior = before.get(parent) || new Set();
|
||||
for (const node of parent.childNodes) if (!prior.has(node)) {
|
||||
if ([ui.cardPile,ui.discardPile,ui.ordering,ui.special].includes(parent)) cards.add(node);
|
||||
else nodes.set(node,parent);
|
||||
}
|
||||
}
|
||||
},
|
||||
bindPlayers(players) {
|
||||
const owned = new Set(players);
|
||||
session.ownResource({}, () => {
|
||||
for (const key of ["currentPhase","lastPhasedPlayer","roundStart"]) {
|
||||
if (owned.has(_status[key])) delete _status[key];
|
||||
}
|
||||
});
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
// Candidate only. No engine globals, event prototype patches, or save writes.
|
||||
const owners = new WeakMap();
|
||||
|
||||
export function createBattleSession(id) {
|
||||
if (typeof id !== "string" || !id.trim()) throw new TypeError("Session ID required");
|
||||
const token = Object.freeze({ id });
|
||||
let state = "running", disposePromise = null;
|
||||
const pending = new Set(), events = new Set(), resources = new Map(), errors = [];
|
||||
const waiters = new Set();
|
||||
const notify = () => { for (const wake of waiters) wake(); waiters.clear(); };
|
||||
const ensureRunning = () => { if (state !== "running") throw new Error("Session is stopping"); };
|
||||
const claim = object => {
|
||||
if (!object || (typeof object !== "object" && typeof object !== "function")) throw new TypeError("Object required");
|
||||
const owner = owners.get(object);
|
||||
if (owner && owner !== token) throw new Error("Foreign session resource");
|
||||
owners.set(object, token);
|
||||
};
|
||||
// Observe a native completion promise; never assimilate GameEvent.then(), which can start queues.
|
||||
const observe = promise => {
|
||||
if (!(promise instanceof Promise)) throw new TypeError("Native completion Promise required");
|
||||
pending.add(promise);
|
||||
promise.then(() => { pending.delete(promise); notify(); }, error => {
|
||||
errors.push(error); pending.delete(promise); notify();
|
||||
});
|
||||
return promise;
|
||||
};
|
||||
const api = {
|
||||
id,
|
||||
get state() { return state; },
|
||||
get active() { return state === "running"; },
|
||||
get pendingCount() { return pending.size; },
|
||||
guard(callback) {
|
||||
if (typeof callback !== "function") throw new TypeError("Callback required");
|
||||
return (...args) => state === "running" ? callback(...args) : undefined;
|
||||
},
|
||||
runTask(factory) {
|
||||
ensureRunning();
|
||||
if (typeof factory !== "function") throw new TypeError("Task factory required");
|
||||
// Reserve before invoking user code so a stop request inside it cannot race drain().
|
||||
return observe(Promise.resolve().then(() => state === "running" ? factory(api) : undefined));
|
||||
},
|
||||
ownEvent(event, completion) {
|
||||
ensureRunning();
|
||||
if (typeof event?.finish !== "function" || !(completion instanceof Promise)) throw new TypeError("Event and native completion required");
|
||||
claim(event);
|
||||
if (events.has(event)) throw new Error("Event already registered");
|
||||
events.add(event); observe(completion);
|
||||
return event;
|
||||
},
|
||||
ownResource(resource, release) {
|
||||
ensureRunning();
|
||||
if (typeof release !== "function") throw new TypeError("Release function required");
|
||||
claim(resource);
|
||||
if (resources.has(resource)) throw new Error("Resource already registered");
|
||||
resources.set(resource, release);
|
||||
return resource;
|
||||
},
|
||||
requestStop() {
|
||||
if (state !== "running") return false;
|
||||
state = "stopping";
|
||||
// Only explicitly registered events. Do not erase global next/after or guess ownership.
|
||||
for (const event of events) {
|
||||
try { event.finish(); } catch (error) { errors.push(error); }
|
||||
}
|
||||
notify();
|
||||
return true;
|
||||
},
|
||||
async drain() {
|
||||
if (state === "running") throw new Error("requestStop required before drain");
|
||||
// Must be awaited by an external coordinator, not from a task tracked by this session.
|
||||
while (pending.size) await new Promise(resolve => waiters.add(resolve));
|
||||
if (errors.length) throw new AggregateError(errors, "Battle tasks failed; cleanup blocked");
|
||||
if (state === "stopping") state = "drained";
|
||||
},
|
||||
dispose() {
|
||||
if (state === "disposed") return Promise.resolve();
|
||||
if (disposePromise) return disposePromise;
|
||||
if (state !== "drained") return Promise.reject(new Error("Drain must complete before disposal"));
|
||||
state = "disposing";
|
||||
disposePromise = (async () => {
|
||||
// Reverse acquisition order; stop at first failure to preserve dependent resources.
|
||||
for (const [resource, release] of [...resources].reverse()) {
|
||||
await release(resource);
|
||||
resources.delete(resource); owners.delete(resource);
|
||||
}
|
||||
for (const event of events) owners.delete(event);
|
||||
events.clear(); state = "disposed";
|
||||
})().catch(error => { state = "drained"; throw error; }).finally(() => { disposePromise = null; });
|
||||
return disposePromise;
|
||||
},
|
||||
};
|
||||
return Object.freeze(api);
|
||||
}
|
||||
|
||||
// A reused ID must never cause old-session cleanup to delete the new player's entry.
|
||||
export function ownPlayerIndex(session, player, playerMap) {
|
||||
const id = player.playerid;
|
||||
if (!id || playerMap[id] !== player) throw new Error("Player must be registered first");
|
||||
return session.ownResource(player, () => { if (playerMap[id] === player) delete playerMap[id]; });
|
||||
}
|
||||
|
||||
// Engine pause booleans are not ownership tokens. Accept a lease from a coordinator instead.
|
||||
export function ownPauseLease(session, lease) {
|
||||
if (typeof lease?.release !== "function") throw new TypeError("Pause lease required");
|
||||
return session.ownResource(lease, () => lease.release());
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
// Candidate settlement adapter. Dependencies are the current mode/state reward functions.
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
const idFor = (run, node) => JSON.stringify([run.runId, run.actIndex, node.id]);
|
||||
export function createBattleSettlement({store, config, getRandomRewardChoices, applyReward, completeNode, enterNextAct, now = Date.now}) {
|
||||
const readRun = () => store.read()[config.saveKey];
|
||||
function current(storage, runId) {
|
||||
const run = storage[config.saveKey];
|
||||
if (!run || run.runId !== runId) throw new Error("Stale run: settlement refused");
|
||||
run.battleFlow ||= { receipts: [], pending: null };
|
||||
return run;
|
||||
}
|
||||
function pending(storage, runId, id) {
|
||||
const run = current(storage, runId), item = run.battleFlow.pending;
|
||||
if (!item || item.id !== id) throw new Error("Settlement checkpoint mismatch");
|
||||
return {run, item};
|
||||
}
|
||||
return Object.freeze({
|
||||
readRun,
|
||||
// Persist fixed candidates before opening choice UI. No mutation of the live run.
|
||||
async prepare({run: snapshot, node, encounter, hp, outcome = "victory"}) {
|
||||
if (!["victory", "defeat"].includes(outcome)) throw new Error("Unknown battle outcome");
|
||||
if (outcome === "victory" && (!Number.isFinite(hp) || !Number.isFinite(encounter.gold) || encounter.gold < 0)) throw new Error("Invalid battle result");
|
||||
const id = idFor(snapshot, node);
|
||||
return store.update(storage => {
|
||||
const run = current(storage, snapshot.runId);
|
||||
if (run.battleFlow.receipts.includes(id)) throw new Error("Battle already settled");
|
||||
if (run.battleFlow.pending) {
|
||||
if (run.battleFlow.pending.id !== id) throw new Error("Another settlement is pending");
|
||||
return run.battleFlow.pending;
|
||||
}
|
||||
if (run.actIndex !== snapshot.actIndex || run.revision !== snapshot.revision ||
|
||||
run.map?.nodes.find(n => n.id === node.id)?.completed !== false) {
|
||||
throw new Error("Stale node or revision");
|
||||
}
|
||||
// Battle may have changed RNG/card state since the last checkpoint.
|
||||
const base = copy(snapshot); delete base.battleFlow;
|
||||
if (outcome === "victory") {
|
||||
base.player.hp = Math.max(1, Math.min(hp, base.player.maxHp ?? hp));
|
||||
base.player.gold += encounter.gold;
|
||||
base.statistics.goldEarned += encounter.gold;
|
||||
base.statistics.defeatedEnemies += encounter.defeatedEnemies ?? 1;
|
||||
}
|
||||
const choices = outcome === "victory" && !encounter.skipRandomReward ? getRandomRewardChoices(base, encounter.rewardPool).filter(c => c.name) : [];
|
||||
if (outcome === "victory" && !encounter.skipRandomReward && !choices.length) throw new Error("Empty battle reward pool");
|
||||
run.battleFlow.pending = {id, state:"awaitingChoice", nodeId:node.id, base, choices:copy(choices), fixedRewards:copy(encounter.fixedRewards || []), victoryDialogue:copy(encounter.victoryDialogue || []), boss:!!encounter.boss, outcome};
|
||||
return run.battleFlow.pending;
|
||||
});
|
||||
},
|
||||
async choose(runId, id, choiceId) {
|
||||
return store.update(storage => {
|
||||
const {item} = pending(storage, runId, id);
|
||||
if (item.state === "chosen") {
|
||||
if (item.choiceId !== choiceId) throw new Error("Choice already locked");
|
||||
return item;
|
||||
}
|
||||
const result = copy(item.base);
|
||||
let route = "defeat";
|
||||
if (item.outcome === "victory") {
|
||||
const choice = item.choices.find(c => c.id === choiceId);
|
||||
if (item.choices.length) {
|
||||
if (!choice) throw new Error("Reward is not a fixed candidate");
|
||||
applyReward(result, choice.effectId || choice.id);
|
||||
} else if (choiceId !== null) throw new Error("Unexpected reward selection");
|
||||
for (const rewardId of item.fixedRewards || []) applyReward(result, rewardId);
|
||||
if (!completeNode(result, item.nodeId)) throw new Error("Node completion failed");
|
||||
route = item.boss && !enterNextAct(result) ? "victory" : "map";
|
||||
} else result.status = "failed";
|
||||
// Save the exact result (including random card ID/target) before final commit.
|
||||
item.state = "chosen"; item.choiceId = choiceId; item.result = result;
|
||||
item.route = route; item.completedAt = now();
|
||||
return item;
|
||||
});
|
||||
},
|
||||
async commit(runId, id) {
|
||||
return store.update(storage => {
|
||||
const saved = storage[config.saveKey];
|
||||
const prior = storage[config.profileKey]?.completedRuns?.find(r => r.runId === runId && r.settlementId === id);
|
||||
if (!saved && prior) return {route:prior.outcome, run:null, duplicate:true};
|
||||
if (saved?.runId === runId && saved.battleFlow?.receipts?.includes(id)) return {route:"map", run:saved, duplicate:true};
|
||||
const {run, item} = pending(storage, runId, id);
|
||||
if (item.state !== "chosen") throw new Error("Durable chosen result required");
|
||||
const result = copy(item.result);
|
||||
result.battleFlow = {receipts:[...run.battleFlow.receipts, id], pending:null};
|
||||
if (item.route === "map") storage[config.saveKey] = result;
|
||||
else {
|
||||
const profile = storage[config.profileKey] ||= {wins:0, completedRuns:[]};
|
||||
profile.completedRuns ||= [];
|
||||
if (!profile.completedRuns.some(r => r.runId === runId)) {
|
||||
if (item.route === "victory") profile.wins = (profile.wins || 0) + 1;
|
||||
profile.completedRuns.push({runId, settlementId:id, outcome:item.route, character:result.player.character,
|
||||
completedNodes:result.statistics.completedNodes, goldEarned:result.statistics.goldEarned, completedAt:item.completedAt});
|
||||
}
|
||||
delete storage[config.saveKey]; // Same transaction as profile; never a second clear write.
|
||||
}
|
||||
return {route:item.route, run:result, duplicate:false};
|
||||
});
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,174 @@
|
||||
import { lib, get, ui } from "../../../../noname.js";
|
||||
|
||||
const suits = { spade: "♠ 黑桃", heart: "♥ 红桃", club: "♣ 梅花", diamond: "♦ 方块" };
|
||||
const types = { basic: "基本牌", trick: "锦囊牌", delay: "延时锦囊", equip: "装备牌" };
|
||||
const affixes = { annihilate: "湮灭：使用后进入本场湮灭区，不再参与本场个人弃牌堆洗切。" };
|
||||
const text = value => {
|
||||
const template = document.createElement("template");
|
||||
// Translation markup is parsed inertly; only plain text is inserted into the UI.
|
||||
template.innerHTML = String(value ?? "").replace(/<br\s*\/?\s*>/gi, "\n");
|
||||
return template.content.textContent.trim();
|
||||
};
|
||||
const translate = value => text(lib.translate[value] || get.translation(value) || value);
|
||||
|
||||
export function describeLibraryCard(card) {
|
||||
const info = lib.card[card.name];
|
||||
const nature = typeof card.nature === "string" ? card.nature.split("|").filter(Boolean).map(translate).join("、") : "";
|
||||
return {
|
||||
name: translate(card.name), suit: suits[card.suit] || "无花色",
|
||||
number: ({ 1: "A", 11: "J", 12: "Q", 13: "K" })[card.number] || String(card.number ?? "—"),
|
||||
nature: nature || "无属性", type: types[info?.type] || "未知类别",
|
||||
red: card.suit === "heart" || card.suit === "diamond",
|
||||
description: text(lib.translate[`${card.name}_info`] || "暂无卡牌介绍。"),
|
||||
affixes: (Array.isArray(card.affixes) ? card.affixes : []).map(key => affixes[key] || `词缀：${translate(key)}`),
|
||||
upgrade: Number.isFinite(card.upgrade) ? card.upgrade : 0,
|
||||
available: Boolean(info),
|
||||
};
|
||||
}
|
||||
|
||||
function element(tag, className, value, parent) {
|
||||
const node = document.createElement(tag);
|
||||
node.className = className;
|
||||
if (value != null) node.textContent = value;
|
||||
parent?.appendChild(node);
|
||||
return node;
|
||||
}
|
||||
|
||||
function button(label, parent, action, className = "ms-deck-button") {
|
||||
const node = element("button", className, label, parent);
|
||||
node.type = "button";
|
||||
node.addEventListener("click", action);
|
||||
return node;
|
||||
}
|
||||
|
||||
// Read-only DOM previews, never game.createCard or Card.init: no IDs, triggers or pile writes.
|
||||
function preview(card, details, parent) {
|
||||
const face = element("div", "ms-deck-face", null, parent);
|
||||
element("span", `ms-deck-corner${details.red ? " ms-deck-red" : ""}`, `${details.suit} ${details.number}`, face);
|
||||
const art = element("div", "ms-deck-art", null, face);
|
||||
element("span", "ms-deck-glyph", details.name, art);
|
||||
const imageName = lib.card[card.name]?.cardimage || card.name;
|
||||
// Only mode-standard local art paths; unknown or missing art keeps the text fallback.
|
||||
if (/^[a-zA-Z0-9_]+$/.test(imageName)) {
|
||||
const image = element("img", "ms-deck-image", null, art);
|
||||
image.alt = "";
|
||||
image.loading = "lazy";
|
||||
image.addEventListener("error", () => image.remove(), { once: true });
|
||||
image.src = `${lib.assetURL || ""}image/card/${imageName}.png`;
|
||||
}
|
||||
element("strong", "ms-deck-name", details.name, face);
|
||||
element("span", "ms-deck-meta", `${details.type} · ${details.nature}`, face);
|
||||
if (details.upgrade || details.affixes.length) {
|
||||
element("span", "ms-deck-tags", [details.upgrade ? `强化 +${details.upgrade}` : "", ...details.affixes.map(value => value.split("：")[0])].filter(Boolean).join(" · "), face);
|
||||
}
|
||||
return face;
|
||||
}
|
||||
|
||||
export function openCardLibrary(run, options = {}) {
|
||||
const existing = document.querySelector("dialog.mengsan-deck-dialog-shuying[open]");
|
||||
if (existing) { existing.focus(); return () => {}; }
|
||||
const previousFocus = document.activeElement;
|
||||
const dialog = element("dialog", "mengsan-deck-dialog-shuying", null);
|
||||
dialog.setAttribute("aria-label", options.title || "卡牌库");
|
||||
const header = element("header", "ms-deck-header", null, dialog);
|
||||
const title = element("div", "ms-deck-title-group", null, header);
|
||||
element("span", "ms-deck-eyebrow", options.eyebrow || "梦三 · 行囊", title);
|
||||
element("h2", "ms-deck-title", options.title || "卡牌库", title);
|
||||
let closed = false;
|
||||
const close = () => {
|
||||
if (closed) return;
|
||||
closed = true;
|
||||
if (dialog.open) dialog.close();
|
||||
dialog.remove();
|
||||
if (previousFocus?.isConnected) previousFocus.focus();
|
||||
};
|
||||
button("关闭", header, close);
|
||||
const summary = element("p", "ms-deck-summary", null, dialog);
|
||||
const body = element("div", "ms-deck-body", null, dialog);
|
||||
const footer = element("p", "ms-deck-footer", "点击卡牌查看完整介绍 · 仅供查看，不改变牌组或抽牌顺序", dialog);
|
||||
const current = Array.isArray(run?.player?.deck) ? run.player.deck : [];
|
||||
let detail = false, selectedButton = null, scrollTop = 0;
|
||||
const list = element("div", "ms-deck-grid", null, body);
|
||||
const detailPanel = element("section", "ms-deck-detail", null, body);
|
||||
detailPanel.hidden = true;
|
||||
function back() {
|
||||
detail = false; detailPanel.hidden = true; list.hidden = false;
|
||||
detailPanel.replaceChildren(); body.scrollTop = scrollTop;
|
||||
selectedButton?.focus({ preventScroll: true });
|
||||
}
|
||||
function showDetail(card, details, owner) {
|
||||
selectedButton = owner; scrollTop = body.scrollTop;
|
||||
detail = true; list.hidden = true; detailPanel.hidden = false;
|
||||
detailPanel.replaceChildren();
|
||||
const backButton = button("返回牌库", detailPanel, back);
|
||||
const content = element("div", "ms-deck-detail-content", null, detailPanel);
|
||||
preview(card, details, content);
|
||||
const copy = element("div", "ms-deck-detail-copy", null, content);
|
||||
element("h3", "", details.name, copy);
|
||||
element("p", "", `${details.suit} ${details.number} · ${details.type} · ${details.nature}`, copy);
|
||||
element("h4", "", "卡牌介绍", copy);
|
||||
element("p", "ms-deck-rules", details.description, copy);
|
||||
if (!details.available) element("p", "ms-deck-warning", "该卡牌定义未加载；保留存档记录，不删除此牌。", copy);
|
||||
if (details.upgrade) element("p", "", `强化等级：${details.upgrade}（实际效果以玩法规则为准）`, copy);
|
||||
for (const affix of details.affixes) element("p", "ms-deck-rules", affix, copy);
|
||||
body.scrollTop = 0; backButton.focus();
|
||||
}
|
||||
function render() {
|
||||
detail = false; list.hidden = false; detailPanel.hidden = true;
|
||||
detailPanel.replaceChildren(); list.replaceChildren(); body.scrollTop = 0;
|
||||
const sections = options.sections ? options.sections() : [{ title: "", cards: current }];
|
||||
summary.textContent = options.sections ? "剩余牌堆按从左到右、从上到下的顺序摸取；第 1 张为下一张。" : `本次征程实际携带 · 共 ${current.length} 张 · 同名不同花色、点数分别展示`;
|
||||
for (const section of sections) {
|
||||
const cards = section.cards;
|
||||
if (section.title) element("h3", "ms-deck-section", `${section.title} · ${cards.length} 张`, list);
|
||||
if (!cards.length) element("p", "ms-deck-empty", section.ordered ? "剩余牌堆为空；下一次摸牌需按规则洗切弃牌堆，洗切后的顺序尚未确定。" : "此处暂无卡牌。", list);
|
||||
cards.forEach((card, index) => {
|
||||
const details = describeLibraryCard(card);
|
||||
const tile = button("", list, () => showDetail(card, details, tile), "ms-deck-card");
|
||||
tile.setAttribute("aria-label", `${section.ordered ? `第 ${index + 1} 张，` : ""}${details.name}，${details.suit}${details.number}，${details.nature}，查看详情`);
|
||||
if (section.ordered) element("span", "ms-deck-order", index === 0 ? "1 · 下一张" : `${index + 1}`, tile);
|
||||
preview(card, details, tile);
|
||||
element("span", "ms-deck-excerpt", details.description, tile);
|
||||
});
|
||||
}
|
||||
}
|
||||
dialog.addEventListener("cancel", event => { event.preventDefault(); if (detail) back(); else close(); });
|
||||
dialog.addEventListener("close", close);
|
||||
// Prevent the map's Escape/Tab handler from acting behind this modal.
|
||||
dialog.addEventListener("keydown", event => event.stopPropagation());
|
||||
render();
|
||||
document.body.appendChild(dialog);
|
||||
try { dialog.showModal(); } catch (error) { close(); throw error; }
|
||||
header.querySelector("button").focus();
|
||||
close.refresh = () => {
|
||||
if (closed) return;
|
||||
// Rebuild from live arrays after a pile mutation, including while viewing details.
|
||||
const wasDetail = detail, offset = body.scrollTop;
|
||||
render(); body.scrollTop = offset;
|
||||
if (wasDetail) header.querySelector("button").focus();
|
||||
};
|
||||
return close;
|
||||
}
|
||||
|
||||
// Only the player's two mode-owned piles are exposed. No hand/equipment/exhaust/global pile.
|
||||
export function mountBattlePiles(session, battle) {
|
||||
let closeDialog = null, disposed = false;
|
||||
const control = button("牌堆", ui.window, () => {
|
||||
if (disposed || !session.active || battle.resolving) return;
|
||||
closeDialog?.();
|
||||
closeDialog = openCardLibrary(null, {
|
||||
title: "战斗牌堆", eyebrow: "梦三 · 个人牌堆",
|
||||
sections: () => [
|
||||
{ title: "剩余牌堆", cards: battle.drawPile, ordered: true },
|
||||
{ title: "弃牌堆", cards: battle.discardPile, ordered: false },
|
||||
],
|
||||
});
|
||||
}, "mengsan-battle-piles-button-shuying");
|
||||
control.setAttribute("aria-haspopup", "dialog");
|
||||
const dispose = () => {
|
||||
if (disposed) return;
|
||||
disposed = true; closeDialog?.(); closeDialog = null; control.remove();
|
||||
};
|
||||
session.ownResource(control, dispose);
|
||||
return { dispose, refresh() { if (!disposed) closeDialog?.refresh?.(); } };
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
// 梦三独有的出牌经济，不修改 noname 的全局牌定义。
|
||||
import { _status } from "../../../../noname.js";
|
||||
export const PLAYER_ENERGY = 3;
|
||||
export const PLAYER_HAND_LIMIT = 3;
|
||||
export const SHA_DAMAGE = 4;
|
||||
|
||||
const COSTS = Object.freeze({ sha: 1, tao: 1, jiu: 1, shan: 0, wuxie: 0,
|
||||
juedou: 2, nanman: 2, wanjian: 2, taoyuan: 2 });
|
||||
|
||||
export const cardCost = card => COSTS[card?.name] ?? 1;
|
||||
|
||||
export const isActiveCardUse = (event, player) => {
|
||||
if (!event || !player) return false;
|
||||
const seen = new Set();
|
||||
let inPhaseUse = false;
|
||||
for (let current = event; current && !seen.has(current); current = current.parent) {
|
||||
seen.add(current);
|
||||
if (current.name === "dying" || current.name === "chooseToRespond") return false;
|
||||
if (current.name === "chooseToUse" && (current.respondTo || String(current.type || "").startsWith("respond"))) return false;
|
||||
if (current.name === "phaseUse" && current.player === player) inPhaseUse = true;
|
||||
}
|
||||
// 某些扩展创建的主动 useCard 事件不保留 phaseUse 父链。
|
||||
return inPhaseUse || (event.name === "useCard" && event.player === player &&
|
||||
_status.currentPhase === player);
|
||||
};
|
||||
|
||||
export const canPayCard = (player, card) => (player?.storage?.mengsanEnergy_shuying ?? Infinity) >= cardCost(card);
|
||||
|
||||
export const payCard = (player, card) => {
|
||||
if (!canPayCard(player, card)) return false;
|
||||
player.storage.mengsanEnergy_shuying -= cardCost(card);
|
||||
return true;
|
||||
};
|
||||
@@ -0,0 +1,17 @@
|
||||
export const isDialogueLineVisible = (line, run) => !line.when || run?.storyFlags?.[line.when.flag] === line.when.equals;
|
||||
|
||||
export const applyDialogueChoice = (run, line, choiceId) => {
|
||||
const choice = line.choices?.find(item => item.id === choiceId);
|
||||
if (!choice || !run || !/^story\.[\w.]+$/.test(line.flag || "")) throw new Error("梦三剧情发言选项无效");
|
||||
run.storyFlags ||= {};
|
||||
run.storyFlags[line.flag] = choice.id;
|
||||
return choice.text;
|
||||
};
|
||||
|
||||
export const applySkippedDialogueChoices = (lines, startIndex, run) => {
|
||||
for (let index = startIndex; index < lines.length; index++) {
|
||||
const line = lines[index];
|
||||
if (!isDialogueLineVisible(line, run) || line.type !== "choice") continue;
|
||||
applyDialogueChoice(run, line, line.defaultChoice || line.choices[0].id);
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,192 @@
|
||||
import { mountMenu } from "./navigation.js";
|
||||
import { ui, get } from "../../../../noname.js";
|
||||
import { isDialogueLineVisible, applyDialogueChoice, applySkippedDialogueChoices } from "./dialogue-choice.js";
|
||||
|
||||
const TYPE_NAMES = {
|
||||
character: "角色",
|
||||
narrator: "旁白",
|
||||
sound: "音效",
|
||||
choice: "选择发言",
|
||||
};
|
||||
|
||||
|
||||
const resolveCharacter = (character, run) => character == "$player" ? run?.player?.character : character;
|
||||
|
||||
const resolveSpeaker = (line, character) => {
|
||||
if (line.speaker == "$player") return character ? get.translation(character) : "你";
|
||||
if (line.speaker) return line.speaker;
|
||||
if (line.type == "character" && character) return get.translation(character);
|
||||
return TYPE_NAMES[line.type] || "旁白";
|
||||
};
|
||||
|
||||
export const splitDialogueText = text => Array.from(String(text || ""));
|
||||
|
||||
export const playDialogue = (lines, options = {}) => new Promise(resolve => {
|
||||
if (!Array.isArray(lines) || !lines.length) {
|
||||
resolve();
|
||||
return;
|
||||
}
|
||||
|
||||
const overlay = ui.create.div(".mengsan-dialogue-overlay-shuying", ui.window);
|
||||
const stage = ui.create.div(".mengsan-dialogue-stage-shuying", overlay);
|
||||
ui.create.div(".mengsan-dialogue-chapter-shuying", options.title || "剧情", stage);
|
||||
const portraitFrame = ui.create.div(".mengsan-dialogue-portrait-frame-shuying", stage);
|
||||
const textBox = ui.create.div(".mengsan-dialogue-box-shuying", stage);
|
||||
const speaker = ui.create.div(".mengsan-dialogue-speaker-shuying", textBox);
|
||||
const text = ui.create.div(".mengsan-dialogue-text-shuying", textBox);
|
||||
const progress = ui.create.div(".mengsan-dialogue-progress-shuying", textBox);
|
||||
const indicator = ui.create.div(".mengsan-dialogue-indicator-shuying", "◆", textBox);
|
||||
const choices = ui.create.div(".mengsan-dialogue-choices-shuying", stage);
|
||||
const skipButton = document.createElement("button");
|
||||
skipButton.type = "button";
|
||||
skipButton.className = "mengsan-dialogue-skip-shuying";
|
||||
skipButton.textContent = "跳过对话";
|
||||
skipButton.setAttribute("aria-label", "跳过对话，未选择的发言使用默认选项");
|
||||
stage.appendChild(skipButton);
|
||||
|
||||
let lineIndex = -1;
|
||||
let timer = null;
|
||||
let typing = false;
|
||||
let paused = false;
|
||||
let currentSpeed = 28;
|
||||
let characters = [];
|
||||
let characterIndex = 0;
|
||||
let currentLine = null;
|
||||
let awaitingChoice = false;
|
||||
const portrait = ui.create.div(".mengsan-dialogue-portrait-shuying", portraitFrame);
|
||||
const reduceMotion = globalThis.matchMedia?.("(prefers-reduced-motion: reduce)")?.matches;
|
||||
|
||||
const stopTimer = () => {
|
||||
if (timer != null) clearTimeout(timer);
|
||||
timer = null;
|
||||
};
|
||||
|
||||
const finishTyping = () => {
|
||||
stopTimer();
|
||||
text.textContent = characters.join("");
|
||||
characterIndex = characters.length;
|
||||
typing = false;
|
||||
if (currentLine?.type === "choice" && awaitingChoice) showChoices(currentLine);
|
||||
else indicator.classList.add("visible");
|
||||
};
|
||||
|
||||
function showChoices(line) {
|
||||
choices.replaceChildren();
|
||||
for (const item of line.choices) {
|
||||
const button = document.createElement("button");
|
||||
button.type = "button";
|
||||
button.className = "mengsan-dialogue-choice-shuying";
|
||||
button.textContent = item.text;
|
||||
button.addEventListener("click", event => {
|
||||
event.stopPropagation();
|
||||
if (!awaitingChoice) return;
|
||||
text.textContent = applyDialogueChoice(options.run, line, item.id);
|
||||
awaitingChoice = false;
|
||||
choices.replaceChildren();
|
||||
speaker.textContent = get.translation(options.run.player.character);
|
||||
stage.dataset.lineType = "character";
|
||||
const character = options.run.player.character;
|
||||
portraitFrame.classList.add("visible");
|
||||
portrait.setBackground(character, "character");
|
||||
indicator.classList.add("visible");
|
||||
textBox.focus();
|
||||
});
|
||||
choices.appendChild(button);
|
||||
}
|
||||
choices.querySelector("button")?.focus();
|
||||
}
|
||||
|
||||
const scheduleCharacter = speed => {
|
||||
if (!typing || paused) return;
|
||||
text.textContent += characters[characterIndex++];
|
||||
if (characterIndex >= characters.length) {
|
||||
finishTyping();
|
||||
return;
|
||||
}
|
||||
timer = setTimeout(() => scheduleCharacter(speed), speed);
|
||||
};
|
||||
|
||||
const close = () => {
|
||||
stopTimer();
|
||||
skipButton.removeEventListener("click", handleSkip);
|
||||
textBox.removeEventListener("click", handleClick);
|
||||
textBox.removeEventListener("keydown", handleKeydown);
|
||||
choices.replaceChildren();
|
||||
overlay.remove();
|
||||
resolve();
|
||||
};
|
||||
|
||||
const showNextLine = () => {
|
||||
do { lineIndex++; } while (lineIndex < lines.length && !isDialogueLineVisible(lines[lineIndex], options.run));
|
||||
if (lineIndex >= lines.length) {
|
||||
close();
|
||||
return;
|
||||
}
|
||||
|
||||
const line = lines[lineIndex];
|
||||
currentLine = line;
|
||||
awaitingChoice = line.type === "choice";
|
||||
choices.replaceChildren();
|
||||
const lineType = TYPE_NAMES[line.type] ? line.type : "narrator";
|
||||
const character = resolveCharacter(line.character, options.run);
|
||||
stage.dataset.lineType = lineType;
|
||||
speaker.textContent = resolveSpeaker(line, character);
|
||||
progress.textContent = `${lineIndex + 1} / ${lines.length}`;
|
||||
indicator.classList.remove("visible");
|
||||
|
||||
if (lineType == "character" && character) {
|
||||
portraitFrame.classList.add("visible");
|
||||
portrait.setBackground(character, "character");
|
||||
portrait.setAttribute("aria-label", `${speaker.textContent}立绘`);
|
||||
}
|
||||
else {
|
||||
portraitFrame.classList.remove("visible");
|
||||
portrait.removeAttribute("aria-label");
|
||||
}
|
||||
|
||||
characters = splitDialogueText(line.text);
|
||||
characterIndex = 0;
|
||||
text.textContent = "";
|
||||
typing = characters.length > 0;
|
||||
const speed = Number.isFinite(line.speed) ? Math.max(0, line.speed) : 28;
|
||||
currentSpeed = speed;
|
||||
if (!typing || reduceMotion || speed == 0) finishTyping();
|
||||
else scheduleCharacter(speed);
|
||||
};
|
||||
|
||||
function handleClick(event) {
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
if (paused) return;
|
||||
if (typing) finishTyping();
|
||||
else if (awaitingChoice) return;
|
||||
else showNextLine();
|
||||
}
|
||||
|
||||
function handleKeydown(event) {
|
||||
if (event.key == "Enter" || event.key == " ") handleClick(event);
|
||||
}
|
||||
|
||||
function handleSkip(event) {
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
if (paused) return;
|
||||
applySkippedDialogueChoices(lines, lineIndex + (awaitingChoice ? 0 : 1), options.run);
|
||||
close();
|
||||
}
|
||||
|
||||
textBox.setAttribute("role", "button");
|
||||
textBox.setAttribute("tabindex", "0");
|
||||
textBox.setAttribute("aria-label", "剧情文本：点击补全文字或继续");
|
||||
textBox.addEventListener("click", handleClick);
|
||||
textBox.addEventListener("keydown", handleKeydown);
|
||||
skipButton.addEventListener("click", handleSkip);
|
||||
mountMenu(overlay, {
|
||||
onOpen() { paused = true; stopTimer(); },
|
||||
onClose() { paused = false; if (typing) scheduleCharacter(currentSpeed); },
|
||||
});
|
||||
const help = ui.create.div(".mengsan-dialogue-help-shuying", stage);
|
||||
help.textContent = "点击补全文字 · 再次点击继续 · Enter / 空格";
|
||||
showNextLine();
|
||||
textBox.focus();
|
||||
});
|
||||
@@ -0,0 +1,83 @@
|
||||
// Candidate only: attach to fresh, session-owned roots BEFORE scheduling them.
|
||||
const attached = new WeakSet();
|
||||
export function observeFreshEvent(session, event) {
|
||||
if (!event || typeof event.start !== "function" || !event.manager?.eventStack ||
|
||||
event.finished || event.manager.eventStack.includes(event) ||
|
||||
event.parent?.childEvents?.includes(event) || attached.has(event)) {
|
||||
throw new Error("Fresh, unobserved engine event required");
|
||||
}
|
||||
const descriptor = Object.getOwnPropertyDescriptor(event, "start");
|
||||
if (descriptor && !descriptor.configurable) throw new Error("Event start is not configurable");
|
||||
const original = event.start;
|
||||
let resolve, reject;
|
||||
const completion = new Promise((yes, no) => { resolve = yes; reject = no; });
|
||||
session.ownEvent(event, completion);
|
||||
let observed = false;
|
||||
function start(...args) {
|
||||
let result;
|
||||
try { result = Reflect.apply(original, this, args); }
|
||||
catch (error) { reject(error); throw error; }
|
||||
if (!observed) {
|
||||
observed = true;
|
||||
if (!(result instanceof Promise)) {
|
||||
reject(new TypeError("Native engine start promise required"));
|
||||
} else {
|
||||
result.then(() => {
|
||||
if (event.manager.eventStack.includes(event) || event.manager.tempEvent === event) {
|
||||
reject(new Error("Event still active after start completion"));
|
||||
} else resolve();
|
||||
}, reject);
|
||||
}
|
||||
}
|
||||
return result; // Never assimilate event.then(), never proactively start a queue.
|
||||
}
|
||||
Object.defineProperty(event, "start", { configurable: true, writable: true, value: start });
|
||||
attached.add(event);
|
||||
session.ownResource({}, () => {
|
||||
if (event.start === start) {
|
||||
if (descriptor) Object.defineProperty(event, "start", descriptor);
|
||||
else delete event.start;
|
||||
}
|
||||
attached.delete(event);
|
||||
});
|
||||
return completion;
|
||||
}
|
||||
|
||||
// Independent delay entry: releasing it never calls global resume/pause2/over.resolve.
|
||||
export function acquirePauseLease(session, pauseManager) {
|
||||
if (!session.active || typeof pauseManager?.setDelay !== "function") throw new Error("Active session and pause manager required");
|
||||
let unlock;
|
||||
const gate = new Promise(resolve => { unlock = resolve; });
|
||||
const settled = pauseManager.setDelay(gate);
|
||||
let released = false;
|
||||
const lease = Object.freeze({
|
||||
release() { if (!released) { released = true; unlock(); } return settled; },
|
||||
get released() { return released; },
|
||||
});
|
||||
session.ownResource(lease, () => lease.release());
|
||||
return lease;
|
||||
}
|
||||
|
||||
// Call outside tracked event/task bodies. Own pauses must be lifted before drain.
|
||||
export async function stopAndDrain(session, leases = []) {
|
||||
session.requestStop();
|
||||
await Promise.all(leases.map(lease => lease.release()));
|
||||
await session.drain();
|
||||
}
|
||||
|
||||
// Only remove this exact node from the parent recorded at acquisition.
|
||||
export function ownNode(session, node) {
|
||||
const parent = node.parentNode;
|
||||
if (!parent) throw new Error("Attached node required");
|
||||
return session.ownResource(node, () => {
|
||||
if (node.parentNode === parent) parent.removeChild(node);
|
||||
});
|
||||
}
|
||||
export function ownListener(session, target, type, listener, options) {
|
||||
const guarded = session.guard(listener);
|
||||
const capture = typeof options === "boolean" ? options : !!options?.capture;
|
||||
const token = {};
|
||||
session.ownResource(token, () => target.removeEventListener(type, guarded, capture));
|
||||
target.addEventListener(type, guarded, options);
|
||||
return guarded;
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
import { ui } from "../../../../noname.js";
|
||||
import { mountMenu } from "./navigation.js";
|
||||
|
||||
export const chooseButtons = (title, choices, description = "", options = {}) => new Promise(resolve => {
|
||||
const previousFocus = document.activeElement;
|
||||
const overlay = ui.create.div(".mengsan-overlay-shuying.mengsan-flow-overlay-shuying", ui.window);
|
||||
overlay.setAttribute("role", "dialog");
|
||||
overlay.setAttribute("aria-modal", "true");
|
||||
overlay.setAttribute("aria-label", title);
|
||||
const panel = ui.create.div(".mengsan-panel-shuying.mengsan-flow-panel-shuying", overlay);
|
||||
const eyebrow = document.createElement("p");
|
||||
eyebrow.className = "mengsan-flow-eyebrow-shuying";
|
||||
eyebrow.textContent = options.eyebrow || "梦三 · 征程";
|
||||
panel.appendChild(eyebrow);
|
||||
const heading = ui.create.div(".mengsan-title-shuying", panel);
|
||||
heading.textContent = title;
|
||||
heading.setAttribute("role", "heading");
|
||||
heading.setAttribute("aria-level", "1");
|
||||
if (description) {
|
||||
const summary = ui.create.div(".mengsan-description-shuying", panel);
|
||||
summary.textContent = description;
|
||||
}
|
||||
const buttons = ui.create.div(".mengsan-choice-list-shuying", panel);
|
||||
const finish = id => {
|
||||
if (overlay.dataset.resolved) return;
|
||||
overlay.dataset.resolved = "true";
|
||||
overlay.remove();
|
||||
if (previousFocus?.isConnected) previousFocus.focus();
|
||||
resolve(id);
|
||||
};
|
||||
choices.forEach(choice => {
|
||||
const button = document.createElement("button");
|
||||
button.type = "button";
|
||||
button.className = "mengsan-choice-shuying";
|
||||
button.dataset.choice = choice.id;
|
||||
if (choice.danger) button.classList.add("danger");
|
||||
const name = document.createElement("span");
|
||||
name.className = "mengsan-choice-name-shuying";
|
||||
name.textContent = choice.name;
|
||||
button.appendChild(name);
|
||||
if (choice.description) {
|
||||
const detail = document.createElement("span");
|
||||
detail.className = "mengsan-choice-description-shuying";
|
||||
detail.textContent = choice.description;
|
||||
button.appendChild(detail);
|
||||
}
|
||||
button.disabled = Boolean(choice.disabled);
|
||||
button.addEventListener("click", () => finish(choice.id));
|
||||
buttons.appendChild(button);
|
||||
});
|
||||
mountMenu(overlay);
|
||||
overlay.addEventListener("keydown", event => {
|
||||
if (event.key === "Escape" && options.back) {
|
||||
event.preventDefault(); finish(options.back); return;
|
||||
}
|
||||
if (event.key !== "Tab") return;
|
||||
const focusable = [...overlay.querySelectorAll("button:not(:disabled)")];
|
||||
const first = focusable[0], last = focusable[focusable.length - 1];
|
||||
if (event.shiftKey && document.activeElement === first) { event.preventDefault(); last.focus(); }
|
||||
else if (!event.shiftKey && document.activeElement === last) { event.preventDefault(); first.focus(); }
|
||||
});
|
||||
buttons.querySelector("button:not(:disabled)")?.focus();
|
||||
});
|
||||
@@ -0,0 +1,91 @@
|
||||
// Candidate factory. Storage writer body reused from batch2 MODIFIED_STORAGE.js.
|
||||
export function createModeStorage({lib, game, config, localStorage, alert = () => {}, console = globalThis.console}) {
|
||||
const MODE_ID = config.modeId;
|
||||
|
||||
|
||||
const copy = value => JSON.parse(JSON.stringify(value));
|
||||
|
||||
// Keep one mode-level writer; a failed write must not poison later retries.
|
||||
let modeStorageQueue = Promise.resolve();
|
||||
|
||||
const writeModeStorage = storage => {
|
||||
if (!lib.db) {
|
||||
// Do not switch backends after an IndexedDB error: that creates two saves.
|
||||
localStorage.setItem(`${lib.configprefix}${MODE_ID}`, JSON.stringify(storage));
|
||||
return Promise.resolve();
|
||||
}
|
||||
return new Promise((resolve, reject) => {
|
||||
let transaction;
|
||||
let requestError;
|
||||
try {
|
||||
// game.putDB resolves at request success, which is before commit.
|
||||
transaction = lib.db.transaction(["data"], "readwrite");
|
||||
transaction.oncomplete = () => resolve();
|
||||
transaction.onerror = event => {
|
||||
requestError = event.target?.error;
|
||||
};
|
||||
transaction.onabort = () => reject(transaction.error || requestError || new Error("梦三存档事务已中止"));
|
||||
transaction.objectStore("data").put(storage, MODE_ID);
|
||||
}
|
||||
catch (error) {
|
||||
if (transaction) {
|
||||
try { transaction.abort(); }
|
||||
catch {} // Already inactive; keep the original failure.
|
||||
}
|
||||
reject(error);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
const persistModeStorage = (update = () => {}) => {
|
||||
// Hold the engine reload guard from enqueue through commit and publication.
|
||||
// reload2 also drains the engine's queued database operations on release.
|
||||
lib.status.reload++;
|
||||
const operation = modeStorageQueue.then(async () => {
|
||||
const storage = copy(lib.storage);
|
||||
update(storage);
|
||||
storage.version = lib.version;
|
||||
await writeModeStorage(storage);
|
||||
lib.storage = storage;
|
||||
}).finally(() => game.reload2());
|
||||
modeStorageQueue = operation.catch(() => {});
|
||||
return operation;
|
||||
};
|
||||
|
||||
const saveRun = async run => {
|
||||
try {
|
||||
// Capture before enqueue: subsequent gameplay mutations cannot alter this save.
|
||||
const snapshot = copy(run);
|
||||
await persistModeStorage(storage => {
|
||||
storage[config.saveKey] = snapshot;
|
||||
});
|
||||
}
|
||||
catch (error) {
|
||||
// Neither delete the previous save nor attempt a second destructive write.
|
||||
alert("梦三存档失败，未覆盖上一次成功保存的进度。当前进度尚未保存，请勿刷新，并查看控制台错误。");
|
||||
console.error("梦三存档失败：", error);
|
||||
throw error;
|
||||
}
|
||||
};
|
||||
|
||||
const clearRun = async () => {
|
||||
await persistModeStorage(storage => {
|
||||
delete storage[config.saveKey];
|
||||
});
|
||||
};
|
||||
|
||||
|
||||
|
||||
return Object.freeze({
|
||||
read: () => copy(lib.storage),
|
||||
saveRun, clearRun,
|
||||
async update(mutator) {
|
||||
let value;
|
||||
await persistModeStorage(storage => {
|
||||
value = mutator(storage);
|
||||
if (value && typeof value.then === "function") throw new TypeError("Storage mutator must be synchronous");
|
||||
});
|
||||
return value === undefined ? undefined : copy(value);
|
||||
},
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
// 梦三怪物规则只作用于敌方单位；子类可覆盖构造参数或 createDeck()。
|
||||
const TIER_RULES = Object.freeze({
|
||||
normal: Object.freeze({ draw: 1, handLimit: 3, energy: 2 }),
|
||||
elite: Object.freeze({ draw: 2, handLimit: 5, energy: 3 }),
|
||||
boss: Object.freeze({ draw: 3, handLimit: 7, energy: 4 }),
|
||||
});
|
||||
|
||||
const BASE_DECKS = Object.freeze({
|
||||
normal: Object.freeze(["sha", "sha", "sha", "sha", "shan", "shan", "tao", "jiu", "guohe", "sha"]),
|
||||
elite: Object.freeze(["sha", "sha", "sha", "sha", "shan", "shan", "shan", "tao", "jiu", "juedou", "wuzhong", "guohe"]),
|
||||
boss: Object.freeze(["sha", "sha", "sha", "sha", "sha", "shan", "shan", "shan", "tao", "tao", "jiu", "jiu", "juedou", "wuzhong", "guohe"]),
|
||||
});
|
||||
|
||||
const HEALTH = Object.freeze({
|
||||
mengsan_soldier_shuying: 24,
|
||||
re_xiahoudun: 30, re_zhangliao: 28, re_xuzhu: 34, re_lvbu: 120,
|
||||
re_ganning: 39, re_zhangfei: 42, re_huangzhong: 37, re_weiyan: 40,
|
||||
re_guanyu: 65, dianwei: 62, shen_guanyu: 165,
|
||||
re_simayi: 47, re_sunben: 49, dongzhuo: 55, re_yuanshao: 52,
|
||||
shen_zhaoyun: 76, shen_simayi: 80, shen_caocao: 210,
|
||||
});
|
||||
const validDeckCard = entry => typeof entry === "string" ? Boolean(entry) : Boolean(entry &&
|
||||
typeof entry.name === "string" && entry.name &&
|
||||
(entry.suit == null || ["spade", "heart", "club", "diamond"].includes(entry.suit)) &&
|
||||
(entry.number == null || Number.isInteger(entry.number) && entry.number >= 1 && entry.number <= 13));
|
||||
|
||||
export class Monster {
|
||||
constructor({ character, tier = "normal", hp, deck, draw, handLimit, energy } = {}) {
|
||||
if (!TIER_RULES[tier]) throw new Error("梦三怪物阶级无效：" + tier);
|
||||
if (typeof character !== "string" || !character) throw new Error("梦三怪物缺少武将ID");
|
||||
const defaults = TIER_RULES[tier];
|
||||
this.character = character;
|
||||
this.tier = tier;
|
||||
this.hp = hp ?? HEALTH[character] ?? (tier === "boss" ? 110 : tier === "elite" ? 60 : 32);
|
||||
this.draw = draw ?? defaults.draw;
|
||||
this.handLimit = handLimit ?? defaults.handLimit;
|
||||
this.energy = energy ?? defaults.energy;
|
||||
this.deck = deck || BASE_DECKS[tier];
|
||||
if (![this.hp, this.draw, this.handLimit, this.energy].every(value => Number.isInteger(value) && value > 0)) throw new Error("梦三怪物数值无效");
|
||||
if (!Array.isArray(this.deck) || !this.deck.length || this.deck.some(entry => !validDeckCard(entry))) throw new Error("梦三怪物牌堆无效");
|
||||
}
|
||||
|
||||
createDeck(prefix) {
|
||||
return this.deck.map((entry, index) => {
|
||||
const card = typeof entry === "string" ? { name: entry } : entry;
|
||||
return {
|
||||
id: `${prefix}_${index}`, name: card.name,
|
||||
suit: card.suit || ["spade", "heart", "club", "diamond"][index % 4],
|
||||
number: card.number || index % 13 + 1,
|
||||
nature: card.nature || null, affixes: Array.isArray(card.affixes) ? card.affixes.slice() : [], upgrade: card.upgrade || 0,
|
||||
};
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// 专属怪物示例：以后可在子类中覆写任意默认行为。
|
||||
export class OpeningSoldier extends Monster {
|
||||
constructor(options = {}) { super({ character: "mengsan_soldier_shuying", tier: "normal", hp: 24, ...options }); }
|
||||
}
|
||||
|
||||
// 新怪物子类在这里注册，未注册的角色使用 Monster 的阶级默认值。
|
||||
export const MONSTER_TYPES = Object.freeze({ mengsan_soldier_shuying: OpeningSoldier });
|
||||
|
||||
export function createMonster(spec) {
|
||||
const Type = Object.hasOwn(MONSTER_TYPES, spec.character) ? MONSTER_TYPES[spec.character] : Monster;
|
||||
return new Type(spec);
|
||||
}
|
||||
|
||||
export { TIER_RULES, BASE_DECKS };
|
||||
@@ -0,0 +1,120 @@
|
||||
import { lib, game, ui } from "../../../../noname.js";
|
||||
import { save } from "../../../../noname/util/config.js";
|
||||
|
||||
let selectingMode = false;
|
||||
|
||||
// Reuse the registered engine splash, not reload-to-the-current-mode or a fake mode list.
|
||||
export const openModeSelection = async () => {
|
||||
if (selectingMode) return;
|
||||
const splash = lib.onloadSplashes.find(item => item.id === lib.config.splash_style) || lib.onloadSplashes[0];
|
||||
if (!splash) throw new Error("模式选择界面未加载，请稍后重试。");
|
||||
selectingMode = true;
|
||||
const previousSplash = window.inSplash;
|
||||
const previousFocus = document.activeElement;
|
||||
const previousInert = ui.window.inert;
|
||||
const node = ui.create.div("#splash", document.body);
|
||||
node.style.zIndex = "1000";
|
||||
window.inSplash = true;
|
||||
ui.window.inert = true;
|
||||
try {
|
||||
let choose;
|
||||
const selected = new Promise(resolve => { choose = resolve; });
|
||||
await splash.init(node, choose);
|
||||
const mode = await selected;
|
||||
if (!lib.config.all.mode.includes(mode)) throw new Error("所选模式不可用。");
|
||||
await save("mode", "config", mode);
|
||||
lib.config.mode = mode;
|
||||
localStorage.setItem(`${lib.configprefix}directstart`, "true");
|
||||
// Reload only AFTER a mode is chosen; retain engine pending-write handling.
|
||||
node.inert = true;
|
||||
game.reload();
|
||||
// Keep the abandoned flow inert while the engine waits for pending DB writes.
|
||||
await new Promise(() => {});
|
||||
} catch (error) {
|
||||
// DefaultSplash owns a Vue app. Clean it up if opening/saving failed.
|
||||
splash.app?.unmount?.();
|
||||
throw error;
|
||||
} finally {
|
||||
node.remove();
|
||||
window.inSplash = previousSplash;
|
||||
ui.window.inert = previousInert;
|
||||
selectingMode = false;
|
||||
if (previousFocus?.isConnected) previousFocus.focus();
|
||||
}
|
||||
};
|
||||
|
||||
export const askMenu = (title, description, choices) => new Promise(resolve => {
|
||||
const previousFocus = document.activeElement;
|
||||
const dialog = document.createElement("dialog");
|
||||
dialog.className = "mengsan-menu-dialog-shuying";
|
||||
dialog.setAttribute("aria-label", title);
|
||||
const heading = document.createElement("h2");
|
||||
heading.textContent = title;
|
||||
const body = document.createElement("p");
|
||||
body.textContent = description;
|
||||
dialog.append(heading, body);
|
||||
let closed = false;
|
||||
const finish = value => {
|
||||
if (closed) return;
|
||||
closed = true;
|
||||
dialog.close();
|
||||
dialog.remove();
|
||||
if (previousFocus?.isConnected) previousFocus.focus();
|
||||
resolve(value);
|
||||
};
|
||||
for (const choice of choices) {
|
||||
const button = document.createElement("button");
|
||||
button.type = "button";
|
||||
button.textContent = choice.name;
|
||||
if (choice.danger) button.className = "danger";
|
||||
button.addEventListener("click", () => finish(choice.id));
|
||||
dialog.appendChild(button);
|
||||
}
|
||||
dialog.addEventListener("cancel", event => { event.preventDefault(); finish(null); });
|
||||
document.body.appendChild(dialog);
|
||||
dialog.showModal();
|
||||
dialog.querySelector("button")?.focus();
|
||||
});
|
||||
|
||||
export const mountMenu = (overlay, options = {}) => {
|
||||
const button = document.createElement("button");
|
||||
button.type = "button";
|
||||
button.className = "mengsan-flow-menu-shuying";
|
||||
const icon = document.createElementNS("http://www.w3.org/2000/svg", "svg");
|
||||
icon.setAttribute("viewBox", "0 0 24 24");
|
||||
icon.setAttribute("aria-hidden", "true");
|
||||
const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
|
||||
path.setAttribute("d", "M4 6h16M4 12h16M4 18h16");
|
||||
icon.appendChild(path);
|
||||
const label = document.createElement("span");
|
||||
label.textContent = "菜单";
|
||||
button.append(icon, label);
|
||||
button.setAttribute("aria-haspopup", "dialog");
|
||||
let opened = false;
|
||||
button.addEventListener("click", async event => {
|
||||
event.stopPropagation();
|
||||
if (opened) return;
|
||||
opened = true;
|
||||
options.onOpen?.();
|
||||
try {
|
||||
const action = await askMenu("征程菜单", "退出不删除存档。未完成的节点与对话将在下次进入时重新开始。", [
|
||||
{ id: "resume", name: "继续当前界面" },
|
||||
{ id: "exit", name: "返回模式选择" },
|
||||
]);
|
||||
if (action !== "exit") return;
|
||||
const confirmed = await askMenu("返回模式选择？", "保留上次已完成节点的存档。本次尚未完成的内容不会提交。", [
|
||||
{ id: "cancel", name: "留在梦三" },
|
||||
{ id: "confirm", name: "确认返回模式选择", danger: true },
|
||||
]);
|
||||
if (confirmed === "confirm") await openModeSelection();
|
||||
} catch (error) {
|
||||
console.error("梦三返回模式选择失败：", error);
|
||||
await askMenu("暂时无法返回", "没有清除征程。请关闭提示后重试。", [{ id: "close", name: "回到当前界面" }]);
|
||||
} finally {
|
||||
opened = false;
|
||||
options.onClose?.();
|
||||
}
|
||||
});
|
||||
overlay.appendChild(button);
|
||||
return button;
|
||||
};
|
||||
@@ -0,0 +1,142 @@
|
||||
// Mode-owned piles use real Card nodes so native searches/gain/insert operations agree.
|
||||
// DIY must access ui piles inside the acting player's engine event, never cache global nodes.
|
||||
import { cardCost } from "./combat-rules.js";
|
||||
|
||||
export function installPersonalPiles(session, owner, battle, run, resources, env) {
|
||||
const { game, ui, get, _status, document, MutationObserver, shuffle } = env;
|
||||
for (const key of ["cardPile", "discardPile"]) {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(ui, key);
|
||||
if (!descriptor || !descriptor.configurable || (!Object.hasOwn(descriptor, "value") && typeof descriptor.get !== "function")) throw new Error("Unsupported pile property: " + key);
|
||||
}
|
||||
const draw = document.createElement("div"), discard = document.createElement("div");
|
||||
// Detached nodes: engine get.position recognises these IDs; no duplicate document IDs.
|
||||
draw.id = "cardPile"; discard.id = "discardPile";
|
||||
const owned = new Set(), restores = [];
|
||||
const strict = env.strict !== false;
|
||||
let released = false, forcedOwner = false;
|
||||
const personal = () => {
|
||||
if (released) return false;
|
||||
if (forcedOwner) return true;
|
||||
const seen = new Set();
|
||||
for (let event = _status.event; event && !seen.has(event); event = event.parent) {
|
||||
seen.add(event);
|
||||
if (event.player) return event.player === owner;
|
||||
}
|
||||
return false; // Never infer ownership from whose turn it is.
|
||||
};
|
||||
const refresh = () => { if (!released) env.refresh(); };
|
||||
function adopt(card, data) {
|
||||
if (owned.has(card)) return;
|
||||
owned.add(card); resources.card(card);
|
||||
card.storage ||= {};
|
||||
if (data) card.storage.mengsanCard_shuying = JSON.parse(JSON.stringify(data));
|
||||
if (data && env.showCosts) {
|
||||
card.dataset.mengsanCost = String(cardCost(data));
|
||||
}
|
||||
// Existing foreign/generated cards retain their original destruction semantics.
|
||||
if (!data) return;
|
||||
card.destroyLog = false;
|
||||
card.destroyed = (current, position) => {
|
||||
if (released || position !== "discardPile") return false;
|
||||
if (data.affixes?.includes("annihilate") && current.storage.mengsanUsed_shuying) {
|
||||
battle.exhaustPile.push(snapshot(current));
|
||||
return true;
|
||||
}
|
||||
return false; // Actual discarded cards remain available to native skills.
|
||||
};
|
||||
if (data.affixes?.includes("annihilate")) card.addGaintag("湮灭");
|
||||
if (data.upgrade) card.addGaintag(`强化+${data.upgrade}`);
|
||||
}
|
||||
function snapshot(card) {
|
||||
const data = card.storage?.mengsanCard_shuying || {};
|
||||
return { ...data, name: card.name, suit: card.suit, number: card.number,
|
||||
nature: card.nature || null, affixes: data.affixes?.slice() || [], upgrade: data.upgrade || 0 };
|
||||
}
|
||||
for (const data of battle.drawPile) {
|
||||
const card = game.createCard(data.name, data.suit, data.number, data.nature);
|
||||
adopt(card, data); draw.appendChild(card);
|
||||
}
|
||||
const publicDiscard = ui.discardPile;
|
||||
for (const [key, node] of [["cardPile", draw], ["discardPile", discard]]) {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(ui, key);
|
||||
let publicNode = descriptor.value;
|
||||
const read = () => personal() ? node : (descriptor.get ? descriptor.get.call(ui) : publicNode);
|
||||
Object.defineProperty(ui, key, { configurable: true, enumerable: descriptor.enumerable,
|
||||
get: read, set(value) { if (descriptor.set) descriptor.set.call(ui, value); else publicNode = value; } });
|
||||
restores.push(() => {
|
||||
if (Object.getOwnPropertyDescriptor(ui, key)?.get === read) Object.defineProperty(ui, key, descriptor.get ? descriptor : { ...descriptor, value: publicNode });
|
||||
});
|
||||
}
|
||||
for (const [key, node] of [["drawPile", draw], ["discardPile", discard]]) {
|
||||
Object.defineProperty(battle, key, { configurable: true, enumerable: true,
|
||||
get: () => Array.from(node.childNodes, snapshot) });
|
||||
}
|
||||
const observer = new MutationObserver(() => {
|
||||
if (released) return;
|
||||
// A card from our deck can be discarded during an enemy-owned event.
|
||||
for (const card of Array.from(publicDiscard.childNodes)) if (owned.has(card)) discard.appendChild(card);
|
||||
for (const node of [draw, discard]) for (const card of node.childNodes) adopt(card);
|
||||
refresh();
|
||||
});
|
||||
for (const node of [draw, discard, publicDiscard]) observer.observe(node, { childList: true });
|
||||
function wash() {
|
||||
const cards = [...draw.childNodes, ...discard.childNodes];
|
||||
if (!cards.length) return false;
|
||||
shuffle(run, cards);
|
||||
for (const card of cards) { card.fix?.(); draw.appendChild(card); }
|
||||
refresh();
|
||||
return true;
|
||||
}
|
||||
function take(number = 1, putBack = false, bottom = false) {
|
||||
if (!Number.isFinite(number) || number <= 0) return [];
|
||||
number = Math.ceil(number);
|
||||
if (draw.childNodes.length + discard.childNodes.length < number) {
|
||||
if (strict) { game.mengsanFailRun_shuying("个人牌堆与弃牌堆不足，挑战失败"); return []; }
|
||||
number = draw.childNodes.length + discard.childNodes.length;
|
||||
}
|
||||
const cards = [];
|
||||
while (cards.length < number) {
|
||||
if (!draw.childNodes.length) wash();
|
||||
const card = draw.removeChild(bottom ? draw.lastChild : draw.firstChild); card.original = "c"; cards.push(card);
|
||||
}
|
||||
if (putBack) for (let i = cards.length - 1; i >= 0; i--) {
|
||||
if (bottom) draw.appendChild(cards[i]); else draw.insertBefore(cards[i], draw.firstChild);
|
||||
}
|
||||
refresh(); return cards;
|
||||
}
|
||||
function wrap(object, key, replacement) {
|
||||
const descriptor = Object.getOwnPropertyDescriptor(object, key), original = object[key];
|
||||
const wrapped = function (...args) { return personal() ? replacement(...args) : original.apply(this, args); };
|
||||
object[key] = wrapped;
|
||||
restores.push(() => { if (object[key] === wrapped) { if (descriptor) Object.defineProperty(object, key, descriptor); else delete object[key]; } });
|
||||
}
|
||||
wrap(get, "cards", (number, putBack) => take(typeof number === "number" ? number : 1, putBack));
|
||||
wrap(get, "bottomCards", (number, putBack) => take(typeof number === "number" ? number : 1, putBack, true));
|
||||
wrap(game, "washCard", wash);
|
||||
session.ownResource(draw, () => {
|
||||
if (released) return;
|
||||
observer.disconnect(); released = true;
|
||||
for (const restore of restores.reverse()) restore();
|
||||
for (const card of owned) card.remove();
|
||||
owned.clear(); draw.remove(); discard.remove();
|
||||
});
|
||||
return {
|
||||
take,
|
||||
// Engine/mod opening draws must not stack with the mode's four-card opening hand.
|
||||
resetOpeningHand() {
|
||||
for (const card of owner.getCards("h")) {
|
||||
if (owned.has(card)) draw.insertBefore(card, draw.firstChild);
|
||||
else card.remove();
|
||||
}
|
||||
refresh();
|
||||
},
|
||||
trimOpeningHand(limit = 4) {
|
||||
for (const card of owner.getCards("h").slice(limit)) {
|
||||
if (owned.has(card)) draw.insertBefore(card, draw.firstChild);
|
||||
else card.remove();
|
||||
}
|
||||
refresh();
|
||||
},
|
||||
withOwner(callback) { const before = forcedOwner; forcedOwner = true; try { return callback(); } finally { forcedOwner = before; } },
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
import config from "../config.js";
|
||||
import { nextRandom } from "../state.js";
|
||||
|
||||
export const getRandomRewardChoices = (run, poolId, count = 3) => {
|
||||
const fallbackId = "shared.pool.battle.normal";
|
||||
const pool = (config.rewardPools[poolId] || config.rewardPools[fallbackId]).slice();
|
||||
for (let index = pool.length - 1; index > 0; index--) {
|
||||
const target = Math.floor(nextRandom(run) * (index + 1));
|
||||
[pool[index], pool[target]] = [pool[target], pool[index]];
|
||||
}
|
||||
return pool.slice(0, count).map(id => ({ id, ...config.rewards[id] }));
|
||||
};
|
||||
@@ -0,0 +1,147 @@
|
||||
// Candidate-only engine-derived release. Never replaces Player.prototype or lib.skill.
|
||||
// Restricted: additional/fixed/superCharlotte skills require a separate audited adapter.
|
||||
export async function removeBattleSkill(player, skill, {lib,game,get,_status}, wholePlayer = false) {
|
||||
const names = Array.isArray(skill) ? skill.slice() : [skill];
|
||||
for (const name of names) {
|
||||
if (lib.skill[name]?.fixed || lib.skill[name]?.superCharlotte) throw new Error("Unsupported protected skill: " + name);
|
||||
}
|
||||
if (!wholePlayer && Object.values(player.additionalSkills || {}).some(list => list?.length)) throw new Error("Additional skill release adapter required");
|
||||
const remove = async function removeSkill(skill) {
|
||||
if (!skill) {
|
||||
return;
|
||||
}
|
||||
_status.event.clearStepCache();
|
||||
if (Array.isArray(skill)) {
|
||||
for (var i = 0; i < skill.length; i++) {
|
||||
await removeSkill.call(this, skill[i]);
|
||||
}
|
||||
} else {
|
||||
if (skill === "counttrigger") {
|
||||
this.stat[this.stat.length - 1].triggerSkill = {};
|
||||
return;
|
||||
} else {
|
||||
var info = lib.skill[skill];
|
||||
if (info?.fixed && arguments[1] !== true) {
|
||||
return skill;
|
||||
}
|
||||
this.unmarkSkill(skill);
|
||||
game.broadcastAll(
|
||||
function(player, skill2) {
|
||||
player.skills.remove(skill2);
|
||||
player.hiddenSkills.remove(skill2);
|
||||
player.invisibleSkills.remove(skill2);
|
||||
delete player.tempSkills[skill2];
|
||||
for (var i2 in player.additionalSkills) {
|
||||
player.additionalSkills[i2].remove(skill2);
|
||||
}
|
||||
},
|
||||
this,
|
||||
skill
|
||||
);
|
||||
this.checkConflict(skill);
|
||||
if (info) {
|
||||
if (info.onremove) {
|
||||
if (typeof info.onremove == "function") {
|
||||
await info.onremove(this, skill);
|
||||
} else if (typeof info.onremove == "string") {
|
||||
if (info.onremove == "storage") {
|
||||
delete this.storage[skill];
|
||||
} else {
|
||||
var cards = this.storage[skill];
|
||||
if (get.itemtype(cards) == "card") {
|
||||
cards = [cards];
|
||||
}
|
||||
if (get.itemtype(cards) == "cards") {
|
||||
if (this.onremove == "discard") {
|
||||
this.$throw(cards);
|
||||
}
|
||||
if (this.onremove == "discard" || this.onremove == "lose") {
|
||||
game.cardsDiscard(cards);
|
||||
delete this.storage[skill];
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (Array.isArray(info.onremove)) {
|
||||
for (var i = 0; i < info.onremove.length; i++) {
|
||||
delete this.storage[info.onremove[i]];
|
||||
}
|
||||
} else if (info.onremove === true) {
|
||||
delete this.storage[skill];
|
||||
}
|
||||
}
|
||||
this.removeSkillTrigger(skill);
|
||||
if (!wholePlayer && !info.keepSkill) {
|
||||
this.removeAdditionalSkills(skill);
|
||||
}
|
||||
}
|
||||
this.enableSkill(skill + "_awake");
|
||||
game.callHook("removeSkillCheck", [skill, this]);
|
||||
}
|
||||
}
|
||||
return skill;
|
||||
};
|
||||
return remove.call(player, skill);
|
||||
}
|
||||
|
||||
// Must be called after gameplay root drained, outside all engine event bodies.
|
||||
export async function runSkillTeardown(releases, {lib,_status}) {
|
||||
if (_status.eventManager.eventStack.length || _status.eventManager.tempEvent) throw new Error("Gameplay must drain before skill release");
|
||||
if (!Array.isArray(releases) || releases.some(fn => typeof fn !== "function")) throw new TypeError("Explicit release callbacks required");
|
||||
const previous = _status.eventManager.rootEvent;
|
||||
const root = new lib.element.GameEvent("mengsanSkillTeardown", false, _status.eventManager);
|
||||
let releaseError;
|
||||
root.setContent(async () => {
|
||||
try {
|
||||
for (const release of releases) {
|
||||
await release();
|
||||
await root.waitNext();
|
||||
}
|
||||
} catch (error) {
|
||||
releaseError = error;
|
||||
// Let the engine drain any queued work and pop this root normally.
|
||||
}
|
||||
});
|
||||
// Natural start completion includes next/after and native stack pop. Failure stays fail-closed.
|
||||
await root.start();
|
||||
if (_status.eventManager.eventStack.includes(root)) throw new Error("Teardown event still active");
|
||||
if (_status.eventManager.rootEvent === root) _status.eventManager.rootEvent = previous;
|
||||
if (releaseError) throw releaseError;
|
||||
}
|
||||
|
||||
// Whole-player disposal differs from removing one source during gameplay: every source is ending.
|
||||
// Each callback runs at most once; failed/partially executed teardown is NOT replayed blindly.
|
||||
export function createPlayerTeardown(players, env) {
|
||||
const captured = players.slice();
|
||||
let operation;
|
||||
const names = player => [...new Set([
|
||||
...(player.skills || []), ...(player.hiddenSkills || []), ...(player.invisibleSkills || []),
|
||||
...Object.keys(player.tempSkills || {}),
|
||||
...Object.values(player.additionalSkills || {}).flatMap(list => typeof list === "string" ? [list] : list || []),
|
||||
])];
|
||||
return () => {
|
||||
if (operation) return operation;
|
||||
operation = (async () => {
|
||||
// Preflight ALL players before modifying any skill.
|
||||
for (const player of captured) for (const name of names(player)) {
|
||||
if (env.lib.skill[name]?.fixed || env.lib.skill[name]?.superCharlotte) throw new Error("Protected skill requires adapter: " + name);
|
||||
if (Object.values(player.additionalSkills || {}).some(value => !Array.isArray(value))) throw new Error("Unsupported additional skill source shape");
|
||||
}
|
||||
await runSkillTeardown(captured.map(player => async () => {
|
||||
const released = new Set();
|
||||
while (names(player).length) {
|
||||
if (released.size >= 128) throw new Error("Skill teardown exceeded bounded expansion");
|
||||
const name = names(player)[0];
|
||||
if (released.has(name)) throw new Error("Released skill was re-added: " + name);
|
||||
await removeBattleSkill(player, name, env, true);
|
||||
released.add(name);
|
||||
// Children can add skills. Drain them before taking the next inventory.
|
||||
await env._status.event.waitNext();
|
||||
}
|
||||
for (const [key,list] of Object.entries(player.additionalSkills || {})) {
|
||||
if (Array.isArray(list) && !list.length) delete player.additionalSkills[key];
|
||||
}
|
||||
}), env);
|
||||
})();
|
||||
return operation;
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
export const getAvailableStoryChoices = (run, content) => {
|
||||
const flags = run.storyFlags || {};
|
||||
return (content?.choices || []).filter(choice => {
|
||||
return (choice.requires || []).every(flag => Boolean(flags[flag]))
|
||||
&& (choice.excludes || []).every(flag => !flags[flag]);
|
||||
});
|
||||
};
|
||||
|
||||
export const applyStoryOutcome = (run, outcome = {}) => {
|
||||
if (!run.storyFlags) run.storyFlags = {};
|
||||
Object.assign(run.storyFlags, outcome.flags || {});
|
||||
return outcome;
|
||||
};
|
||||
Reference in New Issue
Block a user