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

Public Member Functions

 gobject_commandscript ()
 
ChatCommandTable GetCommands () const override
 
virtual std::vector< Acore::ChatCommands::ChatCommandBuilderGetCommands () const =0
 
- Public Member Functions inherited from ScriptObject
virtual bool IsDatabaseBound () const
 
virtual bool isAfterLoadScript () const
 
virtual void checkValidity ()
 
const std::string & GetName () const
 

Static Public Member Functions

static bool HandleGameObjectActivateCommand (ChatHandler *handler, GameObjectSpawnId guidLow)
 
static bool HandleGameObjectAddCommand (ChatHandler *handler, GameObjectEntry objectId, Optional< int32 > spawnTimeSecs)
 
static bool HandleGameObjectAddTempCommand (ChatHandler *handler, GameObjectEntry objectId, Optional< uint64 > spawntime)
 
static bool HandleGameObjectTargetCommand (ChatHandler *handler, Optional< Variant< GameObjectEntry, std::string_view > > objectId)
 
static bool HandleGameObjectDeleteCommand (ChatHandler *handler, GameObjectSpawnId spawnId)
 
static bool HandleGameObjectTurnCommand (ChatHandler *handler, GameObjectSpawnId guidLow, Optional< float > oz, Optional< float > oy, Optional< float > ox)
 
static bool HandleGameObjectMoveCommand (ChatHandler *handler, GameObjectSpawnId guidLow, Optional< std::array< float, 3 > > xyz)
 
static bool HandleGameObjectSetPhaseCommand (ChatHandler *handler, GameObjectSpawnId guidLow, uint32 phaseMask)
 
static bool HandleGameObjectNearCommand (ChatHandler *handler, Optional< float > dist)
 
static bool HandleGameObjectInfoCommand (ChatHandler *handler, Optional< EXACT_SEQUENCE("guid")> isGuid, Variant< Hyperlink< gameobject_entry >, Hyperlink< gameobject >, uint32 > data)
 
static bool HandleGameObjectSetStateCommand (ChatHandler *handler, GameObjectSpawnId guidLow, int32 objectType, Optional< uint32 > objectState)
 

Additional Inherited Members

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

Detailed Description

Constructor & Destructor Documentation

◆ gobject_commandscript()

gobject_commandscript::gobject_commandscript ( )
inline
46: CommandScript("gobject_commandscript") { }
Definition: ScriptMgr.h:850

Member Function Documentation

◆ GetCommands()

ChatCommandTable gobject_commandscript::GetCommands ( ) const
inlineoverridevirtual

Implements CommandScript.

49 {
50 static ChatCommandTable gobjectCommandTable =
51 {
52 { "activate", HandleGameObjectActivateCommand, SEC_GAMEMASTER, Console::No },
53 { "delete", HandleGameObjectDeleteCommand, SEC_ADMINISTRATOR, Console::No },
54 { "info", HandleGameObjectInfoCommand, SEC_MODERATOR, Console::No },
55 { "move", HandleGameObjectMoveCommand, SEC_ADMINISTRATOR, Console::No },
56 { "near", HandleGameObjectNearCommand, SEC_MODERATOR, Console::No },
57 { "target", HandleGameObjectTargetCommand, SEC_MODERATOR, Console::No },
58 { "turn", HandleGameObjectTurnCommand, SEC_ADMINISTRATOR, Console::No },
59 { "add temp", HandleGameObjectAddTempCommand, SEC_GAMEMASTER, Console::No },
60 { "add", HandleGameObjectAddCommand, SEC_ADMINISTRATOR, Console::No },
61 { "set phase", HandleGameObjectSetPhaseCommand, SEC_ADMINISTRATOR, Console::No },
62 { "set state", HandleGameObjectSetStateCommand, SEC_ADMINISTRATOR, Console::No }
63 };
64 static ChatCommandTable commandTable =
65 {
66 { "gobject", gobjectCommandTable }
67 };
68 return commandTable;
69 }
@ SEC_ADMINISTRATOR
Definition: Common.h:69
@ SEC_GAMEMASTER
Definition: Common.h:68
@ SEC_MODERATOR
Definition: Common.h:67
std::vector< ChatCommandBuilder > ChatCommandTable
Definition: ChatCommand.h:50
static bool HandleGameObjectDeleteCommand(ChatHandler *handler, GameObjectSpawnId spawnId)
Definition: cs_gobject.cpp:297
static bool HandleGameObjectTargetCommand(ChatHandler *handler, Optional< Variant< GameObjectEntry, std::string_view > > objectId)
Definition: cs_gobject.cpp:183
static bool HandleGameObjectNearCommand(ChatHandler *handler, Optional< float > dist)
Definition: cs_gobject.cpp:452
static bool HandleGameObjectInfoCommand(ChatHandler *handler, Optional< EXACT_SEQUENCE("guid")> isGuid, Variant< Hyperlink< gameobject_entry >, Hyperlink< gameobject >, uint32 > data)
Definition: cs_gobject.cpp:499
static bool HandleGameObjectAddCommand(ChatHandler *handler, GameObjectEntry objectId, Optional< int32 > spawnTimeSecs)
Definition: cs_gobject.cpp:93
static bool HandleGameObjectActivateCommand(ChatHandler *handler, GameObjectSpawnId guidLow)
Definition: cs_gobject.cpp:71
static bool HandleGameObjectAddTempCommand(ChatHandler *handler, GameObjectEntry objectId, Optional< uint64 > spawntime)
Definition: cs_gobject.cpp:158
static bool HandleGameObjectMoveCommand(ChatHandler *handler, GameObjectSpawnId guidLow, Optional< std::array< float, 3 > > xyz)
Definition: cs_gobject.cpp:370
static bool HandleGameObjectTurnCommand(ChatHandler *handler, GameObjectSpawnId guidLow, Optional< float > oz, Optional< float > oy, Optional< float > ox)
Definition: cs_gobject.cpp:331
static bool HandleGameObjectSetStateCommand(ChatHandler *handler, GameObjectSpawnId guidLow, int32 objectType, Optional< uint32 > objectState)
Definition: cs_gobject.cpp:562
static bool HandleGameObjectSetPhaseCommand(ChatHandler *handler, GameObjectSpawnId guidLow, uint32 phaseMask)
Definition: cs_gobject.cpp:427

