feat(WG): prioritize native faction, flip only the surplus at war start (#164)

The greedy per-join balance flipped players based on the live in-war
counts at accept time, so a minority-faction player who accepted early
could be morphed unnecessarily and (with team-lock) stay that way.

Add a native-priority pass: snapshot the native split from the invited
maps on the first join of a war, keep the minority faction fully native,
and let the majority fill its fair share (floor(total/2)) native in
accept order. Players past that share -- the latest to commit -- flip to
even the sides, minimizing faction changes.

Gated by CFBG.Battlefield.NativePriority.Enable (default 1); disabling it
falls back to the previous greedy balance.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: Nyeriah

conf/CFBG.conf.dist

@@ -32,6 +32,16 @@
 #       Default: 1 - (Enabled)
 #                0 - (Disabled)
 #
+#   CFBG.Battlefield.NativePriority.Enable
+#       Description: When assigning teams for a Wintergrasp war, keep the minority
+#                    faction entirely on its native side and morph only the
+#                    majority's surplus to even the teams. The majority fills its
+#                    fair share native in invite-accept order, so the players moved
+#                    are the last to commit. Disable to fall back to the per-join
+#                    greedy balance. Requires CFBG.Battlefield.Enable = 1.
+#       Default: 1 - (Enabled)
+#                0 - (Disabled, greedy per-join balance)
+#
 #   CFBG.Battlefield.ReapplyOnResurrect.Enable
 #       Description: Re-apply a cross-faction player's assigned race/faction/morph
 #                    when they resurrect inside Wintergrasp, so the ghost->alive
@@ -100,6 +110,7 @@
 CFBG.Enable = 1
 CFBG.Battlefield.Enable = 1
 CFBG.Battlefield.TeamLock.Enable = 1
+CFBG.Battlefield.NativePriority.Enable = 1
 CFBG.Battlefield.ReapplyOnResurrect.Enable = 1
 CFBG.BalancedTeams = 1
 CFBG.BalancedTeams.Class.LowLevel = 0

src/CFBG.cpp

@@ -151,6 +151,7 @@ void CFBG::LoadConfig()
 
     _IsEnableWGSystem = sConfigMgr->GetOption<bool>("CFBG.Battlefield.Enable", true);
     _IsEnableWGTeamLock = sConfigMgr->GetOption<bool>("CFBG.Battlefield.TeamLock.Enable", true);
+    _IsEnableWGNativePriority = sConfigMgr->GetOption<bool>("CFBG.Battlefield.NativePriority.Enable", true);
     _IsEnableWGReapplyOnResurrect = sConfigMgr->GetOption<bool>("CFBG.Battlefield.ReapplyOnResurrect.Enable", true);
     _IsEnableAvgIlvl = sConfigMgr->GetOption<bool>("CFBG.Include.Avg.Ilvl.Enable", false);
     _IsEnableBalancedTeams = sConfigMgr->GetOption<bool>("CFBG.BalancedTeams", false);
@@ -635,6 +636,37 @@ void CFBG::SetWGWarAssignment(ObjectGuid guid, TeamId team)
 void CFBG::ClearWGWarAssignments()
 {
     _wgWarAssignmentStore.clear();
+    _wgCensusValid = false;
+    _wgMajorityNativeKept = 0;
+}
+
+TeamId CFBG::ResolveWGWarTeam(Player* player, uint32 nativeAllianceInvited, uint32 nativeHordeInvited)
+{
+    // Capture the native split once: at the first join PlayersInWar is empty
+    // and nobody is faked, so the invited counts are the true native census.
+    if (!_wgCensusValid)
+    {
+        _wgMajorityTeam = (nativeAllianceInvited >= nativeHordeInvited) ? TEAM_ALLIANCE : TEAM_HORDE;
+        _wgMajorityFairShare = (nativeAllianceInvited + nativeHordeInvited) / 2;
+        _wgMajorityNativeKept = 0;
+        _wgCensusValid = true;
+    }
+
+    TeamId realTeam = player->GetTeamId(true);
+
+    // Minority stays native.
+    if (realTeam != _wgMajorityTeam)
+        return realTeam;
+
+    // Majority keeps its fair share native in accept order; the rest (latest
+    // to commit) flip.
+    if (_wgMajorityNativeKept < _wgMajorityFairShare)
+    {
+        ++_wgMajorityNativeKept;
+        return realTeam;
+    }
+
+    return (_wgMajorityTeam == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE;
 }
 
 void CFBG::DoForgetPlayersInList(Player* player)

src/CFBG.h

@@ -137,6 +137,7 @@ class CFBG
     inline bool IsEnableSystem() const { return _IsEnableSystem; }
     inline bool IsEnableWGSystem() const { return _IsEnableWGSystem; }
     inline bool IsEnableWGTeamLock() const { return _IsEnableWGTeamLock; }
+    inline bool IsEnableWGNativePriority() const { return _IsEnableWGNativePriority; }
     inline bool IsEnableWGReapplyOnResurrect() const { return _IsEnableWGReapplyOnResurrect; }
     inline bool IsEnableAvgIlvl() const { return _IsEnableAvgIlvl; }
     inline bool IsEnableBalancedTeams() const { return _IsEnableBalancedTeams; }
@@ -167,6 +168,11 @@ class CFBG
     void SetWGWarAssignment(ObjectGuid guid, TeamId team);
     void ClearWGWarAssignments();
 
+    // Native-priority WG balancing: keep the minority native, flip only the
+    // majority's surplus (latest accepters). Census captured on the first call
+    // of a war, reset in ClearWGWarAssignments.
+    TeamId ResolveWGWarTeam(Player* player, uint32 nativeAllianceInvited, uint32 nativeHordeInvited);
+
     bool ShouldForgetInListPlayers(Player* player);
     bool IsPlayingNative(Player* player);
 
@@ -214,6 +220,12 @@ class CFBG
 
     std::unordered_map<Player*, FakePlayer> _fakePlayerStore;
     std::unordered_map<ObjectGuid, TeamId> _wgWarAssignmentStore;
+
+    // Per-war native census for ResolveWGWarTeam, reset in ClearWGWarAssignments.
+    bool   _wgCensusValid        = false;
+    TeamId _wgMajorityTeam       = TEAM_ALLIANCE;
+    uint32 _wgMajorityFairShare  = 0;
+    uint32 _wgMajorityNativeKept = 0;
     std::unordered_map<Player*, ObjectGuid> _fakeNamePlayersStore;
     std::unordered_map<Player*, bool> _forgetBGPlayersStore;
     std::unordered_map<Player*, bool> _forgetInListPlayersStore;
@@ -225,6 +237,7 @@ class CFBG
     bool _IsEnableSystem;
     bool _IsEnableWGSystem;
     bool _IsEnableWGTeamLock;
+    bool _IsEnableWGNativePriority;
     bool _IsEnableWGReapplyOnResurrect;
     bool _IsEnableAvgIlvl;
     bool _IsEnableBalancedTeams;

src/CFBG_SC.cpp

@@ -289,13 +289,22 @@ class CFBG_Battlefield : public BattlefieldScript
 
         if (locked)
             assignedTeam = *locked;
+        else if (sCFBG->IsEnableWGNativePriority())
+        {
+            // Invited maps still hold the full native war population here:
+            // core erases each accepter from InvitedPlayers only after this hook.
+            uint32 allianceInvited = static_cast<uint32>(bf->GetInvitedPlayersMap(TEAM_ALLIANCE).size());
+            uint32 hordeInvited    = static_cast<uint32>(bf->GetInvitedPlayersMap(TEAM_HORDE).size());
+
+            assignedTeam = sCFBG->ResolveWGWarTeam(player, allianceInvited, hordeInvited);
+
+            if (sCFBG->IsEnableWGTeamLock())
+                sCFBG->SetWGWarAssignment(player->GetGUID(), assignedTeam);
+        }
         else
         {
-            // Hook fires before core's PlayersInWar.insert, so the candidate is
-            // counted in neither side here. Reading the live core set drops the
-            // parallel bucket we used to maintain and removes the divergence path
-            // where AddOrSetPlayerToCorrectBfGroup rejects the join after the
-            // hook has already mutated module state.
+            // Greedy fallback: candidate is in neither set yet (hook fires
+            // before PlayersInWar.insert), so balance off the live core counts.
             uint32 allianceCount = static_cast<uint32>(bf->GetPlayersInWarSet(TEAM_ALLIANCE).size());
             uint32 hordeCount    = static_cast<uint32>(bf->GetPlayersInWarSet(TEAM_HORDE).size());