koishi-plugin-noah 1.1.1 → 1.1.3

package/lib/index.js

@@ -333,6 +333,7 @@ var CardService = class {
   tableName = "card";
   /**
    * 获取所有卡片列表
+   * @returns 包含所有卡片的数组
    */
   async getAllCards() {
     const cards = await this.ctx.database.get(this.tableName, {});
@@ -342,9 +343,9 @@ var CardService = class {
     }));
   }
   /**
-   * 根据 user id 获取卡片列表
-   * @param uid 用户的 user id
-   * @returns 该用户绑定的卡片的完整信息列表
+   * 根据用户ID获取卡片列表
+   * @param uid - 用户ID
+   * @returns 该用户绑定的卡片完整信息列表
    */
   async getCardsByUid(uid) {
     const rows = await this.ctx.database.get("user_card", { uid }, ["cid"]);
@@ -355,7 +356,9 @@ var CardService = class {
     }));
   }
   /**
-   * 根据 id 获取卡片信息
+   * 根据卡片ID获取卡片信息
+   * @param id - 卡片ID
+   * @returns 卡片信息，不存在则返回null
    */
   async getCardById(id) {
     const rows = await this.ctx.database.get(this.tableName, id);
@@ -366,7 +369,9 @@ var CardService = class {
     };
   }
   /**
-   * 根据 code 获取卡片信息
+   * 根据卡号获取卡片信息
+   * @param code - 卡号
+   * @returns 卡片信息，不存在则返回null
    */
   async getCardByCode(code) {
     const rows = await this.ctx.database.get(this.tableName, { code });
@@ -377,7 +382,9 @@ var CardService = class {
     };
   }
   /**
-   * 根据 name 获取卡片信息
+   * 根据卡片名称获取卡片信息
+   * @param name - 卡片名称
+   * @returns 卡片信息，不存在则返回null
    */
   async getCardByName(name13) {
     const rows = await this.ctx.database.get(this.tableName, { name: name13 });
@@ -388,12 +395,12 @@ var CardService = class {
     };
   }
   /**
-   * 创建一张新的卡
-   * @param uid 用户的 uid
-   * @param code 卡片的卡号
-   * @param name 卡片的名称
-   * @param defaultServerId 默认服务器 ID（若没有默认服务器则为 0）
-   * @returns 创建成功后包含自动填充 id 等字段的完整对象
+   * 创建一张新卡片
+   * @param uid - 用户ID
+   * @param code - 卡片卡号
+   * @param name - 卡片名称
+   * @param defaultServerId - 默认服务器ID（若没有默认服务器则为0）
+   * @returns 创建成功后包含自动填充ID等字段的完整对象
    */
   async createCard(uid, code, name13, defaultServerId = 0) {
     const data = {
@@ -409,10 +416,11 @@ var CardService = class {
     };
   }
   /**
-   * 更新卡片的信息
-   * - 可更新 code、name、defaultServerId
-   * @param id 卡片的 id
-   * @param partial 更新字段
+   * 更新卡片信息
+   * 可更新 code、name、defaultServerId
+   * @param id - 卡片ID
+   * @param partial - 要更新的字段
+   * @returns 无返回值的Promise
    */
   async updateCard(id, partial) {
     if (partial.defaultServerId === void 0) {
@@ -422,7 +430,8 @@ var CardService = class {
   }
   /**
    * 删除卡片
-   * @param id 卡片 id
+   * @param id - 卡片ID
+   * @returns 无返回值的Promise
    */
   async removeCard(id) {
     await this.ctx.database.remove(this.tableName, id);
@@ -437,6 +446,16 @@ var CardService = class {
       }
     }
   }
+  /**
+   * 根据用户ID获取默认卡片
+   * @param uid - 用户ID
+   * @returns 用户设置的默认卡片，若不存在则返回null
+   */
+  async getDefaultCardByUid(uid) {
+    const userRes = await this.ctx.database.get("user", { id: uid }, ["defaultCardId"]);
+    if (!userRes[0] || userRes[0].defaultCardId === void 0 || userRes[0].defaultCardId === 0) return null;
+    return await this.getCardById(userRes[0].defaultCardId);
+  }
 };
 
 // src/core/services/user-service.ts
@@ -448,25 +467,29 @@ var UserService = class {
     __name(this, "UserService");
   }
   /**
-   * Update a user's default server ID
-   * @param uid User ID
-   * @param serverId Server ID
+   * 更新用户的默认服务器ID
+   * @param uid - 用户ID
+   * @param serverId - 服务器ID
+   * @returns 无返回值的Promise
    */
   async updateUserDefaultServer(uid, serverId) {
     await this.ctx.database.set("user", uid, { defaultServerId: serverId });
   }
   /**
-   * Update a user's default card ID
-   * @param uid User ID
-   * @param cardId Card ID
+   * 更新用户的默认卡片ID
+   * @param uid - 用户ID
+   * @param cardId - 卡片ID
+   * @returns 无返回值的Promise
    */
   async updateUserDefaultCard(uid, cardId) {
     await this.ctx.database.set("user", uid, { defaultCardId: cardId });
   }
   /**
-   * Update a channel's default server ID
-   * @param cid Channel ID
-   * @param serverId Server ID
+   * 更新频道的默认服务器ID
+   * @param platform - 平台标识
+   * @param cid - 频道ID
+   * @param serverId - 服务器ID
+   * @returns 无返回值的Promise
    */
   async updateChannelDefaultServer(platform, cid, serverId) {
     await this.ctx.database.setChannel(platform, cid, { defaultServerId: serverId });
@@ -496,7 +519,8 @@ function bind(ctx, config) {
     if (!cardName) return session.text("commands.timeout");
     if (cardName.includes(" ")) return session.text(".invalid-name");
     const res = await cardService.createCard(session.user.id, cardCode, cardName);
-    if (session.user.defaultCardId === 0) {
+    const defaultCard = await cardService.getDefaultCardByUid(session.user.id);
+    if (!defaultCard) {
       await userService.updateUserDefaultCard(session.user.id, res.id);
     }
     return session.text(".success", { cardName, cardCode });
@@ -518,30 +542,33 @@ var ServerService = class {
   tableName = "server";
   /**
    * 获取所有服务器列表
+   * @returns 服务器列表
    */
   async getAllServers() {
     return await this.ctx.database.get(this.tableName, {});
   }
   /**
-   * 根据 user id 获取服务器列表
-   * @param uid 用户的 user id
-   * @returns 该用户绑定的服务器的完整信息列表
+   * 根据用户ID获取服务器列表
+   * @param uid - 用户ID
+   * @returns 该用户绑定的服务器完整信息列表
    */
   async getServersByUid(uid) {
     const rows = await this.ctx.database.get("user_server", { uid }, ["sid"]);
     return await this.ctx.database.get("server", rows.map((obj) => obj.sid));
   }
   /**
-   * 根据 channel id 获取服务器列表
-   * @param cid 频道的 channel id
-   * @returns 该频道绑定的服务器的完整信息列表
+   * 根据频道ID获取服务器列表
+   * @param cid - 频道ID
+   * @returns 该频道绑定的服务器完整信息列表
    */
   async getServersByCid(cid) {
     const rows = await this.ctx.database.get("channel_server", { cid }, ["sid"]);
     return await this.ctx.database.get("server", rows.map((obj) => obj.sid));
   }
   /**
-   * 根据 id 获取服务器信息
+   * 根据服务器ID获取服务器信息
+   * @param id - 服务器ID
+   * @returns 服务器信息，不存在则返回null
    */
   async getServerById(id) {
     const rows = await this.ctx.database.get(this.tableName, id);
@@ -549,6 +576,8 @@ var ServerService = class {
   }
   /**
    * 根据名称查找服务器
+   * @param name - 服务器名称
+   * @returns 服务器信息，不存在则返回null
    */
   async getServerByName(name13) {
     const rows = await this.ctx.database.get(this.tableName, { name: name13 });
@@ -556,6 +585,8 @@ var ServerService = class {
   }
   /**
    * 根据类型筛选服务器
+   * @param type - 服务器类型
+   * @returns 筛选后的服务器列表
    */
   async getServersByType(type) {
     const servers = await this.ctx.database.get(this.tableName, { type });
@@ -563,8 +594,8 @@ var ServerService = class {
   }
   /**
    * 创建一个新的服务器记录并关联到用户
-   * @param serverData 要插入的数据 (不含 id)
-   * @param uid 用户的 ID
+   * @param serverData - 要插入的数据(不含ID)
+   * @param uid - 用户ID
    * @returns 插入后的完整数据
    */
   async createServerForUser(serverData, uid) {
@@ -574,8 +605,8 @@ var ServerService = class {
   }
   /**
    * 创建一个新的服务器记录并关联到频道
-   * @param serverData 要插入的数据 (不含 id)
-   * @param cid 频道的 ID
+   * @param serverData - 要插入的数据(不含ID)
+   * @param cid - 频道ID
    * @returns 插入后的完整数据
    */
   async createServerForChannel(serverData, cid) {
@@ -585,15 +616,17 @@ var ServerService = class {
   }
   /**
    * 更新服务器记录
-   * @param id 服务器 id
-   * @param partial 要更新的字段
+   * @param id - 服务器ID
+   * @param partial - 要更新的字段
+   * @returns 无返回值的Promise
    */
   async updateServer(id, partial) {
     await this.ctx.database.set(this.tableName, id, partial);
   }
   /**
    * 删除服务器记录
-   * @param id 服务器 id
+   * @param id - 服务器ID
+   * @returns 无返回值的Promise
    */
   async removeServer(id) {
     await this.ctx.database.remove(this.tableName, id);
@@ -624,14 +657,41 @@ var ServerService = class {
       }
     }
   }
+  /**
+   * 根据用户ID获取默认服务器
+   * @param uid - 用户ID
+   * @returns 用户设置的默认服务器，若不存在则返回null
+   */
+  async getDefaultServerByUid(uid) {
+    const userRes = await this.ctx.database.get("user", { id: uid }, ["defaultServerId"]);
+    if (!userRes[0] || userRes[0].defaultServerId === void 0 || userRes[0].defaultServerId === 0) return null;
+    return await this.getServerById(userRes[0].defaultServerId);
+  }
+  /**
+   * 根据频道ID获取默认服务器
+   * @param platform - 平台标识
+   * @param cid - 频道ID
+   * @returns 频道设置的默认服务器，若不存在则返回null
+   */
+  async getDefaultServerByCid(platform, cid) {
+    const channelRes = await this.ctx.database.getChannel(platform, cid, ["defaultServerId"]);
+    if (!channelRes || channelRes.defaultServerId === void 0 || channelRes.defaultServerId === 0) return null;
+    return await this.getServerById(channelRes.defaultServerId);
+  }
 };
 
 // src/core/commands/card.ts
 function card(ctx, config) {
-  ctx.command("card").alias("卡片管理").userFields(["defaultCardId", "defaultServerId", "id"]).channelFields(["defaultServerId", "id"]).action(async ({ session }) => {
+  ctx.command("card").alias("卡片管理").userFields(["id"]).channelFields(["id"]).action(async ({ session }) => {
     const cardService = new CardService(ctx);
     const serverService = new ServerService(ctx);
     const userService = new UserService(ctx);
+    const defaultCard = await cardService.getDefaultCardByUid(session.user.id);
+    const defaultCardId = defaultCard ? defaultCard.id : 0;
+    const userDefaultServer = await serverService.getDefaultServerByUid(session.user.id);
+    const userDefaultServerId = userDefaultServer ? userDefaultServer.id : 0;
+    const channelDefaultServer = await serverService.getDefaultServerByCid(session.platform, session.channel.id);
+    const channelDefaultServerId = channelDefaultServer ? channelDefaultServer.id : 0;
     return await showCardSelectMenu(
       ctx,
       session,
@@ -639,10 +699,10 @@ function card(ctx, config) {
       serverService,
       userService,
       session.user.id,
-      session.user.defaultCardId,
-      session.user.defaultServerId,
+      defaultCardId,
+      userDefaultServerId,
       session.channel.id,
-      session.channel.defaultServerId
+      channelDefaultServerId
     );
   });
 }
@@ -793,31 +853,39 @@ var serverValues = ["asphyxia", "mao"];
 
 // src/core/commands/server.ts
 function server(ctx, config) {
-  ctx.command("server").alias("服务器管理").option("channel", "-c").userFields(["defaultServerId", "id"]).channelFields(["defaultServerId", "id"]).action(async ({ session, options }) => {
+  ctx.command("server").alias("服务器管理").option("channel", "-c").userFields(["id"]).channelFields(["id"]).action(async ({ session, options }) => {
     const serverService = new ServerService(ctx);
     const userService = new UserService(ctx);
     if (options.channel) {
       if (!hasPermission(isGuildAdmin(session), isPluginAdmin(session, config))) return session.text(".no-auth");
+      const userDefaultServer2 = await serverService.getDefaultServerByUid(session.user.id);
+      const userDefaultServerId2 = userDefaultServer2 ? userDefaultServer2.id : 0;
+      const channelDefaultServer2 = await serverService.getDefaultServerByCid(session.platform, session.channel.id);
+      const channelDefaultServerId2 = channelDefaultServer2 ? channelDefaultServer2.id : 0;
       return await showChannelServerSelectMenu(
         ctx,
         session,
         serverService,
         userService,
         session.user.id,
-        session.user.defaultServerId,
+        userDefaultServerId2,
         session.channel.id,
-        session.channel.defaultServerId
+        channelDefaultServerId2
       );
     }
+    const userDefaultServer = await serverService.getDefaultServerByUid(session.user.id);
+    const userDefaultServerId = userDefaultServer ? userDefaultServer.id : 0;
+    const channelDefaultServer = await serverService.getDefaultServerByCid(session.platform, session.channel.id);
+    const channelDefaultServerId = channelDefaultServer ? channelDefaultServer.id : 0;
     return await showUserServerSelectMenu(
       ctx,
       session,
       serverService,
       userService,
       session.user.id,
-      session.user.defaultServerId,
+      userDefaultServerId,
       session.channel.id,
-      session.channel.defaultServerId
+      channelDefaultServerId
     );
   });
 }
@@ -1193,6 +1261,9 @@ var Asphyxia = class {
   supportedGames = ["sdvx", "iidx"];
   gameServices = {};
   logger = new import_koishi4.Logger("Noah-Asphyxia");
+  /**
+   * 初始化各个游戏服务实例
+   */
   constructor() {
     this.gameServices["sdvx"] = SDVXService.getInstance(this.logger);
     this.gameServices["iidx"] = IIDXService.getInstance(this.logger);
@@ -1204,7 +1275,7 @@ var import_koishi5 = require("koishi");
 
 // src/servers/utils/grade.ts
 function getSDVXGrade(score) {
-  if (score > 99e5) return "S";
+  if (score >= 99e5) return "S";
   if (score >= 98e5) return "AAA+";
   if (score >= 97e5) return "AAA";
   if (score >= 95e5) return "AA+";
@@ -1323,12 +1394,23 @@ var MusicService = class _MusicService {
   constructor(config) {
     this.sdvx_data_url = config.sdvx_data_url;
   }
+  /**
+   * 获取 MusicService 实例
+   * @param config - SDVX 配置对象
+   * @returns MusicService 实例
+   */
   static getInstance(config) {
     if (!_MusicService.instance) {
       _MusicService.instance = new _MusicService(config);
     }
     return _MusicService.instance;
   }
+  /**
+   * 获取音乐信息
+   * @param ctx - Koishi 上下文对象
+   * @param musicIds - 音乐 ID 数组
+   * @returns 音乐信息数组
+   */
   async getMusic(ctx, musicIds) {
     try {
       const response = await ctx.http.post(`/music`, {
@@ -1621,6 +1703,9 @@ var Mao = class {
   supportedGames = ["sdvx"];
   gameServices = {};
   logger = new import_koishi5.Logger("Noah-Mao");
+  /**
+   * 初始化SDVX游戏服务实例
+   */
   constructor() {
     this.gameServices["sdvx"] = SDVXService2.getInstance(this.logger);
   }
@@ -1632,6 +1717,12 @@ var ServerFactory = class {
     __name(this, "ServerFactory");
   }
   serverInstances = /* @__PURE__ */ new Map();
+  /**
+   * 根据服务器类型获取服务器实例，如果不存在则创建新实例
+   * @param serverType - 服务器类型
+   * @returns 对应的服务器实例
+   * @throws 当请求不支持的服务器类型时抛出异常
+   */
   getServer(serverType) {
     if (!this.serverInstances.has(serverType)) {
       let serverInstance;
@@ -1662,15 +1753,30 @@ var ServerManager = class _ServerManager {
   constructor() {
     this.factory = new ServerFactory();
   }
+  /**
+   * 获取服务器管理器实例
+   * @returns 服务器管理器的唯一实例
+   */
   static getInstance() {
     if (!_ServerManager.instance) {
       _ServerManager.instance = new _ServerManager();
     }
     return _ServerManager.instance;
   }
+  /**
+   * 根据服务器类型获取对应的服务器实例
+   * @param serverType - 服务器类型
+   * @returns 对应的服务器实例
+   */
   getServer(serverType) {
     return this.factory.getServer(serverType);
   }
+  /**
+   * 根据服务器类型和游戏类型获取对应的游戏服务实例
+   * @param serverType - 服务器类型
+   * @param gameType - 游戏类型
+   * @returns 对应的游戏服务实例
+   */
   getGameService(serverType, gameType) {
     const server2 = this.factory.getServer(serverType);
     return server2.gameServices[gameType];
@@ -1688,6 +1794,10 @@ var ScoreService = class _ScoreService {
   static instance;
   constructor() {
   }
+  /**
+   * 获取 ScoreService 实例
+   * @returns ScoreService 实例
+   */
   static getInstance() {
     if (!_ScoreService.instance) {
       _ScoreService.instance = new _ScoreService();
@@ -1695,17 +1805,17 @@ var ScoreService = class _ScoreService {
     return _ScoreService.instance;
   }
   /**
-   * Sort scores by volforce in descending order
-   * @param scores Array of SDVX scores to sort
-   * @returns New array of scores sorted by volforce (highest to lowest)
+   * 按 Volforce 降序排序分数
+   * @param scores - 待排序的 SDVX 分数数组
+   * @returns 按 Volforce 降序排序的新数组
    */
   sortByVolforce(scores) {
     return [...scores].sort((a, b) => b.extra.volforce - a.extra.volforce);
   }
   /**
-   * Get the top 50 scores by volforce, including ties
-   * @param scores Array of SDVX scores to process
-   * @returns Array of scores with highest volforce values (may exceed 50 if there are ties)
+   * 获取前 50 名分数（包括并列）
+   * @param scores - 待处理的 SDVX 分数数组
+   * @returns 包含最高 Volforce 值的分数数组（如果存在并列，可能超过 50 个）
    */
   getBest50(scores) {
     const sortedScores = this.sortByVolforce(scores);
@@ -1736,10 +1846,10 @@ var BaseDrawer = class {
     __name(this, "BaseDrawer");
   }
   /**
-   * Compress an image buffer
-   * @param canvas The canvas object to compress
-   * @param compression Compression options
-   * @returns Promise resolving to a compressed buffer
+   * 压缩图片缓冲区
+   * @param canvas - 要压缩的canvas对象
+   * @param compression - 压缩选项
+   * @returns 压缩后的缓冲区
    */
   async compressImage(canvas, compression) {
     if (!compression) {
@@ -1750,7 +1860,7 @@ var BaseDrawer = class {
         const pngBuffer = await canvas.toBuffer("png");
         return (0, import_sharp.default)(pngBuffer).png({
           compressionLevel: 9,
-          // Maximum compression
+          // 最大压缩
           adaptiveFiltering: true,
           progressive: true
         }).toBuffer();
@@ -1775,10 +1885,10 @@ var CoreDrawer = class extends BaseDrawer {
     __name(this, "CoreDrawer");
   }
   /**
-   * Generate a generic image for core functionality
-   * @param options Configuration options for image generation
-   * @param compression Compression options
-   * @returns Promise resolving to a Buffer containing the image data
+   * 生成通用图像
+   * @param options - 图像生成配置选项
+   * @param compression - 压缩选项
+   * @returns 包含图像数据的Buffer
    */
   async generateImage(options, compression) {
     const { Canvas, loadImage } = this.ctx.skia;
@@ -1833,10 +1943,10 @@ var SDVXDrawer = class extends BaseDrawer {
   }
   // TODO: 添加最近图片的生成
   /**
-   * Generate a Recent image for SDVX scores
-   * @param options Configuration options for image generation
-   * @param compression Compression options
-   * @returns Promise resolving to a Buffer containing the image data
+   * 生成SDVX最近成绩图像
+   * @param options - 图像生成配置选项
+   * @param compression - 压缩选项
+   * @returns 包含图像数据的Buffer
    */
   async generateRecentImage(options, compression) {
     const { Canvas, loadImage, FontLibrary } = this.ctx.skia;
@@ -1853,10 +1963,10 @@ var SDVXDrawer = class extends BaseDrawer {
     return this.compressImage(canvas, compression);
   }
   /**
-   * Generate a Volforce image for SDVX scores
-   * @param options Configuration options for image generation
-   * @param compression Compression options
-   * @returns Promise resolving to a Buffer containing the image data
+   * 生成SDVX Volforce图像
+   * @param options - 图像生成配置选项
+   * @param compression - 压缩选项
+   * @returns 包含图像数据的Buffer
    */
   async generateVFImage(options, compression) {
     const { Canvas, loadImage, FontLibrary } = this.ctx.skia;
@@ -1915,7 +2025,12 @@ var SDVXDrawer = class extends BaseDrawer {
     return this.compressImage(canvas, compression);
   }
   /**
-   * Draw score cards on the canvas
+   * 在画布上绘制成绩卡片
+   * @param ctx - Canvas上下文
+   * @param scores - 成绩数组
+   * @param cardBgImage - 卡片背景图像
+   * @param loadImage - 图像加载函数
+   * @param config - SDVX配置
    */
   async drawScoreCards(ctx, scores, cardBgImage, loadImage, config) {
     if (scores.length === 0) return;
@@ -2282,10 +2397,10 @@ var IIDXDrawer = class extends BaseDrawer {
     __name(this, "IIDXDrawer");
   }
   /**
-   * Generate an image for IIDX data
-   * @param options Configuration options for image generation
-   * @param compression Compression options
-   * @returns Promise resolving to a Buffer containing the image data
+   * 生成IIDX游戏数据图像
+   * @param options - 图像生成配置选项
+   * @param compression - 压缩选项
+   * @returns 包含图像数据的Buffer
    */
   async generateImage(options, compression) {
     const { Canvas, loadImage } = this.ctx.skia;
@@ -2317,7 +2432,13 @@ var IIDXDrawer = class extends BaseDrawer {
     return this.compressImage(canvas, compression);
   }
   /**
-   * Draw ranking information
+   * 绘制段位信息
+   * @param ctx - Canvas上下文
+   * @param centerX - 中心X坐标
+   * @param y - 起始Y坐标
+   * @param sp_dan - sp 段位
+   * @param dp_dan - dp 段位
+   * @param textColor - 文字颜色
    */
   drawRankingInfo(ctx, centerX, y, sp_dan, dp_dan, textColor) {
     ctx.fillStyle = textColor;
@@ -2342,6 +2463,12 @@ var DrawerFactory = class {
     __name(this, "DrawerFactory");
   }
   drawerInstances = /* @__PURE__ */ new Map();
+  /**
+   * 根据绘图类型获取绘图实例，如果不存在则创建新实例
+   * @param drawerType - 绘图类型（游戏类型或核心类型）
+   * @returns 对应的绘图实例
+   * @throws 当请求不支持的绘图类型时抛出异常
+   */
   getDrawer(drawerType) {
     if (!this.drawerInstances.has(drawerType)) {
       let drawerInstance;
@@ -2377,15 +2504,25 @@ var DrawerManager = class _DrawerManager {
     this.factory = new DrawerFactory(ctx);
     this.logger = new import_koishi6.Logger("Noah-Drawer");
   }
+  /**
+   * 获取绘图管理器实例
+   * @param ctx - Koishi上下文
+   * @returns 绘图管理器的唯一实例
+   */
   static getInstance(ctx) {
     if (!_DrawerManager.instance) {
       _DrawerManager.instance = new _DrawerManager(ctx);
     }
     return _DrawerManager.instance;
   }
-  getDrawer(gameType) {
-    this.logger.info(`Getting drawer for ${gameType}`);
-    return this.factory.getDrawer(gameType);
+  /**
+   * 根据插件类型获取对应的绘图实例
+   * @param pluginType - 插件类型
+   * @returns 对应的绘图实例
+   */
+  getDrawer(pluginType) {
+    this.logger.info(`Getting drawer for ${pluginType}`);
+    return this.factory.getDrawer(pluginType);
   }
 };
 function apply6(ctx, config) {
@@ -2408,12 +2545,14 @@ function vf(ctx, config) {
     if (serverRes.length === 0) return session.text(".server-not-found");
     let cardCode = "";
     if (!options.card) {
-      const cardRes = await cardService.getCardById(session.user.defaultCardId);
-      cardCode = cardRes.code;
+      const defaultCard = await cardService.getDefaultCardByUid(session.user.id);
+      if (!defaultCard) return session.text(".card-not-found");
+      cardCode = defaultCard.code;
     } else {
       let cardListMsg = "";
       for (let i = 0; i < userCards.length; i++) {
-        if (userCards[i].id === session.user.defaultCardId) {
+        const defaultCard = await cardService.getDefaultCardByUid(session.user.id);
+        if (defaultCard && userCards[i].id === defaultCard.id) {
           cardListMsg += `<p>${i + 1}. ${userCards[i].name} < 默认卡片</p>`;
         } else {
           cardListMsg += `<p>${i + 1}. ${userCards[i].name}</p>`;
@@ -2433,9 +2572,15 @@ function vf(ctx, config) {
     const card2 = await cardService.getCardByCode(cardCode);
     let server2;
     if (card2.defaultServerId != void 0 && card2.defaultServerId != 0) server2 = await serverService.getServerById(card2.defaultServerId);
-    else if (session.channel.defaultServerId != void 0 && session.channel.defaultServerId != 0) server2 = await serverService.getServerById(session.channel.defaultServerId);
-    else if (session.user.defaultServerId != void 0 && session.user.defaultServerId != 0) server2 = await serverService.getServerById(session.user.defaultServerId);
-    else return session.text(".server-not-found");
+    else {
+      const channelDefaultServer = await serverService.getDefaultServerByCid(session.platform, session.channel.id);
+      if (channelDefaultServer) server2 = channelDefaultServer;
+      else {
+        const userDefaultServer = await serverService.getDefaultServerByUid(session.user.id);
+        if (userDefaultServer) server2 = userDefaultServer;
+        else return session.text(".server-not-found");
+      }
+    }
     const serverManager = ServerManager.getInstance();
     const sdvxService = serverManager.getGameService(server2.type, "sdvx");
     const scoreService = ScoreService.getInstance();