PetHandler.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 "CreatureAI.h"
#include "Group.h"
#include "Log.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "Opcodes.h"
#include "Pet.h"
#include "Player.h"
#include "Spell.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "Util.h"
#include "Vehicle.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
 
namespace
{
struct PetGuidRequest
{
    ObjectGuid guid;
};
 
struct PetActionRequest
{
    ObjectGuid petGuid;
    ObjectGuid targetGuid;
    uint32 action;
    float x;
    float y;
    float z;
};
 
struct PetNameQueryRequest
{
    ObjectGuid petGuid;
    ObjectGuid petNumber;
};
 
struct PetSetActionRequest
{
    ObjectGuid petGuid;
    uint32 action;
    uint32 index;
};
 
struct PetRenameRequest
{
    DeclinedName declinedName;
    std::string name;
    uint32 petNumber;
    bool hasDeclinedNames;
};
 
struct PetSpellAutocastRequest
{
    ObjectGuid petGuid;
    uint32 spellId;
    bool state;
};
 
struct PetCastSpellRequest
{
    ObjectGuid targetGuid;
    ObjectGuid transportDstGuid;
    ObjectGuid itemGuid;
    ObjectGuid transportSrcGuid;
    ObjectGuid petGuid;
    uint32 spellId;
    uint32 targetFlags;
    WorldLocation dstLoc;
    WorldLocation srcLoc;
    float missileSpeed;
    float elevation;
    uint8 castCount;
    uint8 castFlags;
};
 
struct SetPetSpecializationRequest
{
    ObjectGuid petGuid;
    uint32 talentTab;
};
 
PetGuidRequest ReadDismissCritterRequest(WorldPacket& recvData)
{
    PetGuidRequest request;
    recvData.ReadGuidMask(request.guid, 4, 6, 7, 5, 1, 0, 2, 3);
    recvData.ReadGuidBytes(request.guid, 2, 4, 5, 0, 1, 7, 3, 6);
    return request;
}
 
PetActionRequest ReadPetActionRequest(WorldPacket& recvData)
{
    PetActionRequest request;
    recvData >> request.action;
 
    // Position
    recvData >> request.y >> request.z >> request.x;
 
    request.petGuid[1] = recvData.ReadBit();
    request.petGuid[0] = recvData.ReadBit();
    request.petGuid[6] = recvData.ReadBit();
    request.petGuid[7] = recvData.ReadBit();
    request.petGuid[5] = recvData.ReadBit();
    request.targetGuid[7] = recvData.ReadBit();
    request.petGuid[2] = recvData.ReadBit();
    request.petGuid[3] = recvData.ReadBit();
    request.targetGuid[6] = recvData.ReadBit();
    request.targetGuid[3] = recvData.ReadBit();
    request.targetGuid[0] = recvData.ReadBit();
    request.targetGuid[2] = recvData.ReadBit();
    request.targetGuid[5] = recvData.ReadBit();
    request.petGuid[4] = recvData.ReadBit();
    request.targetGuid[4] = recvData.ReadBit();
    request.targetGuid[1] = recvData.ReadBit();
 
    recvData.ReadByteSeq(request.petGuid[7]);
    recvData.ReadByteSeq(request.petGuid[6]);
    recvData.ReadByteSeq(request.petGuid[1]);
    recvData.ReadByteSeq(request.petGuid[2]);
    recvData.ReadByteSeq(request.petGuid[5]);
    recvData.ReadByteSeq(request.petGuid[4]);
    recvData.ReadByteSeq(request.targetGuid[5]);
    recvData.ReadByteSeq(request.petGuid[3]);
    recvData.ReadByteSeq(request.targetGuid[0]);
    recvData.ReadByteSeq(request.targetGuid[1]);
    recvData.ReadByteSeq(request.targetGuid[7]);
    recvData.ReadByteSeq(request.targetGuid[4]);
    recvData.ReadByteSeq(request.targetGuid[6]);
    recvData.ReadByteSeq(request.targetGuid[2]);
    recvData.ReadByteSeq(request.targetGuid[3]);
    recvData.ReadByteSeq(request.petGuid[0]);
 
    return request;
}
 
PetGuidRequest ReadPetStopAttackRequest(WorldPacket& recvData)
{
    PetGuidRequest request;
 
    request.guid[7] = recvData.ReadBit();
    request.guid[5] = recvData.ReadBit();
    request.guid[1] = recvData.ReadBit();
    request.guid[6] = recvData.ReadBit();
    request.guid[0] = recvData.ReadBit();
    request.guid[2] = recvData.ReadBit();
    request.guid[4] = recvData.ReadBit();
    request.guid[3] = recvData.ReadBit();
 
    recvData.ReadByteSeq(request.guid[2]);
    recvData.ReadByteSeq(request.guid[5]);
    recvData.ReadByteSeq(request.guid[0]);
    recvData.ReadByteSeq(request.guid[4]);
    recvData.ReadByteSeq(request.guid[1]);
    recvData.ReadByteSeq(request.guid[7]);
    recvData.ReadByteSeq(request.guid[6]);
    recvData.ReadByteSeq(request.guid[3]);
 
    return request;
}
 
PetNameQueryRequest ReadPetNameQueryRequest(WorldPacket& recvData)
{
    PetNameQueryRequest request;
 
    request.petNumber[0] = recvData.ReadBit();
    request.petNumber[5] = recvData.ReadBit();
    request.petGuid[1] = recvData.ReadBit();
    request.petGuid[7] = recvData.ReadBit();
    request.petNumber[7] = recvData.ReadBit();
    request.petGuid[6] = recvData.ReadBit();
    request.petGuid[4] = recvData.ReadBit();
    request.petGuid[5] = recvData.ReadBit();
    request.petGuid[0] = recvData.ReadBit();
    request.petNumber[3] = recvData.ReadBit();
    request.petNumber[6] = recvData.ReadBit();
    request.petNumber[2] = recvData.ReadBit();
    request.petGuid[3] = recvData.ReadBit();
    request.petGuid[2] = recvData.ReadBit();
    request.petNumber[1] = recvData.ReadBit();
    request.petNumber[4] = recvData.ReadBit();
 
    recvData.ReadByteSeq(request.petNumber[2]);
    recvData.ReadByteSeq(request.petNumber[1]);
    recvData.ReadByteSeq(request.petNumber[0]);
    recvData.ReadByteSeq(request.petNumber[7]);
    recvData.ReadByteSeq(request.petGuid[5]);
    recvData.ReadByteSeq(request.petGuid[0]);
    recvData.ReadByteSeq(request.petNumber[6]);
    recvData.ReadByteSeq(request.petGuid[4]);
    recvData.ReadByteSeq(request.petNumber[5]);
    recvData.ReadByteSeq(request.petGuid[2]);
    recvData.ReadByteSeq(request.petGuid[6]);
    recvData.ReadByteSeq(request.petNumber[3]);
    recvData.ReadByteSeq(request.petGuid[3]);
    recvData.ReadByteSeq(request.petNumber[4]);
    recvData.ReadByteSeq(request.petGuid[1]);
    recvData.ReadByteSeq(request.petGuid[7]);
 
    return request;
}
 
PetSetActionRequest ReadPetSetActionRequest(WorldPacket& recvData)
{
    PetSetActionRequest request;
    recvData >> request.index;
    recvData >> request.action;
    recvData.ReadGuidMask(request.petGuid, 1, 0, 5, 3, 2, 7, 6, 4);
    recvData.ReadGuidBytes(request.petGuid, 5, 6, 7, 3, 2, 1, 4, 0);
    return request;
}
 
PetRenameRequest ReadPetRenameRequest(WorldPacket& recvData)
{
    PetRenameRequest request;
    uint8 declinedNamesLength[MAX_DECLINED_NAME_CASES];
 
    recvData >> request.petNumber;
    bool hasName = !recvData.ReadBit();
    request.hasDeclinedNames = recvData.ReadBit();
    if (request.hasDeclinedNames)
        for (int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
            declinedNamesLength[i] = recvData.ReadBits(7);
    if (hasName)
        request.name = recvData.ReadString(recvData.ReadBits(8));
    if (request.hasDeclinedNames)
        for (int i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
            request.declinedName.name[i] = recvData.ReadString(declinedNamesLength[i]);
 
    return request;
}
 
PetGuidRequest ReadPetAbandonRequest(WorldPacket& recvData)
{
    PetGuidRequest request;
 
    request.guid[7] = recvData.ReadBit();
    request.guid[3] = recvData.ReadBit();
    request.guid[4] = recvData.ReadBit();
    request.guid[2] = recvData.ReadBit();
    request.guid[5] = recvData.ReadBit();
    request.guid[6] = recvData.ReadBit();
    request.guid[1] = recvData.ReadBit();
    request.guid[0] = recvData.ReadBit();
 
    recvData.ReadByteSeq(request.guid[0]);
    recvData.ReadByteSeq(request.guid[2]);
    recvData.ReadByteSeq(request.guid[5]);
    recvData.ReadByteSeq(request.guid[6]);
    recvData.ReadByteSeq(request.guid[7]);
    recvData.ReadByteSeq(request.guid[1]);
    recvData.ReadByteSeq(request.guid[4]);
    recvData.ReadByteSeq(request.guid[3]);
 
    return request;
}
 
PetSpellAutocastRequest ReadPetSpellAutocastRequest(WorldPacket& recvPacket)
{
    PetSpellAutocastRequest request;
 
    recvPacket >> request.spellId;
    recvPacket.ReadGuidMask(request.petGuid, 0, 4, 2, 6, 1, 5, 3, 7);
    request.state = recvPacket.ReadBit();
    recvPacket.ReadGuidBytes(request.petGuid, 5, 0, 4, 1, 7, 2, 3, 6);
 
    return request;
}
 
PetCastSpellRequest ReadPetCastSpellRequest(WorldPacket& recvPacket)
{
    PetCastSpellRequest request = PetCastSpellRequest();
    ObjectGuid transportGuid;
    ObjectGuid movementGuid;
 
    bool hasUnkMovementField = false;
    bool hasTransport = false;
    bool hasTransportTime2 = false;
    bool hasTransportTime3 = false;
    bool hasMovementFlags = false;
    bool hasMovementFlags2 = false;
    bool hasFallDirection = false;
    bool hasFallData = false;
    bool hasPitch = false;
    bool hasOrientation = false;
    bool hasSplineElevation = false;
    bool hasTimestamp = false;
 
    uint32 targetStrLength = 0;
    uint32 movementForcesCount = 0;
    uint32 archeologyCount = 0;
 
    bool hasDestLocation = recvPacket.ReadBit();
    request.petGuid[7] = recvPacket.ReadBit();
    bool hasMissileSpeed = !recvPacket.ReadBit();
    bool hasSrcLocation = recvPacket.ReadBit();
    request.petGuid[1] = recvPacket.ReadBit();
    archeologyCount = recvPacket.ReadBits(2);
    bool hasTargetMask = !recvPacket.ReadBit();
    request.petGuid[4] = recvPacket.ReadBit();
    recvPacket.ReadBit();
    request.petGuid[6] = recvPacket.ReadBit();
    bool hasTargetString = !recvPacket.ReadBit();
    recvPacket.ReadBit();
    bool hasMovement = recvPacket.ReadBit();
    bool hasCastFlags = !recvPacket.ReadBit();
    bool hasSpellId = !recvPacket.ReadBit();
    request.petGuid[0] = recvPacket.ReadBit();
    request.petGuid[5] = recvPacket.ReadBit();
    request.petGuid[2] = recvPacket.ReadBit();
    for (uint32 i = 0; i < archeologyCount; ++i)
        recvPacket.ReadBits(2);                            // archeologyType
    request.petGuid[3] = recvPacket.ReadBit();
    bool hasGlyphIndex = !recvPacket.ReadBit();
    bool hasCastCount = !recvPacket.ReadBit();
    bool hasElevation = !recvPacket.ReadBit();
 
    if (hasMovement)
    {
        hasOrientation = !recvPacket.ReadBit();
        hasSplineElevation = !recvPacket.ReadBit();
        recvPacket.ReadBit();
        movementGuid[5] = recvPacket.ReadBit();
        movementGuid[7] = recvPacket.ReadBit();
        hasMovementFlags2 = !recvPacket.ReadBit();
        hasTimestamp = !recvPacket.ReadBit();
        hasFallData = recvPacket.ReadBit();
        hasMovementFlags = !recvPacket.ReadBit();
        hasUnkMovementField = !recvPacket.ReadBit();
 
        if (hasMovementFlags)
            recvPacket.ReadBits(30);                       // Movement Flags
 
        recvPacket.ReadBit();
        movementGuid[6] = recvPacket.ReadBit();
        hasTransport = recvPacket.ReadBit();
        movementGuid[0] = recvPacket.ReadBit();
        movementForcesCount = recvPacket.ReadBits(22);
 
        if (hasTransport)
        {
            hasTransportTime2 = recvPacket.ReadBit();
            hasTransportTime3 = recvPacket.ReadBit();
            transportGuid[5] = recvPacket.ReadBit();
            transportGuid[6] = recvPacket.ReadBit();
            transportGuid[4] = recvPacket.ReadBit();
            transportGuid[0] = recvPacket.ReadBit();
            transportGuid[1] = recvPacket.ReadBit();
            transportGuid[2] = recvPacket.ReadBit();
            transportGuid[7] = recvPacket.ReadBit();
            transportGuid[3] = recvPacket.ReadBit();
        }
 
        movementGuid[1] = recvPacket.ReadBit();
 
        if (hasMovementFlags2)
            recvPacket.ReadBits(13);                       // Movement Flags 2
 
        movementGuid[3] = recvPacket.ReadBit();
        movementGuid[2] = recvPacket.ReadBit();
        recvPacket.ReadBit();
        hasPitch = !recvPacket.ReadBit();
        movementGuid[4] = recvPacket.ReadBit();
 
        if (hasFallData)
            hasFallDirection = recvPacket.ReadBit();
    }
 
    if (hasDestLocation)
        recvPacket.ReadGuidMask(request.transportDstGuid, 2, 0, 1, 4, 5, 6, 3, 7);
 
    if (hasCastFlags)
        request.castFlags = recvPacket.ReadBits(5);        // Cast Flags
 
    recvPacket.ReadGuidMask(request.itemGuid, 2, 4, 7, 0, 6, 1, 5, 3);
 
    if (hasTargetMask)
        request.targetFlags = recvPacket.ReadBits(20);     // Target Flags
 
    if (hasTargetString)
        targetStrLength = recvPacket.ReadBits(7);          // Target String
 
    if (hasSrcLocation)
        recvPacket.ReadGuidMask(request.transportSrcGuid, 2, 0, 3, 1, 6, 7, 4, 5);
 
    recvPacket.ReadGuidMask(request.targetGuid, 6, 0, 3, 4, 2, 1, 5, 7);
 
    recvPacket.ReadGuidBytes(request.petGuid, 2, 6, 3);
 
    for (uint32 i = 0; i < archeologyCount; ++i)
    {
        recvPacket.read_skip<uint32>();                    // unk1
        recvPacket.read_skip<uint32>();                    // unk2
    }
    recvPacket.ReadGuidBytes(request.petGuid, 1, 7, 0, 4, 5);
 
    if (hasDestLocation)
    {
        recvPacket.ReadByteSeq(request.transportDstGuid[4]);
        recvPacket.ReadByteSeq(request.transportDstGuid[1]);
        recvPacket.ReadByteSeq(request.transportDstGuid[7]);
        request.dstLoc.m_positionZ = recvPacket.read<float>(); // Position Z
        request.dstLoc.m_positionY = recvPacket.read<float>(); // Position Y
        recvPacket.ReadByteSeq(request.transportDstGuid[6]);
        recvPacket.ReadByteSeq(request.transportDstGuid[3]);
        request.dstLoc.m_positionX = recvPacket.read<float>(); // Position X
        recvPacket.ReadByteSeq(request.transportDstGuid[2]);
        recvPacket.ReadByteSeq(request.transportDstGuid[5]);
        recvPacket.ReadByteSeq(request.transportDstGuid[0]);
    }
 
    if (hasMovement)
    {
        if (hasPitch)
            recvPacket.read_skip<float>();                 // Pitch
 
        if (hasTransport)
        {
            if (hasTransportTime3)
                recvPacket.read_skip<int32>();             // Transport Time 3
 
            if (hasTransportTime2)
                recvPacket.read_skip<int32>();             // Transport Time 2
 
            recvPacket.read_skip<uint8>();                 // Transport Seat
            recvPacket.read_skip<float>();                 // Orientation
            recvPacket.read_skip<float>();                 // Position Z
            recvPacket.ReadByteSeq(transportGuid[2]);
            recvPacket.read_skip<int32>();                 // Transport Time
            recvPacket.ReadByteSeq(transportGuid[3]);
            recvPacket.read_skip<float>();                 // Position X
            recvPacket.ReadByteSeq(transportGuid[6]);
            recvPacket.ReadByteSeq(transportGuid[5]);
            recvPacket.ReadByteSeq(transportGuid[7]);
            recvPacket.ReadByteSeq(transportGuid[0]);
            recvPacket.read_skip<float>();                 // Position Y
            recvPacket.ReadByteSeq(transportGuid[4]);
            recvPacket.ReadByteSeq(transportGuid[1]);
        }
 
        if (hasUnkMovementField)
            recvPacket.read_skip<int32>();
 
        for (uint32 i = 0; i < movementForcesCount; ++i)
            recvPacket.read_skip<uint32>();                // Movement Forces
 
        recvPacket.ReadByteSeq(movementGuid[3]);
 
        if (hasOrientation)
            recvPacket.read_skip<float>();                 // Orientation
 
        recvPacket.ReadByteSeq(movementGuid[5]);
 
        if (hasFallData)
        {
            recvPacket.read_skip<float>();                 // Z Speed
 
            if (hasFallDirection)
            {
                recvPacket.read_skip<float>();             // CosAngle
                recvPacket.read_skip<float>();             // XY Speed
                recvPacket.read_skip<float>();             // SinAngle
            }
            recvPacket.read_skip<int32>();                 // FallTime
        }
 
        if (hasTimestamp)
            recvPacket.read_skip<int32>();                 // Timestamp
 
        recvPacket.ReadByteSeq(movementGuid[6]);
        recvPacket.read_skip<float>();                     // Position X
        recvPacket.ReadByteSeq(movementGuid[1]);
        recvPacket.read_skip<float>();                     // Position Z
        recvPacket.ReadByteSeq(movementGuid[2]);
        recvPacket.ReadByteSeq(movementGuid[7]);
        recvPacket.ReadByteSeq(movementGuid[0]);
        recvPacket.read_skip<float>();                     // Position Y
        recvPacket.ReadByteSeq(movementGuid[4]);
 
        if (hasSplineElevation)
            recvPacket.read_skip<float>();                 // Spline Elevation
    }
 
    if (hasSrcLocation)
    {
        recvPacket.ReadByteSeq(request.transportSrcGuid[3]);
        recvPacket.ReadByteSeq(request.transportSrcGuid[4]);
        recvPacket.ReadByteSeq(request.transportSrcGuid[2]);
        recvPacket.ReadByteSeq(request.transportSrcGuid[1]);
        recvPacket.ReadByteSeq(request.transportSrcGuid[0]);
        recvPacket.ReadByteSeq(request.transportSrcGuid[7]);
        request.srcLoc.m_positionZ = recvPacket.read<float>(); // Position Z
        recvPacket.ReadByteSeq(request.transportSrcGuid[6]);
        recvPacket.ReadByteSeq(request.transportSrcGuid[5]);
        request.srcLoc.m_positionX = recvPacket.read<float>(); // Position X
        request.srcLoc.m_positionY = recvPacket.read<float>(); // Position Y
    }
 
    if (hasMissileSpeed)
        request.missileSpeed = recvPacket.read<float>();   // missileSpeed
 
    recvPacket.ReadGuidBytes(request.itemGuid, 1, 2, 5, 7, 4, 6, 3, 0);
 
    recvPacket.ReadGuidBytes(request.targetGuid, 1, 5, 7, 3, 0, 2, 4, 6);
 
    if (hasElevation)
        request.elevation = recvPacket.read<float>();      // Elevation
 
    if (hasCastCount)
        request.castCount = recvPacket.read<uint8>();      // Cast Count
 
    if (hasTargetString)
        recvPacket.ReadString(targetStrLength);
 
    if (hasGlyphIndex)
        recvPacket.read_skip<int32>();                     // Glyph Index
 
    if (hasSpellId)
        request.spellId = recvPacket.read<uint32>();
 
    return request;
}
 
SetPetSpecializationRequest ReadSetPetSpecializationRequest(WorldPacket& recvData)
{
    SetPetSpecializationRequest request;
    recvData >> request.talentTab;
    recvData.ReadGuidMask(request.petGuid, 5, 7, 3, 0, 6, 4, 1, 2);
    recvData.ReadGuidBytes(request.petGuid, 7, 5, 4, 3, 0, 2, 6, 1);
    return request;
}
 
Unit* ValidatePetActionRequest(Player* player, PetActionRequest& request, uint8 flag, uint32 spellId)
{
    Unit* pet = ObjectAccessor::GetUnit(*player, request.petGuid);
    if (!pet)
    {
        SF_LOG_ERROR("network", "HandlePetAction: Pet (GUID: %u) doesn't exist for player %s (GUID: %u)", uint32(GUID_LOPART(request.petGuid)), player->GetName().c_str(), GUID_LOPART(player->GetGUID()));
        return NULL;
    }
 
    if (pet != player->GetFirstControlled())
    {
        SF_LOG_ERROR("network", "HandlePetAction: Pet (GUID: %u) does not belong to player %s (GUID: %u)", uint32(GUID_LOPART(request.petGuid)), player->GetName().c_str(), GUID_LOPART(player->GetGUID()));
        return NULL;
    }
 
    if (!pet->IsAlive())
    {
        SpellInfo const* spell = (flag == ACT_ENABLED || flag == ACT_PASSIVE) ? sSpellMgr->GetSpellInfo(spellId) : NULL;
        if (!spell)
            return NULL;
        if (!(spell->Attributes & SPELL_ATTR0_CASTABLE_WHILE_DEAD))
            return NULL;
    }

    if (pet->GetTypeId() == TypeID::TYPEID_PLAYER && !(flag == ACT_COMMAND && spellId == COMMAND_ATTACK))
        return NULL;
 
    return pet;
}
 
Unit* ValidatePetStopAttackRequest(Player* player, PetGuidRequest& request)
{
    Unit* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*player, request.guid);
    if (!pet)
    {
        SF_LOG_ERROR("network", "HandlePetStopAttack: Pet %u does not exist", uint32(GUID_LOPART(request.guid)));
        return NULL;
    }
 
    if (pet != player->GetPet() && pet != player->GetCharm())
    {
        SF_LOG_ERROR("network", "HandlePetStopAttack: Pet GUID %u isn't a pet or charmed creature of player %s",
            uint32(GUID_LOPART(request.guid)), player->GetName().c_str());
        return NULL;
    }
 
    if (!pet->IsAlive())
        return NULL;
 
    return pet;
}
 
Unit* ValidatePetSetActionRequest(Player* player, PetSetActionRequest& request, CharmInfo*& charmInfo)
{
    charmInfo = NULL;
 
    Unit* pet = ObjectAccessor::GetUnit(*player, request.petGuid);
    if (!pet || pet != player->GetFirstControlled())
    {
        SF_LOG_ERROR("network", "HandlePetSetAction: Unknown pet (GUID: %u) or pet owner (GUID: %u)", GUID_LOPART(request.petGuid), player->GetGUIDLow());
        return NULL;
    }
 
    charmInfo = pet->GetCharmInfo();
    if (!charmInfo)
    {
        SF_LOG_ERROR("network", "WorldSession::HandlePetSetAction: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), uint8(pet->GetTypeId()));
        return NULL;
    }
 
    //ignore invalid position
    if (request.index >= MAX_UNIT_ACTION_BAR_INDEX)
        return NULL;
 
    return pet;
}
 
Pet* ValidatePetRenameTarget(Player* player)
{
    Pet* pet = player->GetPet();
 
    if (!pet || pet->getPetType() != PetType::HUNTER_PET ||
        !pet->HasByteFlag(UNIT_FIELD_SHAPESHIFT_FORM, 2, UNIT_CAN_BE_RENAMED) ||
        !pet->GetCharmInfo())
        return NULL;
 
    return pet;
}
 
bool ValidatePetRenameName(WorldSession* session, PetRenameRequest& request)
{
    PetNameInvalidReason res = ObjectMgr::CheckPetName(request.name);
    if (res != PET_NAME_SUCCESS)
    {
        session->SendPetNameInvalid(res, request.name, NULL, request.petNumber);
        return false;
    }
 
    if (sObjectMgr->IsReservedName(request.name))
    {
        session->SendPetNameInvalid(PET_NAME_RESERVED, request.name, NULL, request.petNumber);
        return false;
    }
 
    return true;
}
 
bool ValidatePetDeclinedNames(WorldSession* session, PetRenameRequest& request)
{
    std::wstring wname;
    if (!Utf8toWStr(request.name, wname))
        return false;
 
    if (!ObjectMgr::CheckDeclinedNames(wname, request.declinedName))
    {
        session->SendPetNameInvalid(PET_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME, request.name, &request.declinedName, request.petNumber);
        return false;
    }
 
    return true;
}
 
Creature* ValidatePetAbandonRequest(Player* player, PetGuidRequest& request)
{
    if (!player->IsInWorld())
        return NULL;
 
    return ObjectAccessor::GetCreatureOrPetOrVehicle(*player, request.guid);
}
 
Creature* ValidatePetAutocastRequest(Player* player, PetSpellAutocastRequest& request, SpellInfo const*& spellInfo, CharmInfo*& charmInfo)
{
    spellInfo = NULL;
    charmInfo = NULL;
 
    if (!player->GetGuardianPet() && !player->GetCharm())
        return NULL;
 
    if (ObjectAccessor::FindPlayer(request.petGuid))
        return NULL;
 
    Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*player, request.petGuid);
    if (!pet || (pet != player->GetGuardianPet() && pet != player->GetCharm()))
    {
        SF_LOG_ERROR("network", "HandlePetSpellAutocastOpcode.Pet %u isn't pet of player %s (GUID: %u).", uint32(GUID_LOPART(request.petGuid)), player->GetName().c_str(), GUID_LOPART(player->GetGUID()));
        return NULL;
    }
 
    spellInfo = sSpellMgr->GetSpellInfo(request.spellId);
    // do not add not learned spells/ passive spells
    if (!pet->HasSpell(request.spellId) || !spellInfo->IsAutocastable())
        return NULL;
 
    charmInfo = pet->GetCharmInfo();
    if (!charmInfo)
    {
        SF_LOG_ERROR("network", "WorldSession::HandlePetSpellAutocastOpcod: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), uint8(pet->GetTypeId()));
        return NULL;
    }
 
    return pet;
}
 
Unit* ValidatePetCastRequest(Player* player, PetCastSpellRequest& request, SpellInfo const*& spellInfo)
{
    spellInfo = NULL;
 
    // This opcode is also sent from charmed and possessed units (players and creatures)
    if (!player->GetGuardianPet() && !player->GetCharm())
        return NULL;
 
    Unit* caster = ObjectAccessor::GetUnit(*player, request.petGuid);
    if (!caster || (caster != player->GetGuardianPet() && caster != player->GetCharm()))
    {
        SF_LOG_ERROR("network", "HandlePetCastSpellOpcode: Pet %u isn't pet of player %s (GUID: %u).", uint32(GUID_LOPART(request.petGuid)), player->GetName().c_str(), GUID_LOPART(player->GetGUID()));
        return NULL;
    }
 
    spellInfo = sSpellMgr->GetSpellInfo(request.spellId);
    if (!spellInfo)
    {
        SF_LOG_ERROR("network", "WORLD: unknown PET spell id %i", request.spellId);
        return NULL;
    }
 
    // do not cast not learned spells
    if (!caster->HasSpell(request.spellId) || spellInfo->IsPassive())
        return NULL;
 
    return caster;
}
 
Pet* ValidatePetSpecializationRequest(Player* player, SetPetSpecializationRequest& request)
{
    if (!player->IsInWorld())
        return NULL;
 
    Pet* pet = ObjectAccessor::GetPet(*player, request.petGuid);
    if (!pet || !pet->IsPet() || pet->getPetType() != PetType::HUNTER_PET ||
        pet->GetOwnerGUID() != player->GetGUID() || !pet->GetCharmInfo())
        return NULL;
 
    return pet;
}
}
 
void WorldSession::HandleDismissCritter(WorldPacket& recvData)
{
    PetGuidRequest request = ReadDismissCritterRequest(recvData);
 
    SF_LOG_DEBUG("network", "WORLD: Received CMSG_DISMISS_CRITTER for (guid: %u)", uint32(GUID_LOPART(request.guid)));
 
    Unit* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, request.guid);
 
    if (!pet)
    {
        SF_LOG_DEBUG("network", "Vanitypet (guid: %u) does not exist - player '%s' (guid: %u / account: %u) attempted to dismiss it (possibly lagged out)",
            uint32(GUID_LOPART(request.guid)), GetPlayer()->GetName().c_str(), GetPlayer()->GetGUIDLow(), GetAccountId());
        return;
    }
 
    if (_player->GetCritterGUID() == pet->GetGUID())
    {
        if (pet->GetTypeId() == TypeID::TYPEID_UNIT && pet->ToCreature()->IsSummon())
            pet->ToTempSummon()->UnSummon();
    }
}
 
void WorldSession::HandlePetAction(WorldPacket& recvData) //  sub_68C8FD [5.4.8 18291]
{
    PetActionRequest request = ReadPetActionRequest(recvData);
 
    uint32 SpellID = UNIT_ACTION_BUTTON_ACTION(request.action);
    uint8 Flag = UNIT_ACTION_BUTTON_TYPE(request.action);             //delete = 0x07 CastSpell = C1
 
    // used also for charmed creature
    SF_LOG_DEBUG("network", "HandlePetAction: Pet (GUID: %u) - Flag: %u, SpellID: %u, Target: %u.", uint32(GUID_LOPART(request.petGuid)), uint32(Flag), SpellID, uint32(GUID_LOPART(request.targetGuid)));
 
    Unit* pet = ValidatePetActionRequest(GetPlayer(), request, Flag, SpellID);
    if (!pet)
        return;
 
    if (GetPlayer()->m_Controlled.size() == 1)
        HandlePetActionHelper(pet, request.petGuid, SpellID, Flag, request.targetGuid, request.x, request.y, request.z);
    else
    {
        //If a pet is dismissed, m_Controlled will change
        std::vector<Unit*> controlled;
        for (Unit::ControlList::iterator itr = GetPlayer()->m_Controlled.begin(); itr != GetPlayer()->m_Controlled.end(); ++itr)
            if ((*itr)->GetEntry() == pet->GetEntry() && (*itr)->IsAlive())
                controlled.push_back(*itr);
        for (std::vector<Unit*>::iterator itr = controlled.begin(); itr != controlled.end(); ++itr)
            HandlePetActionHelper(*itr, request.petGuid, SpellID, Flag, request.targetGuid, request.x, request.y, request.z);
    }
}
 
void WorldSession::HandlePetStopAttack(WorldPacket& recvData)
{
    PetGuidRequest request = ReadPetStopAttackRequest(recvData);
 
    SF_LOG_DEBUG("network", "WORLD: Received CMSG_PET_STOP_ATTACK for GUID " UI64FMTD "", (uint64)request.guid);
 
    Unit* pet = ValidatePetStopAttackRequest(GetPlayer(), request);
    if (!pet)
        return;
 
    pet->AttackStop();
}
 
void WorldSession::HandlePetActionHelper(Unit* pet, uint64 guid1, uint32 spellid, uint16 flag, uint64 guid2, float x, float y, float z)
{
    CharmInfo* charmInfo = pet->GetCharmInfo();
    if (!charmInfo)
    {
        SF_LOG_ERROR("network", "WorldSession::HandlePetAction(petGuid: " UI64FMTD ", tagGuid: " UI64FMTD ", spellId: %u, flag: %u): object (entry: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!",
            guid1, guid2, spellid, flag, pet->GetGUIDLow(), uint8(pet->GetTypeId()));
        return;
    }
 
    switch (flag)
    {
        case ACT_COMMAND:                                   //0x07
            switch (spellid)
            {
                case COMMAND_STAY:                          //flat=1792  //STAY
                    pet->StopMoving();
                    pet->GetMotionMaster()->Clear(false);
                    pet->GetMotionMaster()->MoveIdle();
                    charmInfo->SetCommandState(COMMAND_STAY);
 
                    charmInfo->SetIsCommandAttack(false);
                    charmInfo->SetIsAtStay(true);
                    charmInfo->SetIsCommandFollow(false);
                    charmInfo->SetIsFollowing(false);
                    charmInfo->SetIsReturning(false);
                    charmInfo->SaveStayPosition();
                    break;
                case COMMAND_FOLLOW:                        //spellid=1792  //FOLLOW
                    pet->AttackStop();
                    pet->InterruptNonMeleeSpells(false);
                    pet->GetMotionMaster()->MoveFollow(_player, PET_FOLLOW_DIST, pet->GetFollowAngle());
                    charmInfo->SetCommandState(COMMAND_FOLLOW);
 
                    charmInfo->SetIsCommandAttack(false);
                    charmInfo->SetIsAtStay(false);
                    charmInfo->SetIsReturning(true);
                    charmInfo->SetIsCommandFollow(true);
                    charmInfo->SetIsFollowing(false);
                    break;
                case COMMAND_ATTACK:                        //spellid=1792  //ATTACK
                {
                    // Can't attack if owner is pacified
                    if (_player->HasAuraType(SPELL_AURA_MOD_PACIFY))
                    {
                        //pet->SendPetCastFail(spellid, SPELL_FAILED_PACIFIED);
                        return;
                    }
 
                    // only place where pet can be player
                    Unit* TargetUnit = ObjectAccessor::GetUnit(*_player, guid2);
                    if (!TargetUnit)
                        return;
 
                    if (Unit* owner = pet->GetOwner())
                        if (!owner->IsValidAttackTarget(TargetUnit))
                            return;
 
                    pet->ClearUnitState(UNIT_STATE_FOLLOW);
                    // This is true if pet has no target or has target but targets differs.
                    if (pet->GetVictim() != TargetUnit || (pet->GetVictim() == TargetUnit && !pet->GetCharmInfo()->IsCommandAttack()))
                    {
                        if (pet->GetVictim())
                            pet->AttackStop();
 
                        if (pet->GetTypeId() != TypeID::TYPEID_PLAYER && pet->ToCreature()->IsAIEnabled)
                        {
                            charmInfo->SetIsCommandAttack(true);
                            charmInfo->SetIsAtStay(false);
                            charmInfo->SetIsFollowing(false);
                            charmInfo->SetIsCommandFollow(false);
                            charmInfo->SetIsReturning(false);
 
                            pet->ToCreature()->AI()->AttackStart(TargetUnit);
 
                            //10% chance to play special pet attack talk, else growl
                            if (pet->ToCreature()->IsPet() && ((Pet*)pet)->getPetType() == PetType::SUMMON_PET && pet != TargetUnit && (std::rand() % 100) < 10)
                                pet->SendPetTalk((uint32)PET_TALK_ATTACK);
                            else
                            {
                                // 90% chance for pet and 100% chance for charmed creature
                                pet->SendPetAIReaction(guid1);
                            }
                        }
                        else                                // charmed player
                        {
                            if (pet->GetVictim() && pet->GetVictim() != TargetUnit)
                                pet->AttackStop();
 
                            charmInfo->SetIsCommandAttack(true);
                            charmInfo->SetIsAtStay(false);
                            charmInfo->SetIsFollowing(false);
                            charmInfo->SetIsCommandFollow(false);
                            charmInfo->SetIsReturning(false);
 
                            pet->Attack(TargetUnit, true);
                            pet->SendPetAIReaction(guid1);
                        }
                    }
                    break;
                }
                case COMMAND_ABANDON:                       // abandon (hunter pet) or dismiss (summoned pet)
                    if (pet->GetCharmerGUID() == GetPlayer()->GetGUID())
                        _player->StopCastingCharm();
                    else if (pet->GetOwnerGUID() == GetPlayer()->GetGUID())
                    {
                        ASSERT(pet->GetTypeId() == TypeID::TYPEID_UNIT);
                        if (pet->IsPet())
                        {
                            if (((Pet*)pet)->getPetType() == PetType::HUNTER_PET)
                                GetPlayer()->RemovePet((Pet*)pet, PET_SAVE_AS_DELETED);
                            else
                                //dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
                                pet->setDeathState(DeathState::CORPSE);
                        }
                        else if (pet->HasUnitTypeMask(UNIT_MASK_MINION))
                        {
                            ((Minion*)pet)->UnSummon();
                        }
                    }
                    break;
                case COMMAND_MOVE_TO:
                    pet->StopMoving();
                    pet->GetMotionMaster()->Clear(false);
                    pet->GetMotionMaster()->MovePoint(0, x, y, z);
                    charmInfo->SetCommandState(COMMAND_MOVE_TO);
 
                    charmInfo->SetIsCommandAttack(false);
                    charmInfo->SetIsAtStay(true);
                    charmInfo->SetIsFollowing(false);
                    charmInfo->SetIsReturning(false);
                    charmInfo->SaveStayPosition();
                    break;
                default:
                    SF_LOG_ERROR("network", "WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
            }
            break;
        case ACT_REACTION:                                  // 0x6
            switch (spellid)
            {
                case REACT_ASSIST:                          //assist
                case REACT_PASSIVE:                         //passive
                    pet->AttackStop();
                case REACT_DEFENSIVE:                       //recovery
                case REACT_AGGRESSIVE:                      //activete
                    if (pet->GetTypeId() == TypeID::TYPEID_UNIT)
                        pet->ToCreature()->SetReactState(ReactStates(spellid));
                    break;
            }
            break;
        case ACT_DISABLED:                                  // 0x81    spell (disabled), ignore
        case ACT_PASSIVE:                                   // 0x01
        case ACT_ENABLED:                                   // 0xC1    spell
        {
            Unit* unit_target = NULL;
 
            if (guid2)
                unit_target = ObjectAccessor::GetUnit(*_player, guid2);
 
            // do not cast unknown spells
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellid);
            if (!spellInfo)
            {
                SF_LOG_ERROR("network", "WORLD: unknown PET spell id %i", spellid);
                return;
            }
 
            for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (spellInfo->Effects[i].TargetA.GetTarget() == TARGET_UNIT_SRC_AREA_ENEMY || spellInfo->Effects[i].TargetA.GetTarget() == TARGET_UNIT_DEST_AREA_ENEMY || spellInfo->Effects[i].TargetA.GetTarget() == TARGET_DEST_DYNOBJ_ENEMY)
                    return;
            }
 
            // do not cast not learned spells
            if (!pet->HasSpell(spellid) || spellInfo->IsPassive())
                return;
 
            //  Clear the flags as if owner clicked 'attack'. AI will reset them
            //  after AttackStart, even if spell failed
            if (pet->GetCharmInfo())
            {
                pet->GetCharmInfo()->SetIsAtStay(false);
                pet->GetCharmInfo()->SetIsCommandAttack(true);
                pet->GetCharmInfo()->SetIsReturning(false);
                pet->GetCharmInfo()->SetIsFollowing(false);
            }
 
            Spell* spell = new Spell(pet, spellInfo, TRIGGERED_NONE);
 
            SpellCastResult result = spell->CheckPetCast(unit_target);
 
            //auto turn to target unless possessed
            if (result == SpellCastResult::SPELL_FAILED_UNIT_NOT_INFRONT && !pet->isPossessed() && !pet->IsVehicle())
            {
                if (unit_target)
                {
                    pet->SetInFront(unit_target);
                    if (Player* player = unit_target->ToPlayer())
                        pet->SendUpdateToPlayer(player);
                }
                else if (Unit* unit_target2 = spell->m_targets.GetUnitTarget())
                {
                    pet->SetInFront(unit_target2);
                    if (Player* player = unit_target2->ToPlayer())
                        pet->SendUpdateToPlayer(player);
                }
 
                if (Unit* powner = pet->GetCharmerOrOwner())
                    if (Player* player = powner->ToPlayer())
                        pet->SendUpdateToPlayer(player);
 
                result = SpellCastResult::SPELL_CAST_OK;
            }
 
            if (result == SpellCastResult::SPELL_CAST_OK)
            {
                pet->ToCreature()->AddCreatureSpellCooldown(spellid);
 
                unit_target = spell->m_targets.GetUnitTarget();
 
                //10% chance to play special pet attack talk, else growl
                //actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
                if (pet->ToCreature()->IsPet() && (((Pet*)pet)->getPetType() == PetType::SUMMON_PET) && (pet != unit_target) && ((std::rand() % 100) < 10))
                    pet->SendPetTalk((uint32)PET_TALK_SPECIAL_SPELL);
                else
                {
                    pet->SendPetAIReaction(guid1);
                }
 
                if (unit_target && !GetPlayer()->IsFriendlyTo(unit_target) && !pet->isPossessed() && !pet->IsVehicle())
                {
                    // This is true if pet has no target or has target but targets differs.
                    if (pet->GetVictim() != unit_target)
                    {
                        if (pet->GetVictim())
                            pet->AttackStop();
                        pet->GetMotionMaster()->Clear();
                        if (pet->ToCreature()->IsAIEnabled)
                            pet->ToCreature()->AI()->AttackStart(unit_target);
                    }
                }
 
                spell->prepare(&(spell->m_targets));
            }
            else
            {
                if (pet->isPossessed() || pet->IsVehicle()) 
                    Spell::SendCastResult(GetPlayer(), spellInfo, 0, result);
                else
                    spell->SendPetCastResult(result);
 
                if (!pet->ToCreature()->HasSpellCooldown(spellid))
                    GetPlayer()->SendClearCooldown(spellid, pet);
 
                spell->finish(false);
                delete spell;
 
                // reset specific flags in case of spell fail. AI will reset other flags
                if (pet->GetCharmInfo())
                    pet->GetCharmInfo()->SetIsCommandAttack(false);
            }
            break;
        }
        default:
            SF_LOG_ERROR("network", "WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
    }
}
 
void WorldSession::HandlePetNameQuery(WorldPacket& recvData)
{
    SF_LOG_INFO("network", "HandlePetNameQuery. CMSG_PET_NAME_QUERY");
 
    PetNameQueryRequest request = ReadPetNameQueryRequest(recvData);
    SendPetNameQuery(request.petGuid, request.petNumber);
}
 
void WorldSession::SendPetNameQuery(ObjectGuid petGuid, uint64 petNumber)
{
    Creature* pet = ObjectAccessor::GetCreatureOrPetOrVehicle(*_player, petGuid);
    if (!pet)
    {
        WorldPacket data(SMSG_PET_NAME_QUERY_RESPONSE, (8 + 1));
        data.WriteBit(0);
        data.FlushBits();
        data << uint64(petNumber);
 
        _player->GetSession()->SendPacket(&data);
        return;
    }
 
    WorldPacket data(SMSG_PET_NAME_QUERY_RESPONSE, (8 + 1 + 1 + 5 + pet->GetName().size() + 4));
    data.WriteBit(1);                               // has data
 
    bool declinedNames = pet->IsPet() && ((Pet*)pet)->GetDeclinedNames();
 
    for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
    {
        if (declinedNames)
            data.WriteBits(((Pet*)pet)->GetDeclinedNames()->name[i].size(), 7);
        else
            data.WriteBits(0, 7);
    }
 
    data.WriteBit(0);                               // unknown
    data.WriteBits(pet->GetName().size(), 8);
    data.FlushBits();
 
    if (declinedNames)
        for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
            data.WriteString(((Pet*)pet)->GetDeclinedNames()->name[i]);
 
    data.WriteString(pet->GetName());
    data << uint32(pet->GetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP));
    data << uint64(petNumber);
 
