Diuse/noname-shuying
1
0
Fork 0
mirror of https://github.com/Shu-Ying/noname-shuying.git synced 2026-10-18 21:30:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat # 新增日志功能

Browse Source
This commit is contained in:
Diuse
2026-10-08 14:40:58 +08:00
parent 3a3d547ccd
commit cba7b5fbcc
19 changed files with 978 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mengsan/battle/battle-flow.js
+51 -20
View File
@@ -1,67 +1,89 @@
// Candidate external coordinator. Finish callbacks return a boolean, NEVER a drain promise.
import { getDiagnostics } from "../../diagnostics/index.js";
const copy = value => JSON.parse(JSON.stringify(value));
export function createBattleFlow({settlement, chooseReward, chooseDefeat, showMap, showEnding, quiesce, releaseSkills = async () => {}, presentVictory = async () => {}}) {
export function createBattleFlow({settlement, chooseReward, chooseDefeat, showMap, showEnding, quiesce, releaseSkills = async () => {}, releaseBattle = () => {}, presentVictory = async () => {}}) {
let state = "map", active = null, work = null, job = null, error = null;
let phase = "map", attempt = 0;
const diagnostics = getDiagnostics().scope("mengsan.flow", () => ({
state, phase, attempt, sessionId: active?.session.id,
sessionState: active?.session.state,
pendingTasks: active?.session.pendingCount,
runId: active?.run.runId, revision: active?.run.revision,
nodeId: active?.node.id, settlementId: job?.pending?.id,
outcome: job?.input?.outcome, commitReceipt: !!job?.committed,
skillsReleased: !!job?.skillsReleased, delivered: !!job?.delivered,
}));
const step = (name, action, wait = true) => {
phase = name;
return diagnostics.step(name, action, {}, { observeWait: wait });
};
async function drive() {
try {
state = "draining";
await active.session.drain();
await step("drain", () => 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);
await step("quiesce.beforePrepare", quiesce);
if (!job.pending) job.pending = await step("prepare", () => settlement.prepare(job.input));
if (job.pending.outcome === "victory" && !job.victoryPresented) {
await presentVictory(copy(job.pending));
await step("victoryDialogue", () => presentVictory(copy(job.pending)), false);
job.victoryPresented = true;
}
if (job.pending.state !== "chosen") {
state = "choosing";
if (!job.hasChoice) {
job.choiceId = job.pending.outcome === "defeat" ? await chooseDefeat(copy(job.pending.base))
: await chooseReward(copy(job.pending.choices), {
job.choiceId = await step("rewardSelection", () => job.pending.outcome === "defeat" ? chooseDefeat(copy(job.pending.base))
: chooseReward(copy(job.pending.choices), {
boss: job.pending.boss,
elite: job.pending.elite,
fixedRewards: copy(job.pending.fixedRewards || []),
rewardPackage: copy(job.pending.rewardPackage || null),
});
}), false);
if (job.pending.outcome !== "defeat" && !job.pending.rewardPackage &&
job.choiceId !== null &&
!job.pending.choices.some(c => c.id === job.choiceId && c.kind !== "gold")) throw new Error("Invalid reward selection");
job.hasChoice = true;
}
job.pending = await settlement.choose(job.input.run.runId, job.pending.id, job.choiceId);
job.pending = await step("applyChoice", () => 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);
job.committed = await step("commit", () => settlement.commit(job.input.run.runId, job.pending.id));
}
if (!job.skillsReleased) {
state = "releasingSkills";
await releaseSkills();
await step("releaseSkills", releaseSkills);
job.skillsReleased = true;
await quiesce();
await step("quiesce.afterSkills", quiesce);
}
state = "cleaning";
await active.session.dispose(); // Failed cleanup retry does NOT replay a committed reward.
await quiesce();
await step("dispose", () => active.session.dispose()); // Failed cleanup retry does NOT replay a committed reward.
await step("quiesce.afterDispose", quiesce);
if (!job.battleReleased) {
await step("releaseBattle", releaseBattle);
job.battleReleased = true;
}
if (!job.delivered) {
state = "presenting";
if (job.committed.route === "map") {
const mapRun = copy(job.committed.run);
job.nextNode = await showMap(mapRun);
job.nextNode = await step("showMap", () => showMap(mapRun), false);
job.committed.run = mapRun;
}
else if (job.committed.route !== "new") {
await showEnding(job.committed.route, copy(job.committed.run));
await step("showEnding", () => showEnding(job.committed.route, copy(job.committed.run)), false);
}
job.delivered = true;
}
state = job.committed.route === "map" ? "map" : "ended";
diagnostics.info("settlement.complete", { route: job.committed.route });
return {...copy(job.committed), nextNode:copy(job.nextNode ?? null)};
} catch (cause) {
diagnostics.error("settlement.failed", cause, { failedPhase: phase });
error = cause; state = "retryable"; throw cause;
}
}
function launch() {
attempt++;
error = null; state = "draining";
work = Promise.resolve().then(drive);
// The engine callback is fire-and-forget; keep failure observable without unhandled rejection.
@@ -76,24 +98,33 @@ export function createBattleFlow({settlement, chooseReward, chooseDefeat, showMa
if (!saved || saved.runId !== run.runId || saved.revision !== run.revision) throw new Error("Stale battle input");
state = "starting";
try {
await quiesce();
await step("quiesce.beforeBattle", 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; }
state = "battle"; attempt = 0; start();
diagnostics.info("battle.started");
} catch (cause) {
diagnostics.error("battle.start.failed", cause, { runId: run.runId, nodeId: node.id });
state = "blocked"; error = cause; throw cause;
}
},
requestFinish({session, hp, outcome = "victory", defeatedEnemies = 1}) {
if (state !== "battle" || session !== active.session) return false;
if (state !== "battle" || session !== active.session) {
diagnostics.info("finish.ignored", { requestedSessionId: session?.id, outcome });
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";
diagnostics.info("finish.accepted", { hp, defeatedEnemies });
active.session.requestStop();
launch();
return true; // No game.pause/resume: stop loop, let current body unwind, then open rewards.
},
retry() {
if (state !== "retryable") throw new Error("No failed settlement to retry");
diagnostics.info("settlement.retry");
launch(); return work;
},
wait() { if (!work) throw new Error("No settlement requested"); return work; },
mengsan/battle/battle-resources.js
+4 -1
View File
@@ -20,11 +20,13 @@ export function createBattleResources(session, {game, ui, _status}) {
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()) {
for (const {object,key,value,descriptor} of fields.slice().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;
cards.clear(); nodes.clear(); fields.length = 0;
before.clear(); uiBefore.clear();
});
return Object.freeze({
field,
@@ -49,6 +51,7 @@ export function createBattleResources(session, {game, ui, _status}) {
for (const key of ["currentPhase","lastPhasedPlayer","roundStart"]) {
if (owned.has(_status[key])) delete _status[key];
}
owned.clear();
});
},
});
mengsan/battle/battle-session.js
+16 -2
View File
@@ -1,4 +1,5 @@
// Candidate only. No engine globals, event prototype patches, or save writes.
import { getDiagnostics } from "../../diagnostics/index.js";
const owners = new WeakMap();
export function createBattleSession(id) {
@@ -7,6 +8,11 @@ export function createBattleSession(id) {
let state = "running", disposePromise = null;
const pending = new Set(), events = new Set(), resources = new Map(), errors = [];
const waiters = new Set();
const diagnostics = getDiagnostics().scope("mengsan.session", () => ({
sessionId: id, state, pendingTasks: pending.size,
eventCount: events.size, resourceCount: resources.size,
recordedErrors: errors.length,
}));
const notify = () => { for (const wake of waiters) wake(); waiters.clear(); };
const ensureRunning = () => { if (state !== "running") throw new Error("Session is stopping"); };
const claim = object => {
@@ -20,6 +26,7 @@ export function createBattleSession(id) {
if (!(promise instanceof Promise)) throw new TypeError("Native completion Promise required");
pending.add(promise);
promise.then(() => { pending.delete(promise); notify(); }, error => {
diagnostics.error("task.failed", error);
errors.push(error); pending.delete(promise); notify();
});
return promise;
@@ -58,9 +65,13 @@ export function createBattleSession(id) {
requestStop() {
if (state !== "running") return false;
state = "stopping";
diagnostics.info("stop.requested");
// 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); }
try { event.finish(); } catch (error) {
diagnostics.error("event.finish.failed", error, { eventName: event.name });
errors.push(error);
}
}
notify();
return true;
@@ -80,7 +91,10 @@ export function createBattleSession(id) {
disposePromise = (async () => {
// Reverse acquisition order; stop at first failure to preserve dependent resources.
for (const [resource, release] of [...resources].reverse()) {
await release(resource);
await diagnostics.step("resource.release", () => release(resource), {
resourceType: resource?.constructor?.name,
playerId: resource?.playerid, nodeName: resource?.nodeName,
});
resources.delete(resource); owners.delete(resource);
}
for (const event of events) owners.delete(event);
mengsan/battle/battle-settlement.js
+23 -3
View File
@@ -4,6 +4,7 @@ import { applySharedBattleEndCards } from "../cards/shared-battle-end.js";
import { settleBondBattle } from "../bonds/state.js";
import { recordNormalBattleVictory } from "../progression/encounter-progress.js";
import { stripBattleProgress } from "../progression/map-checkpoint.js";
import { getDiagnostics } from "../../diagnostics/index.js";
import { prepareRewardPackage, applyRewardPackage }
from "../progression/reward-package.js";
@@ -14,6 +15,11 @@ export function createBattleSettlement({
enterNextAct, createRun, now = Date.now, logRewardPackage = () => {},
}) {
let item = null, committed = null, commitPromise = null;
const diagnostics = getDiagnostics().scope("mengsan.settlement", () => ({
settlementId: item?.id, runId: item?.base.runId,
nodeId: item?.nodeId, pendingState: item?.state,
route: item?.route, commitReceipt: !!committed,
}));
const readRun = () => store.read()[config.saveKey];
function current(storage, runId) {
const run = storage[config.saveKey];
@@ -27,6 +33,11 @@ export function createBattleSettlement({
function validateCheckpoint(run, snapshot, nodeId) {
if (run.actIndex !== snapshot.actIndex || run.revision !== snapshot.revision ||
run.map?.nodes.find(node => node.id === nodeId)?.completed !== false) {
diagnostics.warn("checkpoint.mismatch", {
expectedRevision: snapshot.revision, actualRevision: run.revision,
expectedAct: snapshot.actIndex, actualAct: run.actIndex,
nodeId, completed: run.map?.nodes.find(node => node.id === nodeId)?.completed,
});
throw new Error("Stale node or revision");
}
}
@@ -75,6 +86,10 @@ export function createBattleSettlement({
getRandomRewardChoices) : null;
item = {id, state:"awaitingChoice", nodeId:node.id, base, choices:copy(choices), fixedRewards:copy(fixedRewards), victoryDialogue:copy(encounter.victoryDialogue || []), boss:!!encounter.boss, elite, outcome, relicRecovery, bondGrowth};
item.rewardPackage = copy(rewardPackage);
diagnostics.info("prepared", {
outcome, choices: choices.map(choice => choice.id), fixedRewards,
expectedRevision: snapshot.revision, actualRevision: run.revision,
});
if (outcome === "victory" && !rewardPackage) {
item.rewardMode = "one-or-skip";
}
@@ -149,6 +164,7 @@ export function createBattleSettlement({
// 在内存锁定最终结果（包括随机牌实例），只在 commit 写入地图进度。
item.state = "chosen"; item.choiceId = copy(choiceId); item.result = stripBattleProgress(result);
item.route = route; item.completedAt = now();
diagnostics.info("choice.applied", { choiceId, route });
if (item.rewardPackage && item.outcome === "victory") {
logRewardPackage(item.rewardPackage, choiceId);
}
@@ -157,8 +173,11 @@ export function createBattleSettlement({
async commit(runId, id) {
const item = pending(runId, id);
if (item.state !== "chosen") throw new Error("Player choice required before saving");
if (committed) return {...copy(committed), duplicate:true};
if (commitPromise) return commitPromise;
if (committed) {
diagnostics.info("commit.duplicate");
return {...copy(committed), duplicate:true};
}
if (commitPromise) { diagnostics.info("commit.inflight"); return commitPromise; }
commitPromise = store.update(storage => {
const saved = storage[config.saveKey];
const prior = storage[config.profileKey]?.completedRuns?.find(r => r.runId === runId && r.settlementId === id);
@@ -188,8 +207,9 @@ export function createBattleSettlement({
else delete storage[config.saveKey]; // Same transaction as profile; never a second clear write.
}
return {route:item.route, run:item.route === "new" ? copy(item.nextRun) : result, duplicate:false};
}).then(result => {
}, { runId, settlementId: id, nodeId: item.nodeId }).then(result => {
committed = copy(result);
diagnostics.info("commit.receipt", { duplicate: result.duplicate, route: result.route });
return copy(committed);
}).finally(() => { commitPromise = null; });
return commitPromise;
mengsan/mode.js
+39 -7
View File
@@ -94,6 +94,7 @@ import { mountGMManager } from "./ui/gm-manager.js";
import { createPlayerTeardown } from "./battle/skill-teardown.js";
import { createBattleResources } from "./battle/battle-resources.js";
import { createModeStorage } from "./progression/mode-storage.js";
import { getDiagnostics } from "../diagnostics/index.js";
import { createBattleSession } from "./battle/battle-session.js";
import { observeFreshEvent } from "./battle/engine-session.js";
import { runPhaseLoop, stopBattleTurn } from "./battle/battle-loop.js";
@@ -141,7 +142,26 @@ const clearRun = modeStorage.clearRun;
const showMap = run => renderMap(run, { saveRun });
let battleSequence = 0;
let activeBattle = null;
const reportFlowError = error => { console.error("梦三流程暂停，未自动清档：", error); };
const diagnosticService = getDiagnostics();
const diagnostics = diagnosticService.scope("mengsan.mode");
diagnosticService.registerContext("mengsan", () => {
const run = _status.mengsanRun_shuying;
const manager = _status.eventManager;
return {
runId: run?.runId, revision: run?.revision, actIndex: run?.actIndex,
character: run?.player?.character, hp: run?.player?.hp,
sessionId: activeBattle?.session.id,
flowState: activeBattle?.flow.state, pendingTasks: activeBattle?.session.pendingCount,
save: modeStorage.lastWrite,
engine: { paused: _status.paused, paused2: _status.paused2,
tempEvent: manager?.tempEvent?.name,
eventStack: manager?.eventStack?.slice(-8).map(event => ({ name: event?.name })) },
};
});
const reportFlowError = error => {
diagnostics.error("journey.failed", error);
console.error("梦三流程暂停，未自动清档：", error);
};
const chooseRun = async savedRun => {
const available = savedRun?.status === "running";
@@ -718,8 +738,9 @@ const registerPlayers = (session, players) => {
});
}
};
const makeFlow = (releaseSkills = async () => {}) => createBattleFlow({
const makeFlow = (releaseSkills = async () => {}, releaseBattle = () => {}) => createBattleFlow({
releaseSkills,
releaseBattle,
presentVictory: pending => {
if (pending.bondGrowth) {
const growth = pending.bondGrowth;
@@ -764,7 +785,10 @@ const requestBattleFinish = outcome => {
const current = activeBattle;
if (!current) return false;
// Complete the original card and all queued replays before snapshotting a victory.
if(outcome==="victory" && current.sharedPendingUses?.size){current.sharedDeferredVictory=true;return false;}
if(outcome==="victory" && current.sharedPendingUses?.size){
diagnostics.info("victory.deferred", { pendingUses: current.sharedPendingUses.size });
current.sharedDeferredVictory=true;return false;
}
for (const player of game.dead) {
recordBondDeath(player, _status.mengsanRun_shuying,
message => game.log(message));
@@ -787,10 +811,12 @@ const awaitSettlement = async (flow, initial = flow.wait()) => {
try { return await operation; }
catch (error) {
if (flow.state !== "retryable") throw error;
diagnostics.error("settlement.prompt", error, { flowState: flow.state });
const action = await chooseButtons("结算未完成", [
{id:"retry",name:"重试保存与结算"},
{id:"exit",name:"保留已保存进度并返回模式选择"},
], "已提交的奖励不会重发。技能释放失败时请返回模式选择，避免重复调用释放回调。");
diagnostics.info("settlement.prompt.action", { action });
if (action === "exit") { await openModeSelection(); throw error; }
operation = flow.retry();
}
@@ -801,14 +827,20 @@ const playBattle = async (run, node, encounter) => {
if (lib.onfree) await new Promise(resolve => lib.onfree.push(resolve));
await quiesceEngine(_status);
const session = createBattleSession(`${run.runId}:${++battleSequence}`);
const resources = createBattleResources(session, {game,ui,_status});
let current;
const flow = makeFlow(() => current.releaseSkills?.());
let resources = createBattleResources(session, {game,ui,_status});
let current, root;
const flow = makeFlow(() => current.releaseSkills?.(), () => {
if (activeBattle === current) activeBattle = null;
for (const key of Object.keys(current)) {
if (key !== "session" && key !== "flow") delete current[key];
}
root = null; resources = null;
});
let finished;
const signal = new Promise(resolve => { finished = resolve; });
current = {session, flow, finished, resources, players: new Set(), monsterPiles: new Map(), energyUI: new Map(), intentUI: new Map()};
activeBattle = current;
const root = new lib.element.GameEvent("mengsanBattle", false, _status.eventManager);
root = new lib.element.GameEvent("mengsanBattle", false, _status.eventManager);
current.root = root;
const previousRoot = _status.eventManager.rootEvent;
session.ownResource({}, () => {
mengsan/progression/mode-storage.js
+47 -9
View File
@@ -1,8 +1,11 @@
// Candidate factory. Storage writer body reused from batch2 MODIFIED_STORAGE.js.
import { migrateRetiredCards } from "../cards/retired-cards.js";
import { stripBattleProgress } from "./map-checkpoint.js";
import { getDiagnostics } from "../../diagnostics/index.js";
export function createModeStorage({lib, game, config, localStorage, alert = () => {}, console = globalThis.console}) {
const MODE_ID = config.modeId;
const diagnostics = getDiagnostics().scope("mengsan.storage");
let writeSequence = 0, lastWrite = null;
const copy = value => JSON.parse(JSON.stringify(value));
@@ -16,10 +19,14 @@ const copyStorage = () => {
// Keep one mode-level writer; a failed write must not poison later retries.
let modeStorageQueue = Promise.resolve();
const writeModeStorage = storage => {
const writeModeStorage = (storage, receipt) => {
receipt.phase = "storage.write";
receipt.storageStatus = "pending";
if (!lib.db) {
// Do not switch backends after an IndexedDB error: that creates two saves.
localStorage.setItem(`${lib.configprefix}${MODE_ID}`, JSON.stringify(storage));
receipt.storageStatus = "committed";
diagnostics.info("storage.committed", receipt);
return Promise.resolve();
}
return new Promise((resolve, reject) => {
@@ -28,11 +35,18 @@ const writeModeStorage = storage => {
try {
// game.putDB resolves at request success, which is before commit.
transaction = lib.db.transaction(["data"], "readwrite");
transaction.oncomplete = () => resolve();
transaction.oncomplete = () => {
receipt.storageStatus = "committed";
diagnostics.info("transaction.committed", receipt);
resolve();
};
transaction.onerror = event => {
requestError = event.target?.error;
};
transaction.onabort = () => reject(transaction.error || requestError || new Error("梦三存档事务已中止"));
transaction.onabort = () => {
receipt.storageStatus = "aborted";
reject(transaction.error || requestError || new Error("梦三存档事务已中止"));
};
transaction.objectStore("data").put(storage, MODE_ID);
}
catch (error) {
@@ -45,18 +59,39 @@ const writeModeStorage = storage => {
});
};
const persistModeStorage = (update = () => {}) => {
const persistModeStorage = (update = () => {}, context = {}) => {
const receipt = { ...context, writeId: ++writeSequence, phase: "queued",
backend: lib.db ? "indexeddb" : "localStorage",
storageStatus: "notStarted", memoryPublished: false };
diagnostics.info("save.queued", receipt);
// 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 () => {
lastWrite = receipt;
receipt.phase = "snapshot";
const storage = copyStorage();
receipt.phase = "mutator";
update(storage);
stripBattleProgress(storage[config.saveKey]);
storage.version = lib.version;
await writeModeStorage(storage);
await writeModeStorage(storage, receipt);
receipt.phase = "memory.publish";
lib.storage = storage;
}).finally(() => game.reload2());
receipt.memoryPublished = true;
diagnostics.info("memory.published", receipt);
}).catch(error => {
diagnostics.error("save.failed", error, receipt);
throw error;
}).finally(() => {
receipt.phase = "reloadGuard.release";
try { game.reload2(); }
catch (error) {
diagnostics.error("reloadGuard.failed", error, receipt);
throw error;
}
diagnostics.info("save.finished", receipt);
});
modeStorageQueue = operation.catch(() => {});
return operation;
};
@@ -67,9 +102,11 @@ const saveRun = async run => {
const snapshot = migrateRetiredCards(stripBattleProgress(copy(run)));
await persistModeStorage(storage => {
storage[config.saveKey] = snapshot;
});
}, { runId: snapshot.runId, revision: snapshot.revision });
}
catch (error) {
diagnostics.error("saveRun.failed", error,
{ runId: run?.runId, revision: run?.revision, lastWrite });
// Neither delete the previous save nor attempt a second destructive write.
alert("梦三存档失败，未覆盖上一次成功保存的进度。当前进度尚未保存，请勿刷新，并查看控制台错误。");
console.error("梦三存档失败：", error);
@@ -87,13 +124,14 @@ const clearRun = async () => {
return Object.freeze({
read: copyStorage,
get lastWrite() { return lastWrite ? { ...lastWrite } : null; },
saveRun, clearRun,
async update(mutator) {
async update(mutator, context = {}) {
let value;
await persistModeStorage(storage => {
value = mutator(storage);
if (value && typeof value.then === "function") throw new TypeError("Storage mutator must be synchronous");
});
}, context);
return value === undefined ? undefined : copy(value);
},
});
mengsan/ui/bonds.js
+3
View File
@@ -2,6 +2,7 @@ import { bondDefinitions, getBondCombat, getBondDeck }
from "../bonds/definitions.js";
import { getBondIntents } from "../bonds/intents.js";
import { bondProbability, ensureBonds, selectBond } from "../bonds/state.js";
import { getDiagnostics } from "../../diagnostics/index.js";
export function renderBonds(parent, run, saveRun, onBusy = () => {}) {
const bonds = ensureBonds(run);
@@ -33,6 +34,8 @@ export function renderBonds(parent, run, saveRun, onBusy = () => {}) {
updated.querySelector('button[aria-pressed="true"]')
?.focus({ preventScroll: true });
} catch (error) {
getDiagnostics().scope("mengsan.bonds").error("selection.save.failed", error,
{ runId: run.runId, revision: run.revision, bondId: id });
selectBond(run, previous);
status.textContent = "保存失败，请重试。";
console.error("梦三助战选择保存失败", error);
mengsan/ui/hand/diagnostics.js
+9
View File
@@ -1,8 +1,17 @@
import { getDiagnostics } from "../../../diagnostics/index.js";
const lines = [];
let pendingWrite = Promise.resolve();
export function createHandDiagnostics(game, sessionId) {
const service = getDiagnostics();
const diagnostics = service.scope("mengsan.hand", { sessionId });
return (message, error) => {
if (service.status().enabled) {
if (error) diagnostics.error("hand.failed", error, { message });
else diagnostics.info("hand.message", { message });
return;
}
const line = `${new Date().toISOString()} [${sessionId}] ${message}` +
(error ? ` ${error.message || error}` : "");
console[error ? "warn" : "info"](`梦三手牌 UI：${line}`);
mengsan/ui/map/renderer.js
+4
View File
@@ -5,6 +5,7 @@ import config from "../../config.js";
import { getRelic } from "../../relics/definitions.js";
import { renderBonds } from "../bonds.js";
import { getSelectableNodes } from "../../progression/state.js";
import { getDiagnostics } from "../../../diagnostics/index.js";
// Original vector pictograms; no external image/font requests.
const iconPaths = {
@@ -186,6 +187,8 @@ export const showMap = (run, { saveRun } = {}) => new Promise(resolve => {
if (result === "exit") await openModeSelection();
} catch (error) {
console.error(error);
getDiagnostics().scope("mengsan.map").error("map.operation.failed", error,
{ runId: run.runId, revision: run.revision });
await askMenu("暂时无法返回", "征程未被清除，请重试。", [{ id: "close", name: "关闭提示" }]);
} finally { exitButton.disabled = false; }
});
@@ -324,6 +327,7 @@ export const showMap = (run, { saveRun } = {}) => new Promise(resolve => {
try { await openNonameMenu(); }
catch (error) {
console.error("梦三打开 Noname 菜单失败：", error);
getDiagnostics().scope("mengsan.map").error("menu.open.failed", error);
await askMenu("暂时无法显示菜单", error.message || "请稍后重试。", [{ id: "close", name: "回到行军图" }]);
}
},
mengsan/ui/navigation.js
+6 -1
View File
@@ -1,5 +1,6 @@
import { lib, game, ui, _status } from "../../../../noname.js";
import { save } from "../../../../noname/util/config.js";
import { getDiagnostics } from "../../diagnostics/index.js";
let selectingMode = false;
let nonameMenuTask = null;
@@ -50,7 +51,10 @@ export const openNonameMenu = async () => {
if (initiallyHidden) {
try {
if (!container.classList.contains("hidden")) ui.click.configMenu();
} catch (closeError) { console.error("Noname 菜单关闭失败：", closeError); }
} catch (closeError) {
getDiagnostics().scope("mengsan.navigation").error("menu.close.failed", closeError);
console.error("Noname 菜单关闭失败：", closeError);
}
if (wasPaused) game.pause2();
else game.resume2();
}
@@ -170,6 +174,7 @@ export const mountMenu = (overlay, options = {}) => {
if (confirmed === "confirm") await openModeSelection();
} catch (error) {
console.error("梦三菜单操作失败：", error);
getDiagnostics().scope("mengsan.navigation").error("menu.operation.failed", error);
await askMenu(action === "noname" ? "暂时无法显示菜单" : "暂时无法返回",
action === "noname" ? error.message || "请关闭提示后重试。" : "没有清除征程。请关闭提示后重试。",
[{ id: "close", name: "回到当前界面" }]);