performance table rewrite and shared sort direction

This commit is contained in:
tresabhi committed 2026-11-17 22:01:46 -06:00
1 parent 966651284d
commit 0578f47914
38 files changed
+965 -874

No files matched your search

@@ -1,41 +0,0 @@
import { Table } from "@radix-ui/themes";
import type { CellProps } from "@radix-ui/themes/components/table";
export enum CompareCellDirection {
HIGHER_IS_BETTER,
LOWER_IS_BETTER,
}
interface CompareCellProps extends CellProps {
value: number;
truth: number;
direction?: CompareCellDirection;
}
export function CompareCell({
value,
truth,
style,
direction = CompareCellDirection.HIGHER_IS_BETTER,
...props
}: CompareCellProps) {
const percentage = value / truth - 1;
const shiftedPercentage = Math.round(
Math.min(100, Math.abs(percentage) * 2 * 100 + 25)
);
return (
<Table.Cell
style={{
backgroundColor:
value === truth
? undefined
: (direction === CompareCellDirection.HIGHER_IS_BETTER) ===
value > truth
? `color-mix(in srgb, var(--green-7) ${shiftedPercentage}%, var(--green-3))`
: `color-mix(in srgb, var(--red-7) ${shiftedPercentage}%, var(--red-3))`,
}}
{...props}
/>
);
}
@@ -1,8 +1,3 @@
.logo {
margin: auto;
color: var(--gray-a5);
}
.label {
display: flex;
align-items: center;
@@ -10,18 +10,16 @@ import { characteristicsGroups } from "../../config/characteristicsGroups";
import { computeCharacteristics } from "../../hooks/useCharacteristics";
import { useStrings } from "../../hooks/useStrings";
import { useUnwrapper } from "../../hooks/useUnwrapper";
import { Logo } from "../../icons/Logo";
import {
CompareEphemeral,
syncShellSlot,
type CompareMember,
} from "../../stores/compareEphemeral";
import { ComparePersistent } from "../../stores/comparePersistent";
import { TankopediaSortDirection } from "../../stores/tankopediaPersistent";
import { SortDirection } from "../../stores/tankopediaPersistent";
import { rankingValue } from "../../tankopedia/calculateRankings";
import { resolveTankModules } from "../../tankopedia/resolveTankModules";
import {
CharacteristicRanking,
type CharacteristicName,
type CharacteristicRenderConfig,
type ComputedCharacteristics,
@@ -79,10 +77,9 @@ export function CompareTable() {
<Table.Root scrollable>
<Table.Head>
<Table.Row>
<Table.Corner>
<Logo className={styles.logo} width={64} height={64} />
<Table.IconCorner>
<CompareInsertionMarker index={0} />
</Table.Corner>
</Table.IconCorner>
{members.map(({ key, state }, index) => (
<CompareTankCard
@@ -255,14 +252,12 @@ function Row({ config, characteristics }: RowProps) {
onClick={() => sort(config.name, values, members)}
>
{!isSorted && <CaretSortIcon className={styles.sort} />}
{isSorted &&
sorting.direction === TankopediaSortDirection.Ascending && (
<CaretRightIcon />
)}
{isSorted &&
sorting.direction === TankopediaSortDirection.Descending && (
<CaretLeftIcon />
)}
{isSorted && sorting.direction === SortDirection.Ascending && (
<CaretRightIcon />
)}
{isSorted && sorting.direction === SortDirection.Descending && (
<CaretLeftIcon />
)}
</IconButton>
<Text>{label}</Text>
@@ -282,10 +277,12 @@ function Row({ config, characteristics }: RowProps) {
value !== undefined && truth !== undefined ? value - truth : 0;
return (
<Table.Cell
<Table.CellRanked
key={members[index].key}
align="end"
style={{ backgroundColor: cellColor(config, value, truth) }}
ranking={config.ranking}
value={value}
truth={truth}
>
<div className={styles.value}>
{output && (
@@ -314,7 +311,7 @@ function Row({ config, characteristics }: RowProps) {
</>
)}
</div>
</Table.Cell>
</Table.CellRanked>
);
})}
</Table.Row>
@@ -331,7 +328,7 @@ function sort(
CompareEphemeral.mutate((draft) => {
const ascending =
draft.sorting?.by === name &&
draft.sorting.direction === TankopediaSortDirection.Descending;
draft.sorting.direction === SortDirection.Descending;
// Missing values always sink to the end
draft.members.sort((a, b) => {
@@ -347,34 +344,7 @@ function sort(
draft.sorting = {
by: name,
direction: ascending
? TankopediaSortDirection.Ascending
: TankopediaSortDirection.Descending,
direction: ascending ? SortDirection.Ascending : SortDirection.Descending,
};
});
}
function cellColor(
config: CharacteristicRenderConfig,
value: number | undefined,
truth: number | undefined,
) {
if (
config.ranking === CharacteristicRanking.None ||
value === undefined ||
truth === undefined ||
value === truth ||
!Number.isFinite(value) ||
!Number.isFinite(truth)
) {
return undefined;
}
const higherIsBetter = config.ranking !== CharacteristicRanking.LowerIsBetter;
const better = higherIsBetter === value > truth;
const change = truth === 0 ? 1 : Math.abs(value / truth - 1);
const intensity = Math.round(Math.min(100, change * 2 * 100 + 25));
const color = better ? "jade" : "red";
return `color-mix(in srgb, var(--${color}-7) ${intensity}%, var(--${color}-3))`;
}
@@ -1,12 +1,11 @@
import { times } from "lodash-es";
import { useEffect, useRef, useState, type ReactNode } from "react";
import { useCallback, useEffect, useState, type ReactNode } from "react";
import type { MaybeSkeletonComponentProps } from "../types/maybeSkeletonComponentProps";
export interface IncrementalLoaderProps<Props extends { key: string }> {
initial: number;
intermediate: number;
rate?: number;
skeleton?: boolean;
data: Props[];
Component: (
@@ -25,6 +24,9 @@ export function IncrementalLoader<Props extends { key: string }>({
const [count, setCount] = useState(initial);
const sliced = data.slice(0, count);
// Stable so memoized skeletons skip re-rendering whenever more load in
const loadMore = useCallback(() => setCount((state) => state + rate), [rate]);
useEffect(() => setCount(initial), [data, initial]);
return (
@@ -37,48 +39,9 @@ export function IncrementalLoader<Props extends { key: string }>({
? initial + intermediate
: Math.min(intermediate, data.length - count),
(index) => (
<Item key={index} rate={rate} setCount={setCount}>
<Component skeleton />
</Item>
<Component key={index} skeleton onIntersection={loadMore} />
),
)}
</>
);
}
interface ItemProps {
children: ReactNode;
rate: number;
setCount: (setter: (state: number) => number) => void;
}
function Item({ setCount, rate, children }: ItemProps) {
const wrapper = useRef<HTMLDivElement>(null);
const observer = useRef<IntersectionObserver | null>(null);
useEffect(() => {
function dispose() {
observer.current?.disconnect();
observer.current = null;
}
if (!wrapper.current) return;
if (observer.current === null) {
observer.current = new IntersectionObserver(([entry]) => {
if (!entry.isIntersecting) return;
setCount((state) => state + rate);
});
observer.current.observe(wrapper.current);
}
return dispose;
}, []);
return (
<div ref={wrapper} className="incremental-loader">
{children}
</div>
);
}
@@ -1,68 +0,0 @@
import {
CaretDownIcon,
CaretSortIcon,
CaretUpIcon,
} from "@radix-ui/react-icons";
import { Button, Flex, Table } from "@radix-ui/themes";
import { useLocale } from "../../hooks/useLocale";
import { TankPerformanceSort } from "../../stores/tankPerformanceSort";
import { TankPerformanceSortTypeNamesArray } from "../../stores/tankPerformanceSort/constants";
import { StickyColumnHeaderCell } from "../StickyColumnHeaderCell";
export function Header() {
const sort = TankPerformanceSort.use();
const { strings } = useLocale();
return (
<Table.Header>
<Table.Row align="center">
<StickyColumnHeaderCell>
{strings.website.tools.performance.table.tanks.header}
</StickyColumnHeaderCell>
{TankPerformanceSortTypeNamesArray.map((type) => {
const isSelected = sort.type === type;
return (
<StickyColumnHeaderCell
px="2"
key={type}
width="0"
justify="center"
>
<Flex align="center" gap="1">
<Button
variant="ghost"
color={isSelected ? undefined : "gray"}
highContrast={!isSelected}
onClick={() => {
if (isSelected) {
TankPerformanceSort.mutate((draft) => {
draft.direction *= -1;
});
} else {
TankPerformanceSort.mutate((draft) => {
draft.type = type;
draft.direction = -1;
});
}
}}
>
{strings.website.tools.performance.table.stats[type]}
{!isSelected && <CaretSortIcon />}
{isSelected && (
<>
{sort.direction === 1 && <CaretUpIcon />}
{sort.direction === -1 && <CaretDownIcon />}
</>
)}
</Button>
</Flex>
</StickyColumnHeaderCell>
);
})}
</Table.Row>
</Table.Header>
);
}
@@ -1,51 +0,0 @@
import { formatCompact } from "@blitzkit/core";
import { literals } from "@blitzkit/i18n/src/literals";
import { InfoCircledIcon } from "@radix-ui/react-icons";
import { Callout, Flex } from "@radix-ui/themes";
import { awaitableAverageDefinitions } from "../../core/awaitables/averageDefinitions";
import { awaitableDiscoveredIdsDefinitions } from "../../core/awaitables/discoveredIdsDefinitions";
import { useLocale } from "../../hooks/useLocale";
import type { MaybeSkeletonComponentProps } from "../../types/maybeSkeletonComponentProps";
import { InlineSkeleton } from "../InlineSkeleton";
const [discoveredIdsDefinitions, averageDefinitions] = await Promise.all([
awaitableDiscoveredIdsDefinitions,
awaitableAverageDefinitions,
]);
export function PerformanceInfo({ skeleton }: MaybeSkeletonComponentProps) {
const { strings, locale } = useLocale();
const samples = formatCompact(
locale,
Math.round(discoveredIdsDefinitions.count)
);
const minutesAgo = Math.floor(
(Date.now() - averageDefinitions.time) / (1000 * 60)
);
const hoursAgo = Math.floor(minutesAgo / 60);
const timeAgo = literals(
strings.website.tools.performance.estimation[
hoursAgo === 0 ? "minutes" : "hours"
],
{ count: hoursAgo === 0 ? minutesAgo : hoursAgo }
);
return (
<Flex justify="center">
<Callout.Root style={{ width: "fit-content" }}>
<Callout.Icon>
<InfoCircledIcon />
</Callout.Icon>
<Callout.Text>
{skeleton && <InlineSkeleton width="9rem" />}
{!skeleton &&
literals(strings.website.tools.performance.estimation.body, {
count: samples,
age: timeAgo,
})}
</Callout.Text>
</Callout.Root>
</Flex>
);
}
@@ -1,47 +0,0 @@
import { Flex, Select, Text } from '@radix-ui/themes';
import { useLocale } from '../../hooks/useLocale';
import { Performance, type PlayerCountPeriod } from '../../stores/performance';
export function PlayerCountControl() {
const playerCountPeriod = Performance.use((state) => state.playerCountPeriod);
const { strings } = useLocale();
return (
<Flex justify="center" align="center" gap="2">
<Text>{strings.website.tools.performance.player_count.label}</Text>
<Select.Root
value={playerCountPeriod}
onValueChange={(period) => {
Performance.mutate((draft) => {
draft.playerCountPeriod = period as PlayerCountPeriod;
});
}}
>
<Select.Trigger variant="classic" />
<Select.Content>
<Select.Item value="total">
{strings.common.player_count_period.total}
</Select.Item>
<Select.Item value="d_120">
{strings.common.player_count_period.d_120}
</Select.Item>
<Select.Item value="d_90">
{strings.common.player_count_period.d_90}
</Select.Item>
<Select.Item value="d_60">
{strings.common.player_count_period.d_60}
</Select.Item>
<Select.Item value="d_30">
{strings.common.player_count_period.d_30}
</Select.Item>
<Select.Item value="d_7">
{strings.common.player_count_period.d_7}
</Select.Item>
<Select.Item value="d_1">
{strings.common.player_count_period.d_1}
</Select.Item>
</Select.Content>
</Select.Root>
</Flex>
);
}
@@ -1,31 +0,0 @@
import { Skeleton, Table } from "@radix-ui/themes";
import { times } from "lodash-es";
import { memo, useRef } from "react";
import { useIntersection } from "../../hooks/useIntersection";
import { TankPerformanceSortTypeNamesArray } from "../../stores/tankPerformanceSort/constants";
interface RowLoaderProps {
onIntersection?: () => void;
}
export const RowLoader = memo<RowLoaderProps>(({ onIntersection }) => {
const row = useRef<HTMLTableRowElement>(null!);
useIntersection(() => onIntersection?.(), row, {
disabled: onIntersection === undefined,
});
return (
<Table.Row ref={row}>
<Table.RowHeaderCell align="center">
<Skeleton height="100%" width="128px" />
</Table.RowHeaderCell>
{times(TankPerformanceSortTypeNamesArray.length, (index) => (
<Table.Cell key={index} align="center">
<Skeleton height="1em" width="32px" />
</Table.Cell>
))}
</Table.Row>
);
});
@@ -1,27 +0,0 @@
import { Flex } from "@radix-ui/themes";
import type { MaybeSkeletonComponentProps } from "../../types/maybeSkeletonComponentProps";
import { StickyTableRoot } from "../StickyTableRoot";
import { Header } from "./Header";
import { Tanks } from "./Tanks";
export function TankTable({ skeleton }: MaybeSkeletonComponentProps) {
return (
<Flex justify="center" maxWidth="100%" flexGrow="1" position="relative">
<StickyTableRoot
size={{ initial: "1", sm: "2" }}
variant="surface"
style={{
position: "absolute",
maxWidth: "100%",
maxHeight: "100%",
height: "100%",
borderBottomRightRadius: 0,
borderBottomLeftRadius: 0,
}}
>
<Header />
<Tanks skeleton={skeleton} />
</StickyTableRoot>
</Flex>
);
}
@@ -1,138 +0,0 @@
import { formatCompact } from "@blitzkit/core";
import { TankDefinition } from "@blitzkit/protos";
import { Table } from "@radix-ui/themes";
import { memo } from "react";
import { awaitableAverageDefinitions } from "../../core/awaitables/averageDefinitions";
import { useAveragesExclusionRatio } from "../../hooks/useAveragesExclusionRatio";
import { useLocale } from "../../hooks/useLocale";
import { Performance } from "../../stores/performance";
import { CompareCell, CompareCellDirection } from "../CompareCell";
import { TankRowHeaderCell } from "../TankRowHeaderCell";
interface TankRowProps {
tank: TankDefinition;
average: Record<string, number>;
}
const averageDefinitions = await awaitableAverageDefinitions;
export const TankRow = memo<TankRowProps>(
({ tank, average }) => {
const averages = averageDefinitions.averages[tank.id];
const ratio = useAveragesExclusionRatio();
const playerCountPeriod = Performance.use(
(state) => state.playerCountPeriod,
);
const { locale } = useLocale();
return (
<Table.Row>
<TankRowHeaderCell tank={tank} />
<CompareCell
value={averages.mu!.wins / averages.mu!.battles}
truth={average.winrate}
align="center"
>
{((averages.mu!.wins / averages.mu!.battles) * 100).toFixed(1)}%
</CompareCell>
<Table.Cell align="center">
{formatCompact(
locale,
Math.round(ratio * averages.samples![playerCountPeriod]),
)}
</Table.Cell>
<CompareCell
value={averages.mu!.damage_dealt / averages.mu!.battles}
truth={average.damage}
align="center"
>
{Math.round(
averages.mu!.damage_dealt / averages.mu!.battles,
).toLocaleString(locale)}
</CompareCell>
<CompareCell
value={averages.mu!.survived_battles / averages.mu!.battles}
truth={average.survival}
align="center"
>
{Math.round(
(averages.mu!.survived_battles / averages.mu!.battles) * 100,
)}
%
</CompareCell>
<CompareCell
value={averages.mu!.xp / averages.mu!.battles}
truth={average.xp}
align="center"
>
{Math.round(averages.mu!.xp / averages.mu!.battles).toLocaleString(
locale,
)}
</CompareCell>
<CompareCell
value={averages.mu!.frags / averages.mu!.battles}
truth={average.kills}
align="center"
>
{(averages.mu!.frags / averages.mu!.battles).toFixed(2)}
</CompareCell>
<CompareCell
value={averages.mu!.spotted / averages.mu!.battles}
truth={average.spots}
align="center"
>
{(averages.mu!.spotted / averages.mu!.battles).toFixed(2)}
</CompareCell>
<CompareCell
value={averages.mu!.hits / averages.mu!.shots}
truth={average.accuracy}
align="center"
>
{Math.round((averages.mu!.hits / averages.mu!.shots) * 100)}%
</CompareCell>
<CompareCell
value={averages.mu!.shots / averages.mu!.battles}
truth={average.shots}
align="center"
>
{(averages.mu!.shots / averages.mu!.battles).toFixed(1)}
</CompareCell>
<CompareCell
value={averages.mu!.hits / averages.mu!.battles}
truth={average.hits}
align="center"
>
{(averages.mu!.hits / averages.mu!.battles).toFixed(1)}
</CompareCell>
<CompareCell
value={averages.mu!.damage_dealt / averages.mu!.damage_received}
truth={average.damageRatio}
align="center"
>
{(averages.mu!.damage_dealt / averages.mu!.damage_received).toFixed(
2,
)}
</CompareCell>
<CompareCell
value={averages.mu!.damage_received / averages.mu!.battles}
truth={average.damageReceived}
direction={CompareCellDirection.LOWER_IS_BETTER}
align="center"
>
{Math.round(
averages.mu!.damage_received / averages.mu!.battles,
).toLocaleString(locale)}
</CompareCell>
<CompareCell
value={averages.mu!.capture_points / averages.mu!.battles}
truth={average.capturePoints}
align="center"
>
{(averages.mu!.capture_points / averages.mu!.battles).toFixed(2)}
</CompareCell>
</Table.Row>
);
},
(prev, next) => prev.tank.id === next.tank.id,
);
@@ -1,269 +0,0 @@
import { formatCompact, type BlitzkitStats } from "@blitzkit/core";
import { Table } from "@radix-ui/themes";
import { times } from "lodash-es";
import {
Fragment,
Suspense,
useCallback,
useEffect,
useMemo,
useState,
} from "react";
import usePromise from "react-promise-suspense";
import { api } from "../../api/dynamic";
import { awaitableAverageDefinitions } from "../../core/awaitables/averageDefinitions";
import { filterTanks } from "../../core/blitzkit/filterTanks";
import { useAveragesExclusionRatio } from "../../hooks/useAveragesExclusionRatio";
import { useLocale } from "../../hooks/useLocale";
import { Performance } from "../../stores/performance";
import { TankFilters } from "../../stores/tankFilters";
import { TankPerformanceSort } from "../../stores/tankPerformanceSort";
import type { MaybeSkeletonComponentProps } from "../../types/maybeSkeletonComponentProps";
import { StickyRowHeaderCell } from "../StickyRowHeaderCell";
import { RowLoader } from "./RowLoader";
import { TankRow } from "./TankRow";
const PREVIEW_COUNT = 10;
const DEFAULT_LOADED_ROWS = 25;
const [tankDefinitions, averageDefinitions] = await Promise.all([
api.tanks(),
awaitableAverageDefinitions,
]);
const tankList = Object.values(tankDefinitions.tanks);
export function Tanks({ skeleton }: MaybeSkeletonComponentProps) {
if (skeleton) {
return (
<Table.Body>
{times(16, (index) => (
<RowLoader key={index} />
))}
</Table.Body>
);
}
const sort = TankPerformanceSort.use();
const filters = TankFilters.use();
const filteredTanks = usePromise(
() =>
filterTanks(filters, tankList).then((tanks) =>
tanks.filter(({ id }) => id in averageDefinitions.averages),
),
// react-promise-suspense has awful type annotations
[filters] as any,
);
const tanksMapped = useMemo(
() =>
filteredTanks.map(({ id }) => ({
id,
...averageDefinitions.averages[id],
})),
[filters],
);
const tanksSorted = useMemo(() => {
const { playerCountPeriod } = Performance.state;
switch (sort.type) {
case "accuracy":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.hits / a.mu!.shots - b.mu!.hits / b.mu!.shots),
);
case "capture_points":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.capture_points / a.mu!.battles -
b.mu!.capture_points / b.mu!.battles),
);
case "damage":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.damage_dealt / a.mu!.battles -
b.mu!.damage_dealt / b.mu!.battles),
);
case "damage_ratio":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.damage_dealt / a.mu!.damage_received -
b.mu!.damage_dealt / b.mu!.damage_received),
);
case "damage_taken":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.damage_received / a.mu!.battles -
b.mu!.damage_received / b.mu!.battles),
);
case "hits":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.hits / a.mu!.battles - b.mu!.hits / b.mu!.battles),
);
case "kills":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.frags / a.mu!.battles - b.mu!.frags / b.mu!.battles),
);
case "shots":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.shots / a.mu!.battles - b.mu!.shots / b.mu!.battles),
);
case "players":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.samples![playerCountPeriod] - b.samples![playerCountPeriod]),
);
case "spots":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.spotted / a.mu!.battles - b.mu!.spotted / b.mu!.battles),
);
case "survival":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.survived_battles / a.mu!.battles -
b.mu!.survived_battles / b.mu!.battles),
);
case "winrate":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.wins / a.mu!.battles - b.mu!.wins / b.mu!.battles),
);
case "xp":
return tanksMapped.sort(
(a, b) =>
sort.direction *
(a.mu!.xp / a.mu!.battles - b.mu!.xp / b.mu!.battles),
);
}
}, [filters, sort]);
const [loadedRows, setLoadedRows] = useState(DEFAULT_LOADED_ROWS);
useEffect(() => {
setLoadedRows(DEFAULT_LOADED_ROWS);
}, [filters, sort]);
const playerCountPeriod = Performance.use((state) => state.playerCountPeriod);
const { strings, locale } = useLocale();
const ratio = useAveragesExclusionRatio();
const sum = useCallback(
(slice: (tank: BlitzkitStats) => number) => {
return tanksSorted.reduce(
(acc, tank) => acc + tank.samples![playerCountPeriod] * slice(tank.mu!),
0,
);
},
[tanksSorted],
);
const battles = sum(({ battles }) => battles);
const winrate = sum(({ wins }) => wins) / battles;
const damage = sum(({ damage_dealt }) => damage_dealt) / battles;
const survival = sum(({ survived_battles }) => survived_battles) / battles;
const xp = sum(({ xp }) => xp) / battles;
const kills = sum(({ frags }) => frags) / battles;
const spots = sum(({ spotted }) => spotted) / battles;
const hits = sum(({ hits }) => hits) / battles;
const shots = sum(({ shots }) => shots) / battles;
const accuracy = hits / shots;
const damageReceived =
sum(({ damage_received }) => damage_received) / battles;
const damageRatio = damage / damageReceived;
const capturePoints = sum(({ capture_points }) => capture_points) / battles;
const average = {
battles,
winrate,
damage,
survival,
xp,
kills,
spots,
hits,
shots,
accuracy,
damageReceived,
damageRatio,
capturePoints,
};
return (
<Table.Body>
<Table.Row>
<StickyRowHeaderCell style={{ overflow: "hidden", display: "flex" }}>
{strings.website.tools.performance.table.tanks.total}
</StickyRowHeaderCell>
<Table.Cell align="center">{(winrate * 100).toFixed(1)}%</Table.Cell>
<Table.Cell align="center">
{formatCompact(
locale,
ratio * averageDefinitions.samples![playerCountPeriod],
)}
</Table.Cell>
<Table.Cell align="center">
{Math.round(damage).toLocaleString(locale)}
</Table.Cell>
<Table.Cell align="center">
{Math.round(survival * 100).toFixed(1)}%
</Table.Cell>
<Table.Cell align="center">
{Math.round(xp).toLocaleString(locale)}
</Table.Cell>
<Table.Cell align="center">{kills.toFixed(2)}</Table.Cell>
<Table.Cell align="center">{spots.toFixed(2)}</Table.Cell>
<Table.Cell align="center">{(accuracy * 100).toFixed(0)}%</Table.Cell>
<Table.Cell align="center">{shots.toFixed(1)}</Table.Cell>
<Table.Cell align="center">{hits.toFixed(1)}</Table.Cell>
<Table.Cell align="center">{damageRatio.toFixed(2)}</Table.Cell>
<Table.Cell align="center">
{Math.round(damageReceived).toLocaleString(locale)}
</Table.Cell>
<Table.Cell align="center">{capturePoints.toFixed(2)}</Table.Cell>
</Table.Row>
{tanksSorted.slice(0, loadedRows).map((averages) => {
const tank = tankDefinitions.tanks[averages.id];
if (tank === undefined) return null;
return (
<Fragment key={tank.id}>
<Suspense fallback={<RowLoader />}>
<TankRow average={average} tank={tank} />
</Suspense>
</Fragment>
);
})}
{times(
Math.min(PREVIEW_COUNT, tanksSorted.length - loadedRows),
(index) => {
return (
<RowLoader
key={index}
onIntersection={() => {
setLoadedRows((state) =>
Math.min(state + 2, tanksSorted.length),
);
}}
/>
);
},
)}
</Table.Body>
);
}
@@ -0,0 +1,12 @@
.controls {
display: flex;
flex-direction: column;
align-items: center;
gap: var(--space-4);
.period {
display: flex;
align-items: center;
gap: var(--space-3);
}
}
@@ -0,0 +1,69 @@
import { CaretDownIcon, DotFilledIcon } from "@radix-ui/react-icons";
import { useStrings } from "../../hooks/useStrings";
import { Performance, type PlayerCountPeriod } from "../../stores/performance";
import { Select } from "../Select";
import { TankSearchFilters } from "../TankSearchFilters";
import { Text } from "../Text";
import styles from "./index.module.css";
const periods: PlayerCountPeriod[] = [
"total",
"d_120",
"d_90",
"d_60",
"d_30",
"d_7",
"d_1",
];
export function PerformanceControls() {
const strings = useStrings();
const playerCountPeriod = Performance.use(
(state) => state.player_count_period,
);
return (
<div className={styles.controls}>
<TankSearchFilters />
<div className={styles.period}>
<Text>{strings.performance.player_count}</Text>
<Select.Root
value={playerCountPeriod}
onValueChange={(value) => {
Performance.mutate((draft) => {
draft.player_count_period = value as PlayerCountPeriod;
});
}}
>
<Select.Trigger>
<Select.Value />
<Select.Icon>
<CaretDownIcon />
</Select.Icon>
</Select.Trigger>
<Select.Portal>
<Select.Content>
<Select.Viewport>
{periods.map((period) => (
<Select.Item key={period} value={period}>
<Select.ItemIndicator>
<DotFilledIcon />
</Select.ItemIndicator>
<Select.ItemText>
{strings.common.player_count_period[period]}
</Select.ItemText>
</Select.Item>
))}
</Select.Viewport>
</Select.Content>
</Select.Portal>
</Select.Root>
</div>
</div>
);
}
@@ -0,0 +1,60 @@
/* Spans the page even when the columns would fit in less */
.root {
--tank-width: 15rem;
width: 100%;
/* Fixed layout keeps stat columns equal. Fixed tables ignore cell minimums, so the table holds 8rem per stat column and scrolls past that */
table {
table-layout: fixed;
width: 100%;
min-width: calc(var(--tank-width) + var(--columns) * 8rem);
}
}
.corner {
box-sizing: border-box;
width: var(--tank-width);
}
.value {
white-space: nowrap;
}
.value-skeleton {
width: 100%;
}
/* Table cells ignore max-width, so the link inside caps the column instead */
.tank {
display: flex;
align-items: center;
gap: var(--space-2);
white-space: nowrap;
.icon {
flex-shrink: 0;
/* Bleeds into the cell's padding so rows stay as tall as their text */
height: calc(1em + 2 * var(--space-3));
margin: calc(-1 * var(--space-3)) 0;
aspect-ratio: 4 / 3;
object-fit: cover;
}
.glyph {
flex-shrink: 0;
width: 1em;
height: 1em;
}
.name {
min-width: 0;
overflow: hidden;
text-overflow: ellipsis;
}
}
.tank-skeleton {
width: 100%;
}
@@ -0,0 +1,391 @@
import { tankIcon } from "@blitzkit/core";
import {
TankType,
type AverageDefinitionsAllStats,
type TankDefinition,
} from "@blitzkit/protos";
import {
memo,
useEffect,
useMemo,
useRef,
useState,
type CSSProperties,
} from "react";
import { api } from "../../api/dynamic";
import {
performanceStatNames,
performanceStats,
type PerformanceEntry,
type PerformanceStatName,
} from "../../config/performanceStats";
import { awaitableAverageDefinitions } from "../../core/awaitables/averageDefinitions";
import { awaitableDiscoveredIdsDefinitions } from "../../core/awaitables/discoveredIdsDefinitions";
import { filterTanks } from "../../core/blitzkit/filterTanks";
import { useLocale } from "../../hooks/useLocale";
import { useStrings } from "../../hooks/useStrings";
import { useUnwrapper } from "../../hooks/useUnwrapper";
import { App } from "../../stores/app";
import { Performance } from "../../stores/performance";
import { TankFilters } from "../../stores/tankFilters";
import { SortDirection } from "../../stores/tankopediaPersistent";
import type { MaybeSkeletonComponentProps } from "../../types/maybeSkeletonComponentProps";
import { ClassIcon } from "../ClassIcon";
import { EmptyState } from "../EmptyState";
import { ExperimentIcon } from "../ExperimentIcon";
import { IncrementalLoader } from "../IncrementalLoader";
import { InlineSkeleton } from "../InlineSkeleton";
import { LinkI18n } from "../LinkI18n";
import { Skeleton } from "../Skeleton";
import { Table } from "../Table";
import { Text } from "../Text";
import styles from "./index.module.css";
const [tankDefinitions, averageDefinitions, discoveredIdsDefinitions] =
await Promise.all([
api.tanks(),
awaitableAverageDefinitions,
awaitableDiscoveredIdsDefinitions,
]);
// Only tanks with statistics can be listed
const tanksWithAverages = Object.values(tankDefinitions.tanks).filter(
({ id }) => id in averageDefinitions.averages,
);
// Samples only cover part of the discovered players, so player counts are scaled up to all of them
const exclusionRatio =
discoveredIdsDefinitions.count / averageDefinitions.samples!.total;
interface PerformanceRow {
tank: TankDefinition;
entry: PerformanceEntry;
values: Record<PerformanceStatName, number>;
}
function computeValues(entry: PerformanceEntry) {
const values = {} as Record<PerformanceStatName, number>;
for (const name of performanceStatNames) {
values[name] = performanceStats[name].value(entry);
}
return values;
}
export function PerformanceTable() {
const strings = useStrings();
const filters = TankFilters.use();
const wargaming = App.use((state) => state.logins.wargaming);
const [filtered, setFiltered] = useState<TankDefinition[] | null>(null);
// Filtering can wait on the player's garage, so the last results stay up until it settles
useEffect(() => {
let cancelled = false;
filterTanks(filters, tanksWithAverages, wargaming?.id).then((tanks) => {
if (!cancelled) setFiltered(tanks);
});
return () => {
cancelled = true;
};
}, [filters, wargaming?.id]);
if (filtered !== null && filtered.length === 0) {
return (
<EmptyState
title={strings.performance.no_tanks.title}
body={strings.performance.no_tanks.body}
/>
);
}
return (
<Table.Root
scrollable
className={styles.root}
style={{ "--columns": performanceStatNames.length } as CSSProperties}
>
<Head />
<Body filtered={filtered} />
</Table.Root>
);
}
function Head() {
return (
<Table.Head>
<Table.Row>
<Table.IconCorner className={styles.corner} />
{performanceStatNames.map((name) => (
<ColumnHeader key={name} name={name} />
))}
</Table.Row>
</Table.Head>
);
}
interface BodyProps {
filtered: TankDefinition[] | null;
}
// Owns sorting and period, so changing them never re-renders the head
function Body({ filtered }: BodyProps) {
const sorting = Performance.use((state) => state.sorting);
const period = Performance.use((state) => state.player_count_period);
const rows = useMemo(() => {
if (filtered === null) return null;
return filtered.map((tank) => {
const average = averageDefinitions.averages[tank.id];
const entry = {
stats: average.mu!,
players: exclusionRatio * average.samples![period],
} satisfies PerformanceEntry;
return {
tank,
entry,
values: computeValues(entry),
} satisfies PerformanceRow;
});
}, [filtered, period]);
// Every tank's stats weighted by how many players it had in the period
const total = useMemo(() => {
if (rows === null) return null;
const stats = {} as AverageDefinitionsAllStats;
let samples = 0;
for (const { tank } of rows) {
const average = averageDefinitions.averages[tank.id];
const weight = average.samples![period];
samples += weight;
for (const key in average.mu!) {
const stat = key as keyof AverageDefinitionsAllStats;
stats[stat] = (stats[stat] ?? 0) + weight * average.mu![stat];
}
}
return computeValues({ stats, players: exclusionRatio * samples });
}, [rows, period]);
const sorted = useMemo(() => {
if (rows === null) return null;
const direction = sorting.direction === SortDirection.Ascending ? 1 : -1;
return [...rows].sort(
(a, b) => direction * (a.values[sorting.by] - b.values[sorting.by]),
);
}, [rows, sorting]);
const data = useMemo(
() =>
(sorted ?? []).map((row) => ({
key: `${row.tank.id}`,
row,
total: total!,
})),
[sorted, total],
);
return (
<Table.Body>
<TotalRow total={total} />
<IncrementalLoader
skeleton={sorted === null}
initial={32}
intermediate={8}
data={data}
Component={Row}
/>
</Table.Body>
);
}
interface TotalRowProps {
total: Record<PerformanceStatName, number> | null;
}
function TotalRow({ total }: TotalRowProps) {
const strings = useStrings();
return (
<Table.Row>
<Table.RowHeader>{strings.performance.total}</Table.RowHeader>
{performanceStatNames.map((name) => (
<Table.Cell key={name}>
{total === null ? (
<Skeleton className={styles["value-skeleton"]} />
) : (
<Value name={name} value={total[name]} />
)}
</Table.Cell>
))}
</Table.Row>
);
}
interface ColumnHeaderProps {
name: PerformanceStatName;
}
function ColumnHeader({ name }: ColumnHeaderProps) {
const strings = useStrings();
const sorting = Performance.use((state) => state.sorting);
return (
<Table.ColumnHeaderSortable
direction={sorting.by === name ? sorting.direction : undefined}
onSort={() => {
Performance.mutate((draft) => {
const ascending =
draft.sorting.by === name &&
draft.sorting.direction === SortDirection.Descending;
draft.sorting = {
by: name,
direction: ascending
? SortDirection.Ascending
: SortDirection.Descending,
};
});
}}
>
{strings.common.stats[name]}
</Table.ColumnHeaderSortable>
);
}
interface ValueProps {
name: PerformanceStatName;
value: number;
}
function Value({ name, value }: ValueProps) {
const locale = useLocale();
return (
<Text className={styles.value}>
{Number.isFinite(value)
? performanceStats[name].format(value, locale)
: "-"}
</Text>
);
}
interface RowProps {
row: PerformanceRow;
total: Record<PerformanceStatName, number>;
}
// Memoized so loading more rows leaves the loaded ones be
const Row = memo((props: MaybeSkeletonComponentProps<RowProps>) => {
if (props.skeleton) {
return <SkeletonRow onIntersection={props.onIntersection} />;
}
const { row, total } = props;
return (
<Table.Row>
<Table.RowHeader>
<TankLink tank={row.tank} />
</Table.RowHeader>
{performanceStatNames.map((name) => (
<Table.CellRanked
key={name}
ranking={performanceStats[name].ranking}
value={row.values[name]}
truth={total[name]}
>
<Value name={name} value={row.values[name]} />
</Table.CellRanked>
))}
</Table.Row>
);
});
interface TankLinkProps {
tank: TankDefinition;
}
function TankLink({ tank }: TankLinkProps) {
const locale = useLocale();
const unwrap = useUnwrapper();
const name = unwrap(tank.name!);
return (
<LinkI18n
locale={locale}
href={`/tanks/${tank.slug}`}
underline="hover"
className={styles.tank}
color={
tank.type === TankType.TANK_TYPE_COLLECTOR
? "blue"
: tank.type === TankType.TANK_TYPE_PREMIUM
? "amber"
: "gray"
}
highContrast={tank.type === TankType.TANK_TYPE_RESEARCHABLE}
>
<img
alt={name}
src={tankIcon(tank.id)}
draggable={false}
className={styles.icon}
/>
<ClassIcon class={tank.class} className={styles.glyph} />
{tank.testing && <ExperimentIcon className={styles.glyph} />}
<span className={styles.name}>{name}</span>
</LinkI18n>
);
}
interface SkeletonRowProps {
onIntersection?: () => void;
}
function SkeletonRow({ onIntersection }: SkeletonRowProps) {
const row = useRef<HTMLTableRowElement>(null);
useEffect(() => {
if (!onIntersection) return;
const observer = new IntersectionObserver(([entry]) => {
if (entry.isIntersecting) onIntersection();
});
observer.observe(row.current!);
return () => observer.disconnect();
}, []);
return (
<Table.Row ref={row}>
<Table.RowHeader>
<InlineSkeleton className={styles["tank-skeleton"]} />
</Table.RowHeader>
{performanceStatNames.map((name) => (
<Table.Cell key={name}>
<InlineSkeleton className={styles["value-skeleton"]} />
</Table.Cell>
))}
</Table.Row>
);
}
@@ -20,7 +20,7 @@
/* Row dividers sit inside the cells, so they take no space. Borders on a row itself don't paint with separate borders, so rows apply them to their cells here */
tbody tr > * {
box-shadow: inset 0 var(--space-0) var(--gray-a4);
box-shadow: inset 0 var(--space-0) var(--gray-5);
}
.column-header {
@@ -32,11 +32,43 @@
padding-bottom: var(--space-4);
background-color: var(--gray-3);
&[data-sortable] {
cursor: pointer;
}
&[data-sorted="true"] {
color: var(--accent-11);
}
}
/* Inline so the cell's alignment still centers it */
.sortable {
display: inline-flex;
align-items: center;
gap: var(--space-2);
}
.corner {
left: 0;
z-index: 2;
z-index: 1;
}
/* Fills the cell inside its padding, so the row's other headers decide the size */
.logo {
--padding: var(--space-3);
--max-height: 4rem;
position: absolute;
top: 50%;
left: var(--padding);
transform: translateY(-50%);
width: calc(100% - var(--padding) * 2);
height: min(var(--max-height), calc(100% - var(--padding) * 2));
color: var(--gray-6);
}
.row-header {
@@ -81,5 +113,21 @@
&[data-align="end"] {
text-align: right;
}
&[data-delta="better"] {
background-color: color-mix(
in srgb,
var(--jade-5) var(--intensity),
var(--jade-1)
);
}
&[data-delta="worse"] {
background-color: color-mix(
in srgb,
var(--red-5) var(--intensity),
var(--red-1)
);
}
}
}
+106 -2
View File
@@ -1,4 +1,17 @@
import { useEffect, useRef, type ComponentProps } from "react";
import {
CaretDownIcon,
CaretSortIcon,
CaretUpIcon,
} from "@radix-ui/react-icons";
import {
useEffect,
useRef,
type ComponentProps,
type CSSProperties,
} from "react";
import { Logo } from "../../icons/Logo";
import { SortDirection } from "../../stores/tankopediaPersistent";
import { CharacteristicRanking } from "../../types/characteristics";
import { classNames } from "../../ui/classNames";
import { Scroller, ScrollerOrientation } from "../Scroller";
import styles from "./index.module.css";
@@ -21,7 +34,7 @@ function Root({ children, className, scrollable, ...props }: RootProps) {
const observer = new ResizeObserver(() => {
table.current!.style.setProperty(
"--head-height",
`${head.offsetHeight}px`
`${head.offsetHeight}px`,
);
});
@@ -78,12 +91,62 @@ function Corner({ className, ...props }: ComponentProps<"th">) {
);
}
function IconCorner({ children, ...props }: ComponentProps<"th">) {
return (
<Corner {...props}>
<Logo className={styles.logo} />
{children}
</Corner>
);
}
function ColumnHeader({ className, ...props }: ComponentProps<"th">) {
return (
<th className={classNames(styles["column-header"], className)} {...props} />
);
}
interface ColumnHeaderSortableProps extends ComponentProps<"th"> {
// Unsorted when undefined
direction: SortDirection | undefined;
onSort: () => void;
}
// The whole header toggles sorting, inheriting the header's font rather than a button's
function ColumnHeaderSortable({
className,
children,
direction,
onSort,
...props
}: ColumnHeaderSortableProps) {
return (
<th
className={classNames(styles["column-header"], className)}
onClick={onSort}
data-sortable
data-sorted={direction !== undefined}
aria-sort={
direction === undefined
? undefined
: direction === SortDirection.Ascending
? "ascending"
: "descending"
}
{...props}
>
{/* The cell stays a table cell, so its content lays out in here instead */}
<span className={styles.sortable}>
{children}
{direction === undefined && <CaretSortIcon />}
{direction === SortDirection.Ascending && <CaretUpIcon />}
{direction === SortDirection.Descending && <CaretDownIcon />}
</span>
</th>
);
}
function RowHeader({ className, ...props }: ComponentProps<"th">) {
return (
<th className={classNames(styles["row-header"], className)} {...props} />
@@ -124,15 +187,56 @@ function Cell({ className, align, ...props }: CellProps) {
);
}
interface CellRankedProps extends CellProps {
ranking: CharacteristicRanking | undefined;
value: number | undefined;
truth: number | undefined;
}
// Tints by how far the value strays from the truth, jade when better and red when worse
function CellRanked({
ranking,
value,
truth,
style,
...props
}: CellRankedProps) {
const isRanked =
ranking !== CharacteristicRanking.None &&
value !== undefined &&
truth !== undefined &&
value !== truth &&
Number.isFinite(value) &&
Number.isFinite(truth);
if (!isRanked) return <Cell style={style} {...props} />;
const higherIsBetter = ranking !== CharacteristicRanking.LowerIsBetter;
const better = higherIsBetter === value > truth;
const change = truth === 0 ? 1 : Math.abs(value / truth - 1);
const intensity = Math.round(Math.min(100, change * 2 * 100 + 25));
return (
<Cell
data-delta={better ? "better" : "worse"}
style={{ "--intensity": `${intensity}%`, ...style } as CSSProperties}
{...props}
/>
);
}
export const Table = {
Root,
Head,
Body,
Row,
Corner,
IconCorner,
ColumnHeader,
ColumnHeaderSortable,
RowHeader,
GroupTitle,
GroupCell,
Cell,
CellRanked,
};
@@ -26,7 +26,7 @@ const tankDefinitions = await api.tanks();
export const TankCard = (props: MaybeSkeletonComponentProps<TankCardProps>) => {
if (props.skeleton) {
return <TankCardSkeleton />;
return <TankCardSkeleton onIntersection={props.onIntersection} />;
}
const unwrap = useUnwrapper();
@@ -1,14 +1,31 @@
import { useEffect, useRef } from "react";
import { InlineSkeleton } from "../InlineSkeleton";
import { Skeleton } from "../Skeleton";
import styles from "./index.module.css";
type TankCardProps = {
compact?: boolean;
onIntersection?: () => void;
};
export const TankCardSkeleton = ({ compact }: TankCardProps) => {
export const TankCardSkeleton = ({ compact, onIntersection }: TankCardProps) => {
const wrapper = useRef<HTMLDivElement>(null);
useEffect(() => {
if (!onIntersection) return;
const observer = new IntersectionObserver(([entry]) => {
if (entry.isIntersecting) onIntersection();
});
observer.observe(wrapper.current!);
return () => observer.disconnect();
}, []);
return (
<div
ref={wrapper}
className={styles.wrapper}
data-compact={compact}
style={{
@@ -1,4 +1,3 @@
import type { Vector2Tuple } from "three";
import { metaSortTank, SEARCH_KEYS } from "@blitzkit/core";
import { literals } from "@blitzkit/i18n/src/literals";
import type { TankDefinition } from "@blitzkit/protos";
@@ -6,6 +5,7 @@ import fuzzysort from "fuzzysort";
import { uniq } from "lodash-es";
import { memo, useMemo } from "react";
import usePromise from "react-promise-suspense";
import type { Vector2Tuple } from "three";
import { api } from "../../api/dynamic";
import { characteristics } from "../../config/characteristics";
import { characteristicRenderConfigs } from "../../config/characteristicsGroups";
@@ -18,8 +18,8 @@ import { useStrings } from "../../hooks/useStrings";
import { App } from "../../stores/app";
import { TankFilters } from "../../stores/tankFilters";
import {
SortDirection,
TankopediaPersistent,
TankopediaSortDirection,
} from "../../stores/tankopediaPersistent";
import { TankSort } from "../../stores/tankopediaSort";
import { sortableCharacteristics } from "../../tankopedia/sortableCharacteristics";
@@ -108,7 +108,7 @@ export const TankSearch = memo<TankSearchProps>(
) {
const byMeta = metaSortTank([...filtered], gameDefinitions);
return tankopediaSort.direction === TankopediaSortDirection.Ascending
return tankopediaSort.direction === SortDirection.Ascending
? byMeta
: byMeta.reverse();
}
@@ -171,7 +171,7 @@ export const TankSearch = memo<TankSearchProps>(
}
const direction =
tankopediaSort.direction === TankopediaSortDirection.Ascending ? 1 : -1;
tankopediaSort.direction === SortDirection.Ascending ? 1 : -1;
return [...filtered].sort((a, b) => {
const aValue = values.get(a.id);
@@ -5,7 +5,7 @@ import {
} from "@radix-ui/react-icons";
import { characteristicsGroups } from "../config/characteristicsGroups";
import { useStrings } from "../hooks/useStrings";
import { TankopediaSortDirection } from "../stores/tankopediaPersistent";
import { SortDirection } from "../stores/tankopediaPersistent";
import { TankSort } from "../stores/tankopediaSort";
import { sortableCharacteristics } from "../tankopedia/sortableCharacteristics";
import type { RenderedCharacteristicName } from "../types/characteristics";
@@ -112,8 +112,8 @@ export function TankSearchSort() {
value={direction}
onValueChange={(value) => {
if (
value !== TankopediaSortDirection.Ascending &&
value !== TankopediaSortDirection.Descending
value !== SortDirection.Ascending &&
value !== SortDirection.Descending
) {
throw new Error(`Unknown tankopedia sort direction: ${value}`);
}
@@ -123,14 +123,14 @@ export function TankSearchSort() {
});
}}
>
<DropdownMenu.RadioItem value={TankopediaSortDirection.Ascending}>
<DropdownMenu.RadioItem value={SortDirection.Ascending}>
<DropdownMenu.ItemIndicator>
<DotFilledIcon />
</DropdownMenu.ItemIndicator>
{strings.website.common.tank_search.sort.direction.ascending}
</DropdownMenu.RadioItem>
<DropdownMenu.RadioItem value={TankopediaSortDirection.Descending}>
<DropdownMenu.RadioItem value={SortDirection.Descending}>
<DropdownMenu.ItemIndicator>
<DotFilledIcon />
</DropdownMenu.ItemIndicator>
@@ -0,0 +1,105 @@
import { formatCompact } from "@blitzkit/core";
import type { AverageDefinitionsAllStats } from "@blitzkit/protos";
import { CharacteristicRanking } from "../types/characteristics";
export interface PerformanceEntry {
stats: AverageDefinitionsAllStats;
players: number;
}
export interface PerformanceStat {
value: (entry: PerformanceEntry) => number;
format: (value: number, locale: string) => string;
ranking: CharacteristicRanking;
}
function perBattle(key: keyof AverageDefinitionsAllStats) {
return ({ stats }: PerformanceEntry) => stats[key] / stats.battles;
}
function percentage(decimals: number) {
return (value: number) => `${(value * 100).toFixed(decimals)}%`;
}
function fixed(decimals: number) {
return (value: number) => value.toFixed(decimals);
}
function integer(value: number, locale: string) {
return Math.round(value).toLocaleString(locale);
}
// TODO: formalize this more like characteristics
export const performanceStats = {
winrate: {
value: perBattle("wins"),
format: percentage(1),
ranking: CharacteristicRanking.HigherIsBetter,
},
players: {
value: ({ players }) => players,
format: (value, locale) => formatCompact(locale, Math.round(value)),
ranking: CharacteristicRanking.None,
},
damage: {
value: perBattle("damage_dealt"),
format: integer,
ranking: CharacteristicRanking.HigherIsBetter,
},
survival: {
value: perBattle("survived_battles"),
format: percentage(0),
ranking: CharacteristicRanking.HigherIsBetter,
},
xp: {
value: perBattle("xp"),
format: integer,
ranking: CharacteristicRanking.HigherIsBetter,
},
kills: {
value: perBattle("frags"),
format: fixed(2),
ranking: CharacteristicRanking.HigherIsBetter,
},
spots: {
value: perBattle("spotted"),
format: fixed(2),
ranking: CharacteristicRanking.HigherIsBetter,
},
accuracy: {
value: ({ stats }) => stats.hits / stats.shots,
format: percentage(0),
ranking: CharacteristicRanking.HigherIsBetter,
},
shots: {
value: perBattle("shots"),
format: fixed(1),
ranking: CharacteristicRanking.HigherIsBetter,
},
hits: {
value: perBattle("hits"),
format: fixed(1),
ranking: CharacteristicRanking.HigherIsBetter,
},
damage_ratio: {
value: ({ stats }) => stats.damage_dealt / stats.damage_received,
format: fixed(2),
ranking: CharacteristicRanking.HigherIsBetter,
},
damage_taken: {
value: perBattle("damage_received"),
format: integer,
ranking: CharacteristicRanking.LowerIsBetter,
},
capture_points: {
value: perBattle("capture_points"),
format: fixed(2),
ranking: CharacteristicRanking.HigherIsBetter,
},
} satisfies Record<string, PerformanceStat>;
export type PerformanceStatName = keyof typeof performanceStats;
export const performanceStatNames = Object.keys(
performanceStats,
) as PerformanceStatName[];
-1
View File
@@ -24,7 +24,6 @@ export const tools: Record<string, Tool> = {
banner_background_position: "bottom",
},
performance: {
disabled: true,
id: "performance",
banner_background_position: "bottom",
},
@@ -1 +1,7 @@
export const awaitableAverageDefinitions = fetchAverage();
import { fetchPB, staticAsset } from "@blitzkit/core";
import { AverageDefinitions } from "@blitzkit/protos";
export const awaitableAverageDefinitions = fetchPB(
staticAsset("averages.pb"),
AverageDefinitions,
);
@@ -1 +1,3 @@
import { fetchDiscoveredIds } from "@blitzkit/core";
export const awaitableDiscoveredIdsDefinitions = fetchDiscoveredIds();
@@ -1,11 +0,0 @@
import { awaitableAverageDefinitions } from "../core/awaitables/averageDefinitions";
import { awaitableDiscoveredIdsDefinitions } from "../core/awaitables/discoveredIdsDefinitions";
const [discoveredIdsDefinitions, averageDefinitions] = await Promise.all([
awaitableDiscoveredIdsDefinitions,
awaitableAverageDefinitions,
]);
export function useAveragesExclusionRatio() {
return discoveredIdsDefinitions.count / averageDefinitions.samples!.total;
}
@@ -1,10 +1,10 @@
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
docImageId,
externalDocImages,
} from "../../../../core/blitzkit/docImages";
import { mixStaticPaths } from "../../../../core/blitzkit/mixStaticPaths";
import { getStaticPaths as _getStaticPaths } from "../../_index";
export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
@@ -20,7 +20,7 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
({
params: { id: docImageId(url) },
props: { url },
}) satisfies GetStaticPathsItem,
} satisfies GetStaticPathsItem),
);
});
@@ -1,19 +0,0 @@
---
import ToolOpenGraph from "../../../../components/ToolOpenGraph.astro";
import { tools } from "../../../../constants/tools";
import BaseLayout from "../../../../layouts/BaseLayout.astro";
import type { getStaticPaths } from "../index.astro";
import { Page } from "./_index";
export { getStaticPaths } from "../index.astro";
const { locale } = Astro.props;
---
<ToolOpenGraph {locale} tool={tools.performance} />
<BaseLayout {locale} noFooter>
<Page client:only="react" {locale}>
<Page skeleton slot="fallback" {locale} />
</Page>
</BaseLayout>
@@ -0,0 +1,28 @@
.page {
/* Fixed to the viewport so the table scrolls, not the page */
height: 100dvh;
display: flex;
flex-direction: column;
align-items: center;
box-sizing: border-box;
.top {
display: flex;
flex-direction: column;
align-items: center;
gap: var(--space-4);
padding: var(--space-4);
}
.table {
flex: 1;
min-height: 0;
align-self: stretch;
overflow: hidden;
display: flex;
justify-content: center;
}
}
@@ -1,30 +1,19 @@
import { PageWrapper } from "../../../../components/PageWrapper";
import { PlayerCountControl } from "../../../../components/Performance/PlayerCountControl";
import { TankTable } from "../../../../components/Performance/Table";
import { TankSearchFilters } from "../../../../components/TankSearchFilters";
import {
LocaleProvider,
type LocaleAcceptorProps,
} from "../../../../hooks/useLocale";
import type { MaybeSkeletonComponentProps } from "../../../../types/maybeSkeletonComponentProps";
import { PerformanceControls } from "../../../../components/PerformanceControls";
import { PerformanceTable } from "../../../../components/PerformanceTable";
import { withErrorWrapper } from "../../../../hocs/withErrorWrapper";
import { withLocale } from "../../../../hocs/withLocale";
import styles from "./_index.module.css";
type PageProps = MaybeSkeletonComponentProps & LocaleAcceptorProps;
export const Page = withLocale(
withErrorWrapper(() => (
<div className={styles.page}>
<div className={styles.top}>
<PerformanceControls />
</div>
export function Page({ skeleton, locale }: PageProps) {
return (
<LocaleProvider locale={locale}>
<Content skeleton={skeleton} />
</LocaleProvider>
);
}
function Content({ skeleton }: MaybeSkeletonComponentProps) {
return (
<PageWrapper pb="0" px="0" color="jade" maxWidth="100%">
<TankSearchFilters />
<PlayerCountControl />
<TankTable skeleton={skeleton} />
</PageWrapper>
);
}
<div className={styles.table}>
<PerformanceTable />
</div>
</div>
)),
);
@@ -0,0 +1,18 @@
---
import ColorScale from "../../../../components/ColorScale.astro";
import BaseLayout from "../../../../layouts/BaseLayout.astro";
import { Page } from "./_index";
export { getStaticPaths } from "../index.astro";
const { locale } = Astro.props;
---
<BaseLayout accent="jade" {locale}>
<ColorScale color="red" />
<ColorScale color="jade" />
<ColorScale color="amber" />
<ColorScale color="blue" />
<Page {locale} client:load />
</BaseLayout>
@@ -2,7 +2,7 @@ import type { TankEnvironment } from "@blitzkit/core";
import { Soapstone } from "soapstone";
import { resolveTankModules } from "../tankopedia/resolveTankModules";
import type { TankState } from "../tankopedia/tankState";
import { TankopediaSortDirection } from "./tankopediaPersistent";
import { SortDirection } from "./tankopediaPersistent";
import type { TankSort } from "./tankopediaSort";
export interface CompareMember {
@@ -24,7 +24,7 @@ export const CompareEphemeral = new Soapstone<
environment,
syncShells: false,
members: [],
sorting: { by: null, direction: TankopediaSortDirection.Descending },
sorting: { by: null, direction: SortDirection.Descending },
}));
// Picks the shell at the same slot on every member, where one exists
+17 -5
View File
@@ -1,12 +1,24 @@
import type { Samples } from "@blitzkit/protos";
import { Soapstone } from "soapstone";
export interface Performance {
playerCountPeriod: PlayerCountPeriod;
}
import type { PerformanceStatName } from "../config/performanceStats";
import { SortDirection } from "./tankopediaPersistent";
export type PlayerCountPeriod = keyof Samples;
export interface PerformanceSort {
by: PerformanceStatName;
direction: SortDirection;
}
export interface Performance {
player_count_period: PlayerCountPeriod;
sorting: PerformanceSort;
}
export const Performance = new Soapstone<Performance>({
playerCountPeriod: "total",
player_count_period: "total",
sorting: {
by: "winrate",
direction: SortDirection.Descending,
},
});
@@ -1,6 +0,0 @@
import en from '@blitzkit/i18n/strings/en.json';
import type { TankPerformanceSortType } from '.';
export const TankPerformanceSortTypeNamesArray = Object.keys(
en.website.tools.performance.table.stats,
) as TankPerformanceSortType[];
@@ -1,15 +0,0 @@
import type en from "@blitzkit/i18n/strings/en.json";
import { Soapstone } from "soapstone";
export type TankPerformanceSortType =
keyof typeof en.website.tools.performance.table.stats;
export interface TankPerformanceSort {
type: TankPerformanceSortType;
direction: -1 | 1;
}
export const TankPerformanceSort = new Soapstone<TankPerformanceSort>({
type: "winrate",
direction: -1,
});
@@ -1,6 +1,6 @@
import { Soapstone } from "soapstone";
export enum TankopediaSortDirection {
export enum SortDirection {
Ascending = "ascending",
Descending = "descending",
}
@@ -1,13 +1,13 @@
import { Soapstone } from "soapstone";
import type { RenderedCharacteristicName } from "../types/characteristics";
import { TankopediaSortDirection } from "./tankopediaPersistent";
import { SortDirection } from "./tankopediaPersistent";
export interface TankSort {
by: RenderedCharacteristicName | null;
direction: TankopediaSortDirection;
direction: SortDirection;
}
export const TankSort = new Soapstone<TankSort>({
by: null,
direction: TankopediaSortDirection.Descending,
direction: SortDirection.Descending,
});