@sjtdev/koishi-plugin-dota2tracker 1.2.19 → 1.2.20-pre.2

package/lib/index.js

@@ -60,474 +60,8 @@ __export(utils_exports, {
   winRateColor: () => winRateColor
 });
 var import_fs = __toESM(require("fs"));
-var dotaconstants2 = __toESM(require("dotaconstants"));
-var import_path = __toESM(require("path"));
-
-// src/queries.ts
-var queries_exports = {};
-__export(queries_exports, {
-  ALL_ABILITIES_CHINESE_NAME: () => ALL_ABILITIES_CHINESE_NAME,
-  CURRENT_GAMEVERSION: () => CURRENT_GAMEVERSION,
-  HERO_INFO: () => HERO_INFO,
-  HERO_MATCHUP_WINRATE: () => HERO_MATCHUP_WINRATE,
-  MATCH_INFO: () => MATCH_INFO,
-  PLAYERS_INFO_WITH_10_MATCHES_FOR_GUILD: () => PLAYERS_INFO_WITH_10_MATCHES_FOR_GUILD,
-  PLAYERS_LASTMATCH_RANKINFO: () => PLAYERS_LASTMATCH_RANKINFO,
-  PLAYERS_MATCHES_FOR_DAILY: () => PLAYERS_MATCHES_FOR_DAILY,
-  PLAYER_EXTRA_INFO: () => PLAYER_EXTRA_INFO,
-  PLAYER_INFO_WITH_25_MATCHES: () => PLAYER_INFO_WITH_25_MATCHES,
-  REQUEST_MATCH_DATA_ANALYSIS: () => REQUEST_MATCH_DATA_ANALYSIS,
-  VERIFYING_PLAYER: () => VERIFYING_PLAYER
-});
 var dotaconstants = __toESM(require("dotaconstants"));
