modify_commandscript Class Reference

Inheritance diagram for modify_commandscript:

Public Member Functions
	modify_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
template<typename... Args>
static void	NotifyModification (ChatHandler *handler, Unit *target, AcoreStrings resourceMessage, AcoreStrings resourceReportMessage, Args &&... args)
static bool	CheckModifyInt32 (ChatHandler *handler, Player *target, int32 modifyValue)
static bool	HandleModifyHPCommand (ChatHandler *handler, int32 healthPoints)
static bool	HandleModifyManaCommand (ChatHandler *handler, int32 manaPoints)
static bool	HandleModifyEnergyCommand (ChatHandler *handler, int32 energyPoints)
static bool	HandleModifyRageCommand (ChatHandler *handler, int32 ragePoints)
static bool	HandleModifyRunicPowerCommand (ChatHandler *handler, int32 runePoints)
static bool	HandleModifyFactionCommand (ChatHandler *handler, Optional< uint32 > factionID, Optional< uint32 > flagID, Optional< uint32 > npcFlagID, Optional< uint32 > dynamicFlagID)
static bool	HandleModifySpellCommand (ChatHandler *handler, uint8 spellFlatID, uint8 op, uint16 val, Optional< uint16 > mark)
static bool	HandleModifyTalentCommand (ChatHandler *handler, uint32 talentPoints)
static bool	CheckModifySpeed (ChatHandler *handler, Unit *target, float speed, float minimumBound, float maximumBound, bool checkInFlight=true)
static bool	HandleModifyASpeedCommand (ChatHandler *handler, float allSpeed)
static bool	HandleModifySpeedCommand (ChatHandler *handler, float speed)
static bool	HandleModifySwimCommand (ChatHandler *handler, float swimSpeed)
static bool	HandleModifyBWalkCommand (ChatHandler *handler, float backSpeed)
static bool	HandleModifyFlyCommand (ChatHandler *handler, float flySpeed)
static bool	HandleModifyScaleCommand (ChatHandler *handler, float scale)
static bool	HandleModifyMountCommand (ChatHandler *handler, uint32 creatureDisplayID, Optional< float > speed)
static bool	HandleModifyMoneyCommand (ChatHandler *handler, Tail money)
static bool	HandleModifyBitCommand (ChatHandler *handler, uint16 field, uint32 bit)
static bool	HandleModifyHonorCommand (ChatHandler *handler, int32 amount)
static bool	HandleModifyDrunkCommand (ChatHandler *handler, uint8 drunklevel)
static bool	HandleModifyRepCommand (ChatHandler *handler, uint32 factionId, Variant< int32, std::string > rank, Optional< int32 > delta)
static bool	HandleMorphTargetCommand (ChatHandler *handler, uint32 displayID)
static bool	HandleMorphResetCommand (ChatHandler *handler)
static bool	HandleMorphMountCommand (ChatHandler *handler, uint32 displayID)
static bool	HandleModifyPhaseCommand (ChatHandler *handler, uint32 phaseMask)
static bool	HandleModifyStandStateCommand (ChatHandler *handler, uint32 anim)
static bool	HandleModifyArenaCommand (ChatHandler *handler, int32 amount)
static bool	HandleModifyGenderCommand (ChatHandler *handler, Tail genderString)

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

modify_commandscript()

modify_commandscript::modify_commandscript ( )

inline

: CommandScript("modify_commandscript") { }

Member Function Documentation

CheckModifyInt32()

static bool modify_commandscript::CheckModifyInt32 ( ChatHandler *  handler, Player *  target, int32  modifyValue  )

inlinestatic

    {
        if (modifyValue < 1)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        if (handler->HasLowerSecurity(target))
        {
            return false;
        }
 
        return true;
    }

References ChatHandler::HasLowerSecurity(), LANG_BAD_VALUE, LANG_NO_CHAR_SELECTED, and ChatHandler::SendErrorMessage().

Referenced by HandleModifyEnergyCommand(), HandleModifyHPCommand(), HandleModifyManaCommand(), HandleModifyRageCommand(), and HandleModifyRunicPowerCommand().

CheckModifySpeed()

static bool modify_commandscript::CheckModifySpeed ( ChatHandler *  handler, Unit *  target, float  speed, float  minimumBound, float  maximumBound, bool  checkInFlight = true  )

