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

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;        if (Team == TEAM_ALLIANCE)            EndBattleground(ALLIANCE);        else            EndBattleground(HORDE);    }    if (Team == TEAM_ALLIANCE)        UpdateWorldState(EY_ALLIANCE_RESOURCES, score);    else        UpdateWorldState(EY_HORDE_RESOURCES, score);}

void BattlegroundKT::PostUpdateImpl(uint32 diff){    if (GetStatus() == STATUS_IN_PROGRESS)    {        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_LastCapturedOrbTeam);            }        }        else        {            uint32 minutesLeftPrev = GetRemainingTimeInMinutes();            m_EndTimer -= diff;            uint32 minutesLeft = GetRemainingTimeInMinutes();            if (minutesLeft != minutesLeftPrev)                UpdateWorldState(BG_KT_TIME_REMAINING, minutesLeft);        }        if (m_UpdatePointsTimer <= diff)        {            for (uint8 i = 0; i < MAX_ORBS; ++i)                if (uint64 guid = m_OrbKeepers[i])                    if (m_playersZone.find(guid) != m_playersZone.end())                        if (Player* player = ObjectAccessor::FindPlayer(guid))                        {                            AccumulateScore(player->GetTeamId(), m_playersZone[guid]);                            UpdatePlayerScore(player, SCORE_ORB_SCORE, m_playersZone[guid]);                        }            m_UpdatePointsTimer = BG_KT_POINTS_UPDATE_TIME;        }        else            m_UpdatePointsTimer -= diff;    }}

void BattlegroundTP::FillInitialWorldStates(WorldStateBuilder& builder){    builder.AppendState(BG_TP_FLAG_CAPTURES_ALLIANCE, GetTeamScore(TEAM_ALLIANCE));    builder.AppendState(BG_TP_FLAG_CAPTURES_HORDE, GetTeamScore(TEAM_HORDE));    if (_flagState[TEAM_ALLIANCE] == BG_TP_FLAG_STATE_ON_GROUND)        builder.AppendState(BG_TP_FLAG_UNK_ALLIANCE, -1);    else if (_flagState[TEAM_ALLIANCE] == BG_TP_FLAG_STATE_ON_PLAYER)        builder.AppendState(BG_TP_FLAG_UNK_ALLIANCE, 1);    else        builder.AppendState(BG_TP_FLAG_UNK_ALLIANCE, 0);    if (_flagState[TEAM_HORDE] == BG_TP_FLAG_STATE_ON_GROUND)        builder.AppendState(BG_TP_FLAG_UNK_HORDE, -1);    else if (_flagState[TEAM_HORDE] == BG_TP_FLAG_STATE_ON_PLAYER)        builder.AppendState(BG_TP_FLAG_UNK_HORDE, 1);    else        builder.AppendState(BG_TP_FLAG_UNK_HORDE, 0);    builder.AppendState(BG_TP_FLAG_CAPTURES_MAX, BG_TP_MAX_TEAM_SCORE);    if (GetStatus() == STATUS_IN_PROGRESS)    {        builder.AppendState(BG_TP_STATE_TIMER_ACTIVE, 1);        builder.AppendState(BG_TP_STATE_TIMER, 25-_minutesElapsed);    }    else        builder.AppendState(BG_TP_STATE_TIMER_ACTIVE, 0);    if (_flagState[TEAM_HORDE] == BG_TP_FLAG_STATE_ON_PLAYER)        builder.AppendState(BG_TP_FLAG_STATE_HORDE, 2);    else        builder.AppendState(BG_TP_FLAG_STATE_HORDE, 1);    if (_flagState[TEAM_ALLIANCE] == BG_TP_FLAG_STATE_ON_PLAYER)        builder.AppendState(BG_TP_FLAG_STATE_ALLIANCE, 2);    else        builder.AppendState(BG_TP_FLAG_STATE_ALLIANCE, 1);}

