AzerothCore 3.3.5a
OpenSource WoW Emulator
Loading...
Searching...
No Matches
misc_commandscript Class Reference
Inheritance diagram for misc_commandscript:
CommandScript ScriptObject

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 ()
 
const std::string & 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 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)
 

Additional Inherited Members

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

Detailed Description

Constructor & Destructor Documentation

◆ misc_commandscript()

misc_commandscript::misc_commandscript ( )
inline
133: CommandScript("misc_commandscript") { }
Definition CommandScript.h:25

Member Function Documentation

◆ GetCommands()

ChatCommandTable misc_commandscript::GetCommands ( ) const
inlineoverridevirtual

Implements CommandScript.

136 {
137 static ChatCommandTable auraCommandTable =
138 {
139 { "stack", HandleAuraStacksCommand, SEC_GAMEMASTER, Console::No },
140 { "", HandleAuraCommand, SEC_GAMEMASTER, Console::No }
141 };
142
143 static ChatCommandTable commandTable =
144 {
145 { "commentator", HandleCommentatorCommand, SEC_MODERATOR, Console::No },
146 { "dev", HandleDevCommand, SEC_ADMINISTRATOR, Console::No },
147 { "gps", HandleGPSCommand, SEC_MODERATOR, Console::No },
148 { "aura", auraCommandTable },
149 { "unaura", HandleUnAuraCommand, SEC_GAMEMASTER, Console::No },
150 { "appear", HandleAppearCommand, SEC_MODERATOR, Console::No },
151 { "summon", HandleSummonCommand, SEC_GAMEMASTER, Console::No },
152 { "groupsummon", HandleGroupSummonCommand, SEC_GAMEMASTER, Console::No },
153 { "commands", HandleCommandsCommand, SEC_PLAYER, Console::Yes },
154 { "die", HandleDieCommand, SEC_GAMEMASTER, Console::No },
155 { "revive", HandleReviveCommand, SEC_GAMEMASTER, Console::Yes },
156 { "dismount", HandleDismountCommand, SEC_PLAYER, Console::No },
157 { "guid", HandleGUIDCommand, SEC_GAMEMASTER, Console::No },
158 { "help", HandleHelpCommand, SEC_PLAYER, Console::Yes },
159 { "cooldown", HandleCooldownCommand, SEC_GAMEMASTER, Console::No },
160 { "distance", HandleGetDistanceCommand, SEC_ADMINISTRATOR, Console::No },
161 { "recall", HandleRecallCommand, SEC_GAMEMASTER, Console::No },
162 { "save", HandleSaveCommand, SEC_PLAYER, Console::No },
163 { "saveall", HandleSaveAllCommand, SEC_GAMEMASTER, Console::Yes },
164 { "kick", HandleKickPlayerCommand, SEC_GAMEMASTER, Console::Yes },
165 { "unstuck", HandleUnstuckCommand, SEC_GAMEMASTER, Console::Yes },
166 { "linkgrave", HandleLinkGraveCommand, SEC_ADMINISTRATOR, Console::No },
167 { "neargrave", HandleNearGraveCommand, SEC_GAMEMASTER, Console::No },
168 { "showarea", HandleShowAreaCommand, SEC_GAMEMASTER, Console::No },
169 { "hidearea", HandleHideAreaCommand, SEC_ADMINISTRATOR, Console::No },
170 { "additem", HandleAddItemCommand, SEC_GAMEMASTER, Console::Yes },
171 { "additem set", HandleAddItemSetCommand, SEC_GAMEMASTER, Console::No },
172 { "wchange", HandleChangeWeather, SEC_ADMINISTRATOR, Console::No },
173 { "maxskill", HandleMaxSkillCommand, SEC_GAMEMASTER, Console::No },
174 { "setskill", HandleSetSkillCommand, SEC_GAMEMASTER, Console::No },
175 { "pinfo", HandlePInfoCommand, SEC_GAMEMASTER, Console::Yes },
176 { "respawn", HandleRespawnCommand, SEC_GAMEMASTER, Console::No },
177 { "respawn all", HandleRespawnAllCommand, SEC_GAMEMASTER, Console::No },
178 { "mute", HandleMuteCommand, SEC_GAMEMASTER, Console::Yes },
179 { "mutehistory", HandleMuteInfoCommand, SEC_GAMEMASTER, Console::Yes },
180 { "unmute", HandleUnmuteCommand, SEC_GAMEMASTER, Console::Yes },
181 { "movegens", HandleMovegensCommand, SEC_ADMINISTRATOR, Console::No },
182 { "cometome", HandleComeToMeCommand, SEC_ADMINISTRATOR, Console::No },
183 { "damage", HandleDamageCommand, SEC_GAMEMASTER, Console::No },
184 { "combatstop", HandleCombatStopCommand, SEC_GAMEMASTER, Console::Yes },
185 { "flusharenapoints", HandleFlushArenaPointsCommand, SEC_ADMINISTRATOR, Console::Yes },
186 { "freeze", HandleFreezeCommand, SEC_GAMEMASTER, Console::No },
187 { "unfreeze", HandleUnFreezeCommand, SEC_GAMEMASTER, Console::No },
188 { "possess", HandlePossessCommand, SEC_GAMEMASTER, Console::No },
189 { "unpossess", HandleUnPossessCommand, SEC_GAMEMASTER, Console::No },
190 { "bindsight", HandleBindSightCommand, SEC_ADMINISTRATOR, Console::No },
191 { "unbindsight", HandleUnbindSightCommand, SEC_ADMINISTRATOR, Console::No },
192 { "playall", HandlePlayAllCommand, SEC_GAMEMASTER, Console::No },
193 { "skirmish", HandleSkirmishCommand, SEC_ADMINISTRATOR, Console::No },
194 { "mailbox", HandleMailBoxCommand, SEC_MODERATOR, Console::No },
195 { "string", HandleStringCommand, SEC_GAMEMASTER, Console::No },
196 { "opendoor", HandleOpenDoorCommand, SEC_GAMEMASTER, Console::No }
197 };
198
199 return commandTable;
200 }
@ SEC_PLAYER
Definition Common.h:57
@ SEC_ADMINISTRATOR
Definition Common.h:60
@ SEC_GAMEMASTER
Definition Common.h:59
@ SEC_MODERATOR
Definition Common.h:58
static bool HandleCommentatorCommand(ChatHandler *handler, Optional< bool > enableArg)
Definition cs_misc.cpp:501
static bool HandleDevCommand(ChatHandler *handler, Optional< bool > enableArg)
Definition cs_misc.cpp:545
static bool HandleDamageCommand(ChatHandler *handler, uint32 damage, Optional< std::string > percent)
Definition cs_misc.cpp:2834
static bool HandleSaveCommand(ChatHandler *handler)
Definition cs_misc.cpp:1370
static bool HandleAuraStacksCommand(ChatHandler *handler, SpellInfo const *spell, int16 stacks)
Definition cs_misc.cpp:702
static bool HandleLinkGraveCommand(ChatHandler *handler, uint32 graveyardId, Optional< std::string_view > team)
Definition cs_misc.cpp:1533
static bool HandlePlayAllCommand(ChatHandler *handler, uint32 soundId)
Definition cs_misc.cpp:2983
static bool HandleAddItemCommand(ChatHandler *handler, Optional< PlayerIdentifier > player, ItemTemplate const *itemTemplate, Optional< int32 > _count)
Definition cs_misc.cpp:1723
static bool HandleAuraCommand(ChatHandler *handler, SpellInfo const *spell)
Definition cs_misc.cpp:676
static bool HandleUnstuckCommand(ChatHandler *handler, Optional< PlayerIdentifier > target, Optional< std::string_view > location)
Definition cs_misc.cpp:1455
static bool HandleRespawnAllCommand(ChatHandler *handler)
Definition cs_misc.cpp:2448
static bool HandleSkirmishCommand(ChatHandler *handler, std::vector< std::string_view > args)
Definition cs_misc.cpp:202
static bool HandleUnbindSightCommand(ChatHandler *handler)
Definition cs_misc.cpp:3033
static bool HandleShowAreaCommand(ChatHandler *handler, uint32 areaID)
Definition cs_misc.cpp:1661
static bool HandleStringCommand(ChatHandler *handler, uint32 id, Optional< uint8 > locale)
Definition cs_misc.cpp:3053
static bool HandleChangeWeather(ChatHandler *handler, uint32 type, float grade)
Definition cs_misc.cpp:1886
static bool HandlePInfoCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:1974
static bool HandleSummonCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:930
static bool HandleCooldownCommand(ChatHandler *handler, Optional< SpellInfo const * > spell)
Definition cs_misc.cpp:1275
static bool HandleReviveCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:1200
static bool HandleOpenDoorCommand(ChatHandler *handler, Optional< float > range)
Definition cs_misc.cpp:3066
static bool HandleCommandsCommand(ChatHandler *handler)
Definition cs_misc.cpp:1157
static bool HandleMailBoxCommand(ChatHandler *handler)
Definition cs_misc.cpp:3046
static bool HandleDieCommand(ChatHandler *handler)
Definition cs_misc.cpp:1163
static bool HandleAppearCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:781
static bool HandleHelpCommand(ChatHandler *handler, Tail cmd)
Definition cs_misc.cpp:1263
static bool HandleRespawnCommand(ChatHandler *handler)
Definition cs_misc.cpp:2424
static bool HandleNearGraveCommand(ChatHandler *handler, Optional< std::string_view > team)
Definition cs_misc.cpp:1584
static bool HandleMovegensCommand(ChatHandler *handler)
Definition cs_misc.cpp:2684
static bool HandleGUIDCommand(ChatHandler *handler)
Definition cs_misc.cpp:1249
static bool HandleAddItemSetCommand(ChatHandler *handler, Variant< Hyperlink< itemset >, uint32 > itemSetId)
Definition cs_misc.cpp:1825
static bool HandleSaveAllCommand(ChatHandler *handler)
Definition cs_misc.cpp:1401
static bool HandleGPSCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:590
static bool HandleKickPlayerCommand(ChatHandler *handler, Optional< PlayerIdentifier > target, Optional< std::string_view > reason)
Definition cs_misc.cpp:1409
static bool HandleHideAreaCommand(ChatHandler *handler, uint32 areaID)
Definition cs_misc.cpp:1692
static bool HandleSetSkillCommand(ChatHandler *handler, Variant< Hyperlink< skill >, uint32 > skillId, int32 level, Optional< uint16 > maxPureSkill)
Definition cs_misc.cpp:1930
static bool HandleUnmuteCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:2584
static bool HandleRecallCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:1333
static bool HandleBindSightCommand(ChatHandler *handler)
Definition cs_misc.cpp:3021
static bool HandleComeToMeCommand(ChatHandler *handler)
Definition cs_misc.cpp:2818
static bool HandleUnPossessCommand(ChatHandler *handler)
Definition cs_misc.cpp:3009
static bool HandleDismountCommand(ChatHandler *handler)
Definition cs_misc.cpp:1225
static bool HandleGroupSummonCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:1052
static bool HandleCombatStopCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:2866
static bool HandleUnAuraCommand(ChatHandler *handler, Variant< SpellInfo const *, std::string_view > spells)
Definition cs_misc.cpp:747
static bool HandleGetDistanceCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:1305
static bool HandleMaxSkillCommand(ChatHandler *handler)
Definition cs_misc.cpp:1916
static bool HandleFlushArenaPointsCommand(ChatHandler *)
Definition cs_misc.cpp:2892
static bool HandleFreezeCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:2898
static bool HandleMuteInfoCommand(ChatHandler *handler, std::string accountName)
Definition cs_misc.cpp:2643
static bool HandleUnFreezeCommand(ChatHandler *handler, Optional< PlayerIdentifier > target)
Definition cs_misc.cpp:2941
static bool HandleMuteCommand(ChatHandler *handler, Optional< PlayerIdentifier > player, std::string notSpeakTime, Tail muteReason)
Definition cs_misc.cpp:2460
static bool HandlePossessCommand(ChatHandler *handler)
Definition cs_misc.cpp:2997
std::vector< ChatCommandBuilder > ChatCommandTable
Definition ChatCommand.h:46

References HandleAddItemCommand(), HandleAddItemSetCommand(), HandleAppearCommand(), HandleAuraCommand(), HandleAuraStacksCommand(), HandleBindSightCommand(), 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(), HandleNearGraveCommand(), HandleOpenDoorCommand(), HandlePInfoCommand(), HandlePlayAllCommand(), HandlePossessCommand(), HandleRecallCommand(), HandleRespawnAllCommand(), HandleRespawnCommand(), HandleReviveCommand(), HandleSaveAllCommand(), HandleSaveCommand(), HandleSetSkillCommand(), HandleShowAreaCommand(), HandleSkirmishCommand(), HandleStringCommand(), HandleSummonCommand(), HandleUnAuraCommand(), HandleUnbindSightCommand(), HandleUnFreezeCommand(), HandleUnmuteCommand(), HandleUnPossessCommand(), HandleUnstuckCommand(), SEC_ADMINISTRATOR, SEC_GAMEMASTER, SEC_MODERATOR, and SEC_PLAYER.

◆ HandleAddItemCommand()

static bool misc_commandscript::HandleAddItemCommand ( ChatHandler handler,
Optional< PlayerIdentifier player,
ItemTemplate const *  itemTemplate,
Optional< int32 _count 
)
inlinestatic
1724 {
1725 if (!sObjectMgr->GetItemTemplate(itemTemplate->ItemId))
1726 {
1727 handler->SendErrorMessage(LANG_COMMAND_ITEMIDINVALID, itemTemplate->ItemId);
1728 return false;
1729 }
1730
1731 uint32 itemId = itemTemplate->ItemId;
1732 int32 count = 1;
1733
1734 if (_count)
1735 count = *_count;
1736
1737 if (!count)
1738 count = 1;
1739
1740 if (!player)
1741 player = PlayerIdentifier::FromTargetOrSelf(handler);
1742
1743 if (!player)
1744 return false;
1745
1746 Player* playerTarget = player->GetConnectedPlayer();
1747
1748 if (!playerTarget)
1749 return false;
1750
1751 // Subtract
1752 if (count < 0)
1753 {
1754 // Only have scam check on player accounts
1755 if (playerTarget->GetSession()->GetSecurity() == SEC_PLAYER)
1756 {
1757 if (!playerTarget->HasItemCount(itemId, 0))
1758 {
1759 // output that player don't have any items to destroy
1760 handler->SendErrorMessage(LANG_REMOVEITEM_FAILURE, handler->GetNameLink(playerTarget), itemId);
1761 return false;
1762 }
1763
1764 if (!playerTarget->HasItemCount(itemId, -count))
1765 {
1766 // output that player don't have as many items that you want to destroy
1767 handler->SendErrorMessage(LANG_REMOVEITEM_ERROR, handler->GetNameLink(playerTarget), itemId);
1768 return false;
1769 }
1770 }
1771
1772 // output successful amount of destroyed items
1773 playerTarget->DestroyItemCount(itemId, -count, true, false);
1774 handler->PSendSysMessage(LANG_REMOVEITEM, itemId, -count, handler->GetNameLink(playerTarget));
1775 return true;
1776 }
1777
1778 // Adding items
1779 uint32 noSpaceForCount = 0;
1780
1781 // check space and find places
1782 ItemPosCountVec dest;
1783 InventoryResult msg = playerTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemId, count, &noSpaceForCount);
1784
1785 if (msg != EQUIP_ERR_OK) // convert to possible store amount
1786 count -= noSpaceForCount;
1787
1788 if (!count || dest.empty()) // can't add any
1789 {
1790 handler->SendErrorMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
1791 return false;
1792 }
1793
1794 Item* item = playerTarget->StoreNewItem(dest, itemId, true);
1795
1796 Player* p = handler->GetSession() ? handler->GetSession()->GetPlayer() : nullptr;
1797 // remove binding (let GM give it to another player later)
1798 if (p && p == playerTarget)
1799 {
1800 for (auto const& itemPos : dest)
1801 {
1802 if (Item* item1 = p->GetItemByPos(itemPos.pos))
1803 {
1804 item1->SetBinding(false);
1805 }
1806 }
1807 }
1808
1809 if (p && count && item)
1810 {
1811 p->SendNewItem(item, count, false, true);
1812
1813 if (p != playerTarget)
1814 {
1815 playerTarget->SendNewItem(item, count, true, false);
1816 }
1817 }
1818
1819 if (noSpaceForCount)
1820 handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
1821
1822 return true;
1823 }
std::int32_t int32
Definition Define.h:103
std::uint32_t uint32
Definition Define.h:107
InventoryResult
Definition Item.h:46
@ EQUIP_ERR_OK
Definition Item.h:47
@ NULL_BAG
Definition Item.h:40
@ NULL_SLOT
Definition Item.h:41
@ LANG_ITEM_CANNOT_CREATE
Definition Language.h:543
@ LANG_REMOVEITEM_FAILURE
Definition Language.h:1332
@ LANG_REMOVEITEM_ERROR
Definition Language.h:1333
@ LANG_REMOVEITEM
Definition Language.h:542
@ LANG_COMMAND_ITEMIDINVALID
Definition Language.h:473
#define sObjectMgr
Definition ObjectMgr.h:1650
std::vector< ItemPosCount > ItemPosCountVec
Definition Player.h:778
virtual std::string GetNameLink() const
Definition Chat.h:198
void PSendSysMessage(std::string_view str, bool escapeCharacters=false)
Definition Chat.cpp:211
WorldSession * GetSession()
Definition Chat.h:242
void SendErrorMessage(uint32 entry)
Definition Chat.cpp:216
Definition Item.h:220
Definition Player.h:1083
bool HasItemCount(uint32 item, uint32 count=1, bool inBankAlso=false) const
Definition PlayerStorage.cpp:655
WorldSession * GetSession() const
Definition Player.h:2016
Item * GetItemByPos(uint16 pos) const
Definition PlayerStorage.cpp:441
void SendNewItem(Item *item, uint32 count, bool received, bool created, bool broadcast=false, bool sendChatMessage=true)
Definition PlayerStorage.cpp:4757
void DestroyItemCount(uint32 item, uint32 count, bool update, bool unequip_check=false)
Definition PlayerStorage.cpp:3121
Item * StoreNewItem(ItemPosCountVec const &pos, uint32 item, bool update, int32 randomPropertyId=0)
Definition PlayerStorage.cpp:2524
InventoryResult CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 item, uint32 count, uint32 *no_space_count=nullptr) const
Definition Player.h:1296
AccountTypes GetSecurity() const
Definition WorldSession.h:378
Player * GetPlayer() const
Definition WorldSession.h:381
static Optional< PlayerIdentifier > FromTargetOrSelf(ChatHandler *handler)
Definition ChatCommandTags.h:184

