koishi-plugin-wordle-game 4.2.1 → 4.4.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 4.4.0 · 2026-10-02
+
+修复未启用 help 插件时发送 `wordle` 会让指令无限调用自己、Koishi 收不到任何消息的问题。主指令现在自带帮助：按常用顺序列出各子指令并提示如何开局，不再依赖 help 插件；带 `-h` 时仍由 help 插件接手。发送 `wordle` 不再顺带登记玩家名（首次游玩时照常登记）。
+
+# 4.3.0 · 2026-09-26
+
+无前缀猜测只接手确定有效的猜测（在词库中、未猜过），其余静默放行；汉兜提示色改为清晰的绿 / 琥珀，下划线对齐拼音；模式清单上下留白对称。 主指令在 help 列表里补回描述；去掉「.显示」显示模式指令，有图只发图、出图失败才退回文字；多轮输入不再追加计时说明。
+
 # 4.2.0 · 2026-09-26
 
 M3 明暗棋盘与非颜色状态符号；棋盘文字替代；多轮输入可延长；修复模式编号越界及并发锁被错误释放，渲染失败不阻断对局。

package/DESIGN_SYSTEM.md

@@ -13,12 +13,12 @@
 
 ## 输出、交互与内容
 
-1. 图文模式只发渲染图，不附文字；完整文字只在用户切到「文字」模式时出现。图片的等价文字随图片标记，切换到文字模式时展开，因此不会在群里重复刷屏。
-2. `插件主指令.显示 文字` / `插件主指令.显示 图文` 切换个人显示偏好；同一机器人中的这些插件共享选择。设置保存在内存，重启恢复图文。文本回复不能把后续条目无提示地压掉；较长管理列表分页。
+1. 有渲染图时只发图片，不附同内容的文字，避免在群里重复刷屏；图片生成失败时才退回文字。插件不提供个人显示模式开关。
+2. 每个插件的主指令都带描述，`help` 列表右侧不留空；主指令先于任何子指令注册（Koishi 会忽略已存在指令的描述）。文本回复不能把后续条目无提示地压掉；较长管理列表分页。
 3. 裸输入必须符合词法、对局状态及参与条件。多个插件匹配时不执行，要求明确完整指令；完整指令继续可用。
 4. 回复说明当前结果、未完成原因和可执行的下一步，不用管理员日志替代用户可用的反馈。退款、赔付与渲染失败不能伪装成功。
 5. 破坏性清空需展示范围、不可撤销性和限时确认码。确认码限制到同一机器人、平台、用户与频道，使用后立即失效。
-6. 多轮输入允许 5 分钟等待，发送「延长」重新计时，发送「取消」退出。斗牛、21 点提供延长等待入口。文字模式不主动撤回已发出的说明。
+6. 多轮输入等待 5 分钟，提问里写明可回复的内容与「取消」，不再追加计时说明。对局内的短窗口（如 21 点保险、投降）提供显式跳过，全员表态后立即进入下一阶段，而不是提供「延长」。
 7. 货币发放先写入核对记录，入账结果不明确时保留待核对状态，不自动重发。管理员核对实际流水并按需人工补发后标记确认；确认操作自身不转账。
 
 ## 内容边界
@@ -44,7 +44,7 @@ node markdown-to-image-service/scripts/sync-design-system.mjs --check
 
 官方色彩算法可在源仓库安装开发依赖后通过 `node scripts/build-material-colors.mjs` 重建，再同步消费者。
 
-回归检查覆盖：24 个源色相的明暗角色对比度、奖牌前景、图表填充/轨道差异、浏览器/服务端 HCT 一致性、文字输出与身份隔离、输入冲突、可延长输入、入账异常、清空确认和 Wordle 并发/渲染失败。工作区截图脚本为 `scripts/verify-rendering.ts`，需 Puppeteer Core 和可用 Chromium。
+回归检查覆盖：24 个源色相的明暗角色对比度、奖牌前景、图表填充/轨道差异、浏览器/服务端 HCT 一致性、主指令描述、输入冲突、入账异常、清空确认和 Wordle 并发/渲染失败。工作区截图脚本为 `scripts/verify-rendering.ts`，需 Puppeteer Core 和可用 Chromium。
 
 ## 本轮改动对应关系
 
@@ -53,9 +53,9 @@ node markdown-to-image-service/scripts/sync-design-system.mjs --check
 | 共享设计规范 | 官方 HCT、2025 动态颜色角色、共享字阶与间距、同步与哈希校验 |
 | Markdown | M3 明暗主题；旧主题名按明暗迁移；代码高亮与 Mermaid 使用 M3 角色；长代码可换行 |
 | message-counter / monetary-rank | M3 角色与共享图表字阶、HCT 头像配色、完整文字榜单；保留昵称截断 |
-| Wordle | 替换复制的 NYT 外观；状态符号与图例；明暗角色；文字棋盘；异常释放并发锁；安全解析模式编号 |
-| MCDLE | 历史猜测完整文字属性；两列属性卡减少超宽表格 |
+| Wordle | 替换复制的 NYT 外观；状态符号与图例；明暗角色；异常释放并发锁；安全解析模式编号；裸词只在确定是猜测时回应 |
+| MCDLE | 猜测按行排成一张表，方便逐项对照；单句页脚居中 |
 | 2048 / ciyi | 数字与奖牌前景按实际对比度选色 |
-| 斗牛 / 21 点 | 付款核对记录、如实反馈退款失败、明确下注金额、延长操作窗口 |
+| 斗牛 / 21 点 | 付款核对记录、如实反馈退款失败、明确下注金额、可显式跳过的短窗口 |
 | sentinel | 完整封印列表按每页 10 位展示 |
-| 其余插件 | 图文双通道、个人文字模式、可取消/延长输入与上下文反馈 |
+| 其余插件 | 渲染失败退回文字、可取消输入与上下文反馈 |

package/README.md

@@ -1,19 +1,25 @@
 # 猜单词
 
