feat: migration 4

packages/scripts/src/buildAssets/boosterIcons.ts

@@ -0,0 +1,51 @@
+import { readdir } from 'fs/promises';
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readStringDVPL } from '../../src/core/blitz/readStringDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+
+export async function boosterIcons() {
+  const boosterFiles = (await readdir(`${DATA}/Gfx/Shared/boosters`)).filter(
+    (file) => !file.endsWith('@2x.txt.dvpl') && !file.startsWith('texture0'),
+  );
+  const image = sharp(
+    await readDVPLFile(`${DATA}/Gfx/Shared/boosters/texture0.packed.webp.dvpl`),
+  );
+  const changes: FileChange[] = [];
+
+  await Promise.all(
+    boosterFiles.map(async (file) => {
+      const name = file.match(/booster_(.+).txt.dvpl/)?.[1];
+
+      if (name === undefined) return;
+
+      const sizes = (
+        await readStringDVPL(`${DATA}/Gfx/Shared/boosters/${file}`)
+      )
+        .split('\n')[4]
+        .split(' ')
+        .map(Number);
+      const content = (
+        await image
+          .clone()
+          .extract({
+            left: sizes[0],
+            top: sizes[1],
+            width: sizes[2],
+            height: sizes[3],
+          })
+          .toBuffer()
+      ).toString('base64');
+
+      changes.push({
+        path: `icons/boosters/${name}.webp`,
+        content,
+        encoding: 'base64',
+      });
+    }),
+  );
+
+  await commitAssets('booster icons', changes);
+}

packages/scripts/src/buildAssets/camouflageIcons.ts

@@ -0,0 +1,20 @@
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+
+export async function camouflageIcons() {
+  console.log('Building camouflage icons...');
+  const content = await readDVPLFile(
+    `${DATA}/Gfx/UI/Hangar/IconCamouflage.packed.webp.dvpl`,
+  ).then((content) => content.toString('base64'));
+  const changes: FileChange[] = [
+    {
+      content,
+      encoding: 'base64',
+      path: 'icons/camo.webp',
+    },
+  ];
+
+  await commitAssets('camo icons', changes);
+}

packages/scripts/src/buildAssets/constants.ts

@@ -0,0 +1,11 @@
+import { readdir } from 'fs/promises';
+import { argv } from 'process';
+
+const isDepot = argv.includes('--depot');
+
+export const DATA = isDepot
+  ? await (async () => {
+      const [installationVersion] = await readdir(`depots/444202`);
+      return `depots/444202/${installationVersion}/Data`;
+    })()
+  : 'C:/Program Files (x86)/Steam/steamapps/common/World of Tanks Blitz/Data';

packages/scripts/src/buildAssets/consumableProvisionIcons.ts

