dsh-pet-live2d-viola 1.1.0 → 1.1.1

package/README.md

@@ -71,6 +71,49 @@ DeepSeek Harness Web GUI 的 **Live2D 桌宠插件**，一台桌宠里可以切
 
 每位角色有自己的待机动作池，每 12 秒换一次姿势，并按各自的静默权重决定要不要说一句话。都子的待机台词与特定动作绑定。
 
+## 随机模式
+
+**右键 → 设置 → 随机模式**，二级界面：
+
+```
+← 返回                随机模式
+　开启随机模式
+──────────────────
+随机内容
+✓ 随机动作＋表情
+　随机动作
+　随机表情
+```
+
+开启后，待机时**每 12 秒**按所选范围重新随机。三种范围：
+
+| 范围 | 动作 | 表情 | 语音 |
+|---|---|---|---|
+| 随机动作 | 每 12 秒随机 | 保持你选的脸 | 静音 |
+| 随机表情 | 照常 | 每 12 秒随机 | 静音 |
+| 随机动作＋表情 | 每 12 秒随机 | 每 12 秒随机 | 静音 |
+
+- **只在待机状态生效** —— 思考/工作/完成等阶段保持各阶段的正常行为
+- **任意范围都静音**：语音带自己的字幕和借来的脸，会打断随机序列
+- 表情池 = **菜单里能选的那些**（排除内部生成的 `_nomouth` 变体）
+- 抽取**不会选中当前已在用的**表情，避免连续两次相同
+- 开关与范围是**两个独立字段**，所以关掉再打开会记住上次选的范围
+- 默认**关闭**。待机漂移本来只动身体不动脸，因为自己乱变的脸会覆盖你手动选的表情 —— 这是有意的默认值
+
+## 功能简介
+
+**右键 → 设置 → 功能简介** —— 只读面板，介绍当前人物的能力。
+
+**所有数字都是实时统计的**，从菜单用的同一批表里数出来，所以加了语音或动作会自动更新：
+
+| 项 | 来源 |
+|---|---|
+| 动作数 | 动作组里以 `_C` 结尾的（与动作菜单一致） |
+| 表情数 | 排除内部组合（与表情菜单一致） |
+| 待机动作数 | 本角色的待机池 |
+| 语音条数 | 点击 + 阶段反应 + 待机 + 下线 |
+| 随机模式 | 说明 + **当前是否开启及所选范围** |
+
 ## 取景
 
 三种取景：**全身 / 四分之三身 / 半身**。

package/lib/client.js

