reset_commandscript Class Reference

Inheritance diagram for reset_commandscript:

Public Member Functions
	reset_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleResetAchievementsCommand (ChatHandler *, Optional< PlayerIdentifier > target)
static bool	HandleResetHonorCommand (ChatHandler *, Optional< PlayerIdentifier > target)
static bool	HandleResetStatsOrLevelHelper (Player *player)
static bool	HandleResetLevelCommand (ChatHandler *, Optional< PlayerIdentifier > target)
static bool	HandleResetSpellsCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetStatsCommand (ChatHandler *, Optional< PlayerIdentifier > target)
static bool	HandleResetTalentsCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetAllCommand (ChatHandler *handler, std::string_view caseName)
static bool	HandleResetItemsEquippedCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsInBagsCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsKeyringCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsInCurrenciesListCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsInBankCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsInVendorBuyBackTabCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsAllCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)
static bool	HandleResetItemsAllAndDeleteBagsCommand (ChatHandler *handler, Optional< PlayerIdentifier > target)

Static Private Member Functions
static Player *	GetPlayerFromIdentifierOrSelectedTarget (ChatHandler *handler, Optional< PlayerIdentifier > target)
static int16	ResetItemsEquipped (Player *playerTarget)
static int16	ResetItemsInBags (Player *playerTarget)
static int16	ResetItemsInBank (Player *playerTarget)
static int16	ResetItemsInKeyring (Player *playerTarget)
static int16	ResetItemsInCurrenciesList (Player *playerTarget)
static int16	ResetItemsInVendorBuyBackTab (Player *playerTarget)
static int16	ResetItemsDeleteStandardBags (Player *playerTarget)
static int16	ResetItemsDeleteBankBags (Player *playerTarget)

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

reset_commandscript()

reset_commandscript::reset_commandscript ( )

inline

: CommandScript("reset_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable reset_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable resetItemsCommandTable =
        {
            { "equipped",       HandleResetItemsEquippedCommand,             SEC_ADMINISTRATOR, Console::Yes },
            { "bags",           HandleResetItemsInBagsCommand,              SEC_ADMINISTRATOR, Console::Yes },
            { "bank",           HandleResetItemsInBankCommand,              SEC_ADMINISTRATOR, Console::Yes },
            { "keyring",        HandleResetItemsKeyringCommand,             SEC_ADMINISTRATOR, Console::Yes },
            { "currency",       HandleResetItemsInCurrenciesListCommand,    SEC_ADMINISTRATOR, Console::Yes },
            { "vendor_buyback", HandleResetItemsInVendorBuyBackTabCommand,  SEC_ADMINISTRATOR, Console::Yes },
            { "all",            HandleResetItemsAllCommand,                 SEC_ADMINISTRATOR, Console::Yes },
            { "allbags",        HandleResetItemsAllAndDeleteBagsCommand,    SEC_ADMINISTRATOR, Console::Yes },
        };
        static ChatCommandTable resetCommandTable =
        {
            { "achievements",   HandleResetAchievementsCommand, SEC_CONSOLE,       Console::Yes },
            { "honor",          HandleResetHonorCommand,        SEC_ADMINISTRATOR, Console::Yes },
            { "level",          HandleResetLevelCommand,        SEC_ADMINISTRATOR, Console::Yes },
            { "spells",         HandleResetSpellsCommand,       SEC_ADMINISTRATOR, Console::Yes },
            { "stats",          HandleResetStatsCommand,        SEC_ADMINISTRATOR, Console::Yes },
            { "talents",        HandleResetTalentsCommand,      SEC_ADMINISTRATOR, Console::Yes },
            { "items",          resetItemsCommandTable                                          },
            { "all",            HandleResetAllCommand,          SEC_CONSOLE,       Console::Yes }
        };
        static ChatCommandTable commandTable =
        {
            { "reset", resetCommandTable }
        };
        return commandTable;
    }