@@ -0,0 +1,192 @@
+import { existsSync } from 'fs';
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readStringDVPL } from '../../src/core/blitz/readStringDVPL';
+import { readXMLDVPL } from '../../src/core/blitz/readXMLDVPL';
+import { readYAMLDVPL } from '../../src/core/blitz/readYAMLDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+import { ConsumablesCommon, ProvisionsCommon } from './definitions';
+
+interface Mappings {
+  Header: { version: number };
+  StyleSheets: {
+    selectors: string[];
+    properties: { 'bg-sprite': string };
+  }[];
+}
+
+const listItemsPattern = /<items path="(.+)\.xml"\/>/g;
+
+export async function consumableProvisionIcons() {
+  console.log('Building consumable and provision icons...');
+
+  const changes: FileChange[] = [];
+
+  const styles = [
+    'UI/Styles/Lobby/Inventory/Event/InventoryBigStyles.yaml',
+    'UI/Styles/Lobby/Inventory/Event/InventoryNormalStyles.yaml',
+    'UI/Styles/Lobby/Inventory/InventoryNormalStyles.yaml',
+    'UI/Screens3/Lobby/Inventory/Equipment/EquipmentItemImage.style.yaml',
+    'UI/Screens/Battle/Styles/BattleEquipmentStyles.yaml',
+  ];
+  const styleSheets = await Promise.all(
+    styles.map(async (path) =>
+      Object.values(
+        (await readYAMLDVPL<Mappings>(`${DATA}/${path}.dvpl`)).StyleSheets,
+      ),
+    ),
+  ).then((array) => array.flat());
+
+  for (const match of (
+    await readStringDVPL(
+      `${DATA}/XML/item_defs/vehicles/common/consumables/list.xml.dvpl`,
+    )
+  ).matchAll(listItemsPattern)) {
+    const consumablesCommon = await readXMLDVPL<{
+      root: ConsumablesCommon;
+    }>(
+      `${DATA}/XML/item_defs/vehicles/common/consumables/${match[1]}.xml.dvpl`,
+    );
+
+    await Promise.all(
+      Object.values(consumablesCommon.root).map(async (consumable) => {
+        const styleSheet = styleSheets.find((styleSheet) =>
+          styleSheet.selectors.some((selector) =>
+            selector.includes(`${consumable.icon} `),
+          ),
+        );
+
+        if (!styleSheet) {
+          console.warn(
+            `No style sheet found for consumable ${consumable.icon}; skipping...`,
+          );
+          return;
+        }
+
+        const configPath = styleSheet.properties['bg-sprite']
+          .replace('~res:/', '')
+          .replace('.psd', '')
+          .replace('.txt', '');
+
+        if (existsSync(`${DATA}/${configPath}.packed.webp.dvpl`)) {
+          const image = sharp(
+            await readDVPLFile(`${DATA}/${configPath}.packed.webp.dvpl`),
+          );
+          const content = (
+            await image.trim({ threshold: 100 }).toBuffer()
+          ).toString('base64');
+
+          changes.push({
+            path: `icons/consumables/${consumable.id}.webp`,
+            encoding: 'base64',
+            content,
+          });
+        } else {
+          const consumablesTexture = sharp(
+            await readDVPLFile(
+              `${`${DATA}/${configPath}`.split('/').slice(0, -1).join('/')}/texture0.packed.webp.dvpl`,
+            ),
+          );
+          const sizes = (await readStringDVPL(`${DATA}/${configPath}.txt.dvpl`))
+            .split('\n')[4]
+            .split(' ')
+            .map(Number);
+          const content = (
+            await consumablesTexture
+              .clone()
+              .extract({
+                left: sizes[0],
+                top: sizes[1],
+                width: sizes[2],
+                height: sizes[3],
+              })
+              .toBuffer()
+          ).toString('base64');
+
+          changes.push({
+            path: `icons/consumables/${consumable.id}.webp`,
+            encoding: 'base64',
+            content,
+          });
+        }
+      }),
+    );
+  }
+
+  for (const match of (
+    await readStringDVPL(
+      `${DATA}/XML/item_defs/vehicles/common/provisions/list.xml.dvpl`,
+    )
+  ).matchAll(listItemsPattern)) {
+    const provisionsCommon = await readXMLDVPL<{
+      root: ProvisionsCommon;
+    }>(`${DATA}/XML/item_defs/vehicles/common/provisions/${match[1]}.xml.dvpl`);
+    await Promise.all(
+      Object.values(provisionsCommon.root).map(async (provision) => {
+        const styleSheet = styleSheets.find((styleSheet) =>
+          styleSheet.selectors.some((selector) =>
+            selector.includes(`${provision.icon} `),
+          ),
+        );
+
+        if (!styleSheet) {
+          console.warn(
+            `No style sheet found for provision ${provision.icon}; skipping...`,
+          );
+          return;
+        }
+
+        const configPath = styleSheet.properties['bg-sprite']
+          .replace('~res:/', '')
+          .replace('.psd', '')
+          .replace('.txt', '');
+
+        if (existsSync(`${DATA}/${configPath}.packed.webp.dvpl`)) {
+          const image = sharp(
+            await readDVPLFile(`${DATA}/${configPath}.packed.webp.dvpl`),
+          );
+          const content = (
+            await image.trim({ threshold: 100 }).toBuffer()
+          ).toString('base64');
+
+          changes.push({
+            path: `icons/provisions/${provision.id}.webp`,
+            encoding: 'base64',
+            content,
+          });
+        } else {
+          const provisionsTexture = sharp(
+            await readDVPLFile(
+              `${`${DATA}/${configPath}`.split('/').slice(0, -1).join('/')}/texture0.packed.webp.dvpl`,
+            ),
+          );
+          const sizes = (await readStringDVPL(`${DATA}/${configPath}.txt.dvpl`))
+            .split('\n')[4]
+            .split(' ')
+            .map(Number);
+          const content = (
+            await provisionsTexture
+              .clone()
+              .extract({
+                left: sizes[0],
+                top: sizes[1],
+                width: sizes[2],
+                height: sizes[3],
+              })
+              .toBuffer()
+          ).toString('base64');
+
+          changes.push({
+            path: `icons/provisions/${provision.id}.webp`,
+            encoding: 'base64',
+            content,
+          });
+        }
+      }),
+    );
+  }
+
+  await commitAssets('consumable and provision icons', changes);
+}