    _player->GetSession()->SendPacket(&data);
}
 
bool WorldSession::CheckStableMaster(uint64 guid)
{
    // spell case or GM
    if (guid == GetPlayer()->GetGUID())
    {
        if (!GetPlayer()->IsGameMaster())
        {
            SF_LOG_DEBUG("network", "Player (GUID:%u) attempt open stable in cheating way.", GUID_LOPART(guid));
            return false;
        }
    }
    // stable master case
    else
    {
        if (!GetPlayer()->GetNPCIfCanInteractWith(guid, UNIT_NPC_FLAG_STABLEMASTER))
        {
            SF_LOG_DEBUG("network", "Stablemaster (GUID:%u) not found or you can't interact with him.", GUID_LOPART(guid));
            return false;
        }
    }
    return true;
}
 
void WorldSession::HandlePetSetAction(WorldPacket& recvData)
{
    SF_LOG_INFO("network", "HandlePetSetAction. CMSG_PET_SET_ACTION");
 
    PetSetActionRequest request = ReadPetSetActionRequest(recvData);
 
    CharmInfo* charmInfo = NULL;
    Unit* pet = ValidatePetSetActionRequest(GetPlayer(), request, charmInfo);
    if (!pet)
        return;
 
    uint32 spell_id = UNIT_ACTION_BUTTON_ACTION(request.action);
    uint8 act_state = UNIT_ACTION_BUTTON_TYPE(request.action);
 
    SF_LOG_INFO("network", "Player %s has changed pet spell action. Position: %u, Spell: %u, State: 0x%X",
        _player->GetName().c_str(), request.index, spell_id, uint32(act_state));
 
    //if it's act for spell (en/disable/cast) and there is a spell given (0 = remove spell) which pet doesn't know, don't add
    if (!((act_state == ACT_ENABLED || act_state == ACT_DISABLED || act_state == ACT_PASSIVE) && spell_id && !pet->HasSpell(spell_id)))
    {
        if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id))
        {
            //sign for autocast
            if (act_state == ACT_ENABLED)
            {
                if (pet->GetTypeId() == TypeID::TYPEID_UNIT && pet->ToCreature()->IsPet())
                    ((Pet*)pet)->ToggleAutocast(spellInfo, true);
                else
                    for (Unit::ControlList::iterator itr = GetPlayer()->m_Controlled.begin(); itr != GetPlayer()->m_Controlled.end(); ++itr)
                        if ((*itr)->GetEntry() == pet->GetEntry())
                            (*itr)->GetCharmInfo()->ToggleCreatureAutocast(spellInfo, true);
            }
            //sign for no/turn off autocast
            else if (act_state == ACT_DISABLED)
            {
                if (pet->GetTypeId() == TypeID::TYPEID_UNIT && pet->ToCreature()->IsPet())
                    ((Pet*)pet)->ToggleAutocast(spellInfo, false);
                else
                    for (Unit::ControlList::iterator itr = GetPlayer()->m_Controlled.begin(); itr != GetPlayer()->m_Controlled.end(); ++itr)
                        if ((*itr)->GetEntry() == pet->GetEntry())
                            (*itr)->GetCharmInfo()->ToggleCreatureAutocast(spellInfo, false);
            }
        }
        charmInfo->SetActionBar(request.index, spell_id, ActiveStates(act_state));
    }
}
 
