koishi-plugin-roulettes 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 forgetmelody
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+import { Context, Schema } from 'koishi';
+declare module 'koishi' {
+    interface Tables {
+        roulettes: Roulette;
+        roulette_groups: RouletteGroup;
+    }
+}
+export interface Roulette {
+    id: number;
+    items: string[];
+}
+export interface RouletteGroup {
+    id: number;
+    name: string;
+    items: number[];
+}
+export declare const name = "roulettes";
+export declare const inject: {
+    required: string[];
+};
+export interface Config {
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, _config: Config): void;

package/lib/index.js

@@ -0,0 +1,266 @@
+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,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var name = "roulettes";
+var inject = {
+  required: ["database"]
+};
+var Config = import_koishi.Schema.object({});
+function apply(ctx, _config) {
+  ctx.model.extend("roulettes", {
+    id: "unsigned",
+    items: "list"
+  }, {
+    primary: "id",
+    autoInc: true
+  });
+  ctx.model.extend("roulette_groups", {
+    id: "unsigned",
+    name: "string",
+    items: "json"
+  }, {
+    primary: "id",
+    autoInc: true
+  });
+  ctx.command("roulette/创建轮盘 <items:text>", "创建轮盘（用逗号分隔选项）", { authority: 3 }).action(async ({ session }, items) => {
+    if (!items) return "请输入轮盘选项，用逗号分隔。\n示例：roulette/创建轮盘 选项1,选项2,选项3";
+    const itemsArray = items.split(",").map((item) => item.trim()).filter((item) => item);
+    if (itemsArray.length === 0) return "至少需要一个有效的选项";
+    try {
+      const roulette = await ctx.model.create("roulettes", {
+        items: itemsArray
+      });
+      return `轮盘创建成功！ID: ${roulette.id}
+包含选项：${itemsArray.join("、")}`;
+    } catch (error) {
+      return "创建轮盘失败：" + error.message;
+    }
+  });
+  ctx.command("roulette/轮盘列表 [page:number]", "查看轮盘列表").option("group", "-g 查看轮盘组列表").action(async ({ session, options }, page = 1) => {
+    const pageSize = 10;
+    if (options.group) {
+      const groups = await ctx.model.get("roulette_groups", {});
+      const total = groups.length;
+      const start = (page - 1) * pageSize;
+      const end = start + pageSize;
+      const pagedGroups = groups.slice(start, end);
+      if (pagedGroups.length === 0) {
+        return "暂无轮盘组";
+      }
+      let message = "轮盘组列表：\n";
+      pagedGroups.forEach((group) => {
+        message += `ID: ${group.id} | 名称: ${group.name} | 包含轮盘数: ${group.items.length}
+`;
+      });
+      message += `
+第${page}页，共${Math.ceil(total / pageSize)}页`;
+      return message;
+    } else {
+      const roulettes = await ctx.model.get("roulettes", {});
+      const total = roulettes.length;
+      const start = (page - 1) * pageSize;
+      const end = start + pageSize;
+      const pagedRoulettes = roulettes.slice(start, end);
+      if (pagedRoulettes.length === 0) {
+        return "暂无轮盘";
+      }
+      let message = "轮盘列表：\n";
+      pagedRoulettes.forEach((roulette) => {
+        message += `ID: ${roulette.id} | 选项数: ${roulette.items.length}
+`;
+        message += `选项: ${roulette.items.join("、")}
+
+`;
+      });
+      message += `第${page}页，共${Math.ceil(total / pageSize)}页`;
+      return message;
+    }
+  });
+  ctx.command("roulette/创建轮盘组 <name> <rouletteIds:text>", "创建轮盘组（轮盘ID用逗号分隔）", { authority: 3 }).action(async ({ session }, name2, rouletteIds) => {
+    if (!name2) return "请输入轮盘组名称";
+    if (!rouletteIds) return "请输入轮盘ID，用逗号分隔";
+    const ids = rouletteIds.split(",").map((id) => parseInt(id.trim())).filter((id) => !isNaN(id));
+    if (ids.length === 0) return "至少需要一个有效的轮盘ID";
+    for (const id of ids) {
+      const roulette = await ctx.model.get("roulettes", { id });
+      if (!roulette || roulette.length === 0) {
+        return `轮盘 ID ${id} 不存在`;
+      }
+    }
+    try {
+      const existingGroup = await ctx.model.get("roulette_groups", { name: name2 });
+      if (existingGroup && existingGroup.length > 0) {
+        return "轮盘组名称已存在";
+      }
+      const group = await ctx.model.create("roulette_groups", {
+        name: name2,
+        items: ids
+      });
+      return `轮盘组创建成功！
+名称: ${group.name}
+ID: ${group.id}
+包含轮盘: ${ids.join("、")}`;
+    } catch (error) {
+      return "创建轮盘组失败：" + error.message;
+    }
+  });
+  ctx.command("roulette/轮盘抽奖 <target>", "抽奖（输入轮盘ID或轮盘组名称）").option("count", "-c <count:number> 抽奖次数，默认1次", { fallback: 1 }).action(async ({ session, options }, target) => {
+    if (!target) return "请输入轮盘ID（数字）或轮盘组名称（中文）";
+    const count = Math.min(Math.max(1, options.count || 1), 10);
+    const isNumeric = /^\d+$/.test(target);
+    if (isNumeric) {
+      const roulette = await ctx.model.get("roulettes", { id: parseInt(target) });
+      if (!roulette || roulette.length === 0) {
+        return `轮盘 ID ${target} 不存在`;
+      }
+      const items = roulette[0].items;
+      if (items.length === 0) {
+        return "该轮盘没有可抽奖的选项";
+      }
+      const results = [];
+      for (let i = 0; i < count; i++) {
+        const randomIndex = Math.floor(Math.random() * items.length);
+        results.push(items[randomIndex]);
+      }
+      let message = `轮盘 ID: ${target}
+抽奖结果：
+`;
+      if (count === 1) {
+        message += `🎉 ${results[0]} 🎉`;
+      } else {
+        results.forEach((result, index) => {
+          message += `${index + 1}. ${result}
+`;
+        });
+      }
+      return message;
+    } else {
+      if (count !== 1) {
+        return "轮盘组抽奖不支持指定次数，将从组内每个轮盘各抽取一个结果";
+      }
+      const groups = await ctx.model.get("roulette_groups", { name: target });
+      if (!groups || groups.length === 0) {
+        return `轮盘组 "${target}" 不存在`;
+      }
+      const group = groups[0];
+      const rouletteIds = group.items;
+      if (!rouletteIds || rouletteIds.length === 0) {
+        return "该轮盘组没有包含任何轮盘";
+      }
+      const roulettes = await Promise.all(
+        rouletteIds.map(async (id) => {
+          const roulette = await ctx.model.get("roulettes", { id });
+          return roulette && roulette.length > 0 ? roulette[0] : null;
+        })
+      );
+      const validRoulettes = roulettes.filter((roulette) => roulette !== null);
+      if (validRoulettes.length === 0) {
+        return "轮盘组中的所有轮盘均已不存在";
+      }
+      const results = validRoulettes.map((roulette) => {
+        if (roulette.items.length === 0) {
+          return { id: roulette.id, result: "（无选项）" };
+        }
+        const randomIndex = Math.floor(Math.random() * roulette.items.length);
+        return { id: roulette.id, result: roulette.items[randomIndex] };
+      });
+      let message = `轮盘组: ${target}
+抽奖结果（从${results.length}个轮盘中各抽取1个）：
+
+`;
+      results.forEach((item, index) => {
+        message += `${index + 1}. [轮盘ID: ${item.id}] ${item.result}
+`;
+      });
+      return message;
+    }
+  });
+  ctx.command("roulette/删除轮盘 <id:number>", "删除轮盘", { authority: 3 }).option("group", "-g 删除轮盘组").action(async ({ session, options }, id) => {
+    if (!id) return "请输入要删除的ID";
+    if (options.group) {
+      const deleted = await ctx.model.remove("roulette_groups", { id });
+      if (deleted) {
+        return "轮盘组删除成功";
+      } else {
+        return "轮盘组不存在";
+      }
+    } else {
+      const deleted = await ctx.model.remove("roulettes", { id });
+      if (deleted) {
+        return "轮盘删除成功";
+      } else {
+        return "轮盘不存在";
+      }
+    }
+  });
+  ctx.command("roulette/轮盘详情 <target>", "查看轮盘或轮盘组详情").action(async ({ session }, target) => {
+    if (!target) return "请输入轮盘ID（数字）或轮盘组名称（中文）";
+    const isNumeric = /^\d+$/.test(target);
+    if (isNumeric) {
+      const roulette = await ctx.model.get("roulettes", { id: parseInt(target) });
+      if (!roulette || roulette.length === 0) {
+        return `轮盘 ID ${target} 不存在`;
+      }
+      const data = roulette[0];
+      return `轮盘 ID: ${data.id}
+选项数: ${data.items.length}
+选项列表：
+${data.items.map((item, index) => `${index + 1}. ${item}`).join("\n")}`;
+    } else {
+      const group = await ctx.model.get("roulette_groups", { name: target });
+      if (!group || group.length === 0) {
+        return `轮盘组 "${target}" 不存在`;
+      }
+      const data = group[0];
+      let roulettesInfo = "";
+      for (const rouletteId of data.items) {
+        const roulette = await ctx.model.get("roulettes", { id: rouletteId });
+        if (roulette && roulette.length > 0) {
+          roulettesInfo += `
+  - 轮盘 ID ${rouletteId}: ${roulette[0].items.length} 个选项`;
+        } else {
+          roulettesInfo += `
+  - 轮盘 ID ${rouletteId}: 已删除`;
+        }
+      }
+      return `轮盘组: ${data.name}
+ID: ${data.id}
+包含轮盘数: ${data.items.length}
+轮盘列表：${roulettesInfo}`;
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "koishi-plugin-roulettes",
+  "description": "轮盘抽奖系统插件，支持创建轮盘、轮盘组，进行抽奖操作，查看和管理轮盘数据",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forgetmelodyXL/roulettes.git"
+  },
+  "author": "forgetmelodyXL",
+  "bugs": {
+    "url": "https://github.com/forgetmelodyXL/roulettes/issues"
+  },
+  "homepage": "https://github.com/forgetmelodyXL/roulettes#readme",
+  "version": "1.0.0",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,217 @@
+# koishi-plugin-roulettes
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-roulettes?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-roulettes)
+
+轮盘抽奖系统插件，支持创建轮盘、轮盘组，进行抽奖操作，查看和管理轮盘数据。
+
+## 功能特性
+
+- ✅ 创建轮盘（支持多个选项，用逗号分隔）
+- ✅ 创建轮盘组（包含多个轮盘）
+- ✅ 查看轮盘列表和轮盘组列表
+- ✅ 进行抽奖（支持指定次数，1-10次）
+- ✅ 删除轮盘和轮盘组
+- ✅ 查看单个轮盘或轮盘组的详情
+- ✅ 轮盘组抽奖（从组内每个轮盘各抽取一个结果）
+
+## 安装
+
+```bash
+npm install koishi-plugin-roulettes
+```
+
+## 配置
+
+该插件无需特殊配置，只需确保你的 Koishi 应用已配置好数据库。
+
+```js
+// koishi.config.js
+module.exports = {
+  plugins: [
+    'roulettes'
+  ]
+}
+```
+
+## 使用方法
+
+### 1. 创建轮盘
+
+使用 `roulette/创建轮盘` 指令创建一个新的轮盘，用逗号分隔选项。
+
+**示例：**
+```
+roulette/创建轮盘 选项1,选项2,选项3
+```
+
+**权限要求：** 权限等级 3
+
+### 2. 创建轮盘组
+
+使用 `roulette/创建轮盘组` 指令创建一个新的轮盘组，指定名称和轮盘ID（用逗号分隔）。
+
+**示例：**
+```
+roulette/创建轮盘组 幸运抽奖 1,2,3
+```
+
+**权限要求：** 权限等级 3
+
+### 3. 查看轮盘列表
+
+使用 `roulette/轮盘列表` 指令查看所有轮盘的列表。
+
+**示例：**
+```
+roulette/轮盘列表
+roulette/轮盘列表 2  // 查看第2页
+```
+
+### 4. 查看轮盘组列表
+
+使用 `roulette/轮盘列表 -g` 指令查看所有轮盘组的列表。
+
+**示例：**
+```
+roulette/轮盘列表 -g
+roulette/轮盘列表 -g 2  // 查看第2页
+```
+
+### 5. 进行抽奖
+
+使用 `roulette/轮盘抽奖` 指令进行抽奖，可以指定轮盘ID或轮盘组名称。
+
+**示例：**
+```
+roulette/轮盘抽奖 1  // 使用轮盘ID 1 抽奖
+roulette/轮盘抽奖 幸运抽奖  // 使用轮盘组 幸运抽奖 抽奖
+roulette/轮盘抽奖 1 -c 3  // 使用轮盘ID 1 抽奖3次
+```
+
+**注意：** 轮盘组抽奖不支持指定次数，会从组内每个轮盘中各抽取一个结果。
+
+### 6. 删除轮盘
+
+使用 `roulette/删除轮盘` 指令删除指定ID的轮盘。
+
+**示例：**
+```
+roulette/删除轮盘 1
+```
+
+**权限要求：** 权限等级 3
+
+### 7. 删除轮盘组
+
+使用 `roulette/删除轮盘 -g` 指令删除指定ID的轮盘组。
+
+**示例：**
+```
+roulette/删除轮盘 -g 1
+```
+
+**权限要求：** 权限等级 3
+
+### 8. 查看轮盘详情
+
+使用 `roulette/轮盘详情` 指令查看指定轮盘ID的详细信息。
+
+**示例：**
+```
+roulette/轮盘详情 1
+```
+
+### 9. 查看轮盘组详情
+
+使用 `roulette/轮盘详情` 指令查看指定轮盘组名称的详细信息。
+
+**示例：**
+```
+roulette/轮盘详情 幸运抽奖
+```
+
+## 指令列表
+
+| 指令 | 描述 | 权限要求 |
+|------|------|----------|
+| `roulette/创建轮盘 <items:text>` | 创建轮盘（用逗号分隔选项） | 3 |
+| `roulette/创建轮盘组 <name> <rouletteIds:text>` | 创建轮盘组（轮盘ID用逗号分隔） | 3 |
+| `roulette/轮盘列表 [page:number]` | 查看轮盘列表 | 无 |
+| `roulette/轮盘列表 -g [page:number]` | 查看轮盘组列表 | 无 |
+| `roulette/轮盘抽奖 <target>` | 抽奖（输入轮盘ID或轮盘组名称） | 无 |
+| `roulette/轮盘抽奖 <target> -c <count:number>` | 抽奖（指定次数，1-10次） | 无 |
+| `roulette/删除轮盘 <id:number>` | 删除轮盘 | 3 |
+| `roulette/删除轮盘 -g <id:number>` | 删除轮盘组 | 3 |
+| `roulette/轮盘详情 <target>` | 查看轮盘或轮盘组详情 | 无 |
+
+## 示例场景
+
+### 场景1：创建一个简单的轮盘并抽奖
+
+1. 创建轮盘：
+   ```
+   roulette/创建轮盘 一等奖,二等奖,三等奖,谢谢参与
+   ```
+
+2. 查看轮盘列表：
+   ```
+   roulette/轮盘列表
+   ```
+
+3. 进行抽奖：
+   ```
+   roulette/轮盘抽奖 1 -c 3
+   ```
+
+### 场景2：创建轮盘组并进行组抽奖
+
+1. 创建多个轮盘：
+   ```
+   roulette/创建轮盘 苹果,香蕉,橙子
+   roulette/创建轮盘 红色,蓝色,绿色
+   ```
+
+2. 创建轮盘组：
+   ```
+   roulette/创建轮盘组 水果颜色组合 1,2
+   ```
+
+3. 进行轮盘组抽奖：
+   ```
+   roulette/轮盘抽奖 水果颜色组合
+   ```
+
+## 数据库结构
+
+该插件会在数据库中创建两个表：
+
+### roulettes 表
+
+| 字段 | 类型 | 描述 |
+|------|------|------|
+| id | unsigned | 轮盘ID（自增主键） |
+| items | list | 轮盘选项列表 |
+
+### roulette_groups 表
+
+| 字段 | 类型 | 描述 |
+|------|------|------|
+| id | unsigned | 轮盘组ID（自增主键） |
+| name | string | 轮盘组名称 |
+| items | json | 包含的轮盘ID数组 |
+
+## 注意事项
+
+1. 轮盘抽奖次数限制为1-10次，超过限制会被自动调整到范围内。
+2. 轮盘组抽奖不支持指定次数，会从组内每个轮盘各抽取一个结果。
+3. 创建轮盘时，选项会自动过滤空值和空白字符。
+4. 创建轮盘组时，会验证所有指定的轮盘ID是否存在。
+5. 删除轮盘时，不会自动从轮盘组中移除该轮盘的引用，请手动管理轮盘组中的轮盘ID。
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request 来帮助改进这个插件！
+
+## 许可证
+
+MIT License