src/unitStats/mappingSbps.ts (1)

108-108: Avoid blindly casting parent to SbpsType["unitType"]

unitType: parent as SbpsType["unitType"] bypasses the new type guarantees. Consider normalizing/validating parent (e.g. via a small mapping or type guard) and either skipping or logging unknown values instead of asserting.

src/unitStats/dpsCommon.ts (1)

231-236: Harden armor lookup against missing armorLayout

def_ebps is guarded, but armorLayout on the vehicle override line isn’t:

if (custUnit.unit_type == "vehicles")
  custUnit.armor = def_ebps?.health.armorLayout.frontArmor || 1;

If armorLayout is ever absent, this will throw. Matching the earlier optional chaining keeps it safe:

-    if (custUnit.unit_type == "vehicles")
-      custUnit.armor = def_ebps?.health.armorLayout.frontArmor || 1;
+    if (custUnit.unit_type == "vehicles")
+      custUnit.armor = def_ebps?.health.armorLayout?.frontArmor || 1;

You could also cache frontArmor once to avoid repeating the property chain.

src/unitStats/weaponLib.ts (1)

219-255: Target-type multipliers wiring looks directionally right but a few edge-cases need tightening

• You assume target_unit.ebps_default.unitTypes is always defined; if ebps_default was never resolved, this will throw. Guard it (or default to an empty array) before .find(...).
• target_damage_mp and target_accuracy_mp only feed into aoeDamageCombines; they don’t affect the direct-hit term finalHitChance * finalDamage. If engine semantics expect these multipliers to apply to all shots vs that target type (not only AoE), you may still be under/over-estimating DPS, especially for low-AoE weapons like AT guns.
• weaponTargetType.penetration_multiplier (and suppression-related multipliers) are currently ignored. If those matter for per-target behavior, they likely should factor into aoePenetrationChance and/or the single-target penetration path.

Given the PR goal is “correct approach to handle the weapons multipliers per target type”, it’s worth double-checking these design points against the game data/schema.

src/unitStats/mappingWeapon.ts (1)

328-343: Tighten target_type_table mapping to avoid invalid unit types and swallowing 0 multipliers

Two things to watch in this mapper:

1. unit_type fallback breaks the literal union and can misrepresent data

unit_type: targetType.target_unit_type_multipliers?.unit_type || "",

"" is not a valid TargetUnitTypeMultipliers["unit_type"] and will cause TypeScript friction or force you back toward any. It also means you push entries even when target_unit_type_multipliers is missing.

2. || 1 hides explicit zero multipliers

For example:

accuracy_multiplier:
  targetType.target_unit_type_multipliers?.weapon_multipliers?.accuracy_multiplier || 1,

If the JSON contains a real 0 (e.g. “never hit infantry”), this code turns it into 1, completely changing behavior.

A safer pattern:

- if (weapon_bag.target_type_table && weapon_bag.target_type_table.length > 0) {
-   for (const targetType of weapon_bag.target_type_table) {
-     weaponData.weapon_bag.target_type_table.push({
-       unit_type: targetType.target_unit_type_multipliers?.unit_type || "",
-       dmg_modifier: targetType.target_unit_type_multipliers?.base_damage_modifier || 0,
-       accuracy_multiplier:
-         targetType.target_unit_type_multipliers?.weapon_multipliers?.accuracy_multiplier || 1,
-       penetration_multiplier:
-         targetType.target_unit_type_multipliers?.weapon_multipliers?.penetration_multiplier || 1,
-       damage_multiplier:
-         targetType.target_unit_type_multipliers?.weapon_multipliers?.damage_multiplier || 1,
-     });
-   }
- }
+ if (weapon_bag.target_type_table && weapon_bag.target_type_table.length > 0) {
+   for (const { target_unit_type_multipliers } of weapon_bag.target_type_table) {
+     if (!target_unit_type_multipliers) continue;
+     const wm = target_unit_type_multipliers.weapon_multipliers ?? {};
+     weaponData.weapon_bag.target_type_table.push({
+       unit_type: target_unit_type_multipliers.unit_type,
+       dmg_modifier: target_unit_type_multipliers.base_damage_modifier ?? 0,
+       accuracy_multiplier: wm.accuracy_multiplier ?? 1,
+       penetration_multiplier: wm.penetration_multiplier ?? 1,
+       damage_multiplier: wm.damage_multiplier ?? 1,
+     });
+   }
+ }

This keeps the literal union intact and preserves explicit 0 values while still defaulting missing fields sensibly.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/unitStats/weaponLib.ts (1)

224-227: Consider guarding ebps_default with optional chaining as well

target_unit?.ebps_default.unitTypes only short‑circuits when target_unit is null/undefined; if a CustomizableUnit instance can exist without ebps_default, this will throw at runtime when trying to read .unitTypes from undefined.

To make this more defensive without changing behavior when everything is populated, consider:

const targetUnitTypes = target_unit?.ebps_default?.unitTypes ?? [];

If the type system guarantees ebps_default is always present whenever target_unit is, this is purely a safety/clarity win and not strictly required.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/unitStats/weaponLib.ts (1)

238-245: Target-type multipliers and bonus are applied inconsistently.

As noted in the previous review, target_damage_bonus is added to aoeDamageCombines without being scaled by aoePenetrationChance or memberHit, which means it contributes to DPS even when the AoE doesn't actually hit or penetrate.

Additionally, the target-type multipliers (target_damage_mp, target_accuracy_mp) only affect the AoE damage term (aoeDamageCombines) but not the direct-hit damage (finalHitChance * finalDamage on Line 325). If these multipliers are intended to affect all damage against the target type (not just splash), they should also be applied to finalDamage and finalAccuracy. If the AoE-only behavior is intentional for AT guns (as the PR title suggests), please add a comment explaining why direct hits are excluded.

Consider scaling target_damage_bonus consistently:

     /** Compute the combined AOE damage multipliers. */
     const aoe_damage_multi =
       aoe_damage * target_damage_mp * target_accuracy_mp * aoePenetrationChance * memberHit;
+    const scaled_target_damage_bonus = 
+      target_damage_bonus * target_damage_mp * target_accuracy_mp * aoePenetrationChance * memberHit;
 
     /** Compute the final AOE damage combined with the base damage modifier (if
      * applies). */
-    aoeDamageCombines = target_damage_bonus + aoe_damage_multi;
+    aoeDamageCombines = scaled_target_damage_bonus + aoe_damage_multi;

Or if direct hits should also be affected by target-type modifiers:

   let finalAccuracy = acc_combined;
   let finalDamage = avgDamage;
+
+  // Apply target-type multipliers to direct hits
+  finalDamage = finalDamage * target_damage_mp;
+  finalAccuracy = finalAccuracy * target_accuracy_mp;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro