@sjtdev/koishi-plugin-dota2tracker 1.2.8-pre → 1.2.8

package/changelog.md

@@ -1,11 +1,34 @@
+# 1.2.8
+**新增**：
+- 新增周报功能，效果等同日报。
+- 日报与周报中新增可关闭总结中显示组合的功能。
+
+**改进**：
+- 现在`查询玩家`与`查询最近比赛`指令可在私聊状态下使用，必须提供SteamID参数。
+- 将战报中的播报评语由随机选取改为固定种子：比赛ID+玩家SteamID+玩家位置，确保在不同调用时刻、次数及平台下，对同一场比赛中的玩家评语保持一致。
+- `查询玩家`指令图片中，玩家近期比赛表中未解析的场次参战率由"?%"改为估算值，显示为"≈xx%"。
+- `查询英雄`指令图片中，由于命石带来的属性数值无法确定作用方式（增加或是替换等），去除命石属性前的“+”，请结合命石说明自行判断。（7.37版本更新带来的API变动，导致使用指令查询某些英雄报错问题，暂无法解决）
+- 比赛图片模板`match_2`中，现在冠绝排名数字位置更准确了。
+- 比赛图片模板`match_2`中，比赛段位可以显示星级了。
+
+<details>
+<summary>为什么未解析的比赛需要“估算”？</summary>
+比赛未解析无法获取“团队击杀数”，若是将己方所有玩家的击杀数相加，则会漏掉那些由小兵、防御塔等非玩家单位击杀数；若是将敌方所有玩家的死亡数相加，又会多出送野、自杀等不应算在己方战果中的计数。<br>目前程序采用将己方所有击杀数累加的方式来估算参战率，可能会略高于实际值。
+</details>
+
+<details>
+<summary><b>1.2.8-pre更新日志</b></summary>
+
 ### 1.2.8-pre
 **改进**：
 - 现在`查询玩家`可在私聊状态使用，必须提供SteamID参数。
 - 将战报中的播报评语由随机选取改为固定种子：比赛ID+玩家SteamID，确保在不同调用时刻、次数及平台下，对同一场比赛中的玩家评语保持一致。
 - `查询玩家`指令图片中，玩家近期比赛表中未解析的场次参战率由"?%"改为估算值，显示为"≈xx%"
-<details>
-<summary>为什么是“估算”？</summary>
-比赛未解析无法获取“团队击杀数”，若是将己方所有玩家的击杀数相加，则会漏掉那些由小兵、防御塔等非玩家单位击杀数；若是将敌方所有玩家的死亡数相加，又会多出送野、自杀等不应算在己方战果中的计数。<br>目前程序采用将己方所有击杀数累加的方式来估算参战率
+
+##### pre.2
+**改进**：
+- 比赛图片模板`match_2`中，现在冠绝排名数字位置更准确了。
+- 比赛图片模板`match_2`中，比赛段位可以显示星级了。
 </details>
 
 # 1.2.7

package/lib/index.js

@@ -117,6 +117,7 @@ function MATCH_INFO(matchId) {
           leaverStatus
           partyId
           position
+          playerSlot
           lane
           imp
           kills
@@ -1213,7 +1214,19 @@ var Config = import_koishi.Schema.intersect([
   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("日报时间小时")
+      dailyReportHours: import_koishi.Schema.number().min(0).max(23).default(6).description("日报时间小时"),
+      dailyReportShowCombi: import_koishi.Schema.boolean().default(true).description("日报是否显示组合")
+    }),
+    import_koishi.Schema.object({})
+  ]),
+  import_koishi.Schema.object({
+    weeklyReportSwitch: import_koishi.Schema.boolean().default(false).description("周报功能").experimental()
+  }),
+  import_koishi.Schema.union([
+    import_koishi.Schema.object({
+      weeklyReportSwitch: import_koishi.Schema.const(true).required(),
+      weeklyReportDayHours: import_koishi.Schema.tuple([import_koishi.Schema.number().min(1).max(7), import_koishi.Schema.number().min(0).max(23)]).default([1, 10]).description("周报发布于周（几）的（几）点"),
+      weeklyReportShowCombi: import_koishi.Schema.boolean().default(true).description("周报是否显示组合")
     }),
     import_koishi.Schema.object({})
   ]),