-Koishi 猜词插件，包含多种词库和游戏模式。
+Koishi 插件：猜词游戏，支持单词、成语、数字与方程式等多种模式
+
+[![GitHub](https://img.shields.io/badge/GitHub-araea%2Fkoishi--plugin--wordle--game-181717?logo=github&logoColor=white)](https://github.com/araea/koishi-plugin-wordle-game)
+[![npm](https://img.shields.io/npm/v/koishi-plugin-wordle-game?logo=npm&logoColor=white&color=CB3837)](https://www.npmjs.com/package/koishi-plugin-wordle-game)
 
 ## 安装
 
 ```sh
-yarn add koishi-plugin-wordle-game
+npm i koishi-plugin-wordle-game
 ```
 
-在 Koishi 中启用，并安装 `database` 与 `puppeteer` 服务。
+启用插件，并安装 `database` 与 `puppeteer` 服务。
+
+## 快速使用
 
-## 指令
+发送 `wordle.开始` 选择模式开局，之后直接发送猜测词即可续猜（默认开启 `enableDirectInput`）。
 
 | 指令 | 说明 |
 | --- | --- |
+| `wordle` | 查看指令列表 |
 | `wordle.开始 [长度]` | 开始模式选择 |
 | `wordle.开始.<模式> [长度]` | 指定模式开局 |
 | `wordle.猜 <内容>` | 提交猜测 |
@@ -26,14 +32,35 @@ yarn add koishi-plugin-wordle-game
 | `wordle.拼音速查表` | 查看拼音速查表 |
 | `wordle.玩法介绍` | 查看玩法 |
 
-模式包括经典、汉兜、词影、Numberle、Math 和 Lewdle 等。部分模式支持 `--hard`、`--uhard`、`--absurd`、`--challenge`、`--wordles`、`--free` 和 `--all` 选项。
+模式包括经典、汉兜、词影、Numberle、Math 与 Lewdle 等。部分模式支持 `--hard`、`--uhard`、`--absurd`、`--challenge`、`--wordles`、`--free` 和 `--all` 选项。
+
+## 配置
+
+| 配置项 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `isDarkThemeEnabled` | boolean | `false` | 使用黑暗主题 |
+| `isHighContrastThemeEnabled` | boolean | `false` | 使用高对比度主题，为色觉障碍准备 |
+| `compositeImagePageWidth` | number | `800` | 多词合成图的页面宽度（像素） |
+| `compositeImagePageHeight` | number | `100` | 多词合成图的页面高度（像素） |
+| `maxSimultaneousGuesses` | number | `4` | 同时猜测的单词数量上限 |
+| `defaultMaxLeaderboardEntries` | number | `10` | 排行榜默认显示的人数 |
+| `defaultWordLengthForGuessing` | number | `5` | 非经典模式下默认的猜测长度 |
+| `enableDirectInput` | boolean | `true` | 对局中直接发送猜测词即可续猜 |
+| `isPreventUserDuplicateGuessInput` | boolean | `true` | 拦截重复提交的猜测词 |
+| `shouldPromptWordLengthInput` | boolean | `true` | 引导式开局时追问一次单词长度 |
+| `shouldPromptForWordLengthOnNonClassicStart` | boolean | `true` | 非经典模式开局时追问一次单词长度 |
+| `enableWordGuessTimeLimit` | boolean | `false` | 给每次作答加上时间限制 |
+| `wordGuessTimeLimitInSeconds` | number | `120` | 每次作答的时间限制（秒） |
+| `retractDelay` | number | `0` | 自动撤回延迟（秒），0 表示不撤回 |
+| `imageType` | `png` / `jpeg` / `webp` | `png` | 发送的图片格式 |
 
-## 许可证
+## 限制 / 风险
 
-可按 [Apache-2.0](LICENSE-APACHE) 或 [MIT](LICENSE-MIT) 使用。
+需要 `database` 服务保存战绩，以及 `puppeteer` 服务渲染图片。
 
-## 显示与交互
+`wordle.查成语` 依赖外部汉典数据，拼音查询依赖配置的拼音 API。
 
-发送 `wordle.显示 文字` 或 `wordle.显示 图文` 切换个人显示偏好。同一机器人中的配套插件共享选择，重启后恢复图文。图文模式中的信息图片附带文字说明；作品素材与感官测试的适用边界见 [设计系统](./DESIGN_SYSTEM.md)。
+## 必要链接
 
-本次更新：M3 明暗棋盘与非颜色状态符号；棋盘文字替代；多轮输入可延长；修复模式编号越界及并发锁被错误释放，渲染失败不阻断对局。
+- [设计系统](DESIGN_SYSTEM.md)
+- [MIT](LICENSE-MIT) / [Apache-2.0](LICENSE-APACHE)

package/lib/config.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "koishi";
-export declare const usage = "## \u4F7F\u7528\n\n\u53D1\u9001 `wordle.\u5F00\u59CB` \u5F00\u5C40\uFF0C\u4E4B\u540E\u76F4\u63A5\u53D1\u9001\u731C\u6D4B\u8BCD\u5373\u53EF\u3002\n\n## \u6307\u4EE4\n\n| \u6307\u4EE4 | \u8BF4\u660E |\n| --- | --- |\n| `wordle.\u5F00\u59CB [\u957F\u5EA6]` | \u5F15\u5BFC\u5F0F\u5F00\u5C40 |\n| `wordle.\u5F00\u59CB.<\u6A21\u5F0F> [\u957F\u5EA6]` | \u6307\u5B9A\u6A21\u5F0F\u5F00\u5C40 |\n| `wordle.\u731C <\u5185\u5BB9>` | \u63D0\u4EA4\u731C\u6D4B |\n| `wordle.\u67E5\u8BE2\u8FDB\u5EA6` | \u67E5\u770B\u5F53\u524D\u5BF9\u5C40\u8FDB\u5EA6 |\n| `wordle.\u7ED3\u675F` | \u7ED3\u675F\u5F53\u524D\u5BF9\u5C40 |\n| `wordle.\u6392\u884C\u699C [\u4EBA\u6570]` | \u67E5\u770B\u6392\u884C\u699C |\n| `wordle.\u6218\u7EE9 [@\u67D0\u4EBA]` | \u67E5\u8BE2\u73A9\u5BB6\u6218\u7EE9 |\n| `wordle.\u67E5\u5355\u8BCD <\u8BCD>` | \u5F15\u5BFC\u5F0F\u67E5\u5355\u8BCD |\n| `wordle.\u67E5\u6210\u8BED <\u6210\u8BED>` | \u67E5\u8BE2\u6210\u8BED\u7684\u62FC\u97F3\u4E0E\u89E3\u91CA\uFF08\u6C49\u5178\uFF09 |\n| `wordle.\u62FC\u97F3\u901F\u67E5\u8868` | \u67E5\u770B\u62FC\u97F3\u901F\u67E5\u8868 |\n| `wordle.\u73A9\u6CD5\u4ECB\u7ECD` | \u67E5\u770B\u73A9\u6CD5\u4ECB\u7ECD |\n\n\u6A21\u5F0F\u5305\u62EC\u7ECF\u5178\u3001\u6C49\u515C\u3001\u8BCD\u5F71\u3001Numberle\u3001Math\u3001Lewdle \u53CA\u5176\u4ED6\u8BCD\u5E93\u3002\n\n\u53EF\u7528\u9009\u9879\uFF1A`--hard`\u3001`--uhard`\u3001`--absurd`\u3001`--challenge`\u3001`--wordles`\u3001`--free`\u3001`--all`\u3002";
+export declare const usage = "## \u4F7F\u7528\n\n\u53D1\u9001 `wordle.\u5F00\u59CB` \u5F00\u5C40\uFF0C\u4E4B\u540E\u76F4\u63A5\u53D1\u9001\u731C\u6D4B\u8BCD\u5373\u53EF\u3002\n\n## \u6307\u4EE4\n\n| \u6307\u4EE4 | \u8BF4\u660E |\n| --- | --- |\n| `wordle` | \u67E5\u770B\u6307\u4EE4\u5217\u8868 |\n| `wordle.\u5F00\u59CB [\u957F\u5EA6]` | \u5F00\u59CB\u6A21\u5F0F\u9009\u62E9 |\n| `wordle.\u5F00\u59CB.<\u6A21\u5F0F> [\u957F\u5EA6]` | \u6307\u5B9A\u6A21\u5F0F\u5F00\u5C40 |\n| `wordle.\u731C <\u5185\u5BB9>` | \u63D0\u4EA4\u731C\u6D4B |\n| `wordle.\u67E5\u8BE2\u8FDB\u5EA6` | \u67E5\u770B\u5F53\u524D\u8FDB\u5EA6 |\n| `wordle.\u7ED3\u675F` | \u7ED3\u675F\u6E38\u620F |\n| `wordle.\u6392\u884C\u699C [\u4EBA\u6570]` | \u67E5\u770B\u6392\u884C\u699C |\n| `wordle.\u6218\u7EE9 [@\u67D0\u4EBA]` | \u67E5\u8BE2\u73A9\u5BB6\u8BB0\u5F55 |\n| `wordle.\u67E5\u5355\u8BCD <\u8BCD>` | \u67E5\u8BE2\u5355\u8BCD\u5E76\u5F00\u59CB\u5F15\u5BFC |\n| `wordle.\u67E5\u6210\u8BED <\u6210\u8BED>` | \u67E5\u8BE2\u62FC\u97F3\u548C\u91CA\u4E49\uFF08\u6C49\u5178\uFF09 |\n| `wordle.\u62FC\u97F3\u901F\u67E5\u8868` | \u67E5\u770B\u62FC\u97F3\u901F\u67E5\u8868 |\n| `wordle.\u73A9\u6CD5\u4ECB\u7ECD` | \u67E5\u770B\u73A9\u6CD5 |\n\n\u6A21\u5F0F\u5305\u62EC\u7ECF\u5178\u3001\u6C49\u515C\u3001\u8BCD\u5F71\u3001Numberle\u3001Math \u548C Lewdle \u7B49\u3002\u90E8\u5206\u6A21\u5F0F\u652F\u6301 `--hard`\u3001`--uhard`\u3001`--absurd`\u3001`--challenge`\u3001`--wordles`\u3001`--free` \u548C `--all` \u9009\u9879\u3002";
 export interface Config {
     isDarkThemeEnabled: boolean;
     isHighContrastThemeEnabled: boolean;

package/lib/help.d.ts

@@ -0,0 +1,14 @@
+import { Session } from 'koishi';
+export interface HelpEntry {
+    name: string;
+    description: string;
+}
+/**
+ * 主指令帮助的内容：从已注册的指令树现取标题与直接子指令，不依赖 help 插件，也不会和指令脱节。
+ * `order` 列出希望靠前的子指令（完整指令名），没列到的按注册顺序排在后面；排版交给各插件。
+ * 不要在动作里 `session.execute('… -h')` 转发：`-h` 由 help 插件提供，缺它指令会无限调用自己。
+ */
+export declare function helpOf(session: Session, name: string, order?: string[]): {
+    title: string;
+    entries: HelpEntry[];
+};

package/lib/index.js

@@ -37,113 +37,11 @@ __export(src_exports, {
   usage: () => usage
 });
 module.exports = __toCommonJS(src_exports);
-
-// src/ux.ts
-var import_koishi = require("koishi");
-var KEY = Symbol.for("araea.koishi.ux.v1");
-function state(ctx) {
-  const root2 = ctx.root;
-  return root2[KEY] ??= { modes: /* @__PURE__ */ new Map(), owners: /* @__PURE__ */ new Set() };
-}
-__name(state, "state");
-var userKey = /* @__PURE__ */ __name((session) => `${session.platform}:${session.selfId}:${session.userId}`, "userKey");
-function usePresentation(ctx, command) {
-  const shared = state(ctx);
-  ctx.command(`${command}.显示 [mode:string]`, "选择图文或文字输出").action(({ session }, mode) => {
-    if (!mode) return `当前：${shared.modes.get(userKey(session)) ? "文字" : "图文"}。发送「${command}.显示 文字」或「${command}.显示 图文」。设置对本机器人各插件生效，重启后恢复图文。`;
-    if (!["文字", "图文"].includes(mode)) return "请选择「文字」或「图文」。";
-    shared.modes.set(userKey(session), mode === "文字");
-    return `已切换为${mode}输出。`;
-  });
-  return {
-    textOnly: /* @__PURE__ */ __name((session) => shared.modes.get(userKey(session)) === true, "textOnly"),
-    /** 图文模式只给图片；图片缺失或用户选了文字模式时才退回文字。 */
-    present(session, image, text) {
-      if (!image || shared.modes.get(userKey(session))) return text;
-      return import_koishi.h.normalize(image);
-    }
-  };
-}
-__name(usePresentation, "usePresentation");
-function registerDirectInput(ctx, name2, matches) {
-  const owner = { name: name2, matches };
-  state(ctx).owners.add(owner);
-  ctx.on("dispose", () => {
-    state(ctx).owners.delete(owner);
-  });
-}
-__name(registerDirectInput, "registerDirectInput");
-async function directInputConflict(ctx, session) {
-  if (session.event.user?.isBot) return true;
-  const owners = [];
-  for (const owner of state(ctx).owners) {
-    try {
-      if (await owner.matches(session)) owners.push(owner.name);
-    } catch {
-    }
-  }
-  if (owners.length < 2) return false;
-  await session.send(`这条消息同时适用于 ${owners.join("、")}，尚未执行。请使用对应游戏的完整指令。`);
-  return true;
-}
-__name(directInputConflict, "directInputConflict");
-async function promptInput(session, instruction) {
-  for (; ; ) {
-    await session.send(`${instruction}
-请在 5 分钟内回复；发送「延长」重新计时，发送「取消」退出。`);
-    const input = await session.prompt(3e5);
-    if (input?.trim() === "延长") continue;
-    return input;
-  }
-}
-__name(promptInput, "promptInput");
-var IMAGE_TEXT_TYPE = "ux-image-text";
-function imageText(text) {
-  return (0, import_koishi.h)(IMAGE_TEXT_TYPE, {}, import_koishi.h.normalize(text));
-}
-__name(imageText, "imageText");
-function isImage(element) {
-  return element.type === "img" || element.type === "image";
-}
-__name(isImage, "isImage");
-function isImageText(element) {
-  return element.type === IMAGE_TEXT_TYPE;
-}
-__name(isImageText, "isImageText");
-function imagesOnly(content) {
-  const walk = /* @__PURE__ */ __name((elements) => elements.flatMap((element) => {
-    if (isImageText(element)) return [];
-    if (isImage(element) || !element.children.length) return [element];
-    return [(0, import_koishi.h)(element.type, element.attrs, walk(element.children))];
-  }), "walk");
-  return walk(import_koishi.h.normalize(content));
-}
-__name(imagesOnly, "imagesOnly");
-function withoutImages(content) {
-  const walk = /* @__PURE__ */ __name((elements) => elements.flatMap((element) => {
-    if (isImage(element)) return [];
-    if (isImageText(element)) return walk(element.children);
-    if (element.children.length) return [(0, import_koishi.h)(element.type, element.attrs, walk(element.children))];
-    return [element];
-  }), "walk");
-  return walk(import_koishi.h.normalize(content));
-}
-__name(withoutImages, "withoutImages");
-function choosePresentation(content, textOnly) {
-  return textOnly ? withoutImages(content) : imagesOnly(content);
-}
-__name(choosePresentation, "choosePresentation");
-function isTextOnly(ctx, session) {
-  return state(ctx).modes.get(userKey(session)) === true;
-}
-__name(isTextOnly, "isTextOnly");
-
-// src/index.ts
 var fs6 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 
 // src/config.ts
-var import_koishi2 = require("koishi");
+var import_koishi = require("koishi");
 var usage = `## 使用
 
 发送 \`wordle.开始\` 开局，之后直接发送猜测词即可。
@@ -152,59 +50,58 @@ var usage = `## 使用
 
 | 指令 | 说明 |
 | --- | --- |
-| \`wordle.开始 [长度]\` | 引导式开局 |
+| \`wordle\` | 查看指令列表 |
+| \`wordle.开始 [长度]\` | 开始模式选择 |
 | \`wordle.开始.<模式> [长度]\` | 指定模式开局 |
 | \`wordle.猜 <内容>\` | 提交猜测 |
-| \`wordle.查询进度\` | 查看当前对局进度 |
-| \`wordle.结束\` | 结束当前对局 |
+| \`wordle.查询进度\` | 查看当前进度 |
+| \`wordle.结束\` | 结束游戏 |
 | \`wordle.排行榜 [人数]\` | 查看排行榜 |
-| \`wordle.战绩 [@某人]\` | 查询玩家战绩 |
-| \`wordle.查单词 <词>\` | 引导式查单词 |
-| \`wordle.查成语 <成语>\` | 查询成语的拼音与解释（汉典） |
+| \`wordle.战绩 [@某人]\` | 查询玩家记录 |
+| \`wordle.查单词 <词>\` | 查询单词并开始引导 |
+| \`wordle.查成语 <成语>\` | 查询拼音和释义（汉典） |
 | \`wordle.拼音速查表\` | 查看拼音速查表 |
-| \`wordle.玩法介绍\` | 查看玩法介绍 |
+| \`wordle.玩法介绍\` | 查看玩法 |
 
-模式包括经典、汉兜、词影、Numberle、Math、Lewdle 及其他词库。
-
-可用选项：\`--hard\`、\`--uhard\`、\`--absurd\`、\`--challenge\`、\`--wordles\`、\`--free\`、\`--all\`。`;
-var Config = import_koishi2.Schema.intersect([
-  import_koishi2.Schema.object({
-    isDarkThemeEnabled: import_koishi2.Schema.boolean().default(false).description(`使用黑暗主题。`),
-    isHighContrastThemeEnabled: import_koishi2.Schema.boolean().default(false).description(`使用高对比度主题，为色觉障碍准备。`)
+模式包括经典、汉兜、词影、Numberle、Math 和 Lewdle 等。部分模式支持 \`--hard\`、\`--uhard\`、\`--absurd\`、\`--challenge\`、\`--wordles\`、\`--free\` 和 \`--all\` 选项。`;
+var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    isDarkThemeEnabled: import_koishi.Schema.boolean().default(false).description(`使用黑暗主题。`),
+    isHighContrastThemeEnabled: import_koishi.Schema.boolean().default(false).description(`使用高对比度主题，为色觉障碍准备。`)
   }).description("主题设置"),
-  import_koishi2.Schema.object({
-    compositeImagePageWidth: import_koishi2.Schema.number().min(1).default(800).description(`多词合成图的页面宽度（像素）。`),
-    compositeImagePageHeight: import_koishi2.Schema.number().min(1).default(100).description(`多词合成图的页面高度（像素）。`),
-    maxSimultaneousGuesses: import_koishi2.Schema.number().min(1).default(4).description(`同时猜测的单词数量上限。`),
-    defaultMaxLeaderboardEntries: import_koishi2.Schema.number().min(0).default(10).description(`排行榜默认显示的人数。`),
-    defaultWordLengthForGuessing: import_koishi2.Schema.number().min(1).default(5).description(`非经典模式下默认的猜测长度。`)
+  import_koishi.Schema.object({
+    compositeImagePageWidth: import_koishi.Schema.number().min(1).default(800).description(`多词合成图的页面宽度（像素）。`),
+    compositeImagePageHeight: import_koishi.Schema.number().min(1).default(100).description(`多词合成图的页面高度（像素）。`),
+    maxSimultaneousGuesses: import_koishi.Schema.number().min(1).default(4).description(`同时猜测的单词数量上限。`),
+    defaultMaxLeaderboardEntries: import_koishi.Schema.number().min(0).default(10).description(`排行榜默认显示的人数。`),
+    defaultWordLengthForGuessing: import_koishi.Schema.number().min(1).default(5).description(`非经典模式下默认的猜测长度。`)
   }).description("游戏设置"),
-  import_koishi2.Schema.intersect([
-    import_koishi2.Schema.object({
-      enableDirectInput: import_koishi2.Schema.boolean().default(true).description(`对局中直接发送猜测词即可续猜，无需指令前缀。`),
-      isPreventUserDuplicateGuessInput: import_koishi2.Schema.boolean().default(true).description(`拦截重复提交的猜测词。`),
-      shouldPromptWordLengthInput: import_koishi2.Schema.boolean().default(true).description(
+  import_koishi.Schema.intersect([
+    import_koishi.Schema.object({
+      enableDirectInput: import_koishi.Schema.boolean().default(true).description(`对局中直接发送猜测词即可续猜，无需指令前缀。`),
+      isPreventUserDuplicateGuessInput: import_koishi.Schema.boolean().default(true).description(`拦截重复提交的猜测词。`),
+      shouldPromptWordLengthInput: import_koishi.Schema.boolean().default(true).description(
         `引导式开局时，追问一次单词长度。关闭则直接用默认长度。`
       ),
-      shouldPromptForWordLengthOnNonClassicStart: import_koishi2.Schema.boolean().default(true).description(
+      shouldPromptForWordLengthOnNonClassicStart: import_koishi.Schema.boolean().default(true).description(
         `以非经典模式开局时，追问一次单词长度。关闭则直接用默认长度。`
       )
     }).description("游戏行为设置"),
-    import_koishi2.Schema.object({
-      enableWordGuessTimeLimit: import_koishi2.Schema.boolean().default(false).description(`给每次作答加上时间限制。`)
+    import_koishi.Schema.object({
+      enableWordGuessTimeLimit: import_koishi.Schema.boolean().default(false).description(`给每次作答加上时间限制。`)
     }),
-    import_koishi2.Schema.union([
-      import_koishi2.Schema.object({
-        enableWordGuessTimeLimit: import_koishi2.Schema.const(true).required(),
-        wordGuessTimeLimitInSeconds: import_koishi2.Schema.number().min(0).default(120).description(`每次作答的时间限制（秒）。`)
+    import_koishi.Schema.union([
+      import_koishi.Schema.object({
+        enableWordGuessTimeLimit: import_koishi.Schema.const(true).required(),
+        wordGuessTimeLimitInSeconds: import_koishi.Schema.number().min(0).default(120).description(`每次作答的时间限制（秒）。`)
       }),
-      import_koishi2.Schema.object({})
+      import_koishi.Schema.object({})
     ]),
-    import_koishi2.Schema.object({
-      retractDelay: import_koishi2.Schema.number().min(0).default(0).description(
+    import_koishi.Schema.object({
+      retractDelay: import_koishi.Schema.number().min(0).default(0).description(
         `自动撤回延迟（秒），0 表示不撤回。`
       ),
-      imageType: import_koishi2.Schema.union(["png", "jpeg", "webp"]).default("png").description(`发送的图片格式。`)
+      imageType: import_koishi.Schema.union(["png", "jpeg", "webp"]).default("png").description(`发送的图片格式。`)
     })
   ])
 ]);
@@ -441,6 +338,24 @@ async function updateDataInTargetFile(logger, newFilePath, targetFilePath, missi
 }
 __name(updateDataInTargetFile, "updateDataInTargetFile");
 
+// src/help.ts
+function helpOf(session, name2, order = []) {
+  const describe = /* @__PURE__ */ __name((command) => session.text([`commands.${command}.description`, ""]), "describe");
+  const rank = /* @__PURE__ */ __name((command) => {
+    const i = order.indexOf(command);
+    return i < 0 ? order.length : i;
+  }, "rank");
+  const entries = [];
+  for (const child of session.app.$commander.get(name2)?.children ?? []) {
+    const { hidden } = child.config;
+    if (!child.match(session) || session.resolve(hidden)) continue;
+    entries.push({ name: child.name, description: describe(child.name) });
+  }
+  entries.sort((a, b) => rank(a.name) - rank(b.name));
+  return { title: describe(name2), entries };
+}
+__name(helpOf, "helpOf");
+
 // src/utils/string.ts
 function removeDuplicates(inputString) {
   let result = "";
@@ -737,8 +652,8 @@ __name(processExtraGameRecords, "processExtraGameRecords");
 async function sendMessage(g, session, message) {
   const config = g.config;
   const { bot, channelId } = session;
-  const [messageId] = await session.send(choosePresentation(message, isTextOnly(g.ctx, session)));
-  if (!isTextOnly(g.ctx, session) && config.retractDelay > 0 && messageId) {
+  const [messageId] = await session.send(message);
+  if (config.retractDelay > 0 && messageId) {
     const prevMessage = g.lastMessageInfo.get(channelId);
     if (prevMessage) {
       const timePassed = Date.now() - prevMessage.timestamp;
@@ -795,10 +710,22 @@ __name(getSessionUserName, "getSessionUserName");
 function register(g) {
   const { ctx, config } = g;
   ctx.command("wordle", "猜单词 · 多词库多模式").alias("wordleGame").action(async ({ session }) => {
-    let { userId, username } = session;
-    username = await getSessionUserName(g, session);
-    await updateNameInPlayerRecord(g, session, userId, username);
-    await session.execute(`wordle -h`);
+    const { title, entries } = helpOf(
+      session,
+      "wordle",
+      ["开始", "猜", "查询进度", "结束", "排行榜", "战绩", "查单词", "查成语", "拼音速查表", "玩法介绍"].map(
+        (name2) => `wordle.${name2}`
+      )
+    );
+    return await sendMessage(
+      g,
+      session,
+      [
+        title,
+        ...entries.map(({ name: name2, description }) => `　${name2}　${description}`),
+        "发送「wordle.开始」开局，之后直接发送猜测词即可。"
+      ].join("\n")
+    );
   });
   ctx.command("wordle.玩法介绍", "查看玩法介绍").action(async ({ session }) => {
     let { userId, username } = session;
@@ -807,12 +734,47 @@ function register(g) {
     return sendMessage(
       g,
       session,
-      "玩法：发送「wordle.开始」选择词库，再发送「wordle.猜 单词」。\n每次猜测会标记：✓ 字符与位置均正确；↔ 答案含该字符但位置不符；× 不包含（重复字符按数量判断）。\n「wordle.查询进度」查看已知线索；「wordle.拼音速查表」查看汉兜拼音；「wordle.结束」结束本局。\n可发送「wordle.显示 文字」切换文字输出。"
+      "玩法：发送「wordle.开始」选择词库，再发送「wordle.猜 单词」。\n每次猜测会标记：✓ 字符与位置均正确；↔ 答案含该字符但位置不符；× 不包含（重复字符按数量判断）。\n「wordle.查询进度」查看已知线索；「wordle.拼音速查表」查看汉兜拼音；「wordle.结束」结束本局。"
     );
   });
 }
 __name(register, "register");
 
+// src/ux.ts
+var import_koishi2 = require("koishi");
+var KEY = Symbol.for("araea.koishi.ux.v1");
+function state(ctx) {
+  const root2 = ctx.root;
+  return root2[KEY] ??= { owners: /* @__PURE__ */ new Set() };
+}
+__name(state, "state");
+function registerDirectInput(ctx, name2, matches) {
+  const owner = { name: name2, matches };
+  state(ctx).owners.add(owner);
+  ctx.on("dispose", () => {
+    state(ctx).owners.delete(owner);
+  });
+}
+__name(registerDirectInput, "registerDirectInput");
+async function directInputConflict(ctx, session) {
+  if (session.event.user?.isBot) return true;
+  const owners = [];
+  for (const owner of state(ctx).owners) {
+    try {
+      if (await owner.matches(session)) owners.push(owner.name);
+    } catch {
+    }
+  }
+  if (owners.length < 2) return false;
+  await session.send(`这条消息同时适用于 ${owners.join("、")}，尚未执行。请使用对应游戏的完整指令。`);
+  return true;
+}
+__name(directInputConflict, "directInputConflict");
+function promptInput(session) {
+  return session.prompt(3e5);
+}
+__name(promptInput, "promptInput");
+
 // src/services/renderer.ts
 var import_cheerio = require("cheerio");
 var import_url = require("url");
@@ -6168,16 +6130,20 @@ __name(resource, "resource");
 // src/services/renderer.ts
 var HUE = 142;
 var imageDescriptions = /* @__PURE__ */ new WeakMap();
-function imageText2(buffer) {
+function imageText(buffer) {
   return imageDescriptions.get(buffer) ?? "棋盘说明暂不可用，可发送「wordle.查询进度」。";
 }
-__name(imageText2, "imageText");
+__name(imageText, "imageText");
 function imageMessage(buffer, type) {
-  const text = imageText2(buffer) ?? "图片内容请使用「wordle.查询进度」查询。";
+  const text = imageText(buffer) ?? "图片内容请使用「wordle.查询进度」查询。";
   if (!buffer.length) return (0, import_koishi3.h)("p", {}, import_koishi3.h.text(text));
-  return (0, import_koishi3.h)("p", {}, [import_koishi3.h.image(buffer, type), imageText(import_koishi3.h.text(text))]);
+  return import_koishi3.h.image(buffer, type);
 }
 __name(imageMessage, "imageMessage");
+var HINT = {
+  light: { ok: lch(40, 48, 142), mis: lch(46, 60, 62), okAlt: lch(46, 70, 50), misAlt: lch(42, 52, 260) },
+  dark: { ok: lch(80, 56, 142), mis: lch(82, 60, 85), okAlt: lch(74, 62, 55), misAlt: lch(76, 40, 255) }
+};
 var PANEL_WIDTH = 611;
 async function capture(g, html, viewport, fileOrigin = false) {
   const $ = (0, import_cheerio.load)(html);
@@ -6203,9 +6169,14 @@ async function capture(g, html, viewport, fileOrigin = false) {
     await page.setViewport({ ...viewport, deviceScaleFactor: 1 });
     if (fileOrigin) await page.goto((0, import_url.pathToFileURL)(resource("emptyHtml.html")).href);
     await page.setContent(html, { waitUntil: "load" });
-    const c = scheme(HUE, g.config.isDarkThemeEnabled);
+    const dark = g.config.isDarkThemeEnabled;
+    const c = scheme(HUE, dark);
+    const hint = HINT[dark ? "dark" : "light"];
     await page.addStyleTag({ content: `${baseline(c)} body{background:${c.surface}!important;color:${c.onSurface}!important} input{color:${c.onSurface};border-radius:12px}
-.text-ok{color:${c.primary}!important;text-decoration:underline;text-decoration-style:double}.text-mis{color:${c.tertiary}!important;text-decoration:underline;text-decoration-style:dashed}.op35,.op80{opacity:1!important;color:${c.onSurfaceVariant}!important}
+.text-ok,.text-mis{text-decoration-line:underline;text-decoration-thickness:1.5px;text-underline-offset:4px;text-decoration-skip-ink:none}
+.text-ok{color:${hint.ok}!important;text-decoration-style:double}.text-mis{color:${hint.mis}!important;text-decoration-style:dashed}
+.colorblind .text-ok{color:${hint.okAlt}!important}.colorblind .text-mis{color:${hint.misAlt}!important}
+.op35,.op80{opacity:1!important;color:${c.onSurfaceVariant}!important}
 .bg-correct{background:${c.primary}!important;border-radius:12px}.fill-correct{fill:${c.primary}!important}.fill-white{fill:${c.onPrimary}!important}
  .bg-base{background:${c.surface}!important} *{animation:none!important;transition:none!important}` });
     buffer = await page.screenshot({ fullPage: true, type: g.config.imageType });
@@ -6378,11 +6349,12 @@ async function generatePanelImage(g, rows, isRanked = false) {
         <style>
             ${baseline(s)}
             ${components()}
-            body {
-                width: ${PANEL_WIDTH}px;
-                padding: 24px;
-                background: var(--md-sys-color-surface);
-            }
+            /* 留白放在外层容器上：截图时注入的基线样式会把 body 的内边距清零，上下就不对称了 */
+            body { width: ${PANEL_WIDTH}px; background: var(--md-sys-color-surface); }
+            .panel { padding: 24px; }
+            /* 序号一位数、两位数时徽标同宽，名字才对得齐 */
+            .m3-list-item .m3-badge { width: 36px; padding: 0; }
+            .m3-list { margin: 0; }
             /* 一屏里要放下十几行，行高比默认的列表项紧一档 */
             .m3-list-item {
                 min-height: 48px;
@@ -6408,12 +6380,12 @@ async function generatePanelImage(g, rows, isRanked = false) {
         </style>
     </head>
     <body>
-    <ul class="m3-list">
+    <main class="panel"><ul class="m3-list">
     ${items}
-    </ul>
+    </ul></main>
     </body>
     </html>`;
-  return capture(g, html, { width: PANEL_WIDTH, height: 128 });
+  return capture(g, html, { width: PANEL_WIDTH, height: 1 });
 }
 __name(generatePanelImage, "generatePanelImage");
 async function renderPanel(g, rows, isRanked = false) {
@@ -17589,7 +17561,7 @@ function generateEmptyGridHtmlForHandle(rowNum, tileNum) {
 __name(generateEmptyGridHtmlForHandle, "generateEmptyGridHtmlForHandle");
 function generateImageTags(buffers) {
   return buffers.map((buffer, index) => {
-    const description = `棋盘 ${index + 1}：${imageText2(buffer)}`;
+    const description = `棋盘 ${index + 1}：${imageText(buffer)}`;
     if (!buffer.length) return `<p>${import_koishi4.h.escape(description)}</p>`;
     return `<img src="data:image/png;base64,${buffer.toString("base64")}" alt="${import_koishi4.h.escape(description)}">`;
   }).join("\n");
@@ -18429,75 +18401,36 @@ function register2(g) {
   const idiomsList = g.data.idiomsList;
   const pinyinData = g.data.pinyinData;
   const equations = g.data.equations;
+  async function directGuess(session) {
+    if (!config.enableDirectInput || !session.channelId) return;
+    const content = `${import_koishi5.h.select(session.content ?? "", "text")}`.trim();
+    if (!content || !/^[\p{L}\d+*/=().-]+$/u.test(content)) return;
+    const [gameInfo] = await ctx.database.get("wordle_game_records", { channelId: session.channelId });
+    if (!gameInfo?.isStarted) return;
+    const { gameMode } = gameInfo;
+    const word = gameMode === "汉兜" || gameMode === "词影" ? content : content.toLowerCase();
+    if (gameInfo.guessHistory?.includes(word)) return;
+    if (gameMode === "汉兜" || gameMode === "词影") {
+      if (!isFourCharacterIdiom(content)) return;
+      const known = isIdiomInList(content, idiomsList) || gameMode === "汉兜" && pinyinData.some((item) => item.term === content);
+      if (!known) return;
+      if (gameMode === "词影" && !checkStrokesData(content, g.data.strokesData)) return;
+      return content;
+    }
+    if (content.length !== gameInfo.guessWordLength) return;
+    if (gameMode === "Numberle") return isNumericString(content) ? content : void 0;
+    if (gameMode === "Math") return isMathEquationValid(content) ? content : void 0;
+    if (!/^[a-zA-Z]+$/.test(content) || !findWord(word)) return;
+    return content;
+  }
+  __name(directGuess, "directGuess");
   registerDirectInput(ctx, "wordle-game", async (session) => {
     if (!ctx.filter(session)) return false;
-    let { channelId, content } = session;
-    if (!config.enableDirectInput) {
-      return false;
-    }
-    if (content) {
-      content = `${import_koishi5.h.select(content, "text")}`.trim();
-    }
-    if (!channelId || !content || !/^[\p{L}\d+*/=().-]+$/u.test(content)) return false;
-    const [gameInfo] = await ctx.database.get("wordle_game_records", { channelId });
-    if (!gameInfo?.isStarted) {
-      return false;
-    }
-    if (gameInfo.gameMode === "汉兜" || gameInfo.gameMode === "词影") {
-      if (!isFourCharacterIdiom(content)) {
-        return false;
-      }
-    } else if (gameInfo.gameMode === "Numberle") {
-      if (!isNumericString(content)) {
-        return false;
-      }
-    } else if (gameInfo.gameMode === "Math") {
-      if (!isMathEquationValid(content)) {
-        return false;
-      }
-    } else {
-      if (!/^[a-zA-Z]+$/.test(content)) {
-        return false;
-      }
-    }
-    if (content.length !== gameInfo.guessWordLength) {
-      return false;
-    }
-    return true;
+    return Boolean(await directGuess(session));
   });
   ctx.middleware(async (session, next) => {
-    let { channelId, content } = session;
-    if (!config.enableDirectInput) {
-      return await next();
-    }
-    if (content) {
-      content = `${import_koishi5.h.select(content, "text")}`.trim();
-    }
-    if (!channelId || !content || !/^[\p{L}\d+*/=().-]+$/u.test(content)) return next();
-    const [gameInfo] = await ctx.database.get("wordle_game_records", { channelId });
-    if (!gameInfo?.isStarted) {
-      return await next();
-    }
-    if (gameInfo.gameMode === "汉兜" || gameInfo.gameMode === "词影") {
-      if (!isFourCharacterIdiom(content)) {
-        return await next();
-      }
-    } else if (gameInfo.gameMode === "Numberle") {
-      if (!isNumericString(content)) {
-        return await next();
-      }
-    } else if (gameInfo.gameMode === "Math") {
-      if (!isMathEquationValid(content)) {
-        return await next();
-      }
-    } else {
-      if (!/^[a-zA-Z]+$/.test(content)) {
-        return await next();
-      }
-    }
-    if (content.length !== gameInfo.guessWordLength) {
-      return await next();
-    }
+    const content = await directGuess(session);
+    if (!content) return next();
     if (await directInputConflict(ctx, session)) return;
     await session.execute(`wordle.猜 ${content}`);
     return;
@@ -18576,7 +18509,7 @@ ${generateGameEndMessage(gameInfo)}`}${processedResult}
 ${examPanel ?? examList}
 发送序号或模式名即可开局，或发送「取消」。`
     );
-    const userInput = await promptInput(session, "继续当前对局。");
+    const userInput = await promptInput(session);
     if (!userInput)
       return await sendMessage(
         g,
@@ -18599,7 +18532,7 @@ ${examPanel ?? examList}
             )}
 发送一个长度即可开局，或发送「取消」。`
           );
-          const userInput2 = await promptInput(session, "继续当前对局。");
+          const userInput2 = await promptInput(session);
           if (!userInput2)
             return await sendMessage(
               g,
@@ -18779,7 +18712,7 @@ ${image}
             )}
 发送一个长度即可开局，或发送「取消」。`
           );
-          const userInput = await promptInput(session, "继续当前对局。");
+          const userInput = await promptInput(session);
           if (!userInput)
             return await sendMessage(
               g,
@@ -19059,7 +18992,7 @@ ${image}${tail}`
           session,
           `💡 发送一个猜测词，或发送「取消」。`
         );
-        const userInput = await promptInput(session, "继续当前对局。");
+        const userInput = await promptInput(session);
         if (!userInput) {
           await setGuessRunningStatus(g, channelId, false);
           return await sendMessage(
@@ -19400,7 +19333,7 @@ ${imageMessage(
 发送「撤销」回到上一步，或发送「结束」收掉这一局。
 没有等到有效输入时，按「撤销」处理。`
           );
-          let userInput = await promptInput(session, "继续当前对局。");
+          let userInput = await promptInput(session);
           const imageBuffer22 = await generateImage(
             g,
             styledHtml,
@@ -20460,7 +20393,6 @@ var inject = {
 };
 var name = "wordle-game";
 async function apply(ctx, config) {
-  const presentation = usePresentation(ctx, "wordle");
   const logger = ctx.logger(`wordleGame`);
   const wordleGameDirPath = path3.join(ctx.baseDir, "data", "wordleGame");
   const idiomsFilePath = path3.join(__dirname, "assets", "汉兜", "idioms.json");

package/lib/ux.d.ts

@@ -3,29 +3,11 @@ type Owner = {
     name: string;
     matches: (session: Session) => boolean | Promise<boolean>;
 };
-/** 图文模式默认只发渲染图；完整文字只在用户切到「文字」模式时出现。偏好只影响本人。 */
-export declare function usePresentation(ctx: Context, command: string): {
-    textOnly: (session: Session) => boolean;
-    /** 图文模式只给图片；图片缺失或用户选了文字模式时才退回文字。 */
-    present(session: Session, image: h.Fragment | null | undefined, text: h.Fragment): h.Fragment;
-};
+/** 渲染图优先，只发图片；图片缺失时才退回等价文字。 */
+export declare function present(image: h.Fragment | null | undefined, text: h.Fragment): h.Fragment;
 /** Plugins register their active input grammar; overlapping messages are never executed. */
 export declare function registerDirectInput(ctx: Context, name: string, matches: Owner['matches']): void;
 export declare function directInputConflict(ctx: Context, session: Session): Promise<boolean>;
-/** No hidden time limit: users can extend the non-game input step without losing context. */
-export declare function promptInput(session: Session, instruction: string): Promise<string | undefined>;
-export declare const IMAGE_FAILURE = "\u56FE\u7247\u6682\u65F6\u65E0\u6CD5\u751F\u6210\uFF0C\u5DF2\u4FDD\u7559\u6587\u5B57\u5185\u5BB9\u3002\u53EF\u4EE5\u7A0D\u540E\u91CD\u8BD5\uFF1B\u82E5\u6301\u7EED\u5931\u8D25\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
-/**
- * 渲染图的等价文字。图文模式随图片一起丢掉、文字模式展开成正文，
- * 因此它永远不会原样发到聊天平台。
- */
-export declare const IMAGE_TEXT_TYPE = "ux-image-text";
-export declare function imageText(text: h.Fragment): h;
-/** 图文模式：保留图片与普通文字，去掉图片的等价文字。 */
-export declare function imagesOnly(content: h.Fragment): h[];
-/** 文字模式：去掉图片，把等价文字展开成普通文本。 */
-export declare function withoutImages(content: h.Fragment): h[];
-/** 发送前的统一选择：文字模式去掉图片，图文模式去掉等价文字。 */
-export declare function choosePresentation(content: h.Fragment, textOnly: boolean): h[];
-export declare function isTextOnly(ctx: Context, session: Session): boolean;
+/** 等待下一句回复。提问本身已经写明了可回复的内容与「取消」，这里不再追加说明。 */
+export declare function promptInput(session: Session): Promise<string | undefined>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-wordle-game",
-  "description": "Koishi 多词库猜词游戏，包含经典、汉兜、Numberle 等模式。",
-  "version": "4.2.1",
+  "description": "Koishi 插件：猜词游戏，支持单词、成语、数字与方程式等多种模式。",
+  "version": "4.4.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [