Inheritance diagram for misc_commandscript:

Public Member Functions
	misc_commandscript ()

ChatCommandTable	GetCommands () const override

Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const

virtual bool	isAfterLoadScript () const

virtual void	checkValidity ()

std::string const &	GetName () const

uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleSkirmishCommand (ChatHandler *handler, std::vector< std::string_view > args)

static bool	HandleCommentatorCommand (ChatHandler *handler, Optional< bool > enableArg)

static bool	HandleDevCommand (ChatHandler *handler, Optional< bool > enableArg)

static bool	HandleGPSCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleAuraCommand (ChatHandler handler, SpellInfo const spell)

static bool	HandleAuraStacksCommand (ChatHandler handler, SpellInfo const spell, int16 stacks)

static bool	HandleUnAuraCommand (ChatHandler handler, Variant< SpellInfo const , std::string_view > spells)

static bool	HandleAppearCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleSummonCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleGroupSummonCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleCommandsCommand (ChatHandler *handler)

static bool	HandleDieCommand (ChatHandler *handler)

static bool	HandleReviveCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleDismountCommand (ChatHandler *handler)

static bool	HandleGUIDCommand (ChatHandler *handler)

static bool	HandleHelpCommand (ChatHandler *handler, Tail cmd)

static bool	HandleCooldownCommand (ChatHandler handler, Optional< SpellInfo const > spell)

static bool	HandleGetDistanceCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleRecallCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleSaveCommand (ChatHandler *handler)

static bool	HandleSaveAllCommand (ChatHandler *handler)

static bool	HandleKickPlayerCommand (ChatHandler *handler, Optional< PlayerIdentifier > target, Optional< std::string_view > reason)

static bool	HandleUnstuckCommand (ChatHandler *handler, Optional< PlayerIdentifier > target, Optional< std::string_view > location)

static bool	HandleLinkGraveCommand (ChatHandler *handler, uint32 graveyardId, Optional< std::string_view > team)

static bool	HandleNearGraveCommand (ChatHandler *handler, Optional< std::string_view > team)

static bool	HandleShowAreaCommand (ChatHandler *handler, uint32 areaID)

static bool	HandleHideAreaCommand (ChatHandler *handler, uint32 areaID)

static bool	HandleAddItemCommand (ChatHandler handler, Optional< PlayerIdentifier > player, ItemTemplate const itemTemplate, Optional< int32 > _count)

static bool	HandleAddItemSetCommand (ChatHandler *handler, Variant< Hyperlink< itemset >, uint32 > itemSetId)

static bool	HandleChangeWeather (ChatHandler *handler, uint32 type, float grade)

static bool	HandleMaxSkillCommand (ChatHandler *handler)

static bool	HandleSetSkillCommand (ChatHandler *handler, Variant< Hyperlink< skill >, uint32 > skillId, int32 level, Optional< uint16 > maxPureSkill)

static bool	HandlePInfoCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleRespawnCreatureByGuidCommand (ChatHandler *handler, ObjectGuid::LowType spawnId)

static bool	HandleRespawnGameObjectByGuidCommand (ChatHandler *handler, ObjectGuid::LowType spawnId)

static bool	HandleRespawnCreatureByEntryCommand (ChatHandler *handler, uint32 entry, Optional< uint32 > mapIdArg, Optional< uint32 > instanceIdArg)

static bool	HandleRespawnGameObjectByEntryCommand (ChatHandler *handler, uint32 entry, Optional< uint32 > mapIdArg, Optional< uint32 > instanceIdArg)

static bool	HandleRespawnCommand (ChatHandler *handler)

static bool	HandleRespawnAllCommand (ChatHandler *handler)

static bool	HandleMuteCommand (ChatHandler *handler, Optional< PlayerIdentifier > player, std::string notSpeakTime, Tail muteReason)

static bool	HandleUnmuteCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleMuteInfoCommand (ChatHandler *handler, std::string accountName)

static bool	HandleMuteInfoHelper (ChatHandler handler, uint32 accountId, char const accountName)

static bool	HandleMovegensCommand (ChatHandler *handler)

static bool	HandleComeToMeCommand (ChatHandler *handler)

static bool	HandleDamageCommand (ChatHandler *handler, uint32 damage, Optional< std::string > percent)

static bool	HandleCombatStopCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleFlushArenaPointsCommand (ChatHandler *)

static bool	HandleFreezeCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandleUnFreezeCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

static bool	HandlePlayAllCommand (ChatHandler *handler, uint32 soundId)

static bool	HandlePossessCommand (ChatHandler *handler)

static bool	HandleUnPossessCommand (ChatHandler *handler)

static bool	HandleBindSightCommand (ChatHandler *handler)

static bool	HandleUnbindSightCommand (ChatHandler *handler)

static bool	HandleMailBoxCommand (ChatHandler *handler)

static bool	HandleStringCommand (ChatHandler *handler, uint32 id, Optional< uint8 > locale)

static bool	HandleOpenDoorCommand (ChatHandler *handler, Optional< float > range)

static bool	HandleBMCommand (ChatHandler *handler, Optional< bool > enableArg)

static bool	HandlePacketLog (ChatHandler *handler, Optional< PlayerIdentifier > target, Optional< bool > enableArg)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (char const *name)

Protected Member Functions inherited from ScriptObject
	ScriptObject (char const *name, uint16 totalAvailableHooks=0)

virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

◆ misc_commandscript()

misc_commandscript::misc_commandscript ( )

inline

93: CommandScript("misc_commandscript") { }

CommandScript

Definition CommandScript.h:25

Member Function Documentation

◆ GetCommands()

ChatCommandTable misc_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable auraCommandTable =
        {
            { "stack",             HandleAuraStacksCommand,        rbac::RBAC_PERM_COMMAND_AURA_STACK,        Console::No  },
            { "",                  HandleAuraCommand,              rbac::RBAC_PERM_COMMAND_AURA,              Console::No  }
        };
 
        static ChatCommandTable commandTable =
        {
            { "commentator",       HandleCommentatorCommand,       rbac::RBAC_PERM_COMMAND_COMMENTATOR,       Console::No  },
            { "dev",               HandleDevCommand,               rbac::RBAC_PERM_COMMAND_DEV,               Console::No  },
            { "gps",               HandleGPSCommand,               rbac::RBAC_PERM_COMMAND_GPS,               Console::No  },
            { "aura",              auraCommandTable                                                                        },
            { "unaura",            HandleUnAuraCommand,            rbac::RBAC_PERM_COMMAND_UNAURA,            Console::No  },
            { "appear",            HandleAppearCommand,            rbac::RBAC_PERM_COMMAND_APPEAR,            Console::No  },
            { "summon",            HandleSummonCommand,            rbac::RBAC_PERM_COMMAND_SUMMON,            Console::No  },
            { "groupsummon",       HandleGroupSummonCommand,       rbac::RBAC_PERM_COMMAND_GROUP_SUMMON,      Console::No  },
            { "commands",          HandleCommandsCommand,          rbac::RBAC_PERM_COMMAND_COMMANDS,          Console::Yes },
            { "die",               HandleDieCommand,               rbac::RBAC_PERM_COMMAND_DIE,               Console::No  },
            { "revive",            HandleReviveCommand,            rbac::RBAC_PERM_COMMAND_REVIVE,            Console::Yes },
            { "dismount",          HandleDismountCommand,          rbac::RBAC_PERM_COMMAND_DISMOUNT,          Console::No  },
            { "guid",              HandleGUIDCommand,              rbac::RBAC_PERM_COMMAND_GUID,              Console::No  },
            { "help",              HandleHelpCommand,              rbac::RBAC_PERM_COMMAND_HELP,              Console::Yes },
            { "cooldown",          HandleCooldownCommand,          rbac::RBAC_PERM_COMMAND_COOLDOWN,          Console::No  },
            { "distance",          HandleGetDistanceCommand,       rbac::RBAC_PERM_COMMAND_DISTANCE,          Console::No  },
            { "recall",            HandleRecallCommand,            rbac::RBAC_PERM_COMMAND_RECALL,            Console::No  },
            { "save",              HandleSaveCommand,              rbac::RBAC_PERM_COMMAND_SAVE,              Console::No  },
            { "saveall",           HandleSaveAllCommand,           rbac::RBAC_PERM_COMMAND_SAVEALL,           Console::Yes },
            { "kick",              HandleKickPlayerCommand,        rbac::RBAC_PERM_COMMAND_KICK,              Console::Yes },
            { "unstuck",           HandleUnstuckCommand,           rbac::RBAC_PERM_COMMAND_UNSTUCK,           Console::Yes },
            { "linkgrave",         HandleLinkGraveCommand,         rbac::RBAC_PERM_COMMAND_LINKGRAVE,         Console::No  },
            { "neargrave",         HandleNearGraveCommand,         rbac::RBAC_PERM_COMMAND_NEARGRAVE,         Console::No  },
            { "showarea",          HandleShowAreaCommand,          rbac::RBAC_PERM_COMMAND_SHOWAREA,          Console::No  },
            { "hidearea",          HandleHideAreaCommand,          rbac::RBAC_PERM_COMMAND_HIDEAREA,          Console::No  },
            { "additem",           HandleAddItemCommand,           rbac::RBAC_PERM_COMMAND_ADDITEM,           Console::Yes },
            { "additem set",       HandleAddItemSetCommand,        rbac::RBAC_PERM_COMMAND_ADDITEMSET,        Console::No  },
            { "wchange",           HandleChangeWeather,            rbac::RBAC_PERM_COMMAND_WCHANGE,           Console::No  },
            { "maxskill",          HandleMaxSkillCommand,          rbac::RBAC_PERM_COMMAND_MAXSKILL,          Console::No  },
            { "setskill",          HandleSetSkillCommand,          rbac::RBAC_PERM_COMMAND_SETSKILL,          Console::No  },
            { "pinfo",             HandlePInfoCommand,             rbac::RBAC_PERM_COMMAND_PINFO,             Console::Yes },
            { "respawn",           HandleRespawnCommand,           rbac::RBAC_PERM_COMMAND_RESPAWN,           Console::No  },
            { "respawn all",       HandleRespawnAllCommand,        rbac::RBAC_PERM_COMMAND_RESPAWN_ALL,       Console::No  },
            { "respawn creature guid",    HandleRespawnCreatureByGuidCommand,    rbac::RBAC_PERM_COMMAND_RESPAWN_CREATURE_GUID,    Console::Yes },
            { "respawn gameobject guid",  HandleRespawnGameObjectByGuidCommand,  rbac::RBAC_PERM_COMMAND_RESPAWN_GAMEOBJECT_GUID,  Console::Yes },
            { "respawn creature entry",   HandleRespawnCreatureByEntryCommand,   rbac::RBAC_PERM_COMMAND_RESPAWN_CREATURE_ENTRY,   Console::Yes },
            { "respawn gameobject entry", HandleRespawnGameObjectByEntryCommand, rbac::RBAC_PERM_COMMAND_RESPAWN_GAMEOBJECT_ENTRY, Console::Yes },
            { "mute",              HandleMuteCommand,              rbac::RBAC_PERM_COMMAND_MUTE,              Console::Yes },
            { "mutehistory",       HandleMuteInfoCommand,          rbac::RBAC_PERM_COMMAND_MUTEHISTORY,       Console::Yes },
            { "unmute",            HandleUnmuteCommand,            rbac::RBAC_PERM_COMMAND_UNMUTE,            Console::Yes },
            { "movegens",          HandleMovegensCommand,          rbac::RBAC_PERM_COMMAND_MOVEGENS,          Console::No  },
            { "cometome",          HandleComeToMeCommand,          rbac::RBAC_PERM_COMMAND_COMETOME,          Console::No  },
            { "damage",            HandleDamageCommand,            rbac::RBAC_PERM_COMMAND_DAMAGE,            Console::No  },
            { "combatstop",        HandleCombatStopCommand,        rbac::RBAC_PERM_COMMAND_COMBATSTOP,        Console::Yes },
            { "flusharenapoints",  HandleFlushArenaPointsCommand,  rbac::RBAC_PERM_COMMAND_FLUSHARENAPOINTS,  Console::Yes },
            { "freeze",            HandleFreezeCommand,            rbac::RBAC_PERM_COMMAND_FREEZE,            Console::No  },
            { "unfreeze",          HandleUnFreezeCommand,          rbac::RBAC_PERM_COMMAND_UNFREEZE,          Console::No  },
            { "possess",           HandlePossessCommand,           rbac::RBAC_PERM_COMMAND_POSSESS,           Console::No  },
            { "unpossess",         HandleUnPossessCommand,         rbac::RBAC_PERM_COMMAND_UNPOSSESS,         Console::No  },
            { "bindsight",         HandleBindSightCommand,         rbac::RBAC_PERM_COMMAND_BINDSIGHT,         Console::No  },
            { "unbindsight",       HandleUnbindSightCommand,       rbac::RBAC_PERM_COMMAND_UNBINDSIGHT,       Console::No  },
            { "playall",           HandlePlayAllCommand,           rbac::RBAC_PERM_COMMAND_PLAYALL,           Console::No  },
            { "skirmish",          HandleSkirmishCommand,          rbac::RBAC_PERM_COMMAND_SKIRMISH,          Console::No  },
            { "mailbox",           HandleMailBoxCommand,           rbac::RBAC_PERM_COMMAND_MAILBOX,           Console::No  },
            { "string",            HandleStringCommand,            rbac::RBAC_PERM_COMMAND_STRING,            Console::No  },
            { "opendoor",          HandleOpenDoorCommand,          rbac::RBAC_PERM_COMMAND_OPENDOOR,          Console::No  },
            { "bm",                HandleBMCommand,                rbac::RBAC_PERM_COMMAND_BEASTMASTER,       Console::No  },
            { "packetlog",         HandlePacketLog,                rbac::RBAC_PERM_COMMAND_PACKETLOG,         Console::Yes }
        };
 
        return commandTable;
    }

◆ HandleAddItemCommand()

static bool misc_commandscript::HandleAddItemCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	player,
		ItemTemplate const *	itemTemplate,
		Optional< int32 >	_count
	)

inlinestatic

    {
        if (!sObjectMgr->GetItemTemplate(itemTemplate->ItemId))
        {
            handler->SendErrorMessage(LANG_COMMAND_ITEMIDINVALID, itemTemplate->ItemId);
            return false;
        }
 
        uint32 itemId = itemTemplate->ItemId;
        int32 count = 1;
 
        if (_count)
            count = *_count;
 
        if (!count)
            count = 1;
 
        if (!player)
            player = PlayerIdentifier::FromTargetOrSelf(handler);
 
        if (!player)
            return false;
 
        Player* playerTarget = player->GetConnectedPlayer();
 
        // Subtract
        if (count < 0)
        {
            uint32 removeCount = uint32(-count);
 
            if (playerTarget)
            {
                // Only have scam check on player accounts
                if (playerTarget->GetSession()->GetSecurity() == SEC_PLAYER)
                {
                    if (!playerTarget->HasItemCount(itemId, 0))
                    {
                        // output that player don't have any items to destroy
                        handler->SendErrorMessage(LANG_REMOVEITEM_FAILURE, handler->GetNameLink(playerTarget), itemId);
                        return false;
                    }
 
                    if (!playerTarget->HasItemCount(itemId, removeCount))
                    {
                        // output that player don't have as many items that you want to destroy
                        handler->SendErrorMessage(LANG_REMOVEITEM_ERROR, handler->GetNameLink(playerTarget), itemId);
                        return false;
                    }
                }
 
                // output successful amount of destroyed items
                playerTarget->DestroyItemCount(itemId, removeCount, true, false);
                handler->PSendSysMessage(LANG_REMOVEITEM, itemId, removeCount, handler->GetNameLink(playerTarget));
                return true;
            }
 
            // offline target: remove the items directly from the DB
            if (handler->HasLowerSecurity(nullptr, player->GetGUID()))
                return false;
 
            std::string nameLink = handler->playerLink(player->GetName());
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_INVENTORY_STACKS_BY_ENTRY_AND_OWNER);
            stmt->SetData(0, itemId);
            stmt->SetData(1, player->GetGUID().GetCounter());
            PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
            std::vector<std::pair<ObjectGuid::LowType, uint32>> stacks;
            uint32 totalCount = 0;
            if (result)
            {
                do
                {
                    Field* fields = result->Fetch();
                    stacks.emplace_back(fields[0].Get<uint32>(), fields[1].Get<uint32>());
                    totalCount += fields[1].Get<uint32>();
                } while (result->NextRow());
            }
 
            if (!totalCount)
            {
                handler->SendErrorMessage(LANG_REMOVEITEM_FAILURE, nameLink, itemId);
                return false;
            }
 
            // Only have scam check on player accounts
            uint32 accountId = sCharacterCache->GetCharacterAccountIdByGuid(player->GetGUID());
            if (AccountMgr::GetSecurity(accountId, realm.Id.Realm) == SEC_PLAYER && totalCount < removeCount)
            {
                handler->SendErrorMessage(LANG_REMOVEITEM_ERROR, nameLink, itemId);
                return false;
            }
 
            CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
            uint32 remaining = removeCount;
            for (auto const& [itemGuid, stackCount] : stacks)
            {
                if (!remaining)
                    break;
 
                if (stackCount <= remaining)
                {
                    remaining -= stackCount;
                    Item::DeleteFromInventoryDB(trans, itemGuid);
                    Item::DeleteFromDB(trans, itemGuid);
 
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GIFT);
                    stmt->SetData(0, itemGuid);
                    trans->Append(stmt);
 
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_REFUND_INSTANCE);
                    stmt->SetData(0, itemGuid);
                    trans->Append(stmt);
 
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_BOP_TRADE);
                    stmt->SetData(0, itemGuid);
                    trans->Append(stmt);
 
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEMCONTAINER_CONTAINER);
                    stmt->SetData(0, itemGuid);
                    trans->Append(stmt);
                }
                else
                {
                    stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_COUNT);
                    stmt->SetData(0, stackCount - remaining);
                    stmt->SetData(1, itemGuid);
                    trans->Append(stmt);
                    remaining = 0;
                }
            }
            CharacterDatabase.CommitTransaction(trans);
 
            handler->PSendSysMessage(LANG_REMOVEITEM, itemId, removeCount - remaining, nameLink);
            return true;
        }
 
        // Adding items requires the target to be online
        if (!playerTarget)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        // Adding items
        uint32 noSpaceForCount = 0;
 
        // check space and find places
        ItemPosCountVec dest;
        InventoryResult msg = playerTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemId, count, &noSpaceForCount);
 
        if (msg != EQUIP_ERR_OK) // convert to possible store amount
            count -= noSpaceForCount;
 
        if (!count || dest.empty()) // can't add any
        {
            handler->SendErrorMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
            return false;
        }
 
        Item* item = playerTarget->StoreNewItem(dest, itemId, true);
 
        Player* p = handler->GetSession() ? handler->GetSession()->GetPlayer() : nullptr;
        // remove binding (let GM give it to another player later)
        if (p && p == playerTarget)
        {
            for (auto const& itemPos : dest)
            {
                if (Item* item1 = p->GetItemByPos(itemPos.pos))
                {
                    item1->SetBinding(false);
                }
            }
        }
 
        if (p && count && item)
        {
            p->SendNewItem(item, count, false, true);
 
            if (p != playerTarget)
            {
                playerTarget->SendNewItem(item, count, true, false);
            }
        }
 
        if (noSpaceForCount)
            handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
 
        return true;
    }