References Player::CanStoreNewItem(), Player::DestroyItemCount(), EQUIP_ERR_OK, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Player::GetItemByPos(), ChatHandler::GetNameLink(), WorldSession::GetPlayer(), WorldSession::GetSecurity(), ChatHandler::GetSession(), Player::GetSession(), Player::HasItemCount(), ItemTemplate::ItemId, LANG_COMMAND_ITEMIDINVALID, LANG_ITEM_CANNOT_CREATE, LANG_REMOVEITEM, LANG_REMOVEITEM_ERROR, LANG_REMOVEITEM_FAILURE, NULL_BAG, NULL_SLOT, ChatHandler::PSendSysMessage(), SEC_PLAYER, ChatHandler::SendErrorMessage(), Player::SendNewItem(), sObjectMgr, and Player::StoreNewItem().

Referenced by GetCommands().

◆ HandleAddItemSetCommand()

static bool misc_commandscript::HandleAddItemSetCommand ( ChatHandler handler,
Variant< Hyperlink< itemset >, uint32 itemSetId 
)
inlinestatic
1826 {
1827 // prevent generation all items with itemset field value '0'
1828 if (!*itemSetId)
1829 {
1831 return false;
1832 }
1833
1834 Player* player = handler->GetSession()->GetPlayer();
1835 Player* playerTarget = handler->getSelectedPlayer();
1836
1837 if (!playerTarget)
1838 {
1839 playerTarget = player;
1840 }
1841
1842 bool found = false;
1843
1844 for (auto const& [itemid, itemTemplate] : *sObjectMgr->GetItemTemplateStore())
1845 {
1846 if (itemTemplate.ItemSet == uint32(itemSetId))
1847 {
1848 found = true;
1849 ItemPosCountVec dest;
1850 InventoryResult msg = playerTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemTemplate.ItemId, 1);
1851
1852 if (msg == EQUIP_ERR_OK)
1853 {
1854 Item* item = playerTarget->StoreNewItem(dest, itemTemplate.ItemId, true);
1855
1856 // remove binding (let GM give it to another player later)
1857 if (player == playerTarget)
1858 {
1859 item->SetBinding(false);
1860 }
1861
1862 player->SendNewItem(item, 1, false, true);
1863
1864 if (player != playerTarget)
1865 {
1866 playerTarget->SendNewItem(item, 1, true, false);
1867 }
1868 }
1869 else
1870 {
1871 player->SendEquipError(msg, nullptr, nullptr, itemTemplate.ItemId);
1872 handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemTemplate.ItemId, 1);
1873 }
1874 }
1875 }
1876
1877 if (!found)
1878 {
1880 return false;
1881 }
1882
1883 return true;
1884 }
@ LANG_NO_ITEMS_FROM_ITEMSET_FOUND
Definition Language.h:548
Player * getSelectedPlayer() const
Definition Chat.cpp:374
void SetBinding(bool val)
Definition Item.h:235
void SendEquipError(InventoryResult msg, Item *pItem, Item *pItem2=nullptr, uint32 itemid=0)
Definition PlayerStorage.cpp:4021

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
782 {
783 if (!target)
784 {
785 target = PlayerIdentifier::FromTarget(handler);
786 }
787
788 if (!target)
789 {
790 return false;
791 }
792
793 Player* _player = handler->GetSession()->GetPlayer();
794 if (target->GetGUID() == _player->GetGUID())
795 {
797 return false;
798 }
799
800 std::string nameLink = handler->playerLink(target->GetName());
801
802 if (target->IsConnected())
803 {
804 auto targetPlayer = target->GetConnectedPlayer();
805
806 // check online security
807 if (handler->HasLowerSecurity(targetPlayer))
808 {
809 return false;
810 }
811
812 Map* map = targetPlayer->GetMap();
813 if (map->IsBattlegroundOrArena())
814 {
815 // only allow if gm mode is on
816 if (!_player->IsGameMaster())
817 {
818 handler->SendErrorMessage(LANG_CANNOT_GO_TO_BG_GM, nameLink);
819 return false;
820 }
821
822 if (!_player->GetMap()->IsBattlegroundOrArena())
823 {
824 _player->SetEntryPoint();
825 }
826
827 _player->SetBattlegroundId(targetPlayer->GetBattlegroundId(), targetPlayer->GetBattlegroundTypeId(), PLAYER_MAX_BATTLEGROUND_QUEUES, false, false, TEAM_NEUTRAL);
828 }
829 else if (map->IsDungeon())
830 {
831 // we have to go to instance, and can go to player only if:
832 // 1) we are in his group (either as leader or as member)
833 // 2) we are not bound to any group and have GM mode on
834 if (_player->GetGroup())
835 {
836 // we are in group, we can go only if we are in the player group
837 if (_player->GetGroup() != targetPlayer->GetGroup())
838 {
840 return false;
841 }
842 }
843 else
844 {
845 // we are not in group, let's verify our GM mode
846 if (!_player->IsGameMaster())
847 {
849 return false;
850 }
851 }
852
853 // if the GM is bound to another instance, he will not be bound to another one
854 InstancePlayerBind* bind = sInstanceSaveMgr->PlayerGetBoundInstance(_player->GetGUID(), targetPlayer->GetMapId(), targetPlayer->GetDifficulty(map->IsRaid()));
855 if (!bind)
856 {
857 if (InstanceSave* save = sInstanceSaveMgr->GetInstanceSave(target->GetConnectedPlayer()->GetInstanceId()))
858 {
859 sInstanceSaveMgr->PlayerBindToInstance(_player->GetGUID(), save, !save->CanReset(), _player);
860 }
861 }
862
863 if (map->IsRaid())
864 {
865 _player->SetRaidDifficulty(targetPlayer->GetRaidDifficulty());
866 }
867 else
868 {
869 _player->SetDungeonDifficulty(targetPlayer->GetDungeonDifficulty());
870 }
871 }
872
873 handler->PSendSysMessage(LANG_APPEARING_AT, nameLink);
874
875 // stop flight if need
876 if (_player->IsInFlight())
877 {
878 _player->GetMotionMaster()->MovementExpired();
879 _player->CleanupAfterTaxiFlight();
880 }
881 else // save only in non-flight case
882 {
883 _player->SaveRecallPosition();
884 }
885
886 if (_player->TeleportTo(targetPlayer->GetMapId(), targetPlayer->GetPositionX(), targetPlayer->GetPositionY(), targetPlayer->GetPositionZ() + 0.25f, _player->GetOrientation(), TELE_TO_GM_MODE, targetPlayer))
887 {
888 _player->SetPhaseMask(targetPlayer->GetPhaseMask() | 1, false);
889 }
890 }
891 else
892 {
893 // check offline security
894 if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
895 {
896 return false;
897 }
898
899 handler->PSendSysMessage(LANG_APPEARING_AT, nameLink);
900
901 // to point where player stay (if loaded)
902 float x, y, z, o;
903 uint32 map;
904 bool in_flight;
905
906 if (!Player::LoadPositionFromDB(map, x, y, z, o, in_flight, target->GetGUID().GetCounter()))
907 {
908 return false;
909 }
910
911 // stop flight if need
912 if (_player->IsInFlight())
913 {
914 _player->GetMotionMaster()->MovementExpired();
915 _player->CleanupAfterTaxiFlight();
916 }
917 // save only in non-flight case
918 else
919 {
920 _player->SaveRecallPosition();
921 }
922
923 _player->TeleportTo(map, x, y, z, _player->GetOrientation());
924 }
925
926 return true;
927 }
#define sInstanceSaveMgr
Definition InstanceSaveMgr.h:202
@ LANG_CANNOT_GO_TO_INST_PARTY
Definition Language.h:137
@ LANG_CANT_TELEPORT_SELF
Definition Language.h:212
@ LANG_APPEARING_AT
Definition Language.h:146
@ LANG_CANNOT_GO_TO_INST_GM
Definition Language.h:138
@ LANG_CANNOT_GO_TO_BG_GM
Definition Language.h:712
@ TELE_TO_GM_MODE
Definition Player.h:828
@ TEAM_NEUTRAL
Definition SharedDefines.h:762
#define PLAYER_MAX_BATTLEGROUND_QUEUES
Definition SharedDefines.h:176
std::string playerLink(std::string const &name) const
Definition Chat.h:231
bool HasLowerSecurity(Player *target, ObjectGuid guid=ObjectGuid::Empty, bool strong=false)
Definition Chat.cpp:57
Definition InstanceSaveMgr.h:56
Definition Map.h:158
bool IsDungeon() const
Definition Map.h:290
bool IsBattlegroundOrArena() const
Definition Map.h:298
bool IsRaid() const
Definition Map.h:292
void MovementExpired(bool reset=true)
Definition MotionMaster.h:180
static ObjectGuid GetGUID(Object const *o)
Definition Object.h:113
void SetDungeonDifficulty(Difficulty dungeon_difficulty)
Definition Player.h:1937
void SetEntryPoint()
Definition Player.cpp:11266
void SetRaidDifficulty(Difficulty raid_difficulty)
Definition Player.h:1938
void SetBattlegroundId(uint32 id, BattlegroundTypeId bgTypeId, uint32 queueSlot, bool invited, bool isRandom, TeamId teamId)
Definition Player.cpp:12288
void SaveRecallPosition()
Definition Player.cpp:5690
Group * GetGroup()
Definition Player.h:2487
bool IsGameMaster() const
Definition Player.h:1177
bool TeleportTo(uint32 mapid, float x, float y, float z, float orientation, uint32 options=0, Unit *target=nullptr, bool newInstance=false)
Definition Player.cpp:1342
static bool LoadPositionFromDB(uint32 &mapid, float &x, float &y, float &z, float &o, bool &in_flight, ObjectGuid::LowType guid)
Definition PlayerStorage.cpp:4882
void CleanupAfterTaxiFlight()
Definition Player.cpp:10412
MotionMaster * GetMotionMaster()
Definition Unit.h:1673
bool IsInFlight() const
Definition Unit.h:1619
void SetPhaseMask(uint32 newPhaseMask, bool update) override
Definition Unit.cpp:19137
Map * GetMap() const
Definition Object.h:587
static Optional< PlayerIdentifier > FromTarget(ChatHandler *handler)
Definition ChatCommandTags.cpp:138
Definition InstanceSaveMgr.h:39
float GetOrientation() const
Definition Position.h:124

References Player::CleanupAfterTaxiFlight(), Acore::ChatCommands::PlayerIdentifier::FromTarget(), Player::GetGroup(), Object::GetGUID(), WorldObject::GetMap(), Unit::GetMotionMaster(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), 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(), MotionMaster::MovementExpired(), PLAYER_MAX_BATTLEGROUND_QUEUES, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), Player::SetBattlegroundId(), Player::SetDungeonDifficulty(), Player::SetEntryPoint(), Unit::SetPhaseMask(), Player::SetRaidDifficulty(), sInstanceSaveMgr, TEAM_NEUTRAL, TELE_TO_GM_MODE, and Player::TeleportTo().

Referenced by GetCommands().

◆ HandleAuraCommand()