References HandleResetAchievementsCommand(), HandleResetAllCommand(), HandleResetHonorCommand(), HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), HandleResetItemsEquippedCommand(), HandleResetItemsInBagsCommand(), HandleResetItemsInBankCommand(), HandleResetItemsInCurrenciesListCommand(), HandleResetItemsInVendorBuyBackTabCommand(), HandleResetItemsKeyringCommand(), HandleResetLevelCommand(), HandleResetSpellsCommand(), HandleResetStatsCommand(), HandleResetTalentsCommand(), SEC_ADMINISTRATOR, and SEC_CONSOLE.

GetPlayerFromIdentifierOrSelectedTarget()

static Player * reset_commandscript::GetPlayerFromIdentifierOrSelectedTarget ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestaticprivate

    {
        Player* targetPlayer = nullptr;
 
        // Check if there is an optional target player name
        // Do not use TargetOrSelf, we must be sure to select ourself
        if (!target)
        {
            // No optional target, so try to get selected target
            target = PlayerIdentifier::FromTarget(handler);
 
            if (!target)
            {
                // No character selected
                handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
                return targetPlayer;
            }
 
            targetPlayer = target->GetConnectedPlayer();
        }
        else
        {
            targetPlayer = target->GetConnectedPlayer();
 
            if (!targetPlayer || !target->IsConnected())
            {
                // No character selected
                handler->SendSysMessage(LANG_PLAYER_NOT_EXIST_OR_OFFLINE);
            }
        }
 
        return targetPlayer;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTarget(), LANG_NO_CHAR_SELECTED, LANG_PLAYER_NOT_EXIST_OR_OFFLINE, and ChatHandler::SendSysMessage().

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), HandleResetItemsEquippedCommand(), HandleResetItemsInBagsCommand(), HandleResetItemsInBankCommand(), HandleResetItemsInCurrenciesListCommand(), HandleResetItemsInVendorBuyBackTabCommand(), and HandleResetItemsKeyringCommand().

HandleResetAchievementsCommand()

static bool reset_commandscript::HandleResetAchievementsCommand ( ChatHandler *  , Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        if (playerTarget)
            playerTarget->ResetAchievements();
        else
            AchievementMgr::DeleteFromDB(target->GetGUID().GetCounter());
 
        return true;
    }

References AchievementMgr::DeleteFromDB(), and Player::ResetAchievements().

Referenced by GetCommands().

HandleResetAllCommand()

static bool reset_commandscript::HandleResetAllCommand ( ChatHandler *  handler, std::string_view  caseName  )

inlinestatic

    {
        AtLoginFlags atLogin;
 
        // Command specially created as single command to prevent using short case names
        if (caseName == "spells")
        {
            atLogin = AT_LOGIN_RESET_SPELLS;
            handler->SendWorldText(LANG_RESETALL_SPELLS);
            if (!handler->GetSession())
                handler->SendSysMessage(LANG_RESETALL_SPELLS);
        }
        else if (caseName == "talents")
        {
            atLogin = AtLoginFlags(AT_LOGIN_RESET_TALENTS | AT_LOGIN_RESET_PET_TALENTS);
            handler->SendWorldText(LANG_RESETALL_TALENTS);
            if (!handler->GetSession())
                handler->SendSysMessage(LANG_RESETALL_TALENTS);
        }
        else if (caseName == "honor")
        {
            CharacterDatabase.Execute(CharacterDatabase.GetPreparedStatement(CHAR_UPD_ALL_HONOR_POINTS));
 
            sWorldSessionMgr->DoForAllOnlinePlayers([](Player* player)
            {
                player->SetHonorPoints(0);
            });
 
            handler->SendWorldText(LANG_RESETALL_HONOR);
            if (!handler->GetSession())
                handler->SendSysMessage(LANG_RESETALL_HONOR);
            return true;
        }
        else if (caseName == "arena")
        {
            CharacterDatabase.Execute(CharacterDatabase.GetPreparedStatement(CHAR_UPD_ALL_ARENA_POINTS));
 
            sWorldSessionMgr->DoForAllOnlinePlayers([](Player* player)
            {
                player->SetArenaPoints(0);
            });
 
            handler->SendWorldText(LANG_RESETALL_ARENA);
            if (!handler->GetSession())
                handler->SendSysMessage(LANG_RESETALL_ARENA);
            return true;
        }
        else
        {
            handler->SendErrorMessage(LANG_RESETALL_UNKNOWN_CASE, caseName);
            return false;
        }
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ALL_AT_LOGIN_FLAGS);
        stmt->SetData(0, uint16(atLogin));
        CharacterDatabase.Execute(stmt);
 
        sWorldSessionMgr->DoForAllOnlinePlayers([&] (Player* player){
            player->SetAtLoginFlag(atLogin);
        });
 
        return true;
    }