packages/scripts/src/buildAssets/currencies.ts

@@ -0,0 +1,79 @@
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { assertSecret } from '../../src/core/blitzkit/secret';
+import { DATA } from './constants';
+
+const ICONS = [
+  ['currency_silver_m.packed.webp', 'silver'],
+  ['currency_premium_xl.packed.webp', 'premium'],
+  ['currency_gold_m.packed.webp', 'gold'],
+  ['currency_free-xp_xl.packed.webp', 'free-xp'],
+  ['currency_elite-xp_xl.packed.webp', 'elite-xp'],
+  ['currency_crew-xp_xl.packed.webp', 'crew-xp'],
+  ['currency_battle-xp_xl.packed.webp', 'xp'],
+];
+
+type BlitzGlossary = Record<
+  string,
+  {
+    image_url: null | string;
+  }
+>;
+
+export async function currencies() {
+  console.log('Building currency icons...');
+
+  const changes: FileChange[] = [];
+
+  await Promise.all(
+    ICONS.map(async ([file, name]) => {
+      const content = (
+        await sharp(
+          await readDVPLFile(`${DATA}/Gfx/Lobby/currency/${file}.dvpl`),
+        )
+          .trim()
+          .toBuffer()
+      ).toString('base64');
+
+      changes.push({
+        content,
+        encoding: 'base64',
+        path: `icons/currencies/${name}.webp`,
+      });
+    }),
+  );
+
+  const glossary = await fetch(assertSecret(process.env.WOTB_GLOSSARY)).then(
+    (response) => response.json() as Promise<BlitzGlossary>,
+  );
+
+  await Promise.all(
+    Object.entries(glossary)
+      .filter(([key]) => /^prx_season_\d+$/.test(key))
+      .map(async ([key, item]) => {
+        if (item.image_url === null) throw new Error(`No image_url for ${key}`);
+
+        const imageRaw = await fetch(item.image_url).then((response) =>
+          response.arrayBuffer(),
+        );
+        const content = (
+          await sharp(imageRaw)
+            .trim({
+              threshold: 100,
+              background: { r: 0, g: 0, b: 0, alpha: 0 },
+            })
+            .toBuffer()
+        ).toString('base64');
+
+        changes.push({
+          content,
+          encoding: 'base64',
+          path: `icons/currencies/${key}.webp`,
+        });
+      }),
+  );
+
+  await commitAssets('currency icons', changes);
+}

packages/scripts/src/buildAssets/equipmentIcons.ts

