koishi-plugin-brick-qq 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,47 @@
+import { Context, Schema } from "koishi";
+export declare const name = "brick";
+export declare const usage = "windbullet\u5927\u4F6C\u7684brick\u63D2\u4EF6\u4F18\u5316\u7248\uFF0C\u6DFB\u52A0\u4E86\u4E00\u4E9B\u8FB9\u754C\u5224\u65AD\u548C\u66B4\u529B\u62CD\u4EBA\u529F\u80FD\u3002\n\u70E7\u5236\u7816\u5757\uFF0C\u7136\u540E\u62CD\u6655\u7FA4\u53CB\uFF01\n\u5982\u679C\u673A\u5668\u4EBA\u6CA1\u6709\u7981\u8A00\u7684\u6743\u9650\uFF0C\u5C06\u6539\u4E3A\u505C\u6B62\u54CD\u5E94\u88AB\u62CD\u6655\u7684\u7528\u6237\u76F8\u540C\u65F6\u95F4\uFF01\n\u5F00\u59CB\u70E7\u5236\u4E4B\u540E\uFF0C\u7FA4\u5185\u5176\u4ED6\u7FA4\u53CB\u53D1\u9001\u4E00\u5B9A\u6570\u91CF\u7684\u6D88\u606F\u5C31\u80FD\u5B8C\u6210\u70E7\u5236\uFF01\n\u70E7\u51FA\u6765\u7684\u7816\u5934\u4E0D\u80FD\u8DE8\u7FA4\u7528\u54E6\uFF01  ";
+export interface Brick {
+    id: number;
+    userId: string;
+    guildId: string;
+    brick: number;
+    lastSlap: number;
+    checkingDay: string;
+}
+export interface BrickCheckinStats {
+    id: number;
+    userId: string;
+    totalCheckins: number;
+    streakDays: number;
+    lastCheckinDay: string;
+}
+declare module "koishi" {
+    interface Channel {
+        brickEnabled: boolean;
+    }
+    interface Tables {
+        brick: Brick;
+        brick_checkin_stats: BrickCheckinStats;
+    }
+}
+interface SpecialUser {
+    [userId: string]: number;
+}
+export interface Config {
+    maxBrick: number;
+    cost: number;
+    cooldown: number;
+    minMuteTime: number;
+    maxMuteTime: number;
+    ignoreMuted: boolean;
+    reverse: number;
+    specialUser: SpecialUser;
+    checking: boolean;
+    minGain?: number;
+    maxGain?: number;
+}
+export declare const Config: Schema<Config>;
+export declare const inject: string[];
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+export {};

package/lib/index.js

