自学教程：C++ EndBattleGround函数代码示例

void BattleGroundAV::HandleKillUnit(Creature *creature, Player *killer){    DEBUG_LOG("BattleGroundAV: HandleKillUnit %i", creature->GetEntry());    if (GetStatus() != STATUS_IN_PROGRESS)        return;    uint8 event1 = (sBattleGroundMgr.GetCreatureEventIndex(creature->GetGUIDLow())).event1;    if (event1 == BG_EVENT_NONE)        return;    switch(event1)    {        case BG_AV_BOSS_A:            CastSpellOnTeam(BG_AV_BOSS_KILL_QUEST_SPELL, HORDE);   // this is a spell which finishes a quest where a player has to kill the boss            RewardReputationToTeam(BG_AV_FACTION_H, m_RepBoss, HORDE);            RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_BOSS), HORDE);            SendYellToAll(LANG_BG_AV_A_GENERAL_DEAD, LANG_UNIVERSAL, GetSingleCreatureGuid(BG_AV_HERALD, 0));            EndBattleGround(HORDE);            break;        case BG_AV_BOSS_H:            CastSpellOnTeam(BG_AV_BOSS_KILL_QUEST_SPELL, ALLIANCE); // this is a spell which finishes a quest where a player has to kill the boss            RewardReputationToTeam(BG_AV_FACTION_A, m_RepBoss, ALLIANCE);            RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_BOSS), ALLIANCE);            SendYellToAll(LANG_BG_AV_H_GENERAL_DEAD, LANG_UNIVERSAL, GetSingleCreatureGuid(BG_AV_HERALD, 0));            EndBattleGround(ALLIANCE);            break;        case BG_AV_CAPTAIN_A:            if (IsActiveEvent(BG_AV_NodeEventCaptainDead_A, 0))                return;            RewardReputationToTeam(BG_AV_FACTION_H, m_RepCaptain, HORDE);            RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_CAPTAIN), HORDE);            UpdateScore(BG_TEAM_ALLIANCE, (-1) * BG_AV_RES_CAPTAIN);            // spawn destroyed aura            SpawnEvent(BG_AV_NodeEventCaptainDead_A, 0, true);            break;        case BG_AV_CAPTAIN_H:            if (IsActiveEvent(BG_AV_NodeEventCaptainDead_H, 0))                return;            RewardReputationToTeam(BG_AV_FACTION_A, m_RepCaptain, ALLIANCE);            RewardHonorToTeam(GetBonusHonorFromKill(BG_AV_KILL_CAPTAIN), ALLIANCE);            UpdateScore(BG_TEAM_HORDE, (-1) * BG_AV_RES_CAPTAIN);            // spawn destroyed aura            SpawnEvent(BG_AV_NodeEventCaptainDead_H, 0, true);            break;        case BG_AV_MINE_BOSSES_NORTH:            ChangeMineOwner(BG_AV_NORTH_MINE, GetAVTeamIndexByTeamId(killer->GetTeam()));            break;        case BG_AV_MINE_BOSSES_SOUTH:            ChangeMineOwner(BG_AV_SOUTH_MINE, GetAVTeamIndexByTeamId(killer->GetTeam()));            break;    }}

void BattleGroundEY::UpdateTeamScore(uint32 Team){    uint32 score = GetTeamScore(Team);    //TODO there should be some sound played when one team is near victory!! - and define variables    /*if (!m_IsInformedNearVictory && score >= BG_EY_WARNING_NEAR_VICTORY_SCORE)    {        if (Team == ALLIANCE)            SendMessageToAll(LANG_BG_EY_A_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);        else            SendMessageToAll(LANG_BG_EY_H_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);        PlaySoundToAll(BG_EY_SOUND_NEAR_VICTORY);        m_IsInformedNearVictory = true;    }*/    if (score >= BG_EY_MAX_TEAM_SCORE)    {        score = BG_EY_MAX_TEAM_SCORE;        EndBattleGround(Team);    }    if (Team == ALLIANCE)        UpdateWorldState(EY_ALLIANCE_RESOURCES, score);    else        UpdateWorldState(EY_HORDE_RESOURCES, score);}

void BattleGroundIC::HandleKillUnit(Creature *unit, Player *killer){    if (GetStatus() != STATUS_IN_PROGRESS)       return;    uint32 entry = unit->GetEntry();    if (entry == 34924)    {        RewardHonorToTeam(500,HORDE);        EndBattleGround(HORDE);    }    else if (entry == 34922)    {        RewardHonorToTeam(500,ALLIANCE);        EndBattleGround(ALLIANCE);    }}

void BattleGroundIC::HandleKillUnit(Creature *unit, Player *killer){    sLog.outDebug("bg_ic HandleKillUnit %i",unit->GetEntry());    if(GetStatus() != STATUS_IN_PROGRESS)        return;    uint32 entry = unit->GetEntry();    if(entry == BG_IC_StaticCreatureInfo[IC_NPC_A_BOSS][0])    {        RewardHonorToTeam(GetBonusHonor(BG_IC_KILL_BOSS),HORDE);        EndBattleGround(HORDE);    }	else if ( entry == BG_IC_StaticCreatureInfo[IC_NPC_H_BOSS][0] )    {        RewardHonorToTeam(GetBonusHonor(BG_IC_KILL_BOSS),ALLIANCE);        EndBattleGround(ALLIANCE);    }}

void BattleGroundAB::Update(time_t diff){    BattleGround::Update(diff);    //If BG-Status = WAIT_JOIN, we must start BG    if(GetStatus() == STATUS_WAIT_JOIN)    {    }    if(GetStatus() == STATUS_IN_PROGRESS)    {        for(int i = 0;i < 5; i++)            if(m_Points[i])                                 //If point is controled                AddPoint(m_Points[i], diff);        if(GetTeamScore(ALLIANCE) >= (2000*1000))           //1 score/per second            EndBattleGround(ALLIANCE);        if(GetTeamScore(HORDE) >= (2000*1000))              //1 score/per second            EndBattleGround(HORDE);    }}

void BattleGroundSA::EventPlayerUsedGO(Player* Source, GameObject* object){    if (object->GetEntry() == BG_SA_ObjEntries[BG_SA_TITAN_RELIC] && GateStatus[BG_SA_ANCIENT_GATE] == BG_SA_GATE_DESTROYED)    {        if (Source->GetTeamId() == attackers)        {            if (Source->GetTeamId() == ALLIANCE)                SendMessageToAll(LANG_BG_SA_ALLIANCE_CAPTURED_RELIC, CHAT_MSG_BG_SYSTEM_NEUTRAL);            else SendMessageToAll(LANG_BG_SA_HORDE_CAPTURED_RELIC, CHAT_MSG_BG_SYSTEM_NEUTRAL);            if (status == BG_SA_ROUND_ONE)            {                RoundScores[0].winner = attackers;                RoundScores[0].time = TotalTime;                attackers = (attackers == TEAM_ALLIANCE) ? TEAM_HORDE : TEAM_ALLIANCE;                status = BG_SA_SECOND_WARMUP;                TotalTime = 0;                ToggleTimer();                SendWarningToAll(LANG_BG_SA_ROUND_ONE_END);                UpdateWaitTimer = 5000;                SignaledRoundTwo = false;                SignaledRoundTwoHalfMin = false;                InitSecondRound = true;                ResetObjs();            }            else if (status == BG_SA_ROUND_TWO)            {                RoundScores[1].winner = attackers;                RoundScores[1].time = TotalTime;ToggleTimer();                if (RoundScores[0].time == RoundScores[1].time)                    EndBattleGround(NULL);                else if (RoundScores[0].time < RoundScores[1].time)                    EndBattleGround(RoundScores[0].winner == TEAM_ALLIANCE ? ALLIANCE : HORDE);                else                    EndBattleGround(RoundScores[1].winner == TEAM_ALLIANCE ? ALLIANCE : HORDE);            }        }    }}

void BattleGroundEY::UpdateTeamScore(uint32 Team){    uint32 score = GetTeamScore(Team);    if(score >= EY_MAX_TEAM_SCORE)    {        score = EY_MAX_TEAM_SCORE;        EndBattleGround(Team);    }    if(Team == ALLIANCE)        UpdateWorldState(EY_ALLIANCE_RESOURCES, score);    else        UpdateWorldState(EY_HORDE_RESOURCES, score);}

void BattleGroundBG::UpdateTeamScore(Team team){    uint32 score = GetTeamScore(team);    if (score >= BG_BG_MAX_TEAM_SCORE)    {        score = BG_BG_MAX_TEAM_SCORE;        EndBattleGround(team);    }    if (team == ALLIANCE)        UpdateWorldState(BG_ALLIANCE_RESOURCES, score);    else        UpdateWorldState(BG_HORDE_RESOURCES, score);}

void BattleGroundEY::UpdateTeamScore(Team team){    uint32 score = m_TeamScores[GetTeamIndexByTeamId(team)];    if (score >= EY_MAX_TEAM_SCORE)    {        score = EY_MAX_TEAM_SCORE;        EndBattleGround(team);    }    if (team == ALLIANCE)        UpdateWorldState(WORLD_STATE_EY_RESOURCES_ALLIANCE, score);    else        UpdateWorldState(WORLD_STATE_EY_RESOURCES_HORDE, score);}

void BattleGroundIC::UpdateScore(TeamIndex teamIdx, int32 points ){    // note: to remove reinforcements points must be negative, for adding reinforcements points must be positive    MANGOS_ASSERT( teamIdx == TEAM_INDEX_ALLIANCE || teamIdx == TEAM_INDEX_HORDE);    m_TeamScores[teamIdx] += points;                      // m_TeamScores is int32 - so no problems here    if (points < 0)    {        if (m_TeamScores[teamIdx] < 1)        {            m_TeamScores[teamIdx] = 0;            // other team will win:            EndBattleGround((teamIdx == TEAM_INDEX_ALLIANCE)? HORDE : ALLIANCE);        }    }    // must be called here, else it could display a negative value    UpdateWorldState(((teamIdx == TEAM_INDEX_HORDE) ? BG_TEAM_HORDE_REINFORC : BG_TEAM_ALLIANCE_REINFORC), m_TeamScores[teamIdx]);}

void BattleGroundNA::HandleKillPlayer(Player *player, Player *killer){    if(GetStatus() != STATUS_IN_PROGRESS)        return;    if(!killer)    {        sLog.outError("BattleGroundNA: Killer player not found");        return;    }    uint32 killer_team_index = GetTeamIndexByTeamId(killer->GetTeam());    ++m_TeamKills[killer_team_index];                       // add kills to killer's team    if(m_TeamKills[killer_team_index] >= GetPlayersCountByTeam(player->GetTeam()))    {        // all opponents killed        EndBattleGround(killer->GetTeam());    }}

void BattleGroundAV::UpdateScore(BattleGroundTeamIndex teamIdx, int32 points ){    // note: to remove reinforcements points must be negative, for adding reinforcements points must be positive    MANGOS_ASSERT( teamIdx == BG_TEAM_ALLIANCE || teamIdx == BG_TEAM_HORDE);    m_TeamScores[teamIdx] += points;                      // m_TeamScores is int32 - so no problems here    if (points < 0)    {        if (m_TeamScores[teamIdx] < 1)        {            m_TeamScores[teamIdx] = 0;            // other team will win:            EndBattleGround((teamIdx == BG_TEAM_ALLIANCE)? HORDE : ALLIANCE);        }        else if (!m_IsInformedNearLose[teamIdx] && m_TeamScores[teamIdx] < BG_AV_SCORE_NEAR_LOSE)        {            SendMessageToAll((teamIdx == BG_TEAM_HORDE) ? LANG_BG_AV_H_NEAR_LOSE : LANG_BG_AV_A_NEAR_LOSE, CHAT_MSG_BG_SYSTEM_NEUTRAL);            PlaySoundToAll(BG_AV_SOUND_NEAR_LOSE);            m_IsInformedNearLose[teamIdx] = true;        }    }    // must be called here, else it could display a negative value    UpdateWorldState(((teamIdx == BG_TEAM_HORDE) ? BG_AV_Horde_Score : BG_AV_Alliance_Score), m_TeamScores[teamIdx]);}

void BattleGroundSA::Update(uint32 diff){    BattleGround::Update(diff);    if (GetStatus() == STATUS_WAIT_JOIN && !shipsStarted)        if (Phase == SA_ROUND_ONE) // Round one not started yet            if (shipsTimer <= diff)                StartShips();            else                shipsTimer -= diff;    if (GetStatus() == STATUS_IN_PROGRESS) // Battleground already in progress    {        if (Round_timer >= BG_SA_ROUNDLENGTH)        {            if(Phase == SA_ROUND_ONE) // Timeout of second round            {                PlaySoundToAll(BG_SA_SOUND_GYD_VICTORY);                SendMessageToAll(defender == ALLIANCE ? LANG_BG_SA_ALLIANCE_TIMEOUT_END_1ROUND : LANG_BG_SA_HORDE_TIMEOUT_END_1ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                RoundScores[0].winner = GetDefender();                RoundScores[0].time = Round_timer;				ResetBattle(0, defender);            }            else // Timeout of second round            {                SendMessageToAll(defender == ALLIANCE ? LANG_BG_SA_ALLIANCE_TIMEOUT_END_2ROUND : LANG_BG_SA_HORDE_TIMEOUT_END_2ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                RoundScores[1].winner = GetDefender();                RoundScores[1].time = Round_timer;				EndBattleGround(TEAM_NONE);                return;            }        }         else            Round_timer += diff;        for (int gyd = 0; gyd < BG_SA_GRY_MAX; ++gyd)        {            // 3 sec delay to spawn new banner instead previous despawned one            if (m_BannerTimers[gyd].timer)            {                if (m_BannerTimers[gyd].timer > diff)                    m_BannerTimers[gyd].timer -= diff;                else                {                    m_BannerTimers[gyd].timer = 0;                    _CreateBanner(gyd, m_BannerTimers[gyd].type, m_BannerTimers[gyd].teamIndex, false);                }            }            // 1-minute to occupy a node from contested state            if (m_GydTimers[gyd])            {                if (m_GydTimers[gyd] > diff)                    m_GydTimers[gyd] -= diff;                else                {                    m_GydTimers[gyd] = 0;                    // Change from contested to occupied !                    uint8 teamIndex = m_Gyd[gyd]-1;                    m_prevGyd[gyd] = m_Gyd[gyd];                    m_Gyd[gyd] += 2;                    // create new occupied banner                    _CreateBanner(gyd, BG_SA_GARVE_TYPE_OCCUPIED, teamIndex, true);                    //_SendNodeUpdate(node);                    _GydOccupied(gyd,(teamIndex == 0) ? ALLIANCE:HORDE);                    // Message to chatlog                    RewardHonorToTeam(85, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardXpToTeam(0, 0.6f, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardReputationToTeam((teamIndex == 0) ? 1050:1085, 65, (teamIndex == 0) ? ALLIANCE:HORDE);                    switch(gyd)                    {                        case 0: SpawnEvent(SA_EVENT_ADD_VECH_W, 0, true);break;                        case 1: SpawnEvent(SA_EVENT_ADD_VECH_E, 0, true);break;                    }                    if (teamIndex == 0)                    {                        // SendMessage2ToAll(LANG_BG_SA_AH_SEIZES_GRAVEYARD,CHAT_MSG_BG_SYSTEM_ALLIANCE,NULL,LANG_BG_ALLY,_GydName(gyd));                        PlaySoundToAll(BG_SA_SOUND_GYD_CAPTURED_ALLIANCE);                        SendWarningToAllSA(gyd, STATUS_CONQUESTED, ALLIANCE);                    }                    else                    {                        // SendMessage2ToAll(LANG_BG_SA_AH_SEIZES_GRAVEYARD,CHAT_MSG_BG_SYSTEM_HORDE,NULL,LANG_BG_HORDE,_GydName(gyd));                        PlaySoundToAll(BG_SA_SOUND_GYD_CAPTURED_HORDE);                        SendWarningToAllSA(gyd, STATUS_CONQUESTED, HORDE);                    }                }            }        }        UpdateTimer();    }    if (GetStatus() == STATUS_WAIT_JOIN && Phase == SA_ROUND_TWO) // Round two, not yet started    {        if (!shipsStarted)            if (shipsTimer <= diff)            {                SendMessageToAll(LANG_BG_SA_START_ONE_MINUTE, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                StartShips();            }            else                shipsTimer -= diff;//.........这里部分代码省略.........

//.........这里部分代码省略.........                    break;                case 19042:                    SendWarningToAllSA(SA_EVENT_NONE, TEAM_NONE, true, type);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DAMAGE);                    break;                case 19047:                    SendWarningToAllSA(SA_EVENT_NONE, TEAM_NONE, true, type, true);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DESTROY);                    UpdatePlayerScore(player, SCORE_GATES_DESTROYED, 1);                    RewardHonorToTeam(85, (teamIndex == 0) ? ALLIANCE : HORDE);                    // make the central graveyard capturable                    MakeInteractive(SA_EVENT_ADD_GRAVE_C, (GetDefender() == ALLIANCE) ? BG_SA_GRAVE_STATUS_ALLY_CONTESTED : BG_SA_GRAVE_STATUS_HORDE_CONTESTED, true);                    SpawnEvent(SA_EVENT_ADD_RED_SIGIL, 0, false);                    break;            }            break;        }        case BG_SA_GO_GATES_YELLOW_MOON:        {            type = BG_SA_GO_GATES_T_YELLOW_MOON;            switch (eventId)            {                case 21630:                    if (!GateYellowMoonDamaged)                    {                        SendMessageSA(player, BG_SA_ATTACK, _GatesName(target_obj));                        GateYellowMoonDamaged = true;                    }                    break;                case 19044:                    SendWarningToAllSA(SA_EVENT_NONE, TEAM_NONE, true, type);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DAMAGE);                    break;                case 19049:                    SendWarningToAllSA(SA_EVENT_NONE, TEAM_NONE, true, type, true);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DESTROY);                    UpdatePlayerScore(player, SCORE_GATES_DESTROYED, 1);                    RewardHonorToTeam(85, (teamIndex == 0) ? ALLIANCE : HORDE);                    SpawnEvent(SA_EVENT_ADD_YELLOW_SIGIL, 0, false);                    break;            }            break;        }        case BG_SA_GO_TITAN_RELIC_A:        case BG_SA_GO_TITAN_RELIC_H:        {            if (eventId == 20572 && player->GetTeam() != GetDefender())            {                if (!relicGateDestroyed)                {                    player->GetSession()->KickPlayer();                    sLog.outError("Player %s has clicked SOTA Relic without Relic gate being destroyed", player->GetName());                    return;                }                //Achievement Storm the Beach (1310)                for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                {                    Player* plr = sObjectMgr.GetPlayer(itr->first);                    if (plr)                    {                        if (plr->GetTeam() != defender)                            plr->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, BG_SA_STORM_THE_BEACH);                    }                }                if (Phase == SA_ROUND_ONE) // Victory at first round                {                    RoundScores[0].winner = GetDefender() == ALLIANCE ? HORDE : ALLIANCE;                    RoundScores[0].time = Round_timer;                    PlaySoundToAll(BG_SA_SOUND_GYD_VICTORY);                    SendMessageToAll(defender == HORDE ? LANG_BG_SA_ALLIANCE_END_1ROUND : LANG_BG_SA_HORDE_END_1ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                    SendWarningToAll(LANG_BG_SA_END_1ROUND);                    RewardHonorToTeam(150, (teamIndex == 0) ? ALLIANCE : HORDE);                    for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                    {                        if (Player* plr = sObjectMgr.GetPlayer(itr->first))                        {                            plr->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, BG_SA_STORM_THE_BEACH);                        }                    }                    ResetBattle(player->GetTeam(), GetDefender());                }                else // Victory at second round                {                    RoundScores[1].winner = GetDefender() == ALLIANCE ? HORDE : ALLIANCE;                    SendMessageToAll(defender == HORDE ? LANG_BG_SA_ALLIANCE_END_2ROUND : LANG_BG_SA_HORDE_END_2ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                    RewardHonorToTeam(150, (teamIndex == 0) ? ALLIANCE : HORDE);                    for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                    {                        if (Player* plr = sObjectMgr.GetPlayer(itr->first))                        {                            plr->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, BG_SA_STORM_THE_BEACH);                        }                    }                    EndBattleGround(player->GetTeam());                }            }            break;        }    }}

void BattleGroundSA::Update(uint32 diff){    BattleGround::Update(diff);    if (GetStatus() == STATUS_WAIT_JOIN && !shipsStarted)        if (Phase == SA_ROUND_ONE) // Round one not started yet        {            if (shipsTimer <= diff)                StartShips();            else                shipsTimer -= diff;        }    if (GetStatus() == STATUS_IN_PROGRESS) // Battleground already in progress    {        if (Round_timer >= BG_SA_ROUNDLENGTH)        {            if (Phase == SA_ROUND_ONE) // Timeout of first round            {                PlaySoundToAll(BG_SA_SOUND_GYD_VICTORY);                SendMessageToAll(defender == ALLIANCE ? LANG_BG_SA_ALLIANCE_TIMEOUT_END_1ROUND : LANG_BG_SA_HORDE_TIMEOUT_END_1ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                SendWarningToAll(LANG_BG_SA_END_1ROUND);                RoundScores[0].winner = GetDefender();                RoundScores[0].time = BG_SA_ROUNDLENGTH;                for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                {                    Player* plr = sObjectMgr.GetPlayer(itr->first);                    if (plr)                        plr->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, BG_SA_END_OF_ROUND);                }                ResetBattle(0, defender);            }            else // Timeout of second round            {                SendMessageToAll(defender == ALLIANCE ? LANG_BG_SA_ALLIANCE_TIMEOUT_END_2ROUND : LANG_BG_SA_HORDE_TIMEOUT_END_2ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                RoundScores[1].winner = GetDefender();                for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                {                    Player* plr = sObjectMgr.GetPlayer(itr->first);                    if (plr)                        plr->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, BG_SA_END_OF_ROUND);                }                if (RoundScores[0].winner == GetDefender())                    EndBattleGround(GetDefender());                else                    EndBattleGround(TEAM_NONE);                return;            }        }        else            Round_timer += diff;        for (int gyd = 0; gyd < BG_SA_GRY_MAX; ++gyd)        {            // 3 sec delay to spawn new banner instead previous despawned one            if (m_BannerTimers[gyd].timer)            {                if (m_BannerTimers[gyd].timer > diff)                    m_BannerTimers[gyd].timer -= diff;                else                {                    m_BannerTimers[gyd].timer = 0;                    _CreateBanner(gyd, m_BannerTimers[gyd].type, m_BannerTimers[gyd].teamIndex, false);                }            }        }        UpdateTimer();    }    if (GetStatus() == STATUS_WAIT_JOIN && Phase == SA_ROUND_TWO) // Round two, not yet started    {        if (!shipsStarted)        {            if (shipsTimer <= diff)            {                SendMessageToAll(LANG_BG_SA_START_ONE_MINUTE, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                StartShips();            }            else                shipsTimer -= diff;        }        if (TimeST2Round < diff)        {            Phase = SA_ROUND_TWO;            SpawnEvent(SA_EVENT_ADD_NPC, 0, true);            SpawnEvent(SA_EVENT_ADD_BOMB_B, (GetDefender() == ALLIANCE ? BG_SA_GRAVE_STATUS_HORDE_OCCUPIED : BG_SA_GRAVE_STATUS_ALLY_OCCUPIED), true);            ToggleTimer();            SetStatus(STATUS_IN_PROGRESS); // Start round two            PlaySoundToAll(SOUND_BG_START);            SendWarningToAll(LANG_BG_SA_HAS_BEGUN);            for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)            {                Player* plr = sObjectMgr.GetPlayer(itr->first);                if (plr)//.........这里部分代码省略.........

void BattleGround::Update(uint32 diff){    if (!GetPlayersSize() && !GetRemovedPlayersSize())        //BG is empty        return;    WorldPacket data;    if(GetRemovedPlayersSize())    {        for(std::map<uint64, uint8>::iterator itr = m_RemovedPlayers.begin(); itr != m_RemovedPlayers.end(); ++itr)        {            Player *plr = sObjectMgr.GetPlayer(itr->first);            switch(itr->second)            {                //following code is handled by event:                /*case 0:                    sBattleGroundMgr.m_BattleGroundQueues[GetTypeID()].RemovePlayer(itr->first);                    //RemovePlayerFromQueue(itr->first);                    if(plr)                    {                        sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetTeam(), plr->GetBattleGroundQueueIndex(m_TypeID), STATUS_NONE, 0, 0);                        plr->GetSession()->SendPacket(&data);                    }                    break;*/                case 1:                                     // currently in bg and was removed from bg                    if(plr)                        RemovePlayerAtLeave(itr->first, true, true);                    else                        RemovePlayerAtLeave(itr->first, false, false);                    break;                default:                    sLog.outError("BattleGround: Unknown remove player case!");            }        }        m_RemovedPlayers.clear();    }    // this code isn't efficient and its idea isn't implemented yet    /* offline players are removed from battleground in worldsession::LogoutPlayer()    // remove offline players from bg after ~5 minutes    if(GetPlayersSize())    {        for(std::map<uint64, BattleGroundPlayer>::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)        {            Player *plr = objmgr.GetPlayer(itr->first);            itr->second.LastOnlineTime += diff;            if(plr)                itr->second.LastOnlineTime = 0;   // update last online time            else                if(itr->second.LastOnlineTime >= MAX_OFFLINE_TIME)                   // 5 minutes                    m_RemovedPlayers[itr->first] = 1;       // add to remove list (BG)        }    }*/    /*********************************************************/    /***           BATTLEGROUND BALLANCE SYSTEM            ***/    /*********************************************************/    // if less then minimum players are in on one side, then start premature finish timer    if(GetStatus() == STATUS_IN_PROGRESS && sBattleGroundMgr.GetPrematureFinishTime() && (GetPlayersCountByTeam(ALLIANCE) < GetMinPlayersPerTeam() || GetPlayersCountByTeam(HORDE) < GetMinPlayersPerTeam()))    {        if(!m_PrematureCountDown)        {            m_PrematureCountDown = true;            m_PrematureCountDownTimer = sBattleGroundMgr.GetPrematureFinishTime();            SendMessageToAll(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING);        }        else if(m_PrematureCountDownTimer < diff)        {            // time's up!            EndBattleGround(0); // noone wins            m_PrematureCountDown = false;        }        else if (!sBattleGroundMgr.isTesting())        {            uint32 newtime = m_PrematureCountDownTimer - diff;            // announce every minute            if (m_PrematureCountDownTimer != sBattleGroundMgr.GetPrematureFinishTime() &&                newtime / (MINUTE * IN_MILLISECONDS) != m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS))                SendMessageToAll(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING);            m_PrematureCountDownTimer = newtime;        }    }    else if (m_PrematureCountDown)        m_PrematureCountDown = false;    /*********************************************************/    /***           BATTLEGROUND ENDING SYSTEM              ***/    /*********************************************************/    if (GetStatus() == STATUS_WAIT_LEAVE)    {        // remove all players from battleground after 2 minutes        m_EndTime += diff;        if(m_EndTime >= TIME_TO_AUTOREMOVE)                 // 2 minutes        {            for(std::map<uint64, BattleGroundPlayer>::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)//.........这里部分代码省略.........

//.........这里部分代码省略.........        int team_points[2] = { 0, 0 };        for (int node = 0; node < BG_AB_DYNAMIC_NODES_COUNT; ++node)        {            // 3 sec delay to spawn new banner instead previous despawned one            if (m_BannerTimers[node].timer )            {                if (m_BannerTimers[node].timer > diff )                    m_BannerTimers[node].timer -= diff;                else                {                    m_BannerTimers[node].timer = 0;                    _CreateBanner(node, m_BannerTimers[node].type, m_BannerTimers[node].teamIndex, false);                }            }            // 1-minute to occupy a node from contested state            if (m_NodeTimers[node] )            {                if (m_NodeTimers[node] > diff )                    m_NodeTimers[node] -= diff;                else                {                    m_NodeTimers[node] = 0;                    // Change from contested to occupied !                    uint8 teamIndex = m_Nodes[node]-1;                    m_prevNodes[node] = m_Nodes[node];                    m_Nodes[node] += 2;                    // burn current contested banner                    _DelBanner(node, BG_AB_NODE_TYPE_CONTESTED, teamIndex);                    // create new occupied banner                    _CreateBanner(node, BG_AB_NODE_TYPE_OCCUPIED, teamIndex, true);                    _SendNodeUpdate(node);                    _NodeOccupied(node,(teamIndex == 0) ? ALLIANCE:HORDE);                    // Message to chatlog                    char buf[256];                    uint8 type = (teamIndex == 0) ? CHAT_MSG_BG_SYSTEM_ALLIANCE : CHAT_MSG_BG_SYSTEM_HORDE;                    sprintf(buf, GetNeoString(LANG_BG_AB_NODE_TAKEN), (teamIndex == 0) ? GetNeoString(LANG_BG_AB_ALLY) : GetNeoString(LANG_BG_AB_HORDE), _GetNodeName(node));                    WorldPacket data;                    ChatHandler::FillMessageData(&data, NULL, type, LANG_UNIVERSAL, NULL, 0, buf, NULL);                    SendPacketToAll(&data);                    PlaySoundToAll((teamIndex == 0) ? SOUND_NODE_CAPTURED_ALLIANCE : SOUND_NODE_CAPTURED_HORDE);                }            }            for (int team = 0; team < 2; ++team)                if (m_Nodes[node] == team + BG_AB_NODE_TYPE_OCCUPIED )                    ++team_points[team];        }        // Accumulate points        for (int team = 0; team < 2; ++team)        {            int points = team_points[team];            if (!points )                continue;            m_lastTick[team] += diff;            if (m_lastTick[team] > BG_AB_TickIntervals[points] )            {                m_lastTick[team] -= BG_AB_TickIntervals[points];                m_TeamScores[team] += BG_AB_TickPoints[points];        m_score[team] = m_TeamScores[team];                m_HonorScoreTics[team] += BG_AB_TickPoints[points];                m_ReputationScoreTics[team] += BG_AB_TickPoints[points];                if (m_ReputationScoreTics[team] >= BG_AB_ReputationScoreTicks[m_HonorMode] )                {                    (team == BG_TEAM_ALLIANCE) ? RewardReputationToTeam(509, 10, ALLIANCE) : RewardReputationToTeam(510, 10, HORDE);                    m_ReputationScoreTics[team] -= BG_AB_ReputationScoreTicks[m_HonorMode];                }                if (m_HonorScoreTics[team] >= BG_AB_HonorScoreTicks[m_HonorMode] )                {                    (team == BG_TEAM_ALLIANCE) ? RewardHonorToTeam(20, ALLIANCE) : RewardHonorToTeam(20, HORDE);                    m_HonorScoreTics[team] -= BG_AB_HonorScoreTicks[m_HonorMode];                }                if (!m_IsInformedNearVictory && m_TeamScores[team] > 1800 )                {                    if (team == BG_TEAM_ALLIANCE )                        SendMessageToAll(GetNeoString(LANG_BG_AB_A_NEAR_VICTORY));                    else                        SendMessageToAll(GetNeoString(LANG_BG_AB_H_NEAR_VICTORY));                    PlaySoundToAll(SOUND_NEAR_VICTORY);                    m_IsInformedNearVictory = true;                }                if (m_TeamScores[team] > 2000 )                    m_TeamScores[team] = 2000;                if (team == BG_TEAM_ALLIANCE )                    UpdateWorldState(BG_AB_OP_RESOURCES_ALLY, m_TeamScores[team]);                if (team == BG_TEAM_HORDE )                    UpdateWorldState(BG_AB_OP_RESOURCES_HORDE, m_TeamScores[team]);            }        }        // Test win condition        if (m_TeamScores[BG_TEAM_ALLIANCE] >= 2000 )            EndBattleGround(ALLIANCE);        if (m_TeamScores[BG_TEAM_HORDE] >= 2000 )            EndBattleGround(HORDE);    }}

void BattleGroundWS::EventPlayerCapturedFlag(Player *Source){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    uint8 type = 0;    uint32 winner = 0;    const char *message = "";    //TODO FIX reputation and honor gains for low level players!    Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);    if (Source->GetBGTeam() == ALLIANCE)    {        if (!this->IsHordeFlagPickedup())            return;        SetHordeFlagPicker(0);                              // must be before aura remove to prevent 2 events (drop+capture) at the same time                                                            // horde flag in base (but not respawned yet)        m_FlagState[BG_TEAM_HORDE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Horde Flag from Player        Source->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);        if (m_FlagDebuffState == 1)          Source->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);        if (m_FlagDebuffState == 2)          Source->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);        message = GetTrinityString(LANG_BG_WS_CAPTURED_HF);        type = CHAT_MSG_BG_SYSTEM_ALLIANCE;        if (GetTeamScore(ALLIANCE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(ALLIANCE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);        RewardReputationToTeam(890, BG_WSG_Reputation[m_HonorMode][BG_WSG_FLAG_CAP], ALLIANCE);          // +35 reputation        RewardHonorToTeam(BG_WSG_Honor[m_HonorMode][BG_WSG_FLAG_CAP], ALLIANCE);                    // +40 bonushonor    }    else    {        if (!this->IsAllianceFlagPickedup())            return;        SetAllianceFlagPicker(0);                           // must be before aura remove to prevent 2 events (drop+capture) at the same time                                                            // alliance flag in base (but not respawned yet)        m_FlagState[BG_TEAM_ALLIANCE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Alliance Flag from Player        Source->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);        if (m_FlagDebuffState == 1)          Source->RemoveAurasDueToSpell(WS_SPELL_FOCUSED_ASSAULT);        if (m_FlagDebuffState == 2)          Source->RemoveAurasDueToSpell(WS_SPELL_BRUTAL_ASSAULT);        message = GetTrinityString(LANG_BG_WS_CAPTURED_AF);        type = CHAT_MSG_BG_SYSTEM_HORDE;        if (GetTeamScore(HORDE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(HORDE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);        RewardReputationToTeam(889, BG_WSG_Reputation[m_HonorMode][BG_WSG_FLAG_CAP], HORDE);             // +35 reputation        RewardHonorToTeam(BG_WSG_Honor[m_HonorMode][BG_WSG_FLAG_CAP], HORDE);                       // +40 bonushonor    }    SpawnBGObject(BG_WS_OBJECT_H_FLAG, BG_WS_FLAG_RESPAWN_TIME);    SpawnBGObject(BG_WS_OBJECT_A_FLAG, BG_WS_FLAG_RESPAWN_TIME);    WorldPacket data;    ChatHandler::FillMessageData(&data, Source->GetSession(), type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);    SendPacketToAll(&data);    UpdateFlagState(Source->GetBGTeam(), 1);                  // flag state none    UpdateTeamScore(Source->GetBGTeam());    // only flag capture should be updated    UpdatePlayerScore(Source, SCORE_FLAG_CAPTURES, 1);      // +1 flag captures...    if (GetTeamScore(ALLIANCE) == BG_WS_MAX_TEAM_SCORE)        winner = ALLIANCE;    if (GetTeamScore(HORDE) == BG_WS_MAX_TEAM_SCORE)        winner = HORDE;    if (winner)    {        UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 0);        UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 0);        UpdateWorldState(BG_WS_FLAG_STATE_ALLIANCE, 1);        UpdateWorldState(BG_WS_FLAG_STATE_HORDE, 1);        RewardHonorToTeam(BG_WSG_Honor[m_HonorMode][BG_WSG_WIN], winner);        EndBattleGround(winner);    }    else    {        m_FlagsTimer[GetTeamIndexByTeamId(Source->GetBGTeam()) ? 0 : 1] = BG_WS_FLAG_RESPAWN_TIME;    }}

void BattleGroundWS::EventPlayerCapturedFlag(Player *Source){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    m_LastCapturedFlagTeam = Source->GetTeam();    uint32 winner = 0;    Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);    if (Source->HasAura(BG_WS_SPELL_FOCUSED_ASSAULT))        Source->RemoveAurasDueToSpell(BG_WS_SPELL_FOCUSED_ASSAULT);    if (Source->HasAura(BG_WS_SPELL_BRUTAL_ASSAULT))        Source->RemoveAurasDueToSpell(BG_WS_SPELL_BRUTAL_ASSAULT);    if (Source->GetTeam() == ALLIANCE)    {        if (!IsHordeFlagPickedup())            return;        SetHordeFlagPicker(0);                              // must be before aura remove to prevent 2 events (drop+capture) at the same time                                                            // horde flag in base (but not respawned yet)        m_FlagState[BG_TEAM_HORDE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Horde Flag from Player        Source->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);        if (GetTeamScore(ALLIANCE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(ALLIANCE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);        RewardReputationToTeam(BATTLEGROUND_WS, m_ReputationCapture, ALLIANCE);    }    else    {        if (!IsAllianceFlagPickedup())            return;        SetAllianceFlagPicker(0);                           // must be before aura remove to prevent 2 events (drop+capture) at the same time                                                            // alliance flag in base (but not respawned yet)        m_FlagState[BG_TEAM_ALLIANCE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Alliance Flag from Player        Source->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);        if (GetTeamScore(HORDE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(HORDE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);        RewardReputationToTeam(BATTLEGROUND_WS, m_ReputationCapture, HORDE);    }    //for flag capture is reward 2 honorable kills    RewardHonorToTeam(GetBonusHonorFromKill(sWorld.getConfig(CONFIG_UINT32_BONUS_HONOR_FLAG_WSG)), Source->GetTeam());    RewardXpToTeam(0, 0.6f, Source->GetTeam());    //flag carrier gets another 2 honorable kills    Source->RewardHonor(NULL, 0, GetBonusHonorFromKill(sWorld.getConfig(CONFIG_UINT32_BONUS_HONOR_FLAG_WSG)));    // despawn flags    SpawnEvent(WS_EVENT_FLAG_A, 0, false);    SpawnEvent(WS_EVENT_FLAG_H, 0, false);    if (Source->GetTeam() == ALLIANCE)        SendMessageToAll(LANG_BG_WS_CAPTURED_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, Source);    else        SendMessageToAll(LANG_BG_WS_CAPTURED_AF, CHAT_MSG_BG_SYSTEM_HORDE, Source);    UpdateFlagState(Source->GetTeam(), 1);                  // flag state none    UpdateTeamScore(Source->GetTeam());    // only flag capture should be updated    UpdatePlayerScore(Source, SCORE_FLAG_CAPTURES, 1);      // +1 flag captures    Source->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BG_OBJECTIVE_CAPTURE,1);    if (GetTeamScore(ALLIANCE) == BG_WS_MAX_TEAM_SCORE)        winner = ALLIANCE;    if (GetTeamScore(HORDE) == BG_WS_MAX_TEAM_SCORE)        winner = HORDE;    if (winner)    {        UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 0);        UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 0);        UpdateWorldState(BG_WS_FLAG_STATE_ALLIANCE, 1);        UpdateWorldState(BG_WS_FLAG_STATE_HORDE, 1);        EndBattleGround(winner);    }    else    {        m_FlagsTimer[GetTeamIndexByTeamId(Source->GetTeam()) ? 0 : 1] = BG_WS_FLAG_RESPAWN_TIME;    }}

void BattleGroundWS::Update(uint32 diff){    BattleGround::Update(diff);    if (GetStatus() == STATUS_IN_PROGRESS)    {        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)        {            m_FlagsTimer[BG_TEAM_ALLIANCE] -= diff;            if (m_FlagsTimer[BG_TEAM_ALLIANCE] < 0)            {                m_FlagsTimer[BG_TEAM_ALLIANCE] = 0;                RespawnFlag(ALLIANCE, true);            }        }        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)        {            m_FlagsDropTimer[BG_TEAM_ALLIANCE] -= diff;            if (m_FlagsDropTimer[BG_TEAM_ALLIANCE] < 0)            {                m_FlagsDropTimer[BG_TEAM_ALLIANCE] = 0;                RespawnFlagAfterDrop(ALLIANCE);            }        }        if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)        {            m_FlagsTimer[BG_TEAM_HORDE] -= diff;            if (m_FlagsTimer[BG_TEAM_HORDE] < 0)            {                m_FlagsTimer[BG_TEAM_HORDE] = 0;                RespawnFlag(HORDE, true);            }        }        if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_ON_GROUND)        {            m_FlagsDropTimer[BG_TEAM_HORDE] -= diff;            if (m_FlagsDropTimer[BG_TEAM_HORDE] < 0)            {                m_FlagsDropTimer[BG_TEAM_HORDE] = 0;                RespawnFlagAfterDrop(HORDE);            }        }        if (m_EndTimer > 0)        {            m_EndTimer -= diff;            if(GetEndTimeMinutes() != m_LastEndTimeMinutes)            {                m_LastEndTimeMinutes = GetEndTimeMinutes();                UpdateWorldState(BG_WS_TIME_REMAINING, m_LastEndTimeMinutes);            }        }        else        {            uint32 h = GetTeamScore(HORDE);            uint32 a = GetTeamScore(ALLIANCE);            if(h || a)            {                if(h > a)                    EndBattleGround(HORDE);                else if(a > h)                    EndBattleGround(ALLIANCE);                else                    EndBattleGround(m_LastCapturedFlagTeam);            }            else                // tie                EndBattleGround(0);        }    }}

void BattleGroundBE::Update(uint32 diff){    BattleGround::Update(diff);    // after bg start we get there    if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize())    {        ModifyStartDelayTime(diff);        if (!(m_Events & 0x01))        {            m_Events |= 0x01;            // setup here, only when at least one player has ported to the map            if(!SetupBattleGround())            {                EndNow();                return;            }            for(uint32 i = BG_BE_OBJECT_DOOR_1; i <= BG_BE_OBJECT_DOOR_4; i++)                SpawnBGObject(i, RESPAWN_IMMEDIATELY);            for(uint32 i = BG_BE_OBJECT_BUFF_1; i <= BG_BE_OBJECT_BUFF_2; i++)                SpawnBGObject(i, RESPAWN_ONE_DAY);            SetStartDelayTime(START_DELAY1);            SendMessageToAll(LANG_ARENA_ONE_MINUTE);        }        // After 30 seconds, warning is signalled        else if (GetStartDelayTime() <= START_DELAY2 && !(m_Events & 0x04))        {            m_Events |= 0x04;            SendMessageToAll(LANG_ARENA_THIRTY_SECONDS);        }        // After 15 seconds, warning is signalled        else if (GetStartDelayTime() <= START_DELAY3 && !(m_Events & 0x08))        {            m_Events |= 0x08;            SendMessageToAll(LANG_ARENA_FIFTEEN_SECONDS);        }        // delay expired (1 minute)        else if (GetStartDelayTime() <= 0 && !(m_Events & 0x10))        {            m_Events |= 0x10;            for(uint32 i = BG_BE_OBJECT_DOOR_1; i <= BG_BE_OBJECT_DOOR_2; i++)                DoorOpen(i);            for(uint32 i = BG_BE_OBJECT_BUFF_1; i <= BG_BE_OBJECT_BUFF_2; i++)                SpawnBGObject(i, 60);            SendMessageToAll(LANG_ARENA_BEGUN);            SetStatus(STATUS_IN_PROGRESS);            SetStartDelayTime(0);            for(BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)                if(Player *plr = objmgr.GetPlayer(itr->first))                    plr->RemoveAurasDueToSpell(SPELL_ARENA_PREPARATION);            if(!GetPlayersCountByTeam(ALLIANCE) && GetPlayersCountByTeam(HORDE))                EndBattleGround(HORDE);            else if(GetPlayersCountByTeam(ALLIANCE) && !GetPlayersCountByTeam(HORDE))                EndBattleGround(ALLIANCE);        }    }    /*if(GetStatus() == STATUS_IN_PROGRESS)    {        // update something    }*/}

//.........这里部分代码省略.........                    SendMessageSA(player, BG_SA_ATTACK, _GatesName(target_obj));                    break;                case 19043:                    // SendMessageSA(player, BG_SA_DAMAGE, _GatesName(target_obj));                    SendWarningToAllSA(NULL, NULL, TEAM_NONE, true, type);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DAMAGE);                    break;                case 19048:                    // SendMessageSA(player, BG_SA_DESTROY, _GatesName(target_obj));                    SendWarningToAllSA(NULL, NULL, TEAM_NONE, true, type, true);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DESTROY);                    UpdatePlayerScore(player, SCORE_GATES_DESTROYED, 1);                    RewardHonorToTeam(85, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardReputationToTeam((teamIndex == 0) ? 1050:1085, 65, (teamIndex == 0) ? ALLIANCE:HORDE);                    break;            }            break;        }        case BG_SA_GO_GATES_RED_SUN:        {            type = BG_SA_GO_GATES_T_RED_SUN;            switch (eventId)            {                case 21630:                    SendMessageSA(player, BG_SA_ATTACK, _GatesName(target_obj));                    break;                case 19042:                    // SendMessageSA(player, BG_SA_DAMAGE, _GatesName(target_obj));                    SendWarningToAllSA(NULL, NULL, TEAM_NONE, true, type);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DAMAGE);                    break;                case 19047:                    // SendMessageSA(player, BG_SA_DESTROY, _GatesName(target_obj));                    SendWarningToAllSA(NULL, NULL, TEAM_NONE, true, type, true);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DESTROY);                    UpdatePlayerScore(player, SCORE_GATES_DESTROYED, 1);                    RewardHonorToTeam(85, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardReputationToTeam((teamIndex == 0) ? 1050:1085, 65, (teamIndex == 0) ? ALLIANCE:HORDE);                    break;            }            break;        }        case BG_SA_GO_GATES_YELLOW_MOON:        {            type = BG_SA_GO_GATES_T_YELLOW_MOON;            switch (eventId)            {                case 21630:                    SendMessageSA(player, BG_SA_ATTACK, _GatesName(target_obj));                    break;                case 19044:                    // SendMessageSA(player, BG_SA_DAMAGE, _GatesName(target_obj));                    SendWarningToAllSA(NULL, NULL, TEAM_NONE, true, type);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DAMAGE);                    break;                case 19049:                    // SendMessageSA(player, BG_SA_DESTROY, _GatesName(target_obj));                    SendWarningToAllSA(NULL, NULL, TEAM_NONE, true, type, true);                    UpdateWorldState(BG_SA_GateStatus[type], GateStatus[type] = BG_SA_GO_GATES_DESTROY);                    UpdatePlayerScore(player, SCORE_GATES_DESTROYED, 1);                    RewardHonorToTeam(85, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardReputationToTeam((teamIndex == 0) ? 1050:1085, 65, (teamIndex == 0) ? ALLIANCE:HORDE);                    break;            }            break;        }        case BG_SA_GO_TITAN_RELIC:        {            if (eventId == 22097 && player->GetTeam() != GetDefender())            {                if(!relicGateDestroyed)                {                    player->GetSession()->KickPlayer();                    sLog.outError("Player %s has clicked SOTA Relic without Relic gate being destroyed", player->GetName());                    return;                }                if(Phase == SA_ROUND_ONE) // Victory at first round                {                    RoundScores[0].winner = GetDefender() == ALLIANCE ? HORDE : ALLIANCE;                    RoundScores[0].time = Round_timer;                    PlaySoundToAll(BG_SA_SOUND_GYD_VICTORY);                    SendMessageToAll(defender == HORDE ? LANG_BG_SA_ALLIANCE_END_1ROUND : LANG_BG_SA_HORDE_END_1ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                    RewardHonorToTeam(150, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardReputationToTeam((teamIndex == 0) ? 1050:1085, 100, (teamIndex == 0) ? ALLIANCE:HORDE);                    ResetBattle(player->GetTeam(), GetDefender());                }                else // Victory at second round                {                    RoundScores[1].winner = GetDefender() == ALLIANCE ? HORDE : ALLIANCE;                    RoundScores[1].time = Round_timer;                    SendMessageToAll(defender == HORDE ? LANG_BG_SA_ALLIANCE_END_2ROUND : LANG_BG_SA_HORDE_END_2ROUND, CHAT_MSG_BG_SYSTEM_NEUTRAL, NULL);                    RewardHonorToTeam(150, (teamIndex == 0) ? ALLIANCE:HORDE);                    RewardReputationToTeam((teamIndex == 0) ? 1050:1085, 100, (teamIndex == 0) ? ALLIANCE:HORDE);                    EndBattleGround(player->GetTeam());                }            }            break;        }    }}

//.........这里部分代码省略.........        for (uint8 node = 0; node < BG_AB_NODES_MAX; ++node)        {            // 3 sec delay to spawn new banner instead previous despawned one            if (m_BannerTimers[node].timer)            {                if (m_BannerTimers[node].timer > diff)                    m_BannerTimers[node].timer -= diff;                else                {                    m_BannerTimers[node].timer = 0;                    _CreateBanner(node, m_BannerTimers[node].type, m_BannerTimers[node].teamIndex, false);                }            }            // 1-minute to occupy a node from contested state            if (m_NodeTimers[node])            {                if (m_NodeTimers[node] > diff)                    m_NodeTimers[node] -= diff;                else                {                    m_NodeTimers[node] = 0;                    // Change from contested to occupied !                    uint8 teamIndex = m_Nodes[node] - 1;                    m_prevNodes[node] = m_Nodes[node];                    m_Nodes[node] += 2;                    // create new occupied banner                    _CreateBanner(node, BG_AB_NODE_TYPE_OCCUPIED, teamIndex, true);                    _SendNodeUpdate(node);                    _NodeOccupied(node, (teamIndex == 0) ? ALLIANCE : HORDE);                    // Message to chatlog                    if (teamIndex == 0)                    {                        SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, CHAT_MSG_BG_SYSTEM_ALLIANCE, NULL, LANG_BG_ALLY, _GetNodeNameId(node));                        PlaySoundToAll(BG_AB_SOUND_NODE_CAPTURED_ALLIANCE);                    }                    else                    {                        SendMessage2ToAll(LANG_BG_AB_NODE_TAKEN, CHAT_MSG_BG_SYSTEM_HORDE, NULL, LANG_BG_HORDE, _GetNodeNameId(node));                        PlaySoundToAll(BG_AB_SOUND_NODE_CAPTURED_HORDE);                    }                }            }            for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)                if (m_Nodes[node] == team + BG_AB_NODE_TYPE_OCCUPIED)                    ++team_points[team];        }        // Accumulate points        for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)        {            int points = team_points[team];            if (!points)                continue;            m_lastTick[team] += diff;            if (m_lastTick[team] > BG_AB_TickIntervals[points])            {                m_lastTick[team] -= BG_AB_TickIntervals[points];                m_TeamScores[team] += BG_AB_TickPoints[points];                m_HonorScoreTics[team] += BG_AB_TickPoints[points];                m_ReputationScoreTics[team] += BG_AB_TickPoints[points];                if (m_ReputationScoreTics[team] >= m_ReputationTics)                {                    (team == BG_TEAM_ALLIANCE) ? RewardReputationToTeam(509, 10, ALLIANCE) : RewardReputationToTeam(510, 10, HORDE);                    m_ReputationScoreTics[team] -= m_ReputationTics;                }                if (m_HonorScoreTics[team] >= m_HonorTics)                {                    RewardHonorToTeam(GetBonusHonorFromKill(1), (team == BG_TEAM_ALLIANCE) ? ALLIANCE : HORDE);                    m_HonorScoreTics[team] -= m_HonorTics;                }                if (!m_IsInformedNearVictory && m_TeamScores[team] > BG_AB_WARNING_NEAR_VICTORY_SCORE)                {                    if (team == BG_TEAM_ALLIANCE)                        SendMessageToAll(LANG_BG_AB_A_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);                    else                        SendMessageToAll(LANG_BG_AB_H_NEAR_VICTORY, CHAT_MSG_BG_SYSTEM_NEUTRAL);                    PlaySoundToAll(BG_AB_SOUND_NEAR_VICTORY);                    m_IsInformedNearVictory = true;                }                if (m_TeamScores[team] > BG_AB_MAX_TEAM_SCORE)                    m_TeamScores[team] = BG_AB_MAX_TEAM_SCORE;                if (team == BG_TEAM_ALLIANCE)                    UpdateWorldState(BG_AB_OP_RESOURCES_ALLY, m_TeamScores[team]);                if (team == BG_TEAM_HORDE)                    UpdateWorldState(BG_AB_OP_RESOURCES_HORDE, m_TeamScores[team]);            }        }        // Test win condition        if (m_TeamScores[BG_TEAM_ALLIANCE] >= BG_AB_MAX_TEAM_SCORE)            EndBattleGround(ALLIANCE);        if (m_TeamScores[BG_TEAM_HORDE] >= BG_AB_MAX_TEAM_SCORE)            EndBattleGround(HORDE);    }}

void BattleGroundWS::Update(uint32 diff){    BattleGround::Update(diff);    if (GetStatus() == STATUS_IN_PROGRESS)    {        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)        {            m_FlagsTimer[BG_TEAM_ALLIANCE] -= diff;            if (m_FlagsTimer[BG_TEAM_ALLIANCE] < 0)            {                m_FlagsTimer[BG_TEAM_ALLIANCE] = 0;                RespawnFlag(ALLIANCE, true);            }        }        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)        {            m_FlagsDropTimer[BG_TEAM_ALLIANCE] -= diff;            if (m_FlagsDropTimer[BG_TEAM_ALLIANCE] < 0)            {                m_FlagsDropTimer[BG_TEAM_ALLIANCE] = 0;                RespawnFlagAfterDrop(ALLIANCE);            }        }        if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_WAIT_RESPAWN)        {            m_FlagsTimer[BG_TEAM_HORDE] -= diff;            if (m_FlagsTimer[BG_TEAM_HORDE] < 0)            {                m_FlagsTimer[BG_TEAM_HORDE] = 0;                RespawnFlag(HORDE, true);            }        }        if (m_FlagState[BG_TEAM_HORDE] == BG_WS_FLAG_STATE_ON_GROUND)        {            m_FlagsDropTimer[BG_TEAM_HORDE] -= diff;            if (m_FlagsDropTimer[BG_TEAM_HORDE] < 0)            {                m_FlagsDropTimer[BG_TEAM_HORDE] = 0;                RespawnFlagAfterDrop(HORDE);            }        }        if (m_FlagState[BG_TEAM_ALLIANCE] >= BG_WS_FLAG_STATE_ON_PLAYER && m_FlagState[BG_TEAM_HORDE] >= BG_WS_FLAG_STATE_ON_PLAYER)        {            if (m_FocusedAssault < BG_WS_FIVE_MINUTES)            {                for(uint8 i = 0; i < BG_TEAMS_COUNT; i++)                {                    Player* carrier = sObjectMgr.GetPlayer(m_FlagKeepers[i]);                    if (!carrier)                        continue;                    if ((!carrier->HasAura(BG_WS_SPELL_FOCUSED_ASSAULT) && !carrier->HasAura(BG_WS_SPELL_BRUTAL_ASSAULT)) ||                         (m_FocusedAssaultExtra && m_FocusedAssault < diff))                        carrier->CastSpell(carrier, (m_FocusedAssault < diff) ? BG_WS_SPELL_BRUTAL_ASSAULT : BG_WS_SPELL_FOCUSED_ASSAULT, true);                }                if (m_FocusedAssault < BG_WS_FIVE_MINUTES && m_FocusedAssaultExtra)                    m_FocusedAssaultExtra = false;            }else m_FocusedAssault -= diff;        }else        {            m_FocusedAssault = BG_WS_CARRIER_DEBUFF;            m_FocusedAssaultExtra = true;        }        if (m_EndTimer > 0)        if (m_EndTimer <= diff)        {            uint32 allianceScore = GetTeamScore(ALLIANCE);            uint32 hordeScore    = GetTeamScore(HORDE);            if (allianceScore > hordeScore)                EndBattleGround(ALLIANCE);            else if (allianceScore < hordeScore)                EndBattleGround(HORDE);            else            {                // if 0 => tie                EndBattleGround(m_LastCapturedFlagTeam);            }        }        else        {            uint32 minutesLeftPrev = GetRemainingTimeInMinutes();            m_EndTimer -= diff;            uint32 minutesLeft = GetRemainingTimeInMinutes();            if (minutesLeft != minutesLeftPrev)                UpdateWorldState(BG_WS_TIME_REMAINING, minutesLeft);        }    }}

void BattleGround::Update(uint32 diff){    if (!GetPlayersSize())    {        // BG is empty        // if there are no players invited, delete BG        // this will delete arena or bg object, where any player entered        // [[   but if you use battleground object again (more battles possible to be played on 1 instance)        //      then this condition should be removed and code:        //      if (!GetInvitedCount(HORDE) && !GetInvitedCount(ALLIANCE))        //          this->AddToFreeBGObjectsQueue(); // not yet implemented        //      should be used instead of current        // ]]        // BattleGround Template instance cannot be updated, because it would be deleted        if (!GetInvitedCount(HORDE) && !GetInvitedCount(ALLIANCE))            delete this;        return;    }    // remove offline players from bg after 5 minutes    if (!m_OfflineQueue.empty())    {        BattleGroundPlayerMap::iterator itr = m_Players.find(*(m_OfflineQueue.begin()));        if (itr != m_Players.end())        {            if (itr->second.OfflineRemoveTime <= sWorld.GetGameTime())            {                RemovePlayerAtLeave(itr->first, true, true);// remove player from BG                m_OfflineQueue.pop_front();                 // remove from offline queue                // do not use itr for anything, because it is erased in RemovePlayerAtLeave()            }        }    }    /*********************************************************/    /***           BATTLEGROUND BALLANCE SYSTEM            ***/    /*********************************************************/    // if less then minimum players are in on one side, then start premature finish timer    if (GetStatus() == STATUS_IN_PROGRESS && sBattleGroundMgr.GetPrematureFinishTime() && (GetPlayersCountByTeam(ALLIANCE) < GetMinPlayersPerTeam() || GetPlayersCountByTeam(HORDE) < GetMinPlayersPerTeam()))    {        if (!m_PrematureCountDown)        {            m_PrematureCountDown = true;            m_PrematureCountDownTimer = sBattleGroundMgr.GetPrematureFinishTime();        }        else if (m_PrematureCountDownTimer < diff)        {            // time's up!            Team winner = TEAM_NONE;            if (GetPlayersCountByTeam(ALLIANCE) >= GetMinPlayersPerTeam())                winner = ALLIANCE;            else if (GetPlayersCountByTeam(HORDE) >= GetMinPlayersPerTeam())                winner = HORDE;            EndBattleGround(winner);            m_PrematureCountDown = false;        }        else if (!sBattleGroundMgr.isTesting())        {            uint32 newtime = m_PrematureCountDownTimer - diff;            // announce every minute            if (newtime > (MINUTE * IN_MILLISECONDS))            {                if (newtime / (MINUTE * IN_MILLISECONDS) != m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS))                    PSendMessageToAll(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING, CHAT_MSG_SYSTEM, NULL, (uint32)(m_PrematureCountDownTimer / (MINUTE * IN_MILLISECONDS)));            }            else            {                // announce every 15 seconds                if (newtime / (15 * IN_MILLISECONDS) != m_PrematureCountDownTimer / (15 * IN_MILLISECONDS))                    PSendMessageToAll(LANG_BATTLEGROUND_PREMATURE_FINISH_WARNING_SECS, CHAT_MSG_SYSTEM, NULL, (uint32)(m_PrematureCountDownTimer / IN_MILLISECONDS));            }            m_PrematureCountDownTimer = newtime;        }    }    else if (m_PrematureCountDown)        m_PrematureCountDown = false;    /*********************************************************/    /***           BATTLEGROUND STARTING SYSTEM            ***/    /*********************************************************/    if (GetStatus() == STATUS_WAIT_JOIN && GetPlayersSize())    {        ModifyStartDelayTime(diff);        if (!(m_Events & BG_STARTING_EVENT_1))        {            m_Events |= BG_STARTING_EVENT_1;            StartingEventCloseDoors();            SetStartDelayTime(m_StartDelayTimes[BG_STARTING_EVENT_FIRST]);            // first start warning - 2 or 1 minute, only if defined            if (m_StartMessageIds[BG_STARTING_EVENT_FIRST])                SendMessageToAll(m_StartMessageIds[BG_STARTING_EVENT_FIRST], CHAT_MSG_BG_SYSTEM_NEUTRAL);        }        // After 1 minute or 30 seconds, warning is signalled//.........这里部分代码省略.........

void BattleGroundWS::EventPlayerCapturedFlag(Player* source){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    Team winner = TEAM_NONE;    source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);    if (source->GetTeam() == ALLIANCE)    {        if (!IsHordeFlagPickedUp())            return;        ClearHordeFlagCarrier();                            // must be before aura remove to prevent 2 events (drop+capture) at the same time        // horde flag in base (but not respawned yet)        m_FlagState[TEAM_INDEX_HORDE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;        // Drop Horde Flag from Player        source->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);        if (GetTeamScore(ALLIANCE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(ALLIANCE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);        RewardReputationToTeam(890, m_ReputationCapture, ALLIANCE);    }    else    {        if (!IsAllianceFlagPickedUp())            return;        ClearAllianceFlagCarrier();                         // must be before aura remove to prevent 2 events (drop+capture) at the same time        // alliance flag in base (but not respawned yet)        m_FlagState[TEAM_INDEX_ALLIANCE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;        // Drop Alliance Flag from Player        source->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);        if (GetTeamScore(HORDE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(HORDE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);        RewardReputationToTeam(889, m_ReputationCapture, HORDE);    }    // for flag capture is reward distributed according level range    RewardHonorToTeam(BG_WSG_FlagCapturedHonor[GetBracketId()], source->GetTeam());    // despawn flags    SpawnEvent(WS_EVENT_FLAG_A, 0, false);    SpawnEvent(WS_EVENT_FLAG_H, 0, false);    if (source->GetTeam() == ALLIANCE)        SendMessageToAll(LANG_BG_WS_CAPTURED_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, source);    else        SendMessageToAll(LANG_BG_WS_CAPTURED_AF, CHAT_MSG_BG_SYSTEM_HORDE, source);    UpdateFlagState(source->GetTeam(), 1);                  // flag state none    UpdateTeamScore(source->GetTeam());    // only flag capture should be updated    UpdatePlayerScore(source, SCORE_FLAG_CAPTURES, 1);      // +1 flag captures    if (GetTeamScore(ALLIANCE) == BG_WS_MAX_TEAM_SCORE)        winner = ALLIANCE;    if (GetTeamScore(HORDE) == BG_WS_MAX_TEAM_SCORE)        winner = HORDE;    if (winner)    {        UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 0);        UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 0);        UpdateWorldState(BG_WS_FLAG_STATE_ALLIANCE, 1);        UpdateWorldState(BG_WS_FLAG_STATE_HORDE, 1);        EndBattleGround(winner);    }    else    {        m_FlagsTimer[GetOtherTeamIndex(GetTeamIndex(source->GetTeam()))] = BG_WS_FLAG_RESPAWN_TIME;    }}

void BattleGroundWS::EventPlayerCapturedFlag(Player *Source){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    uint32 winner = 0;    Source->RemoveAurasWithInterruptFlags(AURA_INTERRUPT_FLAG_ENTER_PVP_COMBAT);    if (Source->GetTeam() == ALLIANCE)    {        if (!IsHordeFlagPickedup())            return;        SetHordeFlagPicker(0);                              // must be before aura remove to prevent 2 events (drop+capture) at the same time                                                            // horde flag in base (but not respawned yet)        m_FlagState[BG_TEAM_HORDE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Horde Flag from Player        Source->RemoveAurasDueToSpell(BG_WS_SPELL_WARSONG_FLAG);        if (GetTeamScore(ALLIANCE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(ALLIANCE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_ALLIANCE);        RewardReputationToTeam(890, m_ReputationCapture, ALLIANCE);    }    else    {        if (!IsAllianceFlagPickedup())            return;        SetAllianceFlagPicker(0);                           // must be before aura remove to prevent 2 events (drop+capture) at the same time                                                            // alliance flag in base (but not respawned yet)        m_FlagState[BG_TEAM_ALLIANCE] = BG_WS_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Alliance Flag from Player        Source->RemoveAurasDueToSpell(BG_WS_SPELL_SILVERWING_FLAG);        if (GetTeamScore(HORDE) < BG_WS_MAX_TEAM_SCORE)            AddPoint(HORDE, 1);        PlaySoundToAll(BG_WS_SOUND_FLAG_CAPTURED_HORDE);        RewardReputationToTeam(889, m_ReputationCapture, HORDE);    }    //for flag capture is reward 2 honorable kills    RewardHonorToTeam(GetBonusHonorFromKill(2), Source->GetTeam());    SpawnBGObject(BG_WS_OBJECT_H_FLAG, BG_WS_FLAG_RESPAWN_TIME);    SpawnBGObject(BG_WS_OBJECT_A_FLAG, BG_WS_FLAG_RESPAWN_TIME);    if (Source->GetTeam() == ALLIANCE)        SendMessageToAll(LANG_BG_WS_CAPTURED_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, Source);    else        SendMessageToAll(LANG_BG_WS_CAPTURED_AF, CHAT_MSG_BG_SYSTEM_HORDE, Source);    UpdateFlagState(Source->GetTeam(), 1);                  // flag state none    UpdateTeamScore(Source->GetTeam());    // only flag capture should be updated    UpdatePlayerScore(Source, SCORE_FLAG_CAPTURES, 1);      // +1 flag captures    if (GetTeamScore(ALLIANCE) == BG_WS_MAX_TEAM_SCORE)        winner = ALLIANCE;    if (GetTeamScore(HORDE) == BG_WS_MAX_TEAM_SCORE)        winner = HORDE;    if (winner)    {        UpdateWorldState(BG_WS_FLAG_UNK_ALLIANCE, 0);        UpdateWorldState(BG_WS_FLAG_UNK_HORDE, 0);        UpdateWorldState(BG_WS_FLAG_STATE_ALLIANCE, 1);        UpdateWorldState(BG_WS_FLAG_STATE_HORDE, 1);        EndBattleGround(winner);    }    else    {        m_FlagsTimer[GetTeamIndexByTeamId(Source->GetTeam()) ? 0 : 1] = BG_WS_FLAG_RESPAWN_TIME;    }}