@@ -0,0 +1,95 @@
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readStringDVPL } from '../../src/core/blitz/readStringDVPL';
+import { readXMLDVPL } from '../../src/core/blitz/readXMLDVPL';
+import { readYAMLDVPL } from '../../src/core/blitz/readYAMLDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+import { OptionalDevices } from './definitions';
+
+interface Mappings {
+  Header: { version: number };
+
+  StyleSheets: {
+    selectors: string[];
+    properties: { 'bg-sprite': string };
+  }[];
+}
+
+export async function equipmentIcons() {
+  console.log('Building equipment icons...');
+
+  const changes: FileChange[] = [];
+  const optionalDevices = await readXMLDVPL<{ root: OptionalDevices }>(
+    `${DATA}/XML/item_defs/vehicles/common/optional_devices.xml.dvpl`,
+  );
+  const mappings = await readYAMLDVPL<Mappings>(
+    `${DATA}/UI/Screens3/Lobby/Inventory/OptionalDevices/OptionalDevicesItemImage.style.yaml.dvpl`,
+  );
+  const image = sharp(
+    await readDVPLFile(
+      `${DATA}/Gfx/UI/InventoryIcons/Big/OptionalDevices/texture0.packed.webp.dvpl`,
+    ),
+  );
+
+  await Promise.all(
+    Object.entries(optionalDevices.root).map(
+      async ([optionalDeviceKey, optionalDevice]) => {
+        if (optionalDeviceKey === 'nextAvailableId') return;
+
+        const mapping = mappings.StyleSheets.find((mapping) =>
+          mapping.selectors.includes(
+            `.optional_device_item.${optionalDevice.icon} #Img`,
+          ),
+        );
+
+        if (!mapping) {
+          console.warn(
+            `No mapping found for ${optionalDevice.icon}; skipping...`,
+          );
+          return;
+        }
+
+        const configPathRaw = mapping.properties['bg-sprite'];
+        const configPath = configPathRaw.replace('~res:/', '');
+
+        if (configPath.startsWith('Gfx/Lobby')) {
+          const configPathWebp = configPath.replace('.txt', '');
+          const image = sharp(
+            await readDVPLFile(`${DATA}/${configPathWebp}.packed.webp.dvpl`),
+          );
+          const content = (await image.trim().toBuffer()).toString('base64');
+
+          changes.push({
+            path: `icons/equipment/${optionalDevice.id}.webp`,
+            encoding: 'base64',
+            content,
+          });
+        } else {
+          const config = await readStringDVPL(`${DATA}/${configPath}.dvpl`);
+          const sizes = config.split('\n')[4].split(' ').map(Number);
+          const content = (
+            await image
+              .clone()
+              .extract({
+                left: sizes[0],
+                top: sizes[1],
+                width: sizes[2],
+                height: sizes[3],
+              })
+              .toBuffer()
+          ).toString('base64');
+
+          changes.push({
+            path: `icons/equipment/${optionalDevice.id}.webp`,
+            encoding: 'base64',
+            content,
+          });
+        }
+      },
+    ),
+  );
+
+  await commitAssets('equipment icons', changes);
+}

packages/scripts/src/buildAssets/flags.ts

@@ -0,0 +1,84 @@
+import { readdir } from 'fs/promises';
+import sharp from 'sharp';
+import { readBase64DVPL } from '../../src/core/blitz/readBase64DVPL';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+
+export async function flags() {
+  console.log('Building flags...');
+
+  const changes = [
+    ...(await Promise.all(
+      (await readdir(`${DATA}/Gfx/Lobby/flags`))
+        .filter(
+          (flag) =>
+            flag.startsWith('flag_profile-stat_') &&
+            !flag.endsWith('@2x.packed.webp.dvpl'),
+        )
+        .map(async (flag) => {
+          const image = sharp(
+            await readDVPLFile(`${DATA}/Gfx/Lobby/flags/${flag}`),
+          );
+          const content = (
+            await image.trim({ threshold: 100 }).toBuffer()
+          ).toString('base64');
+          const name = flag.match(/flag_profile-stat_(.+)\.packed\.webp/)![1];
+
+          return {
+            content,
+            encoding: 'base64',
+            path: `flags/circle/${name}.webp`,
+          } satisfies FileChange;
+        }),
+    )),
+    ...(await Promise.all(
+      (await readdir(`${DATA}/Gfx/Lobby/flags`))
+        .filter(
+          (flag) =>
+            flag.startsWith('flag_tutor-tank_') &&
+            !flag.endsWith('@2x.packed.webp.dvpl'),
+        )
+        .map(async (flag) => {
+          const content = await readBase64DVPL(
+            `${DATA}/Gfx/Lobby/flags/${flag}`,
+          );
+          const name = flag.match(/flag_tutor-tank_(.+)\.packed\.webp/)![1];
+
+          return {
+            content,
+            encoding: 'base64',
+            path: `flags/scratched/${name}.webp`,
+          } satisfies FileChange;
+        }),
+    )),
+    ...(await Promise.all(
+      (await readdir(`${DATA}/Gfx/Lobby/flags`))
+        .filter(
+          (flag) =>
+            flag.startsWith('flag_filter_') &&
+            flag.endsWith('@2x.packed.webp.dvpl'),
+        )
+        .map(async (flag) => {
+          const content = (
+            await sharp(await readDVPLFile(`${DATA}/Gfx/Lobby/flags/${flag}`))
+              .trim({
+                threshold: 100,
+                background: { r: 0, g: 0, b: 0, alpha: 0 },
+              })
+              .toBuffer()
+          ).toString('base64');
+          const name = flag.match(/flag_filter_(.+)@2x\.packed\.webp/)![1];
+
+          return {
+            content,
+            encoding: 'base64',
+            path: `flags/fade_small/${name}.webp`,
+          } satisfies FileChange;
+        }),
+    )),
+  ];
+
+  await commitAssets('flags', changes);
+}