References Player::CanStoreNewItem(), CHAR_DEL_GIFT, CHAR_DEL_ITEM_BOP_TRADE, CHAR_DEL_ITEM_REFUND_INSTANCE, CHAR_DEL_ITEMCONTAINER_CONTAINER, CHAR_SEL_CHAR_INVENTORY_STACKS_BY_ENTRY_AND_OWNER, CHAR_UPD_ITEM_COUNT, CharacterDatabase, Item::DeleteFromDB(), Item::DeleteFromInventoryDB(), Player::DestroyItemCount(), EQUIP_ERR_OK, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Field::Get(), Player::GetItemByPos(), ChatHandler::GetNameLink(), WorldSession::GetPlayer(), WorldSession::GetSecurity(), AccountMgr::GetSecurity(), ChatHandler::GetSession(), Player::GetSession(), Player::HasItemCount(), ChatHandler::HasLowerSecurity(), Realm::Id, ItemTemplate::ItemId, LANG_COMMAND_ITEMIDINVALID, LANG_ITEM_CANNOT_CREATE, LANG_PLAYER_NOT_FOUND, LANG_REMOVEITEM, LANG_REMOVEITEM_ERROR, LANG_REMOVEITEM_FAILURE, NULL_BAG, NULL_SLOT, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), realm, RealmHandle::Realm, sCharacterCache, SEC_PLAYER, ChatHandler::SendErrorMessage(), Player::SendNewItem(), PreparedStatementBase::SetData(), sObjectMgr, and Player::StoreNewItem().

Referenced by GetCommands().

◆ HandleAddItemSetCommand()

static bool misc_commandscript::HandleAddItemSetCommand	(	ChatHandler *	handler,
		Variant< Hyperlink< itemset >, uint32 >	itemSetId
	)

inlinestatic

    {
        // prevent generation all items with itemset field value '0'
        if (!*itemSetId)
        {
            handler->SendErrorMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND, uint32(itemSetId));
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
        Player* playerTarget = handler->getSelectedPlayer();
 
        if (!playerTarget)
        {
            playerTarget = player;
        }
 
        bool found = false;
 
        for (auto const& [itemid, itemTemplate] : *sObjectMgr->GetItemTemplateStore())
        {
            if (itemTemplate.ItemSet == uint32(itemSetId))
            {
                found = true;
                ItemPosCountVec dest;
                InventoryResult msg = playerTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemTemplate.ItemId, 1);
 
                if (msg == EQUIP_ERR_OK)
                {
                    Item* item = playerTarget->StoreNewItem(dest, itemTemplate.ItemId, true);
 
                    // remove binding (let GM give it to another player later)
                    if (player == playerTarget)
                    {
                        item->SetBinding(false);
                    }
 
                    player->SendNewItem(item, 1, false, true);
 
                    if (player != playerTarget)
                    {
                        playerTarget->SendNewItem(item, 1, true, false);
                    }
                }
                else
                {
                    player->SendEquipError(msg, nullptr, nullptr, itemTemplate.ItemId);
                    handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemTemplate.ItemId, 1);
                }
            }
        }
 
        if (!found)
        {
            handler->SendErrorMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND, uint32(itemSetId));
            return false;
        }
 
        return true;
    }

References Player::CanStoreNewItem(), EQUIP_ERR_OK, WorldSession::GetPlayer(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSession(), LANG_ITEM_CANNOT_CREATE, LANG_NO_ITEMS_FROM_ITEMSET_FOUND, NULL_BAG, NULL_SLOT, ChatHandler::PSendSysMessage(), Player::SendEquipError(), ChatHandler::SendErrorMessage(), Player::SendNewItem(), Item::SetBinding(), sObjectMgr, and Player::StoreNewItem().

Referenced by GetCommands().

◆ HandleAppearCommand()

static bool misc_commandscript::HandleAppearCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTarget(handler);
        }
 
        if (!target)
        {
            return false;
        }
 
        Player* _player = handler->GetSession()->GetPlayer();
        if (target->GetGUID() == _player->GetGUID())
        {
            handler->SendErrorMessage(LANG_CANT_TELEPORT_SELF);
            return false;
        }
 
        std::string nameLink = handler->playerLink(target->GetName());
 
        if (target->IsConnected())
        {
            auto targetPlayer = target->GetConnectedPlayer();
 
            // check online security
            if (handler->HasLowerSecurity(targetPlayer))
            {
                return false;
            }
 
            Map* map = targetPlayer->GetMap();
            if (map->IsBattlegroundOrArena())
            {
                // only allow if gm mode is on
                if (!_player->IsGameMaster())
                {
                    handler->SendErrorMessage(LANG_CANNOT_GO_TO_BG_GM, nameLink);
                    return false;
                }
 
                if (!_player->GetMap()->IsBattlegroundOrArena())
                {
                    _player->SetEntryPoint();
                }
 
                _player->SetBattlegroundId(targetPlayer->GetBattlegroundId(), targetPlayer->GetBattlegroundTypeId(), PLAYER_MAX_BATTLEGROUND_QUEUES, false, false, TEAM_NEUTRAL);
            }
            else if (map->IsDungeon())
            {
                // we have to go to instance, and can go to player only if:
                //   1) we are in his group (either as leader or as member)
                //   2) we are not bound to any group and have GM mode on
                if (_player->GetGroup())
                {
                    // we are in group, we can go only if we are in the player group
                    if (_player->GetGroup() != targetPlayer->GetGroup())
                    {
                        handler->SendErrorMessage(LANG_CANNOT_GO_TO_INST_PARTY, nameLink);
                        return false;
                    }
                }
                else
                {
                    // we are not in group, let's verify our GM mode
                    if (!_player->IsGameMaster())
                    {
                        handler->SendErrorMessage(LANG_CANNOT_GO_TO_INST_GM, nameLink);
                        return false;
                    }
                }
 
                // if the GM is bound to another instance, he will not be bound to another one
                InstancePlayerBind* bind = sInstanceSaveMgr->PlayerGetBoundInstance(_player->GetGUID(), targetPlayer->GetMapId(), targetPlayer->GetDifficulty(map->IsRaid()));
                if (!bind)
                {
                    if (InstanceSave* save = sInstanceSaveMgr->GetInstanceSave(target->GetConnectedPlayer()->GetInstanceId()))
                    {
                        sInstanceSaveMgr->PlayerBindToInstance(_player->GetGUID(), save, !save->CanReset(), _player);
                    }
                }
 
                if (map->IsRaid())
                {
                    _player->SetRaidDifficulty(targetPlayer->GetRaidDifficulty());
                }
                else
                {
                    _player->SetDungeonDifficulty(targetPlayer->GetDungeonDifficulty());
                }
            }
 
            handler->PSendSysMessage(LANG_APPEARING_AT, nameLink);
 
            // stop flight if need
            if (_player->IsInFlight())
            {
                _player->GetMotionMaster()->MovementExpired();
                _player->CleanupAfterTaxiFlight();
            }
            else // save only in non-flight case
                _player->SaveRecallPosition();
 
            if (Transport* transport = targetPlayer->GetTransport())
            {
                if (Transport* oldTransport = _player->GetTransport())
                    oldTransport->RemovePassenger(_player, true);
 
                float x;
                float y;
                float z;
                float o;
                targetPlayer->m_movementInfo.transport.pos.GetPosition(x, y, z, o);
 
                _player->SetTransport(transport);
                _player->m_movementInfo.transport.guid = transport->GetGUID();
                _player->m_movementInfo.transport.pos.Relocate(x, y, z, o);
                _player->AddUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT);
 
                float worldX = x;
                float worldY = y;
                float worldZ = z;
                float worldO = o;
                transport->CalculatePassengerPosition(worldX, worldY, worldZ, &worldO);
 
                transport->AddPassenger(_player, false);
 
                if (_player->TeleportTo(transport->GetMapId(), worldX, worldY, worldZ + 0.25f, worldO, TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_GM_MODE, targetPlayer))
                    _player->SetPhaseMask(targetPlayer->GetPhaseMask() | 1, false);
            }
            else
            {
                if (_player->TeleportTo(targetPlayer->GetMapId(), targetPlayer->GetPositionX(), targetPlayer->GetPositionY(), targetPlayer->GetPositionZ() + 0.25f, _player->GetOrientation(), TELE_TO_GM_MODE, targetPlayer))
                    _player->SetPhaseMask(targetPlayer->GetPhaseMask() | 1, false);
            }
        }
        else
        {
            // check offline security
            if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
            {
                return false;
            }
 
            handler->PSendSysMessage(LANG_APPEARING_AT, nameLink);
 
            // to point where player stay (if loaded)
            float x, y, z, o;
            uint32 map;
            bool in_flight;
 
            if (!Player::LoadPositionFromDB(map, x, y, z, o, in_flight, target->GetGUID().GetCounter()))
            {
                return false;
            }
 
            // stop flight if need
            if (_player->IsInFlight())
            {
                _player->GetMotionMaster()->MovementExpired();
                _player->CleanupAfterTaxiFlight();
            }
            // save only in non-flight case
            else
            {
                _player->SaveRecallPosition();
            }
 
            _player->TeleportTo(map, x, y, z, _player->GetOrientation());
        }
 
        return true;
    }

References Unit::AddUnitMovementFlag(), Player::CleanupAfterTaxiFlight(), Acore::ChatCommands::PlayerIdentifier::FromTarget(), Player::GetGroup(), Object::GetGUID(), WorldObject::GetMap(), Unit::GetMotionMaster(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), WorldObject::GetTransport(), MovementInfo::TransportInfo::guid, ChatHandler::HasLowerSecurity(), Map::IsBattlegroundOrArena(), Map::IsDungeon(), Player::IsGameMaster(), Unit::IsInFlight(), Map::IsRaid(), LANG_APPEARING_AT, LANG_CANNOT_GO_TO_BG_GM, LANG_CANNOT_GO_TO_INST_GM, LANG_CANNOT_GO_TO_INST_PARTY, LANG_CANT_TELEPORT_SELF, Player::LoadPositionFromDB(), WorldObject::m_movementInfo, MotionMaster::MovementExpired(), MOVEMENTFLAG_ONTRANSPORT, PLAYER_MAX_BATTLEGROUND_QUEUES, ChatHandler::playerLink(), MovementInfo::TransportInfo::pos, ChatHandler::PSendSysMessage(), Position::Relocate(), Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), Player::SetBattlegroundId(), Player::SetDungeonDifficulty(), Player::SetEntryPoint(), Unit::SetPhaseMask(), Player::SetRaidDifficulty(), WorldObject::SetTransport(), sInstanceSaveMgr, TEAM_NEUTRAL, TELE_TO_GM_MODE, TELE_TO_NOT_LEAVE_TRANSPORT, Player::TeleportTo(), and MovementInfo::transport.

Referenced by GetCommands().

◆ HandleAuraCommand()

static bool misc_commandscript::HandleAuraCommand	(	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;
        }
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        Aura::TryRefreshStackOrCreate(spell, MAX_EFFECT_MASK, target, target);
 
        return true;
    }

References ChatHandler::getSelectedUnit(), SpellInfo::Id, SpellMgr::IsSpellValid(), LANG_COMMAND_NOSPELLFOUND, LANG_COMMAND_SPELL_BROKEN, LANG_SELECT_CHAR_OR_CREATURE, MAX_EFFECT_MASK, ChatHandler::SendErrorMessage(), and Aura::TryRefreshStackOrCreate().

Referenced by GetCommands().

◆ HandleAuraStacksCommand()

static bool misc_commandscript::HandleAuraStacksCommand	(	ChatHandler *	handler,
		SpellInfo const *	spell,
		int16	stacks
	)

inlinestatic

    {
        if (!spell)
        {
            handler->SendErrorMessage(LANG_COMMAND_NOSPELLFOUND);
            return false;
        }
 
        if (!SpellMgr::IsSpellValid(spell))
        {
            handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
            return false;
        }
 
        if (!stacks)
        {
            handler->SendErrorMessage(LANG_COMMAND_AURASTACK_NO_STACK);
            return false;
        }
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        Aura* aur = target->GetAura(spell->Id);
        if (!aur)
        {
            handler->SendErrorMessage(LANG_COMMAND_AURASTACK_NO_AURA, spell->Id);
            return false;
        }
 
        if (!spell->StackAmount)
        {
            handler->SendErrorMessage(LANG_COMMAND_AURASTACK_CANT_STACK, spell->Id);
            return false;
        }
 
        aur->ModStackAmount(stacks);
 
        return true;
    }

References Unit::GetAura(), ChatHandler::getSelectedUnit(), SpellInfo::Id, SpellMgr::IsSpellValid(), LANG_COMMAND_AURASTACK_CANT_STACK, LANG_COMMAND_AURASTACK_NO_AURA, LANG_COMMAND_AURASTACK_NO_STACK, LANG_COMMAND_NOSPELLFOUND, LANG_COMMAND_SPELL_BROKEN, LANG_SELECT_CHAR_OR_CREATURE, Aura::ModStackAmount(), ChatHandler::SendErrorMessage(), and SpellInfo::StackAmount.

Referenced by GetCommands().

◆ HandleBindSightCommand()

static bool misc_commandscript::HandleBindSightCommand ( ChatHandler * handler )

inlinestatic

    {
        Unit* unit = handler->getSelectedUnit();
        if (!unit)
        {
            return false;
        }
 
        handler->GetSession()->GetPlayer()->CastSpell(unit, 6277, true);
        return true;
    }

References Unit::CastSpell(), WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), and ChatHandler::GetSession().

Referenced by GetCommands().

◆ HandleBMCommand()

static bool misc_commandscript::HandleBMCommand	(	ChatHandler *	handler,
		Optional< bool >	enableArg
	)

inlinestatic

    {
        WorldSession* session = handler->GetSession();
 
        if (!session)
            return false;
 
        auto SetBMMod = [&](bool enable)
        {
            char const* enabled = "ON";
            char const* disabled = "OFF";
            handler->SendNotification(LANG_COMMAND_BEASTMASTER_MODE, enable ? enabled : disabled);
 
            session->GetPlayer()->SetBeastMaster(enable);
        };
 
        if (!enableArg)
        {
            if (!AccountMgr::IsPlayerAccount(session->GetSecurity()) && session->GetPlayer()->IsDeveloper())
                SetBMMod(true);
            else
                SetBMMod(false);
 
            return true;
        }
 
        if (*enableArg)
        {
            SetBMMod(true);
            return true;
        }
        else
        {
            SetBMMod(false);
            return true;
        }
 
        handler->SendErrorMessage(LANG_USE_BOL);
        return false;
    }

References WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::GetSession(), Player::IsDeveloper(), AccountMgr::IsPlayerAccount(), LANG_COMMAND_BEASTMASTER_MODE, LANG_USE_BOL, ChatHandler::SendErrorMessage(), ChatHandler::SendNotification(), and Player::SetBeastMaster().

Referenced by GetCommands().

◆ HandleChangeWeather()

static bool misc_commandscript::HandleChangeWeather	(	ChatHandler *	handler,
		uint32	type,
		float	grade
	)

inlinestatic

    {
        // Weather is OFF
        if (!sWorld->getBoolConfig(CONFIG_WEATHER))
        {
            handler->SendErrorMessage(LANG_WEATHER_DISABLED);
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
        uint32 zoneid = player->GetZoneId();
 
        Weather* weather = player->GetMap()->GetOrGenerateZoneDefaultWeather(zoneid);
        if (!weather)
        {
            handler->SendErrorMessage(LANG_NO_WEATHER);
            return false;
        }
 
        weather->SetWeather(WeatherType(type), grade);
 
        return true;
    }

References CONFIG_WEATHER, WorldObject::GetMap(), Map::GetOrGenerateZoneDefaultWeather(), WorldSession::GetPlayer(), ChatHandler::GetSession(), WorldObject::GetZoneId(), LANG_NO_WEATHER, LANG_WEATHER_DISABLED, ChatHandler::SendErrorMessage(), Weather::SetWeather(), and sWorld.

Referenced by GetCommands().

◆ HandleCombatStopCommand()

static bool misc_commandscript::HandleCombatStopCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target || !target->IsConnected())
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        // check online security
        if (handler->HasLowerSecurity(playerTarget))
        {
            return false;
        }
 
        playerTarget->CombatStop();
        playerTarget->GetThreatMgr().RemoveMeFromThreatLists();
        return true;
    }

