koishi-plugin-maple-dice-v2 0.0.1 → 0.0.3

package/lib/index.js

@@ -1,607 +1,596 @@
-import { Schema } from 'koishi';
-export const name = 'maple-dice-v2';
-export const using = ['database'];
-// 骰子解析类
-class DiceRoller {
-    static parseDice(expression) {
-        // 如果表达式为空，默认为1d100
-        if (!expression) {
-            expression = '1d100';
-        }
-        // 清理表达式
-        expression = expression.replace(/\s+/g, '').toLowerCase();
-        // 匹配 xdy 后面可选的运算符和数字，支持 + - * /
-        const diceRegex = /^(\d+)?d(\d+)(?:([+\-*/])(\d+))?$/;
-        const match = expression.match(diceRegex);
-        if (!match) {
-            throw new Error('无效的掷骰表达式。正确格式: r xdy[+-*/]z');
-        }
-        const count = match[1] ? parseInt(match[1]) : 1;
-        const sides = parseInt(match[2]);
-        const operator = match[3] || '';
-        const modifier = match[4] ? parseInt(match[4]) : 0;
-        if (count < 1 || sides < 1) {
-            throw new Error('骰子数量和面数必须为正整数');
-        }
-        if (count > 100) {
-            throw new Error('一次最多只能掷 100 个骰子');
-        }
-        const rolls = [];
-        for (let i = 0; i < count; i++) {
-            rolls.push(Math.floor(Math.random() * sides) + 1);
-        }
-        const diceTotal = rolls.reduce((sum, roll) => sum + roll, 0);
-        let total;
-        switch (operator) {
-            case '+':
-                total = diceTotal + modifier;
-                break;
-            case '-':
-                total = diceTotal - modifier;
-                break;
-            case '*':
-                total = diceTotal * modifier;
-                break;
-            case '/':
-                if (modifier === 0) {
-                    throw new Error('除数不能为0');
-                }
-                total = Math.floor(diceTotal / modifier); // 向下取整
-                break;
-            default:
-                total = diceTotal;
-        }
-        let expr = `${count}d${sides}`;
-        if (operator) {
-            expr += `${operator}${modifier}`;
-        }
-        return {
-            total,
-            details: rolls,
-            expression: expr,
-            operator,
-            modifier,
-            count,
-            sides
-        };
-    }
-    // 技能检定
-    static skillCheck(skillValue) {
-        const diceValue = Math.floor(Math.random() * 100) + 1;
-        // 判断成功等级
-        let successLevel = '';
-        if (diceValue === 1) {
-            successLevel = 'greatSuccess'; // 大成功
-        }
-        else if (diceValue === 100) {
-            successLevel = 'greatFail'; // 大失败
-        }
-        else if (diceValue <= Math.floor(skillValue / 5)) {
-            successLevel = 'extremeSuccess'; // 极难成功
-        }
-        else if (diceValue <= Math.floor(skillValue / 2)) {
-            successLevel = 'hardSuccess'; // 困难成功
-        }
-        else if (diceValue <= skillValue) {
-            successLevel = 'success'; // 成功
-        }
-        else {
-            successLevel = 'fail'; // 失败
-        }
-        return {
-            diceValue,
-            skillValue,
-            successLevel
-        };
-    }
-    // 奖励骰/惩罚骰检定
-    static bonusPenaltyCheck(tensCount, skillValue, isReward) {
-        // 生成十位数的备选结果
-        const tens = [];
-        for (let i = 0; i < tensCount; i++) {
-            tens.push(Math.floor(Math.random() * 10)); // 0-9
-        }
-        // 生成个位数
-        const unit = Math.floor(Math.random() * 10); // 0-9
-        // 选择十位数：奖励骰取最小，惩罚骰取最大
-        let selectedTen;
-        if (isReward) {
-            selectedTen = Math.min(...tens);
-        }
-        else {
-            selectedTen = Math.max(...tens);
-        }
-        // 组合成最终骰值 (0-99, 0表示100)
-        let diceValue = selectedTen * 10 + unit;
-        if (diceValue === 0) {
-            diceValue = 100;
-        }
-        // 判断成功等级
-        let successLevel = '';
-        if (diceValue === 1) {
-            successLevel = 'greatSuccess'; // 大成功
-        }
-        else if (diceValue === 100) {
-            successLevel = 'greatFail'; // 大失败
-        }
-        else if (diceValue <= Math.floor(skillValue / 5)) {
-            successLevel = 'extremeSuccess'; // 极难成功
-        }
-        else if (diceValue <= Math.floor(skillValue / 2)) {
-            successLevel = 'hardSuccess'; // 困难成功
-        }
-        else if (diceValue <= skillValue) {
-            successLevel = 'success'; // 成功
-        }
-        else {
-            successLevel = 'fail'; // 失败
-        }
-        return {
-            diceValue,
-            skillValue,
-            successLevel,
-            tens,
-            unit
-        };
-    }
-    // 获取成功等级的描述
-    static getSuccessLevelText(level) {
-        const texts = {
-            'greatSuccess': '大成功',
-            'greatFail': '大失败',
-            'extremeSuccess': '极难成功',
-            'hardSuccess': '困难成功',
-            'success': '成功',
-            'fail': '失败'
-        };
-        return texts[level] || level;
-    }
-}
-// 配置定义
-export const Config = Schema.object({
-    defaultSkill: Schema.number()
-        .default(50)
-        .min(1)
-        .max(100)
-        .description('默认技能值（当ra指令未指定时使用）'),
-    replyMode: Schema.union([
-        Schema.const('global').description('全局: 调用所有自定义回复'),
-        Schema.const('group').description('群组: 仅调用当前群组内添加的所有自定义回复（私聊时，仅调用本人私聊添加的所有自定义回复）'),
-        Schema.const('personal').description('个人: 仅调用由本人添加的所有自定义回复')
-    ])
-        .default('global')
-        .description('回复模式'),
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name,
+  using: () => using
 });
