wp_commandscript Class Reference

Inheritance diagram for wp_commandscript:

Public Member Functions
	wp_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	HandleWpAddCommand (ChatHandler *handler, const char *args)
static bool	HandleWpLoadCommand (ChatHandler *handler, const char *args)
static bool	HandleWpReloadCommand (ChatHandler *handler, const char *args)
static bool	HandleWpUnLoadCommand (ChatHandler *handler, const char *)
static bool	HandleWpEventCommand (ChatHandler *handler, const char *args)
static bool	HandleWpModifyCommand (ChatHandler *handler, const char *args)
static bool	HandleWpShowCommand (ChatHandler *handler, const char *args)

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

wp_commandscript()

wp_commandscript::wp_commandscript ( )

inline

: CommandScript("wp_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable wp_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable wpCommandTable =
        {
            { "add",        HandleWpAddCommand,      rbac::RBAC_PERM_COMMAND_WP_ADD,    Console::No },
            { "event",      HandleWpEventCommand,    rbac::RBAC_PERM_COMMAND_WP_EVENT,  Console::No },
            { "load",       HandleWpLoadCommand,     rbac::RBAC_PERM_COMMAND_WP_LOAD,   Console::No },
            { "modify",     HandleWpModifyCommand,   rbac::RBAC_PERM_COMMAND_WP_MODIFY, Console::No },
            { "unload",     HandleWpUnLoadCommand,   rbac::RBAC_PERM_COMMAND_WP_UNLOAD, Console::No },
            { "reload",     HandleWpReloadCommand,   rbac::RBAC_PERM_COMMAND_WP_RELOAD, Console::No },
            { "show",       HandleWpShowCommand,     rbac::RBAC_PERM_COMMAND_WP_SHOW,   Console::No }
        };
        static ChatCommandTable commandTable =
        {
            { "wp", wpCommandTable }
        };
        return commandTable;
    }

References HandleWpAddCommand(), HandleWpEventCommand(), HandleWpLoadCommand(), HandleWpModifyCommand(), HandleWpReloadCommand(), HandleWpShowCommand(), HandleWpUnLoadCommand(), rbac::RBAC_PERM_COMMAND_WP_ADD, rbac::RBAC_PERM_COMMAND_WP_EVENT, rbac::RBAC_PERM_COMMAND_WP_LOAD, rbac::RBAC_PERM_COMMAND_WP_MODIFY, rbac::RBAC_PERM_COMMAND_WP_RELOAD, rbac::RBAC_PERM_COMMAND_WP_SHOW, and rbac::RBAC_PERM_COMMAND_WP_UNLOAD.

HandleWpAddCommand()

static bool wp_commandscript::HandleWpAddCommand ( ChatHandler *  handler, const char *  args  )

inlinestatic

Add a waypoint to a creature.

The user can either select an npc or provide its GUID.

The user can even select a visual waypoint - then the new waypoint is placed after the selected one - this makes insertion of new waypoints possible.

eg: .wp add 12345 -> adds a waypoint to the npc with the GUID 12345

.wp add -> adds a waypoint to the currently selected creature

Parameters

args	if the user did not provide a GUID, it is nullptr

Returns

true - command did succeed, false - something went wrong

    {
        // optional
        char* path_number = nullptr;
        uint32 pathid = 0;
 
        if (*args)
            path_number = strtok((char*)args, " ");
 
        uint32 point = 0;
        Creature* target = handler->getSelectedCreature();
 
        if (!path_number)
        {
            if (target)
                pathid = target->GetWaypointPath();
            else
            {
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_MAX_ID);
 
                PreparedQueryResult result = WorldDatabase.Query(stmt);
 
                uint32 maxpathid = result->Fetch()->Get<int32>();
                pathid = maxpathid + 1;
                handler->PSendSysMessage("{}{}|r", "|cff00ff00", "New path started.");
            }
        }
        else
            pathid = atoi(path_number);
 
        // path_id -> ID of the Path
        // point   -> number of the waypoint (if not 0)
 
        if (!pathid)
        {
            handler->PSendSysMessage("{}{}|r", "|cffff33ff", "Current creature haven't loaded path.");
            return true;
        }
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_MAX_POINT);
        stmt->SetData(0, pathid);
        PreparedQueryResult result = WorldDatabase.Query(stmt);
 
        if (result)
            point = (*result)[0].Get<uint32>();
 
        Player* player = handler->GetSession()->GetPlayer();
        //Map* map = player->GetMap();
 
        stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_WAYPOINT_DATA);
 
        stmt->SetData(0, pathid);
        stmt->SetData(1, point + 1);
        stmt->SetData(2, player->GetPositionX());
        stmt->SetData(3, player->GetPositionY());
        stmt->SetData(4, player->GetPositionZ());
 
        WorldDatabase.Execute(stmt);
 
        handler->PSendSysMessage("{}{}{}{}{}{}|r", "|cff00ff00", "PathID: |r|cff00ffff", pathid, "|r|cff00ff00: Waypoint |r|cff00ffff", point + 1, "|r|cff00ff00 created. ");
        return true;
    }                                                           // HandleWpAddCommand

References WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetWaypointPath(), ChatHandler::PSendSysMessage(), PreparedStatementBase::SetData(), WORLD_INS_WAYPOINT_DATA, WORLD_SEL_WAYPOINT_DATA_MAX_ID, WORLD_SEL_WAYPOINT_DATA_MAX_POINT, and WorldDatabase.

Referenced by GetCommands().

HandleWpEventCommand()

static bool wp_commandscript::HandleWpEventCommand ( ChatHandler *  handler, const char *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        char* show_str = strtok((char*)args, " ");
        std::string show = show_str;
 
        // Check
        if ((show != "add") && (show != "mod") && (show != "del") && (show != "listid"))
            return false;
 
        char* arg_id = strtok(nullptr, " ");
        uint32 id = 0;
 
        if (show == "add")
        {
            if (arg_id)
                id = atoi(arg_id);
 
            if (id)
            {
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID);
                stmt->SetData(0, id);
                PreparedQueryResult result = WorldDatabase.Query(stmt);
 
                if (!result)
                {
                    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_WAYPOINT_SCRIPT);
 
                    stmt->SetData(0, id);
 
                    WorldDatabase.Execute(stmt);
 
                    handler->PSendSysMessage("{}{}{}|r", "|cff00ff00", "Wp Event: New waypoint event added: ", id);
                }
                else
                    handler->PSendSysMessage("|cff00ff00Wp Event: You have choosed an existing waypoint script guid: {}|r", id);
            }
            else
            {
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPTS_MAX_ID);
 
                PreparedQueryResult result = WorldDatabase.Query(stmt);
 
                id = result->Fetch()->Get<uint32>();
 
                stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_WAYPOINT_SCRIPT);
 
                stmt->SetData(0, id + 1);
 
                WorldDatabase.Execute(stmt);
 
                handler->PSendSysMessage("{}{}{}|r", "|cff00ff00", "Wp Event: New waypoint event added: |r|cff00ffff", id + 1);
            }
 
            return true;
        }
 
        if (show == "listid")
        {
            if (!arg_id)
            {
                handler->PSendSysMessage("{}{}|r", "|cff33ffff", "Wp Event: You must provide waypoint script id.");
                return true;
            }
 
            id = atoi(arg_id);
 
            uint32 a2, a3, a4, a5, a6;
            float a8, a9, a10, a11;
            char const* a7;
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPT_BY_ID);
            stmt->SetData(0, id);
            PreparedQueryResult result = WorldDatabase.Query(stmt);
 
            if (!result)
            {
                handler->PSendSysMessage("{}{}{}|r", "|cff33ffff", "Wp Event: No waypoint scripts found on id: ", id);
                return true;
            }
 
            Field* fields;
 
            do
            {
                fields = result->Fetch();
                a2 = fields[0].Get<uint32>();
                a3 = fields[1].Get<uint32>();
                a4 = fields[2].Get<uint32>();
                a5 = fields[3].Get<uint32>();
                a6 = fields[4].Get<uint32>();
                a7 = fields[5].Get<std::string>().c_str();
                a8 = fields[6].Get<float>();
                a9 = fields[7].Get<float>();
                a10 = fields[8].Get<float>();
                a11 = fields[9].Get<float>();
 
                handler->PSendSysMessage("|cffff33ffid:|r|cff00ffff {}|r|cff00ff00, guid: |r|cff00ffff{}|r|cff00ff00, delay: |r|cff00ffff{}|r|cff00ff00, command: |r|cff00ffff{}|r|cff00ff00, datalong: |r|cff00ffff{}|r|cff00ff00, datalong2: |r|cff00ffff{}|r|cff00ff00, datatext: |r|cff00ffff{}|r|cff00ff00, posx: |r|cff00ffff{}|r|cff00ff00, posy: |r|cff00ffff{}|r|cff00ff00, posz: |r|cff00ffff{}|r|cff00ff00, orientation: |r|cff00ffff{}|r", id, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
            } while (result->NextRow());
        }
 
        if (show == "del")
        {
            if (!arg_id)
            {
                handler->SendSysMessage("|cffff33ffERROR: Waypoint script guid not present.|r");
                return true;
            }
 
            id = atoi(arg_id);
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID);
 
            stmt->SetData(0, id);
 
            PreparedQueryResult result = WorldDatabase.Query(stmt);
 
            if (result)
            {
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_WAYPOINT_SCRIPT);
 
                stmt->SetData(0, id);
 
                WorldDatabase.Execute(stmt);
 
                handler->PSendSysMessage("{}{}{}|r", "|cff00ff00", "Wp Event: Waypoint script removed: ", id);
            }
            else
                handler->PSendSysMessage("|cffff33ffWp Event: ERROR: you have selected a non existing script: {}|r", id);
 
            return true;
        }
 
        if (show == "mod")
        {
            if (!arg_id)
            {
                handler->SendSysMessage("|cffff33ffERROR: Waypoint script guid not present.|r");
                return true;
            }
 
            id = atoi(arg_id);
 
            if (!id)
            {
                handler->SendSysMessage("|cffff33ffERROR: No vallid waypoint script id not present.|r");
                return true;
            }
 
            char* arg_2 = strtok(nullptr, " ");
 
            if (!arg_2)
            {
                handler->SendSysMessage("|cffff33ffERROR: No argument present.|r");
                return true;
            }
 
            std::string arg_string  = arg_2;
 
            if ((arg_string != "setid") && (arg_string != "delay") && (arg_string != "command")
                    && (arg_string != "datalong") && (arg_string != "datalong2") && (arg_string != "dataint") && (arg_string != "posx")
                    && (arg_string != "posy") && (arg_string != "posz") && (arg_string != "orientation"))
            {
                handler->SendSysMessage("|cffff33ffERROR: No valid argument present.|r");
                return true;
            }
 
            char* arg_3;
            std::string arg_str_2 = arg_2;
            arg_3 = strtok(nullptr, " ");
 
            if (!arg_3)
            {
                handler->SendSysMessage("|cffff33ffERROR: No additional argument present.|r");
                return true;
            }
 
            if (arg_str_2 == "setid")
            {
                uint32 newid = atoi(arg_3);
                handler->PSendSysMessage("{}{}|r|cff00ffff{}|r|cff00ff00{}|r|cff00ffff{}|r", "|cff00ff00", "Wp Event: Wypoint scipt guid: ", newid, " id changed: ", id);
 
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_SCRIPT_ID);
 
                stmt->SetData(0, newid);
                stmt->SetData(1, id);
 
                WorldDatabase.Execute(stmt);
 
                return true;
            }
            else
            {
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID);
                stmt->SetData(0, id);
                PreparedQueryResult result = WorldDatabase.Query(stmt);
 
                if (!result)
                {
                    handler->SendSysMessage("|cffff33ffERROR: You have selected an non existing waypoint script guid.|r");
                    return true;
                }
 
                if (arg_str_2 == "posx")
                {
                    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_SCRIPT_X);
 
                    stmt->SetData(0, float(atof(arg_3)));
                    stmt->SetData(1, id);
 
                    WorldDatabase.Execute(stmt);
 
                    handler->PSendSysMessage("|cff00ff00Waypoint script:|r|cff00ffff {}|r|cff00ff00 position_x updated.|r", id);
                    return true;
                }
                else if (arg_str_2 == "posy")
                {
                    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_SCRIPT_Y);
 
                    stmt->SetData(0, float(atof(arg_3)));
                    stmt->SetData(1, id);
 
                    WorldDatabase.Execute(stmt);
 
                    handler->PSendSysMessage("|cff00ff00Waypoint script: {} position_y updated.|r", id);
                    return true;
                }
                else if (arg_str_2 == "posz")
                {
                    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_SCRIPT_Z);
 
                    stmt->SetData(0, float(atof(arg_3)));
                    stmt->SetData(1, id);
 
                    WorldDatabase.Execute(stmt);
 
                    handler->PSendSysMessage("|cff00ff00Waypoint script: |r|cff00ffff{}|r|cff00ff00 position_z updated.|r", id);
                    return true;
                }
                else if (arg_str_2 == "orientation")
                {
                    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_SCRIPT_O);
 
                    stmt->SetData(0, float(atof(arg_3)));
                    stmt->SetData(1, id);
 
                    WorldDatabase.Execute(stmt);
 
                    handler->PSendSysMessage("|cff00ff00Waypoint script: |r|cff00ffff{}|r|cff00ff00 orientation updated.|r", id);
                    return true;
                }
                else if (arg_str_2 == "dataint")
                {
                    WorldDatabase.Execute("UPDATE waypoint_scripts SET {}='{}' WHERE guid='{}'", arg_2, atoi(arg_3), id); // Query can't be a prepared statement
 
                    handler->PSendSysMessage("|cff00ff00Waypoint script: |r|cff00ffff{}|r|cff00ff00 dataint updated.|r", id);
                    return true;
                }
                else
                {
                    std::string arg_str_3 = arg_3;
                    WorldDatabase.EscapeString(arg_str_3);
                    WorldDatabase.Execute("UPDATE waypoint_scripts SET {}='{}' WHERE guid='{}'", arg_2, arg_str_3, id); // Query can't be a prepared statement
                }
            }
            handler->PSendSysMessage("{}{}|r|cff00ffff{}:|r|cff00ff00 {} {}|r", "|cff00ff00", "Waypoint script:", id, arg_2, "updated.");
        }
        return true;
    }

