//-----------------------------------------------------------------------------
// Purpose:
// Input : flInterval -
//-----------------------------------------------------------------------------
void CNPC_WpnScanner::MoveToAttack(float flInterval)
{
if (GetEnemy() == NULL)
return;
if ( flInterval <= 0 )
return;
Vector vTargetPos = GetEnemyLKP();
Vector idealPos = IdealGoalForMovement( vTargetPos, GetAbsOrigin(), GetGoalDistance(), 128 );
NDebugOverlay::Box( idealPos, -Vector(4,4,4), Vector(4,4,4), 0,255,0,8, 0.1 );
MoveToTarget( flInterval, idealPos );
//FIXME: Re-implement?
/*
// ---------------------------------------------------------
// Add evasion if I have taken damage recently
// ---------------------------------------------------------
if ((m_flLastDamageTime + SCANNER_EVADE_TIME) > gpGlobals->curtime)
{
vFlyDirection = vFlyDirection + VelocityToEvade(GetEnemyCombatCharacterPointer());
}
*/
}
// Initialisierung
protected func Initialize()
{
// Fliegen! :D
SetAction("Fly");
MoveToTarget();
//SetClrModulation(RGBa(RandomX(0,255),RandomX(0,255),RandomX(0,255)),this());
return;
}
/**
** Unit attacks!
**
** if (SubAction & WEAK_TARGET) is true the goal is a weak goal.
** This means the unit AI (little AI) could choose a new better goal.
**
** @todo Lets do some tries to reach the target.
** If target place is not reachable, choose better goal to reduce
** the pathfinder load.
**
** @param unit Unit, for that the attack is handled.
*/
/* virtual */ void COrder_Attack::Execute(CUnit &unit)
{
Assert(this->HasGoal() || Map.Info.IsPointOnMap(this->goalPos));
if (unit.Wait) {
unit.Wait--;
return;
}
switch (this->State) {
case 0: { // First entry
// did Order change ?
if (CheckForTargetInRange(unit)) {
return;
}
// Can we already attack ?
if (this->HasGoal()) {
CUnit &goal = *this->GetGoal();
const int dist = goal.MapDistanceTo(unit);
if (unit.Type->MinAttackRange < dist &&
dist <= unit.Stats->Variables[ATTACKRANGE_INDEX].Max) {
const Vec2i dir = goal.tilePos + goal.Type->GetHalfTileSize() - unit.tilePos;
UnitHeadingFromDeltaXY(unit, dir);
this->State = ATTACK_TARGET;
AttackTarget(unit);
return;
}
}
this->State = MOVE_TO_TARGET;
// FIXME: should use a reachable place to reduce pathfinder time.
}
// FALL THROUGH
case MOVE_TO_TARGET:
case MOVE_TO_TARGET + WEAK_TARGET:
if (!unit.CanMove()) {
this->Finished = true;
return;
}
MoveToTarget(unit);
break;
case ATTACK_TARGET:
case ATTACK_TARGET + WEAK_TARGET:
AttackTarget(unit);
break;
case WEAK_TARGET:
DebugPrint("FIXME: wrong entry.\n");
break;
}
}
void AIRobot::Update(float elapsedTime)
{
// Step 1 : check for enemy
// TODO : Finish this part and decide what to do
CheckForEnemy();
// Step 2 : check if we reached target
if (isCloseEnough())
{
mGridPos = mGridTarget;
FindNewTarget();
}
// Step 3 : move towards target
MoveToTarget(elapsedTime);
}
AI_NavPathProgress_t CAI_BasePhysicsFlyingBot::ProgressFlyPath(
float flInterval,
const CBaseEntity *pNewTarget,
unsigned collisionMask,
bool bNewTrySimplify,
float strictPointTolerance)
{
AI_ProgressFlyPathParams_t params( collisionMask );
params.strictPointTolerance = strictPointTolerance;
params.SetCurrent( pNewTarget, bNewTrySimplify );
AI_NavPathProgress_t progress = GetNavigator()->ProgressFlyPath( params );
switch ( progress )
{
case AINPP_NO_CHANGE:
case AINPP_ADVANCED:
{
MoveToTarget(flInterval, GetNavigator()->GetCurWaypointPos());
break;
}
case AINPP_COMPLETE:
{
TaskMovementComplete();
break;
}
case AINPP_BLOCKED: // function is not supposed to test blocking, just simple path progression
default:
{
AssertMsg( 0, ( "Unexpected result" ) );
break;
}
}
return progress;
}
void CBigMomma::StartTask( Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_FIND_NODE:
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( !HasMemory( bits_MEMORY_ADVANCE_NODE ) )
{
if ( pTarget )
pev->netname = m_hTargetEnt->pev->target;
}
NodeStart( pev->netname );
TaskComplete();
ALERT( at_aiconsole, "BM: Found node %s\n", STRING(pev->netname) );
}
break;
case TASK_NODE_DELAY:
m_nodeTime = gpGlobals->time + pTask->flData;
TaskComplete();
ALERT( at_aiconsole, "BM: FAIL! Delay %.2f\n", pTask->flData );
break;
case TASK_PROCESS_NODE:
ALERT( at_aiconsole, "BM: Reached node %s\n", STRING(pev->netname) );
NodeReach();
TaskComplete();
break;
case TASK_PLAY_NODE_PRESEQUENCE:
case TASK_PLAY_NODE_SEQUENCE:
{
int sequence;
if ( pTask->iTask == TASK_PLAY_NODE_SEQUENCE )
sequence = GetNodeSequence();
else
sequence = GetNodePresequence();
ALERT( at_aiconsole, "BM: Playing node sequence %s\n", STRING(sequence) );
if ( sequence )
{
sequence = LookupSequence( STRING( sequence ) );
if ( sequence != -1 )
{
pev->sequence = sequence;
pev->frame = 0;
ResetSequenceInfo( );
ALERT( at_aiconsole, "BM: Sequence %s\n", STRING(GetNodeSequence()) );
return;
}
}
TaskComplete();
}
break;
case TASK_NODE_YAW:
pev->ideal_yaw = GetNodeYaw();
TaskComplete();
break;
case TASK_WAIT_NODE:
m_flWait = gpGlobals->time + GetNodeDelay();
if ( m_hTargetEnt->pev->spawnflags & SF_INFOBM_WAIT )
ALERT( at_aiconsole, "BM: Wait at node %s forever\n", STRING(pev->netname) );
else
ALERT( at_aiconsole, "BM: Wait at node %s for %.2f\n", STRING(pev->netname), GetNodeDelay() );
break;
case TASK_MOVE_TO_NODE_RANGE:
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( !pTarget )
TaskFail();
else
{
if ( (pTarget->pev->origin - pev->origin).Length() < GetNodeRange() )
TaskComplete();
else
{
Activity act = ACT_WALK;
if ( pTarget->pev->spawnflags & SF_INFOBM_RUN )
act = ACT_RUN;
m_vecMoveGoal = pTarget->pev->origin;
if ( !MoveToTarget( act, 2 ) )
{
TaskFail();
}
}
}
}
ALERT( at_aiconsole, "BM: Moving to node %s\n", STRING(pev->netname) );
break;
case TASK_MELEE_ATTACK1:
// Play an attack sound here
EMIT_SOUND_DYN( ENT(pev), CHAN_VOICE, RANDOM_SOUND_ARRAY(pAttackSounds), 1.0, ATTN_NORM, 0, PITCH_NORM );
CBaseMonster::StartTask( pTask );
break;
default:
CBaseMonster::StartTask( pTask );
break;
}
}
//=========================================================
// Start task - selects the correct activity and performs
// any necessary calculations to start the next task on the
// schedule.
//=========================================================
void CBaseMonster :: StartTask ( Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_TURN_RIGHT:
{
float flCurrentYaw;
flCurrentYaw = UTIL_AngleMod( pev->angles.y );
pev->ideal_yaw = UTIL_AngleMod( flCurrentYaw - pTask->flData );
SetTurnActivity();
break;
}
case TASK_TURN_LEFT:
{
float flCurrentYaw;
flCurrentYaw = UTIL_AngleMod( pev->angles.y );
pev->ideal_yaw = UTIL_AngleMod( flCurrentYaw + pTask->flData );
SetTurnActivity();
break;
}
case TASK_REMEMBER:
{
Remember ( (int)pTask->flData );
TaskComplete();
break;
}
case TASK_FORGET:
{
Forget ( (int)pTask->flData );
TaskComplete();
break;
}
case TASK_FIND_HINTNODE:
{
m_iHintNode = FindHintNode();
if ( m_iHintNode != NO_NODE )
{
TaskComplete();
}
else
{
TaskFail();
}
break;
}
case TASK_STORE_LASTPOSITION:
{
m_vecLastPosition = pev->origin;
TaskComplete();
break;
}
case TASK_CLEAR_LASTPOSITION:
{
m_vecLastPosition = g_vecZero;
TaskComplete();
break;
}
case TASK_CLEAR_HINTNODE:
{
m_iHintNode = NO_NODE;
TaskComplete();
break;
}
case TASK_STOP_MOVING:
{
if ( m_IdealActivity == m_movementActivity )
{
m_IdealActivity = GetStoppedActivity();
}
RouteClear();
TaskComplete();
break;
}
case TASK_PLAY_SEQUENCE_FACE_ENEMY:
case TASK_PLAY_SEQUENCE_FACE_TARGET:
case TASK_PLAY_SEQUENCE:
{
m_IdealActivity = ( Activity )( int )pTask->flData;
break;
}
case TASK_PLAY_ACTIVE_IDLE:
{
// monsters verify that they have a sequence for the node's activity BEFORE
// moving towards the node, so it's ok to just set the activity without checking here.
m_IdealActivity = ( Activity )WorldGraph.m_pNodes[ m_iHintNode ].m_sHintActivity;
break;
}
case TASK_SET_SCHEDULE:
{
Schedule_t *pNewSchedule;
pNewSchedule = GetScheduleOfType( (int)pTask->flData );
if ( pNewSchedule )
{
ChangeSchedule( pNewSchedule );
}
else
{
TaskFail();
}
break;
}
case TASK_FIND_NEAR_NODE_COVER_FROM_ENEMY:
{
if ( m_hEnemy == NULL )
{
TaskFail();
return;
}
if ( FindCover( m_hEnemy->pev->origin, m_hEnemy->pev->view_ofs, 0, pTask->flData ) )
{
// try for cover farther than the FLData from the schedule.
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_FAR_NODE_COVER_FROM_ENEMY:
{
if ( m_hEnemy == NULL )
{
TaskFail();
return;
}
if ( FindCover( m_hEnemy->pev->origin, m_hEnemy->pev->view_ofs, pTask->flData, CoverRadius() ) )
{
// try for cover farther than the FLData from the schedule.
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_NODE_COVER_FROM_ENEMY:
{
if ( m_hEnemy == NULL )
{
TaskFail();
return;
}
if ( FindCover( m_hEnemy->pev->origin, m_hEnemy->pev->view_ofs, 0, CoverRadius() ) )
{
// try for cover farther than the FLData from the schedule.
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_COVER_FROM_ENEMY:
{
entvars_t *pevCover;
if ( m_hEnemy == NULL )
{
// Find cover from self if no enemy available
pevCover = pev;
// TaskFail();
// return;
}
else
pevCover = m_hEnemy->pev;
if ( FindLateralCover( pevCover->origin, pevCover->view_ofs ) )
{
// try lateral first
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else if ( FindCover( pevCover->origin, pevCover->view_ofs, 0, CoverRadius() ) )
{
// then try for plain ole cover
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else
{
// no coverwhatsoever.
TaskFail();
}
break;
}
case TASK_FIND_COVER_FROM_ORIGIN:
{
if ( FindCover( pev->origin, pev->view_ofs, 0, CoverRadius() ) )
{
// then try for plain ole cover
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else
{
// no cover!
TaskFail();
}
}
break;
case TASK_FIND_COVER_FROM_BEST_SOUND:
{
CSound *pBestSound;
pBestSound = PBestSound();
ASSERT( pBestSound != NULL );
/*
if ( pBestSound && FindLateralCover( pBestSound->m_vecOrigin, g_vecZero ) )
{
// try lateral first
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
*/
if ( pBestSound && FindCover( pBestSound->m_vecOrigin, g_vecZero, pBestSound->m_iVolume, CoverRadius() ) )
{
// then try for plain ole cover
m_flMoveWaitFinished = gpGlobals->time + pTask->flData;
TaskComplete();
}
else
{
// no coverwhatsoever. or no sound in list
TaskFail();
}
break;
}
case TASK_FACE_HINTNODE:
{
pev->ideal_yaw = WorldGraph.m_pNodes[ m_iHintNode ].m_flHintYaw;
SetTurnActivity();
break;
}
case TASK_FACE_LASTPOSITION:
MakeIdealYaw ( m_vecLastPosition );
SetTurnActivity();
break;
case TASK_FACE_TARGET:
if ( m_hTargetEnt != NULL )
{
MakeIdealYaw ( m_hTargetEnt->pev->origin );
SetTurnActivity();
}
else
TaskFail();
break;
case TASK_FACE_ENEMY:
{
MakeIdealYaw ( m_vecEnemyLKP );
SetTurnActivity();
break;
}
case TASK_FACE_IDEAL:
{
SetTurnActivity();
break;
}
case TASK_FACE_ROUTE:
{
if (FRouteClear())
{
ALERT(at_aiconsole, "No route to face!\n");
TaskFail();
}
else
{
MakeIdealYaw(m_Route[m_iRouteIndex].vecLocation);
SetTurnActivity();
}
break;
}
case TASK_WAIT_PVS:
case TASK_WAIT_INDEFINITE:
{
// don't do anything.
break;
}
case TASK_WAIT:
case TASK_WAIT_FACE_ENEMY:
{// set a future time that tells us when the wait is over.
m_flWaitFinished = gpGlobals->time + pTask->flData;
break;
}
case TASK_WAIT_RANDOM:
{// set a future time that tells us when the wait is over.
m_flWaitFinished = gpGlobals->time + RANDOM_FLOAT( 0.1, pTask->flData );
break;
}
case TASK_MOVE_TO_TARGET_RANGE:
{
if ( (m_hTargetEnt->pev->origin - pev->origin).Length() < 1 )
TaskComplete();
else
{
m_vecMoveGoal = m_hTargetEnt->pev->origin;
if ( !MoveToTarget( ACT_WALK, 2 ) )
TaskFail();
}
break;
}
case TASK_RUN_TO_SCRIPT:
case TASK_WALK_TO_SCRIPT:
{
Activity newActivity;
if ( !m_pGoalEnt || (m_pGoalEnt->pev->origin - pev->origin).Length() < 1 )
TaskComplete();
else
{
if ( pTask->iTask == TASK_WALK_TO_SCRIPT )
newActivity = ACT_WALK;
else
newActivity = ACT_RUN;
// This monster can't do this!
if ( LookupActivity( newActivity ) == ACTIVITY_NOT_AVAILABLE )
TaskComplete();
else
{
if ( m_pGoalEnt != NULL )
{
Vector vecDest;
vecDest = m_pGoalEnt->pev->origin;
if ( !MoveToLocation( newActivity, 2, vecDest ) )
{
TaskFail();
ALERT( at_aiconsole, "%s Failed to reach script!!!\n", STRING(pev->classname) );
RouteClear();
}
}
else
{
TaskFail();
ALERT( at_aiconsole, "%s: MoveTarget is missing!?!\n", STRING(pev->classname) );
RouteClear();
}
}
}
TaskComplete();
break;
}
case TASK_CLEAR_MOVE_WAIT:
{
m_flMoveWaitFinished = gpGlobals->time;
TaskComplete();
break;
}
case TASK_MELEE_ATTACK1_NOTURN:
case TASK_MELEE_ATTACK1:
{
m_IdealActivity = ACT_MELEE_ATTACK1;
break;
}
case TASK_MELEE_ATTACK2_NOTURN:
case TASK_MELEE_ATTACK2:
{
m_IdealActivity = ACT_MELEE_ATTACK2;
break;
}
case TASK_RANGE_ATTACK1_NOTURN:
case TASK_RANGE_ATTACK1:
{
m_IdealActivity = ACT_RANGE_ATTACK1;
break;
}
case TASK_RANGE_ATTACK2_NOTURN:
case TASK_RANGE_ATTACK2:
{
m_IdealActivity = ACT_RANGE_ATTACK2;
break;
}
case TASK_RELOAD_NOTURN:
case TASK_RELOAD:
{
m_IdealActivity = ACT_RELOAD;
break;
}
case TASK_SPECIAL_ATTACK1:
{
m_IdealActivity = ACT_SPECIAL_ATTACK1;
break;
}
case TASK_SPECIAL_ATTACK2:
{
m_IdealActivity = ACT_SPECIAL_ATTACK2;
break;
}
case TASK_SET_ACTIVITY:
{
m_IdealActivity = (Activity)(int)pTask->flData;
TaskComplete();
break;
}
case TASK_GET_PATH_TO_ENEMY_LKP:
{
if ( BuildRoute ( m_vecEnemyLKP, bits_MF_TO_LOCATION, NULL ) )
{
TaskComplete();
}
else if (BuildNearestRoute( m_vecEnemyLKP, pev->view_ofs, 0, (m_vecEnemyLKP - pev->origin).Length() ))
{
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 ( BuildRoute ( pEnemy->pev->origin, bits_MF_TO_ENEMY, pEnemy ) )
{
TaskComplete();
}
else if (BuildNearestRoute( pEnemy->pev->origin, pEnemy->pev->view_ofs, 0, (pEnemy->pev->origin - pev->origin).Length() ))
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToEnemy failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_ENEMY_CORPSE:
{
UTIL_MakeVectors( pev->angles );
if ( BuildRoute ( m_vecEnemyLKP - gpGlobals->v_forward * 64, bits_MF_TO_LOCATION, NULL ) )
{
TaskComplete();
}
else
{
ALERT ( at_aiconsole, "GetPathToEnemyCorpse failed!!\n" );
TaskFail();
}
}
break;
case TASK_GET_PATH_TO_SPOT:
{
CBaseEntity *pPlayer = UTIL_FindEntityByClassname( NULL, "player" );
if ( BuildRoute ( m_vecMoveGoal, bits_MF_TO_LOCATION, pPlayer ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToSpot failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_TARGET:
{
RouteClear();
if ( m_hTargetEnt != NULL && MoveToTarget( m_movementActivity, 1 ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToSpot failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_SCRIPT:
{
RouteClear();
if ( m_pCine != NULL && MoveToLocation( m_movementActivity, 1, m_pCine->pev->origin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToSpot failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_HINTNODE:// for active idles!
{
if ( MoveToLocation( m_movementActivity, 2, WorldGraph.m_pNodes[ m_iHintNode ].m_vecOrigin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToHintNode failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_LASTPOSITION:
{
m_vecMoveGoal = m_vecLastPosition;
if ( MoveToLocation( m_movementActivity, 2, m_vecMoveGoal ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToLastPosition failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_BESTSOUND:
{
CSound *pSound;
pSound = PBestSound();
if ( pSound && MoveToLocation( m_movementActivity, 2, pSound->m_vecOrigin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToBestSound failed!!\n" );
TaskFail();
}
break;
}
case TASK_GET_PATH_TO_BESTSCENT:
{
CSound *pScent;
pScent = PBestScent();
if ( pScent && MoveToLocation( m_movementActivity, 2, pScent->m_vecOrigin ) )
{
TaskComplete();
}
else
{
// no way to get there =(
ALERT ( at_aiconsole, "GetPathToBestScent failed!!\n" );
TaskFail();
}
break;
}
case TASK_RUN_PATH:
{
// UNDONE: This is in some default AI and some monsters can't run? -- walk instead?
if ( LookupActivity( ACT_RUN ) != ACTIVITY_NOT_AVAILABLE )
{
m_movementActivity = ACT_RUN;
}
else
{
m_movementActivity = ACT_WALK;
}
TaskComplete();
break;
}
case TASK_WALK_PATH:
{
if ( pev->movetype == MOVETYPE_FLY )
{
m_movementActivity = ACT_FLY;
}
if ( LookupActivity( ACT_WALK ) != ACTIVITY_NOT_AVAILABLE )
{
m_movementActivity = ACT_WALK;
}
else
{
m_movementActivity = ACT_RUN;
}
TaskComplete();
break;
}
case TASK_STRAFE_PATH:
{
Vector2D vec2DirToPoint;
Vector2D vec2RightSide;
// to start strafing, we have to first figure out if the target is on the left side or right side
UTIL_MakeVectors ( pev->angles );
vec2DirToPoint = ( m_Route[ 0 ].vecLocation - pev->origin ).Make2D().Normalize();
vec2RightSide = gpGlobals->v_right.Make2D().Normalize();
if ( DotProduct ( vec2DirToPoint, vec2RightSide ) > 0 )
{
// strafe right
m_movementActivity = ACT_STRAFE_RIGHT;
}
else
{
// strafe left
m_movementActivity = ACT_STRAFE_LEFT;
}
TaskComplete();
break;
}
case TASK_WAIT_FOR_MOVEMENT:
{
if (FRouteClear())
{
TaskComplete();
}
break;
}
case TASK_EAT:
{
Eat( pTask->flData );
TaskComplete();
break;
}
case TASK_SMALL_FLINCH:
{
m_IdealActivity = GetSmallFlinchActivity();
break;
}
case TASK_DIE:
{
RouteClear();
m_IdealActivity = GetDeathActivity();
pev->deadflag = DEAD_DYING;
break;
}
case TASK_SOUND_WAKE:
{
AlertSound();
TaskComplete();
break;
}
case TASK_SOUND_DIE:
{
DeathSound();
TaskComplete();
break;
}
case TASK_SOUND_IDLE:
{
IdleSound();
TaskComplete();
break;
}
case TASK_SOUND_PAIN:
{
PainSound();
TaskComplete();
break;
}
case TASK_SOUND_DEATH:
{
DeathSound();
TaskComplete();
break;
}
case TASK_SOUND_ANGRY:
{
// sounds are complete as soon as we get here, cause we've already played them.
ALERT ( at_aiconsole, "SOUND\n" );
TaskComplete();
break;
}
case TASK_WAIT_FOR_SCRIPT:
{
if ( m_pCine->m_iDelay <= 0 && gpGlobals->time >= m_pCine->m_startTime )
{
TaskComplete(); //LRC - start playing immediately
}
else if (!m_pCine->IsAction() && m_pCine->m_iszIdle)
{
m_pCine->StartSequence( (CBaseMonster *)this, m_pCine->m_iszIdle, FALSE );
if (FStrEq( STRING(m_pCine->m_iszIdle), STRING(m_pCine->m_iszPlay)))
{
pev->framerate = 0;
}
}
else
m_IdealActivity = ACT_IDLE;
break;
}
case TASK_PLAY_SCRIPT:
{
if (m_pCine->IsAction())
{
//ALERT(at_console,"PlayScript: setting idealactivity %d\n",m_pCine->m_fAction);
switch(m_pCine->m_fAction)
{
case 0:
m_IdealActivity = ACT_RANGE_ATTACK1; break;
case 1:
m_IdealActivity = ACT_RANGE_ATTACK2; break;
case 2:
m_IdealActivity = ACT_MELEE_ATTACK1; break;
case 3:
m_IdealActivity = ACT_MELEE_ATTACK2; break;
case 4:
m_IdealActivity = ACT_SPECIAL_ATTACK1; break;
case 5:
m_IdealActivity = ACT_SPECIAL_ATTACK2; break;
case 6:
m_IdealActivity = ACT_RELOAD; break;
case 7:
m_IdealActivity = ACT_HOP; break;
}
pev->framerate = 1.0; // shouldn't be needed, but just in case
pev->movetype = MOVETYPE_FLY;
ClearBits(pev->flags, FL_ONGROUND);
}
else
{
m_pCine->StartSequence( (CBaseMonster *)this, m_pCine->m_iszPlay, TRUE );
if ( m_fSequenceFinished )
ClearSchedule();
pev->framerate = 1.0;
//ALERT( at_aiconsole, "Script %s has begun for %s\n", STRING( m_pCine->m_iszPlay ), STRING(pev->classname) );
}
m_scriptState = SCRIPT_PLAYING;
break;
}
case TASK_ENABLE_SCRIPT:
{
m_pCine->DelayStart( 0 );
TaskComplete();
break;
}
//LRC
case TASK_END_SCRIPT:
{
m_pCine->SequenceDone( this );
TaskComplete();
break;
}
case TASK_PLANT_ON_SCRIPT:
{
if ( m_pCine != NULL )
{
// Plant on script
// LRC - if it's a teleport script, do the turn too
if (m_pCine->m_fMoveTo == 4 || m_pCine->m_fMoveTo == 6)
{
if (m_pCine->m_fTurnType == 0) //LRC
pev->angles.y = m_hTargetEnt->pev->angles.y;
else if (m_pCine->m_fTurnType == 1)
pev->angles.y = UTIL_VecToYaw(m_hTargetEnt->pev->origin - pev->origin);
pev->ideal_yaw = pev->angles.y;
pev->avelocity = Vector( 0, 0, 0 );
pev->velocity = Vector( 0, 0, 0 );
pev->effects |= EF_NOINTERP;
}
if (m_pCine->m_fMoveTo != 6)
pev->origin = m_pGoalEnt->pev->origin;
}
TaskComplete();
break;
}
case TASK_FACE_SCRIPT:
{
if ( m_pCine != NULL && m_pCine->m_fMoveTo != 0) // movetype "no move" makes us ignore turntype
{
switch (m_pCine->m_fTurnType)
{
case 0:
pev->ideal_yaw = UTIL_AngleMod( m_pCine->pev->angles.y );
break;
case 1:
// yes, this is inconsistent- turn to face uses the "target" and turn to angle uses the "cine".
if (m_hTargetEnt)
MakeIdealYaw ( m_hTargetEnt->pev->origin );
else
MakeIdealYaw ( m_pCine->pev->origin );
break;
// default: don't turn
}
}
TaskComplete();
m_IdealActivity = ACT_IDLE;
RouteClear();
break;
}
case TASK_SUGGEST_STATE:
{
m_IdealMonsterState = (MONSTERSTATE)(int)pTask->flData;
TaskComplete();
break;
}
case TASK_SET_FAIL_SCHEDULE:
m_failSchedule = (int)pTask->flData;
TaskComplete();
break;
case TASK_CLEAR_FAIL_SCHEDULE:
m_failSchedule = SCHED_NONE;
TaskComplete();
break;
default:
{
ALERT ( at_aiconsole, "No StartTask entry for %d\n", (SHARED_TASKS)pTask->iTask );
break;
}
}
}
//! called during the update of the entity
void KamikazeAttacker::Update()
{
if(m_fHitPoints < 0.0f || !GSETTINGS)
{
return;
}
auto settings = DYNAMIC_CAST(m_Settings, KamikazeAttackerSettings);
switch (m_eState)
{
case KamikazeAttacker::S_Moving:
{
Vector3 vToHQ = m_TargetHQ->GetAbsolutePosition() - GetAbsolutePosition();
bool reachedHQ = false;
if ((int)m_CurrentTarget > (int)m_Path.size() - 3)
{
float fDistToHQSq = vToHQ.GetLengthSquared();
reachedHQ = fDistToHQSq < settings->m_fHQKamikazeRange*settings->m_fHQKamikazeRange;
}
if (reachedHQ)
{
m_fDecelTimer = 0.0f;
m_eState = S_PreparingAttack;
m_bTargetReached = true;
break;
}
if (!m_bTargetReached)
MoveToTarget();
else
SteerToTarget();
LookAtTarget();
}
break;
case S_PreparingAttack:
{
if (m_TargetHQ->GetHitPoints() < 0.0f)
{
if (auto nextTarget = WAVEMGR->GetNextHQ())
{
m_TargetHQ = nextTarget;
m_eState = S_Moving;
}
else
m_eState = S_Idle;
}
else
{
m_vSpeed = Math::Damp(m_vSpeed, Vector3::Zero, g_fDeltaTime, settings->m_fDecelDuration);
m_fDecelTimer += g_fDeltaTime;
if (m_fDecelTimer > settings->m_fDecelDuration)
{
m_eState = S_AttackingHQ;
break;
}
Translate(m_vSpeed * g_fDeltaTime);
auto vToHQ = (m_TargetHQ->GetAbsolutePosition() - GetAbsolutePosition()).Normalized();
m_vLookAt = Math::Damp(m_vLookAt, vToHQ, g_fDeltaTime, 0.1f).Normalized();
LookAt(m_vLookAt);
}
}
break;
case KamikazeAttacker::S_AttackingHQ:
{
Vector3 vToHQ = (m_TargetHQ->GetAbsolutePosition() - GetAbsolutePosition()).Normalized();
Vector3 vAcceleration = vToHQ*settings->m_fKamikazeMaxAccel*g_fDeltaTime;
m_vSpeed += vAcceleration;
m_vSpeed.Limit(settings->m_fKamikazeMaxSpeed);
Translate(m_vSpeed * g_fDeltaTime);
}
break;
}
super::Update();
}
void CScientist :: StartTask( Task_t *pTask )
{
switch( pTask->iTask )
{
case TASK_SAY_HEAL:
// if ( FOkToSpeak() )
Talk( 2 );
m_hTalkTarget = m_hTargetEnt;
PlaySentence( "SC_HEAL", 2, VOL_NORM, ATTN_IDLE );
TaskComplete();
break;
case TASK_SCREAM:
Scream();
TaskComplete();
break;
case TASK_RANDOM_SCREAM:
if ( RANDOM_FLOAT( 0, 1 ) < pTask->flData )
Scream();
TaskComplete();
break;
case TASK_SAY_FEAR:
if ( FOkToSpeak() )
{
Talk( 2 );
m_hTalkTarget = m_hEnemy;
if ( m_hEnemy->IsPlayer() )
PlaySentence( "SC_PLFEAR", 5, VOL_NORM, ATTN_NORM );
else
PlaySentence( "SC_FEAR", 5, VOL_NORM, ATTN_NORM );
}
TaskComplete();
break;
case TASK_HEAL:
m_IdealActivity = ACT_MELEE_ATTACK1;
break;
case TASK_RUN_PATH_SCARED:
m_movementActivity = ACT_RUN_SCARED;
break;
case TASK_MOVE_TO_TARGET_RANGE_SCARED:
{
if ( (m_hTargetEnt->pev->origin - pev->origin).Length() < 1 )
TaskComplete();
else
{
m_vecMoveGoal = m_hTargetEnt->pev->origin;
if ( !MoveToTarget( ACT_WALK_SCARED, 0.5 ) )
TaskFail();
}
}
break;
default:
CTalkMonster::StartTask( pTask );
break;
}
}
//! called during the update of the entity
void ShootingAttacker::Update()
{
if(m_fHitPoints < 0.0f)
return;
switch (m_eState)
{
case shoot::ShootingAttacker::S_Moving:
{
bool reachedHQ = false;
if ((int)m_CurrentTarget > (int)m_Path.size() - 3)
{
float fDistToHQSq = (m_TargetHQ->GetAbsolutePosition() - GetAbsolutePosition()).GetLengthSquared();
reachedHQ = fDistToHQSq < m_AttackerSettings->m_fHQRange*m_AttackerSettings->m_fHQRange;
}
if (reachedHQ)
{
m_ShootTarget = m_TargetHQ;
m_eState = S_AttackingHQ;
m_bTargetReached = true;
auto hoverAnim = static_cast<Visitor*>(GetMeshEntity()->GetComponent("HoverAnim"));
hoverAnim->Visit(GetMeshEntity());
break;
}
if (!m_bTargetReached)
MoveToTarget();
else
{
// this is the second target, just steer to it
SteerToTarget();
}
LookAtTarget();
}
break;
case shoot::ShootingAttacker::S_AttackingHQ:
{
if (m_TargetHQ->GetHitPoints() < 0.0f)
{
if (auto nextTarget = WAVEMGR->GetNextHQ())
{
m_TargetHQ = nextTarget;
m_eState = S_Moving;
}
else
m_eState = S_Idle;
}
else
{
SteerToTarget();
AimAndShoot();
}
}
break;
}
super::Update();
}
void FlipTarget ()
{
MoveToTarget ((m_currentPort == m_triggerPort0) ? m_triggerPort1 : m_triggerPort0);
}
