koishi-plugin-card-21-game/lib/index.js

Koishi 的 21 点（黑杰克）纸牌游戏插件。完整赌场规则。

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 inject = {
  required: ["monetary", "database"],
  optional: ["markdownToImage"]
};
var name = "card-21-game";
var usage = `## 使用

1. 启动 \`monetary\` 和 \`database\` 服务。
2. 设置指令别名。
3. 投注：\`blackjack.加入游戏 [投注]\`。
4. 开始：
   - 有庄家模式：\`blackjack.开始游戏\`。
   - 无庄家模式：\`blackjack.开始游戏 -n\`。

- 筹码为通用货币，通过其他插件（签到、钓鱼、赛马等）获得。
- 文本转图片：推荐 \`imagify\` 插件，视觉效果更佳。

## 规则

- 无庄家模式：玩家之间进行游戏。
- 有庄家模式：庄家与玩家对战，庄家为机器人。
- 游戏目标：使手牌点数尽量接近 21 点，但不超过 21 点。

## 术语

- 投降：玩家未要牌前可投降，返还半注。
- 黑杰克：手牌点数 21 点，且只有两张手牌。赔率为 1.5。
- 加倍：玩家持两张手牌且点数为 11 时，可加倍投注，只能再要一张牌。
- 保险：庄家的第一张牌是 A 时，玩家可将筹码分半，购买保险。庄家手牌 21 点时，获双倍保险金。
- 分牌：玩家手牌为对子时，可分两副手牌，分别进行操作，若分出的是 A，只能再要一张牌。

## QQ 群

- 956758505`;
var Config = import_koishi.Schema.intersect([
  import_koishi.Schema.object({
    allowZeroBetJoin: import_koishi.Schema.boolean().default(true).description(`是否开启零投注也能加入游戏的功能。`),
    enableCardBetting: import_koishi.Schema.boolean().default(false).description(`是否开启投注牌型功能。`),
    enableSurrender: import_koishi.Schema.boolean().default(false).description(`是否开启投降功能。`)
  }).description("一般设置"),
  import_koishi.Schema.object({
    retractDelay: import_koishi.Schema.number().min(0).default(0).description(
      `自动撤回等待的时间，单位是秒。值为 0 时不启用自动撤回功能。`
    ),
    imageType: import_koishi.Schema.union(["png", "jpeg", "webp"]).default("png").description(`发送的图片类型。`),
    isTextToImageConversionEnabled: import_koishi.Schema.boolean().default(false).description(
      `（QQ 官方机器人必须开启，防违规检测）是否开启将文本转为图片的功能（可选），如需启用，需要启用 \`markdownToImage\` 服务。`
    ),
    isEnableQQOfficialRobotMarkdownTemplate: import_koishi.Schema.boolean().default(false).description(
      `（QQ 官方机器人必须开启文本转图片功能，用于防违规检测）是否启用 QQ 官方机器人的 Markdown 模板，带消息按钮。`
    )
  }).description("消息处理设置"),
  import_koishi.Schema.union([
    import_koishi.Schema.object({
      isEnableQQOfficialRobotMarkdownTemplate: import_koishi.Schema.const(true).required(),
      customTemplateId: import_koishi.Schema.string().default("").description(`自定义模板 ID。`),
      key: import_koishi.Schema.string().default("").description(
        `文本内容中特定插值的 key。如果你的插值为 {{.info}}，那么请在这里填 info。`
      ),
      // key2: Schema.string().default('').description(`发送图片信息的特定插值的 key，用于存放图片的宽高。与下面的 key3 联动，Markdown 源码中形如：{{.key2}}{{.key3}}，那么该配置项就填 key2，下面的就填 key3。`),
      // key3: Schema.string().default('').description(`发送图片URL的特定插值的 key，用于存放图片的URL。`),
      numberOfMessageButtonsPerRow: import_koishi.Schema.number().min(1).max(5).default(2).description(`每行消息按钮的数量。`)
    }),
    import_koishi.Schema.object({})
  ]),
  import_koishi.Schema.object({
    defaultMaxLeaderboardEntries: import_koishi.Schema.number().min(0).default(10).description(`显示排行榜时默认的最大人数。`)
  }).description("排行榜设置"),
  import_koishi.Schema.object({
    minimumRequiredCurrencyForGameEntry: import_koishi.Schema.number().min(0).default(0).description(`加入游戏所需的最低货币数量。`),
    dealerSpeed: import_koishi.Schema.number().min(0).default(2).description(`庄家要牌的速度，单位是秒。`),
    betMaxDuration: import_koishi.Schema.number().min(0).default(30).description(`投注牌型操作的等待时长，单位是秒。`),
    buyInsuranceMaxDuration: import_koishi.Schema.number().min(0).default(10).description(`买保险操作的等待时长，单位是秒。`),
    surrenderMaxDuration: import_koishi.Schema.number().min(0).default(10).description(`投降操作的等待时长，单位是秒。`),
    joinGameProcedureWaitTimeInSeconds: import_koishi.Schema.number().min(0).default(2).description(`办理加入游戏手续等待时间，单位是秒。`)
  }).description("游戏操作设置"),
  import_koishi.Schema.object({
    numberOfDecks: import_koishi.Schema.number().min(1).max(8).default(4).description(
      `使用几副扑克牌，默认为 4 副（因为闲家都是明牌，所以建议使用默认值）。`
    )
  }).description("扑克牌设置"),
  import_koishi.Schema.object({
    transferFeeRate: import_koishi.Schema.number().default(0.1).description(`转账收取的手续费比例。`),
    isBellaPluginPointsEnabledForCurrency: import_koishi.Schema.boolean().default(false).description(`是否启用 Bella 签到插件的积分作为货币。`)
  }).description("费用设置")
]);
var initialDeck = [
  "♥️A",
  "♥️2",
  "♥️3",
  "♥️4",
  "♥️5",
  "♥️6",
  "♥️7",
  "♥️8",
  "♥️9",
  "♥️10",
  "♥️J",
  "♥️Q",
  "♥️K",
  "♦️A",
  "♦️2",
  "♦️3",
  "♦️4",
  "♦️5",
  "♦️6",
  "♦️7",
  "♦️8",
  "♦️9",
  "♦️10",
  "♦️J",
  "♦️Q",
  "♦️K",
  "♣️A",
  "♣️2",
  "♣️3",
  "♣️4",
  "♣️5",
  "♣️6",
  "♣️7",
  "♣️8",
  "♣️9",
  "♣️10",
  "♣️J",
  "♣️Q",
  "♣️K",
  "♠️A",
  "♠️2",
  "♠️3",
  "♠️4",
  "♠️5",
  "♠️6",
  "♠️7",
  "♠️8",
  "♠️9",
  "♠️10",
  "♠️J",
  "♠️Q",
  "♠️K"
];
function apply(ctx, config) {
  const {
    allowZeroBetJoin,
    isTextToImageConversionEnabled,
    betMaxDuration,
    buyInsuranceMaxDuration,
    surrenderMaxDuration,
    numberOfDecks,
    defaultMaxLeaderboardEntries,
    dealerSpeed,
    enableCardBetting,
    enableSurrender,
    joinGameProcedureWaitTimeInSeconds,
    transferFeeRate
  } = config;
  ctx.model.extend(
    "blackjack_game_record",
    {
      id: "unsigned",
      channelId: "string",
      deck: "list",
      bankerHand: "list",
      currentPlayerIndex: "integer",
      currentPlayerUserId: "string",
      currentPlayerUserName: "string",
      currentPlayerHandIndex: "integer",
      gameStatus: "string",
      canSurrender: "boolean",
      canBuyInsurance: "boolean",
      isNoDealerMode: "boolean"
    },
    {
      primary: "id",
      autoInc: true
    }
  );
  ctx.model.extend(
    "blackjack_playing_record",
    {
      id: "unsigned",
      channelId: "string",
      userId: "string",
      username: "string",
      bet: "double",
      playerHand: "list",
      playerHandIndex: "integer",
      playerIndex: "integer",
      betPlayerUserId: "string",
      betPlayerUserName: "string",
      betType: "string",
      betAmount: "double",
      isBuyInsurance: "boolean",
      insurance: "double",
      isSurrender: "boolean",
      isOver: "boolean",
      win: "double",
      betWin: "double",
      afterDoublingTheBet: "string"
    },
    {
      primary: "id",
      autoInc: true
    }
  );
  ctx.model.extend(
    "blackjack_player_record",
    {
      id: "unsigned",
      userId: "string",
      username: "string",
      win: "unsigned",
      moneyChange: "double",
      lose: "unsigned",
      numberOf21: "unsigned",
      numberOfBlackJack: "unsigned",
      draw: "unsigned"
    },
    {
      primary: "id",
      autoInc: true
    }
  );
  ctx.command("blackJack", "blackJack/21点游戏帮助").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    if (config.isEnableQQOfficialRobotMarkdownTemplate && session.platform === "qq" && config.key !== "" && config.customTemplateId !== "" || session.platform === "qq") {
      return await sendMessage(
        session,
        `🎉 欢迎来到 BlackJack/21 点游戏！
😆 希望你能玩的开心！
`,
        `查询玩家记录 改名 转账 加入游戏 排行榜`
      );
    }
    await session.execute(`blackjack -h`);
  });
  ctx.command("blackJack.转账 [content:text]", "转账").userFields(["id", "name", "permissions"]).action(async ({ session }, content) => {
    const sessionUserName = await getSessionUserName(session);
    if (!content) {
      let message = ``;
      if (config.isEnableQQOfficialRobotMarkdownTemplate && session.platform === "qq" && config.key !== "" && config.customTemplateId !== "") {
        message = `【@${sessionUserName}】
欢迎使用转账功能！
检测到缺少【被转账对象】
请输入：【被转账对象的ID或其修改后的名字】或【取消】
输入示例：
> 圣斗士星矢
注意：名字不是 QQ 名或 QQ 号，而是其改名后的名字或其专属ID）
`;
      } else {
        message = `【@${sessionUserName}】
检测到缺少【被转账对象】！
请选择您的操作：【@被转账对象】或【取消】
【被转账对象】：@被转账人。
输入示例：
> @小小学`;
      }
      await sendMessage(session, message, `转账`);
      const userInput = await session.prompt();
      if (!userInput)
        return await sendMessage(
          session,
          `【@${sessionUserName}】
输入超时。`,
          `转账`
        );
      if (userInput === "取消")
        return await sendMessage(
          session,
          `【@${sessionUserName}】
转账操作已取消。`,
          `转账`
        );
      content = userInput;
    }
    content = await replaceAtTags(session, content);
    const { user, platform } = session;
    const uid = user.id;
    let userId = "";
    let username = "";
    let remainingContent;
    if (config.isEnableQQOfficialRobotMarkdownTemplate && session.platform === "qq" && config.key !== "" && config.customTemplateId !== "") {
      const contentArray = content.split(" ");
      userId = contentArray[0];
      username = contentArray[0];
      let targetPlayerRecord = [];
      targetPlayerRecord = await ctx.database.get("blackjack_player_record", {
        userId
      });
      if (targetPlayerRecord.length === 0) {
        targetPlayerRecord = await ctx.database.get(
          "blackjack_player_record",
          { username }
        );
        if (targetPlayerRecord.length === 0) {
          return await sendMessage(
            session,
            `【@${sessionUserName}】
未找到符合要求的用户 ID。`,
            `转账`
          );
        }
      }
      userId = targetPlayerRecord[0].userId;
      username = targetPlayerRecord[0].username;
      remainingContent = contentArray[1];
    } else {
      const userIdRegex = /<at id="(?<userId>[^"]+)"(?: name="(?<username>[^"]+)")?\/>/;
      const match = content && content.match(userIdRegex);
      if (!match) {
        const contentArray = content.split(" ");
        userId = contentArray[0];
        const targetPlayerRecord = await ctx.database.get("blackjack_player_record", { userId });
        if (targetPlayerRecord.length === 0) {
          return await sendMessage(
            session,
            `【@${sessionUserName}】
未找到符合要求的用户 ID。`,
            `转账`
          );
        } else {
          userId = targetPlayerRecord[0].userId;
          username = targetPlayerRecord[0].username;
          remainingContent = contentArray[1];
        }
      } else {
        userId = match.groups.userId;
        username = match.groups.username;
        remainingContent = content.replace(match[0], "").trim();
      }
    }
    let amount;
    if (remainingContent.length > 0) {
      amount = parseFloat(remainingContent);
      if (Number.isNaN(amount)) {
        return await sendMessage(
          session,
          `【@${sessionUserName}】
转账金额必须是一个有效的数字。`,
          `转账`
        );
      }
      if (amount < 0) {
        return await sendMessage(
          session,
          `【@${sessionUserName}】
转账金额不能为负数！`,
          `转账`
        );
      }
    } else {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
未找到有效的转账金额。`,
        `转账`
      );
    }
    let userMoney = 0;
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const bellaSignIn = await ctx.database.get(
        "bella_sign_in",
        { id: session.userId }
      );
      if (bellaSignIn.length === 0) {
        return await sendMessage(
          session,
          `【@${sessionUserName}】
转账失败！
您当没有货币记录哦，快去签到吧！`,
          `转账`
        );
      }
      userMoney = bellaSignIn[0].point;
    } else {
      const getUserMonetary = await ctx.database.get("monetary", { uid });
      if (getUserMonetary.length === 0) {
        await ctx.database.create("monetary", {
          uid,
          value: 0,
          currency: "default"
        });
        return await sendMessage(
          session,
          `【@${sessionUserName}】
您还没有货币记录呢~
无法进行转账操作哦！
不过别担心！
已经为您办理货币登记了呢~`,
          `转账`
        );
      }
      const userMonetary = getUserMonetary[0];
      userMoney = userMonetary.value;
    }
    if (userMoney < amount) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
检测到您当前的余额不足！
转账金额为：【${amount}】
但您剩余的货币为：【${userMoney}】`,
        `转账`
      );
    }
    const transferFee = amount * transferFeeRate;
    if (userMoney < amount + transferFee) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
