arena_commandscript Class Reference

Inheritance diagram for arena_commandscript:

Public Member Functions
	arena_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	HandleArenaCreateCommand (ChatHandler *handler, Optional< PlayerIdentifier > captain, QuotedString name, ArenaTeamTypes type)
static bool	HandleArenaDisbandCommand (ChatHandler *handler, uint32 teamId)
static bool	HandleArenaRenameCommand (ChatHandler *handler, QuotedString oldName, QuotedString newName)
static bool	HandleArenaCaptainCommand (ChatHandler *handler, uint32 teamId, Optional< PlayerIdentifier > target)
static bool	HandleArenaInfoCommand (ChatHandler *handler, uint32 teamId)
static bool	HandleArenaLookupCommand (ChatHandler *handler, Tail needle)
static bool	HandleArenaSeasonRewardCommand (ChatHandler *handler, std::string teamsFilterStr)
static bool	HandleArenaSeasonDeleteTeamsCommand (ChatHandler *handler)
static bool	HandleArenaSeasonStartCommand (ChatHandler *handler, uint8 seasonId)
static bool	HandleArenaSeasonSetStateCommand (ChatHandler *handler, uint8 state)

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

arena_commandscript()

arena_commandscript::arena_commandscript ( )

inline

: CommandScript("arena_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable arena_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable arenaSeasonSetCommandTable =
        {
            { "state",          HandleArenaSeasonSetStateCommand, SEC_ADMINISTRATOR, Console::Yes }
        };
 
        static ChatCommandTable arenaSeasonCommandTable =
        {
            { "reward",         HandleArenaSeasonRewardCommand,      SEC_ADMINISTRATOR, Console::Yes },
            { "deleteteams",    HandleArenaSeasonDeleteTeamsCommand, SEC_ADMINISTRATOR, Console::Yes },
            { "start",          HandleArenaSeasonStartCommand,       SEC_ADMINISTRATOR, Console::Yes },
            { "set",            arenaSeasonSetCommandTable }
        };
 
        static ChatCommandTable arenaCommandTable =
        {
            { "create",         HandleArenaCreateCommand,   SEC_ADMINISTRATOR, Console::Yes },
            { "disband",        HandleArenaDisbandCommand,  SEC_ADMINISTRATOR, Console::Yes },
            { "rename",         HandleArenaRenameCommand,   SEC_ADMINISTRATOR, Console::Yes },
            { "captain",        HandleArenaCaptainCommand,  SEC_ADMINISTRATOR, Console::No  },
            { "info",           HandleArenaInfoCommand,     SEC_GAMEMASTER,    Console::Yes },
            { "lookup",         HandleArenaLookupCommand,   SEC_GAMEMASTER,    Console::No  },
            { "season",         arenaSeasonCommandTable  }
        };
 
        static ChatCommandTable commandTable =
        {
            { "arena", arenaCommandTable }
        };
 
        return commandTable;
    }

References HandleArenaCaptainCommand(), HandleArenaCreateCommand(), HandleArenaDisbandCommand(), HandleArenaInfoCommand(), HandleArenaLookupCommand(), HandleArenaRenameCommand(), HandleArenaSeasonDeleteTeamsCommand(), HandleArenaSeasonRewardCommand(), HandleArenaSeasonSetStateCommand(), HandleArenaSeasonStartCommand(), SEC_ADMINISTRATOR, and SEC_GAMEMASTER.

HandleArenaCaptainCommand()

static bool arena_commandscript::HandleArenaCaptainCommand ( ChatHandler *  handler, uint32  teamId, Optional< PlayerIdentifier >  target  )