References Unit::CombatStop(), Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Unit::GetThreatMgr(), ChatHandler::HasLowerSecurity(), LANG_PLAYER_NOT_FOUND, ThreatManager::RemoveMeFromThreatLists(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandleComeToMeCommand()

static bool misc_commandscript::HandleComeToMeCommand ( ChatHandler * handler )

inlinestatic

    {
        Creature* caster = handler->getSelectedCreature();
        if (!caster)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
 
        caster->GetMotionMaster()->MovePoint(0, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
 
        return true;
    }

References Unit::GetMotionMaster(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), LANG_SELECT_CREATURE, MotionMaster::MovePoint(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandleCommandsCommand()

static bool misc_commandscript::HandleCommandsCommand ( ChatHandler * handler )

inlinestatic

    {
        SendCommandHelpFor(*handler, "");
        return true;
    }

References Acore::ChatCommands::SendCommandHelpFor().

Referenced by GetCommands().

◆ HandleCommentatorCommand()

static bool misc_commandscript::HandleCommentatorCommand	(	ChatHandler *	handler,
		Optional< bool >	enableArg
	)

inlinestatic

    {
        WorldSession* session = handler->GetSession();
 
        if (!session)
        {
            handler->SendErrorMessage(LANG_USE_BOL);
            return false;
        }
 
        auto SetCommentatorMod = [&](bool enable)
        {
            handler->SendNotification(enable ? "Commentator mode on" : "Commentator mode off");
            session->GetPlayer()->SetCommentator(enable);
        };
 
        if (!enableArg)
        {
            if (!AccountMgr::IsPlayerAccount(session->GetSecurity()) && session->GetPlayer()->IsCommentator())
            {
                SetCommentatorMod(true);
            }
            else
            {
                SetCommentatorMod(false);
            }
 
            return true;
        }
 
        if (*enableArg)
        {
            SetCommentatorMod(true);
            return true;
        }
        else
        {
            SetCommentatorMod(false);
            return true;
        }
    }

References WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::GetSession(), Player::IsCommentator(), AccountMgr::IsPlayerAccount(), LANG_USE_BOL, ChatHandler::SendErrorMessage(), ChatHandler::SendNotification(), and Player::SetCommentator().

Referenced by GetCommands().

◆ HandleCooldownCommand()

static bool misc_commandscript::HandleCooldownCommand	(	ChatHandler *	handler,
		Optional< SpellInfo const * >	spell
	)

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        std::string nameLink = handler->GetNameLink(target);
 
        if (!spell)
        {
            target->RemoveAllSpellCooldown();
            handler->PSendSysMessage(LANG_REMOVEALL_COOLDOWN, nameLink);
        }
        else
        {
            if (!SpellMgr::IsSpellValid(*spell))
            {
                handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell.value()->Id);
                return false;
            }
 
            target->RemoveSpellCooldown(spell.value()->Id, true);
            handler->PSendSysMessage(LANG_REMOVE_COOLDOWN, spell.value()->Id, target == handler->GetSession()->GetPlayer() ? handler->GetAcoreString(LANG_YOU) : nameLink);
        }
        return true;
    }

References ChatHandler::GetAcoreString(), ChatHandler::GetNameLink(), WorldSession::GetPlayer(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSession(), SpellMgr::IsSpellValid(), LANG_COMMAND_SPELL_BROKEN, LANG_PLAYER_NOT_FOUND, LANG_REMOVE_COOLDOWN, LANG_REMOVEALL_COOLDOWN, LANG_YOU, ChatHandler::PSendSysMessage(), Player::RemoveAllSpellCooldown(), Player::RemoveSpellCooldown(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandleDamageCommand()

static bool misc_commandscript::HandleDamageCommand	(	ChatHandler *	handler,
		uint32	damage,
		Optional< std::string >	percent
	)

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
        if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        if (target->IsPlayer())
            if (handler->HasLowerSecurity(target->ToPlayer()))
                return false;
 
        if (!target->IsAlive() || !damage)
            return true;
 
        if (target->IsCreature() && handler->GetSession()->GetSecurity() == SEC_CONSOLE) // pussywizard
            target->ToCreature()->LowerPlayerDamageReq(target->GetMaxHealth());
 
        if (percent)
            if (StringStartsWith("pct", *percent))
                if (damage <= 100)
                    damage = target->CountPctFromMaxHealth(damage);
 
        Unit::DealDamage(handler->GetSession()->GetPlayer(), target, damage, nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false, true);
 
        if (target != handler->GetSession()->GetPlayer())
            handler->GetSession()->GetPlayer()->SendAttackStateUpdate(HITINFO_AFFECTS_VICTIM, target, 1, SPELL_SCHOOL_MASK_NORMAL, damage, 0, 0, VICTIMSTATE_HIT, 0);
 
        return true;
    }

References Unit::CountPctFromMaxHealth(), Unit::DealDamage(), DIRECT_DAMAGE, Unit::GetMaxHealth(), WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), Unit::GetTarget(), ChatHandler::HasLowerSecurity(), HITINFO_AFFECTS_VICTIM, Unit::IsAlive(), Object::IsCreature(), Object::IsPlayer(), LANG_SELECT_CHAR_OR_CREATURE, Creature::LowerPlayerDamageReq(), SEC_CONSOLE, Unit::SendAttackStateUpdate(), ChatHandler::SendErrorMessage(), SPELL_SCHOOL_MASK_NORMAL, StringStartsWith(), Object::ToCreature(), Object::ToPlayer(), and VICTIMSTATE_HIT.

Referenced by GetCommands().

◆ HandleDevCommand()

static bool misc_commandscript::HandleDevCommand	(	ChatHandler *	handler,
		Optional< bool >	enableArg
	)

inlinestatic

    {
        WorldSession* session = handler->GetSession();
 
        if (!session)
        {
            handler->SendErrorMessage(LANG_USE_BOL);
            return false;
        }
 
        auto SetDevMod = [&](bool enable)
        {
            handler->SendNotification(enable ? LANG_DEV_ON : LANG_DEV_OFF);
            session->GetPlayer()->SetDeveloper(enable);
            sScriptMgr->OnHandleDevCommand(handler->GetSession()->GetPlayer(), enable);
        };
 
        if (!enableArg)
        {
            if (!AccountMgr::IsPlayerAccount(session->GetSecurity()) && session->GetPlayer()->IsDeveloper())
            {
                SetDevMod(true);
            }
            else
            {
                SetDevMod(false);
            }
 
            return true;
        }
 
        if (*enableArg)
        {
            SetDevMod(true);
            return true;
        }
        else
        {
            SetDevMod(false);
            return true;
        }
    }

References WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::GetSession(), Player::IsDeveloper(), AccountMgr::IsPlayerAccount(), LANG_DEV_OFF, LANG_DEV_ON, LANG_USE_BOL, ChatHandler::SendErrorMessage(), ChatHandler::SendNotification(), Player::SetDeveloper(), and sScriptMgr.

Referenced by GetCommands().

◆ HandleDieCommand()

static bool misc_commandscript::HandleDieCommand ( ChatHandler * handler )

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
 
        if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        if (target->IsPlayer())
        {
            if (handler->HasLowerSecurity(target->ToPlayer()))
            {
                return false;
            }
        }
 
        if (target->IsAlive())
        {
            if (sWorld->getBoolConfig(CONFIG_DIE_COMMAND_MODE))
            {
                if (target->IsCreature() && handler->GetSession()->GetSecurity() == SEC_CONSOLE) // pussywizard
                {
                    target->ToCreature()->LowerPlayerDamageReq(target->GetMaxHealth());
                }
                Unit::Kill(handler->GetSession()->GetPlayer(), target);
            }
            else
            {
                Unit::DealDamage(handler->GetSession()->GetPlayer(), target, target->GetHealth(), nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false, true);
            }
        }
 
        return true;
    }

References CONFIG_DIE_COMMAND_MODE, Unit::DealDamage(), DIRECT_DAMAGE, Unit::GetHealth(), Unit::GetMaxHealth(), WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), Unit::GetTarget(), ChatHandler::HasLowerSecurity(), Unit::IsAlive(), Object::IsCreature(), Object::IsPlayer(), Unit::Kill(), LANG_SELECT_CHAR_OR_CREATURE, Creature::LowerPlayerDamageReq(), SEC_CONSOLE, ChatHandler::SendErrorMessage(), SPELL_SCHOOL_MASK_NORMAL, sWorld, Object::ToCreature(), and Object::ToPlayer().

Referenced by GetCommands().

◆ HandleDismountCommand()

static bool misc_commandscript::HandleDismountCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        // If player is not mounted, so go out :)
        if (!player->IsMounted())
        {
            handler->SendErrorMessage(LANG_CHAR_NON_MOUNTED);
            return false;
        }
 
        if (player->IsInFlight())
        {
            handler->SendErrorMessage(LANG_YOU_IN_FLIGHT);
            return false;
        }
 
        player->Dismount();
        player->RemoveAurasByType(SPELL_AURA_MOUNTED);
        player->SetSpeed(MOVE_RUN, 1, true);
        player->SetSpeed(MOVE_FLIGHT, 1, true);
        return true;
    }

References Unit::Dismount(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Unit::IsInFlight(), Unit::IsMounted(), LANG_CHAR_NON_MOUNTED, LANG_YOU_IN_FLIGHT, MOVE_FLIGHT, MOVE_RUN, Unit::RemoveAurasByType(), ChatHandler::SendErrorMessage(), Unit::SetSpeed(), and SPELL_AURA_MOUNTED.

Referenced by GetCommands().

◆ HandleFlushArenaPointsCommand()

static bool misc_commandscript::HandleFlushArenaPointsCommand ( ChatHandler * )

inlinestatic

    {
        sArenaTeamMgr->DistributeArenaPoints();
        return true;
    }

References sArenaTeamMgr.

Referenced by GetCommands().

◆ HandleFreezeCommand()

static bool misc_commandscript::HandleFreezeCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        Creature* creatureTarget = handler->getSelectedCreature();
 
        if (!target && !creatureTarget)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target && !creatureTarget)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
        if (playerTarget && !creatureTarget)
        {
            handler->PSendSysMessage(LANG_COMMAND_FREEZE, target->GetName());
 
            if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_FREEZE))
            {
                Aura::TryRefreshStackOrCreate(spellInfo, MAX_EFFECT_MASK, playerTarget, playerTarget);
            }
 
            return true;
        }
        else if (creatureTarget && creatureTarget->IsAlive())
        {
            handler->PSendSysMessage(LANG_COMMAND_FREEZE, GetLocalizeCreatureName(creatureTarget, handler->GetSessionDbcLocale()));
 
            if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_FREEZE))
            {
                Aura::TryRefreshStackOrCreate(spellInfo, MAX_EFFECT_MASK, creatureTarget, creatureTarget);
            }
 
            return true;
        }
 
        handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
        return false;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), GetLocalizeCreatureName(), ChatHandler::getSelectedCreature(), ChatHandler::GetSessionDbcLocale(), Unit::IsAlive(), LANG_COMMAND_FREEZE, LANG_SELECT_CHAR_OR_CREATURE, MAX_EFFECT_MASK, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), SPELL_FREEZE, sSpellMgr, and Aura::TryRefreshStackOrCreate().

Referenced by GetCommands().

◆ HandleGetDistanceCommand()

static bool misc_commandscript::HandleGetDistanceCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        WorldObject* object = handler->getSelectedUnit();
 
        if (!object && !target)
        {
            return false;
        }
 
        if (!object && target && target->IsConnected())
        {
            object = target->GetConnectedPlayer();
        }
 
        if (!object)
        {
            return false;
        }
 
        handler->PSendSysMessage(LANG_DISTANCE, handler->GetSession()->GetPlayer()->GetDistance(object), handler->GetSession()->GetPlayer()->GetDistance2d(object), handler->GetSession()->GetPlayer()->GetExactDist(object), handler->GetSession()->GetPlayer()->GetExactDist2d(object));
        return true;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), WorldObject::GetDistance(), WorldObject::GetDistance2d(), Position::GetExactDist(), Position::GetExactDist2d(), WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), LANG_DISTANCE, and ChatHandler::PSendSysMessage().

Referenced by GetCommands().

◆ HandleGPSCommand()

static bool misc_commandscript::HandleGPSCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        WorldObject* object = handler->getSelectedUnit();
 
        if (!object && !target)
        {
            return false;
        }
 
        if (!object && target && target->IsConnected())
        {
            object = target->GetConnectedPlayer();
        }
 
        if (!object)
        {
            return false;
        }
 
        CellCoord const cellCoord = Acore::ComputeCellCoord(object->GetPositionX(), object->GetPositionY());
        Cell cell(cellCoord);
 
        uint32 zoneId, areaId;
        object->GetZoneAndAreaId(zoneId, areaId);
 
        MapEntry const* mapEntry = sMapStore.LookupEntry(object->GetMapId());
        AreaTableEntry const* zoneEntry = sAreaTableStore.LookupEntry(zoneId);
        AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
 
        float zoneX = object->GetPositionX();
        float zoneY = object->GetPositionY();
 
        Map2ZoneCoordinates(zoneX, zoneY, zoneId);
 
        float groundZ = object->GetMapHeight(object->GetPositionX(), object->GetPositionY(), MAX_HEIGHT);
        float floorZ = object->GetMapHeight(object->GetPositionX(), object->GetPositionY(), object->GetPositionZ());
 
        uint32 haveMap = GridTerrainLoader::ExistMap(object->GetMapId(), cell.GridX(), cell.GridY()) ? 1 : 0;
        uint32 haveVMap = GridTerrainLoader::ExistVMap(object->GetMapId(), cell.GridX(), cell.GridY()) ? 1 : 0;
        uint32 haveMMAP = handler->GetSession()->GetPlayer()->GetMap()->GetMapCollisionData().GetMMapData().GetNavMesh() ? 1 : 0;
 
        if (haveVMap)
        {
            if (object->IsOutdoors())
            {
                handler->PSendSysMessage("You are outdoors");
            }
            else
            {
                handler->PSendSysMessage("You are indoors");
            }
        }
        else
        {
            handler->PSendSysMessage("no VMAP available for area info");
        }
 
        handler->PSendSysMessage(LANG_MAP_POSITION,
                                 object->GetMapId(), (mapEntry ? mapEntry->name[handler->GetSessionDbcLocale()] : "<unknown>"),
                                 zoneId, (zoneEntry ? zoneEntry->area_name[handler->GetSessionDbcLocale()] : "<unknown>"),
                                 areaId, (areaEntry ? areaEntry->area_name[handler->GetSessionDbcLocale()] : "<unknown>"),
                                 object->GetPhaseMask(),
                                 object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), object->GetOrientation(),
                                 cell.GridX(), cell.GridY(), cell.CellX(), cell.CellY(), object->GetInstanceId(),
                                 zoneX, zoneY, groundZ, floorZ, haveMap, haveVMap, haveMMAP);
 
        LiquidData const& liquidData = object->GetLiquidData();
 
        if (liquidData.Status)
        {
            handler->PSendSysMessage(LANG_LIQUID_STATUS, liquidData.Level, liquidData.DepthLevel, liquidData.Entry, liquidData.Flags, liquidData.Status);
        }
 
        if (object->GetTransport())
        {
            handler->PSendSysMessage("Transport offset: {:0.2f}, {:0.2f}, {:0.2f}, {:0.2f}", object->m_movementInfo.transport.pos.GetPositionX(), object->m_movementInfo.transport.pos.GetPositionY(), object->m_movementInfo.transport.pos.GetPositionZ(), object->m_movementInfo.transport.pos.GetOrientation());
        }
 
        return true;
    }

References AreaTableEntry::area_name, Cell::CellX(), Cell::CellY(), Acore::ComputeCellCoord(), LiquidData::DepthLevel, LiquidData::Entry, GridTerrainLoader::ExistMap(), GridTerrainLoader::ExistVMap(), LiquidData::Flags, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), WorldObject::GetMap(), Map::GetMapCollisionData(), WorldLocation::GetMapId(), MapCollisionData::GetMMapData(), MMapData::GetNavMesh(), WorldObject::GetPhaseMask(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), ChatHandler::GetSessionDbcLocale(), WorldObject::GetTransport(), Cell::GridX(), Cell::GridY(), WorldObject::IsOutdoors(), LANG_LIQUID_STATUS, LANG_MAP_POSITION, LiquidData::Level, WorldObject::m_movementInfo, Map2ZoneCoordinates(), MAX_HEIGHT, MapEntry::name, MovementInfo::TransportInfo::pos, ChatHandler::PSendSysMessage(), sAreaTableStore, sMapStore, LiquidData::Status, and MovementInfo::transport.

Referenced by GetCommands().

◆ HandleGroupSummonCommand()

static bool misc_commandscript::HandleGroupSummonCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target || !target->IsConnected())
        {
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target->GetConnectedPlayer()))
        {
            return false;
        }
 
        auto targetPlayer = target->GetConnectedPlayer();
 
        Group* group = targetPlayer->GetGroup();
 
        std::string nameLink = handler->playerLink(target->GetName());
 
        if (!group)
        {
            handler->SendErrorMessage(LANG_NOT_IN_GROUP, nameLink);
            return false;
        }
 
        Map* gmMap = handler->GetSession()->GetPlayer()->GetMap();
        bool toInstance = gmMap->Instanceable();
 
        // we are in instance, and can summon only player in our group with us as lead
        if (toInstance && (
                    !handler->GetSession()->GetPlayer()->GetGroup() || (group->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID()) ||
                    (handler->GetSession()->GetPlayer()->GetGroup()->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID())))
            // the last check is a bit excessive, but let it be, just in case
        {
            handler->SendErrorMessage(LANG_CANNOT_SUMMON_TO_INST);
            return false;
        }
 
        for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
        {
            Player* player = itr->GetSource();
 
            if (!player || player == handler->GetSession()->GetPlayer() || !player->GetSession())
            {
                continue;
            }
 
            // check online security
            if (handler->HasLowerSecurity(player))
            {
                return false;
            }
 
            std::string plNameLink = handler->GetNameLink(player);
 
            if (player->IsBeingTeleported())
            {
                handler->SendErrorMessage(LANG_IS_TELEPORTED, plNameLink);
                return false;
            }
 
            if (toInstance)
            {
                Map* playerMap = player->GetMap();
 
                if (playerMap->Instanceable() && playerMap->GetInstanceId() != gmMap->GetInstanceId())
                {
                    // cannot summon from instance to instance
                    handler->SendErrorMessage(LANG_CANNOT_SUMMON_TO_INST, plNameLink);
                    return false;
                }
            }
 
            handler->PSendSysMessage(LANG_SUMMONING, plNameLink, "");
            if (handler->needReportToTarget(player))
            {
                ChatHandler(player->GetSession()).PSendSysMessage(LANG_SUMMONED_BY, handler->GetNameLink());
            }
 
            // stop flight if need
            if (player->IsInFlight())
            {
                player->GetMotionMaster()->MovementExpired();
                player->CleanupAfterTaxiFlight();
            }
            // save only in non-flight case
            else
            {
                player->SaveRecallPosition();
            }
 
            // before GM
            float x, y, z;
            handler->GetSession()->GetPlayer()->GetClosePoint(x, y, z, player->GetObjectSize());
            player->TeleportTo(handler->GetSession()->GetPlayer()->GetMapId(), x, y, z, player->GetOrientation(), 0, handler->GetSession()->GetPlayer());
        }
 
        return true;
    }

References Player::CleanupAfterTaxiFlight(), Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), WorldObject::GetClosePoint(), Group::GetFirstMember(), Player::GetGroup(), Object::GetGUID(), Map::GetInstanceId(), Group::GetLeaderGUID(), WorldObject::GetMap(), WorldLocation::GetMapId(), Unit::GetMotionMaster(), ChatHandler::GetNameLink(), WorldObject::GetObjectSize(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Player::GetSession(), ChatHandler::HasLowerSecurity(), Map::Instanceable(), Player::IsBeingTeleported(), Unit::IsInFlight(), LANG_CANNOT_SUMMON_TO_INST, LANG_IS_TELEPORTED, LANG_NOT_IN_GROUP, LANG_SUMMONED_BY, LANG_SUMMONING, MotionMaster::MovementExpired(), ChatHandler::needReportToTarget(), ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), and Player::TeleportTo().

Referenced by GetCommands().

◆ HandleGUIDCommand()

static bool misc_commandscript::HandleGUIDCommand ( ChatHandler * handler )

inlinestatic

    {
        ObjectGuid guid = handler->GetSession()->GetPlayer()->GetTarget();
 
        if (!guid)
        {
            handler->SendErrorMessage(LANG_NO_SELECTION);
            return false;
        }
 
        handler->PSendSysMessage(LANG_OBJECT_GUID, guid.ToString());
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), Unit::GetTarget(), LANG_NO_SELECTION, LANG_OBJECT_GUID, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and ObjectGuid::ToString().

Referenced by GetCommands().

◆ HandleHelpCommand()

static bool misc_commandscript::HandleHelpCommand	(	ChatHandler *	handler,
		Tail	cmd
	)

inlinestatic

    {
        Acore::ChatCommands::SendCommandHelpFor(*handler, cmd);
 
        if (cmd.empty())
        {
            Acore::ChatCommands::SendCommandHelpFor(*handler, "help");
        }
 
        return true;
    }

