//-----------------------------------------------------------------------------
// Purpose: Calculate m_vecVelocity and m_flNextThink to reach vecDest from
// GetOrigin() traveling at flSpeed.
// Input : Vector vecDest -
// flSpeed -
//-----------------------------------------------------------------------------
void CBaseToggle::LinearMove( const Vector &vecDest, float flSpeed )
{
ASSERTSZ(flSpeed != 0, "LinearMove: no speed is defined!");
m_vecFinalDest = vecDest;
m_movementType = MOVE_TOGGLE_LINEAR;
// Already there?
if (vecDest == GetLocalOrigin())
{
MoveDone();
return;
}
// set destdelta to the vector needed to move
Vector vecDestDelta = vecDest - GetLocalOrigin();
// divide vector length by speed to get time to reach dest
float flTravelTime = vecDestDelta.Length() / flSpeed;
// set m_flNextThink to trigger a call to LinearMoveDone when dest is reached
SetMoveDoneTime( flTravelTime );
// scale the destdelta vector by the time spent traveling to get velocity
SetLocalVelocity( vecDestDelta / flTravelTime );
}
void CCharacter::Jump()
{
if (!GetGroundEntity())
return;
SetGroundEntity(NULL);
Vector vecLocalUp = GetUpVector();
if (HasMoveParent())
{
TMatrix mGlobalToLocal = GetMoveParent()->GetGlobalToLocalTransform();
vecLocalUp = mGlobalToLocal.TransformNoTranslate(vecLocalUp);
}
SetLocalVelocity(GetLocalVelocity() + vecLocalUp * JumpStrength());
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
// -
// *pTraceResult -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_BaseNPC::AutoMovement( float flInterval, CBaseEntity *pTarget, AIMoveTrace_t *pTraceResult )
{
bool ignored;
Vector newPos;
QAngle newAngles;
if (flInterval <= 0.0)
return true;
m_ScheduleState.bTaskRanAutomovement = true;
if (GetIntervalMovement( flInterval, ignored, newPos, newAngles ))
{
// DevMsg( "%.2f : (%.1f) %.1f %.1f %.1f\n", gpGlobals->curtime, (newPos - GetLocalOrigin()).Length(), newPos.x, newPos.y, newAngles.y );
if ( m_hCine )
{
m_hCine->ModifyScriptedAutoMovement( &newPos );
}
if (GetMoveType() == MOVETYPE_STEP)
{
if (!(GetFlags() & FL_FLY))
{
if ( !pTarget )
{
pTarget = GetNavTargetEntity();
}
// allow NPCs to adjust the automatic movement
if ( ModifyAutoMovement( newPos ) )
{
// Set our motor's speed here
Vector vecOriginalPosition = GetAbsOrigin();
bool bResult = false;
if (!TaskIsComplete())
{
bResult = ( GetMotor()->MoveGroundStep( newPos, pTarget, newAngles.y, false, true, pTraceResult ) == AIM_SUCCESS );
}
Vector change = GetAbsOrigin() - vecOriginalPosition;
if (flInterval != 0)
{
change /= flInterval;
}
GetMotor()->SetMoveVel(change);
return bResult;
}
return ( GetMotor()->MoveGroundStep( newPos, pTarget, newAngles.y, false, true, pTraceResult ) == AIM_SUCCESS );
}
else
{
// FIXME: here's no direct interface to a fly motor, plus this needs to support a state where going through the world is okay.
// FIXME: add callbacks into the script system for validation
// FIXME: add function on scripts to force only legal movements
// FIXME: GetIntervalMovement deals in Local space, nor global. Currently now way to communicate that through these interfaces.
SetLocalOrigin( newPos );
SetLocalAngles( newAngles );
return true;
}
}
else if (GetMoveType() == MOVETYPE_FLY)
{
Vector dist = newPos - GetLocalOrigin();
VectorScale( dist, 1.0 / flInterval, dist );
SetLocalVelocity( dist );
return true;
}
}
return false;
}
void CCharacter::MoveThink()
{
if (!GetGroundEntity())
return;
if (m_vecGoalVelocity.LengthSqr())
m_vecGoalVelocity.Normalize();
m_vecMoveVelocity.x = Approach(m_vecGoalVelocity.x, m_vecMoveVelocity.x, GameServer()->GetFrameTime()*4);
m_vecMoveVelocity.y = 0;
m_vecMoveVelocity.z = Approach(m_vecGoalVelocity.z, m_vecMoveVelocity.z, GameServer()->GetFrameTime()*4);
if (m_vecMoveVelocity.LengthSqr() > 0)
{
TMatrix m = GetLocalTransform();
Vector vecUp = GetUpVector();
if (HasMoveParent())
{
TMatrix mGlobalToLocal = GetMoveParent()->GetGlobalToLocalTransform();
vecUp = mGlobalToLocal.TransformNoTranslate(vecUp);
}
Vector vecRight = m.GetForwardVector().Cross(vecUp).Normalized();
Vector vecForward = vecUp.Cross(vecRight).Normalized();
m.SetColumn(0, vecForward);
m.SetColumn(1, vecUp);
m.SetColumn(2, vecRight);
TVector vecMove = m_vecMoveVelocity * CharacterSpeed();
TVector vecLocalVelocity = m.TransformNoTranslate(vecMove);
SetLocalVelocity(vecLocalVelocity);
}
else
SetLocalVelocity(TVector());
eastl::vector<CEntityHandle<CBaseEntity> > apCollisionList;
size_t iMaxEntities = GameServer()->GetMaxEntities();
for (size_t j = 0; j < iMaxEntities; j++)
{
CBaseEntity* pEntity2 = CBaseEntity::GetEntity(j);
if (!pEntity2)
continue;
if (pEntity2->IsDeleted())
continue;
if (pEntity2 == this)
continue;
if (!pEntity2->ShouldCollide())
continue;
apCollisionList.push_back(pEntity2);
}
TMatrix mGlobalToLocalRotation;
if (HasMoveParent())
{
mGlobalToLocalRotation = GetMoveParent()->GetGlobalToLocalTransform();
mGlobalToLocalRotation.SetTranslation(TVector());
}
float flSimulationFrameTime = 0.01f;
// Break simulations up into consistent small steps to preserve accuracy.
for (; m_flMoveSimulationTime < GameServer()->GetGameTime(); m_flMoveSimulationTime += flSimulationFrameTime)
{
TVector vecVelocity = GetLocalVelocity();
TVector vecLocalOrigin = GetLocalOrigin();
TVector vecGlobalOrigin = GetGlobalOrigin();
vecVelocity = vecVelocity * flSimulationFrameTime;
TVector vecLocalDestination = vecLocalOrigin + vecVelocity;
TVector vecGlobalDestination = vecLocalDestination;
if (GetMoveParent())
vecGlobalDestination = GetMoveParent()->GetGlobalTransform() * vecLocalDestination;
TVector vecNewLocalOrigin = vecLocalDestination;
size_t iTries = 0;
while (true)
{
iTries++;
TVector vecPoint, vecNormal;
TVector vecLocalCollisionPoint, vecGlobalCollisionPoint;
bool bContact = false;
for (size_t i = 0; i < apCollisionList.size(); i++)
{
CBaseEntity* pEntity2 = apCollisionList[i];
if (GetMoveParent() == pEntity2)
{
if (pEntity2->CollideLocal(vecLocalOrigin, vecLocalDestination, vecPoint, vecNormal))
{
bContact = true;
Touching(pEntity2);
vecLocalCollisionPoint = vecPoint;
vecGlobalCollisionPoint = GetMoveParent()->GetGlobalTransform() * vecPoint;
}
}
else
{
if (pEntity2->Collide(vecGlobalOrigin, vecGlobalDestination, vecPoint, vecNormal))
{
bContact = true;
Touching(pEntity2);
vecGlobalCollisionPoint = vecPoint;
if (GetMoveParent())
{
vecLocalCollisionPoint = GetMoveParent()->GetGlobalToLocalTransform() * vecPoint;
vecNormal = GetMoveParent()->GetGlobalToLocalTransform().TransformNoTranslate(vecNormal);
}
else
vecLocalCollisionPoint = vecGlobalCollisionPoint;
}
}
}
if (bContact)
{
vecNewLocalOrigin = vecLocalCollisionPoint;
vecVelocity -= vecLocalCollisionPoint - vecLocalOrigin;
}
if (!bContact)
break;
if (iTries > 4)
break;
vecLocalOrigin = vecLocalCollisionPoint;
vecGlobalOrigin = vecGlobalCollisionPoint;
// Clip the velocity to the surface normal of whatever we hit.
TFloat flDistance = vecVelocity.Dot(vecNormal);
vecVelocity = vecVelocity - vecNormal * flDistance;
// Do it one more time just to make sure we're not headed towards the plane.
TFloat flAdjust = vecVelocity.Dot(vecNormal);
if (flAdjust < 0.0f)
vecVelocity -= (vecNormal * flAdjust);
vecLocalDestination = vecLocalOrigin + vecVelocity;
if (GetMoveParent())
vecGlobalDestination = GetMoveParent()->GetGlobalTransform() * vecLocalDestination;
else
vecGlobalDestination = vecLocalDestination;
SetLocalVelocity(vecVelocity.Normalized() * GetLocalVelocity().Length());
}
SetLocalOrigin(vecNewLocalOrigin);
// Try to keep the player on the ground.
// Untested.
/*TVector vecStart = GetGlobalOrigin() + GetGlobalTransform().GetUpVector()*m_flMaxStepSize;
TVector vecEnd = GetGlobalOrigin() - GetGlobalTransform().GetUpVector()*m_flMaxStepSize;
// First go up a bit
TVector vecHit, vecNormal;
Game()->TraceLine(GetGlobalOrigin(), vecStart, vecHit, vecNormal, NULL);
vecStart = vecHit;
// Now see if there's ground underneath us.
bool bHit = Game()->TraceLine(vecStart, vecEnd, vecHit, vecNormal, NULL);
if (bHit && vecNormal.y >= TFloat(0.7f))
SetGlobalOrigin(vecHit);*/
m_flMoveSimulationTime += flSimulationFrameTime;
}
}
void UPhysicsMovementComponent::OnRep_velocity()
{
SetLocalVelocity(velocity);
}
void CDHLProjectile::PhysicsSimulate( void )
{
//-------------------------------------------------------------------------------
//Our own movement/physics simulation!
//-------------------------------------------------------------------------------
#ifdef CLIENT_DLL
if ( m_bCollided )
return;
if ( !m_pShooter && m_hShooter )
m_pShooter = m_hShooter.Get();
#else
if ( m_flRemoveAt > 0.0f )
{
if ( m_flRemoveAt < gpGlobals->curtime )
{
m_flRemoveAt = 0.0f;
SUB_Remove();
}
return;
}
if ( IsMarkedForDeletion() )
return;
#endif
float flFrametime = gpGlobals->frametime;
//Scale for slow motion
if ( DHLRules() )
{
if ( (m_iType == DHL_PROJECTILE_TYPE_BULLET || m_iType == DHL_PROJECTILE_TYPE_PELLET) )
flFrametime *= (dhl_bulletspeed.GetFloat() * DHLRules()->GetTimescale());
else if ( m_iType == DHL_PROJECTILE_TYPE_COMBATKNIFE )
flFrametime *= (dhl_knifespeed.GetFloat() * DHLRules()->GetTimescale());
else
flFrametime *= DHLRules()->GetTimescale();
}
Vector vecDir = vec3_origin;
#ifndef CLIENT_DLL
Vector vecStartPos = m_vecCurPosition; //This is where we are
Vector vecEndPos = m_vecCurPosition; //This is where we're going
Vector vecVelocity = m_vecCurVelocity; //Velocity
#else
Vector vecStartPos = GetLocalOrigin(); //This is where we are
Vector vecEndPos = GetLocalOrigin(); //This is where we're going
Vector vecVelocity = GetLocalVelocity(); //Velocity
#endif
//Find out where we should move to
if ( vecVelocity != vec3_origin )
{
static ConVarRef gravVar( "sv_gravity" );
//Gravity
float newZVelocity = vecVelocity.z - ( flFrametime * gravVar.GetFloat() * GetGravity() );
vecVelocity.z = ( (vecVelocity.z + newZVelocity) / 2 );
vecDir = vecVelocity;
VectorNormalize( vecDir );
//Gravity needs to be cumulative
#ifndef CLIENT_DLL
m_vecCurVelocity = vecVelocity;
#else
SetLocalVelocity( vecVelocity );
#endif
vecVelocity *= flFrametime;
vecEndPos = vecStartPos + vecVelocity;
if ( vecEndPos.IsValid() )
{
CTraceFilterSkipTwoEntities movetrfilter( this, m_pShooter, COLLISION_GROUP_NONE );
trace_t movetr;
UTIL_TraceLine( vecStartPos, vecEndPos, MASK_SHOT, &movetrfilter, &movetr );
#ifndef CLIENT_DLL
//Trace to triggers so we can hit surf glass and such
CTakeDamageInfo triggerInfo( this, GetOwnerEntity(), m_iDamage, DMG_BULLET );
if ( m_iType == DHL_PROJECTILE_TYPE_COMBATKNIFE )
{
//CalculateMeleeDamageForce( &triggerInfo, vecDir, movetr.endpos, 0.7f );
Vector vecForce = vecDir;
VectorNormalize( vecForce );
//vecForce *= 10.0f;
triggerInfo.SetDamageForce( vecForce );
}
else
CalculateBulletDamageForce( &triggerInfo, m_iAmmoType, vecDir, movetr.endpos, 1.0f );
triggerInfo.SetDamagePosition( movetr.endpos );
TraceAttackToTriggers( triggerInfo, movetr.startpos, movetr.endpos, vecDir );
#else
//Hit ragdolls on the client
CBaseEntity* pEnt = DHL_FX_AffectRagdolls( movetr.endpos, movetr.startpos, DMG_BULLET, &m_RagdollHitList );
//Keep track of ones we've hit
if ( pEnt )
m_RagdollHitList.AddToTail( pEnt );
#endif
if ( movetr.DidHit() )
if ( OnTouch( movetr, false, &movetrfilter ) )
return;
MoveProjectileToPosition( vecEndPos );
m_flDistanceTravelled += vecEndPos.DistTo( vecStartPos );
#ifndef CLIENT_DLL
//On rare occasions the projectile likes to fly right through the world and keep going forever, causing a memory leak
if ( m_flDistanceTravelled > MAX_TRACE_LENGTH )
{
SUB_Remove();
//SetThink( &CDHLProjectile::SUB_Remove );
//SetNextThink( gpGlobals->curtime + 0.1 );
}
#endif
}
//Simulate Angles
//QAngle angles;
#ifdef CLIENT_DLL
QAngle angles = GetLocalAngles();
//VectorAngles( vecDir, angles );
//angles.z = GetLocalAngles().z; //Vector conversion loses z
QAngle angVel = GetLocalAngularVelocity();
angles += angVel * flFrametime;
SetLocalAngles( angles );
SetNetworkAngles( angles );
#endif
}
}
