QueryHandler.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
#include "Common.h"
#include "Config.h"
#include "DatabaseEnv.h"
#include "Language.h"
#include "Log.h"
#include "MapManager.h"
#include "NPCHandler.h"
#include "ObjectMgr.h"
#include "Opcodes.h"
#include "Pet.h"
#include "Player.h"
#include "UpdateMask.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
 
void WorldSession::SendNameQueryOpcode(ObjectGuid guid)
{
    ObjectGuid guid2 = 0;
    ObjectGuid guid3 = guid;
 
    Player* player = ObjectAccessor::FindPlayer(guid);
    CharacterNameData const* nameData = sWorld->GetCharacterNameData(GUID_LOPART(guid));
 
    WorldPacket data(SMSG_QUERY_PLAYER_NAME_RESPONSE, 500);
    data.WriteGuidMask(guid, 3, 6, 7, 2, 5, 4, 0, 1);
 
    data.WriteGuidBytes(guid, 5, 4, 7, 6, 1, 2);
 
    data << uint8(!nameData);
 
    if (nameData)
    {
        data << uint32(nameData->m_realm); // realmIdSecond
        data << uint32(GetAccountId()); // AccID
        data << uint8(nameData->m_class);
        data << uint8(nameData->m_race);
        data << uint8(nameData->m_level);
        data << uint8(nameData->m_gender);
    }
 
    data.WriteGuidBytes(guid, 0, 3);
 
    if (!nameData)
    {
        SendPacket(&data);
        return;
    }
 
    data.WriteBit(guid2[2]);
    data.WriteBit(guid2[7]);
    data.WriteBit(guid3[7]);
    data.WriteBit(guid3[2]);
    data.WriteBit(guid3[0]);
    data.WriteBit(0); //isDeleted ? Wod ?
    data.WriteBit(guid2[4]);
    data.WriteBit(guid3[5]);
    data.WriteBit(guid2[1]);
    data.WriteBit(guid2[3]);
    data.WriteBit(guid2[0]);
 
    DeclinedName const* names = (player ? player->GetDeclinedNames() : NULL);
    for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
        data.WriteBits(names ? names->name[i].size() : 0, 7);
 
    data.WriteBit(guid3[6]);
    data.WriteBit(guid3[3]);
    data.WriteBit(guid2[5]);
    data.WriteBit(guid3[1]);
    data.WriteBit(guid3[4]);
    data.WriteBits(nameData->m_name.size(), 6);
    data.WriteBit(guid2[6]);
 
    data.FlushBits();
 
    data.WriteByteSeq(guid3[6]);
    data.WriteByteSeq(guid3[0]);
    data.WriteString(nameData->m_name);
    data.WriteByteSeq(guid2[5]);
    data.WriteByteSeq(guid2[2]);
    data.WriteByteSeq(guid3[3]);
    data.WriteByteSeq(guid2[4]);
    data.WriteByteSeq(guid2[3]);
    data.WriteByteSeq(guid3[4]);
    data.WriteByteSeq(guid3[2]);
    data.WriteByteSeq(guid2[7]);
 
    if (names)
        for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
            data.WriteString(names->name[i]);
 
    data.WriteByteSeq(guid2[6]);
    data.WriteByteSeq(guid3[7]);
    data.WriteByteSeq(guid3[1]);
    data.WriteByteSeq(guid2[1]);
    data.WriteByteSeq(guid3[5]);
    data.WriteByteSeq(guid2[0]);
 
    SendPacket(&data);
}
 
void WorldSession::HandleNameQueryOpcode(WorldPacket& recvData)
{
    ObjectGuid guid;
 
    uint8 bit14, bit1C;
    uint32 unk, unk1;
 
    recvData.ReadGuidMask(guid, 4);
    bit14 = recvData.ReadBit();
    recvData.ReadGuidMask(guid, 6, 0, 7, 1);
    bit1C = recvData.ReadBit();
    recvData.ReadGuidMask(guid, 5, 2, 3);
 
    recvData.ReadGuidBytes(guid, 7, 5, 1, 2, 6, 3, 0, 4);
 
    // virtual and native realm Addresses
 
    if (bit14)
        recvData >> unk;
 
    if (bit1C)
        recvData >> unk1;
 
    // This is disable by default to prevent lots of console spam
    // SF_LOG_INFO("network", "HandleNameQueryOpcode %u", guid);
 
    SendNameQueryOpcode(guid);
}
 
void WorldSession::SendRealmNameQueryOpcode(uint32 realmId)
{
    RealmNameMap::const_iterator iter = realmNameStore.find(realmId);
 
    bool found = iter != realmNameStore.end();
    std::string realmName = found ? iter->second : "";
 
    WorldPacket data(SMSG_REALM_NAME_QUERY_RESPONSE);
    data << uint8(!found);
    data << uint32(realmId);
 
    if (found)
    {
        data.WriteBits(realmName.length(), 8);
        data.WriteBit(realmId == GetVirtualRealmID());
        data.WriteBits(realmName.length(), 8);
        data.FlushBits();
 
        data.WriteString(realmName);
        data.WriteString(realmName);
    }
 
    SendPacket(&data);
}
 
void WorldSession::HandleRealmNameQueryOpcode(WorldPacket& recvPacket)
{
    uint32 realmId;
    recvPacket >> realmId;
    SendRealmNameQueryOpcode(realmId);
}
 
void WorldSession::HandleQueryTimeOpcode(WorldPacket& /*recvData*/)
{
    SendQueryTimeResponse();
}
 
void WorldSession::SendQueryTimeResponse()
{
    WorldPacket data(SMSG_QUERY_TIME_RESPONSE, 4 + 4);
    data << uint32(time(NULL));
    data << uint32(sWorld->GetNextDailyQuestsResetTime() - time(NULL));
    SendPacket(&data);
}

void WorldSession::HandleCreatureQueryOpcode(WorldPacket& recvData)
{
    uint32 entry;
    recvData >> entry;
 
    WorldPacket data(SMSG_CREATURE_QUERY_RESPONSE, 500);
 
    CreatureTemplate const* info = sObjectMgr->GetCreatureTemplate(entry);
 
    data << uint32(entry);
    data.WriteBit(info != 0);                                    // Has data
 
    if (info)
    {
        std::string Name, SubName;
        Name = info->Name;
        SubName = info->SubName;
 
        int loc_idx = GetSessionDbLocaleIndex();
        if (loc_idx >= 0)
        {
            if (CreatureLocale const* cl = sObjectMgr->GetCreatureLocale(entry))
            {
                ObjectMgr::GetLocaleString(cl->Name, loc_idx, Name);
                ObjectMgr::GetLocaleString(cl->SubName, loc_idx, SubName);
            }
        }
 
        SF_LOG_DEBUG("network", "WORLD: CMSG_CREATURE_QUERY '%s' - Entry: %u.", info->Name.c_str(), entry);
 
        data.WriteBits(SubName.length() ? SubName.length() + 1 : 0, 11);
        data.WriteBits(MAX_CREATURE_QUEST_ITEMS, 22);        // Quest items
        data.WriteBits(0, 11);
 
        for (int i = 0; i < 8; i++)
        {
            if (i == 0)
                data.WriteBits(Name.length() + 1, 11);
            else
                data.WriteBits(0, 11);                       // Name2, ..., name8
        }
 
        data.WriteBit(info->RacialLeader);
        data.WriteBits(info->IconName.length() + 1, 6);
        data.FlushBits();
 
        data << uint32(info->KillCredit[0]);                  // New in 3.1, kill credit
        data << uint32(info->Modelid4);                       // Modelid4
        data << uint32(info->Modelid2);                       // Modelid2
        data << uint32(info->expansion);                      // Expansion Required
        data << uint32(info->type);                           // CreatureType.dbc
        data << float(info->ModHealth);                       // Hp modifier
        data << uint32(info->type_flags);                     // Flags
        data << uint32(info->type_flags2);                    // Flags2
        data << uint32(info->rank);                           // Creature Rank (elite, boss, etc)
        data << uint32(info->movementId);                     // CreatureMovementInfo.dbc
        data << Name;
 
        if (SubName != "")
            data << SubName;                                // Subname
 
        data << uint32(info->Modelid1);                       // Modelid1
        data << uint32(info->Modelid3);                       // Modelid3
 
        if (info->IconName != "")
            data << info->IconName;                           // "Directions" for guard, string for Icons 2.3.0
 
        for (uint32 i = 0; i < MAX_CREATURE_QUEST_ITEMS; ++i)
            data << uint32(info->questItems[i]);              // ItemId[6], quest drop
 
        data << uint32(info->KillCredit[1]);                  // New in 3.1, kill credit
        data << float(info->ModMana);                         // Mana modifier
        data << uint32(info->family);                         // CreatureFamily.dbc
 
        SF_LOG_DEBUG("network", "WORLD: Sent SMSG_CREATURE_QUERY_RESPONSE");
    }
    else
        SF_LOG_DEBUG("network", "WORLD: CMSG_CREATURE_QUERY - NO CREATURE INFO! (ENTRY: %u)", entry);
 
    SendPacket(&data);
}

