void NPC_ReachedGoal( void ) { // Debug_NPCPrintf( NPC, d_npcai, DEBUG_LEVEL_INFO, "UpdateGoal: reached goal entity\n" ); NPC_ClearGoal(); NPCS.NPCInfo->goalTime = level.time; //MCG - Begin NPCS.NPCInfo->aiFlags &= ~NPCAI_MOVING; NPCS.ucmd.forwardmove = 0; //Return that the goal was reached trap_ICARUS_TaskIDComplete( NPCS.NPC, TID_MOVE_NAV ); //MCG - End }
//Simply turn until facing desired angles void NPC_BSFace (void) { //FIXME: once you stop sending turning info, they reset to whatever their delta_angles was last???? //Once this is over, it snaps back to what it was facing before- WHY??? if( NPC_UpdateAngles ( qtrue, qtrue ) ) { trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE ); NPCInfo->desiredYaw = client->ps.viewangles[YAW]; NPCInfo->desiredPitch = client->ps.viewangles[PITCH]; NPCInfo->aimTime = 0;//ok to turn normally now } }
void NPC_BSPointShoot (qboolean shoot) {//FIXME: doesn't check for clear shot... vec3_t muzzle, dir, angles, org; //spot_t spot_enemy = SPOT_CHEST; if ( !NPC->enemy || !NPC->enemy->inuse || (NPC->enemy->NPC && NPC->enemy->health <= 0) ) {//FIXME: should still keep shooting for a second or two after they actually die... trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE ); goto finished; return; } CalcEntitySpot(NPC, SPOT_WEAPON, muzzle); CalcEntitySpot(NPC->enemy, SPOT_HEAD, org);//Was spot_org //Head is a little high, so let's aim for the chest: //if ( NPC->enemy->client ) //{ // org[2] -= 12;//NOTE: is this enough? //} VectorSubtract(org, muzzle, dir); vectoangles(dir, angles); switch( NPC->client->ps.weapon ) { case WP_NONE: // case WP_TRICORDER: case WP_STUN_BATON: case WP_SABER: //don't do any pitch change if not holding a firing weapon break; default: NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]); break; } NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]); if ( NPC_UpdateAngles ( qtrue, qtrue ) ) {//FIXME: if angles clamped, this may never work! //NPCInfo->shotTime = NPC->attackDebounceTime = 0; if ( shoot ) {//FIXME: needs to hold this down if using a weapon that requires it, like phaser... //ucmd.buttons |= BUTTON_ATTACK; WeaponThink( qtrue ); } //if ( !shoot || !(NPC->svFlags & SVF_LOCKEDENEMY) ) if (1) {//If locked_enemy is on, dont complete until it is destroyed... trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE ); goto finished; } } //else if ( shoot && (NPC->svFlags & SVF_LOCKEDENEMY) ) if (0) {//shooting them till their dead, not aiming right at them yet... /* qboolean movingTarget = qfalse; if ( NPC->enemy->client ) { if ( VectorLengthSquared( NPC->enemy->client->ps.velocity ) ) { movingTarget = qtrue; } } else if ( VectorLengthSquared( NPC->enemy->s.pos.trDelta ) ) { movingTarget = qtrue; } if (movingTarget ) */ { float dist = VectorLength( dir ); float yawMiss, yawMissAllow = NPC->enemy->r.maxs[0]; float pitchMiss, pitchMissAllow = (NPC->enemy->r.maxs[2] - NPC->enemy->r.mins[2])/2; if ( yawMissAllow < 8.0f ) { yawMissAllow = 8.0f; } if ( pitchMissAllow < 8.0f ) { pitchMissAllow = 8.0f; } yawMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw ))) * dist; pitchMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[PITCH], NPCInfo->desiredPitch))) * dist; if ( yawMissAllow >= yawMiss && pitchMissAllow > pitchMiss ) { ucmd.buttons |= BUTTON_ATTACK; } } } return; finished: NPCInfo->desiredYaw = client->ps.viewangles[YAW]; NPCInfo->desiredPitch = client->ps.viewangles[PITCH]; NPCInfo->aimTime = 0;//ok to turn normally now }
void G_Roff( gentity_t *ent ) {//updates roff scripting for this entity. int roff_id; vec3_t org, ang; const roff_list_t * roff; if ( !ent->next_roff_time ) { return; } if ( ent->next_roff_time > level.time ) {// either I don't think or it's just not time to have me think yet return; } roff_id = G_LoadRoff( ent->roffname ); if ( !roff_id ) { // Couldn't cache this rof return; } // The ID is one higher than the array index roff = &roffs[ roff_id - 1 ]; if ( roff->type == 2 ) { move_rotate2_t *data = &roffs[ roff_id - 1 ].data[ ent->roff_ctr ]; VectorCopy( data->origin_delta, org ); VectorCopy( data->rotate_delta, ang ); if (data->mStartNote != -1 || data->mNumNotes) { //RAFIXME - impliment this. //G_RoffNotetrackCallback(ent, roffs[roff_id - 1].mNoteTrackIndexes[data->mStartNote]); } } else { move_rotate2_t *data = &roffs[ roff_id - 1 ].data[ ent->roff_ctr ]; VectorCopy( data->origin_delta, org ); VectorCopy( data->rotate_delta, ang ); } #ifdef _DEBUG if ( g_developer.integer ) { Com_Printf( S_COLOR_GREEN"ROFF dat: num: %d o:<%.2f %.2f %.2f> a:<%.2f %.2f %.2f>\n", ent->roff_ctr, org[0], org[1], org[2], ang[0], ang[1], ang[2] ); } #endif if ( ent->client ) { // Set up the angle interpolation //------------------------------------- VectorAdd( ent->s.apos.trBase, ang, ent->s.apos.trBase ); ent->s.apos.trTime = level.time; ent->s.apos.trType = TR_INTERPOLATE; // Store what the next apos->trBase should be VectorCopy( ent->s.apos.trBase, ent->client->ps.viewangles ); VectorCopy( ent->s.apos.trBase, ent->r.currentAngles ); VectorCopy( ent->s.apos.trBase, ent->s.angles ); if ( ent->NPC ) { //ent->NPC->desiredPitch = ent->s.apos.trBase[PITCH]; ent->NPC->desiredYaw = ent->s.apos.trBase[YAW]; } // Set up the origin interpolation //------------------------------------- VectorAdd( ent->s.pos.trBase, org, ent->s.pos.trBase ); ent->s.pos.trTime = level.time; ent->s.pos.trType = TR_INTERPOLATE; // Store what the next pos->trBase should be VectorCopy( ent->s.pos.trBase, ent->client->ps.origin ); VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin ); //VectorCopy( ent->s.pos.trBase, ent->s.origin ); } else { // Set up the angle interpolation //------------------------------------- VectorScale( ang, roff->mLerp, ent->s.apos.trDelta ); VectorCopy( ent->pos2, ent->s.apos.trBase ); ent->s.apos.trTime = level.time; ent->s.apos.trType = TR_LINEAR; // Store what the next apos->trBase should be VectorAdd( ent->pos2, ang, ent->pos2 ); // Set up the origin interpolation //------------------------------------- VectorScale( org, roff->mLerp, ent->s.pos.trDelta ); VectorCopy( ent->pos1, ent->s.pos.trBase ); ent->s.pos.trTime = level.time; ent->s.pos.trType = TR_LINEAR; // Store what the next apos->trBase should be VectorAdd( ent->pos1, org, ent->pos1 ); //make it true linear... FIXME: sticks around after ROFF is done, but do we really care? ent->alt_fire = qtrue; //RAFIXME - impliment tiefighter thinks. if ( /*ent->e_ThinkFunc == thinkF_TieFighterThink || ent->e_ThinkFunc == thinkF_TieBomberThink ||*/ ( !ent->think && ent->s.eType != ET_MISSILE && ent->s.eType != ET_ITEM && ent->s.eType != ET_MOVER ) ) {//will never set currentAngles & currentOrigin itself ( why do we limit which one's get set?, just set all the time? ) BG_EvaluateTrajectory( &ent->s.apos, level.time, ent->r.currentAngles ); BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->r.currentOrigin ); } } // Link just in case. trap_LinkEntity( ent ); // See if the ROFF playback is done //------------------------------------- if ( ++ent->roff_ctr >= roff->frames ) { // We are done, so let me think no more, then tell the task that we're done. ent->next_roff_time = 0; // Stop any rotation or movement. VectorClear( ent->s.pos.trDelta ); VectorClear( ent->s.apos.trDelta ); trap_ICARUS_TaskIDComplete( ent, TID_MOVE_NAV ); return; } ent->next_roff_time = level.time + roff->mFrameTime; }
/* qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw ) Added: option to do just pitch or just yaw Does not include "aim" in it's calculations FIXME: stop compressing angles into shorts!!!! */ qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw ) { #if 1 float error; float decay; float targetPitch = 0; float targetYaw = 0; float yawSpeed; qboolean exact = qtrue; // if angle changes are locked; just keep the current angles // aimTime isn't even set anymore... so this code was never reached, but I need a way to lock NPC's yaw, so instead of making a new SCF_ flag, just use the existing render flag... - dmv if ( !NPC->enemy && ( (level.time < NPCInfo->aimTime) /*|| NPC->client->renderInfo.renderFlags & RF_LOCKEDANGLE*/) ) { if(doPitch) targetPitch = NPCInfo->lockedDesiredPitch; if(doYaw) targetYaw = NPCInfo->lockedDesiredYaw; } else { // we're changing the lockedDesired Pitch/Yaw below so it's lost it's original meaning, get rid of the lock flag // NPC->client->renderInfo.renderFlags &= ~RF_LOCKEDANGLE; if(doPitch) { targetPitch = NPCInfo->desiredPitch; NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch; } if(doYaw) { targetYaw = NPCInfo->desiredYaw; NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw; } } if ( NPC->s.weapon == WP_EMPLACED_GUN ) { // FIXME: this seems to do nothing, actually... yawSpeed = 20; } else { yawSpeed = NPCInfo->stats.yawSpeed; } if ( NPC->s.weapon == WP_SABER && NPC->client->ps.fd.forcePowersActive&(1<<FP_SPEED) ) { char buf[128]; float tFVal = 0; trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf)); tFVal = atof(buf); yawSpeed *= 1.0f/tFVal; } if( doYaw ) { // decay yaw error error = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw ); if( fabs(error) > MIN_ANGLE_ERROR ) { if ( error ) { exact = qfalse; decay = 60.0 + yawSpeed * 3; decay *= 50.0f / 1000.0f;//msec if ( error < 0.0 ) { error += decay; if ( error > 0.0 ) { error = 0.0; } } else { error -= decay; if ( error < 0.0 ) { error = 0.0; } } } } ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + error ) - client->ps.delta_angles[YAW]; } //FIXME: have a pitchSpeed? if( doPitch ) { // decay pitch error error = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch ); if ( fabs(error) > MIN_ANGLE_ERROR ) { if ( error ) { exact = qfalse; decay = 60.0 + yawSpeed * 3; decay *= 50.0f / 1000.0f;//msec if ( error < 0.0 ) { error += decay; if ( error > 0.0 ) { error = 0.0; } } else { error -= decay; if ( error < 0.0 ) { error = 0.0; } } } } ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + error ) - client->ps.delta_angles[PITCH]; } ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL]; if ( exact && trap_ICARUS_TaskIDPending( NPC, TID_ANGLE_FACE ) ) { trap_ICARUS_TaskIDComplete( NPC, TID_ANGLE_FACE ); } return exact; #else float error; float decay; float targetPitch = 0; float targetYaw = 0; float yawSpeed; //float runningMod = NPCInfo->currentSpeed/100.0f; qboolean exact = qtrue; qboolean doSound = qfalse; // if angle changes are locked; just keep the current angles if ( level.time < NPCInfo->aimTime ) { if(doPitch) targetPitch = NPCInfo->lockedDesiredPitch; if(doYaw) targetYaw = NPCInfo->lockedDesiredYaw; } else { if(doPitch) targetPitch = NPCInfo->desiredPitch; if(doYaw) targetYaw = NPCInfo->desiredYaw; // NPCInfo->aimTime = level.time + 250; if(doPitch) NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch; if(doYaw) NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw; } yawSpeed = NPCInfo->stats.yawSpeed; if(doYaw) { // decay yaw error error = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw ); if( fabs(error) > MIN_ANGLE_ERROR ) { /* if(NPC->client->playerTeam == TEAM_BORG&& NPCInfo->behaviorState != BS_FACE&&NPCInfo->tempBehavior!= BS_FACE) {//HACK - borg turn more jittery if ( error ) { exact = qfalse; decay = 60.0 + yawSpeed * 3; decay *= 50.0 / 1000.0;//msec //Snap to if(fabs(error) > 10) { if(random() > 0.6) { doSound = qtrue; } } if ( error < 0.0)//-10.0 ) { error += decay; if ( error > 0.0 ) { error = 0.0; } } else if ( error > 0.0)//10.0 ) { error -= decay; if ( error < 0.0 ) { error = 0.0; } } } } else*/ if ( error ) { exact = qfalse; decay = 60.0 + yawSpeed * 3; decay *= 50.0 / 1000.0;//msec if ( error < 0.0 ) { error += decay; if ( error > 0.0 ) { error = 0.0; } } else { error -= decay; if ( error < 0.0 ) { error = 0.0; } } } } ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + error ) - client->ps.delta_angles[YAW]; } //FIXME: have a pitchSpeed? if(doPitch) { // decay pitch error error = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch ); if ( fabs(error) > MIN_ANGLE_ERROR ) { /* if(NPC->client->playerTeam == TEAM_BORG&& NPCInfo->behaviorState != BS_FACE&&NPCInfo->tempBehavior!= BS_FACE) {//HACK - borg turn more jittery if ( error ) { exact = qfalse; decay = 60.0 + yawSpeed * 3; decay *= 50.0 / 1000.0;//msec //Snap to if(fabs(error) > 10) { if(random() > 0.6) { doSound = qtrue; } } if ( error < 0.0)//-10.0 ) { error += decay; if ( error > 0.0 ) { error = 0.0; } } else if ( error > 0.0)//10.0 ) { error -= decay; if ( error < 0.0 ) { error = 0.0; } } } } else*/ if ( error ) { exact = qfalse; decay = 60.0 + yawSpeed * 3; decay *= 50.0 / 1000.0;//msec if ( error < 0.0 ) { error += decay; if ( error > 0.0 ) { error = 0.0; } } else { error -= decay; if ( error < 0.0 ) { error = 0.0; } } } } ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + error ) - client->ps.delta_angles[PITCH]; } ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL]; /* if(doSound) { G_Sound(NPC, G_SoundIndex(va("sound/enemies/borg/borgservo%d.wav", Q_irand(1, 8)))); } */ return exact; #endif }