From 1e4e052999993ea87dd7e1e74864daeb172b002a Mon Sep 17 00:00:00 2001 From: Kalle <38327916+Sendouc@users.noreply.github.com> Date: Thu, 29 Oct 2026 20:43:52 +0200 Subject: [PATCH] Add weapon range variants, lethal ranges and special ranges to comp analyzer --- .../build-analyzer/analyzer-constants.ts | 16 + app/features/build-analyzer/analyzer-types.ts | 52 +- app/features/build-analyzer/core/stats.ts | 5 +- .../build-analyzer/data/weapon-params.ts | 494 +++++++++++- .../comp-analyzer/comp-analyzer-hooks.ts | 55 ++ .../comp-analyzer-search-params.test.ts | 14 + .../comp-analyzer-search-params.ts | 19 +- .../components/RangeVisualization.module.css | 110 +++ .../components/RangeVisualization.tsx | 710 ++++++++++++------ .../core/SpecialWeaponRange.test.ts | 23 + .../comp-analyzer/core/SpecialWeaponRange.ts | 49 +- .../comp-analyzer/core/WeaponRange.test.ts | 207 ++++- .../comp-analyzer/core/WeaponRange.ts | 246 ++++-- .../routes/comp-analyzer.module.css | 5 + .../comp-analyzer/routes/comp-analyzer.tsx | 47 +- .../components/CompGraphic.module.css | 35 + .../img-export/components/CompGraphic.tsx | 152 +++- ...2026-10-28-comp-analyzer-range-variants.md | 11 + changelog/2026-10-28-weapon-range-accuracy.md | 5 + locales/en/analyzer.json | 16 + scripts/create-analyzer-json.ts | 301 ++++++-- 21 files changed, 2145 insertions(+), 427 deletions(-) create mode 100644 app/features/comp-analyzer/routes/comp-analyzer.module.css create mode 100644 changelog/2026-10-28-comp-analyzer-range-variants.md create mode 100644 changelog/2026-10-28-weapon-range-accuracy.md diff --git a/app/features/build-analyzer/analyzer-constants.ts b/app/features/build-analyzer/analyzer-constants.ts index 1d44403c1..94ddf30e1 100644 --- a/app/features/build-analyzer/analyzer-constants.ts +++ b/app/features/build-analyzer/analyzer-constants.ts @@ -136,6 +136,22 @@ export const MAX_AP = 57; export const MAIN_SLOT_AP = 10; export const SUB_SLOT_AP = 3; +/** Ways of shooting a main weapon that fly differently, see `Range_Variants` of the weapon params */ +export const RANGE_VARIANT_KEYS = [ + "vertical", + "horizontal", + "tap", + "hold", + "long", + "short", + "ground", + "jump", + "charged", + "partialCharge", + "standard", + "turret", +] as const; + /** How many active players the opponent's team has more than the user's team */ export const TENACITY_PLAYER_DEFICITS = [1, 2, 3] as const; diff --git a/app/features/build-analyzer/analyzer-types.ts b/app/features/build-analyzer/analyzer-types.ts index 0c316df00..aa9ba7b7d 100644 --- a/app/features/build-analyzer/analyzer-types.ts +++ b/app/features/build-analyzer/analyzer-types.ts @@ -7,6 +7,7 @@ import type { } from "~/modules/in-game-lists/types"; import type { DAMAGE_TYPE, + RANGE_VARIANT_KEYS, TENACITY_PLAYER_DEFICITS, } from "./analyzer-constants"; import type { SPECIAL_EFFECTS } from "./core/specialEffects"; @@ -17,7 +18,7 @@ type Overwrites = Record< Partial> >; -export interface BaseWeaponStats { +export interface BaseWeaponStats extends RangeParams { /** Replacing default values of the ability json for this specific weapon */ overwrites?: Overwrites; /** Weapon's weight class. "Light/Heavy weapon" */ @@ -107,16 +108,42 @@ export interface BaseWeaponStats { /** How much ink a fully charged Splatana shot consumes? */ InkConsumeFullCharge_ChargeParam?: number; - // Range parameters for shooters/blasters/sloshers/splatlings/dualies + // Range parameters for chargers (direct distance values) + /** Charger full charge range */ + DistanceFullCharge?: number; + /** Charger max charge range */ + DistanceMaxCharge?: number; + /** Charger min charge range */ + DistanceMinCharge?: number; + + /** Which way of shooting the `Range_*` params describe, set when the weapon has `Range_Variants` */ + Range_VariantKey?: RangeVariantKey; + /** Other ways of shooting the weapon that fly differently (a roller's horizontal swing, a charger's tap shot) */ + Range_Variants?: RangeVariantParams[]; +} + +/** A way of shooting a main weapon with its own flight, e.g. a roller's vertical or horizontal swing */ +export type RangeVariantKey = (typeof RANGE_VARIANT_KEYS)[number]; + +export interface RangeVariantParams extends RangeParams { + Range_VariantKey: RangeVariantKey; +} + +/** How a main weapon's shot flies, see comp-analyzer's `WeaponRange` */ +export interface RangeParams { /** Initial bullet velocity */ Range_SpawnSpeed?: number; + /** Upward angle the bullet is shot at, in degrees (vertical roller swings) */ + Range_SpawnAngle?: number; + /** How far in front of the player the bullet spawns (Splatanas) */ + Range_SpawnOffsetZ?: number; /** Velocity cap after straight phase */ Range_GoStraightStateEndMaxSpeed?: number; /** Frames in straight phase */ Range_GoStraightToBrakeStateFrame?: number; /** Gravity constant (typically 0.016) */ Range_FreeGravity?: number; - /** Air resistance during free phase (rollers only, typically 0.1) */ + /** Air resistance during free phase (typically 0.02) */ Range_FreeAirResist?: number; /** Velocity multiplier (typically 2.0) */ Range_ZRate?: number; @@ -126,20 +153,16 @@ export interface BaseWeaponStats { Range_BrakeGravity?: number; /** Frames in brake phase (typically 4) */ Range_BrakeToFreeStateFrame?: number; - /** Max frames (Splatanas) or max bounces (Bloblobber) before projectile stops */ + /** Brake phase ends early once the bullet falls faster than this (typically -0.15) */ + Range_BrakeToFreeVelocityY?: number; + /** Max frames (Splatanas, blasters) or max bounces (Bloblobber) before projectile stops */ Range_BurstFrame?: number; /** Speed multiplier after bouncing (Bloblobber only) */ Range_BounceAfterMaxSpeed?: number; - - // Range parameters for chargers (direct distance values) - /** Charger full charge range */ - DistanceFullCharge?: number; - /** Charger max charge range */ - DistanceMaxCharge?: number; - /** Charger min charge range */ - DistanceMinCharge?: number; - - // Blaster specific + /** Straight line flight distance (a charger's tap shot) */ + Range_Distance?: number; + /** Damage by distance from the shooter (rollers, brushes) */ + Range_DistanceDamage?: DistanceDamage[]; /** Blaster explosion radius */ BlastRadius?: number; } @@ -212,6 +235,7 @@ export type SpecialWeaponParams = SpecialWeaponParamsObject[SpecialWeaponId] & { Range_BrakeAirResist?: number; Range_BrakeGravity?: number; Range_BrakeToFreeStateFrame?: number; + Range_BrakeToFreeVelocityY?: number; }; export type ParamsJson = { diff --git a/app/features/build-analyzer/core/stats.ts b/app/features/build-analyzer/core/stats.ts index 3bd9d2a86..5d96ebb50 100644 --- a/app/features/build-analyzer/core/stats.ts +++ b/app/features/build-analyzer/core/stats.ts @@ -34,6 +34,7 @@ import type { AbilityPoints, AnalyzedBuild, DamageType, + DistanceDamage, InkConsumeType, MainWeaponInkConsumptionStats, MainWeaponParams, @@ -551,7 +552,9 @@ function damages(args: StatFunctionInput): AnalyzedBuild["stats"]["damages"] { const value = args.mainWeaponParams[key as keyof MainWeaponParams]; if (Array.isArray(value)) { - for (const subValue of value.flat()) { + for (const subValue of ( + value as Array + ).flat()) { result.push({ type, value: subValue.Damage / 10, diff --git a/app/features/build-analyzer/data/weapon-params.ts b/app/features/build-analyzer/data/weapon-params.ts index 1f486a857..1ce8063a4 100644 --- a/app/features/build-analyzer/data/weapon-params.ts +++ b/app/features/build-analyzer/data/weapon-params.ts @@ -77,6 +77,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 1.667, Range_GoStraightToBrakeStateFrame: 3, Range_FreeGravity: 0.016, + Range_FreeAirResist: 0.02, Range_ZRate: 2, MoveSpeed: 0.06, DamageParam_ValueMax: 520, @@ -171,6 +172,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 0.8484, Range_GoStraightToBrakeStateFrame: 7, Range_FreeGravity: 0.016, + Range_BurstFrame: 11, Range_ZRate: 2, BlastRadius: 3.9, WeaponSpeedType: "Fast", @@ -201,6 +203,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 0.9131, Range_GoStraightToBrakeStateFrame: 9, Range_FreeGravity: 0.016, + Range_BurstFrame: 13, Range_ZRate: 2, BlastRadius: 3.385, MoveSpeed: 0.045, @@ -230,6 +233,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 1.0073, Range_GoStraightToBrakeStateFrame: 11, Range_FreeGravity: 0.016, + Range_BurstFrame: 15, Range_ZRate: 2, BlastRadius: 3.335, MoveSpeed: 0.04, @@ -259,6 +263,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 0.92715, Range_GoStraightToBrakeStateFrame: 8, Range_FreeGravity: 0.016, + Range_BurstFrame: 12, Range_ZRate: 2, BlastRadius: 4.085, WeaponSpeedType: "Fast", @@ -289,6 +294,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 1.13305, Range_GoStraightToBrakeStateFrame: 11, Range_FreeGravity: 0.016, + Range_BurstFrame: 15, Range_ZRate: 2, BlastRadius: 3.335, MoveSpeed: 0.055, @@ -318,6 +324,7 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 1.3426, Range_GoStraightToBrakeStateFrame: 11, Range_FreeGravity: 0.016, + Range_BurstFrame: 15, Range_ZRate: 2, BlastRadius: 3.325, MoveSpeed: 0.05, @@ -347,8 +354,21 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 1.65, Range_GoStraightToBrakeStateFrame: 7, Range_FreeGravity: 0.016, + Range_BurstFrame: 11, Range_ZRate: 2, BlastRadius: 2.035, + Range_VariantKey: "ground", + Range_Variants: [ + { + Range_SpawnSpeed: 0.92, + Range_GoStraightStateEndMaxSpeed: 0.9, + Range_GoStraightToBrakeStateFrame: 7, + Range_BurstFrame: 11, + Range_ZRate: 2, + BlastRadius: 3.635, + Range_VariantKey: "jump", + }, + ], MoveSpeed: 0.04, DamageParam_ValueDirect: 1250, BlastParam_DistanceDamage: [ @@ -416,6 +436,16 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 4, Range_FreeGravity: 0.016, Range_ZRate: 2, + Range_VariantKey: "tap", + Range_Variants: [ + { + Range_SpawnSpeed: 2.4, + Range_GoStraightStateEndMaxSpeed: 2.3032, + Range_GoStraightToBrakeStateFrame: 3, + Range_ZRate: 2, + Range_VariantKey: "hold", + }, + ], MoveSpeed: 0.066, MoveSpeedVariable: 0.072, DamageParam_ValueMax: 380, @@ -434,7 +464,46 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 6, Range_FreeGravity: 0.04, Range_FreeAirResist: 0.1, + Range_SpawnAngle: 7.5, + Range_DistanceDamage: [ + { + Damage: 1200, + Distance: 4.2, + }, + { + Damage: 500, + Distance: 12.43, + }, + { + Damage: 350, + Distance: 14.2, + }, + ], Range_ZRate: 2, + Range_VariantKey: "vertical", + Range_Variants: [ + { + Range_SpawnSpeed: 0.8, + Range_GoStraightToBrakeStateFrame: 6, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 1000, + Distance: 4.7, + }, + { + Damage: 500, + Distance: 6.7, + }, + { + Damage: 250, + Distance: 8.7, + }, + ], + Range_VariantKey: "horizontal", + }, + ], WeaponSpeedType: "Fast", BodyParam_Damage: 700, VerticalSwingUnitGroupParam_DamageParam_DamageMinValue: 350, @@ -451,7 +520,50 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 6, Range_FreeGravity: 0.04, Range_FreeAirResist: 0.1, + Range_SpawnAngle: 7.5, + Range_DistanceDamage: [ + { + Damage: 1500, + Distance: 5.2, + }, + { + Damage: 1000, + Distance: 8.2, + }, + { + Damage: 500, + Distance: 11.2, + }, + { + Damage: 400, + Distance: 13.2, + }, + ], Range_ZRate: 2, + Range_VariantKey: "vertical", + Range_Variants: [ + { + Range_SpawnSpeed: 1.05, + Range_GoStraightToBrakeStateFrame: 7, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 1500, + Distance: 4.2, + }, + { + Damage: 1000, + Distance: 7.2, + }, + { + Damage: 350, + Distance: 10.7, + }, + ], + Range_VariantKey: "horizontal", + }, + ], BodyParam_Damage: 1250, VerticalSwingUnitGroupParam_DamageParam_DamageMinValue: 400, VerticalSwingUnitGroupParam_DamageParam_DamageMaxValue: 1500, @@ -467,7 +579,54 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 9, Range_FreeGravity: 0.04, Range_FreeAirResist: 0.1, + Range_SpawnAngle: 7.5, + Range_DistanceDamage: [ + { + Damage: 1800, + Distance: 8.2, + }, + { + Damage: 1000, + Distance: 14, + }, + { + Damage: 500, + Distance: 19.53, + }, + { + Damage: 400, + Distance: 20.6, + }, + ], Range_ZRate: 2, + Range_VariantKey: "vertical", + Range_Variants: [ + { + Range_SpawnSpeed: 1.2, + Range_GoStraightToBrakeStateFrame: 9, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 1800, + Distance: 7.2, + }, + { + Damage: 1000, + Distance: 12.9, + }, + { + Damage: 500, + Distance: 16.49, + }, + { + Damage: 400, + Distance: 17.4, + }, + ], + Range_VariantKey: "horizontal", + }, + ], WeaponSpeedType: "Slow", BodyParam_Damage: 1250, VerticalSwingUnitGroupParam_DamageParam_DamageMinValue: 400, @@ -484,7 +643,46 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 9, Range_FreeGravity: 0.04, Range_FreeAirResist: 0.1, + Range_SpawnAngle: 7.5, + Range_DistanceDamage: [ + { + Damage: 1500, + Distance: 5.2, + }, + { + Damage: 1000, + Distance: 10.2, + }, + { + Damage: 400, + Distance: 16.2, + }, + ], Range_ZRate: 2, + Range_VariantKey: "vertical", + Range_Variants: [ + { + Range_SpawnSpeed: 0.94, + Range_GoStraightToBrakeStateFrame: 7, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 1500, + Distance: 4.2, + }, + { + Damage: 1000, + Distance: 7.2, + }, + { + Damage: 300, + Distance: 10.96923, + }, + ], + Range_VariantKey: "horizontal", + }, + ], BodyParam_Damage: 1250, VerticalSwingUnitGroupParam_DamageParam_DamageMinValue: 400, VerticalSwingUnitGroupParam_DamageParam_DamageMaxValue: 1500, @@ -501,7 +699,50 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 6, Range_FreeGravity: 0.04, Range_FreeAirResist: 0.1, + Range_SpawnAngle: 7.5, + Range_DistanceDamage: [ + { + Damage: 1200, + Distance: 5.2, + }, + { + Damage: 1000, + Distance: 7.7, + }, + { + Damage: 500, + Distance: 14.5, + }, + { + Damage: 400, + Distance: 16, + }, + ], Range_ZRate: 2, + Range_VariantKey: "vertical", + Range_Variants: [ + { + Range_SpawnSpeed: 1.1, + Range_GoStraightToBrakeStateFrame: 8, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 700, + Distance: 4.2, + }, + { + Damage: 500, + Distance: 6.2, + }, + { + Damage: 400, + Distance: 8.2, + }, + ], + Range_VariantKey: "horizontal", + }, + ], BodyParam_Damage: 700, VerticalSwingUnitGroupParam_DamageParam_DamageMinValue: 400, VerticalSwingUnitGroupParam_DamageParam_DamageMaxValue: 1200, @@ -515,6 +756,22 @@ export const weaponParams = { "1100": { Range_SpawnSpeed: 0.72, Range_GoStraightToBrakeStateFrame: 7, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 300, + Distance: 4.3, + }, + { + Damage: 250, + Distance: 6.8, + }, + { + Damage: 150, + Distance: 10.3, + }, + ], Range_ZRate: 2, WeaponSpeedType: "Fast", BodyParam_Damage: 200, @@ -527,6 +784,18 @@ export const weaponParams = { "1110": { Range_SpawnSpeed: 0.84, Range_GoStraightToBrakeStateFrame: 8, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 400, + Distance: 3.3, + }, + { + Damage: 200, + Distance: 14.3, + }, + ], Range_ZRate: 2, BodyParam_Damage: 250, SwingUnitGroupParam_DamageParam_DamageMinValue: 200, @@ -538,6 +807,18 @@ export const weaponParams = { "1120": { Range_SpawnSpeed: 1.05, Range_GoStraightToBrakeStateFrame: 9, + Range_FreeGravity: 0.04, + Range_FreeAirResist: 0.1, + Range_DistanceDamage: [ + { + Damage: 600, + Distance: 5, + }, + { + Damage: 310, + Distance: 13, + }, + ], Range_ZRate: 2, BodyParam_Damage: 300, SwingUnitGroupParam_DamageParam_DamageMinValue: 310, @@ -550,6 +831,13 @@ export const weaponParams = { DistanceFullCharge: 16.765, DistanceMaxCharge: 16.765, DistanceMinCharge: 9.261, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 9.261, + }, + ], MoveSpeedFullCharge: 0.03, DamageParam_ValueFullCharge: 1400, DamageParam_ValueMaxCharge: 800, @@ -563,6 +851,13 @@ export const weaponParams = { DistanceFullCharge: 24.037, DistanceMaxCharge: 24.037, DistanceMinCharge: 9.033, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 9.033, + }, + ], MoveSpeedFullCharge: 0.02, DamageParam_ValueFullCharge: 1600, DamageParam_ValueMaxCharge: 800, @@ -575,6 +870,13 @@ export const weaponParams = { DistanceFullCharge: 26.037, DistanceMaxCharge: 24.037, DistanceMinCharge: 9.033, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 9.033, + }, + ], MoveSpeedFullCharge: 0.02, DamageParam_ValueFullCharge: 1600, DamageParam_ValueMaxCharge: 800, @@ -586,6 +888,13 @@ export const weaponParams = { DistanceFullCharge: 29.05, DistanceMaxCharge: 29.05, DistanceMinCharge: 9.045, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 9.045, + }, + ], WeaponSpeedType: "Slow", MoveSpeedFullCharge: 0.015, DamageParam_ValueFullCharge: 1800, @@ -600,6 +909,13 @@ export const weaponParams = { DistanceFullCharge: 31.05, DistanceMaxCharge: 29.05, DistanceMinCharge: 9.045, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 9.045, + }, + ], WeaponSpeedType: "Slow", MoveSpeedFullCharge: 0.015, DamageParam_ValueFullCharge: 1800, @@ -626,6 +942,13 @@ export const weaponParams = { DistanceFullCharge: 19.804, DistanceMaxCharge: 18.804, DistanceMinCharge: 12.602, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 12.602, + }, + ], MoveSpeedFullCharge: 0.03, DamageParam_ValueFullCharge: 1800, DamageParam_ValueMaxCharge: 1300, @@ -639,6 +962,13 @@ export const weaponParams = { DistanceFullCharge: 26.037, DistanceMaxCharge: 24.037, DistanceMinCharge: 9.033, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: 9.033, + }, + ], MoveSpeedFullCharge: 0.068, DamageParam_ValueFullCharge: 680, DamageParam_ValueMaxCharge: 680, @@ -653,9 +983,11 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 2, Range_FreeGravity: 0.05, + Range_FreeAirResist: 0.12, Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, Range_ZRate: 2, MoveSpeed: 0.04, DamageParam_ValueDirectMax: 700, @@ -668,9 +1000,11 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 3, Range_FreeGravity: 0.05, + Range_FreeAirResist: 0.12, Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, Range_ZRate: 2, WeaponSpeedType: "Fast", MoveSpeed: 0.066, @@ -684,9 +1018,11 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 5, Range_FreeGravity: 0.06, + Range_FreeAirResist: 0.16, Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, MoveSpeed: 0.07, DamageParam_ValueDirectMax: 760, DamageParam_ValueDirectMin: 520, @@ -699,11 +1035,13 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 3, Range_FreeGravity: 0.015, + Range_FreeAirResist: 0.01, Range_BrakeAirResist: 0.01, Range_BrakeGravity: 0.01, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, Range_ZRate: 0.5, - Range_BounceAfterMaxSpeed: 0.6, + Range_BounceAfterMaxSpeed: 0.35, Range_BurstFrame: 3, MoveSpeed: 0.05, DamageParam_ValueDirect: 320, @@ -715,9 +1053,11 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 8, Range_FreeGravity: 0.05, + Range_FreeAirResist: 0.12, Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, Range_ZRate: 1, WeaponSpeedType: "Slow", MoveSpeed: 0.045, @@ -736,9 +1076,11 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 2, Range_FreeGravity: 0.05, + Range_FreeAirResist: 0.12, Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, Range_ZRate: 2, MoveSpeed: 0.04, DamageParam_ValueDirectMax: 480, @@ -826,6 +1168,15 @@ export const weaponParams = { Range_SpawnSpeed: 2.21915, Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 8, + Range_VariantKey: "long", + Range_Variants: [ + { + Range_SpawnSpeed: 1.1, + Range_GoStraightStateEndMaxSpeed: 1.027, + Range_GoStraightToBrakeStateFrame: 8, + Range_VariantKey: "short", + }, + ], MoveSpeed: 0.086, MoveSpeed_Charge: 0.086, MoveSpeedVariable: 0.05, @@ -916,6 +1267,16 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 3, Range_FreeGravity: 0.016, Range_ZRate: 2, + Range_VariantKey: "standard", + Range_Variants: [ + { + Range_SpawnSpeed: 3.2, + Range_GoStraightStateEndMaxSpeed: 3.197, + Range_GoStraightToBrakeStateFrame: 3, + Range_ZRate: 2, + Range_VariantKey: "turret", + }, + ], MoveSpeed: 0.06, DamageParam_ValueMax: 360, DamageParam_ValueMin: 180, @@ -960,6 +1321,16 @@ export const weaponParams = { Range_GoStraightToBrakeStateFrame: 4, Range_FreeGravity: 0.016, Range_ZRate: 2, + Range_VariantKey: "standard", + Range_Variants: [ + { + Range_SpawnSpeed: 3.312, + Range_GoStraightStateEndMaxSpeed: 2.23, + Range_GoStraightToBrakeStateFrame: 3, + Range_ZRate: 2, + Range_VariantKey: "turret", + }, + ], MoveSpeed: 0.07, DamageParam_ValueMax: 255, DamageParam_ValueMin: 128, @@ -991,6 +1362,7 @@ export const weaponParams = { Range_SpawnSpeed: 2.4, Range_GoStraightStateEndMaxSpeed: 2.3135, Range_GoStraightToBrakeStateFrame: 4, + Range_BrakeGravity: 0.07, Range_ZRate: 2, WeaponSpeedType: "Slow", MoveSpeed: 0.05, @@ -1033,7 +1405,24 @@ export const weaponParams = { Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, BlastRadius: 2.05, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_SpawnSpeed: 2.1, + Range_GoStraightStateEndMaxSpeed: 10, + Range_GoStraightToBrakeStateFrame: 4, + Range_FreeGravity: 0.15, + Range_FreeAirResist: 0.24, + Range_BrakeAirResist: 0.1, + Range_BrakeGravity: 0.04, + Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, + BlastRadius: 2.05, + Range_VariantKey: "partialCharge", + }, + ], MoveSpeedFullCharge: 0.068, DamageParam_ValueMax: 350, DamageParam_ValueMin: 300, @@ -1056,6 +1445,22 @@ export const weaponParams = { Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_SpawnSpeed: 1.45, + Range_GoStraightStateEndMaxSpeed: 10, + Range_GoStraightToBrakeStateFrame: 4, + Range_FreeGravity: 0.15, + Range_FreeAirResist: 0.24, + Range_BrakeAirResist: 0.1, + Range_BrakeGravity: 0.04, + Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, + Range_VariantKey: "partialCharge", + }, + ], WeaponSpeedType: "Fast", MoveSpeedFullCharge: 0.084, DamageParam_ValueMax: 450, @@ -1074,7 +1479,24 @@ export const weaponParams = { Range_BrakeAirResist: 0.1, Range_BrakeGravity: 0.04, Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, BlastRadius: 2.05, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_SpawnSpeed: 2.294, + Range_GoStraightStateEndMaxSpeed: 10, + Range_GoStraightToBrakeStateFrame: 4, + Range_FreeGravity: 0.15, + Range_FreeAirResist: 0.24, + Range_BrakeAirResist: 0.1, + Range_BrakeGravity: 0.04, + Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, + BlastRadius: 2.05, + Range_VariantKey: "partialCharge", + }, + ], WeaponSpeedType: "Slow", MoveSpeedFullCharge: 0.04, DamageParam_ValueMax: 350, @@ -1094,10 +1516,29 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 22, Range_FreeGravity: 0.02, + Range_FreeAirResist: 0, Range_BrakeAirResist: 0, Range_BrakeGravity: 0.0027, Range_BrakeToFreeStateFrame: 0, + Range_BrakeToFreeVelocityY: 0, + Range_SpawnOffsetZ: 0.8, Range_BurstFrame: 26, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_SpawnSpeed: 2.82, + Range_GoStraightToBrakeStateFrame: 5, + Range_FreeGravity: 0, + Range_FreeAirResist: 0, + Range_BrakeAirResist: 0, + Range_BrakeGravity: 0, + Range_BrakeToFreeStateFrame: 0, + Range_BrakeToFreeVelocityY: 0, + Range_SpawnOffsetZ: 1.4, + Range_BurstFrame: 6, + Range_VariantKey: "tap", + }, + ], MoveSpeed_Charge: 0.06, DamageParam_SplatanaVerticalDirect: 1400, DamageParam_SplatanaVertical: 700, @@ -1112,10 +1553,29 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 10, Range_FreeGravity: 0.1, + Range_FreeAirResist: 0, Range_BrakeAirResist: 0, Range_BrakeGravity: 0.02, Range_BrakeToFreeStateFrame: 0, + Range_BrakeToFreeVelocityY: 0, + Range_SpawnOffsetZ: 0.8, Range_BurstFrame: 14, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_SpawnSpeed: 3.3, + Range_GoStraightToBrakeStateFrame: 5, + Range_FreeGravity: 0, + Range_FreeAirResist: 0, + Range_BrakeAirResist: 0, + Range_BrakeGravity: 0, + Range_BrakeToFreeStateFrame: 0, + Range_BrakeToFreeVelocityY: 0, + Range_SpawnOffsetZ: 1.4, + Range_BurstFrame: 4, + Range_VariantKey: "tap", + }, + ], WeaponSpeedType: "Fast", MoveSpeed_Charge: 0.0945, DamageParam_SplatanaVerticalDirect: 1200, @@ -1131,10 +1591,29 @@ export const weaponParams = { Range_GoStraightStateEndMaxSpeed: 10, Range_GoStraightToBrakeStateFrame: 21, Range_FreeGravity: 0.1, + Range_FreeAirResist: 0, Range_BrakeAirResist: 0, Range_BrakeGravity: 0.02, Range_BrakeToFreeStateFrame: 0, + Range_BrakeToFreeVelocityY: 0, + Range_SpawnOffsetZ: 1.4, Range_BurstFrame: 21, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_SpawnSpeed: 2.3, + Range_GoStraightToBrakeStateFrame: 6, + Range_FreeGravity: 0, + Range_FreeAirResist: 0, + Range_BrakeAirResist: 0, + Range_BrakeGravity: 0, + Range_BrakeToFreeStateFrame: 0, + Range_BrakeToFreeVelocityY: 0, + Range_SpawnOffsetZ: 1.4, + Range_BurstFrame: 6, + Range_VariantKey: "tap", + }, + ], MoveSpeed_Charge: 0.055, DamageParam_SplatanaVerticalDirect: 1600, DamageParam_SplatanaVertical: 800, @@ -2372,6 +2851,7 @@ export const weaponParams = { Range_BrakeAirResist: 0.09, Range_BrakeGravity: 0.09, Range_BrakeToFreeStateFrame: 10, + Range_BrakeToFreeVelocityY: -0.1, Range_BlastRadius: 4, }, "2": { @@ -2618,10 +3098,14 @@ export const weaponParams = { }, ], BumpDamage: 400, - Range_SpawnSpeed: 3.36, - Range_GoStraightStateEndMaxSpeed: 2.232, - Range_GoStraightToBrakeStateFrame: 7, - Range_FreeGravity: 0.016, + Range_SpawnSpeed: 2, + Range_GoStraightToBrakeStateFrame: 8, + Range_FreeGravity: 0.05, + Range_FreeAirResist: 0.12, + Range_BrakeAirResist: 0.1, + Range_BrakeGravity: 0.04, + Range_BrakeToFreeStateFrame: 1, + Range_BrakeToFreeVelocityY: 10, Range_BlastRadius: 4.8, }, "13": { diff --git a/app/features/comp-analyzer/comp-analyzer-hooks.ts b/app/features/comp-analyzer/comp-analyzer-hooks.ts index fe915e663..9a7792611 100644 --- a/app/features/comp-analyzer/comp-analyzer-hooks.ts +++ b/app/features/comp-analyzer/comp-analyzer-hooks.ts @@ -1,3 +1,5 @@ +import type { RangeVariantKey } from "~/features/build-analyzer/analyzer-types"; +import type { MainWeaponId } from "~/modules/in-game-lists/types"; import { useSearchParam } from "~/modules/search-params/hooks"; import { compAnalyzerSearchParams } from "./comp-analyzer-search-params"; @@ -20,3 +22,56 @@ export function useTargetSubDefenseAp() { export function useTargetResAp() { return useSearchParam(compAnalyzerSearchParams, "res"); } + +/** Ways of shooting turned on in the range chart, per weapon */ +export function useRangeVariants() { + const [entries, setEntries] = useSearchParam( + compAnalyzerSearchParams, + "rangeVariants", + ); + + const enabledVariantKeys = (weaponId: MainWeaponId) => + entries.flatMap((entry) => { + const [entryWeaponId, key] = entry.split("-"); + return Number(entryWeaponId) === weaponId ? [key as RangeVariantKey] : []; + }); + + const setEnabledVariantKeys = ( + weaponId: MainWeaponId, + keys: RangeVariantKey[], + ) => { + setEntries([ + ...entries.filter((entry) => !entry.startsWith(`${weaponId}-`)), + ...keys.map((key) => `${weaponId}-${key}`), + ]); + }; + + return { enabledVariantKeys, setEnabledVariantKeys }; +} + +/** Weapons left out of the range chart */ +export function useHiddenRanges() { + const [hiddenWeaponIds, setHiddenWeaponIds] = useSearchParam( + compAnalyzerSearchParams, + "hiddenRanges", + ); + + const [selectedWeaponIds] = useSelectedWeapons(); + + const toggleHidden = (weaponId: MainWeaponId) => { + const stillSelected = hiddenWeaponIds.filter( + (id) => id !== weaponId && selectedWeaponIds.includes(id), + ); + setHiddenWeaponIds( + hiddenWeaponIds.includes(weaponId) + ? stillSelected + : [...stillSelected, weaponId], + ); + }; + + return { hiddenWeaponIds, toggleHidden }; +} + +export function useSpecialRanges() { + return useSearchParam(compAnalyzerSearchParams, "specialRanges"); +} diff --git a/app/features/comp-analyzer/comp-analyzer-search-params.test.ts b/app/features/comp-analyzer/comp-analyzer-search-params.test.ts index 3bbbe7d15..08fa30efd 100644 --- a/app/features/comp-analyzer/comp-analyzer-search-params.test.ts +++ b/app/features/comp-analyzer/comp-analyzer-search-params.test.ts @@ -14,6 +14,9 @@ describe("compAnalyzerSearchParams", () => { singleCombos: [false, true], subDef: [0, 29, 57], res: [0, 57], + rangeVariants: [[], ["1010-horizontal"], ["400-tap", "400-hold"]], + specialRanges: [false, true], + hiddenRanges: [[], [1010], [1010, 400]], }); }); @@ -39,5 +42,16 @@ describe("compAnalyzerSearchParams", () => { ["abc"], ]); assertDecodesToDefault(compAnalyzerSearchParams, "res", [["-1"], ["58"]]); + assertDecodesToDefault(compAnalyzerSearchParams, "specialRanges", [["1"]]); + }); + + test("drops malformed range variant entries", () => { + expect( + SearchParams.decodeParam(compAnalyzerSearchParams.shape.rangeVariants, [ + "1010-horizontal", + "1010-sideways", + "horizontal", + ]), + ).toEqual(["1010-horizontal"]); }); }); diff --git a/app/features/comp-analyzer/comp-analyzer-search-params.ts b/app/features/comp-analyzer/comp-analyzer-search-params.ts index 4815c91db..f67a1b32b 100644 --- a/app/features/comp-analyzer/comp-analyzer-search-params.ts +++ b/app/features/comp-analyzer/comp-analyzer-search-params.ts @@ -1,5 +1,8 @@ import * as v from "valibot"; -import { MAX_AP } from "~/features/build-analyzer/analyzer-constants"; +import { + MAX_AP, + RANGE_VARIANT_KEYS, +} from "~/features/build-analyzer/analyzer-constants"; import { mainWeaponIds } from "~/modules/in-game-lists/weapon-ids"; import * as SearchParams from "~/modules/search-params/search-params"; import { SP } from "~/modules/search-params/search-params"; @@ -7,6 +10,11 @@ import { numericEnum } from "~/utils/schema"; import { MAX_WEAPONS } from "./comp-analyzer-constants"; import type { CategorizationType } from "./comp-analyzer-types"; +/** `-`, a way of shooting a weapon turned on in the range chart */ +const RANGE_VARIANT_ENTRY_REGEX = new RegExp( + `^\\d{1,4}-(${RANGE_VARIANT_KEYS.join("|")})$`, +); + const CATEGORIZATION_TYPES = [ "category", "sub", @@ -26,6 +34,15 @@ export const compAnalyzerSearchParams = SearchParams.define({ }, ), singleCombos: SP.param(v.boolean(), { default: false, loader: false }), + rangeVariants: SP.param( + v.array(v.pipe(v.string(), v.regex(RANGE_VARIANT_ENTRY_REGEX))), + { default: [], loader: false }, + ), + specialRanges: SP.param(v.boolean(), { default: false, loader: false }), + hiddenRanges: SP.param( + v.pipe(v.array(numericEnum(mainWeaponIds)), v.maxLength(MAX_WEAPONS)), + { default: [], loader: false }, + ), subDef: SP.param( v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(MAX_AP)), { diff --git a/app/features/comp-analyzer/components/RangeVisualization.module.css b/app/features/comp-analyzer/components/RangeVisualization.module.css index e106a21ce..30c26845e 100644 --- a/app/features/comp-analyzer/components/RangeVisualization.module.css +++ b/app/features/comp-analyzer/components/RangeVisualization.module.css @@ -88,8 +88,10 @@ .weaponLegendItem { display: flex; + flex-wrap: wrap; align-items: center; gap: var(--s-1); + min-width: 0; } .weaponLegendColor { @@ -110,3 +112,111 @@ height: auto; min-height: 150px; } + +.variantChip { + display: flex; + align-items: center; + gap: var(--s-1); + padding: var(--s-0-5) var(--s-2); + background: var(--color-bg-higher); + border: 1px solid var(--color-border); + border-radius: var(--radius-field); + font-size: var(--font-xs); + color: var(--color-text); + cursor: pointer; + flex-wrap: wrap; + + &:hover { + background: var(--color-bg-high); + } +} + +.variantChipHidden { + background: transparent; + border-style: dashed; + opacity: 0.6; +} + +.variantLine { + flex-shrink: 0; +} + +.lethalRange { + font-size: var(--font-xs); + color: var(--color-text-high); + white-space: nowrap; +} + +.specialRangesToggleRow { + display: flex; + padding-block-start: var(--s-2); + border-block-start: 1px solid var(--color-border); +} + +.specialRanges { + display: flex; + flex-direction: column; + gap: var(--s-1); +} + +.specialRangeRow { + position: relative; + display: flex; + align-items: center; + min-height: 24px; +} + +.specialRangeIcon { + position: absolute; + inset-inline-start: 0; +} + +.specialRangeTrack { + position: relative; + height: 18px; +} + +.specialRangeBar { + position: absolute; + inset-block: 0; + inset-inline-start: 0; + display: flex; + align-items: center; + padding-inline: var(--s-1); + border-radius: var(--radius-field); + font-size: var(--font-xs); + font-weight: var(--weight-semi); + color: black; + white-space: nowrap; +} + +.specialRangeBlast { + position: absolute; + inset-block: 0; + border-radius: var(--radius-field); + opacity: 0.35; +} + +.weaponLegendItemHidden > :not(.visibilityToggle) { + opacity: 0.35; +} + +.visibilityToggle { + display: flex; + align-items: center; + gap: var(--s-0-5); + padding: var(--s-0-5); + background: transparent; + border: none; + border-radius: var(--radius-field); + color: var(--color-text-high); + cursor: pointer; + + &:hover { + background: var(--color-bg-high); + } + + &[aria-pressed="false"] img { + opacity: 0.35; + } +} diff --git a/app/features/comp-analyzer/components/RangeVisualization.tsx b/app/features/comp-analyzer/components/RangeVisualization.tsx index 68bf4de6e..e53459554 100644 --- a/app/features/comp-analyzer/components/RangeVisualization.tsx +++ b/app/features/comp-analyzer/components/RangeVisualization.tsx @@ -1,7 +1,17 @@ +import clsx from "clsx"; +import { Eye, EyeOff } from "lucide-react"; import { useState } from "react"; import { useTranslation } from "react-i18next"; -import { WeaponImage } from "~/components/Image"; +import { SendouSwitch } from "~/components/elements/Switch"; +import { SpecialWeaponImage, WeaponImage } from "~/components/Image"; +import type { RangeVariantKey } from "~/features/build-analyzer/analyzer-types"; import type { MainWeaponId } from "~/modules/in-game-lists/types"; +import { + useHiddenRanges, + useRangeVariants, + useSpecialRanges, +} from "../comp-analyzer-hooks"; +import * as SpecialWeaponRange from "../core/SpecialWeaponRange"; import * as WeaponRange from "../core/WeaponRange"; import styles from "./RangeVisualization.module.css"; @@ -12,6 +22,15 @@ const BENCHMARK_COLORS = [ "rgba(100, 100, 120, 0.5)", ] as const; +const CHART_WIDTH = 600; +const CHART_HEIGHT = 240; +const CHART_PADDING = { top: 20, right: 60, bottom: 30, left: 50 }; +const CHART_INNER_WIDTH = + CHART_WIDTH - CHART_PADDING.left - CHART_PADDING.right; +const MAX_RANGE = 32; + +const ALTERNATE_VARIANT_DASH = "6,4"; + interface RangeVisualizationProps { weaponIds: MainWeaponId[]; } @@ -19,20 +38,24 @@ interface RangeVisualizationProps { export function RangeVisualization({ weaponIds }: RangeVisualizationProps) { const { t } = useTranslation(["analyzer", "weapons"]); const [isCollapsed, setIsCollapsed] = useState(false); + const { enabledVariantKeys, setEnabledVariantKeys } = useRangeVariants(); + const [showSpecialRanges, setShowSpecialRanges] = useSpecialRanges(); + const { hiddenWeaponIds, toggleHidden } = useHiddenRanges(); - const weaponsWithRange = WeaponRange.ofWeapons(weaponIds); + const weaponsWithRange = WeaponRange.ofWeapons(weaponIds, enabledVariantKeys); + const shownWeapons = weaponsWithRange.filter( + (weapon) => !hiddenWeaponIds.includes(weapon.weaponId), + ); const benchmarkTrajectories = WeaponRange.benchmarkTrajectories(); if (weaponsWithRange.length === 0) { return null; } - const maxRange = 32; - const allYValues: number[] = []; - for (const weapon of weaponsWithRange) { - if (weapon.trajectory) { - for (const point of weapon.trajectory) { + for (const weapon of shownWeapons) { + for (const variant of weapon.variants) { + for (const point of variant.trajectory ?? []) { if (point.y >= 0) { allYValues.push(point.y); } @@ -40,8 +63,15 @@ export function RangeVisualization({ weaponIds }: RangeVisualizationProps) { } } - const minY = 0; - const maxY = Math.max(...allYValues, 2); + const handleToggleVariant = ( + weapon: WeaponRange.WeaponWithRange, + key: RangeVariantKey, + ) => { + const nextKeys = WeaponRange.toggleVariant(weapon, key); + if (!nextKeys) return; + + setEnabledVariantKeys(weapon.weaponId, nextKeys); + }; return (
@@ -68,99 +98,242 @@ export function RangeVisualization({ weaponIds }: RangeVisualizationProps) {
))} - +
+ + +
+ + {t("analyzer:comp.specialRanges")} + +
+ {showSpecialRanges ? ( + + ) : null} +
) : null} ); } +function WeaponLegend({ + weapons, + hiddenWeaponIds, + onToggleVariant, + onToggleHidden, +}: { + weapons: WeaponRange.WeaponWithRange[]; + hiddenWeaponIds: MainWeaponId[]; + onToggleVariant: ( + weapon: WeaponRange.WeaponWithRange, + key: RangeVariantKey, + ) => void; + onToggleHidden: (weaponId: MainWeaponId) => void; +}) { + const { t } = useTranslation(["analyzer"]); + + return ( +
+ {weapons.map((weapon) => { + const color = SLOT_COLORS[weapon.slot % SLOT_COLORS.length]; + const isHidden = hiddenWeaponIds.includes(weapon.weaponId); + const visibilityToggle = ( + onToggleHidden(weapon.weaponId)} + /> + ); + + if (weapon.allVariantKeys.length === 0) { + const [variant] = weapon.variants; + return ( +
+ {visibilityToggle} + + + {variant.range.toFixed(1)} + + +
+ ); + } + + const allVariants = WeaponRange.variantsOf(weapon.weaponId); + + return ( +
+ {visibilityToggle} + {allVariants.map((variant) => { + if (variant.key === null) return null; + const key = variant.key; + const isShown = weapon.variants.some( + (shown) => shown.key === key, + ); + + return ( + + ); + })} +
+ ); + })} +
+ ); +} + +function VisibilityToggle({ + weaponId, + isHidden, + onToggle, +}: { + weaponId: MainWeaponId; + isHidden: boolean; + onToggle: () => void; +}) { + const { t } = useTranslation(["analyzer", "weapons"]); + const weaponName = t(`weapons:MAIN_${weaponId}`); + + return ( + + ); +} + +function VariantLineSample({ + color, + isDefault, +}: { + color: string; + isDefault: boolean; +}) { + return ( + + + + ); +} + +function LethalRangeLabel({ + lethal, +}: { + lethal: WeaponRange.LethalRange | undefined; +}) { + const { t } = useTranslation(["analyzer"]); + + if (!lethal) return null; + + return ( + + {t("analyzer:comp.lethalRange", { + shots: lethal.shots, + distance: lethal.distance.toFixed(1), + })} + + ); +} + interface TrajectoryChartProps { weapons: WeaponRange.WeaponWithRange[]; - benchmarkTrajectories: Array<{ - id: MainWeaponId; - range: number; - trajectory?: WeaponRange.TrajectoryPoint[]; - }>; - maxRange: number; - minY: number; + benchmarkTrajectories: WeaponRange.BenchmarkTrajectory[]; maxY: number; } function TrajectoryChart({ weapons, benchmarkTrajectories, - maxRange, - minY, maxY, }: TrajectoryChartProps) { - const chartWidth = 600; - const chartHeight = 200; - const padding = { top: 20, right: 60, bottom: 30, left: 50 }; - const innerWidth = chartWidth - padding.left - padding.right; - const innerHeight = chartHeight - padding.top - padding.bottom; + const minY = 0; + const innerHeight = CHART_HEIGHT - CHART_PADDING.top - CHART_PADDING.bottom; - const xScale = (z: number) => (z / maxRange) * innerWidth; + const xScale = (z: number) => (z / MAX_RANGE) * CHART_INNER_WIDTH; const yScale = (y: number) => innerHeight - ((y - minY) / (maxY - minY)) * innerHeight; - // where the trajectory hits the ground (lastPoint may be below it or mid-air); blasts happen there - const getGroundIntersection = ( - trajectory: WeaponRange.TrajectoryPoint[], - ): WeaponRange.TrajectoryPoint | null => { - for (let i = 0; i < trajectory.length; i++) { - const point = trajectory[i]; - if (point.y < 0) { - const prevPoint = trajectory[i - 1]; - if (prevPoint && prevPoint.y >= 0) { - const t = prevPoint.y / (prevPoint.y - point.y); - const groundZ = prevPoint.z + t * (point.z - prevPoint.z); - return { z: groundZ, y: 0 }; - } - break; - } - } - const lastPoint = trajectory[trajectory.length - 1]; - return lastPoint && lastPoint.y >= 0 ? lastPoint : null; - }; - const trajectoryToPath = ( trajectory: WeaponRange.TrajectoryPoint[], ): string => { - if (trajectory.length === 0) return ""; + const points = clampToGround(trajectory).map( + (p) => `${xScale(p.z)},${yScale(p.y)}`, + ); + if (points.length === 0) return ""; - const clampedPoints: WeaponRange.TrajectoryPoint[] = []; - for (const point of trajectory) { - if (point.y >= 0) { - clampedPoints.push(point); - } else { - const prevPoint = clampedPoints[clampedPoints.length - 1]; - if (prevPoint && prevPoint.y > 0) { - const t = prevPoint.y / (prevPoint.y - point.y); - const groundZ = prevPoint.z + t * (point.z - prevPoint.z); - clampedPoints.push({ z: groundZ, y: 0 }); - } - break; - } - } - - if (clampedPoints.length === 0) return ""; - - const points = clampedPoints.map((p) => `${xScale(p.z)},${yScale(p.y)}`); return `M ${points.join(" L ")}`; }; const groundY = yScale(0); const xTicks: number[] = []; - const xStep = Math.ceil(maxRange / 5); - for (let x = 0; x <= maxRange; x += xStep) { + const xStep = Math.ceil(MAX_RANGE / 5); + for (let x = 0; x <= MAX_RANGE; x += xStep) { xTicks.push(x); } @@ -170,174 +343,265 @@ function TrajectoryChart({ yTicks.push(y); } + const shownVariants = weapons.flatMap((weapon) => + weapon.variants.map((variant) => ({ + id: `${weapon.weaponId}-${weapon.slot}-${variant.key}`, + color: SLOT_COLORS[weapon.slot % SLOT_COLORS.length], + variant, + })), + ); + return ( -
-
- {weapons.map((weapon) => { - const color = SLOT_COLORS[weapon.slot % SLOT_COLORS.length]; + + + {xTicks.map((tick) => ( + + ))} + {yTicks.map((tick) => ( + + ))} + + + + {benchmarkTrajectories.map((benchmark, index) => { + const x = xScale(benchmark.range); return ( -
- - - - {weapon.range.toFixed(1)} - -
+ ); })} -
- - - {/* Grid lines */} - {xTicks.map((tick) => ( - { + if (!variant.trajectory) return null; + return ( + - ))} - {yTicks.map((tick) => ( - { + if (!variant.blastRadius || !variant.trajectory) return null; + const blastPoint = clampToGround(variant.trajectory).at(-1); + if (!blastPoint) return null; + return ( + - ))} + ); + })} - {/* Ground line (y=0) */} - + {shownVariants.map(({ id, color, variant }) => { + if (!variant.lethal || !variant.trajectory) return null; + const markerY = heightAt(variant.trajectory, variant.lethal.distance); + if (markerY === null) return null; + return ( + + ); + })} - {/* Benchmark vertical lines */} - {benchmarkTrajectories.map((benchmark, index) => { - const x = xScale(benchmark.range); - return ( - - ); - })} - - {/* Weapon trajectories */} - {weapons.map((weapon) => { - if (!weapon.trajectory) return null; - const color = SLOT_COLORS[weapon.slot % SLOT_COLORS.length]; - return ( - - ); - })} - - {/* Blast radius circles */} - {weapons.map((weapon) => { - if (!weapon.blastRadius || !weapon.trajectory) return null; - const groundPoint = getGroundIntersection(weapon.trajectory); - if (!groundPoint) return null; - const color = SLOT_COLORS[weapon.slot % SLOT_COLORS.length]; - const radiusPixels = xScale(weapon.blastRadius); - return ( - - ); - })} - - {/* X axis labels */} - {xTicks.map((tick) => ( - - {tick} - - ))} - - {/* Y axis labels */} - {yTicks.map((tick) => ( - - {tick} - - ))} - - {/* Axis labels */} + {xTicks.map((tick) => ( - z + {tick} + ))} + + {yTicks.map((tick) => ( - y + {tick} - - + ))} + + + z + + + y + + + + ); +} + +/** Special ranges of the comp as bars on the same x scale as the trajectory chart above them */ +function SpecialRangeRows({ weaponIds }: { weaponIds: MainWeaponId[] }) { + const rows = SpecialWeaponRange.ofWeapons(weaponIds); + + if (rows.length === 0) return null; + + const trackStyle = { + marginInlineStart: `${(CHART_PADDING.left / CHART_WIDTH) * 100}%`, + width: `${(CHART_INNER_WIDTH / CHART_WIDTH) * 100}%`, + }; + const percentageOfTrack = (distance: number) => + `${(Math.min(distance, MAX_RANGE) / MAX_RANGE) * 100}%`; + + return ( +
+ {rows.map((row) => { + const color = SLOT_COLORS[row.slot % SLOT_COLORS.length]; + return ( +
+ +
+ + {row.range.toFixed(1)} + {row.blastRadius ? ` + ${row.blastRadius.toFixed(1)}` : ""} + + {row.blastRadius ? ( + + ) : null} +
+
+ ); + })}
); } + +/** The trajectory up to where it reaches the ground (or its last point mid-air) */ +function clampToGround( + trajectory: WeaponRange.TrajectoryPoint[], +): WeaponRange.TrajectoryPoint[] { + const clampedPoints: WeaponRange.TrajectoryPoint[] = []; + for (const point of trajectory) { + if (point.y >= 0) { + clampedPoints.push(point); + continue; + } + + const prevPoint = clampedPoints.at(-1); + if (prevPoint && prevPoint.y > 0) { + const t = prevPoint.y / (prevPoint.y - point.y); + clampedPoints.push({ + z: prevPoint.z + t * (point.z - prevPoint.z), + y: 0, + }); + } + break; + } + + return clampedPoints; +} + +function heightAt( + trajectory: WeaponRange.TrajectoryPoint[], + z: number, +): number | null { + const points = clampToGround(trajectory); + for (let i = 1; i < points.length; i++) { + const prevPoint = points[i - 1]; + const point = points[i]; + if (z < prevPoint.z || z > point.z) continue; + + const t = + point.z === prevPoint.z ? 0 : (z - prevPoint.z) / (point.z - prevPoint.z); + return prevPoint.y + t * (point.y - prevPoint.y); + } + + return null; +} diff --git a/app/features/comp-analyzer/core/SpecialWeaponRange.test.ts b/app/features/comp-analyzer/core/SpecialWeaponRange.test.ts index 15bbc9a41..2b18d1bf1 100644 --- a/app/features/comp-analyzer/core/SpecialWeaponRange.test.ts +++ b/app/features/comp-analyzer/core/SpecialWeaponRange.test.ts @@ -1,4 +1,5 @@ import { describe, expect, test } from "vitest"; +import type { SpecialWeaponId } from "~/modules/in-game-lists/types"; import { BIG_BUBBLER_ID, BOOYAH_BOMB_ID, @@ -18,6 +19,17 @@ describe("SpecialWeaponRange.ofSpecial", () => { expect(result?.range).toBeGreaterThan(0); }); + // "Calculating weapon range (11.1.0 ver.)" community sheet + test.each([ + { why: "Trizooka", id: TRIZOOKA_ID, expected: 22.55 }, + { why: "Crab Tank cannon", id: CRAB_TANK_ID, expected: 24.66 }, + ] satisfies Array<{ why: string; id: SpecialWeaponId; expected: number }>)( + "matches the community range sheet: $why", + ({ id, expected }) => { + expect(SpecialWeaponRange.ofSpecial(id)?.range).toBeCloseTo(expected, 1); + }, + ); + test("Crab Tank reaches further than Trizooka", () => { const crab = SpecialWeaponRange.ofSpecial(CRAB_TANK_ID); const trizooka = SpecialWeaponRange.ofSpecial(TRIZOOKA_ID); @@ -55,3 +67,14 @@ describe("SpecialWeaponRange.ofSpecial", () => { } }); }); + +describe("SpecialWeaponRange.ofWeapons", () => { + test("keeps the comp slot of each special with a range and leaves the rest out", () => { + // Splat Roller (Big Bubbler), Squeezer (Trizooka) + const specials = SpecialWeaponRange.ofWeapons([1010, 400]); + + expect( + specials.map(({ slot, specialWeaponId }) => ({ slot, specialWeaponId })), + ).toEqual([{ slot: 1, specialWeaponId: TRIZOOKA_ID }]); + }); +}); diff --git a/app/features/comp-analyzer/core/SpecialWeaponRange.ts b/app/features/comp-analyzer/core/SpecialWeaponRange.ts index accc98e08..710fc09c1 100644 --- a/app/features/comp-analyzer/core/SpecialWeaponRange.ts +++ b/app/features/comp-analyzer/core/SpecialWeaponRange.ts @@ -4,17 +4,17 @@ * specials carry a radius in their params. */ -import { specialWeaponParams } from "~/features/build-analyzer/core/utils"; -import type { SpecialWeaponId } from "~/modules/in-game-lists/types"; +import { + mainWeaponParams, + specialWeaponParams, +} from "~/features/build-analyzer/core/utils"; +import type { + MainWeaponId, + SpecialWeaponId, +} from "~/modules/in-game-lists/types"; import { specialWeaponIds } from "~/modules/in-game-lists/weapon-ids"; import * as WeaponRange from "./WeaponRange"; -const DEFAULT_BRAKE_AIR_RESIST = 0.36; -const DEFAULT_BRAKE_GRAVITY = 0.07; -const DEFAULT_BRAKE_TO_FREE_FRAME = 4; -const DEFAULT_FREE_GRAVITY = 0.016; -const DEFAULT_FREE_AIR_RESIST = 0; - /** Range of a special: how far its projectile flies, or the radius of its area. */ export interface SpecialWeaponRangeResult { /** In game distance units. */ @@ -45,23 +45,11 @@ export function ofSpecial( }; } - if (params.Range_SpawnSpeed === undefined) return null; - - const trajectoryParams: WeaponRange.TrajectoryParams = { - spawnSpeed: params.Range_SpawnSpeed, - goStraightStateEndMaxSpeed: - params.Range_GoStraightStateEndMaxSpeed ?? params.Range_SpawnSpeed, - goStraightToBrakeStateFrame: params.Range_GoStraightToBrakeStateFrame ?? 4, - freeGravity: params.Range_FreeGravity ?? DEFAULT_FREE_GRAVITY, - freeAirResist: params.Range_FreeAirResist ?? DEFAULT_FREE_AIR_RESIST, - brakeAirResist: params.Range_BrakeAirResist ?? DEFAULT_BRAKE_AIR_RESIST, - brakeGravity: params.Range_BrakeGravity ?? DEFAULT_BRAKE_GRAVITY, - brakeToFreeFrame: - params.Range_BrakeToFreeStateFrame ?? DEFAULT_BRAKE_TO_FREE_FRAME, - }; + const flightParams = WeaponRange.trajectoryParams(params); + if (!flightParams) return null; const range = WeaponRange.groundRange( - WeaponRange.simulateTrajectory(trajectoryParams), + WeaponRange.simulateTrajectory(flightParams), ); return { @@ -76,6 +64,21 @@ export interface SpecialWeaponWithRange extends SpecialWeaponRangeResult { specialWeaponId: SpecialWeaponId; } +/** The special of a comp's weapon with its range. */ +export interface CompSpecialWithRange extends SpecialWeaponWithRange { + /** Position of the weapon in the comp */ + slot: number; +} + +/** Ranges of the specials of a comp's weapons in comp order, the ones without a range to draw left out. */ +export function ofWeapons(weaponIds: MainWeaponId[]): CompSpecialWithRange[] { + return weaponIds.flatMap((weaponId, slot) => { + const { specialWeaponId } = mainWeaponParams(weaponId); + const result = ofSpecial(specialWeaponId); + return result ? [{ slot, specialWeaponId, ...result }] : []; + }); +} + /** Every special with a range to draw, widest first. */ export function allSpecials(): SpecialWeaponWithRange[] { return specialWeaponIds diff --git a/app/features/comp-analyzer/core/WeaponRange.test.ts b/app/features/comp-analyzer/core/WeaponRange.test.ts index 86ea1efd5..5dcd9eb8d 100644 --- a/app/features/comp-analyzer/core/WeaponRange.test.ts +++ b/app/features/comp-analyzer/core/WeaponRange.test.ts @@ -1,4 +1,5 @@ import { describe, expect, test } from "vitest"; +import type { RangeVariantKey } from "~/features/build-analyzer/analyzer-types"; import type { MainWeaponId } from "~/modules/in-game-lists/types"; import * as WeaponRange from "./WeaponRange"; @@ -11,6 +12,41 @@ const RANGE_COMPARISONS: [MainWeaponId, MainWeaponId][] = [ [2070, 7010], // Snipewriter 5H > Tri-Stringer ]; +// "Calculating weapon range (11.1.0 ver.)" community sheet, rows whose params didn't change since +const SHEET_RANGES: Array<{ + weaponId: MainWeaponId; + key: RangeVariantKey | null; + expected: number; + why: string; +}> = [ + { weaponId: 40, key: null, expected: 11.93, why: "Splattershot" }, + { weaponId: 210, key: null, expected: 9.86, why: "Blaster bursts mid-air" }, + { weaponId: 250, key: null, expected: 17.39, why: "Rapid Blaster Pro" }, + { weaponId: 260, key: "jump", expected: 7.77, why: "S-BLAST jump shot" }, + { weaponId: 400, key: "hold", expected: 11.63, why: "Squeezer hold" }, + { weaponId: 1010, key: "horizontal", expected: 9.27, why: "Splat Roller" }, + { weaponId: 1030, key: "horizontal", expected: 8.3, why: "Flingza Roller" }, + { weaponId: 2060, key: "tap", expected: 12.6, why: "Goo Tuber tap" }, + { weaponId: 3000, key: null, expected: 11.15, why: "Slosher air resist" }, + { weaponId: 3040, key: null, expected: 17.39, why: "Explosher" }, + { weaponId: 4030, key: "short", expected: 10.77, why: "Ballpoint short" }, + { weaponId: 5020, key: "turret", expected: 15.75, why: "Glooga turret" }, + { weaponId: 5050, key: "turret", expected: 14.22, why: "Douser turret" }, + { + weaponId: 7010, + key: "partialCharge", + expected: 13.83, + why: "Tri-Stringer", + }, + { + weaponId: 8020, + key: "charged", + expected: 16.1, + why: "Decavitator charged, spawn offset", + }, + { weaponId: 8020, key: "tap", expected: 15.2, why: "Decavitator tap" }, +]; + describe("WeaponRange.ofWeapons", () => { test("keeps a separate slot for each copy of a duplicated weapon", () => { const weapons = WeaponRange.ofWeapons([40, 40, 70]); @@ -24,7 +60,176 @@ describe("WeaponRange.ofWeapons", () => { const [longer] = WeaponRange.ofWeapons([longerId]); const [shorter] = WeaponRange.ofWeapons([shorterId]); - expect(longer.range).toBeGreaterThan(shorter.range); + expect(longer.variants[0].range).toBeGreaterThan( + shorter.variants[0].range, + ); }, ); + + test("shows only the default variant when none are enabled", () => { + const [roller] = WeaponRange.ofWeapons([1010]); + + expect(roller.variants.map((variant) => variant.key)).toEqual(["vertical"]); + expect(roller.allVariantKeys).toEqual(["vertical", "horizontal"]); + }); + + test("shows the enabled variants in the weapon's own order", () => { + const [roller] = WeaponRange.ofWeapons([1010], () => [ + "horizontal", + "vertical", + ]); + + expect(roller.variants.map((variant) => variant.key)).toEqual([ + "vertical", + "horizontal", + ]); + }); + + test("weapons with one way of shooting have no variant keys", () => { + const [splattershot] = WeaponRange.ofWeapons([40]); + + expect(splattershot.allVariantKeys).toEqual([]); + expect(splattershot.variants[0].key).toBeNull(); + }); +}); + +describe("WeaponRange.variantsOf", () => { + test.each(SHEET_RANGES)( + "matches the community range sheet: $why", + ({ weaponId, key, expected }) => { + const variant = WeaponRange.variantsOf(weaponId).find( + (candidate) => key === null || candidate.key === key, + ); + + expect(variant?.range).toBeCloseTo(expected, 1); + }, + ); + + test("Splatana shots spawn in front of the player at shooting height", () => { + const [charged, tap] = WeaponRange.variantsOf(8000); + + expect(charged.trajectory?.[0]).toEqual({ z: 0.8, y: 1 }); + expect(tap.trajectory?.[0]).toEqual({ z: 1.4, y: 1 }); + }); + + test("vertical roller flicks are launched upwards", () => { + const [vertical] = WeaponRange.variantsOf(1010); + const highestPoint = Math.max( + ...(vertical.trajectory ?? []).map((point) => point.y), + ); + + expect(highestPoint).toBeGreaterThan(1); + }); + + test("rollers carry their one-shot distance per swing", () => { + const [vertical, horizontal] = WeaponRange.variantsOf(1010); + + expect(vertical.lethal).toEqual({ shots: 1, distance: 8.2 }); + expect(horizontal.lethal).toEqual({ shots: 1, distance: 7.2 }); + }); +}); + +describe("WeaponRange.lethalRange", () => { + test.each([ + { + why: "ends where damage drops below one-shot", + points: [ + { Damage: 1500, Distance: 5.2 }, + { Damage: 1000, Distance: 8.2 }, + { Damage: 500, Distance: 11.2 }, + ], + expected: { shots: 1, distance: 8.2 }, + }, + { + why: "interpolates between points", + points: [ + { Damage: 400, Distance: 3.3 }, + { Damage: 200, Distance: 14.3 }, + ], + expected: { shots: 3, distance: 3.3 + (11 * (400 - 1000 / 3)) / 200 }, + }, + { + why: "is null when damage never drops a breakpoint", + points: [ + { Damage: 600, Distance: 5 }, + { Damage: 500, Distance: 13 }, + ], + expected: null, + }, + ])("$why", ({ points, expected }) => { + const result = WeaponRange.lethalRange(points); + + if (expected === null) { + expect(result).toBeNull(); + } else { + expect(result?.shots).toBe(expected.shots); + expect(result?.distance).toBeCloseTo(expected.distance); + } + }); +}); + +describe("WeaponRange.simulateTrajectory", () => { + const params: WeaponRange.TrajectoryParams = { + spawnSpeed: 1, + spawnAngle: 0, + spawnOffsetZ: 0, + goStraightStateEndMaxSpeed: 1, + goStraightToBrakeStateFrame: 2, + freeGravity: 0.016, + freeAirResist: 0.02, + brakeAirResist: 0.09, + brakeGravity: 0.09, + brakeToFreeFrame: 10, + brakeToFreeVelocityY: -0.15, + }; + + test("ends the brake phase once the shot falls faster than brakeToFreeVelocityY", () => { + const earlyFree = WeaponRange.groundRange( + WeaponRange.simulateTrajectory({ ...params, brakeToFreeVelocityY: -0.1 }), + ); + const fullBrake = WeaponRange.groundRange( + WeaponRange.simulateTrajectory({ ...params, brakeToFreeVelocityY: -99 }), + ); + + expect(earlyFree).toBeGreaterThan(fullBrake); + }); +}); + +describe("WeaponRange.toggleVariant", () => { + const roller = (enabled: RangeVariantKey[]) => + WeaponRange.ofWeapons([1010], () => enabled)[0]; + + test.each([ + { + why: "turning on an alternative keeps the default", + enabled: [], + key: "horizontal", + expected: ["vertical", "horizontal"], + }, + { + why: "back to only the default is stored as nothing", + enabled: ["vertical", "horizontal"], + key: "horizontal", + expected: [], + }, + { + why: "the default can be hidden while an alternative shows", + enabled: ["vertical", "horizontal"], + key: "vertical", + expected: ["horizontal"], + }, + { + why: "the last shown variant can't be hidden", + enabled: ["horizontal"], + key: "horizontal", + expected: null, + }, + ] satisfies Array<{ + why: string; + enabled: RangeVariantKey[]; + key: RangeVariantKey; + expected: RangeVariantKey[] | null; + }>)("$why", ({ enabled, key, expected }) => { + expect(WeaponRange.toggleVariant(roller(enabled), key)).toEqual(expected); + }); }); diff --git a/app/features/comp-analyzer/core/WeaponRange.ts b/app/features/comp-analyzer/core/WeaponRange.ts index a00963415..6999af79b 100644 --- a/app/features/comp-analyzer/core/WeaponRange.ts +++ b/app/features/comp-analyzer/core/WeaponRange.ts @@ -1,9 +1,14 @@ /** * How far main weapons shoot: a frame by frame simulation of a shot's flight (straight, braking, - * then falling) from the weapon's params, chargers reaching their full charge distance in a line. + * then falling) from the weapon's params, chargers reaching their charge distance in a line. * Distances are in game units, measured from a player standing on flat ground. */ +import type { + DistanceDamage, + RangeParams, + RangeVariantKey, +} from "~/features/build-analyzer/analyzer-types"; import { mainWeaponParams } from "~/features/build-analyzer/core/utils"; import type { MainWeaponId } from "~/modules/in-game-lists/types"; import { weaponCategories } from "~/modules/in-game-lists/weapon-ids"; @@ -11,6 +16,10 @@ import { weaponCategories } from "~/modules/in-game-lists/weapon-ids"; /** Flight params of a shot, `Range_*` of the weapon's params with the game's defaults filled in. */ export interface TrajectoryParams { spawnSpeed: number; + /** Upward angle of the shot in degrees */ + spawnAngle: number; + /** How far in front of the player the shot spawns */ + spawnOffsetZ: number; goStraightStateEndMaxSpeed: number; goStraightToBrakeStateFrame: number; freeGravity: number; @@ -18,6 +27,7 @@ export interface TrajectoryParams { brakeAirResist: number; brakeGravity: number; brakeToFreeFrame: number; + brakeToFreeVelocityY: number; burstFrame?: number; bounceAfterMaxSpeed?: number; } @@ -28,11 +38,16 @@ export interface TrajectoryPoint { y: number; } +const DEFAULT_GO_STRAIGHT_TO_BRAKE_STATE_FRAME = 4; const DEFAULT_BRAKE_AIR_RESIST = 0.36; const DEFAULT_BRAKE_GRAVITY = 0.07; const DEFAULT_BRAKE_TO_FREE_FRAME = 4; +const DEFAULT_BRAKE_TO_FREE_VELOCITY_Y = -0.15; const DEFAULT_FREE_GRAVITY = 0.016; -const DEFAULT_FREE_AIR_RESIST = 0; +const DEFAULT_FREE_AIR_RESIST = 0.02; + +/** Damage (in tenths of HP) it takes to splat a player */ +const SPLAT_DAMAGE = 1000; function getWeaponCategoryName(weaponId: MainWeaponId): string | undefined { for (const category of weaponCategories) { @@ -64,15 +79,46 @@ function bouncingRange(trajectory: TrajectoryPoint[]): number { return lastPoint?.z ?? 0; } +/** Flight params of `Range_*` params with the game's defaults filled in, `null` when they have no speed. */ +export function trajectoryParams( + params: Omit, +): TrajectoryParams | null { + if (params.Range_SpawnSpeed === undefined) return null; + + return { + spawnSpeed: params.Range_SpawnSpeed, + spawnAngle: params.Range_SpawnAngle ?? 0, + spawnOffsetZ: params.Range_SpawnOffsetZ ?? 0, + goStraightStateEndMaxSpeed: + params.Range_GoStraightStateEndMaxSpeed ?? params.Range_SpawnSpeed, + goStraightToBrakeStateFrame: + params.Range_GoStraightToBrakeStateFrame ?? + DEFAULT_GO_STRAIGHT_TO_BRAKE_STATE_FRAME, + freeGravity: params.Range_FreeGravity ?? DEFAULT_FREE_GRAVITY, + freeAirResist: params.Range_FreeAirResist ?? DEFAULT_FREE_AIR_RESIST, + brakeAirResist: params.Range_BrakeAirResist ?? DEFAULT_BRAKE_AIR_RESIST, + brakeGravity: params.Range_BrakeGravity ?? DEFAULT_BRAKE_GRAVITY, + brakeToFreeFrame: + params.Range_BrakeToFreeStateFrame ?? DEFAULT_BRAKE_TO_FREE_FRAME, + brakeToFreeVelocityY: + params.Range_BrakeToFreeVelocityY ?? DEFAULT_BRAKE_TO_FREE_VELOCITY_Y, + burstFrame: params.Range_BurstFrame, + bounceAfterMaxSpeed: params.Range_BounceAfterMaxSpeed, + }; +} + /** - * The shot's position on every frame until it lands, bursts or stops. Bouncing shots - * (`bounceAfterMaxSpeed` set) bounce `burstFrame` times instead of landing. + * The shot's position on every frame until it lands, bursts or stops. The brake phase ends early once + * the shot falls faster than `brakeToFreeVelocityY`. Bouncing shots (`bounceAfterMaxSpeed` set) + * bounce `burstFrame` times instead of landing. */ export function simulateTrajectory( params: TrajectoryParams, ): TrajectoryPoint[] { const { spawnSpeed, + spawnAngle, + spawnOffsetZ, goStraightStateEndMaxSpeed, goStraightToBrakeStateFrame, freeGravity, @@ -80,6 +126,7 @@ export function simulateTrajectory( brakeAirResist, brakeGravity, brakeToFreeFrame, + brakeToFreeVelocityY, burstFrame, bounceAfterMaxSpeed, } = params; @@ -90,10 +137,11 @@ export function simulateTrajectory( const maxFrames = isBouncing ? 300 : (burstFrame ?? 300); const points: TrajectoryPoint[] = []; - let z = 0; + const angleRadians = (spawnAngle * Math.PI) / 180; + let z = spawnOffsetZ; let y = PLAYER_HEIGHT; - let vz = spawnSpeed; - let vy = 0; + let vz = spawnSpeed * Math.cos(angleRadians); + let vy = spawnSpeed * Math.sin(angleRadians); let frame = 0; let bounceCount = 0; @@ -101,11 +149,16 @@ export function simulateTrajectory( while (frame < goStraightToBrakeStateFrame && frame < maxFrames) { z += vz; + y += vy; points.push({ z, y }); frame++; } - vz = Math.min(vz, goStraightStateEndMaxSpeed); + const speed = Math.hypot(vz, vy); + if (speed > goStraightStateEndMaxSpeed) { + vz *= goStraightStateEndMaxSpeed / speed; + vy *= goStraightStateEndMaxSpeed / speed; + } for (let i = 0; i < brakeToFreeFrame && frame < maxFrames; i++) { vz *= 1 - brakeAirResist; @@ -128,6 +181,8 @@ export function simulateTrajectory( return points; } } + + if (vy < brakeToFreeVelocityY) break; } while (frame < maxFrames) { @@ -167,56 +222,111 @@ export function simulateTrajectory( return points; } +/** How many hits splat at point blank and up to which distance that many still do. */ +export interface LethalRange { + shots: number; + distance: number; +} + +/** + * Lethal range of damage falling off linearly between `distanceDamage` points (rollers, brushes), + * `null` when the weapon splats in the same number of hits at every distance. + */ +export function lethalRange( + distanceDamage: DistanceDamage[], +): LethalRange | null { + const [closest] = distanceDamage; + if (!closest || closest.Damage <= 0) return null; + + const shots = Math.ceil(SPLAT_DAMAGE / closest.Damage); + const threshold = SPLAT_DAMAGE / shots; + + for (let i = 1; i < distanceDamage.length; i++) { + const near = distanceDamage[i - 1]; + const far = distanceDamage[i]; + if (far.Damage >= threshold) continue; + + const t = (near.Damage - threshold) / (near.Damage - far.Damage); + return { + shots, + distance: near.Distance + t * (far.Distance - near.Distance), + }; + } + + return null; +} + /** Range of a main weapon, `unsupported` for weapons the model can't simulate. */ export interface WeaponRangeResult { range: number; blastRadius?: number; rangeType: "calculated" | "direct" | "unsupported"; trajectory?: TrajectoryPoint[]; + lethal?: LethalRange; } -/** Range of a main weapon with the trajectory it was measured from. */ +/** One way of shooting a weapon with its range, `key` `null` for weapons that only have one. */ +export interface WeaponRangeVariant extends WeaponRangeResult { + key: RangeVariantKey | null; + isDefault: boolean; +} + +/** Range of a main weapon's default way of shooting with the trajectory it was measured from. */ export function ofMainWeapon(weaponId: MainWeaponId): WeaponRangeResult { + return variantsOf(weaponId)[0]; +} + +/** Every way of shooting a main weapon (a roller's vertical and horizontal swing…), the default first. */ +export function variantsOf(weaponId: MainWeaponId): WeaponRangeVariant[] { const category = getWeaponCategoryName(weaponId); if (!category) { - return { range: 0, rangeType: "unsupported" }; + return [{ key: null, isDefault: true, range: 0, rangeType: "unsupported" }]; } const params = mainWeaponParams(weaponId); + const defaultRangeParams: RangeParams = + category === "CHARGERS" && params.DistanceFullCharge !== undefined + ? { Range_Distance: params.DistanceFullCharge } + : params; - if (category === "CHARGERS" && params.DistanceFullCharge !== undefined) { - const range = params.DistanceFullCharge; + return [ + { + key: params.Range_VariantKey ?? null, + isDefault: true, + ...rangeOf(defaultRangeParams), + }, + ...(params.Range_Variants ?? []).map((variant) => ({ + key: variant.Range_VariantKey, + isDefault: false, + ...rangeOf(variant), + })), + ]; +} + +function rangeOf(params: RangeParams): WeaponRangeResult { + const lethal = params.Range_DistanceDamage + ? (lethalRange(params.Range_DistanceDamage) ?? undefined) + : undefined; + + if (params.Range_Distance !== undefined) { return { - range, + range: params.Range_Distance, rangeType: "direct", trajectory: [ { z: 0, y: PLAYER_HEIGHT }, - { z: range, y: PLAYER_HEIGHT }, + { z: params.Range_Distance, y: PLAYER_HEIGHT }, ], + lethal, }; } - if (params.Range_SpawnSpeed === undefined) { + const flightParams = trajectoryParams(params); + if (!flightParams) { return { range: 0, rangeType: "unsupported" }; } - const trajectoryParams: TrajectoryParams = { - spawnSpeed: params.Range_SpawnSpeed, - goStraightStateEndMaxSpeed: - params.Range_GoStraightStateEndMaxSpeed ?? params.Range_SpawnSpeed, - goStraightToBrakeStateFrame: params.Range_GoStraightToBrakeStateFrame ?? 4, - freeGravity: params.Range_FreeGravity ?? DEFAULT_FREE_GRAVITY, - freeAirResist: params.Range_FreeAirResist ?? DEFAULT_FREE_AIR_RESIST, - brakeAirResist: params.Range_BrakeAirResist ?? DEFAULT_BRAKE_AIR_RESIST, - brakeGravity: params.Range_BrakeGravity ?? DEFAULT_BRAKE_GRAVITY, - brakeToFreeFrame: - params.Range_BrakeToFreeStateFrame ?? DEFAULT_BRAKE_TO_FREE_FRAME, - burstFrame: params.Range_BurstFrame, - bounceAfterMaxSpeed: params.Range_BounceAfterMaxSpeed, - }; - - const trajectory = simulateTrajectory(trajectoryParams); + const trajectory = simulateTrajectory(flightParams); const range = params.Range_BounceAfterMaxSpeed !== undefined ? bouncingRange(trajectory) @@ -227,32 +337,76 @@ export function ofMainWeapon(weaponId: MainWeaponId): WeaponRangeResult { blastRadius: params.BlastRadius, rangeType: "calculated", trajectory, + lethal, }; } -/** A comp's weapon with its range. */ +/** A comp's weapon with the ways of shooting it that are shown. */ export interface WeaponWithRange { weaponId: MainWeaponId; /** Position in the comp, kept through the filtering so duplicates stay apart */ slot: number; - range: number; - blastRadius?: number; - rangeType: "calculated" | "direct" | "unsupported"; - trajectory?: TrajectoryPoint[]; + /** Shown ways of shooting, default first when it is one of them */ + variants: WeaponRangeVariant[]; + /** Every way of shooting the weapon has, empty when it has only one */ + allVariantKeys: RangeVariantKey[]; } -/** Ranges of a comp's weapons, the ones the model can't simulate left out. */ -export function ofWeapons(weaponIds: MainWeaponId[]): WeaponWithRange[] { - return weaponIds - .map((weaponId, slot) => { - const result = ofMainWeapon(weaponId); - return { +/** + * Ranges of a comp's weapons, the ones the model can't simulate left out. `enabledVariantKeys` picks + * which ways of shooting a weapon are shown, its default when it returns none it has. + */ +export function ofWeapons( + weaponIds: MainWeaponId[], + enabledVariantKeys: (weaponId: MainWeaponId) => RangeVariantKey[] = () => [], +): WeaponWithRange[] { + return weaponIds.flatMap((weaponId, slot) => { + const all = variantsOf(weaponId).filter( + (variant) => variant.rangeType !== "unsupported", + ); + if (all.length === 0) return []; + + const enabledKeys = enabledVariantKeys(weaponId); + const enabled = all.filter( + (variant) => variant.key !== null && enabledKeys.includes(variant.key), + ); + + return [ + { weaponId, slot, - ...result, - }; - }) - .filter((w) => w.rangeType !== "unsupported"); + variants: enabled.length > 0 ? enabled : [all[0]], + allVariantKeys: all.flatMap((variant) => + variant.key !== null ? [variant.key] : [], + ), + }, + ]; + }); +} + +/** + * Ways of shooting a comp's weapon to show after toggling `key`: empty when only the default is left, + * `null` when the toggle would hide every one of them. + */ +export function toggleVariant( + weapon: WeaponWithRange, + key: RangeVariantKey, +): RangeVariantKey[] | null { + const shownKeys = weapon.variants.flatMap((variant) => + variant.key !== null ? [variant.key] : [], + ); + const nextKeys = weapon.allVariantKeys.filter((variantKey) => + variantKey === key + ? !shownKeys.includes(variantKey) + : shownKeys.includes(variantKey), + ); + + if (nextKeys.length === 0) return null; + if (nextKeys.length === 1 && nextKeys[0] === weapon.allVariantKeys[0]) { + return []; + } + + return nextKeys; } /** Weapons drawn under every comp's ranges for scale: Splattershot and Snipewriter 5H. */ diff --git a/app/features/comp-analyzer/routes/comp-analyzer.module.css b/app/features/comp-analyzer/routes/comp-analyzer.module.css new file mode 100644 index 000000000..09309bf72 --- /dev/null +++ b/app/features/comp-analyzer/routes/comp-analyzer.module.css @@ -0,0 +1,5 @@ +.selectedWeaponsColumn { + width: 100%; + max-width: 40rem; + margin-inline: auto; +} diff --git a/app/features/comp-analyzer/routes/comp-analyzer.tsx b/app/features/comp-analyzer/routes/comp-analyzer.tsx index 328a14630..3348b058d 100644 --- a/app/features/comp-analyzer/routes/comp-analyzer.tsx +++ b/app/features/comp-analyzer/routes/comp-analyzer.tsx @@ -1,3 +1,4 @@ +import clsx from "clsx"; import { HardDriveDownload } from "lucide-react"; import { useState } from "react"; import { useTranslation } from "react-i18next"; @@ -20,8 +21,11 @@ import { metaTags, ogPageImage } from "../../../utils/remix"; import { MAX_WEAPONS } from "../comp-analyzer-constants"; import { useCategorization, + useHiddenRanges, + useRangeVariants, useSelectedWeapons, useSingleWeaponCombos, + useSpecialRanges, useTargetSubDefenseAp, } from "../comp-analyzer-hooks"; import { DamageComboList } from "../components/DamageComboBar"; @@ -30,6 +34,7 @@ import { SelectedWeapons } from "../components/SelectedWeapons"; import { WeaponCategories } from "../components/WeaponCategories"; import { WeaponGrid } from "../components/WeaponGrid"; import * as DamageCombos from "../core/DamageCombos"; +import styles from "./comp-analyzer.module.css"; export const meta: MetaFunction = (args) => { return metaTags({ @@ -95,23 +100,25 @@ function CompAnalyzerPage() { }; return ( -
- -
- {selectedWeaponIds.length >= MAX_WEAPONS ? ( - - ) : ( - }> - {t("analyzer:comp.exportHint", { max: MAX_WEAPONS })} - - )} +
+
+ +
+ {selectedWeaponIds.length >= MAX_WEAPONS ? ( + + ) : ( + }> + {t("analyzer:comp.exportHint", { max: MAX_WEAPONS })} + + )} +
); } diff --git a/app/features/img-export/components/CompGraphic.module.css b/app/features/img-export/components/CompGraphic.module.css index a52b34dd6..33be81852 100644 --- a/app/features/img-export/components/CompGraphic.module.css +++ b/app/features/img-export/components/CompGraphic.module.css @@ -126,6 +126,41 @@ } } +.rangeBarAlternate { + background-image: repeating-linear-gradient( + -45deg, + transparent 0, + transparent 4px, + oklch(0% 0 0 / 0.25) 4px, + oklch(0% 0 0 / 0.25) 8px + ); +} + +.rangeLabel { + position: absolute; + inset-block: 0; + inset-inline-start: var(--s-1-5); + display: flex; + align-items: center; + font-size: var(--font-2xs); + font-weight: var(--weight-bold); + line-height: 1; + color: oklch(20% 0 0); + white-space: nowrap; +} + +.rangeLethalTick { + position: absolute; + inset-block: 0; + z-index: 1; + width: 0; + border-left: 2px solid oklch(20% 0 0 / 0.75); +} + +.rangeIconSpacer { + width: 28px; +} + .rangeBlast { position: absolute; inset-block: 0; diff --git a/app/features/img-export/components/CompGraphic.tsx b/app/features/img-export/components/CompGraphic.tsx index 4f75855c9..a20490406 100644 --- a/app/features/img-export/components/CompGraphic.tsx +++ b/app/features/img-export/components/CompGraphic.tsx @@ -6,6 +6,7 @@ import { SubWeaponImage, WeaponImage, } from "~/components/Image"; +import type { RangeVariantKey } from "~/features/build-analyzer/analyzer-types"; import { mainWeaponParams } from "~/features/build-analyzer/core/utils"; import { LETHAL_DAMAGE, @@ -16,6 +17,7 @@ import type { DamageCombo, DamageSegment, } from "~/features/comp-analyzer/comp-analyzer-types"; +import * as SpecialWeaponRange from "~/features/comp-analyzer/core/SpecialWeaponRange"; import * as WeaponRange from "~/features/comp-analyzer/core/WeaponRange"; import type { MainWeaponId } from "~/modules/in-game-lists/types"; import { COMP_ANALYZER_URL, navIconUrl } from "~/utils/urls"; @@ -40,6 +42,9 @@ export function CompGraphic({ title, showRanges = true, showCombos = true, + enabledVariantKeys, + hiddenRangeWeaponIds = [], + showSpecialRanges = false, }: { weaponIds: MainWeaponId[]; /** Without a title the whole header is left out */ @@ -48,10 +53,21 @@ export function CompGraphic({ combos: DamageCombo[]; showRanges?: boolean; showCombos?: boolean; + /** Ways of shooting each weapon drawn in the range chart, its default when none */ + enabledVariantKeys?: (weaponId: MainWeaponId) => RangeVariantKey[]; + /** Weapons left out of the range chart */ + hiddenRangeWeaponIds?: MainWeaponId[]; + showSpecialRanges?: boolean; }) { const { t } = useTranslation(["analyzer"]); - const weaponsWithRange = WeaponRange.ofWeapons(weaponIds); + const weaponsWithRange = WeaponRange.ofWeapons( + weaponIds, + enabledVariantKeys, + ).filter((weapon) => !hiddenRangeWeaponIds.includes(weapon.weaponId)); + const specialRanges = showSpecialRanges + ? SpecialWeaponRange.ofWeapons(weaponIds) + : []; const topCombos = combos.slice(0, MAX_COMBOS); return ( @@ -78,12 +94,15 @@ export function CompGraphic({ /> ))}
- {showRanges && weaponsWithRange.length > 0 ? ( + {showRanges && weaponsWithRange.length + specialRanges.length > 0 ? ( <> {t("analyzer:comp.weaponRanges")} - + ) : null} {showCombos && topCombos.length > 0 ? ( @@ -146,52 +165,111 @@ function WeaponRow({ function RangeChart({ weapons, + specialRanges, }: { - weapons: Array<{ - weaponId: MainWeaponId; - range: number; - blastRadius?: number; - slot: number; - }>; + weapons: WeaponRange.WeaponWithRange[]; + specialRanges: SpecialWeaponRange.CompSpecialWithRange[]; }) { + const { t } = useTranslation(["analyzer"]); + return (
- {weapons.map((weapon) => ( -
- + weapon.variants.map((variant, index) => ( +
+ {index === 0 ? ( + + ) : ( +
+ )} + 0 + ? t(`analyzer:comp.rangeVariant.${variant.key}`) + : undefined + } + /> +
{variant.range.toFixed(1)}
+
+ )), + )} + {specialRanges.map((special) => ( +
+ -
-
- {weapon.blastRadius ? ( -
- ) : null} -
-
{weapon.range.toFixed(1)}
+ +
{special.range.toFixed(1)}
))}
); } +function RangeTrack({ + slot, + range, + blastRadius, + lethalDistance, + isAlternate = false, + label, +}: { + slot: number; + range: number; + blastRadius?: number; + lethalDistance?: number; + isAlternate?: boolean; + label?: string; +}) { + return ( +
+
+ {label ? {label} : null} +
+ {blastRadius ? ( +
+ ) : null} + {lethalDistance ? ( +
+ ) : null} +
+ ); +} + function ComboRow({ combo }: { combo: DamageCombo }) { const { t } = useTranslation(["analyzer"]); diff --git a/changelog/2026-10-28-comp-analyzer-range-variants.md b/changelog/2026-10-28-comp-analyzer-range-variants.md new file mode 100644 index 000000000..9e3d73649 --- /dev/null +++ b/changelog/2026-10-28-comp-analyzer-range-variants.md @@ -0,0 +1,11 @@ +--- +navItem: comp-analyzer +type: feature +--- +Comp analyzer range chart shows more than max range + +- Toggle other ways of shooting a weapon: roller and Splatana swings, Squeezer hold, Ballpoint short range, S-BLAST jump shots, charger taps, stringer partial charges and dualie turrets +- Rollers and brushes mark how far they still splat in their fewest hits +- Show the ranges of the comp's special weapons +- Hide a weapon from the range chart by clicking its icon +- Wider page and a taller range chart, so overlapping trajectories are easier to tell apart diff --git a/changelog/2026-10-28-weapon-range-accuracy.md b/changelog/2026-10-28-weapon-range-accuracy.md new file mode 100644 index 000000000..df54a218d --- /dev/null +++ b/changelog/2026-10-28-weapon-range-accuracy.md @@ -0,0 +1,5 @@ +--- +navItem: [comp-analyzer, plans] +type: bug +--- +More accurate weapon ranges: sloshers and brushes no longer reach too far, blaster shots burst mid-air, vertical roller flicks fly further, Trizooka reaches further and Crab Tank shows its cannon range diff --git a/locales/en/analyzer.json b/locales/en/analyzer.json index 529fa9d41..011465014 100644 --- a/locales/en/analyzer.json +++ b/locales/en/analyzer.json @@ -212,6 +212,22 @@ "comp.enemySubDef": "Enemy Sub Defense Up", "comp.weaponRanges": "Weapon Ranges", "comp.damageCombos": "Damage Combos", + "comp.specialRanges": "Special ranges", + "comp.hideFromRangeChart": "Hide {{weapon}} from the range chart", + "comp.showInRangeChart": "Show {{weapon}} in the range chart", + "comp.lethalRange": "{{shots}}-shot ≤ {{distance}}", + "comp.rangeVariant.vertical": "Vertical", + "comp.rangeVariant.horizontal": "Horizontal", + "comp.rangeVariant.tap": "Tap", + "comp.rangeVariant.hold": "Hold", + "comp.rangeVariant.long": "Long", + "comp.rangeVariant.short": "Short", + "comp.rangeVariant.ground": "Ground", + "comp.rangeVariant.jump": "Jump", + "comp.rangeVariant.charged": "Charged", + "comp.rangeVariant.partialCharge": "Partial charge", + "comp.rangeVariant.standard": "Standard", + "comp.rangeVariant.turret": "Turret", "comp.subRoles": "Sub weapon roles", "comp.specialRoles": "Special weapon roles", "comp.subCategory.LETHAL": "One-hit", diff --git a/scripts/create-analyzer-json.ts b/scripts/create-analyzer-json.ts index 24798a0f3..8194525c1 100644 --- a/scripts/create-analyzer-json.ts +++ b/scripts/create-analyzer-json.ts @@ -6,8 +6,10 @@ import { fileURLToPath } from "node:url"; import * as v from "valibot"; import type { BaseWeaponStats, + DistanceDamage, MainWeaponParams, ParamsJson, + RangeParams, SubWeaponParams, WeaponKit, } from "~/features/build-analyzer/analyzer-types"; @@ -256,7 +258,15 @@ function getWeaponCategoryName(weaponId: number): string | undefined { return undefined; } -function extractRangeParams(weapon: MainWeapon, params: any) { +function extractRangeParams( + weapon: MainWeapon, + params: any, +): RangeParams & + Pick & + Pick< + BaseWeaponStats, + "DistanceFullCharge" | "DistanceMaxCharge" | "DistanceMinCharge" + > { const category = getWeaponCategoryName(weapon.Id); const isBrella = category === "BRELLAS"; const isSlosher = category === "SLOSHERS"; @@ -265,14 +275,31 @@ function extractRangeParams(weapon: MainWeapon, params: any) { return {}; } + const zRate = params.spl__SpawnBulletAdditionMovePlayerParam?.ZRate; const isCharger = params.MoveParam?.$type === "spl__BulletChargerMoveParam"; if (isCharger) { - return { + const chargeDistances = { DistanceFullCharge: params.MoveParam?.DistanceFullCharge, DistanceMaxCharge: params.MoveParam?.DistanceMaxCharge, DistanceMinCharge: params.MoveParam?.DistanceMinCharge, }; + if ( + chargeDistances.DistanceMinCharge === chargeDistances.DistanceFullCharge + ) { + return chargeDistances; + } + + return { + ...chargeDistances, + Range_VariantKey: "charged", + Range_Variants: [ + { + Range_VariantKey: "tap", + Range_Distance: chargeDistances.DistanceMinCharge, + }, + ], + }; } if (isSlosher) { @@ -284,59 +311,89 @@ function extractRangeParams(weapon: MainWeapon, params: any) { : best, units?.[0], ); - const moveParam = unitForRange?.MoveParam; const isBloblobber = weapon.Id === 3030 || weapon.Id === 3031; + const bounceAfterMaxSpeed = params.BounceGroupParam?.BounceParam?.find( + (bounceParam: any) => bounceParam.BounceAfterMaxSpeed !== undefined, + )?.BounceAfterMaxSpeed; return { - Range_SpawnSpeed: unitForRange?.SpawnSpeedGround, - Range_GoStraightStateEndMaxSpeed: moveParam?.GoStraightStateEndMaxSpeed, - Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, - Range_FreeGravity: moveParam?.FreeGravity, - Range_BrakeAirResist: moveParam?.BrakeAirResist, - Range_BrakeGravity: moveParam?.BrakeGravity, - Range_BrakeToFreeStateFrame: moveParam?.BrakeToFreeStateFrame, - Range_ZRate: params.spl__SpawnBulletAdditionMovePlayerParam?.ZRate, - Range_BounceAfterMaxSpeed: isBloblobber ? 0.6 : undefined, - Range_BurstFrame: isBloblobber ? 3 : undefined, + ...rangeParamsFromMoveParam( + unitForRange?.MoveParam, + unitForRange?.SpawnSpeedGround, + ), + Range_ZRate: zRate, + Range_BounceAfterMaxSpeed: isBloblobber ? bounceAfterMaxSpeed : undefined, + Range_BurstFrame: isBloblobber ? BLOBLOBBER_BOUNCES : undefined, }; } const isRoller = category === "ROLLERS"; if (isRoller) { - const unit = params.VerticalSwingUnitGroupParam?.Unit?.[0]; - const moveParam = unit?.UnitParam?.MoveParam; + const verticalUnit = params.VerticalSwingUnitGroupParam?.Unit?.[0]; + const horizontalUnit = params.WideSwingUnitGroupParam?.Unit?.[0]; return { - Range_SpawnSpeed: unit?.SpawnSpeedBase, - Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, - Range_FreeGravity: moveParam?.FreeGravity, - Range_FreeAirResist: moveParam?.FreeAirResist, - Range_ZRate: params.spl__SpawnBulletAdditionMovePlayerParam?.ZRate, + ...rangeParamsFromMoveParam( + verticalUnit?.UnitParam?.MoveParam, + verticalUnit?.SpawnSpeedBase, + ), + Range_SpawnAngle: verticalUnit?.SpawnRotateXDegreeBase, + Range_DistanceDamage: distanceDamageCurve( + params.VerticalSwingUnitGroupParam?.DamageParam?.Inside, + ), + Range_ZRate: zRate, + Range_VariantKey: "vertical", + Range_Variants: [ + { + ...rangeParamsFromMoveParam( + horizontalUnit?.UnitParam?.MoveParam, + horizontalUnit?.SpawnSpeedBase, + ), + Range_DistanceDamage: distanceDamageCurve( + params.WideSwingUnitGroupParam?.DamageParam?.Inside, + ), + Range_VariantKey: "horizontal", + }, + ], }; } const isBrush = category === "BRUSHES"; if (isBrush) { const unit = params.SwingUnitGroupParam?.Unit?.[0]; - const moveParam = unit?.UnitParam?.MoveParam; return { - Range_SpawnSpeed: unit?.SpawnSpeedBase, - Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, - Range_ZRate: params.spl__SpawnBulletAdditionMovePlayerParam?.ZRate, + ...rangeParamsFromMoveParam( + unit?.UnitParam?.MoveParam, + unit?.SpawnSpeedBase, + ), + Range_DistanceDamage: distanceDamageCurve( + params.SwingUnitGroupParam?.DamageParam?.Inside, + ), + Range_ZRate: zRate, }; } const isSplatana = category === "SPLATANAS"; if (isSplatana) { - const bulletParam = params.BulletSaberVerticalParam; - const moveParam = bulletParam?.MoveParam; - return { - Range_SpawnSpeed: moveParam?.SpawnSpeed, - Range_GoStraightStateEndMaxSpeed: moveParam?.GoStraightStateEndMaxSpeed, - Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, - Range_FreeGravity: moveParam?.FreeGravity, - Range_BrakeAirResist: moveParam?.BrakeAirResist, - Range_BrakeGravity: moveParam?.BrakeGravity, - Range_BrakeToFreeStateFrame: moveParam?.BrakeToFreeStateFrame, + const swingParam = params.spl__WeaponSaberParam?.SwingParam; + const splatanaRangeParams = (bulletParam: any, shotBulletOffset: any) => ({ + ...rangeParamsFromMoveParam(bulletParam?.MoveParam), + Range_SpawnOffsetZ: shotBulletOffset?.Z, Range_BurstFrame: bulletParam?.BurstParam?.BurstFrame, + }); + return { + ...splatanaRangeParams( + params.BulletSaberVerticalParam, + swingParam?.ShotBulletOffset_Vertical, + ), + Range_VariantKey: "charged", + Range_Variants: [ + { + ...splatanaRangeParams( + params.BulletSaberHorizontalParam, + swingParam?.ShotBulletOffset_R, + ), + Range_VariantKey: "tap", + }, + ], }; } @@ -350,50 +407,172 @@ function extractRangeParams(weapon: MainWeapon, params: any) { ? undefined : bulletParam?.DetonationParam?.BlastParam?.DistanceDamage?.[0]?.Distance; return { - Range_SpawnSpeed: moveParam?.SpawnSpeedMax, - Range_GoStraightStateEndMaxSpeed: moveParam?.GoStraightStateEndMaxSpeed, - Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, - Range_FreeGravity: moveParam?.FreeGravity, - Range_FreeAirResist: moveParam?.FreeAirResist, - Range_BrakeAirResist: moveParam?.BrakeAirResist, - Range_BrakeGravity: moveParam?.BrakeGravity, - Range_BrakeToFreeStateFrame: moveParam?.BrakeToFreeStateFrame, + ...rangeParamsFromMoveParam(moveParam, moveParam?.SpawnSpeedMax), BlastRadius: blastRadius, + Range_VariantKey: "charged", + Range_Variants: [ + { + ...rangeParamsFromMoveParam(moveParam, moveParam?.SpawnSpeedMid), + BlastRadius: blastRadius, + Range_VariantKey: "partialCharge", + }, + ], }; } const isSplatling = category === "SPLATLINGS"; if (isSplatling) { const isBallpoint = weapon.Id === 4030 || weapon.Id === 4031; - const moveParam = isBallpoint ? params.VariableMoveParam : params.MoveParam; + const splatlingRangeParams = (moveParam: any) => + rangeParamsFromMoveParam( + moveParam, + moveParam?.SpawnSpeedFirstLastAndSecond, + ); + if (isBallpoint) { + return { + ...splatlingRangeParams(params.VariableMoveParam), + Range_VariantKey: "long", + Range_Variants: [ + { + ...splatlingRangeParams(params.MoveParam), + Range_VariantKey: "short", + }, + ], + }; + } + return splatlingRangeParams(params.MoveParam); + } + + if (isBrella) { return { - Range_SpawnSpeed: isBallpoint - ? moveParam?.SpawnSpeed - : moveParam?.SpawnSpeedFirstLastAndSecond, - Range_GoStraightStateEndMaxSpeed: moveParam?.GoStraightStateEndMaxSpeed, - Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, + ...rangeParamsFromMoveParam( + params.spl__BulletShelterShotgunParam?.GroupParams?.[0]?.MoveParam, + ), + Range_ZRate: zRate, }; } const isBlaster = params.BlastParam?.DistanceDamage !== undefined; - const blastRadius = isBlaster - ? params.BlastParam?.DistanceDamage?.[1]?.Distance - : undefined; + if (isBlaster) { + const blasterRangeParams = ( + moveParam: any, + burstParam: any, + blastParam: any, + ) => ({ + ...rangeParamsFromMoveParam(moveParam), + Range_BurstFrame: + burstParam?.BurstFrame ?? params.WeaponParam?.ShotGuideFrame, + Range_ZRate: zRate, + BlastRadius: blastParam?.DistanceDamage?.[1]?.Distance, + }); + const groundRangeParams = blasterRangeParams( + params.MoveParam, + params.BlasterBurstParam, + params.BlastParam, + ); + if (!params.MoveJumpParam) return groundRangeParams; - const moveParam = isBrella - ? params.spl__BulletShelterShotgunParam?.GroupParams?.[0]?.MoveParam - : params.MoveParam; + return { + ...groundRangeParams, + Range_VariantKey: "ground", + Range_Variants: [ + { + ...blasterRangeParams( + params.MoveJumpParam, + params.BlasterBurstJumpParam, + params.BlastJumpParam, + ), + Range_VariantKey: "jump", + }, + ], + }; + } + const shooterRangeParams = (moveParam: any) => ({ + ...rangeParamsFromMoveParam(moveParam), + Range_ZRate: zRate, + }); + + if (params.MoveLapOverParam) { + return { + ...shooterRangeParams(params.MoveParam), + Range_VariantKey: "standard", + Range_Variants: [ + { + ...shooterRangeParams(params.MoveLapOverParam), + Range_VariantKey: "turret", + }, + ], + }; + } + + if (params.VariableMoveParam) { + return { + ...shooterRangeParams(params.MoveParam), + Range_VariantKey: "tap", + Range_Variants: [ + { + ...shooterRangeParams(params.VariableMoveParam), + Range_VariantKey: "hold", + }, + ], + }; + } + + return shooterRangeParams(params.MoveParam); +} + +// how many times a Bloblobber bubble bounces before bursting, not in the params +const BLOBLOBBER_BOUNCES = 3; + +function rangeParamsFromMoveParam( + moveParam: any, + spawnSpeed: number | undefined = moveParam?.SpawnSpeed, +): RangeParams { return { - Range_SpawnSpeed: moveParam?.SpawnSpeed, + Range_SpawnSpeed: spawnSpeed, Range_GoStraightStateEndMaxSpeed: moveParam?.GoStraightStateEndMaxSpeed, Range_GoStraightToBrakeStateFrame: moveParam?.GoStraightToBrakeStateFrame, Range_FreeGravity: moveParam?.FreeGravity, - Range_ZRate: params.spl__SpawnBulletAdditionMovePlayerParam?.ZRate, - BlastRadius: blastRadius, + Range_FreeAirResist: moveParam?.FreeAirResist, + Range_BrakeAirResist: moveParam?.BrakeAirResist, + Range_BrakeGravity: moveParam?.BrakeGravity, + Range_BrakeToFreeStateFrame: moveParam?.BrakeToFreeStateFrame, + Range_BrakeToFreeVelocityY: moveParam?.BrakeToFreeVelocityY, }; } +// roller & brush ink damage falls off linearly between these distances +function distanceDamageCurve(damageParam: any): DistanceDamage[] | undefined { + if (!damageParam) return undefined; + + const points: DistanceDamage[] = [ + { + Damage: damageParam.DamageMaxValue, + Distance: damageParam.DamageMaxDistance, + }, + { + Damage: damageParam.DamageHighValue, + Distance: damageParam.DamageHighDistance, + }, + { + Damage: damageParam.DamageLowValue, + Distance: damageParam.DamageLowDistance, + }, + { + Damage: damageParam.DamageMinValue, + Distance: damageParam.DamageMinDistance, + }, + ]; + + return points.filter( + (point, i) => + i === 0 || + point.Damage !== points[i - 1].Damage || + point.Distance !== points[i - 1].Distance, + ); +} + function parametersToMainWeaponResult( weapon: MainWeapon, params: any, @@ -720,6 +899,8 @@ const BOOYAH_BOMB_FLY_DISTANCE = 27; const SUPER_CHUMP_FLY_DISTANCE = 30; const TRIPLE_INKSTRIKE_FLY_DISTANCE = 28; const ULTRA_STAMP_FLY_DISTANCE = 24; +// not in the params, value from the "Calculating weapon range" community sheet +const CRAB_TANK_CANNON_SPAWN_SPEED = 2; // Range circles for the map planner (see app/features/comp-analyzer/core/SpecialWeaponRange.ts): // travel distance plus blast, or a single effect radius. Global (Tenta Missiles, Killer Wail), placed/utility @@ -740,6 +921,7 @@ function specialWeaponRangeParams( Range_BrakeAirResist: moveParam?.BrakeAirResist, Range_BrakeGravity: moveParam?.BrakeGravity, Range_BrakeToFreeStateFrame: moveParam?.BrakeToFreeStateFrame, + Range_BrakeToFreeVelocityY: moveParam?.BrakeToFreeVelocityY, }); switch (specialWeapon.__RowId) { @@ -753,9 +935,10 @@ function specialWeaponRangeParams( Range_Distance: rawParams.MoveParam?.Distance, Range_BlastRadius: outerBlastDistance(rawParams.BlastParam), }; - case "SpChariot": // Crab Tank (rapid gun reach) + case "SpChariot": // Crab Tank (cannon shot) return { - ...trajectoryFromMoveParam(rawParams.ShooterMoveParam), + ...trajectoryFromMoveParam(rawParams.CannonParam?.MoveParam), + Range_SpawnSpeed: CRAB_TANK_CANNON_SPAWN_SPEED, Range_BlastRadius: outerBlastDistance( rawParams.CannonParam?.BlastParam, ),