void CPhysicsEntitySolver::Spawn()
{
SetNextThink( gpGlobals->curtime + m_separationDuration );
PhysDisableEntityCollisions( m_hMovingEntity, m_hPhysicsBlocker );
m_savedCollisionGroup = m_hPhysicsBlocker->GetCollisionGroup();
m_hPhysicsBlocker->SetCollisionGroup( COLLISION_GROUP_DEBRIS );
if ( m_hPhysicsBlocker->VPhysicsGetObject() )
{
m_hPhysicsBlocker->VPhysicsGetObject()->RecheckContactPoints();
}
}
void CNPC_Zombine::DropGrenade( Vector vDir )
{
if ( m_hGrenade == NULL )
return;
m_hGrenade->SetParent( NULL );
m_hGrenade->SetOwnerEntity( NULL );
Vector vGunPos;
QAngle angles;
GetAttachment( "grenade_attachment", vGunPos, angles );
IPhysicsObject *pPhysObj = m_hGrenade->VPhysicsGetObject();
if ( pPhysObj == NULL )
{
m_hGrenade->SetMoveType( MOVETYPE_VPHYSICS );
m_hGrenade->SetSolid( SOLID_VPHYSICS );
m_hGrenade->SetCollisionGroup( COLLISION_GROUP_WEAPON );
m_hGrenade->CreateVPhysics();
}
if ( pPhysObj )
{
pPhysObj->Wake();
pPhysObj->SetPosition( vGunPos, angles, true );
pPhysObj->ApplyForceCenter( vDir * 0.2f );
pPhysObj->RecheckCollisionFilter();
}
m_hGrenade = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the magnitude of the entity's angular velocity.
//-----------------------------------------------------------------------------
void CPointVelocitySensor::SampleVelocity( void )
{
if ( m_hTargetEntity == NULL )
return;
Vector vecVelocity;
if ( m_hTargetEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
IPhysicsObject *pPhys = m_hTargetEntity->VPhysicsGetObject();
if ( pPhys != NULL )
{
pPhys->GetVelocity( &vecVelocity, NULL );
}
}
else
{
vecVelocity = m_hTargetEntity->GetAbsVelocity();
}
/*
float flSpeed = VectorNormalize( vecVelocity );
float flDot = ( m_vecAxis != vec3_origin ) ? DotProduct( vecVelocity, m_vecAxis ) : 1.0f;
*/
// We want the component of the velocity vector in the direction of the axis, which since the
// axis is normalized is simply their dot product (eg V . A = |V|*|A|*cos(theta) )
m_fPrevVelocity = ( m_vecAxis != vec3_origin ) ? DotProduct( vecVelocity, m_vecAxis ) : 1.0f;
// if it's changed since the last frame, poke the output
if ( m_fPrevVelocity != m_Velocity.Get() )
{
m_Velocity.Set( m_fPrevVelocity, NULL, NULL );
}
}
void CNPC_Dog::PrescheduleThink( void )
{
BaseClass::PrescheduleThink();
if ( m_hPhysicsEnt )
{
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
if ( pPhysObj && pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
{
m_hPhysicsEnt->SetOwnerEntity( NULL );
}
}
if ( m_flTimeToCatch < gpGlobals->curtime )
m_flTimeToCatch = 0.0f;
if ( GetIdealActivity() == ACT_IDLE )
{
if ( m_hPhysicsEnt && m_bHasObject == true )
{
SetIdealActivity( (Activity)ACT_DOG_WAITING );
}
}
}
void CNPC_Dog::CleanCatchAndThrow( bool bClearTimers )
{
if ( m_hPhysicsEnt )
{
if ( m_bHasObject == true )
{
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
m_hPhysicsEnt->SetParent( NULL );
m_hPhysicsEnt->SetOwnerEntity( NULL );
Vector vGunPos;
QAngle angGunAngles;
GetAttachment( m_iPhysGunAttachment, vGunPos, angGunAngles );
if ( pPhysObj )
{
pPhysObj->Wake();
pPhysObj->RemoveShadowController();
pPhysObj->SetPosition( vGunPos, angGunAngles, true );
}
else
{
Warning( "CleanCatchAndThrow: m_hPhysicsEnt->VPhysicsGetObject == NULL!\n" );
}
m_hPhysicsEnt->SetMoveType( (MoveType_t)m_iContainerMoveType );
if ( pPhysObj )
{
pPhysObj->RecheckCollisionFilter();
}
ClearBeams();
}
m_hPhysicsEnt = NULL;
}
if ( bClearTimers == true )
{
m_bDoCatchThrowBehavior = false;
m_bDoWaitforObjectBehavior = false;
m_flTimeToCatch = 0.0f;
m_flNextSwat = 0.0f;
SetCondition( COND_DOG_LOST_PHYSICS_ENTITY );
}
}
void CPhysForce::ForceOff( void )
{
if ( !m_pController )
return;
physenv->DestroyMotionController( m_pController );
m_pController = NULL;
SetThink( NULL );
SetNextThink( TICK_NEVER_THINK );
IPhysicsObject *pPhys = NULL;
if ( m_attachedObject )
{
pPhys = m_attachedObject->VPhysicsGetObject();
if ( pPhys )
{
pPhys->Wake();
}
}
}
void CNPC_Dog::PickupOrCatchObject( const char *pAttachmentName )
{
if ( m_hPhysicsEnt )
{
InvalidateBoneCache();
int iAttachment = LookupAttachment( pAttachmentName );
if ( iAttachment == 0 )
iAttachment = m_iPhysGunAttachment;
// Move physobject to shadow
IPhysicsObject *pPhysicsObject = m_hPhysicsEnt->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->SetShadow( 1e4, 1e4, false, false );
pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
}
m_iContainerMoveType = m_hPhysicsEnt->GetMoveType();
m_hPhysicsEnt->SetMoveType( MOVETYPE_NONE );
m_hPhysicsEnt->SetParent( this, iAttachment );
m_hPhysicsEnt->SetLocalOrigin( vec3_origin );
m_hPhysicsEnt->SetLocalAngles( vec3_angle );
m_hPhysicsEnt->SetGroundEntity( NULL );
if ( m_hPhysicsEnt->GetOwnerEntity() == NULL )
m_hPhysicsEnt->SetOwnerEntity( this );
if ( pPhysicsObject )
pPhysicsObject->RecheckCollisionFilter();
m_bHasObject = true;
//Fire Output!
m_OnPickup.FireOutput( this, this );
}
}
void CPhysicsNPCSolver::Think()
{
bool finished = m_allowIntersection ? !IsIntersecting() : !CheckTouching();
if ( finished )
{
UTIL_Remove(this);
return;
}
if ( m_allowIntersection )
{
IPhysicsObject *pObject = m_hEntity->VPhysicsGetObject();
if ( !pObject )
{
UTIL_Remove(this);
return;
}
pObject->Wake();
}
ResetCancelTime();
}
void CPhysForce::ActivateForce( void )
{
BaseClass::Activate();
IPhysicsObject *pPhys = NULL;
if ( m_attachedObject )
{
pPhys = m_attachedObject->VPhysicsGetObject();
}
if ( !pPhys )
return;
Vector linear;
AngularImpulse angular;
SetupForces( pPhys, linear, angular );
m_integrator.SetConstantForce( linear, angular );
m_pController = physenv->CreateMotionController( &m_integrator );
m_pController->AttachObject( pPhys );
// Make sure the object is simulated
pPhys->Wake();
}
void CPhysMotor::Activate( void )
{
BaseClass::Activate();
// This gets called after all objects spawn and after all objects restore
if ( m_attachedObject == NULL )
{
CBaseEntity *pAttach = gEntList.FindEntityByName( NULL, m_nameAttach, NULL );
if ( pAttach && pAttach->GetMoveType() == MOVETYPE_VPHYSICS )
{
m_attachedObject = pAttach;
IPhysicsObject *pPhys = m_attachedObject->VPhysicsGetObject();
CalculateAcceleration();
matrix3x4_t matrix;
pPhys->GetPositionMatrix( matrix );
Vector motorAxis_ls;
VectorIRotate( m_motor.m_axis, matrix, motorAxis_ls );
float inertia = DotProductAbs( pPhys->GetInertia(), motorAxis_ls );
m_motor.m_maxTorque = inertia * m_motor.m_inertiaFactor * (m_angularAcceleration + m_additionalAcceleration);
m_motor.m_restistanceDamping = 1.0f;
}
}
if ( m_attachedObject )
{
IPhysicsObject *pPhys = m_attachedObject->VPhysicsGetObject();
// create a hinge constraint for this object?
if ( m_spawnflags & SF_MOTOR_HINGE )
{
// UNDONE: Don't do this on restore?
if ( !m_pHinge )
{
constraint_hingeparams_t hingeParams;
hingeParams.Defaults();
hingeParams.worldAxisDirection = m_motor.m_axis;
hingeParams.worldPosition = GetLocalOrigin();
m_pHinge = physenv->CreateHingeConstraint( g_PhysWorldObject, pPhys, NULL, hingeParams );
m_pHinge->SetGameData( (void *)this );
}
if ( m_spawnflags & SF_MOTOR_NOCOLLIDE )
{
physenv->DisableCollisions( pPhys, g_PhysWorldObject );
}
}
else
{
m_pHinge = NULL;
}
// NOTE: On restore, this path isn't run because m_pController will not be NULL
if ( !m_pController )
{
m_pController = physenv->CreateMotionController( &m_motor );
m_pController->AttachObject( m_attachedObject->VPhysicsGetObject() );
if ( m_spawnflags & SF_MOTOR_START_ON )
{
TurnOn();
}
}
}
// Need to do this on restore since there's no good way to save this
if ( m_pController )
{
m_pController->SetEventHandler( &m_motor );
}
}
void CWeaponGravityGun::SoundUpdate( void )
{
int newState;
if ( m_hObject )
newState = SS_LOCKEDON;
else
newState = SS_SCANNING;
if ( newState != m_soundState )
{
SoundStop();
m_soundState = newState;
SoundStart();
}
switch( m_soundState )
{
case SS_SCANNING:
break;
case SS_LOCKEDON:
{
CPASAttenuationFilter filter( GetOwner() );
filter.MakeReliable();
float height = m_hObject->GetAbsOrigin().z - m_originalObjectPosition.z;
// go from pitch 90 to 150 over a height of 500
int pitch = 90 + (int)UTIL_LineFraction( height, 0, 500, 60 );
CSoundParameters params;
if ( GetParametersForSound( "Weapon_Physgun.LockedOn", params, NULL ) )
{
EmitSound_t ep( params );
ep.m_nFlags = SND_CHANGE_VOL | SND_CHANGE_PITCH;
ep.m_nPitch = pitch;
EmitSound( filter, GetOwner()->entindex(), ep );
}
// attenutate the movement sounds over 200 units of movement
float distance = UTIL_LineFraction( m_movementLength, 0, 200, 1.0 );
// blend the "mass" sounds between 50 and 500 kg
IPhysicsObject *pPhys = m_hObject->VPhysicsGetObject();
float fade = UTIL_LineFraction( pPhys->GetMass(), 50, 500, 1.0 );
if ( GetParametersForSound( "Weapon_Physgun.LightObject", params, NULL ) )
{
EmitSound_t ep( params );
ep.m_nFlags = SND_CHANGE_VOL;
ep.m_flVolume = fade * distance;
EmitSound( filter, GetOwner()->entindex(), ep );
}
if ( GetParametersForSound( "Weapon_Physgun.HeavyObject", params, NULL ) )
{
EmitSound_t ep( params );
ep.m_nFlags = SND_CHANGE_VOL;
ep.m_flVolume = (1.0 - fade) * distance;
EmitSound( filter, GetOwner()->entindex(), ep );
}
}
break;
}
}
void CNPC_Dog::ThrowObject( const char *pAttachmentName )
{
if ( m_hPhysicsEnt )
{
m_bHasObject = false;
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
if ( pPhysObj )
{
Vector vGunPos;
QAngle angGunAngles;
AngularImpulse angVelocity = RandomAngularImpulse( -250 , -250 ) / pPhysObj->GetMass();
InvalidateBoneCache();
int iAttachment = LookupAttachment( pAttachmentName );
if ( iAttachment == 0 )
iAttachment = m_iPhysGunAttachment;
GetAttachment( iAttachment, vGunPos, angGunAngles );
pPhysObj->Wake();
if ( pPhysObj->GetShadowController() )
{
m_hPhysicsEnt->SetParent( NULL );
m_hPhysicsEnt->SetMoveType( (MoveType_t)m_iContainerMoveType );
m_hPhysicsEnt->SetOwnerEntity( this );
pPhysObj->RemoveShadowController();
pPhysObj->SetPosition( m_hPhysicsEnt->GetLocalOrigin(), m_hPhysicsEnt->GetLocalAngles(), true );
pPhysObj->RecheckCollisionFilter();
pPhysObj->RecheckContactPoints();
}
if ( m_hThrowTarget == NULL )
#ifdef SecobMod__Enable_Fixed_Multiplayer_AI
m_hThrowTarget = UTIL_GetNearestVisiblePlayer(this);
#else
m_hThrowTarget = AI_GetSinglePlayer();
#endif //SecobMod__Enable_Fixed_Multiplayer_AI
Vector vThrowDirection;
if ( m_hThrowTarget )
{
Vector vThrowOrigin = m_hThrowTarget->GetAbsOrigin();
if ( m_hThrowTarget->IsPlayer() )
vThrowOrigin = vThrowOrigin + Vector( random->RandomFloat( -128, 128 ), random->RandomFloat( -128, 128 ), 0 );
Vector vecToss = VecCheckToss( this, vGunPos, vThrowOrigin, m_flThrowArcModifier, 1.0f, true );
if( vecToss == vec3_origin )
{
// Fix up an impossible throw so dog will at least toss the box in the target's general direction instead of dropping it.
// Also toss it up in the air so it will fall down and break. (Just throw the box up at a 45 degree angle)
Vector forward, up;
GetVectors( &forward, NULL, &up );
vecToss = forward + up;
VectorNormalize( vecToss );
vecToss *= pPhysObj->GetMass() * 30.0f;
}
vThrowDirection = vecToss + ( m_hThrowTarget->GetSmoothedVelocity() / 2 );
Vector vLinearDrag;
Vector unitVel = vThrowDirection;
VectorNormalize( unitVel );
float flTest = 1000 / vThrowDirection.Length();
float flDrag = pPhysObj->CalculateLinearDrag( vThrowDirection );
vThrowDirection = vThrowDirection + ( unitVel * ( flDrag * flDrag ) ) / flTest;
pPhysObj->SetVelocity( &vThrowDirection, &angVelocity );
m_flTimeToCatch = gpGlobals->curtime + dog_max_wait_time.GetFloat();
//Don't start pulling until the object is away from me.
//We base the time on the throw velocity.
m_flTimeToPull = gpGlobals->curtime + ( 1000 / vThrowDirection.Length() );
}
//Fire Output!
m_OnThrow.FireOutput( this, this );
ClearBeams();
if ( m_bBeamEffects == true )
{
EmitSound( "Weapon_PhysCannon.Launch" );
CBeam *pBeam = CBeam::BeamCreate( "sprites/orangelight1.vmt", 1.8 );
if ( pBeam != NULL )
{
pBeam->PointEntInit( m_hPhysicsEnt->WorldSpaceCenter(), this );
pBeam->SetEndAttachment( m_iPhysGunAttachment );
pBeam->SetWidth( 6.4 );
pBeam->SetEndWidth( 12.8 );
pBeam->SetBrightness( 255 );
pBeam->SetColor( 255, 255, 255 );
pBeam->LiveForTime( 0.2f );
pBeam->RelinkBeam();
pBeam->SetNoise( 2 );
}
Vector shotDir = ( m_hPhysicsEnt->WorldSpaceCenter() - vGunPos );
VectorNormalize( shotDir );
CPVSFilter filter( m_hPhysicsEnt->WorldSpaceCenter() );
te->GaussExplosion( filter, 0.0f, m_hPhysicsEnt->WorldSpaceCenter() - ( shotDir * 4.0f ), RandomVector(-1.0f, 1.0f), 0 );
}
}
}
}
void CNPC_Dog::PullObject( bool bMantain )
{
if ( m_hPhysicsEnt == NULL )
{
TaskFail( "Ack! No Phys Object!");
return;
}
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
if ( pPhysObj == NULL )
{
TaskFail( "Pulling object with no Phys Object?!" );
return;
}
if( pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
{
m_bHasObject = false;
ClearBeams();
TaskFail("Player Grabbed Ball");
return;
}
CreateBeams();
Vector vGunPos;
GetAttachment( m_iPhysGunAttachment, vGunPos );
float flDistance = ( vGunPos - m_hPhysicsEnt->WorldSpaceCenter() ).Length();
if ( bMantain == false )
{
if ( flDistance <= DOG_CATCH_DISTANCE )
{
m_hPhysicsEnt->SetOwnerEntity( this );
GetNavigator()->StopMoving();
//Fire Output!
m_OnPickup.FireOutput( this, this );
m_bHasObject = true;
ClearBeams();
TaskComplete();
return;
}
}
Vector vDir = ( vGunPos - m_hPhysicsEnt->WorldSpaceCenter() );
Vector vCurrentVel;
float flCurrentVel;
AngularImpulse vCurrentAI;
pPhysObj->GetVelocity( &vCurrentVel, &vCurrentAI );
flCurrentVel = vCurrentVel.Length();
VectorNormalize( vCurrentVel );
VectorNormalize( vDir );
float flVelMod = DOG_PULL_VELOCITY_MOD;
if ( bMantain == true )
flVelMod *= 2;
vCurrentVel = vCurrentVel * flCurrentVel * flVelMod;
vCurrentAI = vCurrentAI * DOG_PULL_ANGULARIMP_MOD;
pPhysObj->SetVelocity( &vCurrentVel, &vCurrentAI );
vDir = vDir * flDistance * (DOG_PULL_TO_GUN_VEL_MOD * 2);
Vector vAngle( 0, 0, 0 );
pPhysObj->AddVelocity( &vDir, &vAngle );
}
//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Dog::StartTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_DOG_SETUP_THROW_TARGET:
{
SetupThrowTarget();
TaskComplete();
}
break;
case TASK_DOG_GET_PATH_TO_PHYSOBJ:
{
FindPhysicsObject( STRING( m_sObjectName ) );
if ( m_hPhysicsEnt == NULL )
{
FindPhysicsObject( NULL );
return;
}
IPhysicsObject *pPhysicsObject = m_hPhysicsEnt->VPhysicsGetObject();
Vector vecGoalPos;
Vector vecDir;
vecDir = GetLocalOrigin() - m_hPhysicsEnt->WorldSpaceCenter();
VectorNormalize(vecDir);
vecDir.z = 0;
if ( m_hPhysicsEnt->GetOwnerEntity() == NULL )
m_hPhysicsEnt->SetOwnerEntity( this );
if ( pPhysicsObject )
pPhysicsObject->RecheckCollisionFilter();
vecGoalPos = m_hPhysicsEnt->WorldSpaceCenter() + (vecDir * DOG_PHYSOBJ_MOVE_TO_DIST );
//If I'm near my goal, then just walk to it.
Activity aActivity = ACT_RUN;
if ( ( vecGoalPos - GetLocalOrigin() ).Length() <= 128 )
aActivity = ACT_WALK;
if ( GetNavigator()->SetGoal( AI_NavGoal_t( vecGoalPos, aActivity ), AIN_NO_PATH_TASK_FAIL ) == false )
{
if ( m_hUnreachableObjects.Find( m_hPhysicsEnt ) == -1 )
m_hUnreachableObjects.AddToTail( m_hPhysicsEnt );
FindPhysicsObject( NULL, m_hPhysicsEnt );
m_flTimeToCatch = gpGlobals->curtime + 0.1;
m_flNextRouteTime = gpGlobals->curtime + 0.3;
m_flNextSwat = gpGlobals->curtime + 0.1;
GetNavigator()->ClearGoal();
}
else
{
TaskComplete();
}
}
break;
case TASK_DOG_FACE_OBJECT:
{
if( m_hPhysicsEnt == NULL )
{
// Physics Object is gone! Probably was an explosive
// or something else broke it.
TaskFail("Physics ent NULL");
return;
}
Vector vecDir;
vecDir = m_hPhysicsEnt->WorldSpaceCenter() - GetLocalOrigin();
VectorNormalize(vecDir);
GetMotor()->SetIdealYaw( UTIL_VecToYaw( vecDir ) );
TaskComplete();
}
break;
case TASK_DOG_PICKUP_ITEM:
{
if( m_hPhysicsEnt == NULL )
{
// Physics Object is gone! Probably was an explosive
// or something else broke it.
TaskFail("Physics ent NULL");
return;
}
else
{
SetIdealActivity( (Activity)ACT_DOG_PICKUP );
}
}
break;
case TASK_DOG_LAUNCH_ITEM:
{
if( m_hPhysicsEnt == NULL )
{
// Physics Object is gone! Probably was an explosive
// or something else broke it.
TaskFail("Physics ent NULL");
return;
}
else
{
if ( m_hPhysicsEnt == NULL || m_bHasObject == false )
{
TaskFail( "Don't have the item!" );
return;
}
SetIdealActivity( (Activity)ACT_DOG_THROW );
}
}
break;
case TASK_DOG_WAIT_FOR_TARGET_TO_FACE:
{
if ( CanTargetSeeMe() )
TaskComplete();
}
break;
case TASK_DOG_WAIT_FOR_OBJECT:
{
SetIdealActivity( (Activity)ACT_DOG_WAITING );
}
break;
case TASK_DOG_CATCH_OBJECT:
{
SetIdealActivity( (Activity)ACT_DOG_CATCH );
}
break;
case TASK_DOG_DELAY_SWAT:
m_flNextSwat = gpGlobals->curtime + pTask->flTaskData;
if ( m_hThrowTarget == NULL )
#ifdef SecobMod__Enable_Fixed_Multiplayer_AI
m_hThrowTarget = UTIL_GetNearestVisiblePlayer(this);
#else
m_hThrowTarget = AI_GetSinglePlayer();
#endif //SecobMod__Enable_Fixed_Multiplayer_AI
TaskComplete();
break;
default:
BaseClass::StartTask( pTask );
}
}
//---------------------------------------------------------
//---------------------------------------------------------
void CNPC_Dog::RunTask( const Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_DOG_PICKUP_ITEM:
{
PullObject( false );
}
break;
case TASK_DOG_GET_PATH_TO_PHYSOBJ:
{
//Check this cause our object might have been deleted.
if ( m_hPhysicsEnt == NULL )
FindPhysicsObject( NULL );
//And if we still can't find anything, then just go away.
if ( m_hPhysicsEnt == NULL )
{
TaskFail( "Can't find an object I like!" );
return;
}
IPhysicsObject *pPhysicsObject = m_hPhysicsEnt->VPhysicsGetObject();
Vector vecGoalPos;
Vector vecDir;
vecDir = GetLocalOrigin() - m_hPhysicsEnt->WorldSpaceCenter();
VectorNormalize(vecDir);
vecDir.z = 0;
if ( m_hPhysicsEnt->GetOwnerEntity() == NULL )
m_hPhysicsEnt->SetOwnerEntity( this );
if ( pPhysicsObject )
pPhysicsObject->RecheckCollisionFilter();
vecGoalPos = m_hPhysicsEnt->WorldSpaceCenter() + (vecDir * DOG_PHYSOBJ_MOVE_TO_DIST );
bool bBuiltRoute = false;
//If I'm near my goal, then just walk to it.
Activity aActivity = ACT_RUN;
if ( ( vecGoalPos - GetLocalOrigin() ).Length() <= 128 )
aActivity = ACT_WALK;
bBuiltRoute = GetNavigator()->SetGoal( AI_NavGoal_t( vecGoalPos, aActivity ), AIN_NO_PATH_TASK_FAIL );
if ( bBuiltRoute == true )
TaskComplete();
else
{
m_flTimeToCatch = gpGlobals->curtime + 0.1;
m_flNextRouteTime = gpGlobals->curtime + 0.3;
m_flNextSwat = gpGlobals->curtime + 0.1;
if ( m_hUnreachableObjects.Find( m_hPhysicsEnt ) == -1 )
m_hUnreachableObjects.AddToTail( m_hPhysicsEnt );
m_hPhysicsEnt = NULL;
GetNavigator()->ClearGoal();
}
}
break;
case TASK_WAIT:
{
if ( IsWaitFinished() )
{
TaskComplete();
}
if ( m_hPhysicsEnt )
{
if ( m_bHasObject == false )
{
GetMotor()->SetIdealYawToTarget( m_hPhysicsEnt->GetAbsOrigin() );
GetMotor()->UpdateYaw();
}
}
break;
}
case TASK_DOG_LAUNCH_ITEM:
if( IsActivityFinished() )
{
if ( m_hPhysicsEnt )
{
m_hPhysicsEnt->SetOwnerEntity( NULL );
}
TaskComplete();
}
break;
case TASK_DOG_WAIT_FOR_TARGET_TO_FACE:
{
if ( CanTargetSeeMe() )
TaskComplete();
}
break;
case TASK_WAIT_FOR_MOVEMENT:
{
if ( GetState() == NPC_STATE_SCRIPT || IsInAScript() )
{
BaseClass::RunTask( pTask );
return;
}
if ( m_hPhysicsEnt != NULL )
{
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
if ( !pPhysObj )
{
Warning( "npc_dog TASK_WAIT_FOR_MOVEMENT with NULL m_hPhysicsEnt->VPhysicsGetObject\n" );
}
if ( pPhysObj && pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
TaskFail( "Player picked it up!" );
//If the object is moving then my old goal might not be valid
//cancel the schedule and make it restart again in a bit.
if ( pPhysObj && pPhysObj->IsAsleep() == false && GetNavigator()->IsGoalActive() == false )
{
Vector vecGoalPos;
Vector vecDir;
vecDir = GetLocalOrigin() - m_hPhysicsEnt->WorldSpaceCenter();
VectorNormalize(vecDir);
vecDir.z = 0;
vecGoalPos = m_hPhysicsEnt->WorldSpaceCenter() + (vecDir * DOG_PHYSOBJ_MOVE_TO_DIST );
GetNavigator()->ClearGoal();
float flDistance = (vecGoalPos - GetLocalOrigin()).Length();
//If I'm near my goal, then just walk to it.
Activity aActivity = ACT_RUN;
if ( ( vecGoalPos - GetLocalOrigin() ).Length() <= 128 )
aActivity = ACT_WALK;
GetNavigator()->SetGoal( AI_NavGoal_t( vecGoalPos, aActivity ), AIN_NO_PATH_TASK_FAIL );
if ( flDistance <= DOG_PHYSOBJ_MOVE_TO_DIST )
{
TaskComplete();
GetNavigator()->StopMoving();
}
}
}
BaseClass::RunTask( pTask );
}
break;
case TASK_DOG_WAIT_FOR_OBJECT:
{
if ( m_hPhysicsEnt != NULL )
{
if ( FVisible( m_hPhysicsEnt ) == false )
{
m_flTimeToCatch = 0.0f;
ClearBeams();
TaskFail( "Lost sight of the object!" );
m_hPhysicsEnt->SetOwnerEntity( NULL );
return;
}
m_hPhysicsEnt->SetOwnerEntity( this );
Vector vForward;
AngleVectors( GetAbsAngles(), &vForward );
Vector vGunPos;
GetAttachment( m_iPhysGunAttachment, vGunPos );
Vector vToObject = m_hPhysicsEnt->WorldSpaceCenter() - vGunPos;
float flDistance = vToObject.Length();
VectorNormalize( vToObject );
SetAim( m_hPhysicsEnt->WorldSpaceCenter() - GetAbsOrigin() );
#ifdef SecobMod__Enable_Fixed_Multiplayer_AI
CBasePlayer *pPlayer = UTIL_GetNearestVisiblePlayer(this);
#else
CBasePlayer *pPlayer = AI_GetSinglePlayer();
#endif //SecobMod__Enable_Fixed_Multiplayer_AI
float flDistanceToPlayer = flDistance;
if ( pPlayer )
{
flDistanceToPlayer = (pPlayer->GetAbsOrigin() - m_hPhysicsEnt->WorldSpaceCenter()).Length();
}
IPhysicsObject *pPhysObj = m_hPhysicsEnt->VPhysicsGetObject();
if ( !pPhysObj )
{
Warning( "npc_dog: TASK_DOG_WAIT_FOR_OBJECT with m_hPhysicsEnt->VPhysicsGetObject == NULL\n" );
}
if ( pPhysObj && !( pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) && flDistanceToPlayer > ( flDistance * 2 ) )
{
if ( m_flTimeToPull <= gpGlobals->curtime )
{
Vector vCurrentVel;
float flCurrentVel;
AngularImpulse vCurrentAI;
pPhysObj->GetVelocity( &vCurrentVel, &vCurrentAI );
flCurrentVel = vCurrentVel.Length();
VectorNormalize( vCurrentVel );
if ( pPhysObj && flDistance <= DOG_PULL_DISTANCE )
{
Vector vDir = ( vGunPos - m_hPhysicsEnt->WorldSpaceCenter() );
VectorNormalize( vDir );
vCurrentVel = vCurrentVel * ( flCurrentVel * DOG_PULL_VELOCITY_MOD );
vCurrentAI = vCurrentAI * DOG_PULL_ANGULARIMP_MOD;
pPhysObj->SetVelocity( &vCurrentVel, &vCurrentAI );
vDir = vDir * flDistance * DOG_PULL_TO_GUN_VEL_MOD;
Vector vAngle( 0, 0, 0 );
pPhysObj->AddVelocity( &vDir, &vAngle );
CreateBeams();
}
float flDot = DotProduct( vCurrentVel, vForward );
if ( flDistance >= DOG_PULL_DISTANCE && flDistance <= ( DOG_PULL_DISTANCE * 2 ) && flDot > -0.3 )
{
if ( pPhysObj->IsAsleep() == false && !( pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) )
{
Vector vecGoalPos;
Vector vecDir;
vecDir = GetLocalOrigin() - m_hPhysicsEnt->WorldSpaceCenter();
VectorNormalize(vecDir);
vecDir.z = 0;
vecGoalPos = m_hPhysicsEnt->WorldSpaceCenter() + (vecDir * DOG_PHYSOBJ_MOVE_TO_DIST );
GetNavigator()->ClearGoal();
//If I'm near my goal, then just walk to it.
Activity aActivity = ACT_RUN;
if ( ( vecGoalPos - GetLocalOrigin() ).Length() <= 128 )
aActivity = ACT_WALK;
GetNavigator()->SetGoal( AI_NavGoal_t( vecGoalPos, aActivity ), AIN_NO_PATH_TASK_FAIL );
}
}
}
}
float flDirDot = DotProduct( vToObject, vForward );
if ( flDirDot < 0.2 )
{
GetMotor()->SetIdealYawToTarget( m_hPhysicsEnt->GetAbsOrigin() );
GetMotor()->UpdateYaw();
}
if ( m_flTimeToCatch < gpGlobals->curtime && m_bDoWaitforObjectBehavior == false )
{
m_hPhysicsEnt->SetOwnerEntity( NULL );
m_flTimeToCatch = 0.0f;
ClearBeams();
TaskFail( "Done waiting!" );
}
else if ( pPhysObj && ( flDistance <= DOG_CATCH_DISTANCE && !( pPhysObj->GetGameFlags() & FVPHYSICS_PLAYER_HELD ) ) )
{
AngularImpulse vZero( 0, 0, 0 );
pPhysObj->SetVelocity( &vec3_origin, &vZero );
GetNavigator()->StopMoving();
//Fire Output!
m_OnCatch.FireOutput( this, this );
m_bHasObject = true;
ClearBeams();
TaskComplete();
}
}
else
{
GetNavigator()->StopMoving();
ClearBeams();
TaskFail("No Physics Object!");
}
}
break;
case TASK_DOG_CATCH_OBJECT:
if( IsActivityFinished() )
{
m_flTimeToCatch = 0.0f;
TaskComplete();
}
break;
default:
BaseClass::RunTask( pTask );
break;
}
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CNPC_CombineDropship::PrescheduleThink( void )
{
BaseClass::PrescheduleThink();
// keep track of think time deltas for burn calc below
float dt = gpGlobals->curtime - m_flLastTime;
m_flLastTime = gpGlobals->curtime;
switch( m_iLandState )
{
case LANDING_NO:
{
if ( IsActivityFinished() && (GetActivity() != ACT_DROPSHIP_FLY_IDLE_EXAGG && GetActivity() != ACT_DROPSHIP_FLY_IDLE_CARGO) )
{
if ( m_hContainer )
{
SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_CARGO );
}
else
{
SetIdealActivity( (Activity)ACT_DROPSHIP_FLY_IDLE_EXAGG );
}
}
DoRotorWash();
}
break;
case LANDING_LEVEL_OUT:
{
// Approach the drop point
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
float flDistance = vecToTarget.Length();
// If we're slowing, make it look like we're slowing
/*
if ( IsActivityFinished() && GetActivity() != ACT_DROPSHIP_DESCEND_IDLE )
{
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
*/
// Are we there yet?
float flSpeed = GetAbsVelocity().Length();
if ( flDistance < 70 && flSpeed < 100 )
{
m_flLandingSpeed = flSpeed;
m_iLandState = LANDING_DESCEND;
// save off current angles so we can work them out over time
QAngle angles = GetLocalAngles();
m_existPitch = angles.x;
m_existRoll = angles.z;
}
DoRotorWash();
}
break;
case LANDING_DESCEND:
{
float flAltitude;
SetLocalAngularVelocity( vec3_angle );
// Ensure we land on the drop point
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
float flDistance = vecToTarget.Length();
float flRampedSpeed = m_flLandingSpeed * (flDistance / 70);
Vector vecVelocity = (flRampedSpeed / flDistance) * vecToTarget;
vecVelocity.z = -75;
SetAbsVelocity( vecVelocity );
flAltitude = GetAltitude();
if ( IsActivityFinished() && GetActivity() != ACT_DROPSHIP_DESCEND_IDLE )
{
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
if ( flAltitude < 72 )
{
QAngle angles = GetLocalAngles();
// Level out quickly.
angles.x = UTIL_Approach( 0.0, angles.x, 0.2 );
angles.z = UTIL_Approach( 0.0, angles.z, 0.2 );
SetLocalAngles( angles );
}
else
{
// randomly move as if buffeted by ground effects
// gently flatten ship from starting pitch/yaw
m_existPitch = UTIL_Approach( 0.0, m_existPitch, 1 );
m_existRoll = UTIL_Approach( 0.0, m_existRoll, 1 );
QAngle angles = GetLocalAngles();
angles.x = m_existPitch + ( sin( gpGlobals->curtime * 3.5f ) * DROPSHIP_MAX_LAND_TILT );
angles.z = m_existRoll + ( sin( gpGlobals->curtime * 3.75f ) * DROPSHIP_MAX_LAND_TILT );
SetLocalAngles( angles );
// figure out where to face (nav point)
Vector targetDir = GetDesiredPosition() - GetAbsOrigin();
// NDebugOverlay::Cross3D( m_pGoalEnt->GetAbsOrigin(), -Vector(2,2,2), Vector(2,2,2), 255, 0, 0, false, 20 );
QAngle targetAngles = GetAbsAngles();
targetAngles.y += UTIL_AngleDiff(UTIL_VecToYaw( targetDir ), targetAngles.y);
// orient ship towards path corner on the way down
angles = GetAbsAngles();
angles.y = UTIL_Approach(targetAngles.y, angles.y, 2 );
SetAbsAngles( angles );
}
if ( flAltitude <= 0.5f )
{
m_iLandState = LANDING_TOUCHDOWN;
// upon landing, make sure ship is flat
QAngle angles = GetLocalAngles();
angles.x = 0;
angles.z = 0;
SetLocalAngles( angles );
// TODO: Release cargo anim
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
DoRotorWash();
// place danger sounds 1 foot above ground to get troops to scatter if they are below dropship
Vector vecBottom = GetAbsOrigin();
vecBottom.z += WorldAlignMins().z;
Vector vecSpot = vecBottom + Vector(0, 0, -1) * (GetAltitude() - 12 );
CSoundEnt::InsertSound( SOUND_DANGER, vecSpot, 400, 0.2, this, 0 );
CSoundEnt::InsertSound( SOUND_PHYSICS_DANGER, vecSpot, 400, 0.2, this, 1 );
// NDebugOverlay::Cross3D( vecSpot, -Vector(4,4,4), Vector(4,4,4), 255, 0, 255, false, 10.0f );
// now check to see if player is below us, if so, cause heat damage to them (i.e. get them to move)
trace_t tr;
Vector vecBBoxMin = CRATE_BBOX_MIN; // use flat box for check
vecBBoxMin.z = -5;
Vector vecBBoxMax = CRATE_BBOX_MAX;
vecBBoxMax.z = 5;
Vector pEndPoint = vecBottom + Vector(0, 0, -1) * ( GetAltitude() - 12 );
AI_TraceHull( vecBottom, pEndPoint, vecBBoxMin, vecBBoxMax, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction < 1.0f )
{
if ( tr.GetEntityIndex() == 1 ) // player???
{
CTakeDamageInfo info( this, this, 20 * dt, DMG_BURN );
CBasePlayer *pPlayer = UTIL_PlayerByIndex(1);
pPlayer->TakeDamage( info );
}
}
}
break;
case LANDING_TOUCHDOWN:
{
if ( IsActivityFinished() && ( GetActivity() != ACT_DROPSHIP_DESCEND_IDLE ) )
{
SetActivity( (Activity)ACT_DROPSHIP_DESCEND_IDLE );
}
m_iLandState = LANDING_UNLOADING;
m_flTroopDeployPause = gpGlobals->curtime + DROPSHIP_PAUSE_B4_TROOP_UNLOAD;
m_flTimeTakeOff = m_flTroopDeployPause + DROPSHIP_DEPLOY_TIME;
}
break;
case LANDING_UNLOADING:
{
// pause before dropping troops
if ( gpGlobals->curtime > m_flTroopDeployPause )
{
if ( m_hContainer ) // don't drop troops if we don't have a crate any more
{
SpawnTroops();
m_flTroopDeployPause = m_flTimeTakeOff + 2; // only drop once
}
}
// manage engine wash and volume
if ( m_flTimeTakeOff - gpGlobals->curtime < 0.5f )
{
m_engineThrust = UTIL_Approach( 1.0f, m_engineThrust, 0.1f );
DoRotorWash();
}
else
{
float idleVolume = 0.2f;
m_engineThrust = UTIL_Approach( idleVolume, m_engineThrust, 0.04f );
if ( m_engineThrust > idleVolume )
{
DoRotorWash(); // make sure we're kicking up dust/water as long as engine thrust is up
}
}
if( gpGlobals->curtime > m_flTimeTakeOff )
{
m_iLandState = LANDING_LIFTOFF;
SetActivity( (Activity)ACT_DROPSHIP_LIFTOFF );
m_engineThrust = 1.0f; // ensure max volume once we're airborne
if ( m_bIsFiring )
{
StopCannon(); // kill cannon sounds if they are on
}
// detach container from ship
if ( m_hContainer && m_leaveCrate )
{
m_hContainer->SetParent(NULL);
m_hContainer->SetMoveType( (MoveType_t)m_iContainerMoveType );
// If the container has a physics object, remove it's shadow
IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->RemoveShadowController();
}
m_hContainer = NULL;
}
}
}
break;
case LANDING_LIFTOFF:
{
// give us some clearance before changing back to larger hull -- keeps ship from getting stuck on
// things like the player, etc since we "pop" the hull...
if ( GetAltitude() > 120 )
{
m_OnFinishedDropoff.FireOutput( this, this );
m_iLandState = LANDING_NO;
// change bounding box back to normal ship hull
Vector vecBBMin, vecBBMax;
ExtractBbox( SelectHeaviestSequence( ACT_DROPSHIP_DEPLOY_IDLE ), vecBBMin, vecBBMax );
UTIL_SetSize( this, vecBBMin, vecBBMax );
Relink();
}
}
break;
case LANDING_SWOOPING:
{
// Did we lose our pickup target?
if ( !m_hPickupTarget )
{
m_iLandState = LANDING_NO;
}
else
{
// Decrease altitude and speed to hit the target point.
Vector vecToTarget = (GetDesiredPosition() - GetAbsOrigin());
float flDistance = vecToTarget.Length();
// Start cheating when we get near it
if ( flDistance < 50 )
{
/*
if ( flDistance > 10 )
{
// Cheat and ensure we touch the target
float flSpeed = GetAbsVelocity().Length();
Vector vecVelocity = vecToTarget;
VectorNormalize( vecVelocity );
SetAbsVelocity( vecVelocity * min(flSpeed,flDistance) );
}
else
*/
{
// Grab the target
m_hContainer = m_hPickupTarget;
m_hPickupTarget = NULL;
m_iContainerMoveType = m_hContainer->GetMoveType();
// If the container has a physics object, move it to shadow
IPhysicsObject *pPhysicsObject = m_hContainer->VPhysicsGetObject();
if ( pPhysicsObject )
{
pPhysicsObject->SetShadow( Vector(1e4,1e4,1e4), AngularImpulse(1e4,1e4,1e4), false, false );
pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
}
int iIndex = 0;//LookupAttachment("Cargo");
/*
Vector vecOrigin;
QAngle vecAngles;
GetAttachment( iIndex, vecOrigin, vecAngles );
m_hContainer->SetAbsOrigin( vecOrigin );
m_hContainer->SetAbsAngles( vec3_angle );
*/
m_hContainer->SetAbsOrigin( GetAbsOrigin() );
m_hContainer->SetParent(this, iIndex);
m_hContainer->SetMoveType( MOVETYPE_PUSH );
m_hContainer->RemoveFlag( FL_ONGROUND );
m_hContainer->Relink();
m_hContainer->SetAbsAngles( vec3_angle );
m_OnFinishedPickup.FireOutput( this, this );
m_iLandState = LANDING_NO;
}
}
}
DoRotorWash();
}
break;
}
DoCombatStuff();
if ( GetActivity() != GetIdealActivity() )
{
//Msg( "setactivity" );
SetActivity( GetIdealActivity() );
}
}
