Merge pull request #65 from tresabhi/1.15.12

.github/workflows/cd-asia-ratings-latest.yml

@@ -1,34 +0,0 @@
-name: CD Asia Ratings Latest
-
-on:
-  schedule:
-    - cron: "0 0 * * *"
-
-jobs:
-  host:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Use node
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18
-          cache: "npm"
-
-      - name: Install Yarn
-        run: npm install --location=global yarn
-
-      - name: Use node_modules cache
-        uses: actions/cache@v3
-        with:
-          path: "**/node_modules"
-          key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
-
-      - name: Install dependencies
-        run: yarn
-
-      - name: Generate leaderboard
-        run: GH_TOKEN=${{ secrets.GH_TOKEN }} yarn publish:ratingsleaderboard --region=asia --latest

.github/workflows/cd-asia-ratings-leaderboards.yml

@@ -1,34 +0,0 @@
-name: CD Asia Ratings Leaderboards
-
-on:
-  schedule:
-    - cron: "0 17 * * *"
-
-jobs:
-  host:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Use node
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18
-          cache: "npm"
-
-      - name: Install Yarn
-        run: npm install --location=global yarn
-
-      - name: Use node_modules cache
-        uses: actions/cache@v3
-        with:
-          path: "**/node_modules"
-          key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
-
-      - name: Install dependencies
-        run: yarn
-
-      - name: Generate leaderboard
-        run: GH_TOKEN=${{ secrets.GH_TOKEN }} yarn publish:ratingsleaderboard --region=asia

.github/workflows/cd-docs.yml

@@ -2,7 +2,7 @@ name: CD Docs
 
 on:
   push:
-    branches: [main]
+    branches: main
 
 jobs:
   build:

.github/workflows/cd-host.yml

@@ -2,7 +2,7 @@ name: CD Host
 
 on:
   schedule:
-    - cron: '0 */6 * * *'
+    - cron: '0 */5 * * *'
   workflow_dispatch:
 
 concurrency:

.github/workflows/cd-ratings-asia.yml

@@ -1,8 +1,12 @@
-name: CD Europe Ratings Latest
+name: CD Ratings Asia
+
+# latest: '0 0 * * *'
+# asia midnight: '0 17 * * *'
 
 on:
   schedule:
-    - cron: "0 0 * * *"
+    - cron: '0 0 * * *'
+    - cron: '0 17 * * *'
 
 jobs:
   host:
@@ -16,7 +20,7 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: 18
-          cache: "npm"
+          cache: 'npm'
 
       - name: Install Yarn
         run: npm install --location=global yarn
@@ -24,11 +28,11 @@ jobs:
       - name: Use node_modules cache
         uses: actions/cache@v3
         with:
-          path: "**/node_modules"
+          path: '**/node_modules'
           key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
 
       - name: Install dependencies
         run: yarn
 
       - name: Generate leaderboard
-        run: GH_TOKEN=${{ secrets.GH_TOKEN }} yarn publish:ratingsleaderboard --region=eu --latest
+        run: GH_TOKEN=${{ secrets.GH_TOKEN }} DISCORD_TOKEN=${{ secrets.DISCORD_TOKEN }} yarn publish:ratingsleaderboard --region=asia --target=${{ github.event.schedule == '0 0 * * *' && 'latest' || 'midnight' }}

.github/workflows/cd-ratings-eu.yml

@@ -1,8 +1,12 @@
-name: CD North America Ratings Latest
+name: CD Ratings Europe
+
+# latest: '0 0 * * *'
+# eu midnight: '0 23 * * *'
 
 on:
   schedule:
     - cron: '0 0 * * *'
+    - cron: '0 23 * * *'
 
 jobs:
   host:
@@ -31,4 +35,4 @@ jobs:
         run: yarn
 
       - name: Generate leaderboard
-        run: GH_TOKEN=${{ secrets.GH_TOKEN }} yarn publish:ratingsleaderboard --region=na --latest
+        run: GH_TOKEN=${{ secrets.GH_TOKEN }} DISCORD_TOKEN=${{ secrets.DISCORD_TOKEN }} yarn publish:ratingsleaderboard --region=eu --target=${{ github.event.schedule == '0 0 * * *' && 'latest' || 'midnight' }}

.github/workflows/cd-ratings-na.yml

@@ -1,8 +1,12 @@
-name: CD Europe Ratings Leaderboards
+name: CD Ratings North America
+
+# latest: '0 0 * * *'
+# na midnight: '0 5 * * *'
 
 on:
   schedule:
-    - cron: "0 23 * * *"
+    - cron: '0 0 * * *'
+    - cron: '0 5 * * *'
 
 jobs:
   host:
@@ -16,7 +20,7 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: 18
-          cache: "npm"
+          cache: 'npm'
 
       - name: Install Yarn
         run: npm install --location=global yarn
@@ -24,11 +28,11 @@ jobs:
       - name: Use node_modules cache
         uses: actions/cache@v3
         with:
-          path: "**/node_modules"
+          path: '**/node_modules'
           key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
 
       - name: Install dependencies
         run: yarn
 
       - name: Generate leaderboard
-        run: GH_TOKEN=${{ secrets.GH_TOKEN }} yarn publish:ratingsleaderboard --region=eu
+        run: GH_TOKEN=${{ secrets.GH_TOKEN }} DISCORD_TOKEN=${{ secrets.DISCORD_TOKEN }} yarn publish:ratingsleaderboard --region=na --target=${{ github.event.schedule == '0 0 * * *' && 'latest' || 'midnight' }}

.github/workflows/ci-build-bot.yml

@@ -1,6 +1,6 @@
 name: CI Build Bot
 
-on: [push, pull_request]
+on: push
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

.github/workflows/ci-build-docs.yml

@@ -1,6 +1,6 @@
 name: CI Build Docs
 
-on: [push, pull_request]
+on: push
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

.github/workflows/ci-build-website.yml

@@ -1,6 +1,6 @@
 name: CI Build Website
 
-on: [push, pull_request]
+on: push
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

.github/workflows/ci-version.yml

@@ -1,8 +1,6 @@
-name: CD North America Ratings Leaderboards
+name: CI Version
 
-on:
+on: push
-  schedule:
-    - cron: '0 5 * * *'
 
 jobs:
   host:
@@ -31,4 +29,4 @@ jobs:
         run: yarn
 
       - name: Generate leaderboard
-        run: GH_TOKEN=${{ secrets.GH_TOKEN }} yarn publish:ratingsleaderboard --region=na
+        run: yarn lint:version

.vscode/settings.json