抱歉，转账失败！
余额不足以支付转账所需手续费！
所需手续费为：【${transferFee}】
而转账后您仅剩：【${userMoney - amount - transferFee}】`,
        `转账`
      );
    }
    const newScore = userMoney - amount - transferFee;
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const targetUser = await ctx.database.get("bella_sign_in", {
        id: userId
      });
      if (targetUser.length === 0) {
        return await sendMessage(
          session,
          `【@${sessionUserName}】
转账失败！
哎呀，我根本不认识他的说...
或者说...他还没签到过呢！`,
          `转账`
        );
      }
      await ctx.database.set(
        "bella_sign_in",
        { id: session.userId },
        { point: newScore }
      );
      const targetUserPoint = targetUser[0].point;
      await ctx.database.set(
        "bella_sign_in",
        { id: userId },
        { point: targetUserPoint + amount }
      );
    } else {
      const targetUser = await ctx.database.getUser(platform, userId);
      if (!targetUser) {
        return await sendMessage(
          session,
          `【@${sessionUserName}】
转账失败！
哎呀，我根本不认识他的说...`,
          `转账`
        );
      }
      await ctx.database.set("monetary", { uid }, { value: newScore });
      const uid2 = targetUser.id;
      const getUserMonetary2 = await ctx.database.get("monetary", {
        uid: uid2
      });
      if (getUserMonetary2.length === 0) {
        await ctx.database.create("monetary", {
          uid: uid2,
          value: amount,
          currency: "default"
        });
      } else {
        const userMonetary2 = getUserMonetary2[0];
        await ctx.database.set(
          "monetary",
          { uid: uid2 },
          { value: userMonetary2.value + amount }
        );
      }
    }
    await sendMessage(
      session,
      `【@${sessionUserName}】