References Field::Get(), ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), WORLD_DEL_WAYPOINT_SCRIPT, WORLD_INS_WAYPOINT_SCRIPT, WORLD_SEL_WAYPOINT_SCRIPT_BY_ID, WORLD_SEL_WAYPOINT_SCRIPT_ID_BY_GUID, WORLD_SEL_WAYPOINT_SCRIPTS_MAX_ID, WORLD_UPD_WAYPOINT_SCRIPT_ID, WORLD_UPD_WAYPOINT_SCRIPT_O, WORLD_UPD_WAYPOINT_SCRIPT_X, WORLD_UPD_WAYPOINT_SCRIPT_Y, WORLD_UPD_WAYPOINT_SCRIPT_Z, and WorldDatabase.

Referenced by GetCommands().

HandleWpLoadCommand()

static bool wp_commandscript::HandleWpLoadCommand ( ChatHandler *  handler, const char *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        // optional
        char* path_number = nullptr;
 
        if (*args)
            path_number = strtok((char*)args, " ");
 
        uint32 pathid = 0;
        ObjectGuid::LowType guidLow = 0;
        Creature* target = handler->getSelectedCreature();
 
        // Did player provide a path_id?
        if (!path_number)
            return false;
 
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        if (target->GetEntry() == 1)
        {
            handler->SendErrorMessage("{}{}|r", "|cffff33ff", "You want to load path to a waypoint? Aren't you?");
            return false;
        }
 
        pathid = atoi(path_number);
 
        if (!pathid)
        {
            handler->PSendSysMessage("{}{}|r", "|cffff33ff", "No valid path number provided.");
            return true;
        }
 
        guidLow = target->GetSpawnId();
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_CREATURE_ADDON_BY_GUID);
 
        stmt->SetData(0, guidLow);
 
        PreparedQueryResult result = WorldDatabase.Query(stmt);
 
        if (result)
        {
            stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_ADDON_PATH);
 
            stmt->SetData(0, pathid);
            stmt->SetData(1, guidLow);
        }
        else
        {
            stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_CREATURE_ADDON);
 
            stmt->SetData(0, guidLow);
            stmt->SetData(1, pathid);
        }
 
        WorldDatabase.Execute(stmt);
 
        stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_MOVEMENT_TYPE);
 
        stmt->SetData(0, uint8(WAYPOINT_MOTION_TYPE));
        stmt->SetData(1, guidLow);
 
        WorldDatabase.Execute(stmt);
 
        target->LoadPath(pathid);
        target->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
        target->GetMotionMaster()->Initialize();
        target->Say("Path loaded.", LANG_UNIVERSAL);
 
        return true;
    }

