bf_commandscript Class Reference

Inheritance diagram for bf_commandscript:

Public Member Functions
	bf_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	HandleBattlefieldStart (ChatHandler *handler, Optional< uint32 > battleIdArg)
static bool	HandleBattlefieldEnd (ChatHandler *handler, Optional< uint32 > battleIdArg)
static bool	HandleBattlefieldEnable (ChatHandler *handler, Optional< uint32 > battleIdArg)
static bool	HandleBattlefieldSwitch (ChatHandler *handler, Optional< uint32 > battleIdArg)
static bool	HandleBattlefieldTimer (ChatHandler *handler, Optional< uint32 > battleIdArg, std::string timeStr)
static bool	HandleBattlefieldQueue (ChatHandler *handler, Optional< uint32 > battleIdArg)

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

bf_commandscript()

bf_commandscript::bf_commandscript ( )

inline

: CommandScript("bf_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable bf_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable battlefieldcommandTable =
        {
            { "start",  HandleBattlefieldStart,  rbac::RBAC_PERM_COMMAND_BF_START,  Console::Yes },
            { "stop",   HandleBattlefieldEnd,    rbac::RBAC_PERM_COMMAND_BF_STOP,   Console::Yes },
            { "switch", HandleBattlefieldSwitch, rbac::RBAC_PERM_COMMAND_BF_SWITCH, Console::Yes },
            { "timer",  HandleBattlefieldTimer,  rbac::RBAC_PERM_COMMAND_BF_TIMER,  Console::Yes },
            { "enable", HandleBattlefieldEnable, rbac::RBAC_PERM_COMMAND_BF_ENABLE, Console::Yes },
            { "queue",  HandleBattlefieldQueue,  rbac::RBAC_PERM_COMMAND_BF_QUEUE,  Console::Yes }
        };
        static ChatCommandTable commandTable =
        {
            { "bf", battlefieldcommandTable }
        };
        return commandTable;
    }

References HandleBattlefieldEnable(), HandleBattlefieldEnd(), HandleBattlefieldQueue(), HandleBattlefieldStart(), HandleBattlefieldSwitch(), HandleBattlefieldTimer(), rbac::RBAC_PERM_COMMAND_BF_ENABLE, rbac::RBAC_PERM_COMMAND_BF_QUEUE, rbac::RBAC_PERM_COMMAND_BF_START, rbac::RBAC_PERM_COMMAND_BF_STOP, rbac::RBAC_PERM_COMMAND_BF_SWITCH, and rbac::RBAC_PERM_COMMAND_BF_TIMER.

HandleBattlefieldEnable()

static bool bf_commandscript::HandleBattlefieldEnable ( ChatHandler *  handler, Optional< uint32 >  battleIdArg  )

inlinestatic

    {
        uint32 const battleId = battleIdArg.value_or(BATTLEFIELD_BATTLEID_WG);
        Battlefield* bf = sBattlefieldMgr->GetBattlefieldByBattleId(battleId);
 
        if (!bf)
        {
            handler->SendErrorMessage(LANG_BF_NOT_FOUND, battleId);
            return false;
        }
 
        if (bf->IsEnabled())
        {
            bf->ToggleBattlefield(false);
            handler->SendWorldText(LANG_BF_DISABLED, battleId);
            if (handler->IsConsole())
                handler->PSendSysMessage(LANG_BF_DISABLED, battleId);
        }
        else
        {
            bf->ToggleBattlefield(true);
            handler->SendWorldText(LANG_BF_ENABLED, battleId);
            if (handler->IsConsole())
                handler->PSendSysMessage(LANG_BF_ENABLED, battleId);
        }
 
        return true;
    }

References BATTLEFIELD_BATTLEID_WG, ChatHandler::IsConsole(), Battlefield::IsEnabled(), LANG_BF_DISABLED, LANG_BF_ENABLED, LANG_BF_NOT_FOUND, ChatHandler::PSendSysMessage(), sBattlefieldMgr, ChatHandler::SendErrorMessage(), ChatHandler::SendWorldText(), and Battlefield::ToggleBattlefield().

Referenced by GetCommands().

HandleBattlefieldEnd()

static bool bf_commandscript::HandleBattlefieldEnd ( ChatHandler *  handler, Optional< uint32 >  battleIdArg  )