packages/scripts/src/buildAssets/gameModeBanners.ts

@@ -0,0 +1,54 @@
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readYAMLDVPL } from '../../src/core/blitz/readYAMLDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+import { SquadBattleTypeStyles } from './definitions';
+
+export async function gameModeBanners() {
+  console.log('Building game mode banners...');
+
+  const changes: FileChange[] = [];
+  const gameTypeSelectorStyles = await readYAMLDVPL<SquadBattleTypeStyles>(
+    `${DATA}/UI/Screens/Lobby/Hangar/GameTypeSelector.yaml.dvpl`,
+  );
+  const squadBattleTypeStyles = await readYAMLDVPL<SquadBattleTypeStyles>(
+    `${DATA}/UI/Screens3/Lobby/Hangar/Squad/SquadBattleType.yaml.dvpl`,
+  );
+  const bannerMatches: { name: string; path: string }[] = [];
+
+  for (const match of gameTypeSelectorStyles.Prototypes[0].components.UIDataLocalBindingsComponent.data[1][2].matchAll(
+    /eGameMode\.([a-zA-Z]+) -> "~res:([^"]+)"/g,
+  )) {
+    bannerMatches.push({ name: match[1], path: match[2] });
+  }
+
+  for (const match of squadBattleTypeStyles.Prototypes[0].components.UIDataLocalBindingsComponent.data[1][2].matchAll(
+    /"(\d+)" -> "battleType\/([a-zA-Z]+)"/g,
+  )) {
+    const id = Number(match[1]);
+    const name = match[2];
+    let path = bannerMatches.find(
+      (bannerMatch) => bannerMatch.name.toLowerCase() === name.toLowerCase(),
+    )?.path;
+
+    if (path === undefined) {
+      path = `/Gfx/UI/Hangar/GameTypes/battle-type_${name.toLowerCase()}`;
+    }
+
+    const content = (
+      await sharp(await readDVPLFile(`${DATA}${path}.packed.webp.dvpl`))
+        .trim({ background: { r: 0, g: 0, b: 0, alpha: 0 } })
+        .toBuffer()
+    ).toString('base64');
+
+    changes.push({
+      path: `icons/game_mode_banners/${id}.webp`,
+      content,
+      encoding: 'base64',
+    });
+  }
+
+  await commitAssets('game mode banners', changes);
+}

packages/scripts/src/buildAssets/index.ts