@@ -0,0 +1,469 @@
+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,
+  usage: () => usage
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_adapter_qq = require("@satorijs/adapter-qq");
+var name = "brick";
+var usage = `windbullet大佬的brick插件优化版，添加了一些边界判断和暴力拍人功能。
+烧制砖块，然后拍晕群友！
+如果机器人没有禁言的权限，将改为停止响应被拍晕的用户相同时间！
+开始烧制之后，群内其他群友发送一定数量的消息就能完成烧制！
+烧出来的砖头不能跨群用哦！  `;
+var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    maxBrick: import_koishi.Schema.number().default(1).min(1).description("砖块最多持有量"),
+    cost: import_koishi.Schema.number().required().min(1).description("多少条消息能烧好一块砖"),
+    cooldown: import_koishi.Schema.number().default(60).min(0).description("拍砖冷却时间（秒）"),
+    minMuteTime: import_koishi.Schema.number().default(10).min(1).description("最小禁言时间（秒）"),
+    maxMuteTime: import_koishi.Schema.number().default(120).min(1).description("最大禁言时间（秒）"),
+    ignoreMuted: import_koishi.Schema.boolean().default(false).description("是否不使用内置计时器判断用户是否被禁言（开启时，用户被拍晕后未被禁言也能正常使用bot以及再被拍晕）"),
+    reverse: import_koishi.Schema.number().default(10).min(0).max(100).description("反被拍晕的默认概率（%）"),
+    specialUser: import_koishi.Schema.dict(Number).role("table").description("键为用户ID，值为被拍时的反击概率（%）<br/>不设置则使用默认概率")
+  }),
+  import_koishi.Schema.object({
+    checking: import_koishi.Schema.boolean().default(false).description("是否开启每日签到（获取随机数量的砖头）")
+  }),
+  import_koishi.Schema.union([
+    import_koishi.Schema.object({
+      checking: import_koishi.Schema.const(true).required(),
+      minGain: import_koishi.Schema.number().required().min(0).description("最小获取数量（不可为负数）"),
+      maxGain: import_koishi.Schema.number().required().min(0).description("最大获取数量")
+    }),
+    import_koishi.Schema.object({
+      checking: import_koishi.Schema.const(false)
+    })
+  ])
+]);
+var inject = ["database"];
+async function apply(ctx, config) {
+  ctx.model.extend("channel", {
+    brickEnabled: { type: "boolean", initial: true }
+  });
+  ctx.model.extend(
+    "brick",
+    {
+      id: "unsigned",
+      userId: "string",
+      guildId: "string",
+      brick: "integer",
+      lastSlap: "unsigned",
+      checkingDay: "string"
+    },
+    { primary: "id", autoInc: true, unique: [["userId", "guildId"]] }
+  );
+  ctx.model.extend(
+    "brick_checkin_stats",
+    {
+      id: "unsigned",
+      userId: "string",
+      totalCheckins: "unsigned",
+      streakDays: "unsigned",
+      lastCheckinDay: "string"
+    },
+    { primary: "id", autoInc: true, unique: [["userId"]] }
+  );
+  const users = {};
+  function tryCleanupUser(key) {
+    const status = users[key];
+    if (status && !status.burning && !status.muted) {
+      delete users[key];
+    }
+  }
+  __name(tryCleanupUser, "tryCleanupUser");
+  function getBrickChannel(session) {
+    return session.channel;
+  }
+  __name(getBrickChannel, "getBrickChannel");
+  function ensureBrickEnabled(session) {
+    if (getBrickChannel(session).brickEnabled === false) {
+      return "本群未开启砖头功能";
+    }
+  }
+  __name(ensureBrickEnabled, "ensureBrickEnabled");
+  ctx.guild().command("砖头");
+  ctx.guild().command("开启砖头", "开启本群砖头功能").channelFields(["brickEnabled"]).action(async ({ session }) => {
+    const channel = getBrickChannel(session);
+    if (channel.brickEnabled) {
+      return "本群已开启砖头功能";
+    }
+    channel.brickEnabled = true;
+    return "砖头功能开启成功";
+  });
+  ctx.guild().command("关闭砖头", "关闭本群砖头功能").channelFields(["brickEnabled"]).action(async ({ session }) => {
+    const channel = getBrickChannel(session);
+    if (channel.brickEnabled === false) {
+      return "本群已关闭砖头功能";
+    }
+    channel.brickEnabled = false;
+    return "砖头功能关闭成功";
+  });
+  ctx.guild().command("砖头.烧砖", "烧点砖头拍人").alias("烧砖").channelFields(["brickEnabled"]).action(async ({ session }) => {
+    const disabledMessage = ensureBrickEnabled(session);
+    if (disabledMessage) return disabledMessage;
+    const user = `${session.guildId}:${session.userId}`;
+    if (!users[user]) {
+      users[user] = { burning: false, muted: false };
+    }
+    const userData = await ctx.database.get("brick", {
+      userId: session.userId,
+      guildId: session.guildId
+    });
+    if (userData.length === 0) {
+      await ctx.database.create("brick", {
+        userId: session.userId,
+        guildId: session.guildId,
+        brick: 0
+      });
+    } else if (userData[0].brick >= config.maxBrick) {
+      return `你最多只能拥有${config.maxBrick}块砖`;
+    }
+    if (users[user]?.muted && !config.ignoreMuted) {
+      return "你还在晕着呢，不能烧砖哦";
+    }
+    if (users[user]?.burning) {
+      return `已经在烧砖了`;
+    }
+    users[user].burning = true;
+    await session.send(`现在开始烧砖啦，群友每发送${config.cost}条消息就烧好一块砖`);
+    let messageCount = 0;
+    const dispose = ctx.guild(session.guildId).middleware(async (session_in, next) => {
+      if (![session.selfId, session.userId].includes(session_in.userId)) {
+        messageCount += 1;
+        if (messageCount >= config.cost) {
+          dispose();
+          await ctx.database.upsert(
+            "brick",
+            (row) => [
+              {
+                userId: session.userId,
+                guildId: session.guildId,
+                brick: import_koishi.$.add(row.brick, 1)
+              }
+            ],
+            ["userId", "guildId"]
+          );
+          users[user].burning = false;
+          tryCleanupUser(user);
+          await session.qq.sendMessage(session.channelId, {
+            msg_type: import_adapter_qq.QQ.Message.Type.MARKDOWN,
+            msg_id: session.messageId,
+            markdown: {
+              content: `<qqbot-at-user id="${session.userId}" /> 砖已经烧好啦`
+            }
+          });
+          return;
+        }
+      }
+      return next();
+    }, true);
+  });
+  ctx.guild().command("砖头.拍人 <user:user>", "拍晕（禁言）对方随机时间，有概率被反将一军", { checkArgCount: true }).alias("拍人").example("拍人 @koishi").channelFields(["brickEnabled"]).action(async ({ session }, user) => {
+    const disabledMessage = ensureBrickEnabled(session);
+    if (disabledMessage) return disabledMessage;
+    if (!user) return "你要拍谁呢？拍人 @用户";
+    const targetUserId = user.split(":")[1];
+    const userKey = `${session.guildId}:${session.userId}`;
+    const targetUserKey = `${session.guildId}:${targetUserId}`;
+    if (targetUserId === session.userId) {
+      return "不能拍自己哦";
+    }
+    if (!users[userKey]) {
+      users[userKey] = { burning: false, muted: false };
+    }
+    if (!users[targetUserKey]) {
+      users[targetUserKey] = { burning: false, muted: false };
+    }
+    const brickData = await ctx.database.get("brick", {
+      userId: session.userId,
+      guildId: session.guildId
+    });
+    if (brickData.length === 0 || brickData[0].brick <= 0) {
+      return "你在这个群还没有砖头，使用 砖头.烧砖 烧点砖头吧";
+    }
+    const lastSlap = brickData[0].lastSlap || 0;
+    const diff = Math.trunc(Date.now() / 1e3 - lastSlap);
+    if (lastSlap > 0 && diff < config.cooldown) {
+      return `${Math.abs(diff - config.cooldown)} 秒后才能再拍人哦`;
+    }
+    if (users[targetUserKey].muted && !config.ignoreMuted) {
+      return "他已经晕了...";
+    }
+    await ctx.database.upsert(
+      "brick",
+      (row) => [
+        {
+          userId: session.userId,
+          guildId: session.guildId,
+          brick: import_koishi.$.subtract(row.brick, 1),
+          // 使用 Math.trunc 确保存入整数，与 unsigned 类型一致
+          lastSlap: Math.trunc(Date.now() / 1e3)
+        }
+      ],
+      ["userId", "guildId"]
+    );
+    const muteTime = import_koishi.Random.int(config.minMuteTime, config.maxMuteTime + 1);
+    const muteTimeMs = muteTime * 1e3;
+    const probability = config.specialUser[targetUserId] !== void 0 ? config.specialUser[targetUserId] / 100 : config.reverse / 100;
+    if (import_koishi.Random.bool(probability)) {
+      await slap(session.userId);
+      session.qq.sendMessage(session.channelId, {
+        msg_type: import_adapter_qq.QQ.Message.Type.MARKDOWN,
+        msg_id: session.messageId,
+        markdown: {
+          content: `<qqbot-at-user id="${targetUserId}" />夺过你的砖头，把你拍晕了 ${muteTime} 秒`
+        }
+      });
+      return;
+    } else {
+      await slap(targetUserId);
+      session.qq.sendMessage(session.channelId, {
+        msg_type: import_adapter_qq.QQ.Message.Type.MARKDOWN,
+        msg_id: session.messageId,
+        markdown: {
+          content: `<qqbot-at-user id="${targetUserId}" /> 你被 <qqbot-at-user id="${session.userId}" /> 拍晕了 ${muteTime} 秒`
+        }
+      });
+      return;
+    }
+    async function slap(slapedUserId) {
+      users[`${session.guildId}:${slapedUserId}`].muted = true;
+      try {
+        await session.bot.muteGuildMember(session.guildId, slapedUserId, muteTimeMs);
+      } catch {
+      }
+      if (!config.ignoreMuted) {
+        silent(slapedUserId, muteTimeMs);
+      }
+    }
+    __name(slap, "slap");
+    function silent(slapedUserId, time) {
+      const dispose = ctx.guild(session.guildId).middleware((ses, next) => {
+        if (ses.userId !== slapedUserId) {
+          return next();
+        }
+      }, true);
+      ctx.setTimeout(() => {
+        dispose();
+        const key = `${session.guildId}:${slapedUserId}`;
+        if (users[key]) {
+          users[key].muted = false;
+          tryCleanupUser(key);
+        }
+      }, time);
+    }
+    __name(silent, "silent");
+  });
+  ctx.guild().command("砖头.暴力拍人 <user:user>", "消耗双倍砖头，100%拍晕对方", { checkArgCount: true }).alias("暴力拍人").example("暴力拍人 @刀豆").channelFields(["brickEnabled"]).action(async ({ session }, user) => {
+    const disabledMessage = ensureBrickEnabled(session);
+    if (disabledMessage) return disabledMessage;
+    if (!user) return "你要拍谁呢？拍人 @用户";
+    const targetUserId = user.split(":")[1];
+    const userKey = `${session.guildId}:${session.userId}`;
+    const targetUserKey = `${session.guildId}:${targetUserId}`;
+    if (targetUserId === session.userId) {
+      return "不能拍自己哦";
+    }
+    if (!users[userKey]) {
+      users[userKey] = { burning: false, muted: false };
+    }
+    if (!users[targetUserKey]) {
+      users[targetUserKey] = { burning: false, muted: false };
+    }
+    const brickData = await ctx.database.get("brick", {
+      userId: session.userId,
+      guildId: session.guildId
+    });
+    if (brickData.length === 0 || brickData[0].brick < 2) {
+      return "暴力拍人需要 2 块砖头，你的砖头不够哦";
+    }
+    const lastSlap = brickData[0].lastSlap || 0;
+    const diff = Math.trunc(Date.now() / 1e3 - lastSlap);
+    if (lastSlap > 0 && diff < config.cooldown) {
+      return `${Math.abs(diff - config.cooldown)} 秒后才能再拍人哦`;
+    }
+    if (users[targetUserKey].muted && !config.ignoreMuted) {
+      return "他已经晕了...";
+    }
+    await ctx.database.upsert(
+      "brick",
+      (row) => [
+        {
+          userId: session.userId,
+          guildId: session.guildId,
+          brick: import_koishi.$.subtract(row.brick, 2),
+          // 使用 Math.trunc 确保存入整数，与 unsigned 类型一致
+          lastSlap: Math.trunc(Date.now() / 1e3)
+        }
+      ],
+      ["userId", "guildId"]
+    );
+    const muteTime = import_koishi.Random.int(config.minMuteTime, config.maxMuteTime + 1) * 3;
+    const muteTimeMs = muteTime * 1e3;
+    users[targetUserKey].muted = true;
+    try {
+      await session.bot.muteGuildMember(session.guildId, targetUserId, muteTimeMs);
+    } catch {
+    }
+    if (!config.ignoreMuted) {
+      const dispose = ctx.guild(session.guildId).middleware((ses, next) => {
+        if (ses.userId !== targetUserId) {
+          return next();
+        }
+      }, true);
+      ctx.setTimeout(() => {
+        dispose();
+        if (users[targetUserKey]) {
+          users[targetUserKey].muted = false;
+          tryCleanupUser(targetUserKey);
+        }
+      }, muteTimeMs);
+    }
+    session.qq.sendMessage(session.guildId, {
+      msg_type: import_adapter_qq.QQ.Message.Type.MARKDOWN,
+      msg_id: session.messageId,
+      markdown: {
+        content: `<qqbot-at-user id="${targetUserId}" />你被 <qqbot-at-user id="${session.userId}" /> 暴力拍晕了 ${muteTime} 秒！`
+      }
+    });
+    return;
+  });
+  ctx.guild().platform("onebot").command("砖头.随机拍人", "随机拍晕（禁言）某个群友随机时间，有概率被反将一军").alias("随机拍人").channelFields(["brickEnabled"]).action(async ({ session }) => {
+    const disabledMessage = ensureBrickEnabled(session);
+    if (disabledMessage) return disabledMessage;
+    const guildMember = [];
+    for await (const member of session.bot.getGuildMemberIter(session.guildId)) {
+      if (member?.user.id && member.user.id !== session.selfId && member.user.id !== session.userId) {
+        guildMember.push(member.user.id);
+      }
+    }
+    if (guildMember.length === 0) {
+      return "群里没有可以拍的人呢...";
+    }
+    await session.execute(`砖头.拍人 ${import_koishi.h.at(import_koishi.Random.pick(guildMember))}`);
+  });
+  ctx.guild().command("砖头.查看", "看看自己在这个群有多少砖头").alias("查看砖头").channelFields(["brickEnabled"]).action(async ({ session }) => {
+    const disabledMessage = ensureBrickEnabled(session);
+    if (disabledMessage) return disabledMessage;
+    const brickData = await ctx.database.get("brick", {
+      userId: session.userId,
+      guildId: session.guildId
+    });
+    if (brickData.length === 0 || brickData[0].brick === 0) {
+      return `你还没有砖头，使用 砖头.烧砖 烧点吧`;
+    } else {
+      return `你有 ${brickData[0].brick}/${config.maxBrick} 块砖头`;
+    }
+  });
+  if (config.checking) {
+    ctx.guild().command("砖头.签到").alias("砖头签到").action(async ({ session }) => {
+      const date = /* @__PURE__ */ new Date();
+      const today = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+      let brick = import_koishi.Random.int(config.minGain, config.maxGain + 1);
+      const userData = await ctx.database.get("brick", {
+        userId: session.userId,
+        guildId: session.guildId
+      });
+      const currentGroupData = userData[0];
+      const statsData = await ctx.database.get("brick_checkin_stats", {
+        userId: session.userId
+      });
+      let totalCheckins = 0;
+      let streakDays = 0;
+      let lastCheckinDay = "";
+      let globalAlreadyCheckedInToday = false;
+      if (statsData.length > 0) {
+        totalCheckins = statsData[0].totalCheckins || 0;
+        streakDays = statsData[0].streakDays || 0;
+        lastCheckinDay = statsData[0].lastCheckinDay || "";
+        globalAlreadyCheckedInToday = lastCheckinDay === today;
+      }
+      if (!globalAlreadyCheckedInToday) {
+        const yesterday = new Date(date);
+        yesterday.setDate(date.getDate() - 1);
+        const yesterdayText = `${yesterday.getFullYear()}-${yesterday.getMonth() + 1}-${yesterday.getDate()}`;
+        totalCheckins += 1;
+        streakDays = lastCheckinDay === yesterdayText ? streakDays + 1 : 1;
+        lastCheckinDay = today;
+        await ctx.database.upsert(
+          "brick_checkin_stats",
+          [
+            {
+              userId: session.userId,
+              totalCheckins,
+              streakDays,
+              lastCheckinDay
+            }
+          ],
+          ["userId"]
+        );
+      }
+      if (currentGroupData?.checkingDay === today) {
+        return `你今天在本群已经签到过了，总签到 ${totalCheckins} 天，连续签到 ${streakDays} 天`;
+      }
+      const currentBrick = currentGroupData?.brick || 0;
+      if (currentBrick + brick > config.maxBrick) {
+        brick = config.maxBrick - currentBrick;
+      } else if (currentBrick + brick < 0) {
+        brick = -currentBrick;
+      }
+      await ctx.database.upsert(
+        "brick",
+        (row) => [
+          {
+            userId: session.userId,
+            guildId: session.guildId,
+            brick: import_koishi.$.add(row.brick, brick),
+            checkingDay: today
+          }
+        ],
+        ["userId", "guildId"]
+      );
+      const currentTotalBrick = currentBrick + brick;
+      if (globalAlreadyCheckedInToday) {
+        if (brick > 0) {
+          return `签到成功，你获得了 ${brick} 块砖头，现在有 ${currentTotalBrick}/${config.maxBrick} 块砖头；总签到 ${totalCheckins} 天，连续签到 ${streakDays} 天`;
+        }
+        return `签到成功，但本群砖头已满，未获得新砖头；当前有 ${currentTotalBrick}/${config.maxBrick} 块砖头，总签到 ${totalCheckins} 天，连续签到 ${streakDays} 天`;
+      }
+      if (brick > 0) {
+        return `签到成功，你获得了 ${brick} 块砖头，现在有 ${currentTotalBrick}/${config.maxBrick} 块砖头；总签到 ${totalCheckins} 天，连续签到 ${streakDays} 天`;
+      }
+      return `签到成功，但本群砖头已满，未获得新砖头；当前有 ${currentTotalBrick}/${config.maxBrick} 块砖头，总签到 ${totalCheckins} 天，连续签到 ${streakDays} 天`;
+    });
+  }
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name,
+  usage
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "koishi-plugin-brick-qq",
+  "description": "功夫再好，一砖撂倒。烧制砖头来拍群友吧，拍好了禁言他，没拍好被禁言！",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "dependencies": {
+    "@satorijs/adapter-qq": "^4.12.0"
+  },
+  "peerDependencies": {
+    "koishi": "4.18.11"
+  }
+}