void WorldSession::HandlePetRename(WorldPacket& recvData)
{
    SF_LOG_INFO("network", "HandlePetRename. CMSG_PET_RENAME");
 
    PetRenameRequest request = ReadPetRenameRequest(recvData);
 
    Pet* pet = ValidatePetRenameTarget(GetPlayer());
    if (!pet)
        return;
 
    if (!ValidatePetRenameName(this, request))
        return;
 
    pet->SetName(request.name);
 
    if (_player->GetGroup())
        _player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_NAME);
 
    pet->RemoveByteFlag(UNIT_FIELD_SHAPESHIFT_FORM, 2, UNIT_CAN_BE_RENAMED);
 
    if (request.hasDeclinedNames)
        if (!ValidatePetDeclinedNames(this, request))
            return;
 
    SQLTransaction trans = CharacterDatabase.BeginTransaction();
    if (request.hasDeclinedNames)
    {
        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_DECLINEDNAME);
        stmt->setUInt32(0, pet->GetCharmInfo()->GetPetNumber());
        trans->Append(stmt);
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_ADD_CHAR_PET_DECLINEDNAME);
        stmt->setUInt32(0, _player->GetGUIDLow());
 
        for (uint8 i = 0; i < 5; i++)
            stmt->setString(i + 1, request.declinedName.name[i]);
 
        trans->Append(stmt);
    }
 
    PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHAR_PET_NAME);
    stmt->setString(0, request.name);
    stmt->setUInt32(1, _player->GetGUIDLow());
    stmt->setUInt32(2, pet->GetCharmInfo()->GetPetNumber());
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
 
    pet->SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(time(NULL))); // cast can't be helped
}
 
void WorldSession::HandlePetAbandon(WorldPacket& recvData)
{
    PetGuidRequest request = ReadPetAbandonRequest(recvData);
 
    SF_LOG_INFO("network", "HandlePetAbandon. CMSG_PET_ABANDON pet guid is %u", GUID_LOPART(request.guid));
 
    // pet/charmed
    Creature* pet = ValidatePetAbandonRequest(GetPlayer(), request);
    if (pet)
    {
        if (pet->IsPet())
            _player->RemovePet((Pet*)pet, PET_SAVE_AS_DELETED);
        else if (pet->GetGUID() == _player->GetCharmGUID())
            _player->StopCastingCharm();
    }
}
 
void WorldSession::HandlePetSpellAutocastOpcode(WorldPacket& recvPacket)
{
    SF_LOG_INFO("network", "CMSG_PET_SPELL_AUTOCAST");
 
    PetSpellAutocastRequest request = ReadPetSpellAutocastRequest(recvPacket);
 
    SpellInfo const* spellInfo = NULL;
    CharmInfo* charmInfo = NULL;
    Creature* pet = ValidatePetAutocastRequest(GetPlayer(), request, spellInfo, charmInfo);
    if (!pet)
        return;
 
    if (pet->IsPet())
        ((Pet*)pet)->ToggleAutocast(spellInfo, request.state);
    else
        pet->GetCharmInfo()->ToggleCreatureAutocast(spellInfo, request.state);
 
    charmInfo->SetSpellAutocast(spellInfo, request.state);
}
 
void WorldSession::HandlePetCastSpellOpcode(WorldPacket& recvPacket)
{
    SF_LOG_DEBUG("network", "WORLD: CMSG_PET_CAST_SPELL");
 
    PetCastSpellRequest request = ReadPetCastSpellRequest(recvPacket);
 
    SF_LOG_DEBUG("network", "WORLD: CMSG_PET_CAST_SPELL, guid: " UI64FMTD ", castCount: %u, spellId %u, castFlags %u", uint64(request.petGuid), request.castCount, request.spellId, request.castFlags);
 
    SpellInfo const* spellInfo = NULL;
    Unit* caster = ValidatePetCastRequest(GetPlayer(), request, spellInfo);
    if (!caster)
        return;
 
    SpellCastTargets targets;
    targets.Initialize(request.targetFlags, request.targetGuid, request.itemGuid, request.transportDstGuid, request.dstLoc, request.transportSrcGuid, request.srcLoc);
    targets.SetElevation(request.elevation);
    targets.SetSpeed(request.missileSpeed);
    targets.Update(caster);
 
    caster->ClearUnitState(UNIT_STATE_FOLLOW);
 
    Spell* spell = new Spell(caster, spellInfo, TRIGGERED_NONE);
    spell->m_cast_count = request.castCount;            // probably pending spell cast
    spell->m_targets = targets;
 
    Unit* unit_target = request.targetGuid ? ObjectAccessor::GetUnit(*_player, request.targetGuid) : nullptr;
    if (!unit_target && caster->GetVehicleKit() && caster->GetVehicleKit()->GetPassenger(0))
        unit_target = caster->GetVehicleKit()->GetPassenger(0);
    SpellCastResult result = spell->CheckPetCast(unit_target ? unit_target : nullptr);
 
    if (result == SpellCastResult::SPELL_CAST_OK)
    {
        spell->prepare(&(spell->m_targets));
 
        if (Creature* creature = caster->ToCreature())
        {
            creature->AddCreatureSpellCooldown(request.spellId);
            if (Pet* pet = creature->ToPet())
            {
                // 10% chance to play special pet attack talk, else growl
                // actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
                if (pet->getPetType() == PetType::SUMMON_PET && ((std::rand() % 100) < 10))
                    pet->SendPetTalk(PET_TALK_SPECIAL_SPELL);
                else
                    pet->SendPetAIReaction(request.petGuid);
            }
        }
    }
    else
    {
        spell->SendPetCastResult(result);
 
        if (caster->GetTypeId() == TypeID::TYPEID_PLAYER)
        {
            if (!caster->ToPlayer()->HasSpellCooldown(request.spellId))
                GetPlayer()->SendClearCooldown(request.spellId, caster);
        }
        else
        {
            if (!caster->ToCreature()->HasSpellCooldown(request.spellId))
                GetPlayer()->SendClearCooldown(request.spellId, caster);
        }
 
        spell->finish(false);
        delete spell;
    }
}
 
void WorldSession::SendPetNameInvalid(uint32 error, const std::string& name, DeclinedName* declinedName, uint32 petNumber)
{
    WorldPacket data(SMSG_PET_NAME_INVALID, 4 + name.size() + 1 + 1 + 1 + 4);
    data.WriteBit(1);
    data.WriteBits(name.size(), 8);
    data.WriteBit(declinedName ? 1 : 0);
    data.FlushBits();
 
    if (declinedName)
    {
        for (uint32 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
            data.WriteBits(declinedName->name[i].size(), 7);
 
        for (uint32 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
            data.WriteString(declinedName->name[i]);
    }
 
    data.WriteString(name);
    data << uint8(error);
    data << uint32(petNumber);
 
    SendPacket(&data);
}
 
void WorldSession::HandlePetLearnTalent(WorldPacket& recvData)
{
    SF_LOG_DEBUG("network", "WORLD: CMSG_PET_LEARN_TALENT");
}
 
void WorldSession::HandleLearnPreviewTalentsPet(WorldPacket& recvData)
{
    SF_LOG_DEBUG("network", "CMSG_LEARN_PREVIEW_TALENTS_PET");
}
 
void WorldSession::HandleSetPetSpecialization(WorldPacket& recvData)
{
    SF_LOG_DEBUG("network", "CMSG_SET_PET_SPECIALIZATION");
 
    SetPetSpecializationRequest request = ReadSetPetSpecializationRequest(recvData);
 
    Pet* pet = ValidatePetSpecializationRequest(GetPlayer(), request);
    if (!pet)
        return;
 
    pet->SetSpec(pet->GetPetSpecByTalentTab(request.talentTab));
}