C++ InvitePlayerToQueue函数代码示例

// Called when a player enters the zone
void Battlefield::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
{
    // If battle is started,
    // If not full of players > invite player to join the war
    // If full of players > announce to player that BF is full and kick him after a few second if he desn't leave
    if (IsWarTime())
    {
        if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer) // Vacant spaces
            InvitePlayerToWar(player);
        else // No more vacant places
        {
            /// @todo Send a packet to announce it to player
            m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
            InvitePlayerToQueue(player);
        }
    }
    else
    {
        // If time left is < 15 minutes invite player to join queue
        if (m_Timer <= m_StartGroupingTimer)
            InvitePlayerToQueue(player);
    }

    // Add player in the list of player in zone
    m_players[player->GetTeamId()].insert(player->GetGUID());
    OnPlayerEnterZone(player);
}

void Battlefield::HandlePlayerEnterZone(Player* player, uint32 /*zone*/)
{
    // If battle is start,
    //   if it not fully > invite player to join the war
    //   if it fully > announce to player that BF is full and kick after few second if he dont leave
    if (IsWarTime())
    {
        if (m_PlayersInWar[player->GetTeamId()].size() + m_InvitedPlayers[player->GetTeamId()].size() < m_MaxPlayer)  //Not fully
            InvitePlayerToWar(player);
        else                                                //Full
        {
            //TODO:Send packet for announce it to player
            m_PlayersWillBeKick[player->GetTeamId()][player->GetGUID()] = time(NULL) + 10;
            InvitePlayerToQueue(player);
        }
    }
    else
    {
        //If time left is <15 minutes invite player to join queue
        if (m_Timer <= m_StartGroupingTimer)
            InvitePlayerToQueue(player);
    }

    //Add player in list of player in zone
    m_players[player->GetTeamId()].insert(player->GetGUID());
    OnPlayerEnterZone(player);                                 //for scripting
}

void Battlefield::InvitePlayersInZoneToQueue()
{
    for (uint8 team = 0; team < 2; ++team)
        for (GuidSet::const_iterator itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                InvitePlayerToQueue(player);
}

void Battlefield::InvitePlayersInZoneToQueue()
{
    for (uint8 team = 0; team < BG_TEAMS_COUNT; ++team)
        for (auto itr = m_players[team].begin(); itr != m_players[team].end(); ++itr)
            if (Player* player = ObjectAccessor::FindPlayer(*itr))
                InvitePlayerToQueue(player);
}

/**
  Function that adds a player to the players of the affected battlefield zones

  @param   player to add
  @param   whether zone is main outdoor pvp zone or a affected zone
*/
void Battlefield::HandlePlayerEnterZone(Player* player, bool isMainZone)
{
    OutdoorPvP::HandlePlayerEnterZone(player, isMainZone);

    // invite to group or queue
    if (!HasPlayer(player->GetObjectGuid()))
    {
        if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS)
        {
            m_invitedPlayers[GetTeamIndexByTeamId(player->GetTeam())][player->GetObjectGuid()] = time(nullptr) + BF_TIME_TO_ACCEPT;
            player->GetSession()->SendBattlefieldWarInvite(m_battleFieldId, m_zoneId, BF_TIME_TO_ACCEPT);
        }
        else if (GetBattlefieldStatus() == BF_STATUS_COOLDOWN && m_timer < m_startInviteDelay)
            InvitePlayerToQueue(player);
    }

    // check if player is already marked as active
    BattlefieldPlayerDataMap::iterator itr = m_activePlayers.find(player->GetObjectGuid());
    if (itr == m_activePlayers.end())
        InitPlayerBattlefieldData(player);
    else
    {
        if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS && itr->second->removeTime && m_startTime > itr->second->removeTime)
            SetupPlayerPosition(player);

        itr->second->removeTime = 0;
    }
}

/**
  Battlefield update function
*/
void Battlefield::Update(uint32 diff)
{
    // update battlefield timer to everyone
    SendBattlefieldTimerUpdate();

    // global battlefield timer
    if (m_timer < diff)
    {
        if (m_status == BF_STATUS_COOLDOWN)
            StartBattle(m_zoneOwner);
        else if (m_status == BF_STATUS_IN_PROGRESS)
            EndBattle(m_zoneOwner);
    }
    else
        m_timer -= diff;

    // refresh battlefield players
    if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS)
    {
        if (m_playersUpdateTimer < diff)
        {
            UpdateBattlefieldPlayers();
            m_playersUpdateTimer = 5000;
        }
        else
            m_playersUpdateTimer -= diff;
    }

    // invite all players in zone to queue
    if (GetBattlefieldStatus() == BF_STATUS_COOLDOWN && m_timer <= m_startInviteDelay && !m_playersInvited)
    {
        m_playersInvited = true;
        for (auto& m_zonePlayer : m_zonePlayers)
        {
            if (!m_zonePlayer.first)
                continue;

            Player* player = sObjectMgr.GetPlayer(m_zonePlayer.first);
            if (!player)
                continue;

            InvitePlayerToQueue(player);
        }
    }

    // kick all the players marked to leave
    if (GetBattlefieldStatus() == BF_STATUS_IN_PROGRESS)
    {
        for (auto& m_invitedPlayer : m_invitedPlayers)
        {
            for (std::map<ObjectGuid, time_t>::iterator itr = m_invitedPlayer.begin(); itr != m_invitedPlayer.end();)
            {
                if (itr->second < time(nullptr))
                {
                    if (Player* player = sObjectMgr.GetPlayer(itr->first))
                        player->GetSession()->SendBattlefieldLeaveMessage(m_battleFieldId, BATTLEFIELD_LEAVE_REASON_EXITED);

                    m_invitedPlayer.erase(itr++);
                }
                else
                    ++itr;
            }
        }
    }

    // check the queued players
    if (m_queueUpdateTimer < diff)
    {
        m_queueUpdateTimer = 30000;

        for (auto& m_queuedPlayer : m_queuedPlayers)
        {
            for (std::set<ObjectGuid>::iterator itr = m_queuedPlayer.begin(); itr != m_queuedPlayer.end();)
            {
                if (!sObjectMgr.GetPlayer(*itr, true))
                    m_queuedPlayer.erase(itr++);
                else
                    ++itr;
            }
        }
    }
    else
        m_queueUpdateTimer -= diff;
}