void BattlegroundTP::FillInitialWorldStates(WorldPacket& data){    data << uint32(BG_TP_FLAG_CAPTURES_ALLIANCE) << uint32(GetTeamScore(TEAM_ALLIANCE));    data << uint32(BG_TP_FLAG_CAPTURES_HORDE) << uint32(GetTeamScore(TEAM_HORDE));    if (_flagState[TEAM_ALLIANCE] == BG_TP_FLAG_STATE_ON_GROUND)        data << uint32(BG_TP_FLAG_UNK_ALLIANCE) << uint32(-1);    else if (_flagState[TEAM_ALLIANCE] == BG_TP_FLAG_STATE_ON_PLAYER)        data << uint32(BG_TP_FLAG_UNK_ALLIANCE) << uint32(1);    else        data << uint32(BG_TP_FLAG_UNK_ALLIANCE) << uint32(0);    if (_flagState[TEAM_HORDE] == BG_TP_FLAG_STATE_ON_GROUND)        data << uint32(BG_TP_FLAG_UNK_HORDE) << uint32(-1);    else if (_flagState[TEAM_HORDE] == BG_TP_FLAG_STATE_ON_PLAYER)        data << uint32(BG_TP_FLAG_UNK_HORDE) << uint32(1);    else        data << uint32(BG_TP_FLAG_UNK_HORDE) << uint32(0);    data << uint32(BG_TP_FLAG_CAPTURES_MAX) << uint32(BG_TP_MAX_TEAM_SCORE);    if (GetStatus() == STATUS_IN_PROGRESS)    {        data << uint32(BG_TP_STATE_TIMER_ACTIVE) << uint32(1);        data << uint32(BG_TP_STATE_TIMER) << uint32(25-_minutesElapsed);    }    else        data << uint32(BG_TP_STATE_TIMER_ACTIVE) << uint32(0);    if (_flagState[TEAM_HORDE] == BG_TP_FLAG_STATE_ON_PLAYER)        data << uint32(BG_TP_FLAG_STATE_HORDE) << uint32(2);    else        data << uint32(BG_TP_FLAG_STATE_HORDE) << uint32(1);    if (_flagState[TEAM_ALLIANCE] == BG_TP_FLAG_STATE_ON_PLAYER)        data << uint32(BG_TP_FLAG_STATE_ALLIANCE) << uint32(2);    else        data << uint32(BG_TP_FLAG_STATE_ALLIANCE) << uint32(1);}

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 game_sv_TeamDeathmatch::WriteGameState(CInifile& ini, LPCSTR sect, bool bRoundResult){    inherited::WriteGameState(ini, sect, bRoundResult);    for(u32 i=0; i<teams.size(); ++i )    {        string16		buf_name;        sprintf_s		(buf_name,"team_%d_score",i);        ini.w_u32		(sect,buf_name, GetTeamScore(i));    }}

void BattlegroundWS::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet){    packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_CAPTURES_ALLIANCE), int32(GetTeamScore(TEAM_ALLIANCE)));    packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_CAPTURES_HORDE), int32(GetTeamScore(TEAM_HORDE)));    if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_GROUND)        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_ALLIANCE), -1);    else if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_PLAYER)        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_ALLIANCE), 1);    else        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_ALLIANCE), 0);    if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_GROUND)        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_HORDE), -1);    else if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_PLAYER)        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_HORDE), 1);    else        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_UNK_HORDE), 0);    packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_CAPTURES_MAX), int32(BG_WS_MAX_TEAM_SCORE));    if (GetStatus() == STATUS_IN_PROGRESS)    {        packet.Worldstates.emplace_back(uint32(BG_WS_STATE_TIMER_ACTIVE), 1);        packet.Worldstates.emplace_back(uint32(BG_WS_STATE_TIMER), int32(25 - _minutesElapsed));    }    else        packet.Worldstates.emplace_back(uint32(BG_WS_STATE_TIMER_ACTIVE), 0);    if (_flagState[TEAM_HORDE] == BG_WS_FLAG_STATE_ON_PLAYER)        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_HORDE), 2);    else        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_HORDE), 1);    if (_flagState[TEAM_ALLIANCE] == BG_WS_FLAG_STATE_ON_PLAYER)        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_ALLIANCE), 2);    else        packet.Worldstates.emplace_back(uint32(BG_WS_FLAG_STATE_ALLIANCE), 1);}