package/readme.md

@@ -0,0 +1,96 @@
+# koishi-plugin-brick-qq
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-brick-qq?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-brick-qq)
+
+功夫再好，一砖撂倒。让群友帮你烧制砖头，再用砖头把人拍晕（禁言）；普通拍人也可能遭到对方反击。
+
+本插件基于原版 brick 插件优化，增加了群聊开关、暴力拍人、每日签到、持久化签到统计，以及禁言失败时的消息拦截降级。
+
+## 使用要求
+
+- Koishi 4.18
+- 已启用 Koishi `database` 服务
+- QQ 官方机器人适配器 `@satorijs/adapter-qq`
+- Bot 需要群成员禁言权限；没有权限时，插件会在本地暂时停止响应被拍晕用户的消息
+
+砖头数量按“用户 + 群聊”分别保存，不能跨群使用。
+
+## 安装
+
+在 Koishi 插件市场搜索 `brick-qq`，或通过包管理器安装：
+
+```bash
+yarn add koishi-plugin-brick-qq
+```
+
+安装后请先启用数据库插件，再启用本插件，并至少配置 `cost`。
+
+## 玩法
+
+1. 发送 `烧砖` 开始烧制砖头。
+2. 烧制期间，其他群友每发送 `cost` 条消息，即可烧好一块砖。
+3. 发送 `拍人 @用户` 消耗一块砖，使对方随机禁言一段时间；对方有概率夺走砖头并反击。
+4. 发送 `暴力拍人 @用户` 消耗两块砖，必定命中，并造成普通拍人的三倍禁言时间。
+
+普通拍人与暴力拍人共用冷却时间。砖头在拍人判定前扣除，即使遭到反击也不会返还。
+
+## 指令
+
+| 指令 | 别名 | 说明 |
+| --- | --- | --- |
+| `砖头` | - | 查看砖头指令列表 |
+| `砖头.烧砖` | `烧砖` | 开始烧制一块砖 |
+| `砖头.拍人 @用户` | `拍人 @用户` | 消耗一块砖随机拍晕对方，有概率被反击 |
+| `砖头.暴力拍人 @用户` | `暴力拍人 @用户` | 消耗两块砖必定拍晕对方，禁言时间为三倍 |
+| `砖头.查看` | `查看砖头` | 查看自己在当前群持有的砖头 |
+| `砖头.签到` | `砖头签到` | 每日签到并随机获得砖头，仅在开启签到功能后注册 |
+| `开启砖头` | - | 开启当前群的砖头功能 |
+| `关闭砖头` | - | 关闭当前群的砖头功能 |
+
+源码中还保留了 `随机拍人` 指令，但该指令目前仅对 OneBot 平台注册，不适用于本插件面向的 QQ 官方机器人适配器。
+
+## 配置项
+
+| 配置项 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `maxBrick` | `number` | `1` | 每位用户在单个群内最多持有的砖头数量 |
+| `cost` | `number` | 必填 | 烧好一块砖所需的其他群友消息数 |
+| `cooldown` | `number` | `60` | 拍人冷却时间，单位为秒；设为 `0` 可关闭冷却 |
+| `minMuteTime` | `number` | `10` | 普通拍人的最短禁言时间，单位为秒 |
+| `maxMuteTime` | `number` | `120` | 普通拍人的最长禁言时间，单位为秒 |
+| `ignoreMuted` | `boolean` | `false` | 是否关闭插件内置的拍晕状态限制与消息拦截，仅依赖平台禁言结果 |
+| `reverse` | `number` | `10` | 普通拍人时对方反击的默认概率，范围为 `0`～`100` |
+| `specialUser` | `Record<string, number>` | `{}` | 为指定 QQ 用户 ID 单独设置反击概率，值为 `0`～`100` |
+| `checking` | `boolean` | `false` | 是否启用每日签到获取砖头 |
+| `minGain` | `number` | - | 单次签到最少获得的砖头，仅在 `checking` 开启时必填 |
+| `maxGain` | `number` | - | 单次签到最多获得的砖头，仅在 `checking` 开启时必填 |
+
+建议保证 `maxMuteTime >= minMuteTime`、`maxGain >= minGain`。签到奖励不会让砖头数量超过 `maxBrick`。
+
+`specialUser` 配置示例：
+
+```yaml
+specialUser:
+  "123456789": 50
+  "987654321": 100
+```
+
+上述配置表示用户 `123456789` 被普通拍人时有 50% 概率反击，用户 `987654321` 必定反击；未配置的用户使用 `reverse`。
+
+## 签到说明
+
+- 每位用户在每个群每天可以领取一次签到砖头。
+- 总签到天数和连续签到天数按用户全局统计，不区分群聊。
+- 同一天在其他群继续签到可以领取该群的砖头，但不会重复增加全局签到天数。
+- 当当前群的砖头已经达到上限时，签到仍会成功，但不会获得新砖头。
+
+## 注意事项
+
+- 烧砖进度保存在内存中，插件重载或 Bot 重启后，尚未完成的烧砖进度会丢失。
+- 默认情况下，平台禁言失败时插件会拦截被拍晕用户在当前群的消息，使其他插件暂时不响应该用户。
+- 开启 `ignoreMuted` 后，插件不会使用上述降级机制，也不会阻止处于拍晕状态的用户继续使用 Bot；请确认 Bot 拥有有效的群禁言权限。
+- QQ 原生 Markdown 消息是否能正常发送，取决于 QQ 官方机器人账号的消息能力和权限。
+
+## 许可证
+
+MIT