C++ CClientPlayer::GetLastPuresyncType方法代码示例

void CClientStreamer::Restream ( bool bMovedFar )
{
    // Limit distance stream in/out rate
    // Vehicles might have to ignore this to reduce blocking loads elsewhere.
    int iMaxOut = 6;
    int iMaxIn = 6;
    if ( bMovedFar )
    {
        iMaxOut = 1000;
        iMaxIn = 1000;
    }

    // Do we have any elements waiting to be streamed out?
    while ( !m_ToStreamOut.empty () )
    {
        CClientStreamElement* pElement = m_ToStreamOut.front ();
        // Make sure we have no stream-references
        if ( pElement->GetTotalStreamReferences () == 0 )
        {
            // Stream out 1 of them per frame
            pElement->InternalStreamOut ();
            iMaxOut--;
        }
        m_ToStreamOut.remove ( pElement );

        if ( iMaxOut <= 0 )
            break;
    }

    static std::vector < CClientStreamElement* > ClosestStreamedOutList;
    static std::vector < CClientStreamElement* > FurthestStreamedInList;
    ClosestStreamedOutList.clear();
    FurthestStreamedInList.clear();

    bool bReachedLimit = ReachedLimit ();
    // Loop through our active elements list (they should be ordered closest to furthest)
    list < CClientStreamElement* > ::iterator iter = m_ActiveElements.begin ();
    for ( ; iter != m_ActiveElements.end (); iter++ )
    {
        CClientStreamElement* pElement = *iter;
        float fElementDistanceExp = pElement->GetExpDistance ();
        
        // Is this element streamed in?
        if ( pElement->IsStreamedIn () )
        {                
            if ( IS_VEHICLE ( pElement ) )
            {
                CClientVehicle* pVehicle = DynamicCast < CClientVehicle > ( pElement );
                if ( pVehicle )
                {
                    if ( pVehicle->GetOccupant ( ) && IS_PLAYER ( pVehicle->GetOccupant ( ) ) )
                    {
                        CClientPlayer* pPlayer = DynamicCast < CClientPlayer > ( pVehicle->GetOccupant ( ) );
                        if ( pPlayer->GetLastPuresyncType ( ) == PURESYNC_TYPE_LIGHTSYNC )
                        {
                            // if the last packet was ls he shouldn't be streamed in
                            m_ToStreamOut.push_back ( pElement );
                        }
                    }

                    // Is this a trailer?
                    if ( pVehicle->GetTowedByVehicle ( ) != NULL )
                    {
                        // Don't stream it out (this is handled by the towing vehicle)
                        continue;
                    }
                }
            }
            if ( IS_PLAYER ( pElement ) )
            {
                CClientPlayer* pPlayer = DynamicCast < CClientPlayer > ( pElement );
                if ( pPlayer->GetLastPuresyncType ( ) == PURESYNC_TYPE_LIGHTSYNC )
                {
                    // if the last packet was ls he isn't/shouldn't be streamed in
                    m_ToStreamOut.push_back ( pElement );
                }
            }
            // Too far away? Use the threshold so we won't flicker load it if it's on the border moving.
            if ( fElementDistanceExp > m_fMaxDistanceThreshold )
            {
                // Unstream it now?
                if ( iMaxOut > 0 )
                {
                    // Make sure we have no stream-references
                    if ( pElement->GetTotalStreamReferences () == 0 )
                    {
                        // Stream out now
                        pElement->InternalStreamOut ();
                        iMaxOut--;
                    }
                    m_ToStreamOut.remove ( pElement );
                }
                else
                {
                    // or later
                    m_ToStreamOut.push_back ( pElement );
                }
            }
            else
            {
//.........这里部分代码省略.........

///////////////////////////////////////////////////////////////
//
// CClientModelCacheManagerImpl::ProcessVehicleList
//
///////////////////////////////////////////////////////////////
void CClientModelCacheManagerImpl::ProcessVehicleList(std::map<ushort, float>& outNeedCacheList, const std::vector<CClientVehicle*>& vehicleList,
                                                      float fMaxStreamDistanceSq)
{
    const ulong ulTimeNow = CClientTime::GetTime();
    for (std::vector<CClientVehicle*>::const_iterator iter = vehicleList.begin(); iter != vehicleList.end(); ++iter)
    {
        CClientVehicle* pVehicle = *iter;
        const ushort    usModelId = pVehicle->GetModel();

        if (usModelId < 400 || usModelId > 611)
            continue;

        // Check if currently within distance
        {
            // Check distance
            CVector vecPosition;
            pVehicle->GetPosition(vecPosition);
            float fDistSq = (m_vecCameraPos - vecPosition).LengthSquared();
            if (fDistSq < fMaxStreamDistanceSq)
            {
                // Add model to needed list
                InsertIntoNeedCacheList(outNeedCacheList, usModelId, fDistSq);
                AddProcessStat("p", true, PURESYNC_TYPE_NONE, usModelId, vecPosition, vecPosition);
                continue;
            }
        }

        CClientPlayer* pDriver = DynamicCast<CClientPlayer>(pVehicle->GetControllingPlayer());
        if (!pDriver)
            continue;

        // Check if will be within distance soon
        ePuresyncType syncType = pDriver->GetLastPuresyncType();
        if (syncType == PURESYNC_TYPE_PURESYNC || syncType == PURESYNC_TYPE_LIGHTSYNC)
        {
            ulong ulSyncAge = ulTimeNow - pDriver->GetLastPuresyncTime();
            if (ulSyncAge < 8000)
            {
                // Get velocity from somewhere
                CVector vecVelocity;
                if (syncType == PURESYNC_TYPE_LIGHTSYNC)
                    vecVelocity = pDriver->GetLightsyncCalcedVelocity();
                else
                {
                    pVehicle->GetMoveSpeed(vecVelocity);
                    vecVelocity *= m_fGameFps;
                }

                // Extrapolate position for 2 seconds time
                float   fSecondsToAdd = std::min(6000UL, ulSyncAge + 2000) * 0.001f;
                CVector vecPosition;
                pVehicle->GetPosition(vecPosition);
                CVector vecNewPosition = vecPosition + vecVelocity * fSecondsToAdd;

                // Check distance
                float fDistSq = (m_vecCameraPos - vecNewPosition).LengthSquared();
                if (fDistSq < fMaxStreamDistanceSq)
                {
                    // Add model to needed list
                    InsertIntoNeedCacheList(outNeedCacheList, usModelId, fDistSq);
                    AddProcessStat("l", true, syncType, usModelId, vecPosition, vecNewPosition);
                    continue;
                }
                AddProcessStat("n", false, syncType, usModelId, vecPosition, vecNewPosition);
                continue;
            }
        }
    }
}