References AT_LOGIN_RESET_PET_TALENTS, AT_LOGIN_RESET_SPELLS, AT_LOGIN_RESET_TALENTS, CHAR_UPD_ALL_ARENA_POINTS, CHAR_UPD_ALL_AT_LOGIN_FLAGS, CHAR_UPD_ALL_HONOR_POINTS, CharacterDatabase, ChatHandler::GetSession(), LANG_RESETALL_ARENA, LANG_RESETALL_HONOR, LANG_RESETALL_SPELLS, LANG_RESETALL_TALENTS, LANG_RESETALL_UNKNOWN_CASE, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), ChatHandler::SendWorldText(), Player::SetArenaPoints(), Player::SetAtLoginFlag(), PreparedStatementBase::SetData(), Player::SetHonorPoints(), and sWorldSessionMgr.

Referenced by GetCommands().

HandleResetHonorCommand()

static bool reset_commandscript::HandleResetHonorCommand ( ChatHandler *  , Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        playerTarget->SetHonorPoints(0);
        playerTarget->SetUInt32Value(PLAYER_FIELD_KILLS, 0);
        playerTarget->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, 0);
        playerTarget->SetUInt32Value(PLAYER_FIELD_TODAY_CONTRIBUTION, 0);
        playerTarget->SetUInt32Value(PLAYER_FIELD_YESTERDAY_CONTRIBUTION, 0);
        playerTarget->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL);
 
        return true;
    }

References ACHIEVEMENT_CRITERIA_TYPE_EARN_HONORABLE_KILL, PLAYER_FIELD_KILLS, PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, PLAYER_FIELD_TODAY_CONTRIBUTION, PLAYER_FIELD_YESTERDAY_CONTRIBUTION, Player::SetHonorPoints(), Unit::SetUInt32Value(), and Player::UpdateAchievementCriteria().

Referenced by GetCommands().

HandleResetItemsAllAndDeleteBagsCommand()

static bool reset_commandscript::HandleResetItemsAllAndDeleteBagsCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
           return false;
        }
        else
        {
 
            // Delete all items destinations
            int16 deletedItemsEquippedCount = ResetItemsEquipped(targetPlayer);
            int16 deletedItemsInBagsCount = ResetItemsInBags(targetPlayer);
            int16 deletedItemsInBankCount = ResetItemsInBank(targetPlayer);
            int16 deletedItemsInKeyringCount = ResetItemsInKeyring(targetPlayer);
            int16 deletedItemsInCurrenciesListCount = ResetItemsInCurrenciesList(targetPlayer);
            int16 deletedItemsInVendorBuyBackTabCount = ResetItemsInVendorBuyBackTab(targetPlayer);
            int16 deletedItemsStandardBagsCount = ResetItemsDeleteStandardBags(targetPlayer);
            int16 deletedItemsBankBagsCount = ResetItemsDeleteBankBags(targetPlayer);
 
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_ALL_BAGS, handler->GetNameLink(targetPlayer),
                deletedItemsEquippedCount,
                deletedItemsInBagsCount,
                deletedItemsInBankCount,
                deletedItemsInKeyringCount,
                deletedItemsInCurrenciesListCount,
                deletedItemsInVendorBuyBackTabCount,
                deletedItemsStandardBagsCount,
                deletedItemsBankBagsCount);
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_ALL_BAGS, ChatHandler::PSendSysMessage(), ResetItemsDeleteBankBags(), ResetItemsDeleteStandardBags(), ResetItemsEquipped(), ResetItemsInBags(), ResetItemsInBank(), ResetItemsInCurrenciesList(), ResetItemsInKeyring(), and ResetItemsInVendorBuyBackTab().

