Merge pull request #353 from Hitjack007/remove-imgur-references

Fix: migrate Imgur images to BlitzKit hosting

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/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/streams/sc2.ts

@@ -90,6 +90,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/i18n/strings/pl.json

@@ -220,190 +220,190 @@
         "clear": "Clear",
         "tier": "Tier {tier}",
         "passive": "{name} (Passive)",
-        "active": "{name} (Active)",
+        "active": "{name} (Aktywne)",
         "no_tanks_found": {
-          "body": "No tanks found.",
+          "body": "Nie znaleziono czołgu.",
           "search_again": "",
           "clear_filters": "Try clearing filters."
         },
         "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": {
       "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",
@@ -656,10 +656,10 @@
           "loader": "Loader"
         },
         "maneuverability": {
-          "title": "Maneuverability"
+          "title": "Mobilność "
         },
         "survivability": {
-          "title": "Survivability"
+          "title": "Przetrwanie"
         }
       },
       "compare": {

packages/i18n/strings/pt.json

@@ -41,7 +41,7 @@
       "development": "Development",
       "opentest": "TesteAberto",
       "preview": "Preview",
-      "production": "Production"
+      "production": "Produção"
     },
     "locales": {
       "en": "Inglês",
@@ -187,11 +187,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 +207,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",

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/Giveaway.tsx

@@ -1,89 +0,0 @@
-import { Code, Flex, Heading, Link, Text } from "@radix-ui/themes";
-import { useEffect, useState, type ReactNode } from "react";
-import type { MaybeSkeletonComponentProps } from "../types/maybeSkeletonComponentProps";
-import { InlineSkeleton } from "./InlineSkeleton";
-
-const TIME = 1764898200 * 1000;
-
-export function Giveaway({ skeleton }: MaybeSkeletonComponentProps) {
-  const [timeLeft, setTimeLeft] = useState<number>(TIME - Date.now());
-
-  useEffect(() => {
-    const interval = setInterval(() => {
-      setTimeLeft(TIME - Date.now());
-    }, 1000);
-
-    return () => {
-      clearInterval(interval);
-    };
-  }, []);
-
-  let string: ReactNode;
-
-  if (timeLeft > 0) {
-    const hours = Math.floor(timeLeft / (1000 * 60 * 60));
-    const minutes = Math.floor((timeLeft / (1000 * 60)) % 60)
-      .toString()
-      .padStart(2, "0");
-    const seconds = Math.floor((timeLeft / 1000) % 60)
-      .toString()
-      .padStart(2, "0");
-
-    string = (
-      <>
-        in{" "}
-        <Code highContrast>
-          {hours}h {minutes}m {seconds}s
-        </Code>
-      </>
-    );
-  } else {
-    string = "has ended. Come again later!";
-  }
-
-  return (
-    <Flex justify="center" px="4">
-      <Link
-        color="gray"
-        highContrast
-        style={{ display: "content" }}
-        href="https://discord.gg/njQdBhNS?event=1446208951136813117"
-        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",
-            boxShadow: "0 0 var(--space-7) var(--blue-a5)",
-          }}
-          align="center"
-          gap="5"
-        >
-          <img
-            src="https://i.imgur.com/mvmJQgB.png"
-            style={{
-              height: "min(15vw, 5rem)",
-              filter: "drop-shadow(0.5rem 0.5rem 1rem #00000080)",
-            }}
-          />
-
-          <Flex direction="column">
-            <Heading size={{ initial: "4", sm: "6" }}>
-              Music Box giveaway {!skeleton && string}{" "}
-              {skeleton && <InlineSkeleton width="10rem" />}
-            </Heading>
-            <Text size={{ initial: "2", sm: "3" }}>
-              Join the BlitzKit Discord server event
-            </Text>
-          </Flex>
-        </Flex>
-      </Link>
-    </Flex>
-  );
-}

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/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/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/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/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]/tanks/[id]/collision.glb.ts

@@ -1,16 +1,15 @@
 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";
@@ -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_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,8 +240,10 @@ async function extractModel(vfs: AbstractVFS, path: string) {
     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 +251,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"]) {
@@ -361,15 +359,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"));