inlinestatic

    {
        ArenaTeam* arena = sArenaTeamMgr->GetArenaTeamById(teamId);
        if (!arena)
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NOT_FOUND, teamId);
            return false;
        }
 
        if (arena->IsFighting())
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_COMBAT);
            return false;
        }
 
        if (!target)
            target = PlayerIdentifier::FromTargetOrSelf(handler);
 
        if (!target)
            return false;
 
        if (!arena->IsMember(target->GetGUID()))
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NOT_MEMBER, target->GetName(), arena->GetName());
            return false;
        }
 
        if (arena->GetCaptain() == target->GetGUID())
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_CAPTAIN, target->GetName(), arena->GetName());
            return false;
        }
 
        std::string oldCaptainName;
        sCharacterCache->GetCharacterNameByGuid(arena->GetCaptain(), oldCaptainName);
        arena->SetCaptain(target->GetGUID());
 
        handler->PSendSysMessage(LANG_ARENA_CAPTAIN, arena->GetName(), arena->GetId(), oldCaptainName, target->GetName());
 
        return true;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), ArenaTeam::GetCaptain(), ArenaTeam::GetId(), ArenaTeam::GetName(), ArenaTeam::IsFighting(), ArenaTeam::IsMember(), LANG_ARENA_CAPTAIN, LANG_ARENA_ERROR_CAPTAIN, LANG_ARENA_ERROR_COMBAT, LANG_ARENA_ERROR_NOT_FOUND, LANG_ARENA_ERROR_NOT_MEMBER, ChatHandler::PSendSysMessage(), sArenaTeamMgr, sCharacterCache, ChatHandler::SendErrorMessage(), and ArenaTeam::SetCaptain().

Referenced by GetCommands().

HandleArenaCreateCommand()

static bool arena_commandscript::HandleArenaCreateCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  captain, QuotedString  name, ArenaTeamTypes  type  )

inlinestatic

    {
        if (sArenaTeamMgr->GetArenaTeamByName(name))
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NAME_EXISTS, name);
            return false;
        }
 
        if (!captain)
            captain = PlayerIdentifier::FromTargetOrSelf(handler);
 
        if (!captain)
            return false;
 
        if (Player::GetArenaTeamIdFromDB(captain->GetGUID(), type) != 0)
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_SIZE, captain->GetName());
            return false;
        }
 
        ArenaTeam* arena = new ArenaTeam();
 
        if (!arena->Create(captain->GetGUID(), type, name, 4293102085, 101, 4293253939, 4, 4284049911))
        {
            delete arena;
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        sArenaTeamMgr->AddArenaTeam(arena);
        handler->PSendSysMessage(LANG_ARENA_CREATE, arena->GetName(), arena->GetId(), arena->GetType(), arena->GetCaptain().ToString());
 
        return true;
    }

References ArenaTeam::Create(), Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), Player::GetArenaTeamIdFromDB(), ArenaTeam::GetCaptain(), ArenaTeam::GetId(), ArenaTeam::GetName(), ArenaTeam::GetType(), LANG_ARENA_CREATE, LANG_ARENA_ERROR_NAME_EXISTS, LANG_ARENA_ERROR_SIZE, LANG_BAD_VALUE, ChatHandler::PSendSysMessage(), sArenaTeamMgr, ChatHandler::SendErrorMessage(), and ObjectGuid::ToString().

Referenced by GetCommands().

HandleArenaDisbandCommand()

static bool arena_commandscript::HandleArenaDisbandCommand ( ChatHandler *  handler, uint32  teamId  )

inlinestatic

    {
        ArenaTeam* arena = sArenaTeamMgr->GetArenaTeamById(teamId);
 
        if (!arena)
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NOT_FOUND, teamId);
            return false;
        }
 
        if (arena->IsFighting())
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_COMBAT);
            return false;
        }
 
        std::string name = arena->GetName();
        arena->Disband();
 
        delete(arena);
 
        handler->PSendSysMessage(LANG_ARENA_DISBAND, name, teamId);
        return true;
    }

References ArenaTeam::Disband(), ArenaTeam::GetName(), ArenaTeam::IsFighting(), LANG_ARENA_DISBAND, LANG_ARENA_ERROR_COMBAT, LANG_ARENA_ERROR_NOT_FOUND, ChatHandler::PSendSysMessage(), sArenaTeamMgr, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleArenaInfoCommand()