转账成功！
被转账人为：【${username}】
转账金额：【${amount}】
收取手续费：【${transferFee}】
您的余额为：【${newScore}】`,
      `查询玩家记录 转账 加入游戏`
    );
  });
  ctx.command("blackJack.加入游戏 [bet:number]", "加入游戏并投注筹码").userFields(["id", "name", "permissions"]).action(async ({ session }, bet) => {
    let { channelId, userId, username, user } = session;
    const uid = user.id;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    username = await getSessionUserName(session);
    const userRecord = await ctx.database.get("blackjack_player_record", {
      userId
    });
    if (userRecord.length === 0) {
      await ctx.database.create("blackjack_player_record", {
        userId,
        username,
        win: 0,
        lose: 0,
        moneyChange: 0,
        numberOfBlackJack: 0,
        numberOf21: 0,
        draw: 0
      });
    } else if (username !== userRecord[0].username) {
      await ctx.database.set(
        "blackjack_player_record",
        { userId },
        { username }
      );
    }
    let gameRecord = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (gameRecord.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      gameRecord = await ctx.database.get("blackjack_game_record", {
        channelId
      });
    }
    const gameInfo = gameRecord[0];
    if (gameInfo.gameStatus !== "未开始") {
      return await sendMessage(
        session,
        `【@${username}】
游戏已经开始了哦~`,
        `改名 要牌 停牌`
      );
    }
    const getPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getPlayer.length !== 0) {
      await sendMessage(
        session,
        `【@${username}】
