void CMomentumGameMovement::PlayerMove()
{
BaseClass::PlayerMove();
if (player->IsAlive())
{
// Check if our eye height is too close to the ceiling and lower it.
// This is needed because we have taller models with the old collision bounds.
const float eyeClearance = 12.0f; // eye pos must be this far below the ceiling
Vector offset = player->GetViewOffset();
Vector vHullMin = GetPlayerMins(player->m_Local.m_bDucked);
vHullMin.z = 0.0f;
Vector vHullMax = GetPlayerMaxs(player->m_Local.m_bDucked);
Vector start = player->GetAbsOrigin();
start.z += vHullMax.z;
Vector end = start;
end.z += eyeClearance - vHullMax.z;
end.z += player->m_Local.m_bDucked ? VEC_DUCK_VIEW.z : VEC_VIEW.z;
vHullMax.z = 0.0f;
Vector fudge(1, 1, 0);
vHullMin += fudge;
vHullMax -= fudge;
trace_t trace;
Ray_t ray;
ray.Init(start, end, vHullMin, vHullMax);
UTIL_TraceRay(ray, PlayerSolidMask(), mv->m_nPlayerHandle.Get(), COLLISION_GROUP_PLAYER_MOVEMENT, &trace);
if (trace.fraction < 1.0f)
{
float est = start.z + trace.fraction * (end.z - start.z) - player->GetAbsOrigin().z - eyeClearance;
if ((player->GetFlags() & FL_DUCKING) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked)
{
offset.z = est;
}
else
{
offset.z = min(est, offset.z);
}
player->SetViewOffset(offset);
}
else
{
if ((player->GetFlags() & FL_DUCKING) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked)
{
player->SetViewOffset(VEC_VIEW);
}
else if (player->m_Local.m_bDucked && !player->m_Local.m_bDucking)
{
player->SetViewOffset(VEC_DUCK_VIEW);
}
}
}
}
surfacedata_t* C_ASW_Alien::GetGroundSurface()
{
//
// Find the name of the material that lies beneath the player.
//
Vector start, end;
VectorCopy( GetAbsOrigin(), start );
VectorCopy( start, end );
// Straight down
end.z -= 38; // was 64
// Fill in default values, just in case.
Ray_t ray;
ray.Init( start, end, GetCollideable()->OBBMins(), GetCollideable()->OBBMaxs() );
trace_t trace;
UTIL_TraceRay( ray, MASK_NPCSOLID_BRUSHONLY, this, COLLISION_GROUP_NPC, &trace );
if ( trace.fraction == 1.0f )
return NULL; // no ground
return physprops->GetSurfaceData( trace.surface.surfaceProps );
}
inline void CSDKGameMovement::TracePlayerBBoxWithStep( const Vector &vStart, const Vector &vEnd,
unsigned int fMask, int collisionGroup, trace_t &trace )
{
VPROF( "CSDKGameMovement::TracePlayerBBoxWithStep" );
Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
vHullMin.z += player->m_Local.m_flStepSize;
Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );
Ray_t ray;
ray.Init( vStart, vEnd, vHullMin, vHullMax );
UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &trace );
}
void RagdollSolveSeparation( ragdoll_t &ragdoll, CBaseEntity *pEntity )
{
byte needsFix[256];
int fixCount = 0;
Assert(ragdoll.listCount<=ARRAYSIZE(needsFix));
for ( int i = 0; i < ragdoll.listCount; i++ )
{
needsFix[i] = 0;
const ragdollelement_t &element = ragdoll.list[i];
if ( element.pConstraint && element.parentIndex >= 0 )
{
Vector start, target;
element.pObject->GetPosition( &start, NULL );
ragdoll.list[element.parentIndex].pObject->LocalToWorld( &target, element.originParentSpace );
if ( needsFix[element.parentIndex] )
{
needsFix[i] = 1;
++fixCount;
continue;
}
Vector dir = target-start;
if ( dir.LengthSqr() > 1.0f )
{
// this fixes a bug in ep2 with antlion grubs, but causes problems in TF2 - revisit, but disable for TF now
#if !defined(TF_CLIENT_DLL)
// heuristic: guess that anything separated and small mass ratio is in some state that's
// keeping the solver from fixing it
float mass = element.pObject->GetMass();
float massParent = ragdoll.list[element.parentIndex].pObject->GetMass();
if ( mass*2.0f < massParent )
{
// if this is <0.5 mass of parent and still separated it's attached to something heavy or
// in a bad state
needsFix[i] = 1;
++fixCount;
continue;
}
#endif
if ( PhysHasContactWithOtherInDirection(element.pObject, dir) )
{
Ray_t ray;
trace_t tr;
ray.Init( target, start );
UTIL_TraceRay( ray, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tr );
if ( tr.DidHit() )
{
needsFix[i] = 1;
++fixCount;
}
}
}
}
}
if ( fixCount )
{
for ( int i = 0; i < ragdoll.listCount; i++ )
{
if ( !needsFix[i] )
continue;
const ragdollelement_t &element = ragdoll.list[i];
Vector target, velocity;
ragdoll.list[element.parentIndex].pObject->LocalToWorld( &target, element.originParentSpace );
ragdoll.list[element.parentIndex].pObject->GetVelocityAtPoint( target, &velocity );
matrix3x4_t xform;
element.pObject->GetPositionMatrix( &xform );
MatrixSetColumn( target, 3, xform );
element.pObject->SetPositionMatrix( xform, true );
element.pObject->SetVelocity( &velocity, &vec3_origin );
}
DevMsg(2, "TICK:%5d:Ragdoll separation count: %d\n", gpGlobals->tickcount, fixCount );
}
else
{
ragdoll.pGroup->ClearErrorState();
}
}
void TracePlayerBBoxForGround2( const Vector& start, const Vector& end, const Vector& minsSrc,
const Vector& maxsSrc, IHandleEntity *player, unsigned int fMask,
int collisionGroup, trace_t& pm )
{
VPROF( "TracePlayerBBoxForGround" );
CPortal_Player *pPortalPlayer = dynamic_cast<CPortal_Player *>(player->GetRefEHandle().Get());
CProp_Portal *pPlayerPortal = pPortalPlayer->m_hPortalEnvironment;
#ifndef CLIENT_DLL
if( pPlayerPortal && pPlayerPortal->m_PortalSimulator.IsReadyToSimulate() == false )
pPlayerPortal = NULL;
#endif
Ray_t ray;
Vector mins, maxs;
float fraction = pm.fraction;
Vector endpos = pm.endpos;
// Check the -x, -y quadrant
mins = minsSrc;
maxs.Init( MIN( 0, maxsSrc.x ), MIN( 0, maxsSrc.y ), maxsSrc.z );
ray.Init( start, end, mins, maxs );
if( pPlayerPortal )
UTIL_Portal_TraceRay( pPlayerPortal, ray, fMask, player, collisionGroup, &pm );
else
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
{
pm.fraction = fraction;
pm.endpos = endpos;
return;
}
// Check the +x, +y quadrant
mins.Init( MAX( 0, minsSrc.x ), MAX( 0, minsSrc.y ), minsSrc.z );
maxs = maxsSrc;
ray.Init( start, end, mins, maxs );
if( pPlayerPortal )
UTIL_Portal_TraceRay( pPlayerPortal, ray, fMask, player, collisionGroup, &pm );
else
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
{
pm.fraction = fraction;
pm.endpos = endpos;
return;
}
// Check the -x, +y quadrant
mins.Init( minsSrc.x, MAX( 0, minsSrc.y ), minsSrc.z );
maxs.Init( MIN( 0, maxsSrc.x ), maxsSrc.y, maxsSrc.z );
ray.Init( start, end, mins, maxs );
if( pPlayerPortal )
UTIL_Portal_TraceRay( pPlayerPortal, ray, fMask, player, collisionGroup, &pm );
else
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
{
pm.fraction = fraction;
pm.endpos = endpos;
return;
}
// Check the +x, -y quadrant
mins.Init( MAX( 0, minsSrc.x ), minsSrc.y, minsSrc.z );
maxs.Init( maxsSrc.x, MIN( 0, maxsSrc.y ), maxsSrc.z );
ray.Init( start, end, mins, maxs );
if( pPlayerPortal )
UTIL_Portal_TraceRay( pPlayerPortal, ray, fMask, player, collisionGroup, &pm );
else
UTIL_TraceRay( ray, fMask, player, collisionGroup, &pm );
if ( pm.m_pEnt && pm.plane.normal[2] >= 0.7)
{
pm.fraction = fraction;
pm.endpos = endpos;
return;
}
pm.fraction = fraction;
pm.endpos = endpos;
}
//-----------------------------------------------------------------------------
// Purpose: Game ray-traces in vphysics.
//-----------------------------------------------------------------------------
void CPhysicsGameTrace::VehicleTraceRayWithWater( const Ray_t &ray, void *pVehicle, trace_t *pTrace )
{
CBaseEntity *pBaseEntity = static_cast<CBaseEntity*>( pVehicle );
UTIL_TraceRay( ray, MASK_SOLID|MASK_WATER, pBaseEntity, COLLISION_GROUP_NONE, pTrace );
}
void CASW_Weapon_Assault_Shotgun::SecondaryAttack()
{
// Only the player fires this way so we can cast
CASW_Player *pPlayer = GetCommander();
if (!pPlayer)
return;
CASW_Marine *pMarine = GetMarine();
if (!pMarine)
return;
//Must have ammo
bool bUsesSecondary = UsesSecondaryAmmo();
bool bUsesClips = UsesClipsForAmmo2();
int iAmmoCount = pMarine->GetAmmoCount(m_iSecondaryAmmoType);
bool bInWater = ( pMarine->GetWaterLevel() == 3 );
if ( (bUsesSecondary &&
( ( bUsesClips && m_iClip2 <= 0) ||
( !bUsesClips && iAmmoCount<=0 )
) )
|| bInWater || m_bInReload )
{
SendWeaponAnim( ACT_VM_DRYFIRE );
BaseClass::WeaponSound( EMPTY );
m_flNextSecondaryAttack = gpGlobals->curtime + 0.5f;
return;
}
BaseClass::WeaponSound( SPECIAL1 );
#ifndef CLIENT_DLL
pMarine->GetMarineSpeech()->Chatter(CHATTER_GRENADE);
Vector vecSrc = pMarine->Weapon_ShootPosition();
Vector vecThrow;
// check for turning on lag compensation
if (pPlayer && pMarine->IsInhabited())
{
CASW_Lag_Compensation::RequestLagCompensation( pPlayer, pPlayer->GetCurrentUserCommand() );
}
vecThrow = UTIL_LaunchVector(vecSrc, pPlayer->GetCrosshairTracePos(), asw_vindicator_grenade_gravity.GetFloat()) * 8.0f * asw_vindicator_grenade_velocity.GetFloat();
QAngle angAiming = pPlayer->EyeAnglesWithCursorRoll();
float fGrenadeDamage = MarineSkills()->GetSkillBasedValueByMarine(pMarine, ASW_MARINE_SKILL_GRENADES, ASW_MARINE_SUBSKILL_GRENADE_INCENDIARY_DMG);
float fGrenadeRadius = MarineSkills()->GetSkillBasedValueByMarine(pMarine, ASW_MARINE_SKILL_GRENADES, ASW_MARINE_SUBSKILL_GRENADE_RADIUS);
if (asw_debug_marine_damage.GetBool())
{
Msg("Grenade damage = %f radius = %f\n", fGrenadeDamage, fGrenadeRadius);
}
// check the grenade fits where we want to spawn it
Ray_t ray;
trace_t pm;
ray.Init( pMarine->WorldSpaceCenter(), vecSrc, -Vector(4,4,4), Vector(4,4,4) );
UTIL_TraceRay( ray, MASK_SOLID, pMarine, COLLISION_GROUP_PROJECTILE, &pm );
if (pm.fraction < 1.0f)
vecSrc = pm.endpos;
CASW_Grenade_Vindicator::Vindicator_Grenade_Create(
fGrenadeDamage,
fGrenadeRadius,
vecSrc, angAiming, vecThrow, AngularImpulse(0,0,0), pMarine, this );
pMarine->OnWeaponFired( this, 1, true );
#endif
SendWeaponAnim( GetPrimaryAttackActivity() );
pMarine->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_PRIMARY );
// Decrease ammo
if ( bUsesClips )
{
m_iClip2 -= 1;
}
else
{
pMarine->RemoveAmmo( 1, m_iSecondaryAmmoType );
}
#ifndef CLIENT_DLL
ASWFailAdvice()->OnMarineUsedSecondary();
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
//data.m_vNormal = dir;
//data.m_flScale = (float)amount;
CPASFilter filter( data.m_vOrigin );
filter.SetIgnorePredictionCull(true);
DispatchParticleEffect( "muzzleflash_grenadelauncher_main", PATTACH_POINT_FOLLOW, this, "muzzle", false, -1, &filter );
#endif
// Can shoot again immediately
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5f;
// Can blow up after a short delay (so have time to release mouse button)
m_flNextSecondaryAttack = gpGlobals->curtime + 1.0f;
}