src/ship/aibig.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Ship/AiBig.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * C module for AI code related to large ships
  16  *
  17  * $Log$
  18  * Revision 1.4  2002/06/09 04:41:26  relnev
  19  * added copyright header
  20  *
  21  * Revision 1.3  2002/06/01 07:12:33  relnev
  22  * a few NDEBUG updates.
  23  *
  24  * removed a few warnings.
  25  *
  26  * Revision 1.2  2002/05/07 03:16:51  theoddone33
  27  * The Great Newline Fix
  28  *
  29  * Revision 1.1.1.1  2002/05/03 03:28:10  root
  30  * Initial import.
  31  *
  32  *
  33  * 13    8/31/99 4:24p Andsager
  34  * Reduce collisions when attacking big ships.
  35  *
  36  * 12    7/19/99 2:18p Mikeb
  37  * DA:  DOH!!
  38  *
  39  * 11    7/19/99 2:11p Mikeb
  40  * DA: sometimes big_ship_attack_normal is not known
  41  *
  42  * 10    6/14/99 3:21p Andsager
  43  * Allow collisions between ship and its debris.  Fix up collision pairs
  44  * when large ship is warping out.
  45  *
  46  * 9     6/02/99 5:41p Andsager
  47  * Reduce range of secondary weapons not fired from turrets in nebula.
  48  * Reduce range of beams fired from turrrets in nebula
  49  *
  50  * 8     5/13/99 2:31p Jamesa
  51  * DA:  Temp fix when attacking subsys of big ship and BS is blown up.
  52  *
  53  * 7     5/06/99 11:46a Andsager
  54  * Bug fixes.  Don't get into illegal strafe submode.  Don't choose turret
  55  * enemy objnum for beam protected.
  56  *
  57  * 6     4/23/99 12:01p Johnson
  58  * Added SIF_HUGE_SHIP
  59  *
  60  * 5     4/20/99 3:40p Andsager
  61  * Changes to big ship ai.  Uses bounding box as limit where to fly to
  62  * when flying away.
  63  *
  64  * 4     4/16/99 5:54p Dave
  65  * Support for on/off style "stream" weapons. Real early support for
  66  * target-painting lasers.
  67  *
  68  * 3     10/13/98 9:29a Dave
  69  * Started neatening up freespace.h. Many variables renamed and
  70  * reorganized. Added AlphaColors.[h,cpp]
  71  *
  72  * 2     10/07/98 10:53a Dave
  73  * Initial checkin.
  74  *
  75  * 1     10/07/98 10:51a Dave
  76  *
  77  * 77    5/25/98 12:12a Mike
  78  * Improve big ship avoidance to avoid big ships when in a nearby dock
  79  * mode.  Fixes very dumb looking behavior in sm2-01a.  Verified sm1-08a
  80  * not too dumb at start.
  81  *
  82  * 76    5/23/98 2:38a Mike
  83  * Improve balance of cheat-firing Synaptics.
  84  *
  85  * 75    5/23/98 12:40a Mike
  86  * Hook for Delta wing to fire Synaptic bombs in sm3-09a.
  87  *
  88  * 74    5/22/98 12:08p Mike
  89  * Force reset of aspect locking when AI ships switch banks due to
  90  * good-time-to-unload-secondaries
  91  *
  92  * 73    5/21/98 1:25p Lawrance
  93  * Fix exception in ai_bpap() when no verts are in closest octant
  94  *
  95  * 72    5/21/98 9:57a Mike
  96  * Massively improve firing of bombs at big ships.  Improve willingness to
  97  * take incoming fire to deliver bomb.  Make a little easier to gain
  98  * aspect lock.
  99  *
 100  * 71    5/12/98 10:06a Mike
 101  * Fix a jillion bugs preventing ships from firing bombs at Lucifer in
 102  * sm3-09.
 103  *
 104  * 70    5/10/98 11:30p Mike
 105  * Better firing of bombs, less likely to go into strafe mode.
 106  *
 107  * 69    5/10/98 3:41a Lawrance
 108  * Fix bug that was preventing ships from leaving strafe mode
 109  *
 110  * 68    5/08/98 4:39p Mike
 111  * Make ships match bank when attacking large ships.
 112  *
 113  * 67    5/07/98 11:59p Mike
 114  * Remove unneeded code, computation of num_verts.
 115  *
 116  * 66    4/29/98 5:01p Mike
 117  * Large overhaul in how turrets fire.
 118  *
 119  * 65    4/27/98 11:59p Mike
 120  * Intermediate checkin.  Getting big ship turrets firing at big ships to
 121  * use pick_big_attack_point.
 122  *
 123  * 64    4/23/98 12:32a Mike
 124  * Fix bogus math which looked at (1-fov) instead of fov.
 125  *
 126  * 63    4/13/98 4:52p Allender
 127  * remove AI_frametime and us flFrametime instead.  Make lock warning work
 128  * in multiplayer for aspect seeking missiles.  Debris fixups
 129  *
 130  * 62    4/13/98 3:27p Lawrance
 131  * Fix bug that caused ships to leave strafe mode right away since they
 132  * hadn't taken damage for a while
 133  *
 134  * 61    4/12/98 2:02p Mike
 135  * Make small ships avoid big ships.
 136  * Turn on Collide_friendly flag.
 137  *
 138  * 60    4/01/98 9:21p John
 139  * Made NDEBUG, optimized build with no warnings or errors.
 140  *
 141  * 59    3/25/98 12:00a Allender
 142  * MK: make sure that output from function gets a valid valud (ai_pbap I
 143  * think)
 144  *
 145  * 58    3/24/98 10:07p Adam
 146  * AL: Add another Assert() to try and catch bogus wp->big_attack_point
 147  *
 148  * 57    3/24/98 9:56p Adam
 149  * AL: Assert that local_attack_point is valid in ai_bpap
 150  *
 151  * 56    3/21/98 3:36p Mike
 152  * Fix/optimize attacking of big ships.
 153  *
 154  * 55    3/16/98 5:17p Mike
 155  * Make ships not get stuck on big ships when attacking.
 156  *
 157  * 54    3/16/98 12:03a Mike
 158  * Add support for kamikaze mode.  Add AIF_NO_DYNAMIC which means
 159  * relentlessly pursue current goal.
 160  *
 161  * 53    3/12/98 4:04p Lawrance
 162  * Leave strafe mode if haven't been hit for a while and no enemy
 163  * fighter/bombers are close by.
 164  *
 165  * 52    3/09/98 5:12p Mike
 166  * Make sure Pl_objp uses are valid.
 167  * Throw asteroids at ships in asteroid field, not "Gal"
 168  * Support ships warp out if no goals after 30 seconds.
 169  *
 170  * 51    3/03/98 11:51p Lawrance
 171  * Ensure target is a ship before looking at SIF flags
 172  *
 173  * 50    3/02/98 11:35a Mike
 174  * Fix logic with ai_do_default_behavior -- return after call.
 175  *
 176  * 49    2/19/98 7:37p Lawrance
 177  * Fix bug that was causing problems with subsystem path following.
 178  *
 179  * 48    2/14/98 3:38p Mike
 180  * Make bombs have arm time, drop for 1/2 second, have hull_strength.
 181  * Make them not fired until closer to target.
 182  *
 183  * 47    2/13/98 3:56p Mike
 184  * Make ships more likely to stick to player orders, not get so distracted
 185  * by getting hit by someone else.
 186  *
 187  * 46    2/11/98 4:30p Lawrance
 188  * Improve disarm/disable behavior.
 189  *
 190  * 45    2/11/98 1:16a Mike
 191  * Mods to AI behavior to make it harder to stay on a ship's tail.  Not
 192  * too much improvement.
 193  *
 194  * 44    2/05/98 12:51a Mike
 195  * Early asteroid stuff.
 196  *
 197  * 43    1/30/98 11:28a Comet
 198  * Fix indexing problem into verts in ai_bpap()
 199  *
 200  * 42    1/29/98 10:46p Mike
 201  * In ai_big_pick_attack_point, handle case of octant with no points.
 202  *
 203  * 41    1/29/98 1:39p Mike
 204  * Better heat seeking homing on big ships.
 205  *
 206  * 40    1/27/98 4:18p Mike
 207  * Not fire weapons too early when attacking large ships.  Aspect lock
 208  * take proper amount of time for AI ships.
 209  *
 210  * 39    1/22/98 5:14p Lawrance
 211  * clean up ai_big code, clear path info when stop attacking a subsystem
 212  *
 213  * 38    1/20/98 11:41p Mike
 214  * Ships use new system of preferred big weapons to fire.  Also, support
 215  * AIF_UNLOAD_SECONDARIES which means fire as fast as possible.
 216  *
 217  * 37    1/20/98 9:47a Mike
 218  * Suppress optimized compiler warnings.
 219  * Some secondary weapon work.
 220  *
 221  * 36    1/17/98 4:45p Mike
 222  * Better support for AI selection of secondary weapons.
 223  *
 224  * 35    1/16/98 3:57p Mike
 225  * Clean up some bugs with attacking of protected ships.  Make turrets
 226  * only fire at targets that are within range.
 227  *
 228  * 34    1/16/98 11:32a Mike
 229  * Fix bug when a ship is attacking a dead subsystem on a protected ship.
 230  *
 231  * 33    1/07/98 1:32p Lawrance
 232  * Remove some nprintf output
 233  *
 234  * 32    1/07/98 1:21p Sandeep
 235  * Fix bug where accessing uninited pointer
 236  *
 237  * 31    1/06/98 6:58p Lawrance
 238  * Attack turrets (sometimes) when fired upon while attacking a ship.
 239  *
 240  * 30    12/31/97 6:28p Lawrance
 241  * Improve attacking subsystems on moving ships.
 242  *
 243  * 29    12/31/97 4:16p Lawrance
 244  * Use different fov's for attacking subsystems depending if ship is
 245  * moving
 246  *
 247  * 28    12/31/97 4:05p Mike
 248  * Support for all teams optionally attacking all teams.
 249  * Lead big ships when attacking their hull.
 250  *
 251  * 27    12/31/97 12:26p Lawrance
 252  * Don't enter strafe mode for transports, fix bug that prevented strafe
 253  * mode from getting entered.
 254  *
 255  * 26    12/30/97 5:20p Mike
 256  * Don't fire secondaries at a protected ship if its hull is very weak.
 257  *
 258  * 25    12/30/97 4:26p Lawrance
 259  * Take out some debug statements
 260  *
 261  * 24    12/15/97 7:16p Lawrance
 262  * improving subsystem attacking
 263  *
 264  * 23    12/02/97 11:58a Lawrance
 265  * avoid during strafe mode only when endangered by a weapon
 266  *
 267  * 22    12/01/97 5:11p Lawrance
 268  * make strafe mode more effective... slow down when approaching and use
 269  * afterburner in avoids
 270  *
 271  * 21    11/27/97 4:21p Lawrance
 272  * set submode to -1 when switching to AIM_NONE from AIM_STRAFE
 273  *
 274  * 20    11/24/97 2:27a Lawrance
 275  * if attacking a big ship and moving very slow, enter strafe mode if
 276  * enemy fighter/bombers are close by
 277  *
 278  * 19    11/14/97 11:27a Johnson
 279  * if goal_objnum is -1, and in STRAFE, return 1 from
 280  * ai_maybe_follow_subsys_path(), so break out of STRAFE code
 281  *
 282  * 18    11/13/97 11:51a Johnson
 283  * ALAN: comment out Int3() in AiBig... need to test on my own machine
 284  *
 285  * 17    11/12/97 11:51p Lawrance
 286  * only check target_objnum == goal_objnum when following path
 287  *
 288  * 16    11/12/97 11:01p Lawrance
 289  * change call to ai_find_path()
 290  * ensure goal_objnum == target_objnum in STRAFE
 291  *
 292  * 15    11/12/97 11:18a Lawrance
 293  * fix bug in path following of subsystems
 294  *
 295  * 14    11/11/97 5:22p Mike
 296  * Don't allow ships to attack navbuoys.
 297  * Make ships lead big ships with dumbfire.
 298  * Make ships smarter about leaving evade weapon mode.
 299  * Fix a couple Assert() bugs.
 300  *
 301  * 13    11/06/97 6:27p Lawrance
 302  * fix bug that was messing up retreat point in STRAFE mode
 303  *
 304  * 12    11/06/97 4:53p Mike
 305  * Limit number of ships that can simultaneously attack another.  Make
 306  * turrets inherit AI class from parent ship.
 307  *
 308  * 11    11/06/97 12:27a Mike
 309  * Better avoid behavior.
 310  * Modify ai_turn_towards_vector() to take a flag parameter.
 311  *
 312  * 10    11/02/97 10:55p Lawrance
 313  * removed some unused code, added some comments
 314  *
 315  * 9     11/01/97 4:01p Mike
 316  * Adapt to new ai_find_path().
 317  *
 318  * 8     10/31/97 11:24a Lawrance
 319  * If taget changes from a big ship to small ship while in AIM_STRAFE,
 320  * switch to AIM_CHASE
 321  *
 322  * 7     10/30/97 10:06p Lawrance
 323  * chg some timing values so ship will reach retreat point
 324  *
 325  * 6     10/30/97 9:17p Lawrance
 326  * work on getting AIM_STRAFE working well with disable/disarm, try to
 327  * balance
 328  *
 329  * 5     10/30/97 12:32a Lawrance
 330  * further work on AIM_STRAFE
 331  *
 332  * 4     10/29/97 6:25p Lawrance
 333  * add AIM_STRAFE functionality
 334  *
 335  * 3     10/26/97 4:19p Lawrance
 336  * added ai_get_weapon_dist()
 337  *
 338  * 2     10/26/97 3:24p Lawrance
 339  * split off large ship ai code into AiBig.cpp
 340  *
 341  * $NoKeywords: $
 342  */
 343
 344 #include "pstypes.h"
 345 #include "fix.h"
 346 #include "linklist.h"
 347 #include "object.h"
 348 #include "physics.h"
 349 #include "vecmat.h"
 350 #include "ship.h"
 351 #include "model.h"
 352 #include "2d.h"
 353 #include "3d.h"
 354 #include "ai.h"
 355 #include "aibig.h"
 356 #include "floating.h"
 357 #include "player.h"
 358 #include "freespace.h"
 359 #include "weapon.h"
 360 #include "missiongoals.h"
 361 #include "missionlog.h"
 362 #include "timer.h"
 363 #include "sound.h"
 364 #include "aigoals.h"
 365 #include "gamesnd.h"
 366 #include "hudmessage.h"
 367 #include "missionmessage.h"
 368 #include "cmeasure.h"
 369 #include "staticrand.h"
 370 #include "multimsgs.h"
 371 #include "afterburner.h"
 372 #include "hudets.h"
 373 #include "shipfx.h"
 374 #include "shiphit.h"
 375 #include "missionparse.h"
 376
 377 #ifndef PLAT_UNIX
 378 #pragma optimize("", off)
 379 #pragma auto_inline(off)
 380 #endif
 381
 382 #define SCAN_FIGHTERS_INTERVAL  2000            // how often an AI fighter/bomber should scan for enemy fighter/bombers
 383                                                                                                                 // if sitting still and pounding on a big ship.  If enemy fighters are
 384                                                                                                                 // close ( < ENTER_STRAFE_THREAT_DIST ), then enter AIM_STRAFE
 385
 386 #define ENTER_STRAFE_THREAT_DIST_SQUARED        360000  // use squared distance, instead of 600
 387
 388 #define MIN_DOT_TO_ATTACK_SUBSYS                                0.7f
 389 #define MIN_DOT_TO_ATTACK_MOVING_SUBSYS 0.97f
 390
 391 // AI BIG MAGIC NUMBERS
 392 #define STRAFE_RETREAT_COLLIDE_TIME     2.0             // when anticipated collision time is less than this, begin retreat
 393 #define STRAFE_RETREAT_COLLIDE_DIST     100             // when perpendicular distance to *surface* is less than this, begin retreat
 394 #define STRAFE_RETREAT_BOX_DIST                 300             // distance beyond the bounding box to retreat
 395
 396 #define EVADE_BOX_BASE_DISTANCE                 300             // standard distance to end evade submode
 397 #define EVADE_BOX_MIN_DISTANCE                  200             // minimun distance to end evade submode, after long time
 398
 399 #define ATTACK_STOP_DISTANCE                            150             // when distance to target is less than this, put on brakes
 400
 401 #define ATTACK_COLLIDE_BASE_DIST                300             // absolute distance at which to begin checking for possible collision
 402 #define ATTACK_COLLIDE_AVOID_DIST               60                      // perpendicular distance to attack surface at which begin avoiding
 403 #define ATTACK_COLLIDE_AVOID_TIME               1.0             // anticipated collision time at which to begin evade
 404 #define ATTACK_COLLIDE_SLOW_DIST                150             // perpendicular distance to attack surface at which begin slowing down
 405 #define ATTACK_COLLIDE_SLOW_TIME                1.5             // anticipated collision time at which to begin slowing down
 406
 407
 408 // forward declarations
 409 void    ai_big_evade_ship();
 410 void    ai_big_chase_attack(ai_info *aip, ship_info *sip, vector *enemy_pos, float dist_to_enemy);
 411 void    ai_big_avoid_ship();
 412 int     ai_big_maybe_follow_subsys_path(int do_dot_check=1);
 413
 414 extern int model_which_octant_distant_many( vector *pnt, int model_num,matrix *model_orient, vector * model_pos, polymodel **pm, int *octs);
 415 extern void compute_desired_rvec(vector *rvec, vector *goal_pos, vector *cur_pos);
 416 extern void big_ship_collide_recover_start(object *objp, object *big_objp, vector *collide_pos, vector *collision_normal);
 417
 418
 419 //      Called by ai_big_pick_attack_point.
 420 //      Generates a random attack point.
 421 //      If truly_random flag set (haha), then generate a pretty random number.  Otherwise, generate a static rand which
 422 //      tends to not change from frame to frame.
 423 //      Try four times and choose nearest point to increase chance of getting a good point.
 424 void ai_bpap(object *objp, vector *attacker_objp_pos, vector *attacker_objp_fvec, vector *attack_point, vector *local_attack_point, float fov, float weapon_travel_dist, vector *surface_normal)
 425 {
 426         float           nearest_dist;
 427         vector  result_point, best_point;
 428         vector  rel_point;
 429         int             num_tries;
 430         model_octant    *octp;
 431         polymodel       *pm;
 432         int             i, q, octs[4];
 433
 434         best_point = objp->pos;
 435         nearest_dist = weapon_travel_dist;
 436
 437         model_which_octant_distant_many(attacker_objp_pos, Ships[objp->instance].modelnum, &objp->orient, &objp->pos, &pm, octs);
 438
 439         num_tries = (int) (vm_vec_dist(&objp->pos, attacker_objp_pos)/objp->radius);
 440
 441         if (num_tries >= 4)
 442                 num_tries = 1;
 443         else
 444                 num_tries = 4 - num_tries;
 445
 446         //      Index #0 is best one.
 447         if ( pm->octants[octs[0]].verts ) {
 448                 *local_attack_point = *pm->octants[octs[0]].verts[0];   //      Set just in case it doesn't get set below.
 449         } else {
 450                 vm_vec_zero(local_attack_point);
 451         }
 452
 453         for (q=0; q<4; q++) {
 454                 octp = &pm->octants[octs[q]];
 455                 if (octp->nverts > 0) {
 456
 457                         if (num_tries > octp->nverts)
 458                                 num_tries = octp->nverts;
 459
 460                         if (num_tries > octp->nverts)
 461                                 num_tries = octp->nverts;
 462
 463                         int     best_index = -1;
 464
 465                         for (i=0; i<num_tries; i++) {
 466                                 int     index;
 467                                 float   dist, dot;
 468                                 vector  v2p;
 469
 470                                 index = (int) (frand() * (octp->nverts));
 471
 472                                 rel_point = *octp->verts[index];
 473                                 vm_vec_unrotate(&result_point, &rel_point, &objp->orient);
 474                                 vm_vec_add2(&result_point, &objp->pos);
 475
 476                                 dist = vm_vec_normalized_dir(&v2p, &result_point, attacker_objp_pos);
 477                                 dot = vm_vec_dot(&v2p, attacker_objp_fvec);
 478
 479                                 if (dot > fov) {
 480                                         if (dist < nearest_dist) {
 481                                                 best_index = index;
 482                                                 nearest_dist = dist;
 483                                                 best_point = result_point;
 484                                                 *local_attack_point = rel_point;
 485                                                 Assert( !vm_is_vec_nan(local_attack_point) );
 486                                                 if (dot > (1.0f + fov)/2.0f)    //      If this point is quite good, quit searching for a better one.
 487                                                         goto done_1;
 488                                         }
 489                                 }
 490                         }
 491                 }
 492         }
 493 done_1:
 494
 495         *attack_point = best_point;
 496
 497         // Cast from attack_objp_pos to local_attack_pos and check for nearest collision.
 498         // If no collision, cast to (0,0,0) [center of big ship]**  [best_point initialized to 000]
 499
 500         // do in world coords to get attack point, then translate to local for local_attack_point
 501         vector attack_dir, end_point, temp;
 502         float dist;
 503         dist = vm_vec_normalized_dir(&attack_dir, attack_point, attacker_objp_pos);
 504
 505         if (dist > 0.1) {
 506                 vm_vec_scale_add(&end_point, attack_point, &attack_dir, 30.0f);
 507         } else {
 508                 vm_vec_scale_add(&end_point, attack_point, attacker_objp_fvec, 30.0f);
 509         }
 510
 511         mc_info mc;
 512         mc.model_num = Ships[objp->instance].modelnum;
 513         mc.orient = &objp->orient;
 514         mc.pos = &objp->pos;
 515         mc.p0 = attacker_objp_pos;
 516         mc.p1 = &end_point;
 517         mc.flags = MC_CHECK_MODEL;
 518         mc.radius = 0.0f;
 519         model_collide(&mc);
 520
 521         if (mc.num_hits > 0) {
 522                 *attack_point = mc.hit_point_world;
 523                 vm_vec_sub(&temp, attack_point, &objp->pos);
 524                 vm_vec_rotate(local_attack_point, &temp, &objp->orient);
 525                 if (surface_normal) {
 526                         vm_vec_unrotate(surface_normal, &mc.hit_normal, &objp->orient);
 527                 }
 528         } else {
 529                 vm_vec_zero(local_attack_point);
 530                 *attack_point = objp->pos;
 531                 if (surface_normal) {
 532                         vm_vec_zero(surface_normal);
 533                 }
 534         }
 535 }
 536
 537 //      Stuff a point to attack based on nearest octant.
 538 //      If no points in that octant, leave attack_point unmodified.
 539 //
 540 //      Note: Default value for fov is 1.0f  1.0f means don't use fov parameter.
 541 //      If fov != 1.0f, try up to four times to find a point that's in the field of view.
 542 void ai_big_pick_attack_point_turret(object *objp, ship_subsys *ssp, vector *gpos, vector *gvec, vector *attack_point, float fov, float weapon_travel_dist)
 543 {
 544         if (!timestamp_elapsed(ssp->turret_pick_big_attack_point_timestamp)) {
 545                 vector  result_point;
 546                 vm_vec_unrotate(&result_point, &ssp->turret_big_attack_point, &objp->orient);
 547                 vm_vec_add(attack_point, &result_point, &objp->pos);
 548         } else {
 549                 vector  local_attack_point;
 550                 ssp->turret_pick_big_attack_point_timestamp = timestamp(2000 + (int) (frand()*500.0f));
 551                 ai_bpap(objp, gpos, gvec, attack_point, &local_attack_point, fov, weapon_travel_dist, NULL);
 552                 ssp->turret_big_attack_point = local_attack_point;
 553         }
 554 }
 555
 556 //      Stuff a point to attack based on nearest octant.
 557 //      If no points in that octant, leave attack_point unmodified.
 558 //
 559 //      Note: Default value for fov is 1.0f  1.0f means don't use fov parameter.
 560 //      If fov != 1.0f, try up to four times to find a point that's in the field of view.
 561 //      Note, attacker_objp can be a ship or a weapon.
 562 void ai_big_pick_attack_point(object *objp, object *attacker_objp, vector *attack_point, float fov)
 563 {
 564         Assert(objp->instance > -1);
 565         Assert(objp->type == OBJ_SHIP);
 566
 567         vector  local_attack_point;
 568
 569         switch (attacker_objp->type) {
 570         case OBJ_SHIP: {
 571                 ai_info *attacker_aip;
 572                 attacker_aip = &Ai_info[Ships[attacker_objp->instance].ai_index];
 573                 if (!timestamp_elapsed(attacker_aip->pick_big_attack_point_timestamp)) {
 574                         vector  result_point;
 575
 576                         vm_vec_unrotate(&result_point, &attacker_aip->big_attack_point, &objp->orient);
 577                         vm_vec_add(attack_point, &result_point, &objp->pos);
 578
 579                         return;
 580                 }
 581
 582                 attacker_aip->pick_big_attack_point_timestamp = timestamp(2000 + (int) (frand()*500.0f));
 583                 break;
 584                                                 }
 585         case OBJ_WEAPON: {
 586                 weapon  *wp = &Weapons[attacker_objp->instance];
 587
 588                 if (!timestamp_elapsed(wp->pick_big_attack_point_timestamp)) {
 589                         vector  result_point;
 590
 591                         vm_vec_unrotate(&result_point, &wp->big_attack_point, &objp->orient);
 592                         vm_vec_add(attack_point, &result_point, &objp->pos);
 593
 594                         return;
 595                 }
 596                 wp->pick_big_attack_point_timestamp = timestamp(2000 + (int) (frand()*500.0f));
 597
 598                 break;
 599                                                   }
 600         }
 601
 602         // checks valid line to target
 603         vector surface_normal;
 604         ai_bpap(objp, &attacker_objp->pos, &attacker_objp->orient.fvec, attack_point, &local_attack_point, fov, 99999.9f, &surface_normal);
 605
 606         switch (attacker_objp->type) {
 607         case OBJ_SHIP: {
 608                 ai_info *attacker_aip;
 609                 // if we can't find a new local_attack_point don't change local_attack_point
 610                 if (vm_vec_mag_squared(&local_attack_point) < 1) {
 611                         return;
 612                 }
 613
 614                 attacker_aip = &Ai_info[Ships[attacker_objp->instance].ai_index];
 615                 attacker_aip->big_attack_point = local_attack_point;
 616                 attacker_aip->big_attack_surface_normal = surface_normal;
 617                 break;
 618                                                 }
 619         case OBJ_WEAPON: {
 620                 weapon  *wp = &Weapons[attacker_objp->instance];
 621                 wp->big_attack_point = local_attack_point;
 622                 Assert( !vm_is_vec_nan(&wp->big_attack_point) );
 623                 break;
 624                                                   }
 625         }
 626
 627         return;
 628 }
 629
 630 // Handler for SM_EVADE submode ( called from ai_big_chase() )
 631 void ai_big_evade_ship()
 632 {
 633         vector  player_pos, enemy_pos;
 634         float           dist;
 635         ship            *shipp = &Ships[Pl_objp->instance];
 636         ai_info *aip = &Ai_info[shipp->ai_index];
 637         vector  randvec, semi_enemy_pos;
 638
 639         ai_set_positions(Pl_objp, En_objp, aip, &player_pos, &enemy_pos);
 640
 641         dist = vm_vec_dist_quick(&player_pos, &enemy_pos);
 642         vm_vec_rand_vec_quick(&randvec);
 643         if ((Missiontime>>14) & 1) {
 644                 vm_vec_scale_add(&semi_enemy_pos, &enemy_pos, &randvec, dist/2.0f);
 645                 aip->prev_goal_point = semi_enemy_pos;
 646         } else {
 647                 semi_enemy_pos = aip->prev_goal_point;
 648         }
 649
 650         accelerate_ship(aip, 1.0f - ((Missiontime>>8) & 0x3f)/128.0f );
 651         turn_away_from_point(Pl_objp, &semi_enemy_pos, 0.0f);
 652
 653         float box_dist;
 654         vector box_vec;
 655         int is_inside;
 656         box_dist = get_world_closest_box_point_with_delta(&box_vec, En_objp, &player_pos, &is_inside, EVADE_BOX_BASE_DISTANCE);
 657         if (box_dist > EVADE_BOX_BASE_DISTANCE) {
 658                 aip->submode = SM_ATTACK;
 659                 aip->submode_start_time = Missiontime;
 660         } else if ((box_dist > EVADE_BOX_MIN_DISTANCE) && (Missiontime - aip->submode_start_time > i2f(5)) ) {
 661                 aip->submode = SM_ATTACK;
 662                 aip->submode_start_time = Missiontime;
 663         }
 664
 665         //TODO TEST
 666
 667 /*      if (dist > 4*En_objp->radius) {
 668                 aip->submode = SM_ATTACK;
 669                 aip->submode_start_time = Missiontime;
 670         } else if (dist > En_objp->radius) {
 671                 if (Missiontime - aip->submode_start_time > i2f(5)) {
 672                         aip->submode = SM_ATTACK;
 673                         aip->submode_start_time = Missiontime;
 674                 }
 675         } */
 676 }
 677
 678 // Handler for SM_AVOID submode ( called from ai_big_chase() )
 679 void ai_big_avoid_ship()
 680 {
 681         ai_big_evade_ship();
 682 }
 683
 684 // reset path following information
 685 void ai_big_subsys_path_cleanup(ai_info *aip)
 686 {
 687         if ( aip->ai_flags & AIF_ON_SUBSYS_PATH ) {
 688                 aip->ai_flags &= ~AIF_ON_SUBSYS_PATH;
 689                 aip->path_goal_dist = -1;
 690                 aip->path_start = -1;
 691                 aip->path_cur = -1;
 692                 aip->path_length = 0;
 693         }
 694 }
 695
 696 // Maybe Pl_objp needs to follow a path to get in line-of-sight to a subsystem
 697 // input:       do_dot_check    =>      default value 0, flag to indicate whether check should be done to ensure
 698 //                                                                              subsystem is within certain field of view.  We don't want to check fov when
 699 //                                                                              strafing, since ship is weaving to avoid turret fire
 700 int ai_big_maybe_follow_subsys_path(int do_dot_check)
 701 {
 702         ai_info *aip;
 703         float           dot = 1.0f, min_dot;
 704         object  *target_objp;
 705
 706         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
 707         target_objp = &Objects[aip->target_objnum];
 708
 709         if ( (aip->targeted_subsys != NULL) && (aip->target_objnum >= 0) && (aip->targeted_subsys->system_info->path_num >= 0) ) {
 710                 polymodel       *pm;
 711                 int                     subsys_path_num, subsys_in_sight, checked_sight;
 712                 float                   dist;
 713
 714                 pm = model_get( Ships[Pl_objp->instance].modelnum );
 715
 716                 // If attacking a subsystem, ensure that we have an unobstructed line of sight... if not, then move
 717                 // towards path linked to subsystem
 718                 subsys_in_sight = 0;    // assume Pl_objp doesn't have line of sight to subys
 719
 720                 // only check for subsystem sight every N milliseconds
 721                 checked_sight = 0;
 722                 if ( timestamp_elapsed(aip->path_subsystem_next_check) ) {
 723                         vector          geye, gsubpos;
 724                         eye                     *ep;
 725
 726                         aip->path_subsystem_next_check = timestamp(1500);
 727
 728                         // get world pos of eye (stored in geye)
 729                         ep = &(pm->view_positions[0] );
 730                         model_find_world_point( &geye, &ep->pnt, Ships[Pl_objp->instance].modelnum, 0, &Pl_objp->orient, &Pl_objp->pos );
 731
 732                         // get world pos of subsystem
 733                         vm_vec_unrotate(&gsubpos, &aip->targeted_subsys->system_info->pnt, &En_objp->orient);
 734                         vm_vec_add2(&gsubpos, &En_objp->pos);
 735
 736                         checked_sight = 1;
 737
 738                         // Calc dot between subsys normal (based on using path info), and subsys_to_eye vector.  This is
 739                         // useful later when we want to decide whether we have a realistic line-of-sight to the subsystem.
 740                         vector subsys_normal, subsys_to_eye;
 741                         if ( do_dot_check ) {
 742                                 if ( !ship_return_subsys_path_normal(&Ships[target_objp->instance], aip->targeted_subsys, &gsubpos, &subsys_normal) ) {
 743                                         vm_vec_normalized_dir(&subsys_to_eye, &geye, &gsubpos);
 744                                         dot = vm_vec_dot(&subsys_normal, &subsys_to_eye);
 745                                 }
 746                         }
 747
 748                         if ( ship_subsystem_in_sight(En_objp, aip->targeted_subsys, &geye, &gsubpos, 1) ) {
 749                                 subsys_in_sight = 1;
 750                         }
 751                 }
 752
 753                 // check if subsystem not in sight
 754                 min_dot = (target_objp->phys_info.fspeed > 5.0f?MIN_DOT_TO_ATTACK_MOVING_SUBSYS:MIN_DOT_TO_ATTACK_SUBSYS);
 755                 if ( (checked_sight && ((!subsys_in_sight) || (dot < min_dot)) ) )  {
 756
 757                         aip->path_goal_dist = 5;
 758                         subsys_path_num = aip->targeted_subsys->system_info->path_num;
 759                         if ( (aip->path_start) == -1 || (aip->mp_index != subsys_path_num) ) {
 760                                 // maybe create a new path
 761                                 if ( subsys_path_num >= 0 ) {
 762                                         Assert(aip->target_objnum >= 0);
 763                                         ai_find_path(Pl_objp, aip->target_objnum, subsys_path_num, 0, 1);
 764                                         if ( aip->path_start >= 0 ) {
 765                                                 aip->ai_flags |= AIF_ON_SUBSYS_PATH;
 766                                         }
 767                                 }
 768                         }
 769                 }
 770
 771                 if ( checked_sight && subsys_in_sight && (dot > min_dot) ) {
 772                         // we've got a clear shot, stay here for a bit
 773                         aip->path_subsystem_next_check = timestamp_rand(5000,8000);
 774                 }
 775
 776                 // If there is a path that we are tracking, see if ship has gotten to within
 777                 // aip->path_goal_dist units.  If so, then ship can stop following the path.  This
 778                 // is required since we don't want to follow the path all the way to the subsystem,
 779                 // and we want ships to stop different distances from their path destination
 780                 if ( aip->path_length > 0 ) {
 781                         int path_done=0;
 782                         int in_view=0;
 783
 784                         Assert(aip->path_length >= 2);
 785                         dist = vm_vec_dist_quick(&Path_points[aip->path_start+aip->path_length-2].pos, &Pl_objp->pos);
 786
 787                         if ( aip->path_cur >= (aip->path_start+aip->path_length-1) ) {
 788                                 path_done=1;
 789                         }
 790
 791                         min_dot = (target_objp->phys_info.fspeed > 5.0f?MIN_DOT_TO_ATTACK_MOVING_SUBSYS:MIN_DOT_TO_ATTACK_SUBSYS);
 792                         if ( (checked_sight && subsys_in_sight) && (dot > min_dot) ) {
 793                                 in_view=1;
 794                         }
 795
 796                         // if we've reached the destination, then we can stop following the path
 797                         if ( path_done || ( dist < aip->path_goal_dist ) || in_view ) {
 798                                 ai_big_subsys_path_cleanup(aip);
 799                         } else if ( dist > aip->path_goal_dist ) {
 800                                 // If we have a path to follow, follow it and return
 801                                 if ( aip->path_start != -1 ) {
 802                                         // for now, only follow the path to the first point
 803                                         if ( aip->path_cur < (aip->path_start+aip->path_length-1) ) {
 804                                                 if ( aip->goal_objnum != aip->target_objnum ) {
 805                                                         //Int3();       // what is going on here? - Get Alan
 806                                                         aip->previous_mode = aip->mode;
 807                                                         aip->mode = AIM_NONE;
 808                                                         aip->submode = -1;
 809                                                         return 1;
 810                                                 }
 811                                                 ai_path();
 812                                                 return 1;
 813                                         }
 814                                 }
 815                         }
 816                 }
 817         }
 818
 819         return 0;
 820 }
 821
 822 // This function is only called from ai_big_chase_attack() when a ship is flying very slowly and
 823 // attacking a big ship.  The ship should scan for enemy fighter/bombers... if any are close, then
 824 // return 1, otherwise return 0;
 825 //
 826 // input: aip   =>      ai_info pointer for Pl_objp
 827 //                       sip    =>      ship_info pointer for Pl_objp
 828 //
 829 // exit:                1       =>      ship should enter strafe mode
 830 //                              0       => ship should not change ai mode, no fighter/bomber threats are near
 831 //
 832 // NOTE: uses SCAN_FIGHTERS_INTERVAL and ENTER_STRAFE_THREAT_DIST_SQUARED which are defined in AiBig.h
 833 int ai_big_maybe_start_strafe(ai_info *aip, ship_info *sip)
 834 {
 835         // if moving slowly (or stopped), and SIF_SMALL_SHIP, then enter STRAFE mode if enemy fighter/bombers
 836         // are near
 837         if ( sip->flags & SIF_SMALL_SHIP ) {
 838                 if ( timestamp_elapsed(aip->scan_for_enemy_timestamp) ) {
 839                         ship_obj        *so;
 840                         object  *test_objp;
 841                         ship            *test_sp;
 842                         float           dist_squared;
 843
 844                         aip->scan_for_enemy_timestamp = timestamp(SCAN_FIGHTERS_INTERVAL);
 845                         // iterate through ships, and see if any fighter/bomber from opposite team are near
 846                         so = GET_FIRST(&Ship_obj_list);
 847                         while( so != END_OF_LIST(&Ship_obj_list) ) {
 848                                 test_objp = &Objects[so->objnum];
 849                                 test_sp = &Ships[test_objp->instance];
 850
 851                                 if ( test_sp->team != Ships[Pl_objp->instance].team ) {
 852                                         if ( Ship_info[test_sp->ship_info_index].flags & SIF_SMALL_SHIP ) {
 853                                                 dist_squared = vm_vec_dist_squared(&Pl_objp->pos, &test_objp->pos);
 854                                                 if ( dist_squared < ENTER_STRAFE_THREAT_DIST_SQUARED ) {
 855                                                         return 1;
 856                                                 }
 857                                         }
 858                                 }
 859                                 so = GET_NEXT(so);
 860                         }
 861                 }
 862         }
 863         // If we've reached here, there are no enemy fighter/bombers near
 864         return 0;
 865 }
 866
 867 //      ATTACK submode handler for chase mode.
 868 void ai_big_chase_attack(ai_info *aip, ship_info *sip, vector *enemy_pos, float dist_to_enemy)
 869 {
 870         int             start_bank;
 871         float           dot_to_enemy, time_to_hit;
 872         polymodel *po = model_get( sip->modelnum );
 873
 874         //      Maybe evade an incoming weapon.
 875         if (((time_to_hit = ai_endangered_by_weapon(aip)) < 4.0f) && (time_to_hit >= 0.0f)) {
 876                 aip->submode = SM_EVADE_WEAPON;
 877                 aip->submode_start_time = Missiontime;
 878                 aip->prev_goal_point = En_objp->pos;
 879         } else {
 880                 //      If moving slowly, maybe evade incoming fire.
 881                 if (Pl_objp->phys_info.speed < 3.0f) {
 882                         object *objp;
 883                         for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
 884                                 if ((objp->type == OBJ_WEAPON) && (Weapons[objp->instance].team != Ships[Pl_objp->instance].team))
 885                                         if (Weapon_info[objp->instance].subtype == WP_LASER) {
 886                                                 vector  in_vec;
 887                                                 float           dist;
 888
 889                                                 vm_vec_sub(&in_vec, &objp->pos, &Pl_objp->pos);
 890                                                 if (vm_vec_dot(&in_vec, &objp->orient.fvec) > 0.0f) {
 891                                                         dist = vm_vec_normalize(&in_vec);
 892                                                         if ((dist < 200.0f) && (vm_vec_dot(&in_vec, &objp->orient.fvec) > 0.95f)) {
 893                                                                 if ((Objects[objp->parent].signature == objp->parent_sig) && (vm_vec_dist_quick(&objp->pos, &Objects[objp->parent].pos) < 300.0f)) {
 894                                                                         set_target_objnum(aip, objp->parent);
 895                                                                         aip->submode = SM_ATTACK;
 896                                                                         aip->submode_start_time = Missiontime;
 897                                                                 } else {
 898                                                                         aip->submode = SM_EVADE;
 899                                                                         aip->submode_start_time = Missiontime;
 900                                                                         aip->prev_goal_point = En_objp->pos;
 901                                                                 }
 902                                                         }
 903                                                 }
 904                                         }
 905                         }
 906
 907                         // Since ship is moving slowly and attacking a large ship, scan if enemy fighters are near, if so
 908                         // then enter strafe mode
 909                         if ( ai_big_maybe_start_strafe(aip, sip) ) {
 910                                 aip->previous_mode = aip->mode;
 911                                 aip->mode = AIM_STRAFE;
 912                                 aip->submode_parm0 = Missiontime;       // use parm0 as time strafe mode entered
 913                                 aip->submode = AIS_STRAFE_ATTACK;
 914                                 aip->submode_start_time = Missiontime;
 915                                 return;
 916                         }
 917
 918                 } // end if ( Pl_objp->phys_info.speed < 3.0f )
 919
 920                 // see if Pl_objp needs to reposition to get a good shot at subsystem which is being attacked
 921                 if ( ai_big_maybe_follow_subsys_path() ) {
 922                         return;
 923                 }
 924
 925                 vector  *rel_pos, vec_to_enemy;
 926                 float           weapon_travel_dist;
 927
 928                 start_bank = Ships[aip->shipnum].weapons.current_primary_bank;
 929
 930                 if ((po->n_guns) && (start_bank != -1)) {
 931                         rel_pos = &po->gun_banks[start_bank].pnt[0];
 932                 } else
 933                         rel_pos = NULL;
 934
 935                 dist_to_enemy = vm_vec_normalized_dir(&vec_to_enemy, enemy_pos, &Pl_objp->pos);
 936                 dot_to_enemy = vm_vec_dot(&vec_to_enemy, &Pl_objp->orient.fvec);
 937
 938                 vector  rvec_vec, *rvec = &rvec_vec;
 939
 940                 if (dist_to_enemy > 500.0f)
 941                         compute_desired_rvec(rvec, enemy_pos, &Pl_objp->pos);
 942                 else
 943                         rvec = NULL;
 944
 945                 ai_turn_towards_vector(enemy_pos, Pl_objp, flFrametime, sip->srotation_time, NULL, rel_pos, 0.0f, 0, rvec);
 946
 947                 // calc range of primary weapon
 948                 weapon_travel_dist = ai_get_weapon_dist(&Ships[Pl_objp->instance].weapons);
 949
 950                 if ( aip->targeted_subsys != NULL ) {
 951                         if (dist_to_enemy > (weapon_travel_dist-20))
 952                                 accelerate_ship(aip, 1.0f);
 953                         else {
 954                                 // AL 12-31-97: Move at least as quickly as your target is moving...
 955                                 accelerate_ship(aip, max(1.0f - dot_to_enemy, Objects[aip->target_objnum].phys_info.fspeed/sip->max_speed));
 956                         }
 957
 958                 } else {
 959                         float accel;
 960                         if (dot_to_enemy < 0.0f) {
 961                                 accel = 0.5f;
 962                         } else if (dot_to_enemy < 0.75f) {
 963                                 accel = 0.75f;
 964                         } else {
 965                                 if (dist_to_enemy > weapon_travel_dist/2.0f) {
 966                                         accel = 1.0f;
 967                                 } else {
 968                                         accel = 1.0f - dot_to_enemy;
 969                                 }
 970                         }
 971
 972                         // use dist normal to enemy here (dont break 50 barrier)
 973                         if (dist_to_enemy < ATTACK_STOP_DISTANCE) {
 974 //                              accelerate_ship(aip, accel * 0.5f);
 975                                 accelerate_ship(aip, -1.0f);
 976                         } else {
 977                                 accelerate_ship(aip, accel);
 978                         }
 979
 980                 }
 981         }
 982 }
 983
 984 // Handler for submode SM_CONTINUOUS_TURN
 985 void ai_big_chase_ct()
 986 {
 987         ai_chase_ct();
 988 }
 989
 990 extern void ai_select_secondary_weapon(object *objp, ship_weapon *swp, int priority1 = -1, int priority2 = -1);
 991 extern float set_secondary_fire_delay(ai_info *aip, ship *shipp, weapon_info *swip);
 992 extern void ai_choose_secondary_weapon(object *objp, ai_info *aip, object *en_objp);
 993 extern int maybe_avoid_big_ship(object *objp, object *ignore_objp, ai_info *aip, vector *goal_point, float delta_time);
 994
 995 extern void maybe_cheat_fire_synaptic(object *objp, ai_info *aip);
 996
 997 // Determine if Pl_objp should fire weapons at current target, based on input parameters
 998 //
 999 // dist_to_enemy        =>              distance (in m) to attack point on current target