void WorldSession::HandleGameObjectQueryOpcode(WorldPacket& recvData)
{
    uint32 entry;
    ObjectGuid guid;
 
    recvData >> entry;
 
    recvData.ReadGuidMask(guid, 5, 3, 6, 2, 7, 1, 0, 4);
    recvData.ReadGuidBytes(guid, 1, 5, 3, 4, 6, 2, 7, 0);
 
    const GameObjectTemplate* info = sObjectMgr->GetGameObjectTemplate(entry);
 
    WorldPacket data(SMSG_GAMEOBJECT_QUERY_RESPONSE, 150);
    data.WriteBit(info != NULL);
    data << uint32(entry);
 
    size_t pos = data.wpos();
    data << uint32(0);
 
    if (info)
    {
        std::string Name;
        std::string IconName;
        std::string CastBarCaption;
 
        Name = info->name;
        IconName = info->IconName;
        CastBarCaption = info->castBarCaption;
 
        int loc_idx = GetSessionDbLocaleIndex();
        if (loc_idx >= 0)
        {
            if (GameObjectLocale const* gl = sObjectMgr->GetGameObjectLocale(entry))
            {
                ObjectMgr::GetLocaleString(gl->Name, loc_idx, Name);
                ObjectMgr::GetLocaleString(gl->CastBarCaption, loc_idx, CastBarCaption);
            }
        }
 
        SF_LOG_DEBUG("network", "WORLD: CMSG_GAMEOBJECT_QUERY '%s' - Entry: %u. ", info->name.c_str(), entry);
 
        data << uint32(info->type);
        data << uint32(info->displayId);
        data << Name;
        data << uint8(0) << uint8(0) << uint8(0);           // name2, name3, name4
        data << IconName;                                   // 2.0.3, string. Icon name to use instead of default icon for go's (ex: "Attack" makes sword)
        data << CastBarCaption;                             // 2.0.3, string. Text will appear in Cast Bar when using GO (ex: "Collecting")
        data << info->unk1;                                 // 2.0.3, string
 
        data.append(info->raw.data, MAX_GAMEOBJECT_DATA);
        data << float(info->size);                          // go size
 
        data << uint8(MAX_GAMEOBJECT_QUEST_ITEMS);
 
        for (uint32 i = 0; i < MAX_GAMEOBJECT_QUEST_ITEMS; ++i)
            data << uint32(info->questItems[i]);            // itemId[6], quest drop
 
        data << int32(info->unkInt32);                      // 4.x, unknown
 
        data.put(pos, uint32(data.wpos() - (pos + 4)));
        SF_LOG_DEBUG("network", "WORLD: Sent SMSG_GAMEOBJECT_QUERY_RESPONSE");
    }
    else
    {
        SF_LOG_DEBUG("network", "WORLD: CMSG_GAMEOBJECT_QUERY - Missing gameobject info for (GUID: %u, ENTRY: %u)",
            GUID_LOPART((uint64)guid), entry);
        SF_LOG_DEBUG("network", "WORLD: Sent SMSG_GAMEOBJECT_QUERY_RESPONSE");
    }
 
    SendPacket(&data);
}
 
void WorldSession::HandleCorpseQueryOpcode(WorldPacket& /*recvData*/)
{
    SF_LOG_DEBUG("network", "WORLD: Received CMSG_CORPSE_QUERY");
 
    Corpse* corpse = GetPlayer()->GetCorpse();
 
    if (!corpse)
    {
        WorldPacket data(SMSG_CORPSE_QUERY, 1);
        data.WriteBits(0, 9); // Not found + guid stream
        for (int i = 0; i < 5; i++)
            data << uint32(0);
        SendPacket(&data);
        return;
    }
 
    uint32 mapId = corpse->GetMapId();
    float x = corpse->GetPositionX();
    float y = corpse->GetPositionY();
    float z = corpse->GetPositionZ();
    uint32 corpseMapId = mapId;
 
    // if corpse at different map
    if (mapId != _player->GetMapId())
    {
        // search entrance map for proper show entrance
        if (MapEntry const* corpseMapEntry = sMapStore.LookupEntry(mapId))
        {
            if (corpseMapEntry->IsInstance() && corpseMapEntry->entrance_map >= 0)
            {
                // if corpse map have entrance
                if (Map const* entranceMap = sMapMgr->CreateBaseMap(corpseMapEntry->entrance_map))
                {
                    mapId = corpseMapEntry->entrance_map;
                    x = corpseMapEntry->entrance_x;
                    y = corpseMapEntry->entrance_y;
                    z = entranceMap->GetHeight(GetPlayer()->GetPhaseMask(), x, y, MAX_HEIGHT);
                }
            }
        }
    }
 
    _player->SendCorpseReclaimDelay();
 
    ObjectGuid corpseGuid = corpse->GetGUID();
 
    WorldPacket data(SMSG_CORPSE_QUERY, 9 + 1 + (4 * 5));
    data.WriteGuidMask(corpseGuid, 0, 3, 2);
    data.WriteBit(1); // Corpse Found
    data.WriteGuidMask(corpseGuid, 5, 4, 1, 7, 6);
 
    data.WriteGuidBytes(corpseGuid, 5);
    data << float(z);
    data.WriteGuidBytes(corpseGuid, 1);
    data << uint32(corpseMapId);
    data.WriteGuidBytes(corpseGuid, 6, 4);
    data << float(x);
    data.WriteGuidBytes(corpseGuid, 3, 7, 2, 0);
    data << int32(mapId);
    data << float(y);
    SendPacket(&data);
}
 
