_battleground_mgr_8cpp_source.html

/*

* This file is part of Project SkyFire https://www.projectskyfire.org.

* See LICENSE.md file for Copyright information

*/


#include "ArenaTeamMgr.h"

#include "Common.h"

#include "ObjectMgr.h"

#include "World.h"

#include "WorldPacket.h"


#include "ArenaTeam.h"

#include "BattlegroundAB.h"

#include "BattlegroundAV.h"

#include "BattlegroundBE.h"

#include "BattlegroundBFG.h"

#include "BattlegroundDS.h"

#include "BattlegroundEY.h"

#include "BattlegroundIC.h"

#include "BattlegroundMgr.h"

#include "BattlegroundNA.h"

#include "BattlegroundRL.h"

#include "BattlegroundRV.h"

#include "BattlegroundSA.h"

#include "BattlegroundTP.h"

#include "BattlegroundTV.h"

#include "BattlegroundVOP.h"

#include "BattlegroundWS.h"

#include "Chat.h"

#include "DisableMgr.h"

#include "Formulas.h"

#include "GameEventMgr.h"

#include "Map.h"

#include "MapInstanced.h"

#include "MapManager.h"

#include "Opcodes.h"

#include "Player.h"

#include "SharedDefines.h"


/*********************************************************/

/***            BATTLEGROUND MANAGER                   ***/

/*********************************************************/


BattlegroundMgr::BattlegroundMgr() :

    m_NextRatedArenaUpdate(sWorld->getIntConfig(WorldIntConfigs::CONFIG_ARENA_RATED_UPDATE_TIMER)),

    m_ArenaTesting(false), m_Testing(false)

{ }


BattlegroundMgr::~BattlegroundMgr()

{

    DeleteAllBattlegrounds();

}


void BattlegroundMgr::DeleteAllBattlegrounds()

{

    for (BattlegroundDataContainer::iterator itr1 = bgDataStore.begin(); itr1 != bgDataStore.end(); ++itr1)

    {

        BattlegroundData& data = itr1->second;


        while (!data.m_Battlegrounds.empty())

            delete data.m_Battlegrounds.begin()->second;

        data.m_Battlegrounds.clear();


        while (!data.BGFreeSlotQueue.empty())

            delete data.BGFreeSlotQueue.front();

    }


    bgDataStore.clear();

}


// used to update running battlegrounds, and delete finished ones


void BattlegroundMgr::Update(uint32 diff)

{

    for (BattlegroundDataContainer::iterator itr1 = bgDataStore.begin(); itr1 != bgDataStore.end(); ++itr1)

    {

        BattlegroundContainer& bgs = itr1->second.m_Battlegrounds;

        BattlegroundContainer::iterator itrDelete = bgs.begin();

        // first one is template and should not be deleted

        for (BattlegroundContainer::iterator itr = ++itrDelete; itr != bgs.end();)

        {

            itrDelete = itr++;

            Battleground* bg = itrDelete->second;


            bg->Update(diff);

            if (bg->ToBeDeleted())

            {

                itrDelete->second = NULL;

                bgs.erase(itrDelete);

                uint8 BracketID = uint8(bg->GetBracketId());

                BattlegroundClientIdsContainer& clients = itr1->second.m_ClientBattlegroundIds[BracketID];

                if (!clients.empty())

                    clients.erase(bg->GetClientInstanceID());


                delete bg;

            }

        }

    }


    // update events timer

    for (int qtype = BATTLEGROUND_QUEUE_NONE; qtype < MAX_BATTLEGROUND_QUEUE_TYPES; ++qtype)

        m_BattlegroundQueues[qtype].UpdateEvents(diff);


    // update scheduled queues

    if (!m_QueueUpdateScheduler.empty())

    {

        std::vector<ScheduledQueueUpdate> scheduled;

        std::swap(scheduled, m_QueueUpdateScheduler);

        for (uint8 i = 0; i < scheduled.size(); i++)

        {

            uint32 arenaMMRating = scheduled[i].ArenaMMRating;

            uint8 arenaType = scheduled[i].ArenaType;

            BattlegroundQueueTypeId bgQueueTypeId = BattlegroundQueueTypeId(scheduled[i].QueueId);

            BattlegroundTypeId bgTypeId = BattlegroundTypeId(scheduled[i].TypeId);

            BattlegroundBracketId bracket_id = BattlegroundBracketId(scheduled[i].BracketId);

            m_BattlegroundQueues[bgQueueTypeId].BattlegroundQueueUpdate(diff, bgTypeId, bracket_id, arenaType, arenaMMRating > 0, arenaMMRating);

        }

    }


    // if rating difference counts, maybe force-update queues

    if (sWorld->getIntConfig(WorldIntConfigs::CONFIG_ARENA_MAX_RATING_DIFFERENCE) && sWorld->getIntConfig(WorldIntConfigs::CONFIG_ARENA_RATED_UPDATE_TIMER))

    {

        // it's time to force update

        if (m_NextRatedArenaUpdate < diff)

        {

            // forced update for rated arenas (scan all, but skipped non rated)

            SF_LOG_TRACE("bg.arena", "BattlegroundMgr: UPDATING ARENA QUEUES");

            for (int qtype = BATTLEGROUND_QUEUE_2v2; qtype <= BATTLEGROUND_QUEUE_5v5; ++qtype)

                for (int bracket = 0; bracket < MAX_BATTLEGROUND_BRACKETS; ++bracket)

                    m_BattlegroundQueues[qtype].BattlegroundQueueUpdate(diff,

                        BattlegroundTypeId::BATTLEGROUND_AA, BattlegroundBracketId(bracket),

                        BattlegroundMgr::BGArenaType(BattlegroundQueueTypeId(qtype)), true, 0);


            m_NextRatedArenaUpdate = sWorld->getIntConfig(WorldIntConfigs::CONFIG_ARENA_RATED_UPDATE_TIMER);

        }

        else

            m_NextRatedArenaUpdate -= diff;

    }

}


void BattlegroundMgr::BuildBattlegroundStatusPacket(WorldPacket* data, Battleground* bg, Player* player, uint8 QueueSlot, uint8 StatusID, uint32 Time1, uint32 Time2, uint8 arenatype)

{

    ObjectGuid playerGuid = player->GetGUID();

    ObjectGuid bgGuid;


    if (bg)

        bgGuid = bg->GetGUID();

    else

        StatusID = STATUS_NONE;


    switch (StatusID)

    {

        case STATUS_NONE:

        {

            data->Initialize(SMSG_BATTLEFIELD_STATUS);


            *data << uint32(Time2);                     // Join Time

            *data << uint32(0);                         // Id

            *data << uint32(QueueSlot);                 // Queue slot


            data->WriteBit(playerGuid[2]);

            data->WriteBit(playerGuid[0]);

            data->WriteBit(playerGuid[4]);

            data->WriteBit(playerGuid[5]);

            data->WriteBit(playerGuid[3]);

            data->WriteBit(playerGuid[7]);

            data->WriteBit(playerGuid[1]);

            data->WriteBit(playerGuid[6]);


            data->WriteByteSeq(playerGuid[3]);

            data->WriteByteSeq(playerGuid[5]);

            data->WriteByteSeq(playerGuid[6]);

            data->WriteByteSeq(playerGuid[4]);

            data->WriteByteSeq(playerGuid[2]);

            data->WriteByteSeq(playerGuid[0]);

            data->WriteByteSeq(playerGuid[1]);

            data->WriteByteSeq(playerGuid[7]);

            break;

        }

        case STATUS_WAIT_QUEUE:

        {

            data->Initialize(SMSG_BATTLEFIELD_STATUS_QUEUED);


            data->WriteBit(bgGuid[1]);

            data->WriteBit(bgGuid[5]);

            data->WriteBit(playerGuid[0]);

            data->WriteBit(bgGuid[7]);

            data->WriteBit(bg->isRated());              // Is Rated

            data->WriteBit(0);                          // AsGroup

            data->WriteBit(1);                          // Eligible In Queue

            data->WriteBit(playerGuid[6]);

            data->WriteBit(playerGuid[4]);

            data->WriteBit(playerGuid[1]);

            data->WriteBit(playerGuid[3]);

            data->WriteBit(playerGuid[7]);

            data->WriteBit(playerGuid[5]);

            data->WriteBit(0);                          // IsSuspended

            data->WriteBit(bgGuid[3]);

            data->WriteBit(bgGuid[0]);

            data->WriteBit(bgGuid[2]);

            data->WriteBit(playerGuid[2]);

            data->WriteBit(bgGuid[6]);

            data->WriteBit(bgGuid[4]);


            data->FlushBits();


            data->WriteByteSeq(bgGuid[4]);

            data->WriteByteSeq(playerGuid[6]);

            *data << uint32(0);                         // Id

            data->WriteByteSeq(bgGuid[5]);

            *data << uint32(Time2);                     // Estimated Wait Time

            data->WriteByteSeq(bgGuid[3]);

            data->WriteByteSeq(playerGuid[3]);

            data->WriteByteSeq(playerGuid[4]);

            data->WriteByteSeq(playerGuid[0]);

            *data << uint8(bg->GetMinLevel());          // MinLevel

            data->WriteByteSeq(bgGuid[0]);

            *data << uint32(Time1);                     // Join Time

            *data << uint8(bg->isArena() ? arenatype : 1); // PremadeSize

            data->WriteByteSeq(bgGuid[1]);

            *data << uint32(GetMSTimeDiffToNow(Time2)); // Time since joined

            data->WriteByteSeq(bgGuid[7]);

            *data << uint32(QueueSlot);                 // Queue slot

            data->WriteByteSeq(playerGuid[2]);

            data->WriteByteSeq(bgGuid[6]);

            *data << uint8(bg->GetMaxLevel());          // MaxLevel

            data->WriteByteSeq(bgGuid[2]);

            data->WriteByteSeq(playerGuid[5]);

            data->WriteByteSeq(playerGuid[1]);

            *data << uint32(bg->GetClientInstanceID()); // Client Instance ID

            data->WriteByteSeq(playerGuid[7]);

            break;

        }

        case STATUS_WAIT_JOIN:

        {

            data->Initialize(SMSG_BATTLEFIELD_STATUS_NEEDCONFIRMATION);


            data->WriteBit(playerGuid[7]);

            data->WriteBit(playerGuid[5]);

            data->WriteBit(playerGuid[4]);

            data->WriteBit(playerGuid[1]);

            data->WriteBit(bgGuid[3]);

            data->WriteBit(bgGuid[2]);

            data->WriteBit(1); // Missing Role

            data->WriteBit(bgGuid[0]);

            data->WriteBit(playerGuid[0]);

            data->WriteBit(playerGuid[6]);

            data->WriteBit(bgGuid[7]);

            data->WriteBit(bgGuid[4]);

            data->WriteBit(bgGuid[1]);

            data->WriteBit(bg->isRated());              // Is Rated

            data->WriteBit(playerGuid[2]);

            data->WriteBit(bgGuid[6]);

            data->WriteBit(playerGuid[3]);

            data->WriteBit(bgGuid[5]);


            data->WriteByteSeq(playerGuid[1]);

            data->WriteByteSeq(bgGuid[1]);

            data->WriteByteSeq(playerGuid[2]);

            *data << uint8(bg->isArena() ? arenatype : 1); // Player count, 1 for bgs, 2-3-5 for arena (2v2, 3v3, 5v5)

            *data << uint32(QueueSlot);                 // Queue slot

            // *data << uint32(role);

            *data << uint32(bg->GetClientInstanceID()); // Client Instance ID

            data->WriteByteSeq(bgGuid[6]);

            data->WriteByteSeq(bgGuid[7]);

            *data << uint32(Time2);                     // Join Time

            data->WriteByteSeq(playerGuid[7]);

            *data << uint8(bg->GetMaxLevel());          // MaxLevel

            data->WriteByteSeq(playerGuid[4]);

            data->WriteByteSeq(bgGuid[2]);

            data->WriteByteSeq(bgGuid[4]);

            *data << uint32(Time1);                     // Time until closed

            *data << uint8(bg->GetMinLevel());          // Min Level

            data->WriteByteSeq(playerGuid[3]);

            data->WriteByteSeq(bgGuid[0]);

            data->WriteByteSeq(playerGuid[5]);

            data->WriteByteSeq(playerGuid[6]);

            *data << uint32(0);                         // Id

            data->WriteByteSeq(bgGuid[3]);

            data->WriteByteSeq(playerGuid[0]);

            data->WriteByteSeq(bgGuid[5]);

            *data << uint32(bg->GetMapId());            // Map Id

            break;

        }

        case STATUS_IN_PROGRESS:

        {

            data->Initialize(SMSG_BATTLEFIELD_STATUS_ACTIVE);


            data->WriteBit(playerGuid[0]);

            data->WriteBit(bgGuid[3]);

            data->WriteBit(playerGuid[3]);

            data->WriteBit(bgGuid[2]);

            data->WriteBit(playerGuid[2]);

            data->WriteBit(bgGuid[5]);

            data->WriteBit(bgGuid[1]);

            data->WriteBit(playerGuid[7]);

            data->WriteBit(0);                          // Left Early

            data->WriteBit(playerGuid[6]);

            data->WriteBit(bgGuid[0]);

            data->WriteBit(player->GetBGTeam() == HORDE ? 0 : 1);

            data->WriteBit(bgGuid[6]);

            data->WriteBit(bgGuid[7]);

            data->WriteBit(bgGuid[4]);

            data->WriteBit(playerGuid[1]);

            data->WriteBit(playerGuid[4]);

            data->WriteBit(playerGuid[5]);

            data->WriteBit(bg->isRated());              // Is Rated


            data->FlushBits();


            data->WriteByteSeq(playerGuid[3]);

            *data << uint32(Time1);                     // Join Time

            *data << uint32(bg->GetRemainingTime());    // Remaining Time

            data->WriteByteSeq(bgGuid[7]);

            data->WriteByteSeq(bgGuid[5]);

            data->WriteByteSeq(playerGuid[1]);

            data->WriteByteSeq(bgGuid[6]);

            *data << uint32(Time2);                     // Elapsed Time

            *data << uint8(bg->GetMaxLevel());          // Max Level

            data->WriteByteSeq(bgGuid[1]);

            data->WriteByteSeq(bgGuid[2]);

            *data << uint32(QueueSlot);                 // Queue slot

            data->WriteByteSeq(playerGuid[4]);

            *data << uint8(bg->GetMinLevel());          // Min Level

            data->WriteByteSeq(playerGuid[6]);

            *data << uint32(bg->GetMapId());            // Map Id

            data->WriteByteSeq(playerGuid[0]);

            data->WriteByteSeq(playerGuid[5]);

            data->WriteByteSeq(playerGuid[7]);

            data->WriteByteSeq(bgGuid[4]);

            *data << uint32(bg->GetClientInstanceID()); // Client Instance ID or faction ?

            data->WriteByteSeq(playerGuid[2]);

            *data << uint8(bg->isArena() ? arenatype : 1); // Player count, 1 for bgs, 2-3-5 for arena (2v2, 3v3, 5v5)

            *data << uint32(0);                         // Id

            data->WriteByteSeq(bgGuid[3]);

            data->WriteByteSeq(bgGuid[0]);

            break;

        }

        case STATUS_WAIT_LEAVE:

            break;

    }

}