References HandleGameObjectActivateCommand(), HandleGameObjectAddCommand(), HandleGameObjectAddTempCommand(), HandleGameObjectDeleteCommand(), HandleGameObjectInfoCommand(), HandleGameObjectMoveCommand(), HandleGameObjectNearCommand(), HandleGameObjectSetPhaseCommand(), HandleGameObjectSetStateCommand(), HandleGameObjectTargetCommand(), HandleGameObjectTurnCommand(), SEC_ADMINISTRATOR, SEC_GAMEMASTER, and SEC_MODERATOR.

◆ HandleGameObjectActivateCommand()

static bool gobject_commandscript::HandleGameObjectActivateCommand ( ChatHandler handler,
GameObjectSpawnId  guidLow 
)
inlinestatic
72 {
73 GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
74 if (!object)
75 {
77 handler->SetSentErrorMessage(true);
78 return false;
79 }
80
81 uint32_t const autoCloseTime = object->GetGOInfo()->GetAutoCloseTime() ? 10000u : 0u;
82
83 // Activate
84 object->SetLootState(GO_READY);
85 object->UseDoorOrButton(autoCloseTime, false, handler->GetSession()->GetPlayer());
86
87 handler->PSendSysMessage("Object activated!");
88
89 return true;
90 }
std::uint32_t uint32
Definition: Define.h:108
@ GO_READY
Definition: GameObject.h:113
@ LANG_COMMAND_OBJNOTFOUND
Definition: Language.h:318
WorldSession * GetSession()
Definition: Chat.h:122
GameObject * GetObjectFromPlayerMapByDbGuid(ObjectGuid::LowType lowguid)
Definition: Chat.cpp:507
void SetSentErrorMessage(bool val)
Definition: Chat.h:118
void PSendSysMessage(char const *fmt, Args &&... args)
Definition: Chat.h:60
Definition: GameObject.h:122
Player * GetPlayer() const
Definition: WorldSession.h:361

References ChatHandler::GetObjectFromPlayerMapByDbGuid(), WorldSession::GetPlayer(), ChatHandler::GetSession(), GO_READY, LANG_COMMAND_OBJNOTFOUND, ChatHandler::PSendSysMessage(), and ChatHandler::SetSentErrorMessage().

Referenced by GetCommands().

◆ HandleGameObjectAddCommand()

static bool gobject_commandscript::HandleGameObjectAddCommand ( ChatHandler handler,
GameObjectEntry  objectId,
Optional< int32 spawnTimeSecs 
)
inlinestatic
Todo:
is it really necessary to add both the real and DB table guid here ?
94 {
95 if (!objectId)
96 return false;
97
98 GameObjectTemplate const* objectInfo = sObjectMgr->GetGameObjectTemplate(objectId);
99 if (!objectInfo)
100 {
102 handler->SetSentErrorMessage(true);
103 return false;
104 }
105
106 if (objectInfo->displayId && !sGameObjectDisplayInfoStore.LookupEntry(objectInfo->displayId))
107 {
108 // report to DB errors log as in loading case
109 LOG_ERROR("sql.sql", "Gameobject (Entry {} GoType: {}) have invalid displayId ({}), not spawned.", *objectId, objectInfo->type, objectInfo->displayId);
111 handler->SetSentErrorMessage(true);
112 return false;
113 }
114
115 Player* player = handler->GetSession()->GetPlayer();
116 float x = float(player->GetPositionX());
117 float y = float(player->GetPositionY());
118 float z = float(player->GetPositionZ());
119 float o = float(player->GetOrientation());
120 Map* map = player->GetMap();
121
122 GameObject* object = sObjectMgr->IsGameObjectStaticTransport(objectInfo->entry) ? new StaticTransport() : new GameObject();
123 ObjectGuid::LowType guidLow = map->GenerateLowGuid<HighGuid::GameObject>();
124
125 if (!object->Create(guidLow, objectInfo->entry, map, player->GetPhaseMaskForSpawn(), x, y, z, o, G3D::Quat(), 0, GO_STATE_READY))
126 {
127 delete object;
128 return false;
129 }
130
131 if (spawnTimeSecs)
132 object->SetRespawnTime(*spawnTimeSecs);
133
134 // fill the gameobject data and save to the db
135 object->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), player->GetPhaseMaskForSpawn());
136 guidLow = object->GetSpawnId();
137
138 // delete the old object and do a clean load from DB with a fresh new GameObject instance.
139 // this is required to avoid weird behavior and memory leaks
140 delete object;
141
142 object = sObjectMgr->IsGameObjectStaticTransport(objectInfo->entry) ? new StaticTransport() : new GameObject();
143 // this will generate a new guid if the object is in an instance
144 if (!object->LoadGameObjectFromDB(guidLow, map, true))
145 {
146 delete object;
147 return false;
148 }
149
151 sObjectMgr->AddGameobjectToGrid(guidLow, sObjectMgr->GetGameObjectData(guidLow));
152
153 handler->PSendSysMessage(LANG_GAMEOBJECT_ADD, uint32(objectId), objectInfo->name.c_str(), guidLow, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
154 return true;
155 }
#define LOG_ERROR(filterType__,...)
Definition: Log.h:159
DBCStorage< GameObjectDisplayInfoEntry > sGameObjectDisplayInfoStore(GameObjectDisplayInfofmt)
@ GO_STATE_READY
Definition: GameObjectData.h:691
#define sObjectMgr
Definition: ObjectMgr.h:1640
@ LANG_GAMEOBJECT_HAVE_INVALID_DATA
Definition: Language.h:389
@ LANG_GAMEOBJECT_NOT_EXIST
Definition: Language.h:549
@ LANG_GAMEOBJECT_ADD
Definition: Language.h:553
virtual bool Create(ObjectGuid::LowType guidlow, uint32 name_id, Map *map, uint32 phaseMask, float x, float y, float z, float ang, G3D::Quat const &rotation, uint32 animprogress, GOState go_state, uint32 artKit=0)
Definition: GameObject.cpp:248
void SetRespawnTime(int32 respawn)
Definition: GameObject.cpp:1301
bool LoadGameObjectFromDB(ObjectGuid::LowType guid, Map *map, bool addToMap=true)
Definition: GameObject.cpp:1120
Definition: GameObjectData.h:32
uint32 type
Definition: GameObjectData.h:34
uint32 entry
Definition: GameObjectData.h:33
std::string name
Definition: GameObjectData.h:36
uint32 displayId
Definition: GameObjectData.h:35
Map * GetMap() const
Definition: Object.h:517
uint32 LowType
Definition: ObjectGuid.h:124
float GetPositionZ() const
Definition: Position.h:119
float GetOrientation() const
Definition: Position.h:120
float GetPositionX() const
Definition: Position.h:117
float GetPositionY() const
Definition: Position.h:118
Definition: Player.h:1046
uint32 GetPhaseMaskForSpawn() const
Definition: Player.cpp:13652
Definition: Transport.h:112
Definition: Map.h:312
uint8 GetSpawnMode() const
Definition: Map.h:419
ObjectGuid::LowType GenerateLowGuid()
Definition: Map.h:632
uint32 GetId() const
Definition: Map.h:378

References GameObject::Create(), GameObjectTemplate::displayId, GameObjectTemplate::entry, Map::GenerateLowGuid(), Map::GetId(), WorldObject::GetMap(), Position::GetOrientation(), Player::GetPhaseMaskForSpawn(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), Map::GetSpawnMode(), GO_STATE_READY, LANG_GAMEOBJECT_ADD, LANG_GAMEOBJECT_HAVE_INVALID_DATA, LANG_GAMEOBJECT_NOT_EXIST, GameObject::LoadGameObjectFromDB(), LOG_ERROR, GameObjectTemplate::name, ChatHandler::PSendSysMessage(), GameObject::SetRespawnTime(), ChatHandler::SetSentErrorMessage(), sGameObjectDisplayInfoStore, sObjectMgr, and GameObjectTemplate::type.

Referenced by GetCommands().

◆ HandleGameObjectAddTempCommand()

static bool gobject_commandscript::HandleGameObjectAddTempCommand ( ChatHandler handler,
GameObjectEntry  objectId,
Optional< uint64 spawntime 
)
inlinestatic
159 {
160 Player* player = handler->GetSession()->GetPlayer();
161 uint64 spawntm(spawntime.value_or(300));
162
163 if (!sObjectMgr->GetGameObjectTemplate(objectId))
164 {
166 handler->SetSentErrorMessage(true);
167 return false;
168 }
169
170 float x = player->GetPositionX();
171 float y = player->GetPositionY();
172 float z = player->GetPositionZ();
173 float ang = player->GetOrientation();
174
175 float rot2 = std::sin(ang / 2);
176 float rot3 = cos(ang / 2);
177
178 player->SummonGameObject(objectId, x, y, z, ang, 0, 0, rot2, rot3, spawntm);
179
180 return true;
181 }
std::uint64_t uint64
Definition: Define.h:107
GameObject * SummonGameObject(uint32 entry, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime, bool checkTransport=true, GOSummonType summonType=GO_SUMMON_TIMED_OR_CORPSE_DESPAWN)
Definition: Object.cpp:2332

References Position::GetOrientation(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), LANG_GAMEOBJECT_NOT_EXIST, ChatHandler::PSendSysMessage(), ChatHandler::SetSentErrorMessage(), sObjectMgr, and WorldObject::SummonGameObject().

Referenced by GetCommands().

◆ HandleGameObjectDeleteCommand()

static bool gobject_commandscript::HandleGameObjectDeleteCommand ( ChatHandler handler,
GameObjectSpawnId  spawnId 
)
inlinestatic
298 {
299 GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(spawnId);
300 if (!object)
301 {
303 handler->SetSentErrorMessage(true);
304 return false;
305 }
306
307 ObjectGuid ownerGuid = object->GetOwnerGUID();
308 if (ownerGuid)
309 {
310 Unit* owner = ObjectAccessor::GetUnit(*handler->GetSession()->GetPlayer(), ownerGuid);
311 if (!owner || !ownerGuid.IsPlayer())
312 {
314 handler->SetSentErrorMessage(true);
315 return false;
316 }
317
318 owner->RemoveGameObject(object, false);
319 }
320
321 object->SetRespawnTime(0); // not save respawn time
322 object->Delete();
323 object->DeleteFromDB();
324
326
327 return true;
328 }
@ LANG_COMMAND_DELOBJMESSAGE
Definition: Language.h:320
@ LANG_COMMAND_DELOBJREFERCREATURE
Definition: Language.h:319
Unit * GetUnit(WorldObject const &, ObjectGuid const guid)
Definition: ObjectAccessor.cpp:204
ObjectGuid::LowType GetSpawnId() const
Definition: GameObject.h:146
Definition: ObjectGuid.h:120
LowType GetCounter() const
Definition: ObjectGuid.h:147
bool IsPlayer() const
Definition: ObjectGuid.h:170
Definition: Unit.h:1290
void RemoveGameObject(GameObject *gameObj, bool del)
Definition: Unit.cpp:6109

References ObjectGuid::GetCounter(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), WorldSession::GetPlayer(), ChatHandler::GetSession(), GameObject::GetSpawnId(), ObjectAccessor::GetUnit(), ObjectGuid::IsPlayer(), LANG_COMMAND_DELOBJMESSAGE, LANG_COMMAND_DELOBJREFERCREATURE, LANG_COMMAND_OBJNOTFOUND, ChatHandler::PSendSysMessage(), Unit::RemoveGameObject(), and ChatHandler::SetSentErrorMessage().

Referenced by GetCommands().

◆ HandleGameObjectInfoCommand()

static bool gobject_commandscript::HandleGameObjectInfoCommand ( ChatHandler handler,
Optional< EXACT_SEQUENCE("guid")>  isGuid,
Variant< Hyperlink< gameobject_entry >, Hyperlink< gameobject >, uint32 data 
)
inlinestatic
500 {
501 uint32 entry = 0;
502 uint32 type = 0;
503 uint32 displayId = 0;
504 std::string name;
505 uint32 lootId = 0;
506 GameObject* gameObject = nullptr;
507
508 ObjectGuid::LowType spawnId = 0;
509 if (isGuid || data.holds_alternative<Hyperlink<gameobject>>())
510 {
511 spawnId = *data;
512 GameObjectData const* spawnData = sObjectMgr->GetGameObjectData(spawnId);
513 if (!spawnData)
514 {
515 handler->PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, spawnId);
516 handler->SetSentErrorMessage(true);
517 return false;
518 }
519 entry = spawnData->id;
520 gameObject = handler->GetObjectFromPlayerMapByDbGuid(spawnId);
521 }
522 else
523 {
524 entry = *data;
525 }
526
527 GameObjectTemplate const* gameObjectInfo = sObjectMgr->GetGameObjectTemplate(entry);
528 if (!gameObjectInfo)
529 {
531 handler->SetSentErrorMessage(true);
532 return false;
533 }
534
535 type = gameObjectInfo->type;
536 displayId = gameObjectInfo->displayId;
537 name = gameObjectInfo->name;
538 if (type == GAMEOBJECT_TYPE_CHEST)
539 lootId = gameObjectInfo->chest.lootId;
540 else if (type == GAMEOBJECT_TYPE_FISHINGHOLE)
541 lootId = gameObjectInfo->fishinghole.lootId;
542
543 handler->PSendSysMessage(LANG_GOINFO_ENTRY, entry);
544 handler->PSendSysMessage(LANG_GOINFO_TYPE, type);
545 handler->PSendSysMessage(LANG_GOINFO_LOOTID, lootId);
546 handler->PSendSysMessage(LANG_GOINFO_DISPLAYID, displayId);
547 if (gameObject)
548 {
549 handler->PSendSysMessage("LootMode: %u", gameObject->GetLootMode());
550 handler->PSendSysMessage("LootState: %u", gameObject->getLootState());
551 handler->PSendSysMessage("GOState: %u", gameObject->GetGoState());
552 handler->PSendSysMessage("PhaseMask: %u", gameObject->GetPhaseMask());
553 handler->PSendSysMessage("IsLootEmpty: %u", gameObject->loot.empty());
554 handler->PSendSysMessage("IsLootLooted: %u", gameObject->loot.isLooted());
555 }
556
557 handler->PSendSysMessage(LANG_GOINFO_NAME, name.c_str());
558
559 return true;
560 }
@ LANG_GOINFO_NAME
Definition: Language.h:1081
@ LANG_GOINFO_DISPLAYID
Definition: Language.h:1080
@ LANG_GOINFO_ENTRY
Definition: Language.h:1078
@ LANG_GOINFO_LOOTID
Definition: Language.h:1082
@ LANG_GOINFO_TYPE
Definition: Language.h:1079
@ GAMEOBJECT_TYPE_CHEST
Definition: SharedDefines.h:1535
@ GAMEOBJECT_TYPE_FISHINGHOLE
Definition: SharedDefines.h:1557
Definition: ChatCommandTags.h:205
constexpr bool holds_alternative() const
Definition: ChatCommandTags.h:303
Loot loot
Definition: GameObject.h:249
GOState GetGoState() const
Definition: GameObject.h:207
LootState getLootState() const
Definition: GameObject.h:226
uint16 GetLootMode() const
Definition: GameObject.h:230
struct GameObjectTemplate::@215::@220 chest
uint32 lootId
Definition: GameObjectData.h:85
struct GameObjectTemplate::@215::@236 fishinghole
Definition: GameObjectData.h:697
uint32 id
Definition: GameObjectData.h:699
uint32 GetPhaseMask() const
Definition: Object.h:434
bool empty() const
Definition: LootMgr.h:367
bool isLooted() const
Definition: LootMgr.h:368

References GameObjectTemplate::chest, GameObjectTemplate::displayId, Loot::empty(), GameObjectTemplate::fishinghole, GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_FISHINGHOLE, GameObject::GetGoState(), GameObject::GetLootMode(), GameObject::getLootState(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), WorldObject::GetPhaseMask(), GameObjectData::id, Loot::isLooted(), LANG_COMMAND_OBJNOTFOUND, LANG_GAMEOBJECT_NOT_EXIST, LANG_GOINFO_DISPLAYID, LANG_GOINFO_ENTRY, LANG_GOINFO_LOOTID, LANG_GOINFO_NAME, LANG_GOINFO_TYPE, GameObject::loot, GameObjectTemplate::lootId, GameObjectTemplate::name, ChatHandler::PSendSysMessage(), ChatHandler::SetSentErrorMessage(), sObjectMgr, and GameObjectTemplate::type.

Referenced by GetCommands().

◆ HandleGameObjectMoveCommand()

static bool gobject_commandscript::HandleGameObjectMoveCommand ( ChatHandler handler,
GameObjectSpawnId  guidLow,
Optional< std::array< float, 3 > >  xyz 
)
inlinestatic
371 {
372 if (!guidLow)
373 return false;
374
375 GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
376 if (!object)
377 {
379 handler->SetSentErrorMessage(true);
380 return false;
381 }
382
383 Position pos;
384 if (xyz)
385 {
386 pos = { (*xyz)[0], (*xyz)[1], (*xyz)[2] };
387 if (!MapMgr::IsValidMapCoord(object->GetMapId(), pos))
388 {
390 handler->SetSentErrorMessage(true);
391 return false;
392 }
393 }
394 else
395 {
396 pos = handler->GetSession()->GetPlayer()->GetPosition();
397 }
398
399 Map* map = object->GetMap();
400
401 pos.SetOrientation(object->GetOrientation());
402 object->Relocate(pos);
403
404 // update which cell has this gameobject registered for loading
405 sObjectMgr->RemoveGameobjectFromGrid(guidLow, object->GetGameObjectData());
406 object->SaveToDB();
407 sObjectMgr->AddGameobjectToGrid(guidLow, object->GetGameObjectData());
408
409 // Generate a completely new spawn with new guid
410 // 3.3.5a client caches recently deleted objects and brings them back to life
411 // when CreateObject block for this guid is received again
412 // however it entirely skips parsing that block and only uses already known location
413 object->Delete();
414
415 object = new GameObject();
416 if (!object->LoadGameObjectFromDB(guidLow, map, true))
417 {
418 delete object;
419 return false;
420 }
421
422 handler->PSendSysMessage(LANG_COMMAND_MOVEOBJMESSAGE, object->GetSpawnId(), object->GetGOInfo()->name.c_str(), object->GetSpawnId());
423 return true;
424 }
@ LANG_COMMAND_MOVEOBJMESSAGE
Definition: Language.h:322
@ LANG_INVALID_TARGET_COORD
Definition: Language.h:308
GameObjectTemplate const * GetGOInfo() const
Definition: GameObject.h:138
GameObjectData const * GetGameObjectData() const
Definition: GameObject.h:140
Definition: Position.h:28
void SetOrientation(float orientation)
Definition: Position.h:112
void GetPosition(float &x, float &y) const
Definition: Position.h:122
uint32 GetMapId() const
Definition: Position.h:276
static bool IsValidMapCoord(uint32 mapid, Position const &pos)
Definition: MapMgr.h:91

