fix: logsin

packages/bot/src/core/blitzstars/filterStats.ts

@@ -0,0 +1,79 @@
+import { blitzStarsTankAverages } from './tankAverages';
+import { SupplementaryStats } from '@blitzkit/core/src/blitz/getAccountInfo';
+import { tankDefinitions, TreeType } from '@blitzkit/core/src/blitzkit/tankDefinitions';
+import { calculateWN8 } from '@blitzkit/core/src/statistics/calculateWN8';
+import { BlitzStats } from '@blitzkit/core/src/statistics/compositeStats';
+import { sumAllStats } from '@blitzkit/core/src/statistics/sumAllStats';
+
+export interface StatFilters {
+  nation?: string;
+  tier?: number;
+  tankType?: string;
+  treeType?: TreeType;
+  tank?: number;
+}
+
+export async function filterStats(
+  { diff, order }: DiffedTankStats,
+  filters: StatFilters,
+) {
+  // tank, if provided, takes priority over all other filters
+  if (filters.tank) filters = { tank: filters.tank };
+
+  const awaitedTankDefinitions = await tankDefinitions;
+  const awaitedTankAverages = await blitzStarsTankAverages;
+  const filteredOrder = order.filter((id) => {
+    const entry = awaitedTankDefinitions[id];
+
+    return (
+      entry &&
+      (filters.nation === undefined || entry.nation === filters.nation) &&
+      (filters.tier === undefined || entry.tier === filters.tier) &&
+      (filters.tankType === undefined || entry.class === filters.tankType) &&
+      (filters.treeType === undefined ||
+        (filters.treeType === 'collector' && entry.treeType === 'collector') ||
+        (filters.treeType === 'premium' && entry.treeType === 'premium') ||
+        (filters.treeType === 'researchable' &&
+          entry.treeType === 'researchable')) &&
+      (filters.tank === undefined || entry.id === filters.tank)
+    );
+  });
+  const stats = sumAllStats(filteredOrder.map((id) => diff[id]));
+  const battlesOfTanksWithAverages = filteredOrder.reduce<number>(
+    (accumulator, id) =>
+      awaitedTankAverages[id] ? accumulator + diff[id].battles : accumulator,
+    0,
+  );
+  const battlesOfTanksWithTankDefinition = filteredOrder.reduce<number>(
+    (accumulator, id) =>
+      awaitedTankDefinitions[id] ? accumulator + diff[id].battles : accumulator,
+    0,
+  );
+  const supplementary = {
+    WN8:
+      filteredOrder.reduce<number>(
+        (accumulator, id) =>
+          awaitedTankAverages[id]
+            ? accumulator +
+              calculateWN8(awaitedTankAverages[id].all, diff[id]) *
+                diff[id].battles
+            : accumulator,
+        0,
+      ) / battlesOfTanksWithAverages,
+    tier:
+      filteredOrder.reduce<number>(
+        (accumulator, id) =>
+          awaitedTankDefinitions[id]
+            ? accumulator + awaitedTankDefinitions[id]!.tier * diff[id].battles
+            : accumulator,
+        0,
+      ) / battlesOfTanksWithTankDefinition,
+  } satisfies SupplementaryStats;
+
+  return { stats, supplementary, filteredOrder };
+}
+
+export interface DiffedTankStats {
+  diff: Record<number, BlitzStats>;
+  order: number[];
+}

packages/bot/src/core/blitzstars/tankAverages.ts

@@ -0,0 +1,101 @@
+import { BlitzStats } from '@blitzkit/core';
+import { context } from '@blitzkit/core/src/blitzkit/context';
+
+interface SpecialStats {
+  winrate: number;
+  damageRatio: number;
+  kdr: number;
+  damagePerBattle: number;
+  killsPerBattle: number;
+  hitsPerBattle: number;
+  spotsPerBattle: number;
+  wpm: number;
+  dpm: number;
+  kpm: number;
+  hitRate: number;
+  survivalRate: number;
+}
+
+export type Percentiles = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+export interface SpecialPercentiles {
+  winRate: Percentiles;
+  damageRatio: Percentiles;
+  kdr: Percentiles;
+  damagePerBattle: Percentiles;
+  killsPerBattle: Percentiles;
+  hitsPerBattle: Percentiles;
+  spotsPerBattle: Percentiles;
+  wpm: Percentiles;
+  dpm: Percentiles;
+  kpm: Percentiles;
+  hitRate: Percentiles;
+  survivalRate: Percentiles;
+}
+
+export interface MeanSd {
+  winrateMean: number;
+  winrateSd: number;
+  hitRateMean: number;
+  hitRateSd: number;
+  survivalRateMean: number;
+  survivalRateSd: number;
+  damageRatioMean: number;
+  damageRatioSd: number;
+  kdrMean: number;
+  kdrSd: number;
+  dpbMean: number;
+  dpbSd: number;
+  kpbMean: number;
+  kpbSd: number;
+  hpbMean: number;
+  hpbSd: number;
+  spbMean: number;
+  spbSd: number;
+}
+
+export interface IndividualTankAverage {
+  _id: number;
+  battle_life_time: number;
+  total_battle_life_time: number;
+  number_of_players: number;
+  tank_id: number;
+  all: BlitzStats;
+  special: SpecialStats;
+  percentiles: SpecialPercentiles;
+  percentiles_player_count: number;
+  meanSd: MeanSd;
+  shotEff: number;
+  last_update: number;
+}
+
+export type BlitzStarsTankAverages = Record<number, IndividualTankAverage>;
+
+export const blitzStarsTankAverages = fetch(
+  'https://www.blitzstars.com/api/tankaverages.json',
+)
+  .then((response) => response.json())
+  .then((json) => {
+    if (context === 'server') {
+      const partialTankAverages: BlitzStarsTankAverages = {};
+
+      (json as IndividualTankAverage[]).forEach((individualTankAverage) => {
+        partialTankAverages[individualTankAverage.tank_id] =
+          individualTankAverage;
+      });
+
+      return partialTankAverages;
+    } else {
+      return json as BlitzStarsTankAverages;
+    }
+  });