void WorldSession::HandleNpcTextQueryOpcode(WorldPacket& recvData)
{
    uint32 textID;
    ObjectGuid guid;
 
    recvData >> textID;
    recvData.ReadGuidMask(guid, 4, 5, 1, 7, 0, 2, 6, 3);
    recvData.ReadGuidBytes(guid, 4, 0, 2, 5, 1, 7, 3, 7);
 
    SF_LOG_ERROR("network", "WORLD: CMSG_NPC_TEXT_QUERY ID '%u', %lu", textID, uint64(guid));
    //SendBroadcastText(textID);
 
    GossipText const* pGossip = sObjectMgr->GetGossipText(textID);
 
    // WNPC collumns should be in this buffer
    ByteBuffer buf;
    if (!pGossip)
    {
        buf << uint32(1);
        for (uint8 i = 0; i < 7; i++)
            buf << uint32(0);
 
        buf << uint32(1);
 
        for (uint8 i = 0; i < 7; i++)
            buf << uint32(0);
 
        buf << std::string("Help help! I'm being repressed!");
    }
    else
    {
        buf << uint32(1);
        for (uint8 i = 0; i < 7; i++)
            buf << uint32(0);
 
        buf << uint32(textID);// ADB cache entry
        for (uint8 i = 0; i < 7; i++)
            buf << uint32(0); // ADB cache entry
 
        buf << std::string(pGossip->Options[0].Text_0);
    }
 
    WorldPacket data(SMSG_NPC_TEXT_UPDATE, 1 + 4 + buf.size());
    data << uint32(textID);
    data << uint32(buf.size());// sizeofbuf
 
    data.append(buf); // data collumns to write to cache
    data.WriteBit(1); // write record to WNPC cache
    data.FlushBits();
 
    SendPacket(&data);
 
    SF_LOG_DEBUG("network", "WORLD: Sent SMSG_NPC_TEXT_UPDATE");
}

void WorldSession::HandlePageTextQueryOpcode(WorldPacket& recvData)
{
    SF_LOG_DEBUG("network", "WORLD: Received CMSG_PAGE_TEXT_QUERY");
 
    uint32 pageID;
    ObjectGuid guid;
 
    recvData >> pageID;
 
    recvData.ReadGuidMask(guid, 2, 1, 3, 7, 6, 4, 0, 5);
    recvData.ReadGuidBytes(guid, 1, 6, 3, 5, 1, 7, 4, 2);
 
    while (pageID)
    {
        WorldPacket data(SMSG_PAGE_TEXT_QUERY_RESPONSE);
 
        PageText const* pageText = sObjectMgr->GetPageText(pageID);
 
        data.WriteBit(pageText != NULL);
 
        if (!pageText)
        {
            data.FlushBits();
            data << uint32(0);
        }
        else
        {
            std::string Text = pageText->Text;
 
            int loc_idx = GetSessionDbLocaleIndex();
            if (loc_idx >= 0)
                if (PageTextLocale const* player = sObjectMgr->GetPageTextLocale(pageID))
                    ObjectMgr::GetLocaleString(player->Text, loc_idx, Text);
 
            data.WriteBits(Text.size(), 12);
 
            data.FlushBits();
 
            data << uint32(pageText->NextPage);
            data << uint32(pageID);
 
            data.WriteString(Text);
            data << uint32(pageID);
        }
 
        pageID = pageText ? pageText->NextPage : 0;
 
        SendPacket(&data);
 
        SF_LOG_DEBUG("network", "WORLD: Sent SMSG_PAGE_TEXT_QUERY_RESPONSE");
    }
}
 
void WorldSession::HandleCorpseMapPositionQuery(WorldPacket& recvData)
{
    SF_LOG_DEBUG("network", "WORLD: Recv CMSG_CORPSE_MAP_POSITION_QUERY");
 
    ObjectGuid corpseGuid;
    recvData.ReadGuidMask(corpseGuid, 7, 6, 3, 0, 4, 1, 5, 2);
    recvData.ReadGuidBytes(corpseGuid, 1, 6, 0, 5, 3, 2, 4, 7);
 
    WorldPacket data(SMSG_CORPSE_MAP_POSITION_QUERY_RESPONSE, 4 + 4 + 4 + 4);
    data << float(0);
    data << float(0);
    data << float(0);
    data << float(0);
    SendPacket(&data);
}
 