References GameObject::GetGameObjectData(), GameObject::GetGOInfo(), WorldLocation::GetMapId(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), Position::GetOrientation(), WorldSession::GetPlayer(), Position::GetPosition(), Position::GetPositionX(), Position::GetPositionY(), ChatHandler::GetSession(), GameObject::GetSpawnId(), MapMgr::IsValidMapCoord(), LANG_COMMAND_MOVEOBJMESSAGE, LANG_COMMAND_OBJNOTFOUND, LANG_INVALID_TARGET_COORD, GameObject::LoadGameObjectFromDB(), GameObjectTemplate::name, ChatHandler::PSendSysMessage(), Position::SetOrientation(), ChatHandler::SetSentErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

◆ HandleGameObjectNearCommand()

static bool gobject_commandscript::HandleGameObjectNearCommand ( ChatHandler handler,
Optional< float >  dist 
)
inlinestatic
453 {
454 float distance = dist.value_or(10.0f);
455 uint32 count = 0;
456
457 Player* player = handler->GetSession()->GetPlayer();
458
460 stmt->SetData(0, player->GetPositionX());
461 stmt->SetData(1, player->GetPositionY());
462 stmt->SetData(2, player->GetPositionZ());
463 stmt->SetData(3, player->GetMapId());
464 stmt->SetData(4, player->GetPositionX());
465 stmt->SetData(5, player->GetPositionY());
466 stmt->SetData(6, player->GetPositionZ());
467 stmt->SetData(7, distance * distance);
468 stmt->SetData(8, player->GetPhaseMask());
469 PreparedQueryResult result = WorldDatabase.Query(stmt);
470
471 if (result)
472 {
473 do
474 {
475 Field* fields = result->Fetch();
476 ObjectGuid::LowType guid = fields[0].Get<uint32>();
477 uint32 entry = fields[1].Get<uint32>();
478 float x = fields[2].Get<float>();
479 float y = fields[3].Get<float>();
480 float z = fields[4].Get<float>();
481 uint16 mapId = fields[5].Get<uint16>();
482
483 GameObjectTemplate const* gameObjectInfo = sObjectMgr->GetGameObjectTemplate(entry);
484
485 if (!gameObjectInfo)
486 continue;
487
488 handler->PSendSysMessage(LANG_GO_LIST_CHAT, guid, entry, guid, gameObjectInfo->name.c_str(), x, y, z, mapId, "", "");
489
490 ++count;
491 } while (result->NextRow());
492 }
493
494 handler->PSendSysMessage(LANG_COMMAND_NEAROBJMESSAGE, distance, count);
495 return true;
496 }
std::uint16_t uint16
Definition: Define.h:109
DatabaseWorkerPool< WorldDatabaseConnection > WorldDatabase
Accessor to the world database.
Definition: DatabaseEnv.cpp:20
std::shared_ptr< PreparedResultSet > PreparedQueryResult
Definition: DatabaseEnvFwd.h:46
@ WORLD_SEL_GAMEOBJECT_NEAREST
Definition: WorldDatabase.h:89
@ LANG_GO_LIST_CHAT
Definition: Language.h:543
@ LANG_COMMAND_NEAROBJMESSAGE
Definition: Language.h:623
Definition: PreparedStatement.h:158
Class used to access individual fields of database query result.
Definition: Field.h:99
std::enable_if_t< std::is_arithmetic_v< T >, T > Get() const
Definition: Field.h:113
Acore::Types::is_default< T > SetData(const uint8 index, T value)
Definition: PreparedStatement.h:78

References Field::Get(), WorldLocation::GetMapId(), WorldObject::GetPhaseMask(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), LANG_COMMAND_NEAROBJMESSAGE, LANG_GO_LIST_CHAT, ChatHandler::PSendSysMessage(), PreparedStatementBase::SetData(), sObjectMgr, WORLD_SEL_GAMEOBJECT_NEAREST, and WorldDatabase.

Referenced by GetCommands().

◆ HandleGameObjectSetPhaseCommand()

static bool gobject_commandscript::HandleGameObjectSetPhaseCommand ( ChatHandler handler,
GameObjectSpawnId  guidLow,
uint32  phaseMask 
)
inlinestatic
428 {
429 if (!guidLow)
430 return false;
431
432 GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
433 if (!object)
434 {
436 handler->SetSentErrorMessage(true);
437 return false;
438 }
439
440 if (!phaseMask)
441 {
443 handler->SetSentErrorMessage(true);
444 return false;
445 }
446
447 object->SetPhaseMask(phaseMask, true);
448 object->SaveToDB();
449 return true;
450 }
@ LANG_BAD_VALUE
Definition: Language.h:147
virtual void SendSysMessage(std::string_view str, bool escapeCharacters=false)
Definition: Chat.cpp:103

References ChatHandler::GetObjectFromPlayerMapByDbGuid(), LANG_BAD_VALUE, LANG_COMMAND_OBJNOTFOUND, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), and ChatHandler::SetSentErrorMessage().

Referenced by GetCommands().

◆ HandleGameObjectSetStateCommand()

static bool gobject_commandscript::HandleGameObjectSetStateCommand ( ChatHandler handler,
GameObjectSpawnId  guidLow,
int32  objectType,
Optional< uint32 objectState 
)
inlinestatic
563 {
564 if (!guidLow)
565 return false;
566
567 GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
568 if (!object)
569 {
571 handler->SetSentErrorMessage(true);
572 return false;
573 }
574
575 if (objectType < 0)
576 {
577 if (objectType == -1)
578 object->SendObjectDeSpawnAnim(object->GetGUID());
579 else if (objectType == -2)
580 return false;
581 return true;
582 }
583
584 if (!objectState)
585 return false;
586
587 if (objectType < 4)
588 object->SetByteValue(GAMEOBJECT_BYTES_1, objectType, *objectState);
589 else if (objectType == 4)
590 {
591 object->SendCustomAnim(*objectState);
592 }
593 handler->PSendSysMessage("Set gobject type %d state %u", objectType, *objectState);
594 return true;
595 }
@ GAMEOBJECT_BYTES_1
Definition: UpdateFields.h:404
static ObjectGuid GetGUID(Object const *o)
Definition: Object.h:106

References GAMEOBJECT_BYTES_1, Object::GetGUID(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), LANG_COMMAND_OBJNOTFOUND, ChatHandler::PSendSysMessage(), and ChatHandler::SetSentErrorMessage().

Referenced by GetCommands().

◆ HandleGameObjectTargetCommand()

static bool gobject_commandscript::HandleGameObjectTargetCommand ( ChatHandler handler,
Optional< Variant< GameObjectEntry, std::string_view > >  objectId 
)
inlinestatic
184 {
185 Player* player = handler->GetSession()->GetPlayer();
186 QueryResult result;
187 GameEventMgr::ActiveEvents const& activeEventsList = sGameEventMgr->GetActiveEventList();
188
189 if (objectId)
190 {
191 if (objectId->holds_alternative<GameObjectEntry>())
192 {
193 result = WorldDatabase.Query("SELECT guid, id, position_x, position_y, position_z, orientation, map, phaseMask, (POW(position_x - '{}', 2) + POW(position_y - '{}', 2) + POW(position_z - '{}', 2)) AS order_ FROM gameobject WHERE map = '{}' AND id = '{}' ORDER BY order_ ASC LIMIT 1",
194 player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), static_cast<uint32>(objectId->get<GameObjectEntry>()));
195 }
196 else
197 {
198 std::string name = std::string(objectId->get<std::string_view>());
199 WorldDatabase.EscapeString(name);
200 result = WorldDatabase.Query(
201 "SELECT guid, id, position_x, position_y, position_z, orientation, map, phaseMask, (POW(position_x - {}, 2) + POW(position_y - {}, 2) + POW(position_z - {}, 2)) AS order_ "
202 "FROM gameobject LEFT JOIN gameobject_template ON gameobject_template.entry = gameobject.id WHERE map = {} AND name LIKE '%{}%' ORDER BY order_ ASC LIMIT 1",
203 player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), name);
204 }
205 }
206 else
207 {
208 std::ostringstream eventFilter;
209 eventFilter << " AND (eventEntry IS NULL ";
210 bool initString = true;
211
212 for (GameEventMgr::ActiveEvents::const_iterator itr = activeEventsList.begin(); itr != activeEventsList.end(); ++itr)
213 {
214 if (initString)
215 {
216 eventFilter << "OR eventEntry IN (" << *itr;
217 initString = false;
218 }
219 else
220 eventFilter << ',' << *itr;
221 }
222
223 if (!initString)
224 eventFilter << "))";
225 else
226 eventFilter << ')';
227
228 result = WorldDatabase.Query("SELECT gameobject.guid, id, position_x, position_y, position_z, orientation, map, phaseMask, "
229 "(POW(position_x - {}, 2) + POW(position_y - {}, 2) + POW(position_z - {}, 2)) AS order_ FROM gameobject "
230 "LEFT OUTER JOIN game_event_gameobject on gameobject.guid = game_event_gameobject.guid WHERE map = '{}' {} ORDER BY order_ ASC LIMIT 10",
231 handler->GetSession()->GetPlayer()->GetPositionX(), handler->GetSession()->GetPlayer()->GetPositionY(), handler->GetSession()->GetPlayer()->GetPositionZ(),
232 handler->GetSession()->GetPlayer()->GetMapId(), eventFilter.str());
233 }
234
235 if (!result)
236 {
238 return true;
239 }
240
241 bool found = false;
242 float x, y, z, o;
243 ObjectGuid::LowType guidLow;
244 uint32 id, phase;
245 uint16 mapId;
246 uint32 poolId;
247
248 do
249 {
250 Field* fields = result->Fetch();
251 guidLow = fields[0].Get<uint32>();
252 id = fields[1].Get<uint32>();
253 x = fields[2].Get<float>();
254 y = fields[3].Get<float>();
255 z = fields[4].Get<float>();
256 o = fields[5].Get<float>();
257 mapId = fields[6].Get<uint16>();
258 phase = fields[7].Get<uint32>();
259 poolId = sPoolMgr->IsPartOfAPool<GameObject>(guidLow);
260 if (!poolId || sPoolMgr->IsSpawnedObject<GameObject>(guidLow))
261 found = true;
262 } while (result->NextRow() && !found);
263
264 if (!found)
265 {
267 return false;
268 }
269
270 GameObjectTemplate const* objectInfo = sObjectMgr->GetGameObjectTemplate(id);
271
272 if (!objectInfo)
273 {
275 return false;
276 }
277
278 GameObject* target = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
279
280 handler->PSendSysMessage(LANG_GAMEOBJECT_DETAIL, guidLow, objectInfo->name.c_str(), guidLow, id, x, y, z, mapId, o, phase);
281
282 if (target)
283 {
284 int32 curRespawnDelay = int32(target->GetRespawnTimeEx() - GameTime::GetGameTime().count());
285 if (curRespawnDelay < 0)
286 curRespawnDelay = 0;
287
288 std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay, true);
289 std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(), true);
290
291 handler->PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(), curRespawnDelayStr.c_str());
292 }
293 return true;
294 }
std::int32_t int32
Definition: Define.h:104
std::string secsToTimeString(uint64 timeInSecs, bool shortText)
Definition: Util.cpp:74
std::shared_ptr< ResultSet > QueryResult
Definition: DatabaseEnvFwd.h:28
#define sGameEventMgr
Definition: GameEventMgr.h:186
@ LANG_GAMEOBJECT_DETAIL
Definition: Language.h:552
@ LANG_COMMAND_TARGETOBJNOTFOUND
Definition: Language.h:311
@ LANG_COMMAND_RAWPAWNTIMES
Definition: Language.h:624
#define sPoolMgr
Definition: PoolMgr.h:163
phase
Definition: boss_skadi.cpp:102
Seconds GetGameTime()
Definition: GameTime.cpp:38
Definition: ChatCommandTags.h:258
uint32 GetRespawnDelay() const
Definition: GameObject.h:199
time_t GetRespawnTimeEx() const
Definition: GameObject.cpp:2968
std::set< uint16 > ActiveEvents
Definition: GameEventMgr.h:106