References Object::GetEntry(), Unit::GetMotionMaster(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), MotionMaster::Initialize(), LANG_SELECT_CREATURE, LANG_UNIVERSAL, Creature::LoadPath(), ChatHandler::PSendSysMessage(), Unit::Say(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), Creature::SetDefaultMovementType(), WAYPOINT_MOTION_TYPE, WORLD_INS_CREATURE_ADDON, WORLD_SEL_CREATURE_ADDON_BY_GUID, WORLD_UPD_CREATURE_ADDON_PATH, WORLD_UPD_CREATURE_MOVEMENT_TYPE, and WorldDatabase.

Referenced by GetCommands().

HandleWpModifyCommand()

static bool wp_commandscript::HandleWpModifyCommand ( ChatHandler *  handler, const char *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        // first arg: add del text emote spell waittime move
        char* show_str = strtok((char*)args, " ");
        if (!show_str)
        {
            return false;
        }
 
        std::string show = show_str;
        // Check
        // Remember: "show" must also be the name of a column!
        if ((show != "delay") && (show != "action") && (show != "action_chance")
                && (show != "move_type") && (show != "del") && (show != "move") && (show != "wpadd")
           )
        {
            return false;
        }
 
        // Next arg is: <PATHID> <WPNUM> <ARGUMENT>
        char* arg_str = nullptr;
 
        // Did user provide a GUID
        // or did the user select a creature?
        // -> variable lowguid is filled with the GUID of the NPC
        uint32 pathid = 0;
        uint32 point = 0;
        Creature* target = handler->getSelectedCreature();
 
        if (!target || target->GetEntry() != VISUAL_WAYPOINT)
        {
            handler->SendSysMessage("|cffff33ffERROR: You must select a waypoint.|r");
            return false;
        }
 
        // The visual waypoint
        ObjectGuid::LowType wpSpawnId = target->GetSpawnId();
 
        // User did select a visual waypoint?
 
        // Check the creature
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_BY_WPGUID);
        stmt->SetData(0, wpSpawnId);
        PreparedQueryResult result = WorldDatabase.Query(stmt);
 
        if (!result)
        {
            handler->PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, wpSpawnId);
            // Select waypoint number from database
            // Since we compare float values, we have to deal with
            // some difficulties.
            // Here we search for all waypoints that only differ in one from 1 thousand
            // (0.001) - There is no other way to compare C++ floats with mySQL floats
            // See also: http://dev.mysql.com/doc/refman/5.0/en/problems-with-float.html
            std::string maxDiff = "0.01";
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_BY_POS);
            stmt->SetData(0, target->GetPositionX());
            stmt->SetData(1, maxDiff);
            stmt->SetData(2, target->GetPositionY());
            stmt->SetData(3, maxDiff);
            stmt->SetData(4, target->GetPositionZ());
            stmt->SetData(5, maxDiff);
            PreparedQueryResult result = WorldDatabase.Query(stmt);
 
            if (!result)
            {
                handler->PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, wpSpawnId);
                return true;
            }
        }
 
        do
        {
            Field* fields = result->Fetch();
            pathid = fields[0].Get<uint32>();
            point  = fields[1].Get<uint32>();
        } while (result->NextRow());
 
        // We have the waypoint number and the GUID of the "master npc"
        // Text is enclosed in "<>", all other arguments not
        arg_str = strtok((char*)nullptr, " ");
 
        // Check for argument
        if (show != "del" && show != "move" && arg_str == nullptr)
        {
            handler->PSendSysMessage(LANG_WAYPOINT_ARGUMENTREQ, show_str);
            return false;
        }
 
        if (show == "del")
        {
            handler->PSendSysMessage("|cff00ff00DEBUG: wp modify del, PathID: |r|cff00ffff{}|r", pathid);
 
            if (wpSpawnId != 0)
                if (Creature* wpCreature = handler->GetSession()->GetPlayer()->GetMap()->GetCreature(target->GetGUID()))
                {
                    wpCreature->CombatStop();
                    wpCreature->DeleteFromDB();
                    wpCreature->AddObjectToRemoveList();
                }
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_WAYPOINT_DATA);
            stmt->SetData(0, pathid);
            stmt->SetData(1, point);
 
            WorldDatabase.Execute(stmt);
 
            stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_DATA_POINT);
            stmt->SetData(0, pathid);
            stmt->SetData(1, point);
 
            WorldDatabase.Execute(stmt);
 
            handler->PSendSysMessage(LANG_WAYPOINT_REMOVED);
            return true;
        }                                                       // del
 
        if (show == "move")
        {
            handler->PSendSysMessage("|cff00ff00DEBUG: wp move, PathID: |r|cff00ffff{}|r", pathid);
 
            Player* chr = handler->GetSession()->GetPlayer();
            Map* map = chr->GetMap();
            {
                // What to do:
                // Move the visual spawnpoint
                // Respawn the owner of the waypoints
                if (wpSpawnId != 0)
                {
                    if (Creature* wpCreature = map->GetCreature(target->GetGUID()))
                    {
                        wpCreature->CombatStop();
                        wpCreature->DeleteFromDB();
                        wpCreature->AddObjectToRemoveList();
                    }
                    // re-create
                    Creature* wpCreature2 = new Creature;
                    if (!wpCreature2->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, chr->GetPhaseMaskForSpawn(), VISUAL_WAYPOINT, 0, chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), chr->GetOrientation()))
                    {
                        handler->PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, VISUAL_WAYPOINT);
                        delete wpCreature2;
                        wpCreature2 = nullptr;
                        return false;
                    }
 
                    wpCreature2->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), chr->GetPhaseMaskForSpawn());
                    // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
                    //TODO: Should we first use "Create" then use "LoadFromDB"?
                    if (!wpCreature2->LoadCreatureFromDB(wpCreature2->GetSpawnId(), map, true, true))
                    {
                        handler->PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, VISUAL_WAYPOINT);
                        delete wpCreature2;
                        wpCreature2 = nullptr;
                        return false;
                    }
                    //sMapMgr->GetMap(npcCreature->GetMapId())->Add(wpCreature2);
                }
 
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_DATA_POSITION);
 
                stmt->SetData(0, chr->GetPositionX());
                stmt->SetData(1, chr->GetPositionY());
                stmt->SetData(2, chr->GetPositionZ());
                stmt->SetData(3, pathid);
                stmt->SetData(4, point);
 
                WorldDatabase.Execute(stmt);
 
                handler->PSendSysMessage(LANG_WAYPOINT_CHANGED);
            }
            return true;
        }                                                       // move
 
        const char* text = arg_str;
 
        if (text == 0)
        {
            // show_str check for present in list of correct values, no sql injection possible
            WorldDatabase.Execute("UPDATE waypoint_data SET {}=nullptr WHERE id='{}' AND point='{}'", show_str, pathid, point); // Query can't be a prepared statement
        }
        else
        {
            // show_str check for present in list of correct values, no sql injection possible
            std::string text2 = text;
            WorldDatabase.EscapeString(text2);
            WorldDatabase.Execute("UPDATE waypoint_data SET {}='{}' WHERE id='{}' AND point='{}'", show_str, text2, pathid, point); // Query can't be a prepared statement
        }
 
        handler->PSendSysMessage(LANG_WAYPOINT_CHANGED_NO, show_str);
        return true;
    }