Referenced by GetCommands().

HandleResetItemsAllCommand()

static bool reset_commandscript::HandleResetItemsAllCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
 
            // Delete all items destinations
            int16 deletedItemsEquippedCount            = ResetItemsEquipped(targetPlayer);
            int16 deletedItemsInBagsCount             = ResetItemsInBags(targetPlayer);
            int16 deletedItemsInBankCount             = ResetItemsInBank(targetPlayer);
            int16 deletedItemsInKeyringCount          = ResetItemsInKeyring(targetPlayer);
            int16 deletedItemsInCurrenciesListCount   = ResetItemsInCurrenciesList(targetPlayer);
            int16 deletedItemsInVendorBuyBackTabCount = ResetItemsInVendorBuyBackTab(targetPlayer);
 
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_ALL, handler->GetNameLink(targetPlayer),
                deletedItemsEquippedCount,
                deletedItemsInBagsCount,
                deletedItemsInBankCount,
                deletedItemsInKeyringCount,
                deletedItemsInCurrenciesListCount,
                deletedItemsInVendorBuyBackTabCount);
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_ALL, ChatHandler::PSendSysMessage(), ResetItemsEquipped(), ResetItemsInBags(), ResetItemsInBank(), ResetItemsInCurrenciesList(), ResetItemsInKeyring(), and ResetItemsInVendorBuyBackTab().

Referenced by GetCommands().

HandleResetItemsEquippedCommand()

static bool reset_commandscript::HandleResetItemsEquippedCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
            int16 deletedItemsCount = ResetItemsEquipped(targetPlayer);
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_EQUIPPED, deletedItemsCount, handler->GetNameLink(targetPlayer));
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_EQUIPPED, ChatHandler::PSendSysMessage(), and ResetItemsEquipped().

Referenced by GetCommands().

HandleResetItemsInBagsCommand()

static bool reset_commandscript::HandleResetItemsInBagsCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
            int16 deletedItemsCount = ResetItemsInBags(targetPlayer);
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_BAGS, deletedItemsCount, handler->GetNameLink(targetPlayer));
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_BAGS, ChatHandler::PSendSysMessage(), and ResetItemsInBags().

Referenced by GetCommands().

HandleResetItemsInBankCommand()

static bool reset_commandscript::HandleResetItemsInBankCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
            int16 deletedItemsCount = ResetItemsInBank(targetPlayer);
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_BANK, deletedItemsCount, handler->GetNameLink(targetPlayer));
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_BANK, ChatHandler::PSendSysMessage(), and ResetItemsInBank().

Referenced by GetCommands().

HandleResetItemsInCurrenciesListCommand()

static bool reset_commandscript::HandleResetItemsInCurrenciesListCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
            int16 deletedItemsCount = ResetItemsInCurrenciesList(targetPlayer);
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_CURRENCY, deletedItemsCount, handler->GetNameLink(targetPlayer));
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_CURRENCY, ChatHandler::PSendSysMessage(), and ResetItemsInCurrenciesList().

Referenced by GetCommands().

HandleResetItemsInVendorBuyBackTabCommand()

static bool reset_commandscript::HandleResetItemsInVendorBuyBackTabCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
            int16 deletedItemsCount = ResetItemsInVendorBuyBackTab(targetPlayer);
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_BUYBACK, deletedItemsCount, handler->GetNameLink(targetPlayer));
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_BUYBACK, ChatHandler::PSendSysMessage(), and ResetItemsInVendorBuyBackTab().

