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 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 ();
}
void cheat_handle_quickwarp(struct vehicle_info *vehicle_info, struct actor_info *actor_info)
{
if (KEYCOMBO_PRESSED(set.key_quickwarp))
{
CCam *pCam = pGame->GetCamera()->GetCam(pGame->GetCamera()->GetActiveCam());
CVector camsrc(*pCam->GetSource()), src, target, tppos;
CColPoint *pCollision = nullptr;
CEntitySAInterface *pEntity = nullptr;
if (pCam->GetMode() == MODE_AIMWEAPON || pCam->GetMode() == MODE_AIMWEAPON_ATTACHED || pCam->GetMode() == MODE_AIMWEAPON_FROMCAR)
{
// calculate target position by aim vector
pGame->GetCamera()->Find3rdPersonCamTargetVector(700.0f, &camsrc, &src, &target);
}
else
{
// else by camera vector
target = camsrc + *pCam->GetFront() * 700.0f;
}
// ignore self vehicle
if (vehicle_info != nullptr)
{
*(::vehicle_info **)VAR_IgnoredEntity = vehicle_info;
}
if (GTAfunc_ProcessLineOfSight(&camsrc, &target, &pCollision, &pEntity, true, true, false, true, true, false, false, false))
{
tppos = *pCollision->GetPosition();
tppos -= (*pCollision->GetNormal()) * 0.5f;
if (pCollision->GetNormal()->fZ >= 0.5f || pPedSelf->GetAreaCode() != 0)
{
tppos.fZ += 1.0f;
tppos.fZ = pGameInterface->GetWorld()->FindGroundZFor3DPosition(&tppos);
}
else
{
tppos.fZ = pGameInterface->GetWorld()->FindGroundZForPosition(tppos.fX, tppos.fY);
}
if (vehicle_info != nullptr)
{
// check for collision
CVehicle *vehSelf = pPedSelf->GetVehicle();
if (vehSelf)
{
pCollision->Destroy();
// check for collision
CVector vecVehicleGravity;
vehSelf->GetGravity(&vecVehicleGravity);
CVector vecVehicleAbove = (-vecVehicleGravity * 5.0f) + tppos;
CVector vecVehicleBelow = (vecVehicleGravity * 5.0f) + tppos;
bool bCollision = GTAfunc_ProcessLineOfSight(&vecVehicleAbove, &vecVehicleBelow, &pCollision, &pEntity,
true, false, false, true, true, false, false, false); // not checking for vehicle collisions
if (bCollision && pCollision)
{
// set vehicle to same Up position has surface normal
CMatrix matVehicleSelf;
vehSelf->GetMatrix(&matVehicleSelf);
CVector vecCollisionNormal = *pCollision->GetNormal();
// get "down" from vehicle model
CVector rotationAxis = matVehicleSelf.vUp;
// normalize our vectors
vecCollisionNormal.Normalize();
rotationAxis.Normalize();
// axis and rotation for gravity
float theta = acos(rotationAxis.DotProduct(&vecCollisionNormal));
if (!near_zero(theta))
{
rotationAxis.CrossProduct(&vecCollisionNormal);
rotationAxis.Normalize();
rotationAxis.ZeroNearZero();
matVehicleSelf = matVehicleSelf.Rotate(&rotationAxis, -theta);
}
// set the new matrix
vehSelf->SetMatrix(&matVehicleSelf);
// set pos floats for actual teleporting
tppos.fX = pCollision->GetPosition()->fX;
tppos.fY = pCollision->GetPosition()->fY;
tppos.fZ = pCollision->GetPosition()->fZ + 1.0f; // should be enough to stay above the ground properly
}
else
{
tppos.fZ += 0.5f;
}
cheat_vehicle_teleport(vehicle_info, &tppos.fX, gta_interior_id_get(), true);
}
}
else if (actor_info != nullptr)
{
tppos.fZ += 1.0f;
cheat_actor_teleport(actor_info, &tppos.fX, gta_interior_id_get());
}
GTAfunc_TogglePlayerControllable(0);
GTAfunc_LockActor(0);
}
if (pCollision != nullptr)
{
pCollision->Destroy();
}
}
}
int CLuaFunctionDefs::ProcessLineOfSight ( lua_State * luaVM )
{
int iArgument1 = lua_type ( luaVM, 1 );
int iArgument2 = lua_type ( luaVM, 2 );
int iArgument3 = lua_type ( luaVM, 3 );
int iArgument4 = lua_type ( luaVM, 4 );
int iArgument5 = lua_type ( luaVM, 5 );
int iArgument6 = lua_type ( luaVM, 6 );
if ( ( iArgument1 == LUA_TNUMBER || iArgument1 == LUA_TSTRING ) &&
( iArgument2 == LUA_TNUMBER || iArgument2 == LUA_TSTRING ) &&
( iArgument3 == LUA_TNUMBER || iArgument3 == LUA_TSTRING ) &&
( iArgument4 == LUA_TNUMBER || iArgument4 == LUA_TSTRING ) &&
( iArgument5 == LUA_TNUMBER || iArgument5 == LUA_TSTRING ) &&
( iArgument6 == LUA_TNUMBER || iArgument6 == LUA_TSTRING ) )
{
CVector vecStart ( static_cast < float > ( lua_tonumber ( luaVM, 1 ) ),
static_cast < float > ( lua_tonumber ( luaVM, 2 ) ),
static_cast < float > ( lua_tonumber ( luaVM, 3 ) ) );
CVector vecEnd ( static_cast < float > ( lua_tonumber ( luaVM, 4 ) ),
static_cast < float > ( lua_tonumber ( luaVM, 5 ) ),
static_cast < float > ( lua_tonumber ( luaVM, 6 ) ) );
CColPoint* pColPoint = NULL;
CClientEntity* pColEntity = NULL;
bool bCheckBuildings = true, bCheckVehicles = true, bCheckPeds = true, bCheckObjects = true, bCheckDummies = true, bSeeThroughStuff = false, bIgnoreSomeObjectsForCamera = false, bShootThroughStuff = false;
CEntity* pIgnoredEntity = NULL;
if ( lua_type ( luaVM, 7 ) == LUA_TBOOLEAN )
{
bCheckBuildings = ( lua_toboolean ( luaVM, 7 ) ) ? true:false;
if ( lua_type ( luaVM, 8 ) == LUA_TBOOLEAN )
{
bCheckVehicles = ( lua_toboolean ( luaVM, 8 ) ) ? true:false;
if ( lua_type ( luaVM, 9 ) == LUA_TBOOLEAN )
{
bCheckPeds = ( lua_toboolean ( luaVM, 9 ) ) ? true:false;
if ( lua_type ( luaVM, 10 ) == LUA_TBOOLEAN )
{
bCheckObjects = ( lua_toboolean ( luaVM, 10 ) ) ? true:false;
if ( lua_type ( luaVM, 11 ) == LUA_TBOOLEAN )
{
bCheckDummies = ( lua_toboolean ( luaVM, 11 ) ) ? true:false;
if ( lua_type ( luaVM, 12 ) == LUA_TBOOLEAN )
{
bSeeThroughStuff = ( lua_toboolean ( luaVM, 12 ) ) ? true:false;
if ( lua_type ( luaVM, 13 ) == LUA_TBOOLEAN )
{
bIgnoreSomeObjectsForCamera = ( lua_toboolean ( luaVM, 13 ) ) ? true:false;
if ( lua_type ( luaVM, 14 ) == LUA_TBOOLEAN )
{
bShootThroughStuff = ( lua_toboolean ( luaVM, 14 ) ) ? true:false;
if ( lua_type ( luaVM, 15 ) == LUA_TLIGHTUSERDATA )
{
CClientEntity* pEntity = lua_toelement ( luaVM, 15 );
if ( pEntity )
{
switch ( pEntity->GetType () )
{
case CCLIENTPED:
case CCLIENTPLAYER:
pIgnoredEntity = static_cast < CClientPed* > ( pEntity )->GetGamePlayer ();
break;
case CCLIENTVEHICLE:
pIgnoredEntity = static_cast < CClientVehicle* > ( pEntity )->GetGameVehicle ();
break;
case CCLIENTOBJECT:
pIgnoredEntity = static_cast < CClientObject* > ( pEntity )->GetGameObject ();
break;
}
}
}
}
}
}
}
}
}
}
}
bool bCollision;
if ( CStaticFunctionDefinitions::ProcessLineOfSight ( vecStart, vecEnd, bCollision, &pColPoint, &pColEntity, bCheckBuildings, bCheckVehicles, bCheckPeds, bCheckObjects, bCheckDummies, bSeeThroughStuff, bIgnoreSomeObjectsForCamera, bShootThroughStuff, pIgnoredEntity ) )
{
// Got a collision?
CVector vecColPosition;
if ( pColPoint )
{
// Get the collision position
vecColPosition = *pColPoint->GetPosition ();
// Delete the colpoint
pColPoint->Destroy ();
}
lua_pushboolean ( luaVM, bCollision );
if ( bCollision )
{
lua_pushnumber ( luaVM, vecColPosition.fX );
lua_pushnumber ( luaVM, vecColPosition.fY );
lua_pushnumber ( luaVM, vecColPosition.fZ );
if ( pColEntity )
lua_pushelement ( luaVM, pColEntity );
else
lua_pushnil ( luaVM );
return 5;
}
return 1;
}
}
else
m_pScriptDebugging->LogBadType ( luaVM, "processLineOfSight" );
lua_pushboolean ( luaVM, false );
return 1;
}
void CClientWeapon::FireInstantHit ( CVector & vecOrigin, CVector & vecTarget )
#endif
{
CVector vecDirection = vecTarget - vecOrigin;
vecDirection.Normalize ();
CClientEntity * pAttachedTo = GetAttachedTo ();
CEntity * pColEntity = NULL;
CColPoint * pColPoint = NULL;
SLineOfSightBuildingResult pBuildingResult;
CEntitySAInterface * pEntity = NULL;
if ( m_Type != WEAPONTYPE_SHOTGUN )
{
//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 )
{
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 ) )
{
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 ( pColEntity && pColEntity->GetEntityType () == ENTITY_TYPE_PED )
{
ePedPieceTypes hitZone = ( ePedPieceTypes ) pColPoint->GetPieceTypeB ();
short sDamage = m_pWeaponInfo->GetDamagePerHit ();
m_pWeapon->GenerateDamageEvent ( dynamic_cast < CPed * > ( pColEntity ), m_pObject, m_Type, sDamage, hitZone, 0 );
}
}
#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 ();
}
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);
}
}
}
}
}