gobject_commandscript Class Reference

Inheritance diagram for gobject_commandscript:

Public Member Functions
	gobject_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleGameObjectActivateCommand (ChatHandler *handler, GameObjectSpawnId guidLow)
static bool	HandleGameObjectAddCommand (ChatHandler *handler, GameObjectEntry objectId, Optional< int32 > spawnTimeSecs)
static bool	HandleGameObjectLoadCommand (ChatHandler *handler, GameObjectSpawnId spawnId)
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)
static bool	HandleGameObjectRespawn (ChatHandler *handler, GameObjectSpawnId guidLow)

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

Detailed Description

Constructor & Destructor Documentation

gobject_commandscript()

gobject_commandscript::gobject_commandscript ( )

inline

: CommandScript("gobject_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable gobject_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable gobjectCommandTable =
        {
            { "activate",  HandleGameObjectActivateCommand, SEC_GAMEMASTER,    Console::No },
            { "delete",    HandleGameObjectDeleteCommand,   SEC_ADMINISTRATOR, Console::No },
            { "info",      HandleGameObjectInfoCommand,     SEC_MODERATOR,     Console::No },
            { "move",      HandleGameObjectMoveCommand,     SEC_ADMINISTRATOR, Console::No },
            { "near",      HandleGameObjectNearCommand,     SEC_MODERATOR,     Console::No },
            { "target",    HandleGameObjectTargetCommand,   SEC_MODERATOR,     Console::No },
            { "turn",      HandleGameObjectTurnCommand,     SEC_ADMINISTRATOR, Console::No },
            { "add temp",  HandleGameObjectAddTempCommand,  SEC_GAMEMASTER,    Console::No },
            { "add",       HandleGameObjectAddCommand,      SEC_ADMINISTRATOR, Console::No },
            { "load",      HandleGameObjectLoadCommand,     SEC_ADMINISTRATOR, Console::Yes },
            { "set phase", HandleGameObjectSetPhaseCommand, SEC_ADMINISTRATOR, Console::No },
            { "set state", HandleGameObjectSetStateCommand, SEC_ADMINISTRATOR, Console::No },
            { "respawn",   HandleGameObjectRespawn,         SEC_GAMEMASTER,    Console::No }
        };
        static ChatCommandTable commandTable =
        {
            { "gobject", gobjectCommandTable }
        };
        return commandTable;
    }

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

HandleGameObjectActivateCommand()

static bool gobject_commandscript::HandleGameObjectActivateCommand ( ChatHandler *  handler, GameObjectSpawnId  guidLow  )

inlinestatic

    {
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(guidLow));
            return false;
        }
 
        uint32_t const autoCloseTime = object->GetGOInfo()->GetAutoCloseTime() ? 10000u : 0u;
 
        // Activate
        object->SetLootState(GO_READY);
        object->UseDoorOrButton(autoCloseTime, false, handler->GetSession()->GetPlayer());
 
        handler->PSendSysMessage("Object activated!");
 
        return true;
    }

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

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 ?

    {
        if (!objectId)
            return false;
 
        GameObjectTemplate const* objectInfo = sObjectMgr->GetGameObjectTemplate(objectId);
        if (!objectInfo)
        {
            handler->SendErrorMessage(LANG_GAMEOBJECT_NOT_EXIST, uint32(objectId));
            return false;
        }
 
        if (objectInfo->displayId && !sGameObjectDisplayInfoStore.LookupEntry(objectInfo->displayId))
        {
            // report to DB errors log as in loading case
            LOG_ERROR("sql.sql", "Gameobject (Entry {} GoType: {}) have invalid displayId ({}), not spawned.", *objectId, objectInfo->type, objectInfo->displayId);
            handler->SendErrorMessage(LANG_GAMEOBJECT_HAVE_INVALID_DATA, uint32(objectId));
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
        float x = float(player->GetPositionX());
        float y = float(player->GetPositionY());
        float z = float(player->GetPositionZ());
        float o = float(player->GetOrientation());
        Map* map = player->GetMap();
 
        GameObject* object = sObjectMgr->IsGameObjectStaticTransport(objectInfo->entry) ? new StaticTransport() : new GameObject();
        ObjectGuid::LowType guidLow = map->GenerateLowGuid<HighGuid::GameObject>();
 
        if (!object->Create(guidLow, objectInfo->entry, map, player->GetPhaseMaskForSpawn(), x, y, z, o, G3D::Quat(), 0, GO_STATE_READY))
        {
            delete object;
            return false;
        }
 
        if (spawnTimeSecs)
            object->SetRespawnTime(*spawnTimeSecs);
 
        // fill the gameobject data and save to the db
        object->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), player->GetPhaseMaskForSpawn());
        guidLow = object->GetSpawnId();
 
        // delete the old object and do a clean load from DB with a fresh new GameObject instance.
        // this is required to avoid weird behavior and memory leaks
        delete object;
 
        object = sObjectMgr->IsGameObjectStaticTransport(objectInfo->entry) ? new StaticTransport() : new GameObject();
        // this will generate a new guid if the object is in an instance
        if (!object->LoadGameObjectFromDB(guidLow, map, true))
        {
            delete object;
            return false;
        }
 
        sObjectMgr->AddGameobjectToGrid(guidLow, sObjectMgr->GetGameObjectData(guidLow));
 
        handler->PSendSysMessage(LANG_GAMEOBJECT_ADD, uint32(objectId), objectInfo->name, guidLow, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ());
        return true;
    }