void BattlegroundEY::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& packet){    packet.Worldstates.emplace_back(uint32(EY_HORDE_BASE), int32(m_TeamPointsCount[TEAM_HORDE]));    packet.Worldstates.emplace_back(uint32(EY_ALLIANCE_BASE), int32(m_TeamPointsCount[TEAM_ALLIANCE]));    packet.Worldstates.emplace_back(0xAB6, 0x0);    packet.Worldstates.emplace_back(0xAB5, 0x0);    packet.Worldstates.emplace_back(0xAB4, 0x0);    packet.Worldstates.emplace_back(0xAB3, 0x0);    packet.Worldstates.emplace_back(0xAB2, 0x0);    packet.Worldstates.emplace_back(0xAB1, 0x0);    packet.Worldstates.emplace_back(0xAB0, 0x0);    packet.Worldstates.emplace_back(0xAAF, 0x0);    packet.Worldstates.emplace_back(uint32(DRAENEI_RUINS_HORDE_CONTROL), int32(m_PointOwnedByTeam[DRAENEI_RUINS] == HORDE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(DRAENEI_RUINS_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[DRAENEI_RUINS] == ALLIANCE && m_PointState[DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(DRAENEI_RUINS_UNCONTROL), int32(m_PointState[DRAENEI_RUINS] != EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(MAGE_TOWER_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[MAGE_TOWER] == ALLIANCE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(MAGE_TOWER_HORDE_CONTROL), int32(m_PointOwnedByTeam[MAGE_TOWER] == HORDE && m_PointState[MAGE_TOWER] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(MAGE_TOWER_UNCONTROL), int32(m_PointState[MAGE_TOWER] != EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(FEL_REAVER_HORDE_CONTROL), int32(m_PointOwnedByTeam[FEL_REAVER] == HORDE && m_PointState[FEL_REAVER] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(FEL_REAVER_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[FEL_REAVER] == ALLIANCE && m_PointState[FEL_REAVER] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(FEL_REAVER_UNCONTROL), int32(m_PointState[FEL_REAVER] != EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(BLOOD_ELF_HORDE_CONTROL), int32(m_PointOwnedByTeam[BLOOD_ELF] == HORDE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(BLOOD_ELF_ALLIANCE_CONTROL), int32(m_PointOwnedByTeam[BLOOD_ELF] == ALLIANCE && m_PointState[BLOOD_ELF] == EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(BLOOD_ELF_UNCONTROL), int32(m_PointState[BLOOD_ELF] != EY_POINT_UNDER_CONTROL));    packet.Worldstates.emplace_back(uint32(NETHERSTORM_FLAG), int32(m_FlagState == BG_EY_FLAG_STATE_ON_BASE));    packet.Worldstates.emplace_back(0xAD2, 0x1);    packet.Worldstates.emplace_back(0xAD1, 0x1);    packet.Worldstates.emplace_back(0xABE, int32(GetTeamScore(TEAM_HORDE)));    packet.Worldstates.emplace_back(0xABD, int32(GetTeamScore(TEAM_ALLIANCE)));    packet.Worldstates.emplace_back(0xA05, 0x8E);    packet.Worldstates.emplace_back(0xAA0, 0x0);    packet.Worldstates.emplace_back(0xA9F, 0x0);    packet.Worldstates.emplace_back(0xA9E, 0x0);    packet.Worldstates.emplace_back(0xC0D, 0x17B);}

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 BattleGroundAC::FillInitialWorldStates(WorldPacket& data, uint32& count){    FillInitialWorldState(data, count, AC_HORDE_BASE,    m_TeamPointsCount[BG_TEAM_HORDE]);    FillInitialWorldState(data, count, AC_ALLIANCE_BASE, m_TeamPointsCount[BG_TEAM_ALLIANCE]);    FillInitialWorldState(data, count, 0xab6, 0x0);    FillInitialWorldState(data, count, 0xab5, 0x0);    FillInitialWorldState(data, count, 0xab4, 0x0);    FillInitialWorldState(data, count, 0xab3, 0x0);    FillInitialWorldState(data, count, 0xab2, 0x0);    FillInitialWorldState(data, count, 0xab1, 0x0);    FillInitialWorldState(data, count, 0xab0, 0x0);    FillInitialWorldState(data, count, 0xaaf, 0x0);    FillInitialWorldState(data, count, TOWER_1_HORDE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_1] == HORDE && m_PointState[BG_AC_NODE_TOWER_1] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_1_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_1] == ALLIANCE && m_PointState[BG_AC_NODE_TOWER_1] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_1_UNCONTROL, m_PointState[BG_AC_NODE_TOWER_1] != AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_2_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_2] == ALLIANCE && m_PointState[BG_AC_NODE_TOWER_2] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_2_HORDE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_2] == HORDE && m_PointState[BG_AC_NODE_TOWER_2] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_2_UNCONTROL, m_PointState[BG_AC_NODE_TOWER_2] != AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_3_HORDE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_3] == HORDE && m_PointState[BG_AC_NODE_TOWER_3] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_3_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_3] == ALLIANCE && m_PointState[BG_AC_NODE_TOWER_3] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_3_UNCONTROL, m_PointState[BG_AC_NODE_TOWER_3] != AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_4_HORDE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_4] == HORDE && m_PointState[BG_AC_NODE_TOWER_4] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_4_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_AC_NODE_TOWER_4] == ALLIANCE && m_PointState[BG_AC_NODE_TOWER_4] == AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, TOWER_4_UNCONTROL, m_PointState[BG_AC_NODE_TOWER_4] != AC_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, FLAG_1_FLAG, m_FlagState == BG_AC_FLAG_STATE_ON_BASE);    FillInitialWorldState(data, count, 0xad2, 0x1);    FillInitialWorldState(data, count, 0xad1, 0x1);    FillInitialWorldState(data, count, 0xabe, GetTeamScore(HORDE));    FillInitialWorldState(data, count, 0xabd, GetTeamScore(ALLIANCE));    FillInitialWorldState(data, count, 0xa05, 0x8e);    FillInitialWorldState(data, count, 0xaa0, 0x0);    FillInitialWorldState(data, count, 0xa9f, 0x0);    FillInitialWorldState(data, count, 0xa9e, 0x0);    FillInitialWorldState(data, count, 0xc0d, 0x17b);}

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::FillInitialWorldStates(WorldPacket& data, uint32& count){    FillInitialWorldState(data, count, EY_HORDE_BASE,    m_TeamPointsCount[BG_TEAM_HORDE]);    FillInitialWorldState(data, count, EY_ALLIANCE_BASE, m_TeamPointsCount[BG_TEAM_ALLIANCE]);    FillInitialWorldState(data, count, 0xab6, 0x0);    FillInitialWorldState(data, count, 0xab5, 0x0);    FillInitialWorldState(data, count, 0xab4, 0x0);    FillInitialWorldState(data, count, 0xab3, 0x0);    FillInitialWorldState(data, count, 0xab2, 0x0);    FillInitialWorldState(data, count, 0xab1, 0x0);    FillInitialWorldState(data, count, 0xab0, 0x0);    FillInitialWorldState(data, count, 0xaaf, 0x0);    FillInitialWorldState(data, count, DRAENEI_RUINS_HORDE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_DRAENEI_RUINS] == HORDE && m_PointState[BG_EY_NODE_DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, DRAENEI_RUINS_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_DRAENEI_RUINS] == ALLIANCE && m_PointState[BG_EY_NODE_DRAENEI_RUINS] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, DRAENEI_RUINS_UNCONTROL, m_PointState[BG_EY_NODE_DRAENEI_RUINS] != EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, MAGE_TOWER_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_MAGE_TOWER] == ALLIANCE && m_PointState[BG_EY_NODE_MAGE_TOWER] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, MAGE_TOWER_HORDE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_MAGE_TOWER] == HORDE && m_PointState[BG_EY_NODE_MAGE_TOWER] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, MAGE_TOWER_UNCONTROL, m_PointState[BG_EY_NODE_MAGE_TOWER] != EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, FEL_REAVER_HORDE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_FEL_REAVER] == HORDE && m_PointState[BG_EY_NODE_FEL_REAVER] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, FEL_REAVER_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_FEL_REAVER] == ALLIANCE && m_PointState[BG_EY_NODE_FEL_REAVER] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, FEL_REAVER_UNCONTROL, m_PointState[BG_EY_NODE_FEL_REAVER] != EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, BLOOD_ELF_HORDE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_BLOOD_ELF] == HORDE && m_PointState[BG_EY_NODE_BLOOD_ELF] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, BLOOD_ELF_ALLIANCE_CONTROL, m_PointOwnedByTeam[BG_EY_NODE_BLOOD_ELF] == ALLIANCE && m_PointState[BG_EY_NODE_BLOOD_ELF] == EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, BLOOD_ELF_UNCONTROL, m_PointState[BG_EY_NODE_BLOOD_ELF] != EY_POINT_UNDER_CONTROL);    FillInitialWorldState(data, count, NETHERSTORM_FLAG, m_FlagState == BG_EY_FLAG_STATE_ON_BASE);    FillInitialWorldState(data, count, 0xad2, 0x1);    FillInitialWorldState(data, count, 0xad1, 0x1);    FillInitialWorldState(data, count, 0xabe, GetTeamScore(HORDE));    FillInitialWorldState(data, count, 0xabd, GetTeamScore(ALLIANCE));    FillInitialWorldState(data, count, 0xa05, 0x8e);    FillInitialWorldState(data, count, 0xaa0, 0x0);    FillInitialWorldState(data, count, 0xa9f, 0x0);    FillInitialWorldState(data, count, 0xa9e, 0x0);    FillInitialWorldState(data, count, 0xc0d, 0x17b);}