void WorldSession::HandleQuestNPCQuery(WorldPacket& recvData)
{
    std::map<uint32, std::vector<uint32>> quests;
    for (int i = 0; i < 50; ++i)
    {
        uint32 questId;
        recvData >> questId;

        if (sObjectMgr->GetQuestTemplate(questId) && _player->GetQuestStatus(questId) == QUEST_STATUS_COMPLETE)
        {
            auto creatures = sObjectMgr->GetCreatureQuestInvolvedRelationReverseBounds(questId);
            for (auto it = creatures.first; it != creatures.second; ++it)
                quests[questId].push_back(it->second);
 
            auto gos = sObjectMgr->GetGOQuestInvolvedRelationReverseBounds(questId);
            for (auto it = gos.first; it != gos.second; ++it)
                quests[questId].push_back(it->second | 0x80000000); // GO mask
        }
    }
 
    uint32 count;
    recvData >> count;
 
    WorldPacket data(SMSG_QUEST_NPC_QUERY_RESPONSE, 3 + count * 14);
    data.WriteBits(quests.size(), 21);
 
    for (auto it = quests.begin(); it != quests.end(); ++it)
        data.WriteBits(it->second.size(), 22);
 
    data.FlushBits();
 
    for (auto it = quests.begin(); it != quests.end(); ++it)
    {
        data << uint32(it->first);
        for (const auto& entry : it->second)
            data << uint32(entry);
    }
 
    SendPacket(&data);
}
 
void WorldSession::HandleQuestPOIQuery(WorldPacket& recvData)
{
    uint32 count = recvData.ReadBits(22);
 
    if (count >= MAX_QUEST_LOG_SIZE)
    {
        recvData.rfinish();
        return;
    }
 
    ByteBuffer poiData;
 
    WorldPacket data(SMSG_QUEST_POI_QUERY_RESPONSE, 4 + (4 + 4) * count);
    data.WriteBits(count, 20);
 
    for (uint32 i = 0; i < count; ++i)
    {
        uint32 questId;
        recvData >> questId;
 
        bool questOk = false;
 
        uint16 questSlot = _player->FindQuestSlot(questId);
 
        if (questSlot != MAX_QUEST_LOG_SIZE)
            questOk = _player->GetQuestSlotQuestId(questSlot) == questId;
 
        if (questOk)
        {
            QuestPOIVector const* POI = sObjectMgr->GetQuestPOIVector(questId);
 
            if (POI)
            {
                data.WriteBits(POI->size(), 18);                // POI count bits
 
                for (QuestPOIVector::const_iterator itr = POI->begin(); itr != POI->end(); ++itr)
                {
                    data.WriteBits(itr->points.size(), 21);     // POI points count bits
 
                    poiData << uint32(itr->FloorId);            // floor id
 
                    for (std::vector<QuestPOIPoint>::const_iterator itr2 = itr->points.begin(); itr2 != itr->points.end(); ++itr2)
                    {
                        poiData << int32(itr2->x);              // POI point x
                        poiData << int32(itr2->y);              // POI point y
                    }
 
                    poiData << int32(itr->ObjectiveIndex);      // objective index
                    poiData << uint32(itr->Id);                 // POI index
                    poiData << uint32(0);                       // unknown (new 5.x.x)
                    poiData << uint32(0);                       // unknown (new 5.x.x)
                    poiData << uint32(itr->MapId);              // mapid
                    poiData << uint32(itr->points.size());      // POI points count
                    poiData << uint32(itr->AreaId);             // areaid
                    poiData << uint32(0);                       // unknown (new 5.x.x)
                    poiData << uint32(itr->Unk4);               // unknown
                    poiData << uint32(itr->Unk3);               // unknown
                }
 
                poiData << uint32(questId);                     // quest ID
                poiData << uint32(POI->size());                 // POI count
            }
            else
            {
                poiData << uint32(questId);
                poiData << uint32(0);
 
                data.WriteBits(0, 18);
            }
        }
        else
        {
            poiData << uint32(questId);
            poiData << uint32(0);
 
            data.WriteBits(0, 18);
        }
    }
 
    poiData << uint32(count);
 
    data.FlushBits();
    data.append(poiData);
 
    SendPacket(&data);
}