Merge AzerothCore 3.3.5 to ElunaAzerothcore [skip ci]

github-actions[bot] · github-actions[bot] · commit 202580da3578 · 2026-05-28T02:56:41.000Z
diff --git a/data/sql/updates/db_world/2026_05_28_00.sql b/data/sql/updates/db_world/2026_05_28_00.sql
@@ -0,0 +1,8 @@
+-- DB update 2026_05_26_00 -> 2026_05_28_00
+--
+DELETE FROM `spawn_group` WHERE `spawnId` IN (153154, 153155, 153156, 153157);
+INSERT INTO `spawn_group` (`groupId`, `spawnType`, `spawnId`) VALUES
+(1, 0, 153154),
+(1, 0, 153155),
+(1, 0, 153156),
+(1, 0, 153157);
diff --git a/src/server/game/Battlefield/Battlefield.cpp b/src/server/game/Battlefield/Battlefield.cpp
@@ -74,19 +74,20 @@ Battlefield::~Battlefield()
     CapturePoints.clear();
 }
 
-void Battlefield::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
+void Battlefield::RemovePlayerFromTracking(ObjectGuid playerGuid)
 {
-    // Clear any stale entries from a prior visit that did not unwind cleanly.
-    // Runs before the script hook so scripts see a clean state if they read any
-    // of these containers.
     for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
     {
-        PlayersInWar[i].erase(player->GetGUID());
-        InvitedPlayers[i].erase(player->GetGUID());
-        PlayersInQueue[i].erase(player->GetGUID());
-        PlayersWillBeKick[i].erase(player->GetGUID());
-        Players[i].erase(player->GetGUID());
+        InvitedPlayers[i].erase(playerGuid);
+        PlayersInQueue[i].erase(playerGuid);
+        PlayersWillBeKick[i].erase(playerGuid);
+        Players[i].erase(playerGuid);
     }
+}
+
+void Battlefield::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
+{
+    RemovePlayerFromTracking(player->GetGUID());
 
     // Allow scripts to adjust the player's effective team or appearance before
     // any team-based battlefield containers (such as player lists or queues) are updated.
@@ -141,13 +142,7 @@ void Battlefield::HandlePlayerLeaveZone(Player* player, uint32 /*zone*/)
     for (BfCapturePoint* cp : CapturePoints)
         cp->HandlePlayerLeave(player);
 
-    for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
-    {
-        InvitedPlayers[i].erase(player->GetGUID());
-        PlayersInQueue[i].erase(player->GetGUID());
-        PlayersWillBeKick[i].erase(player->GetGUID());
-        Players[i].erase(player->GetGUID());
-    }
+    RemovePlayerFromTracking(player->GetGUID());
     SendRemoveWorldStates(player);
     RemovePlayerFromResurrectQueue(player->GetGUID());
     OnPlayerLeaveZone(player);
@@ -634,34 +629,22 @@ GraveyardStruct const* Battlefield::GetClosestGraveyard(Player* player)
     return nullptr;
 }
 
-void Battlefield::AddPlayerToResurrectQueue(ObjectGuid npcGuid, ObjectGuid playerGuid)
+void Battlefield::AddPlayerToResurrectQueue(ObjectGuid /*npcGuid*/, ObjectGuid playerGuid)
 {
-    for (BfGraveyard* gy : GraveyardList)
-    {
-        if (!gy)
-            continue;
+    Player* player = ObjectAccessor::FindPlayer(playerGuid);
+    if (!player)
+        return;
 
-        if (gy->HasNpc(npcGuid))
-        {
-            gy->AddPlayer(playerGuid);
-            break;
-        }
-    }
+    player->CastSpell(player, SPELL_WAITING_FOR_RESURRECT, true);
 }
 
 void Battlefield::RemovePlayerFromResurrectQueue(ObjectGuid playerGuid)
 {
-    for (BfGraveyard* gy : GraveyardList)
-    {
-        if (!gy)
-            continue;
+    Player* player = ObjectAccessor::FindPlayer(playerGuid);
+    if (!player)
+        return;
 
-        if (gy->HasPlayer(playerGuid))
-        {
-            gy->RemovePlayer(playerGuid);
-            break;
-        }
-    }
+    player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
 }
 
 void Battlefield::SendAreaSpiritHealerQueryOpcode(Player* player, ObjectGuid const& guid)