References Acore::ChatCommands::SendCommandHelpFor().

Referenced by GetCommands().

◆ HandleHideAreaCommand()

static bool misc_commandscript::HandleHideAreaCommand	(	ChatHandler *	handler,
		uint32	areaID
	)

inlinestatic

    {
        Player* playerTarget = handler->getSelectedPlayer();
        if (!playerTarget)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaID);
        if (!area)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        int32 offset = area->exploreFlag / 32;
        if (offset >= PLAYER_EXPLORED_ZONES_SIZE)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        uint32 val = uint32((1 << (area->exploreFlag % 32)));
        uint32 currFields = playerTarget->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
        playerTarget->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, uint32((currFields ^ val)));
 
        handler->SendSysMessage(LANG_UNEXPLORE_AREA);
        return true;
    }

References AreaTableEntry::exploreFlag, ChatHandler::getSelectedPlayer(), Object::GetUInt32Value(), LANG_BAD_VALUE, LANG_NO_CHAR_SELECTED, LANG_UNEXPLORE_AREA, PLAYER_EXPLORED_ZONES_1, PLAYER_EXPLORED_ZONES_SIZE, sAreaTableStore, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), and Unit::SetUInt32Value().

Referenced by GetCommands().

◆ HandleKickPlayerCommand()

static bool misc_commandscript::HandleKickPlayerCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target,
		Optional< std::string_view >	reason
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target || !target->IsConnected())
        {
            return false;
        }
 
        auto targetPlayer = target->GetConnectedPlayer();
 
        if (handler->GetSession() && target->GetGUID() == handler->GetSession()->GetPlayer()->GetGUID())
        {
            handler->SendErrorMessage(LANG_COMMAND_KICKSELF);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(targetPlayer))
        {
            return false;
        }
 
        std::string kickReasonStr = handler->GetAcoreString(LANG_NO_REASON);
        if (reason && !reason->empty())
        {
            kickReasonStr = std::string{ *reason };
        }
 
        if (sWorld->getBoolConfig(CONFIG_SHOW_KICK_IN_WORLD))
        {
            handler->SendWorldText(LANG_COMMAND_KICKMESSAGE_WORLD, (handler->GetSession() ? handler->GetSession()->GetPlayerName() : "Server"), target->GetName(), kickReasonStr);
        }
        else
        {
            handler->PSendSysMessage(LANG_COMMAND_KICKMESSAGE, target->GetName());
        }
 
        targetPlayer->GetSession()->KickPlayer("HandleKickPlayerCommand");
 
        return true;
    }

References CONFIG_SHOW_KICK_IN_WORLD, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), ChatHandler::GetAcoreString(), Object::GetGUID(), WorldSession::GetPlayer(), WorldSession::GetPlayerName(), ChatHandler::GetSession(), ChatHandler::HasLowerSecurity(), LANG_COMMAND_KICKMESSAGE, LANG_COMMAND_KICKMESSAGE_WORLD, LANG_COMMAND_KICKSELF, LANG_NO_REASON, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), ChatHandler::SendWorldText(), and sWorld.

Referenced by GetCommands().

◆ HandleLinkGraveCommand()

static bool misc_commandscript::HandleLinkGraveCommand	(	ChatHandler *	handler,
		uint32	graveyardId,
		Optional< std::string_view >	team
	)

inlinestatic

    {
        TeamId teamId;
 
        if (!team)
        {
            teamId = TEAM_NEUTRAL;
        }
        else if (StringEqualI(team->substr(0, 6), "horde"))
        {
            teamId = TEAM_HORDE;
        }
        else if (StringEqualI(team->substr(0, 9), "alliance"))
        {
            teamId = TEAM_ALLIANCE;
        }
        else
        {
            return false;
        }
 
        GraveyardStruct const* graveyard = sGraveyard->GetGraveyard(graveyardId);
 
        if (!graveyard)
        {
            handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDNOEXIST, graveyardId);
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
        uint32 zoneId = player->GetZoneId();
 
        AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(zoneId);
        if (!areaEntry || areaEntry->zone != 0)
        {
            handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDWRONGZONE, graveyardId, zoneId);
            return false;
        }
 
        if (sGraveyard->AddGraveyardLink(graveyardId, zoneId, teamId))
        {
            handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDLINKED, graveyardId, zoneId);
        }
        else
        {
            handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDALRLINKED, graveyardId, zoneId);
        }
 
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), WorldObject::GetZoneId(), LANG_COMMAND_GRAVEYARDALRLINKED, LANG_COMMAND_GRAVEYARDLINKED, LANG_COMMAND_GRAVEYARDNOEXIST, LANG_COMMAND_GRAVEYARDWRONGZONE, ChatHandler::PSendSysMessage(), sAreaTableStore, ChatHandler::SendErrorMessage(), sGraveyard, StringEqualI(), TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and AreaTableEntry::zone.

Referenced by GetCommands().

◆ HandleMailBoxCommand()

static bool misc_commandscript::HandleMailBoxCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        handler->GetSession()->SendShowMailBox(player->GetGUID());
        return true;
    }

References Object::GetGUID(), WorldSession::GetPlayer(), ChatHandler::GetSession(), and WorldSession::SendShowMailBox().

Referenced by GetCommands().

◆ HandleMaxSkillCommand()

static bool misc_commandscript::HandleMaxSkillCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* SelectedPlayer = handler->getSelectedPlayer();
        if (!SelectedPlayer)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        // each skills that have max skill value dependent from level seted to current level max skill value
        SelectedPlayer->UpdateSkillsToMaxSkillsForLevel();
        return true;
    }

References ChatHandler::getSelectedPlayer(), LANG_NO_CHAR_SELECTED, ChatHandler::SendErrorMessage(), and Player::UpdateSkillsToMaxSkillsForLevel().

Referenced by GetCommands().

◆ HandleMovegensCommand()

static bool misc_commandscript::HandleMovegensCommand ( ChatHandler * handler )

inlinestatic

    {
        Unit* unit = handler->getSelectedUnit();
        if (!unit)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        handler->PSendSysMessage(LANG_MOVEGENS_LIST, (unit->IsPlayer() ? "Player" : "Creature"), unit->GetGUID().ToString());
 
        MotionMaster* motionMaster = unit->GetMotionMaster();
        float x, y, z;
        motionMaster->GetDestination(x, y, z);
 
        for (uint8 i = 0; i < MAX_MOTION_SLOT; ++i)
        {
            MovementGenerator* movementGenerator = motionMaster->GetMotionSlot(i);
            if (!movementGenerator)
            {
                handler->SendSysMessage("Empty");
                continue;
            }
 
            switch (movementGenerator->GetMovementGeneratorType())
            {
                case IDLE_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_IDLE);
                    break;
                case RANDOM_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_RANDOM);
                    break;
                case WAYPOINT_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_WAYPOINT);
                    break;
                case ANIMAL_RANDOM_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_ANIMAL_RANDOM);
                    break;
                case CONFUSED_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_CONFUSED);
                    break;
                case CHASE_MOTION_TYPE:
                {
                    Unit* target = nullptr;
                    if (unit->IsPlayer())
                    {
                        target = static_cast<ChaseMovementGenerator<Player> const*>(movementGenerator)->GetTarget();
                    }
                    else
                    {
                        target = static_cast<ChaseMovementGenerator<Creature> const*>(movementGenerator)->GetTarget();
                    }
 
                    if (!target)
                    {
                        handler->SendSysMessage(LANG_MOVEGENS_CHASE_NULL);
                    }
                    else if (target->IsPlayer())
                    {
                        handler->PSendSysMessage(LANG_MOVEGENS_CHASE_PLAYER, target->GetName(), target->GetGUID().ToString());
                    }
                    else
                    {
                        handler->PSendSysMessage(LANG_MOVEGENS_CHASE_CREATURE, target->GetName(), target->GetGUID().ToString());
                    }
                    break;
                }
                case FOLLOW_MOTION_TYPE:
                {
                    Unit* target = nullptr;
                    if (unit->IsPlayer())
                    {
                        target = static_cast<FollowMovementGenerator<Player> const*>(movementGenerator)->GetTarget();
                    }
                    else
                    {
                        target = static_cast<FollowMovementGenerator<Creature> const*>(movementGenerator)->GetTarget();
                    }
 
                    if (!target)
                    {
                        handler->SendSysMessage(LANG_MOVEGENS_FOLLOW_NULL);
                    }
                    else if (target->IsPlayer())
                    {
                        handler->PSendSysMessage(LANG_MOVEGENS_FOLLOW_PLAYER, target->GetName(), target->GetGUID().ToString());
                    }
                    else
                    {
                        handler->PSendSysMessage(LANG_MOVEGENS_FOLLOW_CREATURE, target->GetName(), target->GetGUID().ToString());
                    }
                    break;
                }
                case HOME_MOTION_TYPE:
                {
                    if (unit->IsCreature())
                    {
                        handler->PSendSysMessage(LANG_MOVEGENS_HOME_CREATURE, x, y, z);
                    }
                    else
                    {
                        handler->SendSysMessage(LANG_MOVEGENS_HOME_PLAYER);
                    }
                    break;
                }
                case FLIGHT_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_FLIGHT);
                    break;
                case POINT_MOTION_TYPE:
                {
                    handler->PSendSysMessage(LANG_MOVEGENS_POINT, x, y, z);
                    break;
                }
                case FLEEING_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_FEAR);
                    break;
                case DISTRACT_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_DISTRACT);
                    break;
                case EFFECT_MOTION_TYPE:
                    handler->SendSysMessage(LANG_MOVEGENS_EFFECT);
                    break;
                default:
                    handler->PSendSysMessage(LANG_MOVEGENS_UNKNOWN, movementGenerator->GetMovementGeneratorType());
                    break;
            }
        }
        return true;
    }

References ANIMAL_RANDOM_MOTION_TYPE, CHASE_MOTION_TYPE, CONFUSED_MOTION_TYPE, DISTRACT_MOTION_TYPE, EFFECT_MOTION_TYPE, FLEEING_MOTION_TYPE, FLIGHT_MOTION_TYPE, FOLLOW_MOTION_TYPE, MotionMaster::GetDestination(), Object::GetGUID(), Unit::GetMotionMaster(), MotionMaster::GetMotionSlot(), MovementGenerator::GetMovementGeneratorType(), WorldObject::GetName(), ChatHandler::getSelectedUnit(), HOME_MOTION_TYPE, IDLE_MOTION_TYPE, Object::IsCreature(), Object::IsPlayer(), LANG_MOVEGENS_ANIMAL_RANDOM, LANG_MOVEGENS_CHASE_CREATURE, LANG_MOVEGENS_CHASE_NULL, LANG_MOVEGENS_CHASE_PLAYER, LANG_MOVEGENS_CONFUSED, LANG_MOVEGENS_DISTRACT, LANG_MOVEGENS_EFFECT, LANG_MOVEGENS_FEAR, LANG_MOVEGENS_FLIGHT, LANG_MOVEGENS_FOLLOW_CREATURE, LANG_MOVEGENS_FOLLOW_NULL, LANG_MOVEGENS_FOLLOW_PLAYER, LANG_MOVEGENS_HOME_CREATURE, LANG_MOVEGENS_HOME_PLAYER, LANG_MOVEGENS_IDLE, LANG_MOVEGENS_LIST, LANG_MOVEGENS_POINT, LANG_MOVEGENS_RANDOM, LANG_MOVEGENS_UNKNOWN, LANG_MOVEGENS_WAYPOINT, LANG_SELECT_CHAR_OR_CREATURE, MAX_MOTION_SLOT, POINT_MOTION_TYPE, ChatHandler::PSendSysMessage(), RANDOM_MOTION_TYPE, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), ObjectGuid::ToString(), and WAYPOINT_MOTION_TYPE.

Referenced by GetCommands().

◆ HandleMuteCommand()

static bool misc_commandscript::HandleMuteCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	player,
		std::string	notSpeakTime,
		Tail	muteReason
	)

inlinestatic

    {
        std::string muteReasonStr{ muteReason };
 
        if (notSpeakTime.empty())
        {
            return false;
        }
 
        if (Acore::StringTo<int32>(notSpeakTime).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (muteReason.empty())
        {
            muteReasonStr = handler->GetAcoreString(LANG_NO_REASON);
        }
 
        if (!player)
        {
            player = PlayerIdentifier::FromTarget(handler);
        }
 
        if (!player)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        Player* target = player->GetConnectedPlayer();
        uint32 accountId = target ? target->GetSession()->GetAccountId() : sCharacterCache->GetCharacterAccountIdByGuid(player->GetGUID());
 
        // find only player from same account if any
        if (!target)
            if (WorldSession* session = sWorldSessionMgr->FindSession(accountId))
            {
                target = session->GetPlayer();
            }
 
        // must have strong lesser security level
        if (handler->HasLowerSecurity(target, player->GetGUID(), true))
        {
            return false;
        }
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME);
        int32 muteDuration = TimeStringToSecs(notSpeakTime);
        if (muteDuration <= 0)
        {
            muteDuration = Acore::StringTo<int32>(notSpeakTime).value_or(0);
        }
 
        if (muteDuration <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        std::string muteBy = "";
        if (handler->GetSession())
        {
            muteBy = handler->GetSession()->GetPlayerName();
        }
        else
        {
            muteBy = handler->GetAcoreString(LANG_CONSOLE);
        }
 
        if (target)
        {
            // Target is online, mute will be in effect right away.
            int64 muteTime = GameTime::GetGameTime().count() + muteDuration;
            target->GetSession()->m_muteTime = muteTime;
            stmt->SetData(0, muteTime);
            std::string nameLink = handler->playerLink(player->GetName());
 
            if (sWorld->getBoolConfig(CONFIG_SHOW_MUTE_IN_WORLD))
            {
                handler->SendWorldText(LANG_COMMAND_MUTEMESSAGE_WORLD, muteBy, nameLink, secsToTimeString(muteDuration, true), muteReasonStr);
            }
 
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_CHAT_DISABLED, secsToTimeString(muteDuration, true), muteBy, muteReasonStr);
        }
        else
        {
            // Target is offline, mute will be in effect starting from the next login.
            stmt->SetData(0, -int32(muteDuration));
        }
 
        stmt->SetData(1, muteReasonStr);
        stmt->SetData(2, muteBy);
        stmt->SetData(3, accountId);
        LoginDatabase.Execute(stmt);
 
        stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_MUTE);
        stmt->SetData(0, accountId);
        stmt->SetData(1, muteDuration / MINUTE);
        stmt->SetData(2, muteBy);
        stmt->SetData(3, muteReasonStr);
        LoginDatabase.Execute(stmt);
 
        std::string nameLink = handler->playerLink(player->GetName());
 
        if (sWorld->getBoolConfig(CONFIG_SHOW_MUTE_IN_WORLD) && !target)
        {
            handler->SendWorldText(LANG_COMMAND_MUTEMESSAGE_WORLD, muteBy, nameLink, secsToTimeString(muteDuration, true), muteReasonStr);
        }
        else
        {
            // pussywizard: notify all online GMs
            std::shared_lock<std::shared_mutex> lock(*HashMapHolder<Player>::GetLock());
            HashMapHolder<Player>::MapType const& m = ObjectAccessor::GetPlayers();
            for (HashMapHolder<Player>::MapType::const_iterator itr = m.begin(); itr != m.end(); ++itr)
                if (itr->second->GetSession()->GetSecurity())
                    ChatHandler(itr->second->GetSession()).PSendSysMessage(target ? LANG_YOU_DISABLE_CHAT : LANG_COMMAND_DISABLE_CHAT_DELAYED,
                            (handler->GetSession() ? handler->GetSession()->GetPlayerName() : handler->GetAcoreString(LANG_CONSOLE)), nameLink, secsToTimeString(muteDuration, true), muteReasonStr);
        }
 
        return true;
    }

References CONFIG_SHOW_MUTE_IN_WORLD, Acore::ChatCommands::PlayerIdentifier::FromTarget(), WorldSession::GetAccountId(), ChatHandler::GetAcoreString(), GameTime::GetGameTime(), Object::GetGUID(), WorldSession::GetPlayerName(), ObjectAccessor::GetPlayers(), ChatHandler::GetSession(), Player::GetSession(), ChatHandler::HasLowerSecurity(), LANG_BAD_VALUE, LANG_COMMAND_DISABLE_CHAT_DELAYED, LANG_COMMAND_MUTEMESSAGE_WORLD, LANG_CONSOLE, LANG_NO_REASON, LANG_PLAYER_NOT_FOUND, LANG_YOU_DISABLE_CHAT, LANG_YOUR_CHAT_DISABLED, LOGIN_INS_ACCOUNT_MUTE, LOGIN_UPD_MUTE_TIME, LoginDatabase, WorldSession::m_muteTime, MINUTE, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), sCharacterCache, secsToTimeString(), ChatHandler::SendErrorMessage(), ChatHandler::SendWorldText(), PreparedStatementBase::SetData(), sWorld, sWorldSessionMgr, and TimeStringToSecs().

Referenced by GetCommands().

◆ HandleMuteInfoCommand()

static bool misc_commandscript::HandleMuteInfoCommand	(	ChatHandler *	handler,
		std::string	accountName
	)

inlinestatic

    {
        if (!Utf8ToUpperOnlyLatin(accountName))
        {
            handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        uint32 accountId = AccountMgr::GetId(accountName);
        if (!accountId)
        {
            handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
            return false;
        }
 
        return HandleMuteInfoHelper(handler, accountId, accountName.c_str());
    }

References AccountMgr::GetId(), HandleMuteInfoHelper(), LANG_ACCOUNT_NOT_EXIST, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and Utf8ToUpperOnlyLatin().

Referenced by GetCommands().

◆ HandleMuteInfoHelper()

static bool misc_commandscript::HandleMuteInfoHelper	(	ChatHandler *	handler,
		uint32	accountId,
		char const *	accountName
	)

inlinestatic

    {
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_MUTE_INFO);
        stmt->SetData(0, accountId);
        PreparedQueryResult result = LoginDatabase.Query(stmt);
 
        if (!result)
        {
            handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY_EMPTY, accountName);
            return true;
        }
 
        handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY, accountName);
        do
        {
            Field* fields = result->Fetch();
            handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY_OUTPUT, Acore::Time::TimeToHumanReadable(Seconds(fields[0].Get<uint32>())), fields[1].Get<uint32>(), fields[2].Get<std::string>(), fields[3].Get<std::string>());
        } while (result->NextRow());
 
        return true;
    }

References LANG_COMMAND_MUTEHISTORY, LANG_COMMAND_MUTEHISTORY_EMPTY, LANG_COMMAND_MUTEHISTORY_OUTPUT, LOGIN_SEL_ACCOUNT_MUTE_INFO, LoginDatabase, ChatHandler::PSendSysMessage(), PreparedStatementBase::SetData(), and Acore::Time::TimeToHumanReadable().

Referenced by HandleMuteInfoCommand().

◆ HandleNearGraveCommand()