inlinestatic

    {
        if (speed > maximumBound || speed < minimumBound)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        if (Player* player = target->ToPlayer())
        {
            // check online security
            if (handler->HasLowerSecurity(player))
            {
                return false;
            }
 
            if (player->IsInFlight() && checkInFlight)
            {
                handler->SendErrorMessage(LANG_CHAR_IN_FLIGHT, handler->GetNameLink(player).c_str());
                return false;
            }
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), ChatHandler::HasLowerSecurity(), LANG_BAD_VALUE, LANG_CHAR_IN_FLIGHT, LANG_NO_CHAR_SELECTED, ChatHandler::SendErrorMessage(), and Object::ToPlayer().

Referenced by HandleModifyASpeedCommand(), HandleModifyBWalkCommand(), HandleModifyFlyCommand(), HandleModifyMountCommand(), HandleModifySpeedCommand(), and HandleModifySwimCommand().

GetCommands()

ChatCommandTable modify_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable modifyspeedCommandTable =
        {
            { "fly",            HandleModifyFlyCommand,           SEC_GAMEMASTER,       Console::No },
            { "all",            HandleModifyASpeedCommand,        SEC_GAMEMASTER,       Console::No },
            { "walk",           HandleModifySpeedCommand,         SEC_GAMEMASTER,       Console::No },
            { "backwalk",       HandleModifyBWalkCommand,         SEC_GAMEMASTER,       Console::No },
            { "swim",           HandleModifySwimCommand,          SEC_GAMEMASTER,       Console::No },
            { "",               HandleModifyASpeedCommand,        SEC_GAMEMASTER,       Console::No }
        };
 
        static ChatCommandTable modifyCommandTable =
        {
            { "hp",             HandleModifyHPCommand,            SEC_GAMEMASTER,       Console::No },
            { "mana",           HandleModifyManaCommand,          SEC_GAMEMASTER,       Console::No },
            { "rage",           HandleModifyRageCommand,          SEC_GAMEMASTER,       Console::No },
            { "runicpower",     HandleModifyRunicPowerCommand,    SEC_GAMEMASTER,       Console::No },
            { "energy",         HandleModifyEnergyCommand,        SEC_GAMEMASTER,       Console::No },
            { "money",          HandleModifyMoneyCommand,         SEC_GAMEMASTER,       Console::No },
            { "scale",          HandleModifyScaleCommand,         SEC_GAMEMASTER,       Console::No },
            { "bit",            HandleModifyBitCommand,           SEC_GAMEMASTER,       Console::No },
            { "faction",        HandleModifyFactionCommand,       SEC_ADMINISTRATOR,    Console::No },
            { "spell",          HandleModifySpellCommand,         SEC_CONSOLE,          Console::No },
            { "talentpoints",   HandleModifyTalentCommand,        SEC_GAMEMASTER,       Console::No },
            { "mount",          HandleModifyMountCommand,         SEC_GAMEMASTER,       Console::No },
            { "honor",          HandleModifyHonorCommand,         SEC_GAMEMASTER,       Console::No },
            { "reputation",     HandleModifyRepCommand,           SEC_GAMEMASTER,       Console::No },
            { "arenapoints",    HandleModifyArenaCommand,         SEC_GAMEMASTER,       Console::No },
            { "drunk",          HandleModifyDrunkCommand,         SEC_GAMEMASTER,       Console::No },
            { "standstate",     HandleModifyStandStateCommand,    SEC_GAMEMASTER,       Console::No },
            { "phase",          HandleModifyPhaseCommand,         SEC_GAMEMASTER,       Console::No },
            { "gender",         HandleModifyGenderCommand,        SEC_GAMEMASTER,       Console::No },
            { "speed",          modifyspeedCommandTable }
        };
 
        static ChatCommandTable morphCommandTable =
        {
            { "reset",          HandleMorphResetCommand,          SEC_MODERATOR,        Console::No },
            { "target",         HandleMorphTargetCommand,         SEC_MODERATOR,        Console::No },
            { "mount",          HandleMorphMountCommand,          SEC_MODERATOR,        Console::No }
        };
 
        static ChatCommandTable commandTable =
        {
            { "morph",          morphCommandTable },
            { "modify",         modifyCommandTable }
        };
 
        return commandTable;
    }

References HandleModifyArenaCommand(), HandleModifyASpeedCommand(), HandleModifyBitCommand(), HandleModifyBWalkCommand(), HandleModifyDrunkCommand(), HandleModifyEnergyCommand(), HandleModifyFactionCommand(), HandleModifyFlyCommand(), HandleModifyGenderCommand(), HandleModifyHonorCommand(), HandleModifyHPCommand(), HandleModifyManaCommand(), HandleModifyMoneyCommand(), HandleModifyMountCommand(), HandleModifyPhaseCommand(), HandleModifyRageCommand(), HandleModifyRepCommand(), HandleModifyRunicPowerCommand(), HandleModifyScaleCommand(), HandleModifySpeedCommand(), HandleModifySpellCommand(), HandleModifyStandStateCommand(), HandleModifySwimCommand(), HandleModifyTalentCommand(), HandleMorphMountCommand(), HandleMorphResetCommand(), HandleMorphTargetCommand(), SEC_ADMINISTRATOR, SEC_CONSOLE, SEC_GAMEMASTER, and SEC_MODERATOR.

HandleModifyArenaCommand()

static bool modify_commandscript::HandleModifyArenaCommand ( ChatHandler *  handler, int32  amount  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        target->ModifyArenaPoints(amount);
 
        handler->PSendSysMessage(LANG_COMMAND_MODIFY_ARENA, handler->GetNameLink(target), target->GetArenaPoints());
 
        return true;
    }

References Player::GetArenaPoints(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), LANG_COMMAND_MODIFY_ARENA, LANG_PLAYER_NOT_FOUND, Player::ModifyArenaPoints(), ChatHandler::PSendSysMessage(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleModifyASpeedCommand()

static bool modify_commandscript::HandleModifyASpeedCommand ( ChatHandler *  handler, float  allSpeed  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayerOrSelf();
        if (CheckModifySpeed(handler, target, allSpeed, 0.1f, 50.0f))
        {
            NotifyModification(handler, target, LANG_YOU_CHANGE_ASPEED, LANG_YOURS_ASPEED_CHANGED, allSpeed);
            target->SetSpeed(MOVE_WALK, allSpeed);
            target->SetSpeed(MOVE_RUN, allSpeed);
            target->SetSpeed(MOVE_SWIM, allSpeed);
            target->SetSpeed(MOVE_FLIGHT, allSpeed);
            return true;
        }
 
        return false;
    }

References CheckModifySpeed(), ChatHandler::getSelectedPlayerOrSelf(), LANG_YOU_CHANGE_ASPEED, LANG_YOURS_ASPEED_CHANGED, MOVE_FLIGHT, MOVE_RUN, MOVE_SWIM, MOVE_WALK, NotifyModification(), and Unit::SetSpeed().

Referenced by GetCommands().

HandleModifyBitCommand()

static bool modify_commandscript::HandleModifyBitCommand ( ChatHandler *  handler, uint16  field, uint32  bit  )

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        // check online security
        if (target->IsPlayer() && handler->HasLowerSecurity(target->ToPlayer()))
        {
            return false;
        }
 
        if (field < OBJECT_END || field >= target->GetValuesCount())
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (bit < 1 || bit > 32)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        if (target->HasFlag(field, (1 << (bit - 1))))
        {
            target->RemoveFlag(field, (1 << (bit - 1)));
            handler->PSendSysMessage(LANG_REMOVE_BIT, bit, field);
        }
        else
        {
            target->SetFlag(field, (1 << (bit - 1)));
            handler->PSendSysMessage(LANG_SET_BIT, bit, field);
        }
 
        return true;
    }

