From 37bb83dfa61cc9949795140a9a7a17bbd861a7aa Mon Sep 17 00:00:00 2001
From: Dan Albert <dan@gingerhq.net>
Date: Mon, 7 Jun 2021 17:48:03 -0700
Subject: [PATCH] Delete a bunch of unused code from `Base`.

---
 game/theater/base.py | 108 -------------------------------------------
 1 file changed, 108 deletions(-)

diff --git a/game/theater/base.py b/game/theater/base.py
index 27390b2d..c7b154bb 100644
--- a/game/theater/base.py
+++ b/game/theater/base.py
@@ -26,7 +26,6 @@ class Base:
         self.armor: Dict[Type[VehicleType], int] = {}
         # TODO: Appears unused.
         self.aa: Dict[AirDefence, int] = {}
-        self.commision_points: Dict[Type, float] = {}
         self.strength = 1
 
     @property
@@ -79,61 +78,6 @@ class Base:
             self.aircraft.items(), self.armor.items(), self.aa.items()
         )
 
-    def _find_best_unit(
-        self, available_units: Dict[UnitType, int], for_type: Task, count: int
-    ) -> Dict[UnitType, int]:
-        if count <= 0:
-            logging.warning("{}: no units for {}".format(self, for_type))
-            return {}
-
-        sorted_units = [
-            key for key in available_units if key in db.UNIT_BY_TASK[for_type]
-        ]
-        sorted_units.sort(key=lambda x: db.PRICES[x], reverse=True)
-
-        result: Dict[UnitType, int] = {}
-        for unit_type in sorted_units:
-            existing_count = available_units[unit_type]  # type: int
-            if not existing_count:
-                continue
-
-            if count <= 0:
-                break
-
-            result_unit_count = min(count, existing_count)
-            count -= result_unit_count
-
-            assert result_unit_count > 0
-            result[unit_type] = result.get(unit_type, 0) + result_unit_count
-
-        logging.info("{} for {} ({}): {}".format(self, for_type, count, result))
-        return result
-
-    def _find_best_planes(
-        self, for_type: Task, count: int
-    ) -> typing.Dict[FlyingType, int]:
-        return self._find_best_unit(self.aircraft, for_type, count)
-
-    def _find_best_armor(self, for_type: Task, count: int) -> typing.Dict[Armor, int]:
-        return self._find_best_unit(self.armor, for_type, count)
-
-    def append_commision_points(self, for_type, points: float) -> int:
-        self.commision_points[for_type] = (
-            self.commision_points.get(for_type, 0) + points
-        )
-        points = self.commision_points[for_type]
-        if points >= 1:
-            self.commision_points[for_type] = points - math.floor(points)
-            return int(math.floor(points))
-
-        return 0
-
-    def filter_units(self, applicable_units: typing.Collection):
-        self.aircraft = {
-            k: v for k, v in self.aircraft.items() if k in applicable_units
-        }
-        self.armor = {k: v for k, v in self.armor.items() if k in applicable_units}
-
     def commision_units(self, units: typing.Dict[typing.Any, int]):
 
         for unit_type, unit_count in units.items():
@@ -190,55 +134,3 @@ class Base:
 
     def set_strength_to_minimum(self) -> None:
         self.strength = BASE_MIN_STRENGTH
-
-    def scramble_count(self, multiplier: float, task: Task = None) -> int:
-        if task:
-            count = sum(
-                [v for k, v in self.aircraft.items() if db.unit_task(k) == task]
-            )
-        else:
-            count = self.total_aircraft
-
-        count = int(math.ceil(count * PLANES_SCRAMBLE_FACTOR * self.strength))
-        return min(
-            min(
-                max(count, PLANES_SCRAMBLE_MIN_BASE),
-                int(PLANES_SCRAMBLE_MAX_BASE * multiplier),
-            ),
-            count,
-        )
-
-    def assemble_count(self):
-        return int(self.total_armor * 0.5)
-
-    def assemble_aa_count(self) -> int:
-        # previous logic removed because we always want the full air defense capabilities.
-        return self.total_aa
-
-    def scramble_sweep(self, multiplier: float) -> typing.Dict[FlyingType, int]:
-        return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
-
-    def scramble_last_defense(self):
-        # return as many CAP-capable aircraft as we can since this is the last defense of the base
-        # (but not more than 20 - that's just nuts)
-        return self._find_best_planes(CAP, min(self.total_aircraft, 20))
-
-    def scramble_cas(self, multiplier: float) -> typing.Dict[FlyingType, int]:
-        return self._find_best_planes(CAS, self.scramble_count(multiplier, CAS))
-
-    def scramble_interceptors(self, multiplier: float) -> typing.Dict[FlyingType, int]:
-        return self._find_best_planes(CAP, self.scramble_count(multiplier, CAP))
-
-    def assemble_attack(self) -> typing.Dict[Armor, int]:
-        return self._find_best_armor(PinpointStrike, self.assemble_count())
-
-    def assemble_defense(self) -> typing.Dict[Armor, int]:
-        count = int(self.total_armor * min(self.strength + 0.5, 1))
-        return self._find_best_armor(PinpointStrike, count)
-
-    def assemble_aa(self, count=None) -> typing.Dict[AirDefence, int]:
-        return self._find_best_unit(
-            self.aa,
-            AirDefence,
-            count and min(count, self.total_aa) or self.assemble_aa_count(),
-        )