@@ -0,0 +1,54 @@
+import { config } from 'dotenv';
+import { argv } from 'process';
+
+config();
+
+const allTargets = argv.includes('--all-targets');
+const targets = argv
+  .find((argument) => argument.startsWith('--target'))
+  ?.split('=')[1]
+  .split(',');
+
+import { boosterIcons } from './boosterIcons';
+import { camouflageIcons } from './camouflageIcons';
+import { consumableProvisionIcons } from './consumableProvisionIcons';
+import { currencies } from './currencies';
+import { definitions } from './definitions';
+import { equipmentIcons } from './equipmentIcons';
+import { flags } from './flags';
+import { gameModeBanners } from './gameModeBanners';
+import { moduleIcons } from './moduleIcons';
+import { shellIcons } from './shellIcons';
+import { skillIcons } from './skillIcons';
+import { tankArmors } from './tankArmors';
+import { tankIcons } from './tankIcons';
+import { tankModels } from './tankModels';
+
+if (!targets && !allTargets) throw new Error('No target(s) specified');
+
+const methods = [
+  tankModels,
+  tankArmors,
+  gameModeBanners,
+  definitions,
+  tankIcons,
+  currencies,
+  skillIcons,
+  flags,
+  shellIcons,
+  moduleIcons,
+  equipmentIcons,
+  consumableProvisionIcons,
+  camouflageIcons,
+  boosterIcons,
+];
+
+for (const method of methods) {
+  if (allTargets || targets?.includes(method.name)) {
+    try {
+      await method();
+    } catch (error) {
+      console.warn(`Failed method ${method.name}; skipping...`, error);
+    }
+  }
+}

packages/scripts/src/buildAssets/moduleIcons.ts

@@ -0,0 +1,37 @@
+import { readdir } from 'fs/promises';
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+
+export async function moduleIcons() {
+  console.log('Building module icons...');
+
+  const changes = await Promise.all(
+    (await readdir(`${DATA}/Gfx/UI/ModulesTechTree`))
+      .filter(
+        (file) =>
+          !file.endsWith('@2x.packed.webp.dvpl') && file.startsWith('vehicle'),
+      )
+      .map(async (file) => {
+        const nameRaw = file.match(/vehicle(.+)\.packed\.webp\.dvpl/)![1];
+        const name = nameRaw[0].toLowerCase() + nameRaw.slice(1);
+        const content = (
+          await sharp(
+            await readDVPLFile(`${DATA}/Gfx/UI/ModulesTechTree/${file}`),
+          )
+            .trim()
+            .toBuffer()
+        ).toString('base64');
+
+        return {
+          content,
+          path: `icons/modules/${name}.webp`,
+          encoding: 'base64',
+        } satisfies FileChange;
+      }),
+  );
+
+  await commitAssets('module icons', changes);
+}

packages/scripts/src/buildAssets/shellIcons.ts

@@ -0,0 +1,51 @@
+import { readdir } from 'fs/promises';
+import sharp from 'sharp';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readStringDVPL } from '../../src/core/blitz/readStringDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+
+export async function shellIcons() {
+  console.log('Building shell icons...');
+
+  const image = sharp(
+    await readDVPLFile(
+      `${DATA}/Gfx/Shared/tank-supply/ammunition/big/texture0.packed.webp.dvpl`,
+    ),
+  );
+
+  const changes = await Promise.all(
+    (await readdir(`${DATA}/Gfx/Shared/tank-supply/ammunition/big`))
+      .filter((file) => file.endsWith('_l.txt.dvpl'))
+      .map(async (file) => {
+        const name = file.match(/(.+)_l\.txt\.dvpl/)![1];
+        const sizes = (
+          await readStringDVPL(
+            `${DATA}/Gfx/Shared/tank-supply/ammunition/big/${file}`,
+          )
+        )
+          .split('\n')[4]
+          .split(' ')
+          .map(Number);
+
+        return {
+          content: (
+            await image
+              .clone()
+              .extract({
+                left: sizes[0],
+                top: sizes[1],
+                width: sizes[2],
+                height: sizes[3],
+              })
+              .toBuffer()
+          ).toString('base64'),
+          encoding: 'base64',
+          path: `icons/shells/${name}.webp`,
+        } satisfies FileChange;
+      }),
+  );
+
+  await commitAssets('shell icons', changes);
+}

packages/scripts/src/buildAssets/skillIcons.ts