Referenced by GetCommands().

HandleResetItemsKeyringCommand()

static bool reset_commandscript::HandleResetItemsKeyringCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = GetPlayerFromIdentifierOrSelectedTarget(handler, target);
 
        if (!targetPlayer)
        {
            return false;
        }
        else
        {
            int16 deletedItemsCount = ResetItemsInKeyring(targetPlayer);
            handler->PSendSysMessage(LANG_COMMAND_RESET_ITEMS_KEYRING, deletedItemsCount, handler->GetNameLink(targetPlayer));
        }
 
        return true;
    }

References ChatHandler::GetNameLink(), GetPlayerFromIdentifierOrSelectedTarget(), LANG_COMMAND_RESET_ITEMS_KEYRING, ChatHandler::PSendSysMessage(), and ResetItemsInKeyring().

Referenced by GetCommands().

HandleResetLevelCommand()

static bool reset_commandscript::HandleResetLevelCommand ( ChatHandler *  , Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        if (!HandleResetStatsOrLevelHelper(playerTarget))
            return false;
 
        uint8 oldLevel = playerTarget->GetLevel();
 
        // set starting level
        uint32 startLevel = !playerTarget->IsClass(CLASS_DEATH_KNIGHT, CLASS_CONTEXT_INIT)
                            ? sWorld->getIntConfig(CONFIG_START_PLAYER_LEVEL)
                            : sWorld->getIntConfig(CONFIG_START_HEROIC_PLAYER_LEVEL);
 
        playerTarget->_ApplyAllLevelScaleItemMods(false);
        playerTarget->SetLevel(startLevel);
        playerTarget->InitRunes();
        playerTarget->InitStatsForLevel(true);
        playerTarget->InitTaxiNodesForLevel();
        playerTarget->InitGlyphsForLevel();
        playerTarget->InitTalentForLevel();
        playerTarget->SetUInt32Value(PLAYER_XP, 0);
 
        playerTarget->_ApplyAllLevelScaleItemMods(true);
 
        // reset level for pet
        if (Pet* pet = playerTarget->GetPet())
            pet->SynchronizeLevelWithOwner();
 
        sScriptMgr->OnPlayerLevelChanged(playerTarget, oldLevel);
 
        return true;
    }

References Player::_ApplyAllLevelScaleItemMods(), CLASS_CONTEXT_INIT, CLASS_DEATH_KNIGHT, CONFIG_START_HEROIC_PLAYER_LEVEL, CONFIG_START_PLAYER_LEVEL, Unit::GetLevel(), Player::GetPet(), HandleResetStatsOrLevelHelper(), Player::InitGlyphsForLevel(), Player::InitRunes(), Player::InitStatsForLevel(), Player::InitTalentForLevel(), Player::InitTaxiNodesForLevel(), Player::IsClass(), PLAYER_XP, Unit::SetLevel(), Unit::SetUInt32Value(), sScriptMgr, and sWorld.

Referenced by GetCommands().

HandleResetSpellsCommand()

static bool reset_commandscript::HandleResetSpellsCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        if (!target)
        {
            target = PlayerIdentifier::FromTargetOrSelf(handler);
        }
 
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        if (target)
        {
            playerTarget->resetSpells(/* bool myClassOnly */);
 
            ChatHandler(playerTarget->GetSession()).SendSysMessage(LANG_RESET_SPELLS);
            if (!handler->GetSession() || handler->GetSession()->GetPlayer() != playerTarget)
                handler->PSendSysMessage(LANG_RESET_SPELLS_ONLINE, handler->GetNameLink(playerTarget));
        }
        else
        {
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ADD_AT_LOGIN_FLAG);
            stmt->SetData(0, uint16(AT_LOGIN_RESET_SPELLS));
            stmt->SetData(1, playerTarget->GetGUID().GetCounter());
            CharacterDatabase.Execute(stmt);
 
            handler->PSendSysMessage(LANG_RESET_SPELLS_OFFLINE, target->GetName());
        }
 
        return true;
    }

References AT_LOGIN_RESET_SPELLS, CHAR_UPD_ADD_AT_LOGIN_FLAG, CharacterDatabase, Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), ObjectGuid::GetCounter(), Object::GetGUID(), ChatHandler::GetNameLink(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Player::GetSession(), LANG_RESET_SPELLS, LANG_RESET_SPELLS_OFFLINE, LANG_RESET_SPELLS_ONLINE, ChatHandler::PSendSysMessage(), Player::resetSpells(), ChatHandler::SendSysMessage(), and PreparedStatementBase::SetData().

Referenced by GetCommands().

HandleResetStatsCommand()

static bool reset_commandscript::HandleResetStatsCommand ( ChatHandler *  , Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        if (!target)
        {
            return false;
        }
 
        Player* playerTarget = target->GetConnectedPlayer();
 
        if (!HandleResetStatsOrLevelHelper(playerTarget))
            return false;
 
        playerTarget->InitRunes();
        playerTarget->InitStatsForLevel(true);
        playerTarget->InitTaxiNodesForLevel();
        playerTarget->InitGlyphsForLevel();
        playerTarget->InitTalentForLevel();
 
        return true;
    }

References HandleResetStatsOrLevelHelper(), Player::InitGlyphsForLevel(), Player::InitRunes(), Player::InitStatsForLevel(), Player::InitTalentForLevel(), and Player::InitTaxiNodesForLevel().

Referenced by GetCommands().

HandleResetStatsOrLevelHelper()

static bool reset_commandscript::HandleResetStatsOrLevelHelper ( Player *  player )

inlinestatic

    {
        ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(player->getClass());
        if (!classEntry)
        {
            LOG_ERROR("dbc", "Class {} not found in DBC (Wrong DBC files?)", player->getClass());
            return false;
        }
 
        uint8 powerType = classEntry->powerType;
 
        // reset m_form if no aura
        if (!player->HasShapeshiftAura())
            player->SetShapeshiftForm(FORM_NONE);
 
        player->SetFactionForRace(player->getRace());
 
        player->SetUInt32Value(UNIT_FIELD_BYTES_0, ((player->getRace()) | (player->getClass() << 8) | (player->getGender() << 16) | (powerType << 24)));
 
        // reset only if player not in some form;
        if (player->GetShapeshiftForm() == FORM_NONE)
            player->InitDisplayIds();
 
        player->SetByteValue(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_PVP);
 
        player->ReplaceAllUnitFlags(UNIT_FLAG_PLAYER_CONTROLLED);
 
        //-1 is default value
        player->SetUInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, uint32(-1));
        return true;
    }

References FORM_NONE, Unit::getClass(), Unit::getGender(), Unit::getRace(), Unit::GetShapeshiftForm(), Unit::HasShapeshiftAura(), Player::InitDisplayIds(), LOG_ERROR, PLAYER_FIELD_WATCHED_FACTION_INDEX, ChrClassesEntry::powerType, Unit::ReplaceAllUnitFlags(), sChrClassesStore, Object::SetByteValue(), Player::SetFactionForRace(), Unit::SetShapeshiftForm(), Unit::SetUInt32Value(), UNIT_BYTE2_FLAG_PVP, UNIT_FIELD_BYTES_0, UNIT_FIELD_BYTES_2, and UNIT_FLAG_PLAYER_CONTROLLED.

Referenced by HandleResetLevelCommand(), and HandleResetStatsCommand().

HandleResetTalentsCommand()