void BattlegroundTP::Update(uint32 diff){    Battleground::Update(diff);    if (GetStatus() == STATUS_IN_PROGRESS)    {        if (GetStartTime() >= 25*MINUTE*IN_MILLISECONDS)        {            if (GetTeamScore(ALLIANCE) == 0)            {                if (GetTeamScore(HORDE) == 0)        // No one scored - result is tie                    EndBattleground(NULL);                else                                 // Horde has more points and thus wins                    EndBattleground(HORDE);            }            else if (GetTeamScore(HORDE) == 0)                EndBattleground(ALLIANCE);           // Alliance has > 0, Horde has 0, alliance wins            else if (GetTeamScore(HORDE) == GetTeamScore(ALLIANCE)) // Team score equal, winner is team that scored the last flag                EndBattleground(m_LastFlagCaptureTeam);            else if (GetTeamScore(HORDE) > GetTeamScore(ALLIANCE))  // Last but not least, check who has the higher score                EndBattleground(HORDE);            else                EndBattleground(ALLIANCE);        }        else if (GetStartTime() > uint32(m_minutesElapsed * MINUTE * IN_MILLISECONDS))        {            ++m_minutesElapsed;            UpdateWorldState(BG_TP_STATE_TIMER, 25 - m_minutesElapsed);        }        if (m_FlagState[BG_TEAM_ALLIANCE] == BG_TP_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_TP_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);                m_BothFlagsKept = false;            }        }        if (m_FlagState[BG_TEAM_HORDE] == BG_TP_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_TP_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);                m_BothFlagsKept = false;            }        }        if (m_BothFlagsKept)        {          m_FlagSpellForceTimer += diff;          if (m_FlagDebuffState == 0 && m_FlagSpellForceTimer >= 600000)  //10 minutes          {            if (Player * plr = sObjectMgr->GetPlayer(m_FlagKeepers[0]))              plr->CastSpell(plr, TP_SPELL_FOCUSED_ASSAULT, true);            if (Player * plr = sObjectMgr->GetPlayer(m_FlagKeepers[1]))              plr->CastSpell(plr, TP_SPELL_FOCUSED_ASSAULT, true);            m_FlagDebuffState = 1;          }          else if (m_FlagDebuffState == 1 && m_FlagSpellForceTimer >= 900000) //15 minutes          {            if (Player * plr = sObjectMgr->GetPlayer(m_FlagKeepers[0]))            {              plr->RemoveAurasDueToSpell(TP_SPELL_FOCUSED_ASSAULT);              plr->CastSpell(plr, TP_SPELL_BRUTAL_ASSAULT, true);            }            if (Player * plr = sObjectMgr->GetPlayer(m_FlagKeepers[1]))            {              plr->RemoveAurasDueToSpell(TP_SPELL_FOCUSED_ASSAULT);              plr->CastSpell(plr, TP_SPELL_BRUTAL_ASSAULT, true);            }            m_FlagDebuffState = 2;          }//.........这里部分代码省略.........

void BattlegroundTP::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 (!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_TP_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Horde Flag from Player        Source->RemoveAurasDueToSpell(BG_TP_SPELL_HORDE_FLAG);        if (m_FlagDebuffState == 1)          Source->RemoveAurasDueToSpell(TP_SPELL_FOCUSED_ASSAULT);        if (m_FlagDebuffState == 2)          Source->RemoveAurasDueToSpell(TP_SPELL_BRUTAL_ASSAULT);        if (GetTeamScore(ALLIANCE) < BG_TP_MAX_TEAM_SCORE)            AddPoint(ALLIANCE, 1);        PlaySoundToAll(BG_TP_SOUND_FLAG_CAPTURED_ALLIANCE);        RewardReputationToTeam(890, m_ReputationCapture, ALLIANCE);    }    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_TP_FLAG_STATE_WAIT_RESPAWN;                                                            // Drop Alliance Flag from Player        Source->RemoveAurasDueToSpell(BG_TP_SPELL_ALLIANCE_FLAG);        if (m_FlagDebuffState == 1)          Source->RemoveAurasDueToSpell(TP_SPELL_FOCUSED_ASSAULT);        if (m_FlagDebuffState == 2)          Source->RemoveAurasDueToSpell(TP_SPELL_BRUTAL_ASSAULT);        if (GetTeamScore(HORDE) < BG_TP_MAX_TEAM_SCORE)            AddPoint(HORDE, 1);        PlaySoundToAll(BG_TP_SOUND_FLAG_CAPTURED_HORDE);        RewardReputationToTeam(889, m_ReputationCapture, HORDE);    }    //for flag capture is reward 2 honorable kills    RewardHonorToTeam(GetBonusHonorFromKill(2), Source->GetTeam());    SpawnBGObject(BG_TP_OBJECT_H_FLAG, BG_TP_FLAG_RESPAWN_TIME);    SpawnBGObject(BG_TP_OBJECT_A_FLAG, BG_TP_FLAG_RESPAWN_TIME);    if (Source->GetTeam() == ALLIANCE)        SendMessageToAll(LANG_BG_TP_CAPTURED_HF, CHAT_MSG_BG_SYSTEM_ALLIANCE, Source);    else        SendMessageToAll(LANG_BG_TP_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    // update last flag capture to be used if teamscore is equal    SetLastFlagCapture(Source->GetTeam());    if (GetTeamScore(ALLIANCE) == BG_TP_MAX_TEAM_SCORE)        winner = ALLIANCE;    if (GetTeamScore(HORDE) == BG_TP_MAX_TEAM_SCORE)        winner = HORDE;    if (winner)    {        UpdateWorldState(BG_TP_FLAG_UNK_ALLIANCE, 0);        UpdateWorldState(BG_TP_FLAG_UNK_HORDE, 0);        UpdateWorldState(BG_TP_FLAG_STATE_ALLIANCE, 1);        UpdateWorldState(BG_TP_FLAG_STATE_HORDE, 1);        UpdateWorldState(BG_TP_STATE_TIMER_ACTIVE, 0);        RewardHonorToTeam(BG_TP_Honor[m_HonorMode][BG_TP_WIN], winner);        EndBattleground(winner);    }    else    {        m_FlagsTimer[GetTeamIndexByTeamId(Source->GetTeam()) ? 0 : 1] = BG_TP_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 <= 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 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 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;    }}

bool game_sv_TeamDeathmatch::HasChampion(){    return (GetTeamScore(0)!=GetTeamScore(1) || g_sv_Skip_Winner_Waiting);}

void BattlegroundKT::PostUpdateImpl(uint32 diff){    if (GetStatus() == STATUS_WAIT_JOIN)    {        m_CheatersCheckTimer -= diff;        if (m_CheatersCheckTimer <= 0)        {            for (BattlegroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)            {                Player * plr = ObjectAccessor::FindPlayer(itr->first);                if (!plr || !plr->IsInWorld())                    continue;                if (plr->GetPositionZ() < 24.0f)                {                    if (plr->GetBGTeam() == HORDE)                        plr->TeleportTo(998, 1781.31f, 1597.76f, 33.61f, plr->GetOrientation(), 0);                    else                        plr->TeleportTo(998, 1784.42f, 1072.73f, 29.88f, plr->GetOrientation(), 0);                }            }            m_CheatersCheckTimer = 4000;        }    }    if (GetStatus() == STATUS_IN_PROGRESS)    {        if (m_EndTimer <= diff)        {            uint32 allianceScore = GetTeamScore(ALLIANCE);            uint32 hordeScore    = GetTeamScore(HORDE);            if (allianceScore > hordeScore)                EndBattleground(ALLIANCE);            else if (allianceScore < hordeScore)                EndBattleground(HORDE);            else                EndBattleground(m_LastCapturedOrbTeam); // if 0 => tie        }        else        {            uint32 minutesLeftPrev = GetRemainingTimeInMinutes();            m_EndTimer -= diff;            uint32 minutesLeft = GetRemainingTimeInMinutes();            if (minutesLeft != minutesLeftPrev)                UpdateWorldState(BG_KT_TIME_REMAINING, minutesLeft);        }        if (m_UpdatePointsTimer <= diff)        {            for (uint8 i = 0; i < MAX_ORBS; ++i)            {                if (uint64 guid = m_OrbKeepers[i])                {                    if (m_playersZone.find(guid) != m_playersZone.end())                    {                        if (Player* player = ObjectAccessor::FindPlayer(guid))                        {                            AccumulateScore(player->GetBGTeam() == ALLIANCE ? BG_TEAM_ALLIANCE : BG_TEAM_HORDE, m_playersZone[guid]);                            UpdatePlayerScore(player, SCORE_ORB_SCORE, m_playersZone[guid]);                        }                    }                }            }            m_UpdatePointsTimer = BG_KT_POINTS_UPDATE_TIME;        }        else            m_UpdatePointsTimer -= diff;    }}

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::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)            {                Player* CarrierA = sObjectMgr.GetPlayer(m_FlagKeepers[BG_TEAM_ALLIANCE]);                Player* CarrierH = sObjectMgr.GetPlayer(m_FlagKeepers[BG_TEAM_HORDE]);                if(!CarrierA || !CarrierH)                    return;                //after 15 minutes spell should have double effect                SpellEntry const *spellInfo = sSpellStore.LookupEntry(BG_WS_FOCUSED_ASSAULT);                if (!spellInfo)                    return;                int32 SpellValue0 = spellInfo->CalculateSimpleValue(EFFECT_INDEX_0);                int32 SpellValue1 = spellInfo->EffectBasePoints[0];                int32 dmgtaken = ((m_FocusedAssault < diff) ? 2*SpellValue0 : SpellValue0) - 1;                if(!CarrierA->HasAura(BG_WS_FOCUSED_ASSAULT))                    CarrierA->CastCustomSpell(CarrierA, BG_WS_FOCUSED_ASSAULT, &dmgtaken, &SpellValue1, 0, true);                if(!CarrierH->HasAura(BG_WS_FOCUSED_ASSAULT))                    CarrierH->CastCustomSpell(CarrierH, BG_WS_FOCUSED_ASSAULT, &dmgtaken, &SpellValue1, 0, true);                                // after 15 minutes buff must be reapplied with double value                if(m_FocusedAssaultExtra && m_FocusedAssault < diff)                {                    CarrierA->CastCustomSpell(CarrierA, BG_WS_FOCUSED_ASSAULT, &dmgtaken, &SpellValue1, 0, true);                    CarrierH->CastCustomSpell(CarrierH, BG_WS_FOCUSED_ASSAULT, &dmgtaken, &SpellValue1, 0, true);                    m_FocusedAssaultExtra = false;                }            }else m_FocusedAssault -= diff;        }else        {            m_FocusedAssault = BG_WS_CARRIER_DEBUFF;            m_FocusedAssaultExtra = true;        }        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)//.........这里部分代码省略.........

void BattleGroundWS::EventPlayerCapturedFlag(Player *Source){    if (GetStatus() != STATUS_IN_PROGRESS)        return;    uint8 type = 0;    uint32 winner = 0;    const char *message = "";    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);        message = GetMangosString(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, 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);        message = GetMangosString(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, m_ReputationCapture, HORDE);    }    //for flag capture is reward distributed according level range    RewardHonorToTeamDepOnLvl(BG_WSG_FlagCapturedHonor, Source->GetTeam());    // despawn flags    SpawnEvent(WS_EVENT_FLAG_A, 0, false);    SpawnEvent(WS_EVENT_FLAG_H, 0, false);    WorldPacket data;    ChatHandler::FillMessageData(&data, Source->GetSession(), type, LANG_UNIVERSAL, NULL, Source->GetGUID(), message, NULL);    SendPacketToAll(&data);    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;    }}

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 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());    // 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[GetTeamIndexByTeamId(Source->GetTeam()) ? 0 : 1] = BG_WS_FLAG_RESPAWN_TIME;    }}

void BattleGroundWS::Update(uint32 diff){    BattleGround::Update(diff);    if (sBattleGroundMgr.IsWSGEndAfterEnabled())    {        if (m_TimeElapsedSinceBeggining > sBattleGroundMgr.GetWSGEndAfterTime() && GetStatus() == STATUS_IN_PROGRESS)        {            if (!sBattleGroundMgr.IsWSGEndAfterAlwaysDraw())            {                if(GetTeamScore(HORDE) > GetTeamScore(ALLIANCE))                {                    EndBattleGround(HORDE);                    return;                }                else if (GetTeamScore(HORDE) < GetTeamScore(ALLIANCE))                {                    EndBattleGround(ALLIANCE);                    return;                }            }            EndBattleGround(0);            return;        }        if(m_TimeElapsedSinceBeggining> sBattleGroundMgr.GetWSGEndAfterTime()/2 &&            m_TimeElapsedSinceBeggining/180000 > (m_TimeElapsedSinceBeggining - diff)/180000) //warning every 3 mins            PrepareMessageToAll("This battleground will end in %u min.",            (sBattleGroundMgr.GetWSGEndAfterTime() - m_TimeElapsedSinceBeggining) /60000);    }    // after bg start we get there (once)    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 = WS_SPIRIT_MAIN_ALLIANCE; i <= WS_SPIRIT_MAIN_HORDE; i++)//                SpawnBGCreature(i, RESPAWN_IMMEDIATELY);            for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_H_4; i++)            {                SpawnBGObject(i, RESPAWN_IMMEDIATELY);                DoorClose(i);            }            for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; i++)                SpawnBGObject(i, RESPAWN_ONE_DAY);            SetStartDelayTime(START_DELAY0);        }        // After 1 minute, warning is signalled        else if (GetStartDelayTime() <= START_DELAY1 && !(m_Events & 0x04))        {            m_Events |= 0x04;            SendMessageToAll(GetHellgroundString(LANG_BG_WS_ONE_MINUTE));        }        // After 1,5 minute, warning is signalled        else if (GetStartDelayTime() <= START_DELAY2 && !(m_Events & 0x08))        {            m_Events |= 0x08;            SendMessageToAll(GetHellgroundString(LANG_BG_WS_HALF_MINUTE));        }        // After 2 minutes, gates OPEN ! x)        else if (GetStartDelayTime() < 0 && !(m_Events & 0x10))        {            m_Events |= 0x10;                        for (uint32 i = BG_WS_OBJECT_DOOR_A_1; i <= BG_WS_OBJECT_DOOR_A_4; i++)                DoorOpen(i);            for (uint32 i = BG_WS_OBJECT_DOOR_H_1; i <= BG_WS_OBJECT_DOOR_H_2; i++)                DoorOpen(i);            SpawnBGObject(BG_WS_OBJECT_DOOR_A_5, RESPAWN_ONE_DAY);            SpawnBGObject(BG_WS_OBJECT_DOOR_A_6, RESPAWN_ONE_DAY);            SpawnBGObject(BG_WS_OBJECT_DOOR_H_3, RESPAWN_ONE_DAY);            SpawnBGObject(BG_WS_OBJECT_DOOR_H_4, RESPAWN_ONE_DAY);            for (uint32 i = BG_WS_OBJECT_A_FLAG; i <= BG_WS_OBJECT_BERSERKBUFF_2; i++)                SpawnBGObject(i, RESPAWN_IMMEDIATELY);            SendMessageToAll(GetHellgroundString(LANG_BG_WS_BEGIN));            PlaySoundToAll(SOUND_BG_START);            if (sWorld.getConfig(CONFIG_BG_START_MUSIC))                PlaySoundToAll(SOUND_BG_START_L70ETC); //MUSIC - Custom config            SetStatus(STATUS_IN_PROGRESS);            for (BattleGroundPlayerMap::const_iterator itr = GetPlayers().begin(); itr != GetPlayers().end(); ++itr)//.........这里部分代码省略.........

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 ScoreboardView::Draw() {			SPADES_MARK_FUNCTION();						world = client->GetWorld();			if(!world){				// no world				return;			}			ctf = dynamic_cast<CTFGameMode *>(world->GetMode());			tc = dynamic_cast<TCGameMode *>(world->GetMode());						Handle<IImage>image;			IFont *font;			Vector2 pos, size;			char buf[256];			std::string str;			float scrWidth = renderer->ScreenWidth();			float scrHeight = renderer->ScreenHeight();			const Vector4 whiteColor = {1,1,1,1};			Handle<IImage> whiteImage = renderer->RegisterImage("Gfx/White.tga");						float teamBarTop = 120.f;			float teamBarHeight = 60.f;			float contentsLeft = scrWidth * .5f - 400.f;			float contentsRight = scrWidth * .5f + 400.f;			float playersHeight = 300.f;			float playersTop = teamBarTop + teamBarHeight;			float playersBottom = playersTop + playersHeight;						// draw shadow			image = renderer->RegisterImage("Gfx/Scoreboard/TopShadow.tga");			size.y = 32.f;			renderer->SetColor(MakeVector4(0,0,0,0.2f));			renderer->DrawImage(image, AABB2(0, teamBarTop-size.y,											 scrWidth, size.y));			renderer->SetColor(MakeVector4(0,0,0,0.2f));			renderer->DrawImage(image, AABB2(0, playersBottom + size.y,											 scrWidth, -size.y));						// draw scores			image = renderer->RegisterImage("Gfx/Scoreboard/ScoresBg.tga");			size = MakeVector2(180.f, 32.f);			pos = MakeVector2((scrWidth - size.x) * .5f,							  teamBarTop - size.y);			renderer->SetColor(MakeVector4(1.f, .45f, .2f, 1.f));			renderer->DrawImage(image, AABB2(pos.x,pos.y,size.x,size.y));						pos.y = pos.y + 5.f;			font = client->designFont;						sprintf(buf, "%d", GetTeamScore(0));			size = font->Measure(buf);			pos.x = scrWidth * .5f - size.x - 16.f;			font->Draw(buf, pos + MakeVector2(0, 1), 1.f,					   MakeVector4(0, 0, 0, 0.3));			font->Draw(buf, pos, 1.f, whiteColor);						sprintf(buf, "%d", GetTeamScore(1));			size = font->Measure(buf);			pos.x = scrWidth * .5f + 16.f;			font->Draw(buf, pos + MakeVector2(0, 1), 1.f,					   MakeVector4(0, 0, 0, 0.3));			font->Draw(buf, pos, 1.f, whiteColor);						sprintf(buf, "-");			size = font->Measure(buf);			pos.x = scrWidth * .5f  - size.x * .5f;			font->Draw(buf, pos + MakeVector2(0, 1), 1.f,					   MakeVector4(0, 0, 0, 0.3));			font->Draw(buf, pos, 1.f, whiteColor);						// draw team bar			image = whiteImage;			renderer->SetColor(AdjustColor(GetTeamColor(0), 0.8f, 0.3f));			renderer->DrawImage(image,								AABB2(0, teamBarTop,									  scrWidth * .5f, teamBarHeight));			renderer->SetColor(AdjustColor(GetTeamColor(1), 0.8f, 0.3f));			renderer->DrawImage(image,								AABB2(scrWidth * .5f, teamBarTop,									  scrWidth * .5f, teamBarHeight));						image = renderer->RegisterImage("Gfx/Scoreboard/Grunt.tga");			size.x = 120.f; size.y = 60.f;			renderer->DrawImage(image,								AABB2(contentsLeft, teamBarTop + teamBarHeight - size.y,									  size.x, size.y));			renderer->DrawImage(image,								AABB2(contentsRight, teamBarTop + teamBarHeight - size.y,									  -size.x, size.y));						font = client->bigTextFont;			str = world->GetTeam(0).name;			pos.x = contentsLeft + 110.f;			pos.y = teamBarTop + 5.f;			font->Draw(str, pos + MakeVector2(0, 2), 1.f,					   MakeVector4(0, 0, 0, 0.5));			font->Draw(str, pos, 1.f, whiteColor);						str = world->GetTeam(1).name;//.........这里部分代码省略.........