static bool misc_commandscript::HandleAuraCommand ( ChatHandler handler,
SpellInfo const *  spell 
)
inlinestatic
677 {
678 if (!spell)
679 {
681 return false;
682 }
683
684 if (!SpellMgr::IsSpellValid(spell))
685 {
686 handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
687 return false;
688 }
689
690 Unit* target = handler->getSelectedUnit();
691 if (!target)
692 {
694 return false;
695 }
696
697 Aura::TryRefreshStackOrCreate(spell, MAX_EFFECT_MASK, target, target);
698
699 return true;
700 }
#define MAX_EFFECT_MASK
Definition DBCStructure.h:1639
@ LANG_COMMAND_NOSPELLFOUND
Definition Language.h:483
@ LANG_SELECT_CHAR_OR_CREATURE
Definition Language.h:31
@ LANG_COMMAND_SPELL_BROKEN
Definition Language.h:526
static Aura * TryRefreshStackOrCreate(SpellInfo const *spellproto, uint8 tryEffMask, WorldObject *owner, Unit *caster, int32 *baseAmount=nullptr, Item *castItem=nullptr, ObjectGuid casterGUID=ObjectGuid::Empty, bool *refresh=nullptr, bool periodicReset=false)
Definition SpellAuras.cpp:326
Unit * getSelectedUnit() const
Definition Chat.cpp:386
static bool IsSpellValid(SpellInfo const *spellInfo)
Definition SpellMgr.cpp:441
Definition Unit.h:620

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
703 {
704 if (!spell)
705 {
707 return false;
708 }
709
710 if (!SpellMgr::IsSpellValid(spell))
711 {
712 handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
713 return false;
714 }
715
716 if (!stacks)
717 {
719 return false;
720 }
721
722 Unit* target = handler->getSelectedUnit();
723 if (!target)
724 {
726 return false;
727 }
728
729 Aura* aur = target->GetAura(spell->Id);
730 if (!aur)
731 {
733 return false;
734 }
735
736 if (!spell->StackAmount)
737 {
739 return false;
740 }
741
742 aur->ModStackAmount(stacks);
743
744 return true;
745 }
@ LANG_COMMAND_AURASTACK_CANT_STACK
Definition Language.h:427
@ LANG_COMMAND_AURASTACK_NO_STACK
Definition Language.h:426
@ LANG_COMMAND_AURASTACK_NO_AURA
Definition Language.h:425
Definition SpellAuras.h:87
bool ModStackAmount(int32 num, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT, bool periodicReset=false)
Definition SpellAuras.cpp:1021
Aura * GetAura(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const
Definition Unit.cpp:5637

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
3022 {
3023 Unit* unit = handler->getSelectedUnit();
3024 if (!unit)
3025 {
3026 return false;
3027 }
3028
3029 handler->GetSession()->GetPlayer()->CastSpell(unit, 6277, true);
3030 return true;
3031 }
SpellCastResult CastSpell(SpellCastTargets const &targets, SpellInfo const *spellInfo, CustomSpellValues const *value, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item *castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)
Definition Unit.cpp:1193

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

Referenced by GetCommands().

◆ HandleChangeWeather()

static bool misc_commandscript::HandleChangeWeather ( ChatHandler handler,
uint32  type,
float  grade 
)
inlinestatic
1887 {
1888 // Weather is OFF
1889 if (!sWorld->getBoolConfig(CONFIG_WEATHER))
1890 {
1892 return false;
1893 }
1894
1895 Player* player = handler->GetSession()->GetPlayer();
1896 uint32 zoneid = player->GetZoneId();
1897
1898 Weather* weather = WeatherMgr::FindWeather(zoneid);
1899
1900 if (!weather)
1901 {
1902 weather = WeatherMgr::AddWeather(zoneid);
1903 }
1904
1905 if (!weather)
1906 {
1908 return false;
1909 }
1910
1911 weather->SetWeather(WeatherType(type), grade);
1912
1913 return true;
1914 }
@ LANG_NO_WEATHER
Definition Language.h:438
@ LANG_WEATHER_DISABLED
Definition Language.h:439
WeatherType
Definition SharedDefines.h:3376
@ CONFIG_WEATHER
Definition WorldConfig.h:53
Weather for one zone.
Definition Weather.h:64
uint32 GetZoneId() const
Definition Object.cpp:3144
#define sWorld
Definition World.h:320
Weather * AddWeather(uint32 zone_id)
Add a Weather object to the list.
Definition WeatherMgr.cpp:66
void SetWeather(WeatherType type, float grade)
Set the weather.
Definition Weather.cpp:262
Weather * FindWeather(uint32 id)
Find a Weather object by the given zoneid.
Definition WeatherMgr.cpp:49

References WeatherMgr::AddWeather(), CONFIG_WEATHER, WeatherMgr::FindWeather(), 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
2867 {
2868 if (!target)
2869 {
2870 target = PlayerIdentifier::FromTargetOrSelf(handler);
2871 }
2872
2873 if (!target || !target->IsConnected())
2874 {
2876 return false;
2877 }
2878
2879 Player* playerTarget = target->GetConnectedPlayer();
2880
2881 // check online security
2882 if (handler->HasLowerSecurity(playerTarget))
2883 {
2884 return false;
2885 }
2886
2887 playerTarget->CombatStop();
2888 playerTarget->getHostileRefMgr().deleteReferences();
2889 return true;
2890 }
@ LANG_PLAYER_NOT_FOUND
Definition Language.h:545
void deleteReferences(bool removeFromMap=false)
Definition HostileRefMgr.cpp:125
void CombatStop(bool includingCast=false)
Definition Unit.cpp:10522
HostileRefMgr & getHostileRefMgr()
Definition Unit.h:902

References Unit::CombatStop(), HostileRefMgr::deleteReferences(), Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Unit::getHostileRefMgr(), ChatHandler::HasLowerSecurity(), LANG_PLAYER_NOT_FOUND, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

◆ HandleComeToMeCommand()

static bool misc_commandscript::HandleComeToMeCommand ( ChatHandler handler)
inlinestatic
2819 {
2820 Creature* caster = handler->getSelectedCreature();
2821 if (!caster)
2822 {
2824 return false;
2825 }
2826
2827 Player* player = handler->GetSession()->GetPlayer();
2828
2829 caster->GetMotionMaster()->MovePoint(0, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
2830
2831 return true;
2832 }
@ LANG_SELECT_CREATURE
Definition Language.h:32
Creature * getSelectedCreature() const
Definition Chat.cpp:410
Definition Creature.h:43
void MovePoint(uint32 id, const Position &pos, bool generatePath=true, bool forceDestination=true)
Definition MotionMaster.h:213
float GetPositionZ() const
Definition Position.h:123
float GetPositionX() const
Definition Position.h:121
float GetPositionY() const
Definition Position.h:122

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
1158 {
1159 SendCommandHelpFor(*handler, "");
1160 return true;
1161 }
AC_GAME_API void SendCommandHelpFor(ChatHandler &handler, std::string_view cmd)
Definition ChatCommand.cpp:533

References Acore::ChatCommands::SendCommandHelpFor().

Referenced by GetCommands().

◆ HandleCommentatorCommand()

static bool misc_commandscript::HandleCommentatorCommand ( ChatHandler handler,
Optional< bool >  enableArg 
)
inlinestatic
502 {
503 WorldSession* session = handler->GetSession();
504
505 if (!session)
506 {
507 return false;
508 }
509
510 auto SetCommentatorMod = [&](bool enable)
511 {
512 handler->SendNotification(enable ? "Commentator mode on" : "Commentator mode off");
513 session->GetPlayer()->SetCommentator(enable);
514 };
515
516 if (!enableArg)
517 {
518 if (!AccountMgr::IsPlayerAccount(session->GetSecurity()) && session->GetPlayer()->IsCommentator())
519 {
520 SetCommentatorMod(true);
521 }
522 else
523 {
524 SetCommentatorMod(false);
525 }
526
527 return true;
528 }
529
530 if (*enableArg)
531 {
532 SetCommentatorMod(true);
533 return true;
534 }
535 else
536 {
537 SetCommentatorMod(false);
538 return true;
539 }
540
542 return false;
543 }
@ LANG_USE_BOL
Definition Language.h:308
void SendNotification(std::string_view str)
Definition Chat.cpp:105
bool IsCommentator() const
Definition Player.h:1171
void SetCommentator(bool on)
Definition Player.h:1172
Player session in the World.
Definition WorldSession.h:330
bool IsPlayerAccount(uint32 gmlevel)
Definition AccountMgr.cpp:312

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
1276 {
1277 Player* target = handler->getSelectedPlayer();
1278 if (!target)
1279 {
1281 return false;
1282 }
1283
1284 std::string nameLink = handler->GetNameLink(target);
1285
1286 if (!spell)
1287 {
1288 target->RemoveAllSpellCooldown();
1289 handler->PSendSysMessage(LANG_REMOVEALL_COOLDOWN, nameLink);
1290 }
1291 else
1292 {
1293 if (!SpellMgr::IsSpellValid(*spell))
1294 {
1295 handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell.value()->Id);
1296 return false;
1297 }
1298
1299 target->RemoveSpellCooldown(spell.value()->Id, true);
1300 handler->PSendSysMessage(LANG_REMOVE_COOLDOWN, spell.value()->Id, target == handler->GetSession()->GetPlayer() ? handler->GetAcoreString(LANG_YOU) : nameLink);
1301 }
1302 return true;
1303 }
@ LANG_YOU
Definition Language.h:76
@ LANG_REMOVE_COOLDOWN
Definition Language.h:538
@ LANG_REMOVEALL_COOLDOWN
Definition Language.h:537
virtual std::string GetAcoreString(uint32 entry) const
Definition Chat.cpp:41
void RemoveAllSpellCooldown()
Definition Player.cpp:3596
void RemoveSpellCooldown(uint32 spell_id, bool update=false)
Definition Player.cpp:3545

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
2835 {
2836 Unit* target = handler->getSelectedUnit();
2837 if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
2838 {
2840 return false;
2841 }
2842
2843 if (target->IsPlayer())
2844 if (handler->HasLowerSecurity(target->ToPlayer()))
2845 return false;
2846
2847 if (!target->IsAlive() || !damage)
2848 return true;
2849
2850 if (target->IsCreature() && handler->GetSession()->GetSecurity() == SEC_CONSOLE) // pussywizard
2851 target->ToCreature()->LowerPlayerDamageReq(target->GetMaxHealth());
2852
2853 if (percent)
2854 if (StringStartsWith("pct", *percent))
2855 if (damage <= 100)
2856 damage = target->CountPctFromMaxHealth(damage);
2857
2858 Unit::DealDamage(handler->GetSession()->GetPlayer(), target, damage, nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false, true);
2859
2860 if (target != handler->GetSession()->GetPlayer())
2862
2863 return true;
2864 }
@ SEC_CONSOLE
Definition Common.h:61
@ SPELL_SCHOOL_MASK_NORMAL
Definition SharedDefines.h:297
@ VICTIMSTATE_HIT
Definition Unit.h:85
@ HITINFO_AFFECTS_VICTIM
Definition Unit.h:99
@ DIRECT_DAMAGE
Definition Unit.h:249
bool StringStartsWith(std::string_view haystack, std::string_view needle)
Definition Util.h:401
void LowerPlayerDamageReq(uint32 unDamage, bool damagedByPlayer=true)
Definition Creature.cpp:3831
bool IsPlayer() const
Definition Object.h:201
Player * ToPlayer()
Definition Object.h:202
bool IsCreature() const
Definition Object.h:205
Creature * ToCreature()
Definition Object.h:206
void SendAttackStateUpdate(CalcDamageInfo *damageInfo)
Definition Unit.cpp:6566
uint32 GetMaxHealth() const
Definition Unit.h:1032
bool IsAlive() const
Definition Unit.h:1707
uint32 CountPctFromMaxHealth(int32 pct) const
Definition Unit.h:1044
ObjectGuid GetTarget() const
Definition Unit.h:811
static uint32 DealDamage(Unit *attacker, Unit *victim, uint32 damage, CleanDamage const *cleanDamage=nullptr, DamageEffectType damagetype=DIRECT_DAMAGE, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const *spellProto=nullptr, bool durabilityLoss=true, bool allowGM=false, Spell const *spell=nullptr)
Definition Unit.cpp:824

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
546 {
547 WorldSession* session = handler->GetSession();
548
549 if (!session)
550 {
551 return false;
552 }
553
554 auto SetDevMod = [&](bool enable)
555 {
556 handler->SendNotification(enable ? LANG_DEV_ON : LANG_DEV_OFF);
557 session->GetPlayer()->SetDeveloper(enable);
558 sScriptMgr->OnHandleDevCommand(handler->GetSession()->GetPlayer(), enable);
559 };
560
561 if (!enableArg)
562 {
563 if (!AccountMgr::IsPlayerAccount(session->GetSecurity()) && session->GetPlayer()->IsDeveloper())
564 {
565 SetDevMod(true);
566 }
567 else
568 {
569 SetDevMod(false);
570 }
571
572 return true;
573 }
574
575 if (*enableArg)
576 {
577 SetDevMod(true);
578 return true;
579 }
580 else
581 {
582 SetDevMod(false);
583 return true;
584 }
585
587 return false;
588 }
@ LANG_DEV_ON
Definition Language.h:932
@ LANG_DEV_OFF
Definition Language.h:933
#define sScriptMgr
Definition ScriptMgr.h:727
void SetDeveloper(bool on)
Definition Player.h:1174
bool IsDeveloper() const
Definition Player.h:1173

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
1164 {
1165 Unit* target = handler->getSelectedUnit();
1166
1167 if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
1168 {
1170 return false;
1171 }
1172
1173 if (target->IsPlayer())
1174 {
1175 if (handler->HasLowerSecurity(target->ToPlayer()))
1176 {
1177 return false;
1178 }
1179 }
1180
1181 if (target->IsAlive())
1182 {
1183 if (sWorld->getBoolConfig(CONFIG_DIE_COMMAND_MODE))
1184 {
1185 if (target->IsCreature() && handler->GetSession()->GetSecurity() == SEC_CONSOLE) // pussywizard
1186 {
1187 target->ToCreature()->LowerPlayerDamageReq(target->GetMaxHealth());
1188 }
1189 Unit::Kill(handler->GetSession()->GetPlayer(), target);
1190 }
1191 else
1192 {
1193 Unit::DealDamage(handler->GetSession()->GetPlayer(), target, target->GetHealth(), nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false, true);
1194 }
1195 }
1196
1197 return true;
1198 }
@ CONFIG_DIE_COMMAND_MODE
Definition WorldConfig.h:66
static void Kill(Unit *killer, Unit *victim, bool durabilityLoss=true, WeaponAttackType attackType=BASE_ATTACK, SpellInfo const *spellProto=nullptr, Spell const *spell=nullptr)
Definition Unit.cpp:17790
uint32 GetHealth() const
Definition Unit.h:1031

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
1226 {
1227 Player* player = handler->GetSession()->GetPlayer();
1228
1229 // If player is not mounted, so go out :)
1230 if (!player->IsMounted())
1231 {
1233 return false;
1234 }
1235
1236 if (player->IsInFlight())
1237 {
1239 return false;
1240 }
1241
1242 player->Dismount();
1244 player->SetSpeed(MOVE_RUN, 1, true);
1245 player->SetSpeed(MOVE_FLIGHT, 1, true);
1246 return true;
1247 }
@ LANG_CHAR_NON_MOUNTED
Definition Language.h:54
@ LANG_YOU_IN_FLIGHT
Definition Language.h:50
@ SPELL_AURA_MOUNTED
Definition SpellAuraDefines.h:141
@ MOVE_FLIGHT
Definition UnitDefines.h:355
@ MOVE_RUN
Definition UnitDefines.h:350
void Dismount()
Definition Unit.cpp:13609
bool IsMounted() const
Definition Unit.h:1800
void SetSpeed(UnitMoveType mtype, float rate, bool forced=false)
Definition Unit.cpp:14521
void RemoveAurasByType(AuraType auraType, ObjectGuid casterGUID=ObjectGuid::Empty, Aura *except=nullptr, bool negative=true, bool positive=true)
Definition Unit.cpp:5166

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
2893 {
2894 sArenaTeamMgr->DistributeArenaPoints();
2895 return true;
2896 }
#define sArenaTeamMgr
Definition ArenaTeamMgr.h:69

References sArenaTeamMgr.

Referenced by GetCommands().

◆ HandleFreezeCommand()

static bool misc_commandscript::HandleFreezeCommand ( ChatHandler handler,
Optional< PlayerIdentifier target 
)
inlinestatic
2899 {
2900 Creature* creatureTarget = handler->getSelectedCreature();
2901
2902 if (!target && !creatureTarget)
2903 {
2904 target = PlayerIdentifier::FromTargetOrSelf(handler);
2905 }
2906
2907 if (!target && !creatureTarget)
2908 {
2910 return false;
2911 }
2912
2913 Player* playerTarget = target->GetConnectedPlayer();
2914 if (playerTarget && !creatureTarget)
2915 {
2916 handler->PSendSysMessage(LANG_COMMAND_FREEZE, target->GetName());
2917
2918 if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_FREEZE))
2919 {
2920 Aura::TryRefreshStackOrCreate(spellInfo, MAX_EFFECT_MASK, playerTarget, playerTarget);
2921 }
2922
2923 return true;
2924 }
2925 else if (creatureTarget && creatureTarget->IsAlive())
2926 {
2928
2929 if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_FREEZE))
2930 {
2931 Aura::TryRefreshStackOrCreate(spellInfo, MAX_EFFECT_MASK, creatureTarget, creatureTarget);
2932 }
2933
2934 return true;
2935 }
2936
2938 return false;
2939 }
@ LANG_COMMAND_FREEZE
Definition Language.h:1054
#define sSpellMgr
Definition SpellMgr.h:825
virtual LocaleConstant GetSessionDbcLocale() const
Definition Chat.cpp:870
Definition SpellInfo.h:316
constexpr auto SPELL_FREEZE
Definition cs_misc.cpp:59
std::string const GetLocalizeCreatureName(Creature *creature, LocaleConstant locale)
Definition cs_misc.cpp:104

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
1306 {
1307 if (!target)
1308 {
1309 target = PlayerIdentifier::FromTargetOrSelf(handler);
1310 }
1311
1312 WorldObject* object = handler->getSelectedUnit();
1313
1314 if (!object && !target)
1315 {
1316 return false;
1317 }
1318
1319 if (!object && target && target->IsConnected())
1320 {
1321 object = target->GetConnectedPlayer();
1322 }
1323
1324 if (!object)
1325 {
1326 return false;
1327 }
1328
1329 handler->PSendSysMessage(LANG_DISTANCE, handler->GetSession()->GetPlayer()->GetDistance(object), handler->GetSession()->GetPlayer()->GetDistance2d(object), handler->GetSession()->GetPlayer()->GetExactDist(object), handler->GetSession()->GetPlayer()->GetExactDist2d(object));
1330 return true;
1331 }
@ LANG_DISTANCE
Definition Language.h:550
Definition Object.h:461
float GetDistance2d(WorldObject const *obj) const
Definition Object.cpp:1256
float GetDistance(WorldObject const *obj) const
Definition Object.cpp:1238
float GetExactDist2d(const float x, const float y) const
Definition Position.h:170
float GetExactDist(float x, float y, float z) const
Definition Position.h:182

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
591 {
592 if (!target)
593 {
594 target = PlayerIdentifier::FromTargetOrSelf(handler);
595 }
596
597 WorldObject* object = handler->getSelectedUnit();
598
599 if (!object && !target)
600 {
601 return false;
602 }
603
604 if (!object && target && target->IsConnected())
605 {
606 object = target->GetConnectedPlayer();
607 }
608
609 if (!object)
610 {
611 return false;
612 }
613
614 CellCoord const cellCoord = Acore::ComputeCellCoord(object->GetPositionX(), object->GetPositionY());
615 Cell cell(cellCoord);
616
617 uint32 zoneId, areaId;
618 object->GetZoneAndAreaId(zoneId, areaId);
619
620 MapEntry const* mapEntry = sMapStore.LookupEntry(object->GetMapId());
621 AreaTableEntry const* zoneEntry = sAreaTableStore.LookupEntry(zoneId);
622 AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
623
624 float zoneX = object->GetPositionX();
625 float zoneY = object->GetPositionY();
626
627 Map2ZoneCoordinates(zoneX, zoneY, zoneId);
628
629 float groundZ = object->GetMapHeight(object->GetPositionX(), object->GetPositionY(), MAX_HEIGHT);
630 float floorZ = object->GetMapHeight(object->GetPositionX(), object->GetPositionY(), object->GetPositionZ());
631
632 uint32 haveMap = GridTerrainLoader::ExistMap(object->GetMapId(), cell.GridX(), cell.GridY()) ? 1 : 0;
633 uint32 haveVMap = GridTerrainLoader::ExistVMap(object->GetMapId(), cell.GridX(), cell.GridY()) ? 1 : 0;
635
636 if (haveVMap)
637 {
638 if (object->IsOutdoors())
639 {
640 handler->PSendSysMessage("You are outdoors");
641 }
642 else
643 {
644 handler->PSendSysMessage("You are indoors");
645 }
646 }
647 else
648 {
649 handler->PSendSysMessage("no VMAP available for area info");
650 }
651
653 object->GetMapId(), (mapEntry ? mapEntry->name[handler->GetSessionDbcLocale()] : "<unknown>"),
654 zoneId, (zoneEntry ? zoneEntry->area_name[handler->GetSessionDbcLocale()] : "<unknown>"),
655 areaId, (areaEntry ? areaEntry->area_name[handler->GetSessionDbcLocale()] : "<unknown>"),
656 object->GetPhaseMask(),
657 object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), object->GetOrientation(),
658 cell.GridX(), cell.GridY(), cell.CellX(), cell.CellY(), object->GetInstanceId(),
659 zoneX, zoneY, groundZ, floorZ, haveMap, haveVMap, haveMMAP);
660
661 LiquidData const& liquidData = object->GetLiquidData();
662
663 if (liquidData.Status)
664 {
665 handler->PSendSysMessage(LANG_LIQUID_STATUS, liquidData.Level, liquidData.DepthLevel, liquidData.Entry, liquidData.Flags, liquidData.Status);
666 }
667
668 if (object->GetTransport())
669 {
670 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());
671 }
672
673 return true;
674 }
void Map2ZoneCoordinates(float &x, float &y, uint32 zone)
Definition DBCStores.cpp:748
DBCStorage< MapEntry > sMapStore(MapEntryfmt)
DBCStorage< AreaTableEntry > sAreaTableStore(AreaTableEntryfmt)
#define MAX_HEIGHT
Definition GridTerrainData.h:26
@ LANG_LIQUID_STATUS
Definition Language.h:216
@ LANG_MAP_POSITION
Definition Language.h:134
static bool ExistVMap(uint32 mapid, int gx, int gy)
Definition GridTerrainLoader.cpp:122
static bool ExistMap(uint32 mapid, int gx, int gy)
Definition GridTerrainLoader.cpp:95
static MMapMgr * createOrGetMMapMgr()
Definition MMapFactory.cpp:27
dtNavMesh const * GetNavMesh(uint32 mapId)
Definition MMapMgr.cpp:306
uint32 GetMapId() const
Definition Position.h:280
bool IsOutdoors() const
Definition Object.cpp:3169
Transport * GetTransport() const
Definition Object.h:648
MovementInfo m_movementInfo
Definition Object.h:658
CellCoord ComputeCellCoord(float x, float y)
Definition GridDefines.h:193
Definition DBCStructure.h:519
Definition Cell.h:45
Definition GridTerrainData.h:199
float Level
Definition GridTerrainData.h:204
uint32 Flags
Definition GridTerrainData.h:203
uint32 Entry
Definition GridTerrainData.h:202
LiquidStatus Status
Definition GridTerrainData.h:206
float DepthLevel
Definition GridTerrainData.h:205
Definition DBCStructure.h:1326
char const * name[16]
Definition DBCStructure.h:1332
Position pos
Definition Object.h:309
struct MovementInfo::TransportInfo transport

