koishi-plugin-maple-dice-v2 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+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 {};

package/lib/index.js

@@ -0,0 +1,607 @@
+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('回复模式'),
+});
+// 等级名称到内部键的映射
+const levelNameToKey = {
+    '大成功': 'greatSuccess',
+    '大失败': 'greatFail',
+    '极难成功': 'extremeSuccess',
+    '困难成功': 'hardSuccess',
+    '成功': 'success',
+    '失败': 'fail'
+};
+const 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);
+    }
+}
+// 获取随机回复 - 从数据库读取
+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);
+}
+// 主插件函数
+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}`);
+    });
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "koishi-plugin-maple-dice-v2",
+  "description": "-",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "maple"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-maple-dice-v2
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-maple-dice-v2?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-maple-dice-v2)
+
+-