@@ -707,80 +690,9 @@ float BfGraveyard::GetDistance(Player* player)
     return player->GetDistance2d(safeLoc->x, safeLoc->y);
 }
 
-void BfGraveyard::AddPlayer(ObjectGuid playerGuid)
-{
-    if (!ResurrectQueue.count(playerGuid))
-    {
-        ResurrectQueue.insert(playerGuid);
-
-        if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
-            player->CastSpell(player, SPELL_WAITING_FOR_RESURRECT, true);
-    }
-}
-
-void BfGraveyard::RemovePlayer(ObjectGuid playerGuid)
-{
-    ResurrectQueue.erase(ResurrectQueue.find(playerGuid));
-
-    if (Player* player = ObjectAccessor::FindPlayer(playerGuid))
-        player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
-}
-
-void BfGraveyard::Resurrect()
-{
-    if (ResurrectQueue.empty())
-        return;
-
-    for (ObjectGuid const& guid : ResurrectQueue)
-    {
-        // Get player object from his guid
-        Player* player = ObjectAccessor::FindPlayer(guid);
-        if (!player)
-            continue;
-
-        // Check if the player is in world and on the good graveyard
-        if (player->IsInWorld())
-            if (Unit* spirit = ObjectAccessor::GetCreature(*player, SpiritGuide[ControlTeam]))
-                spirit->CastSpell(spirit, SPELL_SPIRIT_HEAL, true);
-
-        // Resurrect player
-        player->CastSpell(player, SPELL_RESURRECTION_VISUAL, true);
-        player->ResurrectPlayer(1.0f);
-        player->CastSpell(player, 6962, true);
-        player->CastSpell(player, SPELL_SPIRIT_HEAL_MANA, true);
-
-        player->SpawnCorpseBones(false);
-    }
-
-    ResurrectQueue.clear();
-}
-
-// For changing graveyard control
 void BfGraveyard::GiveControlTo(TeamId team)
 {
     ControlTeam = team;
-    // Teleport to other graveyard, players which were on this graveyard
-    RelocateDeadPlayers();
-}
-
-void BfGraveyard::RelocateDeadPlayers()
-{
-    GraveyardStruct const* closestGrave = nullptr;
-    for (ObjectGuid const& guid : ResurrectQueue)
-    {
-        Player* player = ObjectAccessor::FindPlayer(guid);
-        if (!player)
-            continue;
-
-        if (closestGrave)
-            player->TeleportTo(player->GetMapId(), closestGrave->x, closestGrave->y, closestGrave->z, player->GetOrientation());
-        else
-        {
-            closestGrave = Bf->GetClosestGraveyard(player);
-            if (closestGrave)
-                player->TeleportTo(player->GetMapId(), closestGrave->x, closestGrave->y, closestGrave->z, player->GetOrientation());
-        }
-    }
 }
 
 Creature* Battlefield::SpawnCreature(uint32 entry, Position pos, TeamId teamId)
diff --git a/src/server/game/Battlefield/Battlefield.h b/src/server/game/Battlefield/Battlefield.h
@@ -169,18 +169,6 @@ class BfGraveyard
     // Set spirit service for the graveyard
     void SetSpirit(Creature* spirit, TeamId team);
 
-    // Add a player to the graveyard
-    void AddPlayer(ObjectGuid playerGuid);
-
-    // Remove a player from the graveyard
-    void RemovePlayer(ObjectGuid playerGuid);
-
-    // Resurrect players
-    void Resurrect();
-
-    // Move players waiting to that graveyard on the nearest one
-    void RelocateDeadPlayers();
-
     // Check if this graveyard has a spirit guide
     bool HasNpc(ObjectGuid guid)
     {
@@ -190,8 +178,7 @@ class BfGraveyard
         return (SpiritGuide[0] == guid || SpiritGuide[1] == guid);
     }
 
-    // Check if a player is in this graveyard's resurrect queue
-    bool HasPlayer(ObjectGuid guid) const { return ResurrectQueue.find(guid) != ResurrectQueue.end(); }
+    ObjectGuid GetSpiritGuide(TeamId team) const { return SpiritGuide[team]; }
 
     // Get the graveyard's ID.
     uint32 GetGraveyardId() const { return GraveyardId; }
@@ -200,7 +187,6 @@ class BfGraveyard
     TeamId ControlTeam;
     uint32 GraveyardId;
     ObjectGuid SpiritGuide[2];
-    GuidUnorderedSet ResurrectQueue;
     Battlefield* Bf;
 };
 
@@ -444,6 +430,8 @@ class Battlefield : public ZoneScript
     /// Returns true if the player is already tracked as actively in the war or invited to join it.
     bool IsPlayerInWarOrInvited(Player* player) const;
 
+    void RemovePlayerFromTracking(ObjectGuid playerGuid);
+
     // Player-iteration helpers: resolve each GUID to a live Player* and call fn(player).
     // Using templates avoids std::function overhead and works naturally with lambdas.
     template<typename Func>
diff --git a/src/server/game/Battlefield/Zones/BattlefieldWG.cpp b/src/server/game/Battlefield/Zones/BattlefieldWG.cpp
@@ -193,9 +193,39 @@ bool BattlefieldWG::SetupBattlefield()
     _scheduler.Schedule(Milliseconds(RESURRECTION_INTERVAL),
         BATTLEFIELD_TIMER_GROUP_RESURRECT, [this](TaskContext context)
     {
-        for (BfGraveyard* gy : GraveyardList)
-            if (gy)
-                gy->Resurrect();
+        ForEachPlayerInZone([this](Player* player)
+        {
+            if (!player->HasAura(SPELL_WAITING_FOR_RESURRECT))
+                return;
+
+            TeamId team = player->GetTeamId();
+            Unit* closestSpirit = nullptr;
+            float closestDist = -1.0f;
+            for (BfGraveyard* gy : GraveyardList)
+            {
+                if (!gy)
+                    continue;
+                Unit* spirit = ObjectAccessor::GetCreature(*player, gy->GetSpiritGuide(team));
+                if (!spirit)
+                    continue;
+                float dist = player->GetDistance(spirit);
+                if (closestDist < 0.0f || dist < closestDist)
+                {
+                    closestDist = dist;
+                    closestSpirit = spirit;
+                }
+            }
+
+            if (closestSpirit)
+                closestSpirit->CastSpell(closestSpirit, SPELL_SPIRIT_HEAL, true);
+
+            player->CastSpell(player, SPELL_RESURRECTION_VISUAL, true);
+            player->ResurrectPlayer(1.0f);
+            player->CastSpell(player, 6962, true);
+            player->CastSpell(player, SPELL_SPIRIT_HEAL_MANA, true);
+            player->SpawnCorpseBones(false);
+            player->RemoveAurasDueToSpell(SPELL_WAITING_FOR_RESURRECT);
+        });
         context.Repeat();
     });
 
@@ -266,19 +296,7 @@ void BattlefieldWG::OnBattleStart()
         capturePoint->SetCapturePointData(capturePoint->GetCapturePointGo(),
             capturePoint->GetCapturePointGo()->GetEntry() == GO_WINTERGRASP_FACTORY_BANNER_SE || capturePoint->GetCapturePointGo()->GetEntry() == GO_WINTERGRASP_FACTORY_BANNER_SW ? GetAttackerTeam() : GetDefenderTeam());
 
-    for (uint8 team = 0; team < 2; ++team)
-        for (ObjectGuid const& guid : Players[team])
-        {
-            // Kick player in orb room, TODO: offline player ?
-            if (Player* player = ObjectAccessor::FindPlayer(guid))
-            {
-                float x, y, z;
-                player->GetPosition(x, y, z);
-                if (5500 > x && x > 5392 && y < 2880 && y > 2800 && z < 480)
-                    player->TeleportTo(MAP_NORTHREND, 5349.8686f, 2838.481f, 409.240f, 0.046328f);
-                SendInitWorldStatesTo(player);
-            }
-        }
+    SendInitWorldStatesToAll();
     // Initialize vehicle counter
     UpdateCounterVehicle(true);
     // Send start warning to all players
diff --git a/src/server/game/DungeonFinding/LFGMgr.cpp b/src/server/game/DungeonFinding/LFGMgr.cpp
@@ -1692,18 +1692,32 @@ namespace lfg
         LfgGuidList players;
         GuidUnorderedSet playersToTeleport;
 
-        for (LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
-        {
-            ObjectGuid guid = it->first;
-            if (guid == proposal.leader)
-                players.push_front(guid);
-            else
-                players.push_back(guid);
+        // Sort players by role, leader first, then tank, healer and dps
+        std::vector<ObjectGuid> tanks, healers, dps;
+
+        if (proposal.leader && proposal.players.contains(proposal.leader))
+            players.push_back(proposal.leader);
 
+        for (auto const& [guid, player] : proposal.players)
+        {
             if (proposal.isNew || GetGroup(guid) != proposal.group)
                 playersToTeleport.insert(guid);
+
+            if (guid == proposal.leader)
+                continue;
+
+            if (player.role & lfg::PLAYER_ROLE_TANK)
+                tanks.push_back(guid);
+            else if (player.role & lfg::PLAYER_ROLE_HEALER)
+                healers.push_back(guid);
+            else
+                dps.push_back(guid);
         }
 
+        players.insert(players.end(), tanks.begin(), tanks.end());
+        players.insert(players.end(), healers.begin(), healers.end());
+        players.insert(players.end(), dps.begin(), dps.end());
+
         // Set the dungeon difficulty
         LFGDungeonData const* dungeon = GetLFGDungeon(proposal.dungeonId);
         ASSERT(dungeon);
diff --git a/src/server/game/Handlers/LFGHandler.cpp b/src/server/game/Handlers/LFGHandler.cpp
@@ -569,12 +569,32 @@ void WorldSession::SendLfgUpdateProposal(lfg::LfgProposal const& proposal)
     data << uint8(silent);                                 // Show proposal window
     data << uint8(proposal.players.size());                // Group size
 
-    for (lfg::LfgProposalPlayerContainer::const_iterator it = proposal.players.begin(); it != proposal.players.end(); ++it)
+    // Sort by roles: tank, healer, dps
+    std::vector<ObjectGuid> ordered;
+    ordered.reserve(proposal.players.size());
+
+    std::vector<ObjectGuid> tanks, healers, dps;
+
+    for (auto const& [pguid, player] : proposal.players)
+    {
+        if (player.role & lfg::PLAYER_ROLE_TANK)
+            tanks.push_back(pguid);
+        else if (player.role & lfg::PLAYER_ROLE_HEALER)
+            healers.push_back(pguid);
+        else
+            dps.push_back(pguid);
+    }
+
+    ordered.insert(ordered.end(), tanks.begin(), tanks.end());
+    ordered.insert(ordered.end(), healers.begin(), healers.end());
+    ordered.insert(ordered.end(), dps.begin(), dps.end());
+
+    for (auto const& pguid : ordered)
     {
-        lfg::LfgProposalPlayer const& player = it->second;
+        lfg::LfgProposalPlayer const& player = proposal.players.find(pguid)->second;
         data << uint32(player.role);                       // Role
-        data << uint8(it->first == guid);                  // Self player
-        if (!player.group)                                 // Player not it a group
+        data << uint8(pguid == guid);                      // Self player
+        if (!player.group)                                 // Player not in a group
         {
             data << uint8(0);                              // Not in dungeon
             data << uint8(0);                              // Not same group
diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.cpp b/src/server/game/Spells/Auras/SpellAuraEffects.cpp
@@ -5347,13 +5347,10 @@ void AuraEffect::HandleAuraDummy(AuraApplication const* aurApp, uint8 mode, bool
                     {
                         case 2584: // Waiting to Resurrect
                             // Waiting to resurrect spell cancel, we must remove player from resurrect queue
+                            // bf branch omitted: it would cascade back into this handler.
                             if (target->IsPlayer())
-                            {
                                 if (Battleground* bg = target->ToPlayer()->GetBattleground())
                                     bg->RemovePlayerFromResurrectQueue(target->ToPlayer());
-                                if (Battlefield* bf = sBattlefieldMgr->GetBattlefieldToZoneId(target->GetZoneId()))
-                                    bf->RemovePlayerFromResurrectQueue(target->GetGUID());
-                            }
                             break;
                         case 43681: // Inactive
                             {
diff --git a/src/server/scripts/Northrend/zone_wintergrasp.cpp b/src/server/scripts/Northrend/zone_wintergrasp.cpp
diff --git a/src/server/scripts/World/item_scripts.cpp b/src/server/scripts/World/item_scripts.cpp