您已在游戏中！
您的投注金额为：【${getPlayer[0].bet}】
买定离手，无法再更改投注！`,
        `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
      );
      return;
    }
    if (!bet) {
      let userMoney2 = 0;
      if (config.isBellaPluginPointsEnabledForCurrency) {
        const bellaSignIn = await ctx.database.get("bella_sign_in", {
          id: session.userId
        });
        if (bellaSignIn.length === 0) {
          if (!allowZeroBetJoin) {
            return await sendMessage(
              session,
              `【@${username}】
您还没有货币记录哦，快去签到吧！`,
              `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
            );
          }
        } else {
          userMoney2 = bellaSignIn[0].point;
        }
      } else {
        let getUserMonetary = await ctx.database.get("monetary", { uid });
        if (getUserMonetary.length === 0) {
          await ctx.database.create("monetary", {
            uid,
            value: 0,
            currency: "default"
          });
          getUserMonetary = await ctx.database.get("monetary", { uid });
          if (!allowZeroBetJoin) {
            return await sendMessage(
              session,
              `【@${username}】
您还没有货币记录呢~
没办法投注的说...
不过别担心！
已经为您办理货币登记了呢~`,
              `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
            );
          }
        }
        const userMonetary = getUserMonetary[0];
        userMoney2 = userMonetary.value;
      }
      const isBalanceSufficient2 = allowZeroBetJoin ? userMoney2 < 0 : userMoney2 <= 0;
      if (isBalanceSufficient2) {
        return await sendMessage(
          session,
          `【@${username}】
抱歉~
您没钱啦！
您当前的货币为：【${userMoney2}】

赶快去赚些钱吧~
加入游戏的大门随时为您敞开！`,
          `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
        );
      }
      await sendMessage(
        session,
        `【@${username}】
🎉 欢迎加入 BlackJack/21 点游戏！
希望你能玩的开心！

游玩需要投注哦 ~
您的货币余额为：【${userMoney2}】
${allowZeroBetJoin && userMoney2 === 0 ? "检测到允许零投注！\n正在为您办理加入游戏手续中..." : "请输入您的【投注金额】："}`,
        `${allowZeroBetJoin && userMoney2 === 0 ? "" : `输入投注金额`}`
      );
      if (allowZeroBetJoin && userMoney2 === 0) {
        await (0, import_koishi.sleep)(joinGameProcedureWaitTimeInSeconds * 1e3);
      }
      bet = allowZeroBetJoin && userMoney2 === 0 ? 0 : Number(await session.prompt());
      if (isNaN(bet)) {
        return await sendMessage(
          session,
          `【@${username}】
输入无效，重新来一次吧~`,
          `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
        );
      }
    }
    if (config.minimumRequiredCurrencyForGameEntry > 0 && bet < config.minimumRequiredCurrencyForGameEntry) {
      return await sendMessage(
        session,
        `【@${username}】
您的投注不够呢！
最少所需投注为：【${config.minimumRequiredCurrencyForGameEntry}】`,
        `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
      );
    }
    if (typeof bet !== "number" || (allowZeroBetJoin ? bet < 0 : bet <= 0)) {
      return await sendMessage(
        session,
        `【@${username}】
准备好投注金额，才可以加入游戏哦~`,
        `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
      );
    }
    let userMoney = 0;
    let isBalanceSufficient = true;
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const bellaSignIn = await ctx.database.get("bella_sign_in", {
        id: session.userId
      });
      if (bellaSignIn.length === 0) {
        if (!allowZeroBetJoin) {
          return await sendMessage(
            session,
            `【@${username}】
您还没有货币记录哦，快去签到吧！`,
            `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
          );
        }
      } else {
        userMoney = bellaSignIn[0].point;
      }
    } else {
      let getUserMonetary = await ctx.database.get("monetary", { uid });
      if (getUserMonetary.length === 0) {
        await ctx.database.create("monetary", {
          uid,
          value: 0,
          currency: "default"
        });
        getUserMonetary = await ctx.database.get("monetary", { uid });
        if (!allowZeroBetJoin) {
          return await sendMessage(
            session,
            `【@${username}】
您还没有货币记录呢~
没办法投注的说...
不过别担心！
已经为您办理货币登记了呢~`,
            `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
          );
        }
      }
      const userMonetary = getUserMonetary[0];
      userMoney = userMonetary.value;
    }
    if (userMoney < bet) {
      isBalanceSufficient = false;
      bet = userMoney <= 0 ? 0 : userMoney;
    }
    if (bet === 0 && !allowZeroBetJoin) {
      return await sendMessage(
        session,
        `【@${username}】
不允许零投注哦~`,
        `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
      );
    }
    const [playerRecord] = await ctx.database.get("blackjack_player_record", {
      userId
    });
    await ctx.database.set(
      "blackjack_player_record",
      { userId },
      { moneyChange: playerRecord.moneyChange - bet }
    );
    if (config.isBellaPluginPointsEnabledForCurrency) {
      await ctx.database.set(
        "bella_sign_in",
        { id: session.userId },
        { point: userMoney - bet }
      );
    } else {
      await ctx.monetary.cost(uid, bet);
    }
    await ctx.database.create("blackjack_playing_record", {
      channelId,
      userId,
      username,
      bet,
      playerHandIndex: 1
    });
    const numberOfPlayers = (await ctx.database.get("blackjack_playing_record", { channelId })).length;
    return await sendMessage(
      session,
      `【@${username}】
${!isBalanceSufficient ? "检测到余额不足！\n已自动向下合并！\n\n" : ""}${bet === 0 && allowZeroBetJoin && userMoney !== 0 ? "检测到允许零投注！\n\n" : ""}投注成功！
您正式加入游戏了！
投注筹码数额为：【${bet}】
剩余通用货币为：【${userMoney - bet}】
当前玩家人数：${numberOfPlayers} 名！`,
      `改名 无庄模式 开始游戏 退出游戏 加入游戏 转账`
    );
  });
  ctx.command("blackJack.退出游戏", "退出游戏").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    let { channelId, userId, user, username } = session;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    username = await getSessionUserName(session);
    const gameInfo = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (gameInfo.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${username}】
你都没加入呢，怎么退出？`,
        `退出游戏 加入游戏`
      );
    }
    if (gameInfo[0].gameStatus !== "未开始") {
      return await sendMessage(session, "哼哼，游戏都开始了还想退出？", ``);
    }
    const playerInfo = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (playerInfo.length === 0) {
      return await sendMessage(
        session,
        `【@${username}】
加入了才能退出哦~`,
        `退出游戏 加入游戏`
      );
    }
    const player = playerInfo[0];
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const bellaSignIn = await ctx.database.get("bella_sign_in", {
        id: player.userId
      });
      if (bellaSignIn.length !== 0) {
        await ctx.database.set(
          "bella_sign_in",
          { id: player.userId },
          { point: bellaSignIn[0].point + player.bet }
        );
      }
    } else {
      const uid = user.id;
      await ctx.monetary.gain(uid, player.bet);
    }
    await ctx.database.remove("blackjack_playing_record", {
      channelId,
      userId
    });
    const numberOfPlayers = (await ctx.database.get("blackjack_playing_record", { channelId })).length;
    return await sendMessage(
      session,
      `【@${username}】
退出游戏成功！
钱已经退给你啦~
剩余玩家人数：${numberOfPlayers} 名！`,
      `无庄模式 开始游戏 退出游戏 加入游戏`
    );
  });
  ctx.command("blackJack.开始游戏", "开始游戏").userFields(["id", "name", "permissions"]).option("noDealerMode", "-n 无庄模式", { fallback: false }).action(async ({ session, options }) => {
    let { channelId, userId, platform } = session;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const sessionUserName = await getSessionUserName(session);
    const gameInfo = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (gameInfo.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
没人怎么玩呀~`,
        `加入游戏`
      );
    }
    if (gameInfo[0].gameStatus !== "未开始") {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
已经开始了哦，待会儿记得来呀~`,
        ``
      );
    }
    const getPlayers = await ctx.database.get(
      "blackjack_playing_record",
      { channelId }
    );
    const numberOfPlayers = getPlayers.length;
    if (options.noDealerMode && numberOfPlayers < 2) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
无庄家模式至少需要两名玩家才能开始游戏哦~`,
        `加入游戏`
      );
    }
    if (numberOfPlayers < 1) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
悲~ 没人玩的说...`,
        `加入游戏`
      );
    }
    await ctx.database.set(
      "blackjack_game_record",
      { channelId },
      { gameStatus: "投注时间" }
    );
    let shuffledPlayersWithIndex = [];
    if (numberOfPlayers !== 1) {
      const shuffledPlayers = shuffleArray(getPlayers);
      await Promise.all(
        shuffledPlayers.map(async (player, index) => {
          const playerIndex = index + 1;
          await ctx.database.set(
            "blackjack_playing_record",
            {
              userId: player.userId,
              channelId: player.channelId
            },
            { playerIndex, playerHandIndex: 1 }
          );
          shuffledPlayersWithIndex.push({
            index: playerIndex,
            player
          });
        })
      );
      if (options.noDealerMode) {
        const minBet = Math.min(...getPlayers.map((player) => player.bet));
        for (const player of getPlayers) {
          if (player.bet > minBet) {
            const refundAmount = player.bet - minBet;
            if (config.isBellaPluginPointsEnabledForCurrency) {
              const bellaSignIn = await ctx.database.get("bella_sign_in", {
                id: player.userId
              });
              if (bellaSignIn.length !== 0) {
                await ctx.database.set(
                  "bella_sign_in",
                  { id: player.userId },
                  { point: bellaSignIn[0].point + refundAmount }
                );
              }
            } else {
              const uid = (await ctx.database.getUser(platform, player.userId)).id;
              await ctx.monetary.gain(uid, refundAmount);
            }
            await ctx.database.set(
              "blackjack_playing_record",
              { channelId, userId: player.userId },
              { bet: minBet }
            );
          }
        }
        const decks2 = generateDecks(numberOfDecks);
        const numTimes2 = 3;
        const shuffledDeck2 = shuffleArrayMultipleTimes(decks2, numTimes2);
        let playerWithIndexOne2;
        let betPlayer2;
        playerWithIndexOne2 = shuffledPlayersWithIndex.length > 0 ? shuffledPlayersWithIndex.find((item) => item.index === 1) : null;
        betPlayer2 = playerWithIndexOne2.player;
        const dealtCardToPunter2 = await dealCards(channelId, shuffledDeck2);
        await ctx.database.set(
          "blackjack_playing_record",
          {
            channelId,
            userId: betPlayer2.userId
          },
          { playerHand: [`${dealtCardToPunter2}`], playerHandIndex: 1 }
        );
        await sendMessage(
          session,
          `
🎉 21 点游戏（无庄模式）开始！
检测到玩家最低投注金额为：【${minBet}】
所有玩家的投注已更改为：【${minBet}】
该局游戏的扑克牌副数为：【${numberOfDecks}】

第一位玩家是：【@${betPlayer2.username}】
您的第一张手牌为：【${dealtCardToPunter2}】
您当前的点数为：【${calculateScore(dealtCardToPunter2)}】
🤔 你还想要再拿一张牌吗？记住哦，如果超过21点就会爆掉哦~
请选择您的操作：
【要牌】或【停牌】`,
          `要牌 停牌`
        );
        await ctx.database.set(
          "blackjack_game_record",
          { channelId },
          {
            deck: shuffledDeck2,
            currentPlayerIndex: 1,
            currentPlayerUserId: betPlayer2.userId,
            currentPlayerUserName: betPlayer2.username,
            gameStatus: "已开始",
            currentPlayerHandIndex: 1,
            isNoDealerMode: true
          }
        );
        return;
      }
      const playerOrder = shuffledPlayersWithIndex.map(
        (item) => `${item.index}. 【${item.player.username ?? "Unknown"}】`
      ).join("\n");
      const prompt = `当前阶段为：【投注牌型】

⌚️ 投注时间为：【${betMaxDuration}】秒！

🎲 玩家序号：
${playerOrder}

🃏 投注类型：

1. 对子：闲家首两张牌相同点数，倍数为 5。
2. 同花对子：闲家首两张牌相同点数和花色，倍数为 30。
3. 同花：庄家第一张牌与闲家前两张牌同花色，倍数为 5。
4. 顺：庄家第一张牌与闲家前两张牌连号，倍数为 10。
5. 三条：庄家第一张牌与闲家前两张牌同点数，倍数为 25。
6. 同花顺：庄家第一张牌与闲家前两张牌同花色且连号，倍数为 25。
7. 同花三条：庄家第一张牌与闲家前两张牌同花色和点数，倍数为 50。

投注示例：投注 1 7 50

投注格式：投注 [玩家序号] [类型] [金额]

其他可选操作：【跳过投注】

【跳过投注】：闲家发送此操作可直接进入下一阶段。`;
      await sendMessage(
        session,
        ` 游戏开始！
${enableCardBetting ? prompt : ""}
⚠️ 注意：该局游戏使用【${numberOfDecks}】副扑克牌

${!enableCardBetting || !enableSurrender ? `正在为庄家发牌...

请庄家亮牌！` : ""}`,
        `${enableCardBetting ? `跳过投注 投注牌型` : ""}`
      );
    } else if (numberOfPlayers === 1) {
      const player = getPlayers[0];
      await ctx.database.set(
        "blackjack_playing_record",
        { userId: player.userId, channelId },
        {
          playerIndex: 1,
          playerHandIndex: 1
        }
      );
      const prompt = `当前阶段为：【投注牌型】

⌚️ 投注时间为：【${betMaxDuration}】秒！

🎲 玩家序号：
1. 【${player.username}】

🃏 投注类型：
1. 对子：闲家首两张牌相同点数，倍数为 5。
2. 同花对子：闲家首两张牌相同点数和花色，倍数为 30。
3. 同花：庄家第一张牌与闲家前两张牌同花色，倍数为 5。
4. 顺：庄家第一张牌与闲家前两张牌连号，倍数为 10。
5. 三条：庄家第一张牌与闲家前两张牌同点数，倍数为 25。
6. 同花顺：庄家第一张牌与闲家前两张牌同花色且连号，倍数为 25。
7. 同花三条：庄家第一张牌与闲家前两张牌同花色和点数，倍数为 50。

投注示例：投注 1 7 50

投注格式：投注 [玩家序号] [类型] [金额]

其他可选操作：【跳过投注】

【跳过投注】：闲家发送此操作可直接进入下一阶段。`;
      await sendMessage(
        session,
        `【@${player.username}】
欢迎来到黑杰克的世界！
你是今天唯一的挑战者，你敢和我赌一把吗？
${enableCardBetting ? prompt : ""}
⚠️ 注意：该局游戏使用【${numberOfDecks}】副扑克牌

${!enableCardBetting || !enableSurrender ? `正在为庄家发牌...

请庄家亮牌！` : ""}`,
        `${enableCardBetting ? `跳过投注 投注牌型` : ""}`
      );
    }
    if (!enableCardBetting || !enableSurrender) {
      await (0, import_koishi.sleep)(dealerSpeed * 1e3);
    }
    if (enableCardBetting) {
      await ctx.database.set(
        "blackjack_game_record",
        { channelId },
        { gameStatus: "投注时间" }
      );
      const gameStatus = await getGameStatus(channelId);
      if (gameStatus === "投注时间") {
        await ctx.database.set(
          "blackjack_game_record",
          { channelId },
          { gameStatus: "投注时间结束" }
        );
        await sendMessage(session, `投注时间已到，下一阶段开始！`, ``);
      }
    }
    const decks = generateDecks(numberOfDecks);
    const numTimes = 3;
    const shuffledDeck = shuffleArrayMultipleTimes(decks, numTimes);
    let playerWithIndexOne;
    let betPlayer;
    if (numberOfPlayers !== 1) {
      playerWithIndexOne = shuffledPlayersWithIndex.length > 0 ? shuffledPlayersWithIndex.find((item) => item.index === 1) : null;
      betPlayer = playerWithIndexOne.player;
    } else {
      betPlayer = getPlayers[0];
    }
    const dealtCardToBanker = await dealCards(channelId, shuffledDeck);
    const dealtCardToPunter = await dealCards(channelId, shuffledDeck);
    await ctx.database.set(
      "blackjack_game_record",
      { channelId },
      {
        deck: shuffledDeck,
        canSurrender: true,
        currentPlayerIndex: 1,
        currentPlayerUserId: betPlayer.userId,
        currentPlayerUserName: betPlayer.username,
        gameStatus: "已开始",
        currentPlayerHandIndex: 1
      }
    );
    if (enableSurrender) {
      await sendMessage(
        session,
        `庄家亮牌：【${dealtCardToBanker}】
点数为：【${calculateScore(dealtCardToBanker)}】

当前阶段为：【投降】
⌚️ 持续时间为：【${surrenderMaxDuration}】秒！

投降倒计时开始！
玩家可以在【${surrenderMaxDuration}】秒内选择是否投降！
【投降】：退回半注。
【跳过投降】：直接进入下一阶段。`,
        `跳过投降 投降`
      );
      const gameCanSurrender = await getGameCanSurrender(channelId);
      if (gameCanSurrender === true) {
        await ctx.database.set(
          "blackjack_game_record",
          { channelId },
          { canSurrender: false }
        );
        await sendMessage(session, `投降已截止，下一阶段开始！`, ``);
      }
      const result = await ctx.database.get("blackjack_game_record", {
        channelId
      });
      if (result.length === 0) {
        return;
      }
    }
    await ctx.database.set(
      "blackjack_game_record",
      { channelId },
      { bankerHand: [`${dealtCardToBanker}`] }
    );
    await ctx.database.set(
      "blackjack_playing_record",
      {
        channelId,
        userId: betPlayer.userId
      },
      { playerHand: [`${dealtCardToPunter}`], playerHandIndex: 1 }
    );
    if (calculateScore(dealtCardToBanker) === 11) {
      await ctx.database.set(
        "blackjack_game_record",
        { channelId },
        { canBuyInsurance: true }
      );
      await sendMessage(
        session,
        `庄家亮牌：【${dealtCardToBanker}】
点数为：【11】点！

当前阶段为：【买保险】
⌚️ 持续时间为：【${buyInsuranceMaxDuration}】秒！

买保险倒计时开始！
玩家可以在【${buyInsuranceMaxDuration}】秒内选择是否买保险！
【买保险】：花费半注，若庄家黑杰克则获得双倍赔偿，否则损失半注。
【跳过买保险】：直接进入下一阶段。`,
        `跳过买保险 买保险`
      );
      const gameCanBuyInsurance = await getGameCanBuyInsurance(channelId);
      if (gameCanBuyInsurance === true) {
        await ctx.database.set(
          "blackjack_game_record",
          { channelId },
          { canBuyInsurance: false }
        );
        await sendMessage(session, `买保险已截止，游戏正式开始！`, ``);
      }
      const betPlayerName = betPlayer.username;
      return await sendMessage(
        session,
        `第一位玩家是：【@${betPlayerName}】
您的第一张牌为：【${dealtCardToPunter}】
您当前的点数为：【${calculateScore(dealtCardToPunter)}】
🤔 你还想要再拿一张牌吗？记住哦，如果超过21点就会爆掉哦~
请选择您的操作：
【要牌】或【停牌】`,
        `要牌 停牌`
      );
    }
    return await sendMessage(
      session,
      `庄家亮牌：【${dealtCardToBanker}】
点数为：【${calculateScore(dealtCardToBanker)}】

第一位玩家是：【@${betPlayer.username}】
您的第一张手牌为：【${dealtCardToPunter}】
您当前的点数为：【${calculateScore(dealtCardToPunter)}】
🤔 你还想要再拿一张牌吗？记住哦，如果超过21点就会爆掉哦~
请选择您的操作：
【要牌】或【停牌】`,
      `要牌 停牌`
    );
  });
  ctx.command("blackJack.投降", "投降").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    const sessionUserName = await getSessionUserName(session);
    if (!enableSurrender) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