References AreaTableEntry::area_name, Cell::CellX(), Cell::CellY(), Acore::ComputeCellCoord(), MMAP::MMapFactory::createOrGetMMapMgr(), LiquidData::DepthLevel, LiquidData::Entry, GridTerrainLoader::ExistMap(), GridTerrainLoader::ExistVMap(), LiquidData::Flags, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), WorldLocation::GetMapId(), MMAP::MMapMgr::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
1053 {
1054 if (!target)
1055 {
1056 target = PlayerIdentifier::FromTargetOrSelf(handler);
1057 }
1058
1059 if (!target || !target->IsConnected())
1060 {
1061 return false;
1062 }
1063
1064 // check online security
1065 if (handler->HasLowerSecurity(target->GetConnectedPlayer()))
1066 {
1067 return false;
1068 }
1069
1070 auto targetPlayer = target->GetConnectedPlayer();
1071
1072 Group* group = targetPlayer->GetGroup();
1073
1074 std::string nameLink = handler->playerLink(target->GetName());
1075
1076 if (!group)
1077 {
1078 handler->SendErrorMessage(LANG_NOT_IN_GROUP, nameLink);
1079 return false;
1080 }
1081
1082 Map* gmMap = handler->GetSession()->GetPlayer()->GetMap();
1083 bool toInstance = gmMap->Instanceable();
1084
1085 // we are in instance, and can summon only player in our group with us as lead
1086 if (toInstance && (
1087 !handler->GetSession()->GetPlayer()->GetGroup() || (group->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID()) ||
1088 (handler->GetSession()->GetPlayer()->GetGroup()->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID())))
1089 // the last check is a bit excessive, but let it be, just in case
1090 {
1092 return false;
1093 }
1094
1095 for (GroupReference* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
1096 {
1097 Player* player = itr->GetSource();
1098
1099 if (!player || player == handler->GetSession()->GetPlayer() || !player->GetSession())
1100 {
1101 continue;
1102 }
1103
1104 // check online security
1105 if (handler->HasLowerSecurity(player))
1106 {
1107 return false;
1108 }
1109
1110 std::string plNameLink = handler->GetNameLink(player);
1111
1112 if (player->IsBeingTeleported())
1113 {
1114 handler->SendErrorMessage(LANG_IS_TELEPORTED, plNameLink);
1115 return false;
1116 }
1117
1118 if (toInstance)
1119 {
1120 Map* playerMap = player->GetMap();
1121
1122 if (playerMap->Instanceable() && playerMap->GetInstanceId() != gmMap->GetInstanceId())
1123 {
1124 // cannot summon from instance to instance
1125 handler->SendErrorMessage(LANG_CANNOT_SUMMON_TO_INST, plNameLink);
1126 return false;
1127 }
1128 }
1129
1130 handler->PSendSysMessage(LANG_SUMMONING, plNameLink, "");
1131 if (handler->needReportToTarget(player))
1132 {
1134 }
1135
1136 // stop flight if need
1137 if (player->IsInFlight())
1138 {
1139 player->GetMotionMaster()->MovementExpired();
1140 player->CleanupAfterTaxiFlight();
1141 }
1142 // save only in non-flight case
1143 else
1144 {
1145 player->SaveRecallPosition();
1146 }
1147
1148 // before GM
1149 float x, y, z;
1150 handler->GetSession()->GetPlayer()->GetClosePoint(x, y, z, player->GetObjectSize());
1151 player->TeleportTo(handler->GetSession()->GetPlayer()->GetMapId(), x, y, z, player->GetOrientation(), 0, handler->GetSession()->GetPlayer());
1152 }
1153
1154 return true;
1155 }
@ LANG_SUMMONING
Definition Language.h:141
@ LANG_NOT_IN_GROUP
Definition Language.h:150
@ LANG_IS_TELEPORTED
Definition Language.h:135
@ LANG_CANNOT_SUMMON_TO_INST
Definition Language.h:136
@ LANG_SUMMONED_BY
Definition Language.h:142
Definition Chat.h:37
virtual bool needReportToTarget(Player *chr) const
Definition Chat.cpp:864
Definition GroupReference.h:27
Definition Group.h:169
GroupReference * GetFirstMember()
Definition Group.h:243
ObjectGuid GetLeaderGUID() const
Definition Group.cpp:2295
bool Instanceable() const
Definition Map.h:289
uint32 GetInstanceId() const
Definition Map.h:261
bool IsBeingTeleported() const
Definition Player.h:2109
bool GetClosePoint(float &x, float &y, float &z, float size, float distance2d=0, float angle=0, WorldObject const *forWho=nullptr, bool force=false) const
Definition Object.cpp:2708
float GetObjectSize() const
Definition Object.cpp:2780

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
1250 {
1251 ObjectGuid guid = handler->GetSession()->GetPlayer()->GetTarget();
1252
1253 if (!guid)
1254 {
1256 return false;
1257 }
1258
1259 handler->PSendSysMessage(LANG_OBJECT_GUID, guid.ToString());
1260 return true;
1261 }
@ LANG_OBJECT_GUID
Definition Language.h:243
@ LANG_NO_SELECTION
Definition Language.h:242
Definition ObjectGuid.h:118
std::string ToString() const
Definition ObjectGuid.cpp:47

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
1264 {
1266
1267 if (cmd.empty())
1268 {
1270 }
1271
1272 return true;
1273 }

References Acore::ChatCommands::SendCommandHelpFor().

Referenced by GetCommands().

◆ HandleHideAreaCommand()

static bool misc_commandscript::HandleHideAreaCommand ( ChatHandler handler,
uint32  areaID 
)
inlinestatic
1693 {
1694 Player* playerTarget = handler->getSelectedPlayer();
1695 if (!playerTarget)
1696 {
1698 return false;
1699 }
1700
1701 AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaID);
1702 if (!area)
1703 {
1705 return false;
1706 }
1707
1708 int32 offset = area->exploreFlag / 32;
1709 if (offset >= PLAYER_EXPLORED_ZONES_SIZE)
1710 {
1712 return false;
1713 }
1714
1715 uint32 val = uint32((1 << (area->exploreFlag % 32)));
1716 uint32 currFields = playerTarget->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
1717 playerTarget->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, uint32((currFields ^ val)));
1718
1720 return true;
1721 }
@ LANG_UNEXPLORE_AREA
Definition Language.h:623
@ LANG_NO_CHAR_SELECTED
Definition Language.h:149
@ LANG_BAD_VALUE
Definition Language.h:148
#define PLAYER_EXPLORED_ZONES_SIZE
Definition Player.h:72
@ PLAYER_EXPLORED_ZONES_1
Definition UpdateFields.h:357
virtual void SendSysMessage(std::string_view str, bool escapeCharacters=false)
Definition Chat.cpp:160
uint32 GetUInt32Value(uint16 index) const
Definition Object.cpp:305
void SetUInt32Value(uint16 index, uint32 value)
Definition Unit.cpp:21181
uint32 exploreFlag
Definition DBCStructure.h:523

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
1410 {
1411 if (!target)
1412 {
1413 target = PlayerIdentifier::FromTargetOrSelf(handler);
1414 }
1415
1416 if (!target || !target->IsConnected())
1417 {
1418 return false;
1419 }
1420
1421 auto targetPlayer = target->GetConnectedPlayer();
1422
1423 if (handler->GetSession() && target->GetGUID() == handler->GetSession()->GetPlayer()->GetGUID())
1424 {
1426 return false;
1427 }
1428
1429 // check online security
1430 if (handler->HasLowerSecurity(targetPlayer))
1431 {
1432 return false;
1433 }
1434
1435 std::string kickReasonStr = handler->GetAcoreString(LANG_NO_REASON);
1436 if (reason && !reason->empty())
1437 {
1438 kickReasonStr = std::string{ *reason };
1439 }
1440
1441 if (sWorld->getBoolConfig(CONFIG_SHOW_KICK_IN_WORLD))
1442 {
1443 handler->SendWorldText(LANG_COMMAND_KICKMESSAGE_WORLD, (handler->GetSession() ? handler->GetSession()->GetPlayerName() : "Server"), target->GetName(), kickReasonStr);
1444 }
1445 else
1446 {
1447 handler->PSendSysMessage(LANG_COMMAND_KICKMESSAGE, target->GetName());
1448 }
1449
1450 targetPlayer->GetSession()->KickPlayer("HandleKickPlayerCommand");
1451
1452 return true;
1453 }
@ LANG_COMMAND_KICKSELF
Definition Language.h:331
@ LANG_COMMAND_KICKMESSAGE_WORLD
Definition Language.h:1297
@ LANG_NO_REASON
Definition Language.h:813
@ LANG_COMMAND_KICKMESSAGE
Definition Language.h:332
@ CONFIG_SHOW_KICK_IN_WORLD
Definition WorldConfig.h:89
void SendWorldText(std::string_view str)
Definition Chat.cpp:131
const std::string & GetName() const
Definition ScriptObject.h:53
std::string const & GetPlayerName() const
Definition WorldSession.cpp:210

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
1534 {
1535 TeamId teamId;
1536
1537 if (!team)
1538 {
1539 teamId = TEAM_NEUTRAL;
1540 }
1541 else if (StringEqualI(team->substr(0, 6), "horde"))
1542 {
1543 teamId = TEAM_HORDE;
1544 }
1545 else if (StringEqualI(team->substr(0, 9), "alliance"))
1546 {
1547 teamId = TEAM_ALLIANCE;
1548 }
1549 else
1550 {
1551 return false;
1552 }
1553
1554 GraveyardStruct const* graveyard = sGraveyard->GetGraveyard(graveyardId);
1555
1556 if (!graveyard)
1557 {
1558 handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDNOEXIST, graveyardId);
1559 return false;
1560 }
1561
1562 Player* player = handler->GetSession()->GetPlayer();
1563 uint32 zoneId = player->GetZoneId();
1564
1565 AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(zoneId);
1566 if (!areaEntry || areaEntry->zone != 0)
1567 {
1568 handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDWRONGZONE, graveyardId, zoneId);
1569 return false;
1570 }
1571
1572 if (sGraveyard->AddGraveyardLink(graveyardId, zoneId, teamId))
1573 {
1574 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDLINKED, graveyardId, zoneId);
1575 }
1576 else
1577 {
1578 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDALRLINKED, graveyardId, zoneId);
1579 }
1580
1581 return true;
1582 }
#define sGraveyard
Definition GameGraveyard.h:74
@ LANG_COMMAND_GRAVEYARDALRLINKED
Definition Language.h:488
@ LANG_COMMAND_GRAVEYARDNOEXIST
Definition Language.h:487
@ LANG_COMMAND_GRAVEYARDWRONGZONE
Definition Language.h:490
@ LANG_COMMAND_GRAVEYARDLINKED
Definition Language.h:489
TeamId
Definition SharedDefines.h:759
@ TEAM_ALLIANCE
Definition SharedDefines.h:760
@ TEAM_HORDE
Definition SharedDefines.h:761
bool StringEqualI(std::string_view a, std::string_view b)
Definition Util.cpp:592
uint32 zone
Definition DBCStructure.h:522
Definition GameGraveyard.h:27

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
3047 {
3048 Player* player = handler->GetSession()->GetPlayer();
3049 handler->GetSession()->SendShowMailBox(player->GetGUID());
3050 return true;
3051 }
void SendShowMailBox(ObjectGuid guid)
Definition NPCHandler.cpp:72

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

Referenced by GetCommands().

◆ HandleMaxSkillCommand()

static bool misc_commandscript::HandleMaxSkillCommand ( ChatHandler handler)
inlinestatic
1917 {
1918 Player* SelectedPlayer = handler->getSelectedPlayer();
1919 if (!SelectedPlayer)
1920 {
1922 return false;
1923 }
1924
1925 // each skills that have max skill value dependent from level seted to current level max skill value
1926 SelectedPlayer->UpdateSkillsToMaxSkillsForLevel();
1927 return true;
1928 }
void UpdateSkillsToMaxSkillsForLevel()
Definition PlayerUpdates.cpp:1130

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

Referenced by GetCommands().

◆ HandleMovegensCommand()

