revert colors

package.json

@@ -10,8 +10,7 @@
     "build-protos": "cd packages/scripts && bun run build-protos",
     "record-performance": "cd packages/scripts && bun run record-performance",
     "download-client": "cd packages/scripts && bun run download-client",
-    "clean-astro": "rm -rf packages/website/.astro packages/website/node_modules/.astro packages/website/node_modules/.vite",
-    "vfs": "cd packages/scripts && bun run vfs"
+    "clean-astro": "rm -rf packages/website/.astro packages/website/node_modules/.astro packages/website/node_modules/.vite"
   },
   "type": "module",
   "workspaces": [

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

@@ -246,27 +246,6 @@ 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],

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

@@ -595,25 +595,9 @@ 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 = piercingPower
+              const penetrationRaw = gunShellEntry.piercingPower
                 .split(" ")
                 .filter((penetrationString) => penetrationString !== "")
                 .map(Number);
@@ -623,7 +607,7 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
               ].shells.push({
                 id: shellId,
                 name: shellName,
-                velocity: speed,
+                velocity: gunShellEntry.speed,
                 armor_damage: shell.damage.armor,
                 module_damage: shell.damage.devices,
                 caliber: shell.caliber,
@@ -639,7 +623,7 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
                   near: penetrationRaw[0],
                   far: penetrationRaw[1],
                 },
-                range: maxDistance,
+                range: gunShellEntry.maxDistance,
               });
             }
 

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

@@ -10,8 +10,6 @@ export abstract class ServerBlitzKitAPI2 extends ServerBlitzKitAPI1 {
     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)

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

@@ -4,13 +4,7 @@ import {
   ChassisDefinitionsList,
   Crew,
   GunDefinitionsList,
-  I_HAT,
-  J_HAT,
-  K_HAT,
   ModelDefinitions,
-  parseHierarchies,
-  Sc2ReadStream,
-  ScgReadStream,
   TankParameters,
   toUniqueId,
   TurretDefinitionsList,
@@ -18,10 +12,9 @@ import {
   VehicleDefinitionArmor,
   VehicleDefinitionList,
   VehicleDefinitions,
-  VertexAttribute,
 } from "@blitzkit/core";
 import { parse as parsePath } from "path";
-import { MathUtils, Vector3 as THREEVector3, Vector3Tuple } from "three";
+import { Vector3Tuple } from "three";
 import { Cache } from "./0_base";
 import { ServerBlitzKitAPI2 } from "./2_camouflageDefinitions";
 
@@ -30,87 +23,6 @@ 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,
@@ -155,12 +67,6 @@ 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;
@@ -235,8 +141,12 @@ export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
               }
             : undefined,
           bounding_box: {
-            min: this.vector3TupleToBlitzkit(hullBoundingBox.min),
-            max: this.vector3TupleToBlitzkit(hullBoundingBox.max),
+            min: this.vector3TupleToBlitzkit(
+              tankParameters.collision.hull.bbox.min,
+            ),
+            max: this.vector3TupleToBlitzkit(
+              tankParameters.collision.hull.bbox.max,
+            ),
           },
           turrets: {},
           tracks: {},
@@ -298,35 +208,26 @@ 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: isFullYaw
-              ? undefined
-              : { min: turretYaw[0], max: turretYaw[1] },
+            yaw:
+              -turretYaw[0] + turretYaw[1] === 360
+                ? undefined
+                : { min: turretYaw[0], max: turretYaw[1] },
             guns: {},
             bounding_box: {
-              min: this.vector3TupleToBlitzkit(turretBoundingBox.min),
-              max: this.vector3TupleToBlitzkit(turretBoundingBox.max),
+              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,
+              ),
             },
           };
 

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

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

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

packages/core/src/blitzkit/index.ts

@@ -25,7 +25,6 @@ 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