-function MATCH_INFO(matchId) {
-  return `
-    {
-      match(id: ${matchId}) {
-        id
-        didRadiantWin
-        lobbyType
-        gameMode
-        regionId
-        parsedDateTime
-        startDateTime
-        endDateTime
-        actualRank
-        rank
-        averageRank
-        durationSeconds
-        topLaneOutcome
-        midLaneOutcome
-        bottomLaneOutcome
-        radiantKills
-        direKills
-        players {
-          steamAccountId
-          steamAccount {
-            name
-          }
-          level
-          hero {
-            id
-            name
-            shortName
-            facets {
-              facetId
-            }
-          }
-          variant
-          dotaPlus {
-            level
-          }
-          leaverStatus
-          partyId
-          position
-          playerSlot
-          lane
-          imp
-          kills
-          deaths
-          assists
-          isRadiant
-          networth
-          steamAccount {
-            seasonRank
-            seasonLeaderboardRank
-          }
-          item0Id
-          item1Id
-          item2Id
-          item3Id
-          item4Id
-          item5Id
-          backpack0Id
-          backpack1Id
-          backpack2Id
-          neutral0Id
-          stats {
-            matchPlayerBuffEvent {
-              abilityId
-              itemId
-              stackCount
-            }
-          }
-          heroDamage
-          towerDamage
-          stats {
-            heroDamageReport {
-              receivedTotal {
-                physicalDamage
-                magicalDamage
-                pureDamage
-              }
-            }
-          }
-          numLastHits
-          numDenies
-          goldPerMinute
-          experiencePerMinute
-          heroHealing
-          stats {
-            itemPurchases{
-              itemId
-              time
-            }
-            campStack
-            heroDamageReport {
-              dealtTotal {
-                stunDuration
-                stunCount
-                slowDuration
-                slowCount
-                disableDuration
-                disableCount
-              }
-            }
-          }
-          additionalUnit {
-            item0Id
-            item1Id
-            item2Id
-            item3Id
-            item4Id
-            item5Id
-            backpack0Id
-            backpack1Id
-            backpack2Id
-            neutral0Id
-          }
-          isRandom
-        }
-        pickBans {
-          isPick
-          bannedHeroId
-          heroId
-          order
-        }
-      }
-      constants {
-        facets (language: S_CHINESE) {
-          name
-          id
-          color
-          icon
-          language {
-            displayName
-          }
-        }
-      }
-    }
-    
-`;
-}
-__name(MATCH_INFO, "MATCH_INFO");
-function PLAYERS_MATCHES_FOR_DAILY(steamAccountIds, seconds) {
-  return `
-  {
-    players(steamAccountIds:[${steamAccountIds.join(",")}]) {
-      steamAccount{id name avatar}
-      matches(request:{startDateTime:${seconds} take:50}){
-        id
-        didRadiantWin
-        parsedDateTime
-        startDateTime
-        players {
-          kills
-          deaths
-          assists
-          imp
-          isRadiant
-          steamAccount {
-            id
-          }
-        }
-      }
-    }
-  }
-  `;
-}
-__name(PLAYERS_MATCHES_FOR_DAILY, "PLAYERS_MATCHES_FOR_DAILY");
-function VERIFYING_PLAYER(steamAccountId) {
-  return `
-    {
-        player(steamAccountId: ${steamAccountId}) {
-          matchCount
-        }
-      }
-      
-    `;
-}
-__name(VERIFYING_PLAYER, "VERIFYING_PLAYER");
-function PLAYERS_LASTMATCH_RANKINFO(steamAccountIds) {
-  return `
-    {
-        players(steamAccountIds:[${steamAccountIds.join(",")}]) {
-          steamAccount{
-            id
-            name
-            avatar
-            seasonRank
-            seasonLeaderboardRank
-          }
-          matches(request:{take:1}){
-            id
-            parsedDateTime
-            startDateTime
-            players{
-              steamAccount{
-                id
-              }
-            }
-          }
-        }
-      }
-      
-    `;
-}
-__name(PLAYERS_LASTMATCH_RANKINFO, "PLAYERS_LASTMATCH_RANKINFO");
-function PLAYER_INFO_WITH_25_MATCHES(steamAccountId, heroId) {
-  return `
-    {
-		player(steamAccountId: ${steamAccountId}) {
-		  steamAccount {
-        avatar
-        name
-        seasonRank
-        seasonLeaderboardRank
-        id
-		  }
-		  guildMember {
-        guild {
-          tag
-        }
-		  }
-		  matchCount
-		  winCount
-		  performance {
-			  imp
-		  }
-		  heroesPerformance(take: 25, request: {matchGroupOrderBy: WIN_COUNT take: 25 ${heroId ? "heroIds:" + heroId : ""}}) {
-        hero {
-          id
-          shortName
-        }
-        imp
-        winCount
-        matchCount
-		  }
-		  matches(request: {take: 25 ${heroId ? "heroIds:" + heroId : ""}}) {
-        id
-        rank
-        lobbyType
-        gameMode
-        startDateTime
-        parsedDateTime
-        durationSeconds
-        didRadiantWin
-        topLaneOutcome
-        midLaneOutcome
-        bottomLaneOutcome
-        radiantKills
-        direKills
-        players {
-          steamAccount {
-            id
-          }
-          isRadiant
-          lane
-          kills
-          deaths
-          assists
-          position
-          award
-          imp
-          hero {
-          id
-          shortName
-          }
-        }
-        }
-      }
-		
-	  }
-	  
-      `;
-}
-__name(PLAYER_INFO_WITH_25_MATCHES, "PLAYER_INFO_WITH_25_MATCHES");
-function PLAYER_EXTRA_INFO(steamAccountId, matchCount, totalHeroCount, heroId) {
-  return `{
-        player(steamAccountId: ${steamAccountId}) {
-          heroesPerformance(take: ${totalHeroCount}, request: {matchGroupOrderBy: MATCH_COUNT, take: ${matchCount} ${heroId ? "heroIds:" + heroId : ""}}) {
-            hero {
-              id
-              shortName
-            }
-            winCount
-            matchCount
-            imp
-          }
-          dotaPlus {
-            heroId
-            level
-          }
-        }
-      }
-      `;
-}
-__name(PLAYER_EXTRA_INFO, "PLAYER_EXTRA_INFO");
-function PLAYERS_INFO_WITH_10_MATCHES_FOR_GUILD(steamAccountIds) {
-  return `{
-    players(steamAccountIds: [${steamAccountIds.join()}]) {
-      steamAccount {
-        id
-        avatar
-        name
-        seasonRank
-      }
-      matches(request: {take: 10}) {
-        didRadiantWin
-        startDateTime
-        players {
-          isRadiant
-          kills
-          deaths
-          assists
-          steamAccount {
-            id
-          }
-          hero {
-            shortName
-          }
-          imp
-        }
-      }
-    }
-  }
-  `;
-}
-__name(PLAYERS_INFO_WITH_10_MATCHES_FOR_GUILD, "PLAYERS_INFO_WITH_10_MATCHES_FOR_GUILD");
-function CURRENT_GAMEVERSION() {
-  return `
-    {
-        constants {
-          gameVersions{name id}
-        }
-      }
-      
-    `;
-}
-__name(CURRENT_GAMEVERSION, "CURRENT_GAMEVERSION");
-function ALL_ABILITIES_CHINESE_NAME() {
-  return `
-    {
-        constants {
-             abilities(language:S_CHINESE){
-            id
-            language{displayName}
-          }
-          gameVersions{name id}
-        }
-      }
-      
-    `;
-}
-__name(ALL_ABILITIES_CHINESE_NAME, "ALL_ABILITIES_CHINESE_NAME");
-function HERO_INFO(heroId) {
-  return `
-    {
-        constants {
-          hero(id: ${heroId}, language: S_CHINESE) {
-            id
-            name
-            shortName
-            aliases
-            roles {
-              roleId
-              level
-            }
-            language {
-              displayName
-              lore
-              hype
-            }
-            abilities {
-              ability(language: S_CHINESE) {
-                name
-                language {
-                  displayName
-                  description
-                  attributes
-                  lore
-                  aghanimDescription
-                  shardDescription
-                  notes
-                }
-                stat {
-                  type
-                  behavior
-                  unitTargetType
-                  unitTargetTeam
-                  unitTargetFlags
-                  unitDamageType
-                  cooldown
-                  manaCost
-                  spellImmunity
-                  isOnCastbar
-                  isGrantedByShard
-                  isGrantedByScepter
-                  hasShardUpgrade
-                  hasScepterUpgrade
-                }
-              }
-            }
-            talents {
-              abilityId
-              slot
-            }
-          }
-        }
-      }
-      
-    `;
-}
-__name(HERO_INFO, "HERO_INFO");
-function HERO_MATCHUP_WINRATE(heroId) {
-  return `
-    {
-        heroStats {
-          matchUp(heroId: ${heroId}, take: ${Object.keys(dotaconstants.heroes).length - 1},bracketBasicIds:LEGEND_ANCIENT) {
-            heroId
-            matchCountWith
-            matchCountVs
-            with {
-              heroId1
-              winRateHeroId1
-              heroId2
-              winRateHeroId2
-              winCount
-              matchCount
-            }
-            vs {
-              heroId1
-              winRateHeroId1
-              heroId2
-              winRateHeroId2
-              winCount
-              matchCount
-            }
-          }
-        }
-      }
-      
-    `;
-}
-__name(HERO_MATCHUP_WINRATE, "HERO_MATCHUP_WINRATE");
-function REQUEST_MATCH_DATA_ANALYSIS(matchId) {
-  return `stratz{matchRetry(id:${matchId})}`;
-}
-__name(REQUEST_MATCH_DATA_ANALYSIS, "REQUEST_MATCH_DATA_ANALYSIS");
-
-// src/utils.ts
+var import_path = __toESM(require("path"));
 var CONFIGS = { STRATZ_API: { URL: "https://api.stratz.com/graphql", TOKEN: "" } };
 var http = null;
 var setTimeout;