投降功能已关闭。`,
        ``
      );
    }
    let { channelId, userId, user, username } = session;
    const uid = user.id;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const getGameInfo = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (getGameInfo.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
哼~ 最看不起投降的人了！`,
        `投降`
      );
    }
    const gameInfo = getGameInfo[0];
    if (gameInfo.gameStatus !== "已开始") {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
还没开始呢笨蛋，这么想投降啊？`,
        `无庄模式 开始游戏 退出游戏 加入游戏`
      );
    }
    const getPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getPlayer.length === 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
你都没来陪我一起玩就想投降？`,
        ``
      );
    }
    if (!gameInfo.canSurrender) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
笨蛋，现在可不能投降！`,
        ``
      );
    }
    const player = getPlayer[0];
    if (player.isSurrender) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
你难道想投降两次嘛！`,
        ``
      );
    }
    const refundAmount = (player.bet + player.betAmount) / 2;
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const bellaSignIn = await ctx.database.get("bella_sign_in", {
        id: userId
      });
      if (bellaSignIn.length !== 0) {
        await ctx.database.set(
          "bella_sign_in",
          { id: userId },
          { point: bellaSignIn[0].point + refundAmount }
        );
      }
    } else {
      await ctx.monetary.gain(uid, refundAmount);
    }
    const [playerRecord] = await ctx.database.get("blackjack_player_record", {
      userId
    });
    await ctx.database.set(
      "blackjack_player_record",
      { userId },
      {
        moneyChange: playerRecord.moneyChange + refundAmount,
        lose: playerRecord.lose + 1
      }
    );
    const [userMonetary] = await ctx.database.get("monetary", { uid });
    await ctx.database.set(
      "blackjack_playing_record",
      { channelId, userId },
      { isSurrender: true }
    );
    const theGameResult = await isGameEnded(channelId);
    if (gameInfo.currentPlayerIndex === player.playerIndex && theGameResult) {
      await ctx.database.remove("blackjack_playing_record", { channelId });
      await ctx.database.remove("blackjack_game_record", { channelId });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
游戏还未开始，你们却都投降了，我感到失望。算了，游戏就此结束，祝你们好运。`,
        `查询玩家记录 排行榜 加入游戏`
      );
    }
    return await sendMessage(
      session,
      `【@${username}】
您投降惹~
损失货币：【${refundAmount}】
您当前的余额为：【${userMonetary.value}】`,
      `投降`
    );
  });
  ctx.command("blackJack.重新开始", "重新开始").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    let { channelId, bot, platform, userId } = session;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const sessionUserName = await getSessionUserName(session);
    const getGameInfo = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (getGameInfo.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
现在的情况根本没必要重新开始嘛！`,
        `查询玩家记录 排行榜 加入游戏`
      );
    }
    const gameInfo = getGameInfo[0];
    if (gameInfo.gameStatus === "未开始") {
      const getPlayers2 = await ctx.database.get("blackjack_playing_record", {
        channelId
      });
      for (const player of getPlayers2) {
        const uid = (await ctx.database.getUser(platform, player.userId)).id;
        await ctx.monetary.gain(uid, player.bet);
      }
      await ctx.database.remove("blackjack_playing_record", { channelId });
      await ctx.database.remove("blackjack_game_record", { channelId });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
哼，既然游戏还没开始的话，只好把钱退给你们咯~`,
        `查询玩家记录 排行榜 加入游戏`
      );
    }
    const getPlayers = await ctx.database.get("blackjack_playing_record", {
      channelId
    });
    for (const player of getPlayers) {
      const [playerRecord] = await ctx.database.get(
        "blackjack_player_record",
        { userId: player.userId }
      );
      await ctx.database.set(
        "blackjack_player_record",
        { userId: player.userId },
        { lose: playerRecord.lose + 1 }
      );
    }
    await removeRecordsByChannelId(channelId);
    return await sendMessage(
      session,
      `【${sessionUserName}】
你们失败了，只能重新开始了~ 你们的钱就拜拜了~ 哈哈~`,
      `查询玩家记录 排行榜 加入游戏`
    );
  });
  ctx.command(
    "blackJack.投注 [playerIndex:number] [betType:string] [betAmount:number]",
    "投注牌型"
  ).userFields(["id", "name", "permissions"]).action(async ({ session }, playerIndex, betType, betAmount) => {
    const sessionUserName = await getSessionUserName(session);
    if (!enableCardBetting) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
投注牌型功能已关闭。`,
        ``
      );
    }
    if (!playerIndex || !betType || !betAmount) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