static bool misc_commandscript::HandleNearGraveCommand	(	ChatHandler *	handler,
		Optional< std::string_view >	team
	)

inlinestatic

    {
        TeamId teamId;
 
        if (!team)
        {
            teamId = TEAM_NEUTRAL;
        }
        else if (StringEqualI(team->substr(0, 6), "horde"))
        {
            teamId = TEAM_HORDE;
        }
        else if (StringEqualI(team->substr(0, 9), "alliance"))
        {
            teamId = TEAM_ALLIANCE;
        }
        else
        {
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
        uint32 zone_id = player->GetZoneId();
 
        GraveyardStruct const* graveyard = sGraveyard->GetClosestGraveyard(player, teamId);
 
        if (graveyard)
        {
            uint32 graveyardId = graveyard->ID;
 
            GraveyardData const* data = sGraveyard->FindGraveyardData(graveyardId, zone_id);
            if (!data)
            {
                handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDERROR, graveyardId);
                return false;
            }
 
            std::string team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_NOTEAM);
 
            if (data->teamId == TEAM_NEUTRAL)
            {
                team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ANY);
            }
            else if (data->teamId == TEAM_HORDE)
            {
                team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_HORDE);
            }
            else if (data->teamId == TEAM_ALLIANCE)
            {
                team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
            }
 
            handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDNEAREST, graveyardId, team_name, zone_id);
        }
        else
        {
            std::string team_name;
 
            if (teamId == TEAM_NEUTRAL)
            {
                team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ANY);
            }
            else if (teamId == TEAM_HORDE)
            {
                team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_HORDE);
            }
            else if (teamId == TEAM_ALLIANCE)
            {
                team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
            }
 
            handler->PSendSysMessage(LANG_COMMAND_ZONENOGRAFACTION, zone_id, team_name);
        }
 
        return true;
    }

References ChatHandler::GetAcoreString(), WorldSession::GetPlayer(), ChatHandler::GetSession(), WorldObject::GetZoneId(), GraveyardStruct::ID, LANG_COMMAND_GRAVEYARD_ALLIANCE, LANG_COMMAND_GRAVEYARD_ANY, LANG_COMMAND_GRAVEYARD_HORDE, LANG_COMMAND_GRAVEYARD_NOTEAM, LANG_COMMAND_GRAVEYARDERROR, LANG_COMMAND_GRAVEYARDNEAREST, LANG_COMMAND_ZONENOGRAFACTION, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), sGraveyard, StringEqualI(), TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, and GraveyardData::teamId.

Referenced by GetCommands().

◆ HandleOpenDoorCommand()

static bool misc_commandscript::HandleOpenDoorCommand	(	ChatHandler *	handler,
		Optional< float >	range
	)

inlinestatic

    {
        if (GameObject* go = handler->GetPlayer()->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_DOOR, range ? *range : 5.0f))
        {
            go->SetGoState(GO_STATE_ACTIVE);
            handler->PSendSysMessage(LANG_CMD_DOOR_OPENED, go->GetName(), go->GetEntry());
            return true;
        }
 
        handler->SendErrorMessage(LANG_CMD_NO_DOOR_FOUND, range ? *range : 5.0f);
        return false;
    }

References WorldObject::FindNearestGameObjectOfType(), GAMEOBJECT_TYPE_DOOR, ChatHandler::GetPlayer(), GO_STATE_ACTIVE, LANG_CMD_DOOR_OPENED, LANG_CMD_NO_DOOR_FOUND, ChatHandler::PSendSysMessage(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandlePacketLog()

static bool misc_commandscript::HandlePacketLog	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target,
		Optional< bool >	enableArg
	)

inlinestatic

    {
        if (!target)
            target = PlayerIdentifier::FromTargetOrSelf(handler);
 
        if (!target || !target->IsConnected())
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
        WorldSession* session = playerTarget->GetSession();
 
        if (!session)
            return false;
 
        if (enableArg)
        {
            if (*enableArg)
            {
                session->SetPacketLogging(true);
                handler->PSendSysMessage("Packet logging enabled for {}.", playerTarget->GetName());
                return true;
            }
            else
            {
                session->SetPacketLogging(false);
                handler->PSendSysMessage("Packet logging disabled for {}.", playerTarget->GetName());
                return true;
            }
        }
 
        handler->SendErrorMessage(LANG_USE_BOL);
        return false;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), WorldObject::GetName(), Player::GetSession(), LANG_PLAYER_NOT_FOUND, LANG_USE_BOL, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and WorldSession::SetPacketLogging().

Referenced by GetCommands().

◆ HandlePInfoCommand()

static bool misc_commandscript::HandlePInfoCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        CharacterDatabasePreparedStatement* stmt = nullptr;
        LoginDatabasePreparedStatement* loginStmt = nullptr;
 
        // Account data print variables
        std::string userName          = handler->GetAcoreString(LANG_ERROR);
        ObjectGuid::LowType lowguid   = target->GetGUID().GetCounter();
        uint32 accId                  = 0;
        std::string eMail             = handler->GetAcoreString(LANG_ERROR);
        std::string regMail           = handler->GetAcoreString(LANG_ERROR);
        uint32 security               = 0;
        std::string lastIp            = handler->GetAcoreString(LANG_ERROR);
        uint8 locked                  = 0;
        std::string lastLogin         = handler->GetAcoreString(LANG_ERROR);
        uint32 failedLogins           = 0;
        uint32 latency                = 0;
        std::string OS                = handler->GetAcoreString(LANG_UNKNOWN);
 
        // Mute data print variables
        int64 muteTime                = -1;
        std::string muteReason        = handler->GetAcoreString(LANG_NO_REASON);
        std::string muteBy            = handler->GetAcoreString(LANG_UNKNOWN);
 
        // Ban data print variables
        int64 banTime                 = -1;
        std::string banType           = handler->GetAcoreString(LANG_UNKNOWN);
        std::string banReason         = handler->GetAcoreString(LANG_NO_REASON);
        std::string bannedBy          = handler->GetAcoreString(LANG_UNKNOWN);
 
        // Character data print variables
        uint8 raceid, classid           = 0; //RACE_NONE, CLASS_NONE
        std::string raceStr, classStr   = handler->GetAcoreString(LANG_UNKNOWN);
        uint8 gender                    = 0;
        int8 locale                     = handler->GetSessionDbcLocale();
        uint32 totalPlayerTime          = 0;
        uint8 level                     = 0;
        std::string alive               = handler->GetAcoreString(LANG_ERROR);
        uint32 money                    = 0;
        uint32 xp                       = 0;
        uint32 xptotal                  = 0;
 
        // Position data print
        uint32 mapId;
        uint32 areaId;
        uint32 phase            = 0;
        std::string areaName    = "";
        std::string zoneName    = "";
 
        // Guild data print variables defined so that they exist, but are not necessarily used
        uint32 guildId           = 0;
        uint8 guildRankId        = 0;
        std::string guildName;
        std::string guildRank;
        std::string note;
        std::string officeNote;
 
        // get additional information from Player object
        if (playerTarget)
        {
            // check online security
            if (handler->HasLowerSecurity(playerTarget))
            {
                return false;
            }
 
            accId             = playerTarget->GetSession()->GetAccountId();
            money             = playerTarget->GetMoney();
            totalPlayerTime   = playerTarget->GetTotalPlayedTime();
            level             = playerTarget->GetLevel();
            latency           = playerTarget->GetSession()->GetLatency();
            raceid            = playerTarget->getRace();
            classid           = playerTarget->getClass();
            muteTime          = playerTarget->GetSession()->m_muteTime;
            mapId             = playerTarget->GetMapId();
            areaId            = playerTarget->GetAreaId();
            alive             = playerTarget->IsAlive() ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO);
            gender            = playerTarget->getGender();
            phase             = playerTarget->GetPhaseMask();
        }
        // get additional information from DB
        else
        {
            // check offline security
            if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
            {
                return false;
            }
 
            // Query informations from the DB
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_PINFO);
            stmt->SetData(0, lowguid);
            PreparedQueryResult charInfoResult = CharacterDatabase.Query(stmt);
 
            if (!charInfoResult)
            {
                return false;
            }
 
            Field* fields      = charInfoResult->Fetch();
            totalPlayerTime    = fields[0].Get<uint32>();
            level              = fields[1].Get<uint8>();
            money              = fields[2].Get<uint32>();
            accId              = fields[3].Get<uint32>();
            raceid             = fields[4].Get<uint8>();
            classid            = fields[5].Get<uint8>();
            mapId              = fields[6].Get<uint16>();
            areaId             = fields[7].Get<uint16>();
            gender             = fields[8].Get<uint8>();
            uint32 health      = fields[9].Get<uint32>();
            uint32 playerFlags = fields[10].Get<uint32>();
 
            if (!health || playerFlags & PLAYER_FLAGS_GHOST)
            {
                alive = handler->GetAcoreString(LANG_NO);
            }
            else
            {
                alive = handler->GetAcoreString(LANG_YES);
            }
        }
 
        // Query the prepared statement for login data
        loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO);
        loginStmt->SetData(0, int32(realm.Id.Realm));
        loginStmt->SetData(1, accId);
 
        PreparedQueryResult accInfoResult = LoginDatabase.Query(loginStmt);
        if (accInfoResult)
        {
            Field* fields = accInfoResult->Fetch();
            userName      = fields[0].Get<std::string>();
            security      = fields[1].Get<uint8>();
 
            // Only fetch these fields if commander has sufficient rights)
            if (!handler->GetSession() || handler->GetSession()->GetSecurity() >= AccountTypes(security))
            {
                eMail     = fields[2].Get<std::string>();
                regMail   = fields[3].Get<std::string>();
                lastIp    = fields[4].Get<std::string>();
                lastLogin = fields[5].Get<std::string>();
 
                if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(lastIp))
                {
                    lastIp.append(" (");
                    lastIp.append(location->CountryName);
                    lastIp.append(")");
                }
            }
            else
            {
                eMail     = handler->GetAcoreString(LANG_UNAUTHORIZED);
                regMail   = handler->GetAcoreString(LANG_UNAUTHORIZED);
                lastIp    = handler->GetAcoreString(LANG_UNAUTHORIZED);
                lastLogin = handler->GetAcoreString(LANG_UNAUTHORIZED);
            }
 
            muteTime      = fields[6].Get<uint64>();
            muteReason    = fields[7].Get<std::string>();
            muteBy        = fields[8].Get<std::string>();
            failedLogins  = fields[9].Get<uint32>();
            locked        = fields[10].Get<uint8>();
            OS            = fields[11].Get<std::string>();
        }
 
        // Creates a chat link to the character. Returns nameLink
        std::string nameLink = handler->playerLink(target->GetName());
 
        // Returns banType, banTime, bannedBy, banreason
        LoginDatabasePreparedStatement* banQuery = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO_BANS);
        banQuery->SetData(0, accId);
 
        PreparedQueryResult accBannedResult = LoginDatabase.Query(banQuery);
        if (!accBannedResult)
        {
            banType = handler->GetAcoreString(LANG_CHARACTER);
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_BANS);
            stmt->SetData(0, lowguid);
            accBannedResult = CharacterDatabase.Query(stmt);
        }
 
        if (accBannedResult)
        {
            Field* fields = accBannedResult->Fetch();
            banTime       = int64(fields[1].Get<uint64>() ? 0 : fields[0].Get<uint32>());
            bannedBy      = fields[2].Get<std::string>();
            banReason     = fields[3].Get<std::string>();
        }
 
        // Can be used to query data from World database
        WorldDatabasePreparedStatement* xpQuery = WorldDatabase.GetPreparedStatement(WORLD_SEL_REQ_XP);
        xpQuery->SetData(0, level);
 
        PreparedQueryResult xpResult = WorldDatabase.Query(xpQuery);
        if (xpResult)
        {
            Field* fields = xpResult->Fetch();
            xptotal       = fields[0].Get<uint32>();
        }
 
        // Can be used to query data from Characters database
        CharacterDatabasePreparedStatement* charXpQuery = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_XP);
        charXpQuery->SetData(0, lowguid);
 
        PreparedQueryResult charXpResult = CharacterDatabase.Query(charXpQuery);
        if (charXpResult)
        {
            Field* fields = charXpResult->Fetch();
            xp = fields[0].Get<uint32>();
            ObjectGuid::LowType gguid = fields[1].Get<uint32>();
 
            if (gguid != 0)
            {
                CharacterDatabasePreparedStatement* guildQuery = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUILD_MEMBER_EXTENDED);
                guildQuery->SetData(0, lowguid);
 
                PreparedQueryResult guildInfoResult = CharacterDatabase.Query(guildQuery);
                if (guildInfoResult)
                {
                    Field* guildInfoFields  = guildInfoResult->Fetch();
                    guildId        = guildInfoFields[0].Get<uint32>();
                    guildName      = guildInfoFields[1].Get<std::string>();
                    guildRank      = guildInfoFields[2].Get<std::string>();
                    note           = guildInfoFields[3].Get<std::string>();
                    officeNote     = guildInfoFields[4].Get<std::string>();
                }
            }
        }
 
        // Initiate output
        // Output I. LANG_PINFO_PLAYER
        handler->PSendSysMessage(LANG_PINFO_PLAYER, playerTarget ? "" : handler->GetAcoreString(LANG_OFFLINE), nameLink, target->GetGUID().ToString());
 
        // Output II. LANG_PINFO_GM_ACTIVE if character is gamemaster
        if (playerTarget && playerTarget->IsGameMaster())
        {
            handler->PSendSysMessage(LANG_PINFO_GM_ACTIVE);
        }
 
        // Output III. LANG_PINFO_BANNED if ban exists and is applied
        if (banTime >= 0)
        {
            handler->PSendSysMessage(LANG_PINFO_BANNED, banType, banReason, banTime > 0 ? secsToTimeString(banTime - GameTime::GetGameTime().count(), true) : handler->GetAcoreString(LANG_PERMANENTLY), bannedBy);
        }
 
        // Output IV. LANG_PINFO_MUTED if mute is applied
        if (muteTime > 0)
        {
            handler->PSendSysMessage(LANG_PINFO_MUTED, muteReason, secsToTimeString(muteTime - GameTime::GetGameTime().count(), true), muteBy);
        }
 
        // Output V. LANG_PINFO_ACC_ACCOUNT
        handler->PSendSysMessage(LANG_PINFO_ACC_ACCOUNT, userName, accId, security);
 
        if (playerTarget)
        {
            uint32 accountFlags = playerTarget->GetSession()->GetAccountFlags();
            handler->PSendSysMessage(LANG_ACCOUNT_FLAGS_PINFO);
            for (uint8 i = 0; i < MAX_ACCOUNT_FLAG; i++)
                if (accountFlags & (uint32(1) << i))
                    handler->PSendSysMessage(LANG_SUBCMDS_LIST_ENTRY, accountFlagNames[i].full);
        }
 
        // Output VI. LANG_PINFO_ACC_LASTLOGIN
        handler->PSendSysMessage(LANG_PINFO_ACC_LASTLOGIN, lastLogin, failedLogins);
 
        // Output VII. LANG_PINFO_ACC_OS
        handler->PSendSysMessage(LANG_PINFO_ACC_OS, OS, latency);
 
        // Output VIII. LANG_PINFO_ACC_REGMAILS
        handler->PSendSysMessage(LANG_PINFO_ACC_REGMAILS, regMail, eMail);
 
        // Output IX. LANG_PINFO_ACC_IP
        handler->PSendSysMessage(LANG_PINFO_ACC_IP, lastIp, locked ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO));
 
        // Output X. LANG_PINFO_CHR_LEVEL
        if (level != sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
        {
            handler->PSendSysMessage(LANG_PINFO_CHR_LEVEL_LOW, level, xp, xptotal, (xptotal - xp));
        }
        else
        {
            handler->PSendSysMessage(LANG_PINFO_CHR_LEVEL_HIGH, level);
        }
 
        // Output XI. LANG_PINFO_CHR_RACE
        switch (raceid)
        {
            case RACE_HUMAN:
                raceStr = "Human";
                break;
            case RACE_ORC:
                raceStr = "Orc";
                break;
            case RACE_DWARF:
                raceStr = "Dwarf";
                break;
            case RACE_NIGHTELF:
                raceStr = "Night Elf";
                break;
            case RACE_UNDEAD_PLAYER:
                raceStr = "Undead";
                break;
            case RACE_TAUREN:
                raceStr = "Tauren";
                break;
            case RACE_GNOME:
                raceStr = "Gnome";
                break;
            case RACE_TROLL:
                raceStr = "Troll";
                break;
            case RACE_BLOODELF:
                raceStr = "Blood Elf";
                break;
            case RACE_DRAENEI:
                raceStr = "Draenei";
                break;
        }
 
        switch (classid)
        {
            case CLASS_WARRIOR:
                classStr = "Warrior";
                break;
            case CLASS_PALADIN:
                classStr = "Paladin";
                break;
            case CLASS_HUNTER:
                classStr = "Hunter";
                break;
            case CLASS_ROGUE:
                classStr = "Rogue";
                break;
            case CLASS_PRIEST:
                classStr = "Priest";
                break;
            case CLASS_DEATH_KNIGHT:
                classStr = "Death Knight";
                break;
            case CLASS_SHAMAN:
                classStr = "Shaman";
                break;
            case CLASS_MAGE:
                classStr = "Mage";
                break;
            case CLASS_WARLOCK:
                classStr = "Warlock";
                break;
            case CLASS_DRUID:
                classStr = "Druid";
                break;
        }
 
        handler->PSendSysMessage(LANG_PINFO_CHR_RACE, (gender == 0 ? handler->GetAcoreString(LANG_CHARACTER_GENDER_MALE) : handler->GetAcoreString(LANG_CHARACTER_GENDER_FEMALE)), raceStr, classStr);
 
        // Output XII. LANG_PINFO_CHR_ALIVE
        handler->PSendSysMessage(LANG_PINFO_CHR_ALIVE, alive);
 
        // Output XIII. LANG_PINFO_CHR_PHASE if player is not in GM mode (GM is in every phase)
        if (playerTarget && !playerTarget->IsGameMaster()) // IsInWorld() returns false on loadingscreen, so it's more
        {
            handler->PSendSysMessage(LANG_PINFO_CHR_PHASE, phase);    // precise than just target (safer ?).
        }
 
        // However, as we usually just require a target here, we use target instead.
        // Output XIV. LANG_PINFO_CHR_MONEY
        uint32 gold = money / GOLD;
        uint32 silv = (money % GOLD) / SILVER;
        uint32 copp = (money % GOLD) % SILVER;
        handler->PSendSysMessage(LANG_PINFO_CHR_MONEY, gold, silv, copp);
 
        // Position data
        MapEntry const* map = sMapStore.LookupEntry(mapId);
        AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId);
 
        if (area)
        {
            zoneName = area->area_name[locale];
 
            AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->zone);
            if (zone)
            {
                areaName = zoneName;
                zoneName = zone->area_name[locale];
            }
        }
 
        if (zoneName.empty())
            zoneName = handler->GetAcoreString(LANG_UNKNOWN);
 
        if (!areaName.empty())
            handler->PSendSysMessage(LANG_PINFO_CHR_MAP_WITH_AREA, map->name[locale], zoneName, areaName);
        else
            handler->PSendSysMessage(LANG_PINFO_CHR_MAP, map->name[locale], zoneName);
 
        // Output XVII. - XVIX. if they are not empty
        if (!guildName.empty())
        {
            handler->PSendSysMessage(LANG_PINFO_CHR_GUILD, guildName, guildId);
            handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_RANK, guildRank, uint32(guildRankId));
 
            if (!note.empty())
            {
                handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_NOTE, note);
            }
 
            if (!officeNote.empty())
            {
                handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_ONOTE, officeNote);
            }
        }
 
        // Output XX. LANG_PINFO_CHR_PLAYEDTIME
        handler->PSendSysMessage(LANG_PINFO_CHR_PLAYEDTIME, (secsToTimeString(totalPlayerTime, true)));
 
        // Output XXI. LANG_PINFO_CHR_ONLINETIME (only for online players)
        if (playerTarget)
        {
            uint32 onlineTime = uint32(GameTime::GetGameTime().count() - playerTarget->m_logintime);
            handler->PSendSysMessage(LANG_PINFO_CHR_ONLINETIME, secsToTimeString(onlineTime, true));
        }
 
        // Mail Data - an own query, because it may or may not be useful.
        // SQL: "SELECT SUM(CASE WHEN (checked & 1) THEN 1 ELSE 0 END) AS 'readmail', COUNT(*) AS 'totalmail' FROM mail WHERE `receiver` = ?"
        CharacterDatabasePreparedStatement* mailQuery = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_MAILS);
        mailQuery->SetData(0, lowguid);
 
        PreparedQueryResult mailInfoResult = CharacterDatabase.Query(mailQuery);
        if (mailInfoResult)
        {
            Field* fields         = mailInfoResult->Fetch();
            uint32 readmail       = uint32(fields[0].Get<double>());
            uint32 totalmail      = uint32(fields[1].Get<uint64>());
 
            // Output XXI. LANG_INFO_CHR_MAILS if at least one mail is given
            if (totalmail >= 1)
            {
                handler->PSendSysMessage(LANG_PINFO_CHR_MAILS, readmail, totalmail);
            }
        }
 
        return true;
    }

