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

void BattlegroundEY::Reset(){    //call parent's class reset    Battleground::Reset();    m_TeamScores[BG_TEAM_ALLIANCE] = 0;    m_TeamScores[BG_TEAM_HORDE] = 0;    m_TeamPointsCount[BG_TEAM_ALLIANCE] = 0;    m_TeamPointsCount[BG_TEAM_HORDE] = 0;    m_HonorScoreTics[BG_TEAM_ALLIANCE] = 0;    m_HonorScoreTics[BG_TEAM_HORDE] = 0;    m_FlagState = BG_EY_FLAG_STATE_ON_BASE;    m_FlagCapturedBgObjectType = 0;    m_FlagKeeper = 0;    m_DroppedFlagGUID = 0;    m_PointAddingTimer = 0;    m_TowerCapCheckTimer = 0;    bool isBGWeekend = sBattlegroundMgr->IsBGWeekend(GetTypeID());    m_HonorTics = (isBGWeekend) ? BG_EY_EYWeekendHonorTicks : BG_EY_NotEYWeekendHonorTicks;    for (uint8 i = 0; i < EY_POINTS_MAX; ++i)    {        m_PointOwnedByTeam[i] = EY_POINT_NO_OWNER;        m_PointState[i] = EY_POINT_STATE_UNCONTROLLED;        m_PointBarStatus[i] = BG_EY_PROGRESS_BAR_STATE_MIDDLE;        m_PlayersNearPoint[i].clear();        m_PlayersNearPoint[i].reserve(15);                  //tip size    }    m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].clear();    m_PlayersNearPoint[EY_PLAYERS_OUT_OF_POINTS].reserve(30);}

void BattleGroundWS::Reset(){    // call parent's class reset    BattleGround::Reset();    // spiritguides and flags not spawned at beginning    m_ActiveEvents[WS_EVENT_SPIRITGUIDES_SPAWN] = BG_EVENT_NONE;    m_ActiveEvents[WS_EVENT_FLAG_A] = BG_EVENT_NONE;    m_ActiveEvents[WS_EVENT_FLAG_H] = BG_EVENT_NONE;    for (uint8 i = 0; i < BG_TEAMS_COUNT; ++i)    {        m_DroppedFlagGuid[i].Clear();        m_FlagState[i]       = BG_WS_FLAG_STATE_ON_BASE;        m_TeamScores[i]      = 0;    }    m_flagCarrierAlliance.Clear();    m_flagCarrierHorde.Clear();    bool isBGWeekend = BattleGroundMgr::IsBGWeekend(GetTypeID());    m_ReputationCapture = (isBGWeekend) ? 25 : 15;    m_HonorWinKills = (isBGWeekend) ? 3 : 1;    m_HonorEndKills = (isBGWeekend) ? 4 : 2;}

void BattleGround::EndNow(){    RemoveFromBGFreeSlotQueue();    SetStatus(STATUS_WAIT_LEAVE);    SetEndTime(TIME_TO_AUTOREMOVE);    // inform invited players about the removal    sBattleGroundMgr.m_BattleGroundQueues[BattleGroundMgr::BGQueueTypeId(GetTypeID())].BGEndedRemoveInvites(this);}

void BattleGround::RewardMark(Player *plr,uint32 count){    // 'Inactive' this aura prevents the player from gaining honor points and battleground tokens    if(plr->GetDummyAura(SPELL_AURA_PLAYER_INACTIVE))        return;    BattleGroundMarks mark;    bool IsSpell;    switch(GetTypeID())    {        case BATTLEGROUND_AV:            IsSpell = true;            if(count == ITEM_WINNER_COUNT)                mark = SPELL_AV_MARK_WINNER;            else                mark = SPELL_AV_MARK_LOSER;            break;        case BATTLEGROUND_WS:            IsSpell = true;            if(count == ITEM_WINNER_COUNT)                mark = SPELL_WS_MARK_WINNER;            else                mark = SPELL_WS_MARK_LOSER;            break;        case BATTLEGROUND_AB:            IsSpell = true;            if(count == ITEM_WINNER_COUNT)                mark = SPELL_AB_MARK_WINNER;            else                mark = SPELL_AB_MARK_LOSER;            break;/*        case BATTLEGROUND_EY:            IsSpell = false;            mark = ITEM_EY_MARK_OF_HONOR;            break;*/        default:            return;    }    if(IsSpell)        plr->CastSpell(plr, mark, true);    else if ( objmgr.GetItemPrototype( mark ) )    {        ItemPosCountVec dest;        uint32 no_space_count = 0;        uint8 msg = plr->CanStoreNewItem( NULL_BAG, NULL_SLOT, dest, mark, count, &no_space_count );        if( msg != EQUIP_ERR_OK )                       // convert to possible store amount            count -= no_space_count;        if( count != 0 && !dest.empty())                // can add some            if(Item* item = plr->StoreNewItem( dest, mark, true, 0))                plr->SendNewItem(item,count,false,true);        if(no_space_count > 0)            SendRewardMarkByMail(plr,mark,no_space_count);    }}

void BattlegroundIC::Reset(){    //call parent's class reset    Battleground::Reset();    m_TeamScores[BG_TEAM_ALLIANCE]          = 0;    m_TeamScores[BG_TEAM_HORDE]             = 0;    bool isBGWeekend = sBattlegroundMgr.IsBGWeekend(GetTypeID());}

uint32 BattleGround::GetBattlemasterEntry() const{    switch (GetTypeID())    {        case BATTLEGROUND_AV: return 15972;        case BATTLEGROUND_WS: return 14623;        case BATTLEGROUND_AB: return 14879;        default:              return 0;    }}

DwarfType::DwarfType(DwarfTypeContext* typeContext, const BString& name,	const DIEType* entry)	:	fTypeContext(typeContext),	fName(name),	fByteSize(0){	fTypeContext->AcquireReference();	GetTypeID(entry, fID);}

void BattleGroundAV::Reset(){    BattleGround::Reset();    // set the reputation and honor variables:    bool isBGWeekend = BattleGroundMgr::IsBGWeekend(GetTypeID());    m_HonorMapComplete    = (isBGWeekend) ? BG_AV_KILL_MAP_COMPLETE_HOLIDAY : BG_AV_KILL_MAP_COMPLETE;    m_RepTowerDestruction = (isBGWeekend) ? BG_AV_REP_TOWER_HOLIDAY         : BG_AV_REP_TOWER;    m_RepCaptain          = (isBGWeekend) ? BG_AV_REP_CAPTAIN_HOLIDAY       : BG_AV_REP_CAPTAIN;    m_RepBoss             = (isBGWeekend) ? BG_AV_REP_BOSS_HOLIDAY          : BG_AV_REP_BOSS;    m_RepOwnedGrave       = (isBGWeekend) ? BG_AV_REP_OWNED_GRAVE_HOLIDAY   : BG_AV_REP_OWNED_GRAVE;    m_RepSurviveCaptain   = (isBGWeekend) ? BG_AV_REP_SURVIVING_CAPTAIN_HOLIDAY : BG_AV_REP_SURVIVING_CAPTAIN;    m_RepSurviveTower     = (isBGWeekend) ? BG_AV_REP_SURVIVING_TOWER_HOLIDAY : BG_AV_REP_SURVIVING_TOWER;    m_RepOwnedMine        = (isBGWeekend) ? BG_AV_REP_OWNED_MINE_HOLIDAY    : BG_AV_REP_OWNED_MINE;    for (uint8 i = 0; i < BG_TEAMS_COUNT; i++)    {        for (uint8 j = 0; j < 9; j++)                        // 9 quests getting tracked            m_Team_QuestStatus[i][j] = 0;        m_TeamScores[i]         = BG_AV_SCORE_INITIAL_POINTS;        m_IsInformedNearLose[i] = false;        m_ActiveEvents[BG_AV_NodeEventCaptainDead_A + i] = BG_EVENT_NONE;    }    for (uint8 i = 0; i < BG_AV_MAX_MINES; i++)    {        m_Mine_Owner[i] = BG_AV_TEAM_NEUTRAL;        m_Mine_PrevOwner[i] = m_Mine_Owner[i];        m_ActiveEvents[BG_AV_MINE_BOSSES+ i] = BG_AV_TEAM_NEUTRAL;        m_ActiveEvents[BG_AV_MINE_EVENT + i] = BG_AV_TEAM_NEUTRAL;        m_Mine_Timer[i] = BG_AV_MINE_TICK_TIMER;    }    m_ActiveEvents[BG_AV_CAPTAIN_A] = 0;    m_ActiveEvents[BG_AV_CAPTAIN_H] = 0;    m_ActiveEvents[BG_AV_HERALD] = 0;    m_ActiveEvents[BG_AV_BOSS_A] = 0;    m_ActiveEvents[BG_AV_BOSS_H] = 0;    for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i)   // towers        m_ActiveEvents[BG_AV_MARSHAL_A_SOUTH + i - BG_AV_NODES_DUNBALDAR_SOUTH] = 0;    for (BG_AV_Nodes i = BG_AV_NODES_FIRSTAID_STATION; i <= BG_AV_NODES_STONEHEART_GRAVE; ++i)   // alliance graves        InitNode(i, BG_AV_TEAM_ALLIANCE, false);    for (BG_AV_Nodes i = BG_AV_NODES_DUNBALDAR_SOUTH; i <= BG_AV_NODES_STONEHEART_BUNKER; ++i)   // alliance towers        InitNode(i, BG_AV_TEAM_ALLIANCE, true);    for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_GRAVE; i <= BG_AV_NODES_FROSTWOLF_HUT; ++i)        // horde graves        InitNode(i, BG_AV_TEAM_HORDE, false);    for (BG_AV_Nodes i = BG_AV_NODES_ICEBLOOD_TOWER; i <= BG_AV_NODES_FROSTWOLF_WTOWER; ++i)     // horde towers        InitNode(i, BG_AV_TEAM_HORDE, true);    InitNode(BG_AV_NODES_SNOWFALL_GRAVE, BG_AV_TEAM_NEUTRAL, false);                            // give snowfall neutral owner}

void BattleGround::StartBattleGround(){    SetStartTime(0);    // add BG to free slot queue    AddToBGFreeSlotQueue();    // add bg to update list    // This must be done here, because we need to have already invited some players when first BG::Update() method is executed    // and it doesn't matter if we call StartBattleGround() more times, because m_BattleGrounds is a map and instance id never changes    sBattleGroundMgr.AddBattleGround(GetInstanceID(), GetTypeID(), this);}

BattleGround::~BattleGround(){    // remove objects and creatures    // (this is done automatically in mapmanager update, when the instance is reset after the reset time)    sBattleGroundMgr.RemoveBattleGround(GetInstanceID(), GetTypeID());    // skip template bgs as they were never added to visible bg list    BattleGroundBracketId bracketId = GetBracketId();    if (bracketId != BG_BRACKET_ID_TEMPLATE)        sBattleGroundMgr.DeleteClientVisibleInstanceId(GetTypeID(), bracketId, GetClientInstanceID());    // unload map    // map can be null at bg destruction    if (m_Map)        m_Map->SetUnload();    // remove from bg free slot queue    this->RemoveFromBGFreeSlotQueue();    for (BattleGroundScoreMap::const_iterator itr = m_PlayerScores.begin(); itr != m_PlayerScores.end(); ++itr)        delete itr->second;}

void BattleGround::PlayerAddedToBGCheckIfBGIsRunning(Player* plr){    if (GetStatus() != STATUS_WAIT_LEAVE)        return;    WorldPacket data;    BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(GetTypeID());    BlockMovement(plr);    sBattleGroundMgr.BuildPvpLogDataPacket(&data, this);    plr->GetSession()->SendPacket(&data);    sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetBattleGroundQueueIndex(bgQueueTypeId), STATUS_IN_PROGRESS, GetEndTime(), GetStartTime());    plr->GetSession()->SendPacket(&data);}

void BattlegroundKT::Reset(){    //call parent's class reset    Battleground::Reset();    BgObjects.resize(BG_KT_OBJECT_MAX);    BgCreatures.resize(BG_KT_CREATURE_MAX);    for(uint32 i = 0; i < MAX_ORBS; ++i)        m_OrbKeepers[i] = 0;    bool isBGWeekend = BattlegroundMgr::IsBGWeekend(GetTypeID());    m_ReputationCapture = (isBGWeekend) ? 45 : 35;    m_HonorWinKills = (isBGWeekend) ? 3 : 1;    m_HonorEndKills = (isBGWeekend) ? 4 : 2;    m_EndTimer = BG_KT_TIME_LIMIT;    m_LastCapturedOrbTeam = TEAM_NONE;}

Resource* ResourceManager::CreateResource(std::string resourceType, std::string resourceName){	auto facIt = m_FactoryFunctions.find(resourceType);	if (facIt == m_FactoryFunctions.end())	{		LOG_ERROR("Failed to load resource /"%s/" of type /"%s/": Type not registered", resourceName.c_str(), resourceType.c_str());		return nullptr;	}		// Call the factory function	Resource* resource = facIt->second(resourceName);	// Store IDs	resource->TypeID = GetTypeID(resourceType);	resource->ResourceID = GetNewResourceID(resource->TypeID);	// Cache	m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;	return resource;}

void BattleGroundWS::ResetBGSubclass(){    // spiritguides and flags not spawned at beginning    m_ActiveEvents[WS_EVENT_SPIRITGUIDES_SPAWN] = BG_EVENT_NONE;    m_ActiveEvents[WS_EVENT_FLAG_A] = BG_EVENT_NONE;    m_ActiveEvents[WS_EVENT_FLAG_H] = BG_EVENT_NONE;    for(uint32 i = 0; i < BG_TEAMS_COUNT; ++i)    {        m_DroppedFlagGUID[i] = 0;        m_FlagKeepers[i]     = 0;        m_FlagState[i]       = BG_WS_FLAG_STATE_ON_BASE;        m_TeamScores[i]      = 0;    }    bool isBGWeekend = sBattleGroundMgr.IsBGWeekend(GetTypeID());    m_ReputationCapture = (isBGWeekend) ? 25 : 15;    m_HonorWinKills = (isBGWeekend) ? 3 : 1;    m_HonorEndKills = (isBGWeekend) ? 4 : 2;}

void BattleGroundWS::EndBattleGround(Team winner){    if (BattleGroundMgr::IsBGWeekend(GetTypeID()))    {        if (winner == ALLIANCE)        {            RewardHonorToTeam(BG_WSG_WinMatchHonor_Holiday[GetBracketId()], ALLIANCE);            RewardHonorToTeam(BG_WSG_LoseMatchHonor_Holiday[GetBracketId()], HORDE);        }        if (winner == HORDE)        {            RewardHonorToTeam(BG_WSG_WinMatchHonor_Holiday[GetBracketId()], HORDE);            RewardHonorToTeam(BG_WSG_LoseMatchHonor_Holiday[GetBracketId()], ALLIANCE);        }    }    else        RewardHonorToTeam(BG_WSG_WinMatchHonor[GetBracketId()], winner);    BattleGround::EndBattleGround(winner);}

void BattlegroundWS::Reset(){    //call parent's class reset    Battleground::Reset();    m_FlagKeepers[BG_TEAM_ALLIANCE] = 0;    m_FlagKeepers[BG_TEAM_HORDE] = 0;    m_DroppedFlagGUID[BG_TEAM_ALLIANCE] = 0;    m_DroppedFlagGUID[BG_TEAM_HORDE] = 0;    _flagState[BG_TEAM_ALLIANCE] = BG_WS_FLAG_STATE_ON_BASE;    _flagState[BG_TEAM_HORDE] = BG_WS_FLAG_STATE_ON_BASE;    m_TeamScores[BG_TEAM_ALLIANCE] = 0;    m_TeamScores[BG_TEAM_HORDE] = 0;    if (sBattlegroundMgr->IsBGWeekend(GetTypeID()))    {        m_ReputationCapture = 45;        m_HonorWinKills = 3;        m_HonorEndKills = 4;    }    else    {        m_ReputationCapture = 35;        m_HonorWinKills = 1;        m_HonorEndKills = 2;    }    _minutesElapsed = 0;    _lastFlagCaptureTeam = 0;    _bothFlagsKept = false;    _flagDebuffState = 0;    _flagSpellForceTimer = 0;    _lastFlagCaptureTeam = 0;    _flagsDropTimer[BG_TEAM_ALLIANCE] = 0;    _flagsDropTimer[BG_TEAM_HORDE] = 0;    _flagsTimer[BG_TEAM_ALLIANCE] = 0;    _flagsTimer[BG_TEAM_HORDE] = 0;}

Resource* ResourceManager::cacheResource(Resource* resource, const std::string& resourceType, const std::string& resourceName, Resource* parent){    //Lock the mutex immediately, and unlock it when leaving the code block.    boost::lock_guard<decltype(m_Mutex)> guard(m_Mutex);    if (resource != nullptr) {        // Store IDs        resource->TypeID = GetTypeID(resourceType);        resource->ResourceID = GetNewResourceID(resource->TypeID);    }    // Cache    m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;    m_ResourceFromName[resourceName] = resource;    if (parent != nullptr) {        m_ResourceParents[resource] = parent;    }    //if (!boost::filesystem::is_directory(resourceName)) {    //    LOG_DEBUG("Adding watch for %s", resourceName.c_str());    //    m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);    //}    return resource;}

void BattleGroundEY::Reset(){    //call parent's class reset    BattleGround::Reset();    m_TeamScores[BG_TEAM_ALLIANCE] = 0;    m_TeamScores[BG_TEAM_HORDE] = 0;    m_TeamPointsCount[BG_TEAM_ALLIANCE] = 0;    m_TeamPointsCount[BG_TEAM_HORDE] = 0;    m_HonorScoreTics[BG_TEAM_ALLIANCE] = 0;    m_HonorScoreTics[BG_TEAM_HORDE] = 0;    m_ExperienceTics[BG_TEAM_ALLIANCE] = 0;    m_ExperienceTics[BG_TEAM_HORDE] = 0;    m_FlagState = BG_EY_FLAG_STATE_ON_BASE;    m_FlagKeeper = 0;    m_DroppedFlagGUID = 0;    m_PointAddingTimer = 0;    m_TowerCapCheckTimer = 0;    bool isBGWeekend = BattleGroundMgr::IsBGWeekend(GetTypeID());    m_HonorTics = (isBGWeekend) ? BG_EY_EYWeekendHonorTicks : BG_EY_NotEYWeekendHonorTicks;    for(uint8 i = 0; i < BG_EY_NODES_MAX; ++i)    {        m_PointOwnedByTeam[i] = EY_POINT_NO_OWNER;        m_PointState[i] = EY_POINT_STATE_UNCONTROLLED;        m_PointBarStatus[i] = BG_EY_PROGRESS_BAR_STATE_MIDDLE;        m_PlayersNearPoint[i].clear();        m_PlayersNearPoint[i].reserve(15);                  //tip size        m_ActiveEvents[i] = BG_EYE_NEUTRAL_TEAM;            // neutral team owns every node    }    // the flag in the middle is spawned at beginning    m_ActiveEvents[BG_EY_EVENT_CAPTURE_FLAG] = BG_EY_EVENT2_FLAG_CENTER;    m_PlayersNearPoint[BG_EY_PLAYERS_OUT_OF_POINTS].clear();    m_PlayersNearPoint[BG_EY_PLAYERS_OUT_OF_POINTS].reserve(30);}

void BattleGroundEY::Reset(){    // call parent's class reset    BattleGround::Reset();    m_TeamScores[TEAM_INDEX_ALLIANCE] = 0;    m_TeamScores[TEAM_INDEX_HORDE] = 0;    m_towersAlliance = 0;    m_towersHorde = 0;    m_honorTicks = BattleGroundMgr::IsBGWeekend(GetTypeID()) ? EY_WEEKEND_HONOR_INTERVAL : EY_NORMAL_HONOR_INTERVAL;    m_honorScoreTicks[TEAM_INDEX_ALLIANCE] = 0;    m_honorScoreTicks[TEAM_INDEX_HORDE] = 0;    m_flagState = EY_FLAG_STATE_ON_BASE;    m_flagCarrier.Clear();    m_DroppedFlagGuid.Clear();    m_flagRespawnTimer = 0;    m_resourceUpdateTimer = 0;    m_felReaverFlagTimer = 0;    m_towerWorldState[NODE_BLOOD_ELF_TOWER] = WORLD_STATE_EY_BLOOD_ELF_TOWER_NEUTRAL;    m_towerWorldState[NODE_FEL_REAVER_RUINS] = WORLD_STATE_EY_FEL_REAVER_RUINS_NEUTRAL;    m_towerWorldState[NODE_MAGE_TOWER] = WORLD_STATE_EY_MAGE_TOWER_NEUTRAL;    m_towerWorldState[NODE_DRAENEI_RUINS] = WORLD_STATE_EY_DRAENEI_RUINS_NEUTRAL;    for (uint8 i = 0; i < EY_NODES_MAX; ++i)    {        m_towerOwner[i] = TEAM_NONE;        m_ActiveEvents[i] = EY_NEUTRAL_TEAM;    }    // the flag in the middle is spawned at beginning    m_ActiveEvents[EY_EVENT_CAPTURE_FLAG] = EY_EVENT2_FLAG_CENTER;}

void BattlegroundBFG::Reset(){    // Call parent's class reset.    Battleground::Reset();    m_TeamScores[BG_TEAM_ALLIANCE]                = 0;    m_TeamScores[BG_TEAM_HORDE]                   = 0;    m_lastTick[BG_TEAM_ALLIANCE]                  = 0;    m_lastTick[BG_TEAM_HORDE]                     = 0;    m_HonorScoreTicks[BG_TEAM_ALLIANCE]           = 0;    m_HonorScoreTicks[BG_TEAM_HORDE]              = 0;    m_IsInformedNearVictory                       = false;    bool isBGWeekend                              = sBattlegroundMgr->IsBGWeekend(GetTypeID());    m_HonorTicks                                  = (isBGWeekend) ? GILNEAS_BG_BGWeekendHonorTicks : GILNEAS_BG_NotBGWeekendHonorTicks;    m_TeamScores500Disadvantage[BG_TEAM_ALLIANCE] = false;    m_TeamScores500Disadvantage[BG_TEAM_HORDE]    = false;    for (uint8 i = 0; i < GILNEAS_BG_DYNAMIC_NODES_COUNT; ++i)    {        m_Nodes[i]              = 0;        m_prevNodes[i]          = 0;        m_NodeTimers[i]         = 0;        m_BannerTimers[i].timer = 0;    }    for (uint8 i = 0; i < GILNEAS_BG_ALL_NODES_COUNT + 3; ++i)// +3 for Aura Triggers.        if (!BgCreatures.empty())            if (BgCreatures[i])                DelCreature(i);}

void BattleGround::RewardQuest(Player *plr){    // 'Inactive' this aura prevents the player from gaining honor points and battleground tokens    if(plr->GetDummyAura(SPELL_AURA_PLAYER_INACTIVE))        return;    uint32 quest;    switch(GetTypeID())    {        case BATTLEGROUND_AV:            quest = SPELL_AV_QUEST_REWARD;            break;        case BATTLEGROUND_WS:            quest = SPELL_WS_QUEST_REWARD;            break;        case BATTLEGROUND_AB:            quest = SPELL_AB_QUEST_REWARD;            break;        default:            return;    }    plr->CastSpell(plr, quest, true);}

/*important notice:buffs aren't spawned/despawned when players captures anythingbuffs are in their positions when battleground starts*/void BattleGround::HandleTriggerBuff(uint64 const& go_guid){    GameObject *obj = HashMapHolder<GameObject>::Find(go_guid);    if(!obj || obj->GetGoType() != GAMEOBJECT_TYPE_TRAP || !obj->isSpawned())        return;    //change buff type, when buff is used:    int32 index = m_BgObjects.size() - 1;    while (index >= 0 && m_BgObjects[index] != go_guid)        index--;    if (index < 0)    {        sLog.outError("BattleGround (Type: %u) has buff gameobject (Guid: %u Entry: %u Type:%u) but it hasn't that object in its internal data",GetTypeID(),GUID_LOPART(go_guid),obj->GetEntry(),obj->GetGoType());        return;    }    //randomly select new buff    uint8 buff = urand(0, 2);    uint32 entry = obj->GetEntry();    if( m_BuffChange && entry != Buff_Entries[buff] )    {        //despawn current buff        SpawnBGObject(index, RESPAWN_ONE_DAY);        //set index for new one        for (uint8 currBuffTypeIndex = 0; currBuffTypeIndex < 3; ++currBuffTypeIndex)            if( entry == Buff_Entries[currBuffTypeIndex] )            {                index -= currBuffTypeIndex;                index += buff;            }    }    SpawnBGObject(index, BUFF_RESPAWN_TIME);}

void BattleGround::RemovePlayerAtLeave(ObjectGuid guid, bool Transport, bool SendPacket){    Team team = GetPlayerTeam(guid);    bool participant = false;    // Remove from lists/maps    BattleGroundPlayerMap::iterator itr = m_Players.find(guid);    if (itr != m_Players.end())    {        UpdatePlayersCountByTeam(team, true);               // -1 player        m_Players.erase(itr);        // check if the player was a participant of the match, or only entered through gm command (goname)        participant = true;    }    BattleGroundScoreMap::iterator itr2 = m_PlayerScores.find(guid);    if (itr2 != m_PlayerScores.end())    {        delete itr2->second;                                // delete player's score        m_PlayerScores.erase(itr2);    }    Player* plr = sObjectMgr.GetPlayer(guid);    if (plr)    {        // should remove spirit of redemption        if (plr->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))            plr->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT);        if (!plr->isAlive())                                // resurrect on exit        {            plr->ResurrectPlayer(1.0f);            plr->SpawnCorpseBones();        }    }    RemovePlayer(plr, guid);                                // BG subclass specific code    if (participant) // if the player was a match participant, remove auras, calc rating, update queue    {        BattleGroundTypeId bgTypeId = GetTypeID();        BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(GetTypeID());        if (plr)        {            if (!team) team = plr->GetTeam();            if (SendPacket)            {                WorldPacket data;                sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetBattleGroundQueueIndex(bgQueueTypeId), STATUS_NONE, 0, 0);                plr->GetSession()->SendPacket(&data);            }            // this call is important, because player, when joins to battleground, this method is not called, so it must be called when leaving bg            plr->RemoveBattleGroundQueueId(bgQueueTypeId);        }        // remove from raid group if player is member        if (Group* group = GetBgRaid(team))        {            if (!group->RemoveMember(guid, 0))              // group was disbanded            {                SetBgRaid(team, NULL);                delete group;            }        }        DecreaseInvitedCount(team);        // we should update battleground queue, but only if bg isn't ending        if (GetStatus() < STATUS_WAIT_LEAVE)        {            // a player has left the battleground, so there are free slots -> add to queue            AddToBGFreeSlotQueue();            sBattleGroundMgr.ScheduleQueueUpdate(bgQueueTypeId, bgTypeId, GetBracketId());        }        // Let others know        WorldPacket data;        sBattleGroundMgr.BuildPlayerLeftBattleGroundPacket(&data, guid);        SendPacketToTeam(team, &data, plr, false);    }    if (plr)    {        // Do next only if found in battleground        plr->SetBattleGroundId(0, BATTLEGROUND_TYPE_NONE);  // We're not in BG.        // reset destination bg team        plr->SetBGTeam(TEAM_NONE);        if (Transport)            plr->TeleportToBGEntryPoint();        DETAIL_LOG("BATTLEGROUND: Removed player %s from BattleGround.", plr->GetName());    }    // battleground object will be deleted next BattleGround::Update() call}

void BattleGround::EndBattleGround(Team winner){    this->RemoveFromBGFreeSlotQueue();    uint32 loser_rating = 0;    uint32 winner_rating = 0;    WorldPacket data;    int32 winmsg_id = 0;    if (winner == ALLIANCE)    {        winmsg_id = LANG_BG_A_WINS;        PlaySoundToAll(SOUND_ALLIANCE_WINS);                // alliance wins sound    }    else if (winner == HORDE)    {        winmsg_id = LANG_BG_H_WINS;        PlaySoundToAll(SOUND_HORDE_WINS);                   // horde wins sound    }    SetWinner(winner);    SetStatus(STATUS_WAIT_LEAVE);    // we must set it this way, because end time is sent in packet!    m_EndTime = TIME_TO_AUTOREMOVE;    for (BattleGroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)    {        Team team = itr->second.PlayerTeam;        if (itr->second.OfflineRemoveTime)            continue;        Player* plr = sObjectMgr.GetPlayer(itr->first);        if (!plr)        {            sLog.outError("BattleGround:EndBattleGround %s not found!", itr->first.GetString().c_str());            continue;        }        // should remove spirit of redemption        if (plr->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))            plr->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT);        if (!plr->isAlive())        {            plr->ResurrectPlayer(1.0f);            plr->SpawnCorpseBones();        }        else        {            // needed cause else in av some creatures will kill the players at the end            plr->CombatStop();            plr->getHostileRefManager().deleteReferences();        }        // this line is obsolete - team is set ALWAYS        // if(!team) team = plr->GetTeam();        if (team == winner)        {            RewardMark(plr, ITEM_WINNER_COUNT);            RewardQuestComplete(plr);        }        else            RewardMark(plr, ITEM_LOSER_COUNT);        plr->CombatStopWithPets(true);        BlockMovement(plr);        sBattleGroundMgr.BuildPvpLogDataPacket(&data, this);        plr->GetSession()->SendPacket(&data);        BattleGroundQueueTypeId bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(GetTypeID());        sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetBattleGroundQueueIndex(bgQueueTypeId), STATUS_IN_PROGRESS, TIME_TO_AUTOREMOVE, GetStartTime());        plr->GetSession()->SendPacket(&data);    }    if (winmsg_id)        SendMessageToAll(winmsg_id, CHAT_MSG_BG_SYSTEM_NEUTRAL);}

void BattleGround::EndBattleGround(uint32 winner){    this->RemoveFromBGFreeSlotQueue();    uint32 almost_winning_team = HORDE;    uint32 loser_rating = 0;    uint32 winner_rating = 0;    WorldPacket data;    Player *Source = NULL;    const char *winmsg = "";    if(winner == ALLIANCE)    {        winmsg = GetTrinityString(LANG_BG_A_WINS);        PlaySoundToAll(SOUND_ALLIANCE_WINS);                // alliance wins sound        SetWinner(WINNER_ALLIANCE);    }    else if(winner == HORDE)    {        winmsg = GetTrinityString(LANG_BG_H_WINS);        PlaySoundToAll(SOUND_HORDE_WINS);                   // horde wins sound        SetWinner(WINNER_HORDE);    }    else    {        SetWinner(3);    }    SetStatus(STATUS_WAIT_LEAVE);    m_EndTime = 0;    for(std::map<uint64, BattleGroundPlayer>::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)    {        Player *plr = objmgr.GetPlayer(itr->first);        if(!plr)        {            sLog.outError("BattleGround: Player " I64FMTD " not found!", itr->first);            continue;        }        // should remove spirit of redemption        if(plr->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))            plr->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT);        if(!plr->isAlive())        {            plr->ResurrectPlayer(1.0f);            plr->SpawnCorpseBones();        }        uint32 team = itr->second.Team;        if(!team) team = plr->GetTeam();        if(team == winner)        {            if(!Source)                Source = plr;            RewardMark(plr,ITEM_WINNER_COUNT);            UpdatePlayerScore(plr, SCORE_BONUS_HONOR, 20);            RewardQuest(plr);        }        else if(winner !=0)        {        RewardMark(plr,ITEM_LOSER_COUNT);        }    else if(winner == 0)    {        if(sWorld.getConfig(CONFIG_PREMATURE_BG_REWARD))    // We're feeling generous, giving rewards to people who not earned them ;)        {    //nested ifs for the win! its boring writing that, forgive me my unfunniness                        if(almost_winning_team == team)                    //player's team had more points                RewardMark(plr,ITEM_WINNER_COUNT);            else                RewardMark(plr,ITEM_LOSER_COUNT);            // if scores were the same, each team gets 1 mark.        }    }        plr->CombatStopWithPets(true);        BlockMovement(plr);        sBattleGroundMgr.BuildPvpLogDataPacket(&data, this);        plr->GetSession()->SendPacket(&data);        uint32 bgQueueTypeId = sBattleGroundMgr.BGQueueTypeId(GetTypeID());        sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetTeam(), plr->GetBattleGroundQueueIndex(bgQueueTypeId), STATUS_IN_PROGRESS, TIME_TO_AUTOREMOVE, GetStartTime());        plr->GetSession()->SendPacket(&data);    }    // inform invited players about the removal    sBattleGroundMgr.m_BattleGroundQueues[sBattleGroundMgr.BGQueueTypeId(GetTypeID())].BGEndedRemoveInvites(this);    if(Source)    {        ChatHandler(Source).FillMessageData(&data, CHAT_MSG_BG_SYSTEM_NEUTRAL, LANG_UNIVERSAL, Source->GetGUID(), winmsg);        SendPacketToAll(&data);//.........这里部分代码省略.........

/*important notice:buffs aren't spawned/despawned when players captures anythingbuffs are in their positions when battleground starts*/void BattleGround::HandleTriggerBuff(uint64 const& go_guid){    GameObject *obj = GetBgMap()->GetGameObject(go_guid);    if (!obj || obj->GetGoType() != GAMEOBJECT_TYPE_TRAP || !obj->isSpawned())        return;    // static buffs are already handled just by database and don't need    // battleground code    if (!m_BuffChange)    {        obj->SetLootState(GO_JUST_DEACTIVATED);             // can be despawned or destroyed        return;    }    // change buff type, when buff is used:    // TODO this can be done when poolsystem works for instances    int32 index = m_BgObjects.size() - 1;    while (index >= 0 && m_BgObjects[index] != go_guid)        index--;    if (index < 0)    {        sLog.outError("BattleGround (Type: %u) has buff gameobject (Guid: %u Entry: %u Type:%u) but it hasn't that object in its internal data",GetTypeID(),GUID_LOPART(go_guid),obj->GetEntry(),obj->GetGoType());        return;    }    //randomly select new buff    uint8 buff = urand(0, 2);    uint32 entry = obj->GetEntry();    if (m_BuffChange && entry != Buff_Entries[buff])    {        //despawn current buff        SpawnBGObject(m_BgObjects[index], RESPAWN_ONE_DAY);        //set index for new one        for (uint8 currBuffTypeIndex = 0; currBuffTypeIndex < 3; ++currBuffTypeIndex)        {            if (entry == Buff_Entries[currBuffTypeIndex])            {                index -= currBuffTypeIndex;                index += buff;            }        }    }    SpawnBGObject(m_BgObjects[index], BUFF_RESPAWN_TIME);}

void BattleGround::RemovePlayerAtLeave(uint64 guid, bool Transport, bool SendPacket){    // Remove from lists/maps    std::map<uint64, BattleGroundPlayer>::iterator itr = m_Players.find(guid);    if(itr != m_Players.end())    {        UpdatePlayersCountByTeam(itr->second.Team, true);   // -1 player        m_Players.erase(itr);    }    std::map<uint64, BattleGroundScore*>::iterator itr2 = m_PlayerScores.find(guid);    if(itr2 != m_PlayerScores.end())    {        delete itr2->second;                                // delete player's score        m_PlayerScores.erase(itr2);    }    RemovePlayerFromResurrectQueue(guid);    Player *plr = objmgr.GetPlayer(guid);    if(plr && !plr->isAlive())                              // resurrect on exit    {        plr->ResurrectPlayer(1.0f);        plr->SpawnCorpseBones();    }    RemovePlayer(plr, guid);                                // BG subclass specific code    if(plr)    {        plr->ClearAfkReports();        if(isArena())        {            if(!sWorld.IsFFAPvPRealm())                plr->RemoveFlag(PLAYER_FLAGS, PLAYER_FLAGS_FFA_PVP);        }        WorldPacket data;        if(SendPacket)        {            sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetTeam(), plr->GetBattleGroundQueueIndex(m_TypeID), STATUS_NONE, 0, 0);            plr->GetSession()->SendPacket(&data);        }        // this call is important, because player, when joins to battleground, this method is not called, so it must be called when leaving bg        plr->RemoveBattleGroundQueueId(m_TypeID);        DecreaseInvitedCount(plr->GetTeam());        //we should update battleground queue, but only if bg isn't ending        if (GetQueueType() < MAX_BATTLEGROUND_QUEUES)            sBattleGroundMgr.m_BattleGroundQueues[GetTypeID()].Update(GetTypeID(), GetQueueType());        if(!plr->GetBattleGroundId())            return;        Group * group = plr->GetGroup();        // remove from raid group if exist        if(group && group == GetBgRaid(plr->GetTeam()))        {            if(!group->RemoveMember(guid, 0))               // group was disbanded            {                SetBgRaid(plr->GetTeam(), NULL);                delete group;            }        }        // Do next only if found in battleground        plr->SetBattleGroundId(0);                          // We're not in BG.        // Let others know        sBattleGroundMgr.BuildPlayerLeftBattleGroundPacket(&data, plr);        SendPacketToTeam(plr->GetTeam(), &data, plr, false);        if(Transport)        {            plr->TeleportTo(plr->GetBattleGroundEntryPointMap(), plr->GetBattleGroundEntryPointX(), plr->GetBattleGroundEntryPointY(), plr->GetBattleGroundEntryPointZ(), plr->GetBattleGroundEntryPointO());            //sLog.outDetail("BATTLEGROUND: Sending %s to %f,%f,%f,%f", pl->GetName(), x,y,z,O);        }        // Log        sLog.outDetail("BATTLEGROUND: Removed player %s from BattleGround.", plr->GetName());    }    /// there will be code which will add battleground to BGFreeSlotQueue , when battleground instance will exist    // we always should check if BG is in that queue before adding..    if(!GetPlayersSize())    {        Reset();    }}

void BattleGround::EndBattleGround(uint32 winner){    this->RemoveFromBGFreeSlotQueue();    uint32 loser_rating = 0;    uint32 winner_rating = 0;    WorldPacket data;    Player *Source = NULL;    const char *winmsg = "";    if(winner == ALLIANCE)    {        winmsg = GetMangosString(LANG_BG_A_WINS);        PlaySoundToAll(SOUND_ALLIANCE_WINS);                // alliance wins sound        SetWinner(WINNER_ALLIANCE);    }    else if(winner == HORDE)    {        winmsg = GetMangosString(LANG_BG_H_WINS);        PlaySoundToAll(SOUND_HORDE_WINS);                   // horde wins sound        SetWinner(WINNER_HORDE);    }    else    {        SetWinner(3);    }    SetStatus(STATUS_WAIT_LEAVE);    m_EndTime = 0;    for(std::map<uint64, BattleGroundPlayer>::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr)    {        Player *plr = sObjectMgr.GetPlayer(itr->first);        if(!plr)        {            sLog.outError("BattleGround: Player (GUID: %u) not found!", GUID_LOPART(itr->first));            continue;        }        // should remove spirit of redemption        if(plr->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))            plr->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT);        if(!plr->isAlive())        {            plr->ResurrectPlayer(1.0f);            plr->SpawnCorpseBones();        }        else        {            //needed cause else in av some creatures will kill the players at the end            plr->CombatStop();            plr->getHostileRefManager().deleteReferences();        }        uint32 team = itr->second.Team;        if(!team) team = plr->GetTeam();        if(team == winner)        {            if(!Source)                Source = plr;            RewardMark(plr,ITEM_WINNER_COUNT);            RewardQuestComplete(plr);        }        else            RewardMark(plr,ITEM_LOSER_COUNT);        plr->CombatStopWithPets(true);        BlockMovement(plr);        sBattleGroundMgr.BuildPvpLogDataPacket(&data, this);        plr->GetSession()->SendPacket(&data);        uint32 bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(GetTypeID());        sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, plr->GetTeam(), plr->GetBattleGroundQueueIndex(bgQueueTypeId), STATUS_IN_PROGRESS, TIME_TO_AUTOREMOVE, GetStartTime());        plr->GetSession()->SendPacket(&data);    }    // inform invited players about the removal    sBattleGroundMgr.m_BattleGroundQueues[BattleGroundMgr::BGQueueTypeId(GetTypeID())].BGEndedRemoveInvites(this);    if(Source)    {        ChatHandler(Source).FillMessageData(&data, CHAT_MSG_BG_SYSTEM_NEUTRAL, LANG_UNIVERSAL, Source->GetGUID(), winmsg);        SendPacketToAll(&data);    }}

void BattleGround::RemovePlayerAtLeave(uint64 guid, bool Transport, bool SendPacket){    uint32 team = GetPlayerTeam(guid);    bool participant = false;    // Remove from lists/maps    std::map<uint64, BattleGroundPlayer>::iterator itr = m_Players.find(guid);    if(itr != m_Players.end())    {        UpdatePlayersCountByTeam(team, true);   // -1 player        m_Players.erase(itr);        // check if the player was a participant of the match, or only entered through gm command (goname)        participant = true;    }    BattleGroundScoreMap::iterator itr2 = m_PlayerScores.find(guid);    if(itr2 != m_PlayerScores.end())    {        delete itr2->second;                                // delete player's score        m_PlayerScores.erase(itr2);    }    Player *plr = sObjectMgr.GetPlayer(guid);    // should remove spirit of redemption    if(plr && plr->HasAuraType(SPELL_AURA_SPIRIT_OF_REDEMPTION))        plr->RemoveSpellsCausingAura(SPELL_AURA_MOD_SHAPESHIFT);    if(plr && !plr->isAlive())                              // resurrect on exit    {        plr->ResurrectPlayer(1.0f);        plr->SpawnCorpseBones();    }    RemovePlayer(plr, guid);                                // BG subclass specific code    if(plr)    {        if(participant) // if the player was a match participant, remove auras, calc rating, update queue        {            if(!team) team = plr->GetTeam();            BattleGroundTypeId bgTypeId = GetTypeID();            uint32 bgQueueTypeId = BattleGroundMgr::BGQueueTypeId(GetTypeID());            WorldPacket data;            if(SendPacket)            {                sBattleGroundMgr.BuildBattleGroundStatusPacket(&data, this, team, plr->GetBattleGroundQueueIndex(bgQueueTypeId), STATUS_NONE, 0, 0);                plr->GetSession()->SendPacket(&data);            }            // this call is important, because player, when joins to battleground, this method is not called, so it must be called when leaving bg            plr->RemoveBattleGroundQueueId(bgQueueTypeId);            DecreaseInvitedCount(team);            //we should update battleground queue, but only if bg isn't ending            if (GetBracketId() < MAX_BATTLEGROUND_BRACKETS)                sBattleGroundMgr.m_BattleGroundQueues[bgQueueTypeId].Update(bgTypeId, GetBracketId());            Group * group = plr->GetGroup();            // remove from raid group if exist            if(group && group == GetBgRaid(team))            {                if(!group->RemoveMember(guid, 0))               // group was disbanded                {                    SetBgRaid(team, NULL);                    delete group;                }            }            // Let others know            sBattleGroundMgr.BuildPlayerLeftBattleGroundPacket(&data, plr);            SendPacketToTeam(team, &data, plr, false);        }        // Do next only if found in battleground        plr->SetBattleGroundId(0);                          // We're not in BG.        // reset destination bg team        plr->SetBGTeam(0);        if(Transport)            plr->TeleportTo(plr->GetBattleGroundEntryPoint());        DETAIL_LOG("BATTLEGROUND: Removed player %s from BattleGround.", plr->GetName());    }    if(!GetPlayersSize() && !GetInvitedCount(HORDE) && !GetInvitedCount(ALLIANCE))    {        // if no players left AND no invitees left, set this bg to delete in next update        // direct deletion could cause crashes        m_SetDeleteThis = true;        // return to prevent addition to freeslotqueue        return;    }    // a player exited the battleground, so there are free slots. add to queue    this->AddToBGFreeSlotQueue();}