C++ CClientPed类代码示例

void CClientPedManager::RestreamPeds ( unsigned short usModel )
{
    // Store the affected vehicles
    CClientPed* pPed;
    std::vector < CClientPed* > ::const_iterator iter = IterBegin ();
    for ( ; iter != IterEnd (); iter++ )
    {
        pPed = *iter;

        // Streamed in and same vehicle ID?
        if ( pPed->IsStreamedIn () && pPed->GetModel () == usModel )
        {
            // Stream it out for a while until streamed decides to stream it
            // back in eventually
            pPed->StreamOutForABit ();
            // Hack fix for Players not unloading.
            if ( IS_PLAYER ( pPed ) )
            {
                // Awesome hack skills + 1, change him to another model while we unload for the lulz
                // Translation: My hack level has increased to ninety eight and we need to wait a frame before reloading the model ID in question so that the custom model unloads properly.
                // To do this we set him to CJ (Impossible to mod to my knowledge) and then set him back in CPed::StreamedInPulse
                pPed->SetModel ( 0, true );
            }
        }
    }
}

void CElementRPCs::SetElementHealth ( NetBitStreamInterface& bitStream )
{
    ElementID ID;
    float fHealth;
    unsigned char ucTimeContext;
    if ( bitStream.Read ( ID ) &&
         bitStream.Read ( fHealth ) &&
         bitStream.Read ( ucTimeContext ) )
    {
        CClientEntity * pEntity = CElementIDs::GetElement ( ID );
        if ( pEntity )
        {
            pEntity->SetSyncTimeContext ( ucTimeContext );

            switch ( pEntity->GetType () )
            {
                case CCLIENTPED:
                case CCLIENTPLAYER:
                {
                    CClientPed* pPed = static_cast < CClientPed * > ( pEntity );                    
                    pPed->SetHealth ( fHealth );
                    break;
                }

                case CCLIENTVEHICLE:
                {
                    CClientVehicle* pVehicle = static_cast < CClientVehicle * > ( pEntity );
                    pVehicle->SetHealth ( fHealth );
                    break;
                }
            }
        }
    }
}

void CElementRPCs::SetElementCollisionsEnabled ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    bool bEnable;

    if ( bitStream.ReadBit ( bEnable ) )
    {
        switch ( pSource->GetType () )
        {
            case CCLIENTPED:
            case CCLIENTPLAYER:
            {
                CClientPed* pPed = static_cast < CClientPed * > ( pSource );
                pPed->SetUsesCollision ( bEnable );
                break;
            }

            case CCLIENTVEHICLE:
            {
                CClientVehicle* pVehicle = static_cast < CClientVehicle * > ( pSource );
                pVehicle->SetCollisionEnabled ( bEnable );
                break;
            }

            case CCLIENTOBJECT:
            {
                CClientObject* pObject = static_cast < CClientObject * > ( pSource );
                pObject->SetCollisionEnabled ( bEnable );
                break;
            }
        }
    }
}

CClientPed* CClientPedManager::Get ( CPlayerPed* pPlayer, bool bValidatePointer, bool bCheckPlayers )
{
    if ( !pPlayer ) return NULL;

    if ( bValidatePointer )
    {
        vector < CClientPed* > ::const_iterator iter = m_StreamedIn.begin ();
        for ( ; iter != m_StreamedIn.end (); iter++ )
        {
            if ( (*iter)->GetGamePlayer () == pPlayer )
            {
                return *iter;
            }
        }
    }
    else
    {
        CClientPed* pPed = reinterpret_cast < CClientPed* > ( pPlayer->GetStoredPointer () );
        if ( pPed->GetType () == CCLIENTPED || bCheckPlayers )
        {
            return pPed;
        }
    }
    return NULL;
}

CClientPlayer* CClientPlayerManager::Get ( CPlayerPed* pPlayer, bool bValidatePointer )
{
    if ( !pPlayer ) return NULL;

    if ( bValidatePointer )
    {
        vector < CClientPlayer* > ::const_iterator iter = m_Players.begin ();
        for ( ; iter != m_Players.end () ; iter++ )
        {
            if ( (*iter)->GetGamePlayer () == pPlayer )
            {
                return *iter;
            }
        }
    }
    else
    {
        CClientPed* pPed = reinterpret_cast < CClientPed* > ( pPlayer->GetStoredPointer () );
        if ( pPed->GetType () == CCLIENTPLAYER )
        {
            return static_cast < CClientPlayer * > ( pPed );
        }
    }

    return NULL;
}