References accountFlagNames, AreaTableEntry::area_name, CHAR_SEL_CHAR_PINFO, CHAR_SEL_GUILD_MEMBER_EXTENDED, CHAR_SEL_PINFO_BANS, CHAR_SEL_PINFO_MAILS, CHAR_SEL_PINFO_XP, CharacterDatabase, CLASS_DEATH_KNIGHT, CLASS_DRUID, CLASS_HUNTER, CLASS_MAGE, CLASS_PALADIN, CLASS_PRIEST, CLASS_ROGUE, CLASS_SHAMAN, CLASS_WARLOCK, CLASS_WARRIOR, CONFIG_MAX_PLAYER_LEVEL, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), AccountFlagName::full, Field::Get(), WorldSession::GetAccountFlags(), WorldSession::GetAccountId(), ChatHandler::GetAcoreString(), WorldObject::GetAreaId(), Unit::getClass(), GameTime::GetGameTime(), Unit::getGender(), WorldSession::GetLatency(), Unit::GetLevel(), WorldLocation::GetMapId(), Player::GetMoney(), WorldObject::GetPhaseMask(), Unit::getRace(), WorldSession::GetSecurity(), ChatHandler::GetSession(), Player::GetSession(), ChatHandler::GetSessionDbcLocale(), Player::GetTotalPlayedTime(), GOLD, ChatHandler::HasLowerSecurity(), Realm::Id, Unit::IsAlive(), Player::IsGameMaster(), LANG_ACCOUNT_FLAGS_PINFO, LANG_CHARACTER, LANG_CHARACTER_GENDER_FEMALE, LANG_CHARACTER_GENDER_MALE, LANG_ERROR, LANG_NO, LANG_NO_REASON, LANG_OFFLINE, LANG_PERMANENTLY, LANG_PINFO_ACC_ACCOUNT, LANG_PINFO_ACC_IP, LANG_PINFO_ACC_LASTLOGIN, LANG_PINFO_ACC_OS, LANG_PINFO_ACC_REGMAILS, LANG_PINFO_BANNED, LANG_PINFO_CHR_ALIVE, LANG_PINFO_CHR_GUILD, LANG_PINFO_CHR_GUILD_NOTE, LANG_PINFO_CHR_GUILD_ONOTE, LANG_PINFO_CHR_GUILD_RANK, LANG_PINFO_CHR_LEVEL_HIGH, LANG_PINFO_CHR_LEVEL_LOW, LANG_PINFO_CHR_MAILS, LANG_PINFO_CHR_MAP, LANG_PINFO_CHR_MAP_WITH_AREA, LANG_PINFO_CHR_MONEY, LANG_PINFO_CHR_ONLINETIME, LANG_PINFO_CHR_PHASE, LANG_PINFO_CHR_PLAYEDTIME, LANG_PINFO_CHR_RACE, LANG_PINFO_GM_ACTIVE, LANG_PINFO_MUTED, LANG_PINFO_PLAYER, LANG_SUBCMDS_LIST_ENTRY, LANG_UNAUTHORIZED, LANG_UNKNOWN, LANG_YES, LOGIN_SEL_PINFO, LOGIN_SEL_PINFO_BANS, LoginDatabase, Player::m_logintime, WorldSession::m_muteTime, MAX_ACCOUNT_FLAG, MapEntry::name, PLAYER_FLAGS_GHOST, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), RACE_BLOODELF, RACE_DRAENEI, RACE_DWARF, RACE_GNOME, RACE_HUMAN, RACE_NIGHTELF, RACE_ORC, RACE_TAUREN, RACE_TROLL, RACE_UNDEAD_PLAYER, realm, RealmHandle::Realm, sAreaTableStore, secsToTimeString(), PreparedStatementBase::SetData(), SILVER, sIPLocation, sMapStore, sWorld, WORLD_SEL_REQ_XP, WorldDatabase, and AreaTableEntry::zone.

Referenced by GetCommands().

◆ HandlePlayAllCommand()

static bool misc_commandscript::HandlePlayAllCommand	(	ChatHandler *	handler,
		uint32	soundId
	)

inlinestatic

    {
        if (!sSoundEntriesStore.LookupEntry(soundId))
        {
            handler->SendErrorMessage(LANG_SOUND_NOT_EXIST, soundId);
            return false;
        }
 
        sWorldSessionMgr->SendGlobalMessage(WorldPackets::Misc::Playsound(soundId).Write());
 
        handler->PSendSysMessage(LANG_COMMAND_PLAYED_TO_ALL, soundId);
        return true;
    }

References LANG_COMMAND_PLAYED_TO_ALL, LANG_SOUND_NOT_EXIST, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), sSoundEntriesStore, and sWorldSessionMgr.

Referenced by GetCommands().

◆ HandlePossessCommand()

static bool misc_commandscript::HandlePossessCommand ( ChatHandler * handler )

inlinestatic

    {
        Unit* unit = handler->getSelectedUnit();
        if (!unit)
        {
            return false;
        }
 
        handler->GetSession()->GetPlayer()->CastSpell(unit, MAP_OUTLAND, true);
        return true;
    }

References Unit::CastSpell(), WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), and MAP_OUTLAND.

Referenced by GetCommands().

◆ HandleRecallCommand()

static bool misc_commandscript::HandleRecallCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target || !target->IsConnected())
        {
            return false;
        }
 
        auto targetPlayer = target->GetConnectedPlayer();
 
        // check online security
        if (handler->HasLowerSecurity(targetPlayer))
        {
            return false;
        }
 
        if (targetPlayer->IsBeingTeleported())
        {
            handler->SendErrorMessage(LANG_IS_TELEPORTED, handler->playerLink(target->GetName()));
            return false;
        }
 
        // stop flight if need
        if (targetPlayer->IsInFlight())
        {
            targetPlayer->GetMotionMaster()->MovementExpired();
            targetPlayer->CleanupAfterTaxiFlight();
        }
 
        targetPlayer->TeleportTo(targetPlayer->m_recallMap, targetPlayer->m_recallX, targetPlayer->m_recallY, targetPlayer->m_recallZ, targetPlayer->m_recallO);
        return true;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), ChatHandler::HasLowerSecurity(), LANG_IS_TELEPORTED, ChatHandler::playerLink(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandleRespawnAllCommand()

static bool misc_commandscript::HandleRespawnAllCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        // Phase 1: respawn creatures/GOs that still have corpses in the grid
        Acore::RespawnDo u_do;
        Acore::WorldObjectWorker<Acore::RespawnDo> worker(player, u_do);
        Cell::VisitObjects(player, worker, player->GetGridActivationRange());
 
        // Phase 2: force-respawn creatures/GOs that were fully removed (non-compat mode)
        // by setting their respawn times to now so ProcessRespawns() picks them up
        Map* map = player->GetMap();
        uint32 gridId = Acore::ComputeGridCoord(player->GetPositionX(), player->GetPositionY()).GetId();
        time_t now = GameTime::GetGameTime().count();
 
        std::vector<ObjectGuid::LowType> creaturesToRespawn;
        for (auto const& pair : map->GetCreatureRespawnTimes())
        {
            CreatureData const* data = sObjectMgr->GetCreatureData(pair.first);
            if (!data || Acore::ComputeGridCoord(data->posX, data->posY).GetId() != gridId)
                continue;
 
            // Skip pooled spawns — Phase 1 already triggered pool rotation via
            // Creature::Respawn() -> PoolMgr::UpdatePool(). Forcing a respawn time
            // here would cause ProcessRespawns() to call UpdatePool() again,
            // spawning duplicates beyond the pool's max_limit.
            if (sPoolMgr->IsPartOfAPool<Creature>(pair.first))
                continue;
 
            creaturesToRespawn.push_back(pair.first);
        }
        for (ObjectGuid::LowType spawnId : creaturesToRespawn)
            map->SaveCreatureRespawnTime(spawnId, now);
 
        std::vector<ObjectGuid::LowType> goesToRespawn;
        for (auto const& pair : map->GetGORespawnTimes())
        {
            GameObjectData const* data = sObjectMgr->GetGameObjectData(pair.first);
            if (!data || Acore::ComputeGridCoord(data->posX, data->posY).GetId() != gridId)
                continue;
 
            // Skip pooled spawns — same reason as creatures above.
            if (sPoolMgr->IsPartOfAPool<GameObject>(pair.first))
                continue;
 
            goesToRespawn.push_back(pair.first);
        }
        for (ObjectGuid::LowType spawnId : goesToRespawn)
            map->SaveGORespawnTime(spawnId, now);
 
        return true;
    }

References Acore::ComputeGridCoord(), Map::GetCreatureRespawnTimes(), GameTime::GetGameTime(), Map::GetGORespawnTimes(), WorldObject::GetGridActivationRange(), CoordPair< LIMIT >::GetId(), WorldObject::GetMap(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), ChatHandler::GetSession(), SpawnData::posX, SpawnData::posY, Map::SaveCreatureRespawnTime(), Map::SaveGORespawnTime(), sObjectMgr, sPoolMgr, and Cell::VisitObjects().

Referenced by GetCommands().

◆ HandleRespawnCommand()

static bool misc_commandscript::HandleRespawnCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        Unit* target = handler->getSelectedUnit();
        if (player->GetTarget() && target)
        {
            if (!target->IsCreature() || target->IsPet())
            {
                handler->SendErrorMessage(LANG_SELECT_CREATURE);
                return false;
            }
 
            if (target->isDead())
            {
                target->ToCreature()->Respawn(true);
            }
            return true;
        }
 
        handler->SendErrorMessage(LANG_SELECT_CREATURE);
        return false;
    }

References WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), Unit::GetTarget(), Object::IsCreature(), Unit::isDead(), Unit::IsPet(), LANG_SELECT_CREATURE, Creature::Respawn(), ChatHandler::SendErrorMessage(), and Object::ToCreature().

Referenced by GetCommands().

◆ HandleRespawnCreatureByEntryCommand()

static bool misc_commandscript::HandleRespawnCreatureByEntryCommand	(	ChatHandler *	handler,
		uint32	entry,
		Optional< uint32 >	mapIdArg,
		Optional< uint32 >	instanceIdArg
	)

inlinestatic

    {
        if (!sObjectMgr->GetCreatureTemplate(entry))
        {
            handler->SendErrorMessage(LANG_RESPAWN_ENTRY_CREATURE_NOT_FOUND, entry);
            return false;
        }
 
        Map* map = nullptr;
        if (handler->GetSession())
        {
            // In-game: always use the player's current map
            map = handler->GetSession()->GetPlayer()->GetMap();
        }
        else
        {
            // Console: mapId required, instanceId optional
            if (!mapIdArg)
            {
                handler->SendSysMessage(LANG_LIST_RESPAWNS_NO_MAP);
                return false;
            }
            map = sMapMgr->FindMap(*mapIdArg, instanceIdArg.value_or(0));
        }
 
        if (!map)
        {
            handler->PSendSysMessage(LANG_RESPAWN_GUID_MAP_NOT_LOADED, mapIdArg.value_or(0));
            return false;
        }
 
        time_t now = GameTime::GetGameTime().count();
        uint32 count = 0;
 
        // Phase 1: respawn dead corpses that are still tracked in the spawn-id store.
        // Collect first to avoid iterator invalidation caused by Respawn().
        std::vector<Creature*> deadCreatures;
        for (auto const& [spawnId, creature] : map->GetCreatureBySpawnIdStore())
        {
            CreatureData const* data = sObjectMgr->GetCreatureData(spawnId);
            if (!data || data->id != entry)
                continue;
            if (creature->isDead())
                deadCreatures.push_back(creature);
        }
        for (Creature* creature : deadCreatures)
        {
            creature->Respawn(true);
            ++count;
        }
 
        // Phase 2: set respawn time to now for fully-removed spawns, skipping pools
        std::vector<ObjectGuid::LowType> toRespawn;
        for (auto const& [spawnId, respawnTime] : map->GetCreatureRespawnTimes())
        {
            CreatureData const* data = sObjectMgr->GetCreatureData(spawnId);
            if (!data || data->id != entry)
                continue;
            if (sPoolMgr->IsPartOfAPool<Creature>(spawnId))
                continue;
            toRespawn.push_back(spawnId);
        }
        for (ObjectGuid::LowType spawnId : toRespawn)
        {
            map->SaveCreatureRespawnTime(spawnId, now);
            ++count;
        }
 
        handler->PSendSysMessage(LANG_RESPAWN_ENTRY_CREATURE_QUEUED, count, entry);
        return true;
    }

References Map::GetCreatureBySpawnIdStore(), Map::GetCreatureRespawnTimes(), GameTime::GetGameTime(), WorldObject::GetMap(), WorldSession::GetPlayer(), ChatHandler::GetSession(), CreatureData::id, LANG_LIST_RESPAWNS_NO_MAP, LANG_RESPAWN_ENTRY_CREATURE_NOT_FOUND, LANG_RESPAWN_ENTRY_CREATURE_QUEUED, LANG_RESPAWN_GUID_MAP_NOT_LOADED, ChatHandler::PSendSysMessage(), Map::SaveCreatureRespawnTime(), ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), sMapMgr, sObjectMgr, and sPoolMgr.

Referenced by GetCommands().

◆ HandleRespawnCreatureByGuidCommand()

static bool misc_commandscript::HandleRespawnCreatureByGuidCommand	(	ChatHandler *	handler,
		ObjectGuid::LowType	spawnId
	)

inlinestatic

    {
        CreatureData const* creData = sObjectMgr->GetCreatureData(spawnId);
        if (!creData)
        {
            handler->SendErrorMessage(LANG_RESPAWN_GUID_CREATURE_NOT_FOUND, spawnId);
            return false;
        }
 
        Map* map = nullptr;
        if (handler->GetSession())
        {
            Player* player = handler->GetSession()->GetPlayer();
            if (player->GetMapId() == creData->mapid)
                map = player->GetMap();
        }
        if (!map)
            map = sMapMgr->FindMap(creData->mapid, 0);
 
        if (!map)
        {
            handler->PSendSysMessage(LANG_RESPAWN_GUID_MAP_NOT_LOADED, creData->mapid);
            return true;
        }
 
        // First pass: check if any instance is alive
        bool isAlive = false;
        auto const creBounds = map->GetCreatureBySpawnIdStore().equal_range(spawnId);
        for (auto itr = creBounds.first; itr != creBounds.second; ++itr)
        {
            if (itr->second->IsAlive())
            {
                isAlive = true;
                break;
            }
        }
 
        if (isAlive)
        {
            handler->PSendSysMessage(LANG_RESPAWN_GUID_CREATURE_ALIVE, spawnId, creData->id);
            return true;
        }
 
        // Second pass: respawn any dead corpses in the world
        for (auto itr = creBounds.first; itr != creBounds.second; ++itr)
        {
            if (itr->second->isDead())
                itr->second->Respawn(true);
        }
        // Also trigger via respawn time queue for fully-removed spawns
        if (map->GetCreatureRespawnTime(spawnId) > 0)
        {
            time_t now = GameTime::GetGameTime().count();
            map->SaveCreatureRespawnTime(spawnId, now);
        }
        handler->PSendSysMessage(LANG_RESPAWN_GUID_CREATURE_QUEUED, spawnId, creData->id);
        return true;
    }

References Map::GetCreatureBySpawnIdStore(), Map::GetCreatureRespawnTime(), GameTime::GetGameTime(), WorldObject::GetMap(), WorldLocation::GetMapId(), WorldSession::GetPlayer(), ChatHandler::GetSession(), CreatureData::id, LANG_RESPAWN_GUID_CREATURE_ALIVE, LANG_RESPAWN_GUID_CREATURE_NOT_FOUND, LANG_RESPAWN_GUID_CREATURE_QUEUED, LANG_RESPAWN_GUID_MAP_NOT_LOADED, SpawnData::mapid, ChatHandler::PSendSysMessage(), Map::SaveCreatureRespawnTime(), ChatHandler::SendErrorMessage(), sMapMgr, and sObjectMgr.

Referenced by GetCommands().

◆ HandleRespawnGameObjectByEntryCommand()

static bool misc_commandscript::HandleRespawnGameObjectByEntryCommand	(	ChatHandler *	handler,
		uint32	entry,
		Optional< uint32 >	mapIdArg,
		Optional< uint32 >	instanceIdArg
	)

inlinestatic

    {
        if (!sObjectMgr->GetGameObjectTemplate(entry))
        {
            handler->SendErrorMessage(LANG_RESPAWN_ENTRY_GAMEOBJECT_NOT_FOUND, entry);
            return false;
        }
 
        Map* map = nullptr;
        if (handler->GetSession())
        {
            // In-game: always use the player's current map
            map = handler->GetSession()->GetPlayer()->GetMap();
        }
        else
        {
            // Console: mapId required, instanceId optional
            if (!mapIdArg)
            {
                handler->SendSysMessage(LANG_LIST_RESPAWNS_NO_MAP);
                return false;
            }
            map = sMapMgr->FindMap(*mapIdArg, instanceIdArg.value_or(0));
        }
 
        if (!map)
        {
            handler->PSendSysMessage(LANG_RESPAWN_GUID_MAP_NOT_LOADED, mapIdArg.value_or(0));
            return false;
        }
 
        time_t now = GameTime::GetGameTime().count();
        uint32 count = 0;
 
        // Phase 1: respawn inactive objects that are still tracked in the spawn-id store.
        // Collect first to avoid iterator invalidation caused by Respawn().
        std::vector<GameObject*> inactiveGOs;
        for (auto const& [spawnId, go] : map->GetGameObjectBySpawnIdStore())
        {
            GameObjectData const* data = sObjectMgr->GetGameObjectData(spawnId);
            if (!data || data->id != entry)
                continue;
            if (!go->isSpawned())
                inactiveGOs.push_back(go);
        }
        for (GameObject* go : inactiveGOs)
        {
            go->Respawn();
            ++count;
        }
 
        // Phase 2: set respawn time to now for fully-removed spawns, skipping pools
        std::vector<ObjectGuid::LowType> toRespawn;
        for (auto const& [spawnId, respawnTime] : map->GetGORespawnTimes())
        {
            GameObjectData const* data = sObjectMgr->GetGameObjectData(spawnId);
            if (!data || data->id != entry)
                continue;
            if (sPoolMgr->IsPartOfAPool<GameObject>(spawnId))
                continue;
            toRespawn.push_back(spawnId);
        }
        for (ObjectGuid::LowType spawnId : toRespawn)
        {
            map->SaveGORespawnTime(spawnId, now);
            ++count;
        }
 
        handler->PSendSysMessage(LANG_RESPAWN_ENTRY_GAMEOBJECT_QUEUED, count, entry);
        return true;
    }

References Map::GetGameObjectBySpawnIdStore(), GameTime::GetGameTime(), Map::GetGORespawnTimes(), WorldObject::GetMap(), WorldSession::GetPlayer(), ChatHandler::GetSession(), GameObjectData::id, LANG_LIST_RESPAWNS_NO_MAP, LANG_RESPAWN_ENTRY_GAMEOBJECT_NOT_FOUND, LANG_RESPAWN_ENTRY_GAMEOBJECT_QUEUED, LANG_RESPAWN_GUID_MAP_NOT_LOADED, ChatHandler::PSendSysMessage(), Map::SaveGORespawnTime(), ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), sMapMgr, sObjectMgr, and sPoolMgr.

Referenced by GetCommands().

◆ HandleRespawnGameObjectByGuidCommand()

static bool misc_commandscript::HandleRespawnGameObjectByGuidCommand	(	ChatHandler *	handler,
		ObjectGuid::LowType	spawnId
	)

inlinestatic

    {
        GameObjectData const* goData = sObjectMgr->GetGameObjectData(spawnId);
        if (!goData)
        {
            handler->SendErrorMessage(LANG_RESPAWN_GUID_GAMEOBJECT_NOT_FOUND, spawnId);
            return false;
        }
 
        Map* map = nullptr;
        if (handler->GetSession())
        {
            Player* player = handler->GetSession()->GetPlayer();
            if (player->GetMapId() == goData->mapid)
                map = player->GetMap();
        }
        if (!map)
            map = sMapMgr->FindMap(goData->mapid, 0);
 
        if (!map)
        {
            handler->PSendSysMessage(LANG_RESPAWN_GUID_MAP_NOT_LOADED, goData->mapid);
            return true;
        }
 
        // First pass: check if any instance is already active
        bool isActive = false;
        auto const goBounds = map->GetGameObjectBySpawnIdStore().equal_range(spawnId);
        for (auto itr = goBounds.first; itr != goBounds.second; ++itr)
        {
            if (itr->second->isSpawned())
            {
                isActive = true;
                break;
            }
        }
 
        if (isActive)
        {
            handler->PSendSysMessage(LANG_RESPAWN_GUID_GAMEOBJECT_ACTIVE, spawnId, goData->id);
            return true;
        }
 
        // Second pass: respawn inactive objects in the world
        for (auto itr = goBounds.first; itr != goBounds.second; ++itr)
            itr->second->Respawn();
        // Also trigger via respawn time queue for fully-removed spawns
        if (map->GetGORespawnTime(spawnId) > 0)
        {
            time_t now = GameTime::GetGameTime().count();
            map->SaveGORespawnTime(spawnId, now);
        }
        handler->PSendSysMessage(LANG_RESPAWN_GUID_GAMEOBJECT_QUEUED, spawnId, goData->id);
        return true;
    }

References Map::GetGameObjectBySpawnIdStore(), GameTime::GetGameTime(), Map::GetGORespawnTime(), WorldObject::GetMap(), WorldLocation::GetMapId(), WorldSession::GetPlayer(), ChatHandler::GetSession(), goData, LANG_RESPAWN_GUID_GAMEOBJECT_ACTIVE, LANG_RESPAWN_GUID_GAMEOBJECT_NOT_FOUND, LANG_RESPAWN_GUID_GAMEOBJECT_QUEUED, LANG_RESPAWN_GUID_MAP_NOT_LOADED, ChatHandler::PSendSysMessage(), Map::SaveGORespawnTime(), ChatHandler::SendErrorMessage(), sMapMgr, and sObjectMgr.

Referenced by GetCommands().

◆ HandleReviveCommand()

static bool misc_commandscript::HandleReviveCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
            target = PlayerIdentifier::FromTargetOrSelf(handler);
 
        if (!target)
            return false;
 
        if (target->IsConnected())
        {
            auto targetPlayer = target->GetConnectedPlayer();
            targetPlayer->RemoveAurasDueToSpell(27827); // Spirit of Redemption
            targetPlayer->ResurrectPlayer(!AccountMgr::IsPlayerAccount(targetPlayer->GetSession()->GetSecurity()) ? 1.0f : 0.5f);
            targetPlayer->SpawnCorpseBones();
            targetPlayer->SaveToDB(false, false);
        }
        else
        {
            CharacterDatabaseTransaction trans(nullptr);
            Player::OfflineResurrect(target->GetGUID(), trans);
        }
 
        return true;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), AccountMgr::IsPlayerAccount(), and Player::OfflineResurrect().

Referenced by GetCommands().

◆ HandleSaveAllCommand()

static bool misc_commandscript::HandleSaveAllCommand ( ChatHandler * handler )

inlinestatic

    {
        ObjectAccessor::SaveAllPlayers();
        handler->SendSysMessage(LANG_PLAYERS_SAVED);
        return true;
    }

References LANG_PLAYERS_SAVED, ObjectAccessor::SaveAllPlayers(), and ChatHandler::SendSysMessage().

Referenced by GetCommands().

◆ HandleSaveCommand()

static bool misc_commandscript::HandleSaveCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        // save GM account without delay and output message
        if (handler->GetSession()->HasPermission(rbac::RBAC_PERM_COMMANDS_SAVE_WITHOUT_DELAY))
        {
            if (Player* target = handler->getSelectedPlayer())
            {
                target->SaveToDB(false, false);
            }
            else
            {
                player->SaveToDB(false, false);
            }
 
            handler->SendSysMessage(LANG_PLAYER_SAVED);
            return true;
        }
 
        // save if the player has last been saved over 20 seconds ago
        uint32 saveInterval = sWorld->getIntConfig(CONFIG_INTERVAL_SAVE);
        if (saveInterval == 0 || (saveInterval > 20 * IN_MILLISECONDS && player->GetSaveTimer() <= saveInterval - 20 * IN_MILLISECONDS))
        {
            player->SaveToDB(false, false);
        }
 
        return true;
    }

References CONFIG_INTERVAL_SAVE, WorldSession::GetPlayer(), Player::GetSaveTimer(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSession(), WorldSession::HasPermission(), IN_MILLISECONDS, LANG_PLAYER_SAVED, rbac::RBAC_PERM_COMMANDS_SAVE_WITHOUT_DELAY, Player::SaveToDB(), ChatHandler::SendSysMessage(), and sWorld.

Referenced by GetCommands().

◆ HandleSetSkillCommand()

static bool misc_commandscript::HandleSetSkillCommand	(	ChatHandler *	handler,
		Variant< Hyperlink< skill >, uint32 >	skillId,
		int32	level,
		Optional< uint16 >	maxPureSkill
	)

inlinestatic

    {
        uint32 skillID = uint32(skillId);
 
        if (skillID <= 0)
        {
            handler->SendErrorMessage(LANG_INVALID_SKILL_ID, skillID);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(skillID);
        if (!skillLine)
        {
            handler->SendErrorMessage(LANG_INVALID_SKILL_ID, uint32(skillID));
            return false;
        }
 
        bool targetHasSkill = target->GetSkillValue(skillID);
 
        // If our target does not yet have the skill they are trying to add to them, the chosen level also becomes
        // the max level of the new profession.
        uint16 max = maxPureSkill ? *maxPureSkill : targetHasSkill ? target->GetPureMaxSkillValue(skillID) : uint16(level);
 
        if (level <= 0 || level > max || max <= 0)
        {
            return false;
        }
 
        // If the player has the skill, we get the current skill step. If they don't have the skill, we
        // add the skill to the player's book with step 1 (which is the first rank, in most cases something
        // like 'Apprentice <skill>'.
        target->SetSkill(skillID, targetHasSkill ? target->GetSkillStep(skillID) : 1, level, max);
        handler->PSendSysMessage(LANG_SET_SKILL, skillID, skillLine->name[handler->GetSessionDbcLocale()], handler->GetNameLink(target), level, max);
        return true;
    }

References ChatHandler::GetNameLink(), Player::GetPureMaxSkillValue(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSessionDbcLocale(), Player::GetSkillStep(), Player::GetSkillValue(), LANG_INVALID_SKILL_ID, LANG_NO_CHAR_SELECTED, LANG_SET_SKILL, SkillLineEntry::name, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), Player::SetSkill(), and sSkillLineStore.

Referenced by GetCommands().

◆ HandleShowAreaCommand()

static bool misc_commandscript::HandleShowAreaCommand	(	ChatHandler *	handler,
		uint32	areaID
	)

inlinestatic

    {
        Player* playerTarget = handler->getSelectedPlayer();
        if (!playerTarget)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaID);
        if (!area)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        int32 offset = area->exploreFlag / 32;
        if (offset >= PLAYER_EXPLORED_ZONES_SIZE)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        uint32 val = uint32((1 << (area->exploreFlag % 32)));
        uint32 currFields = playerTarget->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
        playerTarget->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, uint32((currFields | val)));
 
        handler->SendSysMessage(LANG_EXPLORE_AREA);
        return true;
    }

References AreaTableEntry::exploreFlag, ChatHandler::getSelectedPlayer(), Object::GetUInt32Value(), LANG_BAD_VALUE, LANG_EXPLORE_AREA, LANG_NO_CHAR_SELECTED, PLAYER_EXPLORED_ZONES_1, PLAYER_EXPLORED_ZONES_SIZE, sAreaTableStore, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), and Unit::SetUInt32Value().

Referenced by GetCommands().

◆ HandleSkirmishCommand()

static bool misc_commandscript::HandleSkirmishCommand	(	ChatHandler *	handler,
		std::vector< std::string_view >	args
	)

inlinestatic

    {
        auto tokens = args;
 
        if (args.empty() || !tokens.size())
        {
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        auto tokensItr = tokens.begin();
 
        std::vector<BattlegroundTypeId> allowedArenas;
        std::string_view arenasStr = *(tokensItr++);
 
        auto arenaTokens = Acore::Tokenize(arenasStr, ',', false);
        for (auto const& arenaName : arenaTokens)
        {
            if (arenaName == "all")
            {
                if (arenaTokens.size() > 1)
                {
                    handler->SendErrorMessage("Invalid [arena] specified.");
                    return false;
                }
 
                allowedArenas.emplace_back(BATTLEGROUND_NA);
                allowedArenas.emplace_back(BATTLEGROUND_BE);
                allowedArenas.emplace_back(BATTLEGROUND_RL);
                allowedArenas.emplace_back(BATTLEGROUND_DS);
                allowedArenas.emplace_back(BATTLEGROUND_RV);
            }
            else if (arenaName == "NA")
            {
                allowedArenas.emplace_back(BATTLEGROUND_NA);
            }
            else if (arenaName == "BE")
            {
                allowedArenas.emplace_back(BATTLEGROUND_BE);
            }
            else if (arenaName == "RL")
            {
                allowedArenas.emplace_back(BATTLEGROUND_RL);
            }
            else if (arenaName == "DS")
            {
                allowedArenas.emplace_back(BATTLEGROUND_DS);
            }
            else if (arenaName == "RV")
            {
                allowedArenas.emplace_back(BATTLEGROUND_RV);
            }
            else
            {
                handler->SendErrorMessage("Invalid [arena] specified.");
                return false;
            }
        }
 
        ASSERT(!allowedArenas.empty());
        BattlegroundTypeId randomizedArenaBgTypeId = Acore::Containers::SelectRandomContainerElement(allowedArenas);
 
        uint8 count = 0;
        if (tokensItr != tokens.end())
        {
            std::string_view mode = *(tokensItr++);
 
            if (mode == "1v1")
            {
                count = 2;
            }
            else if (mode == "2v2")
            {
                count = 4;
            }
            else if (mode == "3v3")
            {
                count = 6;
            }
            else if (mode == "5v5")
            {
                count = 10;
            }
        }
 
        if (!count)
        {
            handler->SendErrorMessage("Invalid bracket. Can be 1v1, 2v2, 3v3, 5v5");
            return false;
        }
 
        if (tokens.size() != uint16(count + 2))
        {
            handler->SendErrorMessage("Invalid number of nicknames for this bracket.");
            return false;
        }
 
        uint8 hcnt = count / 2;
        uint8 error = 0;
        std::string last_name;
        Player* plr = nullptr;
        std::array<Player*, 10> players = {};
        uint8 cnt = 0;
 
        for (; tokensItr != tokens.end(); ++tokensItr)
        {
            last_name = std::string(*tokensItr);
            plr = ObjectAccessor::FindPlayerByName(last_name, false);
 
            if (!plr)
            {
                error = 1;
                break;
            }
 
            if (!plr->IsInWorld() || !plr->FindMap() || plr->IsBeingTeleported())
            {
                error = 2;
                break;
            }
 
            if (plr->GetMap()->GetEntry()->Instanceable())
            {
                error = 3;
                break;
            }
 
            if (plr->IsUsingLfg())
            {
                error = 4;
                break;
            }
 
            if (plr->InBattlegroundQueue())
            {
                error = 5;
                break;
            }
 
            if (plr->IsInFlight())
            {
                error = 10;
                break;
            }
 
            if (!plr->IsAlive())
            {
                error = 11;
                break;
            }
 
            Group const* g = plr->GetGroup();
 
            if (hcnt > 1)
            {
                if (!g)
                {
                    error = 6;
                    break;
                }
 
                if (g->isRaidGroup() || g->isBGGroup() || g->isBFGroup() || g->isLFGGroup())
                {
                    error = 7;
                    break;
                }
 
                if (g->GetMembersCount() != hcnt)
                {
                    error = 8;
                    break;
                }
 
                uint8 sti = (cnt < hcnt ? 0 : hcnt);
                if (sti != cnt && players[sti]->GetGroup() != plr->GetGroup())
                {
                    error = 9;
                    last_name += " and " + players[sti]->GetName();
                    break;
                }
            }
            else // 1v1
            {
                if (g)
                {
                    error = 12;
                    break;
                }
            }
 
            players[cnt++] = plr;
        }
 
        for (uint8 i = 0; i < cnt && !error; ++i)
        {
            for (uint8 j = i + 1; j < cnt; ++j)
            {
                if (players[i]->GetGUID() == players[j]->GetGUID())
                {
                    last_name = players[i]->GetName();
                    error = 13;
                    break;
                }
            }
        }
 
        switch (error)
        {
            case 1:
                handler->PSendSysMessage("Player {} not found.", last_name);
                break;
            case 2:
                handler->PSendSysMessage("Player {} is being teleported.", last_name);
                break;
            case 3:
                handler->PSendSysMessage("Player {} is in instance/battleground/arena.", last_name);
                break;
            case 4:
                handler->PSendSysMessage("Player {} is in LFG system.", last_name);
                break;
            case 5:
                handler->PSendSysMessage("Player {} is queued for battleground/arena.", last_name);
                break;
            case 6:
                handler->PSendSysMessage("Player {} is not in group.", last_name);
                break;
            case 7:
                handler->PSendSysMessage("Player {} is not in normal group.", last_name);
                break;
            case 8:
                handler->PSendSysMessage("Group of player {} has invalid member count.", last_name);
                break;
            case 9:
                handler->PSendSysMessage("Players {} are not in the same group.", last_name);
                break;
            case 10:
                handler->PSendSysMessage("Player {} is in flight.", last_name);
                break;
            case 11:
                handler->PSendSysMessage("Player {} is dead.", last_name);
                break;
            case 12:
                handler->PSendSysMessage("Player {} is in a group.", last_name);
                break;
            case 13:
                handler->PSendSysMessage("Player {} occurs more than once.", last_name);
                break;
        }
 
        if (error)
        {
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Battleground* bgt = sBattlegroundMgr->GetBattlegroundTemplate(BATTLEGROUND_AA);
        if (!bgt)
        {
            handler->SendErrorMessage("Couldn't create arena map!");
            return false;
        }
 
        Battleground* bg = sBattlegroundMgr->CreateNewBattleground(randomizedArenaBgTypeId, GetBattlegroundBracketById(bgt->GetMapId(), bgt->GetBracketId()), ArenaType(hcnt >= 2 ? hcnt : 2), false);
        if (!bg)
        {
            handler->SendErrorMessage("Couldn't create arena map!");
            return false;
        }
 
        bg->StartBattleground();
 
        BattlegroundTypeId bgTypeId = bg->GetBgTypeID();
 
        TeamId teamId1 = Player::TeamIdForRace(players[0]->getRace());
        TeamId teamId2 = (teamId1 == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE);
 
        for (uint8 i = 0; i < cnt; ++i)
        {
            Player* player = players[i];
 
            TeamId teamId = (i < hcnt ? teamId1 : teamId2);
            player->SetEntryPoint();
 
            uint32 queueSlot = 0;
            WorldPacket data;
            sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_IN_PROGRESS, 0, bg->GetStartTime(), bg->GetArenaType(), teamId);
            player->SendDirectMessage(&data);
 
            // Remove from LFG queues
            sLFGMgr->LeaveAllLfgQueues(player->GetGUID(), false);
 
            // Book the reservation like the queue path does, so it is symmetric
            // with RemovePlayerAtLeave's decrement and the 0-players/0-invited
            // state can't let Battleground::Update delete the arena while players
            // are still on the loading screen.
            bg->IncreaseInvitedCount(teamId);
            player->SetBattlegroundId(bg->GetInstanceID(), bgTypeId, queueSlot, true, false, teamId);
 
            // A synchronous teleport failure would strand that reservation (the
            // player never enters and never reaches RemovePlayerAtLeave), leaving
            // the arena undeletable; release it and reset his bg data.
            if (!sBattlegroundMgr->SendToBattleground(player, bg->GetInstanceID(), bgTypeId))
            {
                bg->DecreaseInvitedCount(teamId);
                player->SetBattlegroundId(0, BATTLEGROUND_TYPE_NONE, PLAYER_MAX_BATTLEGROUND_QUEUES, false, false, TEAM_NEUTRAL);
            }
        }
 
        handler->PSendSysMessage("Success! Players are now being teleported to the arena.");
        return true;
    }

References ASSERT, BATTLEGROUND_AA, BATTLEGROUND_BE, BATTLEGROUND_DS, BATTLEGROUND_NA, BATTLEGROUND_RL, BATTLEGROUND_RV, BATTLEGROUND_TYPE_NONE, Battleground::DecreaseInvitedCount(), WorldObject::FindMap(), ObjectAccessor::FindPlayerByName(), Battleground::GetArenaType(), GetBattlegroundBracketById(), Battleground::GetBgTypeID(), Battleground::GetBracketId(), Map::GetEntry(), Player::GetGroup(), Object::GetGUID(), Battleground::GetInstanceID(), WorldObject::GetMap(), Battleground::GetMapId(), Group::GetMembersCount(), WorldObject::GetName(), Battleground::GetStartTime(), Player::InBattlegroundQueue(), Battleground::IncreaseInvitedCount(), MapEntry::Instanceable(), Unit::IsAlive(), Player::IsBeingTeleported(), Group::isBFGroup(), Group::isBGGroup(), Unit::IsInFlight(), Object::IsInWorld(), Group::isLFGGroup(), Group::isRaidGroup(), Player::IsUsingLfg(), PLAYER_MAX_BATTLEGROUND_QUEUES, ChatHandler::PSendSysMessage(), sBattlegroundMgr, Acore::Containers::SelectRandomContainerElement(), Player::SendDirectMessage(), ChatHandler::SendErrorMessage(), Player::SetBattlegroundId(), Player::SetEntryPoint(), ChatHandler::SetSentErrorMessage(), sLFGMgr, Battleground::StartBattleground(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, TEAM_NEUTRAL, Player::TeamIdForRace(), and Acore::Tokenize().

Referenced by GetCommands().

◆ HandleStringCommand()

static bool misc_commandscript::HandleStringCommand	(	ChatHandler *	handler,
		uint32	id,
		Optional< uint8 >	locale
	)

inlinestatic

    {
        if (!id)
        {
            handler->SendSysMessage(LANG_CMD_SYNTAX);
            return false;
        }
 
        std::string str = sObjectMgr->GetAcoreString(id, locale ? static_cast<LocaleConstant>(*locale) : DEFAULT_LOCALE);
        handler->SendSysMessage(str);
        return true;
    }

References DEFAULT_LOCALE, LANG_CMD_SYNTAX, ChatHandler::SendSysMessage(), and sObjectMgr.

Referenced by GetCommands().

◆ HandleSummonCommand()

static bool misc_commandscript::HandleSummonCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTarget(handler);
        }
 
        if (!target)
        {
            return false;
        }
 
        Player* _player = handler->GetSession()->GetPlayer();
        if (target->GetGUID() == _player->GetGUID())
        {
            handler->SendErrorMessage(LANG_CANT_TELEPORT_SELF);
            return false;
        }
 
        std::string nameLink = handler->playerLink(target->GetName());
 
        if (target->IsConnected())
        {
            auto targetPlayer = target->GetConnectedPlayer();
 
            // check online security
            if (handler->HasLowerSecurity(targetPlayer))
            {
                return false;
            }
 
            if (targetPlayer->IsBeingTeleported())
            {
                handler->SendErrorMessage(LANG_IS_TELEPORTED, nameLink);
                return false;
            }
 
            Map* map = handler->GetSession()->GetPlayer()->GetMap();
 
            if (map->IsBattlegroundOrArena())
            {
                handler->SendErrorMessage("Can't summon to a battleground!");
                return false;
            }
            else if (map->IsDungeon())
            {
                // Allow GM to summon players or only other GM accounts inside instances.
                if (!sWorld->getBoolConfig(CONFIG_INSTANCE_GMSUMMON_PLAYER))
                {
                    // pussywizard: prevent unbinding normal player's perm bind by just summoning him >_>
                    if (!targetPlayer->GetSession()->GetSecurity())
                    {
                        handler->SendErrorMessage("Only GMs can be summoned to an instance!");
                        return false;
                    }
                }
 
                Map* destMap = targetPlayer->GetMap();
 
                if (destMap->Instanceable() && destMap->GetInstanceId() != map->GetInstanceId())
                {
                    sInstanceSaveMgr->PlayerUnbindInstance(target->GetGUID(), map->GetInstanceId(), targetPlayer->GetDungeonDifficulty(), true, targetPlayer);
                }
 
                // we are in an instance, and can only summon players in our group with us as leader
                if (!handler->GetSession()->GetPlayer()->GetGroup() || !targetPlayer->GetGroup() ||
                        (targetPlayer->GetGroup()->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID()) ||
                        (handler->GetSession()->GetPlayer()->GetGroup()->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID()))
                    // the last check is a bit excessive, but let it be, just in case
                {
                    handler->SendErrorMessage(LANG_CANNOT_SUMMON_TO_INST, nameLink);
                    return false;
                }
            }
 
            handler->PSendSysMessage(LANG_SUMMONING, nameLink, "");
            if (handler->needReportToTarget(targetPlayer))
            {
                ChatHandler(targetPlayer->GetSession()).PSendSysMessage(LANG_SUMMONED_BY, handler->playerLink(_player->GetName()));
            }
 
            // stop flight if need
            if (targetPlayer->IsInFlight())
            {
                targetPlayer->GetMotionMaster()->MovementExpired();
                targetPlayer->CleanupAfterTaxiFlight();
            }
            // save only in non-flight case
            else
            {
                targetPlayer->SaveRecallPosition();
            }
 
            // before GM
            float x, y, z;
            handler->GetSession()->GetPlayer()->GetClosePoint(x, y, z, targetPlayer->GetObjectSize());
            targetPlayer->TeleportTo(handler->GetSession()->GetPlayer()->GetMapId(), x, y, z, targetPlayer->GetOrientation(), 0, handler->GetSession()->GetPlayer());
        }
        else
        {
            // check offline security
            if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
            {
                return false;
            }
 
            handler->PSendSysMessage(LANG_SUMMONING, nameLink, handler->GetAcoreString(LANG_OFFLINE));
 
            // in point where GM stay
            Player::SavePositionInDB(handler->GetSession()->GetPlayer()->GetMapId(),
                                     handler->GetSession()->GetPlayer()->GetPositionX(),
                                     handler->GetSession()->GetPlayer()->GetPositionY(),
                                     handler->GetSession()->GetPlayer()->GetPositionZ(),
                                     handler->GetSession()->GetPlayer()->GetOrientation(),
                                     handler->GetSession()->GetPlayer()->GetZoneId(),
                                     target->GetGUID());
        }
 
        return true;
    }

