Merge AzerothCore 3.3.5 to ElunaAzerothcore [skip ci]

Author: github-actions[bot]

src/server/apps/worldserver/worldserver.conf.dist

@@ -3690,6 +3690,18 @@ Wintergrasp.SkipBattleSessionCount = 3500
 
 Wintergrasp.KickVoAPlayers = 1
 
+#
+#     Wintergrasp.EssenceBothFactions
+#         Description: Grant the "Essence of Wintergrasp" buff to both factions
+#                      during peacetime, regardless of who controls the keep.
+#                      The wartime suppression still applies; this only affects
+#                      who receives the buff once the battle is over.
+#         Default:     0 - (Disabled, only the defending faction gets the buff)
+#                      1 - (Enabled, attackers and defenders both get the buff,
+#                           so both factions can access Vault of Archavon)
+
+Wintergrasp.EssenceBothFactions = 0
+
 #
 ###################################################################################################
 

src/server/game/Battlefield/Battlefield.cpp

@@ -93,6 +93,8 @@ void Battlefield::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
     // any team-based battlefield containers (such as player lists or queues) are updated.
     sScriptMgr->OnBattlefieldPlayerEnterZone(this, player);
 
+    TryRejoinAfterLogout(player); // relog: auto-rejoin, skip invite below
+
     // Xinef: do not invite players on taxi
     if (!player->IsInFlight())
     {
@@ -124,12 +126,20 @@ void Battlefield::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
 
 void Battlefield::HandlePlayerLeaveZone(Player* player, uint32 /*zone*/)
 {
+    // Logout still runs full leave-war cleanup, but marks the player for grace-window auto-rejoin.
+    bool const isLogout = player->GetSession() && player->GetSession()->PlayerLogout();
+
     if (IsWarTime())
     {
         // If the player is participating to the battle
         if (PlayersInWar[player->GetTeamId()].erase(player->GetGUID()))
         {
-            player->GetSession()->SendBfLeaveMessage(BattleId);
+            if (isLogout)
+                LogoutGracePlayers[player->GetTeamId()][player->GetGUID()] =
+                    GameTime::GetGameTime().count() + LOGOUT_GRACE_SECONDS;
+            else
+                player->GetSession()->SendBfLeaveMessage(BattleId);
+
             if (Group* group = player->GetGroup()) // Remove the player from the raid group
                 if (group->isBFGroup())
                     group->RemoveMember(player->GetGUID());
@@ -321,6 +331,7 @@ void Battlefield::StartBattle()
     {
         PlayersInWar[team].clear();
         Groups[team].clear();
+        LogoutGracePlayers[team].clear();
     }
 
     Timer = BattleTime;
@@ -396,6 +407,14 @@ void Battlefield::EndBattle(bool endByTimer)
     OnBattleEnd(endByTimer);
     sScriptMgr->OnBattlefieldWarEnd(this, endByTimer);
 
+    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
+    {
+        for (ObjectGuid const& guid : Groups[team])
+            if (Group* group = sGroupMgr->GetGroupByGUID(guid.GetCounter()))
+                group->Disband();
+        Groups[team].clear();
+    }
+
     // Reset battlefield timer
     Timer = NoWarBattleTime;
     SendInitWorldStatesToAll();
@@ -588,6 +607,41 @@ bool Battlefield::AddOrSetPlayerToCorrectBfGroup(Player* player)
     return true;
 }
 
+void Battlefield::TryRejoinAfterLogout(Player* player)
+{
+    ObjectGuid const guid = player->GetGUID();
+    time_t const now = GameTime::GetGameTime().count();
+
+    // Consume the marker and honor its grace window (check both teams; team may have changed).
+    bool pending = false;
+    for (uint8 team = 0; team < PVP_TEAMS_COUNT; ++team)
+        if (auto itr = LogoutGracePlayers[team].find(guid); itr != LogoutGracePlayers[team].end())
+        {
+            pending = itr->second > now;
+            LogoutGracePlayers[team].erase(itr);
+        }
+
+    // Vacancy gate mirrors HandlePlayerEnterZone (full team -> queue path). Pre-hook:
+    // we can't abort after JoinWar, which may already have mutated module state.
+    if (!pending || !IsWarTime() || !HasWarVacancy(player->GetTeamId()))
+        return;
+
+    if (Group* current = player->GetGroup())
+        if (current->isBGGroup() || current->isBFGroup())
+            return;
+
+    // Rejoin via the normal join path: firing JoinWar lets modules rebuild
+    // per-session (Player*-keyed) state and pick the team before the raid bind.
+    sScriptMgr->OnBattlefieldPlayerJoinWar(this, player);
+
+    if (AddOrSetPlayerToCorrectBfGroup(player))
+    {
+        player->GetSession()->SendBfEntered(BattleId);
+        PlayersInWar[player->GetTeamId()].insert(guid);
+        OnPlayerJoinWar(player);
+    }
+}
+
 BfGraveyard* Battlefield::GetGraveyardById(uint32 id) const
 {
     if (id < GraveyardList.size())

src/server/game/Battlefield/Battlefield.h

@@ -278,6 +278,11 @@ class Battlefield : public ZoneScript
     /// Force player to join a battlefield group
     bool AddOrSetPlayerToCorrectBfGroup(Player* player);
 
+    /// Auto-rejoin a player who relogged within the grace window after a mid-war
+    /// logout, via the normal join hooks. No-op without a pending logout marker.
+    /// Called from HandlePlayerEnterZone (which fires on the post-login zone set).
+    void TryRejoinAfterLogout(Player* player);
+
     // Graveyard methods
     // Find which graveyard the player must be teleported to to be resurrected by spiritguide
     GraveyardStruct const* GetClosestGraveyard(Player* player);
@@ -381,6 +386,10 @@ class Battlefield : public ZoneScript
     GuidUnorderedSet PlayersInWar[PVP_TEAMS_COUNT];         // Players in WG combat
     PlayerTimerMap InvitedPlayers[PVP_TEAMS_COUNT];
     PlayerTimerMap PlayersWillBeKick[PVP_TEAMS_COUNT];
+    // Mid-war logouts: GUID -> timestamp until which a relog auto-rejoins the war.
+    PlayerTimerMap LogoutGracePlayers[PVP_TEAMS_COUNT];
+
+    static constexpr uint32 LOGOUT_GRACE_SECONDS = 120; // relog auto-rejoin window
 
     // Variables that must exist for each battlefield
     uint32 TypeId;                                          // See enum BattlefieldTypes

src/server/game/Battlefield/Zones/BattlefieldWG.cpp

@@ -479,12 +479,17 @@ void BattlefieldWG::OnBattleEnd(bool endByTimer)
         }
     }
 
+    bool const grantEssenceToAttackers = sWorld->getBoolConfig(CONFIG_WINTERGRASP_ESSENCE_BOTH_FACTIONS);
+
     for (ObjectGuid const& guid : PlayersInWar[GetAttackerTeam()])
         if (Player* player = ObjectAccessor::FindPlayer(guid))
         {
             player->CastSpell(player, SPELL_DEFEAT_REWARD, true);
             RemoveAurasFromPlayer(player);
 
+            if (grantEssenceToAttackers)
+                player->CastSpell(player, SPELL_ESSENCE_OF_WINTERGRASP, true);
+
             for (uint8 i = 0; i < damagedTowersAtt; ++i)
                 player->CastSpell(player, spellDamagedAtt, true);
             for (uint8 i = 0; i < brokenTowersAtt; ++i)

src/server/game/Entities/Player/Player.cpp

@@ -13119,6 +13119,11 @@ PartyResult Player::CanUninviteFromGroup(ObjectGuid targetPlayerGUID) const
 
         if (InBattleground())
             return ERR_INVITE_RESTRICTED;
+
+        // BF raids are owned by the Battlefield system; leaders/assistants must not
+        // be able to kick members (would drop their team assignment mid-battle).
+        if (grp->isBFGroup())
+            return ERR_NOT_LEADER;
     }
 
     return ERR_PARTY_RESULT_OK;

src/server/game/Entities/Unit/Unit.cpp

@@ -954,6 +954,9 @@ bool Unit::IsImmunedToSpell(SpellInfo const* spellInfo, uint32 effectMask, Unit
             for (auto const& [immunitySchoolMask, immunityAuraId] : schoolList)
             {
                 SpellInfo const* immuneSpellInfo = sSpellMgr->GetSpellInfo(immunityAuraId);
+                if (immunityAuraId == spellInfo->Id)
+                    continue;
+
                 if ((immunitySchoolMask & schoolMask) != schoolMask)
                     continue;
 
@@ -10087,6 +10090,9 @@ bool Unit::IsImmunedToSpell(SpellInfo const* spellInfo, Spell const* spell)
             SpellImmuneContainer const& schoolList = m_spellImmune[IMMUNITY_SCHOOL];
             for (auto itr = schoolList.begin(); itr != schoolList.end(); ++itr)
             {
+                if (itr->second == spellInfo->Id)
+                    continue;
+
                 SpellInfo const* immuneSpellInfo = sSpellMgr->GetSpellInfo(itr->second);
                 if (!(itr->first & spellSchoolMask))
                     continue;

src/server/game/Handlers/GroupHandler.cpp

@@ -129,6 +129,16 @@ void WorldSession::HandleGroupInviteOpcode(WorldPacket& recvData)
         return;
     }
 
+    // Battlefield raids (e.g. Wintergrasp) have their composition managed by the BF
+    // system based on queue and team balance. Letting raid members recruit outsiders
+    // bypasses Battlefield::AddOrSetPlayerToCorrectBfGroup, which on WG entry then
+    // refuses to add the invitee because they are already in a BF group.
+    if (Group* invitingGroup = invitingPlayer->GetGroup(); invitingGroup && invitingGroup->isBFGroup())
+    {
+        SendPartyResult(PARTY_OP_INVITE, membername, ERR_NOT_LEADER);
+        return;
+    }
+
     Group* group = invitingPlayer->GetGroup();
     if (group && group->isBGGroup())
         group = invitingPlayer->GetOriginalGroup();

src/server/game/Spells/SpellInfoCorrections.cpp

@@ -1527,7 +1527,7 @@ void SpellMgr::LoadSpellInfoCorrections()
         spellInfo->Speed = 8.0f;
     });
 
-    // Spell Absorption
+    // Shadowmoon Reaver - Spell Absorption
     ApplySpellFix({ 41034 }, [](SpellInfo* spellInfo)
     {
         spellInfo->Effects[EFFECT_2].Effect = SPELL_EFFECT_APPLY_AURA;
@@ -1536,12 +1536,13 @@ void SpellMgr::LoadSpellInfoCorrections()
         spellInfo->Effects[EFFECT_2].MiscValue = SPELL_SCHOOL_MASK_MAGIC;
     });
 
-    // Shared Bonds
+    // Priestess of Delight and Priestess of Torment - Shared Bonds
     ApplySpellFix({ 41363 }, [](SpellInfo* spellInfo)
     {
         spellInfo->AttributesEx &= ~SPELL_ATTR1_IS_CHANNELED;
     });
 
+    // Illidari Council - Veras Darkshadow
     ApplySpellFix({
         41485,  // Deadly Poison
         41487   // Envenom
@@ -1570,13 +1571,13 @@ void SpellMgr::LoadSpellInfoCorrections()
         spellInfo->RangeEntry = sSpellRangeStore.LookupEntry(13); // 0-50000yd
     });
 
-    // Watery Grave Explosion
+    // Morogrim Tidewalker - Watery Grave Explosion
     ApplySpellFix({ 37852 }, [](SpellInfo* spellInfo)
     {
         spellInfo->AttributesEx5 |= SPELL_ATTR5_ALLOW_WHILE_STUNNED;
     });
 
-    // Amplify Damage
+    // Prince Malchezaar - Amplify Damage
     ApplySpellFix({ 39095 }, [](SpellInfo* spellInfo)
     {
         spellInfo->MaxAffectedTargets = 1;
@@ -1589,6 +1590,7 @@ void SpellMgr::LoadSpellInfoCorrections()
         spellInfo->AttributesCu |= SPELL_ATTR0_CU_SINGLE_AURA_STACK;
     });
 
+    // Archimonde
     ApplySpellFix({
         31984,  // Finger of Death
         35354   // Hand of Death
@@ -1598,12 +1600,18 @@ void SpellMgr::LoadSpellInfoCorrections()
         spellInfo->Attributes = SPELL_ATTR0_IS_ABILITY;
     });
 
-    // Finger of Death
+    // Archimonde - Finger of Death
     ApplySpellFix({ 32111 }, [](SpellInfo* spellInfo)
     {
         spellInfo->CastTimeEntry = sSpellCastTimesStore.LookupEntry(0); // We only need the animation, no damage
     });
 
+    // Archimonde - Doomfire
+    ApplySpellFix({ 31944, 31969 }, [](SpellInfo* spellInfo)
+    {
+        spellInfo->AttributesEx4 |= SPELL_ATTR4_NO_CAST_LOG;
+    });
+
     // Flame Breath, catapult spell
     ApplySpellFix({ 50989 }, [](SpellInfo* spellInfo)
     {

src/server/game/Spells/SpellMgr.cpp

@@ -1101,7 +1101,9 @@ bool SpellArea::IsFitToRequirements(Player const* player, uint32 newZone, uint32
                     return false;
 
                 Battlefield* Bf = sBattlefieldMgr->GetBattlefieldByBattleId(BATTLEFIELD_BATTLEID_WG);
-                if (!Bf || player->GetTeamId() != Bf->GetDefenderTeam() || Bf->IsWarTime())
+                if (!Bf || Bf->IsWarTime())
+                    return false;
+                if (!sWorld->getBoolConfig(CONFIG_WINTERGRASP_ESSENCE_BOTH_FACTIONS) && player->GetTeamId() != Bf->GetDefenderTeam())
                     return false;
                 break;
             }

src/server/game/World/WorldConfig.cpp

@@ -596,6 +596,7 @@ void WorldConfig::BuildConfigCache()
 
     SetConfigValue<uint32>(CONFIG_WINTERGRASP_SKIP_BATTLE_SESSION_COUNT, "Wintergrasp.SkipBattleSessionCount", 3500);
     SetConfigValue<bool>(CONFIG_WINTERGRASP_KICK_VOA_PLAYERS, "Wintergrasp.KickVoAPlayers", true, ConfigValueCache::Reloadable::No);
+    SetConfigValue<bool>(CONFIG_WINTERGRASP_ESSENCE_BOTH_FACTIONS, "Wintergrasp.EssenceBothFactions", false);
 
     SetConfigValue<uint32>(CONFIG_BIRTHDAY_TIME, "BirthdayTime", 1222964635);
     SetConfigValue<bool>(CONFIG_MINIGOB_MANABONK, "Minigob.Manabonk.Enable", true);