static bool misc_commandscript::HandleMovegensCommand ( ChatHandler handler)
inlinestatic
2685 {
2686 Unit* unit = handler->getSelectedUnit();
2687 if (!unit)
2688 {
2690 return false;
2691 }
2692
2693 handler->PSendSysMessage(LANG_MOVEGENS_LIST, (unit->IsPlayer() ? "Player" : "Creature"), unit->GetGUID().ToString());
2694
2695 MotionMaster* motionMaster = unit->GetMotionMaster();
2696 float x, y, z;
2697 motionMaster->GetDestination(x, y, z);
2698
2699 for (uint8 i = 0; i < MAX_MOTION_SLOT; ++i)
2700 {
2701 MovementGenerator* movementGenerator = motionMaster->GetMotionSlot(i);
2702 if (!movementGenerator)
2703 {
2704 handler->SendSysMessage("Empty");
2705 continue;
2706 }
2707
2708 switch (movementGenerator->GetMovementGeneratorType())
2709 {
2710 case IDLE_MOTION_TYPE:
2712 break;
2713 case RANDOM_MOTION_TYPE:
2715 break;
2718 break;
2721 break;
2724 break;
2725 case CHASE_MOTION_TYPE:
2726 {
2727 Unit* target = nullptr;
2728 if (unit->IsPlayer())
2729 {
2730 target = static_cast<ChaseMovementGenerator<Player> const*>(movementGenerator)->GetTarget();
2731 }
2732 else
2733 {
2734 target = static_cast<ChaseMovementGenerator<Creature> const*>(movementGenerator)->GetTarget();
2735 }
2736
2737 if (!target)
2738 {
2740 }
2741 else if (target->IsPlayer())
2742 {
2743 handler->PSendSysMessage(LANG_MOVEGENS_CHASE_PLAYER, target->GetName(), target->GetGUID().ToString());
2744 }
2745 else
2746 {
2747 handler->PSendSysMessage(LANG_MOVEGENS_CHASE_CREATURE, target->GetName(), target->GetGUID().ToString());
2748 }
2749 break;
2750 }
2751 case FOLLOW_MOTION_TYPE:
2752 {
2753 Unit* target = nullptr;
2754 if (unit->IsPlayer())
2755 {
2756 target = static_cast<FollowMovementGenerator<Player> const*>(movementGenerator)->GetTarget();
2757 }
2758 else
2759 {
2760 target = static_cast<FollowMovementGenerator<Creature> const*>(movementGenerator)->GetTarget();
2761 }
2762
2763 if (!target)
2764 {
2766 }
2767 else if (target->IsPlayer())
2768 {
2769 handler->PSendSysMessage(LANG_MOVEGENS_FOLLOW_PLAYER, target->GetName(), target->GetGUID().ToString());
2770 }
2771 else
2772 {
2773 handler->PSendSysMessage(LANG_MOVEGENS_FOLLOW_CREATURE, target->GetName(), target->GetGUID().ToString());
2774 }
2775 break;
2776 }
2777 case HOME_MOTION_TYPE:
2778 {
2779 if (unit->IsCreature())
2780 {
2782 }
2783 else
2784 {
2786 }
2787 break;
2788 }
2789 case FLIGHT_MOTION_TYPE:
2791 break;
2792 case POINT_MOTION_TYPE:
2793 {
2794 handler->PSendSysMessage(LANG_MOVEGENS_POINT, x, y, z);
2795 break;
2796 }
2799 break;
2802 break;
2803 case EFFECT_MOTION_TYPE:
2805 break;
2806 default:
2807 handler->PSendSysMessage(LANG_MOVEGENS_UNKNOWN, movementGenerator->GetMovementGeneratorType());
2808 break;
2809 }
2810 }
2811 return true;
2812 }
std::uint8_t uint8
Definition Define.h:109
@ LANG_MOVEGENS_FOLLOW_PLAYER
Definition Language.h:934
@ LANG_MOVEGENS_EFFECT
Definition Language.h:937
@ LANG_MOVEGENS_UNKNOWN
Definition Language.h:590
@ LANG_MOVEGENS_CHASE_PLAYER
Definition Language.h:584
@ LANG_MOVEGENS_IDLE
Definition Language.h:579
@ LANG_MOVEGENS_CONFUSED
Definition Language.h:583
@ LANG_MOVEGENS_FOLLOW_CREATURE
Definition Language.h:935
@ LANG_MOVEGENS_FOLLOW_NULL
Definition Language.h:936
@ LANG_MOVEGENS_DISTRACT
Definition Language.h:658
@ LANG_MOVEGENS_CHASE_CREATURE
Definition Language.h:585
@ LANG_MOVEGENS_RANDOM
Definition Language.h:580
@ LANG_MOVEGENS_WAYPOINT
Definition Language.h:581
@ LANG_MOVEGENS_POINT
Definition Language.h:656
@ LANG_MOVEGENS_ANIMAL_RANDOM
Definition Language.h:582
@ LANG_MOVEGENS_CHASE_NULL
Definition Language.h:586
@ LANG_MOVEGENS_FLIGHT
Definition Language.h:589
@ LANG_MOVEGENS_HOME_CREATURE
Definition Language.h:587
@ LANG_MOVEGENS_HOME_PLAYER
Definition Language.h:588
@ LANG_MOVEGENS_LIST
Definition Language.h:578
@ LANG_MOVEGENS_FEAR
Definition Language.h:657
@ MAX_MOTION_SLOT
Definition MotionMaster.h:66
@ DISTRACT_MOTION_TYPE
Definition MotionMaster.h:50
@ IDLE_MOTION_TYPE
Definition MotionMaster.h:39
@ CHASE_MOTION_TYPE
Definition MotionMaster.h:45
@ WAYPOINT_MOTION_TYPE
Definition MotionMaster.h:41
@ FLEEING_MOTION_TYPE
Definition MotionMaster.h:49
@ CONFUSED_MOTION_TYPE
Definition MotionMaster.h:44
@ HOME_MOTION_TYPE
Definition MotionMaster.h:46
@ POINT_MOTION_TYPE
Definition MotionMaster.h:48
@ FLIGHT_MOTION_TYPE
Definition MotionMaster.h:47
@ FOLLOW_MOTION_TYPE
Definition MotionMaster.h:54
@ ANIMAL_RANDOM_MOTION_TYPE
Definition MotionMaster.h:43
@ RANDOM_MOTION_TYPE
Definition MotionMaster.h:40
@ EFFECT_MOTION_TYPE
Definition MotionMaster.h:56
Definition TargetedMovementGenerator.h:39
Definition TargetedMovementGenerator.h:76
Definition MotionMaster.h:112
_Ty GetMotionSlot(int slot) const
Definition MotionMaster.h:155
bool GetDestination(float &x, float &y, float &z)
Definition MotionMaster.cpp:976
Definition MovementGenerator.h:28
virtual MovementGeneratorType GetMovementGeneratorType()=0
std::string const & GetName() const
Definition Object.h:514
std::string ToString(Type &&val, Params &&... params)
Definition StringConvert.h:250

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
2461 {
2462 std::string muteReasonStr{ muteReason };
2463
2464 if (notSpeakTime.empty())
2465 {
2466 return false;
2467 }
2468
2469 if (Acore::StringTo<int32>(notSpeakTime).value_or(0) < 0)
2470 {
2472 return false;
2473 }
2474
2475 if (muteReason.empty())
2476 {
2477 muteReasonStr = handler->GetAcoreString(LANG_NO_REASON);
2478 }
2479
2480 if (!player)
2481 {
2482 player = PlayerIdentifier::FromTarget(handler);
2483 }
2484
2485 if (!player)
2486 {
2488 return false;
2489 }
2490
2491 Player* target = player->GetConnectedPlayer();
2492 uint32 accountId = target ? target->GetSession()->GetAccountId() : sCharacterCache->GetCharacterAccountIdByGuid(player->GetGUID());
2493
2494 // find only player from same account if any
2495 if (!target)
2496 if (WorldSession* session = sWorldSessionMgr->FindSession(accountId))
2497 {
2498 target = session->GetPlayer();
2499 }
2500
2501 // must have strong lesser security level
2502 if (handler->HasLowerSecurity(target, player->GetGUID(), true))
2503 {
2504 return false;
2505 }
2506
2508 int32 muteDuration = TimeStringToSecs(notSpeakTime);
2509 if (muteDuration <= 0)
2510 {
2511 muteDuration = Acore::StringTo<int32>(notSpeakTime).value_or(0);
2512 }
2513
2514 if (muteDuration <= 0)
2515 {
2517 return false;
2518 }
2519
2520 std::string muteBy = "";
2521 if (handler->GetSession())
2522 {
2523 muteBy = handler->GetSession()->GetPlayerName();
2524 }
2525 else
2526 {
2527 muteBy = handler->GetAcoreString(LANG_CONSOLE);
2528 }
2529
2530 if (target)
2531 {
2532 // Target is online, mute will be in effect right away.
2533 int64 muteTime = GameTime::GetGameTime().count() + muteDuration;
2534 target->GetSession()->m_muteTime = muteTime;
2535 stmt->SetData(0, muteTime);
2536 std::string nameLink = handler->playerLink(player->GetName());
2537
2538 if (sWorld->getBoolConfig(CONFIG_SHOW_MUTE_IN_WORLD))
2539 {
2540 handler->SendWorldText(LANG_COMMAND_MUTEMESSAGE_WORLD, muteBy, nameLink, secsToTimeString(muteDuration, true), muteReasonStr);
2541 }
2542
2543 ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_CHAT_DISABLED, secsToTimeString(muteDuration, true), muteBy, muteReasonStr);
2544 }
2545 else
2546 {
2547 // Target is offline, mute will be in effect starting from the next login.
2548 stmt->SetData(0, -int32(muteDuration));
2549 }
2550
2551 stmt->SetData(1, muteReasonStr);
2552 stmt->SetData(2, muteBy);
2553 stmt->SetData(3, accountId);
2554 LoginDatabase.Execute(stmt);
2555
2556 stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_MUTE);
2557 stmt->SetData(0, accountId);
2558 stmt->SetData(1, muteDuration / MINUTE);
2559 stmt->SetData(2, muteBy);
2560 stmt->SetData(3, muteReasonStr);
2561 LoginDatabase.Execute(stmt);
2562
2563 std::string nameLink = handler->playerLink(player->GetName());
2564
2565 if (sWorld->getBoolConfig(CONFIG_SHOW_MUTE_IN_WORLD) && !target)
2566 {
2567 handler->SendWorldText(LANG_COMMAND_MUTEMESSAGE_WORLD, muteBy, nameLink, secsToTimeString(muteDuration, true), muteReasonStr);
2568 }
2569 else
2570 {
2571 // pussywizard: notify all online GMs
2572 std::shared_lock<std::shared_mutex> lock(*HashMapHolder<Player>::GetLock());
2574 for (HashMapHolder<Player>::MapType::const_iterator itr = m.begin(); itr != m.end(); ++itr)
2575 if (itr->second->GetSession()->GetSecurity())
2576 ChatHandler(itr->second->GetSession()).PSendSysMessage(target ? LANG_YOU_DISABLE_CHAT : LANG_COMMAND_DISABLE_CHAT_DELAYED,
2577 (handler->GetSession() ? handler->GetSession()->GetPlayerName() : handler->GetAcoreString(LANG_CONSOLE)), nameLink, secsToTimeString(muteDuration, true), muteReasonStr);
2578 }
2579
2580 return true;
2581 }
#define sCharacterCache
Definition CharacterCache.h:83
constexpr auto MINUTE
Definition Common.h:47
DatabaseWorkerPool< LoginDatabaseConnection > LoginDatabase
Accessor to the realm/login database.
Definition DatabaseEnv.cpp:22
std::int64_t int64
Definition Define.h:102
@ LANG_COMMAND_DISABLE_CHAT_DELAYED
Definition Language.h:333
@ LANG_YOUR_CHAT_DISABLED
Definition Language.h:346
@ LANG_COMMAND_MUTEMESSAGE_WORLD
Definition Language.h:1300
@ LANG_YOU_DISABLE_CHAT
Definition Language.h:347
@ LANG_CONSOLE
Definition Language.h:1094
@ LOGIN_UPD_MUTE_TIME
Definition LoginDatabase.h:72
@ LOGIN_INS_ACCOUNT_MUTE
Definition LoginDatabase.h:114
std::string secsToTimeString(uint64 timeInSecs, bool shortText)
Definition Util.cpp:73
uint32 TimeStringToSecs(const std::string &timestring)
Definition Util.cpp:163
@ CONFIG_SHOW_MUTE_IN_WORLD
Definition WorldConfig.h:90
#define sWorldSessionMgr
Definition WorldSessionMgr.h:110
Definition ObjectAccessor.h:41
std::unordered_map< ObjectGuid, T * > MapType
Definition ObjectAccessor.h:47
Acore::Types::is_default< T > SetData(const uint8 index, T value)
Definition PreparedStatement.h:77
Definition PreparedStatement.h:157
uint32 GetAccountId() const
Definition WorldSession.h:380
time_t m_muteTime
Definition WorldSession.h:513
AC_GAME_API std::string GetAcoreString(ChatHandler const *handler, AcoreStrings which)
Definition ChatCommandHelpers.cpp:27
Seconds GetGameTime()
Definition GameTime.cpp:38
HashMapHolder< Player >::MapType const & GetPlayers()
Definition ObjectAccessor.cpp:75

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
2644 {
2645 if (!Utf8ToUpperOnlyLatin(accountName))
2646 {
2647 handler->SendErrorMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
2648 return false;
2649 }
2650
2651 uint32 accountId = AccountMgr::GetId(accountName);
2652 if (!accountId)
2653 {
2654 handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName);
2655 return false;
2656 }
2657
2658 return HandleMuteInfoHelper(handler, accountId, accountName.c_str());
2659 }
@ LANG_ACCOUNT_NOT_EXIST
Definition Language.h:448
bool Utf8ToUpperOnlyLatin(std::string &utf8String)
Definition Util.cpp:532
static bool HandleMuteInfoHelper(ChatHandler *handler, uint32 accountId, char const *accountName)
Definition cs_misc.cpp:2662
uint32 GetId(std::string const &username)
Definition AccountMgr.cpp:236

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
2663 {
2665 stmt->SetData(0, accountId);
2666 PreparedQueryResult result = LoginDatabase.Query(stmt);
2667
2668 if (!result)
2669 {
2670 handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY_EMPTY, accountName);
2671 return true;
2672 }
2673
2674 handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY, accountName);
2675 do
2676 {
2677 Field* fields = result->Fetch();
2678 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>());
2679 } while (result->NextRow());
2680
2681 return true;
2682 }
std::shared_ptr< PreparedResultSet > PreparedQueryResult
Definition DatabaseEnvFwd.h:45
std::chrono::seconds Seconds
Seconds shorthand typedef.
Definition Duration.h:30
@ LANG_COMMAND_MUTEHISTORY_OUTPUT
Definition Language.h:1120
@ LANG_COMMAND_MUTEHISTORY_EMPTY
Definition Language.h:1119
@ LANG_COMMAND_MUTEHISTORY
Definition Language.h:1118
@ LOGIN_SEL_ACCOUNT_MUTE_INFO
Definition LoginDatabase.h:115
Class used to access individual fields of database query result.
Definition Field.h:98
AC_COMMON_API std::string TimeToHumanReadable(Seconds time=0s, std::string_view fmt={})
Definition Timer.cpp:287

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
1585 {
1586 TeamId teamId;
1587
1588 if (!team)
1589 {
1590 teamId = TEAM_NEUTRAL;
1591 }
1592 else if (StringEqualI(team->substr(0, 6), "horde"))
1593 {
1594 teamId = TEAM_HORDE;
1595 }
1596 else if (StringEqualI(team->substr(0, 9), "alliance"))
1597 {
1598 teamId = TEAM_ALLIANCE;
1599 }
1600 else
1601 {
1602 return false;
1603 }
1604
1605 Player* player = handler->GetSession()->GetPlayer();
1606 uint32 zone_id = player->GetZoneId();
1607
1608 GraveyardStruct const* graveyard = sGraveyard->GetClosestGraveyard(player, teamId);
1609
1610 if (graveyard)
1611 {
1612 uint32 graveyardId = graveyard->ID;
1613
1614 GraveyardData const* data = sGraveyard->FindGraveyardData(graveyardId, zone_id);
1615 if (!data)
1616 {
1617 handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDERROR, graveyardId);
1618 return false;
1619 }
1620
1621 std::string team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_NOTEAM);
1622
1623 if (data->teamId == TEAM_NEUTRAL)
1624 {
1625 team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ANY);
1626 }
1627 else if (data->teamId == TEAM_HORDE)
1628 {
1629 team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_HORDE);
1630 }
1631 else if (data->teamId == TEAM_ALLIANCE)
1632 {
1633 team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
1634 }
1635
1636 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDNEAREST, graveyardId, team_name, zone_id);
1637 }
1638 else
1639 {
1640 std::string team_name;
1641
1642 if (teamId == TEAM_NEUTRAL)
1643 {
1644 team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ANY);
1645 }
1646 else if (teamId == TEAM_HORDE)
1647 {
1648 team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_HORDE);
1649 }
1650 else if (teamId == TEAM_ALLIANCE)
1651 {
1652 team_name = handler->GetAcoreString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
1653 }
1654
1655 handler->PSendSysMessage(LANG_COMMAND_ZONENOGRAFACTION, zone_id, team_name);
1656 }
1657
1658 return true;
1659 }
@ LANG_COMMAND_GRAVEYARD_ALLIANCE
Definition Language.h:495
@ LANG_COMMAND_ZONENOGRAFACTION
Definition Language.h:499
@ LANG_COMMAND_GRAVEYARDNEAREST
Definition Language.h:497
@ LANG_COMMAND_GRAVEYARD_NOTEAM
Definition Language.h:493
@ LANG_COMMAND_GRAVEYARDERROR
Definition Language.h:492
@ LANG_COMMAND_GRAVEYARD_HORDE
Definition Language.h:496
@ LANG_COMMAND_GRAVEYARD_ANY
Definition Language.h:494
Definition GameGraveyard.h:38
TeamId teamId
Definition GameGraveyard.h:40
uint32 ID
Definition GameGraveyard.h:28

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
3067 {
3068 if (GameObject* go = handler->GetPlayer()->FindNearestGameObjectOfType(GAMEOBJECT_TYPE_DOOR, range ? *range : 5.0f))
3069 {
3070 go->SetGoState(GO_STATE_ACTIVE);
3071 handler->PSendSysMessage(LANG_CMD_DOOR_OPENED, go->GetName(), go->GetEntry());
3072 return true;
3073 }
3074
3075 handler->SendErrorMessage(LANG_CMD_NO_DOOR_FOUND, range ? *range : 5.0f);
3076 return false;
3077 }
@ GO_STATE_ACTIVE
Definition GameObjectData.h:689
@ LANG_CMD_NO_DOOR_FOUND
Definition Language.h:1156
@ LANG_CMD_DOOR_OPENED
Definition Language.h:1157
@ GAMEOBJECT_TYPE_DOOR
Definition SharedDefines.h:1560
Player * GetPlayer() const
Definition Chat.cpp:36
Definition GameObject.h:120
GameObject * FindNearestGameObjectOfType(GameobjectTypes type, float range) const
Definition Object.cpp:2459

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().

◆ HandlePInfoCommand()