inlinestatic

    {
        uint32 const battleId = battleIdArg.value_or(BATTLEFIELD_BATTLEID_WG);
        Battlefield* bf = sBattlefieldMgr->GetBattlefieldByBattleId(battleId);
 
        if (!bf)
        {
            handler->SendErrorMessage(LANG_BF_NOT_FOUND, battleId);
            return false;
        }
 
        bf->EndBattle(true);
        handler->SendWorldText(LANG_BF_STOPPED, battleId);
        if (handler->IsConsole())
            handler->PSendSysMessage(LANG_BF_STOPPED, battleId);
 
        return true;
    }

References BATTLEFIELD_BATTLEID_WG, Battlefield::EndBattle(), ChatHandler::IsConsole(), LANG_BF_NOT_FOUND, LANG_BF_STOPPED, ChatHandler::PSendSysMessage(), sBattlefieldMgr, ChatHandler::SendErrorMessage(), and ChatHandler::SendWorldText().

Referenced by GetCommands().

HandleBattlefieldQueue()

static bool bf_commandscript::HandleBattlefieldQueue ( ChatHandler *  handler, Optional< uint32 >  battleIdArg  )

inlinestatic

    {
        uint32 const battleId = battleIdArg.value_or(BATTLEFIELD_BATTLEID_WG);
        Battlefield* bf = sBattlefieldMgr->GetBattlefieldByBattleId(battleId);
 
        if (!bf)
        {
            handler->SendErrorMessage(LANG_BF_NOT_FOUND, battleId);
            return false;
        }
 
        handler->PSendSysMessage(bf->IsWarTime() ? LANG_BF_QUEUE_HDR_WAR : LANG_BF_QUEUE_HDR_WAIT,
            battleId, bf->GetTimer() / IN_MILLISECONDS);
 
        static char const* teamNames[PVP_TEAMS_COUNT] = { "Alliance", "Horde" };
 
        std::string offlineSuffix = handler->GetAcoreString(LANG_OFFLINE);
 
        auto nameOf = [offlineSuffix](ObjectGuid guid) -> std::string
        {
            if (Player* p = ObjectAccessor::FindPlayer(guid))
                return p->GetName();
            return std::to_string(guid.GetCounter()) + offlineSuffix;
        };
 
        for (uint8 i = 0; i < PVP_TEAMS_COUNT; ++i)
        {
            TeamId team = TeamId(i);
 
            GuidUnorderedSet const& inQueue = bf->GetPlayersQueueSet(team);
            PlayerTimerMap   const& invited = bf->GetInvitedPlayersMap(team);
            GuidUnorderedSet const& inWar   = bf->GetPlayersInWarSet(team);
 
            handler->PSendSysMessage(LANG_BF_QUEUE_TEAM_HDR,
                teamNames[i],
                static_cast<uint32>(inQueue.size()),
                static_cast<uint32>(invited.size()),
                static_cast<uint32>(inWar.size()));
 
            for (ObjectGuid const& guid : inQueue)
                handler->PSendSysMessage(LANG_BF_QUEUE_PLAYER_QUEUE, nameOf(guid));
 
            SystemTimePoint now = GameTime::GetSystemTime();
            for (auto const& [guid, expiry] : invited)
            {
                SystemTimePoint expiryPoint = std::chrono::system_clock::from_time_t(expiry);
                int32 secsLeft = std::max(int32(0), static_cast<int32>(
                    std::chrono::duration_cast<Seconds>(expiryPoint - now).count()));
                handler->PSendSysMessage(LANG_BF_QUEUE_PLAYER_INVITED, nameOf(guid), secsLeft);
            }
 
            for (ObjectGuid const& guid : inWar)
                handler->PSendSysMessage(LANG_BF_QUEUE_PLAYER_WAR, nameOf(guid));
        }
 
        return true;
    }

References BATTLEFIELD_BATTLEID_WG, ObjectAccessor::FindPlayer(), ChatHandler::GetAcoreString(), Battlefield::GetInvitedPlayersMap(), Battlefield::GetPlayersInWarSet(), Battlefield::GetPlayersQueueSet(), GameTime::GetSystemTime(), Battlefield::GetTimer(), IN_MILLISECONDS, Battlefield::IsWarTime(), LANG_BF_NOT_FOUND, LANG_BF_QUEUE_HDR_WAIT, LANG_BF_QUEUE_HDR_WAR, LANG_BF_QUEUE_PLAYER_INVITED, LANG_BF_QUEUE_PLAYER_QUEUE, LANG_BF_QUEUE_PLAYER_WAR, LANG_BF_QUEUE_TEAM_HDR, LANG_OFFLINE, ChatHandler::PSendSysMessage(), PVP_TEAMS_COUNT, sBattlefieldMgr, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleBattlefieldStart()

static bool bf_commandscript::HandleBattlefieldStart ( ChatHandler *  handler, Optional< uint32 >  battleIdArg  )

inlinestatic

    {
        uint32 const battleId = battleIdArg.value_or(BATTLEFIELD_BATTLEID_WG);
        Battlefield* bf = sBattlefieldMgr->GetBattlefieldByBattleId(battleId);
 
        if (!bf)
        {
            handler->SendErrorMessage(LANG_BF_NOT_FOUND, battleId);
            return false;
        }
 
        bf->StartBattle();
        handler->SendWorldText(LANG_BF_STARTED, battleId);
        if (handler->IsConsole())
            handler->PSendSysMessage(LANG_BF_STARTED, battleId);
 
        return true;
    }

References BATTLEFIELD_BATTLEID_WG, ChatHandler::IsConsole(), LANG_BF_NOT_FOUND, LANG_BF_STARTED, ChatHandler::PSendSysMessage(), sBattlefieldMgr, ChatHandler::SendErrorMessage(), ChatHandler::SendWorldText(), and Battlefield::StartBattle().

Referenced by GetCommands().

HandleBattlefieldSwitch()

static bool bf_commandscript::HandleBattlefieldSwitch ( ChatHandler *  handler, Optional< uint32 >  battleIdArg  )

inlinestatic

    {
        uint32 const battleId = battleIdArg.value_or(BATTLEFIELD_BATTLEID_WG);
        Battlefield* bf = sBattlefieldMgr->GetBattlefieldByBattleId(battleId);
 
        if (!bf)
        {
            handler->SendErrorMessage(LANG_BF_NOT_FOUND, battleId);
            return false;
        }
 
        bf->EndBattle(false);
        handler->SendWorldText(LANG_BF_SWITCHED, battleId);
        if (handler->IsConsole())
            handler->PSendSysMessage(LANG_BF_SWITCHED, battleId);
 
        return true;
    }

References BATTLEFIELD_BATTLEID_WG, Battlefield::EndBattle(), ChatHandler::IsConsole(), LANG_BF_NOT_FOUND, LANG_BF_SWITCHED, ChatHandler::PSendSysMessage(), sBattlefieldMgr, ChatHandler::SendErrorMessage(), and ChatHandler::SendWorldText().

Referenced by GetCommands().

HandleBattlefieldTimer()

static bool bf_commandscript::HandleBattlefieldTimer ( ChatHandler *  handler, Optional< uint32 >  battleIdArg, std::string  timeStr  )

inlinestatic

    {
        if (timeStr.empty())
        {
            return false;
        }
 
        uint32 const battleId = battleIdArg.value_or(BATTLEFIELD_BATTLEID_WG);
 
        if (Acore::StringTo<int32>(timeStr).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        int32 time = TimeStringToSecs(timeStr);
        if (time <= 0)
        {
            time = Acore::StringTo<int32>(timeStr).value_or(0);
        }
 
        if (time <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        Battlefield* bf = sBattlefieldMgr->GetBattlefieldByBattleId(battleId);
 
        if (!bf)
        {
            handler->SendErrorMessage(LANG_BF_NOT_FOUND, battleId);
            return false;
        }
 
        bf->SetTimer(time * IN_MILLISECONDS);
        bf->SendInitWorldStatesToAll();
        handler->SendWorldText(LANG_BF_TIMER_SET, battleId, time);
        if (handler->IsConsole())
            handler->PSendSysMessage(LANG_BF_TIMER_SET, battleId, time);
 
        return true;
    }

References BATTLEFIELD_BATTLEID_WG, IN_MILLISECONDS, ChatHandler::IsConsole(), LANG_BAD_VALUE, LANG_BF_NOT_FOUND, LANG_BF_TIMER_SET, ChatHandler::PSendSysMessage(), sBattlefieldMgr, ChatHandler::SendErrorMessage(), Battlefield::SendInitWorldStatesToAll(), ChatHandler::SendWorldText(), Battlefield::SetTimer(), and TimeStringToSecs().

Referenced by GetCommands().

---

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

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