@sjtdev/koishi-plugin-dota2tracker 1.1.2-hotfix.2 → 1.1.3

package/lib/index.js

@@ -50,6 +50,7 @@ __export(utils_exports, {
   playerisValid: () => playerisValid,
   query: () => query,
   readDirectoryFilesSync: () => readDirectoryFilesSync,
+  roundToDecimalPlaces: () => roundToDecimalPlaces,
   sec2time: () => sec2time,
   winRateColor: () => winRateColor
 });
@@ -189,6 +190,32 @@ function MATCH_INFO(matchId) {
 `;
 }
 __name(MATCH_INFO, "MATCH_INFO");
+function MATCHES_FOR_DAILY(steamAccountIds, seconds) {
+  return `
+  {
+    players(steamAccountIds:${JSON.stringify(steamAccountIds)}) {
+      steamAccount{id name}
+      matches(request:{startDateTime:${seconds} take:50}){
+        id
+        didRadiantWin
+        parsedDateTime
+        startDateTime
+        players {
+          kills
+          deaths
+          assists
+          imp
+          isRadiant
+          steamAccount {
+            id
+          }
+        }
+      }
+    }
+  }
+  `;
+}
+__name(MATCHES_FOR_DAILY, "MATCHES_FOR_DAILY");
 function VERIFYING_PLAYER(steamAccountId) {
   return `
     {
@@ -221,7 +248,7 @@ function PLAYERS_LASTMATCH(steamAccountIds) {
     `;
 }
 __name(PLAYERS_LASTMATCH, "PLAYERS_LASTMATCH");
-function PLAYER_INFO_WITH_25_MATCHES(steamAccountId) {
+function PLAYER_INFO_WITH_25_MATCHES(steamAccountId, heroId) {
   return `
     {
 		player(steamAccountId: ${steamAccountId}) {
@@ -242,7 +269,7 @@ function PLAYER_INFO_WITH_25_MATCHES(steamAccountId) {
 		  performance {
 			imp
 		  }
-		  heroesPerformance(take: 25, request: {matchGroupOrderBy: WIN_COUNT, take: 25}) {
+		  heroesPerformance(take: 25, request: {matchGroupOrderBy: WIN_COUNT take: 25 ${heroId ? "heroIds:" + heroId : ""}}) {
 			hero {
 			  id
 			  shortName
@@ -251,7 +278,7 @@ function PLAYER_INFO_WITH_25_MATCHES(steamAccountId) {
 			winCount
 			matchCount
 		  }
-		  matches(request: {take: 25}) {
+		  matches(request: {take: 25 ${heroId ? "heroIds:" + heroId : ""}}) {
 			id
 			rank
       lobbyType
@@ -286,10 +313,10 @@ function PLAYER_INFO_WITH_25_MATCHES(steamAccountId) {
       `;
 }
 __name(PLAYER_INFO_WITH_25_MATCHES, "PLAYER_INFO_WITH_25_MATCHES");
-function PLAYER_EXTRA_INFO(steamAccountId, matchCount, totalHeroCount) {
+function PLAYER_EXTRA_INFO(steamAccountId, matchCount, totalHeroCount, heroId) {
   return `{
         player(steamAccountId: ${steamAccountId}) {
-          heroesPerformance(take: ${totalHeroCount}, request: {matchGroupOrderBy: MATCH_COUNT, take: ${matchCount}}) {
+          heroesPerformance(take: ${totalHeroCount}, request: {matchGroupOrderBy: MATCH_COUNT, take: ${matchCount} ${heroId ? "heroIds:" + heroId : ""}}) {
             hero {
               id
               shortName
@@ -778,6 +805,11 @@ async function playerisValid(steamAccountId) {
   }
 }
 __name(playerisValid, "playerisValid");
+function roundToDecimalPlaces(number, decimalPlaces) {
+  const factor = Math.pow(10, decimalPlaces);
+  return Math.round(number * factor) / factor;
+}
+__name(roundToDecimalPlaces, "roundToDecimalPlaces");
 
 // src/index.ts
 var import_fs2 = __toESM(require("fs"));
@@ -1055,12 +1087,24 @@ var dotaconstants_add_default = {
 var import_koishi2 = require("koishi");
 var ejs = __toESM(require("ejs"));
 var name = "dota2tracker";
-var usage = "DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑定），以及一系列查询功能。";
+var usage = `
+DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑定），以及一系列查询功能。  
+**更多信息请进入插件主页查看。**`;
 var inject = ["database", "puppeteer", "cron"];
 var Config = import_koishi.Schema.intersect([
   import_koishi.Schema.object({
     STRATZ_API_TOKEN: import_koishi.Schema.string().required().description("※必须。stratz.com的API TOKEN，可在 https://stratz.com/api 获取")
   }).description("基础设置"),
+  import_koishi.Schema.object({
+    dailyReportSwitch: import_koishi.Schema.boolean().default(false).description("日报功能").experimental()
+  }),
+  import_koishi.Schema.union([
+    import_koishi.Schema.object({
+      dailyReportSwitch: import_koishi.Schema.const(true).required(),
+      dailyReportHours: import_koishi.Schema.number().min(0).max(23).default(6).description("日报时间小时")
+    }),
+    import_koishi.Schema.object({})
+  ]),
   import_koishi.Schema.object({
     template_match: import_koishi.Schema.union([...readDirectoryFilesSync(`./node_modules/@sjtdev/koishi-plugin-${name}/template/match`)]).default("match_1").description("生成比赛信息图片使用的模板，见 https://github.com/sjtdev/koishi-plugin-dota2tracker/wiki 有模板展示。"),
     template_player: import_koishi.Schema.union([...readDirectoryFilesSync(`./node_modules/@sjtdev/koishi-plugin-${name}/template/player`)]).default("player_1").description("生成玩家信息图片使用的模板。（目前仅有一张模板）"),
@@ -1254,7 +1298,7 @@ async function apply(ctx, config) {
       queryAndDisplayMatch(session, lastMatchId);
     }
   });
-  ctx.command("查询玩家 <input_data>", "查询玩家信息").usage("查询指定玩家的个人信息与最近战绩，生成图片发布。\n参数可输入该玩家的SteamID或已在本群绑定玩家的别名，无参数时尝试查询调用指令玩家的SteamID").example("-查询玩家 123456789").example("-查询玩家 张三").action(async ({ session }, input_data) => {
+  ctx.command("查询玩家 <input_data>", "查询玩家信息，可指定英雄").usage("查询指定玩家的个人信息与最近战绩，生成图片发布。\n参数可输入该玩家的SteamID或已在本群绑定玩家的别名，无参数时尝试查询调用指令玩家的SteamID").option("hero", "-o <value:string> 查询玩家指定英雄使用情况（同其他英雄查询，可用简称与ID）").example("-查询玩家 123456789").example("-查询玩家 张三").example("-查询玩家 张三 hero 敌法师").action(async ({ session, options }, input_data) => {
     if (session.guild) {
       let sessionPlayer;
       if (!input_data) {
@@ -1270,15 +1314,16 @@ async function apply(ctx, config) {
         return;
       }
       session.send("正在获取玩家数据，请稍后...");
+      let hero = findingHero(options.hero);
       let steamId = flagBindedPlayer?.steamId ?? input_data;
       let player;
       try {
-        let queryRes = await query(PLAYER_INFO_WITH_25_MATCHES(steamId));
+        let queryRes = await query(PLAYER_INFO_WITH_25_MATCHES(steamId, hero.id));
         if (queryRes.status == 200) {
           player = queryRes.data.data.player;
         } else
           throw 0;
-        let queryRes2 = await query(PLAYER_EXTRA_INFO(steamId, player.matchCount, Object.keys(dotaconstants3.heroes).length));
+        let queryRes2 = await query(PLAYER_EXTRA_INFO(steamId, player.matchCount, Object.keys(dotaconstants3.heroes).length, hero.id));
         if (queryRes2.status == 200) {
           let playerExtra = queryRes2.data.data.player;
           let filteredDotaPlus = {};
@@ -1290,11 +1335,11 @@ async function apply(ctx, config) {
               };
             }
           });
-          playerExtra.heroesPerformance.forEach((hero) => {
-            if (filteredDotaPlus[hero.hero.id]) {
-              filteredDotaPlus[hero.hero.id].shortName = hero.hero.shortName;
-              filteredDotaPlus[hero.hero.id].winCount = hero.winCount;
-              filteredDotaPlus[hero.hero.id].matchCount = hero.matchCount;
+          playerExtra.heroesPerformance.forEach((hero2) => {
+            if (filteredDotaPlus[hero2.hero.id]) {
+              filteredDotaPlus[hero2.hero.id].shortName = hero2.hero.shortName;
+              filteredDotaPlus[hero2.hero.id].winCount = hero2.winCount;
+              filteredDotaPlus[hero2.hero.id].matchCount = hero2.matchCount;
             }
           });
           player.dotaPlus = Object.values(filteredDotaPlus);
@@ -1307,6 +1352,7 @@ async function apply(ctx, config) {
           player.heroesPerformanceTop10 = playerExtra.heroesPerformance.slice(0, 10);
         } else
           throw 0;
+        player.genHero = hero ? true : false;
         session.send(await ctx.puppeteer.render(genImageHTML(player, config.template_player, "player" /* Player */)));
       } catch (error) {
         ctx.logger.error(error);
@@ -1316,24 +1362,8 @@ async function apply(ctx, config) {
   });
   ctx.command("查询英雄 <input_data>", "查询英雄技能/面板信息").usage("查询英雄的技能说明与各项数据，生成图片发布。\n参数可输入英雄ID、英雄名、英雄常用别名").example("-查询英雄 15").example("-查询英雄 雷泽").example("-查询英雄 电魂").action(async ({ session }, input_data) => {
     if (input_data) {
-      let dc_heroes = Object.values(dotaconstants3.heroes).map((hero) => ({ id: hero["id"], name: hero["name"], shortName: hero["name"].match(/^npc_dota_hero_(.+)$/)[1] }));
-      let cn_heroes = Object.keys(HEROES_CHINESE).map((key) => ({
-        id: parseInt(key),
-        names_cn: HEROES_CHINESE[key]
-      }));
-      const mergedMap = /* @__PURE__ */ new Map();
-      [dc_heroes, cn_heroes].forEach((array) => {
-        array.forEach((item) => {
-          const existingItem = mergedMap.get(item.id);
-          if (existingItem)
-            mergedMap.set(item.id, { ...existingItem, ...item });
-          else
-            mergedMap.set(item.id, item);
-        });
-      });
-      let heroes3 = Array.from(mergedMap.values());
-      let findingHero = heroes3.find((hero) => hero.names_cn.includes(input_data) || hero.shortName === input_data.toLowerCase() || hero.id == input_data);
-      if (!findingHero) {
+      let hero = findingHero(input_data);
+      if (!hero) {
         session.send("未找到输入的英雄，请确认后重新输入。");
         return;
       }
@@ -1356,11 +1386,11 @@ async function apply(ctx, config) {
           }
         } else
           throw 0;
-        let queryRes3 = await query(HERO_INFO(findingHero.id));
+        let queryRes3 = await query(HERO_INFO(hero.id));
         if (queryRes3.status == 200) {
-          let hero = queryRes3.data.data.constants.hero;
-          hero.talents.forEach((talent) => talent.name_cn = AbilitiesConstantsCN.data.abilities.find((item) => item.id == talent.abilityId).language.displayName);
-          await session.send(await ctx.puppeteer.render(genImageHTML(hero, config.template_hero, "hero" /* Hero */)));
+          let hero2 = queryRes3.data.data.constants.hero;
+          hero2.talents.forEach((talent) => talent.name_cn = AbilitiesConstantsCN.data.abilities.find((item) => item.id == talent.abilityId).language.displayName);
+          await session.send(await ctx.puppeteer.render(genImageHTML(hero2, config.template_hero, "hero" /* Hero */)));
         } else
           throw 0;
       } catch (error) {
@@ -1374,29 +1404,13 @@ async function apply(ctx, config) {
   });
   ctx.command("查询英雄对战 <input_data:string>", "查询英雄近一周的最佳搭档与最佳克星英雄").usage("根据输入英雄查询最近一周比赛数据（传奇~万古分段）中与该英雄组合胜率最高英雄和与该英雄对抗胜率最低英雄。\n参数可输入英雄ID、英雄名、英雄常用别名").option("limit", "-l <value:number> 返回英雄个数（默认值 5）", { fallback: 5 }).option("filter", "-f <value:number> 过滤场数过低的组合（单位：%，默认值0.75）", { fallback: 0.5 }).example("-查询英雄对战 敌法师	（无额外参数默认返回5个英雄，过滤舍弃场次占比0.75%以下）").example("-查询英雄对战 敌法师 -l=10 -f=1	（返回10个英雄，过滤舍弃场次占比1%以下）").example("-查询英雄对战 敌法师 -l 10 -f 1	（等同于上例，参数接空格也可使用）").action(async ({ session, options }, input_data) => {
     if (input_data) {
-      let dc_heroes = Object.values(dotaconstants3.heroes).map((hero) => ({ id: hero["id"], name: hero["name"], shortName: hero["name"].match(/^npc_dota_hero_(.+)$/)[1] }));
-      let cn_heroes = Object.keys(HEROES_CHINESE).map((key) => ({
-        id: parseInt(key),
-        names_cn: HEROES_CHINESE[key]
-      }));
-      const mergedMap = /* @__PURE__ */ new Map();
-      [dc_heroes, cn_heroes].forEach((array) => {
-        array.forEach((item) => {
-          const existingItem = mergedMap.get(item.id);
-          if (existingItem)
-            mergedMap.set(item.id, { ...existingItem, ...item });
-          else
-            mergedMap.set(item.id, item);
-        });
-      });
-      let heroes3 = Array.from(mergedMap.values());
-      let findingHero = heroes3.find((hero) => hero.names_cn.includes(input_data) || hero.shortName === input_data.toLowerCase() || hero.id == input_data);
-      if (!findingHero) {
+      let hero = findingHero(input_data);
+      if (!hero) {
         session.send("未找到输入的英雄，请确认后重新输入。");
         return;
       }
       try {
-        let queryRes = await query(HERO_MATCHUP_WINRATE(findingHero.id));
+        let queryRes = await query(HERO_MATCHUP_WINRATE(hero.id));
         if (queryRes.status == 200) {
           let heroStats = queryRes.data.data.heroStats;
           let withTopFive = heroStats.matchUp[0].with.filter((item) => item.matchCount / heroStats.matchUp[0].matchCountWith > Math.max(0, Math.min(5, options.filter)) / 100).map((item) => {
@@ -1421,6 +1435,28 @@ async function apply(ctx, config) {
       }
     }
   });
+  function findingHero(input) {
+    if (!input)
+      return;
+    let dc_heroes = Object.values(dotaconstants3.heroes).map((hero) => ({ id: hero["id"], name: hero["name"], shortName: hero["name"].match(/^npc_dota_hero_(.+)$/)[1] }));
+    let cn_heroes = Object.keys(HEROES_CHINESE).map((key) => ({
+      id: parseInt(key),
+      names_cn: HEROES_CHINESE[key]
+    }));
+    const mergedMap = /* @__PURE__ */ new Map();
+    [dc_heroes, cn_heroes].forEach((array) => {
+      array.forEach((item) => {
+        const existingItem = mergedMap.get(item.id);
+        if (existingItem)
+          mergedMap.set(item.id, { ...existingItem, ...item });
+        else
+          mergedMap.set(item.id, item);
+      });
+    });
+    let heroes3 = Array.from(mergedMap.values());
+    return heroes3.find((hero) => hero.names_cn.includes(input) || hero.shortName === input.toLowerCase() || hero.id == input);
+  }
+  __name(findingHero, "findingHero");
   ctx.on("ready", async () => {
     const tables = await ctx.database.tables;
     if (!("dt_subscribed_guilds" in tables)) {
@@ -1443,6 +1479,78 @@ async function apply(ctx, config) {
       ctx.database.remove("dt_sended_match_id", { sendTime: { $lt: oneMonthAgo } });
       ctx.database.remove("dt_previous_query_results", { queryTime: { $lt: oneMonthAgo } });
     });
+    if (config.dailyReportSwitch) {
+      ctx.cron(`0 ${config.dailyReportHours} * * *`, async function() {
+        const oneDayAgo = (0, import_moment.default)().subtract(1, "days").unix();
+        const subscribedGuilds = await ctx.database.get("dt_subscribed_guilds", void 0);
+        const subscribedPlayersInGuild = (await ctx.database.get("dt_subscribed_players", void 0)).filter((player) => subscribedGuilds.some((guild) => guild.guildId == player.guildId));
+        let queryRes = await query(
+          MATCHES_FOR_DAILY(
+            subscribedPlayersInGuild.map((player) => player.steamId).filter((value, index, self) => self.indexOf(value) === index),
+            oneDayAgo
+          )
+        );
+        const players = queryRes.data.data.players.filter((player) => player.matches.length > 0);
+        const matches = players.map((player) => player.matches.map((match) => match)).flat().filter((item, index, self) => index === self.findIndex((t) => t.id === item.id));
+        for (let subPlayer of subscribedPlayersInGuild) {
+          let player = players.find((player2) => subPlayer.steamId == player2.steamAccount.id);
+          if (!player)
+            continue;
+          const guildMember = await ctx.bots.find((bot) => bot.platform == subPlayer.platform)?.getGuildMember(subPlayer.guildId, subPlayer.userId);
+          subPlayer.name = subPlayer.nickName || (guildMember?.nick ?? players.find((player2) => player2.steamAccount.id == subPlayer.steamId)?.steamAccount.name);
+          player.winCount = player.matches.filter((match) => match.didRadiantWin == match.players.find((innerPlayer) => innerPlayer.steamAccount.id == player.steamAccount.id).isRadiant).length;
+          player.loseCount = player.matches.length - player.winCount;
+          player.avgKills = roundToDecimalPlaces(player.matches.reduce((acc, match) => acc + match.players.find((innerPlayer) => innerPlayer.steamAccount.id == player.steamAccount.id).kills, 0) / player.matches.length, 2);
+          player.avgDeaths = roundToDecimalPlaces(player.matches.reduce((acc, match) => acc + match.players.find((innerPlayer) => innerPlayer.steamAccount.id == player.steamAccount.id).deaths, 0) / player.matches.length, 2);
+          player.avgAssists = roundToDecimalPlaces(
+            player.matches.reduce((acc, match) => acc + match.players.find((innerPlayer) => innerPlayer.steamAccount.id == player.steamAccount.id).assists, 0) / player.matches.length,
+            2
+          );
+          player.avgKDA = roundToDecimalPlaces((player.avgKills + player.avgAssists) / (player.avgDeaths || 1), 2);
+          player.avgImp = roundToDecimalPlaces(player.matches.reduce((acc, match) => acc + match.players.find((innerPlayer) => innerPlayer.steamAccount.id == player.steamAccount.id).imp, 0) / player.matches.length, 0);
+          subPlayer = Object.assign(subPlayer, player);
+        }
+        for (let guild of subscribedGuilds) {
+          const currentsubscribedPlayers = subscribedPlayersInGuild.filter((player) => player.platform == guild.platform && player.guildId == guild.guildId && player.matches?.length);
+          if (currentsubscribedPlayers.length) {
+            const currentsubscribedPlayersIds = currentsubscribedPlayers.map((player) => player.steamId);
+            const combinationsMap = /* @__PURE__ */ new Map();
+            matches.forEach((match) => {
+              const sortedPlayerIds = match.players.map((player) => player.steamAccount.id).filter((id) => currentsubscribedPlayersIds.includes(id)).sort((a, b) => a.steamId - b.steamId);
+              const key = sortedPlayerIds.join(",");
+              if (!combinationsMap.has(key)) {
+                const players2 = currentsubscribedPlayers.filter((subPlayer) => sortedPlayerIds.includes(subPlayer.steamId));
+                if (players2.length > 0) {
+                  const name2 = players2.map((subPlayer) => subPlayer.name).join("/");
+                  combinationsMap.set(key, {
+                    players: players2,
+                    name: name2,
+                    winCount: match.didRadiantWin == match.players.find((innerPlayer) => innerPlayer.steamAccount.id == players2[0].steamId).isRadiant ? 1 : 0,
+                    matches: [match]
+                  });
+                }
+              } else {
+                const combi = combinationsMap.get(key);
+                combi.matches.push(match);
+                combi.winCount += match.didRadiantWin == match.players.find((innerPlayer) => innerPlayer.steamAccount.id == combi.players[0].steamId).isRadiant ? 1 : 0;
+              }
+            });
+            const combinations = Array.from(combinationsMap.values());
+            await ctx.broadcast(
+              [`${guild.platform}:${guild.guildId}`],
+              `昨日总结：
+                            ${currentsubscribedPlayers.map(
+                (player) => `${player.name}: ${player.winCount}胜${player.loseCount}负 胜率${Math.round(player.winCount / player.matches.length * 100)}%，平均KDA: [${player.avgKills}/${player.avgDeaths}/${player.avgAssists}](${player.avgKDA})，平均表现: ${player.avgImp > 0 ? "+" : ""}${player.avgImp}`
+              ).join("\n")}
+                            ${combinations.map((combi) => `组合[${combi.name}]: ${combi.winCount}胜${combi.matches.length - combi.winCount}负 胜率${Math.round(combi.winCount / combi.matches.length * 100)}%`).join("\n")}`.replace(
+                /\s*\n\s*/g,
+                "\n"
+              )
+            );
+          }
+        }
+      });
+    }
     ctx.cron("* * * * *", async function() {
       const subscribedGuilds = await ctx.database.get("dt_subscribed_guilds", void 0);
       const subscribedPlayersInGuild = (await ctx.database.get("dt_subscribed_players", void 0)).filter((player) => subscribedGuilds.some((guild) => guild.guildId == player.guildId));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sjtdev/koishi-plugin-dota2tracker",
   "description": "",
-  "version": "1.1.2-hotfix.2",
+  "version": "1.1.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -11,7 +11,8 @@
     "template"
   ],
   "contributors": [
-    "sjtdev <sh1j1n9ta0@foxmail.com>"
+    "sjtdev <sh1j1n9ta0@foxmail.com>",
+    "sjtdev"
   ],
   "homepage": "https://github.com/sjtdev/koishi-plugin-dota2tracker",
   "repository": {

package/readme.md

@@ -8,10 +8,10 @@ DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑
 
 ### 使用
 需在插件配置页填入STRATZ API TOKEN，否则无法使用。(配置中提供了API的获取链接)  
-在希望推送战报信息的群组使用指令【-订阅本群】，玩家可使用指令【-绑定】来将自身账号与Steam账号绑定，bot会尝试追踪已订阅群组中的绑定玩家的最新对局信息。  
+在希望推送战报信息的群组使用指令`订阅本群`，玩家可使用指令`绑定`来将自身账号与Steam账号绑定，bot会尝试追踪已订阅群组中的绑定玩家的最新对局信息。  
 其他查询功能见下方指令说明。  
-**直接调用help指令可获取更详细的说明，调用【指令 -h】还会有用法示例。（例如：订阅本群 -h）**
-**更新日志见[changelog](changelog.md)
+**直接调用help指令可获取更详细的说明，调用【指令 -h】还会有用法示例。（例如：订阅本群 -h）**  
+**更新日志见[changelog](changelog.md)**  
 
 ### 指令
 指令 <必填参数> [可选参数]

package/template/player/player_1.ejs

@@ -530,13 +530,14 @@
                 </tbody>
             </table>
             <div class="plus">
-                <%- player.dotaPlus.map((hero) => `
+                <%- !player.genHero?
+                player.dotaPlus.map((hero) => `
                 <div class="hero">
                     <img src="${utils.getImageUrl(hero.shortName, ImageType.Heroes)}" alt="" />
                     <div class="level"><img src="${utils.getImageUrl("hero_badge_" + Math.ceil((hero.level + 1) / 6))}" alt="" /><span>${hero.level}</span></div>
                     <span>${((hero.winCount / hero.matchCount) * 100).toFixed(2)}%</span>
                     <span>${hero.matchCount}</span>
-                </div>`).join("") %>
+                </div>`).join(""):"" %>
             </div>
         </div>
     </body>