@@ -0,0 +1,51 @@
+import sharp from 'sharp';
+import { TankClass } from '../../src/components/Tanks';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readXMLDVPL } from '../../src/core/blitz/readXMLDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+
+interface SkillIcon {
+  name: string;
+  state: number;
+}
+
+export interface Avatar {
+  roles: unknown;
+  skillsByClasses: Record<TankClass, string>;
+  skills: {
+    [name: string]: {
+      userString: string;
+      effectDescription: string;
+      tipDescription: string;
+      icon: SkillIcon | SkillIcon[];
+      type: 'continuous' | 'trigger';
+    };
+  };
+}
+
+export async function skillIcons() {
+  console.log('Building skill icons...');
+
+  const avatar = await readXMLDVPL<{ root: Avatar }>(
+    `${DATA}/XML/item_defs/tankmen/avatar.xml.dvpl`,
+  );
+  const changes = await Promise.all(
+    Object.values(avatar.root.skills).map(async (skill) => {
+      const icon = Array.isArray(skill.icon) ? skill.icon[0] : skill.icon;
+      const name = icon.name.split('/').at(-1)!.replace(/_\d$/, '');
+      const path = `${DATA}${icon.name.replace('~res:', '')}.packed.webp.dvpl`;
+      const image = sharp(await readDVPLFile(path)).trim();
+      const content = (await image.toBuffer()).toString('base64');
+
+      return {
+        content,
+        encoding: 'base64',
+        path: `icons/skills/${name}.webp`,
+      } satisfies FileChange;
+    }),
+  );
+
+  commitAssets('skill icons', changes);
+}

packages/scripts/src/buildAssets/tankArmors.ts

@@ -0,0 +1,46 @@
+import { NodeIO } from '@gltf-transform/core';
+import { readdir } from 'fs/promises';
+import { extractArmor } from '../../src/core/blitz/extractArmor';
+import { readXMLDVPL } from '../../src/core/blitz/readXMLDVPL';
+import { toUniqueId } from '../../src/core/blitz/toUniqueId';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+import { VehicleDefinitionList } from './definitions';
+
+export async function tankArmors() {
+  console.log('Building tank armors...');
+
+  const changes: FileChange[] = [];
+  const nodeIO = new NodeIO();
+  const nations = await readdir(`${DATA}/XML/item_defs/vehicles`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+
+  await Promise.all(
+    nations.map(async (nation) => {
+      const tanks = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+        `${DATA}/XML/item_defs/vehicles/${nation}/list.xml.dvpl`,
+      );
+
+      await Promise.all(
+        Object.entries(tanks.root).map(async ([tankKey, tank]) => {
+          if (tankKey.includes('tutorial_bot')) return;
+
+          const id = toUniqueId(nation, tank.id);
+          const model = await extractArmor(DATA, `${nation}-${tankKey}`);
+
+          changes.push({
+            path: `3d/tanks/armor/${id}.glb`,
+            encoding: 'base64',
+            content: Buffer.from(await nodeIO.writeBinary(model)).toString(
+              'base64',
+            ),
+          });
+        }),
+      );
+    }),
+  );
+
+  await commitAssets('tank armor', changes);
+}

packages/scripts/src/buildAssets/tankIcons.ts