References CONFIG_INSTANCE_GMSUMMON_PLAYER, Acore::ChatCommands::PlayerIdentifier::FromTarget(), ChatHandler::GetAcoreString(), WorldObject::GetClosePoint(), Player::GetGroup(), Object::GetGUID(), Map::GetInstanceId(), Group::GetLeaderGUID(), WorldObject::GetMap(), WorldLocation::GetMapId(), WorldObject::GetName(), Position::GetOrientation(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), WorldObject::GetZoneId(), ChatHandler::HasLowerSecurity(), Map::Instanceable(), Map::IsBattlegroundOrArena(), Map::IsDungeon(), LANG_CANNOT_SUMMON_TO_INST, LANG_CANT_TELEPORT_SELF, LANG_IS_TELEPORTED, LANG_OFFLINE, LANG_SUMMONED_BY, LANG_SUMMONING, ChatHandler::needReportToTarget(), ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Player::SavePositionInDB(), ChatHandler::SendErrorMessage(), sInstanceSaveMgr, and sWorld.

Referenced by GetCommands().

◆ HandleUnAuraCommand()

static bool misc_commandscript::HandleUnAuraCommand	(	ChatHandler *	handler,
		Variant< SpellInfo const *, std::string_view >	spells
	)

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        if (spells.holds_alternative<std::string_view>() && spells.get<std::string_view>() == "all")
        {
            target->RemoveAllAuras();
            return true;
        }
 
        if (!spells.holds_alternative<SpellInfo const*>())
        {
            handler->SendErrorMessage(LANG_COMMAND_NOSPELLFOUND);
            return false;
        }
 
        auto spell = spells.get<SpellInfo const*>();
 
        if (!SpellMgr::IsSpellValid(spell))
        {
            handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
            return false;
        }
 
        target->RemoveAurasDueToSpell(spell->Id);
 
        return true;
    }

References ChatHandler::getSelectedUnit(), SpellMgr::IsSpellValid(), LANG_COMMAND_NOSPELLFOUND, LANG_COMMAND_SPELL_BROKEN, LANG_SELECT_CHAR_OR_CREATURE, Unit::RemoveAllAuras(), Unit::RemoveAurasDueToSpell(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandleUnbindSightCommand()

static bool misc_commandscript::HandleUnbindSightCommand ( ChatHandler * handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        if (player->isPossessing())
        {
            return false;
        }
 
        player->StopCastingBindSight();
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), Unit::isPossessing(), and Player::StopCastingBindSight().

Referenced by GetCommands().

◆ HandleUnFreezeCommand()

static bool misc_commandscript::HandleUnFreezeCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        Creature* creatureTarget = handler->getSelectedCreature();
 
        if (!target && !creatureTarget)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target && !creatureTarget)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        if (!creatureTarget && playerTarget && playerTarget->HasAura(SPELL_FREEZE))
        {
            handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, target->GetName());
            playerTarget->RemoveAurasDueToSpell(SPELL_FREEZE);
            return true;
        }
        else if (creatureTarget && creatureTarget->HasAura(SPELL_FREEZE))
        {
            handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, GetLocalizeCreatureName(creatureTarget, handler->GetSessionDbcLocale()));
            creatureTarget->RemoveAurasDueToSpell(SPELL_FREEZE);
            return true;
        }
        else if (!creatureTarget && target && !target->IsConnected())
        {
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_AURA_FROZEN);
            stmt->SetData(0, target->GetGUID().GetCounter());
            CharacterDatabase.Execute(stmt);
            handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, target->GetName());
            return true;
        }
 
        handler->SendSysMessage(LANG_COMMAND_FREEZE_WRONG);
        return true;
    }

References CHAR_DEL_CHAR_AURA_FROZEN, CharacterDatabase, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), GetLocalizeCreatureName(), ChatHandler::getSelectedCreature(), ChatHandler::GetSessionDbcLocale(), Unit::HasAura(), LANG_COMMAND_FREEZE_WRONG, LANG_COMMAND_UNFREEZE, LANG_SELECT_CHAR_OR_CREATURE, ChatHandler::PSendSysMessage(), Unit::RemoveAurasDueToSpell(), ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), and SPELL_FREEZE.

Referenced by GetCommands().

◆ HandleUnmuteCommand()

static bool misc_commandscript::HandleUnmuteCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target
	)

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
        uint32 accountId = playerTarget ? playerTarget->GetSession()->GetAccountId() : sCharacterCache->GetCharacterAccountIdByGuid(target->GetGUID());
 
        // find only player from same account if any
        if (!playerTarget)
        {
            if (WorldSession* session = sWorldSessionMgr->FindSession(accountId))
            {
                playerTarget = session->GetPlayer();
            }
        }
 
        // must have strong lesser security level
        if (handler->HasLowerSecurity(playerTarget, target->GetGUID(), true))
        {
            return false;
        }
 
        if (playerTarget)
        {
            if (playerTarget->CanSpeak())
            {
                handler->SendErrorMessage(LANG_CHAT_ALREADY_ENABLED);
                return false;
            }
 
            playerTarget->GetSession()->m_muteTime = 0;
        }
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME);
        stmt->SetData(0, 0);
        stmt->SetData(1, "");
        stmt->SetData(2, "");
        stmt->SetData(3, accountId);
        LoginDatabase.Execute(stmt);
 
        if (playerTarget)
        {
            ChatHandler(playerTarget->GetSession()).PSendSysMessage(LANG_YOUR_CHAT_ENABLED);
        }
 
        handler->PSendSysMessage(LANG_YOU_ENABLE_CHAT, handler->playerLink(target->GetName()));
 
        return true;
    }

References Player::CanSpeak(), Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), WorldSession::GetAccountId(), Object::GetGUID(), Player::GetSession(), ChatHandler::HasLowerSecurity(), LANG_CHAT_ALREADY_ENABLED, LANG_YOU_ENABLE_CHAT, LANG_YOUR_CHAT_ENABLED, LOGIN_UPD_MUTE_TIME, LoginDatabase, WorldSession::m_muteTime, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), sCharacterCache, ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), and sWorldSessionMgr.

Referenced by GetCommands().

◆ HandleUnPossessCommand()

static bool misc_commandscript::HandleUnPossessCommand ( ChatHandler * handler )

inlinestatic

    {
        Unit* unit = handler->getSelectedUnit();
        if (!unit)
        {
            unit = handler->GetSession()->GetPlayer();
        }
 
        unit->RemoveCharmAuras();
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), and Unit::RemoveCharmAuras().

Referenced by GetCommands().

◆ HandleUnstuckCommand()

static bool misc_commandscript::HandleUnstuckCommand	(	ChatHandler *	handler,
		Optional< PlayerIdentifier >	target,
		Optional< std::string_view >	location
	)

inlinestatic

    {
        // No args required for players
        if (handler->GetSession() && AccountMgr::IsPlayerAccount(handler->GetSession()->GetSecurity()))
        {
            if (Player* player = handler->GetSession()->GetPlayer())
            {
                player->CastSpell(player, SPELL_STUCK, false);
            }
 
            return true;
        }
 
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target || !target->IsConnected())
        {
            if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
                return false;
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_HOMEBIND);
            stmt->SetData(0, target->GetGUID().GetCounter());
 
            PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
            if (result)
            {
                Field* fieldsDB = result->Fetch();
                WorldLocation loc(fieldsDB[0].Get<uint16>(), fieldsDB[2].Get<float>(), fieldsDB[3].Get<float>(), fieldsDB[4].Get<float>(), 0.0f);
                uint32 zoneId = fieldsDB[1].Get<uint16>();
 
                Player::SavePositionInDB(loc, zoneId, target->GetGUID(), nullptr);
 
                handler->PSendSysMessage(LANG_SUMMONING, target->GetName(), handler->GetAcoreString(LANG_OFFLINE));
            }
 
            return true;
        }
 
        Player* player = target->GetConnectedPlayer();
 
        if (player->IsInFlight() || player->IsInCombat())
        {
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(7355);
            if (!spellInfo)
                return false;
 
            if (player)
                Spell::SendCastResult(player, spellInfo, 0, SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW);
 
            return false;
        }
 
        if (location->empty() || *location == "inn")
        {
            player->TeleportTo(player->m_homebindMapId, player->m_homebindX, player->m_homebindY, player->m_homebindZ, player->GetOrientation());
            return true;
        }
 
        if (*location == "graveyard")
        {
            player->RepopAtGraveyard();
            return true;
        }
 
        if (*location == "startzone")
        {
            player->TeleportTo(player->GetStartPosition());
            return true;
        }
 
        //Not a supported argument
        return false;
    }

References CHAR_SEL_CHARACTER_HOMEBIND, CharacterDatabase, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Field::Get(), ChatHandler::GetAcoreString(), Position::GetOrientation(), WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::GetSession(), Player::GetStartPosition(), ChatHandler::HasLowerSecurity(), Unit::IsInCombat(), Unit::IsInFlight(), AccountMgr::IsPlayerAccount(), LANG_OFFLINE, LANG_SUMMONING, Player::m_homebindMapId, Player::m_homebindX, Player::m_homebindY, Player::m_homebindZ, ChatHandler::PSendSysMessage(), Player::RepopAtGraveyard(), Player::SavePositionInDB(), Spell::SendCastResult(), PreparedStatementBase::SetData(), SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW, SPELL_STUCK, sSpellMgr, and Player::TeleportTo().

Referenced by GetCommands().

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

azerothcore-wotlk/src/server/scripts/Commands/cs_misc.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ misc_commandscript()

Member Function Documentation

◆ GetCommands()

◆ HandleAddItemCommand()

◆ HandleAddItemSetCommand()

◆ HandleAppearCommand()

◆ HandleAuraCommand()

◆ HandleAuraStacksCommand()

◆ HandleBindSightCommand()

◆ HandleBMCommand()

◆ HandleChangeWeather()

◆ HandleCombatStopCommand()

◆ HandleComeToMeCommand()

◆ HandleCommandsCommand()

◆ HandleCommentatorCommand()

◆ HandleCooldownCommand()

◆ HandleDamageCommand()

◆ HandleDevCommand()

◆ HandleDieCommand()

◆ HandleDismountCommand()

◆ HandleFlushArenaPointsCommand()

◆ HandleFreezeCommand()

◆ HandleGetDistanceCommand()

◆ HandleGPSCommand()

◆ HandleGroupSummonCommand()

◆ HandleGUIDCommand()

◆ HandleHelpCommand()

◆ HandleHideAreaCommand()

◆ HandleKickPlayerCommand()

◆ HandleLinkGraveCommand()

◆ HandleMailBoxCommand()

◆ HandleMaxSkillCommand()

◆ HandleMovegensCommand()

◆ HandleMuteCommand()

◆ HandleMuteInfoCommand()

◆ HandleMuteInfoHelper()

◆ HandleNearGraveCommand()

◆ HandleOpenDoorCommand()

◆ HandlePacketLog()

◆ HandlePInfoCommand()

◆ HandlePlayAllCommand()

◆ HandlePossessCommand()

◆ HandleRecallCommand()

◆ HandleRespawnAllCommand()

◆ HandleRespawnCommand()

◆ HandleRespawnCreatureByEntryCommand()

◆ HandleRespawnCreatureByGuidCommand()

◆ HandleRespawnGameObjectByEntryCommand()

◆ HandleRespawnGameObjectByGuidCommand()

◆ HandleReviveCommand()

◆ HandleSaveAllCommand()

◆ HandleSaveCommand()

◆ HandleSetSkillCommand()

◆ HandleShowAreaCommand()

◆ HandleSkirmishCommand()

◆ HandleStringCommand()

◆ HandleSummonCommand()

◆ HandleUnAuraCommand()

◆ HandleUnbindSightCommand()

◆ HandleUnFreezeCommand()

◆ HandleUnmuteCommand()

◆ HandleUnPossessCommand()

◆ HandleUnstuckCommand()