References ChatHandler::getSelectedUnit(), Object::GetValuesCount(), Object::HasFlag(), ChatHandler::HasLowerSecurity(), Object::IsPlayer(), LANG_BAD_VALUE, LANG_NO_CHAR_SELECTED, LANG_REMOVE_BIT, LANG_SET_BIT, ChatHandler::PSendSysMessage(), Object::RemoveFlag(), ChatHandler::SendErrorMessage(), Object::SetFlag(), and Object::ToPlayer().

Referenced by GetCommands().

HandleModifyBWalkCommand()

static bool modify_commandscript::HandleModifyBWalkCommand ( ChatHandler *  handler, float  backSpeed  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayerOrSelf();
        if (CheckModifySpeed(handler, target, backSpeed, 0.1f, 50.0f))
        {
            NotifyModification(handler, target, LANG_YOU_CHANGE_BACK_SPEED, LANG_YOURS_BACK_SPEED_CHANGED, backSpeed);
            target->SetSpeedRate(MOVE_RUN_BACK, backSpeed);
            return true;
        }
 
        return false;
    }

References CheckModifySpeed(), ChatHandler::getSelectedPlayerOrSelf(), LANG_YOU_CHANGE_BACK_SPEED, LANG_YOURS_BACK_SPEED_CHANGED, MOVE_RUN_BACK, NotifyModification(), and Unit::SetSpeedRate().

Referenced by GetCommands().

HandleModifyDrunkCommand()

static bool modify_commandscript::HandleModifyDrunkCommand ( ChatHandler *  handler, uint8  drunklevel  )

inlinestatic

    {
        if (drunklevel > 100)
        {
            drunklevel = 100;
        }
 
        if (Player* target = handler->getSelectedPlayer())
        {
            target->SetDrunkValue(drunklevel);
        }
 
        return true;
    }

References ChatHandler::getSelectedPlayer().

Referenced by GetCommands().

HandleModifyEnergyCommand()

static bool modify_commandscript::HandleModifyEnergyCommand ( ChatHandler *  handler, int32  energyPoints  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
 
        if (!CheckModifyInt32(handler, target, energyPoints))
        {
            return false;
        }
 
        energyPoints *= 10;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_ENERGY, handler->GetNameLink(target), energyPoints / 10, energyPoints / 10);
 
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_ENERGY_CHANGED, handler->GetNameLink(), energyPoints / 10, energyPoints / 10);
        }
 
        target->SetMaxPower(POWER_ENERGY, energyPoints);
        target->SetPower(POWER_ENERGY, energyPoints);
 
        LOG_DEBUG("misc", handler->GetAcoreString(LANG_CURRENT_ENERGY), target->GetMaxPower(POWER_ENERGY));
 
        return true;
    }

References CheckModifyInt32(), ChatHandler::GetAcoreString(), Unit::GetMaxPower(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), LANG_CURRENT_ENERGY, LANG_YOU_CHANGE_ENERGY, LANG_YOURS_ENERGY_CHANGED, LOG_DEBUG, ChatHandler::needReportToTarget(), POWER_ENERGY, ChatHandler::PSendSysMessage(), Unit::SetMaxPower(), and Unit::SetPower().

Referenced by GetCommands().

HandleModifyFactionCommand()

static bool modify_commandscript::HandleModifyFactionCommand ( ChatHandler *  handler, Optional< uint32 >  factionID, Optional< uint32 >  flagID, Optional< uint32 >  npcFlagID, Optional< uint32 >  dynamicFlagID  )

inlinestatic

    {
        Creature* target = handler->getSelectedCreature();
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        if (!factionID)
        {
            uint32 factionid = target->GetFaction();
            uint32 flag      = target->GetUnitFlags();
            uint32 npcflag   = target->GetNpcFlags();
            uint32 dyflag    = target->GetDynamicFlags();
            handler->PSendSysMessage(LANG_CURRENT_FACTION, target->GetGUID().ToString(), factionid, flag, npcflag, dyflag);
            return true;
        }
 
        uint32 factionid = factionID.value();
        UnitFlags flag;
        NPCFlags npcflag;
        uint32 dyflag;
 
        auto pflag = flagID;
        if (!pflag)
            flag = target->GetUnitFlags();
        else
            flag = UnitFlags(*pflag);
 
        auto pnpcflag = npcFlagID;
        if (!pnpcflag)
            npcflag = target->GetNpcFlags();
        else
            npcflag = NPCFlags(*npcFlagID);
 
        auto pdyflag = dynamicFlagID;
        if (!pdyflag)
            dyflag = target->GetDynamicFlags();
        else
            dyflag = *dynamicFlagID;
 
        if (!sFactionTemplateStore.LookupEntry(factionid))
        {
            handler->SendErrorMessage(LANG_WRONG_FACTION, factionid);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_FACTION, target->GetGUID().ToString(), factionid, flag, npcflag, dyflag);
 
        target->SetFaction(factionid);
        target->ReplaceAllUnitFlags(flag);
        target->ReplaceAllNpcFlags(npcflag);
        target->ReplaceAllDynamicFlags(dyflag);
 
        return true;
    }

