@sjtdev/koishi-plugin-dota2tracker 1.2.1 → 1.2.3

package/changelog.md

@@ -0,0 +1,85 @@
+### 1.2.3
+**修复**：修复了比赛战报图片中称号`摸`判定不正确的问题  
+**改进**：微调了比赛战报图片中称号的显示样式  
+
+### 1.2.2
+**移除**：取消`查询英雄`的缓存功能，原因为valve的API返回的数据可能包含未本地化的字段（例如这次的7.36b更新后获取到的很多改动后技能说明暂时都是英文），这些数据无法根据版本判断是否需要更新缓存。  
+**修复**：修复了`查询英雄`图片中某些命石提供技能可能被判定为先天技能的问题。（实际为API缺陷）  
+
+### 1.2.1
+**改进**：优化比赛战报图片中，对多个同种物品（例如双护腕双挂件一类）的出装时间显示进行优化，原先都将显示为最后一件此种物品的购买时间，现在可以显示不同的时间。  
+> 从第一件购买时间算起，例如火枪于1:00 2:00 3:00购买了三个系带，游戏结束前卖出其中之一，则剩余两个则显示为1:00 2:00  
+
+**改进**：出于实用性考虑，比赛战报图片中将不再显示辅助道具的购买时间。  
+
+### 1.2.0
+**改进**：对`查询英雄`模板代码进行了调整与部分重写，完成7.36版本的英雄数据匹配，现在可正常使用。  
+> （人话说就是先天技能和命石适配完成了）  
+
+**移除**：因`查询英雄`指令已适配7.36版本，`7.36`指令退役。（删除）  
+#### hotfix
+**修复**：删除一些留存的测试用代码
+
+### 1.1.10
+**修复**：修复`7.36`指令因DOTA2官网的cdn链接变动导致获取失败的问题，并优化了加载速度。  
+**修复**：修复每次在koishi重新启动后，使用指令`7.36`都会重新获取数据的问题。  
+#### hotfix
+**修复**：修复一处编译问题导致`7.36`指令无法使用的问题
+
+### 1.1.9
+**新增**：v1.1.6加入的功能等待解析时间现在可以配置，位于插件页配置项`dataParsingTimeoutMinutes`  
+**修复**：修复因v1.1.8修改数据获取方式导致的`绑定`指令失效  
+**修复**：修复指令`查询英雄`报错问题（数据仍为7.35d，等待上游API更新）  
+**改进**：兼容Discord、KOOK等频道类平台，将订阅与绑定存储时群组(guild)改为频道(channel)，对onebot(qq)类无影响（出现使用问题请联系我）  
+<details>
+    <summary>若此前已在使用频道类平台……</summary>
+    此版本前频道类平台应该无法使用战报功能与日报功能。此版本在订阅本群与绑定玩家时将存储channelId而不是guildID，对于非频道类平台这两个值是一样的，不会造成影响。但频道类平台应该会彻底失效，解决方案只有操作数据库，将channelId填入原先guildId处（兼容原因，未修改数据库字段名[guildId]，但实际上存入的已经是channel的ID了；guildId和channelId可参考数据库表channel中的数据），或重新订阅与绑定。（若是重新订阅与绑定，不会覆盖原先存储guildId的数据，也就是说旧数据依然会存在，可根据需求选择是否删除）
+</details>
+
+### 1.1.8
+**改进**：将数据获取方式从 npm 包 `axios` 切换为 Koishi 提供的 `http` 服务，并简化了相关代码（用户体验无差别）。  
+**改进**：为 `match_2` 模板添加了玩家小队标识（效果与 `match_1` 模板中的相同功能一致，但在显示上进行了微调）。  
+
+### 1.1.7
+**改进**：玩家信息模板中代表位置的图标替换为简约风格图标  
+**修复**：于v1.1.5新增的`7.36`指令生成英雄改动图片时会额外产生的测试用的`remainingContent.html`文件，现已不再生成。（如果之前使用了该命令并产生了此文件，可根据需要手动删除。位于`koishi/node_modules/@sjtdev/koishi-plugin-dota2tracker/`）  
+
+### 1.1.6
+由于近期stratz网站问题，比赛数据无法自动解析，导致bot会一直等待解析后的战报数据而无法发送。
+**新增**：现在调整为比赛结束1小时后仍然未解析时将直接发出缺失部分数据的战报（缺失包括BP顺序、出装时间、英雄受到伤害等）  
+#### hotfix
+**修复**：修复引发播报未解析比赛战报失败的一个小问题  
+
+### 1.1.5
+**新增**：为新版本7.36添加新指令`7.36`  
+`7.36 <英雄ID|英雄名|英雄常用别名>`可查询对应英雄的改动信息，未输入英雄查询参数时直接返回官网7.36更新日志链接  
+添加`--refresh|-r`参数可强制重新获取数据，如`7.36 -r`，也可在查询时使用，如`7.36 敌法师 -r`  
+
+### 1.1.4
+**改进**：完善查询玩家指定英雄的生成模板  
+
+### 1.1.3
+**新增**：新增实验性功能【日报昨日总结】，在指定时间播报昨日已订阅群组中已绑定群友的战绩（简略文字），默认关闭，可在插件配置中打开  
+`查询玩家`指令新增功能，现在额外输入参数`--hero <英雄ID|英雄名|英雄常用别名>`可查询目标玩家指定英雄的详情（--hero可替换为-o）  
+例如：  
+* `查询玩家 123456789 --hero 敌法师`  
+* `查询玩家 -o 敌法师` （仍可缺省玩家参数以自查）  
+
+### 1.1.2
+**改进**：完成查询群友功能  
+**修复**：修复玩家模板中显示NaN的部分  
+#### hotfix
+**修复**：修复查询远古玩家账号时可能意外失败的问题  
+**改进**：调整mvp中的控制分与[控]称号算法  
+#### hotfix.2
+**修复**：修复初次使用查询英雄指令时，技能名初始化失败导致的错误  
+
+### 1.1.2-beta
+**改进**：为`查询群友`添加模板，还在调整布局中  
+
+### 1.1.1
+**改进**：玩家信息模板添加近25场内各个位置表现展示  
+
+### 1.1.0
+**改进**：使用ejs重写模板相关代码使其模块化，使新增模板更方便  
+**新增**：为比赛信息添加了仿MAX+模板，效果可见[match_2](./wiki/match_2)，可在插件配置中切换   