References Map::AddObjectToRemoveList(), Creature::Create(), Map::GenerateLowGuid(), Field::Get(), Map::GetCreature(), Object::GetEntry(), Object::GetGUID(), Map::GetId(), WorldObject::GetMap(), Position::GetOrientation(), Player::GetPhaseMaskForSpawn(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetSpawnId(), Map::GetSpawnMode(), LANG_WAYPOINT_ARGUMENTREQ, LANG_WAYPOINT_CHANGED, LANG_WAYPOINT_CHANGED_NO, LANG_WAYPOINT_NOTFOUNDDBPROBLEM, LANG_WAYPOINT_NOTFOUNDSEARCH, LANG_WAYPOINT_REMOVED, LANG_WAYPOINT_VP_NOTCREATED, Creature::LoadCreatureFromDB(), ChatHandler::PSendSysMessage(), Creature::SaveToDB(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), Unit, VISUAL_WAYPOINT, WORLD_DEL_WAYPOINT_DATA, WORLD_SEL_WAYPOINT_DATA_BY_POS, WORLD_SEL_WAYPOINT_DATA_BY_WPGUID, WORLD_UPD_WAYPOINT_DATA_POINT, WORLD_UPD_WAYPOINT_DATA_POSITION, and WorldDatabase.

Referenced by GetCommands().

HandleWpReloadCommand()

static bool wp_commandscript::HandleWpReloadCommand ( ChatHandler *  handler, const char *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        uint32 id = atoi(args);
 
        if (!id)
            return false;
 
        handler->PSendSysMessage("{}{}|r|cff00ffff{}|r", "|cff00ff00", "Loading Path: ", id);
        sWaypointMgr->ReloadPath(id);
        return true;
    }

References ChatHandler::PSendSysMessage(), and sWaypointMgr.

Referenced by GetCommands().

HandleWpShowCommand()

static bool wp_commandscript::HandleWpShowCommand ( ChatHandler *  handler, const char *  args  )

inlinestatic

    {
        if (!*args)
            return false;
 
        // first arg: on, off, first, last
        char* show_str = strtok((char*)args, " ");
        if (!show_str)
            return false;
 
        // second arg: GUID (optional, if a creature is selected)
        char* guid_str = strtok((char*)nullptr, " ");
 
        uint32 pathid = 0;
        Creature* target = handler->getSelectedCreature();
 
        // Did player provide a PathID?
 
        if (!guid_str)
        {
            // No PathID provided
            // -> Player must have selected a creature
 
            if (!target)
            {
                handler->SendErrorMessage(LANG_SELECT_CREATURE);
                return false;
            }
 
            pathid = target->GetWaypointPath();
        }
        else
        {
            // PathID provided
            // Warn if player also selected a creature
            // -> Creature selection is ignored <-
            if (target)
                handler->SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
 
            pathid = atoi((char*)guid_str);
        }
 
        std::string show = show_str;
 
        //handler->PSendSysMessage("wpshow - show: {}", show);
 
        // Show info for the selected waypoint
        if (show == "info")
        {
            // Check if the user did specify a visual waypoint
            if (!target || target->GetEntry() != VISUAL_WAYPOINT)
            {
                handler->SendErrorMessage(LANG_WAYPOINT_VP_SELECT);
                return false;
            }
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_ALL_BY_WPGUID);
 
            stmt->SetData(0, target->GetSpawnId());
 
            PreparedQueryResult result = WorldDatabase.Query(stmt);
 
            if (!result)
            {
                handler->SendErrorMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, target->GetSpawnId());
                return false;
            }
 
            handler->SendSysMessage("|cff00ffffDEBUG: wp show info:|r");
            do
            {
                Field* fields = result->Fetch();
                pathid                  = fields[0].Get<uint32>();
                uint32 point            = fields[1].Get<uint32>();
                uint32 delay            = fields[2].Get<uint32>();
                uint32 flag             = fields[3].Get<uint32>();
                uint32 ev_id            = fields[4].Get<uint32>();
                uint32 ev_chance        = fields[5].Get<uint32>();
 
                handler->PSendSysMessage("|cff00ff00Show info: for current point: |r|cff00ffff{}|r|cff00ff00, Path ID: |r|cff00ffff{}|r", point, pathid);
                handler->PSendSysMessage("|cff00ff00Show info: delay: |r|cff00ffff{}|r", delay);
                handler->PSendSysMessage("|cff00ff00Show info: Move flag: |r|cff00ffff{}|r", flag);
                handler->PSendSysMessage("|cff00ff00Show info: Waypoint event: |r|cff00ffff{}|r", ev_id);
                handler->PSendSysMessage("|cff00ff00Show info: Event chance: |r|cff00ffff{}|r", ev_chance);
            } while (result->NextRow());
 
            return true;
        }
 
        if (show == "on")
        {
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_POS_BY_ID);
 
            stmt->SetData(0, pathid);
 
            PreparedQueryResult result = WorldDatabase.Query(stmt);
 
            if (!result)
            {
                handler->SendErrorMessage("|cffff33ffPath no found.|r");
                return false;
            }
 
            handler->PSendSysMessage("|cff00ff00DEBUG: wp on, PathID: |cff00ffff{}|r", pathid);
 
            // Delete all visuals for this NPC
            stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_WPGUID_BY_ID);
 
            stmt->SetData(0, pathid);
 
            PreparedQueryResult result2 = WorldDatabase.Query(stmt);
 
            if (result2)
            {
                bool hasError = false;
                do
                {
                    Field* fields = result2->Fetch();
                    uint32 wpguid = fields[0].Get<uint32>();
                    Creature* creature = handler->GetSession()->GetPlayer()->GetMap()->GetCreature(ObjectGuid::Create<HighGuid::Unit>(VISUAL_WAYPOINT, wpguid));
 
                    if (!creature)
                    {
                        handler->PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, wpguid);
                        hasError = true;
 
                        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_CREATURE);
                        stmt->SetData(0, wpguid);
 
                        WorldDatabase.Execute(stmt);
                    }
                    else
                    {
                        creature->CombatStop();
                        creature->DeleteFromDB();
                        creature->AddObjectToRemoveList();
                    }
                } while (result2->NextRow());
 
                if (hasError)
                {
                    handler->PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
                    handler->PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
                    handler->PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
                }
            }
 
            do
            {
                Field* fields = result->Fetch();
                uint32 point    = fields[0].Get<uint32>();
                float x         = fields[1].Get<float>();
                float y         = fields[2].Get<float>();
                float z         = fields[3].Get<float>();
 
                uint32 id = VISUAL_WAYPOINT;
 
                Player* chr = handler->GetSession()->GetPlayer();
                Map* map = chr->GetMap();
                float o = chr->GetOrientation();
 
                Creature* wpCreature = new Creature;
                if (!wpCreature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, chr->GetPhaseMaskForSpawn(), id, 0, x, y, z, o))
                {
                    handler->PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
                    delete wpCreature;
                    return false;
                }
 
                wpCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), chr->GetPhaseMaskForSpawn());
 
                // Set "wpguid" column to the visual waypoint
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_DATA_WPGUID);
                stmt->SetData(0, wpCreature->GetSpawnId());
                stmt->SetData(1, pathid);
                stmt->SetData(2, point);
 
                WorldDatabase.Execute(stmt);
 
                // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
                if (!wpCreature->LoadCreatureFromDB(wpCreature->GetSpawnId(), map, true, true))
                {
                    handler->PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
                    delete wpCreature;
                    return false;
                }
 
                if (target)
                {
                    wpCreature->SetDisplayId(target->GetDisplayId());
                    wpCreature->SetObjectScale(0.5f);
                    wpCreature->SetLevel(point > STRONG_MAX_LEVEL ? STRONG_MAX_LEVEL : point);
                }
            } while (result->NextRow());
 
            handler->SendSysMessage("|cff00ff00Showing the current creature's path.|r");
            return true;
        }
 
        if (show == "first")
        {
            handler->PSendSysMessage("|cff00ff00DEBUG: wp first, GUID: {}|r", pathid);
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_POS_FIRST_BY_ID);
            stmt->SetData(0, pathid);
 
            PreparedQueryResult result = WorldDatabase.Query(stmt);
            if (!result)
            {
                handler->SendErrorMessage(LANG_WAYPOINT_NOTFOUND, pathid);
                return false;
            }
 
            Field* fields = result->Fetch();
            float x         = fields[0].Get<float>();
            float y         = fields[1].Get<float>();
            float z         = fields[2].Get<float>();
            uint32 id = VISUAL_WAYPOINT;
 
            Player* chr = handler->GetSession()->GetPlayer();
            float o = chr->GetOrientation();
            Map* map = chr->GetMap();
 
            Creature* creature = new Creature;
            if (!creature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, chr->GetPhaseMaskForSpawn(), id, 0, x, y, z, o))
            {
                handler->PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
                delete creature;
                return false;
            }
 
            creature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), chr->GetPhaseMaskForSpawn());
            if (!creature->LoadCreatureFromDB(creature->GetSpawnId(), map, true, true))
            {
                handler->PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
                delete creature;
                return false;
            }
 
            if (target)
            {
                creature->SetDisplayId(target->GetDisplayId());
                creature->SetObjectScale(0.5f);
            }
 
            return true;
        }
 
        if (show == "last")
        {
            handler->PSendSysMessage("|cff00ff00DEBUG: wp last, PathID: |r|cff00ffff{}|r", pathid);
 
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_WAYPOINT_DATA_POS_LAST_BY_ID);
            stmt->SetData(0, pathid);
 
            PreparedQueryResult result = WorldDatabase.Query(stmt);
            if (!result)
            {
                handler->SendErrorMessage(LANG_WAYPOINT_NOTFOUNDLAST, pathid);
                return false;
            }
 
            Field* fields = result->Fetch();
            float x = fields[0].Get<float>();
            float y = fields[1].Get<float>();
            float z = fields[2].Get<float>();
            float o = fields[3].Get<float>();
            uint32 id = VISUAL_WAYPOINT;
 
            Player* chr = handler->GetSession()->GetPlayer();
            Map* map = chr->GetMap();
 
            Creature* creature = new Creature;
            if (!creature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, chr->GetPhaseMaskForSpawn(), id, 0, x, y, z, o))
            {
                handler->PSendSysMessage(LANG_WAYPOINT_NOTCREATED, id);
                delete creature;
                return false;
            }
 
            creature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), chr->GetPhaseMaskForSpawn());
            if (!creature->LoadCreatureFromDB(creature->GetSpawnId(), map, true, true))
            {
                handler->PSendSysMessage(LANG_WAYPOINT_NOTCREATED, id);
                delete creature;
                return false;
            }
 
            if (target)
            {
                creature->SetDisplayId(target->GetDisplayId());
                creature->SetObjectScale(0.5f);
            }
 
            return true;
        }
 
        if (show == "off")
        {
            WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_CREATURE_BY_ID);
            stmt->SetArguments(1, 1, 1);
 
            PreparedQueryResult result = WorldDatabase.Query(stmt);
            if (!result)
            {
                handler->SendErrorMessage(LANG_WAYPOINT_VP_NOTFOUND);
                return false;
            }
 
            bool hasError = false;
 
            do
            {
                Field* fields = result->Fetch();
                ObjectGuid::LowType guid = fields[0].Get<uint32>();
                Creature* creature = handler->GetSession()->GetPlayer()->GetMap()->GetCreature(ObjectGuid::Create<HighGuid::Unit>(VISUAL_WAYPOINT, guid));
                if (!creature)
                {
                    handler->PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, guid);
                    hasError = true;
 
                    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_CREATURE);
 
                    stmt->SetData(0, guid);
 
                    WorldDatabase.Execute(stmt);
                }
                else
                {
                    creature->CombatStop();
                    creature->DeleteFromDB();
                    creature->AddObjectToRemoveList();
                }
            } while (result->NextRow());
 
            // set "wpguid" column to "empty" - no visual waypoint spawned
            stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_WAYPOINT_DATA_ALL_WPGUID);
 
            WorldDatabase.Execute(stmt);
 
            if (hasError)
            {
                handler->PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
                handler->PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
                handler->PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
            }
 
            handler->SendSysMessage(LANG_WAYPOINT_VP_ALLREMOVED);
            return true;
        }
 
        handler->PSendSysMessage("|cffff33ffDEBUG: wpshow - no valid command found|r");
        return true;
    }