static bool misc_commandscript::HandlePInfoCommand ( ChatHandler handler,
Optional< PlayerIdentifier target 
)
inlinestatic
1975 {
1976 if (!target)
1977 {
1978 target = PlayerIdentifier::FromTargetOrSelf(handler);
1979 }
1980
1981 if (!target)
1982 {
1983 return false;
1984 }
1985
1986 Player* playerTarget = target->GetConnectedPlayer();
1987
1988 CharacterDatabasePreparedStatement* stmt = nullptr;
1989 LoginDatabasePreparedStatement* loginStmt = nullptr;
1990
1991 // Account data print variables
1992 std::string userName = handler->GetAcoreString(LANG_ERROR);
1993 ObjectGuid::LowType lowguid = target->GetGUID().GetCounter();
1994 uint32 accId = 0;
1995 std::string eMail = handler->GetAcoreString(LANG_ERROR);
1996 std::string regMail = handler->GetAcoreString(LANG_ERROR);
1997 uint32 security = 0;
1998 std::string lastIp = handler->GetAcoreString(LANG_ERROR);
1999 uint8 locked = 0;
2000 std::string lastLogin = handler->GetAcoreString(LANG_ERROR);
2001 uint32 failedLogins = 0;
2002 uint32 latency = 0;
2003 std::string OS = handler->GetAcoreString(LANG_UNKNOWN);
2004
2005 // Mute data print variables
2006 int64 muteTime = -1;
2007 std::string muteReason = handler->GetAcoreString(LANG_NO_REASON);
2008 std::string muteBy = handler->GetAcoreString(LANG_UNKNOWN);
2009
2010 // Ban data print variables
2011 int64 banTime = -1;
2012 std::string banType = handler->GetAcoreString(LANG_UNKNOWN);
2013 std::string banReason = handler->GetAcoreString(LANG_NO_REASON);
2014 std::string bannedBy = handler->GetAcoreString(LANG_UNKNOWN);
2015
2016 // Character data print variables
2017 uint8 raceid, classid = 0; //RACE_NONE, CLASS_NONE
2018 std::string raceStr, classStr = handler->GetAcoreString(LANG_UNKNOWN);
2019 uint8 gender = 0;
2020 int8 locale = handler->GetSessionDbcLocale();
2021 uint32 totalPlayerTime = 0;
2022 uint8 level = 0;
2023 std::string alive = handler->GetAcoreString(LANG_ERROR);
2024 uint32 money = 0;
2025 uint32 xp = 0;
2026 uint32 xptotal = 0;
2027
2028 // Position data print
2029 uint32 mapId;
2030 uint32 areaId;
2031 uint32 phase = 0;
2032 std::string areaName = "";
2033 std::string zoneName = "";
2034
2035 // Guild data print variables defined so that they exist, but are not necessarily used
2036 uint32 guildId = 0;
2037 uint8 guildRankId = 0;
2038 std::string guildName;
2039 std::string guildRank;
2040 std::string note;
2041 std::string officeNote;
2042
2043 // get additional information from Player object
2044 if (playerTarget)
2045 {
2046 // check online security
2047 if (handler->HasLowerSecurity(playerTarget))
2048 {
2049 return false;
2050 }
2051
2052 accId = playerTarget->GetSession()->GetAccountId();
2053 money = playerTarget->GetMoney();
2054 totalPlayerTime = playerTarget->GetTotalPlayedTime();
2055 level = playerTarget->GetLevel();
2056 latency = playerTarget->GetSession()->GetLatency();
2057 raceid = playerTarget->getRace();
2058 classid = playerTarget->getClass();
2059 muteTime = playerTarget->GetSession()->m_muteTime;
2060 mapId = playerTarget->GetMapId();
2061 areaId = playerTarget->GetAreaId();
2062 alive = playerTarget->IsAlive() ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO);
2063 gender = playerTarget->getGender();
2064 phase = playerTarget->GetPhaseMask();
2065 }
2066 // get additional information from DB
2067 else
2068 {
2069 // check offline security
2070 if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
2071 {
2072 return false;
2073 }
2074
2075 // Query informations from the DB
2076 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_PINFO);
2077 stmt->SetData(0, lowguid);
2078 PreparedQueryResult charInfoResult = CharacterDatabase.Query(stmt);
2079
2080 if (!charInfoResult)
2081 {
2082 return false;
2083 }
2084
2085 Field* fields = charInfoResult->Fetch();
2086 totalPlayerTime = fields[0].Get<uint32>();
2087 level = fields[1].Get<uint8>();
2088 money = fields[2].Get<uint32>();
2089 accId = fields[3].Get<uint32>();
2090 raceid = fields[4].Get<uint8>();
2091 classid = fields[5].Get<uint8>();
2092 mapId = fields[6].Get<uint16>();
2093 areaId = fields[7].Get<uint16>();
2094 gender = fields[8].Get<uint8>();
2095 uint32 health = fields[9].Get<uint32>();
2096 uint32 playerFlags = fields[10].Get<uint32>();
2097
2098 if (!health || playerFlags & PLAYER_FLAGS_GHOST)
2099 {
2100 alive = handler->GetAcoreString(LANG_NO);
2101 }
2102 else
2103 {
2104 alive = handler->GetAcoreString(LANG_YES);
2105 }
2106 }
2107
2108 // Query the prepared statement for login data
2109 loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO);
2110 loginStmt->SetData(0, int32(realm.Id.Realm));
2111 loginStmt->SetData(1, accId);
2112
2113 PreparedQueryResult accInfoResult = LoginDatabase.Query(loginStmt);
2114 if (accInfoResult)
2115 {
2116 Field* fields = accInfoResult->Fetch();
2117 userName = fields[0].Get<std::string>();
2118 security = fields[1].Get<uint8>();
2119
2120 // Only fetch these fields if commander has sufficient rights)
2121 if (!handler->GetSession() || handler->GetSession()->GetSecurity() >= AccountTypes(security))
2122 {
2123 eMail = fields[2].Get<std::string>();
2124 regMail = fields[3].Get<std::string>();
2125 lastIp = fields[4].Get<std::string>();
2126 lastLogin = fields[5].Get<std::string>();
2127
2128 if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(lastIp))
2129 {
2130 lastIp.append(" (");
2131 lastIp.append(location->CountryName);
2132 lastIp.append(")");
2133 }
2134 }
2135 else
2136 {
2137 eMail = handler->GetAcoreString(LANG_UNAUTHORIZED);
2138 regMail = handler->GetAcoreString(LANG_UNAUTHORIZED);
2139 lastIp = handler->GetAcoreString(LANG_UNAUTHORIZED);
2140 lastLogin = handler->GetAcoreString(LANG_UNAUTHORIZED);
2141 }
2142
2143 muteTime = fields[6].Get<uint64>();
2144 muteReason = fields[7].Get<std::string>();
2145 muteBy = fields[8].Get<std::string>();
2146 failedLogins = fields[9].Get<uint32>();
2147 locked = fields[10].Get<uint8>();
2148 OS = fields[11].Get<std::string>();
2149 }
2150
2151 // Creates a chat link to the character. Returns nameLink
2152 std::string nameLink = handler->playerLink(target->GetName());
2153
2154 // Returns banType, banTime, bannedBy, banreason
2155 LoginDatabasePreparedStatement* banQuery = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO_BANS);
2156 banQuery->SetData(0, accId);
2157
2158 PreparedQueryResult accBannedResult = LoginDatabase.Query(banQuery);
2159 if (!accBannedResult)
2160 {
2161 banType = handler->GetAcoreString(LANG_CHARACTER);
2162 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_BANS);
2163 stmt->SetData(0, lowguid);
2164 accBannedResult = CharacterDatabase.Query(stmt);
2165 }
2166
2167 if (accBannedResult)
2168 {
2169 Field* fields = accBannedResult->Fetch();
2170 banTime = int64(fields[1].Get<uint64>() ? 0 : fields[0].Get<uint32>());
2171 bannedBy = fields[2].Get<std::string>();
2172 banReason = fields[3].Get<std::string>();
2173 }
2174
2175 // Can be used to query data from World database
2176 WorldDatabasePreparedStatement* xpQuery = WorldDatabase.GetPreparedStatement(WORLD_SEL_REQ_XP);
2177 xpQuery->SetData(0, level);
2178
2179 PreparedQueryResult xpResult = WorldDatabase.Query(xpQuery);
2180 if (xpResult)
2181 {
2182 Field* fields = xpResult->Fetch();
2183 xptotal = fields[0].Get<uint32>();
2184 }
2185
2186 // Can be used to query data from Characters database
2187 CharacterDatabasePreparedStatement* charXpQuery = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_XP);
2188 charXpQuery->SetData(0, lowguid);
2189
2190 PreparedQueryResult charXpResult = CharacterDatabase.Query(charXpQuery);
2191 if (charXpResult)
2192 {
2193 Field* fields = charXpResult->Fetch();
2194 xp = fields[0].Get<uint32>();
2195 ObjectGuid::LowType gguid = fields[1].Get<uint32>();
2196
2197 if (gguid != 0)
2198 {
2200 guildQuery->SetData(0, lowguid);
2201
2202 PreparedQueryResult guildInfoResult = CharacterDatabase.Query(guildQuery);
2203 if (guildInfoResult)
2204 {
2205 Field* guildInfoFields = guildInfoResult->Fetch();
2206 guildId = guildInfoFields[0].Get<uint32>();
2207 guildName = guildInfoFields[1].Get<std::string>();
2208 guildRank = guildInfoFields[2].Get<std::string>();
2209 note = guildInfoFields[3].Get<std::string>();
2210 officeNote = guildInfoFields[4].Get<std::string>();
2211 }
2212 }
2213 }
2214
2215 // Initiate output
2216 // Output I. LANG_PINFO_PLAYER
2217 handler->PSendSysMessage(LANG_PINFO_PLAYER, playerTarget ? "" : handler->GetAcoreString(LANG_OFFLINE), nameLink, target->GetGUID().ToString());
2218
2219 // Output II. LANG_PINFO_GM_ACTIVE if character is gamemaster
2220 if (playerTarget && playerTarget->IsGameMaster())
2221 {
2223 }
2224
2225 // Output III. LANG_PINFO_BANNED if ban exists and is applied
2226 if (banTime >= 0)
2227 {
2228 handler->PSendSysMessage(LANG_PINFO_BANNED, banType, banReason, banTime > 0 ? secsToTimeString(banTime - GameTime::GetGameTime().count(), true) : handler->GetAcoreString(LANG_PERMANENTLY), bannedBy);
2229 }
2230
2231 // Output IV. LANG_PINFO_MUTED if mute is applied
2232 if (muteTime > 0)
2233 {
2234 handler->PSendSysMessage(LANG_PINFO_MUTED, muteReason, secsToTimeString(muteTime - GameTime::GetGameTime().count(), true), muteBy);
2235 }
2236
2237 // Output V. LANG_PINFO_ACC_ACCOUNT
2238 handler->PSendSysMessage(LANG_PINFO_ACC_ACCOUNT, userName, accId, security);
2239
2240 if (playerTarget)
2241 {
2242 uint32 accountFlags = playerTarget->GetSession()->GetAccountFlags();
2244 for (uint8 i = 0; i < MAX_ACCOUNT_FLAG; i++)
2245 if (accountFlags & static_cast<uint32>(accountFlagText[i].flag))
2247 }
2248
2249 // Output VI. LANG_PINFO_ACC_LASTLOGIN
2250 handler->PSendSysMessage(LANG_PINFO_ACC_LASTLOGIN, lastLogin, failedLogins);
2251
2252 // Output VII. LANG_PINFO_ACC_OS
2253 handler->PSendSysMessage(LANG_PINFO_ACC_OS, OS, latency);
2254
2255 // Output VIII. LANG_PINFO_ACC_REGMAILS
2256 handler->PSendSysMessage(LANG_PINFO_ACC_REGMAILS, regMail, eMail);
2257
2258 // Output IX. LANG_PINFO_ACC_IP
2259 handler->PSendSysMessage(LANG_PINFO_ACC_IP, lastIp, locked ? handler->GetAcoreString(LANG_YES) : handler->GetAcoreString(LANG_NO));
2260
2261 // Output X. LANG_PINFO_CHR_LEVEL
2262 if (level != sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
2263 {
2264 handler->PSendSysMessage(LANG_PINFO_CHR_LEVEL_LOW, level, xp, xptotal, (xptotal - xp));
2265 }
2266 else
2267 {
2269 }
2270
2271 // Output XI. LANG_PINFO_CHR_RACE
2272 switch (raceid)
2273 {
2274 case RACE_HUMAN:
2275 raceStr = "Human";
2276 break;
2277 case RACE_ORC:
2278 raceStr = "Orc";
2279 break;
2280 case RACE_DWARF:
2281 raceStr = "Dwarf";
2282 break;
2283 case RACE_NIGHTELF:
2284 raceStr = "Night Elf";
2285 break;
2286 case RACE_UNDEAD_PLAYER:
2287 raceStr = "Undead";
2288 break;
2289 case RACE_TAUREN:
2290 raceStr = "Tauren";
2291 break;
2292 case RACE_GNOME:
2293 raceStr = "Gnome";
2294 break;
2295 case RACE_TROLL:
2296 raceStr = "Troll";
2297 break;
2298 case RACE_BLOODELF:
2299 raceStr = "Blood Elf";
2300 break;
2301 case RACE_DRAENEI:
2302 raceStr = "Draenei";
2303 break;
2304 }
2305
2306 switch (classid)
2307 {
2308 case CLASS_WARRIOR:
2309 classStr = "Warrior";
2310 break;
2311 case CLASS_PALADIN:
2312 classStr = "Paladin";
2313 break;
2314 case CLASS_HUNTER:
2315 classStr = "Hunter";
2316 break;
2317 case CLASS_ROGUE:
2318 classStr = "Rogue";
2319 break;
2320 case CLASS_PRIEST:
2321 classStr = "Priest";
2322 break;
2323 case CLASS_DEATH_KNIGHT:
2324 classStr = "Death Knight";
2325 break;
2326 case CLASS_SHAMAN:
2327 classStr = "Shaman";
2328 break;
2329 case CLASS_MAGE:
2330 classStr = "Mage";
2331 break;
2332 case CLASS_WARLOCK:
2333 classStr = "Warlock";
2334 break;
2335 case CLASS_DRUID:
2336 classStr = "Druid";
2337 break;
2338 }
2339
2340 handler->PSendSysMessage(LANG_PINFO_CHR_RACE, (gender == 0 ? handler->GetAcoreString(LANG_CHARACTER_GENDER_MALE) : handler->GetAcoreString(LANG_CHARACTER_GENDER_FEMALE)), raceStr, classStr);
2341
2342 // Output XII. LANG_PINFO_CHR_ALIVE
2343 handler->PSendSysMessage(LANG_PINFO_CHR_ALIVE, alive);
2344
2345 // Output XIII. LANG_PINFO_CHR_PHASE if player is not in GM mode (GM is in every phase)
2346 if (playerTarget && !playerTarget->IsGameMaster()) // IsInWorld() returns false on loadingscreen, so it's more
2347 {
2348 handler->PSendSysMessage(LANG_PINFO_CHR_PHASE, phase); // precise than just target (safer ?).
2349 }
2350
2351 // However, as we usually just require a target here, we use target instead.
2352 // Output XIV. LANG_PINFO_CHR_MONEY
2353 uint32 gold = money / GOLD;
2354 uint32 silv = (money % GOLD) / SILVER;
2355 uint32 copp = (money % GOLD) % SILVER;
2356 handler->PSendSysMessage(LANG_PINFO_CHR_MONEY, gold, silv, copp);
2357
2358 // Position data
2359 MapEntry const* map = sMapStore.LookupEntry(mapId);
2360 AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId);
2361
2362 if (area)
2363 {
2364 zoneName = area->area_name[locale];
2365
2366 AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->zone);
2367 if (zone)
2368 {
2369 areaName = zoneName;
2370 zoneName = zone->area_name[locale];
2371 }
2372 }
2373
2374 if (zoneName.empty())
2375 zoneName = handler->GetAcoreString(LANG_UNKNOWN);
2376
2377 if (!areaName.empty())
2378 handler->PSendSysMessage(LANG_PINFO_CHR_MAP_WITH_AREA, map->name[locale], zoneName, areaName);
2379 else
2380 handler->PSendSysMessage(LANG_PINFO_CHR_MAP, map->name[locale], zoneName);
2381
2382 // Output XVII. - XVIX. if they are not empty
2383 if (!guildName.empty())
2384 {
2385 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD, guildName, guildId);
2386 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_RANK, guildRank, uint32(guildRankId));
2387
2388 if (!note.empty())
2389 {
2391 }
2392
2393 if (!officeNote.empty())
2394 {
2395 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_ONOTE, officeNote);
2396 }
2397 }
2398
2399 // Output XX. LANG_PINFO_CHR_PLAYEDTIME
2400 handler->PSendSysMessage(LANG_PINFO_CHR_PLAYEDTIME, (secsToTimeString(totalPlayerTime, true)));
2401
2402 // Mail Data - an own query, because it may or may not be useful.
2403 // SQL: "SELECT SUM(CASE WHEN (checked & 1) THEN 1 ELSE 0 END) AS 'readmail', COUNT(*) AS 'totalmail' FROM mail WHERE `receiver` = ?"
2405 mailQuery->SetData(0, lowguid);
2406
2407 PreparedQueryResult mailInfoResult = CharacterDatabase.Query(mailQuery);
2408 if (mailInfoResult)
2409 {
2410 Field* fields = mailInfoResult->Fetch();
2411 uint32 readmail = uint32(fields[0].Get<double>());
2412 uint32 totalmail = uint32(fields[1].Get<uint64>());
2413
2414 // Output XXI. LANG_INFO_CHR_MAILS if at least one mail is given
2415 if (totalmail >= 1)
2416 {
2417 handler->PSendSysMessage(LANG_PINFO_CHR_MAILS, readmail, totalmail);
2418 }
2419 }
2420
2421 return true;
2422 }
@ CHAR_SEL_PINFO_XP
Definition CharacterDatabase.h:338
@ CHAR_SEL_GUILD_MEMBER_EXTENDED
Definition CharacterDatabase.h:146
@ CHAR_SEL_CHAR_PINFO
Definition CharacterDatabase.h:337
@ CHAR_SEL_PINFO_MAILS
Definition CharacterDatabase.h:339
@ CHAR_SEL_PINFO_BANS
Definition CharacterDatabase.h:340
#define MAX_ACCOUNT_FLAG
Definition Common.h:64
AccountTypes
Definition Common.h:56
DatabaseWorkerPool< CharacterDatabaseConnection > CharacterDatabase
Accessor to the character database.
Definition DatabaseEnv.cpp:21
DatabaseWorkerPool< WorldDatabaseConnection > WorldDatabase
Accessor to the world database.
Definition DatabaseEnv.cpp:20
std::int8_t int8
Definition Define.h:105
std::uint64_t uint64
Definition Define.h:106
std::uint16_t uint16
Definition Define.h:108
#define sIPLocation
Definition IPLocation.h:49
@ LANG_YES
Definition Language.h:457
@ LANG_CHARACTER_GENDER_FEMALE
Definition Language.h:818
@ LANG_PINFO_CHR_GUILD_NOTE
Definition Language.h:808
@ LANG_PINFO_CHR_ALIVE
Definition Language.h:802
@ LANG_PINFO_ACC_LASTLOGIN
Definition Language.h:796
@ LANG_CHARACTER
Definition Language.h:1095
@ LANG_UNKNOWN
Definition Language.h:77
@ LANG_PINFO_CHR_PHASE
Definition Language.h:803
@ LANG_ERROR
Definition Language.h:78
@ LANG_PERMANENTLY
Definition Language.h:1096
@ LANG_OFFLINE
Definition Language.h:69
@ LANG_PINFO_CHR_LEVEL_LOW
Definition Language.h:800
@ LANG_PINFO_CHR_PLAYEDTIME
Definition Language.h:810
@ LANG_UNAUTHORIZED
Definition Language.h:814
@ LANG_SUBCMDS_LIST_ENTRY
Definition Language.h:230
@ LANG_PINFO_CHR_RACE
Definition Language.h:801
@ LANG_PINFO_CHR_MAP_WITH_AREA
Definition Language.h:815
@ LANG_PINFO_PLAYER
Definition Language.h:791
@ LANG_PINFO_ACC_OS
Definition Language.h:797
@ LANG_CHARACTER_GENDER_MALE
Definition Language.h:817
@ LANG_PINFO_CHR_MONEY
Definition Language.h:804
@ LANG_PINFO_CHR_LEVEL_HIGH
Definition Language.h:812
@ LANG_NO
Definition Language.h:458
@ LANG_PINFO_CHR_MAP
Definition Language.h:805
@ LANG_PINFO_ACC_IP
Definition Language.h:799
@ LANG_PINFO_BANNED
Definition Language.h:793
@ LANG_PINFO_CHR_GUILD_RANK
Definition Language.h:807
@ LANG_PINFO_ACC_ACCOUNT
Definition Language.h:795
@ LANG_PINFO_ACC_REGMAILS
Definition Language.h:798
@ LANG_PINFO_GM_ACTIVE
Definition Language.h:792
@ LANG_PINFO_CHR_MAILS
Definition Language.h:811
@ LANG_PINFO_CHR_GUILD
Definition Language.h:806
@ LANG_ACCOUNT_FLAGS_PINFO
Definition Language.h:221
@ LANG_PINFO_CHR_GUILD_ONOTE
Definition Language.h:809
@ LANG_PINFO_MUTED
Definition Language.h:794
@ LOGIN_SEL_PINFO
Definition LoginDatabase.h:90
@ LOGIN_SEL_PINFO_BANS
Definition LoginDatabase.h:91
@ PLAYER_FLAGS_GHOST
Definition Player.h:484
@ CLASS_HUNTER
Definition SharedDefines.h:143
@ CLASS_DRUID
Definition SharedDefines.h:151
@ CLASS_SHAMAN
Definition SharedDefines.h:147
@ CLASS_PRIEST
Definition SharedDefines.h:145
@ CLASS_WARRIOR
Definition SharedDefines.h:141
@ CLASS_WARLOCK
Definition SharedDefines.h:149
@ CLASS_MAGE
Definition SharedDefines.h:148
@ CLASS_DEATH_KNIGHT
Definition SharedDefines.h:146
@ CLASS_PALADIN
Definition SharedDefines.h:142
@ CLASS_ROGUE
Definition SharedDefines.h:144
@ SILVER
Definition SharedDefines.h:252
@ GOLD
Definition SharedDefines.h:253
@ RACE_TROLL
Definition SharedDefines.h:78
@ RACE_UNDEAD_PLAYER
Definition SharedDefines.h:75
@ RACE_ORC
Definition SharedDefines.h:72
@ RACE_DRAENEI
Definition SharedDefines.h:81
@ RACE_NIGHTELF
Definition SharedDefines.h:74
@ RACE_BLOODELF
Definition SharedDefines.h:80
@ RACE_DWARF
Definition SharedDefines.h:73
@ RACE_GNOME
Definition SharedDefines.h:77
@ RACE_HUMAN
Definition SharedDefines.h:71
@ RACE_TAUREN
Definition SharedDefines.h:76
@ CONFIG_MAX_PLAYER_LEVEL
Definition WorldConfig.h:186
@ WORLD_SEL_REQ_XP
Definition WorldDatabase.h:117
phase
Definition boss_skadi.cpp:103
std::enable_if_t< std::is_arithmetic_v< T >, T > Get() const
Definition Field.h:112
uint32 LowType
Definition ObjectGuid.h:122
uint32 GetTotalPlayedTime()
Definition Player.h:1208
uint32 GetMoney() const
Definition Player.h:1621
uint8 getGender() const
Definition Unit.h:798
uint8 getClass() const
Definition Unit.h:793
uint8 getRace(bool original=false) const
Definition Unit.cpp:20865
uint8 GetLevel() const
Definition Unit.h:1026
uint32 GetPhaseMask() const
Definition Object.h:502
uint32 GetAreaId() const
Definition Object.cpp:3152
uint32 GetAccountFlags() const
Definition WorldSession.h:335
uint32 GetLatency() const
Definition WorldSession.h:521
AccountFlagText const accountFlagText[MAX_ACCOUNT_FLAG]
Definition cs_misc.cpp:67
Realm realm
Definition World.cpp:111
char const * area_name[16]
Definition DBCStructure.h:527
Definition IPLocation.h:23
uint32 Realm
Definition Realm.h:43
RealmHandle Id
Definition Realm.h:69