References GameObject::Create(), GameObjectTemplate::displayId, GameObjectTemplate::entry, GameObject, 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(), ChatHandler::SendErrorMessage(), GameObject::SetRespawnTime(), sGameObjectDisplayInfoStore, sObjectMgr, and GameObjectTemplate::type.

Referenced by GetCommands().

HandleGameObjectAddTempCommand()

static bool gobject_commandscript::HandleGameObjectAddTempCommand ( ChatHandler *  handler, GameObjectEntry  objectId, Optional< uint64 >  spawntime  )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        uint64 spawntm(spawntime.value_or(300));
 
        if (!sObjectMgr->GetGameObjectTemplate(objectId))
        {
            handler->SendErrorMessage(LANG_GAMEOBJECT_NOT_EXIST, uint32(objectId));
            return false;
        }
 
        float x = player->GetPositionX();
        float y = player->GetPositionY();
        float z = player->GetPositionZ();
        float ang = player->GetOrientation();
 
        float rot2 = std::sin(ang / 2);
        float rot3 = cos(ang / 2);
 
        player->SummonGameObject(objectId, x, y, z, ang, 0, 0, rot2, rot3, spawntm);
 
        return true;
    }

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

Referenced by GetCommands().

HandleGameObjectDeleteCommand()

static bool gobject_commandscript::HandleGameObjectDeleteCommand ( ChatHandler *  handler, GameObjectSpawnId  spawnId  )

inlinestatic

    {
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(spawnId);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(spawnId));
            return false;
        }
 
        ObjectGuid ownerGuid = object->GetOwnerGUID();
        if (ownerGuid)
        {
            Unit* owner = ObjectAccessor::GetUnit(*handler->GetSession()->GetPlayer(), ownerGuid);
            if (!owner || !ownerGuid.IsPlayer())
            {
                handler->SendErrorMessage(LANG_COMMAND_DELOBJREFERCREATURE, ownerGuid.ToString(), object->GetSpawnId());
                return false;
            }
 
            owner->RemoveGameObject(object, false);
        }
 
        object->SetRespawnTime(0);                                 // not save respawn time
        object->Delete();
        object->DeleteFromDB();
 
        handler->PSendSysMessage(LANG_COMMAND_DELOBJMESSAGE, object->GetSpawnId());
 
        return true;
    }

References 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(), ChatHandler::SendErrorMessage(), and ObjectGuid::ToString().

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

    {
        uint32 entry = 0;
        uint32 type = 0;
        uint32 displayId = 0;
        std::string name;
        uint32 lootId = 0;
        GameObject* gameObject = nullptr;
 
        ObjectGuid::LowType spawnId = 0;
        if (isGuid || data.holds_alternative<Hyperlink<gameobject>>())
        {
            spawnId = *data;
            GameObjectData const* spawnData = sObjectMgr->GetGameObjectData(spawnId);
            if (!spawnData)
            {
                handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, spawnId);
                return false;
            }
            entry = spawnData->id;
            gameObject = handler->GetObjectFromPlayerMapByDbGuid(spawnId);
        }
        else
        {
            entry = *data;
        }
 
        GameObjectTemplate const* gameObjectInfo = sObjectMgr->GetGameObjectTemplate(entry);
        if (!gameObjectInfo)
        {
            handler->SendErrorMessage(LANG_GAMEOBJECT_NOT_EXIST, entry);
            return false;
        }
 
        type = gameObjectInfo->type;
        displayId = gameObjectInfo->displayId;
        name = gameObjectInfo->name;
        if (type == GAMEOBJECT_TYPE_CHEST)
            lootId = gameObjectInfo->chest.lootId;
        else if (type == GAMEOBJECT_TYPE_FISHINGHOLE)
            lootId = gameObjectInfo->fishinghole.lootId;
 
        handler->PSendSysMessage(LANG_GOINFO_ENTRY, entry);
        if (gameObject)
            handler->PSendSysMessage("GUID: {}", gameObject->GetGUID().ToString());
        handler->PSendSysMessage(LANG_GOINFO_TYPE, type);
        handler->PSendSysMessage(LANG_GOINFO_LOOTID, lootId);
        handler->PSendSysMessage(LANG_GOINFO_DISPLAYID, displayId);
        if (gameObject)
        {
            handler->PSendSysMessage("LootMode: {}", gameObject->GetLootMode());
            handler->PSendSysMessage("LootState: {}", gameObject->getLootState());
            handler->PSendSysMessage("GOState: {}", gameObject->GetGoState());
            handler->PSendSysMessage("PhaseMask: {}", gameObject->GetPhaseMask());
            handler->PSendSysMessage("IsLootEmpty: {}", gameObject->loot.empty());
            handler->PSendSysMessage("IsLootLooted: {}", gameObject->loot.isLooted());
        }
 
        handler->PSendSysMessage(LANG_GOINFO_NAME, name);
 
        return true;
    }

References GameObjectTemplate::chest, GameObjectTemplate::displayId, Loot::empty(), GameObjectTemplate::fishinghole, GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_FISHINGHOLE, GameObject::GetGoState(), Object::GetGUID(), 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::SendErrorMessage(), sObjectMgr, ObjectGuid::ToString(), and GameObjectTemplate::type.

Referenced by GetCommands().

HandleGameObjectLoadCommand()

static bool gobject_commandscript::HandleGameObjectLoadCommand ( ChatHandler *  handler, GameObjectSpawnId  spawnId  )

inlinestatic

    {
        if (!spawnId)
            return false;
 
        if (sObjectMgr->GetGameObjectData(spawnId))
        {
            handler->SendErrorMessage("Gameobject spawn {} is already loaded.", uint32(spawnId));
            return false;
        }
 
        GameObjectData const* data = sObjectMgr->LoadGameObjectDataFromDB(spawnId);
        if (!data)
        {
            handler->SendErrorMessage("Gameobject spawn {} not found in the database.", uint32(spawnId));
            return false;
        }
 
        if (sPoolMgr->IsPartOfAPool<GameObject>(spawnId))
        {
            handler->SendErrorMessage("Gameobject spawn {} is part of a pool and cannot be manually loaded.", uint32(spawnId));
            return false;
        }
 
        QueryResult eventResult = WorldDatabase.Query("SELECT guid FROM game_event_gameobject WHERE guid = {}", uint32(spawnId));
        if (eventResult)
        {
            handler->SendErrorMessage("Gameobject spawn {} is managed by the game event system and cannot be manually loaded.", uint32(spawnId));
            return false;
        }
 
        Map* map = sMapMgr->FindBaseNonInstanceMap(data->mapid);
        if (!map)
        {
            handler->SendErrorMessage("Gameobject spawn {} is on a non-continent map (ID: {}). Only continent maps are supported.", uint32(spawnId), data->mapid);
            return false;
        }
 
        GameObjectTemplate const* objectInfo = sObjectMgr->GetGameObjectTemplate(data->id);
        if (!objectInfo)
        {
            handler->SendErrorMessage("Gameobject template not found for entry {}.", data->id);
            return false;
        }
 
        GameObject* object = sObjectMgr->IsGameObjectStaticTransport(objectInfo->entry) ? new StaticTransport() : new GameObject();
        if (!object->LoadGameObjectFromDB(spawnId, map, true))
        {
            delete object;
            handler->SendErrorMessage("Failed to load gameobject spawn {}.", uint32(spawnId));
            return false;
        }
 
        sObjectMgr->AddGameobjectToGrid(spawnId, data);
        handler->PSendSysMessage("Gameobject spawn {} loaded successfully.", uint32(spawnId));
        return true;
    }

References GameObjectTemplate::entry, GameObjectData::id, GameObject::LoadGameObjectFromDB(), GameObjectData::mapid, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), sMapMgr, sObjectMgr, sPoolMgr, and WorldDatabase.

Referenced by GetCommands().

HandleGameObjectMoveCommand()

static bool gobject_commandscript::HandleGameObjectMoveCommand ( ChatHandler *  handler, GameObjectSpawnId  guidLow, Optional< std::array< float, 3 > >  xyz  )

inlinestatic

    {
        if (!guidLow)
            return false;
 
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(guidLow));
            return false;
        }
 
        Position pos;
        if (xyz)
        {
            pos = { (*xyz)[0], (*xyz)[1], (*xyz)[2] };
            if (!MapMgr::IsValidMapCoord(object->GetMapId(), pos))
            {
                handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, pos.GetPositionX(), pos.GetPositionY(), object->GetMapId());
                return false;
            }
        }
        else
        {
            pos = handler->GetSession()->GetPlayer()->GetPosition();
        }
 
        Map* map = object->GetMap();
 
        pos.SetOrientation(object->GetOrientation());
        object->Relocate(pos);
 
        // update which cell has this gameobject registered for loading
        sObjectMgr->RemoveGameobjectFromGrid(guidLow, object->GetGameObjectData());
        object->SaveToDB();
        sObjectMgr->AddGameobjectToGrid(guidLow, object->GetGameObjectData());
 
        // Generate a completely new spawn with new guid
        // 3.3.5a client caches recently deleted objects and brings them back to life
        // when CreateObject block for this guid is received again
        // however it entirely skips parsing that block and only uses already known location
        object->Delete();
 
        object = new GameObject();
        if (!object->LoadGameObjectFromDB(guidLow, map, true))
        {
            delete object;
            return false;
        }
 
        handler->PSendSysMessage(LANG_COMMAND_MOVEOBJMESSAGE, object->GetSpawnId(), object->GetGOInfo()->name, object->GetSpawnId());
        return true;
    }

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(), ChatHandler::SendErrorMessage(), Position::SetOrientation(), and sObjectMgr.

Referenced by GetCommands().

HandleGameObjectNearCommand()

static bool gobject_commandscript::HandleGameObjectNearCommand ( ChatHandler *  handler, Optional< float >  dist  )

inlinestatic

    {
        float distance = dist.value_or(10.0f);
        uint32 count = 0;
 
        Player* player = handler->GetSession()->GetPlayer();
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAMEOBJECT_NEAREST);
        stmt->SetData(0, player->GetPositionX());
        stmt->SetData(1, player->GetPositionY());
        stmt->SetData(2, player->GetPositionZ());
        stmt->SetData(3, player->GetMapId());
        stmt->SetData(4, player->GetPositionX());
        stmt->SetData(5, player->GetPositionY());
        stmt->SetData(6, player->GetPositionZ());
        stmt->SetData(7, distance * distance);
        stmt->SetData(8, player->GetPhaseMask());
        PreparedQueryResult result = WorldDatabase.Query(stmt);
 
        if (result)
        {
            do
            {
                Field* fields = result->Fetch();
                ObjectGuid::LowType guid = fields[0].Get<uint32>();
                uint32 entry = fields[1].Get<uint32>();
                float x = fields[2].Get<float>();
                float y = fields[3].Get<float>();
                float z = fields[4].Get<float>();
                uint16 mapId = fields[5].Get<uint16>();
 
                GameObjectTemplate const* gameObjectInfo = sObjectMgr->GetGameObjectTemplate(entry);
 
                if (!gameObjectInfo)
                    continue;
 
                handler->PSendSysMessage(LANG_GO_LIST_CHAT, guid, entry, guid, gameObjectInfo->name, x, y, z, mapId, "", "");
 
                ++count;
            } while (result->NextRow());
        }
 
        handler->PSendSysMessage(LANG_COMMAND_NEAROBJMESSAGE, distance, count);
        return true;
    }

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