References Field::Get(), GameTime::GetGameTime(), WorldLocation::GetMapId(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), GameObject::GetRespawnDelay(), GameObject::GetRespawnTimeEx(), ChatHandler::GetSession(), LANG_COMMAND_RAWPAWNTIMES, LANG_COMMAND_TARGETOBJNOTFOUND, LANG_GAMEOBJECT_DETAIL, LANG_GAMEOBJECT_NOT_EXIST, GameObjectTemplate::name, ChatHandler::PSendSysMessage(), secsToTimeString(), ChatHandler::SendSysMessage(), sGameEventMgr, sObjectMgr, sPoolMgr, and WorldDatabase.

Referenced by GetCommands().

◆ HandleGameObjectTurnCommand()

static bool gobject_commandscript::HandleGameObjectTurnCommand ( ChatHandler handler,
GameObjectSpawnId  guidLow,
Optional< float >  oz,
Optional< float >  oy,
Optional< float >  ox 
)
inlinestatic
332 {
333 if (!guidLow)
334 return false;
335
336 GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
337 if (!object)
338 {
340 handler->SetSentErrorMessage(true);
341 return false;
342 }
343
344 if (!oz)
345 oz = handler->GetSession()->GetPlayer()->GetOrientation();
346
347 Map* map = object->GetMap();
348 object->Relocate(object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), *oz);
349 object->SetLocalRotationAngles(*oz, oy.value_or(0.0f), ox.value_or(0.0f));
350 object->SaveToDB();
351
352 // Generate a completely new spawn with new guid
353 // 3.3.5a client caches recently deleted objects and brings them back to life
354 // when CreateObject block for this guid is received again
355 // however it entirely skips parsing that block and only uses already known location
356 object->Delete();
357
358 object = new GameObject();
359 if (!object->LoadGameObjectFromDB(guidLow, map, true))
360 {
361 delete object;
362 return false;
363 }
364
365 handler->PSendSysMessage(LANG_COMMAND_TURNOBJMESSAGE, object->GetSpawnId(), object->GetGOInfo()->name.c_str(), object->GetSpawnId());
366 return true;
367 }
@ LANG_COMMAND_TURNOBJMESSAGE
Definition: Language.h:321

References GameObject::GetGOInfo(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), Position::GetOrientation(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), GameObject::GetSpawnId(), LANG_COMMAND_OBJNOTFOUND, LANG_COMMAND_TURNOBJMESSAGE, GameObject::LoadGameObjectFromDB(), GameObjectTemplate::name, ChatHandler::PSendSysMessage(), and ChatHandler::SetSentErrorMessage().

Referenced by GetCommands().