References accountFlagText, 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(), 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_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, 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, AccountFlagText::text, WORLD_SEL_REQ_XP, WorldDatabase, and AreaTableEntry::zone.

Referenced by GetCommands().

◆ HandlePlayAllCommand()

static bool misc_commandscript::HandlePlayAllCommand ( ChatHandler handler,
uint32  soundId 
)
inlinestatic
2984 {
2985 if (!sSoundEntriesStore.LookupEntry(soundId))
2986 {
2987 handler->SendErrorMessage(LANG_SOUND_NOT_EXIST, soundId);
2988 return false;
2989 }
2990
2991 sWorldSessionMgr->SendGlobalMessage(WorldPackets::Misc::Playsound(soundId).Write());
2992
2994 return true;
2995 }
DBCStorage< SoundEntriesEntry > sSoundEntriesStore(SoundEntriesfmt)
@ LANG_COMMAND_PLAYED_TO_ALL
Definition Language.h:1063
@ LANG_SOUND_NOT_EXIST
Definition Language.h:211
Definition MiscPackets.h:85

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
2998 {
2999 Unit* unit = handler->getSelectedUnit();
3000 if (!unit)
3001 {
3002 return false;
3003 }
3004
3005 handler->GetSession()->GetPlayer()->CastSpell(unit, MAP_OUTLAND, true);
3006 return true;
3007 }
@ MAP_OUTLAND
Definition AreaDefines.h:216

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
1334 {
1335 if (!target)
1336 {
1337 target = PlayerIdentifier::FromTargetOrSelf(handler);
1338 }
1339
1340 if (!target || !target->IsConnected())
1341 {
1342 return false;
1343 }
1344
1345 auto targetPlayer = target->GetConnectedPlayer();
1346
1347 // check online security
1348 if (handler->HasLowerSecurity(targetPlayer))
1349 {
1350 return false;
1351 }
1352
1353 if (targetPlayer->IsBeingTeleported())
1354 {
1355 handler->SendErrorMessage(LANG_IS_TELEPORTED, handler->playerLink(target->GetName()));
1356 return false;
1357 }
1358
1359 // stop flight if need
1360 if (targetPlayer->IsInFlight())
1361 {
1362 targetPlayer->GetMotionMaster()->MovementExpired();
1363 targetPlayer->CleanupAfterTaxiFlight();
1364 }
1365
1366 targetPlayer->TeleportTo(targetPlayer->m_recallMap, targetPlayer->m_recallX, targetPlayer->m_recallY, targetPlayer->m_recallZ, targetPlayer->m_recallO);
1367 return true;
1368 }

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
2449 {
2450 Player* player = handler->GetSession()->GetPlayer();
2451
2452 Acore::RespawnDo u_do;
2453 Acore::WorldObjectWorker<Acore::RespawnDo> worker(player, u_do);
2454 Cell::VisitGridObjects(player, worker, player->GetGridActivationRange());
2455
2456 return true;
2457 }
Definition GridNotifiers.h:635
float GetGridActivationRange() const
Definition Object.cpp:1616
Definition GridNotifiers.h:250
static void VisitGridObjects(WorldObject const *obj, T &visitor, float radius)
Definition CellImpl.h:165

References WorldObject::GetGridActivationRange(), WorldSession::GetPlayer(), ChatHandler::GetSession(), and Cell::VisitGridObjects().

Referenced by GetCommands().

◆ HandleRespawnCommand()

static bool misc_commandscript::HandleRespawnCommand ( ChatHandler handler)
inlinestatic
2425 {
2426 Player* player = handler->GetSession()->GetPlayer();
2427
2428 Unit* target = handler->getSelectedUnit();
2429 if (player->GetTarget() && target)
2430 {
2431 if (!target->IsCreature() || target->IsPet())
2432 {
2434 return false;
2435 }
2436
2437 if (target->isDead())
2438 {
2439 target->ToCreature()->Respawn(true);
2440 }
2441 return true;
2442 }
2443
2445 return false;
2446 }
void Respawn(bool force=false)
Definition Creature.cpp:2043
bool IsPet() const
Definition Unit.h:747
bool isDead() const
Definition Unit.h:1709

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().

◆ HandleReviveCommand()

static bool misc_commandscript::HandleReviveCommand ( ChatHandler handler,
Optional< PlayerIdentifier target 
)
inlinestatic
1201 {
1202 if (!target)
1203 target = PlayerIdentifier::FromTargetOrSelf(handler);
1204
1205 if (!target)
1206 return false;
1207
1208 if (target->IsConnected())
1209 {
1210 auto targetPlayer = target->GetConnectedPlayer();
1211 targetPlayer->RemoveAurasDueToSpell(27827); // Spirit of Redemption
1212 targetPlayer->ResurrectPlayer(!AccountMgr::IsPlayerAccount(targetPlayer->GetSession()->GetSecurity()) ? 1.0f : 0.5f);
1213 targetPlayer->SpawnCorpseBones();
1214 targetPlayer->SaveToDB(false, false);
1215 }
1216 else
1217 {
1218 CharacterDatabaseTransaction trans(nullptr);
1219 Player::OfflineResurrect(target->GetGUID(), trans);
1220 }
1221
1222 return true;
1223 }
SQLTransaction< CharacterDatabaseConnection > CharacterDatabaseTransaction
Definition DatabaseEnvFwd.h:69
static void OfflineResurrect(ObjectGuid const guid, CharacterDatabaseTransaction trans)
Definition Player.cpp:4613

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

Referenced by GetCommands().

◆ HandleSaveAllCommand()

static bool misc_commandscript::HandleSaveAllCommand ( ChatHandler handler)
inlinestatic
1402 {
1405 return true;
1406 }
@ LANG_PLAYERS_SAVED
Definition Language.h:47
void SaveAllPlayers()
Definition ObjectAccessor.cpp:262

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

Referenced by GetCommands().

◆ HandleSaveCommand()

static bool misc_commandscript::HandleSaveCommand ( ChatHandler handler)
inlinestatic
1371 {
1372 Player* player = handler->GetSession()->GetPlayer();
1373
1374 // save GM account without delay and output message
1375 if (handler->GetSession()->GetSecurity() >= SEC_GAMEMASTER)
1376 {
1377 if (Player* target = handler->getSelectedPlayer())
1378 {
1379 target->SaveToDB(false, false);
1380 }
1381 else
1382 {
1383 player->SaveToDB(false, false);
1384 }
1385
1387 return true;
1388 }
1389
1390 // save if the player has last been saved over 20 seconds ago
1391 uint32 saveInterval = sWorld->getIntConfig(CONFIG_INTERVAL_SAVE);
1392 if (saveInterval == 0 || (saveInterval > 20 * IN_MILLISECONDS && player->GetSaveTimer() <= saveInterval - 20 * IN_MILLISECONDS))
1393 {
1394 player->SaveToDB(false, false);
1395 }
1396
1397 return true;
1398 }
constexpr auto IN_MILLISECONDS
Definition Common.h:53
@ LANG_PLAYER_SAVED
Definition Language.h:46
@ CONFIG_INTERVAL_SAVE
Definition WorldConfig.h:164
void SaveToDB(bool create, bool logout)
Definition PlayerStorage.cpp:7064
uint32 GetSaveTimer() const
Definition Player.h:2374

References CONFIG_INTERVAL_SAVE, WorldSession::GetPlayer(), Player::GetSaveTimer(), WorldSession::GetSecurity(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSession(), IN_MILLISECONDS, LANG_PLAYER_SAVED, Player::SaveToDB(), SEC_GAMEMASTER, 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
1931 {
1932 uint32 skillID = uint32(skillId);
1933
1934 if (skillID <= 0)
1935 {
1936 handler->SendErrorMessage(LANG_INVALID_SKILL_ID, skillID);
1937 return false;
1938 }
1939
1940 Player* target = handler->getSelectedPlayer();
1941 if (!target)
1942 {
1944 return false;
1945 }
1946
1947 SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(skillID);
1948 if (!skillLine)
1949 {
1950 handler->SendErrorMessage(LANG_INVALID_SKILL_ID, uint32(skillID));
1951 return false;
1952 }
1953
1954 bool targetHasSkill = target->GetSkillValue(skillID);
1955
1956 // If our target does not yet have the skill they are trying to add to them, the chosen level also becomes
1957 // the max level of the new profession.
1958 uint16 max = maxPureSkill ? *maxPureSkill : targetHasSkill ? target->GetPureMaxSkillValue(skillID) : uint16(level);
1959
1960 if (level <= 0 || level > max || max <= 0)
1961 {
1962 return false;
1963 }
1964
1965 // If the player has the skill, we get the current skill step. If they don't have the skill, we
1966 // add the skill to the player's book with step 1 (which is the first rank, in most cases something
1967 // like 'Apprentice <skill>'.
1968 target->SetSkill(skillID, targetHasSkill ? target->GetSkillStep(skillID) : 1, level, max);
1969 handler->PSendSysMessage(LANG_SET_SKILL, skillID, skillLine->name[handler->GetSessionDbcLocale()], handler->GetNameLink(target), level, max);
1970 return true;
1971 }
DBCStorage< SkillLineEntry > sSkillLineStore(SkillLinefmt)
@ LANG_INVALID_SKILL_ID
Definition Language.h:531
@ LANG_SET_SKILL
Definition Language.h:528
uint16 GetSkillValue(uint32 skill) const
Definition Player.cpp:5480
uint16 GetSkillStep(uint16 skill) const
Definition Player.cpp:5468
uint16 GetPureMaxSkillValue(uint32 skill) const
Definition Player.cpp:5515
void SetSkill(uint16 id, uint16 step, uint16 currVal, uint16 maxVal)
Definition Player.cpp:5359
Definition DBCStructure.h:1584
char const * name[16]
Definition DBCStructure.h:1588

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
1662 {
1663 Player* playerTarget = handler->getSelectedPlayer();
1664 if (!playerTarget)
1665 {
1667 return false;
1668 }
1669
1670 AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaID);
1671 if (!area)
1672 {
1674 return false;
1675 }
1676
1677 int32 offset = area->exploreFlag / 32;
1678 if (offset >= PLAYER_EXPLORED_ZONES_SIZE)
1679 {
1681 return false;
1682 }
1683
1684 uint32 val = uint32((1 << (area->exploreFlag % 32)));
1685 uint32 currFields = playerTarget->GetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset);
1686 playerTarget->SetUInt32Value(PLAYER_EXPLORED_ZONES_1 + offset, uint32((currFields | val)));
1687
1689 return true;
1690 }
@ LANG_EXPLORE_AREA
Definition Language.h:622

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
203 {
204 auto tokens = args;
205
206 if (args.empty() || !tokens.size())
207 {
208 handler->SetSentErrorMessage(true);
209 return false;
210 }
211
212 auto tokensItr = tokens.begin();
213
214 std::vector<BattlegroundTypeId> allowedArenas;
215 std::string_view arenasStr = *(tokensItr++);
216
217 auto arenaTokens = Acore::Tokenize(arenasStr, ',', false);
218 for (auto const& arenaName : arenaTokens)
219 {
220 if (arenaName == "all")
221 {
222 if (arenaTokens.size() > 1)
223 {
224 handler->SendErrorMessage("Invalid [arena] specified.");
225 return false;
226 }
227
228 allowedArenas.emplace_back(BATTLEGROUND_NA);
229 allowedArenas.emplace_back(BATTLEGROUND_BE);
230 allowedArenas.emplace_back(BATTLEGROUND_RL);
231 allowedArenas.emplace_back(BATTLEGROUND_DS);
232 allowedArenas.emplace_back(BATTLEGROUND_RV);
233 }
234 else if (arenaName == "NA")
235 {
236 allowedArenas.emplace_back(BATTLEGROUND_NA);
237 }
238 else if (arenaName == "BE")
239 {
240 allowedArenas.emplace_back(BATTLEGROUND_BE);
241 }
242 else if (arenaName == "RL")
243 {
244 allowedArenas.emplace_back(BATTLEGROUND_RL);
245 }
246 else if (arenaName == "DS")
247 {
248 allowedArenas.emplace_back(BATTLEGROUND_DS);
249 }
250 else if (arenaName == "RV")
251 {
252 allowedArenas.emplace_back(BATTLEGROUND_RV);
253 }
254 else
255 {
256 handler->SendErrorMessage("Invalid [arena] specified.");
257 return false;
258 }
259 }
260
261 ASSERT(!allowedArenas.empty());
262 BattlegroundTypeId randomizedArenaBgTypeId = Acore::Containers::SelectRandomContainerElement(allowedArenas);
263
264 uint8 count = 0;
265 if (tokensItr != tokens.end())
266 {
267 std::string_view mode = *(tokensItr++);
268
269 if (mode == "1v1")
270 {
271 count = 2;
272 }
273 else if (mode == "2v2")
274 {
275 count = 4;
276 }
277 else if (mode == "3v3")
278 {
279 count = 6;
280 }
281 else if (mode == "5v5")
282 {
283 count = 10;
284 }
285 }
286
287 if (!count)
288 {
289 handler->SendErrorMessage("Invalid bracket. Can be 1v1, 2v2, 3v3, 5v5");
290 return false;
291 }
292
293 if (tokens.size() != uint16(count + 2))
294 {
295 handler->SendErrorMessage("Invalid number of nicknames for this bracket.");
296 return false;
297 }
298
299 uint8 hcnt = count / 2;
300 uint8 error = 0;
301 std::string last_name;
302 Player* plr = nullptr;
303 std::array<Player*, 10> players = {};
304 uint8 cnt = 0;
305
306 for (; tokensItr != tokens.end(); ++tokensItr)
307 {
308 last_name = std::string(*tokensItr);
309 plr = ObjectAccessor::FindPlayerByName(last_name, false);
310
311 if (!plr)
312 {
313 error = 1;
314 break;
315 }
316
317 if (!plr->IsInWorld() || !plr->FindMap() || plr->IsBeingTeleported())
318 {
319 error = 2;
320 break;
321 }
322
323 if (plr->GetMap()->GetEntry()->Instanceable())
324 {
325 error = 3;
326 break;
327 }
328
329 if (plr->IsUsingLfg())
330 {
331 error = 4;
332 break;
333 }
334
335 if (plr->InBattlegroundQueue())
336 {
337 error = 5;
338 break;
339 }
340
341 if (plr->IsInFlight())
342 {
343 error = 10;
344 break;
345 }
346
347 if (!plr->IsAlive())
348 {
349 error = 11;
350 break;
351 }
352
353 const Group* g = plr->GetGroup();
354
355 if (hcnt > 1)
356 {
357 if (!g)
358 {
359 error = 6;
360 break;
361 }
362
363 if (g->isRaidGroup() || g->isBGGroup() || g->isBFGroup() || g->isLFGGroup())
364 {
365 error = 7;
366 break;
367 }
368
369 if (g->GetMembersCount() != hcnt)
370 {
371 error = 8;
372 break;
373 }
374
375 uint8 sti = (cnt < hcnt ? 0 : hcnt);
376 if (sti != cnt && players[sti]->GetGroup() != plr->GetGroup())
377 {
378 error = 9;
379 last_name += " and " + players[sti]->GetName();
380 break;
381 }
382 }
383 else // 1v1
384 {
385 if (g)
386 {
387 error = 12;
388 break;
389 }
390 }
391
392 players[cnt++] = plr;
393 }
394
395 for (uint8 i = 0; i < cnt && !error; ++i)
396 {
397 for (uint8 j = i + 1; j < cnt; ++j)
398 {
399 if (players[i]->GetGUID() == players[j]->GetGUID())
400 {
401 last_name = players[i]->GetName();
402 error = 13;
403 break;
404 }
405 }
406 }
407
408 switch (error)
409 {
410 case 1:
411 handler->PSendSysMessage("Player {} not found.", last_name);
412 break;
413 case 2:
414 handler->PSendSysMessage("Player {} is being teleported.", last_name);
415 break;
416 case 3:
417 handler->PSendSysMessage("Player {} is in instance/battleground/arena.", last_name);
418 break;
419 case 4:
420 handler->PSendSysMessage("Player {} is in LFG system.", last_name);
421 break;
422 case 5:
423 handler->PSendSysMessage("Player {} is queued for battleground/arena.", last_name);
424 break;
425 case 6:
426 handler->PSendSysMessage("Player {} is not in group.", last_name);
427 break;
428 case 7:
429 handler->PSendSysMessage("Player {} is not in normal group.", last_name);
430 break;
431 case 8:
432 handler->PSendSysMessage("Group of player {} has invalid member count.", last_name);
433 break;
434 case 9:
435 handler->PSendSysMessage("Players {} are not in the same group.", last_name);
436 break;
437 case 10:
438 handler->PSendSysMessage("Player {} is in flight.", last_name);
439 break;
440 case 11:
441 handler->PSendSysMessage("Player {} is dead.", last_name);
442 break;
443 case 12:
444 handler->PSendSysMessage("Player {} is in a group.", last_name);
445 break;
446 case 13:
447 handler->PSendSysMessage("Player {} occurs more than once.", last_name);
448 break;
449 }
450
451 if (error)
452 {
453 handler->SetSentErrorMessage(true);
454 return false;
455 }
456
457 Battleground* bgt = sBattlegroundMgr->GetBattlegroundTemplate(BATTLEGROUND_AA);
458 if (!bgt)
459 {
460 handler->SendErrorMessage("Couldn't create arena map!");
461 return false;
462 }
463
464 Battleground* bg = sBattlegroundMgr->CreateNewBattleground(randomizedArenaBgTypeId, GetBattlegroundBracketById(bgt->GetMapId(), bgt->GetBracketId()), ArenaType(hcnt >= 2 ? hcnt : 2), false);
465 if (!bg)
466 {
467 handler->SendErrorMessage("Couldn't create arena map!");
468 return false;
469 }
470
471 bg->StartBattleground();
472
473 BattlegroundTypeId bgTypeId = bg->GetBgTypeID();
474
475 TeamId teamId1 = Player::TeamIdForRace(players[0]->getRace());
476 TeamId teamId2 = (teamId1 == TEAM_ALLIANCE ? TEAM_HORDE : TEAM_ALLIANCE);
477
478 for (uint8 i = 0; i < cnt; ++i)
479 {
480 Player* player = players[i];
481
482 TeamId teamId = (i < hcnt ? teamId1 : teamId2);
483 player->SetEntryPoint();
484
485 uint32 queueSlot = 0;
486 WorldPacket data;
487 sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_IN_PROGRESS, 0, bg->GetStartTime(), bg->GetArenaType(), teamId);
488 player->GetSession()->SendPacket(&data);
489
490 // Remove from LFG queues
491 sLFGMgr->LeaveAllLfgQueues(player->GetGUID(), false);
492
493 player->SetBattlegroundId(bg->GetInstanceID(), bgTypeId, queueSlot, true, false, teamId);
494 sBattlegroundMgr->SendToBattleground(player, bg->GetInstanceID(), bgTypeId);
495 }
496
497 handler->PSendSysMessage("Success! Players are now being teleported to the arena.");
498 return true;
499 }
#define sBattlegroundMgr
Definition BattlegroundMgr.h:187
@ STATUS_IN_PROGRESS
Definition Battleground.h:193
ArenaType
Definition Battleground.h:207
PvPDifficultyEntry const * GetBattlegroundBracketById(uint32 mapid, BattlegroundBracketId id)
Definition DBCStores.cpp:815
#define ASSERT
Definition Errors.h:68
#define sLFGMgr
Definition LFGMgr.h:641
BattlegroundTypeId
Definition SharedDefines.h:3734
@ BATTLEGROUND_AA
Definition SharedDefines.h:3741
@ BATTLEGROUND_BE
Definition SharedDefines.h:3740
@ BATTLEGROUND_RV
Definition SharedDefines.h:3746
@ BATTLEGROUND_NA
Definition SharedDefines.h:3739
@ BATTLEGROUND_DS
Definition SharedDefines.h:3745
@ BATTLEGROUND_RL
Definition SharedDefines.h:3743
Definition Battleground.h:294
uint32 GetMapId() const
Definition Battleground.h:436
uint8 GetArenaType() const
Definition Battleground.h:348
void StartBattleground()
Definition Battleground.cpp:1143
uint32 GetInstanceID() const
Definition Battleground.h:322
uint32 GetStartTime() const
Definition Battleground.h:325
BattlegroundBracketId GetBracketId() const
Definition Battleground.h:321
BattlegroundTypeId GetBgTypeID(bool GetRandom=false) const
Definition Battleground.h:320
void SetSentErrorMessage(bool val)
Definition Chat.h:238
bool isLFGGroup(bool restricted=false) const
Definition Group.cpp:2264
bool isBGGroup() const
Definition Group.cpp:2275
uint32 GetMembersCount() const
Definition Group.h:245
bool isBFGroup() const
Definition Group.cpp:2280
bool isRaidGroup() const
Definition Group.cpp:2270
MapEntry const * GetEntry() const
Definition Map.h:165
bool IsInWorld() const
Definition Object.h:108
static TeamId TeamIdForRace(uint8 race)
Definition Player.cpp:5873
bool InBattlegroundQueue(bool ignoreArena=false) const
Definition Player.cpp:12187
bool IsUsingLfg()
Definition Player.cpp:13047
Map * FindMap() const
Definition Object.h:588
Definition WorldPacket.h:26
void SendPacket(WorldPacket const *packet)
Send a packet to the client.
Definition WorldSession.cpp:251
auto SelectRandomContainerElement(C const &container) -> typename std::add_const< decltype(*std::begin(container))>::type &
Definition Containers.h:133
std::vector< std::string_view > Tokenize(std::string_view str, char sep, bool keepEmpty)
Definition Tokenize.cpp:20
Player * FindPlayerByName(std::string const &name, bool checkInWorld=true)
Definition ObjectAccessor.cpp:271
bool Instanceable() const
Definition DBCStructure.h:1354