void BattlegroundMgr::BuildPvpLogDataPacket(WorldPacket* data, Battleground* bg)

{

    ByteBuffer buff;

    uint8 isArena = bg->isArena();


    data->Initialize(SMSG_PVP_LOG_DATA, (1 + 1 + 4 + 40 * bg->GetPlayerScoresSize()));


    *data << uint8(bg->GetPlayersCountByTeam(ALLIANCE));

    *data << uint8(bg->GetPlayersCountByTeam(HORDE));


    data->WriteBit(bg->GetStatus() == STATUS_WAIT_LEAVE);    // If Ended

    data->WriteBit(0);                                       // Unk Some player stuff

    data->WriteBit(0);                                       // isRated


    data->WriteBits(bg->GetPlayerScoresSize(), 19);


    for (Battleground::BattlegroundScoreMap::const_iterator itr = bg->GetPlayerScoresBegin(); itr != bg->GetPlayerScoresEnd(); ++itr)

    {

        if (!bg->IsPlayerInBattleground(itr->first))

        {

            SF_LOG_ERROR("network", "Player " UI64FMTD " has scoreboard entry for battleground %u but is not in battleground!", itr->first, uint32(bg->GetTypeID(true)));

            continue;

        }


        Player* player = ObjectAccessor::FindPlayer(itr->first);

        if (!player)

            continue;

        ObjectGuid playerGUID = itr->first;

        BattlegroundScore* score = itr->second;


        data->WriteBit(playerGUID[6]);

        data->WriteBit(player->GetBGTeam() == HORDE ? 0 : 1);

        data->WriteBit(0);              // Rating Change

        data->WriteBit(playerGUID[0]);

        data->WriteBit(0);              // MMR Change

        data->WriteBit(playerGUID[7]);

        data->WriteBit(0);              // PreMatch MMR

        data->WriteBit(playerGUID[3]);

        data->WriteBit(0);              // Prematch Rating

        data->WriteBit(playerGUID[4]);

        data->WriteBit(playerGUID[1]);


        buff << uint32(score->HealingDone);             // healing done

        buff.WriteByteSeq(playerGUID[4]);

        buff.WriteByteSeq(playerGUID[5]);

        buff.WriteByteSeq(playerGUID[2]);


        if (!isArena)

        {

            buff << uint32(score->Deaths);

            buff << uint32(score->HonorableKills);

            buff << uint32(score->BonusHonor / 100);

        }


        buff.WriteByteSeq(playerGUID[3]);

        buff << uint32(score->DamageDone);              // damage done

        buff << uint32(score->KillingBlows);

        buff.WriteByteSeq(playerGUID[1]);

        buff.WriteByteSeq(playerGUID[6]);

        buff.WriteByteSeq(playerGUID[7]);

        buff.WriteByteSeq(playerGUID[0]);

        buff << int32(bg->GetPlayerActiveSpec(playerGUID));


        switch (bg->GetTypeID(true))                             // Custom values

        {

            case BattlegroundTypeId::BATTLEGROUND_RB:

                switch (bg->GetMapId())

                {

                    case 489:

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundWGScore*)score)->FlagCaptures);        // flag captures

                        buff << uint32(((BattlegroundWGScore*)score)->FlagReturns);         // flag returns

                        break;

                    case 566:

                        data->WriteBits(1, 22);

                        buff << uint32(((BattlegroundEYScore*)score)->FlagCaptures);        // flag captures

                        break;

                    case 529:

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundABScore*)score)->BasesAssaulted);      // bases assaulted

                        buff << uint32(((BattlegroundABScore*)score)->BasesDefended);       // bases defended

                        break;

                    case 30:

                        data->WriteBits(5, 22);

                        buff << uint32(((BattlegroundAVScore*)score)->GraveyardsAssaulted); // GraveyardsAssaulted

                        buff << uint32(((BattlegroundAVScore*)score)->GraveyardsDefended);  // GraveyardsDefended

                        buff << uint32(((BattlegroundAVScore*)score)->TowersAssaulted);     // TowersAssaulted

                        buff << uint32(((BattlegroundAVScore*)score)->TowersDefended);      // TowersDefended

                        buff << uint32(((BattlegroundAVScore*)score)->MinesCaptured);       // MinesCaptured

                        break;

                    case 607:

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundSAScore*)score)->demolishers_destroyed);

                        buff << uint32(((BattlegroundSAScore*)score)->gates_destroyed);

                        break;

                    case 628:                                   // IC

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundICScore*)score)->BasesAssaulted);       // bases assaulted

                        buff << uint32(((BattlegroundICScore*)score)->BasesDefended);        // bases defended

                        break;

                    case 726:

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundTPScore*)score)->FlagCaptures);         // flag captures

                        buff << uint32(((BattlegroundTPScore*)score)->FlagReturns);          // flag returns

                        break;

                    case 761:

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundBFGScore*)score)->BasesAssaulted);      // bases assaulted

                        buff << uint32(((BattlegroundBFGScore*)score)->BasesDefended);       // bases defended

                        break;

                    case 998:

                        data->WriteBits(2, 22);

                        buff << uint32(((BattlegroundVOPScore*)score)->OrbControl);         // orb possession

                        buff << uint32(((BattlegroundVOPScore*)score)->OrbScore);           // victory points

                        break;

                    default:

                        data->WriteBits(0, 22);

                        break;

                }

                break;

            case BattlegroundTypeId::BATTLEGROUND_AV:

                data->WriteBits(5, 22);

                buff << uint32(((BattlegroundAVScore*)score)->GraveyardsAssaulted); // GraveyardsAssaulted

                buff << uint32(((BattlegroundAVScore*)score)->GraveyardsDefended);  // GraveyardsDefended

                buff << uint32(((BattlegroundAVScore*)score)->TowersAssaulted);     // TowersAssaulted

                buff << uint32(((BattlegroundAVScore*)score)->TowersDefended);      // TowersDefended

                buff << uint32(((BattlegroundAVScore*)score)->MinesCaptured);       // MinesCaptured

                break;

            case BattlegroundTypeId::BATTLEGROUND_WS:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundWGScore*)score)->FlagCaptures);        // flag captures

                buff << uint32(((BattlegroundWGScore*)score)->FlagReturns);         // flag returns

                break;

            case BattlegroundTypeId::BATTLEGROUND_AB:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundABScore*)score)->BasesAssaulted);      // bases assaulted

                buff << uint32(((BattlegroundABScore*)score)->BasesDefended);       // bases defended

                break;

            case BattlegroundTypeId::BATTLEGROUND_EY:

                data->WriteBits(1, 22);

                buff << uint32(((BattlegroundEYScore*)score)->FlagCaptures);        // flag captures

                break;

            case BattlegroundTypeId::BATTLEGROUND_SA:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundSAScore*)score)->demolishers_destroyed);

                buff << uint32(((BattlegroundSAScore*)score)->gates_destroyed);

                break;

            case BattlegroundTypeId::BATTLEGROUND_IC:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundICScore*)score)->BasesAssaulted);       // bases assaulted

                buff << uint32(((BattlegroundICScore*)score)->BasesDefended);        // bases defended

                break;

            case BattlegroundTypeId::BATTLEGROUND_TP:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundTPScore*)score)->FlagCaptures);         // flag captures

                buff << uint32(((BattlegroundTPScore*)score)->FlagReturns);          // flag returns

                break;

            case BattlegroundTypeId::BATTLEGROUND_BFG:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundBFGScore*)score)->BasesAssaulted);      // bases assaulted

                buff << uint32(((BattlegroundBFGScore*)score)->BasesDefended);       // bases defended

                break;

            case BattlegroundTypeId::BATTLEGROUND_VOP:

                data->WriteBits(2, 22);

                buff << uint32(((BattlegroundVOPScore*)score)->OrbControl);         // orb possession

                buff << uint32(((BattlegroundVOPScore*)score)->OrbScore);           // victory Points

                break;

            case BattlegroundTypeId::BATTLEGROUND_NA:

            case BattlegroundTypeId::BATTLEGROUND_BE:

            case BattlegroundTypeId::BATTLEGROUND_AA:

            case BattlegroundTypeId::BATTLEGROUND_RL:

            case BattlegroundTypeId::BATTLEGROUND_DS:

            case BattlegroundTypeId::BATTLEGROUND_RV:

            case BattlegroundTypeId::BATTLEGROUND_TV:

                data->WriteBits(0, 22);

                break;

            default:

                data->WriteBits(0, 22);

                break;

        }


        data->WriteBit(player->IsInWorld());

        data->WriteBit(!isArena);

        data->WriteBit(playerGUID[5]);

        data->WriteBit(playerGUID[2]);

    }


    /*if (isRated)                                             // arena

    {

        // it seems this must be according to BG_WINNER_A/H and _NOT_ BG_TEAM_A/H

        for (int8 i = 0; i < BG_TEAMS_COUNT; ++i)

        {

            int32 rating_change = bg->GetArenaTeamRatingChangeByIndex(i);


            uint32 pointsLost = rating_change < 0 ? -rating_change : 0;

            uint32 pointsGained = rating_change > 0 ? rating_change : 0;

            uint32 MatchmakerRating = bg->GetArenaMatchmakerRatingByIndex(i);


            *data << uint32(MatchmakerRating);              // Matchmaking Value

            *data << uint32(pointsLost);                    // Rating Lost

            *data << uint32(pointsGained);                  // Rating gained


            SF_LOG_DEBUG("bg.battleground", "rating change: %d", rating_change);

        }

    }*/


    data->FlushBits();

    data->append(buff);


    if (bg->GetStatus() == STATUS_WAIT_LEAVE)

        *data << uint8(bg->GetWinner());

}


void BattlegroundMgr::BuildStatusFailedPacket(WorldPacket* data, Battleground* bg, Player* player, uint8 QueueSlot, GroupJoinBattlegroundResult result)