@@ -1599,6 +1599,32 @@ window.__ModuleLoader__.load({
 			"pet.menu.frame": "显示取景框边界",
 			"pet.menu.blink": "自动眨眼",
 			"pet.menu.gaze": "视线追随鼠标",
+			"pet.menu.randomMode": "随机模式",
+			"pet.menu.title.random": "随机模式",
+			"pet.menu.randomModeOn": "开启随机模式",
+			"pet.menu.randomScope": "随机内容",
+			"pet.menu.randomMotion": "随机动作",
+			"pet.menu.randomExpression": "随机表情",
+			"pet.menu.randomBoth": "随机动作＋表情",
+			"pet.menu.about": "功能简介",
+			"pet.menu.title.about": "功能简介",
+			"pet.about.who": "当前人物",
+			"pet.about.pool": "动作与表情",
+			"pet.about.pool.text": "{motions} 个动作、{expressions} 个表情，右键菜单里可直接挑选",
+			"pet.about.idle": "待机",
+			"pet.about.idle.text": "每 12 秒从 {count} 个待机动作里随机换一次姿势",
+			"pet.about.voice": "语音",
+			"pet.about.voice.click": "点击 {count} 条",
+			"pet.about.voice.phase": "阶段反应 {count} 条",
+			"pet.about.voice.idle": "待机 {count} 条",
+			"pet.about.voice.farewell": "下线 1 条",
+			"pet.about.voice.none": "这个人物还没有语音",
+			"pet.about.listSep": "、",
+			"pet.about.random": "随机模式",
+			"pet.about.random.text": "在「设置 → 随机模式」里开启。开启后待机时每 12 秒按所选范围重新随机，并且不出声；可选只为动作、只为表情，或两者都随机。",
+			"pet.about.random.now": "当前：已开启（{scope}）",
+			"pet.about.how": "操作",
+			"pet.about.how.text": "左键拖动移动、滚轮缩放、点击说话、右键打开菜单。",
 			"pet.menu.submenuHint": "点击进入",
 			"pet.menu.volume": "语音音量",
 			"pet.menu.title.volume": "语音音量（0 为静音）",
@@ -1724,6 +1750,32 @@ window.__ModuleLoader__.load({
 			"pet.menu.frame": "Show framing boundary",
 			"pet.menu.blink": "Auto blink",
 			"pet.menu.gaze": "Eyes follow pointer",
+			"pet.menu.randomMode": "Random mode",
+			"pet.menu.title.random": "Random mode",
+			"pet.menu.randomModeOn": "Enable random mode",
+			"pet.menu.randomScope": "What to randomise",
+			"pet.menu.randomMotion": "Random motions",
+			"pet.menu.randomExpression": "Random expressions",
+			"pet.menu.randomBoth": "Both motion and expression",
+			"pet.menu.about": "About this character",
+			"pet.menu.title.about": "About this character",
+			"pet.about.who": "Currently showing",
+			"pet.about.pool": "Motions and expressions",
+			"pet.about.pool.text": "{motions} motions and {expressions} expressions, all pickable from the right-click menu",
+			"pet.about.idle": "Idling",
+			"pet.about.idle.text": "Changes pose every 12 seconds, drawn from {count} idle motions",
+			"pet.about.voice": "Voice",
+			"pet.about.voice.click": "{count} on click",
+			"pet.about.voice.phase": "{count} phase reactions",
+			"pet.about.voice.idle": "{count} idle lines",
+			"pet.about.voice.farewell": "1 goodbye",
+			"pet.about.voice.none": "No voice lines yet for this character",
+			"pet.about.listSep": ", ",
+			"pet.about.random": "Random mode",
+			"pet.about.random.text": "Turn it on under Settings → Random mode. While it is on, the idle pose is redrawn every 12 seconds according to the scope you pick, and she stays silent; the scope can be motions only, expressions only, or both.",
+			"pet.about.random.now": "Currently on ({scope})",
+			"pet.about.how": "Controls",
+			"pet.about.how.text": "Drag to move, scroll to zoom, click to talk, right-click for the menu.",
 			"pet.menu.submenuHint": "open",
 			"pet.menu.volume": "Voice volume",
 			"pet.menu.title.volume": "Voice volume (0 = muted)",
@@ -2434,6 +2486,13 @@ window.__ModuleLoader__.load({
 	font: 12px/1.5 system-ui, -apple-system, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif;
 }
 .dsh-l2d-menu-title { padding: 5px 8px 3px; opacity: .6; font-size: 11px; letter-spacing: .04em; }
+/*
+ * A read-only line inside the menu, for the description panel.
+ *
+ * Wraps and stays dimmer than a button, so it reads as copy rather than as something to press — the panel has no actions,
+ * and a row that looks clickable but does nothing is worse than plain text.
+ */
+.dsh-l2d-menu-text { padding: 0 8px 6px; opacity: .85; font-size: 12px; line-height: 1.5; white-space: normal; }
 .dsh-l2d-menu button {
 	display: block;
 	width: 100%;
@@ -2729,6 +2788,26 @@ window.__ModuleLoader__.load({
 				 */
 				this.blinkEnabled = options.blink !== false;
 				this.gazeEnabled = options.gaze !== false;
+				/**
+				 * Random mode, pushed in from the layout like the two above.
+				 *
+				 * `randomMode` says whether it is on; `randomScope` says what it randomises — motions, expressions, or both.
+				 * Two fields rather than one enum with an "off" member, so switching the mode off and on again restores the
+				 * scope that was chosen rather than resetting it.
+				 *
+				 * Read from the options rather than assigned literals so the FIRST frame already respects them; later changes
+				 * arrive through {@link setRandomMode}. @see randomScope
+				 */
+				this.randomMode = options.randomMode === true;
+				this.randomScope = options.randomScope ?? "both";
+				/**
+				 * The expressions random mode may draw from, pushed in by the pet.
+				 *
+				 * It CANNOT be read from the model: `Live2DModel` exposes no `.expressions` — measured on a loaded instance,
+				 * the property is `undefined` — so the only list of names is the one the host sends in the snapshot, which
+				 * only the pet has. @see drawIdleFace
+				 */
+				this.expressionPool = Array.isArray(options.expressionPool) ? options.expressionPool : [];
 				/**
 				 * How the drift hands a motion to the pet so its line (voice AND caption) can be
 				 * played: `(motion) => void`.
@@ -3934,9 +4013,11 @@ window.__ModuleLoader__.load({
 			/**
 			 * Play one drift clip for the current phase.
 			 *
-			 * MOVES ONLY. The face used to be randomised here too, which meant her expression
-			 * drifted on its own and silently overwrote whatever was picked from the menu. Her
-			 * expression now changes only when one is chosen.
+			 * MOVES ONLY, unless RANDOM MODE is on. The face used to be randomised here unconditionally, which meant her
+			 * expression drifted on its own and silently overwrote whatever was picked from the menu. Her expression now
+			 * changes only when one is chosen — except while the user has switched random mode on, where pairing a random
+			 * face with the random motion is the whole feature. An explicit mode is the difference: a face that changes on
+			 * its own is a defect, the same behaviour behind a switch the user threw is not.
 			 *
 			 * A click animation outranks this entirely: while its hold window is open nothing is
 			 * attempted, so the startle cannot be cut short even by a drift that was already due.
@@ -3945,6 +4026,22 @@ window.__ModuleLoader__.load({
 				if (this.clickHoldsModel()) return;
 				const binding = this.phaseAnimation ?? PHASE_ANIMATION.idle;
 				const motions = binding.idleMotions ?? PHASE_ANIMATION.idle.idleMotions;
+				const random = this.randomModeEnabled();
+				/*
+				 * RANDOM MODE, three scopes.
+				 *
+				 * `motion`   — the motion is drawn at random (the weighted pool still applies) and the face is left alone.
+				 *              That is what the drift already does, so this scope changes nothing except that it is now an
+				 *              explicit choice; it exists so the menu can express it, and so a user who wants a still face
+				 *              with lively motion has somewhere to say so.
+				 * `expression` — the motion follows the pool and a new face is drawn.
+				 * `both`     — a fresh motion AND a fresh face, which is the pairing this mode was built for.
+				 *
+				 * The face is drawn BEFORE the empty-pool early return, because it does not depend on the motion pool: a
+				 * phase with no motions would otherwise freeze the face as well as the body, and the mode would look like it
+				 * worked in some states and not others.
+				 */
+				if (random && this.randomFaces()) this.drawIdleFace();
 				if (motions.length === 0) return;
 				// Avoid repeating the clip already playing, so the drift reads as activity
 				// rather than as one motion stuttering on a timer.
@@ -3961,7 +4058,87 @@ window.__ModuleLoader__.load({
 				 * because `thinking` uses a different set from every other phase and offering both would
 				 * let the two cancel each other — a second request is dropped while one is playing.
 				 */
-				this.offerLine(motion);
+				if (!this.randomSilencesVoice(random)) this.offerLine(motion);
+			}
+
+			/**
+			 * True while the user has random mode switched on AND a drift slot is allowed to use it.
+			 *
+			 * The switch lives on this object, pushed in by the pet's `applyLayout` — the stage holds no layout of its own,
+			 * which is why this is a field rather than a read of `options.layout`.
+			 *
+			 * Two conditions beyond the switch:
+			 *
+			 * `idlePhase` must BE `idle`, or be unset. The mode is specified for the resting state, and letting it run
+			 * during `listening`, `thinking`, `working` or `done` would overwrite the face each of those reactions pairs
+			 * with its own line — the reaction plays, and a moment later the face it chose is replaced. `undefined` is
+			 * accepted because the drift can run before any phase has been seen, which is the resting state.
+			 *
+			 * A click must not own the model. `playPhaseIdle` already refuses to play while one does, so this only keeps the
+			 * face consistent with the body it is decided alongside.
+			 */
+			randomModeEnabled() {
+				if (this.randomMode !== true) return false;
+				if (this.idlePhase !== undefined && this.idlePhase !== "idle") return false;
+				return !this.clickHoldsModel();
+			}
+
+			/** True when the active scope draws a new FACE on each slot. @see randomScope */
+			randomFaces() {
+				return this.randomScope === "expression" || this.randomScope === "both";
+			}
+
+			/**
+			 * True when the drift must stay SILENT for this slot.
+			 *
+			 * ANY active random-mode scope silences the voice. A clip carries its own caption and borrows its own face, so a
+			 * line interrupts the sequence the mode is running — and for the face-drawing scopes the two would also fight
+			 * over the expression parameter, the line winning until it ended and the drift then overwriting the face it had
+			 * picked. `motion` has no such conflict, but a drift that speaks in one scope and not another reads as the mode
+			 * being unreliable rather than as a rule, so the whole mode is quiet.
+			 *
+			 * Called with the already-computed `random` flag so the condition is evaluated once per slot.
+			 */
+			randomSilencesVoice(random) {
+				return random === true;
+			}
+
+			/** Set random mode for the character now showing, from the persisted layout. */
+			setRandomMode(on) {
+				this.randomMode = on === true;
+			}
+
+			/** Set what random mode randomises, from the persisted layout. @see randomScope */
+			setRandomScope(scope) {
+				this.randomScope = typeof scope === "string" ? scope : "both";
+			}
+
+			/** Replace the expression pool, for a character switch. @see expressionPool */
+			setExpressionPool(names) {
+				this.expressionPool = Array.isArray(names) ? names : [];
+			}
+
+			/**
+			 * Wear a random expression, for a random-mode idle slot.
+			 *
+			 * The pool arrives from the pet already filtered, so what random mode can pick is exactly what the expression
+			 * menu offers — the internal combinations exist for voice lines to borrow and are not meant to be worn alone.
+			 *
+			 * The current face is excluded from the draw so consecutive slots do not show the same expression twice. The
+			 * guard is on the FILTERED pool rather than an index into it, because that pool is usually shorter than the
+			 * model's list and an index computed from one would address the wrong entry.
+			 *
+			 * `{ user: true }` is deliberately NOT passed. That flag records a deliberate choice and pushes the drift timer
+			 * out of the way; this IS the drift, so claiming priority would be the drift cancelling itself.
+			 */
+			drawIdleFace() {
+				const pool = this.expressionPool;
+				if (!Array.isArray(pool) || pool.length === 0) return false;
+				const options = pool.filter((name) => name !== this.lastExpression);
+				const from = options.length > 0 ? options : pool;
+				const chosen = from[Math.floor(Math.random() * from.length)];
+				if (chosen === undefined) return false;
+				return this.playExpression(chosen);
 			}
 
 			/**
@@ -4577,6 +4754,114 @@ window.__ModuleLoader__.load({
 				this.syncPhase();
 			}
 
+			/**
+			 * The expressions random mode may draw from.
+			 *
+			 * Exactly the list the expression MENU offers, built by the same two rules: the names come from the host's
+			 * snapshot — the loaded `Live2DModel` has no expression list of its own — and the internal combinations are
+			 * removed, because those exist for voice lines to borrow and are not meant to be worn on their own.
+			 *
+			 * Kept next to the menu's own filter in spirit if not in code, so the two cannot disagree about what is pickable:
+			 * a pool that drifted apart would let random mode show a face the user can neither choose nor reset to.
+			 * @see INTERNAL_EXPRESSIONS
+			 */
+			randomFacePool() {
+				const names = this.snapshot?.model?.expressions;
+				if (!Array.isArray(names)) return [];
+				const internal = INTERNAL_EXPRESSIONS();
+				return names.filter((name) => !internal.has(expressionKey(name)));
+			}
+
+			/**
+			 * The rows of the 「功能简介」 panel: what the character now on screen can actually DO.
+			 *
+			 * Every number is COUNTED from the same tables the rest of the menu uses rather than written down here, so the
+			 * panel cannot drift out of date — an entry added to a character's voice lines appears in this list the next time
+			 * it is opened, and a character with a new scope of reactions needs no edit here.
+			 *
+			 * Returned as `{ head, text }` pairs rather than as finished elements so the drawing stays in `openMenu`, next to
+			 * the menu it belongs to, and this stays a pure description of the character.
+			 */
+			characterIntro() {
+				const t = this.options.t;
+				const snapshot = this.snapshot;
+				const model = snapshot?.model;
+				if (model === undefined) return [];
+				const content = activeCharacterConfig();
+				const rows = [];
+
+				/*
+				 * Who, and in which outfit.
+				 *
+				 * The two labels come from the same table pair the menu uses — `characterLabel` answers "who" and `modelLabel`
+				 * answers "wearing what" — and the outfit is only appended when it ADDS something. For 都子 the two are the
+				 * same string ("都子"), so showing both would read as 「都子（都子）」.
+				 */
+				const id = snapshot?.characters?.active;
+				const who = characterLabel(id);
+				const outfit = modelLabel(id);
+				rows.push({ head: t("pet.about.who"), text: outfit === who ? who : `${who}（${outfit}）` });
+
+				/*
+				 * The motion and expression COUNTS are filtered exactly as their menus filter them: motions are the
+				 * centre-layer `_C` clips only, and the internal expression combinations are excluded. Counting the raw lists
+				 * would advertise entries the user cannot reach — the motion list includes the additive L/R poses, and the
+				 * expression list includes the `_nomouth` variants built for voice lines.
+				 */
+				const motions = (model.motions ?? []).filter((name) => name.endsWith("_C")).length;
+				const internal = INTERNAL_EXPRESSIONS();
+				const expressions = (model.expressions ?? []).filter((name) => !internal.has(expressionKey(name))).length;
+				rows.push({ head: t("pet.about.pool"), text: t("pet.about.pool.text", { motions, expressions }) });
+
+				/*
+				 * The idle drift, from the character's own content.
+				 *
+				 * `content.idleMotions` is the client-side mirror of the host's active pool — the same list `verify-phases`
+				 * compares — so this is the count the drift will actually draw from. The phase binding is used as a fallback
+				 * because it is what the running stage holds once a phase has arrived.
+				 */
+				const idle = (content.idleMotions ?? snapshot?.animation?.idleMotions ?? []).length;
+				if (idle > 0) rows.push({ head: t("pet.about.idle"), text: t("pet.about.idle.text", { count: idle }) });
+
+				// What she says, split the way the voice system splits it.
+				const click = CLICK_REACTIONS[id] ?? CLICK_REACTIONS[id?.replace(/_(school|virtual)$/, "")];
+				const clicks = (click?.normal?.length ?? 0) + (click?.rapid?.length ?? 0);
+				const reactions = Object.values(content.phaseReactions ?? {}).reduce((n, entry) => n + (entry?.reactions?.length ?? 0), 0)
+					+ Object.values(content.phaseLines ?? {}).reduce((n, entry) => n + (entry?.lines?.length ?? 0), 0);
+				const idleLines = (content.idleLines ?? []).length;
+				const parts = [];
+				if (click !== undefined && clicks > 0) parts.push(t("pet.about.voice.click", { count: clicks }));
+				if (reactions > 0) parts.push(t("pet.about.voice.phase", { count: reactions }));
+				if (idleLines > 0) parts.push(t("pet.about.voice.idle", { count: idleLines }));
+				if ((content.farewellVoice ?? "") !== "") parts.push(t("pet.about.voice.farewell"));
+				rows.push({ head: t("pet.about.voice"), text: parts.length > 0 ? parts.join(t("pet.about.listSep")) : t("pet.about.voice.none") });
+
+				/*
+				 * Random mode, described on its own rather than as a clause inside the controls line.
+				 *
+				 * It is the one thing in this panel that changes BEHAVIOUR rather than reporting what the character has, so
+				 * it needs three facts the controls line could not carry: where it lives, what the three scopes do, and that
+				 * it is silent. The last one is the non-obvious part — a user who turns it on and hears nothing would
+				 * otherwise read that as a fault.
+				 *
+				 * The CURRENT state is appended while it is on, so the panel also answers "why is she doing that", which is
+				 * the question someone actually opens this for.
+				 */
+				const scopeNow = snapshot?.layout?.randomModeScope ?? "both";
+				const scopeLabel = scopeNow === "motion" ? t("pet.menu.randomMotion")
+					: scopeNow === "expression" ? t("pet.menu.randomExpression")
+						: t("pet.menu.randomBoth");
+				const randomOn = snapshot?.layout?.randomModeEnabled === true;
+				rows.push({
+					head: t("pet.about.random"),
+					text: `${t("pet.about.random.text")}${randomOn ? t("pet.about.random.now", { scope: scopeLabel }) : ""}`
+				});
+
+				// Interactions worth knowing about, which are the same for every character.
+				rows.push({ head: t("pet.about.how"), text: t("pet.about.how.text") });
+				return rows;
+			}
+
 			/** Apply a snapshot's layout to the DOM (position + size + framing). */
 			applyLayout() {
 				const layout = this.snapshot?.layout;
@@ -4651,6 +4936,16 @@ window.__ModuleLoader__.load({
 				 */
 				this.stage?.setBlinkEnabled(layout.blink !== false);
 				this.stage?.setGazeEnabled(layout.gaze !== false);
+				// Pushed like the two above. Read by the drift, so it must be current before the next idle slot.
+				this.stage?.setRandomMode(layout.randomModeEnabled === true);
+				this.stage?.setRandomScope(layout.randomModeScope);
+				/*
+				 * Re-pushed on every layout pass, not only at construction, because the pool is per CHARACTER: switching from
+				 * 由乃 to 都子 swaps the expression names, and a stale pool would have random mode drawing faces the new model
+				 * does not have. `playExpression` refuses an unknown name, so the symptom would be a face that silently stops
+				 * changing rather than an error.
+				 */
+				this.stage?.setExpressionPool(this.randomFacePool());
 				/*
 				 * Voice level.
 				 *
@@ -5018,6 +5313,14 @@ window.__ModuleLoader__.load({
 						// respects them; later changes go through the setters in applyLayout.
 						blink: this.snapshot?.layout?.blink,
 						gaze: this.snapshot?.layout?.gaze,
+						randomMode: this.snapshot?.layout?.randomModeEnabled,
+						randomScope: this.snapshot?.layout?.randomModeScope,
+						/*
+						 * The pool random mode draws faces from, pushed in because the stage cannot derive it — the loaded
+						 * `Live2DModel` exposes no expression list, so the only source of names is the host's snapshot.
+						 * Filtered here rather than in the stage, because the exclusion set is per-character content.
+						 */
+						expressionPool: this.randomFacePool(),
 						/*
 						 * The drift decides WHICH line a slot gets — a 丸君 pose's own clip, or a
 						 * chance of an occasional line — and hands over the resolved file name. The
@@ -6612,15 +6915,21 @@ window.__ModuleLoader__.load({
 					menu.appendChild(button);
 				};
 
-				/** Header for a second level, with its Back button. */
-				const header = (title) => {
+				/**
+				 * Header for a second level, with its Back button.
+				 *
+				 * @param title - the level's name.
+				 * @param backTo - the level the Back button returns to. Defaults to the root, which is where every second
+				 *   level is reached from; only a THIRD level has to say otherwise, and 「功能简介」 under 设置 is one.
+				 */
+				const header = (title, backTo = "root") => {
 					const head = document.createElement("div");
 					head.className = "dsh-l2d-menu-head";
 					const back = document.createElement("button");
 					back.type = "button";
 					back.className = "dsh-l2d-menu-back";
 					back.textContent = t("pet.menu.back");
-					back.addEventListener("click", () => this.renderMenuView("root"));
+					back.addEventListener("click", () => this.renderMenuView(backTo));
 					const label = document.createElement("div");
 					label.className = "dsh-l2d-menu-title";
 					label.textContent = title;
@@ -6672,6 +6981,55 @@ window.__ModuleLoader__.load({
 							// as well as mapping the identifier to readable copy.
 							item(expressionLabel(expression), () => this.stage?.playExpression(expression, { user: true }));
 						}
+					} else if (view === "random") {
+						header(t("pet.menu.title.random"));
+						/** Write one layout key and re-render, so the ticks track the state. */
+						const write = (patch) => {
+							API.layout(patch).then((result) => {
+								if (this.destroyed || !result.ok) return;
+								this.snapshot = { ...this.snapshot, layout: result.layout };
+								this.applyLayout();
+								this.refreshMenu("random");
+							}, () => {});
+						};
+						const on = this.snapshot.layout?.randomModeEnabled === true;
+						const scope = this.snapshot.layout?.randomModeScope ?? "both";
+						item(`${on ? "\u2713 " : "\u3000"}${t("pet.menu.randomModeOn")}`, () => write({ randomModeEnabled: !on }));
+						menu.appendChild(document.createElement("hr"));
+						/*
+						 * The three scopes, each a radio-style tick.
+						 *
+						 * A heading rather than nothing, because the three rows are meaningless without knowing they choose
+						 * WHAT is randomised rather than whether it is — and the ticks stay visible while the mode is off, so
+						 * the scope can be set before switching it on.
+						 */
+						const head = document.createElement("div");
+						head.className = "dsh-l2d-menu-title";
+						head.textContent = t("pet.menu.randomScope");
+						menu.appendChild(head);
+						for (const [key, label] of [["motion", t("pet.menu.randomMotion")], ["expression", t("pet.menu.randomExpression")], ["both", t("pet.menu.randomBoth")]]) {
+							item(`${scope === key ? "\u2713 " : "\u3000"}${label}`, () => write({ randomModeScope: key }));
+						}
+					} else if (view === "about") {
+						/*
+						 * The ONE third level: reached from 设置, so Back returns there rather than to the root.
+						 *
+						 * Read-only, so it is drawn as text rather than as buttons — a row that looks pressable and does
+						 * nothing is worse than plain copy. Each row is a heading plus a sentence, the same shape the
+						 * settings headings use.
+						 */
+						header(t("pet.menu.title.about"), "settings");
+						const intro = this.characterIntro();
+						if (intro.length === 0) menu.appendChild(this.menuEmpty());
+						for (const row of intro) {
+							const head = document.createElement("div");
+							head.className = "dsh-l2d-menu-title";
+							head.textContent = row.head;
+							const body = document.createElement("div");
+							body.className = "dsh-l2d-menu-text";
+							body.textContent = row.text;
+							menu.append(head, body);
+						}
 					} else if (view === "characters") {
 						/*
 						 * One row per CHARACTER, not per model.
@@ -6818,7 +7176,7 @@ window.__ModuleLoader__.load({
 								// Apply straight away rather than waiting for the next poll, so the
 								// boundary appears the moment it is switched on.
 								this.applyLayout();
-								this.renderMenuView("settings");
+								this.refreshMenu("settings");
 							}, () => {});
 						});
 						// Blink and gaze. Both re-render the submenu so the ticks track the state.
@@ -6828,7 +7186,7 @@ window.__ModuleLoader__.load({
 								if (this.destroyed || !result.ok) return;
 								this.snapshot = { ...this.snapshot, layout: result.layout };
 								this.applyLayout();
-								this.renderMenuView("settings");
+								this.refreshMenu("settings");
 							}, () => {});
 						});
 						const gaze = this.snapshot.layout?.gaze !== false;
@@ -6837,9 +7195,16 @@ window.__ModuleLoader__.load({
 								if (this.destroyed || !result.ok) return;
 								this.snapshot = { ...this.snapshot, layout: result.layout };
 								this.applyLayout();
-								this.renderMenuView("settings");
+								this.refreshMenu("settings");
 							}, () => {});
 						});
+						/*
+						 * Random mode opens a level rather than toggling, because it has TWO decisions: whether it is on, and
+						 * what it randomises. A single checkbox could only express the first.
+						 */
+						submenu(`${this.snapshot.layout?.randomModeEnabled === true ? "\u2713 " : "\u3000"}${t("pet.menu.randomMode")}`, "random");
+						// A read-only description of whoever is on screen. @see characterIntro
+						submenu(t("pet.menu.about"), "about");
 						// Opens a submenu rather than toggling, so the current level is visible at a glance.
 						submenu(t("pet.menu.volume"), "volume");
 					} else {
@@ -6944,6 +7309,28 @@ window.__ModuleLoader__.load({
 				this.menuAnchor = null;
 			}
 
+			/**
+			 * Re-render the open menu, if a menu is still open.
+			 *
+			 * Necessary because `closeMenu` sets `renderMenuView` to `undefined`, and a menu row closes the menu as part of
+			 * its own click — `item` runs the action and then closes. So an action that REDRAWS to show a new tick does so
+			 * from an asynchronous callback that fires AFTER the close, where the method no longer exists:
+			 *
+			 *     TypeError: this.renderMenuView is not a function
+			 *
+			 * It was thrown by the layout toggles and swallowed by their empty rejection handler, so the ticks simply never
+			 * updated and nothing was reported. Guarded here rather than at each call site, because whether a menu is still
+			 * open is this method's own precondition.
+			 *
+			 * @param view - the level to draw.
+			 * @returns true when it was drawn.
+			 */
+			refreshMenu(view) {
+				if (this.menu === null || typeof this.renderMenuView !== "function") return false;
+				this.renderMenuView(view);
+				return true;
+			}
+
 			onDocumentPointerDown(event) {
 				if (this.menu !== null && !this.menu.contains(event.target)) this.closeMenu();
 			}

package/lib/index.js

@@ -589,6 +589,13 @@ export const Config = z.object({
 	showFrame: z.boolean().description("显示取景框边界（虚线，仅作视觉参考，不影响拖动与缩放）。"),
 	blink: z.boolean().description("自动眨眼。"),
 	gaze: z.boolean().description("视线与头部追随鼠标。"),
+	randomModeEnabled: z.boolean()
+		.description("随机模式：待机时按下面选择的范围随机播放。仅待机状态生效。"),
+	randomModeScope: z.union([
+		z.const("motion").description("随机动作（表情保持不变）"),
+		z.const("expression").description("随机表情（动作照常）"),
+		z.const("both").description("随机动作＋表情")
+	]).description("随机模式随机的内容。"),
 	voiceVolume: z.number().step(0.1).min(LAYOUT_LIMITS.voiceVolume.min).max(LAYOUT_LIMITS.voiceVolume.max)
 		.description("语音音量，0 为静音（也可在桌宠菜单的「设置 → 语音音量」里调整）。"),
 	name: z.string().min(1).max(24).description("桌宠显示名。")

package/lib/persist.js

@@ -18,6 +18,15 @@ export const CROP_PRESETS = ["full", "threeQuarter", "bust"];
 /** Default framing: the whole character, so nothing is ever cut off. */
 export const DEFAULT_CROP = "full";
 
+/**
+ * What random mode randomises on each idle slot.
+ *
+ * `motion` and `expression` are the two halves the drift can draw from; `both` pairs a fresh one of each. Kept as a closed
+ * list because the value is persisted and arrives from the client, so an unknown string has to be rejected in one place —
+ * @see normalizeLayout.
+ */
+export const RANDOM_MODE_SCOPES = ["motion", "expression", "both"];
+
 /**
  * Layout defaults.
  *
@@ -56,6 +65,24 @@ export const DEFAULT_LAYOUT = {
 	blink: true,
 	/** Eyes and head follow the pointer anywhere on screen. */
 	gaze: true,
+	/**
+	 * Random mode: the idle drift draws its motion and/or its expression at random instead of following the pool alone.
+	 *
+	 * OFF by default, and deliberately so. The drift normally animates the BODY ONLY — her face changes only when one is
+	 * chosen from the menu — because a face that changes on its own overwrites the user's pick. That is still the right
+	 * default, so this is an opt-in mode rather than a change to the drift itself.
+	 *
+	 * While a face-randomising scope is active, a manual pick lasts only until the next slot. That is the point of the mode
+	 * rather than a defect of it — and `resetExpression` still restores the resting face on demand.
+	 */
+	randomModeEnabled: false,
+	/**
+	 * What random mode randomises. @see RANDOM_MODE_SCOPES
+	 *
+	 * Its own field rather than one enum with an "off" member, because the two are separate decisions: turning the mode off
+	 * and later on again should restore the scope that was chosen before, not reset it to a default.
+	 */
+	randomModeScope: "both",
 	/**
 	 * Playback volume for every spoken clip, 0..1.
 	 *
@@ -177,6 +204,10 @@ export function normalizeLayout(patch, base = DEFAULT_LAYOUT) {
 		showFrame: typeof raw.showFrame === "boolean" ? raw.showFrame : base.showFrame,
 		blink: typeof raw.blink === "boolean" ? raw.blink : base.blink,
 		gaze: typeof raw.gaze === "boolean" ? raw.gaze : base.gaze,
+		randomModeEnabled: typeof raw.randomModeEnabled === "boolean" ? raw.randomModeEnabled : base.randomModeEnabled,
+		// An unknown scope degrades to the previous one, matching how `crop` is handled: the value reaches the drift, and an
+		// unrecognised string there would silently match no branch and leave the mode doing nothing.
+		randomModeScope: RANDOM_MODE_SCOPES.includes(raw.randomModeScope) ? raw.randomModeScope : base.randomModeScope,
 		voiceVolume: clampNumber(raw.voiceVolume, base.voiceVolume, LAYOUT_LIMITS.voiceVolume.min, LAYOUT_LIMITS.voiceVolume.max)
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-pet-live2d-viola",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Live2D desktop pet for the DeepSeek Harness web GUI. One pet, three characters: 都子 (miyako_014_casual_spring_01_marukun), 薇欧拉 in casual or school uniform, and 由乃 in casual clothes or her virtual-avatar outfit — each with its own motions, expressions, voice lines, captions, idle drift, click reactions and goodbye.",
   "type": "module",
   "main": "lib/index.js",