augment trees, pitch-limit fallback, and cached definitions

This commit is contained in:
tresabhi committed 2026-11-15 17:28:43 -06:00
1 parent da9c5272bc
commit 79129ff3c0
57 files changed
+2196 -717

No files matched your search

+13
View File
@@ -16,12 +16,15 @@ import { fetchPB } from "../../api";
import { fetchJSON } from "../../api/fetchJSON";
import { BlitzScripts } from "../../types/blitzScripts";
import { AbstractBlitzKitAPI } from "./abstract";
import { Cache } from "./server/0_base";
export class ClientBlitzKitAPI extends AbstractBlitzKitAPI {
@Cache()
game() {
return fetchPB(alias("api", "/definitions/game.pb"), GameDefinitions);
}
@Cache()
consumables() {
return fetchPB(
alias("api", "/definitions/consumables.pb"),
@@ -29,10 +32,12 @@ export class ClientBlitzKitAPI extends AbstractBlitzKitAPI {
);
}
@Cache()
tanks() {
return fetchPB(alias("api", "/definitions/tanks.pb"), TankDefinitions);
}
@Cache()
camouflages() {
return fetchPB(
alias("api", "/definitions/camouflage.pb"),
@@ -40,6 +45,7 @@ export class ClientBlitzKitAPI extends AbstractBlitzKitAPI {
);
}
@Cache()
provisions() {
return fetchPB(
alias("api", "/definitions/provisions.pb"),
@@ -47,14 +53,17 @@ export class ClientBlitzKitAPI extends AbstractBlitzKitAPI {
);
}
@Cache()
models() {
return fetchPB(alias("api", "/definitions/models.pb"), ModelDefinitions);
}
@Cache()
skills() {
return fetchPB(alias("api", "/definitions/skills.pb"), SkillDefinitions);
}
@Cache()
equipment() {
return fetchPB(
alias("api", "/definitions/equipment.pb"),
@@ -62,18 +71,22 @@ export class ClientBlitzKitAPI extends AbstractBlitzKitAPI {
);
}
@Cache()
gallery() {
return fetchPB(alias("api", "/definitions/gallery.pb"), Gallery);
}
@Cache()
maps() {
return fetchPB(alias("api", "/definitions/maps.pb"), MapDefinitions);
}
@Cache()
scripts() {
return fetchJSON<BlitzScripts>(alias("api", "/definitions/scripts.json"));
}
@Cache()
strings(locale: string) {
return fetchJSON<Strings>(alias("api", `/strings/${locale}.json`));
}
@@ -13,11 +13,20 @@ import {
toUniqueId,
TurretDefinitionsList,
UnlocksListing,
UpgradeAttributesXml,
UpgradeProgressionXml,
UpgradeProgressionXmlNode,
UpgradeProgressionXmlRequirement,
VehicleDefinitionList,
VehicleDefinitions,
} from "@blitzkit/core";
import {
AssaultRanges,
AugmentAttribute,
AugmentNode,
AugmentNodeType,
AugmentProgression,
AugmentRequirement,
Crew,
Equalizer,
GunDefinition,
@@ -32,6 +41,14 @@ import {
} from "@blitzkit/protos";
import { Cache, ServerBlitzKitAPI0 } from "./0_base";
// What an augment attribute shows, by attribute name
interface AugmentAttributeDefinition {
icon: string;
title: string;
}
type AugmentAttributeDefinitions = Map<string, AugmentAttributeDefinition>;
export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
private parseResearchCost(raw: number | string) {
if (typeof raw === "number") {
@@ -51,6 +68,129 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
}
}
private parseAugmentProgression(
xml: UpgradeProgressionXml,
attributeDefinitions: AugmentAttributeDefinitions,
) {
const iconName = (path?: string) => path?.split("/").at(-1);
const types = {
NODETYPE_COMMON: AugmentNodeType.AUGMENT_NODE_TYPE_COMMON,
NODETYPE_MECHANIC: AugmentNodeType.AUGMENT_NODE_TYPE_MECHANIC,
NODETYPE_ALTERNATIVE_MECHANIC:
AugmentNodeType.AUGMENT_NODE_TYPE_ALTERNATIVE,
} satisfies Record<UpgradeProgressionXmlNode["nodeType"], AugmentNodeType>;
const parseRequirements = (
requiredNodes: UpgradeProgressionXmlNode["requiredNodes"],
) =>
(requiredNodes === undefined || requiredNodes === ""
? []
: requiredNodes.node
).map((requirement: UpgradeProgressionXmlRequirement) =>
typeof requirement === "string"
? ({
tech_name: requirement,
vertical_first: false,
} satisfies AugmentRequirement)
: ({
tech_name: requirement["#text"],
vertical_first: requirement["@_verticalFirst"] === "true",
} satisfies AugmentRequirement),
);
const parseNode = (node: UpgradeProgressionXmlNode) =>
({
id: node.id,
tech_name: node.techName,
type: types[node.nodeType],
xp_cost: node.xpCost ?? 0,
position:
node.gridPosition === undefined
? undefined
: { x: node.gridPosition.column, y: node.gridPosition.row },
requires: parseRequirements(node.requiredNodes),
attributes: (node.attributes?.attribute ?? []).map(
({ attributeName, value }) => {
const definition = attributeDefinitions.get(attributeName);
return {
name: attributeName,
value: typeof value === "boolean" ? Number(value) : value,
icon: iconName(definition?.icon),
title:
definition === undefined
? undefined
: this.getString(definition.title),
} satisfies AugmentAttribute;
},
),
name:
node.displayName === undefined
? undefined
: this.getString(node.displayName),
} satisfies AugmentNode);
const parsedNodes = xml.nodes.node.map(parseNode);
const byTechName = new Map(
parsedNodes.map((node) => [node.tech_name, node]),
);
const groups =
xml.alternativeMechanicGroups?.alternativeMechanicGroup ?? [];
if (groups.length > 1) {
throw new Error(
"Upgrade progression with more than one alternative group",
);
}
const group = groups.at(0);
const alternativeNames = new Set(group?.alternativeNodes.node);
for (const node of parsedNodes) {
if (
node.type === AugmentNodeType.AUGMENT_NODE_TYPE_ALTERNATIVE &&
!alternativeNames.has(node.tech_name)
) {
throw new Error(
`Alternative upgrade ${node.tech_name} belongs to no group`,
);
}
}
return {
rows: xml.matrix.rows,
columns: xml.matrix.columns,
nodes: parsedNodes.filter(
(node) => node.type !== AugmentNodeType.AUGMENT_NODE_TYPE_ALTERNATIVE,
),
group:
group === undefined
? undefined
: {
tech_name: group.techName,
name: this.getString(group.displayName),
description: this.getString(group.description),
icon: iconName(group.icon),
xp_cost: group.xpCost,
position: {
x: group.gridPosition.column,
y: group.gridPosition.row,
},
requires: parseRequirements(group.requiredNodes),
alternatives: group.alternativeNodes.node.map((techName) => {
const node = byTechName.get(techName);
if (node === undefined) {
throw new Error(`Unknown alternative upgrade ${techName}`);
}
return node;
}),
},
} satisfies AugmentProgression;
}
@Cache()
async tanks() {
const tankDefinitions = TankDefinitions.create();
@@ -164,6 +304,23 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
const tankXps = new Map<number, ResearchCost>();
// Only some builds ship augment trees
const upgradeAttributesPath =
"Data/XML/item_defs/vehicles/common/tank_upgrade_attributes.xml";
const upgradeAttributeDefinitions: AugmentAttributeDefinitions = new Map();
if ((await this.vfs.resolve(upgradeAttributesPath)) !== null) {
const upgradeAttributes =
await this.vfs.xmlWithAttributes<UpgradeAttributesXml>(
upgradeAttributesPath,
);
for (const { attributeName, icon, title } of upgradeAttributes.root
.attributes.attribute) {
upgradeAttributeDefinitions.set(attributeName, { icon, title });
}
}
for (const nation of this.nationsDir!) {
const tankList = await this.vfs.xml<{ root: VehicleDefinitionList }>(
`Data/XML/item_defs/vehicles/${nation}/list.xml`,
@@ -429,12 +586,25 @@ export abstract class ServerBlitzKitAPI1 extends ServerBlitzKitAPI0 {
}
}
const augment_progression =
tankDefinition.root.upgradeProgression === undefined
? undefined
: this.parseAugmentProgression(
(
await this.vfs.xmlWithAttributes<{
root: { upgradeProgression: UpgradeProgressionXml };
}>(`Data/XML/item_defs/vehicles/${nation}/${tankKey}.xml`)
).root.upgradeProgression,
upgradeAttributeDefinitions,
);
tankDefinitions.tanks[tankId] = {
ancestors: [],
successors: [],
id: tankId,
dev_name: tankKey,
module_positions,
augment_progression,
roles: {},
camouflages: camouflages,
fixed_camouflage: fixedCamouflage,
@@ -21,6 +21,13 @@ import { MathUtils, Vector3 as THREEVector3, Vector3Tuple } from "three";
import { Cache } from "./0_base";
import { ServerBlitzKitAPI2 } from "./2_camouflages";
// The `front` and `back` tags hold "min max range" in degrees
function parseExtraPitchLimitValues(raw: string | undefined) {
if (raw === undefined) return undefined;
return raw.trim().split(/\s+/).map(Number);
}
export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
private vector3TupleToBlitzkit(tuple: Vector3Tuple) {
return { x: tuple[0], y: tuple[1], z: -tuple[2] } satisfies ProtoVector3;
@@ -350,17 +357,21 @@ export abstract class ServerBlitzKitAPI3 extends ServerBlitzKitAPI2 {
gunModel = 2;
}
const front = gun.extraPitchLimits?.front
? gun.extraPitchLimits.front.split(" ").map(Number)
: undefined;
const back = gun.extraPitchLimits?.back
? gun.extraPitchLimits.back.split(" ").map(Number)
: undefined;
const transition = gun.extraPitchLimits?.transition
? typeof gun.extraPitchLimits.transition === "number"
? gun.extraPitchLimits.transition
: gun.extraPitchLimits.transition.at(-1)!
: undefined;
// The client merges shared and per-tank values one field at a time:
// front, back and transition each fall back on the shared gun
const extraPitchLimits = {
...gunListEntry.extraPitchLimits,
...gun.extraPitchLimits,
};
const front = parseExtraPitchLimitValues(extraPitchLimits.front);
const back = parseExtraPitchLimitValues(extraPitchLimits.back);
// A repeated tag overwrites the last one, and one value covers both
const transition =
extraPitchLimits.transition === undefined
? undefined
: typeof extraPitchLimits.transition === "number"
? extraPitchLimits.transition
: extraPitchLimits.transition.at(-1)!;
const gunArmor: Armor = { thickness: {}, spaced: [] };
const maskName = `gun_${gunModel.toString().padStart(2, "0")}`;
const maskEnabled =
@@ -4,9 +4,21 @@ import { XMLParser } from "fast-xml-parser";
import type { normalize } from "node:path/posix";
import { parse as parseYaml } from "yaml";
// Tags of an upgrade progression that are lists even with a single child
const UPGRADE_PROGRESSION_LIST_TAGS = new Set([
"node",
"attribute",
"alternativeMechanicGroup",
]);
export abstract class AbstractVFS {
textDecoder = new TextDecoder();
private xmlParser = new XMLParser();
private attributeXmlParser = new XMLParser({
ignoreAttributes: false,
// A lone child would otherwise parse to an object instead of a list
isArray: (name) => UPGRADE_PROGRESSION_LIST_TAGS.has(name),
});
protected normalizePath?: typeof normalize;
@@ -80,6 +92,12 @@ export abstract class AbstractVFS {
return this.xmlParser.parse(file) as Type;
}
// Keeps attributes as `@_name` and lists as arrays, which `xml` drops
async xmlWithAttributes<Type>(path: string) {
const file = await this.text(path);
return this.attributeXmlParser.parse(file) as Type;
}
protected async _csv(text: string, options: Options = {}) {
const parsed = parseCSV(text, options);
return parsed;
@@ -17,6 +17,11 @@ export interface GunDefinitionsList {
tags: string;
level: number;
pitchLimits: string;
extraPitchLimits?: {
front?: string;
back?: string;
transition?: number | number[];
};
burst?: { count: number; rate: number };
clip?: { count: number; rate: number };
shots: {
+1
View File
@@ -23,6 +23,7 @@ export * from "./tankParameters";
export * from "./tanksStats";
export * from "./techTreeLayoutYaml";
export * from "./turretDefinitionsList";
export * from "./upgradeProgressionXml";
export * from "./vehicleDefinitionArmor";
export * from "./vehicleDefinitionList";
export * from "./vehicleDefinitions";
@@ -0,0 +1,61 @@
// Parsed with attributes and with these elements forced to arrays, see
// `AbstractVFS.xmlWithAttributes`
// Plain text unless the connector carries `verticalFirst`
export type UpgradeProgressionXmlRequirement =
| string
// Attribute values stay strings
| { "#text": string; "@_verticalFirst"?: string };
export interface UpgradeProgressionXmlAttribute {
attributeName: string;
// Numbers, or `true`/`false` for switches
value: number | boolean;
}
export interface UpgradeProgressionXmlNode {
id: number;
techName: string;
nodeType:
| "NODETYPE_COMMON"
| "NODETYPE_MECHANIC"
| "NODETYPE_ALTERNATIVE_MECHANIC";
xpCost?: number;
displayName?: string;
icon?: string;
gridPosition?: { row: number; column: number };
// Empty elements parse to an empty string
requiredNodes?: "" | { node: UpgradeProgressionXmlRequirement[] };
attributes?: { attribute: UpgradeProgressionXmlAttribute[] };
}
export interface UpgradeProgressionXmlGroup {
techName: string;
displayName: string;
description: string;
icon?: string;
xpCost: number;
gridPosition: { row: number; column: number };
requiredNodes: { node: UpgradeProgressionXmlRequirement[] };
alternativeNodes: { node: string[] };
}
export interface UpgradeProgressionXml {
matrix: { rows: number; columns: number };
alternativeMechanicGroups?: {
alternativeMechanicGroup: UpgradeProgressionXmlGroup[];
};
nodes: { node: UpgradeProgressionXmlNode[] };
}
export interface UpgradeAttributesXml {
root: {
attributes: {
attribute: {
attributeName: string;
icon: string;
title: string;
}[];
};
};
}
@@ -1,4 +1,4 @@
import { BlitzModuleType } from "@blitzkit/core";
import { BlitzModuleType, VehicleDefinitionArmor } from "@blitzkit/core";
export interface VehicleDefinitions {
invisibility: {
@@ -13,6 +13,8 @@ export interface VehicleDefinitions {
};
consumableSlots: number;
provisionSlots: number;
// Tier 11 tanks only, parsed separately because it needs attributes
upgradeProgression?: object;
optDevicePreset: string | string[];
hull: {
armor: VehicleDefinitionArmor;
+6 -3
View File
@@ -178,7 +178,9 @@
"flexibility": "Flexibility",
"maneuverability": "Maneuverability",
"survivability": "Survivability",
"concealment": "Concealment"
"concealment": "Concealment",
"assault_shells": "Assault shells"
},
"items": {
@@ -225,8 +227,8 @@
"gun_rear_elevation": "Rear elevation",
"azimuth_left": "Azimuth left",
"azimuth_right": "Azimuth right",
"speed_forward": "Forward",
"speed_backward": "Backward",
"speed_forward": "Top speed",
"speed_backward": "Reverse speed",
"speeds": "Speed",
"engine_power": "Engine power",
"brake_force": "Brake force",
@@ -288,6 +290,7 @@
"consumables": "Consumables",
"provisions": "Provisions",
"modules": "Modules",
"augments": "Augments",
"camouflage": "Camouflage",
"module_types": {
"turret": "Turret",
@@ -10,40 +10,41 @@ message TankDefinitions {
}
message TankDefinition {
uint32 id = 1;
string slug = 2;
map<string, uint32> roles = 3;
bool fixed_camouflage = 5;
repeated int32 camouflages = 6;
repeated int32 ancestors = 7;
repeated int32 successors = 8;
repeated Crew crew = 9;
uint32 health = 10;
string nation = 11;
I18nString name = 12;
TankType type = 13;
uint32 max_consumables = 14;
uint32 max_provisions = 15;
uint32 tier = 16;
TankClass class = 17;
bool testing = 18;
bool deprecated = 19;
repeated TurretDefinition turrets = 20;
repeated EngineDefinition engines = 21;
repeated TrackDefinition tracks = 22;
TankPrice price = 23;
optional ResearchCost research_cost = 24;
float speed_forwards = 25;
float speed_backwards = 26;
float camouflage_still = 27;
float camouflage_moving = 28;
float camouflage_on_fire = 29;
string equipment_preset = 30;
uint32 weight = 31;
string dev_name = 32;
optional Equalizer equalizer = 33;
optional I18nString name_full = 34;
repeated ModulePosition module_positions = 35;
uint32 id = 1;
string slug = 2;
map<string, uint32> roles = 3;
bool fixed_camouflage = 5;
repeated int32 camouflages = 6;
repeated int32 ancestors = 7;
repeated int32 successors = 8;
repeated Crew crew = 9;
uint32 health = 10;
string nation = 11;
I18nString name = 12;
TankType type = 13;
uint32 max_consumables = 14;
uint32 max_provisions = 15;
uint32 tier = 16;
TankClass class = 17;
bool testing = 18;
bool deprecated = 19;
repeated TurretDefinition turrets = 20;
repeated EngineDefinition engines = 21;
repeated TrackDefinition tracks = 22;
TankPrice price = 23;
optional ResearchCost research_cost = 24;
float speed_forwards = 25;
float speed_backwards = 26;
float camouflage_still = 27;
float camouflage_moving = 28;
float camouflage_on_fire = 29;
string equipment_preset = 30;
uint32 weight = 31;
string dev_name = 32;
optional Equalizer equalizer = 33;
optional I18nString name_full = 34;
repeated ModulePosition module_positions = 35;
optional AugmentProgression augment_progression = 36;
}
// Hand-authored cell in the modules screen grid. Tanks without any use the
@@ -54,6 +55,63 @@ message ModulePosition {
ProtoVector2 position = 3;
}
// Tier 11 augment tree (`upgradeProgression` in the game files). Cells are
// placed by hand on a 1-based grid and the connectors are routed by the
// client, see the loadout augments layout.
message AugmentProgression {
uint32 rows = 1;
uint32 columns = 2;
repeated AugmentNode nodes = 3;
optional AugmentGroup group = 4;
}
// TODO: render these differently in the browser
enum AugmentNodeType {
AUGMENT_NODE_TYPE_COMMON = 0;
AUGMENT_NODE_TYPE_MECHANIC = 1;
AUGMENT_NODE_TYPE_ALTERNATIVE = 2;
}
message AugmentNode {
int32 id = 1;
string tech_name = 2;
AugmentNodeType type = 3;
// Alternative nodes live in their group and cost nothing on their own
int32 xp_cost = 4;
// Missing for alternative nodes
optional ProtoVector2 position = 5;
repeated AugmentRequirement requires = 6;
repeated AugmentAttribute attributes = 7;
optional I18nString name = 8;
}
message AugmentRequirement {
string tech_name = 1;
// Route the connector along the column before the row
bool vertical_first = 2;
}
message AugmentAttribute {
string name = 1;
// Switches are stored as 0 or 1
float value = 2;
// Icon file name, missing for attributes the client has no art for
optional string icon = 3;
optional I18nString title = 4;
}
// Mutually exclusive final choice that all of its requirements lead into
message AugmentGroup {
string tech_name = 1;
I18nString name = 2;
I18nString description = 3;
optional string icon = 4;
int32 xp_cost = 5;
ProtoVector2 position = 6;
repeated AugmentRequirement requires = 7;
repeated AugmentNode alternatives = 8;
}
message Equalizer {
float health = 1;
float penetration = 2;
@@ -19,7 +19,7 @@
&[data-size="major"] {
--padding: var(--space-3);
--content-size: calc(1.5 * var(--font-size-regular));
--content-size: calc(1.75 * var(--font-size-regular));
}
padding: var(--padding) calc(2 * var(--padding));
@@ -1,5 +1,5 @@
.discriminator {
--inset: var(--space-3);
--inset: var(--space-2);
&[data-inset="small"] {
--inset: var(--space-2);
@@ -0,0 +1,87 @@
.tree {
--line-thickness: calc(var(--space-1) * 2);
--line-color: var(--gray-6);
.cell {
.north,
.south,
.west,
.east {
position: absolute;
background-color: var(--line-color);
}
.north,
.south {
left: 50%;
width: var(--line-thickness);
transform: translateX(-50%);
}
.west,
.east {
top: 50%;
height: var(--line-thickness);
transform: translateY(-50%);
}
/* An empty cell passes a line through, out to the middle of the gaps */
.north {
top: calc(var(--depth-gap) / -2);
height: calc(50% + var(--depth-gap) / 2);
}
.south {
bottom: calc(var(--depth-gap) / -2);
height: calc(50% + var(--depth-gap) / 2);
}
.west {
left: calc(var(--sibling-gap) / -2);
width: calc(50% + var(--sibling-gap) / 2);
}
.east {
right: calc(var(--sibling-gap) / -2);
width: calc(50% + var(--sibling-gap) / 2);
}
/* The buttons are translucent, so around a node the lines stay in the gaps */
&[data-node="true"] {
.north {
top: auto;
bottom: 100%;
height: calc(var(--depth-gap) / 2);
}
.south {
bottom: auto;
top: 100%;
height: calc(var(--depth-gap) / 2);
}
.west {
left: auto;
right: 100%;
width: calc(var(--sibling-gap) / 2);
}
.east {
right: auto;
left: 100%;
width: calc(var(--sibling-gap) / 2);
}
}
}
.alternatives {
grid-column: 1 / -1;
display: flex;
justify-content: center;
gap: var(--sibling-gap);
/* Prices hang below the nodes */
padding-bottom: calc(var(--space-2) + var(--font-size-minor));
}
}
@@ -0,0 +1,244 @@
import { alias, formatCompact } from "@blitzkit/core";
import {
AugmentNodeType,
type AugmentGroup,
type AugmentNode,
type AugmentProgression,
} from "@blitzkit/protos";
import {
DoubleArrowDownIcon,
DoubleArrowUpIcon,
LightningBoltIcon,
StarFilledIcon,
} from "@radix-ui/react-icons";
import { useCallback, useMemo } from "react";
import { useLocale } from "../../hooks/useLocale";
import { useStrings } from "../../hooks/useStrings";
import { layoutAugmentTree } from "../../tankopedia/augmentTreeLayout";
import { AUGMENT_GROUP_ID } from "../../tankopedia/augments";
import { classNames } from "../../ui/classNames";
import { IconButton } from "../IconButton";
import { LoadoutSection } from "../LoadoutSection";
import shared from "../LoadoutTree/index.module.css";
import { Text } from "../Text";
import styles from "./index.module.css";
interface AugmentIconProps {
icon?: string;
isCommon: boolean;
}
function AugmentIcon({ icon, isCommon }: AugmentIconProps) {
if (icon !== undefined) {
return (
<img
alt=""
src={alias("api", `/icons/augments/${icon}.webp`)}
className={shared.icon}
/>
);
}
return isCommon ? (
<StarFilledIcon className={shared.icon} />
) : (
<LightningBoltIcon className={shared.icon} />
);
}
interface PriceProps {
xp: number;
}
function Price({ xp }: PriceProps) {
const locale = useLocale();
if (xp <= 0) return null;
return (
<div className={shared.price}>
<Text size="minor">{formatCompact(locale, xp)}</Text>
<img alt="xp" src={alias("api", "/icons/currencies/xp.webp")} />
</div>
);
}
interface AugmentButtonProps {
node: AugmentNode;
isSelected: boolean;
onToggle: (id: number) => void;
}
function AugmentButton({ node, isSelected, onToggle }: AugmentButtonProps) {
const isCommon = node.type === AugmentNodeType.AUGMENT_NODE_TYPE_COMMON;
const handleClick = useCallback(() => onToggle(node.id), [onToggle, node]);
return (
<IconButton
radius="1"
size="major"
variant={isSelected ? "surface" : "soft"}
color={isSelected ? (isCommon ? undefined : "amber") : "gray"}
className={shared.node}
data-notable={!isCommon}
onClick={handleClick}
>
<AugmentIcon
icon={node.attributes.find((attribute) => attribute.icon)?.icon}
isCommon={isCommon}
/>
<Price xp={node.xp_cost} />
</IconButton>
);
}
interface GroupButtonProps {
group: AugmentGroup;
// One of its alternatives is installed
isSelected: boolean;
onToggle: (id: number) => void;
}
// Where the branches meet; the choice itself hangs below
function GroupButton({ group, isSelected, onToggle }: GroupButtonProps) {
const handleClick = useCallback(() => onToggle(AUGMENT_GROUP_ID), [onToggle]);
return (
<IconButton
radius="1"
size="major"
variant={isSelected ? "surface" : "soft"}
color={isSelected ? "amber" : "gray"}
className={shared.node}
data-notable
onClick={handleClick}
>
<AugmentIcon icon={group.icon} isCommon={false} />
<Price xp={group.xp_cost} />
</IconButton>
);
}
interface ContentProps {
progression: AugmentProgression;
selected: number[];
onToggle: (id: number) => void;
}
function Content({ progression, selected, onToggle }: ContentProps) {
const { group } = progression;
const installed = useMemo(() => new Set(selected), [selected]);
const isGroupSelected =
group?.alternatives.some(({ id }) => installed.has(id)) ?? false;
const { cells, columns, rows } = useMemo(
() => layoutAugmentTree(progression),
[progression],
);
return (
<div
className={classNames(shared.tree, styles.tree)}
style={{
gridTemplateColumns: `repeat(${columns}, auto)`,
gridTemplateRows: `repeat(${rows}, auto) auto`,
}}
>
{cells.map((cell) => (
<div
key={`${cell.row},${cell.column}`}
className={classNames(shared.cell, styles.cell)}
data-node={cell.node !== undefined || cell.group !== undefined}
style={{ gridColumn: cell.column, gridRow: cell.row }}
>
{cell.north && <span className={styles.north} />}
{cell.south && <span className={styles.south} />}
{cell.west && <span className={styles.west} />}
{cell.east && <span className={styles.east} />}
{cell.node && (
<AugmentButton
node={cell.node}
isSelected={installed.has(cell.node.id)}
onToggle={onToggle}
/>
)}
{cell.group && (
<GroupButton
group={cell.group}
isSelected={isGroupSelected}
onToggle={onToggle}
/>
)}
</div>
))}
{group !== undefined && (
// The mutually exclusive choice, hanging below the cell that leads in
<div className={styles.alternatives} style={{ gridRow: rows + 1 }}>
{group.alternatives.map((node) => (
<AugmentButton
key={node.id}
node={node}
isSelected={installed.has(node.id)}
onToggle={onToggle}
/>
))}
</div>
)}
</div>
);
}
interface LoadoutAugmentsProps {
progression: AugmentProgression;
selected: number[];
onToggle: (id: number) => void;
onStock: () => void;
onMaximize: () => void;
}
export function LoadoutAugments({
progression,
selected,
onToggle,
onStock,
onMaximize,
}: LoadoutAugmentsProps) {
const strings = useStrings();
return (
<LoadoutSection
title={strings.tanks.loadout.augments}
actions={
<>
<IconButton
highContrast
color="gray"
size="minor"
variant="ghost"
onClick={onStock}
>
<DoubleArrowUpIcon />
</IconButton>
<IconButton
highContrast
color="gray"
size="minor"
variant="ghost"
onClick={onMaximize}
>
<DoubleArrowDownIcon />
</IconButton>
</>
}
>
<Content
progression={progression}
selected={selected}
onToggle={onToggle}
/>
</LoadoutSection>
);
}
@@ -1,7 +1,4 @@
.tree {
/* The game lays the tree out left to right; here depth runs top to bottom */
--depth-gap: var(--space-5);
--sibling-gap: var(--space-4);
--line-thickness: var(--space-1);
--line-border: var(--space-1) solid var(--gray-6);
@@ -9,12 +6,7 @@
margin-bottom: calc(var(--space-2) + var(--font-size-minor));
}
display: grid;
gap: var(--depth-gap) var(--sibling-gap);
.cell {
position: relative;
.trunk-left,
.trunk-right {
position: absolute;
@@ -71,41 +63,5 @@
.snake-right {
left: 100%;
}
.module {
position: relative;
.icon {
width: 2em;
height: 2em;
.module[data-major="true"] & {
transform: scale(1.25);
}
}
.price {
display: flex;
gap: var(--space-1);
font-size: var(--font-size-minor);
position: absolute;
top: 100%;
left: 50%;
transform: translateX(-50%);
margin-top: var(--space-2);
background-color: var(--gray-2);
svg,
img {
width: 1em;
height: 1em;
}
}
}
}
}
@@ -16,10 +16,12 @@ import { useStrings } from "../../hooks/useStrings";
import { useUnwrapper } from "../../hooks/useUnwrapper";
import { layoutModuleTree } from "../../tankopedia/moduleTreeLayout";
import type { TankState } from "../../tankopedia/tankState";
import { classNames } from "../../ui/classNames";
import { Discriminator } from "../Discriminator";
import { IconButton } from "../IconButton";
import { LinkI18n } from "../LinkI18n";
import { LoadoutSection } from "../LoadoutSection";
import shared from "../LoadoutTree/index.module.css";
import { Text } from "../Text";
import { Tooltip } from "../Tooltip";
import styles from "./index.module.css";
@@ -76,11 +78,11 @@ function Content({ tank, selected, onSelect }: ContentProps) {
tank.turrets
.flatMap((turret) => turret.guns)
.toReversed()
.map((gun) => [gun.id, gun])
.map((gun) => [gun.id, gun]),
),
],
]),
[tank]
[tank],
);
const resolve = useCallback(
@@ -88,7 +90,7 @@ function Content({ tank, selected, onSelect }: ContentProps) {
unlock.type === ModuleType.MODULE_TYPE_VEHICLE
? (tanks.tanks[unlock.id] as TankDefinition | undefined)
: modules.get(unlock.type)?.get(unlock.id),
[modules]
[modules],
);
const { cells, columns, rows } = useMemo(
@@ -107,9 +109,9 @@ function Content({ tank, selected, onSelect }: ContentProps) {
return children.filter((child) => resolve(child) !== undefined);
},
tank.module_positions
tank.module_positions,
),
[tank, resolve]
[tank, resolve],
);
// Prices hang below the modules, so room is only reserved if the bottom row has one
@@ -118,12 +120,12 @@ function Content({ tank, selected, onSelect }: ContentProps) {
(cell) =>
cell.position[0] === bottomRow &&
cell.unlock !== undefined &&
cell.unlock.cost!.value > 0
cell.unlock.cost!.value > 0,
);
return (
<div
className={styles.tree}
className={classNames(shared.tree, styles.tree)}
data-has-bottom-cost={hasBottomCost}
style={{
// Transposed: the layout's columns (depth) become rows
@@ -137,7 +139,7 @@ function Content({ tank, selected, onSelect }: ContentProps) {
return (
<div
key={cell.position.join(",")}
className={styles.cell}
className={classNames(shared.cell, styles.cell)}
style={{ gridColumn: cell.position[1], gridRow: cell.position[0] }}
>
{cell.trunkUp && <span className={styles["trunk-left"]} />}
@@ -209,9 +211,10 @@ function ModuleNode({
const button = (
<IconButton
radius="1"
size="major"
variant={isSelected ? "surface" : "soft"}
color={isSelected ? (isTop ? "amber" : undefined) : "gray"}
className={styles.module}
className={shared.node}
data-major={unlock.type === ModuleType.MODULE_TYPE_VEHICLE}
onClick={() => {
if (!isTank) onSelect(unlock);
@@ -224,16 +227,15 @@ function ModuleNode({
? tankIcon(unlock.id)
: alias(
"api",
`/icons/modules/${moduleIconNames[unlock.type]}.webp`
`/icons/modules/${moduleIconNames[unlock.type]}.webp`,
)
}
className={styles.icon}
/>
<Discriminator corner="top-left">{romanize(module.tier)}</Discriminator>
{unlock.cost!.value > 0 && (
<div className={styles.price}>
<div className={shared.price}>
<Text size="minor">{formatCompact(locale, unlock.cost!.value)}</Text>
<img
alt={unlock.cost!.type}
@@ -0,0 +1,41 @@
/* What the modules and the augments have in common; each draws its own lines */
.tree {
/* The game lays the tree out left to right; here depth runs top to bottom */
--depth-gap: var(--space-5);
--sibling-gap: var(--space-4);
display: grid;
gap: var(--depth-gap) var(--sibling-gap);
}
.cell {
position: relative;
}
.node {
position: relative;
.price {
display: flex;
gap: var(--space-1);
font-size: var(--font-size-minor);
position: absolute;
top: 100%;
left: 50%;
transform: translateX(-50%);
margin-top: var(--space-2);
background-color: var(--gray-2);
svg,
img {
width: 1em;
height: 1em;
}
}
}
@@ -8,12 +8,12 @@ import { useStrings } from "../hooks/useStrings";
import { TankopediaSortDirection } from "../stores/tankopediaPersistent";
import { TankSort } from "../stores/tankopediaSort";
import { sortableCharacteristics } from "../tankopedia/sortableCharacteristics";
import type { CharacteristicName } from "../types/characteristics";
import type { RenderedCharacteristicName } from "../types/characteristics";
import { Button } from "./Button";
import { DropdownMenu } from "./DropdownMenu";
interface ItemProps {
by: CharacteristicName;
by: RenderedCharacteristicName;
}
function Item({ by }: ItemProps) {
@@ -77,6 +77,8 @@ export function TankSearchSort() {
(item) => "name" in item && sortableCharacteristics.has(item.name),
);
if (items.length === 0) return null;
return (
<DropdownMenu.Sub key={group.name}>
<DropdownMenu.SubTrigger>
@@ -88,6 +88,10 @@
align-items: center;
gap: var(--space-3);
/* Same height with or without the number, so the bars line up */
font-size: var(--font-size-minor);
height: 1em;
.bar-wrapper {
flex: 1;
height: var(--space-1);
@@ -1,6 +1,6 @@
import { romanize } from "@blitzkit/core";
import { literals } from "@blitzkit/i18n/src/literals";
import { useRef } from "react";
import { Fragment, useRef } from "react";
import { characteristicsGroups } from "../../config/characteristicsGroups";
import { toys } from "../../config/toys";
import { useDuelModules } from "../../hooks/useDuelModules";
@@ -15,6 +15,7 @@ import type {
CharacteristicsGroup,
ComputedCharacteristics,
ToyName,
ToyRenderConfig,
} from "../../types/characteristics";
import { Heading } from "../Heading";
import { SegmentedControl } from "../SegmentedControl";
@@ -36,28 +37,35 @@ export function TankopediaCharacteristics({
<CompareOptions />
<div className={styles.characteristics}>
{characteristicsGroups.map((group) => {
const items = group.order.filter(
(item) => "name" in item && characteristics.has(item.name),
).length;
const shouldRender = items > 0;
if (!shouldRender) return null;
return (
<Group
key={group.name}
group={group}
characteristics={characteristics}
rankings={rankings}
/>
);
})}
{characteristicsGroups.map((group) => (
<Group
key={group.name}
group={group}
characteristics={characteristics}
rankings={rankings}
/>
))}
</div>
</div>
);
}
type GroupItem = CharacteristicsGroup["order"][number];
// A toy that needs a characteristic only shows for the tanks that have it
function hasToy(
{ requires }: ToyRenderConfig,
characteristics: ComputedCharacteristics,
) {
return requires === undefined || characteristics.has(requires);
}
function itemKey(item: GroupItem) {
if ("toy" in item) return `toy:${item.toy}`;
if ("label" in item) return `label:${item.label}`;
return item.name;
}
interface GroupProps {
group: CharacteristicsGroup;
characteristics: ComputedCharacteristics;
@@ -66,15 +74,25 @@ interface GroupProps {
function Group({ group, characteristics, rankings }: GroupProps) {
const strings = useStrings();
const toys = group.order.filter((item) => "toy" in item).length;
const characteristicsCount = group.order.filter(
(item) => "name" in item && characteristics.has(item.name),
).length;
const labelsCount =
characteristicsCount > 0
? group.order.filter((item) => "label" in item).length
: 0;
const items = characteristicsCount + labelsCount;
let toys = 0;
let characteristicsCount = 0;
let labelsCount = 0;
for (const item of group.order) {
if ("toy" in item) {
if (hasToy(item, characteristics)) toys++;
} else if ("label" in item) {
labelsCount++;
} else if (characteristics.has(item.name)) {
characteristicsCount++;
}
}
if (toys + characteristicsCount === 0) return null;
// Labels only head characteristics, so they go when there are none
const hasLabels = characteristicsCount > 0;
const items = characteristicsCount + (hasLabels ? labelsCount : 0);
const groupSpan = `calc(${toys} * var(--group-span) + ${items} + 2)`;
const contentSpan = `calc(${toys} * var(--group-span) + ${items})`;
@@ -105,11 +123,11 @@ function Group({ group, characteristics, rankings }: GroupProps) {
}}
>
{group.order.map((item) => (
<>
{"toy" in item && (
<ToyAssigner characteristics={characteristics} {...item} />
<Fragment key={itemKey(item)}>
{"toy" in item && hasToy(item, characteristics) && (
<ToyAssigner characteristics={characteristics} toy={item.toy} />
)}
{"label" in item && <Label {...item} />}
{"label" in item && hasLabels && <Label {...item} />}
{"name" in item && characteristics.has(item.name) && (
<Item
config={item}
@@ -117,7 +135,7 @@ function Group({ group, characteristics, rankings }: GroupProps) {
ranking={rankings.get(item.name)}
/>
)}
</>
</Fragment>
))}
<div className={styles.dead} />
@@ -165,18 +183,18 @@ function Item({ config, value, ranking }: ItemProps) {
<CharacteristicValue config={config} value={value} />
</div>
{ranking && (
<div className={styles.ranking}>
<Bar value={ranking.score} />
<div className={styles.ranking}>
{ranking ? <Bar value={ranking.score} /> : <BarStub />}
{ranking && (
<Text lowContrast size="minor" className={styles.number}>
{literals(strings.units.fraction, {
numerator: ranking.rank,
denominator: ranking.total,
})}
</Text>
</div>
)}
)}
</div>
</span>
);
}
@@ -229,6 +247,18 @@ function CompareOptions() {
);
}
// Unranked items get a full neutral bar
function BarStub() {
return (
<div className={styles["bar-wrapper"]}>
<div
className={styles.bar}
style={{ backgroundColor: "var(--gray-3)", width: "100%" }}
/>
</div>
);
}
interface BarProps {
value: number;
}
@@ -1,7 +1,9 @@
import { MAX_SKILL_LEVEL } from "@blitzkit/core";
import { useCallback } from "react";
import { useDuelModules } from "../../hooks/useDuelModules";
import { Tankopedia } from "../../stores/tankopedia";
import { selectModule } from "../../tankopedia/selectModule";
import { createAugments, toggleAugment } from "../../tankopedia/augments";
import { LoadoutConsumables } from "../LoadoutConsumables";
import { LoadoutEquipment } from "../LoadoutEquipment";
import { LoadoutModules } from "../LoadoutModules";
@@ -9,11 +11,13 @@ import { LoadoutProvisions } from "../LoadoutProvisions";
import { LoadoutShells } from "../LoadoutShells";
import { LoadoutSkills } from "../LoadoutSkills";
import { LoadoutStatus } from "../LoadoutStatus";
import { LoadoutAugments } from "../LoadoutAugments";
export function TankopediaLoadout() {
return (
<>
<Modules />
<Augments />
<Shells />
<Equipment />
<Provisions />
@@ -58,6 +62,47 @@ function Modules() {
);
}
function Augments() {
const protagonist = useDuelModules("protagonist");
const selected = Tankopedia.use((state) => state.protagonist.augments);
const progression = protagonist.tank.augment_progression;
const handleToggle = useCallback(
(id: number) => {
if (progression === undefined) return;
Tankopedia.mutate((draft) => {
toggleAugment(draft.protagonist, progression, id);
});
},
[progression],
);
const handleStock = useCallback(() => {
Tankopedia.mutate((draft) => {
draft.protagonist.augments = [];
});
}, []);
const handleMaximize = useCallback(() => {
Tankopedia.mutate((draft) => {
draft.protagonist.augments = createAugments(progression);
});
}, [progression]);
if (progression === undefined) return null;
return (
<LoadoutAugments
progression={progression}
selected={selected}
onToggle={handleToggle}
onStock={handleStock}
onMaximize={handleMaximize}
/>
);
}
function Shells() {
const protagonist = useDuelModules("protagonist");
@@ -541,3 +541,85 @@
}
}
}
.assault {
--axis-width: var(--space-8);
--axis-height: var(--space-7);
position: relative;
width: 100%;
height: 100%;
padding: var(--space-4) var(--space-5) var(--axis-height) var(--axis-width);
border-radius: inherit;
background-color: var(--gray-2);
user-select: none;
.assault-damage {
position: absolute;
top: var(--space-4);
bottom: var(--axis-height);
left: var(--space-2);
span {
position: absolute;
left: 0;
transform: translateY(50%);
color: var(--gray-11);
font-size: var(--font-size-minor);
white-space: nowrap;
}
}
.assault-plot {
position: relative;
display: flex;
align-items: flex-end;
width: 100%;
height: 100%;
cursor: ew-resize;
touch-action: none;
}
.assault-sector {
background: linear-gradient(
45deg,
color-mix(in hsl, var(--tomato-7), var(--jade-7) var(--mix)),
color-mix(in hsl, var(--tomato-9), var(--jade-9) var(--mix))
);
border-top: 1px solid var(--gray-11);
}
.assault-cursor {
position: absolute;
top: 0;
bottom: 0;
width: 2px;
transform: translateX(-50%);
background-color: var(--accent-11);
pointer-events: none;
}
.assault-distances {
position: absolute;
bottom: 0;
left: var(--axis-width);
right: var(--space-5);
display: flex;
height: var(--axis-height);
div {
position: relative;
height: 100%;
}
span {
position: absolute;
right: 0;
margin-top: var(--space-2);
transform: translateX(50%);
color: var(--gray-11);
font-size: var(--font-size-minor);
writing-mode: vertical-rl;
}
}
}
@@ -22,6 +22,11 @@ import { useDuelModels } from "../../hooks/useDuelModels";
import { useDuelModules } from "../../hooks/useDuelModules";
import { useEquipment } from "../../hooks/useEquipment";
import { useStrings } from "../../hooks/useStrings";
import {
fakeLogSquishyHigh,
fakeLogSquishyHighInverse,
fakeLogSquishyLow,
} from "../../core/blitzkit/fakeLog";
import { Tankopedia } from "../../stores/tankopedia";
import type { ComputedCharacteristics } from "../../types/characteristics";
import { Button } from "../Button";
@@ -901,3 +906,131 @@ export function FlexibilityToy() {
</div>
);
}
// Where the pointer is across the plot, from 0 to 1
function plotFraction(event: PointerEvent<HTMLDivElement>) {
const rect = event.currentTarget.getBoundingClientRect();
return clamp((event.clientX - rect.left) / rect.width, 0, 1);
}
export function AssaultShellsToy({ characteristics }: ToyProps) {
const strings = useStrings();
const distance = Tankopedia.use((state) => state.environment.distance);
// Where the cursor is while it is dragged, as a fraction of the plot
const [dragged, setDragged] = useState<number>();
const distances = characteristics.get("_assault_distances") as number[];
const factors = characteristics.get("_assault_factors") as number[];
const baseDamage = characteristics.get("_base_damage") as number;
const maxDistance = distances.at(-1)!;
// Sector widths are stretched so the near ones stay readable. The last one
// always ends at the far edge
const sectors = useMemo(() => {
const maxFactor = Math.max(...factors);
let start = 0;
return distances.map((sectorDistance, index) => {
const end = fakeLogSquishyHigh(sectorDistance / maxDistance);
const relative = factors[index] / maxFactor;
const sector = {
distance: sectorDistance,
factor: factors[index],
width: `${(end - start) * 100}%`,
height: `${fakeLogSquishyLow(relative) * 100}%`,
mix: `${clamp(2 * relative - 1, 0, 1) * 100}%`,
};
start = end;
return sector;
});
}, [distances, factors, maxDistance]);
const cursor =
dragged ??
fakeLogSquishyHigh(Math.min(distance, maxDistance) / maxDistance);
const handlePointerDown = useCallback(
(event: PointerEvent<HTMLDivElement>) => {
event.currentTarget.setPointerCapture(event.pointerId);
setDragged(plotFraction(event));
},
[],
);
const handlePointerMove = useCallback(
(event: PointerEvent<HTMLDivElement>) => {
if (!event.currentTarget.hasPointerCapture(event.pointerId)) return;
setDragged(plotFraction(event));
},
[],
);
// Only the release writes the distance, so dragging recomputes nothing
const handlePointerUp = useCallback(
(event: PointerEvent<HTMLDivElement>) => {
if (!event.currentTarget.hasPointerCapture(event.pointerId)) return;
const fraction = plotFraction(event);
Tankopedia.mutate((draft) => {
draft.environment.distance =
fakeLogSquishyHighInverse(fraction) * maxDistance;
});
setDragged(undefined);
},
[maxDistance],
);
const handlePointerCancel = useCallback(() => setDragged(undefined), []);
return (
<div className={styles.assault}>
<div className={styles["assault-damage"]}>
{sectors.map(({ distance: sectorDistance, factor, height }) => (
<span key={sectorDistance} style={{ bottom: height }}>
{literals(strings.common.units.hp, {
value: Math.round(baseDamage * factor),
})}
</span>
))}
</div>
<div
className={styles["assault-plot"]}
onPointerDown={handlePointerDown}
onPointerMove={handlePointerMove}
onPointerUp={handlePointerUp}
onPointerCancel={handlePointerCancel}
>
{sectors.map(({ distance: sectorDistance, width, height, mix }) => (
<div
key={sectorDistance}
className={styles["assault-sector"]}
style={{ width, height, "--mix": mix } as CSSProperties}
/>
))}
<div
className={styles["assault-cursor"]}
style={{ left: `${cursor * 100}%` }}
/>
</div>
<div className={styles["assault-distances"]}>
{sectors.map(({ distance: sectorDistance, width }) => (
<div key={sectorDistance} style={{ width }}>
<span>
{literals(strings.common.units.m, {
value: Math.round(sectorDistance),
})}
</span>
</div>
))}
</div>
</div>
);
}
+250 -107
View File
@@ -1,4 +1,3 @@
import type { Vector2Tuple } from "three";
import {
blitzkitToBlitzShellKind,
isExplosive,
@@ -6,6 +5,8 @@ import {
unionBoundingBox,
} from "@blitzkit/core";
import { ShellType, TankClass } from "@blitzkit/protos";
import type { Vector2Tuple } from "three";
import { shellSlot } from "../tankopedia/augments";
import { hullTraverseSpeed } from "../tankopedia/hullTraverseSpeed";
import { rawTerrainCoefficient } from "../tankopedia/rawTerrainCoefficient";
import { tankClassToBlitzTankClass } from "../tankopedia/tankClass";
@@ -30,10 +31,11 @@ export const characteristics = {
},
},
damage: {
// Compute time only: damage before the assault shell falloff
_base_damage: {
type: CharacteristicType.Number,
compute({ shell, environment, equalizer, script, gun }) {
compute({ shell, environment, equalizer, script, gun, augment }) {
let coefficient = 1;
if (environment.equalize) coefficient *= equalizer.damage;
@@ -56,15 +58,29 @@ export const characteristics = {
coefficient *= effect.bonusValues!.factor;
});
if (gun.assault_ranges?.types.includes(shell.type)) {
const range = gun.assault_ranges.ranges.find(
({ distance }) => distance >= environment.distance,
);
let damage = shell.armor_damage;
coefficient *= range?.factor ?? 0;
}
augment(`SHELL_DAMAGE_SLOT_${shellSlot(gun, shell)}`, (value) => {
damage += value;
});
return coefficient * shell.armor_damage;
return coefficient * damage;
},
},
damage: {
type: CharacteristicType.Number,
compute({ shell, environment, gun, characteristic }) {
const damage = characteristic("_base_damage") as number;
if (!gun.assault_ranges?.types.includes(shell.type)) return damage;
const range = gun.assault_ranges.ranges.find(
({ distance }) => distance >= environment.distance,
);
return damage * (range?.factor ?? 0);
},
},
@@ -100,16 +116,23 @@ export const characteristics = {
return gun.gun_type!.$case !== "auto_reloader";
},
compute({ gun, characteristic }): number {
compute({ gun, characteristic, augment }): number {
if (gun.gun_type!.$case === "auto_reloader") return -Infinity;
const c = characteristic("_reload_coefficient") as number;
let reload = 0;
augment("GUN_RELOAD_TIME", (value) => {
reload += value;
});
if (gun.gun_type!.$case === "regular") {
return c * gun.gun_type!.value.reload;
reload += gun.gun_type!.value.reload;
} else {
reload += gun.gun_type!.value.clip_reload;
}
return c * gun.gun_type!.value.clip_reload;
return c * reload;
},
},
@@ -120,14 +143,23 @@ export const characteristics = {
return gun.gun_type!.$case === "auto_reloader";
},
compute({ gun, characteristic }) {
compute({ gun, characteristic, augment }) {
if (gun.gun_type!.$case !== "auto_reloader") return [];
const reloadCoefficient = characteristic("_reload_coefficient") as number;
let bonus = 0;
return gun.gun_type!.value.shell_reloads.map(
(reload) => reload * reloadCoefficient,
);
augment("GUN_RELOAD_TIME", (value) => {
bonus += value;
});
return gun.gun_type!.value.shell_reloads.map((base) => {
let reload = base;
reload += bonus;
return reload * reloadCoefficient;
});
},
},
@@ -237,7 +269,11 @@ export const characteristics = {
const rest = reloads.length - 1;
const cycle = characteristic("_optimal_shell_cycle") as number;
return damage * rest + (damage * (60 - rest * intraClip)) / cycle;
let dpm = damage * rest;
dpm += (damage * (60 - rest * intraClip)) / cycle;
return dpm;
},
},
@@ -381,7 +417,7 @@ export const characteristics = {
penetration: {
type: CharacteristicType.Number,
compute({ shell, environment, equalizer, script }) {
compute({ gun, shell, environment, equalizer, script, augment }) {
let c = 1;
script("protagonist", "CalibratedShells", (effect) => {
@@ -391,26 +427,43 @@ export const characteristics = {
if (environment.equalize) c *= equalizer.penetration;
return c * shell.penetration!.near;
let penetration = shell.penetration!.near;
augment(
`SHELL_PIERCING_POWER_100_SLOT_${shellSlot(gun, shell)}`,
(value) => {
penetration += value;
},
);
return c * penetration;
},
},
penetration_loss_by_distance: {
type: CharacteristicType.Number,
compute({ shell, script }) {
compute({ gun, shell, script, augment }) {
let c = 1;
script("protagonist", "StaticMiscAttrsModifier", (effect) => {
c += effect.bonusValues!.piercingPenaltyFactor500m / 100;
});
return (
c *
100 *
((shell.penetration!.near - shell.penetration!.far) /
shell.penetration!.near)
);
const slot = shellSlot(gun, shell);
let near = shell.penetration!.near;
let far = shell.penetration!.far;
augment(`SHELL_PIERCING_POWER_100_SLOT_${slot}`, (value) => {
near += value;
});
augment(`SHELL_PIERCING_POWER_500_SLOT_${slot}`, (value) => {
far += value;
});
const loss = (near - far) / near;
return 100 * c * loss;
},
},
@@ -429,7 +482,7 @@ export const characteristics = {
shell_velocity: {
type: CharacteristicType.Number,
compute({ shell, script }) {
compute({ gun, shell, script, augment }) {
let c = 1;
script("protagonist", "StaticMiscAttrsModifier", (effect) => {
@@ -440,7 +493,13 @@ export const characteristics = {
c += effect.bonusValues!.projectileSpeedFactor / 100;
});
return c * shell.velocity;
let velocity = shell.velocity;
augment(`SHELL_SPEED_SLOT_${shellSlot(gun, shell)}`, (value) => {
velocity += value;
});
return c * velocity;
},
},
@@ -506,45 +565,53 @@ export const characteristics = {
speed_forward: {
type: CharacteristicType.Number,
compute({ tank, script }) {
let bias = 0;
compute({ tank, script, augment }) {
let speed = tank.speed_forwards;
let factor = 1;
augment("FORWARD_MAX_SPEED", (value) => {
speed += value;
});
script("protagonist", "GearOil", (effect) => {
bias += effect.bonusValues?.fwdSpeedLimitBias ?? 0;
speed += effect.bonusValues?.fwdSpeedLimitBias ?? 0;
});
script("protagonist", "ImprovedAfterburning", (effect) => {
bias += effect.fwdSpeedLimitBias ?? 0;
speed += effect.fwdSpeedLimitBias ?? 0;
});
script("protagonist", "AttributesModifier", (effect) => {
factor *= effect.attributes?.speedLimitsFactor ?? 1;
});
return (tank.speed_forwards + bias) * factor;
return speed * factor;
},
},
speed_backward: {
type: CharacteristicType.Number,
compute({ tank, script }) {
let bias = 0;
compute({ tank, script, augment }) {
let speed = tank.speed_backwards;
let factor = 1;
augment("BACKWARD_MAX_SPEED", (value) => {
speed += value;
});
script("protagonist", "GearOil", (effect) => {
bias += effect.bonusValues?.bkwdSpeedLimitBias ?? 0;
speed += effect.bonusValues?.bkwdSpeedLimitBias ?? 0;
});
script("protagonist", "ImprovedAfterburning", (effect) => {
bias += effect.bkwdSpeedLimitBias ?? 0;
speed += effect.bkwdSpeedLimitBias ?? 0;
});
script("protagonist", "AttributesModifier", (effect) => {
factor *= effect.attributes?.speedLimitsFactor ?? 1;
});
return (tank.speed_backwards + bias) * factor;
return speed * factor;
},
},
@@ -552,9 +619,8 @@ export const characteristics = {
type: CharacteristicType.Number,
compute({ tank, gun, turret, track, degressive, script }): number {
/*
Mirrors the game's hangar params builder (wotblitz.exe 11.21, aim time
at 0x19eb300). Consumables such as FireControlSystem are battle-time
only and are not part of it.
Mirrors how the game computes aim time in the hangar. Consumables such as
FireControlSystem are battle-time only and are not part of it.
T = (A × C) × ln(√(1 + k² × S)) / (1 − p/100)
@@ -601,9 +667,13 @@ export const characteristics = {
dispersion: {
type: CharacteristicType.Number,
compute({ gun, degressive, script }) {
compute({ gun, degressive, script, augment }) {
let coefficient = 1;
augment("DISPERSION_ANGLE_FACTOR_BONUS", (value) => {
coefficient += value;
});
script("protagonist", "miscAttrs/shotDispersionAngleFactor", (effect) => {
coefficient += effect.bonusValues!.percent / 100;
});
@@ -684,12 +754,18 @@ export const characteristics = {
compute(context): number {
const skill = (context.environment.skills.smooth_driving ?? 0) / 100;
return (
context.track.dispersion_move *
(1 +
(context.characteristic("_stabilizer_coefficient") as number) -
skill)
);
const stabilizer = context.characteristic(
"_stabilizer_coefficient",
) as number;
let coefficient = 1;
context.augment("DISPERSION_VEHICLE_MOVEMENT_FACTOR", (value) => {
coefficient *= value;
});
coefficient *= 1 + stabilizer - skill;
return context.track.dispersion_move * coefficient;
},
},
@@ -698,12 +774,18 @@ export const characteristics = {
compute(context): number {
const skill = (context.environment.skills.smooth_turn ?? 0) / 100;
return (
context.track.dispersion_traverse *
(1 +
(context.characteristic("_stabilizer_coefficient") as number) -
skill)
);
const stabilizer = context.characteristic(
"_stabilizer_coefficient",
) as number;
let coefficient = 1;
context.augment("DISPERSION_VEHICLE_ROTATION_FACTOR", (value) => {
coefficient *= value;
});
coefficient *= 1 + stabilizer - skill;
return context.track.dispersion_traverse * coefficient;
},
},
@@ -712,12 +794,18 @@ export const characteristics = {
compute(context): number {
const skill = (2 * (context.environment.skills.smooth_turret ?? 0)) / 100;
return (
context.gun.dispersion_traverse *
(1 +
(context.characteristic("_stabilizer_coefficient") as number) -
skill)
);
const stabilizer = context.characteristic(
"_stabilizer_coefficient",
) as number;
let coefficient = 1;
context.augment("DISPERSION_TURRET_ROTATION_FACTOR", (value) => {
coefficient *= value;
});
coefficient *= 1 + stabilizer - skill;
return context.gun.dispersion_traverse * coefficient;
},
},
@@ -726,62 +814,74 @@ export const characteristics = {
compute(context): number {
const skill = (context.environment.skills.soft_recoil ?? 0) / 100;
return (
context.gun.dispersion_shot *
(1 +
(context.characteristic("_stabilizer_coefficient") as number) -
skill)
);
const stabilizer = context.characteristic(
"_stabilizer_coefficient",
) as number;
const coefficient = 1 + stabilizer - skill;
return context.gun.dispersion_shot * coefficient;
},
},
dispersion_gun_damaged: {
type: CharacteristicType.Number,
compute(context): number {
return (
context.gun.dispersion_damaged *
(1 + (context.characteristic("_stabilizer_coefficient") as number))
);
const stabilizer = context.characteristic(
"_stabilizer_coefficient",
) as number;
const coefficient = 1 + stabilizer;
return context.gun.dispersion_damaged * coefficient;
},
},
// dispersion_angle: unavailable,
dispersion_angle: {
type: CharacteristicType.Number,
compute({ characteristic }) {
// Dispersion is the radius of the circle at 100 m
const dispersion = characteristic("dispersion") as number;
return Math.atan(dispersion / 100) * (180 / Math.PI);
},
},
gun_depression: {
type: CharacteristicType.Number,
compute({ state, turret, gun, script }) {
compute({ state, turret, gun, script, augment }) {
const turretModel = state.model.turrets[turret.id];
const gunModel = turretModel.guns[gun.id];
let bonus = 0;
let depression = gunModel.pitch!.max;
script("protagonist", "ImprovedPitchLimitsSystem", (effect) => {
bonus += effect.bonusValues?.lowerPitchLimitIncrease ?? 0;
depression += state.model.initial_turret_rotation?.pitch ?? 0;
augment("PITCH_LIMIT_DOWN", (value) => {
depression += value;
});
return (
gunModel.pitch!.max +
(state.model.initial_turret_rotation?.pitch ?? 0) +
bonus
);
script("protagonist", "ImprovedPitchLimitsSystem", (effect) => {
depression += effect.bonusValues?.lowerPitchLimitIncrease ?? 0;
});
return depression;
},
},
gun_elevation: {
type: CharacteristicType.Number,
compute({ state, turret, gun, script }) {
compute({ state, turret, gun, script, augment }) {
const turretModel = state.model.turrets[turret.id];
const gunModel = turretModel.guns[gun.id];
let bonus = 0;
let elevation = -gunModel.pitch!.min;
script("protagonist", "ImprovedPitchLimitsSystem", (effect) => {
bonus += effect.bonusValues?.upperPitchLimitIncrease ?? 0;
elevation -= state.model.initial_turret_rotation?.pitch ?? 0;
augment("PITCH_LIMIT_UP", (value) => {
elevation += value;
});
return (
-gunModel.pitch!.min -
(state.model.initial_turret_rotation?.pitch ?? 0) +
bonus
);
script("protagonist", "ImprovedPitchLimitsSystem", (effect) => {
elevation += effect.bonusValues?.upperPitchLimitIncrease ?? 0;
});
return elevation;
},
},
@@ -856,14 +956,14 @@ export const characteristics = {
weight: {
type: CharacteristicType.Number,
compute({ tank, engine, track, turret, gun }) {
return (
(tank.weight +
engine.weight +
track.weight +
turret.weight +
gun.weight) /
1000
);
let weight = tank.weight;
weight += engine.weight;
weight += track.weight;
weight += turret.weight;
weight += gun.weight;
return weight / 1000;
},
},
@@ -906,10 +1006,15 @@ export const characteristics = {
engine_power: {
type: CharacteristicType.Number,
// explicit return type breaks the circular inference through characteristic()
compute({ engine, characteristic }): number {
return (
engine.power * (characteristic("_engine_power_coefficient") as number)
);
compute({ engine, characteristic, augment }): number {
const coefficient = characteristic("_engine_power_coefficient") as number;
let power = engine.power;
augment("ENGINE_POWER", (value) => {
power += value;
});
return power * coefficient;
},
},
@@ -1047,9 +1152,13 @@ export const characteristics = {
_turret_traverse_coefficient: {
type: CharacteristicType.Number,
compute({ progressive, script }) {
compute({ progressive, script, augment }) {
let c = 1;
augment("TURRET_ROTATION_SPEED_FACTOR_BONUS", (value) => {
c += value;
});
script("protagonist", "Fuel", (effect) => {
c += (effect.bonusValues?.turretRotationSpeedIncrease ?? 0) / 100;
});
@@ -1076,7 +1185,7 @@ export const characteristics = {
health: {
type: CharacteristicType.Number,
compute({ tank, turret, environment, equalizer, script }) {
compute({ tank, turret, environment, equalizer, script, augment }) {
let c0 = 1;
script("protagonist", "SmallHPStock", (effect) => {
@@ -1093,8 +1202,12 @@ export const characteristics = {
c1 *= equalizer.health;
}
let health = tank.health + turret.health;
let health = tank.health;
health += turret.health;
augment("MAX_HEALTH", (value) => {
health += value;
});
health *= c0 * c1;
if (environment.equalize) {
@@ -1107,14 +1220,19 @@ export const characteristics = {
fire_chance: {
type: CharacteristicType.Number,
compute({ engine, script }) {
compute({ engine, script, augment }) {
// Augments are a fraction of the chance, not points of it
let c = 1;
augment("FIRE_START_CHANCE", (value) => {
c += value;
});
script("protagonist", "SafetySet", (effect) => {
c -= (effect.bonusValues?.fireProtectionIncrease ?? 0) / 100;
});
return 100 * c * engine.fire_chance;
return 100 * Math.max(0, c) * engine.fire_chance;
},
},
@@ -1239,4 +1357,29 @@ export const characteristics = {
return size.y;
},
},
// Compute time only: what the assault shells visualizer is drawn from
_assault_distances: {
type: CharacteristicType.NumberList,
should_render({ gun, shell }) {
return gun.assault_ranges?.types.includes(shell.type) === true;
},
compute({ gun }) {
return gun.assault_ranges!.ranges.map(({ distance }) => distance);
},
},
_assault_factors: {
type: CharacteristicType.NumberList,
should_render({ gun, shell }) {
return gun.assault_ranges?.types.includes(shell.type) === true;
},
compute({ gun }) {
return gun.assault_ranges!.ranges.map(({ factor }) => factor);
},
},
} satisfies Record<string, Characteristic>;
@@ -68,6 +68,12 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
// ],
// },
{
name: "assault_shells",
sortable: false,
order: [{ toy: "assault_shells", requires: "_assault_distances" }],
},
{
name: "gun",
// render: CharacteristicsGroupRender.Statistical,
@@ -83,45 +89,45 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
{ name: "dpm", decimals: 0, units: "hp", localize: true },
{
name: "dpm_effective",
indent: true,
decimals: 0,
units: "hp",
localize: true,
indent: true,
},
{
name: "dpm_peekaboo",
indent: true,
decimals: 0,
units: "hp",
localize: true,
indent: true,
},
{ name: "damage", decimals: 0, units: "hp", localize: true },
{
name: "damage_range",
indent: true,
decimals: 0,
units: "hp",
localize: true,
indent: true,
},
{ name: "module_damage", decimals: 0, units: "hp", localize: true },
{
name: "module_damage_range",
indent: true,
decimals: 0,
units: "hp",
localize: true,
indent: true,
},
{
name: "reload",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 1,
units: "s",
ranking: CharacteristicRanking.LowerIsBetter,
},
{
name: "reloads",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 1,
units: "s",
ranking: CharacteristicRanking.LowerIsBetter,
},
{ toy: "reload" },
@@ -134,12 +140,15 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
order: [
{ name: "clipping_potential", localize: true, units: "hp" },
{ name: "clip_size" },
{ name: "optimal_shell", ranking: CharacteristicRanking.None },
{
name: "optimal_shell",
ranking: CharacteristicRanking.None,
},
{
name: "intra_clip",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 2,
units: "s",
ranking: CharacteristicRanking.LowerIsBetter,
},
{ name: "burst_size" },
{ name: "intra_burst", decimals: 2, units: "s" },
@@ -158,15 +167,15 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
{ name: "penetration", units: "mm" },
{
name: "penetration_loss_by_distance",
units: "percentage",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
units: "percentage",
},
{
name: "penetration_loss_after_ricochet",
units: "percentage",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
units: "percentage",
},
{ name: "shell_velocity", units: "m_s" },
{ name: "shell_range", units: "m" },
@@ -174,19 +183,19 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
{ name: "caliber", units: "mm" },
{
name: "ricochet",
units: "deg",
ranking: CharacteristicRanking.None,
units: "deg",
},
{
name: "normalization",
units: "deg",
ranking: CharacteristicRanking.None,
units: "deg",
},
{
name: "explosion_radius",
ranking: CharacteristicRanking.None,
decimals: 2,
units: "m",
ranking: CharacteristicRanking.None,
},
{ toy: "ricochet" },
@@ -199,53 +208,53 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
order: [
{
name: "aim_time",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 2,
units: "s",
ranking: CharacteristicRanking.LowerIsBetter,
},
{
name: "dispersion",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 3,
units: "m",
ranking: CharacteristicRanking.LowerIsBetter,
},
{ name: "dispersion_angle", decimals: 3, units: "deg" },
{ label: "dispersion_penalties" },
{
name: "dispersion_moving",
decimals: 3,
units: "plus",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 3,
units: "plus",
},
{
name: "dispersion_hull_traversing",
decimals: 3,
units: "plus",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 3,
units: "plus",
},
{
name: "dispersion_turret_traversing",
decimals: 3,
units: "plus",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 3,
units: "plus",
},
{
name: "dispersion_shooting",
decimals: 3,
units: "plus",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 3,
units: "plus",
},
{
name: "dispersion_gun_damaged",
decimals: 1,
units: "x",
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 1,
units: "x",
},
// { toy: "aim_time" },
@@ -273,15 +282,14 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
name: "maneuverability",
// render: CharacteristicsGroupRender.Statistical,
order: [
{ label: "speeds" },
{ name: "speed_forward", units: "km_h", indent: true },
{ name: "speed_backward", units: "km_h", indent: true },
{ name: "speed_forward", units: "km_h" },
{ name: "speed_backward", units: "km_h" },
{
name: "weight",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 1,
units: "t",
ranking: CharacteristicRanking.LowerIsBetter,
},
{ name: "engine_power", units: "bhp" },
{ name: "power_to_weight", decimals: 1, units: "bhp_t" },
@@ -289,54 +297,78 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
{ label: "power_to_weight_on_terrain" },
{
name: "power_to_weight_hard",
indent: true,
decimals: 1,
units: "bhp_t",
indent: true,
},
{
name: "power_to_weight_medium",
indent: true,
decimals: 1,
units: "bhp_t",
indent: true,
},
{
name: "power_to_weight_soft",
indent: true,
decimals: 1,
units: "bhp_t",
indent: true,
},
// { name: "brake_force", decimals: 1, units: "kN" },
{ label: "hull_traverse_speeds" },
{ name: "hull_traverse_speed_hard", units: "deg_s", indent: true },
{ name: "hull_traverse_speed_medium", units: "deg_s", indent: true },
{ name: "hull_traverse_speed_soft", units: "deg_s", indent: true },
{
name: "hull_traverse_speed_hard",
indent: true,
units: "deg_s",
},
{
name: "hull_traverse_speed_medium",
indent: true,
units: "deg_s",
},
{
name: "hull_traverse_speed_soft",
indent: true,
units: "deg_s",
},
{ name: "turret_traverse_speed", units: "deg_s" },
{ name: "gun_traverse_speed", units: "deg_s" },
{ label: "terrain_coefficient" },
{ name: "hard_terrain_coefficient", decimals: 0, indent: true },
{ name: "medium_terrain_coefficient", decimals: 0, indent: true },
{ name: "soft_terrain_coefficient", decimals: 0, indent: true },
{
name: "hard_terrain_coefficient",
indent: true,
decimals: 0,
},
{
name: "medium_terrain_coefficient",
indent: true,
decimals: 0,
},
{
name: "soft_terrain_coefficient",
indent: true,
decimals: 0,
},
{ label: "raw_terrain_coefficient" },
{
name: "hard_terrain_coefficient_raw",
decimals: 2,
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 2,
},
{
name: "medium_terrain_coefficient_raw",
decimals: 2,
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 2,
},
{
name: "soft_terrain_coefficient_raw",
decimals: 2,
indent: true,
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 2,
},
{ toy: "traverse" },
@@ -354,9 +386,9 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
{ name: "health", units: "hp" },
{
name: "fire_chance",
ranking: CharacteristicRanking.LowerIsBetter,
decimals: 0,
units: "percentage",
ranking: CharacteristicRanking.LowerIsBetter,
},
{ name: "crew_count" },
// { name: "fire_rate", units: "hp_s" },
@@ -377,51 +409,51 @@ export const characteristicsGroups: CharacteristicsGroup[] = [
{ label: "camouflages" },
{
name: "camouflage",
indent: true,
decimals: 2,
units: "percentage",
indent: true,
},
{
name: "camouflage_moving",
indent: true,
decimals: 2,
units: "percentage",
indent: true,
},
{
name: "camouflage_shooting_still",
indent: true,
decimals: 2,
units: "percentage",
indent: true,
},
{
name: "camouflage_shooting_moving",
indent: true,
decimals: 2,
units: "percentage",
indent: true,
},
{
name: "camouflage_on_fire",
indent: true,
decimals: 2,
units: "percentage",
indent: true,
},
{ toy: "view_range" },
{
name: "width",
units: "m",
ranking: CharacteristicRanking.LowerIsBetter,
units: "m",
},
{
name: "height",
units: "m",
ranking: CharacteristicRanking.LowerIsBetter,
units: "m",
},
{
name: "length",
units: "m",
ranking: CharacteristicRanking.LowerIsBetter,
units: "m",
},
],
},
+2
View File
@@ -1,5 +1,6 @@
import type { ReactNode } from "react";
import {
AssaultShellsToy,
FlexibilityToy,
ReloadToy,
RicochetToy,
@@ -18,4 +19,5 @@ export const toys: Record<string, (props: ToyProps) => ReactNode> = {
reload: ReloadToy,
view_range: ViewRangeToy,
flexibility: FlexibilityToy,
assault_shells: AssaultShellsToy,
};
@@ -1,9 +1,10 @@
import { normalizeAngleRad } from "@blitzkit/core";
import type { PitchLimits, YawLimits } from "@blitzkit/protos";
import { clamp } from "lodash-es";
import { degToRad } from "three/src/math/MathUtils.js";
import { degToRad, radToDeg } from "three/src/math/MathUtils.js";
export const DEFAULT_PITCH_TRANSITION = 20;
// The game's default is 0.4 rad
export const DEFAULT_PITCH_TRANSITION = radToDeg(0.4);
export function applyPitchYawLimits(
pitch: number, // rad
@@ -27,5 +27,5 @@ export async function extractPackedIcon(texture: sharp.Sharp, sizes: number[]) {
);
}
return await texture.clone().extract({ left, top, width, height }).toBuffer();
return await texture.clone().extract({ left, top, width, height }).webp().toBuffer();
}
@@ -0,0 +1,54 @@
import sharp from "sharp";
import { vfs } from "../blitzkit/vfs";
import { extractPackedIcon } from "./extractPackedIcon";
import { parsePackedSpriteRect } from "./parsePackedSpriteRect";
// Route props that point at a sprite, for each way of reading one
export interface PackedSpriteProps {
packed: string;
}
export interface DiscreteSpriteProps {
descriptor: string;
texture: string;
}
// A standalone texture; the sprite rect lives in its RIFF `extr` chunk. Reads
// it the way the client does, as webp. Trimming is only a guess, so it is
// used solely for textures that carry no rect.
export async function readPackedSprite(path: string) {
const packed = await vfs.file(path);
const texture = sharp(packed);
const rect = parsePackedSpriteRect(packed);
if (rect === null) {
return new Uint8Array(await texture.trim().webp().toBuffer());
}
return new Uint8Array(await extractPackedIcon(texture, rect));
}
// A rect in a `.txt` descriptor (line 4) cut out of a shared atlas texture
export async function readDiscreteSprite(descriptor: string, texture: string) {
const rect = (await vfs.text(descriptor))
.split("\n")[4]
.split(" ")
.map(Number);
return new Uint8Array(
await extractPackedIcon(sharp(await vfs.file(texture)), rect)
);
}
// Sprites in the UI styles are named without an extension and are either a
// standalone texture or an entry of the `texture0` atlas next to them
export async function readStyleSprite(path: string) {
const packed = `${path}.packed.webp`;
if (await vfs.resolve(packed)) return await readPackedSprite(packed);
return await readDiscreteSprite(
`${path}.txt`,
`${path.split("/").slice(0, -1).join("/")}/texture0.packed.webp`
);
}
@@ -6,10 +6,12 @@ import {
} from "@blitzkit/core";
import type { BlitzEffectScript } from "@blitzkit/core/src/types/blitzEffectScript";
import { CrewType, type TankDefinition } from "@blitzkit/protos";
import { useMemo } from "react";
import { api } from "../api/dynamic";
import { characteristics } from "../config/characteristics";
import { defaultEqualizer } from "../config/equalizer";
import { Tankopedia } from "../stores/tankopedia";
import { augmentAttributes } from "../tankopedia/augments";
import { createTankState } from "../tankopedia/createTankState";
import type { TankState } from "../tankopedia/tankState";
import type {
@@ -152,6 +154,13 @@ export function computeCharacteristics(
}
}
const augments = augmentAttributes(tank, states.protagonist);
function augment(name: string, callback: (value: number) => void) {
if (!augments.has(name)) return;
for (const value of augments.get(name)!) callback(value);
}
const context = {
state: states.protagonist,
environment,
@@ -170,6 +179,7 @@ export function computeCharacteristics(
characteristic,
script,
augment,
} satisfies CharacteristicContext;
for (const name in characteristics) {
@@ -198,7 +208,12 @@ export function useCharacteristics(side: DuelSide) {
);
const environment = Tankopedia.use((state) => state.environment);
return computeCharacteristics({ protagonist: A, antagonist: B }, environment);
// A stable map, so what reads it only recomputes when the loadout changes
return useMemo(
() =>
computeCharacteristics({ protagonist: A, antagonist: B }, environment),
[A, B, environment],
);
}
export function computeDefaultCharacteristics(tank: TankDefinition) {
@@ -1,6 +1,9 @@
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readPackedSprite,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -13,8 +16,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
files.filter(
(flag) =>
flag.startsWith("flag_profile-stat_") &&
!flag.endsWith("@2x.packed.webp"),
),
!flag.endsWith("@2x.packed.webp")
)
);
for (const flag of circleFiles) {
@@ -23,17 +26,13 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
paths.push({
params: { id },
props: { path },
props: { packed: path },
});
}
return paths;
});
export async function GET({ props }: APIContext<{ path: string }>) {
const image = sharp(await vfs.file(props.path));
const content = await image.trim({ threshold: 100 }).toBuffer();
const bytes = new Uint8Array(content);
return new Response(bytes);
export async function GET({ props }: APIContext<PackedSpriteProps>) {
return new Response(await readPackedSprite(props.packed));
}
@@ -1,6 +1,9 @@
import sharp from "sharp";
import type { APIContext, GetStaticPathsItem } from "astro";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readPackedSprite,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -12,8 +15,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
.then((files) =>
files.filter(
(flag) =>
flag.startsWith("flag_filter_") && flag.endsWith("@2x.packed.webp"),
),
flag.startsWith("flag_filter_") && flag.endsWith("@2x.packed.webp")
)
);
for (const flag of fadedFiles) {
@@ -22,18 +25,13 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
paths.push({
params: { id },
props: { path },
props: { packed: path },
});
}
return paths;
});
export async function GET({ props }: APIContext<{ path: string }>) {
const bytes = await sharp(new Uint8Array(await vfs.file(props.path)))
.trim({ background: { r: 0, g: 0, b: 0, alpha: 0 }, threshold: 1 })
.webp()
.toBuffer();
return new Response(new Uint8Array(bytes));
export async function GET({ props }: APIContext<PackedSpriteProps>) {
return new Response(await readPackedSprite(props.packed));
}
@@ -1,7 +1,10 @@
import type { SquadBattleTypeStylesYaml } from "@blitzkit/core";
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readPackedSprite,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -9,26 +12,26 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
const paths: GetStaticPathsItem[] = [];
const gameTypeSelectorStyles = await vfs.yaml<SquadBattleTypeStylesYaml>(
`Data/UI/Screens/Lobby/Hangar/GameTypeSelector.yaml`,
`Data/UI/Screens/Lobby/Hangar/GameTypeSelector.yaml`
);
const squadBattleTypeStyles = await vfs.yaml<SquadBattleTypeStylesYaml>(
`Data/UI/Screens3/Lobby/Hangar/Squad/SquadBattleType.yaml`,
`Data/UI/Screens3/Lobby/Hangar/Squad/SquadBattleType.yaml`
);
const bannerMatches: { name: string; path: string }[] = [];
for (const match of gameTypeSelectorStyles.Prototypes[0].components.UIDataLocalBindingsComponent.data[1][2].matchAll(
/eGameMode\.(\w+) -> "~res:([^"]+)"/g,
/eGameMode\.(\w+) -> "~res:([^"]+)"/g
)) {
bannerMatches.push({ name: match[1], path: match[2] });
}
for (const match of squadBattleTypeStyles.Prototypes[0].components.UIDataLocalBindingsComponent.data[1][2].matchAll(
/eGameMode\.(\w+) -> "battleType\/([a-zA-Z]+)"/g,
/eGameMode\.(\w+) -> "battleType\/([a-zA-Z]+)"/g
)) {
const id = match[1];
const name = match[2];
let path = bannerMatches.find(
(bannerMatch) => bannerMatch.name.toLowerCase() === name.toLowerCase(),
(bannerMatch) => bannerMatch.name.toLowerCase() === name.toLowerCase()
)?.path;
if (path === undefined) {
@@ -37,18 +40,13 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
paths.push({
params: { id },
props: { path: `Data${path}.packed.webp` },
props: { packed: `Data${path}.packed.webp` },
});
}
return paths;
});
export async function GET({ props }: APIContext<{ path: string }>) {
const buffer = await sharp(await vfs.file(props.path))
.trim({ background: { r: 0, g: 0, b: 0, alpha: 0 } })
.toBuffer();
const bytes = new Uint8Array(buffer);
return new Response(bytes);
export async function GET({ props }: APIContext<PackedSpriteProps>) {
return new Response(await readPackedSprite(props.packed));
}
@@ -0,0 +1,35 @@
import type { APIContext, GetStaticPathsItem } from "astro";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readPackedSprite,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
const ROOT = "Data/Gfx/Lobby/icons/upgrades";
export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
const paths: GetStaticPathsItem[] = [];
const files = await vfs.dir(ROOT);
for (const file of files) {
if (file.endsWith("@2x.packed.webp")) continue;
const match = file.match(/^(.+)\.packed\.webp$/);
if (match === null) continue;
paths.push({
params: { id: match[1] },
props: { packed: `${ROOT}/${file}` },
});
}
return paths;
});
export async function GET({ props }: APIContext<PackedSpriteProps>) {
return new Response(await readPackedSprite(props.packed));
}
@@ -1,6 +1,9 @@
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readDiscreteSprite,
type DiscreteSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -11,8 +14,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
.dir("Data/Gfx/Shared/boosters")
.then((files) =>
files.filter(
(file) => !file.includes("@2x.txt") && !file.startsWith("texture0"),
),
(file) => !file.includes("@2x.txt") && !file.startsWith("texture0")
)
);
for (const file of boosterFiles) {
@@ -20,34 +23,20 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
if (id === undefined) continue;
const sizes = (await vfs.text(`Data/Gfx/Shared/boosters/${file}`))
.split("\n")[4]
.split(" ")
.map(Number);
paths.push({
params: { id },
props: { sizes },
props: {
descriptor: `Data/Gfx/Shared/boosters/${file}`,
texture: `Data/Gfx/Shared/boosters/texture0.packed.webp`,
},
});
}
return paths;
});
export async function GET({ props }: APIContext<{ sizes: number[] }>) {
const image = sharp(
await vfs.file(`Data/Gfx/Shared/boosters/texture0.packed.webp`),
export async function GET({ props }: APIContext<DiscreteSpriteProps>) {
return new Response(
await readDiscreteSprite(props.descriptor, props.texture)
);
const buffer = await image
.clone()
.extract({
left: props.sizes[0],
top: props.sizes[1],
width: props.sizes[2],
height: props.sizes[3],
})
.toBuffer();
const bytes = new Uint8Array(buffer);
return new Response(bytes);
}
@@ -1,14 +1,9 @@
import sharp from "sharp";
import { vfs } from "../../../core/blitzkit/vfs";
import { readPackedSprite } from "../../../core/blitz/readSprite";
export { getStaticPaths } from "../_index";
export async function GET() {
const buffer = await sharp(
await vfs.file("Data/Gfx/UI/Hangar/IconCamouflage.packed.webp"),
)
.trim()
.toBuffer();
return new Response(new Uint8Array(buffer));
return new Response(
await readPackedSprite("Data/Gfx/UI/Hangar/IconCamouflage.packed.webp"),
);
}
@@ -3,8 +3,7 @@ import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { api } from "../../../../api/dynamic";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import { extractPackedIcon } from "../../../../core/blitz/extractPackedIcon";
import { parsePackedSpriteRect } from "../../../../core/blitz/parsePackedSpriteRect";
import { readPackedSprite } from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -38,16 +37,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
});
export async function GET({ props }: APIContext<{ path: string }>) {
const path = (await vfs.resolve(`${props.path}@2x.packed.webp`))
const packed = (await vfs.resolve(`${props.path}@2x.packed.webp`))
? `${props.path}@2x.packed.webp`
: `${props.path}.packed.webp`;
const packed = await vfs.file(path);
const texture = sharp(packed);
const sizes = parsePackedSpriteRect(packed);
const image = sizes
? sharp(await extractPackedIcon(texture, sizes))
: texture;
const bytes = await image.webp().toBuffer();
return new Response(new Uint8Array(bytes));
return new Response(await readPackedSprite(packed));
}
@@ -1,9 +1,7 @@
import type { ConsumablesCommon } from "@blitzkit/core";
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import { extractPackedIcon } from "../../../../core/blitz/extractPackedIcon";
import { parsePackedSpriteRect } from "../../../../core/blitz/parsePackedSpriteRect";
import { readStyleSprite } from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -70,43 +68,5 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
});
export async function GET({ props }: APIContext<{ path: string }>) {
let buffer: Buffer;
if (await vfs.resolve(`Data/${props.path}.packed.webp`)) {
const packedBuffer = await vfs.file(`Data/${props.path}.packed.webp`);
const consumablesTexture = sharp(packedBuffer);
const sizes = parsePackedSpriteRect(packedBuffer);
if (sizes) {
buffer = await extractPackedIcon(consumablesTexture, sizes);
} else {
buffer = await consumablesTexture.trim({ threshold: 80 }).toBuffer();
}
} else {
const consumablesTexture = sharp(
await vfs.file(
`${`Data/${props.path}`
.split("/")
.slice(0, -1)
.join("/")}/texture0.packed.webp`,
),
);
const sizes = (await vfs.text(`Data/${props.path}.txt`))
.split("\n")[4]
.split(" ")
.map(Number);
buffer = await consumablesTexture
.clone()
.extract({
left: sizes[0],
top: sizes[1],
width: sizes[2],
height: sizes[3],
})
.toBuffer();
}
const bytes = new Uint8Array(buffer);
return new Response(bytes);
return new Response(await readStyleSprite(`Data/${props.path}`));
}
@@ -5,9 +5,8 @@ import {
} from "@blitzkit/core";
import locales from "@blitzkit/i18n/locales.json";
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import { vfs } from "../../../../core/blitzkit/vfs";
import { readPackedSprite } from "../../../../core/blitz/readSprite";
import { getStaticPaths as _getStaticPaths } from "../../_index";
const ICONS = [
@@ -36,13 +35,11 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
}
const glossary = await fetch(
`${WOTB_GLOSSARY_DOMAIN}/${locales.default}/${WOTB_GLOSSARY_PATH}`,
`${WOTB_GLOSSARY_DOMAIN}/${locales.default}/${WOTB_GLOSSARY_PATH}`
)
.then((response) => response.json() as Promise<BlitzGlossary>)
.then((glossary) =>
Object.values(glossary)
.entries()
.filter(([key]) => /^prx_season_\d+$/.test(`${key}`)),
Object.entries(glossary).filter(([key]) => /^prx_season_\d+$/.test(key))
);
for (const [id, item] of glossary) {
@@ -63,25 +60,12 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
export async function GET({
props,
}: APIContext<{ local: boolean; source: string }>) {
let buffer: Buffer;
if (props.local) {
buffer = await sharp(await vfs.file(props.source))
.trim()
.toBuffer();
} else {
const imageRaw = await fetch(props.source).then((response) =>
response.arrayBuffer(),
);
buffer = await sharp(imageRaw)
.trim({
threshold: 100,
background: { r: 0, g: 0, b: 0, alpha: 0 },
})
.toBuffer();
return new Response(await readPackedSprite(props.source));
}
const bytes = new Uint8Array(buffer);
return new Response(bytes);
// The glossary already serves these cropped
return new Response(
await fetch(props.source).then((response) => response.arrayBuffer())
);
}
@@ -1,7 +1,12 @@
import type { OptionalDevices } from "@blitzkit/core";
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readDiscreteSprite,
readPackedSprite,
type DiscreteSpriteProps,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -14,16 +19,18 @@ interface Mappings {
}[];
}
type Props = PackedSpriteProps | DiscreteSpriteProps;
export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
const paths: GetStaticPathsItem[] = [];
console.log("Building equipment icons...");
const optionalDevices = await vfs.xml<{ root: OptionalDevices }>(
`Data/XML/item_defs/vehicles/common/optional_devices.xml`,
`Data/XML/item_defs/vehicles/common/optional_devices.xml`
);
const mappings = await vfs.yaml<Mappings>(
`Data/UI/Screens3/Lobby/Inventory/OptionalDevices/OptionalDevicesItemImage.style.yaml`,
`Data/UI/Screens3/Lobby/Inventory/OptionalDevices/OptionalDevicesItemImage.style.yaml`
);
for (const optionalDeviceKey in optionalDevices.root) {
@@ -33,8 +40,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
const mapping = mappings.StyleSheets.find((mapping) =>
mapping.selectors.includes(
`.optional_device_item.${optionalDevice.icon} #Img`,
),
`.optional_device_item.${optionalDevice.icon} #Img`
)
);
if (!mapping) {
@@ -50,20 +57,14 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
paths.push({
params: { id: optionalDevice.id },
props: {
sizes: undefined,
source: `Data/${configPathWebp}.packed.webp`,
},
props: { packed: `Data/${configPathWebp}.packed.webp` },
});
} else {
const config = await vfs.text(`Data/${configPath}`);
const sizes = config.split("\n")[4].split(" ").map(Number);
paths.push({
params: { id: optionalDevice.id },
props: {
sizes,
source: `Data/Gfx/UI/InventoryIcons/Big/OptionalDevices/texture0.packed.webp`,
descriptor: `Data/${configPath}`,
texture: `Data/Gfx/UI/InventoryIcons/Big/OptionalDevices/texture0.packed.webp`,
},
});
}
@@ -72,26 +73,10 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
return paths;
});
export async function GET({
props,
}: APIContext<{ sizes?: number[]; source: string }>) {
const image = sharp(await vfs.file(props.source));
let buffer: Buffer;
if (props.sizes) {
buffer = await image
.extract({
left: props.sizes[0],
top: props.sizes[1],
width: props.sizes[2],
height: props.sizes[3],
})
.toBuffer();
} else {
buffer = await image.trim().toBuffer();
}
const bytes = new Uint8Array(buffer);
return new Response(bytes);
export async function GET({ props }: APIContext<Props>) {
return new Response(
"packed" in props
? await readPackedSprite(props.packed)
: await readDiscreteSprite(props.descriptor, props.texture)
);
}
@@ -1,6 +1,9 @@
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readPackedSprite,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -12,8 +15,8 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
.then((files) =>
files.filter(
(file) =>
!file.endsWith("@2x.packed.webp") && file.startsWith("vehicle"),
),
!file.endsWith("@2x.packed.webp") && file.startsWith("vehicle")
)
);
for (const file of files) {
@@ -23,18 +26,13 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
paths.push({
params: { id },
props: { path },
props: { packed: path },
});
}
return paths;
});
export async function GET({ props }: APIContext<{ path: string }>) {
const buffer = await sharp(await vfs.file(props.path))
.trim()
.toBuffer();
const bytes = new Uint8Array(buffer);
return new Response(bytes);
export async function GET({ props }: APIContext<PackedSpriteProps>) {
return new Response(await readPackedSprite(props.packed));
}
@@ -1,9 +1,7 @@
import type { ProvisionsCommon } from "@blitzkit/core";
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { extractPackedIcon } from "../../../../core/blitz/extractPackedIcon";
import { parsePackedSpriteRect } from "../../../../core/blitz/parsePackedSpriteRect";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import { readStyleSprite } from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -70,43 +68,5 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
});
export async function GET({ props }: APIContext<{ path: string }>) {
let buffer: Buffer;
if (await vfs.resolve(`Data/${props.path}.packed.webp`)) {
const packedBuffer = await vfs.file(`Data/${props.path}.packed.webp`);
const provisionsTexture = sharp(packedBuffer);
const sizes = parsePackedSpriteRect(packedBuffer);
if (sizes) {
buffer = await extractPackedIcon(provisionsTexture, sizes);
} else {
buffer = await provisionsTexture.trim({ threshold: 80 }).toBuffer();
}
} else {
const provisionsTexture = sharp(
await vfs.file(
`${`Data/${props.path}`
.split("/")
.slice(0, -1)
.join("/")}/texture0.packed.webp`,
),
);
const sizes = (await vfs.text(`Data/${props.path}.txt`))
.split("\n")[4]
.split(" ")
.map(Number);
buffer = await provisionsTexture
.clone()
.extract({
left: sizes[0],
top: sizes[1],
width: sizes[2],
height: sizes[3],
})
.toBuffer();
}
const bytes = new Uint8Array(buffer);
return new Response(bytes);
return new Response(await readStyleSprite(`Data/${props.path}`));
}
@@ -1,6 +1,9 @@
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readDiscreteSprite,
type DiscreteSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -13,38 +16,21 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
for (const file of files) {
const id = file.match(/(.+)_l\.txt/)![1];
const sizes = (
await vfs.text(`Data/Gfx/Shared/tank-supply/ammunition/big/${file}`)
)
.split("\n")[4]
.split(" ")
.map(Number);
paths.push({
params: { id },
props: { sizes },
props: {
descriptor: `Data/Gfx/Shared/tank-supply/ammunition/big/${file}`,
texture: `Data/Gfx/Shared/tank-supply/ammunition/big/texture0.packed.webp`,
},
});
}
return paths;
});
export async function GET({ props }: APIContext<{ sizes: number[] }>) {
const image = sharp(
await vfs.file(
`Data/Gfx/Shared/tank-supply/ammunition/big/texture0.packed.webp`,
),
export async function GET({ props }: APIContext<DiscreteSpriteProps>) {
return new Response(
await readDiscreteSprite(props.descriptor, props.texture)
);
const buffer = await image
.clone()
.extract({
left: props.sizes[0],
top: props.sizes[1],
width: props.sizes[2],
height: props.sizes[3],
})
.toBuffer();
const bytes = new Uint8Array(buffer);
return new Response(bytes);
}
@@ -1,7 +1,10 @@
import type { TankmenAvatar } from "@blitzkit/core";
import type { APIContext, GetStaticPathsItem } from "astro";
import sharp from "sharp";
import { mixStaticPaths } from "../../../../astro/mixStaticPaths";
import {
readPackedSprite,
type PackedSpriteProps,
} from "../../../../core/blitz/readSprite";
import { vfs } from "../../../../core/blitzkit/vfs";
import { getStaticPaths as _getStaticPaths } from "../../_index";
@@ -9,7 +12,7 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
const paths: GetStaticPathsItem[] = [];
const avatar = await vfs.xml<{ root: TankmenAvatar }>(
`Data/XML/item_defs/tankmen/avatar.xml`,
`Data/XML/item_defs/tankmen/avatar.xml`
);
for (const key in avatar.root.skills) {
@@ -20,18 +23,13 @@ export const getStaticPaths = mixStaticPaths(_getStaticPaths, async () => {
paths.push({
params: { id },
props: { path },
props: { packed: path },
});
}
return paths;
});
export async function GET({ props }: APIContext<{ path: string }>) {
const buffer = await sharp(await vfs.file(props.path))
.trim()
.toBuffer();
const bytes = new Uint8Array(buffer);
return new Response(bytes);
export async function GET({ props }: APIContext<PackedSpriteProps>) {
return new Response(await readPackedSprite(props.packed));
}
@@ -4,8 +4,7 @@ import {
type VehicleDefinitionList,
} from "@blitzkit/core";
import type { APIContext } from "astro";
import sharp from "sharp";
import { parsePackedSpriteRect } from "../../../../../core/blitz/parsePackedSpriteRect";
import { readPackedSprite } from "../../../../../core/blitz/readSprite";
import { vfs } from "../../../../../core/blitzkit/vfs";
export { getStaticPaths } from "../_index";
@@ -33,52 +32,11 @@ export async function GET({ props }: APIContext<{ id: number }>) {
const parameters = await vfs.yaml<TankParameters>(
`Data/3d/Tanks/Parameters/${nation}/${tankKey}.yaml`,
);
const bigPath = `Data/${parameters.resourcesPath.bigIconPath
const packed = `Data/${parameters.resourcesPath.bigIconPath
.replace(/~res:\//, "")
.replace(/\..+/, "")}.packed.webp`;
const big = await extractPackedTankIcon(await vfs.file(bigPath));
return new Response(big);
return new Response(await readPackedSprite(packed));
}
}
}
export async function extractPackedTankIcon(bytes: Uint8Array) {
const texture = sharp(bytes);
const spriteRect = parsePackedSpriteRect(bytes);
if (!spriteRect) {
throw new Error(`Missing RIFF sprite bounds`);
}
const [left, top, width, height] = spriteRect;
const bounds = [left, top, width, height];
if (!bounds.every(Number.isInteger)) {
throw new Error(`Invalid RIFF sprite bounds: ${bounds.join(" ")}`);
}
const metadata = await texture.metadata();
if (metadata.width === undefined || metadata.height === undefined) {
throw new Error(`Failed to read image dimensions`);
}
if (
left < 0 ||
top < 0 ||
width <= 0 ||
height <= 0 ||
left + width > metadata.width ||
top + height > metadata.height
) {
throw new Error(
`Out-of-bounds RIFF sprite: ${bounds.join(" ")} in ${metadata.width}x${metadata.height}`,
);
}
const buffer = await texture.extract({ left, top, width, height }).toBuffer();
const array = new Uint8Array(buffer);
return array;
}
@@ -4,8 +4,8 @@ import {
type VehicleDefinitionList,
} from "@blitzkit/core";
import type { APIContext } from "astro";
import { readPackedSprite } from "../../../../../core/blitz/readSprite";
import { vfs } from "../../../../../core/blitzkit/vfs";
import { extractPackedTankIcon } from "./big.webp";
export { getStaticPaths } from "../_index";
@@ -32,12 +32,11 @@ export async function GET({ props }: APIContext<{ id: number }>) {
const parameters = await vfs.yaml<TankParameters>(
`Data/3d/Tanks/Parameters/${nation}/${tankKey}.yaml`,
);
const bigPath = `Data/${parameters.resourcesPath.smallIconPath
const packed = `Data/${parameters.resourcesPath.smallIconPath
.replace(/~res:\//, "")
.replace(/\..+/, "")}.packed.webp`;
const big = await extractPackedTankIcon(await vfs.file(bigPath));
return new Response(big);
return new Response(await readPackedSprite(packed));
}
}
}
@@ -1,9 +1,9 @@
import { Soapstone } from "soapstone";
import type { CharacteristicName } from "../types/characteristics";
import type { RenderedCharacteristicName } from "../types/characteristics";
import { TankopediaSortDirection } from "./tankopediaPersistent";
export interface TankSort {
by: CharacteristicName | null;
by: RenderedCharacteristicName | null;
direction: TankopediaSortDirection;
}
@@ -0,0 +1,239 @@
import type {
AugmentGroup,
AugmentNode,
AugmentProgression,
AugmentRequirement,
} from "@blitzkit/protos";
import type { Vector2Tuple } from "three";
import { CellGrid } from "./cellGrid";
/**
* Follows how the game routes the connectors of its augment tree.
*
* Every node is placed by hand on a shared grid and the connectors are
* per-cell flags, same as the modules screen. Each requirement becomes an
* edge that is routed along one row and one column, never diagonally. The
* game's arrowheads are left out, the same as on the modules screen.
*/
export interface AugmentTreeCell {
// 1-based grid column (depth) and row
position: Vector2Tuple;
// Missing for empty cells that only carry a connector line
node?: AugmentNode;
// The final choice every branch ends in. Takes the cell its edges point at
group?: AugmentGroup;
// Line from the cell center to the left
left: boolean;
// Line from the cell center to the right
right: boolean;
// Line from the cell center up to the previous row
top: boolean;
// Line from the cell center down to the next row
bottom: boolean;
}
// A cell as the website shows it. The game lays the tree out left to right
// and the website top to bottom, so the game's depth becomes the row
export interface AugmentTreeDisplayCell {
// 1-based grid row (depth) and column
row: number;
column: number;
node?: AugmentNode;
group?: AugmentGroup;
north: boolean;
south: boolean;
west: boolean;
east: boolean;
}
// Source row and column, then target row and column
type Edge = readonly [
fromRow: number,
fromColumn: number,
toRow: number,
toColumn: number,
verticalFirst: boolean,
];
function emptyCell(column: number, row: number) {
return {
position: [column, row],
left: false,
right: false,
top: false,
bottom: false,
} satisfies AugmentTreeCell;
}
export function layoutAugmentTree({ nodes, group }: AugmentProgression) {
// Only placed nodes can have a line drawn from them
const byTechName = new Map(
nodes
.filter((node) => node.position !== undefined)
.map((node) => [node.tech_name, node]),
);
const edges: Edge[] = [];
const connect = (
requires: AugmentRequirement[],
toRow: number,
toColumn: number,
) => {
for (const { tech_name, vertical_first } of requires) {
// Nothing to draw from a node the tank doesn't have
if (!byTechName.has(tech_name)) continue;
const from = byTechName.get(tech_name)!.position!;
edges.push([from.y, from.x, toRow, toColumn, vertical_first]);
}
};
for (const node of nodes) {
if (node.position === undefined) continue;
connect(node.requires, node.position.y, node.position.x);
}
if (group !== undefined) {
connect(group.requires, group.position!.y, group.position!.x);
}
const grid = new CellGrid<AugmentTreeCell>(emptyCell);
const { cellAt } = grid;
for (const node of nodes) {
if (node.position !== undefined) {
cellAt(node.position.x, node.position.y).node = node;
}
}
if (group !== undefined) {
cellAt(group.position!.x, group.position!.y).group = group;
}
// Cells strictly between two ends, which stay untouched here
const runHorizontally = (row: number, from: number, to: number) => {
const step = from < to ? 1 : -1;
for (let column = from + step; column !== to; column += step) {
const cell = cellAt(column, row);
cell.left = true;
cell.right = true;
}
};
const runVertically = (column: number, from: number, to: number) => {
const step = from < to ? 1 : -1;
for (let row = from + step; row !== to; row += step) {
const cell = cellAt(column, row);
cell.top = true;
cell.bottom = true;
}
};
// Where a run turns, joining the vertical and horizontal pieces
const corner = (
row: number,
column: number,
otherRow: number,
otherColumn: number,
) => {
const cell = cellAt(column, row);
if (row <= otherRow) cell.bottom = true;
else cell.top = true;
if (column <= otherColumn) cell.right = true;
else cell.left = true;
};
// Attaches the line to both nodes
const attach = (
fromRow: number,
fromColumn: number,
toRow: number,
toColumn: number,
verticalFirst: boolean,
) => {
const from = cellAt(fromColumn, fromRow);
const to = cellAt(toColumn, toRow);
if (fromColumn === toColumn) {
if (fromRow < toRow) {
from.bottom = true;
to.top = true;
} else {
from.top = true;
to.bottom = true;
}
} else if (fromRow === toRow) {
if (toColumn <= fromColumn) {
from.left = true;
to.right = true;
} else {
from.right = true;
to.left = true;
}
} else if (verticalFirst) {
if (fromRow < toRow) from.bottom = true;
else from.top = true;
if (toColumn <= fromColumn) to.right = true;
else to.left = true;
} else {
if (fromColumn < toColumn) from.right = true;
else from.left = true;
if (fromRow < toRow) to.top = true;
else to.bottom = true;
}
};
for (const [fromRow, fromColumn, toRow, toColumn, verticalFirst] of edges) {
// The client draws nothing for an edge that starts where it ends
if (fromRow === toRow && fromColumn === toColumn) continue;
// Touching ends are left to `attach`
if (fromRow === toRow) {
if (fromColumn !== toColumn)
runHorizontally(fromRow, fromColumn, toColumn);
} else if (fromColumn === toColumn) {
runVertically(fromColumn, fromRow, toRow);
} else if (verticalFirst) {
// Down the source column, then along the target row
runVertically(fromColumn, fromRow, toRow);
corner(toRow, fromColumn, fromRow, toColumn);
runHorizontally(toRow, fromColumn, toColumn);
} else {
// Along the source row, then down the target column
runHorizontally(fromRow, fromColumn, toColumn);
corner(fromRow, toColumn, toRow, fromColumn);
runVertically(toColumn, fromRow, toRow);
}
attach(fromRow, fromColumn, toRow, toColumn, verticalFirst);
}
return {
cells: grid.cells().map(
({ position: [column, row], node, group, left, right, top, bottom }) =>
({
row: column,
column: row,
node,
group,
north: left,
south: right,
west: top,
east: bottom,
} satisfies AugmentTreeDisplayCell),
),
rows: grid.columns,
columns: grid.rows,
};
}
+177
View File
@@ -0,0 +1,177 @@
import {
AugmentNodeType,
type AugmentNode,
type AugmentProgression,
type TankDefinition,
} from "@blitzkit/protos";
import type { TankState } from "./tankState";
function isAlternative(node: AugmentNode) {
return node.type === AugmentNodeType.AUGMENT_NODE_TYPE_ALTERNATIVE;
}
// Alternatives live in the final group, outside the grid
export function listAugmentNodes({ nodes, group }: AugmentProgression) {
return [...nodes, ...(group?.alternatives ?? [])];
}
// Standing in for the final group, which has no id of its own
export const AUGMENT_GROUP_ID = -1;
function directPrerequisites(
progression: AugmentProgression,
node: AugmentNode,
) {
const byTechName = new Map(
progression.nodes.map((other) => [other.tech_name, other.id]),
);
const requires = isAlternative(node)
? progression.group?.requires ?? []
: node.requires;
return requires.flatMap(({ tech_name }) => byTechName.get(tech_name) ?? []);
}
// Everything the given nodes stand on, the nodes themselves included
function foundations(progression: AugmentProgression, ids: number[]) {
const byId = new Map(
listAugmentNodes(progression).map((node) => [node.id, node]),
);
const found = new Set<number>();
const pending = [...ids];
while (pending.length > 0) {
const id = pending.pop()!;
const node = byId.get(id);
if (found.has(id) || node === undefined) continue;
found.add(id);
pending.push(...directPrerequisites(progression, node));
}
return found;
}
/**
* Like picking a module: choosing an augment installs everything on the way to
* it. Choosing one that is already installed steps back to it by removing
* what was built on top, and removes it too once nothing is left on top. The
* final group is a choice, so installing one alternative replaces the other.
*/
export function toggleAugment(
draft: Pick<TankState, "augments">,
progression: AugmentProgression,
id: number,
) {
const nodes = listAugmentNodes(progression);
const installed = new Set(draft.augments);
const alternatives = new Set(
progression.group?.alternatives.map((alternative) => alternative.id),
);
if (id === AUGMENT_GROUP_ID) {
const { group } = progression;
if (group === undefined) return;
const needed = directPrerequisites(progression, group.alternatives[0]);
if (needed.every((other) => installed.has(other))) {
// Already there, so back out of the choice
draft.augments = draft.augments.filter(
(other) => !alternatives.has(other),
);
} else {
for (const other of foundations(progression, needed))
installed.add(other);
draft.augments = [...installed];
}
return;
}
const node = nodes.find((candidate) => candidate.id === id);
if (node === undefined) return;
if (!installed.has(id)) {
for (const other of foundations(progression, [id])) installed.add(other);
if (alternatives.has(id)) {
for (const other of alternatives)
if (other !== id) installed.delete(other);
}
draft.augments = [...installed];
return;
}
// Everything installed that stands on this one, however far up
const above = new Set<number>();
let grew = true;
while (grew) {
grew = false;
for (const other of nodes) {
if (!installed.has(other.id) || above.has(other.id)) continue;
const stands = directPrerequisites(progression, other).some(
(prerequisite) => prerequisite === id || above.has(prerequisite),
);
if (!stands) continue;
above.add(other.id);
grew = true;
}
}
const removed = above.size > 0 ? above : new Set([id]);
draft.augments = draft.augments.filter((other) => !removed.has(other));
}
// Everything in the grid. The final group still needs a choice
export function createAugments(progression?: AugmentProgression) {
if (!progression) return [];
return progression.nodes.map((node) => node.id);
}
// Every value the installed augments give each attribute, keyed by the
// attribute's name without the `ATTRIBUTE_NAME_` prefix
export function augmentAttributes(
{ augment_progression }: TankDefinition,
state: TankState,
) {
const attributes = new Map<string, number[]>();
if (augment_progression === undefined) return attributes;
const installed = new Set(state.augments);
for (const node of listAugmentNodes(augment_progression)) {
if (!installed.has(node.id)) continue;
for (const { name, value } of node.attributes) {
const key = name.replace(/^ATTRIBUTE_NAME_/, "");
if (!attributes.has(key)) attributes.set(key, []);
attributes.get(key)!.push(value);
}
}
return attributes;
}
// Slots are the position of the shell in the gun's list, counted from 1
export function shellSlot(
gun: { shells: { id: number }[] },
shell: { id: number },
) {
return gun.shells.findIndex(({ id }) => id === shell.id) + 1;
}
@@ -0,0 +1,41 @@
import type { Vector2Tuple } from "three";
// A sparse grid that grows to fit whatever is placed on it, shared by the
// module and augment trees. Cells are indexed column first, then row
export class CellGrid<Cell extends { position: Vector2Tuple }> {
private readonly columnCells = new Map<number, Map<number, Cell>>();
// Highest 1-based column and row anything has been placed at
columns = 0;
rows = 0;
constructor(
private readonly createCell: (column: number, row: number) => Cell,
) {}
// An arrow, so it can be pulled off the grid and called on its own
cellAt = (column: number, row: number) => {
let cells = this.columnCells.get(column);
if (cells === undefined) {
cells = new Map();
this.columnCells.set(column, cells);
}
let cell = cells.get(row);
if (cell === undefined) {
cell = this.createCell(column, row);
cells.set(row, cell);
this.columns = Math.max(this.columns, column);
this.rows = Math.max(this.rows, row);
}
return cell;
};
cells() {
return [...this.columnCells.values()].flatMap((cells) => [
...cells.values(),
]);
}
}
@@ -1,6 +1,7 @@
import { createDefaultProvisions } from "@blitzkit/core";
import type { TankDefinition } from "@blitzkit/protos";
import { api } from "../api/dynamic";
import { createAugments } from "./augments";
import { createTankEquipment } from "./createTankEquipment";
import { createTankStatus } from "./createTankStatus";
import type { TankState } from "./tankState";
@@ -36,6 +37,7 @@ export function createTankState(tank: TankDefinition) {
model: models.models[tank.id],
consumables: [],
augments: createAugments(tank.augment_progression),
provisions: createDefaultProvisions(tank, gun, provisions, scripts),
camouflage: true,
cooldown_booster: 0,
@@ -1,30 +1,4 @@
import type {
CharacteristicContext,
CharacteristicScript,
} from "../types/characteristics";
function hullTraverseRotationCoefficient(
driverCoefficient: number,
virtuosoSkill: number,
script: CharacteristicScript,
) {
let coefficient = 1 + virtuosoSkill / 100;
let rotationSpeedFactor = 1;
script("protagonist", "StaticPhysicsAttrsModifier", (effect) => {
coefficient += (effect.bonusPercentage?.rotationSpeedFactor ?? 0) / 100;
});
script("protagonist", "ImprovedAfterburning", (effect) => {
rotationSpeedFactor *= effect.rotationSpeedFactor ?? 1;
});
script("protagonist", "AfterburnerAbility", (effect) => {
rotationSpeedFactor *= effect.bonusValues?.rotationSpeedFactor ?? 1;
});
return driverCoefficient * coefficient * rotationSpeedFactor;
}
import type { CharacteristicContext } from "../types/characteristics";
export function hullTraverseSpeed(
rawTerrainResistance: number,
@@ -38,6 +12,7 @@ export function hullTraverseSpeed(
gun,
progressive,
script,
augment,
environment,
characteristic,
} = context;
@@ -54,14 +29,32 @@ export function hullTraverseSpeed(
stockGun.weight;
const weight =
tank.weight + engine.weight + track.weight + turret.weight + gun.weight;
// Engine augments are flat, so this goes through the finished stat
const enginePower =
(engine.power * (characteristic("_engine_power_coefficient") as number)) /
stockEngine.power;
const rotationSpeed = hullTraverseRotationCoefficient(
progressive("driver"),
environment.skills.virtuoso ?? 0,
script,
);
(characteristic("engine_power") as number) / stockEngine.power;
const virtuosoSkill = environment.skills.virtuoso ?? 0;
let rotationCoefficient = 1 + virtuosoSkill / 100;
let rotationSpeedFactor = 1;
augment("HULL_ROTATION_SPEED_FACTOR_BONUS", (value) => {
rotationCoefficient += value;
});
script("protagonist", "StaticPhysicsAttrsModifier", (effect) => {
rotationCoefficient +=
(effect.bonusPercentage?.rotationSpeedFactor ?? 0) / 100;
});
script("protagonist", "ImprovedAfterburning", (effect) => {
rotationSpeedFactor *= effect.rotationSpeedFactor ?? 1;
});
script("protagonist", "AfterburnerAbility", (effect) => {
rotationSpeedFactor *= effect.bonusValues?.rotationSpeedFactor ?? 1;
});
const rotationSpeed =
progressive("driver") * rotationCoefficient * rotationSpeedFactor;
return (
enginePower *
@@ -1,9 +1,10 @@
import { ModuleType, type ModulePosition, type Unlock } from "@blitzkit/protos";
import type { Vector2Tuple } from "three";
import { CellGrid } from "./cellGrid";
/**
* Port of the game client's modules screen layout (wotblitz.exe 11.21,
* `ModulesTreeInfoCache` auto-layout + `TankModulesTreeController` arrows).
* Follows how the game lays out its modules screen: automatic placement and
* the arrows.
*
* Every node lives on one shared grid: depth is the column, and leaves take
* consecutive rows with each parent centered over its children. Connectors are
@@ -58,13 +59,6 @@ function key(unlock: Unlock) {
return `${unlock.type}:${unlock.id}`;
}
// Cells are indexed column first, then row
type CellGrid = Map<number, Map<number, ModuleTreeCell>>;
function flattenGrid(grid: CellGrid) {
return [...grid.values()].flatMap((column) => [...column.values()]);
}
function emptyCell(x: number, y: number) {
return {
position: [x, y],
@@ -93,7 +87,7 @@ function layoutSnake(placements: Placement[]) {
// The client takes this from whichever deep module sorts last
const lastOnFirstRow = deep.length > 0 && deep.at(-1)!.position[1] === 1;
const grid: CellGrid = new Map();
const grid = new CellGrid<ModuleTreeCell>(emptyCell);
for (const {
unlock,
@@ -113,17 +107,10 @@ function layoutSnake(placements: Placement[]) {
: offset + 1;
}
let columnCells = grid.get(column);
if (columnCells === undefined) {
columnCells = new Map();
grid.set(column, columnCells);
}
columnCells.set(row, { ...emptyCell(column, row), unlock });
grid.cellAt(column, row).unlock = unlock;
}
const cells = flattenGrid(grid);
const cells = grid.cells();
const width = Math.ceil(ordered.length / height);
for (const cell of cells) {
@@ -149,15 +136,11 @@ function layoutSnake(placements: Placement[]) {
}
}
let columns = width;
let rows = height;
for (const cell of cells) {
columns = Math.max(columns, cell.position[0]);
rows = Math.max(rows, cell.position[1]);
}
return { cells, columns, rows };
return {
cells,
columns: Math.max(width, grid.columns),
rows: Math.max(height, grid.rows),
};
}
function sortSiblings(unlocks: Unlock[]) {
@@ -259,29 +242,8 @@ export function layoutModuleTree(
if (isSnake) return layoutSnake([...placements.values()]);
const grid: CellGrid = new Map();
let columns = 0;
let rows = 0;
const cellAt = (x: number, y: number) => {
let columnCells = grid.get(x);
if (columnCells === undefined) {
columnCells = new Map();
grid.set(x, columnCells);
}
let cell = columnCells.get(y);
if (cell === undefined) {
cell = emptyCell(x, y);
columnCells.set(y, cell);
columns = Math.max(columns, x);
rows = Math.max(rows, y);
}
return cell;
};
const grid = new CellGrid<ModuleTreeCell>(emptyCell);
const { cellAt } = grid;
for (const {
unlock,
@@ -316,5 +278,5 @@ export function layoutModuleTree(
}
}
return { cells: flattenGrid(grid), columns, rows };
return { cells: grid.cells(), columns: grid.columns, rows: grid.rows };
}
@@ -2,7 +2,7 @@ import { characteristics } from "../config/characteristics";
import { characteristicsGroups } from "../config/characteristicsGroups";
import {
CharacteristicType,
type CharacteristicName,
type RenderedCharacteristicName,
} from "../types/characteristics";
const sortableCharacteristicTypes = new Set<CharacteristicType>([
@@ -11,9 +11,11 @@ const sortableCharacteristicTypes = new Set<CharacteristicType>([
CharacteristicType.Interval,
]);
export const sortableCharacteristics = new Set<CharacteristicName>();
export const sortableCharacteristics = new Set<RenderedCharacteristicName>();
for (const group of characteristicsGroups) {
if (!group.sortable) continue;
for (const config of group.order) {
if (!("name" in config)) continue;
@@ -18,6 +18,7 @@ export interface TankState {
consumables: number[];
provisions: number[];
augments: number[];
camouflage: boolean;
cooldown_booster: number;
}
+14 -1
View File
@@ -65,6 +65,10 @@ export interface CharacteristicContext {
): ReturnType<Characteristic["compute"]>;
script: CharacteristicScript;
// Like scripts, but for each value the installed augments give an attribute,
// named without the `ATTRIBUTE_NAME_` prefix
augment(name: string, callback: (value: number) => void): void;
}
export type CrewStatRole = "commander" | "loader" | "gunner" | "driver";
@@ -83,6 +87,11 @@ export enum CharacteristicRanking {
}
export type CharacteristicName = keyof typeof characteristics;
// The ones with strings; underscored characteristics are compute time only
export type RenderedCharacteristicName = Exclude<
CharacteristicName,
`_${string}`
>;
export type CharacteristicReturnType = ReturnType<Characteristic["compute"]>;
export type ComputedCharacteristics = Map<
@@ -91,7 +100,7 @@ export type ComputedCharacteristics = Map<
>;
export interface CharacteristicRenderConfig {
name: CharacteristicName;
name: RenderedCharacteristicName;
decimals?: number;
units?: keyof Strings["units"];
@@ -108,6 +117,8 @@ export interface CharacteristicRenderConfig {
export interface ToyRenderConfig {
toy: string;
// Only shown when this characteristic is computed for the tank
requires?: CharacteristicName;
}
export interface LabelRenderConfig {
@@ -118,5 +129,7 @@ export type ToyName = keyof typeof toys;
export type CharacteristicsGroup = {
name: string;
// Groups that only some tanks have are no use as a sort key
sortable?: boolean;
order: (CharacteristicRenderConfig | LabelRenderConfig | ToyRenderConfig)[];
};