deserter_commandscript Class Reference

Inheritance diagram for deserter_commandscript:

Public Member Functions
	deserter_commandscript ()
ChatCommandTable	GetCommands () const override
	Returns the command structure for the system.
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	HandleDeserterAdd (ChatHandler *handler, Optional< std::string > playerName, Optional< std::string > time, bool isInstance)
	Applies the Deserter Debuff to a player.
static bool	HandleDeserterRemove (ChatHandler *handler, Optional< PlayerIdentifier > player, bool isInstance)
	Removes the Deserter Debuff from a player.
static bool	HandleDeserterRemoveAll (ChatHandler *handler, bool isInstance, Optional< std::string > maxTime)
	Removes the Deserter Debuff from all players.
static bool	HandleDeserterInstanceAdd (ChatHandler *handler, Optional< std::string > playerName, Optional< std::string > time)
static bool	HandleDeserterBGAdd (ChatHandler *handler, Optional< std::string > playerName, Optional< std::string > time)
static bool	HandleDeserterInstanceRemove (ChatHandler *handler, Optional< PlayerIdentifier > player)
static bool	HandleDeserterBGRemove (ChatHandler *handler, Optional< PlayerIdentifier > player)
static bool	HandleDeserterInstanceRemoveAll (ChatHandler *handler, Optional< std::string > maxTime)
static bool	HandleDeserterBGRemoveAll (ChatHandler *handler, Optional< std::string > maxTime)

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

deserter_commandscript()

deserter_commandscript::deserter_commandscript ( )

inline