HandleGameObjectRespawn()

static bool gobject_commandscript::HandleGameObjectRespawn ( ChatHandler *  handler, GameObjectSpawnId  guidLow  )

inlinestatic

    {
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(guidLow));
            return false;
        }
 
        object->Respawn();
        handler->PSendSysMessage(LANG_CMD_GO_RESPAWN, object->GetNameForLocaleIdx(handler->GetSessionDbcLocale()), object->GetEntry(), object->GetSpawnId());
        return true;
    }

References Object::GetEntry(), GameObject::GetNameForLocaleIdx(), ChatHandler::GetObjectFromPlayerMapByDbGuid(), ChatHandler::GetSessionDbcLocale(), GameObject::GetSpawnId(), LANG_CMD_GO_RESPAWN, LANG_COMMAND_OBJNOTFOUND, ChatHandler::PSendSysMessage(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleGameObjectSetPhaseCommand()

static bool gobject_commandscript::HandleGameObjectSetPhaseCommand ( ChatHandler *  handler, GameObjectSpawnId  guidLow, uint32  phaseMask  )

inlinestatic

    {
        if (!guidLow)
            return false;
 
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(guidLow));
            return false;
        }
 
        if (!phaseMask)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        object->SetPhaseMask(phaseMask, true);
        object->SaveToDB();
        return true;
    }

References ChatHandler::GetObjectFromPlayerMapByDbGuid(), LANG_BAD_VALUE, LANG_COMMAND_OBJNOTFOUND, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleGameObjectSetStateCommand()

static bool gobject_commandscript::HandleGameObjectSetStateCommand ( ChatHandler *  handler, GameObjectSpawnId  guidLow, int32  objectType, Optional< uint32 >  objectState  )

inlinestatic

    {
        if (!guidLow)
            return false;
 
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(guidLow));
            return false;
        }
 
        if (objectType < 0)
        {
            if (objectType == -1)
                object->SendObjectDeSpawnAnim(object->GetGUID());
            else if (objectType == -2)
                return false;
            return true;
        }
 
        if (!objectState)
            return false;
 
        if (objectType < 4)
            object->SetByteValue(GAMEOBJECT_BYTES_1, objectType, *objectState);
        else if (objectType == 4)
        {
            object->SendCustomAnim(*objectState);
        }
        handler->PSendSysMessage("Set gobject type {} state {}", objectType, *objectState);
        return true;
    }

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

Referenced by GetCommands().

HandleGameObjectTargetCommand()

