src/ship/shipfx.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/ShipFX.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * Routines for ship effects (as in special)
  16  *
  17  * $Log$
  18  * Revision 1.7  2004/07/04 11:39:06  taylor
  19  * fix missing debrief text, crash on exit, path separator's, warning fixes, no GR_SOFT
  20  *
  21  * Revision 1.6  2003/05/25 02:30:44  taylor
  22  * Freespace 1 support
  23  *
  24  * Revision 1.5  2002/09/04 01:12:11  relnev
  25  * changes to screen backup/mouse drawing code.  removed a few warnings.
  26  *
  27  * Revision 1.4  2002/06/17 06:33:11  relnev
  28  * ryan's struct patch for gcc 2.95
  29  *
  30  * Revision 1.3  2002/06/09 04:41:26  relnev
  31  * added copyright header
  32  *
  33  * Revision 1.2  2002/05/07 03:16:52  theoddone33
  34  * The Great Newline Fix
  35  *
  36  * Revision 1.1.1.1  2002/05/03 03:28:10  root
  37  * Initial import.
  38  *
  39  *
  40  * 51    9/13/99 4:53p Andsager
  41  *
  42  * 50    9/13/99 10:09a Andsager
  43  * Add debug console commands to lower model render detail and fireball
  44  * LOD for big ship explosiosns.
  45  *
  46  * 49    9/08/99 10:44p Andsager
  47  * Make HUGE ships not die when warping out, after warp effect started.
  48  *
  49  * 48    9/06/99 10:16p Andsager
  50  * Modify big ship explosions.  Less frequent fireballs, fewer particles,
  51  * larger fireballs
  52  *
  53  * 47    9/05/99 11:10a Andsager
  54  * Fix up which split ship get debris pieces.  Dont render debris pieces
  55  * for split ships until they are near clip plane.
  56  *
  57  * 46    9/02/99 12:55a Mikek
  58  * Scale engine wash by speed.
  59  *
  60  * 45    9/01/99 10:15a Dave
  61  *
  62  * 44    8/31/99 10:13p Andsager
  63  * Add Knossos warp effect fireball
  64  *
  65  * 43    8/23/99 11:09a Andsager
  66  * Round 2 of Knossos explosion
  67  *
  68  * 42    8/20/99 2:16p Andsager
  69  * Make only supercaps slow down extra fast after warping in.
  70  *
  71  * 41    8/20/99 1:42p Andsager
  72  * Frist pass on Knossos explosion.
  73  *
  74  * 40    8/19/99 4:36p Andsager
  75  * Cleaned up special_warpout
  76  *
  77  * 39    8/16/99 10:04p Andsager
  78  * Add special-warp-dist and special-warpout-name sexp for Knossos device
  79  * warpout.
  80  *
  81  * 38    8/16/99 2:01p Andsager
  82  * Knossos warp-in warp-out.
  83  *
  84  * 37    8/13/99 10:49a Andsager
  85  * Knossos and HUGE ship warp out.  HUGE ship warp in.  Stealth search
  86  * modes dont collide big ships.
  87  *
  88  * 36    8/05/99 2:06a Dave
  89  * Whee.
  90  *
  91  * 35    7/18/99 12:32p Dave
  92  * Randomly oriented shockwaves.
  93  *
  94  * 34    7/09/99 12:52a Andsager
  95  * Modify engine wash (1) less damage (2) only at a closer range (3) no
  96  * damage when engine is disabled
  97  *
  98  * 33    7/06/99 10:45a Andsager
  99  * Modify engine wash to work on any ship that is not small.  Add AWACS
 100  * ask for help.
 101  *
 102  * 32    7/02/99 9:55p Dave
 103  * Player engine wash sound.
 104  *
 105  * 31    7/02/99 4:31p Dave
 106  * Much more sophisticated lightning support.
 107  *
 108  * 30    7/01/99 4:23p Dave
 109  * Full support for multiple linked ambient engine sounds. Added "big
 110  * damage" flag.
 111  *
 112  * 29    7/01/99 11:44a Dave
 113  * Updated object sound system to allow multiple obj sounds per ship.
 114  * Added hit-by-beam sound. Added killed by beam sound.
 115  *
 116  * 28    6/17/99 12:06p Andsager
 117  * Add a fireball for each live debris piece.
 118  *
 119  * 27    6/14/99 3:21p Andsager
 120  * Allow collisions between ship and its debris.  Fix up collision pairs
 121  * when large ship is warping out.
 122  *
 123  * 26    5/27/99 12:14p Andsager
 124  * Some fixes for live debris when more than one subsys on ship with live
 125  * debris.  Set subsys strength (when 0) blows off subsystem.
 126  * sexp_hits_left_subsystem works for SUBSYSTEM_UNKNOWN.
 127  *
 128  * 25    5/26/99 11:46a Dave
 129  * Added ship-blasting lighting and made the randomization of lighting
 130  * much more customizable.
 131  *
 132  * 24    5/25/99 10:05a Andsager
 133  * Fix assert with wing warping out with no warp effect.
 134  *
 135  * 23    5/24/99 5:45p Dave
 136  * Added detail levels to the nebula, with a decent speedup. Split nebula
 137  * lightning into its own section.
 138  *
 139  * 22    5/21/99 5:03p Andsager
 140  * Add code to display engine wash death.  Modify ship_kill_packet
 141  *
 142  * 21    5/19/99 11:09a Andsager
 143  * Turn on engine wash.  Check every 1/4 sec.
 144  *
 145  * 20    5/18/99 1:30p Dave
 146  * Added muzzle flash table stuff.
 147  *
 148  * 19    5/17/99 10:33a Dave
 149  * Fixed warning.
 150  *
 151  * 18    5/11/99 10:16p Andsager
 152  * First pass on engine wash effect.  Rotation (control input), damage,
 153  * shake.
 154  *
 155  * 17    5/09/99 6:00p Dave
 156  * Lots of cool new effects. E3 build tweaks.
 157  *
 158  * 16    4/28/99 11:13p Dave
 159  * Temporary checkin of artillery code.
 160  *
 161  * 15    3/29/99 6:17p Dave
 162  * More work on demo system. Got just about everything in except for
 163  * blowing ships up, secondary weapons and player death/warpout.
 164  *
 165  * 14    3/28/99 5:58p Dave
 166  * Added early demo code. Make objects move. Nice and framerate
 167  * independant, but not much else. Don't use yet unless you're me :)
 168  *
 169  * 13    3/23/99 2:29p Andsager
 170  * Fix shockwaves for kamikazi and Fred defined.  Collect together
 171  * shockwave_create_info struct.
 172  *
 173  * 12    3/20/99 3:03p Andsager
 174  * Fix get_model_cross_section_at_z() from getting invalid index .
 175  *
 176  * 11    3/19/99 9:51a Dave
 177  * Checkin to repair massive source safe crash. Also added support for
 178  * pof-style nebulae, and some new weapons code.
 179  *
 180  * 10    2/26/99 4:14p Dave
 181  * Put in the ability to have multiple shockwaves for ships.
 182  *
 183  * 9     1/29/99 12:47a Dave
 184  * Put in sounds for beam weapon. A bunch of interface screens (tech
 185  * database stuff).
 186  *
 187  * 8     1/28/99 9:10a Andsager
 188  * Particles increased in width, life, number.  Max particles increased
 189  *
 190  * 7     1/27/99 9:56a Dave
 191  * Temporary checkin of beam weapons for Dan to make cool sounds.
 192  *
 193  * 6     1/11/99 12:42p Andsager
 194  * Add live debris - debris which is created from a destroyed subsystem,
 195  * when the ship is still alive
 196  *
 197  * 5     11/18/98 10:29a Johnson
 198  * fix assert in shipfx_remove_submodel_ship_sparks.  submodel may not
 199  * have spark and be destroyed.
 200  *
 201  * 4     11/17/98 4:27p Andsager
 202  * Stop sparks from emitting from destroyed subobjects
 203  *
 204  * 3     10/20/98 1:39p Andsager
 205  * Make so sparks follow animated ship submodels.  Modify
 206  * ship_weapon_do_hit_stuff() and ship_apply_local_damage() to add
 207  * submodel_num.  Add submodel_num to multiplayer hit packet.
 208  *
 209  * 2     10/07/98 10:53a Dave
 210  * Initial checkin.
 211  *
 212  * 1     10/07/98 10:51a Dave
 213  *
 214  *
 215  * $NoKeywords: $
 216  */
 217
 218 #include "pstypes.h"
 219 #include "systemvars.h"
 220 #include "ship.h"
 221 #include "fireballs.h"
 222 #include "debris.h"
 223 #include "hudtarget.h"
 224 #include "shipfx.h"
 225 #include "multi.h"
 226 #include "gamesnd.h"
 227 #include "timer.h"
 228 #include "3d.h"                 // needed for View_position, which is used when playing a 3D sound
 229 #include "multi.h"
 230 #include "multiutil.h"
 231 #include "hud.h"
 232 #include "fvi.h"
 233 #include "gamesequence.h"
 234 #include "lighting.h"
 235 #include "linklist.h"
 236 #include "particle.h"
 237 #include "multimsgs.h"
 238 #include "multiutil.h"
 239 #include "bmpman.h"
 240 #include "freespace.h"
 241 #include "muzzleflash.h"
 242 #include "demo.h"
 243 #include "shiphit.h"
 244 #include "neblightning.h"
 245 #include "objectsnd.h"
 246
 247 #ifndef NDEBUG
 248 extern float flFrametime;
 249 extern int Framecount;
 250 #endif
 251
 252 #define SHIP_CANNON_BITMAP                      "argh"
 253 int Ship_cannon_bitmap = -1;
 254
 255 int Player_engine_wash_loop = -1;
 256
 257 void shipfx_remove_submodel_ship_sparks(ship *shipp, int submodel_num)
 258 {
 259         Assert(submodel_num != -1);
 260
 261         // maybe no active sparks on submodel
 262         if (shipp->num_hits == 0) {
 263                 return;
 264         }
 265
 266         for (int spark_num=0; spark_num<shipp->num_hits; spark_num++) {
 267                 if (shipp->sparks[spark_num].submodel_num == submodel_num) {
 268                         shipp->sparks[spark_num].end_time = timestamp(1);
 269                 }
 270         }
 271 }
 272
 273 // Check if subsystem has live debris and create
 274 // DKA: 5/26/99 make velocity of debris scale according to size of debris subobject (at least for large subobjects)
 275 void shipfx_subsystem_mabye_create_live_debris(object *ship_obj, ship *ship_p, ship_subsys *subsys, vector *exp_center, float exp_mag)
 276 {
 277         // initializations
 278         polymodel *pm = model_get(ship_p->modelnum);
 279         int submodel_num = subsys->system_info->subobj_num;
 280         submodel_instance_info *sii = &subsys->submodel_info_1;
 281
 282         object *live_debris_obj;
 283         int i, num_live_debris, live_debris_submodel;
 284
 285         // get number of live debris objects to create
 286         num_live_debris = pm->submodel[submodel_num].num_live_debris;
 287         if (num_live_debris <= 0) {
 288                 return;
 289         }
 290
 291         ship_model_start(ship_obj);
 292
 293         // copy angles
 294         angles copy_angs = pm->submodel[submodel_num].angs;
 295         angles zero_angs = {0.0f, 0.0f, 0.0f};
 296
 297         // make sure the axis point is set
 298         if ( !sii->axis_set ) {
 299                 model_init_submodel_axis_pt(sii, ship_p->modelnum, submodel_num);
 300         }
 301
 302         // get the rotvel
 303         vector model_axis, world_axis, rotvel, world_axis_pt;
 304         void model_get_rotating_submodel_axis(vector *model_axis, vector *world_axis, int modelnum, int submodel_num, object *obj);
 305         model_get_rotating_submodel_axis(&model_axis, &world_axis, ship_p->modelnum, submodel_num, ship_obj);
 306         vm_vec_copy_scale(&rotvel, &world_axis, sii->cur_turn_rate);
 307
 308         model_find_world_point(&world_axis_pt, &sii->pt_on_axis, ship_p->modelnum, submodel_num, &ship_obj->orient, &ship_obj->pos);
 309
 310         matrix m_rot;   // rotation for debris orient about axis
 311         vm_quaternion_rotate(&m_rot, vm_vec_mag((vector*)&sii->angs), &model_axis);
 312
 313
 314         // create live debris pieces
 315         for (i=0; i<num_live_debris; i++) {
 316                 live_debris_submodel = pm->submodel[submodel_num].live_debris[i];
 317                 vector start_world_pos, start_model_pos, end_world_pos;
 318
 319                 // get start world pos
 320                 vm_vec_zero(&start_world_pos);
 321                 model_find_world_point(&start_world_pos, &pm->submodel[live_debris_submodel].offset, ship_p->modelnum, live_debris_submodel, &ship_obj->orient, &ship_obj->pos );
 322
 323                 // convert to model coord of underlying submodel
 324                 // set angle to zero
 325                 pm->submodel[submodel_num].angs = zero_angs;
 326                 world_find_model_point(&start_model_pos, &start_world_pos, pm, submodel_num, &ship_obj->orient, &ship_obj->pos);
 327
 328                 // rotate from submodel coord to world coords
 329                 // reset angle to current angle
 330                 pm->submodel[submodel_num].angs = copy_angs;
 331                 model_find_world_point(&end_world_pos, &start_model_pos, ship_p->modelnum, submodel_num, &ship_obj->orient, &ship_obj->pos);
 332
 333                 // create fireball here.
 334                 fireball_create(&end_world_pos, FIREBALL_EXPLOSION_MEDIUM, OBJ_INDEX(ship_obj), pm->submodel[live_debris_submodel].rad);
 335
 336                 // create debris
 337                 live_debris_obj = debris_create(ship_obj, ship_p->modelnum, live_debris_submodel, &end_world_pos, exp_center, 1, exp_mag);
 338
 339                 // only do if debris is created
 340                 if (live_debris_obj) {
 341                         // get radial velocity of debris
 342                         vector delta_x, radial_vel;
 343                         vm_vec_sub(&delta_x, &end_world_pos, &world_axis_pt);
 344                         vm_vec_crossprod(&radial_vel, &rotvel, &delta_x);
 345
 346                         if (Ship_info[ship_p->ship_info_index].flags & SIF_KNOSSOS_DEVICE) {
 347                                 // set velocity to cross center of knossos device
 348                                 vector rand_vec, vec_to_center;
 349
 350                                 float vel_mag = vm_vec_mag_quick(&radial_vel) * 1.3f * (0.9f + 0.2f*frand());
 351                                 vm_vec_normalized_dir(&vec_to_center, &world_axis_pt, &end_world_pos);
 352                                 vm_vec_rand_vec_quick(&rand_vec);
 353                                 vm_vec_scale_add2(&vec_to_center, &rand_vec, 0.2f);
 354                                 vm_vec_scale_add2(&live_debris_obj->phys_info.vel, &vec_to_center, vel_mag);
 355
 356                         } else {
 357                                 // Get rotation of debris object
 358                                 matrix copy = live_debris_obj->orient;
 359                                 vm_matrix_x_matrix(&live_debris_obj->orient, &copy, &m_rot);
 360
 361                                 // Add radial velocity (at least as large as exp velocity)
 362                                 vector temp_vel;        // explosion velocity with ship_obj velocity removed
 363                                 vm_vec_sub(&temp_vel, &live_debris_obj->phys_info.vel, &ship_obj->phys_info.vel);
 364
 365                                 // find magnitudes of radial and temp velocity
 366                                 float vel_mag = vm_vec_mag(&temp_vel);
 367                                 float rotvel_mag = vm_vec_mag(&radial_vel);
 368
 369                                 if (rotvel_mag > 0.1) {
 370                                         float scale = (1.2f + 0.2f * frand()) * vel_mag / rotvel_mag;
 371                                         // always add *at least* rotvel
 372                                         if (scale < 1) {
 373                                                 scale = 1.0f;
 374                                         }
 375
 376                                         if (exp_mag > 1) {      // whole ship going down
 377                                                 scale = exp_mag;
 378                                         }
 379
 380                                         if (Ship_info[ship_p->ship_info_index].flags & SIF_KNOSSOS_DEVICE) {
 381                                                 scale = 1.0f;
 382                                         }
 383
 384                                         vm_vec_scale_add2(&live_debris_obj->phys_info.vel, &radial_vel, scale);
 385                                 }
 386
 387                                 // scale up speed of debris if ship_obj > 125, but not for knossos
 388                                 if (ship_obj->radius > 250 && !(Ship_info[ship_p->ship_info_index].flags & SIF_KNOSSOS_DEVICE)) {
 389                                         vm_vec_scale(&live_debris_obj->phys_info.vel, ship_obj->radius/250.0f);
 390                                 }
 391                         }
 392                 }
 393         }
 394
 395         ship_model_stop(ship_obj);
 396 }
 397
 398 void set_ship_submodel_as_blown_off(ship *shipp, char *name)
 399 {
 400         int found =     FALSE;
 401
 402         // go through list of ship subsystems and find name
 403         ship_subsys     *pss = NULL;
 404         for (pss=GET_FIRST(&shipp->subsys_list); pss!=END_OF_LIST(&shipp->subsys_list); pss=GET_NEXT(pss)) {
 405                 if ( stricmp(pss->system_info->name, name) == 0) {
 406                         found = TRUE;
 407                         break;
 408                 }
 409         }
 410
 411         // set its blown off flag to TRUE
 412         Assert(found);
 413         if (found) {
 414                 pss->submodel_info_1.blown_off = 1;
 415         }
 416 }
 417
 418
 419 // Create debris for ship submodel which has live debris (at ship death)
 420 // when ship submodel has not already been blown off (and hence liberated live debris)
 421 void shipfx_maybe_create_live_debris_at_ship_death( object *ship_obj )
 422 {
 423         // if ship has live debris, detonate that subsystem now
 424         // search for any live debris
 425
 426         ship *shipp = &Ships[ship_obj->instance];
 427         polymodel *pm = model_get(shipp->modelnum);
 428
 429         int live_debris_submodel = -1;
 430         for (int idx=0; idx<pm->num_debris_objects; idx++) {
 431                 if (pm->submodel[pm->debris_objects[idx]].is_live_debris) {
 432                         live_debris_submodel = pm->debris_objects[idx];
 433
 434                         // get submodel that produces live debris
 435                         int model_get_parent_submodel_for_live_debris( int model_num, int live_debris_model_num );
 436                         int parent = model_get_parent_submodel_for_live_debris( shipp->modelnum, live_debris_submodel);
 437                         Assert(parent != -1);
 438
 439                         // set model values only once (esp blown off)
 440                         ship_model_start(ship_obj);
 441
 442                         // check if already blown off  (ship model set)
 443                         if ( !pm->submodel[parent].blown_off ) {
 444
 445                                 // get ship_subsys for live_debris
 446                                 // Go through all subsystems and look for submodel the subsystems with "parent" submodel.
 447                                 ship_subsys     *pss = NULL;
 448                                 for ( pss = GET_FIRST(&shipp->subsys_list); pss != END_OF_LIST(&shipp->subsys_list); pss = GET_NEXT(pss) ) {
 449                                         if (pss->system_info->subobj_num == parent) {
 450                                                 break;
 451                                         }
 452                                 }
 453
 454                                 Assert (pss != NULL);
 455                                 if (pss != NULL) {
 456                                         vector exp_center, tmp = {0.0f, 0.0f, 0.0f};
 457                                         model_find_world_point(&exp_center, &tmp, shipp->modelnum, parent, &ship_obj->orient, &ship_obj->pos );
 458
 459                                         // if not blown off, blow it off
 460                                         shipfx_subsystem_mabye_create_live_debris(ship_obj, shipp, pss, &exp_center, 3.0f);
 461
 462                                         // now set subsystem as blown off, so we only get one copy
 463                                         pm->submodel[parent].blown_off = 1;
 464                                         set_ship_submodel_as_blown_off(&Ships[ship_obj->instance], pss->system_info->name);
 465                                 }
 466                         }
 467                 }
 468         }
 469
 470         // clean up
 471         ship_model_stop(ship_obj);
 472
 473 }
 474
 475 void shipfx_blow_off_subsystem(object *ship_obj,ship *ship_p,ship_subsys *subsys, vector *exp_center)
 476 {
 477         vector subobj_pos;
 478
 479         model_subsystem *psub = subsys->system_info;
 480
 481         get_subsystem_world_pos(ship_obj, subsys, &subobj_pos);
 482
 483 /*
 484         if ( psub->turret_gun_sobj > -1 )
 485                 debris_create( ship_obj, ship_p->modelnum, psub->turret_gun_sobj, &subobj_pos, exp_center, 0, 1.0f );
 486
 487         if ( psub->subobj_num > -1 )
 488                 debris_create( ship_obj, ship_p->modelnum, psub->subobj_num, &subobj_pos, exp_center, 0, 1.0f );
 489 */
 490         // get rid of sparks on submodel that is destroyed
 491         shipfx_remove_submodel_ship_sparks(ship_p, psub->subobj_num);
 492
 493         // create debris shards
 494         shipfx_blow_up_model(ship_obj, ship_p->modelnum, psub->subobj_num, 50, &subobj_pos );
 495
 496         // create live debris objects, if any
 497         // TODO:  some MULITPLAYER implcations here!!
 498         shipfx_subsystem_mabye_create_live_debris(ship_obj, ship_p, subsys, exp_center, 1.0f);
 499
 500         // create first fireball
 501         fireball_create( &subobj_pos, FIREBALL_EXPLOSION_MEDIUM, OBJ_INDEX(ship_obj), psub->radius );
 502 }
 503
 504
 505 void shipfx_blow_up_hull(object *obj, int model, vector *exp_center)
 506 {
 507         int i;
 508         polymodel * pm;
 509         ushort sig_save;
 510
 511
 512         pm = model_get(model);
 513         if (!pm) return;
 514
 515         // in multiplayer, send a debris_hull_create packet.  Save/restore the debris signature
 516         // when in misison only (since we can create debris pieces before mission starts)
 517         sig_save = 0;
 518         if ( (Game_mode & GM_MULTIPLAYER) && (Game_mode & GM_IN_MISSION) ) {
 519                 sig_save = multi_get_next_network_signature( MULTI_SIG_DEBRIS );
 520                 multi_set_network_signature( (ushort)(Ships[obj->instance].arrival_distance), MULTI_SIG_DEBRIS );
 521         }
 522
 523         bool try_live_debris = true;
 524         for (i=0; i<pm->num_debris_objects; i++ )       {
 525                 if (! pm->submodel[pm->debris_objects[i]].is_live_debris) {
 526                         vector tmp = {0.0f, 0.0f, 0.0f };
 527                         model_find_world_point(&tmp, &pm->submodel[pm->debris_objects[i]].offset, model, 0, &obj->orient, &obj->pos );
 528                         debris_create( obj, model, pm->debris_objects[i], &tmp, exp_center, 1, 3.0f );
 529                 } else {
 530                         if ( try_live_debris ) {
 531                                 // only create live debris once
 532                                 // this creates *all* the live debris for *all* the currently live subsystems.
 533                                 try_live_debris = false;
 534                                 shipfx_maybe_create_live_debris_at_ship_death(obj);
 535                         }
 536                 }
 537         }
 538
 539         // restore the ship signature to it's original value.
 540         if ( (Game_mode & GM_MULTIPLAYER) && (Game_mode & GM_IN_MISSION) ) {
 541                 multi_set_network_signature( sig_save, MULTI_SIG_DEBRIS );
 542         }
 543 }
 544
 545
 546 // Creates "ndebris" pieces of debris on random verts of the the "submodel" in the
 547 // ship's model.
 548 void shipfx_blow_up_model(object *obj,int model, int submodel, int ndebris, vector *exp_center )
 549 {
 550         int i;
 551
 552         // if in a multiplayer game -- seed the random number generator with a value that will be the same
 553         // on all clients in the game -- the net_signature of the object works nicely -- since doing so should
 554         // ensure that all pieces of debris will get scattered in same direction on all machines
 555         if ( Game_mode & GM_MULTIPLAYER )
 556                 srand( obj->net_signature );
 557
 558         // made a change to allow anyone but multiplayer client to blow up hull.  Clients will do it when
 559         // they get the create packet
 560         if ( submodel == 0 ) {
 561                 shipfx_blow_up_hull(obj,model, exp_center );
 562         }
 563
 564         for (i=0; i<ndebris; i++ )      {
 565                 vector pnt1, pnt2;
 566
 567                 // Gets two random points on the surface of a submodel
 568                 submodel_get_two_random_points(model, submodel, &pnt1, &pnt2 );
 569
 570                 vector tmp, outpnt;
 571
 572                 vm_vec_avg( &tmp, &pnt1, &pnt2 );
 573                 model_find_world_point(&outpnt, &tmp, model,submodel, &obj->orient, &obj->pos );
 574
 575                 debris_create( obj, -1, -1, &outpnt, exp_center, 0, 1.0f );
 576         }
 577 }
 578
 579
 580 // =================================================
 581 //          SHIP WARP IN EFFECT CODE
 582 // =================================================
 583
 584
 585 // Given an ship, find the radius of it as viewed from the front.
 586 static float shipfx_calculate_effect_radius( object *objp )
 587 {
 588         float w,h,rad;
 589         ship *shipp = &Ships[objp->instance];
 590
 591         polymodel *pm = model_get( shipp->modelnum );
 592
 593         w = pm->maxs.xyz.x - pm->mins.xyz.x;
 594         h = pm->maxs.xyz.y - pm->mins.xyz.y;
 595
 596         if ( w > h )    {
 597                 rad = w / 2.0f;
 598         } else {
 599                 rad = h / 2.0f;
 600         }
 601
 602         object *docked_objp = ai_find_docked_object( objp );
 603
 604         //      If ship is docked then center wormhold about their center and make radius large enough.
 605         if ( docked_objp ) {
 606                 ship *docked_shipp = &Ships[docked_objp->instance];
 607
 608                 pm = model_get( docked_shipp->modelnum );
 609
 610                 w = pm->maxs.xyz.x - pm->mins.xyz.x;
 611                 h = pm->maxs.xyz.y - pm->mins.xyz.y;
 612
 613                 if ( w > h )    {
 614                         rad += w / 2.0f;
 615                 } else {
 616                         rad += h / 2.0f;
 617                 }
 618         }
 619         return rad*3.0f;
 620 }
 621
 622 // How long the stage 1 & stage 2 of warp in effect lasts.
 623 // There are different times for small, medium, and large ships.
 624 // The appropriate values are picked depending on the ship's
 625 // radius.
 626 #define SHIPFX_WARP_DELAY       (2.0f)          // time for warp effect to ramp up before ship moves into it.
 627
 628 // Give object objp, calculate how long it should take the
 629 // ship to go through the warp effect and how fast the ship
 630 // should go.   For reference,  capital ship of 2780m
 631 // should take 7 seconds to fly through.   Fighters of 30,
 632 // should take 1.5 seconds to fly through.
 633
 634 #define LARGEST_RAD 1390.0f
 635 #define LARGEST_RAD_TIME 7.0f
 636
 637 #define SMALLEST_RAD 15.0f
 638 #define SMALLEST_RAD_TIME 1.5f
 639
 640
 641 static float shipfx_calculate_warp_time( object * objp )
 642 {
 643         // Find rad_percent from 0 to 1, 0 being smallest ship, 1 being largest
 644         float rad_percent = (objp->radius-SMALLEST_RAD) / (LARGEST_RAD-SMALLEST_RAD);
 645         if ( rad_percent < 0.0f ) {
 646                 rad_percent = 0.0f;
 647         } else if ( rad_percent > 1.0f )        {
 648                 rad_percent = 1.0f;
 649         }
 650         float rad_time = rad_percent*(LARGEST_RAD_TIME-SMALLEST_RAD_TIME) + SMALLEST_RAD_TIME;
 651
 652         return rad_time;
 653 }
 654
 655 // calculate warp speed
 656 float shipfx_calculate_warp_speed(object *objp)
 657 {
 658         float length;
 659
 660         Assert(objp->type == OBJ_SHIP);
 661         if (objp->type != OBJ_SHIP) {
 662                 length = 2.0f * objp->radius;
 663         } else {
 664                 length = ship_get_length(&Ships[objp->instance]);
 665         }
 666         return length / shipfx_calculate_warp_time(objp);
 667 }
 668
 669
 670 // This is called to actually warp this object in
 671 // after all the flashy fx are done, or if the flashy
 672 // fx don't work for some reason.
 673 void shipfx_actually_warpin(    ship *shipp, object *objp )
 674 {
 675         shipp->flags &= (~SF_ARRIVING_STAGE_1);
 676         shipp->flags &= (~SF_ARRIVING_STAGE_2);
 677
 678         // let physics in on it too.
 679         objp->phys_info.flags &= (~PF_WARP_IN);
 680 }
 681
 682 // JAS - code to start the ship doing the warp in effect
 683 // This also starts the animating 3d effect playing.
 684 // There are two modes, stage 1 and stage 2.   Stage 1 is
 685 // when the ship just invisibly waits for a certain time
 686 // period after the effect starts, and then stage 2 begins,
 687 // where the ships flies through the effect at a set
 688 // velocity so it gets through in a certain amount of
 689 // time.
 690 void shipfx_warpin_start( object *objp )
 691 {
 692         ship *shipp;
 693         float effect_time, effect_radius;
 694
 695         shipp = &Ships[objp->instance];
 696
 697         if ( shipp->flags & SF_ARRIVING )       {
 698                 mprintf(( "Ship is already arriving!\n" ));
 699                 return;
 700         }
 701
 702         // post a warpin event
 703         if(Game_mode & GM_DEMO_RECORD){
 704                 demo_POST_warpin(objp->signature, shipp->flags);
 705         }
 706
 707         // if there is no arrival warp, then skip the whole thing
 708         if ( shipp->flags & SF_NO_ARRIVAL_WARP )        {
 709                 shipfx_actually_warpin(shipp,objp);
 710                 return;
 711         }
 712
 713         // VALIDATE special_warp_objnum
 714         if (shipp->special_warp_objnum >= 0) {
 715
 716                 int ref_objnum = shipp->special_warp_objnum;
 717                 int valid_reference_ship = FALSE;
 718
 719                 // Validate reference_objnum
 720                 if ((ref_objnum >= 0) && (ref_objnum < MAX_OBJECTS)) {
 721                         object *sp_objp = &Objects[ref_objnum];
 722                         if (sp_objp->type == OBJ_SHIP) {
 723                                 if (Ship_info[Ships[sp_objp->instance].ship_info_index].flags & SIF_KNOSSOS_DEVICE) {
 724                                         valid_reference_ship = TRUE;
 725                                 }
 726                         }
 727                 }
 728
 729                 if (valid_reference_ship != TRUE) {
 730                         shipp->special_warp_objnum = -1;
 731                 }
 732         }
 733
 734         // only move warp effect pos if not special warp in.
 735         if (shipp->special_warp_objnum >= 0) {
 736                 Assert(!(Game_mode & GM_MULTIPLAYER));
 737                 polymodel *pm;
 738                 pm = model_get(shipp->modelnum);
 739                 vm_vec_scale_add(&shipp->warp_effect_pos, &objp->pos, &objp->orient.v.fvec, -pm->mins.xyz.z);
 740         } else {
 741                 vm_vec_scale_add( &shipp->warp_effect_pos, &objp->pos, &objp->orient.v.fvec, objp->radius );
 742         }
 743
 744         // The ending zero mean this is a warp-in effect
 745         if ( !(shipp->flags & SF_INITIALLY_DOCKED) ) {
 746                 int warp_objnum;
 747
 748                 // Effect time is 'SHIPFX_WARP_DELAY' (1.5 secs) seconds to start, 'shipfx_calculate_warp_time'
 749                 // for ship to go thru, and 'SHIPFX_WARP_DELAY' (1.5 secs) to go away.
 750                 effect_time = shipfx_calculate_warp_time(objp) + SHIPFX_WARP_DELAY + SHIPFX_WARP_DELAY;
 751                 effect_radius = shipfx_calculate_effect_radius(objp);
 752
 753                 // maybe special warpin
 754                 if (shipp->special_warp_objnum >= 0) {
 755                         // cap radius to size of knossos
 756                         effect_radius = min(effect_radius, 0.8f*Objects[shipp->special_warp_objnum].radius);
 757                         warp_objnum = fireball_create(&shipp->warp_effect_pos, FIREBALL_KNOSSOS_EFFECT, shipp->special_warp_objnum, effect_radius, 0, NULL, effect_time, shipp->ship_info_index);
 758                 } else {
 759                         warp_objnum = fireball_create(&shipp->warp_effect_pos, FIREBALL_WARP_EFFECT, OBJ_INDEX(objp), effect_radius, 0, NULL, effect_time, shipp->ship_info_index);
 760                 }
 761                 if (warp_objnum < 0 )   {       // JAS: This must always be created, if not, just warp the ship in
 762                         shipfx_actually_warpin(shipp,objp);
 763                         return;
 764                 }
 765
 766                 shipp->warp_effect_fvec = Objects[warp_objnum].orient.v.fvec;
 767                 // maybe negate if special warp effect
 768                 if (shipp->special_warp_objnum >= 0) {
 769                         if (vm_vec_dotprod(&shipp->warp_effect_fvec, &objp->orient.v.fvec) < 0) {
 770                                 vm_vec_negate(&shipp->warp_effect_fvec);
 771                         }
 772                 }
 773
 774
 775                 shipp->final_warp_time = timestamp(fl2i(SHIPFX_WARP_DELAY*1000.0f));
 776                 shipp->flags |= SF_ARRIVING_STAGE_1;
 777
 778                 // see if this ship is docked with anything, and if so, make docked ship be "arriving"
 779                 /*
 780                 if ( Ai_info[shipp->ai_index].dock_objnum != -1 ) {
 781                         Ships[Ai_info[shipp->ai_index].dock_objnum].final_warp_time = timestamp(fl2i(warp_time*1000.0f));
 782                         Ships[Ai_info[shipp->ai_index].dock_objnum].flags |= SF_ARRIVING_STAGE_1;
 783                 }
 784                 */
 785         }
 786 }
 787
 788 void shipfx_warpin_frame( object *objp, float frametime )
 789 {
 790         ship *shipp;
 791
 792         shipp = &Ships[objp->instance];
 793
 794         if ( shipp->flags & SF_DYING ) return;
 795
 796         if ( shipp->flags & SF_ARRIVING_STAGE_1 )       {
 797                 if ( timestamp_elapsed(shipp->final_warp_time) ) {
 798
 799                         // let physics know the ship is going to warp in.
 800                         objp->phys_info.flags |= PF_WARP_IN;
 801
 802                         // done doing stage 1 of warp, so go on to stage 2
 803                         shipp->flags &= (~SF_ARRIVING_STAGE_1);
 804                         shipp->flags |= SF_ARRIVING_STAGE_2;
 805
 806                         float warp_time = shipfx_calculate_warp_time(objp);
 807                         float speed = shipfx_calculate_warp_speed(objp);                        // How long it takes to move through warp effect
 808
 809                         // Make ship move at velocity so that it moves two radius's in warp_time seconds.
 810                         vector vel;
 811                         vel = objp->orient.v.fvec;
 812                         vm_vec_scale( &vel, speed );
 813                         objp->phys_info.vel = vel;
 814                         objp->phys_info.desired_vel = vel;
 815                         objp->phys_info.prev_ramp_vel.xyz.x = 0.0f;
 816                         objp->phys_info.prev_ramp_vel.xyz.y = 0.0f;
 817                         objp->phys_info.prev_ramp_vel.xyz.z = speed;
 818                         objp->phys_info.forward_thrust = 0.0f;          // How much the forward thruster is applied.  0-1.
 819
 820                         shipp->final_warp_time = timestamp(fl2i(warp_time*1000.0f));
 821
 822                         /*
 823                         // see if this ship is docked with anything, and if so, make docked ship be "arriving"
 824                         if ( Ai_info[shipp->ai_index].dock_objnum != -1 ) {
 825                                 Ships[Ai_info[shipp->ai_index].dock_objnum].flags &= (~SF_ARRIVING_STAGE_1);
 826                                 Ships[Ai_info[shipp->ai_index].dock_objnum].flags |= SF_ARRIVING_STAGE_2;
 827                                 Ships[Ai_info[shipp->ai_index].dock_objnum].final_warp_time = timestamp(fl2i(warp_time*1000.0f));
 828                         }
 829                         */
 830                 }
 831         } else if ( shipp->flags & SF_ARRIVING_STAGE_2 )        {
 832                 if ( timestamp_elapsed(shipp->final_warp_time) ) {
 833                         // done doing stage 2 of warp, so turn off arriving flag
 834                         shipfx_actually_warpin(shipp,objp);
 835
 836                         // notify physics to slow down
 837                         if (Ship_info[shipp->ship_info_index].flags & SIF_SUPERCAP) {
 838                                 // let physics know this is a special warp in
 839                                 objp->phys_info.flags |= PF_SPECIAL_WARP_IN;
 840                         }
 841                 }
 842         }
 843
 844 }
 845
 846 // This is called to actually warp this object out
 847 // after all the flashy fx are done, or if the flashy
 848 // fx don't work for some reason.  OR to skip the flashy
 849 // fx.
 850 void shipfx_actually_warpout( ship *shipp, object *objp )
 851 {
 852         // Once we get through effect, make the ship go away
 853
 854         if ( objp == Player_obj )       {
 855                 // Normally, this will never get called for the player. If it
 856                 // does, it is because some error (like the warpout effect
 857                 // couldn't start) so go ahead an warp the player out.
 858                 // All this does is set the event to go to debriefing, the
 859                 // same thing that happens after the player warp out effect
 860                 // ends.
 861                 gameseq_post_event( GS_EVENT_DEBRIEF ); // proceed to debriefing
 862         } else {
 863                 object *docked_objp;
 864
 865                 // Code for objects except player ship warping out
 866                 objp->flags |= OF_SHOULD_BE_DEAD;
 867                 // check to see if departing ship is docked with anything and if so, mark that object
 868                 // gone as well
 869                 docked_objp = ai_find_docked_object( objp );
 870                 if ( docked_objp ) {
 871                         docked_objp->flags |= OF_SHOULD_BE_DEAD;
 872                 }
 873
 874                 ship_departed( objp->instance );
 875                 if ( docked_objp ){
 876                         ship_departed( docked_objp->instance );
 877                 }
 878         }
 879 }
 880
 881 // compute_special_warpout_stuff();
 882 int compute_special_warpout_stuff(object *objp, float *speed, float *warp_time, vector *warp_pos)
 883 {
 884         object  *sp_objp = NULL;
 885         ship            *shipp;
 886         int             valid_refenence_ship = FALSE, ref_objnum;
 887         vector  facing_normal, vec_to_knossos;
 888         float           dist_to_plane;
 889
 890         // knossos warpout only valid in single player
 891         if (Game_mode & GM_MULTIPLAYER) {
 892                 mprintf(("special warpout only for single player\n"));
 893                 return -1;
 894         }
 895
 896         // find special warp ship reference
 897         valid_refenence_ship = FALSE;
 898         ref_objnum = Ships[objp->instance].special_warp_objnum;
 899
 900         // Validate reference_objnum
 901         if ((ref_objnum >= 0) && (ref_objnum < MAX_OBJECTS)) {
 902                 sp_objp = &Objects[ref_objnum];
 903                 if (sp_objp->type == OBJ_SHIP) {
 904                         shipp = &Ships[sp_objp->instance];
 905                         if (Ship_info[shipp->ship_info_index].flags & SIF_KNOSSOS_DEVICE) {
 906                                 valid_refenence_ship = TRUE;
 907                         }
 908                 }
 909         }
 910
 911         if (!valid_refenence_ship) {
 912                 Int3();
 913                 mprintf(("special warpout reference ship not found\n"));
 914                 return -1;
 915         }
 916
 917         // get facing normal from knossos
 918         vm_vec_sub(&vec_to_knossos, &sp_objp->pos, &objp->pos);
 919         facing_normal = sp_objp->orient.v.fvec;
 920         if (vm_vec_dotprod(&vec_to_knossos, &sp_objp->orient.v.fvec) > 0) {
 921                 vm_vec_negate(&facing_normal);
 922         }
 923
 924         // find position to play the warp ani..
 925         dist_to_plane = fvi_ray_plane(warp_pos, &sp_objp->pos, &facing_normal, &objp->pos, &objp->orient.v.fvec, 0.0f);
 926
 927         // calculate distance to warpout point.
 928         polymodel *pm = model_get(Ships[objp->instance].modelnum);
 929         dist_to_plane += pm->mins.xyz.z;
 930
 931         if (dist_to_plane < 0) {
 932                 mprintf(("warpout started too late\n"));
 933                 return -1;
 934         }
 935
 936         // validate angle
 937         float max_warpout_angle = 0.707f;       // 45 degree half-angle cone for small ships
 938         if (Ship_info[Ships[objp->instance].ship_info_index].flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) {
 939                 max_warpout_angle = 0.866f;     // 30 degree half-angle cone for BIG or HUGE
 940         }
 941
 942         if (-vm_vec_dotprod(&objp->orient.v.fvec, &facing_normal) < max_warpout_angle) {        // within allowed angle
 943                 Int3();
 944                 mprintf(("special warpout angle exceeded\n"));
 945                 return -1;
 946         }
 947
 948         // Calculate speed needed to get
 949         *speed = shipfx_calculate_warp_speed(objp);
 950
 951         // Calculate how long to fly through the effect.  Not to get to the effect, just through it.
 952         *warp_time = shipfx_calculate_warp_time(objp);
 953         *warp_time += dist_to_plane / *speed;
 954
 955         return 0;
 956 }
 957
 958
 959 void compute_warpout_stuff(object *objp, float *speed, float *warp_time, vector *warp_pos)
 960 {
 961         // If we're warping through the knossos, do something different.
 962         if (Ships[objp->instance].special_warp_objnum >= 0) {
 963                 if (compute_special_warpout_stuff(objp, speed, warp_time, warp_pos) != -1) {
 964                         return;
 965                 } else {
 966                         mprintf(("Invalid special warp\n"));
 967                 }
 968         }
 969
 970         object  *docked_objp = ai_find_docked_object( objp );
 971         vector  center_pos = objp->pos;
 972         float           radius, ship_move_dist, warp_dist;
 973
 974         radius = objp->radius;
 975
 976         //      If ship is docked then center wormhold about their center and make radius large enough.
 977         if ( docked_objp ) {
 978                 vm_vec_avg(&center_pos, &objp->pos, &docked_objp->pos);
 979                 radius += docked_objp->radius;
 980         }
 981
 982         // Calculate how long to fly through the effect.  Not to get to the effect, just through it.
 983         *warp_time = shipfx_calculate_warp_time(objp);
 984
 985         // Pick some speed at which we want to go through the warp effect.
 986         // This is determined by shipfx_calculate_warp_time specifying how long
 987         // it should take to go through the effect, or 2R.
 988         *speed = shipfx_calculate_warp_speed(objp);
 989
 990         if ( objp == Player_obj )       {
 991                 *speed = 0.8f*objp->phys_info.max_vel.xyz.z;
 992         }
 993
 994         // Now we know our speed. Figure out how far the warp effect will be from here.
 995         ship_move_dist = (*speed * SHIPFX_WARP_DELAY) + radius*1.5f;            // We want to get to 1.5R away from effect
 996         if ( ship_move_dist < radius*1.5f ) {
 997                 ship_move_dist = radius*1.5f;
 998         }
 999
1000         // If this is a huge ship, set the distance to the length of the ship
1001         if (Ship_info[Ships[objp->instance].ship_info_index].flags & SIF_HUGE_SHIP) {
1002                 ship_move_dist = 0.5f * ship_get_length(&Ships[objp->instance]);
1003         }
1004
1005         // Acount for time to get to warp effect, before we actually go through it.
1006         *warp_time += ship_move_dist / *speed;
1007
1008         warp_dist = ship_move_dist;
1009         // allow for off center
1010         if (Ship_info[Ships[objp->instance].ship_info_index].flags & SIF_HUGE_SHIP) {
1011                 polymodel *pm = model_get(Ships[objp->instance].modelnum);
1012                 warp_dist -= pm->mins.xyz.z;
1013         }
1014
1015         vm_vec_scale_add( warp_pos, &center_pos, &objp->orient.v.fvec, warp_dist );
1016 }
1017
1018 // JAS - code to start the ship doing the warp out effect
1019 // This puts the ship into a mode specified by SF_DEPARTING
1020 // where it flies forward for a set time period at a set
1021 // velocity, then disappears when that time is reached.  This
1022 // also starts the animating 3d effect playing.
1023 void shipfx_warpout_start( object *objp )
1024 {
1025         float warp_time;
1026         ship *shipp;
1027         shipp = &Ships[objp->instance];
1028
1029         if (    shipp->flags & SF_DEPART_WARP ) {
1030                 mprintf(( "Ship is already departing!\n" ));
1031                 return;
1032         }
1033
1034         // if we're dying return
1035         if ( shipp->flags & SF_DYING ) {
1036                 return;
1037         }
1038
1039         // if we're HUGE, keep alive - set guardian
1040         if (Ship_info[shipp->ship_info_index].flags & SIF_HUGE_SHIP) {
1041                 objp->flags |= OF_GUARDIAN;
1042         }
1043
1044         // post a warpin event
1045         if(Game_mode & GM_DEMO_RECORD){
1046                 demo_POST_warpout(objp->signature, shipp->flags);
1047         }
1048
1049         // don't send ship depart packets for player ships
1050         if ( (MULTIPLAYER_MASTER) && !(objp->flags & OF_PLAYER_SHIP) ){
1051                 send_ship_depart_packet( objp );
1052         }
1053
1054         // don't do departure wormhole if ship flag is set which indicates no effect
1055         if ( shipp->flags & SF_NO_DEPARTURE_WARP ) {
1056                 // DKA 5/25/99 If he's going to warpout, set it.
1057                 // Next line fixes assert in wing cleanup code when no warp effect.
1058                 shipp->flags |= SF_DEPART_WARP;
1059
1060                 shipfx_actually_warpout(shipp, objp);
1061                 return;
1062         }
1063
1064         if ( objp == Player_obj )       {
1065                 HUD_printf(XSTR( "Subspace node activated", 498) );
1066         }
1067
1068         float   speed, effect_time, effect_radius;
1069         vector  warp_pos;
1070         // warp time from compute warpout stuff includes time to get up to warp_pos
1071         compute_warpout_stuff(objp, &speed, &warp_time, &warp_pos);
1072         shipp->warp_effect_pos = warp_pos;
1073
1074         // The ending one means this is a warp-out effect
1075         int warp_objnum;
1076         // Effect time is 'SHIPFX_WARP_DELAY' (1.5 secs) seconds to start, 'shipfx_calculate_warp_time'
1077         // for ship to go thru, and 'SHIPFX_WARP_DELAY' (1.5 secs) to go away.
1078         // effect_time = shipfx_calculate_warp_time(objp) + SHIPFX_WARP_DELAY + SHIPFX_WARP_DELAY;
1079         effect_time = warp_time + SHIPFX_WARP_DELAY;
1080         effect_radius = shipfx_calculate_effect_radius(objp);
1081
1082         // maybe special warpout
1083         if (shipp->special_warp_objnum >= 0) {
1084                 // cap radius to size of knossos
1085                 effect_radius = min(effect_radius, 0.8f*Objects[shipp->special_warp_objnum].radius);
1086                 warp_objnum = fireball_create(&shipp->warp_effect_pos, FIREBALL_KNOSSOS_EFFECT, shipp->special_warp_objnum, effect_radius, 1, NULL, effect_time, shipp->ship_info_index);
1087         } else {
1088                 warp_objnum = fireball_create(&shipp->warp_effect_pos, FIREBALL_WARP_EFFECT, OBJ_INDEX(objp), effect_radius, 1, NULL, effect_time, shipp->ship_info_index);
1089         }
1090         if (warp_objnum < 0 )   {       // JAS: This must always be created, if not, just warp the ship in
1091                 shipfx_actually_warpout(shipp,objp);
1092                 return;
1093         }
1094
1095         shipp->warp_effect_fvec = Objects[warp_objnum].orient.v.fvec;
1096         // maybe negate if special warp effect
1097         if (shipp->special_warp_objnum >= 0) {
1098                 if (vm_vec_dotprod(&shipp->warp_effect_fvec, &objp->orient.v.fvec) > 0) {
1099                         vm_vec_negate(&shipp->warp_effect_fvec);
1100                 }
1101         }
1102
1103         // Make the warp effect stage 1 last SHIP_WARP_TIME1 seconds.
1104         if ( objp == Player_obj )       {
1105                 warp_time = fireball_lifeleft(&Objects[warp_objnum]);
1106                 shipp->final_warp_time = timestamp(fl2i(warp_time*1000.0f));
1107         } else {
1108                 shipp->final_warp_time = timestamp(fl2i(warp_time*2.0f*1000.0f));
1109         }
1110         shipp->flags |= SF_DEPART_WARP;
1111
1112 //      mprintf(( "Warp time = %.4f , effect time = %.4f ms\n", warp_time*1000.0f, effect_time ));
1113
1114         // This is a hack to make the ship go at the right speed to go from it's current position to the warp_effect_pos;
1115
1116         // Set ship's velocity to 'speed'
1117         // This should actually be an AI that flies from the current
1118         // position through 'shipp->warp_effect_pos' in 'warp_time'
1119         // and keeps going
1120         if ( objp != Player_obj )       {
1121                 vector vel;
1122                 vel = objp->orient.v.fvec;
1123                 vm_vec_scale( &vel, speed );
1124                 objp->phys_info.vel = vel;
1125                 objp->phys_info.desired_vel = vel;
1126                 objp->phys_info.prev_ramp_vel.xyz.x = 0.0f;
1127                 objp->phys_info.prev_ramp_vel.xyz.y = 0.0f;
1128                 objp->phys_info.prev_ramp_vel.xyz.z = speed;
1129                 objp->phys_info.forward_thrust = 1.0f;          // How much the forward thruster is applied.  0-1.
1130
1131                 // special case for HUGE ships
1132                 if (Ship_info[shipp->ship_info_index].flags & SIF_HUGE_SHIP) {
1133 //                      objp->phys_info.flags |= PF_SPECIAL_WARP_OUT;
1134                 }
1135         }
1136
1137 }
1138
1139 void shipfx_warpout_frame( object *objp, float frametime )
1140 {
1141         ship *shipp;
1142         shipp = &Ships[objp->instance];
1143
1144         if ( shipp->flags & SF_DYING ) return;
1145
1146         vector tempv;
1147         float warp_pos; // position of warp effect in object's frame of reference
1148
1149         vm_vec_sub( &tempv, &objp->pos, &shipp->warp_effect_pos );
1150         warp_pos = -vm_vec_dot( &tempv, &shipp->warp_effect_fvec );
1151
1152
1153         // Find the closest point on line from center of wormhole
1154         vector pos;
1155         float dist;
1156
1157         fvi_ray_plane(&pos,&objp->pos,&shipp->warp_effect_fvec,&shipp->warp_effect_pos, &shipp->warp_effect_fvec, 0.0f );
1158         dist = vm_vec_dist( &pos, &objp->pos );
1159
1160 //      mprintf(( "Warp pos = %.1f, rad=%.1f, center dist = %.1f\n", warp_pos, objp->radius, dist ));
1161
1162         if ( objp == Player_obj )       {
1163                 // Code for player warpout frame
1164
1165                 if ( (Player->control_mode==PCM_WARPOUT_STAGE2) && (warp_pos > objp->radius) )  {
1166                         gameseq_post_event( GS_EVENT_PLAYER_WARPOUT_DONE_STAGE2 );
1167                 }
1168
1169                 if ( timestamp_elapsed(shipp->final_warp_time) ) {
1170
1171                         // Something went wrong... oh well, warp him out anyway.
1172                         if ( Player->control_mode != PCM_WARPOUT_STAGE3 )       {
1173                                 mprintf(( "Hmmm... player ship warpout time elapsed, but he wasn't in warp stage 3.\n" ));
1174                         }
1175
1176                         gameseq_post_event( GS_EVENT_PLAYER_WARPOUT_DONE );
1177                         ship_departed( objp->instance );                                                                // mark log entry for the player
1178                 }
1179
1180         } else {
1181                 // Code for all non-player ships warpout frame
1182
1183                 int timed_out = timestamp_elapsed(shipp->final_warp_time);
1184                 if ( timed_out )        {
1185 //                      mprintf(("Frame %i: Ship %s missed departue cue.\n", Framecount, shipp->ship_name ));
1186                         int     delta_ms = timestamp_until(shipp->final_warp_time);
1187                         if (delta_ms > 1000.0f * frametime ) {
1188                                 nprintf(("AI", "Frame %i: Ship %s missed departue cue by %7.3f seconds.\n", Framecount, shipp->ship_name, - (float) delta_ms/1000.0f));
1189                         }
1190                 }
1191
1192                 // MWA 10/21/97 -- added shipp->flags & SF_NO_DEPARTURE_WARP part of next if statement.  For ships
1193                 // that don't get a wormhole effect, I wanted to drop into this code immediately.
1194                 if ( (warp_pos > objp->radius)  || (shipp->flags & SF_NO_DEPARTURE_WARP) || timed_out ) {
1195                         shipfx_actually_warpout( shipp, objp );
1196                 }
1197         }
1198 }
1199
1200
1201 //==================================================
1202 // Stuff for keeping track of which ships are in
1203 // whose shadows.
1204
1205
1206 // Given point p0, in object's frame of reference, find if
1207 // it can see the sun.
1208 int shipfx_point_in_shadow( vector *p0, matrix *src_orient, vector *src_pos, float radius )
1209 {
1210         mc_info mc;
1211         object *objp;
1212         ship_obj *so;
1213         ship *shipp;
1214         int n_lights;
1215         int idx;
1216
1217         vector rp0, rp1;
1218
1219         vector light_dir;
1220
1221         // Move rp0 into world coordinates
1222         vm_vec_unrotate(&rp0, p0, src_orient);
1223         vm_vec_add2(&rp0, src_pos);
1224
1225         // get the # of global lights
1226         n_lights = light_get_global_count();
1227
1228         for(idx=0; idx<n_lights; idx++){
1229                 // get the light dir for this light
1230                 light_get_global_dir(&light_dir, idx);
1231
1232                 // Find rp1
1233                 vm_vec_scale_add( &rp1, &rp0, &light_dir, 10000.0f );
1234
1235                 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) )    {
1236                         objp = &Objects[so->objnum];
1237                         shipp = &Ships[objp->instance];
1238
1239                         mc.model_num = shipp->modelnum;
1240                         mc.orient = &objp->orient;
1241                         mc.pos = &objp->pos;
1242                         mc.p0 = &rp0;
1243                         mc.p1 = &rp1;
1244                         mc.flags = MC_CHECK_MODEL;
1245
1246                         if ( model_collide(&mc) ){
1247                                 return 1;
1248                         }
1249                 }
1250         }
1251
1252         // not in shadow
1253         return 0;
1254 }
1255
1256
1257 // Given an ship see if it is in a shadow.
1258 int shipfx_in_shadow( object * src_obj )
1259 {
1260         mc_info mc;
1261         object *objp;
1262         ship_obj *so;
1263         ship *shipp;
1264         int n_lights;
1265         int idx;
1266
1267         vector rp0, rp1;
1268         vector light_dir;
1269
1270         rp0 = src_obj->pos;
1271
1272         // get the # of global lights
1273         n_lights = light_get_global_count();
1274
1275         for(idx=0; idx<n_lights; idx++){
1276                 // get the direction for this light
1277                 light_get_global_dir(&light_dir, idx);
1278
1279                 // Find rp1
1280                 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) )    {
1281                         objp = &Objects[so->objnum];
1282
1283                         if ( src_obj != objp )  {
1284                                 shipp = &Ships[objp->instance];
1285
1286                                 vm_vec_scale_add( &rp1, &rp0, &light_dir, objp->radius*10.0f );
1287
1288                                 mc.model_num = shipp->modelnum;
1289                                 mc.orient = &objp->orient;
1290                                 mc.pos = &objp->pos;
1291                                 mc.p0 = &rp0;
1292                                 mc.p1 = &rp1;
1293                                 mc.flags = MC_CHECK_MODEL;
1294
1295         //                      mc.flags |= MC_CHECK_SPHERELINE;
1296         //                      mc.radius = src_obj->radius;
1297
1298                                 if ( model_collide(&mc) )       {
1299                                         return 1;
1300                                 }
1301                         }
1302                 }
1303         }
1304
1305         // not in shadow
1306         return 0;
1307 }
1308
1309 // Given world point see if it is in a shadow.
1310 int shipfx_eye_in_shadow( vector *eye_pos, object * src_obj, int sun_n )
1311 {
1312         mc_info mc;
1313         object *objp;
1314         ship_obj *so;
1315         ship *shipp;
1316
1317         vector rp0, rp1;
1318         vector light_dir;
1319
1320         rp0 = *eye_pos;
1321
1322         // get the light dir
1323         if(!light_get_global_dir(&light_dir, sun_n)){
1324                 return 0;
1325         }
1326
1327         // Find rp1
1328         for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) )    {
1329                 objp = &Objects[so->objnum];
1330
1331                 if ( src_obj != objp )  {
1332                         shipp = &Ships[objp->instance];
1333
1334                         vm_vec_scale_add( &rp1, &rp0, &light_dir, objp->radius*10.0f );
1335
1336                         ship_model_start(objp);
1337
1338                         mc.model_num = shipp->modelnum;
1339                         mc.orient = &objp->orient;
1340                         mc.pos = &objp->pos;
1341                         mc.p0 = &rp0;
1342                         mc.p1 = &rp1;
1343                         mc.flags = MC_CHECK_MODEL;
1344
1345         //                      mc.flags |= MC_CHECK_SPHERELINE;
1346         //                      mc.radius = src_obj->radius;
1347
1348                         int hit = model_collide(&mc);
1349
1350                         ship_model_stop(objp);
1351
1352                         if (hit) {
1353                                 return 1;
1354                         }
1355                 }
1356         }
1357
1358         // Check all the big hull debris pieces.
1359         debris  *db = Debris;
1360
1361         int i;
1362         for ( i = 0; i < MAX_DEBRIS_PIECES; i++, db++ ) {
1363                 if ( !(db->flags & DEBRIS_USED) || !db->is_hull ){
1364                         continue;
1365                 }
1366
1367                 objp = &Objects[db->objnum];
1368
1369                 vm_vec_scale_add( &rp1, &rp0, &light_dir, objp->radius*10.0f );
1370
1371                 mc.model_num = db->model_num;   // Fill in the model to check
1372                 mc.submodel_num = db->submodel_num;
1373                 model_clear_instance( mc.model_num );
1374                 mc.orient = &objp->orient;                                      // The object's orient
1375                 mc.pos = &objp->pos;                                                    // The object's position
1376                 mc.p0 = &rp0;                           // Point 1 of ray to check
1377                 mc.p1 = &rp1;                                   // Point 2 of ray to check
1378                 mc.flags = (MC_CHECK_MODEL | MC_SUBMODEL);
1379
1380                 if (model_collide(&mc)) {
1381                         return 1;
1382                 }
1383         }
1384
1385         // not in shadow
1386         return 0;
1387 }
1388
1389 //=====================================================================================
1390 // STUFF FOR DOING SHIP GUN FLASHES
1391 //=====================================================================================
1392
1393 #define MAX_FLASHES     128                     // How many flashes total
1394 #define FLASH_LIFE_PRIMARY              0.25f                   // How long flash lives
1395 #define FLASH_LIFE_SECONDARY    0.50f                   // How long flash lives
1396
1397
1398 typedef struct ship_flash {
1399         int     objnum;                                 // object number of parent ship
1400         int     obj_signature;                  // signature of that object
1401         int     light_num;                              // which light in the model this uses
1402         float   life;                                           // how long this should be around
1403         float max_life;                         // how long this has been around.
1404 } ship_flash;
1405
1406 int Ship_flash_inited = 0;
1407 int Ship_flash_highest = -1;
1408 ship_flash Ship_flash[MAX_FLASHES];
1409
1410 // Resets the ship flash stuff. Call before each level.
1411 void shipfx_flash_init()
1412 {
1413         int i;
1414
1415         for (i=0; i<MAX_FLASHES; i++ )  {
1416                 Ship_flash[i].objnum = -1;                      // mark as unused
1417         }
1418         Ship_flash_highest = -1;
1419         Ship_flash_inited = 1;
1420 }
1421
1422
1423 // Given that a ship fired a weapon, light up the model
1424 // accordingly.
1425 void shipfx_flash_create(object *objp, ship * shipp, vector *gun_pos, vector *gun_dir, int is_primary, int weapon_info_index)
1426 {
1427         int i;
1428         int objnum = OBJ_INDEX(objp);
1429
1430         Assert(Ship_flash_inited);
1431
1432         polymodel *pm = model_get( shipp->modelnum );
1433         int closest_light = -1;
1434         float d, closest_dist = 0.0f;
1435
1436         // ALWAYS do this - since this is called once per firing
1437         // if this is a cannon type weapon, create a muzzle flash
1438         // HACK - let the flak guns do this on their own since they fire so quickly
1439         if((Weapon_info[weapon_info_index].wi_flags & WIF_MFLASH) && !(Weapon_info[weapon_info_index].wi_flags & WIF_FLAK)){
1440                 // spiffy new flash stuff
1441                 mflash_create(gun_pos, gun_dir, Weapon_info[weapon_info_index].muzzle_flash);
1442         }
1443
1444         if ( pm->num_lights < 1 ) return;
1445
1446         for (i=0; i<pm->num_lights; i++ )       {
1447                 d = vm_vec_dist( &pm->lights[i].pos, gun_pos );
1448
1449                 if ( pm->lights[i].type == BSP_LIGHT_TYPE_WEAPON ) {
1450                         if ( (closest_light==-1) || (d<closest_dist) )  {
1451                                 closest_light = i;
1452                                 closest_dist = d;
1453                         }
1454                 }
1455         }
1456
1457         if ( closest_light == -1 ) return;
1458
1459         int first_slot = -1;
1460
1461         for (i=0; i<=Ship_flash_highest; i++ )  {
1462                 if ( (first_slot==-1) && (Ship_flash[i].objnum < 0) )   {
1463                         first_slot = i;
1464                 }
1465
1466                 if ( (Ship_flash[i].objnum == objnum) && (Ship_flash[i].obj_signature==objp->signature) )       {
1467                         if ( Ship_flash[i].light_num == closest_light ) {
1468                                 // This is already flashing!
1469                                 Ship_flash[i].life = 0.0f;
1470                                 if ( is_primary )       {
1471                                         Ship_flash[i].max_life = FLASH_LIFE_PRIMARY;
1472                                 } else {
1473                                         Ship_flash[i].max_life = FLASH_LIFE_SECONDARY;
1474                                 }
1475                                 return;
1476                         }
1477                 }
1478         }
1479
1480         if ( first_slot == -1 ) {
1481                 if ( Ship_flash_highest < MAX_FLASHES-1 )       {
1482                         Ship_flash_highest++;
1483                         first_slot = Ship_flash_highest;
1484                 } else {
1485                         //mprintf(( "SHIP_FLASH: Out of flash spots!\n" ));
1486                         return;         // out of flash slots
1487                 }
1488         }
1489
1490         Assert( Ship_flash[first_slot].objnum == -1 );
1491
1492         Ship_flash[first_slot].objnum = objnum;
1493         Ship_flash[first_slot].obj_signature = objp->signature;
1494         Ship_flash[first_slot].life = 0.0f;             // Start it up
1495         if ( is_primary )       {
1496                 Ship_flash[first_slot].max_life = FLASH_LIFE_PRIMARY;
1497         } else {
1498                 Ship_flash[first_slot].max_life = FLASH_LIFE_SECONDARY;
1499         }
1500         Ship_flash[first_slot].light_num = closest_light;
1501 }
1502
1503 // Sets the flash lights in the model used by this
1504 // ship to the appropriate values.  There might not
1505 // be any flashes linked to this ship in which
1506 // case this function does nothing.
1507 void shipfx_flash_light_model( object *objp, ship * shipp )
1508 {
1509         int i, objnum = OBJ_INDEX(objp);
1510         polymodel *pm = model_get( shipp->modelnum );
1511
1512         for (i=0; i<=Ship_flash_highest; i++ )  {
1513                 if ( (Ship_flash[i].objnum == objnum) && (Ship_flash[i].obj_signature==objp->signature) )       {
1514                         float v = (Ship_flash[i].max_life - Ship_flash[i].life)/Ship_flash[i].max_life;
1515
1516                         pm->lights[Ship_flash[i].light_num].value += v / 255.0f;
1517                 }
1518         }
1519
1520 }
1521
1522 // Does whatever processing needs to be done each frame.
1523 void shipfx_flash_do_frame(float frametime)
1524 {
1525         ship_flash *sf;
1526         int kill_it = 0;
1527         int i;
1528
1529         for (i=0, sf = &Ship_flash[0]; i<=Ship_flash_highest; i++, sf++ )       {
1530                 if ( sf->objnum > -1 )  {
1531                         if ( Objects[sf->objnum].signature != sf->obj_signature )       {
1532                                 kill_it = 1;
1533                         }
1534                         sf->life += frametime;
1535                         if ( sf->life >= sf->max_life ) kill_it = 1;
1536
1537                         if (kill_it) {
1538                                 sf->objnum = -1;
1539                                 if ( i == Ship_flash_highest )  {
1540                                         while( (Ship_flash_highest>0) && (Ship_flash[Ship_flash_highest].objnum == -1) )        {
1541                                                 Ship_flash_highest--;
1542                                         }
1543                                 }
1544                         }
1545                 }
1546         }
1547
1548 }
1549
1550 float Particle_width = 1.2f;
1551 DCF(particle_width, "Multiplier for angular width of the particle spew")
1552 {
1553         if ( Dc_command ) {
1554                 dc_get_arg(ARG_FLOAT);
1555                 if ( (Dc_arg_float >= 0 ) && (Dc_arg_float <= 5) ) {
1556                         Particle_width = Dc_arg_float;
1557                 } else {
1558                         dc_printf( "Illegal value for particle width. (Must be from 0-5) \n\n");
1559                 }
1560         }
1561 }
1562
1563 float Particle_number = 1.2f;
1564 DCF(particle_num, "Multiplier for the number of particles created")
1565 {
1566         if ( Dc_command ) {
1567                 dc_get_arg(ARG_FLOAT);
1568                 if ( (Dc_arg_float >= 0 ) && (Dc_arg_float <= 5) ) {
1569                         Particle_number = Dc_arg_float;
1570                 } else {
1571                         dc_printf( "Illegal value for particle num. (Must be from 0-5) \n\n");
1572                 }
1573         }
1574 }
1575
1576 float Particle_life = 1.2f;
1577 DCF(particle_life, "Multiplier for the lifetime of particles created")
1578 {
1579         if ( Dc_command ) {
1580                 dc_get_arg(ARG_FLOAT);
1581                 if ( (Dc_arg_float >= 0 ) && (Dc_arg_float <= 5) ) {
1582                         Particle_life = Dc_arg_float;
1583                 } else {
1584                         dc_printf( "Illegal value for particle life. (Must be from 0-5) \n\n");
1585                 }
1586         }
1587 }
1588
1589 // Make sparks fly off of ship n.
1590 // sn = spark number to spark, corrosponding to element in
1591 //      ship->hitpos array.  If this isn't -1, it is a just
1592 //      got hit by weapon spark, otherwise pick one randomally.
1593 void shipfx_emit_spark( int n, int sn )
1594 {
1595         int create_spark = 1;
1596         object * obj;
1597         vector outpnt;
1598         ship *shipp = &Ships[n];
1599         float ship_radius, spark_scale_factor;
1600
1601         if ( shipp->num_hits <= 0 )
1602                 return;
1603
1604         // get radius of ship
1605         ship_radius = model_get_radius(Ship_info[shipp->ship_info_index].modelnum);
1606
1607         // get spark_scale_factor -- how much to increase ship sparks, based on radius
1608         if (ship_radius > 40) {
1609                 spark_scale_factor = 1.0f;
1610         } else if (ship_radius > 20) {
1611                 spark_scale_factor = (ship_radius - 20.0f) / 20.0f;
1612         } else {
1613                 spark_scale_factor = 0.0f;
1614         }
1615
1616         float spark_time_scale  = 1.0f + spark_scale_factor * (Particle_life   - 1.0f);
1617         float spark_width_scale = 1.0f + spark_scale_factor * (Particle_width  - 1.0f);
1618         float spark_num_scale   = 1.0f + spark_scale_factor * (Particle_number - 1.0f);
1619
1620         obj = &Objects[shipp->objnum];
1621         ship_info* si = &Ship_info[shipp->ship_info_index];
1622
1623         float hull_percent = obj->hull_strength / si->initial_hull_strength;
1624         if (hull_percent < 0.001) {
1625                 hull_percent = 0.001f;
1626         }
1627         float fraction = 0.1f * obj->radius / hull_percent;
1628         if (fraction > 1.0f) {
1629                 fraction = 1.0f;
1630         }
1631
1632         int spark_num;
1633         if ( sn == -1 ) {
1634                 spark_num = myrand() % shipp->num_hits;
1635         } else {
1636                 spark_num = sn;
1637         }
1638
1639         // don't display sparks that have expired
1640         if ( timestamp_elapsed(shipp->sparks[spark_num].end_time) ) {
1641                 return;
1642         }
1643
1644         // get spark position
1645         if (shipp->sparks[spark_num].submodel_num != -1) {
1646                 ship_model_start(obj);
1647                 model_find_world_point(&outpnt, &shipp->sparks[spark_num].pos, shipp->modelnum, shipp->sparks[spark_num].submodel_num, &obj->orient, &obj->pos);
1648                 ship_model_stop(obj);
1649         } else {
1650                 // rotate sparks correctly with current ship orient
1651                 vm_vec_unrotate(&outpnt, &shipp->sparks[spark_num].pos, &obj->orient);
1652                 vm_vec_add2(&outpnt,&obj->pos);
1653         }
1654
1655         if ( shipp->flags & (SF_ARRIVING|SF_DEPART_WARP) ) {
1656                 vector tmp;
1657                 vm_vec_sub( &tmp, &outpnt, &shipp->warp_effect_pos );
1658                 if ( vm_vec_dot( &tmp, &shipp->warp_effect_fvec ) < 0.0f )      {
1659                         // if in front of warp plane, don't create.
1660                         create_spark = 0;
1661                 }
1662         }
1663
1664         if ( create_spark )     {
1665
1666                 particle_emitter        pe;
1667
1668                 pe.pos = outpnt;                                // Where the particles emit from
1669
1670                 if ( shipp->flags & (SF_ARRIVING|SF_DEPART_WARP) ) {
1671                         // No velocity if going through warp.
1672                         pe.vel = vmd_zero_vector;
1673                 } else {
1674                         // Initial velocity of all the particles.
1675                         // 0.0f = 0% of parent's.
1676                         // 1.0f = 100% of parent's.
1677                         vm_vec_copy_scale( &pe.vel, &obj->phys_info.vel, 0.7f );
1678                 }
1679
1680                 // TODO: add velocity from rotation if submodel is rotating
1681                 // v_rot = w x r
1682
1683                 // r = outpnt - model_find_world_point(0)
1684
1685                 // w = model_find_world_dir(
1686                 // model_find_world_dir(&out_dir, &in_dir, model_num, submodel_num, &objorient, &objpos);
1687
1688                 vector tmp_norm, tmp_vel;
1689                 vm_vec_sub( &tmp_norm, &outpnt, &obj->pos );
1690                 vm_vec_normalize_safe(&tmp_norm);
1691
1692                 tmp_vel = obj->phys_info.vel;
1693                 if ( vm_vec_normalize_safe(&tmp_vel) > 1.0f )   {
1694                         vm_vec_scale_add2(&tmp_norm,&tmp_vel, -2.0f);
1695                         vm_vec_normalize_safe(&tmp_norm);
1696                 }
1697
1698                 pe.normal = tmp_norm;                   // What normal the particle emit around
1699                 pe.normal_variance = 0.3f;              //      How close they stick to that normal 0=good, 1=360 degree
1700                 pe.min_rad = 0.20f;                             // Min radius
1701                 pe.max_rad = 0.50f;                             // Max radius
1702
1703                 // first time through - set up end time and make heavier initially
1704                 if ( sn > -1 )  {
1705                         // Sparks for first time at this spot
1706                         if (si->flags & SIF_FIGHTER) {
1707                                 if (hull_percent > 0.6f) {
1708                                         // sparks only once when hull > 60%
1709                                         float spark_duration = (float)pow(2.0f, -5.0f*(hull_percent-1.3f)) * (1.0f + 0.6f*(frand()-0.5f));      // +- 30%
1710                                         shipp->sparks[spark_num].end_time = timestamp( (int) (1000.0f * spark_duration) );
1711                                 } else {
1712                                         // spark never ends when hull < 60% (~277 hr)
1713                                         shipp->sparks[spark_num].end_time = timestamp( 100000000 );
1714                                 }
1715                         }
1716
1717                         if ( D3D_enabled ) {
1718                                 pe.num_low  = 25;                               // Lowest number of particles to create (hardware)
1719                                 pe.num_high = 30;                               // Highest number of particles to create (hardware)
1720                         } else {
1721                                 pe.num_low  = 5;                                // Lowest number of particles to create (software)
1722                                 pe.num_high = 7;                                // Highest number of particles to create (software)
1723                         }
1724                         pe.normal_variance = 1.0f;      //      How close they stick to that normal 0=good, 1=360 degree
1725                         pe.min_vel = 2.0f;                              // How fast the slowest particle can move
1726                         pe.max_vel = 12.0f;                             // How fast the fastest particle can move
1727                         pe.min_life = 0.05f;                            // How long the particles live
1728                         pe.max_life = 0.55f;                            // How long the particles live
1729
1730                         particle_emit( &pe, PARTICLE_FIRE, 0 );
1731                 } else {
1732
1733                         pe.min_rad = 0.7f;                              // Min radius
1734                         pe.max_rad = 1.3f;                              // Max radius
1735                         if ( D3D_enabled ) {
1736                                 pe.num_low  = int (20 * spark_num_scale);               // Lowest number of particles to create (hardware)
1737                                 pe.num_high = int (50 * spark_num_scale);               // Highest number of particles to create (hardware)
1738                         } else {
1739                                 pe.num_low  = 2;                        // Lowest number of particles to create (software)
1740                                 pe.num_high = 8;                // Highest number of particles to create (software)
1741                         }
1742                         pe.normal_variance = 0.2f * spark_width_scale;          //      How close they stick to that normal 0=good, 1=360 degree
1743                         pe.min_vel = 3.0f;                              // How fast the slowest particle can move
1744                         pe.max_vel = 12.0f;                             // How fast the fastest particle can move
1745                         pe.min_life = 0.35f*2.0f * spark_time_scale;            // How long the particles live
1746                         pe.max_life = 0.75f*2.0f * spark_time_scale;            // How long the particles live
1747
1748                         particle_emit( &pe, PARTICLE_SMOKE, 0 );
1749                 }
1750         }
1751
1752         // Select time to do next spark
1753 //      Ships[n].next_hit_spark = timestamp_rand(100,500);
1754         shipp->next_hit_spark = timestamp_rand(50,100);
1755 }
1756
1757
1758
1759 //=====================================================================================
1760 // STUFF FOR DOING LARGE SHIP EXPLOSIONS
1761 //=====================================================================================
1762
1763 int     Bs_exp_fire_low = 1;
1764 float   Bs_exp_fire_time_mult = 1.0f;
1765
1766 DCF_BOOL(bs_exp_fire_low, Bs_exp_fire_low)
1767 DCF(bs_exp_fire_time_mult, "Multiplier time between fireball in big ship explosion")
1768 {
1769         if ( Dc_command ) {
1770                 dc_get_arg(ARG_FLOAT);
1771                 if ( (Dc_arg_float >= 0.1 ) && (Dc_arg_float <= 5) ) {
1772                         Bs_exp_fire_time_mult = Dc_arg_float;
1773                 } else {
1774                         dc_printf( "Illegal value for bs_exp_fire_time_mult. (Must be from 0.1-5) \n\n");
1775                 }
1776         }
1777 }
1778
1779 #define MAX_SPLIT_SHIPS         3               // How many can explode at once.  Each one is about 1K.
1780
1781 #define DEBRIS_NONE                     0
1782 #define DEBRIS_DRAW                     1
1783 #define DEBRIS_FREE                     2
1784
1785 typedef struct clip_ship {
1786         object*                 parent_obj;
1787         float                   length_left;    // uncomsumed length
1788         matrix                  orient;
1789         physics_info    phys_info;
1790         vector                  local_pivot;                                                            // world center of mass position of half ship
1791         vector                  model_center_disp_to_orig_center;       // displacement from half ship center to original model center
1792         vector                  clip_plane_norm;                                                        // clip plane normal (local [0,0,1] or [0,0,-1])
1793         float                           cur_clip_plane_pt;                                              // displacement from half ship clip plane to original model center
1794         float                           explosion_vel;
1795         ubyte                           draw_debris[MAX_DEBRIS_OBJECTS];
1796         int                             next_fireball;
1797 } clip_ship;
1798
1799 typedef struct split_ship {
1800         int                             used;                                   // 0 if not used, 1 if used
1801         clip_ship               front_ship;
1802         clip_ship               back_ship;
1803         int                             explosion_flash_timestamp;
1804         int                             explosion_flash_started;
1805         int                             sound_handle[NUM_SUB_EXPL_HANDLES];
1806 } split_ship;
1807
1808
1809 static split_ship Split_ships[MAX_SPLIT_SHIPS];
1810 static int Split_ships_inited = 0;
1811
1812 static void split_ship_init_system()
1813 {
1814         int i;
1815         for (i=0; i<MAX_SPLIT_SHIPS; i++ )      {
1816                 Split_ships[i].used = 0;
1817         }
1818         Split_ships_inited = 1;
1819 }
1820
1821 static void maybe_fireball_wipe(clip_ship* half_ship, int* sound_handle);
1822 static void split_ship_init( ship* shipp, split_ship* split_ship )
1823 {
1824         object* parent_ship_obj = &Objects[shipp->objnum];
1825         matrix* orient = &parent_ship_obj->orient;
1826         for (int ii=0; ii<NUM_SUB_EXPL_HANDLES; ii++) {
1827                 split_ship->sound_handle[ii] = shipp->sub_expl_sound_handle[ii];
1828         }
1829
1830         // play 3d sound for shockwave explosion
1831         snd_play_3d( &Snds[SND_SHOCKWAVE_EXPLODE], &parent_ship_obj->pos, &View_position, 0.0f, NULL, 0, 1.0f, SND_PRIORITY_SINGLE_INSTANCE, NULL, 3.0f );
1832
1833         // initialize both ships
1834         split_ship->front_ship.parent_obj = parent_ship_obj;
1835         split_ship->back_ship.parent_obj  = parent_ship_obj;
1836         split_ship->explosion_flash_timestamp = timestamp((int)(0.00075f*parent_ship_obj->radius));
1837         split_ship->explosion_flash_started = 0;
1838         split_ship->front_ship.orient = *orient;
1839         split_ship->back_ship.orient  = *orient;
1840         split_ship->front_ship.next_fireball = timestamp_rand(0, 100);
1841         split_ship->back_ship.next_fireball  = timestamp_rand(0, 100);
1842
1843         split_ship->front_ship.clip_plane_norm = vmd_z_vector;
1844         vm_vec_copy_scale(&split_ship->back_ship.clip_plane_norm, &vmd_z_vector, -1.0f);
1845
1846         // find the point at which the ship splits (relative to its pivot)
1847         polymodel* pm = model_get(shipp->modelnum);
1848         float init_clip_plane_dist;
1849         if (pm->num_split_plane > 0) {
1850                 int index = rand()%pm->num_split_plane;
1851                 init_clip_plane_dist = pm->split_plane[index];
1852         } else {
1853                 init_clip_plane_dist = 0.5f * (0.5f - frand())*pm->core_radius;
1854         }
1855
1856         split_ship->back_ship.cur_clip_plane_pt =  init_clip_plane_dist;
1857         split_ship->front_ship.cur_clip_plane_pt = init_clip_plane_dist;
1858
1859         float dist;
1860         dist = (split_ship->front_ship.cur_clip_plane_pt+pm->maxs.xyz.z)/2.0f;
1861         vm_vec_copy_scale(&split_ship->front_ship.local_pivot, &orient->v.fvec, dist);
1862         (void) vm_vec_make(&split_ship->front_ship.model_center_disp_to_orig_center, 0.0f, 0.0f, -dist);
1863         dist = (split_ship->back_ship.cur_clip_plane_pt +pm->mins.xyz.z)/2.0f;
1864         vm_vec_copy_scale(&split_ship->back_ship.local_pivot, &orient->v.fvec, dist);
1865         (void) vm_vec_make(&split_ship->back_ship.model_center_disp_to_orig_center, 0.0f, 0.0f, -dist);
1866         vm_vec_add2(&split_ship->front_ship.local_pivot, &parent_ship_obj->pos );
1867         vm_vec_add2(&split_ship->back_ship.local_pivot,  &parent_ship_obj->pos );
1868
1869         // find which debris pieces are in the front and back split ships
1870         for (int i=0; i<pm->num_debris_objects; i++ )   {
1871                 vector temp_pos = {0.0f, 0.0f, 0.0f};
1872                 vector tmp = {0.0f, 0.0f, 0.0f };
1873                 vector tmp1 = pm->submodel[pm->debris_objects[i]].offset;
1874                 // tmp is world position,  temp_pos is world_pivot,  tmp1 is offset from world_pivot (in ship local coord)
1875                 model_find_world_point(&tmp, &tmp1, shipp->modelnum, -1, &vmd_identity_matrix, &temp_pos );
1876                 if (tmp.xyz.z > init_clip_plane_dist) {
1877                         split_ship->front_ship.draw_debris[i] = DEBRIS_DRAW;
1878                         split_ship->back_ship.draw_debris[i]  = DEBRIS_NONE;
1879                 } else {
1880                         split_ship->front_ship.draw_debris[i] = DEBRIS_NONE;
1881                         split_ship->back_ship.draw_debris[i]  = DEBRIS_DRAW;
1882                 }
1883         }
1884
1885         /*
1886         // set the remaining debris slots to not draw
1887         for (i=pm->num_debris_objects; i<MAX_DEBRIS_OBJECTS; i++) {
1888                 split_ship->front_ship.draw_debris[i] = DEBRIS_NONE;
1889                 split_ship->back_ship.draw_debris[i]  = DEBRIS_NONE;
1890         } */
1891
1892         // set up physics
1893         physics_init( &split_ship->front_ship.phys_info );
1894         physics_init( &split_ship->back_ship.phys_info );
1895         split_ship->front_ship.phys_info.flags  |= (PF_ACCELERATES | PF_DEAD_DAMP);
1896         split_ship->back_ship.phys_info.flags |= (PF_ACCELERATES | PF_DEAD_DAMP);
1897         split_ship->front_ship.phys_info.side_slip_time_const = 10000.0f;
1898         split_ship->back_ship.phys_info.side_slip_time_const =  10000.0f;
1899         split_ship->front_ship.phys_info.rotdamp = 10000.0f;
1900         split_ship->back_ship.phys_info.rotdamp =  10000.0f;
1901
1902         // set up explosion vel and relative velocities (assuming mass depends on length)
1903         float front_length = pm->maxs.xyz.z - split_ship->front_ship.cur_clip_plane_pt;
1904         float back_length  = split_ship->back_ship.cur_clip_plane_pt - pm->mins.xyz.z;
1905         float ship_length = front_length + back_length;
1906         split_ship->front_ship.length_left = front_length;
1907         split_ship->back_ship.length_left  = back_length;
1908
1909         float expl_length_scale = (ship_length - 200.0f) / 2000.0f;
1910         // s_r_f effects speed of "wipe" and rotvel
1911         float speed_reduction_factor = (1.0f + 0.001f*parent_ship_obj->radius);
1912         float explosion_time = (3.0f + expl_length_scale + (frand()-0.5f)) * speed_reduction_factor;
1913         float long_length = max(front_length, back_length);
1914         float expl_vel = long_length / explosion_time;
1915         split_ship->front_ship.explosion_vel = expl_vel;
1916         split_ship->back_ship.explosion_vel  = -expl_vel;
1917
1918         float rel_vel = (0.6f + 0.2f*frand()) * expl_vel * speed_reduction_factor;
1919         float front_vel = rel_vel * back_length / ship_length;
1920         float back_vel = -rel_vel * front_length / ship_length;
1921         // mprintf(("rel_vel %.1f, expl_vel %.1f\n", rel_vel, expl_vel));
1922
1923         // set up rotational vel
1924         vector rotvel;
1925         vm_vec_rand_vec_quick(&rotvel);
1926         rotvel.xyz.z = 0.0f;
1927         vm_vec_normalize(&rotvel);
1928         vm_vec_scale(&rotvel, 0.15f / speed_reduction_factor);
1929         split_ship->front_ship.phys_info.rotvel = rotvel;
1930         vm_vec_copy_scale(&split_ship->back_ship.phys_info.rotvel, &rotvel, -(front_length*front_length)/(back_length*back_length));
1931         split_ship->front_ship.phys_info.rotvel.xyz.z = parent_ship_obj->phys_info.rotvel.xyz.z;
1932         split_ship->back_ship.phys_info.rotvel.xyz.z  = parent_ship_obj->phys_info.rotvel.xyz.z;
1933
1934
1935         // modify vel of each split ship based on rotvel of parent ship obj
1936         vector temp_rotvel = parent_ship_obj->phys_info.rotvel;
1937         temp_rotvel.xyz.z = 0.0f;
1938         vector vel_from_rotvel;
1939         vm_vec_crossprod(&vel_from_rotvel, &temp_rotvel, &split_ship->front_ship.local_pivot);
1940         //      vm_vec_scale_add2(&split_ship->front_ship.phys_info.vel, &vel_from_rotvel, 0.5f);
1941         vm_vec_crossprod(&vel_from_rotvel, &temp_rotvel, &split_ship->back_ship.local_pivot);
1942         //      vm_vec_scale_add2(&split_ship->back_ship.phys_info.vel, &vel_from_rotvel, 0.5f);
1943
1944         // set up velocity and make initial fireballs and particles
1945         split_ship->front_ship.phys_info.vel = parent_ship_obj->phys_info.vel;
1946         split_ship->back_ship.phys_info.vel  = parent_ship_obj->phys_info.vel;
1947         maybe_fireball_wipe(&split_ship->front_ship, (int*)&split_ship->sound_handle);
1948         maybe_fireball_wipe(&split_ship->back_ship,  (int*)&split_ship->sound_handle);
1949         vm_vec_scale_add2(&split_ship->front_ship.phys_info.vel, &orient->v.fvec, front_vel);
1950         vm_vec_scale_add2(&split_ship->back_ship.phys_info.vel,  &orient->v.fvec, back_vel);
1951
1952         // HANDLE LIVE DEBRIS - blow off if not already gone
1953         shipfx_maybe_create_live_debris_at_ship_death( parent_ship_obj );
1954 }
1955
1956
1957 static void half_ship_render_ship_and_debris(clip_ship* half_ship,ship *shipp)
1958 {
1959         Assert( Split_ships_inited );
1960
1961         polymodel *pm = model_get(shipp->modelnum);
1962
1963         // get rotated clip plane normal and world coord of original ship center
1964         vector orig_ship_world_center, clip_plane_norm, model_clip_plane_pt, debris_clip_plane_pt;
1965         vm_vec_unrotate(&clip_plane_norm, &half_ship->clip_plane_norm, &half_ship->orient);
1966         vm_vec_unrotate(&orig_ship_world_center, &half_ship->model_center_disp_to_orig_center, &half_ship->orient);
1967         vm_vec_add2(&orig_ship_world_center, &half_ship->local_pivot);
1968
1969         // *out_pivot = orig_ship_world_center;
1970
1971         // get debris clip plane pt and draw debris
1972         vm_vec_unrotate(&debris_clip_plane_pt, &half_ship->model_center_disp_to_orig_center, &half_ship->orient);
1973         vm_vec_add2(&debris_clip_plane_pt, &half_ship->local_pivot);
1974         g3_start_user_clip_plane( &debris_clip_plane_pt, &clip_plane_norm);
1975
1976         // set up render flags
1977         uint render_flags = MR_NORMAL;
1978
1979         for (int i=0; i<pm->num_debris_objects; i++ )   {
1980                 // draw DEBRIS_FREE in test only
1981                 if (half_ship->draw_debris[i] == DEBRIS_DRAW) {
1982                         vector temp_pos = orig_ship_world_center;
1983                         vector tmp = {0.0f, 0.0f, 0.0f};
1984                         vector tmp1 = pm->submodel[pm->debris_objects[i]].offset;
1985
1986                         // determine if explosion front has past debris piece
1987                         // 67 ~ dist expl moves in 2 frames -- maybe fraction works better
1988                         int is_live_debris = pm->submodel[pm->debris_objects[i]].is_live_debris;
1989                         int create_debris = 0;
1990                         // front ship
1991                         if (half_ship->explosion_vel > 0) {
1992                                 if (half_ship->cur_clip_plane_pt > tmp1.xyz.z + pm->submodel[pm->debris_objects[i]].max.xyz.z - 0.1f*half_ship->explosion_vel) {
1993                                         create_debris = 1;
1994                                 }
1995                                 // is the debris visible
1996 //                              if (half_ship->cur_clip_plane_pt > tmp1.xyz.z + pm->submodel[pm->debris_objects[i]].min.xyz.z - 0.5f*half_ship->explosion_vel) {
1997 //                                      render_debris = 1;
1998 //                              }
1999                         // back ship
2000                         } else {
2001                                 if (half_ship->cur_clip_plane_pt < tmp1.xyz.z + pm->submodel[pm->debris_objects[i]].min.xyz.z - 0.1f*half_ship->explosion_vel) {
2002                                         create_debris = 1;
2003                                 }
2004                                 // is the debris visible
2005 //                              if (half_ship->cur_clip_plane_pt < tmp1.xyz.z + pm->submodel[pm->debris_objects[i]].max.xyz.z - 0.5f*half_ship->explosion_vel) {
2006 //                                      render_debris = 1;
2007 //                              }
2008                         }
2009
2010                         // Draw debris, but not live debris
2011                         if ( !is_live_debris ) {
2012                                 model_find_world_point(&tmp, &tmp1, shipp->modelnum, -1, &half_ship->orient, &temp_pos);
2013                                 submodel_render(shipp->modelnum, pm->debris_objects[i], &half_ship->orient, &tmp, render_flags);
2014                         }
2015
2016                         // make free piece of debris
2017                         if ( create_debris ) {
2018                                 half_ship->draw_debris[i] = DEBRIS_FREE;                // mark debris to not render with model
2019                                 vector center_to_debris, debris_vel, radial_vel;
2020                                 // check if last debris piece, ie, debris_count == 0
2021                                 int debris_count = 0;
2022                                 for (int j=0; j<pm->num_debris_objects; j++ ) {
2023                                         if (half_ship->draw_debris[j] == DEBRIS_DRAW) {
2024                                                 debris_count++;
2025                                         }
2026                                 }
2027                                 // do debris create here, but not for live debris
2028                                 // debris vel (1) split ship vel (2) split ship rotvel (3) random
2029                                 if ( !is_live_debris ) {
2030                                         object* debris_obj;
2031                                         debris_obj = debris_create(half_ship->parent_obj, shipp->modelnum, pm->debris_objects[i], &tmp, &half_ship->local_pivot, 1, 1.0f);
2032                                         // AL: make sure debris_obj isn't NULL!
2033                                         if ( debris_obj ) {
2034                                                 vm_vec_scale(&debris_obj->phys_info.rotvel, 4.0f);
2035                                                 debris_obj->orient = half_ship->orient;
2036                                                 // if (debris_count > 0) {
2037                                                         //mprintf(( "base rotvel %.1f, debris rotvel mag %.2f\n", vm_vec_mag(&half_ship->phys_info.rotvel), vm_vec_mag(&debris_obj->phys_info.rotvel) ));
2038                                                         vm_vec_sub(&center_to_debris, &tmp, &half_ship->local_pivot);
2039                                                         vm_vec_crossprod(&debris_vel, &center_to_debris, &half_ship->phys_info.rotvel);
2040                                                         vm_vec_add2(&debris_vel, &half_ship->phys_info.vel);
2041                                                         vm_vec_copy_normalize(&radial_vel, &center_to_debris);
2042                                                         float radial_mag = 10.0f + 30.0f*frand();
2043                                                         vm_vec_scale_add2(&debris_vel, &radial_vel, radial_mag);
2044                                                         debris_obj->phys_info.vel = debris_vel;
2045                                                 /* } else {
2046                                                         debris_obj->phys_info.vel = half_ship->phys_info.vel;
2047                                                         debris_obj->phys_info.rotvel = half_ship->phys_info.rotvel;
2048                                                 } */
2049                                         }
2050                                 }
2051                         }
2052                 }
2053         }
2054
2055         // get model clip plane pt and draw model
2056         vector temp;
2057         (void) vm_vec_make(&temp, 0.0f, 0.0f, half_ship->cur_clip_plane_pt);
2058         vm_vec_unrotate(&model_clip_plane_pt, &temp, &half_ship->orient);
2059         vm_vec_add2(&model_clip_plane_pt, &orig_ship_world_center);
2060         g3_start_user_clip_plane( &model_clip_plane_pt, &clip_plane_norm );
2061         model_render(shipp->modelnum, &half_ship->orient, &orig_ship_world_center, render_flags);
2062 }
2063
2064 void shipfx_large_blowup_level_init()
2065 {
2066         split_ship_init_system();
2067
2068         if(Ship_cannon_bitmap != -1){
2069                 bm_unload(Ship_cannon_bitmap);
2070                 Ship_cannon_bitmap = bm_load(SHIP_CANNON_BITMAP);
2071         }
2072 }
2073
2074 // Returns 0 if couldn't init
2075 int shipfx_large_blowup_init(ship *shipp)
2076 {
2077
2078         if ( !Split_ships_inited )      {
2079                 split_ship_init_system();
2080         }
2081
2082         int i;
2083         for (i=0; i<MAX_SPLIT_SHIPS; i++ )      {
2084                 if ( Split_ships[i].used == 0 ) {
2085                         break;
2086                 }
2087         }
2088
2089         if ( i >= MAX_SPLIT_SHIPS )     {
2090                 mprintf(( "Not enough split ship slots!! See John!\n" ));
2091                 Int3();
2092                 return 0;
2093         }
2094
2095         Split_ships[i].used = 1;
2096         shipp->large_ship_blowup_index = i;
2097
2098         split_ship_init(shipp, &Split_ships[i] );
2099
2100         return 1;
2101 }
2102
2103 // ----------------------------------------------------------------------------
2104 // uses list of model z values with constant increment to find the radius of the
2105 // cross section at the current model z value
2106 float get_model_cross_section_at_z(float z, polymodel* pm)
2107 {
2108         if (pm->num_xc < 2) {
2109                 return 0.0f;
2110         }
2111
2112         float index, increment;
2113         increment = (pm->xc[pm->num_xc-1].z - pm->xc[0].z) / (float)(pm->num_xc - 1);
2114         index = (z - pm->xc[0].z) / increment;
2115
2116         if (index < 0.5f) {
2117                 return pm->xc[0].radius;
2118         } else if (index > (pm->num_xc - 1.0f - 0.5f)) {
2119                 return pm->xc[pm->num_xc-1].radius;
2120         } else {
2121                 int floor_index = (int)floor(index);
2122                 int ceil_index  = (int)ceil(index);
2123                 return max(pm->xc[ceil_index].radius, pm->xc[floor_index].radius);
2124         }
2125 }
2126
2127 // returns how long sound has been playing
2128 int get_sound_time_played(int snd_id, int handle)
2129 {
2130         if (handle == -1) {
2131                 return 100000;
2132         }
2133
2134         int bits_per_sample, frequency;
2135         snd_get_format(snd_id, &bits_per_sample, &frequency);
2136         int time_left = snd_time_remaining(handle, bits_per_sample, frequency);
2137         int duration = snd_get_duration(snd_id);
2138
2139         return (duration - time_left);
2140 }
2141
2142 // sound manager for big ship sub explosions sounds.
2143 // forces playing of sub-explosion sounds.  keeps track of active sounds, plays them for >= 750 ms
2144 // when sound has played >= 750, sound is stopped and new instance is started
2145 void do_sub_expl_sound(float radius, vector* sound_pos, int* sound_handle)
2146 {
2147         int sound_index, handle;
2148         // multiplier for range (near and far distances) to apply attenuation
2149         float sound_range = 1.0f + 0.0043f*radius;
2150
2151         int handle_index = rand()%NUM_SUB_EXPL_HANDLES;
2152         //mprintf(("handle_index %d\n", *handle_index));
2153
2154         // sound_index = get_sub_explosion_sound_index(handle_index);
2155         sound_index = SND_SHIP_EXPLODE_1;
2156         handle = sound_handle[handle_index];
2157
2158
2159         // mprintf(("dist to sound %.1f snd_indx: %d, h1: %d, h2: %d\n", vm_vec_dist(&Player_obj->pos, sound_pos), next_sound_index, sound_handle[0], sound_handle[1]));
2160
2161         if (handle == -1) {
2162                 // if no handle, get one
2163                 sound_handle[handle_index] = snd_play_3d( &Snds[sound_index], sound_pos, &View_position, 0.0f, NULL, 0, 0.6f, SND_PRIORITY_MUST_PLAY, NULL, sound_range );
2164         } else if (!snd_is_playing(handle)) {
2165                 // if sound not playing and old, get new one
2166                 // I don't think will happen with SND_PRIORITY_MUST_PLAY
2167                 if (get_sound_time_played(Snds[sound_index].id, handle) > 400) {
2168                         //mprintf(("sound not playing %d, time_played %d, stopped\n", handle, get_sound_time_played(Snds[sound_index].id, handle)));
2169                         snd_stop(sound_handle[handle_index]);
2170                         sound_handle[handle_index] = snd_play_3d( &Snds[sound_index], sound_pos, &View_position, 0.0f, NULL, 0, 0.6f, SND_PRIORITY_MUST_PLAY, NULL, sound_range );
2171                 }
2172         } else if (get_sound_time_played(Snds[sound_index].id, handle) > 750) {
2173                 //mprintf(("time %f, cur sound %d time_played %d num sounds %d\n", f2fl(Missiontime), handle_index, get_sound_time_played(Snds[sound_index].id, handle), snd_num_playing() ));
2174                 sound_handle[handle_index] = snd_play_3d( &Snds[sound_index], sound_pos, &View_position, 0.0f, NULL, 0, 0.6f, SND_PRIORITY_MUST_PLAY, NULL, sound_range );
2175         }
2176 }
2177
2178 // maybe create a fireball along model clip plane
2179 // also maybe plays explosion sound
2180 static void maybe_fireball_wipe(clip_ship* half_ship, int* sound_handle)
2181 {
2182         // maybe make fireball to cover wipe.
2183         if ( timestamp_elapsed(half_ship->next_fireball) ) {
2184                 if ( half_ship->length_left > 0.2f*fl_abs(half_ship->explosion_vel) )   {
2185
2186                         polymodel* pm = model_get(Ships[half_ship->parent_obj->instance].modelnum);
2187
2188                         vector model_clip_plane_pt, orig_ship_world_center, temp;
2189
2190                         vm_vec_unrotate(&orig_ship_world_center, &half_ship->model_center_disp_to_orig_center, &half_ship->orient);
2191                         vm_vec_add2(&orig_ship_world_center, &half_ship->local_pivot);
2192
2193                         (void) vm_vec_make(&temp, 0.0f, 0.0f, half_ship->cur_clip_plane_pt);
2194                         vm_vec_unrotate(&model_clip_plane_pt, &temp, &half_ship->orient);
2195                         vm_vec_add2(&model_clip_plane_pt, &orig_ship_world_center);
2196                         vm_vec_rand_vec_quick(&temp);
2197                         vm_vec_scale(&temp, 0.1f*frand());
2198                         vm_vec_add2(&model_clip_plane_pt, &temp);
2199
2200                         float rad = get_model_cross_section_at_z(half_ship->cur_clip_plane_pt, pm);
2201                         if (rad < 1) {
2202                                 rad = half_ship->parent_obj->radius * frand_range(0.4f, 0.6f);
2203                         } else {
2204                                 // make fireball radius (1.5 +/- .1) * model_cross_section value
2205                                 rad *= frand_range(1.4f, 1.6f);
2206                         }
2207
2208                         rad *= 1.5f;
2209                         rad = min(rad, half_ship->parent_obj->radius);
2210
2211                         // mprintf(("xc %.1f model %.1f\n", rad, half_ship->parent_obj->radius*0.25));
2212                         int fireball_type = FIREBALL_EXPLOSION_LARGE1 + rand()%FIREBALL_NUM_LARGE_EXPLOSIONS;
2213                         int low_res_fireballs = Bs_exp_fire_low;
2214                         fireball_create(&model_clip_plane_pt, fireball_type, OBJ_INDEX(half_ship->parent_obj), rad, 0, &half_ship->parent_obj->phys_info.vel, 0.0f, -1, NULL, low_res_fireballs);
2215
2216                         // start the next fireball up (3-4 per frame) + 30%
2217                         int time_low, time_high;
2218                         time_low = int(650 * Bs_exp_fire_time_mult);
2219                         time_high = int(900 * Bs_exp_fire_time_mult);
2220                         half_ship->next_fireball = timestamp_rand(time_low, time_high);
2221
2222                         // do sound
2223                         do_sub_expl_sound(half_ship->parent_obj->radius, &model_clip_plane_pt, sound_handle);
2224
2225                         // do particles
2226                         particle_emitter        pe;
2227
2228                         pe.num_low = 40;                                        // Lowest number of particles to create
2229                         pe.num_high = 80;                               // Highest number of particles to create
2230                         pe.pos = model_clip_plane_pt;   // Where the particles emit from
2231                         pe.vel = half_ship->phys_info.vel;              // Initial velocity of all the particles
2232
2233 #if defined(FS2_DEMO) || defined(FS1_DEMO)
2234                         float range = 1.0f + 0.002f*half_ship->parent_obj->radius * 5.0f;
2235 #else
2236                         float range = 1.0f + 0.002f*half_ship->parent_obj->radius;
2237 #endif
2238
2239 #if defined(FS2_DEMO) || defined(FS1_DEMO)
2240                         pe.min_life = 2.0f*range;                               // How long the particles live
2241                         pe.max_life = 10.0f*range;                              // How long the particles live
2242 #else
2243                         pe.min_life = 0.5f*range;                               // How long the particles live
2244                         pe.max_life = 6.0f*range;                               // How long the particles live
2245 #endif
2246                         pe.normal = vmd_x_vector;               // What normal the particle emit around
2247                         pe.normal_variance = 2.0f;              //      How close they stick to that normal 0=on normal, 1=180, 2=360 degree
2248                         pe.min_vel = 0.0f;                              // How fast the slowest particle can move
2249                         pe.max_vel = half_ship->explosion_vel;                          // How fast the fastest particle can move
2250
2251 #if defined(FS2_DEMO) || defined(FS1_DEMO)
2252                         float scale = half_ship->parent_obj->radius * 0.02f;
2253 #else
2254                         float scale = half_ship->parent_obj->radius * 0.01f;
2255 #endif
2256                         pe.min_rad = 0.5f*scale;                                // Min radius
2257                         pe.max_rad = 1.5f*scale;                                // Max radius
2258
2259                         particle_emit( &pe, PARTICLE_SMOKE2, 0, range );
2260
2261                 } else {
2262                         // time out forever
2263                         half_ship->next_fireball = timestamp(-1);
2264                 }
2265         }
2266 }
2267
2268
2269 // Returns 1 when explosion is done
2270 int shipfx_large_blowup_do_frame(ship *shipp, float frametime)
2271 {
2272         // DAVE:  I made this not do any movement just to try to get things working...
2273         // return 0;
2274
2275         Assert( Split_ships_inited );
2276         Assert( shipp->large_ship_blowup_index > -1 );
2277
2278         split_ship *the_split_ship = &Split_ships[shipp->large_ship_blowup_index];
2279         Assert( the_split_ship->used );         // Get John
2280
2281         // Do fireballs, particles, shockwave here
2282         // Note parent ship is still valid, vel and pos updated in obj_move_all
2283
2284         if ( timestamp_elapsed(the_split_ship->explosion_flash_timestamp) ) {
2285                 if ( !the_split_ship->explosion_flash_started ) {
2286                         object* objp = &Objects[shipp->objnum];
2287                         if (objp->flags & OF_WAS_RENDERED) {
2288                                 float excess_dist = vm_vec_dist(&Player_obj->pos, &objp->pos) - 2.0f*objp->radius - Player_obj->radius;
2289                                 float intensity = 1.0f - 0.1f*excess_dist / objp->radius;
2290
2291                                 if (intensity > 1) {
2292                                         intensity = 1.0f;
2293                                 }
2294
2295                                 if (intensity > 0.1f) {
2296                                         // big_explosion_flash(intensity);
2297                                 }
2298                         }
2299                         the_split_ship->explosion_flash_started = 1;
2300                 }
2301         }
2302
2303         physics_sim(&the_split_ship->front_ship.local_pivot, &the_split_ship->front_ship.orient, &the_split_ship->front_ship.phys_info, frametime);
2304         physics_sim(&the_split_ship->back_ship.local_pivot,  &the_split_ship->back_ship.orient,  &the_split_ship->back_ship.phys_info,  frametime);
2305         the_split_ship->front_ship.length_left -= the_split_ship->front_ship.explosion_vel*frametime;
2306         the_split_ship->back_ship.length_left  += the_split_ship->back_ship.explosion_vel *frametime;
2307         the_split_ship->front_ship.cur_clip_plane_pt += the_split_ship->front_ship.explosion_vel*frametime;
2308         the_split_ship->back_ship.cur_clip_plane_pt  += the_split_ship->back_ship.explosion_vel *frametime;
2309
2310         float length_left = max( the_split_ship->front_ship.length_left, the_split_ship->back_ship.length_left );
2311
2312         //      mprintf(( "Blowup frame, dist = %.1f \n", length_left ));
2313
2314         if ( length_left < 0 )  {
2315                 the_split_ship->used = 0;
2316                 return 1;
2317         }
2318
2319         maybe_fireball_wipe(&the_split_ship->front_ship, (int*)&the_split_ship->sound_handle);
2320         maybe_fireball_wipe(&the_split_ship->back_ship,  (int*)&the_split_ship->sound_handle);
2321         return 0;
2322 }
2323
2324 void shipfx_large_blowup_render(ship* shipp)
2325 {
2326 // This actually renders the original model like it should render.
2327 //      object *objp = &Objects[shipp->objnum];
2328 //      model_render( shipp->modelnum, &objp->orient, &objp->pos, MR_NORMAL );
2329 //      return;
2330
2331         Assert( Split_ships_inited );
2332         Assert( shipp->large_ship_blowup_index > -1 );
2333
2334         split_ship *the_split_ship = &Split_ships[shipp->large_ship_blowup_index];
2335         Assert( the_split_ship->used );         // Get John
2336
2337         // vector front_global_pivot, back_global_pivot;
2338
2339         if (the_split_ship->front_ship.length_left > 0) {
2340                 half_ship_render_ship_and_debris(&the_split_ship->front_ship,shipp);
2341         }
2342
2343         if (the_split_ship->back_ship.length_left > 0) {
2344                 half_ship_render_ship_and_debris(&the_split_ship->back_ship,shipp);
2345         }
2346
2347         g3_stop_user_clip_plane();
2348 }
2349
2350
2351 // ================== DO THE ELECTRIC ARCING STUFF =====================
2352 // Creates any new ones, moves old ones.
2353
2354 #define MAX_ARC_LENGTH_PERCENTAGE 0.25f
2355
2356 #define MAX_EMP_ARC_TIMESTAMP            (150.0f)
2357
2358 void shipfx_do_damaged_arcs_frame( ship *shipp )
2359 {
2360         int i;
2361         int should_arc;
2362         object *obj = &Objects[shipp->objnum];
2363         ship_info * sip = &Ship_info[shipp->ship_info_index];
2364
2365         should_arc = 1;
2366
2367         float damage = obj->hull_strength / sip->initial_hull_strength;
2368
2369         if (damage < 0) {
2370                 damage = 0.0f;
2371         }
2372
2373         // don't draw an arc based on damage
2374         if ( damage > 0.30f )   {
2375                 // Don't do spark.
2376                 should_arc = 0;
2377         }
2378
2379         // we should draw an arc
2380         if( shipp->emp_intensity > 0.0f){
2381                 should_arc = 1;
2382         }
2383
2384         // Kill off old sparks
2385         for(i=0; i<MAX_SHIP_ARCS; i++){
2386                 if(timestamp_valid(shipp->arc_timestamp[i]) && timestamp_elapsed(shipp->arc_timestamp[i])){
2387                         shipp->arc_timestamp[i] = timestamp(-1);
2388                 }
2389         }
2390
2391         // if we shouldn't draw an arc, return
2392         if(!should_arc){
2393                 return;
2394         }
2395
2396         if (!timestamp_valid(shipp->arc_next_time))     {
2397                 // start the next fireball up in the next 10 seconds or so...
2398                 int freq;
2399
2400                 // if the emp effect is active
2401                 if(shipp->emp_intensity > 0.0f){
2402                         freq = fl2i(MAX_EMP_ARC_TIMESTAMP);
2403                 }
2404                 // otherwise if we're arcing based upon damage
2405                 else {
2406                         freq = fl2i((damage+0.1f)*5000.0f);
2407                 }
2408
2409                 // set the next arc time
2410                 shipp->arc_next_time = timestamp_rand(freq*2,freq*4);
2411         }
2412
2413         if ( timestamp_elapsed(shipp->arc_next_time) )  {
2414
2415                 shipp->arc_next_time = timestamp(-1);           // invalid, so it gets restarted next frame
2416
2417                 //mprintf(( "Creating new ship arc!\n" ));
2418
2419                 int n, n_arcs = ((rand()>>5) % 3)+1;            // Create 1-3 sparks
2420
2421                 vector v1, v2, v3, v4;
2422                 submodel_get_two_random_points( shipp->modelnum, -1, &v1, &v2 );
2423                 submodel_get_two_random_points( shipp->modelnum, -1, &v3, &v4 );
2424
2425                 // For large ships, cap the length to be 25% of max radius
2426                 if ( obj->radius > 200.0f )     {
2427                         float max_dist = obj->radius * MAX_ARC_LENGTH_PERCENTAGE;
2428
2429                         vector tmp;
2430                         float d;
2431
2432                         // Cap arc 2->1
2433                         vm_vec_sub( &tmp, &v1, &v2 );
2434                         d = vm_vec_mag_quick( &tmp );
2435                         if ( d > max_dist )     {
2436                                 vm_vec_scale_add( &v1, &v2, &tmp, max_dist / d );
2437                         }
2438
2439                         // Cap arc 2->3
2440                         vm_vec_sub( &tmp, &v3, &v2 );
2441                         d = vm_vec_mag_quick( &tmp );
2442                         if ( d > max_dist )     {
2443                                 vm_vec_scale_add( &v3, &v2, &tmp, max_dist / d );
2444                         }
2445
2446
2447                         // Cap arc 2->4
2448                         vm_vec_sub( &tmp, &v4, &v2 );
2449                         d = vm_vec_mag_quick( &tmp );
2450                         if ( d > max_dist )     {
2451                                 vm_vec_scale_add( &v4, &v2, &tmp, max_dist / d );
2452                         }
2453
2454                 }
2455
2456                 n = 0;
2457
2458 //              int a = 100, b = 1000;
2459                 float factor = 1.0f + 0.0025f*obj->radius;
2460                 int a = (int) (factor*100.0f);
2461                 int b = (int) (factor*1000.0f);
2462                 int lifetime = (myrand()%((b)-(a)+1))+(a);
2463
2464                 // Create the arc effects
2465                 for (i=0; i<MAX_SHIP_ARCS; i++ )        {
2466                         if ( !timestamp_valid( shipp->arc_timestamp[i] ) )      {
2467                                 //shipp->arc_timestamp[i] = timestamp_rand(400,1000);   // live up to a second
2468                                 shipp->arc_timestamp[i] = timestamp(lifetime);  // live up to a second
2469
2470                                 switch( n )     {
2471                                 case 0:
2472                                         shipp->arc_pts[i][0] = v1;
2473                                         shipp->arc_pts[i][1] = v2;
2474                                         break;
2475                                 case 1:
2476                                         shipp->arc_pts[i][0] = v2;
2477                                         shipp->arc_pts[i][1] = v3;
2478                                         break;
2479
2480                                 case 2:
2481                                         shipp->arc_pts[i][0] = v2;
2482                                         shipp->arc_pts[i][1] = v4;
2483                                         break;
2484
2485                                 default:
2486                                         Int3();
2487                                 }
2488
2489                                 // determine what kind of arc to create
2490                                 if(shipp->emp_intensity > 0.0f){
2491                                         shipp->arc_type[i] = MARC_TYPE_EMP;
2492                                 } else {
2493                                         shipp->arc_type[i] = MARC_TYPE_NORMAL;
2494                                 }
2495
2496                                 n++;
2497                                 if ( n == n_arcs )
2498                                         break;  // Don't need to create anymore
2499                         }
2500
2501                         // rotate v2 out of local coordinates into world.
2502                         // Use v2 since it is used in every bolt.  See above switch().
2503                         vector snd_pos;
2504                         vm_vec_unrotate(&snd_pos, &v2, &obj->orient);
2505                         vm_vec_add2(&snd_pos, &obj->pos );
2506
2507                         //Play a sound effect
2508                         if ( lifetime > 750 )   {
2509                                 // 1.00 second effect
2510                                 snd_play_3d( &Snds[SND_DEBRIS_ARC_05], &snd_pos, &View_position, obj->radius );
2511                         } else if ( lifetime >  500 )   {
2512                                 // 0.75 second effect
2513                                 snd_play_3d( &Snds[SND_DEBRIS_ARC_04], &snd_pos, &View_position, obj->radius );
2514                         } else if ( lifetime >  250 )   {
2515                                 // 0.50 second effect
2516                                 snd_play_3d( &Snds[SND_DEBRIS_ARC_03], &snd_pos, &View_position, obj->radius );
2517                         } else if ( lifetime >  100 )   {
2518                                 // 0.25 second effect
2519                                 snd_play_3d( &Snds[SND_DEBRIS_ARC_02], &snd_pos, &View_position, obj->radius );
2520                         } else {
2521                                 // 0.10 second effect
2522                                 snd_play_3d( &Snds[SND_DEBRIS_ARC_01], &snd_pos, &View_position, obj->radius );
2523                         }
2524                 }
2525         }
2526
2527         // maybe move arc points around
2528         for (i=0; i<MAX_SHIP_ARCS; i++ )        {
2529                 if ( timestamp_valid( shipp->arc_timestamp[i] ) )       {
2530                         if ( !timestamp_elapsed( shipp->arc_timestamp[i] ) )    {
2531                                 // Maybe move a vertex....  20% of the time maybe?
2532                                 int mr = myrand();
2533                                 if ( mr < RAND_MAX/5 )  {
2534                                         vector v1, v2;
2535                                         submodel_get_two_random_points( shipp->modelnum, -1, &v1, &v2 );
2536
2537                                         vector static_one;
2538
2539                                         if ( mr % 2 )   {
2540                                                 static_one = shipp->arc_pts[i][0];
2541                                         } else {
2542                                                 static_one = shipp->arc_pts[i][1];
2543                                         }
2544
2545                                         // For large ships, cap the length to be 25% of max radius
2546                                         if ( obj->radius > 200.0f )     {
2547                                                 float max_dist = obj->radius * MAX_ARC_LENGTH_PERCENTAGE;
2548
2549                                                 vector tmp;
2550                                                 float d;
2551
2552                                                 // Cap arc 2->1
2553                                                 vm_vec_sub( &tmp, &v1, &static_one );
2554                                                 d = vm_vec_mag_quick( &tmp );
2555                                                 if ( d > max_dist )     {
2556                                                         vm_vec_scale_add( &v1, &static_one, &tmp, max_dist / d );
2557                                                 }
2558                                         }
2559
2560                                         shipp->arc_pts[i][mr % 2] = v1;
2561                                 }
2562                         }
2563                 }
2564         }
2565 }
2566
2567 int l_cruiser_count = 1;
2568 int l_big_count = 2;
2569 int l_huge_count = 3;
2570 float l_max_radius = 3000.0f;
2571 void shipfx_do_lightning_frame( ship *shipp )
2572 {
2573         /*
2574         ship_info *sip;
2575         object *objp;
2576         int stamp, count;
2577         vector v1, v2, n1, n2, temp, temp2;
2578         bolt_info binfo;
2579
2580         // sanity checks
2581         Assert(shipp != NULL);
2582         if(shipp == NULL){
2583                 return;
2584         }
2585         Assert(shipp->ship_info_index >= 0);
2586         if(shipp->ship_info_index < 0){
2587                 return;
2588         }
2589         Assert(shipp->objnum >= 0);
2590         if(shipp->objnum < 0){
2591                 return;
2592         }
2593
2594         // get some pointers
2595         sip = &Ship_info[shipp->ship_info_index];
2596         objp = &Objects[shipp->objnum];
2597
2598         // if this is not a nebula mission, don't do anything
2599         if(!(The_mission.flags & MISSION_FLAG_FULLNEB)){
2600                 shipp->lightning_stamp = -1;
2601                 return;
2602         }
2603
2604         // if this not a cruiser or big ship
2605         if(!((sip->flags & SIF_CRUISER) || (sip->flags & SIF_BIG_SHIP) || (sip->flags & SIF_HUGE_SHIP))){
2606                 shipp->lightning_stamp = -1;
2607                 return;
2608         }
2609
2610         // determine stamp and count values
2611         if(sip->flags & SIF_CRUISER){
2612                 stamp = (int)((float)(Nebl_cruiser_min + ((Nebl_cruiser_max - Nebl_cruiser_min) * Nebl_intensity)) * frand_range(0.8f, 1.1f));
2613                 count = l_cruiser_count;
2614         }
2615         else {
2616                 if(sip->flags & SIF_HUGE_SHIP){
2617                         stamp = (int)((float)(Nebl_supercap_min + ((Nebl_supercap_max - Nebl_supercap_min) * Nebl_intensity)) * frand_range(0.8f, 1.1f));
2618                         count = l_huge_count;
2619                 } else {
2620                         stamp = (int)((float)(Nebl_cap_min + ((Nebl_cap_max - Nebl_cap_min) * Nebl_intensity)) * frand_range(0.8f, 1.1f));
2621                         count = l_big_count;
2622                 }
2623         }
2624
2625         // if his timestamp is unset
2626         if(shipp->lightning_stamp == -1){
2627                 shipp->lightning_stamp = timestamp(stamp);
2628                 return;
2629         }
2630         // if his timestamp is currently unelapsed
2631         if(!timestamp_elapsed(shipp->lightning_stamp)){
2632                 return;
2633         }
2634
2635         mprintf(("SHIP BOLT\n"));
2636
2637         // restamp him first
2638         shipp->lightning_stamp = timestamp(stamp);
2639
2640         // ah, now we can create some lightning bolts
2641         count = (int)frand_range(0.0f, (float)count);
2642         while(count > 0){
2643                 // get 2 points on the hull of the ship
2644                 submodel_get_two_random_points(shipp->modelnum, 0, &v1, &v2, &n1, &n2);
2645
2646                 // make up to 2 bolts
2647                 if(objp->radius > l_max_radius){
2648                         vm_vec_scale_add(&temp2, &v1, &n1, l_max_radius);
2649                 } else {
2650                         vm_vec_scale_add(&temp2, &v1, &n1, objp->radius);
2651                 }
2652                 vm_vec_unrotate(&temp, &temp2, &objp->orient);
2653                 vm_vec_add2(&temp, &objp->pos);
2654                 vm_vec_unrotate(&temp2, &v1, &objp->orient);
2655                 vm_vec_add2(&temp2, &objp->pos);
2656
2657                 // create the bolt
2658                 binfo.start = temp;
2659                 binfo.strike = temp2;
2660                 binfo.num_strikes = 3;
2661                 binfo.noise = 0.045f;
2662                 binfo.life = 375;
2663                 binfo.delay = (int)frand_range(0.0f, 1600.0f);
2664                 nebl_bolt(&binfo);
2665                 count--;
2666
2667                 // done
2668                 if(count <= 0){
2669                         break;
2670                 }
2671
2672                 // one more
2673                 if(objp->radius > l_max_radius){
2674                         vm_vec_scale_add(&temp2, &v2, &n2, l_max_radius);
2675                 } else {
2676                         vm_vec_scale_add(&temp2, &v2, &n2, objp->radius);
2677                 }
2678                 vm_vec_unrotate(&temp, &temp2, &objp->orient);
2679                 vm_vec_add2(&temp, &objp->pos);
2680                 vm_vec_unrotate(&temp2, &v2, &objp->orient);
2681                 vm_vec_add2(&temp2, &objp->pos);
2682
2683                 // create the bolt
2684                 binfo.start = temp;
2685                 binfo.strike = temp2;
2686                 binfo.num_strikes = 3;
2687                 binfo.noise = 0.045f;
2688                 binfo.life = 375;
2689                 binfo.delay = (int)frand_range(0.0f, 1600.0f);
2690                 nebl_bolt(&binfo);
2691                 count--;
2692         }
2693         */
2694 }
2695
2696 // do all shockwaves for a ship blowing up
2697 void shipfx_do_shockwave_stuff(ship *shipp, shockwave_create_info *sci)
2698 {
2699         ship_info *sip;
2700         object *objp;
2701         polymodel *pm;
2702         vector temp, dir, shockwave_pos;
2703         vector head = vmd_zero_vector;
2704         vector tail = vmd_zero_vector;
2705         float len, step, cur;
2706         int idx;
2707
2708         // sanity checks
2709         Assert(shipp != NULL);
2710         if(shipp == NULL){
2711                 return;
2712         }
2713         Assert(shipp->ship_info_index >= 0);
2714         if(shipp->ship_info_index < 0){
2715                 return;
2716         }
2717         Assert(shipp->objnum >= 0);
2718         if(shipp->objnum < 0){
2719                 return;
2720         }
2721         Assert(sci != NULL);
2722         if (sci == NULL) {
2723                 return;
2724         }
2725
2726         // get some pointers
2727         sip = &Ship_info[shipp->ship_info_index];
2728         objp = &Objects[shipp->objnum];
2729
2730         Assert(sip->shockwave_count > 0);
2731         if(sip->shockwave_count <= 0){
2732                 return;
2733         }
2734
2735         // get vectors at the head and tail of the object, dead center
2736         pm = model_get(shipp->modelnum);
2737         if(pm == NULL){
2738                 return;
2739         }
2740         head.xyz.x = pm->submodel[0].offset.xyz.x;
2741         head.xyz.y = pm->submodel[0].offset.xyz.y;
2742         head.xyz.z = pm->maxs.xyz.z;
2743
2744         tail.xyz.x = pm->submodel[0].offset.xyz.x;
2745         tail.xyz.y = pm->submodel[0].offset.xyz.y;
2746         tail.xyz.z = pm->mins.xyz.z;
2747
2748         // transform the vectors into world coords
2749         vm_vec_unrotate(&temp, &head, &objp->orient);
2750         vm_vec_add(&head, &temp, &objp->pos);
2751         vm_vec_unrotate(&temp, &tail, &objp->orient);
2752         vm_vec_add(&tail, &temp, &objp->pos);
2753
2754         // now create as many shockwaves as needed
2755         vm_vec_sub(&dir, &head, &tail);
2756         len = vm_vec_mag(&dir);
2757         step = 1.0f / ((float)sip->shockwave_count + 1.0f);
2758         cur = step;
2759         for(idx=0; idx<sip->shockwave_count; idx++){
2760                 // get the shockwave position
2761                 temp = dir;
2762                 vm_vec_scale(&temp, cur);
2763                 vm_vec_add(&shockwave_pos, &tail, &temp);
2764
2765                 // if knossos device, make shockwave in center
2766                 if (Ship_info[shipp->ship_info_index].flags & SIF_KNOSSOS_DEVICE) {
2767                         shockwave_pos = Objects[shipp->objnum].pos;
2768                 }
2769
2770                 // create the shockwave
2771                 shockwave_create_info sci2;
2772                 sci2.blast = (sci->blast / (float)sip->shockwave_count) * frand_range(0.75f, 1.25f);
2773                 sci2.damage = (sci->damage / (float)sip->shockwave_count) * frand_range(0.75f, 1.25f);
2774                 sci2.inner_rad = sci->inner_rad;
2775                 sci2.outer_rad = sci->outer_rad;
2776                 sci2.speed = sci->speed * frand_range(0.75f, 1.25f);
2777                 sci2.rot_angle = frand_range(0.0f, 359.0f);
2778
2779                 shockwave_create(shipp->objnum, &shockwave_pos, &sci2, SW_SHIP_DEATH, (int)frand_range(0.0f, 350.0f));
2780                 // shockwave_create(shipp->objnum, &objp->pos, sip->shockwave_speed, sip->inner_rad, sip->outer_rad, sip->damage, sip->blast, SW_SHIP_DEATH);
2781
2782                 // next shockwave
2783                 cur += step;
2784         }
2785 }
2786
2787 int Wash_on = 1;
2788 DCF_BOOL(engine_wash, Wash_on);
2789 #define ENGINE_WASH_CHECK_INTERVAL              250     // (4x sec)
2790 // Do engine wash effect for ship
2791 // Assumes length of engine wash is greater than radius of engine wash hemisphere
2792 void engine_wash_ship_process(ship *shipp)
2793 {
2794         int idx, j;
2795         object *objp, *ship_objp, *max_ship_intensity_objp;
2796         int started_with_no_wash = shipp->wash_intensity <= 0 ? 1 : 0;
2797
2798         if (!Wash_on) {
2799                 return;
2800         }
2801
2802         Assert(shipp != NULL);
2803         Assert(shipp->objnum >= 0);
2804         objp = &Objects[shipp->objnum];
2805         ship_obj *so;
2806         ship_objp = NULL;
2807
2808         vector world_thruster_pos, world_thruster_norm, apex, thruster_to_ship, apex_to_ship, temp;
2809         float dist_sqr, inset_depth, dot_to_ship, max_ship_intensity;
2810         polymodel *pm;
2811
2812         float max_wash_dist, half_angle, radius_mult;
2813
2814         // if this is not a fighter or bomber, we don't care
2815         if ((objp->type != OBJ_SHIP) || !(Ship_info[shipp->ship_info_index].flags & (SIF_FIGHTER|SIF_BOMBER)) ) {
2816                 return;
2817         }
2818
2819         // is it time to check for engine wash
2820         int time_to_next_hit = timestamp_until(shipp->wash_timestamp);
2821         if (time_to_next_hit < 0) {
2822                 if (time_to_next_hit < -ENGINE_WASH_CHECK_INTERVAL) {
2823                         time_to_next_hit = 0;
2824                 }
2825
2826                 // keep interval constant independent of framerate
2827                 shipp->wash_timestamp = timestamp(ENGINE_WASH_CHECK_INTERVAL + time_to_next_hit);
2828
2829                 // initialize wash params
2830                 shipp->wash_intensity = 0.0f;
2831                 vm_vec_zero(&shipp->wash_rot_axis);
2832                 max_ship_intensity_objp = NULL;
2833                 max_ship_intensity = 0;
2834         } else {
2835                 return;
2836         }
2837
2838         // only do damage if we're within half of the max wash distance
2839         int do_damage = 0;
2840
2841         // go thru Ship_used_list and check if we're in wash from CAP or SUPERCAP (SIF_HUGE)
2842         for (so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so)) {
2843                 ship_objp = &Objects[so->objnum];
2844
2845                 // don't do small ships
2846                 if ( (Ship_info[Ships[ship_objp->instance].ship_info_index].flags & SIF_SMALL_SHIP) ) {
2847                         continue;
2848                 }
2849
2850                 pm = model_get(Ships[ship_objp->instance].modelnum);
2851                 float ship_intensity = 0;
2852
2853                 // if engines disabled, no engine wash
2854                 if (ship_get_subsystem_strength(&Ships[ship_objp->instance], SUBSYSTEM_ENGINE) < 0.01) {
2855                         continue;
2856                 }
2857
2858                 float   speed_scale;
2859                 if (ship_objp->phys_info.speed > 20.0f)
2860                         speed_scale = 1.0f;
2861                 else
2862                         speed_scale = ship_objp->phys_info.speed/20.0f;
2863
2864                 for (idx = 0; idx < pm->n_thrusters; idx++) {
2865                         thruster_bank *bank = &pm->thrusters[idx];
2866
2867                         // check if thruster bank has engine wash
2868                         if (bank->wash_info_index < 0) {
2869                                 // if huge, give default engine wash
2870                                 if (Ship_info[Ships[ship_objp->instance].ship_info_index].flags & SIF_HUGE_SHIP) {
2871                                         bank->wash_info_index = 0;
2872                                         nprintf(("wash", "Adding default engine wash to ship %s", Ship_info[Ships[ship_objp->instance].ship_info_index].name));
2873                                 } else {
2874                                         continue;
2875                                 }
2876                         }
2877
2878                         engine_wash_info *ewp = &Engine_wash_info[(int)bank->wash_info_index];
2879                         half_angle = ewp->angle;
2880                         radius_mult = ewp->radius_mult;
2881
2882                         for (j=0; j<bank->num_slots; j++) {
2883                                 // get world pos of thruster
2884                                 vm_vec_unrotate(&world_thruster_pos, &bank->pnt[j], &ship_objp->orient);
2885                                 vm_vec_add2(&world_thruster_pos, &ship_objp->pos);
2886
2887                                 // get world norm of thruster;
2888                                 vm_vec_unrotate(&world_thruster_norm, &bank->norm[j], &ship_objp->orient);
2889
2890                                 // get vector from thruster to ship
2891                                 vm_vec_sub(&thruster_to_ship, &objp->pos, &world_thruster_pos);
2892
2893                                 // check if on back side of thruster
2894                                 dot_to_ship = vm_vec_dotprod(&thruster_to_ship, &world_thruster_norm);
2895                                 if (dot_to_ship > 0) {
2896
2897                                         // get max wash distance
2898                                         max_wash_dist = max(ewp->length, bank->radius[j]*ewp->radius_mult);
2899
2900                                         // check if within dist range
2901                                         dist_sqr = vm_vec_mag_squared(&thruster_to_ship);
2902                                         if (dist_sqr < max_wash_dist*max_wash_dist) {
2903
2904                                                 // check if inside the sphere
2905                                                 if (dist_sqr < radius_mult*radius_mult*bank->radius[j]*bank->radius[j]) {
2906                                                         vm_vec_crossprod(&temp, &world_thruster_norm, &thruster_to_ship);
2907                                                         vm_vec_scale_add2(&shipp->wash_rot_axis, &temp, dot_to_ship / dist_sqr);
2908 //                                                      shipp->wash_intensity += (1.0f - dist_sqr / (max_wash_dist*max_wash_dist));
2909                                                         ship_intensity += (1.0f - dist_sqr / (max_wash_dist*max_wash_dist));
2910                                                         if (!do_damage) {
2911                                                                 if (dist_sqr < 0.25 * max_wash_dist * max_wash_dist) {
2912                                                                         do_damage = 1;
2913                                                                 }
2914                                                         }
2915                                                 } else {
2916                                                         // check if inside cone - first fine apex of cone
2917                                                         inset_depth = float(bank->radius[j] / tan(half_angle));
2918                                                         vm_vec_scale_add(&apex, &world_thruster_pos, &world_thruster_norm, -inset_depth);
2919                                                         vm_vec_sub(&apex_to_ship, &objp->pos, &apex);
2920                                                         vm_vec_normalize(&apex_to_ship);
2921
2922                                                         // check if inside cone angle
2923                                                         if (vm_vec_dotprod(&apex_to_ship, &world_thruster_norm) > cos(half_angle)) {
2924                                                                 vm_vec_crossprod(&temp, &world_thruster_norm, &thruster_to_ship);
2925                                                                 vm_vec_scale_add2(&shipp->wash_rot_axis, &temp, dot_to_ship / dist_sqr);
2926 //                                                              shipp->wash_intensity += (1.0f - dist_sqr / (max_wash_dist*max_wash_dist));
2927                                                                 ship_intensity += (1.0f - dist_sqr / (max_wash_dist*max_wash_dist));
2928                                                                 if (!do_damage) {
2929                                                                         if (dist_sqr < 0.25 * max_wash_dist * max_wash_dist) {
2930                                                                                 do_damage = 1;
2931                                                                         }
2932                                                                 }
2933                                                         }
2934                                                 }
2935                                         }
2936                                 }
2937                         }
2938                 }
2939                 shipp->wash_intensity += ship_intensity * speed_scale;
2940                 if (ship_intensity > max_ship_intensity) {
2941                         max_ship_intensity = ship_intensity;
2942                         max_ship_intensity_objp = ship_objp;
2943                 }
2944         }
2945
2946         // apply damage at rate of 1%/sec
2947         if (shipp->wash_intensity > 0) {
2948                 Assert(max_ship_intensity_objp != NULL);
2949
2950                 nprintf(("wash", "Wash intensity %.2f\n", shipp->wash_intensity));
2951
2952                 float damage;
2953                 if (!do_damage) {
2954                         damage = 0;
2955                 } else {
2956                         damage = (0.001f * 0.003f * ENGINE_WASH_CHECK_INTERVAL * Ship_info[shipp->ship_info_index].initial_hull_strength * shipp->wash_intensity);
2957                 }
2958
2959                 ship_apply_wash_damage(&Objects[shipp->objnum], max_ship_intensity_objp, damage);
2960
2961                 // if we had no wash before now, add the wash object sound
2962                 if(started_with_no_wash){
2963                         if(shipp != Player_ship){
2964                                 obj_snd_assign(shipp->objnum, SND_ENGINE_WASH, &vmd_zero_vector, 1);
2965                         } else {
2966                                 Player_engine_wash_loop = snd_play_looping( &Snds[SND_ENGINE_WASH], 0.0f , -1, -1, 1.0f);
2967                         }
2968                 }
2969         }
2970         // if we've got no wash, kill any wash object sounds from this guy
2971         else {
2972                 if(shipp != Player_ship){
2973                         obj_snd_delete(shipp->objnum, SND_ENGINE_WASH);
2974                 } else {
2975                         snd_stop(Player_engine_wash_loop);
2976                         Player_engine_wash_loop = -1;
2977                 }
2978         }
2979 }
2980
2981 // engine wash level init
2982 void shipfx_engine_wash_level_init()
2983 {
2984         Player_engine_wash_loop = -1;
2985 }
2986
2987 // pause engine wash sounds
2988 void shipfx_stop_engine_wash_sound()
2989 {
2990         if(Player_engine_wash_loop != -1){
2991                 snd_stop(Player_engine_wash_loop);
2992                 Player_engine_wash_loop = -1;
2993         }
2994 }