raven
/
jediacademy
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
jediacademy/codemp/game/NPC_behavior.c

1749 lines
50 KiB
C
Raw Permalink Blame History

//NPC_behavior.cpp
/*
FIXME - MCG:
These all need to make use of the snapshots. Write something that can look for only specific
things in a snapshot or just go through the snapshot every frame and save the info in case
we need it...
*/
#include "b_local.h"
#include "g_nav.h"
#include "../icarus/Q3_Interface.h"
extern qboolean showBBoxes;
extern vec3_t NPCDEBUG_BLUE;
extern void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
extern void NPC_CheckGetNewWeapon( void );
#include "../namespace_begin.h"
extern qboolean PM_InKnockDown( playerState_t *ps );
#include "../namespace_end.h"
extern void NPC_AimAdjust( int change );
extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);
/*
void NPC_BSAdvanceFight (void)
Advance towards your captureGoal and shoot anyone you can along the way.
*/
void NPC_BSAdvanceFight (void)
{//FIXME: IMPLEMENT
//Head to Goal if I can
//Make sure we're still headed where we want to capture
if ( NPCInfo->captureGoal )
{//FIXME: if no captureGoal, what do we do?
//VectorCopy( NPCInfo->captureGoal->r.currentOrigin, NPCInfo->tempGoal->r.currentOrigin );
//NPCInfo->goalEntity = NPCInfo->tempGoal;
NPC_SetMoveGoal( NPC, NPCInfo->captureGoal->r.currentOrigin, 16, qtrue, -1, NULL );
// NAV_ClearLastRoute(NPC);
NPCInfo->goalTime = level.time + 100000;
}
// NPC_BSRun();
NPC_CheckEnemy(qtrue, qfalse, qtrue);
//FIXME: Need melee code
if( NPC->enemy )
{//See if we can shoot him
vec3_t delta, forward;
vec3_t angleToEnemy;
vec3_t hitspot, muzzle, diff, enemy_org, enemy_head;
float distanceToEnemy;
qboolean attack_ok = qfalse;
qboolean dead_on = qfalse;
float attack_scale = 1.0;
float aim_off;
float max_aim_off = 64;
//Yaw to enemy
VectorMA(NPC->enemy->r.absmin, 0.5, NPC->enemy->r.maxs, enemy_org);
CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
VectorSubtract (enemy_org, muzzle, delta);
vectoangles ( delta, angleToEnemy );
distanceToEnemy = VectorNormalize(delta);
if(!NPC_EnemyTooFar(NPC->enemy, distanceToEnemy*distanceToEnemy, qtrue))
{
attack_ok = qtrue;
}
if(attack_ok)
{
NPC_UpdateShootAngles(angleToEnemy, qfalse, qtrue);
NPCInfo->enemyLastVisibility = enemyVisibility;
enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV);//CHECK_360|//CHECK_PVS|
if(enemyVisibility == VIS_FOV)
{//He's in our FOV
attack_ok = qtrue;
CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_head);
if(attack_ok)
{
trace_t tr;
gentity_t *traceEnt;
//are we gonna hit him if we shoot at his center?
trap_Trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
traceEnt = &g_entities[tr.entityNum];
if( traceEnt != NPC->enemy &&
(!traceEnt || !traceEnt->client || !NPC->client->enemyTeam || NPC->client->enemyTeam != traceEnt->client->playerTeam) )
{//no, so shoot for the head
attack_scale *= 0.75;
trap_Trace ( &tr, muzzle, NULL, NULL, enemy_head, NPC->s.number, MASK_SHOT );
traceEnt = &g_entities[tr.entityNum];
}
VectorCopy( tr.endpos, hitspot );
if( traceEnt == NPC->enemy || (traceEnt->client && NPC->client->enemyTeam && NPC->client->enemyTeam == traceEnt->client->playerTeam) )
{
dead_on = qtrue;
}
else
{
attack_scale *= 0.5;
if(NPC->client->playerTeam)
{
if(traceEnt && traceEnt->client && traceEnt->client->playerTeam)
{
if(NPC->client->playerTeam == traceEnt->client->playerTeam)
{//Don't shoot our own team
attack_ok = qfalse;
}
}
}
}
}
if( attack_ok )
{
//ok, now adjust pitch aim
VectorSubtract (hitspot, muzzle, delta);
vectoangles ( delta, angleToEnemy );
NPC->NPC->desiredPitch = angleToEnemy[PITCH];
NPC_UpdateShootAngles(angleToEnemy, qtrue, qfalse);
if( !dead_on )
{//We're not going to hit him directly, try a suppressing fire
//see if where we're going to shoot is too far from his origin
AngleVectors (NPCInfo->shootAngles, forward, NULL, NULL);
VectorMA ( muzzle, distanceToEnemy, forward, hitspot);
VectorSubtract(hitspot, enemy_org, diff);
aim_off = VectorLength(diff);
if(aim_off > random() * max_aim_off)//FIXME: use aim value to allow poor aim?
{
attack_scale *= 0.75;
//see if where we're going to shoot is too far from his head
VectorSubtract(hitspot, enemy_head, diff);
aim_off = VectorLength(diff);
if(aim_off > random() * max_aim_off)
{
attack_ok = qfalse;
}
}
attack_scale *= (max_aim_off - aim_off + 1)/max_aim_off;
}
}
}
}
if( attack_ok )
{
if( NPC_CheckAttack( attack_scale ))
{//check aggression to decide if we should shoot
enemyVisibility = VIS_SHOOT;
WeaponThink(qtrue);
}
else
attack_ok = qfalse;
}
//Don't do this- only for when stationary and trying to shoot an enemy
// else
// NPC->cantHitEnemyCounter++;
}
else
{//FIXME:
NPC_UpdateShootAngles(NPC->client->ps.viewangles, qtrue, qtrue);
}
if(!ucmd.forwardmove && !ucmd.rightmove)
{//We reached our captureGoal
if(trap_ICARUS_IsInitialized(NPC->s.number))
{
trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
}
}
}
void Disappear(gentity_t *self)
{
// ClientDisconnect(self);
self->s.eFlags |= EF_NODRAW;
self->think = 0;
self->nextthink = -1;
}
void MakeOwnerInvis (gentity_t *self);
void BeamOut (gentity_t *self)
{
// gentity_t *tent = G_Spawn();
/*
tent->owner = self;
tent->think = MakeOwnerInvis;
tent->nextthink = level.time + 1800;
//G_AddEvent( ent, EV_PLAYER_TELEPORT, 0 );
tent = G_TempEntity( self->client->pcurrentOrigin, EV_PLAYER_TELEPORT );
*/
//fixme: doesn't actually go away!
self->nextthink = level.time + 1500;
self->think = Disappear;
self->client->squadname = NULL;
self->client->playerTeam = self->s.teamowner = TEAM_FREE;
//self->r.svFlags |= SVF_BEAMING; //this appears unused in SP as well
}
void NPC_BSCinematic( void )
{
if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
{
WeaponThink( qtrue );
}
if ( UpdateGoal() )
{//have a goalEntity
//move toward goal, should also face that goal
NPC_MoveToGoal( qtrue );
}
if ( NPCInfo->watchTarget )
{//have an entity which we want to keep facing
//NOTE: this will override any angles set by NPC_MoveToGoal
vec3_t eyes, viewSpot, viewvec, viewangles;
CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
CalcEntitySpot( NPCInfo->watchTarget, SPOT_HEAD_LEAN, viewSpot );
VectorSubtract( viewSpot, eyes, viewvec );
vectoangles( viewvec, viewangles );
NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = viewangles[YAW];
NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch = viewangles[PITCH];
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_BSWait( void )
{
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_BSInvestigate (void)
{
/*
//FIXME: maybe allow this to be set as a tempBState in a script? Just specify the
//investigateGoal, investigateDebounceTime and investigateCount? (Needs a macro)
vec3_t invDir, invAngles, spot;
gentity_t *saveGoal;
//BS_INVESTIGATE would turn toward goal, maybe take a couple steps towards it,
//look for enemies, then turn away after your investigate counter was down-
//investigate counter goes up every time you set it...
if(level.time > NPCInfo->enemyCheckDebounceTime)
{
NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 1000);
NPC_CheckEnemy(qtrue, qfalse);
if(NPC->enemy)
{//FIXME: do anger script
NPCInfo->goalEntity = NPC->enemy;
// NAV_ClearLastRoute(NPC);
NPCInfo->behaviorState = BS_RUN_AND_SHOOT;
NPCInfo->tempBehavior = BS_DEFAULT;
NPC_AngerSound();
return;
}
}
NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
if(NPCInfo->stats.vigilance <= 1.0 && NPCInfo->eventOwner)
{
VectorCopy(NPCInfo->eventOwner->r.currentOrigin, NPCInfo->investigateGoal);
}
saveGoal = NPCInfo->goalEntity;
if( level.time > NPCInfo->walkDebounceTime )
{
vec3_t vec;
VectorSubtract(NPCInfo->investigateGoal, NPC->r.currentOrigin, vec);
vec[2] = 0;
if(VectorLength(vec) > 64)
{
if(Q_irand(0, 100) < NPCInfo->investigateCount)
{//take a full step
//NPCInfo->walkDebounceTime = level.time + 1400;
//actually finds length of my BOTH_WALK anim
NPCInfo->walkDebounceTime = PM_AnimLength( NPC->client->clientInfo.animFileIndex, BOTH_WALK1 );
}
}
}
if( level.time < NPCInfo->walkDebounceTime )
{//walk toward investigateGoal
/*
NPCInfo->goalEntity = NPCInfo->tempGoal;
// NAV_ClearLastRoute(NPC);
VectorCopy(NPCInfo->investigateGoal, NPCInfo->tempGoal->r.currentOrigin);
*/
/* NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue );
NPC_MoveToGoal( qtrue );
//FIXME: walk2?
NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_WALK1,SETANIM_FLAG_NORMAL);
ucmd.buttons |= BUTTON_WALKING;
}
else
{
NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
if(NPCInfo->hlookCount > 30)
{
if(Q_irand(0, 10) > 7)
{
NPCInfo->hlookCount = 0;
}
}
else if(NPCInfo->hlookCount < -30)
{
if(Q_irand(0, 10) > 7)
{
NPCInfo->hlookCount = 0;
}
}
else if(NPCInfo->hlookCount == 0)
{
NPCInfo->hlookCount = Q_irand(-1, 1);
}
else if(Q_irand(0, 10) > 7)
{
if(NPCInfo->hlookCount > 0)
{
NPCInfo->hlookCount++;
}
else//lookCount < 0
{
NPCInfo->hlookCount--;
}
}
if(NPCInfo->vlookCount >= 15)
{
if(Q_irand(0, 10) > 7)
{
NPCInfo->vlookCount = 0;
}
}
else if(NPCInfo->vlookCount <= -15)
{
if(Q_irand(0, 10) > 7)
{
NPCInfo->vlookCount = 0;
}
}
else if(NPCInfo->vlookCount == 0)
{
NPCInfo->vlookCount = Q_irand(-1, 1);
}
else if(Q_irand(0, 10) > 8)
{
if(NPCInfo->vlookCount > 0)
{
NPCInfo->vlookCount++;
}
else//lookCount < 0
{
NPCInfo->vlookCount--;
}
}
//turn toward investigateGoal
CalcEntitySpot( NPC, SPOT_HEAD, spot );
VectorSubtract(NPCInfo->investigateGoal, spot, invDir);
VectorNormalize(invDir);
vectoangles(invDir, invAngles);
NPCInfo->desiredYaw = AngleNormalize360(invAngles[YAW] + NPCInfo->hlookCount);
NPCInfo->desiredPitch = AngleNormalize360(invAngles[PITCH] + NPCInfo->hlookCount);
}
NPC_UpdateAngles(qtrue, qtrue);
NPCInfo->goalEntity = saveGoal;
// NAV_ClearLastRoute(NPC);
if(level.time > NPCInfo->investigateDebounceTime)
{
NPCInfo->tempBehavior = BS_DEFAULT;
}
NPC_CheckSoundEvents();
*/
}
qboolean NPC_CheckInvestigate( int alertEventNum )
{
gentity_t *owner = level.alertEvents[alertEventNum].owner;
int invAdd = level.alertEvents[alertEventNum].level;
vec3_t soundPos;
float soundRad = level.alertEvents[alertEventNum].radius;
float earshot = NPCInfo->stats.earshot;
VectorCopy( level.alertEvents[alertEventNum].position, soundPos );
//NOTE: Trying to preserve previous investigation behavior
if ( !owner )
{
return qfalse;
}
if ( owner->s.eType != ET_PLAYER && owner->s.eType != ET_NPC && owner == NPCInfo->goalEntity )
{
return qfalse;
}
if ( owner->s.eFlags & EF_NODRAW )
{
return qfalse;
}
if ( owner->flags & FL_NOTARGET )
{
return qfalse;
}
if ( soundRad < earshot )
{
return qfalse;
}
//if(!trap_InPVSIgnorePortals(ent->r.currentOrigin, NPC->r.currentOrigin))//should we be able to hear through areaportals?
if ( !trap_InPVS( soundPos, NPC->r.currentOrigin ) )
{//can hear through doors?
return qfalse;
}
if ( owner->client && owner->client->playerTeam && NPC->client->playerTeam && owner->client->playerTeam != NPC->client->playerTeam )
{
if( (float)NPCInfo->investigateCount >= (NPCInfo->stats.vigilance*200) && owner )
{//If investigateCount == 10, just take it as enemy and go
if ( ValidEnemy( owner ) )
{//FIXME: run angerscript
G_SetEnemy( NPC, owner );
NPCInfo->goalEntity = NPC->enemy;
NPCInfo->goalRadius = 12;
NPCInfo->behaviorState = BS_HUNT_AND_KILL;
return qtrue;
}
}
else
{
NPCInfo->investigateCount += invAdd;
}
//run awakescript
G_ActivateBehavior(NPC, BSET_AWAKE);
/*
if ( Q_irand(0, 10) > 7 )
{
NPC_AngerSound();
}
*/
//NPCInfo->hlookCount = NPCInfo->vlookCount = 0;
NPCInfo->eventOwner = owner;
VectorCopy( soundPos, NPCInfo->investigateGoal );
if ( NPCInfo->investigateCount > 20 )
{
NPCInfo->investigateDebounceTime = level.time + 10000;
}
else
{
NPCInfo->investigateDebounceTime = level.time + (NPCInfo->investigateCount*500);
}
NPCInfo->tempBehavior = BS_INVESTIGATE;
return qtrue;
}
return qfalse;
}
/*
void NPC_BSSleep( void )
*/
void NPC_BSSleep( void )
{
int alertEvent = NPC_CheckAlertEvents( qtrue, qfalse, -1, qfalse, AEL_MINOR );
//There is an event to look at
if ( alertEvent >= 0 )
{
G_ActivateBehavior(NPC, BSET_AWAKE);
return;
}
/*
if ( level.time > NPCInfo->enemyCheckDebounceTime )
{
if ( NPC_CheckSoundEvents() != -1 )
{//only 1 alert per second per 0.1 of vigilance
NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 10000);
G_ActivateBehavior(NPC, BSET_AWAKE);
}
}
*/
}
extern qboolean NPC_MoveDirClear( int forwardmove, int rightmove, qboolean reset );
void NPC_BSFollowLeader (void)
{
vec3_t vec;
float leaderDist;
visibility_t leaderVis;
int curAnim;
if ( !NPC->client->leader )
{//ok, stand guard until we find an enemy
if( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
{
NPCInfo->tempBehavior = BS_DEFAULT;
}
else
{
NPCInfo->tempBehavior = BS_STAND_GUARD;
NPC_BSStandGuard();
}
return;
}
if ( !NPC->enemy )
{//no enemy, find one
NPC_CheckEnemy( NPCInfo->confusionTime<level.time, qfalse, qtrue );//don't find new enemy if this is tempbehav
if ( NPC->enemy )
{//just found one
NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
}
else
{
if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
{
int eventID = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_MINOR );
if ( level.alertEvents[eventID].level >= AEL_SUSPICIOUS && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
{
NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
if ( !level.alertEvents[eventID].owner ||
!level.alertEvents[eventID].owner->client ||
level.alertEvents[eventID].owner->health <= 0 ||
level.alertEvents[eventID].owner->client->playerTeam != NPC->client->enemyTeam )
{//not an enemy
}
else
{
//FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him? Or just let combat AI handle this... (act as if you lost him)
G_SetEnemy( NPC, level.alertEvents[eventID].owner );
NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
NPCInfo->enemyLastSeenTime = level.time;
TIMER_Set( NPC, "attackDelay", Q_irand( 500, 1000 ) );
}
}
}
}
if ( !NPC->enemy )
{
if ( NPC->client->leader
&& NPC->client->leader->enemy
&& NPC->client->leader->enemy != NPC
&& ( (NPC->client->leader->enemy->client&&NPC->client->leader->enemy->client->playerTeam==NPC->client->enemyTeam)
||(/*NPC->client->leader->enemy->r.svFlags&SVF_NONNPC_ENEMY*/0&&NPC->client->leader->enemy->alliedTeam==NPC->client->enemyTeam) )
&& NPC->client->leader->enemy->health > 0 )
{ //rwwFIXMEFIXME: use SVF_NONNPC_ENEMY?
G_SetEnemy( NPC, NPC->client->leader->enemy );
NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
NPCInfo->enemyLastSeenTime = level.time;
}
}
}
else
{
if ( NPC->enemy->health <= 0 || (NPC->enemy->flags&FL_NOTARGET) )
{
G_ClearEnemy( NPC );
if ( NPCInfo->enemyCheckDebounceTime > level.time + 1000 )
{
NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 1000, 2000 );
}
}
else if ( NPC->client->ps.weapon && NPCInfo->enemyCheckDebounceTime < level.time )
{
NPC_CheckEnemy( (NPCInfo->confusionTime<level.time||NPCInfo->tempBehavior!=BS_FOLLOW_LEADER), qfalse, qtrue );//don't find new enemy if this is tempbehav
}
}
if ( NPC->enemy && NPC->client->ps.weapon )
{//If have an enemy, face him and fire
if ( NPC->client->ps.weapon == WP_SABER )//|| NPCInfo->confusionTime>level.time )
{//lightsaber user or charmed enemy
if ( NPCInfo->tempBehavior != BS_FOLLOW_LEADER )
{//not already in a temp bState
//go after the guy
NPCInfo->tempBehavior = BS_HUNT_AND_KILL;
NPC_UpdateAngles(qtrue, qtrue);
return;
}
}
enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|CHECK_PVS|
if ( enemyVisibility > VIS_PVS )
{//face
vec3_t enemy_org, muzzle, delta, angleToEnemy;
float distanceToEnemy;
CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
NPC_AimWiggle( enemy_org );
CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
VectorSubtract( enemy_org, muzzle, delta);
vectoangles( delta, angleToEnemy );
distanceToEnemy = VectorNormalize( delta );
NPCInfo->desiredYaw = angleToEnemy[YAW];
NPCInfo->desiredPitch = angleToEnemy[PITCH];
NPC_UpdateFiringAngles( qtrue, qtrue );
if ( enemyVisibility >= VIS_SHOOT )
{//shoot
NPC_AimAdjust( 2 );
if ( NPC_GetHFOVPercentage( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.hfov ) > 0.6f
&& NPC_GetHFOVPercentage( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.vfov ) > 0.5f )
{//actually withing our front cone
WeaponThink( qtrue );
}
}
else
{
NPC_AimAdjust( 1 );
}
//NPC_CheckCanAttack(1.0, qfalse);
}
else
{
NPC_AimAdjust( -1 );
}
}
else
{//FIXME: combine with vector calc below
vec3_t head, leaderHead, delta, angleToLeader;
CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
CalcEntitySpot( NPC, SPOT_HEAD, head );
VectorSubtract (leaderHead, head, delta);
vectoangles ( delta, angleToLeader );
VectorNormalize(delta);
NPC->NPC->desiredYaw = angleToLeader[YAW];
NPC->NPC->desiredPitch = angleToLeader[PITCH];
NPC_UpdateAngles(qtrue, qtrue);
}
//leader visible?
leaderVis = NPC_CheckVisibility( NPC->client->leader, CHECK_PVS|CHECK_360|CHECK_SHOOT );// ent->e_UseFunc = useF_NULL;
//Follow leader, stay within visibility and a certain distance, maintain a distance from.
curAnim = NPC->client->ps.legsAnim;
if ( curAnim != BOTH_ATTACK1 && curAnim != BOTH_ATTACK2 && curAnim != BOTH_ATTACK3 && curAnim != BOTH_MELEE1 && curAnim != BOTH_MELEE2 )
{//Don't move toward leader if we're in a full-body attack anim
//FIXME, use IdealDistance to determine if we need to close distance
float followDist = 96.0f;//FIXME: If there are enmies, make this larger?
float backupdist, walkdist, minrundist;
float leaderHDist;
if ( NPCInfo->followDist )
{
followDist = NPCInfo->followDist;
}
backupdist = followDist/2.0f;
walkdist = followDist*0.83;
minrundist = followDist*1.33;
VectorSubtract(NPC->client->leader->r.currentOrigin, NPC->r.currentOrigin, vec);
leaderDist = VectorLength( vec );//FIXME: make this just nav distance?
//never get within their radius horizontally
vec[2] = 0;
leaderHDist = VectorLength( vec );
if( leaderHDist > backupdist && (leaderVis != VIS_SHOOT || leaderDist > walkdist) )
{//We should close in?
NPCInfo->goalEntity = NPC->client->leader;
NPC_SlideMoveToGoal();
if ( leaderVis == VIS_SHOOT && leaderDist < minrundist )
{
ucmd.buttons |= BUTTON_WALKING;
}
}
else if ( leaderDist < backupdist )
{//We should back off?
NPCInfo->goalEntity = NPC->client->leader;
NPC_SlideMoveToGoal();
//reversing direction
ucmd.forwardmove = -ucmd.forwardmove;
ucmd.rightmove = -ucmd.rightmove;
VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
}//otherwise, stay where we are
//check for do not enter and stop if there's one there...
if ( ucmd.forwardmove || ucmd.rightmove || VectorCompare( vec3_origin, NPC->client->ps.moveDir ) )
{
NPC_MoveDirClear( ucmd.forwardmove, ucmd.rightmove, qtrue );
}
}
}
#define APEX_HEIGHT 200.0f
#define PARA_WIDTH (sqrt(APEX_HEIGHT)+sqrt(APEX_HEIGHT))
#define JUMP_SPEED 200.0f
void NPC_BSJump (void)
{
vec3_t dir, angles, p1, p2, apex;
float time, height, forward, z, xy, dist, yawError, apexHeight;
if( !NPCInfo->goalEntity )
{//Should have task completed the navgoal
return;
}
if ( NPCInfo->jumpState != JS_JUMPING && NPCInfo->jumpState != JS_LANDING )
{
//Face navgoal
VectorSubtract(NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir);
vectoangles(dir, angles);
NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
}
NPC_UpdateAngles ( qtrue, qtrue );
yawError = AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw );
//We don't really care about pitch here
switch ( NPCInfo->jumpState )
{
case JS_FACING:
if ( yawError < MIN_ANGLE_ERROR )
{//Facing it, Start crouching
NPC_SetAnim(NPC, SETANIM_LEGS, BOTH_CROUCH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
NPCInfo->jumpState = JS_CROUCHING;
}
break;
case JS_CROUCHING:
if ( NPC->client->ps.legsTimer > 0 )
{//Still playing crouching anim
return;
}
//Create a parabola
if ( NPC->r.currentOrigin[2] > NPCInfo->goalEntity->r.currentOrigin[2] )
{
VectorCopy( NPC->r.currentOrigin, p1 );
VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p2 );
}
else if ( NPC->r.currentOrigin[2] < NPCInfo->goalEntity->r.currentOrigin[2] )
{
VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p1 );
VectorCopy( NPC->r.currentOrigin, p2 );
}
else
{
VectorCopy( NPC->r.currentOrigin, p1 );
VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p2 );
}
//z = xy*xy
VectorSubtract( p2, p1, dir );
dir[2] = 0;
//Get xy and z diffs
xy = VectorNormalize( dir );
z = p1[2] - p2[2];
apexHeight = APEX_HEIGHT/2;
/*
//Determine most desirable apex height
apexHeight = (APEX_HEIGHT * PARA_WIDTH/xy) + (APEX_HEIGHT * z/128);
if ( apexHeight < APEX_HEIGHT * 0.5 )
{
apexHeight = APEX_HEIGHT*0.5;
}
else if ( apexHeight > APEX_HEIGHT * 2 )
{
apexHeight = APEX_HEIGHT*2;
}
*/
//FIXME: length of xy will change curve of parabola, need to account for this
//somewhere... PARA_WIDTH
z = (sqrt(apexHeight + z) - sqrt(apexHeight));
assert(z >= 0);
// Com_Printf("apex is %4.2f percent from p1: ", (xy-z)*0.5/xy*100.0f);
xy -= z;
xy *= 0.5;
assert(xy > 0);
VectorMA( p1, xy, dir, apex );
apex[2] += apexHeight;
VectorCopy(apex, NPC->pos1);
//Now we have the apex, aim for it
height = apex[2] - NPC->r.currentOrigin[2];
time = sqrt( height / ( .5 * NPC->client->ps.gravity ) );
if ( !time )
{
// Com_Printf("ERROR no time in jump\n");
return;
}
// set s.origin2 to the push velocity
VectorSubtract ( apex, NPC->r.currentOrigin, NPC->client->ps.velocity );
NPC->client->ps.velocity[2] = 0;
dist = VectorNormalize( NPC->client->ps.velocity );
forward = dist / time;
VectorScale( NPC->client->ps.velocity, forward, NPC->client->ps.velocity );
NPC->client->ps.velocity[2] = time * NPC->client->ps.gravity;
// Com_Printf( "%s jumping %s, gravity at %4.0f percent\n", NPC->targetname, vtos(NPC->client->ps.velocity), NPC->client->ps.gravity/8.0f );
NPC->flags |= FL_NO_KNOCKBACK;
NPCInfo->jumpState = JS_JUMPING;
//FIXME: jumpsound?
break;
case JS_JUMPING:
if ( showBBoxes )
{
VectorAdd(NPC->r.mins, NPC->pos1, p1);
VectorAdd(NPC->r.maxs, NPC->pos1, p2);
G_Cube( p1, p2, NPCDEBUG_BLUE, 0.5 );
}
if ( NPC->s.groundEntityNum != ENTITYNUM_NONE)
{//Landed, start landing anim
//FIXME: if the
VectorClear(NPC->client->ps.velocity);
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_LAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
NPCInfo->jumpState = JS_LANDING;
//FIXME: landsound?
}
else if ( NPC->client->ps.legsTimer > 0 )
{//Still playing jumping anim
//FIXME: apply jump velocity here, a couple frames after start, not right away
return;
}
else
{//still in air, but done with jump anim, play inair anim
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_INAIR1, SETANIM_FLAG_OVERRIDE);
}
break;
case JS_LANDING:
if ( NPC->client->ps.legsTimer > 0 )
{//Still playing landing anim
return;
}
else
{
NPCInfo->jumpState = JS_WAITING;
//task complete no matter what...
NPC_ClearGoal();
NPCInfo->goalTime = level.time;
NPCInfo->aiFlags &= ~NPCAI_MOVING;
ucmd.forwardmove = 0;
NPC->flags &= ~FL_NO_KNOCKBACK;
//Return that the goal was reached
trap_ICARUS_TaskIDComplete( NPC, TID_MOVE_NAV );
//Or should we keep jumping until reached goal?
/*
NPCInfo->goalEntity = UpdateGoal();
if ( !NPCInfo->goalEntity )
{
NPC->flags &= ~FL_NO_KNOCKBACK;
Q3_TaskIDComplete( NPC, TID_MOVE_NAV );
}
*/
}
break;
case JS_WAITING:
default:
NPCInfo->jumpState = JS_FACING;
break;
}
}
void NPC_BSRemove (void)
{
NPC_UpdateAngles ( qtrue, qtrue );
if( !trap_InPVS( NPC->r.currentOrigin, g_entities[0].r.currentOrigin ) )//FIXME: use cg.vieworg?
{ //rwwFIXMEFIXME: Care about all clients instead of just 0?
G_UseTargets2( NPC, NPC, NPC->target3 );
NPC->s.eFlags |= EF_NODRAW;
NPC->s.eType = ET_INVISIBLE;
NPC->r.contents = 0;
NPC->health = 0;
NPC->targetname = NULL;
//Disappear in half a second
NPC->think = G_FreeEntity;
NPC->nextthink = level.time + FRAMETIME;
}//FIXME: else allow for out of FOV???
}
void NPC_BSSearch (void)
{
NPC_CheckEnemy(qtrue, qfalse, qtrue);
//Look for enemies, if find one:
if ( NPC->enemy )
{
if( NPCInfo->tempBehavior == BS_SEARCH )
{//if tempbehavior, set tempbehavior to default
NPCInfo->tempBehavior = BS_DEFAULT;
}
else
{//if bState, change to run and shoot
NPCInfo->behaviorState = BS_HUNT_AND_KILL;
NPC_BSRunAndShoot();
}
return;
}
//FIXME: what if our goalEntity is not NULL and NOT our tempGoal - they must
//want us to do something else? If tempBehavior, just default, else set
//to run and shoot...?
//FIXME: Reimplement
if ( !NPCInfo->investigateDebounceTime )
{//On our way to a tempGoal
float minGoalReachedDistSquared = 32*32;
vec3_t vec;
//Keep moving toward our tempGoal
NPCInfo->goalEntity = NPCInfo->tempGoal;
VectorSubtract ( NPCInfo->tempGoal->r.currentOrigin, NPC->r.currentOrigin, vec);
if ( vec[2] < 24 )
{
vec[2] = 0;
}
if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
{
/*
//FIXME: can't get the radius...
float wpRadSq = waypoints[NPCInfo->tempGoal->waypoint].radius * waypoints[NPCInfo->tempGoal->waypoint].radius;
if ( minGoalReachedDistSquared > wpRadSq )
{
minGoalReachedDistSquared = wpRadSq;
}
*/
minGoalReachedDistSquared = 32*32;//12*12;
}
if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
{
//Close enough, just got there
NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if ( ( NPCInfo->homeWp == WAYPOINT_NONE ) || ( NPC->waypoint == WAYPOINT_NONE ) )
{
//Heading for or at an invalid waypoint, get out of this bState
if( NPCInfo->tempBehavior == BS_SEARCH )
{//if tempbehavior, set tempbehavior to default
NPCInfo->tempBehavior = BS_DEFAULT;
}
else
{//if bState, change to stand guard
NPCInfo->behaviorState = BS_STAND_GUARD;
NPC_BSRunAndShoot();
}
return;
}
if ( NPC->waypoint == NPCInfo->homeWp )
{
//Just Reached our homeWp, if this is the first time, run your lostenemyscript
if ( NPCInfo->aiFlags & NPCAI_ENROUTE_TO_HOMEWP )
{
NPCInfo->aiFlags &= ~NPCAI_ENROUTE_TO_HOMEWP;
G_ActivateBehavior( NPC, BSET_LOSTENEMY );
}
}
//Com_Printf("Got there.\n");
//Com_Printf("Looking...");
if( !Q_irand(0, 1) )
{
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_NORMAL);
}
else
{
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_NORMAL);
}
NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
}
else
{
NPC_MoveToGoal( qtrue );
}
}
else
{
//We're there
if ( NPCInfo->investigateDebounceTime > level.time )
{
//Still waiting around for a bit
//Turn angles every now and then to look around
if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
{
if ( !Q_irand( 0, 30 ) )
{
int numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
int branchNum = Q_irand( 0, numEdges - 1 );
vec3_t branchPos, lookDir;
int nextWp = trap_Nav_GetNodeEdge( NPCInfo->tempGoal->waypoint, branchNum );
trap_Nav_GetNodePosition( nextWp, branchPos );
VectorSubtract( branchPos, NPCInfo->tempGoal->r.currentOrigin, lookDir );
NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + flrand( -45, 45 ) );
}
//pick an angle +-45 degrees off of the dir of a random branch
//from NPCInfo->tempGoal->waypoint
//int branch = Q_irand( 0, (waypoints[NPCInfo->tempGoal->waypoint].numNeighbors - 1) );
//int nextWp = waypoints[NPCInfo->tempGoal->waypoint].nextWaypoint[branch][NPC->client->moveType];
//vec3_t lookDir;
//VectorSubtract( waypoints[nextWp].origin, NPCInfo->tempGoal->r.currentOrigin, lookDir );
//Look in that direction +- 45 degrees
//NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + Q_flrand( -45, 45 ) );
}
}
//Com_Printf(".");
}
else
{//Just finished waiting
NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if ( NPC->waypoint == NPCInfo->homeWp )
{
int numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
int branchNum = Q_irand( 0, numEdges - 1 );
int nextWp = trap_Nav_GetNodeEdge( NPCInfo->homeWp, branchNum );
trap_Nav_GetNodePosition( nextWp, NPCInfo->tempGoal->r.currentOrigin );
NPCInfo->tempGoal->waypoint = nextWp;
}
/*
//Pick a random branch
int branch = Q_irand( 0, (waypoints[NPCInfo->homeWp].numNeighbors - 1) );
int nextWp = waypoints[NPCInfo->homeWp].nextWaypoint[branch][NPC->client->moveType];
VectorCopy( waypoints[nextWp].origin, NPCInfo->tempGoal->r.currentOrigin );
NPCInfo->tempGoal->waypoint = nextWp;
//Com_Printf("\nHeading for wp %d...\n", waypoints[NPCInfo->homeWp].nextWaypoint[branch][NPC->client->moveType]);
*/
}
else
{//At a branch, so return home
trap_Nav_GetNodePosition( NPCInfo->homeWp, NPCInfo->tempGoal->r.currentOrigin );
NPCInfo->tempGoal->waypoint = NPCInfo->homeWp;
/*
VectorCopy( waypoints[NPCInfo->homeWp].origin, NPCInfo->tempGoal->r.currentOrigin );
NPCInfo->tempGoal->waypoint = NPCInfo->homeWp;
//Com_Printf("\nHeading for wp %d...\n", NPCInfo->homeWp);
*/
}
NPCInfo->investigateDebounceTime = 0;
//Start moving toward our tempGoal
NPCInfo->goalEntity = NPCInfo->tempGoal;
NPC_MoveToGoal( qtrue );
}
}
NPC_UpdateAngles( qtrue, qtrue );
}
/*
-------------------------
NPC_BSSearchStart
-------------------------
*/
void NPC_BSSearchStart( int homeWp, bState_t bState )
{
//FIXME: Reimplement
if ( homeWp == WAYPOINT_NONE )
{
homeWp = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if( NPC->waypoint == WAYPOINT_NONE )
{
NPC->waypoint = homeWp;
}
}
NPCInfo->homeWp = homeWp;
NPCInfo->tempBehavior = bState;
NPCInfo->aiFlags |= NPCAI_ENROUTE_TO_HOMEWP;
NPCInfo->investigateDebounceTime = 0;
trap_Nav_GetNodePosition( homeWp, NPCInfo->tempGoal->r.currentOrigin );
NPCInfo->tempGoal->waypoint = homeWp;
//Com_Printf("\nHeading for wp %d...\n", NPCInfo->homeWp);
}
/*
-------------------------
NPC_BSNoClip
Use in extreme circumstances only
-------------------------
*/
void NPC_BSNoClip ( void )
{
if ( UpdateGoal() )
{
vec3_t dir, forward, right, angles, up = {0, 0, 1};
float fDot, rDot, uDot;
VectorSubtract( NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir );
vectoangles( dir, angles );
NPCInfo->desiredYaw = angles[YAW];
AngleVectors( NPC->r.currentAngles, forward, right, NULL );
VectorNormalize( dir );
fDot = DotProduct(forward, dir) * 127;
rDot = DotProduct(right, dir) * 127;
uDot = DotProduct(up, dir) * 127;
ucmd.forwardmove = floor(fDot);
ucmd.rightmove = floor(rDot);
ucmd.upmove = floor(uDot);
}
else
{
//Cut velocity?
VectorClear( NPC->client->ps.velocity );
}
NPC_UpdateAngles( qtrue, qtrue );
}
void NPC_BSWander (void)
{//FIXME: don't actually go all the way to the next waypoint, just move in fits and jerks...?
if ( !NPCInfo->investigateDebounceTime )
{//Starting out
float minGoalReachedDistSquared = 64;//32*32;
vec3_t vec;
//Keep moving toward our tempGoal
NPCInfo->goalEntity = NPCInfo->tempGoal;
VectorSubtract ( NPCInfo->tempGoal->r.currentOrigin, NPC->r.currentOrigin, vec);
if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
{
minGoalReachedDistSquared = 64;
}
if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
{
//Close enough, just got there
NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if( !Q_irand(0, 1) )
{
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_NORMAL);
}
else
{
NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_NORMAL);
}
//Just got here, so Look around for a while
NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
}
else
{
//Keep moving toward goal
NPC_MoveToGoal( qtrue );
}
}
else
{
//We're there
if ( NPCInfo->investigateDebounceTime > level.time )
{
//Still waiting around for a bit
//Turn angles every now and then to look around
if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
{
if ( !Q_irand( 0, 30 ) )
{
int numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
int branchNum = Q_irand( 0, numEdges - 1 );
vec3_t branchPos, lookDir;
int nextWp = trap_Nav_GetNodeEdge( NPCInfo->tempGoal->waypoint, branchNum );
trap_Nav_GetNodePosition( nextWp, branchPos );
VectorSubtract( branchPos, NPCInfo->tempGoal->r.currentOrigin, lookDir );
NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + flrand( -45, 45 ) );
}
}
}
}
else
{//Just finished waiting
NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
if ( NPC->waypoint != WAYPOINT_NONE )
{
int numEdges = trap_Nav_GetNodeNumEdges( NPC->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
int branchNum = Q_irand( 0, numEdges - 1 );
int nextWp = trap_Nav_GetNodeEdge( NPC->waypoint, branchNum );
trap_Nav_GetNodePosition( nextWp, NPCInfo->tempGoal->r.currentOrigin );
NPCInfo->tempGoal->waypoint = nextWp;
}
NPCInfo->investigateDebounceTime = 0;
//Start moving toward our tempGoal
NPCInfo->goalEntity = NPCInfo->tempGoal;
NPC_MoveToGoal( qtrue );
}
}
}
NPC_UpdateAngles( qtrue, qtrue );
}
/*
void NPC_BSFaceLeader (void)
{
vec3_t head, leaderHead, delta, angleToLeader;
if ( !NPC->client->leader )
{//uh.... okay.
return;
}
CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
CalcEntitySpot( NPC, SPOT_HEAD, head );
VectorSubtract( leaderHead, head, delta );
vectoangles( delta, angleToLeader );
VectorNormalize( delta );
NPC->NPC->desiredYaw = angleToLeader[YAW];
NPC->NPC->desiredPitch = angleToLeader[PITCH];
NPC_UpdateAngles(qtrue, qtrue);
}
*/
/*
-------------------------
NPC_BSFlee
-------------------------
*/
extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern void WP_DropWeapon( gentity_t *dropper, vec3_t velocity );
extern void ChangeWeapon( gentity_t *ent, int newWeapon );
void NPC_Surrender( void )
{//FIXME: say "don't shoot!" if we weren't already surrendering
if ( NPC->client->ps.weaponTime || PM_InKnockDown( &NPC->client->ps ) )
{
return;
}
if ( NPC->s.weapon != WP_NONE &&
NPC->s.weapon != WP_STUN_BATON &&
NPC->s.weapon != WP_SABER )
{
//WP_DropWeapon( NPC, NULL ); //rwwFIXMEFIXME: Do this (gonna need a system for notifying client of removal)
}
if ( NPCInfo->surrenderTime < level.time - 5000 )
{//haven't surrendered for at least 6 seconds, tell them what you're doing
//FIXME: need real dialogue EV_SURRENDER
NPCInfo->blockedSpeechDebounceTime = 0;//make sure we say this
G_AddVoiceEvent( NPC, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 3000 );
}
// NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_SURRENDER_START, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
// NPC->client->ps.torsoTimer = 1000;
NPCInfo->surrenderTime = level.time + 1000;//stay surrendered for at least 1 second
//FIXME: while surrendering, make a big sight/sound alert? Or G_AlertTeam?
}
qboolean NPC_CheckSurrender( void )
{
if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV )
&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE
&& !NPC->client->ps.weaponTime && !PM_InKnockDown( &NPC->client->ps )
&& NPC->enemy && NPC->enemy->client && NPC->enemy->enemy == NPC && NPC->enemy->s.weapon != WP_NONE && NPC->enemy->s.weapon != WP_STUN_BATON
&& NPC->enemy->health > 20 && NPC->enemy->painDebounceTime < level.time - 3000 && NPC->enemy->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] < level.time - 1000 )
{//don't surrender if scripted to run somewhere or if we're in the air or if we're busy or if we don't have an enemy or if the enemy is not mad at me or is hurt or not a threat or busy being attacked
//FIXME: even if not in a group, don't surrender if there are other enemies in the PVS and within a certain range?
if ( NPC->s.weapon != WP_ROCKET_LAUNCHER
&& NPC->s.weapon != WP_REPEATER
&& NPC->s.weapon != WP_FLECHETTE
&& NPC->s.weapon != WP_SABER )
{//jedi and heavy weapons guys never surrender
//FIXME: rework all this logic into some orderly fashion!!!
if ( NPC->s.weapon != WP_NONE )
{//they have a weapon so they'd have to drop it to surrender
//don't give up unless low on health
if ( NPC->health > 25 /*|| NPC->health >= NPC->max_health*/ )
{ //rwwFIXMEFIXME: Keep max health not a ps state?
return qfalse;
}
//if ( g_crosshairEntNum == NPC->s.number && NPC->painDebounceTime > level.time )
if (NPC_SomeoneLookingAtMe(NPC) && NPC->painDebounceTime > level.time)
{//if he just shot me, always give up
//fall through
}
else
{//don't give up unless facing enemy and he's very close
if ( !InFOV( NPC->enemy, NPC, 60, 30 ) )
{//I'm not looking at them
return qfalse;
}
else if ( DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) < 65536/*256*256*/ )
{//they're not close
return qfalse;
}
else if ( !trap_InPVS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
{//they're not in the same room
return qfalse;
}
}
}
//fixme: this logic keeps making npc's randomly surrender
/*
if ( NPCInfo->group && NPCInfo->group->numGroup <= 1 )
{//I'm alone but I was in a group//FIXME: surrender anyway if just melee or no weap?
if ( NPC->s.weapon == WP_NONE
//NPC has a weapon
|| (NPC->enemy && NPC->enemy->s.number < MAX_CLIENTS)
|| (NPC->enemy->s.weapon == WP_SABER&&NPC->enemy->client&&!NPC->enemy->client->ps.saberHolstered)
|| (NPC->enemy->NPC && NPC->enemy->NPC->group && NPC->enemy->NPC->group->numGroup > 2) )
{//surrender only if have no weapon or fighting a player or jedi or if we are outnumbered at least 3 to 1
if ( (NPC->enemy && NPC->enemy->s.number < MAX_CLIENTS) )
{//player is the guy I'm running from
//if ( g_crosshairEntNum == NPC->s.number )
if (NPC_SomeoneLookingAtMe(NPC))
{//give up if player is aiming at me
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return qtrue;
}
else if ( NPC->enemy->s.weapon == WP_SABER )
{//player is using saber
if ( InFOV( NPC, NPC->enemy, 60, 30 ) )
{//they're looking at me
if ( DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) < 16384 )
{//they're close
if ( trap_InPVS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
{//they're in the same room
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return qtrue;
}
}
}
}
}
else if ( NPC->enemy )
{//???
//should NPC's surrender to others?
if ( InFOV( NPC, NPC->enemy, 30, 30 ) )
{//they're looking at me
if ( DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) < 4096 )
{//they're close
if ( trap_InPVS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
{//they're in the same room
//FIXME: should player-team NPCs not fire on surrendered NPCs?
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return qtrue;
}
}
}
}
}
}
*/
}
}
return qfalse;
}
void NPC_BSFlee( void )
{//FIXME: keep checking for danger
gentity_t *goal;
if ( TIMER_Done( NPC, "flee" ) && NPCInfo->tempBehavior == BS_FLEE )
{
NPCInfo->tempBehavior = BS_DEFAULT;
NPCInfo->squadState = SQUAD_IDLE;
//FIXME: should we set some timer to make him stay in this spot for a bit,
//so he doesn't just suddenly turn around and come back at the enemy?
//OR, just stop running toward goal for last second or so of flee?
}
if ( NPC_CheckSurrender() )
{
return;
}
goal = NPCInfo->goalEntity;
if ( !goal )
{
goal = NPCInfo->lastGoalEntity;
if ( !goal )
{//???!!!
goal = NPCInfo->tempGoal;
}
}
if ( goal )
{
qboolean moved;
qboolean reverseCourse = qtrue;
//FIXME: if no weapon, find one and run to pick it up?
//Let's try to find a waypoint that gets me away from this thing
if ( NPC->waypoint == WAYPOINT_NONE )
{
NPC->waypoint = NAV_GetNearestNode( NPC, NPC->lastWaypoint );
}
if ( NPC->waypoint != WAYPOINT_NONE )
{
int numEdges = trap_Nav_GetNodeNumEdges( NPC->waypoint );
if ( numEdges != WAYPOINT_NONE )
{
vec3_t dangerDir;
int nextWp;
int branchNum;
VectorSubtract( NPCInfo->investigateGoal, NPC->r.currentOrigin, dangerDir );
VectorNormalize( dangerDir );
for ( branchNum = 0; branchNum < numEdges; branchNum++ )
{
vec3_t branchPos, runDir;
nextWp = trap_Nav_GetNodeEdge( NPC->waypoint, branchNum );
trap_Nav_GetNodePosition( nextWp, branchPos );
VectorSubtract( branchPos, NPC->r.currentOrigin, runDir );
VectorNormalize( runDir );
if ( DotProduct( runDir, dangerDir ) > flrand( 0, 0.5 ) )
{//don't run toward danger
continue;
}
//FIXME: don't want to ping-pong back and forth
NPC_SetMoveGoal( NPC, branchPos, 0, qtrue, -1, NULL );
reverseCourse = qfalse;
break;
}
}
}
moved = NPC_MoveToGoal( qfalse );//qtrue? (do try to move straight to (away from) goal)
if ( NPC->s.weapon == WP_NONE && (moved == qfalse || reverseCourse) )
{//No weapon and no escape route... Just cower? Need anim.
NPC_Surrender();
NPC_UpdateAngles( qtrue, qtrue );
return;
}
//If our move failed, then just run straight away from our goal
//FIXME: We really shouldn't do this.
if ( moved == qfalse )
{
vec3_t dir;
float dist;
if ( reverseCourse )
{
VectorSubtract( NPC->r.currentOrigin, goal->r.currentOrigin, dir );
}
else
{
VectorSubtract( goal->r.currentOrigin, NPC->r.currentOrigin, dir );
}
NPCInfo->distToGoal = dist = VectorNormalize( dir );
NPCInfo->desiredYaw = vectoyaw( dir );
NPCInfo->desiredPitch = 0;
ucmd.forwardmove = 127;
}
else if ( reverseCourse )
{
//ucmd.forwardmove *= -1;
//ucmd.rightmove *= -1;
//VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
NPCInfo->desiredYaw *= -1;
}
//FIXME: can stop after a safe distance?
//ucmd.upmove = 0;
ucmd.buttons &= ~BUTTON_WALKING;
//FIXME: what do we do once we've gotten to our goal?
}
NPC_UpdateAngles( qtrue, qtrue );
NPC_CheckGetNewWeapon();
}
void NPC_StartFlee( gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax )
{
int cp = -1;
if ( trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
{//running somewhere that a script requires us to go, don't interrupt that!
return;
}
//if have a fleescript, run that instead
if ( G_ActivateBehavior( NPC, BSET_FLEE ) )
{
return;
}
//FIXME: play a flee sound? Appropriate to situation?
if ( enemy )
{
G_SetEnemy( NPC, enemy );
}
//FIXME: if don't have a weapon, find nearest one we have a route to and run for it?
if ( dangerLevel > AEL_DANGER || NPC->s.weapon == WP_NONE || ((!NPCInfo->group || NPCInfo->group->numGroup <= 1) && NPC->health <= 10 ) )
{//IF either great danger OR I have no weapon OR I'm alone and low on health, THEN try to find a combat point out of PVS
cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_COVER|CP_AVOID|CP_HAS_ROUTE|CP_NO_PVS, 128, -1 );
}
//FIXME: still happens too often...
if ( cp == -1 )
{//okay give up on the no PVS thing
cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_COVER|CP_AVOID|CP_HAS_ROUTE, 128, -1 );
if ( cp == -1 )
{//okay give up on the avoid
cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_COVER|CP_HAS_ROUTE, 128, -1 );
if ( cp == -1 )
{//okay give up on the cover
cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_HAS_ROUTE, 128, -1 );
}
}
}
//see if we got a valid one
if ( cp != -1 )
{//found a combat point
NPC_SetCombatPoint( cp );
NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp, NULL );
NPCInfo->behaviorState = BS_HUNT_AND_KILL;
NPCInfo->tempBehavior = BS_DEFAULT;
}
else
{//need to just run like hell!
if ( NPC->s.weapon != WP_NONE )
{
return;//let's just not flee?
}
else
{
//FIXME: other evasion AI? Duck? Strafe? Dodge?
NPCInfo->tempBehavior = BS_FLEE;
//Run straight away from here... FIXME: really want to find farthest waypoint/navgoal from this pos... maybe based on alert event radius?
NPC_SetMoveGoal( NPC, dangerPoint, 0, qtrue, -1, NULL );
//store the danger point
VectorCopy( dangerPoint, NPCInfo->investigateGoal );//FIXME: make a new field for this?
}
}
//FIXME: localize this Timer?
TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
//FIXME: is this always applicable?
NPCInfo->squadState = SQUAD_RETREAT;
TIMER_Set( NPC, "flee", Q_irand( fleeTimeMin, fleeTimeMax ) );
TIMER_Set( NPC, "panic", Q_irand( 1000, 4000 ) );//how long to wait before trying to nav to a dropped weapon
if (NPC->client->NPC_class != CLASS_PROTOCOL)
{
TIMER_Set( NPC, "duck", 0 );
}
}
void G_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax )
{
if ( !self->NPC )
{//player
return;
}
SaveNPCGlobals();
SetNPCGlobals( self );
NPC_StartFlee( enemy, dangerPoint, dangerLevel, fleeTimeMin, fleeTimeMax );
RestoreNPCGlobals();
}
void NPC_BSEmplaced( void )
{
qboolean enemyLOS = qfalse;
qboolean enemyCS = qfalse;
qboolean faceEnemy = qfalse;
qboolean shoot = qfalse;
vec3_t impactPos;
//Don't do anything if we're hurt
if ( NPC->painDebounceTime > level.time )
{
NPC_UpdateAngles( qtrue, qtrue );
return;
}
if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
{
WeaponThink( qtrue );
}
//If we don't have an enemy, just idle
if ( NPC_CheckEnemyExt(qfalse) == qfalse )
{
if ( !Q_irand( 0, 30 ) )
{
NPCInfo->desiredYaw = NPC->s.angles[1] + Q_irand( -90, 90 );
}
if ( !Q_irand( 0, 30 ) )
{
NPCInfo->desiredPitch = Q_irand( -20, 20 );
}
NPC_UpdateAngles( qtrue, qtrue );
return;
}
if ( NPC_ClearLOS4( NPC->enemy ) )
{
int hit;
gentity_t *hitEnt;
enemyLOS = qtrue;
hit = NPC_ShotEntity( NPC->enemy, impactPos );
hitEnt = &g_entities[hit];
if ( hit == NPC->enemy->s.number || ( hitEnt && hitEnt->takedamage ) )
{//can hit enemy or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
enemyCS = qtrue;
NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
}
}
/*
else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
{
NPCInfo->enemyLastSeenTime = level.time;
faceEnemy = qtrue;
NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
}
*/
if ( enemyLOS )
{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
faceEnemy = qtrue;
}
if ( enemyCS )
{
shoot = qtrue;
}
if ( faceEnemy )
{//face the enemy
NPC_FaceEnemy( qtrue );
}
else
{//we want to face in the dir we're running
NPC_UpdateAngles( qtrue, qtrue );
}
if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
{
shoot = qfalse;
}
if ( NPC->enemy && NPC->enemy->enemy )
{
if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
shoot = qfalse;
}
}
if ( shoot )
{//try to shoot if it's time
if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
{
WeaponThink( qtrue );
}
}
}
Reference in New Issue View Git Blame Copy Permalink