请输入投注信息，格式如下：
投注 [玩家序号] [牌型] [金额]
示例：投注 1 7 50`,
        `投注牌型`
      );
    }
    let { channelId, userId, user, username } = session;
    const uid = user.id;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const getGameInfo = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (getGameInfo.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
开始游戏之后才能投注呢~`,
        `无庄模式 开始游戏 退出游戏 加入游戏`
      );
    }
    const gameInfo = getGameInfo[0];
    if (gameInfo.gameStatus !== "投注时间") {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
现在不在投注时间哦~`,
        ``
      );
    }
    let betPlayer;
    const getPlayers = await ctx.database.get("blackjack_playing_record", {
      channelId
    });
    const numberOfPlayers = getPlayers.length;
    const getThisPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getThisPlayer.length === 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
加入游戏才可以投注！`,
        ``
      );
    }
    const thisPlayer = getThisPlayer[0];
    if (thisPlayer.betAmount) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
笨蛋，买定离手哦，才不给你更改投注！`,
        `投注牌型`
      );
    }
    if (numberOfPlayers === 1) {
      betPlayer = getPlayers[0];
    } else {
      const getBetPlayer = await ctx.database.get(
        "blackjack_playing_record",
        { channelId, playerIndex }
      );
      betPlayer = getBetPlayer[0];
    }
    const cardTypes = {
      1: "对子",
      2: "同花对子",
      3: "同花",
      4: "顺",
      5: "三条",
      6: "同花顺",
      7: "同花三条"
    };
    function getCardType(number) {
      return cardTypes[number] || "未知牌型";
    }
    __name(getCardType, "getCardType");
    const betTypeNumber = Number(betType);
    if (!isNaN(betTypeNumber) && betTypeNumber >= 1 && betTypeNumber <= 8) {
      betType = getCardType(betTypeNumber);
    } else {
      if (!(betType in cardTypes)) {
        return await sendMessage(
          session,
          `【@${sessionUserName}】
