//------------------------------------------------------------------------------ // Purpose : // Input : // Output : //------------------------------------------------------------------------------ void CAI_BasePhysicsFlyingBot::StartTask( const Task_t *pTask ) { switch (pTask->iTask) { // Skip as done via bone controller case TASK_FACE_ENEMY: { TaskComplete(); break; } // Activity is just idle (have no run) case TASK_RUN_PATH: { GetNavigator()->SetMovementActivity(ACT_IDLE); TaskComplete(); break; } // Don't check for run/walk activity case TASK_RUN_TO_TARGET: case TASK_WALK_TO_TARGET: { if (GetTarget() == NULL) { TaskFail(FAIL_NO_TARGET); } else { if (!GetNavigator()->SetGoal( GOALTYPE_TARGETENT ) ) { TaskFail(FAIL_NO_ROUTE); GetNavigator()->ClearGoal(); } } TaskComplete(); break; } // Override to get more to get a directional path case TASK_GET_PATH_TO_RANDOM_NODE: { if ( GetNavigator()->SetRandomGoal( pTask->flTaskData, m_vLastPatrolDir ) ) TaskComplete(); else TaskFail(FAIL_NO_REACHABLE_NODE); break; } default: { BaseClass::StartTask(pTask); } } }
//----------------------------------------------------------------------------- // TASK_RANGE_ATTACK1 / TASK_RANGE_ATTACK2 / etc. //----------------------------------------------------------------------------- void CAI_BaseHumanoid::RunTaskRangeAttack1( const Task_t *pTask ) { if ( ( CapabilitiesGet() & bits_CAP_USE_SHOT_REGULATOR ) == 0 ) { BaseClass::RunTask( pTask ); return; } AutoMovement( ); Vector vecEnemyLKP = GetEnemyLKP(); // If our enemy was killed, but I'm not done animating, the last known position comes // back as the origin and makes the me face the world origin if my attack schedule // doesn't break when my enemy dies. (sjb) if( vecEnemyLKP != vec3_origin ) { if ( ( pTask->iTask == TASK_RANGE_ATTACK1 || pTask->iTask == TASK_RELOAD ) && ( CapabilitiesGet() & bits_CAP_AIM_GUN ) && FInAimCone( vecEnemyLKP ) ) { // Arms will aim, so leave body yaw as is GetMotor()->SetIdealYawAndUpdate( GetMotor()->GetIdealYaw(), AI_KEEP_YAW_SPEED ); } else { GetMotor()->SetIdealYawToTargetAndUpdate( vecEnemyLKP, AI_KEEP_YAW_SPEED ); } } if ( IsActivityFinished() ) { if ( !GetEnemy() || !GetEnemy()->IsAlive() ) { TaskComplete(); return; } if ( !GetShotRegulator()->IsInRestInterval() ) { if ( GetShotRegulator()->ShouldShoot() ) { OnRangeAttack1(); ResetIdealActivity( ACT_RANGE_ATTACK1 ); } return; } TaskComplete(); } }
//========================================================= // RunTask //========================================================= void CBigMomma::RunTask( Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_MOVE_TO_NODE_RANGE: { float distance; if ( m_hTargetEnt == NULL ) TaskFail(); else { distance = ( m_vecMoveGoal - pev->origin ).Length2D(); // Set the appropriate activity based on an overlapping range // overlap the range to prevent oscillation if ( (distance < GetNodeRange()) || MovementIsComplete() ) { ALERT( at_aiconsole, "BM: Reached node!\n" ); TaskComplete(); RouteClear(); // Stop moving } } } break; case TASK_WAIT_NODE: if ( m_hTargetEnt != NULL && (m_hTargetEnt->pev->spawnflags & SF_INFOBM_WAIT) ) return; if ( gpGlobals->time > m_flWaitFinished ) TaskComplete(); ALERT( at_aiconsole, "BM: The WAIT is over!\n" ); break; case TASK_PLAY_NODE_PRESEQUENCE: case TASK_PLAY_NODE_SEQUENCE: if ( m_fSequenceFinished ) { m_Activity = ACT_RESET; TaskComplete(); } break; default: CBaseMonster::RunTask( pTask ); break; } }
//------------------------------------------------------------------------------ // Purpose: routine called every frame when a task is running // Input : pTask - the task structure //------------------------------------------------------------------------------ void CAI_ASW_RangedAttackBehavior::RunTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_RANGED_FIND_MISSILE_LOCATION: { TaskComplete(); m_flDeferUntil = gpGlobals->curtime + m_flFireRate; break; } case TASK_RANGED_PREPARE_TO_FIRE: { if ( !GetOuter()->FInAimCone( m_vMissileLocation ) ) { GetMotor()->SetIdealYawToTargetAndUpdate( m_vMissileLocation, AI_KEEP_YAW_SPEED ); } if ( GetOuter()->IsActivityFinished() ) { TaskComplete(); } break; } case TASK_RANGED_FIRE: { if ( GetOuter()->IsActivityFinished() ) { TaskComplete(); GetOuter()->OnRangeAttack1(); } break; } case TASK_RANGED_FIRE_RECOVER: { if ( GetOuter()->IsActivityFinished() ) { TaskComplete(); } break; } default: BaseClass::RunTask( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CNPC_Ichthyosaur::StartTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_ICH_THRASH_PATH: GetNavigator()->SetMovementActivity( (Activity) ACT_ICH_THRASH ); TaskComplete(); break; case TASK_ICH_GET_PATH_TO_RANDOM_NODE: { if ( GetEnemy() == NULL || !GetNavigator()->SetRandomGoal( GetEnemy()->GetLocalOrigin(), pTask->flTaskData ) ) { if (!GetNavigator()->SetRandomGoal( pTask->flTaskData ) ) { TaskFail(FAIL_NO_REACHABLE_NODE); return; } } TaskComplete(); } break; case TASK_ICH_GET_PATH_TO_DROWN_NODE: { Vector drownPos = GetLocalOrigin() - Vector( 0, 0, pTask->flTaskData ); if ( GetNavigator()->SetGoal( drownPos, AIN_CLEAR_TARGET ) == false ) { TaskFail( FAIL_NO_ROUTE ); return; } TaskComplete(); } break; case TASK_MELEE_ATTACK1: m_flPlaybackRate = 1.0f; BaseClass::StartTask(pTask); break; default: BaseClass::StartTask(pTask); break; } }
void CController :: StartTask ( const Task_t& task ) { switch ( task.iTask ) { case TASK_RANGE_ATTACK1: CSquadMonster :: StartTask ( task ); break; case TASK_GET_PATH_TO_ENEMY_LKP: { if (BuildNearestRoute( m_vecEnemyLKP, GetViewOffset(), task.flData, (m_vecEnemyLKP - GetAbsOrigin()).Length() + 1024 )) { TaskComplete(); } else { // no way to get there =( ALERT ( at_aiconsole, "GetPathToEnemyLKP failed!!\n" ); TaskFail(); } break; } case TASK_GET_PATH_TO_ENEMY: { CBaseEntity *pEnemy = m_hEnemy; if ( pEnemy == NULL ) { TaskFail(); return; } if (BuildNearestRoute( pEnemy->GetAbsOrigin(), pEnemy->GetViewOffset(), task.flData, (pEnemy->GetAbsOrigin() - GetAbsOrigin()).Length() + 1024 )) { TaskComplete(); } else { // no way to get there =( ALERT ( at_aiconsole, "GetPathToEnemy failed!!\n" ); TaskFail(); } break; } default: CSquadMonster :: StartTask ( task ); break; } }
//========================================================= // StartTask //========================================================= void CController :: StartTask ( Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_RANGE_ATTACK1: CSquadMonster :: StartTask ( pTask ); break; case TASK_GET_PATH_TO_ENEMY_LKP: { if (BuildNearestRoute( m_vecEnemyLKP, pev->view_ofs, pTask->flData, (m_vecEnemyLKP - pev->origin).Length() + 1024 )) { TaskComplete(); } else { // no way to get there =( ALERT ( at_aiconsole, "GetPathToEnemyLKP failed!!\n" ); TaskFail(); } break; } case TASK_GET_PATH_TO_ENEMY: { CBaseEntity *pEnemy = m_hEnemy; if ( pEnemy == NULL ) { TaskFail(); return; } if (BuildNearestRoute( pEnemy->pev->origin, pEnemy->pev->view_ofs, pTask->flData, (pEnemy->pev->origin - pev->origin).Length() + 1024 )) { TaskComplete(); } else { // no way to get there =( ALERT ( at_aiconsole, "GetPathToEnemy failed!!\n" ); TaskFail(); } break; } default: CSquadMonster :: StartTask ( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_BehaviorAlyxInjured::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_FIND_COVER_FROM_ENEMY: { CBaseEntity *pLeader = GetFollowTarget(); if ( !pLeader ) { BaseClass::StartTask( pTask ); break; } // Find a position behind our follow target Vector coverPos = vec3_invalid; if ( FindCoverFromEnemyBehindTarget( pLeader, COVER_DISTANCE, &coverPos ) ) { AI_NavGoal_t goal( GOALTYPE_LOCATION, coverPos, ACT_RUN, AIN_HULL_TOLERANCE, AIN_DEF_FLAGS ); GetOuter()->GetNavigator()->SetGoal( goal ); GetOuter()->m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData; TaskComplete(); return; } // Couldn't find anything TaskFail( FAIL_NO_COVER ); break; } default: BaseClass::StartTask( pTask ); break; } }
//========================================================= // RunTask //========================================================= void CNPC_Bullsquid::RunTask ( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_SQUID_HOPTURN: { if ( GetEnemy() ) { Vector vecFacing = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin() ); VectorNormalize( vecFacing ); GetMotor()->SetIdealYaw( vecFacing ); } if ( IsSequenceFinished() ) { TaskComplete(); } break; } default: { BaseClass::RunTask( pTask ); break; } } }
//----------------------------------------------------------------------------- // Purpose: // // // Output : //----------------------------------------------------------------------------- void CNPC_RollerDozer::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_ROLLERDOZER_GET_PATH_TO_CLEANUP_POINT: if ( GetNavigator()->SetGoal( m_vecCleanupPoint, AIN_CLEAR_TARGET ) ) { TaskComplete(); } else { // no way to get there TaskFail(FAIL_NO_ROUTE); } break; case TASK_ROLLERDOZER_CLEAR_DEBRIS: GetNavigator()->ClearGoal(); m_flWaitFinished = gpGlobals->curtime + 5; break; case TASK_ROLLERDOZER_FIND_CLEANUP_NODE: break; default: BaseClass::StartTask( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_RappelBehavior::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_MOVE_AWAY_PATH: GetOuter()->GetMotor()->SetIdealYaw( UTIL_AngleMod( GetOuter()->GetLocalAngles().y - 180.0f ) ); BaseClass::StartTask( pTask ); break; case TASK_RANGE_ATTACK1: BaseClass::StartTask( pTask ); break; case TASK_RAPPEL: { CreateZipline(); SetDescentSpeed(); } break; case TASK_HIT_GROUND: m_bOnGround = true; TaskComplete(); break; default: BaseClass::StartTask( pTask ); break; } }
void CASW_Alien_Jumper::StartTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_ASW_ALIEN_FACE_JUMP: break; case TASK_ASW_ALIEN_JUMP: if ( CheckLanding() ) { TaskComplete(); } break; case TASK_ASW_ALIEN_RETRY_JUMP: { if (!DoJumpTo(m_vecLastJumpAttempt)) WaitAndRetryJump(m_vecLastJumpAttempt); } break; default: BaseClass::StartTask( pTask ); break; } }
void CNPC_Infected::RunAttackTask( int task ) { AutoMovement( ); Vector vecEnemyLKP = GetEnemyLKP(); // If our enemy was killed, but I'm not done animating, the last known position comes // back as the origin and makes the me face the world origin if my attack schedule // doesn't break when my enemy dies. (sjb) if( vecEnemyLKP != vec3_origin ) { if ( ( task == TASK_RANGE_ATTACK1 || task == TASK_RELOAD ) && ( CapabilitiesGet() & bits_CAP_AIM_GUN ) && FInAimCone( vecEnemyLKP ) ) { // Arms will aim, so leave body yaw as is GetMotor()->SetIdealYawAndUpdate( GetMotor()->GetIdealYaw(), AI_KEEP_YAW_SPEED ); } else { GetMotor()->SetIdealYawToTargetAndUpdate( vecEnemyLKP, AI_KEEP_YAW_SPEED ); } } CAnimationLayer *pPlayer = GetAnimOverlay( m_iAttackLayer ); if ( pPlayer->m_bSequenceFinished ) { if ( task == TASK_RELOAD && GetShotRegulator() ) { GetShotRegulator()->Reset( false ); } TaskComplete(); } }
//------------------------------------------------------------------------------ // Purpose: routine called to start when a task initially starts // Input : pTask - the task structure //------------------------------------------------------------------------------ void CAI_ASW_PrepareToEngageBehavior::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_PREPARE_TO_ENGAGE: { CBaseEntity *pEnemy = GetEnemy(); if ( pEnemy == NULL ) { TaskFail( FAIL_NO_ENEMY ); return; } if ( GetPrepareToAttackPath( GetEnemy()->GetAbsOrigin() ) ) { TaskComplete(); } else { // TODO: wander to a random nearby spot TaskFail( FAIL_NO_ROUTE ); } return; } default: BaseClass::StartTask( pTask ); break; } }
void CNPC_Gargantua::StartTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_FLAME_SWEEP: //TEMP TEMP FlameCreate(); m_flWaitFinished = gpGlobals->curtime + pTask->flTaskData; m_flameTime = gpGlobals->curtime + 6; m_flameX = 0; m_flameY = 0; break; case TASK_SOUND_ATTACK: if ( random->RandomInt(0,100) < 30 ) { CPASAttenuationFilter filter( this ); enginesound->EmitSound( filter, entindex(), CHAN_VOICE, pAttackSounds[ random->RandomInt(0,ARRAYSIZE(pAttackSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM ); } TaskComplete(); break; case TASK_DIE: m_flWaitFinished = gpGlobals->curtime + 1.6; DeathEffect(); // FALL THROUGH default: BaseClass::StartTask( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_FearBehavior::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_FEAR_IN_SAFE_PLACE: // We've arrived! Lock the hint and set the marker. we're safe for now. m_hSafePlaceHint = m_hMovingToHint; m_hSafePlaceHint->Lock( GetOuter() ); m_SafePlaceMoveMonitor.SetMark( GetOuter(), FEAR_SAFE_PLACE_TOLERANCE ); TaskComplete(); break; case TASK_FEAR_GET_PATH_TO_SAFETY_HINT: // Using TaskInterrupt() optimizations. See RunTask(). break; case TASK_FEAR_WAIT_FOR_SAFETY: m_flTimeToSafety = gpGlobals->curtime + BEHAVIOR_FEAR_SAFETY_TIME; break; default: BaseClass::StartTask( pTask ); break; } }
void CNPC_Gargantua::StartTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_FLAME_SWEEP: //TEMP TEMP FlameCreate(); m_flWaitFinished = gpGlobals->curtime + pTask->flTaskData; m_flameTime = gpGlobals->curtime + 6; m_flameX = 0; m_flameY = 0; break; case TASK_SOUND_ATTACK: if ( random->RandomInt(0,100) < 30 ) { CPASAttenuationFilter filter( this ); EmitSound( filter, entindex(), "Garg.Attack" ); } TaskComplete(); break; case TASK_DIE: m_flWaitFinished = gpGlobals->curtime + 1.6; DeathEffect(); // FALL THROUGH default: BaseClass::StartTask( pTask ); break; } }
void CNPC_Monk::RunTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_RELOAD: { Activity reloadGesture = TranslateActivity( ACT_GESTURE_RELOAD ); if ( GetIdealActivity() != ACT_RELOAD && reloadGesture != ACT_INVALID ) { if ( !IsPlayingGesture( reloadGesture ) ) { if ( GetShotRegulator() ) { GetShotRegulator()->Reset( false ); } TaskComplete(); } return; } BaseClass::RunTask( pTask ); } break; default: BaseClass::RunTask( pTask ); break; } }
void CMGargantua::StartTask( Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_FLAME_SWEEP: FlameCreate(); m_flWaitFinished = gpGlobals->time + pTask->flData; m_flameTime = gpGlobals->time + 6; m_flameX = 0; m_flameY = 0; break; case TASK_SOUND_ATTACK: if ( RANDOM_LONG(0,100) < 30 ) EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, pAttackSounds[ RANDOM_LONG(0,ARRAYSIZE(pAttackSounds)-1) ], 1.0, ATTN_GARG, 0, PITCH_NORM ); TaskComplete(); break; case TASK_DIE: m_flWaitFinished = gpGlobals->time + 1.6; // FALL THROUGH default: CMBaseMonster::StartTask( pTask ); break; } }
void CNPC_Monk::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_RELOAD: { if ( GetActiveWeapon() && GetActiveWeapon()->HasPrimaryAmmo() ) { // Don't reload if you have done so while moving (See BACK_AWAY_AND_RELOAD schedule). TaskComplete(); return; } if( m_iNumZombies >= 2 && random->RandomInt( 1, 3 ) == 1 ) { SpeakIfAllowed( TLK_ATTACKING ); } Activity reloadGesture = TranslateActivity( ACT_GESTURE_RELOAD ); if ( reloadGesture != ACT_INVALID && IsPlayingGesture( reloadGesture ) ) { ResetIdealActivity( ACT_IDLE ); return; } BaseClass::StartTask( pTask ); } break; default: BaseClass::StartTask( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: Handle task running //----------------------------------------------------------------------------- void CAI_PassengerBehaviorZombie::RunTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_PASSENGER_ZOMBIE_RANGE_ATTACK1: { // Face the entry point Vector vecAttachPoint; GetAttachmentPoint( &vecAttachPoint ); GetOuter()->GetMotor()->SetIdealYawToTarget( vecAttachPoint ); // All done when you touch the ground if ( GetOuter()->GetFlags() & FL_ONGROUND ) { m_flNextLeapTime = gpGlobals->curtime + 2.0f; TaskComplete(); return; } } break; case TASK_MELEE_ATTACK1: if ( GetOuter()->IsSequenceFinished() ) { TaskComplete(); } break; case TASK_PASSENGER_ZOMBIE_DISMOUNT: { if ( GetOuter()->IsSequenceFinished() ) { // Completely separate from the vehicle FinishDismount(); TaskComplete(); } break; } default: BaseClass::RunTask( pTask ); break; } }
void CZombie::StartTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_ZOMBIE_EXPRESS_ANGER: { if ( random->RandomInt( 1, 4 ) == 2 ) SetIdealActivity( (Activity)ACT_ZOMBIE_TANTRUM ); else TaskComplete(); break; } case TASK_ZOMBIE_YAW_TO_DOOR: { AssertMsg( m_hBlockingDoor != NULL, "Expected condition handling to break schedule before landing here" ); if ( m_hBlockingDoor != NULL ) GetMotor()->SetIdealYaw( m_flDoorBashYaw ); TaskComplete(); break; } case TASK_ZOMBIE_ATTACK_DOOR: { m_DurationDoorBash.Reset(); SetIdealActivity( SelectDoorBash() ); break; } case TASK_ZOMBIE_CHARGE_ENEMY: { if ( !GetEnemy() ) TaskFail( FAIL_NO_ENEMY ); else if ( GetNavigator()->SetVectorGoalFromTarget( GetEnemy()->GetLocalOrigin() ) ) { m_vPositionCharged = GetEnemy()->GetLocalOrigin(); TaskComplete(); } else TaskFail( FAIL_NO_ROUTE ); break; } default: BaseClass::StartTask( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_ASW_JumpBehavior::RunTask( const Task_t *pTask ) { // some state that needs be set each frame if ( GetOuter()->GetFlags() & FL_ONGROUND ) { m_bHasDoneAirAttack = false; } switch ( pTask->iTask ) { case TASK_FACE_JUMP: { Vector jumpDir = m_vecSavedJump; VectorNormalize( jumpDir ); QAngle jumpAngles; VectorAngles( jumpDir, jumpAngles ); GetMotor()->SetIdealYawAndUpdate( jumpAngles[YAW], AI_KEEP_YAW_SPEED ); GetOuter()->SetTurnActivity(); if ( GetMotor()->DeltaIdealYaw() < 2 ) { TaskComplete(); } } break; case TASK_JUMP: if ( CheckLanding() ) { TaskComplete(); } break; default: BaseClass::RunTask( pTask ); break; } }
//========================================================= // RunTask //========================================================= void CNPC_HAssassin::RunTask ( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_ASSASSIN_FALL_TO_GROUND: GetMotor()->SetIdealYawAndUpdate( GetEnemyLKP() ); if ( IsSequenceFinished() ) { if ( GetAbsVelocity().z > 0) { SetActivity( ACT_ASSASSIN_FLY_UP ); } else if ( HasCondition ( COND_SEE_ENEMY )) { SetActivity( ACT_ASSASSIN_FLY_ATTACK ); SetCycle( 0 ); } else { SetActivity( ACT_ASSASSIN_FLY_DOWN ); SetCycle( 0 ); } ResetSequenceInfo( ); } if ( GetFlags() & FL_ONGROUND) { TaskComplete( ); } else if( gpGlobals->curtime > m_flWaitFinished || GetAbsVelocity().z == 0.0 ) { // I've waited two seconds and haven't hit the ground. Try to force it. trace_t trace; UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 1 ), MASK_NPCSOLID, this, COLLISION_GROUP_NONE, &trace ); if( trace.DidHitWorld() ) { SetGroundEntity( trace.m_pEnt ); } else { // Try again in a couple of seconds. m_flWaitFinished = gpGlobals->curtime + 2.0f; } } break; default: BaseClass::RunTask ( pTask ); break; } }
//========================================================= // RunTask //========================================================= void CNPC_Houndeye::RunTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_HOUND_THREAT_DISPLAY: { GetMotor()->SetIdealYawToTargetAndUpdate( GetEnemyLKP(), AI_KEEP_YAW_SPEED ); if ( IsActivityFinished() ) { TaskComplete(); } break; } case TASK_HOUND_CLOSE_EYE: { /*//<<TEMP>> if ( pev->skin < HOUNDEYE_EYE_FRAMES - 1 ) { pev->skin++; } */ break; } case TASK_HOUND_HOP_BACK: { if ( IsActivityFinished() ) { TaskComplete(); } break; } default: { BaseClass::RunTask(pTask); break; } } }
//========================================================= // RunTask //========================================================= void CMGargantua::RunTask( Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_FLAME_SWEEP: if ( gpGlobals->time > m_flWaitFinished ) { FlameDestroy(); TaskComplete(); FlameControls( 0, 0 ); SetBoneController( 0, 0 ); SetBoneController( 1, 0 ); } else { BOOL cancel = FALSE; Vector angles = g_vecZero; FlameUpdate(); edict_t *pEnemy = m_hEnemy; if ( pEnemy ) { Vector org = pev->origin; org.z += 64; Vector dir = UTIL_BodyTarget(pEnemy,org) - org; angles = UTIL_VecToAngles( dir ); angles.x = -angles.x; angles.y -= pev->angles.y; if ( dir.Length() > 400 ) cancel = TRUE; } if ( fabs(angles.y) > 60 ) cancel = TRUE; if ( cancel ) { m_flWaitFinished -= 0.5; m_flameTime -= 0.5; } // FlameControls( angles.x + 2 * sin(gpGlobals->time*8), angles.y + 28 * sin(gpGlobals->time*8.5) ); FlameControls( angles.x, angles.y ); } break; default: CMBaseMonster::RunTask( pTask ); break; } }
void CRebelZombie::RunTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_ZOMBIE_ATTACK_DOOR: { if ( IsActivityFinished() ) { if ( m_DurationDoorBash.Expired() ) { TaskComplete(); m_NextTimeToStartDoorBash.Reset(); } else ResetIdealActivity( SelectDoorBash() ); } break; } case TASK_ZOMBIE_CHARGE_ENEMY: { break; } case TASK_ZOMBIE_EXPRESS_ANGER: { if ( IsActivityFinished() ) { TaskComplete(); } break; } default: BaseClass::RunTask( pTask ); break; } }
void CZombie :: RunTask ( Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_CHECK_FOR_NOBODY_AROUND: { CBaseEntity *pEnt = NULL; while (pEnt = UTIL_FindEntityInSphere(pEnt, pev->origin + Vector(0, 0, 20), 18)) { if (pEnt->edict() == edict()) continue; if (!pEnt->IsAlive()) continue; if (pEnt->pev->solid == SOLID_NOT || pEnt->pev->solid == SOLID_TRIGGER) continue; return; } TaskComplete(); } break; case TASK_AWAKE_FROM_DEAD: { if ( pev->frame >= 255 ) { ReSpawn(); TaskComplete(); } } break; default: CBaseMonster::RunTask(pTask); break; } }
void CASW_Alien_Jumper::RunTask( const Task_t *pTask ) { switch ( pTask->iTask ) { case TASK_ASW_ALIEN_FACE_JUMP: { Vector jumpDir = m_vecSavedJump; VectorNormalize( jumpDir ); QAngle jumpAngles; VectorAngles( jumpDir, jumpAngles ); GetMotor()->SetIdealYawAndUpdate( jumpAngles[YAW], AI_KEEP_YAW_SPEED ); SetTurnActivity(); if ( abs(GetMotor()->DeltaIdealYaw()) < 2 ) { //Msg("Alien jumping: jumpyaw=%f delta=%f ang.y=%f\n", //jumpAngles[YAW], GetMotor()->DeltaIdealYaw(), GetLocalAngles().y); TaskComplete(); } } break; case TASK_ASW_ALIEN_JUMP: if ( CheckLanding() ) { TaskComplete(); } break; default: BaseClass::RunTask( pTask ); break; } }
//----------------------------------------------------------------------------- // Purpose: // Input : *pTask - //----------------------------------------------------------------------------- void CAI_RappelBehavior::RunTask( const Task_t *pTask ) { switch( pTask->iTask ) { case TASK_RAPPEL: { // If we don't do this, the beam won't show up sometimes. Ideally, all beams would update their // bboxes correctly, but we're close to shipping and we can't change that now. if ( m_hLine ) { m_hLine->RelinkBeam(); } if( GetEnemy() ) { // Face the enemy if there's one. Vector vecEnemyLKP = GetEnemyLKP(); GetOuter()->GetMotor()->SetIdealYawToTargetAndUpdate( vecEnemyLKP ); } SetDescentSpeed(); if( GetOuter()->GetFlags() & FL_ONGROUND ) { CBaseEntity *pGroundEnt = GetOuter()->GetGroundEntity(); if( pGroundEnt && pGroundEnt->IsPlayer() ) { // try to shove the player in the opposite direction as they are facing (so they'll see me) Vector vecForward; pGroundEnt->GetVectors( &vecForward, NULL, NULL ); pGroundEnt->SetAbsVelocity( vecForward * -500 ); break; } GetOuter()->m_OnRappelTouchdown.FireOutput( GetOuter(), GetOuter(), 0 ); GetOuter()->RemoveFlag( FL_FLY ); CutZipline(); TaskComplete(); } } break; default: BaseClass::RunTask( pTask ); break; } }