mv
/
sqwarmed
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sqwarmed/sdk_src/game/server/swarm/asw_marine_schedule.cpp

3527 lines
99 KiB
C++
Raw Blame History

#include "cbase.h"
#include "ai_default.h"
#include "ai_task.h"
#include "ai_schedule.h"
#include "ai_node.h"
#include "ai_hull.h"
#include "ai_hint.h"
#include "ai_squad.h"
#include "ai_senses.h"
#include "ai_navigator.h"
#include "ai_motor.h"
#include "ai_behavior.h"
#include "ai_baseactor.h"
#include "ai_behavior_lead.h"
#include "ai_behavior_follow.h"
#include "ai_behavior_standoff.h"
#include "ai_behavior_assault.h"
#include "ai_playerally.h"
#include "ai_pathfinder.h"
#include "ai_link.h"
#include "soundent.h"
#include "game.h"
#include "npcevent.h"
#include "entitylist.h"
#include "activitylist.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "sceneentity.h"
#include "asw_marine.h"
#include "asw_player.h"
#include "asw_marine_resource.h"
#include "asw_marine_profile.h"
#include "asw_weapon.h"
#include "asw_marine_speech.h"
//#include "asw_drone.h"
#include "asw_pickup.h"
#include "asw_pickup_weapon.h"
#include "asw_gamerules.h"
#include "asw_mission_manager.h"
#include "weapon_flaregun.h"
#include "ammodef.h"
#include "asw_shareddefs.h"
#include "asw_sentry_base.h"
#include "asw_button_area.h"
#include "asw_equipment_list.h"
#include "asw_weapon_parse.h"
#include "asw_weapon_ammo_bag_shared.h"
#include "asw_fx_shared.h"
#include "asw_parasite.h"
#include "shareddefs.h"
#include "datacache/imdlcache.h"
#include "asw_bloodhound.h"
#include "beam_shared.h"
#include "rope.h"
#include "shot_manipulator.h"
#include "asw_use_area.h"
#include "asw_computer_area.h"
#include "ai_network.h"
#include "ai_networkmanager.h"
#include "asw_util_shared.h"
#include "asw_ammo.h"
#include "asw_ammo_drop.h"
#include "asw_door_area.h"
#include "asw_door.h"
#include "smartptr.h"
#include "ai_waypoint.h"
#include "particle_parse.h"
#include "asw_alien_goo_shared.h"
#include "asw_prop_physics.h"
#include "asw_weapon_heal_gun_shared.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// anim events
int AE_MARINE_KICK;
int AE_MARINE_UNFREEZE;
// activities
int ACT_MARINE_GETTING_UP;
int ACT_MARINE_LAYING_ON_FLOOR;
ConVar asw_marine_aim_error_max("asw_marine_aim_error_max", "20.0f", FCVAR_CHEAT, "Maximum firing error angle for AI marines with base accuracy skill\n");
ConVar asw_marine_aim_error_min("asw_marine_aim_error_min", "5.0f", FCVAR_CHEAT, "Minimum firing error angle for AI marines with base accuracy skill\n");
// todo: have this value vary based on marine skill/level/distance
ConVar asw_marine_aim_error_decay_multiplier("asw_marine_aim_error_decay_multiplier", "0.9f", FCVAR_CHEAT, "Value multiplied per turn to reduce aim error over time\n");
ConVar asw_blind_follow( "asw_blind_follow", "0", FCVAR_NONE, "Set to 1 to give marines short sight range while following (old school alien swarm style)" );
ConVar asw_debug_marine_aim( "asw_debug_marine_aim", "0", FCVAR_CHEAT, "Shows debug info on marine aiming" );
ConVar asw_debug_throw( "asw_debug_throw", "0", FCVAR_CHEAT, "Show node debug info on throw visibility checks" );
ConVar asw_debug_order_weld( "asw_debug_order_weld", "0", FCVAR_DEVELOPMENTONLY, "Debug lines for ordering marines to offhand weld a door" );
extern ConVar ai_lead_time;
#define ASW_MARINE_GOO_SCAN_TIME 0.5f
// offsets and yaws for following formation
const static Vector g_MarineFollowOffset[]=
{
Vector( -60, -70, 0 ),
Vector( -120, 0, 0 ),
Vector( -60, 70, 0 ),
Vector( -40, -80, 0 ),
Vector( -40, -80, 0 ),
Vector( -40, -80, 0 ),
};
const static float g_MarineFollowDirection[]=
{
-70,
180,
70,
90,
90,
90
};
bool CASW_Marine::CreateBehaviors()
{
//AddBehavior( &m_ActBusyBehavior );
//AddBehavior( &m_AssaultBehavior );
//AddBehavior( &m_StandoffBehavior );
return true;
}
// make the view cone
bool CASW_Marine::FInViewCone( const Vector &vecSpot )
{
Vector los = ( vecSpot - EyePosition() );
float flDist = los.NormalizeInPlace();
if ( flDist <= GetCloseCombatSightRange() ) // see 360 up close
return true;
if ( GetASWOrders() == ASW_ORDER_HOLD_POSITION )
{
// otherwise check if this enemy is within our holding cone
Vector holdingDir = vec3_origin;
QAngle holdingAng(0, m_fHoldingYaw, 0);
AngleVectors(holdingAng, &holdingDir);
float flDot = DotProduct( los, holdingDir );
return ( flDot > m_flFieldOfView );
}
else if ( GetASWOrders() == ASW_ORDER_FOLLOW )
{
Vector vecHead = HeadDirection2D();
float flDot = DotProduct( los, vecHead );
return ( flDot > m_flFieldOfView );
}
// see 360 otherwise
return true;
}
float CASW_Marine::GetFollowSightRange()
{
return GetSenses()->GetDistLook();
}
float CASW_Marine::GetCloseCombatSightRange()
{
if (ASWGameRules())
{
switch (ASWGameRules()->GetSkillLevel())
{
case 1: return ASW_CLOSE_COMBAT_SIGHT_RANGE_EASY; break;
case 2: return ASW_CLOSE_COMBAT_SIGHT_RANGE_NORMAL; break;
case 3: return ASW_CLOSE_COMBAT_SIGHT_RANGE_HARD; break;
case 4:
case 5:
default: return ASW_CLOSE_COMBAT_SIGHT_RANGE_INSANE; break;
}
}
return ASW_CLOSE_COMBAT_SIGHT_RANGE_INSANE;
}
bool CASW_Marine::WeaponLOSCondition(const Vector &ownerPos, const Vector &targetPos, bool bSetConditions )
{
if (!BaseClass::WeaponLOSCondition(ownerPos, targetPos, bSetConditions))
return false;
if (!GetSenses())
{
if (bSetConditions)
SetCondition(COND_NOT_FACING_ATTACK);
return false;
}
float flDist = targetPos.DistTo(ownerPos);
// too far away?
if (flDist > GetSenses()->GetDistLook())
{
if (bSetConditions)
SetCondition(COND_TOO_FAR_TO_ATTACK);
return false;
}
if ( flDist < GetCloseCombatSightRange() )
{
return true;
}
Vector vBodyDir = BodyDirection2D( );
float flDot = DotProduct( targetPos - ownerPos, vBodyDir );
// in hold mode, we can shoot if it's in our cone, or if it's very close
if (GetASWOrders() == ASW_ORDER_HOLD_POSITION)
{
if ( flDot > ASW_HOLD_POSITION_FOV_DOT )
{
//if (bSetConditions)
//SetCondition(COND_CAN_RANGE_ATTACK1);
return true;
}
if (bSetConditions)
SetCondition(COND_NOT_FACING_ATTACK);
return false;
}
if ( GetASWOrders() == ASW_ORDER_FOLLOW )
{
if ( flDot < ASW_FOLLOW_MODE_FOV_DOT )
return false;
}
if ( flDist < GetFollowSightRange() ) //&& flDot > 0.5f )
{
//if (bSetConditions)
//SetCondition(COND_CAN_RANGE_ATTACK1);
return true;
}
if (bSetConditions)
SetCondition(COND_TOO_FAR_TO_ATTACK);
return false;
}
/*
int CASW_Marine::RangeAttack1Conditions ( float flDot, float flDist )
{
if (!GetSenses())
return COND_NOT_FACING_ATTACK;
// too far away?
if (flDist > GetSenses()->GetDistLook())
{
return COND_TOO_FAR_TO_ATTACK;
}
// in hold mode, we can shoot if it's in our cone, or if it's very close
if (GetASWOrders() == ASW_ORDER_HOLD_POSITION)
{
if (flDist < GetCloseCombatSightRange())
return COND_CAN_RANGE_ATTACK1;
if (flDot > 0.5f)
return COND_CAN_RANGE_ATTACK1;
else
return COND_NOT_FACING_ATTACK;
}
if (flDist < GetFollowSightRange())
{
Msg("%f in follow mode, alien is within follow range (r=%f fw=%f\n", gpGlobals->curtime, flDist, GetFollowSightRange());
return COND_CAN_RANGE_ATTACK1;
}
Msg("%f in follow mode, alien IS NOT in follow range (r=%f fw=%f\n", gpGlobals->curtime, flDist, GetFollowSightRange());
// must mean we're in follow mode and it's too far away
return COND_TOO_FAR_TO_ATTACK;
}
*/
// ========== ASW Schedule Stuff =========
int CASW_Marine::SelectSchedule()
{
if ( (HasCondition(COND_ENEMY_DEAD) || HasCondition(COND_ENEMY_OCCLUDED) || HasCondition(COND_WEAPON_SIGHT_OCCLUDED))
&& m_fOverkillShootTime > gpGlobals->curtime)
{
return SCHED_ASW_OVERKILL_SHOOT;
}
if (m_bWaitingToRappel && !m_bOnGround)
{
return SCHED_ASW_RAPPEL;
}
if (m_bPreventMovement)
return SCHED_ASW_HOLD_POSITION;
// if we acquire a new enemy, create our aim error offset
if (HasCondition(COND_NEW_ENEMY))
SetNewAimError(GetEnemy());
ClearCondition( COND_ASW_NEW_ORDERS );
if ( HasCondition( COND_PATH_BLOCKED_BY_PHYSICS_PROP ) || HasCondition( COND_COMPLETELY_OUT_OF_AMMO ) )
{
int iMeleeSchedule = SelectMeleeSchedule();
if( iMeleeSchedule != -1 )
return iMeleeSchedule;
}
int iOffhandSchedule = SelectOffhandItemSchedule();
if ( iOffhandSchedule != -1 )
return iOffhandSchedule;
int iHackingSchedule = SelectHackingSchedule();
if ( iHackingSchedule != -1 )
return iHackingSchedule;
if ( m_hUsingEntity.Get() )
return SCHED_ASW_USING_OVER_TIME;
int iHealSchedule = SelectHealSchedule();
if( iHealSchedule != -1)
return iHealSchedule;
if ( HasCondition( COND_SQUADMATE_NEEDS_AMMO ) )
{
int iResupplySchedule = SelectGiveAmmoSchedule();
if ( iResupplySchedule != -1 )
return iResupplySchedule;
}
int iTakeAmmoSchedule = SelectTakeAmmoSchedule();
if ( iTakeAmmoSchedule != -1 )
return iTakeAmmoSchedule;
if ( HasCondition ( COND_SQUADMATE_WANTS_AMMO ) )
{
int iResupplySchedule = SelectGiveAmmoSchedule();
if ( iResupplySchedule != -1 )
return iResupplySchedule;
}
// === following ===
if ( GetASWOrders() == ASW_ORDER_FOLLOW )
{
int iFollowSchedule = SelectFollowSchedule();
if ( iFollowSchedule != -1 )
return iFollowSchedule;
}
if ( GetASWOrders() == ASW_ORDER_MOVE_TO )
{/*
if ( HasCondition(COND_CAN_RANGE_ATTACK1) )
{
//Msg("Marine's select schedule returning SCHED_RANGE_ATTACK1\n");
CBaseEntity* pEnemy = GetEnemy();
if (pEnemy) // don't shoot unless we actually have an enemy
return SCHED_RANGE_ATTACK1;
} */
// if we're already there, hold position
float dist = GetAbsOrigin().DistTo(m_vecMoveToOrderPos);
if ( dist > 30 )
{
return SCHED_ASW_MOVE_TO_ORDER_POS;
}
SetASWOrders(ASW_ORDER_HOLD_POSITION, m_fHoldingYaw);
}
// === holding position ===
if ( HasCondition( COND_CAN_RANGE_ATTACK1 ) )
{
//Msg("Marine's select schedule returning SCHED_RANGE_ATTACK1\n");
CBaseEntity* pEnemy = GetEnemy();
if (pEnemy) // don't shoot unless we actually have an enemy
return SCHED_RANGE_ATTACK1;
}
//Msg("Marine's select schedule returning SCHED_ASW_HOLD_POSITION\n");
return SCHED_ASW_HOLD_POSITION;
}
// translation of schedules
int CASW_Marine::TranslateSchedule( int scheduleType )
{
Assert(scheduleType != SCHED_STANDOFF);
Assert(scheduleType != SCHED_CHASE_ENEMY);
int result = CAI_PlayerAlly::TranslateSchedule(scheduleType);
if (result == SCHED_RANGE_ATTACK1)
result = SCHED_ASW_RANGE_ATTACK1;
return result;
}
//-----------------------------------------------------------------------------
void CASW_Marine::TaskFail( AI_TaskFailureCode_t code )
{
if ( IsCurSchedule( SCHED_ASW_MOVE_TO_ORDER_POS, false ) )
{
// if we failed to reach some ammo to pickup, then don't try to pick it up again for a while
if ( m_hTakeAmmo.Get() )
{
m_hIgnoreAmmo.AddToTail( m_hTakeAmmo );
m_hTakeAmmo = NULL;
m_flResetAmmoIgnoreListTime = gpGlobals->curtime + 15.0f;
}
if ( m_hTakeAmmoDrop.Get() )
{
m_hIgnoreAmmo.AddToTail( m_hTakeAmmoDrop );
m_hTakeAmmoDrop = NULL;
m_flResetAmmoIgnoreListTime = gpGlobals->curtime + 15.0f;
}
// change orders back to hold/follow
m_hAreaToUse = NULL;
if ( m_bWasFollowing )
{
SetASWOrders( ASW_ORDER_FOLLOW );
}
else
{
SetASWOrders( ASW_ORDER_HOLD_POSITION, GetHoldingYaw() );
}
}
else if ( IsCurSchedule( SCHED_MELEE_ATTACK_PROP1, false ) )
{
m_hPhysicsPropTarget = NULL;
}
BaseClass::TaskFail( code );
}
ConVar asw_marine_auto_hack( "asw_marine_auto_hack", "0", FCVAR_CHEAT, "If set to 1, marine will automatically hack nearby computers and button panels" );
#define AUTO_HACK_DIST 768.0f
int CASW_Marine::SelectHackingSchedule()
{
if ( !GetMarineProfile() || GetMarineProfile()->GetMarineClass() != MARINE_CLASS_TECH )
return -1;
if ( asw_marine_auto_hack.GetBool() )
{
CASW_Use_Area *pClosestArea = NULL;
float flClosestDist = FLT_MAX;
// check for a computer hack nearby
for ( int i = 0; i < IASW_Use_Area_List::AutoList().Count(); i++ )
{
CASW_Use_Area *pArea = static_cast< CASW_Use_Area* >( IASW_Use_Area_List::AutoList()[ i ] );
if ( pArea->Classify() == CLASS_ASW_BUTTON_PANEL )
{
CASW_Button_Area *pButton = assert_cast< CASW_Button_Area* >( pArea );
if ( !pButton->IsLocked() || !pButton->HasPower() )
continue;
float flDist = GetAbsOrigin().DistTo( pArea->WorldSpaceCenter() );
if ( flDist < flClosestDist && flDist < AUTO_HACK_DIST )
{
flClosestDist = flDist;
pClosestArea = pArea;
}
}
else if ( pArea->Classify() == CLASS_ASW_COMPUTER_AREA )
{
CASW_Computer_Area *pComputer = assert_cast< CASW_Computer_Area* >( pArea );
if ( pComputer->IsLocked() || ( pComputer->HasDownloadObjective() && pComputer->GetHackProgress() < 1.0f ) )
{
float flDist = GetAbsOrigin().DistTo( pArea->WorldSpaceCenter() );
if ( flDist < flClosestDist && flDist < AUTO_HACK_DIST )
{
flClosestDist = flDist;
pClosestArea = pArea;
}
}
}
}
if ( pClosestArea )
{
m_hAreaToUse = pClosestArea;
}
}
if ( m_hAreaToUse.Get() )
{
if ( m_hAreaToUse->IsUsable( this ) )
{
// notify to kill the effect in a couple of seconds
CASW_Player *pPlayer = GetCommander();
if ( pPlayer && pPlayer->GetMarine() )
{
CSingleUserRecipientFilter user( pPlayer );
UserMessageBegin( user, "ASWOrderStopItemFX" );
WRITE_SHORT( entindex() );
WRITE_BOOL( false );
WRITE_BOOL( false );
MessageEnd();
}
if ( m_hUsingEntity.Get() == m_hAreaToUse.Get() )
{
return SCHED_ASW_USING_OVER_TIME;
}
else
{
return SCHED_ASW_USE_AREA;
}
}
else
{
m_vecMoveToOrderPos = m_hAreaToUse->WorldSpaceCenter(); // TODO: hacking spot marked up in the level?
return SCHED_ASW_MOVE_TO_ORDER_POS;
}
}
return -1;
}
void CASW_Marine::OrderHackArea( CASW_Use_Area *pArea )
{
if ( !pArea )
return;
bool bHackOrdered = false;
if ( pArea->Classify() == CLASS_ASW_BUTTON_PANEL )
{
CASW_Button_Area *pButton = assert_cast< CASW_Button_Area* >( pArea );
if ( !pButton->IsLocked() || !pButton->HasPower() )
return;
float flDist = GetAbsOrigin().DistTo( pArea->WorldSpaceCenter() );
if ( flDist < AUTO_HACK_DIST )
{
m_hAreaToUse = pArea;
bHackOrdered = true;
}
}
else if ( pArea->Classify() == CLASS_ASW_COMPUTER_AREA )
{
CASW_Computer_Area *pComputer = assert_cast< CASW_Computer_Area* >( pArea );
if ( pComputer->IsLocked() || ( pComputer->HasDownloadObjective() && pComputer->GetHackProgress() < 1.0f ) )
{
float flDist = GetAbsOrigin().DistTo( pArea->WorldSpaceCenter() );
if ( flDist < AUTO_HACK_DIST )
{
m_hAreaToUse = pArea;
bHackOrdered = true;
}
}
}
if( bHackOrdered )
{
CASW_Player *pPlayer = GetCommander();
if ( pPlayer && pPlayer->GetMarine() )
{
Vector vecOrigin = pArea->WorldSpaceCenter();
trace_t tr;
// Find where that leg hits the ground
UTIL_TraceLine(vecOrigin, vecOrigin + Vector(0, 0, -60),
MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr);
CSingleUserRecipientFilter user( pPlayer );
UserMessageBegin( user, "ASWOrderUseItemFX" );
WRITE_SHORT( entindex() );
WRITE_SHORT( ASW_USE_ORDER_HACK );
WRITE_SHORT( -1 );
WRITE_FLOAT( tr.endpos.x );
WRITE_FLOAT( tr.endpos.y );
WRITE_FLOAT( tr.endpos.z );
MessageEnd();
}
}
}
int CASW_Marine::SelectTakeAmmoSchedule()
{
if ( !m_hTakeAmmo.Get() && !m_hTakeAmmoDrop.Get() )
{
if ( gpGlobals->curtime < m_flNextAmmoScanTime )
return -1;
m_flNextAmmoScanTime = gpGlobals->curtime + 1.0f;
if ( m_flResetAmmoIgnoreListTime != 0.0f && gpGlobals->curtime > m_flResetAmmoIgnoreListTime )
{
m_hIgnoreAmmo.Purge();
m_flResetAmmoIgnoreListTime = 0.0f;
}
const float flAmmoScanRadiusSqr = 384.0f * 384.0f;
int nAmmoPickupCount = IAmmoPickupAutoList::AutoList().Count();
for ( int i = 0; i < nAmmoPickupCount; i++ )
{
CASW_Ammo *pAmmo = static_cast< CASW_Ammo* >( IAmmoPickupAutoList::AutoList()[ i ] );
EHANDLE hAmmo = pAmmo;
if ( m_hIgnoreAmmo.Find( hAmmo ) != m_hIgnoreAmmo.InvalidIndex() )
continue;
// check ammo is nearby
if ( GetAbsOrigin().DistToSqr( pAmmo->GetAbsOrigin() ) > flAmmoScanRadiusSqr )
continue;
// check we need this ammo
if ( !pAmmo->AllowedToPickup( this ) )
continue;
int nCurrentCount = GetAmmoCount( pAmmo->GetAmmoType() );
// check we don't have more ammo than a human player
bool bHumanNeedsAmmo = false;
for ( int m = 0; m < ASWGameResource()->GetMaxMarineResources(); m++ )
{
CASW_Marine_Resource *pMR = ASWGameResource()->GetMarineResource( m );
if ( !pMR || pMR == GetMarineResource() || !pMR->IsInhabited() || !pMR->GetMarineEntity() )
continue;
if ( !pAmmo->AllowedToPickup( pMR->GetMarineEntity() ) )
continue;
if ( pMR->GetMarineEntity()->GetAmmoCount( pAmmo->GetAmmoType() ) < nCurrentCount )
{
bHumanNeedsAmmo = true;
break;
}
}
if ( bHumanNeedsAmmo )
continue;
m_hTakeAmmo = pAmmo;
m_hTakeAmmoDrop = NULL;
break;
}
// search for ammo satchel drops
if ( !m_hTakeAmmo )
{
int nAmmoDropCount = IAmmoDropAutoList::AutoList().Count();
for( int i = 0; i < nAmmoDropCount; i++ )
{
CASW_Ammo_Drop *pAmmoDrop = static_cast< CASW_Ammo_Drop* >( IAmmoDropAutoList::AutoList()[ i ] );
EHANDLE hAmmoDrop = pAmmoDrop;
EHANDLE hAmmo = pAmmoDrop;
if ( m_hIgnoreAmmo.Find( hAmmoDrop ) != m_hIgnoreAmmo.InvalidIndex() )
continue;
if( GetAbsOrigin().DistToSqr( pAmmoDrop->GetAbsOrigin() ) > flAmmoScanRadiusSqr )
continue;
if( !pAmmoDrop->AllowedToPickup( this ) )
continue;
bool bHumanNeedsAmmo = false;
for( int j = 0; j < ASWGameResource()->GetMaxMarineResources(); j++)
{
CASW_Marine_Resource *pMR = ASWGameResource()->GetMarineResource( j );
if( !pMR || pMR == GetMarineResource() || !pMR->IsInhabited() || !pMR->GetMarineEntity() )
continue;
if( !pAmmoDrop->AllowedToPickup( pMR->GetMarineEntity() ) )
continue;
if ( !pAmmoDrop->NeedsAmmoMoreThan( this, pMR->GetMarineEntity() ) )
{
bHumanNeedsAmmo = true;
break;
}
}
if( bHumanNeedsAmmo )
continue;
m_hTakeAmmoDrop = pAmmoDrop;
break;
}
}
}
EHANDLE hAmmo = ( m_hTakeAmmo.Get() ? m_hTakeAmmo : ( m_hTakeAmmoDrop.Get() ? m_hTakeAmmoDrop : NULL ) );
if ( hAmmo != NULL )
{
SetPoseParameter( "move_x", 1.0f );
SetPoseParameter( "move_y", 0.0f );
// if we're in range of the deploy spot, then use the item
if ( hAmmo->GetAbsOrigin().DistTo( GetAbsOrigin() ) < ASW_MARINE_USE_RADIUS )
{
if( m_hTakeAmmo.Get() )
{
m_hTakeAmmo->ActivateUseIcon( this, ASW_USE_RELEASE_QUICK );
}
else
{
m_hTakeAmmoDrop->ActivateUseIcon( this, ASW_USE_RELEASE_QUICK );
}
m_hTakeAmmo = NULL;
m_hTakeAmmoDrop = NULL;
DoAnimationEvent( PLAYERANIMEVENT_PICKUP );
m_flNextAmmoScanTime = gpGlobals->curtime + 1.0f;
return SCHED_ASW_PICKUP_WAIT;
}
else
{
// move to the ammo
m_vecMoveToOrderPos = hAmmo->GetAbsOrigin();
return SCHED_ASW_MOVE_TO_ORDER_POS;
}
}
return -1;
}
bool CASW_Marine::OnObstructionPreSteer( AILocalMoveGoal_t *pMoveGoal, float distClear, AIMoveResult_t *pResult )
{
SetPhysicsPropTarget( NULL );
if ( pMoveGoal->directTrace.pObstruction )
{
CASW_Prop_Physics *pPropPhysics = dynamic_cast< CASW_Prop_Physics *>( pMoveGoal->directTrace.pObstruction );
if ( pPropPhysics && pPropPhysics->m_takedamage == DAMAGE_YES && pPropPhysics->m_iHealth > 0 )
{
SetPhysicsPropTarget( pPropPhysics );
}
}
return false;
}
void CASW_Marine::GatherConditions()
{
BaseClass::GatherConditions();
ClearCondition( COND_PATH_BLOCKED_BY_PHYSICS_PROP );
ClearCondition( COND_PROP_DESTROYED );
ClearCondition( COND_COMPLETELY_OUT_OF_AMMO );
if( !GetCurSchedule() )
return;
bool bClearTargets = false;
if( GetCurSchedule()->GetId() == GetGlobalScheduleId( SCHED_MELEE_ATTACK_PROP1 ) )
{
if( !GetPhysicsPropTarget() || GetPhysicsPropTarget()->GetHealth() <= 0 )
{
SetCondition( COND_PROP_DESTROYED );
bClearTargets = true;
}
}
else
{
if( GetPhysicsPropTarget() )
{
if( GetPhysicsPropTarget()->GetHealth() > 0 )
{
SetCondition( COND_PATH_BLOCKED_BY_PHYSICS_PROP );
}
else
{
bClearTargets = true;
}
}
}
if( bClearTargets )
{
if( GetEnemy() == GetPhysicsPropTarget() )
{
SetEnemy( NULL );
}
SetPhysicsPropTarget( NULL );
}
int iCurSchedule = GetCurSchedule()->GetId();
bool bRangedAttackSchedule = false;
switch( iCurSchedule )
{
case SCHED_RANGE_ATTACK1:
case SCHED_RANGE_ATTACK2:
case SCHED_SPECIAL_ATTACK1:
case SCHED_SPECIAL_ATTACK2:
{
bRangedAttackSchedule = true;
}
break;
};
if( IsOutOfAmmo() && bRangedAttackSchedule )
{
SetCondition( COND_COMPLETELY_OUT_OF_AMMO );
}
}
void CASW_Marine::BuildScheduleTestBits()
{
// ammo bag functionality needs to interrupt base class behaviors
SetCustomInterruptCondition(COND_SQUADMATE_WANTS_AMMO);
SetCustomInterruptCondition(COND_SQUADMATE_NEEDS_AMMO);
SetCustomInterruptCondition(COND_PATH_BLOCKED_BY_PHYSICS_PROP);
SetCustomInterruptCondition(COND_COMPLETELY_OUT_OF_AMMO);
}
int CASW_Marine::SelectGiveAmmoSchedule()
{
// iterate over all teammates, looking for most needy target for ammo
CASW_Game_Resource *pGameResource = ASWGameResource();
for ( int i=0; i<pGameResource->GetMaxMarineResources(); i++ )
{
CASW_Marine_Resource* pMarineResource = pGameResource->GetMarineResource(i);
if ( !pMarineResource )
continue;
CASW_Marine* pMarine = pMarineResource->GetMarineEntity();
if ( !pMarine || ( pMarine == this ) )
continue;
// see if the current marine can use ammo I have
if ( CanGiveAmmoTo( pMarine ) )
{
// $TODO: find most appropriate give ammo target a la AmmoNeed_t
m_hGiveAmmoTarget = pMarine;
return SCHED_ASW_GIVE_AMMO;
}
}
m_hGiveAmmoTarget = NULL;
return -1;
}
bool CASW_Marine::CanHeal() const
{
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon *pWeapon = GetASWWeapon( iWeapon );
if ( pWeapon && pWeapon->Classify() == CLASS_ASW_HEAL_GUN && pWeapon->HasAmmo() )
{
return true;
}
}
return false;
}
#define MARINE_START_HEAL_THRESHOLD 0.65f
#define MARINE_STOP_HEAL_THRESHOLD 0.85f
int CASW_Marine::SelectHealSchedule()
{
// iterate over all teammates, looking for most needy target for health
CASW_Game_Resource *pGameResource = ASWGameResource();
for ( int i=0; i<pGameResource->GetMaxMarineResources(); i++ )
{
CASW_Marine_Resource* pMarineResource = pGameResource->GetMarineResource(i);
if ( !pMarineResource )
continue;
CASW_Marine* pMarine = pMarineResource->GetMarineEntity();
if ( !pMarine )
continue;
// see if the current marine can use ammo I have
if ( CanHeal() && pMarine->GetHealth() < pMarine->GetMaxHealth() * MARINE_START_HEAL_THRESHOLD )
{
m_hHealTarget = pMarine;
return SCHED_ASW_HEAL_MARINE;
}
}
m_hHealTarget = NULL;
return -1;
}
void CASW_Marine::SetASWOrders(ASW_Orders NewOrders, float fHoldingYaw, const Vector *pOrderPos)
{
Vector vecPos = vec3_origin;
if (pOrderPos)
vecPos = *pOrderPos;
if (m_ASWOrders != NewOrders || m_vecMoveToOrderPos != vecPos
|| (fHoldingYaw != -1 && fHoldingYaw != m_fHoldingYaw))
{
SetCondition( COND_ASW_NEW_ORDERS );
if (NewOrders == ASW_ORDER_HOLD_POSITION)
{
SetDistLook( ASW_HOLD_POSITION_SIGHT_RANGE ); // make marines see further when holding position
m_flFieldOfView = ASW_HOLD_POSITION_FOV_DOT;
}
else
{
m_flFieldOfView = ASW_FOLLOW_MODE_FOV_DOT;
if ( !asw_blind_follow.GetBool() )
{
SetDistLook( ASW_FOLLOW_MODE_SIGHT_RANGE );
SetHeightLook( ASW_FOLLOW_MODE_SIGHT_HEIGHT );
}
else
{
SetDistLook( ASW_DUMB_FOLLOW_MODE_SIGHT_RANGE );
SetHeightLook( ASW_DUMB_FOLLOW_MODE_SIGHT_HEIGHT );
}
}
}
if ( NewOrders != ASW_ORDER_FOLLOW )
{
GetSquadFormation()->Remove(this, true);
m_hMarineFollowTarget = NULL;
}
m_bWasFollowing = ( NewOrders == ASW_ORDER_FOLLOW || ( NewOrders != ASW_ORDER_HOLD_POSITION && m_ASWOrders == ASW_ORDER_FOLLOW ) ); // keeps track of follow vs hold, so we can return to the right orders after completing the new ones
m_ASWOrders = NewOrders;
m_vecMoveToOrderPos = vecPos;
if (fHoldingYaw != -1)
m_fHoldingYaw = fHoldingYaw;
//Msg("Marine receives asw orders: %d\n", NewOrders);
}
void CASW_Marine::OrdersFromPlayer(CASW_Player *pPlayer, ASW_Orders NewOrders, CBaseEntity *pMarine, bool bChatter, float fHoldingYaw, Vector *pVecOrderPos)
{
MDLCACHE_CRITICAL_SECTION();
// asw temp - AI ignore follow orders in SP
//if (gpGlobals->maxClients <= 1 && NewOrders == ASW_ORDER_FOLLOW)
//return;
if (fHoldingYaw == -1)
fHoldingYaw = GetAbsAngles()[YAW];
m_bDoneOrderChatter = false;
SetASWOrders(NewOrders, fHoldingYaw, pVecOrderPos);
if (NewOrders == ASW_ORDER_FOLLOW)
{
if ( pMarine && pMarine->Classify() == CLASS_ASW_MARINE )
{
// Assert( assert_cast<CASW_Marine*>( pMarine )->GetSquadFormation()->Leader() == pMarine );
CASW_Marine *pReallyMarine = assert_cast<CASW_Marine*>( pMarine );
if ( pReallyMarine != GetSquadLeader() )
GetSquadFormation()->ChangeLeader( pReallyMarine );
if ( !GetSquadFormation()->IsValid( GetSquadFormation()->Find(this) ) )
pReallyMarine->GetSquadFormation()->Add( this );
}
else
{
GetSquadFormation()->Remove( this, true );
}
//DoEmote(2); // make them smile on receiving orders
// make sure his move_x/y pose parameters are at full moving forwards, so the AI follow movement will detect some sequence motion when calculating goal speed
SetPoseParameter( "move_x", 1.0f );
SetPoseParameter( "move_y", 0.0f );
if (bChatter && !IsInfested())
GetMarineSpeech()->QueueChatter(CHATTER_USE, gpGlobals->curtime + 0.1f, gpGlobals->curtime + 5.0f);
}
else if (NewOrders == ASW_ORDER_HOLD_POSITION)
{
//m_fHoldingYaw = GetAbsAngles().y;
if (bChatter && !IsInfested() && ( GetFlags() & FL_ONGROUND ) && !m_hUsingEntity.Get())
GetMarineSpeech()->QueueChatter(CHATTER_HOLDING_POSITION, gpGlobals->curtime + 0.1f, gpGlobals->curtime + 5.0f);
}
else if (NewOrders == ASW_ORDER_MOVE_TO && pVecOrderPos != NULL)
{
//DoEmote(2); // make them smile on receiving orders
// make sure his move_x/y pose parameters are at full moving fowards, so the AI follow movement will detect some sequence motion when calculating goal speed
SetPoseParameter( "move_x", 1.0f );
SetPoseParameter( "move_y", 0.0f );
//Msg("Recieived orders to move to %f %f %f\n",
//pVecOrderPos[0], pVecOrderPos[1], pVecOrderPos[2]);
//m_vecMoveToOrderPos = *pVecOrderPos;
//Msg("m_vecMoveToOrderPos= %f %f %f\n",
// m_vecMoveToOrderPos[0], m_vecMoveToOrderPos[1], m_vecMoveToOrderPos[2]);
}
m_fCachedIdealSpeed = MaxSpeed();
}
static void DebugWaypoint( AI_Waypoint_t * pWay, int r, int g, int b, float flDuration = 3 )
{
if ( pWay && pWay->GetNext() )
{
NDebugOverlay::Line( pWay->GetPos(), pWay->GetNext()->GetPos(), r, g, b, true, 3 );
return DebugWaypoint( pWay->GetNext(), r, g, b, flDuration );
}
}
/// because AI_Waypoint_t::flPathDistGoal is broken
static float GetWaypointDistToEnd( const Vector &vStartPos, AI_Waypoint_t *way )
{
if ( !way ) return FLT_MAX;
float ret = way->GetPos().DistTo(vStartPos);
while ( way->GetNext() )
{
ret += way->GetNext()->GetPos().DistTo( way->GetPos() );
way = way->GetNext();
}
return ret;
}
/// When a marine uses an offhand item, sometimes you need to pick a different
/// location for its use than exactly where the cursor was. And sometimes
/// you need to kibosh the use altogether. Returns true if the offhand use
/// should continue, false means it should be aborted
static bool AdjustOffhandItemDestination( CASW_Marine *pMarine, CASW_Weapon *pWeapon, const Vector &vecDestIn, Vector * RESTRICT vecDestOut )
{
// NDebugOverlay::Cross3D( vecDestIn, 16, 255, 16, 16, true, 3 );
if ( pWeapon->Classify() == CLASS_ASW_WELDER )
{
// find a door near the given position
CASW_Door_Area *pClosestArea = NULL;
CASW_Door * RESTRICT pDoor = NULL;
float flClosestDist = FLT_MAX;
for ( int i = 0; i < IASW_Use_Area_List::AutoList().Count(); i++ )
{
CASW_Use_Area *pArea = static_cast< CASW_Use_Area* >( IASW_Use_Area_List::AutoList()[ i ] );
if ( pArea->Classify() == CLASS_ASW_DOOR_AREA )
{
CASW_Door_Area *pDoorArea = assert_cast<CASW_Door_Area*>( pArea );
float flDist = (vecDestIn - pArea->WorldSpaceCenter()).Length2D( );
if ( flDist < flClosestDist && flDist < 240 )
{
flClosestDist = flDist;
pClosestArea = pDoorArea;
}
}
}
if ( !pClosestArea )
{
return false;
}
pDoor = pClosestArea->GetASWDoor();
if ( !pDoor )
{
AssertMsg( false, "Door area is missing its door!\n" );
return false;
}
if ( asw_debug_order_weld.GetBool() ) NDebugOverlay::EntityBounds( pDoor, 0, 0, 255, 64, 3 );
// pick a point to either side of the door and build routes to them
Vector vStandPoints[2];
float fkickout = pMarine->BoundingRadius() * 1.1f;
float flTolerance = pMarine->BoundingRadius() * 1.1f;
// get the door's transform, and punch its saved "closed position" into the translate row
if ( true )
{
matrix3x4_t mat = pDoor->EntityToWorldTransform();
mat.SetOrigin( pDoor->GetClosedPosition() );
VectorTransform( Vector(fkickout,0,0), mat, vStandPoints[0] );
VectorTransform( Vector(-fkickout,0,0), mat, vStandPoints[1] );
}
else
{
pDoor->EntityToWorldSpace( Vector(fkickout,0,0), vStandPoints + 0 ); // forward
pDoor->EntityToWorldSpace( Vector(-fkickout,0,0), vStandPoints + 1 );
}
CAI_Pathfinder *pathfinder = pMarine->GetPathfinder();
AI_Waypoint_t *routeFwd =
pathfinder->BuildRoute( pMarine->GetAbsOrigin(), vStandPoints[0],
NULL, flTolerance, NAV_GROUND, bits_BUILD_GET_CLOSE );
AI_Waypoint_t *routeBack =
pathfinder->BuildRoute( pMarine->GetAbsOrigin(), vStandPoints[1],
NULL, flTolerance, NAV_GROUND, bits_BUILD_GET_CLOSE );
if ( asw_debug_order_weld.GetBool() )
{
if ( routeFwd )
{
NDebugOverlay::Circle( vStandPoints[0], QAngle(90, 0, 0), 24, 0, 128, 255, 255, true, 3 );
}
else
{
NDebugOverlay::Circle( vStandPoints[0], QAngle(90, 0, 0), 24, 255, 0, 0, 255, true, 3 );
}
if ( routeBack )
{
NDebugOverlay::Circle( vStandPoints[1], QAngle(90, 0, 0), 24, 0, 255, 128, 255, true, 3 );
}
else
{
NDebugOverlay::Circle( vStandPoints[1], QAngle(90, 0, 0), 24, 255, 0, 0, 255, true, 3 );
}
}
if ( !routeBack && !routeFwd )
{
delete routeFwd;
delete routeBack;
return false;
}
CASW_Marine *pLeader = static_cast< CASW_Marine* >( pMarine->GetSquadLeader() );
float flDists[2];
flDists[0] = routeFwd ? GetWaypointDistToEnd( pMarine->GetAbsOrigin(), routeFwd ) : FLT_MAX;
flDists[1] = routeBack ? GetWaypointDistToEnd( pMarine->GetAbsOrigin(), routeBack ) : FLT_MAX;
bool bUseForwardRoute = ( routeFwd && ( !routeBack || flDists[0] < flDists[1] ) );
if ( pLeader )
{
// move to whichever one is closer to our follow leader
CAI_Pathfinder *pathfinder = pLeader->GetPathfinder();
CPlainAutoPtr<AI_Waypoint_t> leaderRouteFwd(
pathfinder->BuildRoute( pLeader->GetAbsOrigin(), vStandPoints[0],
NULL, flTolerance, NAV_GROUND, bits_BUILD_GET_CLOSE ) );
CPlainAutoPtr<AI_Waypoint_t> leaderRouteBack(
pathfinder->BuildRoute( pLeader->GetAbsOrigin(), vStandPoints[1],
NULL, flTolerance, NAV_GROUND, bits_BUILD_GET_CLOSE ) );
float flLeaderDists[2];
flLeaderDists[0] = leaderRouteFwd.IsValid() ? GetWaypointDistToEnd( pLeader->GetAbsOrigin(), leaderRouteFwd.Get() ) : FLT_MAX;
flLeaderDists[1] = leaderRouteBack.IsValid() ? GetWaypointDistToEnd( pLeader->GetAbsOrigin(), leaderRouteBack.Get()) : FLT_MAX;
if ( leaderRouteFwd.IsValid() || leaderRouteBack.IsValid() )
{
bool bLeaderUseForwardRoute = ( leaderRouteFwd.IsValid() && ( !leaderRouteBack.IsValid() || flLeaderDists[0] < flLeaderDists[1] ) );
if ( bLeaderUseForwardRoute != bUseForwardRoute )
{
// leader is on an opposite side to the marine, push the point forward a bit more so marine clears the doorway he's running through
matrix3x4_t mat = pDoor->EntityToWorldTransform();
mat.SetOrigin( pDoor->GetClosedPosition() );
float fkickout = pMarine->BoundingRadius() * 2.2f;
VectorTransform( Vector(fkickout,0,0), mat, vStandPoints[0] );
VectorTransform( Vector(-fkickout,0,0), mat, vStandPoints[1] );
delete routeFwd;
delete routeBack;
routeFwd =
pathfinder->BuildRoute( pMarine->GetAbsOrigin(), vStandPoints[0],
NULL, flTolerance, NAV_GROUND, bits_BUILD_GET_CLOSE );
routeBack =
pathfinder->BuildRoute( pMarine->GetAbsOrigin(), vStandPoints[1],
NULL, flTolerance, NAV_GROUND, bits_BUILD_GET_CLOSE );
if ( !routeBack && !routeFwd )
{
delete routeFwd;
delete routeBack;
return false;
}
flDists[0] = routeFwd ? GetWaypointDistToEnd( pMarine->GetAbsOrigin(), routeFwd ) : FLT_MAX;
flDists[1] = routeBack ? GetWaypointDistToEnd( pMarine->GetAbsOrigin(), routeBack ) : FLT_MAX;
if ( ( bLeaderUseForwardRoute && routeFwd ) || ( !bLeaderUseForwardRoute && routeBack ) )
{
bUseForwardRoute = bLeaderUseForwardRoute;
}
}
}
}
// pick the shorter (or only existing) route
if ( bUseForwardRoute )
{
*vecDestOut = routeFwd->GetLast()->GetPos(); // vStandPoints[0];
if ( asw_debug_order_weld.GetBool() )
{
DebugWaypoint( routeFwd, 255, 255, 0 );
if ( routeBack )
{
Msg( "%.3f < %.3f\n", flDists[0], flDists[1] );
DebugWaypoint( routeBack, 0, 255, 0 );
}
}
}
else
{
*vecDestOut = routeBack->GetLast()->GetPos(); // vStandPoints[1];
if ( asw_debug_order_weld.GetBool() )
{
DebugWaypoint( routeBack, 255, 255, 0 );
if ( routeFwd )
{
Msg( "%.3f < %.3f\n", flDists[1], flDists[0] );
DebugWaypoint( routeFwd, 0, 255, 0 );
}
}
}
delete routeFwd;
delete routeBack;
return true;
}
else
{
// do nothing, just copy through
*vecDestOut = vecDestIn;
return true;
}
}
void CASW_Marine::OrderUseOffhandItem( int iInventorySlot, const Vector &vecDest )
{
// check we have an item in that slot
CASW_Weapon* pWeapon = GetASWWeapon( iInventorySlot );
if ( !pWeapon || !pWeapon->GetWeaponInfo() || !pWeapon->GetWeaponInfo()->m_bOffhandActivate )
return;
// m_vecOffhandItemSpot = vecDest;
if ( !AdjustOffhandItemDestination( this, pWeapon, vecDest, &m_vecOffhandItemSpot) )
return;
else if ( asw_debug_order_weld.GetBool() )
{
NDebugOverlay::Cross( m_vecOffhandItemSpot, 12.0f, 255, 0, 0, true, 3 );
}
if ( pWeapon->GetWeaponInfo()->m_nOffhandOrderType == ASW_OFFHAND_USE_IMMEDIATELY )
{
pWeapon->OffhandActivate();
return;
}
CASW_Player *pPlayer = GetCommander();
if ( pPlayer )
{
//DispatchParticleEffect( "marine_hit_blood_ff", vecDest, QAngle( 0, 0, 0 ) );
// Tell the player's client that he's been hurt.
CSingleUserRecipientFilter user( pPlayer );
UserMessageBegin( user, "ASWOrderUseItemFX" );
WRITE_SHORT( entindex() );
WRITE_SHORT( ASW_USE_ORDER_WITH_ITEM );
WRITE_SHORT( iInventorySlot );
WRITE_FLOAT( m_vecOffhandItemSpot.x );
WRITE_FLOAT( m_vecOffhandItemSpot.y );
WRITE_FLOAT( m_vecOffhandItemSpot.z );
MessageEnd();
}
m_ASWOrders = ASW_ORDER_USE_OFFHAND_ITEM;
m_hOffhandItemToUse = pWeapon;
SetCondition( COND_ASW_NEW_ORDERS );
}
#define ASW_DEPLOY_RANGE 75.0f
int CASW_Marine::SelectOffhandItemSchedule()
{
if ( m_bWaitingForWeld )
{
if( gpGlobals->curtime > m_flBeginWeldTime + 5.0f )
{
FinishedUsingOffhandItem( false );
return SCHED_ASW_FOLLOW_WAIT;
}
return SCHED_ASW_FOLLOW_WAIT;
}
if ( GetASWOrders() != ASW_ORDER_USE_OFFHAND_ITEM )
return -1;
if ( !m_hOffhandItemToUse.Get() )
return -1;
const CASW_WeaponInfo *pInfo = m_hOffhandItemToUse->GetWeaponInfo();
if ( !pInfo )
return -1;
SetPoseParameter( "move_x", 1.0f );
SetPoseParameter( "move_y", 0.0f );
if ( pInfo->m_nOffhandOrderType == ASW_OFFHAND_DEPLOY )
{
// if we're in range of the deploy spot, then use the item
if ( ( m_vecOffhandItemSpot - GetAbsOrigin() ).Length2D() < ASW_DEPLOY_RANGE )
{
m_hOffhandItemToUse->OffhandActivate();
FinishedUsingOffhandItem( false );
if ( m_bWaitingForWeld )
{
return SCHED_ASW_FOLLOW_WAIT;
}
}
else
{
// otherwise, move to just in front of the deploy spot
Vector dir = GetAbsOrigin() - m_vecOffhandItemSpot;
dir.z = 0;
dir.NormalizeInPlace();
m_vecMoveToOrderPos = m_vecOffhandItemSpot + dir * 50.0f;
return SCHED_ASW_MOVE_TO_ORDER_POS;
}
}
else
{
// if we have line of sight to the target spot
if ( CanThrowOffhand( m_hOffhandItemToUse, GetOffhandThrowSource(), m_vecOffhandItemSpot, asw_debug_throw.GetInt() == 3 ) )
{
m_hOffhandItemToUse->OffhandActivate();
FinishedUsingOffhandItem( true );
}
else
{
const float MIN_THROW_RANGE = 50.0f;
const float MAX_THROW_RANGE = 700.0f;
Vector pos;
int iNode = FindThrowNode( m_vecOffhandItemSpot, MIN_THROW_RANGE, MAX_THROW_RANGE, 1.0f );
if ( iNode != NO_NODE )
{
// move to the spot with line of sight
m_vecMoveToOrderPos = g_pBigAINet->GetNode(iNode)->GetPosition(GetHullType());
return SCHED_ASW_MOVE_TO_ORDER_POS;
}
else
{
// abort
Msg( "Failed to find throw node\n" );
FinishedUsingOffhandItem( true, true );
}
}
}
return -1;
}
void CASW_Marine::FinishedUsingOffhandItem( bool bItemThrown, bool bFailed )
{
// go back to following our commander's marine
CASW_Player *pPlayer = GetCommander();
if ( pPlayer && pPlayer->GetMarine() )
{
OrdersFromPlayer( pPlayer, ASW_ORDER_FOLLOW, pPlayer->GetMarine(), true );
CSingleUserRecipientFilter user( pPlayer );
UserMessageBegin( user, "ASWOrderStopItemFX" );
WRITE_SHORT( entindex() );
WRITE_BOOL( bItemThrown );
WRITE_BOOL( bFailed );
MessageEnd();
}
else
{
OrdersFromPlayer( NULL, ASW_ORDER_HOLD_POSITION, this, true, GetLocalAngles().y);
}
}
// checks if our thrown offhand item will reach the destination
bool CASW_Marine::CanThrowOffhand( CASW_Weapon *pWeapon, const Vector &vecSrc, const Vector &vecDest, bool bDrawArc )
{
if ( !pWeapon )
return false;
Vector vecVelocity = UTIL_LaunchVector( vecSrc, vecDest, pWeapon->GetThrowGravity() ) * 28.0f;
Vector vecResult = UTIL_Check_Throw( vecSrc, vecVelocity, pWeapon->GetThrowGravity(),
-Vector( 12,12,12 ), Vector( 12,12,12 ), MASK_NPCSOLID, COLLISION_GROUP_PROJECTILE, this, bDrawArc );
float flDist = vecResult.DistTo( vecDest );
return ( flDist < 50.0f );
}
int CASW_Marine::FindThrowNode( const Vector &vThreatPos, float flMinThreatDist, float flMaxThreatDist, float flBlockTime )
{
if ( !CAI_NetworkManager::NetworksLoaded() )
return NO_NODE;
AI_PROFILE_SCOPE( CASW_Marine::FindThrowNode );
Remember( bits_MEMORY_TASK_EXPENSIVE );
int iMyNode = GetPathfinder()->NearestNodeToNPC();
if ( iMyNode == NO_NODE )
{
Vector pos = GetAbsOrigin();
DevWarning( 2, "FindThrowNode() - %s has no nearest node! (Check near %f %f %f)\n", GetClassname(), pos.x, pos.y, pos.z);
return NO_NODE;
}
// ------------------------------------------------------------------------------------
// We're going to search for a shoot node by expanding to our current node's neighbors
// and then their neighbors, until a shooting position is found, or all nodes are beyond MaxDist
// ------------------------------------------------------------------------------------
AI_NearNode_t *pBuffer = (AI_NearNode_t *)stackalloc( sizeof(AI_NearNode_t) * g_pBigAINet->NumNodes() );
CNodeList list( pBuffer, g_pBigAINet->NumNodes() );
CVarBitVec wasVisited(g_pBigAINet->NumNodes()); // Nodes visited
// mark start as visited
wasVisited.Set( iMyNode );
list.Insert( AI_NearNode_t(iMyNode, 0) );
static int nSearchRandomizer = 0; // tries to ensure the links are searched in a different order each time;
while ( list.Count() )
{
int nodeIndex = list.ElementAtHead().nodeIndex;
// remove this item from the list
list.RemoveAtHead();
const Vector &nodeOrigin = g_pBigAINet->GetNode(nodeIndex)->GetPosition(GetHullType());
// HACKHACK: Can't we rework this loop and get rid of this?
// skip the starting node, or we probably wouldn't have called this function.
if ( nodeIndex != iMyNode )
{
bool skip = false;
// Don't accept climb nodes, and assume my nearest node isn't valid because
// we decided to make this check in the first place. Keep moving
if ( !skip && !g_pBigAINet->GetNode(nodeIndex)->IsLocked() &&
g_pBigAINet->GetNode(nodeIndex)->GetType() != NODE_CLIMB )
{
// Now check its distance and only accept if in range
float flThreatDist = ( nodeOrigin - vThreatPos ).Length();
if ( flThreatDist < flMaxThreatDist &&
flThreatDist > flMinThreatDist )
{
//CAI_Node *pNode = g_pBigAINet->GetNode(nodeIndex);
if ( CanThrowOffhand( m_hOffhandItemToUse.Get(), GetOffhandThrowSource( &nodeOrigin ), vThreatPos, asw_debug_throw.GetInt() == 2 ) )
{
// Note when this node was used, so we don't try
// to use it again right away.
g_pBigAINet->GetNode(nodeIndex)->Lock( flBlockTime );
if ( asw_debug_throw.GetBool() )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:los", nodeIndex), false, 1 );
// draw the arc
CanThrowOffhand( m_hOffhandItemToUse.Get(), GetOffhandThrowSource( &nodeOrigin ), vThreatPos, true );
}
// The next NPC who searches should use a slight different pattern
nSearchRandomizer = nodeIndex;
return nodeIndex;
}
else
{
if ( asw_debug_throw.GetBool() )
{
NDebugOverlay::Text( nodeOrigin, CFmtStr( "%d:!throw", nodeIndex), false, 1 );
}
}
}
else
{
if ( asw_debug_throw.GetBool() )
{
CFmtStr msg( "%d:%s", nodeIndex, ( flThreatDist < flMaxThreatDist ) ? "too close" : "too far" );
NDebugOverlay::Text( nodeOrigin, msg, false, 1 );
}
}
}
}
// Go through each link and add connected nodes to the list
for (int link=0; link < g_pBigAINet->GetNode(nodeIndex)->NumLinks();link++)
{
int index = (link + nSearchRandomizer) % g_pBigAINet->GetNode(nodeIndex)->NumLinks();
CAI_Link *nodeLink = g_pBigAINet->GetNode(nodeIndex)->GetLinkByIndex(index);
if ( !GetPathfinder()->IsLinkUsable( nodeLink, iMyNode ) )
continue;
int newID = nodeLink->DestNodeID(nodeIndex);
// If not already visited, add to the list
if (!wasVisited.IsBitSet(newID))
{
float dist = (GetLocalOrigin() - g_pBigAINet->GetNode(newID)->GetPosition(GetHullType())).LengthSqr();
list.Insert( AI_NearNode_t(newID, dist) );
wasVisited.Set( newID );
}
}
}
// We failed. No range attack node node was found
return NO_NODE;
}
// custom follow stuff
#define ASW_FOLLOW_DISTANCE 230
#define ASW_FOLLOW_DISTANCE_NO_LOS 100
#define ASW_FORMATION_FOLLOW_DISTANCE 40
bool CASW_Marine::NeedToUpdateSquad()
{
// basically, if I am a leader and I've moved, an update is needed.
return ( GetSquadLeader() == this && GetSquadFormation()->ShouldUpdateFollowPositions() );
}
bool CASW_Marine::NeedToFollowMove()
{
CASW_Marine * RESTRICT pLeader = GetSquadLeader();
if ( !pLeader || pLeader == this )
return false;
if( IsOutOfAmmo() && GetEnemy() )
return false;
// only move if we're not near our saved follow point
float dist = ( GetAbsOrigin() - GetFollowPos() ).Length2DSqr();
return dist > ( ASW_FORMATION_FOLLOW_DISTANCE * ASW_FORMATION_FOLLOW_DISTANCE );
}
static bool ValidMarineMeleeTarget( CBaseEntity *pEnt )
{
if ( !pEnt )
return false;
// don't punch big scary aliens
Class_T entClass = pEnt->Classify();
if ( entClass == CLASS_ASW_BOOMER || entClass == CLASS_ASW_SHIELDBUG ||
entClass == CLASS_ASW_HARVESTER || entClass == CLASS_ASW_MORTAR_BUG )
return false;
return true;
}
int CASW_Marine::SelectMeleeSchedule()
{
if( GetPhysicsPropTarget() )
{
SetEnemy( GetPhysicsPropTarget() );
return SCHED_MELEE_ATTACK_PROP1;
}
else if( GetEnemy() )
{
bool bLastManStanding = true;
CASW_Game_Resource *pGameResource = ASWGameResource();
for ( int i = 0; i < pGameResource->GetMaxMarineResources(); i++ )
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pMarine = pMR ? pMR->GetMarineEntity() : NULL;
if( pMarine && pMarine != this && pMarine->GetHealth() > 0 )
{
bLastManStanding = false;
break;
}
}
if( GetHealth() > GetMaxHealth() * 0.5f || bLastManStanding || GetAbsOrigin().DistToSqr( GetEnemyLKP() ) < Square( 100.0f ) )
{
if ( ValidMarineMeleeTarget( GetEnemy() ) )
{
return SCHED_ENGAGE_AND_MELEE_ATTACK1;
}
}
}
return -1;
}
ConVar asw_follow_slow_distance( "asw_follow_slow_distance", "1200.0f", FCVAR_CHEAT, "Marines will follow their leader slowly during combat if he's within this distance" );
int CASW_Marine::SelectFollowSchedule()
{
// if we don't have anyone to follow, revert to holding position orders
if ( !GetSquadLeader() && ASWGameRules() && gpGlobals->curtime > ASWGameRules()->m_fMissionStartedTime + 4.0f )
{
SetASWOrders(ASW_ORDER_HOLD_POSITION, GetAbsAngles()[YAW], &GetAbsOrigin());
return SCHED_ASW_HOLD_POSITION;
}
if (NeedToFollowMove())
{
return SCHED_ASW_FOLLOW_MOVE;
}
// shoot if we need to
if ( HasCondition(COND_CAN_RANGE_ATTACK1) )
{
//Msg("Marine's select schedule returning SCHED_RANGE_ATTACK1\n");
CBaseEntity* pEnemy = GetEnemy();
if (pEnemy) // don't shoot unless we actually have an enemy
return SCHED_RANGE_ATTACK1;
}
if( IsOutOfAmmo() && GetEnemy() )
{
SetCondition( COND_COMPLETELY_OUT_OF_AMMO );
int iMeleeSchedule = SelectMeleeSchedule();
if( iMeleeSchedule != -1 )
return iMeleeSchedule;
}
// check if we're too near another marine
//CASW_Marine *pCloseMarine = TooCloseToAnotherMarine();
//if (pCloseMarine)
//{
//Msg("marine is too close to %d\n", pCloseMarine->entindex());
//return SCHED_ASW_FOLLOW_BACK_OFF;
//}
return SCHED_ASW_FOLLOW_WAIT;
}
#define ASW_MARINE_TOO_CLOSE 40
CASW_Marine* CASW_Marine::TooCloseToAnotherMarine()
{
if ( !ASWGameResource() )
return NULL;
CASW_Game_Resource *pGameResource = ASWGameResource();
for (int i=0;i<pGameResource->GetMaxMarineResources();i++)
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
if (!pMR)
continue;
CASW_Marine *pMarine = pMR->GetMarineEntity();
if (!pMarine || pMarine == this)
continue;
float dist = pMarine->GetAbsOrigin().DistTo(GetAbsOrigin());
if ( dist < ASW_MARINE_TOO_CLOSE)
{
Msg("marine %d is %f away\n", i, dist);
return pMarine;
}
}
return NULL;
}
void CASW_Marine::StartTask(const Task_t *pTask)
{
switch (pTask->iTask)
{
case TASK_ASW_ORDER_TO_DEPLOY_SPOT:
{
CASW_Bloodhound *pDropship = dynamic_cast<CASW_Bloodhound*>(gEntList.FindEntityByClassname( NULL, "asw_bloodhound" ));
if (pDropship)
pDropship->MarineLanded(this);
TaskComplete();
break;
}
case TASK_ASW_FACE_HOLDING_YAW:
case TASK_ASW_FACE_USING_ITEM:
{
SetWait( pTask->flTaskData );
SetIdealActivity( ACT_IDLE );
break;
}
case TASK_ASW_START_USING_AREA:
{
if ( m_hAreaToUse.Get() && m_hAreaToUse->IsUsable( this ) )
{
m_hAreaToUse->ActivateUseIcon( this, ASW_USE_RELEASE_QUICK );
}
TaskComplete();
break;
}
case TASK_ASW_CHATTER_CONFIRM:
{
if (!m_bDoneOrderChatter)
{
m_bDoneOrderChatter = true;
if (!IsInfested() && random->RandomFloat() <= pTask->flTaskData)
GetMarineSpeech()->QueueChatter(CHATTER_USE, gpGlobals->curtime + 0.1f, gpGlobals->curtime + 5.0f, GetCommander());
}
TaskComplete();
break;
}
case TASK_ASW_FACE_FOLLOW_WAIT:
{
SetWait( pTask->flTaskData );
break;
}
case TASK_ASW_FACE_ENEMY_WITH_ERROR:
{
break;
}
case TASK_ASW_OVERKILL_SHOOT:
{
m_fStartedFiringTime = gpGlobals->curtime;
break;
}
case TASK_ASW_GET_PATH_TO_ORDER_POS:
{
//NDebugOverlay::Line( GetAbsOrigin(), m_vecMoveToOrderPos, 255, 0, 0, true, 4.0f );
float flTolerance = AIN_HULL_TOLERANCE;
if ( m_vecMoveToOrderPos == m_vecOffhandItemSpot )
{
flTolerance = 100.0f;
}
AI_NavGoal_t goal(m_vecMoveToOrderPos, ACT_RUN, flTolerance);
GetNavigator()->SetGoal( goal );
TaskComplete();
break;
}
case TASK_ASW_GET_PATH_TO_FOLLOW_TARGET:
{
if ( !GetSquadLeader() )
TaskFail("No follow target");
else
{
AI_NavGoal_t goal( GetFollowPos(), ACT_RUN, 60 ); // AIN_HULL_TOLERANCE
GetNavigator()->SetGoal( goal );
TaskComplete();
}
}
break;
case TASK_ASW_GET_PATH_TO_PROP:
{
if ( !GetPhysicsPropTarget() )
TaskFail("No prop");
else
{
AI_NavGoal_t goal( GetPhysicsPropTarget()->WorldSpaceCenter(), ACT_RUN, 60 ); // AIN_HULL_TOLERANCE
GetNavigator()->SetGoal( goal );
TaskComplete();
}
}
break;
case TASK_ASW_WAIT_FOR_FOLLOW_MOVEMENT:
case TASK_ASW_WAIT_FOR_MOVEMENT:
{
if (GetNavigator()->GetGoalType() == GOALTYPE_NONE)
{
TaskComplete();
GetNavigator()->ClearGoal(); // Clear residual state
}
else if (!GetNavigator()->IsGoalActive())
{
SetIdealActivity( GetStoppedActivity() );
}
else
{
// Check validity of goal type
ValidateNavGoal();
}
break;
}
case TASK_ASW_GET_BACK_OFF_PATH:
{
CASW_Marine *pCloseMarine = TooCloseToAnotherMarine();
if (!pCloseMarine)
TaskFail("No marine too close");
else
{
Vector diff = GetAbsOrigin() - pCloseMarine->GetAbsOrigin();
Vector diffnorm = diff;
VectorNormalize(diffnorm);
Vector vecGoalPos = GetAbsOrigin() + diffnorm * 60; // move to x units away from this marine
AI_NavGoal_t goal(vecGoalPos, ACT_RUN, AIN_HULL_TOLERANCE);
GetNavigator()->SetGoal( goal );
TaskComplete();
}
}
break;
case TASK_MOVE_AWAY_PATH:
GetMotor()->SetIdealYaw( UTIL_AngleMod( GetLocalAngles().y - 180.0f ) );
BaseClass::StartTask( pTask );
break;
case TASK_ASW_RAPPEL:
{
CreateZipline();
SetDescentSpeed();
}
break;
case TASK_ASW_HIT_GROUND:
m_bOnGround = true;
TaskComplete();
break;
case TASK_ASW_GET_PATH_TO_GIVE_AMMO:
if (!m_hGiveAmmoTarget)
{
TaskComplete();
}
break;
case TASK_ASW_MOVE_TO_GIVE_AMMO:
if (!m_hGiveAmmoTarget)
{
TaskComplete();
}
break;
case TASK_ASW_SWAP_TO_AMMO_BAG:
{
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if ( !pWeapon || pWeapon->Classify() != CLASS_ASW_AMMO_BAG )
{
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon *pWeapon = GetASWWeapon( iWeapon );
if ( pWeapon && pWeapon->Classify() == CLASS_ASW_AMMO_BAG )
{
Weapon_Switch( pWeapon );
break;
}
}
}
TaskComplete();
}
break;
case TASK_ASW_GIVE_AMMO_TO_MARINE:
if (m_hGiveAmmoTarget)
{
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if ( pWeapon && pWeapon->Classify() == CLASS_ASW_AMMO_BAG )
{
CASW_Weapon_Ammo_Bag *pAmmoBag = dynamic_cast<CASW_Weapon_Ammo_Bag*>(pWeapon);
pAmmoBag->ThrowAmmo();
}
}
TaskComplete();
break;
case TASK_MELEE_ATTACK1:
{
if( !GetEnemy() )
{
TaskFail("No enemy!");
}
else if ( GetAbsOrigin().DistToSqr( GetEnemy()->GetAbsOrigin() ) > Square( 100.0f ) )
{
if ( GetEnemy() == GetPhysicsPropTarget() )
{
SetPhysicsPropTarget( NULL );
}
TaskFail("Melee target too far!");
}
else
{
DoAnimationEvent( (PlayerAnimEvent_t) ( PLAYERANIMEVENT_MELEE + ( int ) pTask->flTaskData ) ); // send anim event to clients
BaseClass::StartTask(pTask);
}
}
break;
case TASK_ASW_GET_PATH_TO_HEAL:
{
if( !m_hHealTarget )
{
TaskFail( FAIL_NO_GOAL );
}
}
break;
case TASK_ASW_MOVE_TO_HEAL:
{
if( !m_hHealTarget )
{
TaskFail( FAIL_NO_GOAL );
}
}
break;
case TASK_ASW_SWAP_TO_HEAL_GUN:
{
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if( !pWeapon || pWeapon->Classify() != CLASS_ASW_HEAL_GUN )
{
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon *pWeapon = GetASWWeapon( iWeapon );
if ( pWeapon && pWeapon->Classify() == CLASS_ASW_HEAL_GUN && pWeapon->HasAmmo() )
{
Weapon_Switch( pWeapon );
break;
}
}
}
TaskComplete();
}
break;
case TASK_ASW_HEAL_MARINE:
{
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if( !pWeapon || pWeapon->Classify() != CLASS_ASW_HEAL_GUN || !pWeapon->HasAmmo() )
{
TaskComplete();
}
else
{
CASW_Weapon_Heal_Gun *pHealgun = static_cast<CASW_Weapon_Heal_Gun*>( pWeapon );
// if the gun to longer has a target...
if ( !pHealgun || !m_hHealTarget ||
m_hHealTarget->GetHealth() <= 0 ||
m_hHealTarget->GetHealth() >= m_hHealTarget->GetMaxHealth() * MARINE_STOP_HEAL_THRESHOLD ||
m_hHealTarget->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) >= Square( CASW_Weapon_Heal_Gun::GetWeaponRange()*0.5 ) )
{
TaskComplete();
}
else
{
bool bHealFailed = false;
// facing another direction
Vector vecAttach = m_hHealTarget->GetAbsOrigin() - GetAbsOrigin();
Vector vecForward;
AngleVectors( ASWEyeAngles(), &vecForward );
if ( DotProduct( vecForward, vecAttach ) < 0.0f )
{
TaskComplete();
bHealFailed = true;
}
if ( !bHealFailed )
pHealgun->HealAttach( m_hHealTarget );
}
}
}
break;
default:
{
return BaseClass::StartTask(pTask);
break;
}
}
}
CBaseEntity *CASW_Marine::BestAlienGooTarget()
{
CASW_Alien_Goo *pAlienGooTarget = NULL;
float flClosestDistSqr = GetFollowSightRange() * GetFollowSightRange();
for ( int iAlienGoo = 0; iAlienGoo < g_AlienGoo.Count(); iAlienGoo++ )
{
// Get the instance of alien goo - if it exists.
CASW_Alien_Goo *pAlienGoo = g_AlienGoo[iAlienGoo];
if ( !pAlienGoo )
continue;
float flDistSqr = GetAbsOrigin().DistToSqr( pAlienGoo->GetAbsOrigin() );
if( flDistSqr < flClosestDistSqr && FInViewCone( pAlienGoo->GetAbsOrigin() ) && !pAlienGoo->m_bHasGrubs ) // grubs = decorative, not a target
{
flClosestDistSqr = flDistSqr;
pAlienGooTarget = pAlienGoo;
}
}
return pAlienGooTarget;
}
bool CASW_Marine::EngageNewAlienGooTarget()
{
CASW_Weapon *pActiveWeapon = GetActiveASWWeapon();
CASW_Weapon *pFlamer = NULL;
if( pActiveWeapon && pActiveWeapon->Classify() == CLASS_ASW_FLAMER && pActiveWeapon->HasAmmo() )
{
pFlamer = pActiveWeapon;
}
else
{
for ( int iWeapon = 0; iWeapon < ASW_NUM_INVENTORY_SLOTS; iWeapon++ )
{
CASW_Weapon *pWeapon = GetASWWeapon( iWeapon );
if ( pWeapon && pWeapon->Classify() == CLASS_ASW_FLAMER && pWeapon->HasAmmo() )
{
pFlamer = pWeapon;
break;
}
}
}
if( pFlamer )
{
EHANDLE hAlienGooTarget = BestAlienGooTarget();
if( hAlienGooTarget.Get() )
{
SetAlienGooTarget( hAlienGooTarget );
// only switch weapons if we have a valid target and the weapon is usable
if( pFlamer != pActiveWeapon )
{
Weapon_Switch( pFlamer );
}
return true;
}
}
return false;
}
const Vector &CASW_Marine::GetEnemyLKP() const
{
// Only override default behavior if we're tracking alien goo and have no other target
if( GetAlienGooTarget() && ( !GetEnemy() || GetAlienGooTarget() == GetEnemy() ) )
{
return GetAlienGooTarget()->GetAbsOrigin();
}
else
{
CASW_Prop_Physics *pPropPhysics = dynamic_cast< CASW_Prop_Physics *>( GetEnemy() );
if ( pPropPhysics && pPropPhysics->m_takedamage == DAMAGE_YES && pPropPhysics->m_iHealth > 0 )
{
return pPropPhysics->GetAbsOrigin();
}
return BaseClass::GetEnemyLKP();
}
}
void CASW_Marine::RunTask( const Task_t *pTask )
{
bool bOld = m_bWantsToFire;
m_bWantsToFire = false;
CheckForAIWeaponSwitch();
// check for firing on the move, if our enemy is in range, with LOS and we're facing him
if (GetASWOrders() == ASW_ORDER_MOVE_TO || GetASWOrders() == ASW_ORDER_FOLLOW)
{
bool bMelee = GetCurSchedule()->GetId() == GetGlobalScheduleId( SCHED_MELEE_ATTACK_PROP1 );
if( !GetEnemy() )
{
if ( m_flLastGooScanTime + ASW_MARINE_GOO_SCAN_TIME < gpGlobals->curtime )
{
EngageNewAlienGooTarget();
m_flLastGooScanTime = gpGlobals->curtime;
}
// base AI doesn't see biomass - Need to override every time if biomass targeted
if( GetAlienGooTarget() )
{
SetEnemy( GetAlienGooTarget() );
}
else if( bMelee && GetPhysicsPropTarget() )
{
SetEnemy( GetPhysicsPropTarget() );
}
}
else if( !bMelee && GetEnemy() == GetPhysicsPropTarget() )
{
SetEnemy( NULL );
SetPhysicsPropTarget( NULL );
}
CASW_Weapon *pWeapon = GetActiveASWWeapon();
bool bOffensiveWeapon = (pWeapon && pWeapon->IsOffensiveWeapon());
if ( GetEnemy() )
{
Vector vecEnemyLKP = GetEnemyLKP();
if ( bOffensiveWeapon && !bMelee && FInAimCone( vecEnemyLKP ) &&
GetAbsOrigin().DistTo( GetEnemy()->GetAbsOrigin() ) <= GetFollowSightRange() )
{
// check it's a valid offensive weapon
bool bWeaponHasLOS = WeaponLOSCondition( GetAbsOrigin(), GetEnemy()->EyePosition(), true );
if ( !bWeaponHasLOS )
{
bWeaponHasLOS = WeaponLOSCondition( GetAbsOrigin(), GetEnemy()->BodyTarget( GetAbsOrigin() ), true );
}
if ( bWeaponHasLOS && !HasCondition(COND_ENEMY_TOO_FAR) )
{
m_bWantsToFire = true;
m_fMarineAimError *= asw_marine_aim_error_decay_multiplier.GetFloat();
if (pTask->iTask != TASK_ASW_OVERKILL_SHOOT)
m_vecOverkillPos = vecEnemyLKP;
m_fRandomFacing = UTIL_VecToYaw(vecEnemyLKP - GetAbsOrigin());
float fTwitch = float(GetHealth()) / float(GetMaxHealth());
if (fTwitch < 0.2)
fTwitch = 0.2f;
m_fNewRandomFacingTime = gpGlobals->curtime + random->RandomFloat(5 * fTwitch, 9.0f * fTwitch);
}
else if ( asw_debug_marine_aim.GetBool() )
{
Msg( "Following AI not shooting enemy as we don't have weapon LOS\n" );
}
}
else if ( asw_debug_marine_aim.GetBool() )
{
Msg("Following AI not shooting enemy: InAimcone=%d FacingIdeal=%d\n",
FInAimCone( vecEnemyLKP ), FacingIdeal());
Vector los = ( vecEnemyLKP - GetAbsOrigin() );
// do this in 2D
los.z = 0;
VectorNormalize( los );
Vector facingDir = BodyDirection2D( );
float flDot = DotProduct( los, facingDir );
Msg( " los = %f %f %f (%f)", VectorExpand( los ), UTIL_VecToYaw( los ) );
Msg( " fac = %f %f %f (%f)", VectorExpand( facingDir ), UTIL_VecToYaw( facingDir ) );
Msg( " flDot = %f eye = %f\n", flDot, UTIL_VecToYaw( EyeDirection2D() ) );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + facingDir * 200, 0, 0, 255, true, 0.1f );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + los * 200, 255, 0, 0, true, 0.1f );
}
}
}
switch(pTask->iTask)
{
case TASK_ASW_FACE_HOLDING_YAW:
{
GetMotor()->SetIdealYawAndUpdate( m_fHoldingYaw );
Scan();
if ( IsWaitFinished())
{
TaskComplete();
}
break;
}
case TASK_ASW_FACE_USING_ITEM:
{
if (!m_hUsingEntity.Get())
{
GetMotor()->SetIdealYawAndUpdate( m_fHoldingYaw );
TaskComplete();
}
else
{
CASW_Use_Area *pArea = dynamic_cast< CASW_Use_Area* >( m_hUsingEntity->GetBaseEntity() );
Vector vecUseTarget = m_hUsingEntity.Get()->GetAbsOrigin();
if ( pArea && pArea->GetProp() )
vecUseTarget = pArea->GetProp()->GetAbsOrigin();
Vector diff = vecUseTarget - GetAbsOrigin();
float fUsingYaw = UTIL_VecToYaw( diff );
GetMotor()->SetIdealYawAndUpdate( fUsingYaw );
}
break;
}
case TASK_ASW_FACE_FOLLOW_WAIT:
{
UpdateFacing();
if ( IsWaitFinished())
{
TaskComplete();
}
break;
}
case TASK_ASW_WAIT_FOR_FOLLOW_MOVEMENT:
{
UpdateFacing();
bool fTimeExpired = ( pTask->flTaskData != 0 && pTask->flTaskData < gpGlobals->curtime - GetTimeTaskStarted() );
if (fTimeExpired || GetNavigator()->GetGoalType() == GOALTYPE_NONE)
{
TaskComplete();
GetNavigator()->StopMoving(); // Stop moving
}
else if (!GetNavigator()->IsGoalActive())
{
SetIdealActivity( GetStoppedActivity() );
}
else
{
// Check validity of goal type
ValidateNavGoal();
const Vector &vecFollowPos = GetFollowPos();
if ( ( GetNavigator()->GetGoalPos() - vecFollowPos ).LengthSqr() > Square( 60 ) )
{
if ( GetNavigator()->GetNavType() != NAV_JUMP )
{
if ( !GetNavigator()->UpdateGoalPos( vecFollowPos ) )
{
TaskFail(FAIL_NO_ROUTE);
}
}
}
else if (!NeedToFollowMove())
{
TaskComplete();
}
else
{
// try to keep facing towards the last known position of the enemy
//if (GetEnemy())
//{
//Vector vecEnemyLKP = GetEnemyLKP();
//AddFacingTarget( GetEnemy(), vecEnemyLKP, 1.0, 0.8 );
//Msg("follow task adding facing target\n");
//}
}
}
break;
}
case TASK_ASW_WAIT_FOR_MOVEMENT:
{
UpdateFacing();
if ( IsMovementFrozen() )
{
TaskFail(FAIL_FROZEN);
break;
}
bool fTimeExpired = ( pTask->flTaskData != 0 && pTask->flTaskData < gpGlobals->curtime - GetTimeTaskStarted() );
if (fTimeExpired || GetNavigator()->GetGoalType() == GOALTYPE_NONE)
{
TaskComplete();
GetNavigator()->StopMoving(); // Stop moving
}
else if (!GetNavigator()->IsGoalActive())
{
SetIdealActivity( GetStoppedActivity() );
}
else
{
// Check validity of goal type
ValidateNavGoal();
}
break;
}
case TASK_ASW_FACE_ENEMY_WITH_ERROR:
{
// If the yaw is locked, this function will not act correctly
Assert( GetMotor()->IsYawLocked() == false );
UpdateFacing();
if ( FacingIdeal() )
{
TaskComplete();
}
break;
}
case TASK_ASW_OVERKILL_SHOOT:
{
RunTaskRangeAttack1(pTask);
break;
}
case TASK_ASW_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();
//GetMotor()->SetIdealYawToTargetAndUpdate( vecEnemyLKP );
//}
SetDescentSpeed();
if( GetFlags() & FL_ONGROUND )
{
//m_OnRappelTouchdown.FireOutput( GetOuter(), GetOuter(), 0 );
RemoveFlag( FL_FLY );
CutZipline();
TaskComplete();
}
}
break;
case TASK_ASW_GET_PATH_TO_GIVE_AMMO:
{
if(m_hGiveAmmoTarget)
{
AI_NavGoal_t goal( m_hGiveAmmoTarget->GetAbsOrigin(), ACT_RUN, CASW_Weapon_Ammo_Bag::GetAIMaxAmmoGiveDistance() );
GetNavigator()->SetGoal( goal );
}
TaskComplete();
}
break;
case TASK_ASW_MOVE_TO_GIVE_AMMO:
// if target is still valid, move to target
if( m_hGiveAmmoTarget)
{
UpdateFacing();
bool bTimeExpired = ( pTask->flTaskData != 0 && pTask->flTaskData < gpGlobals->curtime - GetTimeTaskStarted() );
bool bArrived = ( ( GetNavigator()->GetGoalPos() - GetAbsOrigin() ).LengthSqr() < Square( CASW_Weapon_Ammo_Bag::GetAIMaxAmmoGiveDistance() ) );
if ( bTimeExpired || GetNavigator()->GetGoalType() == GOALTYPE_NONE || bArrived )
{
TaskComplete();
GetNavigator()->StopMoving();
}
else if (!GetNavigator()->IsGoalActive())
{
SetIdealActivity( GetStoppedActivity() );
}
else
{
// Check validity of goal type
ValidateNavGoal();
// see if target marine has moved far enough that we need to adjust path
const Vector &vecCurrentPos = m_hGiveAmmoTarget->GetAbsOrigin();
if ( ( GetNavigator()->GetGoalPos() - vecCurrentPos ).LengthSqr() > Square( CASW_Weapon_Ammo_Bag::GetAIMaxAmmoGiveDistance() ) )
{
if ( GetNavigator()->GetNavType() != NAV_JUMP )
{
if ( !GetNavigator()->UpdateGoalPos( vecCurrentPos ) )
{
TaskFail( FAIL_NO_ROUTE );
}
}
}
}
}
else
// otherwise, the move task is complete (either we've arrived or the target is invalid)
{
m_hGiveAmmoTarget = NULL;
TaskComplete();
}
break;
case TASK_ASW_GET_PATH_TO_HEAL:
{
if( m_hHealTarget )
{
AI_NavGoal_t goal( m_hHealTarget->GetAbsOrigin(), ACT_RUN, CASW_Weapon_Heal_Gun::GetWeaponRange() * 0.5f );
GetNavigator()->SetGoal( goal );
}
TaskComplete();
}
break;
case TASK_ASW_MOVE_TO_HEAL:
{
// if target is still valid, move to target
if( m_hHealTarget )
{
UpdateFacing();
bool bTimeExpired = ( pTask->flTaskData != 0 && pTask->flTaskData < gpGlobals->curtime - GetTimeTaskStarted() );
bool bArrived = ( ( GetNavigator()->GetGoalPos() - GetAbsOrigin() ).LengthSqr() < Square( CASW_Weapon_Heal_Gun::GetWeaponRange()*0.5f ) );
if ( bTimeExpired || GetNavigator()->GetGoalType() == GOALTYPE_NONE || bArrived )
{
TaskComplete();
GetNavigator()->StopMoving();
}
else if (!GetNavigator()->IsGoalActive())
{
SetIdealActivity( GetStoppedActivity() );
}
else
{
// Check validity of goal type
ValidateNavGoal();
// see if target marine has moved far enough that we need to adjust path
const Vector &vecCurrentPos = m_hHealTarget->GetAbsOrigin();
if ( ( GetNavigator()->GetGoalPos() - vecCurrentPos ).LengthSqr() > Square( CASW_Weapon_Heal_Gun::GetWeaponRange()*0.5f ) )
{
if ( GetNavigator()->GetNavType() != NAV_JUMP )
{
if ( !GetNavigator()->UpdateGoalPos( vecCurrentPos ) )
{
TaskFail( FAIL_NO_ROUTE );
}
}
}
}
}
else
// otherwise, the move task is complete (either we've arrived or the target is invalid)
{
m_hHealTarget = NULL;
TaskComplete();
}
}
break;
case TASK_ASW_SWAP_TO_HEAL_GUN:
{
// this is done in StartTask
}
break;
case TASK_ASW_HEAL_MARINE:
{
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if( !m_hHealTarget || !pWeapon || pWeapon->Classify() != CLASS_ASW_HEAL_GUN || !pWeapon->HasAmmo() )
{
TaskComplete();
}
else
{
CASW_Weapon_Heal_Gun *pHealgun = static_cast<CASW_Weapon_Heal_Gun*>( pWeapon );
bool bHealSucceeded = true;
// if the gun to longer has a target...
if ( m_hHealTarget->GetHealth() <= 0 ||
m_hHealTarget->GetHealth() >= m_hHealTarget->GetMaxHealth() * MARINE_STOP_HEAL_THRESHOLD )
{
TaskComplete();
bHealSucceeded = false;
}
else
{
if ( m_hHealTarget->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) >= Square( CASW_Weapon_Heal_Gun::GetWeaponRange()*0.75 ) )
{
TaskComplete();
}
else
{
// facing another direction
Vector vecAttach = m_hHealTarget->GetAbsOrigin() - GetAbsOrigin();
Vector vecForward;
AngleVectors( ASWEyeAngles(), &vecForward );
if ( DotProduct( vecForward, vecAttach ) < 0.0f )
{
TaskComplete();
}
}
}
if ( !pHealgun || !pHealgun->HasHealAttachTarget() )
{
bHealSucceeded = false;
TaskComplete();
}
if ( bHealSucceeded )
pHealgun->PrimaryAttack();
}
}
break;
default:
{
BaseClass::RunTask(pTask);
}
}
if (bOld && !m_bWantsToFire)
{
//Msg("Stopped firing\n");
}
}
void CASW_Marine::CheckForAIWeaponSwitch()
{
if ( !GetEnemy() )
return;
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if ( pWeapon && pWeapon->IsOffensiveWeapon() && pWeapon->HasPrimaryAmmo() )
return;
// see if any of our other inventory items are valid weapons
for ( int i = 0; i < ASW_NUM_INVENTORY_SLOTS; i++ )
{
CASW_Weapon *pOtherWeapon = GetASWWeapon( i );
if ( pOtherWeapon != pWeapon && pOtherWeapon && pOtherWeapon->IsOffensiveWeapon() && pOtherWeapon->HasPrimaryAmmo() )
{
Weapon_Switch( pOtherWeapon );
m_iHurtWithoutOffensiveWeapon = 0;
return;
}
}
// if we have no guns with primary ammo, search for one with secondary ammo
for ( int i = 0; i < ASW_NUM_INVENTORY_SLOTS; i++ )
{
CASW_Weapon *pOtherWeapon = GetASWWeapon( i );
if ( pOtherWeapon != pWeapon && pOtherWeapon && pOtherWeapon->IsOffensiveWeapon() && pOtherWeapon->HasAmmo() )
{
Weapon_Switch( pOtherWeapon );
m_iHurtWithoutOffensiveWeapon = 0;
return;
}
}
}
#define ASW_OVERKILL_TIME random->RandomFloat(0.5f,1.0f)
void CASW_Marine::RunTaskRangeAttack1( const Task_t *pTask )
{
m_bWantsToFire = true;
AutoMovement( );
Vector vecEnemyLKP = GetEnemyLKP();
float fAimYaw;
if (pTask->iTask != TASK_ASW_OVERKILL_SHOOT)
fAimYaw = CalcIdealYaw(vecEnemyLKP);
else
fAimYaw = CalcIdealYaw(m_vecOverkillPos);
//add in our aim error
fAimYaw += m_fMarineAimError;
// reduce the aim error
m_fMarineAimError *= asw_marine_aim_error_decay_multiplier.GetFloat();
// 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 || pTask->iTask == TASK_ASW_OVERKILL_SHOOT) &&
( CapabilitiesGet() & bits_CAP_AIM_GUN ) &&
FInAimCone( vecEnemyLKP ) )
{
GetMotor()->SetIdealYawAndUpdate( fAimYaw, AI_KEEP_YAW_SPEED );
if (pTask->iTask != TASK_ASW_OVERKILL_SHOOT)
m_fOverkillShootTime = gpGlobals->curtime + ASW_OVERKILL_TIME;
}
else
{
GetMotor()->SetIdealYawAndUpdate( fAimYaw, AI_KEEP_YAW_SPEED );
}
if (pTask->iTask != TASK_ASW_OVERKILL_SHOOT)
{
m_vecOverkillPos = vecEnemyLKP;
}
}
if (pTask->iTask != TASK_ASW_OVERKILL_SHOOT)
{
if (gpGlobals->curtime > m_fStartedFiringTime + 0.3f)
{
TaskComplete();
return;
}
if (HasCondition(COND_ENEMY_DEAD)
|| HasCondition(COND_ENEMY_OCCLUDED)
|| HasCondition(COND_WEAPON_BLOCKED_BY_FRIEND)
|| HasCondition(COND_WEAPON_SIGHT_OCCLUDED)
|| HasCondition(COND_ASW_NEW_ORDERS))
{
m_bWantsToFire = false;
TaskComplete();
}
}
else
{
if (gpGlobals->curtime > m_fOverkillShootTime)
{
TaskComplete();
return;
}
}
}
void CASW_Marine::StartTaskRangeAttack1( const Task_t *pTask )
{
if (GetEnemy() == NULL)
{
//Msg("Started ranged attack task with no enemy!");
}
m_fStartedFiringTime = gpGlobals->curtime;
BaseClass::StartTaskRangeAttack1(pTask);
}
bool CASW_Marine::SetNewAimError(CBaseEntity *pTarget)
{
if (!pTarget)
return false;
// find our current yaw to the enemy
float currentYaw = UTIL_AngleMod( GetLocalAngles().y );
Vector enemyDir = GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter();
VectorNormalize( enemyDir );
float angleDiff = VecToYaw( enemyDir );
angleDiff = UTIL_AngleDiff( angleDiff, currentYaw );
// create some random error amount, within our angle
m_fMarineAimError = random->RandomFloat( asw_marine_aim_error_min.GetFloat(), asw_marine_aim_error_max.GetFloat() );
if ( m_fMarineAimError > fabs( angleDiff ) )
{
m_fMarineAimError = fabs( angleDiff );
}
if ( angleDiff > 0 )
{
m_fMarineAimError = -m_fMarineAimError;
}
if ( asw_debug_marine_aim.GetBool() )
{
Msg( "Set marine's aim error to %f\n", m_fMarineAimError );
}
return true;
}
// adjusts a target point by our aim error angle
void CASW_Marine::AddAimErrorToTarget(Vector &vecTarget)
{
Vector diff = vecTarget;
Vector diff_rotated;
matrix3x4_t fRotateMatrix;
AngleMatrix(QAngle(0, m_fMarineAimError, 0), fRotateMatrix);
VectorRotate( diff, fRotateMatrix, diff_rotated);
VectorRotate(diff, QAngle(0, m_fMarineAimError, 0), diff_rotated);
vecTarget = diff_rotated;
return;
}
//-----------------------------------------------------------------------------
// Purpose: Return the actual position the NPC wants to fire at when it's trying
// to hit it's current enemy.
//-----------------------------------------------------------------------------
Vector CASW_Marine::GetActualShootPosition( const Vector &shootOrigin )
{
// Project the target's location into the future.
Vector vecEnemyLKP = GetEnemyLKP();
Vector vecEnemyOffset = GetEnemy()->BodyTarget( shootOrigin ) - GetEnemy()->GetAbsOrigin();
Vector vecTargetPosition = vecEnemyOffset + vecEnemyLKP;
// lead for some fraction of a second.
return (vecTargetPosition + ( GetEnemy()->GetSmoothedVelocity() * ai_lead_time.GetFloat() ));
}
// potentially miss
// asw - this is mostly copied from ai_basenpc, but with our added aim error on top
Vector CASW_Marine::GetActualShootTrajectory( const Vector &shootOrigin )
{
const Task_t *pCurTask = GetTask();
if ( pCurTask && pCurTask->iTask == TASK_ASW_OVERKILL_SHOOT )
{
// if we're overkill shooting, fire at the overkill pos
Vector shotDir = m_vecOverkillPos+Vector(0,0,45) - shootOrigin;
VectorNormalize( shotDir );
CollectShotStats( shootOrigin, shotDir );
CShotManipulator manipulator( shotDir );
manipulator.ApplySpread( GetAttackSpread( GetActiveWeapon(), GetEnemy() ), GetSpreadBias( GetActiveWeapon(), GetEnemy() ) );
shotDir = manipulator.GetResult();
return shotDir;
}
Vector vecShotDir;
if( !GetEnemy() )
{
vecShotDir = GetShootEnemyDir( shootOrigin );
}
else
{
Vector vecProjectedPosition = GetActualShootPosition( shootOrigin );
vecShotDir = vecProjectedPosition - shootOrigin;
VectorNormalize( vecShotDir );
// NOW we have a shoot direction. Where a 100% accurate bullet should go.
// Modify it by weapon proficiency.
// construct a manipulator
CShotManipulator manipulator( vecShotDir );
manipulator.ApplySpread( GetAttackSpread( GetActiveWeapon(), GetEnemy() ), GetSpreadBias( GetActiveWeapon(), GetEnemy() ) );
vecShotDir = manipulator.GetResult();
}
AddAimErrorToTarget( vecShotDir ); // asw
return vecShotDir;
}
void CASW_Marine::DrawDebugGeometryOverlays()
{
if (GetASWOrders() == ASW_ORDER_MOVE_TO)
{
float flViewRange = acos(0.8);
Vector vEyeDir = EyeDirection2D( );
Vector vLeftDir, vRightDir;
float fSin, fCos;
SinCos( flViewRange, &fSin, &fCos );
vLeftDir.x = vEyeDir.x * fCos - vEyeDir.y * fSin;
vLeftDir.y = vEyeDir.x * fSin + vEyeDir.y * fCos;
vLeftDir.z = vEyeDir.z;
fSin = sin(-flViewRange);
fCos = cos(-flViewRange);
vRightDir.x = vEyeDir.x * fCos - vEyeDir.y * fSin;
vRightDir.y = vEyeDir.x * fSin + vEyeDir.y * fCos;
vRightDir.z = vEyeDir.z;
//NDebugOverlay::BoxDirection(m_vecMoveToOrderPos, Vector(0,0,-40), Vector(200,0,40), vLeftDir, 255, 0, 0, 50, 0 );
//NDebugOverlay::BoxDirection(m_vecMoveToOrderPos, Vector(0,0,-40), Vector(200,0,40), vRightDir, 255, 0, 0, 50, 0 );
//NDebugOverlay::BoxDirection(m_vecMoveToOrderPos, Vector(0,0,-40), Vector(200,0,40), vEyeDir, 0, 255, 0, 50, 0 );
NDebugOverlay::Box(m_vecMoveToOrderPos, -Vector(2,2,2), Vector(2,2,2), 0, 255, 0, 128, 0 );
}
BaseClass::DrawDebugGeometryOverlays();
if ( GetSquadFormation() )
{
GetSquadFormation()->DrawDebugGeometryOverlays();
}
}
ConVar asw_marine_face_last_enemy_time( "asw_marine_face_last_enemy_time", "5.0", FCVAR_CHEAT, "Amount of time that AI marines will face their last enemy after losing it while in follow mode" );
void CASW_Marine::UpdateFacing()
{
if ( gpGlobals->curtime > m_flNextYawOffsetTime )
{
RecalculateAIYawOffset();
}
if ( m_vecFacingPointFromServer.Get() != vec3_origin )
{
float flAimYaw = UTIL_VecToYaw( m_vecFacingPointFromServer.Get() - GetAbsOrigin() );
GetMotor()->SetIdealYawAndUpdate( flAimYaw );
}
else if ( GetEnemy() )
{
Vector vecEnemyLKP = GetEnemyLKP();
float flAimYaw = CalcIdealYaw( vecEnemyLKP ) + m_fMarineAimError;
GetMotor()->SetIdealYawAndUpdate( flAimYaw );
m_flLastEnemyYaw = flAimYaw;
m_flLastEnemyYawTime = gpGlobals->curtime;
m_flAIYawOffset = 0;
if ( asw_debug_marine_aim.GetBool() )
{
Vector vecAim;
QAngle angAim = QAngle( 0, flAimYaw, 0 );
AngleVectors( angAim, &vecAim );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + vecAim * 50, 255, 255, 0, false, 0.1f );
NDebugOverlay::Line( GetAbsOrigin(), vecEnemyLKP, 255, 255, 255, false, 0.1f );
Msg( "aim error = %f fAimYaw = %f\n", m_fMarineAimError, flAimYaw );
}
}
else if ( IsCurSchedule( SCHED_ASW_MOVE_TO_ORDER_POS ) ) // face our order destination
{
Vector vecEnemyLKP = GetEnemyLKP();
float flAimYaw = CalcIdealYaw( m_vecMoveToOrderPos );
GetMotor()->SetIdealYawAndUpdate( flAimYaw );
if ( asw_debug_marine_aim.GetBool() )
{
Vector vecAim;
QAngle angAim = QAngle( 0, flAimYaw, 0 );
AngleVectors( angAim, &vecAim );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + vecAim * 50, 255, 255, 0, false, 0.1f );
NDebugOverlay::Line( GetAbsOrigin(), vecEnemyLKP, 255, 255, 255, false, 0.1f );
Msg( "aim error = %f fAimYaw = %f\n", m_fMarineAimError, flAimYaw );
}
}
else if ( IsCurSchedule( SCHED_ASW_HEAL_MARINE ) ) // face the marine that we want to heal
{
if ( m_hHealTarget.Get() )
{
float flAimYaw = CalcIdealYaw( m_hHealTarget.Get()->GetAbsOrigin() );
GetMotor()->SetIdealYawAndUpdate( flAimYaw );
if ( asw_debug_marine_aim.GetBool() )
{
Vector vecAim;
QAngle angAim = QAngle( 0, flAimYaw, 0 );
AngleVectors( angAim, &vecAim );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + vecAim * 50, 0, 255, 0, false, 0.2f );
}
}
}
else if ( GetASWOrders() == ASW_ORDER_FOLLOW )
{
float flAimYaw = GetSquadFormation()->GetYaw( GetSquadFormation()->Find(this) );
if ( gpGlobals->curtime < m_flLastEnemyYawTime + asw_marine_face_last_enemy_time.GetFloat() )
{
flAimYaw = m_flLastEnemyYaw;
}
flAimYaw += m_flAIYawOffset;
GetMotor()->SetIdealYawAndUpdate( flAimYaw );
if ( asw_debug_marine_aim.GetBool() )
{
Vector vecAim;
QAngle angAim = QAngle( 0, flAimYaw, 0 );
AngleVectors( angAim, &vecAim );
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + vecAim * 50, 255, 255, 0, false, 0.1f );
Msg( "aim error = %f fAimYaw = %f m_flAIYawOffset = %f\n", m_fMarineAimError, flAimYaw, m_flAIYawOffset );
}
}
// else
// {
// // face our destination
// Vector vecDest = GetNavigator()->GetGoalPos();
//
// float fAimYaw = CalcIdealYaw( vecDest );// + m_fMarineAimError; // TODO: put aim error back in
// GetMotor()->SetIdealYawAndUpdate( fAimYaw );
// }
}
bool CASW_Marine::OverrideMoveFacing( const AILocalMoveGoal_t &move, float flInterval )
{
// make him looking towards his holding direction as he moves
/*
if (GetASWOrders() == ASW_ORDER_MOVE_TO)
{
QAngle holding(0, m_fHoldingYaw,0);
Vector vecForward;
AngleVectors(holding, &vecForward);
Vector vDest = GetNavigator()->GetGoalPos();
Msg("Adding facing target..\n");
AddFacingTarget( vDest + vecForward * 100.0f, 10.0f, 1.0f );
}*/
// if we're moving to a specific spot, make sure we face our enemy so we can shoot while on the move
if (GetEnemy() && (GetASWOrders()==ASW_ORDER_MOVE_TO || GetASWOrders() == ASW_ORDER_FOLLOW))
{
// ASWTODO - is this move_yaw set needed? (or needs to be move_x/y?)
//float flMoveYaw = UTIL_VecToYaw( move.dir );
//float idealYaw = UTIL_AngleMod( flMoveYaw );
//float flEYaw = UTIL_VecToYaw( GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter() );
// UpdateFacing();
// find movement direction to compensate for not being turned far enough
// ASWTODO - is this move_yaw set needed? (or needs to be move_x/y?)
/*
float fSequenceMoveYaw = GetSequenceMoveYaw( GetSequence() );
float flDiff = UTIL_AngleDiff( flMoveYaw, GetLocalAngles().y + fSequenceMoveYaw );
SetPoseParameter( "move_yaw", GetPoseParameter( "move_yaw" ) + flDiff );
*/
return true;
}
return true;
return BaseClass::OverrideMoveFacing( move, flInterval );
}
// check for AI changing weapon if he's getting hurt and has a non-offensive weapon equipped
bool CASW_Marine::CheckAutoWeaponSwitch()
{
CASW_Weapon *pWeapon = GetActiveASWWeapon();
if (pWeapon && pWeapon->IsOffensiveWeapon())
return true;
// marine doesn't auto switch weapons the first two times he's hurt
m_iHurtWithoutOffensiveWeapon++;
if (m_iHurtWithoutOffensiveWeapon <3)
return false;
// find best offensive weapon
CASW_Weapon *pBestWeapon = NULL;
for (int i=0;i<ASW_MAX_MARINE_WEAPONS;i++)
{
pWeapon = GetASWWeapon(i);
if (pWeapon && pWeapon->IsOffensiveWeapon())
{
pBestWeapon = pWeapon;
break;
}
}
if (pBestWeapon)
{
Weapon_Switch( pWeapon );
m_iHurtWithoutOffensiveWeapon = 0;
return true;
}
return false;
}
inline const Vector & CASW_Marine::GetFollowPos()
{
m_hMarineFollowTarget = GetSquadLeader();
// if I'm in a squad and it has a leader, then
// use the computed position. Otherwise fall
// back to current pos.
unsigned slot = GetSquadFormation()->Find(this);
return ( GetSquadFormation()->IsValid(slot) ?
GetSquadFormation()->GetIdealPosition(slot) :
GetAbsOrigin() );
}
// ===== Rappeling ===================================
void CASW_Marine::BeginRappel()
{
m_bWaitingToRappel = true;
m_bOnGround = false;
RemoveFlag(FL_ONGROUND);
// Send the message to begin rappeling!
SetCondition( COND_ASW_BEGIN_RAPPEL );
m_vecRopeAnchor = GetAbsOrigin();
}
void CASW_Marine::CutZipline()
{
if( m_hLine.Get() )
{
UTIL_Remove( m_hLine );
}
// create one just hanging down in its place
CBeam *pBeam;
pBeam = CBeam::BeamCreate( "cable/cable.vmt", 1 );
pBeam->SetColor( 150, 150, 150 );
pBeam->SetWidth( 1.0 ); // was 0.3
pBeam->SetEndWidth( 1.0 );
//pBeam->PointEntInit( GetAbsOrigin() + Vector( 0, 0, 80 ), this );
//pBeam->SetEndAttachment( attachment );
//pBeam->SetAbsEndPos(GetAbsOrigin());
pBeam->PointsInit(m_vecRopeAnchor, GetAbsOrigin());
if( m_hLine.Get() )
{
UTIL_Remove( m_hLine );
}
m_hLine.Set( pBeam );
//CBaseEntity *pAnchor = CreateEntityByName( "asw_rope_anchor" );
//pAnchor->SetOwnerEntity( this );
//pAnchor->SetAbsOrigin( m_vecRopeAnchor );
//pAnchor->Spawn();
}
void CASW_Marine::CreateZipline()
{
if( !m_hLine )
{
int attachment = LookupAttachment( "zipline" );
if( attachment != -1 )
{
CBeam *pBeam;
pBeam = CBeam::BeamCreate( "cable/cable.vmt", 1 );
pBeam->SetColor( 150, 150, 150 );
pBeam->SetWidth( 1.0 ); // was 0.3
pBeam->SetEndWidth( 1.0 );
pBeam->PointEntInit( GetAbsOrigin() + Vector( 0, 0, 80 ), this );
pBeam->SetEndAttachment( attachment );
m_hLine.Set( pBeam );
}
}
}
#define RAPPEL_MAX_SPEED 600 // Go this fast if you're really high.
#define RAPPEL_MIN_SPEED 60 // Go no slower than this.
#define RAPPEL_DECEL_DIST (20.0f * 12.0f) // Start slowing down when you're this close to the ground.
void CASW_Marine::SetDescentSpeed()
{
// Trace to the floor and see how close we're getting. Slow down if we're close.
// STOP if there's an NPC under us.
trace_t tr;
AI_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 8192 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
float flDist = fabs( GetAbsOrigin().z - tr.endpos.z );
float speed = RAPPEL_MAX_SPEED;
if( flDist <= RAPPEL_DECEL_DIST )
{
float factor;
factor = flDist / RAPPEL_DECEL_DIST;
speed = MAX( RAPPEL_MIN_SPEED, speed * factor );
}
Vector vecNewVelocity = vec3_origin;
vecNewVelocity.z = -speed;
SetAbsVelocity( vecNewVelocity );
}
void CASW_Marine::CleanupOnDeath( CBaseEntity *pCulprit, bool bFireDeathOutput )
{
BaseClass::CleanupOnDeath( pCulprit, bFireDeathOutput );
//This will remove the beam and create a rope if the NPC dies while rappeling down.
if ( m_hLine )
{
CutZipline();
}
}
// use head direction to determine if spot is shootable
bool CASW_Marine::FInAimCone( const Vector &vecSpot )
{
return BaseClass::FInAimCone( vecSpot );
Vector los = ( vecSpot - Weapon_ShootPosition() );
// do this in 2D
los.z = 0;
VectorNormalize( los );
Vector facingDir = HeadDirection2D( );
float flDot = DotProduct( los, facingDir );
if (CapabilitiesGet() & bits_CAP_AIM_GUN)
{
// FIXME: query current animation for ranges
return ( flDot > DOT_30DEGREE );
}
if ( flDot > 0.994 )//!!!BUGBUG - magic number same as FacingIdeal(), what is this?
return true;
return false;
}
void CASW_Marine::OnWeldStarted()
{
m_bWaitingForWeld = true;
m_flBeginWeldTime = gpGlobals->curtime;
SetCondition( COND_ASW_NEW_ORDERS );
}
void CASW_Marine::OnWeldFinished()
{
m_bWaitingForWeld = false;
SetCondition( COND_ASW_NEW_ORDERS );
}
ConVar asw_debug_combat_status( "asw_debug_combat_status", "0", FCVAR_CHEAT, "Show marine's combat status on the screen" );
void CASW_Marine::UpdateCombatStatus()
{
const float flCombatEnemyDist = 512.0f;
const float flNearbyMarineDist = 768.0f;
CASW_Game_Resource *pGameResource = ASWGameResource();
if ( !IsInhabited() && GetEnemy() && GetEnemy()->GetAbsOrigin().DistTo( GetAbsOrigin() ) < flCombatEnemyDist )
{
m_flLastSquadEnemyTime = gpGlobals->curtime;
}
else
{
// check nearby squad mates
for ( int i = 0; i < pGameResource->GetMaxMarineResources(); i++ )
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pOtherMarine = pMR ? pMR->GetMarineEntity() : NULL;
if ( pOtherMarine && pOtherMarine != this && !pOtherMarine->IsInhabited() && pOtherMarine->GetEnemy()
&& pOtherMarine->GetAbsOrigin().DistTo( GetAbsOrigin() ) < flNearbyMarineDist
&& pOtherMarine->GetEnemy()->GetAbsOrigin().DistTo( pOtherMarine->GetAbsOrigin() ) < flCombatEnemyDist )
{
m_flLastSquadEnemyTime = gpGlobals->curtime;
break;
}
}
}
m_flLastSquadShotAlienTime = 0.0f;
for ( int i = 0; i < pGameResource->GetMaxMarineResources(); i++ )
{
CASW_Marine_Resource *pMR = pGameResource->GetMarineResource(i);
CASW_Marine *pOtherMarine = pMR ? pMR->GetMarineEntity() : NULL;
if ( pOtherMarine != this && pOtherMarine && pOtherMarine->GetAbsOrigin().DistTo( GetAbsOrigin() ) < flNearbyMarineDist )
{
m_flLastSquadShotAlienTime = MAX( m_flLastSquadShotAlienTime, pOtherMarine->m_flLastHurtAlienTime );
}
}
if ( asw_debug_combat_status.GetBool() )
{
engine->Con_NPrintf( GetMarineResource()->m_MarineProfileIndex, "%s: %s", GetMarineProfile()->GetShortName(), IsInCombat() ? "COMBAT" : "not in combat" );
}
}
ConVar asw_marine_force_combat_status( "asw_marine_force_combat_status", "0", FCVAR_CHEAT );
bool CASW_Marine::IsInCombat()
{
if ( asw_marine_force_combat_status.GetBool() )
return true;
const float flCombatTime = 10.0f;
return ( ( m_flLastSquadEnemyTime != 0.0f && m_flLastSquadEnemyTime > gpGlobals->curtime - flCombatTime ) ||
( m_flLastSquadShotAlienTime != 0.0f && m_flLastSquadShotAlienTime > gpGlobals->curtime - flCombatTime ) );
}
bool CASW_Marine::FValidateHintType( CAI_Hint *pHint )
{
if ( pHint->HintType() == HINT_FOLLOW_WAIT_POINT )
return true;
return BaseClass::FValidateHintType( pHint );
}
ConVar asw_marine_random_yaw( "asw_marine_random_yaw", "40", FCVAR_NONE, "Min/max angle the marine will change his yaw when idling in follow mode" );
ConVar asw_marine_yaw_interval_min( "asw_marine_yaw_interval_min", "3", FCVAR_NONE, "Min time between AI marine shifting his yaw" );
ConVar asw_marine_yaw_interval_max( "asw_marine_yaw_interval_max", "8", FCVAR_NONE, "Max time between AI marine shifting his yaw" );
ConVar asw_marine_toggle_crouch_chance( "asw_marine_toggle_crouch_chance", "0.4", FCVAR_NONE, "Chance of AI changing between crouched and non-crouched while idling in follow mode" );
void CASW_Marine::RecalculateAIYawOffset()
{
m_flAIYawOffset = RandomFloat( -asw_marine_random_yaw.GetFloat(), asw_marine_random_yaw.GetFloat() );
if ( asw_blind_follow.GetBool() )
{
m_bAICrouch = ( GetASWOrders() == ASW_ORDER_HOLD_POSITION );
}
else if ( RandomFloat() < asw_marine_toggle_crouch_chance.GetFloat() )
{
m_bAICrouch = !m_bAICrouch;
}
m_flNextYawOffsetTime = gpGlobals->curtime + RandomFloat( asw_marine_yaw_interval_min.GetFloat(), asw_marine_yaw_interval_max.GetFloat() );
}
// disables collision between the marine and certain props that the marine cannot break reliably
void CASW_Marine::CheckForDisablingAICollision( CBaseEntity *pEntity )
{
if ( !pEntity )
return;
// don't disable collision between the marine and breakable crates
const char *szModelName = STRING( pEntity->GetModelName() );
if ( !szModelName )
return;
if ( !CanMarineGetStuckOnProp( szModelName ) )
return;
PhysDisableEntityCollisions( this, pEntity );
SetPhysicsPropTarget( NULL );
}
//-----------------------------------------------------------------------------
// Schedules
//-----------------------------------------------------------------------------
AI_BEGIN_CUSTOM_NPC( asw_marine, CASW_Marine )
DECLARE_CONDITION( COND_ASW_NEW_ORDERS )
DECLARE_CONDITION( COND_ASW_BEGIN_RAPPEL )
DECLARE_CONDITION( COND_SQUADMATE_WANTS_AMMO )
DECLARE_CONDITION( COND_SQUADMATE_NEEDS_AMMO )
DECLARE_CONDITION( COND_PATH_BLOCKED_BY_PHYSICS_PROP )
DECLARE_CONDITION( COND_PROP_DESTROYED )
DECLARE_CONDITION( COND_COMPLETELY_OUT_OF_AMMO )
DECLARE_TASK( TASK_ASW_FACE_HOLDING_YAW )
DECLARE_TASK( TASK_ASW_FACE_USING_ITEM )
DECLARE_TASK( TASK_ASW_START_USING_AREA )
DECLARE_TASK( TASK_ASW_FACE_ENEMY_WITH_ERROR )
DECLARE_TASK( TASK_ASW_OVERKILL_SHOOT )
DECLARE_TASK( TASK_ASW_GET_PATH_TO_ORDER_POS )
DECLARE_TASK( TASK_ASW_GET_PATH_TO_FOLLOW_TARGET )
DECLARE_TASK( TASK_ASW_GET_PATH_TO_PROP )
DECLARE_TASK( TASK_ASW_FACE_FOLLOW_WAIT )
DECLARE_TASK( TASK_ASW_GET_BACK_OFF_PATH )
DECLARE_TASK( TASK_ASW_WAIT_FOR_FOLLOW_MOVEMENT )
DECLARE_TASK( TASK_ASW_WAIT_FOR_MOVEMENT )
DECLARE_TASK( TASK_ASW_CHATTER_CONFIRM )
DECLARE_TASK( TASK_ASW_RAPPEL )
DECLARE_TASK( TASK_ASW_HIT_GROUND )
DECLARE_TASK( TASK_ASW_ORDER_TO_DEPLOY_SPOT )
DECLARE_TASK( TASK_ASW_GET_PATH_TO_GIVE_AMMO )
DECLARE_TASK( TASK_ASW_MOVE_TO_GIVE_AMMO )
DECLARE_TASK( TASK_ASW_SWAP_TO_AMMO_BAG )
DECLARE_TASK( TASK_ASW_GIVE_AMMO_TO_MARINE )
DECLARE_TASK( TASK_ASW_GET_PATH_TO_HEAL )
DECLARE_TASK( TASK_ASW_MOVE_TO_HEAL )
DECLARE_TASK( TASK_ASW_SWAP_TO_HEAL_GUN )
DECLARE_TASK( TASK_ASW_HEAL_MARINE )
DECLARE_ANIMEVENT( AE_MARINE_KICK )
DECLARE_ANIMEVENT( AE_MARINE_UNFREEZE )
// Activities
DECLARE_ACTIVITY( ACT_MARINE_GETTING_UP )
DECLARE_ACTIVITY( ACT_MARINE_LAYING_ON_FLOOR )
DEFINE_SCHEDULE
(
SCHED_ASW_HOLD_POSITION,
" Tasks"
" TASK_STOP_MOVING 0"
//" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
" TASK_ASW_FACE_HOLDING_YAW 2"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
" COND_CAN_MELEE_ATTACK1"
" COND_CAN_MELEE_ATTACK2"
" COND_IDLE_INTERRUPT"
" COND_ASW_NEW_ORDERS"
" COND_ASW_BEGIN_RAPPEL"
)
DEFINE_SCHEDULE
(
SCHED_ASW_USE_AREA,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_ASW_START_USING_AREA 0"
" TASK_ASW_FACE_USING_ITEM 0"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
" COND_CAN_MELEE_ATTACK1"
" COND_CAN_MELEE_ATTACK2"
" COND_IDLE_INTERRUPT"
" COND_ASW_NEW_ORDERS"
" COND_ASW_BEGIN_RAPPEL"
)
DEFINE_SCHEDULE
(
SCHED_ASW_USING_OVER_TIME,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_ASW_FACE_USING_ITEM 0"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
" COND_CAN_MELEE_ATTACK1"
" COND_CAN_MELEE_ATTACK2"
" COND_IDLE_INTERRUPT"
" COND_ASW_NEW_ORDERS"
" COND_ASW_BEGIN_RAPPEL"
)
DEFINE_SCHEDULE
(
SCHED_ASW_OVERKILL_SHOOT,
" Tasks"
" TASK_ASW_OVERKILL_SHOOT 0"
""
" Interrupts"
" COND_NO_PRIMARY_AMMO"
" COND_ASW_NEW_ORDERS"
)
DEFINE_SCHEDULE
(
SCHED_ASW_RANGE_ATTACK1,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_ASW_FACE_ENEMY_WITH_ERROR 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_RANGE_ATTACK1 0"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_ENEMY_OCCLUDED"
" COND_NO_PRIMARY_AMMO"
" COND_HEAR_DANGER"
" COND_WEAPON_BLOCKED_BY_FRIEND"
" COND_WEAPON_SIGHT_OCCLUDED"
" COND_LOST_ENEMY"
" COND_ASW_NEW_ORDERS"
)
DEFINE_SCHEDULE
(
SCHED_ASW_MOVE_TO_ORDER_POS,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ASW_FOLLOW_WAIT"
" TASK_ASW_GET_PATH_TO_ORDER_POS 0"
" TASK_ASW_CHATTER_CONFIRM 0.4"
" TASK_RUN_PATH 0"
" TASK_ASW_WAIT_FOR_MOVEMENT 0"
" TASK_STOP_MOVING 1"
""
" Interrupts"
" COND_ASW_NEW_ORDERS"
" COND_NEW_ENEMY"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
)
DEFINE_SCHEDULE
(
SCHED_ASW_FOLLOW_MOVE,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ASW_FOLLOW_WAIT"
" TASK_ASW_GET_PATH_TO_FOLLOW_TARGET 0"
" TASK_RUN_PATH 0"
" TASK_ASW_WAIT_FOR_FOLLOW_MOVEMENT 0"
" TASK_STOP_MOVING 1"
""
" Interrupts"
" COND_ASW_NEW_ORDERS"
" COND_NEW_ENEMY"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
)
DEFINE_SCHEDULE
(
SCHED_ASW_FOLLOW_WAIT,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_ASW_FACE_FOLLOW_WAIT 0.3"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
" COND_CAN_MELEE_ATTACK1"
" COND_CAN_MELEE_ATTACK2"
" COND_IDLE_INTERRUPT"
" COND_ASW_NEW_ORDERS"
" COND_GIVE_WAY"
)
DEFINE_SCHEDULE
(
SCHED_ASW_PICKUP_WAIT,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_WAIT 1.5"
""
" Interrupts"
)
DEFINE_SCHEDULE
(
SCHED_ASW_FOLLOW_BACK_OFF,
" Tasks"
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_ASW_FOLLOW_WAIT"
" TASK_ASW_GET_BACK_OFF_PATH 0"
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_STOP_MOVING 1"
""
" Interrupts"
" COND_ASW_NEW_ORDERS"
" COND_NEW_ENEMY"
" COND_SEE_ENEMY"
" COND_CAN_RANGE_ATTACK1"
" COND_CAN_RANGE_ATTACK2"
)
//===============================================
//===============================================
DEFINE_SCHEDULE
(
SCHED_ASW_RAPPEL_WAIT,
" Tasks"
" TASK_SET_ACTIVITY ACTIVITY:ACT_RAPPEL_LOOP"
" TASK_WAIT_INDEFINITE 0"
""
" Interrupts"
" COND_ASW_BEGIN_RAPPEL"
);
//===============================================
//===============================================
DEFINE_SCHEDULE
(
SCHED_ASW_RAPPEL,
" Tasks"
" TASK_SET_ACTIVITY ACTIVITY:ACT_RAPPEL_LOOP"
" TASK_WAIT 0.2"
" TASK_ASW_RAPPEL 0"
" TASK_ASW_HIT_GROUND 0"
" TASK_ASW_ORDER_TO_DEPLOY_SPOT 0"
//" TASK_SET_SCHEDULE SCHEDULE:SCHED_ASW_CLEAR_RAPPEL_POINT"
""
" Interrupts"
""
" COND_NEW_ENEMY" // Only so the enemy selection code will pick an enemy!
);
//===============================================
//===============================================
DEFINE_SCHEDULE
(
SCHED_ASW_CLEAR_RAPPEL_POINT,
" Tasks"
" TASK_ASW_HIT_GROUND 0"
" TASK_MOVE_AWAY_PATH 128" // Clear this spot for other rappellers
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
""
);
//===============================================
//===============================================
DEFINE_SCHEDULE
(
SCHED_ASW_GIVE_AMMO,
" Tasks"
" TASK_ASW_GET_PATH_TO_GIVE_AMMO 0"
" TASK_ASW_MOVE_TO_GIVE_AMMO 0"
" TASK_ASW_SWAP_TO_AMMO_BAG 0"
" TASK_ASW_GIVE_AMMO_TO_MARINE 0"
""
" Interrupts"
""
);
//===============================================
//===============================================
DEFINE_SCHEDULE
(
SCHED_ASW_HEAL_MARINE,
" Tasks"
" TASK_ASW_GET_PATH_TO_HEAL 0"
" TASK_ASW_MOVE_TO_HEAL 0"
" TASK_ASW_SWAP_TO_HEAL_GUN 0"
" TASK_ASW_HEAL_MARINE 0"
""
" Interrupts"
""
);
//=========================================================
//=========================================================
DEFINE_SCHEDULE
(
SCHED_MELEE_ATTACK_PROP1,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_ASW_GET_PATH_TO_PROP 40" // 40 = attack distance
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MELEE_ATTACK1 1"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MELEE_ATTACK1 2"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MELEE_ATTACK1 3"
""
" Interrupts"
//" COND_NEW_ENEMY"
" COND_PROP_DESTROYED"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_ENEMY_OCCLUDED"
);
//=========================================================
//=========================================================
DEFINE_SCHEDULE
(
SCHED_ENGAGE_AND_MELEE_ATTACK1,
" Tasks"
" TASK_STOP_MOVING 0"
" TASK_GET_CHASE_PATH_TO_ENEMY 40" // 40 = attack distance
" TASK_RUN_PATH 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MELEE_ATTACK1 1"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MELEE_ATTACK1 2"
" TASK_FACE_ENEMY 0"
" TASK_ANNOUNCE_ATTACK 1" // 1 = primary attack
" TASK_MELEE_ATTACK1 3"
""
" Interrupts"
" COND_NEW_ENEMY"
" COND_ENEMY_DEAD"
" COND_LIGHT_DAMAGE"
" COND_HEAVY_DAMAGE"
" COND_ENEMY_OCCLUDED"
);
AI_END_CUSTOM_NPC()
// DECLARE_TASK( TASK_ASW_TRACK_AND_FIRE )
Reference in New Issue View Git Blame Copy Permalink