void CPedRPCs::SetPedRotation ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    SPedRotationSync rotation;
    unsigned char ucTimeContext;
    if ( bitStream.Read ( &rotation ) &&
         bitStream.Read ( ucTimeContext ) )
    {
        uchar ucNewWay = 0;
        if ( bitStream.GetNumberOfBytesUsed () > 0 )
            bitStream.Read ( ucNewWay );

        CClientPed* pPed = m_pPedManager->Get ( pSource->GetID (), true );
        if ( pPed )
        {
            if ( ucNewWay == 1 )
                pPed->SetCurrentRotationNew ( rotation.data.fRotation );
            else
                pPed->SetCurrentRotation ( rotation.data.fRotation );

            if ( !IS_PLAYER ( pPed ) )
                pPed->SetCameraRotation ( rotation.data.fRotation );
            pPed->SetSyncTimeContext ( ucTimeContext );
        }
    }
}

void CWeaponRPCs::TakeWeapon ( NetBitStreamInterface& bitStream )
{
    // Read out weapon id and ammo amount
    ElementID ID;
    SWeaponTypeSync weaponType;

    if ( bitStream.ReadCompressed ( ID ) &&
         bitStream.Read ( &weaponType )  )
    {
        unsigned char ucWeaponID = weaponType.data.ucWeaponType;

        CClientPed * pPed = m_pPedManager->Get ( ID, true );
        if ( pPed )
        {
            // Don't change remote players weapons (affects sync)
            if ( pPed->GetType () == CCLIENTPED || ( CClientPlayer * ) pPed == m_pPlayerManager->GetLocalPlayer () )
            {
                // Is the weapon id valid? (may not be neccessary, just being safe)
                if ( CClientPickupManager::IsValidWeaponID ( ucWeaponID ) )
                {
                    // Remove the weapon
                    pPed->RemoveWeapon ( static_cast < eWeaponType > ( ucWeaponID ) );
                }
            }
        }
    }
}

void CPedRPCs::SetPedAnimationProgress ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    // Read out the player and vehicle id
    char szAnimName [ 64 ];
    unsigned char ucAnimSize;
    float fProgress;

    if ( bitStream.Read ( ucAnimSize ) )
    {
        // Grab the ped
        CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
        if ( pPed )
        {
            if ( ucAnimSize > 0 )
            {
                if ( bitStream.Read ( szAnimName, ucAnimSize ) )
                {
                    szAnimName [ ucAnimSize ] = 0;
                    if ( bitStream.Read ( fProgress ) )
                    {
                        CAnimBlendAssociation* pA = g_pGame->GetAnimManager ()->RpAnimBlendClumpGetAssociation ( pPed->GetClump (), szAnimName );
                        if ( pA )
                        {
                            pA->SetCurrentProgress ( fProgress );
                        }
                    }
                }
            }
            else
            {
                pPed->KillAnimation ();
            }
        }
    }
}

void CPedRPCs::WarpPedIntoVehicle ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    // Read out the player and vehicle id
    ElementID VehicleID;
    unsigned char ucSeat;
    unsigned char ucTimeContext;
    if ( bitStream.Read ( VehicleID ) &&
         bitStream.Read ( ucSeat ) &&
         bitStream.Read ( ucTimeContext ) )
    {
        // Grab the ped
        CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
        if ( pPed )
        {
            pPed->SetSyncTimeContext ( ucTimeContext );

            // Grab the vehicle
            CClientVehicle* pVehicle = m_pVehicleManager->Get ( VehicleID );
            if ( pVehicle )
            {
                CStaticFunctionDefinitions::WarpPedIntoVehicle ( pPed, pVehicle, ucSeat );
            }
        }
    }
}

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

        if (usModelId < 7 || usModelId > 312)
            continue;

        // Check if currently within distance
        {
            // Check distance
            CVector vecPosition;
            pPed->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;
            }
        }

        // Check if will be within distance soon
        {
            // Extrapolate position for 2 seconds time
            ulong ulSyncAge = 0;
            if (ulSyncAge < 8000)
            {
                // Get velocity
                CVector vecVelocity;
                pPed->GetMoveSpeed(vecVelocity);
                vecVelocity *= m_fGameFps;

                // Extrapolate position for 2 seconds time
                float   fSecondsToAdd = std::min(6000UL, ulSyncAge + 2000) * 0.001f;
                CVector vecPosition;
                pPed->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, PURESYNC_TYPE_NONE, usModelId, vecPosition, vecNewPosition);
                    continue;
                }
                AddProcessStat("n", false, PURESYNC_TYPE_NONE, usModelId, vecPosition, vecNewPosition);
                continue;
            }
        }
    }
}

