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;
}
void CElementRPCs::SetElementAlpha ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
unsigned char ucAlpha;
if ( bitStream.Read ( ucAlpha ) )
{
switch ( pSource->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed* > ( pSource );
pPed->SetAlpha ( ucAlpha );
break;
}
case CCLIENTVEHICLE:
{
CClientVehicle* pVehicle = static_cast < CClientVehicle* > ( pSource );
pVehicle->SetAlpha ( ucAlpha );
break;
}
case CCLIENTOBJECT:
case CCLIENTWEAPON:
{
CClientObject * pObject = static_cast < CClientObject* > ( pSource );
pObject->SetAlpha ( ucAlpha );
break;
}
default: break;
}
}
}
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 CElementRPCs::SetElementAlpha ( NetBitStreamInterface& bitStream )
{
ElementID ID;
unsigned char ucAlpha;
if ( bitStream.Read ( ID ) && bitStream.Read ( ucAlpha ) )
{
CClientEntity* pEntity = CElementIDs::GetElement ( ID );
if ( pEntity )
{
switch ( pEntity->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed* > ( pEntity );
pPed->SetAlpha ( ucAlpha );
break;
}
case CCLIENTVEHICLE:
{
CClientVehicle* pVehicle = static_cast < CClientVehicle* > ( pEntity );
pVehicle->SetAlpha ( ucAlpha );
break;
}
case CCLIENTOBJECT:
{
CClientObject * pObject = static_cast < CClientObject* > ( pEntity );
pObject->SetAlpha ( ucAlpha );
break;
}
default: break;
}
}
}
}
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 );
}
}
}
}
void CElementRPCs::SetElementFrozen ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
bool bFrozen;
if ( bitStream.ReadBit ( bFrozen ) )
{
switch ( pSource->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed * > ( pSource );
pPed->SetFrozen ( bFrozen );
break;
}
case CCLIENTVEHICLE:
{
CClientVehicle* pVehicle = static_cast < CClientVehicle * > ( pSource );
pVehicle->SetFrozen ( bFrozen );
break;
}
case CCLIENTOBJECT:
{
CClientObject* pObject = static_cast < CClientObject * > ( pSource );
pObject->SetStatic ( bFrozen );
break;
}
}
}
}
///////////////////////////////////////////////////////////////
//
// 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 ) );
}
}
}
}
}
}
void CPedRPCs::SetPedMoveAnim ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
unsigned int uiMoveAnim;
if ( bitStream.ReadCompressed ( uiMoveAnim ) )
{
CClientPed* pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
pPed->SetMoveAnim ( (eMoveAnim)uiMoveAnim );
}
}
}
void CPedRPCs::SetPedChoking ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
bool bChoking;
if ( bitStream.ReadBit ( bChoking ) )
{
CClientPed* pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
pPed->SetChoking ( bChoking );
}
}
}
void CPedRPCs::SetPedFightingStyle ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
unsigned char ucStyle;
if ( bitStream.Read ( ucStyle ) )
{
CClientPed* pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
pPed->SetFightingStyle ( ( eFightingStyle ) ucStyle );
}
}
}
void CWeaponRPCs::TakeAllWeapons ( NetBitStreamInterface& bitStream )
{
ElementID ID;
if ( bitStream.ReadCompressed ( ID ) )
{
CClientPed * pPed = m_pPedManager->Get ( ID, true );
if ( pPed )
{
// Remove all our weapons
pPed->RemoveAllWeapons ();
}
}
}
void CWeaponRPCs::SetWeaponSlot ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
SWeaponSlotSync slot;
if ( bitStream.Read ( &slot ) )
{
CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
pPed->SetCurrentWeaponSlot ( (eWeaponSlot) slot.data.uiSlot );
}
}
}
//
// Apply object movement to contacting peds
//
void CDeathmatchObject::UpdateContacting ( const CVector& vecCenterOfRotation, const CVector& vecFrameTranslation, const CVector& vecFrameRotation )
{
bool bHasRotation = ( vecFrameRotation.fX != 0 || vecFrameRotation.fY != 0 || vecFrameRotation.fZ != 0 );
bool bHasTranslation = ( vecFrameTranslation.fX != 0 || vecFrameTranslation.fY != 0 || vecFrameTranslation.fZ != 0 );
// Early out if no orientation change here
if ( !bHasRotation && !bHasTranslation )
return;
// Step through each contacting ped
list < CClientPed * > ::iterator iter = m_Contacts.begin ();
for ( ; iter != m_Contacts.end () ; iter++ )
{
CClientPed* pPed = *iter;
// Get ped start position
CVector vecPlayerPosition;
pPed->GetPosition ( vecPlayerPosition );
// Apply rotation effect on position
if ( bHasRotation )
{
vecPlayerPosition -= vecCenterOfRotation;
RotateVector ( vecPlayerPosition, CVector(-vecFrameRotation.fX, -vecFrameRotation.fY, -vecFrameRotation.fZ ) );
vecPlayerPosition += vecCenterOfRotation;
}
// Apply translation
vecPlayerPosition += vecFrameTranslation;
pPed->SetPosition ( vecPlayerPosition );
// Also change ped facing direction
if ( vecFrameRotation.fZ != 0 )
{
float fRotationZ = pPed->GetCurrentRotation ();
pPed->SetCurrentRotation ( fRotationZ + vecFrameRotation.fZ );
}
}
// Look in attached objects for more ped contacts
list < CClientEntity * > ::iterator itera = m_AttachedEntities.begin ();
for ( ; itera != m_AttachedEntities.end () ; itera++ )
{
CClientEntity* pEntity = *itera;
if ( IS_OBJECT ( pEntity ) )
{
CDeathmatchObject* pObject = static_cast < CDeathmatchObject* > ( pEntity );
pObject->UpdateContacting( vecCenterOfRotation, vecFrameTranslation, vecFrameRotation );
}
}
}
void CClientPedManager::DoPulse ( void )
{
CClientPed * pPed = NULL;
// Loop through our streamed-in peds
vector < CClientPed * > List = m_StreamedIn;
vector < CClientPed* > ::iterator iter = List.begin ();
for ( ; iter != List.end (); ++iter )
{
pPed = *iter;
// We should have a game ped here
assert ( pPed->GetGamePlayer () );
pPed->StreamedInPulse ();
}
}
void CPedRPCs::SetPedHeadless ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
bool bIsHeadless;
if ( bitStream.ReadBit ( bIsHeadless ) )
{
// Grab the ped
CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
pPed->SetHeadless ( bIsHeadless );
}
}
}
void CPedRPCs::SetPedFrozen ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
bool bIsFrozen = 0;
if ( bitStream.ReadBit ( bIsFrozen ) )
{
// Grab the ped
CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
pPed->SetFrozen ( bIsFrozen );
}
}
}
void CElementRPCs::SetElementVelocity ( NetBitStreamInterface& bitStream )
{
// Read out the entity id and the speed
ElementID ID;
CVector vecVelocity;
if ( bitStream.Read ( ID ) &&
bitStream.Read ( vecVelocity.fX ) &&
bitStream.Read ( vecVelocity.fY ) &&
bitStream.Read ( vecVelocity.fZ ) )
{
// Grab the entity
CClientEntity* pEntity = CElementIDs::GetElement ( ID );
if ( pEntity )
{
switch ( pEntity->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed* > ( pEntity );
pPed->SetMoveSpeed ( vecVelocity );
pPed->ResetInterpolation ();
// If local player, reset return position (so we can't warp back if connection fails)
if ( pPed->IsLocalPlayer () )
{
m_pClientGame->GetNetAPI ()->ResetReturnPosition ();
}
break;
}
case CCLIENTVEHICLE:
{
CClientVehicle* pVehicle = static_cast < CClientVehicle* > ( pEntity );
pVehicle->SetMoveSpeed ( vecVelocity );
break;
}
case CCLIENTOBJECT:
{
CClientObject * pObject = static_cast < CClientObject * > ( pEntity );
pObject->SetMoveSpeed ( vecVelocity );
break;
}
}
}
}
}
void CPedRPCs::RemovePedFromVehicle ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
// Read out the player and vehicle id
unsigned char ucTimeContext;
if ( bitStream.Read ( ucTimeContext ) )
{
// Grab the ped
CClientPed * pPed = m_pPedManager->Get ( pSource->GetID (), true );
if ( pPed )
{
if ( CStaticFunctionDefinitions::RemovePedFromVehicle ( pPed ) )
pPed->SetSyncTimeContext ( ucTimeContext );
}
}
}
void CWeaponRPCs::SetWeaponSlot ( NetBitStreamInterface& bitStream )
{
ElementID ID;
SWeaponSlotSync slot;
if ( bitStream.ReadCompressed ( ID ) &&
bitStream.Read ( &slot ) )
{
CClientPed * pPed = m_pPedManager->Get ( ID, true );
if ( pPed )
{
pPed->SetCurrentWeaponSlot ( (eWeaponSlot) slot.data.uiSlot );
}
}
}
