Merge branch 'main' into dev-rinth

scripts/buildAssets/definitions.ts

@@ -38,7 +38,7 @@ import { DATA, POI } from './constants';
 import { Avatar } from './skillIcons';
 import { TankParameters } from './tankIcons';
 
-interface Strings {
+export interface BlitzStrings {
   [key: string]: string;
 }
 type ShellKind =
@@ -334,7 +334,7 @@ const blitzShellKindToBlitzrinth: Record<ShellKind, ShellType> = {
 const missingStrings: Record<string, string> = {
   '#artefacts:tungstentip/name': 'Tungsten Shells',
 };
-const botPattern = /^.+((tutorial_bot(\d+)?)|(TU(R?)))$/;
+export const botPattern = /^.+((tutorial_bot(\d+)?)|(TU(R?)))$/;
 
 export async function definitions(production: boolean) {
   console.log('Building definitions...');
@@ -361,12 +361,12 @@ export async function definitions(production: boolean) {
     (nations) => nations.filter((nation) => nation !== 'common'),
   );
   const tankStringIdMap: Record<string, number> = {};
-  const stringsPreInstalled = await readYAMLDVPL<Strings>(
+  const stringsPreInstalled = await readYAMLDVPL<BlitzStrings>(
     `${DATA}/${POI.strings}/en.yaml.dvpl`,
   );
   const stringsCache = await fetch(POI.cachedStrings)
     .then((response) => response.text())
-    .then((string) => parseYaml(string) as Strings);
+    .then((string) => parseYaml(string) as BlitzStrings);
   const optionalDevices = await readXMLDVPL<{ root: OptionalDevices }>(
     `${DATA}/${POI.optionalDevices}.dvpl`,
   );

scripts/buildAssets/index.ts

@@ -24,15 +24,17 @@ import { skillIcons } from './skillIcons';
 import { tankArmors } from './tankArmors';
 import { tankIcons } from './tankIcons';
 import { tankModels } from './tankModels';
+import { videos } from './videos';
 
 if (!targets && !allTargets) throw new Error('No target(s) specified');
 
 const methods = [
-  // definitions,
-  // scratchedFlags,
-  // currencies,
-  // skillIcons,
-  // circleFlags,
+  definitions,
+  videos,
+  scratchedFlags,
+  currencies,
+  skillIcons,
+  circleFlags,
   shellIcons,
   moduleIcons,
   equipmentIcons,

scripts/buildAssets/tankArmors.ts

@@ -28,9 +28,6 @@ export async function tankArmors(production: boolean) {
           if (tankKey.includes('tutorial_bot')) return;
 
           const id = toUniqueId(nation, tank.id);
-
-          console.log(`Building armor ${id} @ ${nation}/${tankKey}`);
-
           const model = await extractArmor(DATA, `${nation}-${tankKey}`);
 
           changes.push({

scripts/buildAssets/tankModels.ts

@@ -32,9 +32,6 @@ export async function tankModels(production: boolean) {
         if (tankKey.includes('tutorial_bot')) return;
 
         const id = toUniqueId(nation, tank.id);
-
-        console.log(`Building model ${id} @ ${nation}/${tankKey}`);
-
         const parameters = await readYAMLDVPL<TankParameters>(
           `${DATA}/${POI.tankParameters}/${nation}/${tankKey}.yaml.dvpl`,
         );

scripts/buildAssets/videos.ts

@@ -0,0 +1,124 @@
+import { readdir } from 'fs/promises';
+import { google } from 'googleapis';
+import { cloneDeep, uniqBy } from 'lodash';
+import { parse as parseYaml } from 'yaml';
+import { readXMLDVPL } from '../../src/core/blitz/readXMLDVPL';
+import { readYAMLDVPL } from '../../src/core/blitz/readYAMLDVPL';
+import { toUniqueId } from '../../src/core/blitz/toUniqueId';
+import { commitAssets } from '../../src/core/blitzkrieg/commitAssets';
+import {
+  VideoDefinitions,
+  videoDefinitions,
+} from '../../src/core/blitzkrieg/videos';
+import { DATA, POI } from './constants';
+import { BlitzStrings, botPattern, VehicleDefinitionList } from './definitions';
+
+const youtubers = [
+  'UCKBYXp4Xn2I2tL1UL4fpbhw', // droodles
+  'UCrQ-Dy8lVsm11u8pCJ8W7Tw', // fatness
+];
+
+export async function videos(production: boolean) {
+  console.log('Building videos...');
+
+  const currentVideos = await videoDefinitions;
+  const auth = await google.auth.getClient({
+    scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
+  });
+  const youtube = google.youtube({ version: 'v3', auth });
+
+  const nations = await readdir(`${DATA}/${POI.vehicleDefinitions}`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+  const stringsPreInstalled = await readYAMLDVPL<BlitzStrings>(
+    `${DATA}/${POI.strings}/en.yaml.dvpl`,
+  );
+  const stringsCache = await fetch(POI.cachedStrings)
+    .then((response) => response.text())
+    .then((string) => parseYaml(string) as BlitzStrings);
+  const strings = {
+    ...stringsPreInstalled,
+    ...stringsCache,
+  };
+  const tanks: { id: number; name: string; tier: number }[] = [];
+  await Promise.all(
+    nations.map(async (nation) => {
+      const tankList = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+        `${DATA}/${POI.vehicleDefinitions}/${nation}/list.xml.dvpl`,
+      );
+
+      await Promise.all(
+        Object.entries(tankList.root).map(async ([tankKey, tank]) => {
+          if (botPattern.test(tankKey)) return null;
+
+          const id = toUniqueId(nation, tank.id);
+          const name =
+            (tank.shortUserString
+              ? strings[tank.shortUserString]
+              : undefined) ?? strings[tank.userString];
+          const tier = tank.level;
+
+          tanks.push({ id, name, tier });
+        }),
+      );
+    }),
+  );
+
+  const tanksSanitized = tanks
+    .sort((a, b) => b.tier - a.tier)
+    .sort((a, b) => {
+      const lastUpdatedA = currentVideos[a.id]?.lastUpdated ?? 0;
+      const lastUpdatedB = currentVideos[b.id]?.lastUpdated ?? 0;
+      return lastUpdatedA - lastUpdatedB;
+    });
+  const videos: VideoDefinitions = cloneDeep(currentVideos);
+
+  let done = 0;
+  for (const tank of tanksSanitized) {
+    try {
+      const results = await youtube.search.list({
+        part: ['snippet'],
+        q: `World of Tanks Blitz ${tank.name}`,
+      });
+
+      if (!results.data.items || results.data.items.length === 0) continue;
+
+      const items = uniqBy(
+        results.data.items.filter(
+          (item) =>
+            item.snippet?.channelId &&
+            item.id?.videoId &&
+            youtubers.includes(item.snippet.channelId),
+        ),
+        (item) => item.snippet!.channelId,
+      );
+
+      videos[tank.id] = {
+        lastUpdated: Math.round(Date.now() / 1000),
+        videos: items.map((item) => item.id!.videoId!),
+      };
+
+      console.log(
+        `${++done} / ${tanks.length} (${Math.round(100 * (done / tanks.length))}%) done; found ${items.length} for ${tank.name}`,
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 1000 / 5));
+    } catch (error) {
+      console.warn('An error occurred, safely exiting prematurely...', error);
+      break;
+    }
+  }
+
+  const content = Object.entries(videos)
+    .map(
+      ([id, { videos, lastUpdated }]) =>
+        `${id},${lastUpdated},${videos.join(',')}`,
+    )
+    .join('\n');
+
+  await commitAssets(
+    'videos',
+    [{ content, encoding: 'utf-8', path: 'definitions/videos.csv' }],
+    production,
+  );
+}