@@ -536,40 +70,46 @@ function init(newHttp, newSetTimeout) {
   setTimeout = newSetTimeout;
 }
 __name(init, "init");
-async function fetchData(query_str) {
-  return await http.post(CONFIGS.STRATZ_API.URL, query_str, {
+async function fetchData(query2) {
+  return await http.post(CONFIGS.STRATZ_API.URL, JSON.stringify(query2), {
     responseType: "json",
     headers: {
       "User-Agent": "STRATZ_API",
-      "Content-Type": "application/graphql",
+      "Content-Type": "application/json",
       Authorization: `Bearer ${CONFIGS.STRATZ_API.TOKEN}`
     }
   });
 }
 __name(fetchData, "fetchData");
-async function query(query_func, ...args) {
-  if (query_func.name.startsWith("PLAYERS") && args[0].length > 5) {
-    const playerIds = args[0];
+async function query(queryName, variables) {
+  if (queryName.startsWith("Players") && variables?.steamAccountIds.length > 5) {
+    const playerIds = variables?.steamAccountIds ?? [];
     const chunkSize = 5;
     let allPlayers = [];
     for (let i = 0; i < playerIds.length; i += chunkSize) {
       const chunk = playerIds.slice(i, i + chunkSize);
-      const query_str = query_func(chunk, ...args.slice(1));
-      const result = await new Promise((resolve) => setTimeout(async () => resolve(await fetchData(query_str)), 100));
-      if (result.errors) throw { errors: result.errors };
+      variables.steamAccountIds = chunk;
+      const query_str = loadGraphqlFile(queryName);
+      const result = await new Promise((resolve) => setTimeout(async () => resolve(await fetchData({ query: query_str, variables })), 200));
+      if (result?.errors) throw { errors: result.errors };
       if (result.data && result.data.players) {
         allPlayers = allPlayers.concat(result.data.players);
       }
     }
-    return { data: { players: allPlayers } };
+    return { players: allPlayers };
   } else {
-    const query_str = query_func(...args);
-    const result = await fetchData(query_str);
+    const query_str = loadGraphqlFile(queryName);
+    const result = await fetchData({ query: query_str, variables });
     if (result.errors) throw { errors: result.errors };
-    return result || {};
+    return result.data;
   }
 }
 __name(query, "query");
+function loadGraphqlFile(queryName) {
+  const filepath = `./node_modules/@sjtdev/koishi-plugin-dota2tracker/queries/${queryName}.graphql`;
+  return import_fs.default.readFileSync(filepath, { encoding: "utf-8" }).replace(/[\r\n]+/g, " ");
+}
+__name(loadGraphqlFile, "loadGraphqlFile");
 async function queryHeroFromValve(heroId) {
   return (await http.get(`https://www.dota2.com/datafeed/herodata?language=schinese&hero_id=${heroId}`)).result.data.heroes[0];
 }
@@ -611,7 +151,8 @@ function getImageUrl(image, type = "local" /* Local */, format = "png" /* png */
 }
 __name(getImageUrl, "getImageUrl");
 function getFormattedMatchData(data) {
-  const { match, constants } = data;
+  const match = data.match;
+  const constants = data.constants;
   ["radiant", "dire"].forEach((team) => {
     match[team] = { killsCount: match[team + "Kills"]?.reduce((acc, cva) => acc + cva, 0) ?? 0, damageReceived: 0, heroDamage: 0, networth: 0, experience: 0 };
   });
@@ -680,7 +221,10 @@ function getFormattedMatchData(data) {
         }
         return acc;
       }, {});
-      player.stats.matchPlayerBuffEvent.splice(0, player.stats.matchPlayerBuffEvent.length, ...Object.values(maxStackCountsByAbilityOrItem));
+      player.buffs = Object.entries(maxStackCountsByAbilityOrItem).map(([key, event]) => ({
+        key,
+        event
+      }));
     }
     switch (player.lane) {
       case "SAFE_LANE":
@@ -741,8 +285,8 @@ function getFormattedMatchData(data) {
       const itemId = player[key];
       if (itemId === void 0 || itemId === null) {
         player.items.push(null);
-      } else if (dotaconstants2.item_ids[itemId]) {
-        const name2 = dotaconstants2.item_ids[itemId];
+      } else if (dotaconstants.item_ids[itemId]) {
+        const name2 = dotaconstants.item_ids[itemId];
         const isRecipe = name2.startsWith(prefix);
         const cleanName = isRecipe ? name2.substring(prefix.length) : name2;
         player.items.push({
@@ -760,8 +304,8 @@ function getFormattedMatchData(data) {
       const itemId = player[key];
       if (itemId === void 0 || itemId === null) {
         player.backpacks.push(null);
-      } else if (dotaconstants2.item_ids[itemId]) {
-        const name2 = dotaconstants2.item_ids[itemId];
+      } else if (dotaconstants.item_ids[itemId]) {
+        const name2 = dotaconstants.item_ids[itemId];
         const isRecipe = name2.startsWith(prefix);
         const cleanName = isRecipe ? name2.substring(prefix.length) : name2;
         player.backpacks.push({
@@ -783,8 +327,8 @@ function getFormattedMatchData(data) {
         const itemId = player.additionalUnit[key];
         if (itemId === void 0 || itemId === null) {
           player.unitItems.push(null);
-        } else if (dotaconstants2.item_ids[itemId]) {
-          const name2 = dotaconstants2.item_ids[itemId];
+        } else if (dotaconstants.item_ids[itemId]) {
+          const name2 = dotaconstants.item_ids[itemId];
           const isRecipe = name2.startsWith(prefix2);
           const cleanName = isRecipe ? name2.substring(prefix2.length) : name2;
           player.unitItems.push({
@@ -802,8 +346,8 @@ function getFormattedMatchData(data) {
         const itemId = player.additionalUnit[key];
         if (itemId === void 0 || itemId === null) {
           player.unitBackpacks.push(null);
-        } else if (dotaconstants2.item_ids[itemId]) {
-          const name2 = dotaconstants2.item_ids[itemId];
+        } else if (dotaconstants.item_ids[itemId]) {
+          const name2 = dotaconstants.item_ids[itemId];
           const isRecipe = name2.startsWith(prefix2);
           const cleanName = isRecipe ? name2.substring(prefix2.length) : name2;
           player.unitBackpacks.push({
@@ -926,7 +470,7 @@ function winRateColor(value) {
 __name(winRateColor, "winRateColor");
 async function playerisValid(steamAccountId) {
   try {
-    let queryRes = await query(VERIFYING_PLAYER, steamAccountId);
+    let queryRes = await query("VerifyingPlayer", { steamAccountId });
     if (queryRes.data.player.matchCount != null) return { isValid: true };
     else return { isValid: false, reason: "SteamID无效或无任何场次。" };
   } catch (error) {
@@ -979,7 +523,7 @@ __name(formatHeroDesc, "formatHeroDesc");
 var import_fs2 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var import_moment = __toESM(require("moment"));
-var dotaconstants3 = __toESM(require("dotaconstants"));
+var dotaconstants2 = __toESM(require("dotaconstants"));
 
 // src/dotaconstants_add.json
 var dotaconstants_add_exports = {};
@@ -1418,10 +962,10 @@ async function apply(ctx, config) {
             memberList = await session.bot?.getGuildMemberList(session.event.channel.id);
           } catch (error) {
           }
-          async function getUsers(subscribedPlayers2, utils, queries, memberList2) {
-            const playerSteamIds = subscribedPlayers2.map((player) => player.steamId);
-            const queryResult = await utils.query(queries.PLAYERS_INFO_WITH_10_MATCHES_FOR_GUILD, playerSteamIds);
-            const playersInfo = queryResult.data.players;
+          async function getUsers(subscribedPlayers2, memberList2) {
+            const playerSteamIds = { steamAccountIds: subscribedPlayers2.map((player) => player.steamId) };
+            const queryResult = await query("PlayersInfoWith10MatchesForGuild", { steamAccountIds: playerSteamIds });
+            const playersInfo = queryResult.players;
             const users2 = [];
             for (const subscribedPlayer of subscribedPlayers2) {
               const queryPlayer = playersInfo.find((player) => player.steamAccount.id == subscribedPlayer.steamId);
@@ -1431,7 +975,7 @@ async function apply(ctx, config) {
             return users2;
           }
           __name(getUsers, "getUsers");
-          const users = await getUsers(subscribedPlayers, utils_exports, queries_exports, memberList);
+          const users = await getUsers(subscribedPlayers, memberList);
           session.send(await ctx.puppeteer.render(genImageHTML(users, "guild_member" /* GuildMember */, "guild_member" /* GuildMember */)));
         } catch (error) {
           ctx.logger.error(error);
@@ -1442,18 +986,17 @@ async function apply(ctx, config) {
   });
   async function queryMatchAndSend(session, matchId) {
     try {
-      let match;
+      let matchQuery;
       let queryLocal = await ctx.database.get("dt_previous_query_results", matchId, ["data"]);
       if (queryLocal.length > 0) {
-        match = queryLocal[0].data;
-        ctx.database.set("dt_previous_query_results", match.id, { queryTime: /* @__PURE__ */ new Date() });
-      } else {
-        match = getFormattedMatchData((await query(MATCH_INFO, matchId)).data);
-      }
+        matchQuery = queryLocal[0].data;
+        ctx.database.set("dt_previous_query_results", matchQuery.match.id, { queryTime: /* @__PURE__ */ new Date() });
+      } else matchQuery = await query("MatchInfo", { matchId });
+      if (matchQuery.match.parsedDateTime)
+        ctx.database.upsert("dt_previous_query_results", (row) => [{ matchId: matchQuery.match.id, data: matchQuery, queryTime: /* @__PURE__ */ new Date() }]);
+      let match = getFormattedMatchData(matchQuery);
       if (match && (match.parsedDateTime || import_moment.default.unix(match.endDateTime).isBefore((0, import_moment.default)().subtract(config.dataParsingTimeoutMinutes, "minutes")))) {
         session.send((ctx.config.urlInMessageType.some((type) => type == "match") ? "https://stratz.com/matches/" + matchId : "") + await ctx.puppeteer.render(genImageHTML(match, config.template_match, "match" /* Match */)));
-        if (match.parsedDateTime)
-          ctx.database.upsert("dt_previous_query_results", (row) => [{ matchId: match.id, data: match, queryTime: /* @__PURE__ */ new Date() }]);
       } else {
         pendingMatches.push({ matchId, guilds: [{ platform: session.event.platform, guildId: session.event.channel.id, players: [] }] });
         session.send("比赛尚未解析，将在解析完成后发布。");
@@ -1461,7 +1004,7 @@ async function apply(ctx, config) {
     } catch (error) {
       ctx.logger.error(error);
       session.send("获取比赛信息失败。");
-      ctx.database.remove("dt_previous_query_results", { matchId: parseInt(matchId) });
+      await ctx.database.remove("dt_previous_query_results", { matchId });
     }
   }
   __name(queryMatchAndSend, "queryMatchAndSend");
@@ -1495,7 +1038,7 @@ async function apply(ctx, config) {
       let lastMatchId = 0;
       try {
         session.send("正在搜索对局详情，请稍后...");
-        lastMatchId = (await query(PLAYERS_LASTMATCH_RANKINFO, [parseInt(flagBindedPlayer?.steamId ?? input_data)])).data.players[0].matches[0].id;
+        lastMatchId = (await query("PlayersLastmatchRankinfo", { steamAccountIds: [parseInt(flagBindedPlayer?.steamId ?? input_data)] })).players[0].matches[0].id;
       } catch (error) {
         session.send("获取玩家最近比赛失败。");
         ctx.logger.error(error);
@@ -1526,8 +1069,13 @@ async function apply(ctx, config) {
       let steamId = flagBindedPlayer?.steamId ?? input_data;
       let player;
       try {
-        player = (await query(PLAYER_INFO_WITH_25_MATCHES, steamId, hero?.id)).data.player;
-        let playerExtra = (await query(PLAYER_EXTRA_INFO, steamId, player.matchCount, Object.keys(dotaconstants3.heroes).length, hero?.id)).data.player;
+        player = (await query("PlayerInfoWith25Matches", { steamAccountId: steamId, heroIds: hero?.id })).player;
+        let playerExtra = (await query("PlayerExtraInfo", {
+          steamAccountId: steamId,
+          matchCount: player.matchCount,
+          totalHeroCount: Object.keys(dotaconstants2.heroes).length,
+          heroIds: hero?.id
+        })).player;
         let filteredDotaPlus = {};
         playerExtra.dotaPlus.forEach((item) => {
           if (!filteredDotaPlus[item.heroId] || filteredDotaPlus[item.heroId].level < item.level) {
@@ -1675,15 +1223,15 @@ async function apply(ctx, config) {
         return;
       }
       try {
-        let heroStats = (await query(HERO_MATCHUP_WINRATE, hero.id)).data.heroStats;
+        let heroStats = (await query("HeroMatchupWinrate", { heroId: hero.id, take: Object.keys(dotaconstants2.heroes).length - 1 })).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) => {
           const winRate = item.winCount / item.matchCount;
           return { ...item, winRate: winRate.toFixed(3) };
-        }).sort((a, b) => b.winRate - a.winRate).slice(0, Math.max(1, Math.min(Object.keys(dotaconstants3.heroes).length - 1, options.limit)));
+        }).sort((a, b) => b.winRate - a.winRate).slice(0, Math.max(1, Math.min(Object.keys(dotaconstants2.heroes).length - 1, options.limit)));
         let vsBottomFive = heroStats.matchUp[0].vs.filter((item) => item.matchCount / heroStats.matchUp[0].matchCountVs > Math.max(0, Math.min(5, options.filter)) / 100).map((item) => {
           const winRate = item.winCount / item.matchCount;
           return { ...item, winRate: winRate.toFixed(3) };
-        }).sort((a, b) => a.winRate - b.winRate).slice(0, Math.max(1, Math.min(Object.keys(dotaconstants3.heroes).length - 1, options.limit)));
+        }).sort((a, b) => a.winRate - b.winRate).slice(0, Math.max(1, Math.min(Object.keys(dotaconstants2.heroes).length - 1, options.limit)));
         session.send(
           `你查询的英雄是${HEROES_CHINESE[heroStats.matchUp[0].heroId][0]}（ID：${heroStats.matchUp[0].heroId}），
 以下是7天内传奇-万古分段比赛数据总结而来的搭档与克制关系
@@ -1699,7 +1247,7 @@ async function apply(ctx, config) {
   });
   function findingHero(input) {
     if (!input) return;
-    let dc_heroes = Object.values(dotaconstants3.heroes).map((hero) => ({
+    let dc_heroes = Object.values(dotaconstants2.heroes).map((hero) => ({
       id: hero["id"],
       name: hero["name"],
       shortName: hero["name"].match(/^npc_dota_hero_(.+)$/)[1]
@@ -1716,8 +1264,8 @@ async function apply(ctx, config) {
         else mergedMap.set(item.id, item);
       });
     });
-    let heroes3 = Array.from(mergedMap.values());
-    return heroes3.find((hero) => hero.names_cn.some((cn) => cn.toLowerCase() == input.toLowerCase()) || hero.shortName === input.toLowerCase() || hero.id == input);
+    let heroes2 = Array.from(mergedMap.values());
+    return heroes2.find((hero) => hero.names_cn.some((cn) => cn.toLowerCase() == input.toLowerCase()) || hero.shortName === input.toLowerCase() || hero.id == input);
   }
   __name(findingHero, "findingHero");
   ctx.on("ready", async () => {
@@ -1749,7 +1297,7 @@ async function apply(ctx, config) {
         const subscribedPlayersSteamIds = subscribedPlayersInGuild.map((player) => player.steamId).filter(function(value, index, self) {
           return self.indexOf(value) === index;
         });
-        const players = (await query(PLAYERS_LASTMATCH_RANKINFO, subscribedPlayersSteamIds)).data.players;
+        const players = (await query("PlayersLastmatchRankinfo", { steamAccountIds: subscribedPlayersSteamIds })).players;
         const lastMatches = players.map((player) => player.matches[0]).filter((item, index, self) => index === self.findIndex((t) => t.id === item.id)).filter((match) => import_moment.default.unix(match.startDateTime).isAfter((0, import_moment.default)().subtract(1, "days"))).filter((match) => !pendingMatches.some((pendingMatch) => pendingMatch.matchId == match.id));
         const sendedMatchesIds = (await ctx.database.get("dt_sended_match_id", { matchId: lastMatches.map((match) => match.id) }, ["matchId"])).map((match) => match.matchId);
         lastMatches.filter((match) => !sendedMatchesIds.includes(match.id)).forEach((match) => {
@@ -1764,7 +1312,7 @@ async function apply(ctx, config) {
             });
           });
           pendingMatches.push({ matchId: match.id, guilds: tempGuilds });
-          query(REQUEST_MATCH_DATA_ANALYSIS, match.id);
+          query("RequestMatchDataAnalysis", { matchId: match.id });
           ctx.logger.info(
             tempGuilds.map((guild) => `追踪到来自群组${guild.platform}:${guild.guildId}的用户${guild.players.map((player) => `[${player.nickName ?? ""}(${player.steamId})]`).join("、")}的尚未播报过的最新比赛 ${match.id}。`).join("")
           );
@@ -1824,13 +1372,16 @@ async function apply(ctx, config) {
         const now = (0, import_moment.default)();
         const pendingMatch = pendingMatches[(now.hours() * 60 + now.minutes()) % pendingMatches.length];
         try {
-          let match;
+          let matchQuery;
           let queryLocal = await ctx.database.get("dt_previous_query_results", pendingMatch.matchId, ["data"]);
           if (queryLocal.length > 0) {
-            match = queryLocal[0].data;
-            ctx.database.set("dt_previous_query_results", match.id, { queryTime: /* @__PURE__ */ new Date() });
-          } else match = getFormattedMatchData((await query(MATCH_INFO, pendingMatch.matchId)).data);
-          if (match.parsedDateTime || import_moment.default.unix(match.endDateTime).isBefore(now.subtract(config.dataParsingTimeoutMinutes, "minutes"))) {
+            matchQuery = queryLocal[0].data;
+            ctx.database.set("dt_previous_query_results", matchQuery.match.id, { queryTime: /* @__PURE__ */ new Date() });
+          } else matchQuery = await query("MatchInfo", { matchId: pendingMatch.matchId });
+          if (matchQuery.match.parsedDateTime || import_moment.default.unix(matchQuery.match.endDateTime).isBefore(now.subtract(config.dataParsingTimeoutMinutes, "minutes"))) {
+            if (matchQuery.match.parsedDateTime)
+              ctx.database.upsert("dt_previous_query_results", (row) => [{ matchId: matchQuery.match.id, data: matchQuery, queryTime: /* @__PURE__ */ new Date() }]);
+            let match = getFormattedMatchData(matchQuery);
             pendingMatches = pendingMatches.filter((item) => item.matchId != match.id);
             const img = await ctx.puppeteer.render(genImageHTML(match, config.template_match, "match" /* Match */));
             for (let commingGuild of pendingMatch.guilds) {
@@ -1856,10 +1407,8 @@ KDA：${((player.kills + player.assists) / (player.deaths || 1)).toFixed(2)} [${
               await ctx.broadcast([`${commingGuild.platform}:${commingGuild.guildId}`], broadMatchMessage + (ctx.config.urlInMessageType.some((type) => type == "match") ? "https://stratz.com/matches/" + match.id : "") + img);
               ctx.logger.info(`${match.id}${match.parsedDateTime ? "已解析，" : "已结束超过1小时仍未被解析，放弃等待解析直接"}生成图片并发布于${commingGuild.platform}:${commingGuild.guildId}。`);
             }
-            if (match.parsedDateTime)
-              ctx.database.upsert("dt_previous_query_results", (row) => [{ matchId: match.id, data: match, queryTime: /* @__PURE__ */ new Date() }]);
             ctx.database.create("dt_sended_match_id", { matchId: match.id, sendTime: /* @__PURE__ */ new Date() });
-          } else ctx.logger.info("比赛 %d 尚未解析完成，继续等待。", match.id);
+          } else ctx.logger.info("比赛 %d 尚未解析完成，继续等待。", matchQuery.match.id);
         } catch (error) {
           ctx.logger.error(error);
           ctx.database.remove("dt_previous_query_results", { matchId: pendingMatch.matchId });
@@ -1870,11 +1419,10 @@ KDA：${((player.kills + player.assists) / (player.deaths || 1)).toFixed(2)} [${
   async function report(timeAgo, title, showCombi) {
     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));
-    const players = (await query(
-      PLAYERS_MATCHES_FOR_DAILY,
-      subscribedPlayersInGuild.map((player) => player.steamId).filter((value, index, self) => self.indexOf(value) === index),
-      timeAgo
-    )).data.players.filter((player) => player.matches.length > 0);
+    const players = (await query("PlayersMatchesForDaily", {
+      steamAccountIds: subscribedPlayersInGuild.map((player) => player.steamId).filter((value, index, self) => self.indexOf(value) === index),
+      seconds: timeAgo
+    })).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);
@@ -1961,7 +1509,7 @@ function genImageHTML(data, template, type) {
     ImageType,
     ImageFormat,
     d2a: dotaconstants_add_exports,
-    dotaconstants: dotaconstants3,
+    dotaconstants: dotaconstants2,
     moment: import_moment.default,
     escapeHTML: /* @__PURE__ */ __name(function escapeHTML(str) {
       if (str == null) return "";

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@sjtdev/koishi-plugin-dota2tracker",
   "description": "koishi插件-追踪群友的DOTA2对局",
-  "version": "1.2.19",
+  "version": "1.2.20-pre.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
     "lib",
     "dist",
     "images",
-    "template"
+    "template",
+    "queries"
   ],
   "contributors": [
     "sjtdev <sh1j1n9ta0@foxmail.com>"

package/queries/AllAbilitiesChineseName.graphql

@@ -0,0 +1,14 @@
+query AllAbilitiesChineseName {
+  constants {
+    abilities(language: S_CHINESE) {
+      id
+      language {
+        displayName
+      }
+    }
+    gameVersions {
+      name
+      id
+    }
+  }
+}

package/queries/CurrentGameversion.graphql

@@ -0,0 +1,8 @@
+query CurrentGameversion {
+  constants {
+    gameVersions {
+      name
+      id
+    }
+  }
+}

package/queries/HeroInfo.graphql

@@ -0,0 +1,53 @@
+query HeroInfo($heroId: Short!) {
+  constants {
+    hero(id: $heroId, language: S_CHINESE) {
+      id
+      name
+      shortName
+      aliases
+      roles {
+        roleId
+        level
+      }
+      language {
+        displayName
+        lore
+        hype
+      }
+      abilities {
+        ability(language: S_CHINESE) {
+          name
+          language {
+            displayName
+            description
+            attributes
+            lore
+            aghanimDescription
+            shardDescription
+            notes
+          }
+          stat {
+            type
+            behavior
+            unitTargetType
+            unitTargetTeam
+            unitTargetFlags
+            unitDamageType
+            cooldown
+            manaCost
+            spellImmunity
+            isOnCastbar
+            isGrantedByShard
+            isGrantedByScepter
+            hasShardUpgrade
+            hasScepterUpgrade
+          }
+        }
+      }
+      talents {
+        abilityId
+        slot
+      }
+    }
+  }
+}

package/queries/HeroMatchupWinrate.graphql

@@ -0,0 +1,25 @@
+query HeroMatchupWinrate($heroId: Short!, $take: Int!) {
+  heroStats {
+    matchUp(heroId: $heroId, take: $take, bracketBasicIds: LEGEND_ANCIENT) {
+      heroId
+      matchCountWith
+      matchCountVs
+      with {
+        heroId1
+        winRateHeroId1
+        heroId2
+        winRateHeroId2
+        winCount
+        matchCount
+      }
+      vs {
+        heroId1
+        winRateHeroId1
+        heroId2
+        winRateHeroId2
+        winCount
+        matchCount
+      }
+    }
+  }
+}

package/queries/MatchInfo.graphql

@@ -0,0 +1,135 @@
+query MatchInfo($matchId: Long!) {
+  match(id: $matchId) {
+    id
+    didRadiantWin
+    lobbyType
+    gameMode
+    regionId
+    parsedDateTime
+    startDateTime
+    endDateTime
+    actualRank
+    rank
+    averageRank
+    durationSeconds
+    topLaneOutcome
+    midLaneOutcome
+    bottomLaneOutcome
+    radiantKills
+    direKills
+    players {
+      steamAccountId
+      steamAccount {
+        name
+      }
+      level
+      hero {
+        id
+        name
+        shortName
+        facets {
+          facetId
+        }
+      }
+      variant
+      dotaPlus {
+        level
+      }
+      leaverStatus
+      partyId
+      position
+      playerSlot
+      lane
+      imp
+      kills
+      deaths
+      assists
+      isRadiant
+      networth
+      steamAccount {
+        seasonRank
+        seasonLeaderboardRank
+      }
+      item0Id
+      item1Id
+      item2Id
+      item3Id
+      item4Id
+      item5Id
+      backpack0Id
+      backpack1Id
+      backpack2Id
+      neutral0Id
+      stats {
+        matchPlayerBuffEvent {
+          abilityId
+          itemId
+          stackCount
+        }
+      }
+      heroDamage
+      towerDamage
+      stats {
+        heroDamageReport {
+          receivedTotal {
+            physicalDamage
+            magicalDamage
+            pureDamage
+          }
+        }
+      }
+      numLastHits
+      numDenies
+      goldPerMinute
+      experiencePerMinute
+      heroHealing
+      stats {
+        itemPurchases {
+          itemId
+          time
+        }
+        campStack
+        heroDamageReport {
+          dealtTotal {
+            stunDuration
+            stunCount
+            slowDuration
+            slowCount
+            disableDuration
+            disableCount
+          }
+        }
+      }
+      additionalUnit {
+        item0Id
+        item1Id
+        item2Id
+        item3Id
+        item4Id
+        item5Id
+        backpack0Id
+        backpack1Id
+        backpack2Id
+        neutral0Id
+      }
+      isRandom
+    }
+    pickBans {
+      isPick
+      bannedHeroId
+      heroId
+      order
+    }
+  }
+  constants {
+    facets(language: S_CHINESE) {
+      name
+      id
+      color
+      icon
+      language {
+        displayName
+      }
+    }
+  }
+}

package/queries/PlayerExtraInfo.graphql

@@ -0,0 +1,17 @@
+query PlayerExtraInfo($steamAccountId: Long!, $totalHeroCount: Int!, $matchCount: Int!, $heroIds: [Short]) {
+  player(steamAccountId: $steamAccountId) {
+    heroesPerformance(take: $totalHeroCount, request: { matchGroupOrderBy: MATCH_COUNT, take: $matchCount, heroIds: $heroIds }) {
+      hero {
+        id
+        shortName
+      }
+      winCount
+      matchCount
+      imp
+    }
+    dotaPlus {
+      heroId
+      level
+    }
+  }
+}

package/queries/PlayerInfoWith25Matches.graphql

@@ -0,0 +1,62 @@
+query PlayerInfoWith25Matches($steamAccountId: Long!, $heroIds: [Short]) {
+  player(steamAccountId: $steamAccountId) {
+    steamAccount {
+      avatar
+      name
+      seasonRank
+      seasonLeaderboardRank
+      id
+    }
+    guildMember {
+      guild {
+        tag
+      }
+    }
+    matchCount
+    winCount
+    performance {
+      imp
+    }
+    heroesPerformance(take: 25, request: { matchGroupOrderBy: WIN_COUNT, take: 25, heroIds: $heroIds }) {
+      hero {
+        id
+        shortName
+      }
+      imp
+      winCount
+      matchCount
+    }
+    matches(request: { take: 25, heroIds: $heroIds }) {
+      id
+      rank
+      lobbyType
+      gameMode
+      startDateTime
+      parsedDateTime
+      durationSeconds
+      didRadiantWin
+      topLaneOutcome
+      midLaneOutcome
+      bottomLaneOutcome
+      radiantKills
+      direKills
+      players {
+        steamAccount {
+          id
+        }
+        isRadiant
+        lane
+        kills
+        deaths
+        assists
+        position
+        award
+        imp
+        hero {
+          id
+          shortName
+        }
+      }
+    }
+  }
+}

package/queries/PlayersInfoWith10MatchesForGuild.graphql

@@ -0,0 +1,27 @@
+query PlayersInfoWith10MatchesForGuild($steamAccountIds: [Long]!) {
+  players(steamAccountIds: $steamAccountIds) {
+    steamAccount {
+      id
+      avatar
+      name
+      seasonRank
+    }
+    matches(request: { take: 10 }) {
+      didRadiantWin
+      startDateTime
+      players {
+        isRadiant
+        kills
+        deaths
+        assists
+        steamAccount {
+          id
+        }
+        hero {
+          shortName
+        }
+        imp
+      }
+    }
+  }
+}

package/queries/PlayersLastmatchRankinfo.graphql

@@ -0,0 +1,21 @@
+query PlayersLastmatchRankinfo($steamAccountIds: [Long]!) {
+  players(steamAccountIds: $steamAccountIds) {
+    steamAccount {
+      id
+      name
+      avatar
+      seasonRank
+      seasonLeaderboardRank
+    }
+    matches(request: { take: 1 }) {
+      id
+      parsedDateTime
+      startDateTime
+      players {
+        steamAccount {
+          id
+        }
+      }
+    }
+  }
+}

package/queries/PlayersMatchesForDaily.graphql

@@ -0,0 +1,25 @@
+query PlayersMatchesForDaily($steamAccountIds: [Long]!, $seconds: Long!) {
+  players(steamAccountIds: $steamAccountIds) {
+    steamAccount {
+      id
+      name
+      avatar
+    }
+    matches(request: { startDateTime: $seconds, take: 50 }) {
+      id
+      didRadiantWin
+      parsedDateTime
+      startDateTime
+      players {
+        kills
+        deaths
+        assists
+        imp
+        isRadiant
+        steamAccount {
+          id
+        }
+      }
+    }
+  }
+}

package/queries/RequestMatchDataAnalysis.graphql

@@ -0,0 +1,5 @@
+query RequestMatchDataAnalysis($matchId: Long!) {
+  stratz {
+    matchRetry(id: $matchId)
+  }
+}

package/queries/VerifyingPlayer.graphql

@@ -0,0 +1,5 @@
+query VerifyingPlayer($steamAccountId: Long!) {
+  player(steamAccountId: $steamAccountId) {
+    matchCount
+  }
+}

package/readme.md

@@ -53,11 +53,6 @@ DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑
 展示见[wiki](https://github.com/sjtdev/koishi-plugin-dota2tracker/wiki)  
 生成图片已使用ejs模板实现，所有模板都在[template]文件夹下，若是有大佬想自己设计模板欢迎联系我完善数据接口。（当前有很多在模板中后处理的数据，不是很友好）  
 
-### 其他问题
-已知问题：当本插件更新版本后，查询已经查询过的比赛数据可能查询失败。  
-* 原因：插件的缓存功能，查询过的比赛数据会缓存至本地以节省API调用次数与服务器流量，再次查询时优先调用本地数据也会提高处理速度。当插件更新后若新增数据的处理或API查询字段，会导致旧的缓存内缺失部分数据引发生成时报错。（播报比赛战报应该不会有这个问题）  
-* 解决：目前在生成失败时会清除缓存，再查询一次就好了。  
-
 ## 灵感来源&鸣谢
 * 感谢[SonodaHanami](https://github.com/SonodaHanami)大佬的[Steam_watcher](https://github.com/SonodaHanami/Steam_watcher)项目，是本插件最重要的灵感来源，并授权提供了战报称号系统、英雄代称与播报信息的代码数据。
 * 也受到了[koishi-plugin-dota2track(npm)](https://www.npmjs.com/package/koishi-plugin-dota2track)的启发，为我的代码提供了一些思路。