References Unit::GetDynamicFlags(), Unit::GetFaction(), Object::GetGUID(), Unit::GetNpcFlags(), ChatHandler::getSelectedCreature(), Unit::GetUnitFlags(), LANG_CURRENT_FACTION, LANG_SELECT_CREATURE, LANG_WRONG_FACTION, LANG_YOU_CHANGE_FACTION, ChatHandler::PSendSysMessage(), Unit::ReplaceAllDynamicFlags(), Unit::ReplaceAllNpcFlags(), Unit::ReplaceAllUnitFlags(), ChatHandler::SendErrorMessage(), Unit::SetFaction(), sFactionTemplateStore, and ObjectGuid::ToString().

Referenced by GetCommands().

HandleModifyFlyCommand()

static bool modify_commandscript::HandleModifyFlyCommand ( ChatHandler *  handler, float  flySpeed  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayerOrSelf();
        if (CheckModifySpeed(handler, target, flySpeed, 0.1f, 50.0f, false))
        {
            NotifyModification(handler, target, LANG_YOU_CHANGE_FLY_SPEED, LANG_YOURS_FLY_SPEED_CHANGED, flySpeed);
            target->SetSpeedRate(MOVE_FLIGHT, flySpeed);
            return true;
        }
 
        return false;
    }

References CheckModifySpeed(), ChatHandler::getSelectedPlayerOrSelf(), LANG_YOU_CHANGE_FLY_SPEED, LANG_YOURS_FLY_SPEED_CHANGED, MOVE_FLIGHT, NotifyModification(), and Unit::SetSpeedRate().

Referenced by GetCommands().

HandleModifyGenderCommand()

static bool modify_commandscript::HandleModifyGenderCommand ( ChatHandler *  handler, Tail  genderString  )

inlinestatic

    {
        if (genderString.empty())
        {
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        PlayerInfo const* info = sObjectMgr->GetPlayerInfo(target->getRace(), target->getClass());
        if (!info)
        {
            return false;
        }
 
        Gender gender;
 
        if (StringEqualI(genderString, "male")) // MALE
        {
            if (target->getGender() == GENDER_MALE)
                return true;
 
            gender = GENDER_MALE;
        }
        else if (StringEqualI(genderString, "female"))    // FEMALE
        {
            if (target->getGender() == GENDER_FEMALE)
                return true;
 
            gender = GENDER_FEMALE;
        }
        else
        {
            handler->SendErrorMessage(LANG_MUST_MALE_OR_FEMALE);
            return false;
        }
 
        // Set gender
        target->SetByteValue(UNIT_FIELD_BYTES_0, 2, gender);
        target->SetByteValue(PLAYER_BYTES_3, 0, gender);
 
        // Change display ID
        target->InitDisplayIds();
 
        char const* gender_full = gender ? "female" : "male";
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_GENDER, handler->GetNameLink(target), gender_full);
 
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_GENDER_CHANGED, gender_full, handler->GetNameLink());
        }
 
        return true;
    }

References GENDER_FEMALE, GENDER_MALE, Unit::getClass(), Unit::getGender(), ChatHandler::GetNameLink(), Unit::getRace(), ChatHandler::getSelectedPlayer(), Player::GetSession(), Player::InitDisplayIds(), LANG_MUST_MALE_OR_FEMALE, LANG_PLAYER_NOT_FOUND, LANG_YOU_CHANGE_GENDER, LANG_YOUR_GENDER_CHANGED, ChatHandler::needReportToTarget(), PLAYER_BYTES_3, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), Object::SetByteValue(), sObjectMgr, StringEqualI(), and UNIT_FIELD_BYTES_0.

Referenced by GetCommands().

HandleModifyHonorCommand()

static bool modify_commandscript::HandleModifyHonorCommand ( ChatHandler *  handler, int32  amount  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target))
        {
            return false;
        }
 
        target->ModifyHonorPoints(amount);
 
        handler->PSendSysMessage(LANG_COMMAND_MODIFY_HONOR, handler->GetNameLink(target), target->GetHonorPoints());
 
        return true;
    }

References Player::GetHonorPoints(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), ChatHandler::HasLowerSecurity(), LANG_COMMAND_MODIFY_HONOR, LANG_PLAYER_NOT_FOUND, Player::ModifyHonorPoints(), ChatHandler::PSendSysMessage(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleModifyHPCommand()

static bool modify_commandscript::HandleModifyHPCommand ( ChatHandler *  handler, int32  healthPoints  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
 
        if (!CheckModifyInt32(handler, target, healthPoints))
        {
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_HP, handler->GetNameLink(target), healthPoints, healthPoints);
 
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_HP_CHANGED, handler->GetNameLink(), healthPoints, healthPoints);
        }
 
        target->SetMaxHealth(healthPoints);
        target->SetHealth(healthPoints);
 
        return true;
    }

