Refine type of AttackableEntities.

GitOrigin-RevId: 80a26b6c7ce3e0bbddcdc7b5181db914b706b79b

Author: cpojer

hera/behavior/Attack.tsx

@@ -22,53 +22,51 @@ export default class Attack {
   ): StateLike | null {
     const entities = getAttackableEntities(vector, state);
     const { attackable, radius, selectedUnit } = state;
-    if (attackable && radius) {
+    if (attackable && radius && entities) {
       const entityB = entities.unit || entities.building;
-      if (entityB) {
-        const onAction = (state: State) => {
-          if (entities.unit && entities.building) {
-            return {
-              attackable: new Map([[vector, attackable.get(vector)!]]),
-              confirmAction: null,
-              radius: {
-                ...radius,
-                fields: new Map([[vector, radius.fields.get(vector)!]]),
-              },
-              selectedAttackable: vector,
-              showCursor: false,
-            };
-          } else if (entityB && selectedUnit?.getAttackWeapon(entityB)) {
-            const { selectedPosition, selectedUnit } = state;
-            if (selectedPosition && selectedUnit) {
-              requestAnimationFrame(() =>
-                attackAction(
-                  actions,
-                  selectedPosition,
-                  selectedUnit,
-                  vector,
-                  entityB,
-                  state,
-                ),
-              );
-            }
+      const onAction = (state: State) => {
+        if (entities.unit && entities.building) {
+          return {
+            attackable: new Map([[vector, attackable.get(vector)!]]),
+            confirmAction: null,
+            radius: {
+              ...radius,
+              fields: new Map([[vector, radius.fields.get(vector)!]]),
+            },
+            selectedAttackable: vector,
+            showCursor: false,
+          };
+        } else if (entityB && selectedUnit?.getAttackWeapon(entityB)) {
+          const { selectedPosition, selectedUnit } = state;
+          if (selectedPosition && selectedUnit) {
+            requestAnimationFrame(() =>
+              attackAction(
+                actions,
+                selectedPosition,
+                selectedUnit,
+                vector,
+                entityB,
+                state,
+              ),
+            );
           }
-          return { confirmAction: null };
-        };
+        }
+        return { confirmAction: null };
+      };
 
-        return shouldConfirm
-          ? {
-              confirmAction: {
-                icon: 'attack',
-                onAction,
-                position: vector,
-              },
-              radius: {
-                ...radius,
-                locked: true,
-              },
-            }
-          : onAction(state);
-      }
+      return shouldConfirm
+        ? {
+            confirmAction: {
+              icon: 'attack',
+              onAction,
+              position: vector,
+            },
+            radius: {
+              ...radius,
+              locked: true,
+            },
+          }
+        : onAction(state);
     }
 
     return null;

hera/behavior/Move.tsx

@@ -300,7 +300,6 @@ export default class Move {
         );
         const moveToField = field || (parent ? RadiusItem(parent) : null);
         const entities = getAttackableEntities(vector, state);
-
         if (moveToField && parent && entities) {
           const onAction = (state: State) => {
             const entity = entities.unit || entities.building;
@@ -320,15 +319,15 @@ export default class Move {
                 selectedAttackable: vector,
                 showCursor: false,
               };
-            } else if (entity && selectedUnit.getAttackWeapon(entity)) {
+            } else if (selectedUnit.getAttackWeapon(entity)) {
               requestAnimationFrame(() =>
                 moveAndAttack(
                   actions,
                   selectedPosition,
                   parent,
                   vector,
                   path,
-                  (entities.unit || entities.building)!,
+                  entity,
                   radius.fields,
                   state,
                 ),

hera/behavior/attack/AttackSelector.tsx

@@ -58,27 +58,27 @@ export default function AttackSelector({
         return getAttackableEntities(position, state);
       }
     }
-    return { building: null, unit: null };
+    return null;
   }, [position, selectedAttackable, selectedPosition, selectedUnit, state]);
 
   const selectBuilding = useCallback(() => {
-    if (entities.building) {
+    if (entities?.building) {
       onSelect(entities.building);
     }
-  }, [entities.building, onSelect]);
+  }, [entities, onSelect]);
 
   const selectUnit = useCallback(() => {
-    if (entities.unit) {
+    if (entities?.unit) {
       onSelect(entities.unit);
     }
-  }, [entities.unit, onSelect]);
+  }, [entities, onSelect]);
 
   if (!selectedPosition || !selectedUnit) {
     return null;
   }
 
   if (selectedAttackable) {
-    if (entities.unit && entities.building) {
+    if (entities?.unit && entities.building) {
       return (
         <EntityPickerFlyout
           animationConfig={animationConfig}
@@ -98,7 +98,7 @@ export default function AttackSelector({
       );
     }
   } else if (position) {
-    if (entities.building || entities.unit) {
+    if (entities) {
       const isShortRange = selectedUnit.info.isShortRange();
       const targetPosition = origin || selectedPosition;
       const futureMap =

hera/behavior/attack/getAttackableEntities.tsx

@@ -3,10 +3,20 @@ import Unit from '@deities/athena/map/Unit.tsx';
 import Vector from '@deities/athena/map/Vector.tsx';
 import { State } from '../../Types.tsx';
 
-type AttackableEntities = {
-  building: Building | null;
-  unit: Unit | null;
-};
+type AttackableEntities =
+  | Readonly<{
+      building: Building;
+      unit: Unit;
+    }>
+  | {
+      building: Building;
+      unit?: null;
+    }
+  | {
+      building?: null;
+      unit: Unit;
+    }
+  | null;
 
 export default function getAttackableEntities(
   vector: Vector,
@@ -19,22 +29,28 @@ export default function getAttackableEntities(
     attackable.has(vector) &&
     vision.isVisible(map, vector)
   ) {
-    const unit = map.units.get(vector);
-    const building = map.buildings.get(vector);
-    return {
-      building:
-        building &&
-        map.isOpponent(building, selectedUnit) &&
-        selectedUnit.getAttackWeapon(building)
-          ? building
-          : null,
-      unit:
-        unit &&
-        map.isOpponent(unit, selectedUnit) &&
-        selectedUnit.getAttackWeapon(unit)
-          ? unit
-          : null,
-    };
+    const targetUnit = map.units.get(vector);
+    const targetBuilding = map.buildings.get(vector);
+    const building =
+      targetBuilding &&
+      map.isOpponent(targetBuilding, selectedUnit) &&
+      selectedUnit.getAttackWeapon(targetBuilding)
+        ? targetBuilding
+        : null;
+    const unit =
+      targetUnit &&
+      map.isOpponent(targetUnit, selectedUnit) &&
+      selectedUnit.getAttackWeapon(targetUnit)
+        ? targetUnit
+        : null;
+
+    return building && unit
+      ? { building, unit }
+      : building
+        ? { building }
+        : unit
+          ? { unit }
+          : null;
   }
-  return { building: null, unit: null };
+  return null;
 }