@@ -0,0 +1,101 @@
+import { readdir } from 'fs/promises';
+import sharp from 'sharp';
+import { Vector3Tuple } from 'three';
+import { NATION_IDS } from '../../src/constants/nations';
+import { readDVPLFile } from '../../src/core/blitz/readDVPLFile';
+import { readXMLDVPL } from '../../src/core/blitz/readXMLDVPL';
+import { readYAMLDVPL } from '../../src/core/blitz/readYAMLDVPL';
+import { commitAssets } from '../../src/core/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+import { VehicleDefinitionList } from './definitions';
+
+export interface TankParameters {
+  resourcesPath: {
+    smallIconPath: string;
+    bigIconPath: string;
+    blitzModelPath: string;
+  };
+  collision: {
+    [key: string]: {
+      points: Vector3Tuple;
+      bbox: {
+        min: Vector3Tuple;
+        max: Vector3Tuple;
+      };
+      averageThickness?: Record<string, number>;
+    };
+  };
+  maskSlice?: {
+    [key: string]:
+      | {
+          enabled: boolean;
+          planePosition: Vector3Tuple;
+          planeNormal: Vector3Tuple;
+          planeAxis: Vector3Tuple;
+          frustumConeBaseRadius: number;
+          frustumConeAngleDegrees: number;
+          planeSliceMode: number;
+          frustumConeSliceMode: number;
+        }
+      | undefined;
+  };
+}
+
+export async function tankIcons() {
+  console.log('Building tank icons...');
+
+  const changes: FileChange[] = [];
+  const nations = await readdir(`${DATA}/XML/item_defs/vehicles`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+
+  await Promise.all(
+    nations.map(async (nation) => {
+      const tanks = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+        `${DATA}/XML/item_defs/vehicles/${nation}/list.xml.dvpl`,
+      );
+
+      await Promise.all(
+        Object.entries(tanks.root).map(async ([tankKey, tank]) => {
+          if (tankKey.includes('tutorial_bot')) return;
+
+          const nationVehicleId = tank.id;
+          const id = (nationVehicleId << 8) + (NATION_IDS[nation] << 4) + 1;
+          const parameters = await readYAMLDVPL<TankParameters>(
+            `${DATA}/3d/Tanks/Parameters/${nation}/${tankKey}.yaml.dvpl`,
+          );
+          const smallPath = `${DATA}/${parameters.resourcesPath.smallIconPath
+            .replace(/~res:\//, '')
+            .replace(/\..+/, '')}.packed.webp.dvpl`;
+          const bigPath = `${DATA}/${parameters.resourcesPath.bigIconPath
+            .replace(/~res:\//, '')
+            .replace(/\..+/, '')}.packed.webp.dvpl`;
+          const big = await sharp(await readDVPLFile(bigPath))
+            .trim()
+            .toBuffer();
+          const small = await sharp(await readDVPLFile(smallPath))
+            .trim()
+            .toBuffer();
+
+          if (big) {
+            changes.push({
+              content: big.toString('base64'),
+              encoding: 'base64',
+              path: `icons/tanks/big/${id}.webp`,
+            });
+          }
+          if (small) {
+            changes.push({
+              content: small.toString('base64'),
+              encoding: 'base64',
+              path: `icons/tanks/small/${id}.webp`,
+            });
+          }
+        }),
+      );
+    }),
+  );
+
+  await commitAssets('tank icons', changes);
+}

packages/scripts/src/buildAssets/tankModels.ts

@@ -0,0 +1,55 @@
+import { NodeIO } from '@gltf-transform/core';
+import { readdir } from 'fs/promises';
+import { extractModel } from '../../src/core/blitz/extractModel';
+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/blitzkit/commitAssets';
+import { FileChange } from '../../src/core/blitzkit/commitMultipleFiles';
+import { DATA } from './constants';
+import { VehicleDefinitionList } from './definitions';
+import { TankParameters } from './tankIcons';
+
+export async function tankModels() {
+  console.log('Building tank models...');
+
+  const nodeIO = new NodeIO();
+  const nations = await readdir(`${DATA}/XML/item_defs/vehicles`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+
+  for (const nationIndex in nations) {
+    const nation = nations[nationIndex];
+    const changes: FileChange[] = [];
+    const tanks = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+      `${DATA}/XML/item_defs/vehicles/${nation}/list.xml.dvpl`,
+    );
+
+    console.log(`Building models for ${nation}`);
+
+    await Promise.all(
+      Object.entries(tanks.root).map(async ([tankKey, tank]) => {
+        if (tankKey.includes('tutorial_bot')) return;
+
+        const id = toUniqueId(nation, tank.id);
+        const parameters = await readYAMLDVPL<TankParameters>(
+          `${DATA}/3d/Tanks/Parameters/${nation}/${tankKey}.yaml.dvpl`,
+        );
+        const model = await extractModel(
+          DATA,
+          parameters.resourcesPath.blitzModelPath.replace(/\.sc2$/, ''),
+        );
+
+        changes.push({
+          path: `3d/tanks/models/${id}.glb`,
+          content: Buffer.from(await nodeIO.writeBinary(model)).toString(
+            'base64',
+          ),
+          encoding: 'base64',
+        });
+      }),
+    );
+
+    await commitAssets(`tank models ${nation}`, changes);
+  }
+}