: CommandScript("deserter_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable deserter_commandscript::GetCommands ( ) const

inlineoverridevirtual

Returns the command structure for the system.

Implements CommandScript.

    {
        static ChatCommandTable deserterInstanceCommandTable =
        {
            { "add",        HandleDeserterInstanceAdd,       SEC_ADMINISTRATOR, Console::Yes },
            { "remove all", HandleDeserterInstanceRemoveAll, SEC_ADMINISTRATOR, Console::Yes },
            { "remove",     HandleDeserterInstanceRemove,    SEC_ADMINISTRATOR, Console::Yes }
        };
        static ChatCommandTable deserterBGCommandTable =
        {
            { "add",        HandleDeserterBGAdd,       SEC_ADMINISTRATOR, Console::Yes },
            { "remove all", HandleDeserterBGRemoveAll, SEC_ADMINISTRATOR, Console::Yes },
            { "remove",     HandleDeserterBGRemove,    SEC_ADMINISTRATOR, Console::Yes }
        };
 
        static ChatCommandTable deserterCommandTable =
        {
            { "instance", deserterInstanceCommandTable },
            { "bg",       deserterBGCommandTable }
        };
        static ChatCommandTable commandTable =
        {
            { "deserter", deserterCommandTable }
        };
        return commandTable;
    }

References HandleDeserterBGAdd(), HandleDeserterBGRemove(), HandleDeserterBGRemoveAll(), HandleDeserterInstanceAdd(), HandleDeserterInstanceRemove(), HandleDeserterInstanceRemoveAll(), and SEC_ADMINISTRATOR.

HandleDeserterAdd()

static bool deserter_commandscript::HandleDeserterAdd ( ChatHandler *  handler, Optional< std::string >  playerName, Optional< std::string >  time, bool  isInstance  )

inlinestatic

Applies the Deserter Debuff to a player.

This function applies a Deserter Debuff of the given type (Instance or BG) to the selected player, with the provided duration in seconds.

Parameters

handler	The ChatHandler, passed by the system.
playerName	Player by name. Optional, defaults to selected or self.
time	The provided duration as TimeString. Optional, defaults to bg/instance default time.
isInstance	provided by the relaying functions, so we don't have to write that much code :)

Returns

true if everything was correct, false if an error occured.

Example Usage:

.deserter instance add 1h30m (using player target or self)
-or-
.deserter bg add 1h30m (using player target or self)
-or-
.deserter bg add Tester 1h30m (using player of name 'Tester')

    {
        Player* target = handler->getSelectedPlayerOrSelf();
        ObjectGuid guid;
 
        if (playerName)
        {
            if (!normalizePlayerName(*playerName))
            {
                handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
                return false;
            }
 
            guid = sCharacterCache->GetCharacterGuidByName(*playerName);
            if (guid)
            {
                target = ObjectAccessor::FindPlayerByName(*playerName);
            }
            else
            {
                if (time)
                {
                    handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
                    return false;
                }
 
                time = playerName;
                playerName = "";
            }
        }
 
        if (!playerName || playerName->empty())
        {
            if (!handler->GetSession())
            {
                return false;
            }
 
            playerName = target->GetName();
            guid = target->GetGUID();
        }
 
        if (!time)
        {
            time = isInstance ? "30m" : "15m";
        }
 
        int32 duration = TimeStringToSecs(*time);
 
        if (duration == 0)
        {
            duration = Acore::StringTo<int32>(*time).value_or(0);
        }
 
        if (duration == 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        uint32 deserterSpell = isInstance ? LFG_SPELL_DUNGEON_DESERTER : BG_SPELL_DESERTER;
 
        if (target)
        {
            Aura* aura = target->GetAura(deserterSpell);
            if (aura && aura->GetDuration() >= duration * IN_MILLISECONDS)
            {
                handler->PSendSysMessage("Player {} already has a longer {} Deserter active.", handler->playerLink(*playerName), isInstance ? "Instance" : "Battleground");
                return true;
            }
 
            aura = target->AddAura(deserterSpell, target);
            if (!aura)
            {
                handler->SendErrorMessage(LANG_BAD_VALUE);
                return false;
            }
            aura->SetDuration(duration * IN_MILLISECONDS);
        }
        else
        {
            int32 remainTime = 0;
            if (QueryResult result = CharacterDatabase.Query("SELECT remainTime FROM character_aura WHERE guid = {} AND spell = {}", guid.GetCounter(), deserterSpell))
            {
                Field* fields = result->Fetch();
                remainTime = fields[0].Get<int32>();
 
                if (remainTime < 0 || remainTime >= duration * IN_MILLISECONDS)
                {
                    handler->PSendSysMessage("Player {} already has a longer {} Deserter active.", handler->playerLink(*playerName), isInstance ? "Instance" : "Battleground");
                    return true;
                }
                CharacterDatabase.Query("DELETE FROM character_aura WHERE guid = {} AND spell = {}", guid.GetCounter(), deserterSpell);
            }
 
            uint8 index = 0;
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_AURA);
            stmt->SetData(index++, guid.GetCounter());
            stmt->SetData(index++, guid.GetCounter());
            stmt->SetData(index++, 0);
            stmt->SetData(index++, deserterSpell);
            stmt->SetData(index++, 1);
            stmt->SetData(index++, 1);
            stmt->SetData(index++, 1);
            stmt->SetData(index++, 0);
            stmt->SetData(index++, 0);
            stmt->SetData(index++, 0);
            stmt->SetData(index++, 0);
            stmt->SetData(index++, 0);
            stmt->SetData(index++, 0);
            stmt->SetData(index++, isInstance ? 1800000 : 900000);
            stmt->SetData(index++, duration * IN_MILLISECONDS);
            stmt->SetData(index, 0);
            CharacterDatabase.Execute(stmt);
        }
 
        if (isInstance)
        {
            if (ObjectGuid groupId = sCharacterCache->GetCharacterGroupGuidByGuid(guid))
                if (Group* group = sGroupMgr->GetGroupByGUID(groupId.GetCounter()))
                    if (group->isLFGGroup())
                        Player::RemoveFromGroup(group, guid);
        }
        else if (target && target->GetMap()->IsBattleground())
            target->LeaveBattleground();
 
        handler->PSendSysMessage("{} of {} Deserter has been added to player {}.", secsToTimeString(duration), isInstance ? "Instance" : "Battleground", handler->playerLink(*playerName));
        return true;
    }

References Unit::AddAura(), BG_SPELL_DESERTER, CHAR_INS_AURA, CharacterDatabase, ObjectAccessor::FindPlayerByName(), Field::Get(), Unit::GetAura(), ObjectGuid::GetCounter(), Aura::GetDuration(), Object::GetGUID(), WorldObject::GetMap(), WorldObject::GetName(), ChatHandler::getSelectedPlayerOrSelf(), ChatHandler::GetSession(), IN_MILLISECONDS, Map::IsBattleground(), LANG_BAD_VALUE, LANG_PLAYER_NOT_FOUND, Player::LeaveBattleground(), LFG_SPELL_DUNGEON_DESERTER, normalizePlayerName(), ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Player::RemoveFromGroup(), sCharacterCache, secsToTimeString(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), Aura::SetDuration(), sGroupMgr, and TimeStringToSecs().

Referenced by HandleDeserterBGAdd(), and HandleDeserterInstanceAdd().

HandleDeserterBGAdd()

static bool deserter_commandscript::HandleDeserterBGAdd ( ChatHandler *  handler, Optional< std::string >  playerName, Optional< std::string >  time  )

inlinestatic

See also

HandleDeserterAdd()

    {
        return HandleDeserterAdd(handler, playerName, time, false);
    }

References HandleDeserterAdd().

Referenced by GetCommands().

HandleDeserterBGRemove()

static bool deserter_commandscript::HandleDeserterBGRemove ( ChatHandler *  handler, Optional< PlayerIdentifier >  player  )

inlinestatic

See also

HandleDeserterRemove()

    {
        return HandleDeserterRemove(handler, player, false);
    }

References HandleDeserterRemove().

Referenced by GetCommands().

HandleDeserterBGRemoveAll()

static bool deserter_commandscript::HandleDeserterBGRemoveAll ( ChatHandler *  handler, Optional< std::string >  maxTime  )

inlinestatic

    {
        return HandleDeserterRemoveAll(handler, false, maxTime);
    }

References HandleDeserterRemoveAll().

Referenced by GetCommands().

HandleDeserterInstanceAdd()

static bool deserter_commandscript::HandleDeserterInstanceAdd ( ChatHandler *  handler, Optional< std::string >  playerName, Optional< std::string >  time  )

inlinestatic

See also

HandleDeserterAdd()

    {
        return HandleDeserterAdd(handler, playerName, time, true);
    }

References HandleDeserterAdd().

Referenced by GetCommands().

HandleDeserterInstanceRemove()

static bool deserter_commandscript::HandleDeserterInstanceRemove ( ChatHandler *  handler, Optional< PlayerIdentifier >  player  )

inlinestatic

See also

HandleDeserterRemove()

    {
        return HandleDeserterRemove(handler, player, true);
    }

References HandleDeserterRemove().

Referenced by GetCommands().

HandleDeserterInstanceRemoveAll()

static bool deserter_commandscript::HandleDeserterInstanceRemoveAll ( ChatHandler *  handler, Optional< std::string >  maxTime  )

inlinestatic

    {
        return HandleDeserterRemoveAll(handler, true, maxTime);
    }

References HandleDeserterRemoveAll().

Referenced by GetCommands().

HandleDeserterRemove()

static bool deserter_commandscript::HandleDeserterRemove ( ChatHandler *  handler, Optional< PlayerIdentifier >  player, bool  isInstance  )

inlinestatic

Removes the Deserter Debuff from a player.

This function removes a Deserter Debuff of the given type (Instance or BG) from the selected player.

Parameters

handler	The ChatHandler, passed by the system.
player	The target player, either by name, the target or self
isInstance	provided by the relaying functions, so we don't have to write that much code :)

Returns

true if everything was correct, false if an error occured.

Example Usage:

.deserter instance remove (using player target or self)
-or-
.deserter bg remove (using player target or self)
-or-
.deserter bg remove Tester (using player of name 'Tester')

    {
        if (!player)
        {
            player = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!player)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        Player* target = player->GetConnectedPlayer();
        uint32 deserterSpell = isInstance ? LFG_SPELL_DUNGEON_DESERTER : BG_SPELL_DESERTER;
        int32 duration = 0;
 
        if (target)
        {
            if (Aura* aura = target->GetAura(deserterSpell))
            {
                duration = aura->GetDuration();
                target->RemoveAura(deserterSpell);
            }
        }
        else
        {
            if (QueryResult result = CharacterDatabase.Query("SELECT remainTime FROM character_aura WHERE guid = {} AND spell = {}", player->GetGUID().GetCounter(), deserterSpell))
            {
                Field* fields = result->Fetch();
                duration = fields[0].Get<int32>();
                CharacterDatabase.Execute("DELETE FROM character_aura WHERE guid = {} AND spell = {}", player->GetGUID().GetCounter(), deserterSpell);
            }
        }
 
        if (duration == 0)
        {
            handler->SendErrorMessage("Player {} does not have {} Deserter.", handler->playerLink(player->GetName()), isInstance ? "Instance" : "Battleground");
            return true;
        }
 
        if (duration < 0)
        {
            handler->SendErrorMessage("Permanent {} Deserter has been removed from player {} (GUID {}).", isInstance ? "Instance" : "Battleground", handler->playerLink(player->GetName()), player->GetGUID().ToString());
            return true;
        }
 
        handler->PSendSysMessage("{} of {} Deserter has been removed from player {} (GUID {}).", secsToTimeString(duration / IN_MILLISECONDS), isInstance ? "Instance" : "Battleground", handler->playerLink(player->GetName()), player->GetGUID().ToString());
        return true;
    }

References BG_SPELL_DESERTER, CharacterDatabase, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Field::Get(), Unit::GetAura(), IN_MILLISECONDS, LANG_NO_CHAR_SELECTED, LFG_SPELL_DUNGEON_DESERTER, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Unit::RemoveAura(), secsToTimeString(), and ChatHandler::SendErrorMessage().

Referenced by HandleDeserterBGRemove(), and HandleDeserterInstanceRemove().

HandleDeserterRemoveAll()

static bool deserter_commandscript::HandleDeserterRemoveAll ( ChatHandler *  handler, bool  isInstance, Optional< std::string >  maxTime  )

inlinestatic

Removes the Deserter Debuff from all players.

This function removes a Deserter Debuff of the given type (Instance or BG) from all players, online or offline.

Parameters

handler	The ChatHandler, passed by the system.
isInstance	provided by the relaying functions, so we don't have to write that much code :)
maxTime	Optional: The maximum remaining time of the Debuff on players to be removed. Any Player with a Deserter Debuff of this time or less will get their Debuff removed. Use -1 for any. Default: 15m for BG, 30m for Instance.

Returns

true if everything was correct, false if an error occured.

Example Usage:

.deserter bg remove all
-or-
.deserter bg remove all 30m
-or-
.deserter bg remove all -1

    {
        uint32 deserterSpell = isInstance ? LFG_SPELL_DUNGEON_DESERTER : BG_SPELL_DESERTER;
        int32 remainTime = isInstance ? 1800 : 1800;
        uint64 deserterCount = 0;
        bool countOnline = true;
 
        if (maxTime)
        {
            remainTime = TimeStringToSecs(*maxTime);
            if (remainTime == 0)
            {
                remainTime = Acore::StringTo<int32>(*maxTime).value_or(0);
            }
        }
 
        // Optimization. Do not execute any further functions or Queries if remainTime is 0.
        if (remainTime == 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        QueryResult result;
        if (remainTime > 0)
        {
            result = CharacterDatabase.Query("SELECT COUNT(guid) FROM character_aura WHERE spell = {} AND remainTime <= {}", deserterSpell, remainTime * IN_MILLISECONDS);
        }
        else
        {
            result = CharacterDatabase.Query("SELECT COUNT(guid) FROM character_aura WHERE spell = {}", deserterSpell);
        }
 
        if (result)
        {
            deserterCount = (*result)[0].Get<uint64>();
        }
 
        // Optimization. Only execute these if there even is a result.
        if (deserterCount > 0)
        {
            countOnline = false;
            if (remainTime > 0)
            {
                CharacterDatabase.Execute("DELETE FROM character_aura WHERE spell = {} AND remainTime <= {}", deserterSpell, remainTime * IN_MILLISECONDS);
            }
            else
            {
                CharacterDatabase.Execute("DELETE FROM character_aura WHERE spell = {}", deserterSpell);
            }
        }
 
        std::shared_lock<std::shared_mutex> lock(*HashMapHolder<Player>::GetLock());
        HashMapHolder<Player>::MapType const& onlinePlayerList = ObjectAccessor::GetPlayers();
        for (HashMapHolder<Player>::MapType::const_iterator itr = onlinePlayerList.begin(); itr != onlinePlayerList.end(); ++itr)
        {
            Player* player = itr->second;
            Aura* aura = player->GetAura(deserterSpell);
            if (aura && (remainTime < 0 || aura->GetDuration() <= remainTime * IN_MILLISECONDS))
            {
                if (countOnline)
                    deserterCount++;
                player->RemoveAura(deserterSpell);
            }
        }
 
        std::string remainTimeStr = secsToTimeString(remainTime);
        if (remainTime < 0)
        {
            remainTimeStr = "infinity";
        }
 
        if (deserterCount == 0)
        {
            handler->PSendSysMessage("No player on this realm has {} Deserter with a duration of {} or less.", isInstance ? "Instance" : "Battleground", remainTimeStr);
            return true;
        }
 
        handler->PSendSysMessage("{} Deserter has been removed from {} player(s) with a duration of {} or less.", isInstance ? "Instance" : "Battleground", deserterCount, remainTimeStr);
        return true;
    }

References BG_SPELL_DESERTER, CharacterDatabase, Unit::GetAura(), ObjectAccessor::GetPlayers(), IN_MILLISECONDS, LANG_BAD_VALUE, LFG_SPELL_DUNGEON_DESERTER, ChatHandler::PSendSysMessage(), Unit::RemoveAura(), secsToTimeString(), ChatHandler::SendErrorMessage(), and TimeStringToSecs().

Referenced by HandleDeserterBGRemoveAll(), and HandleDeserterInstanceRemoveAll().

---

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

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