void CPedRPCs::ReloadPedWeapon ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    CClientPed* pPed = m_pPedManager->Get ( pSource->GetID (), true );
    if ( pPed )
    {
        pPed->ReloadWeapon ();            
    }
}

void CPedRPCs::RemovePedJetPack ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
    if ( pPed )
    {
        pPed->SetHasJetPack ( false );
    }
}

void CWeaponRPCs::TakeAllWeapons ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
    if ( pPed )
    {
        // Remove all our weapons
        pPed->RemoveAllWeapons ();
    }
}

int CLuaOOPDefs::SetPedOccupiedVehicle ( lua_State* luaVM )
{
    //  ped.vehicle = element vehicle
    //  ped.vehicle = nil
    CClientPed* pPed;
    CClientVehicle* pVehicle;
    uint uiSeat = 0;

    CScriptArgReader argStream ( luaVM );

    argStream.ReadUserData ( pPed );
    argStream.ReadUserData ( pVehicle, NULL );
    if ( pVehicle != NULL )
    {
        MinClientReqCheck ( argStream, MIN_CLIENT_REQ_WARPPEDINTOVEHICLE_CLIENTSIDE, "function is being called client side" );
        if ( !argStream.HasErrors () )
        {
            if ( !pPed->IsLocalEntity () || !pVehicle->IsLocalEntity () )
                argStream.SetCustomError ( "This client side function will only work with client created peds and vehicles" );
        }

        if ( !argStream.HasErrors () )
        {
            if ( CStaticFunctionDefinitions::WarpPedIntoVehicle ( pPed, pVehicle, uiSeat ) )
            {
                lua_pushboolean ( luaVM, true );
                return 1;
            }
        }
        else
            m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
    }
    else
    {
        if ( !argStream.HasErrors () )
        {
            if ( !pPed->IsLocalEntity ()  )
                argStream.SetCustomError ( "This client side function will only work with client created peds" );
        }

        if ( !argStream.HasErrors () )
        {
            if ( CStaticFunctionDefinitions::RemovePedFromVehicle ( pPed ) )
            {
                lua_pushboolean ( luaVM, true );
                return 1;
            }
        }
        else
            m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
    }

    lua_pushboolean ( luaVM, false );

    return 1;
}

void CWeaponRPCs::TakeWeapon ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
    // Read out weapon id and ammo amount
    SWeaponTypeSync weaponType;

    if ( bitStream.Read ( &weaponType )  )
    {
        unsigned char ucWeaponID = weaponType.data.ucWeaponType;

        CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
        if ( pPed )
        {
            // Is the weapon id valid? (may not be neccessary, just being safe)
            if ( CClientPickupManager::IsValidWeaponID ( ucWeaponID ) )
            {
                // Have we ammo in packet? If so, we need to take the ammo, not weapon
                SWeaponAmmoSync ammo ( ucWeaponID, true, false );
                if ( bitStream.Read ( &ammo ) )
                {
                    unsigned short usAmmo = ammo.data.usTotalAmmo;

                    // Do we have the weapon?
                    CWeapon* pPlayerWeapon = pPed->GetWeapon ( (eWeaponType) ucWeaponID );
                    if ( pPlayerWeapon == NULL ) return;

                    unsigned char ucAmmoInClip = static_cast < unsigned char > ( pPlayerWeapon->GetAmmoInClip () );
                    pPlayerWeapon->SetAmmoInClip ( 0 );

                    unsigned long ulWeaponAmmo = pPlayerWeapon->GetAmmoTotal ();
                    if ( usAmmo > ulWeaponAmmo )
                        ulWeaponAmmo = 0;
                    else
                        ulWeaponAmmo -= usAmmo;

                    // Update the ammo
                    pPlayerWeapon->SetAmmoTotal ( ulWeaponAmmo );

                    if ( pPlayerWeapon->GetAmmoTotal () > ucAmmoInClip )
                        pPlayerWeapon->SetAmmoInClip ( ucAmmoInClip );
                    else if ( pPlayerWeapon->GetAmmoTotal () <= ucAmmoInClip )
                        pPlayerWeapon->SetAmmoInClip ( pPlayerWeapon->GetAmmoTotal () );
                }
                else
                {
                    // Don't change remote players weapons (affects sync)
                    if ( pPed->IsLocalPlayer () )
                    {
                        // Remove the weapon
                        pPed->RemoveWeapon ( static_cast < eWeaponType > ( ucWeaponID ) );
                    }
                }
            }
        }
    }
}