@@ -1,32 +0,0 @@
-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 } from "../../protos";
+import { CrewType, ShellType, TankClass, TankType } from "../../protos";
 
 export const SHELL_NAMES: Record<ShellType, string> = {
   [ShellType.SHELL_TYPE_AP]: "AP",
@@ -15,6 +15,33 @@ 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",
@@ -41,3 +68,8 @@ 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

@@ -0,0 +1,50 @@
+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

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

packages/core/src/index.ts

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

packages/core/src/streams/sc2.ts

@@ -90,28 +90,6 @@ 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/gunDefinitionsList.ts

@@ -20,13 +20,11 @@ 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,9 +10,6 @@ export type ShellDefinitionsList = Record<
     normalizationAngle?: number;
     ricochetAngle?: number;
     explosionRadius?: number;
-    speed: number;
-    maxDistance?: number;
-    piercingPower: string;
   }
 > & {
   icons: Record<string, string>;

packages/i18n/strings/pl.json

@@ -220,190 +220,190 @@
         "clear": "Clear",
         "tier": "Tier {tier}",
         "passive": "{name} (Passive)",
-        "active": "{name} (Aktywne)",
+        "active": "{name} (Active)",
         "no_tanks_found": {
-          "body": "Nie znaleziono czołgu.",
+          "body": "No tanks found.",
           "search_again": "",
           "clear_filters": "Try clearing filters."
         },
         "sort": {
-          "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",
+          "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",
           "fire.tertiaryPenetration": "tertiary penetration",
-          "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.damage": "damage",
+          "fire.moduleDamage": "module damage",
+          "fire.shellVelocity": "shell velocity",
+          "fire.shellRange": "shell range",
+          "fire.shellCapacity": "shell capacity",
+          "fire.aimTime": "aim time",
           "fire.dispersionStill": "dispersion still",
           "fire.dispersionMoving": "dispersion moving",
-          "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",
+          "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",
           "maneuverability.traverseSpeed": "traverse speed"
         },
         "sort_dropdown": {
-          "label": "Filtruj",
+          "label": "Sort",
           "groups": {
             "sort": {
-              "no_sort": "Brak filtrów",
-              "label": "Filtruj według",
-              "fire": "Siła ognia",
-              "maneuverability": "Mobilność ",
-              "survivability": "Przetrwanie"
+              "no_sort": "No sort",
+              "label": "Sort by",
+              "fire": "Fire",
+              "maneuverability": "Maneuverability",
+              "survivability": "Survivability"
             },
             "direction": {
               "label": "Direction",
-              "ascending": "Rosnąco",
-              "descending": "Malejąco"
+              "ascending": "Ascending",
+              "descending": "Descending"
             }
           }
         }
       },
       "warnings": {
-        "test": "Wartości statystyk czołgów w fazie testowej mogą ulec zmianie."
+        "test": "Tanks in testing are subject to change and may not represent the final product."
       }
     },
     "home": {
       "discord": {
-        "join_short": "Dołącz do elity!",
-        "join_long": "Dołącz do topowej elity!",
+        "join_short": "Join cool people!",
+        "join_long": "Join super duper cool people!",
         "action": "Discord"
       },
       "hero": {
-        "credit": "Według {name} ♥️"
+        "credit": "By {name} ❤️"
       },
       "hot_tanks": {
-        "title": "Popularne czołgi",
-        "subtitle": "Ostatnie {days} dni"
+        "title": "Popular tanks",
+        "subtitle": "Last {days} days"
       },
       "other_projects": {
-        "title": "Inne epickie projekty"
+        "title": "Other cool projects"
       },
-      "help_translate": "Proszę pomóż przetłumaczyć {name} na {language}!",
-      "seo_description": "Narzędzia do wszystkiego World of Tanks Blitz"
+      "help_translate": "Please help translate {name} to {language}!",
+      "seo_description": "Tools for everything World of Tanks Blitz"
     },
     "docs": {
       "patches": {
-        "name": "Zapisy zmian BlitzKit",
-        "seo_description": "Zapisy zmian BlitzKit: Discord bot i strona internetowa"
+        "name": "BlitzKit Changelogs",
+        "seo_description": "Changelogs for BlitzKit Discord bot and website"
       }
     },
     "tools": {
       "playlist": {
-        "reset": "Resetuj",
-        "shuffle": "Wymieszaj",
-        "remove": "Usuń czołgi, którymi grałem",
-        "tracking": "BlitzKit zapisuje twoje bitwy",
+        "reset": "Reset",
+        "shuffle": "Shuffle",
+        "remove": "Remove played",
+        "tracking": "BlitzKit is tracking your battles",
         "sort": {
-          "button": "Filtruj według",
-          "last_played": "Ostatnio używane czołgi",
-          "least_played": "Najmniej używane czołgi"
+          "button": "Sort by",
+          "last_played": "Last played",
+          "least_played": "Least played"
         },
         "table": {
           "index": "#",
-          "never": "Nigdy",
-          "tank": "Czołg",
-          "last_played": "Ostatnio używane czołgi",
-          "battles": "Wszystkie bitwy na koncie",
+          "never": "Never",
+          "tank": "Tank",
+          "last_played": "Last played",
+          "battles": "Career battles",
           "unrecorded": "--",
           "wins": "Zwycięstwa"
         },
         "large_warning": {
-          "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ź"
+          "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"
         },
-        "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"
+        "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"
       },
       "mixer": {
-        "name": "Mikser",
+        "name": "Mixer",
         "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": "Zrzut ekranu",
-        "randomize": "Wymieszaj"
+        "screenshot": "Screenshot",
+        "randomize": "Randomize"
       },
       "guess": {
-        "name": "Zgadnij",
+        "name": "Guess",
         "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": "Wpisz odpowiedź",
-          "skip": "Pomiń",
-          "guess": "Zgaduję",
-          "next": "Następny",
+          "placeholder": "Type to guess...",
+          "skip": "Skip",
+          "guess": "Guess",
+          "next": "Next",
           "no_results": "Brak wyników"
         },
         "stats": "{correct} / {total} correct, {streak} streak",
         "help": {
-          "title": "Odsłonić część czołgu?",
+          "title": "Partially reveal tank?",
           "description": "Reveals the tank without showing the name. This round will be considered incorrect and break your streak!",
-          "cancel": "Anuluj",
-          "reveal": "Pokaż"
+          "cancel": "Cancel",
+          "reveal": "Reveal"
         },
-        "clear": "Wyczyść",
-        "select_all": "Zaznacz wszystko ",
-        "tier": "Poziom czołgu {tier}"
+        "clear": "Clear",
+        "select_all": "Select all",
+        "tier": "Tier {tier}"
       },
       "tankopedia": {
-        "search": "Wyszukaj statystykę...",
+        "search": "Search a stat...",
         "name": "Tankopedia",
-        "button": "Znajdź czołg",
-        "description": "Encyklopedia czołgów w WoTb",
+        "button": "Find tanks",
+        "description": "Blitz tank encyclopedia",
         "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": "Pomiń"
+            "skip": "Skip"
           },
           "assault": {
             "title": "Assault shells"
           },
           "rotator": {
-            "hull": "Kadłub",
-            "turret": "Wieża",
-            "hard": "Utwardzony",
+            "hull": "Hull",
+            "turret": "Turret",
+            "hard": "Hard",
             "medium": "Średni",
-            "soft": "Miękki",
-            "effective": "Rzeczywisty"
+            "soft": "Soft",
+            "effective": "Effective"
           },
           "ricochet": {
-            "angle": "Kąt",
+            "angle": "Angle",
             "normalization": "Normalization",
-            "effective_angle": "Rzeczywisty kąt nachylenia pancerza",
-            "armor": "Pancerz",
-            "no_ricochet": "Pociski odłamkowe nie rykoszetują."
+            "effective_angle": "Effective angle",
+            "armor": "Armor",
+            "no_ricochet": "Explosive shells don't ricochet"
           },
           "view_range": {
-            "camo": "Kamuflaż",
-            "ghost_factory": "Fabryka duchów",
-            "dead_rail": "Martwy tor"
+            "camo": "Camo",
+            "ghost_factory": "Ghost Factory",
+            "dead_rail": "Dead Rail"
           },
           "flexibility": {
             "yaw": "Yaw",
@@ -656,10 +656,10 @@
           "loader": "Loader"
         },
         "maneuverability": {
-          "title": "Mobilność "
+          "title": "Maneuverability"
         },
         "survivability": {
-          "title": "Przetrwanie"
+          "title": "Survivability"
         }
       },
       "compare": {

packages/i18n/strings/pt.json

@@ -41,7 +41,7 @@
       "development": "Development",
       "opentest": "TesteAberto",
       "preview": "Preview",
-      "production": "Produção"
+      "production": "Production"
     },
     "locales": {
       "en": "Inglês",
@@ -187,11 +187,11 @@
   },
   "website": {
     "redirect": {
-      "title": "301: movido permanentemente",
+      "title": "301: moved permanently",
       "body": "This page has moved. Redirecting..."
     },
     "settings": {
-      "title": "Configurações",
+      "title": "Settings",
       "description": "Change BlitzKit settings",
       "dev_mode": "Modo de desenvolvimento",
       "auto_load_models": "Auto-load models",
@@ -207,9 +207,9 @@
         "copied": "Copiado!"
       },
       "tank_search": {
-        "select_dialog_title": "Procura por tanque",
+        "select_dialog_title": "Search for tanks",
         "swap_dialog_title": "Swap tank",
-        "clear_filters": "Limpar filtros",
+        "clear_filters": "Clear filters",
         "login": "Login to use this",
         "search_bar_hint": "Procurar tanques...",
         "recent": "Visto recentemente",

packages/scripts/package.json

@@ -5,8 +5,7 @@
     "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",
-    "vfs": "bun src/vfs/index.ts"
+    "download-client": "bun src/downloadClient/index.ts"
   },
   "dependencies": {
     "@blitzkit/closed": "workspace:*",

packages/scripts/src/vfs/index.ts

@@ -1,23 +0,0 @@
-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));
-
-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);
-  }
-}

