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++; } } } }