static bool reset_commandscript::HandleResetTalentsCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        Player* targetPlayer = nullptr;
 
        if (target)
        {
            targetPlayer = target->GetConnectedPlayer();
        }
        else
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        if (targetPlayer)
        {
            targetPlayer->resetTalents(true);
            targetPlayer->SendTalentsInfoData(false);
            ChatHandler(targetPlayer->GetSession()).SendSysMessage(LANG_RESET_TALENTS);
            if (!handler->GetSession() || handler->GetSession()->GetPlayer() != targetPlayer)
                handler->PSendSysMessage(LANG_RESET_TALENTS_ONLINE, handler->GetNameLink(targetPlayer));
 
            Pet* pet = targetPlayer->GetPet();
            Pet::resetTalentsForAllPetsOf(targetPlayer, pet);
            if (pet)
                targetPlayer->SendTalentsInfoData(true);
            return true;
        }
        else
        {
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ADD_AT_LOGIN_FLAG);
            stmt->SetData(0, uint16(AT_LOGIN_RESET_TALENTS | AT_LOGIN_RESET_PET_TALENTS));
            stmt->SetData(1, target->GetGUID().GetCounter());
            CharacterDatabase.Execute(stmt);
 
            std::string nameLink = handler->playerLink(target->GetName());
            handler->PSendSysMessage(LANG_RESET_TALENTS_OFFLINE, nameLink);
            return true;
        }
    }

References AT_LOGIN_RESET_PET_TALENTS, AT_LOGIN_RESET_TALENTS, CHAR_UPD_ADD_AT_LOGIN_FLAG, CharacterDatabase, ChatHandler::GetNameLink(), Player::GetPet(), WorldSession::GetPlayer(), ChatHandler::GetSession(), Player::GetSession(), LANG_NO_CHAR_SELECTED, LANG_RESET_TALENTS, LANG_RESET_TALENTS_OFFLINE, LANG_RESET_TALENTS_ONLINE, ChatHandler::playerLink(), ChatHandler::PSendSysMessage(), Player::resetTalents(), Pet::resetTalentsForAllPetsOf(), ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), Player::SendTalentsInfoData(), and PreparedStatementBase::SetData().

Referenced by GetCommands().

ResetItemsDeleteBankBags()

static int16 reset_commandscript::ResetItemsDeleteBankBags ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        // Bank bags
        for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; ++i)
        {
            Bag* pBag = (Bag*)playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pBag)
            {
                // prevent no empty ?
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        return count;
    }

References BANK_SLOT_BAG_END, BANK_SLOT_BAG_START, Player::DestroyItem(), Player::GetItemByPos(), and INVENTORY_SLOT_BAG_0.

Referenced by HandleResetItemsAllAndDeleteBagsCommand().

ResetItemsDeleteStandardBags()

static int16 reset_commandscript::ResetItemsDeleteStandardBags ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        // Standard bag slots
        for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
        {
            Bag* pBag = (Bag*)playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pBag)
            {
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        return count;
    }

References Player::DestroyItem(), Player::GetItemByPos(), INVENTORY_SLOT_BAG_0, INVENTORY_SLOT_BAG_END, and INVENTORY_SLOT_BAG_START.

Referenced by HandleResetItemsAllAndDeleteBagsCommand().

ResetItemsEquipped()

static int16 reset_commandscript::ResetItemsEquipped ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; ++i)
        {
            Item* pItem = playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pItem)
            {
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        return count;
    }

References Player::DestroyItem(), EQUIPMENT_SLOT_END, EQUIPMENT_SLOT_START, Player::GetItemByPos(), and INVENTORY_SLOT_BAG_0.

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), and HandleResetItemsEquippedCommand().

ResetItemsInBags()

static int16 reset_commandscript::ResetItemsInBags ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        // Default bagpack :
        for (uint8 i = INVENTORY_SLOT_ITEM_START; i < INVENTORY_SLOT_ITEM_END; ++i)
        {
            Item* pItem = playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pItem)
            {
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        // Bag slots
        for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; ++i)
        {
            Bag* pBag = (Bag*)playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pBag)
            {
                for (uint8 j = 0; j < pBag->GetBagSize(); ++j)
                {
                    Item* pItem = pBag->GetItemByPos(j);
                    if (pItem)
                    {
                        playerTarget->DestroyItem(i, j, true);
                        ++count;
                    }
                }
            }
        }
 
        return count;
    }

References Player::DestroyItem(), Bag::GetBagSize(), Player::GetItemByPos(), Bag::GetItemByPos(), INVENTORY_SLOT_BAG_0, INVENTORY_SLOT_BAG_END, INVENTORY_SLOT_BAG_START, INVENTORY_SLOT_ITEM_END, and INVENTORY_SLOT_ITEM_START.

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), and HandleResetItemsInBagsCommand().

ResetItemsInBank()

static int16 reset_commandscript::ResetItemsInBank ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        // Normal bank slot
        for (uint8 i = BANK_SLOT_ITEM_START; i < BANK_SLOT_ITEM_END; ++i)
        {
            Item* pItem = playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pItem)
            {
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        // Bank bagslots
        for (uint8 i = BANK_SLOT_BAG_START; i < BANK_SLOT_BAG_END; ++i)
        {
            Bag* pBag = (Bag*)playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pBag)
            {
                for (uint8 j = 0; j < pBag->GetBagSize(); ++j)
                {
                    Item* pItem = pBag->GetItemByPos(j);
                    if (pItem)
                    {
                        playerTarget->DestroyItem(i, j, true);
                        ++count;
                    }
                }
            }
        }
 
        return count;
    }

References BANK_SLOT_BAG_END, BANK_SLOT_BAG_START, BANK_SLOT_ITEM_END, BANK_SLOT_ITEM_START, Player::DestroyItem(), Bag::GetBagSize(), Player::GetItemByPos(), Bag::GetItemByPos(), and INVENTORY_SLOT_BAG_0.

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), and HandleResetItemsInBankCommand().

ResetItemsInCurrenciesList()

static int16 reset_commandscript::ResetItemsInCurrenciesList ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        for (uint8 i = CURRENCYTOKEN_SLOT_START; i < CURRENCYTOKEN_SLOT_END; ++i)
        {
            Item* pItem = playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pItem)
            {
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        return count;
    }

References CURRENCYTOKEN_SLOT_END, CURRENCYTOKEN_SLOT_START, Player::DestroyItem(), Player::GetItemByPos(), and INVENTORY_SLOT_BAG_0.

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), and HandleResetItemsInCurrenciesListCommand().

ResetItemsInKeyring()

static int16 reset_commandscript::ResetItemsInKeyring ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        for (uint8 i = KEYRING_SLOT_START; i < KEYRING_SLOT_END; ++i)
        {
            Item* pItem = playerTarget->GetItemByPos(INVENTORY_SLOT_BAG_0, i);
            if (pItem)
            {
                playerTarget->DestroyItem(INVENTORY_SLOT_BAG_0, i, true);
                ++count;
            }
        }
 
        return count;
    }

References Player::DestroyItem(), Player::GetItemByPos(), INVENTORY_SLOT_BAG_0, KEYRING_SLOT_END, and KEYRING_SLOT_START.

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), and HandleResetItemsKeyringCommand().

ResetItemsInVendorBuyBackTab()

static int16 reset_commandscript::ResetItemsInVendorBuyBackTab ( Player *  playerTarget )

inlinestaticprivate

    {
        if (!playerTarget)
        {
            return -1;
        }
 
        int16 count = 0;
        for (uint8 i = BUYBACK_SLOT_START; i < BUYBACK_SLOT_END; ++i)
        {
            Item* pItem = playerTarget->GetItemFromBuyBackSlot(i);
            if (pItem)
            {
                playerTarget->RemoveItemFromBuyBackSlot(i, true);
                ++count;
            }
        }
 
        return count;
    }

References BUYBACK_SLOT_END, BUYBACK_SLOT_START, Player::GetItemFromBuyBackSlot(), and Player::RemoveItemFromBuyBackSlot().

Referenced by HandleResetItemsAllAndDeleteBagsCommand(), HandleResetItemsAllCommand(), and HandleResetItemsInVendorBuyBackTabCommand().

---

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

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