feat: migration 4

packages/scripts/src/averages.ts

@@ -0,0 +1,240 @@
+import { chunk, times } from 'lodash';
+import { Region, REGIONS } from '../src/constants/regions';
+import { getAccountInfo } from '../src/core/blitz/getAccountInfo';
+import getTankStats from '../src/core/blitz/getTankStats';
+import { idToRegion } from '../src/core/blitz/idToRegion';
+import {
+  AverageDefinitions,
+  AverageDefinitionsEntry,
+  AverageDefinitionsEntrySubPartial,
+  AverageDefinitionsManifest,
+  Samples,
+} from '../src/core/blitzkit/averageDefinitions';
+import {
+  averageDefinitionsAllStatsKeys,
+  emptySamples,
+} from '../src/core/blitzkit/averageDefinitions/constants';
+import { commitAssets } from '../src/core/blitzkit/commitAssets';
+import { fetchPreDiscoveredIds } from '../src/core/blitzkit/fetchPreDiscoveredIds';
+import { encodeToBase64 } from '../src/core/protobuf/encodeToBase64';
+import { IndividualTankStats } from '../src/types/tanksStats';
+
+interface DataPoint {
+  x: number;
+  y: number;
+  w: number;
+}
+
+const MINUTE = 60 * 1000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+// const MAX_ACTIVITY_TIME = 120 * DAY;
+// const MIN_BATTLES = 5000;
+const RUN_TIME = 5 * HOUR + 55 * MINUTE;
+const THREADS = 10;
+const PLAYER_IDS_PER_CALL = 100;
+
+const startTime = Date.now();
+const preDiscoveredIds = await fetchPreDiscoveredIds();
+const playerIds: Record<Region, number[][]> = {
+  asia: chunk(
+    preDiscoveredIds.filter((id) => idToRegion(id) === 'asia'),
+    PLAYER_IDS_PER_CALL,
+  ),
+  com: chunk(
+    preDiscoveredIds.filter((id) => idToRegion(id) === 'com'),
+    PLAYER_IDS_PER_CALL,
+  ),
+  eu: chunk(
+    preDiscoveredIds.filter((id) => idToRegion(id) === 'eu'),
+    PLAYER_IDS_PER_CALL,
+  ),
+};
+let regionIndex = 0;
+const samples: Samples = { ...emptySamples };
+const availableRegions = [...REGIONS];
+const tankIds: number[] = [];
+const tanksSorted: Record<number, IndividualTankStats[]> = {};
+let postWorkRequested = false;
+
+times(THREADS, async () => {
+  while (availableRegions.length > 0 && startTime + RUN_TIME > Date.now()) {
+    const region = availableRegions[regionIndex];
+    const regionIds = playerIds[region];
+    const [ids] = regionIds.splice(
+      Math.floor(Math.random() * regionIds.length),
+      1,
+    );
+    const accountInfo = await getAccountInfo(region, ids, undefined, {
+      fields: 'last_battle_time,statistics.all.battles',
+    });
+
+    const filteredIds = ids.filter((_, index) => {
+      const info = accountInfo[index];
+
+      if (info === null) return false;
+
+      const timeSinceLastActivity = Date.now() - info.last_battle_time * 1000;
+
+      samples.total++;
+      if (timeSinceLastActivity <= 120 * DAY) samples.d_120++;
+      if (timeSinceLastActivity <= 90 * DAY) samples.d_90++;
+      if (timeSinceLastActivity <= 60 * DAY) samples.d_60++;
+      if (timeSinceLastActivity <= 30 * DAY) samples.d_30++;
+      if (timeSinceLastActivity <= 7 * DAY) samples.d_7++;
+      if (timeSinceLastActivity <= 1 * DAY) samples.d_1++;
+
+      return true;
+
+      // return (
+      //   timeSinceLastActivity <= MAX_ACTIVITY_TIME &&
+      //   info.statistics.all.battles > MIN_BATTLES
+      // );
+    });
+
+    const players = await Promise.all(
+      filteredIds.map((id) =>
+        getTankStats(region, id, {
+          fields: 'last_battle_time,battle_life_time,all,tank_id',
+        }),
+      ),
+    );
+
+    players.forEach((tanks) => {
+      tanks?.forEach((tank) => {
+        if (tank.all.battles === 0) return;
+
+        if (!tankIds.includes(tank.tank_id)) {
+          console.log(
+            `Found new tank: ${tank.tank_id} (${tankIds.length + 1})`,
+          );
+          tankIds.push(tank.tank_id);
+          tanksSorted[tank.tank_id] = [];
+        }
+
+        tanksSorted[tank.tank_id].push(tank);
+      });
+    });
+
+    if (regionIds.length === 0 && availableRegions.includes(region)) {
+      availableRegions.splice(availableRegions.indexOf(region), 1);
+    }
+    regionIndex = (regionIndex + 1) % availableRegions.length;
+  }
+
+  if (!postWorkRequested) {
+    postWorkRequested = true;
+    postWork();
+  }
+});
+
+async function postWork() {
+  console.log(
+    `Generating statistics based on ${samples.d_120.toLocaleString()} players (${samples.total.toLocaleString()} checked in total) and ${tankIds.length} tanks...`,
+  );
+
+  const averages: Record<number, AverageDefinitionsEntry> = {};
+
+  tankIds.forEach((id) => {
+    const tanksSortedEntry = tanksSorted[id];
+    // const tanks = tanksSortedEntry.filter(
+    //   (tank) => Date.now() - tank.last_battle_time * 1000 <= MAX_ACTIVITY_TIME,
+    // );
+    const tanks = tanksSortedEntry;
+    const entry: AverageDefinitionsEntrySubPartial = {
+      mu: {},
+      sigma: {},
+      r: {},
+      samples: { ...emptySamples },
+    };
+
+    tanks.forEach((tank) => {
+      const timeSinceLastActivity = Date.now() - tank.last_battle_time * 1000;
+
+      entry.samples.total++;
+      if (timeSinceLastActivity <= 120 * DAY) entry.samples.d_120++;
+      if (timeSinceLastActivity <= 90 * DAY) entry.samples.d_90++;
+      if (timeSinceLastActivity <= 60 * DAY) entry.samples.d_60++;
+      if (timeSinceLastActivity <= 30 * DAY) entry.samples.d_30++;
+      if (timeSinceLastActivity <= 7 * DAY) entry.samples.d_7++;
+      if (timeSinceLastActivity <= 1 * DAY) entry.samples.d_1++;
+    });
+
+    const dataWY = tanks.map((tank) => ({
+      w: tank.all.battles,
+      y: tank.all.wins / tank.all.battles,
+    }));
+
+    averageDefinitionsAllStatsKeys.forEach((key) => {
+      const data: DataPoint[] = dataWY.map(({ w, y }, index) => ({
+        w,
+        x:
+          (key === 'battle_life_time'
+            ? tanks[index].battle_life_time
+            : tanks[index].all[key]) / w,
+        y,
+      }));
+
+      if (data.length === 0) return;
+
+      function sum(slicer: (data: DataPoint) => number) {
+        return data.reduce(
+          (accumulator, data) => accumulator + slicer(data),
+          0,
+        );
+      }
+
+      const sum_w = sum(({ w }) => w);
+      const sum_wx = sum(({ w, x }) => w * x);
+      const sum_wy = sum(({ w, y }) => w * y);
+      const x_bar = sum_wx / sum_w;
+      const y_bar = sum_wy / sum_w;
+      // undo normalization for mu to get a simple average
+      const mu = sum(({ w, x }) => w * x) / samples.d_120;
+
+      const sigma_numerator = sum(({ w, x }) => w * (x - x_bar) ** 2);
+      const sigma = Math.sqrt(sigma_numerator / sum_w);
+
+      const r_numerator = sum(({ w, x, y }) => w * (x - x_bar) * (y - y_bar));
+      const r_denominator_x = sum(({ w, x }) => w * (x - x_bar) ** 2);
+      const r_denominator_y = sum(({ w, y }) => w * (y - y_bar) ** 2);
+      const r = r_numerator / Math.sqrt(r_denominator_x * r_denominator_y);
+
+      entry.mu[key] = mu;
+      entry.sigma[key] = sigma;
+      entry.r[key] = isNaN(r) ? 0 : r;
+    });
+
+    averages[id] = entry as AverageDefinitionsEntry;
+  });
+
+  const time = Date.now();
+  const latest = Math.round(time / DAY);
+  const averageDefinitions = {
+    averages,
+    samples,
+    time,
+  } satisfies AverageDefinitions;
+
+  const manifest: AverageDefinitionsManifest = {
+    version: 1,
+    latest,
+  };
+
+  commitAssets('averages', [
+    {
+      path: `averages/${latest}.pb`,
+      content: await encodeToBase64(
+        'average_definitions',
+        'blitzkit.AverageDefinitions',
+        averageDefinitions,
+      ),
+      encoding: 'base64',
+    },
+    {
+      path: 'averages/manifest.json',
+      content: JSON.stringify(manifest),
+      encoding: 'utf-8',
+    },
+  ]);
+}