package/lib/index.js

@@ -808,8 +808,8 @@ function getFormattedMatchData(match) {
   findMaxByProperty("towerDamage", "heroDamage").titles.push({ name: "拆", color: "#FEDCBA" });
   findMaxByProperty("heroHealing").titles.push({ name: "奶", color: "#00FF00" });
   match.players.reduce((lowest, player) => {
-    const currentContribution = (player.kills + player.assists) / match[player.team].KillsCount;
-    const lowestContribution = (lowest.kills + lowest.assists) / match[lowest.team].KillsCount;
+    const currentContribution = (player.kills + player.assists) / match[player.team].killsCount;
+    const lowestContribution = (lowest.kills + lowest.assists) / match[lowest.team].killsCount;
     if (currentContribution < lowestContribution) {
       return player;
     } else if (currentContribution === lowestContribution) {
@@ -1469,7 +1469,7 @@ async function apply(ctx, config) {
       }
     }
   });
-  ctx.command("查询英雄 <input_data>", "查询英雄技能/面板信息").usage("查询英雄的技能说明与各项数据，生成图片发布。\n参数可输入英雄ID、英雄名、英雄常用别名").option("random", "-r 随机选择英雄").option("refresh", "-f 忽略缓存刷新数据").example("-查询英雄 15").example("-查询英雄 雷泽").example("-查询英雄 电魂").action(async ({ session, options }, input_data) => {
+  ctx.command("查询英雄 <input_data>", "查询英雄技能/面板信息").usage("查询英雄的技能说明与各项数据，生成图片发布。\n参数可输入英雄ID、英雄名、英雄常用别名").option("random", "-r 随机选择英雄").example("-查询英雄 15").example("-查询英雄 雷泽").example("-查询英雄 电魂").action(async ({ session, options }, input_data) => {
     if (options.random)
       input_data = random.pick(Object.keys(HEROES_CHINESE));
     if (input_data) {
@@ -1478,94 +1478,81 @@ async function apply(ctx, config) {
         session.send("未找到输入的英雄，请确认后重新输入。");
         return;
       }
+      await session.send("正在获取英雄数据，请稍后...");
       try {
-        const tempHero = await ctx.database.get("dt_hero_data_cache", hero.id);
-        if (tempHero.length && !options.refresh) {
-          const gameVersionId = (await query(CURRENT_GAMEVERSION())).data.constants.gameVersions[0].id;
-          if (tempHero[0].gameVersionId >= gameVersionId) {
-            hero = tempHero[0].hero;
+        const queryHero = await queryHeroFromValve(hero.id);
+        Object.assign(hero, queryHero);
+        hero.facet_abilities.forEach((fa, i) => {
+          if (fa.abilities.length) {
+            fa.abilities.forEach((ab) => {
+              if (!hero.facets[i].abilities)
+                hero.facets[i].abilities = [];
+              if (hero.facets[i].description_loc !== ab.desc_loc)
+                hero.facets[i].abilities.push({ id: ab.id, name: ab.name, name_loc: ab.name_loc, description_ability_loc: formatHeroDesc(ab.desc_loc, ab.special_values, "facet" /* Facet */) });
+              else
+                hero.facets[i].description_loc = formatHeroDesc(hero.facets[i].description_loc, ab.special_values, "facet" /* Facet */);
+              ab.ability_is_facet = true;
+              hero.abilities.push(ab);
+            });
           }
-        } else {
-          const queryHero = await queryHeroFromValve(hero.id);
-          Object.assign(hero, queryHero);
-          hero.facet_abilities.forEach((fa, i) => {
-            if (fa.abilities.length) {
-              fa.abilities.forEach((ab) => {
-                if (!hero.facets[i].abilities)
-                  hero.facets[i].abilities = [];
-                if (hero.facets[i].description_loc !== ab.desc_loc)
-                  hero.facets[i].abilities.push({ id: ab.id, name: ab.name, name_loc: ab.name_loc, description_ability_loc: formatHeroDesc(ab.desc_loc, ab.special_values, "facet" /* Facet */) });
-                else
-                  hero.facets[i].description_loc = formatHeroDesc(hero.facets[i].description_loc, ab.special_values, "facet" /* Facet */);
-                hero.abilities.push(ab);
-              });
+        });
+        const all_special_values = [...hero.abilities.flatMap((ab) => ab.special_values), ...hero.facet_abilities.flatMap((fas) => fas.abilities.flatMap((fa) => fa.special_values))];
+        hero.abilities.forEach((ab) => {
+          ab.facets_loc.forEach((facet, i) => {
+            if (facet) {
+              if (!hero.facets[i].abilities)
+                hero.facets[i].abilities = [];
+              hero.facets[i].abilities.push({ id: ab.id, name: ab.name, name_loc: ab.name_loc, description_ability_loc: formatHeroDesc(facet, all_special_values, "facet" /* Facet */), attributes: [] });
             }
           });
-          const all_special_values = [...hero.abilities.flatMap((ab) => ab.special_values), ...hero.facet_abilities.flatMap((fas) => fas.abilities.flatMap((fa) => fa.special_values))];
-          hero.abilities.forEach((ab) => {
-            ab.facets_loc.forEach((facet, i) => {
-              if (facet) {
-                if (!hero.facets[i].abilities)
-                  hero.facets[i].abilities = [];
-                hero.facets[i].abilities.push({ id: ab.id, name: ab.name, name_loc: ab.name_loc, description_ability_loc: formatHeroDesc(facet, all_special_values, "facet" /* Facet */), attributes: [] });
+          hero.facets.forEach((facet) => {
+            const svs = ab.special_values.filter((sv) => sv.facet_bonus.name === facet.name);
+            svs.forEach((sv) => {
+              if (sv.heading_loc) {
+                facet.abilities.find((ability) => ab.id == ability.id)?.attributes.push({ heading_loc: sv.heading_loc, values: [...sv.facet_bonus.values] });
               }
             });
-            hero.facets.forEach((facet) => {
-              const svs = ab.special_values.filter((sv) => sv.facet_bonus.name === facet.name);
-              svs.forEach((sv) => {
-                if (sv.heading_loc) {
-                  facet.abilities.find((ability) => ab.id == ability.id)?.attributes.push({ heading_loc: sv.heading_loc, values: [...sv.facet_bonus.values] });
-                }
-              });
-            });
-            ab.desc_loc = formatHeroDesc(ab.desc_loc, all_special_values);
-            ab.notes_loc = ab.notes_loc.map((note) => formatHeroDesc(note, all_special_values));
-            if (ab.ability_has_scepter)
-              ab.scepter_loc = formatHeroDesc(ab.scepter_loc, ab.special_values, "scepter" /* Scepter */);
-            if (ab.ability_has_shard)
-              ab.shard_loc = formatHeroDesc(ab.shard_loc, ab.special_values, "shard" /* Shard */);
           });
-          hero.talents.forEach((talent) => {
-            const regex = /\{s:(.*?)\}/g;
-            let match;
-            while ((match = regex.exec(talent.name_loc)) !== null) {
-              const specialValueName = match[1];
-              const target = talent.special_values?.find((sv) => sv.name === specialValueName);
-              if (target) {
-                talent.name_loc = talent.name_loc.replace(match[0], target.values_float.join("/"));
-              } else {
-                const ability = hero.abilities.find((ability2) => ability2.special_values.some((specialValue) => specialValue.bonuses.some((bonus) => bonus.name === talent.name)));
-                if (ability) {
-                  const specialValues = ability.special_values.filter((specialValue) => specialValue.bonuses.some((bonus) => bonus.name === talent.name));
-                  const regex2 = /{s:bonus_(.*?)}/g;
-                  let match2;
-                  const replacements = [];
-                  while ((match2 = regex2.exec(talent.name_loc)) !== null) {
-                    const specialValue = specialValues.find((sv) => sv.name === String(match2[1]));
-                    const replacement = specialValue?.bonuses.find((bonus) => bonus.name === talent.name)?.value;
-                    if (replacement !== void 0) {
-                      replacements.push({ original: match2[0], replacement });
-                    }
+          ab.desc_loc = formatHeroDesc(ab.desc_loc, all_special_values);
+          ab.notes_loc = ab.notes_loc.map((note) => formatHeroDesc(note, all_special_values));
+          if (ab.ability_has_scepter)
+            ab.scepter_loc = formatHeroDesc(ab.scepter_loc, ab.special_values, "scepter" /* Scepter */);
+          if (ab.ability_has_shard)
+            ab.shard_loc = formatHeroDesc(ab.shard_loc, ab.special_values, "shard" /* Shard */);
+        });
+        hero.talents.forEach((talent) => {
+          const regex = /\{s:(.*?)\}/g;
+          let match;
+          while ((match = regex.exec(talent.name_loc)) !== null) {
+            const specialValueName = match[1];
+            const target = talent.special_values?.find((sv) => sv.name === specialValueName);
+            if (target) {
+              talent.name_loc = talent.name_loc.replace(match[0], target.values_float.join("/"));
+            } else {
+              const ability = hero.abilities.find((ability2) => ability2.special_values.some((specialValue) => specialValue.bonuses.some((bonus) => bonus.name === talent.name)));
+              if (ability) {
+                const specialValues = ability.special_values.filter((specialValue) => specialValue.bonuses.some((bonus) => bonus.name === talent.name));
+                const regex2 = /{s:bonus_(.*?)}/g;
+                let match2;
+                const replacements = [];
+                while ((match2 = regex2.exec(talent.name_loc)) !== null) {
+                  const specialValue = specialValues.find((sv) => sv.name === String(match2[1]));
+                  const replacement = specialValue?.bonuses.find((bonus) => bonus.name === talent.name)?.value;
+                  if (replacement !== void 0) {
+                    replacements.push({ original: match2[0], replacement });
                   }
-                  replacements.forEach(({ original, replacement }) => {
-                    talent.name_loc = talent.name_loc.replace(original, replacement);
-                  });
                 }
+                replacements.forEach(({ original, replacement }) => {
+                  talent.name_loc = talent.name_loc.replace(original, replacement);
+                });
               }
             }
-          });
-          try {
-            const gameVersionId = (await query(CURRENT_GAMEVERSION())).data.constants.gameVersions[0].id;
-            await ctx.database.upsert("dt_hero_data_cache", (row) => [{ id: hero.id, hero, gameVersionId }]);
-          } catch (error) {
-            ctx.logger.error(error);
-            await session.send("数据缓存失败。");
           }
-        }
+        });
         await session.send(await ctx.puppeteer.render(genImageHTML(hero, config.template_hero, "hero" /* Hero */)));
       } catch (error) {
         ctx.logger.error(error);
-        await session.send("获取数据失败");
+        session.send("获取数据失败");
       }
     } else {
       session.send("请输入参数。");
@@ -1641,9 +1628,6 @@ async function apply(ctx, config) {
     if (!("dt_previous_query_results" in tables)) {
       ctx.model.extend("dt_previous_query_results", { matchId: "unsigned", data: "json", queryTime: "timestamp" }, { primary: "matchId" });
     }
-    if (!("dt_hero_data_cache" in tables)) {
-      ctx.model.extend("dt_hero_data_cache", { id: "unsigned", gameVersionId: "unsigned", hero: "json" });
-    }
     ctx.cron("0 */6 * * *", () => {
       const oneMonthAgo = (0, import_moment.default)().subtract(1, "months").toDate();
       ctx.database.remove("dt_sended_match_id", { sendTime: { $lt: oneMonthAgo } });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sjtdev/koishi-plugin-dota2tracker",
   "description": "koishi插件-追踪群友的DOTA2对局",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -31,7 +31,7 @@
     "moment": "^2.30.1"
   },
   "peerDependencies": {
-    "koishi": "^4.17.3"
+    "koishi": "^4.17.8"
   },
   "koishi": {
     "preview": "true",
@@ -47,4 +47,4 @@
       "zh"
     ]
   }
-}
+}

package/readme.md

@@ -4,7 +4,8 @@
 
 DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑定），以及一系列查询功能。
 ### 安装
-在koishi插件市场搜索安装
+在koishi插件市场搜索安装  
+有关koishi的使用说明：（[koishi官方文档](https://koishi.chat/)）
 
 ### 使用
 需在插件配置页填入STRATZ API TOKEN，否则无法使用。(配置中提供了API的获取链接)  
@@ -36,10 +37,11 @@ DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑
   返回一张图片，包含英雄属性与技能详情。（此处英雄名为中文名）
 * <del>`查询英雄对战 <英雄ID|英雄名|英雄常用别名>`</del>  
   好像不是很实用
-* `7.36 [英雄ID|英雄名|英雄常用别名] [--refresh|-r]`  
-  查询官网7.36更新日志中指定英雄的改动信息  
+* <del>`7.36 [英雄ID|英雄名|英雄常用别名] [--refresh|-r]`</del>  
+  <del>查询官网7.36更新日志中指定英雄的改动信息  
   无英雄参数时直接返回官网7.36更新日志网址  
-  首次使用时将缓存更新日志网页，若读取失败或出错，可添加`--refresh`或`-r`指令重新缓存  
+  首次使用时将缓存更新日志网页，若读取失败或出错，可添加`--refresh`或`-r`指令重新缓存</del>  
+  `查询英雄`指令已适配7.36改动，所以此指令已废弃
 
 ### 英雄ID|英雄名|英雄常用别名 列表
 [dotaconstants_add.json](https://github.com/sjtdev/koishi-plugin-dota2tracker/blob/master/src/dotaconstants_add.json#L102-L226)  

package/template/hero/hero_1.ejs

@@ -189,9 +189,6 @@
                 background-color: #444;
             }
 
-            .details .list {
-            }
-
             .details .list td {
                 width: 50%;
                 text-align: center;
@@ -648,10 +645,10 @@
             <div class="skills">
                 ${hero.abilities//.filter((item) => dotaconstants.abilities[item.name].behavior != "Hidden")
                 .map((item) => `
-                <div class="skill" data-ability="${item.ability_is_innate}">
+                <div class="skill" data-innate="${item.ability_is_innate&&!item.ability_is_facet}">
                     <p class="title">
                         <span class="name">${item.name_loc}</span>
-                        ${item.ability_is_innate?`<span class="is_innate">先天技能</span>`:""}
+                        ${item.ability_is_innate&&!item.ability_is_facet?`<span class="is_innate">先天技能</span>`:""}
                         ${item.ability_is_granted_by_scepter ?`<img src="${utils.getImageUrl("scepter")}" class="scepter">`:""}
                         ${item.ability_is_granted_by_shard ?`<img src="${utils.getImageUrl("shard")}" class="shard">`:""}
                     </p>
@@ -736,7 +733,7 @@
             const items = document.querySelectorAll('.skills > .skill');
             items.forEach(item => {
                 // const name = item.getAttribute('data-name');
-                const abilityIsInnate = item.getAttribute('data-ability') === 'true';
+                const abilityIsInnate = item.getAttribute('data-innate') === 'true';
                 const img = item.querySelector('.img_stats > img');
                 const imageUrl = img.src;
 

package/template/match/match_2.ejs

@@ -242,7 +242,10 @@
             .player > .titles {
                 grid-row: 4;
                 grid-column: 1 / span 3;
-                text-shadow: 1px 1px 0 #333; /* 设置阴影颜色及偏移 */
+                /* text-shadow: 1px 1px 0 #333; 设置阴影颜色及偏移 */
+            }
+            .player > .titles > span {
+                margin-right: 1.5px;
             }
 
             .player > .player_name {
@@ -398,6 +401,33 @@
     </head>
     <body>
         <% const match = data; %>
+        <% function darkenHexColor(hex, percentage) {
+            // 移除前缀 #
+            hex = hex.replace(/^#/, '');
+
+            // 处理三位 hex 颜色值
+            if (hex.length === 3) {
+                hex = hex.split('').map(char => char + char).join('');
+            }
+        
+            // 将 hex 转换为 RGB
+            let r = parseInt(hex.substring(0, 2), 16);
+            let g = parseInt(hex.substring(2, 4), 16);
+            let b = parseInt(hex.substring(4, 6), 16);
+        
+            // 将 RGB 变暗
+            r = Math.floor(r * (1 - percentage / 100));
+            g = Math.floor(g * (1 - percentage / 100));
+            b = Math.floor(b * (1 - percentage / 100));
+        
+            // 将 RGB 转换回 hex
+            const darkenedHex = `#${((1 << 24) + (r << 16) + (g << 8) + b)
+                .toString(16)
+                .slice(1)
+                .toUpperCase()}`;
+        
+            return darkenedHex;
+        } %>
         <nav>
             <div class="match_id">
                 <p>比赛 <%-match.id%></p>
@@ -456,7 +486,7 @@
                     <img src="${utils.getImageUrl('star_' + player.rank.star)}" class="stars" />
                     <p>${player.steamAccount.seasonLeaderboardRank??""}</p>
                 </div>
-                <div class="titles">${player.titles.map((item) => `<span style="color: ${item.color};">${item.name}</span>`).join('&nbsp;')}</div>
+                <div class="titles">${player.titles.map((item) => `<span style="color: ${darkenHexColor(item.color, 25)};">${item.name}</span>`).join('')}</div>
                 <div class="player_name row-1">
                     <span class="rank">${`[${d2a.rank[player.rank.medal]}${player.rank.star||""}]`}</span>
                     <span class="name">${player.steamAccount.name}</span>