MoP 5.4.8.18414 opcode campaign: 22 packet waves, quest-log projection, quest-NPC query

src/game/Object/ObjectMgr.h

@@ -1366,6 +1366,15 @@ class ObjectMgr
             return m_CreatureQuestRelations.equal_range(entry);
         }
 
+        /// Quest-completion relations keyed by quest instead of by creature.
+        /// SMSG_QUEST_NPC_QUERY_RESPONSE answers with the quest's ENDER
+        /// creatures; retail 18414 captures confirm that rule (quest 28508
+        /// returns its ender 44452, never its giver 42898).
+        QuestRelationsMapBounds GetQuestEnderCreaturesMapBounds(uint32 questId) const
+        {
+            return m_QuestEnderCreatures.equal_range(questId);
+        }
+
         QuestRelationsMapBounds GetCreatureQuestInvolvedRelationsMapBounds(uint32 entry) const
         {
             return m_CreatureQuestInvolvedRelations.equal_range(entry);
@@ -1497,6 +1506,7 @@ class ObjectMgr
 
         QuestRelationsMap       m_CreatureQuestRelations;
         QuestRelationsMap       m_CreatureQuestInvolvedRelations;
+        QuestRelationsMap       m_QuestEnderCreatures;
         QuestRelationsMap       m_GOQuestRelations;
         QuestRelationsMap       m_GOQuestInvolvedRelations;
 

src/game/Object/ObjectMgrQuestRelations.cpp

@@ -161,6 +161,16 @@ void ObjectMgr::LoadCreatureInvolvedRelations()
 {
     LoadQuestRelationsHelper(m_CreatureQuestInvolvedRelations, QA_CREATURE, QR_END);
 
+    // Inverse view for CMSG_QUEST_NPC_QUERY, which asks by quest rather than
+    // by creature. Built from the same rows, so it cannot drift from them and
+    // needs no additional query or table-name coupling.
+    m_QuestEnderCreatures.clear();
+    for (QuestRelationsMap::const_iterator itr = m_CreatureQuestInvolvedRelations.begin();
+         itr != m_CreatureQuestInvolvedRelations.end(); ++itr)
+    {
+        m_QuestEnderCreatures.insert(QuestRelationsMap::value_type(itr->second, itr->first));
+    }
+
     for (QuestRelationsMap::iterator itr = m_CreatureQuestInvolvedRelations.begin(); itr != m_CreatureQuestInvolvedRelations.end(); ++itr)
     {
         CreatureInfo const* cInfo = GetCreatureTemplate(itr->first);

src/game/Object/ObjectUpdate.cpp

@@ -110,6 +110,15 @@ namespace
         PLAYER_FIELD_BUYBACK_TIMESTAMP_1 + 12 ==
             MopUpdateObject::SelfBuybackSourceStart + MopUpdateObject::SelfBuybackFieldCount,
         "self buyback translation must cover the legacy price and timestamp arrays");
+    static_assert(PLAYER_QUEST_LOG_1_1 == MopUpdateObject::SelfQuestLogSourceStart &&
+        PLAYER_QUEST_LOG_50_5 + 1 ==
+            MopUpdateObject::SelfQuestLogSourceStart + MopUpdateObject::SelfQuestLogFieldCount,
+        "self quest-log translation must cover all fifty legacy five-word slots");
+    static_assert(MAX_QUEST_OFFSET == MopUpdateObject::SelfQuestLogSourceStride,
+        "legacy quest slot stride must match the projection's source stride");
+    static_assert(PLAYER_QUEST_LOG_2_1 - PLAYER_QUEST_LOG_1_1 ==
+        MopUpdateObject::SelfQuestLogSourceStride,
+        "legacy quest slots must remain contiguous at the projected stride");
 
     bool CanBuildMopInventoryObject(Object const& object, Player* target)
     {
@@ -576,7 +585,8 @@ void Object::BuildValuesUpdateBlockForPlayer(UpdateData* data, Player* target) c
             fields.reserve(25 + MopUpdateObject::ObserverVisibleItemFieldCount +
                 MopUpdateObject::SelfInventoryFieldCount +
                 MopUpdateObject::SelfSkillFieldCount +
-                MopUpdateObject::SelfBuybackFieldCount);
+                MopUpdateObject::SelfBuybackFieldCount +
+                MopUpdateObject::SelfQuestLogFieldCount);
             auto addIfChanged = [this, &fields](uint16 sourceIndex)
             {
                 if (m_changedValues[sourceIndex])
@@ -605,6 +615,17 @@ void Object::BuildValuesUpdateBlockForPlayer(UpdateData* data, Player* target) c
             addIfChanged(UNIT_FIELD_DISPLAYID);
             addIfChanged(UNIT_FIELD_NATIVEDISPLAYID);
 
+            // QuestLogFrame renders a slot only once the client holds its
+            // quest id, so an accepted quest never appears until these private
+            // fields are projected. Ordered ahead of the visible-item feed
+            // because the serializer requires ascending legacy indices.
+            for (uint16 i = MopUpdateObject::SelfQuestLogSourceStart;
+                 i < MopUpdateObject::SelfQuestLogSourceStart +
+                     MopUpdateObject::SelfQuestLogFieldCount; ++i)
+            {
+                addIfChanged(i);
+            }
+
             // Local equipment changes use the same public 18414 visible-item
             // projection as updates sent to nearby observers.
             for (uint16 i = MopUpdateObject::ObserverVisibleItemSourceStart;

src/game/Object/Player.cpp

@@ -2339,16 +2339,15 @@ void Player::SetGMVisible(bool on)
  */
 void Player::SendLogXPGain(uint32 GivenXP, Unit* victim, uint32 RestXP)
 {
-    WorldPacket data(SMSG_LOG_XPGAIN, 21);
-    data << (victim ? victim->GetObjectGuid() : ObjectGuid());// guid
-    data << uint32(GivenXP + RestXP);                       // given experience
-    data << uint8(victim ? 0 : 1);                          // 00-kill_xp type, 01-non_kill_xp type
-    if (victim)
-    {
-        data << uint32(GivenXP);                            // experience without rested bonus
-        data << float(1);                                   // 1 - none 0 - 100% group bonus output
-    }
-    data << uint8(0);                                       // new 2.4.0
+    MopProgressionPackets::ExperienceGain packetInfo;
+    packetInfo.sourceGuid = victim ? victim->GetObjectGuid() : ObjectGuid();
+    packetInfo.totalExperience = GivenXP + RestXP;
+    packetInfo.type = victim ? 0 : 1;
+    packetInfo.hasBaseExperience = victim != nullptr;
+    packetInfo.baseExperience = GivenXP;
+
+    WorldPacket data;
+    MopProgressionPackets::BuildExperienceGain(data, packetInfo);
     GetSession()->SendPacket(&data);
 }
 
@@ -2453,22 +2452,17 @@ void Player::GiveLevel(uint32 level)
     uint32 basehp = 0, basemana = 0;
     sObjectMgr.GetPlayerClassLevelInfo(getClass(), level, basehp, basemana);
 
-    // send levelup info to client
-    WorldPacket data(SMSG_LEVELUP_INFO, (4 + 4 + MAX_STORED_POWERS * 4 + MAX_STATS * 4));
-    data << uint32(level);
-    data << uint32(int32(basehp) - int32(GetCreateHealth()));
-    // for(int i = 0; i < MAX_POWERS; ++i)                  // Powers loop (0-4)
-    data << uint32(int32(basemana)   - int32(GetCreateMana()));
-    data << uint32(0);
-    data << uint32(0);
-    data << uint32(0);
-    data << uint32(0);
-    // end for
-    for (int i = STAT_STRENGTH; i < MAX_STATS; ++i)         // Stats loop (0-4)
-    {
-        data << uint32(int32(info.stats[i]) - GetCreateStat(Stats(i)));
-    }
+    MopProgressionPackets::LevelUpInfo packetInfo;
+    packetInfo.level = level;
+    packetInfo.healthDelta = uint32(int32(basehp) - int32(GetCreateHealth()));
+    packetInfo.powerDeltas[POWER_MANA] =
+        uint32(int32(basemana) - int32(GetCreateMana()));
+    for (int i = STAT_STRENGTH; i < MAX_STATS; ++i)
+        packetInfo.statDeltas[i] =
+            uint32(int32(info.stats[i]) - GetCreateStat(Stats(i)));
 
+    WorldPacket data;
+    MopProgressionPackets::BuildLevelUpInfo(data, packetInfo);
     GetSession()->SendPacket(&data);
 
     SetUInt32Value(PLAYER_NEXT_LEVEL_XP, sObjectMgr.GetXPForLevel(level));
@@ -4118,9 +4112,8 @@ void Player::Customize(ObjectGuid guid, uint8 gender, uint8 skin, uint8 face, ui
  */
 void Player::SendExplorationExperience(uint32 Area, uint32 Experience)
 {
-    WorldPacket data(SMSG_EXPLORATION_EXPERIENCE, 8);
-    data << uint32(Area);
-    data << uint32(Experience);
+    WorldPacket data;
+    MopAreaTriggerPackets::BuildExplorationExperience(data, Area, Experience);
     GetSession()->SendPacket(&data);
 }
 
@@ -4584,9 +4577,8 @@ void Player::ApplyEquipCooldown(Item* pItem)
 
         AddSpellCooldown(spellData.SpellId, pItem->GetEntry(), time(NULL) + 30);
 
-        WorldPacket data(SMSG_ITEM_COOLDOWN, 12);
-        data << pItem->GetObjectGuid();
-        data << uint32(spellData.SpellId);
+        WorldPacket data;
+        MopSpellPackets::BuildItemCooldown(data, pItem->GetObjectGuid(), spellData.SpellId);
         GetSession()->SendPacket(&data);
     }
 }

src/game/Object/Player.h

@@ -635,6 +635,13 @@ namespace MopDeathPackets
 {
     static size_t const CEMETERY_LIST_MAX = 16;
 
+    inline void BuildDurabilityDamageDeath(WorldPacket& out)
+    {
+        // Wow.exe 18414 route 0x1E3E reaches sub_CE083A without consuming
+        // payload bytes and raises the retained DURABILITYDAMAGE_DEATH text.
+        out.Initialize(SMSG_DURABILITY_DAMAGE_DEATH, 0);
+    }
+
     inline void BuildDeathReleaseLocation(WorldPacket& out, uint32 mapId,
         float x, float y, float z)
     {
@@ -701,6 +708,187 @@ namespace MopReputationPackets
     }
 }
 
+namespace MopProgressionPackets
+{
+    struct ExperienceGain
+    {
+        ObjectGuid sourceGuid;
+        uint32 totalExperience = 0;
+        uint8 type = 0;
+        bool hasBaseExperience = false;
+        uint32 baseExperience = 0;
+    };
+
+    inline void BuildExperienceGain(WorldPacket& out,
+        ExperienceGain const& info)
+    {
+        out.Initialize(SMSG_LOG_XPGAIN, 19);
+
+        // Wow.exe 18414 reader sub_6F7E25 uses an inverted presence bit for
+        // base XP. The current backend has no group-rate or recruit-a-friend
+        // inputs, so their directly verified neutral bits are emitted here.
+        out.WriteBit(!info.hasBaseExperience);
+        out.WriteGuidMask<1, 2, 7, 4, 3>(info.sourceGuid);
+        out.WriteBit(false); // no recruit-a-friend bonus
+        out.WriteGuidMask<0, 5, 6>(info.sourceGuid);
+        out.WriteBit(true);  // default group rate 1.0; no float follows
+        out.FlushBits();
+
+        out.WriteGuidBytes<4, 2>(info.sourceGuid);
+        out << info.type;
+        out.WriteGuidBytes<7, 1, 3, 6>(info.sourceGuid);
+        out << info.totalExperience;
+        if (info.hasBaseExperience)
+            out << info.baseExperience;
+        out.WriteGuidBytes<0, 5>(info.sourceGuid);
+    }
+
+    struct LevelUpInfo
+    {
+        uint32 talentDelta = 0;
+        uint32 healthDelta = 0;
+        std::array<uint32, MAX_STATS> statDeltas = {{}};
+        uint32 level = 0;
+        std::array<uint32, MAX_STORED_POWERS> powerDeltas = {{}};
+    };
+
+    inline void BuildLevelUpInfo(WorldPacket& out, LevelUpInfo const& info)
+    {
+        out.Initialize(SMSG_LEVELUP_INFO, 13 * sizeof(uint32));
+
+        // Wow.exe 18414 reader sub_6BAC39 consumes thirteen uint32 values.
+        // Terminal sub_7B12E9 maps these slots to PLAYER_LEVEL_UP arguments.
+        out << info.talentDelta << info.healthDelta;
+        for (uint32 delta : info.statDeltas)
+            out << delta;
+        out << info.level;
+        for (uint32 delta : info.powerDeltas)
+            out << delta;
+    }
+}
+
+namespace MopComboPointPackets
+{
+    inline void BuildUpdate(WorldPacket& out, ObjectGuid target, uint8 points)
+    {
+        out.Initialize(SMSG_UPDATE_COMBO_POINTS, 10);
+
+        // Wow.exe 18414 reader sub_6E2BC4 consumes six target-GUID bytes,
+        // the raw combo-point byte, then the final two target-GUID bytes.
+        // Terminal sub_CCA14B publishes the recovered GUID/value pair.
+        out.WriteGuidMask<0, 5, 6, 3, 7, 4, 1, 2>(target);
+        out.WriteGuidBytes<5, 6, 4, 7, 3, 0>(target);
+        out << points;
+        out.WriteGuidBytes<2, 1>(target);
+    }
+}
+
+namespace MopDuelPackets
+{
+    inline void BuildRequested(WorldPacket& out, ObjectGuid arbiter,
+        ObjectGuid initiator)
+    {
+        out.Initialize(SMSG_DUEL_REQUESTED, 18);
+
+        // Reader sub_6CA34C interleaves the duel flag and initiator masks.
+        out.WriteGuidMask<5>(arbiter);
+        out.WriteGuidMask<4, 2, 7>(initiator);
+        out.WriteGuidMask<0>(arbiter);
+        out.WriteGuidMask<5>(initiator);
+        out.WriteGuidMask<4, 6>(arbiter);
+        out.WriteGuidMask<1, 3, 6>(initiator);
+        out.WriteGuidMask<7, 3, 2, 1>(arbiter);
+        out.WriteGuidMask<0>(initiator);
+        out.FlushBits();
+
+        out.WriteGuidBytes<5, 3>(arbiter);
+        out.WriteGuidBytes<7, 4>(initiator);
+        out.WriteGuidBytes<7>(arbiter);
+        out.WriteGuidBytes<3, 6, 0>(initiator);
+        out.WriteGuidBytes<4>(arbiter);
+        out.WriteGuidBytes<2, 1>(initiator);
+        out.WriteGuidBytes<0, 2, 6, 1>(arbiter);
+        out.WriteGuidBytes<5>(initiator);
+    }
+
+    inline void BuildOutOfBounds(WorldPacket& out)
+    {
+        // Wow.exe 18414 routes 0x001A through the fieldless reader sub_6BC12D.
+        out.Initialize(SMSG_DUEL_OUTOFBOUNDS, 0);
+    }
+
+    inline void BuildInBounds(WorldPacket& out)
+    {
+        // Wow.exe 18414 routes 0x163A through the same fieldless reader.
+        out.Initialize(SMSG_DUEL_INBOUNDS, 0);
+    }
+
+    inline void BuildComplete(WorldPacket& out, bool completed)
+    {
+        out.Initialize(SMSG_DUEL_COMPLETE, 1);
+
+        // Reader sub_6D3E7C consumes exactly one MSB-first completion bit.
+        out.WriteBit(completed);
+        out.FlushBits();
+    }
+
+    inline void BuildCountdown(WorldPacket& out, uint32 milliseconds)
+    {
+        out.Initialize(SMSG_DUEL_COUNTDOWN, sizeof(milliseconds));
+
+        // Reader sub_6D9F28 consumes one uint32; terminal sub_9BFFD4
+        // divides it by 1000 before updating the duel countdown UI.
+        out << milliseconds;
+    }
+
+    inline bool BuildWinner(WorldPacket& out, bool retreat,
+        std::string const& winnerName, uint32 winnerRealmAddress,
+        std::string const& loserName, uint32 loserRealmAddress)
+    {
+        if (winnerName.size() > 63 || loserName.size() > 63)
+            return false;
+
+        out.Initialize(SMSG_DUEL_WINNER,
+            2 + 2 * sizeof(uint32) + winnerName.size() + loserName.size());
+
+        // Reader sub_6CFDCC consumes the outcome followed by two six-bit
+        // lengths. Its realm-address fields are crossed around the names;
+        // terminal sub_9C0069 pairs them back as winner then loser.
+        out.WriteBit(retreat);
+        out.WriteBits(uint32(winnerName.size()), 6);
+        out.WriteBits(uint32(loserName.size()), 6);
+        out.FlushBits();
+
+        out << loserRealmAddress;
+        out.append(winnerName.c_str(), winnerName.size());
+        out << winnerRealmAddress;
+        out.append(loserName.c_str(), loserName.size());
+        return true;
+    }
+}
+
+namespace MopMirrorTimerPackets
+{
+    inline void BuildStart(WorldPacket& out, uint32 type, uint32 maxValue,
+        uint32 currentValue, int32 regeneration, uint32 spellId, bool paused)
+    {
+        out.Initialize(SMSG_START_MIRROR_TIMER, 21);
+
+        // Wow.exe 18414 reader sub_6F16F9 consumes five uint32 values in
+        // max/spell/current/regen/type order, then one MSB-first pause bit.
+        out << maxValue << spellId << currentValue << uint32(regeneration) << type;
+        out.WriteBit(paused);
+        out.FlushBits();
+    }
+
+    inline void BuildStop(WorldPacket& out, uint32 type)
+    {
+        // Wow.exe 18414 reader sub_6D9F28 consumes only the timer type.
+        out.Initialize(SMSG_STOP_MIRROR_TIMER, sizeof(type));
+        out << type;
+    }
+}
+
 namespace MopAreaTriggerPackets
 {
     struct Request
@@ -749,6 +937,16 @@ namespace MopAreaTriggerPackets
         // ERR_CORPSE_IS_NOT_IN_INSTANCE.
         out.Initialize(SMSG_AREA_TRIGGER_NO_CORPSE, 0);
     }
+
+    inline void BuildExplorationExperience(WorldPacket& out, uint32 areaId,
+        uint32 experience)
+    {
+        out.Initialize(SMSG_EXPLORATION_EXPERIENCE, 8);
+
+        // Wow.exe 18414 reader sub_6BB9C1 consumes the area-table key first;
+        // terminal sub_7B1384 then displays the second uint32 as awarded XP.
+        out << areaId << experience;
+    }
 }
 
 namespace MopQuestPackets

src/game/Object/PlayerCombo.cpp

@@ -88,9 +88,8 @@ void Player::SendComboPoints()
     Unit* combotarget = sObjectAccessor.GetUnit(*this, m_comboTargetGuid);
     if (combotarget)
     {
-        WorldPacket data(SMSG_UPDATE_COMBO_POINTS, combotarget->GetPackGUID().size() + 1);
-        data << combotarget->GetPackGUID();
-        data << uint8(m_comboPoints);
+        WorldPacket data;
+        MopComboPointPackets::BuildUpdate(data, combotarget->GetObjectGuid(), uint8(m_comboPoints));
         GetSession()->SendPacket(&data);
     }
     /*else