傻瓜，给我个有效的牌型！`,
          `投注牌型`
        );
      }
    }
    if (typeof betAmount !== "number" || betAmount <= 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
哼，给我爆金币！`,
        `投注牌型`
      );
    }
    let userMoney = 0;
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const bellaSignIn = await ctx.database.get("bella_sign_in", {
        id: userId
      });
      if (bellaSignIn.length !== 0) {
        userMoney = bellaSignIn[0].point;
      }
    } else {
      const [userMonetary] = await ctx.database.get("monetary", { uid });
      userMoney = userMonetary.value;
    }
    if (userMoney < betAmount) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
你怎么这么穷惹~ 没钱了啦！
你当前的货币数额为：【${userMoney}】个。`,
        `投注牌型`
      );
    }
    const [playerRecord] = await ctx.database.get("blackjack_player_record", {
      userId
    });
    await ctx.database.set(
      "blackjack_player_record",
      { userId },
      {
        moneyChange: playerRecord.moneyChange - betAmount
      }
    );
    if (config.isBellaPluginPointsEnabledForCurrency) {
      const bellaSignIn = await ctx.database.get("bella_sign_in", {
        id: userId
      });
      if (bellaSignIn.length !== 0) {
        await ctx.database.set(
          "bella_sign_in",
          { id: userId },
          { point: bellaSignIn[0].point - betAmount }
        );
      }
    } else {
      await ctx.monetary.cost(uid, betAmount);
    }
    await ctx.database.set(
      "blackjack_playing_record",
      { channelId, userId },
      {
        betPlayerUserId: betPlayer.userId,
        betPlayerUserName: betPlayer.username,
        betType,
        betAmount
      }
    );
    const multiplier = getCardTypeMultiplier(betType);
    return await sendMessage(
      session,
      `【@${username}】
