TrinityCore
Loading...
Searching...
No Matches
cs_misc.cpp
Go to the documentation of this file.
1/*
2 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#include "ScriptMgr.h"
19#include "AccountMgr.h"
20#include "ArenaTeamMgr.h"
21#include "CellImpl.h"
22#include "CharacterCache.h"
23#include "Chat.h"
24#include "ChatCommand.h"
25#include "DatabaseEnv.h"
26#include "DB2Stores.h"
27#include "DisableMgr.h"
28#include "GridNotifiers.h"
29#include "Group.h"
30#include "IPLocation.h"
31#include "Item.h"
32#include "ItemBonusMgr.h"
33#include "Language.h"
34#include "MiscPackets.h"
35#include "MMapManager.h"
36#include "MotionMaster.h"
37#include "MovementDefines.h"
38#include "ObjectAccessor.h"
39#include "ObjectMgr.h"
40#include "PhasingHandler.h"
41#include "Player.h"
42#include "RealmList.h"
43#include "SpellAuras.h"
44#include "SpellHistory.h"
45#include "SpellMgr.h"
46#include "TerrainMgr.h"
47#include "Transport.h"
48#include "Weather.h"
49#include "World.h"
50#include "WorldSession.h"
51
52#if TRINITY_COMPILER_IS_GCC
53#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
54#endif
55
56using namespace Trinity::ChatCommands;
57
58class misc_commandscript : public CommandScript
59{
60public:
61 misc_commandscript() : CommandScript("misc_commandscript") { }
62
63 std::span<ChatCommandBuilder const> GetCommands() const override
64 {
65 static ChatCommandTable commandTable =
66 {
67 { "additem", HandleAddItemCommand, rbac::RBAC_PERM_COMMAND_ADDITEM, Console::No },
68 { "additem to", HandleAddItemToCommand, rbac::RBAC_PERM_COMMAND_ADDITEM, Console::No },
69 { "additem set", HandleAddItemSetCommand, rbac::RBAC_PERM_COMMAND_ADDITEMSET, Console::No },
70 { "appear", HandleAppearCommand, rbac::RBAC_PERM_COMMAND_APPEAR, Console::No },
71 { "aura", HandleAuraCommand, rbac::RBAC_PERM_COMMAND_AURA, Console::No },
72 { "bank", HandleBankCommand, rbac::RBAC_PERM_COMMAND_BANK, Console::No },
73 { "bindsight", HandleBindSightCommand, rbac::RBAC_PERM_COMMAND_BINDSIGHT, Console::No },
74 { "combatstop", HandleCombatStopCommand, rbac::RBAC_PERM_COMMAND_COMBATSTOP, Console::Yes },
75 { "cometome", HandleComeToMeCommand, rbac::RBAC_PERM_COMMAND_COMETOME, Console::No },
76 { "commands", HandleCommandsCommand, rbac::RBAC_PERM_COMMAND_COMMANDS, Console::Yes },
77 { "cooldown", HandleCooldownCommand, rbac::RBAC_PERM_COMMAND_COOLDOWN, Console::No },
78 { "damage", HandleDamageCommand, rbac::RBAC_PERM_COMMAND_DAMAGE, Console::No },
79 { "damage go", HandleDamageGoCommand, rbac::RBAC_PERM_COMMAND_DAMAGE, Console::No },
80 { "dev", HandleDevCommand, rbac::RBAC_PERM_COMMAND_DEV, Console::No },
81 { "die", HandleDieCommand, rbac::RBAC_PERM_COMMAND_DIE, Console::No },
82 { "dismount", HandleDismountCommand, rbac::RBAC_PERM_COMMAND_DISMOUNT, Console::No },
83 { "distance", HandleGetDistanceCommand, rbac::RBAC_PERM_COMMAND_DISTANCE, Console::No },
84 { "freeze", HandleFreezeCommand, rbac::RBAC_PERM_COMMAND_FREEZE, Console::No },
85 { "gps", HandleGPSCommand, rbac::RBAC_PERM_COMMAND_GPS, Console::No },
86 { "guid", HandleGUIDCommand, rbac::RBAC_PERM_COMMAND_GUID, Console::No },
87 { "help", HandleHelpCommand, rbac::RBAC_PERM_COMMAND_HELP, Console::Yes },
88 { "hidearea", HandleHideAreaCommand, rbac::RBAC_PERM_COMMAND_HIDEAREA, Console::No },
89 { "itemmove", HandleItemMoveCommand, rbac::RBAC_PERM_COMMAND_ITEMMOVE, Console::No },
90 { "kick", HandleKickPlayerCommand, rbac::RBAC_PERM_COMMAND_KICK, Console::Yes },
91 { "linkgrave", HandleLinkGraveCommand, rbac::RBAC_PERM_COMMAND_LINKGRAVE, Console::No },
92 { "listfreeze", HandleListFreezeCommand, rbac::RBAC_PERM_COMMAND_LISTFREEZE, Console::No },
93 { "movegens", HandleMovegensCommand, rbac::RBAC_PERM_COMMAND_MOVEGENS, Console::No },
94 { "mute", HandleMuteCommand, rbac::RBAC_PERM_COMMAND_MUTE, Console::Yes },
95 { "mutehistory", HandleMuteHistoryCommand, rbac::RBAC_PERM_COMMAND_MUTEHISTORY, Console::Yes },
96 { "neargrave", HandleNearGraveCommand, rbac::RBAC_PERM_COMMAND_NEARGRAVE, Console::No },
97 { "pinfo", HandlePInfoCommand, rbac::RBAC_PERM_COMMAND_PINFO, Console::Yes },
98 { "playall", HandlePlayAllCommand, rbac::RBAC_PERM_COMMAND_PLAYALL, Console::No },
99 { "possess", HandlePossessCommand, rbac::RBAC_PERM_COMMAND_POSSESS, Console::No },
100 { "pvpstats", HandlePvPstatsCommand, rbac::RBAC_PERM_COMMAND_PVPSTATS, Console::Yes },
101 { "recall", HandleRecallCommand, rbac::RBAC_PERM_COMMAND_RECALL, Console::No },
102 { "repairitems", HandleRepairitemsCommand, rbac::RBAC_PERM_COMMAND_REPAIRITEMS, Console::Yes },
103 { "respawn", HandleRespawnCommand, rbac::RBAC_PERM_COMMAND_RESPAWN, Console::No },
104 { "revive", HandleReviveCommand, rbac::RBAC_PERM_COMMAND_REVIVE, Console::Yes },
105 { "saveall", HandleSaveAllCommand, rbac::RBAC_PERM_COMMAND_SAVEALL, Console::Yes },
106 { "save", HandleSaveCommand, rbac::RBAC_PERM_COMMAND_SAVE, Console::No },
107 { "setskill", HandleSetSkillCommand, rbac::RBAC_PERM_COMMAND_SETSKILL, Console::No },
108 { "showarea", HandleShowAreaCommand, rbac::RBAC_PERM_COMMAND_SHOWAREA, Console::No },
109 { "summon", HandleSummonCommand, rbac::RBAC_PERM_COMMAND_SUMMON, Console::No },
110 { "unaura", HandleUnAuraCommand, rbac::RBAC_PERM_COMMAND_UNAURA, Console::No },
111 { "unbindsight", HandleUnbindSightCommand, rbac::RBAC_PERM_COMMAND_UNBINDSIGHT, Console::No },
112 { "unfreeze", HandleUnFreezeCommand, rbac::RBAC_PERM_COMMAND_UNFREEZE, Console::No },
113 { "unmute", HandleUnmuteCommand, rbac::RBAC_PERM_COMMAND_UNMUTE, Console::Yes },
114 { "unpossess", HandleUnPossessCommand, rbac::RBAC_PERM_COMMAND_UNPOSSESS, Console::No },
115 { "unstuck", HandleUnstuckCommand, rbac::RBAC_PERM_COMMAND_UNSTUCK, Console::Yes },
116 { "wchange", HandleChangeWeather, rbac::RBAC_PERM_COMMAND_WCHANGE, Console::No },
117 { "mailbox", HandleMailBoxCommand, rbac::RBAC_PERM_COMMAND_MAILBOX, Console::No },
118 };
119 return commandTable;
120 }
121
122 static bool HandlePvPstatsCommand(ChatHandler* handler)
123 {
124 if (sWorld->getBoolConfig(CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE))
125 {
126 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PVPSTATS_FACTIONS_OVERALL);
127 PreparedQueryResult result = CharacterDatabase.Query(stmt);
128
129 if (result)
130 {
131 Field* fields = result->Fetch();
132 uint32 horde_victories = fields[1].GetUInt32();
133
134 if (!(result->NextRow()))
135 return false;
136
137 fields = result->Fetch();
138 uint32 alliance_victories = fields[1].GetUInt32();
139
140 handler->PSendSysMessage(LANG_PVPSTATS, alliance_victories, horde_victories);
141 }
142 else
143 return false;
144 }
145 else
146 handler->PSendSysMessage(LANG_PVPSTATS_DISABLED);
147
148 return true;
149 }
150
151 static bool HandleDevCommand(ChatHandler* handler, Optional<bool> enableArg)
152 {
153 Player* player = handler->GetSession()->GetPlayer();
154
155 if (!enableArg)
156 {
157 handler->GetSession()->SendNotification(player->IsDeveloper() ? LANG_DEV_ON : LANG_DEV_OFF);
158 return true;
159 }
160
161 if (*enableArg)
162 {
163 player->SetDeveloper(true);
164 handler->GetSession()->SendNotification(LANG_DEV_ON);
165 }
166 else
167 {
168 player->SetDeveloper(false);
169 handler->GetSession()->SendNotification(LANG_DEV_OFF);
170 }
171
172 return true;
173 }
174
175 static bool HandleGPSCommand(ChatHandler* handler, char const* args)
176 {
177 WorldObject* object = nullptr;
178 if (*args)
179 {
180 HighGuid guidHigh;
181 ObjectGuid::LowType guidLow = handler->extractLowGuidFromLink((char*)args, guidHigh);
182 if (!guidLow)
183 return false;
184 switch (guidHigh)
185 {
186 case HighGuid::Player:
187 {
188 object = ObjectAccessor::FindConnectedPlayer(ObjectGuid::Create<HighGuid::Player>(guidLow));
189 if (!object)
190 {
191 handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
192 handler->SetSentErrorMessage(true);
193 }
194 break;
195 }
196 case HighGuid::Creature:
197 {
198 object = handler->GetCreatureFromPlayerMapByDbGuid(guidLow);
199 if (!object)
200 {
201 handler->SendSysMessage(LANG_COMMAND_NOCREATUREFOUND);
202 handler->SetSentErrorMessage(true);
203 }
204 break;
205 }
206 case HighGuid::GameObject:
207 {
208 object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
209 if (!object)
210 {
211 handler->SendSysMessage(LANG_COMMAND_NOGAMEOBJECTFOUND);
212 handler->SetSentErrorMessage(true);
213 }
214 break;
215 }
216 default:
217 return false;
218 }
219 if (!object)
220 return false;
221 }
222 else
223 {
224 object = handler->getSelectedUnit();
225
226 if (!object)
227 {
228 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
229 handler->SetSentErrorMessage(true);
230 return false;
231 }
232 }
233
234 CellCoord cellCoord = Trinity::ComputeCellCoord(object->GetPositionX(), object->GetPositionY());
235 Cell cell(cellCoord);
236
237 uint32 zoneId, areaId;
238 object->GetZoneAndAreaId(zoneId, areaId);
239 uint32 mapId = object->GetMapId();
240
241 MapEntry const* mapEntry = sMapStore.LookupEntry(mapId);
242 AreaTableEntry const* zoneEntry = sAreaTableStore.LookupEntry(zoneId);
243 AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
244
245 float zoneX = object->GetPositionX();
246 float zoneY = object->GetPositionY();
247
248 sDB2Manager.Map2ZoneCoordinates(zoneId, zoneX, zoneY);
249
250 Map* map = object->GetMap();
251 float groundZ = object->GetMapHeight(object->GetPositionX(), object->GetPositionY(), MAX_HEIGHT);
252 float floorZ = object->GetMapHeight(object->GetPositionX(), object->GetPositionY(), object->GetPositionZ());
253
254 GridCoord gridCoord = Trinity::ComputeGridCoord(object->GetPositionX(), object->GetPositionY());
255
256 int gridX = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
257 int gridY = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
258
259 uint32 haveMap = TerrainInfo::ExistMap(mapId, gridX, gridY) ? 1 : 0;
260 uint32 haveVMap = TerrainInfo::ExistVMap(mapId, gridX, gridY) ? 1 : 0;
261 uint32 haveMMap = (DisableMgr::IsPathfindingEnabled(mapId) && MMAP::MMapManager::instance()->GetNavMesh(object->GetMapId(), object->GetInstanceId())) ? 1 : 0;
262
263 if (haveVMap)
264 {
265 if (object->IsOutdoors())
266 handler->PSendSysMessage(LANG_GPS_POSITION_OUTDOORS);
267 else
268 handler->PSendSysMessage(LANG_GPS_POSITION_INDOORS);
269 }
270 else
271 handler->PSendSysMessage(LANG_GPS_NO_VMAP);
272
273 char const* unknown = handler->GetTrinityString(LANG_UNKNOWN);
274
275 handler->PSendSysMessage(LANG_MAP_POSITION,
276 mapId, (mapEntry ? mapEntry->MapName[handler->GetSessionDbcLocale()] : unknown),
277 zoneId, (zoneEntry ? zoneEntry->AreaName[handler->GetSessionDbcLocale()] : unknown),
278 areaId, (areaEntry ? areaEntry->AreaName[handler->GetSessionDbcLocale()] : unknown),
279 object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), object->GetOrientation());
280 if (Transport* transport = dynamic_cast<Transport*>(object->GetTransport()))
281 handler->PSendSysMessage(LANG_TRANSPORT_POSITION,
282 transport->GetGOInfo()->moTransport.SpawnMap, object->GetTransOffsetX(), object->GetTransOffsetY(), object->GetTransOffsetZ(), object->GetTransOffsetO(),
283 transport->GetEntry(), transport->GetName().c_str());
284 handler->PSendSysMessage(LANG_GRID_POSITION,
285 cell.GridX(), cell.GridY(), cell.CellX(), cell.CellY(), object->GetInstanceId(),
286 zoneX, zoneY, groundZ, floorZ, map->GetMinHeight(object->GetPhaseShift(), object->GetPositionX(), object->GetPositionY()), haveMap, haveVMap, haveMMap);
287
288 LiquidData liquidStatus;
289 ZLiquidStatus status = map->GetLiquidStatus(object->GetPhaseShift(), object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), {}, &liquidStatus);
290 if (status)
291 handler->PSendSysMessage(LANG_LIQUID_STATUS, liquidStatus.level, liquidStatus.depth_level, liquidStatus.entry, uint32(liquidStatus.type_flags.AsUnderlyingType()), status);
292
293 PhasingHandler::PrintToChat(handler, object);
294
295 return true;
296 }
297
298 static bool HandleAuraCommand(ChatHandler* handler, SpellInfo const* spell)
299 {
300 Unit* target = handler->getSelectedUnit();
301 if (!target)
302 {
303 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
304 handler->SetSentErrorMessage(true);
305 return false;
306 }
307
308 if (!spell)
309 return false;
310
311 target->AddAura(spell, MAX_EFFECT_MASK, target);
312 return true;
313 }
314
315 static bool HandleUnAuraCommand(ChatHandler* handler, Variant<SpellInfo const*, EXACT_SEQUENCE("all")> spellArg)
316 {
317 Unit* target = handler->getSelectedUnit();
318 if (!target)
319 {
320 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
321 handler->SetSentErrorMessage(true);
322 return false;
323 }
324
325 if (spellArg.holds_alternative<EXACT_SEQUENCE("all")>())
326 {
327 target->RemoveAllAuras();
328 return true;
329 }
330
331 if (SpellInfo const* spellInfo = spellArg.get<SpellInfo const*>())
332 {
333 target->RemoveAurasDueToSpell(spellInfo->Id);
334 return true;
335 }
336
337 return false;
338 }
339
340 // Teleport to Player
341 static bool HandleAppearCommand(ChatHandler* handler, char const* args)
342 {
343 Player* target;
344 ObjectGuid targetGuid;
345 std::string targetName;
346 if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
347 return false;
348
349 Player* _player = handler->GetSession()->GetPlayer();
350 if (target == _player || targetGuid == _player->GetGUID())
351 {
352 handler->SendSysMessage(LANG_CANT_TELEPORT_SELF);
353 handler->SetSentErrorMessage(true);
354 return false;
355 }
356
357 if (target)
358 {
359 // check online security
360 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
361 return false;
362
363 std::string chrNameLink = handler->playerLink(targetName);
364
365 Map* map = target->GetMap();
366 if (map->IsBattlegroundOrArena())
367 {
368 // only allow if gm mode is on
369 if (!_player->IsGameMaster())
370 {
371 handler->PSendSysMessage(LANG_CANNOT_GO_TO_BG_GM, chrNameLink.c_str());
372 handler->SetSentErrorMessage(true);
373 return false;
374 }
375 }
376 else if (map->IsDungeon())
377 {
378 // we have to go to instance, and can go to player only if:
379 // 1) we are in his group (either as leader or as member)
380 // 2) we are not bound to any group and have GM mode on
381 if (_player->GetGroup())
382 {
383 // we are in group, we can go only if we are in the player group
384 if (_player->GetGroup() != target->GetGroup())
385 {
386 handler->PSendSysMessage(LANG_CANNOT_GO_TO_INST_PARTY, chrNameLink.c_str());
387 handler->SetSentErrorMessage(true);
388 return false;
389 }
390 }
391 else
392 {
393 // we are not in group, let's verify our GM mode
394 if (!_player->IsGameMaster())
395 {
396 handler->PSendSysMessage(LANG_CANNOT_GO_TO_INST_GM, chrNameLink.c_str());
397 handler->SetSentErrorMessage(true);
398 return false;
399 }
400 }
401
402 if (map->IsRaid())
403 {
404 _player->SetRaidDifficultyID(target->GetRaidDifficultyID());
405 _player->SetLegacyRaidDifficultyID(target->GetLegacyRaidDifficultyID());
406 }
407 else
408 _player->SetDungeonDifficultyID(target->GetDungeonDifficultyID());
409 }
410
411 handler->PSendSysMessage(LANG_APPEARING_AT, chrNameLink.c_str());
412
413 if (_player->GetBattlegroundId() && _player->GetBattlegroundId() != target->GetBattlegroundId())
414 _player->LeaveBattleground(false, true);
415
416 if (map->IsBattlegroundOrArena())
417 {
418 // all's well, set bg id
419 // when porting out from the bg, it will be reset to 0
420 _player->SetBattlegroundId(target->GetBattlegroundId(), target->GetBattlegroundTypeId(), BATTLEGROUND_QUEUE_NONE);
421 // remember current position as entry point for return at bg end teleportation
422 if (!_player->GetMap()->IsBattlegroundOrArena())
423 _player->SetBattlegroundEntryPoint();
424 }
425
426 // stop flight if need
427 if (_player->IsInFlight())
428 _player->FinishTaxiFlight();
429 else
430 _player->SaveRecallPosition(); // save only in non-flight case
431
432 // to point to see at target with same orientation
433 float x, y, z;
434 target->GetClosePoint(x, y, z, _player->GetCombatReach(), 1.0f);
435
436 _player->TeleportTo(target->GetMapId(), x, y, z, _player->GetAbsoluteAngle(target), TELE_TO_GM_MODE, target->GetInstanceId());
437 PhasingHandler::InheritPhaseShift(_player, target);
438 _player->UpdateObjectVisibility();
439 }
440 else
441 {
442 // check offline security
443 if (handler->HasLowerSecurity(nullptr, targetGuid))
444 return false;
445
446 std::string nameLink = handler->playerLink(targetName);
447
448 handler->PSendSysMessage(LANG_APPEARING_AT, nameLink.c_str());
449
450 // to point where player stay (if loaded)
451 float x, y, z, o;
452 uint32 map;
453 bool in_flight;
454 if (!Player::LoadPositionFromDB(map, x, y, z, o, in_flight, targetGuid))
455 return false;
456
457 if (_player->GetBattlegroundId())
458 _player->LeaveBattleground(false, true);
459
460 // stop flight if need
461 if (_player->IsInFlight())
462 _player->FinishTaxiFlight();
463 else
464 _player->SaveRecallPosition(); // save only in non-flight case
465
466 _player->TeleportTo(map, x, y, z, _player->GetOrientation());
467 }
468
469 return true;
470 }
471
472 // Summon Player
473 static bool HandleSummonCommand(ChatHandler* handler, char const* args)
474 {
475 Player* target;
476 ObjectGuid targetGuid;
477 std::string targetName;
478 if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
479 return false;
480
481 Player* _player = handler->GetSession()->GetPlayer();
482 if (target == _player || targetGuid == _player->GetGUID())
483 {
484 handler->PSendSysMessage(LANG_CANT_TELEPORT_SELF);
485 handler->SetSentErrorMessage(true);
486 return false;
487 }
488
489 if (target)
490 {
491 std::string nameLink = handler->playerLink(targetName);
492 // check online security
493 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
494 return false;
495
496 if (target->IsBeingTeleported())
497 {
498 handler->PSendSysMessage(LANG_IS_TELEPORTED, nameLink.c_str());
499 handler->SetSentErrorMessage(true);
500 return false;
501 }
502
503 Map* map = _player->GetMap();
504
505 if (map->IsBattlegroundOrArena())
506 {
507 // only allow if gm mode is on
508 if (!_player->IsGameMaster())
509 {
510 handler->PSendSysMessage(LANG_CANNOT_GO_TO_BG_GM, nameLink.c_str());
511 handler->SetSentErrorMessage(true);
512 return false;
513 }
514 }
515 else if (map->IsDungeon())
516 {
517 Map* targetMap = target->GetMap();
518 Player* targetGroupLeader = nullptr;
519 if (Group* targetGroup = target->GetGroup())
520 targetGroupLeader = ObjectAccessor::GetPlayer(map, targetGroup->GetLeaderGUID());
521
522 // check if far teleport is allowed
523 if (!targetGroupLeader || (targetGroupLeader->GetMapId() != map->GetId()) || (targetGroupLeader->GetInstanceId() != map->GetInstanceId()))
524 if ((targetMap->GetId() != map->GetId()) || (targetMap->GetInstanceId() != map->GetInstanceId()))
525 {
526 handler->PSendSysMessage(LANG_CANNOT_SUMMON_TO_INST);
527 handler->SetSentErrorMessage(true);
528 return false;
529 }
530
531 // check if we're already in a different instance of the same map
532 if ((targetMap->GetId() == map->GetId()) && (targetMap->GetInstanceId() != map->GetInstanceId()))
533 {
534 handler->PSendSysMessage(LANG_CANNOT_SUMMON_INST_INST, nameLink.c_str());
535 handler->SetSentErrorMessage(true);
536 return false;
537 }
538 }
539
540 handler->PSendSysMessage(LANG_SUMMONING, nameLink.c_str(), "");
541 if (handler->needReportToTarget(target))
542 ChatHandler(target->GetSession()).PSendSysMessage(LANG_SUMMONED_BY, handler->playerLink(_player->GetName()).c_str());
543
544 if (target->GetBattlegroundId() && _player->GetBattlegroundId() != target->GetBattlegroundId())
545 target->LeaveBattleground(false, true);
546
547 if (map->IsBattlegroundOrArena())
548 {
549 // all's well, set bg id
550 // when porting out from the bg, it will be reset to 0
551 target->SetBattlegroundId(_player->GetBattlegroundId(), _player->GetBattlegroundTypeId(), BATTLEGROUND_QUEUE_NONE);
552 // remember current position as entry point for return at bg end teleportation
553 if (!target->GetMap()->IsBattlegroundOrArena())
554 target->SetBattlegroundEntryPoint();
555 }
556
557 // stop flight if need
558 if (_player->IsInFlight())
559 _player->FinishTaxiFlight();
560 else
561 _player->SaveRecallPosition(); // save only in non-flight case
562
563 // before GM
564 float x, y, z;
565 _player->GetClosePoint(x, y, z, target->GetCombatReach());
566 target->TeleportTo(_player->GetMapId(), x, y, z, target->GetOrientation(), TELE_TO_NONE, map->GetInstanceId());
567 PhasingHandler::InheritPhaseShift(target, _player);
568 target->UpdateObjectVisibility();
569 }
570 else
571 {
572 // check offline security
573 if (handler->HasLowerSecurity(nullptr, targetGuid))
574 return false;
575
576 std::string nameLink = handler->playerLink(targetName);
577
578 handler->PSendSysMessage(LANG_SUMMONING, nameLink.c_str(), handler->GetTrinityString(LANG_OFFLINE));
579
580 // in point where GM stay
581 Player::SavePositionInDB(WorldLocation(_player->GetMapId(),
582 _player->GetPositionX(),
583 _player->GetPositionY(),
584 _player->GetPositionZ(),
585 _player->GetOrientation()),
586 _player->GetZoneId(),
587 targetGuid, nullptr);
588 }
589
590 return true;
591 }
592
593 static bool HandleCommandsCommand(ChatHandler* handler)
594 {
595 Trinity::ChatCommands::SendCommandHelpFor(*handler, "");
596 return true;
597 }
598
599 static bool HandleDieCommand(ChatHandler* handler)
600 {
601 Unit* target = handler->getSelectedUnit();
602
603 if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
604 {
605 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
606 handler->SetSentErrorMessage(true);
607 return false;
608 }
609
610 if (Player* player = target->ToPlayer())
611 if (handler->HasLowerSecurity(player, ObjectGuid::Empty, false))
612 return false;
613
614 if (target->IsAlive())
615 {
616 if (sWorld->getBoolConfig(CONFIG_DIE_COMMAND_MODE))
617 Unit::Kill(handler->GetSession()->GetPlayer(), target);
618 else
619 Unit::DealDamage(handler->GetSession()->GetPlayer(), target, target->GetHealth(), nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false);
620 }
621
622 return true;
623 }
624
625 static bool HandleReviveCommand(ChatHandler* handler, char const* args)
626 {
627 Player* target;
628 ObjectGuid targetGuid;
629 if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid))
630 return false;
631
632 if (target)
633 {
634 target->ResurrectPlayer(target->GetSession()->HasPermission(rbac::RBAC_PERM_RESURRECT_WITH_FULL_HPS) ? 1.0f : 0.5f);
635 target->SpawnCorpseBones();
636 target->SaveToDB();
637 }
638 else
639 {
640 CharacterDatabaseTransaction trans(nullptr);
641 Player::OfflineResurrect(targetGuid, trans);
642 }
643
644 return true;
645 }
646
647 static bool HandleDismountCommand(ChatHandler* handler)
648 {
649 Player* player = handler->getSelectedPlayerOrSelf();
650
651 // If player is not mounted, so go out :)
652 if (!player->IsMounted())
653 {
654 handler->SendSysMessage(LANG_CHAR_NON_MOUNTED);
655 handler->SetSentErrorMessage(true);
656 return false;
657 }
658
659 if (player->IsInFlight())
660 {
661 handler->SendSysMessage(LANG_CHAR_IN_FLIGHT);
662 handler->SetSentErrorMessage(true);
663 return false;
664 }
665
666 player->Dismount();
667 player->RemoveAurasByType(SPELL_AURA_MOUNTED);
668 return true;
669 }
670
671 static bool HandleGUIDCommand(ChatHandler* handler)
672 {
673 ObjectGuid guid = handler->GetSession()->GetPlayer()->GetTarget();
674
675 if (guid.IsEmpty())
676 {
677 handler->SendSysMessage(LANG_NO_SELECTION);
678 handler->SetSentErrorMessage(true);
679 return false;
680 }
681
682 handler->PSendSysMessage(LANG_OBJECT_GUID, guid.ToString().c_str());
683 return true;
684 }
685
686 static bool HandleHelpCommand(ChatHandler* handler, Tail cmd)
687 {
688 Trinity::ChatCommands::SendCommandHelpFor(*handler, cmd);
689 if (cmd.empty())
690 Trinity::ChatCommands::SendCommandHelpFor(*handler, "help");
691 return true;
692 }
693
694 // move item to other slot
695 static bool HandleItemMoveCommand(ChatHandler* handler, uint8 srcSlot, uint8 dstSlot)
696 {
697 if (srcSlot == dstSlot)
698 return true;
699
700 if (!handler->GetSession()->GetPlayer()->IsValidPos(INVENTORY_SLOT_BAG_0, srcSlot, true))
701 return false;
702
703 if (!handler->GetSession()->GetPlayer()->IsValidPos(INVENTORY_SLOT_BAG_0, dstSlot, false))
704 return false;
705
706 uint16 src = ((INVENTORY_SLOT_BAG_0 << 8) | srcSlot);
707 uint16 dst = ((INVENTORY_SLOT_BAG_0 << 8) | dstSlot);
708
709 handler->GetSession()->GetPlayer()->SwapItem(src, dst);
710
711 return true;
712 }
713
714 static bool HandleCooldownCommand(ChatHandler* handler, Optional<SpellInfo const*> spellArg)
715 {
716 Unit* target = handler->getSelectedUnit();
717 if (!target)
718 {
719 handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
720 handler->SetSentErrorMessage(true);
721 return false;
722 }
723
724 Player* owner = target->GetCharmerOrOwnerPlayerOrPlayerItself();
725 if (!owner)
726 {
727 owner = handler->GetSession()->GetPlayer();
728 target = owner;
729 }
730
731 std::string nameLink = handler->GetNameLink(owner);
732
733 if (!spellArg)
734 {
735 target->GetSpellHistory()->ResetAllCooldowns();
736 target->GetSpellHistory()->ResetAllCharges();
737 handler->PSendSysMessage(LANG_REMOVEALL_COOLDOWN, nameLink.c_str());
738 }
739 else
740 {
741 if (!*spellArg)
742 {
743 handler->PSendSysMessage(LANG_UNKNOWN_SPELL, owner == handler->GetSession()->GetPlayer() ? handler->GetTrinityString(LANG_YOU) : nameLink.c_str());
744 handler->SetSentErrorMessage(true);
745 return false;
746 }
747
748 target->GetSpellHistory()->ResetCooldown((*spellArg)->Id, true);
749 target->GetSpellHistory()->ResetCharges((*spellArg)->ChargeCategoryId);
750 handler->PSendSysMessage(LANG_REMOVE_COOLDOWN, (*spellArg)->Id, owner == handler->GetSession()->GetPlayer() ? handler->GetTrinityString(LANG_YOU) : nameLink.c_str());
751 }
752 return true;
753 }
754
755 static bool HandleGetDistanceCommand(ChatHandler* handler, char const* args)
756 {
757 WorldObject* object = nullptr;
758 if (*args)
759 {
760 HighGuid guidHigh;
761 ObjectGuid::LowType guidLow = handler->extractLowGuidFromLink((char*)args, guidHigh);
762 if (!guidLow)
763 return false;
764 switch (guidHigh)
765 {
766 case HighGuid::Player:
767 {
768 object = ObjectAccessor::GetPlayer(*handler->GetSession()->GetPlayer(), ObjectGuid::Create<HighGuid::Player>(guidLow));
769 if (!object)
770 {
771 handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
772 handler->SetSentErrorMessage(true);
773 }
774 break;
775 }
776 case HighGuid::Creature:
777 {
778 object = handler->GetCreatureFromPlayerMapByDbGuid(guidLow);
779 if (!object)
780 {
781 handler->SendSysMessage(LANG_COMMAND_NOCREATUREFOUND);
782 handler->SetSentErrorMessage(true);
783 }
784 break;
785 }
786 case HighGuid::GameObject:
787 {
788 object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
789 if (!object)
790 {
791 handler->SendSysMessage(LANG_COMMAND_NOGAMEOBJECTFOUND);
792 handler->SetSentErrorMessage(true);
793 }
794 break;
795 }
796 default:
797 return false;
798 }
799 if (!object)
800 return false;
801 }
802 else
803 {
804 object = handler->getSelectedUnit();
805 if (!object)
806 {
807 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
808 handler->SetSentErrorMessage(true);
809 return false;
810 }
811 }
812
813 handler->PSendSysMessage(LANG_DISTANCE, handler->GetSession()->GetPlayer()->GetDistance(object), handler->GetSession()->GetPlayer()->GetDistance2d(object), handler->GetSession()->GetPlayer()->GetExactDist(object), handler->GetSession()->GetPlayer()->GetExactDist2d(object));
814 return true;
815 }
816
817 // Teleport player to last position
818 static bool HandleRecallCommand(ChatHandler* handler, char const* args)
819 {
820 Player* target;
821 if (!handler->extractPlayerTarget((char*)args, &target))
822 return false;
823
824 // check online security
825 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
826 return false;
827
828 if (target->IsBeingTeleported())
829 {
830 handler->PSendSysMessage(LANG_IS_TELEPORTED, handler->GetNameLink(target).c_str());
831 handler->SetSentErrorMessage(true);
832 return false;
833 }
834
835 target->FinishTaxiFlight();
836
837 target->Recall();
838 return true;
839 }
840
841 static bool HandleSaveCommand(ChatHandler* handler)
842 {
843 Player* player = handler->GetSession()->GetPlayer();
844
845 // save GM account without delay and output message
846 if (handler->GetSession()->HasPermission(rbac::RBAC_PERM_COMMANDS_SAVE_WITHOUT_DELAY))
847 {
848 if (Player* target = handler->getSelectedPlayer())
849 target->SaveToDB();
850 else
851 player->SaveToDB();
852 handler->SendSysMessage(LANG_PLAYER_SAVED);
853 return true;
854 }
855
856 // save if the player has last been saved over 20 seconds ago
857 uint32 saveInterval = sWorld->getIntConfig(CONFIG_INTERVAL_SAVE);
858 if (saveInterval == 0 || (saveInterval > 20 * IN_MILLISECONDS && player->GetSaveTimer() <= saveInterval - 20 * IN_MILLISECONDS))
859 player->SaveToDB();
860
861 return true;
862 }
863
864 // Save all players in the world
865 static bool HandleSaveAllCommand(ChatHandler* handler)
866 {
867 ObjectAccessor::SaveAllPlayers();
868 handler->SendSysMessage(LANG_PLAYERS_SAVED);
869 return true;
870 }
871
872 // kick player
873 static bool HandleKickPlayerCommand(ChatHandler* handler, char const* args)
874 {
875 Player* target = nullptr;
876 std::string playerName;
877 if (!handler->extractPlayerTarget((char*)args, &target, nullptr, &playerName))
878 return false;
879
880 if (handler->GetSession() && target == handler->GetSession()->GetPlayer())
881 {
882 handler->SendSysMessage(LANG_COMMAND_KICKSELF);
883 handler->SetSentErrorMessage(true);
884 return false;
885 }
886
887 // check online security
888 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
889 return false;
890
891 std::string kickReasonStr = handler->GetTrinityString(LANG_NO_REASON);
892 if (*args != '\0')
893 {
894 char const* kickReason = strtok(nullptr, "\r");
895 if (kickReason != nullptr)
896 kickReasonStr = kickReason;
897 }
898
899 if (sWorld->getBoolConfig(CONFIG_SHOW_KICK_IN_WORLD))
900 sWorld->SendWorldText(LANG_COMMAND_KICKMESSAGE_WORLD, (handler->GetSession() ? handler->GetSession()->GetPlayerName().c_str() : "Server"), playerName.c_str(), kickReasonStr.c_str());
901 else
902 handler->PSendSysMessage(LANG_COMMAND_KICKMESSAGE, playerName.c_str());
903
904 target->GetSession()->KickPlayer("HandleKickPlayerCommand GM Command");
905
906 return true;
907 }
908
909 static bool HandleUnstuckCommand(ChatHandler* handler, char const* args)
910 {
911#define SPELL_UNSTUCK_ID 7355
912#define SPELL_UNSTUCK_VISUAL 2683
913
914 // No args required for players
915 if (handler->GetSession() && !handler->GetSession()->HasPermission(rbac::RBAC_PERM_COMMANDS_USE_UNSTUCK_WITH_ARGS))
916 {
917 // 7355: "Stuck"
918 if (Player* player = handler->GetSession()->GetPlayer())
919 player->CastSpell(player, SPELL_UNSTUCK_ID, false);
920 return true;
921 }
922
923 if (!*args)
924 return false;
925
926 char* player_str = strtok((char*)args, " ");
927 if (!player_str)
928 return false;
929
930 std::string location_str = "inn";
931 if (char const* loc = strtok(nullptr, " "))
932 location_str = loc;
933
934 Player* player = nullptr;
935 ObjectGuid targetGUID;
936 if (!handler->extractPlayerTarget(player_str, &player, &targetGUID))
937 return false;
938
939 if (!player)
940 {
941 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_HOMEBIND);
942 stmt->setUInt64(0, targetGUID.GetCounter());
943 PreparedQueryResult result = CharacterDatabase.Query(stmt);
944 if (result)
945 {
946 Field* fields = result->Fetch();
947
948 CharacterDatabaseTransaction dummy;
949 Player::SavePositionInDB(WorldLocation(fields[0].GetUInt16(), fields[2].GetFloat(), fields[3].GetFloat(), fields[4].GetFloat(), 0.0f), fields[1].GetUInt16(), targetGUID, dummy);
950 return true;
951 }
952
953 return false;
954 }
955
956 if (player->IsInFlight() || player->IsInCombat())
957 {
958 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_UNSTUCK_ID, DIFFICULTY_NONE);
959 if (!spellInfo)
960 return false;
961
962 if (Player* caster = handler->GetSession()->GetPlayer())
963 caster->SendDirectMessage(WorldPackets::Misc::DisplayGameError(GameError::ERR_CLIENT_LOCKED_OUT).Write());
964
965 return false;
966 }
967
968 if (location_str == "inn")
969 {
970 player->TeleportTo(player->m_homebind);
971 return true;
972 }
973
974 if (location_str == "graveyard")
975 {
976 player->RepopAtGraveyard();
977 return true;
978 }
979
980 //Not a supported argument
981 return false;
982
983 }
984
985 static bool HandleLinkGraveCommand(ChatHandler* handler, uint32 graveyardId, Optional<std::string> teamArg)
986 {
987 uint32 team;
988
989 if (!teamArg)
990 team = 0;
991 else if (StringEqualI(*teamArg, "horde"))
992 team = HORDE;
993 else if (StringEqualI(*teamArg, "alliance"))
994 team = ALLIANCE;
995 else
996 return false;
997
998 WorldSafeLocsEntry const* graveyard = sObjectMgr->GetWorldSafeLoc(graveyardId);
999
1000 if (!graveyard)
1001 {
1002 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDNOEXIST, graveyardId);
1003 handler->SetSentErrorMessage(true);
1004 return false;
1005 }
1006
1007 Player* player = handler->GetSession()->GetPlayer();
1008
1009 uint32 zoneId = player->GetZoneId();
1010
1011 AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(zoneId);
1012 if (!areaEntry || areaEntry->GetFlags().HasFlag(AreaFlags::IsSubzone))
1013 {
1014 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDWRONGZONE, graveyardId, zoneId);
1015 handler->SetSentErrorMessage(true);
1016 return false;
1017 }
1018
1019 if (sObjectMgr->AddGraveyardLink(graveyardId, zoneId, team, true))
1020 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDLINKED, graveyardId, zoneId);
1021 else
1022 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDALRLINKED, graveyardId, zoneId);
1023
1024 return true;
1025 }
1026
1027 static bool HandleNearGraveCommand(ChatHandler* handler, Optional<std::string> teamArg)
1028 {
1029 uint32 team;
1030
1031 if (!teamArg)
1032 team = 0;
1033 else if (StringEqualI(*teamArg, "horde"))
1034 team = HORDE;
1035 else if (StringEqualI(*teamArg, "alliance"))
1036 team = ALLIANCE;
1037 else
1038 return false;
1039
1040 Player* player = handler->GetSession()->GetPlayer();
1041 uint32 zone_id = player->GetZoneId();
1042
1043 WorldSafeLocsEntry const* graveyard = sObjectMgr->GetClosestGraveyard(*player, team, nullptr);
1044 if (graveyard)
1045 {
1046 uint32 graveyardId = graveyard->ID;
1047
1048 GraveyardData const* data = sObjectMgr->FindGraveyardData(graveyardId, zone_id);
1049 if (!data)
1050 {
1051 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDERROR, graveyardId);
1052 handler->SetSentErrorMessage(true);
1053 return false;
1054 }
1055
1056 std::string team_name = handler->GetTrinityString(LANG_COMMAND_GRAVEYARD_NOTEAM);
1057
1058 if (team == 0)
1059 team_name = handler->GetTrinityString(LANG_COMMAND_GRAVEYARD_ANY);
1060 else if (team == HORDE)
1061 team_name = handler->GetTrinityString(LANG_COMMAND_GRAVEYARD_HORDE);
1062 else if (team == ALLIANCE)
1063 team_name = handler->GetTrinityString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
1064
1065 handler->PSendSysMessage(LANG_COMMAND_GRAVEYARDNEAREST, graveyardId, team_name.c_str(), zone_id);
1066 }
1067 else
1068 {
1069 std::string team_name;
1070
1071 if (team == HORDE)
1072 team_name = handler->GetTrinityString(LANG_COMMAND_GRAVEYARD_HORDE);
1073 else if (team == ALLIANCE)
1074 team_name = handler->GetTrinityString(LANG_COMMAND_GRAVEYARD_ALLIANCE);
1075
1076 if (!team)
1077 handler->PSendSysMessage(LANG_COMMAND_ZONENOGRAVEYARDS, zone_id);
1078 else
1079 handler->PSendSysMessage(LANG_COMMAND_ZONENOGRAFACTION, zone_id, team_name.c_str());
1080 }
1081
1082 return true;
1083 }
1084
1085 static bool HandleShowAreaCommand(ChatHandler* handler, uint32 areaId)
1086 {
1087 Player* playerTarget = handler->getSelectedPlayer();
1088 if (!playerTarget)
1089 {
1090 handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
1091 handler->SetSentErrorMessage(true);
1092 return false;
1093 }
1094
1095 AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId);
1096 if (!area)
1097 {
1098 handler->SendSysMessage(LANG_BAD_VALUE);
1099 handler->SetSentErrorMessage(true);
1100 return false;
1101 }
1102
1103 if (area->AreaBit < 0)
1104 {
1105 handler->SendSysMessage(LANG_BAD_VALUE);
1106 handler->SetSentErrorMessage(true);
1107 return false;
1108 }
1109
1110 uint32 offset = area->AreaBit / PLAYER_EXPLORED_ZONES_BITS;
1111 uint64 val = UI64LIT(1) << (area->AreaBit % PLAYER_EXPLORED_ZONES_BITS);
1112 playerTarget->AddExploredZones(offset, val);
1113
1114 handler->SendSysMessage(LANG_EXPLORE_AREA);
1115 return true;
1116 }
1117
1118 static bool HandleHideAreaCommand(ChatHandler* handler, uint32 areaId)
1119 {
1120 Player* playerTarget = handler->getSelectedPlayer();
1121 if (!playerTarget)
1122 {
1123 handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
1124 handler->SetSentErrorMessage(true);
1125 return false;
1126 }
1127
1128 AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId);
1129 if (!area)
1130 {
1131 handler->SendSysMessage(LANG_BAD_VALUE);
1132 handler->SetSentErrorMessage(true);
1133 return false;
1134 }
1135
1136 if (area->AreaBit < 0)
1137 {
1138 handler->SendSysMessage(LANG_BAD_VALUE);
1139 handler->SetSentErrorMessage(true);
1140 return false;
1141 }
1142
1143 uint32 offset = area->AreaBit / PLAYER_EXPLORED_ZONES_BITS;
1144 uint64 val = UI64LIT(1) << (area->AreaBit % PLAYER_EXPLORED_ZONES_BITS);
1145 playerTarget->RemoveExploredZones(offset, val);
1146
1147 handler->SendSysMessage(LANG_UNEXPLORE_AREA);
1148 return true;
1149 }
1150
1151 static bool HandleAddItemCommandHelper(ChatHandler* handler, Player* player, Player* playerTarget,
1152 Variant<Hyperlink<item>, uint32, std::string_view> const& itemArg, Optional<int32> countArg,
1153 Optional<std::string_view> const& bonusListIdString, Optional<uint8> itemContextArg)
1154 {
1155 uint32 itemId = 0;
1156 std::vector<int32> bonusListIDs;
1157 ItemContext itemContext = ItemContext::NONE;
1158 if (Hyperlink<::item> const* itemLinkData = std::get_if<Hyperlink<::item>>(&itemArg))
1159 {
1160 itemId = (*itemLinkData)->Item->GetId();
1161 bonusListIDs = (*itemLinkData)->ItemBonusListIDs;
1162 itemContext = static_cast<ItemContext>((*itemLinkData)->Context);
1163 }
1164 else if (uint32 const* itemIdPtr = std::get_if<uint32>(&itemArg))
1165 itemId = *itemIdPtr;
1166 else if (std::string_view const* itemNameText = std::get_if<std::string_view>(&itemArg))
1167 {
1168 std::string itemName(*itemNameText);
1169 if (itemName.starts_with('['))
1170 itemName.erase(0, 1);
1171 if (itemName.ends_with(']'))
1172 itemName.pop_back();
1173
1174 auto itr = std::ranges::find_if(sItemSparseStore, [&itemName](ItemSparseEntry const* sparse)
1175 {
1176 for (LocaleConstant i = LOCALE_enUS; i < TOTAL_LOCALES; i = LocaleConstant(i + 1))
1177 if (itemName == sparse->Display[i])
1178 return true;
1179 return false;
1180 });
1181
1182 if (itr == sItemSparseStore.end())
1183 {
1184 handler->PSendSysMessage(LANG_COMMAND_COULDNOTFIND, itemName.c_str());
1185 handler->SetSentErrorMessage(true);
1186 return false;
1187 }
1188
1189 itemId = itr->ID;
1190 }
1191
1192 int32 count = countArg.value_or(1);
1193 if (count == 0)
1194 count = 1;
1195
1196 // semicolon separated bonuslist ids (parse them after all arguments are extracted by strtok!)
1197 if (bonusListIdString)
1198 for (std::string_view token : Trinity::Tokenize(*bonusListIdString, ';', false))
1199 if (Optional<int32> bonusListId = Trinity::StringTo<int32>(token); bonusListId && *bonusListId)
1200 bonusListIDs.push_back(*bonusListId);
1201
1202 if (itemContextArg)
1203 {
1204 itemContext = ItemContext(*itemContextArg);
1205 if (itemContext < ItemContext::Max)
1206 {
1207 std::vector<int32> contextBonuses = ItemBonusMgr::GetBonusListsForItem(itemId, itemContext);
1208 bonusListIDs.insert(bonusListIDs.begin(), contextBonuses.begin(), contextBonuses.end());
1209 std::ranges::sort(bonusListIDs);
1210 bonusListIDs.erase(std::unique(bonusListIDs.begin(), bonusListIDs.end()), bonusListIDs.end());
1211 }
1212 }
1213
1214 ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(itemId);
1215 if (!itemTemplate)
1216 {
1217 handler->PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, itemId);
1218 handler->SetSentErrorMessage(true);
1219 return false;
1220 }
1221
1222 // Subtract
1223 if (count < 0)
1224 {
1225 uint32 destroyedItemCount = playerTarget->DestroyItemCount(itemId, -count, true, false);
1226
1227 if (destroyedItemCount > 0)
1228 {
1229 // output the amount of items successfully destroyed
1230 handler->PSendSysMessage(LANG_REMOVEITEM, itemId, destroyedItemCount, handler->GetNameLink(playerTarget).c_str());
1231
1232 // check to see if we were unable to destroy all of the amount requested.
1233 uint32 unableToDestroyItemCount = -count - destroyedItemCount;
1234 if (unableToDestroyItemCount > 0)
1235 {
1236 // output message for the amount of items we couldn't destroy
1237 handler->PSendSysMessage(LANG_REMOVEITEM_FAILURE, itemId, unableToDestroyItemCount, handler->GetNameLink(playerTarget).c_str());
1238 }
1239 }
1240 else
1241 {
1242 // failed to destroy items of the amount requested
1243 handler->PSendSysMessage(LANG_REMOVEITEM_FAILURE, itemId, -count, handler->GetNameLink(playerTarget).c_str());
1244 }
1245
1246 return true;
1247 }
1248
1249 // Adding items
1250 uint32 noSpaceForCount = 0;
1251
1252 // check space and find places
1253 ItemPosCountVec dest;
1254 InventoryResult msg = playerTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemId, count, &noSpaceForCount);
1255 if (msg != EQUIP_ERR_OK) // convert to possible store amount
1256 count -= noSpaceForCount;
1257
1258 if (count == 0 || dest.empty()) // can't add any
1259 {
1260 handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
1261 handler->SetSentErrorMessage(true);
1262 return false;
1263 }
1264
1265 Item* item = playerTarget->StoreNewItem(dest, itemId, true, GenerateItemRandomBonusListId(itemId), GuidSet(), itemContext,
1266 bonusListIDs.empty() ? nullptr : &bonusListIDs);
1267
1268 // remove binding (let GM give it to another player later)
1269 if (player == playerTarget)
1270 for (ItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end(); ++itr)
1271 if (Item* item1 = player->GetItemByPos(itr->pos))
1272 item1->SetBinding(false);
1273
1274 if (count > 0 && item)
1275 {
1276 player->SendNewItem(item, count, false, true);
1277 handler->PSendSysMessage(LANG_ADDITEM, itemId, count, handler->GetNameLink(playerTarget).c_str());
1278 if (player != playerTarget)
1279 playerTarget->SendNewItem(item, count, true, false);
1280 }
1281
1282 if (noSpaceForCount > 0)
1283 handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemId, noSpaceForCount);
1284
1285 return true;
1286 }
1287
1288 static bool HandleAddItemCommand(ChatHandler* handler,
1289 Variant<Hyperlink<::item>, uint32, std::string_view> const& item, Optional<int32> countArg,
1290 Optional<std::string_view> const& bonusListIdString, Optional<uint8> itemContextArg)
1291 {
1292 Player* player = handler->GetSession()->GetPlayer();
1293 Player* playerTarget = handler->getSelectedPlayerOrSelf();
1294
1295 return HandleAddItemCommandHelper(handler, player, playerTarget, item, countArg, bonusListIdString, itemContextArg);
1296 }
1297
1298 static bool HandleAddItemToCommand(ChatHandler* handler, PlayerIdentifier const& target,
1299 Variant<Hyperlink<::item>, uint32, std::string_view> const& item, Optional<int32> countArg,
1300 Optional<std::string_view> const& bonusListIdString, Optional<uint8> itemContextArg)
1301 {
1302 Player* player = handler->GetSession()->GetPlayer();
1303 if (!target.IsConnected())
1304 {
1305 handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
1306 handler->SetSentErrorMessage(true);
1307 return false;
1308 }
1309
1310 return HandleAddItemCommandHelper(handler, player, target.GetConnectedPlayer(), item, countArg, bonusListIdString, itemContextArg);
1311 }
1312
1313 static bool HandleAddItemSetCommand(ChatHandler* handler, Variant<Hyperlink<itemset>, uint32> itemSetId, Optional<std::string_view> bonuses, Optional<uint8> context)
1314 {
1315 // prevent generation all items with itemset field value '0'
1316 if (*itemSetId == 0)
1317 {
1318 handler->PSendSysMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND, *itemSetId);
1319 handler->SetSentErrorMessage(true);
1320 return false;
1321 }
1322
1323 std::vector<int32> bonusListIDs;
1324
1325 // semicolon separated bonuslist ids (parse them after all arguments are extracted by strtok!)
1326 if (bonuses)
1327 for (std::string_view token : Trinity::Tokenize(*bonuses, ';', false))
1328 if (Optional<int32> bonusListId = Trinity::StringTo<int32>(token); bonusListId && *bonusListId)
1329 bonusListIDs.push_back(*bonusListId);
1330
1331 ItemContext itemContext = ItemContext::NONE;
1332 if (context)
1333 itemContext = ItemContext(*context);
1334
1335 Player* player = handler->GetSession()->GetPlayer();
1336 Player* playerTarget = handler->getSelectedPlayer();
1337 if (!playerTarget)
1338 playerTarget = player;
1339
1340 bool found = false;
1341 ItemTemplateContainer const& its = sObjectMgr->GetItemTemplateStore();
1342 for (auto const& itemTemplatePair : its)
1343 {
1344 if (itemTemplatePair.second.GetItemSet() != *itemSetId)
1345 continue;
1346
1347 found = true;
1348 ItemPosCountVec dest;
1349 InventoryResult msg = playerTarget->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, itemTemplatePair.first, 1);
1350 if (msg == EQUIP_ERR_OK)
1351 {
1352 std::vector<int32> bonusListIDsForItem = bonusListIDs; // copy, bonuses for each depending on context might be different for each item
1353 if (itemContext < ItemContext::Max)
1354 {
1355 std::vector<int32> contextBonuses = ItemBonusMgr::GetBonusListsForItem(itemTemplatePair.first, itemContext);
1356 bonusListIDsForItem.insert(bonusListIDsForItem.begin(), contextBonuses.begin(), contextBonuses.end());
1357 }
1358
1359 Item* item = playerTarget->StoreNewItem(dest, itemTemplatePair.first, true, {}, GuidSet(), itemContext,
1360 bonusListIDsForItem.empty() ? nullptr : &bonusListIDsForItem);
1361 if (!item)
1362 continue;
1363
1364 // remove binding (let GM give it to another player later)
1365 if (player == playerTarget)
1366 item->SetBinding(false);
1367
1368 player->SendNewItem(item, 1, false, true);
1369 if (player != playerTarget)
1370 playerTarget->SendNewItem(item, 1, true, false);
1371 }
1372 else
1373 {
1374 player->SendEquipError(msg, nullptr, nullptr, itemTemplatePair.first);
1375 handler->PSendSysMessage(LANG_ITEM_CANNOT_CREATE, itemTemplatePair.first, 1);
1376 }
1377 }
1378
1379 if (!found)
1380 {
1381 handler->PSendSysMessage(LANG_NO_ITEMS_FROM_ITEMSET_FOUND, *itemSetId);
1382 handler->SetSentErrorMessage(true);
1383 return false;
1384 }
1385
1386 return true;
1387 }
1388
1389 static bool HandleBankCommand(ChatHandler* handler)
1390 {
1391 handler->GetSession()->SendShowBank(handler->GetSession()->GetPlayer()->GetGUID(), PlayerInteractionType::Banker);
1392 return true;
1393 }
1394
1395 static bool HandleChangeWeather(ChatHandler* handler, WeatherType type, float intensity)
1396 {
1397 // Weather is OFF
1398 if (!sWorld->getBoolConfig(CONFIG_WEATHER))
1399 {
1400 handler->SendSysMessage(LANG_WEATHER_DISABLED);
1401 handler->SetSentErrorMessage(true);
1402 return false;
1403 }
1404
1405 Player* player = handler->GetSession()->GetPlayer();
1406 uint32 zoneid = player->GetZoneId();
1407
1408 Weather* weather = player->GetMap()->GetOrGenerateZoneDefaultWeather(zoneid);
1409 if (!weather)
1410 {
1411 handler->SendSysMessage(LANG_NO_WEATHER);
1412 handler->SetSentErrorMessage(true);
1413 return false;
1414 }
1415
1416 weather->SetWeather(type, intensity);
1417
1418 return true;
1419 }
1420
1421 static bool HandleSetSkillCommand(ChatHandler* handler, Variant<Hyperlink<skill>, uint32> skillId, uint32 level, Optional<uint32> maxSkillArg)
1422 {
1423 Player* target = handler->getSelectedPlayerOrSelf();
1424 if (!target)
1425 {
1426 handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
1427 handler->SetSentErrorMessage(true);
1428 return false;
1429 }
1430
1431 SkillLineEntry const* skillLine = sSkillLineStore.LookupEntry(skillId);
1432 if (!skillLine)
1433 {
1434 handler->PSendSysMessage(LANG_INVALID_SKILL_ID, *skillId);
1435 handler->SetSentErrorMessage(true);
1436 return false;
1437 }
1438
1439 bool targetHasSkill = target->GetSkillValue(skillId) != 0;
1440
1441 // If our target does not yet have the skill they are trying to add to them, the chosen level also becomes
1442 // the max level of the new profession.
1443 uint16 max = maxSkillArg.value_or(targetHasSkill ? target->GetPureMaxSkillValue(skillId) : level);
1444
1445 if (level == 0 || level > max)
1446 return false;
1447
1448 // If the player has the skill, we get the current skill step. If they don't have the skill, we
1449 // add the skill to the player's book with step 1 (which is the first rank, in most cases something
1450 // like 'Apprentice <skill>'.
1451 target->SetSkill(skillId, targetHasSkill ? target->GetSkillStep(skillId) : 1, level, max);
1452 handler->PSendSysMessage(LANG_SET_SKILL, *skillId, skillLine->DisplayName[handler->GetSessionDbcLocale()], handler->GetNameLink(target).c_str(), level, max);
1453 return true;
1454 }
1455
1473 static bool HandlePInfoCommand(ChatHandler* handler, Optional<PlayerIdentifier> arg)
1474 {
1475 if (!arg)
1476 arg = PlayerIdentifier::FromTargetOrSelf(handler);
1477
1478 if (!arg)
1479 return false;
1480
1481 // Define ALL the player variables!
1482 Player* target = arg->GetConnectedPlayer();
1483 ObjectGuid targetGuid = arg->GetGUID();
1484 std::string targetName = arg->GetName();
1485 CharacterDatabasePreparedStatement* stmt = nullptr;
1486
1487 /* The variables we extract for the command. They are
1488 * default as "does not exist" to prevent problems
1489 * The output is printed in the follow manner:
1490 *
1491 * Player %s %s (guid: %u) - I. LANG_PINFO_PLAYER
1492 * ** GM Mode active, Phase: -1 - II. LANG_PINFO_GM_ACTIVE (if GM)
1493 * ** Banned: (Type, Reason, Time, By) - III. LANG_PINFO_BANNED (if banned)
1494 * ** Muted: (Reason, Time, By) - IV. LANG_PINFO_MUTED (if muted)
1495 * * Account: %s (id: %u), GM Level: %u - V. LANG_PINFO_ACC_ACCOUNT
1496 * * Last Login: %u (Failed Logins: %u) - VI. LANG_PINFO_ACC_LASTLOGIN
1497 * * Uses OS: %s - Latency: %u ms - VII. LANG_PINFO_ACC_OS
1498 * * Registration Email: %s - Email: %s - VIII. LANG_PINFO_ACC_REGMAILS
1499 * * Last IP: %u (Locked: %s) - IX. LANG_PINFO_ACC_IP
1500 * * Level: %u (%u/%u XP (%u XP left) - X. LANG_PINFO_CHR_LEVEL
1501 * * Race: %s %s, Class %s - XI. LANG_PINFO_CHR_RACE
1502 * * Alive ?: %s - XII. LANG_PINFO_CHR_ALIVE
1503 * * Phases: %s - XIII. LANG_PINFO_CHR_PHASE (if not GM)
1504 * * Money: %ug%us%uc - XIV. LANG_PINFO_CHR_MONEY
1505 * * Map: %s, Area: %s - XV. LANG_PINFO_CHR_MAP
1506 * * Guild: %s (Id: %s) - XVI. LANG_PINFO_CHR_GUILD (if in guild)
1507 * ** Rank: %s, ID: %u - XVII. LANG_PINFO_CHR_GUILD_RANK (if in guild)
1508 * ** Note: %s - XVIII.LANG_PINFO_CHR_GUILD_NOTE (if in guild and has note)
1509 * ** O. Note: %s - XVIX. LANG_PINFO_CHR_GUILD_ONOTE (if in guild and has officer note)
1510 * * Played time: %s - XX. LANG_PINFO_CHR_PLAYEDTIME
1511 * * Mails: %u Read/%u Total - XXI. LANG_PINFO_CHR_MAILS (if has mails)
1512 *
1513 * Not all of them can be moved to the top. These should
1514 * place the most important ones to the head, though.
1515 *
1516 * For a cleaner overview, I segment each output in Roman numerals
1517 */
1518
1519 // Account data print variables
1520 std::string userName = handler->GetTrinityString(LANG_ERROR);
1521 uint32 accId = 0;
1522 ObjectGuid::LowType lowguid = targetGuid.GetCounter();
1523 std::string eMail = handler->GetTrinityString(LANG_ERROR);
1524 std::string regMail = handler->GetTrinityString(LANG_ERROR);
1525 uint32 security = 0;
1526 std::string lastIp = handler->GetTrinityString(LANG_ERROR);
1527 uint8 locked = 0;
1528 std::string lastLogin = handler->GetTrinityString(LANG_ERROR);
1529 uint32 failedLogins = 0;
1530 uint32 latency = 0;
1531 std::string OS = handler->GetTrinityString(LANG_UNKNOWN);
1532
1533 // Mute data print variables
1534 int64 muteTime = -1;
1535 std::string muteReason = handler->GetTrinityString(LANG_NO_REASON);
1536 std::string muteBy = handler->GetTrinityString(LANG_UNKNOWN);
1537
1538 // Ban data print variables
1539 int64 banTime = -1;
1540 std::string banType = handler->GetTrinityString(LANG_UNKNOWN);
1541 std::string banReason = handler->GetTrinityString(LANG_NO_REASON);
1542 std::string bannedBy = handler->GetTrinityString(LANG_UNKNOWN);
1543
1544 // Character data print variables
1545 uint8 raceid, classid = 0; //RACE_NONE, CLASS_NONE
1546 std::string raceStr, classStr = handler->GetTrinityString(LANG_UNKNOWN);
1547 uint8 gender = 0;
1548 LocaleConstant locale = handler->GetSessionDbcLocale();
1549 uint32 totalPlayerTime = 0;
1550 uint8 level = 0;
1551 std::string alive = handler->GetTrinityString(LANG_ERROR);
1552 uint64 money = 0;
1553 uint32 xp = 0;
1554 uint32 xptotal = 0;
1555
1556 // Position data print
1557 uint32 mapId;
1558 uint32 areaId;
1559 char const* areaName = nullptr;
1560 char const* zoneName = nullptr;
1561
1562 // Guild data print variables defined so that they exist, but are not necessarily used
1563 ObjectGuid::LowType guildId = UI64LIT(0);
1564 uint8 guildRankId = 0;
1565 std::string guildName;
1566 std::string guildRank;
1567 std::string note;
1568 std::string officeNote;
1569
1570 // Mail data print is only defined if you have a mail
1571
1572 if (target)
1573 {
1574 // check online security
1575 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
1576 return false;
1577
1578 accId = target->GetSession()->GetAccountId();
1579 money = target->GetMoney();
1580 totalPlayerTime = target->GetTotalPlayedTime();
1581 level = target->GetLevel();
1582 latency = target->GetSession()->GetLatency();
1583 raceid = target->GetRace();
1584 classid = target->GetClass();
1585 muteTime = target->GetSession()->m_muteTime;
1586 mapId = target->GetMapId();
1587 areaId = target->GetAreaId();
1588 alive = target->IsAlive() ? handler->GetTrinityString(LANG_YES) : handler->GetTrinityString(LANG_NO);
1589 gender = target->GetNativeGender();
1590 }
1591 // get additional information from DB
1592 else
1593 {
1594 // check offline security
1595 if (handler->HasLowerSecurity(nullptr, targetGuid))
1596 return false;
1597
1598 // Query informations from the DB
1599 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_PINFO);
1600 stmt->setUInt64(0, lowguid);
1601 PreparedQueryResult result = CharacterDatabase.Query(stmt);
1602
1603 if (!result)
1604 return false;
1605
1606 Field* fields = result->Fetch();
1607 totalPlayerTime = fields[0].GetUInt32();
1608 level = fields[1].GetUInt8();
1609 money = fields[2].GetUInt64();
1610 accId = fields[3].GetUInt32();
1611 raceid = fields[4].GetUInt8();
1612 classid = fields[5].GetUInt8();
1613 mapId = fields[6].GetUInt16();
1614 areaId = fields[7].GetUInt16();
1615 gender = fields[8].GetUInt8();
1616 uint32 health = fields[9].GetUInt32();
1617 uint32 playerFlags = fields[10].GetUInt32();
1618
1619 if (!health || playerFlags & PLAYER_FLAGS_GHOST)
1620 alive = handler->GetTrinityString(LANG_NO);
1621 else
1622 alive = handler->GetTrinityString(LANG_YES);
1623 }
1624
1625 // Query the prepared statement for login data
1626 LoginDatabasePreparedStatement* stmt2 = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO);
1627 stmt2->setInt32(0, int32(sRealmList->GetCurrentRealmId().Realm));
1628 stmt2->setUInt32(1, accId);
1629 PreparedQueryResult result = LoginDatabase.Query(stmt2);
1630
1631 if (result)
1632 {
1633 Field* fields = result->Fetch();
1634 userName = fields[0].GetString();
1635 security = fields[1].GetUInt8();
1636
1637 // Only fetch these fields if commander has sufficient rights)
1638 if (handler->HasPermission(rbac::RBAC_PERM_COMMANDS_PINFO_CHECK_PERSONAL_DATA) && // RBAC Perm. 48, Role 39
1639 (!handler->GetSession() || handler->GetSession()->GetSecurity() >= AccountTypes(security)))
1640 {
1641 eMail = fields[2].GetString();
1642 regMail = fields[3].GetString();
1643 lastIp = fields[4].GetString();
1644 lastLogin = fields[5].GetString();
1645
1646 if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(lastIp))
1647 {
1648 lastIp.append(" (");
1649 lastIp.append(location->CountryName);
1650 lastIp.append(")");
1651 }
1652 }
1653 else
1654 {
1655 eMail = handler->GetTrinityString(LANG_UNAUTHORIZED);
1656 regMail = handler->GetTrinityString(LANG_UNAUTHORIZED);
1657 lastIp = handler->GetTrinityString(LANG_UNAUTHORIZED);
1658 lastLogin = handler->GetTrinityString(LANG_UNAUTHORIZED);
1659 }
1660 muteTime = fields[6].GetUInt64();
1661 muteReason = fields[7].GetString();
1662 muteBy = fields[8].GetString();
1663 failedLogins = fields[9].GetUInt32();
1664 locked = fields[10].GetUInt8();
1665 OS = fields[11].GetString();
1666 }
1667
1668 // Creates a chat link to the character. Returns nameLink
1669 std::string nameLink = handler->playerLink(targetName);
1670
1671 // Returns banType, banTime, bannedBy, banreason
1672 stmt2 = LoginDatabase.GetPreparedStatement(LOGIN_SEL_PINFO_BANS);
1673 stmt2->setUInt32(0, accId);
1674 PreparedQueryResult result2 = LoginDatabase.Query(stmt2);
1675 if (!result2)
1676 {
1677 banType = handler->GetTrinityString(LANG_CHARACTER);
1678 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_BANS);
1679 stmt->setUInt64(0, lowguid);
1680 result2 = CharacterDatabase.Query(stmt);
1681 }
1682 else
1683 banType = handler->GetTrinityString(LANG_ACCOUNT);
1684
1685 if (result2)
1686 {
1687 Field* fields = result2->Fetch();
1688 bool permanent = fields[1].GetUInt64() != 0;
1689 banTime = !permanent ? int64(fields[0].GetUInt32()) : 0;
1690 bannedBy = fields[2].GetString();
1691 banReason = fields[3].GetString();
1692 }
1693
1694 // Can be used to query data from Characters database
1695 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_XP);
1696 stmt->setUInt64(0, lowguid);
1697 PreparedQueryResult result4 = CharacterDatabase.Query(stmt);
1698
1699 if (result4)
1700 {
1701 Field* fields = result4->Fetch();
1702 xp = fields[0].GetUInt32(); // Used for "current xp" output and "%u XP Left" calculation
1703 ObjectGuid::LowType gguid = fields[1].GetUInt64(); // We check if have a guild for the person, so we might not require to query it at all
1704 xptotal = sObjectMgr->GetXPForLevel(level);
1705
1706 if (gguid)
1707 {
1708 // Guild Data - an own query, because it may not happen.
1709 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GUILD_MEMBER_EXTENDED);
1710 stmt->setUInt64(0, lowguid);
1711 PreparedQueryResult result5 = CharacterDatabase.Query(stmt);
1712 if (result5)
1713 {
1714 Field* fields5 = result5->Fetch();
1715 guildId = fields5[0].GetUInt64();
1716 guildName = fields5[1].GetString();
1717 guildRank = fields5[2].GetString();
1718 guildRankId = fields5[3].GetUInt8();
1719 note = fields5[4].GetString();
1720 officeNote = fields5[5].GetString();
1721 }
1722 }
1723 }
1724
1725 // Initiate output
1726 // Output I. LANG_PINFO_PLAYER
1727 handler->PSendSysMessage(LANG_PINFO_PLAYER, target ? "" : handler->GetTrinityString(LANG_OFFLINE), nameLink.c_str(), targetGuid.ToString().c_str());
1728
1729 // Output II. LANG_PINFO_GM_ACTIVE if character is gamemaster
1730 if (target && target->IsGameMaster())
1731 handler->PSendSysMessage(LANG_PINFO_GM_ACTIVE);
1732
1733 // Output III. LANG_PINFO_BANNED if ban exists and is applied
1734 if (banTime >= 0)
1735 handler->PSendSysMessage(LANG_PINFO_BANNED, banType.c_str(), banReason.c_str(), banTime > 0 ? secsToTimeString(std::max<int64>(banTime - GameTime::GetGameTime(), 0), TimeFormat::ShortText).c_str() : handler->GetTrinityString(LANG_PERMANENTLY), bannedBy.c_str());
1736
1737 // Output IV. LANG_PINFO_MUTED if mute is applied
1738 if (muteTime > 0)
1739 handler->PSendSysMessage(LANG_PINFO_MUTED, muteReason.c_str(), secsToTimeString(muteTime - GameTime::GetGameTime(), TimeFormat::ShortText).c_str(), muteBy.c_str());
1740
1741 // Output V. LANG_PINFO_ACC_ACCOUNT
1742 handler->PSendSysMessage(LANG_PINFO_ACC_ACCOUNT, userName.c_str(), accId, security);
1743
1744 // Output VI. LANG_PINFO_ACC_LASTLOGIN
1745 handler->PSendSysMessage(LANG_PINFO_ACC_LASTLOGIN, lastLogin.c_str(), failedLogins);
1746
1747 // Output VII. LANG_PINFO_ACC_OS
1748 handler->PSendSysMessage(LANG_PINFO_ACC_OS, OS.c_str(), latency);
1749
1750 // Output VIII. LANG_PINFO_ACC_REGMAILS
1751 handler->PSendSysMessage(LANG_PINFO_ACC_REGMAILS, regMail.c_str(), eMail.c_str());
1752
1753 // Output IX. LANG_PINFO_ACC_IP
1754 handler->PSendSysMessage(LANG_PINFO_ACC_IP, lastIp.c_str(), locked ? handler->GetTrinityString(LANG_YES) : handler->GetTrinityString(LANG_NO));
1755
1756 // Output X. LANG_PINFO_CHR_LEVEL
1757 if (level != sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
1758 handler->PSendSysMessage(LANG_PINFO_CHR_LEVEL_LOW, level, xp, xptotal, (xptotal - xp));
1759 else
1760 handler->PSendSysMessage(LANG_PINFO_CHR_LEVEL_HIGH, level);
1761
1762 // Output XI. LANG_PINFO_CHR_RACE
1763 raceStr = DB2Manager::GetChrRaceName(raceid, locale);
1764 classStr = DB2Manager::GetChrClassName(classid, locale);
1765 handler->PSendSysMessage(LANG_PINFO_CHR_RACE, (gender == 0 ? handler->GetTrinityString(LANG_CHARACTER_GENDER_MALE) : handler->GetTrinityString(LANG_CHARACTER_GENDER_FEMALE)), raceStr.c_str(), classStr.c_str());
1766
1767 // Output XII. LANG_PINFO_CHR_ALIVE
1768 handler->PSendSysMessage(LANG_PINFO_CHR_ALIVE, alive.c_str());
1769
1770 // Output XIII. phases
1771 if (target)
1772 PhasingHandler::PrintToChat(handler, target);
1773
1774 // Output XIV. LANG_PINFO_CHR_MONEY
1775 uint32 gold = money / GOLD;
1776 uint32 silv = (money % GOLD) / SILVER;
1777 uint32 copp = (money % GOLD) % SILVER;
1778 handler->PSendSysMessage(LANG_PINFO_CHR_MONEY, gold, silv, copp);
1779
1780 // Position data
1781 MapEntry const* map = sMapStore.LookupEntry(mapId);
1782 AreaTableEntry const* area = sAreaTableStore.LookupEntry(areaId);
1783 if (area)
1784 {
1785 zoneName = area->AreaName[locale];
1786
1787 if (area->GetFlags().HasFlag(AreaFlags::IsSubzone))
1788 {
1789 AreaTableEntry const* zone = sAreaTableStore.LookupEntry(area->ParentAreaID);
1790 if (zone)
1791 {
1792 areaName = zoneName;
1793 zoneName = zone->AreaName[locale];
1794 }
1795 }
1796 }
1797
1798 if (!zoneName)
1799 zoneName = handler->GetTrinityString(LANG_UNKNOWN);
1800
1801 if (areaName)
1802 handler->PSendSysMessage(LANG_PINFO_CHR_MAP_WITH_AREA, map->MapName[locale], zoneName, areaName);
1803 else
1804 handler->PSendSysMessage(LANG_PINFO_CHR_MAP, map->MapName[locale], zoneName);
1805
1806 // Output XVII. - XVIX. if they are not empty
1807 if (!guildName.empty())
1808 {
1809 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD, guildName.c_str(), std::to_string(guildId).c_str());
1810 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_RANK, guildRank.c_str(), uint32(guildRankId));
1811 if (!note.empty())
1812 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_NOTE, note.c_str());
1813 if (!officeNote.empty())
1814 handler->PSendSysMessage(LANG_PINFO_CHR_GUILD_ONOTE, officeNote.c_str());
1815 }
1816
1817 // Output XX. LANG_PINFO_CHR_PLAYEDTIME
1818 handler->PSendSysMessage(LANG_PINFO_CHR_PLAYEDTIME, (secsToTimeString(totalPlayerTime, TimeFormat::ShortText, true)).c_str());
1819
1820 // Mail Data - an own query, because it may or may not be useful.
1821 // SQL: "SELECT SUM(CASE WHEN (checked & 1) THEN 1 ELSE 0 END) AS 'readmail', COUNT(*) AS 'totalmail' FROM mail WHERE `receiver` = ?"
1822 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PINFO_MAILS);
1823 stmt->setUInt64(0, lowguid);
1824 PreparedQueryResult result6 = CharacterDatabase.Query(stmt);
1825 if (result6)
1826 {
1827 Field* fields = result6->Fetch();
1828 uint32 readmail = uint32(fields[0].GetDouble());
1829 uint32 totalmail = uint32(fields[1].GetUInt64());
1830
1831 // Output XXI. LANG_INFO_CHR_MAILS if at least one mail is given
1832 if (totalmail >= 1)
1833 handler->PSendSysMessage(LANG_PINFO_CHR_MAILS, readmail, totalmail);
1834 }
1835
1836 return true;
1837 }
1838
1839 static bool HandleRespawnCommand(ChatHandler* handler)
1840 {
1841 Player* player = handler->GetSession()->GetPlayer();
1842
1843 // accept only explicitly selected target (not implicitly self targeting case)
1844 Creature* target = !player->GetTarget().IsEmpty() ? handler->getSelectedCreature() : nullptr;
1845 if (target)
1846 {
1847 if (target->IsPet())
1848 {
1849 handler->SendSysMessage(LANG_SELECT_CREATURE);
1850 handler->SetSentErrorMessage(true);
1851 return false;
1852 }
1853
1854 if (target->isDead())
1855 target->Respawn();
1856 return true;
1857 }
1858
1859 // First handle any creatures that still have a corpse around
1860 Trinity::RespawnDo u_do;
1861 Trinity::WorldObjectWorker<Trinity::RespawnDo> worker(player, u_do);
1862 Cell::VisitGridObjects(player, worker, player->GetGridActivationRange());
1863
1864 // Now handle any that had despawned, but had respawn time logged.
1865 std::vector<RespawnInfo const*> data;
1866 player->GetMap()->GetRespawnInfo(data, SPAWN_TYPEMASK_ALL);
1867 if (!data.empty())
1868 {
1869 uint32 const gridId = Trinity::ComputeGridCoord(player->GetPositionX(), player->GetPositionY()).GetId();
1870 for (RespawnInfo const* info : data)
1871 if (info->gridId == gridId)
1872 player->GetMap()->Respawn(info->type, info->spawnId);
1873 }
1874
1875 return true;
1876 }
1877
1878 // mute player for the specified duration
1879 static bool HandleMuteCommand(ChatHandler* handler, Optional<PlayerIdentifier> player, uint32 muteTime, Tail muteReason)
1880 {
1881 std::string muteReasonStr{ muteReason };
1882 if (muteReason.empty())
1883 muteReasonStr = handler->GetTrinityString(LANG_NO_REASON);
1884
1885 if (!player)
1886 player = PlayerIdentifier::FromTarget(handler);
1887 if (!player)
1888 {
1889 handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
1890 handler->SetSentErrorMessage(true);
1891 return false;
1892 }
1893
1894 Player* target = player->GetConnectedPlayer();
1895 uint32 accountId = target ? target->GetSession()->GetAccountId() : sCharacterCache->GetCharacterAccountIdByGuid(*player);
1896
1897 // find only player from same account if any
1898 if (!target)
1899 if (WorldSession* session = sWorld->FindSession(accountId))
1900 target = session->GetPlayer();
1901
1902 // must have strong lesser security level
1903 if (handler->HasLowerSecurity(target, player->GetGUID(), true))
1904 return false;
1905
1906 LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME);
1907 std::string muteBy = "";
1908 if (Player* gmPlayer = handler->GetPlayer())
1909 muteBy = gmPlayer->GetName();
1910 else
1911 muteBy = handler->GetTrinityString(LANG_CONSOLE);
1912
1913 if (target)
1914 {
1915 // Target is online, mute will be in effect right away.
1916 int64 mutedUntil = GameTime::GetGameTime() + static_cast<int64>(muteTime) * MINUTE;
1917 target->GetSession()->m_muteTime = mutedUntil;
1918 stmt->setInt64(0, mutedUntil);
1919 }
1920 else
1921 {
1922 // Target is offline, mute will be in effect starting from the next login.
1923 stmt->setInt64(0, -static_cast<int64>(muteTime) * MINUTE);
1924 }
1925
1926 stmt->setString(1, muteReasonStr);
1927 stmt->setString(2, muteBy);
1928 stmt->setUInt32(3, accountId);
1929 LoginDatabase.Execute(stmt);
1930 stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_MUTE);
1931 stmt->setUInt32(0, accountId);
1932 stmt->setUInt32(1, muteTime);
1933 stmt->setString(2, muteBy);
1934 stmt->setString(3, muteReasonStr);
1935 LoginDatabase.Execute(stmt);
1936
1937 std::string nameLink = handler->playerLink(*player);
1938 if (sWorld->getBoolConfig(CONFIG_SHOW_MUTE_IN_WORLD))
1939 sWorld->SendWorldText(LANG_COMMAND_MUTEMESSAGE_WORLD, muteBy.c_str(), nameLink.c_str(), muteTime, muteReasonStr.c_str());
1940 if (target)
1941 {
1942 ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_CHAT_DISABLED, muteTime, muteBy.c_str(), muteReasonStr.c_str());
1943 handler->PSendSysMessage(LANG_YOU_DISABLE_CHAT, nameLink.c_str(), muteTime, muteReasonStr.c_str());
1944 }
1945 else
1946 {
1947 handler->PSendSysMessage(LANG_COMMAND_DISABLE_CHAT_DELAYED, nameLink.c_str(), muteTime, muteReasonStr.c_str());
1948 }
1949
1950 return true;
1951 }
1952
1953 // unmute player
1954 static bool HandleUnmuteCommand(ChatHandler* handler, char const* args)
1955 {
1956 Player* target;
1957 ObjectGuid targetGuid;
1958 std::string targetName;
1959 if (!handler->extractPlayerTarget((char*)args, &target, &targetGuid, &targetName))
1960 return false;
1961
1962 uint32 accountId = target ? target->GetSession()->GetAccountId() : sCharacterCache->GetCharacterAccountIdByGuid(targetGuid);
1963
1964 // find only player from same account if any
1965 if (!target)
1966 if (WorldSession* session = sWorld->FindSession(accountId))
1967 target = session->GetPlayer();
1968
1969 // must have strong lesser security level
1970 if (handler->HasLowerSecurity (target, targetGuid, true))
1971 return false;
1972
1973 if (target)
1974 {
1975 if (target->GetSession()->CanSpeak())
1976 {
1977 handler->SendSysMessage(LANG_CHAT_ALREADY_ENABLED);
1978 handler->SetSentErrorMessage(true);
1979 return false;
1980 }
1981
1982 target->GetSession()->m_muteTime = 0;
1983 }
1984
1985 LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME);
1986 stmt->setInt64(0, 0);
1987 stmt->setString(1, ""sv);
1988 stmt->setString(2, ""sv);
1989 stmt->setUInt32(3, accountId);
1990 LoginDatabase.Execute(stmt);
1991
1992 if (target)
1993 ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_CHAT_ENABLED);
1994
1995 std::string nameLink = handler->playerLink(targetName);
1996
1997 handler->PSendSysMessage(LANG_YOU_ENABLE_CHAT, nameLink.c_str());
1998
1999 return true;
2000 }
2001
2002 // mutehistory command
2003 static bool HandleMuteHistoryCommand(ChatHandler* handler, std::string accountName)
2004 {
2005 if (!Utf8ToUpperOnlyLatin(accountName))
2006 {
2007 handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
2008 handler->SetSentErrorMessage(true);
2009 return false;
2010 }
2011
2012 uint32 accountId = AccountMgr::GetId(accountName);
2013 if (!accountId)
2014 {
2015 handler->PSendSysMessage(LANG_ACCOUNT_NOT_EXIST, accountName.c_str());
2016 return false;
2017 }
2018
2019 return HandleMuteHistoryHelper(accountId, accountName.c_str(), handler);
2020 }
2021
2022 // helper for mutehistory
2023 static bool HandleMuteHistoryHelper(uint32 accountId, char const* accountName, ChatHandler *handler)
2024 {
2025 LoginDatabasePreparedStatement *stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_MUTE_INFO);
2026 stmt->setUInt32(0, accountId);
2027 PreparedQueryResult result = LoginDatabase.Query(stmt);
2028
2029 if (!result)
2030 {
2031 handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY_EMPTY, accountName);
2032 return true;
2033 }
2034
2035 handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY, accountName);
2036 do
2037 {
2038 Field* fields = result->Fetch();
2039
2040 // we have to manually set the string for mutedate
2041 time_t sqlTime = fields[0].GetUInt32();
2042 tm timeinfo;
2043 char buffer[80];
2044
2045 // set it to string
2046 localtime_r(&sqlTime, &timeinfo);
2047 strftime(buffer, sizeof(buffer),"%Y-%m-%d %I:%M%p", &timeinfo);
2048
2049 handler->PSendSysMessage(LANG_COMMAND_MUTEHISTORY_OUTPUT, buffer, fields[1].GetUInt32(), fields[2].GetCString(), fields[3].GetCString());
2050 } while (result->NextRow());
2051 return true;
2052 }
2053
2054 static bool HandleMovegensCommand(ChatHandler* handler)
2055 {
2056 Unit* unit = handler->getSelectedUnit();
2057 if (!unit)
2058 {
2059 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
2060 handler->SetSentErrorMessage(true);
2061 return false;
2062 }
2063
2064 handler->PSendSysMessage(LANG_MOVEGENS_LIST, (unit->GetTypeId() == TYPEID_PLAYER ? "Player" : "Creature"), unit->GetGUID().ToString().c_str());
2065
2066 if (unit->GetMotionMaster()->Empty())
2067 {
2068 handler->SendSysMessage("Empty");
2069 return true;
2070 }
2071
2072 float x, y, z;
2073 unit->GetMotionMaster()->GetDestination(x, y, z);
2074
2075 std::vector<MovementGeneratorInformation> const list = unit->GetMotionMaster()->GetMovementGeneratorsInformation();
2076 for (MovementGeneratorInformation const& info : list)
2077 {
2078 switch (info.Type)
2079 {
2080 case IDLE_MOTION_TYPE:
2081 handler->SendSysMessage(LANG_MOVEGENS_IDLE);
2082 break;
2083 case RANDOM_MOTION_TYPE:
2084 handler->SendSysMessage(LANG_MOVEGENS_RANDOM);
2085 break;
2086 case WAYPOINT_MOTION_TYPE:
2087 handler->SendSysMessage(LANG_MOVEGENS_WAYPOINT);
2088 break;
2089 case CONFUSED_MOTION_TYPE:
2090 handler->SendSysMessage(LANG_MOVEGENS_CONFUSED);
2091 break;
2092 case CHASE_MOTION_TYPE:
2093 if (info.TargetGUID.IsEmpty())
2094 handler->SendSysMessage(LANG_MOVEGENS_CHASE_NULL);
2095 else if (info.TargetGUID.IsPlayer())
2096 handler->PSendSysMessage(LANG_MOVEGENS_CHASE_PLAYER, info.TargetName.c_str(), info.TargetGUID.ToString().c_str());
2097 else
2098 handler->PSendSysMessage(LANG_MOVEGENS_CHASE_CREATURE, info.TargetName.c_str(), info.TargetGUID.ToString().c_str());
2099 break;
2100 case FOLLOW_MOTION_TYPE:
2101 if (info.TargetGUID.IsEmpty())
2102 handler->SendSysMessage(LANG_MOVEGENS_FOLLOW_NULL);
2103 else if (info.TargetGUID.IsPlayer())
2104 handler->PSendSysMessage(LANG_MOVEGENS_FOLLOW_PLAYER, info.TargetName.c_str(), info.TargetGUID.ToString().c_str());
2105 else
2106 handler->PSendSysMessage(LANG_MOVEGENS_FOLLOW_CREATURE, info.TargetName.c_str(), info.TargetGUID.ToString().c_str());
2107 break;
2108 case HOME_MOTION_TYPE:
2109 if (unit->GetTypeId() == TYPEID_UNIT)
2110 handler->PSendSysMessage(LANG_MOVEGENS_HOME_CREATURE, x, y, z);
2111 else
2112 handler->SendSysMessage(LANG_MOVEGENS_HOME_PLAYER);
2113 break;
2114 case FLIGHT_MOTION_TYPE:
2115 handler->SendSysMessage(LANG_MOVEGENS_FLIGHT);
2116 break;
2117 case POINT_MOTION_TYPE:
2118 handler->PSendSysMessage(LANG_MOVEGENS_POINT, x, y, z);
2119 break;
2120 case FLEEING_MOTION_TYPE:
2121 handler->SendSysMessage(LANG_MOVEGENS_FEAR);
2122 break;
2123 case DISTRACT_MOTION_TYPE:
2124 handler->SendSysMessage(LANG_MOVEGENS_DISTRACT);
2125 break;
2126 case EFFECT_MOTION_TYPE:
2127 handler->SendSysMessage(LANG_MOVEGENS_EFFECT);
2128 break;
2129 default:
2130 handler->PSendSysMessage(LANG_MOVEGENS_UNKNOWN, info.Type);
2131 break;
2132 }
2133 }
2134 return true;
2135 }
2136
2137 static bool HandleComeToMeCommand(ChatHandler* handler)
2138 {
2139 Creature* caster = handler->getSelectedCreature();
2140 if (!caster)
2141 {
2142 handler->SendSysMessage(LANG_SELECT_CREATURE);
2143 handler->SetSentErrorMessage(true);
2144 return false;
2145 }
2146
2147 Player* player = handler->GetSession()->GetPlayer();
2148
2149 caster->GetMotionMaster()->MovePoint(0, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
2150
2151 return true;
2152 }
2153
2154 static bool HandleDamageCommand(ChatHandler* handler, uint32 damage, Optional<SpellSchools> school, Optional<SpellInfo const*> spellInfo)
2155 {
2156 Unit* target = handler->getSelectedUnit();
2157 if (!target || !handler->GetSession()->GetPlayer()->GetTarget())
2158 {
2159 handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
2160 handler->SetSentErrorMessage(true);
2161 return false;
2162 }
2163
2164 if (Player* player = target->ToPlayer())
2165 if (handler->HasLowerSecurity(player, ObjectGuid::Empty, false))
2166 return false;
2167
2168 if (!target->IsAlive())
2169 return true;
2170
2171 // flat melee damage without resistence/etc reduction
2172 if (!school)
2173 {
2174 Unit::DealDamage(handler->GetSession()->GetPlayer(), target, damage, nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false);
2175 if (target != handler->GetSession()->GetPlayer())
2176 handler->GetSession()->GetPlayer()->SendAttackStateUpdate (HITINFO_AFFECTS_VICTIM, target, 1, SPELL_SCHOOL_MASK_NORMAL, damage, 0, 0, VICTIMSTATE_HIT, 0, 0);
2177 return true;
2178 }
2179
2180 SpellSchoolMask schoolmask = SpellSchoolMask(1 << *school);
2181
2182 if (Unit::IsDamageReducedByArmor(schoolmask))
2183 damage = Unit::CalcArmorReducedDamage(handler->GetSession()->GetPlayer(), target, damage, nullptr, BASE_ATTACK);
2184
2185 Player* attacker = handler->GetSession()->GetPlayer();
2186
2187 // melee damage by specific school
2188 if (!spellInfo)
2189 {
2190 DamageInfo dmgInfo(attacker, target, damage, nullptr, schoolmask, SPELL_DIRECT_DAMAGE, BASE_ATTACK);
2191 Unit::CalcAbsorbResist(dmgInfo);
2192
2193 if (!dmgInfo.GetDamage())
2194 return true;
2195
2196 damage = dmgInfo.GetDamage();
2197
2198 uint32 absorb = dmgInfo.GetAbsorb();
2199 uint32 resist = dmgInfo.GetResist();
2200 Unit::DealDamageMods(attacker, target, damage, &absorb);
2201 Unit::DealDamage(attacker, target, damage, nullptr, DIRECT_DAMAGE, schoolmask, nullptr, false);
2202 attacker->SendAttackStateUpdate(HITINFO_AFFECTS_VICTIM, target, 0, schoolmask, damage, absorb, resist, VICTIMSTATE_HIT, 0, 0);
2203 return true;
2204 }
2205
2206 // non-melee damage
2207
2208 SpellNonMeleeDamage damageInfo(attacker, target, *spellInfo, { (*spellInfo)->GetSpellXSpellVisualId(handler->GetSession()->GetPlayer()), 0 }, (*spellInfo)->SchoolMask);
2209 damageInfo.damage = damage;
2210 Unit::DealDamageMods(damageInfo.attacker, damageInfo.target, damageInfo.damage, &damageInfo.absorb);
2211 target->DealSpellDamage(&damageInfo, true);
2212 target->SendSpellNonMeleeDamageLog(&damageInfo);
2213 return true;
2214 }
2215
2216 static bool HandleDamageGoCommand(ChatHandler* handler, Variant<Hyperlink<gameobject>, ObjectGuid::LowType> spawnId, int32 damage)
2217 {
2218 GameObject* go = handler->GetObjectFromPlayerMapByDbGuid(*spawnId);
2219 if (!go)
2220 {
2221 handler->PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, std::to_string(*spawnId).c_str());
2222 handler->SetSentErrorMessage(true);
2223 return false;
2224 }
2225
2226 if (!go->IsDestructibleBuilding())
2227 {
2228 handler->SendSysMessage(LANG_INVALID_GAMEOBJECT_TYPE);
2229 handler->SetSentErrorMessage(true);
2230 return false;
2231 }
2232
2233 go->ModifyHealth(-damage, handler->GetSession()->GetPlayer());
2234 handler->PSendSysMessage(LANG_GAMEOBJECT_DAMAGED, go->GetName().c_str(), std::to_string(*spawnId).c_str(), -damage, go->GetGOValue()->Building.Health);
2235 return true;
2236 }
2237
2238 static bool HandleCombatStopCommand(ChatHandler* handler, char const* args)
2239 {
2240 Player* target = nullptr;
2241
2242 if (args && args[0] != '\0')
2243 {
2244 target = ObjectAccessor::FindPlayerByName(args);
2245 if (!target)
2246 {
2247 handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
2248 handler->SetSentErrorMessage(true);
2249 return false;
2250 }
2251 }
2252
2253 if (!target)
2254 {
2255 if (!handler->extractPlayerTarget((char*)args, &target))
2256 return false;
2257 }
2258
2259 // check online security
2260 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
2261 return false;
2262
2263 target->CombatStop();
2264 return true;
2265 }
2266
2267 static bool HandleRepairitemsCommand(ChatHandler* handler, char const* args)
2268 {
2269 Player* target;
2270 if (!handler->extractPlayerTarget((char*)args, &target))
2271 return false;
2272
2273 // check online security
2274 if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
2275 return false;
2276
2277 // Repair items
2278 target->DurabilityRepairAll(false, 0, false);
2279
2280 handler->PSendSysMessage(LANG_YOU_REPAIR_ITEMS, handler->GetNameLink(target).c_str());
2281 if (handler->needReportToTarget(target))
2282 ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_ITEMS_REPAIRED, handler->GetNameLink().c_str());
2283
2284 return true;
2285 }
2286
2287 static bool HandleFreezeCommand(ChatHandler* handler, char const* args)
2288 {
2289 Player* player = handler->getSelectedPlayer(); // Selected player, if any. Might be null.
2290 uint32 freezeDuration = 0; // Freeze Duration (in seconds)
2291 bool canApplyFreeze = false; // Determines if every possible argument is set so Freeze can be applied
2292 bool getDurationFromConfig = false; // If there's no given duration, we'll retrieve the world cfg value later
2293
2294 /*
2295 Possible Freeze Command Scenarios:
2296 case 1 - .freeze (without args and a selected player)
2297 case 2 - .freeze duration (with a selected player)
2298 case 3 - .freeze player duration
2299 case 4 - .freeze player (without specifying duration)
2300 */
2301
2302 // case 1: .freeze
2303 if (!*args)
2304 {
2305 // Might have a selected player. We'll check it later
2306 // Get the duration from world cfg
2307 getDurationFromConfig = true;
2308 }
2309 else
2310 {
2311 // Get the args that we might have (up to 2)
2312 char const* arg1 = strtok((char*)args, " ");
2313 char const* arg2 = strtok(nullptr, " ");
2314
2315 // Analyze them to see if we got either a playerName or duration or both
2316 if (arg1)
2317 {
2318 if (isNumeric(arg1))
2319 {
2320 // case 2: .freeze duration
2321 // We have a selected player. We'll check him later
2322 freezeDuration = uint32(atoi(arg1));
2323 canApplyFreeze = true;
2324 }
2325 else
2326 {
2327 // case 3 or 4: .freeze player duration | .freeze player
2328 // find the player
2329 std::string name = arg1;
2330 normalizePlayerName(name);
2331 player = ObjectAccessor::FindPlayerByName(name);
2332 // Check if we have duration set
2333 if (arg2 && isNumeric(arg2))
2334 {
2335 freezeDuration = uint32(atoi(arg2));
2336 canApplyFreeze = true;
2337 }
2338 else
2339 getDurationFromConfig = true;
2340 }
2341 }
2342 }
2343
2344 // Check if duration needs to be retrieved from config
2345 if (getDurationFromConfig)
2346 {
2347 freezeDuration = sWorld->getIntConfig(CONFIG_GM_FREEZE_DURATION);
2348 canApplyFreeze = true;
2349 }
2350
2351 // Player and duration retrieval is over
2352 if (canApplyFreeze)
2353 {
2354 if (!player) // can be null if some previous selection failed
2355 {
2356 handler->SendSysMessage(LANG_COMMAND_FREEZE_WRONG);
2357 return true;
2358 }
2359 else if (player == handler->GetSession()->GetPlayer())
2360 {
2361 // Can't freeze himself
2362 handler->SendSysMessage(LANG_COMMAND_FREEZE_ERROR);
2363 return true;
2364 }
2365 else // Apply the effect
2366 {
2367 // Add the freeze aura and set the proper duration
2368 // Player combat status and flags are now handled
2369 // in Freeze Spell AuraScript (OnApply)
2370 Aura* freeze = player->AddAura(9454, player);
2371 if (freeze)
2372 {
2373 if (freezeDuration)
2374 freeze->SetDuration(freezeDuration * IN_MILLISECONDS);
2375 handler->PSendSysMessage(LANG_COMMAND_FREEZE, player->GetName().c_str());
2376 // save player
2377 player->SaveToDB();
2378 return true;
2379 }
2380 }
2381 }
2382 return false;
2383 }
2384
2385 static bool HandleUnFreezeCommand(ChatHandler* handler, Optional<std::string> targetNameArg)
2386 {
2387 std::string name;
2388 Player* player;
2389
2390 if (targetNameArg)
2391 {
2392 name = *targetNameArg;
2393 normalizePlayerName(name);
2394 player = ObjectAccessor::FindPlayerByName(name);
2395 }
2396 else // If no name was entered - use target
2397 {
2398 player = handler->getSelectedPlayer();
2399 if (player)
2400 name = player->GetName();
2401 }
2402
2403 if (player)
2404 {
2405 handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, name.c_str());
2406
2407 // Remove Freeze spell (allowing movement and spells)
2408 // Player Flags + Neutral faction removal is now
2409 // handled on the Freeze Spell AuraScript (OnRemove)
2410 player->RemoveAurasDueToSpell(9454);
2411 }
2412 else
2413 {
2414 if (targetNameArg)
2415 {
2416 // Check for offline players
2417 ObjectGuid guid = sCharacterCache->GetCharacterGuidByName(name);
2418 if (guid.IsEmpty())
2419 {
2420 handler->SendSysMessage(LANG_COMMAND_FREEZE_WRONG);
2421 return true;
2422 }
2423
2424 // If player found: delete his freeze aura
2425 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_AURA_FROZEN);
2426 stmt->setUInt64(0, guid.GetCounter());
2427 CharacterDatabase.Execute(stmt);
2428
2429 handler->PSendSysMessage(LANG_COMMAND_UNFREEZE, name.c_str());
2430 return true;
2431 }
2432 else
2433 {
2434 handler->SendSysMessage(LANG_COMMAND_FREEZE_WRONG);
2435 return true;
2436 }
2437 }
2438
2439 return true;
2440 }
2441
2442 static bool HandleListFreezeCommand(ChatHandler* handler)
2443 {
2444 // Get names from DB
2445 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_AURA_FROZEN);
2446 PreparedQueryResult result = CharacterDatabase.Query(stmt);
2447 if (!result)
2448 {
2449 handler->SendSysMessage(LANG_COMMAND_NO_FROZEN_PLAYERS);
2450 return true;
2451 }
2452
2453 // Header of the names
2454 handler->PSendSysMessage(LANG_COMMAND_LIST_FREEZE);
2455
2456 // Output of the results
2457 do
2458 {
2459 Field* fields = result->Fetch();
2460 std::string player = fields[0].GetString();
2461 int32 remaintime = fields[1].GetInt32();
2462 // Save the frozen player to update remaining time in case of future .listfreeze uses
2463 // before the frozen state expires
2464 if (Player* frozen = ObjectAccessor::FindPlayerByName(player))
2465 frozen->SaveToDB();
2466 // Notify the freeze duration
2467 if (remaintime == -1) // Permanent duration
2468 handler->PSendSysMessage(LANG_COMMAND_PERMA_FROZEN_PLAYER, player.c_str());
2469 else
2470 // show time left (seconds)
2471 handler->PSendSysMessage(LANG_COMMAND_TEMP_FROZEN_PLAYER, player.c_str(), remaintime / IN_MILLISECONDS);
2472 }
2473 while (result->NextRow());
2474
2475 return true;
2476 }
2477
2478 static bool HandlePlayAllCommand(ChatHandler* handler, uint32 soundId, Optional<int32> broadcastTextId)
2479 {
2480 if (!sSoundKitStore.LookupEntry(soundId))
2481 {
2482 handler->PSendSysMessage(LANG_SOUND_NOT_EXIST, soundId);
2483 handler->SetSentErrorMessage(true);
2484 return false;
2485 }
2486
2487 sWorld->SendGlobalMessage(WorldPackets::Misc::PlaySound(handler->GetSession()->GetPlayer()->GetGUID(), soundId, broadcastTextId.value_or(0)).Write());
2488
2489 handler->PSendSysMessage(LANG_COMMAND_PLAYED_TO_ALL, soundId);
2490 return true;
2491 }
2492
2493 static bool HandlePossessCommand(ChatHandler* handler)
2494 {
2495 Unit* unit = handler->getSelectedUnit();
2496 if (!unit)
2497 return false;
2498
2499 handler->GetSession()->GetPlayer()->CastSpell(unit, 530, true);
2500 return true;
2501 }
2502
2503 static bool HandleUnPossessCommand(ChatHandler* handler)
2504 {
2505 Unit* unit = handler->getSelectedUnit();
2506 if (!unit)
2507 unit = handler->GetSession()->GetPlayer();
2508
2509 unit->RemoveCharmAuras();
2510
2511 return true;
2512 }
2513
2514 static bool HandleBindSightCommand(ChatHandler* handler)
2515 {
2516 Unit* unit = handler->getSelectedUnit();
2517 if (!unit)
2518 return false;
2519
2520 handler->GetSession()->GetPlayer()->CastSpell(unit, 6277, true);
2521 return true;
2522 }
2523
2524 static bool HandleUnbindSightCommand(ChatHandler* handler)
2525 {
2526 Player* player = handler->GetSession()->GetPlayer();
2527
2528 if (player->isPossessing())
2529 return false;
2530
2531 player->StopCastingBindSight();
2532 return true;
2533 }
2534
2535 static bool HandleMailBoxCommand(ChatHandler* handler)
2536 {
2537 Player* player = handler->GetSession()->GetPlayer();
2538
2539 handler->GetSession()->SendShowMailBox(player->GetGUID());
2540 return true;
2541 }
2542};
2543
2544void AddSC_misc_commandscript()
2545{
2546 new misc_commandscript();
2547}
sCharacterCache
#define sCharacterCache
Definition CharacterCache.h:79
CHAR_SEL_PINFO_XP
@ CHAR_SEL_PINFO_XP
Definition CharacterDatabase.h:432
CHAR_SEL_PVPSTATS_FACTIONS_OVERALL
@ CHAR_SEL_PVPSTATS_FACTIONS_OVERALL
Definition CharacterDatabase.h:620
CHAR_SEL_CHAR_HOMEBIND
@ CHAR_SEL_CHAR_HOMEBIND
Definition CharacterDatabase.h:435
CHAR_DEL_CHAR_AURA_FROZEN
@ CHAR_DEL_CHAR_AURA_FROZEN
Definition CharacterDatabase.h:443
CHAR_SEL_CHARACTER_AURA_FROZEN
@ CHAR_SEL_CHARACTER_AURA_FROZEN
Definition CharacterDatabase.h:423
CHAR_SEL_GUILD_MEMBER_EXTENDED
@ CHAR_SEL_GUILD_MEMBER_EXTENDED
Definition CharacterDatabase.h:104
CHAR_SEL_CHAR_PINFO
@ CHAR_SEL_CHAR_PINFO
Definition CharacterDatabase.h:431
CHAR_SEL_PINFO_MAILS
@ CHAR_SEL_PINFO_MAILS
Definition CharacterDatabase.h:433
CHAR_SEL_PINFO_BANS
@ CHAR_SEL_PINFO_BANS
Definition CharacterDatabase.h:434
EXACT_SEQUENCE
#define EXACT_SEQUENCE(str)
Definition ChatCommandTags.h:96
LocaleConstant
LocaleConstant
Definition Common.h:51
TOTAL_LOCALES
@ TOTAL_LOCALES
Definition Common.h:65
LOCALE_enUS
@ LOCALE_enUS
Definition Common.h:52
IN_MILLISECONDS
@ IN_MILLISECONDS
Definition Common.h:38
MINUTE
@ MINUTE
Definition Common.h:32
AccountTypes
AccountTypes
Definition Common.h:42
sSkillLineStore
DB2Storage< SkillLineEntry > sSkillLineStore("SkillLine.db2", &SkillLineLoadInfo::Instance)
sMapStore
DB2Storage< MapEntry > sMapStore("Map.db2", &MapLoadInfo::Instance)
sItemSparseStore
DB2Storage< ItemSparseEntry > sItemSparseStore("ItemSparse.db2", &ItemSparseLoadInfo::Instance)
sSoundKitStore
DB2Storage< SoundKitEntry > sSoundKitStore("SoundKit.db2", &SoundKitLoadInfo::Instance)
sAreaTableStore
DB2Storage< AreaTableEntry > sAreaTableStore("AreaTable.db2", &AreaTableLoadInfo::Instance)
sDB2Manager
#define sDB2Manager
Definition DB2Stores.h:579
MAX_EFFECT_MASK
#define MAX_EFFECT_MASK
Definition DBCEnums.h:2451
ItemContext
ItemContext
Definition DBCEnums.h:1324
DIFFICULTY_NONE
@ DIFFICULTY_NONE
Definition DBCEnums.h:936
CharacterDatabaseTransaction
SQLTransaction< CharacterDatabaseConnection > CharacterDatabaseTransaction
Definition DatabaseEnvFwd.h:64
PreparedQueryResult
std::shared_ptr< PreparedResultSet > PreparedQueryResult
Definition DatabaseEnvFwd.h:46
LoginDatabase
DatabaseWorkerPool< LoginDatabaseConnection > LoginDatabase
Accessor to the realm/login database.
Definition DatabaseEnv.cpp:22
CharacterDatabase
DatabaseWorkerPool< CharacterDatabaseConnection > CharacterDatabase
Accessor to the character database.
Definition DatabaseEnv.cpp:21
uint8
uint8_t uint8
Definition Define.h:156
int64
int64_t int64
Definition Define.h:149
int32
int32_t int32
Definition Define.h:150
uint64
uint64_t uint64
Definition Define.h:153
UI64LIT
#define UI64LIT(N)
Definition Define.h:139
uint16
uint16_t uint16
Definition Define.h:155
uint32
uint32_t uint32
Definition Define.h:154
MAX_NUMBER_OF_GRIDS
#define MAX_NUMBER_OF_GRIDS
Definition GridDefines.h:38
MAX_HEIGHT
#define MAX_HEIGHT
Definition GridDefines.h:60
sIPLocation
#define sIPLocation
Definition IPLocation.h:56
InventoryResult
InventoryResult
Definition ItemDefines.h:25
EQUIP_ERR_OK
@ EQUIP_ERR_OK
Definition ItemDefines.h:26
GenerateItemRandomBonusListId
ItemRandomBonusListId GenerateItemRandomBonusListId(uint32 item_id)
Definition ItemEnchantmentMgr.cpp:87
LANG_COMMAND_KICKSELF
@ LANG_COMMAND_KICKSELF
Definition Language.h:332
LANG_COMMAND_KICKMESSAGE_WORLD
@ LANG_COMMAND_KICKMESSAGE_WORLD
Definition Language.h:1231
LANG_YES
@ LANG_YES
Definition Language.h:482
LANG_MOVEGENS_FOLLOW_PLAYER
@ LANG_MOVEGENS_FOLLOW_PLAYER
Definition Language.h:915
LANG_CHARACTER_GENDER_FEMALE
@ LANG_CHARACTER_GENDER_FEMALE
Definition Language.h:804
LANG_DEV_ON
@ LANG_DEV_ON
Definition Language.h:913
LANG_COMMAND_GRAVEYARDALRLINKED
@ LANG_COMMAND_GRAVEYARDALRLINKED
Definition Language.h:513
LANG_MOVEGENS_EFFECT
@ LANG_MOVEGENS_EFFECT
Definition Language.h:918
LANG_SELECT_CREATURE
@ LANG_SELECT_CREATURE
Definition Language.h:32
LANG_PINFO_CHR_GUILD_NOTE
@ LANG_PINFO_CHR_GUILD_NOTE
Definition Language.h:796
LANG_PINFO_CHR_ALIVE
@ LANG_PINFO_CHR_ALIVE
Definition Language.h:790
LANG_SUMMONING
@ LANG_SUMMONING
Definition Language.h:142
LANG_NO_REASON
@ LANG_NO_REASON
Definition Language.h:1100
LANG_PINFO_ACC_LASTLOGIN
@ LANG_PINFO_ACC_LASTLOGIN
Definition Language.h:784
LANG_CHARACTER
@ LANG_CHARACTER
Definition Language.h:1105
LANG_UNKNOWN
@ LANG_UNKNOWN
Definition Language.h:77
LANG_COMMAND_GRAVEYARD_ALLIANCE
@ LANG_COMMAND_GRAVEYARD_ALLIANCE
Definition Language.h:520
LANG_COMMAND_OBJNOTFOUND
@ LANG_COMMAND_OBJNOTFOUND
Definition Language.h:324
LANG_MOVEGENS_UNKNOWN
@ LANG_MOVEGENS_UNKNOWN
Definition Language.h:615
LANG_ERROR
@ LANG_ERROR
Definition Language.h:78
LANG_PERMANENTLY
@ LANG_PERMANENTLY
Definition Language.h:1106
LANG_COMMAND_ZONENOGRAFACTION
@ LANG_COMMAND_ZONENOGRAFACTION
Definition Language.h:524
LANG_NO_WEATHER
@ LANG_NO_WEATHER
Definition Language.h:463
LANG_DEV_OFF
@ LANG_DEV_OFF
Definition Language.h:914
LANG_OFFLINE
@ LANG_OFFLINE
Definition Language.h:69
LANG_PLAYERS_SAVED
@ LANG_PLAYERS_SAVED
Definition Language.h:47
LANG_PINFO_CHR_LEVEL_LOW
@ LANG_PINFO_CHR_LEVEL_LOW
Definition Language.h:788
LANG_CANNOT_GO_TO_INST_PARTY
@ LANG_CANNOT_GO_TO_INST_PARTY
Definition Language.h:138
LANG_PINFO_CHR_PLAYEDTIME
@ LANG_PINFO_CHR_PLAYEDTIME
Definition Language.h:798
LANG_UNAUTHORIZED
@ LANG_UNAUTHORIZED
Definition Language.h:1095
LANG_COMMAND_PLAYED_TO_ALL
@ LANG_COMMAND_PLAYED_TO_ALL
Definition Language.h:1073
LANG_GPS_POSITION_INDOORS
@ LANG_GPS_POSITION_INDOORS
Definition Language.h:1108
LANG_COMMAND_DISABLE_CHAT_DELAYED
@ LANG_COMMAND_DISABLE_CHAT_DELAYED
Definition Language.h:334
LANG_IS_TELEPORTED
@ LANG_IS_TELEPORTED
Definition Language.h:136
LANG_LIQUID_STATUS
@ LANG_LIQUID_STATUS
Definition Language.h:217
LANG_COMMAND_COULDNOTFIND
@ LANG_COMMAND_COULDNOTFIND
Definition Language.h:497
LANG_COMMAND_FREEZE_ERROR
@ LANG_COMMAND_FREEZE_ERROR
Definition Language.h:1065
LANG_COMMAND_NOCREATUREFOUND
@ LANG_COMMAND_NOCREATUREFOUND
Definition Language.h:510
LANG_PINFO_CHR_RACE
@ LANG_PINFO_CHR_RACE
Definition Language.h:789
LANG_PINFO_CHR_MAP_WITH_AREA
@ LANG_PINFO_CHR_MAP_WITH_AREA
Definition Language.h:801
LANG_ITEM_CANNOT_CREATE
@ LANG_ITEM_CANNOT_CREATE
Definition Language.h:568
LANG_MOVEGENS_CHASE_PLAYER
@ LANG_MOVEGENS_CHASE_PLAYER
Definition Language.h:609
LANG_COMMAND_GRAVEYARDNOEXIST
@ LANG_COMMAND_GRAVEYARDNOEXIST
Definition Language.h:512
LANG_CANT_TELEPORT_SELF
@ LANG_CANT_TELEPORT_SELF
Definition Language.h:213
LANG_PVPSTATS
@ LANG_PVPSTATS
Definition Language.h:112
LANG_APPEARING_AT
@ LANG_APPEARING_AT
Definition Language.h:147
LANG_MOVEGENS_IDLE
@ LANG_MOVEGENS_IDLE
Definition Language.h:604
LANG_YOU
@ LANG_YOU
Definition Language.h:76
LANG_MOVEGENS_CONFUSED
@ LANG_MOVEGENS_CONFUSED
Definition Language.h:608
LANG_PINFO_PLAYER
@ LANG_PINFO_PLAYER
Definition Language.h:779
LANG_COMMAND_LIST_FREEZE
@ LANG_COMMAND_LIST_FREEZE
Definition Language.h:1069
LANG_MOVEGENS_FOLLOW_CREATURE
@ LANG_MOVEGENS_FOLLOW_CREATURE
Definition Language.h:916
LANG_MOVEGENS_FOLLOW_NULL
@ LANG_MOVEGENS_FOLLOW_NULL
Definition Language.h:917
LANG_PLAYER_SAVED
@ LANG_PLAYER_SAVED
Definition Language.h:46
LANG_PINFO_ACC_OS
@ LANG_PINFO_ACC_OS
Definition Language.h:785
LANG_UNEXPLORE_AREA
@ LANG_UNEXPLORE_AREA
Definition Language.h:645
LANG_CHARACTER_GENDER_MALE
@ LANG_CHARACTER_GENDER_MALE
Definition Language.h:803
LANG_MOVEGENS_DISTRACT
@ LANG_MOVEGENS_DISTRACT
Definition Language.h:680
LANG_YOUR_CHAT_DISABLED
@ LANG_YOUR_CHAT_DISABLED
Definition Language.h:354
LANG_COMMAND_GRAVEYARDWRONGZONE
@ LANG_COMMAND_GRAVEYARDWRONGZONE
Definition Language.h:515
LANG_COMMAND_NO_FROZEN_PLAYERS
@ LANG_COMMAND_NO_FROZEN_PLAYERS
Definition Language.h:1068
LANG_CHAT_ALREADY_ENABLED
@ LANG_CHAT_ALREADY_ENABLED
Definition Language.h:356
LANG_COMMAND_GRAVEYARDNEAREST
@ LANG_COMMAND_GRAVEYARDNEAREST
Definition Language.h:522
LANG_WEATHER_DISABLED
@ LANG_WEATHER_DISABLED
Definition Language.h:464
LANG_GAMEOBJECT_DAMAGED
@ LANG_GAMEOBJECT_DAMAGED
Definition Language.h:219
LANG_COMMAND_UNFREEZE
@ LANG_COMMAND_UNFREEZE
Definition Language.h:1067
LANG_NO_ITEMS_FROM_ITEMSET_FOUND
@ LANG_NO_ITEMS_FROM_ITEMSET_FOUND
Definition Language.h:573
LANG_PINFO_CHR_MONEY
@ LANG_PINFO_CHR_MONEY
Definition Language.h:792
LANG_REMOVE_COOLDOWN
@ LANG_REMOVE_COOLDOWN
Definition Language.h:563
LANG_INVALID_SKILL_ID
@ LANG_INVALID_SKILL_ID
Definition Language.h:556
LANG_YOU_REPAIR_ITEMS
@ LANG_YOU_REPAIR_ITEMS
Definition Language.h:391
LANG_YOU_ENABLE_CHAT
@ LANG_YOU_ENABLE_CHAT
Definition Language.h:358
LANG_YOUR_CHAT_ENABLED
@ LANG_YOUR_CHAT_ENABLED
Definition Language.h:357
LANG_COMMAND_TEMP_FROZEN_PLAYER
@ LANG_COMMAND_TEMP_FROZEN_PLAYER
Definition Language.h:1084
LANG_CANNOT_SUMMON_INST_INST
@ LANG_CANNOT_SUMMON_INST_INST
Definition Language.h:141
LANG_PINFO_CHR_LEVEL_HIGH
@ LANG_PINFO_CHR_LEVEL_HIGH
Definition Language.h:800
LANG_NO
@ LANG_NO
Definition Language.h:483
LANG_COMMAND_MUTEMESSAGE_WORLD
@ LANG_COMMAND_MUTEMESSAGE_WORLD
Definition Language.h:1234
LANG_CANNOT_SUMMON_TO_INST
@ LANG_CANNOT_SUMMON_TO_INST
Definition Language.h:137
LANG_UNKNOWN_SPELL
@ LANG_UNKNOWN_SPELL
Definition Language.h:560
LANG_YOUR_ITEMS_REPAIRED
@ LANG_YOUR_ITEMS_REPAIRED
Definition Language.h:392
LANG_YOU_DISABLE_CHAT
@ LANG_YOU_DISABLE_CHAT
Definition Language.h:355
LANG_COMMAND_GRAVEYARDLINKED
@ LANG_COMMAND_GRAVEYARDLINKED
Definition Language.h:514
LANG_PINFO_CHR_MAP
@ LANG_PINFO_CHR_MAP
Definition Language.h:793
LANG_CHAR_NON_MOUNTED
@ LANG_CHAR_NON_MOUNTED
Definition Language.h:54
LANG_NO_CHAR_SELECTED
@ LANG_NO_CHAR_SELECTED
Definition Language.h:150
LANG_OBJECT_GUID
@ LANG_OBJECT_GUID
Definition Language.h:244
LANG_TRANSPORT_POSITION
@ LANG_TRANSPORT_POSITION
Definition Language.h:229
LANG_MOVEGENS_CHASE_CREATURE
@ LANG_MOVEGENS_CHASE_CREATURE
Definition Language.h:610
LANG_PINFO_ACC_IP
@ LANG_PINFO_ACC_IP
Definition Language.h:787
LANG_CONSOLE
@ LANG_CONSOLE
Definition Language.h:1104
LANG_COMMAND_ZONENOGRAVEYARDS
@ LANG_COMMAND_ZONENOGRAVEYARDS
Definition Language.h:523
LANG_INVALID_GAMEOBJECT_TYPE
@ LANG_INVALID_GAMEOBJECT_TYPE
Definition Language.h:218
LANG_SELECT_CHAR_OR_CREATURE
@ LANG_SELECT_CHAR_OR_CREATURE
Definition Language.h:31
LANG_COMMAND_NOGAMEOBJECTFOUND
@ LANG_COMMAND_NOGAMEOBJECTFOUND
Definition Language.h:511
LANG_MOVEGENS_RANDOM
@ LANG_MOVEGENS_RANDOM
Definition Language.h:605
LANG_REMOVEITEM_FAILURE
@ LANG_REMOVEITEM_FAILURE
Definition Language.h:691
LANG_PINFO_BANNED
@ LANG_PINFO_BANNED
Definition Language.h:781
LANG_PLAYER_NOT_FOUND
@ LANG_PLAYER_NOT_FOUND
Definition Language.h:570
LANG_COMMAND_MUTEHISTORY_OUTPUT
@ LANG_COMMAND_MUTEHISTORY_OUTPUT
Definition Language.h:1130
LANG_COMMAND_MUTEHISTORY_EMPTY
@ LANG_COMMAND_MUTEHISTORY_EMPTY
Definition Language.h:1129
LANG_SOUND_NOT_EXIST
@ LANG_SOUND_NOT_EXIST
Definition Language.h:212
LANG_SUMMONED_BY
@ LANG_SUMMONED_BY
Definition Language.h:143
LANG_MOVEGENS_WAYPOINT
@ LANG_MOVEGENS_WAYPOINT
Definition Language.h:606
LANG_MOVEGENS_POINT
@ LANG_MOVEGENS_POINT
Definition Language.h:678
LANG_PINFO_CHR_GUILD_RANK
@ LANG_PINFO_CHR_GUILD_RANK
Definition Language.h:795
LANG_CANNOT_GO_TO_INST_GM
@ LANG_CANNOT_GO_TO_INST_GM
Definition Language.h:139
LANG_PINFO_ACC_ACCOUNT
@ LANG_PINFO_ACC_ACCOUNT
Definition Language.h:783
LANG_EXPLORE_AREA
@ LANG_EXPLORE_AREA
Definition Language.h:644
LANG_COMMAND_GRAVEYARD_NOTEAM
@ LANG_COMMAND_GRAVEYARD_NOTEAM
Definition Language.h:518
LANG_ACCOUNT
@ LANG_ACCOUNT
Definition Language.h:832
LANG_PINFO_ACC_REGMAILS
@ LANG_PINFO_ACC_REGMAILS
Definition Language.h:786
LANG_BAD_VALUE
@ LANG_BAD_VALUE
Definition Language.h:149
LANG_ADDITEM
@ LANG_ADDITEM
Definition Language.h:565
LANG_COMMAND_MUTEHISTORY
@ LANG_COMMAND_MUTEHISTORY
Definition Language.h:1128
LANG_PVPSTATS_DISABLED
@ LANG_PVPSTATS_DISABLED
Definition Language.h:113
LANG_PINFO_GM_ACTIVE
@ LANG_PINFO_GM_ACTIVE
Definition Language.h:780
LANG_CANNOT_GO_TO_BG_GM
@ LANG_CANNOT_GO_TO_BG_GM
Definition Language.h:728
LANG_COMMAND_FREEZE
@ LANG_COMMAND_FREEZE
Definition Language.h:1064
LANG_PINFO_CHR_MAILS
@ LANG_PINFO_CHR_MAILS
Definition Language.h:799
LANG_COMMAND_PERMA_FROZEN_PLAYER
@ LANG_COMMAND_PERMA_FROZEN_PLAYER
Definition Language.h:1070
LANG_MOVEGENS_CHASE_NULL
@ LANG_MOVEGENS_CHASE_NULL
Definition Language.h:611
LANG_GPS_POSITION_OUTDOORS
@ LANG_GPS_POSITION_OUTDOORS
Definition Language.h:1107
LANG_MOVEGENS_FLIGHT
@ LANG_MOVEGENS_FLIGHT
Definition Language.h:614
LANG_ACCOUNT_NOT_EXIST
@ LANG_ACCOUNT_NOT_EXIST
Definition Language.h:473
LANG_COMMAND_KICKMESSAGE
@ LANG_COMMAND_KICKMESSAGE
Definition Language.h:333
LANG_PINFO_CHR_GUILD
@ LANG_PINFO_CHR_GUILD
Definition Language.h:794
LANG_CHAR_IN_FLIGHT
@ LANG_CHAR_IN_FLIGHT
Definition Language.h:53
LANG_COMMAND_GRAVEYARDERROR
@ LANG_COMMAND_GRAVEYARDERROR
Definition Language.h:517
LANG_COMMAND_FREEZE_WRONG
@ LANG_COMMAND_FREEZE_WRONG
Definition Language.h:1066
LANG_PINFO_CHR_GUILD_ONOTE
@ LANG_PINFO_CHR_GUILD_ONOTE
Definition Language.h:797
LANG_MAP_POSITION
@ LANG_MAP_POSITION
Definition Language.h:135
LANG_MOVEGENS_HOME_CREATURE
@ LANG_MOVEGENS_HOME_CREATURE
Definition Language.h:612
LANG_GRID_POSITION
@ LANG_GRID_POSITION
Definition Language.h:220
LANG_SET_SKILL
@ LANG_SET_SKILL
Definition Language.h:553
LANG_NO_SELECTION
@ LANG_NO_SELECTION
Definition Language.h:243
LANG_MOVEGENS_HOME_PLAYER
@ LANG_MOVEGENS_HOME_PLAYER
Definition Language.h:613
LANG_MOVEGENS_LIST
@ LANG_MOVEGENS_LIST
Definition Language.h:603
LANG_GPS_NO_VMAP
@ LANG_GPS_NO_VMAP
Definition Language.h:1109
LANG_DISTANCE
@ LANG_DISTANCE
Definition Language.h:575
LANG_COMMAND_GRAVEYARD_HORDE
@ LANG_COMMAND_GRAVEYARD_HORDE
Definition Language.h:521
LANG_COMMAND_GRAVEYARD_ANY
@ LANG_COMMAND_GRAVEYARD_ANY
Definition Language.h:519
LANG_MOVEGENS_FEAR
@ LANG_MOVEGENS_FEAR
Definition Language.h:679
LANG_REMOVEITEM
@ LANG_REMOVEITEM
Definition Language.h:567
LANG_PINFO_MUTED
@ LANG_PINFO_MUTED
Definition Language.h:782
LANG_REMOVEALL_COOLDOWN
@ LANG_REMOVEALL_COOLDOWN
Definition Language.h:562
LANG_COMMAND_ITEMIDINVALID
@ LANG_COMMAND_ITEMIDINVALID
Definition Language.h:498
LOGIN_SEL_PINFO
@ LOGIN_SEL_PINFO
Definition LoginDatabase.h:83
LOGIN_SEL_ACCOUNT_MUTE_INFO
@ LOGIN_SEL_ACCOUNT_MUTE_INFO
Definition LoginDatabase.h:106
LOGIN_UPD_MUTE_TIME
@ LOGIN_UPD_MUTE_TIME
Definition LoginDatabase.h:68
LOGIN_SEL_PINFO_BANS
@ LOGIN_SEL_PINFO_BANS
Definition LoginDatabase.h:84
LOGIN_INS_ACCOUNT_MUTE
@ LOGIN_INS_ACCOUNT_MUTE
Definition LoginDatabase.h:105
ZLiquidStatus
ZLiquidStatus
Definition MapDefines.h:133
DISTRACT_MOTION_TYPE
@ DISTRACT_MOTION_TYPE
Definition MovementDefines.h:45
IDLE_MOTION_TYPE
@ IDLE_MOTION_TYPE
Definition MovementDefines.h:35
CHASE_MOTION_TYPE
@ CHASE_MOTION_TYPE
Definition MovementDefines.h:40
WAYPOINT_MOTION_TYPE
@ WAYPOINT_MOTION_TYPE
Definition MovementDefines.h:37
FLEEING_MOTION_TYPE
@ FLEEING_MOTION_TYPE
Definition MovementDefines.h:44
CONFUSED_MOTION_TYPE
@ CONFUSED_MOTION_TYPE
Definition MovementDefines.h:39
HOME_MOTION_TYPE
@ HOME_MOTION_TYPE
Definition MovementDefines.h:41
POINT_MOTION_TYPE
@ POINT_MOTION_TYPE
Definition MovementDefines.h:43
FLIGHT_MOTION_TYPE
@ FLIGHT_MOTION_TYPE
Definition MovementDefines.h:42
FOLLOW_MOTION_TYPE
@ FOLLOW_MOTION_TYPE
Definition MovementDefines.h:49
RANDOM_MOTION_TYPE
@ RANDOM_MOTION_TYPE
Definition MovementDefines.h:36
EFFECT_MOTION_TYPE
@ EFFECT_MOTION_TYPE
Definition MovementDefines.h:51
TYPEID_UNIT
@ TYPEID_UNIT
Definition ObjectGuid.h:43
TYPEID_PLAYER
@ TYPEID_PLAYER
Definition ObjectGuid.h:44
GuidSet
std::set< ObjectGuid > GuidSet
Definition ObjectGuid.h:432
HighGuid
HighGuid
Definition ObjectGuid.h:109
normalizePlayerName
bool normalizePlayerName(std::string &name)
Definition ObjectMgr.cpp:157
ItemTemplateContainer
std::unordered_map< uint32, ItemTemplate > ItemTemplateContainer
Definition ObjectMgr.h:515
sObjectMgr
#define sObjectMgr
Definition ObjectMgr.h:1873
Optional
std::optional< T > Optional
Optional helper class to wrap optional values within.
Definition Optional.h:25
ItemPosCountVec
std::vector< ItemPosCount > ItemPosCountVec
Definition Player.h:827
TELE_TO_GM_MODE
@ TELE_TO_GM_MODE
Definition Player.h:909
TELE_TO_NONE
@ TELE_TO_NONE
Definition Player.h:908
INVENTORY_SLOT_BAG_0
constexpr uint8 INVENTORY_SLOT_BAG_0
Definition Player.h:706
PLAYER_FLAGS_GHOST
@ PLAYER_FLAGS_GHOST
Definition Player.h:516
PLAYER_EXPLORED_ZONES_BITS
@ PLAYER_EXPLORED_ZONES_BITS
Definition Player.h:161
sRealmList
#define sRealmList
Definition RealmList.h:95
SpellSchoolMask
SpellSchoolMask
Definition SharedDefines.h:340
SPELL_SCHOOL_MASK_NORMAL
@ SPELL_SCHOOL_MASK_NORMAL
Definition SharedDefines.h:342
BATTLEGROUND_QUEUE_NONE
constexpr BattlegroundQueueTypeId BATTLEGROUND_QUEUE_NONE
Definition SharedDefines.h:7205
GameError::ERR_CLIENT_LOCKED_OUT
@ ERR_CLIENT_LOCKED_OUT
BASE_ATTACK
@ BASE_ATTACK
Definition SharedDefines.h:7437
ALLIANCE
@ ALLIANCE
Definition SharedDefines.h:1309
HORDE
@ HORDE
Definition SharedDefines.h:1308
SILVER
@ SILVER
Definition SharedDefines.h:276
GOLD
@ GOLD
Definition SharedDefines.h:277
WeatherType
WeatherType
Definition SharedDefines.h:6461
SPAWN_TYPEMASK_ALL
@ SPAWN_TYPEMASK_ALL
Definition SpawnData.h:50
SPELL_AURA_MOUNTED
@ SPELL_AURA_MOUNTED
Definition SpellAuraDefines.h:165
sSpellMgr
#define sSpellMgr
Definition SpellMgr.h:812
StringEqualI
TC_COMMON_API bool StringEqualI(std::string_view str1, std::string_view str2)
Definition Util.cpp:849
HITINFO_AFFECTS_VICTIM
@ HITINFO_AFFECTS_VICTIM
Definition UnitDefines.h:387
DIRECT_DAMAGE
@ DIRECT_DAMAGE
Definition UnitDefines.h:155
SPELL_DIRECT_DAMAGE
@ SPELL_DIRECT_DAMAGE
Definition UnitDefines.h:156
VICTIMSTATE_HIT
@ VICTIMSTATE_HIT
Definition Unit.h:50
NULL_BAG
@ NULL_BAG
Definition Unit.h:63
NULL_SLOT
@ NULL_SLOT
Definition Unit.h:64
Utf8ToUpperOnlyLatin
bool Utf8ToUpperOnlyLatin(std::string &utf8String)
Definition Util.cpp:752
secsToTimeString
std::string secsToTimeString(uint64 timeInSecs, TimeFormat timeFormat, bool hoursOnly)
Definition Util.cpp:116
isNumeric
bool isNumeric(wchar_t wchar)
Definition Util.h:207
AccountMgr::GetId
static uint32 GetId(std::string_view username)
Definition AccountMgr.cpp:293
Aura::SetDuration
void SetDuration(int32 duration, bool withMods=false)
Definition SpellAuras.cpp:941
BaseEntity::GetGUID
ObjectGuid const & GetGUID() const
Definition BaseEntity.h:163
BaseEntity::GetTypeId
TypeID GetTypeId() const
Definition BaseEntity.h:166
ChatHandler::getSelectedPlayerOrSelf
Player * getSelectedPlayerOrSelf()
Definition Chat.cpp:248
ChatHandler::HasPermission
virtual bool HasPermission(uint32 permission) const
Definition Chat.cpp:51
ChatHandler::playerLink
std::string playerLink(std::string const &name) const
Definition Chat.cpp:603
ChatHandler::getSelectedUnit
Unit * getSelectedUnit()
Definition Chat.cpp:216
ChatHandler::getSelectedPlayer
Player * getSelectedPlayer()
Definition Chat.cpp:204
ChatHandler::GetSession
WorldSession * GetSession()
Definition Chat.h:42
ChatHandler::GetSessionDbcLocale
virtual LocaleConstant GetSessionDbcLocale() const
Definition Chat.cpp:593
ChatHandler::GetNameLink
virtual std::string GetNameLink() const
Definition Chat.cpp:56
ChatHandler::GetCreatureFromPlayerMapByDbGuid
Creature * GetCreatureFromPlayerMapByDbGuid(ObjectGuid::LowType lowguid)
Definition Chat.cpp:401
ChatHandler::HasLowerSecurity
bool HasLowerSecurity(Player *target, ObjectGuid guid, bool strong=false)
Definition Chat.cpp:61
ChatHandler::getSelectedCreature
Creature * getSelectedCreature()
Definition Chat.cpp:240
ChatHandler::GetObjectFromPlayerMapByDbGuid
GameObject * GetObjectFromPlayerMapByDbGuid(ObjectGuid::LowType lowguid)
Definition Chat.cpp:391
ChatHandler::SetSentErrorMessage
void SetSentErrorMessage(bool val)
Definition Chat.h:127
ChatHandler::GetPlayer
Player * GetPlayer() const
Definition Chat.cpp:37
ChatHandler::PSendSysMessage
void PSendSysMessage(char const *fmt, Args &&... args)
Definition Chat.h:62
ChatHandler::SendSysMessage
virtual void SendSysMessage(std::string_view str, bool escapeCharacters=false)
Definition Chat.cpp:111
ChatHandler::needReportToTarget
virtual bool needReportToTarget(Player *chr) const
Definition Chat.cpp:587
ChatHandler::extractPlayerTarget
bool extractPlayerTarget(char *args, Player **player, ObjectGuid *player_guid=nullptr, std::string *player_name=nullptr)
Definition Chat.cpp:490
ChatHandler::extractLowGuidFromLink
ObjectGuid::LowType extractLowGuidFromLink(char *text, HighGuid &guidHigh)
Definition Chat.cpp:432
ChatHandler::GetTrinityString
virtual char const * GetTrinityString(uint32 entry) const
Definition Chat.cpp:46
Creature::Respawn
void Respawn(bool force=false)
Definition Creature.cpp:2325
DB2Manager::GetChrClassName
static char const * GetChrClassName(uint8 class_, LocaleConstant locale=DEFAULT_LOCALE)
Definition DB2Stores.cpp:2118
DB2Manager::GetChrRaceName
static char const * GetChrRaceName(uint8 race, LocaleConstant locale=DEFAULT_LOCALE)
Definition DB2Stores.cpp:2165
DamageInfo::GetResist
uint32 GetResist() const
Definition Unit.h:469
DamageInfo::GetDamage
uint32 GetDamage() const
Definition Unit.h:466
DamageInfo::GetAbsorb
uint32 GetAbsorb() const
Definition Unit.h:468
EnumFlag::AsUnderlyingType
constexpr std::underlying_type_t< T > AsUnderlyingType() const
Definition EnumFlag.h:122
Field
Class used to access individual fields of database query result.
Definition Field.h:94
Field::GetUInt64
uint64 GetUInt64() const noexcept
Definition Field.cpp:71
Field::GetUInt32
uint32 GetUInt32() const noexcept
Definition Field.cpp:57
Field::GetUInt16
uint16 GetUInt16() const noexcept
Definition Field.cpp:43
Field::GetUInt8
uint8 GetUInt8() const noexcept
Definition Field.cpp:29
Field::GetInt32
int32 GetInt32() const noexcept
Definition Field.cpp:64
Field::GetString
std::string GetString() const noexcept
Definition Field.cpp:113
GameObject::GetGOValue
GameObjectValue const * GetGOValue() const
Definition GameObject.h:213
GameObject::ModifyHealth
void ModifyHealth(int32 change, WorldObject *attackerOrHealer=nullptr, uint32 spellId=0)
Definition GameObject.cpp:3760
GameObject::IsDestructibleBuilding
bool IsDestructibleBuilding() const
Definition GameObject.cpp:2175
Group
Definition Group.h:209
Item
Definition Item.h:185
Item::SetBinding
void SetBinding(bool val)
Definition Item.h:216
MMAP::MMapManager::instance
static MMapManager * instance()
Definition MMapManager.cpp:90
MMAP::MMapManager::GetNavMesh
dtNavMesh * GetNavMesh(uint32 mapId, uint32 instanceId)
Definition MMapManager.cpp:448
Map
Definition Map.h:227
Map::IsDungeon
bool IsDungeon() const
Definition Map.cpp:3303
Map::GetLiquidStatus
ZLiquidStatus GetLiquidStatus(PhaseShift const &phaseShift, float x, float y, float z, Optional< map_liquidHeaderTypeFlags > ReqLiquidType={}, LiquidData *data=nullptr, float collisionHeight=2.03128f)
Definition Map.cpp:1704
Map::IsBattlegroundOrArena
bool IsBattlegroundOrArena() const
Definition Map.cpp:3405
Map::GetOrGenerateZoneDefaultWeather
Weather * GetOrGenerateZoneDefaultWeather(uint32 zoneId)
Definition Map.cpp:4029
Map::IsRaid
bool IsRaid() const
Definition Map.cpp:3313
Map::GetMinHeight
float GetMinHeight(PhaseShift const &phaseShift, float x, float y)
Definition Map.cpp:1725
Map::GetId
uint32 GetId() const
Definition Map.cpp:3288
Map::GetRespawnInfo
RespawnInfo * GetRespawnInfo(SpawnObjectType type, ObjectGuid::LowType spawnId) const
Definition Map.cpp:2152
Map::GetInstanceId
uint32 GetInstanceId() const
Definition Map.h:353
Map::Respawn
void Respawn(RespawnInfo *info, CharacterDatabaseTransaction dbTrans=nullptr)
Definition Map.cpp:2070
MotionMaster::GetMovementGeneratorsInformation
std::vector< MovementGeneratorInformation > GetMovementGeneratorsInformation() const
Definition MotionMaster.cpp:136
MotionMaster::GetDestination
bool GetDestination(float &x, float &y, float &z)
Definition MotionMaster.cpp:502
MotionMaster::MovePoint
void MovePoint(uint32 id, Position const &pos, bool generatePath=true, Optional< float > finalOrient={}, Optional< float > speed={}, MovementWalkRunSpeedSelectionMode speedSelectionMode=MovementWalkRunSpeedSelectionMode::Default, Optional< float > closeEnoughDistance={}, Optional< MovementFadeObject > fadeObject={}, Scripting::v2::ActionResultSetter< MovementStopReason > &&scriptResult={})
Definition MotionMaster.cpp:639
MotionMaster::Empty
bool Empty() const
Definition MotionMaster.cpp:126
ObjectGuid::GetCounter
LowType GetCounter() const
Definition ObjectGuid.h:336
ObjectGuid::Empty
static ObjectGuid const Empty
Definition ObjectGuid.h:314
ObjectGuid::IsEmpty
bool IsEmpty() const
Definition ObjectGuid.h:362
ObjectGuid::ToString
std::string ToString() const
Definition ObjectGuid.cpp:866
ObjectGuid::LowType
uint64 LowType
Definition ObjectGuid.h:321
Object::ToPlayer
Player * ToPlayer()
Definition Object.h:126
PhasingHandler::PrintToChat
static void PrintToChat(ChatHandler *chat, WorldObject const *target)
Definition PhasingHandler.cpp:625
PhasingHandler::InheritPhaseShift
static void InheritPhaseShift(WorldObject *target, WorldObject const *source)
Definition PhasingHandler.cpp:264
Player::StopCastingBindSight
void StopCastingBindSight() const
Definition Player.cpp:26867
Player::IsValidPos
bool IsValidPos(uint16 pos, bool explicit_pos) const
Definition Player.h:1481
Player::SendEquipError
void SendEquipError(InventoryResult msg, Item const *item1=nullptr, Item const *item2=nullptr, uint32 itemId=0) const
Definition Player.cpp:13048
Player::StoreNewItem
Item * StoreNewItem(ItemPosCountVec const &pos, uint32 itemId, bool update, ItemRandomBonusListId randomBonusListId=0, GuidSet const &allowedLooters=GuidSet(), ItemContext context=ItemContext::NONE, std::vector< int32 > const *bonusListIDs=nullptr, bool addToCollection=true)
Definition Player.cpp:11288
Player::GetSaveTimer
uint32 GetSaveTimer() const
Definition Player.h:2664
Player::GetBattlegroundTypeId
BattlegroundTypeId GetBattlegroundTypeId() const
Definition Player.h:2573
Player::LeaveBattleground
void LeaveBattleground(bool teleportToEntryPoint=true, bool withoutDeserterDebuff=false)
Definition Player.cpp:24282
Player::GetTotalPlayedTime
uint32 GetTotalPlayedTime() const
Definition Player.h:1331
Player::SetBattlegroundId
void SetBattlegroundId(uint32 val, BattlegroundTypeId bgTypeId, BattlegroundQueueTypeId queueId)
Definition Player.cpp:25704
Player::GetNativeGender
Gender GetNativeGender() const override
Definition Player.h:1334
Player::GetSkillValue
uint16 GetSkillValue(uint32 skill) const
Definition Player.cpp:5920
Player::OfflineResurrect
static void OfflineResurrect(ObjectGuid const &guid, CharacterDatabaseTransaction trans)
Definition Player.cpp:4387
Player::SetBattlegroundEntryPoint
void SetBattlegroundEntryPoint()
Definition Player.cpp:24228
Player::SetDeveloper
void SetDeveloper(bool on)
Definition Player.h:1290
Player::SpawnCorpseBones
void SpawnCorpseBones(bool triggerSave=true)
Definition Player.cpp:4453
Player::SetRaidDifficultyID
void SetRaidDifficultyID(Difficulty raid_difficulty)
Definition Player.h:2170
Player::DurabilityRepairAll
void DurabilityRepairAll(bool takeCost, float discountMod, bool guildBank)
Definition Player.cpp:4573
Player::SavePositionInDB
static void SavePositionInDB(WorldLocation const &loc, uint16 zoneId, ObjectGuid guid, CharacterDatabaseTransaction trans)
Definition Player.cpp:21773
Player::SetSkill
void SetSkill(uint32 id, uint16 step, uint16 newVal, uint16 maxVal)
Definition Player.cpp:5654
Player::m_homebind
WorldLocation m_homebind
Definition Player.h:2679
Player::SwapItem
void SwapItem(uint16 src, uint16 dst)
Definition Player.cpp:12567
Player::GetSession
WorldSession * GetSession() const
Definition Player.h:2256
Player::GetItemByPos
Item * GetItemByPos(uint16 pos) const
Definition Player.cpp:9538
Player::SaveRecallPosition
void SaveRecallPosition()
Definition Player.h:2667
Player::RepopAtGraveyard
void RepopAtGraveyard()
Definition Player.cpp:4687
Player::SendNewItem
void SendNewItem(Item *item, uint32 quantity, bool pushed, bool created, bool broadcast=false, uint32 dungeonEncounterId=0)
Definition Player.cpp:13835
Player::GetDungeonDifficultyID
Difficulty GetDungeonDifficultyID() const
Definition Player.h:2166
Player::SetLegacyRaidDifficultyID
void SetLegacyRaidDifficultyID(Difficulty raid_difficulty)
Definition Player.h:2171
Player::GetPureMaxSkillValue
uint16 GetPureMaxSkillValue(uint32 skill) const
Definition Player.cpp:5950
Player::DestroyItemCount
uint32 DestroyItemCount(uint32 item, uint32 count, bool update, bool unequip_check=false)
Definition Player.cpp:12140
Player::AddExploredZones
void AddExploredZones(uint32 pos, uint64 mask)
Definition Player.cpp:6289
Player::TeleportTo
bool TeleportTo(uint32 mapid, float x, float y, float z, float orientation, TeleportToOptions options=TELE_TO_NONE, Optional< uint32 > instanceId={}, uint32 teleportSpellId=0)
Definition Player.cpp:1181
Player::FinishTaxiFlight
void FinishTaxiFlight()
Definition Player.cpp:23302
Player::Recall
void Recall()
Definition Player.h:2672
Player::GetSkillStep
uint16 GetSkillStep(uint32 skill) const
Definition Player.cpp:5908
Player::IsGameMaster
bool IsGameMaster() const
Definition Player.h:1293
Player::LoadPositionFromDB
static bool LoadPositionFromDB(uint32 &mapid, float &x, float &y, float &z, float &o, bool &in_flight, ObjectGuid guid)
Definition Player.cpp:17872
Player::SetDungeonDifficultyID
void SetDungeonDifficultyID(Difficulty dungeon_difficulty)
Definition Player.h:2169
Player::RemoveExploredZones
void RemoveExploredZones(uint32 pos, uint64 mask)
Definition Player.cpp:6298
Player::GetRaidDifficultyID
Difficulty GetRaidDifficultyID() const
Definition Player.h:2167
Player::SaveToDB
void SaveToDB(bool create=false)
Definition Player.cpp:20386
Player::GetBattlegroundId
uint32 GetBattlegroundId() const
Definition Player.h:2572
Player::GetMoney
uint64 GetMoney() const
Definition Player.h:1890
Player::IsDeveloper
bool IsDeveloper() const
Definition Player.h:1289
Player::GetGroup
Group * GetGroup(Optional< uint8 > partyIndex)
Definition Player.h:2781
Player::UpdateObjectVisibility
void UpdateObjectVisibility(bool forced=true) override
Definition Player.cpp:24772
Player::GetLegacyRaidDifficultyID
Difficulty GetLegacyRaidDifficultyID() const
Definition Player.h:2168
Player::CanStoreNewItem
InventoryResult CanStoreNewItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 item, uint32 count, uint32 *no_space_count=nullptr) const
Definition Player.cpp:9970
Player::IsBeingTeleported
bool IsBeingTeleported() const
Definition Player.h:2385
Player::ResurrectPlayer
void ResurrectPlayer(float restore_percent, bool applySickness=false)
Definition Player.cpp:4269
PreparedStatementBase::setString
void setString(uint8 index, std::string &&value)
Definition PreparedStatement.cpp:103
PreparedStatementBase::setUInt32
void setUInt32(uint8 index, uint32 value)
Definition PreparedStatement.cpp:49
PreparedStatementBase::setInt64
void setInt64(uint8 index, int64 value)
Definition PreparedStatement.cpp:79
PreparedStatementBase::setUInt64
void setUInt64(uint8 index, uint64 value)
Definition PreparedStatement.cpp:55
PreparedStatementBase::setInt32
void setInt32(uint8 index, int32 value)
Definition PreparedStatement.cpp:73
SpellHistory::ResetAllCharges
void ResetAllCharges()
Definition SpellHistory.cpp:945
SpellHistory::ResetCooldown
void ResetCooldown(uint32 spellId, bool update=false)
Definition SpellHistory.cpp:647
SpellHistory::ResetAllCooldowns
void ResetAllCooldowns()
Definition SpellHistory.cpp:673
SpellHistory::ResetCharges
void ResetCharges(uint32 chargeCategoryId)
Definition SpellHistory.cpp:928
TerrainInfo::ExistVMap
static bool ExistVMap(uint32 mapid, int32 gx, int32 gy)
Definition TerrainMgr.cpp:109
TerrainInfo::ExistMap
static bool ExistMap(uint32 mapid, int32 gx, int32 gy, bool log=true)
Definition TerrainMgr.cpp:76
Unit
Definition Unit.h:647
Unit::DealDamage
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)
Definition Unit.cpp:825
Unit::RemoveAurasByType
void RemoveAurasByType(AuraType auraType, std::function< bool(AuraApplication const *)> const &check, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3973
Unit::CombatStop
void CombatStop(bool includingCast=false, bool mutualPvP=true, bool(*unitFilter)(Unit const *otherUnit)=nullptr)
Definition Unit.cpp:6031
Unit::GetClass
uint8 GetClass() const
Definition Unit.h:776
Unit::DealDamageMods
static void DealDamageMods(Unit const *attacker, Unit const *victim, uint32 &damage, uint32 *absorb)
Definition Unit.cpp:804
Unit::SendAttackStateUpdate
void SendAttackStateUpdate(CalcDamageInfo *damageInfo)
Definition Unit.cpp:5668
Unit::DealSpellDamage
void DealSpellDamage(SpellNonMeleeDamage const *damageInfo, bool durabilityLoss)
Definition Unit.cpp:1308
Unit::CalcAbsorbResist
static void CalcAbsorbResist(DamageInfo &damageInfo, Spell *spell=nullptr)
Definition Unit.cpp:1866
Unit::GetMotionMaster
MotionMaster * GetMotionMaster()
Definition Unit.h:1750
Unit::IsPet
bool IsPet() const
Definition Unit.h:763
Unit::CalcArmorReducedDamage
static uint32 CalcArmorReducedDamage(Unit const *attacker, Unit *victim, uint32 damage, SpellInfo const *spellInfo, WeaponAttackType attackType=MAX_ATTACK, uint8 attackerLevel=0)
Definition Unit.cpp:1689
Unit::Dismount
void Dismount()
Definition Unit.cpp:8336
Unit::AddAura
Aura * AddAura(uint32 spellId, Unit *target)
Definition Unit.cpp:12344
Unit::IsAlive
bool IsAlive() const
Definition Unit.h:1205
Unit::GetCombatReach
float GetCombatReach() const override
Definition Unit.h:717
Unit::SendSpellNonMeleeDamageLog
void SendSpellNonMeleeDamageLog(SpellNonMeleeDamage const *log)
Definition Unit.cpp:5559
Unit::IsInFlight
bool IsInFlight() const
Definition Unit.h:1042
Unit::isPossessing
bool isPossessing() const
Definition Unit.cpp:6669
Unit::GetHealth
uint64 GetHealth() const
Definition Unit.h:800
Unit::IsMounted
bool IsMounted() const
Definition Unit.h:927
Unit::RemoveAllAuras
void RemoveAllAuras()
Definition Unit.cpp:4400
Unit::GetSpellHistory
SpellHistory * GetSpellHistory()
Definition Unit.h:1521
Unit::IsDamageReducedByArmor
static bool IsDamageReducedByArmor(SpellSchoolMask damageSchoolMask, SpellInfo const *spellInfo=nullptr)
Definition Unit.cpp:1680
Unit::RemoveAurasDueToSpell
void RemoveAurasDueToSpell(uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint32 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)
Definition Unit.cpp:3992
Unit::Kill
static void Kill(Unit *attacker, Unit *victim, bool durabilityLoss=true, bool skipSettingDeathState=false)
Definition Unit.cpp:11311
Unit::GetTarget
ObjectGuid GetTarget() const
Definition Unit.h:1847
Unit::GetLevel
uint8 GetLevel() const
Definition Unit.h:769
Unit::GetRace
uint8 GetRace() const
Definition Unit.h:773
Unit::RemoveCharmAuras
void RemoveCharmAuras()
Definition Unit.cpp:6755
Unit::IsInCombat
bool IsInCombat() const
Definition Unit.h:1073
Unit::isDead
bool isDead() const
Definition Unit.h:1207
Weather
Weather for one zone.
Definition Weather.h:67
WorldLocation::GetMapId
constexpr uint32 GetMapId() const
Definition Position.h:216
WorldObject::GetMap
Map * GetMap() const
Definition Object.h:411
WorldObject::GetGridActivationRange
float GetGridActivationRange() const
Definition Object.cpp:769
WorldObject::GetClosePoint
void GetClosePoint(float &x, float &y, float &z, float size, float distance2d=0, float relAngle=0) const
Definition Object.cpp:2754
WorldObject::CastSpell
SpellCastResult CastSpell(CastSpellTargetArg const &targets, uint32 spellId, CastSpellExtraArgs const &args={ })
Definition Object.cpp:2222
WorldObject::GetPhaseShift
PhaseShift & GetPhaseShift()
Definition Object.h:310
WorldObject::GetTransport
TransportBase * GetTransport() const
Definition Object.h:537
WorldObject::GetInstanceId
uint32 GetInstanceId() const
Definition Object.h:308
WorldObject::IsOutdoors
bool IsOutdoors() const
Definition Object.h:336
WorldObject::GetDistance2d
float GetDistance2d(WorldObject const *obj) const
Definition Object.cpp:448
WorldObject::GetName
std::string const & GetName() const
Definition Object.h:342
WorldObject::GetCharmerOrOwnerPlayerOrPlayerItself
Player * GetCharmerOrOwnerPlayerOrPlayerItself() const
Definition Object.cpp:1626
WorldObject::GetDistance
float GetDistance(WorldObject const *obj) const
Definition Object.cpp:430
WorldObject::GetAreaId
uint32 GetAreaId() const
Definition Object.h:333
WorldObject::GetZoneId
uint32 GetZoneId() const
Definition Object.h:332
WorldPackets::Misc::PlaySound::Write
WorldPacket const * Write() override
Definition MiscPackets.cpp:519
WorldSession
Player session in the World.
Definition WorldSession.h:981
WorldSession::SendNotification
void SendNotification(char const *format,...) ATTR_PRINTF(2
Definition WorldSession.cpp:752
WorldSession::GetSecurity
AccountTypes GetSecurity() const
Definition WorldSession.h:1017
WorldSession::GetPlayer
Player * GetPlayer() const
Definition WorldSession.h:1024
WorldSession::SendShowBank
void SendShowBank(ObjectGuid guid, PlayerInteractionType interactionType)
Definition BankHandler.cpp:300
WorldSession::CanSpeak
bool CanSpeak() const
Definition WorldSession.cpp:783
WorldSession::HasPermission
bool HasPermission(uint32 permissionId)
Definition WorldSession.cpp:1483
WorldSession::GetAccountId
uint32 GetAccountId() const
Definition WorldSession.h:1018
WorldSession::SendShowMailBox
void SendShowMailBox(ObjectGuid guid)
Definition NPCHandler.cpp:88
WorldSession::GetLatency
uint32 GetLatency() const
Definition WorldSession.h:1206
WorldSession::GetPlayerName
std::string const & GetPlayerName() const
Definition WorldSession.cpp:206
WorldSession::KickPlayer
void KickPlayer(std::string_view reason)
Kick a player out of the World.
Definition WorldSession.cpp:710
misc_commandscript
Definition cs_misc.cpp:59
misc_commandscript::HandleDevCommand
static bool HandleDevCommand(ChatHandler *handler, Optional< bool > enableArg)
Definition cs_misc.cpp:151
misc_commandscript::HandleGetDistanceCommand
static bool HandleGetDistanceCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:755
misc_commandscript::HandleAddItemSetCommand
static bool HandleAddItemSetCommand(ChatHandler *handler, Variant< Hyperlink< itemset >, uint32 > itemSetId, Optional< std::string_view > bonuses, Optional< uint8 > context)
Definition cs_misc.cpp:1313
misc_commandscript::HandleMuteHistoryHelper
static bool HandleMuteHistoryHelper(uint32 accountId, char const *accountName, ChatHandler *handler)
Definition cs_misc.cpp:2023
misc_commandscript::HandleDamageCommand
static bool HandleDamageCommand(ChatHandler *handler, uint32 damage, Optional< SpellSchools > school, Optional< SpellInfo const * > spellInfo)
Definition cs_misc.cpp:2154
misc_commandscript::HandleAddItemCommandHelper
static bool HandleAddItemCommandHelper(ChatHandler *handler, Player *player, Player *playerTarget, Variant< Hyperlink< item >, uint32, std::string_view > const &itemArg, Optional< int32 > countArg, Optional< std::string_view > const &bonusListIdString, Optional< uint8 > itemContextArg)
Definition cs_misc.cpp:1151
misc_commandscript::HandleSaveCommand
static bool HandleSaveCommand(ChatHandler *handler)
Definition cs_misc.cpp:841
misc_commandscript::HandleAuraCommand
static bool HandleAuraCommand(ChatHandler *handler, SpellInfo const *spell)
Definition cs_misc.cpp:298
misc_commandscript::HandleUnbindSightCommand
static bool HandleUnbindSightCommand(ChatHandler *handler)
Definition cs_misc.cpp:2524
misc_commandscript::HandleCooldownCommand
static bool HandleCooldownCommand(ChatHandler *handler, Optional< SpellInfo const * > spellArg)
Definition cs_misc.cpp:714
misc_commandscript::HandleSummonCommand
static bool HandleSummonCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:473
misc_commandscript::HandleMuteCommand
static bool HandleMuteCommand(ChatHandler *handler, Optional< PlayerIdentifier > player, uint32 muteTime, Tail muteReason)
Definition cs_misc.cpp:1879
misc_commandscript::HandleBankCommand
static bool HandleBankCommand(ChatHandler *handler)
Definition cs_misc.cpp:1389
misc_commandscript::HandleListFreezeCommand
static bool HandleListFreezeCommand(ChatHandler *handler)
Definition cs_misc.cpp:2442
misc_commandscript::HandleReviveCommand
static bool HandleReviveCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:625
misc_commandscript::HandleUnAuraCommand
static bool HandleUnAuraCommand(ChatHandler *handler, Variant< SpellInfo const *, EXACT_SEQUENCE("all")> spellArg)
Definition cs_misc.cpp:315
misc_commandscript::HandleShowAreaCommand
static bool HandleShowAreaCommand(ChatHandler *handler, uint32 areaId)
Definition cs_misc.cpp:1085
misc_commandscript::HandleCommandsCommand
static bool HandleCommandsCommand(ChatHandler *handler)
Definition cs_misc.cpp:593
misc_commandscript::HandleMailBoxCommand
static bool HandleMailBoxCommand(ChatHandler *handler)
Definition cs_misc.cpp:2535
misc_commandscript::HandleDieCommand
static bool HandleDieCommand(ChatHandler *handler)
Definition cs_misc.cpp:599
misc_commandscript::HandlePInfoCommand
static bool HandlePInfoCommand(ChatHandler *handler, Optional< PlayerIdentifier > arg)
Definition cs_misc.cpp:1473
misc_commandscript::HandleKickPlayerCommand
static bool HandleKickPlayerCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:873
misc_commandscript::HandleChangeWeather
static bool HandleChangeWeather(ChatHandler *handler, WeatherType type, float intensity)
Definition cs_misc.cpp:1395
misc_commandscript::HandleAddItemToCommand
static bool HandleAddItemToCommand(ChatHandler *handler, PlayerIdentifier const &target, Variant< Hyperlink<::item >, uint32, std::string_view > const &item, Optional< int32 > countArg, Optional< std::string_view > const &bonusListIdString, Optional< uint8 > itemContextArg)
Definition cs_misc.cpp:1298
misc_commandscript::HandleHelpCommand
static bool HandleHelpCommand(ChatHandler *handler, Tail cmd)
Definition cs_misc.cpp:686
misc_commandscript::HandleRespawnCommand
static bool HandleRespawnCommand(ChatHandler *handler)
Definition cs_misc.cpp:1839
misc_commandscript::GetCommands
std::span< ChatCommandBuilder const > GetCommands() const override
Definition cs_misc.cpp:63
misc_commandscript::HandleMovegensCommand
static bool HandleMovegensCommand(ChatHandler *handler)
Definition cs_misc.cpp:2054
misc_commandscript::HandleGUIDCommand
static bool HandleGUIDCommand(ChatHandler *handler)
Definition cs_misc.cpp:671
misc_commandscript::HandlePlayAllCommand
static bool HandlePlayAllCommand(ChatHandler *handler, uint32 soundId, Optional< int32 > broadcastTextId)
Definition cs_misc.cpp:2478
misc_commandscript::HandleGPSCommand
static bool HandleGPSCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:175
misc_commandscript::HandleSaveAllCommand
static bool HandleSaveAllCommand(ChatHandler *handler)
Definition cs_misc.cpp:865
misc_commandscript::HandleUnFreezeCommand
static bool HandleUnFreezeCommand(ChatHandler *handler, Optional< std::string > targetNameArg)
Definition cs_misc.cpp:2385
misc_commandscript::HandleDamageGoCommand
static bool HandleDamageGoCommand(ChatHandler *handler, Variant< Hyperlink< gameobject >, ObjectGuid::LowType > spawnId, int32 damage)
Definition cs_misc.cpp:2216
misc_commandscript::HandleBindSightCommand
static bool HandleBindSightCommand(ChatHandler *handler)
Definition cs_misc.cpp:2514
misc_commandscript::HandleComeToMeCommand
static bool HandleComeToMeCommand(ChatHandler *handler)
Definition cs_misc.cpp:2137
misc_commandscript::HandleUnPossessCommand
static bool HandleUnPossessCommand(ChatHandler *handler)
Definition cs_misc.cpp:2503
misc_commandscript::HandleNearGraveCommand
static bool HandleNearGraveCommand(ChatHandler *handler, Optional< std::string > teamArg)
Definition cs_misc.cpp:1027
misc_commandscript::HandleUnmuteCommand
static bool HandleUnmuteCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:1954
misc_commandscript::HandleDismountCommand
static bool HandleDismountCommand(ChatHandler *handler)
Definition cs_misc.cpp:647
misc_commandscript::HandleRecallCommand
static bool HandleRecallCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:818
misc_commandscript::HandleCombatStopCommand
static bool HandleCombatStopCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:2238
misc_commandscript::HandleHideAreaCommand
static bool HandleHideAreaCommand(ChatHandler *handler, uint32 areaId)
Definition cs_misc.cpp:1118
misc_commandscript::HandlePvPstatsCommand
static bool HandlePvPstatsCommand(ChatHandler *handler)
Definition cs_misc.cpp:122
misc_commandscript::misc_commandscript
misc_commandscript()
Definition cs_misc.cpp:61
misc_commandscript::HandleMuteHistoryCommand
static bool HandleMuteHistoryCommand(ChatHandler *handler, std::string accountName)
Definition cs_misc.cpp:2003
misc_commandscript::HandleLinkGraveCommand
static bool HandleLinkGraveCommand(ChatHandler *handler, uint32 graveyardId, Optional< std::string > teamArg)
Definition cs_misc.cpp:985
misc_commandscript::HandleRepairitemsCommand
static bool HandleRepairitemsCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:2267
misc_commandscript::HandleFreezeCommand
static bool HandleFreezeCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:2287
misc_commandscript::HandleSetSkillCommand
static bool HandleSetSkillCommand(ChatHandler *handler, Variant< Hyperlink< skill >, uint32 > skillId, uint32 level, Optional< uint32 > maxSkillArg)
Definition cs_misc.cpp:1421
misc_commandscript::HandleItemMoveCommand
static bool HandleItemMoveCommand(ChatHandler *handler, uint8 srcSlot, uint8 dstSlot)
Definition cs_misc.cpp:695
misc_commandscript::HandlePossessCommand
static bool HandlePossessCommand(ChatHandler *handler)
Definition cs_misc.cpp:2493
misc_commandscript::HandleAddItemCommand
static bool HandleAddItemCommand(ChatHandler *handler, Variant< Hyperlink<::item >, uint32, std::string_view > const &item, Optional< int32 > countArg, Optional< std::string_view > const &bonusListIdString, Optional< uint8 > itemContextArg)
Definition cs_misc.cpp:1288
misc_commandscript::HandleUnstuckCommand
static bool HandleUnstuckCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:909
misc_commandscript::HandleAppearCommand
static bool HandleAppearCommand(ChatHandler *handler, char const *args)
Definition cs_misc.cpp:341
SPELL_UNSTUCK_ID
#define SPELL_UNSTUCK_ID
AddSC_misc_commandscript
void AddSC_misc_commandscript()
Definition cs_misc.cpp:2544
sWorld
#define sWorld
Definition World.h:919
Weather::SetWeather
void SetWeather(WeatherType type, float intensity)
Set the weather.
Definition Weather.cpp:275
CONFIG_MAX_PLAYER_LEVEL
@ CONFIG_MAX_PLAYER_LEVEL
Definition World.h:263
CONFIG_GM_FREEZE_DURATION
@ CONFIG_GM_FREEZE_DURATION
Definition World.h:288
CONFIG_INTERVAL_SAVE
@ CONFIG_INTERVAL_SAVE
Definition World.h:239
CONFIG_SHOW_KICK_IN_WORLD
@ CONFIG_SHOW_KICK_IN_WORLD
Definition World.h:152
CONFIG_WEATHER
@ CONFIG_WEATHER
Definition World.h:125
CONFIG_SHOW_MUTE_IN_WORLD
@ CONFIG_SHOW_MUTE_IN_WORLD
Definition World.h:153
CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE
@ CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE
Definition World.h:140
CONFIG_DIE_COMMAND_MODE
@ CONFIG_DIE_COMMAND_MODE
Definition World.h:135
DisableMgr::IsPathfindingEnabled
bool IsPathfindingEnabled(uint32 mapId)
Definition DisableMgr.cpp:422
GameTime::GetGameTime
time_t GetGameTime()
Definition GameTime.cpp:52
ItemBonusMgr::GetBonusListsForItem
std::vector< int32 > GetBonusListsForItem(uint32 itemId, ItemBonusGenerationParams const &params)
Definition ItemBonusMgr.cpp:415
ObjectAccessor::FindPlayerByName
TC_GAME_API Player * FindPlayerByName(std::string_view name)
Definition ObjectAccessor.cpp:261
ObjectAccessor::SaveAllPlayers
TC_GAME_API void SaveAllPlayers()
Definition ObjectAccessor.cpp:291
ObjectAccessor::GetPlayer
TC_GAME_API Player * GetPlayer(Map const *, ObjectGuid const &guid)
Definition ObjectAccessor.cpp:230
ObjectAccessor::FindConnectedPlayer
TC_GAME_API Player * FindConnectedPlayer(ObjectGuid const &)
Definition ObjectAccessor.cpp:276
Trinity::ChatCommands::ChatCommandTable
ChatCommandBuilder const [] ChatCommandTable
Definition ChatCommand.h:49
Trinity::ChatCommands::SendCommandHelpFor
TC_GAME_API void SendCommandHelpFor(ChatHandler &handler, std::string_view cmd)
Definition ChatCommand.cpp:508
Trinity::Tokenize
TC_COMMON_API std::vector< std::string_view > Tokenize(std::string_view str, char sep, bool keepEmpty)
Definition Util.cpp:57
Trinity::ComputeCellCoord
constexpr CellCoord ComputeCellCoord(float x, float y)
Definition GridDefines.h:186
Trinity::ComputeGridCoord
constexpr GridCoord ComputeGridCoord(float x, float y)
Definition GridDefines.h:174
rbac::RBAC_PERM_COMMAND_COMMANDS
@ RBAC_PERM_COMMAND_COMMANDS
Definition RBAC.h:370
rbac::RBAC_PERM_COMMAND_DISMOUNT
@ RBAC_PERM_COMMAND_DISMOUNT
Definition RBAC.h:375
rbac::RBAC_PERM_COMMAND_POSSESS
@ RBAC_PERM_COMMAND_POSSESS
Definition RBAC.h:393
rbac::RBAC_PERM_COMMAND_NEARGRAVE
@ RBAC_PERM_COMMAND_NEARGRAVE
Definition RBAC.h:390
rbac::RBAC_PERM_COMMAND_PLAYALL
@ RBAC_PERM_COMMAND_PLAYALL
Definition RBAC.h:392
rbac::RBAC_PERM_COMMAND_UNFREEZE
@ RBAC_PERM_COMMAND_UNFREEZE
Definition RBAC.h:405
rbac::RBAC_PERM_COMMAND_MUTE
@ RBAC_PERM_COMMAND_MUTE
Definition RBAC.h:389
rbac::RBAC_PERM_COMMAND_HIDEAREA
@ RBAC_PERM_COMMAND_HIDEAREA
Definition RBAC.h:382
rbac::RBAC_PERM_COMMAND_SHOWAREA
@ RBAC_PERM_COMMAND_SHOWAREA
Definition RBAC.h:401
rbac::RBAC_PERM_COMMAND_REPAIRITEMS
@ RBAC_PERM_COMMAND_REPAIRITEMS
Definition RBAC.h:395
rbac::RBAC_PERM_COMMAND_BINDSIGHT
@ RBAC_PERM_COMMAND_BINDSIGHT
Definition RBAC.h:367
rbac::RBAC_PERM_COMMAND_ADDITEM
@ RBAC_PERM_COMMAND_ADDITEM
Definition RBAC.h:362
rbac::RBAC_PERM_COMMAND_DEV
@ RBAC_PERM_COMMAND_DEV
Definition RBAC.h:373
rbac::RBAC_PERM_COMMAND_RESPAWN
@ RBAC_PERM_COMMAND_RESPAWN
Definition RBAC.h:396
rbac::RBAC_PERM_COMMAND_PVPSTATS
@ RBAC_PERM_COMMAND_PVPSTATS
Definition RBAC.h:671
rbac::RBAC_PERM_COMMAND_UNMUTE
@ RBAC_PERM_COMMAND_UNMUTE
Definition RBAC.h:406
rbac::RBAC_PERM_COMMAND_HELP
@ RBAC_PERM_COMMAND_HELP
Definition RBAC.h:381
rbac::RBAC_PERM_COMMAND_COOLDOWN
@ RBAC_PERM_COMMAND_COOLDOWN
Definition RBAC.h:371
rbac::RBAC_PERM_COMMAND_COMETOME
@ RBAC_PERM_COMMAND_COMETOME
Definition RBAC.h:369
rbac::RBAC_PERM_COMMAND_COMBATSTOP
@ RBAC_PERM_COMMAND_COMBATSTOP
Definition RBAC.h:368
rbac::RBAC_PERM_COMMAND_SETSKILL
@ RBAC_PERM_COMMAND_SETSKILL
Definition RBAC.h:400
rbac::RBAC_PERM_COMMAND_ADDITEMSET
@ RBAC_PERM_COMMAND_ADDITEMSET
Definition RBAC.h:363
rbac::RBAC_PERM_COMMAND_AURA
@ RBAC_PERM_COMMAND_AURA
Definition RBAC.h:365
rbac::RBAC_PERM_COMMANDS_SAVE_WITHOUT_DELAY
@ RBAC_PERM_COMMANDS_SAVE_WITHOUT_DELAY
Definition RBAC.h:83
rbac::RBAC_PERM_COMMAND_MOVEGENS
@ RBAC_PERM_COMMAND_MOVEGENS
Definition RBAC.h:388
rbac::RBAC_PERM_COMMAND_UNSTUCK
@ RBAC_PERM_COMMAND_UNSTUCK
Definition RBAC.h:408
rbac::RBAC_PERM_COMMAND_REVIVE
@ RBAC_PERM_COMMAND_REVIVE
Definition RBAC.h:397
rbac::RBAC_PERM_COMMAND_APPEAR
@ RBAC_PERM_COMMAND_APPEAR
Definition RBAC.h:364
rbac::RBAC_PERM_COMMAND_FREEZE
@ RBAC_PERM_COMMAND_FREEZE
Definition RBAC.h:378
rbac::RBAC_PERM_COMMAND_BANK
@ RBAC_PERM_COMMAND_BANK
Definition RBAC.h:366
rbac::RBAC_PERM_COMMAND_GPS
@ RBAC_PERM_COMMAND_GPS
Definition RBAC.h:379
rbac::RBAC_PERM_COMMAND_UNPOSSESS
@ RBAC_PERM_COMMAND_UNPOSSESS
Definition RBAC.h:407
rbac::RBAC_PERM_COMMAND_SUMMON
@ RBAC_PERM_COMMAND_SUMMON
Definition RBAC.h:402
rbac::RBAC_PERM_COMMAND_RECALL
@ RBAC_PERM_COMMAND_RECALL
Definition RBAC.h:394
rbac::RBAC_PERM_COMMAND_DIE
@ RBAC_PERM_COMMAND_DIE
Definition RBAC.h:374
rbac::RBAC_PERM_COMMAND_ITEMMOVE
@ RBAC_PERM_COMMAND_ITEMMOVE
Definition RBAC.h:383
rbac::RBAC_PERM_COMMAND_MAILBOX
@ RBAC_PERM_COMMAND_MAILBOX
Definition RBAC.h:651
rbac::RBAC_PERM_COMMAND_SAVE
@ RBAC_PERM_COMMAND_SAVE
Definition RBAC.h:399
rbac::RBAC_PERM_COMMAND_LISTFREEZE
@ RBAC_PERM_COMMAND_LISTFREEZE
Definition RBAC.h:386
rbac::RBAC_PERM_COMMAND_UNBINDSIGHT
@ RBAC_PERM_COMMAND_UNBINDSIGHT
Definition RBAC.h:404
rbac::RBAC_PERM_COMMANDS_USE_UNSTUCK_WITH_ARGS
@ RBAC_PERM_COMMANDS_USE_UNSTUCK_WITH_ARGS
Definition RBAC.h:84
rbac::RBAC_PERM_COMMAND_DAMAGE
@ RBAC_PERM_COMMAND_DAMAGE
Definition RBAC.h:372
rbac::RBAC_PERM_RESURRECT_WITH_FULL_HPS
@ RBAC_PERM_RESURRECT_WITH_FULL_HPS
Definition RBAC.h:91
rbac::RBAC_PERM_COMMAND_UNAURA
@ RBAC_PERM_COMMAND_UNAURA
Definition RBAC.h:403
rbac::RBAC_PERM_COMMAND_KICK
@ RBAC_PERM_COMMAND_KICK
Definition RBAC.h:384
rbac::RBAC_PERM_COMMAND_WCHANGE
@ RBAC_PERM_COMMAND_WCHANGE
Definition RBAC.h:409
rbac::RBAC_PERM_COMMAND_LINKGRAVE
@ RBAC_PERM_COMMAND_LINKGRAVE
Definition RBAC.h:385
rbac::RBAC_PERM_COMMAND_SAVEALL
@ RBAC_PERM_COMMAND_SAVEALL
Definition RBAC.h:398
rbac::RBAC_PERM_COMMANDS_PINFO_CHECK_PERSONAL_DATA
@ RBAC_PERM_COMMANDS_PINFO_CHECK_PERSONAL_DATA
Definition RBAC.h:101
rbac::RBAC_PERM_COMMAND_PINFO
@ RBAC_PERM_COMMAND_PINFO
Definition RBAC.h:391
rbac::RBAC_PERM_COMMAND_MUTEHISTORY
@ RBAC_PERM_COMMAND_MUTEHISTORY
Definition RBAC.h:506
rbac::RBAC_PERM_COMMAND_GUID
@ RBAC_PERM_COMMAND_GUID
Definition RBAC.h:380
rbac::RBAC_PERM_COMMAND_DISTANCE
@ RBAC_PERM_COMMAND_DISTANCE
Definition RBAC.h:376
AreaTableEntry::GetFlags
EnumFlag< AreaFlags > GetFlags() const
Definition DB2Structure.h:153
AreaTableEntry::AreaName
LocalizedString AreaName
Definition DB2Structure.h:129
Cell
Definition Cell.h:38
Cell::GridX
uint32 GridX() const
Definition Cell.h:63
Cell::GridY
uint32 GridY() const
Definition Cell.h:64
Cell::CellX
uint32 CellX() const
Definition Cell.h:61
Cell::CellY
uint32 CellY() const
Definition Cell.h:62
Cell::VisitGridObjects
static void VisitGridObjects(WorldObject const *obj, T &visitor, float radius)
Definition CellImpl.h:140
CoordPair::x_coord
uint32 x_coord
Definition GridDefines.h:150
CoordPair::GetId
constexpr uint32 GetId() const
Definition GridDefines.h:143
CoordPair::y_coord
uint32 y_coord
Definition GridDefines.h:151
ItemSparseEntry::Display
LocalizedString Display
Definition DB2Structure.h:2599
LiquidData::entry
uint32 entry
Definition MapDefines.h:148
LiquidData::type_flags
EnumFlag< map_liquidHeaderTypeFlags > type_flags
Definition MapDefines.h:147
LiquidData::depth_level
float depth_level
Definition MapDefines.h:150
LiquidData::level
float level
Definition MapDefines.h:149
MapEntry::MapName
LocalizedString MapName
Definition DB2Structure.h:2902
Position::GetPositionX
constexpr float GetPositionX() const
Definition Position.h:87
Position::GetPositionY
constexpr float GetPositionY() const
Definition Position.h:88
Position::GetExactDist2d
float GetExactDist2d(const float x, const float y) const
Definition Position.h:117
Position::GetExactDist
float GetExactDist(float x, float y, float z) const
Definition Position.h:129
Position::GetAbsoluteAngle
float GetAbsoluteAngle(float x, float y) const
Definition Position.h:136
Position::GetOrientation
constexpr float GetOrientation() const
Definition Position.h:90
Position::GetPositionZ
constexpr float GetPositionZ() const
Definition Position.h:89
SkillLineEntry::DisplayName
LocalizedString DisplayName
Definition DB2Structure.h:3678
Trinity::ChatCommands::PlayerIdentifier::FromTarget
static Optional< PlayerIdentifier > FromTarget(ChatHandler *handler)
Definition ChatCommandTags.cpp:165
Trinity::ChatCommands::PlayerIdentifier::FromTargetOrSelf
static Optional< PlayerIdentifier > FromTargetOrSelf(ChatHandler *handler)
Definition ChatCommandTags.h:179
GameObjectValue::Building
struct GameObjectValue::@197 Building