{

    ObjectGuid playerGuid = player->GetGUID(); // player who caused the error

    ObjectGuid battlegroundGuid = bg->GetGUID();

    ObjectGuid unkGuid3 = 0;


    data->Initialize(SMSG_BATTLEFIELD_STATUS_FAILED);


    *data << uint32(player->GetBattlegroundQueueJoinTime(bg->GetTypeID())); // Join Time

    *data << uint32(0);                         // Id ???

    *data << uint32(QueueSlot);                 // Queue slot

    *data << uint32(result);                    // Result


    data->WriteBit(unkGuid3[7]);

    data->WriteBit(battlegroundGuid[2]);

    data->WriteBit(battlegroundGuid[7]);

    data->WriteBit(unkGuid3[5]);

    data->WriteBit(playerGuid[2]);

    data->WriteBit(battlegroundGuid[6]);

    data->WriteBit(playerGuid[7]);

    data->WriteBit(playerGuid[3]);

    data->WriteBit(battlegroundGuid[0]);

    data->WriteBit(battlegroundGuid[3]);

    data->WriteBit(unkGuid3[4]);

    data->WriteBit(playerGuid[1]);

    data->WriteBit(unkGuid3[0]);

    data->WriteBit(playerGuid[0]);

    data->WriteBit(unkGuid3[2]);

    data->WriteBit(battlegroundGuid[4]);

    data->WriteBit(playerGuid[4]);

    data->WriteByteSeq(battlegroundGuid[1]);

    data->WriteBit(unkGuid3[3]);

    data->WriteBit(battlegroundGuid[5]);

    data->WriteBit(unkGuid3[1]);

    data->WriteBit(playerGuid[6]);

    data->WriteBit(playerGuid[5]);

    data->WriteBit(unkGuid3[6]);


    data->WriteByteSeq(unkGuid3[1]);

    data->WriteByteSeq(unkGuid3[2]);

    data->WriteByteSeq(unkGuid3[7]);

    data->WriteByteSeq(battlegroundGuid[6]);

    data->WriteByteSeq(battlegroundGuid[0]);

    data->WriteByteSeq(playerGuid[5]);

    data->WriteByteSeq(playerGuid[0]);

    data->WriteByteSeq(battlegroundGuid[1]);

    data->WriteByteSeq(battlegroundGuid[7]);

    data->WriteByteSeq(playerGuid[6]);

    data->WriteByteSeq(unkGuid3[0]);

    data->WriteByteSeq(battlegroundGuid[5]);

    data->WriteByteSeq(unkGuid3[6]);

    data->WriteByteSeq(playerGuid[1]);

    data->WriteByteSeq(battlegroundGuid[2]);

    data->WriteByteSeq(playerGuid[7]);

    data->WriteByteSeq(playerGuid[2]);

    data->WriteByteSeq(playerGuid[3]);

    data->WriteByteSeq(unkGuid3[5]);

    data->WriteByteSeq(playerGuid[4]);

    data->WriteByteSeq(unkGuid3[3]);

    data->WriteByteSeq(battlegroundGuid[3]);

    data->WriteByteSeq(unkGuid3[4]);

    data->WriteByteSeq(battlegroundGuid[4]);

}


void BattlegroundMgr::BuildUpdateWorldStatePacket(WorldPacket* data, uint32 field, uint32 value)

{

    data->Initialize(SMSG_UPDATE_WORLD_STATE, 4 + 4);

    data->WriteBit(0);

    *data << uint32(value);

    *data << uint32(field);

}


void BattlegroundMgr::BuildPlaySoundPacket(WorldPacket* data, uint32 soundid)

{

    data->Initialize(SMSG_PLAY_SOUND, 4 + 9);

    data->WriteBits(0, 8);

    *data << uint32(soundid);

}


void BattlegroundMgr::BuildPlayerLeftBattlegroundPacket(WorldPacket* data, uint64 guid)

{

    ObjectGuid guidBytes = guid;


    data->Initialize(SMSG_BATTLEGROUND_PLAYER_LEFT, 8);

    data->WriteBit(guidBytes[3]);

    data->WriteBit(guidBytes[5]);

    data->WriteBit(guidBytes[6]);

    data->WriteBit(guidBytes[0]);

    data->WriteBit(guidBytes[1]);

    data->WriteBit(guidBytes[2]);

    data->WriteBit(guidBytes[7]);

    data->WriteBit(guidBytes[4]);


    data->WriteByteSeq(guidBytes[0]);

    data->WriteByteSeq(guidBytes[6]);

    data->WriteByteSeq(guidBytes[5]);

    data->WriteByteSeq(guidBytes[7]);

    data->WriteByteSeq(guidBytes[2]);

    data->WriteByteSeq(guidBytes[1]);

    data->WriteByteSeq(guidBytes[3]);

    data->WriteByteSeq(guidBytes[4]);

}


void BattlegroundMgr::BuildPlayerJoinedBattlegroundPacket(WorldPacket* data, uint64 guid)

{

    ObjectGuid guidBytes = guid;


    data->Initialize(SMSG_BATTLEGROUND_PLAYER_JOINED, 9);

    data->WriteBit(guidBytes[7]);

    data->WriteBit(guidBytes[1]);

    data->WriteBit(guidBytes[0]);

    data->WriteBit(guidBytes[4]);

    data->WriteBit(guidBytes[2]);

    data->WriteBit(guidBytes[5]);

    data->WriteBit(guidBytes[6]);

    data->WriteBit(guidBytes[3]);


    data->WriteByteSeq(guidBytes[0]);

    data->WriteByteSeq(guidBytes[3]);

    data->WriteByteSeq(guidBytes[7]);

    data->WriteByteSeq(guidBytes[5]);

    data->WriteByteSeq(guidBytes[2]);

    data->WriteByteSeq(guidBytes[6]);

    data->WriteByteSeq(guidBytes[4]);

    data->WriteByteSeq(guidBytes[1]);

}


Battleground* BattlegroundMgr::GetBattlegroundThroughClientInstance(uint32 instanceId, BattlegroundTypeId bgTypeId)

{

    //cause at HandleBattlegroundJoinOpcode the clients sends the instanceid he gets from

    //SMSG_BATTLEFIELD_LIST we need to find the battleground with this clientinstance-id

    Battleground* bg = GetBattlegroundTemplate(bgTypeId);

    if (!bg)

        return NULL;


    if (bg->isArena())

        return GetBattleground(instanceId, bgTypeId);


    BattlegroundDataContainer::const_iterator it = bgDataStore.find(bgTypeId);

    if (it == bgDataStore.end())

        return NULL;


    for (BattlegroundContainer::const_iterator itr = it->second.m_Battlegrounds.begin(); itr != it->second.m_Battlegrounds.end(); ++itr)

    {

        if (itr->second->GetClientInstanceID() == instanceId)

            return itr->second;

    }


    return NULL;

}


Battleground* BattlegroundMgr::GetBattleground(uint32 instanceId, BattlegroundTypeId bgTypeId)

{

    if (!instanceId)

        return NULL;


    BattlegroundDataContainer::const_iterator begin, end;


    if (bgTypeId == BattlegroundTypeId::BATTLEGROUND_TYPE_NONE)

    {

        begin = bgDataStore.begin();

        end = bgDataStore.end();

    }

    else

    {

        end = bgDataStore.find(bgTypeId);

        if (end == bgDataStore.end())

            return NULL;

        begin = end++;

    }


    for (BattlegroundDataContainer::const_iterator it = begin; it != end; ++it)

    {

        BattlegroundContainer const& bgs = it->second.m_Battlegrounds;

        BattlegroundContainer::const_iterator itr = bgs.find(instanceId);

        if (itr != bgs.end())

            return itr->second;

    }


    return NULL;

}


Battleground* BattlegroundMgr::GetBattlegroundTemplate(BattlegroundTypeId bgTypeId)

{

    BattlegroundDataContainer::const_iterator itr = bgDataStore.find(bgTypeId);

    if (itr == bgDataStore.end())

        return NULL;


    BattlegroundContainer const& bgs = itr->second.m_Battlegrounds;

    // map is sorted and we can be sure that lowest instance id has only BG template

    return bgs.empty() ? NULL : bgs.begin()->second;

}


uint32 BattlegroundMgr::CreateClientVisibleInstanceId(BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id)

{

    if (IsArenaType(bgTypeId))

        return 0;                                           //arenas don't have client-instanceids


    uint8 BracketID = uint8(bracket_id);

    // we create here an instanceid, which is just for

    // displaying this to the client and without any other use..

    // the client-instanceIds are unique for each battleground-type

    // the instance-id just needs to be as low as possible, beginning with 1

    // the following works, because std::set is default ordered with "<"

    // the optimalization would be to use as bitmask std::vector<uint32> - but that would only make code unreadable


    BattlegroundClientIdsContainer& clientIds = bgDataStore[bgTypeId].m_ClientBattlegroundIds[BracketID];

    uint32 lastId = 0;

    for (BattlegroundClientIdsContainer::const_iterator itr = clientIds.begin(); itr != clientIds.end();)

    {

        if ((++lastId) != *itr)                             //if there is a gap between the ids, we will break..

            break;

        lastId = *itr;

    }


    clientIds.insert(++lastId);

    return lastId;

}


// create a new battleground that will really be used to play


Battleground* BattlegroundMgr::CreateNewBattleground(BattlegroundTypeId originalBgTypeId, PvPDifficultyEntry const* bracketEntry, uint8 arenaType, bool isRated)

{

    BattlegroundTypeId bgTypeId = originalBgTypeId;

    bool isRandom = false;


    switch (originalBgTypeId)

    {

        case BattlegroundTypeId::BATTLEGROUND_RB:

            isRandom = true;

        case BattlegroundTypeId::BATTLEGROUND_AA:

            bgTypeId = GetRandomBG(originalBgTypeId);

            break;

        default:

            break;

    }


    // get the template BG

    Battleground* bg_template = GetBattlegroundTemplate(bgTypeId);


    if (!bg_template)

    {

        SF_LOG_ERROR("bg.battleground", "Battleground: CreateNewBattleground - bg template not found for %u", uint32(bgTypeId));

        return NULL;

    }


    Battleground* bg = NULL;

    // create a copy of the BG template

    switch (bgTypeId)

    {

        case BattlegroundTypeId::BATTLEGROUND_AV:

            bg = new BattlegroundAV(*(BattlegroundAV*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_WS:

            bg = new BattlegroundWS(*(BattlegroundWS*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_AB:

            bg = new BattlegroundAB(*(BattlegroundAB*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_NA:

            bg = new BattlegroundNA(*(BattlegroundNA*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_BE:

            bg = new BattlegroundBE(*(BattlegroundBE*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_EY:

            bg = new BattlegroundEY(*(BattlegroundEY*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_RL:

            bg = new BattlegroundRL(*(BattlegroundRL*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_SA:

            bg = new BattlegroundSA(*(BattlegroundSA*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_DS:

            bg = new BattlegroundDS(*(BattlegroundDS*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_RV:

            bg = new BattlegroundRV(*(BattlegroundRV*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_IC:

            bg = new BattlegroundIC(*(BattlegroundIC*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_TP:

            bg = new BattlegroundTP(*(BattlegroundTP*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_BFG:

            bg = new BattlegroundBFG(*(BattlegroundBFG*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_VOP:

            bg = new BattlegroundVOP(*(BattlegroundVOP*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_TV:

            bg = new BattlegroundTV(*(BattlegroundTV*)bg_template);

            break;

        case BattlegroundTypeId::BATTLEGROUND_RB:

        case BattlegroundTypeId::BATTLEGROUND_AA:

            bg = new Battleground(*bg_template);

            break;

        default:

            return NULL;

    }


    bg->SetBracket(bracketEntry);

    bg->SetInstanceID(sMapMgr->GenerateInstanceId());

    bg->SetClientInstanceID(CreateClientVisibleInstanceId(isRandom ? BattlegroundTypeId::BATTLEGROUND_RB : bgTypeId, bracketEntry->GetBracketId()));

    bg->Reset();                     // reset the new bg (set status to status_wait_queue from status_none)

    bg->SetStatus(STATUS_WAIT_JOIN); // start the joining of the bg

    bg->SetArenaType(arenaType);

    bg->SetTypeID(originalBgTypeId);

    bg->SetRandomTypeID(bgTypeId);

    bg->SetRated(isRated);

    bg->SetRandom(isRandom);

    bg->SetGuid(MAKE_NEW_GUID(uint32(bgTypeId), 0, HIGHGUID_BATTLEGROUND));


    // Set up correct min/max player counts for scoreboards

    if (bg->isArena())

    {

        uint32 maxPlayersPerTeam = 0;

        switch (arenaType)

        {

            case ARENA_TYPE_2v2:

                maxPlayersPerTeam = 2;

                break;

            case ARENA_TYPE_3v3:

                maxPlayersPerTeam = 3;

                break;

            case ARENA_TYPE_5v5:

                maxPlayersPerTeam = 5;

                break;

        }


        bg->SetMaxPlayersPerTeam(maxPlayersPerTeam);

        bg->SetMaxPlayers(maxPlayersPerTeam * 2);

    }


    return bg;

}


// used to create the BG templates


bool BattlegroundMgr::CreateBattleground(CreateBattlegroundData& data)

{

    // Create the BG

    Battleground* bg = NULL;

    switch (data.bgTypeId)

    {

        case BattlegroundTypeId::BATTLEGROUND_AV:

            bg = new BattlegroundAV;

            break;

        case BattlegroundTypeId::BATTLEGROUND_WS:

            bg = new BattlegroundWS;

            break;

        case BattlegroundTypeId::BATTLEGROUND_AB:

            bg = new BattlegroundAB;

            break;

        case BattlegroundTypeId::BATTLEGROUND_NA:

            bg = new BattlegroundNA;

            break;

        case BattlegroundTypeId::BATTLEGROUND_BE:

            bg = new BattlegroundBE;

            break;

        case BattlegroundTypeId::BATTLEGROUND_EY:

            bg = new BattlegroundEY;

            break;

        case BattlegroundTypeId::BATTLEGROUND_RL:

            bg = new BattlegroundRL;

            break;

        case BattlegroundTypeId::BATTLEGROUND_SA:

            bg = new BattlegroundSA;

            break;

        case BattlegroundTypeId::BATTLEGROUND_DS:

            bg = new BattlegroundDS;

            break;

        case BattlegroundTypeId::BATTLEGROUND_RV:

            bg = new BattlegroundRV;

            break;

        case BattlegroundTypeId::BATTLEGROUND_IC:

            bg = new BattlegroundIC;

            break;

        case BattlegroundTypeId::BATTLEGROUND_AA:

            bg = new Battleground;

            break;

        case BattlegroundTypeId::BATTLEGROUND_RB:

            bg = new Battleground;

            bg->SetRandom(true);

            break;

        case BattlegroundTypeId::BATTLEGROUND_TP:

            bg = new BattlegroundTP;

            break;

        case BattlegroundTypeId::BATTLEGROUND_TV:

            bg = new BattlegroundTV;

            break;

        case BattlegroundTypeId::BATTLEGROUND_BFG:

            bg = new BattlegroundBFG;

            break;

        case BattlegroundTypeId::BATTLEGROUND_VOP:

            bg = new BattlegroundVOP;

            break;

        default:

            return false;

    }


    bg->SetMapId(data.MapID);

    bg->SetTypeID(data.bgTypeId);

    bg->SetInstanceID(0);

    bg->SetArenaorBGType(data.IsArena);

    bg->SetMinPlayersPerTeam(data.MinPlayersPerTeam);

    bg->SetMaxPlayersPerTeam(data.MaxPlayersPerTeam);

    bg->SetMinPlayers(data.MinPlayersPerTeam * 2);

    bg->SetMaxPlayers(data.MaxPlayersPerTeam * 2);

    bg->SetName(data.BattlegroundName);

    bg->SetTeamStartLoc(ALLIANCE, data.Team1StartLocX, data.Team1StartLocY, data.Team1StartLocZ, data.Team1StartLocO);

    bg->SetTeamStartLoc(HORDE, data.Team2StartLocX, data.Team2StartLocY, data.Team2StartLocZ, data.Team2StartLocO);

    bg->SetStartMaxDist(data.StartMaxDist);

    bg->SetLevelRange(data.LevelMin, data.LevelMax);

    bg->SetScriptId(data.scriptId);

    bg->SetGuid(MAKE_NEW_GUID(uint32(data.bgTypeId), 0, HIGHGUID_BATTLEGROUND));


    AddBattleground(bg);


    return true;

}


void BattlegroundMgr::CreateInitialBattlegrounds()

{

    uint32 oldMSTime = getMSTime();

    //                                               0   1                  2                  3       4       5                 6               7              8            9             10      11

    QueryResult result = WorldDatabase.Query("SELECT id, MinPlayersPerTeam, MaxPlayersPerTeam, MinLvl, MaxLvl, AllianceStartLoc, AllianceStartO, HordeStartLoc, HordeStartO, StartMaxDist, Weight, ScriptName FROM battleground_template");


    if (!result)

    {

        SF_LOG_ERROR("server.loading", ">> Loaded 0 battlegrounds. DB table `battleground_template` is empty.");

        return;

    }


    uint32 count = 0;


    do

    {

        Field* fields = result->Fetch();


        uint32 bgTypeId = fields[0].GetUInt32();

        if (DisableMgr::IsDisabledFor(DISABLE_TYPE_BATTLEGROUND, bgTypeId, NULL))

            continue;


        // can be overwrite by values from DB

        BattlemasterListEntry const* bl = sBattlemasterListStore.LookupEntry(bgTypeId);

        if (!bl)

        {

            SF_LOG_ERROR("bg.battleground", "Battleground ID %u not found in BattleMasterList.dbc. Battleground not created.", bgTypeId);

            continue;

        }


        CreateBattlegroundData data;

        data.bgTypeId = BattlegroundTypeId(bgTypeId);

        data.IsArena = (bl->type == TYPE_ARENA);

        data.MinPlayersPerTeam = fields[1].GetUInt16();

        data.MaxPlayersPerTeam = fields[2].GetUInt16();

        data.LevelMin = fields[3].GetUInt8();

        data.LevelMax = fields[4].GetUInt8();

        float dist = fields[9].GetFloat();

        data.StartMaxDist = dist * dist;


        data.scriptId = sObjectMgr->GetScriptId(fields[11].GetCString());

        data.BattlegroundName = bl->name;

        data.MapID = bl->mapid[0];


        if (data.MaxPlayersPerTeam == 0 || data.MinPlayersPerTeam > data.MaxPlayersPerTeam)

        {

            SF_LOG_ERROR("sql.sql", "Table `battleground_template` for id %u has bad values for MinPlayersPerTeam (%u) and MaxPlayersPerTeam(%u)",

                bgTypeId, data.MinPlayersPerTeam, data.MaxPlayersPerTeam);

            continue;

        }


        if (data.LevelMin == 0 || data.LevelMax == 0 || data.LevelMin > data.LevelMax)

        {

            SF_LOG_ERROR("sql.sql", "Table `battleground_template` for id %u has bad values for LevelMin (%u) and LevelMax(%u)",

                bgTypeId, data.LevelMin, data.LevelMax);

            continue;

        }


        if (data.bgTypeId == BattlegroundTypeId::BATTLEGROUND_AA || data.bgTypeId == BattlegroundTypeId::BATTLEGROUND_RB)

        {

            data.Team1StartLocX = 0;

            data.Team1StartLocY = 0;

            data.Team1StartLocZ = 0;

            data.Team1StartLocO = fields[6].GetFloat();

            data.Team2StartLocX = 0;

            data.Team2StartLocY = 0;

            data.Team2StartLocZ = 0;

            data.Team2StartLocO = fields[8].GetFloat();

        }

        else

        {

            uint32 startId = fields[5].GetUInt32();

            if (WorldSafeLocsEntry const* start = sWorldSafeLocsStore.LookupEntry(startId))

            {

                data.Team1StartLocX = start->x;

                data.Team1StartLocY = start->y;

                data.Team1StartLocZ = start->z;

                data.Team1StartLocO = fields[6].GetFloat();

            }

            else

            {

                SF_LOG_ERROR("sql.sql", "Table `battleground_template` for id %u have non-existed WorldSafeLocs.dbc id %u in field `AllianceStartLoc`. BG not created.", bgTypeId, startId);

                continue;

            }


            startId = fields[7].GetUInt32();

            if (WorldSafeLocsEntry const* start = sWorldSafeLocsStore.LookupEntry(startId))

            {

                data.Team2StartLocX = start->x;

                data.Team2StartLocY = start->y;

                data.Team2StartLocZ = start->z;

                data.Team2StartLocO = fields[8].GetFloat();

            }

            else

            {

                SF_LOG_ERROR("sql.sql", "Table `battleground_template` for id %u have non-existed WorldSafeLocs.dbc id %u in field `HordeStartLoc`. BG not created.", bgTypeId, startId);

                continue;

            }

        }


        if (!CreateBattleground(data))

            continue;


        if (data.IsArena)

        {

            if (data.bgTypeId != BattlegroundTypeId::BATTLEGROUND_AA)

                m_ArenaSelectionWeights[data.bgTypeId] = fields[10].GetUInt8();

        }

        else if (data.bgTypeId != BattlegroundTypeId::BATTLEGROUND_RB)

            m_BGSelectionWeights[data.bgTypeId] = fields[10].GetUInt8();


        ++count;

    } while (result->NextRow());


    SF_LOG_INFO("server.loading", ">> Loaded %u battlegrounds in %u ms", count, GetMSTimeDiffToNow(oldMSTime));

}


void BattlegroundMgr::BuildBattlegroundListPacket(WorldPacket* data, uint64 guid, Player* player, BattlegroundTypeId bgTypeId)

{

    if (!player)

        return;


    BattlegroundDataContainer::iterator it = bgDataStore.find(bgTypeId);

    if (it == bgDataStore.end())

        return;


    PvPDifficultyEntry const* bracketEntry = GetBattlegroundBracketByLevel(it->second.m_Battlegrounds.begin()->second->GetMapId(), player->getLevel());

    if (!bracketEntry)

        return;


    uint32 winnerConquest = (player->GetRandomWinner() ? sWorld->getIntConfig(WorldIntConfigs::CONFIG_BG_REWARD_WINNER_CONQUEST_FIRST) : sWorld->getIntConfig(WorldIntConfigs::CONFIG_BG_REWARD_WINNER_CONQUEST_LAST)) / CURRENCY_PRECISION;

    uint32 winnerHonor = (player->GetRandomWinner() ? sWorld->getIntConfig(WorldIntConfigs::CONFIG_BG_REWARD_WINNER_HONOR_FIRST) : sWorld->getIntConfig(WorldIntConfigs::CONFIG_BG_REWARD_WINNER_HONOR_LAST)) / CURRENCY_PRECISION;

    uint32 loserHonor = (!player->GetRandomWinner() ? sWorld->getIntConfig(WorldIntConfigs::CONFIG_BG_REWARD_LOSER_HONOR_FIRST) : sWorld->getIntConfig(WorldIntConfigs::CONFIG_BG_REWARD_LOSER_HONOR_LAST)) / CURRENCY_PRECISION;


    ObjectGuid guidBytes = guid;


    data->Initialize(SMSG_BATTLEFIELD_LIST);

    *data << uint32(winnerConquest)             // Winner Conquest Reward or Random Winner Conquest Reward

        << uint32(loserHonor)                 // Loser Honor Reward or Random Loser Honor Reward

        << uint8(bracketEntry->minLevel)      // min level

        << uint32(winnerConquest)             // Winner Conquest Reward or Random Winner Conquest Reward

        << uint32(winnerHonor)                // Winner Honor Reward or Random Winner Honor Reward

        << uint32(bgTypeId)                   // battleground id

        << uint32(winnerHonor)                // Winner Honor Reward or Random Winner Honor Reward

        << uint8(bracketEntry->maxLevel)      // max level

        << uint32(loserHonor);                // Loser Honor Reward or Random Loser Honor Reward


    data->WriteBit(guidBytes[0]);

    data->WriteBit(0);            // fake bit ?

    data->WriteBit(guidBytes[4]);

    data->WriteBit(0);            // fake bit ?

    data->WriteBit(guidBytes[2]);

    data->WriteBit(0);            // fake bit ?

    data->WriteBit(guidBytes[7]);

    data->WriteBit(guidBytes[6]);

    data->WriteBit(guidBytes[5]);

    data->WriteBit(guidBytes[1]);

    data->WriteBit(0);            // fake bit ?

    data->WriteBit(guidBytes[3]);


    size_t count_pos = data->bitwpos();

    data->WriteBits(0, 22);                                 // placeholder


    data->FlushBits();


    data->WriteByteSeq(guidBytes[7]);

    data->WriteByteSeq(guidBytes[3]);

    data->WriteByteSeq(guidBytes[4]);

    data->WriteByteSeq(guidBytes[0]);

    data->WriteByteSeq(guidBytes[5]);

    data->WriteByteSeq(guidBytes[6]);

    data->WriteByteSeq(guidBytes[1]);

    data->WriteByteSeq(guidBytes[2]);


    uint32 count = 0;

    uint8 bracketId = uint8(bracketEntry->GetBracketId());

    BattlegroundClientIdsContainer& clientIds = it->second.m_ClientBattlegroundIds[bracketId];

    for (BattlegroundClientIdsContainer::const_iterator itr = clientIds.begin(); itr != clientIds.end(); ++itr)

    {

        *data << uint32(*itr);

        ++count;

    }

    data->PutBits(count_pos, count, 22);                    // bg instance count

}


void BattlegroundMgr::SendToBattleground(Player* player, uint32 instanceId, BattlegroundTypeId bgTypeId)

{

    if (Battleground* bg = GetBattleground(instanceId, bgTypeId))

    {

        float x, y, z, O;

        uint32 mapid = bg->GetMapId();

        uint32 team = player->GetBGTeam();


        bg->GetTeamStartLoc(team, x, y, z, O);

        SF_LOG_DEBUG("bg.battleground", "BattlegroundMgr::SendToBattleground: Sending %s to map %u, X %f, Y %f, Z %f, O %f (bgType %u)", player->GetName().c_str(), mapid, x, y, z, O, uint32(bgTypeId));

        player->TeleportTo(mapid, x, y, z, O);

    }

    else

        SF_LOG_ERROR("bg.battleground", "BattlegroundMgr::SendToBattleground: Instance %u (bgType %u) not found while trying to teleport player %s", instanceId, uint32(bgTypeId), player->GetName().c_str());

}


void BattlegroundMgr::SendAreaSpiritHealerQueryOpcode(Player* player, Battleground* bg, uint64 guid)

{

    ObjectGuid Guid = guid;

    uint32 time_ = 30000 - bg->GetLastResurrectTime();      // resurrect every 30 seconds

    if (time_ == uint32(-1))

        time_ = 0;


    WorldPacket data(SMSG_AREA_SPIRIT_HEALER_TIME, 12);

    data.WriteGuidMask(Guid, 5, 2, 7, 6, 1, 0, 3, 4);


    data.WriteGuidBytes(Guid, 2, 3, 5, 4, 6);

    data << time_;

    data.WriteGuidBytes(Guid, 7, 0, 1);


    player->GetSession()->SendPacket(&data);

}


bool BattlegroundMgr::IsArenaType(BattlegroundTypeId bgTypeId)

{

    return bgTypeId == BattlegroundTypeId::BATTLEGROUND_AA

        || bgTypeId == BattlegroundTypeId::BATTLEGROUND_BE

        || bgTypeId == BattlegroundTypeId::BATTLEGROUND_NA

        || bgTypeId == BattlegroundTypeId::BATTLEGROUND_DS

        || bgTypeId == BattlegroundTypeId::BATTLEGROUND_RV

        || bgTypeId == BattlegroundTypeId::BATTLEGROUND_TV

        || bgTypeId == BattlegroundTypeId::BATTLEGROUND_RL;

}


BattlegroundQueueTypeId BattlegroundMgr::BGQueueTypeId(BattlegroundTypeId bgTypeId, uint8 arenaType)

{

    switch (bgTypeId)

    {

        case BattlegroundTypeId::BATTLEGROUND_AB:

            return BATTLEGROUND_QUEUE_AB;

        case BattlegroundTypeId::BATTLEGROUND_AV:

            return BATTLEGROUND_QUEUE_AV;

        case BattlegroundTypeId::BATTLEGROUND_EY:

            return BATTLEGROUND_QUEUE_EY;

        case BattlegroundTypeId::BATTLEGROUND_IC:

            return BATTLEGROUND_QUEUE_IC;

        case BattlegroundTypeId::BATTLEGROUND_TP:

            return BATTLEGROUND_QUEUE_TP;

        case BattlegroundTypeId::BATTLEGROUND_BFG:

            return BATTLEGROUND_QUEUE_BFG;

        case BattlegroundTypeId::BATTLEGROUND_RB:

            return BATTLEGROUND_QUEUE_RB;

        case BattlegroundTypeId::BATTLEGROUND_SA:

            return BATTLEGROUND_QUEUE_SA;

        case BattlegroundTypeId::BATTLEGROUND_WS:

            return BATTLEGROUND_QUEUE_WS;

        case BattlegroundTypeId::BATTLEGROUND_VOP:

            return BATTLEGROUND_QUEUE_VOP;

        case BattlegroundTypeId::BATTLEGROUND_AA:

        case BattlegroundTypeId::BATTLEGROUND_BE:

        case BattlegroundTypeId::BATTLEGROUND_DS:

        case BattlegroundTypeId::BATTLEGROUND_NA:

        case BattlegroundTypeId::BATTLEGROUND_RL:

        case BattlegroundTypeId::BATTLEGROUND_RV:

        case BattlegroundTypeId::BATTLEGROUND_TV:

            switch (arenaType)

            {

                case ARENA_TYPE_2v2:

                    return BATTLEGROUND_QUEUE_2v2;

                case ARENA_TYPE_3v3:

                    return BATTLEGROUND_QUEUE_3v3;

                case ARENA_TYPE_5v5:

                    return BATTLEGROUND_QUEUE_5v5;

                default:

                    return BATTLEGROUND_QUEUE_NONE;

            }

        default:

            return BATTLEGROUND_QUEUE_NONE;

    }

}


BattlegroundTypeId BattlegroundMgr::BGTemplateId(BattlegroundQueueTypeId bgQueueTypeId)

{

    switch (bgQueueTypeId)

    {

        case BATTLEGROUND_QUEUE_WS:

            return BattlegroundTypeId::BATTLEGROUND_WS;

        case BATTLEGROUND_QUEUE_AB:

            return BattlegroundTypeId::BATTLEGROUND_AB;

        case BATTLEGROUND_QUEUE_AV:

            return BattlegroundTypeId::BATTLEGROUND_AV;

        case BATTLEGROUND_QUEUE_EY:

            return BattlegroundTypeId::BATTLEGROUND_EY;

        case BATTLEGROUND_QUEUE_SA:

            return BattlegroundTypeId::BATTLEGROUND_SA;

        case BATTLEGROUND_QUEUE_IC:

            return BattlegroundTypeId::BATTLEGROUND_IC;

        case BATTLEGROUND_QUEUE_TP:

            return BattlegroundTypeId::BATTLEGROUND_TP;

        case BATTLEGROUND_QUEUE_BFG:

            return BattlegroundTypeId::BATTLEGROUND_BFG;

        case BATTLEGROUND_QUEUE_RB:

            return BattlegroundTypeId::BATTLEGROUND_RB;

        case BATTLEGROUND_QUEUE_VOP:

            return BattlegroundTypeId::BATTLEGROUND_VOP;

        case BATTLEGROUND_QUEUE_2v2:

        case BATTLEGROUND_QUEUE_3v3:

        case BATTLEGROUND_QUEUE_5v5:

            return BattlegroundTypeId::BATTLEGROUND_AA;

        default:

            return BattlegroundTypeId(0);                   // used for unknown template (it existed and do nothing)

    }

}


uint8 BattlegroundMgr::BGArenaType(BattlegroundQueueTypeId bgQueueTypeId)

{

    switch (bgQueueTypeId)

    {

        case BATTLEGROUND_QUEUE_2v2:

            return ARENA_TYPE_2v2;

        case BATTLEGROUND_QUEUE_3v3:

            return ARENA_TYPE_3v3;

        case BATTLEGROUND_QUEUE_5v5:

            return ARENA_TYPE_5v5;

        default:

            return 0;

    }

}


void BattlegroundMgr::ToggleTesting()

{

    m_Testing = !m_Testing;

    sWorld->SendWorldText(m_Testing ? LANG_DEBUG_BG_ON : LANG_DEBUG_BG_OFF);

}


void BattlegroundMgr::ToggleArenaTesting()

{

    m_ArenaTesting = !m_ArenaTesting;

    sWorld->SendWorldText(m_ArenaTesting ? LANG_DEBUG_ARENA_ON : LANG_DEBUG_ARENA_OFF);

}


void BattlegroundMgr::SetHolidayWeekends(uint32 mask)

{

    for (uint32 bgtype = 1; bgtype < MAX_BATTLEGROUND_TYPE_ID; ++bgtype)

    {

        if (Battleground* bg = GetBattlegroundTemplate(BattlegroundTypeId(bgtype)))

        {

            bg->SetHoliday(mask & (1 << bgtype));

        }

    }

}


void BattlegroundMgr::ScheduleQueueUpdate(uint32 arenaMatchmakerRating, uint8 arenaType, BattlegroundQueueTypeId bgQueueTypeId, BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id)

{

    //This method must be atomic, @todo add mutex

    //we will use only 1 number created of bgTypeId and bracket_id

    ScheduledQueueUpdate scheduleId = { arenaMatchmakerRating, arenaType, bgQueueTypeId, bgTypeId, bracket_id };

    if (std::find(m_QueueUpdateScheduler.begin(), m_QueueUpdateScheduler.end(), scheduleId) == m_QueueUpdateScheduler.end())

        m_QueueUpdateScheduler.push_back(scheduleId);

}


uint32 BattlegroundMgr::GetMaxRatingDifference() const

{

    // this is for stupid people who can't use brain and set max rating difference to 0

    uint32 diff = sWorld->getIntConfig(WorldIntConfigs::CONFIG_ARENA_MAX_RATING_DIFFERENCE);

    if (diff == 0)

        diff = 5000;

    return diff;

}


uint32 BattlegroundMgr::GetRatingDiscardTimer() const

{

    return sWorld->getIntConfig(WorldIntConfigs::CONFIG_ARENA_RATING_DISCARD_TIMER);

}


uint32 BattlegroundMgr::GetPrematureFinishTime() const

{

    return sWorld->getIntConfig(WorldIntConfigs::CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER);

}


void BattlegroundMgr::LoadBattleMastersEntry()

{

    uint32 oldMSTime = getMSTime();


    mBattleMastersMap.clear();                                  // need for reload case


    QueryResult result = WorldDatabase.Query("SELECT entry, bg_template FROM battlemaster_entry");


    if (!result)

    {

        SF_LOG_INFO("server.loading", ">> Loaded 0 battlemaster entries. DB table `battlemaster_entry` is empty!");

        return;

    }


    uint32 count = 0;


    do

    {

        ++count;


        Field* fields = result->Fetch();


        uint32 entry = fields[0].GetUInt32();

        uint32 bgTypeId = fields[1].GetUInt32();

        if (!sBattlemasterListStore.LookupEntry(bgTypeId))

        {

            SF_LOG_ERROR("sql.sql", "Table `battlemaster_entry` contain entry %u for not existed battleground type %u, ignored.", entry, bgTypeId);

            continue;

        }


        mBattleMastersMap[entry] = BattlegroundTypeId(bgTypeId);

    } while (result->NextRow());


    SF_LOG_INFO("server.loading", ">> Loaded %u battlemaster entries in %u ms", count, GetMSTimeDiffToNow(oldMSTime));

}


HolidayIds BattlegroundMgr::BGTypeToWeekendHolidayId(BattlegroundTypeId bgTypeId)

{

    switch (bgTypeId)

    {

        case BattlegroundTypeId::BATTLEGROUND_AV: return HolidayIds::HOLIDAY_CALL_TO_ARMS_AV;

        case BattlegroundTypeId::BATTLEGROUND_AB: return HolidayIds::HOLIDAY_CALL_TO_ARMS_AB;

        case BattlegroundTypeId::BATTLEGROUND_EY: return HolidayIds::HOLIDAY_CALL_TO_ARMS_EY;

        case BattlegroundTypeId::BATTLEGROUND_WS: return HolidayIds::HOLIDAY_CALL_TO_ARMS_WS;

        case BattlegroundTypeId::BATTLEGROUND_SA: return HolidayIds::HOLIDAY_CALL_TO_ARMS_SA;

        case BattlegroundTypeId::BATTLEGROUND_IC: return HolidayIds::HOLIDAY_CALL_TO_ARMS_IC;

        case BattlegroundTypeId::BATTLEGROUND_TP: return HolidayIds::HOLIDAY_CALL_TO_ARMS_TP;

        case BattlegroundTypeId::BATTLEGROUND_BFG: return HolidayIds::HOLIDAY_CALL_TO_ARMS_BFG;

        case BattlegroundTypeId::BATTLEGROUND_SM: return HolidayIds::HOLIDAY_CALL_TO_ARMS_SM;

        case BattlegroundTypeId::BATTLEGROUND_VOP: return HolidayIds::HOLIDAY_CALL_TO_ARMS_TK;

        case BattlegroundTypeId::BATTLEGROUND_DG: return HolidayIds::HOLIDAY_CALL_TO_ARMS_DG;

        default: return HolidayIds::HOLIDAY_NONE;

    }

}


BattlegroundTypeId BattlegroundMgr::WeekendHolidayIdToBGType(HolidayIds holiday)

{

    switch (holiday)

    {

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_AV: return BattlegroundTypeId::BATTLEGROUND_AV;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_AB: return BattlegroundTypeId::BATTLEGROUND_AB;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_EY: return BattlegroundTypeId::BATTLEGROUND_EY;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_WS: return BattlegroundTypeId::BATTLEGROUND_WS;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_SA: return BattlegroundTypeId::BATTLEGROUND_SA;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_IC: return BattlegroundTypeId::BATTLEGROUND_IC;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_TP: return BattlegroundTypeId::BATTLEGROUND_TP;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_BFG: return BattlegroundTypeId::BATTLEGROUND_BFG;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_SM: return BattlegroundTypeId::BATTLEGROUND_SM;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_TK: return BattlegroundTypeId::BATTLEGROUND_VOP;

        case HolidayIds::HOLIDAY_CALL_TO_ARMS_DG: return BattlegroundTypeId::BATTLEGROUND_DG;

        default: return BattlegroundTypeId::BATTLEGROUND_TYPE_NONE;

    }

}


bool BattlegroundMgr::IsBGWeekend(BattlegroundTypeId bgTypeId)

{

    return IsHolidayActive(BGTypeToWeekendHolidayId(bgTypeId));

}


BattlegroundTypeId BattlegroundMgr::GetRandomBG(BattlegroundTypeId bgTypeId)

{

    uint32 weight = 0;

    BattlegroundTypeId returnBgTypeId = BattlegroundTypeId::BATTLEGROUND_TYPE_NONE;

    BattlegroundSelectionWeightMap selectionWeights;


    if (bgTypeId == BattlegroundTypeId::BATTLEGROUND_AA)

    {

        for (BattlegroundSelectionWeightMap::const_iterator it = m_ArenaSelectionWeights.begin(); it != m_ArenaSelectionWeights.end(); ++it)

        {

            if (it->second)

            {

                weight += it->second;

                selectionWeights[it->first] = it->second;

            }

        }

    }

    else if (bgTypeId == BattlegroundTypeId::BATTLEGROUND_RB)

    {

        for (BattlegroundSelectionWeightMap::const_iterator it = m_BGSelectionWeights.begin(); it != m_BGSelectionWeights.end(); ++it)

        {

            if (it->second)

            {

                weight += it->second;

                selectionWeights[it->first] = it->second;

            }

        }

    }


    if (weight)

    {

        // Select a random value

        uint32 selectedWeight = std::rand() % (weight - 1);

        // Select the correct bg (if we have in DB A(10), B(20), C(10), D(15) --> [0---A---9|10---B---29|30---C---39|40---D---54])

        weight = 0;

        for (BattlegroundSelectionWeightMap::const_iterator it = selectionWeights.begin(); it != selectionWeights.end(); ++it)

        {

            weight += it->second;

            if (selectedWeight < weight)

            {

                returnBgTypeId = it->first;

                break;

            }

        }

    }


    return returnBgTypeId;

}


BGFreeSlotQueueContainer& BattlegroundMgr::GetBGFreeSlotQueueStore(BattlegroundTypeId bgTypeId)

{

    return bgDataStore[bgTypeId].BGFreeSlotQueue;

}


void BattlegroundMgr::AddToBGFreeSlotQueue(BattlegroundTypeId bgTypeId, Battleground* bg)

{

    bgDataStore[bgTypeId].BGFreeSlotQueue.push_front(bg);

}


void BattlegroundMgr::RemoveFromBGFreeSlotQueue(BattlegroundTypeId bgTypeId, uint32 instanceId)

{

    BGFreeSlotQueueContainer& queues = bgDataStore[bgTypeId].BGFreeSlotQueue;

    for (BGFreeSlotQueueContainer::iterator itr = queues.begin(); itr != queues.end(); ++itr)

        if ((*itr)->GetInstanceID() == instanceId)

        {

            queues.erase(itr);

            return;

        }

}


void BattlegroundMgr::AddBattleground(Battleground* bg)

{

    if (bg)

        bgDataStore[bg->GetTypeID()].m_Battlegrounds[bg->GetInstanceID()] = bg;

}


void BattlegroundMgr::RemoveBattleground(BattlegroundTypeId bgTypeId, uint32 instanceId)

{

    bgDataStore[bgTypeId].m_Battlegrounds.erase(instanceId);

}


ArenaTeam.h

ArenaTeamMgr.h

ARENA_TYPE_5v5
@ ARENA_TYPE_5v5
Definition Battleground.h:172

ARENA_TYPE_3v3
@ ARENA_TYPE_3v3
Definition Battleground.h:171

ARENA_TYPE_2v2
@ ARENA_TYPE_2v2
Definition Battleground.h:170

TYPE_ARENA
@ TYPE_ARENA
Definition Battleground.h:211

STATUS_WAIT_QUEUE
@ STATUS_WAIT_QUEUE
Definition Battleground.h:146

STATUS_NONE
@ STATUS_NONE
Definition Battleground.h:145

STATUS_WAIT_LEAVE
@ STATUS_WAIT_LEAVE
Definition Battleground.h:149

STATUS_WAIT_JOIN
@ STATUS_WAIT_JOIN
Definition Battleground.h:147

STATUS_IN_PROGRESS
@ STATUS_IN_PROGRESS
Definition Battleground.h:148

BattlegroundAB.h

BattlegroundAV.h

BattlegroundBE.h

BattlegroundBFG.h

BattlegroundDS.h

BattlegroundEY.h

BattlegroundIC.h

BattlegroundMgr.h

BattlegroundContainer
std::map< uint32, Battleground * > BattlegroundContainer
Definition BattlegroundMgr.h:15

BattlegroundClientIdsContainer
std::set< uint32 > BattlegroundClientIdsContainer
Definition BattlegroundMgr.h:16

BattlegroundNA.h

BGFreeSlotQueueContainer
std::list< Battleground * > BGFreeSlotQueueContainer
Definition BattlegroundQueue.h:17

BattlegroundRL.h

BattlegroundRV.h

BattlegroundSA.h

BattlegroundTP.h

BattlegroundTV.h

BattlegroundVOP.h

BattlegroundWS.h

Chat.h

Common.h

MAX_BATTLEGROUND_BRACKETS
#define MAX_BATTLEGROUND_BRACKETS
Definition DBCEnums.h:34

BattlegroundBracketId
BattlegroundBracketId
Definition DBCEnums.h:28

sWorldSafeLocsStore
DBCStorage< WorldSafeLocsEntry > sWorldSafeLocsStore(WorldSafeLocsEntryfmt)

sBattlemasterListStore
DBCStorage< BattlemasterListEntry > sBattlemasterListStore(BattlemasterListEntryfmt)

GetBattlegroundBracketByLevel
PvPDifficultyEntry const * GetBattlegroundBracketByLevel(uint32 mapid, uint32 level)
Definition DBCStores.cpp:1295

int32
std::int32_t int32
Definition Define.h:73

UI64FMTD
#define UI64FMTD
Definition Define.h:64

uint8
std::uint8_t uint8
Definition Define.h:79

uint32
std::uint32_t uint32
Definition Define.h:77

uint64
std::uint64_t uint64
Definition Define.h:76

DisableMgr.h

DISABLE_TYPE_BATTLEGROUND
@ DISABLE_TYPE_BATTLEGROUND
Definition DisableMgr.h:18

Formulas.h

IsHolidayActive
bool IsHolidayActive(HolidayIds id)
Definition GameEventMgr.cpp:1597

GameEventMgr.h

LANG_DEBUG_BG_OFF
@ LANG_DEBUG_BG_OFF
Definition Language.h:722

LANG_DEBUG_ARENA_OFF
@ LANG_DEBUG_ARENA_OFF
Definition Language.h:720

LANG_DEBUG_BG_ON
@ LANG_DEBUG_BG_ON
Definition Language.h:721

LANG_DEBUG_ARENA_ON
@ LANG_DEBUG_ARENA_ON
Definition Language.h:719

SF_LOG_DEBUG
#define SF_LOG_DEBUG(filterType__,...)
Definition Log.h:134

SF_LOG_ERROR
#define SF_LOG_ERROR(filterType__,...)
Definition Log.h:143

SF_LOG_TRACE
#define SF_LOG_TRACE(filterType__,...)
Definition Log.h:131

SF_LOG_INFO
#define SF_LOG_INFO(filterType__,...)
Definition Log.h:137

Map.h

MapInstanced.h

MapManager.h

sMapMgr
#define sMapMgr
Definition MapManager.h:145

HIGHGUID_BATTLEGROUND
@ HIGHGUID_BATTLEGROUND
Definition ObjectDefines.h:24

MAKE_NEW_GUID
uint64 MAKE_NEW_GUID(uint32 l, uint32 e, uint32 h)
Definition ObjectDefines.h:190

ObjectMgr.h

sObjectMgr
#define sObjectMgr
Definition ObjectMgr.h:1617

Opcodes.h

Player.h

QueryResult
Skyfire::AutoPtr< ResultSet, Skyfire::Mutex > QueryResult
Definition QueryResult.h:48

SharedDefines.h

GroupJoinBattlegroundResult
GroupJoinBattlegroundResult
Definition SharedDefines.h:4187

CURRENCY_PRECISION
#define CURRENCY_PRECISION
Definition SharedDefines.h:4279

BattlegroundQueueTypeId
BattlegroundQueueTypeId
Definition SharedDefines.h:4168

BATTLEGROUND_QUEUE_2v2
@ BATTLEGROUND_QUEUE_2v2
Definition SharedDefines.h:4180

BATTLEGROUND_QUEUE_RB
@ BATTLEGROUND_QUEUE_RB
Definition SharedDefines.h:4179

BATTLEGROUND_QUEUE_SA
@ BATTLEGROUND_QUEUE_SA
Definition SharedDefines.h:4174

BATTLEGROUND_QUEUE_AB
@ BATTLEGROUND_QUEUE_AB
Definition SharedDefines.h:4172

BATTLEGROUND_QUEUE_5v5
@ BATTLEGROUND_QUEUE_5v5
Definition SharedDefines.h:4182

BATTLEGROUND_QUEUE_WS
@ BATTLEGROUND_QUEUE_WS
Definition SharedDefines.h:4171

BATTLEGROUND_QUEUE_BFG
@ BATTLEGROUND_QUEUE_BFG
Definition SharedDefines.h:4177

BATTLEGROUND_QUEUE_AV
@ BATTLEGROUND_QUEUE_AV
Definition SharedDefines.h:4170

MAX_BATTLEGROUND_QUEUE_TYPES
@ MAX_BATTLEGROUND_QUEUE_TYPES
Definition SharedDefines.h:4183

BATTLEGROUND_QUEUE_EY
@ BATTLEGROUND_QUEUE_EY
Definition SharedDefines.h:4173

BATTLEGROUND_QUEUE_TP
@ BATTLEGROUND_QUEUE_TP
Definition SharedDefines.h:4176

BATTLEGROUND_QUEUE_3v3
@ BATTLEGROUND_QUEUE_3v3
Definition SharedDefines.h:4181

BATTLEGROUND_QUEUE_NONE
@ BATTLEGROUND_QUEUE_NONE
Definition SharedDefines.h:4169

BATTLEGROUND_QUEUE_VOP
@ BATTLEGROUND_QUEUE_VOP
Definition SharedDefines.h:4178

BATTLEGROUND_QUEUE_IC
@ BATTLEGROUND_QUEUE_IC
Definition SharedDefines.h:4175

ALLIANCE
@ ALLIANCE
Definition SharedDefines.h:877

HORDE
@ HORDE
Definition SharedDefines.h:876

BattlegroundTypeId
BattlegroundTypeId
Definition SharedDefines.h:4003

BattlegroundTypeId::BATTLEGROUND_AA
@ BATTLEGROUND_AA
Definition SharedDefines.h:4010

BattlegroundTypeId::BATTLEGROUND_EY
@ BATTLEGROUND_EY
Definition SharedDefines.h:4011

BattlegroundTypeId::BATTLEGROUND_RL
@ BATTLEGROUND_RL
Definition SharedDefines.h:4012

BattlegroundTypeId::BATTLEGROUND_TP
@ BATTLEGROUND_TP
Definition SharedDefines.h:4021

BattlegroundTypeId::BATTLEGROUND_VOP
@ BATTLEGROUND_VOP
Definition SharedDefines.h:4026

BattlegroundTypeId::BATTLEGROUND_RB
@ BATTLEGROUND_RB
Definition SharedDefines.h:4017

BattlegroundTypeId::BATTLEGROUND_BFG
@ BATTLEGROUND_BFG
Definition SharedDefines.h:4022

BattlegroundTypeId::BATTLEGROUND_BE
@ BATTLEGROUND_BE
Definition SharedDefines.h:4009

BattlegroundTypeId::BATTLEGROUND_SM
@ BATTLEGROUND_SM
Definition SharedDefines.h:4028

BattlegroundTypeId::BATTLEGROUND_WS
@ BATTLEGROUND_WS
Definition SharedDefines.h:4006

BattlegroundTypeId::BATTLEGROUND_AV
@ BATTLEGROUND_AV
Definition SharedDefines.h:4005

BattlegroundTypeId::BATTLEGROUND_AB
@ BATTLEGROUND_AB
Definition SharedDefines.h:4007

BattlegroundTypeId::BATTLEGROUND_DG
@ BATTLEGROUND_DG
Definition SharedDefines.h:4030

BattlegroundTypeId::BATTLEGROUND_NA
@ BATTLEGROUND_NA
Definition SharedDefines.h:4008

BattlegroundTypeId::BATTLEGROUND_TYPE_NONE
@ BATTLEGROUND_TYPE_NONE
Definition SharedDefines.h:4004

BattlegroundTypeId::BATTLEGROUND_IC
@ BATTLEGROUND_IC
Definition SharedDefines.h:4016

BattlegroundTypeId::BATTLEGROUND_TV
@ BATTLEGROUND_TV
Definition SharedDefines.h:4029

BattlegroundTypeId::BATTLEGROUND_DS
@ BATTLEGROUND_DS
Definition SharedDefines.h:4014

BattlegroundTypeId::BATTLEGROUND_SA
@ BATTLEGROUND_SA
Definition SharedDefines.h:4013

BattlegroundTypeId::BATTLEGROUND_RV
@ BATTLEGROUND_RV
Definition SharedDefines.h:4015

HolidayIds
HolidayIds
Definition SharedDefines.h:3227

HolidayIds::HOLIDAY_CALL_TO_ARMS_SM
@ HOLIDAY_CALL_TO_ARMS_SM
Definition SharedDefines.h:3264

HolidayIds::HOLIDAY_CALL_TO_ARMS_TP
@ HOLIDAY_CALL_TO_ARMS_TP
Definition SharedDefines.h:3257

HolidayIds::HOLIDAY_CALL_TO_ARMS_SA
@ HOLIDAY_CALL_TO_ARMS_SA
Definition SharedDefines.h:3249

HolidayIds::HOLIDAY_CALL_TO_ARMS_WS
@ HOLIDAY_CALL_TO_ARMS_WS
Definition SharedDefines.h:3235

HolidayIds::HOLIDAY_CALL_TO_ARMS_IC
@ HOLIDAY_CALL_TO_ARMS_IC
Definition SharedDefines.h:3253

HolidayIds::HOLIDAY_CALL_TO_ARMS_EY
@ HOLIDAY_CALL_TO_ARMS_EY
Definition SharedDefines.h:3243

HolidayIds::HOLIDAY_NONE
@ HOLIDAY_NONE
Definition SharedDefines.h:3228

HolidayIds::HOLIDAY_CALL_TO_ARMS_TK
@ HOLIDAY_CALL_TO_ARMS_TK
Definition SharedDefines.h:3265

HolidayIds::HOLIDAY_CALL_TO_ARMS_DG
@ HOLIDAY_CALL_TO_ARMS_DG
Definition SharedDefines.h:3266

HolidayIds::HOLIDAY_CALL_TO_ARMS_AB
@ HOLIDAY_CALL_TO_ARMS_AB
Definition SharedDefines.h:3236

HolidayIds::HOLIDAY_CALL_TO_ARMS_AV
@ HOLIDAY_CALL_TO_ARMS_AV
Definition SharedDefines.h:3234

HolidayIds::HOLIDAY_CALL_TO_ARMS_BFG
@ HOLIDAY_CALL_TO_ARMS_BFG
Definition SharedDefines.h:3256

MAX_BATTLEGROUND_TYPE_ID
#define MAX_BATTLEGROUND_TYPE_ID
Definition SharedDefines.h:4034

GetMSTimeDiffToNow
uint32 GetMSTimeDiffToNow(uint32 oldMSTime)
Definition Timer.h:22

getMSTime
uint32 getMSTime()
Definition Timer.h:12

World.h

WorldPacket.h

BattlegroundAB
Definition BattlegroundAB.h:236

BattlegroundAV
Definition BattlegroundAV.h:1529

BattlegroundBE
Definition BattlegroundBE.h:33

BattlegroundBFG
Definition BattlegroundBFG.h:208

BattlegroundDS
Definition BattlegroundDS.h:70

BattlegroundEY
Definition BattlegroundEY.h:320

Battleground
Definition Battleground.h:275

Battleground::SetMapId
void SetMapId(uint32 MapID)
Definition Battleground.h:392

Battleground::SetInstanceID
void SetInstanceID(uint32 InstanceID)
Definition Battleground.h:333

Battleground::GetMapId
uint32 GetMapId() const
Definition Battleground.h:393

Battleground::GetTypeID
BattlegroundTypeId GetTypeID(bool GetRandom=false) const
Definition Battleground.h:302

Battleground::ToBeDeleted
bool ToBeDeleted() const
Definition Battleground.h:531

Battleground::GetMinLevel
uint32 GetMinLevel() const
Definition Battleground.h:313

Battleground::SetRandom
void SetRandom(bool isRandom)
Definition Battleground.h:360

Battleground::SetMaxPlayers
void SetMaxPlayers(uint32 MaxPlayers)
Definition Battleground.h:339

Battleground::Reset
virtual void Reset()
Definition Battleground.cpp:1097

Battleground::GetPlayerScoresSize
uint32 GetPlayerScoresSize() const
Definition Battleground.h:376

Battleground::GetPlayerActiveSpec
uint32 GetPlayerActiveSpec(uint64 guid) const
Definition Battleground.cpp:1869

Battleground::SetScriptId
void SetScriptId(uint32 scriptId)
Definition Battleground.h:346

Battleground::isRated
bool isRated() const
Definition Battleground.h:367

Battleground::SetName
void SetName(char const *Name)
Definition Battleground.h:328

Battleground::SetBracket
void SetBracket(PvPDifficultyEntry const *bracketEntry)
Definition Battleground.cpp:1980

Battleground::SetMinPlayersPerTeam
void SetMinPlayersPerTeam(uint32 MinPlayers)
Definition Battleground.h:352

Battleground::SetRated
void SetRated(bool state)
Definition Battleground.h:342

Battleground::SetStartMaxDist
void SetStartMaxDist(float startMaxDist)
Definition Battleground.h:410

Battleground::GetRemainingTime
uint32 GetRemainingTime() const
Definition Battleground.h:308

Battleground::GetGUID
uint64 GetGUID() const
Definition Battleground.h:301

Battleground::Update
void Update(uint32 diff)
Definition Battleground.cpp:181

Battleground::GetInstanceID
uint32 GetInstanceID() const
Definition Battleground.h:304

Battleground::GetPlayerScoresBegin
BattlegroundScoreMap::const_iterator GetPlayerScoresBegin() const
Definition Battleground.h:374

Battleground::SetLevelRange
void SetLevelRange(uint32 min, uint32 max)
Definition Battleground.h:341

Battleground::GetClientInstanceID
uint32 GetClientInstanceID() const
Definition Battleground.h:306

Battleground::SetGuid
void SetGuid(uint64 newGuid)
Definition Battleground.h:327

Battleground::SetClientInstanceID
void SetClientInstanceID(uint32 InstanceID)
Definition Battleground.h:335

Battleground::SetStatus
void SetStatus(BattlegroundStatus Status)
Definition Battleground.h:334

Battleground::isArena
bool isArena() const
Definition Battleground.h:365

Battleground::SetArenaType
void SetArenaType(uint8 type)
Definition Battleground.h:343

Battleground::SetRandomTypeID
void SetRandomTypeID(BattlegroundTypeId TypeID)
Definition Battleground.h:330

Battleground::SetTeamStartLoc
void SetTeamStartLoc(uint32 TeamID, float X, float Y, float Z, float O)
Definition Battleground.cpp:616

Battleground::GetStatus
BattlegroundStatus GetStatus() const
Definition Battleground.h:305

Battleground::SetArenaorBGType
void SetArenaorBGType(bool _isArena)
Definition Battleground.h:344

Battleground::GetWinner
uint8 GetWinner() const
Definition Battleground.h:321

Battleground::GetPlayersCountByTeam
uint32 GetPlayersCountByTeam(uint32 Team) const
Definition Battleground.h:448

Battleground::GetLastResurrectTime
uint32 GetLastResurrectTime() const
Definition Battleground.h:309

Battleground::GetBracketId
BattlegroundBracketId GetBracketId() const
Definition Battleground.h:303

Battleground::IsPlayerInBattleground
bool IsPlayerInBattleground(uint64 guid) const
Definition Battleground.cpp:1882

Battleground::GetMaxLevel
uint32 GetMaxLevel() const
Definition Battleground.h:314

Battleground::GetPlayerScoresEnd
BattlegroundScoreMap::const_iterator GetPlayerScoresEnd() const
Definition Battleground.h:375

Battleground::SetMinPlayers
void SetMinPlayers(uint32 MinPlayers)
Definition Battleground.h:340

Battleground::SetMaxPlayersPerTeam
void SetMaxPlayersPerTeam(uint32 MaxPlayers)
Definition Battleground.h:351

Battleground::SetTypeID
void SetTypeID(BattlegroundTypeId TypeID)
Definition Battleground.h:329

BattlegroundIC
Definition BattlegroundIC.h:846

BattlegroundMgr::GetBattlegroundThroughClientInstance
Battleground * GetBattlegroundThroughClientInstance(uint32 instanceId, BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:684

BattlegroundMgr::BuildUpdateWorldStatePacket
void BuildUpdateWorldStatePacket(WorldPacket *data, uint32 field, uint32 value)
Definition BattlegroundMgr.cpp:621

BattlegroundMgr::LoadBattleMastersEntry
void LoadBattleMastersEntry()
Definition BattlegroundMgr.cpp:1355

BattlegroundMgr::BuildPlayerJoinedBattlegroundPacket
void BuildPlayerJoinedBattlegroundPacket(WorldPacket *data, uint64 guid)
Definition BattlegroundMgr.cpp:660

BattlegroundMgr::m_ArenaTesting
bool m_ArenaTesting
Definition BattlegroundMgr.h:152

BattlegroundMgr::CreateBattleground
bool CreateBattleground(CreateBattlegroundData &data)
Definition BattlegroundMgr.cpp:897

BattlegroundMgr::AddToBGFreeSlotQueue
void AddToBGFreeSlotQueue(BattlegroundTypeId bgTypeId, Battleground *bg)
Definition BattlegroundMgr.cpp:1488

BattlegroundMgr::m_BGSelectionWeights
BattlegroundSelectionWeightMap m_BGSelectionWeights
Definition BattlegroundMgr.h:149

BattlegroundMgr::m_QueueUpdateScheduler
std::vector< ScheduledQueueUpdate > m_QueueUpdateScheduler
Definition BattlegroundMgr.h:150

BattlegroundMgr::BattlegroundSelectionWeightMap
std::map< BattlegroundTypeId, uint8 > BattlegroundSelectionWeightMap
Definition BattlegroundMgr.h:147

BattlegroundMgr::DeleteAllBattlegrounds
void DeleteAllBattlegrounds()
Definition BattlegroundMgr.cpp:54

BattlegroundMgr::GetBattleground
Battleground * GetBattleground(uint32 InstanceID, BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:708

BattlegroundMgr::BattlegroundMgr
BattlegroundMgr()
Definition BattlegroundMgr.cpp:44

BattlegroundMgr::RemoveBattleground
void RemoveBattleground(BattlegroundTypeId bgTypeId, uint32 instanceId)
Definition BattlegroundMgr.cpp:1510

BattlegroundMgr::GetMaxRatingDifference
uint32 GetMaxRatingDifference() const
Definition BattlegroundMgr.cpp:1336

BattlegroundMgr::GetRandomBG
BattlegroundTypeId GetRandomBG(BattlegroundTypeId id)
Definition BattlegroundMgr.cpp:1434

BattlegroundMgr::CreateInitialBattlegrounds
void CreateInitialBattlegrounds()
Definition BattlegroundMgr.cpp:980

BattlegroundMgr::m_BattlegroundQueues
BattlegroundQueue m_BattlegroundQueues[MAX_BATTLEGROUND_QUEUE_TYPES]
Definition BattlegroundMgr.h:131

BattlegroundMgr::IsArenaType
static bool IsArenaType(BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:1198

BattlegroundMgr::GetBGFreeSlotQueueStore
BGFreeSlotQueueContainer & GetBGFreeSlotQueueStore(BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:1483

BattlegroundMgr::BGQueueTypeId
static BattlegroundQueueTypeId BGQueueTypeId(BattlegroundTypeId bgTypeId, uint8 arenaType)
Definition BattlegroundMgr.cpp:1209

BattlegroundMgr::AddBattleground
void AddBattleground(Battleground *bg)
Definition BattlegroundMgr.cpp:1504

BattlegroundMgr::BuildBattlegroundStatusPacket
void BuildBattlegroundStatusPacket(WorldPacket *data, Battleground *bg, Player *player, uint8 queueSlot, uint8 statusId, uint32 time1, uint32 time2, uint8 arenaType)
Definition BattlegroundMgr.cpp:140

BattlegroundMgr::ToggleArenaTesting
void ToggleArenaTesting()
Definition BattlegroundMgr.cpp:1310

BattlegroundMgr::BGTemplateId
static BattlegroundTypeId BGTemplateId(BattlegroundQueueTypeId bgQueueTypeId)
Definition BattlegroundMgr.cpp:1256

BattlegroundMgr::RemoveFromBGFreeSlotQueue
void RemoveFromBGFreeSlotQueue(BattlegroundTypeId bgTypeId, uint32 instanceId)
Definition BattlegroundMgr.cpp:1493

BattlegroundMgr::mBattleMastersMap
BattleMastersMap mBattleMastersMap
Definition BattlegroundMgr.h:154

BattlegroundMgr::ScheduleQueueUpdate
void ScheduleQueueUpdate(uint32 arenaMatchmakerRating, uint8 arenaType, BattlegroundQueueTypeId bgQueueTypeId, BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id)
Definition BattlegroundMgr.cpp:1327

BattlegroundMgr::CreateNewBattleground
Battleground * CreateNewBattleground(BattlegroundTypeId bgTypeId, PvPDifficultyEntry const *bracketEntry, uint8 arenaType, bool isRated)
Definition BattlegroundMgr.cpp:777

BattlegroundMgr::m_ArenaSelectionWeights
BattlegroundSelectionWeightMap m_ArenaSelectionWeights
Definition BattlegroundMgr.h:148

BattlegroundMgr::SendToBattleground
void SendToBattleground(Player *player, uint32 InstanceID, BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:1165

BattlegroundMgr::SetHolidayWeekends
void SetHolidayWeekends(uint32 mask)
Definition BattlegroundMgr.cpp:1316

BattlegroundMgr::BuildPvpLogDataPacket
void BuildPvpLogDataPacket(WorldPacket *data, Battleground *bg)
Definition BattlegroundMgr.cpp:343

BattlegroundMgr::ToggleTesting
void ToggleTesting()
Definition BattlegroundMgr.cpp:1304

BattlegroundMgr::GetRatingDiscardTimer
uint32 GetRatingDiscardTimer() const
Definition BattlegroundMgr.cpp:1345

BattlegroundMgr::WeekendHolidayIdToBGType
static BattlegroundTypeId WeekendHolidayIdToBGType(HolidayIds holiday)
Definition BattlegroundMgr.cpp:1410

BattlegroundMgr::BuildStatusFailedPacket
void BuildStatusFailedPacket(WorldPacket *data, Battleground *bg, Player *pPlayer, uint8 QueueSlot, GroupJoinBattlegroundResult result)
Definition BattlegroundMgr.cpp:557

BattlegroundMgr::BGTypeToWeekendHolidayId
static HolidayIds BGTypeToWeekendHolidayId(BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:1391

BattlegroundMgr::BuildBattlegroundListPacket
void BuildBattlegroundListPacket(WorldPacket *data, uint64 guid, Player *player, BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:1097

BattlegroundMgr::GetBattlegroundTemplate
Battleground * GetBattlegroundTemplate(BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:739

BattlegroundMgr::BuildPlaySoundPacket
void BuildPlaySoundPacket(WorldPacket *data, uint32 soundId)
Definition BattlegroundMgr.cpp:629

BattlegroundMgr::BuildPlayerLeftBattlegroundPacket
void BuildPlayerLeftBattlegroundPacket(WorldPacket *data, uint64 guid)
Definition BattlegroundMgr.cpp:636

BattlegroundMgr::~BattlegroundMgr
~BattlegroundMgr()
Definition BattlegroundMgr.cpp:49

BattlegroundMgr::GetPrematureFinishTime
uint32 GetPrematureFinishTime() const
Definition BattlegroundMgr.cpp:1350

BattlegroundMgr::CreateClientVisibleInstanceId
uint32 CreateClientVisibleInstanceId(BattlegroundTypeId bgTypeId, BattlegroundBracketId bracket_id)
Definition BattlegroundMgr.cpp:750

BattlegroundMgr::Update
void Update(uint32 diff)
Definition BattlegroundMgr.cpp:72

BattlegroundMgr::m_NextRatedArenaUpdate
uint32 m_NextRatedArenaUpdate
Definition BattlegroundMgr.h:151

BattlegroundMgr::SendAreaSpiritHealerQueryOpcode
void SendAreaSpiritHealerQueryOpcode(Player *player, Battleground *bg, uint64 guid)
Definition BattlegroundMgr.cpp:1181

BattlegroundMgr::IsBGWeekend
static bool IsBGWeekend(BattlegroundTypeId bgTypeId)
Definition BattlegroundMgr.cpp:1429

BattlegroundMgr::m_Testing
bool m_Testing
Definition BattlegroundMgr.h:153

BattlegroundMgr::BGArenaType
static uint8 BGArenaType(BattlegroundQueueTypeId bgQueueTypeId)
Definition BattlegroundMgr.cpp:1289

BattlegroundMgr::bgDataStore
BattlegroundDataContainer bgDataStore
Definition BattlegroundMgr.h:129

BattlegroundNA
Definition BattlegroundNA.h:33

BattlegroundRL
Definition BattlegroundRL.h:29

BattlegroundRV
Definition BattlegroundRV.h:83

BattlegroundSA
Class for manage Strand of Ancient battleground.
Definition BattlegroundSA.h:431

BattlegroundTP
Definition BattlegroundTP.h:157

BattlegroundTV
Definition BattlegroundTV.h:29

BattlegroundVOP
Definition BattlegroundVOP.h:81

BattlegroundWS
Definition BattlegroundWS.h:145

ByteBuffer
Definition ByteBuffer.h:120

ByteBuffer::WriteGuidBytes
void WriteGuidBytes(const ObjectGuid &guid, Offsets... offsets)
Definition ByteBuffer.h:264

ByteBuffer::WriteBit
bool WriteBit(uint32 bit)
Definition ByteBuffer.h:164

ByteBuffer::WriteGuidMask
void WriteGuidMask(const ObjectGuid &guid, Offsets... offsets)
Definition ByteBuffer.h:248

ByteBuffer::bitwpos
size_t bitwpos() const
Returns position of last written bit.
Definition ByteBuffer.h:492

ByteBuffer::append
void append(T value)
Definition ByteBuffer.h:147

ByteBuffer::PutBits
void PutBits(size_t pos, T value, uint32 bitCount)
Definition ByteBuffer.h:283

ByteBuffer::WriteBits
void WriteBits(T value, size_t bits)
Definition ByteBuffer.h:192

ByteBuffer::WriteByteSeq
void WriteByteSeq(uint8 b)
Definition ByteBuffer.h:227

ByteBuffer::FlushBits
void FlushBits()
Definition ByteBuffer.h:154

Field
Definition Field.h:16

Field::GetUInt8
uint8 GetUInt8() const
Definition Field.h:26

Field::GetUInt16
uint16 GetUInt16() const
Definition Field.h:69

Field::GetFloat
float GetFloat() const
Definition Field.h:177

Field::GetUInt32
uint32 GetUInt32() const
Definition Field.h:105

ObjectAccessor::FindPlayer
static Player * FindPlayer(uint64)
Definition ObjectAccessor.cpp:240

Object::GetGUID
uint64 GetGUID() const
Definition Object.h:119

Object::IsInWorld
bool IsInWorld() const
Definition Object.h:114

Player
Definition Player.h:1289

Player::GetBGTeam
uint32 GetBGTeam() const
Definition Player.cpp:17979

Player::GetBattlegroundQueueJoinTime
uint32 GetBattlegroundQueueJoinTime(BattlegroundTypeId bgTypeId) const
Definition Player.h:2707

Player::GetSession
WorldSession * GetSession() const
Definition Player.h:2417

Player::GetRandomWinner
bool GetRandomWinner() const
Definition Player.h:2757

Player::TeleportTo
bool TeleportTo(uint32 mapid, float x, float y, float z, float orientation, uint32 options=0)
Definition Player.cpp:2090

Unit::getLevel
uint8 getLevel() const
Definition Unit.h:1528

WorldObject::GetName
std::string const & GetName() const
Definition Object.h:664

WorldPacket
Definition WorldPacket.h:16

WorldPacket::Initialize
void Initialize(Opcodes opcode, size_t newres=200)
Definition WorldPacket.h:31

WorldSession::SendPacket
void SendPacket(WorldPacket const *packet, bool forced=false)
Send a packet to the client.
Definition WorldSession.cpp:196

WorldDatabase
WorldDatabaseWorkerPool WorldDatabase
Accessor to the world database.
Definition Main.cpp:40

SMSG_BATTLEFIELD_LIST
@ SMSG_BATTLEFIELD_LIST
Definition Opcodes.h:536

SMSG_BATTLEFIELD_STATUS_ACTIVE
@ SMSG_BATTLEFIELD_STATUS_ACTIVE
Definition Opcodes.h:545

SMSG_AREA_SPIRIT_HEALER_TIME
@ SMSG_AREA_SPIRIT_HEALER_TIME
Definition Opcodes.h:515

SMSG_BATTLEFIELD_STATUS
@ SMSG_BATTLEFIELD_STATUS
Definition Opcodes.h:544

SMSG_BATTLEFIELD_STATUS_NEEDCONFIRMATION
@ SMSG_BATTLEFIELD_STATUS_NEEDCONFIRMATION
Definition Opcodes.h:547

SMSG_UPDATE_WORLD_STATE
@ SMSG_UPDATE_WORLD_STATE
Definition Opcodes.h:1055

SMSG_PLAY_SOUND
@ SMSG_PLAY_SOUND
Definition Opcodes.h:883

SMSG_BATTLEFIELD_STATUS_QUEUED
@ SMSG_BATTLEFIELD_STATUS_QUEUED
Definition Opcodes.h:548

SMSG_PVP_LOG_DATA
@ SMSG_PVP_LOG_DATA
Definition Opcodes.h:892

SMSG_BATTLEGROUND_PLAYER_LEFT
@ SMSG_BATTLEGROUND_PLAYER_LEFT
Definition Opcodes.h:550

SMSG_BATTLEFIELD_STATUS_FAILED
@ SMSG_BATTLEFIELD_STATUS_FAILED
Definition Opcodes.h:546

SMSG_BATTLEGROUND_PLAYER_JOINED
@ SMSG_BATTLEGROUND_PLAYER_JOINED
Definition Opcodes.h:549

sWorld
#define sWorld
Definition World.h:910

WorldIntConfigs
WorldIntConfigs
Definition World.h:198

WorldIntConfigs::CONFIG_BG_REWARD_WINNER_HONOR_FIRST
@ CONFIG_BG_REWARD_WINNER_HONOR_FIRST
Definition World.h:355

WorldIntConfigs::CONFIG_ARENA_RATED_UPDATE_TIMER
@ CONFIG_ARENA_RATED_UPDATE_TIMER
Definition World.h:297

WorldIntConfigs::CONFIG_BG_REWARD_WINNER_HONOR_LAST
@ CONFIG_BG_REWARD_WINNER_HONOR_LAST
Definition World.h:356

WorldIntConfigs::CONFIG_BG_REWARD_WINNER_CONQUEST_LAST
@ CONFIG_BG_REWARD_WINNER_CONQUEST_LAST
Definition World.h:360

WorldIntConfigs::CONFIG_ARENA_RATING_DISCARD_TIMER
@ CONFIG_ARENA_RATING_DISCARD_TIMER
Definition World.h:296

WorldIntConfigs::CONFIG_BG_REWARD_LOSER_HONOR_FIRST
@ CONFIG_BG_REWARD_LOSER_HONOR_FIRST
Definition World.h:357

WorldIntConfigs::CONFIG_BG_REWARD_LOSER_HONOR_LAST
@ CONFIG_BG_REWARD_LOSER_HONOR_LAST
Definition World.h:358

WorldIntConfigs::CONFIG_BG_REWARD_WINNER_CONQUEST_FIRST
@ CONFIG_BG_REWARD_WINNER_CONQUEST_FIRST
Definition World.h:359

WorldIntConfigs::CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER
@ CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER
Definition World.h:293

WorldIntConfigs::CONFIG_ARENA_MAX_RATING_DIFFERENCE
@ CONFIG_ARENA_MAX_RATING_DIFFERENCE
Definition World.h:295

DisableMgr::IsDisabledFor
bool IsDisabledFor(DisableType type, uint32 entry, Unit const *unit, uint8 flags)
Definition DisableMgr.cpp:292

BattlegroundABScore
Definition BattlegroundAB.h:228

BattlegroundAVScore
Definition BattlegroundAV.h:1515

BattlegroundBFGScore
Definition BattlegroundBFG.h:200

BattlegroundData
Definition BattlegroundMgr.h:45

BattlegroundData::m_Battlegrounds
BattlegroundContainer m_Battlegrounds
Definition BattlegroundMgr.h:46

BattlegroundData::BGFreeSlotQueue
BGFreeSlotQueueContainer BGFreeSlotQueue
Definition BattlegroundMgr.h:48

BattlegroundEYScore
Definition BattlegroundEY.h:313

BattlegroundICScore
Definition BattlegroundIC.h:838

BattlegroundMgr::ScheduledQueueUpdate
Definition BattlegroundMgr.h:134

BattlegroundSAScore
Definition BattlegroundSA.h:13

BattlegroundScore
Definition Battleground.h:249

BattlegroundScore::KillingBlows
uint32 KillingBlows
Definition Battleground.h:256

BattlegroundScore::HealingDone
uint32 HealingDone
Definition Battleground.h:261

BattlegroundScore::Deaths
uint32 Deaths
Definition Battleground.h:257

BattlegroundScore::BonusHonor
uint32 BonusHonor
Definition Battleground.h:259

BattlegroundScore::HonorableKills
uint32 HonorableKills
Definition Battleground.h:258

BattlegroundScore::DamageDone
uint32 DamageDone
Definition Battleground.h:260

BattlegroundTPScore
Definition BattlegroundTP.h:148

BattlegroundVOPScore
Definition BattlegroundVOP.h:73

BattlegroundWGScore
Definition BattlegroundWS.h:137

BattlemasterListEntry
Definition DBCStructure.h:778

BattlemasterListEntry::mapid
int32 mapid[16]
Definition DBCStructure.h:780

BattlemasterListEntry::type
uint32 type
Definition DBCStructure.h:781

BattlemasterListEntry::name
char * name
Definition DBCStructure.h:783

CreateBattlegroundData
Definition BattlegroundMgr.h:23

CreateBattlegroundData::Team2StartLocZ
float Team2StartLocZ
Definition BattlegroundMgr.h:38

CreateBattlegroundData::IsArena
bool IsArena
Definition BattlegroundMgr.h:25

CreateBattlegroundData::Team1StartLocO
float Team1StartLocO
Definition BattlegroundMgr.h:35

CreateBattlegroundData::LevelMax
uint32 LevelMax
Definition BattlegroundMgr.h:29

CreateBattlegroundData::MaxPlayersPerTeam
uint32 MaxPlayersPerTeam
Definition BattlegroundMgr.h:27

CreateBattlegroundData::LevelMin
uint32 LevelMin
Definition BattlegroundMgr.h:28

CreateBattlegroundData::scriptId
uint32 scriptId
Definition BattlegroundMgr.h:41

CreateBattlegroundData::bgTypeId
BattlegroundTypeId bgTypeId
Definition BattlegroundMgr.h:24

CreateBattlegroundData::Team1StartLocZ
float Team1StartLocZ
Definition BattlegroundMgr.h:34

CreateBattlegroundData::Team1StartLocY
float Team1StartLocY
Definition BattlegroundMgr.h:33

CreateBattlegroundData::MinPlayersPerTeam
uint32 MinPlayersPerTeam
Definition BattlegroundMgr.h:26

CreateBattlegroundData::Team2StartLocX
float Team2StartLocX
Definition BattlegroundMgr.h:36

CreateBattlegroundData::MapID
uint32 MapID
Definition BattlegroundMgr.h:31

CreateBattlegroundData::StartMaxDist
float StartMaxDist
Definition BattlegroundMgr.h:40

CreateBattlegroundData::Team2StartLocO
float Team2StartLocO
Definition BattlegroundMgr.h:39

CreateBattlegroundData::Team2StartLocY
float Team2StartLocY
Definition BattlegroundMgr.h:37

CreateBattlegroundData::Team1StartLocX
float Team1StartLocX
Definition BattlegroundMgr.h:32

CreateBattlegroundData::BattlegroundName
char * BattlegroundName
Definition BattlegroundMgr.h:30

ObjectGuid
Definition ByteBuffer.h:66

PvPDifficultyEntry
Definition DBCStructure.h:2097

PvPDifficultyEntry::maxLevel
uint32 maxLevel
Definition DBCStructure.h:2102

PvPDifficultyEntry::GetBracketId
BattlegroundBracketId GetBracketId() const
Definition DBCStructure.h:2106

PvPDifficultyEntry::minLevel
uint32 minLevel
Definition DBCStructure.h:2101

WorldSafeLocsEntry
Definition DBCStructure.h:2977