feat: transition to protobug

packages/core/src/blitzkit/averageDefinitions/index.ts

@@ -1,41 +1,6 @@
-import { decodeProtobuf } from '../../protobuf/decodeProtobuf';
-import { BlitzkitStats } from '../../statistics';
+import { AverageDefinitions } from '../../protos';
 import { asset } from '../asset';
 
-export interface AverageDefinitionsEntry {
-  mu: BlitzkitStats;
-  sigma: BlitzkitStats;
-  r: BlitzkitStats;
-  samples: Samples;
-}
-
-export interface AverageDefinitionsEntrySubPartial {
-  mu: Partial<BlitzkitStats>;
-  sigma: Partial<BlitzkitStats>;
-  r: Partial<BlitzkitStats>;
-  samples: Samples;
-}
-
-export interface AverageDefinitionsEntryWithId extends AverageDefinitionsEntry {
-  id: number;
-}
-
-export interface AverageDefinitions {
-  averages: Record<number, AverageDefinitionsEntry>;
-  samples: Samples;
-  time: number;
-}
-
-export interface Samples {
-  d_1: number;
-  d_7: number;
-  d_30: number;
-  d_60: number;
-  d_90: number;
-  d_120: number;
-  total: number;
-}
-
 export interface AverageDefinitionsManifest {
   version: 1;
   /**
@@ -44,30 +9,18 @@ export interface AverageDefinitionsManifest {
   latest: number;
 }
 
-export const averageDefinitions = fetch(asset('averages/manifest.json'), {
-  cache: 'no-store',
-})
-  .then((response) => response.json() as Promise<AverageDefinitionsManifest>)
-  .then((manifest) => fetch(asset(`averages/${manifest.latest}.pb`)))
-  .then((response) => response.arrayBuffer())
-  .then((buffer) =>
-    decodeProtobuf<AverageDefinitions>(
-      'average_definitions',
-      'blitzkit.AverageDefinitions',
-      new Uint8Array(buffer),
-    ),
+export async function fetchAverageDefinitions() {
+  const manifestResponse = await fetch(asset('averages/manifest.json'));
+  const manifestJson =
+    (await manifestResponse.json()) as AverageDefinitionsManifest;
+  const averageDefinitionsResponse = await fetch(
+    asset(`averages/${manifestJson.latest}.pb`),
   );
+  const averageDefinitionsBuffer =
+    await averageDefinitionsResponse.arrayBuffer();
+  const averageDefinitionsArray = new Uint8Array(averageDefinitionsBuffer);
 
-export const averageDefinitionsArray = averageDefinitions.then((data) =>
-  Object.entries(data.averages)
-    .map(
-      ([key, value]) =>
-        ({
-          id: Number(key),
-          ...(value as AverageDefinitionsEntry),
-        }) satisfies AverageDefinitionsEntryWithId,
-    )
-    .filter((tank) => tank.mu.battles > 0),
-);
+  return AverageDefinitions.deserializeBinary(averageDefinitionsArray);
+}
 
 export * from './constants';

packages/core/src/blitzkit/reviews.ts

@@ -1,26 +1,10 @@
-import { decodeProtobuf } from '../protobuf';
+import { Reviews } from '../protos';
 import { asset } from './asset';
 
-export interface Reviews {
-  reviews: Record<number, Review>;
-}
+export async function fetchReviews() {
+  const response = await fetch(asset('definitions/reviews.pb'));
+  const buffer = await response.arrayBuffer();
+  const array = new Uint8Array(buffer);
 
-interface Review {
-  last_updated: number;
-  videos?: Video[];
+  return Reviews.deserializeBinary(array);
 }
-
-export interface Video {
-  id: string;
-  author: string;
-}
-
-export const reviews = fetch(asset('definitions/reviews.pb'))
-  .then((response) => response.arrayBuffer())
-  .then((buffer) =>
-    decodeProtobuf<Reviews>(
-      'reviews',
-      'blitzkit.Reviews',
-      new Uint8Array(buffer),
-    ),
-  );

packages/core/src/blitzkit/tankDefinitions/index.ts

@@ -1,224 +1,12 @@
-import { Vector2Tuple } from 'three';
+import { TankDefinitions } from '../../protos';
 import { asset } from '../asset';
-import { fetchCdonLz4 } from '../fetchCdonLz4';
 
-export enum TankClass {
-  Unspecified,
-  Light,
-  Medium,
-  Heavy,
-  TankDestroyer,
-}
-export enum TankType {
-  Unspecified,
-  Researchable,
-  Premium,
-  Collector,
-}
+export async function fetchTankDefinitions() {
+  const response = await fetch(asset('definitions/tanks.pb'));
+  const buffer = await response.arrayBuffer();
+  const array = new Uint8Array(buffer);
 
-export enum ShellType {
-  Unspecified,
-  AP,
-  APCR,
-  HEAT,
-  HE,
-}
-
-export enum CrewType {
-  Unspecified,
-  Commander,
-  Radioman,
-  Gunner,
-  Driver,
-  Loader,
-}
-
-export type TankDefinitions = Record<number, TankDefinition>;
-export enum ModuleType {
-  Unspecified,
-  Vehicle,
-  Engine,
-  Tracks,
-  Turret,
-  Gun,
-}
-
-export interface Unlock {
-  type: ModuleType;
-  id: number;
-  cost: {
-    // string being the season coins
-    type: 'xp' | string;
-    value: number;
-  };
-}
-export interface Crew {
-  type: CrewType;
-  count?: number;
-  substitute?: CrewType[];
-}
-export type ModuleDefinition =
-  | TrackDefinition
-  | EngineDefinition
-  | TurretDefinition
-  | GunDefinition;
-export interface TankDefinition {
-  id: number;
-  roles: Record<number, number>;
-  description?: string;
-  fixed_camouflage: boolean;
-  camouflages: number[];
-  ancestors: number[];
-  successors: number[];
-  crew: Crew[];
-  health: number;
-  nation: string;
-  name: string;
-  nameFull?: string;
-  type: TankType;
-  max_consumables: number;
-  max_provisions: number;
-  tier: Tier;
-  class: TankClass;
-  testing: boolean;
-  deprecated: boolean;
-  turrets: TurretDefinition[];
-  engines: EngineDefinition[];
-  tracks: TrackDefinition[];
-  price: TankPrice;
-  xp?: number;
-  speed_forwards: number;
-  speed_backwards: number;
-  camouflage_still: number;
-  camouflage_moving: number;
-  camouflage_onFire: number;
-  equipment_preset: string;
-  weight: number;
-}
-export interface TrackDefinition {
-  id: number;
-  tier: Tier;
-  name: string;
-  weight: number;
-  traverse_speed: number;
-  xp?: number;
-  dispersion_move: number;
-  dispersion_traverse: number;
-  resistance_hard: number;
-  resistance_medium: number;
-  resistance_soft: number;
-  unlocks?: Unlock[];
-}
-export interface EngineDefinition {
-  id: number;
-  name: string;
-  xp?: number;
-  tier: Tier;
-  fire_chance: number;
-  power: number;
-  weight: number;
-  unlocks?: Unlock[];
-}
-export type TankPrice = {
-  type: TankPriceType;
-  value: number;
-};
-enum TankPriceType {
-  Unspecified,
-  Credits,
-  Gold,
-}
-export interface TurretDefinition {
-  health: number;
-  view_range: number;
-  traverse_speed: number;
-  xp?: number;
-  id: number;
-  name: string;
-  tier: Tier;
-  guns: GunDefinition[];
-  weight: number;
-  unlocks?: Unlock[];
-}
-export type GunDefinition =
-  | GunDefinitionRegular
-  | GunDefinitionAutoLoader
-  | GunDefinitionAutoReloader;
-interface GunDefinitionBase {
-  rotation_speed: number;
-  xp?: number;
-  weight: number;
-  id: number;
-  name: string;
-  tier: Tier;
-  shells: ShellDefinition[];
-  camouflage_loss: number;
-  aim_time: number;
-  dispersion_base: number;
-  dispersion_traverse: number;
-  dispersion_shot: number;
-  dispersion_damaged: number;
-  unlocks?: Unlock[];
-}
-interface GunDefinitionRegular {
-  gun: GunDefinitionBase;
-  regular: GunDefinitionRegularProperties;
-}
-interface GunDefinitionRegularProperties {
-  reload: number;
-}
-interface GunDefinitionAutoLoader {
-  gun: GunDefinitionBase;
-  auto_loader: GunDefinitionAutoLoaderProperties;
-}
-interface GunDefinitionAutoLoaderProperties {
-  reload: number;
-  intra_clip: number;
-  count: number;
-}
-interface GunDefinitionAutoReloader {
-  gun: GunDefinitionBase;
-  auto_reloader: GunDefinitionAutoReloaderProperties;
-}
-interface GunDefinitionAutoReloaderProperties {
-  reload: number[];
-  intraClip: number;
-  count: number;
-}
-export interface ShellDefinition {
-  id: number;
-  name: string;
-  velocity: number;
-  armor_damage: number;
-  module_damage: number;
-  caliber: number;
-  icon: string;
-  penetration: number | Vector2Tuple;
-  type: ShellType;
-  normalization?: number;
-  ricochet?: number;
-  explosion_radius?: number;
-}
-
-export const tankDefinitions = fetchCdonLz4<TankDefinitions>(
-  asset('definitions/tanks.cdon.lz4'),
-);
-
-export const tankDefinitionsArray = tankDefinitions.then((tanks) =>
-  Object.values(tanks),
-);
-export enum Tier {
-  Unspecified,
-  I,
-  II,
-  III,
-  IV,
-  V,
-  VI,
-  VII,
-  VIII,
-  IX,
-  X,
+  return TankDefinitions.deserializeBinary(array);
 }
 
 export * from './constants';

packages/core/src/index.ts

@@ -1,11 +1,11 @@
 export * from './blitz';
 export * from './blitzkit';
+export * from './protos';
 // export * from './blitzstars';
 // export * from './databases';
 export * from './imgur';
 export * from './math';
 export * from './patreon';
-// export * from './protobuf';
 export * from './statistics';
 // export * from './streams';
 // export * from './types';

packages/core/src/protobuf/decodeProtobuf.ts

@@ -1,9 +0,0 @@
-import { lookupProtobufType, ProtoSource } from './lookupProtobufType';
-
-export function decodeProtobuf<Type>(
-  source: ProtoSource,
-  type: string,
-  data: Uint8Array,
-) {
-  return lookupProtobufType(source, type).decode(data).toJSON() as Type;
-}

packages/core/src/protobuf/encodeProtobuf.ts

@@ -1,14 +0,0 @@
-import { lookupProtobufType, ProtoSource } from './lookupProtobufType';
-
-export function encodeProtobuf(
-  source: ProtoSource,
-  type: string,
-  data: Record<string, any>,
-) {
-  const message = lookupProtobufType(source, type);
-  const verification = message.verify(data);
-
-  if (verification !== null) throw new Error(verification);
-
-  return message.encode(message.create(data)).finish();
-}

packages/core/src/protobuf/encodeProtobufToBase64.ts

@@ -1,11 +0,0 @@
-import { encodeProtobuf } from './encodeProtobuf';
-import { ProtoSource } from './lookupProtobufType';
-
-export async function encodeProtobufToBase64(
-  source: ProtoSource,
-  type: string,
-  data: any,
-) {
-  const array = encodeProtobuf(source, type, data);
-  return Buffer.from(array).toString('base64');
-}

packages/core/src/protobuf/index.ts

@@ -1,4 +0,0 @@
-export * from './decodeProtobuf';
-export * from './encodeProtobuf';
-export * from './encodeProtobufToBase64';
-export * from './lookupProtobufType';

packages/core/src/protobuf/lookupProtobufType.ts

@@ -1,12 +0,0 @@
-import protobuf from 'protobufjs';
-import average_definitions from '../../protos/average_definitions.proto';
-import reviews from '../../protos/reviews.proto';
-import tank_definitions from '../../protos/tank_definitions.proto';
-
-export type ProtoSource = keyof typeof protos;
-
-const protos = { reviews, average_definitions, tank_definitions };
-
-export function lookupProtobufType(source: ProtoSource, type: string) {
-  return protobuf.parse(protos[source]).root.lookupType(type);
-}

packages/core/src/protos/index.ts

@@ -0,0 +1 @@
+export * from './generated';

packages/core/src/protos/raw/average_definitions.proto

@@ -0,0 +1,47 @@
+syntax = "proto3";
+
+package blitzkit;
+
+message AverageDefinitions {
+  map<uint32, AverageDefinitionsEntry> averages = 1;
+  Samples samples = 2;
+  uint64 time = 3;
+}
+
+message AverageDefinitionsEntry {
+  AverageDefinitionsAllStats mu = 1;
+  AverageDefinitionsAllStats sigma = 2;
+  AverageDefinitionsAllStats r = 3;
+  Samples samples = 4;
+}
+
+message AverageDefinitionsAllStats {
+  float battles = 1;
+  float capture_points = 2;
+  float damage_dealt = 3;
+  float damage_received = 4;
+  float dropped_capture_points = 5;
+  float frags = 6;
+  float frags8p = 7;
+  float hits = 8;
+  float losses = 9;
+  float max_frags = 10;
+  float max_xp = 11;
+  float shots = 12;
+  float spotted = 13;
+  float survived_battles = 14;
+  float win_and_survived = 15;
+  float wins = 16;
+  float xp = 17;
+  float battle_life_time = 18;
+}
+
+message Samples {
+  uint32 d_1 = 1;
+  uint32 d_7 = 2;
+  uint32 d_30 = 3;
+  uint32 d_60 = 4;
+  uint32 d_90 = 5;
+  uint32 d_120 = 6;
+  uint32 total = 7;
+}

packages/core/src/protos/raw/reviews.proto

@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package blitzkit;
+
+message Reviews {
+  map<uint32, Review> reviews = 1;
+}
+
+message Review {
+  float last_updated = 1;
+  repeated Video videos = 2;
+}
+
+message Video {
+  string id = 1;
+  string author = 2;
+}

packages/core/src/protos/raw/tank_definitions.proto

@@ -0,0 +1,239 @@
+syntax = "proto3";
+
+package blitzkit;
+
+message TankDefinitions {
+  map<uint32, TankDefinition> tanks = 1;
+}
+
+message TankDefinition {
+  uint32 id = 1;
+  map<uint32, uint32> roles = 2;
+  optional string description = 3;
+  bool fixed_camouflage = 4;
+  repeated int32 camouflages = 5;
+  repeated int32 ancestors = 6;
+  repeated int32 successors = 7;
+  repeated Crew crew = 8;
+  uint32 health = 9;
+  string nation = 10;
+  string name = 11;
+  optional string name_full = 12;
+  TankType type = 13;
+  uint32 max_consumables = 14;
+  uint32 max_provisions = 15;
+  Tier 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 uint32 xp = 24;
+  float speed_forwards = 25;
+  float speed_backwards = 26;
+  float camouflage_still = 27;
+  float camouflage_moving = 28;
+  float camouflage_onFire = 29;
+  string equipment_preset = 30;
+  uint32 weight = 31;
+}
+
+enum TankPriceType {
+  TANK_PRICE_TYPE_UNSPECIFIED = 0;
+  TANK_PRICE_TYPE_CREDITS = 1;
+  TANK_PRICE_TYPE_GOLD = 2;
+}
+
+message TankPrice {
+  TankPriceType type = 1;
+  uint32 value = 2;
+}
+
+message TrackDefinition {
+  uint32 id = 1;
+  Tier tier = 2;
+  string name = 3;
+  uint32 weight = 4;
+  float traverse_speed = 5;
+  optional uint32 xp = 6;
+  float dispersion_move = 7;
+  float dispersion_traverse = 8;
+  float resistance_hard = 9;
+  float resistance_medium = 10;
+  float resistance_soft = 11;
+  repeated Unlock unlocks = 12;
+}
+
+message EngineDefinition {
+  uint32 id = 1;
+  string name = 2;
+  optional uint32 xp = 3;
+  Tier tier = 4;
+  optional float fire_chance = 5;
+  uint32 power = 6;
+  uint32 weight = 7;
+  repeated Unlock unlocks = 8;
+}
+
+message TurretDefinition {
+  uint32 id = 1;
+  uint32 health = 2;
+  uint32 view_range = 3;
+  float traverse_speed = 4;
+  optional uint32 xp = 5;
+  string name = 6;
+  uint32 tier = 7;
+  uint32 weight = 8;
+  repeated GunDefinition guns = 9;
+  repeated Unlock unlocks = 10;
+}
+
+message GunDefinition {
+  oneof gun_type {
+    GunDefinitionRegular regular = 1;
+    GunDefinitionAutoLoader auto_loader = 2;
+    GunDefinitionAutoReloader auto_reloader = 3;
+  }
+}
+
+message GunDefinitionRegular {
+  GunDefinitionBase gun = 1;
+  GunDefinitionRegularProperties regular = 2;
+}
+
+message GunDefinitionRegularProperties {
+  float reload = 1;
+}
+
+message GunDefinitionAutoLoader {
+  GunDefinitionBase gun = 1;
+  GunDefinitionAutoLoaderProperties auto_loader = 2;
+}
+
+message GunDefinitionAutoLoaderProperties {
+  float clip_reload = 1;
+  float intra_clip = 2;
+  float shell_count = 3;
+}
+
+message GunDefinitionAutoReloader {
+  GunDefinitionBase gun = 1;
+  GunDefinitionAutoReloaderProperties auto_reloader = 2;
+}
+
+message GunDefinitionAutoReloaderProperties {
+  repeated float shell_reloads = 1;
+  float intra_clip = 2;
+  float shell_count = 3;
+}
+
+message GunDefinitionBase {
+  uint32 id = 1;
+  float rotation_speed = 2;
+  optional uint32 xp = 3;
+  uint32 weight = 4;
+  string name = 5;
+  uint32 tier = 6;
+  repeated ShellDefinition shells = 7;
+  float camouflage_loss = 8;
+  float aim_time = 9;
+  float dispersion_base = 10;
+  float dispersion_traverse = 11;
+  float dispersion_shot = 12;
+  float dispersion_damaged = 13;
+  repeated Unlock unlocks = 14;
+}
+
+message ShellDefinition {
+  uint32 id = 1;
+  string name = 2;
+  uint32 velocity = 3;
+  uint32 armor_damage = 4;
+  uint32 module_damage = 5;
+  uint32 caliber = 6;
+  string icon = 7;
+  ShellPenetration penetration = 8;
+  ShellType type = 9;
+  uint32 normalization = 10;
+  uint32 ricochet = 11;
+  uint32 explosion_radius = 12;
+}
+
+enum ShellType {
+  SHELL_TYPE_UNSPECIFIED = 0;
+  SHELL_TYPE_AP = 1;
+  SHELL_TYPE_APCR = 2;
+  SHELL_TYPE_HEAT = 3;
+  SHELL_TYPE_HE = 4;
+}
+
+message ShellPenetration {
+  uint32 near = 1;
+  uint32 far = 2;
+}
+
+message Unlock {
+  int32 id = 1;
+  ModuleType type = 2;
+  UnlockCost cost = 3;
+}
+
+message UnlockCost {
+  string type = 1;
+  int32 value = 2;
+}
+
+enum ModuleType {
+  MODULE_TYPE_UNSPECIFIED = 0;
+  MODULE_TYPE_VEHICLE = 1;
+  MODULE_TYPE_ENGINE = 2;
+  MODULE_TYPE_TRACKS = 3;
+  MODULE_TYPE_TURRET = 4;
+  MODULE_TYPE_GUN = 5;
+}
+
+enum TankClass {
+  TANK_CLASS_UNSPECIFIED = 0;
+  TANK_CLASS_LIGHT = 1;
+  TANK_CLASS_MEDIUM = 2;
+  TANK_CLASS_HEAVY = 3;
+  TANK_CLASS_TANK_DESTROYER = 4;
+}
+
+enum Tier {
+  TIER_UNSPECIFIED = 0;
+  TIER_I = 1;
+  TIER_II = 2;
+  TIER_III = 3;
+  TIER_IV = 4;
+  TIER_V = 5;
+  TIER_VI = 6;
+  TIER_VII = 7;
+  TIER_VIII = 8;
+  TIER_IX = 9;
+  TIER_X = 10;
+}
+
+enum TankType {
+  TANK_TYPE_UNSPECIFIED = 0;
+  TANK_TYPE_RESEARCHABLE = 1;
+  TANK_TYPE_PREMIUM = 2;
+  TANK_TYPE_COLLECTOR = 3;
+}
+
+message Crew {
+  CrewType type = 1;
+  uint32 count = 2;
+  repeated CrewType substitute = 3;
+}
+
+enum CrewType {
+  CREW_TYPE_UNSPECIFIED = 0;
+  CREW_TYPE_COMMANDER = 1;
+  CREW_TYPE_RADIOMAN = 2;
+  CREW_TYPE_GUNNER = 3;
+  CREW_TYPE_DRIVER = 4;
+  CREW_TYPE_LOADER = 5;
+}