投注成功！
您投注了【${betType}】（${multiplier}倍）牌型！
投注对象为：【@${betPlayer.username}】
投注金额：【${betAmount}】`,
      `投注牌型`
    );
  });
  ctx.command("blackJack.跳过投注", "跳过投注牌型的等待时间").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    const sessionUserName = await getSessionUserName(session);
    if (!enableCardBetting) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
投注牌型功能已关闭。`,
        ``
      );
    }
    let { channelId, userId, username, user } = session;
    username = sessionUserName;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const getPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getPlayer.length === 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
不加入怎么用指令呢~`,
        `加入游戏`
      );
    }
    let gameRecord = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (gameRecord.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
笨蛋~ 还没开始呢！`,
        `无庄模式 开始游戏 退出游戏 加入游戏`
      );
    }
    const gameInfo = gameRecord[0];
    if (gameInfo.gameStatus !== "投注时间") {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
现在不在投注时间哦~`,
        ``
      );
    }
    await ctx.database.set(
      "blackjack_game_record",
      { channelId },
      { gameStatus: "投注时间结束" }
    );
    return await sendMessage(
      session,
      `玩家【@${username}】执行【跳过投注】操作，【投注】通道已关闭！`,
      ``
    );
  });
  ctx.command("blackJack.跳过买保险", "跳过买保险的等待时间").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    const sessionUserName = await getSessionUserName(session);
    let { channelId, userId, username, user } = session;
    username = sessionUserName;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const getPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getPlayer.length === 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
你不在游戏里的说...`,
        `加入游戏`
      );
    }
    let gameRecord = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (gameRecord.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
游戏还没开始呢！`,
        `无庄模式 开始游戏 退出游戏 加入游戏`
      );
    }
    const gameInfo = gameRecord[0];
    if (!gameInfo.canBuyInsurance) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
现在可买不了保险~`,
        ``
      );
    }
    await ctx.database.set(
      "blackjack_game_record",
      { channelId },
      { canBuyInsurance: false }
    );
    return await sendMessage(
      session,
      `【@${username}】
您执行了【跳过买保险】操作！
【买保险】通道已关闭！`,
      ``
    );
  });
  ctx.command("blackJack.跳过投降", "跳过投降的等待时间").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    const sessionUserName = await getSessionUserName(session);
    if (!enableSurrender) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
投降功能已关闭。`,
        ``
      );
    }
    let { channelId, userId, username, user } = session;
    username = sessionUserName;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const getPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getPlayer.length === 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
你还不在游戏里面哦~`,
        `加入游戏`
      );
    }
    let gameRecord = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (gameRecord.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
还没开始呢！`,
        `无庄模式 开始游戏 退出游戏 加入游戏`
      );
    }
    const gameInfo = gameRecord[0];
    if (!gameInfo.canSurrender) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
还没到可以跳过的时候呢~`,
        ``
      );
    }
    await ctx.database.set(
      "blackjack_game_record",
      { channelId },
      { canSurrender: false }
    );
    return await sendMessage(
      session,
      `【@${username}】
您执行了【跳过投降】操作！
【投降】通道已关闭！`,
      `投降`
    );
  });
  ctx.command("blackJack.买保险", "买保险").userFields(["id", "name", "permissions"]).action(async ({ session }) => {
    let { channelId, userId, username } = session;
    const sessionUserName = await getSessionUserName(session);
    username = sessionUserName;
    if (!channelId) {
      channelId = `privateChat_${userId}`;
    }
    const getPlayer = await ctx.database.get("blackjack_playing_record", {
      channelId,
      userId
    });
    if (getPlayer.length === 0) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
想买保险？先加入游戏再说！笨蛋~`,
        `加入游戏`
      );
    }
    const player = getPlayer[0];
    if (player.isBuyInsurance) {
      return await sendMessage(
        session,
        `【@${sessionUserName}】
买一次就够了，笨蛋！而且只能买一次好不好！`,
        `买保险`
      );
    }
    const getGameInfo = await ctx.database.get("blackjack_game_record", {
      channelId
    });
    if (getGameInfo.length === 0) {
      await ctx.database.create("blackjack_game_record", {
        channelId,
        gameStatus: "未开始"
      });
      return await sendMessage(
        session,
        `【@${sessionUserName}】
游戏还没开始呢~ 买不了保险的说...`,
        `无庄模式 开始游戏 退出游戏 加入游戏`
      );
    }
    const gameInfo = getGameInfo[0];
    if (gameInfo.gameSta