packages/website/src/components/ArticlePlug.astro

@@ -0,0 +1,38 @@
+---
+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/Giveaway.tsx

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

packages/website/src/components/GuessRenderer.tsx

@@ -1,9 +1,9 @@
 import { useModel } from "../hooks/useModel";
 import { Guess, GuessState } from "../stores/guess";
 import { SmartCanvas } from "./SmartCanvas";
+import { TankModel } from "./TankModel";
 import { Controls } from "./Tankopedia/HeroSection/components/TankSandbox/components/Control";
 import { Lighting } from "./Tankopedia/HeroSection/components/TankSandbox/components/Lighting";
-import { TankModel } from "./Tankopedia/HeroSection/components/TankSandbox/components/TankModel";
 
 const BRIGHTNESS = 2 ** -5.5;
 const CONTRAST = 2 ** 2;

packages/website/src/components/Markdown.tsx

@@ -1,20 +1,13 @@
 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({ src, ...props }: ComponentProps<'img'>) {
-  return (
-    <img
-      style={{ maxWidth: '100%' }}
-      src={src && isExternalImage(src) ? docImageUrl(src) : src}
-      {...props}
-    />
-  );
+function Image(props: ComponentProps<'img'>) {
+  return <img style={{ maxWidth: '100%' }} {...props} />;
 }
 
 export function Markdown({ children }: MarkdownProps) {

packages/website/src/components/StupidCat.tsx

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

packages/website/src/components/TankModel.tsx

@@ -0,0 +1,297 @@
+import {
+  invalidate,
+  useThree,
+  type ObjectMap,
+  type ThreeEvent,
+} from "@react-three/fiber";
+import { useRef } from "react";
+import type { Texture } from "three";
+import { Group, Mesh, MeshStandardMaterial, Vector2 } from "three";
+import { applyPitchYawLimits } from "../core/blitz/applyPitchYawLimits";
+import { hasEquipment } from "../core/blitzkit/hasEquipment";
+import { modelTransformEvent } from "../core/blitzkit/modelTransform";
+import { controlsEnabledEvent } from "../core/controlsEnabled";
+import { useBatched } from "../hooks/useBatched";
+import { useModel } from "../hooks/useModel";
+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";
+
+interface SectionProps {
+  map: ObjectMap;
+}
+
+function Tracks({ map }: SectionProps) {
+  const Batched = useBatched(map, true);
+
+  const position = useRef(new Vector2());
+  const delta = useRef(new Vector2());
+
+  const textures = useRef(new Set<Texture | null>());
+
+  function handlePointerMove(event: PointerEvent) {
+    delta.current.set(event.clientX, event.clientY).sub(position.current);
+    position.current.set(event.clientX, event.clientY);
+
+    const deltaX = delta.current.x / window.innerWidth;
+    const deltaY = delta.current.y / window.innerHeight;
+
+    const offset = deltaX + deltaY;
+
+    for (const texture of textures.current) {
+      if (!texture) continue;
+      texture.offset.y += offset;
+    }
+
+    invalidate();
+  }
+  function handlePointerUp() {
+    controlsEnabledEvent.dispatch(true);
+
+    window.removeEventListener("pointermove", handlePointerMove);
+    window.removeEventListener("pointerup", handlePointerUp);
+  }
+  function handlePointerDown(event: ThreeEvent<PointerEvent>) {
+    if (Tankopedia.state.display !== TankopediaDisplay.Model) {
+      return;
+    }
+
+    const material = (event.object as Mesh).material as MeshStandardMaterial;
+
+    textures.current = new Set([
+      material.map,
+      material.aoMap,
+      material.normalMap,
+      material.roughnessMap,
+      material.metalnessMap,
+    ]);
+
+    position.current.set(event.clientX, event.clientY);
+    event.stopPropagation();
+
+    controlsEnabledEvent.dispatch(false);
+
+    window.addEventListener("pointermove", handlePointerMove);
+    window.addEventListener("pointerup", handlePointerUp);
+  }
+
+  return (
+    <Batched
+      onPointerDown={handlePointerDown}
+      slicer={(node) => {
+        return node.name.startsWith("chassis_track_");
+      }}
+    />
+  );
+}
+
+function Hull({ map }: SectionProps) {
+  const Batched = useBatched(map, true);
+
+  function handlePointerDown(event: ThreeEvent<PointerEvent>) {
+    event.stopPropagation();
+  }
+
+  return (
+    <Batched
+      onPointerDown={handlePointerDown}
+      slicer={(node) => {
+        const isHull = node.name === "hull";
+        const isWheel = node.name.startsWith("chassis_wheel_");
+
+        return isHull || isWheel;
+      }}
+    />
+  );
+}
+
+function Turret({ map }: SectionProps) {
+  const turret = Duel.use((state) => state.protagonist.turret);
+  const gun = Duel.use((state) => state.protagonist.gun);
+
+  const tankModelDefinition = useTankModelDefinition();
+  const turretModelDefinition = tankModelDefinition.turrets[turret.id];
+  const gunModelDefinition = turretModelDefinition.guns[gun.id];
+
+  const Batched = useBatched(map, true);
+
+  const position = useRef(new Vector2());
+  const delta = useRef(new Vector2());
+
+  const canvas = useThree((state) => state.gl.domElement);
+
+  function onPointerDown(event: ThreeEvent<PointerEvent>) {
+    event.stopPropagation();
+
+    position.current.set(event.clientX, event.clientY);
+
+    controlsEnabledEvent.dispatch(false);
+    Tankopedia.mutate((draft) => {
+      draft.shot = undefined;
+      draft.highlightArmor = undefined;
+    });
+    window.addEventListener("pointermove", handlePointerMove);
+    window.addEventListener("pointerup", handlePointerUp);
+  }
+  function handlePointerMove(event: PointerEvent) {
+    const hasImprovedVerticalStabilizer = hasEquipment(
+      122,
+      Duel.state.protagonist.tank.equipment_preset,
+      Duel.state.protagonist.equipmentMatrix,
+    );
+    const hasDownImprovedVerticalStabilizer = hasEquipment(
+      124,
+      Duel.state.protagonist.tank.equipment_preset,
+      Duel.state.protagonist.equipmentMatrix,
+    );
+    const boundingRect = canvas.getBoundingClientRect();
+
+    delta.current.set(event.clientX, event.clientY).sub(position.current);
+    position.current.set(event.clientX, event.clientY);
+
+    const [pitch, yaw] = applyPitchYawLimits(
+      modelTransformEvent.last!.pitch,
+      modelTransformEvent.last!.yaw +
+        delta.current.x * (Math.PI / boundingRect.width),
+      gunModelDefinition.pitch!,
+      turretModelDefinition.yaw,
+      hasImprovedVerticalStabilizer,
+      hasDownImprovedVerticalStabilizer,
+    );
+    modelTransformEvent.dispatch({ pitch, yaw });
+  }
+  function handlePointerUp() {
+    controlsEnabledEvent.dispatch(true);
+    window.removeEventListener("pointermove", handlePointerMove);
+    window.removeEventListener("pointerup", handlePointerUp);
+  }
+
+  return (
+    <Batched
+      onPointerDown={onPointerDown}
+      slicer={(node) => {
+        const isCurrentTurret =
+          node.name ===
+          `turret_${turretModelDefinition.model_id
+            .toString()
+            .padStart(2, "0")}`;
+
+        return isCurrentTurret;
+      }}
+    />
+  );
+}
+
+function Gun({ map }: SectionProps) {
+  const Batched = useBatched(map, true);
+
+  const turret = Duel.use((state) => state.protagonist.turret);
+  const gun = Duel.use((state) => state.protagonist.gun);
+
+  const tankModelDefinition = useTankModelDefinition();
+  const turretModelDefinition = tankModelDefinition.turrets[turret.id];
+  const gunModelDefinition = turretModelDefinition.guns[gun.id];
+
+  const position = useRef(new Vector2());
+  const delta = useRef(new Vector2());
+  const pitch = useRef(0);
+  const yaw = useRef(0);
+
+  const canvas = useThree((state) => state.gl.domElement);
+
+  function handlePointerMove(event: PointerEvent) {
+    const hasImprovedVerticalStabilizer = hasEquipment(
+      122,
+      Duel.state.protagonist.tank.equipment_preset,
+      Duel.state.protagonist.equipmentMatrix,
+    );
+    const hasDownImprovedVerticalStabilizer = hasEquipment(
+      124,
+      Duel.state.protagonist.tank.equipment_preset,
+      Duel.state.protagonist.equipmentMatrix,
+    );
+    const boundingRect = canvas.getBoundingClientRect();
+    delta.current.set(event.clientX, event.clientY).sub(position.current);
+    position.current.set(event.clientX, event.clientY);
+
+    [pitch.current, yaw.current] = applyPitchYawLimits(
+      pitch.current - delta.current.y * (Math.PI / boundingRect.height),
+      yaw.current + delta.current.x * (Math.PI / boundingRect.width),
+      gunModelDefinition.pitch!,
+      turretModelDefinition.yaw,
+      hasImprovedVerticalStabilizer,
+      hasDownImprovedVerticalStabilizer,
+    );
+    modelTransformEvent.dispatch({ pitch: pitch.current, yaw: yaw.current });
+  }
+  function handlePointerUp() {
+    controlsEnabledEvent.dispatch(true);
+    window.removeEventListener("pointermove", handlePointerMove);
+    window.removeEventListener("pointerup", handlePointerUp);
+  }
+  function onPointerDown(event: ThreeEvent<PointerEvent>) {
+    event.stopPropagation();
+
+    controlsEnabledEvent.dispatch(false);
+    Tankopedia.mutate((draft) => {
+      draft.shot = undefined;
+      draft.highlightArmor = undefined;
+    });
+
+    position.current.set(event.clientX, event.clientY);
+    pitch.current = modelTransformEvent.last!.pitch;
+    yaw.current = modelTransformEvent.last!.yaw;
+
+    window.addEventListener("pointermove", handlePointerMove);
+    window.addEventListener("pointerup", handlePointerUp);
+  }
+
+  return (
+    <Batched
+      onPointerDown={onPointerDown}
+      slicer={(node) => {
+        const isCurrentMantlet =
+          node.name ===
+          `gun_${gunModelDefinition.model_id.toString().padStart(2, "0")}_mask`;
+        const isCurrentGun =
+          node.name ===
+          `gun_${gunModelDefinition.model_id.toString().padStart(2, "0")}`;
+
+        return isCurrentGun || isCurrentMantlet;
+      }}
+    />
+  );
+}
+
+export function TankModel() {
+  const protagonist = Duel.use((draft) => draft.protagonist);
+
+  const track = Duel.use((state) => state.protagonist.track);
+  const turret = Duel.use((state) => state.protagonist.turret);
+
+  const hullContainer = useRef<Group>(null);
+  const turretContainer = useRef<Group>(null!);
+  const gunContainer = useRef<Group>(null!);
+
+  const { gltf } = useModel(protagonist.tank.id);
+
+  useTankTransform(track, turret, turretContainer, gunContainer);
+
+  return (
+    <ModelTankWrapper ref={hullContainer}>
+      <Tracks map={gltf} />
+      <Hull map={gltf} />
+
+      <group ref={turretContainer}>
+        <Turret map={gltf} />
+
+        <group ref={gunContainer}>
+          <Gun map={gltf} />
+        </group>
+      </group>
+    </ModelTankWrapper>
+  );
+}

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

@@ -1,7 +1,7 @@
 import {
   normalizeBoundingBox,
   resolveDpm,
-  tankBoundingBox,
+  unionBoundingBox,
   type TankDefinition,
 } from "@blitzkit/core";
 import { useMemo } from "react";
@@ -112,7 +112,10 @@ export function TankSearchCard({ tank, onSelect }: TankSearchCardProps) {
         return (tank.camouflage_still * gun.camouflage_loss * 100).toFixed(0);
       case "survivability.volume": {
         const dimensions = normalizeBoundingBox(
-          tankBoundingBox(tankModelDefinition, turretModelDefinition),
+          unionBoundingBox(
+            tankModelDefinition.bounding_box!,
+            turretModelDefinition.bounding_box!,
+          ),
         );
 
         return (dimensions.x * dimensions.y * dimensions.z).toFixed(0);
@@ -120,7 +123,10 @@ export function TankSearchCard({ tank, onSelect }: TankSearchCardProps) {
 
       case "survivability.length": {
         const bounds = normalizeBoundingBox(
-          tankBoundingBox(tankModelDefinition, turretModelDefinition),
+          unionBoundingBox(
+            tankModelDefinition.bounding_box!,
+            turretModelDefinition.bounding_box!,
+          ),
         );
 
         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,
-  tankBoundingBox,
+  unionBoundingBox,
   type TankDefinition,
 } from "@blitzkit/core";
 import { literals } from "@blitzkit/i18n/src/literals";
@@ -137,10 +137,16 @@ export const TankSearch = memo<TankSearchProps>(
               const bTurretModelDefinition =
                 bTankModelDefinition.turrets[b.turrets.at(-1)!.id];
               const aSize = normalizeBoundingBox(
-                tankBoundingBox(aTankModelDefinition, aTurretModelDefinition),
+                unionBoundingBox(
+                  aTankModelDefinition.bounding_box!,
+                  aTurretModelDefinition.bounding_box!,
+                ),
               );
               const bSize = normalizeBoundingBox(
-                tankBoundingBox(bTankModelDefinition, bTurretModelDefinition),
+                unionBoundingBox(
+                  bTankModelDefinition.bounding_box!,
+                  bTurretModelDefinition.bounding_box!,
+                ),
               );
               const aVolume = aSize.x * aSize.y * aSize.z;
               const bVolume = bSize.x * bSize.y * bSize.z;
@@ -158,10 +164,16 @@ export const TankSearch = memo<TankSearchProps>(
               const bTurretModelDefinition =
                 bTankModelDefinition.turrets[b.turrets.at(-1)!.id];
               const aSize = normalizeBoundingBox(
-                tankBoundingBox(aTankModelDefinition, aTurretModelDefinition),
+                unionBoundingBox(
+                  aTankModelDefinition.bounding_box!,
+                  aTurretModelDefinition.bounding_box!,
+                ),
               );
               const bSize = normalizeBoundingBox(
-                tankBoundingBox(bTankModelDefinition, bTurretModelDefinition),
+                unionBoundingBox(
+                  bTankModelDefinition.bounding_box!,
+                  bTurretModelDefinition.bounding_box!,
+                ),
               );
               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/HeroSection/components/TankSandbox/components/Lighting.tsx

@@ -125,7 +125,7 @@ export function Lighting({ hasPbr }: Props) {
               position={position}
               intensity={intensity}
               penumbra={1}
-              castShadow={highGraphics}
+              castShadow={highGraphics && index === 0}
               decay={1}
               color="#ffffff"
               angle={0}

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

@@ -1,271 +0,0 @@
-import { invalidate, useThree, type ThreeEvent } from "@react-three/fiber";
-import { 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 { controlsEnabledEvent } from "../../../../../../core/controlsEnabled";
-import { useModel } from "../../../../../../hooks/useModel";
-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";
-
-export function TankModel() {
-  const protagonist = Duel.use((draft) => draft.protagonist);
-  const track = Duel.use((state) => state.protagonist.track);
-  const turret = Duel.use((state) => state.protagonist.turret);
-  const canvas = useThree((state) => state.gl.domElement);
-  const hullContainer = useRef<Group>(null);
-  const turretContainer = useRef<Group>(null!);
-  const gunContainer = useRef<Group>(null!);
-  const tankModelDefinition = useTankModelDefinition();
-  const turretModelDefinition =
-    tankModelDefinition.turrets[protagonist.turret.id];
-  const gunModelDefinition = turretModelDefinition.guns[protagonist.gun.id];
-  const { gltf } = useModel(protagonist.tank.id);
-  const nodes = Object.values(gltf.nodes);
-
-  useTankTransform(track, turret, turretContainer, gunContainer);
-
-  return (
-    <ModelTankWrapper ref={hullContainer}>
-      {nodes.map((node) => {
-        const isHull = node.name === "hull";
-        const isWheel = node.name.startsWith("chassis_wheel_");
-        const isTrack = node.name.startsWith("chassis_track_");
-        const isVisible = isHull || isWheel || isTrack;
-        const position = new Vector2();
-        const delta = new Vector2();
-
-        if (!isVisible) return null;
-
-        function translateTexture(offset: number) {
-          const mesh = node.children[0] as Mesh;
-          const material = mesh?.material as MeshStandardMaterial;
-
-          if (!material) return;
-
-          invalidate();
-
-          const textures = new Set([
-            material.map,
-            material.aoMap,
-            material.normalMap,
-            material.roughnessMap,
-            material.metalnessMap,
-          ]);
-
-          for (const texture of textures) {
-            if (texture) texture.offset.y += offset;
-          }
-        }
-
-        function onPointerDown(event: ThreeEvent<PointerEvent>) {
-          if (isTrack && Tankopedia.state.display === TankopediaDisplay.Model) {
-            position.set(event.clientX, event.clientY);
-            event.stopPropagation();
-
-            controlsEnabledEvent.dispatch(false);
-
-            window.addEventListener("pointermove", handlePointerMove);
-            window.addEventListener("pointerup", handlePointerUp);
-          } else {
-            event.stopPropagation();
-          }
-        }
-        function handlePointerMove(event: PointerEvent) {
-          delta.set(event.clientX, event.clientY).sub(position);
-          position.set(event.clientX, event.clientY);
-          const deltaX = delta.x / window.innerWidth;
-          const deltaY = delta.y / window.innerHeight;
-
-          translateTexture(deltaX + deltaY);
-        }
-        function handlePointerUp() {
-          controlsEnabledEvent.dispatch(true);
-
-          window.removeEventListener("pointermove", handlePointerMove);
-          window.removeEventListener("pointerup", handlePointerUp);
-        }
-
-        return jsxTree(node, {
-          mesh(_, props, key) {
-            return (
-              <mesh
-                {...props}
-                key={key}
-                onPointerDown={onPointerDown}
-                castShadow
-                receiveShadow
-              />
-            );
-          },
-        });
-      })}
-
-      <group ref={turretContainer}>
-        {nodes.map((node) => {
-          const isTurret = node.name.startsWith("turret_");
-          const isCurrentTurret =
-            node.name ===
-            `turret_${turretModelDefinition.model_id
-              .toString()
-              .padStart(2, "0")}`;
-          const isVisible = isCurrentTurret;
-          const position = new Vector2();
-          const delta = new Vector2();
-
-          if (!isVisible) return null;
-
-          function onPointerDown(event: ThreeEvent<PointerEvent>) {
-            event.stopPropagation();
-
-            if (!isTurret) return;
-
-            position.set(event.clientX, event.clientY);
-
-            controlsEnabledEvent.dispatch(false);
-            Tankopedia.mutate((draft) => {
-              draft.shot = undefined;
-              draft.highlightArmor = undefined;
-            });
-            window.addEventListener("pointermove", handlePointerMove);
-            window.addEventListener("pointerup", handlePointerUp);
-          }
-          function handlePointerMove(event: PointerEvent) {
-            const hasImprovedVerticalStabilizer = hasEquipment(
-              122,
-              Duel.state.protagonist.tank.equipment_preset,
-              Duel.state.protagonist.equipmentMatrix,
-            );
-            const hasDownImprovedVerticalStabilizer = hasEquipment(
-              124,
-              Duel.state.protagonist.tank.equipment_preset,
-              Duel.state.protagonist.equipmentMatrix,
-            );
-            const boundingRect = canvas.getBoundingClientRect();
-
-            delta.set(event.clientX, event.clientY).sub(position);
-            position.set(event.clientX, event.clientY);
-
-            const [pitch, yaw] = applyPitchYawLimits(
-              modelTransformEvent.last!.pitch,
-              modelTransformEvent.last!.yaw +
-                delta.x * (Math.PI / boundingRect.width),
-              gunModelDefinition.pitch!,
-              turretModelDefinition.yaw,
-              hasImprovedVerticalStabilizer,
-              hasDownImprovedVerticalStabilizer,
-            );
-            modelTransformEvent.dispatch({ pitch, yaw });
-          }
-          function handlePointerUp() {
-            controlsEnabledEvent.dispatch(true);
-            window.removeEventListener("pointermove", handlePointerMove);
-            window.removeEventListener("pointerup", handlePointerUp);
-          }
-
-          return jsxTree(node, {
-            mesh(_, props, key) {
-              return (
-                <mesh
-                  {...props}
-                  key={key}
-                  onPointerDown={onPointerDown}
-                  castShadow
-                  receiveShadow
-                />
-              );
-            },
-          });
-        })}
-
-        <group ref={gunContainer}>
-          {nodes.map((node) => {
-            const isCurrentMantlet =
-              node.name ===
-              `gun_${gunModelDefinition.model_id
-                .toString()
-                .padStart(2, "0")}_mask`;
-            const isCurrentGun =
-              node.name ===
-              `gun_${gunModelDefinition.model_id.toString().padStart(2, "0")}`;
-            const isVisible = isCurrentGun || isCurrentMantlet;
-            const position = new Vector2();
-            const delta = new Vector2();
-
-            if (!isVisible) return null;
-
-            let pitch = 0;
-            let yaw = 0;
-
-            function onPointerDown(event: ThreeEvent<PointerEvent>) {
-              event.stopPropagation();
-
-              controlsEnabledEvent.dispatch(false);
-              Tankopedia.mutate((draft) => {
-                draft.shot = undefined;
-                draft.highlightArmor = undefined;
-              });
-
-              position.set(event.clientX, event.clientY);
-              pitch = modelTransformEvent.last!.pitch;
-              yaw = modelTransformEvent.last!.yaw;
-
-              window.addEventListener("pointermove", handlePointerMove);
-              window.addEventListener("pointerup", handlePointerUp);
-            }
-            function handlePointerMove(event: PointerEvent) {
-              const hasImprovedVerticalStabilizer = hasEquipment(
-                122,
-                Duel.state.protagonist.tank.equipment_preset,
-                Duel.state.protagonist.equipmentMatrix,
-              );
-              const hasDownImprovedVerticalStabilizer = hasEquipment(
-                124,
-                Duel.state.protagonist.tank.equipment_preset,
-                Duel.state.protagonist.equipmentMatrix,
-              );
-              const boundingRect = canvas.getBoundingClientRect();
-              delta.set(event.clientX, event.clientY).sub(position);
-              position.set(event.clientX, event.clientY);
-
-              [pitch, yaw] = applyPitchYawLimits(
-                pitch - delta.y * (Math.PI / boundingRect.height),
-                yaw + delta.x * (Math.PI / boundingRect.width),
-                gunModelDefinition.pitch!,
-                turretModelDefinition.yaw,
-                hasImprovedVerticalStabilizer,
-                hasDownImprovedVerticalStabilizer,
-              );
-              modelTransformEvent.dispatch({ pitch, yaw });
-            }
-            function handlePointerUp() {
-              controlsEnabledEvent.dispatch(true);
-              window.removeEventListener("pointermove", handlePointerMove);
-              window.removeEventListener("pointerup", handlePointerUp);
-            }
-
-            return jsxTree(node, {
-              mesh(_, props, key) {
-                return (
-                  <mesh
-                    {...props}
-                    key={key}
-                    onPointerDown={onPointerDown}
-                    castShadow
-                    receiveShadow
-                  />
-                );
-              },
-            });
-          })}
-        </group>
-      </group>
-    </ModelTankWrapper>
-  );
-}

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

@@ -23,12 +23,12 @@ import {
   type ThicknessRange,
 } from "../../../../Armor/components/StaticArmor";
 import { SmartCanvas } from "../../../../SmartCanvas";
+import { TankModel } from "../../../../TankModel";
 import { AutoClear } from "./components/AutoClear";
 import { Controls } from "./components/Control";
 import { InitialAligner } from "./components/InitialAligner";
 import { Lighting } from "./components/Lighting";
 import { SceneProps } from "./components/SceneProps";
-import { TankModel } from "./components/TankModel";
 
 interface TankSandboxProps {
   thicknessRange: ThicknessRange;

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

@@ -1,32 +0,0 @@
-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/tankCharacteristics.ts

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

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

@@ -7,23 +7,12 @@ 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, gun, shell } = defaultTankWeapon(tank);
+  const turret = tank.turrets.at(-1)!;
+  const gun = turret.guns.at(-1)!;
 
   return {
     camouflage: true,
@@ -33,7 +22,7 @@ export function tankToDuelMember(
     provisions: createDefaultProvisions(tank, gun, provisionDefinitions),
     engine: tank.engines.at(-1)!,
     gun,
-    shell,
+    shell: tank.turrets.at(-1)!.guns.at(-1)!.shells[0],
     tank,
     track: tank.tracks.at(-1)!,
     turret,

packages/website/src/hooks/useBatched.tsx

@@ -0,0 +1,89 @@
+import type { ObjectMap } from "@react-three/fiber";
+import type { ComponentProps } from "react";
+import {
+  BatchedMesh,
+  Group,
+  Mesh,
+  MeshStandardMaterial,
+  type Object3D,
+} from "three";
+
+interface BatchedProps extends ComponentProps<"group"> {
+  slicer: (node: Object3D) => boolean;
+  mutator?: (mesh: Mesh) => void;
+}
+
+export function useBatched(map: ObjectMap, shadows = false) {
+  return function Batched({ slicer, mutator, ...props }: BatchedProps) {
+    const groups = new Map<
+      MeshStandardMaterial,
+      { clonedMaterial: MeshStandardMaterial; meshes: Mesh[] }
+    >();
+
+    for (const node of Object.values(map.nodes)) {
+      if (!slicer(node)) continue;
+
+      node.traverse((object) => {
+        if (!(object instanceof Mesh)) return;
+
+        const originalMaterial = object.material;
+
+        if (!(originalMaterial instanceof MeshStandardMaterial)) return;
+
+        let group = groups.get(originalMaterial);
+
+        if (!group) {
+          group = {
+            clonedMaterial: originalMaterial.clone(),
+            meshes: [],
+          };
+          groups.set(originalMaterial, group);
+        }
+
+        group.meshes.push(object);
+      });
+    }
+
+    const wrapper = new Group();
+
+    for (const { clonedMaterial: material, meshes } of groups.values()) {
+      let vertices = 0;
+      let indices = 0;
+
+      for (const mesh of meshes) {
+        vertices += mesh.geometry.attributes.position.count;
+        indices += mesh.geometry.index!.count;
+      }
+
+      const batched = new BatchedMesh(
+        meshes.length,
+        vertices,
+        indices,
+        material,
+      );
+
+      for (const mesh of meshes) {
+        const geometryId = batched.addGeometry(mesh.geometry);
+        const instanceId = batched.addInstance(geometryId);
+
+        mesh.updateWorldMatrix(true, false);
+        batched.setMatrixAt(instanceId, mesh.matrixWorld);
+
+        if (shadows) {
+          batched.castShadow = true;
+          batched.receiveShadow = true;
+        }
+
+        mutator?.(mesh);
+      }
+
+      wrapper.add(batched);
+    }
+
+    return (
+      <group {...props}>
+        <primitive object={wrapper} />
+      </group>
+    );
+  };
+}

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

@@ -1,39 +0,0 @@
-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]/tanks/[id]/collision.glb.ts

@@ -1,15 +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";
 
 export { getStaticPaths } from "./_index";
@@ -55,10 +56,13 @@ async function extractArmor(vfs: AbstractVFS, fileName: string) {
   const scene = document.createScene();
   const buffer = document.createBuffer();
 
-  parseHierarchies<Scene | Node>(
-    sc2["#hierarchy"],
-    scene,
-    (hierarchy, components, parent) => {
+  function parseHierarchies(hierarchies: Hierarchy[], parent: Scene | Node) {
+    hierarchies.forEach((hierarchy) => {
+      const components = times(
+        hierarchy.components.count,
+        (index) => hierarchy.components[index.toString().padStart(4, "0")],
+      );
+
       components.forEach((component) => {
         switch (component["comp.typename"]) {
           case "TransformComponent":
@@ -159,9 +163,13 @@ async function extractArmor(vfs: AbstractVFS, fileName: string) {
         }
       });
 
-      return parent;
-    },
-  );
+      if (hierarchy["#hierarchy"]) {
+        parseHierarchies(hierarchy["#hierarchy"], parent);
+      }
+    });
+  }
+
+  parseHierarchies(sc2["#hierarchy"], scene);
 
   return document;
 }

packages/website/src/pages/[...chunk_api]/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,
@@ -240,10 +240,8 @@ async function extractModel(vfs: AbstractVFS, path: string) {
     materials.set(id, resolvedMaterial);
   });
 
-  parseHierarchies<Scene | Node>(
-    sc2["#hierarchy"],
-    scene,
-    (hierarchy, components, parent) => {
+  function parseHierarchies(hierarchies: Hierarchy[], parent: Scene | Node) {
+    hierarchies.forEach((hierarchy) => {
       if (
         omitMeshNames.start.some((omit) => hierarchy.name.startsWith(omit)) ||
         omitMeshNames.end.some((omit) => hierarchy.name.endsWith(omit))
@@ -251,6 +249,10 @@ 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"]) {
@@ -359,11 +361,15 @@ async function extractModel(vfs: AbstractVFS, path: string) {
         }
       });
 
-      parent.addChild(node);
+      if (hierarchy["#hierarchy"]) {
+        parseHierarchies(hierarchy["#hierarchy"], node);
+      }
 
-      return node;
-    },
-  );
+      parent.addChild(node);
+    });
+  }
+
+  parseHierarchies(sc2["#hierarchy"], scene);
 
   scene.addChild(document.createNode("test"));
 

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

@@ -5,7 +5,6 @@ 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 { Countdown } from "../../../components/Countdown";
 import HomeHero from "../../../components/HomeHero.astro";
 import { Plugs } from "../../../components/Plugs";
 import ToolCard from "../../../components/ToolCard.astro";
@@ -66,8 +65,6 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, () => {
 <BaseLayout {locale}>
   <HomeHero />
 
-  <Countdown client:load />
-
   {
     locale !== locales.default && (
       <Flex justify="center" pt="4" my="4">

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

@@ -13,7 +13,6 @@ 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";
@@ -54,7 +53,9 @@ 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, gun, shell } = defaultTankWeapon(tank);
+const turret = tank.turrets.at(-1)!;
+const gun = turret.guns.at(-1)!;
+const shell = gun.shells[0];
 const characteristics = tankCharacteristics(
   {
     tank,