References CheckModifyInt32(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), LANG_YOU_CHANGE_HP, LANG_YOURS_HP_CHANGED, ChatHandler::needReportToTarget(), ChatHandler::PSendSysMessage(), Unit::SetHealth(), and Unit::SetMaxHealth().

Referenced by GetCommands().

HandleModifyManaCommand()

static bool modify_commandscript::HandleModifyManaCommand ( ChatHandler *  handler, int32  manaPoints  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
 
        if (!CheckModifyInt32(handler, target, manaPoints))
        {
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_MANA, handler->GetNameLink(target), manaPoints, manaPoints);
 
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_MANA_CHANGED, handler->GetNameLink(), manaPoints, manaPoints);
        }
 
        target->SetMaxPower(POWER_MANA, manaPoints);
        target->SetPower(POWER_MANA, manaPoints);
 
        return true;
    }

References CheckModifyInt32(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), LANG_YOU_CHANGE_MANA, LANG_YOURS_MANA_CHANGED, ChatHandler::needReportToTarget(), POWER_MANA, ChatHandler::PSendSysMessage(), Unit::SetMaxPower(), and Unit::SetPower().

Referenced by GetCommands().

HandleModifyMoneyCommand()

static bool modify_commandscript::HandleModifyMoneyCommand ( ChatHandler *  handler, Tail  money  )

inlinestatic

    {
        if (money.empty())
        {
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target))
        {
            return false;
        }
 
        auto IsExistWord = [](std::string_view line, std::initializer_list<std::string_view> words)
        {
            for (auto const& word : words)
            {
                if (line.find(word) != std::string_view::npos)
                {
                    return true;
                }
            }
 
            return false;
        };
 
        Optional<int32> moneyToAddO = 0;
        if (IsExistWord(money, { "g", "s", "c" }))
        {
            moneyToAddO = MoneyStringToMoney(money);
        }
        else
        {
            moneyToAddO = Acore::StringTo<int32>(money);
        }
 
        if (!moneyToAddO)
        {
            return false;
        }
 
        int32 moneyToAdd = *moneyToAddO;
        uint32 targetMoney = target->GetMoney();
 
        if (moneyToAdd < 0)
        {
            int32 newmoney = int32(targetMoney) + moneyToAdd;
 
            LOG_DEBUG("chat.system", handler->GetAcoreString(LANG_CURRENT_MONEY), targetMoney, moneyToAdd, newmoney);
            if (newmoney <= 0)
            {
                handler->PSendSysMessage(LANG_YOU_TAKE_ALL_MONEY, handler->GetNameLink(target));
                if (handler->needReportToTarget(target))
                    ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_ALL_MONEY_GONE, handler->GetNameLink());
 
                target->SetMoney(0);
            }
            else
            {
                if (newmoney > MAX_MONEY_AMOUNT)
                    newmoney = MAX_MONEY_AMOUNT;
 
                handler->PSendSysMessage(LANG_YOU_TAKE_MONEY, std::abs(moneyToAdd), handler->GetNameLink(target));
                if (handler->needReportToTarget(target))
                    ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_MONEY_TAKEN, handler->GetNameLink(), std::abs(moneyToAdd));
                target->SetMoney(newmoney);
            }
        }
        else
        {
            handler->PSendSysMessage(LANG_YOU_GIVE_MONEY, moneyToAdd, handler->GetNameLink(target));
            if (handler->needReportToTarget(target))
                ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_MONEY_GIVEN, handler->GetNameLink(), moneyToAdd);
 
            if (moneyToAdd >= MAX_MONEY_AMOUNT)
                moneyToAdd = MAX_MONEY_AMOUNT;
 
            if (targetMoney >= uint32(MAX_MONEY_AMOUNT) - moneyToAdd)
                moneyToAdd -= targetMoney;
 
            target->ModifyMoney(moneyToAdd);
        }
 
        LOG_DEBUG("chat.system", handler->GetAcoreString(LANG_NEW_MONEY), targetMoney, moneyToAdd, target->GetMoney());
 
        return true;
    }

References ChatHandler::GetAcoreString(), Player::GetMoney(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), ChatHandler::HasLowerSecurity(), LANG_CURRENT_MONEY, LANG_NEW_MONEY, LANG_NO_CHAR_SELECTED, LANG_YOU_GIVE_MONEY, LANG_YOU_TAKE_ALL_MONEY, LANG_YOU_TAKE_MONEY, LANG_YOURS_ALL_MONEY_GONE, LANG_YOURS_MONEY_GIVEN, LANG_YOURS_MONEY_TAKEN, LOG_DEBUG, MAX_MONEY_AMOUNT, Player::ModifyMoney(), MoneyStringToMoney(), ChatHandler::needReportToTarget(), ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and Player::SetMoney().

Referenced by GetCommands().

HandleModifyMountCommand()

static bool modify_commandscript::HandleModifyMountCommand ( ChatHandler *  handler, uint32  creatureDisplayID, Optional< float >  speed  )

inlinestatic

    {
        if (!sCreatureDisplayInfoStore.LookupEntry(creatureDisplayID))
        {
            handler->SendErrorMessage(LANG_NO_MOUNT);
            return false;
        }
 
        Player* target = handler->getSelectedPlayerOrSelf();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, ObjectGuid::Empty))
        {
            return false;
        }
 
        float _speed = speed ? *speed : 1.0f;
 
        if (!CheckModifySpeed(handler, target, _speed, 0.1f, 50.0f))
        {
            return false;
        }
 
        NotifyModification(handler, target, LANG_YOU_GIVE_MOUNT, LANG_MOUNT_GIVED);
 
        target->Mount(creatureDisplayID);
        target->SetSpeed(MOVE_RUN, _speed, true);
        target->SetSpeed(MOVE_FLIGHT, _speed, true);
        return true;
    }

References CheckModifySpeed(), ObjectGuid::Empty, ChatHandler::getSelectedPlayerOrSelf(), ChatHandler::HasLowerSecurity(), LANG_MOUNT_GIVED, LANG_NO_CHAR_SELECTED, LANG_NO_MOUNT, LANG_YOU_GIVE_MOUNT, Unit::Mount(), MOVE_FLIGHT, MOVE_RUN, NotifyModification(), sCreatureDisplayInfoStore, ChatHandler::SendErrorMessage(), and Unit::SetSpeed().

Referenced by GetCommands().

HandleModifyPhaseCommand()

static bool modify_commandscript::HandleModifyPhaseCommand ( ChatHandler *  handler, uint32  phaseMask  )

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            target = handler->GetSession()->GetPlayer();
        }
        else if (target->IsPlayer() && handler->HasLowerSecurity(target->ToPlayer())) // check online security
        {
            return false;
        }
 
        target->SetPhaseMask(phaseMask, true);
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), ChatHandler::HasLowerSecurity(), Object::IsPlayer(), Unit::SetPhaseMask(), and Object::ToPlayer().

Referenced by GetCommands().

HandleModifyRageCommand()

static bool modify_commandscript::HandleModifyRageCommand ( ChatHandler *  handler, int32  ragePoints  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
 
        if (!CheckModifyInt32(handler, target, ragePoints))
        {
            return false;
        }
 
        ragePoints *= 10;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_RAGE, handler->GetNameLink(target), ragePoints / 10, ragePoints / 10);
 
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_RAGE_CHANGED, handler->GetNameLink(), ragePoints / 10, ragePoints / 10);
        }
 
        target->SetMaxPower(POWER_RAGE, ragePoints);
        target->SetPower(POWER_RAGE, ragePoints);
 
        return true;
    }

References CheckModifyInt32(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), LANG_YOU_CHANGE_RAGE, LANG_YOURS_RAGE_CHANGED, ChatHandler::needReportToTarget(), POWER_RAGE, ChatHandler::PSendSysMessage(), Unit::SetMaxPower(), and Unit::SetPower().

Referenced by GetCommands().

HandleModifyRepCommand()

static bool modify_commandscript::HandleModifyRepCommand ( ChatHandler *  handler, uint32  factionId, Variant< int32, std::string >  rank, Optional< int32 >  delta  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target))
        {
            return false;
        }
 
        int32 amount = 0;
 
        if (rank.holds_alternative<std::string>())
        {
            std::string rankStr = rank.get<std::string>();
            std::wstring wrankStr;
 
            if (!Utf8toWStr(rankStr, wrankStr))
            {
                return false;
            }
 
            wstrToLower(wrankStr);
 
            int32 r = 0;
            amount = -42000;
 
            for (; r < MAX_REPUTATION_RANK; ++r)
            {
                std::string rank = handler->GetAcoreString(ReputationRankStrIndex[r]);
                if (rank.empty())
                    continue;
 
                std::wstring wrank;
                if (!Utf8toWStr(rank, wrank))
                    continue;
 
                wstrToLower(wrank);
 
                if (wrank.substr(0, wrankStr.size()) == wrankStr)
                {
                    if (delta)
                    {
                        if (*delta < 0 || (*delta > ReputationMgr::PointsInRank[r] - 1))
                        {
                            handler->SendErrorMessage(LANG_COMMAND_FACTION_DELTA, ReputationMgr::PointsInRank[r] - 1);
                            return false;
                        }
 
                        amount += *delta;
                    }
 
                    break;
                }
 
                amount += ReputationMgr::PointsInRank[r];
            }
 
            if (r >= MAX_REPUTATION_RANK)
            {
                handler->SendErrorMessage(LANG_COMMAND_FACTION_INVPARAM, rankStr.c_str());
                return false;
            }
        }
        else
        {
            amount = rank.get<int32>();
        }
 
        if (!amount)
        {
            return false;
        }
 
        FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionId);
 
        if (!factionEntry)
        {
            handler->SendErrorMessage(LANG_COMMAND_FACTION_UNKNOWN, factionId);
            return false;
        }
 
        if (factionEntry->reputationListID < 0)
        {
            handler->SendErrorMessage(LANG_COMMAND_FACTION_NOREP_ERROR, factionEntry->name[handler->GetSessionDbcLocale()], factionId);
            return false;
        }
 
        target->GetReputationMgr().SetOneFactionReputation(factionEntry, float(amount), false);
        target->GetReputationMgr().SendState(target->GetReputationMgr().GetState(factionEntry));
 
        handler->PSendSysMessage(LANG_COMMAND_MODIFY_REP, factionEntry->name[handler->GetSessionDbcLocale()], factionId,
                                 handler->GetNameLink(target), target->GetReputationMgr().GetReputation(factionEntry));
        return true;
    }