-// 等级名称到内部键的映射
-const levelNameToKey = {
-    '大成功': 'greatSuccess',
-    '大失败': 'greatFail',
-    '极难成功': 'extremeSuccess',
-    '困难成功': 'hardSuccess',
-    '成功': 'success',
-    '失败': 'fail'
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "maple-dice-v2";
+var using = ["database"];
+var DiceRoller = class {
+  static {
+    __name(this, "DiceRoller");
+  }
+  static parseDice(expression) {
+    if (!expression) {
+      expression = "1d100";
+    }
+    expression = expression.replace(/\s+/g, "").toLowerCase();
+    const diceRegex = /^(\d+)?d(\d+)(?:([+\-*/])(\d+))?$/;
+    const match = expression.match(diceRegex);
+    if (!match) {
+      throw new Error("无效的掷骰表达式。正确格式: r xdy[+-*/]z");
+    }
+    const count = match[1] ? parseInt(match[1]) : 1;
+    const sides = parseInt(match[2]);
+    const operator = match[3] || "";
+    const modifier = match[4] ? parseInt(match[4]) : 0;
+    if (count < 1 || sides < 1) {
+      throw new Error("骰子数量和面数必须为正整数");
+    }
+    if (count > 100) {
+      throw new Error("一次最多只能掷 100 个骰子");
+    }
+    const rolls = [];
+    for (let i = 0; i < count; i++) {
+      rolls.push(Math.floor(Math.random() * sides) + 1);
+    }
+    const diceTotal = rolls.reduce((sum, roll) => sum + roll, 0);
+    let total;
+    switch (operator) {
+      case "+":
+        total = diceTotal + modifier;
+        break;
+      case "-":
+        total = diceTotal - modifier;
+        break;
+      case "*":
+        total = diceTotal * modifier;
+        break;
+      case "/":
+        if (modifier === 0) {
+          throw new Error("除数不能为0");
+        }
+        total = Math.floor(diceTotal / modifier);
+        break;
+      default:
+        total = diceTotal;
+    }
+    let expr = `${count}d${sides}`;
+    if (operator) {
+      expr += `${operator}${modifier}`;
+    }
+    return {
+      total,
+      details: rolls,
+      expression: expr,
+      operator,
+      modifier,
+      count,
+      sides
+    };
+  }
+  // 技能检定
+  static skillCheck(skillValue) {
+    const diceValue = Math.floor(Math.random() * 100) + 1;
+    let successLevel = "";
+    if (diceValue === 1) {
+      successLevel = "greatSuccess";
+    } else if (diceValue === 100) {
+      successLevel = "greatFail";
+    } else if (diceValue <= Math.floor(skillValue / 5)) {
+      successLevel = "extremeSuccess";
+    } else if (diceValue <= Math.floor(skillValue / 2)) {
+      successLevel = "hardSuccess";
+    } else if (diceValue <= skillValue) {
+      successLevel = "success";
+    } else {
+      successLevel = "fail";
+    }
+    return {
+      diceValue,
+      skillValue,
+      successLevel
+    };
+  }
+  // 奖励骰/惩罚骰检定
+  static bonusPenaltyCheck(tensCount, skillValue, isReward) {
+    const tens = [];
+    for (let i = 0; i < tensCount; i++) {
+      tens.push(Math.floor(Math.random() * 10));
+    }
+    const unit = Math.floor(Math.random() * 10);
+    let selectedTen;
+    if (isReward) {
+      selectedTen = Math.min(...tens);
+    } else {
+      selectedTen = Math.max(...tens);
+    }
+    let diceValue = selectedTen * 10 + unit;
+    if (diceValue === 0) {
+      diceValue = 100;
+    }
+    let successLevel = "";
+    if (diceValue === 1) {
+      successLevel = "greatSuccess";
+    } else if (diceValue === 100) {
+      successLevel = "greatFail";
+    } else if (diceValue <= Math.floor(skillValue / 5)) {
+      successLevel = "extremeSuccess";
+    } else if (diceValue <= Math.floor(skillValue / 2)) {
+      successLevel = "hardSuccess";
+    } else if (diceValue <= skillValue) {
+      successLevel = "success";
+    } else {
+      successLevel = "fail";
+    }
+    return {
+      diceValue,
+      skillValue,
+      successLevel,
+      tens,
+      unit
+    };
+  }
+  // 获取成功等级的描述
+  static getSuccessLevelText(level) {
+    const texts = {
+      "greatSuccess": "大成功",
+      "greatFail": "大失败",
+      "extremeSuccess": "极难成功",
+      "hardSuccess": "困难成功",
+      "success": "成功",
+      "fail": "失败"
+    };
+    return texts[level] || level;
+  }
 };
-const keyToLevelName = {
-    'greatSuccess': '大成功',
-    'greatFail': '大失败',
-    'extremeSuccess': '极难成功',
-    'hardSuccess': '困难成功',
-    'success': '成功',
-    'fail': '失败'
+var Config = import_koishi.Schema.object({
+  defaultSkill: import_koishi.Schema.number().default(50).min(1).max(100).description("默认技能值（当ra指令未指定时使用）"),
+  replyMode: import_koishi.Schema.union([
+    import_koishi.Schema.const("global").description("全局: 调用所有自定义回复"),
+    import_koishi.Schema.const("group").description("群组: 仅调用当前群组内添加的所有自定义回复（私聊时，仅调用本人私聊添加的所有自定义回复）"),
+    import_koishi.Schema.const("personal").description("个人: 仅调用由本人添加的所有自定义回复")
+  ]).default("global").description("回复模式")
+});
+var keyToLevelName = {
+  "greatSuccess": "大成功",
+  "greatFail": "大失败",
+  "extremeSuccess": "极难成功",
+  "hardSuccess": "困难成功",
+  "success": "成功",
+  "fail": "失败"
 };
-// 根据回复模式和会话信息筛选回复
 function filterResponsesByMode(responses, session, replyMode, levelName) {
-    // 如果没有任何回复，返回空数组
-    if (responses.length === 0) {
-        return [];
-    }
-    // 如果是私聊环境
-    const isPrivate = !session.guildId;
-    const userId = session.userId;
-    const groupId = isPrivate ? '私聊' : session.guildId;
-    // 根据回复模式筛选
-    switch (replyMode) {
-        case 'global':
-            // 全局模式：返回所有该等级的自定义回复
-            return responses.filter(r => r.level === levelName);
-        case 'group':
-            // 群组模式：返回当前群组（或私聊）内添加的所有自定义回复
-            return responses.filter(r => r.level === levelName &&
-                r.group === groupId);
-        case 'personal':
-            // 个人模式：返回由本人添加的所有自定义回复
-            return responses.filter(r => r.level === levelName &&
-                r.author === userId);
-        default:
-            // 默认返回全局模式
-            return responses.filter(r => r.level === levelName);
-    }
+  if (responses.length === 0) {
+    return [];
+  }
+  const isPrivate = !session.guildId;
+  const userId = session.userId;
+  const groupId = isPrivate ? "私聊" : session.guildId;
+  switch (replyMode) {
+    case "global":
+      return responses.filter((r) => r.level === levelName);
+    case "group":
+      return responses.filter(
+        (r) => r.level === levelName && r.group === groupId
+      );
+    case "personal":
+      return responses.filter(
+        (r) => r.level === levelName && r.author === userId
+      );
+    default:
+      return responses.filter((r) => r.level === levelName);
+  }
 }
-// 获取随机回复 - 从数据库读取
+__name(filterResponsesByMode, "filterResponsesByMode");
 async function getRandomResponse(ctx, session, config, successLevel, diceValue, skillValue) {
-    // 将内部等级转换为显示名称
-    const levelName = keyToLevelName[successLevel] || '成功';
-    // 从数据库获取所有回复
-    const allResponses = await ctx.database.get('maple-dice-responses', {});
-    // 根据回复模式筛选回复
-    const filteredResponses = filterResponsesByMode(allResponses, session, config.replyMode, levelName);
-    let replies = [];
-    if (filteredResponses.length === 0) {
-        // 如果没有符合条件的自定义回复，使用默认回复
-        const defaultResponses = {
-            '大成功': ['大成功！骰值：{result}'],
-            '大失败': ['大失败！骰值：{result}'],
-            '极难成功': ['极难成功！骰值：{result}'],
-            '困难成功': ['困难成功！骰值：{result}'],
-            '成功': ['成功！骰值：{result}'],
-            '失败': ['失败！骰值：{result}'],
-        };
-        replies = defaultResponses[levelName] || ['{level}！骰值：{result}'];
-    }
-    else {
-        replies = filteredResponses.map(r => r.content);
-    }
-    const randomResponse = replies[Math.floor(Math.random() * replies.length)];
-    // 替换变量
-    const levelText = DiceRoller.getSuccessLevelText(successLevel);
-    return randomResponse
-        .replace(/{result}/g, diceValue.toString())
-        .replace(/{skill}/g, skillValue.toString())
-        .replace(/{level}/g, levelText);
+  const levelName = keyToLevelName[successLevel] || "成功";
+  const allResponses = await ctx.database.get("maple-dice-responses", {});
+  const filteredResponses = filterResponsesByMode(allResponses, session, config.replyMode, levelName);
+  let replies = [];
+  if (filteredResponses.length === 0) {
+    const defaultResponses = {
+      "大成功": ["大成功！骰值：{result}"],
+      "大失败": ["大失败！骰值：{result}"],
+      "极难成功": ["极难成功！骰值：{result}"],
+      "困难成功": ["困难成功！骰值：{result}"],
+      "成功": ["成功！骰值：{result}"],
+      "失败": ["失败！骰值：{result}"]
+    };
+    replies = defaultResponses[levelName] || ["{level}！骰值：{result}"];
+  } else {
+    replies = filteredResponses.map((r) => r.content);
+  }
+  const randomResponse = replies[Math.floor(Math.random() * replies.length)];
+  const levelText = DiceRoller.getSuccessLevelText(successLevel);
+  return randomResponse.replace(/{result}/g, diceValue.toString()).replace(/{skill}/g, skillValue.toString()).replace(/{level}/g, levelText);
 }
-// 主插件函数
-export function apply(ctx, config) {
-    console.log('maple-dice-v2 插件加载中...');
-    // 扩展数据库表，添加group字段
-    ctx.model.extend('maple-dice-responses', {
-        id: 'unsigned',
-        level: 'string',
-        content: 'text',
-        author: 'string',
-        group: 'string', // 添加群字段
-        created: 'timestamp',
-    }, {
-        primary: 'id',
-        autoInc: true,
-    });
-    // r 指令 - 修改为可选参数，支持加减乘除
-    ctx.command('r [expression:string]', '基础掷骰（默认为1d100）')
-        .alias('roll')
-        .alias('掷骰')
-        .example('r          掷1个100面骰（默认）')
-        .example('r d6       掷1个6面骰')
-        .example('r 3d6      掷3个6面骰')
-        .example('r 2d20+5   掷2个20面骰并加5')
-        .example('r 3d10-2   掷3个10面骰并减2')
-        .example('r 2d6*3    掷2个6面骰并乘以3')
-        .example('r 4d10/2   掷4个10面骰并除以2')
-        .action(async ({ session }, expression) => {
-        try {
-            const result = DiceRoller.parseDice(expression);
-            let output = `r ${result.expression} = `;
-            // 根据运算符决定输出格式
-            if (!result.operator) {
-                // 没有运算符
-                if (result.count === 1) {
-                    output += `${result.total}`;
-                }
-                else {
-                    output += `${result.details.join('+')} = ${result.total}`;
-                }
-            }
-            else {
-                // 有运算符
-                if (result.count === 1) {
-                    // 只有一个骰子
-                    output += `${result.details[0]}${result.operator}${result.modifier} = ${result.total}`;
-                }
-                else {
-                    // 多个骰子，用括号括起细节
-                    // 对于加减法：r 2d3-1 = (1+2)-1 = 2
-                    output += `(${result.details.join('+')})${result.operator}${result.modifier} = ${result.total}`;
-                }
-            }
-            return output;
-        }
-        catch (error) {
-            return `错误: ${error.message}`;
-        }
-    });
-    // ra 指令
-    ctx.command('ra [skill:number]', '技能检定')
-        .alias('检定')
-        .action(async ({ session }, skill) => {
-        const skillValue = skill || config.defaultSkill;
-        if (skillValue < 1 || skillValue > 100) {
-            return '技能值必须在1-100之间';
-        }
-        const result = DiceRoller.skillCheck(skillValue);
-        const response = await getRandomResponse(ctx, session, config, result.successLevel, result.diceValue, skillValue);
-        const levelText = DiceRoller.getSuccessLevelText(result.successLevel);
-        return `ra ${skillValue}=${result.diceValue}/${skillValue} ${levelText}\n${response}`;
-    });
-    // rb 指令 - 奖励骰
-    ctx.command('rb <input:string>', '奖励骰检定')
-        .example('rb 3/70     进行3个奖励骰的70点技能检定')
-        .example('rb 2        进行2个奖励骰，使用默认技能值')
-        .action(async ({ session }, input) => {
-        try {
-            // 解析输入格式: "x/y" 或 "x"
-            const parts = input.split('/');
-            const tensCount = parseInt(parts[0]);
-            if (isNaN(tensCount) || tensCount < 1) {
-                return '奖励骰数量必须是正整数';
-            }
-            let skillValue = config.defaultSkill;
-            if (parts.length > 1) {
-                skillValue = parseInt(parts[1]);
-                if (isNaN(skillValue) || skillValue < 1 || skillValue > 100) {
-                    return '技能值必须在1-100之间';
-                }
-            }
-            const result = DiceRoller.bonusPenaltyCheck(tensCount, skillValue, true);
-            const response = await getRandomResponse(ctx, session, config, result.successLevel, result.diceValue, skillValue);
-            const levelText = DiceRoller.getSuccessLevelText(result.successLevel);
-            // 格式化十位数显示
-            const tensDisplay = `[${result.tens.join(',')}]`;
-            const unitDisplay = `[${result.unit}]`;
-            return `rb ${tensCount}/${skillValue}=${tensDisplay}+${unitDisplay}=${result.diceValue}/${skillValue} ${levelText}\n${response}`;
-        }
-        catch (error) {
-            return `错误: ${error.message}`;
-        }
-    });
-    // rp 指令 - 惩罚骰
-    ctx.command('rp <input:string>', '惩罚骰检定')
-        .example('rp 3/70     进行3个惩罚骰的70点技能检定')
-        .example('rp 2        进行2个惩罚骰，使用默认技能值')
-        .action(async ({ session }, input) => {
-        try {
-            // 解析输入格式: "x/y" 或 "x"
-            const parts = input.split('/');
-            const tensCount = parseInt(parts[0]);
-            if (isNaN(tensCount) || tensCount < 1) {
-                return '惩罚骰数量必须是正整数';
-            }
-            let skillValue = config.defaultSkill;
-            if (parts.length > 1) {
-                skillValue = parseInt(parts[1]);
-                if (isNaN(skillValue) || skillValue < 1 || skillValue > 100) {
-                    return '技能值必须在1-100之间';
-                }
-            }
-            const result = DiceRoller.bonusPenaltyCheck(tensCount, skillValue, false);
-            const response = await getRandomResponse(ctx, session, config, result.successLevel, result.diceValue, skillValue);
-            const levelText = DiceRoller.getSuccessLevelText(result.successLevel);
-            // 格式化十位数显示
-            const tensDisplay = `[${result.tens.join(',')}]`;
-            const unitDisplay = `[${result.unit}]`;
-            return `rp ${tensCount}/${skillValue}=${tensDisplay}+${unitDisplay}=${result.diceValue}/${skillValue} ${levelText}\n${response}`;
-        }
-        catch (error) {
-            return `错误: ${error.message}`;
-        }
-    });
-    // 添加自定义回复指令
-    ctx.command('添加自定义回复 <level:string> <text:string>', '添加自定义回复（用&分隔多条回复）')
-        .alias('添加回复')
-        .example('添加自定义回复 大成功 太棒了！大成功！骰值：{result}&奇迹般的大成功！骰值：{result}')
-        .action(async ({ session }, level, text) => {
-        // 检查等级是否有效
-        const validLevels = ['大成功', '极难成功', '困难成功', '成功', '失败', '大失败'];
-        if (!validLevels.includes(level)) {
-            return `无效的成功等级。可用等级：${validLevels.join('、')}`;
-        }
-        // 检查用户ID是否存在
-        if (!session?.userId) {
-            return '无法获取用户信息，请确保在正确的环境下使用此指令';
-        }
-        // 获取群组信息
-        const groupId = session.guildId ? session.guildId : '私聊';
-        // 按&符号分割回复文本，并过滤空项
-        const replies = text.split('&')
-            .map(item => item.trim())
-            .filter(item => item.length > 0);
-        if (replies.length === 0) {
-            return '未提供有效的回复文本';
-        }
-        // 批量添加回复，包含作者和群组信息
-        const addedResponses = [];
-        for (const reply of replies) {
-            const result = await ctx.database.create('maple-dice-responses', {
-                level,
-                content: reply,
-                author: session.userId,
-                group: groupId,
-                created: new Date(),
-            });
-            addedResponses.push(result);
-        }
-        return `成功为【${level}】添加了 ${replies.length} 条自定义回复（群组: ${groupId}）\n新增内容:\n${addedResponses.map((r, i) => `${i + 1}. [ID:${r.id}] ${r.content}`).join('\n')}`;
-    });
-    // 查看自定义回复指令 - 添加选项
-    ctx.command('查看自定义回复 [options]', '查看自定义回复')
-        .alias('查看回复')
-        .option('mode', '-m  查看由本人添加的所有自定义回复')
-        .option('group', '-g  查看当前群组内添加的所有自定义回复（私聊时，仅调用本人私聊添加的所有自定义回复）')
-        .option('all', '-a  查看所有自定义回复')
-        .example('查看自定义回复 -g        查看当前群组内的自定义回复（默认）')
-        .example('查看自定义回复 -m        查看由本人添加的自定义回复')
-        .example('查看自定义回复 -a        查看所有自定义回复')
-        .action(async ({ session, options }, level) => {
-        // 确定查询模式
-        let mode = 'group'; // 默认模式为群组模式
-        if (options?.all) {
-            mode = 'all';
-        }
-        else if (options?.mode) {
-            mode = 'personal';
-        }
-        else if (options?.group) {
-            mode = 'group';
-        }
-        // 获取当前会话信息
-        const isPrivate = !session?.guildId;
-        const userId = session?.userId;
-        const groupId = isPrivate ? '私聊' : session?.guildId;
-        // 构建查询条件
-        const query = {};
-        if (level) {
-            const validLevels = ['大成功', '极难成功', '困难成功', '成功', '失败', '大失败'];
-            if (!validLevels.includes(level)) {
-                return `无效的成功等级。可用等级：${validLevels.join('、')}`;
-            }
-            query.level = level;
-        }
-        // 根据模式添加额外查询条件
-        switch (mode) {
-            case 'personal':
-                if (!userId) {
-                    return '无法获取用户信息，请确保在正确的环境下使用此指令';
-                }
-                query.author = userId;
-                break;
-            case 'group':
-                if (!groupId) {
-                    return '无法获取群组信息，请确保在正确的环境下使用此指令';
-                }
-                query.group = groupId;
-                break;
-            case 'all':
-                // 不添加额外的查询条件
-                break;
-        }
-        // 从数据库获取回复
-        const responses = await ctx.database.get('maple-dice-responses', query);
-        if (responses.length === 0) {
-            const modeText = {
-                'all': '所有',
-                'group': `当前${isPrivate ? '私聊' : '群组'}`,
-                'personal': '本人'
-            }[mode];
-            const levelText = level ? `【${level}】` : '';
-            return `${modeText}${levelText}暂无自定义回复，请使用【添加自定义回复】指令添加`;
-        }
-        // 按等级分组并按ID排序
-        const grouped = {};
-        for (const response of responses) {
-            if (!grouped[response.level]) {
-                grouped[response.level] = [];
-            }
-            grouped[response.level].push(response);
-        }
-        // 每个等级内按ID排序
-        for (const levelName in grouped) {
-            grouped[levelName].sort((a, b) => a.id - b.id);
-        }
-        // 构建输出，显示作者信息和可修改标记
-        if (level) {
-            // 只显示指定等级
-            const levelResponses = grouped[level] || [];
-            const modeText = {
-                'all': '所有',
-                'group': `当前${isPrivate ? '私聊' : '群组'}`,
-                'personal': '本人'
-            }[mode];
-            let output = `${modeText}【${level}】（${levelResponses.length}条）:\n`;
-            output += levelResponses.map((r, index) => {
-                const isOwner = userId && r.author === userId;
-                return `${index + 1}. [ID:${r.id}] ${r.content} ${isOwner ? '(可修改)' : ''}`;
-            }).join('\n');
-            return output;
-        }
-        else {
-            // 显示所有等级
-            const modeText = {
-                'all': '所有',
-                'group': `当前${isPrivate ? '私聊' : '群组'}`,
-                'personal': '本人'
-            }[mode];
-            let output = `${modeText}自定义回复:\n\n`;
-            const levelNames = ['大成功', '极难成功', '困难成功', '成功', '失败', '大失败'];
-            for (const levelName of levelNames) {
-                const levelResponses = grouped[levelName] || [];
-                if (levelResponses.length > 0) {
-                    output += `【${levelName}】（${levelResponses.length}条）:\n`;
-                    output += levelResponses.map((r, index) => {
-                        const isOwner = userId && r.author === userId;
-                        return `${index + 1}. [ID:${r.id}] ${r.content} ${isOwner ? '(可修改)' : ''}`;
-                    }).join('\n');
-                    output += '\n\n';
-                }
-            }
-            return output.trim();
-        }
-    });
-    // 删除自定义回复指令 - 检查作者权限
-    ctx.command('删除自定义回复 <id:number>', '删除自定义回复')
-        .alias('删除回复')
-        .example('删除自定义回复 1   删除ID为1的回复')
-        .action(async ({ session }, id) => {
-        // 检查用户ID是否存在
-        if (!session?.userId) {
-            return '无法获取用户信息，请确保在正确的环境下使用此指令';
-        }
-        // 检查ID是否存在
-        const existing = await ctx.database.get('maple-dice-responses', { id });
-        if (existing.length === 0) {
-            return `未找到ID为${id}的回复`;
-        }
-        // 检查权限：只能删除自己添加的回复
-        const response = existing[0];
-        if (response.author !== session.userId) {
-            return `无法删除此回复，您只能删除自己添加的回复。\n输入【查看自定义回复 -m】查看由自己添加的回复`;
-        }
-        // 获取要删除的回复内容
-        const contentToDelete = response.content;
-        const level = response.level;
-        // 删除回复
-        await ctx.database.remove('maple-dice-responses', { id });
-        return `已删除【${level}】的回复(ID: ${id}):\n${contentToDelete}`;
-    });
-    // 修改自定义回复指令 - 检查作者权限
-    ctx.command('修改自定义回复 <id:number> <text:string>', '修改自定义回复')
-        .alias('修改回复')
-        .example('修改自定义回复 1 新的回复内容')
-        .action(async ({ session }, id, text) => {
-        // 检查用户ID是否存在
-        if (!session?.userId) {
-            return '无法获取用户信息，请确保在正确的环境下使用此指令';
-        }
-        // 检查ID是否存在
-        const existing = await ctx.database.get('maple-dice-responses', { id });
-        if (existing.length === 0) {
-            return `未找到ID为${id}的回复`;
-        }
-        // 检查权限：只能修改自己添加的回复
-        const response = existing[0];
-        if (response.author !== session.userId) {
-            return `无法修改此回复，您只能修改自己添加的回复。\n输入【查看自定义回复 -m】查看由自己添加的回复`;
-        }
-        // 检查新内容是否为空
-        if (!text.trim()) {
-            return '新回复内容不能为空';
-        }
-        // 获取旧内容和等级
-        const oldContent = response.content;
-        const level = response.level;
-        // 修改回复
-        await ctx.database.set('maple-dice-responses', { id }, {
-            content: text.trim(),
-            created: new Date(), // 更新修改时间
-        });
-        return `已修改【${level}】的回复(ID: ${id}):\n原内容: ${oldContent}\n新内容: ${text.trim()}`;
-    });
-    // 清空所有自定义回复指令 - 不进行作者限制
-    ctx.command('清空自定义回复', '清空所有自定义回复')
-        .alias('清空回复')
-        .action(async () => {
-        const count = await ctx.database.remove('maple-dice-responses', {});
-        return `已清空所有 ${count} 条自定义回复`;
-    });
-    ctx.on('ready', () => {
-        console.log('maple-dice-v2 插件已加载完成');
-        ctx.logger('maple-dice-v2').info(`默认技能值: ${config.defaultSkill}`);
-        ctx.logger('maple-dice-v2').info(`回复模式: ${config.replyMode}`);
+__name(getRandomResponse, "getRandomResponse");
+function apply(ctx, config) {
+  console.log("maple-dice-v2 插件加载中...");
+  ctx.model.extend("maple-dice-responses", {
+    id: "unsigned",
+    level: "string",
+    content: "text",
+    author: "string",
+    group: "string",
+    // 添加群字段
+    created: "timestamp"
+  }, {
+    primary: "id",
+    autoInc: true
+  });
+  ctx.command("r [expression:string]", "基础掷骰（默认为1d100）").alias("roll").alias("掷骰").example("r 3d6      掷3个6面骰").example("r 2d20+5   掷2个20面骰并加5").action(async ({ session }, expression) => {
+    try {
+      const result = DiceRoller.parseDice(expression);
+      let output = `r ${result.expression} = `;
+      if (!result.operator) {
+        if (result.count === 1) {
+          output += `${result.total}`;
+        } else {
+          output += `${result.details.join("+")} = ${result.total}`;
+        }
+      } else {
+        if (result.count === 1) {
+          output += `${result.details[0]}${result.operator}${result.modifier} = ${result.total}`;
+        } else {
+          output += `(${result.details.join("+")})${result.operator}${result.modifier} = ${result.total}`;
+        }
+      }
+      return output;
+    } catch (error) {
+      return `错误: ${error.message}`;
+    }
+  });
+  ctx.command("ra [skill:number]", "技能检定").alias("检定").example("ra        使用默认技能值进行检定").example("ra 80     使用80点技能值进行检定").action(async ({ session }, skill) => {
+    const skillValue = skill || config.defaultSkill;
+    if (skillValue < 1 || skillValue > 100) {
+      return "技能值必须在1-100之间";
+    }
+    const result = DiceRoller.skillCheck(skillValue);
+    const response = await getRandomResponse(ctx, session, config, result.successLevel, result.diceValue, skillValue);
+    const levelText = DiceRoller.getSuccessLevelText(result.successLevel);
+    return `ra ${skillValue}=${result.diceValue}/${skillValue} ${levelText}
+${response}`;
+  });
+  ctx.command("rb <input:string>", "奖励骰检定").example("rb 3/70     进行3个奖励骰的70点技能检定").example("rb 2        进行2个奖励骰，使用默认技能值").action(async ({ session }, input) => {
+    try {
+      const parts = input.split("/");
+      const tensCount = parseInt(parts[0]);
+      if (isNaN(tensCount) || tensCount < 1) {
+        return "奖励骰数量必须是正整数";
+      }
+      let skillValue = config.defaultSkill;
+      if (parts.length > 1) {
+        skillValue = parseInt(parts[1]);
+        if (isNaN(skillValue) || skillValue < 1 || skillValue > 100) {
+          return "技能值必须在1-100之间";
+        }
+      }
+      const result = DiceRoller.bonusPenaltyCheck(tensCount, skillValue, true);
+      const response = await getRandomResponse(ctx, session, config, result.successLevel, result.diceValue, skillValue);
+      const levelText = DiceRoller.getSuccessLevelText(result.successLevel);
+      const tensDisplay = `[${result.tens.join(",")}]`;
+      const unitDisplay = `[${result.unit}]`;
+      return `rb ${tensCount}/${skillValue}=${tensDisplay}+${unitDisplay}=${result.diceValue}/${skillValue} ${levelText}
+${response}`;
+    } catch (error) {
+      return `错误: ${error.message}`;
+    }
+  });
+  ctx.command("rp <input:string>", "惩罚骰检定").example("rp 3/70     进行3个惩罚骰的70点技能检定").example("rp 2        进行2个惩罚骰，使用默认技能值").action(async ({ session }, input) => {
+    try {
+      const parts = input.split("/");
+      const tensCount = parseInt(parts[0]);
+      if (isNaN(tensCount) || tensCount < 1) {
+        return "惩罚骰数量必须是正整数";
+      }
+      let skillValue = config.defaultSkill;
+      if (parts.length > 1) {
+        skillValue = parseInt(parts[1]);
+        if (isNaN(skillValue) || skillValue < 1 || skillValue > 100) {
+          return "技能值必须在1-100之间";
+        }
+      }
+      const result = DiceRoller.bonusPenaltyCheck(tensCount, skillValue, false);
+      const response = await getRandomResponse(ctx, session, config, result.successLevel, result.diceValue, skillValue);
+      const levelText = DiceRoller.getSuccessLevelText(result.successLevel);
+      const tensDisplay = `[${result.tens.join(",")}]`;
+      const unitDisplay = `[${result.unit}]`;
+      return `rp ${tensCount}/${skillValue}=${tensDisplay}+${unitDisplay}=${result.diceValue}/${skillValue} ${levelText}
+${response}`;
+    } catch (error) {
+      return `错误: ${error.message}`;
+    }
+  });
+  ctx.command("添加自定义回复 <level:string> <text:string>", "添加自定义回复（用&分隔多条回复）").alias("添加回复").example("添加自定义回复 大成功 太棒了！大成功！骰值：{result}").example("添加自定义回复 成功 成功！骰值：{result}&干得漂亮！骰值：{result}").action(async ({ session }, level, text) => {
+    const validLevels = ["大成功", "极难成功", "困难成功", "成功", "失败", "大失败"];
+    if (!validLevels.includes(level)) {
+      return `无效的成功等级。可用等级：${validLevels.join("、")}`;
+    }
+    if (!session?.userId) {
+      return "无法获取用户信息，请确保在正确的环境下使用此指令";
+    }
+    const groupId = session.guildId ? session.guildId : "私聊";
+    const replies = text.split("&").map((item) => item.trim()).filter((item) => item.length > 0);
+    if (replies.length === 0) {
+      return "未提供有效的回复文本";
+    }
+    const addedResponses = [];
+    for (const reply of replies) {
+      const result = await ctx.database.create("maple-dice-responses", {
+        level,
+        content: reply,
+        author: session.userId,
+        group: groupId,
+        created: /* @__PURE__ */ new Date()
+      });
+      addedResponses.push(result);
+    }
+    return `成功为"${level}"添加了 ${replies.length} 条自定义回复（群组: ${groupId}）
+新增内容:
+${addedResponses.map((r, i) => `${i + 1}. [ID:${r.id}] ${r.content}`).join("\n")}`;
+  });
+  ctx.command("查看自定义回复 [options]", "查看自定义回复").alias("查看回复").option("mode", "-m  查看由本人添加的所有自定义回复").option("group", "-g  查看当前群组内添加的所有自定义回复（私聊时，仅调用本人私聊添加的所有自定义回复）").option("all", "-a  查看所有自定义回复").example("查看自定义回复 -g        查看当前群组内的自定义回复（默认）").example("查看自定义回复 -m        查看由本人添加的自定义回复").action(async ({ session, options }, level) => {
+    let mode = "group";
+    if (options?.all) {
+      mode = "all";
+    } else if (options?.mode) {
+      mode = "personal";
+    } else if (options?.group) {
+      mode = "group";
+    }
+    const isPrivate = !session?.guildId;
+    const userId = session?.userId;
+    const groupId = isPrivate ? "私聊" : session?.guildId;
+    const query = {};
+    if (level) {
+      const validLevels = ["大成功", "极难成功", "困难成功", "成功", "失败", "大失败"];
+      if (!validLevels.includes(level)) {
+        return `无效的成功等级。可用等级：${validLevels.join("、")}`;
+      }
+      query.level = level;
+    }
+    switch (mode) {
+      case "personal":
+        if (!userId) {
+          return "无法获取用户信息，请确保在正确的环境下使用此指令";
+        }
+        query.author = userId;
+        break;
+      case "group":
+        if (!groupId) {
+          return "无法获取群组信息，请确保在正确的环境下使用此指令";
+        }
+        query.group = groupId;
+        break;
+      case "all":
+        break;
+    }
+    const responses = await ctx.database.get("maple-dice-responses", query);
+    if (responses.length === 0) {
+      const modeText = {
+        "all": "所有",
+        "group": `当前${isPrivate ? "私聊" : "群组"}`,
+        "personal": "本人"
+      }[mode];
+      const levelText = level ? `"${level}"` : "";
+      return `${modeText}${levelText}暂无自定义回复，请使用"添加自定义回复"指令添加`;
+    }
+    const grouped = {};
+    for (const response of responses) {
+      if (!grouped[response.level]) {
+        grouped[response.level] = [];
+      }
+      grouped[response.level].push(response);
+    }
+    for (const levelName in grouped) {
+      grouped[levelName].sort((a, b) => a.id - b.id);
+    }
+    if (level) {
+      const levelResponses = grouped[level] || [];
+      const modeText = {
+        "all": "所有",
+        "group": `当前${isPrivate ? "私聊" : "群组"}`,
+        "personal": "本人"
+      }[mode];
+      let output = `${modeText}"${level}"（${levelResponses.length}条）:
+`;
+      output += levelResponses.map((r, index) => {
+        const isOwner = userId && r.author === userId;
+        return `${index + 1}. [ID:${r.id}] ${r.content} ${isOwner ? "(可修改)" : ""}`;
+      }).join("\n");
+      return output;
+    } else {
+      const modeText = {
+        "all": "所有",
+        "group": `当前${isPrivate ? "私聊" : "群组"}`,
+        "personal": "本人"
+      }[mode];
+      let output = `${modeText}自定义回复:
+
+`;
+      const levelNames = ["大成功", "极难成功", "困难成功", "成功", "失败", "大失败"];
+      for (const levelName of levelNames) {
+        const levelResponses = grouped[levelName] || [];
+        if (levelResponses.length > 0) {
+          output += `"${levelName}"（${levelResponses.length}条）:
+`;
+          output += levelResponses.map((r, index) => {
+            const isOwner = userId && r.author === userId;
+            return `${index + 1}. [ID:${r.id}] ${r.content} ${isOwner ? "(可修改)" : ""}`;
+          }).join("\n");
+          output += "\n\n";
+        }
+      }
+      return output.trim();
+    }
+  });
+  ctx.command("删除自定义回复 <id:number>", '删除自定义回复（ID可从"查看自定义回复 -m"中查看）').alias("删除回复").example("删除自定义回复 1   删除ID为1的回复").action(async ({ session }, id) => {
+    if (!session?.userId) {
+      return "无法获取用户信息，请确保在正确的环境下使用此指令";
+    }
+    const existing = await ctx.database.get("maple-dice-responses", { id });
+    if (existing.length === 0) {
+      return `未找到ID为${id}的回复`;
+    }
+    const response = existing[0];
+    if (response.author !== session.userId) {
+      return `无法删除此回复，您只能删除自己添加的回复。
+输入"查看自定义回复 -m"查看由自己添加的回复`;
+    }
+    const contentToDelete = response.content;
+    const level = response.level;
+    await ctx.database.remove("maple-dice-responses", { id });
+    return `已删除"${level}"的回复(ID: ${id}):
+${contentToDelete}`;
+  });
+  ctx.command("修改自定义回复 <id:number> <text:string>", '修改自定义回复（ID可从"查看自定义回复 -m"中查看）').alias("修改回复").example("修改自定义回复 1 新的回复内容").action(async ({ session }, id, text) => {
+    if (!session?.userId) {
+      return "无法获取用户信息，请确保在正确的环境下使用此指令";
+    }
+    const existing = await ctx.database.get("maple-dice-responses", { id });
+    if (existing.length === 0) {
+      return `未找到ID为${id}的回复`;
+    }
+    const response = existing[0];
+    if (response.author !== session.userId) {
+      return `无法修改此回复，您只能修改自己添加的回复。
+输入"查看自定义回复 -m"查看由自己添加的回复`;
+    }
+    if (!text.trim()) {
+      return "新回复内容不能为空";
+    }
+    const oldContent = response.content;
+    const level = response.level;
+    await ctx.database.set("maple-dice-responses", { id }, {
+      content: text.trim(),
+      created: /* @__PURE__ */ new Date()
+      // 更新修改时间
     });
+    return `已修改"${level}"的回复(ID: ${id}):
+原内容: ${oldContent}
+新内容: ${text.trim()}`;
+  });
+  ctx.command("清空自定义回复 [options]", "清空自定义回复").alias("清空回复").option("all", "-a  清空所有自定义回复(默认)").option("me", "-m  清空自己添加的自定义回复").option("user", "-u <userId:string>  清空指定用户添加的所有自定义回复").option("thisGroup", "-tg  清空当前群聊的自定义回复").option("group", "-g <groupId:string>  清空指定群内的所有自定义回复").action(async ({ session, options }) => {
+    const userId = session?.userId;
+    const groupId = session?.guildId || "私聊";
+    const authorOptions = [];
+    if (options?.all) authorOptions.push("-a");
+    if (options?.me) authorOptions.push("-m");
+    if (options?.user) authorOptions.push("-u");
+    if (authorOptions.length > 1) {
+      return `选项冲突：${authorOptions.join("、")}不能同时使用，请在[-a、-m、-u]中选择一个`;
+    }
+    const groupOptions = [];
+    if (options?.thisGroup) groupOptions.push("-tg");
+    if (options?.group) groupOptions.push("-g");
+    if (options?.thisGroup && options?.group) {
+      return "选项冲突：-tg和-g不能同时使用，请在[-a、-tg、-g]中选择一个";
+    }
+    let authorQuery = "all";
+    let authorValue = void 0;
+    if (options?.all) {
+      authorQuery = "all";
+    } else if (options?.me) {
+      if (!userId) {
+        return "无法获取用户信息，请确保在正确的环境下使用此指令";
+      }
+      authorQuery = "me";
+      authorValue = userId;
+    } else if (options?.user) {
+      authorQuery = "user";
+      authorValue = options.user;
+    }
+    let groupQuery = "all";
+    let groupValue = void 0;
+    if (options?.all) {
+      groupQuery = "all";
+    } else if (options?.thisGroup) {
+      groupQuery = "thisGroup";
+      groupValue = groupId;
+    } else if (options?.group) {
+      groupQuery = "group";
+      groupValue = options.group;
+    }
+    let query = {};
+    let description = "";
+    switch (authorQuery) {
+      case "all":
+        description += "所有用户";
+        break;
+      case "me":
+        query.author = authorValue;
+        description += "自己";
+        break;
+      case "user":
+        query.author = authorValue;
+        description += `用户 ${authorValue}`;
+        break;
+    }
+    switch (groupQuery) {
+      case "all":
+        description += "的所有群组";
+        break;
+      case "thisGroup":
+        if (authorQuery === "all") {
+          description = `${groupId === "私聊" ? "私聊" : "当前群组"}`;
+        } else {
+          description += `在${groupId === "私聊" ? "私聊" : "当前群组"}内`;
+        }
+        query.group = groupValue;
+        break;
+      case "group":
+        if (authorQuery === "all") {
+          description = `群组 ${groupValue}`;
+        } else {
+          description += `在群组 ${groupValue} 内`;
+        }
+        query.group = groupValue;
+        break;
+    }
+    const responses = await ctx.database.get("maple-dice-responses", query);
+    const count = responses.length;
+    if (count === 0) {
+      return `没有找到符合条件的自定义回复`;
+    }
+    await ctx.database.remove("maple-dice-responses", query);
+    return `已清空 ${count} 条${description}的自定义回复`;
+  });
+  ctx.on("ready", () => {
+    console.log("maple-dice-v2 插件已加载完成");
+    ctx.logger("maple-dice-v2").info(`默认技能值: ${config.defaultSkill}`);
+    ctx.logger("maple-dice-v2").info(`回复模式: ${config.replyMode}`);
+  });
 }
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name,
+  using
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-maple-dice-v2",
   "description": "-",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/lib/index.d.ts

@@ -1,23 +0,0 @@
-import { Context, Schema } from 'koishi';
-export declare const name = "maple-dice-v2";
-export declare const using: readonly ["database"];
-declare module 'koishi' {
-    interface Tables {
-        'maple-dice-responses': DiceResponse;
-    }
-}
-interface DiceResponse {
-    id: number;
-    level: string;
-    content: string;
-    author: string;
-    group: string;
-    created: Date;
-}
-export interface Config {
-    defaultSkill: number;
-    replyMode: 'global' | 'group' | 'personal';
-}
-export declare const Config: Schema<Config>;
-export declare function apply(ctx: Context, config: Config): void;
-export {};