Add a feature flag for pilot limits.

This doesn't currently interact very well with the auto purchase since
the procurer might by aircraft that don't have pilots available. That
should be fixed, but for the short term we should just default to not
enabling this new feature.

game/settings.py

@@ -34,11 +34,14 @@ class Settings:
     player_income_multiplier: float = 1.0
     enemy_income_multiplier: float = 1.0
 
+    #: Feature flag for squadron limits.
+    enable_squadron_pilot_limits: bool = False
+
     #: The maximum number of pilots a squadron can have at one time. Changing this after
     #: the campaign has started will have no immediate effect; pilots already in the
     #: squadron will not be removed if the limit is lowered and pilots will not be
     #: immediately created if the limit is raised.
-    squadron_pilot_limit: int = 24
+    squadron_pilot_limit: int = 4
 
     #: The number of pilots a squadron can replace per turn.
     squadron_replenishment_rate: int = 4

game/squadrons.py

@@ -112,9 +112,19 @@ class Squadron:
             return self.name
         return f'{self.name} "{self.nickname}"'
 
+    @property
+    def pilot_limits_enabled(self) -> bool:
+        return self.game.settings.enable_squadron_pilot_limits
+
+    def claim_new_pilot_if_allowed(self) -> Optional[Pilot]:
+        if self.pilot_limits_enabled:
+            return None
+        self._recruit_pilots(1)
+        return self.available_pilots.pop()
+
     def claim_available_pilot(self) -> Optional[Pilot]:
         if not self.available_pilots:
-            return None
+            return self.claim_new_pilot_if_allowed()
 
         # For opfor, so player/AI option is irrelevant.
         if not self.player:
@@ -140,7 +150,7 @@ class Squadron:
         # If they only *prefer* players and we're out of players, just return an AI
         # pilot.
         if not prefer_players:
-            return None
+            return self.claim_new_pilot_if_allowed()
         return self.available_pilots.pop()
 
     def claim_pilot(self, pilot: Pilot) -> None:
@@ -169,9 +179,12 @@ class Squadron:
         self.available_pilots.extend(new_pilots)
 
     def replenish_lost_pilots(self) -> None:
+        if not self.pilot_limits_enabled:
+            return
+
         replenish_count = min(
             self.game.settings.squadron_replenishment_rate,
-            self.number_of_unfilled_pilot_slots,
+            self._number_of_unfilled_pilot_slots,
         )
         if replenish_count > 0:
             self._recruit_pilots(replenish_count)
@@ -213,20 +226,23 @@ class Squadron:
         return len(self.current_roster)
 
     @property
-    def number_of_unfilled_pilot_slots(self) -> int:
+    def _number_of_unfilled_pilot_slots(self) -> int:
         return self.game.settings.squadron_pilot_limit - len(self.active_pilots)
 
     @property
     def number_of_available_pilots(self) -> int:
         return len(self.available_pilots)
 
+    def can_provide_pilots(self, count: int) -> bool:
+        return not self.pilot_limits_enabled or self.number_of_available_pilots >= count
+
     @property
     def has_available_pilots(self) -> bool:
-        return bool(self.available_pilots)
+        return not self.pilot_limits_enabled or bool(self.available_pilots)
 
     @property
     def has_unfilled_pilot_slots(self) -> bool:
-        return self.number_of_unfilled_pilot_slots > 0
+        return not self.pilot_limits_enabled or self._number_of_unfilled_pilot_slots > 0
 
     def can_auto_assign(self, task: FlightType) -> bool:
         return task in self.auto_assignable_mission_types

game/transfers.py

@@ -299,8 +299,12 @@ class AirliftPlanner:
             required,
             available_aircraft,
             squadron.aircraft.dcs_unit_type.group_size_max,
-            squadron.number_of_available_pilots,
         )
+        # TODO: Use number_of_available_pilots directly once feature flag is gone.
+        # The number of currently available pilots is not relevant when pilot limits
+        # are disabled.
+        if not squadron.can_provide_pilots(flight_size):
+            flight_size = squadron.number_of_available_pilots
         capacity = flight_size * capacity_each
 
         if capacity < self.transfer.size: