go_commandscript Class Reference

Inheritance diagram for go_commandscript:

Public Member Functions
	go_commandscript ()
ChatCommandTable	GetCommands () const override
virtual std::vector< Acore::ChatCommands::ChatCommandBuilder >	GetCommands () const =0
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	DoTeleport (ChatHandler *handler, Position pos, uint32 mapId=MAPID_INVALID)
static bool	HandleGoCreatureCIdCommand (ChatHandler *handler, Variant< Hyperlink< creature_entry >, uint32 > cId)
static bool	HandleGoCreatureSpawnIdCommand (ChatHandler *handler, Variant< Hyperlink< creature >, ObjectGuid::LowType > spawnId)
static bool	HandleGoCreatureNameCommand (ChatHandler *handler, Tail name)
static bool	HandleGoGameObjectSpawnIdCommand (ChatHandler *handler, uint32 spawnId)
static bool	HandleGoGameObjectGOIdCommand (ChatHandler *handler, uint32 goId)
static bool	HandleGoGraveyardCommand (ChatHandler *handler, uint32 gyId)
static bool	HandleGoGridCommand (ChatHandler *handler, float gridX, float gridY, Optional< uint32 > oMapId)
static bool	HandleGoTaxinodeCommand (ChatHandler *handler, Variant< Hyperlink< taxinode >, uint32 > nodeId)
static bool	HandleGoTriggerCommand (ChatHandler *handler, Variant< Hyperlink< areatrigger >, uint32 > areaTriggerId)
static bool	HandleGoZoneXYCommand (ChatHandler *handler, float x, float y, Optional< Variant< Hyperlink< area >, uint32 > > areaIdArg)
static bool	HandleGoXYZCommand (ChatHandler *handler, Tail args)
	Teleports the GM to the specified world coordinates, optionally specifying map ID and orientation. More...
static bool	HandleGoTicketCommand (ChatHandler *handler, uint32 ticketId)
static bool	HandleGoQuestCommand (ChatHandler *handler, std::string_view type, Quest const *quest)
static CreatureData const *	GetCreatureData (ChatHandler *handler, uint32 entry)
static GameObjectData const *	GetGameObjectData (ChatHandler *handler, uint32 entry)

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

go_commandscript()

go_commandscript::go_commandscript ( )

inline

: CommandScript("go_commandscript") { }

Member Function Documentation

DoTeleport()

static bool go_commandscript::DoTeleport ( ChatHandler *  handler, Position  pos, uint32  mapId = MAPID_INVALID  )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        if (mapId == MAPID_INVALID)
            mapId = player->GetMapId();
        if (!MapMgr::IsValidMapCoord(mapId, pos) || sObjectMgr->IsTransportMap(mapId))
        {
            handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, pos.GetPositionX(), pos.GetPositionY(), mapId);
            return false;
        }
 
        // stop flight if need
        if (player->IsInFlight())
        {
            player->GetMotionMaster()->MovementExpired();
            player->CleanupAfterTaxiFlight();
        }
        // save only in non-flight case
        else
            player->SaveRecallPosition();
 
        player->TeleportTo({ mapId, pos });
        return true;
    }

References Player::CleanupAfterTaxiFlight(), WorldLocation::GetMapId(), Unit::GetMotionMaster(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), ChatHandler::GetSession(), Unit::IsInFlight(), MapMgr::IsValidMapCoord(), LANG_INVALID_TARGET_COORD, MAPID_INVALID, MotionMaster::MovementExpired(), Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), sObjectMgr, and Player::TeleportTo().

Referenced by HandleGoCreatureCIdCommand(), HandleGoCreatureNameCommand(), HandleGoCreatureSpawnIdCommand(), HandleGoGameObjectGOIdCommand(), HandleGoGameObjectSpawnIdCommand(), HandleGoQuestCommand(), HandleGoTaxinodeCommand(), HandleGoTriggerCommand(), and HandleGoXYZCommand().

GetCommands()

