Merge pull request #6207 from IllianiCBT/leadershipAndReinforcementFixes

Fixed Unit Eligibility Logic For Frontline and Leadership Units

Author: IllianiBird

MekHQ/src/mekhq/campaign/stratcon/StratconRulesManager.java

@@ -28,6 +28,7 @@
 package mekhq.campaign.stratcon;
 
 import megamek.codeUtilities.ObjectUtility;
+import megamek.common.Entity;
 import megamek.common.Minefield;
 import megamek.common.TargetRoll;
 import megamek.common.annotations.Nullable;
@@ -827,6 +828,7 @@ private static void swapInPlayerUnits(StratconScenario scenario, Campaign campai
                         }
                     }
                 }
+
                 for (Unit unit : potentialUnits) {
                     if ((sft.getAllowedUnitType() == 11) && (!campaign.getCampaignOptions().isUseDropShips())) {
                         continue;
@@ -2305,119 +2307,245 @@ private static boolean subElementsOrSelfDeployed(Force force, Campaign campaign)
     }
 
     /**
-     * Returns a list of individual units eligible for deployment in scenarios run
-     * by "Defend" lances
+     * Retrieves a list of units that are eligible for deployment in support of a Frontline force.
+     *
+     * <p>A unit is considered eligible if:</p>
+     * <ul>
+     *   <li>It is valid (available, properly deployed, and of a suitable type i.e., conventional
+     *   infantry or battle armor).</li>
+     *   <li>The force to which it belongs is valid (not deployed, part of a combat team, and not in
+     *   reserve).</li>
+     * </ul>
      *
-     * @return List of unit IDs.
+     * @param campaign        The campaign instance holding the units and forces involved.
+     * @param currentScenario
+     * @return A list of {@code Unit} objects that meet the requirements for deployment in support
+     * of a Frontline force.
      */
-    public static List<Unit> getEligibleDefensiveUnits(Campaign campaign) {
-        List<Unit> retVal = new ArrayList<>();
-
-        for (Unit u : campaign.getUnits()) {
-            // "defensive" units are infantry, battle armor and (Weisman help you) gun
-            // emplacements
-            // and also said unit should be intact/alive/etc
-            boolean isEligibleInfantry = ((u.getEntity().getUnitType() == INFANTRY)
-                    || (u.getEntity().getUnitType() == BATTLE_ARMOR)) && !u.isUnmanned();
-
-            boolean isEligibleGunEmplacement = u.getEntity().getUnitType() == GUN_EMPLACEMENT;
-
-            if ((isEligibleInfantry || isEligibleGunEmplacement)
-                    && !u.isDeployed()
-                    && !u.isMothballed()
-                    && (u.checkDeployment() == null)
-                    && !isUnitDeployedToStratCon(u)) {
-
-                // this is a little inefficient, but probably there aren't too many active AtB
-                // contracts at a time
-                for (AtBContract contract : campaign.getActiveAtBContracts()) {
-                    if (contract.getStratconCampaignState().isForceDeployedHere(u.getForceId())) {
-                        continue;
-                    }
-                }
+    public static List<Unit> getEligibleFrontlineUnits(Campaign campaign, StratconScenario currentScenario) {
+        List<Unit> defensiveUnits = new ArrayList<>();
+
+        // Retrieve the list of units from force 0
+        Vector<UUID> unitIDs = campaign.getForce(0).getAllUnits(true);
+
+        for (UUID unitId : unitIDs) {
+            Unit unit = campaign.getUnit(unitId);
+
+            // Validate the unit
+            if (!isUnitValidForFrontlineDeployment(unit)) {
+                continue;
+            }
 
-                retVal.add(u);
+            // Validate the force associated with the unit
+            if (!isForceEligible(unit, campaign, currentScenario)) {
+                continue;
             }
+
+            defensiveUnits.add(unit);
         }
 
-        return retVal;
+        return defensiveUnits;
+    }
+
+    /**
+     * Checks if a unit is valid for deployment in support of a Frontline force.
+     *
+     * <p>A unit is considered valid if:</p>
+     * <ul>
+     *   <li>The unit is not null.</li>
+     *   <li>The unit is available for deployment.</li>
+     *   <li>The unit's deployment checks return no errors.</li>
+     *   <li>The unit's entity is of type conventional infantry or battle armor.</li>
+     * </ul>
+     *
+     * @param unit The {@code Unit} object to validate.
+     * @return {@code true} if the unit is valid; {@code false} otherwise.
+     */
+    private static boolean isUnitValidForFrontlineDeployment(@Nullable Unit unit) {
+        if (unit == null) {
+            return false;
+        }
+
+        if (!unit.isAvailable()) {
+            return false;
+        }
+
+        if (unit.checkDeployment() != null) {
+            return false;
+        }
+
+        Entity entity = unit.getEntity();
+        return entity != null && (unit.isConventionalInfantry() || unit.isBattleArmor());
     }
 
     /**
-     * Returns a list of individual units eligible for deployment in scenarios that
-     * result from the
-     * lance leader having a leadership score
+     * Checks if the force associated with a unit is eligible for deployment in support of a Frontline
+     * force.
      *
-     * @return List of unit IDs.
+     * <p>A force is considered eligible if:</p>
+     * <ul>
+     *   <li>The force is not null.</li>
+     *   <li>The force has not already been deployed.</li>
+     *   <li>The force is part of a combat team.</li>
+     *   <li>The combat team is not assigned a reserve role.</li>
+     * </ul>
+     *
+     * @param unit            The {@code Unit} whose associated force is being validated.
+     * @param campaign        The {@code Campaign} object used to retrieve information about the force.
+     * @param currentScenario
+     * @return {@code true} if the associated force is eligible; {@code false} otherwise.
      */
-    public static List<Unit> getEligibleLeadershipUnits(Campaign campaign, ArrayList<Integer> forceIDs,
+    private static boolean isForceEligible(Unit unit, Campaign campaign, StratconScenario currentScenario) {
+        int forceId = unit.getForceId();
+        Force force = campaign.getForce(forceId);
+
+        // If the force is deployed, skip; added check for insurance
+        if (force == null || force.isDeployed()) {
+            return false;
+        }
+
+        // Check the associated combat team and its role
+        CombatTeam combatTeam = force.isCombatTeam() ? campaign.getCombatTeamsTable().get(forceId) : null;
+
+        if (combatTeam == null) {
+            return false;
+        }
+
+        if (combatTeam.getRole().isReserve()) {
+            return false;
+        }
+
+        AtBContract forceContract = combatTeam.getContract(campaign);
+        AtBContract scenarioContract = currentScenario.getBackingContract(campaign);
+
+        return forceContract.equals(scenarioContract);
+    }
+
+    /**
+     * Retrieves a list of units that are eligible for leadership deployment.
+     *
+     * <p>A unit is considered eligible for leadership deployment if:</p>
+     * <ul>
+     *   <li>There is sufficient leadership skill to justify leadership deployment.</li>
+     *   <li>The total leadership budget (based on leadership skill) is greater than 0.</li>
+     *   <li>The unit matches the general unit type of the primary force in the scenario.</li>
+     *   <li>The unit's battle value is within the computed budget.</li>
+     *   <li>The unit and its associated force are valid for deployment.</li>
+     * </ul>
+     *
+     * @param campaign         The campaign instance holding the units and forces involved.
+     * @param currentScenario  The current StratCon scenario being processed.
+     * @param leadershipSkill  The leadership skill value used to calculate budget.
+     * @return A list of {@code Unit} objects eligible for deployment as leadership units.
+     */
+    public static List<Unit> getEligibleLeadershipUnits(Campaign campaign, StratconScenario currentScenario,
                                                         int leadershipSkill) {
-        List<Unit> eligibleUnits = new ArrayList<>();
+        List<Integer> forceIds = currentScenario.getPrimaryForceIDs();
+        List<Unit> leadershipUnits = new ArrayList<>();
 
         // If there is no leadership skill, we shouldn't continue
         if (leadershipSkill <= 0) {
-            return eligibleUnits;
+            return leadershipUnits;
         }
 
-        // The criteria are as follows:
-        // - unit is eligible to be spawned on the scenario type
-        // - unit has a lower BV than the BV budget granted from Leadership
-        // Leadership budget is capped at 5 levels
         int totalBudget = min(BASE_LEADERSHIP_BUDGET * leadershipSkill, BASE_LEADERSHIP_BUDGET * 5);
 
-        int primaryUnitType = getPrimaryUnitType(campaign, forceIDs);
+        int primaryUnitType = getPrimaryUnitType(campaign, forceIds);
 
         // If there are no units (somehow), we've no reason to continue
         if (primaryUnitType == -1) {
-            return eligibleUnits;
+            return leadershipUnits;
         }
 
         int generalUnitType = convertSpecificUnitTypeToGeneral(primaryUnitType);
 
-        for (UUID unitId : campaign.getForce(0).getAllUnits(true)) {
+
+        // Retrieve the list of units from force 0
+        Vector<UUID> unitIDs = campaign.getForce(0).getAllUnits(true);
+
+        for (UUID unitId : unitIDs) {
             Unit unit = campaign.getUnit(unitId);
-            if (unit == null) {
+
+            // Validate the unit
+            if (!isUnitValidForLeadershipDeployment(unit, generalUnitType, totalBudget)) {
                 continue;
             }
 
-            // the general idea is that we want something that can be deployed to the scenario -
-            // e.g., no infantry on air scenarios etc.
-            boolean validUnitType = (forceCompositionMatchesDeclaredUnitType(unit.getEntity().getUnitType(),
-                        generalUnitType));
-
-            if (validUnitType
-                && !unit.isDeployed()
-                && !unit.isMothballed()
-                && (unit.getEntity().calculateBattleValue(true, true) <= totalBudget)
-                && (unit.checkDeployment() == null)
-                && !isUnitDeployedToStratCon(unit)) {
-                eligibleUnits.add(unit);
+            // Validate the force associated with the unit
+            if (!isForceEligible(unit, campaign, currentScenario)) {
+                continue;
             }
+
+            leadershipUnits.add(unit);
+        }
+
+        return leadershipUnits;
+    }
+
+    /**
+     * Checks if a unit is valid for leadership deployment.
+     *
+     * <p>A unit is considered valid for leadership deployment if:</p>
+     * <ul>
+     *   <li>The unit is not null.</li>
+     *   <li>The unit is available for deployment.</li>
+     *   <li>The unit has no existing deployment records (i.e., not already deployed).</li>
+     *   <li>The unit's entity is valid and has a battle value within the provided leadership budget.</li>
+     *   <li>The unit matches the general unit type required for the deployment.</li>
+     * </ul>
+     *
+     * @param unit            The {@code Unit} object to validate for leadership deployment.
+     * @param generalUnitType The general unit type required for this deployment.
+     * @param totalBudget     The total battle value budget available for leadership deployment.
+     * @return {@code true} if the unit is valid for leadership deployment; {@code false} otherwise.
+     */
+    private static boolean isUnitValidForLeadershipDeployment(@Nullable Unit unit, int generalUnitType,
+                                                              int totalBudget) {
+        if (unit == null) {
+            return false;
+        }
+
+        if (!unit.isAvailable()) {
+            return false;
+        }
+
+        if (unit.checkDeployment() != null) {
+            return false;
+        }
+
+        Entity entity = unit.getEntity();
+
+        if (entity == null) {
+            return false;
+        }
+
+        if (entity.calculateBattleValue(true, true) > totalBudget) {
+            return false;
         }
 
-        return eligibleUnits;
+        return forceCompositionMatchesDeclaredUnitType(entity.getUnitType(), generalUnitType);
     }
 
     /**
      * Check if the unit's force (if one exists) has been deployed to a StratCon
      * track
      */
-    public static boolean isUnitDeployedToStratCon(Unit u) {
-        if (!u.getCampaign().getCampaignOptions().isUseStratCon()) {
+    public static boolean isUnitDeployedToStratCon(Unit unit) {
+        if (!unit.getCampaign().getCampaignOptions().isUseStratCon()) {
             return false;
         }
 
         // this is a little inefficient, but probably there aren't too many active AtB
         // contracts at a time
-        return u.getCampaign().getActiveAtBContracts().stream()
+        return unit.getCampaign().getActiveAtBContracts().stream()
                 .anyMatch(contract -> (contract.getStratconCampaignState() != null) &&
-                        contract.getStratconCampaignState().isForceDeployedHere(u.getForceId()));
+                        contract.getStratconCampaignState().isForceDeployedHere(unit.getForceId()));
     }
 
     /**
      * Calculates the majority unit type for the forces given the IDs.
      */
-    private static int getPrimaryUnitType(Campaign campaign, ArrayList<Integer> forceIDs) {
+    private static int getPrimaryUnitType(Campaign campaign, List<Integer> forceIDs) {
         Map<Integer, Integer> unitTypeBuckets = new TreeMap<>();
         int biggestBucketID = -1;
         int biggestBucketCount = 0;

MekHQ/src/mekhq/campaign/stratcon/StratconScenario.java

@@ -299,6 +299,24 @@ public AtBDynamicScenario getBackingScenario() {
         return backingScenario;
     }
 
+    /**
+     * Retrieves the {@link AtBContract} associated with the backing scenario.
+     *
+     * <p>If the backing scenario is null, this method will return {@code null}. Otherwise, it
+     * retrieves the associated contract through the provided campaign instance.
+     *
+     * @param campaign The {@code Campaign} instance used to obtain the contract.
+     * @return The {@code AtBContract} associated with the current backing scenario, or {@code null}
+     * if no backing scenario exists.
+     */
+    public @Nullable AtBContract getBackingContract(Campaign campaign) {
+        if (backingScenario == null) {
+            return null;
+        }
+
+        return backingScenario.getContract(campaign);
+    }
+
     @XmlJavaTypeAdapter(DateAdapter.class)
     public LocalDate getDeploymentDate() {
         return deploymentDate;

MekHQ/src/mekhq/campaign/unit/Unit.java

@@ -1131,8 +1131,29 @@ public void undeploy() {
         scenarioId = -1;
     }
 
+    /**
+     * Validates the deployment readiness of the unit.
+     *
+     * <p>This method checks multiple conditions to determine whether the unit is deployable. If the
+     * unit is not deployable, a descriptive error message is returned indicating the reason for its
+     * ineligibility. If the unit passes all validations, {@code null} is returned, implying it is
+     * ready for deployment.<p>
+     *
+     * Deployment checks performed:
+     * <ul>
+     *   <li>If the unit is not functional, it cannot be deployed.</li>
+     *   <li>If the unit is unmanned and is not an unmanned trailer, it cannot be deployed.</li>
+     *   <li>If the unit is in the process of being refitted, it cannot be deployed.</li>
+     *   <li>If the unit is a tank and does not have the required crew size, it cannot be deployed.</li>
+     *   <li>If the unit is a BattleArmor unit with empty suits, it cannot be deployed until these
+     *   are filled or salvaged.</li>
+     * </ul>
+     *
+     * @return A descriptive {@code String} error message if the unit cannot be deployed, or {@code null}
+     * if the unit is deployable.
+     */
     // TODO: Add support for advanced medical
-    public String checkDeployment() {
+    public @Nullable String checkDeployment() {
         if (!isFunctional()) {
             return "unit is not functional";
         }

MekHQ/src/mekhq/gui/stratcon/StratconScenarioWizard.java

@@ -206,7 +206,7 @@ private void setUI(boolean isPrimaryForce) {
             gbc.gridy++;
             int leadershipSkill = currentScenario.getBackingScenario().getLanceCommanderSkill(S_LEADER, campaign);
             eligibleLeadershipUnits = getEligibleLeadershipUnits(
-                campaign, currentScenario.getPrimaryForceIDs(), leadershipSkill);
+                campaign, currentScenario, leadershipSkill);
             eligibleLeadershipUnits.sort(Comparator.comparing(this::getForceNameReversed));
 
             setLeadershipUI(gbc, eligibleLeadershipUnits, leadershipSkill);
@@ -406,7 +406,7 @@ private void setDefensiveUI(GridBagConstraints gbc) {
         gbc.gridy++;
 
         // Obtain eligible infantry units
-        List<Unit> eligibleInfantryUnits = StratconRulesManager.getEligibleDefensiveUnits(campaign);
+        List<Unit> eligibleInfantryUnits = StratconRulesManager.getEligibleFrontlineUnits(campaign, currentScenario);
         eligibleInfantryUnits.sort(Comparator.comparing(Unit::getName));
 
         // Add a unit selector for infantry units