Merge branch '1.16.0' into main

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,11 +6,11 @@ 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,
-  tankopedia,
-} from '../../../core/blitzstars/tankopedia';
+  BlitzkriegTankDefinition,
+  tankDefinitions,
+} 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';
@@ -30,7 +30,7 @@ export default function SessionPage() {
 
         list: {
           stats: IndividualTankStats;
-          tankopedia?: TankopediaEntry;
+          tankDefinitions?: BlitzkriegTankDefinition;
           career: IndividualTankStats;
           currentWN8?: number;
           careerWN8?: number;
@@ -88,7 +88,7 @@ export default function SessionPage() {
           }),
           {},
         );
-        const awaitedTankopedia = await tankopedia;
+        const awaitedTankDefinitions = await tankDefinitions;
         const awaitedTankAverages = await tankAverages;
         const careerWN8 =
           careerRaw[id].reduce(
@@ -119,7 +119,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(
@@ -231,90 +231,95 @@ export default function SessionPage() {
               .sort(
                 (a, b) => b.stats.last_battle_time - a.stats.last_battle_time,
               )
-              .map(({ stats, tankopedia, career, careerWN8, currentWN8 }) => {
-                const rowStats: Record<
-                  CustomColumnDisplay,
-                  Breakdown.RowStatItem | undefined
-                > = {
-                  battles: {
-                    title: 'Battles',
-                    current: stats.all.battles.toLocaleString(),
-                    career: career.all.battles.toLocaleString(),
-                  },
-                  winrate: {
-                    title: 'Winrate',
-                    current: `${(
-                      100 *
-                      (stats.all.wins / stats.all.battles)
-                    ).toFixed(2)}%`,
-                    career: `${(
-                      100 *
-                      (career.all.wins / career.all.battles)
-                    ).toFixed(2)}%`,
-                    delta:
-                      stats.all.wins / stats.all.battles -
-                      career.all.wins / career.all.battles,
-                  },
-                  wn8: {
-                    title: 'WN8',
-                    current:
-                      currentWN8 === undefined
-                        ? undefined
-                        : Math.round(currentWN8).toLocaleString(),
-                    career:
-                      careerWN8 === undefined
-                        ? undefined
-                        : Math.round(careerWN8).toLocaleString(),
-                    percentile:
-                      currentWN8 === undefined
-                        ? undefined
-                        : getWN8Percentile(currentWN8),
-                  },
-                  damage: {
-                    title: 'Damage',
-                    current: Math.round(
-                      stats.all.damage_dealt / stats.all.battles,
-                    ).toLocaleString(),
-                    career: Math.round(
-                      career.all.damage_dealt / career.all.battles,
-                    ).toLocaleString(),
-                    delta:
-                      stats.all.damage_dealt / stats.all.battles -
-                      career.all.damage_dealt / career.all.battles,
-                  },
-                  none: undefined,
-                };
+              .map(
+                ({ stats, tankDefinitions, career, careerWN8, currentWN8 }) => {
+                  const rowStats: Record<
+                    CustomColumnDisplay,
+                    Breakdown.RowStatItem | undefined
+                  > = {
+                    battles: {
+                      title: 'Battles',
+                      current: stats.all.battles.toLocaleString(),
+                      career: career.all.battles.toLocaleString(),
+                    },
+                    winrate: {
+                      title: 'Winrate',
+                      current: `${(
+                        100 *
+                        (stats.all.wins / stats.all.battles)
+                      ).toFixed(2)}%`,
+                      career: `${(
+                        100 *
+                        (career.all.wins / career.all.battles)
+                      ).toFixed(2)}%`,
+                      delta:
+                        stats.all.wins / stats.all.battles -
+                        career.all.wins / career.all.battles,
+                    },
+                    wn8: {
+                      title: 'WN8',
+                      current:
+                        currentWN8 === undefined
+                          ? undefined
+                          : Math.round(currentWN8).toLocaleString(),
+                      career:
+                        careerWN8 === undefined
+                          ? undefined
+                          : Math.round(careerWN8).toLocaleString(),
+                      percentile:
+                        currentWN8 === undefined
+                          ? undefined
+                          : getWN8Percentile(currentWN8),
+                    },
+                    damage: {
+                      title: 'Damage',
+                      current: Math.round(
+                        stats.all.damage_dealt / stats.all.battles,
+                      ).toLocaleString(),
+                      career: Math.round(
+                        career.all.damage_dealt / career.all.battles,
+                      ).toLocaleString(),
+                      delta:
+                        stats.all.damage_dealt / stats.all.battles -
+                        career.all.damage_dealt / career.all.battles,
+                    },
+                    none: undefined,
+                  };
 
-                return (
-                  <Breakdown.Row
-                    color={session.color}
-                    key={stats.tank_id}
-                    minimized={!session.showCareer}
-                    title={tankopedia?.name ?? `Unknown tank ${stats.tank_id}`}
-                    type="tank"
-                    tankType={tankopedia?.type}
-                    treeType={(() => {
-                      if (tankopedia?.is_collectible)
-                        return TreeTypeEnum.Collector;
-                      if (tankopedia?.is_premium) return TreeTypeEnum.Premium;
-                    })()}
-                    stats={session.customColumns.map((customColumn) => {
-                      const rowStat = rowStats[customColumn.display];
+                  return (
+                    <Breakdown.Row
+                      color={session.color}
+                      key={stats.tank_id}
+                      minimized={!session.showCareer}
+                      title={
+                        tankDefinitions?.name ?? `Unknown tank ${stats.tank_id}`
+                      }
+                      type="tank"
+                      tankType={tankDefinitions?.type}
+                      treeType={(() => {
+                        if (tankDefinitions?.tree_type === 'collector')
+                          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 {
-                        ...rowStat,
-                        delta:
-                          customColumn.showDelta &&
-                          rowStat.percentile === undefined
-                            ? rowStat.delta
-                            : undefined,
-                      };
-                    })}
-                  />
-                );
-              })}
+                        return {
+                          ...rowStat,
+                          delta:
+                            customColumn.showDelta &&
+                            rowStat.percentile === undefined
+                              ? rowStat.delta
+                              : 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/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/breakdown.tsx

@@ -8,12 +8,11 @@ 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 addFilterOptions from '../core/discord/addFilterOptions';
 import addUsernameChoices from '../core/discord/addUsernameChoices';
 import autocompleteTanks from '../core/discord/autocompleteTanks';
@@ -44,7 +43,7 @@ async function render(
   { 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}
-            treeType={tankopediaEntry ? await getTreeType(id) : undefined}
-            title={await resolveTankName(id)}
+            tankType={tankDefinition?.type}
+            treeType={tankDefinition ? await getTreeType(id) : undefined}
+            title={awaitedTankDefinitions[id].name}
             stats={[
               {
                 title: 'Battles',

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/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,
-} from '../core/blitzstars/tankopedia';
+  tankDefinitions,
+} 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]!,
-          tank_id: tankData.tank_id,
+          tankDefinitions: (await tankDefinitions)[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) {
-        groupedTanks[tank.tankopedia.nation] = [tank.tankopedia];
-        nations.push(tank.tankopedia.nation);
+      if (groupedTanks[tank.tankDefinitions.nation] === undefined) {
+        groupedTanks[tank.tankDefinitions.nation] = [tank.tankDefinitions];
+        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}
-                            name={await resolveTankName(tank.tank_id)}
+                            key={tank.id}
+                            name={tank.name}
                             tankType={tank.type}
-                            image={tank.images?.normal}
-                            treeType={await getTreeType(tank.tank_id)}
+                            image={tankIcon(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}
-                            name={await resolveTankName(tank.tank_id)}
+                            key={tank.id}
+                            name={tank.name}
                             tankType={tank.type}
-                            image={tank.images?.normal}
-                            treeType={await getTreeType(tank.tank_id)}
+                            image={tankIcon(tank.id)}
+                            treeType={await getTreeType(tank.id)}
                           />
                         )),
                       )}

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/components/Breakdown/components/Row.tsx

@@ -5,7 +5,7 @@ import {
   GrayColor,
   PALETTES,
 } from '../../../constants/radixColors';
-import { TREE_TYPE_ICONS, TreeTypeEnum } from '../../Tanks';
+import { TREE_TYPE_ICONS, TankType, TreeTypeEnum } from '../../Tanks';
 import { RowStat } from './RowStat';
 
 export interface RowStatItem {
@@ -21,7 +21,7 @@ interface RowProps {
   title: string;
   minimized?: boolean;
   treeType?: TreeTypeEnum;
-  tankType?: string;
+  tankType?: TankType;
   color?: AccentColor | GrayColor;
   stats: (RowStatItem | undefined)[];
 }
@@ -72,8 +72,8 @@ export function Row({
                 ? treeType === TreeTypeEnum.Collector
                   ? theme.textLowContrast_blue
                   : treeType === TreeTypeEnum.Premium
-                  ? theme.textLowContrast_amber
-                  : theme.textHighContrast
+                    ? theme.textLowContrast_amber
+                    : theme.textHighContrast
                 : theme.textLowContrast,
             fontWeight: 900,
             fontSize: 16,

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
-      style={{
-        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="/"
+    <Theme radius="none">
+      <div
         style={{
-          color: 'inherit',
-          display: 'flex',
-          alignItems: 'center',
-          justifyContent: 'center',
+          position: 'fixed',
+          top: 0,
+          left: 0,
+          width: '100%',
+          zIndex: 1,
+          padding: '1rem',
+          background: theme.colors.appBackground1_alpha,
+          borderBottom: theme.borderStyles.nonInteractive,
+          backdropFilter: 'blur(4rem)',
+          boxSizing: 'border-box',
         }}
       >
-        <BlitzkriegWormWide />
-      </Link>
-      {/* <Button>
-        <PersonIcon />
-      </Button> */}
-    </div>
+        <Flex justify="center">
+          <Flex
+            justify="between"
+            align="center"
+            style={{ maxWidth: 800, width: '100%', padding: '0 16px' }}
+          >
+            <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/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,34 @@ export enum TreeTypeEnum {
   Collector,
 }
 
-export type TreeTypeString = 'tech-tree' | 'premium' | 'collector';
+export const TANK_TYPES = [
+  'tank_destroyer',
+  'light',
+  'medium',
+  'heavy',
+] as const;
+
+// TODO: remove hyphen for underscore
+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/constants/tools.ts

@@ -14,13 +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',
-    disabled: true,
+    description: 'Blitz tank encyclopedia',
   },
   {
     id: 'inactive',

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/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?.is_premium) return TreeTypeEnum.Premium;
+  if (entry.tree_type === 'collector') return TreeTypeEnum.Collector;
+  if (entry.tree_type === 'premium') return TreeTypeEnum.Premium;
 
   return TreeTypeEnum.TechTree;
 }

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,12 +1,15 @@
 import { go } from 'fuzzysort';
+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,
     });
@@ -16,10 +19,10 @@ export default async function resolveTankId(tank: string | number) {
         cause: `Could not find tank by the name "${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', {

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 { tankopediaInfo } from '../blitz/tankopediaInfo';
-import { TIER_ROMAN_NUMERALS, Tier } from '../blitzstars/tankopedia';
+import { encyclopediaInfo } from '../blitz/encyclopediaInfo';
 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 (nation) info.push(awaitedTankopediaInfo.vehicle_nations[nation]);
+  if (tank) return awaitedTankDefinitions[tank].name;
+  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(', ');

src/core/blitzkrieg/octokit.ts

@@ -1,4 +1,7 @@
+import { throttling } from '@octokit/plugin-throttling';
 import { Octokit } from '@octokit/rest';
 import { secrets } from './secrets';
 
+Octokit.plugin(throttling);
+
 export const octokit = new Octokit({ auth: secrets.GH_TOKEN });

src/core/blitzkrieg/tankIcon.ts

@@ -0,0 +1,5 @@
+import { asset } from './asset';
+
+export function tankIcon(id: number, size: 'big' | 'small' = 'big') {
+  return asset(`icons/${size}/${id}.webp`);
+}

src/core/blitzstars/tankAverages.ts

@@ -1,6 +1,6 @@
 import { AllStats } from '../blitz/getAccountInfo';
 import { context } from '../blitzkrieg/context';
-import { tankopedia } from './tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export interface SpecialStats {
   winrate: number;
@@ -80,7 +80,7 @@ export interface IndividualTankAverage {
   last_update: number;
 }
 
-tankopedia;
+tankDefinitions;
 
 export type TankAverages = Record<number, IndividualTankAverage>;
 

src/core/blitzstars/tankopedia.ts

@@ -1,91 +0,0 @@
-import { deburr } from 'lodash';
-import { context } from '../blitzkrieg/context';
-
-export interface TankopediaEntry {
-  name: string;
-  nation: string;
-  is_premium: boolean;
-  is_collectible: boolean;
-  tier: Tier;
-  cost: { price_credit: number; price_gold: number };
-  images: { preview: string; normal: string };
-  tank_id: number;
-  type: string;
-  description: string;
-}
-export interface Tankopedia {
-  [id: number]: TankopediaEntry | undefined;
-}
-
-export const tankopedia = fetch(
-  context === 'website'
-    ? '/api/tankopedia'
-    : 'https://www.blitzstars.com/bs-tankopedia.json',
-)
-  .then(async (response) => response.json())
-  .then((wrapperTankopedia) =>
-    context === 'server'
-      ? (wrapperTankopedia as { data: Tankopedia }).data
-      : (wrapperTankopedia as Tankopedia),
-  );
-const entries = new Promise<TankopediaEntry[]>(async (resolve) => {
-  resolve(Object.entries(await tankopedia).map(([, entry]) => entry));
-});
-export const TANKS = new Promise<TankopediaEntry[]>(async (resolve) => {
-  resolve((await entries).map((entry) => entry));
-});
-export const TANK_NAMES = new Promise<string[]>(async (resolve) => {
-  resolve((await entries).map(({ name }) => name));
-});
-export const TANK_NAMES_DIACRITICS = TANK_NAMES.then((tankNames) =>
-  Promise.all(
-    tankNames.map(async (tankName, index) => {
-      const id = (await TANKS)[index].tank_id;
-      const name = tankName ?? `Unknown Tank ${id}`;
-      const diacriticless = deburr(name);
-
-      return {
-        original: name,
-        diacriticless,
-        combined: `${name}${diacriticless}`,
-        id,
-      };
-    }),
-  ),
-);
-
-export const TANK_ICONS: Record<string, string> = {
-  'AT-SPG': 'https://i.imgur.com/BIHSEH0.png',
-  lightTank: 'https://i.imgur.com/CSNha5V.png',
-  mediumTank: 'https://i.imgur.com/wvf3ltm.png',
-  heavyTank: 'https://i.imgur.com/ECeqlZa.png',
-};
-
-export const TANK_ICONS_PREMIUM: Record<string, string> = {
-  'AT-SPG': 'https://i.imgur.com/TCu3EdR.png',
-  lightTank: 'https://i.imgur.com/zdkpTRb.png',
-  mediumTank: 'https://i.imgur.com/3z7eHX6.png',
-  heavyTank: 'https://i.imgur.com/P3vbmyA.png',
-};
-
-export const TANK_ICONS_COLLECTOR: Record<string, string> = {
-  'AT-SPG': 'https://i.imgur.com/WTjeirB.png',
-  lightTank: 'https://i.imgur.com/EwhtKkU.png',
-  mediumTank: 'https://i.imgur.com/u8YDMBh.png',
-  heavyTank: 'https://i.imgur.com/8xRf3nc.png',
-};
-
-export type Tier = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
-
-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',
-};

src/core/discord/addFilterOptions.ts

@@ -4,7 +4,7 @@ import {
   SlashCommandSubcommandGroupBuilder,
 } from 'discord.js';
 import { TREE_TYPE_NAMES, TreeTypeString } from '../../components/Tanks';
-import { tankopediaInfo } from '../blitz/tankopediaInfo';
+import { encyclopediaInfo } from '../blitz/encyclopediaInfo';
 import addPeriodSubCommands from './addPeriodSubCommands';
 import addTankChoices from './addTankChoices';
 import addTierChoices from './addTierChoices';
@@ -17,7 +17,7 @@ export default async function addFilterOptions<
     option: SlashCommandSubcommandBuilder,
   ) => SlashCommandSubcommandBuilder = (option) => option,
 ): Promise<OptionType> {
-  const awaitedTankopediaInfo = await tankopediaInfo;
+  const awaitedEncyclopediaInfo = await encyclopediaInfo;
 
   addPeriodSubCommands(option, (option) => {
     extra(option);
@@ -28,7 +28,7 @@ export default async function addFilterOptions<
           .setName('nation')
           .setDescription('Nation')
           .addChoices(
-            ...Object.entries(awaitedTankopediaInfo.vehicle_nations).map(
+            ...Object.entries(awaitedEncyclopediaInfo.vehicle_nations).map(
               ([type, name]) => ({ name, value: type }),
             ),
           )
@@ -40,7 +40,7 @@ export default async function addFilterOptions<
           .setName('tank-type')
           .setDescription('Tank type')
           .addChoices(
-            ...Object.entries(awaitedTankopediaInfo.vehicle_types).map(
+            ...Object.entries(awaitedEncyclopediaInfo.vehicle_types).map(
               ([type, name]) => ({
                 name: name.replace(' Tank', ''),
                 value: type,
@@ -55,8 +55,8 @@ export default async function addFilterOptions<
           .setDescription('Tech tree type')
           .addChoices(
             {
-              name: TREE_TYPE_NAMES['tech-tree'],
-              value: 'tech-tree' satisfies TreeTypeString,
+              name: TREE_TYPE_NAMES['researchable'],
+              value: 'researchable' satisfies TreeTypeString,
             },
             {
               name: TREE_TYPE_NAMES.premium,

src/core/discord/autocompleteTanks.ts

@@ -4,7 +4,7 @@ import {
   CacheType,
 } from 'discord.js';
 import { go } from 'fuzzysort';
-import { TANK_NAMES_DIACRITICS } from '../blitzstars/tankopedia';
+import { tankNamesDiacritics } from '../blitzkrieg/definitions/tanks';
 import {
   DISCORD_CHOICES_MAX_NAME_SIZE,
   OVERFLOW_SUFFIX,
@@ -19,7 +19,7 @@ export default async function autocompleteTanks(
   await interaction.respond(
     focusedOption.value
       ? await Promise.all(
-          go(focusedOption.value, await TANK_NAMES_DIACRITICS, {
+          go(focusedOption.value, await tankNamesDiacritics, {
             keys: ['combined'],
             limit: 10,
           }).map(async (item) => {

src/core/statistics/filterStats.ts

@@ -1,7 +1,7 @@
 import { TreeTypeString } from '../../components/Tanks';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 import { DiffedTankStats } from '../blitzstars/getStatsInPeriod';
 import { tankAverages } from '../blitzstars/tankAverages';
-import { tankopedia } from '../blitzstars/tankopedia';
 import calculateWN8 from './calculateWN8';
 import sumStats from './sumStats';
 
@@ -20,10 +20,10 @@ export async function filterStats(
   // tank, if provided, takes priority over all other filters
   if (filters.tank) filters = { tank: filters.tank };
 
-  const awaitedTankopedia = await tankopedia;
+  const awaitedTankDefinitions = await tankDefinitions;
   const awaitedTankAverages = await tankAverages;
   const filteredOrder = order.filter((id) => {
-    const entry = awaitedTankopedia[id];
+    const entry = awaitedTankDefinitions[id];
 
     return (
       entry &&
@@ -31,14 +31,11 @@ export async function filterStats(
       (filters.tier === undefined || entry.tier === filters.tier) &&
       (filters.tankType === undefined || entry.type === filters.tankType) &&
       (filters.treeType === undefined ||
-        (filters.treeType === 'collector' && entry.is_collectible) ||
-        (filters.treeType === 'premium' &&
-          entry.is_premium &&
-          !entry.is_collectible) ||
-        (filters.treeType === 'tech-tree' &&
-          !entry.is_collectible &&
-          !entry.is_premium)) &&
-      (filters.tank === undefined || entry.tank_id === filters.tank)
+        (filters.treeType === 'collector' && entry.tree_type === 'collector') ||
+        (filters.treeType === 'premium' && entry.tree_type === 'premium') ||
+        (filters.treeType === 'researchable' &&
+          entry.tree_type === 'researchable')) &&
+      (filters.tank === undefined || entry.id === filters.tank)
     );
   });
   const stats = sumStats(filteredOrder.map((id) => diff[id]));
@@ -47,9 +44,9 @@ export async function filterStats(
       awaitedTankAverages[id] ? accumulator + diff[id].battles : accumulator,
     0,
   );
-  const battlesOfTanksWithTankopediaEntry = filteredOrder.reduce<number>(
+  const battlesOfTanksWithTankDefinition = filteredOrder.reduce<number>(
     (accumulator, id) =>
-      awaitedTankopedia[id] ? accumulator + diff[id].battles : accumulator,
+      awaitedTankDefinitions[id] ? accumulator + diff[id].battles : accumulator,
     0,
   );
   const supplementary = {
@@ -66,11 +63,11 @@ export async function filterStats(
     tier:
       filteredOrder.reduce<number>(
         (accumulator, id) =>
-          awaitedTankopedia[id]
-            ? accumulator + awaitedTankopedia[id]!.tier * diff[id].battles
+          awaitedTankDefinitions[id]
+            ? accumulator + awaitedTankDefinitions[id]!.tier * diff[id].battles
             : accumulator,
         0,
-      ) / battlesOfTanksWithTankopediaEntry,
+      ) / battlesOfTanksWithTankDefinition,
   };
 
   return { stats, supplementary, filteredOrder };

src/core/statistics/getTierWeights.ts

@@ -1,16 +1,16 @@
 import { TierWeightsRecord } from '../../components/TierWeights';
 import { AllStats } from '../blitz/getAccountInfo';
-import { tankopedia } from '../blitzstars/tankopedia';
+import { tankDefinitions } from '../blitzkrieg/definitions/tanks';
 
 export async function getTierWeights(
   stats: Record<number, AllStats>,
   order: number[] = Object.keys(stats).map(parseInt),
 ) {
-  const awaitedTankopedia = await tankopedia;
+  const awaitedTankDefinitions = await tankDefinitions;
   const tierWeights: TierWeightsRecord = {};
 
-  order.map((id) => {
-    const entry = awaitedTankopedia[id];
+  order.forEach((id) => {
+    const entry = awaitedTankDefinitions[id];
 
     if (!entry) return;
     if (!tierWeights[entry.tier]) tierWeights[entry.tier] = 0;

src/stitches.config.ts

@@ -4,6 +4,7 @@ import {
   orangeDark,
   slate,
   slateDark,
+  slateDarkA,
   tealDark,
 } from '@radix-ui/colors';
 import { createBorderStyles, createColors, createSpaces } from 'bepaint';
@@ -14,6 +15,7 @@ export const theme = {
 
   colors: {
     ...createColors(slateDark),
+    ...createColors(slateDarkA, 'alpha'),
     ...createColors(slate, 'light'),
 
     ...createColors(amberDark, 'amber'),

src/stores/session.ts

@@ -1,6 +1,6 @@
 import { produce } from 'immer';
 import { create } from 'zustand';
-import { devtools, persist } from 'zustand/middleware';
+import { persist } from 'zustand/middleware';
 import { CustomColumnDisplay } from '../app/tools/session/components/CustomColumn';
 import { AccentColor, GrayColor } from '../constants/radixColors';
 import { Region } from '../constants/regions';
@@ -66,26 +66,24 @@ export function resetSession() {
 }
 
 export const useSession = create<Session>()(
-  devtools(
-    persist(
-      (set) => ({
-        title: 'Untitled session',
-        isTracking: false,
-        resetPrompt: true,
-        showTotal: true,
-        showCareer: true,
-        embedPrompt: true,
+  persist(
+    (set) => ({
+      title: 'Untitled session',
+      isTracking: false,
+      resetPrompt: true,
+      showTotal: true,
+      showCareer: true,
+      embedPrompt: true,
 
-        customColumns: [
-          { display: 'battles', showDelta: false },
-          { display: 'winrate', showDelta: true },
-          { display: 'wn8', showDelta: false },
-          { display: 'damage', showDelta: true },
-        ],
-        color: 'slate',
-      }),
-      { name: 'session' },
-    ),
+      customColumns: [
+        { display: 'battles', showDelta: false },
+        { display: 'winrate', showDelta: true },
+        { display: 'wn8', showDelta: false },
+        { display: 'damage', showDelta: true },
+      ],
+      color: 'slate',
+    }),
+    { name: 'session' },
   ),
 );
 

src/stores/tankopedia.ts

@@ -0,0 +1,40 @@
+import { produce } from 'immer';
+import { create } from 'zustand';
+import { TankType, TreeTypeString } from '../components/Tanks';
+import { Tier } from '../core/blitzkrieg/definitions/tanks';
+
+export type TankopediaSortBy = 'tier' | 'name';
+export type TankopediaSortDirection = 'ascending' | 'descending';
+export type TankopediaTestTankDisplay = 'include' | 'exclude' | 'only';
+
+type Tankopedia = {
+  sort: {
+    by: TankopediaSortBy;
+    direction: TankopediaSortDirection;
+  };
+  filters: {
+    tiers: Tier[];
+    types: TankType[];
+    treeTypes: TreeTypeString[];
+    nations: string[];
+    test: TankopediaTestTankDisplay;
+  };
+};
+
+export const useTankopedia = create<Tankopedia>()(() => ({
+  sort: {
+    by: 'tier',
+    direction: 'descending',
+  },
+  filters: {
+    tiers: [],
+    types: [],
+    treeTypes: [],
+    nations: [],
+    test: 'include',
+  },
+}));
+
+export default function mutateTankopedia(recipe: (draft: Tankopedia) => void) {
+  useTankopedia.setState(produce(recipe));
+}