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;
}
}
}
}
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 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;
}
}
}
}
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;
}
}
}
void CUnoccupiedVehicleSync::Packet_UnoccupiedVehicleSync ( NetBitStreamInterface& BitStream )
{
// While we're not out of vehicles
while ( BitStream.GetNumberOfUnreadBits () >= 8 )
{
SUnoccupiedVehicleSync vehicle;
if ( BitStream.Read ( &vehicle ) )
{
CClientVehicle* pVehicle = m_pVehicleManager->Get ( vehicle.data.vehicleID );
if ( pVehicle && pVehicle->CanUpdateSync ( vehicle.data.ucTimeContext ) )
{
if ( vehicle.data.bSyncPosition ) pVehicle->SetTargetPosition ( vehicle.data.vecPosition, UNOCCUPIED_VEHICLE_SYNC_RATE, vehicle.data.bSyncVelocity, vehicle.data.vecVelocity.fZ );
if ( vehicle.data.bSyncRotation ) pVehicle->SetTargetRotation ( vehicle.data.vecRotation, UNOCCUPIED_VEHICLE_SYNC_RATE );
if ( vehicle.data.bSyncVelocity ) pVehicle->SetMoveSpeed ( vehicle.data.vecVelocity );
if ( vehicle.data.bSyncTurnVelocity ) pVehicle->SetTurnSpeed ( vehicle.data.vecTurnVelocity );
if ( vehicle.data.bSyncHealth ) pVehicle->SetHealth ( vehicle.data.fHealth );
pVehicle->SetEngineOn ( vehicle.data.bEngineOn );
if ( pVehicle->GetVehicleType() == CLIENTVEHICLE_TRAIN )
pVehicle->SetDerailed ( vehicle.data.bDerailed );
#ifdef MTA_DEBUG
pVehicle->m_pLastSyncer = NULL;
pVehicle->m_ulLastSyncTime = GetTickCount32 ();
pVehicle->m_szLastSyncType = "unoccupied";
#endif
}
}
else
break;
}
}
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 CClientPacketRecorder::ReadLocalData(FILE* pFile)
{
// Grab the local player
CClientPlayer* pPlayer = m_pManager->GetPlayerManager()->GetLocalPlayer();
if (pPlayer)
{
// Grab the vehicle
CClientVehicle* pVehicle = pPlayer->GetOccupiedVehicle();
if (pVehicle)
{
// Temp vars
CMatrix matVehicle;
CVector vecMoveSpeed;
CVector vecTurnSpeed;
float fHealth;
// Read it out
fread(&matVehicle.vRight.fX, sizeof(float), 1, pFile);
fread(&matVehicle.vRight.fY, sizeof(float), 1, pFile);
fread(&matVehicle.vRight.fZ, sizeof(float), 1, pFile);
fread(&matVehicle.vFront.fX, sizeof(float), 1, pFile);
fread(&matVehicle.vFront.fY, sizeof(float), 1, pFile);
fread(&matVehicle.vFront.fZ, sizeof(float), 1, pFile);
fread(&matVehicle.vUp.fX, sizeof(float), 1, pFile);
fread(&matVehicle.vUp.fY, sizeof(float), 1, pFile);
fread(&matVehicle.vUp.fZ, sizeof(float), 1, pFile);
fread(&matVehicle.vPos.fX, sizeof(float), 1, pFile);
fread(&matVehicle.vPos.fY, sizeof(float), 1, pFile);
fread(&matVehicle.vPos.fZ, sizeof(float), 1, pFile);
fread(&vecMoveSpeed.fX, sizeof(float), 1, pFile);
fread(&vecMoveSpeed.fY, sizeof(float), 1, pFile);
fread(&vecMoveSpeed.fZ, sizeof(float), 1, pFile);
fread(&vecTurnSpeed.fX, sizeof(float), 1, pFile);
fread(&vecTurnSpeed.fY, sizeof(float), 1, pFile);
fread(&vecTurnSpeed.fZ, sizeof(float), 1, pFile);
fread(&fHealth, sizeof(float), 1, pFile);
CControllerState cs;
fread(&cs, sizeof(CControllerState), 1, pFile);
// Set the data
pVehicle->SetMatrix(matVehicle);
pVehicle->SetMoveSpeed(vecMoveSpeed);
pVehicle->SetTurnSpeed(vecTurnSpeed);
pVehicle->SetHealth(fHealth);
// Set the controller state
CControllerState csLast;
g_pGame->GetPad()->Disable(true);
g_pGame->GetPad()->GetCurrentControllerState(&csLast);
g_pGame->GetPad()->SetLastControllerState(&csLast);
g_pGame->GetPad()->SetCurrentControllerState(&cs);
}
}
}
void CElementRPCs::SetElementPosition ( NetBitStreamInterface& bitStream )
{
// Read out the entity id and the position
ElementID ID;
CVector vecPosition;
unsigned char ucTimeContext;
if ( bitStream.Read ( ID ) &&
bitStream.Read ( vecPosition.fX ) &&
bitStream.Read ( vecPosition.fY ) &&
bitStream.Read ( vecPosition.fZ ) &&
bitStream.Read ( ucTimeContext ) )
{
// Grab the entity
CClientEntity* pEntity = CElementIDs::GetElement ( ID );
if ( pEntity )
{
// Update the sync context to the new one
pEntity->SetSyncTimeContext ( ucTimeContext );
// If it's a player, use Teleport
if ( pEntity->GetType () == CCLIENTPLAYER )
{
unsigned char ucWarp = 1;
bitStream.Read ( ucWarp );
CClientPlayer* pPlayer = static_cast < CClientPlayer* > ( pEntity );
if ( ucWarp )
{
pPlayer->Teleport ( vecPosition );
pPlayer->ResetInterpolation ();
}
else
{
pPlayer->SetPosition ( vecPosition );
}
// If local player, reset return position (so we can't warp back if connection fails)
if ( pPlayer->IsLocalPlayer () )
{
m_pClientGame->GetNetAPI ()->ResetReturnPosition ();
}
}
else if ( pEntity->GetType () == CCLIENTVEHICLE )
{
CClientVehicle* pVehicle = static_cast < CClientVehicle* > ( pEntity );
pVehicle->RemoveTargetPosition ();
pVehicle->SetPosition ( vecPosition );
}
else
{
// Set its position
pEntity->SetPosition ( vecPosition );
}
}
}
}
void CClientPlayerManager::DoPulse ( void )
{
unsigned long ulCurrentTime = CClientTime::GetTime ();
CClientPlayer * pPlayer = NULL;
vector < CClientPlayer* > ::const_iterator iter = m_Players.begin ();
for ( ; iter != m_Players.end (); ++iter )
{
pPlayer = *iter;
if ( !pPlayer->IsLocalPlayer () )
{
// Pulse voice data if voice is enabled
if ( g_pClientGame->GetVoiceRecorder()->IsEnabled() && pPlayer->GetVoice() )
pPlayer->GetVoice()->DoPulse();
// Flag him with connection error if its been too long since last puresync and force his position
unsigned long ulLastPuresyncTime = pPlayer->GetLastPuresyncTime ();
bool bHasConnectionTrouble = ( ulLastPuresyncTime != 0 && ulCurrentTime >= ulLastPuresyncTime + REMOTE_PLAYER_CONNECTION_TROUBLE_TIME );
if ( bHasConnectionTrouble && !g_pClientGame->IsDownloadingBigPacket () && !pPlayer->IsDeadOnNetwork () )
{
pPlayer->SetHasConnectionTrouble ( true );
// Reset his controller so he doesn't get stuck shooting or something
CControllerState State;
memset ( &State, 0, sizeof ( CControllerState ) );
pPlayer->SetControllerState ( State );
// Grab his vehicle if any and force the position to where he was last sync
CClientVehicle* pVehicle = pPlayer->GetOccupiedVehicle ();
if ( pVehicle )
{
// Is he driving the vehicle?
if ( pPlayer->GetOccupiedVehicleSeat () == 0 )
{
// Force his position to where he was last sync
pVehicle->SetPosition ( pPlayer->GetLastPuresyncPosition () );
pVehicle->SetMoveSpeed ( CVector ( 0, 0, 0 ) );
pVehicle->SetTurnSpeed ( CVector ( 0, 0, 0 ) );
pPlayer->ResetInterpolation ();
}
}
else
{
// Force his position to where he was last sync
pPlayer->SetPosition ( pPlayer->GetLastPuresyncPosition () );
pPlayer->ResetInterpolation ();
pPlayer->SetMoveSpeed ( CVector ( 0, 0, 0 ) );
pPlayer->ResetInterpolation ();
}
}
else
{
pPlayer->SetHasConnectionTrouble ( false );
}
}
}
}
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 CClientVehicleManager::DoPulse ( void )
{
CClientVehicle * pVehicle = NULL;
// Loop through our streamed-in vehicles
vector < CClientVehicle * > cloneList = m_StreamedIn;
vector < CClientVehicle* > ::iterator iter = cloneList.begin ();
for ( ; iter != cloneList.end (); ++iter )
{
pVehicle = *iter;
// We should have a game vehicle here
assert ( pVehicle->GetGameVehicle () );
pVehicle->StreamedInPulse ();
}
}
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 CClientPathNode::DoPulse(void)
{
list<CClientEntity*>::iterator iter = m_List.begin();
for (; iter != m_List.end(); iter++)
{
// TEST!
if ((*iter)->GetType() == CCLIENTVEHICLE)
{
CClientVehicle* pVehicle = static_cast<CClientVehicle*>(*iter);
CVector vecMoveSpeed;
pVehicle->GetMoveSpeed(vecMoveSpeed);
vecMoveSpeed.fZ = 0.0f;
pVehicle->SetMoveSpeed(vecMoveSpeed);
}
(*iter)->SetPosition(m_vecPosition);
}
}
void CClientVehicleManager::RestreamVehicles ( unsigned short usModel )
{
// Store the affected vehicles
CClientVehicle* pVehicle;
std::vector < CClientVehicle* > ::iterator iter = IterBegin ();
for ( ; iter != IterEnd (); iter++ )
{
pVehicle = *iter;
// Streamed in and same vehicle ID?
if ( pVehicle->IsStreamedIn () && pVehicle->GetModel () == usModel )
{
// Stream it out for a while until streamed decides to stream it
// back in eventually
pVehicle->StreamOutForABit ();
}
}
}
CVehicle* CClientTask::GetParameterVehicle ( const char* szKey )
{
// Grab the parameter, is it userdata?
CLuaArgument* pArgument = GetParameter ( szKey );
if ( pArgument && pArgument->GetType () == LUA_TLIGHTUSERDATA )
{
// Grab the player and verify it
CClientVehicle* pVehicle = reinterpret_cast < CClientVehicle* > ( pArgument->GetLightUserData () );
if ( VERIFY_VEHICLE ( pVehicle ) )
{
// Return the game vehicle
return pVehicle->GetGameVehicle ();
}
}
// Non-existing
return NULL;
}
CClientVehicle * CStreamer::GetVehicleFromGameVehicle(IVVehicle * pGameVehicle)
{
// Get the streamed in vehicles list
std::list <CStreamableEntity *> * m_streamedVehicles = &m_streamedElements[ENTITY_TYPE_VEHICLE];
// Loop through the streamed in vehicles list
for(std::list<CStreamableEntity *>::iterator iter = m_streamedVehicles->begin(); iter != m_streamedVehicles->end(); iter++)
{
// Get the vehicle pointer
CClientVehicle * pTestVehicle = reinterpret_cast<CClientVehicle *>(*iter);
// Is this the vehicle we are looking for?
if(pTestVehicle->GetGameVehicle()->GetVehicle() == pGameVehicle)
return pTestVehicle;
}
// No vehicle found
return NULL;
}
int CLuaOOPDefs::GetVehicleGravity ( lua_State* luaVM )
{
CClientVehicle* pVehicle = NULL;
CScriptArgReader argStream ( luaVM );
argStream.ReadUserData ( pVehicle );
if ( !argStream.HasErrors () )
{
CVector vecGravity;
pVehicle->GetGravity ( vecGravity );
lua_pushvector ( luaVM, vecGravity );
return 1;
}
else
m_pScriptDebugging->LogCustom ( luaVM, argStream.GetFullErrorMessage () );
lua_pushboolean ( luaVM, false );
return 1;
}
void CElementRPCs::SetElementHealth ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
float fHealth;
unsigned char ucTimeContext;
if ( bitStream.Read ( fHealth ) &&
bitStream.Read ( ucTimeContext ) )
{
pSource->SetSyncTimeContext ( ucTimeContext );
switch ( pSource->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed * > ( pSource );
if ( pPed->IsHealthLocked() )
pPed->LockHealth ( fHealth );
else
pPed->SetHealth ( fHealth );
break;
}
case CCLIENTVEHICLE:
{
CClientVehicle* pVehicle = static_cast < CClientVehicle * > ( pSource );
pVehicle->SetHealth ( fHealth );
break;
}
case CCLIENTOBJECT:
case CCLIENTWEAPON:
{
CClientObject* pObject = static_cast < CClientObject * > ( pSource );
pObject->SetHealth ( fHealth );
break;
}
}
}
}
void CElementRPCs::SetElementModel ( CClientEntity* pSource, NetBitStreamInterface& bitStream )
{
unsigned short usModel;
if ( bitStream.Read ( usModel ) )
{
switch ( pSource->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed * > ( pSource );
pPed->SetModel ( usModel );
break;
}
case CCLIENTVEHICLE:
{
uchar ucVariant = 255, ucVariant2 = 255;
if ( bitStream.GetNumberOfUnreadBits () >= sizeof ( ucVariant ) + sizeof ( ucVariant2 ) )
{
bitStream.Read ( ucVariant );
bitStream.Read ( ucVariant2 );
}
CClientVehicle* pVehicle = static_cast < CClientVehicle * > ( pSource );
pVehicle->SetModelBlocking ( usModel, ucVariant, ucVariant2 );
break;
}
case CCLIENTOBJECT:
case CCLIENTWEAPON:
{
CClientObject* pObject = static_cast < CClientObject * > ( pSource );
pObject->SetModel ( usModel );
break;
}
}
}
}
void CElementRPCs::SetElementModel ( NetBitStreamInterface& bitStream )
{
ElementID ID;
unsigned short usModel;
if ( bitStream.Read ( ID ) &&
bitStream.Read ( usModel ) )
{
CClientEntity * pEntity = CElementIDs::GetElement ( ID );
if ( pEntity )
{
switch ( pEntity->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
{
CClientPed* pPed = static_cast < CClientPed * > ( pEntity );
pPed->SetModel ( usModel );
break;
}
case CCLIENTVEHICLE:
{
CClientVehicle* pVehicle = static_cast < CClientVehicle * > ( pEntity );
pVehicle->SetModelBlocking ( usModel );
break;
}
case CCLIENTOBJECT:
{
CClientObject* pObject = static_cast < CClientObject * > ( pEntity );
pObject->SetModel ( usModel );
break;
}
}
}
}
}
void CClientWeapon::Fire ( void )
{
if ( !m_pWeapon || !m_pObject ) return;
switch ( m_Type )
{
case WEAPONTYPE_PISTOL:
case WEAPONTYPE_PISTOL_SILENCED:
case WEAPONTYPE_DESERT_EAGLE:
#ifdef SHOTGUN_TEST
case WEAPONTYPE_SHOTGUN:
case WEAPONTYPE_SAWNOFF_SHOTGUN:
case WEAPONTYPE_SPAS12_SHOTGUN:
#endif
case WEAPONTYPE_MICRO_UZI:
case WEAPONTYPE_MP5:
case WEAPONTYPE_AK47:
case WEAPONTYPE_M4:
case WEAPONTYPE_TEC9:
case WEAPONTYPE_COUNTRYRIFLE:
case WEAPONTYPE_SNIPERRIFLE:
case WEAPONTYPE_MINIGUN:
{
CVector vecOrigin, vecRotation;
GetPosition ( vecOrigin );
if ( m_pAttachedToEntity )
{
GetRotationRadians ( vecRotation );
}
else
{
GetRotationRadians ( vecRotation );
vecRotation = -vecRotation;
}
CVector vecTarget;
float fDistance = m_pWeaponInfo->GetWeaponRange ();
if ( m_targetType == TARGET_TYPE_ENTITY )
{
if ( m_pTarget )
{
if ( m_pTarget->GetType ( ) == CCLIENTPED || m_pTarget->GetType ( ) == CCLIENTPLAYER )
{
CClientPed * pPed = (CClientPed *) (CClientEntity *) m_pTarget;
pPed->GetBonePosition( m_targetBone, vecTarget );
}
else
{
if ( m_pTarget->GetType() == CCLIENTVEHICLE )
{
if ( m_itargetWheel <= MAX_WHEELS )
{
CClientVehicle * pTarget = (CClientVehicle*)(CClientEntity *)m_pTarget;
vecTarget = pTarget->GetGameVehicle()->GetWheelPosition ( (eWheels)m_itargetWheel );
}
else
m_pTarget->GetPosition( vecTarget );
}
else
m_pTarget->GetPosition( vecTarget );
}
if ( m_weaponConfig.bShootIfTargetOutOfRange == false && (vecOrigin - vecTarget).Length() >= fDistance )
{
return;
}
}
else
{
ResetWeaponTarget ( );
}
}
else if ( m_targetType == TARGET_TYPE_VECTOR )
{
vecTarget = m_vecTarget;
if ( m_weaponConfig.bShootIfTargetOutOfRange == false && (vecOrigin - vecTarget).Length() >= fDistance )
{
return;
}
}
else
{
CVector vecFireOffset = *m_pWeaponInfo->GetFireOffset ();
RotateVector ( vecFireOffset, vecRotation );
#ifndef SHOTGUN_TEST
vecOrigin += vecFireOffset;
#endif
CVector vecDirection ( 1, 0, 0 );
vecDirection *= fDistance;
RotateVector ( vecDirection, vecRotation );
vecTarget = vecOrigin + vecDirection;
}
// Save
short sDamage = m_pWeaponInfo->GetDamagePerHit ( );
float fAccuracy = m_pWeaponInfo->GetAccuracy ( );
float fTargetRange = m_pWeaponInfo->GetTargetRange ( );
float fRange = m_pWeaponInfo->GetWeaponRange ( );
// Set new
m_pWeaponInfo->SetDamagePerHit ( m_pWeaponStat->GetDamagePerHit ( ) );
m_pWeaponInfo->SetAccuracy ( m_pWeaponStat->GetAccuracy ( ) );
m_pWeaponInfo->SetTargetRange ( m_pWeaponStat->GetTargetRange ( ) );
m_pWeaponInfo->SetWeaponRange ( m_pWeaponStat->GetWeaponRange ( ) );
// Begin our lag compensation
CPlayerPed* pOwnerPed = NULL;
if ( m_pOwner && !m_pTarget && g_pClientGame->GetPlayerManager()->Exists(m_pOwner) ) // No need for compensation if we're hitting a target directly
{
pOwnerPed = m_pOwner->GetGamePlayer();
//if ( g_pGame->m_pPreWeaponFireHandler && pOwnerPed )
//g_pGame->m_pPreWeaponFireHandler ( pOwnerPed, false );
}
#ifdef SHOTGUN_TEST
CVector vecTemp;
CVector vecFireOffset = *m_pWeaponInfo->GetFireOffset ();
RotateVector ( vecFireOffset, vecRotation );
vecTemp = vecFireOffset;
vecTemp += vecOrigin;
#ifdef MARKER_DEBUG
// Process
m_pMarker->SetPosition ( vecOrigin );
#endif
CVector vecTemp2;
GetRotationDegrees(vecTemp2);
vecTemp2.fZ -= 84.6f;
SetRotationDegrees(vecTemp2);
FireInstantHit ( vecOrigin, vecTarget-vecOrigin, vecTemp );
vecTemp2.fZ += 84.6f;
SetRotationDegrees(vecTemp2);
#else
FireInstantHit ( vecOrigin, vecTarget );
#endif
// Restore
m_pWeaponInfo->SetDamagePerHit ( sDamage );
m_pWeaponInfo->SetAccuracy ( fAccuracy );
m_pWeaponInfo->SetTargetRange ( fTargetRange );
m_pWeaponInfo->SetWeaponRange ( fRange );
// End our lag compensation
//if ( g_pGame->m_pPostWeaponFireHandler && pOwnerPed )
//g_pGame->m_pPostWeaponFireHandler ();
m_nAmmoInClip--;
m_fireTimer.Reset();
break;
}
default: break;
}
}
void CClientWeapon::Fire ( bool bServerFire )
{
if ( !m_pWeapon || !m_pObject || ( !IsLocalEntity ( ) && m_pOwner != g_pClientGame->GetLocalPlayer ( ) && bServerFire == false ) ) return;
switch ( m_Type )
{
case WEAPONTYPE_PISTOL:
case WEAPONTYPE_PISTOL_SILENCED:
case WEAPONTYPE_DESERT_EAGLE:
#ifdef SHOTGUN_TEST
case WEAPONTYPE_SHOTGUN:
case WEAPONTYPE_SAWNOFF_SHOTGUN:
case WEAPONTYPE_SPAS12_SHOTGUN:
#endif
case WEAPONTYPE_MICRO_UZI:
case WEAPONTYPE_MP5:
case WEAPONTYPE_AK47:
case WEAPONTYPE_M4:
case WEAPONTYPE_TEC9:
case WEAPONTYPE_COUNTRYRIFLE:
case WEAPONTYPE_SNIPERRIFLE:
case WEAPONTYPE_MINIGUN:
{
CMatrix matOrigin;
GetMatrix ( matOrigin );
CVector vecTarget;
float fDistance = m_pWeaponInfo->GetWeaponRange ();
if ( m_targetType == TARGET_TYPE_ENTITY )
{
if ( m_pTarget )
{
if ( m_pTarget->GetType ( ) == CCLIENTPED || m_pTarget->GetType ( ) == CCLIENTPLAYER )
{
CClientPed * pPed = (CClientPed *) (CClientEntity *) m_pTarget;
pPed->GetBonePosition( m_targetBone, vecTarget );
}
else
{
if ( m_pTarget->GetType() == CCLIENTVEHICLE )
{
if ( m_itargetWheel <= MAX_WHEELS )
{
CClientVehicle * pTarget = (CClientVehicle*)(CClientEntity *)m_pTarget;
vecTarget = pTarget->GetGameVehicle()->GetWheelPosition ( (eWheels)m_itargetWheel );
}
else
m_pTarget->GetPosition( vecTarget );
}
else
m_pTarget->GetPosition( vecTarget );
}
if ( m_weaponConfig.bShootIfTargetOutOfRange == false && (matOrigin.GetPosition() - vecTarget).Length() >= fDistance )
{
return;
}
}
else
{
ResetWeaponTarget ( );
}
}
else if ( m_targetType == TARGET_TYPE_VECTOR )
{
vecTarget = m_vecTarget;
if ( m_weaponConfig.bShootIfTargetOutOfRange == false && (matOrigin.GetPosition() - vecTarget).Length() >= fDistance )
{
return;
}
}
else
{
#ifndef SHOTGUN_TEST
CVector vecFireOffset = *m_pWeaponInfo->GetFireOffset ();
matOrigin = CMatrix( vecFireOffset, m_vecFireRotationNoTarget ) * matOrigin;
#endif
CVector vecDirection ( 1, 0, 0 );
vecDirection *= fDistance;
vecTarget = matOrigin.TransformVector( vecDirection );
}
// Save
short sDamage = m_pWeaponInfo->GetDamagePerHit ( );
float fAccuracy = m_pWeaponInfo->GetAccuracy ( );
float fTargetRange = m_pWeaponInfo->GetTargetRange ( );
float fRange = m_pWeaponInfo->GetWeaponRange ( );
// Set new
m_pWeaponInfo->SetDamagePerHit ( m_pWeaponStat->GetDamagePerHit ( ) );
m_pWeaponInfo->SetAccuracy ( m_pWeaponStat->GetAccuracy ( ) );
m_pWeaponInfo->SetTargetRange ( m_pWeaponStat->GetTargetRange ( ) );
m_pWeaponInfo->SetWeaponRange ( m_pWeaponStat->GetWeaponRange ( ) );
#ifdef SHOTGUN_TEST
CVector vecFireOffset = *m_pWeaponInfo->GetFireOffset ();
CMatrix matTemp = CMatrix( vecFireOffset ) * matOrigin;
#ifdef MARKER_DEBUG
// Process
m_pMarker->SetPosition ( matOrigin.GetPosition() );
#endif
CVector vecTemp2;
GetRotationDegrees(vecTemp2);
vecTemp2.fZ -= 84.6f;
SetRotationDegrees(vecTemp2);
FireInstantHit ( matOrigin.GetPosition(), vecTarget-matOrigin.GetPosition(), matTemp.GetPosition() );
vecTemp2.fZ += 84.6f;
SetRotationDegrees(vecTemp2);
#else
FireInstantHit ( matOrigin.GetPosition(), vecTarget, bServerFire );
#endif
// Restore
m_pWeaponInfo->SetDamagePerHit ( sDamage );
m_pWeaponInfo->SetAccuracy ( fAccuracy );
m_pWeaponInfo->SetTargetRange ( fTargetRange );
m_pWeaponInfo->SetWeaponRange ( fRange );
m_nAmmoInClip--;
m_fireTimer.Reset();
break;
}
default: break;
}
}
///////////////////////////////////////////////////////////////
//
// 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;
}
}
}
}
void CClientPacketRecorder::RecordLocalData(CClientPlayer* pLocalPlayer)
{
if (m_bRecording && m_szFilename)
{
// Open our file
FILE* pFile = fopen(m_szFilename, "ab+");
if (pFile)
{
// Write our timestamp
if (m_bFrameBased)
{
long lFrameStamp = m_lFrames - m_lRelative;
fwrite(&lFrameStamp, sizeof(long), 1, pFile);
}
else
{
long lTimeStamp = CClientTime::GetTime() - m_lRelative;
fwrite(&lTimeStamp, sizeof(long), 1, pFile);
}
// fwrite ( &ulTimeStamp, sizeof ( unsigned long ), 1, pFile );
// Write the packet ID
fputc(0xFE, pFile);
// Grab the vehicle
CClientVehicle* pVehicle = pLocalPlayer->GetOccupiedVehicle();
if (pVehicle)
{
// Read out the matrix, movespeed and turnspeed
CMatrix matVehicle;
CVector vecMoveSpeed;
CVector vecTurnSpeed;
pVehicle->GetMatrix(matVehicle);
pVehicle->GetMoveSpeed(vecMoveSpeed);
pVehicle->GetTurnSpeed(vecTurnSpeed);
float fHealth = pVehicle->GetHealth();
// Write it
fwrite(&matVehicle.vRight.fX, sizeof(float), 1, pFile);
fwrite(&matVehicle.vRight.fY, sizeof(float), 1, pFile);
fwrite(&matVehicle.vRight.fZ, sizeof(float), 1, pFile);
fwrite(&matVehicle.vFront.fX, sizeof(float), 1, pFile);
fwrite(&matVehicle.vFront.fY, sizeof(float), 1, pFile);
fwrite(&matVehicle.vFront.fZ, sizeof(float), 1, pFile);
fwrite(&matVehicle.vUp.fX, sizeof(float), 1, pFile);
fwrite(&matVehicle.vUp.fY, sizeof(float), 1, pFile);
fwrite(&matVehicle.vUp.fZ, sizeof(float), 1, pFile);
fwrite(&matVehicle.vPos.fX, sizeof(float), 1, pFile);
fwrite(&matVehicle.vPos.fY, sizeof(float), 1, pFile);
fwrite(&matVehicle.vPos.fZ, sizeof(float), 1, pFile);
fwrite(&vecMoveSpeed.fX, sizeof(float), 1, pFile);
fwrite(&vecMoveSpeed.fY, sizeof(float), 1, pFile);
fwrite(&vecMoveSpeed.fZ, sizeof(float), 1, pFile);
fwrite(&vecTurnSpeed.fX, sizeof(float), 1, pFile);
fwrite(&vecTurnSpeed.fY, sizeof(float), 1, pFile);
fwrite(&vecTurnSpeed.fZ, sizeof(float), 1, pFile);
fwrite(&fHealth, sizeof(float), 1, pFile);
// Write the controller state
CControllerState cs;
g_pGame->GetPad()->GetCurrentControllerState(&cs);
fwrite(&cs, sizeof(CControllerState), 1, pFile);
}
// Close the file
fclose(pFile);
}
}
}
void CClientWeapon::FireInstantHit ( CVector vecOrigin, CVector vecTarget, bool bServerFire, bool bRemote )
#endif
{
CVector vecDirection = vecTarget - vecOrigin;
vecDirection.Normalize ();
CClientEntity * pAttachedTo = GetAttachedTo ();
CVector vecOriginalTarget = vecTarget;
CEntity * pColEntity = NULL;
CColPoint * pColPoint = NULL;
SLineOfSightBuildingResult pBuildingResult;
CEntitySAInterface * pEntity = NULL;
if ( m_Type != WEAPONTYPE_SHOTGUN )
{
CVector vecWeaponFirePosition;
if ( !IsLocalEntity ( ) && m_pOwner )
{
CClientPlayer * pPlayer = m_pOwner;
CClientPed * pLocalPlayer = g_pClientGame->GetLocalPlayer();
if ( pLocalPlayer && pPlayer )
{
CClientVehicle* pVehicle = pLocalPlayer->GetRealOccupiedVehicle ();
// Move both players to where they should be for shot compensation
if ( pPlayer && !pPlayer->IsLocalPlayer () )
{
if ( !pVehicle || pLocalPlayer->GetOccupiedVehicleSeat() == 0 )
{
// Warp back in time to where we were when this player shot (their latency)
// We don't account for interpolation here, +250ms seems to work better
// ** Changed ajustment to +125ms as the position of this clients player on the firers screen
// has been changed. See CClientPed::UpdateTargetPosition() **
CVector vecPosition;
unsigned short usLatency = ( pPlayer->GetLatency () + 125 );
g_pClientGame->GetNetAPI()->GetInterpolation ( vecPosition, usLatency );
// Move the entity back
if ( pVehicle )
{
pVehicle->GetPosition ( vecWeaponFirePosition );
pVehicle->SetPosition ( vecPosition, false, false );
}
else
{
pLocalPlayer->GetPosition ( vecWeaponFirePosition );
pLocalPlayer->SetPosition ( vecPosition, false, false );
}
}
}
}
}
//if ( pAttachedTo ) pAttachedTo->WorldIgnore ( true );
if ( m_pWeapon->ProcessLineOfSight ( &vecOrigin, &vecTarget, &pColPoint, &pColEntity, m_weaponConfig.flags, &pBuildingResult, m_Type, &pEntity ) )
{
vecTarget = pColPoint->GetPosition ();
}
// Don't continue without a valid colpoint
if ( !pColPoint )
return;
//if ( pAttachedTo ) pAttachedTo->WorldIgnore ( false );
// return if shoot if target is blocked is false and we aren't pointing at our target
if ( ( m_pTarget != NULL && m_pTarget->GetGameEntity ( ) != NULL && m_pTarget->GetGameEntity()->GetInterface ( ) != pEntity ) && m_weaponConfig.bShootIfTargetBlocked == false && bRemote == false )
{
if ( pColPoint )
pColPoint->Destroy ();
return;
}
// Execute our weapon fire event
CClientEntity * pClientEntity = m_pManager->FindEntitySafe ( pColEntity );
CLuaArguments Arguments;
if ( pClientEntity )
Arguments.PushElement ( pClientEntity ); // entity that got hit
else
Arguments.PushNil ( ); // Probably a building.
Arguments.PushNumber ( pColPoint->GetPosition ( ).fX ); // pos x
Arguments.PushNumber ( pColPoint->GetPosition ( ).fY ); // pos y
Arguments.PushNumber ( pColPoint->GetPosition ( ).fZ ); // pos z
Arguments.PushNumber ( pColPoint->GetNormal ( ).fX ); // Normal x
Arguments.PushNumber ( pColPoint->GetNormal ( ).fY ); // Normal y
Arguments.PushNumber ( pColPoint->GetNormal ( ).fZ ); // Normal z
Arguments.PushNumber ( pColPoint->GetSurfaceTypeB ( ) ); // Surface type "B"
Arguments.PushNumber ( pColPoint->GetLightingForTimeOfDay ( ) ); // Lighting
Arguments.PushNumber ( pColPoint->GetPieceTypeB ( ) ); // Piece
if ( !CallEvent ( "onClientWeaponFire", Arguments, true ) )
{
if ( pColPoint )
pColPoint->Destroy ();
return;
}
DoGunShells ( vecOrigin, vecDirection );
CVector vecCollision;
if ( g_pGame->GetWaterManager ()->TestLineAgainstWater ( vecOrigin, vecTarget, &vecCollision ) )
{
g_pGame->GetFx ()->TriggerBulletSplash ( vecCollision );
g_pGame->GetAudioEngine ()->ReportBulletHit ( NULL, SURFACE_TYPE_WATER_SHALLOW, &vecCollision, 0.0f );
}
#ifdef MARKER_DEBUG
m_pMarker2->SetPosition ( vecTarget );
#endif
m_pWeapon->DoBulletImpact ( m_pObject, pEntity, &vecOrigin, &vecTarget, pColPoint, 0 );
if ( !IsLocalEntity ( ) && m_pOwner )
{
CClientPed * pPed = m_pOwner;
CClientPed * pLocalPlayer = g_pClientGame->GetLocalPlayer();
if ( pPed->GetType () == CCLIENTPLAYER )
{
// Restore compensated positions
if ( !pPed->IsLocalPlayer () )
{
CClientVehicle* pVehicle = pLocalPlayer->GetRealOccupiedVehicle ();
if ( !pVehicle )
{
pLocalPlayer->SetPosition ( vecWeaponFirePosition, false, false );
}
else if ( pLocalPlayer->GetOccupiedVehicleSeat() == 0 )
{
pVehicle->SetPosition ( vecWeaponFirePosition, false, false );
}
}
}
}
if ( !IsLocalEntity ( ) && GetOwner ( ) == g_pClientGame->GetLocalPlayer ( ) && bServerFire == false )
{
g_pClientGame->GetNetAPI ( )->SendBulletSyncCustomWeaponFire ( this, vecOrigin, vecOriginalTarget );
}
}
#ifdef SHOTGUN_TEST
else
{
//if ( pAttachedTo ) pAttachedTo->WorldIgnore ( true );
//if ( pAttachedTo ) pAttachedTo->WorldIgnore ( false );
// Fire instant hit is off by a few degrees
FireShotgun ( m_pObject, vecOrigin, vecTarget, vecRotation );
}
#endif
if ( pColPoint )
pColPoint->Destroy ();
}
bool CUnoccupiedVehicleSync::WriteVehicleInformation ( NetBitStreamInterface* pBitStream, CDeathmatchVehicle* pVehicle )
{
bool bSyncVehicle = false;
SUnoccupiedVehicleSync vehicle;
// Copy the vehicle data into the sync structures
vehicle.data.vehicleID = pVehicle->GetID ();
vehicle.data.ucTimeContext = pVehicle->GetSyncTimeContext ();
pVehicle->GetPosition ( vehicle.data.vecPosition );
pVehicle->GetRotationDegrees ( vehicle.data.vecRotation );
if ( pVehicle->GetGameVehicle () )
{
pVehicle->GetMoveSpeed ( vehicle.data.vecVelocity );
pVehicle->GetTurnSpeed ( vehicle.data.vecTurnVelocity );
}
vehicle.data.fHealth = pVehicle->GetHealth ();
CClientVehicle* pTrailer = pVehicle->GetRealTowedVehicle ();
if ( pTrailer )
vehicle.data.trailer = pTrailer->GetID ();
else
vehicle.data.trailer = static_cast < ElementID > ( INVALID_ELEMENT_ID );
// Adjust the sync flags
if ( pVehicle->GetModelInfo ()->IsBoat () )
{
// Boats vary their z height a bit when on water due to the wave effect
// It's not needed to sync these tiny changes.
const CVector& vecLastPosition = pVehicle->m_LastSyncedData->vecPosition;
if ( fabs ( vecLastPosition.fX - vehicle.data.vecPosition.fX ) > FLOAT_EPSILON ||
fabs ( vecLastPosition.fY - vehicle.data.vecPosition.fY ) > FLOAT_EPSILON ||
fabs ( vecLastPosition.fZ - vehicle.data.vecPosition.fZ ) > 1.2f )
{
bSyncVehicle = true;
vehicle.data.bSyncPosition = true;
pVehicle->m_LastSyncedData->vecPosition = vehicle.data.vecPosition;
}
const CVector& vecLastVelocity = pVehicle->m_LastSyncedData->vecMoveSpeed;
if ( vecLastVelocity != vehicle.data.vecVelocity &&
(
fabs ( vehicle.data.vecVelocity.fX ) > FLOAT_EPSILON ||
fabs ( vehicle.data.vecVelocity.fY ) > FLOAT_EPSILON ||
fabs ( vehicle.data.vecVelocity.fZ ) > FLOAT_EPSILON
)
)
{
bSyncVehicle = true;
vehicle.data.bSyncVelocity = true;
pVehicle->m_LastSyncedData->vecMoveSpeed = vehicle.data.vecVelocity;
}
}
else
{
if ( pVehicle->m_LastSyncedData->vecPosition != vehicle.data.vecPosition )
{
bSyncVehicle = true;
vehicle.data.bSyncPosition = true;
pVehicle->m_LastSyncedData->vecPosition = vehicle.data.vecPosition;
}
if ( pVehicle->m_LastSyncedData->vecMoveSpeed != vehicle.data.vecVelocity )
{
bSyncVehicle = true;
vehicle.data.bSyncVelocity = true;
pVehicle->m_LastSyncedData->vecMoveSpeed = vehicle.data.vecVelocity;
}
}
if ( pVehicle->m_LastSyncedData->vecRotation != vehicle.data.vecRotation )
{
bSyncVehicle = true;
vehicle.data.bSyncRotation = true;
pVehicle->m_LastSyncedData->vecRotation = vehicle.data.vecRotation;
}
if ( pVehicle->m_LastSyncedData->vecTurnSpeed != vehicle.data.vecTurnVelocity )
{
bSyncVehicle = true;
vehicle.data.bSyncTurnVelocity = true;
pVehicle->m_LastSyncedData->vecTurnSpeed = vehicle.data.vecTurnVelocity;
}
if ( fabs ( pVehicle->m_LastSyncedData->fHealth - vehicle.data.fHealth ) > FLOAT_EPSILON )
{
bSyncVehicle = true;
vehicle.data.bSyncHealth = true;
pVehicle->m_LastSyncedData->fHealth = vehicle.data.fHealth;
}
if ( pVehicle->m_LastSyncedData->Trailer != vehicle.data.trailer )
{
bSyncVehicle = true;
vehicle.data.bSyncTrailer = true;
pVehicle->m_LastSyncedData->Trailer = vehicle.data.trailer;
}
if ( pVehicle->IsEngineOn () )
{
bSyncVehicle = true;
vehicle.data.bEngineOn = true;
}
if ( pVehicle->IsDerailed () )
{
bSyncVehicle = true;
vehicle.data.bDerailed = true;
}
if ( pVehicle->IsInWater () )
{
bSyncVehicle = true;
vehicle.data.bIsInWater = true;
}
// If nothing has changed we dont sync the vehicle
if ( !bSyncVehicle )
return false;
// Write the data
pBitStream->Write ( &vehicle );
return true;
}
void CNametags::DrawDefault()
{
// Grab the resolution width and height
static float fResWidth = static_cast<float>(g_pCore->GetGraphics()->GetViewportWidth());
static float fResHeight = static_cast<float>(g_pCore->GetGraphics()->GetViewportHeight());
// Got any players that are not local?
if (m_pPlayerManager->Count() <= 1)
return;
list<CClientPlayer*> playerTags;
// Grab the local player
CClientPlayer* pLocalPlayer = m_pPlayerManager->GetLocalPlayer();
if (!pLocalPlayer)
return;
CClientVehicle* pSniperTargetedVehicle = NULL;
CClientPlayer* pSniperTargetedPlayer = NULL;
// Grab our current weapon slot. Use screen center if melee or none
eWeaponSlot eSlot = pLocalPlayer->GetCurrentWeaponSlot();
if (eSlot >= WEAPONSLOT_TYPE_HANDGUN && eSlot <= WEAPONSLOT_TYPE_RIFLE)
{
CVector vecOrigin, vecTarget;
pLocalPlayer->GetShotData(&vecOrigin, &vecTarget);
// Ignore the local player for this
pLocalPlayer->WorldIgnore(true);
// Do the raycast
CColPoint* pColPoint = NULL;
CEntity* pEntity = NULL;
SLineOfSightFlags flags;
flags.bCheckBuildings = true;
flags.bCheckVehicles = true;
flags.bCheckPeds = true;
flags.bCheckObjects = true;
flags.bCheckDummies = true;
flags.bSeeThroughStuff = true;
flags.bIgnoreSomeObjectsForCamera = false;
flags.bShootThroughStuff = true;
g_pGame->GetWorld()->ProcessLineOfSight(&vecOrigin, &vecTarget, &pColPoint, &pEntity, flags);
if (pColPoint)
pColPoint->Destroy();
// Un-ignore the local player
pLocalPlayer->WorldIgnore(false);
// Did we find an entity?
if (pEntity)
{
// Grab the CClientEntity belonging to this game_sa entity
CClientEntity* pClientEntity = reinterpret_cast<CClientEntity*>(pEntity->GetStoredPointer());
if (pClientEntity)
{
// Is it a vehicle? Is it a ped?
eClientEntityType EntityType = pClientEntity->GetType();
switch (EntityType)
{
case CCLIENTVEHICLE:
{
pSniperTargetedVehicle = static_cast<CClientVehicle*>(pClientEntity);
break;
}
case CCLIENTPLAYER:
{
pSniperTargetedPlayer = static_cast<CClientPlayer*>(pClientEntity);
break;
}
default:
break;
}
}
}
}
// Grab the local player vehicle
CClientVehicle* pLocalVehicle = pLocalPlayer->GetOccupiedVehicle();
CVehicle* pLocalGameVehicle = NULL;
if (pLocalVehicle)
pLocalGameVehicle = pLocalVehicle->GetGameVehicle();
CMatrix CameraMatrix;
g_pGame->GetCamera()->GetMatrix(&CameraMatrix);
// Remove collision from our local vehicle (if we have one)
if (pLocalVehicle)
pLocalVehicle->WorldIgnore(true);
// Draw the nametags we need to
CVector vecPlayerPosition;
CClientVehicle* pPlayerVehicle = NULL;
float fDistanceExp;
bool bCollision;
CColPoint* pColPoint = NULL;
CEntity* pGameEntity = NULL;
CClientEntity* pEntity = NULL;
CClientPlayer* pPlayer;
CClientStreamElement* pElement;
list<CClientStreamElement*>::const_iterator iter = m_pPlayerStreamer->ActiveElementsBegin();
for (; iter != m_pPlayerStreamer->ActiveElementsEnd(); ++iter)
{
pElement = *iter;
if (!pElement->IsStreamedIn())
continue;
if (pElement->GetType() != CCLIENTPLAYER)
continue;
pPlayer = static_cast<CClientPlayer*>(pElement);
if (pPlayer->IsLocalPlayer())
continue;
// Get the distance from the camera
pPlayer->GetPosition(vecPlayerPosition);
fDistanceExp = pPlayer->GetExpDistance();
pPlayerVehicle = pPlayer->GetOccupiedVehicle();
// Is he in the same vehicle as the local player?
if ((pSniperTargetedPlayer == pPlayer) || (pSniperTargetedVehicle && pSniperTargetedVehicle == pPlayerVehicle) ||
(pLocalVehicle && pLocalVehicle == pPlayerVehicle) || (fDistanceExp < DEFAULT_VIEW_RANGE_EXP && pPlayer->IsOnScreen()))
{
SLineOfSightFlags flags;
flags.bCheckBuildings = true;
flags.bCheckVehicles = true;
flags.bCheckPeds = false;
flags.bCheckObjects = true;
bCollision = g_pCore->GetGame()->GetWorld()->ProcessLineOfSight(&CameraMatrix.vPos, &vecPlayerPosition, &pColPoint, &pGameEntity, flags);
if (!bCollision || (pGameEntity && pPlayerVehicle && pGameEntity == pPlayerVehicle->GetGameEntity()))
{
pPlayer->SetNametagDistance(sqrt(fDistanceExp));
playerTags.push_front(pPlayer);
}
// Destroy the colpoint
if (pColPoint)
pColPoint->Destroy();
}
}
// Readd collision from our local vehicle (if we have one)
if (pLocalVehicle)
pLocalVehicle->WorldIgnore(false);
// Draw each player's nametag
float fAlphaModifier;
unsigned char ucAlpha;
float fDistance;
list<CClientPlayer*>::iterator iterTags = playerTags.begin();
for (; iterTags != playerTags.end(); ++iterTags)
{
pPlayer = *iterTags;
fDistance = pPlayer->GetNametagDistance();
static float fFullAlphaDistance = 7.0f;
if ((fDistance < fFullAlphaDistance) || (pSniperTargetedPlayer && pSniperTargetedPlayer == pPlayer) ||
(pSniperTargetedVehicle && pSniperTargetedVehicle == pPlayer->GetOccupiedVehicle()))
{
fAlphaModifier = 1.0f;
}
else
{
fAlphaModifier = 1.0f - ((fDistance - fFullAlphaDistance) / (DEFAULT_VIEW_RANGE - fFullAlphaDistance));
}
// Calculate the alpha for the nametag
ucAlpha = static_cast<unsigned char>(180.0f * fAlphaModifier);
// Draw the tag
DrawTagForPlayer(pPlayer, ucAlpha);
}
}
void CFoo::Test ( const char* szString )
{
CClientManager* pManager = g_pClientGame->GetManager ();
CClientPlayer* pLocal = pManager->GetPlayerManager ()->GetLocalPlayer ();
CClientVehicleManager* pVehicleManager = pManager->GetVehicleManager ();
CVector vecLocal;
pLocal->GetPosition ( vecLocal );
CClientCamera* pCamera = pManager->GetCamera ();
// ChrML: Trying to reproduce mantis issue #2760
if ( stricmp ( szString, "2760" ) == 0 )
{
vecLocal = CVector ( 0.0f, 0.0f, 5.0f );
for ( int i = 0; i < 20; i++ )
{
vecLocal.fX += 5.0f;
CClientPlayer* pPlayer = new CClientPlayer ( pManager, i + 50 );
pPlayer->SetDeadOnNetwork ( false );
pPlayer->SetModel ( 168 + i );
pPlayer->AttachTo ( NULL );
pPlayer->SetFrozen ( false );
pPlayer->RemoveAllWeapons ();
pPlayer->Teleport ( vecLocal );
pPlayer->SetCameraRotation ( 0 );
pPlayer->ResetInterpolation ();
pPlayer->SetMoveSpeed ( CVector () );
pPlayer->SetHealth ( 100.0f );
pPlayer->SetArmor ( 0 );
pPlayer->SetCurrentRotation ( 0 );
pPlayer->SetInterior ( 0 );
pPlayer->SetDimension ( 0 );
}
pLocal->SetDeadOnNetwork ( false );
pLocal->SetModel ( 145 );
pLocal->AttachTo ( NULL );
pLocal->SetFrozen ( false );
pLocal->RemoveAllWeapons ();
pLocal->Teleport ( vecLocal );
pLocal->SetCameraRotation ( 0 );
pLocal->ResetInterpolation ();
pLocal->SetMoveSpeed ( CVector () );
pLocal->SetHealth ( 100.0f );
pLocal->SetArmor ( 0 );
pLocal->SetCurrentRotation ( 0 );
pLocal->SetInterior ( 0 );
pLocal->SetDimension ( 0 );
g_pClientGame->SetAllDimensions ( 0 );
// Reset return position so we can't warp back to where we were if local player
g_pClientGame->GetNetAPI ()->ResetReturnPosition ();
// Make sure the camera is normal
pCamera->SetFocusToLocalPlayer ();
pCamera->FadeIn ( 0.0f );
}
// Player load crash
else if ( stricmp ( szString, "2741" ) == 0 )
{
bFoo_PlayerLimitCrash = true;
}
//
else if ( strnicmp ( szString, "interp", 6 ) == 0 )
{
if ( pVehicleManager->Count () > 0 )
{
CClientVehicle* pVehicle = *pVehicleManager->IterBegin ();
float fdelta = atof ( szString + 7 );
CVector vecT;
pVehicle->GetPosition ( vecT );
vecT.fZ = fdelta;
pVehicle->SetTargetPosition ( vecT, TICK_RATE );
g_pCore->ChatPrintf ( "Done %f", false, fdelta );
static_cast < CDeathmatchVehicle* > ( pVehicle )->SetIsSyncing ( false );
}
}
//
else if ( strnicmp ( szString, "interr", 6 ) == 0 )
{
if ( pVehicleManager->Count () > 0 )
{
CClientVehicle* pVehicle = *pVehicleManager->IterBegin ();
CVector vecT;
pVehicle->GetRotationDegrees ( vecT );
vecT.fZ = atof ( szString + 7 );
pVehicle->SetTargetRotation ( vecT, TICK_RATE );
g_pCore->ChatPrintf ( "Done %f", false, atof ( szString + 7 ) );
static_cast < CDeathmatchVehicle* > ( pVehicle )->SetIsSyncing ( false );
}
}
else if ( stricmp ( szString, "choke" ) == 0 )
{
g_pClientGame->GetLocalPlayer ()->SetChoking ( true );
}
//
else if ( strnicmp ( szString, "static", 6 ) == 0 )
{
if ( pVehicleManager->Count () > 0 )
{
CClientVehicle* pVehicle = *pVehicleManager->IterBegin ();
pVehicle->GetGameVehicle ()->SetRemap ( atoi ( szString + 7 ) );
g_pCore->ChatPrintf ( "Set %i", false, atoi ( szString + 7 ) );
}
}
//
else if ( strnicmp ( szString, "getmass", 7 ) == 0 )
{
CClientVehicle* pVehicle = pLocal->GetOccupiedVehicle ();
if ( pVehicle )
{
g_pCore->ChatPrintf ( "Mass == %f", false, pVehicle->GetGameVehicle ()->GetMass () );
}
}
else if ( strnicmp ( szString, "setmass", 7 ) == 0 )
{
CClientVehicle* pVehicle = pLocal->GetOccupiedVehicle ();
if ( pVehicle )
{
pVehicle->GetGameVehicle ()->SetMass ( atof ( szString + 8 ) );
g_pCore->ChatPrintf ( "Set mass to %f", false, pVehicle->GetGameVehicle ()->GetMass () );
}
}
//
/*
else if ( strnicmp ( szString, "setmm", 5 ) == 0 )
{
CClientVehicle* pVehicle = pLocal->GetOccupiedVehicle ();
if ( pVehicle )
{
float fVal = atof ( szString + 6);
szString += 4;
float* fMass = (float*) atoi ( szString + 6 );
*fMass = fVal;
g_pCore->ChatPrintf ( "Set %X to %f", false, fMass, fVal );
}
}
*/
/*
else if ( stricmp ( szString, "getmm" ) == 0 )
{
CClientVehicle* pVehicle = pLocal->GetOccupiedVehicle ();
if ( pVehicle )
{
float* fMass = (float*) atoi ( szString );
g_pCore->ChatPrintf ( "Get %f", false, *fMass );
}
}
*/
/*
else if ( stricmp ( szString, "dump" ) == 0 )
{
FILE* poo = fopen ( "vehs.txt", "w+" );
if ( poo )
{
tHandlingData* pHandling = (tHandlingData*) 0xC2B9E0;
unsigned int uiIndex = 0;
for ( ; uiIndex < 219; uiIndex++ )
{
fprintf ( poo, "\n\n\n\n####### VEHICLE ID %u #######\n", uiIndex );
fprintf ( poo, "fMass = %f\n", pHandling->fMass );
fprintf ( poo, "fUnknown1 = %f\n", pHandling->fUnknown1 );
fprintf ( poo, "fTurnMass = %f\n", pHandling->fTurnMass );
fprintf ( poo, "fDragCoeff = %f\n", pHandling->fDragCoeff );
fprintf ( poo, "vecCenterOfMass = %f, %f, %f\n", pHandling->vecCenterOfMass.fX, pHandling->vecCenterOfMass.fY, pHandling->vecCenterOfMass.fZ );
fprintf ( poo, "uiPercentSubmerged = %u\n", pHandling->uiPercentSubmerged );
fprintf ( poo, "fUnknown2 = %f\n", pHandling->fUnknown2 );
fprintf ( poo, "fTractionMultiplier = %f\n", pHandling->fTractionMultiplier );
fprintf ( poo, "Transmission.fUnknown [0] = %f\n", pHandling->Transmission.fUnknown [0] );
fprintf ( poo, "Transmission.fUnknown [1] = %f\n", pHandling->Transmission.fUnknown [1] );
fprintf ( poo, "Transmission.fUnknown [2] = %f\n", pHandling->Transmission.fUnknown [2] );
fprintf ( poo, "Transmission.fUnknown [3] = %f\n", pHandling->Transmission.fUnknown [3] );
fprintf ( poo, "Transmission.fUnknown [4] = %f\n", pHandling->Transmission.fUnknown [4] );
fprintf ( poo, "Transmission.fUnknown [5] = %f\n", pHandling->Transmission.fUnknown [5] );
fprintf ( poo, "Transmission.fUnknown [6] = %f\n", pHandling->Transmission.fUnknown [6] );
fprintf ( poo, "Transmission.fUnknown [7] = %f\n", pHandling->Transmission.fUnknown [7] );
fprintf ( poo, "Transmission.fUnknown [8] = %f\n", pHandling->Transmission.fUnknown [8] );
fprintf ( poo, "Transmission.fUnknown [9] = %f\n", pHandling->Transmission.fUnknown [9] );
fprintf ( poo, "Transmission.fUnknown [10] = %f\n", pHandling->Transmission.fUnknown [10] );
fprintf ( poo, "Transmission.fUnknown [11] = %f\n", pHandling->Transmission.fUnknown [11] );
fprintf ( poo, "Transmission.fUnknown [12] = %f\n", pHandling->Transmission.fUnknown [12] );
fprintf ( poo, "Transmission.fUnknown [13] = %f\n", pHandling->Transmission.fUnknown [13] );
fprintf ( poo, "Transmission.fUnknown [14] = %f\n", pHandling->Transmission.fUnknown [14] );
fprintf ( poo, "Transmission.fUnknown [15] = %f\n", pHandling->Transmission.fUnknown [15] );
fprintf ( poo, "Transmission.fUnknown [16] = %f\n", pHandling->Transmission.fUnknown [16] );
fprintf ( poo, "Transmission.fUnknown [17] = %f\n", pHandling->Transmission.fUnknown [17] );
fprintf ( poo, "Transmission.ucDriveType = %c\n", pHandling->Transmission.ucDriveType );
fprintf ( poo, "Transmission.ucEngineType = %c\n", pHandling->Transmission.ucEngineType );
fprintf ( poo, "Transmission.ucNumberOfGears = %u\n", pHandling->Transmission.ucNumberOfGears );
fprintf ( poo, "Transmission.ucUnknown = %u\n", pHandling->Transmission.ucUnknown );
fprintf ( poo, "Transmission.uiHandlingFlags = 0x%X\n", pHandling->Transmission.uiHandlingFlags );
fprintf ( poo, "Transmission.fEngineAccelleration = %f\n", pHandling->Transmission.fEngineAccelleration );
fprintf ( poo, "Transmission.fEngineInertia = %f\n", pHandling->Transmission.fEngineInertia );
fprintf ( poo, "Transmission.fMaxVelocity = %f\n", pHandling->Transmission.fMaxVelocity );
fprintf ( poo, "Transmission.fUnknown2 [0] = %f\n", pHandling->Transmission.fUnknown2 [0] );
fprintf ( poo, "Transmission.fUnknown2 [1] = %f\n", pHandling->Transmission.fUnknown2 [1] );
fprintf ( poo, "Transmission.fUnknown2 [2] = %f\n", pHandling->Transmission.fUnknown2 [2] );
fprintf ( poo, "fBrakeDecelleration = %f\n", pHandling->fBrakeDecelleration );
fprintf ( poo, "fBrakeBias = %f\n", pHandling->fBrakeBias );
fprintf ( poo, "bABS = %u\n", pHandling->bABS );
fprintf ( poo, "fSteeringLock = %f\n", pHandling->fSteeringLock );
fprintf ( poo, "fTractionLoss = %f\n", pHandling->fTractionLoss );
fprintf ( poo, "fTractionBias = %f\n", pHandling->fTractionBias );
fprintf ( poo, "fSuspensionForceLevel = %f\n", pHandling->fSuspensionForceLevel );
fprintf ( poo, "fSuspensionDamping = %f\n", pHandling->fSuspensionDamping );
fprintf ( poo, "fSuspensionHighSpdDamping = %f\n", pHandling->fSuspensionHighSpdDamping );
fprintf ( poo, "fSuspensionUpperLimit = %f\n", pHandling->fSuspensionUpperLimit );
fprintf ( poo, "fSuspensionLowerLimit = %f\n", pHandling->fSuspensionLowerLimit );
fprintf ( poo, "fSuspensionFrontRearBias = %f\n", pHandling->fSuspensionFrontRearBias );
fprintf ( poo, "fSuspensionAntidiveMultiplier = %f\n", pHandling->fSuspensionAntidiveMultiplier );
fprintf ( poo, "fCollisionDamageMultiplier = %f\n", pHandling->fCollisionDamageMultiplier );
fprintf ( poo, "uiModelFlags = %X\n", pHandling->uiModelFlags );
fprintf ( poo, "uiHandlingFlags = %X\n", pHandling->uiHandlingFlags );
fprintf ( poo, "fSeatOffsetDistance = %f\n", pHandling->fSeatOffsetDistance );
fprintf ( poo, "uiMonetary = %u\n", pHandling->uiMonetary );
fprintf ( poo, "ucHeadLight = 0x%X\n", pHandling->ucHeadLight );
fprintf ( poo, "ucTailLight = 0x%X\n", pHandling->ucTailLight );
fprintf ( poo, "ucAnimGroup = 0x%X\n", pHandling->ucAnimGroup );
fprintf ( poo, "ucUnused = 0x%X\n", pHandling->ucUnused );
fprintf ( poo, "iUnknown7 = %f, %X\n", pHandling->iUnknown7, pHandling->iUnknown7 );
pHandling += 1;
}
g_pCore->ChatPrintf ( "Dumped", false );
fclose ( poo );
}
}
*/
else if ( strnicmp ( szString, "moveug", 6 ) == 0 )
{
if ( pVehicleManager->Count () > 0 )
{
CClientVehicle* pVehicle = *pVehicleManager->IterBegin ();
/*
CClientPed* pModel = pVehicle->GetOccupant ( 0 );
if ( !pModel )
{
CClientPlayer* pPlayer = new CClientPlayer ( g_pClientGame->GetManager (), 50 );
pModel = pPlayer->LoadModel ( 0 );
pModel->WarpIntoVehicle ( pVehicle );
}
*/
pVehicle->RemoveTargetPosition ();
pVehicle->RemoveTargetRotation ();
CVector vecT;
pVehicle->GetPosition ( vecT );
vecT.fZ = atof ( szString + 7 );
pVehicle->SetPosition ( vecT );
g_pCore->ChatPrintf ( "Done", false );
}
}
else if ( strnicmp ( szString, "nocol", 5 ) == 0 )
{
if ( pVehicleManager->Count () > 0 )
{
CClientVehicle* pVehicle = *pVehicleManager->IterBegin ();
pVehicle->SetCollisionEnabled ( false );
g_pCore->ChatPrintf ( "Done", false );
}
}
else if ( stricmp ( szString, "resetdamage" ) == 0 )
{
g_pClientGame->GetPlayerManager ()->GetLocalPlayer ()->GetGamePlayer ()->ResetLastDamage ();
}
else if ( strnicmp ( szString, "fuckveh", 7 ) == 0 )
{
CClientVehicle* pVehicle = pLocal->GetOccupiedVehicle ();
if ( pVehicle )
{
pVehicle->SetTargetPosition ( CVector ( 0, 0, 0 ), TICK_RATE );
pVehicle->SetTargetRotation ( CVector ( 0, 0, 0 ), TICK_RATE );
g_pCore->ChatPrintf ( "Done", false );
}
}
else if ( stricmp ( szString, "ped" ) == 0 )
{
CClientPed* pPed = new CClientPed ( g_pClientGame->GetManager (), INVALID_ELEMENT_ID, 9 );
vecLocal.fX += 5.0f;
pPed->SetPosition ( vecLocal );
}
else if ( strnicmp ( szString, "callit", 6 ) == 0 )
{
FILE* pFile = fopen ( "C:/dump.txt", "w+" );
for ( int i = 0; i < 400; i++ )
{
int iIndex = i;
const char* szName = NULL;
_asm
{
mov eax, 0x4D3A30
push iIndex
call eax
mov szName, eax
add esp, 4
}
fprintf ( pFile, "%i: %s\n", iIndex, szName );
}
fclose ( pFile );
}
else if ( strnicmp ( szString, "veh", 3 ) == 0 )
{
int i = 600;
FILE* p = fopen ( "C:/dump.txt", "w+" );
for ( int a = 0; a < 13; a++ )
{
g_pGame->GetModelInfo ( i )->AddRef ( true );
CVehicle* pVehicle = g_pGame->GetPools ()->AddVehicle ( (eVehicleTypes)i );
DWORD* dw2 = (DWORD*)(((DWORD)pVehicle->GetVehicleInterface ()) + 0xE1 * 4 );
DWORD dw = *dw2;
dw = dw + 4;
dw = dw - 0xC2B9E0;
dw = dw / 224;
fprintf ( p, "Array [%u] = %u;\n", i, dw );
g_pGame->GetPools ()->RemoveVehicle ( pVehicle );
fflush ( p );
g_pGame->GetModelInfo ( i )->RemoveRef ( );
i++;
}
fclose ( p );
}
else if ( strnicmp ( szString, "groups", 6 ) == 0 )
{
FILE* pFile = fopen ( "C:/dump.txt", "w+" );
int i = 0;
for ( ; i < 139; i++ )
{
fprintf ( pFile, "==%s [%s] (%i)==\n", pGroups [i].szGroupName, pGroups [i].szSomething, i );
int i2 = 0;
for ( ; i2 < pGroups [i].ulAnimCount; i2++ )
{
const char* szAnimName = pGroups [i].pAnimNames [i2];
if ( szAnimName [0] )
{
fprintf ( pFile, "''%i'': %s<br>\n", i2, szAnimName );
}
}
fprintf ( pFile, "\n" );
}
fclose ( pFile );
}
else if ( strnicmp ( szString, "getshot", 7 ) == 0 )
{
if ( pLocal->GetGamePlayer ()->GetCanBeShotInVehicle () )
{
g_pCore->ChatEcho ( "true" );
}
else
{
g_pCore->ChatEcho ( "false" );
}
}
else if ( strnicmp ( szString, "gettest", 7 ) == 0 )
{
if ( pLocal->GetGamePlayer ()->GetTestForShotInVehicle () )
{
g_pCore->ChatEcho ( "true" );
}
else
{
g_pCore->ChatEcho ( "false" );
}
}
else if ( strnicmp ( szString, "setshot", 7 ) == 0 )
{
pLocal->GetGamePlayer ()->SetCanBeShotInVehicle ( true );
}
else if ( strnicmp ( szString, "settest", 8 ) == 0 )
{
pLocal->GetGamePlayer ()->SetTestForShotInVehicle ( true );
}
else if ( stricmp ( szString, "applytest" ) == 0 )
{
DWORD oldProt, oldProt2;
VirtualProtect((LPVOID)0x5E8FFB,6,PAGE_EXECUTE_READWRITE,&oldProt);
*(unsigned char*) (0x5E8FFB ) = 0x90;
*(unsigned char*) (0x5E8FFC ) = 0x90;
*(unsigned char*) (0x5E8FFD ) = 0x90;
*(unsigned char*) (0x5E8FFE ) = 0x90;
*(unsigned char*) (0x5E8FFF ) = 0x90;
*(unsigned char*) (0x5E9000 ) = 0x90;
VirtualProtect((LPVOID)0x5E8FFB,6,oldProt,&oldProt2);
}
}
void CNametags::DrawFromAim()
{
unsigned long ulCurrentTime = CClientTime::GetTime();
// Got any players that are not local?
if (m_pPlayerManager->Count() > 1)
{
// Grab the local player
CClientPlayer* pLocalPlayer = m_pPlayerManager->GetLocalPlayer();
if (pLocalPlayer)
{
// Grab the current time and the camera
unsigned long ulCurrentTime = CClientTime::GetTime();
CCamera* pCamera = g_pGame->GetCamera();
// Grab our controller state
CControllerState State;
g_pGame->GetPad()->GetCurrentControllerState(&State);
// Grab our current weapon slot. Use screen center if melee or none
CVector vecStart;
CVector vecTarget;
eWeaponSlot eSlot = pLocalPlayer->GetCurrentWeaponSlot();
if (eSlot == WEAPONSLOT_TYPE_UNARMED || eSlot == WEAPONSLOT_TYPE_MELEE || eSlot == WEAPONSLOT_TYPE_RIFLE || eSlot == WEAPONSLOT_TYPE_THROWN ||
eSlot == WEAPONSLOT_TYPE_SPECIAL || eSlot == WEAPONSLOT_TYPE_GIFT || eSlot == WEAPONSLOT_TYPE_PARACHUTE || eSlot == WEAPONSLOT_TYPE_DETONATOR)
{
// Grab the active cam
CCamera* pCamera = g_pGame->GetCamera();
CCam* pActive = pCamera->GetCam(pCamera->GetActiveCam());
// Grab the camera matrix
CMatrix matCamera;
pCamera->GetMatrix(&matCamera);
vecStart = matCamera.vPos;
// Range
float fRange;
eWeaponType eWeapon = pLocalPlayer->GetCurrentWeaponType();
float fSkill = pLocalPlayer->GetStat(g_pGame->GetStats()->GetSkillStatIndex(eWeapon));
CWeaponStat* pWeaponStat = g_pGame->GetWeaponStatManager()->GetWeaponStatsFromSkillLevel(eWeapon, fSkill);
if (pWeaponStat)
{
fRange = pWeaponStat->GetTargetRange();
}
else
{
fRange = MELEE_VISIBLE_RANGE;
}
// Find the target position
CVector vecFront = *pActive->GetFront();
vecFront.Normalize();
vecTarget = *pActive->GetSource() + vecFront * fRange;
}
else
{
// Grab the weapon and keysync state. If it exists and he holds Target down
CWeapon* pPlayerWeapon = pLocalPlayer->GetWeapon();
if (pPlayerWeapon && State.RightShoulder1)
{
// Grab the gun muzzle position
eWeaponType eWeapon = pLocalPlayer->GetCurrentWeaponType();
float fSkill = pLocalPlayer->GetStat(g_pGame->GetStats()->GetSkillStatIndex(eWeapon));
CWeaponStat* pWeaponStat = g_pGame->GetWeaponStatManager()->GetWeaponStatsFromSkillLevel(eWeapon, fSkill);
CVector vecGunMuzzle = *pWeaponStat->GetFireOffset();
pLocalPlayer->GetTransformedBonePosition(BONE_RIGHTWRIST, vecGunMuzzle);
// Grab the target point
pCamera->Find3rdPersonCamTargetVector(AIM_VISIBLE_RANGE, &vecGunMuzzle, &vecStart, &vecTarget);
}
else
{
// Grab the active cam
CCam* pActive = pCamera->GetCam(pCamera->GetActiveCam());
// Grab the camera matrix
CMatrix matCamera;
pCamera->GetMatrix(&matCamera);
vecStart = matCamera.vPos;
// Find the target position
CVector vecFront = *pActive->GetFront();
vecFront.Normalize();
vecTarget = *pActive->GetSource() + vecFront * MELEE_VISIBLE_RANGE;
}
}
// Ignore the local player for this
pLocalPlayer->WorldIgnore(true);
// Do the raycast
CColPoint* pColPoint = NULL;
CEntity* pEntity = NULL;
SLineOfSightFlags flags;
flags.bCheckBuildings = true;
flags.bCheckVehicles = true;
flags.bCheckPeds = true;
flags.bCheckObjects = true;
flags.bCheckDummies = true;
flags.bSeeThroughStuff = true;
flags.bIgnoreSomeObjectsForCamera = false;
flags.bShootThroughStuff = true;
g_pGame->GetWorld()->ProcessLineOfSight(&vecStart, &vecTarget, &pColPoint, &pEntity, flags);
if (pColPoint)
pColPoint->Destroy();
// Un-ignore the local player
pLocalPlayer->WorldIgnore(false);
// Did we find an entity?
if (pEntity)
{
// Grab the CClientEntity belonging to this game_sa entity
CClientEntity* pClientEntity = reinterpret_cast<CClientEntity*>(pEntity->GetStoredPointer());
if (pClientEntity)
{
// Is it a vehicle? Is it a ped?
eClientEntityType EntityType = pClientEntity->GetType();
if (EntityType == CCLIENTVEHICLE)
{
CClientVehicle* pClientVehicle = static_cast<CClientVehicle*>(pClientEntity);
// Set the current time as the last draw time for all players inside
CClientPed* pPed;
int i;
for (i = 0; i < 8; i++)
{
// Grab this seat's occupant and set its last nametag show time to now
pPed = pClientVehicle->GetOccupant(i);
if (pPed && pPed->GetType() == CCLIENTPLAYER)
{
static_cast<CClientPlayer*>(pPed)->SetLastNametagShow(ulCurrentTime);
}
}
}
else if (EntityType == CCLIENTPLAYER)
{
// Grab the player this entity is
CClientPlayer* pClientPlayer = static_cast<CClientPlayer*>(pClientEntity);
if (pClientPlayer)
{
// Set now as the last time we had the cursor above him
pClientPlayer->SetLastNametagShow(ulCurrentTime);
}
}
}
}
// Grab the local player vehicle
CClientVehicle* pLocalVehicle = pLocalPlayer->GetOccupiedVehicle();
// Draw the nametags we need to
CClientPlayer* pPlayer;
CClientStreamElement* pElement;
list<CClientStreamElement*>::const_iterator iter = m_pPlayerStreamer->ActiveElementsBegin();
for (; iter != m_pPlayerStreamer->ActiveElementsEnd(); ++iter)
{
pElement = *iter;
if (!pElement->IsStreamedIn())
continue;
if (pElement->GetType() != CCLIENTPLAYER)
continue;
pPlayer = static_cast<CClientPlayer*>(pElement);
if (pPlayer->IsLocalPlayer())
continue;
// Is he in the same vehicle as the local player?
if (pLocalVehicle && pPlayer->GetOccupiedVehicle() == pLocalVehicle)
{
pPlayer->SetLastNametagShow(ulCurrentTime);
}
// Can we show this player's nametag
unsigned long ulLastNametagShow = pPlayer->GetLastNametagShow();
if (ulLastNametagShow != 0 && ulCurrentTime <= ulLastNametagShow + NAMETAG_END_FADE_TIME)
{
unsigned long ulLastNametagShow = pPlayer->GetLastNametagShow();
// Calculate the alpha modifier
float fAlphaTimeModifier;
if (ulCurrentTime < ulLastNametagShow + NAMETAG_BEGIN_FADE_TIME)
{
fAlphaTimeModifier = 1.0f;
}
else
{
fAlphaTimeModifier = 1.0f - (ulCurrentTime - ulLastNametagShow - NAMETAG_BEGIN_FADE_TIME) / 1000.0f;
}
// Calculate the alpha for the nametag
unsigned char ucAlpha = static_cast<unsigned char>(180.0f * fAlphaTimeModifier);
// Draw it
DrawTagForPlayer(pPlayer, ucAlpha);
}
}
}
}
}
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
{
FurthestStreamedInList.push_back( pElement );
}
}
else
{
// Same dimension as us?
if ( pElement->GetDimension () == m_usDimension )
{
// Too far away? Stop here.
if ( fElementDistanceExp > m_fMaxDistanceExp )
continue;
if ( IS_VEHICLE ( pElement ) )
{
CClientVehicle* pVehicle = DynamicCast < CClientVehicle > ( pElement );
if ( pVehicle && 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 isn't streaming in soon.
continue;
}
}
if ( pVehicle && pVehicle->GetTowedByVehicle ( ) )
{
// Streaming in of towed vehicles is done in CClientVehicle::StreamIn 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 streaming in soon.
continue;
}
}
// If attached and attached-to is streamed out, don't consider for streaming in
CClientStreamElement* pAttachedTo = DynamicCast< CClientStreamElement >( pElement->GetAttachedTo() );
if ( pAttachedTo && !pAttachedTo->IsStreamedIn() )
{
// ...unless attached to low LOD version
CClientObject* pAttachedToObject = DynamicCast < CClientObject > ( pAttachedTo );
CClientObject* pObject = DynamicCast < CClientObject > ( pElement );
if ( !pObject || !pAttachedToObject || pObject->IsLowLod () == pAttachedToObject->IsLowLod () )
continue;
}
// Not room to stream in more elements?
if ( bReachedLimit )
{
// Add to the list that might be streamed in during the final phase
if ( (int)ClosestStreamedOutList.size() < iMaxIn ) // (only add if there is a chance it will be used)
ClosestStreamedOutList.push_back( pElement );
}
else
{
// Stream in the new element. Don't do it instantly unless moved from far away.
pElement->InternalStreamIn ( bMovedFar );
bReachedLimit = ReachedLimit ();
if ( !bReachedLimit )
{
iMaxIn--;
if ( iMaxIn <= 0 )
break;
}
}
}
}
}
// Complex code of doom:
// ClosestStreamedOutList is {nearest to furthest} list of streamed out elements within streaming distance
// FurthestStreamedInList is {nearest to furthest} list of streamed in elements
if ( bReachedLimit )
{
// Check 'furthest streamed in' against 'closest streamed out' to see if the state can be swapped
int iFurthestStreamedInIndex = FurthestStreamedInList.size() - 1;
uint uiClosestStreamedOutIndex = 0;
for( uint i = 0 ; i < 10 ; i++ )
{
// Check limits for this frame
if ( iMaxIn <= 0 || iMaxOut <= 0 )
break;
// Check indicies are valid
if ( iFurthestStreamedInIndex < 0 )
break;
if ( uiClosestStreamedOutIndex >= ClosestStreamedOutList.size() )
break;
// See if ClosestStreamedOut is nearer than FurthestStreamedIn
CClientStreamElement* pFurthestStreamedIn = FurthestStreamedInList[ iFurthestStreamedInIndex ];
CClientStreamElement* pClosestStreamedOut = ClosestStreamedOutList[ uiClosestStreamedOutIndex ];
if ( pClosestStreamedOut->GetExpDistance () >= pFurthestStreamedIn->GetExpDistance () )
break;
// Stream out FurthestStreamedIn candidate if possible
if ( pFurthestStreamedIn->GetTotalStreamReferences () == 0 )
{
// Stream out now
pFurthestStreamedIn->InternalStreamOut ();
iMaxOut--;
}
m_ToStreamOut.remove ( pFurthestStreamedIn );
iFurthestStreamedInIndex--; // Always advance to the next candidate
// Stream in ClosestStreamedOut candidate if possible
if ( !ReachedLimit () )
{
// Stream in the new element. No need to do it instantly unless moved from far away.
pClosestStreamedOut->InternalStreamIn ( bMovedFar );
iMaxIn--;
uiClosestStreamedOutIndex++;
}
}
}
}