static bool gobject_commandscript::HandleGameObjectTargetCommand ( ChatHandler *  handler, Optional< Variant< GameObjectEntry, std::string_view > >  objectId  )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        QueryResult result;
        GameEventMgr::ActiveEvents const& activeEventsList = sGameEventMgr->GetActiveEventList();
 
        if (objectId)
        {
            if (objectId->holds_alternative<GameObjectEntry>())
            {
                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",
                                              player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), static_cast<uint32>(objectId->get<GameObjectEntry>()));
            }
            else
            {
                std::string name = std::string(objectId->get<std::string_view>());
                WorldDatabase.EscapeString(name);
                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 LEFT JOIN gameobject_template ON gameobject_template.entry = gameobject.id WHERE map = {} AND name LIKE '%{}%' ORDER BY order_ ASC LIMIT 1",
                        player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), name);
            }
        }
        else
        {
            std::ostringstream eventFilter;
            eventFilter << " AND (eventEntry IS NULL ";
            bool initString = true;
 
            for (GameEventMgr::ActiveEvents::const_iterator itr = activeEventsList.begin(); itr != activeEventsList.end(); ++itr)
            {
                if (initString)
                {
                    eventFilter  <<  "OR eventEntry IN (" << *itr;
                    initString = false;
                }
                else
                    eventFilter << ',' << *itr;
            }
 
            if (!initString)
                eventFilter << "))";
            else
                eventFilter << ')';
 
            result = WorldDatabase.Query("SELECT gameobject.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 "
                                          "LEFT OUTER JOIN game_event_gameobject on gameobject.guid = game_event_gameobject.guid WHERE map = '{}' {} ORDER BY order_ ASC LIMIT 10",
                                          handler->GetSession()->GetPlayer()->GetPositionX(), handler->GetSession()->GetPlayer()->GetPositionY(), handler->GetSession()->GetPlayer()->GetPositionZ(),
                                          handler->GetSession()->GetPlayer()->GetMapId(), eventFilter.str());
        }
 
        if (!result)
        {
            handler->SendSysMessage(LANG_COMMAND_TARGETOBJNOTFOUND);
            return true;
        }
 
        bool found = false;
        float x, y, z, o;
        ObjectGuid::LowType guidLow;
        uint32 id, phase;
        uint16 mapId;
        uint32 poolId;
 
        do
        {
            Field* fields = result->Fetch();
            guidLow = fields[0].Get<uint32>();
            id =      fields[1].Get<uint32>();
            x =       fields[2].Get<float>();
            y =       fields[3].Get<float>();
            z =       fields[4].Get<float>();
            o =       fields[5].Get<float>();
            mapId =   fields[6].Get<uint16>();
            phase =   fields[7].Get<uint32>();
            poolId =  sPoolMgr->IsPartOfAPool<GameObject>(guidLow);
            if (!poolId || sPoolMgr->IsSpawnedObject<GameObject>(guidLow))
                found = true;
        } while (result->NextRow() && !found);
 
        if (!found)
        {
            handler->PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST, id);
            return false;
        }
 
        GameObjectTemplate const* objectInfo = sObjectMgr->GetGameObjectTemplate(id);
 
        if (!objectInfo)
        {
            handler->PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST, id);
            return false;
        }
 
        GameObject* target = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
 
        handler->PSendSysMessage(LANG_GAMEOBJECT_DETAIL, guidLow, objectInfo->name, guidLow, id, x, y, z, mapId, o, phase);
 
        if (target)
        {
            int32 curRespawnDelay = int32(target->GetRespawnTimeEx() - GameTime::GetGameTime().count());
            if (curRespawnDelay < 0)
                curRespawnDelay = 0;
 
            std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay, true);
            std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(), true);
 
            handler->PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr, curRespawnDelayStr);
        }
        return true;
    }

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

    {
        if (!guidLow)
            return false;
 
        GameObject* object = handler->GetObjectFromPlayerMapByDbGuid(guidLow);
        if (!object)
        {
            handler->SendErrorMessage(LANG_COMMAND_OBJNOTFOUND, uint32(guidLow));
            return false;
        }
 
        if (!oz)
            oz = handler->GetSession()->GetPlayer()->GetOrientation();
 
        Map* map = object->GetMap();
        object->Relocate(object->GetPositionX(), object->GetPositionY(), object->GetPositionZ(), *oz);
        object->SetWorldRotationAngles(*oz, oy.value_or(0.0f), ox.value_or(0.0f));
        object->SaveToDB();
 
        // Generate a completely new spawn with new guid
        // 3.3.5a client caches recently deleted objects and brings them back to life
        // when CreateObject block for this guid is received again
        // however it entirely skips parsing that block and only uses already known location
        object->Delete();
 
        object = new GameObject();
        if (!object->LoadGameObjectFromDB(guidLow, map, true))
        {
            delete object;
            return false;
        }
 
        handler->PSendSysMessage(LANG_COMMAND_TURNOBJMESSAGE, object->GetSpawnId(), object->GetGOInfo()->name, object->GetSpawnId());
        return true;
    }

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

Referenced by GetCommands().

---

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

• azerothcore-wotlk/src/server/scripts/Commands/cs_gobject.cpp