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