simplify compatibility logic

packages/website-ue/src/components/TankopediaLoadout/index.tsx

@@ -55,12 +55,11 @@ function Consumables() {
   const consumables = useConsumables();
   const tierPrices = useTierPrices();
   const tank = useProtagonist();
-  const isCompatible = useCompatibility();
+  const isCompatible = useCompatibility(tank);
 
   return Object.values(consumables.consumables).map(
     ({ compatibility, consumable }) => {
-      if (!isCompatible(compatibility!, tank)) return null;
+      if (!isCompatible(compatibility!)) return null;
-
       return <span>{consumable!.name_key}</span>;
     },
   );

packages/website-ue/src/hooks/useCompatibility.ts

@@ -6,75 +6,60 @@ import type { Sets } from "@protos/sets";
 import type { Tank } from "@protos/tank";
 import { useSets } from "./useSets";
 
-export function useCompatibility(
+export function useCompatibility(tank: Tank) {
-  compatibility: CompatibilityComponent,
-  tank: Tank,
-) {
   const sets = useSets();
 
-  return function (
+  return function (compatibility: CompatibilityComponent) {
-    {
-      tank_compatibility,
-      tank_set_compatibility,
-      game_type_compatibility,
-      quest_compatibility,
-      quest_slots_compatibility,
-      tank_style_compatibility,
-    }: CompatibilityComponent,
-    tank: Tank,
-  ) {
     if (
-      tank_set_compatibility ||
+      compatibility.tank_set_compatibility ||
-      game_type_compatibility ||
+      compatibility.game_type_compatibility ||
-      quest_compatibility ||
+      compatibility.quest_compatibility ||
-      quest_slots_compatibility ||
+      compatibility.quest_slots_compatibility ||
-      tank_style_compatibility
+      compatibility.tank_style_compatibility
     ) {
       throw new Error("Not implemented");
     }
 
-    if (
+    return (
-      tank_compatibility !== undefined &&
+      compatibility.tank_compatibility === undefined ||
-      (!tankCompatibilityApplies(tank_compatibility.include!, tank, sets) ||
+      (tankCompatibilityApplies(
-        tankCompatibilityApplies(tank_compatibility.exclude!, tank, sets))
+        compatibility.tank_compatibility.include,
-    ) {
+        tank,
-      return false;
+        sets,
-    }
+      ) &&
-
+        !tankCompatibilityApplies(
-    return true;
+          compatibility.tank_compatibility.exclude,
+          tank,
+          sets,
+        ))
+    );
   };
 }
 
 function tankCompatibilityApplies(
-  {
+  include: TankCompatibility_Include | undefined,
-    nations,
-    tiers,
-    tier_catalog_ids,
-    classes,
-    catalogs_id,
-    tank_traits,
-    types,
-    tank_sets_catalog_ids,
-    is_special,
-    tech_tags,
-    ...rest
-  }: TankCompatibility_Include,
   tank: Tank,
   sets: Sets,
 ) {
-  if (is_special) {
+  if (include === undefined) {
+    return true;
+  }
+
+  if (include.is_special) {
     throw new Error("is_special Not implemented");
   }
 
   return (
-    nations.some((nation) => nation === tank.tank!.nation) ||
+    include.nations.some((nation) => nation === tank.tank!.nation) ||
-    tiers.some((tier) => tier === tank.tank!.tier) ||
+    include.tiers.some((tier) => tier === tank.tank!.tier) ||
-    tier_catalog_ids.some((tier) => tier === tank.tank!.tier_catalog_id) ||
+    include.tier_catalog_ids.some(
-    classes.some((_class) => _class === tank.tank!.tank_class) ||
+      (tier) => tier === tank.tank!.tier_catalog_id,
-    catalogs_id.some((id) => id === tank.id) ||
+    ) ||
-    tank_traits.some((trait) => tankHasTraits(trait, tank)) ||
+    include.classes.some((_class) => _class === tank.tank!.tank_class) ||
-    types.some((type) => type === tank.tank!.tank_type) ||
+    include.catalogs_id.some((id) => id === tank.id) ||
-    tank_sets_catalog_ids.some((id) =>
+    include.tank_traits.some((trait) => tankHasTraits(trait, tank)) ||
+    include.types.some((type) => type === tank.tank!.tank_type) ||
+    include.tank_sets_catalog_ids.some((id) =>
       Object.entries(sets.sets).some(
         ([setId, set]) =>
           setId === id &&
@@ -85,7 +70,7 @@ function tankCompatibilityApplies(
           ),
       ),
     ) ||
-    tech_tags.some((tag) => tank.tank!.tech_tags.includes(tag))
+    include.tech_tags.some((tag) => tank.tank!.tech_tags.includes(tag))
   );
 }