static bool arena_commandscript::HandleArenaInfoCommand ( ChatHandler *  handler, uint32  teamId  )

inlinestatic

    {
        ArenaTeam* arena = sArenaTeamMgr->GetArenaTeamById(teamId);
        if (!arena)
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NOT_FOUND, teamId);
            return false;
        }
 
        handler->PSendSysMessage(LANG_ARENA_INFO_HEADER, arena->GetName(), arena->GetId(), arena->GetRating(), arena->GetType(), arena->GetType());
 
        for (auto const& itr : arena->GetMembers())
            handler->PSendSysMessage(LANG_ARENA_INFO_MEMBERS, itr.Name, itr.Guid.ToString(), itr.PersonalRating, (arena->GetCaptain() == itr.Guid ? "- Captain" : ""));
 
        return true;
    }

References ArenaTeam::GetCaptain(), ArenaTeam::GetId(), ArenaTeam::GetMembers(), ArenaTeam::GetName(), ArenaTeam::GetRating(), ArenaTeam::GetType(), LANG_ARENA_ERROR_NOT_FOUND, LANG_ARENA_INFO_HEADER, LANG_ARENA_INFO_MEMBERS, ChatHandler::PSendSysMessage(), sArenaTeamMgr, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleArenaLookupCommand()

static bool arena_commandscript::HandleArenaLookupCommand ( ChatHandler *  handler, Tail  needle  )

inlinestatic

    {
        if (needle.empty())
            return false;
 
        bool found = false;
        for (auto [teamId, team] : sArenaTeamMgr->GetArenaTeams())
        {
            if (StringContainsStringI(team->GetName(), needle))
            {
                if (handler->GetSession())
                {
                    handler->PSendSysMessage(LANG_ARENA_LOOKUP, team->GetName(), team->GetId(), team->GetType(), team->GetType());
                    found = true;
                    continue;
                }
            }
        }
 
        if (!found)
            handler->PSendSysMessage(LANG_ARENA_ERROR_NAME_NOT_FOUND, std::string(needle));
 
        return true;
    }

References ChatHandler::GetSession(), LANG_ARENA_ERROR_NAME_NOT_FOUND, LANG_ARENA_LOOKUP, ChatHandler::PSendSysMessage(), sArenaTeamMgr, and StringContainsStringI().

Referenced by GetCommands().

HandleArenaRenameCommand()

static bool arena_commandscript::HandleArenaRenameCommand ( ChatHandler *  handler, QuotedString  oldName, QuotedString  newName  )

inlinestatic

    {
        ArenaTeam* arena = sArenaTeamMgr->GetArenaTeamByName(oldName);
        if (!arena)
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NAME_NOT_FOUND, oldName);
            return false;
        }
 
        if (sArenaTeamMgr->GetArenaTeamByName(newName))
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_NAME_EXISTS, oldName);
            return false;
        }
 
        if (arena->IsFighting())
        {
            handler->SendErrorMessage(LANG_ARENA_ERROR_COMBAT);
            return false;
        }
 
        if (!arena->SetName(newName))
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        handler->PSendSysMessage(LANG_ARENA_RENAME, arena->GetId(), oldName, newName);
 
        return true;
    }

References ArenaTeam::GetId(), ArenaTeam::IsFighting(), LANG_ARENA_ERROR_COMBAT, LANG_ARENA_ERROR_NAME_EXISTS, LANG_ARENA_ERROR_NAME_NOT_FOUND, LANG_ARENA_RENAME, LANG_BAD_VALUE, ChatHandler::PSendSysMessage(), sArenaTeamMgr, ChatHandler::SendErrorMessage(), and ArenaTeam::SetName().

Referenced by GetCommands().

HandleArenaSeasonDeleteTeamsCommand()

static bool arena_commandscript::HandleArenaSeasonDeleteTeamsCommand ( ChatHandler *  handler )

inlinestatic

    {
        handler->PSendSysMessage("Deleting arena teams...");
        sArenaSeasonMgr->DeleteArenaTeams();
        handler->PSendSysMessage("Arena teams deleted.");
        return true;
    }

References ChatHandler::PSendSysMessage(), and sArenaSeasonMgr.

Referenced by GetCommands().

HandleArenaSeasonRewardCommand()

static bool arena_commandscript::HandleArenaSeasonRewardCommand ( ChatHandler *  handler, std::string  teamsFilterStr  )

inlinestatic

    {
        std::unique_ptr<ArenaTeamFilter> uniqueFilter = ArenaTeamFilterFactoryByUserInput().CreateFilterByUserInput(teamsFilterStr);
        if (!uniqueFilter)
        {
            handler->PSendSysMessage("Invalid filter. Please check your input.");
            return false;
        }
 
        std::shared_ptr<ArenaTeamFilter> sharedFilter = std::move(uniqueFilter);
 
        if (!sArenaSeasonMgr->CanDeleteArenaTeams())
        {
            handler->PSendSysMessage("Cannot proceed. Make sure there are no active arenas and that rewards exist for the current season.");
            handler->PSendSysMessage("Hint: You can disable the arena queue using the following command: .arena season set state 0");
            return false;
        }
 
        handler->PSendSysMessage("Distributing rewards for arena teams (types: "+teamsFilterStr+")...");
        sArenaSeasonMgr->RewardTeamsForTheSeason(sharedFilter);
        handler->PSendSysMessage("Rewards distributed.");
        return true;
    }

References ArenaTeamFilterFactoryByUserInput::CreateFilterByUserInput(), ChatHandler::PSendSysMessage(), and sArenaSeasonMgr.

Referenced by GetCommands().

HandleArenaSeasonSetStateCommand()

static bool arena_commandscript::HandleArenaSeasonSetStateCommand ( ChatHandler *  handler, uint8  state  )

inlinestatic

    {
        ArenaSeasonState seasonState;
        switch (state) {
            case ARENA_SEASON_STATE_DISABLED:
                seasonState = ARENA_SEASON_STATE_DISABLED;
                break;
            case ARENA_SEASON_STATE_IN_PROGRESS:
                seasonState = ARENA_SEASON_STATE_IN_PROGRESS;
                break;
            default:
                handler->PSendSysMessage("Invalid state.");
                return false;
        }
 
        sArenaSeasonMgr->SetSeasonState(seasonState);
        handler->PSendSysMessage("Arena season updated.");
        return true;
    }

References ARENA_SEASON_STATE_DISABLED, ARENA_SEASON_STATE_IN_PROGRESS, ChatHandler::PSendSysMessage(), and sArenaSeasonMgr.

Referenced by GetCommands().

HandleArenaSeasonStartCommand()

static bool arena_commandscript::HandleArenaSeasonStartCommand ( ChatHandler *  handler, uint8  seasonId  )

inlinestatic

    {
        if (seasonId == sArenaSeasonMgr->GetCurrentSeason())
        {
            sArenaSeasonMgr->SetSeasonState(ARENA_SEASON_STATE_IN_PROGRESS);
            handler->PSendSysMessage("Arena season updated.");
            return true;
        }
 
        const uint8 maxSeasonId = 8;
        if (seasonId > maxSeasonId)
        {
            handler->PSendSysMessage("Invalid season id.");
            return false;
        }
 
        sArenaSeasonMgr->ChangeCurrentSeason(seasonId);
        handler->PSendSysMessage("Arena season changed to season {}.", seasonId);
        return true;
    }

References ARENA_SEASON_STATE_IN_PROGRESS, ChatHandler::PSendSysMessage(), and sArenaSeasonMgr.

Referenced by GetCommands().

---

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

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