Core/Packets: Updated and enabled duel opcodes

Closes #14438

8 files changed, 194 insertions, 37 deletions

diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
index 41dcf76145a..35d33962c91 100644
--- a/src/server/game/Entities/Player/Player.cpp
+++ b/src/server/game/Entities/Player/Player.cpp
@@ -92,6 +92,7 @@
 #include "WorldStatePackets.h"
 #include "MiscPackets.h"
 #include "ChatPackets.h"
+#include "DuelPackets.h"
 #include "MovementPackets.h"
 #include "ItemPackets.h"
 #include "QuestPackets.h"
@@ -7441,8 +7442,7 @@ void Player::CheckDuelDistance(time_t currTime)
         {
             duel->outOfBound = currTime;
 
-            WorldPacket data(SMSG_DUEL_OUT_OF_BOUNDS, 0);
-            GetSession()->SendPacket(&data);
+            GetSession()->SendPacket(WorldPackets::Duel::DuelOutOfBounds().Write());
         }
     }
     else
@@ -7451,8 +7451,7 @@ void Player::CheckDuelDistance(time_t currTime)
         {
             duel->outOfBound = 0;
 
-            WorldPacket data(SMSG_DUEL_IN_BOUNDS, 0);
-            GetSession()->SendPacket(&data);
+            GetSession()->SendPacket(WorldPackets::Duel::DuelInBounds().Write());
         }
         else if (currTime >= (duel->outOfBound+10))
             DuelComplete(DUEL_FLED);
@@ -7472,20 +7471,23 @@ void Player::DuelComplete(DuelCompleteType type)
 
     TC_LOG_DEBUG("entities.unit", "Duel Complete %s %s", GetName().c_str(), duel->opponent->GetName().c_str());
 
-    WorldPacket data(SMSG_DUEL_COMPLETE, (1));
-    data << (uint8)((type != DUEL_INTERRUPTED) ? 1 : 0);
-    GetSession()->SendPacket(&data);
+    WorldPackets::Duel::DuelComplete duelCompleted;
+    duelCompleted.Started = type != DUEL_INTERRUPTED ? true : false;
+    GetSession()->SendPacket(duelCompleted.Write());
 
     if (duel->opponent->GetSession())
-        duel->opponent->GetSession()->SendPacket(&data);
+        duel->opponent->GetSession()->SendPacket(duelCompleted.Write());
 
     if (type != DUEL_INTERRUPTED)
     {
-        data.Initialize(SMSG_DUEL_WINNER, (1+20));          // we guess size
-        data << uint8(type == DUEL_WON ? 0 : 1);            // 0 = just won; 1 = fled
-        data << duel->opponent->GetName();
-        data << GetName();
-        SendMessageToSet(&data, true);
+        WorldPackets::Duel::DuelWinner duelWinner;
+        duelWinner.BeatenName = (type == DUEL_WON ? duel->opponent->GetName() : GetName());
+        duelWinner.WinnerName = (type == DUEL_WON ? GetName() : duel->opponent->GetName());
+        duelWinner.BeatenVirtualRealmAddress = GetVirtualRealmAddress();
+        duelWinner.WinnerVirtualRealmAddress = GetVirtualRealmAddress();
+        duelWinner.Fled = type != DUEL_WON;
+
+        SendMessageToSet(duelWinner.Write(), true);
     }
 
     sScriptMgr->OnPlayerDuelEnd(duel->opponent, this, type);
@@ -25585,13 +25587,6 @@ std::string Player::GetGuildName()
     return GetGuildId() ? sGuildMgr->GetGuildById(GetGuildId())->GetName() : "";
 }
 
-void Player::SendDuelCountdown(uint32 counter)
-{
-    WorldPacket data(SMSG_DUEL_COUNTDOWN, 4);
-    data << uint32(counter);                                // seconds
-    GetSession()->SendPacket(&data);
-}
-
 void Player::AddRefundReference(ObjectGuid it)
 {
     m_refundableItems.insert(it);
diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h
index 923261297ec..3f94fc23fa9 100644
--- a/src/server/game/Entities/Player/Player.h
+++ b/src/server/game/Entities/Player/Player.h
@@ -1990,7 +1990,6 @@ class Player : public Unit, public GridObject<Player>
         void UpdateDuelFlag(time_t currTime);
         void CheckDuelDistance(time_t currTime);
         void DuelComplete(DuelCompleteType type);
-        void SendDuelCountdown(uint32 counter);
 
         bool IsGroupVisibleFor(Player const* p) const;
         bool IsInSameGroupWith(Player const* p) const;
diff --git a/src/server/game/Handlers/DuelHandler.cpp b/src/server/game/Handlers/DuelHandler.cpp
index 75e5781caa8..db18bbb79a4 100644
--- a/src/server/game/Handlers/DuelHandler.cpp
+++ b/src/server/game/Handlers/DuelHandler.cpp
@@ -24,6 +24,30 @@
 #include "UpdateData.h"
 #include "Player.h"
 
+#define SPELL_DUEL  7266
+#define SPELL_MOUNTED_DUEL  62875
+
+void WorldSession::HandleCanDuel(WorldPackets::Duel::CanDuel& packet)
+{
+    Player* player = ObjectAccessor::FindPlayer(packet.TargetGUID);
+
+    if (!player)
+        return;
+
+    WorldPackets::Duel::CanDuelResult response;
+    response.TargetGUID = packet.TargetGUID;
+    response.Result = !player->duel;
+    SendPacket(response.Write());
+
+    if (response.Result)
+    {
+        if (_player->IsMounted())
+            _player->CastSpell(player, SPELL_MOUNTED_DUEL);
+        else
+            _player->CastSpell(player, SPELL_DUEL);
+    }
+}
+
 void WorldSession::HandleDuelResponseOpcode(WorldPackets::Duel::DuelResponse& duelResponse)
 {
     if (duelResponse.Accepted)
@@ -50,8 +74,9 @@ void WorldSession::HandleDuelAccepted()
     player->duel->startTimer = now;
     plTarget->duel->startTimer = now;
 
-    player->SendDuelCountdown(3000);
-    plTarget->SendDuelCountdown(3000);
+    WorldPackets::Duel::DuelCountdown packet(3000); // milliseconds
+    player->GetSession()->SendPacket(packet.Write());
+    plTarget->GetSession()->SendPacket(packet.Write());
 }
 
 void WorldSession::HandleDuelCancelled()
diff --git a/src/server/game/Server/Packets/DuelPackets.cpp b/src/server/game/Server/Packets/DuelPackets.cpp
index 5c03c3b1cca..bf679a07b8a 100644
--- a/src/server/game/Server/Packets/DuelPackets.cpp
+++ b/src/server/game/Server/Packets/DuelPackets.cpp
@@ -17,9 +17,59 @@
 
 #include "DuelPackets.h"
 
+void WorldPackets::Duel::CanDuel::Read()
+{
+    _worldPacket >> TargetGUID;
+}
+
+WorldPacket const* WorldPackets::Duel::CanDuelResult::Write()
+{
+    _worldPacket << TargetGUID;
+    _worldPacket.WriteBit(Result);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Duel::DuelComplete::Write()
+{
+    _worldPacket.WriteBit(Started);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Duel::DuelCountdown::Write()
+{
+    _worldPacket << Countdown;
+
+    return &_worldPacket;
+}
+
+WorldPacket const* WorldPackets::Duel::DuelRequested::Write()
+{
+    _worldPacket << ArbiterGUID;
+    _worldPacket << RequestedByGUID;
+    _worldPacket << RequestedByWowAccount;
+
+    return &_worldPacket;
+}
+
 void WorldPackets::Duel::DuelResponse::Read()
 {
     _worldPacket >> ArbiterGUID;
     Accepted = _worldPacket.ReadBit();
 }
 
+WorldPacket const* WorldPackets::Duel::DuelWinner::Write()
+{
+    _worldPacket.WriteBits(BeatenName.size(), 6);
+    _worldPacket.WriteBits(WinnerName.size(), 6);
+    _worldPacket.WriteBit(Fled);
+    _worldPacket << BeatenVirtualRealmAddress;
+    _worldPacket << WinnerVirtualRealmAddress;
+    _worldPacket.WriteString(BeatenName);
+    _worldPacket.WriteString(WinnerName);
+
+    return &_worldPacket;
+}
diff --git a/src/server/game/Server/Packets/DuelPackets.h b/src/server/game/Server/Packets/DuelPackets.h
index e66516188be..9a53f9b4d18 100644
--- a/src/server/game/Server/Packets/DuelPackets.h
+++ b/src/server/game/Server/Packets/DuelPackets.h
@@ -25,6 +25,75 @@ namespace WorldPackets
 {
     namespace Duel
     {
+        class CanDuel final : public ClientPacket
+        {
+        public:
+            CanDuel(WorldPacket&& packet) : ClientPacket(CMSG_CAN_DUEL, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid TargetGUID;
+        };
+
+        class CanDuelResult final : public ServerPacket
+        {
+        public:
+            CanDuelResult() : ServerPacket(SMSG_CAN_DUEL_RESULT, 16 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid TargetGUID;
+            bool Result = false;
+        };
+
+        class DuelComplete final : public ServerPacket
+        {
+        public:
+            DuelComplete() : ServerPacket(SMSG_DUEL_COMPLETE, 1) { }
+
+            WorldPacket const* Write() override;
+
+            bool Started = false;
+        };
+
+        class DuelCountdown final : public ServerPacket
+        {
+        public:
+            DuelCountdown(uint32 countdown) : ServerPacket(SMSG_DUEL_COUNTDOWN, 4), Countdown(countdown) { }
+
+            WorldPacket const* Write() override;
+
+            uint32 Countdown = 0;
+        };
+
+        class DuelInBounds final : public ServerPacket
+        {
+        public:
+            DuelInBounds() : ServerPacket(SMSG_DUEL_IN_BOUNDS, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class DuelOutOfBounds final : public ServerPacket
+        {
+        public:
+            DuelOutOfBounds() : ServerPacket(SMSG_DUEL_OUT_OF_BOUNDS, 0) { }
+
+            WorldPacket const* Write() override { return &_worldPacket; }
+        };
+
+        class DuelRequested final : public ServerPacket
+        {
+        public:
+            DuelRequested() : ServerPacket(SMSG_DUEL_REQUESTED, 16 * 3) { }
+
+            WorldPacket const* Write() override;
+
+            ObjectGuid ArbiterGUID;
+            ObjectGuid RequestedByGUID;
+            ObjectGuid RequestedByWowAccount;
+        };
+
         class DuelResponse : public ClientPacket
         {
         public:
@@ -35,6 +104,20 @@ namespace WorldPackets
             ObjectGuid ArbiterGUID;
             bool Accepted = false;
         };
+
+        class DuelWinner final : public ServerPacket
+        {
+        public:
+            DuelWinner() : ServerPacket(SMSG_DUEL_WINNER, 4 * 4 + 1) { }
+
+            WorldPacket const* Write() override;
+
+            std::string BeatenName;
+            std::string WinnerName;
+            uint32 BeatenVirtualRealmAddress = 0;
+            uint32 WinnerVirtualRealmAddress = 0;
+            bool Fled = false;
+        };
     }
 }
 
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index fc7ebf9f1eb..a820840de0c 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -244,7 +244,7 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CANCEL_QUEUED_SPELL,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CANCEL_TEMP_ENCHANTMENT,                 STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCancelTempEnchantmentOpcode);
     DEFINE_HANDLER(CMSG_CANCEL_TRADE,                                       STATUS_LOGGEDIN_OR_RECENTLY_LOGGOUT, PROCESS_THREADUNSAFE, WorldPackets::Trade::CancelTrade, &WorldSession::HandleCancelTradeOpcode);
-    DEFINE_OPCODE_HANDLER_OLD(CMSG_CAN_DUEL,                                STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
+    DEFINE_HANDLER(CMSG_CAN_DUEL,                                           STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Duel::CanDuel, &WorldSession::HandleCanDuel);
     DEFINE_HANDLER(CMSG_CAST_SPELL,                                         STATUS_LOGGEDIN,  PROCESS_THREADSAFE,   WorldPackets::Spells::CastSpell, &WorldSession::HandleCastSpellOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CHALLENGE_MODE_REQUEST_LEADERS,          STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_CHALLENGE_MODE_REQUEST_MAP_STATS,        STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
@@ -349,7 +349,7 @@ void OpcodeTable::Initialize()
     DEFINE_OPCODE_HANDLER_OLD(CMSG_DISMISS_CRITTER,                         STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleDismissCritter            );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_DO_MASTER_LOOT_ROLL,                     STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_OPCODE_HANDLER_OLD(CMSG_DO_READY_CHECK,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleRaidReadyCheckOpcode      );
-    DEFINE_HANDLER(CMSG_DUEL_RESPONSE,                                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, WorldPackets::Duel::DuelResponse, &WorldSession::HandleDuelResponseOpcode);
+    DEFINE_HANDLER(CMSG_DUEL_RESPONSE,                                      STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Duel::DuelResponse, &WorldSession::HandleDuelResponseOpcode);
     DEFINE_OPCODE_HANDLER_OLD(CMSG_EJECT_PASSENGER,                         STATUS_UNHANDLED, PROCESS_INPLACE,      &WorldSession::Handle_NULL                     );
     DEFINE_HANDLER(CMSG_EMOTE,                                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, WorldPackets::Chat::EmoteClient, &WorldSession::HandleEmoteOpcode);
     DEFINE_HANDLER(CMSG_ENABLE_NAGLE,                                       STATUS_NEVER,     PROCESS_INPLACE,      WorldPacket, &WorldSession::Handle_EarlyProccess);
@@ -967,7 +967,7 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SCENE,                            STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SPELL_VISUAL,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_SPELL_VISUAL_KIT,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAN_DUEL_RESULT,                         STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAN_DUEL_RESULT,                         STATUS_NEVER,        CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAST_FAILED,                             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CATEGORY_COOLDOWN,                       STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_CHALLEGE_MODE_REWARDS,                   STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
@@ -1060,12 +1060,12 @@ void OpcodeTable::Initialize()
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DISPLAY_TOAST,                           STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DONT_AUTO_PUSH_SPELLS_TO_ACTION_BAR,     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DROP_NEW_CONNECTION,                     STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_COMPLETE,                           STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_COUNTDOWN,                          STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_IN_BOUNDS,                          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_OUT_OF_BOUNDS,                      STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_REQUESTED,                          STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
-    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_WINNER,                             STATUS_UNHANDLED,    CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_COMPLETE,                           STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_COUNTDOWN,                          STATUS_NEVER,        CONNECTION_TYPE_REALM);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_IN_BOUNDS,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_OUT_OF_BOUNDS,                      STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_REQUESTED,                          STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
+    DEFINE_SERVER_OPCODE_HANDLER(SMSG_DUEL_WINNER,                             STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_DURABILITY_DAMAGE_DEATH,                 STATUS_UNHANDLED,    CONNECTION_TYPE_REALM);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_EMOTE,                                   STATUS_NEVER,        CONNECTION_TYPE_INSTANCE);
     DEFINE_SERVER_OPCODE_HANDLER(SMSG_ENABLE_BARBER_SHOP,                      STATUS_NEVER,        CONNECTION_TYPE_REALM);
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index ef301ec04d3..8ec5af98db7 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -170,6 +170,7 @@ namespace WorldPackets
 
     namespace Duel
     {
+        class CanDuel;
         class DuelResponse;
     }
 
@@ -1027,6 +1028,7 @@ class WorldSession
         void HandleStableSwapPetCallback(PreparedQueryResult result, uint32 petId);
         void SendTrainerBuyFailed(ObjectGuid guid, uint32 spellId, uint32 reason);
 
+        void HandleCanDuel(WorldPackets::Duel::CanDuel& packet);
         void HandleDuelResponseOpcode(WorldPackets::Duel::DuelResponse& duelResponse);
         void HandleDuelAccepted();
         void HandleDuelCancelled();
diff --git a/src/server/game/Spells/SpellEffects.cpp b/src/server/game/Spells/SpellEffects.cpp
index 61634e2be7c..520f45522ec 100644
--- a/src/server/game/Spells/SpellEffects.cpp
+++ b/src/server/game/Spells/SpellEffects.cpp
@@ -67,6 +67,7 @@
 #include "GuildMgr.h"
 #include "ReputationMgr.h"
 #include "AreaTrigger.h"
+#include "DuelPackets.h"
 #include "MiscPackets.h"
 #include "SpellPackets.h"
 
@@ -3890,11 +3891,13 @@ void Spell::EffectDuel(SpellEffIndex effIndex)
     //END
 
     // Send request
-    WorldPacket data(SMSG_DUEL_REQUESTED, 8 + 8);
-    data << pGameObj->GetGUID();
-    data << caster->GetGUID();
-    caster->GetSession()->SendPacket(&data);
-    target->GetSession()->SendPacket(&data);
+    WorldPackets::Duel::DuelRequested packet;
+    packet.ArbiterGUID = pGameObj->GetGUID();
+    packet.RequestedByGUID = caster->GetGUID();
+    packet.RequestedByWowAccount = caster->GetSession()->GetAccountGUID();
+
+    caster->GetSession()->SendPacket(packet.Write());
+    target->GetSession()->SendPacket(packet.Write());
 
     // create duel-info
     DuelInfo* duel   = new DuelInfo;