References ASSERT, BATTLEGROUND_AA, BATTLEGROUND_BE, BATTLEGROUND_DS, BATTLEGROUND_NA, BATTLEGROUND_RL, BATTLEGROUND_RV, 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(), Player::GetSession(), Battleground::GetStartTime(), Player::InBattlegroundQueue(), MapEntry::Instanceable(), Unit::IsAlive(), Player::IsBeingTeleported(), Group::isBFGroup(), Group::isBGGroup(), Unit::IsInFlight(), Object::IsInWorld(), Group::isLFGGroup(), Group::isRaidGroup(), Player::IsUsingLfg(), ChatHandler::PSendSysMessage(), sBattlegroundMgr, Acore::Containers::SelectRandomContainerElement(), ChatHandler::SendErrorMessage(), WorldSession::SendPacket(), Player::SetBattlegroundId(), Player::SetEntryPoint(), ChatHandler::SetSentErrorMessage(), sLFGMgr, Battleground::StartBattleground(), STATUS_IN_PROGRESS, TEAM_ALLIANCE, TEAM_HORDE, Player::TeamIdForRace(), and Acore::Tokenize().

Referenced by GetCommands().

◆ HandleStringCommand()

static bool misc_commandscript::HandleStringCommand ( ChatHandler handler,
uint32  id,
Optional< uint8 locale 
)
inlinestatic
3054 {
3055 if (!id)
3056 {
3058 return false;
3059 }
3060
3061 std::string str = sObjectMgr->GetAcoreString(id, locale ? static_cast<LocaleConstant>(*locale) : DEFAULT_LOCALE);
3062 handler->SendSysMessage(str);
3063 return true;
3064 }
LocaleConstant
Definition Common.h:117
#define DEFAULT_LOCALE
Definition Common.h:131
@ LANG_CMD_SYNTAX
Definition Language.h:42

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
931 {
932 if (!target)
933 {
934 target = PlayerIdentifier::FromTarget(handler);
935 }
936
937 if (!target)
938 {
939 return false;
940 }
941
942 Player* _player = handler->GetSession()->GetPlayer();
943 if (target->GetGUID() == _player->GetGUID())
944 {
946 return false;
947 }
948
949 std::string nameLink = handler->playerLink(target->GetName());
950
951 if (target->IsConnected())
952 {
953 auto targetPlayer = target->GetConnectedPlayer();
954
955 // check online security
956 if (handler->HasLowerSecurity(targetPlayer))
957 {
958 return false;
959 }
960
961 if (targetPlayer->IsBeingTeleported())
962 {
963 handler->SendErrorMessage(LANG_IS_TELEPORTED, nameLink);
964 return false;
965 }
966
967 Map* map = handler->GetSession()->GetPlayer()->GetMap();
968
969 if (map->IsBattlegroundOrArena())
970 {
971 handler->SendErrorMessage("Can't summon to a battleground!");
972 return false;
973 }
974 else if (map->IsDungeon())
975 {
976 // Allow GM to summon players or only other GM accounts inside instances.
977 if (!sWorld->getBoolConfig(CONFIG_INSTANCE_GMSUMMON_PLAYER))
978 {
979 // pussywizard: prevent unbinding normal player's perm bind by just summoning him >_>
980 if (!targetPlayer->GetSession()->GetSecurity())
981 {
982 handler->SendErrorMessage("Only GMs can be summoned to an instance!");
983 return false;
984 }
985 }
986
987 Map* destMap = targetPlayer->GetMap();
988
989 if (destMap->Instanceable() && destMap->GetInstanceId() != map->GetInstanceId())
990 {
991 sInstanceSaveMgr->PlayerUnbindInstance(target->GetGUID(), map->GetInstanceId(), targetPlayer->GetDungeonDifficulty(), true, targetPlayer);
992 }
993
994 // we are in an instance, and can only summon players in our group with us as leader
995 if (!handler->GetSession()->GetPlayer()->GetGroup() || !targetPlayer->GetGroup() ||
996 (targetPlayer->GetGroup()->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID()) ||
997 (handler->GetSession()->GetPlayer()->GetGroup()->GetLeaderGUID() != handler->GetSession()->GetPlayer()->GetGUID()))
998 // the last check is a bit excessive, but let it be, just in case
999 {
1000 handler->SendErrorMessage(LANG_CANNOT_SUMMON_TO_INST, nameLink);
1001 return false;
1002 }
1003 }
1004
1005 handler->PSendSysMessage(LANG_SUMMONING, nameLink, "");
1006 if (handler->needReportToTarget(targetPlayer))
1007 {
1008 ChatHandler(targetPlayer->GetSession()).PSendSysMessage(LANG_SUMMONED_BY, handler->playerLink(_player->GetName()));
1009 }
1010
1011 // stop flight if need
1012 if (targetPlayer->IsInFlight())
1013 {
1014 targetPlayer->GetMotionMaster()->MovementExpired();
1015 targetPlayer->CleanupAfterTaxiFlight();
1016 }
1017 // save only in non-flight case
1018 else
1019 {
1020 targetPlayer->SaveRecallPosition();
1021 }
1022
1023 // before GM
1024 float x, y, z;
1025 handler->GetSession()->GetPlayer()->GetClosePoint(x, y, z, targetPlayer->GetObjectSize());
1026 targetPlayer->TeleportTo(handler->GetSession()->GetPlayer()->GetMapId(), x, y, z, targetPlayer->GetOrientation(), 0, handler->GetSession()->GetPlayer());
1027 }
1028 else
1029 {
1030 // check offline security
1031 if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
1032 {
1033 return false;
1034 }
1035
1036 handler->PSendSysMessage(LANG_SUMMONING, nameLink, handler->GetAcoreString(LANG_OFFLINE));
1037
1038 // in point where GM stay
1040 handler->GetSession()->GetPlayer()->GetPositionX(),
1041 handler->GetSession()->GetPlayer()->GetPositionY(),
1042 handler->GetSession()->GetPlayer()->GetPositionZ(),
1043 handler->GetSession()->GetPlayer()->GetOrientation(),
1044 handler->GetSession()->GetPlayer()->GetZoneId(),
1045 target->GetGUID());
1046 }
1047
1048 return true;
1049 }
@ CONFIG_INSTANCE_GMSUMMON_PLAYER
Definition WorldConfig.h:45
static void SavePositionInDB(uint32 mapid, float x, float y, float z, float o, uint32 zone, ObjectGuid guid)
Definition PlayerMisc.cpp:84

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
748 {
749 Unit* target = handler->getSelectedUnit();
750 if (!target)
751 {
753 return false;
754 }
755
756 if (spells.holds_alternative<std::string_view>() && spells.get<std::string_view>() == "all")
757 {
758 target->RemoveAllAuras();
759 return true;
760 }
761
762 if (!spells.holds_alternative<SpellInfo const*>())
763 {
765 return false;
766 }
767
768 auto spell = spells.get<SpellInfo const*>();
769
770 if (!SpellMgr::IsSpellValid(spell))
771 {
772 handler->SendErrorMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
773 return false;
774 }
775
776 target->RemoveAurasDueToSpell(spell->Id);
777
778 return true;
779 }
spells
Definition boss_krystallus.cpp:26
void RemoveAurasDueToSpell(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:4965
void RemoveAllAuras()
Definition Unit.cpp:5375

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
3034 {
3035 Player* player = handler->GetSession()->GetPlayer();
3036
3037 if (player->isPossessing())
3038 {
3039 return false;
3040 }
3041
3042 player->StopCastingBindSight();
3043 return true;
3044 }
void StopCastingBindSight(Aura *except=nullptr)
Definition Player.cpp:13135
bool isPossessing() const
Definition Unit.h:1240

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
2942 {
2943 Creature* creatureTarget = handler->getSelectedCreature();
2944
2945 if (!target && !creatureTarget)
2946 {
2947 target = PlayerIdentifier::FromTargetOrSelf(handler);
2948 }
2949
2950 if (!target && !creatureTarget)
2951 {
2953 return false;
2954 }
2955
2956 Player* playerTarget = target->GetConnectedPlayer();
2957
2958 if (!creatureTarget && playerTarget && playerTarget->HasAura(SPELL_FREEZE))
2959 {
2960 handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, target->GetName());
2961 playerTarget->RemoveAurasDueToSpell(SPELL_FREEZE);
2962 return true;
2963 }
2964 else if (creatureTarget && creatureTarget->HasAura(SPELL_FREEZE))
2965 {
2967 creatureTarget->RemoveAurasDueToSpell(SPELL_FREEZE);
2968 return true;
2969 }
2970 else if (!creatureTarget && target && !target->IsConnected())
2971 {
2973 stmt->SetData(0, target->GetGUID().GetCounter());
2974 CharacterDatabase.Execute(stmt);
2975 handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, target->GetName());
2976 return true;
2977 }
2978
2980 return true;
2981 }
@ CHAR_DEL_CHAR_AURA_FROZEN
Definition CharacterDatabase.h:355
@ LANG_COMMAND_UNFREEZE
Definition Language.h:1057
@ LANG_COMMAND_FREEZE_WRONG
Definition Language.h:1056
bool HasAura(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const
Definition Unit.cpp:5777

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
2585 {
2586 if (!target)
2587 {
2588 target = PlayerIdentifier::FromTargetOrSelf(handler);
2589 }
2590
2591 if (!target)
2592 {
2593 return false;
2594 }
2595
2596 Player* playerTarget = target->GetConnectedPlayer();
2597 uint32 accountId = playerTarget ? playerTarget->GetSession()->GetAccountId() : sCharacterCache->GetCharacterAccountIdByGuid(target->GetGUID());
2598
2599 // find only player from same account if any
2600 if (!playerTarget)
2601 {
2602 if (WorldSession* session = sWorldSessionMgr->FindSession(accountId))
2603 {
2604 playerTarget = session->GetPlayer();
2605 }
2606 }
2607
2608 // must have strong lesser security level
2609 if (handler->HasLowerSecurity(playerTarget, target->GetGUID(), true))
2610 {
2611 return false;
2612 }
2613
2614 if (playerTarget)
2615 {
2616 if (playerTarget->CanSpeak())
2617 {
2619 return false;
2620 }
2621
2622 playerTarget->GetSession()->m_muteTime = 0;
2623 }
2624
2626 stmt->SetData(0, 0);
2627 stmt->SetData(1, "");
2628 stmt->SetData(2, "");
2629 stmt->SetData(3, accountId);
2630 LoginDatabase.Execute(stmt);
2631
2632 if (playerTarget)
2633 {
2635 }
2636
2637 handler->PSendSysMessage(LANG_YOU_ENABLE_CHAT, handler->playerLink(target->GetName()));
2638
2639 return true;
2640 }
@ LANG_CHAT_ALREADY_ENABLED
Definition Language.h:348
@ LANG_YOU_ENABLE_CHAT
Definition Language.h:350
@ LANG_YOUR_CHAT_ENABLED
Definition Language.h:349
bool CanSpeak() const
Definition PlayerMisc.cpp:69

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
3010 {
3011 Unit* unit = handler->getSelectedUnit();
3012 if (!unit)
3013 {
3014 unit = handler->GetSession()->GetPlayer();
3015 }
3016
3017 unit->RemoveCharmAuras();
3018 return true;
3019 }
void RemoveCharmAuras()
Definition Unit.cpp:11280

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
1456 {
1457 // No args required for players
1458 if (handler->GetSession() && AccountMgr::IsPlayerAccount(handler->GetSession()->GetSecurity()))
1459 {
1460 if (Player* player = handler->GetSession()->GetPlayer())
1461 {
1462 player->CastSpell(player, SPELL_STUCK, false);
1463 }
1464
1465 return true;
1466 }
1467
1468 if (!target)
1469 {
1470 target = PlayerIdentifier::FromTargetOrSelf(handler);
1471 }
1472
1473 if (!target || !target->IsConnected())
1474 {
1475 if (handler->HasLowerSecurity(nullptr, target->GetGUID()))
1476 return false;
1477
1479 stmt->SetData(0, target->GetGUID().GetCounter());
1480
1481 PreparedQueryResult result = CharacterDatabase.Query(stmt);
1482
1483 if (result)
1484 {
1485 Field* fieldsDB = result->Fetch();
1486 WorldLocation loc(fieldsDB[0].Get<uint16>(), fieldsDB[2].Get<float>(), fieldsDB[3].Get<float>(), fieldsDB[4].Get<float>(), 0.0f);
1487 uint32 zoneId = fieldsDB[1].Get<uint16>();
1488
1489 Player::SavePositionInDB(loc, zoneId, target->GetGUID(), nullptr);
1490
1491 handler->PSendSysMessage(LANG_SUMMONING, target->GetName(), handler->GetAcoreString(LANG_OFFLINE));
1492 }
1493
1494 return true;
1495 }
1496
1497 Player* player = target->GetConnectedPlayer();
1498
1499 if (player->IsInFlight() || player->IsInCombat())
1500 {
1501 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(7355);
1502 if (!spellInfo)
1503 return false;
1504
1505 if (player)
1507
1508 return false;
1509 }
1510
1511 if (location->empty() || *location == "inn")
1512 {
1513 player->TeleportTo(player->m_homebindMapId, player->m_homebindX, player->m_homebindY, player->m_homebindZ, player->GetOrientation());
1514 return true;
1515 }
1516
1517 if (*location == "graveyard")
1518 {
1519 player->RepopAtGraveyard();
1520 return true;
1521 }
1522
1523 if (*location == "startzone")
1524 {
1525 player->TeleportTo(player->GetStartPosition());
1526 return true;
1527 }
1528
1529 //Not a supported argument
1530 return false;
1531 }
@ CHAR_SEL_CHARACTER_HOMEBIND
Definition CharacterDatabase.h:87
@ SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW
Definition SharedDefines.h:1122
float m_homebindZ
Definition Player.h:2392
uint32 m_homebindMapId
Definition Player.h:2388
void RepopAtGraveyard()
Definition Player.cpp:4949
float m_homebindY
Definition Player.h:2391
WorldLocation GetStartPosition() const
Definition Player.cpp:11385
float m_homebindX
Definition Player.h:2390
static void SendCastResult(Player *caster, SpellInfo const *spellInfo, uint8 castCount, SpellCastResult result, SpellCustomErrors customError=SPELL_CUSTOM_ERROR_NONE)
Definition Spell.cpp:4693
bool IsInCombat() const
Definition Unit.h:879
Definition Position.h:255
constexpr auto SPELL_STUCK
Definition cs_misc.cpp:58

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: