pet_commandscript Class Reference

Inheritance diagram for pet_commandscript:

Public Member Functions
	pet_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandlePetCreateCommand (ChatHandler *handler)
static bool	HandlePetLearnCommand (ChatHandler *handler, SpellInfo const *spell)
static bool	HandlePetDeleteCommand (ChatHandler *handler, PlayerIdentifier owner, uint32 petNumber)
static bool	HandlePetListCommand (ChatHandler *handler, PlayerIdentifier owner)
static bool	HandlePetUnlearnCommand (ChatHandler *handler, SpellInfo const *spell)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (const char *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name, uint16 totalAvailableHooks=0)
virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

pet_commandscript()

pet_commandscript::pet_commandscript ( )

inline

: CommandScript("pet_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable pet_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable petCommandTable =
        {
            { "create",  HandlePetCreateCommand,  rbac::RBAC_PERM_COMMAND_PET_CREATE,  Console::No  },
            { "delete",  HandlePetDeleteCommand,  rbac::RBAC_PERM_COMMAND_PET_DELETE,  Console::Yes },
            { "learn",   HandlePetLearnCommand,   rbac::RBAC_PERM_COMMAND_PET_LEARN,   Console::No  },
            { "list",    HandlePetListCommand,    rbac::RBAC_PERM_COMMAND_PET_LIST,    Console::Yes },
            { "unlearn", HandlePetUnlearnCommand, rbac::RBAC_PERM_COMMAND_PET_UNLEARN, Console::No  }
        };
 
        static ChatCommandTable commandTable =
        {
            { "pet", petCommandTable }
        };
 
        return commandTable;
    }

References HandlePetCreateCommand(), HandlePetDeleteCommand(), HandlePetLearnCommand(), HandlePetListCommand(), HandlePetUnlearnCommand(), rbac::RBAC_PERM_COMMAND_PET_CREATE, rbac::RBAC_PERM_COMMAND_PET_DELETE, rbac::RBAC_PERM_COMMAND_PET_LEARN, rbac::RBAC_PERM_COMMAND_PET_LIST, and rbac::RBAC_PERM_COMMAND_PET_UNLEARN.

HandlePetCreateCommand()

static bool pet_commandscript::HandlePetCreateCommand ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        Creature* creatureTarget = handler->getSelectedCreature();
 
        if (!creatureTarget || creatureTarget->IsPet() || creatureTarget->IsPlayer())
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        CreatureTemplate const* creatrueTemplate = sObjectMgr->GetCreatureTemplate(creatureTarget->GetEntry());
        // Creatures with family 0 crashes the server
        if (!creatrueTemplate->family)
        {
            handler->SendErrorMessage(LANG_CREATURE_NON_TAMEABLE, creatrueTemplate->Entry);
            return false;
        }
 
        if (player->IsExistPet())
        {
            handler->SendErrorMessage(LANG_YOU_ALREADY_HAVE_PET);
            return false;
        }
 
        if (!player->CreatePet(creatureTarget))
        {
            handler->SendErrorMessage(LANG_CREATURE_NON_TAMEABLE, creatrueTemplate->Entry);
            return false;
        }
 
        return true;
    }

References Player::CreatePet(), CreatureTemplate::Entry, CreatureTemplate::family, Object::GetEntry(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Player::IsExistPet(), Unit::IsPet(), Object::IsPlayer(), LANG_CREATURE_NON_TAMEABLE, LANG_SELECT_CREATURE, LANG_YOU_ALREADY_HAVE_PET, ChatHandler::SendErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandlePetDeleteCommand()

static bool pet_commandscript::HandlePetDeleteCommand ( ChatHandler *  handler, PlayerIdentifier  owner, uint32  petNumber  )

inlinestatic

    {
        ObjectGuid ownerGuid = owner.GetGUID();
 
        QueryResult result = CharacterDatabase.Query(
            "SELECT entry, name FROM character_pet WHERE id = {} AND owner = {}",
            petNumber, ownerGuid.GetCounter());
 
        if (!result)
        {
            handler->SendErrorMessage(LANG_PET_DELETE_NOT_FOUND, petNumber, owner.GetName(),
                                      ownerGuid.GetCounter());
            return false;
        }
 
        if (Player* online = owner.GetConnectedPlayer())
        {
            if (Pet* activePet = online->GetPet())
            {
                if (activePet->GetCharmInfo() &&
                    activePet->GetCharmInfo()->GetPetNumber() == petNumber)
                {
                    online->RemovePet(activePet, PET_SAVE_AS_DELETED);
                }
            }
 
            // Drop the pet from the in-memory PetStable so the stable UI / call-pet
            // logic does not reference a row that no longer exists in the database.
            if (PetStable* stable = online->GetPetStable())
            {
                if (stable->CurrentPet && stable->CurrentPet->PetNumber == petNumber)
                    stable->CurrentPet.reset();
 
                for (Optional<PetStable::PetInfo>& stabled : stable->StabledPets)
                    if (stabled && stabled->PetNumber == petNumber)
                        stabled.reset();
 
                stable->UnslottedPets.erase(
                    std::remove_if(stable->UnslottedPets.begin(), stable->UnslottedPets.end(),
                        [petNumber](PetStable::PetInfo const& p) { return p.PetNumber == petNumber; }),
                    stable->UnslottedPets.end());
            }
        }
 
        Field* fields    = result->Fetch();
        uint32 entry     = fields[0].Get<uint32>();
        std::string name = fields[1].Get<std::string>();
 
        std::string creatureName = "<unknown>";
        if (CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(entry))
            creatureName = cInfo->Name;
 
        Pet::DeleteFromDB(petNumber);
 
        handler->PSendSysMessage(LANG_PET_DELETE_SUCCESS, petNumber, name, entry, creatureName,
                                 owner.GetName(), ownerGuid.GetCounter());
        return true;
    }

References CharacterDatabase, Pet::DeleteFromDB(), Field::Get(), Acore::ChatCommands::PlayerIdentifier::GetConnectedPlayer(), ObjectGuid::GetCounter(), Acore::ChatCommands::PlayerIdentifier::GetGUID(), Acore::ChatCommands::PlayerIdentifier::GetName(), LANG_PET_DELETE_NOT_FOUND, LANG_PET_DELETE_SUCCESS, PET_SAVE_AS_DELETED, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandlePetLearnCommand()

static bool pet_commandscript::HandlePetLearnCommand ( ChatHandler *  handler, SpellInfo const *  spell  )

inlinestatic

    {
        if (!spell)
        {
            handler->SendErrorMessage(LANG_COMMAND_NOSPELLFOUND);
            return false;
        }
 
        if (!SpellMgr::IsSpellValid(spell))
        {
            handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
            return false;
        }
 
        Pet* pet = handler->GetSession()->GetPlayer()->GetPet();
        if (!pet)
        {
            handler->SendErrorMessage("You have no pet");
            return false;
        }
 
        SpellScriptsBounds bounds = sObjectMgr->GetSpellScriptsBounds(spell->Id);
        uint32 spellDifficultyId = sSpellMgr->GetSpellDifficultyId(spell->Id);
        if (bounds.first != bounds.second || spellDifficultyId)
        {
            handler->SendErrorMessage("Spell {} cannot be learnt using a command!", spell->Id);
            return false;
        }
 
        // Check if pet already has it
        if (pet->HasSpell(spell->Id))
        {
            handler->SendErrorMessage("Pet already has spell: {}", spell->Id);
            return false;
        }
 
        pet->learnSpell(spell->Id);
        handler->PSendSysMessage("Pet has learned spell {}", spell->Id);
 
        return true;
    }

References Player::GetPet(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Pet::HasSpell(), SpellInfo::Id, SpellMgr::IsSpellValid(), LANG_COMMAND_NOSPELLFOUND, LANG_COMMAND_SPELL_BROKEN, Pet::learnSpell(), ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), sObjectMgr, and sSpellMgr.

Referenced by GetCommands().

HandlePetListCommand()

static bool pet_commandscript::HandlePetListCommand ( ChatHandler *  handler, PlayerIdentifier  owner  )

inlinestatic

    {
        ObjectGuid ownerGuid = owner.GetGUID();
 
        QueryResult result = CharacterDatabase.Query(
            "SELECT id, entry, level, slot, name, PetType FROM character_pet "
            "WHERE owner = {} ORDER BY slot, id",
            ownerGuid.GetCounter());
 
        if (!result)
        {
            handler->PSendSysMessage(LANG_PET_LIST_EMPTY, owner.GetName(), ownerGuid.GetCounter());
            return true;
        }
 
        handler->PSendSysMessage(LANG_PET_LIST_HEADER, owner.GetName(), ownerGuid.GetCounter());
 
        do
        {
            Field* fields    = result->Fetch();
            uint32 petNumber = fields[0].Get<uint32>();
            uint32 entry     = fields[1].Get<uint32>();
            uint8  level     = fields[2].Get<uint8>();
            uint8  slot      = fields[3].Get<uint8>();
            std::string name = fields[4].Get<std::string>();
            uint8  petType   = fields[5].Get<uint8>();
 
            std::string creatureName = "<unknown>";
            if (CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(entry))
                creatureName = cInfo->Name;
 
            handler->PSendSysMessage(LANG_PET_LIST_ENTRY, petNumber, uint32(slot), entry,
                                     creatureName, name, uint32(level), uint32(petType));
        } while (result->NextRow());
 
        return true;
    }

References CharacterDatabase, Field::Get(), ObjectGuid::GetCounter(), Acore::ChatCommands::PlayerIdentifier::GetGUID(), Acore::ChatCommands::PlayerIdentifier::GetName(), LANG_PET_LIST_EMPTY, LANG_PET_LIST_ENTRY, LANG_PET_LIST_HEADER, ChatHandler::PSendSysMessage(), and sObjectMgr.

Referenced by GetCommands().

HandlePetUnlearnCommand()

static bool pet_commandscript::HandlePetUnlearnCommand ( ChatHandler *  handler, SpellInfo const *  spell  )

inlinestatic

    {
        if (!spell)
        {
            handler->SendErrorMessage(LANG_COMMAND_NOSPELLFOUND);
            return false;
        }
 
        if (!SpellMgr::IsSpellValid(spell))
        {
            handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
            return false;
        }
 
        Pet* pet = handler->GetSession()->GetPlayer()->GetPet();
        if (!pet)
        {
            handler->SendErrorMessage("You have no pet");
            return false;
        }
 
        if (pet->HasSpell(spell->Id))
        {
            pet->removeSpell(spell->Id, false);
        }
        else
        {
            handler->PSendSysMessage("Pet doesn't have that spell");
        }
 
        return true;
    }

References Player::GetPet(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Pet::HasSpell(), SpellInfo::Id, SpellMgr::IsSpellValid(), LANG_COMMAND_NOSPELLFOUND, LANG_COMMAND_SPELL_BROKEN, ChatHandler::PSendSysMessage(), Pet::removeSpell(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/server/scripts/Commands/cs_pet.cpp