Merge branch 'main' into pr/Hitjack007/378-2

packages/core/src/blitzkit/api/server/0_base.ts

@@ -246,6 +246,27 @@ export abstract class ServerBlitzKitAPI0 extends BlitzKitAPI {
     return this;
   }
 
+  protected getTankFilterIds(
+    name: string,
+    definitionKey: string,
+    filter: "include" | "exclude",
+  ) {
+    const keys = name.trim().split(/\s+/).filter(Boolean);
+
+    return keys.flatMap((key) => {
+      const id = this.tankStringIdMap[key];
+
+      if (id === undefined) {
+        console.warn(
+          `Skipping unavailable tank "${key}" in ${filter} vehicle filter for "${definitionKey}"`,
+        );
+        return [];
+      }
+
+      return [id];
+    });
+  }
+
   protected getString(name: string) {
     const collection: Record<string, string> = {
       [locales.default]: this.stringsI18n[locales.default][name],
@@ -264,6 +285,8 @@ export abstract class ServerBlitzKitAPI0 extends BlitzKitAPI {
       collection[locale] = localizedString;
     }
 
+    collection[locales.default] = collection[locales.default] ?? name;
+
     return { locales: collection } satisfies I18nString;
   }
 }

packages/core/src/blitzkit/api/server/1_tankDefinitions.ts

@@ -387,7 +387,7 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
               : TankType.TANK_TYPE_RESEARCHABLE,
           tier: tank.level,
           class: tankClass,
-          testing: tankTags.includes("testTank"),
+          testing: tankTags.includes("testTank") || tank.level === 11,
           deprecated: tankTags.includes("deprecated"),
           price: tankPrice,
           camouflage_still: tankDefinition.root.invisibility.still,
@@ -595,9 +595,25 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
             for (const shellKey in gunListEntry.shots) {
               const gunShellEntry = gunListEntry.shots[shellKey];
               const shell = shellList.root[shellKey];
+
+              // Newer client data stores shot properties on the shell rather
+              // than repeating them under every gun's <shots> entry.
+              const speed =
+                typeof gunShellEntry === "string"
+                  ? shell.speed
+                  : gunShellEntry.speed;
+              const maxDistance =
+                typeof gunShellEntry === "string"
+                  ? shell.maxDistance
+                  : gunShellEntry.maxDistance;
+              const piercingPower =
+                typeof gunShellEntry === "string"
+                  ? shell.piercingPower
+                  : gunShellEntry.piercingPower;
+
               const shellId = toUniqueId(nation, shell.id);
               const shellName = this.getString(shell.userString);
-              const penetrationRaw = gunShellEntry.piercingPower
+              const penetrationRaw = piercingPower
                 .split(" ")
                 .filter((penetrationString) => penetrationString !== "")
                 .map(Number);
@@ -607,7 +623,7 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
               ].shells.push({
                 id: shellId,
                 name: shellName,
-                velocity: gunShellEntry.speed,
+                velocity: speed,
                 armor_damage: shell.damage.armor,
                 module_damage: shell.damage.devices,
                 caliber: shell.caliber,
@@ -623,7 +639,7 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
                   near: penetrationRaw[0],
                   far: penetrationRaw[1],
                 },
-                range: gunShellEntry.maxDistance,
+                range: maxDistance,
               });
             }
 

packages/core/src/blitzkit/api/server/2_camouflageDefinitions.ts

