cs_modify.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org.
* See LICENSE.md file for Copyright information
*/
 
/* ScriptData
Name: modify_commandscript
%Complete: 100
Comment: All modify related commands
Category: commandscripts
EndScriptData */
 
#include "Chat.h"
#include "ObjectMgr.h"
#include "Opcodes.h"
#include "Pet.h"
#include "Player.h"
#include "ReputationMgr.h"
#include "ScriptMgr.h"
#include <stdlib.h>
 
 
class modify_commandscript : public CommandScript
{
public:
    modify_commandscript() : CommandScript("modify_commandscript") { }
 
    std::vector<ChatCommand> GetCommands() const OVERRIDE
    {
        static std::vector<ChatCommand> modifyspeedCommandTable =
        {
            { "all",      rbac::RBAC_PERM_COMMAND_MODIFY_SPEED_ALL,      false, &HandleModifyASpeedCommand, "", },
            { "backwalk", rbac::RBAC_PERM_COMMAND_MODIFY_SPEED_BACKWALK, false, &HandleModifyBWalkCommand,  "", },
            { "fly",      rbac::RBAC_PERM_COMMAND_MODIFY_SPEED_FLY,      false, &HandleModifyFlyCommand,    "", },
            { "walk",     rbac::RBAC_PERM_COMMAND_MODIFY_SPEED_WALK,     false, &HandleModifySpeedCommand,  "", },
            { "swim",     rbac::RBAC_PERM_COMMAND_MODIFY_SPEED_SWIM,     false, &HandleModifySwimCommand,   "", },
            { "",         rbac::RBAC_PERM_COMMAND_MODIFY_SPEED,          false, &HandleModifyASpeedCommand, "", },
        };
        static std::vector<ChatCommand> modifyCommandTable =
        {
            { "bit",          rbac::RBAC_PERM_COMMAND_MODIFY_BIT,          false, &HandleModifyBitCommand,           "", },
            { "drunk",        rbac::RBAC_PERM_COMMAND_MODIFY_DRUNK,        false, &HandleModifyDrunkCommand,         "", },
            { "energy",       rbac::RBAC_PERM_COMMAND_MODIFY_ENERGY,       false, &HandleModifyEnergyCommand,        "", },
            { "faction",      rbac::RBAC_PERM_COMMAND_MODIFY_FACTION,      false, &HandleModifyFactionCommand,       "", },
            { "gender",       rbac::RBAC_PERM_COMMAND_MODIFY_GENDER,       false, &HandleModifyGenderCommand,        "", },
            { "honor",        rbac::RBAC_PERM_COMMAND_MODIFY_HONOR,        false, &HandleModifyHonorCommand,         "", },
            { "hp",           rbac::RBAC_PERM_COMMAND_MODIFY_HP,           false, &HandleModifyHPCommand,            "", },
            { "mana",         rbac::RBAC_PERM_COMMAND_MODIFY_MANA,         false, &HandleModifyManaCommand,          "", },
            { "money",        rbac::RBAC_PERM_COMMAND_MODIFY_MONEY,        false, &HandleModifyMoneyCommand,         "", },
            { "mount",        rbac::RBAC_PERM_COMMAND_MODIFY_MOUNT,        false, &HandleModifyMountCommand,         "", },
            { "phase",        rbac::RBAC_PERM_COMMAND_MODIFY_PHASE,        false, &HandleModifyPhaseCommand,         "", },
            { "rage",         rbac::RBAC_PERM_COMMAND_MODIFY_RAGE,         false, &HandleModifyRageCommand,          "", },
            { "reputation",   rbac::RBAC_PERM_COMMAND_MODIFY_REPUTATION,   false, &HandleModifyRepCommand,           "", },
            { "runicpower",   rbac::RBAC_PERM_COMMAND_MODIFY_RUNICPOWER,   false, &HandleModifyRunicPowerCommand,    "", },
            { "scale",        rbac::RBAC_PERM_COMMAND_MODIFY_SCALE,        false, &HandleModifyScaleCommand,         "", },
            { "speed",        rbac::RBAC_PERM_COMMAND_MODIFY_SPEED,        false, NULL,           "", modifyspeedCommandTable },
            { "spell",        rbac::RBAC_PERM_COMMAND_MODIFY_SPELL,        false, &HandleModifySpellCommand,         "", },
            { "standstate",   rbac::RBAC_PERM_COMMAND_MODIFY_STANDSTATE,   false, &HandleModifyStandStateCommand,    "", },
        };
        static std::vector<ChatCommand> commandTable =
        {
            { "morph",   rbac::RBAC_PERM_COMMAND_MORPH,   false, &HandleModifyMorphCommand,          "", },
            { "demorph", rbac::RBAC_PERM_COMMAND_DEMORPH, false, &HandleDeMorphCommand,              "", },
            { "modify",  rbac::RBAC_PERM_COMMAND_MODIFY,  false, NULL,                 "", modifyCommandTable },
        };
        return commandTable;
    }
 
    //Edit Player HP
    static bool HandleModifyHPCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        int32 hp = atoi((char*)args);
        int32 hpm = atoi((char*)args);
 
        if (hp < 1 || hpm < 1 || hpm < hp)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_HP, handler->GetNameLink(target).c_str(), hp, hpm);
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_HP_CHANGED, handler->GetNameLink().c_str(), hp, hpm);
 
        target->SetMaxHealth(hpm);
        target->SetHealth(hp);
 
        return true;
    }
 
    //Edit Player Mana
    static bool HandleModifyManaCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        int32 mana = atoi((char*)args);
        int32 manam = atoi((char*)args);
 
        if (mana <= 0 || manam <= 0 || manam < mana)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_MANA, handler->GetNameLink(target).c_str(), mana, manam);
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_MANA_CHANGED, handler->GetNameLink().c_str(), mana, manam);
 
        target->SetMaxPower(POWER_MANA, manam);
        target->SetPower(POWER_MANA, mana);
 
        return true;
    }
 
    //Edit Player Energy
    static bool HandleModifyEnergyCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        // char* pmana = strtok((char*)args, " ");
        // if (!pmana)
        //     return false;
 
        // char* pmanaMax = strtok(NULL, " ");
        // if (!pmanaMax)
        //     return false;
 
        // int32 manam = atoi(pmanaMax);
        // int32 mana = atoi(pmana);
 
        int32 energy = atoi((char*)args) * 10;
        int32 energym = atoi((char*)args) * 10;
 
        if (energy <= 0 || energym <= 0 || energym < energy)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_ENERGY, handler->GetNameLink(target).c_str(), energy / 10, energym / 10);
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_ENERGY_CHANGED, handler->GetNameLink().c_str(), energy / 10, energym / 10);
 
        target->SetMaxPower(POWER_ENERGY, energym);
        target->SetPower(POWER_ENERGY, energy);
 
        SF_LOG_DEBUG("misc", handler->GetSkyFireString(LANG_CURRENT_ENERGY), target->GetMaxPower(POWER_ENERGY));
 
        return true;
    }
 
    //Edit Player Rage
    static bool HandleModifyRageCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        // char* pmana = strtok((char*)args, " ");
        // if (!pmana)
        //     return false;
 
        // char* pmanaMax = strtok(NULL, " ");
        // if (!pmanaMax)
        //     return false;
 
        // int32 manam = atoi(pmanaMax);
        // int32 mana = atoi(pmana);
 
        int32 rage = atoi((char*)args) * 10;
        int32 ragem = atoi((char*)args) * 10;
 
        if (rage <= 0 || ragem <= 0 || ragem < rage)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_RAGE, handler->GetNameLink(target).c_str(), rage / 10, ragem / 10);
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_RAGE_CHANGED, handler->GetNameLink().c_str(), rage / 10, ragem / 10);
 
        target->SetMaxPower(POWER_RAGE, ragem);
        target->SetPower(POWER_RAGE, rage);
 
        return true;
    }
 
    // Edit Player Runic Power
    static bool HandleModifyRunicPowerCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        int32 rune = atoi((char*)args) * 10;
        int32 runem = atoi((char*)args) * 10;
 
        if (rune <= 0 || runem <= 0 || runem < rune)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_RUNIC_POWER, handler->GetNameLink(target).c_str(), rune / 10, runem / 10);
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_RUNIC_POWER_CHANGED, handler->GetNameLink().c_str(), rune / 10, runem / 10);
 
        target->SetMaxPower(POWER_RUNIC_POWER, runem);
        target->SetPower(POWER_RUNIC_POWER, rune);
 
        return true;
    }
 
    //Edit Player Faction
    static bool HandleModifyFactionCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        char* pfactionid = handler->extractKeyFromLink((char*)args, "Hfaction");
 
        Creature* target = handler->getSelectedCreature();
        if (!target)
        {
            handler->SendSysMessage(LANG_SELECT_CREATURE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        if (!pfactionid)
        {
            uint32 factionid = target->getFaction();
            uint32 flag = target->GetUInt32Value(UNIT_FIELD_FLAGS);
            uint32 npcflag = target->GetUInt32Value(UNIT_FIELD_NPC_FLAGS);
            uint32 dyflag = target->GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS);
            handler->PSendSysMessage(LANG_CURRENT_FACTION, target->GetGUIDLow(), factionid, flag, npcflag, dyflag);
            return true;
        }
 
        uint32 factionid = atoi(pfactionid);
        uint32 flag;
 
        char* pflag = strtok(NULL, " ");
        if (!pflag)
            flag = target->GetUInt32Value(UNIT_FIELD_FLAGS);
        else
            flag = atoi(pflag);
 
        char* pnpcflag = strtok(NULL, " ");
 
        uint32 npcflag;
        if (!pnpcflag)
            npcflag = target->GetUInt32Value(UNIT_FIELD_NPC_FLAGS);
        else
            npcflag = atoi(pnpcflag);
 
        char* pdyflag = strtok(NULL, " ");
 
        uint32  dyflag;
        if (!pdyflag)
            dyflag = target->GetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS);
        else
            dyflag = atoi(pdyflag);
 
        if (!sFactionTemplateStore.LookupEntry(factionid))
        {
            handler->PSendSysMessage(LANG_WRONG_FACTION, factionid);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_FACTION, target->GetGUIDLow(), factionid, flag, npcflag, dyflag);
 
        target->setFaction(factionid);
        target->SetUInt32Value(UNIT_FIELD_FLAGS, flag);
        target->SetUInt32Value(UNIT_FIELD_NPC_FLAGS, npcflag);
        target->SetUInt32Value(OBJECT_FIELD_DYNAMIC_FLAGS, dyflag);
 
        return true;
    }
 
    //Edit Player Spell
    static bool HandleModifySpellCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        char* pspellflatid = strtok((char*)args, " ");
        if (!pspellflatid)
            return false;
 
        char* pop = strtok(NULL, " ");
        if (!pop)
            return false;
 
        char* pval = strtok(NULL, " ");
        if (!pval)
            return false;
 
        uint16 mark;
 
        char* pmark = strtok(NULL, " ");
 
        uint8 spellflatid = atoi(pspellflatid);
        uint8 op = atoi(pop);
        uint16 val = atoi(pval);
        if (!pmark)
            mark = 65535;
        else
            mark = atoi(pmark);
 
        Player* target = handler->getSelectedPlayer();
        if (target == NULL)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_SPELLFLATID, spellflatid, val, mark, handler->GetNameLink(target).c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_SPELLFLATID_CHANGED, handler->GetNameLink().c_str(), spellflatid, val, mark);
 
        WorldPacket data(SMSG_SET_FLAT_SPELL_MODIFIER, (1 + 1 + 2 + 2));
        data << uint8(spellflatid);
        data << uint8(op);
        data << uint16(val);
        data << uint16(mark);
        target->GetSession()->SendPacket(&data);
 
        return true;
    }
 
    //Edit Player Aspeed
    static bool HandleModifyASpeedCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        float ASpeed = (float)atof((char*)args);
 
        if (ASpeed > 50.0f || ASpeed < 0.1f)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        std::string targetNameLink = handler->GetNameLink(target);
 
        if (target->IsInFlight())
        {
            handler->PSendSysMessage(LANG_CHAR_IN_FLIGHT, targetNameLink.c_str());
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_ASPEED, ASpeed, targetNameLink.c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_ASPEED_CHANGED, handler->GetNameLink().c_str(), ASpeed);
 
        target->SetSpeed(MOVE_WALK, ASpeed, true);
        target->SetSpeed(MOVE_RUN, ASpeed, true);
        target->SetSpeed(MOVE_SWIM, ASpeed, true);
        //target->SetSpeed(MOVE_TURN,    ASpeed, true);
        target->SetSpeed(MOVE_FLIGHT, ASpeed, true);
        return true;
    }
 
    //Edit Player Speed
    static bool HandleModifySpeedCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        float Speed = (float)atof((char*)args);
 
        if (Speed > 50.0f || Speed < 0.1f)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        std::string targetNameLink = handler->GetNameLink(target);
 
        if (target->IsInFlight())
        {
            handler->PSendSysMessage(LANG_CHAR_IN_FLIGHT, targetNameLink.c_str());
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_SPEED, Speed, targetNameLink.c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_SPEED_CHANGED, handler->GetNameLink().c_str(), Speed);
 
        target->SetSpeed(MOVE_RUN, Speed, true);
 
        return true;
    }
 
    //Edit Player Swim Speed
    static bool HandleModifySwimCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        float Swim = (float)atof((char*)args);
 
        if (Swim > 50.0f || Swim < 0.1f)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        std::string targetNameLink = handler->GetNameLink(target);
 
        if (target->IsInFlight())
        {
            handler->PSendSysMessage(LANG_CHAR_IN_FLIGHT, targetNameLink.c_str());
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_SWIM_SPEED, Swim, targetNameLink.c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_SWIM_SPEED_CHANGED, handler->GetNameLink().c_str(), Swim);
 
        target->SetSpeed(MOVE_SWIM, Swim, true);
 
        return true;
    }
 
    //Edit Player Walk Speed
    static bool HandleModifyBWalkCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        float BSpeed = (float)atof((char*)args);
 
        if (BSpeed > 50.0f || BSpeed < 0.1f)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        std::string targetNameLink = handler->GetNameLink(target);
 
        if (target->IsInFlight())
        {
            handler->PSendSysMessage(LANG_CHAR_IN_FLIGHT, targetNameLink.c_str());
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_BACK_SPEED, BSpeed, targetNameLink.c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_BACK_SPEED_CHANGED, handler->GetNameLink().c_str(), BSpeed);
 
        target->SetSpeed(MOVE_RUN_BACK, BSpeed, true);
 
        return true;
    }
 
    //Edit Player Fly
    static bool HandleModifyFlyCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        float FSpeed = (float)atof((char*)args);
 
        if (FSpeed > 50.0f || FSpeed < 0.1f)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_FLY_SPEED, FSpeed, handler->GetNameLink(target).c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_FLY_SPEED_CHANGED, handler->GetNameLink().c_str(), FSpeed);
 
        target->SetSpeed(MOVE_FLIGHT, FSpeed, true);
 
        return true;
    }
 
    //Edit Player or Creature Scale
    static bool HandleModifyScaleCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        float Scale = (float)atof((char*)args);
        if (Scale > 10.0f || Scale < 0.1f)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendSysMessage(LANG_SELECT_CHAR_OR_CREATURE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        if (Player* player = target->ToPlayer())
        {
            // check online security
            if (handler->HasLowerSecurity(player, 0))
                return false;
 
            handler->PSendSysMessage(LANG_YOU_CHANGE_SIZE, Scale, handler->GetNameLink(player).c_str());
            if (handler->needReportToTarget(player))
                ChatHandler(player->GetSession()).PSendSysMessage(LANG_YOURS_SIZE_CHANGED, handler->GetNameLink().c_str(), Scale);
        }
 
        target->SetObjectScale(Scale);
 
        return true;
    }
 
    //Enable Player mount
    static bool HandleModifyMountCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        uint16 mId = 1147;
        float speed = (float)15;
        uint32 num = 0;
 
        num = atoi((char*)args);
        switch (num)
        {
            case 1:
                mId = 14340;
                break;
            case 2:
                mId = 4806;
                break;
            case 3:
                mId = 6471;
                break;
            case 4:
                mId = 12345;
                break;
            case 5:
                mId = 6472;
                break;
            case 6:
                mId = 6473;
                break;
            case 7:
                mId = 10670;
                break;
            case 8:
                mId = 10719;
                break;
            case 9:
                mId = 10671;
                break;
            case 10:
                mId = 10672;
                break;
            case 11:
                mId = 10720;
                break;
            case 12:
                mId = 14349;
                break;
            case 13:
                mId = 11641;
                break;
            case 14:
                mId = 12244;
                break;
            case 15:
                mId = 12242;
                break;
            case 16:
                mId = 14578;
                break;
            case 17:
                mId = 14579;
                break;
            case 18:
                mId = 14349;
                break;
            case 19:
                mId = 12245;
                break;
            case 20:
                mId = 14335;
                break;
            case 21:
                mId = 207;
                break;
            case 22:
                mId = 2328;
                break;
            case 23:
                mId = 2327;
                break;
            case 24:
                mId = 2326;
                break;
            case 25:
                mId = 14573;
                break;
            case 26:
                mId = 14574;
                break;
            case 27:
                mId = 14575;
                break;
            case 28:
                mId = 604;
                break;
            case 29:
                mId = 1166;
                break;
            case 30:
                mId = 2402;
                break;
            case 31:
                mId = 2410;
                break;
            case 32:
                mId = 2409;
                break;
            case 33:
                mId = 2408;
                break;
            case 34:
                mId = 2405;
                break;
            case 35:
                mId = 14337;
                break;
            case 36:
                mId = 6569;
                break;
            case 37:
                mId = 10661;
                break;
            case 38:
                mId = 10666;
                break;
            case 39:
                mId = 9473;
                break;
            case 40:
                mId = 9476;
                break;
            case 41:
                mId = 9474;
                break;
            case 42:
                mId = 14374;
                break;
            case 43:
                mId = 14376;
                break;
            case 44:
                mId = 14377;
                break;
            case 45:
                mId = 2404;
                break;
            case 46:
                mId = 2784;
                break;
            case 47:
                mId = 2787;
                break;
            case 48:
                mId = 2785;
                break;
            case 49:
                mId = 2736;
                break;
            case 50:
                mId = 2786;
                break;
            case 51:
                mId = 14347;
                break;
            case 52:
                mId = 14346;
                break;
            case 53:
                mId = 14576;
                break;
            case 54:
                mId = 9695;
                break;
            case 55:
                mId = 9991;
                break;
            case 56:
                mId = 6448;
                break;
            case 57:
                mId = 6444;
                break;
            case 58:
                mId = 6080;
                break;
            case 59:
                mId = 6447;
                break;
            case 60:
                mId = 4805;
                break;
            case 61:
                mId = 9714;
                break;
            case 62:
                mId = 6448;
                break;
            case 63:
                mId = 6442;
                break;
            case 64:
                mId = 14632;
                break;
            case 65:
                mId = 14332;
                break;
            case 66:
                mId = 14331;
                break;
            case 67:
                mId = 8469;
                break;
            case 68:
                mId = 2830;
                break;
            case 69:
                mId = 2346;
                break;
            default:
                handler->SendSysMessage(LANG_NO_MOUNT);
                handler->SetSentErrorMessage(true);
                return false;
        }
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        handler->PSendSysMessage(LANG_YOU_GIVE_MOUNT, handler->GetNameLink(target).c_str());
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_MOUNT_GIVED, handler->GetNameLink().c_str());
 
        target->SetUInt32Value(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP);
        target->Mount(mId);
 
        WorldPacket data(SMSG_MOVE_SET_RUN_SPEED, (8 + 4 + 1 + 4));
        data.append(target->GetPackGUID());
        data << (uint32)0;
        data << (uint8)0;                                       //new 2.1.0
        data << float(speed);
        target->SendMessageToSet(&data, true);
 
        data.Initialize(SMSG_MOVE_SET_SWIM_SPEED, (8 + 4 + 4));
        data.append(target->GetPackGUID());
        data << (uint32)0;
        data << float(speed);
        target->SendMessageToSet(&data, true);
 
        return true;
    }
 
    //Edit Player money
    static bool HandleModifyMoneyCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        int64 moneyToAdd = 0;
        if (strchr(args, 'g') || strchr(args, 's') || strchr(args, 'c'))
            moneyToAdd = MoneyStringToMoney(std::string(args));
        else
            moneyToAdd = atol(args);
 
        uint64 targetMoney = target->GetMoney();
 
        if (moneyToAdd < 0)
        {
            int64 newmoney = int64(targetMoney) + moneyToAdd;
 
            SF_LOG_DEBUG("misc", handler->GetSkyFireString(LANG_CURRENT_MONEY), uint32(targetMoney), int32(moneyToAdd), uint32(newmoney));
            if (newmoney <= 0)
            {
                handler->PSendSysMessage(LANG_YOU_TAKE_ALL_MONEY, handler->GetNameLink(target).c_str());
                if (handler->needReportToTarget(target))
                    ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_ALL_MONEY_GONE, handler->GetNameLink().c_str());
 
                target->SetMoney(0);
            }
            else
            {
                uint32 moneyToAddMsg = moneyToAdd * -1;
                if (newmoney > int64(MAX_MONEY_AMOUNT))
                    newmoney = MAX_MONEY_AMOUNT;
 
                handler->PSendSysMessage(LANG_YOU_TAKE_MONEY, moneyToAddMsg, handler->GetNameLink(target).c_str());
                if (handler->needReportToTarget(target))
                    ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_MONEY_TAKEN, handler->GetNameLink().c_str(), moneyToAddMsg);
                target->SetMoney(newmoney);
            }
        }
        else
        {
            handler->PSendSysMessage(LANG_YOU_GIVE_MONEY, uint32(moneyToAdd), handler->GetNameLink(target).c_str());
            if (handler->needReportToTarget(target))
                ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOURS_MONEY_GIVEN, handler->GetNameLink().c_str(), uint32(moneyToAdd));
 
            if (moneyToAdd >= int64(MAX_MONEY_AMOUNT))
                moneyToAdd = MAX_MONEY_AMOUNT;
 
            if (targetMoney >= uint64(MAX_MONEY_AMOUNT) - moneyToAdd)
                moneyToAdd -= targetMoney;
 
            target->ModifyMoney(moneyToAdd);
        }
 
        SF_LOG_DEBUG("misc", handler->GetSkyFireString(LANG_NEW_MONEY), uint32(targetMoney), int32(moneyToAdd), uint32(target->GetMoney()));
 
        return true;
    }
 
    //Edit Unit field
    static bool HandleModifyBitCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
        {
            handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (target->GetTypeId() == TypeID::TYPEID_PLAYER && handler->HasLowerSecurity(target->ToPlayer(), 0))
            return false;
 
        char* pField = strtok((char*)args, " ");
        if (!pField)
            return false;
 
        char* pBit = strtok(NULL, " ");
        if (!pBit)
            return false;
 
        uint16 field = atoi(pField);
        uint32 bit = atoi(pBit);
 
        if (field < OBJECT_END || field >= target->GetValuesCount())
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            return false;
        }
        if (bit < 1 || bit > 32)
        {
            handler->SendSysMessage(LANG_BAD_VALUE);
            handler->SetSentErrorMessage(true);
            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;
    }
 
    static bool HandleModifyHonorCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        int32 amount = (uint32)atoi(args);
 
        target->ModifyCurrency(CURRENCY_TYPE_HONOR_POINTS, amount, true, true);
 
        handler->PSendSysMessage(LANG_COMMAND_MODIFY_HONOR, handler->GetNameLink(target).c_str(), target->GetCurrency(CURRENCY_TYPE_HONOR_POINTS, false));
 
        return true;
    }
 
    static bool HandleModifyDrunkCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        uint8 drunklevel = (uint8)atoi(args);
        if (drunklevel > 100)
            drunklevel = 100;
 
        if (Player* target = handler->getSelectedPlayer())
            target->SetDrunkValue(drunklevel);
 
        return true;
    }
 
    static bool HandleModifyRepCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // check online security
        if (handler->HasLowerSecurity(target, 0))
            return false;
 
        char* factionTxt = handler->extractKeyFromLink((char*)args, "Hfaction");
        if (!factionTxt)
            return false;
 
        uint32 factionId = atoi(factionTxt);
 
        int32 amount = 0;
        char* rankTxt = strtok(NULL, " ");
        if (!factionId || !rankTxt)
            return false;
 
        amount = atoi(rankTxt);
        if ((amount == 0) && (rankTxt[0] != '-') && !isdigit(rankTxt[0]))
        {
            std::string rankStr = rankTxt;
            std::wstring wrankStr;
            if (!Utf8toWStr(rankStr, wrankStr))
                return false;
            wstrToLower(wrankStr);
 
            int r = 0;
            amount = -42000;
            for (; r < MAX_REPUTATION_RANK; ++r)
            {
                std::string rank = handler->GetSkyFireString(ReputationRankStrIndex[r]);
                if (rank.empty())
                    continue;
 
                std::wstring wrank;
                if (!Utf8toWStr(rank, wrank))
                    continue;
 
                wstrToLower(wrank);
 
                if (wrank.substr(0, wrankStr.size()) == wrankStr)
                {
                    char* deltaTxt = strtok(NULL, " ");
                    if (deltaTxt)
                    {
                        int32 delta = atoi(deltaTxt);
                        if ((delta < 0) || (delta > ReputationMgr::PointsInRank[r] - 1))
                        {
                            handler->PSendSysMessage(LANG_COMMAND_FACTION_DELTA, (ReputationMgr::PointsInRank[r] - 1));
                            handler->SetSentErrorMessage(true);
                            return false;
                        }
                        amount += delta;
                    }
                    break;
                }
                amount += ReputationMgr::PointsInRank[r];
            }
            if (r >= MAX_REPUTATION_RANK)
            {
                handler->PSendSysMessage(LANG_COMMAND_FACTION_INVPARAM, rankTxt);
                handler->SetSentErrorMessage(true);
                return false;
            }
        }
 
        FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionId);
 
        if (!factionEntry)
        {
            handler->PSendSysMessage(LANG_COMMAND_FACTION_UNKNOWN, factionId);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        if (factionEntry->reputationListID < 0)
        {
            handler->PSendSysMessage(LANG_COMMAND_FACTION_NOREP_ERROR, factionEntry->name, factionId);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        target->GetReputationMgr().SetOneFactionReputation(factionEntry, amount, false);
        target->GetReputationMgr().SendState(target->GetReputationMgr().GetState(factionEntry));
        handler->PSendSysMessage(LANG_COMMAND_MODIFY_REP, factionEntry->name, factionId,
            handler->GetNameLink(target).c_str(), target->GetReputationMgr().GetReputation(factionEntry));
        return true;
    }
 
    //morph creature or player
    static bool HandleModifyMorphCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        uint16 display_id = (uint16)atoi((char*)args);
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
            target = handler->GetSession()->GetPlayer();
 
        // check online security
        else if (target->GetTypeId() == TypeID::TYPEID_PLAYER && handler->HasLowerSecurity(target->ToPlayer(), 0))
            return false;
 
        target->SetDisplayId(display_id);
 
        return true;
    }
 
    //set temporary phase mask for player
    static bool HandleModifyPhaseCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        uint32 phase = (uint32)atoi((char*)args);
 
        Unit* target = handler->getSelectedUnit();
        if (!target)
            target = handler->GetSession()->GetPlayer();
 
        target->SetPhased(phase, true, !target->IsPhased(phase));
 
        return true;
    }
 
    //change standstate
    static bool HandleModifyStandStateCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        uint32 anim_id = atoi((char*)args);
        handler->GetSession()->GetPlayer()->SetUInt32Value(UNIT_FIELD_NPC_EMOTESTATE, anim_id);
 
        return true;
    }
 
    static bool HandleModifyGenderCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        Player* target = handler->getSelectedPlayer();
 
        if (!target)
        {
            handler->PSendSysMessage(LANG_PLAYER_NOT_FOUND);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        PlayerInfo const* info = sObjectMgr->GetPlayerInfo(target->getRace(), target->getClass());
        if (!info)
            return false;
 
        char const* gender_str = (char*)args;
        int gender_len = strlen(gender_str);
 
        Gender gender;
 
        if (!strncmp(gender_str, "male", gender_len))            // MALE
        {
            if (target->getGender() == GENDER_MALE)
                return true;
 
            gender = GENDER_MALE;
        }
        else if (!strncmp(gender_str, "female", gender_len))    // FEMALE
        {
            if (target->getGender() == GENDER_FEMALE)
                return true;
 
            gender = GENDER_FEMALE;
        }
        else
        {
            handler->SendSysMessage(LANG_MUST_MALE_OR_FEMALE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        // Set gender
        target->SetGender(gender);
        target->SetByteValue(PLAYER_FIELD_PVP_INFO, 0, gender);
 
        // Change display ID
        target->InitDisplayIds();
 
        char const* gender_full = gender ? "female" : "male";
 
        handler->PSendSysMessage(LANG_YOU_CHANGE_GENDER, handler->GetNameLink(target).c_str(), gender_full);
 
        if (handler->needReportToTarget(target))
            ChatHandler(target->GetSession()).PSendSysMessage(LANG_YOUR_GENDER_CHANGED, gender_full, handler->GetNameLink().c_str());
 
        return true;
    }
    //demorph player or unit
    static bool HandleDeMorphCommand(ChatHandler* handler, const char* /*args*/)
    {
        Unit* target = handler->getSelectedUnit();
        if (!target)
            target = handler->GetSession()->GetPlayer();
 
        // check online security
        else if (target->GetTypeId() == TypeID::TYPEID_PLAYER && handler->HasLowerSecurity(target->ToPlayer(), 0))
            return false;
 
        target->DeMorph();
 
        return true;
    }
 
    static bool HandleModifyCurrencyCommand(ChatHandler* handler, const char* args)
    {
        if (!*args)
            return false;
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->PSendSysMessage(LANG_PLAYER_NOT_FOUND);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        char* currencyIdStr = strtok((char*)args, " ");
        if (!currencyIdStr)
            return false;
 
        uint32 currencyId = atoi(currencyIdStr);
        const CurrencyTypesEntry* currencyType = sCurrencyTypesStore.LookupEntry(currencyId);
        if (!currencyType)
            return false;
 
        char* amountStr = strtok(NULL, " ");
        if (!amountStr)
            return false;
 
        uint32 amount = atoi(amountStr);
        if (!amount)
            return false;
 
        target->ModifyCurrency(currencyId, amount, true, true);
 
        return true;
    }
};
 
void AddSC_modify_commandscript()
{
    new modify_commandscript();
}