1000 // dot_to_enemy =>              dot product between fvec of Pl_objp and vector from Pl_objp to attack point
1001 //
1002 void ai_big_maybe_fire_weapons(float dist_to_enemy, float dot_to_enemy, vector *firing_pos, vector *enemy_pos, vector *enemy_vel)
1003 {
1004         ai_info         *aip;
1005         ship_weapon     *swp;
1006
1007         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1008         swp = &Ships[Pl_objp->instance].weapons;
1009
1010         if (dot_to_enemy > 0.95f - 0.5f * En_objp->radius/max(1.0f, En_objp->radius + dist_to_enemy)) {
1011                 aip->time_enemy_in_range += flFrametime;
1012
1013                 //      Chance of hitting ship is based on dot product of firing ship's forward vector with vector to ship
1014                 //      and also the size of the target relative to distance to target.
1015                 if (dot_to_enemy > max(0.5f, 0.90f + aip->ai_accuracy/10.0f - En_objp->radius/max(1.0f,dist_to_enemy))) {
1016
1017                         ship *temp_shipp;
1018                         temp_shipp = &Ships[Pl_objp->instance];
1019                         ship_weapon *tswp = &temp_shipp->weapons;
1020
1021                         if ( tswp->num_primary_banks > 0 ) {
1022                                 Assert(tswp->current_primary_bank < tswp->num_primary_banks);
1023                                 weapon_info     *wip = &Weapon_info[tswp->primary_bank_weapons[tswp->current_primary_bank]];
1024
1025                                 if (dist_to_enemy < wip->max_speed * wip->lifetime)
1026                                         ai_fire_primary_weapon(Pl_objp);
1027
1028                                 int     priority1, priority2;
1029
1030                                 priority1 = -1;
1031                                 priority2 = -1;
1032
1033                                 //      Maybe favor selecting a bomb.
1034                                 //      Note, if you're firing a bomb, if it's aspect seeking, the firing conditions can be looser.
1035                                 if (Ship_info[Ships[En_objp->instance].ship_info_index].flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP))
1036                                         if (En_objp->phys_info.speed * dist_to_enemy < 5000.0f)         //      Don't select a bomb if enemy moving fast relative to distance
1037                                                 priority1 = WIF_BOMB;
1038
1039                                 if (!(En_objp->flags & OF_PROTECTED)) {
1040                                         //ai_select_secondary_weapon(Pl_objp, tswp, priority1, priority2);      //      Note, need to select to get weapon speed and lifetime
1041
1042                                         ai_choose_secondary_weapon(Pl_objp, aip, En_objp);
1043                                         int current_bank = tswp->current_secondary_bank;
1044                                         weapon_info     *swip = &Weapon_info[tswp->secondary_bank_weapons[current_bank]];
1045
1046                                         //      If ship is protected and very low on hits, don't fire missiles.
1047                                         if ((current_bank > -1) &&  (!(En_objp->flags & OF_PROTECTED) || (En_objp->hull_strength > 10*swip->damage))) {
1048                                                 if (aip->ai_flags & AIF_UNLOAD_SECONDARIES) {
1049                                                         if (timestamp_until(swp->next_secondary_fire_stamp[current_bank]) > swip->fire_wait*1000.0f) {
1050                                                                 swp->next_secondary_fire_stamp[current_bank] = timestamp((int) (swip->fire_wait*1000.0f));
1051                                                         }
1052                                                 }
1053
1054                                                 if (timestamp_elapsed(swp->next_secondary_fire_stamp[current_bank])) {
1055
1056                                                         float firing_range = swip->max_speed * swip->lifetime;
1057                                                         // reduce firing range of secondaries in nebula
1058                                                         extern int Nebula_sec_range;
1059                                                         if ((The_mission.flags & MISSION_FLAG_FULLNEB) && Nebula_sec_range) {
1060                                                                 firing_range *= 0.8f;
1061                                                         }
1062
1063                                                         float t = 0.25f;        //      default delay in seconds until next fire.
1064
1065                                                         if (dist_to_enemy < firing_range*1.0f) {
1066
1067
1068                                                                 //vm_vec_scale_add(&future_enemy_pos, enemy_pos, enemy_vel, dist_to_enemy/swip->max_speed);
1069                                                                 //if (vm_vec_dist_quick(&future_enemy_pos, firing_pos) < firing_range * 0.8f) {
1070                                                                         if (ai_fire_secondary_weapon(Pl_objp)) {
1071                                                                                 if (aip->ai_flags & AIF_UNLOAD_SECONDARIES) {
1072                                                                                         t = swip->fire_wait;
1073                                                                                 } else {
1074                                                                                         t = set_secondary_fire_delay(aip, temp_shipp, swip);
1075                                                                                 }
1076
1077                                                                                 swp->next_secondary_fire_stamp[current_bank] = timestamp((int) (t*1000.0f));
1078                                                                         }
1079                                                                 //}
1080                                                         }
1081                                                         swp->next_secondary_fire_stamp[current_bank] = timestamp((int) (t*1000.0f));
1082                                                 }
1083                                         }
1084                                 }
1085                         }
1086                 }
1087         } else {
1088                 aip->time_enemy_in_range *= (1.0f - flFrametime);
1089         }
1090 }
1091
1092 // switch ai ship into chase mode
1093 void ai_big_switch_to_chase_mode(ai_info *aip)
1094 {
1095         aip->previous_mode = aip->mode;
1096         aip->mode = AIM_CHASE;
1097         aip->submode = SM_ATTACK;
1098         aip->submode_start_time = Missiontime;
1099 }
1100
1101 extern int ai_big_strafe_maybe_retreat(float dist, vector *target_pos);
1102
1103 // Make object Pl_objp chase object En_objp, which is a big ship, not a small ship.
1104 void ai_big_chase()
1105 {
1106         float                   dist_to_enemy, dot_to_enemy;
1107         vector          player_pos, enemy_pos, vec_to_enemy;
1108         ship_info       *sip = &Ship_info[Ships[Pl_objp->instance].ship_info_index];
1109         ship                    *shipp = &Ships[Pl_objp->instance];
1110         ai_info         *aip = &Ai_info[shipp->ai_index];
1111         int                     enemy_ship_type;
1112         vector          predicted_enemy_pos;
1113
1114         Assert(aip->mode == AIM_CHASE);
1115
1116         maybe_cheat_fire_synaptic(Pl_objp, aip);
1117
1118         enemy_ship_type = Ship_info[Ships[En_objp->instance].ship_info_index].flags;
1119
1120         ai_set_positions(Pl_objp, En_objp, aip, &player_pos, &enemy_pos);
1121
1122         player_pos = Pl_objp->pos;
1123         ai_big_pick_attack_point(En_objp, Pl_objp, &enemy_pos, 0.8f);
1124
1125         //      Compute the predicted position of the center of the ship, then add the delta to the goal pos.
1126         if (En_objp->phys_info.speed > 3.0f) {
1127                 set_predicted_enemy_pos(&predicted_enemy_pos, Pl_objp, En_objp, aip);
1128                 vm_vec_add2(&enemy_pos, &predicted_enemy_pos);
1129                 vm_vec_sub2(&enemy_pos, &En_objp->pos);
1130         }       else
1131                 predicted_enemy_pos = En_objp->pos;
1132
1133         if (aip->targeted_subsys != NULL) {
1134                 get_subsystem_pos(&enemy_pos, En_objp, aip->targeted_subsys);
1135         }
1136
1137         dist_to_enemy = vm_vec_normalized_dir(&vec_to_enemy, &enemy_pos, &player_pos); // - En_objp->radius;
1138         dot_to_enemy = vm_vec_dot(&vec_to_enemy, &Pl_objp->orient.fvec);
1139
1140         if (aip->ai_flags & AIF_TARGET_COLLISION) {
1141                 if ( ai_big_strafe_maybe_retreat(dist_to_enemy, &enemy_pos) ) {
1142                         aip->mode = AIM_STRAFE;
1143                         aip->submode = AIS_STRAFE_AVOID;
1144                         aip->submode_parm0 = Missiontime;       // use parm0 as time strafe mode entered
1145                         return;
1146                 }
1147         }
1148
1149         if (aip->ai_flags & AIF_KAMIKAZE) {
1150                 //nprintf(("AI", "Kamikaze: %7.3f %7.3f\n", dot_to_enemy, dist_to_enemy));
1151                 accelerate_ship(aip, 1.0f);
1152                 if ((dist_to_enemy < 400.0f) && ai_maybe_fire_afterburner(Pl_objp, aip)) {
1153                         afterburners_start(Pl_objp);
1154                         aip->afterburner_stop_time = Missiontime + 3*F1_0;
1155                 }
1156         }
1157
1158         //      If just acquired target, or target is not in reasonable cone, don't refine believed enemy position.
1159         if ((dot_to_enemy < 0.25f) || (aip->target_time < 1.0f) || (aip->ai_flags & AIF_SEEK_LOCK)) {
1160                 update_aspect_lock_information(aip, &vec_to_enemy, dist_to_enemy - En_objp->radius, En_objp->radius);
1161         } else if (aip->targeted_subsys != NULL) {
1162                 Assert(aip->targeted_subsys != NULL);
1163                 get_subsystem_pos(&enemy_pos, En_objp, aip->targeted_subsys);
1164                 vm_vec_add2(&enemy_pos, &predicted_enemy_pos);
1165                 vm_vec_sub2(&enemy_pos, &En_objp->pos);
1166                 dist_to_enemy = vm_vec_normalized_dir(&vec_to_enemy, &enemy_pos, &player_pos); // - En_objp->radius;
1167                 dot_to_enemy = vm_vec_dot(&vec_to_enemy, &Pl_objp->orient.fvec);
1168                 update_aspect_lock_information(aip, &vec_to_enemy, dist_to_enemy, En_objp->radius);
1169         } else if (En_objp->flags & OF_PROTECTED) {     //      If protected and we're not attacking a subsystem, stop attacking!
1170                 update_aspect_lock_information(aip, &vec_to_enemy, dist_to_enemy - En_objp->radius, En_objp->radius);
1171                 aip->target_objnum = -1;
1172                 if (find_enemy(Pl_objp-Objects, MAX_ENEMY_DISTANCE, Skill_level_max_attackers[Game_skill_level]) == -1) {
1173                         ai_do_default_behavior(Pl_objp);
1174                         return;
1175                 }
1176         } else {
1177                 update_aspect_lock_information(aip, &vec_to_enemy, dist_to_enemy - En_objp->radius, En_objp->radius);
1178         }
1179
1180         //      If recently acquired target and not looking at target, just turn a bit.
1181         switch (aip->submode) {
1182         case SM_ATTACK:
1183         case SM_SUPER_ATTACK:
1184                 if (vm_vec_dist_quick(&Pl_objp->pos, &predicted_enemy_pos) > 100.0f + En_objp->radius * 2.0f) {
1185                         if (maybe_avoid_big_ship(Pl_objp, En_objp, aip, &predicted_enemy_pos, 10.0f))
1186                                 return;
1187                 }
1188
1189                 if (aip->target_time < 2.0f)
1190                         if ((dot_to_enemy < 0.9f) || (dist_to_enemy > 300.0f)) {
1191                                 aip->submode = SM_CONTINUOUS_TURN;
1192                                 aip->submode_start_time = Missiontime - fl2f(2.75f);    //      This backdated start time allows immediate switchout.
1193                                 if (dot_to_enemy > 0.0f)
1194                                         aip->target_time += flFrametime * dot_to_enemy;
1195                         }
1196                 break;
1197         }
1198
1199         //
1200         //      Set turn and acceleration based on submode.
1201         //
1202         switch (aip->submode) {
1203         case SM_CONTINUOUS_TURN:
1204                 ai_big_chase_ct();
1205                 break;
1206
1207         case SM_ATTACK:
1208         case SM_SUPER_ATTACK:
1209         case SM_ATTACK_FOREVER:
1210                 ai_big_chase_attack(aip, sip, &enemy_pos, dist_to_enemy);
1211                 break;
1212
1213         case SM_EVADE:
1214                 ai_big_evade_ship();
1215                 break;
1216
1217         case SM_AVOID:
1218                 ai_big_avoid_ship();
1219                 break;
1220
1221         case SM_EVADE_WEAPON:
1222                 evade_weapon();
1223                 break;
1224
1225         default:
1226                 aip->last_attack_time = Missiontime;
1227                 aip->submode = SM_ATTACK;
1228                 break;
1229         }
1230
1231         // maybe Pl_objp was forced into strafe mode, if so return now
1232         if ( aip->mode == AIM_STRAFE )
1233                 return;
1234
1235         //      Maybe choose a new submode.
1236         if (aip->submode != SM_AVOID && aip->submode != SM_EVADE ) {
1237                 //      If a very long time since attacked, attack no matter what!
1238                 if (aip->submode != SM_SUPER_ATTACK) {
1239                         if (Missiontime - aip->last_attack_time > i2f(6)) {
1240                                 aip->submode = SM_SUPER_ATTACK;
1241                                 aip->submode_start_time = Missiontime;
1242                                 aip->last_attack_time = Missiontime;
1243                         }
1244                 }
1245
1246                 //      If a collision is expected, pull out!
1247                 float dist_normal_to_enemy;
1248
1249                 if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
1250                         dist_normal_to_enemy = fl_abs((dist_to_enemy * vm_vec_dot(&vec_to_enemy, &aip->big_attack_surface_normal)));
1251                 } else {
1252                         // don;t have normal so use a conservative value here
1253                         dist_normal_to_enemy = 0.3f * dist_to_enemy;
1254                 }
1255
1256 //              float time_to_enemy = dist_normal_to_enemy / Pl_objp->phys_info.speed * fl_abs(vm_vec_dot(&Pl_objp->phys_info.vel, &aip->big_attack_surface_normal));
1257 //              if (Framecount % 30 == 1) {
1258 //                      mprintf(("normal dist; %.1f, time: %.1f\n", dist_normal_to_enemy, time_to_enemy));
1259 //              }
1260
1261                 // since we're not in strafe and we may get a bad normal, cap dist_normal_to_enemy as min(0.3*dist_to_enemy, self)
1262                 // this will allow us to get closer on a bad normal
1263                 dist_normal_to_enemy = max(0.3f*dist_to_enemy, dist_normal_to_enemy);
1264
1265                 if (dist_to_enemy < ATTACK_COLLIDE_BASE_DIST) {
1266                         // within 50m or 1sec
1267                         float time_to_enemy;
1268                         if (vm_vec_mag_squared(&aip->big_attack_surface_normal) > 0.9) {
1269                                 if (Pl_objp->phys_info.speed > 0.1) {
1270                                         time_to_enemy = dist_normal_to_enemy / fl_abs(vm_vec_dot(&Pl_objp->phys_info.vel, &aip->big_attack_surface_normal));
1271                                 } else {
1272                                         // a big time
1273                                         time_to_enemy = 100.0f;
1274                                 }
1275                         } else {
1276                                 if (Pl_objp->phys_info.speed > 0.1) {
1277                                         time_to_enemy = dist_normal_to_enemy / Pl_objp->phys_info.speed;
1278                                 } else {
1279                                         // a big time
1280                                         time_to_enemy = 100.0f;
1281                                 }
1282                         }
1283
1284                         float speed_dist = max(0.0f, (Pl_objp->phys_info.speed-50) * 2);
1285                         if ((dist_normal_to_enemy < ATTACK_COLLIDE_AVOID_DIST + speed_dist) || (time_to_enemy < ATTACK_COLLIDE_AVOID_TIME) ) {
1286                                 // get away, simulate crsh recovery (don't use avoid)
1287 //                              accelerate_ship(aip, -1.0f);
1288                                 big_ship_collide_recover_start(Pl_objp, En_objp, &Pl_objp->pos, NULL);
1289 //                              aip->submode = SM_AVOID;
1290 //                              aip->submode_start_time = Missiontime;
1291                         } else if ((dist_normal_to_enemy < ATTACK_COLLIDE_SLOW_DIST) || (time_to_enemy < ATTACK_COLLIDE_SLOW_TIME) ) {
1292                                 // slow down
1293                                 accelerate_ship(aip, -1.0f);
1294                         }
1295                 }
1296
1297                 /*
1298                 if ((dot_to_enemy > 1.0f - 0.1f * En_objp->radius/(dist_to_enemy + 1.0f)) && (Pl_objp->phys_info.speed > dist_to_enemy/5.0f)) {
1299                         if (might_collide_with_ship(Pl_objp, En_objp, dot_to_enemy, dist_to_enemy, (aip->targeted_subsys == NULL)*2.0f + 1.5f)) {
1300                                 if ((Missiontime - aip->last_hit_time > F1_0*4) && (dist_to_enemy < Pl_objp->radius*2 + En_objp->radius*2)) {
1301                                         accelerate_ship(aip, -1.0f);
1302                                 } else {
1303                                         aip->submode = SM_AVOID;
1304                                         aip->submode_start_time = Missiontime;
1305                                 }
1306                         }
1307                 } */
1308         }
1309
1310         switch (aip->submode) {
1311         case SM_CONTINUOUS_TURN:
1312                 if (Missiontime - aip->submode_start_time > i2f(3)) {
1313                         aip->last_attack_time = Missiontime;
1314                         aip->submode = SM_ATTACK;
1315                         aip->submode_start_time = Missiontime;
1316                 }
1317                 break;
1318
1319         case SM_ATTACK:
1320         case SM_ATTACK_FOREVER:
1321                 break;
1322
1323         case SM_EVADE:
1324                 if (dist_to_enemy > 4*En_objp->radius) {
1325                         aip->submode = SM_ATTACK;
1326                         aip->submode_start_time = Missiontime;
1327                         aip->last_attack_time = Missiontime;
1328                 }
1329                 break;
1330
1331         case SM_SUPER_ATTACK:
1332                 break;
1333
1334         case SM_AVOID:
1335                 // if outside box by > 300 m
1336                 // DA 4/20/98  can never get here attacking a big ship
1337                 {
1338                 int is_inside;
1339                 float box_dist = get_world_closest_box_point_with_delta(NULL, En_objp, &Pl_objp->pos, &is_inside, 0.0f);
1340
1341                 if (box_dist > 300) {
1342                         aip->submode = SM_ATTACK;
1343                         aip->last_attack_time = Missiontime;
1344                         aip->submode_start_time = Missiontime;
1345                 }
1346                 }
1347                 break;
1348
1349 /*              if (dot_to_enemy > -0.2f) {
1350                         aip->submode_start_time = Missiontime;
1351                 } else if (Missiontime - aip->submode_start_time > i2f(1)/2) {
1352                         if (might_collide_with_ship(Pl_objp, En_objp, dot_to_enemy, dist_to_enemy, 3.0f)) {
1353                                 aip->submode_start_time = Missiontime;
1354                         } else {
1355                                 aip->submode = SM_ATTACK;
1356                                 aip->last_attack_time = Missiontime;
1357                                 aip->submode_start_time = Missiontime;
1358                         }
1359                 }
1360
1361                 break;*/
1362
1363         case SM_EVADE_WEAPON:
1364                 if (aip->danger_weapon_objnum == -1) {
1365                         aip->submode = SM_ATTACK;
1366                         aip->submode_start_time = Missiontime;
1367                         aip->last_attack_time = Missiontime;
1368                 }
1369                 break;
1370
1371         default:
1372                 aip->submode = SM_ATTACK;
1373                 aip->last_attack_time = Missiontime;
1374                 aip->submode_start_time = Missiontime;
1375         }
1376
1377         //
1378         //      Maybe fire primary weapon and update time_enemy_in_range
1379         //
1380         //nprintf(("AI", "time_enemy_in_range = %7.3f, dot = %7.3f\n", aip->time_enemy_in_range, dot_to_enemy));
1381
1382         // AL: add condition that Pl_objp must not be following a path to fire.  This may be too extreme, but
1383         //     I noticed AI ships firing inappropriately when following a path near a big ship.
1384         //               TODO: investigate why ships fire (and aren't close to hitting ship) when following a path near
1385         //                               a big ship
1386         if (aip->mode != AIM_EVADE && aip->path_start == -1 ) {
1387                 ai_big_maybe_fire_weapons(dist_to_enemy, dot_to_enemy, &player_pos, &predicted_enemy_pos, &En_objp->phys_info.vel);
1388         } else
1389                 aip->time_enemy_in_range *= (1.0f - flFrametime);
1390 }
1391
1392 void ai_big_ship(object *objp)
1393 {
1394         // do nothing
1395 }
1396
1397 // all three parms are output parameters
1398 //      Enemy object is En_objp
1399 // pos  =>              world pos of attack point
1400 // dist =>              distance from Pl_objp front to attack point
1401 // dot  =>              dot of Pl_objp fvec and vector to attack point
1402 //      fire_pos =>     world pos from which firing
1403 void ai_big_attack_get_data(vector *enemy_pos, float *dist_to_enemy, float *dot_to_enemy)
1404 {
1405         vector          player_pos, vec_to_enemy, predicted_enemy_pos;
1406         ship                    *shipp = &Ships[Pl_objp->instance];
1407         ai_info         *aip = &Ai_info[shipp->ai_index];
1408         ship_info       *esip = &Ship_info[Ships[En_objp->instance].ship_info_index];
1409
1410         Assert(aip->mode == AIM_STRAFE);
1411
1412         // ensure that Pl_objp is still targeting a big ship
1413         if ( !(esip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) ) {
1414                 ai_big_switch_to_chase_mode(aip);
1415                 return;
1416         }
1417
1418         ai_set_positions(Pl_objp, En_objp, aip, &player_pos, enemy_pos);
1419
1420         player_pos = Pl_objp->pos;
1421
1422         if (aip->targeted_subsys != NULL) {
1423                 Assert(aip->targeted_subsys != NULL);
1424                 get_subsystem_pos(enemy_pos, En_objp, aip->targeted_subsys);
1425         } else {
1426                 // checks valid line to target
1427                 ai_big_pick_attack_point(En_objp, Pl_objp, enemy_pos, 0.8f);
1428         }
1429
1430         // Take player pos to be center of ship + ship_radius
1431         vm_vec_scale_add2(&player_pos, &Pl_objp->orient.fvec, Pl_objp->radius);
1432
1433         //      If seeking lock, try to point directly at ship, else predict position so lasers can hit it.
1434         //      If just acquired target, or target is not in reasonable cone, don't refine believed enemy position.
1435         vm_vec_normalized_dir(&vec_to_enemy, enemy_pos, &player_pos);
1436         *dot_to_enemy=vm_vec_dot(&vec_to_enemy, &Pl_objp->orient.fvec);
1437         if ((*dot_to_enemy < 0.25f) || (aip->target_time < 1.0f) || (aip->ai_flags & AIF_SEEK_LOCK)) {
1438                 predicted_enemy_pos=*enemy_pos;
1439         } else {
1440                 vector  gun_pos, pnt;
1441                 polymodel *po = model_get( Ship_info[shipp->ship_info_index].modelnum );
1442                 float           weapon_speed;
1443
1444                 //      Compute position of gun in absolute space and use that as fire position.
1445                 pnt = po->gun_banks[0].pnt[0];
1446                 vm_vec_unrotate(&gun_pos, &pnt, &Pl_objp->orient);
1447                 vm_vec_add2(&gun_pos, &Pl_objp->pos);
1448                 weapon_speed = ai_get_weapon_speed(&shipp->weapons);
1449
1450                 set_predicted_enemy_pos_turret(&predicted_enemy_pos, &gun_pos, Pl_objp, enemy_pos, &En_objp->phys_info.vel, weapon_speed, aip->time_enemy_in_range);
1451         }
1452
1453         *dist_to_enemy = vm_vec_normalized_dir(&vec_to_enemy, &predicted_enemy_pos, &player_pos);
1454         *dot_to_enemy = vm_vec_dot(&vec_to_enemy, &Pl_objp->orient.fvec);
1455         update_aspect_lock_information(aip, &vec_to_enemy, *dist_to_enemy, En_objp->radius);
1456
1457         *enemy_pos = predicted_enemy_pos;
1458 }
1459
1460 // check to see if Pl_objp has gotten too close to attacking point.. if so, break off by entering
1461 // AIS_STRAFE_RETREAT
1462 int ai_big_strafe_maybe_retreat(float dist, vector *target_pos)
1463 {
1464         ai_info *aip;
1465         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1466
1467         vector vec_to_target;
1468         vm_vec_sub(&vec_to_target, target_pos, &Pl_objp->pos);
1469
1470         float dist_to_target, dist_normal_to_target, time_to_target;
1471         dist_to_target = vm_vec_mag_quick(&vec_to_target);
1472         if (vm_vec_mag_quick(&aip->big_attack_surface_normal) > 0.9) {
1473                 dist_normal_to_target = -vm_vec_dotprod(&vec_to_target, &aip->big_attack_surface_normal);
1474         } else {
1475                 dist_normal_to_target = 0.2f * vm_vec_mag_quick(&vec_to_target);
1476         }
1477
1478         dist_normal_to_target = max(0.2f*dist_to_target, dist_normal_to_target);
1479         time_to_target = dist_normal_to_target / Pl_objp->phys_info.speed;
1480
1481         // add distance penalty for going too fast
1482         float speed_to_dist_penalty = max(0.0f, (Pl_objp->phys_info.speed-50));
1483
1484         //if ((dot_to_enemy > 1.0f - 0.1f * En_objp->radius/(dist_to_enemy + 1.0f)) && (Pl_objp->phys_info.speed > dist_to_enemy/5.0f))
1485
1486         // Inside 2 sec retreat, setting goal point to box point + 300m
1487         // If collision, use std collision resolution.
1488         if ( !(aip->ai_flags & AIF_KAMIKAZE) && ((aip->ai_flags & AIF_TARGET_COLLISION) || (time_to_target < STRAFE_RETREAT_COLLIDE_TIME) || (dist_normal_to_target < STRAFE_RETREAT_COLLIDE_DIST + speed_to_dist_penalty)) ) {
1489                 if (aip->ai_flags & AIF_TARGET_COLLISION) {
1490                         // use standard collision resolution
1491                         aip->ai_flags &= ~AIF_TARGET_COLLISION;
1492                         big_ship_collide_recover_start(Pl_objp, En_objp, &Pl_objp->pos, NULL);
1493                 } else {
1494                         // too close for comfort so fly to box point + 300
1495                         aip->submode = AIS_STRAFE_RETREAT1;
1496                         aip->submode_start_time = Missiontime;
1497
1498                         float box_dist;
1499                         int is_inside;
1500                         vector goal_point;
1501                         box_dist = get_world_closest_box_point_with_delta(&goal_point, En_objp, &Pl_objp->pos, &is_inside, STRAFE_RETREAT_BOX_DIST);
1502
1503                         // set goal point
1504                         aip->goal_point = goal_point;
1505
1506                         if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
1507                                 afterburners_start(Pl_objp);
1508                                 aip->afterburner_stop_time = Missiontime + 3*F1_0;
1509                         }
1510                 }
1511
1512                 return 1;
1513         } else {
1514                 return 0;
1515         }
1516 }
1517
1518 // attack directly to the turret and fire weapons
1519 void ai_big_strafe_attack()
1520 {
1521         ai_info *aip;
1522         vector  target_pos;
1523         vector  rand_vec;
1524         float           target_dist, target_dot, accel, t;
1525         object  *target_objp;
1526
1527         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1528
1529         if ( ai_big_maybe_follow_subsys_path(0) ) {
1530                 return;
1531         }
1532
1533         ai_big_attack_get_data(&target_pos, &target_dist, &target_dot);
1534         if ( ai_big_strafe_maybe_retreat(target_dist, &target_pos) )
1535                 return;
1536
1537         target_objp = &Objects[aip->target_objnum];
1538
1539         if (aip->ai_flags & AIF_KAMIKAZE) {
1540                 if (target_dist < 1200.0f) {
1541                         //nprintf(("AI", "Kamikaze: %7.3f %7.3f\n", target_dot, target_dist));
1542                         ai_turn_towards_vector(&target_pos, Pl_objp, flFrametime, Ship_info[Ships[Pl_objp->instance].ship_info_index].srotation_time, NULL, NULL, 0.0f, 0);
1543                         accelerate_ship(aip, 1.0f);
1544                         if ((target_dist < 400.0f) && ai_maybe_fire_afterburner(Pl_objp, aip)) {
1545                                 afterburners_start(Pl_objp);
1546                                 aip->afterburner_stop_time = Missiontime + 3*F1_0;
1547                         }
1548                         return;
1549                 }
1550         }
1551
1552         if (!(aip->ai_flags & AIF_SEEK_LOCK) || (aip->aspect_locked_time < 2.0f)) {
1553                 t  = ai_endangered_by_weapon(aip);
1554                 if ( t > 0.0f && t < 1.5f ) {
1555                         // set up goal_point for avoid path to turn towards
1556                         aip->goal_point = Pl_objp->pos;
1557                         switch(rand()%4) {
1558                         case 0:
1559                                 vm_vec_scale_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.uvec, 2.0f);
1560                                 break;
1561                         case 1:
1562                                 vm_vec_scale_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.uvec, -2.0f);
1563                                 break;
1564                         case 2:
1565                                 vm_vec_scale_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.rvec, 2.0f);
1566                                 break;
1567                         case 3:
1568                                 vm_vec_scale_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.rvec, -2.0f);
1569                                 break;
1570                         } // end switch
1571
1572                         vm_vec_scale(&rand_vec, 1000.0f);
1573                         vm_vec_add2(&aip->goal_point, &rand_vec);
1574
1575                         aip->submode = AIS_STRAFE_AVOID;
1576                         aip->submode_start_time = Missiontime;
1577         //              nprintf(("Alan","Ship %s entering AIS_STRAFE_AVOID at frame %d\n", Ships[aip->shipnum].ship_name, Framecount));
1578
1579                         if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
1580                                 afterburners_start(Pl_objp);
1581                                 aip->afterburner_stop_time = Missiontime + fl2f(0.5f);
1582                         }
1583                 }
1584         }
1585
1586         // maybe fire weapons at target
1587         ai_big_maybe_fire_weapons(target_dist, target_dot, &Pl_objp->pos, &En_objp->pos, &En_objp->phys_info.vel);
1588         turn_towards_point(Pl_objp, &target_pos, NULL, 0.0f);
1589
1590         // Slow down if we've not been hit for a while
1591         fix last_hit = Missiontime - aip->last_hit_time;
1592         if ( target_dist > 1200 || last_hit < F1_0*6) {
1593                 accel = 1.0f;
1594         } else {
1595                 float attack_time;
1596                 attack_time = f2fl(Missiontime - aip->submode_start_time);
1597                 if ( attack_time > 15 ) {
1598                         accel = 0.2f;
1599                 } else if ( attack_time > 10 ) {
1600                         accel = 0.4f;
1601                 } else if ( attack_time > 8 ) {
1602                         accel = 0.6f;
1603                 } else if ( attack_time > 5 ) {
1604                         accel = 0.8f;
1605                 } else {
1606                         accel = 1.0f;
1607                 }
1608         }
1609
1610         accel = 1.0f;
1611         accelerate_ship(aip, accel);
1612
1613         // if haven't been hit in quite a while, leave strafe mode
1614         fix long_enough;
1615         long_enough = F1_0*20;
1616         if ( (last_hit > long_enough) && ( (Missiontime - aip->submode_parm0) > long_enough) ) {
1617                 ai_big_switch_to_chase_mode(aip);
1618         }
1619 }
1620
1621 // pick a new attack point when entering this state, and keep using it
1622 void ai_big_strafe_avoid()
1623 {
1624         ai_info *aip;
1625         vector  target_pos;
1626         float           target_dist, target_dot;
1627         fix             mode_time;
1628
1629         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1630
1631         mode_time = Missiontime - aip->submode_start_time;
1632
1633         ai_big_attack_get_data(&target_pos, &target_dist, &target_dot);
1634         if ( ai_big_strafe_maybe_retreat(target_dist, &target_pos) )
1635                 return;
1636
1637         if ( mode_time > fl2f(0.5)) {
1638                 aip->submode = AIS_STRAFE_ATTACK;
1639                 aip->submode_start_time = Missiontime;
1640 //              nprintf(("Alan","Ship %s entering AIS_STRAFE_ATTACK at frame %d\n", Ships[aip->shipnum].ship_name, Framecount));
1641         }
1642
1643         turn_towards_point(Pl_objp, &aip->goal_point, NULL, 0.0f);
1644         accelerate_ship(aip, 1.0f);
1645 }
1646
1647 // move towards aip->goal_point in an evasive manner
1648 void ai_big_strafe_retreat1()
1649 {
1650         float dist;
1651         ai_info *aip;
1652         vector  rand_vec;
1653
1654         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1655
1656         dist = vm_vec_dist_quick(&Pl_objp->pos, &aip->goal_point);
1657         if ( dist < 70 ) {
1658                 aip->submode = AIS_STRAFE_POSITION;
1659                 aip->submode_start_time = Missiontime;
1660 //              nprintf(("Alan","Ship %s entering AIS_STRAFE_POSITION\n", Ships[aip->shipnum].ship_name));
1661                 return;
1662         }
1663
1664         if (Missiontime - aip->submode_start_time > fl2f(1.50f)) {
1665                 // set up goal_point for avoid path to turn towards
1666                 aip->prev_goal_point = Pl_objp->pos;
1667                 switch(rand()%4) {
1668                 case 0:
1669                         vm_vec_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.uvec);
1670                         break;
1671                 case 1:
1672                         vm_vec_scale_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.uvec, -1.0f);
1673                         break;
1674                 case 2:
1675                         vm_vec_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.rvec);
1676                         break;
1677                 case 3:
1678                         vm_vec_scale_add(&rand_vec, &Pl_objp->orient.fvec, &Pl_objp->orient.rvec, -1.0f);
1679                         break;
1680                 } // end switch
1681
1682                 //vm_vec_scale(&rand_vec, 200.0f);
1683                 //vm_vec_add2(&aip->prev_goal_point, &rand_vec);
1684                 vm_vec_scale_add(&aip->prev_goal_point, &aip->goal_point, &rand_vec, 200.0f);
1685
1686                 aip->submode = AIS_STRAFE_RETREAT2;
1687                 aip->submode_start_time = Missiontime;
1688         }
1689
1690         turn_towards_point(Pl_objp, &aip->goal_point, NULL, 0.0f);
1691         accelerate_ship(aip, 1.0f);
1692 }
1693
1694 void ai_big_strafe_retreat2()
1695 {
1696         float dist;
1697         ai_info *aip;
1698
1699         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1700
1701         if (Pl_objp->phys_info.flags & PF_AFTERBURNER_ON ) {
1702                 if (Missiontime > aip->afterburner_stop_time) {
1703                         //nprintf(("AI", "Frame %i, turning off afterburner.\n", AI_FrameCount));
1704                         afterburners_stop(Pl_objp);
1705                 }
1706         }
1707
1708         dist = vm_vec_dist_quick(&Pl_objp->pos, &aip->goal_point);
1709         if ( dist < 70 ) {
1710                 aip->submode = AIS_STRAFE_POSITION;
1711                 aip->submode_start_time = Missiontime;
1712 //              nprintf(("Alan","Ship %s entering AIS_STRAFE_POSITION\n", Ships[aip->shipnum].ship_name));
1713                 return;
1714         }
1715
1716         if (Missiontime - aip->submode_start_time > fl2f(0.70f)) {
1717                 aip->submode = AIS_STRAFE_RETREAT1;
1718                 aip->submode_start_time = Missiontime;
1719
1720                 if ( (Missiontime - aip->last_hit_time) < F1_0*5 ) {
1721                         if (ai_maybe_fire_afterburner(Pl_objp, aip)) {
1722                                 afterburners_start(Pl_objp);
1723                                 aip->afterburner_stop_time = Missiontime + F1_0;
1724                         }
1725                 }
1726         }
1727
1728         turn_towards_point(Pl_objp, &aip->prev_goal_point, NULL, 0.0f);
1729         accelerate_ship(aip, 1.0f);
1730 }
1731
1732 // reposition self to begin another strafing run
1733 void ai_big_strafe_position()
1734 {
1735         ai_info *aip;
1736         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1737         // TODO: loop around or something!!
1738
1739         aip->submode = AIS_STRAFE_ATTACK;
1740         aip->submode_start_time = Missiontime;
1741 //      nprintf(("Alan","Ship %s entering AIS_STRAFE_ATTACK\n", Ships[aip->shipnum].ship_name));
1742 }
1743
1744 //      --------------------------------------------------------------------------
1745 // #define      AIS_STRAFE_ATTACK               201     // fly towards target and attack
1746 // #define      AIS_STRAFE_AVOID                202     // fly evasive vector to avoid incoming fire
1747 // #define      AIS_STRAFE_RETREAT1     203     // fly away from attack point (directly)
1748 // #define      AIS_STRAFE_RETREAT1     204     // fly away from attack point (on an avoid vector)
1749 // #define      AIS_STRAFE_POSITION     205     // re-position to resume strafing attack
1750 //
1751 void ai_big_strafe()
1752 {
1753         ai_info *aip;
1754
1755         aip = &Ai_info[Ships[Pl_objp->instance].ai_index];
1756
1757         Assert(aip->mode == AIM_STRAFE);
1758
1759 /*
1760         if ( aip->goal_objnum != aip->target_objnum ) {
1761                 Int3(); // what is going on here? - Get Alan
1762                 aip->mode = AIM_NONE;
1763                 return;
1764         }
1765 */
1766
1767         // check if target is still a big ship... if not enter chase mode
1768         if ( !(Ship_info[Ships[En_objp->instance].ship_info_index].flags & (SIF_BIG_SHIP|SIF_HUGE_SHIP)) ) {
1769                 ai_big_switch_to_chase_mode(aip);
1770                 return;
1771         }
1772
1773         switch (aip->submode) {
1774         case AIS_STRAFE_ATTACK:
1775                 ai_big_strafe_attack();
1776                 break;
1777         case AIS_STRAFE_AVOID:
1778                 ai_big_strafe_avoid();
1779                 break;
1780         case AIS_STRAFE_RETREAT1:
1781                 ai_big_strafe_retreat1();
1782                 break;
1783         case AIS_STRAFE_RETREAT2:
1784                 ai_big_strafe_retreat2();
1785                 break;
1786         case AIS_STRAFE_POSITION:
1787                 ai_big_strafe_position();
1788                 break;
1789         default:
1790
1791                 Int3();         //      Illegal submode for AIM_STRAFE
1792                 break;
1793         }
1794 }
1795
1796 // See if Pl_objp should enter strafe mode (This is called from maybe_evade_dumbfire_weapon(), and the
1797 // weapon_objnum is for a weapon that is about to collide with Pl_objp
1798 //
1799 // Check if weapon_objnum was fired by Pl_objp's target, and whether Pl_objp's target is a big ship, if
1800 // so, enter AIM_STRAFE
1801 int ai_big_maybe_enter_strafe_mode(object *pl_objp, int weapon_objnum, int consider_target_only)
1802 {
1803         ai_info         *aip;
1804         ship_info       *sip;
1805         object          *weapon_objp, *parent_objp;
1806
1807         aip = &Ai_info[Ships[pl_objp->instance].ai_index];
1808         Assert(aip->mode != AIM_STRAFE);                // can't happen
1809
1810         // if Pl_objp has no target, then we can't enter strafe mode
1811         if ( aip->target_objnum < 0 ) {
1812                 return 0;
1813         }
1814
1815         // if target is not a ship, stafe mode is not possible
1816         if ( Objects[aip->target_objnum].type != OBJ_SHIP ) {
1817                 return 0;
1818         }
1819
1820         sip = &Ship_info[Ships[Objects[aip->target_objnum].instance].ship_info_index];
1821
1822         // if Pl_objp's target is not a big/capital ship, then cannot enter strafe mode
1823         // AL 12-31-97: Even though transports are considered big ships, don't enter strafe mode on them
1824         if ( !(sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) || (sip->flags & SIF_TRANSPORT) ) {
1825                 return 0;
1826         }
1827
1828         //      If Pl_objp not a fighter or bomber, don't enter strafe mode. -- MK, 11/11/97.
1829         if ( !(Ship_info[Ships[pl_objp->instance].ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER)) ) {
1830                 return 0;
1831         }
1832
1833         Assert(weapon_objnum >= 0 && weapon_objnum < MAX_OBJECTS);
1834         weapon_objp = &Objects[weapon_objnum];
1835         Assert(weapon_objp->type == OBJ_WEAPON);
1836
1837         Assert(weapon_objp->parent >= 0 && weapon_objp->parent < MAX_OBJECTS);
1838         parent_objp = &Objects[weapon_objp->parent];
1839         if ( (parent_objp->signature != weapon_objp->parent_sig) || (parent_objp->type != OBJ_SHIP) ) {
1840                 return 0;
1841         }
1842
1843         // Maybe the ship which fired the weapon isn't the current target
1844         if ( OBJ_INDEX(parent_objp) != aip->target_objnum ) {
1845
1846 //JAS IMPOSSIBLE                if (1) { // consider_target_only ) {
1847 //JAS IMPOSSIBLE                        return 0;
1848 //JAS IMPOSSIBLE                } else {
1849                         // switch targets
1850                         sip = &Ship_info[Ships[parent_objp->instance].ship_info_index];
1851                         if ( !(sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) || (sip->flags & SIF_TRANSPORT) ) {
1852                                 return 0;
1853                         }
1854                         set_target_objnum(aip, OBJ_INDEX(parent_objp));
1855 //JAS IMPOSSIBLE                }
1856         }
1857
1858         ai_big_strafe_maybe_attack_turret(pl_objp, weapon_objp);
1859
1860         // if we've got this far, the weapon must have come from the player's target, and it is a
1861         // big/capital ship... so enter strafe mode
1862         aip->previous_mode = aip->mode;
1863         aip->mode = AIM_STRAFE;
1864         aip->submode_parm0 = Missiontime;       // use parm0 as time strafe mode entered
1865         aip->submode = AIS_STRAFE_AVOID;
1866         aip->submode_start_time = Missiontime;
1867 //      nprintf(("Alan","%s Accepted strafe mode\n", Ships[pl_objp->instance].ship_name));
1868
1869         return 1;
1870 }
1871
1872 // Consider attacking a turret, if a turret actually fired the weapon
1873 // input:       ship_objp       =>      ship that will attack the turret
1874 //                              weapon_objp     =>
1875 void ai_big_strafe_maybe_attack_turret(object *ship_objp, object *weapon_objp)
1876 {
1877         ai_info *aip;
1878         object  *parent_objp;
1879
1880         Assert(ship_objp->type == OBJ_SHIP);
1881         aip = &Ai_info[Ships[ship_objp->instance].ai_index];
1882
1883         // Make decision to attack turret based on AI class.  The better AI ships will realize that
1884         // it is better to take out the turrets first on a big ship.
1885         if ( (frand()*100) > (aip->ai_courage-15) )
1886                 return;
1887
1888         // If ship is already attacking a subsystem, don't switch
1889         if ( aip->targeted_subsys != NULL ) {
1890                 return;
1891         }
1892
1893         // If the weapon is not from a turret, return
1894         if ( Weapons[weapon_objp->instance].turret_subsys == NULL ) {
1895                 return;
1896         }
1897
1898         // Only attack turret if it sits on current target
1899         Assert(weapon_objp->parent >= 0 && weapon_objp->parent < MAX_OBJECTS);
1900         parent_objp = &Objects[weapon_objp->parent];
1901         if ( (parent_objp->signature != weapon_objp->parent_sig) || (parent_objp->type != OBJ_SHIP) ) {
1902                 return;
1903         }
1904
1905         if ( aip->target_objnum != OBJ_INDEX(parent_objp) ) {
1906                 return;
1907         }
1908
1909         // attack the turret
1910         set_targeted_subsys(aip, Weapons[weapon_objp->instance].turret_subsys, OBJ_INDEX(parent_objp));
1911 }