@@ -1,15 +1,60 @@
-import { CamouflageDefinitions } from "@blitzkit/core";
+import {
+  CamouflageDefinitions,
+  Sc2ReadStream,
+  type TankParameters,
+} from "@blitzkit/core";
+import { isEqual, times } from "lodash-es";
 import { Cache } from "./0_base";
 import { ServerBlitzKitAPI1 } from "./1_tankDefinitions";
 
 export abstract class ServerBlitzKitAPI2 extends ServerBlitzKitAPI1 {
+  private async skinPresets(vehicle: string) {
+    const [nation, tankKey] = vehicle.split(":");
+    const parameters = await this.vfs.yaml<TankParameters>(
+      `Data/3d/Tanks/Parameters/${nation}/${tankKey}.yaml`,
+    );
+    const sc2 = new Sc2ReadStream(
+      (
+        await this.vfs.file(
+          `Data/3d/${parameters.resourcesPath.blitzModelPath}`,
+        )
+      ).buffer as ArrayBuffer,
+    ).sc2();
+    const presets = new Set<string>();
+
+    for (const node of sc2["#dataNodes"]) {
+      if (typeof node.configCount !== "number") continue;
+
+      times(node.configCount, (index) => node[`configArchive_${index}`])
+        .filter(
+          (archive) =>
+            !isEqual(archive.textures, node.configArchive_0.textures),
+        )
+        .forEach((archive) => presets.add(archive.configName));
+    }
+
+    return presets;
+  }
+
   @Cache()
   async camouflageDefinitions() {
     const camouflageDefinitions = CamouflageDefinitions.create();
+    const customization = await this.vfs.yaml<
+      Record<string, { Name: string; Path: string }>
+    >("Data/3d/Customization.yaml");
+    const items = new Map(
+      Object.values(customization).map(({ Name, Path }) => [
+        Name,
+        Path.replace("~res:/", "Data/").replace(/\.sc2$/, ""),
+      ]),
+    );
+    const skinPresets = new Map<string, Promise<Set<string>>>();
 
     for (const camoKey in this.camouflagesXml!.root.camouflages) {
       const camo = this.camouflagesXml!.root.camouflages[camoKey];
 
+      if (!(camoKey in this.camouflagesYaml!)) continue;
+
       const yamlEntry = this.camouflagesYaml![camoKey];
       const fullName = yamlEntry.userString
         ? this.getString(yamlEntry.userString)
@@ -20,12 +65,57 @@ export abstract class ServerBlitzKitAPI2 extends ServerBlitzKitAPI1 {
       const resolvedTankName = shortName ?? fullName;
       const resolvedTankNameFull =
         resolvedTankName === fullName ? undefined : fullName;
+      const include = camo.vehicleFilter.include;
+      const vehicle =
+        include && !Array.isArray(include) && "vehicle" in include
+          ? include.vehicle?.name
+          : undefined;
+      let tankId: number | undefined = undefined;
+
+      if (vehicle && vehicle in this.tankStringIdMap) {
+        const resolvedParts = await Promise.all(
+          Object.values(yamlEntry.customEntities ?? {}).map(
+            async ({ item }) => {
+              const path = items.get(item);
+
+              return (
+                path !== undefined &&
+                (await this.vfs.resolve(`${path}.sc2`)) &&
+                (await this.vfs.resolve(`${path}.scg`))
+              );
+            },
+          ),
+        );
+
+        const [nation, tankKey] = vehicle.split(":");
+        // some unique camos only set the preset for their one tank
+        const preset =
+          yamlEntry.preset ??
+          yamlEntry.override?.[nation]?.override?.[tankKey]?.preset;
+        let hasPreset = false;
+
+        if (preset !== undefined) {
+          if (!skinPresets.has(vehicle)) {
+            skinPresets.set(vehicle, this.skinPresets(vehicle));
+          }
+
+          hasPreset = (await skinPresets.get(vehicle)!).has(preset);
+        }
+
+        if (resolvedParts.some(Boolean) || hasPreset) {
+          tankId = this.tankStringIdMap[vehicle];
+        }
+      }
+
+      const name = this.getString(camo.userString);
 
       camouflageDefinitions.camouflages[camo.id] = {
         id: camo.id,
-        name: this.getString(camo.userString),
+        name,
         tank_name: resolvedTankName,
         tank_name_full: resolvedTankNameFull,
+        tank_id: tankId,
+        attachment: camo.kind === "customization",
       };
     }
 

packages/core/src/blitzkit/api/server/3_modelDefinitions.ts

@@ -4,7 +4,13 @@ import {
   ChassisDefinitionsList,
   Crew,
   GunDefinitionsList,
+  I_HAT,
+  J_HAT,
+  K_HAT,
   ModelDefinitions,
+  parseHierarchies,
+  Sc2ReadStream,
+  ScgReadStream,
   TankParameters,
   toUniqueId,
   TurretDefinitionsList,
@@ -12,9 +18,10 @@ import {
   VehicleDefinitionArmor,
   VehicleDefinitionList,
   VehicleDefinitions,
+  VertexAttribute,
 } from "@blitzkit/core";
 import { parse as parsePath } from "path";
-import { Vector3Tuple } from "three";
+import { MathUtils, Vector3 as THREEVector3, Vector3Tuple } from "three";
 import { Cache } from "./0_base";
 import { ServerBlitzKitAPI2 } from "./2_camouflageDefinitions";
 
@@ -23,6 +30,87 @@ export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
     return { x: tuple[0], y: tuple[1], z: tuple[2] } satisfies Vector3;
   }
 
+  private async collisionBoundingBoxes(
+    nation: string,
+    tankKey: string,
+    turretRotation?: { yaw: number; pitch: number; roll: number },
+  ) {
+    const boundingBoxes: Record<
+      string,
+      { min: Vector3Tuple; max: Vector3Tuple }
+    > = {};
+    const path = `Data/3d/Tanks/CollisionMeshes/${nation}-${tankKey}`;
+
+    if (!(await this.vfs.resolve(`${path}.sc2`))) {
+      throw new Error(`Missing collision mesh for ${nation}-${tankKey}`);
+    }
+
+    const sc2 = new Sc2ReadStream(
+      (await this.vfs.file(`${path}.sc2`)).buffer as ArrayBuffer,
+    ).sc2();
+    const scg = new ScgReadStream(
+      (await this.vfs.file(`${path}.scg`)).buffer as ArrayBuffer,
+    ).scg();
+
+    parseHierarchies(sc2["#hierarchy"], null, (hierarchy, components) => {
+      for (const component of components) {
+        if (component["comp.typename"] !== "RenderComponent") continue;
+
+        const polygonGroup = scg.get(
+          component["rc.renderObj"]["ro.batches"]["0000"]["rb.datasource"],
+        );
+
+        if (!polygonGroup) continue;
+
+        const min: Vector3Tuple = [Infinity, Infinity, Infinity];
+        const max: Vector3Tuple = [-Infinity, -Infinity, -Infinity];
+        const rotate =
+          turretRotation && hierarchy.name.toLowerCase().startsWith("turret");
+
+        polygonGroup.vertices.forEach((vertex) => {
+          vertex.forEach(({ attribute, value }) => {
+            if (attribute !== VertexAttribute.VERTEX) return;
+
+            const position = new THREEVector3(...value);
+
+            if (rotate) {
+              position
+                .applyAxisAngle(
+                  I_HAT,
+                  -MathUtils.degToRad(turretRotation.pitch),
+                )
+                .applyAxisAngle(
+                  J_HAT,
+                  -MathUtils.degToRad(turretRotation.roll),
+                )
+                .applyAxisAngle(
+                  K_HAT,
+                  -MathUtils.degToRad(turretRotation.yaw),
+                );
+            }
+
+            const coordinates = position.toArray();
+
+            for (let axis = 0; axis < 3; axis++) {
+              min[axis] = Math.min(min[axis], coordinates[axis]);
+              max[axis] = Math.max(max[axis], coordinates[axis]);
+            }
+          });
+        });
+
+        boundingBoxes[hierarchy.name.toLowerCase()] = { min, max };
+      }
+
+      return null;
+    });
+
+    if (!boundingBoxes.hull) {
+      throw new Error(`Missing hull collision mesh for ${nation}-${tankKey}`);
+    }
+
+    return boundingBoxes;
+  }
+
   private assignArmor(
     raw: VehicleDefinitionArmor[string],
     id: number,
@@ -67,6 +155,12 @@ export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
         const tankParameters = await this.vfs.yaml<TankParameters>(
           `Data/3d/Tanks/Parameters/${nation}/${tankKey}.yaml`,
         );
+        const collisionBoundingBoxes = await this.collisionBoundingBoxes(
+          nation,
+          tankKey,
+          tankDefinition.root.hull.turretInitialRotation,
+        );
+        const hullBoundingBox = collisionBoundingBoxes.hull;
         const turretOrigin = tankDefinition.root.hull.turretPositions.turret
           .split(" ")
           .map(Number) as Vector3Tuple;
@@ -141,12 +235,8 @@ export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
               }
             : undefined,
           bounding_box: {
-            min: this.vector3TupleToBlitzkit(
-              tankParameters.collision.hull.bbox.min,
-            ),
-            max: this.vector3TupleToBlitzkit(
-              tankParameters.collision.hull.bbox.max,
-            ),
+            min: this.vector3TupleToBlitzkit(hullBoundingBox.min),
+            max: this.vector3TupleToBlitzkit(hullBoundingBox.max),
           },
           turrets: {},
           tracks: {},
@@ -208,26 +298,35 @@ export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
 
           turret.userString;
 
+          const turretCollisionName = parsePath(
+            turret.hitTester.collisionModel,
+          ).name.toLowerCase();
+          const isFullYaw = -turretYaw[0] + turretYaw[1] === 360;
+
+          if (!collisionBoundingBoxes[turretCollisionName] && isFullYaw) {
+            throw new Error(
+              `Missing turret collision mesh for ${nation}-${tankKey} ${turretKey}`,
+            );
+          }
+
+          const turretBoundingBox = collisionBoundingBoxes[
+            turretCollisionName
+          ] ?? {
+            min: [0, 0, 0] as Vector3Tuple,
+            max: [0, 0, 0] as Vector3Tuple,
+          };
+
           modelDefinitions.models[tankId].turrets[turretId] = {
             armor: turretArmor,
             gun_origin: this.vector3TupleToBlitzkit(gunOrigin),
             model_id: turretModel,
-            yaw:
-              -turretYaw[0] + turretYaw[1] === 360
-                ? undefined
-                : { min: turretYaw[0], max: turretYaw[1] },
+            yaw: isFullYaw
+              ? undefined
+              : { min: turretYaw[0], max: turretYaw[1] },
             guns: {},
             bounding_box: {
-              min: this.vector3TupleToBlitzkit(
-                tankParameters.collision[
-                  parsePath(turret.hitTester.collisionModel).name.toLowerCase()
-                ].bbox.min,
-              ),
-              max: this.vector3TupleToBlitzkit(
-                tankParameters.collision[
-                  parsePath(turret.hitTester.collisionModel).name.toLowerCase()
-                ].bbox.max,
-              ),
+              min: this.vector3TupleToBlitzkit(turretBoundingBox.min),
+              max: this.vector3TupleToBlitzkit(turretBoundingBox.max),
             },
           };
 

packages/core/src/blitzkit/api/server/6_consumableDefinitions.ts

@@ -44,9 +44,7 @@ export abstract class ServerBlitzKitAPI6 extends ServerBlitzKitAPI5 {
             filter_type: {
               $case: "ids",
               value: {
-                ids: includeRaw.name.split(/ +/).map((key) => {
-                  return this.tankStringIdMap[key];
-                }),
+                ids: this.getTankFilterIds(includeRaw.name, key, "include"),
               },
             },
           });
@@ -72,9 +70,7 @@ export abstract class ServerBlitzKitAPI6 extends ServerBlitzKitAPI5 {
             filter_type: {
               $case: "ids",
               value: {
-                ids: excludeRaw.name.split(/ +/).map((key) => {
-                  return this.tankStringIdMap[key];
-                }),
+                ids: this.getTankFilterIds(excludeRaw.name, key, "exclude"),
               },
             },
           });

packages/core/src/blitzkit/api/server/7_provisionDefinitions.ts

@@ -11,7 +11,7 @@ export abstract class ServerBlitzKitAPI7 extends ServerBlitzKitAPI6 {
   async provisionDefinitions() {
     const provisionDefinitions = ProvisionDefinitions.create();
 
-    Object.entries(this.provisionsCommon).forEach(([, provision]) => {
+    Object.entries(this.provisionsCommon).forEach(([key, provision]) => {
       const entry: Provision = {
         id: provision.id,
         exclude: [],
@@ -42,9 +42,7 @@ export abstract class ServerBlitzKitAPI7 extends ServerBlitzKitAPI6 {
             filter_type: {
               $case: "ids",
               value: {
-                ids: includeRaw.name.split(/ +/).map((key) => {
-                  return this.tankStringIdMap[key];
-                }),
+                ids: this.getTankFilterIds(includeRaw.name, key, "include"),
               },
             },
           });
@@ -70,9 +68,7 @@ export abstract class ServerBlitzKitAPI7 extends ServerBlitzKitAPI6 {
             filter_type: {
               $case: "ids",
               value: {
-                ids: excludeRaw.name
-                  .split(/ +/)
-                  .map((key) => this.tankStringIdMap[key]),
+                ids: this.getTankFilterIds(excludeRaw.name, key, "exclude"),
               },
             },
           });

packages/core/src/blitzkit/index.ts

@@ -25,6 +25,7 @@ export * from "./sluggify";
 export * from "./staticAsset";
 export * from "./sum";
 export * from "./tankDefinitions";
+export * from "./tankBoundingBox";
 export * from "./tankIcon";
 export * from "./tankNames";
 export * from "./unionBoundingBox";

packages/core/src/blitzkit/tankBoundingBox.ts

@@ -0,0 +1,32 @@
+import { ModelDefinition, TurretModelDefinition } from "../protos";
+import { unionBoundingBox } from "./unionBoundingBox";
+
+export function tankBoundingBox(
+  tankModelDefinition: ModelDefinition,
+  turretModelDefinition: TurretModelDefinition,
+) {
+  const hull = tankModelDefinition.bounding_box!;
+  const turret = turretModelDefinition.bounding_box!;
+  const origin = tankModelDefinition.turret_origin!;
+
+  if (
+    turret.min!.x === turret.max!.x &&
+    turret.min!.y === turret.max!.y &&
+    turret.min!.z === turret.max!.z
+  ) {
+    return unionBoundingBox(hull, hull);
+  }
+
+  return unionBoundingBox(hull, {
+    min: {
+      x: turret.min!.x + origin.x,
+      y: turret.min!.y + origin.z,
+      z: turret.min!.z + origin.y,
+    },
+    max: {
+      x: turret.max!.x + origin.x,
+      y: turret.max!.y + origin.z,
+      z: turret.max!.z + origin.y,
+    },
+  });
+}

packages/core/src/blitzkit/tankDefinitions/constants.ts

@@ -1,5 +1,5 @@
 import { times } from "lodash-es";
-import { CrewType, ShellType, TankClass, TankType } from "../../protos";
+import { CrewType, ShellType } from "../../protos";
 
 export const SHELL_NAMES: Record<ShellType, string> = {
   [ShellType.SHELL_TYPE_AP]: "AP",
@@ -15,33 +15,6 @@ export const CREW_MEMBER_NAMES = {
   [CrewType.CREW_TYPE_RADIOMAN]: "radioman",
 } as const;
 
-/**
- * @deprecated use svg
- */
-export const TANK_ICONS: Record<TankClass, string> = {
-  [TankClass.TANK_CLASS_TANK_DESTROYER]: "https://i.imgur.com/BIHSEH0.png",
-  [TankClass.TANK_CLASS_LIGHT]: "https://i.imgur.com/CSNha5V.png",
-  [TankClass.TANK_CLASS_MEDIUM]: "https://i.imgur.com/wvf3ltm.png",
-  [TankClass.TANK_CLASS_HEAVY]: "https://i.imgur.com/ECeqlZa.png",
-};
-/**
- * @deprecated use svg
- */
-export const TANK_ICONS_PREMIUM: Record<TankClass, string> = {
-  [TankClass.TANK_CLASS_TANK_DESTROYER]: "https://i.imgur.com/TCu3EdR.png",
-  [TankClass.TANK_CLASS_LIGHT]: "https://i.imgur.com/zdkpTRb.png",
-  [TankClass.TANK_CLASS_MEDIUM]: "https://i.imgur.com/3z7eHX6.png",
-  [TankClass.TANK_CLASS_HEAVY]: "https://i.imgur.com/P3vbmyA.png",
-};
-/**
- * @deprecated use svg
- */
-export const TANK_ICONS_COLLECTOR: Record<TankClass, string> = {
-  [TankClass.TANK_CLASS_TANK_DESTROYER]: "https://i.imgur.com/WTjeirB.png",
-  [TankClass.TANK_CLASS_LIGHT]: "https://i.imgur.com/EwhtKkU.png",
-  [TankClass.TANK_CLASS_MEDIUM]: "https://i.imgur.com/u8YDMBh.png",
-  [TankClass.TANK_CLASS_HEAVY]: "https://i.imgur.com/8xRf3nc.png",
-};
 export const TIERS = times(10, (index) => index + 1);
 export const TIER_ROMAN_NUMERALS: Record<number, string> = {
   1: "I",
@@ -68,8 +41,3 @@ export const flags: Record<string, string> = {
   european: "🇪🇺",
   other: "<:other:1218421572243558482>",
 };
-export const TREE_TYPE_ICONS: Record<TankType, Record<TankClass, string>> = {
-  [TankType.TANK_TYPE_RESEARCHABLE]: TANK_ICONS,
-  [TankType.TANK_TYPE_PREMIUM]: TANK_ICONS_PREMIUM,
-  [TankType.TANK_TYPE_COLLECTOR]: TANK_ICONS_COLLECTOR,
-};

packages/core/src/imgur/imgur.ts

@@ -1,50 +0,0 @@
-export enum ImgurSize {
-  /**
-   * The default size
-   */
-  Default = '',
-  /**
-   * Unknown size but really really small
-   */
-  UltraSmall = 'ss',
-  /**
-   * 90x90
-   */
-  SmallSquare = 's',
-  /**
-   * 160x160
-   */
-  BigSquare = 'b',
-  /**
-   * 160x160
-   */
-  SmallThumbnail = 't',
-  /**
-   * 320x320
-   */
-  MediumThumbnail = 'm',
-  /**
-   * 640x640
-   */
-  LargeThumbnail = 'l',
-  /**
-   * 1024x1024
-   */
-  HugeThumbnail = 'h',
-}
-
-interface ImgurOptions {
-  format: 'jpeg' | 'png';
-  size: ImgurSize;
-}
-
-const defaultImgurOptions: ImgurOptions = {
-  format: 'png',
-  size: ImgurSize.Default,
-};
-
-export function imgur(id: string, imgurOptions?: Partial<ImgurOptions>) {
-  const options = { ...defaultImgurOptions, ...imgurOptions };
-
-  return `https://i.imgur.com/${id}${options.size}.${options.format}`;
-}

packages/core/src/imgur/index.ts

@@ -1 +0,0 @@
-export * from './imgur';

packages/core/src/index.ts

@@ -1,6 +1,5 @@
 export * from "./blitz";
 export * from "./blitzkit";
-export * from "./imgur";
 export * from "./math";
 export * from "./patreon";
 export * from "./protobuf";

packages/core/src/protos/camouflage_definitions.proto

@@ -13,4 +13,6 @@ message Camouflage {
   required I18nString name           = 2;
   optional I18nString tank_name      = 3;
   optional I18nString tank_name_full = 4;
+  optional uint32     tank_id        = 5;
+  optional bool       attachment     = 6;
 }

packages/core/src/protos/camouflage_definitions.ts

@@ -24,6 +24,8 @@ export interface Camouflage {
   name: I18nString | undefined;
   tank_name?: I18nString | undefined;
   tank_name_full?: I18nString | undefined;
+  tank_id?: number | undefined;
+  attachment?: boolean | undefined;
 }
 
 function createBaseCamouflageDefinitions(): CamouflageDefinitions {
@@ -191,7 +193,7 @@ export const CamouflageDefinitions_CamouflagesEntry: MessageFns<CamouflageDefini
 };
 
 function createBaseCamouflage(): Camouflage {
-  return { id: 0, name: undefined, tank_name: undefined, tank_name_full: undefined };
+  return { id: 0, name: undefined, tank_name: undefined, tank_name_full: undefined, tank_id: 0, attachment: false };
 }
 
 export const Camouflage: MessageFns<Camouflage> = {
@@ -208,6 +210,12 @@ export const Camouflage: MessageFns<Camouflage> = {
     if (message.tank_name_full !== undefined) {
       I18nString.encode(message.tank_name_full, writer.uint32(34).fork()).join();
     }
+    if (message.tank_id !== undefined && message.tank_id !== 0) {
+      writer.uint32(40).uint32(message.tank_id);
+    }
+    if (message.attachment !== undefined && message.attachment !== false) {
+      writer.uint32(48).bool(message.attachment);
+    }
     return writer;
   },
 
@@ -250,6 +258,22 @@ export const Camouflage: MessageFns<Camouflage> = {
           message.tank_name_full = I18nString.decode(reader, reader.uint32());
           continue;
         }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.tank_id = reader.uint32();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.attachment = reader.bool();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -265,6 +289,8 @@ export const Camouflage: MessageFns<Camouflage> = {
       name: isSet(object.name) ? I18nString.fromJSON(object.name) : undefined,
       tank_name: isSet(object.tank_name) ? I18nString.fromJSON(object.tank_name) : undefined,
       tank_name_full: isSet(object.tank_name_full) ? I18nString.fromJSON(object.tank_name_full) : undefined,
+      tank_id: isSet(object.tank_id) ? globalThis.Number(object.tank_id) : 0,
+      attachment: isSet(object.attachment) ? globalThis.Boolean(object.attachment) : false,
     };
   },
 
@@ -282,6 +308,12 @@ export const Camouflage: MessageFns<Camouflage> = {
     if (message.tank_name_full !== undefined) {
       obj.tank_name_full = I18nString.toJSON(message.tank_name_full);
     }
+    if (message.tank_id !== undefined && message.tank_id !== 0) {
+      obj.tank_id = Math.round(message.tank_id);
+    }
+    if (message.attachment !== undefined && message.attachment !== false) {
+      obj.attachment = message.attachment;
+    }
     return obj;
   },
 
@@ -300,6 +332,8 @@ export const Camouflage: MessageFns<Camouflage> = {
     message.tank_name_full = (object.tank_name_full !== undefined && object.tank_name_full !== null)
       ? I18nString.fromPartial(object.tank_name_full)
       : undefined;
+    message.tank_id = object.tank_id ?? 0;
+    message.attachment = object.attachment ?? false;
     return message;
   },
 };

packages/core/src/streams/pvr.ts

@@ -88,6 +88,7 @@ enum PvrChannelType {
 
 enum ResolvedBitRatePixelFormat {
   R4G4B4A4,
+  R8G8B8A8,
   R5G6B5A0,
 }
 
@@ -137,6 +138,27 @@ export class PvrReadStream extends ReadStream {
           };
         }
 
+        case ResolvedBitRatePixelFormat.R8G8B8A8: {
+          const data = Buffer.alloc(pixelCount * 4);
+
+          times(pixelCount, (index) => {
+            const buffer = this.consumeUint8Array(4);
+            const bufferIndex = index * 4;
+
+            data[bufferIndex] = buffer[0]; // R
+            data[bufferIndex + 1] = buffer[1]; // G
+            data[bufferIndex + 2] = buffer[2]; // B
+            data[bufferIndex + 3] = buffer[3]; // A
+          });
+
+          return {
+            data,
+            width: header.width,
+            height: header.height,
+            channels: 4 as const,
+          };
+        }
+
         case ResolvedBitRatePixelFormat.R5G6B5A0: {
           const data = Buffer.alloc(pixelCount * 3);
 
@@ -208,10 +230,13 @@ export class PvrReadStream extends ReadStream {
     if (pixelFormat.order === "rgba") {
       if (isEqual(pixelFormat.bitRates, [4, 4, 4, 4])) {
         return ResolvedBitRatePixelFormat.R4G4B4A4;
-      } else
+      } else if (isEqual(pixelFormat.bitRates, [8, 8, 8, 8])) {
+        return ResolvedBitRatePixelFormat.R8G8B8A8;
+      } else {
         throw new TypeError(
           `Unhandled rgba bit rate ${pixelFormat.bitRates.join(", ")}`,
         );
+      }
     } else if (pixelFormat.order === "rgb\0") {
       if (isEqual(pixelFormat.bitRates, [5, 6, 5, 0])) {
         return ResolvedBitRatePixelFormat.R5G6B5A0;

packages/core/src/streams/sc2.ts

@@ -40,6 +40,8 @@ export interface ConfigArchive {
 
 interface EnabledPresets {
   AlphaTest: boolean;
+  AlphaBlend?: boolean;
+  AlphaBlendAdditive?: boolean;
 }
 
 interface Flags {
@@ -90,6 +92,28 @@ export interface Hierarchy {
   name: string;
 }
 
+export function parseHierarchies<Parent>(
+  hierarchies: Hierarchy[],
+  parent: Parent,
+  parseHierarchy: (
+    hierarchy: Hierarchy,
+    components: Component[],
+    parent: Parent,
+  ) => Parent | undefined,
+) {
+  for (const hierarchy of hierarchies) {
+    const components = Array.from(
+      { length: hierarchy.components.count },
+      (_, index) => hierarchy.components[index.toString().padStart(4, "0")],
+    );
+    const child = parseHierarchy(hierarchy, components, parent);
+
+    if (child !== undefined && hierarchy["#hierarchy"]) {
+      parseHierarchies(hierarchy["#hierarchy"], child, parseHierarchy);
+    }
+  }
+}
+
 // 0001, 0002, 0003...: Component
 type Components = {
   count: number;

packages/core/src/types/camouflagesYaml.ts

@@ -3,5 +3,12 @@ export type CamouflagesYaml = Record<
   {
     userString?: string;
     shortUserString?: string;
+    preset?: string;
+    customEntities?: Record<string, { item: string }>;
+    // nation -> tank
+    override?: Record<
+      string,
+      { override?: Record<string, { preset?: string }> }
+    >;
   }
 >;

packages/core/src/types/gunDefinitionsList.ts

@@ -20,11 +20,13 @@ export interface GunDefinitionsList {
       burst?: { count: number; rate: number };
       clip?: { count: number; rate: number };
       shots: {
-        [key: string]: {
-          speed: number;
-          piercingPower: string;
-          maxDistance: number;
-        };
+        [key: string]:
+          | ""
+          | {
+              speed: number;
+              piercingPower: string;
+              maxDistance: number;
+            };
       };
     };
   };

packages/core/src/types/shellDefinitionsList.ts

@@ -10,6 +10,9 @@ export type ShellDefinitionsList = Record<
     normalizationAngle?: number;
     ricochetAngle?: number;
     explosionRadius?: number;
+    speed: number;
+    maxDistance?: number;
+    piercingPower: string;
   }
 > & {
   icons: Record<string, string>;

packages/i18n/strings/en.json

@@ -1,10 +1,4 @@
 {
-  "test": {
-    "default": "test",
-    "long": "This is a long test string. You MUST NEVER see this in the UI. My favorite fruit is {fruit} because it has the color of {color}. I like it so much that I will say its name 3 times! {fruit}! {fruit}! {fruit}! Once again, it's {color}, not {not_color}.",
-    "fox": "The quick brown fox jumps over the lazy dog."
-  },
-
   "common": {
     "name": "BlitzKit",
 
@@ -44,7 +38,7 @@
 
     "branches": {
       "beta": "Beta",
-      "development": "Development",
+      "development": "Post Malone Edition",
       "opentest": "OpenTest",
       "preview": "Preview",
       "production": "Production"
@@ -338,6 +332,13 @@
     },
 
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
+
       "playlist": {
         "reset": "Reset",
         "shuffle": "Shuffle",
@@ -993,11 +994,10 @@
 
     "footer": {
       "motto": "Everything World of Tanks Blitz",
-      "copyright": "Unaffiliated with Wargaming or any service",
+      "association": "An Open Collective Project",
 
       "about": {
         "title": "About",
-        "credits": "Credits",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Patches"

packages/i18n/strings/es.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "test",
-    "long": "This is a long test string. You MUST NEVER see this in the UI. My favorite fruit is {fruit} because it has the color of {color}. I like it so much that I will say its name 3 times! {fruit}! {fruit}! {fruit}! Once again, it's {color}, not {not_color}.",
-    "fox": "El rápido zorro marrón salta sobre el perro perezoso."
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "Restablecer",
         "shuffle": "Shuffle",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "Suave",
             "health": "Salud",
             "fireChance": "Probabilidad de incendio",
+            "trackRepairTime": "Track repair time",
             "viewRange": "Rango de visión",
             "camouflageStill": "Quieto",
             "camouflageMoving": "En movimiento",
@@ -921,7 +923,6 @@
       "copyright": "No afiliado con Wargaming u otros servicios",
       "about": {
         "title": "About",
-        "credits": "Credits",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Parches"

packages/i18n/strings/fr.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "teste",
-    "long": "Ceci est une longue chaîne de test. Vous ne DEVEZ JAMAIS le voir dans l'interface utilisateur. Mon fruit préféré est {fruit}, car il a la couleur {color}. Je l'aime tellement que je vais dire son nom 3 fois ! {fruit}! {fruit}! {fruit} ! Encore une fois, c'est {color}, pas {not_color}.",
-    "fox": "Le renard brun et rapide saute par-dessus le chien paresseux."
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "Reset",
         "shuffle": "Shuffle",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "Soft",
             "health": "Health",
             "fireChance": "Fire chance",
+            "trackRepairTime": "Track repair time",
             "viewRange": "View range",
             "camouflageStill": "Still",
             "camouflageMoving": "Moving",
@@ -921,7 +923,6 @@
       "copyright": "Unaffiliated with Wargaming or any service",
       "about": {
         "title": "About",
-        "credits": "Credits",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Patches"

packages/i18n/strings/ja.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "test",
-    "long": "This is a long test string. You MUST NEVER see this in the UI. My favorite fruit is {fruit} because it has the color of {color}. I like it so much that I will say its name 3 times! {fruit}! {fruit}! {fruit}! Once again, it's {color}, not {not_color}.",
-    "fox": "すばしっこい茶色のキツネが怠け者の犬を飛び越した。"
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "リセット",
         "shuffle": "Shuffle",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "軟弱地",
             "health": "耐久値",
             "fireChance": "火災発生率",
+            "trackRepairTime": "Track repair time",
             "viewRange": "視認範囲",
             "camouflageStill": "静止時",
             "camouflageMoving": "移動時",
@@ -921,7 +923,6 @@
       "copyright": "Wargamingやその他のサービスとは関係ありません",
       "about": {
         "title": "概要",
-        "credits": "クレジット",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "パッチノート"

packages/i18n/strings/pl.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "test",
-    "long": "This is a long test string. You MUST NEVER see this in the UI. My favorite fruit is {fruit} because it has the color of {color}. I like it so much that I will say its name 3 times! {fruit}! {fruit}! {fruit}! Once again, it's {color}, not {not_color}.",
-    "fox": "Szybki brązowy lis przeskoczył nad leniwym psem."
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -19,7 +14,7 @@
     "gun_types": {
       "auto_loader": "Samo ładowacz",
       "auto_reloader": "Automatyczne przeładowanie",
-      "regular": "Regular"
+      "regular": "Regularny"
     },
     "shells": {
       "ap": "AP",
@@ -38,10 +33,10 @@
     },
     "branches": {
       "beta": "Beta",
-      "development": "Development",
-      "opentest": "OpenTest",
-      "preview": "Preview",
-      "production": "Production"
+      "development": "Rozwój",
+      "opentest": "OtwartyTest",
+      "preview": "Przegląd",
+      "production": "Produkcja"
     },
     "locales": {
       "en": "Angielski",
@@ -102,28 +97,28 @@
       "other": "Hybryda"
     },
     "tank_class_short": {
-      "-1": "unrecognized",
+      "-1": "nierozpoznany",
       "0": "Lekki",
       "1": "Średni",
       "2": "Ciężki",
-      "3": "TD"
+      "3": "NC"
     },
     "tank_class_short_plural_lowercase": {
       "0": "lekkie",
       "1": "średnie",
       "2": "ciężkie",
-      "3": "TDs"
+      "3": "NC-ów"
     },
     "tank_class_medium": {
-      "-1": "unrecognized",
+      "-1": "nierozpoznany",
       "0": "Lekki",
       "1": "Średni",
       "2": "Ciężki",
       "3": "Niszczyciel czołgów"
     },
     "tree_type": {
-      "-1": "unrecognized",
-      "0": "Tech tree",
+      "-1": "nierozpoznany",
+      "0": "Drzewko technologiczne",
       "1": "Premium",
       "2": "Kolekcjonerski"
     },
@@ -187,223 +182,229 @@
   },
   "website": {
     "redirect": {
-      "title": "301: moved permanently",
-      "body": "This page has moved. Redirecting..."
+      "title": "301: przeniesiony na stałe",
+      "body": "Ta strona została przeniesiona. Przekierowywanie..."
     },
     "settings": {
-      "title": "Settings",
-      "description": "Change BlitzKit settings",
-      "dev_mode": "Development mode",
-      "auto_load_models": "Auto-load models",
-      "language": "Language"
+      "title": "Ustawienia",
+      "description": "Zmień ustawienia BlitzKit",
+      "dev_mode": "Tryb deweloperski",
+      "auto_load_models": "Automatycznie wczytaj modele",
+      "language": "Język"
     },
     "common": {
       "player_search": {
-        "hint": "Search players...",
-        "no_results": "No results",
-        "searching": "Searching..."
+        "hint": "Szukaj graczy...",
+        "no_results": "Brak wyników",
+        "searching": "Wyszukiwanie..."
       },
       "copy_button": {
-        "copied": "Copied!"
+        "copied": "Skopiowano!"
       },
       "tank_search": {
-        "select_dialog_title": "Search for tanks",
-        "swap_dialog_title": "Swap tank",
-        "clear_filters": "Clear filters",
-        "login": "Login to use this",
-        "search_bar_hint": "Search tanks...",
-        "recent": "Recently viewed",
-        "select_all": "Select all",
-        "count_singular": "1 tank",
-        "count_plural": "{count} tanks",
-        "sorting_by": "Sorting by {name}",
-        "clear": "Clear",
-        "tier": "Tier {tier}",
-        "passive": "{name} (Passive)",
-        "active": "{name} (Active)",
+        "select_dialog_title": "Szukaj czołgów",
+        "swap_dialog_title": "Zamień czołg",
+        "clear_filters": "Wyczyść filtry",
+        "login": "Zaloguj się, aby tego użyć",
+        "search_bar_hint": "Szukaj czołgów...",
+        "recent": "Ostatnio oglądane",
+        "select_all": "Zaznacz wszystko",
+        "count_singular": "1 czołg",
+        "count_plural": "{count} czołgi",
+        "sorting_by": "Sortowanie według {name}",
+        "clear": "Wyczyść",
+        "tier": "Poziom czołgu {tier}",
+        "passive": "{name} (Pasywny)",
+        "active": "{name} (Aktywne)",
         "no_tanks_found": {
-          "body": "No tanks found.",
+          "body": "Nie znaleziono czołgu.",
           "search_again": "",
-          "clear_filters": "Try clearing filters."
+          "clear_filters": "Spróbuj wyczyścić filtry."
         },
         "sort": {
-          "meta.none": "none",
-          "survivability.health": "health",
-          "survivability.viewRange": "view range",
-          "survivability.camouflageStill": "camouflage still",
-          "survivability.camouflageMoving": "camouflage moving",
-          "survivability.camouflageShooting": "camouflage shooting",
-          "survivability.volume": "volume",
-          "survivability.length": "length",
-          "fire.dpm": "standard DPM",
-          "fire.dpmPremium": "premium DPM",
-          "fire.reload": "reload",
-          "fire.caliber": "caliber",
-          "fire.standardPenetration": "standard penetration",
-          "fire.premiumPenetration": "premium penetration",
+          "meta.none": "brak",
+          "survivability.health": "punkty.życia",
+          "survivability.viewRange": "zasięg widzenia",
+          "survivability.camouflageStill": "kamuflaż w bezruchu",
+          "survivability.camouflageMoving": "kamuflaż w trakcie ruchu",
+          "survivability.camouflageShooting": "kamuflaż podczas strzału",
+          "survivability.volume": "wartość",
+          "survivability.length": "długość",
+          "fire.dpm": "DPM pocisków podstawowych",
+          "fire.dpmPremium": "DPM pocisków premium",
+          "fire.reload": "przeładowanie",
+          "fire.caliber": "kaliber",
+          "fire.standardPenetration": "Penetracja pocisków standardowych",
+          "fire.premiumPenetration": "Penetracja pocisków premium",
           "fire.tertiaryPenetration": "tertiary penetration",
-          "fire.damage": "damage",
-          "fire.moduleDamage": "module damage",
-          "fire.shellVelocity": "shell velocity",
-          "fire.shellRange": "shell range",
-          "fire.shellCapacity": "shell capacity",
-          "fire.aimTime": "aim time",
+          "fire.damage": "uszkodzenia",
+          "fire.moduleDamage": "Uszkodzenia modułów",
+          "fire.shellVelocity": "Prędkość pocisku",
+          "fire.shellRange": "Zasięg pocisku",
+          "fire.shellCapacity": "Maksymalna ilość pocisków",
+          "fire.aimTime": "Czas celowania",
           "fire.dispersionStill": "dispersion still",
           "fire.dispersionMoving": "dispersion moving",
-          "fire.gunDepression": "gun depression",
-          "fire.gunElevation": "gun elevation",
-          "maneuverability.forwardsSpeed": "forwards speed",
-          "maneuverability.backwardsSpeed": "backwards speed",
-          "maneuverability.power": "power",
-          "maneuverability.powerToWeight": "power to weight",
-          "maneuverability.weight": "weight",
+          "fire.gunDepression": "Depresja działa",
+          "fire.gunElevation": "Elewacja działa",
+          "maneuverability.forwardsSpeed": "Maksymalna prędkość do przodu",
+          "maneuverability.backwardsSpeed": "Maksymalna prędkość do tyłu",
+          "maneuverability.power": "Moc silnika",
+          "maneuverability.powerToWeight": "Proporcja mocy do masy",
+          "maneuverability.weight": "Masa czołgu",
           "maneuverability.traverseSpeed": "traverse speed"
         },
         "sort_dropdown": {
-          "label": "Sort",
+          "label": "Filtruj",
           "groups": {
             "sort": {
-              "no_sort": "No sort",
-              "label": "Sort by",
-              "fire": "Fire",
-              "maneuverability": "Maneuverability",
-              "survivability": "Survivability"
+              "no_sort": "Brak filtrów",
+              "label": "Filtruj według",
+              "fire": "Siła ognia",
+              "maneuverability": "Mobilność ",
+              "survivability": "Przetrwanie"
             },
             "direction": {
               "label": "Direction",
-              "ascending": "Ascending",
-              "descending": "Descending"
+              "ascending": "Rosnąco",
+              "descending": "Malejąco"
             }
           }
         }
       },
       "warnings": {
-        "test": "Tanks in testing are subject to change and may not represent the final product."
+        "test": "Wartości statystyk czołgów w fazie testowej mogą ulec zmianie."
       }
     },
     "home": {
       "discord": {
-        "join_short": "Join cool people!",
-        "join_long": "Join super duper cool people!",
+        "join_short": "Dołącz do elity!",
+        "join_long": "Dołącz do topowej elity!",
         "action": "Discord"
       },
       "hero": {
-        "credit": "By {name} ❤️"
+        "credit": "Według {name} ♥️"
       },
       "hot_tanks": {
-        "title": "Popular tanks",
-        "subtitle": "Last {days} days"
+        "title": "Popularne czołgi",
+        "subtitle": "Ostatnie {days} dni"
       },
       "other_projects": {
-        "title": "Other cool projects"
+        "title": "Inne epickie projekty"
       },
-      "help_translate": "Please help translate {name} to {language}!",
-      "seo_description": "Tools for everything World of Tanks Blitz"
+      "help_translate": "Proszę pomóż przetłumaczyć {name} na {language}!",
+      "seo_description": "Narzędzia do wszystkiego World of Tanks Blitz"
     },
     "docs": {
       "patches": {
-        "name": "BlitzKit Changelogs",
-        "seo_description": "Changelogs for BlitzKit Discord bot and website"
+        "name": "Zapisy zmian BlitzKit",
+        "seo_description": "Zapisy zmian BlitzKit: Discord bot i strona internetowa"
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
-        "reset": "Reset",
-        "shuffle": "Shuffle",
-        "remove": "Remove played",
-        "tracking": "BlitzKit is tracking your battles",
+        "reset": "Resetuj",
+        "shuffle": "Wymieszaj",
+        "remove": "Usuń czołgi, którymi grałem",
+        "tracking": "BlitzKit zapisuje twoje bitwy",
         "sort": {
-          "button": "Sort by",
-          "last_played": "Last played",
-          "least_played": "Least played"
+          "button": "Filtruj według",
+          "last_played": "Ostatnio używane czołgi",
+          "least_played": "Najmniej używane czołgi"
         },
         "table": {
           "index": "#",
-          "never": "Never",
-          "tank": "Tank",
-          "last_played": "Last played",
-          "battles": "Career battles",
+          "never": "Nigdy",
+          "tank": "Czołg",
+          "last_played": "Ostatnio używane czołgi",
+          "battles": "Wszystkie bitwy na koncie",
           "unrecorded": "--",
           "wins": "Zwycięstwa"
         },
         "large_warning": {
-          "title": "That's a lot of tanks!",
-          "description": "Are you sure you want to create a playlist of {count} tanks? That's {time} hours of gameplay at 50% winrate!",
-          "cancel": "Cancel",
-          "proceed": "Proceed"
+          "title": "To jest mnóstwo czołgów!",
+          "description": "Czy na pewno chcesz stworzyć playlistę złożoną z {count} czołgów? To {time} godzin gry przy 50% zwycięstw!",
+          "cancel": "Anuluj",
+          "proceed": "Zatwierdź"
         },
-        "generate": "Generate playlist",
-        "name": "Playlist",
-        "description": "Tank playlist generator",
-        "seo_description": "Don't know what to play in World of Tanks Blitz? Use BlitzKit Playlist to get suggestions!",
-        "button": "Generate",
-        "pool_size": "{count} possible tanks"
+        "generate": "Wygeneruj playlistę",
+        "name": "Playlista",
+        "description": "Generator playlisty czołgów",
+        "seo_description": "Nie wiesz, którym czołgiem grać w World of Tanks Blitz? Użyj funkcji playlisty BlitzKit, i ułóż własną listę czołgów do gry!",
+        "button": "Wygeneruj",
+        "pool_size": "{count} możliwe czołgi"
       },
       "mixer": {
-        "name": "Mixer",
+        "name": "Mikser",
         "button": "Mix and match",
         "description": "Mix tank modules",
         "seo_description": "Mix and match hulls, turrets, and guns of tanks in World of Tanks Blitz",
-        "screenshot": "Screenshot",
-        "randomize": "Randomize"
+        "screenshot": "Zrzut ekranu",
+        "randomize": "Wymieszaj"
       },
       "guess": {
-        "name": "Guess",
+        "name": "Zgadnij",
         "button": "What could it be?",
         "description": "Silhouette mini-game",
         "seo_description": "Play a tank guessing game with a silhouette in World of Tanks Blitz",
         "search": {
-          "placeholder": "Type to guess...",
-          "skip": "Skip",
-          "guess": "Guess",
-          "next": "Next",
+          "placeholder": "Wpisz odpowiedź",
+          "skip": "Pomiń",
+          "guess": "Zgaduję",
+          "next": "Następny",
           "no_results": "Brak wyników"
         },
         "stats": "{correct} / {total} correct, {streak} streak",
         "help": {
-          "title": "Partially reveal tank?",
+          "title": "Odsłonić część czołgu?",
           "description": "Reveals the tank without showing the name. This round will be considered incorrect and break your streak!",
-          "cancel": "Cancel",
-          "reveal": "Reveal"
+          "cancel": "Anuluj",
+          "reveal": "Pokaż"
         },
-        "clear": "Clear",
-        "select_all": "Select all",
-        "tier": "Tier {tier}"
+        "clear": "Wyczyść",
+        "select_all": "Zaznacz wszystko ",
+        "tier": "Poziom czołgu {tier}"
       },
       "tankopedia": {
-        "search": "Search a stat...",
+        "search": "Wyszukaj statystykę...",
         "name": "Tankopedia",
-        "button": "Find tanks",
-        "description": "Blitz tank encyclopedia",
+        "button": "Znajdź czołg",
+        "description": "Encyklopedia czołgów w WoTb",
         "seo_description": "Statistics, armor, and more for all tanks in World of Tanks Blitz",
         "tank_seo_title": "{name} - Tier {tier} {nationality} {class} | {website} Tankopedia | World of Tanks Blitz (WoTB)",
         "tank_seo_description": "{name} armor, statistics, equipment, provisions, and more. {dpm} DPM, {alpha}hp alpha, {penetration}mm penetration, {speed}kph top speed, {health}hp health.",
         "visualizers": {
           "reload": {
-            "skip": "Skip"
+            "skip": "Pomiń"
           },
           "assault": {
             "title": "Assault shells"
           },
           "rotator": {
-            "hull": "Hull",
-            "turret": "Turret",
-            "hard": "Hard",
+            "hull": "Kadłub",
+            "turret": "Wieża",
+            "hard": "Utwardzony",
             "medium": "Średni",
-            "soft": "Soft",
-            "effective": "Effective"
+            "soft": "Miękki",
+            "effective": "Rzeczywisty"
           },
           "ricochet": {
-            "angle": "Angle",
+            "angle": "Kąt",
             "normalization": "Normalization",
-            "effective_angle": "Effective angle",
-            "armor": "Armor",
-            "no_ricochet": "Explosive shells don't ricochet"
+            "effective_angle": "Rzeczywisty kąt nachylenia pancerza",
+            "armor": "Pancerz",
+            "no_ricochet": "Pociski odłamkowe nie rykoszetują."
           },
           "view_range": {
-            "camo": "Camo",
-            "ghost_factory": "Ghost Factory",
-            "dead_rail": "Dead Rail"
+            "camo": "Kamuflaż",
+            "ghost_factory": "Fabryka duchów",
+            "dead_rail": "Martwy tor"
           },
           "flexibility": {
             "yaw": "Yaw",
@@ -443,71 +444,71 @@
               "ricochet": "Ricochet",
               "explosion_radius": "Explosion radius",
               "exit": "Exit",
-              "reset": "Reset"
+              "reset": "Zresetuj"
             },
-            "advanced": "Advanced highlighting",
+            "advanced": "Zaawansowane podświetlanie",
             "shot_card": {
               "element": {
-                "primary": "Primary",
+                "primary": "Główny",
                 "spaced": "Spaced",
-                "external": "External",
-                "gap": "Gap",
-                "gun": "Gun",
-                "track": "Tracks"
+                "external": "Zewnętrzny",
+                "gap": "Odstęp",
+                "gun": "Działo",
+                "track": "Gąsienice"
               },
               "status": {
-                "penetration": "{damage}hp penetration",
-                "blocked": "Blocked",
-                "ricochet": "Ricochet",
-                "splash": "{damage}hp splash"
+                "penetration": "{damage} penetracja punktów wytrzymałości",
+                "blocked": "Zablokowany",
+                "ricochet": "Rykoszet",
+                "splash": "{damage} rozprysk punktów wytrzymałości"
               },
               "stats": {
-                "thickness_and_angle": "{thickness}mm {angle}°",
-                "nominal": "{thickness}mm nominal",
-                "ricochet_loss": "{loss}% penetration"
+                "thickness_and_angle": "{thickness}mm {angle}",
+                "nominal": "{thickness}mm nominalny",
+                "ricochet_loss": "{loss}% penetracji"
               }
             }
           },
           "static": {
-            "name": "Static armor",
-            "primary": "Primary",
-            "spaced": "Spaced",
-            "external": "External",
+            "name": "Pancerz statyczny",
+            "primary": "Główny Pancerz",
+            "spaced": "Ekran przeciwkumulacyjny",
+            "external": "Zewnętrzny",
             "edit": {
-              "label": "Edit",
-              "reset": "Reset"
+              "label": "Edytuj",
+              "reset": "Zresetuj"
             }
           }
         },
         "meta": {
-          "back": "Back",
-          "compare": "Compare",
+          "back": "Powrót",
+          "compare": "Porównaj",
           "swap": {
-            "button": "Swap",
-            "title": "Swap tanks"
+            "button": "Zamień",
+            "title": "Zamień czołgi"
           },
           "vanilla": "Vanilla",
           "opentest": "OpenTest",
-          "full_name": "Full name",
+          "full_name": "Pełna nazwa",
           "nation": "Naród",
           "class": "Klasa",
           "tier": "Poziom",
           "type": "Rodzaj",
           "dev_id": "DEV: ID",
-          "dev_name": "DEV: NAME",
-          "purchase": "Purchase price",
-          "restoration": "Restoration price",
+          "dev_name": "DEV: NAZWA",
+          "purchase": "Cena zakupu",
+          "restoration": "Cena odzyskania",
           "sale": "Sale price",
           "research": "Research XP"
         },
         "tech_tree": {
-          "title": "Tech tree",
-          "battle": "1 battle",
-          "battles": "{count} battles",
-          "route": "Route {index} of {count}"
+          "title": "Drzewko technologiczne",
+          "battle": "1 bitwa",
+          "battles": "{count} bitew",
+          "route": "Ścieżka {index} z {count}"
         },
         "game_modes": {
-          "title": "Game mode abilities"
+          "title": "Umiejętności trybu gry"
         },
         "review": {
           "title": "Review videos",
@@ -520,26 +521,26 @@
             "equalize": "Equalize"
           },
           "modules": {
-            "title": "Modules",
-            "stock": "Stock",
-            "upgrade": "Upgrade"
+            "title": "Moduły",
+            "stock": "Standardowy",
+            "upgrade": "Ulepsz"
           },
           "equipment": {
-            "title": "Equipment",
-            "clear": "Clear"
+            "title": "Wyposażenie",
+            "clear": "Wyczyść"
           },
           "provisions": {
-            "title": "Provisions",
-            "clear": "Clear"
+            "title": "Materiały eksploatacyjne",
+            "clear": "Wyczyść"
           },
           "consumables": {
             "title": "Consumables",
-            "clear": "Clear",
+            "clear": "Wyczyść",
             "info": "Yellow consumables do not affect the statistics."
           },
           "skills": {
             "title": "Crew skills",
-            "clear": "Clear",
+            "clear": "Wyczyść",
             "maximize": "Maximize",
             "info": "Yellow skills only apply under special circumstances. Hold Space to quickly toggle between level 0 and 7."
           },
@@ -557,49 +558,49 @@
           },
           "values": {
             "shell_index": "Shell {index}",
-            "at_distance": "At {distance}m",
-            "at_distance_slider_label": "Distance",
-            "dispersion_at_distance": "Dispersion at {distance}m",
-            "gun_flexibility": "Gun flexibility",
-            "speed": "Speed",
-            "terrain_coefficients": "Terrain coefficients",
-            "raw_terrain_coefficients": "Raw terrain coefficients",
-            "power_to_weight_ratio": "Power to weight ratio",
-            "hull_traverse_speed": "Hull traverse speed",
-            "camouflage": "Camouflage",
-            "reload": "Reload",
-            "crewCount": "Crew count",
+            "at_distance": "Z odległości {distance}m",
+            "at_distance_slider_label": "Zasięg widzenia",
+            "dispersion_at_distance": "Rozrzut na {distance}m",
+            "gun_flexibility": "Elastyczność działa",
+            "speed": "Prędkość",
+            "terrain_coefficients": "Współczynniki terenu",
+            "raw_terrain_coefficients": "Surowe współczynniki terenu",
+            "power_to_weight_ratio": "Stosunek mocy do masy",
+            "hull_traverse_speed": "Prędkość obrotu kadłuba",
+            "camouflage": "Kamuflaż",
+            "reload": "Przeładowanie",
+            "crewCount": "Liczba członków załogi",
             "shellNormalization": "Normalization",
             "shellRicochet": "Ricochet",
-            "dpm": "DPM",
-            "dpmEffective": "Effective at 60s",
-            "peekabooDpm": "Peekaboo DPM",
-            "peekabooDpmInfo": "Damage per minute assuming you only fire after resetting camouflage (or the reload finishes, if it's slower) — at least 10 seconds between shots.",
-            "shells": "Shells",
-            "mostOptimalShellIndex": "Most optimal shell",
-            "shellReloads": "Reloads",
-            "shellReload": "Reload",
-            "intraClip": "Intra-clip",
+            "dpm": "Uszkodzenia na minutę",
+            "dpmEffective": "Efektywne w 60s",
+            "peekabooDpm": "Obrażenia na minutę w stylu „wychyl i schowaj”",
+            "peekabooDpmInfo": "Obrażenia na minutę przy założeniu, że strzelisz tylko po zresetowaniu kamuflażu (lub ponownym załadowaniu, jeśli jest wolniejszy) — co najmniej 10 sekund pomiędzy strzałami.",
+            "shells": "Pociski",
+            "mostOptimalShellIndex": "Optymalny pocisk",
+            "shellReloads": "Przeładowania",
+            "shellReload": "Przeładowanie",
+            "intraClip": "Czas przeładowania pocisku",
             "caliber": "Caliber",
             "penetration": "Penetration",
             "damage": "Uszkodzenia",
-            "damageWithoutAssault": "Damage without assault shells",
-            "clipDamage": "Clipping potential",
-            "moduleDamage": "Module damage",
-            "explosionRadius": "Explosion radius",
-            "shellVelocity": "Shell velocity",
-            "aimTime": "Aim time",
+            "damageWithoutAssault": "Uszkodzenia bez pocisków szturmowych",
+            "clipDamage": "Potencjał magazynu",
+            "moduleDamage": "Uszkodzenia modułów",
+            "explosionRadius": "Promień eksplozji",
+            "shellVelocity": "Prędkość pocisku",
+            "aimTime": "Czas celowania",
             "dispersion": "Still",
-            "dispersionMoving": "Moving",
-            "dispersionHullTraversing": "Hull traversing",
-            "dispersionTurretTraversing": "Turret traversing",
-            "dispersionShooting": "Shooting",
-            "dispersionGunDamaged": "Gun damaged",
-            "gunDepression": "Depression",
-            "gunElevation": "Elevation",
-            "gunFrontalDepression": "Frontal depression",
-            "gunFrontalElevation": "Frontal elevation",
-            "gunRearDepression": "Rear depression",
+            "dispersionMoving": "Podczas ruchu",
+            "dispersionHullTraversing": "Obrót kadłuba",
+            "dispersionTurretTraversing": "Obrót wieży",
+            "dispersionShooting": "Strzelanie",
+            "dispersionGunDamaged": "Uszkodzone Działo",
+            "gunDepression": "Limit obrotu działa w dół",
+            "gunElevation": "Limit obrotu działa w górę",
+            "gunFrontalDepression": "Przedni limit obrotu działa w dół",
+            "gunFrontalElevation": "Przedni limit obrotu działa w górę",
+            "gunRearDepression": "Tylne opuszczanie działa",
             "gunRearElevation": "Rear elevation",
             "azimuthLeft": "Azimuth left",
             "azimuthRight": "Azimuth right",
@@ -623,9 +624,10 @@
             "hullTraverseSoftTerrain": "Soft",
             "health": "Health",
             "fireChance": "Fire chance",
+            "trackRepairTime": "Track repair time",
             "viewRange": "View range",
             "camouflageStill": "Still",
-            "camouflageMoving": "Moving",
+            "camouflageMoving": "Podczas ruchu",
             "camouflageShootingStill": "Shooting while still",
             "camouflageShootingMoving": "Shooting while moving",
             "camouflageCaughtOnFire": "Caught on fire",
@@ -647,7 +649,7 @@
         "crew": {
           "title": "Crew training",
           "info": "represents the other roles a crew member can take.",
-          "count": "Crew count",
+          "count": "Liczba członków załogi",
           "commander": "Commander",
           "gunner": "Gunner",
           "driver": "Driver",
@@ -655,14 +657,14 @@
           "loader": "Loader"
         },
         "maneuverability": {
-          "title": "Maneuverability"
+          "title": "Mobilność "
         },
         "survivability": {
-          "title": "Survivability"
+          "title": "Przetrwanie"
         }
       },
       "compare": {
-        "name": "Compare",
+        "name": "Porównaj",
         "button": "Compare tanks",
         "description": "Compare tank statistics",
         "seo_description": "Compare tanks statistics and loadouts in World of Tanks Blitz",
@@ -672,7 +674,7 @@
             "title": "Add tanks",
             "description": "Select tanks to add to comparison"
           },
-          "clear": "Clear",
+          "clear": "Wyczyść",
           "deltas": {
             "none": "No deltas",
             "percentage": "Percentage",
@@ -685,17 +687,17 @@
         },
         "table": {
           "equipment": {
-            "clear": "Clear",
+            "clear": "Wyczyść",
             "apply_to_all": "Apply to all"
           },
           "skills": {
-            "clear": "Clear",
+            "clear": "Wyczyść",
             "maximize": "Maximize",
             "equalize": "Equalize"
           },
           "modules": {
-            "stock": "Stock",
-            "upgrade": "Upgrade"
+            "stock": "Standardowy",
+            "upgrade": "Ulepsz"
           },
           "provisions": {
             "clear": "Clear this tank",
@@ -760,14 +762,14 @@
         "seo_description": "Track your stats in real time as you play World of Tanks Blitz",
         "search": {
           "lookup": "Look up a player to get started",
-          "hint": "Search players...",
-          "searching": "Searching...",
+          "hint": "Szukaj graczy...",
+          "searching": "Wyszukiwanie...",
           "no_results": "No players found"
         },
         "controls": {
           "title": "Tracking {name}",
           "subtitle": "Since {time}",
-          "reset": "Reset",
+          "reset": "Zresetuj",
           "change": "Change"
         },
         "no_cc": {
@@ -791,7 +793,7 @@
         "description": "Rank Blitz tanks",
         "seo_description": "Explore tier lists ranking tanks from best to worst, based on player ratings and statistical performance in World of Tanks Blitz",
         "buttons": {
-          "reset": "Reset",
+          "reset": "Zresetuj",
           "share": "Share"
         }
       },
@@ -827,7 +829,7 @@
               "success": {
                 "title": "Copy URL",
                 "info": "Generated the URL for {name}. The embed will start tracking as soon as the URL is pasted. Reset at any time by right-clicking on PC or long-pressing on mobile and then selecting \"Reset\".",
-                "back": "Back",
+                "back": "Powrót",
                 "copy": "Copy URL"
               }
             },
@@ -838,7 +840,7 @@
           },
           "customize": {
             "title": "Customize",
-            "reset": "Reset",
+            "reset": "Zresetuj",
             "description": "Bells and whistles of your embed"
           }
         },
@@ -921,7 +923,6 @@
       "copyright": "Unaffiliated with Wargaming or any service",
       "about": {
         "title": "About",
-        "credits": "Credits",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Patches"

packages/i18n/strings/pt.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "teste",
-    "long": "This is a long test string. You MUST NEVER see this in the UI. My favorite fruit is {fruit} because it has the color of {color}. I like it so much that I will say its name 3 times! {fruit}! {fruit}! {fruit}! Once again, it's {color}, not {not_color}.",
-    "fox": "A ágil raposa castanha salta por cima do cão preguiçoso."
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -41,7 +36,7 @@
       "development": "Development",
       "opentest": "TesteAberto",
       "preview": "Preview",
-      "production": "Production"
+      "production": "Produção"
     },
     "locales": {
       "en": "Inglês",
@@ -187,11 +182,11 @@
   },
   "website": {
     "redirect": {
-      "title": "301: moved permanently",
+      "title": "301: movido permanentemente",
       "body": "This page has moved. Redirecting..."
     },
     "settings": {
-      "title": "Settings",
+      "title": "Configurações",
       "description": "Change BlitzKit settings",
       "dev_mode": "Modo de desenvolvimento",
       "auto_load_models": "Auto-load models",
@@ -207,9 +202,9 @@
         "copied": "Copiado!"
       },
       "tank_search": {
-        "select_dialog_title": "Search for tanks",
+        "select_dialog_title": "Procura por tanque",
         "swap_dialog_title": "Swap tank",
-        "clear_filters": "Clear filters",
+        "clear_filters": "Limpar filtros",
         "login": "Login to use this",
         "search_bar_hint": "Procurar tanques...",
         "recent": "Visto recentemente",
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "Restaurar",
         "shuffle": "Shuffle",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "Macio",
             "health": "Vida",
             "fireChance": "Chance de incêndio",
+            "trackRepairTime": "Track repair time",
             "viewRange": "Alcance de visão",
             "camouflageStill": "Parado",
             "camouflageMoving": "Em movimento",
@@ -921,7 +923,6 @@
       "copyright": "Não afiliado à Wargaming ou qualquer serviço",
       "about": {
         "title": "Sobre",
-        "credits": "Créditos",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Atualizações"

packages/i18n/strings/ru.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "тест",
-    "long": "Это длинная тестовая строка. Вы НИКОГДА не должны видеть её в пользовательском интерфейсе. Мой любимый фрукт — {fruit}, потому что это цвет {color}. Он мне так нравится, так что я скажу его 3 раза {fruit}! {fruit}! {fruit}! И ещё раз, это {color}, а не {not_color}.",
-    "fox": "Съешь же ещё этих мягких французских булок, да выпей чаю."
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -38,10 +33,10 @@
     },
     "branches": {
       "beta": "Бета",
-      "development": "Development",
+      "development": "Разработка",
       "opentest": "Открытый тест",
-      "preview": "Preview",
-      "production": "Production"
+      "preview": "Предпросмотр",
+      "production": "Производство"
     },
     "locales": {
       "en": "Английский",
@@ -194,7 +189,7 @@
       "title": "Настройки",
       "description": "Изменить настройки BlitzKit",
       "dev_mode": "Режим разработчика",
-      "auto_load_models": "Auto-load models",
+      "auto_load_models": "Автозагрузка моделей",
       "language": "Язык"
     },
     "common": {
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "Сброс",
         "shuffle": "Перемешать",
@@ -413,7 +414,7 @@
           }
         },
         "sandbox": {
-          "load_model": "Load model",
+          "load_model": "Загрузить модель",
           "poses": {
             "hull_down": "За холмом",
             "face_hug": "В упор",
@@ -574,7 +575,7 @@
             "dpm": "ДПМ",
             "dpmEffective": "Эффективность за 60с",
             "peekabooDpm": "Peekaboo DPM",
-            "peekabooDpmInfo": "Damage per minute assuming you only fire after resetting camouflage (or the reload finishes, if it's slower) — at least 10 seconds between shots.",
+            "peekabooDpmInfo": "Урон в минуту при условии, если вы сбросите камуфляж(или перезарядка окончена, если она медленнее) - не менее 10 секунд между выстрелами.",
             "shells": "Снарядов в барабане",
             "mostOptimalShellIndex": "Самый эффективный снаряд",
             "shellReloads": "Перезарядка",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "На мягком грунте",
             "health": "Прочность",
             "fireChance": "Вероятность возгорания",
+            "trackRepairTime": "Track repair time",
             "viewRange": "Радиус обзора",
             "camouflageStill": "Когда неподвижен",
             "camouflageMoving": "В движении",
@@ -921,7 +923,6 @@
       "copyright": "Не связан с Wargaming или иным сервисом",
       "about": {
         "title": "О сайте",
-        "credits": "Авторы",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Патчи"

packages/i18n/strings/uk.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "тест",
-    "long": "{color}{fruit}",
-    "fox": "Швидка бура лисиця перестрибує через лінивого собаку."
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "Скинути",
         "shuffle": "Перемішати",
@@ -364,7 +365,7 @@
           "title": "Partially reveal tank?",
           "description": "Reveals the tank without showing the name. This round will be considered incorrect and break your streak!",
           "cancel": "",
-          "reveal": "Reveal"
+          "reveal": "Рівень"
         },
         "clear": "Clear",
         "select_all": "Вибрати все",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "Soft",
             "health": "Здоров'я",
             "fireChance": "Fire chance",
+            "trackRepairTime": "Track repair time",
             "viewRange": "View range",
             "camouflageStill": "Нерухомо",
             "camouflageMoving": "У русі",
@@ -921,7 +923,6 @@
       "copyright": "Unaffiliated with Wargaming or any service",
       "about": {
         "title": "About",
-        "credits": "Credits",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "Patches"

packages/i18n/strings/zh.json

@@ -1,9 +1,4 @@
 {
-  "test": {
-    "default": "测试",
-    "long": "这是一个测试用长字符串。你绝对不会在用户界面中看见这些。我最喜欢的水果是{fruit}因为它的颜色是{color}的。我如此喜欢它，以至于我会把它的名字念3次！{fruit}！{fruit}！{fruit}！重申一次，它是{color}的而不是{not_color}的。",
-    "fox": "褐色的狐狸迅速地跳过那只懒狗"
-  },
   "common": {
     "name": "BlitzKit",
     "units": {
@@ -307,6 +302,12 @@
       }
     },
     "tools": {
+      "credits": {
+        "name": "Credits",
+        "button": "View people",
+        "description": "Contributors of BlitzKit",
+        "seo_description": "BlitzKit is the work of many"
+      },
       "playlist": {
         "reset": "重置",
         "shuffle": "换一批",
@@ -623,6 +624,7 @@
             "hullTraverseSoftTerrain": "水面上车转速率",
             "health": "血量",
             "fireChance": "发动机受击时着火概率",
+            "trackRepairTime": "Track repair time",
             "viewRange": "视野范围",
             "camouflageStill": "静止隐蔽",
             "camouflageMoving": "移动时",
@@ -921,7 +923,6 @@
       "copyright": "本网站与 Wargaming战游网 或任何服务无关",
       "about": {
         "title": "关于",
-        "credits": "鸣谢",
         "discord": "Discord",
         "github": "GitHub",
         "patches": "补丁"

packages/scripts/package.json

@@ -5,7 +5,9 @@
     "discover-ids": "bun src/discoverIds/index.ts",
     "build-protos": "bun src/protos.ts",
     "record-performance": "bun src/recordPerformance/index.ts",
-    "download-client": "bun src/downloadClient/index.ts"
+    "download-client": "bun src/downloadClient/index.ts",
+    "download-smart-dlc": "bun src/downloadSmartDLC/index.ts",
+    "vfs": "bun src/vfs/index.ts"
   },
   "dependencies": {
     "@blitzkit/closed": "workspace:*",

packages/scripts/src/downloadClient/index.ts

@@ -9,6 +9,8 @@ import {
 } from "./constants";
 import { QuickGitHubRelease } from "./types";
 
+const DEPOT_DOWNLOADER_RETRY_TIME = 30_000;
+
 const provider = assertSecret(import.meta.env.CLIENT_PROVIDER);
 const source = assertSecret(import.meta.env.CLIENT_SOURCE);
 const dir = assertSecret(import.meta.env.CLIENT_DIR);
@@ -43,11 +45,27 @@ if (provider === "steam") {
   const username = assertSecret(import.meta.env.STEAM_USERNAME);
   const password = assertSecret(import.meta.env.STEAM_PASSWORD);
 
-  await $`${DEPOT_DOWNLOADER_EXECUTABLE} -os ${
-    platform
-  } -app ${id} -username ${username} -password ${
-    password
-  } -dir ${dir} -max-downloads ${DEPOT_DOWNLOADER_MAX_DOWNLOADS}`;
+  while (true) {
+    const result = await $`${
+      DEPOT_DOWNLOADER_EXECUTABLE
+    } -os ${platform} -app ${id} -username ${
+      username
+    } -password ${password} -dir ${dir} -max-downloads ${
+      DEPOT_DOWNLOADER_MAX_DOWNLOADS
+    }`.nothrow();
+
+    if (result.exitCode === 0) {
+      console.log("Client downloaded successfully!");
+      break;
+    }
+
+    console.error(
+      `DepotDownloader failed (exit ${result.exitCode}). Retrying in ${DEPOT_DOWNLOADER_RETRY_TIME / 1000} seconds...`,
+    );
+    await new Promise((resolve) =>
+      setTimeout(resolve, DEPOT_DOWNLOADER_RETRY_TIME),
+    );
+  }
 } else if (provider === "zip") {
   const url = assertSecret(import.meta.env.CLIENT_SOURCE);
 

packages/scripts/src/downloadSmartDLC/index.ts

@@ -2,9 +2,16 @@ import { dvp } from "@blitzkit/closed";
 import { assertSecret } from "@blitzkit/core";
 import { mkdir, writeFile } from "fs/promises";
 import { parse as parsePath } from "path";
-import ProgressBar from "progress";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { PATCHES_ROOT, vfs } from "./buildAssets/constants";
+import { RegionsPublish } from "../types/regionsPublish";
+import { vfs } from "../vfs/vfs";
+
+const CLIENT_DIR = assertSecret(import.meta.env.CLIENT_DIR);
+
+const regionsPublish = await vfs.yaml<RegionsPublish>(
+  "Data/regions_publish.yaml",
+);
+const [smartDlcUrl] = regionsPublish.Common.smartDlcUrls;
 
 const versionTextFile = await vfs.text(`Data/version.txt`);
 const currentVersion = versionTextFile
@@ -18,9 +25,7 @@ console.log(`Installing patches for ${currentVersion}...`);
 let patchIndex = 1;
 while (true) {
   const response = await fetch(
-    `${assertSecret(
-      import.meta.env.WOTB_DLC_CDN,
-    )}/dlc/s${currentVersion}_${patchIndex}.yaml`,
+    `${smartDlcUrl}/s${currentVersion}_${patchIndex}.yaml`,
   );
 
   console.log(patchIndex, response.status);
@@ -30,51 +35,34 @@ while (true) {
   console.log(`Applying patch ${patchIndex}...`);
 
   const data = parseYaml(await response.text());
-  const dvpm = await fetch(
-    `${assertSecret(import.meta.env.WOTB_DLC_CDN)}/dlc/${data.dx11}`,
-  ).then((response) => response.arrayBuffer());
+  const dvpm = await fetch(`${smartDlcUrl}/${data.dx11}`).then((response) =>
+    response.arrayBuffer(),
+  );
   const dvpd = await fetch(
-    `${assertSecret(import.meta.env.WOTB_DLC_CDN)}/dlc/${data.dx11.replace(
-      ".dvpm",
-      ".dvpd",
-    )}`,
+    `${smartDlcUrl}/${data.dx11.replace(".dvpm", ".dvpd")}`,
   ).then((response) => response.arrayBuffer());
   const files = await dvp(dvpm, dvpd);
-  const bar = new ProgressBar(
-    `Patching ${files.length} files :bar`,
-    files.length,
-  );
 
   for (const { path, data } of files) {
     console.log(`Patching "${path}"...`);
 
     const { dir } = parsePath(path);
 
-    try {
-      await mkdir(`${PATCHES_ROOT}/Data/${dir}`, { recursive: true });
-    } catch (error) {
-      console.warn(`Failed to make directory "${dir}"`);
-    }
+    await mkdir(`${CLIENT_DIR}/Data/${dir}`, { recursive: true });
 
     const buffer = Buffer.from(data);
 
-    await writeFile(`${PATCHES_ROOT}/Data/${path}`, new Uint8Array(buffer));
-
-    bar.tick();
+    await writeFile(`${CLIENT_DIR}/Data/${path}`, new Uint8Array(buffer));
   }
 
   console.log("patches done for patch");
 
   if ("dynamicContentLocalizationsDir" in data) {
     console.log(
-      `${assertSecret(import.meta.env.WOTB_DLC_CDN)}/dlc/${
-        data.dynamicContentLocalizationsDir
-      }/en.yaml`,
+      `${smartDlcUrl}/${data.dynamicContentLocalizationsDir}/en.yaml`,
     );
     const localizationsResponse = await fetch(
-      `${assertSecret(import.meta.env.WOTB_DLC_CDN)}/dlc/${
-        data.dynamicContentLocalizationsDir
-      }/en.yaml`,
+      `${smartDlcUrl}/${data.dynamicContentLocalizationsDir}/en.yaml`,
     );
     console.log("fetched");
     const newStrings = parseYaml(await localizationsResponse.text());
@@ -86,10 +74,10 @@ while (true) {
     const patchedContent = stringifyYaml(patchedStrings);
     console.log("stringified");
 
-    await mkdir(`${PATCHES_ROOT}/Data/Strings`, { recursive: true });
+    await mkdir(`${CLIENT_DIR}/Data/Strings`, { recursive: true });
     console.log("mkdir");
     await writeFile(
-      `${PATCHES_ROOT}/Data/Strings/en.yaml`,
+      `${CLIENT_DIR}/Data/Strings/en.yaml`,
       new Uint8Array(Buffer.from(patchedContent)),
     );
     console.log("file");

packages/scripts/src/types/regionsPublish.ts

@@ -0,0 +1,7 @@
+export interface RegionsPublish {
+  Common: Common;
+}
+
+interface Common {
+  smartDlcUrls: string[];
+}

packages/scripts/src/vfs/index.ts

@@ -0,0 +1,23 @@
+import { vfs } from "./vfs";
+
+const command = Bun.argv[2];
+const path = Bun.argv[3];
+
+if (!path) {
+  console.error("Gimme a path to assess dumb ass");
+  process.exit(1);
+}
+
+if (command === "cat") {
+  const content = await vfs.file(path);
+  await Bun.write(Bun.stdout, content);
+} else if (command === "ls") {
+  const files = await vfs.dir(path);
+
+  for (const file of files) {
+    console.log(file);
+  }
+} else if (command === "yaml") {
+  const content = await vfs.yaml(path);
+  await Bun.write(Bun.stdout, JSON.stringify(content, null, 2));
+}

packages/scripts/src/vfs/vfs.ts

@@ -0,0 +1,4 @@
+import { assertSecret } from "@blitzkit/core";
+import { LocalVFS } from "@blitzkit/core/src/blitzkit/vfs/local";
+
+export const vfs = new LocalVFS(assertSecret(import.meta.env.CLIENT_DIR));

packages/website/src/components/ArticlePlug.astro

@@ -1,38 +0,0 @@
----
-import { tankIcon } from "@blitzkit/core";
-import { Flex, Heading, Link, Strong, Text } from "@radix-ui/themes";
----
-
-<Flex justify="center" px="4">
-  <Link
-    color="gray"
-    highContrast
-    style={{ display: "content" }}
-    href="/docs/guides/christmas-2025"
-    underline="none"
-  >
-    <Flex
-      mt="3"
-      px="5"
-      py="4"
-      style={{
-        borderRadius: "var(--radius-3)",
-        backgroundImage: "url(https://i.imgur.com/LRYmSkg.png)",
-        backgroundSize: "cover",
-        backgroundPosition: "center",
-        boxSizing: "border-box",
-      }}
-      align="center"
-      gap="5"
-    >
-      <img src={tankIcon(25169)} style={{ height: "min(15vw, 5rem)" }} />
-
-      <Flex direction="column">
-        <Heading size={{ initial: "4", sm: "6" }}>Christmas 2025</Heading>
-        <Text size={{ initial: "2", sm: "3" }}>
-          Win the <Strong>GSOR the TANK</Strong> and more!
-        </Text>
-      </Flex>
-    </Flex>
-  </Link>
-</Flex>

packages/website/src/components/Beg/index.module.css

@@ -0,0 +1,36 @@
+.outer {
+  padding: 0 var(--space-4);
+  margin-top: var(--space-3);
+
+  img {
+    width: 1.25em;
+    height: 1.25em;
+
+    border-radius: 50%;
+  }
+
+  .center {
+    position: relative;
+
+    background: linear-gradient(var(--pink-3), var(--purple-2));
+    box-shadow: var(--shadow-3);
+
+    max-width: 40rem;
+
+    padding: var(--space-5);
+    border-radius: var(--radius-4);
+
+    .important {
+      position: absolute;
+
+      top: 0;
+      left: 50%;
+
+      transform: translate(-50%, -50%);
+
+      background-color: inherit;
+
+      padding: var(--space-3);
+    }
+  }
+}

packages/website/src/components/Beg/index.tsx

@@ -0,0 +1,48 @@
+import { HeartFilledIcon } from "@radix-ui/react-icons";
+import { Button, Em, Flex, Strong, Text } from "@radix-ui/themes";
+import { donationTiers } from "../../config/donations";
+import styles from "./index.module.css";
+
+export function Beg() {
+  return (
+    <Flex align="center" gap="4" direction="column" className={styles.outer}>
+      <Text size="3" className={styles.important}>
+        <Flex gap="2" align="center">
+          <img src="https://github.com/tresabhi.png" />
+          <Em>We need your attention</Em>
+        </Flex>
+      </Text>
+
+      <Flex direction="column" className={styles.center} gap="4">
+        <Flex direction="column" gap="3">
+          <Text color="tomato">
+            We can no longer keep BlitzKit sustainable for <Strong>free</Strong>
+            .
+          </Text>
+
+          <Text>
+            We want to add tank modules, player statistics, rebalancing patch
+            notes, bring back the Discord bot, and more.
+          </Text>
+
+          <Text>
+            But paying out of pocket makes that impossible. We are an earnest
+            non-profit, so consider donating to make the above possible. 100% of
+            your money goes back into BlitzKit.
+          </Text>
+        </Flex>
+
+        <Flex gap="3">
+          {donationTiers.map(({ name, value, link }) => (
+            <a target="_blank" key={name} href={link}>
+              <Button size="3" color="crimson">
+                {value === null && <HeartFilledIcon />}
+                {value === null ? "Custom" : `$${value}`}
+              </Button>
+            </a>
+          ))}
+        </Flex>
+      </Flex>
+    </Flex>
+  );
+}

packages/website/src/components/Countdown.tsx

@@ -3,9 +3,9 @@ import { useEffect, useState, type ReactNode } from "react";
 import type { MaybeSkeletonComponentProps } from "../types/maybeSkeletonComponentProps";
 import { InlineSkeleton } from "./InlineSkeleton";
 
-const TIME = 1764898200 * 1000;
+const TIME = 1792598400 * 1000;
 
-export function Giveaway({ skeleton }: MaybeSkeletonComponentProps) {
+export function Countdown({ skeleton }: MaybeSkeletonComponentProps) {
   const [timeLeft, setTimeLeft] = useState<number>(TIME - Date.now());
 
   useEffect(() => {
@@ -31,14 +31,14 @@ export function Giveaway({ skeleton }: MaybeSkeletonComponentProps) {
 
     string = (
       <>
-        in{" "}
+        revealed in{" "}
         <Code highContrast>
           {hours}h {minutes}m {seconds}s
         </Code>
       </>
     );
   } else {
-    string = "has ended. Come again later!";
+    string = "have been revealed.";
   }
 
   return (
@@ -47,7 +47,7 @@ export function Giveaway({ skeleton }: MaybeSkeletonComponentProps) {
         color="gray"
         highContrast
         style={{ display: "content" }}
-        href="https://discord.gg/njQdBhNS?event=1446208951136813117"
+        href="https://preview.blitzkit.app/tanks"
         underline="none"
       >
         <Flex
@@ -56,17 +56,17 @@ export function Giveaway({ skeleton }: MaybeSkeletonComponentProps) {
           py="4"
           style={{
             borderRadius: "var(--radius-3)",
-            backgroundImage: "url(https://i.imgur.com/LRYmSkg.png)",
+            backgroundImage: "url(https://i.imgur.com/xgngxoy.png)",
             backgroundSize: "cover",
             backgroundPosition: "center",
             boxSizing: "border-box",
-            boxShadow: "0 0 var(--space-7) var(--blue-a5)",
+            boxShadow: "0 0 var(--space-7) var(--white-a2)",
           }}
           align="center"
           gap="5"
         >
           <img
-            src="https://i.imgur.com/mvmJQgB.png"
+            src="https://i.imgur.com/kXV3r3P.png"
             style={{
               height: "min(15vw, 5rem)",
               filter: "drop-shadow(0.5rem 0.5rem 1rem #00000080)",
@@ -75,11 +75,11 @@ export function Giveaway({ skeleton }: MaybeSkeletonComponentProps) {
 
           <Flex direction="column">
             <Heading size={{ initial: "4", sm: "6" }}>
-              Music Box giveaway {!skeleton && string}{" "}
+              Tier XIs {!skeleton && string}{" "}
               {skeleton && <InlineSkeleton width="10rem" />}
             </Heading>
             <Text size={{ initial: "2", sm: "3" }}>
-              Join the BlitzKit Discord server event
+              Get ready to go to the Tankopedia!
             </Text>
           </Flex>
         </Flex>

packages/website/src/components/CreditsPromo.astro

@@ -0,0 +1,135 @@
+---
+import { Grid, Text } from "@radix-ui/themes";
+import { credits } from "../config/credits";
+import { getStrings } from "../core/i18n/getStrings";
+
+interface Props {
+  locale: string;
+}
+
+const { locale } = Astro.props;
+
+const strings = getStrings(locale);
+---
+
+<style>
+  .credits {
+    display: flex;
+    justify-content: center;
+
+    padding: var(--space-4);
+
+    .inner {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-2);
+
+      width: 100%;
+      max-width: 80rem;
+
+      .list {
+        gap: var(--space-5);
+
+        .link {
+          display: contents;
+
+          .person {
+            --profile-size: 5rem;
+
+            position: relative;
+
+            display: flex;
+            flex-direction: column;
+
+            padding: var(--space-4);
+            padding-top: 0;
+            margin-top: calc(var(--profile-size) / 2);
+            gap: var(--space-1);
+
+            box-shadow: var(--shadow-3);
+            border-radius: var(--radius-3);
+
+            .contain {
+              border-radius: inherit;
+
+              position: absolute;
+
+              top: 0;
+              right: 0;
+
+              width: 100%;
+              height: 100%;
+
+              overflow: hidden;
+
+              .hint {
+                width: 100%;
+                height: 100%;
+
+                background-size: cover;
+                background-position: center;
+
+                filter: saturate(20) brightness(0.125) blur(4rem);
+              }
+            }
+
+            .text {
+              position: relative;
+            }
+
+            img {
+              border-radius: 50%;
+
+              position: relative;
+
+              margin-top: calc(var(--profile-size) / -2);
+
+              object-fit: cover;
+              width: var(--profile-size);
+              height: var(--profile-size);
+
+              margin-bottom: var(--space-2);
+            }
+          }
+        }
+      }
+    }
+  }
+</style>
+
+<div class="credits">
+  <div class="inner">
+    <Grid
+      className="list"
+      py="4"
+      columns="repeat(auto-fill, minmax(16rem, 1fr))"
+      flow="dense"
+      gap="4"
+      gapY="8"
+    >
+      {
+        credits.map((person) => (
+          <a target="_blank" href={person.url} class="link">
+            <div class="person">
+              <div class="contain">
+                <div
+                  class="hint"
+                  style={`background-image: url(${person.image})`}
+                />
+              </div>
+
+              <img src={person.image} />
+
+              <Text weight="medium" className="text" color="gray" highContrast>
+                {person.name}
+              </Text>
+              <Text className="text" color="gray" wrap="pretty">
+                {person.description}
+              </Text>
+            </div>
+          </a>
+        ))
+      }
+    </Grid>
+  </div>
+</div>

packages/website/src/components/Footer.astro

@@ -43,9 +43,9 @@ const strings = getStrings(locale);
       }}
     >
       <Heading>BlitzKit</Heading>
-      <Text color="gray">{strings.website.footer.motto}</Text>
-      <Text size="1" color="gray">
-        {strings.website.footer.copyright}
+      <Text size="2" color="gray">{strings.website.footer.motto}</Text>
+      <Text size="2" color="gray">
+        {strings.website.footer.association}
       </Text>
 
       <Box mt="2">
@@ -84,9 +84,6 @@ const strings = getStrings(locale);
             sm: "start",
           }}
         >
-          <LinkI18n {locale} href="/docs/about/credits" color="gray">
-            {strings.website.footer.about.credits}
-          </LinkI18n>
           <Link
             href="https://discord.gg/nDt7AjGJQH"
             target="_blank"

packages/website/src/components/Markdown.tsx

@@ -1,13 +1,20 @@
 import { Link, Table } from '@radix-ui/themes';
 import MarkdownToJSX from 'markdown-to-jsx';
 import type { ComponentProps } from 'react';
+import { docImageUrl, isExternalImage } from '../core/blitzkit/docImages';
 
 interface MarkdownProps {
   children: string;
 }
 
-function Image(props: ComponentProps<'img'>) {
-  return <img style={{ maxWidth: '100%' }} {...props} />;
+function Image({ src, ...props }: ComponentProps<'img'>) {
+  return (
+    <img
+      style={{ maxWidth: '100%' }}
+      src={src && isExternalImage(src) ? docImageUrl(src) : src}
+      {...props}
+    />
+  );
 }
 
 export function Markdown({ children }: MarkdownProps) {

packages/website/src/components/Navbar.astro

@@ -5,7 +5,7 @@ import {
   GearIcon,
   HamburgerMenuIcon,
 } from "@radix-ui/react-icons";
-import { Box, Code, Flex, IconButton, Link } from "@radix-ui/themes";
+import { Box, Code, Flex, Grid, IconButton, Link } from "@radix-ui/themes";
 import { resolveBranchName } from "../core/blitzkit/branches";
 import { getStrings } from "../core/i18n/getStrings";
 import { Var } from "../core/radix/var";
@@ -20,7 +20,7 @@ export interface Props {
 
 const { integrated = false } = Astro.props;
 const toolsFiltered = Object.values(tools).filter(
-  (tool) => !tool.href && !tool.disabled
+  (tool) => !tool.href && !tool.disabled,
 );
 const { locale } = Astro.props;
 const branchName = resolveBranchName(locale);
@@ -105,7 +105,7 @@ const strings = getStrings(locale);
   <Flex
     className="content"
     width="100%"
-    p={{ initial: "4", sm: "3" }}
+    p="3"
     direction="column"
     align="center"
   >
@@ -133,41 +133,6 @@ const strings = getStrings(locale);
 
         <Box flexGrow="1" />
 
-        <Flex
-          align="center"
-          gap={{ initial: "3", md: "6" }}
-          display={{ initial: "none", sm: "flex" }}
-          justify="center"
-          className="tools"
-        >
-          {
-            toolsFiltered.map((tool) => {
-              const selected = Astro.url.pathname.includes(`/${tool.id}`);
-              const toolStrings =
-                strings.website.tools[
-                  (tool.strings ??
-                    tool.id) as keyof typeof strings.website.tools
-                ];
-
-              return (
-                <LinkI18n
-                  {locale}
-                  weight={selected ? "medium" : "regular"}
-                  color="gray"
-                  highContrast={selected}
-                  size={{ initial: "1", md: "2" }}
-                  href={`/${tool.id}`}
-                  underline="hover"
-                >
-                  {toolStrings.name}
-                </LinkI18n>
-              );
-            })
-          }
-        </Flex>
-
-        <Box flexGrow="1" />
-
         <Flex align="center" gap="4">
           <Link
             style={{ display: "flex", alignContent: "center" }}
@@ -191,7 +156,7 @@ const strings = getStrings(locale);
 
           <NavbarAccount {locale} client:idle />
 
-          <Flex align="center" display={{ initial: "flex", sm: "none" }}>
+          <Flex align="center">
             <IconButton variant="ghost" color="gray" className="hamburger">
               <Cross1Icon data-expanded />
               <HamburgerMenuIcon data-closed />
@@ -200,11 +165,10 @@ const strings = getStrings(locale);
         </Flex>
       </Flex>
 
-      <Flex
-        direction="column"
+      <Grid
         data-expanded
+        columns="repeat(auto-fill, minmax(30rem, 1fr))"
         gap="3"
-        display={{ initial: "flex", sm: "none" }}
       >
         {
           toolsFiltered.map((tool) => {
@@ -229,7 +193,7 @@ const strings = getStrings(locale);
                   }}
                 >
                   <Flex
-                    py="4"
+                    p="6"
                     justify="end"
                     flexGrow="1"
                     style={{
@@ -243,7 +207,7 @@ const strings = getStrings(locale);
             );
           })
         }
-      </Flex>
+      </Grid>
     </Flex>
   </Flex>
 

packages/website/src/components/StupidCat.tsx

@@ -1,3 +0,0 @@
-export function StupidCat() {
-  return <img src="https://i.imgur.com/6FBBzb9.png" />;
-}

packages/website/src/components/TankSearch/components/Card.tsx

@@ -1,7 +1,7 @@
 import {
   normalizeBoundingBox,
   resolveDpm,
-  unionBoundingBox,
+  tankBoundingBox,
   type TankDefinition,
 } from "@blitzkit/core";
 import { useMemo } from "react";
@@ -112,10 +112,7 @@ export function TankSearchCard({ tank, onSelect }: TankSearchCardProps) {
         return (tank.camouflage_still * gun.camouflage_loss * 100).toFixed(0);
       case "survivability.volume": {
         const dimensions = normalizeBoundingBox(
-          unionBoundingBox(
-            tankModelDefinition.bounding_box!,
-            turretModelDefinition.bounding_box!,
-          ),
+          tankBoundingBox(tankModelDefinition, turretModelDefinition),
         );
 
         return (dimensions.x * dimensions.y * dimensions.z).toFixed(0);
@@ -123,10 +120,7 @@ export function TankSearchCard({ tank, onSelect }: TankSearchCardProps) {
 
       case "survivability.length": {
         const bounds = normalizeBoundingBox(
-          unionBoundingBox(
-            tankModelDefinition.bounding_box!,
-            turretModelDefinition.bounding_box!,
-          ),
+          tankBoundingBox(tankModelDefinition, turretModelDefinition),
         );
 
         return Math.max(bounds.x, bounds.y, bounds.z).toFixed(0);

packages/website/src/components/TankSearch/index.tsx

@@ -3,7 +3,7 @@ import {
   normalizeBoundingBox,
   resolveDpm,
   SEARCH_KEYS,
-  unionBoundingBox,
+  tankBoundingBox,
   type TankDefinition,
 } from "@blitzkit/core";
 import { literals } from "@blitzkit/i18n/src/literals";
@@ -137,16 +137,10 @@ export const TankSearch = memo<TankSearchProps>(
               const bTurretModelDefinition =
                 bTankModelDefinition.turrets[b.turrets.at(-1)!.id];
               const aSize = normalizeBoundingBox(
-                unionBoundingBox(
-                  aTankModelDefinition.bounding_box!,
-                  aTurretModelDefinition.bounding_box!,
-                ),
+                tankBoundingBox(aTankModelDefinition, aTurretModelDefinition),
               );
               const bSize = normalizeBoundingBox(
-                unionBoundingBox(
-                  bTankModelDefinition.bounding_box!,
-                  bTurretModelDefinition.bounding_box!,
-                ),
+                tankBoundingBox(bTankModelDefinition, bTurretModelDefinition),
               );
               const aVolume = aSize.x * aSize.y * aSize.z;
               const bVolume = bSize.x * bSize.y * bSize.z;
@@ -164,16 +158,10 @@ export const TankSearch = memo<TankSearchProps>(
               const bTurretModelDefinition =
                 bTankModelDefinition.turrets[b.turrets.at(-1)!.id];
               const aSize = normalizeBoundingBox(
-                unionBoundingBox(
-                  aTankModelDefinition.bounding_box!,
-                  aTurretModelDefinition.bounding_box!,
-                ),
+                tankBoundingBox(aTankModelDefinition, aTurretModelDefinition),
               );
               const bSize = normalizeBoundingBox(
-                unionBoundingBox(
-                  bTankModelDefinition.bounding_box!,
-                  bTurretModelDefinition.bounding_box!,
-                ),
+                tankBoundingBox(bTankModelDefinition, bTurretModelDefinition),
               );
               const aLength = Math.max(aSize.x, aSize.y, aSize.z);
               const bLength = Math.max(bSize.x, bSize.y, bSize.z);

packages/website/src/components/Tankopedia/CharacteristicsSection/components/Characteristics/components/GunFlexibilityVisualizer/index.tsx

@@ -44,7 +44,9 @@ export function GunFlexibilityVisualizer({
   const tank = Duel.use((state) => state.protagonist.tank);
   const turret = Duel.use((state) => state.protagonist.turret);
   const gun = Duel.use((state) => state.protagonist.gun);
-  const modelRequested = Tankopedia.use((state) => state.modelRequested);
+  const modelRequested = Tankopedia.use(
+    (state) => state.loaders.model.requested,
+  );
 
   const tankModel = modelDefinition.models[tank.id];
   const turretModel = tankModel.turrets[turret.id];

packages/website/src/components/Tankopedia/CharacteristicsSection/components/Characteristics/components/InfoWithDelta.tsx

@@ -1,5 +1,5 @@
 import { createDefaultSkills } from "@blitzkit/core";
-import { Flex, Progress, Text } from "@radix-ui/themes";
+import { Box, Flex, Progress, Text } from "@radix-ui/themes";
 import { clamp } from "lodash-es";
 import { memo, useMemo, type ComponentProps, type ReactNode } from "react";
 import { api } from "../../../../../../core/blitzkit/api";
@@ -16,6 +16,7 @@ import {
   TankopediaRelativeAgainst,
 } from "../../../../../../stores/tankopedia";
 import { Info, type InfoProps } from "./Info";
+import { StatScale } from "./StatScale";
 
 type InfoWithDeltaProps = Omit<InfoProps, "name"> & {
   stats: TankCharacteristics;
@@ -122,6 +123,15 @@ export const InfoWithDelta = memo<InfoWithDeltaProps>(
           return othersValue !== undefined;
         }) as TankCharacteristics[];
     }, [relativeAgainst, shellIndex, equipmentMatrix, equalize]);
+    const values = useMemo(
+      () =>
+        others.map((tank) =>
+          typeof props.value === "function"
+            ? props.value(tank)!
+            : (tank[props.value] as number),
+        ),
+      [others],
+    );
     const betterTanks = others.filter((tank) => {
       const othersValue =
         typeof props.value === "function"
@@ -161,13 +171,25 @@ export const InfoWithDelta = memo<InfoWithDeltaProps>(
 
         {!noRanking && (
           <Flex pl={indent ? "2" : "0"} align="center" gap="2">
-            <Progress
-              variant="soft"
-              size="1"
-              value={goodness * 100}
-              color={color}
-              style={{ height: "0.125rem", opacity: 0.5 }}
-            />
+            <Box position="relative" flexGrow="1">
+              <StatScale
+                values={values}
+                value={uhWhatDoICallThisVariable}
+                lowerIsBetter={deltaType === "lowerIsBetter"}
+              />
+
+              <Progress
+                variant="soft"
+                size="1"
+                value={goodness * 100}
+                color={color}
+                style={{
+                  position: "relative",
+                  height: "0.125rem",
+                  opacity: 0.75,
+                }}
+              />
+            </Box>
 
             <Text color="gray" size="1">
               {clamp(betterTanks.length + 1, 1, others.length)} /{" "}

packages/website/src/components/Tankopedia/CharacteristicsSection/components/Characteristics/components/StatScale.tsx

@@ -0,0 +1,91 @@
+import { memo, useEffect, useMemo, useRef } from "react";
+
+const RESOLUTION = 1000;
+const HEIGHT = 8;
+const DENSE_TICKS = 100;
+
+interface StatScaleProps {
+  values: number[];
+  value: number;
+  lowerIsBetter?: boolean;
+}
+
+export const StatScale = memo<StatScaleProps>(
+  ({ values, value, lowerIsBetter }) => {
+    const canvasRef = useRef<HTMLCanvasElement>(null);
+    const ticks = useMemo(() => {
+      const min = Math.min(value, ...values);
+      const max = Math.max(value, ...values);
+      const range = max - min;
+      const positions = new Set<number>();
+
+      for (const other of values) {
+        const raw = range === 0 ? 0.5 : (other - min) / range;
+        const x = Math.round((lowerIsBetter ? 1 - raw : raw) * RESOLUTION);
+
+        if (x === 0 || x === RESOLUTION) continue;
+
+        positions.add(x);
+      }
+
+      return Array.from(positions, (x) => ({ x }));
+    }, [values, value, lowerIsBetter]);
+
+    useEffect(() => {
+      const canvas = canvasRef.current;
+      if (!canvas) return;
+
+      const draw = () => {
+        const { width } = canvas.getBoundingClientRect();
+        const pixelRatio = window.devicePixelRatio || 1;
+        const canvasWidth = Math.ceil(width * pixelRatio);
+        const canvasHeight = Math.ceil(HEIGHT * pixelRatio);
+
+        if (canvas.width !== canvasWidth || canvas.height !== canvasHeight) {
+          canvas.width = canvasWidth;
+          canvas.height = canvasHeight;
+        }
+
+        const context = canvas.getContext("2d");
+        if (!context) return;
+
+        context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+        context.clearRect(0, 0, width, HEIGHT);
+
+        const styles = getComputedStyle(canvas);
+        for (const { x } of ticks) {
+          context.fillStyle = styles.getPropertyValue("--gray-a6").trim();
+          context.fillRect((x / RESOLUTION) * width, 0, 1, HEIGHT);
+        }
+      };
+
+      const observer = new ResizeObserver(draw);
+      observer.observe(canvas);
+      window.addEventListener("resize", draw);
+      draw();
+
+      return () => {
+        observer.disconnect();
+        window.removeEventListener("resize", draw);
+      };
+    }, [ticks]);
+
+    return (
+      <canvas
+        ref={canvasRef}
+        aria-hidden="true"
+        style={{
+          position: "absolute",
+          top: 0,
+          bottom: 0,
+          left: 0,
+          width: "100%",
+          height: HEIGHT,
+          margin: "auto 0",
+          opacity: Math.min(1, Math.sqrt(DENSE_TICKS / ticks.length)),
+          pointerEvents: "none",
+        }}
+      />
+    );
+  },
+);

packages/website/src/components/Tankopedia/HeroSection/components/Options/components/SidebarIconButton.tsx

@@ -0,0 +1,44 @@
+import { Flex, IconButton, type FlexProps } from "@radix-ui/themes";
+import type { ComponentProps, CSSProperties } from "react";
+
+type SidebarIconButtonProps = ComponentProps<typeof IconButton> & {
+  selected: boolean;
+  src: string;
+  alt: string;
+  imageStyle?: CSSProperties;
+};
+
+export function SidebarIconGroup({ style, ...props }: FlexProps) {
+  return (
+    <Flex
+      direction="column"
+      overflow="hidden"
+      style={{ borderRadius: "var(--radius-full)", ...style }}
+      {...props}
+    />
+  );
+}
+
+export function SidebarIconButton({
+  selected,
+  src,
+  alt,
+  imageStyle,
+  ...props
+}: SidebarIconButtonProps) {
+  return (
+    <IconButton
+      color={selected ? undefined : "gray"}
+      variant="soft"
+      size={{ initial: "2", sm: "3" }}
+      radius="none"
+      {...props}
+    >
+      <img
+        alt={alt}
+        src={src}
+        style={{ width: "50%", height: "50%", ...imageStyle }}
+      />
+    </IconButton>
+  );
+}

packages/website/src/components/Tankopedia/HeroSection/components/Options/components/SkinSwitcher.tsx

@@ -0,0 +1,106 @@
+import { alias } from "@blitzkit/core";
+import { Flex, Tooltip } from "@radix-ui/themes";
+import { uniqBy } from "lodash-es";
+import { SKIN_NUMBER } from "../../../../../../constants/skinNumber";
+import { api } from "../../../../../../core/blitzkit/api";
+import { useLocale } from "../../../../../../hooks/useLocale";
+import { Duel } from "../../../../../../stores/duel";
+import { Tankopedia } from "../../../../../../stores/tankopedia";
+import { TankopediaDisplay } from "../../../../../../stores/tankopediaPersistent/constants";
+import { SidebarIconButton } from "./SidebarIconButton";
+
+const camouflageDefinitions = await api.camouflageDefinitions();
+
+export function SkinSwitcher() {
+  const tank = Duel.use((state) => state.protagonist.tank);
+  const skin = Tankopedia.use((state) => state.loaders.skin.requested);
+  const attachment = Tankopedia.use(
+    (state) => state.loaders.attachment.requested,
+  );
+  const requestedDisplay = Tankopedia.use((state) => state.requestedDisplay);
+  const disturbed = Tankopedia.use((state) => state.disturbed);
+  const { unwrap } = useLocale();
+  const skins = uniqBy(
+    Object.values(camouflageDefinitions.camouflages).filter(
+      (camouflage) => camouflage.tank_id === tank.id,
+    ),
+    (camouflage) => unwrap(camouflage.name!),
+  );
+
+  // attachments aren't camouflages so they get their own group
+  const groups = [
+    skins.filter((camouflage) => !camouflage.attachment),
+    skins.filter((camouflage) => camouflage.attachment),
+  ].filter((group) => group.length > 0);
+
+  if (skins.length === 0) return null;
+
+  return (
+    <Flex
+      direction="column"
+      gap="3"
+      top="50%"
+      right={
+        disturbed && requestedDisplay === TankopediaDisplay.Model
+          ? "3"
+          : "-4rem"
+      }
+      style={{
+        position: "absolute",
+        transform: "translateY(-50%)",
+        transitionDuration: "200ms",
+        pointerEvents: "auto",
+      }}
+    >
+      {groups.map((group) => (
+        <Flex key={group[0].id} direction="column">
+          {group.map((camouflage, index) => {
+            const name = unwrap(camouflage.name!).replace(
+              "%(camo_num)",
+              SKIN_NUMBER,
+            );
+            const top = index === 0 ? "var(--radius-full)" : "0";
+            const bottom =
+              index === group.length - 1 ? "var(--radius-full)" : "0";
+
+            return (
+              <Tooltip key={camouflage.id} content={name} side="left">
+                <SidebarIconButton
+                  selected={
+                    (camouflage.attachment ? attachment : skin) ===
+                    camouflage.id
+                  }
+                  alt={name}
+                  src={alias("api", `/icons/camouflages/${camouflage.id}.webp`)}
+                  size={{ initial: "3", sm: "4" }}
+                  radius="full"
+                  style={{
+                    borderRadius: `${top} ${top} ${bottom} ${bottom}`,
+                  }}
+                  imageStyle={{
+                    width: "70%",
+                    height: "70%",
+                    borderRadius: "50%",
+                  }}
+                  onClick={() => {
+                    Tankopedia.mutate((draft) => {
+                      const loader =
+                        draft.loaders[
+                          camouflage.attachment ? "attachment" : "skin"
+                        ];
+
+                      loader.requested =
+                        loader.requested === camouflage.id
+                          ? undefined
+                          : camouflage.id;
+                    });
+                  }}
+                />
+              </Tooltip>
+            );
+          })}
+        </Flex>
+      ))}
+    </Flex>
+  );
+}

packages/website/src/components/Tankopedia/HeroSection/components/Options/index.tsx

@@ -46,6 +46,11 @@ import { TankSearch } from "../../../../TankSearch";
 import { CustomShellButton } from "./components/CustomShellButton";
 import { DynamicArmorSwitcher } from "./components/DynamicArmorSwitcher";
 import { QuickInputs } from "./components/QuickInputs";
+import {
+  SidebarIconButton,
+  SidebarIconGroup,
+} from "./components/SidebarIconButton";
+import { SkinSwitcher } from "./components/SkinSwitcher";
 import { SpallLinerSwitcher } from "./components/SpallLinerSwitcher";
 import { Thicknesses } from "./components/Thicknesses";
 
@@ -77,7 +82,9 @@ export function Options({ thicknessRange, canvas, skeleton }: OptionsProps) {
   const revealed = Tankopedia.use((state) => state.revealed);
   const disturbed = Tankopedia.use((state) => state.disturbed);
   const highGraphics = TankopediaPersistent.use((state) => state.highGraphics);
-  const modelRequested = Tankopedia.use((state) => state.modelRequested);
+  const modelRequested = Tankopedia.use(
+    (state) => state.loaders.model.requested,
+  );
   const equalize = Duel.use((state) => state.equalize);
   const equalizer = Duel.use((state) => state.antagonist.tank.equalizer);
 
@@ -87,6 +94,8 @@ export function Options({ thicknessRange, canvas, skeleton }: OptionsProps) {
 
       <Thicknesses skeleton={skeleton} thicknessRange={thicknessRange} />
 
+      <SkinSwitcher />
+
       <Flex
         gap="2"
         direction="column"
@@ -181,24 +190,13 @@ export function Options({ thicknessRange, canvas, skeleton }: OptionsProps) {
           </Popover.Root>
         )}
 
-        <Flex
-          direction="column"
-          style={{
-            borderRadius: "var(--radius-full)",
-          }}
-          overflow="hidden"
-        >
+        <SidebarIconGroup>
           {antagonistGun.shells.map((thisShell) => (
-            <IconButton
-              color={
-                thisShell.id === antagonistShell.id && !hasCustomShell
-                  ? undefined
-                  : "gray"
-              }
-              variant="soft"
+            <SidebarIconButton
               key={thisShell.id}
-              size={{ initial: "2", sm: "3" }}
-              radius="none"
+              selected={thisShell.id === antagonistShell.id && !hasCustomShell}
+              alt={unwrap(thisShell.name!)}
+              src={alias("api", `/icons/shells/${thisShell.icon}.webp`)}
               onClick={() => {
                 Duel.mutate((draft) => {
                   draft.antagonist.shell = thisShell;
@@ -208,19 +206,10 @@ export function Options({ thicknessRange, canvas, skeleton }: OptionsProps) {
                   draft.customShell = undefined;
                 });
               }}
-            >
-              <img
-                alt={unwrap(thisShell.name!)}
-                src={alias("api", `/icons/shells/${thisShell.icon}.webp`)}
-                style={{
-                  width: "50%",
-                  height: "50%",
-                }}
-              />
-            </IconButton>
+            />
           ))}
           <CustomShellButton />
-        </Flex>
+        </SidebarIconGroup>
 
         <Flex
           direction="column"

packages/website/src/components/Tankopedia/HeroSection/components/TankSandbox/Title/index.tsx

@@ -1,30 +1,53 @@
 import { UpdateIcon } from "@radix-ui/react-icons";
 import { Button, Flex, Heading } from "@radix-ui/themes";
+import { useEffect, useRef } from "react";
+import { SKIN_NUMBER } from "../../../../../../constants/skinNumber";
+import { api } from "../../../../../../core/blitzkit/api";
 import { useLocale } from "../../../../../../hooks/useLocale";
 import { Duel } from "../../../../../../stores/duel";
 import { Tankopedia } from "../../../../../../stores/tankopedia";
 import type { MaybeSkeletonComponentProps } from "../../../../../../types/maybeSkeletonComponentProps";
 import { Tracker } from "./components/Tracker";
 
+const camouflageDefinitions = await api.camouflageDefinitions();
+
 export function Title({ skeleton }: MaybeSkeletonComponentProps) {
   const { unwrap, strings } = useLocale();
-  const modelRequested = Tankopedia.use((state) => state.modelRequested);
+  const modelRequested = Tankopedia.use(
+    (state) => state.loaders.model.requested,
+  );
   const protagonist = Duel.use((state) => state.protagonist.tank);
   const revealed = Tankopedia.use((state) => state.revealed);
   const disturbed = Tankopedia.use((state) => state.disturbed);
-  const name = unwrap(protagonist.name!);
+  const hasRevealed = useRef(false);
+  const skin = Tankopedia.use((state) => state.loaders.skin.requested);
+  const camouflage =
+    skin === undefined ? undefined : camouflageDefinitions.camouflages[skin];
+  const tankName = unwrap(protagonist.name!);
+  // legendary camos carry the tank's in-battle name
+  const name = (
+    camouflage
+      ? camouflage.tank_name
+        ? unwrap(camouflage.tank_name)
+        : `${tankName} ${unwrap(camouflage.name!)}`
+      : tankName
+  ).replace("%(camo_num)", SKIN_NUMBER);
   const fontSize = revealed
     ? disturbed
       ? "1.5rem"
       : "2rem"
     : `min(12vh, ${75 / name.length}vw)`;
 
+  useEffect(() => {
+    if (revealed) hasRevealed.current = true;
+  }, [revealed]);
+
   return (
     <Flex
       onPointerDown={(event) => {
         event.preventDefault();
 
-        if (!modelRequested) return;
+        if (!modelRequested || hasRevealed.current) return;
 
         Tankopedia.mutate((draft) => {
           draft.revealed = true;
@@ -86,7 +109,7 @@ export function Title({ skeleton }: MaybeSkeletonComponentProps) {
             onPointerDown={(event) => event.stopPropagation()}
             onClick={() => {
               Tankopedia.mutate((draft) => {
-                draft.modelRequested = true;
+                draft.loaders.model.requested = true;
               });
             }}
           >

packages/website/src/components/Tankopedia/HeroSection/components/TankSandbox/components/Lighting.tsx

@@ -18,7 +18,7 @@ import { TankopediaDisplay } from "../../../../../../stores/tankopediaPersistent
 
 const ANGLE = degToRad(15);
 const REVEAL_ANIMATION_TIME = 3;
-const TRANSITION_ANIMATION_TIME = 0.5;
+export const TRANSITION_ANIMATION_TIME = 0.5;
 
 const LIGHTS_COUNT = 3;
 const THETA_OFFSET = degToRad(180 - 45);
@@ -46,17 +46,26 @@ export function Lighting({ hasPbr }: Props) {
 
   const highGraphics = TankopediaPersistent.use((state) => state.highGraphics);
   const requestedDisplay = Tankopedia.use((state) => state.requestedDisplay);
+  const revealed = Tankopedia.use((state) => state.revealed);
+  const skinPending = Tankopedia.use(
+    (state) =>
+      state.loaders.skin.requested !== state.loaders.skin.loaded ||
+      state.loaders.attachment.requested !== state.loaders.attachment.loaded,
+  );
 
   const animationTime = useRef(REVEAL_ANIMATION_TIME);
   const t0 = useRef(performance.now() / 1e3 - animationTime.current);
+  const holding = useRef(false);
 
   const isRevealing = useRef(true);
+  const isFirstReveal = useRef(true);
 
   const [animate, setAnimate] = useState(true);
 
   useEffect(() => {
     Tankopedia.mutate((draft) => {
       draft.revealed = true;
+      draft.loaders.model.loaded = true;
     });
   }, []);
 
@@ -71,6 +80,37 @@ export function Lighting({ hasPbr }: Props) {
     setAnimate(true);
   }, [requestedDisplay]);
 
+  useEffect(() => {
+    if (isFirstReveal.current) {
+      isFirstReveal.current = false;
+      return;
+    }
+
+    if (!revealed) {
+      animationTime.current = TRANSITION_ANIMATION_TIME;
+      t0.current = performance.now() / 1e3;
+      holding.current = true;
+    } else if (holding.current) {
+      animationTime.current = REVEAL_ANIMATION_TIME;
+      t0.current = performance.now() / 1e3 - animationTime.current;
+      holding.current = false;
+    } else {
+      return;
+    }
+
+    setAnimate(true);
+    invalidate();
+  }, [revealed]);
+
+  useEffect(() => {
+    if (!skinPending) return;
+
+    animationTime.current = TRANSITION_ANIMATION_TIME;
+    t0.current = performance.now() / 1e3;
+
+    setAnimate(true);
+  }, [skinPending]);
+
   return (
     <>
       <ContactShadows
@@ -90,6 +130,7 @@ export function Lighting({ hasPbr }: Props) {
           hasPbr={hasPbr}
           t0={t0}
           animationTime={animationTime}
+          holding={holding}
           wrapper={wrapper}
           stop={() => {
             setAnimate(false);
@@ -124,6 +165,7 @@ export function Lighting({ hasPbr }: Props) {
               key={index}
               position={position}
               intensity={intensity}
+              userData={{ intensity }}
               penumbra={1}
               castShadow={highGraphics}
               decay={1}
@@ -145,11 +187,19 @@ interface AnimatorProps {
 
   t0: RefObject<number>;
   animationTime: RefObject<number>;
+  holding: RefObject<boolean>;
   wrapper: RefObject<Group | null>;
   hasPbr: boolean;
 }
 
-function Animator({ stop, t0, animationTime, wrapper, hasPbr }: AnimatorProps) {
+function Animator({
+  stop,
+  t0,
+  animationTime,
+  holding,
+  wrapper,
+  hasPbr,
+}: AnimatorProps) {
   const requestedDisplay = Tankopedia.use((state) => state.requestedDisplay);
   const display = Tankopedia.use((state) => state.display);
 
@@ -166,6 +216,11 @@ function Animator({ stop, t0, animationTime, wrapper, hasPbr }: AnimatorProps) {
     for (const child of wrapper.current.children) {
       if (child instanceof SpotLight) {
         child.angle = ANGLE * t * factor;
+        child.intensity = child.userData.intensity;
+
+        if (child.angle === 0) {
+          child.intensity = 0;
+        }
       } else if (child instanceof HemisphereLight) {
         child.intensity = HEMISPHERE_INTENSITY * t * factor;
       }
@@ -176,7 +231,7 @@ function Animator({ stop, t0, animationTime, wrapper, hasPbr }: AnimatorProps) {
 
   useFrame(({ invalidate }) => {
     const dt = performance.now() / 1e3 - t0.current;
-    const x = clamp(dt / animationTime.current, 0, 2);
+    const x = clamp(dt / animationTime.current, 0, holding.current ? 1 : 2);
 
     if (x === 2) {
       apply(1);
@@ -188,6 +243,9 @@ function Animator({ stop, t0, animationTime, wrapper, hasPbr }: AnimatorProps) {
     const t = (0.5 * Math.sin(Math.PI * (x + 0.5)) + 0.5) ** 2;
 
     apply(t);
+
+    if (holding.current && x === 1) return;
+
     invalidate();
 
     if (x >= 1 && Tankopedia.state.display !== requestedDisplay) {

packages/website/src/components/Tankopedia/HeroSection/components/TankSandbox/components/TankModel.tsx

@@ -1,18 +1,21 @@
 import { invalidate, useThree, type ThreeEvent } from "@react-three/fiber";
-import { useRef } from "react";
+import type { QuicklimeEvent } from "quicklime";
+import { useEffect, useRef } from "react";
 import { Group, Mesh, MeshStandardMaterial, Vector2 } from "three";
 import { applyPitchYawLimits } from "../../../../../../core/blitz/applyPitchYawLimits";
 import { hasEquipment } from "../../../../../../core/blitzkit/hasEquipment";
-import { jsxTree } from "../../../../../../core/blitzkit/jsxTree";
 import { modelTransformEvent } from "../../../../../../core/blitzkit/modelTransform";
+import { skinTree } from "../../../../../../core/blitzkit/skinTree";
 import { controlsEnabledEvent } from "../../../../../../core/controlsEnabled";
 import { useModel } from "../../../../../../hooks/useModel";
+import { useSkin } from "../../../../../../hooks/useSkin";
 import { useTankModelDefinition } from "../../../../../../hooks/useTankModelDefinition";
 import { useTankTransform } from "../../../../../../hooks/useTankTransform";
 import { Duel } from "../../../../../../stores/duel";
 import { Tankopedia } from "../../../../../../stores/tankopedia";
 import { TankopediaDisplay } from "../../../../../../stores/tankopediaPersistent/constants";
 import { ModelTankWrapper } from "../../../../../Armor/components/ModelTankWrapper";
+import { transitionEvent } from "./Lighting";
 
 export function TankModel() {
   const protagonist = Duel.use((draft) => draft.protagonist);
@@ -28,9 +31,46 @@ export function TankModel() {
   const gunModelDefinition = turretModelDefinition.guns[protagonist.gun.id];
   const { gltf } = useModel(protagonist.tank.id);
   const nodes = Object.values(gltf.nodes);
+  const skinGltf = useSkin(protagonist.tank.id);
+  const attachmentGltf = useSkin(protagonist.tank.id, "attachment");
+  const skins = [skinGltf, attachmentGltf].filter((skin) => skin !== undefined);
 
   useTankTransform(track, turret, turretContainer, gunContainer);
 
+  useEffect(() => {
+    const emissiveMaterials = new Set<MeshStandardMaterial>();
+
+    for (const scene of [gltf.scene, ...skins.map((skin) => skin.scene)]) {
+      scene.traverse((object) => {
+        if (
+          object instanceof Mesh &&
+          object.material instanceof MeshStandardMaterial &&
+          object.material.emissiveMap
+        ) {
+          emissiveMaterials.add(object.material);
+        }
+      });
+    }
+
+    // emissive parts fade with the lights instead of glowing in the dark
+    function applyIntensity(intensity: number) {
+      for (const material of emissiveMaterials) {
+        material.emissiveIntensity = intensity;
+      }
+    }
+
+    function handleTransitionEvent(event: QuicklimeEvent<number>) {
+      applyIntensity(event.data);
+    }
+
+    applyIntensity(transitionEvent.last!);
+    transitionEvent.on(handleTransitionEvent);
+
+    return () => {
+      transitionEvent.off(handleTransitionEvent);
+    };
+  }, [gltf, skinGltf, attachmentGltf]);
+
   return (
     <ModelTankWrapper ref={hullContainer}>
       {nodes.map((node) => {
@@ -92,7 +132,7 @@ export function TankModel() {
           window.removeEventListener("pointerup", handlePointerUp);
         }
 
-        return jsxTree(node, {
+        return skinTree(node, skins, {
           mesh(_, props, key) {
             return (
               <mesh
@@ -169,7 +209,7 @@ export function TankModel() {
             window.removeEventListener("pointerup", handlePointerUp);
           }
 
-          return jsxTree(node, {
+          return skinTree(node, skins, {
             mesh(_, props, key) {
               return (
                 <mesh
@@ -250,7 +290,7 @@ export function TankModel() {
               window.removeEventListener("pointerup", handlePointerUp);
             }
 
-            return jsxTree(node, {
+            return skinTree(node, skins, {
               mesh(_, props, key) {
                 return (
                   <mesh

packages/website/src/components/Tankopedia/HeroSection/index.tsx

@@ -20,7 +20,9 @@ export function HeroSection({ skeleton }: MaybeSkeletonComponentProps) {
   const canvas = useRef<HTMLCanvasElement>(null!);
   const isFullScreen = useFullScreen();
   const protagonist = Duel.use((state) => state.protagonist.tank);
-  const modelRequested = Tankopedia.use((state) => state.modelRequested);
+  const modelRequested = Tankopedia.use(
+    (state) => state.loaders.model.requested,
+  );
   const thicknessRange = useMemo(() => {
     const entries = Object.values(tankDefinitions.tanks);
     const filtered = entries.filter(

packages/website/src/config/credits.ts

@@ -0,0 +1,102 @@
+interface CreditPeople {
+  name: string;
+  description: string;
+  url?: string;
+  image: string;
+}
+
+export const credits: CreditPeople[] = [
+  {
+    name: "TrèsAbhi",
+    description: "Founder and lead developer",
+    url: "https://abhi-deep.com/",
+    image: "https://github.com/tresabhi.png",
+  },
+  {
+    name: "HitJack",
+    description: "Developer on website",
+    url: "https://marksstuff.com",
+    image: "https://github.com/Hitjack007.png",
+  },
+  {
+    name: "aeson000",
+    description: "Advisor on game and website",
+    url: "https://discord.gg/WHdER7ZPAD",
+    image: "/media/users/aeson000.png",
+  },
+  {
+    name: "GonnaHetzMe",
+    description: "Developer and advisor on back end",
+    url: "https://github.com/karelpak1",
+    image: "https://github.com/karelpak1.png",
+  },
+  {
+    name: "ChickenMan7777",
+    description: "Moderator and former advisor on game mechanics",
+    url: "https://discord.gg/rEsUbXCqD9",
+    image: "/media/users/chickenman7777.webp",
+  },
+  {
+    name: "Avenir",
+    description: "Moderator and elite Advanced Recon Commando",
+    image: "/media/users/avenir.webp",
+  },
+  {
+    name: "Pyogenics",
+    description: "Former advisor on game 3D format",
+    url: "https://github.com/Pyogenics",
+    image: "https://github.com/Pyogenics.png",
+  },
+  {
+    name: "Prince_NA",
+    description: "Former advisor on bot and website",
+    image: "/media/users/prince-na.webp",
+  },
+  {
+    name: "Vovko",
+    description: "Former advisor on bot",
+    url: "https://amth.one/",
+    image: "https://github.com/cufee.png",
+  },
+  {
+    name: "S0AP",
+    description: "Former advisor on and advertiser for bot",
+    url: "https://discord.gg/3KfH93um3Y",
+    image: "/media/users/s0ap.webp",
+  },
+  {
+    name: "Synx",
+    description: "Former advisor on bot and website",
+    url: "https://www.youtube.com/@Synx_Blitz",
+    image: "/media/users/synx.webp",
+  },
+  {
+    name: "34wotb",
+    description: "Former advisor on bot",
+    url: "https://www.twitch.tv/34wotb/",
+    image: "/media/users/34wotb.jpg",
+  },
+  {
+    name: "HisRoyalFatness",
+    description: "Former advisor on website",
+    url: "https://www.youtube.com/@hisroyalfatness",
+    image: "/media/users/hisroyalfatness.jpg",
+  },
+  {
+    name: "Minitelrose",
+    description: "Former advisor on game mechanics",
+    url: "https://wotinspector.com/",
+    image: "/media/users/minitelrose.webp",
+  },
+  {
+    name: "Maddox",
+    description: "Game asset decompression",
+    url: "https://github.com/Maddoxkkm",
+    image: "https://github.com/Maddoxkkm.png",
+  },
+  {
+    name: "TJ Duff",
+    description: "Chief executive cheer leader",
+    image: "/media/users/tj-duff.jpg",
+  },
+];

packages/website/src/config/donations.ts

@@ -0,0 +1,23 @@
+// TODO: source this from the open collective api, if even possible
+export const donationTiers = [
+  {
+    name: "The Backer",
+    value: 5,
+    link: "https://opencollective.com/blitzkit/contribute/backers-106312/checkout",
+  },
+  {
+    name: "The Engineer",
+    value: 10,
+    link: "https://opencollective.com/blitzkit/contribute/the-engineer-107057/checkout",
+  },
+  {
+    name: "The Patron",
+    value: 25,
+    link: "https://opencollective.com/blitzkit/contribute/the-patron-107056/checkout",
+  },
+  {
+    name: "The Sponsor",
+    value: null,
+    link: "https://opencollective.com/blitzkit/donate",
+  },
+];

packages/website/src/constants/skinNumber.ts

@@ -0,0 +1 @@
+export const SKIN_NUMBER = "0417";

packages/website/src/constants/tools.ts

@@ -74,4 +74,8 @@ export const tools: Record<string, Tool> = {
     href: "https://discord.gg/nDt7AjGJQH",
     button: "plum",
   },
+  credits: {
+    id: "credits",
+    button: "bronze",
+  },
 };

packages/website/src/core/blitzkit/docImages.ts

@@ -0,0 +1,32 @@
+import { alias } from "@blitzkit/core";
+
+const EXTERNAL_IMAGE = /^https?:\/\//;
+const MARKDOWN_IMAGES = [
+  /!\[[^\]]*\]\((\S+?)(?:\s+"[^"]*")?\)/g,
+  /<img[^>]*\ssrc=["']([^"']+)["']/g,
+];
+
+export function isExternalImage(src: string) {
+  return EXTERNAL_IMAGE.test(src);
+}
+
+export function docImageId(url: string) {
+  let hash = 0x811c9dc5;
+
+  for (let index = 0; index < url.length; index++) {
+    hash ^= url.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+
+  return hash.toString(16).padStart(8, "0");
+}
+
+export function docImageUrl(url: string) {
+  return alias("api", `/docs/images/${docImageId(url)}.webp`);
+}
+
+export function externalDocImages(markdown: string) {
+  return MARKDOWN_IMAGES.flatMap((pattern) =>
+    Array.from(markdown.matchAll(pattern), (match) => match[1]),
+  ).filter(isExternalImage);
+}

packages/website/src/core/blitzkit/jsxTree.tsx

@@ -1,5 +1,5 @@
 import type { ComponentProps, ReactNode } from "react";
-import { Mesh, MeshStandardMaterial, Object3D } from "three";
+import { AdditiveBlending, Mesh, MeshStandardMaterial, Object3D } from "three";
 
 export function jsxTree(
   node: Object3D,
@@ -27,6 +27,10 @@ export function jsxTree(
 
     if (props.material instanceof MeshStandardMaterial) {
       props.material.depthWrite = true;
+
+      if (props.material.userData.blending === "additive") {
+        props.material.blending = AdditiveBlending;
+      }
     }
 
     return mergers?.mesh ? (

packages/website/src/core/blitzkit/skinTree.tsx

@@ -0,0 +1,79 @@
+import type { Material, Object3D } from "three";
+import type { Skin } from "../../hooks/useSkin";
+import { jsxTree } from "./jsxTree";
+
+type Mergers = Parameters<typeof jsxTree>[1];
+
+// names get sanitized and made unique on load
+function nameOf(object3d: Object3D): string {
+  return object3d.userData.name ?? object3d.name;
+}
+
+/**
+ * skins are layered in order, so an attachment's states win over the
+ * camouflage's
+ */
+export function skinTree(node: Object3D, skins: Skin[], mergers: Mergers) {
+  const skinNodes = new Map<string, Object3D[]>();
+  const materials = new Map<string, Material>();
+  const states: Record<string, string | null> = {};
+
+  for (const skin of skins) {
+    for (const node of skin.scene.children) {
+      skinNodes.set(node.name, [...(skinNodes.get(node.name) ?? []), node]);
+    }
+
+    for (const [name, material] of skin.materials) {
+      materials.set(name, material);
+    }
+
+    Object.assign(states, skin.scene.userData.states);
+  }
+
+  function switchChildren(object3d: Object3D, childMergers: Mergers) {
+    if (object3d.userData.state === undefined) return;
+
+    const name = nameOf(object3d);
+    const state = name in states ? states[name] : object3d.userData.state;
+
+    return object3d.children
+      .filter((child) => nameOf(child) === state)
+      .map((child) => jsxTree(child, childMergers));
+  }
+
+  const partMergers: Mergers = {
+    ...mergers,
+    group(object3d, props, key) {
+      return (
+        <group key={key} {...props}>
+          {switchChildren(object3d, partMergers) ?? props.children}
+        </group>
+      );
+    },
+  };
+  const skinMergers: Mergers = {
+    mesh(mesh, props, key) {
+      const material = materials.get((mesh.material as Material).name);
+
+      return mergers!.mesh!(
+        mesh,
+        material ? { ...props, material } : props,
+        key,
+      );
+    },
+    group(object3d, props, key) {
+      const parts = skinNodes.get(object3d.name) ?? [];
+
+      return (
+        <group key={key} {...props}>
+          {switchChildren(object3d, skinMergers) ?? props.children}
+          {parts.flatMap((part) =>
+            part.children.map((child) => jsxTree(child, partMergers)),
+          )}
+        </group>
+      );
+    },
+  };
+
+  return jsxTree(node, skinMergers);
+}

packages/website/src/core/blitzkit/switcherStates.ts

@@ -0,0 +1,255 @@
+import { parseHierarchies, type Sc2ReadStream } from "@blitzkit/core";
+import { times } from "lodash-es";
+
+interface Value {
+  "any.type": string;
+  "any.value": unknown;
+}
+
+interface ScriptNode {
+  type: string;
+  node: Record<string, unknown> & { defaults?: Record<string, Value> };
+  connections?: Record<
+    string,
+    { pinIn: string; pinOut: string; target: string }
+  >;
+}
+
+interface Script {
+  nodes: Record<string, ScriptNode>;
+}
+
+interface Action {
+  "act.delay": number;
+  "act.entityName": string;
+  "act.event": number;
+  "act.switchIndex": number;
+  "act.type": number;
+  "act.userEventId": string;
+}
+
+interface Entity {
+  name: string;
+  parent?: Entity;
+  children: Entity[];
+}
+
+const SELF_ENTITY = "*** Self ***";
+const SCENE_LOADED_EVENT = 1;
+const USER_EVENT = 2;
+const SWITCH_ACTIONS = [8, 9];
+// what the game fires as a tank is shown in the garage, in order
+const LOAD_EVENTS = ["Added", "TankAliveInHangar", "TankIsShownInNewScreen"];
+const MAX_DEPTH = 64;
+
+function findChild(entity: Entity, name: string): Entity | undefined {
+  for (const child of entity.children) {
+    if (child.name === name) return child;
+
+    const found = findChild(child, name);
+
+    if (found) return found;
+  }
+}
+
+function resolveTarget(owner: Entity, entityName: string) {
+  if (entityName === SELF_ENTITY) return owner;
+
+  const [first, ...rest] = entityName.split("->");
+  let target: Entity | undefined;
+
+  for (
+    let ancestor: Entity | undefined = owner;
+    ancestor && !target;
+    ancestor = ancestor.parent
+  ) {
+    target = ancestor.name === first ? ancestor : findChild(ancestor, first);
+  }
+
+  for (const name of rest) target = target && findChild(target, name);
+
+  return target;
+}
+
+/**
+ * replays what picks each state switcher's state as a tank is shown in the
+ * garage, with the camo's preset applied and its items attached; delayed
+ * actions are skipped so states stay as they are when the tank appears
+ */
+export function switcherStates(
+  sc2: ReturnType<Sc2ReadStream["sc2"]>,
+  preset: string | undefined,
+  attachments: Map<string, string[]>,
+) {
+  const scripts: Record<string, Script> = {};
+  const stateNames = new Map<Entity, string[]>();
+  const scenarios: { owner: Entity; script: Script }[] = [];
+  const actions: { owner: Entity; action: Action }[] = [];
+  const states: Record<string, string | null> = {};
+
+  function activateState(entity: Entity | undefined, state: number) {
+    const names = entity && stateNames.get(entity);
+
+    if (names) states[entity.name] = names[state] ?? null;
+  }
+
+  for (const component of Object.values(
+    sc2["#sceneComponents"] as unknown as Record<string, unknown>,
+  ) as { "comp.typename"?: string; "ssc.scripts"?: Record<string, Script> }[]) {
+    if (component?.["comp.typename"] !== "ScenarioSingletonComponent") continue;
+
+    Object.assign(scripts, component["ssc.scripts"]);
+  }
+
+  parseHierarchies<Entity>(
+    sc2["#hierarchy"],
+    { name: "", children: [] },
+    (hierarchy, components, parent) => {
+      const entity: Entity = { name: hierarchy.name, parent, children: [] };
+
+      parent.children.push(entity);
+
+      for (const item of attachments.get(hierarchy.name) ?? []) {
+        entity.children.push({ name: item, parent: entity, children: [] });
+      }
+
+      for (const component of components) {
+        switch (component["comp.typename"]) {
+          case "StateSwitcherComponent": {
+            const names = times(
+              component["ssc.statesCount"],
+              (index) => component[`ssc.state${index}`],
+            );
+
+            stateNames.set(entity, names);
+            states[entity.name] = names[component["ssc.activeState"]] ?? null;
+            break;
+          }
+
+          case "ScenarioComponent": {
+            const script = scripts[component["scenario.scriptId"]];
+
+            if (script) scenarios.push({ owner: entity, script });
+            break;
+          }
+
+          case "ActionComponent":
+            times(component["ac.actionCount"], (index) => {
+              actions.push({
+                owner: entity,
+                action: component[index.toString().padStart(4, "0")] as Action,
+              });
+            });
+            break;
+        }
+      }
+
+      return entity;
+    },
+  );
+
+  function runScenario(
+    { owner, script }: (typeof scenarios)[number],
+    event: string,
+  ) {
+    const { nodes } = script;
+    const links = (id: string) => Object.values(nodes[id].connections ?? {});
+
+    function input(id: string, pin: string): unknown {
+      const link = links(id).find((link) => link.pinIn === pin);
+
+      return link
+        ? output(link.target, link.pinOut)
+        : nodes[id].node.defaults?.[pin]?.["any.value"];
+    }
+
+    function output(id: string, pin: string): unknown {
+      const { type, node } = nodes[id];
+
+      switch (type) {
+        case "ScenarioSceneInfoNode":
+          return node["scenarioSceneInfoNode.infoKind"] === "GetCurrentEntity"
+            ? owner
+            : undefined;
+
+        case "ScenarioGetMemberNode":
+          return node["scenarioGetMemberNode.fieldName"] === "parent" &&
+            pin === "parent"
+            ? (input(id, "object") as Entity | undefined)?.parent
+            : undefined;
+
+        case "ScenarioFunctionNode":
+          switch (
+            `${node["scenarioFunctionNode.className"]}.${node["scenarioFunctionNode.functionName"]}`
+          ) {
+            case "Entity.FindChildByName": {
+              const entity = input(id, "entity") as Entity | undefined;
+              return entity && findChild(entity, input(id, "name") as string);
+            }
+
+            case "TankComponent.GetAppliedSkinMaterialConfigName":
+              return preset;
+
+            case "String.Compare":
+              return input(id, "1") === input(id, "2");
+          }
+      }
+    }
+
+    function execute(id: string, depth: number) {
+      if (depth > MAX_DEPTH) return;
+
+      const { type, node } = nodes[id];
+      let pin = "exit";
+
+      if (type === "ScenarioEventNode") {
+        pin = "event";
+      } else if (type === "ScenarioBranchNode") {
+        pin = input(id, "condition") ? "true" : "false";
+      } else if (
+        node["scenarioFunctionNode.functionName"] === "ActivateState"
+      ) {
+        activateState(
+          input(id, "entity") as Entity | undefined,
+          Number(input(id, "state")),
+        );
+      }
+
+      for (const link of links(id)) {
+        if (link.pinIn === pin) execute(link.target, depth + 1);
+      }
+    }
+
+    for (const id in nodes) {
+      const { type, node } = nodes[id];
+      const name =
+        node["ScenarioEventNode.eventName"] === "Custom"
+          ? node.defaults?.["Event Name"]?.["any.value"]
+          : node["ScenarioEventNode.eventName"];
+
+      if (type === "ScenarioEventNode" && name === event) execute(id, 0);
+    }
+  }
+
+  for (const event of LOAD_EVENTS) {
+    for (const { owner, action } of actions) {
+      if (
+        action["act.delay"] === 0 &&
+        SWITCH_ACTIONS.includes(action["act.type"]) &&
+        (event === LOAD_EVENTS[0]
+          ? action["act.event"] === SCENE_LOADED_EVENT
+          : action["act.event"] === USER_EVENT &&
+            action["act.userEventId"] === event)
+      ) {
+        activateState(
+          resolveTarget(owner, action["act.entityName"]),
+          action["act.switchIndex"],
+        );
+      }
+    }
+
+    for (const scenario of scenarios) runScenario(scenario, event);
+  }
+
+  return states;
+}

packages/website/src/core/blitzkit/tankCharacteristics.ts

@@ -8,8 +8,8 @@ import {
   resolvePenetrationCoefficient,
   ShellType,
   sum,
+  tankBoundingBox,
   TankClass,
-  unionBoundingBox,
   type EngineDefinition,
   type EquipmentDefinitions,
   type GunDefinition,
@@ -336,10 +336,7 @@ export function tankCharacteristics(
   );
 
   const size = normalizeBoundingBox(
-    unionBoundingBox(
-      tankModelDefinition.bounding_box!,
-      turretModelDefinition.bounding_box!,
-    ),
+    tankBoundingBox(tankModelDefinition, turretModelDefinition),
   );
   const weightKg =
     tank.weight + engine.weight + track.weight + turret.weight + gun.weight;

packages/website/src/core/blitzkit/tankToDuelMember.ts

@@ -7,12 +7,23 @@ import {
 import type { DuelMember } from "../../stores/duel";
 import { genericDefaultEquipmentMatrix } from "../../stores/duel/constants";
 
+export function defaultTankWeapon(tank: TankDefinition) {
+  for (const turret of [...tank.turrets].reverse()) {
+    for (const gun of [...turret.guns].reverse()) {
+      const shell = gun.shells[0];
+
+      if (shell) return { turret, gun, shell };
+    }
+  }
+
+  throw new Error(`Tank ${tank.id} has no gun with shells`);
+}
+
 export function tankToDuelMember(
   tank: TankDefinition,
   provisionDefinitions: ProvisionDefinitions,
 ) {
-  const turret = tank.turrets.at(-1)!;
-  const gun = turret.guns.at(-1)!;
+  const { turret, gun, shell } = defaultTankWeapon(tank);
 
   return {
     camouflage: true,
@@ -22,7 +33,7 @@ export function tankToDuelMember(
     provisions: createDefaultProvisions(tank, gun, provisionDefinitions),
     engine: tank.engines.at(-1)!,
     gun,
-    shell: tank.turrets.at(-1)!.guns.at(-1)!.shells[0],
+    shell,
     tank,
     track: tank.tracks.at(-1)!,
     turret,

packages/website/src/hooks/useArmor.ts

@@ -4,7 +4,7 @@ import { GLTFLoader } from "three-stdlib";
 import { useDispose } from "./useDispose";
 
 export function useArmor(id: number) {
-  const path = alias("api", `/tanks/${id}/collision.glb`);
+  const path = alias("models_tanks", `/${id}/collision.glb`);
   const gltf = useLoader(GLTFLoader, path);
 
   useDispose(gltf, path);

packages/website/src/hooks/useModel.ts

@@ -5,7 +5,7 @@ import { GLTFLoader } from "three-stdlib";
 import { useDispose } from "./useDispose";
 
 export function useModel(id: number) {
-  const path = alias("api", `/tanks/${id}/model.glb`);
+  const path = alias("models_tanks", `/${id}/model.glb`);
   const gltf = useLoader(GLTFLoader, path);
 
   useDispose(gltf, path);

packages/website/src/hooks/useSkin.ts

@@ -0,0 +1,89 @@
+import { alias } from "@blitzkit/core";
+import { useEffect } from "react";
+import type { Group, Material } from "three";
+import { GLTFLoader } from "three-stdlib";
+import { TRANSITION_ANIMATION_TIME } from "../components/Tankopedia/HeroSection/components/TankSandbox/components/Lighting";
+import { Tankopedia } from "../stores/tankopedia";
+
+export interface Skin {
+  scene: Group;
+  materials: Map<string, Material>;
+}
+
+const skins = new Map<string, Promise<Skin>>();
+const loadedSkins = new Map<string, Skin>();
+
+async function loadSkin(path: string) {
+  const gltf = await new GLTFLoader().loadAsync(path);
+  const materials: Material[] = await gltf.parser.getDependencies("material");
+  const skin = {
+    scene: gltf.scene,
+    materials: new Map(
+      materials
+        .filter((material) => material.userData.camouflage)
+        .map((material) => [material.name, material]),
+    ),
+  };
+
+  loadedSkins.set(path, skin);
+
+  return skin;
+}
+
+function skinPath(id: number, skin: number) {
+  return alias("models_legendary", `/${id}/skins/${skin}.glb`);
+}
+
+// attachments load the same way as camouflages and can be shown with one
+export function useSkin(id: number, loader: "skin" | "attachment" = "skin") {
+  const requested = Tankopedia.use((state) => state.loaders[loader].requested);
+  const loaded = Tankopedia.use((state) => state.loaders[loader].loaded);
+
+  useEffect(() => {
+    if (requested === Tankopedia.state.loaders[loader].loaded) return;
+
+    const path = requested === undefined ? undefined : skinPath(id, requested);
+    const cached = path === undefined || loadedSkins.has(path);
+    let settled = false;
+
+    if (!cached) {
+      Tankopedia.mutate((draft) => {
+        draft.revealed = false;
+      });
+
+      if (!skins.has(path)) skins.set(path, loadSkin(path));
+    }
+
+    // swaps halfway through the lighting transition
+    Promise.all([
+      path && skins.get(path),
+      new Promise((resolve) =>
+        setTimeout(resolve, TRANSITION_ANIMATION_TIME * 1e3),
+      ),
+    ]).then(() => {
+      if (settled) return;
+
+      settled = true;
+      Tankopedia.mutate((draft) => {
+        draft.loaders[loader].loaded = requested;
+        if (!cached) draft.revealed = true;
+      });
+    });
+
+    return () => {
+      if (settled) return;
+
+      settled = true;
+
+      if (cached) return;
+
+      Tankopedia.mutate((draft) => {
+        draft.revealed = true;
+      });
+    };
+  }, [id, loader, requested]);
+
+  return loaded === undefined
+    ? undefined
+    : loadedSkins.get(skinPath(id, loaded));
+}

packages/website/src/pages/[...chunk_api]/docs/images/[id].webp.ts

@@ -0,0 +1,39 @@
+import type { APIContext, GetStaticPathsItem } from "astro";
+import sharp from "sharp";
+import {
+  docImageId,
+  externalDocImages,
+} from "../../../../core/blitzkit/docImages";
+import { mixStaticPaths } from "../../../../core/blitzkit/mixStaticPaths";
+import { getStaticPaths as _getStaticPaths } from "../../_index";
+
+export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
+  const documents = import.meta.glob<string>(
+    "../../../../../../../docs/**/*.md",
+    { eager: true, query: "?raw", import: "default" },
+  );
+  const urls = new Set(Object.values(documents).flatMap(externalDocImages));
+
+  return Array.from(
+    urls,
+    (url) =>
+      ({
+        params: { id: docImageId(url) },
+        props: { url },
+      }) satisfies GetStaticPathsItem,
+  );
+});
+
+export async function GET({ props }: APIContext<{ url: string }>) {
+  const response = await fetch(props.url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${props.url}: ${response.status}`);
+  }
+
+  const image = await sharp(Buffer.from(await response.arrayBuffer()))
+    .webp()
+    .toBuffer();
+
+  return new Response(new Uint8Array(image));
+}

packages/website/src/pages/[...chunk_api]/icons/camouflages/[id].webp.ts

@@ -0,0 +1,53 @@
+import type { CamouflagesXml } from "@blitzkit/core";
+import type { APIContext, GetStaticPathsItem } from "astro";
+import sharp from "sharp";
+import { extractPackedIcon } from "../../../../core/blitz/extractPackedIcon";
+import { parsePackedSpriteRect } from "../../../../core/blitz/parsePackedSpriteRect";
+import { api } from "../../../../core/blitzkit/api";
+import { mixStaticPaths } from "../../../../core/blitzkit/mixStaticPaths";
+import { vfs } from "../../../../core/blitzkit/vfs";
+import { getStaticPaths as _getStaticPaths } from "../../_index";
+
+export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
+  const camouflageDefinitions = await api.camouflageDefinitions();
+  const camouflagesXml = await vfs.xml<{ root: CamouflagesXml }>(
+    "Data/XML/item_defs/vehicles/common/camouflages.xml",
+  );
+  const icons = new Map(
+    Object.values(camouflagesXml.root.camouflages).map((camouflage) => [
+      camouflage.id,
+      camouflage.icon,
+    ]),
+  );
+  const paths: GetStaticPathsItem[] = [];
+
+  for (const camouflage of Object.values(camouflageDefinitions.camouflages)) {
+    const icon = icons.get(camouflage.id);
+
+    if (camouflage.tank_id === undefined || !icon) continue;
+
+    paths.push({
+      params: { id: camouflage.id },
+      props: {
+        path: icon.replace("~res:/", "Data/").replace(/\.txt$/, ""),
+      },
+    });
+  }
+
+  return paths;
+});
+
+export async function GET({ props }: APIContext<{ path: string }>) {
+  const path = (await vfs.resolve(`${props.path}@2x.packed.webp`))
+    ? `${props.path}@2x.packed.webp`
+    : `${props.path}.packed.webp`;
+  const packed = await vfs.file(path);
+  const texture = sharp(packed);
+  const sizes = parsePackedSpriteRect(packed);
+  const image = sizes
+    ? sharp(await extractPackedIcon(texture, sizes))
+    : texture;
+  const bytes = await image.webp().toBuffer();
+
+  return new Response(new Uint8Array(bytes));
+}

packages/website/src/pages/[...chunk_default]/[...locale]/credits/index.astro

@@ -0,0 +1,13 @@
+---
+import CreditsPromo from "../../../../components/CreditsPromo.astro";
+import { tools } from "../../../../constants/tools";
+import ToolLayout from "../../../../layouts/ToolLayout.astro";
+
+export { getStaticPaths } from "../index.astro";
+
+const { locale } = Astro.props;
+---
+
+<ToolLayout tool={tools.credits} {locale}>
+  <CreditsPromo {locale} />
+</ToolLayout>

packages/website/src/pages/[...chunk_default]/[...locale]/index.astro

@@ -5,6 +5,7 @@ import locales from "@blitzkit/i18n/locales.json";
 import { literals } from "@blitzkit/i18n/src/literals";
 import { Box, Flex, Link } from "@radix-ui/themes";
 import { AesonPlug } from "../../../components/AesonPlug";
+import { Beg } from "../../../components/Beg";
 import HomeHero from "../../../components/HomeHero.astro";
 import { Plugs } from "../../../components/Plugs";
 import ToolCard from "../../../components/ToolCard.astro";
@@ -65,6 +66,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, () => {
 <BaseLayout {locale}>
   <HomeHero />
 
+  <Beg />
+
   {
     locale !== locales.default && (
       <Flex justify="center" pt="4" my="4">

packages/website/src/pages/[...chunk_default]/[...locale]/tanks/[slug]/index.astro

@@ -13,6 +13,7 @@ import { load } from "cheerio";
 import { api } from "../../../../../core/blitzkit/api";
 import { mixStaticPaths } from "../../../../../core/blitzkit/mixStaticPaths";
 import { tankCharacteristics } from "../../../../../core/blitzkit/tankCharacteristics";
+import { defaultTankWeapon } from "../../../../../core/blitzkit/tankToDuelMember";
 import { getStrings } from "../../../../../core/i18n/getStrings";
 import BaseLayout from "../../../../../layouts/BaseLayout.astro";
 import { genericDefaultEquipmentMatrix } from "../../../../../stores/duel/constants";
@@ -53,9 +54,7 @@ const title = literals(strings.website.tools.tankopedia.tank_seo_title, {
 const url = import.meta.env.SITE + Astro.url.pathname;
 
 const icon = alias("api", `/tanks/${id}/icons/big.webp`);
-const turret = tank.turrets.at(-1)!;
-const gun = turret.guns.at(-1)!;
-const shell = gun.shells[0];
+const { turret, gun, shell } = defaultTankWeapon(tank);
 const characteristics = tankCharacteristics(
   {
     tank,

packages/website/src/pages/[...chunk_models_legendary]/[id]/skins/[skin].glb.ts

@@ -0,0 +1,255 @@
+import {
+  parseHierarchies,
+  Sc2ReadStream,
+  type CamouflagesXml,
+  type CamouflagesYaml,
+  type TankParameters,
+} from "@blitzkit/core";
+import {
+  Document,
+  Material,
+  Node,
+  NodeIO,
+  PropertyType,
+  Scene,
+} from "@gltf-transform/core";
+import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
+import { dedup, mergeDocuments, unpartition } from "@gltf-transform/functions";
+import type { APIContext } from "astro";
+import type { Vector3Tuple, Vector4Tuple } from "three";
+import { SKIN_NUMBER } from "../../../../constants/skinNumber";
+import { api } from "../../../../core/blitzkit/api";
+import { mixStaticPaths } from "../../../../core/blitzkit/mixStaticPaths";
+import { switcherStates } from "../../../../core/blitzkit/switcherStates";
+import { vfs } from "../../../../core/blitzkit/vfs";
+import {
+  extractMaterials,
+  extractModel,
+} from "../../../[...chunk_models_tanks]/[id]/model.glb";
+import { getStaticPaths as _getStaticPaths } from "../../_index";
+
+const SKIN_NUMBER_SLOTS = 5;
+const DIGIT_COLUMNS = 5;
+const DIGIT_ROWS = 2;
+
+export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
+  const camouflages = await api.camouflageDefinitions();
+
+  return Object.values(camouflages.camouflages)
+    .filter((camouflage) => camouflage.tank_id)
+    .map((camouflage) => ({
+      params: { id: camouflage.tank_id!, skin: camouflage.id },
+      props: { skin: camouflage.id },
+    }));
+});
+
+const camouflagesXml = await vfs.xml<{ root: CamouflagesXml }>(
+  "Data/XML/item_defs/vehicles/common/camouflages.xml",
+);
+const camouflagesYaml = await vfs.yaml<CamouflagesYaml>(
+  "Data/camouflages.yaml",
+);
+const customization = await vfs.yaml<
+  Record<string, { Name: string; Path: string }>
+>("Data/3d/Customization.yaml");
+
+export async function GET({ props }: APIContext<{ skin: number }>) {
+  const nodeIO = new NodeIO().registerExtensions(ALL_EXTENSIONS);
+
+  const items = new Map(
+    Object.values(customization).map(({ Name, Path }) => [
+      Name,
+      Path.replace("~res:/3d/", "").replace(/\.sc2$/, ""),
+    ]),
+  );
+  const key = Object.keys(camouflagesXml.root.camouflages).find(
+    (key) => camouflagesXml.root.camouflages[key].id === props.skin,
+  )!;
+  const include = camouflagesXml.root.camouflages[key].vehicleFilter.include;
+  const [nation, tankKey] = (
+    include as { vehicle: { name: string } }
+  ).vehicle.name.split(":");
+  const { customEntities } = camouflagesYaml[key];
+  const preset =
+    camouflagesYaml[key].preset ??
+    camouflagesYaml[key].override?.[nation]?.override?.[tankKey]?.preset;
+  const parameters = await vfs.yaml<TankParameters>(
+    `Data/3d/Tanks/Parameters/${nation}/${tankKey}.yaml`,
+  );
+  const basePath = parameters.resourcesPath.blitzModelPath.replace(
+    /\.sc2$/,
+    "",
+  );
+  const sc2 = new Sc2ReadStream(
+    (await vfs.file(`Data/3d/${basePath}.sc2`)).buffer as ArrayBuffer,
+  ).sc2();
+  const slots: Record<
+    string,
+    {
+      target: string;
+      position: Vector3Tuple;
+      rotation: Vector4Tuple;
+      scale: Vector3Tuple;
+    }
+  > = {};
+
+  parseHierarchies(sc2["#hierarchy"], null, (hierarchy, components) => {
+    for (const component of components) {
+      if (component["comp.typename"] === "NewSlotComponent") {
+        for (const slot of Object.values(component.slots)) {
+          slots[slot.name] = {
+            target: hierarchy.name,
+            position: slot.transform.position,
+            rotation: slot.transform.rotation,
+            scale: slot.transform.scale,
+          };
+        }
+      }
+
+      if (component["comp.typename"] === "SlotComponent") {
+        slots[component["sc.slotName"]] = {
+          target: hierarchy.name,
+          position: component["sc.attachmentTranslation"] as Vector3Tuple,
+          rotation: component["sc.attachmentRotation"] as Vector4Tuple,
+          scale: component["sc.attachmentScale"] as Vector3Tuple,
+        };
+      }
+    }
+
+    return null;
+  });
+
+  const attachments = new Map<string, string[]>();
+
+  for (const name in customEntities) {
+    const slot = slots[name];
+
+    if (!slot) continue;
+
+    attachments.set(slot.target, [
+      ...(attachments.get(slot.target) ?? []),
+      customEntities[name].item,
+    ]);
+  }
+
+  const states = switcherStates(sc2, preset, attachments);
+
+  // attachments are layered over camouflages, so they only keep what they change
+  if (camouflagesXml.root.camouflages[key].kind === "customization") {
+    const baseline = switcherStates(sc2, preset, new Map());
+
+    for (const name in states) {
+      if (states[name] === baseline[name]) delete states[name];
+    }
+  }
+  const document = new Document();
+  const scene = document.createScene();
+  const targets = new Map<string, Node>();
+
+  document.createBuffer();
+
+  if (preset) {
+    const materials = await extractMaterials(document, sc2, basePath, preset);
+
+    // parts may share these names, so mark the ones that replace the tank's
+    for (const material of materials.values()) {
+      if (!(material instanceof Material)) continue;
+
+      material.setExtras({ ...material.getExtras(), camouflage: true });
+    }
+  }
+
+  for (const name in customEntities) {
+    const slot = slots[name];
+    const path = items.get(customEntities[name].item);
+
+    if (
+      !slot ||
+      !path ||
+      !(await vfs.resolve(`Data/3d/${path}.sc2`)) ||
+      !(await vfs.resolve(`Data/3d/${path}.scg`))
+    ) {
+      continue;
+    }
+
+    const part = await extractModel(vfs, path, true);
+    const partSc2 = new Sc2ReadStream(
+      (await vfs.file(`Data/3d/${path}.sc2`)).buffer as ArrayBuffer,
+    ).sc2();
+
+    Object.assign(states, switcherStates(partSc2, preset, new Map()));
+
+    const map = mergeDocuments(document, part);
+    const partScene = map.get(part.getRoot().listScenes()[0]) as Scene;
+    const node = document
+      .createNode(name)
+      .setTranslation(slot.position)
+      .setRotation(slot.rotation)
+      .setScale(slot.scale);
+    let target = targets.get(slot.target);
+
+    if (!target) {
+      target = document.createNode(slot.target);
+      targets.set(slot.target, target);
+      scene.addChild(target);
+    }
+
+    for (const child of partScene.listChildren()) {
+      node.addChild(child as Node);
+    }
+
+    partScene.dispose();
+    target.addChild(node);
+  }
+
+  scene.setExtras({ states });
+
+  applySkinNumber(document, SKIN_NUMBER);
+
+  await document.transform(
+    dedup({ propertyTypes: [PropertyType.ACCESSOR, PropertyType.TEXTURE] }),
+    unpartition(),
+  );
+
+  return new Response(await nodeIO.writeBinary(document));
+}
+
+function applySkinNumber(document: Document, number: string) {
+  const start = Math.ceil((SKIN_NUMBER_SLOTS - number.length) / 2) + 1;
+
+  for (const node of document.getRoot().listNodes()) {
+    const match = node.getName().match(/_number_\d+_(\d+)$/);
+
+    if (!match) continue;
+
+    const digit = number[Number(match[1]) - start];
+
+    if (digit === undefined) {
+      node.dispose();
+      continue;
+    }
+
+    const cell = (Number(digit) + 9) % 10;
+    const column = cell % DIGIT_COLUMNS;
+    const row = Math.floor(cell / DIGIT_COLUMNS);
+
+    node.traverse((child) => {
+      for (const primitive of child.getMesh()?.listPrimitives() ?? []) {
+        const uvs = primitive.getAttribute("TEXCOORD_0")?.clone();
+
+        if (!uvs) continue;
+
+        for (let index = 0; index < uvs.getCount(); index++) {
+          const [u, v] = uvs.getElement(index, [0, 0]) as [number, number];
+
+          uvs.setElement(index, [
+            (column + u) / DIGIT_COLUMNS,
+            (row + v) / DIGIT_ROWS,
+          ]);
+        }
+
+        primitive.setAttribute("TEXCOORD_0", uvs);
+      }
+    });
+  }
+}

packages/website/src/pages/[...chunk_models_legendary]/_index.ts

@@ -0,0 +1,3 @@
+import { chunkedStaticPaths } from "../../core/blitzkit/chunkedStaticPaths";
+
+export const getStaticPaths = chunkedStaticPaths("models_legendary");

packages/website/src/pages/[...chunk_models_tanks]/[id]/_index.ts

@@ -0,0 +1,12 @@
+import { api } from "../../../core/blitzkit/api";
+import { mixStaticPaths } from "../../../core/blitzkit/mixStaticPaths";
+import { getStaticPaths as _getStaticPaths } from "../_index";
+
+export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
+  const tanks = await api.tankDefinitions();
+
+  return Object.values(tanks.tanks).map((tank) => ({
+    params: { id: tank.id },
+    props: { id: tank.id },
+  }));
+});

packages/website/src/pages/[...chunk_models_tanks]/[id]/collision.glb.ts

@@ -1,17 +1,16 @@
 import {
+  parseHierarchies,
   Sc2ReadStream,
   ScgReadStream,
   toUniqueId,
   VertexAttribute,
   vertexAttributeVectorSizes,
-  type Hierarchy,
   type VehicleDefinitionList,
 } from "@blitzkit/core";
 import type { AbstractVFS } from "@blitzkit/core/src/blitzkit/vfs/abstract";
 import { Accessor, Document, Node, NodeIO, Scene } from "@gltf-transform/core";
 import type { APIContext } from "astro";
-import { times } from "lodash-es";
-import { vfs } from "../../../../core/blitzkit/vfs";
+import { vfs } from "../../../core/blitzkit/vfs";
 
 export { getStaticPaths } from "./_index";
 
@@ -56,13 +55,10 @@ async function extractArmor(vfs: AbstractVFS, fileName: string) {
   const scene = document.createScene();
   const buffer = document.createBuffer();
 
-  function parseHierarchies(hierarchies: Hierarchy[], parent: Scene | Node) {
-    hierarchies.forEach((hierarchy) => {
-      const components = times(
-        hierarchy.components.count,
-        (index) => hierarchy.components[index.toString().padStart(4, "0")],
-      );
-
+  parseHierarchies<Scene | Node>(
+    sc2["#hierarchy"],
+    scene,
+    (hierarchy, components, parent) => {
       components.forEach((component) => {
         switch (component["comp.typename"]) {
           case "TransformComponent":
@@ -163,13 +159,9 @@ async function extractArmor(vfs: AbstractVFS, fileName: string) {
         }
       });
 
-      if (hierarchy["#hierarchy"]) {
-        parseHierarchies(hierarchy["#hierarchy"], parent);
-      }
-    });
-  }
-
-  parseHierarchies(sc2["#hierarchy"], scene);
+      return parent;
+    },
+  );
 
   return document;
 }

packages/website/src/pages/[...chunk_models_tanks]/[id]/model.glb.ts

@@ -1,13 +1,13 @@
 import {
   bufferToBigInt,
   DdsReadStream,
+  parseHierarchies,
   PvrReadStream,
   Sc2ReadStream,
   ScgReadStream,
   toUniqueId,
   VertexAttribute,
   type ConfigArchive,
-  type Hierarchy,
   type TankParameters,
   type Textures,
   type VehicleDefinitionList,
@@ -17,10 +17,10 @@ import { Document, Material, Node, NodeIO, Scene } from "@gltf-transform/core";
 import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
 import { dedup, prune } from "@gltf-transform/functions";
 import type { APIContext } from "astro";
-import { times } from "lodash-es";
+import { isEqual, times } from "lodash-es";
 import { dirname } from "path";
 import sharp from "sharp";
-import { vfs } from "../../../../core/blitzkit/vfs";
+import { vfs } from "../../../core/blitzkit/vfs";
 import {
   vertexAttributeGLTFName,
   vertexAttributeGltfVectorSizes,
@@ -65,11 +65,21 @@ export async function GET({ props }: APIContext<{ id: number }>) {
 const ERROR_ON_UNKNOWN_COMPONENT = false;
 
 const omitMeshNames = {
-  start: ["chassis_chassis_", "chassis_track_crash_", "HP_"],
+  start: [
+    "chassis_chassis_",
+    "chassis_track_crash_",
+    "HP_",
+    // mastery marks a new tank doesn't have yet
+    "custom_gun_marks_",
+  ],
   end: ["_POINT"],
 };
 
-async function extractModel(vfs: AbstractVFS, path: string) {
+export async function extractModel(
+  vfs: AbstractVFS,
+  path: string,
+  isPart = false,
+) {
   const sc2Path = `Data/3d/${path}.sc2`;
   const scgPath = `Data/3d/${path}.scg`;
   const sc2 = new Sc2ReadStream(
@@ -81,167 +91,12 @@ async function extractModel(vfs: AbstractVFS, path: string) {
   const document = new Document();
   const scene = document.createScene();
   const buffer = document.createBuffer();
-  const materials = new Map<bigint, Material | bigint | undefined>();
+  const materials = await extractMaterials(document, sc2, path);
 
-  for (const node of sc2["#dataNodes"]) {
-    const id = bufferToBigInt(node["#id"]);
-
-    if (node.parentMaterialKey !== undefined) {
-      /**
-       * material depends on a parent and doesn't seem to have any
-       * properties so we just point it to the parent
-       */
-      materials.set(id, node.parentMaterialKey);
-      continue;
-    }
-
-    const material = document.createMaterial(node.materialName);
-    let textures: Textures | undefined = undefined;
-
-    if (node.textures) {
-      textures = node.textures;
-    } else if (typeof node.configCount === "number") {
-      textures = node.configArchive_0.textures;
-    }
-
-    if (textures) {
-      const baseColor = await readBaseColor(
-        `Data/3d/${dirname(path)}/${textures.baseColorMap ?? textures.albedo}`,
-      );
-      material.setBaseColorTexture(
-        document
-          .createTexture(node.materialName)
-          .setMimeType("image/webp")
-          .setImage(baseColor),
-      );
-
-      let defaultConfigArchive: ConfigArchive | undefined = undefined;
-
-      if (node.configCount) {
-        const names = times(
-          node.configCount,
-          (index) => node[`configArchive_${index}`],
-        );
-
-        defaultConfigArchive = names.find(
-          (archive) => archive.configName === "Default",
-        );
-        defaultConfigArchive ??= node.configArchive_0;
-      }
-
-      const customCullMode =
-        node.customCullMode ?? defaultConfigArchive?.customCullMode;
-
-      if (customCullMode === 0) {
-        material.setDoubleSided(true);
-      } else if (customCullMode !== undefined) {
-        material.setDoubleSided(false);
-      }
-
-      if (
-        node.enabledPresets?.AlphaTest &&
-        node.properties?.alphatestThreshold
-      ) {
-        const view = new DataView(node.properties.alphatestThreshold);
-        const alphaCutoff =
-          view.byteLength < 4
-            ? 0.5
-            : view.getFloat32(view.byteLength - 4, true);
-
-        material.setAlphaMode("MASK").setAlphaCutoff(alphaCutoff);
-      }
-
-      if (node.configCount) {
-        for (
-          let configIndex = 0;
-          configIndex < node.configCount;
-          configIndex++
-        ) {
-          const archive = node[`configArchive_${configIndex}`];
-
-          if (
-            archive.configName !== "Default" ||
-            !archive.enabledPresets?.AlphaTest ||
-            !archive.properties?.alphatestThreshold
-          ) {
-            continue;
-          }
-
-          const view = new DataView(archive.properties.alphatestThreshold);
-          const alphaCutoff =
-            view.byteLength < 4
-              ? 0.5
-              : view.getFloat32(view.byteLength - 4, true);
-
-          material.setAlphaMode("MASK").setAlphaCutoff(alphaCutoff);
-        }
-      }
-
-      if (textures.miscMap) {
-        material.setOcclusionTexture(
-          document
-            .createTexture(node.materialName)
-            .setMimeType("image/webp")
-            .setImage(
-              await readOcclusion(
-                `Data/3d/${dirname(path)}/${textures.miscMap}`,
-              ),
-            ),
-        );
-      }
-
-      if (textures.baseRMMap) {
-        material.setMetallicRoughnessTexture(
-          document
-            .createTexture(node.materialName)
-            .setMimeType("image/webp")
-            .setImage(
-              await readRoughnessMetallic(
-                `Data/3d/${dirname(path)}/${textures.baseRMMap}`,
-              ),
-            ),
-        );
-      }
-
-      if (textures.baseNormalMap ?? textures.normalmap) {
-        const isBase = textures.baseNormalMap !== undefined;
-
-        material.setNormalTexture(
-          document
-            .createTexture(node.materialName)
-            .setMimeType("image/webp")
-            .setImage(
-              await readNormal(
-                `Data/3d/${dirname(path)}/${
-                  textures.baseNormalMap ?? textures.normalmap
-                }`,
-                isBase,
-              ),
-            ),
-        );
-      }
-
-      materials.set(id, material);
-    }
-  }
-
-  // replace children materials with parents
-  materials.forEach((material, id) => {
-    if (typeof material !== "bigint") return;
-
-    let resolvedMaterial: Material | bigint | undefined = material;
-
-    while (typeof resolvedMaterial === "bigint") {
-      const linkedParentMaterial = materials.get(resolvedMaterial);
-
-      resolvedMaterial = linkedParentMaterial;
-    }
-
-    materials.set(id, resolvedMaterial);
-  });
-
-  function parseHierarchies(hierarchies: Hierarchy[], parent: Scene | Node) {
-    hierarchies.forEach((hierarchy) => {
+  parseHierarchies<Scene | Node>(
+    sc2["#hierarchy"],
+    scene,
+    (hierarchy, components, parent) => {
       if (
         omitMeshNames.start.some((omit) => hierarchy.name.startsWith(omit)) ||
         omitMeshNames.end.some((omit) => hierarchy.name.endsWith(omit))
@@ -249,10 +104,6 @@ async function extractModel(vfs: AbstractVFS, path: string) {
         return;
 
       const node = document.createNode(hierarchy.name);
-      const components = times(
-        hierarchy.components.count,
-        (index) => hierarchy.components[index.toString().padStart(4, "0")],
-      );
 
       components.forEach((component) => {
         switch (component["comp.typename"]) {
@@ -264,9 +115,10 @@ async function extractModel(vfs: AbstractVFS, path: string) {
           case "TransformComponent": {
             const localTranslation = component["tc.localTranslation"];
             // The game resets top-level node translation to [0, 0, 0] on load.
-            // Child nodes must keep their authored local offsets.
+            // Child nodes and customization parts must keep their authored
+            // local offsets.
             node.setTranslation(
-              parent instanceof Scene ? [0, 0, 0] : localTranslation,
+              parent instanceof Scene && !isPart ? [0, 0, 0] : localTranslation,
             );
             node.setRotation(component["tc.localRotation"]);
             node.setScale(component["tc.localScale"]);
@@ -274,13 +126,20 @@ async function extractModel(vfs: AbstractVFS, path: string) {
             break;
           }
 
+          case "StateSwitcherComponent":
+            node.setExtras({
+              state: component[`ssc.state${component["ssc.activeState"]}`],
+            });
+            break;
+
           case "RenderComponent": {
             const renderObject = component["rc.renderObj"];
 
             times(renderObject["ro.batchCount"], (batchIndex): void => {
               const lodIndex = renderObject[`rb${batchIndex}.lodIndex`];
 
-              if (lodIndex !== 0) return;
+              // -1 means the batch has no lods and is always drawn
+              if (lodIndex !== 0 && !(isPart && lodIndex === -1)) return;
 
               const batchKey = batchIndex.toString().padStart(4, "0");
               const batch = renderObject["ro.batches"][batchKey];
@@ -361,15 +220,11 @@ async function extractModel(vfs: AbstractVFS, path: string) {
         }
       });
 
-      if (hierarchy["#hierarchy"]) {
-        parseHierarchies(hierarchy["#hierarchy"], node);
-      }
-
       parent.addChild(node);
-    });
-  }
 
-  parseHierarchies(sc2["#hierarchy"], scene);
+      return node;
+    },
+  );
 
   scene.addChild(document.createNode("test"));
 
@@ -378,6 +233,212 @@ async function extractModel(vfs: AbstractVFS, path: string) {
   return document;
 }
 
+export async function extractMaterials(
+  document: Document,
+  sc2: ReturnType<Sc2ReadStream["sc2"]>,
+  path: string,
+  config?: string,
+) {
+  const materials = new Map<bigint, Material | bigint | undefined>();
+
+  for (const node of sc2["#dataNodes"]) {
+    const id = bufferToBigInt(node["#id"]);
+
+    if (node.parentMaterialKey !== undefined) {
+      /**
+       * material depends on a parent and doesn't seem to have any
+       * properties so we just point it to the parent
+       */
+      materials.set(id, node.parentMaterialKey);
+      continue;
+    }
+
+    let textures: Textures | undefined = undefined;
+
+    if (config !== undefined) {
+      if (typeof node.configCount !== "number") continue;
+
+      const archive = times(
+        node.configCount,
+        (index) => node[`configArchive_${index}`],
+      ).find((archive) => archive.configName === config);
+
+      if (
+        !archive ||
+        isEqual(archive.textures, node.configArchive_0.textures)
+      ) {
+        continue;
+      }
+
+      textures = archive.textures;
+    } else if (node.textures) {
+      textures = node.textures;
+    } else if (typeof node.configCount === "number") {
+      textures = node.configArchive_0.textures;
+    }
+
+    const material = document.createMaterial(node.materialName);
+
+    if (textures) {
+      const baseColor = await readBaseColor(
+        `Data/3d/${dirname(path)}/${textures.baseColorMap ?? textures.albedo}`,
+      );
+      material.setBaseColorTexture(
+        document
+          .createTexture(node.materialName)
+          .setMimeType("image/webp")
+          .setImage(baseColor),
+      );
+
+      let defaultConfigArchive: ConfigArchive | undefined = undefined;
+
+      if (node.configCount) {
+        const names = times(
+          node.configCount,
+          (index) => node[`configArchive_${index}`],
+        );
+
+        defaultConfigArchive = names.find(
+          (archive) => archive.configName === "Default",
+        );
+        defaultConfigArchive ??= node.configArchive_0;
+      }
+
+      const customCullMode =
+        node.customCullMode ?? defaultConfigArchive?.customCullMode;
+
+      if (customCullMode === 0) {
+        material.setDoubleSided(true);
+      } else if (customCullMode !== undefined) {
+        material.setDoubleSided(false);
+      }
+
+      if (
+        node.enabledPresets?.AlphaTest &&
+        node.properties?.alphatestThreshold
+      ) {
+        const view = new DataView(node.properties.alphatestThreshold);
+        const alphaCutoff =
+          view.byteLength < 4
+            ? 0.5
+            : view.getFloat32(view.byteLength - 4, true);
+
+        material.setAlphaMode("MASK").setAlphaCutoff(alphaCutoff);
+      }
+
+      if (node.configCount) {
+        for (
+          let configIndex = 0;
+          configIndex < node.configCount;
+          configIndex++
+        ) {
+          const archive = node[`configArchive_${configIndex}`];
+
+          if (
+            archive.configName !== "Default" ||
+            !archive.enabledPresets?.AlphaTest ||
+            !archive.properties?.alphatestThreshold
+          ) {
+            continue;
+          }
+
+          const view = new DataView(archive.properties.alphatestThreshold);
+          const alphaCutoff =
+            view.byteLength < 4
+              ? 0.5
+              : view.getFloat32(view.byteLength - 4, true);
+
+          material.setAlphaMode("MASK").setAlphaCutoff(alphaCutoff);
+        }
+      }
+
+      const enabledPresets =
+        node.enabledPresets ?? defaultConfigArchive?.enabledPresets;
+      const fxName = node.fxName ?? defaultConfigArchive?.fxName;
+
+      if (enabledPresets?.AlphaBlend || enabledPresets?.AlphaBlendAdditive) {
+        material.setAlphaMode("BLEND");
+      }
+
+      if (enabledPresets?.AlphaBlendAdditive) {
+        // gltf has no additive blending so the viewer applies it
+        material.setExtras({ blending: "additive" });
+      }
+
+      if (fxName?.endsWith("/Textured.material")) {
+        // unlit in game, emissive so the viewer can fade it with the lights
+        material
+          .setEmissiveTexture(material.getBaseColorTexture())
+          .setEmissiveFactor([1, 1, 1])
+          .setBaseColorFactor([0, 0, 0, 1]);
+      }
+
+      if (textures.miscMap) {
+        material.setOcclusionTexture(
+          document
+            .createTexture(node.materialName)
+            .setMimeType("image/webp")
+            .setImage(
+              await readOcclusion(
+                `Data/3d/${dirname(path)}/${textures.miscMap}`,
+              ),
+            ),
+        );
+      }
+
+      if (textures.baseRMMap) {
+        material.setMetallicRoughnessTexture(
+          document
+            .createTexture(node.materialName)
+            .setMimeType("image/webp")
+            .setImage(
+              await readRoughnessMetallic(
+                `Data/3d/${dirname(path)}/${textures.baseRMMap}`,
+              ),
+            ),
+        );
+      }
+
+      if (textures.baseNormalMap ?? textures.normalmap) {
+        const isBase = textures.baseNormalMap !== undefined;
+
+        material.setNormalTexture(
+          document
+            .createTexture(node.materialName)
+            .setMimeType("image/webp")
+            .setImage(
+              await readNormal(
+                `Data/3d/${dirname(path)}/${
+                  textures.baseNormalMap ?? textures.normalmap
+                }`,
+                isBase,
+              ),
+            ),
+        );
+      }
+
+      materials.set(id, material);
+    }
+  }
+
+  // replace children materials with parents
+  materials.forEach((material, id) => {
+    if (typeof material !== "bigint") return;
+
+    let resolvedMaterial: Material | bigint | undefined = material;
+
+    while (typeof resolvedMaterial === "bigint") {
+      const linkedParentMaterial = materials.get(resolvedMaterial);
+
+      resolvedMaterial = linkedParentMaterial;
+    }
+
+    materials.set(id, resolvedMaterial);
+  });
+
+  return materials;
+}
+
 async function readBaseColor(path: string) {
   const raw = await readTexture(path);
   const image = await sharp(raw.data, { raw }).webp().toBuffer();

packages/website/src/pages/[...chunk_models_tanks]/_index.ts

@@ -0,0 +1,3 @@
+import { chunkedStaticPaths } from "../../core/blitzkit/chunkedStaticPaths";
+
+export const getStaticPaths = chunkedStaticPaths("models_tanks");

packages/website/src/stores/tankopedia.ts

@@ -78,10 +78,19 @@ export enum TankopediaRelativeAgainst {
   All,
 }
 
+interface LoaderState<Type> {
+  requested: Type;
+  loaded: Type;
+}
+
 interface Tankopedia {
   disturbed: boolean;
   revealed: boolean;
-  modelRequested: boolean;
+  loaders: {
+    model: LoaderState<boolean>;
+    skin: LoaderState<number | undefined>;
+    attachment: LoaderState<number | undefined>;
+  };
   shot?: Shot;
   skills: Record<string, number>;
   relativeAgainst: TankopediaRelativeAgainst;
@@ -113,7 +122,11 @@ const skillDefinitions = await api.skillDefinitions();
 export const Tankopedia = new Varuna<Tankopedia, ModelDefinition>((model) => ({
   disturbed: false,
   revealed: false,
-  modelRequested: App.state.autoLoadModels,
+  loaders: {
+    model: { requested: App.state.autoLoadModels, loaded: false },
+    skin: { requested: undefined, loaded: undefined },
+    attachment: { requested: undefined, loaded: undefined },
+  },
   relativeAgainst: TankopediaRelativeAgainst.Class,
   editStatic: false,
   skills: createDefaultSkills(skillDefinitions),