References Creature::Create(), Map::GenerateLowGuid(), Field::Get(), Map::GetCreature(), Unit::GetDisplayId(), Object::GetEntry(), Map::GetId(), WorldObject::GetMap(), Position::GetOrientation(), Player::GetPhaseMaskForSpawn(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetSpawnId(), Map::GetSpawnMode(), Creature::GetWaypointPath(), LANG_SELECT_CREATURE, LANG_WAYPOINT_CREATSELECTED, LANG_WAYPOINT_NOTCREATED, LANG_WAYPOINT_NOTFOUND, LANG_WAYPOINT_NOTFOUNDDBPROBLEM, LANG_WAYPOINT_NOTFOUNDLAST, LANG_WAYPOINT_NOTREMOVED, LANG_WAYPOINT_TOOFAR1, LANG_WAYPOINT_TOOFAR2, LANG_WAYPOINT_TOOFAR3, LANG_WAYPOINT_VP_ALLREMOVED, LANG_WAYPOINT_VP_NOTCREATED, LANG_WAYPOINT_VP_NOTFOUND, LANG_WAYPOINT_VP_SELECT, Creature::LoadCreatureFromDB(), ChatHandler::PSendSysMessage(), Creature::SaveToDB(), ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetArguments(), PreparedStatementBase::SetData(), Creature::SetDisplayId(), Unit::SetLevel(), Creature::SetObjectScale(), STRONG_MAX_LEVEL, Unit, VISUAL_WAYPOINT, WORLD_DEL_CREATURE, WORLD_SEL_CREATURE_BY_ID, WORLD_SEL_WAYPOINT_DATA_ALL_BY_WPGUID, WORLD_SEL_WAYPOINT_DATA_POS_BY_ID, WORLD_SEL_WAYPOINT_DATA_POS_FIRST_BY_ID, WORLD_SEL_WAYPOINT_DATA_POS_LAST_BY_ID, WORLD_SEL_WAYPOINT_DATA_WPGUID_BY_ID, WORLD_UPD_WAYPOINT_DATA_ALL_WPGUID, WORLD_UPD_WAYPOINT_DATA_WPGUID, and WorldDatabase.

Referenced by GetCommands().

HandleWpUnLoadCommand()

static bool wp_commandscript::HandleWpUnLoadCommand ( ChatHandler *  handler, const char *    )

inlinestatic

    {
        Creature* target = handler->getSelectedCreature();
 
        if (!target)
        {
            handler->PSendSysMessage("{}{}|r", "|cff33ffff", "You must select target.");
            return true;
        }
 
        uint32 guildLow = target->GetSpawnId();
 
        if (target->GetCreatureAddon())
        {
            if (target->GetCreatureAddon()->path_id != 0)
            {
                WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_CREATURE_ADDON);
                stmt->SetData(0, guildLow);
 
                WorldDatabase.Execute(stmt);
 
                target->UpdateWaypointID(0);
 
                stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_MOVEMENT_TYPE);
                stmt->SetData(0, uint8(IDLE_MOTION_TYPE));
                stmt->SetData(1, guildLow);
 
                WorldDatabase.Execute(stmt);
 
                target->LoadPath(0);
                target->SetDefaultMovementType(IDLE_MOTION_TYPE);
                target->GetMotionMaster()->MoveTargetedHome();
                target->GetMotionMaster()->Initialize();
                target->Say("Path unloaded.", LANG_UNIVERSAL);
                return true;
            }
            handler->PSendSysMessage("{}{}|r", "|cffff33ff", "Target have no loaded path.");
        }
        return true;
    }

References Creature::GetCreatureAddon(), Unit::GetMotionMaster(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), IDLE_MOTION_TYPE, MotionMaster::Initialize(), LANG_UNIVERSAL, Creature::LoadPath(), MotionMaster::MoveTargetedHome(), CreatureAddon::path_id, ChatHandler::PSendSysMessage(), Unit::Say(), PreparedStatementBase::SetData(), Creature::SetDefaultMovementType(), Creature::UpdateWaypointID(), WORLD_DEL_CREATURE_ADDON, WORLD_UPD_CREATURE_MOVEMENT_TYPE, and WorldDatabase.

Referenced by GetCommands().

---

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

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