ChatCommandTable go_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable goCommandTable =
        {
            { "creature",      HandleGoCreatureSpawnIdCommand,   SEC_MODERATOR,  Console::No },
            { "creature id",   HandleGoCreatureCIdCommand,       SEC_MODERATOR,  Console::No },
            { "creature name", HandleGoCreatureNameCommand,      SEC_MODERATOR,  Console::No },
            { "gameobject",    HandleGoGameObjectSpawnIdCommand, SEC_MODERATOR,  Console::No },
            { "gameobject id", HandleGoGameObjectGOIdCommand,    SEC_MODERATOR,  Console::No },
            { "graveyard",     HandleGoGraveyardCommand,         SEC_MODERATOR,  Console::No },
            { "grid",          HandleGoGridCommand,              SEC_MODERATOR,  Console::No },
            { "taxinode",      HandleGoTaxinodeCommand,          SEC_MODERATOR,  Console::No },
            { "trigger",       HandleGoTriggerCommand,           SEC_MODERATOR,  Console::No },
            { "zonexy",        HandleGoZoneXYCommand,            SEC_MODERATOR,  Console::No },
            { "xyz",           HandleGoXYZCommand,               SEC_MODERATOR,  Console::No },
            { "ticket",        HandleGoTicketCommand,            SEC_GAMEMASTER, Console::No },
            { "quest",         HandleGoQuestCommand,             SEC_MODERATOR,  Console::No },
        };
 
        static ChatCommandTable commandTable =
        {
            { "go", goCommandTable }
        };
        return commandTable;
    }

References HandleGoCreatureCIdCommand(), HandleGoCreatureNameCommand(), HandleGoCreatureSpawnIdCommand(), HandleGoGameObjectGOIdCommand(), HandleGoGameObjectSpawnIdCommand(), HandleGoGraveyardCommand(), HandleGoGridCommand(), HandleGoQuestCommand(), HandleGoTaxinodeCommand(), HandleGoTicketCommand(), HandleGoTriggerCommand(), HandleGoXYZCommand(), HandleGoZoneXYCommand(), SEC_GAMEMASTER, and SEC_MODERATOR.

GetCreatureData()

static CreatureData const * go_commandscript::GetCreatureData ( ChatHandler *  handler, uint32  entry  )

inlinestatic

    {
        CreatureData const* spawnpoint = nullptr;
        for (auto const& pair : sObjectMgr->GetAllCreatureData())
        {
            if (pair.second.id1 != entry)
            {
                continue;
            }
 
            if (!spawnpoint)
            {
                spawnpoint = &pair.second;
            }
            else
            {
                handler->SendSysMessage(LANG_COMMAND_GOCREATMULTIPLE);
                break;
            }
        }
 
        return spawnpoint;
    }

References LANG_COMMAND_GOCREATMULTIPLE, ChatHandler::SendSysMessage(), and sObjectMgr.

Referenced by HandleGoCreatureCIdCommand(), HandleGoCreatureNameCommand(), and HandleGoQuestCommand().

GetGameObjectData()

static GameObjectData const * go_commandscript::GetGameObjectData ( ChatHandler *  handler, uint32  entry  )

inlinestatic

    {
        GameObjectData const* spawnpoint = nullptr;
        for (auto const& pair : sObjectMgr->GetAllGOData())
        {
            if (pair.second.id != entry)
            {
                continue;
            }
 
            if (!spawnpoint)
            {
                spawnpoint = &pair.second;
            }
            else
            {
                handler->SendSysMessage(LANG_COMMAND_GOCREATMULTIPLE);
                break;
            }
        }
 
        return spawnpoint;
    }

References LANG_COMMAND_GOCREATMULTIPLE, ChatHandler::SendSysMessage(), and sObjectMgr.

Referenced by HandleGoGameObjectGOIdCommand(), and HandleGoQuestCommand().

HandleGoCreatureCIdCommand()

static bool go_commandscript::HandleGoCreatureCIdCommand ( ChatHandler *  handler, Variant< Hyperlink< creature_entry >, uint32 >  cId  )

inlinestatic

    {
        CreatureData const* spawnpoint = GetCreatureData(handler, *cId);
 
        if (!spawnpoint)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOCREATNOTFOUND);
            return false;
        }
 
        return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
    }

References DoTeleport(), GetCreatureData(), LANG_COMMAND_GOCREATNOTFOUND, CreatureData::mapid, CreatureData::posX, CreatureData::posY, CreatureData::posZ, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleGoCreatureNameCommand()

static bool go_commandscript::HandleGoCreatureNameCommand ( ChatHandler *  handler, Tail  name  )

inlinestatic

    {
        if (!name.data())
            return false;
 
        // Make sure we don't pass double quotes into the SQL query. Otherwise it causes a MySQL error
        std::string str = name.data(); // Making subtractions to the last character does not with in string_view
        if (str.front() == '"')
            str = str.substr(1);
        if (str.back() == '"')
            str = str.substr(0, str.size() - 1);
 
        QueryResult result = WorldDatabase.Query("SELECT entry FROM creature_template WHERE name = \"{}\" LIMIT 1", str);
        if (!result)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOCREATNOTFOUND);
            return false;
        }
 
        uint32 entry = result->Fetch()[0].Get<uint32>();
        CreatureData const* spawnpoint = GetCreatureData(handler, entry);
        if (!spawnpoint)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOCREATNOTFOUND);
            return false;
        }
 
        return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
    }

References DoTeleport(), GetCreatureData(), LANG_COMMAND_GOCREATNOTFOUND, ChatHandler::SendErrorMessage(), and WorldDatabase.

Referenced by GetCommands().

HandleGoCreatureSpawnIdCommand()

static bool go_commandscript::HandleGoCreatureSpawnIdCommand ( ChatHandler *  handler, Variant< Hyperlink< creature >, ObjectGuid::LowType >  spawnId  )

inlinestatic

    {
        CreatureData const* spawnpoint = sObjectMgr->GetCreatureData(spawnId);
        if (!spawnpoint)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOCREATNOTFOUND);
            return false;
        }
 
        return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
    }

References DoTeleport(), LANG_COMMAND_GOCREATNOTFOUND, CreatureData::mapid, CreatureData::posX, CreatureData::posY, CreatureData::posZ, ChatHandler::SendErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandleGoGameObjectGOIdCommand()

static bool go_commandscript::HandleGoGameObjectGOIdCommand ( ChatHandler *  handler, uint32  goId  )

inlinestatic

    {
        GameObjectData const* spawnpoint = GetGameObjectData(handler, goId);
 
        if (!spawnpoint)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOOBJNOTFOUND);
            return false;
        }
 
        return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
    }

References DoTeleport(), GetGameObjectData(), LANG_COMMAND_GOOBJNOTFOUND, GameObjectData::mapid, GameObjectData::posX, GameObjectData::posY, GameObjectData::posZ, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleGoGameObjectSpawnIdCommand()

static bool go_commandscript::HandleGoGameObjectSpawnIdCommand ( ChatHandler *  handler, uint32  spawnId  )

inlinestatic

    {
        GameObjectData const* spawnpoint = sObjectMgr->GetGameObjectData(spawnId);
        if (!spawnpoint)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOOBJNOTFOUND);
            return false;
        }
 
        return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
    }

References DoTeleport(), LANG_COMMAND_GOOBJNOTFOUND, GameObjectData::mapid, GameObjectData::posX, GameObjectData::posY, GameObjectData::posZ, ChatHandler::SendErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandleGoGraveyardCommand()

static bool go_commandscript::HandleGoGraveyardCommand ( ChatHandler *  handler, uint32  gyId  )

inlinestatic

    {
        GraveyardStruct const* gy = sGraveyard->GetGraveyard(gyId);
        if (!gy)
        {
            handler->SendErrorMessage(LANG_COMMAND_GRAVEYARDNOEXIST, gyId);
            return false;
        }
 
        if (!MapMgr::IsValidMapCoord(gy->Map, gy->x, gy->y, gy->z))
        {
            handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, gy->x, gy->y, gy->Map);
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
        // stop flight if need
        if (player->IsInFlight())
        {
            player->GetMotionMaster()->MovementExpired();
            player->CleanupAfterTaxiFlight();
        }
        // save only in non-flight case
        else
            player->SaveRecallPosition();
 
        player->TeleportTo(gy->Map, gy->x, gy->y, gy->z, player->GetOrientation());
        return true;
    }

References Player::CleanupAfterTaxiFlight(), Unit::GetMotionMaster(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Unit::IsInFlight(), MapMgr::IsValidMapCoord(), LANG_COMMAND_GRAVEYARDNOEXIST, LANG_INVALID_TARGET_COORD, GraveyardStruct::Map, MotionMaster::MovementExpired(), Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), sGraveyard, Player::TeleportTo(), GraveyardStruct::x, GraveyardStruct::y, and GraveyardStruct::z.

Referenced by GetCommands().

HandleGoGridCommand()

static bool go_commandscript::HandleGoGridCommand ( ChatHandler *  handler, float  gridX, float  gridY, Optional< uint32 >  oMapId  )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        uint32 mapId = oMapId.value_or(player->GetMapId());
 
        // center of grid
        float x = (gridX - CENTER_GRID_ID + 0.5f) * SIZE_OF_GRIDS;
        float y = (gridY - CENTER_GRID_ID + 0.5f) * SIZE_OF_GRIDS;
 
        if (!MapMgr::IsValidMapCoord(mapId, x, y))
        {
            handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, x, y, mapId);
            return false;
        }
 
        // stop flight if need
        if (player->IsInFlight())
        {
            player->GetMotionMaster()->MovementExpired();
            player->CleanupAfterTaxiFlight();
        }
        // save only in non-flight case
        else
            player->SaveRecallPosition();
 
        Map const* map = sMapMgr->CreateBaseMap(mapId);
        float z = std::max(map->GetHeight(x, y, MAX_HEIGHT), map->GetWaterLevel(x, y));
 
        player->TeleportTo(mapId, x, y, z, player->GetOrientation());
        return true;
    }

References CENTER_GRID_ID, Player::CleanupAfterTaxiFlight(), Map::GetHeight(), WorldLocation::GetMapId(), Unit::GetMotionMaster(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Map::GetWaterLevel(), Unit::IsInFlight(), MapMgr::IsValidMapCoord(), LANG_INVALID_TARGET_COORD, MAX_HEIGHT, MotionMaster::MovementExpired(), Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), SIZE_OF_GRIDS, sMapMgr, and Player::TeleportTo().

Referenced by GetCommands().

HandleGoQuestCommand()

static bool go_commandscript::HandleGoQuestCommand ( ChatHandler *  handler, std::string_view  type, Quest const *  quest  )

inlinestatic

    {
        uint32 entry = quest->GetQuestId();
 
        if (type == "starter")
        {
            QuestRelations* qr = sObjectMgr->GetCreatureQuestRelationMap();
 
            for (auto itr = qr->begin(); itr != qr->end(); ++itr)
            {
                if (itr->second == entry)
                {
                    CreatureData const* spawnpoint = GetCreatureData(handler, itr->first);
                    if (!spawnpoint)
                    {
                        handler->SendErrorMessage(LANG_COMMAND_GOCREATNOTFOUND);
                        return false;
                    }
 
                    // We've found a creature, teleport to it.
                    return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
                }
            }
 
            qr = sObjectMgr->GetGOQuestRelationMap();
 
            for (auto itr = qr->begin(); itr != qr->end(); ++itr)
            {
                if (itr->second == entry)
                {
                    GameObjectData const* spawnpoint = GetGameObjectData(handler, itr->first);
                    if (!spawnpoint)
                    {
                        handler->SendErrorMessage(LANG_COMMAND_GOOBJNOTFOUND);
                        return false;
                    }
 
                    return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
                }
            }
        }
        else if (type == "ender")
        {
            QuestRelations* qr = sObjectMgr->GetCreatureQuestInvolvedRelationMap();
 
            for (auto itr = qr->begin(); itr != qr->end(); ++itr)
            {
                if (itr->second == entry)
                {
                    CreatureData const* spawnpoint = GetCreatureData(handler, itr->first);
                    if (!spawnpoint)
                    {
                        handler->SendErrorMessage(LANG_COMMAND_GOCREATNOTFOUND);
                        return false;
                    }
 
                    // We've found a creature, teleport to it.
                    return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
                }
            }
 
            qr = sObjectMgr->GetGOQuestInvolvedRelationMap();
 
            for (auto itr = qr->begin(); itr != qr->end(); ++itr)
            {
                if (itr->second == entry)
                {
                    GameObjectData const* spawnpoint = GetGameObjectData(handler, itr->first);
                    if (!spawnpoint)
                    {
                        handler->SendErrorMessage(LANG_COMMAND_GOOBJNOTFOUND);
                        return false;
                    }
 
                    return DoTeleport(handler, { spawnpoint->posX, spawnpoint->posY, spawnpoint->posZ }, spawnpoint->mapid);
                }
            }
        }
        else
        {
            handler->SendErrorMessage(LANG_CMD_GOQUEST_INVALID_SYNTAX);
            return false;
        }
 
        return false;
    }

References DoTeleport(), GetCreatureData(), GetGameObjectData(), Quest::GetQuestId(), LANG_CMD_GOQUEST_INVALID_SYNTAX, LANG_COMMAND_GOCREATNOTFOUND, LANG_COMMAND_GOOBJNOTFOUND, CreatureData::mapid, GameObjectData::mapid, CreatureData::posX, GameObjectData::posX, CreatureData::posY, GameObjectData::posY, CreatureData::posZ, GameObjectData::posZ, ChatHandler::SendErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandleGoTaxinodeCommand()

static bool go_commandscript::HandleGoTaxinodeCommand ( ChatHandler *  handler, Variant< Hyperlink< taxinode >, uint32 >  nodeId  )

inlinestatic

    {
        TaxiNodesEntry const* node = sTaxiNodesStore.LookupEntry(nodeId);
        if (!node)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOTAXINODENOTFOUND, uint32(nodeId));
            return false;
        }
        return DoTeleport(handler, { node->x, node->y, node->z }, node->map_id);
    }

References DoTeleport(), LANG_COMMAND_GOTAXINODENOTFOUND, TaxiNodesEntry::map_id, ChatHandler::SendErrorMessage(), sTaxiNodesStore, TaxiNodesEntry::x, TaxiNodesEntry::y, and TaxiNodesEntry::z.

Referenced by GetCommands().

HandleGoTicketCommand()

static bool go_commandscript::HandleGoTicketCommand ( ChatHandler *  handler, uint32  ticketId  )

inlinestatic

    {
        GmTicket* ticket = sTicketMgr->GetTicket(ticketId);
        if (!ticket)
        {
            handler->SendSysMessage(LANG_COMMAND_TICKETNOTEXIST);
            return true;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
 
        // stop flight if need
        if (player->IsInFlight())
        {
            player->GetMotionMaster()->MovementExpired();
            player->CleanupAfterTaxiFlight();
        }
        // save only in non-flight case
        else
            player->SaveRecallPosition();
 
        ticket->TeleportTo(player);
        return true;
    }

References Player::CleanupAfterTaxiFlight(), Unit::GetMotionMaster(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Unit::IsInFlight(), LANG_COMMAND_TICKETNOTEXIST, MotionMaster::MovementExpired(), Player::SaveRecallPosition(), ChatHandler::SendSysMessage(), sTicketMgr, and GmTicket::TeleportTo().

Referenced by GetCommands().

HandleGoTriggerCommand()

static bool go_commandscript::HandleGoTriggerCommand ( ChatHandler *  handler, Variant< Hyperlink< areatrigger >, uint32 >  areaTriggerId  )

inlinestatic

    {
        AreaTrigger const* at = sObjectMgr->GetAreaTrigger(areaTriggerId);
        if (!at)
        {
            handler->SendErrorMessage(LANG_COMMAND_GOAREATRNOTFOUND, uint32(areaTriggerId));
            return false;
        }
        return DoTeleport(handler, { at->x, at->y, at->z }, at->map);
    }

References DoTeleport(), LANG_COMMAND_GOAREATRNOTFOUND, AreaTrigger::map, ChatHandler::SendErrorMessage(), sObjectMgr, AreaTrigger::x, AreaTrigger::y, and AreaTrigger::z.

Referenced by GetCommands().

HandleGoXYZCommand()

static bool go_commandscript::HandleGoXYZCommand ( ChatHandler *  handler, Tail  args  )

inlinestatic

Teleports the GM to the specified world coordinates, optionally specifying map ID and orientation.

Parameters

handler	The ChatHandler that is handling the command.
args	The coordinates to teleport to in format "x y z [mapId [orientation]]".

Returns

true The command was successful.

false The command was unsuccessful (show error or syntax)

    {
        std::wstring wInputCoords;
        if (!Utf8toWStr(args, wInputCoords))
        {
            return false;
        }
 
        // extract float and integer values from the input
        std::vector<float> locationValues;
        std::wregex floatRegex(L"(-?\\d+(?:\\.\\d+)?)");
        std::wsregex_iterator floatRegexIterator(wInputCoords.begin(), wInputCoords.end(), floatRegex);
        std::wsregex_iterator end;
        while (floatRegexIterator != end)
        {
            std::wsmatch match = *floatRegexIterator;
            std::wstring matchStr = match.str();
 
            // try to convert the match to a float
            try
            {
                locationValues.push_back(std::stof(matchStr));
            }
            // if the match is not a float, do not add it to the vector
            catch (std::invalid_argument const&){}
 
            ++floatRegexIterator;
        }
 
        // X and Y are required
        if (locationValues.size() < 2)
        {
            return false;
        }
 
        Player* player = handler->GetSession()->GetPlayer();
 
        uint32 mapId = locationValues.size() >= 4 ? uint32(locationValues[3]) : player->GetMapId();
 
        float x = locationValues[0];
        float y = locationValues[1];
 
        if (!sMapStore.LookupEntry(mapId) || !MapMgr::IsValidMapCoord(mapId, x, y))
        {
            handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, x, y, mapId);
            return false;
        }
 
        Map const* map = sMapMgr->CreateBaseMap(mapId);
 
        float z = locationValues.size() >= 3 ? locationValues[2] : std::max(map->GetHeight(x, y, MAX_HEIGHT), map->GetWaterLevel(x, y));
        // map ID (locationValues[3]) already handled above
        float o = locationValues.size() >= 5 ? locationValues[4] : player->GetOrientation();
 
        if (!MapMgr::IsValidMapCoord(mapId, x, y, z, o))
        {
            handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, x, y, mapId);
            return false;
        }
 
        return DoTeleport(handler, { x, y, z, o }, mapId);
    }