@@ -1,39 +1,60 @@
 {
   "cSpell.words": [
+    "AABBOX",
     "Abhi",
     "accountinfo",
+    "alphatest",
+    "apcr",
+    "atgm",
     "bepaint",
+    "BINORMAL",
     "blitzstars",
     "cleandist",
     "cockroackdb",
     "corsproxy",
+    "CUBETEXCOORD",
     "customperiod",
     "deburr",
+    "decalmask",
     "diacriticless",
+    "dvpl",
+    "DVPLCRC",
     "Everytime",
+    "FASTNAME",
     "fullstats",
     "fuzzysort",
+    "gamemode",
     "immer",
+    "JOINTINDEX",
+    "JOINTWEIGHT",
     "kranvagn",
+    "krieg",
     "Leaderboard",
     "leaderboards",
     "MURICA",
+    "normalmap",
     "Oopsy",
     "outdir",
     "outfile",
     "ownedtanks",
     "playerachievements",
     "playerinfo",
+    "Promisable",
     "ratingsleaderboard",
+    "ratingsplot",
+    "researchable",
     "Resvg",
     "roboto",
+    "SCPG",
     "searchclans",
     "searchplayers",
     "searchtanks",
     "SKLLD",
     "Smri",
+    "Specularity",
     "startcase",
     "statsfull",
+    "steamapps",
     "Stringifying",
     "strvk",
     "subnation",
@@ -41,15 +62,19 @@
     "tankopedia",
     "tankopedias",
     "tankstats",
+    "TEXCOORD",
     "tresabhi",
     "Unicum",
     "Unregistering",
     "vickers",
     "vitepress",
+    "Vovko",
     "wargaming",
     "webp",
     "winrate",
     "wotblitz",
+    "XMLDVPL",
+    "YAMLDVPL",
     "zustand"
   ],
   "deno.enable": false,

README.md

@@ -14,31 +14,10 @@ Go to [application directory for Blitzkrieg](https://discord.com/application-dir
 
 ### https://blitz-krieg.vercel.app/
 
-![Blitzkrieg website](https://i.imgur.com/QOXUP63.png)
+![Blitzkrieg website](https://i.imgur.com/eRIZe5P.png)
 
 ## Visit the documentation website
 
 ### https://tresabhi.github.io/blitzkrieg/
 
-![Blitzkrieg documentation website](https://i.imgur.com/mCZCZEI.png)
+![Blitzkrieg documentation website](https://i.imgur.com/TOt5fMx.png)
-
-## Run the bot
-
-### Install dependencies
-
-```bash
-yarn
-```
-
-### Create `.env`
-
-```env
-GH_TOKEN={YOUR_GITHUB_TOKEN_HERE}
-DISCORD_TOKEN={YOUR_DISCORD_TOKE_HERE}
-```
-
-### Run the command
-
-```bash
-yarn dev:bot
-```

docs/changelogs/1.15.10.md

@@ -0,0 +1,23 @@
+# Blitzkrieg 1.15.10
+
+The 10th patch for the `1.15` update is here, breaking the record of the most patches for a single update!
+
+## Features
+
+- Added `/today`
+  - This is a direct alias for `/breakdown today`
+- Drastically simplified ratings command
+  - `/ratings current` and `/ratings archive` have been now merged
+  - Where the data is fetched from is now decided directly from the chosen season number
+- Simplified many error messages
+- Title bar description text is now centered when there is no image
+  - It always felt awkward when there was no image on the left but the left still aligned to the right
+- Removed `/link`'s requirement to select a username explicitly from the search results
+- Full names for regions are now used in the `/link` command
+  - So "NA" turns into "North America"
+
+## Fixes
+
+- Fixed contrast issues with WN8 percentile colors behind white text
+- Archived ratings neighbors now functions once again
+- Disabled tankopedia; this feature isn't finished yet and the changes were accidentally leaked

docs/changelogs/1.15.11.md

@@ -0,0 +1,11 @@
+# Blitzkrieg 1.15.11
+
+There's an easter egg somewhere in this update 🤔
+
+## Features
+
+- Added `/permissions` which lists all permissions required to run the bot and checks if the bot has them or not
+
+## Changes
+
+- Error messages now do no use embeds, instead utilize simple headings and paragraphs

docs/changelogs/1.15.12.md

@@ -0,0 +1,8 @@
+# Blitzkrieg 1.15.12
+
+Sometimes embeds need love too.
+
+## Changes
+
+- Session embeds are now translucent by default
+  - Session embed titles are now the username of the player by default

docs/changelogs/1.15.2.md

@@ -0,0 +1,9 @@
+# Blitzkrieg 1.15.2
+
+Infinity reduced to a finite value.
+
+## Fixes
+
+- Added a maximum value to the jump to position button
+- Removed neighbor checking for the seeding player
+  - This fixes the jump to position button not loading at all

docs/changelogs/1.15.3.md

@@ -0,0 +1,30 @@
+# Blitzkrieg 1.15.3
+
+The bot now gets more expressive!
+
+## Features
+
+- The bot can now have presence messages; examples:
+  - "Living in {number} servers"
+  - "Server {number} users"
+  - "Observing {number} channels"
+  - More will be added in the future! Give me some ideas
+
+## Changes
+
+- Moved `/credits` to `/about creators`
+- `/debug` command now ditches embeds and has better information to serve
+
+## Technical Features
+
+- Added a workflow and lint for package and changelog version miss match
+
+## Technical Changes
+
+- Removed manual trigger for Asian latest ratings leaderboard archiver
+- Leaderboard archiver now accepts an explicit target like `midnight` or `latest`
+- Combined midnight and latest leaderboard archival workflow into one file
+
+## Technical Fixed
+
+- Reviewed all workflow triggers and updated them

docs/changelogs/1.15.4.md

@@ -0,0 +1,13 @@
+# Blitzkrieg 1.15.4
+
+Unlocking future potential
+
+## Technical Changes
+
+- Moved the word "Ratings" to the front of the workflow name
+- Renamed `blitzkrieg-db` to `blitzkrieg-assets`
+- Moved the region folders from the root to `regions`
+
+## Technical Fixes
+
+- The ratings leaderboard archiver now correctly skips undefined players

docs/changelogs/1.15.5.md

@@ -0,0 +1,7 @@
+# Blitzkrieg 1.15.5
+
+Oops, this should've been in the last patch.
+
+## Fixes
+
+- User and channel cache is now guild cache exhaustive

docs/changelogs/1.15.6.md

@@ -0,0 +1,11 @@
+# Blitzkrieg 1.15.6
+
+This should have also been in the last update lol.
+
+## Changes
+
+- Changed the format of `/about creators` and added one more person
+
+## Fixes
+
+- Archived ratings leaderboards are now fetched from the correct URL path

docs/changelogs/1.15.7.md

@@ -0,0 +1,20 @@
+# Blitzkrieg 1.15.7
+
+Simple yet powerful theming options for the session tracker
+
+## Features
+
+- The accent color of the session tracker (hence the embed too) can now be tweaked
+  - Access this setting via the dropdown from Options > Accent color
+
+## Fixes
+
+- Reimplemented the commas for last numbers in the overflow count of the ratings leaderboard
+  - For example, "+1234567 more" will now read "+1,234,567 more"
+
+## Technical Features
+
+- Added class names for more in-depth customization for those who are comfortable with CSS
+  - `session-tracker-root`
+  - `session-tracker-row`
+  - `session-tracker-row-stat`

docs/changelogs/1.15.8.md

@@ -0,0 +1,9 @@
+# Blitzkrieg 1.15.8
+
+A request fulfilled \:\)
+
+## Features
+
+- Added custom titles in session tracker
+  - Change the title through Options > Edit title...
+- Colors are shown when selecting a theme color for the session tracker

docs/changelogs/1.15.9.md

@@ -0,0 +1,13 @@
+# Blitzkrieg 1.15.9
+
+~~Curiosity killed the cat~~ Ratings killed the Blitzkrieg
+
+## Fixes
+
+- Deleted ratings players are now handled properly
+
+## Technical Fixes
+
+- Latest archived season number
+  - Is now cached properly
+  - Is now fetched in a chaining fashion correctly

docs/guide/creators.md

@@ -0,0 +1,5 @@
+# Creators
+
+- **TrèsAbhi** `@tresabhi`: Creator and main programmer
+- **Prince_NA** `@prince_na`: Game advisor & tester
+- **Vovko**: Technical advisor

docs/guide/permissions.md

@@ -1,7 +0,0 @@
-# Permissions
-
-The following Discord permissions are required by the bot to ensure full functionality:
-
-- Manage nicknames
-- Read messages / view channels
-- Attach files

next.config.js

@@ -1,6 +1,6 @@
 import { createVanillaExtractPlugin } from '@vanilla-extract/next-plugin';
 
-const withVanillaExtract = createVanillaExtractPlugin();
+const withVanillaExtract = createVanillaExtractPlugin({ tests: /\.css$/ });
 
 /** @type {import('next').NextConfig} */
 const nextConfig = {

package.dist.json

@@ -1,7 +0,0 @@
-{
-  "main": "server.js",
-  "type": "module",
-  "scripts": {
-    "start": "node --enable-source-maps server.cjs"
-  }
-}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzkrieg",
-  "version": "1.15.1",
+  "version": "1.15.11",
   "description": "🎉 Tools for everything World of Tanks Blitz",
   "main": "src/server.ts",
   "type": "module",
@@ -9,7 +9,9 @@
     "build:website": "next build",
     "build:docs": "vitepress build docs",
     "build:ratingsleaderboard": "vite-node --script scripts/buildRatingsLeaderboard",
-    "build:tankopedia": "vite-node --script scripts/buildTankopedia",
+    "build:assets": "vite-node --script scripts/buildAssets",
+    "build:test": "vite-node --script scripts/buildTest",
+    "build:ratingsplot": "vite-node --script scripts/buildRatingsPlot",
     "dev:bot": "yarn build:bot && yarn start:bot",
     "dev:docs": "vitepress dev docs",
     "dev:website": "next dev",
@@ -21,16 +23,20 @@
     "lint": "npx tsc",
     "lint:website": "next lint",
     "format": "prettier --write \"**/*.@(json|js|jsx|css|md|ts|tsx|html|xml|yml|gltf)\"",
+    "lint:version": "vite-node --script scripts/checkVersionMissMatch",
     "knip": "knip",
     "update": "yarn upgrade --latest"
   },
   "license": "MIT",
   "dependencies": {
+    "@octokit/plugin-throttling": "^8.1.3",
     "@octokit/rest": "^20.0.1",
     "@prisma/client": "^5.4.1",
     "@radix-ui/colors": "^3.0.0-rc.4",
     "@radix-ui/react-icons": "^1.3.0",
-    "@radix-ui/themes": "^1.1.2",
+    "@radix-ui/themes": "^2.0.1",
+    "@react-three/drei": "^9.90.1",
+    "@react-three/fiber": "^8.15.12",
     "@resvg/resvg-js": "^2.4.1",
     "@vanilla-extract/css": "^1.13.0",
     "bepaint": "^0.1.0-beta.3",
@@ -39,20 +45,23 @@
     "dotenv": "^16.3.1",
     "esbuild": "^0.19.3",
     "express": "^4.18.2",
+    "false": "^0.0.4",
     "fuzzysort": "^2.0.4",
     "immer": "^10.0.2",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "markdown-escape": "^2.0.0",
-    "next": "^13.5.2",
+    "next": "^14.0.3",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-fuzzysort": "^1.0.1",
     "satori": "^0.10.8",
+    "sharp": "^0.33.0",
+    "three": "^0.159.0",
     "vite-node": "^0.34.5",
     "vitepress": "^1.0.0-rc.20",
     "vitepress-plugin-auto-sidebar": "^1.1.0",
-    "xml-js": "^1.6.11",
+    "yaml": "^2.3.4",
     "zustand": "^4.4.1"
   },
   "devDependencies": {
@@ -62,12 +71,17 @@
     "@types/express": "^4.17.18",
     "@types/js-yaml": "^4.0.8",
     "@types/lodash": "^4.14.199",
+    "@types/lz4": "^0.6.4",
     "@types/markdown-escape": "^1.1.0",
     "@types/node": "^20.6.5",
     "@types/react": "^18.2.22",
+    "@types/three": "^0.159.0",
     "@vanilla-extract/next-plugin": "^2.3.1",
     "compare-versions": "^6.1.0",
-    "knip": "^2.27.1",
+    "crc": "^4.3.2",
+    "fast-xml-parser": "^4.3.2",
+    "knip": "^3.4.0",
+    "lz4": "^0.6.5",
     "prettier": "^3.0.3",
     "prisma": "^5.4.1",
     "typescript": "^5.2.2"

scripts/buildAssets.ts

@@ -0,0 +1,544 @@
+import { config } from 'dotenv';
+import { existsSync } from 'fs';
+import { mkdir, readdir, rm } from 'fs/promises';
+import { argv } from 'process';
+import sharp from 'sharp';
+import { TankType } from '../src/components/Tanks';
+import { NATION_IDS } from '../src/constants/nations';
+import { SCPGStream } from '../src/core/blitz/SCPGStream';
+import { readBase64DVPL } from '../src/core/blitz/readBase64DVPL';
+import { readDVPLFile } from '../src/core/blitz/readDVPLFile';
+import { readStringDVPL } from '../src/core/blitz/readStringDVPL';
+import { readXMLDVPL } from '../src/core/blitz/readXMLDVPL';
+import { readYAMLDVPL } from '../src/core/blitz/readYAMLDVPL';
+import { toUniqueId } from '../src/core/blitz/toUniqueId';
+import commitMultipleFiles, {
+  FileChange,
+} from '../src/core/blitzkrieg/commitMultipleFiles';
+import { BlitzkriegGunDefinitions } from '../src/core/blitzkrieg/definitions/guns';
+import {
+  BlitzkriegShellDefinitions,
+  ShellType,
+} from '../src/core/blitzkrieg/definitions/shells';
+import {
+  BlitzkriegTankDefinitions,
+  Tier,
+} from '../src/core/blitzkrieg/definitions/tanks';
+import { BlitzkriegTurretDefinitions } from '../src/core/blitzkrieg/definitions/turrets';
+
+config();
+
+// WARNING! MOST OF THESE TYPES ARE NOT EXHAUSTIVE!
+
+interface VehicleDefinitionList {
+  [key: string]: {
+    id: number;
+    userString: string;
+    shortUserString?: string;
+    description: string;
+    price: number | { gold: ''; '#text': number };
+    sellPrice?: { gold: ''; '#text': number };
+    enrichmentPermanentCost: number;
+    notInShop?: boolean;
+    tags: string;
+    level: number;
+    combatRole?: Record<string, string>;
+    configurationModes: string;
+  };
+}
+interface TurretDefinitionsList {
+  nextAvailableId: number;
+  ids: Record<string, number>;
+}
+interface GunDefinitionsList {
+  nextAvailableId: number;
+  ids: Record<string, number>;
+  shared: {
+    [key: string]: {
+      userString: string;
+      tags: string;
+      level: number;
+      pitchLimits: string;
+      burst?: { count: number; rate: number };
+      clip?: { count: number; rate: number };
+      shots: {
+        [key: string]: {
+          speed: number;
+          piercingPower: string;
+        };
+      };
+    };
+  };
+}
+type ShellKind =
+  | 'ARMOR_PIERCING'
+  | 'ARMOR_PIERCING_CR'
+  | 'HIGH_EXPLOSIVE'
+  | 'HOLLOW_CHARGE';
+type ShellDefinitionsList = Record<
+  string,
+  {
+    id: number;
+    userString: string;
+    icon: string;
+    kind: ShellKind;
+    caliber: number;
+    damage: { armor: number; devices: number };
+    normalizationAngle: number;
+    ricochetAngle: number;
+  }
+> & {
+  icons: Record<string, string>;
+};
+interface VehicleDefinitions {
+  turrets0: {
+    [key: string]: {
+      userString: number;
+      level: number;
+      yawLimits: string | string[];
+      guns: {
+        [key: string]: {
+          maxAmmo: number;
+          pitchLimits?: string | string[];
+        };
+      };
+    };
+  };
+}
+interface Strings {
+  [key: string]: string;
+}
+type BlitzTankType = 'AT-SPG' | 'lightTank' | 'mediumTank' | 'heavyTank';
+interface TankParameters {
+  resourcesPath: {
+    smallIconPath: string;
+    bigIconPath: string;
+    blitzModelPath: string;
+  };
+}
+
+const blitzTankTypeToBlitzkrieg: Record<BlitzTankType, TankType> = {
+  'AT-SPG': 'tank_destroyer',
+  lightTank: 'light',
+  mediumTank: 'medium',
+  heavyTank: 'heavy',
+};
+const blitzShellKindToBLitzkrieg: Record<ShellKind, ShellType> = {
+  ARMOR_PIERCING: 'ap',
+  ARMOR_PIERCING_CR: 'ap_cr',
+  HIGH_EXPLOSIVE: 'he',
+  HOLLOW_CHARGE: 'hc',
+};
+const DATA =
+  'C:/Program Files (x86)/Steam/steamapps/common/World of Tanks Blitz/Data';
+const LANGUAGE = 'en';
+const DOI = {
+  vehicleDefinitions: 'XML/item_defs/vehicles',
+  strings: 'Strings',
+  tankParameters: '3d/Tanks/Parameters',
+  smallIcons: 'Gfx/UI/BattleScreenHUD/SmallTankIcons',
+  bigIcons: 'Gfx/UI/BigTankIcons',
+  flags: 'Gfx/Lobby/flags',
+  '3d': '3d',
+  bigShellIcons: 'Gfx/Shared/tank-supply/ammunition/big',
+};
+
+const allTargets = argv.includes('--all-targets');
+const targets = argv
+  .find((argument) => argument.startsWith('--target'))
+  ?.split('=')[1]
+  .split(',');
+
+if (!targets && !allTargets) throw new Error('No target(s) specified');
+
+if (allTargets || targets?.includes('definitions')) {
+  console.log('Building tank definitions...');
+
+  const tankDefinitions: BlitzkriegTankDefinitions = {};
+  const turretDefinitions: BlitzkriegTurretDefinitions = {};
+  const gunDefinitions: BlitzkriegGunDefinitions = {};
+  const shellDefinitions: BlitzkriegShellDefinitions = {};
+  const nations = await readdir(`${DATA}/${DOI.vehicleDefinitions}`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+  const strings = await readYAMLDVPL<Strings>(
+    `${DATA}/${DOI.strings}/${LANGUAGE}.yaml.dvpl`,
+  );
+
+  await Promise.all(
+    nations.map(async (nation) => {
+      const tankList = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+        `${DATA}/${DOI.vehicleDefinitions}/${nation}/list.xml.dvpl`,
+      );
+      const turretList = await readXMLDVPL<{
+        root: TurretDefinitionsList;
+      }>(
+        `${DATA}/${DOI.vehicleDefinitions}/${nation}/components/turrets.xml.dvpl`,
+      );
+      const gunList = await readXMLDVPL<{
+        root: GunDefinitionsList;
+      }>(
+        `${DATA}/${DOI.vehicleDefinitions}/${nation}/components/guns.xml.dvpl`,
+      );
+      const shellList = await readXMLDVPL<{
+        root: ShellDefinitionsList;
+      }>(
+        `${DATA}/${DOI.vehicleDefinitions}/${nation}/components/shells.xml.dvpl`,
+      );
+
+      for (const tankKey in tankList.root) {
+        const tank = tankList.root[tankKey];
+        const tankDefinition = await readXMLDVPL<{ root: VehicleDefinitions }>(
+          `${DATA}/${DOI.vehicleDefinitions}/${nation}/${tankKey}.xml.dvpl`,
+        );
+        const tankId = toUniqueId(nation, tank.id);
+        const tankTags = tank.tags.split(' ');
+        const tankTurrets = Object.keys(tankDefinition.root.turrets0).map(
+          (turretKey) => {
+            const turret = tankDefinition.root.turrets0[turretKey];
+            const turretId = toUniqueId(nation, turretList.root.ids[turretKey]);
+            const turretGuns = Object.keys(turret.guns).map((gunKey) => {
+              const turretGunEntry = turret.guns[gunKey];
+              const gunId = toUniqueId(nation, gunList.root.ids[gunKey]);
+              const gun = gunList.root.shared[gunKey];
+              const pitchLimitsRaw =
+                turretGunEntry.pitchLimits ?? gun.pitchLimits;
+              const gunShells = Object.keys(gun.shots).map((shellKey) => {
+                const turretShellEntry = gun.shots[shellKey];
+                const shell = shellList.root[shellKey];
+                const shellId = toUniqueId(nation, shell.id);
+
+                shellDefinitions[shellId] = {
+                  id: shellId,
+                  name:
+                    strings[shell.userString] ?? shellKey.replaceAll('_', ' '),
+                  speed: turretShellEntry.speed,
+                  damage: {
+                    armor: shell.damage.armor,
+                    devices: shell.damage.devices,
+                  },
+                  caliber: shell.caliber,
+                  normalization: shell.normalizationAngle,
+                  ricochet: shell.ricochetAngle,
+                  type: blitzShellKindToBLitzkrieg[shell.kind],
+                  icon: shell.icon,
+                };
+
+                return shellId;
+              });
+
+              gunDefinitions[gunId] = {
+                id: gunId,
+                pitch: (typeof pitchLimitsRaw === 'string'
+                  ? pitchLimitsRaw
+                  : pitchLimitsRaw.at(-1)!
+                )
+                  .split(' ')
+                  .map(Number) as [number, number],
+                name: strings[gun.userString] ?? gunKey.replaceAll('_', ' '),
+                tier: gun.level as Tier,
+                shells: gunShells,
+              };
+
+              return gunId;
+            });
+
+            turretDefinitions[turretId] = {
+              id: turretId,
+              name:
+                strings[turret.userString] ??
+                turretKey
+                  .replaceAll('_', ' ')
+                  .replace(/^(Turret ([0-9] )?)+/, ''),
+              tier: turret.level as Tier,
+              yaw: (typeof turret.yawLimits === 'string'
+                ? turret.yawLimits
+                : turret.yawLimits.at(-1)!
+              )
+                .split(' ')
+                .map(Number) as [number, number],
+              guns: turretGuns,
+            };
+
+            return turretId;
+          },
+        );
+
+        tankDefinitions[tankId] = {
+          id: tankId,
+          name:
+            (tank.shortUserString
+              ? strings[tank.shortUserString]
+              : undefined) ??
+            strings[tank.userString] ??
+            tankKey.replaceAll('_', ' '),
+          nation,
+          tree_type: (tank.sellPrice ? 'gold' in tank.sellPrice : false)
+            ? 'collector'
+            : (typeof tank.price === 'number' ? false : 'gold' in tank.price)
+              ? 'premium'
+              : 'researchable',
+          tier: tank.level as Tier,
+          type: blitzTankTypeToBlitzkrieg[tankTags[0] as BlitzTankType],
+          testing: tankTags.includes('testTank') ? true : undefined,
+          turrets: tankTurrets,
+        };
+      }
+    }),
+  );
+
+  console.log('Committing tank definitions...');
+  await commitMultipleFiles(
+    'tresabhi',
+    'blitzkrieg-assets',
+    'main',
+    'definitions',
+    [
+      {
+        content: JSON.stringify(tankDefinitions),
+        encoding: 'utf-8',
+        path: 'definitions/tanks.json',
+      },
+      {
+        content: JSON.stringify(turretDefinitions),
+        encoding: 'utf-8',
+        path: 'definitions/turrets.json',
+      },
+      {
+        content: JSON.stringify(gunDefinitions),
+        encoding: 'utf-8',
+        path: 'definitions/guns.json',
+      },
+      {
+        content: JSON.stringify(shellDefinitions),
+        encoding: 'utf-8',
+        path: 'definitions/shells.json',
+      },
+    ],
+
+    true,
+  );
+}
+
+if (
+  allTargets ||
+  targets?.includes('bigTankIcons') ||
+  targets?.includes('smallTankIcons')
+) {
+  console.log('Building tank icons...');
+
+  const changes: FileChange[] = [];
+  const nations = await readdir(`${DATA}/${DOI.vehicleDefinitions}`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+
+  await Promise.all(
+    nations.map(async (nation) => {
+      const tanks = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+        `${DATA}/${DOI.vehicleDefinitions}/${nation}/list.xml.dvpl`,
+      );
+
+      for (const tankIndex in tanks.root) {
+        const tank = tanks.root[tankIndex];
+        const nationVehicleId = tank.id;
+        const id = (nationVehicleId << 8) + (NATION_IDS[nation] << 4) + 1;
+        const parameters = await readYAMLDVPL<TankParameters>(
+          `${DATA}/${DOI.tankParameters}/${nation}/${tankIndex}.yaml.dvpl`,
+        );
+        const small = `${DATA}/${parameters.resourcesPath.smallIconPath
+          .replace(/~res:\//, '')
+          .replace(/\..+/, '')}.packed.webp.dvpl`;
+        const big = `${DATA}/${parameters.resourcesPath.bigIconPath
+          .replace(/~res:\//, '')
+          .replace(/\..+/, '')}.packed.webp.dvpl`;
+
+        if (allTargets || targets?.includes('bigTankIcons')) {
+          changes.push({
+            content: await readBase64DVPL(big),
+            encoding: 'base64',
+            path: `icons/big/${id}.webp`,
+          });
+        }
+        if (allTargets || targets?.includes('smallTankIcons')) {
+          changes.push({
+            content: await readBase64DVPL(small),
+            encoding: 'base64',
+            path: `icons/small/${id}.webp`,
+          });
+        }
+      }
+    }),
+  );
+
+  console.log('Committing tank icons...');
+  await commitMultipleFiles(
+    'tresabhi',
+    'blitzkrieg-assets',
+    'main',
+    'tank icons',
+    changes,
+    true,
+  );
+}
+
+if (allTargets || targets?.includes('scratchedFlags')) {
+  console.log('Building scratched flags...');
+
+  const flags = await readdir(`${DATA}/${DOI.flags}`);
+
+  console.log('Committing scratched flags...');
+  commitMultipleFiles(
+    'tresabhi',
+    'blitzkrieg-assets',
+    'main',
+    'scratched flags',
+    await Promise.all(
+      flags
+        .filter(
+          (flag) =>
+            flag.startsWith('flag_tutor-tank_') &&
+            !flag.endsWith('@2x.packed.webp.dvpl'),
+        )
+        .map(async (flag) => {
+          const content = await readBase64DVPL(`${DATA}/${DOI.flags}/${flag}`);
+          const name = flag.match(/flag_tutor-tank_(.+)\.packed\.webp/)![1];
+
+          return {
+            content,
+            encoding: 'base64',
+            path: `flags/scratched/${name}.webp`,
+          } satisfies FileChange;
+        }),
+    ),
+    true,
+  );
+}
+
+if (allTargets || targets?.includes('circleFlags')) {
+  const flags = await readdir(`${DATA}/${DOI.flags}`);
+
+  commitMultipleFiles(
+    'tresabhi',
+    'blitzkrieg-assets',
+    'main',
+    'circle flags',
+    await Promise.all(
+      flags
+        .filter(
+          (flag) =>
+            flag.startsWith('flag_profile-stat_') &&
+            !flag.endsWith('@2x.packed.webp.dvpl'),
+        )
+        .map(async (flag) => {
+          const content = await readBase64DVPL(`${DATA}/${DOI.flags}/${flag}`);
+          const name = flag.match(/flag_profile-stat_(.+)\.packed\.webp/)![1];
+
+          return {
+            content,
+            encoding: 'base64',
+            path: `flags/circle/${name}.webp`,
+          } satisfies FileChange;
+        }),
+    ),
+    true,
+  );
+}
+
+if (allTargets || targets?.includes('tankModels')) {
+  console.log('Building tank models...');
+
+  if (existsSync('dist/assets/models')) {
+    await rm('dist/assets/models', { recursive: true });
+  }
+  await mkdir('dist/assets/models', { recursive: true });
+
+  const changes: FileChange[] = [];
+  const nations = await readdir(`${DATA}/${DOI.vehicleDefinitions}`).then(
+    (nations) => nations.filter((nation) => nation !== 'common'),
+  );
+
+  await Promise.all(
+    nations.map(async (nation) => {
+      const tanks = await readXMLDVPL<{ root: VehicleDefinitionList }>(
+        `${DATA}/${DOI.vehicleDefinitions}/${nation}/list.xml.dvpl`,
+      );
+
+      for (const tankIndex in tanks.root) {
+        const tank = tanks.root[tankIndex];
+        const nationVehicleId = tank.id;
+        const id = (nationVehicleId << 8) + (NATION_IDS[nation] << 4) + 1;
+
+        // if (id !== 897) continue;
+        console.log(`Building model ${id} @ ${nation}/${tankIndex}`);
+
+        const parameters = await readYAMLDVPL<TankParameters>(
+          `${DATA}/${DOI.tankParameters}/${nation}/${tankIndex}.yaml.dvpl`,
+        );
+        const sc2Path = parameters.resourcesPath.blitzModelPath;
+        const scgPath = parameters.resourcesPath.blitzModelPath.replace(
+          /\.sc2$/,
+          '.scg',
+        );
+        const sc2Stream = await SCPGStream.fromDVPLFile(
+          `${DATA}/${DOI['3d']}/${sc2Path}.dvpl`,
+        );
+        const scgStream = await SCPGStream.fromDVPLFile(
+          `${DATA}/${DOI['3d']}/${scgPath}.dvpl`,
+        );
+
+        const sc2 = sc2Stream.consumeSC2();
+        const scg = scgStream.consumeSCG();
+      }
+    }),
+  );
+}
+
+if (allTargets || targets?.includes('shellIcons')) {
+  console.log('Building shell icons...');
+
+  const image = sharp(
+    await readDVPLFile(
+      `${DATA}/${DOI.bigShellIcons}/texture0.packed.webp.dvpl`,
+    ),
+  );
+
+  const changes = await Promise.all(
+    (await readdir(`${DATA}/${DOI.bigShellIcons}`))
+      .filter((file) => file.endsWith('_l.txt.dvpl'))
+      .map(async (file) => {
+        const name = file.match(/(.+)_l\.txt\.dvpl/)![1];
+        const sizes = (
+          await readStringDVPL(`${DATA}/${DOI.bigShellIcons}/${file}`)
+        )
+          .split('\n')[4]
+          .split(' ')
+          .map(Number);
+
+        return {
+          content: (
+            await image
+              .clone()
+              .extract({
+                left: sizes[0],
+                top: sizes[1],
+                width: sizes[2],
+                height: sizes[3],
+              })
+              .toBuffer()
+          ).toString('base64'),
+          encoding: 'base64',
+          path: `shells/${name}.webp`,
+        } satisfies FileChange;
+      }),
+  );
+
+  console.log('Committing shell icons...');
+  commitMultipleFiles(
+    'tresabhi',
+    'blitzkrieg-assets',
+    'main',
+    'shell icons',
+    changes,
+    true,
+  );
+}

scripts/buildRatingsLeaderboard.ts

@@ -6,8 +6,8 @@ import {
   RatingsNeighbors,
   RatingsPlayer,
 } from '../src/commands/ratings';
+import commitMultipleFiles from '../src/core/blitzkrieg/commitMultipleFiles.js';
 import { patientFetchJSON } from '../src/core/blitzkrieg/patientFetchJSON';
-import commitMultipleFiles from './commitMultipleFiles.js';
 
 /*
  * Central North American Time (UTC-5): use 0 5 * * *.
@@ -23,12 +23,15 @@ export type BlitzkriegRatingsLeaderboardEntry = { id: number; score: number };
 export type BlitzkriegRatingsLeaderboard = BlitzkriegRatingsLeaderboardEntry[];
 
 const publish = argv.includes('--publish');
-const latest = argv.includes('--latest');
+const target = argv
+  .find((arg) => arg.startsWith('--target='))
+  ?.split('=')[1] as 'midnight' | 'latest' | undefined;
 const server = argv.find((arg) => arg.startsWith('--region='))?.split('=')[1];
 
+if (!target) throw new Error('Target parameter not specified');
 if (!server) throw new Error('Region parameter not specified');
 
-const NEIGHBORS = 1024;
+const NEIGHBORS = 2 ** 8;
 const PLAYERS = await patientFetchJSON<RatingsInfo>(
   `https://${server}.wotblitz.com/en/api/rating-leaderboards/season/`,
 ).then((data) => (data.detail === undefined ? data.count : undefined));
@@ -98,7 +101,10 @@ await Promise.all([
 console.log('Converting to an array...');
 for (let index = 0; index < PLAYERS; index++) {
   const listing = players[index + 1];
-  if (!listing) console.warn(`Position ${index + 1} had no player`);
+  if (!listing) {
+    console.warn(`Position ${index + 1} had no player`);
+    continue;
+  }
 
   leaderboard[index] = {
     id: listing.spa_id,
@@ -110,28 +116,23 @@ const leaderboardJSON = JSON.stringify(leaderboard);
 
 if (publish) {
   const octokit = new Octokit({ auth: env.GH_TOKEN });
-
   const info = await patientFetchJSON<RatingsInfo & { detail: undefined }>(
     `https://${server}.wotblitz.com/en/api/rating-leaderboards/season/`,
   );
   const normalizedServer = server === 'na' ? 'com' : server;
-
+  const infoPath = `regions/${normalizedServer}/ratings/${info.current_season}/info.json`;
-  const infoPath = `${normalizedServer}/ratings/${info.current_season}/info.json`;
+  const leaderboardPath = `regions/${normalizedServer}/ratings/${info.current_season}/${target}.json`;
-  const leaderboardPath = `${normalizedServer}/ratings/${info.current_season}/${
-    latest ? 'latest' : 'midnight'
-  }.json`;
   const infoJSON = JSON.stringify(info);
 
   console.log(`Publishing to season ${info.current_season}...`);
   commitMultipleFiles(
-    octokit,
     'tresabhi',
-    'blitzkrieg-db',
+    'blitzkrieg-assets',
     'main',
     new Date().toString(),
     [
-      { path: infoPath, content: infoJSON },
+      { path: infoPath, content: infoJSON, encoding: 'utf-8' },
-      { path: leaderboardPath, content: leaderboardJSON },
+      { path: leaderboardPath, content: leaderboardJSON, encoding: 'utf-8' },
     ],
   );
 } else {

scripts/buildRatingsPlot.ts

@@ -0,0 +1,46 @@
+import { writeFile } from 'fs/promises';
+import { Region } from '../src/constants/regions';
+import { getRatingsNeighbors } from '../src/core/blitz/getRatingsNeighbors';
+
+const REGION: Region = 'com';
+const PLAYER = 1041988373;
+const ITERATIONS = 2 ** 4;
+const MAX_NEIGHBORS = 2 ** 7;
+const data: [number, number][] = [];
+let finished = 0;
+
+for (let index = 0; index < ITERATIONS; index++) {
+  const neighbors = Math.round((Math.random() * MAX_NEIGHBORS) / 2) * 2;
+  const start = Date.now();
+
+  console.log(`🟡 Iteration ${index} with ${neighbors} neighbors`);
+
+  try {
+    await getRatingsNeighbors(REGION, PLAYER, neighbors);
+
+    finished++;
+    console.log(
+      `🟢 (${Math.round(
+        100 * (finished / ITERATIONS),
+      )}%) Iteration ${index} with ${neighbors} neighbors`,
+    );
+
+    const end = Date.now();
+    const time = end - start;
+
+    data.push([neighbors, time]);
+  } catch (error) {
+    console.log(
+      `🔴 Iteration ${index} with ${neighbors} neighbors\n\n${error}`,
+    );
+  }
+}
+
+console.log('🟢 Done, sorting');
+data.sort(([neighborsA], [neighborsB]) => neighborsA - neighborsB);
+
+console.log('🟢 Writing');
+writeFile(
+  'dist/ratingsPlot.csv',
+  data.map(([neighbors, time]) => `${neighbors},${time}`).join('\n'),
+);

scripts/buildTankopedia.ts

@@ -1,86 +0,0 @@
-import decompress from 'decompress';
-import { readFile, readdir, rm, writeFile } from 'fs/promises';
-import { load } from 'js-yaml';
-import { ElementCompact, xml2js } from 'xml-js';
-import { NATION_IDS } from '../src/constants/nations';
-
-const REWRITE = false;
-const VEHICLE_DEFS = 'assets/Data/XML/item_defs/vehicles';
-const APK_FILE = 'temp/blitz.apk';
-const STRINGS = 'assets/Data/Strings';
-const LANGUAGE = 'en';
-const DIRECTORIES_OF_INTEREST = [VEHICLE_DEFS, STRINGS];
-
-if (REWRITE) {
-  await rm('temp/blitz', { recursive: true, force: true });
-  decompress(APK_FILE, 'temp/blitz', {
-    filter: (file) =>
-      DIRECTORIES_OF_INTEREST.some((dir) => file.path.startsWith(dir)),
-  });
-}
-
-interface BlitzkriegTankopedia {
-  id: number;
-  nation: string;
-  name: string;
-  name_short?: string;
-  is_premium: boolean;
-  is_collector: boolean;
-  tier: number;
-  type: string;
-}
-
-const strings = await readFile(
-  `temp/blitz/${STRINGS}/${LANGUAGE}.yaml`,
-  'utf-8',
-).then((data) => load(data) as Record<string, string>);
-const tankopedia: Record<number, BlitzkriegTankopedia> = {};
-const nations = await readdir(`temp/blitz/${VEHICLE_DEFS}`);
-
-await Promise.all(
-  nations
-    .filter((nation) => nation !== 'common')
-    .map(async (nation) => {
-      const listXML = await readFile(
-        `temp/blitz/${VEHICLE_DEFS}/${nation}/list.xml`,
-        'utf-8',
-      );
-      const list = xml2js(listXML, { compact: true }) as ElementCompact;
-
-      await Promise.all(
-        Object.entries<ElementCompact>(list.root).map(
-          async ([vehicle, vehicleData]) => {
-            // const vehicleXML = await readFile(
-            //   `temp/blitz/${VEHICLE_DEFS}/${nation}/${vehicle}.xml`,
-            //   'utf-8',
-            // ).then((xml) => xml2js(xml, { compact: true }) as ElementCompact);
-            const nationVehicleId = parseInt(list.root[vehicle].id._text);
-            const id = (nationVehicleId << 8) + (NATION_IDS[nation] << 4) + 1;
-            // TODO: use userString property instead
-            const name = strings[`#${nation}_vehicles:${vehicle}`];
-            const name_short = strings[`#${nation}_vehicles:${vehicle}_short`];
-            const is_premium = 'gold' in vehicleData.price;
-            const is_collector = vehicleData.sellPrice
-              ? 'gold' in vehicleData.sellPrice
-              : false;
-            const tier = parseInt(vehicleData.level._text);
-            const tags = vehicleData.tags._text.split(' ');
-            const type = tags[0];
-
-            tankopedia[id] = {
-              id,
-              name,
-              name_short,
-              nation,
-              is_premium,
-              is_collector,
-              tier,
-              type,
-            };
-          },
-        ),
-      );
-    }),
-);
-
-writeFile('dist/tankopedia.json', JSON.stringify(tankopedia, null, 2));

scripts/checkVersionMissMatch.ts

@@ -0,0 +1,12 @@
+import { readdir } from 'fs/promises';
+import packageJSON from '../package.json';
+
+const { version } = packageJSON;
+const changelogs = await readdir('docs/changelogs');
+const hasVersion = changelogs.includes(`${version}.md`);
+
+if (hasVersion) {
+  console.log(`Version ${version} found in changelogs`);
+} else {
+  throw new Error(`Version ${version} not found in changelogs`);
+}

scripts/commitMultipleFiles.ts

@@ -1,70 +0,0 @@
-import { Octokit } from '@octokit/rest';
-
-export default async function commitMultipleFiles(
-  octokit: Octokit,
-  owner: string,
-  repo: string,
-  branch: string,
-  message: string,
-  changes: { path: string; content: string }[],
-) {
-  // Get the latest commit SHA on the specified branch
-  const { data: refData } = await octokit.git.getRef({
-    owner,
-    repo,
-    ref: `heads/${branch}`,
-  });
-  const latestCommitSha = refData.object.sha;
-
-  // Get the tree SHA for the latest commit
-  const { data: commitData } = await octokit.git.getCommit({
-    owner,
-    repo,
-    commit_sha: latestCommitSha,
-  });
-  const treeSha = commitData.tree.sha;
-
-  // Create blobs for each file
-  const blobs = await Promise.all(
-    changes.map(async (change) => {
-      const { data: blobData } = await octokit.git.createBlob({
-        owner,
-        repo,
-        content: change.content,
-        encoding: 'utf-8',
-      });
-
-      return {
-        sha: blobData.sha,
-        path: change.path,
-        mode: '100644',
-        type: 'blob',
-      } as const;
-    }),
-  );
-
-  // Create a new tree with the new blobs
-  const { data: treeData } = await octokit.git.createTree({
-    owner,
-    repo,
-    base_tree: treeSha,
-    tree: blobs,
-  });
-
-  // Create a new commit with the new tree
-  const { data: newCommitData } = await octokit.git.createCommit({
-    owner,
-    repo,
-    message,
-    tree: treeData.sha,
-    parents: [latestCommitSha],
-  });
-
-  // Update the branch reference to point to the new commit
-  await octokit.git.updateRef({
-    owner,
-    repo,
-    ref: `heads/${branch}`,
-    sha: newCommitData.sha,
-  });
-}

src/app/api/tankopedia/route.ts

@@ -1,6 +0,0 @@
-import { NextResponse } from 'next/server';
-import { tankopedia } from '../../../core/blitzstars/tankopedia';
-
-export async function GET() {
-  return NextResponse.json(await tankopedia);
-}

src/app/embeds/session/page.tsx

@@ -6,22 +6,29 @@ import * as Breakdown from '../../../components/Breakdown';
 import { TreeTypeEnum } from '../../../components/Tanks';
 import { WARGAMING_APPLICATION_ID } from '../../../constants/wargamingApplicationID';
 import fetchBlitz from '../../../core/blitz/fetchBlitz';
-import { tankAverages } from '../../../core/blitzstars/tankAverages';
 import {
-  TankopediaEntry,
+  BlitzkriegTankDefinition,
-  tankopedia,
+  tankDefinitions,
-} from '../../../core/blitzstars/tankopedia';
+} from '../../../core/blitzkrieg/definitions/tanks';
+import { tankAverages } from '../../../core/blitzstars/tankAverages';
 import calculateWN8 from '../../../core/statistics/calculateWN8';
 import { deltaTankStats } from '../../../core/statistics/deltaTankStats';
 import getWN8Percentile from '../../../core/statistics/getWN8Percentile';
-import { resetSession, useSession } from '../../../stores/session';
+import mutateSession, {
+  resetSession,
+  useSession,
+} from '../../../stores/session';
 import { IndividualTankStats, TanksStats } from '../../../types/tanksStats';
 import { CustomColumnDisplay } from '../../tools/session/components/CustomColumn';
 import { Menu } from '../../tools/session/components/Menu';
 
 const REFRESH_RATE = 1 / 5;
 
-export default function SessionPage() {
+interface SessionPageProps {
+  naked?: boolean;
+}
+
+export default function SessionPage({ naked = true }: SessionPageProps) {
   const session = useSession();
   const since = session.isTracking ? new Date(session.time) : undefined;
   const [diff, setDiff] = useState<
@@ -30,7 +37,7 @@ export default function SessionPage() {
 
         list: {
           stats: IndividualTankStats;
-          tankopedia?: TankopediaEntry;
+          tankDefinitions?: BlitzkriegTankDefinition;
           career: IndividualTankStats;
           currentWN8?: number;
           careerWN8?: number;
@@ -72,6 +79,14 @@ export default function SessionPage() {
       0,
     ) / careerBattles;
 
+  useEffect(() => {
+    if (session.title === 'Untitled session') {
+      mutateSession((draft) => {
+        if (draft.isTracking) draft.title = draft.nickname;
+      });
+    }
+  }, [session.title]);
+
   useEffect(() => {
     async function recalculateDiff() {
       if (session.isTracking) {
@@ -88,7 +103,7 @@ export default function SessionPage() {
           }),
           {},
         );
-        const awaitedTankopedia = await tankopedia;
+        const awaitedTankDefinitions = await tankDefinitions;
         const awaitedTankAverages = await tankAverages;
         const careerWN8 =
           careerRaw[id].reduce(
@@ -119,7 +134,7 @@ export default function SessionPage() {
           ).map((stats) => {
             return {
               stats,
-              tankopedia: awaitedTankopedia[stats.tank_id],
+              tankDefinitions: awaitedTankDefinitions[stats.tank_id],
               career: career[stats.tank_id],
               currentWN8: awaitedTankAverages[stats.tank_id]
                 ? calculateWN8(
@@ -207,15 +222,10 @@ export default function SessionPage() {
               since !== undefined &&
               diff !== undefined && (
                 <Breakdown.Row
+                  naked={naked}
+                  color={session.color}
                   minimized={!session.showCareer}
-                  title={`Since ${since.toLocaleString(undefined, {
+                  title={session.title}
-                    hour: 'numeric',
-                    minute: 'numeric',
-                    hour12: true,
-                    month: 'short',
-                    year: 'numeric',
-                    day: 'numeric',
-                  })}`}
                   stats={session.customColumns.map((customColumn) => {
                     const rowStat = totalRowStats[customColumn.display];
 
@@ -237,89 +247,96 @@ export default function SessionPage() {
               .sort(
                 (a, b) => b.stats.last_battle_time - a.stats.last_battle_time,
               )
-              .map(({ stats, tankopedia, career, careerWN8, currentWN8 }) => {
+              .map(
-                const rowStats: Record<
+                ({ stats, tankDefinitions, career, careerWN8, currentWN8 }) => {
-                  CustomColumnDisplay,
+                  const rowStats: Record<
-                  Breakdown.RowStatItem | undefined
+                    CustomColumnDisplay,
-                > = {
+                    Breakdown.RowStatItem | undefined
-                  battles: {
+                  > = {
-                    title: 'Battles',
+                    battles: {
-                    current: stats.all.battles.toLocaleString(),
+                      title: 'Battles',
-                    career: career.all.battles.toLocaleString(),
+                      current: stats.all.battles.toLocaleString(),
-                  },
+                      career: career.all.battles.toLocaleString(),
-                  winrate: {
+                    },
-                    title: 'Winrate',
+                    winrate: {
-                    current: `${(
+                      title: 'Winrate',
-                      100 *
+                      current: `${(
-                      (stats.all.wins / stats.all.battles)
+                        100 *
-                    ).toFixed(2)}%`,
+                        (stats.all.wins / stats.all.battles)
-                    career: `${(
+                      ).toFixed(2)}%`,
-                      100 *
+                      career: `${(
-                      (career.all.wins / career.all.battles)
+                        100 *
-                    ).toFixed(2)}%`,
+                        (career.all.wins / career.all.battles)
-                    delta:
+                      ).toFixed(2)}%`,
-                      stats.all.wins / stats.all.battles -
+                      delta:
-                      career.all.wins / career.all.battles,
+                        stats.all.wins / stats.all.battles -
-                  },
+                        career.all.wins / career.all.battles,
-                  wn8: {
+                    },
-                    title: 'WN8',
+                    wn8: {
-                    current:
+                      title: 'WN8',
-                      currentWN8 === undefined
+                      current:
-                        ? undefined
+                        currentWN8 === undefined
-                        : Math.round(currentWN8).toLocaleString(),
+                          ? undefined
-                    career:
+                          : Math.round(currentWN8).toLocaleString(),
-                      careerWN8 === undefined
+                      career:
-                        ? undefined
+                        careerWN8 === undefined
-                        : Math.round(careerWN8).toLocaleString(),
+                          ? undefined
-                    percentile:
+                          : Math.round(careerWN8).toLocaleString(),
-                      currentWN8 === undefined
+                      percentile:
-                        ? undefined
+                        currentWN8 === undefined
-                        : getWN8Percentile(currentWN8),
+                          ? undefined
-                  },
+                          : getWN8Percentile(currentWN8),
-                  damage: {
+                    },
-                    title: 'Damage',
+                    damage: {
-                    current: Math.round(
+                      title: 'Damage',
-                      stats.all.damage_dealt / stats.all.battles,
+                      current: Math.round(
-                    ).toLocaleString(),
+                        stats.all.damage_dealt / stats.all.battles,
-                    career: Math.round(
+                      ).toLocaleString(),
-                      career.all.damage_dealt / career.all.battles,
+                      career: Math.round(
-                    ).toLocaleString(),
+                        career.all.damage_dealt / career.all.battles,
-                    delta:
+                      ).toLocaleString(),
-                      stats.all.damage_dealt / stats.all.battles -
+                      delta:
-                      career.all.damage_dealt / career.all.battles,
+                        stats.all.damage_dealt / stats.all.battles -
-                  },
+                        career.all.damage_dealt / career.all.battles,
-                  none: undefined,
+                    },
-                };
+                    none: undefined,
+                  };
 
-                return (
+                  return (
-                  <Breakdown.Row
+                    <Breakdown.Row
-                    key={stats.tank_id}
+                      naked={naked}
-                    minimized={!session.showCareer}
+                      color={session.color}
-                    title={tankopedia?.name ?? `Unknown tank ${stats.tank_id}`}
+                      key={stats.tank_id}
-                    type="tank"
+                      minimized={!session.showCareer}
-                    tankType={tankopedia?.type}
+                      title={
-                    treeType={(() => {
+                        tankDefinitions?.name ?? `Unknown tank ${stats.tank_id}`
-                      if (tankopedia?.is_collectible)
+                      }
-                        return TreeTypeEnum.Collector;
+                      type="tank"
-                      if (tankopedia?.is_premium) return TreeTypeEnum.Premium;
+                      tankType={tankDefinitions?.type}
-                    })()}
+                      treeType={(() => {
-                    stats={session.customColumns.map((customColumn) => {
+                        if (tankDefinitions?.tree_type === 'collector')
-                      const rowStat = rowStats[customColumn.display];
+                          return TreeTypeEnum.Collector;
+                        if (tankDefinitions?.tree_type === 'premium')
+                          return TreeTypeEnum.Premium;
+                      })()}
+                      stats={session.customColumns.map((customColumn) => {
+                        const rowStat = rowStats[customColumn.display];
 
-                      if (!rowStat) return undefined;
+                        if (!rowStat) return undefined;
 
-                      return {
+                        return {
-                        ...rowStat,
+                          ...rowStat,
-                        delta:
+                          delta:
-                          customColumn.showDelta &&
+                            customColumn.showDelta &&
-                          rowStat.percentile === undefined
+                            rowStat.percentile === undefined
-                            ? rowStat.delta
+                              ? rowStat.delta
-                            : undefined,
+                              : undefined,
-                      };
+                        };
-                    })}
+                      })}
-                  />
+                    />
-                );
+                  );
-              })}
+                },
+              )}
           </Breakdown.Root>
         </div>
       </ContextMenu.Trigger>

src/app/layout.tsx

@@ -36,12 +36,19 @@ export default function RootLayout({ children }: RootLayoutProps) {
       <body
         style={{
           margin: 0,
+          paddingTop: isEmbed ? 0 : '3.25rem',
           background: isEmbed
             ? 'transparent'
             : 'url(https://i.imgur.com/PhS06NJ.png)',
         }}
       >
-        <Theme appearance="dark" panelBackground="translucent" radius="full">
+        <Theme
+          appearance="dark"
+          panelBackground="translucent"
+          radius="full"
+          suppressHydrationWarning
+          suppressContentEditableWarning
+        >
           {!isEmbed && <Navbar />}
 
           <Flex direction="column">{children}</Flex>

src/app/tools/layout.tsx

@@ -11,7 +11,7 @@ interface ToolsLayoutProps {
 
 export default function ToolsLayout({ children }: ToolsLayoutProps) {
   const pathname = usePathname();
-  const toolId = pathname.split('/').at(-1);
+  const toolId = pathname.split('/').at(2);
   const tool = TOOLS.find((tool) => tool.id === toolId);
 
   return (

src/app/tools/ratings/components/PageTurner/index.tsx

@@ -59,6 +59,8 @@ export function PageTurner({
             type="number"
             ref={pageInput}
             style={{ width: 64, textAlign: 'center' }}
+            min={1}
+            max={pages}
             onBlur={(event) => {
               onPageChange(
                 Math.max(

src/app/tools/ratings/page.tsx

@@ -299,19 +299,11 @@ export default function Page() {
       }
     }
 
-    const seedingPlayerNeighborEntry = Object.entries(
-      leaderboard[region][season],
-    ).find(([, player]) => id === player);
-
-    if (seedingPlayerNeighborEntry === undefined) return null;
-
-    // const seedingPlayerPosition = parseInt(seedingPlayerNeighborEntry[0]);
     const { neighbors } = await getRatingsNeighbors(region, id, size, true);
 
     useLeaderboardCache.setState(
       produce((draft: LeaderboardCache) => {
         neighbors.forEach((neighbor, neighborIndex) => {
-          // const position = neighborIndex - radius + seedingPlayerPosition;
           const position = neighbor.number - 1;
 
           if (!(position in draft[region][season])) {
@@ -347,9 +339,9 @@ export default function Page() {
   async function jumpToPosition(position: number) {
     if (!ratingsInfo || ratingsInfo?.detail) return;
 
-    const targetPosition = Math.max(
+    const targetPosition = Math.min(
-      0,
+      ratingsInfo.count - 1,
-      Math.min(position, ratingsInfo.count - 1),
+      Math.max(0, Math.min(position, ratingsInfo.count - 1)),
     );
 
     if (season === 0) {

src/app/tools/session/components/CustomColumn.tsx

@@ -23,8 +23,6 @@ export function CustomColumn({ column, Builder }: CustomColumn) {
       <Builder.SubTrigger>Column {column + 1}</Builder.SubTrigger>
 
       <Builder.SubContent>
-        <Builder.Label>Display</Builder.Label>
-
         <Builder.RadioGroup
           value={customColumn.display}
           onValueChange={(event) =>

src/app/tools/session/components/Menu.tsx

@@ -1,4 +1,21 @@
-import { ContextMenu, DropdownMenu } from '@radix-ui/themes';
+import {
+  Button,
+  ContextMenu,
+  Dialog,
+  DropdownMenu,
+  Flex,
+  Heading,
+  TextField,
+} from '@radix-ui/themes';
+import { createColors } from 'bepaint';
+import { useRef, useState } from 'react';
+import {
+  ACCENT_COLORS,
+  AccentColor,
+  GRAY_COLORS,
+  GrayColor,
+  PALETTES,
+} from '../../../../constants/radixColors';
 import { useSession } from '../../../../stores/session';
 import { CustomColumn } from './CustomColumn';
 
@@ -9,38 +26,111 @@ interface ContextMenuProps {
 
 export function Menu({ Builder, reset }: ContextMenuProps) {
   const session = useSession();
+  const [showTitleEditor, setShowTitleEditor] = useState(false);
+  const titleInput = useRef<HTMLInputElement>(null);
 
   return (
-    <Builder.Content>
+    <>
-      <CustomColumn Builder={Builder} column={0} />
+      <Dialog.Root open={showTitleEditor} onOpenChange={setShowTitleEditor}>
-      <CustomColumn Builder={Builder} column={1} />
+        <Dialog.Content>
-      <CustomColumn Builder={Builder} column={2} />
+          <Flex direction="column" gap="4">
-      <CustomColumn Builder={Builder} column={3} />
+            <Heading size="4">Edit title</Heading>
 
-      <Builder.Separator />
+            <Flex gap="2" style={{ width: '100%' }}>
+              <TextField.Root style={{ flex: 1 }}>
+                <TextField.Input
+                  ref={titleInput}
+                  defaultValue={session.title}
+                  placeholder="Enter title..."
+                  onKeyDown={(event) => {
+                    if (event.key === 'Enter' && titleInput.current) {
+                      setShowTitleEditor(false);
+                      useSession.setState({ title: titleInput.current!.value });
+                    }
+                  }}
+                />
+              </TextField.Root>
 
-      <Builder.CheckboxItem
+              <Dialog.Close>
-        checked={session.showTotal}
+                <Button
-        onCheckedChange={(checked) =>
+                  onClick={() =>
-          useSession.setState({ showTotal: checked })
+                    useSession.setState({ title: titleInput.current!.value })
-        }
+                  }
-      >
+                >
-        Show total
+                  Set
-      </Builder.CheckboxItem>
+                </Button>
-      <Builder.CheckboxItem
+              </Dialog.Close>
-        checked={session.showCareer}
+            </Flex>
-        onCheckedChange={(checked) =>
+          </Flex>
-          useSession.setState({ showCareer: checked })
+        </Dialog.Content>
-        }
+      </Dialog.Root>
-      >
-        Show career
-      </Builder.CheckboxItem>
 
-      <Builder.Separator />
+      <Builder.Content>
+        <Builder.Sub>
+          <Builder.SubTrigger>Accent color</Builder.SubTrigger>
 
-      <Builder.Item color="red" onClick={reset}>
+          <Builder.SubContent>
-        Reset
+            <Builder.RadioGroup
-      </Builder.Item>
+              value={session.color}
-    </Builder.Content>
+              onValueChange={(value) =>
+                useSession.setState({ color: value as AccentColor | GrayColor })
+              }
+            >
+              {[...ACCENT_COLORS, ...GRAY_COLORS].map((color) => (
+                <Builder.RadioItem value={color} key={color}>
+                  <Flex gap="2" align="center">
+                    <div
+                      style={{
+                        backgroundColor: createColors(PALETTES[color])
+                          .solidBackground,
+                        width: 16,
+                        height: 16,
+                        borderRadius: '100%',
+                      }}
+                    />
+                    {`${color.charAt(0).toUpperCase()}${color.slice(1)}`}
+                  </Flex>
+                </Builder.RadioItem>
+              ))}
+            </Builder.RadioGroup>
+          </Builder.SubContent>
+        </Builder.Sub>
+
+        <Builder.Separator />
+
+        <Builder.Item onClick={() => setShowTitleEditor(true)}>
+          Edit title...
+        </Builder.Item>
+        <CustomColumn Builder={Builder} column={0} />
+        <CustomColumn Builder={Builder} column={1} />
+        <CustomColumn Builder={Builder} column={2} />
+        <CustomColumn Builder={Builder} column={3} />
+
+        <Builder.Separator />
+
+        <Builder.CheckboxItem
+          checked={session.showTotal}
+          onCheckedChange={(checked) =>
+            useSession.setState({ showTotal: checked })
+          }
+        >
+          Show total
+        </Builder.CheckboxItem>
+        <Builder.CheckboxItem
+          checked={session.showCareer}
+          onCheckedChange={(checked) =>
+            useSession.setState({ showCareer: checked })
+          }
+        >
+          Show career
+        </Builder.CheckboxItem>
+
+        <Builder.Separator />
+
+        <Builder.Item color="red" onClick={reset}>
+          Reset
+        </Builder.Item>
+      </Builder.Content>
+    </>
   );
 }

src/app/tools/session/page.tsx

@@ -248,7 +248,7 @@ export default function Page() {
         </div>
       </div>
 
-      <SessionPage />
+      <SessionPage naked={false} />
     </PageWrapper>
   );
 }

src/app/tools/tankopedia/[id]/page.tsx

@@ -0,0 +1,250 @@
+'use client';
+
+import { ArrowLeftIcon, CaretRightIcon } from '@radix-ui/react-icons';
+import {
+  Button,
+  Card,
+  Checkbox,
+  Dialog,
+  Flex,
+  Heading,
+  Slider,
+  Tabs,
+  Text,
+  Theme,
+  Tooltip,
+} from '@radix-ui/themes';
+import { OrbitControls } from '@react-three/drei';
+import { Canvas } from '@react-three/fiber';
+import Link from 'next/link';
+import { use, useEffect, useState } from 'react';
+import { Flag } from '../../../../components/Flag';
+import PageWrapper from '../../../../components/PageWrapper';
+import { asset } from '../../../../core/blitzkrieg/asset';
+import { gunDefinitions } from '../../../../core/blitzkrieg/definitions/guns';
+import { shellDefinitions } from '../../../../core/blitzkrieg/definitions/shells';
+import {
+  TIER_ROMAN_NUMERALS,
+  tankDefinitions,
+  tanksDefinitionsArray,
+} from '../../../../core/blitzkrieg/definitions/tanks';
+import { turretDefinitions } from '../../../../core/blitzkrieg/definitions/turrets';
+import * as styles from '../page.css';
+
+type Mode = 'model' | 'armor';
+
+export default function Page({ params }: { params: { id: string } }) {
+  const id = parseInt(params.id);
+  const awaitedTankDefinitions = use(tankDefinitions);
+  const awaitedTanksDefinitionsArray = use(tanksDefinitionsArray);
+  const awaitedTurretDefinitions = use(turretDefinitions);
+  const awaitedGunDefinitions = use(gunDefinitions);
+  const awaitedShellDefinitions = use(shellDefinitions);
+  const tank = awaitedTankDefinitions[id];
+  const [turret, setTurret] = useState(
+    awaitedTurretDefinitions[tank.turrets[0]],
+  );
+  const [gun, setGun] = useState(awaitedGunDefinitions[turret.guns[0]]);
+  const [crew, setCrew] = useState(100);
+  const [versusTank, setVersusTank] = useState(
+    awaitedTanksDefinitionsArray[0].id,
+  );
+  const [mode, setMode] = useState<Mode>('model');
+
+  console.log(versusTank);
+
+  useEffect(() => setGun(awaitedGunDefinitions[turret.guns[0]]), [turret]);
+
+  return (
+    <PageWrapper>
+      <Flex gap="8" direction="column">
+        <Flex gap="4" direction="column">
+          <Flex justify="between" align="center">
+            <Link
+              href="/tools/tankopedia"
+              style={{ color: 'unset', textDecoration: 'none' }}
+            >
+              <Flex gap="1" align="center">
+                <ArrowLeftIcon />
+                <Text>Back to tankopedia</Text>
+              </Flex>
+            </Link>
+
+            <Flex gap="2" align="center">
+              <Flag nation={tank.nation} />
+              <Heading>{tank.name}</Heading>
+            </Flex>
+          </Flex>
+
+          <Card style={{ position: 'relative' }}>
+            <Flex direction="column" gap="2">
+              <Tabs.Root
+                value={mode}
+                onValueChange={(value) => setMode(value as Mode)}
+              >
+                <Tabs.List>
+                  <Tabs.Trigger value="model">Model</Tabs.Trigger>
+                  <Tabs.Trigger value="armor">Armor</Tabs.Trigger>
+                </Tabs.List>
+              </Tabs.Root>
+
+              <div style={{ height: '50vh', maxHeight: 576 }}>
+                <Canvas onPointerDown={(event) => event.preventDefault()}>
+                  <OrbitControls />
+
+                  <ambientLight />
+                  <directionalLight />
+
+                  <mesh>
+                    <torusKnotGeometry args={[undefined, undefined, 128, 16]} />
+                    <meshStandardMaterial color="cyan" />
+                  </mesh>
+                </Canvas>
+              </div>
+
+              {mode === 'armor' && (
+                <Flex gap="2" align="center" className={styles.enhancedArmor}>
+                  <Checkbox defaultChecked />
+                  <Text>Enhanced armor</Text>
+                </Flex>
+              )}
+            </Flex>
+          </Card>
+
+          {mode === 'armor' && (
+            <Card>
+              <Flex align="center" justify="between" gap="2">
+                <Flex align="center" gap="4">
+                  <Text>Versus</Text>
+
+                  <Dialog.Root>
+                    <Dialog.Trigger>
+                      <Button variant="ghost">
+                        {awaitedTankDefinitions[versusTank].name}
+                        <CaretRightIcon />
+                      </Button>
+                    </Dialog.Trigger>
+
+                    <Dialog.Content>Do something lol</Dialog.Content>
+                  </Dialog.Root>
+                </Flex>
+
+                <Flex gap="2" align="center">
+                  <Checkbox defaultChecked />
+                  <Text>Calibrated shells</Text>
+                </Flex>
+
+                <Flex gap="1">
+                  <Button variant="solid" radius="small">
+                    <img src={asset('shells/ap.webp')} width={24} height={24} />
+                  </Button>
+                  <Button variant="soft" radius="small" color="gray">
+                    <img
+                      src={asset('shells/hc_premium.webp')}
+                      width={24}
+                      height={24}
+                    />
+                  </Button>
+                  <Button variant="soft" radius="small" color="gray">
+                    <img src={asset('shells/he.webp')} width={24} height={24} />
+                  </Button>
+                </Flex>
+              </Flex>
+            </Card>
+          )}
+        </Flex>
+
+        <Flex gap="6" direction="column">
+          <Heading>Build</Heading>
+
+          <Flex gap="2" direction="column">
+            <Heading size="5" weight="regular">
+              Modules
+            </Heading>
+            <Theme radius="small">
+              <Flex gap="4">
+                <Flex gap="1">
+                  {tank.turrets.map((turretId) => {
+                    const thisTurret = awaitedTurretDefinitions[turretId];
+
+                    return (
+                      <Tooltip content={thisTurret.name}>
+                        <Button
+                          onClick={() => setTurret(thisTurret)}
+                          variant={
+                            turret.id === thisTurret.id ? 'solid' : 'soft'
+                          }
+                        >
+                          <img
+                            src="/images/modules/turret.png"
+                            width={32}
+                            height={32}
+                          />
+                          {TIER_ROMAN_NUMERALS[thisTurret.tier]}
+                        </Button>
+                      </Tooltip>
+                    );
+                  })}
+                </Flex>
+
+                <Flex gap="1">
+                  {turret.guns.map((gunId, index) => {
+                    const thisGun = awaitedGunDefinitions[gunId];
+
+                    return (
+                      <Tooltip content={thisGun.name}>
+                        <Button
+                          onClick={() => setGun(thisGun)}
+                          variant={gun.id === thisGun.id ? 'solid' : 'soft'}
+                        >
+                          <img
+                            src="/images/modules/gun.png"
+                            width={32}
+                            height={32}
+                          />
+                          {TIER_ROMAN_NUMERALS[thisGun.tier]}
+                        </Button>
+                      </Tooltip>
+                    );
+                  })}
+                </Flex>
+              </Flex>
+            </Theme>
+          </Flex>
+
+          <Flex gap="2" direction="column">
+            <Heading size="5" weight="regular">
+              Crew
+            </Heading>
+
+            <Flex gap="4" align="center">
+              <Text>{crew}%</Text>
+
+              <Slider
+                style={{ flex: 1 }}
+                value={[crew]}
+                min={50}
+                max={100}
+                onValueChange={([crew]) => setCrew(crew)}
+              />
+            </Flex>
+          </Flex>
+        </Flex>
+
+        <Flex gap="2" direction="column">
+          <Heading size="5">Shells</Heading>
+
+          {gun.shells.map((shellId) => {
+            const shell = awaitedShellDefinitions[shellId];
+
+            return (
+              <Text>
+                {shell.name} ({shell.type}): {shell.damage.armor}
+              </Text>
+            );
+          })}
+        </Flex>
+      </Flex>
+    </PageWrapper>
+  );
+}

src/app/tools/tankopedia/components/Options/index.css.ts

@@ -0,0 +1,17 @@
+import { style } from '@vanilla-extract/css';
+
+export const splitFilters = style({
+  '@media': {
+    'screen and (min-width: 513px)': {
+      display: 'none',
+    },
+  },
+});
+
+export const oneLineFilters = style({
+  '@media': {
+    'screen and (max-width: 512px)': {
+      display: 'none',
+    },
+  },
+});

src/app/tools/tankopedia/components/Options/index.tsx

@@ -0,0 +1,388 @@
+'use client';
+
+import { CaretDownIcon } from '@radix-ui/react-icons';
+import { Button, DropdownMenu, Flex } from '@radix-ui/themes';
+import { use } from 'react';
+import { Flag } from '../../../../../components/Flag';
+import {
+  TANK_TYPES,
+  TREE_TYPES,
+  TREE_TYPE_ICONS,
+  TREE_TYPE_IMAGES,
+  TreeTypeEnum,
+} from '../../../../../components/Tanks';
+import {
+  NATIONS,
+  TIERS,
+  TIER_ROMAN_NUMERALS,
+} from '../../../../../core/blitzkrieg/definitions/tanks';
+import mutateTankopedia, {
+  TankopediaTestTankDisplay,
+  useTankopedia,
+} from '../../../../../stores/tankopedia';
+import * as styles from './index.css';
+
+export function Options() {
+  const nations = use(NATIONS);
+  const tankopediaState = useTankopedia();
+
+  return (
+    <Flex justify="center" direction="column" gap="2">
+      <Flex gap="2" style={{ flex: 1 }} wrap="wrap">
+        <Button
+          color="red"
+          onClick={() =>
+            useTankopedia.setState({
+              filters: {
+                nations: [],
+                tiers: [],
+                treeTypes: [],
+                types: [],
+                test: 'include',
+              },
+            })
+          }
+        >
+          Clear
+        </Button>
+        <DropdownMenu.Root>
+          <DropdownMenu.Trigger>
+            <Button variant="soft">
+              Test tanks
+              <CaretDownIcon />
+            </Button>
+          </DropdownMenu.Trigger>
+          <DropdownMenu.Content>
+            <DropdownMenu.RadioGroup
+              value={tankopediaState.filters.test}
+              onValueChange={(value) =>
+                mutateTankopedia((draft) => {
+                  draft.filters.test = value as TankopediaTestTankDisplay;
+                })
+              }
+            >
+              <DropdownMenu.RadioItem value="include">
+                Include
+              </DropdownMenu.RadioItem>
+              <DropdownMenu.RadioItem value="exclude">
+                Exclude
+              </DropdownMenu.RadioItem>
+              <DropdownMenu.RadioItem value="only">Only</DropdownMenu.RadioItem>
+            </DropdownMenu.RadioGroup>
+          </DropdownMenu.Content>
+        </DropdownMenu.Root>
+        <Flex style={{ flex: 1 }}>
+          {TREE_TYPES.map((type, index) => (
+            <Button
+              key={type}
+              variant={
+                tankopediaState.filters.treeTypes.includes(type)
+                  ? 'solid'
+                  : 'soft'
+              }
+              style={{
+                flex: 1,
+                margin: -0.5,
+                borderTopLeftRadius: index === 0 ? undefined : 0,
+                borderBottomLeftRadius: index === 0 ? undefined : 0,
+                borderTopRightRadius:
+                  index === TREE_TYPES.length - 1 ? undefined : 0,
+                borderBottomRightRadius:
+                  index === TREE_TYPES.length - 1 ? undefined : 0,
+              }}
+              onClick={() =>
+                mutateTankopedia((draft) => {
+                  if (draft.filters.treeTypes.includes(type)) {
+                    draft.filters.treeTypes = draft.filters.treeTypes.filter(
+                      (preexistingType) => preexistingType !== type,
+                    );
+                  } else {
+                    draft.filters.treeTypes.push(type);
+                  }
+                })
+              }
+            >
+              <img
+                src={TREE_TYPE_IMAGES[type]}
+                style={{ width: '1em', height: '1em' }}
+              />
+            </Button>
+          ))}
+        </Flex>
+        <Flex style={{ flex: 1 }}>
+          {[...TANK_TYPES].reverse().map((type, index) => (
+            <Button
+              key={type}
+              variant={
+                tankopediaState.filters.types.includes(type) ? 'solid' : 'soft'
+              }
+              style={{
+                flex: 1,
+                margin: -0.5,
+                borderTopLeftRadius: index === 0 ? undefined : 0,
+                borderBottomLeftRadius: index === 0 ? undefined : 0,
+                borderTopRightRadius:
+                  index === TANK_TYPES.length - 1 ? undefined : 0,
+                borderBottomRightRadius:
+                  index === TANK_TYPES.length - 1 ? undefined : 0,
+              }}
+              onClick={() =>
+                mutateTankopedia((draft) => {
+                  if (draft.filters.types.includes(type)) {
+                    draft.filters.types = draft.filters.types.filter(
+                      (preexistingType) => preexistingType !== type,
+                    );
+                  } else {
+                    draft.filters.types.push(type);
+                  }
+                })
+              }
+            >
+              <img
+                src={TREE_TYPE_ICONS[TreeTypeEnum.TechTree][type]}
+                style={{ width: '1em', height: '1em' }}
+              />
+            </Button>
+          ))}
+        </Flex>
+        <Flex
+          direction="column"
+          className={styles.splitFilters}
+          style={{ width: '100%' }}
+        >
+          <Flex>
+            {[...TIERS]
+              .reverse()
+              .slice(0, 5)
+              .map((tier, index) => (
+                <Button
+                  key={tier}
+                  variant={
+                    tankopediaState.filters.tiers.includes(tier)
+                      ? 'solid'
+                      : 'soft'
+                  }
+                  style={{
+                    flex: 1,
+                    margin: -0.5,
+                    borderTopLeftRadius: index === 0 ? undefined : 0,
+                    borderBottomLeftRadius: 0,
+                    borderTopRightRadius:
+                      index === TIERS.length - Math.round(TIERS.length / 2) - 1
+                        ? undefined
+                        : 0,
+                    borderBottomRightRadius: 0,
+                  }}
+                  onClick={() =>
+                    mutateTankopedia((draft) => {
+                      if (draft.filters.tiers.includes(tier)) {
+                        draft.filters.tiers = draft.filters.tiers.filter(
+                          (preexistingTier) => preexistingTier !== tier,
+                        );
+                      } else {
+                        draft.filters.tiers.push(tier);
+                      }
+                    })
+                  }
+                >
+                  {TIER_ROMAN_NUMERALS[tier]}
+                </Button>
+              ))}
+          </Flex>
+          <Flex>
+            {[...TIERS]
+              .reverse()
+              .slice(5, 10)
+              .map((tier, index) => (
+                <Button
+                  key={tier}
+                  variant={
+                    tankopediaState.filters.tiers.includes(tier)
+                      ? 'solid'
+                      : 'soft'
+                  }
+                  style={{
+                    flex: 1,
+                    margin: -0.5,
+                    borderTopLeftRadius: 0,
+                    borderBottomLeftRadius: index === 0 ? undefined : 0,
+                    borderTopRightRadius: 0,
+                    borderBottomRightRadius:
+                      index === TIERS.length - Math.round(TIERS.length / 2) - 1
+                        ? undefined
+                        : 0,
+                  }}
+                  onClick={() =>
+                    mutateTankopedia((draft) => {
+                      if (draft.filters.tiers.includes(tier)) {
+                        draft.filters.tiers = draft.filters.tiers.filter(
+                          (preexistingTier) => preexistingTier !== tier,
+                        );
+                      } else {
+                        draft.filters.tiers.push(tier);
+                      }
+                    })
+                  }
+                >
+                  {TIER_ROMAN_NUMERALS[tier]}
+                </Button>
+              ))}
+          </Flex>
+        </Flex>
+        <Flex
+          direction="column"
+          className={styles.splitFilters}
+          style={{ width: '100%' }}
+        >
+          <Flex>
+            {nations.slice(0, 5).map((nation, index) => (
+              <Button
+                key={nation}
+                variant={
+                  tankopediaState.filters.nations.includes(nation)
+                    ? 'solid'
+                    : 'soft'
+                }
+                style={{
+                  flex: 1,
+                  margin: -0.5,
+                  borderTopLeftRadius: index === 0 ? undefined : 0,
+                  borderBottomLeftRadius: 0,
+                  borderTopRightRadius:
+                    index === nations.length - Math.round(nations.length / 2)
+                      ? undefined
+                      : 0,
+                  borderBottomRightRadius:
+                    index === nations.length - 1 ? undefined : 0,
+                }}
+                onClick={() =>
+                  mutateTankopedia((draft) => {
+                    if (draft.filters.nations.includes(nation)) {
+                      draft.filters.nations = draft.filters.nations.filter(
+                        (preexistingType) => preexistingType !== nation,
+                      );
+                    } else {
+                      draft.filters.nations.push(nation);
+                    }
+                  })
+                }
+              >
+                <Flag nation={nation} />
+              </Button>
+            ))}
+          </Flex>
+
+          <Flex>
+            {nations.slice(5, 10).map((nation, index) => (
+              <Button
+                key={nation}
+                variant={
+                  tankopediaState.filters.nations.includes(nation)
+                    ? 'solid'
+                    : 'soft'
+                }
+                style={{
+                  flex: 1,
+                  margin: -0.5,
+                  borderTopLeftRadius: 0,
+                  borderBottomLeftRadius: index === 0 ? undefined : 0,
+                  borderTopRightRadius:
+                    index === nations.length - 1 ? undefined : 0,
+                  borderBottomRightRadius:
+                    index ===
+                    nations.length - Math.round(nations.length / 2) - 1
+                      ? undefined
+                      : 0,
+                }}
+                onClick={() =>
+                  mutateTankopedia((draft) => {
+                    if (draft.filters.nations.includes(nation)) {
+                      draft.filters.nations = draft.filters.nations.filter(
+                        (preexistingType) => preexistingType !== nation,
+                      );
+                    } else {
+                      draft.filters.nations.push(nation);
+                    }
+                  })
+                }
+              >
+                <Flag nation={nation} />
+              </Button>
+            ))}
+          </Flex>
+        </Flex>
+      </Flex>
+
+      <Flex gap="2" style={{ flex: 1 }} wrap="wrap">
+        <Flex className={styles.oneLineFilters} style={{ flex: 1 }}>
+          {[...TIERS].reverse().map((tier, index) => (
+            <Button
+              key={tier}
+              variant={
+                tankopediaState.filters.tiers.includes(tier) ? 'solid' : 'soft'
+              }
+              style={{
+                flex: 1,
+                margin: -0.5,
+                borderTopLeftRadius: index === 0 ? undefined : 0,
+                borderBottomLeftRadius: index === 0 ? undefined : 0,
+                borderTopRightRadius:
+                  index === TIERS.length - 1 ? undefined : 0,
+                borderBottomRightRadius:
+                  index === TIERS.length - 1 ? undefined : 0,
+              }}
+              onClick={() =>
+                mutateTankopedia((draft) => {
+                  if (draft.filters.tiers.includes(tier)) {
+                    draft.filters.tiers = draft.filters.tiers.filter(
+                      (preexistingTier) => preexistingTier !== tier,
+                    );
+                  } else {
+                    draft.filters.tiers.push(tier);
+                  }
+                })
+              }
+            >
+              {TIER_ROMAN_NUMERALS[tier]}
+            </Button>
+          ))}
+        </Flex>
+        <Flex className={styles.oneLineFilters} style={{ flex: 1 }}>
+          {nations.map((nation, index) => (
+            <Button
+              key={nation}
+              variant={
+                tankopediaState.filters.nations.includes(nation)
+                  ? 'solid'
+                  : 'soft'
+              }
+              style={{
+                flex: 1,
+                margin: -0.5,
+                borderTopLeftRadius: index === 0 ? undefined : 0,
+                borderBottomLeftRadius: index === 0 ? undefined : 0,
+                borderTopRightRadius:
+                  index === nations.length - 1 ? undefined : 0,
+                borderBottomRightRadius:
+                  index === nations.length - 1 ? undefined : 0,
+              }}
+              onClick={() =>
+                mutateTankopedia((draft) => {
+                  if (draft.filters.nations.includes(nation)) {
+                    draft.filters.nations = draft.filters.nations.filter(
+                      (preexistingType) => preexistingType !== nation,
+                    );
+                  } else {
+                    draft.filters.nations.push(nation);
+                  }
+                })
+              }
+            >
+              <Flag nation={nation} />
+            </Button>
+          ))}
+        </Flex>
+      </Flex>
+    </Flex>
+  );
+}

src/app/tools/tankopedia/components/PageTurner.tsx

@@ -0,0 +1,77 @@
+import { CaretLeftIcon, CaretRightIcon } from '@radix-ui/react-icons';
+import { Button, Flex, TextField } from '@radix-ui/themes';
+import { useEffect, useRef } from 'react';
+import { BlitzkriegTankDefinition } from '../../../../core/blitzkrieg/definitions/tanks';
+
+interface PageTurnerProps {
+  page: number;
+  setPage: (page: number) => void;
+  searchedList: BlitzkriegTankDefinition[];
+  tanksPerPage: number;
+}
+
+export function PageTurner({
+  page,
+  setPage,
+  searchedList,
+  tanksPerPage,
+}: PageTurnerProps) {
+  const pageInput = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    if (pageInput.current) pageInput.current.value = `${page + 1}`;
+  }, [page]);
+
+  return (
+    <Flex align="center" justify="center" gap="2">
+      <Button
+        variant="soft"
+        disabled={page === 0}
+        onClick={() => setPage(Math.max(0, page - 1))}
+      >
+        <CaretLeftIcon />
+      </Button>
+      <TextField.Root>
+        <TextField.Slot>Page</TextField.Slot>
+        <TextField.Input
+          defaultValue={1}
+          type="number"
+          ref={pageInput}
+          min={1}
+          max={Math.floor(searchedList.length / tanksPerPage) + 1}
+          style={{ width: 64, textAlign: 'center' }}
+          onBlur={(event) => {
+            setPage(
+              Math.max(
+                0,
+                Math.min(
+                  Math.floor(searchedList.length / tanksPerPage),
+                  event.target.valueAsNumber - 1,
+                ),
+              ),
+            );
+          }}
+          onKeyDown={(event) => {
+            if (event.key === 'Enter') {
+              (event.target as HTMLInputElement).blur();
+            }
+          }}
+        />
+        <TextField.Slot>
+          out of {Math.floor(searchedList.length / tanksPerPage) + 1}
+        </TextField.Slot>
+      </TextField.Root>
+      <Button
+        variant="soft"
+        disabled={Math.floor(searchedList.length / tanksPerPage) === page}
+        onClick={() =>
+          setPage(
+            Math.min(Math.floor(searchedList.length / tanksPerPage), page + 1),
+          )
+        }
+      >
+        <CaretRightIcon />
+      </Button>
+    </Flex>
+  );
+}

src/app/tools/tankopedia/page.css.ts

@@ -0,0 +1,57 @@
+import { style } from '@vanilla-extract/css';
+import { theme } from '../../../stitches.config';
+
+export const listing = style({});
+
+export const flag = style({
+  transitionDuration: theme.durations.regular,
+  left: '0',
+  top: '0',
+
+  [`.${listing}:hover &, .${listing}:active &`]: {
+    transform: 'translateX(-25%)',
+    filter: 'blur(3rem)',
+  },
+});
+
+export const listingShadow = style({
+  boxShadow: `inset 128px -128px 128px -128px ${theme.colors.appBackground1}`,
+
+  [`.${listing}:hover &, .${listing}:active &`]: {
+    boxShadow: `inset 0 0 0 -128px ${theme.colors.appBackground1}`,
+  },
+});
+
+export const listingLabel = style({
+  transition: `transform ${theme.durations.regular}`,
+  transform: 'translateY(0)',
+
+  [`.${listing}:hover &, .${listing}:active &`]: {
+    transform: 'translateY(200%)',
+  },
+});
+
+export const listingImage = style({
+  transition: `transform ${theme.durations.regular}`,
+  position: 'absolute',
+  left: '50%',
+
+  [`.${listing}:hover &, .${listing}:active &`]: {
+    transform: 'translate(-25%, 10%)',
+  },
+});
+
+export const enhancedArmor = style({
+  '@media': {
+    'screen and (min-width: 400px)': {
+      position: 'absolute',
+      right: 16,
+      top: 16,
+    },
+
+    'screen and (max-width: 399px)': {
+      // left: 16,
+      // bottom: 16,
+    },
+  },
+});

src/app/tools/tankopedia/page.tsx

@@ -0,0 +1,329 @@
+'use client';
+
+import { slateDark } from '@radix-ui/colors';
+import {
+  CaretDownIcon,
+  CaretUpIcon,
+  MagnifyingGlassIcon,
+} from '@radix-ui/react-icons';
+import {
+  Button,
+  Card,
+  DropdownMenu,
+  Flex,
+  Inset,
+  Text,
+  TextField,
+} from '@radix-ui/themes';
+import { go } from 'fuzzysort';
+import { Suspense, use, useEffect, useMemo, useRef, useState } from 'react';
+import PageWrapper from '../../../components/PageWrapper';
+import { asset } from '../../../core/blitzkrieg/asset';
+import {
+  BlitzkriegTankDefinition,
+  TANK_ICONS,
+  TANK_ICONS_COLLECTOR,
+  TANK_ICONS_PREMIUM,
+  TIER_ROMAN_NUMERALS,
+  tanksDefinitionsArray,
+} from '../../../core/blitzkrieg/definitions/tanks';
+import { tankIcon } from '../../../core/blitzkrieg/tankIcon';
+import { theme } from '../../../stitches.config';
+import mutateTankopedia, {
+  TankopediaSortBy,
+  TankopediaSortDirection,
+  useTankopedia,
+} from '../../../stores/tankopedia';
+import { Options } from './components/Options';
+import { PageTurner } from './components/PageTurner';
+import * as styles from './page.css';
+
+const TANKS_PER_PAGE = 3 * 2 ** 3;
+
+export default function Page() {
+  const tankopediaState = useTankopedia();
+  const awaitedTanks = use(tanksDefinitionsArray);
+  const input = useRef<HTMLInputElement>(null);
+  const searchableTanks = useMemo(
+    () =>
+      awaitedTanks
+        .filter(
+          (tank) =>
+            (tankopediaState.filters.tiers.length === 0
+              ? true
+              : tankopediaState.filters.tiers.includes(tank.tier)) &&
+            (tankopediaState.filters.types.length === 0
+              ? true
+              : tankopediaState.filters.types.includes(tank.type)) &&
+            (tankopediaState.filters.treeTypes.length === 0
+              ? true
+              : tankopediaState.filters.treeTypes.includes(tank.tree_type)) &&
+            (tankopediaState.filters.nations.length === 0
+              ? true
+              : tankopediaState.filters.nations.includes(tank.nation)) &&
+            (tankopediaState.filters.test === 'include'
+              ? true
+              : tankopediaState.filters.test === 'exclude'
+                ? !tank.testing
+                : tank.testing),
+        )
+        .sort((a, b) => {
+          let diff = 0;
+
+          if (tankopediaState.sort.by === 'tier') {
+            diff = a.tier - b.tier;
+          }
+          if (tankopediaState.sort.by === 'name') {
+            diff = a.name.localeCompare(b.name);
+          }
+
+          return tankopediaState.sort.direction === 'ascending' ? diff : -diff;
+        }),
+    [tankopediaState.filters, tankopediaState.sort],
+  );
+  const [searchedList, setSearchedList] = useState(searchableTanks);
+  const [page, setPage] = useState(0);
+  const [showFilters, setShowFilters] = useState(false);
+
+  useEffect(() => {
+    setSearchedList(searchableTanks);
+    if (input.current) input.current.value = '';
+  }, [searchableTanks]);
+
+  useEffect(() => {
+    setPage(
+      Math.min(
+        Math.max(0, page),
+        Math.ceil(searchedList.length / TANKS_PER_PAGE) - 1,
+      ),
+    );
+  }, [searchedList]);
+
+  return (
+    <PageWrapper size="wide" color="purple">
+      <Suspense fallback={<Text>Loading...</Text>}>
+        <Flex direction="column" gap="4">
+          <Flex gap="2">
+            <TextField.Root style={{ flex: 1 }}>
+              <TextField.Slot>
+                <MagnifyingGlassIcon height="16" width="16" />
+              </TextField.Slot>
+              <TextField.Input
+                ref={input}
+                placeholder="Search tanks..."
+                onChange={(event) => {
+                  if (event.target.value.length === 0) {
+                    setSearchedList(searchableTanks);
+                  } else {
+                    setSearchedList(
+                      go(event.target.value, searchableTanks, {
+                        keys: [
+                          'name',
+                          'id',
+                        ] satisfies (keyof BlitzkriegTankDefinition)[],
+                      }).map(({ obj }) => obj),
+                    );
+                  }
+                }}
+              />
+            </TextField.Root>
+
+            <DropdownMenu.Root>
+              <DropdownMenu.Trigger>
+                <Button variant="soft">
+                  Sort
+                  <CaretDownIcon />
+                </Button>
+              </DropdownMenu.Trigger>
+              <DropdownMenu.Content>
+                <DropdownMenu.Label>By</DropdownMenu.Label>
+                <DropdownMenu.RadioGroup
+                  value={tankopediaState.sort.by}
+                  onValueChange={(value) =>
+                    mutateTankopedia((draft) => {
+                      draft.sort.by = value as TankopediaSortBy;
+                    })
+                  }
+                >
+                  <DropdownMenu.RadioItem value="tier">
+                    Tier
+                  </DropdownMenu.RadioItem>
+                  <DropdownMenu.RadioItem value="name">
+                    Name
+                  </DropdownMenu.RadioItem>
+                </DropdownMenu.RadioGroup>
+
+                <DropdownMenu.Separator />
+
+                <DropdownMenu.Label>Direction</DropdownMenu.Label>
+                <DropdownMenu.RadioGroup
+                  value={tankopediaState.sort.direction}
+                  onValueChange={(value) =>
+                    mutateTankopedia((draft) => {
+                      draft.sort.direction = value as TankopediaSortDirection;
+                    })
+                  }
+                >
+                  <DropdownMenu.RadioItem value="ascending">
+                    Ascending
+                  </DropdownMenu.RadioItem>
+                  <DropdownMenu.RadioItem value="descending">
+                    Descending
+                  </DropdownMenu.RadioItem>
+                </DropdownMenu.RadioGroup>
+              </DropdownMenu.Content>
+            </DropdownMenu.Root>
+
+            <Button
+              variant="soft"
+              onClick={() => setShowFilters((state) => !state)}
+            >
+              Filters {showFilters ? <CaretUpIcon /> : <CaretDownIcon />}
+            </Button>
+          </Flex>
+
+          {showFilters && (
+            <Card>
+              <Suspense fallback={<Text>Loading...</Text>}>
+                <Options />
+              </Suspense>
+            </Card>
+          )}
+        </Flex>
+
+        <PageTurner
+          page={page}
+          setPage={setPage}
+          tanksPerPage={TANKS_PER_PAGE}
+          searchedList={searchedList}
+        />
+
+        <Flex wrap="wrap" gap="3" justify="center">
+          {searchedList
+            .map((tank) => (
+              <a
+                key={tank.id}
+                href={`/tools/tankopedia/${tank.id}`}
+                style={{
+                  flex: 1,
+                  textDecoration: 'none',
+                  color: 'unset',
+                }}
+              >
+                <Card className={styles.listing}>
+                  <Inset
+                    key={tank.id}
+                    style={{
+                      minWidth: 256,
+                      minHeight: 128,
+                      position: 'relative',
+                      display: 'flex',
+                    }}
+                  >
+                    <img
+                      className={styles.flag}
+                      src={asset(`flags/scratched/${tank.nation}.webp`)}
+                      style={{
+                        width: '100%',
+                        height: '100%',
+                        objectFit: 'contain',
+                        position: 'absolute',
+                      }}
+                    />
+
+                    <div
+                      style={{
+                        width: 256,
+                        height: 128,
+                      }}
+                      className={styles.listingImage}
+                    >
+                      <img
+                        src={tankIcon(tank.id)}
+                        style={{
+                          objectFit: 'contain',
+                          objectPosition: 'left center',
+                        }}
+                      />
+                    </div>
+
+                    <div
+                      className={styles.listingShadow}
+                      style={{
+                        width: '100%',
+                        height: '100%',
+                        position: 'absolute',
+                        transition: `box-shadow ${theme.durations.regular}`,
+                      }}
+                    />
+
+                    <Flex
+                      align="center"
+                      justify="between"
+                      className={styles.listingLabel}
+                      style={{
+                        position: 'absolute',
+                        bottom: 8,
+                        padding: '0 12px',
+                        width: '100%',
+                        boxSizing: 'border-box',
+                      }}
+                    >
+                      <Flex align="center" justify="center" gap="1">
+                        <img
+                          src={
+                            (tank.tree_type === 'collector'
+                              ? TANK_ICONS_COLLECTOR
+                              : tank.tree_type === 'premium'
+                                ? TANK_ICONS_PREMIUM
+                                : TANK_ICONS)[tank.type]
+                          }
+                          style={{ width: '1em', height: '1em' }}
+                        />
+                        <Text
+                          size="4"
+                          color={
+                            tank.tree_type === 'collector'
+                              ? 'blue'
+                              : tank.tree_type === 'premium'
+                                ? 'amber'
+                                : undefined
+                          }
+                          weight="medium"
+                          style={{
+                            color:
+                              tank.tree_type === 'researchable'
+                                ? slateDark.slate12
+                                : undefined,
+                            whiteSpace: 'nowrap',
+                            maxWidth: 160,
+                            display: 'block',
+                            textOverflow: 'ellipsis',
+                            overflow: 'hidden',
+                          }}
+                        >
+                          {tank.name}
+                        </Text>
+                      </Flex>
+
+                      <Text size="4" color="gray" highContrast={false}>
+                        {TIER_ROMAN_NUMERALS[tank.tier]}
+                      </Text>
+                    </Flex>
+                  </Inset>
+                </Card>
+              </a>
+            ))
+            .slice(page * TANKS_PER_PAGE, (page + 1) * TANKS_PER_PAGE)}
+        </Flex>
+
+        <PageTurner
+          page={page}
+          setPage={setPage}
+          tanksPerPage={TANKS_PER_PAGE}
+          searchedList={searchedList}
+        />
+      </Suspense>
+    </PageWrapper>
+  );
+}

src/commands/about.ts

@@ -6,18 +6,18 @@ import { COMMANDS_RAW, CommandRegistry } from '../events/interactionCreate';
 
 const RAW_PATH = `https://raw.githubusercontent.com/tresabhi/blitzkrieg/main/docs/`;
 const DOCS = {
-  permissions: 'guide/permissions',
   embeds: 'guide/embeds',
   introduction: 'guide/introduction',
   invite: 'guide/invite',
   timezones: 'guide/timezones',
+  creators: 'guide/creators',
 };
 const DOC_DESCRIPTIONS: Record<keyof typeof DOCS, string> = {
-  permissions: 'The permissions needed for the bot to function',
   embeds: 'How embeds work',
   introduction: 'About the bot',
   invite: 'How to invite the bot',
   timezones: 'How Blitzkrieg infers and uses your timezone',
+  creators: 'Who created the bot',
 };
 
 function addDocsSubcommands(option: SlashCommandSubcommandsOnlyBuilder) {

src/commands/breakdown.tsx

@@ -8,13 +8,12 @@ import { AllStats, getAccountInfo } from '../core/blitz/getAccountInfo';
 import { getClanAccountInfo } from '../core/blitz/getClanAccountInfo';
 import getTankStats from '../core/blitz/getTankStats';
 import getTreeType from '../core/blitz/getTreeType';
-import resolveTankName from '../core/blitz/resolveTankName';
+import { tankDefinitions } from '../core/blitzkrieg/definitions/tanks';
 import { filtersToDescription } from '../core/blitzkrieg/filtersToDescription';
 import { getBlitzStarsLinkButton } from '../core/blitzstars/getBlitzStarsLinkButton';
 import getStatsInPeriod from '../core/blitzstars/getStatsInPeriod';
 import { tankAverages } from '../core/blitzstars/tankAverages';
-import { tankopedia } from '../core/blitzstars/tankopedia';
+import addPeriodicFilterOptions from '../core/discord/addPeriodicFilterOptions';
-import addFilterOptions from '../core/discord/addFilterOptions';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteTanks from '../core/discord/autocompleteTanks';
 import autocompleteUsername from '../core/discord/autocompleteUsername';
@@ -34,17 +33,17 @@ import resolvePlayerFromCommand, {
 import calculateWN8 from '../core/statistics/calculateWN8';
 import { StatFilters, filterStats } from '../core/statistics/filterStats';
 import getWN8Percentile from '../core/statistics/getWN8Percentile';
-import { CommandRegistryRaw } from '../events/interactionCreate';
+import { CommandRegistryPromisable } from '../events/interactionCreate';
 
 const ROWS_PER_PAGE = 8;
 const MAX_PAGES = 10;
 
-async function render(
+export async function renderBreakdown(
   { region, id }: ResolvedPlayer,
   { start, end, name }: ResolvedPeriod,
   filters: StatFilters,
 ) {
-  const awaitedTankopedia = await tankopedia;
+  const awaitedTankDefinitions = await tankDefinitions;
   const awaitedTankAverages = await tankAverages;
   const statsInPeriod = await getStatsInPeriod(region, id, start, end);
   const { filteredOrder } = await filterStats(statsInPeriod, filters);
@@ -183,7 +182,7 @@ async function render(
 
     await Promise.all(
       filteredOrder.map(async (id, index) => {
-        const tankopediaEntry = awaitedTankopedia[id];
+        const tankDefinition = awaitedTankDefinitions[id];
         const current = orderedCurrentStats[index];
         const career = orderedCareerStats[index];
         const currentWN8 = orderedCurrentWN8[index];
@@ -193,9 +192,9 @@ async function render(
           <Breakdown.Row
             key={id}
             type="tank"
-            tankType={tankopediaEntry?.type}
+            tankType={tankDefinition?.type}
-            treeType={tankopediaEntry ? await getTreeType(id) : undefined}
+            treeType={tankDefinition ? await getTreeType(id) : undefined}
-            title={await resolveTankName(id)}
+            title={awaitedTankDefinitions[id].name}
             stats={[
               {
                 title: 'Battles',
@@ -291,9 +290,9 @@ async function render(
   }
 }
 
-export const breakdownCommand = new Promise<CommandRegistryRaw>(
+export const breakdownCommand = new Promise<CommandRegistryPromisable>(
   async (resolve) => {
-    const command = await addFilterOptions(
+    const command = await addPeriodicFilterOptions(
       new SlashCommandBuilder()
         .setName('breakdown')
         .setDescription("A period's breakdown by tanks played"),
@@ -317,7 +316,7 @@ export const breakdownCommand = new Promise<CommandRegistryRaw>(
         });
 
         return [
-          ...(await render(player, period, filters)),
+          ...(await renderBreakdown(player, period, filters)),
           buttonPrimary(path, 'Refresh'),
           await getBlitzStarsLinkButton(player.region, player.id),
         ];
@@ -333,7 +332,7 @@ export const breakdownCommand = new Promise<CommandRegistryRaw>(
         const period = resolvePeriodFromButton(player.region, interaction);
         const filters = getFiltersFromButton(interaction);
 
-        return await render(player, period, filters);
+        return await renderBreakdown(player, period, filters);
       },
     });
   },

src/commands/credits.ts

@@ -1,15 +0,0 @@
-import { AttachmentBuilder, SlashCommandBuilder } from 'discord.js';
-import { CommandRegistry } from '../events/interactionCreate';
-
-export const creditsCommand: CommandRegistry = {
-  inProduction: true,
-  inPublic: true,
-
-  command: new SlashCommandBuilder()
-    .setName('credits')
-    .setDescription('Me and the people who made this bot'),
-
-  async handler() {
-    return new AttachmentBuilder('https://i.imgur.com/ZF5ch33.png');
-  },
-};

src/commands/debug.ts

@@ -1,11 +1,6 @@
 import { SlashCommandBuilder } from 'discord.js';
 import packageJSON from '../../package.json' assert { type: 'json' };
-import getClientId from '../core/blitzkrieg/getClientId';
-import { tankAverages } from '../core/blitzstars/tankAverages';
-import { tankopedia } from '../core/blitzstars/tankopedia';
 import { client } from '../core/discord/client';
-import embedInfo from '../core/discord/embedInfo';
-import markdownTable from '../core/discord/markdownTable';
 import { CommandRegistry } from '../events/interactionCreate';
 
 const executionStart = new Date().getTime();
@@ -18,27 +13,24 @@ export const debugCommand: CommandRegistry = {
     .setName('debug')
     .setDescription('Debug information about the bot'),
 
-  async handler(interaction) {
+  async handler() {
     const currentTime = new Date().getTime();
     const uptime = currentTime - executionStart;
+    const list = [
+      ['Version', packageJSON.version],
+      ['Shard', client.shard?.ids[0] ?? 'default'],
+      [
+        'Uptime',
+        `${Math.floor((uptime / 1000 / 60 / 60) % 24)}h ${Math.floor(
+          (uptime / 1000 / 60) % 60,
+        )}m ${Math.floor((uptime / 1000) % 60)}s ${Math.floor(
+          uptime % 1000,
+        )}ms`,
+      ],
+    ]
+      .map(([key, value]) => `- ${key}: ${value}`)
+      .join('\n');
 
-    return embedInfo(
+    return `# Debug\n\n${list}`;
-      `${client.user?.username} debug information`,
-      markdownTable([
-        ['Version', packageJSON.version],
-        ['Client ID', getClientId()],
-        ['Tag', interaction.client.user.tag],
-        [
-          'Uptime',
-          `${Math.floor(uptime / 1000 / 60 / 60 / 24)}d ${Math.floor(
-            (uptime / 1000 / 60 / 60) % 24,
-          )}h ${Math.floor((uptime / 1000 / 60) % 60)}m ${Math.floor(
-            (uptime / 1000) % 60,
-          )}s ${Math.floor(uptime % 1000)}ms`,
-        ],
-        ['Tankopedia cached', `${(await tankopedia) !== undefined}`],
-        ['Tank averages cached', `${(await tankAverages) !== undefined}`],
-      ]),
-    );
   },
 };

src/commands/eligible.ts

@@ -1,10 +1,10 @@
 import { SlashCommandBuilder } from 'discord.js';
 import { getAccountInfo } from '../core/blitz/getAccountInfo';
+import { tankDefinitions } from '../core/blitzkrieg/definitions/tanks';
 import getPeriodNow from '../core/blitzkrieg/getPeriodNow';
 import getTimeDaysAgo from '../core/blitzkrieg/getTimeDaysAgo';
 import getStatsInPeriod from '../core/blitzstars/getStatsInPeriod';
 import { tankAverages } from '../core/blitzstars/tankAverages';
-import { tankopedia } from '../core/blitzstars/tankopedia';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import embedNegative from '../core/discord/embedNegative';
 import embedPositive from '../core/discord/embedPositive';
@@ -66,11 +66,11 @@ export const eligibleCommand: CommandRegistry = {
         (await entries.reduce<PossiblyPromise<number>>(
           async (accumulator, [tankIdString, stats]) => {
             const tankId = parseInt(tankIdString);
-            const tankopediaEntry = (await tankopedia)[tankId];
+            const tankDefinition = (await tankDefinitions)[tankId];
 
-            if (!tankopediaEntry) return accumulator;
+            if (!tankDefinition) return accumulator;
 
-            const tankTier = tankopediaEntry.tier;
+            const tankTier = tankDefinition.tier;
 
             return (await accumulator) + tankTier * stats.battles;
           },
@@ -79,9 +79,9 @@ export const eligibleCommand: CommandRegistry = {
         (await entries.reduce<PossiblyPromise<number>>(
           async (accumulator, [tankIdString, stats]) => {
             const tankId = parseInt(tankIdString);
-            const tankopediaEntry = (await tankopedia)[tankId];
+            const tankDefinition = (await tankDefinitions)[tankId];
 
-            if (!tankopediaEntry) return accumulator;
+            if (!tankDefinition) return accumulator;
 
             return stats.battles;
           },
@@ -110,7 +110,7 @@ export const eligibleCommand: CommandRegistry = {
           async (accumulator, [tankIdString, stats]) => {
             const tankId = parseInt(tankIdString);
 
-            if ((await tankopedia)[tankId]?.tier === 10) {
+            if ((await tankDefinitions)[tankId]?.tier === 10) {
               const tankStats = diffed[tankId];
               return (await accumulator) + tankStats.damage_dealt;
             } else return accumulator;
@@ -121,7 +121,7 @@ export const eligibleCommand: CommandRegistry = {
           async (accumulator, [tankIdString, stats]) => {
             const tankId = parseInt(tankIdString);
 
-            if ((await tankopedia)[tankId]?.tier === 10) {
+            if ((await tankDefinitions)[tankId]?.tier === 10) {
               const tankStats = diffed[tankId];
               return (await accumulator) + tankStats.battles;
             } else return accumulator;

src/commands/evolution.tsx

@@ -29,7 +29,7 @@ import resolvePlayerFromButton from '../core/discord/resolvePlayerFromButton';
 import resolvePlayerFromCommand, {
   ResolvedPlayer,
 } from '../core/discord/resolvePlayerFromCommand';
-import { CommandRegistryRaw } from '../events/interactionCreate';
+import { CommandRegistryPromisable } from '../events/interactionCreate';
 
 type EvolutionStatType = 'player' | 'tank';
 
@@ -107,7 +107,7 @@ async function render(
   );
 }
 
-export const evolutionCommand = new Promise<CommandRegistryRaw>(
+export const evolutionCommand = new Promise<CommandRegistryPromisable>(
   async (resolve) => {
     let playerGroup: SlashCommandSubcommandGroupBuilder;
     let tankGroup: SlashCommandSubcommandGroupBuilder;

src/commands/fullStats.tsx

@@ -10,7 +10,7 @@ import { emblemIdToURL } from '../core/blitzkrieg/emblemIdToURL';
 import { filtersToDescription } from '../core/blitzkrieg/filtersToDescription';
 import { getBlitzStarsLinkButton } from '../core/blitzstars/getBlitzStarsLinkButton';
 import getStatsInPeriod from '../core/blitzstars/getStatsInPeriod';
-import addFilterOptions from '../core/discord/addFilterOptions';
+import addPeriodicFilterOptions from '../core/discord/addPeriodicFilterOptions';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteTanks from '../core/discord/autocompleteTanks';
 import autocompleteUsername from '../core/discord/autocompleteUsername';
@@ -29,7 +29,7 @@ import resolvePlayerFromCommand, {
 } from '../core/discord/resolvePlayerFromCommand';
 import { StatFilters, filterStats } from '../core/statistics/filterStats';
 import { getTierWeights } from '../core/statistics/getTierWeights';
-import { CommandRegistryRaw } from '../events/interactionCreate';
+import { CommandRegistryPromisable } from '../events/interactionCreate';
 
 async function render(
   { region, id }: ResolvedPlayer,
@@ -64,9 +64,9 @@ async function render(
   );
 }
 
-export const fullStatsCommand = new Promise<CommandRegistryRaw>(
+export const fullStatsCommand = new Promise<CommandRegistryPromisable>(
   async (resolve) => {
-    const command = await addFilterOptions(
+    const command = await addPeriodicFilterOptions(
       new SlashCommandBuilder()
         .setName('full-stats')
         .setDescription('Full in-game statistics'),

src/commands/link.tsx

@@ -1,25 +1,21 @@
 import { teal } from '@radix-ui/colors';
-import {
+import { GuildMemberRoleManager, SlashCommandBuilder } from 'discord.js';
-  AttachmentBuilder,
-  GuildMemberRoleManager,
-  SlashCommandBuilder,
-} from 'discord.js';
 import markdownEscape from 'markdown-escape';
 import discord from '../../discord.json' assert { type: 'json' };
 import { Glow } from '../components/AllStatsOverview/components/WN8Display/components/Glow';
 import Wrapper from '../components/Wrapper';
-import { REGION_NAMES_SHORT, Region } from '../constants/regions';
+import { REGION_NAMES } from '../constants/regions';
 import { getAccountInfo } from '../core/blitz/getAccountInfo';
 import { getClanAccountInfo } from '../core/blitz/getClanAccountInfo';
 import { linkBlitzAndDiscord } from '../core/blitzkrieg/discordBlitz';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteUsername from '../core/discord/autocompleteUsername';
+import embedInfo from '../core/discord/embedInfo';
 import embedNegative from '../core/discord/embedNegative';
+import resolvePlayerFromCommand from '../core/discord/resolvePlayerFromCommand';
 import { CommandRegistry } from '../events/interactionCreate';
 import { theme } from '../stitches.config';
 
-const serverAndIdPattern = /(com|eu|asia)\/[0-9]+/;
-
 export const verifyCommand: CommandRegistry = {
   inProduction: true,
   inPublic: true,
@@ -30,193 +26,183 @@ export const verifyCommand: CommandRegistry = {
     .addStringOption((option) => addUsernameChoices(option).setRequired(true)),
 
   async handler(interaction) {
-    const username = interaction.options.getString('username', true);
+    const { id, region } = await resolvePlayerFromCommand(interaction);
+    const discordId = parseInt(interaction.user.id);
+    const accountInfo = await getAccountInfo(region, id);
+    const clanAccountInfo = await getClanAccountInfo(region, id, ['clan']);
 
-    if (serverAndIdPattern.test(username)) {
+    await linkBlitzAndDiscord(discordId, region, id);
-      const [region, idString] = username.split('/');
-      const id = parseInt(idString);
-      const discordId = parseInt(interaction.user.id);
-      const accountInfo = await getAccountInfo(region as Region, id);
-      const clanAccountInfo = await getClanAccountInfo(region as Region, id, [
-        'clan',
-      ]);
 
-      await linkBlitzAndDiscord(discordId, region as Region, id);
+    if (interaction.guildId === discord.sklld_guild_id) {
-
+      if (!interaction.guild?.members.me?.permissions.has('ManageRoles')) {
-      if (interaction.guildId === discord.sklld_guild_id) {
+        return embedNegative(
-        if (!interaction.guild?.members.me?.permissions.has('ManageRoles')) {
+          `${markdownEscape(interaction.user.username)} failed to verify`,
-          return embedNegative(
+          "I don't have the permission to change your manage roles.",
-            `${markdownEscape(interaction.user.username)} failed to verify`,
-            "I don't have the permission to change your manage roles.",
-          );
-        }
-
-        await (interaction.member!.roles as GuildMemberRoleManager).remove(
-          discord.sklld_verify_role,
-        );
-        await (interaction.member!.roles as GuildMemberRoleManager).add(
-          discord.sklld_peasant_role,
         );
       }
 
-      return (
+      await (interaction.member!.roles as GuildMemberRoleManager).remove(
-        <Wrapper fat>
+        discord.sklld_verify_role,
+      );
+      await (interaction.member!.roles as GuildMemberRoleManager).add(
+        discord.sklld_peasant_role,
+      );
+    }
+
+    return [
+      <Wrapper fat>
+        <div
+          style={{
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'space-between',
+          }}
+        >
+          <Glow color={teal.teal9} rotation={90} />
+
           <div
             style={{
               display: 'flex',
+              flexDirection: 'column',
               alignItems: 'center',
-              justifyContent: 'space-between',
+              justifyContent: 'center',
+              gap: 16,
             }}
           >
-            <Glow color={teal.teal9} rotation={90} />
+            <div
+              style={{
+                display: 'flex',
+                gap: 8,
+                alignItems: 'center',
+                justifyContent: 'center',
+              }}
+            >
+              <img
+                src={
+                  interaction.user.avatarURL({ extension: 'png' }) ??
+                  'https://i.stack.imgur.com/l60Hf.png'
+                }
+                style={{
+                  width: 64,
+                  height: 64,
+                  borderRadius: 32,
+                  objectFit: 'cover',
+                }}
+              />
+
+              <div
+                style={{
+                  display: 'flex',
+                  flexDirection: 'column',
+                  gap: 4,
+                }}
+              >
+                <span
+                  style={{
+                    fontSize: 32,
+                    color: theme.colors.textHighContrast,
+                    fontWeight: 900,
+                    maxWidth: 240,
+                    overflow: 'hidden',
+                    textOverflow: 'ellipsis',
+                    whiteSpace: 'nowrap',
+                  }}
+                >
+                  {interaction.user.displayName}
+                </span>
+                <span
+                  style={{
+                    fontSize: 16,
+                    color: theme.colors.textLowContrast,
+                  }}
+                >
+                  @{interaction.user.username}
+                </span>
+              </div>
+            </div>
 
             <div
               style={{
                 display: 'flex',
-                flexDirection: 'column',
                 alignItems: 'center',
                 justifyContent: 'center',
-                gap: 16,
+                gap: 4,
+                color: theme.colors.textLowContrast_teal,
               }}
             >
-              <div
+              <img
+                src="https://i.imgur.com/jIcRgog.png"
                 style={{
-                  display: 'flex',
+                  width: 16,
-                  gap: 8,
+                  height: 16,
-                  alignItems: 'center',
-                  justifyContent: 'center',
                 }}
-              >
+              />
+              <span style={{ fontSize: 16 }}>Accounts linked</span>
+            </div>
+
+            <div
+              style={{
+                display: 'flex',
+                gap: 8,
+                alignItems: 'center',
+                justifyContent: 'center',
+              }}
+            >
+              {clanAccountInfo?.clan ? (
                 <img
-                  src={
-                    interaction.user.avatarURL({ extension: 'png' }) ??
-                    'https://i.stack.imgur.com/l60Hf.png'
-                  }
                   style={{
                     width: 64,
                     height: 64,
                     borderRadius: 32,
                     objectFit: 'cover',
                   }}
+                  src={`https://wotblitz-gc.gcdn.co/icons/clanEmblems1x/clan-icon-v2-${clanAccountInfo?.clan?.emblem_set_id}.png`}
                 />
-
+              ) : null}
-                <div
-                  style={{
-                    display: 'flex',
-                    flexDirection: 'column',
-                    gap: 4,
-                  }}
-                >
-                  <span
-                    style={{
-                      fontSize: 32,
-                      color: theme.colors.textHighContrast,
-                      fontWeight: 900,
-                      maxWidth: 240,
-                      overflow: 'hidden',
-                      textOverflow: 'ellipsis',
-                      whiteSpace: 'nowrap',
-                    }}
-                  >
-                    {interaction.user.displayName}
-                  </span>
-                  <span
-                    style={{
-                      fontSize: 16,
-                      color: theme.colors.textLowContrast,
-                    }}
-                  >
-                    @{interaction.user.username}
-                  </span>
-                </div>
-              </div>
-
               <div
                 style={{
                   display: 'flex',
-                  alignItems: 'center',
+                  flexDirection: 'column',
-                  justifyContent: 'center',
                   gap: 4,
-                  color: theme.colors.textLowContrast_teal,
                 }}
               >
-                <img
+                <span
-                  src="https://i.imgur.com/jIcRgog.png"
                   style={{
-                    width: 16,
+                    fontSize: 32,
-                    height: 16,
+                    color: theme.colors.textHighContrast,
-                  }}
+                    fontWeight: 900,
-                />
+                    maxWidth: 240,
-                <span style={{ fontSize: 16 }}>Accounts linked</span>
+                    overflow: 'hidden',
-              </div>
+                    textOverflow: 'ellipsis',
-
+                    whiteSpace: 'nowrap',
-              <div
-                style={{
-                  display: 'flex',
-                  gap: 8,
-                  alignItems: 'center',
-                  justifyContent: 'center',
-                }}
-              >
-                {clanAccountInfo?.clan ? (
-                  <img
-                    style={{
-                      width: 64,
-                      height: 64,
-                      borderRadius: 32,
-                      objectFit: 'cover',
-                    }}
-                    src={`https://wotblitz-gc.gcdn.co/icons/clanEmblems1x/clan-icon-v2-${clanAccountInfo?.clan?.emblem_set_id}.png`}
-                  />
-                ) : null}
-                <div
-                  style={{
-                    display: 'flex',
-                    flexDirection: 'column',
-                    gap: 4,
                   }}
                 >
-                  <span
+                  {accountInfo.nickname}
-                    style={{
+                </span>
-                      fontSize: 32,
+                <span
-                      color: theme.colors.textHighContrast,
+                  style={{
-                      fontWeight: 900,
+                    fontSize: 16,
-                      maxWidth: 240,
+                    color: theme.colors.textLowContrast,
-                      overflow: 'hidden',
+                  }}
-                      textOverflow: 'ellipsis',
+                >
-                      whiteSpace: 'nowrap',
+                  {clanAccountInfo?.clan
-                    }}
+                    ? `[${clanAccountInfo?.clan?.tag}] - `
-                  >
+                    : ''}
-                    {accountInfo.nickname}
+                  {REGION_NAMES[region]}
-                  </span>
+                </span>
-                  <span
-                    style={{
-                      fontSize: 16,
-                      color: theme.colors.textLowContrast,
-                    }}
-                  >
-                    {clanAccountInfo?.clan
-                      ? `[${clanAccountInfo?.clan?.tag}] - `
-                      : ''}
-                    {REGION_NAMES_SHORT[region as Region]}
-                  </span>
-                </div>
               </div>
             </div>
-
-            <Glow color={teal.teal9} rotation={-90} />
           </div>
-        </Wrapper>
+
-      );
+          <Glow color={teal.teal9} rotation={-90} />
-    } else {
+        </div>
-      return [
+      </Wrapper>,
-        embedNegative(
+
-          'Please select from the options',
+      embedInfo(
-          'Follow the procedure like the video above. The search results may take a while to show up.',
+        'Incorrect account?',
-        ),
+        'Use the command again and select a username from the search results.',
-        new AttachmentBuilder('https://i.imgur.com/2p6GFgC.gif'),
+      ),
-      ];
+    ];
-    }
   },
 
   autocomplete: autocompleteUsername,

src/commands/ownedTanks.tsx

@@ -3,19 +3,19 @@ import NoData, { NoDataType } from '../components/NoData';
 import * as Tanks from '../components/Tanks';
 import TitleBar from '../components/TitleBar';
 import Wrapper from '../components/Wrapper';
+import { encyclopediaInfo } from '../core/blitz/encyclopediaInfo';
 import { getAccountInfo } from '../core/blitz/getAccountInfo';
 import { getClanAccountInfo } from '../core/blitz/getClanAccountInfo';
 import getTankStats from '../core/blitz/getTankStats';
 import getTreeType from '../core/blitz/getTreeType';
-import resolveTankName from '../core/blitz/resolveTankName';
-import { tankopediaInfo } from '../core/blitz/tankopediaInfo';
-import { emblemIdToURL } from '../core/blitzkrieg/emblemIdToURL';
 import {
+  BlitzkriegTankDefinition,
   TIER_ROMAN_NUMERALS,
-  TankopediaEntry,
   Tier,
-  tankopedia,
+  tankDefinitions,
-} from '../core/blitzstars/tankopedia';
+} from '../core/blitzkrieg/definitions/tanks';
+import { emblemIdToURL } from '../core/blitzkrieg/emblemIdToURL';
+import { tankIcon } from '../core/blitzkrieg/tankIcon';
 import addTierChoices from '../core/discord/addTierChoices';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteUsername from '../core/discord/autocompleteUsername';
@@ -41,21 +41,21 @@ export const ownedTanksCommand: CommandRegistry = {
     const filteredTanks = (
       await Promise.all(
         tankStats.map(async (tankData) => ({
-          tankopedia: (await tankopedia)[tankData.tank_id]!,
+          tankDefinitions: (await tankDefinitions)[tankData.tank_id]!,
-          tank_id: tankData.tank_id,
+          id: tankData.tank_id,
         })),
       )
-    ).filter((tank) => tank.tankopedia?.tier === tier);
+    ).filter((tank) => tank.tankDefinitions?.tier === tier);
     const clanAccountInfo = await getClanAccountInfo(server, id, ['clan']);
-    const groupedTanks: Record<string, TankopediaEntry[]> = {};
+    const groupedTanks: Record<string, BlitzkriegTankDefinition[]> = {};
     const nations: string[] = [];
 
     filteredTanks.forEach((tank) => {
-      if (groupedTanks[tank.tankopedia.nation] === undefined) {
+      if (groupedTanks[tank.tankDefinitions.nation] === undefined) {
-        groupedTanks[tank.tankopedia.nation] = [tank.tankopedia];
+        groupedTanks[tank.tankDefinitions.nation] = [tank.tankDefinitions];
-        nations.push(tank.tankopedia.nation);
+        nations.push(tank.tankDefinitions.nation);
       } else {
-        groupedTanks[tank.tankopedia.nation].push(tank.tankopedia);
+        groupedTanks[tank.tankDefinitions.nation].push(tank.tankDefinitions);
       }
     });
 
@@ -86,7 +86,7 @@ export const ownedTanksCommand: CommandRegistry = {
               return (
                 <Tanks.Root>
                   <Tanks.Title>
-                    {(await tankopediaInfo).vehicle_nations[nation]}
+                    {(await encyclopediaInfo).vehicle_nations[nation]}
                   </Tanks.Title>
 
                   <Tanks.Row>
@@ -94,11 +94,11 @@ export const ownedTanksCommand: CommandRegistry = {
                       {await Promise.all(
                         leftColumn.map(async (tank) => (
                           <Tanks.Item
-                            key={tank.tank_id}
+                            key={tank.id}
-                            name={await resolveTankName(tank.tank_id)}
+                            name={tank.name}
                             tankType={tank.type}
-                            image={tank.images?.normal}
+                            image={tankIcon(tank.id)}
-                            treeType={await getTreeType(tank.tank_id)}
+                            treeType={await getTreeType(tank.id)}
                           />
                         )),
                       )}
@@ -107,11 +107,11 @@ export const ownedTanksCommand: CommandRegistry = {
                       {await Promise.all(
                         rightColumn.map(async (tank) => (
                           <Tanks.Item
-                            key={tank.tank_id}
+                            key={tank.id}
-                            name={await resolveTankName(tank.tank_id)}
+                            name={tank.name}
                             tankType={tank.type}
-                            image={tank.images?.normal}
+                            image={tankIcon(tank.id)}
-                            treeType={await getTreeType(tank.tank_id)}
+                            treeType={await getTreeType(tank.id)}
                           />
                         )),
                       )}

src/commands/permissions.ts

@@ -0,0 +1,42 @@
+import { SlashCommandBuilder } from 'discord.js';
+import { CommandRegistry } from '../events/interactionCreate';
+
+export const permissionsCommand: CommandRegistry = {
+  inProduction: true,
+  inPublic: true,
+
+  command: new SlashCommandBuilder()
+    .setName('permissions')
+    .setDescription('Checks wether the bot has the required permissions'),
+
+  async handler(interaction) {
+    // friday the 13th permissions easter egg
+    const isFridayThe13th =
+      new Date().getDay() === 5 && new Date().getDate() === 13;
+    const permissions = [
+      [
+        interaction.appPermissions?.has('ViewChannel'),
+        'View channels: needed for the refresh button to work',
+      ],
+      [
+        interaction.appPermissions?.has('ReadMessageHistory'),
+        'Read message history: also needed for the refresh button to work',
+      ],
+      [
+        interaction.appPermissions?.has('AttachFiles'),
+        'Attach files: needed for image-based commands to work',
+      ],
+    ];
+    const body = permissions
+      .map(([hasPermission, description]) => {
+        if (hasPermission) {
+          return `${isFridayThe13th ? '😇' : '✅'} ${description}`;
+        } else {
+          return `${isFridayThe13th ? '💀' : '❌'} ${description}`;
+        }
+      })
+      .join('\n');
+
+    return `# Permissions\n${body}`;
+  },
+};

src/commands/ratings.tsx

@@ -2,9 +2,9 @@ import {
   APIApplicationCommandOptionChoice,
   SlashCommandBuilder,
   SlashCommandSubcommandBuilder,
-  SlashCommandSubcommandGroupBuilder,
 } from 'discord.js';
 import { range } from 'lodash';
+import markdownEscape from 'markdown-escape';
 import { BlitzkriegRatingsLeaderboard } from '../../scripts/buildRatingsLeaderboard';
 import * as Leaderboard from '../components/Leaderboard';
 import TitleBar from '../components/TitleBar';
@@ -17,18 +17,17 @@ import { getClanAccountInfo } from '../core/blitz/getClanAccountInfo';
 import getRatingsInfo from '../core/blitz/getRatingsInfo';
 import { getRatingsLeague } from '../core/blitz/getRatingsLeague';
 import { getRatingsNeighbors } from '../core/blitz/getRatingsNeighbors';
-import regionToRegionSubdomain from '../core/blitz/regionToRegionSubdomain';
+import { isOnGoingRatingsSeason } from '../core/blitz/isOnGoingRatingsSeason';
 import { getArchivedLatestSeasonNumber } from '../core/blitzkrieg/getArchivedLatestSeasonNumber';
 import getArchivedRatingsInfo from '../core/blitzkrieg/getArchivedRatingsInfo';
 import { getArchivedRatingsLeaderboard } from '../core/blitzkrieg/getArchivedRatingsLeaderboard';
 import getArchivedRatingsMidnightLeaderboard from '../core/blitzkrieg/getArchivedRatingsMidnightLeaderboard';
 import { UserError } from '../core/blitzkrieg/userError';
 import addRegionChoices from '../core/discord/addRegionChoices';
-import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteUsername from '../core/discord/autocompleteUsername';
 import embedNegative from '../core/discord/embedNegative';
 import resolvePlayerFromCommand from '../core/discord/resolvePlayerFromCommand';
-import { CommandRegistryRaw } from '../events/interactionCreate';
+import { CommandRegistryPromisable } from '../events/interactionCreate';
 
 export interface RatingsPlayer {
   spa_id: number;
@@ -117,18 +116,22 @@ export interface RatingsNeighbors {
   neighbors: RatingsPlayer[];
 }
 
-function addSubcommands(
+const noOngoingSeason = embedNegative(
-  option: SlashCommandSubcommandGroupBuilder,
+  'No ongoing season',
-  addOptions = (option: SlashCommandSubcommandBuilder) => option,
+  "Wargaming didn't provide any data for this season.",
-) {
+);
-  return option
+
-    .addSubcommand((option) =>
+export const ratingsCommand = new Promise<CommandRegistryPromisable>(
-      addOptions(
+  async (resolve) => {
-        option
+    const latestArchivedSeasonNumber = await getArchivedLatestSeasonNumber();
-          .setName('neighbors')
+    const onGoingSeason = await isOnGoingRatingsSeason();
-          .setDescription('Your position and neighbors'),
+    const seasonNumbers = range(
-      )
+      FIRST_ARCHIVED_RATINGS_SEASON,
-        .addStringOption(addUsernameChoices)
+      latestArchivedSeasonNumber + (onGoingSeason ? 1 : 0) + 1,
+    );
+
+    function addSubcommands(option: SlashCommandSubcommandBuilder) {
+      return option
         .addIntegerOption((option) =>
           option
             .setName('limit')
@@ -136,77 +139,57 @@ function addSubcommands(
             .setRequired(false)
             .setMinValue(5)
             .setMaxValue(30),
-        ),
+        )
-    )
-    .addSubcommand((option) =>
-      addOptions(option.setName('league').setDescription('Top league players'))
         .addStringOption((option) =>
           option
-            .setName('league')
+            .setName('season')
-            .setDescription('The league to display')
+            .setDescription('Season number')
-            .addChoices(
-              ...LEAGUES.map(
-                ({ name }, value) =>
-                  ({
-                    name,
-                    value: `${value}`,
-                  }) satisfies APIApplicationCommandOptionChoice<string>,
-              ),
-            )
-            .setRequired(true),
-        )
-        .addStringOption(addRegionChoices)
-        .addIntegerOption((option) =>
-          option
-            .setName('limit')
-            .setDescription('How many rows to display (default: 10)')
             .setRequired(false)
-            .setMinValue(5)
+            .addChoices(
-            .setMaxValue(30),
+              ...seasonNumbers
-        ),
+                .map(
-    );
+                  (number, index) =>
-}
+                    ({
-
+                      name: `${number}${index === seasonNumbers.length - 1 && onGoingSeason ? ' (current)' : ''}`,
-const noOngoingSeason = embedNegative(
+                      value: `${number}`,
-  'No ongoing season',
+                    }) satisfies APIApplicationCommandOptionChoice<string>,
-  "Wargaming didn't provide any data for this season.",
+                )
-);
+                .reverse(),
-
+            ),
-export const ratingsCommand = new Promise<CommandRegistryRaw>(
+        );
-  async (resolve) => {
+    }
-    const latestArchivedSeasonNumber = await getArchivedLatestSeasonNumber();
-    const seasonChoices = range(
-      FIRST_ARCHIVED_RATINGS_SEASON,
-      latestArchivedSeasonNumber + 1,
-    ).map(
-      (number) =>
-        ({
-          name: `Season ${number}`,
-          value: `${number}`,
-        }) satisfies APIApplicationCommandOptionChoice<string>,
-    );
 
     const command = new SlashCommandBuilder()
       .setName('ratings')
       .setDescription('Ratings battles statistics')
-      .addSubcommandGroup((option) =>
+      .addSubcommand((option) =>
-        addSubcommands(
-          option.setName('archive').setDescription('Any previous season'),
-          (option) =>
-            option.addStringOption((option) =>
-              option
-                .setName('season')
-                .setDescription('The season number')
-                .setChoices(...seasonChoices)
-                .setRequired(true),
-            ),
-        ),
-      )
-      .addSubcommandGroup((option) =>
         addSubcommands(
           option
-            .setName('current')
+            .setName('neighbors')
-            .setDescription('The current running Ratings season'),
+            .setDescription('Shows neighboring players on the leaderboard'),
+        ),
+      )
+      .addSubcommand((option) =>
+        addSubcommands(
+          option
+            .setName('league')
+            .setDescription('Shows top players from a league')
+            .addStringOption(addRegionChoices)
+            .addStringOption((option) =>
+              option
+                .setName('league')
+                .setDescription('The league to display')
+                .addChoices(
+                  ...LEAGUES.map(
+                    ({ name }, value) =>
+                      ({
+                        name,
+                        value: `${value}`,
+                      }) satisfies APIApplicationCommandOptionChoice<string>,
+                  ),
+                )
+                .setRequired(true),
+            ),
         ),
       );
 
@@ -225,18 +208,19 @@ export const ratingsCommand = new Promise<CommandRegistryRaw>(
           nickname: string;
         }
 
-        const subcommandGroup = interaction.options.getSubcommandGroup(true) as
-          | 'archive'
-          | 'current';
         const subcommand = interaction.options.getSubcommand(true) as
           | 'league'
           | 'neighbors';
         const limit = interaction.options.getInteger('limit') ?? 10;
         const seasonOption = interaction.options.getString('season');
-        const season = seasonOption ? parseInt(seasonOption) : undefined;
+        const season = seasonOption
+          ? parseInt(seasonOption)
+          : onGoingSeason
+            ? latestArchivedSeasonNumber + 1
+            : latestArchivedSeasonNumber;
+        const isCurrentSeason = season === latestArchivedSeasonNumber + 1;
         let titleName: string;
         let titleImage: string | undefined;
-        let titleNameDiscriminator: string | undefined;
         let titleDescription: string;
         let playersBefore: number;
         let playersAfter: number;
@@ -250,70 +234,66 @@ export const ratingsCommand = new Promise<CommandRegistryRaw>(
             interaction.options.getString('league')!,
           );
           const region = interaction.options.getString('region') as Region;
-          regionRatingsInfo = await (subcommandGroup === 'current'
+          regionRatingsInfo = await (isCurrentSeason
             ? getRatingsInfo(region)
             : getArchivedRatingsInfo(region, season!));
 
           if (regionRatingsInfo.detail !== undefined) return noOngoingSeason;
 
-          const regionSubdomain = regionToRegionSubdomain(region);
+          const result = isCurrentSeason
-          const result =
+            ? await getRatingsLeague(region, leagueIndex).then(async (result) =>
-            subcommandGroup === 'current'
+                result.slice(0, limit).map(
-              ? await getRatingsLeague(region, leagueIndex).then(
+                  (player) =>
-                  async (result) =>
+                    ({
-                    result.slice(0, limit).map(
+                      id: player.spa_id,
-                      (player) =>
+                      score: player.score,
-                        ({
+                      position: player.number,
-                          id: player.spa_id,
+                      clan: player.clan_tag,
-                          score: player.score,
+                      nickname: player.nickname,
-                          position: player.number,
+                    }) satisfies SimplifiedPlayer,
-                          clan: player.clan_tag,
+                ),
-                          nickname: player.nickname,
+              )
-                        }) satisfies SimplifiedPlayer,
+            : await getArchivedRatingsLeaderboard(region, season!).then(
-                    ),
+                async (players) => {
-                )
+                  const firstPlayerIndex =
-              : await getArchivedRatingsLeaderboard(region, season!).then(
+                    leagueIndex === 0
-                  async (players) => {
+                      ? 0
-                    const firstPlayerIndex =
+                      : players.findIndex(
-                      leagueIndex === 0
+                          (player) =>
-                        ? 0
+                            player.score < LEAGUES[leagueIndex - 1].minScore,
-                        : players.findIndex(
+                        );
-                            (player) =>
+                  const lastPlayerIndex = firstPlayerIndex + limit - 1;
-                              player.score < LEAGUES[leagueIndex - 1].minScore,
+                  const trimmed = players.slice(
-                          );
+                    firstPlayerIndex,
-                    const lastPlayerIndex = firstPlayerIndex + limit - 1;
+                    lastPlayerIndex + 1,
-                    const trimmed = players.slice(
+                  );
-                      firstPlayerIndex,
+                  const clanData = await getClanAccountInfo(
-                      lastPlayerIndex + 1,
+                    region,
-                    );
+                    trimmed.map(({ id }) => id),
-                    const clanData = await getClanAccountInfo(
+                    ['clan'],
-                      region,
+                  );
-                      trimmed.map(({ id }) => id),
-                      ['clan'],
-                    );
 
-                    return trimmed.map(
+                  return trimmed.map(
-                      (player, index) =>
+                    (player, index) =>
-                        ({
+                      ({
-                          id: player.id,
+                        id: player.id,
-                          score: player.score,
+                        score: player.score,
-                          position: firstPlayerIndex + index + 1,
+                        position: firstPlayerIndex + index + 1,
-                          clan: clanData[player.id]?.clan?.tag,
+                        clan: clanData[player.id]?.clan?.tag,
-                          nickname:
+                        nickname:
-                            clanData[player.id]?.account_name ??
+                          clanData[index]?.account_name ??
-                            `Unknown Player ${player.id}`,
+                          `Deleted ${player.id}`,
-                        }) satisfies SimplifiedPlayer,
+                      }) satisfies SimplifiedPlayer,
-                    );
+                  );
-                  },
+                },
-                );
+              );
           const leagueInfo = regionRatingsInfo.leagues[leagueIndex];
-          midnightLeaderboard =
+          midnightLeaderboard = isCurrentSeason
-            subcommandGroup === 'current'
+            ? await getArchivedRatingsMidnightLeaderboard(
-              ? await getArchivedRatingsMidnightLeaderboard(
+                region,
-                  region,
+                regionRatingsInfo.current_season,
-                  regionRatingsInfo.current_season,
+              )
-                )
+            : await getArchivedRatingsMidnightLeaderboard(region, season!);
-              : await getArchivedRatingsMidnightLeaderboard(region, season!);
 
           players = result;
           playersBefore = result ? result[0].position - 1 : 0;
@@ -328,22 +308,17 @@ export const ratingsCommand = new Promise<CommandRegistryRaw>(
           titleDescription = `Top ${limit} players`;
         } else {
           const { region, id } = await resolvePlayerFromCommand(interaction);
-          regionRatingsInfo =
+          regionRatingsInfo = isCurrentSeason
-            subcommandGroup === 'current'
+            ? await getRatingsInfo(region)
-              ? await getRatingsInfo(region)
+            : await getArchivedRatingsInfo(region, season!);
-              : await getArchivedRatingsInfo(region, season!);
 
           if (regionRatingsInfo.detail !== undefined) return noOngoingSeason;
 
           const accountInfo = await getAccountInfo(region, id);
           const clan = (await getClanAccountInfo(region, id, ['clan']))?.clan;
-          const neighbors =
+          const neighbors = isCurrentSeason
-            subcommandGroup === 'current'
+            ? await getRatingsNeighbors(region, id, Math.round(limit / 2)).then(
-              ? await getRatingsNeighbors(
+                (players) =>
-                  region,
-                  id,
-                  Math.round(limit / 2),
-                ).then((players) =>
                   players.neighbors.map(
                     (player) =>
                       ({
@@ -354,52 +329,47 @@ export const ratingsCommand = new Promise<CommandRegistryRaw>(
                         nickname: player.nickname,
                       }) satisfies SimplifiedPlayer,
                   ),
-                )
+              )
-              : await getArchivedRatingsLeaderboard(region, season!).then(
+            : await getArchivedRatingsLeaderboard(region, season!).then(
-                  async (players) => {
+                async (players) => {
-                    const playerIndex = players.findIndex(
+                  const playerIndex = players.findIndex(
-                      (player) => player.id === id,
+                    (player) => player.id === id,
+                  );
+
+                  if (playerIndex === -1) {
+                    throw new UserError(
+                      `# ${markdownEscape(accountInfo.nickname)} didn't play ratings in season ${season}\nThis player did not participate in this season or did not get past calibration.`,
                     );
+                  }
 
-                    if (playerIndex === -1) {
+                  const halfRange = Math.round(limit / 2);
-                      throw new UserError(
+                  const trimmed = players.slice(
-                        `${accountInfo.nickname} didn't player ratings in season ${season}`,
+                    playerIndex - halfRange,
-                        {
+                    playerIndex + halfRange + 1,
-                          cause:
+                  );
-                            'This player did not participate in this season or did not get past calibration.',
+                  const clanData = await getClanAccountInfo(
-                        },
+                    region,
-                      );
+                    trimmed.map((player) => player.id),
-                    }
+                    ['clan'],
+                  );
 
-                    const halfRange = Math.round(limit / 2);
+                  return trimmed.map((player, index) => ({
-                    const trimmed = players.slice(
+                    id: player.id,
-                      playerIndex - halfRange,
+                    score: player.score,
-                      playerIndex + halfRange + 1,
+                    position: playerIndex + index + 1,
-                    );
+                    clan: clanData[index]?.clan?.tag,
-                    const clanData = await getClanAccountInfo(
+                    nickname: clanData[index]
-                      region,
+                      ? clanData[index]!.account_name
-                      trimmed.map((player) => player.id),
+                      : `Deleted ${player.id}`,
-                      ['clan'],
+                  }));
-                    );
+                },
-
+              );
-                    return trimmed.map((player, index) => ({
+          midnightLeaderboard = isCurrentSeason
-                      id: player.id,
+            ? await getArchivedRatingsMidnightLeaderboard(
-                      score: player.score,
+                region,
-                      position: playerIndex + index + 1,
+                regionRatingsInfo.current_season,
-                      clan: clanData[player.id]!.clan?.tag,
+              )
-                      nickname: clanData[player.id]!.account_name,
+            : await getArchivedRatingsMidnightLeaderboard(region, season!);
-                    }));
-                  },
-                );
-          midnightLeaderboard =
-            subcommandGroup === 'current'
-              ? await getArchivedRatingsMidnightLeaderboard(
-                  region,
-                  regionRatingsInfo.current_season,
-                )
-              : await getArchivedRatingsMidnightLeaderboard(region, season!);
-
-          if (clan && neighbors) titleNameDiscriminator = `[${clan.tag}]`;
 
           players = neighbors;
           titleImage = clan
@@ -461,11 +431,15 @@ export const ratingsCommand = new Promise<CommandRegistryRaw>(
             {items && (
               <Leaderboard.Root>
                 {playersBefore > 0 && (
-                  <Leaderboard.Gap message={`+ ${playersBefore} more`} />
+                  <Leaderboard.Gap
+                    message={`+ ${playersBefore.toLocaleString()} more`}
+                  />
                 )}
                 {items}
                 {playersAfter > 0 && (
-                  <Leaderboard.Gap message={`+ ${playersAfter} more`} />
+                  <Leaderboard.Gap
+                    message={`+ ${playersAfter.toLocaleString()} more`}
+                  />
                 )}
               </Leaderboard.Root>
             )}

src/commands/searchTanks.ts

@@ -1,7 +1,7 @@
 import { SlashCommandBuilder } from 'discord.js';
 import { go } from 'fuzzysort';
 import markdownEscape from 'markdown-escape';
-import { TANK_NAMES_DIACRITICS } from '../core/blitzstars/tankopedia';
+import { tankNamesDiacritics } from '../core/blitzkrieg/definitions/tanks';
 import addTankChoices from '../core/discord/addTankChoices';
 import embedInfo from '../core/discord/embedInfo';
 import { CommandRegistry } from '../events/interactionCreate';
@@ -25,7 +25,7 @@ export const searchTanksCommand: CommandRegistry = {
   async handler(interaction) {
     const tank = interaction.options.getString('tank')!;
     const limit = interaction.options.getInteger('limit') ?? 25;
-    const results = go(tank, await TANK_NAMES_DIACRITICS, {
+    const results = go(tank, await tankNamesDiacritics, {
       limit,
       keys: ['combined'],
     }).map((result) => result.obj.original);

src/commands/stats.tsx

@@ -9,7 +9,7 @@ import { emblemIdToURL } from '../core/blitzkrieg/emblemIdToURL';
 import { filtersToDescription } from '../core/blitzkrieg/filtersToDescription';
 import { getBlitzStarsLinkButton } from '../core/blitzstars/getBlitzStarsLinkButton';
 import getStatsInPeriod from '../core/blitzstars/getStatsInPeriod';
-import addFilterOptions from '../core/discord/addFilterOptions';
+import addPeriodicFilterOptions from '../core/discord/addPeriodicFilterOptions';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteTanks from '../core/discord/autocompleteTanks';
 import autocompleteUsername from '../core/discord/autocompleteUsername';
@@ -27,7 +27,7 @@ import resolvePlayerFromCommand, {
   ResolvedPlayer,
 } from '../core/discord/resolvePlayerFromCommand';
 import { StatFilters, filterStats } from '../core/statistics/filterStats';
-import { CommandRegistryRaw } from '../events/interactionCreate';
+import { CommandRegistryPromisable } from '../events/interactionCreate';
 
 async function render(
   { region, id }: ResolvedPlayer,
@@ -57,48 +57,50 @@ async function render(
   );
 }
 
-export const statsCommand = new Promise<CommandRegistryRaw>(async (resolve) => {
+export const statsCommand = new Promise<CommandRegistryPromisable>(
-  const command = await addFilterOptions(
+  async (resolve) => {
-    new SlashCommandBuilder()
+    const command = await addPeriodicFilterOptions(
-      .setName('stats')
+      new SlashCommandBuilder()
-      .setDescription('Regular battles statistics'),
+        .setName('stats')
-    (option) => option.addStringOption(addUsernameChoices),
+        .setDescription('Regular battles statistics'),
-  );
+      (option) => option.addStringOption(addUsernameChoices),
+    );
 
-  resolve({
+    resolve({
-    inProduction: true,
+      inProduction: true,
-    inPublic: true,
+      inPublic: true,
 
-    command,
+      command,
 
-    async handler(interaction) {
+      async handler(interaction) {
-      const player = await resolvePlayerFromCommand(interaction);
+        const player = await resolvePlayerFromCommand(interaction);
-      const period = resolvePeriodFromCommand(player.region, interaction);
+        const period = resolvePeriodFromCommand(player.region, interaction);
-      const filters = await getFiltersFromCommand(interaction);
+        const filters = await getFiltersFromCommand(interaction);
-      const path = commandToURL(interaction, {
+        const path = commandToURL(interaction, {
-        ...player,
+          ...player,
-        ...getCustomPeriodParams(interaction),
+          ...getCustomPeriodParams(interaction),
-        ...filters,
+          ...filters,
-      });
+        });
 
-      return Promise.all([
+        return Promise.all([
-        render(player, period, filters),
+          render(player, period, filters),
-        buttonRefresh(interaction, path),
+          buttonRefresh(interaction, path),
-        getBlitzStarsLinkButton(player.region, player.id),
+          getBlitzStarsLinkButton(player.region, player.id),
-      ]);
+        ]);
-    },
+      },
 
-    autocomplete: (interaction) => {
+      autocomplete: (interaction) => {
-      autocompleteUsername(interaction);
+        autocompleteUsername(interaction);
-      autocompleteTanks(interaction);
+        autocompleteTanks(interaction);
-    },
+      },
 
-    async button(interaction) {
+      async button(interaction) {
-      const player = await resolvePlayerFromButton(interaction);
+        const player = await resolvePlayerFromButton(interaction);
-      const period = resolvePeriodFromButton(player.region, interaction);
+        const period = resolvePeriodFromButton(player.region, interaction);
-      const filters = getFiltersFromButton(interaction);
+        const filters = getFiltersFromButton(interaction);
 
-      return await render(player, period, filters);
+        return await render(player, period, filters);
-    },
+      },
-  });
+    });
-});
+  },
+);

src/commands/today.ts

@@ -0,0 +1,71 @@
+import { SlashCommandBuilder } from 'discord.js';
+import { encyclopediaInfo } from '../core/blitz/encyclopediaInfo';
+import { getBlitzStarsLinkButton } from '../core/blitzstars/getBlitzStarsLinkButton';
+import { addFilterOptions } from '../core/discord/addFilterOptions';
+import addUsernameChoices from '../core/discord/addUsernameChoices';
+import autocompleteTanks from '../core/discord/autocompleteTanks';
+import autocompleteUsername from '../core/discord/autocompleteUsername';
+import buttonPrimary from '../core/discord/buttonPrimary';
+import commandToURL from '../core/discord/commandToURL';
+import { getCustomPeriodParams } from '../core/discord/getCustomPeriodParams';
+import { getFiltersFromButton } from '../core/discord/getFiltersFromButton';
+import { getFiltersFromCommand } from '../core/discord/getFiltersFromCommand';
+import resolvePeriodFromButton from '../core/discord/resolvePeriodFromButton';
+import resolvePeriodFromCommand from '../core/discord/resolvePeriodFromCommand';
+import resolvePlayerFromButton from '../core/discord/resolvePlayerFromButton';
+import resolvePlayerFromCommand from '../core/discord/resolvePlayerFromCommand';
+import { CommandRegistryPromisable } from '../events/interactionCreate';
+import { renderBreakdown } from './breakdown';
+
+export const todayCommand = new Promise<CommandRegistryPromisable>(
+  async (resolve) => {
+    const awaitedEncyclopediaInfo = await encyclopediaInfo;
+    const command = addFilterOptions(
+      new SlashCommandBuilder()
+        .setName('today')
+        .setDescription("Today's played tanks and statistics"),
+      awaitedEncyclopediaInfo,
+    ).addStringOption(addUsernameChoices);
+
+    resolve({
+      inProduction: true,
+      inPublic: true,
+
+      command,
+
+      async handler(interaction) {
+        const player = await resolvePlayerFromCommand(interaction);
+        const period = resolvePeriodFromCommand(
+          player.region,
+          interaction,
+          'today',
+        );
+        const filters = await getFiltersFromCommand(interaction);
+        const path = commandToURL(interaction, {
+          ...player,
+          ...getCustomPeriodParams(interaction, true),
+          ...filters,
+        });
+
+        return [
+          ...(await renderBreakdown(player, period, filters)),
+          buttonPrimary(path, 'Refresh'),
+          await getBlitzStarsLinkButton(player.region, player.id),
+        ];
+      },
+
+      autocomplete: (interaction) => {
+        autocompleteUsername(interaction);
+        autocompleteTanks(interaction);
+      },
+
+      async button(interaction) {
+        const player = await resolvePlayerFromButton(interaction);
+        const period = resolvePeriodFromButton(player.region, interaction);
+        const filters = getFiltersFromButton(interaction);
+
+        return await renderBreakdown(player, period, filters);
+      },
+    });
+  },
+);

src/components/AllStatsOverview/components/WN8Display/index.tsx

@@ -37,7 +37,7 @@ export function WN8Display({ WN8 }: WN8DisplayProps) {
         gap: -16,
       }}
     >
-      <Glow color={PERCENTILE_COLORS[percentile]} />
+      <Glow color={color} />
 
       <div
         style={{
@@ -71,7 +71,7 @@ export function WN8Display({ WN8 }: WN8DisplayProps) {
         </span>
       </div>
 
-      <Glow color={PERCENTILE_COLORS[percentile]} direction="reverse" />
+      <Glow color={color} direction="reverse" />
     </div>
   );
 }

src/components/Breakdown/components/Root.tsx

@@ -6,7 +6,10 @@ export interface RootProps {
 
 export function Root({ children }: RootProps) {
   return (
-    <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+    <div
+      className="session-tracker-root"
+      style={{ display: 'flex', flexDirection: 'column', gap: 8 }}
+    >
       {children}
     </div>
   );

src/components/Breakdown/components/Row.tsx

@@ -1,6 +1,11 @@
+import { createColors } from 'bepaint';
 import { Percentile } from '../../../constants/percentiles';
-import { theme } from '../../../stitches.config';
+import {
-import { TREE_TYPE_ICONS, TreeTypeEnum } from '../../Tanks';
+  AccentColor,
+  GrayColor,
+  PALETTES,
+} from '../../../constants/radixColors';
+import { TREE_TYPE_ICONS, TankType, TreeTypeEnum } from '../../Tanks';
 import { RowStat } from './RowStat';
 
 export interface RowStatItem {
@@ -13,22 +18,39 @@ export interface RowStatItem {
 
 interface RowProps {
   type?: 'tank' | 'summary';
+  naked?: boolean;
   title: string;
   minimized?: boolean;
   treeType?: TreeTypeEnum;
-  tankType?: string;
+  tankType?: TankType;
-
+  color?: AccentColor | GrayColor;
   stats: (RowStatItem | undefined)[];
 }
 
-export function Row(props: RowProps) {
+export function Row({
+  color = 'slate',
+  stats,
+  title,
+  minimized,
+  tankType,
+  treeType,
+  naked = false,
+  type,
+}: RowProps) {
+  const palette = PALETTES[`${color}Dark`];
+  const theme = createColors(palette);
+
   return (
     <div
+      className="session-tracker-row"
       style={{
+        maxWidth: naked ? 600 : undefined,
         display: 'flex',
         flexDirection: 'column',
         borderRadius: 4,
-        backgroundColor: theme.colors.appBackground2,
+        backgroundColor: naked
+          ? `${theme.appBackground2}c0`
+          : theme.appBackground2,
         overflow: 'hidden',
       }}
     >
@@ -39,16 +61,14 @@ export function Row(props: RowProps) {
           justifyContent: 'center',
           padding: 8,
           gap: 4,
-          backgroundColor: theme.colors.componentInteractive,
+          backgroundColor: naked
+            ? `${theme.componentInteractive}c0`
+            : theme.componentInteractive,
         }}
       >
-        {props.type === 'tank' && props.tankType !== undefined && (
+        {type === 'tank' && tankType !== undefined && (
           <img
-            src={
+            src={TREE_TYPE_ICONS[treeType ?? TreeTypeEnum.TechTree][tankType]}
-              TREE_TYPE_ICONS[props.treeType ?? TreeTypeEnum.TechTree][
-                props.tankType
-              ]
-            }
             style={{ width: 16, height: 16 }}
           />
         )}
@@ -56,18 +76,18 @@ export function Row(props: RowProps) {
         <span
           style={{
             color:
-              props.type === 'tank'
+              type === 'tank'
-                ? props.treeType === TreeTypeEnum.Collector
+                ? treeType === TreeTypeEnum.Collector
-                  ? theme.colors.textLowContrast_blue
+                  ? theme.textLowContrast_blue
-                  : props.treeType === TreeTypeEnum.Premium
+                  : treeType === TreeTypeEnum.Premium
-                  ? theme.colors.textLowContrast_amber
+                    ? theme.textLowContrast_amber
-                  : theme.colors.textHighContrast
+                    : theme.textHighContrast
-                : theme.colors.textLowContrast,
+                : theme.textLowContrast,
             fontWeight: 900,
             fontSize: 16,
           }}
         >
-          {props.title}
+          {title}
         </span>
       </div>
 
@@ -78,11 +98,11 @@ export function Row(props: RowProps) {
           paddingBottom: 8,
         }}
       >
-        {props.stats.map(
+        {stats.map(
           (row, index) =>
             row && (
               <RowStat
-                minimized={props.minimized}
+                minimized={minimized}
                 key={index}
                 name={`${row.title} • ${row.career ?? '--'}`}
                 value={row.current ?? '--'}

src/components/Breakdown/components/RowStat.tsx

@@ -1,5 +1,10 @@
+import { createColors } from 'bepaint';
 import { Percentile } from '../../../constants/percentiles';
-import { theme } from '../../../stitches.config';
+import {
+  AccentColor,
+  GrayColor,
+  PALETTES,
+} from '../../../constants/radixColors';
 import PercentileIndicator from '../../PercentileIndicator';
 
 export interface RowStatProps {
@@ -8,6 +13,7 @@ export interface RowStatProps {
   delta?: number;
   percentile?: Percentile;
   minimized?: boolean;
+  color?: AccentColor | GrayColor;
 }
 
 export function RowStat({
@@ -16,9 +22,13 @@ export function RowStat({
   delta,
   percentile,
   minimized = false,
+  color = 'slate',
 }: RowStatProps) {
+  const theme = createColors(PALETTES[`${color}Dark`]);
+
   return (
     <div
+      className="session-tracker-row-stat"
       style={{
         display: 'flex',
         flexDirection: 'column',
@@ -52,7 +62,7 @@ export function RowStat({
 
         <span
           style={{
-            color: theme.colors.textHighContrast,
+            color: theme.textHighContrast,
             fontWeight: 'bold',
             fontSize: 16,
             textAlign: 'center',
@@ -65,7 +75,7 @@ export function RowStat({
       {!minimized && (
         <span
           style={{
-            color: theme.colors.textLowContrast,
+            color: theme.textLowContrast,
             textAlign: 'center',
             fontSize: 12,
           }}

src/components/Flag.tsx

@@ -0,0 +1,19 @@
+import { asset } from '../core/blitzkrieg/asset';
+
+interface FlagProps {
+  nation: string;
+}
+
+export function Flag({ nation }: FlagProps) {
+  return (
+    <div
+      style={{
+        width: 22,
+        height: 22,
+        overflow: 'hidden',
+      }}
+    >
+      <img src={asset(`flags/circle/${nation}.webp`)} alt={nation} />
+    </div>
+  );
+}

src/components/Navbar/components/Button.tsx

@@ -1,21 +0,0 @@
-import { ReactNode } from 'react';
-
-interface ButtonProps {
-  children: ReactNode;
-}
-
-export function Button({ children }: ButtonProps) {
-  return (
-    <button
-      style={{
-        padding: 16,
-        border: 'none',
-        cursor: 'pointer',
-        background: 'none',
-        color: 'inherit',
-      }}
-    >
-      {children}
-    </button>
-  );
-}

src/components/Navbar/index.tsx

@@ -1,38 +1,72 @@
+import { DiscordLogoIcon } from '@radix-ui/react-icons';
+import { Flex, Text, Theme } from '@radix-ui/themes';
 import Link from 'next/link';
 import { theme } from '../../stitches.config';
 import { BlitzkriegWormWide } from '../BlitzkriegWormWide';
 
 export default function Navbar() {
   return (
-    <div
+    <Theme radius="none">
-      style={{
+      <div
-        width: '100%',
-        display: 'flex',
-        alignItems: 'center',
-        justifyContent: 'center',
-        color: theme.colors.textHighContrast,
-        backgroundColor: theme.colors.appBackground2,
-        borderBottom: theme.borderStyles.nonInteractive,
-        height: 48, // TODO: remove this when the icons are implemented
-      }}
-    >
-      {/* <Button>
-        <HamburgerMenuIcon />
-      </Button> */}
-      <Link
-        href="/"
         style={{
-          color: 'inherit',
+          position: 'fixed',
-          display: 'flex',
+          top: 0,
-          alignItems: 'center',
+          left: 0,
-          justifyContent: 'center',
+          width: '100%',
+          zIndex: 1,
+          padding: '1rem',
+          background: theme.colors.appBackground1_alpha,
+          borderBottom: theme.borderStyles.nonInteractive,
+          backdropFilter: 'blur(4rem)',
+          boxSizing: 'border-box',
         }}
       >
-        <BlitzkriegWormWide />
+        <Flex justify="center">
-      </Link>
+          <Flex
-      {/* <Button>
+            justify="between"
-        <PersonIcon />
+            align="center"
-      </Button> */}
+            style={{ maxWidth: 800, width: '100%', padding: '0 16px' }}
-    </div>
+          >
+            <Flex justify="center" align="center" gap="2">
+              <Link
+                href="/"
+                style={{
+                  color: 'inherit',
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                }}
+              >
+                <BlitzkriegWormWide />
+              </Link>
+              <Text size="2">❤️</Text>
+              <Text size="2">
+                <Link
+                  href="https://tresabhi.github.io/"
+                  style={{ color: 'inherit', textDecoration: 'none' }}
+                  target="_blank"
+                >
+                  by TrèsAbhi
+                </Link>
+              </Text>
+            </Flex>
+
+            <Flex justify="center" align="center" gap="2">
+              <Link
+                href="https://discord.gg/nDt7AjGJQH"
+                style={{
+                  color: 'inherit',
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                }}
+              >
+                <DiscordLogoIcon />
+              </Link>
+            </Flex>
+          </Flex>
+        </Flex>
+      </div>
+    </Theme>
   );
 }

src/components/PageWrapper.tsx

@@ -3,28 +3,30 @@ import { ComponentProps } from 'react';
 
 interface PageWrapperProps extends ComponentProps<typeof Flex> {
   color?: ComponentProps<typeof Theme>['accentColor'];
+  size?: 'regular' | 'wide';
 }
 
 export default function PageWrapper({
   style,
   color,
+  size = 'regular',
   ...props
 }: PageWrapperProps) {
   return (
     <Theme accentColor={color}>
       <Flex
-        {...props}
         direction="column"
         gap="4"
         style={{
           width: '100%',
-          maxWidth: 800,
+          maxWidth: size === 'regular' ? 800 : 960,
           margin: 'auto',
           padding: 16,
           boxSizing: 'border-box',
 
           ...style,
         }}
+        {...props}
       />
     </Theme>
   );

src/components/PercentileIndicator.tsx

@@ -1,4 +1,5 @@
 import {
+  amber,
   blue,
   green,
   lime,
@@ -8,7 +9,6 @@ import {
   red,
   slate,
   teal,
-  yellow,
 } from '@radix-ui/colors';
 import { Percentile } from '../constants/percentiles';
 
@@ -20,8 +20,8 @@ export const PERCENTILE_COLORS = {
   [Percentile.VeryBad]: slate.slate9,
   [Percentile.Bad]: red.red9,
   [Percentile.BelowAverage]: orange.orange9,
-  [Percentile.Average]: yellow.yellow9,
+  [Percentile.Average]: amber.amber10,
-  [Percentile.AboveAverage]: lime.lime9,
+  [Percentile.AboveAverage]: lime.lime8,
   [Percentile.Good]: green.green9,
   [Percentile.VeryGood]: teal.teal9,
   [Percentile.Great]: blue.blue9,

src/components/Tanks/components/Item.tsx

@@ -2,7 +2,7 @@ import {
   TANK_ICONS,
   TANK_ICONS_COLLECTOR,
   TANK_ICONS_PREMIUM,
-} from '../../../core/blitzstars/tankopedia';
+} from '../../../core/blitzkrieg/definitions/tanks';
 import { theme } from '../../../stitches.config';
 
 export enum TreeTypeEnum {
@@ -11,17 +11,33 @@ export enum TreeTypeEnum {
   Collector,
 }
 
-export type TreeTypeString = 'tech-tree' | 'premium' | 'collector';
+export const TANK_TYPES = [
+  'tank_destroyer',
+  'light',
+  'medium',
+  'heavy',
+] as const;
+
+export const TREE_TYPES = ['researchable', 'premium', 'collector'] as const;
+
+export type TankType = (typeof TANK_TYPES)[number];
+export type TreeTypeString = (typeof TREE_TYPES)[number];
 
 export const TREE_TYPE_NAMES: Record<TreeTypeString, string> = {
-  'tech-tree': 'Tech tree',
+  researchable: 'Tech tree',
   premium: 'Premium',
   collector: 'Collector',
 };
 
+export const TREE_TYPE_IMAGES: Record<TreeTypeString, string> = {
+  researchable: 'https://i.imgur.com/pJxO2XY.png',
+  premium: 'https://i.imgur.com/mZzSwOU.png',
+  collector: 'https://i.imgur.com/7A0RsG5.png',
+};
+
 export interface ItemProps {
   image?: string;
-  tankType?: string;
+  tankType?: TankType;
   name: string;
   treeType: TreeTypeEnum;
 }

src/components/TierWeights.tsx

@@ -1,4 +1,4 @@
-import { Tier } from '../core/blitzstars/tankopedia';
+import { Tier } from '../core/blitzkrieg/definitions/tanks';
 import { theme } from '../stitches.config';
 
 export type TierWeightsRecord = Partial<Record<Tier, number>>;

src/components/TitleBar.tsx

@@ -36,6 +36,8 @@ export default function TitleBar({ name, image, description }: TitleBarProps) {
             style={{
               display: 'flex',
               gap: 4,
+              alignItems: 'center',
+              justifyContent: 'center',
             }}
           >
             <span
@@ -51,9 +53,21 @@ export default function TitleBar({ name, image, description }: TitleBarProps) {
             </span>
           </div>
 
-          <span style={{ color: theme.colors.textLowContrast, fontSize: 16 }}>
+          <div
-            {description}
+            style={{
-          </span>
+              display: 'flex',
+              justifyContent: image ? 'flex-start' : 'center',
+            }}
+          >
+            <span
+              style={{
+                color: theme.colors.textLowContrast,
+                fontSize: 16,
+              }}
+            >
+              {description}
+            </span>
+          </div>
         </div>
       </div>
     </div>

src/constants/radixColors.ts

@@ -0,0 +1,55 @@
+import * as colors from '@radix-ui/colors';
+import { Theme } from '@radix-ui/themes';
+import { ComponentProps } from 'react';
+
+export type AccentColor = Exclude<
+  ComponentProps<typeof Theme>['accentColor'],
+  'gray' | undefined
+>;
+export type AccentColorDark = `${AccentColor}Dark`;
+export type GrayColor = Exclude<
+  ComponentProps<typeof Theme>['grayColor'],
+  'auto' | undefined
+>;
+export type GrayColorDark = `${GrayColor}Dark`;
+
+export const ACCENT_COLORS: AccentColor[] = [
+  'tomato',
+  'red',
+  'ruby',
+  'crimson',
+  'pink',
+  'plum',
+  'purple',
+  'violet',
+  'iris',
+  'indigo',
+  'blue',
+  'cyan',
+  'teal',
+  'jade',
+  'green',
+  'grass',
+  'brown',
+  'orange',
+  'sky',
+  'mint',
+  'lime',
+  'yellow',
+  'amber',
+  'gold',
+  'bronze',
+];
+export const GRAY_COLORS: GrayColor[] = [
+  'gray',
+  'mauve',
+  'slate',
+  'sage',
+  'olive',
+  'sand',
+];
+
+export const PALETTES: Record<
+  AccentColor | AccentColorDark | GrayColor | GrayColorDark,
+  { [key: `${string}${number}`]: string }
+> = colors;

src/constants/tools.ts

@@ -14,12 +14,12 @@ export const TOOLS: Tool[] = [
   {
     id: 'ratings',
     title: 'Ratings',
-    description: 'Current and archived ratings leaderboards',
+    description: 'Ratings gamemode leaderboards',
   },
   {
     id: 'tankopedia',
     title: 'Tankopedia',
-    description: 'Full Blitz tank encyclopedia',
+    description: 'Blitz tank encyclopedia',
     disabled: true,
   },
   {

src/core/blitz/SCPGStream.ts

@@ -0,0 +1,465 @@
+import { times } from 'lodash';
+import { readDVPL } from './readDVPL';
+import { readDVPLFile } from './readDVPLFile';
+
+enum KAType {
+  NONE = 0,
+  BOOLEAN = 1,
+  INT32 = 2,
+  FLOAT = 3,
+  STRING = 4,
+  WIDE_STRING = 5,
+  BYTE_ARRAY = 6,
+  UINT32 = 7,
+  KEYED_ARCHIVE = 8,
+  INT64 = 9,
+  UINT64 = 10,
+  VECTOR2 = 11,
+  VECTOR3 = 12,
+  VECTOR4 = 13,
+  MATRIX2 = 14,
+  MATRIX3 = 15,
+  MATRIX4 = 16,
+  COLOR = 17,
+  FASTNAME = 18,
+  AABBOX3 = 19,
+  FILEPATH = 20,
+  FLOAT64 = 21,
+  INT8 = 22,
+  UINT8 = 23,
+  INT16 = 24,
+  UINT16 = 25,
+  ARRAY = 27,
+  UNCONFIRMED_TRANSFORM = 29,
+}
+
+enum VertexType {
+  VERTEX,
+  NORMAL,
+  COLOR,
+  TEXCOORD0,
+  TEXCOORD1,
+  TEXCOORD2,
+  TEXCOORD3,
+  TANGENT,
+  BINORMAL,
+  HARD_JOINTINDEX,
+  PIVOT4,
+  FLEXIBILITY,
+  ANGLE_SIN_COS,
+  JOINTINDEX,
+  JOINTWEIGHT,
+  CUBETEXCOORD0,
+  CUBETEXCOORD1,
+  CUBETEXCOORD2,
+  CUBETEXCOORD3,
+}
+
+interface PolygonGroupRaw {
+  '##name': 'PolygonGroup';
+  '#id': Buffer;
+  cubeTextureCoordCount: number;
+  indexCount: number;
+  indexFormat: 0 | 1;
+  indices: Buffer;
+  packing: 0 | 1;
+  primitiveCount: number;
+  rhi_primitiveType: 1 | 2 | 10;
+  textureCoordCount: number;
+  vertexCount: number;
+  vertexFormat: number;
+  vertices: Buffer;
+}
+
+const VECTOR_SIZES = [
+  [VertexType.COLOR, VertexType.FLEXIBILITY, VertexType.HARD_JOINTINDEX],
+  [
+    VertexType.TEXCOORD0,
+    VertexType.TEXCOORD1,
+    VertexType.TEXCOORD2,
+    VertexType.TEXCOORD3,
+    VertexType.ANGLE_SIN_COS,
+  ],
+  [
+    VertexType.VERTEX,
+    VertexType.NORMAL,
+    VertexType.TANGENT,
+    VertexType.BINORMAL,
+    VertexType.CUBETEXCOORD0,
+    VertexType.CUBETEXCOORD1,
+    VertexType.CUBETEXCOORD2,
+    VertexType.CUBETEXCOORD3,
+  ],
+  [VertexType.PIVOT4, VertexType.JOINTINDEX, VertexType.JOINTWEIGHT],
+];
+
+export class SCPGStream {
+  public index = 0;
+  constructor(public buffer: Buffer) {}
+
+  skip(size: number) {
+    this.index += size;
+  }
+  back(size: number) {
+    this.skip(-size);
+  }
+  read(size: number) {
+    return this.buffer.subarray(this.index, this.index + size);
+  }
+  consume(size: number) {
+    const subarray = this.read(size);
+    this.skip(size);
+
+    return subarray;
+  }
+
+  readRemaining() {
+    return this.read(Number.POSITIVE_INFINITY);
+  }
+  consumeRemaining() {
+    return this.consume(Number.POSITIVE_INFINITY);
+  }
+
+  consumeByteArray(size: number) {
+    return this.consume(size);
+  }
+
+  consumeAscii(size: number) {
+    return this.consume(size).toString('ascii');
+  }
+
+  consumeInt8() {
+    return this.consume(1).readInt8();
+  }
+  consumeInt16() {
+    return this.consume(2).readInt16LE();
+  }
+  consumeInt32() {
+    return this.consume(4).readInt32LE();
+  }
+  consumeInt64() {
+    return this.consume(8).readBigInt64LE();
+  }
+  consumeUInt8() {
+    return this.consume(1).readUInt8();
+  }
+  consumeUInt16() {
+    return this.consume(2).readUInt16LE();
+  }
+  consumeUInt32() {
+    return this.consume(4).readUInt32LE();
+  }
+  consumeUInt64() {
+    return this.consume(8).readBigUInt64LE();
+  }
+  consumeFloat() {
+    return this.consume(4).readFloatLE();
+  }
+
+  consumeBoolean() {
+    return this.consume(1).readUInt8() === 1;
+  }
+
+  consumeVectorN(size: number) {
+    return times(size, () => this.consumeFloat());
+  }
+  consumeVector2() {
+    return this.consumeVectorN(2);
+  }
+  consumeVector3() {
+    return this.consumeVectorN(3);
+  }
+  consumeVector4() {
+    return this.consumeVectorN(4);
+  }
+
+  consumeMatrixN(size: number) {
+    return times(size, () => this.consumeVectorN(size));
+  }
+  consumeMatrix2() {
+    return this.consumeMatrixN(2);
+  }
+  consumeMatrix3() {
+    return this.consumeMatrixN(3);
+  }
+  consumeMatrix4() {
+    return this.consumeMatrixN(4);
+  }
+
+  consumeSCGHeader() {
+    return {
+      name: this.consumeAscii(4),
+      version: this.consumeUInt32(),
+      nodeCount: this.consumeUInt32(),
+      nodeCount2: this.consumeUInt32(),
+    };
+  }
+  consumeSCG() {
+    const header = this.consumeSCGHeader();
+    const polygonGroupsRaw: PolygonGroupRaw[] = [];
+
+    for (let index = 0; index < header.nodeCount; index++) {
+      const polygonGroupRaw = this.consumeKA() as PolygonGroupRaw;
+      polygonGroupsRaw.push(polygonGroupRaw);
+    }
+
+    const polygonGroups = polygonGroupsRaw.map((polygonGroupRaw) => {
+      const indicesStream = new SCPGStream(polygonGroupRaw.indices);
+      const indices: number[] = [];
+
+      for (let index = 0; index < polygonGroupRaw.indexCount; index++) {
+        indices.push(
+          polygonGroupRaw.indexFormat === 0
+            ? indicesStream.consumeUInt16()
+            : indicesStream.consumeUInt32(),
+        );
+      }
+
+      const verticesStream = new SCPGStream(polygonGroupRaw.vertices);
+      const vertices: Partial<Record<VertexType, number[]>>[] = [];
+      const vertexFormatBuffer = Buffer.alloc(4);
+      vertexFormatBuffer.writeUInt32LE(polygonGroupRaw.vertexFormat, 0);
+      const vertexFormat = [...vertexFormatBuffer]
+        .map((number) => number.toString(2))
+        .join('')
+        .split('')
+        .map((bitString, index) => (bitString === '1' ? index : null))
+        .filter((type) => type !== null) as VertexType[];
+
+      for (let index = 0; index < polygonGroupRaw.vertexCount; index++) {
+        vertexFormat.forEach((type) => {
+          const resolved = VECTOR_SIZES.some((types, size) => {
+            if (types.includes(type)) {
+              if (!(index in vertices)) vertices[index] = {};
+              vertices[index][type] = verticesStream.consumeVectorN(size + 1);
+
+              return true;
+            }
+          });
+
+          if (!resolved) {
+            throw new TypeError(`Unknown vertex type: ${type}`);
+          }
+        });
+      }
+
+      return { vertices, indices };
+    });
+
+    return polygonGroups;
+  }
+
+  consumeSC2Header() {
+    const header = {
+      name: this.consumeAscii(4),
+      version: this.consumeUInt32(),
+      nodeCount: this.consumeUInt32(),
+    };
+    const versionTags = this.consumeKA();
+    const descriptor = this.consumeSC2Descriptor();
+
+    return { header, versionTags, descriptor };
+  }
+  consumeSC2Descriptor() {
+    const size = this.consumeUInt32();
+    const fileType = this.consumeUInt32();
+
+    // other felids that we don't care about for some reason lol
+    this.skip(size - 4);
+
+    return { size, fileType };
+  }
+  consumeSC2() {
+    this.consumeSC2Header();
+    return this.consumeKA();
+  }
+
+  consumeKAValue(
+    type: KAType = this.consumeUInt8(),
+    stringTable?: Record<number, string>,
+  ): unknown {
+    switch (type) {
+      case KAType.NONE:
+        return undefined;
+
+      case KAType.FILEPATH:
+      case KAType.STRING: {
+        if (stringTable) {
+          const id = this.consumeUInt32();
+          return stringTable[id];
+        } else {
+          const length = this.consumeUInt32();
+          return this.consumeAscii(length);
+        }
+      }
+
+      case KAType.BYTE_ARRAY: {
+        const length = this.consumeUInt32();
+        return this.consumeByteArray(length);
+      }
+
+      case KAType.FLOAT:
+        return this.consumeFloat();
+
+      case KAType.ARRAY: {
+        const length = this.consumeUInt32();
+        const value = [];
+
+        for (let index = 0; index < length; index++) {
+          value.push(this.consumeKAValue(undefined, stringTable));
+        }
+
+        return value;
+      }
+
+      case KAType.KEYED_ARCHIVE: {
+        this.skip(4); // UInt32 length of the nested archive in bytes
+
+        return this.consumeKA(stringTable);
+      }
+
+      case KAType.INT8:
+        return this.consumeInt8();
+      case KAType.INT16:
+        return this.consumeInt16();
+      case KAType.INT32:
+        return this.consumeInt32();
+      case KAType.INT64:
+        return this.consumeInt64();
+      case KAType.UINT8:
+        return this.consumeUInt8();
+      case KAType.UINT16:
+        return this.consumeUInt16();
+      case KAType.UINT32:
+        return this.consumeUInt32();
+      case KAType.UINT64:
+        return this.consumeUInt64();
+
+      case KAType.BOOLEAN:
+        return this.consumeBoolean();
+
+      case KAType.VECTOR2:
+        return this.consumeVector2();
+      case KAType.VECTOR3:
+        return this.consumeVector3();
+      case KAType.VECTOR4:
+        return this.consumeVector4();
+
+      case KAType.COLOR:
+        return this.consumeVector4(); // as RGBA
+
+      case KAType.MATRIX2:
+        return this.consumeMatrix2();
+      case KAType.MATRIX3:
+        return this.consumeMatrix3();
+      case KAType.MATRIX4:
+        return this.consumeMatrix4();
+
+      case KAType.AABBOX3: {
+        const minimum = this.consumeVector3();
+        const maximum = this.consumeVector3();
+
+        return { minimum, maximum };
+      }
+
+      case KAType.FASTNAME: {
+        if (!stringTable) throw new Error('No string table provided');
+        const index = this.consumeUInt32();
+        return stringTable[index];
+      }
+
+      case KAType.UNCONFIRMED_TRANSFORM: {
+        const position = this.consumeVector3();
+        const scale = this.consumeVector3();
+        const rotation = this.consumeVector3();
+        const UNCONFIRMED_scalar = this.consumeFloat();
+
+        return {
+          position,
+          scale,
+          rotation,
+          UNCONFIRMED_scalar,
+        };
+      }
+
+      default:
+        throw new TypeError(
+          `Unhandled KA type: ${type} (${KAType[type] ?? 'unknown type'})`,
+        );
+    }
+  }
+  consumeKA(stringTable?: Record<number, string>) {
+    this.skip(2); // "KA"
+    const version = this.consumeUInt16();
+    const pairs: Record<string, any> = {};
+
+    if (version === 0x0001) {
+      const count = this.consumeUInt32();
+
+      for (let index = 0; index < count; index++) {
+        const name = this.consumeKAValue(undefined, stringTable) as string;
+        const value = this.consumeKAValue(undefined, stringTable);
+
+        pairs[name] = value;
+      }
+    } else if (version === 0x0002) {
+      const count = this.consumeUInt32();
+      const strings: string[] = [];
+      const stringTable: Record<number, string> = {};
+
+      for (let index = 0; index < count; index++) {
+        const length = this.consumeUInt16();
+        const string = this.consumeAscii(length);
+
+        strings.push(string);
+      }
+
+      for (let index = 0; index < count; index++) {
+        const id = this.consumeUInt32();
+        stringTable[id] = strings[index];
+      }
+
+      const nodeCount = this.consumeUInt32();
+
+      for (let index = 0; index < nodeCount; index++) {
+        const keyId = this.consumeUInt32();
+        const value = this.consumeKAValue(undefined, stringTable);
+        const key = stringTable[keyId];
+
+        pairs[key] = value;
+      }
+    } else if (version === 0x0102) {
+      if (!stringTable) throw new Error('No string table provided');
+
+      const count = this.consumeUInt32();
+
+      for (let index = 0; index < count; index++) {
+        const keyIndex = this.consumeUInt32();
+        const key = stringTable[keyIndex];
+        const valueType = this.consumeUInt8();
+
+        if (valueType === KAType.STRING) {
+          const valueIndex = this.consumeUInt32();
+          const value = stringTable[valueIndex];
+          pairs[key] = value;
+        } else {
+          const value = this.consumeKAValue(valueType, stringTable);
+          pairs[key] = value;
+        }
+      }
+    } else if (version === 0xff02) {
+      // same as 0x0102 but empty and with no count
+      return {};
+    } else throw new RangeError(`Unhandled KA version: ${version}`);
+
+    return pairs;
+  }
+
+  static fromDVPL(buffer: Buffer) {
+    return new SCPGStream(readDVPL(buffer));
+  }
+
+  static async fromDVPLFile(file: string) {
+    return new SCPGStream(await readDVPLFile(file));
+  }
+}

src/core/blitz/encyclopediaInfo.ts

@@ -1,7 +1,7 @@
 import { WARGAMING_APPLICATION_ID } from '../../constants/wargamingApplicationID';
 import fetchBlitz from './fetchBlitz';
 
-export interface TankopediaInfo {
+export interface EncyclopediaInfo {
   achievement_sections: Record<string, { name: string; order: number }>;
   tanks_updated_at: number;
   languages: Record<string, string>;
@@ -10,6 +10,6 @@ export interface TankopediaInfo {
   game_version: string;
 }
 
-export const tankopediaInfo = fetchBlitz<TankopediaInfo>(
+export const encyclopediaInfo = fetchBlitz<EncyclopediaInfo>(
   `https://api.wotblitz.com/wotb/encyclopedia/info/?application_id=${WARGAMING_APPLICATION_ID}`,
 );

src/core/blitz/getRatingsInfo.ts

@@ -4,7 +4,11 @@ import { context } from '../blitzkrieg/context';
 import { patientFetch } from '../blitzkrieg/patientFetch';
 import regionToRegionSubdomain from './regionToRegionSubdomain';
 
+const ratingsInfoCache: Partial<Record<Region, RatingsInfo>> = {};
+
 export default async function getRatingsInfo(region: Region) {
+  if (ratingsInfoCache[region]) return ratingsInfoCache[region]!;
+
   const response = await patientFetch(
     context === 'website'
       ? `/api/${region}/ratings/current/info`
@@ -14,6 +18,9 @@ export default async function getRatingsInfo(region: Region) {
     undefined,
     { cache: 'no-store' },
   );
+  const data = (await response.json()) as RatingsInfo;
 
-  return (await response.json()) as Promise<RatingsInfo>;
+  ratingsInfoCache[region] = data;
+
+  return data;
 }

src/core/blitz/getTankStats.ts

@@ -10,10 +10,9 @@ export default async function getTankStats(region: Region, id: number) {
   );
 
   if (tankStats[id] === null) {
-    throw new UserError('No tank stats available', {
+    throw new UserError(
-      cause:
+      "# No tank stats available\nThis player doesn't have any stats available. This may not be the player you are looking for.",
-        "This player doesn't have any stats for tanks available. This may not be the player you are looking for.",
+    );
-    });
   }
 
   return tankStats[id];

src/core/blitz/getTreeType.ts

@@ -1,11 +1,11 @@
 import { TreeTypeEnum } from '../../components/Tanks';
-import { tankopedia } from '../blitzstars/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export default async function getTreeType(id: number) {
-  const entry = (await tankopedia)[id];
+  const entry = (await tankDefinitions)[id];
 
-  if (entry?.is_collectible) return TreeTypeEnum.Collector;
+  if (entry.tree_type === 'collector') return TreeTypeEnum.Collector;
-  if (entry?.is_premium) return TreeTypeEnum.Premium;
+  if (entry.tree_type === 'premium') return TreeTypeEnum.Premium;
 
   return TreeTypeEnum.TechTree;
 }

src/core/blitz/isOnGoingRatingsSeason.ts

@@ -0,0 +1,6 @@
+import getRatingsInfo from './getRatingsInfo';
+
+export async function isOnGoingRatingsSeason() {
+  const ratingsInfo = await getRatingsInfo('com');
+  return ratingsInfo.detail === undefined;
+}

src/core/blitz/readBase64DVPL.ts

@@ -0,0 +1,6 @@
+import { readDVPLFile } from './readDVPLFile';
+
+export async function readBase64DVPL(file: string) {
+  const buffer = await readDVPLFile(file);
+  return buffer.toString('base64');
+}

src/core/blitz/readDVPL.ts

@@ -0,0 +1,51 @@
+import { crc32 } from 'crc';
+import { decodeBlock } from 'lz4';
+
+/**
+ * Thanks Maddoxkkm! Modernized heavily.
+ *
+ * https://github.com/Maddoxkkm/dvpl_converter/
+ */
+export function readDVPL(buffer: Buffer) {
+  const footerBuffer = buffer.subarray(buffer.length - 20, buffer.length);
+
+  if (
+    footerBuffer.toString('utf8', 16, 20) !== 'DVPL' ||
+    footerBuffer.length !== 20
+  ) {
+    throw new SyntaxError('Invalid DVPL footer');
+  }
+
+  const footerData = {
+    oSize: footerBuffer.readUInt32LE(0),
+    cSize: footerBuffer.readUInt32LE(4),
+    crc32: footerBuffer.readUInt32LE(8),
+    type: footerBuffer.readUInt32LE(12),
+  };
+  const targetBlock = buffer.subarray(0, buffer.length - 20);
+
+  if (targetBlock.length !== footerData.cSize) {
+    throw new RangeError('DVPL size mismatch');
+  }
+  if (crc32(targetBlock) !== footerData.crc32) {
+    throw new TypeError('DVPL CRC32 mismatch');
+  }
+  if (footerData.type === 0) {
+    if (!(footerData.oSize === footerData.cSize && footerData.type === 0)) {
+      throw new RangeError('DVPL type and size mismatch');
+    }
+
+    return targetBlock;
+  } else if (footerData.type === 1 || footerData.type === 2) {
+    const deDVPLBlock = Buffer.alloc(footerData.oSize);
+    const DecompressedBlockSize = decodeBlock(targetBlock, deDVPLBlock);
+
+    if (DecompressedBlockSize !== footerData.oSize) {
+      throw new RangeError('Decompressed DVPL size mismatch');
+    }
+
+    return deDVPLBlock;
+  } else {
+    throw new SyntaxError('Unknown DVPL format');
+  }
+}

src/core/blitz/readDVPLFile.ts

@@ -0,0 +1,6 @@
+import { readFile } from 'fs/promises';
+import { readDVPL } from './readDVPL';
+
+export async function readDVPLFile(file: string) {
+  return readDVPL(await readFile(file));
+}

src/core/blitz/readStringDVPL.ts

@@ -0,0 +1,6 @@
+import { readDVPLFile } from './readDVPLFile';
+
+export async function readStringDVPL(file: string) {
+  const buffer = await readDVPLFile(file);
+  return buffer.toString();
+}

src/core/blitz/readXMLDVPL.ts

@@ -0,0 +1,9 @@
+import { XMLParser } from 'fast-xml-parser';
+import { readStringDVPL } from './readStringDVPL';
+
+export async function readXMLDVPL<Type>(file: string) {
+  const parser = new XMLParser();
+  const xml = await readStringDVPL(file);
+
+  return parser.parse(xml) as Type;
+}

src/core/blitz/readYAMLDVPL.ts

@@ -0,0 +1,8 @@
+import { parse } from 'yaml';
+import { readStringDVPL } from './readStringDVPL';
+
+export async function readYAMLDVPL<Type>(file: string) {
+  const yaml = await readStringDVPL(file);
+
+  return parse(yaml) as Type;
+}

src/core/blitz/resolveTankId.ts

@@ -1,30 +1,34 @@
 import { go } from 'fuzzysort';
+import markdownEscape from 'markdown-escape';
+import {
+  tankDefinitions,
+  tanksDefinitionsArray,
+} from '../blitzkrieg/definitions/tanks';
 import { UserError } from '../blitzkrieg/userError';
-import { TANKS, tankopedia } from '../blitzstars/tankopedia';
 
 export default async function resolveTankId(tank: string | number) {
   const number = typeof tank === 'string' ? parseInt(tank) : tank;
 
   if (Number.isNaN(number)) {
-    const searchResult = go(`${tank}`, await TANKS, {
+    const searchResult = go(`${tank}`, await tanksDefinitionsArray, {
       keys: ['name'],
       limit: 1,
     });
 
     if (searchResult.length === 0) {
-      throw new UserError('Tank not found', {
+      throw new UserError(
-        cause: `Could not find tank by the name "${tank}".`,
+        `# Tank not found\nCould not find tank by the name "${markdownEscape(`${tank}`)}".`,
-      });
+      );
     } else {
-      return searchResult[0].obj.tank_id;
+      return searchResult[0].obj.id;
     }
   } else {
-    if ((await tankopedia)[number]) {
+    if ((await tankDefinitions)[number]) {
       return number;
     } else {
-      throw new UserError('Tank not found', {
+      throw new UserError(
-        cause: `Could not find tank by the ID "${number}".`,
+        `# Tank not found\nCould not find tank by the ID "${number}". Try typing the name of the tank instead of a number.`,
-      });
+      );
     }
   }
 }

src/core/blitz/resolveTankName.ts

@@ -1,6 +0,0 @@
-import { tankopedia } from '../blitzstars/tankopedia';
-
-export default async function resolveTankName(tankId: number) {
-  const tankopediaName = (await tankopedia)[tankId]?.name;
-  return tankopediaName ? tankopediaName : `Unknown Tank ${tankId}`;
-}

src/core/blitz/toUniqueId.ts

@@ -0,0 +1,5 @@
+import { NATION_IDS } from '../../constants/nations';
+
+export function toUniqueId(nation: string, id: number) {
+  return (id << 8) + (NATION_IDS[nation] << 4) + 1;
+}

src/core/blitzkrieg/asset.ts

@@ -0,0 +1,3 @@
+export function asset(path: string) {
+  return `https://raw.githubusercontent.com/tresabhi/blitzkrieg-assets/main/${path}`;
+}

src/core/blitzkrieg/commitMultipleFiles.ts

@@ -0,0 +1,98 @@
+import { octokit } from './octokit';
+
+const TIME_PER_BLOB = 2 ** 4 * 1000;
+
+export interface FileChange {
+  path: string;
+  content: string;
+  encoding: 'utf-8' | 'base64';
+}
+
+export default async function commitMultipleFiles(
+  owner: string,
+  repo: string,
+  branch: string,
+  message: string,
+  changes: FileChange[],
+  verbose = false,
+) {
+  const latestCommitSha = (
+    await octokit.git.getRef({
+      owner,
+      repo,
+      ref: `heads/${branch}`,
+    })
+  ).data.object.sha;
+  const treeSha = (
+    await octokit.git.getCommit({
+      owner,
+      repo,
+      commit_sha: latestCommitSha,
+    })
+  ).data.tree.sha;
+  const blobs: {
+    sha: string;
+    path: string;
+    mode: '100644';
+    type: 'blob';
+  }[] = [];
+
+  for (const changeIndexString in changes) {
+    const changeIndex = parseInt(changeIndexString);
+    const change = changes[changeIndex];
+    let done = false;
+
+    while (!done) {
+      try {
+        const { sha } = (
+          await octokit.git.createBlob({
+            owner,
+            repo,
+            content: change.content,
+            encoding: change.encoding,
+          })
+        ).data;
+
+        blobs.push({ sha, path: change.path, mode: '100644', type: 'blob' });
+        done = true;
+      } catch (error) {
+        console.warn(
+          `Failed blob ${changeIndex + 1} / ${
+            changes.length
+          }; retrying in ${TIME_PER_BLOB}ms...`,
+        );
+
+        await new Promise((resolve) => setTimeout(resolve, TIME_PER_BLOB));
+      }
+    }
+
+    if (verbose) {
+      console.log(
+        `Created blob ${changeIndex + 1} / ${changes.length} (${(
+          (100 * (changeIndex + 1)) /
+          changes.length
+        ).toFixed(2)}%)`,
+      );
+    }
+  }
+
+  const { data: treeData } = await octokit.git.createTree({
+    owner,
+    repo,
+    base_tree: treeSha,
+    tree: blobs,
+  });
+  const { data: newCommitData } = await octokit.git.createCommit({
+    owner,
+    repo,
+    message,
+    tree: treeData.sha,
+    parents: [latestCommitSha],
+  });
+  await octokit.git.updateRef({
+    owner,
+    repo,
+    ref: `heads/${branch}`,
+    sha: newCommitData.sha,
+  });
+}

src/core/blitzkrieg/definitions/guns.ts

@@ -0,0 +1,18 @@
+import { asset } from '../asset';
+import { Tier } from './tanks';
+
+export interface BlitzkriegGunDefinition {
+  id: number;
+  name: string;
+  tier: Tier;
+  pitch: [number, number];
+  shells: number[];
+}
+
+export type BlitzkriegGunDefinitions = Record<number, BlitzkriegGunDefinition>;
+
+export const gunDefinitions = fetch(asset('definitions/guns.json'), {
+  cache: 'no-cache',
+}).then(
+  async (response) => response.json() as Promise<BlitzkriegGunDefinitions>,
+);

src/core/blitzkrieg/definitions/shells.ts

@@ -0,0 +1,26 @@
+import { asset } from '../asset';
+
+export type ShellType = 'ap' | 'ap_cr' | 'hc' | 'he';
+
+export interface BlitzkriegShellDefinition {
+  id: number;
+  name: string;
+  speed: number;
+  damage: { armor: number; devices: number };
+  caliber: number;
+  normalization: number;
+  ricochet: number;
+  type: ShellType;
+  icon: string;
+}
+
+export type BlitzkriegShellDefinitions = Record<
+  number,
+  BlitzkriegShellDefinition
+>;
+
+export const shellDefinitions = fetch(asset('definitions/shells.json'), {
+  cache: 'no-cache',
+}).then(
+  async (response) => response.json() as Promise<BlitzkriegShellDefinitions>,
+);

src/core/blitzkrieg/definitions/tanks.ts

@@ -0,0 +1,100 @@
+import { deburr } from 'lodash';
+import { TankType, TreeTypeString } from '../../../components/Tanks';
+import { asset } from '../asset';
+
+export interface BlitzkriegTankDefinition {
+  id: number;
+  nation: string;
+  name: string;
+  tree_type: TreeTypeString;
+  tier: Tier;
+  type: TankType;
+  testing?: boolean;
+  turrets: number[];
+}
+export type BlitzkriegTankDefinitions = Record<
+  number,
+  BlitzkriegTankDefinition
+>;
+
+export const tankDefinitions = fetch(asset('definitions/tanks.json'), {
+  cache: 'no-cache',
+}).then(
+  async (response) => response.json() as Promise<BlitzkriegTankDefinitions>,
+);
+
+const entries = new Promise<BlitzkriegTankDefinition[]>(async (resolve) => {
+  resolve(Object.entries(await tankDefinitions).map(([, entry]) => entry));
+});
+export const tanksDefinitionsArray = new Promise<BlitzkriegTankDefinition[]>(
+  async (resolve) => {
+    resolve((await entries).map((entry) => entry));
+  },
+);
+export const tankNames = new Promise<string[]>(async (resolve) => {
+  resolve((await entries).map(({ name }) => name));
+});
+export const tankNamesDiacritics = tankNames.then((tankNames) =>
+  Promise.all(
+    tankNames.map(async (tankName, index) => {
+      const { id } = (await tanksDefinitionsArray)[index];
+      const name = tankName ?? `Unknown Tank ${id}`;
+      const diacriticless = deburr(name);
+
+      return {
+        original: name,
+        diacriticless,
+        combined: `${name}${diacriticless}`,
+        id,
+      };
+    }),
+  ),
+);
+
+export const TANK_ICONS: Record<TankType, string> = {
+  tank_destroyer: 'https://i.imgur.com/BIHSEH0.png',
+  light: 'https://i.imgur.com/CSNha5V.png',
+  medium: 'https://i.imgur.com/wvf3ltm.png',
+  heavy: 'https://i.imgur.com/ECeqlZa.png',
+};
+
+export const TANK_ICONS_PREMIUM: Record<TankType, string> = {
+  tank_destroyer: 'https://i.imgur.com/TCu3EdR.png',
+  light: 'https://i.imgur.com/zdkpTRb.png',
+  medium: 'https://i.imgur.com/3z7eHX6.png',
+  heavy: 'https://i.imgur.com/P3vbmyA.png',
+};
+
+export const TANK_ICONS_COLLECTOR: Record<TankType, string> = {
+  tank_destroyer: 'https://i.imgur.com/WTjeirB.png',
+  light: 'https://i.imgur.com/EwhtKkU.png',
+  medium: 'https://i.imgur.com/u8YDMBh.png',
+  heavy: 'https://i.imgur.com/8xRf3nc.png',
+};
+
+export const TIERS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] as const;
+
+export type Tier = (typeof TIERS)[number];
+
+export const TIER_ROMAN_NUMERALS: Record<Tier, string> = {
+  1: 'I',
+  2: 'II',
+  3: 'III',
+  4: 'IV',
+  5: 'V',
+  6: 'VI',
+  7: 'VII',
+  8: 'VIII',
+  9: 'IX',
+  10: 'X',
+};
+
+export const NATIONS = tanksDefinitionsArray.then((tanks) => {
+  const nationsObject: Record<string, true> = {};
+
+  tanks.forEach(({ nation }) => {
+    nationsObject[nation] = true;
+  });
+
+  return Object.keys(nationsObject);
+});

src/core/blitzkrieg/definitions/turrets.ts

@@ -0,0 +1,21 @@
+import { asset } from '../asset';
+import { Tier } from './tanks';
+
+export interface BlitzkriegTurretDefinition {
+  id: number;
+  name: string;
+  tier: Tier;
+  yaw: [number, number];
+  guns: number[];
+}
+
+export type BlitzkriegTurretDefinitions = Record<
+  number,
+  BlitzkriegTurretDefinition
+>;
+
+export const turretDefinitions = fetch(asset('definitions/turrets.json'), {
+  cache: 'no-cache',
+}).then(
+  async (response) => response.json() as Promise<BlitzkriegTurretDefinitions>,
+);

src/core/blitzkrieg/filtersToDescription.ts

@@ -1,8 +1,11 @@
 import { TREE_TYPE_NAMES } from '../../components/Tanks';
-import resolveTankName from '../blitz/resolveTankName';
+import { encyclopediaInfo } from '../blitz/encyclopediaInfo';
-import { tankopediaInfo } from '../blitz/tankopediaInfo';
-import { TIER_ROMAN_NUMERALS, Tier } from '../blitzstars/tankopedia';
 import { StatFilters } from '../statistics/filterStats';
+import {
+  TIER_ROMAN_NUMERALS,
+  Tier,
+  tankDefinitions,
+} from './definitions/tanks';
 
 export async function filtersToDescription({
   nation,
@@ -11,13 +14,14 @@ export async function filtersToDescription({
   treeType,
   tank,
 }: StatFilters) {
-  const awaitedTankopediaInfo = await tankopediaInfo;
+  const awaitedEncyclopediaInfo = await encyclopediaInfo;
+  const awaitedTankDefinitions = await tankDefinitions;
   const info: string[] = [];
 
-  if (tank) return await resolveTankName(tank);
+  if (tank) return awaitedTankDefinitions[tank].name;
-  if (nation) info.push(awaitedTankopediaInfo.vehicle_nations[nation]);
+  if (nation) info.push(awaitedEncyclopediaInfo.vehicle_nations[nation]);
   if (tier) info.push(`Tier ${TIER_ROMAN_NUMERALS[tier as Tier]}`);
-  if (tankType) info.push(awaitedTankopediaInfo.vehicle_types[tankType]);
+  if (tankType) info.push(awaitedEncyclopediaInfo.vehicle_types[tankType]);
   if (treeType) info.push(TREE_TYPE_NAMES[treeType]);
 
   return info.length === 0 ? 'No filters' : info.join(', ');