References Acore::ChatCommands::Variant< T1, Ts >::get(), ChatHandler::GetAcoreString(), ChatHandler::GetNameLink(), ReputationMgr::GetReputation(), Player::GetReputationMgr(), ChatHandler::getSelectedPlayer(), ChatHandler::GetSessionDbcLocale(), ReputationMgr::GetState(), ChatHandler::HasLowerSecurity(), Acore::ChatCommands::Variant< T1, Ts >::holds_alternative(), LANG_COMMAND_FACTION_DELTA, LANG_COMMAND_FACTION_INVPARAM, LANG_COMMAND_FACTION_NOREP_ERROR, LANG_COMMAND_FACTION_UNKNOWN, LANG_COMMAND_MODIFY_REP, LANG_PLAYER_NOT_FOUND, MAX_REPUTATION_RANK, FactionEntry::name, ReputationMgr::PointsInRank, ChatHandler::PSendSysMessage(), FactionEntry::reputationListID, ReputationRankStrIndex, ChatHandler::SendErrorMessage(), ReputationMgr::SendState(), ReputationMgr::SetOneFactionReputation(), sFactionStore, Utf8toWStr(), and wstrToLower().

Referenced by GetCommands().

HandleModifyRunicPowerCommand()

static bool modify_commandscript::HandleModifyRunicPowerCommand ( ChatHandler *  handler, int32  runePoints  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
 
        if (!CheckModifyInt32(handler, target, runePoints))
        {
            return false;
        }
 
        runePoints *= 10;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_RUNIC_POWER, handler->GetNameLink(target), runePoints / 10, runePoints / 10);
 
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_RUNIC_POWER_CHANGED, handler->GetNameLink(), runePoints / 10, runePoints / 10);
        }
 
        target->SetMaxPower(POWER_RUNIC_POWER, runePoints);
        target->SetPower(POWER_RUNIC_POWER, runePoints);
 
        return true;
    }

References CheckModifyInt32(), ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), LANG_YOU_CHANGE_RUNIC_POWER, LANG_YOURS_RUNIC_POWER_CHANGED, ChatHandler::needReportToTarget(), POWER_RUNIC_POWER, ChatHandler::PSendSysMessage(), Unit::SetMaxPower(), and Unit::SetPower().

Referenced by GetCommands().

HandleModifyScaleCommand()

static bool modify_commandscript::HandleModifyScaleCommand ( ChatHandler *  handler, float  scale  )

inlinestatic

    {
        if (scale > 10.0f || scale < 0.1f)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CHAR_OR_CREATURE);
            return false;
        }
 
        if (Player* player = target->ToPlayer())
        {
            // check online security
            if (handler->HasLowerSecurity(player))
                return false;
 
            handler->PSendSysMessage(LANG_YOU_CHANGE_SIZE, scale, handler->GetNameLink(player));
            if (handler->needReportToTarget(player))
                ChatHandler(player->GetSession()).PSendSysMessage(LANG_YOURS_SIZE_CHANGED, handler->GetNameLink(), scale);
        }
 
        target->SetObjectScale(scale);
 
        return true;
    }

References ChatHandler::GetNameLink(), ChatHandler::getSelectedUnit(), ChatHandler::HasLowerSecurity(), LANG_BAD_VALUE, LANG_SELECT_CHAR_OR_CREATURE, LANG_YOU_CHANGE_SIZE, LANG_YOURS_SIZE_CHANGED, ChatHandler::needReportToTarget(), ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), Object::SetObjectScale(), and Object::ToPlayer().

Referenced by GetCommands().

HandleModifySpeedCommand()

static bool modify_commandscript::HandleModifySpeedCommand ( ChatHandler *  handler, float  speed  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayerOrSelf();
        if (CheckModifySpeed(handler, target, speed, 0.1f, 50.0f))
        {
            NotifyModification(handler, target, LANG_YOU_CHANGE_SPEED, LANG_YOURS_SPEED_CHANGED, speed);
            target->SetSpeedRate(MOVE_RUN, speed);
            return true;
        }
 
        return false;
    }

References CheckModifySpeed(), ChatHandler::getSelectedPlayerOrSelf(), LANG_YOU_CHANGE_SPEED, LANG_YOURS_SPEED_CHANGED, MOVE_RUN, NotifyModification(), and Unit::SetSpeedRate().

Referenced by GetCommands().

HandleModifySpellCommand()

static bool modify_commandscript::HandleModifySpellCommand ( ChatHandler *  handler, uint8  spellFlatID, uint8  op, uint16  val, Optional< uint16 >  mark  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target))
        {
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_SPELLFLATID, spellFlatID, val, mark ? *mark : 65535, handler->GetNameLink(target));
        if (handler->needReportToTarget(target))
        {
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_SPELLFLATID_CHANGED, handler->GetNameLink(), spellFlatID, val, mark ? *mark : 65535);
        }
 
        WorldPacket data(SMSG_SET_FLAT_SPELL_MODIFIER, (1 + 1 + 2 + 2));
        data << uint8(spellFlatID);
        data << uint8(op);
        data << uint16(val);
        data << uint16(mark ? *mark : 65535);
        target->GetSession()->SendPacket(&data);
 
        return true;
    }

References ChatHandler::GetNameLink(), ChatHandler::getSelectedPlayer(), Player::GetSession(), ChatHandler::HasLowerSecurity(), LANG_NO_CHAR_SELECTED, LANG_YOU_CHANGE_SPELLFLATID, LANG_YOURS_SPELLFLATID_CHANGED, ChatHandler::needReportToTarget(), ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), WorldSession::SendPacket(), and SMSG_SET_FLAT_SPELL_MODIFIER.

Referenced by GetCommands().

HandleModifyStandStateCommand()

static bool modify_commandscript::HandleModifyStandStateCommand ( ChatHandler *  handler, uint32  anim  )

inlinestatic

    {
        handler->GetSession()->GetPlayer()->SetUInt32Value(UNIT_NPC_EMOTESTATE, anim);
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), Unit::SetUInt32Value(), and UNIT_NPC_EMOTESTATE.

Referenced by GetCommands().

HandleModifySwimCommand()

static bool modify_commandscript::HandleModifySwimCommand ( ChatHandler *  handler, float  swimSpeed  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayerOrSelf();
        if (CheckModifySpeed(handler, target, swimSpeed, 0.1f, 50.0f))
        {
            NotifyModification(handler, target, LANG_YOU_CHANGE_SWIM_SPEED, LANG_YOURS_SWIM_SPEED_CHANGED, swimSpeed);
            target->SetSpeedRate(MOVE_SWIM, swimSpeed);
            return true;
        }
 
        return false;
    }

References CheckModifySpeed(), ChatHandler::getSelectedPlayerOrSelf(), LANG_YOU_CHANGE_SWIM_SPEED, LANG_YOURS_SWIM_SPEED_CHANGED, MOVE_SWIM, NotifyModification(), and Unit::SetSpeedRate().

Referenced by GetCommands().

HandleModifyTalentCommand()

static bool modify_commandscript::HandleModifyTalentCommand ( ChatHandler *  handler, uint32  talentPoints  )

inlinestatic

    {
        if (!talentPoints)
        {
            return false;
        }
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        if (target->IsPlayer())
        {
            // check online security
            if (handler->HasLowerSecurity(target->ToPlayer()))
            {
                return false;
            }
 
            target->ToPlayer()->SetFreeTalentPoints(talentPoints);
            target->ToPlayer()->SendTalentsInfoData(false);
            return true;
        }
        else if (target->IsPet())
        {
            Unit* owner = target->GetOwner();
            if (owner && owner->IsPlayer() && ((Pet*)target)->IsPermanentPetFor(owner->ToPlayer()))
            {
                // check online security
                if (handler->HasLowerSecurity(owner->ToPlayer()))
                    return false;
                ((Pet*)target)->SetFreeTalentPoints(talentPoints);
                owner->ToPlayer()->SendTalentsInfoData(true);
                return true;
            }
        }
 
        handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
        return false;
    }

References Unit::GetOwner(), ChatHandler::getSelectedUnit(), ChatHandler::HasLowerSecurity(), Unit::IsPet(), Object::IsPlayer(), LANG_NO_CHAR_SELECTED, ChatHandler::SendErrorMessage(), Player::SendTalentsInfoData(), Player::SetFreeTalentPoints(), and Object::ToPlayer().

Referenced by GetCommands().

HandleMorphMountCommand()

static bool modify_commandscript::HandleMorphMountCommand ( ChatHandler *  handler, uint32  displayID  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayerOrSelf();
 
        if (target->IsPlayer() && handler->HasLowerSecurity(target->ToPlayer())) // check online security
            return false;
 
        if (!target->GetAuraEffectsByType(SPELL_AURA_MOUNTED).empty())
            target->SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID, displayID);
        else
            return false;
 
        return true;
    }

References Unit::GetAuraEffectsByType(), ChatHandler::getSelectedPlayerOrSelf(), ChatHandler::HasLowerSecurity(), Object::IsPlayer(), Unit::SetUInt32Value(), SPELL_AURA_MOUNTED, Object::ToPlayer(), and UNIT_FIELD_MOUNTDISPLAYID.

Referenced by GetCommands().

HandleMorphResetCommand()

static bool modify_commandscript::HandleMorphResetCommand ( ChatHandler *  handler )

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            target = handler->GetSession()->GetPlayer();
        }
        else if (target->IsPlayer() && handler->HasLowerSecurity(target->ToPlayer())) // check online security
        {
            return false;
        }
 
        target->DeMorph();
        return true;
    }

References Unit::DeMorph(), WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), ChatHandler::HasLowerSecurity(), Object::IsPlayer(), and Object::ToPlayer().

Referenced by GetCommands().

HandleMorphTargetCommand()

static bool modify_commandscript::HandleMorphTargetCommand ( ChatHandler *  handler, uint32  displayID  )

inlinestatic

    {
        Unit* target = handler->getSelectedUnit();
 
        if (!target)
        {
            target = handler->GetSession()->GetPlayer();
        }
        else if (target->IsPlayer() && handler->HasLowerSecurity(target->ToPlayer())) // check online security
        {
            return false;
        }
 
        target->SetDisplayId(displayID);
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::getSelectedUnit(), ChatHandler::GetSession(), ChatHandler::HasLowerSecurity(), Object::IsPlayer(), Unit::SetDisplayId(), and Object::ToPlayer().

Referenced by GetCommands().

NotifyModification()

template<typename... Args>

static void modify_commandscript::NotifyModification ( ChatHandler *  handler, Unit *  target, AcoreStrings  resourceMessage, AcoreStrings  resourceReportMessage, Args &&...  args  )

inlinestatic

    {
        if (Player* player = target->ToPlayer())
        {
            handler->PSendSysMessage(resourceMessage, std::forward<Args>(args)..., handler->GetNameLink(player));
 
            if (handler->needReportToTarget(player))
            {
                ChatHandler(player->GetSession()).PSendSysMessage(resourceReportMessage, handler->GetNameLink(), std::forward<Args>(args)...);
            }
        }
    }

References ChatHandler::GetNameLink(), ChatHandler::needReportToTarget(), ChatHandler::PSendSysMessage(), and Object::ToPlayer().

Referenced by HandleModifyASpeedCommand(), HandleModifyBWalkCommand(), HandleModifyFlyCommand(), HandleModifyMountCommand(), HandleModifySpeedCommand(), and HandleModifySwimCommand().

---

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

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