References DoTeleport(), Map::GetHeight(), WorldLocation::GetMapId(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Map::GetWaterLevel(), MapMgr::IsValidMapCoord(), LANG_INVALID_TARGET_COORD, MAX_HEIGHT, ChatHandler::SendErrorMessage(), sMapMgr, sMapStore, and Utf8toWStr().

Referenced by GetCommands().

HandleGoZoneXYCommand()

static bool go_commandscript::HandleGoZoneXYCommand ( ChatHandler *  handler, float  x, float  y, Optional< Variant< Hyperlink< area >, uint32 > >  areaIdArg  )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        uint32 areaId = areaIdArg ? *areaIdArg : player->GetZoneId();
 
        AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaId);
 
        if (x < 0 || x > 100 || y < 0 || y > 100 || !areaEntry)
        {
            handler->SendErrorMessage(LANG_INVALID_ZONE_COORD, x, y, areaId);
            return false;
        }
 
        // update to parent zone if exist (client map show only zones without parents)
        AreaTableEntry const* zoneEntry = areaEntry->zone ? sAreaTableStore.LookupEntry(areaEntry->zone) : areaEntry;
                ASSERT(zoneEntry);
 
        Map const* map = sMapMgr->CreateBaseMap(zoneEntry->mapid);
 
        if (map->Instanceable())
        {
            handler->SendErrorMessage(LANG_INVALID_ZONE_MAP, areaEntry->ID, areaEntry->area_name[handler->GetSessionDbcLocale()], map->GetId(), map->GetMapName());
            return false;
        }
 
        Zone2MapCoordinates(x, y, zoneEntry->ID);
 
        if (!MapMgr::IsValidMapCoord(zoneEntry->mapid, x, y))
        {
            handler->SendErrorMessage(LANG_INVALID_TARGET_COORD, x, y, zoneEntry->mapid);
            return false;
        }
 
        // stop flight if need
        if (player->IsInFlight())
        {
            player->GetMotionMaster()->MovementExpired();
            player->CleanupAfterTaxiFlight();
        }
        // save only in non-flight case
        else
            player->SaveRecallPosition();
 
        float z = std::max(map->GetHeight(x, y, MAX_HEIGHT), map->GetWaterLevel(x, y));
 
        player->TeleportTo(zoneEntry->mapid, x, y, z, player->GetOrientation());
        return true;
    }

References AreaTableEntry::area_name, ASSERT, Player::CleanupAfterTaxiFlight(), Map::GetHeight(), Map::GetId(), Map::GetMapName(), Unit::GetMotionMaster(), Position::GetOrientation(), WorldSession::GetPlayer(), ChatHandler::GetSession(), ChatHandler::GetSessionDbcLocale(), Map::GetWaterLevel(), WorldObject::GetZoneId(), AreaTableEntry::ID, Map::Instanceable(), Unit::IsInFlight(), MapMgr::IsValidMapCoord(), LANG_INVALID_TARGET_COORD, LANG_INVALID_ZONE_COORD, LANG_INVALID_ZONE_MAP, AreaTableEntry::mapid, MAX_HEIGHT, MotionMaster::MovementExpired(), sAreaTableStore, Player::SaveRecallPosition(), ChatHandler::SendErrorMessage(), sMapMgr, Player::TeleportTo(), AreaTableEntry::zone, and Zone2MapCoordinates().

Referenced by GetCommands().