@@ -1397,7 +1410,7 @@ async function apply(ctx, config) {
     queryMatchAndSend(session, match_id);
   });
   ctx.command("查询最近比赛 [input_data]", "查询玩家的最近比赛").usage("查询指定玩家的最近一场比赛的比赛数据，生成图片发布。\n参数可输入该玩家的SteamID或已在本群绑定玩家的别名，无参数时尝试查询调用指令玩家的SteamID").example("查询最近比赛 123456789").example("查询最近比赛 张三").action(async ({ session }, input_data) => {
-    if (session.guild) {
+    if (session.guild || !session.guild && input_data) {
       let sessionPlayer;
       if (!input_data) {
         sessionPlayer = (await ctx.database.get("dt_subscribed_players", { guildId: session.event.channel.id, platform: session.event.platform, userId: session.event.user.id }))[0];
@@ -1420,6 +1433,8 @@ async function apply(ctx, config) {
         return;
       }
       queryMatchAndSend(session, lastMatchId);
+    } else {
+      session.send("<p>指令调用失败。</p><p>当前不属于群聊状态，必须提供指定玩家的SteamID。</p>");
     }
   });
   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) => {
@@ -1663,81 +1678,13 @@ async function apply(ctx, config) {
     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));
-        const players = (await query(
-          MATCHES_FOR_DAILY(
-            subscribedPlayersInGuild.map((player) => player.steamId).filter((value, index, self) => self.indexOf(value) === index),
-            oneDayAgo
-          )
-        )).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;
-          let guildMember;
-          try {
-            guildMember = await ctx.bots.find((bot) => bot.platform == subPlayer.platform)?.getGuildMember(subPlayer.guildId, subPlayer.userId);
-          } catch (error) {
-            ctx.logger.error("获取群组信息失败。" + error);
-          }
-          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 - b);
-              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());
-            try {
-              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"
-                )
-              );
-            } catch (error) {
-              ctx.logger.error(error);
-            }
-          }
-        }
+        await report(oneDayAgo, "昨日总结", config.dailyReportShowCombi);
+      });
+    }
+    if (config.weeklyReportSwitch) {
+      ctx.cron(`0 ${config.weeklyReportDayHours[1]} * * ${config.weeklyReportDayHours[0]}`, async function() {
+        const oneWeekAgo = (0, import_moment.default)().subtract(1, "weeks").unix();
+        await report(oneWeekAgo, "上周总结", config.weeklyReportShowCombi);
       });
     }
     ctx.cron("* * * * *", async function() {
@@ -1786,15 +1733,16 @@ async function apply(ctx, config) {
               let idsToFind = commingGuild.players.map((player) => player.steamId);
               let broadPlayers = match.players.filter((item) => idsToFind.includes(item.steamAccountId));
               for (let player of broadPlayers) {
-                const random2 = new import_koishi2.Random(() => simpleHashToSeed(match.id, player.steamAccountId));
+                const random2 = new import_koishi2.Random(() => simpleHashToSeed(`${match.id}-${player.steamAccountId}-${player.playerSlot}`));
                 let broadPlayerMessage = `${player.steamAccount.name}的${random2.pick(HEROES_CHINESE[player.hero.id])}`;
+                console.log([player.deathContribution, player.killContribution]);
                 if (player.isRadiant == match.didRadiantWin) {
                   if (player.deathContribution < 0.2 || player.killContribution > 0.75 || player.heroDamage / player.networth > 1.5 || player.towerDamage > 1e4 || player.imp > 0)
                     broadPlayerMessage += random2.pick(WIN_POSITIVE);
                   else
                     broadPlayerMessage += random2.pick(WIN_NEGATIVE);
                 } else {
-                  if (player.deathContribution < 0.25 || player.killContribution > 0.75 || player.heroDamage / player.networth > 1.25 || player.towerDamage > 5e3 || player.imp > 0)
+                  if (player.deathContribution < 0.25 || player.killContribution > 0.75 || player.heroDamage / player.networth > 1 || player.towerDamage > 5e3 || player.imp > 0)
                     broadPlayerMessage += random2.pick(LOSE_POSITIVE);
                   else
                     broadPlayerMessage += random2.pick(LOSE_NEGATIVE);
@@ -1804,7 +1752,7 @@ KDA：${((player.kills + player.assists) / (player.deaths || 1)).toFixed(2)} [${
                 broadMatchMessage += broadPlayerMessage + "\n";
               }
               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}。`);
+              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() }]);
@@ -1818,6 +1766,79 @@ 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(
+      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 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;
+      let guildMember;
+      try {
+        guildMember = await ctx.bots.find((bot) => bot.platform == subPlayer.platform)?.getGuildMember(subPlayer.guildId, subPlayer.userId);
+      } catch (error) {
+        ctx.logger.error("获取群组信息失败。" + error);
+      }
+      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 - b);
+          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());
+        try {
+          await ctx.broadcast(
+            [`${guild.platform}:${guild.guildId}`],
+            `${title}：
+                                ${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")}
+                                ${showCombi ? 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.logger.info(`发布日报于${guild.platform}:${guild.guildId}`);
+        } catch (error) {
+          ctx.logger.error(error);
+        }
+      }
+    }
+  }
+  __name(report, "report");
   ctx.on("dispose", async () => {
   });
 }
@@ -1844,9 +1865,8 @@ function genImageHTML(data, template, type) {
   return result;
 }
 __name(genImageHTML, "genImageHTML");
-function simpleHashToSeed(matchId, playerId) {
-  const input = `${matchId}-${playerId}`;
-  const encoded = btoa(input);
+function simpleHashToSeed(inputString) {
+  const encoded = btoa(inputString);
   let total = 0;
   for (let i = 0; i < encoded.length; i++) {
     total += encoded.charCodeAt(i);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sjtdev/koishi-plugin-dota2tracker",
   "description": "koishi插件-追踪群友的DOTA2对局",
-  "version": "1.2.8-pre",
+  "version": "1.2.8",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -26,7 +26,7 @@
     "dota2"
   ],
   "dependencies": {
-    "dotaconstants": "^8.8.0",
+    "dotaconstants": "^8.10.0",
     "ejs": "^3.1.10",
     "moment": "^2.30.1"
   },

package/readme.md

@@ -12,6 +12,8 @@ DOTA2Bot插件-提供自动追踪群友的最新对局的功能（需群友绑
 在希望推送战报信息的群组（或频道）使用指令`订阅本群`，玩家可使用指令`绑定`来将自身账号与Steam账号绑定，bot会尝试追踪已订阅群组（或频道）中的绑定玩家的最新对局信息。  
 其他查询功能见下方指令说明。  
 **直接调用help指令可获取更详细的说明，调用【指令 -h】还会有用法示例。（例如：订阅本群 -h）**  
+**本插件使用的所有SteamID均为SteamID3类型（即DOTA2游戏内个人页面显示的好友ID与stratz登录后个人页面链接中显示的ID），有关SteamID类型见 https://steamid.tatlead.com/ （由[issue](../../issues/1)提供，感谢这位用户）**  
+  
 **更新日志见[changelog](changelog.md)**  
 
 ### 指令

package/template/hero/hero_1.ejs

@@ -683,7 +683,7 @@
                 `).join("")}
             </div>
             <div class="skills">
-                ${hero.abilities//.filter((item) => dotaconstants.abilities[item.name].behavior != "Hidden")
+                ${hero.abilities//.filter((item) => dotaconstants.abilities[item.name]?.behavior != "Hidden")
                 .map((item) => `
                 <div class="skill" data-innate="${item.ability_is_innate&&!item.ability_is_facet}">
                     <p class="title">
@@ -695,26 +695,20 @@
                     <div class="img_stats">
                         <img src="${utils.getImageUrl(item.name, ImageType.Abilities)}" onerror="this.onerror=null; this.src='${utils.getImageUrl(`innate_icon`,ImageType.Icons)}';"/>
                         <div class="stats">
-                            <p class="behavior">技能：${(Array.isArray(dotaconstants.abilities[item.name].behavior) ? dotaconstants.abilities[item.name].behavior : [dotaconstants.abilities[item.name].behavior])
+                            <p class="behavior">技能：${[].concat(dotaconstants.abilities[item.name]?.behavior)
                                 .filter((beh) => beh !== "Hidden" || !(item.ability_is_granted_by_shard || item.ability_is_granted_by_scepter))
-                                .map((beh) => d2a.behavior[beh])
-                                .join("/")}</p>
-                            ${dotaconstants.abilities[item.name].target_team
-                                    ? `<p class="target_team">影响：${(Array.isArray(dotaconstants.abilities[item.name].target_team)
-                                    ? dotaconstants.abilities[item.name].target_team
-                                    : [dotaconstants.abilities[item.name].target_team])
-                                    .map((tt) => d2a.target_team[tt])
-                                    .join("/")}</p>`
-                                    : ""}
-                            ${!Array.isArray(dotaconstants.abilities[item.name].dmg_type) && dotaconstants.abilities[item.name].dmg_type
-                                    ? `<p class="dmg_type ${dotaconstants.abilities[item.name].dmg_type}">伤害类型：</p>`
-                                    : ""}
-                            ${dotaconstants.abilities[item.name].dispellable
-                                    ? `<p class="dispellable ${dotaconstants.abilities[item.name].dispellable == "Strong Dispels Only" ? "Strong" : dotaconstants.abilities[item.name].dispellable}">能否驱散：</p>`
-                                    : ""}
-                            ${!Array.isArray(dotaconstants.abilities[item.name].bkbpierce) && dotaconstants.abilities[item.name].bkbpierce
-                                    ? `<p class="bkbpierce">无视减益免疫： ${dotaconstants.abilities[item.name].bkbpierce == "Yes" ? "是" : "否"}</p>`
-                                    : ""}
+                                .map((beh) => d2a.behavior[beh]).join("/")}
+                            </p>
+                            ${dotaconstants.abilities[item.name]?.target_team ?
+                            `<p class="target_team">影响：${[].concat(dotaconstants.abilities[item.name]?.target_team)
+                                .map((tt) => d2a.target_team[tt]).join("/")}
+                            </p>` : ""}
+                            ${!Array.isArray(dotaconstants.abilities[item.name]?.dmg_type) && dotaconstants.abilities[item.name]?.dmg_type ?
+                            `<p class="dmg_type ${dotaconstants.abilities[item.name]?.dmg_type}">伤害类型：</p>` : ""}
+                            ${dotaconstants.abilities[item.name]?.dispellable ?
+                            `<p class="dispellable ${dotaconstants.abilities[item.name]?.dispellable == "Strong Dispels Only" ? "Strong" : dotaconstants.abilities[item.name]?.dispellable}">能否驱散：</p>` : ""}
+                            ${!Array.isArray(dotaconstants.abilities[item.name]?.bkbpierce) && dotaconstants.abilities[item.name]?.bkbpierce ?
+                            `<p class="bkbpierce">无视减益免疫： ${dotaconstants.abilities[item.name]?.bkbpierce == "Yes" ? "是" : "否"}</p>` : ""}
                         </div>
                     </div>
                     <p class="description">${item.desc_loc}</p>
@@ -768,7 +762,7 @@
                                 </span>`  : "" }
                                 ${sv.facet_bonus.name ?
                                 `<span class="alternative facet">
-                                    <span class="facet"><span class="name_back type_${hero.facets.find(facet=>facet.name==sv.facet_bonus.name).color}"><img src="${utils.getImageUrl(hero.facets.find(facet=>facet.name==sv.facet_bonus.name).icon, ImageType.IconsFacets)}" />${sv.facet_bonus.values.map(value => (value > 0 ? '<span class="plus">+</span>' : "") + value + (sv.is_percentage ? "%" : "")).join(" / ")}</span></span>
+                                    <span class="facet"><span class="name_back type_${hero.facets.find(facet=>facet.name==sv.facet_bonus.name).color}"><img src="${utils.getImageUrl(hero.facets.find(facet=>facet.name==sv.facet_bonus.name).icon, ImageType.IconsFacets)}" />${sv.facet_bonus.values.map(value => value + (sv.is_percentage ? "%" : "")).join(" / ")}</span></span>
                                 </span>` : "" }
                                 ${sv.bonuses.length ? 
                                 `<span class="alternative talent">

package/template/match/match_2.ejs

@@ -49,6 +49,18 @@
                 color: #ffb400;
             }
 
+            nav > .rank {
+                width: 48px;
+                height: 48px;
+                position: relative;
+            }
+
+            nav > .rank > img {
+                width: 48px;
+                height: 48px;
+                position: absolute;
+            }
+
             .radiant {
                 color: #3c9028;
             }
@@ -232,9 +244,9 @@
             .player > .rank > p {
                 position: absolute;
                 width: 100%;
-                bottom: 3px;
+                bottom: 1.5px;
                 text-align: center;
-                font-size: 9px;
+                font-size: 8px;
                 color: #fff;
                 text-shadow: -1px -1px 0 #000, 1px -1px 0 #000, -1px 1px 0 #000, 1px 1px 0 #000; /* 文字描边 */
             }
@@ -450,7 +462,8 @@
                 <p><%-d2a.lobbyTypes[match.lobbyType] || match.lobbyType%>/<%-d2a.gameMode[match.gameMode] || match.gameMode%></p>
             </div>
             <div class="rank">
-                <img width="48" height="48" src="<%-utils.getImageUrl('medal_' + match.rank?.toString().split('')[0])%>" alt="" />
+                <img src="<%-utils.getImageUrl('medal_' + (match.rank?.toString().split('')[0] ?? '0'))%>" alt="" />
+                <img style="z-index: 1;" src="<%-utils.getImageUrl('star_' + (match.rank?.toString().split('')[1] ?? '0'))%>" alt="" />
             </div>
         </nav>
         <section class="match_result">