2 * Copyright (C) Volition, Inc. 1999. All rights reserved.
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
10 * $Logfile: /Freespace2/code/Ship/Ship.cpp $
15 * Ship (and other object) handling functions
18 * Revision 1.10 2006/04/26 19:47:57 taylor
19 * FS1 keeps single-database and multi-database techroom entries separate so do it here too
21 * Revision 1.9 2004/09/20 01:31:44 theoddone33
24 * Revision 1.8 2004/07/04 11:39:06 taylor
25 * fix missing debrief text, crash on exit, path separator's, warning fixes, no GR_SOFT
27 * Revision 1.7 2003/06/11 18:30:33 taylor
30 * Revision 1.6 2003/05/25 02:30:44 taylor
33 * Revision 1.5 2002/06/17 06:33:11 relnev
34 * ryan's struct patch for gcc 2.95
36 * Revision 1.4 2002/06/09 04:41:26 relnev
37 * added copyright header
39 * Revision 1.3 2002/06/02 00:31:36 relnev
40 * implemented osregistry
42 * Revision 1.2 2002/05/03 13:34:34 theoddone33
45 * Revision 1.1.1.1 2002/05/03 03:28:10 root
49 * 144 10/13/99 3:43p Jefff
50 * fixed unnumbered XSTRs
52 * 143 9/14/99 3:26a Dave
53 * Fixed laser fogging problem in nebula (D3D)> Fixed multiplayer
54 * respawn-too-early problem. Made a few crash points safe.
56 * 142 9/11/99 4:02p Dave
57 * Don't page in model textures when doing ship_model_change() in fred.
59 * 141 9/10/99 9:44p Dave
60 * Bumped version # up. Make server reliable connects not have such a huge
63 * 140 9/06/99 3:30p Mikek
64 * Added system to restrict weapon choices for dogfight missions.
66 * 139 9/01/99 10:15a Dave
68 * 138 9/01/99 8:43a Andsager
69 * supress WARNING from no_fred ships flag
71 * 137 8/26/99 8:52p Dave
72 * Gave multiplayer TvT messaging a heavy dose of sanity. Cheat codes.
74 * 136 8/26/99 6:08p Andsager
75 * Add debug code for lethality and number of turrets targeting player.
77 * 135 8/26/99 5:14p Andsager
79 * 134 8/26/99 9:45a Dave
80 * First pass at easter eggs and cheats.
82 * 133 8/24/99 4:25p Andsager
83 * Add ship-vanish sexp
85 * 132 8/23/99 11:59a Andsager
86 * Force choice of big fireball when Knossos destroyed. Allow logging of
87 * ship destroyed when no killer_name (ie, from debug).
89 * 131 8/23/99 11:09a Andsager
90 * Round 2 of Knossos explosion
92 * 130 8/20/99 5:09p Andsager
93 * Second pass on Knossos device explosion
95 * 129 8/18/99 10:59p Andsager
96 * Enable "b" key to target bombers.
98 * 128 8/18/99 12:09p Andsager
99 * Add debug if message has no anim for message. Make messages come from
102 * 127 8/16/99 10:04p Andsager
103 * Add special-warp-dist and special-warpout-name sexp for Knossos device
106 * 126 8/16/99 4:06p Dave
107 * Big honking checkin.
109 * 125 8/16/99 2:01p Andsager
110 * Knossos warp-in warp-out.
112 * 124 8/13/99 10:49a Andsager
113 * Knossos and HUGE ship warp out. HUGE ship warp in. Stealth search
114 * modes dont collide big ships.
116 * 123 8/05/99 6:19p Dave
117 * New demo checksums.
119 * 122 8/05/99 12:57a Andsager
120 * the insanity of it all!
122 * 121 8/03/99 11:13a Andsager
123 * Bump up number of ship_subsystems for demo
125 * 120 8/02/99 10:39p Dave
126 * Added colored shields. OoOoOoooOoo
128 * 119 7/29/99 10:47p Dave
129 * Standardized D3D fogging using vertex fog. Shook out Savage 4 bugs.
131 * 118 7/29/99 12:05a Dave
132 * Nebula speed optimizations.
134 * 117 7/28/99 1:36p Andsager
135 * Modify cargo1 to include flag CARGO_NO_DEPLETE. Add sexp
136 * cargo-no-deplete (only for BIG / HUGE). Modify ship struct to pack
139 * 116 7/26/99 5:50p Dave
140 * Revised ingame join. Better? We'll see....
142 * 115 7/26/99 8:06a Andsager
143 * Consistent personas
145 * 114 7/24/99 5:22p Jefff
146 * Removed debug rendering of interpolated ships in multiplayer.
148 * 113 7/19/99 8:57p Andsager
149 * Added Ship_exited red_alert_carry flag and hull strength for RED ALERT
150 * carry over of Exited_ships
152 * 112 7/19/99 7:20p Dave
153 * Beam tooling. Specialized player-killed-self messages. Fixed d3d nebula
156 * 111 7/19/99 12:02p Andsager
157 * Allow AWACS on any ship subsystem. Fix sexp_set_subsystem_strength to
158 * only blow up subsystem if its strength is > 0
160 * 110 7/18/99 9:56p Andsager
161 * Make max_ship_subsys 300 again!
163 * 109 7/18/99 5:20p Dave
164 * Jump node icon. Fixed debris fogging. Framerate warning stuff.
166 * 108 7/18/99 12:32p Dave
167 * Randomly oriented shockwaves.
169 * 107 7/15/99 6:36p Jamesa
170 * Moved default ship name into the ships.tbl
172 * 104 7/15/99 9:20a Andsager
173 * FS2_DEMO initial checkin
175 * 103 7/13/99 5:03p Alanl
176 * make sure object sounds get assigned to ships
178 * 102 7/09/99 5:54p Dave
179 * Seperated cruiser types into individual types. Added tons of new
180 * briefing icons. Campaign screen.
182 * 101 7/08/99 5:49p Andsager
183 * Fixed bug colliding with just warped in Cap ship
185 * 100 7/08/99 10:53a Dave
186 * New multiplayer interpolation scheme. Not 100% done yet, but still
187 * better than the old way.
189 * 99 7/06/99 4:24p Dave
190 * Mid-level checkin. Starting on some potentially cool multiplayer
193 * 98 7/06/99 10:45a Andsager
194 * Modify engine wash to work on any ship that is not small. Add AWACS
197 * 97 7/01/99 4:23p Dave
198 * Full support for multiple linked ambient engine sounds. Added "big
201 * 96 7/01/99 11:44a Dave
202 * Updated object sound system to allow multiple obj sounds per ship.
203 * Added hit-by-beam sound. Added killed by beam sound.
205 * 95 6/30/99 5:53p Dave
206 * Put in new anti-camper code.
208 * 94 6/20/99 12:06a Alanl
209 * new event music changes
211 * 93 6/16/99 4:06p Dave
212 * New pilot info popup. Added new draw-bitmap-as-poly function.
214 * 92 6/16/99 10:21a Dave
215 * Added send-message-list sexpression.
217 * 91 6/14/99 3:21p Andsager
218 * Allow collisions between ship and its debris. Fix up collision pairs
219 * when large ship is warping out.
221 * 90 6/10/99 3:43p Dave
222 * Do a better job of syncing text colors to HUD gauges.
224 * 89 6/07/99 4:21p Andsager
225 * Add HUD color for tagged object. Apply to target and radar.
227 * 88 6/04/99 5:08p Andsager
228 * Sort of hack to allow minicap and supercap tat the same time.
230 * 87 6/03/99 9:29p Andsager
231 * Remove special case for Asteroid ship LOD warning
233 * 86 6/03/99 11:43a Dave
234 * Added the ability to use a different model when rendering to the HUD
237 * 85 6/01/99 8:35p Dave
238 * Finished lockarm weapons. Added proper supercap weapons/damage. Added
239 * awacs-set-radius sexpression.
241 * 84 5/28/99 9:26a Andsager
242 * Added check_world_pt_in_expanded_ship_bbox() function
244 * 83 5/26/99 4:00p Dave
245 * Fixed small lighting bug,
247 * 82 5/26/99 11:46a Dave
248 * Added ship-blasting lighting and made the randomization of lighting
249 * much more customizable.
251 * 81 5/24/99 5:45p Dave
252 * Added detail levels to the nebula, with a decent speedup. Split nebula
253 * lightning into its own section.
255 * 80 5/21/99 5:03p Andsager
256 * Add code to display engine wash death. Modify ship_kill_packet
258 * 79 5/20/99 7:00p Dave
259 * Added alternate type names for ships. Changed swarm missile table
262 * 78 5/19/99 11:09a Andsager
263 * Turn on engine wash. Check every 1/4 sec.
265 * 77 5/18/99 1:30p Dave
266 * Added muzzle flash table stuff.
268 * 76 5/18/99 12:08p Andsager
269 * Added observer_process_post to handle observer too far away
271 * 75 5/18/99 11:15a Andsager
272 * Fix bug in mulitplayer max rangel
274 * 74 5/18/99 10:08a Andsager
275 * Modified single maximum range before blown up to also be multi
278 * 73 5/14/99 3:01p Andsager
279 * Fix bug in ship_do_cap_subsys_cargo_revealed
281 * 72 5/14/99 1:59p Andsager
282 * Multiplayer message for subsystem cargo revealed.
284 * 71 5/14/99 11:50a Andsager
285 * Added vaporize for SMALL ships hit by HUGE beams. Modified dying
286 * frame. Enlarged debris shards and range at which visible.
288 * 70 5/12/99 2:55p Andsager
289 * Implemented level 2 tag as priority in turret object selection
291 * 69 5/11/99 10:16p Andsager
292 * First pass on engine wash effect. Rotation (control input), damage,
295 * 68 5/10/99 4:54p Dave
296 * Fixed particularly hideous subsystem bug related to multiple ship types
297 * using the same model.
299 * 67 4/30/99 12:18p Dave
300 * Several minor bug fixes.
302 * 66 4/29/99 2:29p Dave
303 * Made flak work much better in multiplayer.
305 * 65 4/28/99 11:13p Dave
306 * Temporary checkin of artillery code.
308 * 64 4/28/99 3:11p Andsager
309 * Stagger turret weapon fire times. Make turrets smarter when target is
310 * protected or beam protected. Add weaopn range to weapon info struct.
312 * 63 4/27/99 12:16a Dave
313 * Fixed beam weapon muzzle glow problem. Fixed premature timeout on the
314 * pxo server list screen. Fixed secondary firing for hosts on a
315 * standalone. Fixed wacky multiplayer weapon "shuddering" problem.
317 * 62 4/23/99 12:30p Andsager
318 * Add debug code for showing attack point against big ships.
320 * 61 4/23/99 12:01p Johnson
321 * Added SIF_HUGE_SHIP
323 * 60 4/20/99 6:39p Dave
324 * Almost done with artillery targeting. Added support for downloading
325 * images on the PXO screen.
327 * 59 4/19/99 11:01p Dave
328 * More sophisticated targeting laser support. Temporary checkin.
330 * 58 4/19/99 12:21p Johnson
331 * Allow ships with invisible polygons which do not collide
333 * 57 4/16/99 5:54p Dave
334 * Support for on/off style "stream" weapons. Real early support for
335 * target-painting lasers.
337 * 56 4/12/99 10:07p Dave
338 * Made network startup more forgiving. Added checkmarks to dogfight
339 * screen for players who hit commit.
341 * 55 4/02/99 9:55a Dave
342 * Added a few more options in the weapons.tbl for beam weapons. Attempt
343 * at putting "pain" packets into multiplayer.
345 * 54 3/31/99 8:24p Dave
346 * Beefed up all kinds of stuff, incluging beam weapons, nebula effects
347 * and background nebulae. Added per-ship non-dimming pixel colors.
349 * 53 3/30/99 5:40p Dave
350 * Fixed reinforcements for TvT in multiplayer.
352 * 52 3/29/99 6:17p Dave
353 * More work on demo system. Got just about everything in except for
354 * blowing ships up, secondary weapons and player death/warpout.
356 * 51 3/28/99 5:58p Dave
357 * Added early demo code. Make objects move. Nice and framerate
358 * independant, but not much else. Don't use yet unless you're me :)
360 * 50 3/26/99 5:23p Andsager
361 * Fix bug with special explostions sometimes not generating shockwaves.
363 * 49 3/26/99 4:49p Dave
364 * Made cruisers able to dock with stuff. Made docking points and paths
367 * 48 3/25/99 4:47p Johnson
368 * HACK allow Mycernus to dock with Enif
370 * 47 3/25/99 2:38p Johnson
371 * Give brad special mission docking stuff
373 * 46 3/25/99 1:30p Johnson
374 * Allow Arcadia/Mentu docking
376 * 45 3/24/99 4:05p Dave
377 * Put in support for assigning the player to a specific squadron with a
378 * specific logo. Preliminary work for doing pos/orient checksumming in
379 * multiplayer to reduce bandwidth.
381 * 44 3/23/99 2:29p Andsager
382 * Fix shockwaves for kamikazi and Fred defined. Collect together
383 * shockwave_create_info struct.
385 * 43 3/20/99 3:46p Dave
386 * Added support for model-based background nebulae. Added 3 new
389 * 42 3/19/99 9:51a Dave
390 * Checkin to repair massive source safe crash. Also added support for
391 * pof-style nebulae, and some new weapons code.
393 * 43 3/12/99 4:30p Anoop
394 * Check for OBJ_NONE as well as OBJ_GHOST when firing secondary weapons
396 * 42 3/11/99 2:22p Dave
397 * Fixed a countermeasure firing assert for multiplayer.
399 * 41 3/10/99 6:51p Dave
400 * Changed the way we buffer packets for all clients. Optimized turret
401 * fired packets. Did some weapon firing optimizations.
403 * 40 3/10/99 2:29p Dan
404 * disable lod warning for asteroid ships
406 * 39 3/09/99 6:24p Dave
407 * More work on object update revamping. Identified several sources of
408 * unnecessary bandwidth.
410 * 38 3/08/99 7:03p Dave
411 * First run of new object update system. Looks very promising.
413 * 37 3/05/99 1:33p Dave
414 * Upped subsystem max to 700
416 * 36 3/04/99 6:09p Dave
417 * Added in sexpressions for firing beams and checking for if a ship is
420 * 35 3/02/99 9:25p Dave
421 * Added a bunch of model rendering debug code. Started work on fixing
422 * beam weapon wacky firing.
424 * 34 3/01/99 7:39p Dave
425 * Added prioritizing ship respawns. Also fixed respawns in TvT so teams
426 * don't mix respawn points.
428 * 33 2/26/99 6:01p Andsager
429 * Add sexp has-been-tagged-delay and cap-subsys-cargo-known-delay
431 * 32 2/26/99 4:14p Dave
432 * Put in the ability to have multiple shockwaves for ships.
434 * 31 2/21/99 1:48p Dave
435 * Some code for monitoring datarate for multiplayer in detail.
437 * 30 2/19/99 3:52p Neilk
438 * Put in some proper handling code for undocking dying objects (handle
439 * wacky object types like OBJ_GHOST).
441 * 29 2/11/99 5:22p Andsager
442 * Fixed bugs, generalized block Sexp_variables
444 * 28 2/11/99 2:15p Andsager
445 * Add ship explosion modification to FRED
447 * 27 2/05/99 12:52p Dave
448 * Fixed Glide nondarkening textures.
450 * 26 2/03/99 12:42p Andsager
451 * Add escort priority. Modify ship_flags_dlg to include field. Save and
452 * Load. Add escort priority field to ship.
454 * 25 2/02/99 9:36a Andsager
455 * Bash hull strength to zero when ship is killed (by sexp)
457 * 24 1/29/99 2:25p Andsager
458 * Added turret_swarm_missiles
460 * 23 1/29/99 12:47a Dave
461 * Put in sounds for beam weapon. A bunch of interface screens (tech
464 * 22 1/27/99 9:56a Dave
465 * Temporary checkin of beam weapons for Dan to make cool sounds.
467 * 21 1/25/99 5:03a Dave
468 * First run of stealth, AWACS and TAG missile support. New mission type
471 * 20 1/24/99 11:37p Dave
472 * First full rev of beam weapons. Very customizable. Removed some bogus
473 * Int3()'s in low level net code.
475 * 19 1/14/99 6:06p Dave
476 * 100% full squad logo support for single player and multiplayer.
478 * 18 1/14/99 12:48a Dave
479 * Todo list bug fixes. Made a pass at putting briefing icons back into
480 * FRED. Sort of works :(
482 * 17 1/12/99 5:45p Dave
483 * Moved weapon pipeline in multiplayer to almost exclusively client side.
484 * Very good results. Bandwidth goes down, playability goes up for crappy
485 * connections. Fixed object update problem for ship subsystems.
487 * 16 1/08/99 2:08p Dave
488 * Fixed software rendering for pofview. Super early support for AWACS and
491 * 15 1/06/99 2:24p Dave
492 * Stubs and release build fixes.
494 * 14 12/23/98 2:53p Andsager
495 * Added ship activation and gas collection subsystems, removed bridge
497 * 13 12/09/98 7:34p Dave
498 * Cleanup up nebula effect. Tweaked many values.
500 * 12 12/08/98 9:36a Dave
501 * Almost done nebula effect for D3D. Looks 85% as good as Glide.
503 * 11 12/06/98 2:36p Dave
504 * Drastically improved nebula fogging.
506 * 10 11/19/98 4:19p Dave
507 * Put IPX sockets back in psnet. Consolidated all multiplayer config
510 * 9 11/14/98 5:33p Dave
511 * Lots of nebula work. Put in ship contrails.
513 * 8 11/11/98 5:37p Dave
514 * Checkin for multiplayer testing.
516 * 7 10/26/98 9:42a Dave
517 * Early flak gun support.
519 * 6 10/23/98 3:51p Dave
520 * Full support for tstrings.tbl and foreign languages. All that remains
521 * is to make it active in Fred.
523 * 5 10/23/98 3:03p Andsager
524 * Initial support for changing rotation rate.
526 * 4 10/20/98 1:39p Andsager
527 * Make so sparks follow animated ship submodels. Modify
528 * ship_weapon_do_hit_stuff() and ship_apply_local_damage() to add
529 * submodel_num. Add submodel_num to multiplayer hit packet.
531 * 3 10/13/98 9:29a Dave
532 * Started neatening up freespace.h. Many variables renamed and
533 * reorganized. Added AlphaColors.[h,cpp]
535 * 2 10/07/98 10:53a Dave
538 * 1 10/07/98 10:51a Dave
540 * 915 8/28/98 3:29p Dave
541 * EMP effect done. AI effects may need some tweaking as required.
543 * 914 8/25/98 1:48p Dave
544 * First rev of EMP effect. Player side stuff basically done. Next comes
547 * 913 8/17/98 5:07p Dave
548 * First rev of corkscrewing missiles.
550 * 912 7/15/98 11:29a Allender
551 * quick error dialog to prevent the > 50 ships per mission problem
553 * 911 7/06/98 6:11p Dave
554 * More object update stuff.
556 * 910 6/30/98 2:23p Dave
557 * Revised object update system. Removed updates for all weapons. Put
558 * button info back into control info packet.
560 * 909 6/12/98 2:49p Dave
561 * Patch 1.02 changes.
563 * 908 6/10/98 6:46p Lawrance
564 * increase SHIP_MULTITEXT_LENGTH to 1500
566 * 906 6/09/98 10:31a Hoffoss
567 * Created index numbers for all xstr() references. Any new xstr() stuff
568 * added from here on out should be added to the end if the list. The
569 * current list count can be found in FreeSpace.cpp (search for
572 * 905 6/01/98 11:43a John
573 * JAS & MK: Classified all strings for localization.
575 * 904 5/24/98 10:50p Mike
576 * Fix problem with ships with propagating explosions not being able to
579 * 903 5/23/98 4:14p John
580 * Added code to preload textures to video card for AGP. Added in code
581 * to page in some bitmaps that weren't getting paged in at level start.
583 * 902 5/23/98 12:05a Adam
584 * change ship_is_getting_locked() to take weapon range into account
586 * 901 5/22/98 5:32p Andsager
587 * Make big ship explosion sounds play all the way through. remove
588 * cur_snd from ship struct.
590 * 900 5/21/98 7:11p Sandeep
591 * Increased the buffer size a bit during parse ships.tbl to account for
592 * slightly lengthy descriptions
594 * 899 5/21/98 3:31p Allender
595 * fix bug where Ship_obj_list was getting overwritten by the exited ships
598 * 898 5/21/98 1:44p Lawrance
599 * add ship_obj list validation
601 * 897 5/21/98 11:33a Lawrance
602 * Check aspect_locked_time when determining if another ship is seeking
605 * 896 5/19/98 8:42p Andsager
606 * Add cur_snd (used for sound management of big ship explosions)
608 * 895 5/18/98 2:50p Peter
609 * AL: Check to make sure we don't overflow support_ships[] array in
610 * ship_find_repair_ship
612 * 894 5/15/98 11:11p Mike
613 * Make game a bit easier based on skill level, mainly at Easy and, to a
614 * lesser extent, Medium.
616 * 893 5/15/98 6:45p Hoffoss
617 * Made some things not appear in the release version of Fred.
619 * 892 5/15/98 5:37p Hoffoss
620 * Added new 'tech description' fields to ship and weapon tables, and
621 * added usage of it in tech room.
623 * 891 5/15/98 12:07p Allender
624 * make messaging come from proper ships when in team vs. team games.
626 * 890 5/14/98 9:38p Andsager
627 * Fixed bug in dying_undock_physics when both ships have ovelapping dying
630 * 889 5/13/98 6:54p Dave
631 * More sophistication to PXO interface. Changed respawn checking so
632 * there's no window for desynchronization between the server and the
635 * 888 5/12/98 10:54p Andsager
636 * Add new sound manager for big ship sub-explosion sounds
638 * 887 5/12/98 2:34p Adam
639 * re-instated the old nicer particle ANI's for ship explosions.
641 * 886 5/12/98 9:15a Andsager
642 * Clean up big ship sub-explosion sound. Make single instance of sounds.
643 * Choose random sounds. Add timestamp to post split sounds. Make
644 * explosion flash depend on wheth ship was visible if within ~1.5 radii.
646 * 885 5/11/98 4:33p Allender
647 * fixed ingame join problems -- started to work on new object updating
648 * code (currently ifdef'ed out)
650 * 884 5/11/98 4:05p Lawrance
651 * Increase sanity timestamp for next_fire_time to 60 seconds
653 * 883 5/10/98 11:30p Mike
654 * Better firing of bombs, less likely to go into strafe mode.
656 * 882 5/09/98 4:52p Lawrance
657 * Implement padlock view (up/rear/left/right)
659 * 881 5/08/98 5:31p Hoffoss
660 * Isolated the joystick force feedback code more from dependence on other
663 * 880 5/08/98 4:39p Mike
664 * Comment out two Asserts that trap a condition that is actually legal.
682 #include "floating.h"
685 #include "fireballs.h"
690 #include "missionlog.h"
691 #include "missionparse.h"
697 #include "freespace.h"
700 #include "linklist.h"
702 #include "hudtarget.h"
703 #include "hudshield.h"
705 #include "multiutil.h"
706 #include "multimsgs.h"
709 #include "eventmusic.h"
712 #include "gamesequence.h"
713 #include "objectsnd.h"
714 #include "cmeasure.h"
715 #include "animplay.h"
716 #include "controlsconfig.h"
717 #include "afterburner.h"
718 #include "shockwave.h"
719 #include "hudsquadmsg.h"
722 #include "subsysdamage.h"
723 #include "missionmessage.h"
724 #include "lighting.h"
725 #include "particle.h"
727 #include "asteroid.h"
728 #include "hudtargetbox.h"
729 #include "multi_respawn.h"
730 #include "hudartillery.h"
731 #include "hudwingmanstatus.h"
732 #include "jumpnode.h"
733 #include "redalert.h"
734 #include "corkscrew.h"
736 #include "localize.h"
738 #include "shipcontrails.h"
739 #include "alphacolors.h"
742 #include "staticrand.h"
743 #include "missionshipchoice.h"
745 #if defined(FS2_DEMO) || defined(FS1_DEMO)
746 #define MAX_SHIP_SUBOBJECTS 360
748 #define MAX_SHIP_SUBOBJECTS 700 // Reduced from 1000 to 400 by MK on 4/1/98.
749 // Highest I saw was 164 in sm2-03a which Sandeep says has a lot of ships.
750 // JAS: sm3-01 needs 460. You cannot know this number until *all* ships
751 // have warped in. So I put code in the paging code which knows all ships
752 // that will warp in.
755 //#define MIN_COLLISION_MOVE_DIST 5.0
756 //#define COLLISION_VEL_CONST 0.1
757 #define COLLISION_FRICTION_FACTOR 0.0 // ratio of maximum friction impulse to repulsion impulse
758 #define COLLISION_ROTATION_FACTOR 1.0 // increase in rotation from collision
760 int Ai_render_debug_flag=0;
762 int Ship_sphere_check = 0;
763 int Ship_auto_repair = 1; // flag to indicate auto-repair of subsystem should occur
764 extern void render_path_points(object *objp);
767 // mwa -- removed 11/24/97 int num_ships = 0;
769 int Num_reinforcements = 0;
770 ship Ships[MAX_SHIPS];
772 wing Wings[MAX_WINGS];
773 int Starting_wings[MAX_PLAYER_WINGS]; // wings player starts a mission with (-1 = none)
774 int ships_inited = 0;
776 engine_wash_info Engine_wash_info[MAX_ENGINE_WASH_TYPES];
777 char get_engine_wash_index(char *engine_wash_name);
779 // information for ships which have exited the game
780 exited_ship Ships_exited[MAX_EXITED_SHIPS];
781 int Num_exited_ships;
783 int Num_engine_wash_types;
785 int Num_ship_subobj_types;
786 int Num_ship_subobjects;
787 int Player_ship_class; // needs to be player specific, move to player structure
789 #define SHIP_OBJ_USED (1<<0) // flag used in ship_obj struct
790 #define MAX_SHIP_OBJS MAX_SHIPS // max number of ships tracked in ship list
791 ship_obj Ship_objs[MAX_SHIP_OBJS]; // array used to store ship object indexes
792 ship_obj Ship_obj_list; // head of linked list of ship_obj structs
794 ship_info Ship_info[MAX_SHIP_TYPES];
795 ship_subsys Ship_subsystems[MAX_SHIP_SUBOBJECTS];
796 ship_subsys ship_subsys_free_list;
797 reinforcements Reinforcements[MAX_REINFORCEMENTS];
799 int Num_player_ship_precedence; // Number of ship types in Player_ship_precedence
800 int Player_ship_precedence[MAX_PLAYER_SHIP_CHOICES]; // Array of ship types, precedence list for player ship/wing selection
802 static int Laser_energy_out_snd_timer; // timer so we play out of laser sound effect periodically
803 static int Missile_out_snd_timer; // timer so we play out of laser sound effect periodically
805 // structure used to hold ship counts of particular types. The order in which these appear is crucial
806 // since the goal code relies on this placement to find the array index in the Ship_counts array
807 const char *Ship_type_names[MAX_SHIP_TYPE_COUNTS] = {
832 int Ship_type_flags[MAX_SHIP_TYPE_COUNTS] = {
835 SIF_FIGHTER | SIF_BOMBER,
855 ship_counts Ship_counts[MAX_SHIP_TYPE_COUNTS];
857 // I don't want to do an AI cargo check every frame, so I made a global timer to limit check to
858 // every SHIP_CARGO_CHECK_INTERVAL ms. Didn't want to make a timer in each ship struct. Ensure
859 // inited to 1 at mission start.
860 static int Ship_cargo_check_timer;
862 // a global definition of the IFF colors
863 color IFF_colors[MAX_IFF_COLORS][2]; // AL 1-2-97: Create two IFF colors, regular and bright
865 void ship_iff_init_colors()
868 int iff_bright_delta=4;
871 for ( i=0; i<2; i++ ) {
874 alpha = (HUD_COLOR_ALPHA_MAX - iff_bright_delta) * 16;
876 alpha = HUD_COLOR_ALPHA_MAX * 16;
878 gr_init_alphacolor( &IFF_colors[IFF_COLOR_HOSTILE][i], 0xff, 0x00, 0x00, alpha, AC_TYPE_HUD);
879 gr_init_alphacolor( &IFF_colors[IFF_COLOR_FRIENDLY][i], 0x00, 0xff, 0x00, alpha, AC_TYPE_HUD);
880 gr_init_alphacolor( &IFF_colors[IFF_COLOR_NEUTRAL][i], 0xff, 0x00, 0x00, alpha, AC_TYPE_HUD);
881 gr_init_alphacolor( &IFF_colors[IFF_COLOR_UNKNOWN][i], 0xff, 0x00, 0xff, alpha, AC_TYPE_HUD);
882 gr_init_alphacolor( &IFF_colors[IFF_COLOR_SELECTION][i], 0xff, 0xff, 0xff, alpha, AC_TYPE_HUD);
883 gr_init_alphacolor( &IFF_colors[IFF_COLOR_MESSAGE][i], 0x7f, 0x7f, 0x7f, alpha, AC_TYPE_HUD);
884 gr_init_alphacolor( &IFF_colors[IFF_COLOR_TAGGED][i], 0xff, 0xff, 0x00, alpha, AC_TYPE_HUD);
888 // set the ship_obj struct fields to default values
889 void ship_obj_list_reset_slot(int index)
891 Ship_objs[index].flags = 0;
892 Ship_objs[index].next = NULL;
893 Ship_objs[index].prev = (ship_obj*)-1;
896 // if the given ship is in alpha/beta/gamma/zeta wings
897 int ship_in_abgz(ship *shipp)
899 if(!strcmp(shipp->ship_name, "Alpha 1")) return 1;
900 if(!strcmp(shipp->ship_name, "Alpha 2")) return 1;
901 if(!strcmp(shipp->ship_name, "Alpha 3")) return 1;
902 if(!strcmp(shipp->ship_name, "Alpha 4")) return 1;
904 if(!strcmp(shipp->ship_name, "Beta 1")) return 1;
905 if(!strcmp(shipp->ship_name, "Beta 2")) return 1;
906 if(!strcmp(shipp->ship_name, "Beta 3")) return 1;
907 if(!strcmp(shipp->ship_name, "Beta 4")) return 1;
909 if(!strcmp(shipp->ship_name, "Gamma 1")) return 1;
910 if(!strcmp(shipp->ship_name, "Gamma 2")) return 1;
911 if(!strcmp(shipp->ship_name, "Gamma 3")) return 1;
912 if(!strcmp(shipp->ship_name, "Gamma 4")) return 1;
914 if(!strcmp(shipp->ship_name, "Zeta 1")) return 1;
915 if(!strcmp(shipp->ship_name, "Zeta 2")) return 1;
916 if(!strcmp(shipp->ship_name, "Zeta 3")) return 1;
917 if(!strcmp(shipp->ship_name, "Zeta 4")) return 1;
923 // ---------------------------------------------------
924 // ship_obj_list_init()
926 void ship_obj_list_init()
930 list_init(&Ship_obj_list);
931 for ( i = 0; i < MAX_SHIP_OBJS; i++ ) {
932 ship_obj_list_reset_slot(i);
936 // ---------------------------------------------------
937 // ship_obj_list_add()
939 // Function to add a node to the Ship_obj_list. Only
940 // called from ship_create()
941 int ship_obj_list_add(int objnum)
945 for ( i = 0; i < MAX_SHIP_OBJS; i++ ) {
946 if ( !(Ship_objs[i].flags & SHIP_OBJ_USED) )
949 if ( i == MAX_SHIP_OBJS ) {
950 Error(LOCATION, "Fatal Error: Ran out of ship object nodes\n");
954 Ship_objs[i].flags = 0;
955 Ship_objs[i].objnum = objnum;
956 list_append(&Ship_obj_list, &Ship_objs[i]);
957 Ship_objs[i].flags |= SHIP_OBJ_USED;
962 // ---------------------------------------------------
963 // ship_obj_list_remove()
965 // Function to remove a node from the Ship_obj_list. Only
966 // called from ship_delete()
967 void ship_obj_list_remove(int index)
969 SDL_assert(index >= 0 && index < MAX_SHIP_OBJS);
970 list_remove(&Ship_obj_list, &Ship_objs[index]);
971 ship_obj_list_reset_slot(index);
974 // ---------------------------------------------------
975 // ship_obj_list_rebuild()
977 // Called from the save/restore code to re-create the Ship_obj_list
979 void ship_obj_list_rebuild()
983 ship_obj_list_init();
985 for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
986 if ( objp->type == OBJ_SHIP ) {
987 Ships[objp->instance].ship_list_index = ship_obj_list_add(OBJ_INDEX(objp));
992 ship_obj *get_ship_obj_ptr_from_index(int index)
994 SDL_assert(index >= 0 && index < MAX_SHIP_OBJS);
995 return &Ship_objs[index];
999 // return number of ships in the game.
1000 int ship_get_num_ships()
1006 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) )
1012 // parse an engine wash info record
1013 void parse_engine_wash()
1015 engine_wash_info *ewp;
1016 ewp = &Engine_wash_info[Num_engine_wash_types];
1018 // name of engine wash info
1019 required_string("$Name:");
1020 stuff_string(ewp->name, F_NAME, NULL);
1022 // half angle of cone of wash from thruster
1023 required_string("$Angle:");
1024 stuff_float(&ewp->angle);
1025 ewp->angle *= (PI / 180.0f);
1027 // radius multiplier for hemisphere around thruster pt
1028 required_string("$Radius Mult:");
1029 stuff_float(&ewp->radius_mult);
1032 required_string("$Length:");
1033 stuff_float(&ewp->length);
1035 // intensity inside hemisphere (or at 0 distance from frustated cone)
1036 required_string("$Intensity:");
1037 stuff_float(&ewp->intensity);
1041 #define SHIP_MULTITEXT_LENGTH 1500
1042 // function to parse the information for a specific ship type.
1045 char buf[SHIP_MULTITEXT_LENGTH + 1];
1048 float hull_percentage_of_hits = 100.0f;
1049 int n_subsystems = 0;
1050 model_subsystem subsystems[MAX_MODEL_SUBSYSTEMS]; // see model.h for max_model_subsystems
1051 for (int idx=0; idx<MAX_MODEL_SUBSYSTEMS; idx++) {
1052 subsystems[idx].stepped_rotation = NULL;
1053 subsystems[idx].ai_rotation = NULL;
1055 int i, num_allowed, rtn = 0;
1056 int allowed_weapons[MAX_WEAPON_TYPES];
1058 sip = &Ship_info[Num_ship_types];
1061 // These should be specified in ships.tbl eventually!
1064 required_string("$Name:");
1065 stuff_string(sip->name, F_NAME, NULL);
1067 // AL 28-3-98: If this is a demo build, we only want to parse weapons that are preceded with
1069 #ifdef DEMO // not needed FS2_DEMO (using separate table file)
1070 if ( sip->name[0] != '@' ) {
1071 // advance to next weapon, and return -1
1072 if ( skip_to_start_of_strings("$Name:", "#End") != 1 ) {
1080 if (SDL_strchr(sip->name, '#') && Fred_running)
1084 if ( sip->name[0] == '@' ) {
1085 char old_name[NAME_LENGTH];
1086 SDL_strlcpy(old_name, sip->name, SDL_arraysize(old_name));
1087 SDL_strlcpy(sip->name, old_name+1, SDL_arraysize(sip->name));
1090 diag_printf ("Ship name -- %s\n", sip->name);
1091 if ( ship_info_lookup( sip->name ) != -1 ){
1092 Error(LOCATION, "Error: Ship name %s already exists in ships.tbl. All ship class names must be unique.", sip->name);
1095 required_string("$Short name:");
1096 stuff_string(sip->short_name, F_NAME, NULL);
1097 diag_printf ("Ship short name -- %s\n", sip->short_name);
1099 find_and_stuff("$Species:", &sip->species, F_NAME, Species_names, MAX_SPECIES_NAMES, "species names");
1100 diag_printf ("Ship species -- %s\n", Species_names[sip->species]);
1102 sip->type_str = sip->maneuverability_str = sip->armor_str = sip->manufacturer_str = NULL;
1103 if (optional_string("+Type:")) {
1104 stuff_string(buf, F_MESSAGE, NULL);
1105 sip->type_str = strdup(buf);
1108 if (optional_string("+Maneuverability:")) {
1109 stuff_string(buf, F_MESSAGE, NULL);
1110 sip->maneuverability_str = strdup(buf);
1113 if (optional_string("+Armor:")) {
1114 stuff_string(buf, F_MESSAGE, NULL);
1115 sip->armor_str = strdup(buf);
1118 if (optional_string("+Manufacturer:")) {
1119 stuff_string(buf, F_MESSAGE, NULL);
1120 sip->manufacturer_str = strdup(buf);
1124 if (optional_string("+Description:")) {
1125 stuff_string(buf, F_MULTITEXT, NULL);
1126 sip->desc = strdup(buf);
1129 sip->tech_desc = NULL;
1130 if (optional_string("+Tech Description:")) {
1131 stuff_string(buf, F_MULTITEXT, NULL, SHIP_MULTITEXT_LENGTH);
1132 sip->tech_desc = strdup(buf);
1135 // Code added here by SS to parse the optional strings for length, gun_mounts, missile_banks
1137 sip->ship_length = NULL;
1138 if (optional_string("+Length:")) {
1139 stuff_string(buf, F_MESSAGE, NULL);
1140 sip->ship_length = strdup(buf);
1143 sip->gun_mounts = NULL;
1144 if (optional_string("+Gun Mounts:")) {
1145 stuff_string(buf, F_MESSAGE, NULL);
1146 sip->gun_mounts = strdup(buf);
1149 sip->missile_banks = NULL;
1150 if (optional_string("+Missile Banks:")) {
1151 stuff_string(buf, F_MESSAGE, NULL);
1152 sip->missile_banks = strdup(buf);
1158 sip->num_detail_levels = 0;
1160 required_string( "$POF file:" );
1161 stuff_string( sip->pof_file, F_NAME, NULL );
1163 // optional hud targeting model
1164 SDL_strlcpy(sip->pof_file_hud, "", SDL_arraysize(sip->pof_file_hud));
1165 if(optional_string( "$POF target file:")){
1166 stuff_string(sip->pof_file_hud, F_NAME, NULL);
1169 required_string("$Detail distance:");
1170 sip->num_detail_levels = stuff_int_list(sip->detail_distance, MAX_SHIP_DETAIL_LEVELS, RAW_INTEGER_TYPE);
1172 // check for optional pixel colors
1173 sip->num_nondark_colors = 0;
1174 while(optional_string("$ND:")){
1180 if(sip->num_nondark_colors < MAX_NONDARK_COLORS){
1181 sip->nondark_colors[sip->num_nondark_colors][0] = nr;
1182 sip->nondark_colors[sip->num_nondark_colors][1] = ng;
1183 sip->nondark_colors[sip->num_nondark_colors++][2] = nb;
1187 required_string("$Show damage:");
1189 stuff_boolean(&bogus_bool);
1191 required_string("$Density:");
1192 stuff_float( &(sip->density) );
1193 diag_printf ("Ship density -- %7.3f\n", sip->density);
1195 required_string("$Damp:");
1196 stuff_float( &(sip->damp) );
1197 diag_printf ("Ship damp -- %7.3f\n", sip->damp);
1199 required_string("$Rotdamp:");
1200 stuff_float( &(sip->rotdamp) );
1201 diag_printf ("Ship rotdamp -- %7.3f\n", sip->rotdamp);
1203 required_string("$Max Velocity:");
1204 stuff_vector(&sip->max_vel);
1206 // calculate the max speed from max_velocity
1207 sip->max_speed = vm_vec_mag(&sip->max_vel);
1209 required_string("$Rotation Time:");
1210 stuff_vector(&sip->rotation_time);
1212 sip->srotation_time = (sip->rotation_time.xyz.x + sip->rotation_time.xyz.y)/2.0f;
1214 sip->max_rotvel.xyz.x = (2 * PI) / sip->rotation_time.xyz.x;
1215 sip->max_rotvel.xyz.y = (2 * PI) / sip->rotation_time.xyz.y;
1216 sip->max_rotvel.xyz.z = (2 * PI) / sip->rotation_time.xyz.z;
1218 // get the backwards velocity;
1219 required_string("$Rear Velocity:");
1220 stuff_float(&sip->max_rear_vel);
1222 // get the accelerations
1223 required_string("$Forward accel:");
1224 stuff_float(&sip->forward_accel );
1226 required_string("$Forward decel:");
1227 stuff_float(&sip->forward_decel );
1229 required_string("$Slide accel:");
1230 stuff_float(&sip->slide_accel );
1232 required_string("$Slide decel:");
1233 stuff_float(&sip->slide_decel );
1235 // get ship explosion info
1236 required_string("$Expl inner rad:");
1237 stuff_float(&sip->inner_rad);
1239 required_string("$Expl outer rad:");
1240 stuff_float(&sip->outer_rad);
1242 required_string("$Expl damage:");
1243 stuff_float(&sip->damage);
1245 required_string("$Expl blast:");
1246 stuff_float(&sip->blast);
1248 required_string("$Expl Propagates:");
1249 stuff_boolean(&sip->explosion_propagates);
1251 required_string("$Shockwave Speed:");
1252 stuff_float( &sip->shockwave_speed );
1254 sip->shockwave_count = 1;
1255 if(optional_string("$Shockwave Count:")){
1256 stuff_int(&sip->shockwave_count);
1259 for ( i = 0; i < MAX_WEAPON_TYPES; i++ ){
1260 sip->allowed_weapons[i] = 0;
1263 // Set the weapons filter used in weapons loadout (for primary weapons)
1264 if (optional_string("$Allowed PBanks:")) {
1265 num_allowed = stuff_int_list(allowed_weapons, MAX_WEAPON_TYPES, WEAPON_LIST_TYPE);
1267 // actually say which weapons are allowed
1268 for ( i = 0; i < num_allowed; i++ ) {
1269 if ( allowed_weapons[i] >= 0 ) { // MK, Bug fix, 9/6/99. Used to be "allowed_weapons" not "allowed_weapons[i]".
1270 sip->allowed_weapons[allowed_weapons[i]] |= 1;
1275 // Set the weapons filter used in weapons loadout (for primary weapons)
1276 if (optional_string("$Allowed Dogfight PBanks:")) {
1277 num_allowed = stuff_int_list(allowed_weapons, MAX_WEAPON_TYPES, WEAPON_LIST_TYPE);
1279 // actually say which weapons are allowed
1280 for ( i = 0; i < num_allowed; i++ ) {
1281 if ( allowed_weapons[i] >= 0 ) {
1282 sip->allowed_weapons[allowed_weapons[i]] |= 2;
1287 // Get default primary bank weapons
1288 for ( i = 0; i < MAX_PRIMARY_BANKS; i++ ){
1289 sip->primary_bank_weapons[i] = -1;
1291 required_string("$Default PBanks:");
1292 sip->num_primary_banks = stuff_int_list(sip->primary_bank_weapons, MAX_PRIMARY_BANKS, WEAPON_LIST_TYPE);
1295 for ( i = 0; i < sip->num_primary_banks; i++ ) {
1296 SDL_assert(sip->primary_bank_weapons[i] >= 0);
1299 // Set the weapons filter used in weapons loadout (for secondary weapons)
1300 if (optional_string("$Allowed SBanks:")) {
1301 num_allowed = stuff_int_list(allowed_weapons, MAX_WEAPON_TYPES, WEAPON_LIST_TYPE);
1303 // actually say which weapons are allowed
1304 for ( i = 0; i < num_allowed; i++ ) {
1305 if ( allowed_weapons[i] >= 0 ) {
1306 sip->allowed_weapons[allowed_weapons[i]] |= 1;
1311 // Set the weapons filter used in weapons loadout (for secondary weapons)
1312 if (optional_string("$Allowed Dogfight SBanks:")) {
1313 num_allowed = stuff_int_list(allowed_weapons, MAX_WEAPON_TYPES, WEAPON_LIST_TYPE);
1315 // actually say which weapons are allowed
1316 for ( i = 0; i < num_allowed; i++ ) {
1317 if ( allowed_weapons[i] >= 0 ) {
1318 sip->allowed_weapons[allowed_weapons[i]] |= 2;
1323 // Get default secondary bank weapons
1324 for ( i = 0; i < MAX_SECONDARY_BANKS; i++ ){
1325 sip->secondary_bank_weapons[i] = -1;
1327 required_string("$Default SBanks:");
1328 sip->num_secondary_banks = stuff_int_list(sip->secondary_bank_weapons, MAX_SECONDARY_BANKS, WEAPON_LIST_TYPE);
1331 for ( i = 0; i < sip->num_secondary_banks; i++ ) {
1332 SDL_assert(sip->secondary_bank_weapons[i] >= 0);
1335 // Get the capacity of each secondary bank
1336 required_string("$Sbank Capacity:");
1338 capacity_count = stuff_int_list(sip->secondary_bank_ammo_capacity, MAX_SECONDARY_BANKS, RAW_INTEGER_TYPE);
1339 if ( capacity_count != sip->num_secondary_banks ) {
1340 Warning(LOCATION, "Secondary bank capacities have not been specified for ship class %s... fix this!!", sip->name);
1343 required_string("$Shields:");
1344 stuff_float(&sip->shields);
1346 // optional shield color
1347 sip->shield_color[0] = 255;
1348 sip->shield_color[1] = 255;
1349 sip->shield_color[2] = 255;
1350 if(optional_string("$Shield Color:")){
1351 stuff_byte(&sip->shield_color[0]);
1352 stuff_byte(&sip->shield_color[1]);
1353 stuff_byte(&sip->shield_color[2]);
1356 // The next three fields are used for the ETS
1357 required_string("$Power Output:");
1358 stuff_float(&sip->power_output);
1360 required_string("$Max Oclk Speed:");
1361 stuff_float(&sip->max_overclocked_speed);
1363 required_string("$Max Weapon Eng:");
1364 stuff_float(&sip->max_weapon_reserve);
1366 required_string("$Hitpoints:");
1367 stuff_float(&sip->initial_hull_strength);
1369 required_string("$Flags:");
1370 char ship_strings[MAX_SHIP_FLAGS][NAME_LENGTH];
1371 int num_strings = stuff_string_list(ship_strings, MAX_SHIP_FLAGS);
1372 sip->flags = SIF_DEFAULT_VALUE;
1373 for ( i=0; i<num_strings; i++ ) {
1374 if (!SDL_strcasecmp(NOX("no_collide"), ship_strings[i]))
1375 sip->flags &= ~SIF_DO_COLLISION_CHECK;
1376 else if (!SDL_strcasecmp(NOX("player_ship"), ship_strings[i]))
1377 sip->flags |= SIF_PLAYER_SHIP;
1378 else if (!SDL_strcasecmp(NOX("default_player_ship"), ship_strings[i]))
1379 sip->flags |= SIF_DEFAULT_PLAYER_SHIP;
1380 else if ( !SDL_strcasecmp(NOX("repair_rearm"), ship_strings[i]))
1381 sip->flags |= SIF_SUPPORT;
1382 else if ( !SDL_strcasecmp(NOX("cargo"), ship_strings[i]))
1383 sip->flags |= SIF_CARGO;
1384 else if ( !SDL_strcasecmp( NOX("fighter"), ship_strings[i]))
1385 sip->flags |= SIF_FIGHTER;
1386 else if ( !SDL_strcasecmp( NOX("bomber"), ship_strings[i]))
1387 sip->flags |= SIF_BOMBER;
1388 else if ( !SDL_strcasecmp( NOX("transport"), ship_strings[i]))
1389 sip->flags |= SIF_TRANSPORT;
1390 else if ( !SDL_strcasecmp( NOX("freighter"), ship_strings[i]))
1391 sip->flags |= SIF_FREIGHTER;
1392 else if ( !SDL_strcasecmp( NOX("capital"), ship_strings[i]))
1393 sip->flags |= SIF_CAPITAL;
1394 else if (!SDL_strcasecmp( NOX("supercap"), ship_strings[i]))
1395 sip->flags |= SIF_SUPERCAP;
1396 else if (!SDL_strcasecmp( NOX("drydock"), ship_strings[i]))
1397 sip->flags |= SIF_DRYDOCK;
1398 else if ( !SDL_strcasecmp( NOX("cruiser"), ship_strings[i]))
1399 sip->flags |= SIF_CRUISER;
1400 else if ( !SDL_strcasecmp( NOX("navbuoy"), ship_strings[i]))
1401 sip->flags |= SIF_NAVBUOY;
1402 else if ( !SDL_strcasecmp( NOX("sentrygun"), ship_strings[i]))
1403 sip->flags |= SIF_SENTRYGUN;
1404 else if ( !SDL_strcasecmp( NOX("escapepod"), ship_strings[i]))
1405 sip->flags |= SIF_ESCAPEPOD;
1406 else if ( !SDL_strcasecmp( NOX("no type"), ship_strings[i]))
1407 sip->flags |= SIF_NO_SHIP_TYPE;
1408 else if ( !SDL_strcasecmp( NOX("ship copy"), ship_strings[i]))
1409 sip->flags |= SIF_SHIP_COPY;
1410 else if ( !SDL_strcasecmp( NOX("in tech database"), ship_strings[i]))
1412 sip->flags |= SIF_IN_TECH_DATABASE;
1414 sip->flags |= SIF_IN_TECH_DATABASE | SIF_IN_TECH_DATABASE_M;
1416 else if ( !SDL_strcasecmp( NOX("in tech database multi"), ship_strings[i]))
1417 sip->flags |= SIF_IN_TECH_DATABASE_M;
1418 else if ( !SDL_strcasecmp( NOX("dont collide invisible"), ship_strings[i]))
1419 sip->flags |= SIF_DONT_COLLIDE_INVIS;
1420 else if ( !SDL_strcasecmp( NOX("big damage"), ship_strings[i]))
1421 sip->flags |= SIF_BIG_DAMAGE;
1422 else if ( !SDL_strcasecmp( NOX("corvette"), ship_strings[i]))
1423 sip->flags |= SIF_CORVETTE;
1424 else if ( !SDL_strcasecmp( NOX("gas miner"), ship_strings[i]))
1425 sip->flags |= SIF_GAS_MINER;
1426 else if ( !SDL_strcasecmp( NOX("awacs"), ship_strings[i]))
1427 sip->flags |= SIF_AWACS;
1428 else if ( !SDL_strcasecmp( NOX("knossos"), ship_strings[i]))
1429 sip->flags |= SIF_KNOSSOS_DEVICE;
1430 else if ( !SDL_strcasecmp( NOX("no_fred"), ship_strings[i]))
1431 sip->flags |= SIF_NO_FRED;
1433 Warning(LOCATION, "Bogus string in ship flags: %s\n", ship_strings[i]);
1436 find_and_stuff("$AI Class:", &sip->ai_class, F_NAME, (const char **)Ai_class_names, Num_ai_classes, "AI class names");
1438 // Get Afterburner information
1439 // Be aware that if $Afterburner is not 1, the other Afterburner fields are not read in
1440 required_string("$Afterburner:");
1441 int has_afterburner;
1442 stuff_boolean(&has_afterburner);
1443 if ( has_afterburner == 1 ) {
1444 sip->flags |= SIF_AFTERBURNER;
1446 required_string("+Aburn Max Vel:");
1447 stuff_vector(&sip->afterburner_max_vel);
1449 required_string("+Aburn For accel:");
1450 stuff_float(&sip->afterburner_forward_accel);
1452 required_string("+Aburn Fuel:");
1453 stuff_float(&sip->afterburner_fuel_capacity);
1455 required_string("+Aburn Burn Rate:");
1456 stuff_float(&sip->afterburner_burn_rate);
1459 required_string("+Aburn Rec Rate:");
1460 stuff_float(&sip->afterburner_recover_rate);
1462 sip->afterburner_max_vel.xyz.x = 0.0f;
1463 sip->afterburner_max_vel.xyz.y = 0.0f;
1464 sip->afterburner_max_vel.xyz.z = 0.0f;
1467 required_string("$Countermeasures:");
1468 stuff_int(&sip->cmeasure_max);
1470 required_string("$Scan time:");
1471 stuff_int(&sip->scan_time);
1473 required_string("$EngineSnd:");
1474 stuff_int(&sip->engine_snd);
1476 required_string("$Closeup_pos:");
1477 stuff_vector(&sip->closeup_pos);
1479 required_string("$Closeup_zoom:");
1480 stuff_float(&sip->closeup_zoom);
1482 sip->shield_icon_index = 255; // stored as ubyte
1483 if (optional_string("$Shield_icon:")) {
1484 char tmpbuf[NAME_LENGTH];
1485 stuff_string(tmpbuf, F_NAME, NULL);
1486 hud_shield_assign_info(sip, tmpbuf);
1489 // read in filename for icon that is used in ship selection
1490 sip->icon_filename[0] = 0;
1491 if ( optional_string("$Ship_icon:") ) {
1492 stuff_string(sip->icon_filename, F_NAME, NULL);
1495 // read in filename for animation that is used in ship selection
1496 sip->anim_filename[0] = 0;
1497 if ( optional_string("$Ship_anim:") ) {
1498 stuff_string(sip->anim_filename, F_NAME, NULL);
1501 // read in filename for animation that is used in ship selection
1502 sip->overhead_filename[0] = 0;
1503 if ( optional_string("$Ship_overhead:") ) {
1504 stuff_string(sip->overhead_filename, F_NAME, NULL);
1508 if ( optional_string("$Score:") ){
1509 stuff_int( &sip->score );
1512 // if the ship is a stealth ship
1513 if ( optional_string("$Stealth:") ){
1514 sip->flags |= SIF_STEALTH;
1518 // parse contrail info
1519 char trail_name[MAX_FILENAME_LEN] = "";
1521 memset(&sip->ct_info, 0, sizeof(trail_info) * MAX_SHIP_CONTRAILS);
1523 while(optional_string("$Trail:")){
1524 // this means you've reached the max # of contrails for a ship
1525 SDL_assert(sip->ct_count <= MAX_SHIP_CONTRAILS);
1527 ci = &sip->ct_info[sip->ct_count++];
1529 required_string("+Offset:");
1530 stuff_vector(&ci->pt);
1532 required_string("+Start Width:");
1533 stuff_float(&ci->w_start);
1535 required_string("+End Width:");
1536 stuff_float(&ci->w_end);
1538 required_string("+Start Alpha:");
1539 stuff_float(&ci->a_start);
1541 required_string("+End Alpha:");
1542 stuff_float(&ci->a_end);
1544 required_string("+Max Life:");
1545 stuff_float(&ci->max_life);
1547 required_string("+Spew Time:");
1548 stuff_int(&ci->stamp);
1550 required_string("+Bitmap:");
1551 stuff_string(trail_name, F_NAME, NULL);
1552 ci->bitmap = bm_load(trail_name);
1557 int r = required_string_3("#End", "$Subsystem:", "$Name" );
1565 float percentage_of_hits;
1566 model_subsystem *sp; // to append on the ships list of subsystems
1568 SDL_assert ( n_subsystems < MAX_MODEL_SUBSYSTEMS );
1569 sp = &subsystems[n_subsystems++]; // subsystems a local -- when done, we will malloc and copy
1570 required_string("$Subsystem:");
1571 stuff_string(sp->subobj_name, F_NAME, ",");
1573 stuff_float(&percentage_of_hits);
1574 stuff_float(&turning_rate);
1575 hull_percentage_of_hits -= percentage_of_hits;
1576 sp->max_hits = sip->initial_hull_strength * (percentage_of_hits / 100.0f);
1577 sp->type = SUBSYSTEM_UNKNOWN;
1578 // specified as how long to turn 360 degrees in ships.tbl
1579 if ( turning_rate > 0.0f ){
1580 sp->turret_turning_rate = PI2 / turning_rate;
1582 sp->turret_turning_rate = 0.0f;
1585 for (i=0; i<MAX_PRIMARY_BANKS; i++)
1586 sp->primary_banks[i] = -1;
1587 for (i=0; i<MAX_SECONDARY_BANKS; i++) {
1588 sp->secondary_banks[i] = -1;
1589 sp->secondary_bank_capacity[i] = 0;
1592 // Get default primary bank weapons
1593 if (optional_string("$Default PBanks:")){
1594 stuff_int_list(sp->primary_banks, MAX_PRIMARY_BANKS, WEAPON_LIST_TYPE);
1597 // Get default secondary bank weapons
1598 if (optional_string("$Default SBanks:")){
1599 stuff_int_list(sp->secondary_banks, MAX_SECONDARY_BANKS, WEAPON_LIST_TYPE);
1602 // Get the capacity of each secondary bank
1603 if (optional_string("$Sbank Capacity:")){
1604 stuff_int_list(sp->secondary_bank_capacity, MAX_SECONDARY_BANKS, RAW_INTEGER_TYPE);
1607 // Get optional engine wake info
1608 if (optional_string("$Engine Wash:")) {
1609 char engine_wash_name[32];
1610 stuff_string(engine_wash_name, F_NAME, NULL);
1611 // get and set index
1612 sp->engine_wash_index = get_engine_wash_index(engine_wash_name);
1614 sp->engine_wash_index = -1;
1617 // Get any AWACS info
1618 sp->awacs_intensity = 0.0f;
1619 if(optional_string("$AWACS:")){
1620 stuff_float(&sp->awacs_intensity);
1621 stuff_float(&sp->awacs_radius);
1622 sip->flags |= SIF_HAS_AWACS;
1625 sp->turret_weapon_type = sp->primary_banks[0]; // temporary, will be obsolete later.
1626 if ( sp->turret_weapon_type < 0 ) {
1627 sp->turret_weapon_type = sp->secondary_banks[0];
1629 sp->model_num = -1; // init value for later sanity checking!!
1636 Int3(); // Impossible return value from required_string_3.
1639 SDL_assert( hull_percentage_of_hits > 0.0f ); // must be > 0
1641 // when done reading subsystems, malloc and copy the subsystem data to the ship info structure
1642 sip->n_subsystems = n_subsystems;
1643 if ( n_subsystems > 0 ) {
1644 sip->subsystems = (model_subsystem *)malloc(sizeof(model_subsystem) * n_subsystems );
1645 SDL_assert( sip->subsystems != NULL );
1648 sip->subsystems = NULL;
1651 for ( i = 0; i < n_subsystems; i++ ){
1652 sip->subsystems[i] = subsystems[i];
1655 // if we have a ship copy, then check to be sure that our base ship exists
1656 if ( sip->flags & SIF_SHIP_COPY ) {
1659 index = ship_info_base_lookup( Num_ship_types ); // Num_ship_types is our current entry into the array
1660 if ( index == -1 ) {
1661 char *p, name[NAME_LENGTH];;
1663 SDL_strlcpy( name, sip->name, SDL_arraysize(name) );
1664 p = SDL_strchr(name, '#');
1667 Error(LOCATION, "Ship %s is a copy, but base ship %s couldn't be found.", sip->name, name);
1674 char get_engine_wash_index(char *engine_wash_name)
1678 for (i=0; i<Num_engine_wash_types; i++) {
1679 if ( 0 == SDL_strcasecmp(engine_wash_name, Engine_wash_info[i].name) ) {
1684 // not found, so return -1
1688 void parse_shiptbl()
1690 // open localization
1693 read_file_text("ships.tbl");
1697 // parse default ship
1698 required_string("#Default Player Ship");
1699 required_string("$Name:");
1700 stuff_string(default_player_ship, F_NAME, NULL, 254);
1701 required_string("#End");
1705 Num_engine_wash_types = 0;
1710 required_string("#Engine Wash Info");
1711 while (required_string_either("#End", "$Name:")) {
1712 SDL_assert( Num_engine_wash_types < MAX_ENGINE_WASH_TYPES );
1714 parse_engine_wash();
1715 Num_engine_wash_types++;
1718 required_string("#End");
1720 required_string("#Ship Classes");
1722 while (required_string_either("#End","$Name:")) {
1723 SDL_assert( Num_ship_types < MAX_SHIP_TYPES );
1725 if ( parse_ship() ) {
1732 required_string("#End");
1734 // Read in a list of ship_info indicies that are an ordering of the player ship precedence.
1735 // This list is used to select an alternate ship when a particular ship is not available
1736 // during ship selection.
1737 required_string("$Player Ship Precedence:");
1738 Num_player_ship_precedence = stuff_int_list(Player_ship_precedence, MAX_PLAYER_SHIP_CHOICES, SHIP_INFO_TYPE);
1740 // close localization
1744 int ship_show_velocity_dot = 0;
1747 DCF_BOOL( show_velocity_dot, ship_show_velocity_dot )
1750 // Called once at the beginning of the game to parse ships.tbl and stuff the Ship_info[]
1754 if ( !ships_inited ) {
1758 } catch (parse_error_t rval) {
1759 Error(LOCATION, "Error parsing 'ships.tbl'\r\nError code = %i.\r\n", (int)rval);
1762 ship_iff_init_colors();
1765 ship_level_init(); // needed for FRED
1769 // This will get called at the start of each level.
1770 void ship_level_init()
1774 // Reset everything between levels
1777 // Mark all the models as invalid, since all the models get paged out
1779 for (i=0; i<MAX_SHIP_TYPES; i++ ) {
1780 Ship_info[i].modelnum = -1;
1781 Ship_info[i].modelnum_hud = -1;
1784 // mwa removed 11/24/97 num_ships = 0;
1785 Num_exited_ships = 0;
1786 for (i=0; i<MAX_SHIPS; i++ ) {
1787 Ships[i].objnum = -1;
1790 for ( i = 0; i < MAX_EXITED_SHIPS; i++ ) {
1791 memset ( &Ships_exited[i], 0, sizeof(exited_ship) );
1792 Ships_exited[i].obj_signature = -1;
1796 for (i = 0; i < MAX_WINGS; i++ )
1797 Wings[i].num_waves = -1;
1799 for (i=0; i<MAX_PLAYER_WINGS; i++)
1800 Starting_wings[i] = -1;
1802 // Empty the subsys list
1803 memset( Ship_subsystems, 0, sizeof(ship_subsys)*MAX_SHIP_SUBOBJECTS );
1805 list_init( &ship_subsys_free_list );
1806 for ( i = 0; i < MAX_SHIP_SUBOBJECTS; i++ )
1807 list_append( &ship_subsys_free_list, &Ship_subsystems[i] );
1809 Laser_energy_out_snd_timer = 1;
1810 Missile_out_snd_timer = 1;
1812 for (i = 0; i < MAX_SHIP_TYPE_COUNTS; i++ ) {
1813 Ship_counts[i].total = 0;
1814 Ship_counts[i].killed = 0;
1817 ship_obj_list_init();
1819 Ship_cargo_check_timer = 1;
1821 shipfx_large_blowup_level_init();
1824 // function to add a ship onto the exited ships list. The reason parameter
1825 // tells us why the ship left the mission (i.e. departed or destroyed)
1826 void ship_add_exited_ship( ship *sp, int reason )
1830 // reuse oldest slots if none left
1831 if ( Num_exited_ships == MAX_EXITED_SHIPS ) {
1834 // find the oldest entry
1836 for ( i = 1; i < MAX_SHIPS; i++ ) {
1837 if ( Ships_exited[i].time < Ships_exited[oldest_entry].time ) {
1841 entry = oldest_entry;
1843 entry = Num_exited_ships;
1847 SDL_strlcpy( Ships_exited[entry].ship_name, sp->ship_name, SDL_arraysize(Ships_exited[0].ship_name) );
1848 Ships_exited[entry].obj_signature = Objects[sp->objnum].signature;
1849 Ships_exited[entry].team = sp->team;
1850 Ships_exited[entry].flags = reason;
1851 // if ship is red alert, flag as such
1852 if (sp->flags & SF_RED_ALERT_STORE_STATUS) {
1853 Ships_exited[entry].flags |= SEF_RED_ALERT_CARRY;
1855 Ships_exited[entry].time = Missiontime;
1856 Ships_exited[entry].hull_strength = int(Objects[sp->objnum].hull_strength);
1858 if ( sp->flags & SF_CARGO_REVEALED )
1859 Ships_exited[entry].flags |= SEF_CARGO_KNOWN;
1860 if ( sp->time_first_tagged > 0 )
1861 Ships_exited[entry].flags |= SEF_BEEN_TAGGED;
1864 // function which attempts to find information about an exited ship based on shipname
1865 int ship_find_exited_ship_by_name( const char *name )
1869 for (i = 0; i < Num_exited_ships; i++) {
1870 if ( !SDL_strcasecmp(name, Ships_exited[i].ship_name) )
1874 if ( i == Num_exited_ships )
1880 // function which attempts to find information about an exited ship based on shipname
1881 int ship_find_exited_ship_by_signature( int signature )
1885 for (i = 0; i < Num_exited_ships; i++) {
1886 if ( signature == Ships_exited[i].obj_signature )
1890 if ( i == Num_exited_ships )
1897 void physics_ship_init(object *objp)
1899 ship_info *sinfo = &Ship_info[Ships[objp->instance].ship_info_index];
1900 physics_info *pi = &objp->phys_info;
1901 polymodel *pm = model_get( Ships[objp->instance].modelnum );
1903 // use mass and I_body_inv from POF read into polymodel
1905 pi->mass = pm->mass * sinfo->density;
1906 pi->I_body_inv = pm->moment_of_inertia;
1907 // scale pm->I_body_inv value by density
1908 vm_vec_scale( &pi->I_body_inv.v.rvec, sinfo->density );
1909 vm_vec_scale( &pi->I_body_inv.v.uvec, sinfo->density );
1910 vm_vec_scale( &pi->I_body_inv.v.fvec, sinfo->density );
1912 pi->side_slip_time_const = sinfo->damp;
1913 pi->rotdamp = sinfo->rotdamp;
1914 pi->max_vel = sinfo->max_vel;
1915 pi->afterburner_max_vel = sinfo->afterburner_max_vel;
1916 pi->max_rotvel = sinfo->max_rotvel;
1917 pi->max_rear_vel = sinfo->max_rear_vel;
1918 pi->flags |= PF_ACCELERATES;
1923 pi->forward_accel_time_const=sinfo->forward_accel;
1924 pi->afterburner_forward_accel_time_const=sinfo->afterburner_forward_accel;
1925 pi->forward_decel_time_const=sinfo->forward_decel;
1926 pi->slide_accel_time_const=sinfo->slide_accel;
1927 pi->slide_decel_time_const=sinfo->slide_decel;
1929 if ( (pi->max_vel.xyz.x > 0.000001f) || (pi->max_vel.xyz.y > 0.000001f) )
1930 pi->flags |= PF_SLIDE_ENABLED;
1932 vm_vec_zero(&pi->vel);
1933 vm_vec_zero(&pi->rotvel);
1936 // pi->accel = 0.0f;
1937 vm_set_identity(&pi->last_rotmat);
1940 // function to set the orders allowed for a ship -- based on ship type. This value might get overridden
1941 // by a value in the mission file.
1942 int ship_get_default_orders_accepted( ship_info *sip )
1946 ship_info_flag = sip->flags;
1948 if ( ship_info_flag & SIF_FIGHTER )
1949 return FIGHTER_MESSAGES;
1950 else if ( ship_info_flag & SIF_BOMBER )
1951 return BOMBER_MESSAGES;
1952 else if ( ship_info_flag & (SIF_CRUISER | SIF_GAS_MINER | SIF_AWACS | SIF_CORVETTE) )
1953 return CRUISER_MESSAGES;
1954 else if ( ship_info_flag & SIF_FREIGHTER )
1955 return FREIGHTER_MESSAGES;
1956 else if ( ship_info_flag & SIF_CAPITAL )
1957 return CAPITAL_MESSAGES;
1958 else if ( ship_info_flag & SIF_TRANSPORT )
1959 return TRANSPORT_MESSAGES;
1960 else if ( ship_info_flag & SIF_SUPPORT )
1961 return SUPPORT_MESSAGES;
1966 void ship_set(int ship_index, int objnum, int ship_type)
1970 object *objp = &Objects[objnum];
1971 ship *shipp = &Ships[ship_index];
1972 ship_weapon *swp = &shipp->weapons;
1973 ship_info *sip = &(Ship_info[ship_type]);
1976 // sprintf(shipp->ship_name, "%s %d", Ship_info[ship_type].name, ship_index); // moved to ship_create()
1977 SDL_assert(strlen(shipp->ship_name) < NAME_LENGTH - 1);
1978 shipp->ship_info_index = ship_type;
1979 shipp->objnum = objnum;
1981 shipp->reinforcement_index = -1;
1985 shipp->escort_priority = 0;
1986 shipp->special_exp_index = -1;
1987 shipp->num_hits = 0;
1989 shipp->wash_killed = 0;
1990 shipp->time_cargo_revealed = 0;
1991 shipp->time_first_tagged = 0;
1992 shipp->wash_timestamp = timestamp(0);
1993 shipp->dock_objnum_when_dead = -1;
1994 shipp->large_ship_blowup_index = -1;
1995 shipp->respawn_priority = 0;
1996 for (i=0; i<NUM_SUB_EXPL_HANDLES; i++) {
1997 shipp->sub_expl_sound_handle[i] = -1;
2000 if ( !Fred_running ) {
2001 shipp->final_warp_time = timestamp(-1);
2002 shipp->final_death_time = timestamp(-1); // There death sequence ain't start et.
2003 shipp->really_final_death_time = timestamp(-1); // There death sequence ain't start et.
2004 shipp->next_fireball = timestamp(-1); // When a random fireball will pop up
2005 shipp->next_hit_spark = timestamp(-1); // when a hit spot will spark
2006 for (i=0; i<MAX_SHIP_ARCS; i++ ) {
2007 shipp->arc_timestamp[i] = timestamp(-1); // Mark this arc as unused
2009 shipp->arc_next_time = timestamp(-1); // No electrical arcs yet.
2010 } else { // the values should be different for Fred
2011 shipp->final_warp_time = -1;
2012 shipp->final_death_time = 0;
2013 shipp->really_final_death_time = -1;
2014 shipp->next_fireball = -1;
2015 shipp->next_hit_spark = -1;
2016 for (i=0; i<MAX_SHIP_ARCS; i++ ) {
2017 shipp->arc_timestamp[i] = -1;
2019 shipp->arc_next_time = -1;
2021 shipp->team = TEAM_FRIENDLY; // Default friendly, probably get overridden.
2022 shipp->arrival_location = 0;
2023 shipp->arrival_distance = 0;
2024 shipp->arrival_anchor = -1;
2025 shipp->arrival_delay = 0;
2026 shipp->arrival_cue = -1;
2027 shipp->departure_location = 0;
2028 shipp->departure_delay = 0;
2029 shipp->departure_cue = -1;
2030 shipp->shield_hits = 0; // No shield hits yet on this baby.
2031 shipp->current_max_speed = Ship_info[ship_type].max_speed;
2033 shipp->alt_type_index = -1;
2035 shipp->lightning_stamp = -1;
2037 shipp->emp_intensity = -1.0f;
2038 shipp->emp_decr = 0.0f;
2040 shipp->targeting_laser_bank = -1;
2041 shipp->targeting_laser_objnum = -1;
2043 shipp->determination = 10;
2044 shipp->wingnum = -1;
2045 for (i = 0; i < MAX_PLAYERS; i++)
2046 shipp->last_targeted_subobject[i] = NULL;
2049 objp->hull_strength = 100.0f;
2051 objp->hull_strength = sip->initial_hull_strength;
2054 shipp->afterburner_fuel = sip->afterburner_fuel_capacity;
2056 shipp->cmeasure_count = sip->cmeasure_max;
2058 for ( i = 0; i < MAX_PRIMARY_BANKS; i++ ){
2059 swp->next_primary_fire_stamp[i] = timestamp(0);
2062 shipp->cmeasure_fire_stamp = timestamp(0);
2064 for ( i = 0; i < MAX_SECONDARY_BANKS; i++ ) {
2066 shipp->weapons.secondary_bank_ammo[i] = 100;
2068 shipp->weapons.secondary_bank_ammo[i] = 0;
2071 swp->secondary_bank_ammo[i] = 0;
2072 swp->secondary_next_slot[i] = 0;
2073 swp->next_secondary_fire_stamp[i] = timestamp(0);
2074 swp->secondary_bank_rearm_time[i] = timestamp(0); // will be able to rearm this bank immediately
2077 for ( i = 0; i < sip->num_secondary_banks; i++ ) {
2079 weapon_size = Weapon_info[sip->secondary_bank_weapons[i]].cargo_size;
2080 SDL_assert( weapon_size > 0.0f );
2082 swp->secondary_bank_ammo[i] = 100;
2084 swp->secondary_bank_ammo[i] = fl2i(sip->secondary_bank_ammo_capacity[i] / weapon_size + 0.5f );
2088 swp->current_primary_bank = -1;
2089 swp->current_secondary_bank = -1;
2092 if ( sip->num_primary_banks > 0 ) {
2093 if ( swp->primary_bank_weapons[BANK_1] >= 0 ) {
2094 swp->current_primary_bank = BANK_1;
2096 swp->current_primary_bank = -1;
2100 swp->current_primary_bank = -1;
2103 if ( sip->num_secondary_banks > 0 ) {
2104 if ( swp->secondary_bank_weapons[BANK_1] >= 0 ) {
2105 swp->current_secondary_bank = BANK_1;
2107 swp->current_secondary_bank = -1;
2111 swp->current_secondary_bank = -1;
2114 shipp->current_cmeasure = 0;
2116 ets_init_ship(objp); // init ship fields that are used for the ETS
2118 physics_ship_init(objp);
2120 objp->shields[0] = 100.0f;
2122 set_shield_strength(objp, sip->shields);
2124 shipp->target_shields_delta = 0.0f;
2125 shipp->target_weapon_energy_delta = 0.0f;
2127 ai_object_init(objp, shipp->ai_index);
2128 shipp->weapons.ai_class = Ai_info[shipp->ai_index].ai_class;
2129 shipp->shield_integrity = NULL;
2130 // shipp->sw.blast_duration = -1; // init shockwave struct
2132 shipp->orders_accepted = ship_get_default_orders_accepted( sip );
2133 shipp->num_swarm_missiles_to_fire = 0;
2134 shipp->num_turret_swarm_info = 0;
2135 shipp->death_roll_snd = -1;
2136 shipp->thruster_bitmap = -1;
2137 shipp->thruster_frame = 0.0f;
2138 shipp->thruster_glow_bitmap = -1;
2139 shipp->thruster_glow_noise = 1.0f;
2140 shipp->thruster_glow_frame = 0.0f;
2141 shipp->next_engine_stutter = 1;
2142 shipp->persona_index = -1;
2143 shipp->flags |= SF_ENGINES_ON;
2144 shipp->subsys_disrupted_flags=0;
2145 shipp->subsys_disrupted_check_timestamp=timestamp(0);
2147 // swarm missile stuff
2148 shipp->next_swarm_fire = 1;
2150 // corkscrew missile stuff
2151 shipp->next_corkscrew_fire = 1;
2154 shipp->score = sip->score;
2157 shipp->tag_left = -1.0f;
2158 shipp->level2_tag_left = -1.0f;
2160 // multiplayer field initializations
2161 for (i = 0; i < MAX_PLAYERS; i++ ) {
2162 shipp->np_updates[i].update_stamp = -1;
2163 shipp->np_updates[i].status_update_stamp = -1;
2164 shipp->np_updates[i].subsys_update_stamp = -1;
2165 shipp->np_updates[i].seq = 0;
2167 extern int oo_arrive_time_count[MAX_SHIPS];
2168 extern int oo_interp_count[MAX_SHIPS];
2169 oo_arrive_time_count[shipp - Ships] = 0;
2170 oo_interp_count[shipp - Ships] = 0;
2172 shipp->special_warp_objnum = -1;
2174 // set awacs warning flags so awacs ship only asks for help once at each level
2175 shipp->awacs_warning_flag = AWACS_WARN_NONE;
2178 // function which recalculates the overall strength of subsystems. Needed because
2179 // several places in FreeSpace change subsystem strength and all this data needs to
2180 // be kept up to date.
2181 void ship_recalc_subsys_strength( ship *shipp )
2184 ship_subsys *ship_system;
2186 // fill in the subsys_info fields for all particular types of subsystems
2187 // make the current strength be 1.0. If there are initial conditions on the ship, then
2188 // the mission parse code should take care of setting that.
2189 for (i = 0; i < SUBSYSTEM_MAX; i++) {
2190 shipp->subsys_info[i].num = 0;
2191 shipp->subsys_info[i].total_hits = 0.0f;
2192 shipp->subsys_info[i].current_hits = 0.0f;
2195 // count all of the subsystems of a particular type. For each generic type of subsystem, we store the
2196 // total count of hits. (i.e. for 3 engines, we store the sum of the max_hits for each engine)
2197 for ( ship_system = GET_FIRST(&shipp->subsys_list); ship_system != END_OF_LIST(&shipp->subsys_list); ship_system = GET_NEXT(ship_system) ) {
2200 type = ship_system->system_info->type;
2201 SDL_assert ( (type >= 0) && (type < SUBSYSTEM_MAX) );
2202 shipp->subsys_info[type].num++;
2203 shipp->subsys_info[type].total_hits += ship_system->system_info->max_hits;
2204 shipp->subsys_info[type].current_hits += ship_system->current_hits;
2207 // set any ship flags which should be set. unset the flags since we might be repairing a subsystem
2208 // through sexpressions.
2209 shipp->flags &= ~SF_DISABLED;
2210 if ( (shipp->subsys_info[SUBSYSTEM_ENGINE].num > 0) && (shipp->subsys_info[SUBSYSTEM_ENGINE].current_hits == 0.0f) ){
2211 shipp->flags |= SF_DISABLED;
2215 shipp->flags &= ~SF_DISARMED;
2216 if ( (shipp->subsys_info[SUBSYSTEM_TURRET].num > 0) && (shipp->subsys_info[SUBSYSTEM_TURRET].current_hits == 0.0f) ){
2217 shipp->flags |= SF_DISARMED;
2222 // routine to possibly fixup the model subsystem information for this ship pointer. Needed when
2223 // ships share the same model.
2224 void ship_copy_subsystem_fixup(ship_info *sip)
2228 model_num = sip->modelnum;
2230 // since we allow a model file to be shared between several ships, we must check to be sure that our
2231 // subsystems have been loaded properly
2233 subsystems_needed = 0;
2234 for (i = 0; i < sip->n_subsystems; i++ ) {
2235 if ( sip->subsystems[i].model_num == -1 ){
2236 subsystems_needed++;
2241 // if we need to get information for all our subsystems, we need to find another ship with the same model
2242 // number as our own and that has the model information
2243 // if ( subsystems_needed == sip->n_subsystems ) {
2244 for ( i = 0; i < Num_ship_types; i++ ) {
2245 model_subsystem *msp;
2247 if ( (Ship_info[i].modelnum != model_num) || (&Ship_info[i] == sip) ){
2251 // see if this ship has subsystems and a model for the subsystems. We only need check the first
2252 // subsystem since previous error checking would have trapped it's loading as an error.
2253 SDL_assert( Ship_info[i].n_subsystems == sip->n_subsystems );
2255 msp = &Ship_info[i].subsystems[0];
2256 model_copy_subsystems( sip->n_subsystems, &(sip->subsystems[0]), msp );
2257 sip->flags |= SIF_PATH_FIXUP;
2265 // ignore_subsys_info => default parameter with value of 0. This is
2266 // only set to 1 by the save/restore code
2267 void subsys_set(int objnum, int ignore_subsys_info)
2269 ship *shipp = &Ships[Objects[objnum].instance];
2270 ship_info *sinfo = &Ship_info[Ships[Objects[objnum].instance].ship_info_index];
2271 model_subsystem *sp;
2272 ship_subsys *ship_system;
2275 // set up the subsystems for this ship. walk through list of subsystems in the ship-info array.
2276 // for each subsystem, get a new ship_subsys instance and set up the pointers and other values
2277 list_init ( &shipp->subsys_list ); // initialize the ship's list of subsystems
2278 for ( i = 0; i < sinfo->n_subsystems; i++ ) {
2280 sp = &(sinfo->subsystems[i]);
2281 if ( sp->model_num == -1 ) {
2282 Warning (LOCATION, "Invalid subobj_num or model_num in subsystem %s on ship type %s.\nNot linking into ship!\n\n(This warning means that a subsystem was present in ships.tbl and not present in the model\nit should probably be removed from the model.)\n", sp->subobj_name, sinfo->name );
2286 // set up the linked list
2287 ship_system = GET_FIRST( &ship_subsys_free_list ); // get a new element from the ship_subsystem array
2288 SDL_assert ( ship_system != &ship_subsys_free_list ); // shouldn't have the dummy element
2289 list_remove( &ship_subsys_free_list, ship_system ); // remove the element from the array
2290 list_append( &shipp->subsys_list, ship_system ); // link the element into the ship
2292 ship_system->system_info = sp; // set the system_info pointer to point to the data read in from the model
2293 if ( !Fred_running ){
2294 ship_system->current_hits = sp->max_hits; // set the max hits
2296 ship_system->current_hits = 0.0f; // Jason wants this to be 0 in Fred.
2298 ship_system->turret_next_fire_stamp = timestamp(0);
2299 ship_system->turret_next_enemy_check_stamp = timestamp(0);
2300 ship_system->turret_enemy_objnum = -1;
2301 ship_system->turret_next_fire_stamp = timestamp((int) frand_range(1.0f, 500.0f)); // next time this turret can fire
2302 ship_system->turret_last_fire_direction = sp->turret_norm;
2303 ship_system->turret_next_fire_pos = 0;
2304 ship_system->turret_time_enemy_in_range = 0.0f;
2305 ship_system->disruption_timestamp=timestamp(0);
2306 ship_system->turret_pick_big_attack_point_timestamp = timestamp(0);
2307 vm_vec_zero(&ship_system->turret_big_attack_point);
2308 ship_system->subsys_cargo_name = -1;
2309 ship_system->subsys_cargo_revealed = 0;
2312 ship_system->weapons.flags = 0;
2315 for (k=0; k<MAX_PRIMARY_BANKS; k++){
2316 if (sp->primary_banks[k] != -1) {
2317 ship_system->weapons.primary_bank_weapons[j] = sp->primary_banks[k];
2318 ship_system->weapons.next_primary_fire_stamp[j++] = 0;
2322 ship_system->weapons.num_primary_banks = j;
2325 for (k=0; k<MAX_SECONDARY_BANKS; k++){
2326 if (sp->secondary_banks[k] != -1) {
2327 ship_system->weapons.secondary_bank_weapons[j] = sp->secondary_banks[k];
2328 ship_system->weapons.secondary_bank_capacity[j] = sp->secondary_bank_capacity[k];
2329 ship_system->weapons.next_secondary_fire_stamp[j++] = timestamp(0);
2333 ship_system->weapons.num_secondary_banks = j;
2334 ship_system->weapons.current_primary_bank = -1;
2335 ship_system->weapons.current_secondary_bank = -1;
2337 for (k=0; k<MAX_SECONDARY_BANKS; k++) {
2338 ship_system->weapons.secondary_bank_ammo[k] = (Fred_running ? 100 : ship_system->weapons.secondary_bank_capacity[k]);
2340 ship_system->weapons.secondary_next_slot[k] = 0;
2343 ship_system->weapons.last_fired_weapon_index = -1;
2344 ship_system->weapons.last_fired_weapon_signature = -1;
2345 ship_system->weapons.detonate_weapon_time = -1;
2346 ship_system->weapons.ai_class = sinfo->ai_class; // assume ai class of ship for turret
2348 // rapid fire (swarm) stuff
2349 ship_system->turret_swarm_info_index = -1;
2352 ship_system->awacs_intensity = sp->awacs_intensity;
2353 ship_system->awacs_radius = sp->awacs_radius;
2354 if (ship_system->awacs_intensity > 0) {
2355 ship_system->system_info->flags |= MSS_FLAG_AWACS;
2358 // turn_rate, turn_accel
2359 // model_set_instance_info
2360 float turn_accel = 0.5f;
2361 model_set_instance_info(&ship_system->submodel_info_1, sp->turn_rate, turn_accel);
2363 // model_clear_instance_info( &ship_system->submodel_info_1 );
2364 model_clear_instance_info( &ship_system->submodel_info_2 );
2367 if ( !ignore_subsys_info ) {
2368 ship_recalc_subsys_strength( shipp );
2375 // Render docking information, NOT while in object's reference frame.
2376 void render_dock_bays(object *objp)
2382 sip = &Ship_info[Ships[objp->instance].ship_info_index];
2383 pm = model_get( sip->modelnum );
2385 if (pm->docking_bays == NULL)
2388 if (pm->docking_bays[0].num_slots != 2)
2391 db = &pm->docking_bays[0];
2394 vector p0, p1, p2, p3, nr;
2396 vm_vec_unrotate(&p0, &db->pnt[0], &objp->orient);
2397 vm_vec_add2(&p0, &objp->pos);
2398 g3_rotate_vertex(&v0, &p0);
2400 vm_vec_unrotate(&p1, &db->pnt[1], &objp->orient);
2401 vm_vec_add2(&p1, &objp->pos);
2402 g3_rotate_vertex(&v1, &p1);
2404 gr_set_color(255, 0, 0);
2405 g3_draw_line(&v0, &v1);
2407 vm_vec_avg(&p2, &p0, &p1);
2409 vm_vec_unrotate(&nr, &db->norm[0], &objp->orient);
2410 vm_vec_scale_add(&p3, &p2, &nr, 10.0f);
2412 g3_rotate_vertex(&v0, &p2);
2413 g3_rotate_vertex(&v1, &p3);
2414 gr_set_color(255, 255, 0);
2415 g3_draw_line(&v0, &v1);
2416 g3_draw_sphere(&v1, 1.25f);
2422 int Ship_shadows = 0;
2424 DCF_BOOL( ship_shadows, Ship_shadows );
2426 MONITOR( NumShipsRend );
2428 int Show_shield_hits = 0;
2429 DCF_BOOL( show_shield_hits, Show_shield_hits );
2431 int Show_tnorms = 0;
2432 DCF_BOOL( show_tnorms, Show_tnorms );
2435 DCF_BOOL( show_paths, Show_paths );
2437 int Show_fpaths = 0;
2438 DCF_BOOL( show_fpaths, Show_fpaths );
2440 void ship_render(object * obj)
2446 num = obj->instance;
2448 SDL_assert( num >= 0);
2451 // show target when attacking big ship
2452 vector temp, target;
2453 ai_info *aip = &Ai_info[Ships[obj->instance].ai_index];
2454 if ( (aip->target_objnum >= 0) && (Ship_info[Ships[Objects[aip->target_objnum].instance].ship_info_index].flags & (SIF_SUPERCAP|SIF_CAPITAL|SIF_CRUISER)) ) {
2455 vm_vec_unrotate(&temp, &aip->big_attack_point, &Objects[aip->target_objnum].orient);
2456 vm_vec_add(&target, &temp, &Objects[aip->target_objnum].pos);
2459 gr_set_color(128,0,0);
2460 g3_rotate_vertex( &v0, &obj->pos );
2461 g3_rotate_vertex( &v1, &target );
2463 g3_draw_line(&v0, &v1);
2465 g3_draw_sphere(&v1, 5.0f);
2470 // if (Ships[num].subtype == SHIP_PLAYER ) return;
2471 if ( obj == Viewer_obj ) {
2472 if (ship_show_velocity_dot && (obj==Player_obj) ) {
2476 vm_vec_scale_add( &v, &obj->phys_info.vel, &obj->orient.v.fvec, 3.0f );
2477 vm_vec_normalize( &v );
2480 vm_vec_scale_add( &p0, &obj->pos, &v, 20.0f);
2482 g3_rotate_vertex( &v0, &p0 );
2484 gr_set_color(0,128,0);
2485 g3_draw_sphere( &v0, 0.1f );
2488 // Show the shield hit effect for the viewer.
2489 if ( Show_shield_hits ) {
2490 shipp = &Ships[num];
2491 if (shipp->shield_hits) {
2492 create_shield_explosion_all(obj);
2493 shipp->shield_hits = 0;
2500 MONITOR_INC( NumShipsRend, 1 );
2502 shipp = &Ships[num];
2503 si = &Ship_info[Ships[num].ship_info_index];
2505 // Make ships that are warping in not render during stage 1
2506 if ( shipp->flags & SF_ARRIVING_STAGE_1 ){
2510 if ( Ship_shadows && shipfx_in_shadow( obj ) ) {
2511 light_set_shadow(1);
2513 light_set_shadow(0);
2516 ship_model_start(obj);
2518 uint render_flags = MR_NORMAL;
2520 // Turn off model caching for the player ship in external view.
2521 if (obj == Player_obj) {
2522 render_flags |= MR_ALWAYS_REDRAW;
2525 // Turn off model caching if this is the player's target.
2526 if ( Player_ai->target_objnum == OBJ_INDEX(obj)) {
2527 render_flags |= MR_ALWAYS_REDRAW;
2531 if(Show_paths || Show_fpaths){
2532 render_flags |= MR_BAY_PATHS;
2536 // Only render electrical arcs if within 500m of the eye (for a 10m piece)
2537 if ( vm_vec_dist_quick( &obj->pos, &Eye_position ) < obj->radius*50.0f ) {
2539 for (i=0; i<MAX_SHIP_ARCS; i++ ) {
2540 if ( timestamp_valid( shipp->arc_timestamp[i] ) ) {
2541 render_flags |= MR_ALWAYS_REDRAW; // Turn off model caching if arcing.
2542 model_add_arc( shipp->modelnum, -1, &shipp->arc_pts[i][0], &shipp->arc_pts[i][1], shipp->arc_type[i] );
2547 if ( shipp->large_ship_blowup_index > -1 ) {
2548 shipfx_large_blowup_render(shipp);
2551 // ship_get_subsystem_strength( shipp, SUBSYSTEM_ENGINE)>ENGINE_MIN_STR
2553 if ( (shipp->thruster_bitmap > -1) && (!(shipp->flags & SF_DISABLED)) && (!ship_subsys_disrupted(shipp, SUBSYSTEM_ENGINE)) ) {
2556 // Add noise to thruster geometry.
2557 ft = obj->phys_info.forward_thrust;
2558 ft *= (1.0f + frand()/5.0f - 1.0f/10.0f);
2562 model_set_thrust( shipp->modelnum, ft, shipp->thruster_bitmap, shipp->thruster_glow_bitmap, shipp->thruster_glow_noise );
2563 render_flags |= MR_SHOW_THRUSTERS;
2566 // fill the model flash lighting values in
2567 shipfx_flash_light_model( obj, shipp );
2569 object *docked_objp = NULL;
2570 ship * docked_shipp = NULL;
2571 ship * warp_shipp = shipp;
2573 // check to see if departing ship is docked with anything.
2574 docked_objp = ai_find_docked_object( obj );
2575 if ( docked_objp ) {
2576 docked_shipp = &Ships[docked_objp->instance];
2578 if ( docked_shipp->flags & (SF_DEPART_WARP|SF_ARRIVING) ) {
2579 warp_shipp = docked_shipp;
2583 // Warp_shipp points to the ship that is going through a
2584 // warp... either this ship or the ship it is docked with.
2586 // If the ship is going "through" the warp effect, then
2587 // set up the model renderer to only draw the polygons in front
2588 // of the warp in effect
2589 int clip_started = 0;
2591 if ( warp_shipp->flags & (SF_ARRIVING|SF_DEPART_WARP) ) {
2594 g3_start_user_clip_plane( &warp_shipp->warp_effect_pos, &warp_shipp->warp_effect_fvec );
2596 // Turn off model caching while going thru warp effect.
2597 render_flags |= MR_ALWAYS_REDRAW;
2600 // maybe set squad logo bitmap
2601 model_set_insignia_bitmap(-1);
2602 if(Game_mode & GM_MULTIPLAYER){
2603 // if its any player's object
2604 int np_index = multi_find_player_by_object( obj );
2605 if((np_index >= 0) && (np_index < MAX_PLAYERS) && MULTI_CONNECTED(Net_players[np_index]) && (Net_players[np_index].player != NULL)){
2606 model_set_insignia_bitmap(Net_players[np_index].player->insignia_texture);
2609 // in single player, we want to render model insignias on all ships in alpha beta and gamma
2611 // if its an object in my squadron
2612 if(ship_in_abgz(shipp)){
2613 model_set_insignia_bitmap(Player->insignia_texture);
2617 // maybe disable lighting
2618 // if((The_mission.flags & MISSION_FLAG_FULLNEB) && (neb2_get_fog_intensity(obj) > 0.33f) && (si->flags & SIF_SMALL_SHIP)){
2619 // render_flags |= MR_NO_LIGHTING;
2623 if(The_mission.flags & MISSION_FLAG_FULLNEB){
2624 extern void model_set_fog_level(float l);
2625 model_set_fog_level(neb2_get_fog_intensity(obj));
2629 if((The_mission.flags & MISSION_FLAG_FULLNEB) && (si->flags & SIF_SMALL_SHIP)){
2630 // force detail levels
2631 float fog_val = neb2_get_fog_intensity(obj);
2632 if(fog_val >= 0.6f){
2633 model_set_detail_level(2);
2634 model_render( shipp->modelnum, &obj->orient, &obj->pos, render_flags | MR_LOCK_DETAIL, OBJ_INDEX(obj) );
2636 model_render( shipp->modelnum, &obj->orient, &obj->pos, render_flags, OBJ_INDEX(obj) );
2639 model_render( shipp->modelnum, &obj->orient, &obj->pos, render_flags, OBJ_INDEX(obj) );
2642 // always turn off fog after rendering a ship
2643 gr_fog_set(GR_FOGMODE_NONE, 0, 0, 0, -1.0f, -1.0f);
2645 light_set_shadow(0);
2648 if (Show_shield_mesh)
2649 ship_draw_shield( obj); // Render the shield.
2652 if ( clip_started ) {
2653 g3_stop_user_clip_plane();
2657 /* if (Mc.shield_hit_tri != -1) {
2658 //render_shield_explosion(model_num, orient, pos, &Hit_point, Hit_tri);
2659 Mc.shield_hit_tri = -1;
2663 ship_model_stop(obj);
2665 if (shipp->shield_hits) {
2666 create_shield_explosion_all(obj);
2667 shipp->shield_hits = 0;
2671 if (Ai_render_debug_flag || Show_paths) {
2672 if ( shipp->ai_index != -1 ){
2673 render_path_points(obj);
2676 render_dock_bays(obj);
2682 ship_subsys *systemp;
2683 vector tpos, tnorm, temp;
2687 gr_set_color(0, 0, 255);
2688 systemp = GET_FIRST( &shipp->subsys_list );
2689 while ( systemp != END_OF_LIST(&shipp->subsys_list) ) {
2690 ship_get_global_turret_gun_info(obj, systemp, &tpos, &tnorm, 1, &temp);
2693 vm_vec_scale_add(&v2, &v1, &tnorm, 20.0f);
2695 g3_rotate_vertex(&l1, &v1);
2696 g3_rotate_vertex(&l2, &v2);
2698 g3_draw_sphere(&l1, 2.0f);
2699 g3_draw_line(&l1, &l2);
2701 systemp = GET_NEXT(systemp);
2707 void ship_subsystem_delete(ship *shipp)
2709 ship_subsys *systemp, *temp;
2711 systemp = GET_FIRST( &shipp->subsys_list );
2712 while ( systemp != END_OF_LIST(&shipp->subsys_list) ) {
2713 temp = GET_NEXT( systemp ); // use temporary since pointers will get screwed with next operation
2714 list_remove( &shipp->subsys_list, systemp ); // remove the element
2715 list_append( &ship_subsys_free_list, systemp ); // and place back onto free list
2716 systemp = temp; // use the temp variable to move right along
2720 void ship_delete( object * obj )
2725 num = obj->instance;
2726 SDL_assert( num >= 0);
2728 SDL_assert( Ships[num].objnum == OBJ_INDEX(obj) );
2730 shipp = &Ships[num];
2732 if (shipp->ai_index != -1){
2733 ai_free_slot(shipp->ai_index);
2736 // free up the list of subsystems of this ship. walk through list and move remaining subsystems
2737 // on ship back to the free list for other ships to use.
2738 ship_subsystem_delete(&Ships[num]);
2741 // mwa 11/24/97 num_ships--;
2743 if (model_get(shipp->modelnum)->shield.ntris) {
2744 free(shipp->shield_integrity);
2745 shipp->shield_integrity = NULL;
2748 if ( shipp->ship_list_index != -1 ) {
2749 ship_obj_list_remove(shipp->ship_list_index);
2750 shipp->ship_list_index = -1;
2753 free_sexp2(shipp->arrival_cue);
2754 free_sexp2(shipp->departure_cue);
2756 // call the contrail system
2757 ct_ship_delete(shipp);
2760 // function used by ship_destroyed and ship_departed which is called if the ship
2761 // is in a wing. This function updates the ship_index list (i.e. removes it's
2762 // entry in the list), and packs the array accordingly.
2763 void ship_wing_cleanup( int shipnum, wing *wingp )
2765 int i, index = -1, team;
2767 team = Ships[shipnum].team;
2768 // compress the ship_index array and mark the last entry with a -1
2769 for (i = 0; i < wingp->current_count; i++ ) {
2770 if ( wingp->ship_index[i] == shipnum ) {
2776 // SDL_assert(index != -1);
2778 // this can happen in multiplayer (dogfight, ingame join specifically)
2783 for ( i = index; i < wingp->current_count - 1; i++ ){
2784 wingp->ship_index[i] = wingp->ship_index[i+1];
2787 wingp->current_count--;
2788 SDL_assert ( wingp->current_count >= 0 );
2789 wingp->ship_index[wingp->current_count] = -1;
2791 // if the current count is 0, check to see if the wing departed or was destroyed.
2792 if ( wingp->current_count == 0 ) {
2794 // if this wing was ordered to depart by the player, set the current_wave equal to the total
2795 // waves so we can mark the wing as gone and no other ships arrive
2796 if ( wingp->flags & WF_DEPARTURE_ORDERED )
2797 wingp->current_wave = wingp->num_waves;
2799 // first, be sure to mark a wing destroyed event if all members of wing were destroyed and on
2800 // the last wave. This circumvents a problem where the wing could be marked as departed and
2801 // destroyed if the last ships were destroyed after the wing's departure cue became true.
2803 // if the wing wasn't destroyed, and it is departing, then mark it as departed -- in this
2804 // case, there had better be ships in this wing with departure entries in the log file. The
2805 // logfile code checks for this case.
2806 if ( (wingp->current_wave == wingp->num_waves) && (wingp->total_destroyed == wingp->total_arrived_count) ) {
2807 mission_log_add_entry(LOG_WING_DESTROYED, wingp->name, NULL, team);
2808 wingp->flags |= WF_WING_GONE;
2809 wingp->time_gone = Missiontime;
2810 } else if ( (wingp->flags & WF_WING_DEPARTING) || (wingp->current_wave == wingp->num_waves) ) {
2815 // apparently, there have been reports of ships still present in the mission when this log
2816 // entry if written. Do a sanity check here to find out for sure.
2817 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
2819 // skip the player -- stupid special case.
2820 if ( &Objects[so->objnum] == Player_obj )
2823 if ( (Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_INGAME_JOIN) )
2826 if ( (Ships[Objects[so->objnum].instance].wingnum == WING_INDEX(wingp)) && !(Ships[Objects[so->objnum].instance].flags & (SF_DEPARTING|SF_DYING)) )
2831 if ( wingp->flags & (WF_WING_DEPARTING|WF_DEPARTURE_ORDERED) )
2832 mission_log_add_entry(LOG_WING_DEPART, wingp->name, NULL, team);
2834 wingp->flags |= WF_WING_GONE;
2835 wingp->time_gone = Missiontime;
2840 // function to do management, like log entries and wing cleanup after a ship has been destroyed
2842 void ship_destroyed( int num )
2846 shipp = &Ships[num];
2848 // add the information to the exited ship list
2849 ship_add_exited_ship( shipp, SEF_DESTROYED );
2851 // determine if we need to count this ship as a klll in counting number of kills per ship type
2852 // look at the ignore flag for the ship (if not in a wing), or the ignore flag for the wing
2853 // (if the ship is in a wing), and add to the kill count if the flags are not set
2854 if ( !(shipp->flags & SF_IGNORE_COUNT) || ((shipp->wingnum != -1) && !(Wings[shipp->wingnum].flags & WF_IGNORE_COUNT)) )
2855 ship_add_ship_type_kill_count( Ship_info[shipp->ship_info_index].flags );
2857 // if ship belongs to a wing -- increment the total number of ships in the wing destroyed
2858 if ( shipp->wingnum != -1 ) {
2861 wingp = &Wings[shipp->wingnum];
2862 wingp->total_destroyed++;
2863 ship_wing_cleanup( num, wingp );
2866 // Note, this call to ai_ship_destroy must come after ship_wing_cleanup for guarded wings to
2867 // properly note the destruction of a ship in their wing.
2868 if ( shipp->ai_index != -1 ) {
2869 ai_ship_destroy(num, SEF_DESTROYED); // Do AI stuff for destruction of ship.
2872 nprintf(("Alan","SHIP DESTROYED: %s\n", shipp->ship_name));
2874 if ( (shipp->wing_status_wing_index >= 0) && (shipp->wing_status_wing_pos >= 0) ) {
2875 nprintf(("Alan","STATUS UPDATED: %s\n", shipp->ship_name));
2876 hud_set_wingman_status_dead(shipp->wing_status_wing_index, shipp->wing_status_wing_pos);
2879 // let the event music system know a hostile was destoyed (important for deciding when to transition from battle to normal music)
2880 if (Player_ship != NULL) {
2881 if (shipp->team != Player_ship->team) {
2882 event_music_hostile_ship_destroyed();
2887 void ship_vanished(int num)
2894 if(Game_mode & GM_DEMO_RECORD){
2895 demo_POST_departed(Objects[Ships[num].objnum].signature, Ships[num].flags);
2898 // add the information to the exited ship list
2899 ship_add_exited_ship( sp, SEF_DEPARTED );
2901 // update wingman status gauge
2902 if ( (sp->wing_status_wing_index >= 0) && (sp->wing_status_wing_pos >= 0) ) {
2903 hud_set_wingman_status_departed(sp->wing_status_wing_index, sp->wing_status_wing_pos);
2906 ai_ship_destroy(num, SEF_DEPARTED); // should still do AI cleanup after ship has departed
2909 void ship_departed( int num )
2917 if(Game_mode & GM_DEMO_RECORD){
2918 demo_POST_departed(Objects[Ships[num].objnum].signature, Ships[num].flags);
2921 // add the information to the exited ship list
2922 ship_add_exited_ship( sp, SEF_DEPARTED );
2924 // update wingman status gauge
2925 if ( (sp->wing_status_wing_index >= 0) && (sp->wing_status_wing_pos >= 0) ) {
2926 hud_set_wingman_status_departed(sp->wing_status_wing_index, sp->wing_status_wing_pos);
2929 // see if this ship departed within the radius of a jump node -- if so, put the node name into
2930 // the secondary mission log field
2931 for ( i = 0; i < Num_jump_nodes; i++ ) {
2933 vector ship_pos, node_pos;
2935 ship_pos = Objects[sp->objnum].pos;
2936 node_pos = Objects[Jump_nodes[i].objnum].pos;
2937 radius = model_get_radius( Jump_nodes[i].modelnum );
2938 dist = vm_vec_dist( &ship_pos, &node_pos );
2939 if ( dist <= radius ) {
2940 mission_log_add_entry(LOG_SHIP_DEPART, sp->ship_name, Jump_nodes[i].name, sp->wingnum);
2945 if ( i == Num_jump_nodes ){
2946 mission_log_add_entry(LOG_SHIP_DEPART, sp->ship_name, NULL, sp->wingnum);
2949 ai_ship_destroy(num, SEF_DEPARTED); // should still do AI cleanup after ship has departed
2951 // don't bother doing this for demo playback - we don't keep track of wing info
2952 if(!(Game_mode & GM_DEMO_PLAYBACK)){
2953 if ( sp->wingnum != -1 ) {
2956 wingp = &Wings[sp->wingnum];
2957 wingp->total_departed++;
2958 ship_wing_cleanup( num, wingp );
2963 // --------------------------------------------------------------------------------------------------------------------
2964 // ship_explode_area_calc_damage
2966 // input pos1 => ship explosion position
2967 // pos2 => other ship position
2968 // inner_rad => distance from ship center for which full damage is applied
2969 // outer_rad => distance from ship center for which no damage is applied
2970 // max_damage => maximum damage applied
2971 // max_blast => maximum impulse applied from blast
2973 // calculates the blast and damage applied to a ship from another ship blowing up.
2975 int ship_explode_area_calc_damage( vector *pos1, vector *pos2, float inner_rad, float outer_rad, float max_damage, float max_blast, float *damage, float *blast )
2979 dist = vm_vec_dist_quick( pos1, pos2 );
2981 // check outside outer radius
2982 if ( dist > outer_rad )
2985 if ( dist < inner_rad ) {
2986 // check insider inner radius
2987 *damage = max_damage;
2990 // between inner and outer
2991 float fraction = 1.0f - (dist - inner_rad) / (outer_rad - inner_rad);
2992 *damage = fraction * max_damage;
2993 *blast = fraction * max_blast;
2999 // --------------------------------------------------------------------------------------------------------------------
3000 // ship_blow_up_area_apply_blast
3001 // this function applies damage to ship close to others when a ship dies and blows up
3003 // inputs: objp => ship object pointers
3004 // pos => position of the ship when it finally blows up
3005 // inner_rad => distance from ship center for which full damage is applied
3006 // outer_rad => distance from ship center for which no damage is applied
3007 // damage => maximum damage applied
3008 // blast => maximum impulse applied from blast
3010 void ship_blow_up_area_apply_blast( object *exp_objp)
3013 SDL_assert( exp_objp->type == OBJ_SHIP );
3014 float inner_rad, outer_rad, max_damage, max_blast, shockwave_speed;
3015 shockwave_create_info sci;
3017 // No area explosion in training missions.
3018 if (The_mission.game_type & MISSION_TYPE_TRAINING){
3022 if ((exp_objp->hull_strength <= KAMIKAZE_HULL_ON_DEATH) && (Ai_info[Ships[exp_objp->instance].ai_index].ai_flags & AIF_KAMIKAZE) && (Ships[exp_objp->instance].special_exp_index < 0)) {
3023 float override = Ai_info[Ships[exp_objp->instance].ai_index].kamikaze_damage;
3025 inner_rad = exp_objp->radius*2.0f;
3026 outer_rad = exp_objp->radius*4.0f; // + (override * 0.3f);
3027 max_damage = override;
3028 max_blast = override * 5.0f;
3029 shockwave_speed = 100.0f;
3031 sip = &Ship_info[Ships[exp_objp->instance].ship_info_index];
3033 if (Ships[exp_objp->instance].special_exp_index != -1) {
3034 int start = Ships[exp_objp->instance].special_exp_index;
3036 inner_rad = (float) atoi(Sexp_variables[start+INNER_RAD].text);
3037 outer_rad = (float) atoi(Sexp_variables[start+OUTER_RAD].text);
3038 max_damage = (float) atoi(Sexp_variables[start+DAMAGE].text);
3039 max_blast = (float) atoi(Sexp_variables[start+BLAST].text);
3040 propagates = atoi(Sexp_variables[start+PROPAGATE].text);
3042 shockwave_speed = (float) atoi(Sexp_variables[start+SHOCK_SPEED].text);
3044 shockwave_speed = 0.0f;
3047 inner_rad = sip->inner_rad;
3048 outer_rad = sip->outer_rad;
3049 max_damage = sip->damage;
3050 max_blast = sip->blast;
3051 shockwave_speed = sip->shockwave_speed;
3055 // nprintf(("AI", "Frame %i: Area effect blast from ship %s\n", Framecount, Ships[exp_objp->instance].ship_name));
3057 // account for ships that give no damage when they blow up.
3058 if ( (max_damage < 0.1f) && (max_blast < 0.1f) ){
3062 if ( shockwave_speed > 0 ) {
3063 sci.inner_rad = inner_rad;
3064 sci.outer_rad = outer_rad;
3065 sci.blast = max_blast;
3066 sci.damage = max_damage;
3067 sci.speed = shockwave_speed;
3068 sci.rot_angle = frand_range(0.0f, 359.0f);
3069 shipfx_do_shockwave_stuff(&Ships[exp_objp->instance], &sci);
3070 // shockwave_create(Ships[exp_objp->instance].objnum, &exp_objp->pos, shockwave_speed, inner_rad, outer_rad, max_damage, max_blast, SW_SHIP_DEATH);
3074 float damage = 0.0f;
3075 for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
3076 if ( (objp->type != OBJ_SHIP) && (objp->type != OBJ_ASTEROID) ) {
3080 if ( objp == exp_objp ){
3084 // don't blast navbuoys
3085 if ( objp->type == OBJ_SHIP ) {
3086 if ( ship_get_SIF(objp->instance) & SIF_NAVBUOY ) {
3091 if ( ship_explode_area_calc_damage( &exp_objp->pos, &objp->pos, inner_rad, outer_rad, max_damage, max_blast, &damage, &blast ) == -1 ){
3095 switch ( objp->type ) {
3097 ship_apply_global_damage( objp, exp_objp, &exp_objp->pos, damage );
3098 vector force, vec_ship_to_impact;
3099 vm_vec_sub( &vec_ship_to_impact, &objp->pos, &exp_objp->pos );
3100 vm_vec_copy_normalize( &force, &vec_ship_to_impact );
3101 vm_vec_scale( &force, blast );
3102 ship_apply_whack( &force, &vec_ship_to_impact, objp );
3105 asteroid_hit(objp, NULL, NULL, damage);
3115 void do_dying_undock_physics(object* objp, ship* sp)
3117 SDL_assert(sp->dock_objnum_when_dead >= 0);
3118 if(sp->dock_objnum_when_dead < 0){
3121 object* dock_obj = &Objects[sp->dock_objnum_when_dead];
3124 SDL_assert(objp->type == OBJ_SHIP);
3125 SDL_assert(dock_obj->type == OBJ_SHIP);
3126 if((objp->type != OBJ_SHIP) || (dock_obj->type != OBJ_SHIP)){
3130 float damage = 0.2f*Ship_info[sp->ship_info_index].initial_hull_strength;
3131 ship_apply_global_damage(dock_obj, objp, &objp->pos, damage);
3134 vector impulse_norm, impulse_vec, pos;
3135 vm_vec_sub(&impulse_norm, &dock_obj->pos, &objp->pos);
3136 vm_vec_normalize(&impulse_norm);
3137 // set for relative separation velocity of ~30
3138 float impulse_mag = 50.f*dock_obj->phys_info.mass*objp->phys_info.mass/(dock_obj->phys_info.mass + objp->phys_info.mass);
3139 vm_vec_copy_scale(&impulse_vec, &impulse_norm, impulse_mag);
3140 vm_vec_rand_vec_quick(&pos);
3141 vm_vec_scale(&pos, dock_obj->radius);
3142 // apply whack to dock obj
3143 physics_apply_whack(&impulse_vec, &pos, &dock_obj->phys_info, &dock_obj->orient, dock_obj->phys_info.mass);
3144 // enhance rotation of the docked ship
3145 vm_vec_scale(&dock_obj->phys_info.rotvel, 2.0f);
3147 // apply whack to ship
3148 vm_vec_negate(&impulse_vec);
3149 vm_vec_rand_vec_quick(&pos);
3150 vm_vec_scale(&pos, objp->radius);
3151 physics_apply_whack(&impulse_vec, &pos, &objp->phys_info, &objp->orient, objp->phys_info.mass);
3153 // reset dock_objnum_when_dead to -1 for dockee, since docker has blown up.
3154 if (Ships[dock_obj->instance].dock_objnum_when_dead == sp->objnum) {
3155 Ships[dock_obj->instance].dock_objnum_when_dead = -1;
3159 // Do the stuff we do in a frame for a ship that's in its death throes.
3160 void ship_dying_frame(object *objp, int ship_num)
3163 sp = &Ships[ship_num];
3164 int knossos_ship = false;
3166 if ( sp->flags & SF_DYING ) {
3167 knossos_ship = (Ship_info[sp->ship_info_index].flags & SIF_KNOSSOS_DEVICE);
3169 // bash hull value toward 0 (from self destruct)
3170 if (objp->hull_strength > 0) {
3171 int time_left = timestamp_until(sp->final_death_time);
3172 float hits_left = objp->hull_strength;
3174 objp->hull_strength -= hits_left * (1000.0f * flFrametime) / time_left;
3177 // special case of VAPORIZE
3178 if (sp->flags & SF_VAPORIZE) {
3179 // SDL_assert(Ship_info[sp->ship_info_index].flags & SIF_SMALL_SHIP);
3180 if (timestamp_elapsed(sp->final_death_time)) {
3183 snd_play_3d( &Snds[SND_VAPORIZED], &objp->pos, &View_position, objp->radius, NULL, 0, 1.0f, SND_PRIORITY_MUST_PLAY );
3185 // do joystick effect
3186 if (objp == Player_obj) {
3190 // if dying ship is docked, do damage to docked and physics
3191 if (sp->dock_objnum_when_dead != -1) {
3192 do_dying_undock_physics(objp, sp);
3195 // do all accounting for respawning client and server side here.
3196 if (objp == Player_obj) {
3197 gameseq_post_event(GS_EVENT_DEATH_BLEW_UP);
3200 // mark object as dead
3201 objp->flags |= OF_SHOULD_BE_DEAD;
3203 // Don't blow up model. Only use debris shards.
3204 // call ship function to clean up after the ship is destroyed.
3205 ship_destroyed(ship_num);
3212 // bash the desired rotvel
3213 objp->phys_info.desired_rotvel = sp->deathroll_rotvel;
3215 // Do fireballs for Big ship with propagating explostion, but not Kamikaze
3216 if (!(Ai_info[sp->ai_index].ai_flags & AIF_KAMIKAZE) && ship_get_exp_propagates(sp)) {
3217 if ( timestamp_elapsed(Ships[ship_num].next_fireball)) {
3218 vector outpnt, pnt1, pnt2;
3219 polymodel *pm = model_get(sp->modelnum);
3221 // Gets two random points on the surface of a submodel
3222 submodel_get_two_random_points(sp->modelnum, pm->detail[0], &pnt1, &pnt2 );
3224 // vm_vec_avg( &tmp, &pnt1, &pnt2 ); [KNOSSOS get random in plane 1/1.414 in rad
3225 model_find_world_point(&outpnt, &pnt1, sp->modelnum, pm->detail[0], &objp->orient, &objp->pos );
3227 float rad = objp->radius*0.1f;
3228 int fireball_type = FIREBALL_EXPLOSION_LARGE1 + rand()%FIREBALL_NUM_LARGE_EXPLOSIONS;
3229 fireball_create( &outpnt, fireball_type, OBJ_INDEX(objp), rad, 0, &objp->phys_info.vel );
3230 // start the next fireball up in the next 50 - 200 ms (2-3 per frame)
3231 sp->next_fireball = timestamp_rand(333,500);
3233 // do sound - maybe start a random sound, if it has played far enough.
3234 do_sub_expl_sound(objp->radius, &outpnt, sp->sub_expl_sound_handle);
3238 // create little fireballs for knossos as it dies
3240 if ( timestamp_elapsed(Ships[ship_num].next_fireball)) {
3241 vector rand_vec, outpnt; // [0-.7 rad] in plane
3242 vm_vec_rand_vec_quick(&rand_vec);
3243 float scale = -vm_vec_dotprod(&objp->orient.v.fvec, &rand_vec) * (0.9f + 0.2f * frand());
3244 vm_vec_scale_add2(&rand_vec, &objp->orient.v.fvec, scale);
3245 vm_vec_normalize_quick(&rand_vec);
3246 scale = objp->radius * frand() * 0.717f;
3247 vm_vec_scale(&rand_vec, scale);
3248 vm_vec_add(&outpnt, &objp->pos, &rand_vec);
3250 float rad = objp->radius*0.2f;
3251 int fireball_type = FIREBALL_EXPLOSION_LARGE1 + rand()%FIREBALL_NUM_LARGE_EXPLOSIONS;
3252 fireball_create( &outpnt, fireball_type, OBJ_INDEX(objp), rad, 0, &objp->phys_info.vel );
3253 // start the next fireball up in the next 50 - 200 ms (2-3 per frame)
3254 sp->next_fireball = timestamp_rand(333,500);
3257 particle_emitter pe;
3259 pe.num_low = 15; // Lowest number of particles to create
3260 pe.num_high = 30; // Highest number of particles to create
3261 pe.pos = outpnt; // Where the particles emit from
3262 pe.vel = objp->phys_info.vel; // Initial velocity of all the particles
3263 pe.min_life = 2.0f; // How long the particles live
3264 pe.max_life = 12.0f; // How long the particles live
3265 pe.normal = objp->orient.v.uvec; // What normal the particle emit around
3266 pe.normal_variance = 2.0f; // How close they stick to that normal 0=on normal, 1=180, 2=360 degree
3268 pe.max_vel = 350.0f;
3269 pe.min_rad = 30.0f; // * objp->radius;
3270 pe.max_rad = 100.0f; // * objp->radius;
3271 particle_emit( &pe, PARTICLE_SMOKE2, 0, 50 );
3273 // do sound - maybe start a random sound, if it has played far enough.
3274 do_sub_expl_sound(objp->radius, &outpnt, sp->sub_expl_sound_handle);
3279 //nprintf(("AI", "Ship.cpp: Frame=%i, Time = %7.3f, Ship %s will die in %7.3f seconds.\n", Framecount, f2fl(Missiontime), Ships[ship_num].ship_name, (float) timestamp_until(sp->final_death_time)/1000.0f));
3280 int time_until_minor_explosions = timestamp_until(sp->final_death_time);
3282 // Wait until just before death and set off some explosions
3283 // If it is less than 1/2 second until large explosion, but there is
3284 // at least 1/10th of a second left, then create 5 small explosions
3285 if ( (time_until_minor_explosions < 500) && (time_until_minor_explosions > 100) && (!sp->pre_death_explosion_happened) ) {
3286 //mprintf(( "Ship almost dying!!\n" ));
3287 sp->next_fireball = timestamp(-1); // never time out again
3288 sp->pre_death_explosion_happened=1; // Mark this event as having occurred
3290 polymodel *pm = model_get(sp->modelnum);
3292 // Start shockwave for ship with propagating explosion, do now for timing
3293 if ( ship_get_exp_propagates(sp) ) {
3294 ship_blow_up_area_apply_blast( objp );
3297 for (int zz=0; zz<6; zz++ ) {
3298 // dont make sequence of fireballs for knossos
3302 // Find two random vertices on the model, then average them
3303 // and make the piece start there.
3304 vector tmp, outpnt, pnt1, pnt2;
3306 // Gets two random points on the surface of a submodel [KNOSSOS]
3307 submodel_get_two_random_points(sp->modelnum, pm->detail[0], &pnt1, &pnt2 );
3309 vm_vec_avg( &tmp, &pnt1, &pnt2 );
3310 model_find_world_point(&outpnt, &tmp, sp->modelnum, pm->detail[0], &objp->orient, &objp->pos );
3312 float rad = frand()*0.30f;
3313 rad += objp->radius*0.40f;
3314 fireball_create( &outpnt, FIREBALL_EXPLOSION_MEDIUM, OBJ_INDEX(objp), rad, 0, &objp->phys_info.vel );
3317 // if ship is docked, undock now.
3318 if (sp->dock_objnum_when_dead != -1) {
3319 // other ship undocks
3320 // These asserts should no longer be needed and they cause a problem that is not obvious how to fix.
3321 //SDL_assert( !(Ai_info[Ships[dock_obj->instance].ai_index].ai_flags & AIF_DOCKED) );
3322 //SDL_assert( Ai_info[Ships[dock_obj->instance].ai_index].dock_objnum == -1 );
3323 // MWA Ai_info[Ships[dock_obj->instance].ai_index].ai_flags &= ~AIF_DOCKED;
3324 // MWA Ai_info[Ships[dock_obj->instance].ai_index].dock_objnum = -1;
3325 // MWA Ai_info[Ships[dock_obj->instance].ai_index].mode = AIM_NONE;
3329 if ( timestamp_elapsed(sp->final_death_time)) {
3331 sp->final_death_time = timestamp(-1); // never time out again
3332 //mprintf(( "Ship dying!!\n" ));
3334 // play ship explosion sound effect, pick appropriate explosion sound
3336 if ( Ship_info[sp->ship_info_index].flags & (SIF_CAPITAL | SIF_KNOSSOS_DEVICE) ) {
3337 sound_index=SND_CAPSHIP_EXPLODE;
3339 if ( OBJ_INDEX(objp) & 1 ) {
3340 sound_index=SND_SHIP_EXPLODE_1;
3342 sound_index=SND_SHIP_EXPLODE_2;
3346 snd_play_3d( &Snds[sound_index], &objp->pos, &View_position, objp->radius, NULL, 0, 1.0f, SND_PRIORITY_MUST_PLAY );
3347 if (objp == Player_obj)
3350 if ( sp->death_roll_snd != -1 ) {
3351 snd_stop(sp->death_roll_snd);
3352 sp->death_roll_snd = -1;
3355 // if dying ship is docked, do damage to docked and physics
3356 if (sp->dock_objnum_when_dead != -1) {
3357 do_dying_undock_physics(objp, sp);
3360 // play a random explosion
3361 particle_emitter pe;
3363 pe.num_low = 50; // Lowest number of particles to create
3364 pe.num_high = 100; // Highest number of particles to create
3365 pe.pos = objp->pos; // Where the particles emit from
3366 pe.vel = objp->phys_info.vel; // Initial velocity of all the particles
3367 pe.min_life = 0.5f; // How long the particles live
3368 pe.max_life = 4.0f; // How long the particles live
3369 pe.normal = objp->orient.v.uvec; // What normal the particle emit around
3370 pe.normal_variance = 2.0f; // How close they stick to that normal 0=on normal, 1=180, 2=360 degree
3371 pe.min_vel = 0.0f; // How fast the slowest particle can move
3372 pe.max_vel = 20.0f; // How fast the fastest particle can move
3373 pe.min_rad = 0.1f; // Min radius
3374 pe.max_rad = 1.5f; // Max radius
3376 if (!knossos_ship) {
3377 particle_emit( &pe, PARTICLE_SMOKE2, 0 );
3380 // If this is a large ship with a propagating explosion, set it to blow up.
3381 if ( ship_get_exp_propagates(sp) ) {
3382 if (Ai_info[sp->ai_index].ai_flags & AIF_KAMIKAZE) {
3383 ship_blow_up_area_apply_blast( objp );
3385 shipfx_large_blowup_init(sp);
3386 // need to timeout immediately to keep physics in sync
3387 sp->really_final_death_time = timestamp(0);
3389 // only do big fireball if not big ship
3391 int fireball_objnum, fireball_type;
3392 float explosion_life;
3393 big_rad = objp->radius*1.75f;
3394 fireball_type = FIREBALL_EXPLOSION_LARGE1 + rand()%FIREBALL_NUM_LARGE_EXPLOSIONS;
3396 big_rad = objp->radius * 1.2f;
3397 fireball_type = FIREBALL_EXPLOSION_LARGE1;
3399 fireball_objnum = fireball_create( &objp->pos, fireball_type, OBJ_INDEX(objp), big_rad, 0, &objp->phys_info.vel );
3400 if ( fireball_objnum > -1 ) {
3401 explosion_life = fireball_lifeleft(&Objects[fireball_objnum]);
3403 explosion_life = 0.0f;
3406 // JAS: I put in all this code because of an item on my todo list that
3407 // said that the ship destroyed debris shouldn't pop in until the
3408 // big explosion is 30% done. I did this on Oct24 and me & Adam
3409 // thought it looked dumb since the explosion didn't move with the
3410 // ship, so instead of just taking this code out, since we might need
3411 // it in the future, I disabled it. You can reenable it by changing
3412 // the commenting on the following two lines.
3413 sp->really_final_death_time = timestamp( fl2i(explosion_life*1000.0f)/5 ); // Wait till 30% of vclip time before breaking the ship up.
3414 //sp->really_final_death_time = timestamp(0); // Make ship break apart the instant the explosion starts
3417 sp->flags |= SF_EXPLODED;
3419 if ( !(ship_get_exp_propagates(sp)) ) {
3420 // apply area of effect blast damage from ship explosion
3421 ship_blow_up_area_apply_blast( objp );
3425 if ( timestamp_elapsed(sp->really_final_death_time)) {
3427 //mprintf(( "Ship really dying!!\n" ));
3428 // do large_ship_split and explosion
3429 if ( sp->large_ship_blowup_index > -1 ) {
3430 if ( shipfx_large_blowup_do_frame(sp, flFrametime) ) {
3431 // do all accounting for respawning client and server side here.
3432 if(objp == Player_obj) {
3433 gameseq_post_event(GS_EVENT_DEATH_BLEW_UP);
3436 objp->flags |= OF_SHOULD_BE_DEAD;
3438 ship_destroyed(ship_num); // call ship function to clean up after the ship is destroyed.
3443 //fireball_create( &objp->pos, FIREBALL_SHIP_EXPLODE1, OBJ_INDEX(objp), objp->radius/2.0f );
3444 //mprintf(("Frame %i: Died!\n", Framecount));
3446 shipfx_blow_up_model(objp, Ships[ship_num].modelnum, 0, 20, &objp->pos );
3448 // do all accounting for respawning client and server side here.
3449 if(objp == Player_obj) {
3450 gameseq_post_event(GS_EVENT_DEATH_BLEW_UP);
3453 objp->flags |= OF_SHOULD_BE_DEAD;
3455 ship_destroyed(ship_num); // call ship function to clean up after the ship is destroyed.
3456 sp->really_final_death_time = timestamp( -1 ); // Never time out again!
3459 // If a ship is dying (and not a capital or big ship) then stutter the engine sound
3460 if ( timestamp_elapsed(sp->next_engine_stutter) ) {
3461 if ( !(Ship_info[sp->ship_info_index].flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) ) {
3462 sp->flags ^= SF_ENGINES_ON; // toggle state of engines
3463 sp->next_engine_stutter = timestamp_rand(50, 250);
3469 void ship_chase_shield_energy_targets(ship *shipp, object *obj, float frametime)
3474 if (shipp->flags & SF_DYING)
3477 sip = &Ship_info[shipp->ship_info_index];
3479 delta = frametime * ETS_RECHARGE_RATE * sip->shields / 100.0f;
3481 // Chase target_shields and target_weapon_energy
3482 if (shipp->target_shields_delta > 0.0f) {
3483 if (delta > shipp->target_shields_delta)
3484 delta = shipp->target_shields_delta;
3486 add_shield_strength(obj, delta);
3487 shipp->target_shields_delta -= delta;
3488 } else if (shipp->target_shields_delta < 0.0f) {
3489 if (delta < -shipp->target_shields_delta)
3490 delta = -shipp->target_shields_delta;
3492 add_shield_strength(obj, -delta);
3493 shipp->target_shields_delta += delta;
3496 delta = frametime * ETS_RECHARGE_RATE * sip->max_weapon_reserve / 100.0f;
3498 if (shipp->target_weapon_energy_delta > 0.0f) {
3499 if (delta > shipp->target_weapon_energy_delta)
3500 delta = shipp->target_weapon_energy_delta;
3502 shipp->weapon_energy += delta;
3503 shipp->target_weapon_energy_delta -= delta;
3504 } else if (shipp->target_weapon_energy_delta < 0.0f) {
3505 if (delta < -shipp->target_weapon_energy_delta)
3506 delta = -shipp->target_weapon_energy_delta;
3508 shipp->weapon_energy -= delta;
3509 shipp->target_weapon_energy_delta += delta;
3514 // Stuff for showing ship thrusters.
3515 typedef struct thrust_anim {
3518 float time; // in seconds
3521 #define NUM_THRUST_ANIMS 6
3522 #define NUM_THRUST_GLOW_ANIMS 6
3524 // These are indexed by: Species*2 + (After_burner_on?1:0)
3525 static thrust_anim Thrust_anims[NUM_THRUST_ANIMS];
3526 char Thrust_anim_names[NUM_THRUST_ANIMS][MAX_FILENAME_LEN] = {
3528 "thruster01", "thruster01a",
3529 "thruster02", "thruster02a",
3530 "thruster03", "thruster03a"
3534 // These are indexed by: Species*2 + (After_burner_on?1:0)
3535 static thrust_anim Thrust_glow_anims[NUM_THRUST_GLOW_ANIMS];
3536 char Thrust_glow_anim_names[NUM_THRUST_GLOW_ANIMS][MAX_FILENAME_LEN] = {
3538 "thrusterglow01", "thrusterglow01a",
3539 "thrusterglow02", "thrusterglow02a",
3540 "thrusterglow03", "thrusterglow03a"
3544 static int Thrust_anim_inited = 0;
3546 // loads the animations for ship's afterburners
3547 void ship_init_thrusters()
3552 if ( Thrust_anim_inited == 1 )
3555 // AL 29-3-98: Don't want to include Shivan thrusters in the demo build
3556 int num_thrust_anims = NUM_THRUST_ANIMS;
3557 #ifdef DEMO // N/A FS2_DEMO
3558 num_thrust_anims = NUM_THRUST_ANIMS - 2;
3561 for ( i = 0; i < num_thrust_anims; i++ ) {
3562 ta = &Thrust_anims[i];
3563 ta->first_frame = bm_load_animation(Thrust_anim_names[i], &ta->num_frames, &fps, 1);
3564 if ( ta->first_frame == -1 ) {
3565 Error(LOCATION,"Error loading animation file: %s\n",Thrust_anim_names[i]);
3568 SDL_assert(fps != 0);
3569 ta->time = i2fl(ta->num_frames)/fps;
3572 // AL 29-3-98: Don't want to include Shivan thrusters in the demo build
3573 int num_thrust_glow_anims = NUM_THRUST_GLOW_ANIMS;
3574 #ifdef DEMO // N/A FS2_DEMO
3575 num_thrust_glow_anims = NUM_THRUST_GLOW_ANIMS - 2;
3578 for ( i = 0; i < num_thrust_glow_anims; i++ ) {
3579 ta = &Thrust_glow_anims[i];
3580 ta->num_frames = NOISE_NUM_FRAMES;
3582 ta->first_frame = bm_load( Thrust_glow_anim_names[i] );
3583 if ( ta->first_frame == -1 ) {
3584 Error(LOCATION,"Error loading bitmap file: %s\n",Thrust_glow_anim_names[i]);
3587 SDL_assert(fps != 0);
3588 ta->time = i2fl(ta->num_frames)/fps;
3591 Thrust_anim_inited = 1;
3595 // JAS - figure out which thruster bitmap will get rendered next
3596 // time around. ship_render needs to have shipp->thruster_bitmap set to
3597 // a valid bitmap number, or -1 if we shouldn't render thrusters.
3598 void ship_do_thruster_frame( ship *shipp, object *objp, float frametime )
3603 thrust_anim *the_anim;
3604 ship_info *sinfo = &Ship_info[shipp->ship_info_index];
3606 if ( !Thrust_anim_inited ) ship_init_thrusters();
3608 // The animations are organized by:
3609 // Species*2 + (After_burner_on?1:0)
3610 anim_index = sinfo->species*2;
3612 if ( objp->phys_info.flags & PF_AFTERBURNER_ON ) {
3613 anim_index++; // select afterburner anim.
3614 rate = 1.5f; // go at 1.5x faster when afterburners on
3616 // If thrust at 0, go at half as fast, full thrust; full framerate
3617 // so set rate from 0.5 to 1.0, depending on thrust from 0 to 1
3618 // rate = 0.5f + objp->phys_info.forward_thrust / 2.0f;
3619 rate = 0.67f * (1.0f + objp->phys_info.forward_thrust);
3624 SDL_assert( anim_index > -1 );
3625 SDL_assert( anim_index < NUM_THRUST_ANIMS );
3627 the_anim = &Thrust_anims[anim_index];
3629 SDL_assert( frametime > 0.0f );
3630 shipp->thruster_frame += frametime * rate;
3633 if ( shipp->thruster_frame < 0.0f ) shipp->thruster_frame = 0.0f;
3634 if ( shipp->thruster_frame > 100.0f ) shipp->thruster_frame = 0.0f;
3636 while ( shipp->thruster_frame > the_anim->time ) {
3637 shipp->thruster_frame -= the_anim->time;
3639 framenum = fl2i( (shipp->thruster_frame*the_anim->num_frames) / the_anim->time );
3640 if ( framenum < 0 ) framenum = 0;
3641 if ( framenum >= the_anim->num_frames ) framenum = the_anim->num_frames-1;
3643 // if ( anim_index == 0 )
3644 // mprintf(( "Frame = %d/%d, anim=%d\n", framenum+1, the_anim->num_frames, anim_index ));
3646 // Get the bitmap for this frame
3647 shipp->thruster_bitmap = the_anim->first_frame + framenum;
3649 // mprintf(( "TF: %.2f\n", shipp->thruster_frame ));
3651 // Do it for glow bitmaps
3652 the_anim = &Thrust_glow_anims[anim_index];
3654 SDL_assert( frametime > 0.0f );
3655 shipp->thruster_glow_frame += frametime * rate;
3658 if ( shipp->thruster_glow_frame < 0.0f ) shipp->thruster_glow_frame = 0.0f;
3659 if ( shipp->thruster_glow_frame > 100.0f ) shipp->thruster_glow_frame = 0.0f;
3661 while ( shipp->thruster_glow_frame > the_anim->time ) {
3662 shipp->thruster_glow_frame -= the_anim->time;
3664 framenum = fl2i( (shipp->thruster_glow_frame*the_anim->num_frames) / the_anim->time );
3665 if ( framenum < 0 ) framenum = 0;
3666 if ( framenum >= the_anim->num_frames ) framenum = the_anim->num_frames-1;
3668 // if ( anim_index == 0 )
3669 // mprintf(( "Frame = %d/%d, anim=%d\n", framenum+1, the_anim->num_frames, anim_index ));
3671 // Get the bitmap for this frame
3672 shipp->thruster_glow_bitmap = the_anim->first_frame; // + framenum;
3673 shipp->thruster_glow_noise = Noise[framenum];
3678 // JAS - figure out which thruster bitmap will get rendered next
3679 // time around. ship_render needs to have shipp->thruster_bitmap set to
3680 // a valid bitmap number, or -1 if we shouldn't render thrusters.
3681 // This does basically the same thing as ship_do_thruster_frame, except it
3682 // operates on a weapon. This is in the ship code because it needs
3683 // the same thruster animation info as the ship stuff, and I would
3684 // rather extern this one function than all the thruster animation stuff.
3685 void ship_do_weapon_thruster_frame( weapon *weaponp, object *objp, float frametime )
3690 thrust_anim *the_anim;
3692 if ( !Thrust_anim_inited ) ship_init_thrusters();
3694 // The animations are organized by:
3695 // Species*2 + (After_burner_on?1:0)
3696 anim_index = weaponp->species*2;
3698 // If thrust at 0, go at half as fast, full thrust; full framerate
3699 // so set rate from 0.5 to 1.0, depending on thrust from 0 to 1
3700 // rate = 0.5f + objp->phys_info.forward_thrust / 2.0f;
3701 rate = 0.67f * (1.0f + objp->phys_info.forward_thrust);
3703 SDL_assert( anim_index > -1 );
3704 SDL_assert( anim_index < NUM_THRUST_ANIMS );
3706 the_anim = &Thrust_anims[anim_index];
3708 SDL_assert( frametime > 0.0f );
3709 weaponp->thruster_frame += frametime * rate;
3712 if ( weaponp->thruster_frame < 0.0f ) weaponp->thruster_frame = 0.0f;
3713 if ( weaponp->thruster_frame > 100.0f ) weaponp->thruster_frame = 0.0f;
3715 while ( weaponp->thruster_frame > the_anim->time ) {
3716 weaponp->thruster_frame -= the_anim->time;
3718 framenum = fl2i( (weaponp->thruster_frame*the_anim->num_frames) / the_anim->time );
3719 if ( framenum < 0 ) framenum = 0;
3720 if ( framenum >= the_anim->num_frames ) framenum = the_anim->num_frames-1;
3722 // if ( anim_index == 0 )
3723 // mprintf(( "Frame = %d/%d, anim=%d\n", framenum+1, the_anim->num_frames, anim_index ));
3725 // Get the bitmap for this frame
3726 weaponp->thruster_bitmap = the_anim->first_frame + framenum;
3728 // mprintf(( "TF: %.2f\n", weaponp->thruster_frame ));
3730 // Do it for glow bitmaps
3731 the_anim = &Thrust_glow_anims[anim_index];
3733 SDL_assert( frametime > 0.0f );
3734 weaponp->thruster_glow_frame += frametime * rate;
3737 if ( weaponp->thruster_glow_frame < 0.0f ) weaponp->thruster_glow_frame = 0.0f;
3738 if ( weaponp->thruster_glow_frame > 100.0f ) weaponp->thruster_glow_frame = 0.0f;
3740 while ( weaponp->thruster_glow_frame > the_anim->time ) {
3741 weaponp->thruster_glow_frame -= the_anim->time;
3743 framenum = fl2i( (weaponp->thruster_glow_frame*the_anim->num_frames) / the_anim->time );
3744 if ( framenum < 0 ) framenum = 0;
3745 if ( framenum >= the_anim->num_frames ) framenum = the_anim->num_frames-1;
3747 // if ( anim_index == 0 )
3748 // mprintf(( "Frame = %d/%d, anim=%d\n", framenum+1, the_anim->num_frames, anim_index ));
3750 // Get the bitmap for this frame
3751 weaponp->thruster_glow_bitmap = the_anim->first_frame; // + framenum;
3752 weaponp->thruster_glow_noise = Noise[framenum];
3757 // Repair damaged subsystems for a ship, called for each ship once per frame.
3758 // TODO: optimize by only calling ever N seconds and keeping track of elapsed time
3760 // NOTE: need to update current_hits in the sp->subsys_list element, and the sp->subsys_info[]
3762 #define SHIP_REPAIR_SUBSYSTEM_RATE 0.01f // percent repair per second for a subsystem
3763 #define SUBSYS_REPAIR_THRESHOLD 0.1 // only repair subsystems that have > 10% strength
3764 void ship_auto_repair_frame(int shipnum, float frametime)
3767 ship_subsys_info *ssip;
3772 if ( !Ship_auto_repair ) // only repair subsystems if Ship_auto_repair flag is set
3776 SDL_assert( shipnum >= 0 && shipnum < MAX_SHIPS);
3777 sp = &Ships[shipnum];
3778 sip = &Ship_info[sp->ship_info_index];
3780 // only allow for the auto-repair of subsystems on small ships
3781 if ( !(sip->flags & SIF_SMALL_SHIP) )
3784 // AL 3-14-98: only allow auto-repair if power output not zero
3785 if ( sip->power_output <= 0 )
3788 // iterate through subsystems, repair as needed based on elapsed frametime
3789 for ( ssp = GET_FIRST(&sp->subsys_list); ssp != END_OF_LIST(&sp->subsys_list); ssp = GET_NEXT(ssp) ) {
3790 SDL_assert(ssp->system_info->type >= 0 && ssp->system_info->type < SUBSYSTEM_MAX);
3791 ssip = &sp->subsys_info[ssp->system_info->type];
3793 if ( ssp->current_hits != ssp->system_info->max_hits ) {
3795 // only repair those subsystems which are not destroyed
3796 if ( ssp->system_info->max_hits <= 0 || ssp->current_hits <= 0 )
3799 // do incremental repair on the subsystem
3800 ssp->current_hits += ssp->system_info->max_hits * SHIP_REPAIR_SUBSYSTEM_RATE * frametime;
3801 ssip->current_hits += ssip->total_hits * SHIP_REPAIR_SUBSYSTEM_RATE * frametime;
3803 // check for overflow of current_hits
3804 if ( ssp->current_hits >= ssp->system_info->max_hits ) {
3805 // TODO: here is hook for when a subsystem is fully repaired (eg add voice)
3806 ssp->current_hits = ssp->system_info->max_hits;
3808 if ( ssip->current_hits >= ssip->total_hits ) {
3809 ssip->current_hits = ssip->total_hits;
3815 // this function checks to see how far the player has strayed from his starting location (should be
3816 // single player only). Issues a warning at some distance. Makes mission end if he keeps flying away
3817 // 3 strikes and you're out or too far away
3818 #define PLAYER_MAX_DIST_WARNING 70000 // distance in KM at which player gets warning to return to battle
3819 #define PLAYER_DISTANCE_MAX_WARNINGS 3 // maximum number of warnings player can receive before mission ends
3820 #define PLAYER_MAX_DIST_END 75000 // distance from starting loc at which we end mission
3821 #define PLAYER_WARN_DELTA_TIME 10000
3822 #define PLAYER_DEATH_DELTA_TIME 5000
3824 void ship_check_player_distance_sub(player *p, int multi_target=-1)
3826 // only check distance for ships
3827 if ( p->control_mode != PCM_NORMAL ) {
3828 // already warping out... don't bother checking anymore
3832 float dist = vm_vec_dist_quick(&Objects[p->objnum].pos, &vmd_zero_vector);
3834 int give_warning_to_player = 0;
3835 if ( dist > PLAYER_MAX_DIST_WARNING ) {
3836 if (p->distance_warning_count == 0) {
3837 give_warning_to_player = 1;
3839 if (timestamp_until(p->distance_warning_time) < 0) {
3840 give_warning_to_player = 1;
3845 if ( give_warning_to_player ) {
3846 // increase warning count
3847 p->distance_warning_count++;
3848 // set timestamp unless player PLAYER_FLAGS_DIST_TO_BE_KILLED flag is set
3849 if ( !(p->flags & PLAYER_FLAGS_DIST_TO_BE_KILLED) ) {
3850 p->distance_warning_time = timestamp(PLAYER_WARN_DELTA_TIME);
3852 // issue up to max warnings
3853 if (p->distance_warning_count <= PLAYER_DISTANCE_MAX_WARNINGS) {
3854 message_send_builtin_to_player( MESSAGE_STRAY_WARNING, NULL, MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_SOON, 0, 0, multi_target, -1 );
3857 // HUD_sourced_printf(HUD_SOURCE_TERRAN_CMD, XSTR("Terran Command: You're straying too far from battle pilot, return immediately or be taken from the battlefield.", -1));
3858 if (p->distance_warning_count > PLAYER_DISTANCE_MAX_WARNINGS) {
3859 p->flags |= PLAYER_FLAGS_DIST_WARNING;
3863 if ( !(p->flags & PLAYER_FLAGS_FORCE_MISSION_OVER) && ((p->distance_warning_count > PLAYER_DISTANCE_MAX_WARNINGS) || (dist > PLAYER_MAX_DIST_END)) ) {
3864 // DKA 5/17/99 - DONT force warpout. Won't work multiplayer. Blow up ship.
3865 if ( !(p->flags & PLAYER_FLAGS_DIST_TO_BE_KILLED) ) {
3866 message_send_builtin_to_player( MESSAGE_STRAY_WARNING_FINAL, NULL, MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, multi_target, -1 );
3867 p->flags |= PLAYER_FLAGS_DIST_TO_BE_KILLED;
3868 p->distance_warning_time = timestamp(PLAYER_DEATH_DELTA_TIME);
3870 // HUD_sourced_printf(HUD_SOURCE_TERRAN_CMD, XSTR("Terran Command: Sorry pilot, removing you from battle because of your insubordination!!!", -1));
3871 // gameseq_post_event(GS_EVENT_PLAYER_WARPOUT_START_FORCED);
3873 // get hull strength and blow up
3874 if ( (p->flags & PLAYER_FLAGS_DIST_TO_BE_KILLED) && (timestamp_until(p->distance_warning_time) < 0) ) {
3875 p->flags |= PLAYER_FLAGS_FORCE_MISSION_OVER;
3876 float damage = 10.0f * Objects[p->objnum].hull_strength;
3877 ship_apply_global_damage(&Objects[p->objnum], &Objects[p->objnum], NULL, damage);
3881 // see if player has moved back into "bounds"
3882 if ( (dist < PLAYER_MAX_DIST_WARNING) && (p->flags & PLAYER_FLAGS_DIST_WARNING) && !(p->flags & PLAYER_FLAGS_DIST_TO_BE_KILLED) ) {
3883 p->flags &= ~PLAYER_FLAGS_DIST_WARNING;
3884 p->distance_warning_count = 1;
3888 void ship_check_player_distance()
3893 if (Game_mode & GM_MULTIPLAYER) {
3894 // if I'm the server, check all non-observer players including myself
3895 if (MULTIPLAYER_MASTER) {
3897 for (idx=0; idx<MAX_PLAYERS; idx++) {
3898 if (MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_OBSERVER(Net_players[idx]) && (Objects[Net_players[idx].player->objnum].type != OBJ_GHOST) ) {
3899 // if bad, blow him up
3900 ship_check_player_distance_sub(Net_players[idx].player, idx);
3907 // maybe blow him up
3908 ship_check_player_distance_sub(Player);
3912 void observer_process_post(object *objp)
3914 SDL_assert(objp->type == OBJ_OBSERVER);
3916 if (Game_mode & GM_MULTIPLAYER) {
3917 // if I'm just an observer
3918 if (MULTI_OBSERVER(Net_players[MY_NET_PLAYER_NUM])) {
3919 float dist = vm_vec_dist_quick(&Player_obj->pos, &vmd_zero_vector);
3920 // if beyond max dist, reset to 0
3921 if (dist > PLAYER_MAX_DIST_END) {
3923 if ((Player_obj != NULL) && (Player_obj->type != OBJ_GHOST)) {
3924 Player_obj->pos = vmd_zero_vector;
3931 // reset some physics info when ship's engines goes from disabled->enabled
3932 void ship_reset_disabled_physics(object *objp, int ship_class)
3934 objp->phys_info.flags &= ~(PF_REDUCED_DAMP | PF_DEAD_DAMP);
3935 objp->phys_info.side_slip_time_const = Ship_info[ship_class].damp;
3938 // Clear/set the subsystem disrupted flags
3939 void ship_subsys_disrupted_check(ship *sp)
3942 int engines_disabled=0;
3944 if ( sp->subsys_disrupted_flags & (1<<SUBSYSTEM_ENGINE) ) {
3948 sp->subsys_disrupted_flags=0;
3950 ss = GET_FIRST(&sp->subsys_list);
3951 while ( ss != END_OF_LIST( &sp->subsys_list ) ) {
3952 if ( !timestamp_elapsed(ss->disruption_timestamp) ) {
3953 sp->subsys_disrupted_flags |= (1<<ss->system_info->type);
3955 ss = GET_NEXT( ss );
3958 if ( engines_disabled ) {
3959 if ( !(sp->subsys_disrupted_flags & (1<<SUBSYSTEM_ENGINE)) ) {
3960 if ( !(sp->flags & SF_DISABLED) ) {
3961 ship_reset_disabled_physics(&Objects[sp->objnum], sp->ship_info_index);
3967 // Maybe check ship subsystems for disruption, and set/clear flags
3968 void ship_subsys_disrupted_maybe_check(ship *shipp)
3970 if ( timestamp_elapsed(shipp->subsys_disrupted_check_timestamp) ) {
3971 ship_subsys_disrupted_check(shipp);
3972 shipp->subsys_disrupted_check_timestamp=timestamp(250);
3976 // Determine if a given subsystem is disrupted (ie inoperable)
3977 // input: ss => pointer to ship subsystem
3978 // exit: 1 => subsystem is disrupted
3979 // 0 => subsystem is not disrupted
3980 int ship_subsys_disrupted(ship_subsys *ss)
3983 Int3(); // should never happen, get Alan if it does.
3987 if ( timestamp_elapsed(ss->disruption_timestamp) ) {
3994 // Disrupt a subsystem (ie make it inoperable for a time)
3995 // input: ss => ship subsystem to be disrupted
3996 // time => time in ms that subsystem should be disrupted
3997 void ship_subsys_set_disrupted(ship_subsys *ss, int time)
4002 Int3(); // should never happen, get Alan if it does.
4006 time_left=timestamp_until(ss->disruption_timestamp);
4007 if ( time_left < 0 ) {
4011 ss->disruption_timestamp = timestamp(time+time_left);
4014 // Determine if a given subsystem is disrupted (ie inoperable)
4015 // input: sp => pointer to ship containing subsystem
4016 // type => type of subsystem (SUBSYSTEM_*)
4017 // exit: 1 => subsystem is disrupted
4018 // 0 => subsystem is not disrupted
4020 int ship_subsys_disrupted(ship *sp, int type)
4022 if ( sp->subsys_disrupted_flags & (1<<type) ) {
4029 float Decay_rate = 1.0f / 120.0f;
4030 DCF(lethality_decay, "time in sec to return from 100 to 0")
4032 dc_get_arg(ARG_FLOAT);
4033 Decay_rate = Dc_arg_float;
4036 float min_lethality = 0.0f;
4038 void lethality_decay(ai_info *aip)
4040 float decay_rate = Decay_rate;
4041 aip->lethality -= 100.0f * decay_rate * flFrametime;
4042 aip->lethality = SDL_max(-10.0f, aip->lethality);
4044 // if (aip->lethality < min_lethality) {
4045 // min_lethality = aip->lethality;
4046 // mprintf(("new lethality low: %.1f\n", min_lethality));
4050 if (Objects[Ships[aip->shipnum].objnum].flags & OF_PLAYER_SHIP) {
4051 if (Framecount % 10 == 0) {
4052 int num_turrets = 0;
4053 if ((aip->target_objnum != -1) && (Objects[aip->target_objnum].type == OBJ_SHIP)) {
4054 int num_turrets_attacking(object *turret_parent, int target_objnum);
4055 num_turrets = num_turrets_attacking(&Objects[aip->target_objnum], Ships[aip->shipnum].objnum);
4057 nprintf(("lethality", "Player lethality: %.1f, num turrets targeting player: %d\n", aip->lethality, num_turrets));
4063 void ship_process_pre(object *objp, float frametime)
4067 MONITOR( NumShips );
4069 // Player ship uses this code, but does a quick out after doing a few things.
4070 // when adding code to this function, decide whether or not a client in a multiplayer game
4071 // needs to execute the code you are adding. Code which moves things, creates things, etc
4072 // probably doesn't need to be called. If you don't know -- find Allender!!!
4073 void ship_process_post(object * obj, float frametime)
4078 if(obj->type != OBJ_SHIP){
4079 nprintf(("Network","Ignoring non-ship object in ship_process_post()\n"));
4083 MONITOR_INC( NumShips, 1 );
4085 num = obj->instance;
4086 SDL_assert( num >= 0 && num < MAX_SHIPS);
4087 SDL_assert( obj->type == OBJ_SHIP );
4088 SDL_assert( Ships[num].objnum == OBJ_INDEX(obj));
4090 shipp = &Ships[num];
4092 shipp->shield_hits = 0;
4094 update_ets(obj, frametime);
4096 afterburners_update(obj, frametime);
4098 ship_subsys_disrupted_maybe_check(shipp);
4100 ship_dying_frame(obj, num);
4102 ship_chase_shield_energy_targets(shipp, obj, frametime);
4104 // AL 1-6-98: record the initial ammo counts for ships, which is used as the max limit for rearming
4105 if ( !(shipp->flags & SF_AMMO_COUNT_RECORDED) ) {
4106 for ( int i=0; i<MAX_SECONDARY_BANKS; i++ ) {
4107 if ( red_alert_mission() ) {
4108 int max_missiles = get_max_ammo_count_for_bank(shipp->ship_info_index, i, shipp->weapons.secondary_bank_weapons[i]);
4109 shipp->weapons.secondary_bank_start_ammo[i] = max_missiles;
4111 shipp->weapons.secondary_bank_start_ammo[i] = shipp->weapons.secondary_bank_ammo[i];
4114 shipp->flags |= SF_AMMO_COUNT_RECORDED;
4117 if(!(Game_mode & GM_STANDALONE_SERVER)){
4118 // Plot ship on the radar. What about multiplayer ships?
4119 if ( obj != Player_obj ) // don't plot myself.
4120 radar_plot_object( obj );
4122 // MWA -- move the spark code to before the check for multiplayer master
4123 // Do ship sparks. Don't do sparks on my ship (since I cannot see it). This
4124 // code will do sparks on other ships in multiplayer though.
4125 // JAS: Actually in external view, you can see sparks, so I don't do sparks
4126 // on the Viewer_obj, not Player_obj.
4127 if ( (obj != Viewer_obj) && timestamp_elapsed(Ships[num].next_hit_spark) ) {
4128 shipfx_emit_spark(num,-1); // -1 means choose random spark location
4131 if ( obj != Viewer_obj ) {
4132 shipfx_do_damaged_arcs_frame( shipp );
4135 // JAS - flicker the thruster bitmaps
4136 ship_do_thruster_frame(shipp,obj,frametime);
4139 ship_auto_repair_frame(num, frametime);
4141 // MWA -- move the spark code to before the check for multiplayer master
4143 // if (timestamp_elapsed(Ships[num].next_hit_spark)) {
4145 // Ships[num].next_hit_spark = timestamp_rand(100,500);
4148 shipfx_do_lightning_frame(shipp);
4150 // if the ship has an EMP effect active, process it
4151 emp_process_ship(shipp);
4153 // call the contrail system
4154 ct_ship_process(shipp);
4156 // process engine wash
4157 void engine_wash_ship_process(ship *shipp);
4158 engine_wash_ship_process(shipp);
4161 if(shipp->tag_left > 0.0f){
4162 shipp->tag_left -= flFrametime;
4163 if(shipp->tag_left <= 0.000001f){
4164 shipp->tag_left = -1.0f;
4166 mprintf(("Killing TAG for %s\n", shipp->ship_name));
4170 // update level 2 TAG info
4171 if(shipp->level2_tag_left > 0.0f){
4172 shipp->level2_tag_left -= flFrametime;
4173 if(shipp->level2_tag_left <= 0.000001f){
4174 shipp->level2_tag_left = -1.0f;
4176 mprintf(("Killing level 2 TAG for %s\n", shipp->ship_name));
4180 if ( shipp->flags & SF_ARRIVING && Ai_info[shipp->ai_index].mode != AIM_BAY_EMERGE ) {
4181 // JAS -- if the ship is warping in, just move it forward at a speed
4182 // fast enough to move 2x it's radius in SHIP_WARP_TIME seconds.
4183 shipfx_warpin_frame( obj, frametime );
4184 } else if ( shipp->flags & SF_DEPART_WARP ) {
4185 // JAS -- if the ship is warping out, just move it forward at a speed
4186 // fast enough to move 2x it's radius in SHIP_WARP_TIME seconds.
4187 shipfx_warpout_frame( obj, frametime );
4191 // for multiplayer people. return here if in multiplay and not the host
4192 if ( (Game_mode & GM_MULTIPLAYER) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER) )
4195 // MWA -- moved the code to maybe fire swarm missiles to after the check for
4196 // multiplayer master. Only single player and multi server needs to do this code
4197 // this code might call ship_fire_secondary which will send the fire packets
4198 swarm_maybe_fire_missile(num);
4200 // maybe fire turret swarm missiles
4201 void turret_swarm_maybe_fire_missile(int num);
4202 turret_swarm_maybe_fire_missile(num);
4204 // maybe fire a corkscrew missile (just like swarmers)
4205 cscrew_maybe_fire_missile(num);
4207 // AL 2-19-98: Fire turret for player if it exists
4208 if ( obj->flags & OF_PLAYER_SHIP ) {
4209 player_maybe_fire_turret(obj);
4212 // if single player, check player object is not too far from starting location
4213 // DKA 5/17/99 check SINGLE and MULTI
4214 // if ( !(Game_mode & GM_MULTIPLAYER) && (obj == Player_obj) )
4215 if (obj == Player_obj) {
4216 ship_check_player_distance();
4219 // update ship lethality
4220 if ( Ships[num].ai_index >= 0 ){
4221 if (!physics_paused && !ai_paused){
4222 lethality_decay(&Ai_info[Ships[num].ai_index]);
4226 // if the ship is a player ship or an observer ship don't need to do AI
4227 if ( (obj->flags & OF_PLAYER_SHIP) || (obj->type == OBJ_OBSERVER) ) {
4231 if ( Ships[num].ai_index >= 0 ){
4232 if (!physics_paused && !ai_paused){
4233 ai_process( obj, Ships[num].ai_index, frametime );
4240 // ------------------------------------------------------------------------
4241 // ship_set_default_weapons()
4243 // Set the ship level weapons based on the information contained in the ship
4244 // info. Weapon assignments are checked against the model to ensure the models
4245 // and the ship info weapon data are in synch.
4249 void ship_set_default_weapons(ship *shipp, ship_info *sip)
4253 ship_weapon *swp = &shipp->weapons;
4255 // Copy primary and secondary weapons from ship_info to ship.
4256 // Later, this will happen in the weapon loadout screen.
4257 for (i=0; i < MAX_PRIMARY_BANKS; i++){
4258 swp->primary_bank_weapons[i] = sip->primary_bank_weapons[i];
4261 for (i=0; i < MAX_SECONDARY_BANKS; i++){
4262 swp->secondary_bank_weapons[i] = sip->secondary_bank_weapons[i];
4265 // Copy the number of primary and secondary banks to ship, and verify that
4266 // model is in synch
4267 po = model_get( sip->modelnum );
4270 if ( po->n_guns > sip->num_primary_banks ) {
4271 SDL_assert(po->n_guns <= MAX_PRIMARY_BANKS);
4272 Warning(LOCATION, "There are %d primary banks in the model file,\nbut only %d primary banks in ships.tbl for %s\n", po->n_guns, sip->num_primary_banks, sip->name);
4273 for ( i = sip->num_primary_banks; i < po->n_guns; i++ ) {
4274 // Make unspecified weapon for bank be a Light Laser
4275 swp->primary_bank_weapons[i] = weapon_info_lookup(NOX("Light Laser"));
4276 SDL_assert(swp->primary_bank_weapons[i] >= 0);
4278 sip->num_primary_banks = po->n_guns;
4280 else if ( po->n_guns < sip->num_primary_banks ) {
4281 Warning(LOCATION, "There are %d primary banks in ships.tbl for %s\nbut only %d primary banks in the model\n", sip->num_primary_banks, sip->name, po->n_guns);
4282 sip->num_primary_banks = po->n_guns;
4286 if ( po->n_missiles > sip->num_secondary_banks ) {
4287 SDL_assert(po->n_missiles <= MAX_SECONDARY_BANKS);
4288 Warning(LOCATION, "There are %d secondary banks in model,\nbut only %d secondary banks in ships.tbl for %s\n", po->n_missiles, sip->num_secondary_banks, sip->name);
4289 for ( i = sip->num_secondary_banks; i < po->n_missiles; i++ ) {
4290 // Make unspecified weapon for bank be a Rockeye Missile
4291 swp->secondary_bank_weapons[i] = weapon_info_lookup(NOX("Rockeye Missile"));
4292 SDL_assert(swp->secondary_bank_weapons[i] >= 0);
4294 sip->num_secondary_banks = po->n_missiles;
4296 else if ( po->n_missiles < sip->num_secondary_banks ) {
4297 Warning(LOCATION, "There are %d secondary banks in ships.tbl for %s,\n but only %d secondary banks in the model.\n", sip->num_secondary_banks, sip->name, po->n_missiles);
4298 sip->num_secondary_banks = po->n_missiles;
4301 swp->num_primary_banks = sip->num_primary_banks;
4302 swp->num_secondary_banks = sip->num_secondary_banks;
4303 for ( i = 0; i < swp->num_secondary_banks; i++ ) {
4305 swp->secondary_bank_ammo[i] = 100;
4307 swp->secondary_bank_ammo[i] = sip->secondary_bank_ammo_capacity[i];
4310 swp->secondary_bank_capacity[i] = sip->secondary_bank_ammo_capacity[i];
4313 for ( i = 0; i < MAX_PRIMARY_BANKS; i++ ){
4314 swp->next_primary_fire_stamp[i] = timestamp(0);
4317 for ( i = 0; i < MAX_SECONDARY_BANKS; i++ ){
4318 swp->next_secondary_fire_stamp[i] = timestamp(0);
4323 // A faster version of ship_check_collision that does not do checking at the polygon
4324 // level. Just checks to see if a vector will intersect a sphere.
4325 int ship_check_collision_fast( object * obj, object * other_obj, vector * hitpos)
4330 SDL_assert( obj->type == OBJ_SHIP );
4331 SDL_assert( obj->instance >= 0 );
4333 num = obj->instance;
4335 ship_model_start(obj); // are these needed in this fast case? probably not.
4337 mc.model_num = Ships[num].modelnum; // Fill in the model to check
4338 mc.orient = &obj->orient; // The object's orient
4339 mc.pos = &obj->pos; // The object's position
4340 mc.p0 = &other_obj->last_pos; // Point 1 of ray to check
4341 mc.p1 = &other_obj->pos; // Point 2 of ray to check
4342 mc.flags = MC_ONLY_SPHERE; // flags
4346 *hitpos = mc.hit_point_world;
4348 ship_model_stop(obj); // are these needed in this fast case? probably not.
4353 // ensure that the subsys path is at least SUBSYS_PATH_DIST from the
4354 // second last to last point.
4355 void ship_maybe_fixup_subsys_path(polymodel *pm, int path_num)
4357 vector *v1, *v2, dir;
4359 int index_1, index_2;
4362 mp = &pm->paths[path_num];
4364 SDL_assert(mp != NULL);
4365 SDL_assert(mp->nverts > 1);
4370 v1 = &mp->verts[index_1].pos;
4371 v2 = &mp->verts[index_2].pos;
4373 dist = vm_vec_dist(v1, v2);
4374 if ( dist < SUBSYS_PATH_DIST-10 ) {
4375 vm_vec_normalized_dir(&dir, v2, v1);
4376 vm_vec_scale_add(v2, v1, &dir, SUBSYS_PATH_DIST);
4380 // fill in the path_num field inside the model_subsystem struct. This is an index into
4381 // the pm->paths[] array, which is a path that provides a frontal approach to a subsystem
4382 // (used for attacking purposes)
4384 // NOTE: path_num in model_subsystem has the follows the following convention:
4385 // > 0 => index into pm->paths[] for model that subsystem sits on
4386 // -1 => path is not yet determined (may or may not exist)
4387 // -2 => path doesn't yet exist for this subsystem
4388 void ship_set_subsys_path_nums(ship_info *sip, polymodel *pm)
4392 for ( i = 0; i < sip->n_subsystems; i++ ) {
4393 sip->subsystems[i].path_num = -1;
4396 for ( i = 0; i < sip->n_subsystems; i++ ) {
4398 for ( j = 0; j < pm->n_paths; j++ ) {
4399 if ( (sip->subsystems[i].subobj_num != -1) && (sip->subsystems[i].subobj_num == pm->paths[j].parent_submodel) ) {
4401 } else if ( !SDL_strcasecmp(sip->subsystems[i].subobj_name, pm->paths[j].parent_name) ) {
4406 if ( pm->n_paths > j ) {
4407 sip->subsystems[i].path_num = j;
4408 ship_maybe_fixup_subsys_path(pm, j);
4414 // If a path num wasn't located, then set value to -2
4415 if ( sip->subsystems[i].path_num == -1 )
4416 sip->subsystems[i].path_num = -2;
4420 // Determine the path indices (indicies into pm->paths[]) for the paths used for approaching/departing
4421 // a fighter bay on a capital ship.
4422 void ship_set_bay_path_nums(ship_info *sip, polymodel *pm)
4425 char bay_num_str[3];
4427 if ( pm->ship_bay != NULL ) {
4429 pm->ship_bay = NULL;
4432 // currently only capital ships have fighter bays
4433 if ( !(sip->flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP)) ) {
4437 // malloc out storage for the path information
4438 pm->ship_bay = (ship_bay*)malloc(sizeof(ship_bay));
4439 SDL_assert(pm->ship_bay != NULL);
4441 pm->ship_bay->num_paths = 0;
4442 // TODO: determine if zeroing out here is affecting any earlier initializations
4443 pm->ship_bay->arrive_flags = 0; // bitfield, set to 1 when that path number is reserved for an arrival
4444 pm->ship_bay->depart_flags = 0; // bitfield, set to 1 when that path number is reserved for a departure
4447 // iterate through the paths that exist in the polymodel, searching for $bayN pathnames
4448 for ( i = 0; i < pm->n_paths; i++ ) {
4449 if ( !SDL_strncasecmp(pm->paths[i].name, NOX("$bay"), 4) ) {
4450 SDL_strlcpy(bay_num_str, pm->paths[i].name+4, SDL_arraysize(bay_num_str));
4451 bay_num = atoi(bay_num_str);
4452 SDL_assert(bay_num >= 1 && bay_num <= MAX_SHIP_BAY_PATHS);
4453 pm->ship_bay->paths[bay_num-1] = i;
4454 pm->ship_bay->num_paths++;
4459 // Ensure create time for ship is unqiue
4460 void ship_make_create_time_unique(ship *shipp)
4462 int sanity_counter = 0, collision;
4463 ship *compare_shipp;
4465 uint new_create_time;
4467 new_create_time = shipp->create_time;
4471 if ( sanity_counter++ > 50 ) {
4478 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
4479 compare_shipp = &Ships[Objects[so->objnum].instance];
4481 if ( compare_shipp == shipp ) {
4485 if ( compare_shipp->create_time == new_create_time ) {
4493 shipp->create_time = new_create_time;
4499 int Ship_subsys_hwm = 0;
4501 void show_ship_subsys_count()
4506 for ( objp = GET_FIRST(&obj_used_list); objp != END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
4507 if (objp->type == OBJ_SHIP) {
4508 count += Ship_info[Ships[(int)objp->type].ship_info_index].n_subsystems;
4512 //nprintf(("AI", "Num subsystems, high water mark = %i, %i\n", count, Ship_subsys_hwm));
4514 if (count > Ship_subsys_hwm) {
4515 Ship_subsys_hwm = count;
4519 // Returns object index of ship.
4521 int ship_create(matrix *orient, vector *pos, int ship_type)
4523 int i, n, objnum, j, k, t;
4527 t = ship_get_num_ships();
4529 // The following check caps the number of ships that can be created. Because Fred needs
4530 // to create all the ships, regardless of when they arrive/depart, it needs a higher
4531 // limit than FreeSpace. On release, however, we will reduce it, thus FreeSpace needs
4532 // to check against what this limit will be, otherwise testing the missions before
4533 // release could work fine, yet not work anymore once a release build is made.
4539 if (t >= SHIPS_LIMIT) {
4540 Error(LOCATION, XSTR("There is a limit of %d ships in the mission at once. Please be sure that you do not have more than %d ships present in the mission at the same time.", 1495), SHIPS_LIMIT, SHIPS_LIMIT );
4545 //nprintf(("AI", "Number of ships = %i\n", t));
4547 for (n=0; n<MAX_SHIPS; n++){
4548 if (Ships[n].objnum == -1){
4553 if (n == MAX_SHIPS){
4557 SDL_assert((ship_type >= 0) && (ship_type < Num_ship_types));
4558 sip = &(Ship_info[ship_type]);
4561 // check to be sure that this ship falls into a ship size category!!!
4562 // get Allender or Mike if you hit this SDL_assert
4563 SDL_assert( sip->flags & (SIF_SMALL_SHIP | SIF_BIG_SHIP | SIF_CAPITAL | SIF_NO_SHIP_TYPE | SIF_NOT_FLYABLE | SIF_ESCAPEPOD | SIF_SUPERCAP | SIF_DRYDOCK | SIF_KNOSSOS_DEVICE) );
4565 sip->modelnum = model_load(sip->pof_file, sip->n_subsystems, &sip->subsystems[0]); // use the highest detail level
4566 shipp->modelnum = sip->modelnum;
4568 // maybe load an optional hud target model
4569 if(strlen(sip->pof_file_hud)){
4570 // check to see if a "real" ship uses this model. if so, load it up for him so that subsystems are setup properly
4572 for(idx=0; idx<Num_ship_types; idx++){
4573 if(!SDL_strcasecmp(Ship_info[idx].pof_file, sip->pof_file_hud)){
4574 Ship_info[idx].modelnum = model_load(Ship_info[idx].pof_file, Ship_info[idx].n_subsystems, &Ship_info[idx].subsystems[0]);
4578 // mow load it for me with no subsystems
4579 sip->modelnum_hud = model_load(sip->pof_file_hud, 0, NULL);
4583 pm = model_get(shipp->modelnum);
4585 ship_copy_subsystem_fixup(sip);
4587 show_ship_subsys_count();
4589 if ( sip->num_detail_levels < pm->n_detail_levels ) {
4590 Warning(LOCATION, "For ship '%s', detail level\nmismatch (POF needs %d)", sip->name, pm->n_detail_levels );
4592 for (i=0; i<pm->n_detail_levels; i++ ) {
4593 sip->detail_distance[i] = 0;
4597 for (i=0; i<sip->num_detail_levels; i++ ) {
4598 pm->detail_depth[i] = i2fl(sip->detail_distance[i]);
4601 if ( sip->flags & SIF_NAVBUOY ) {
4602 // JAS: Nav buoys don't need to do collisions!
4603 objnum = obj_create(OBJ_SHIP, -1, n, orient, pos, model_get_radius(shipp->modelnum), OF_RENDERS | OF_PHYSICS );
4605 objnum = obj_create(OBJ_SHIP, -1, n, orient, pos, model_get_radius(shipp->modelnum), OF_RENDERS | OF_COLLIDES | OF_PHYSICS );
4607 SDL_assert( objnum >= 0 );
4609 shipp->ai_index = ai_get_slot(n);
4610 SDL_assert( shipp->ai_index >= 0 );
4612 SDL_snprintf(shipp->ship_name, SDL_arraysize(shipp->ship_name), NOX("%s %d"), Ship_info[ship_type].name, n);
4613 ship_set_default_weapons(shipp, sip); // Moved up here because ship_set requires that weapon info be valid. MK, 4/28/98
4614 ship_set(n, objnum, ship_type);
4616 // fill in the path_num field inside the model_subsystem struct. This is an index into
4617 // the pm->paths[] array, which is a path that provides a frontal approach to a subsystem
4618 // (used for attacking purposes)
4620 // NOTE: path_num in model_subsystem has the follows the following convention:
4621 // > 0 => index into pm->paths[] for model that subsystem sits on
4622 // -1 => path is not yet determined (may or may not exist)
4623 // -2 => path doesn't yet exist for this subsystem
4624 ship_set_subsys_path_nums(sip, pm);
4626 // set the path indicies for fighter bays on the ship (currently, only capital ships have fighter bays)
4627 ship_set_bay_path_nums(sip, pm);
4629 init_ai_object(objnum);
4630 ai_clear_ship_goals( &Ai_info[Ships[n].ai_index] ); // only do this one here. Can't do it in init_ai because it might wipe out goals in mission file
4632 //ship_set_default_weapons(shipp, sip);
4634 // Allocate shield and initialize it.
4635 if (pm->shield.ntris) {
4636 shipp->shield_integrity = (float *)malloc(sizeof(float)*pm->shield.ntris);
4637 for (i=0; i<pm->shield.ntris; i++)
4638 shipp->shield_integrity[i] = 1.0f;
4641 shipp->shield_integrity = NULL;
4643 // fix up references into paths for this ship's model to point to a ship_subsys entry instead
4644 // of a submodel index. The ship_subsys entry should be the same for *all* instances of the
4647 if ( !(sip->flags & SIF_PATH_FIXUP )) {
4648 for ( i = 0; i < pm->n_paths; i++ ) {
4649 for ( j = 0; j < pm->paths[i].nverts; j++ ) {
4650 for ( k = 0; k < pm->paths[i].verts[j].nturrets; k++ ) {
4651 int ptindex = pm->paths[i].verts[j].turret_ids[k]; // this index is a submodel number (ala bspgen)
4655 // iterate through the ship_subsystems looking for an id that matches
4657 ss = GET_FIRST(&Ships[n].subsys_list);
4658 while ( ss != END_OF_LIST( &Ships[n].subsys_list ) ) {
4659 if ( ss->system_info->subobj_num == ptindex ) { // when these are equal, fix up the ref
4660 pm->paths[i].verts[j].turret_ids[k] = index; // in path structure to index a ship_subsys
4664 ss = GET_NEXT( ss );
4667 if ( ss == END_OF_LIST(&Ships[n].subsys_list) )
4668 Warning(LOCATION, "Couldn't fix up turret indices in spline path\n\nModel: %s\nPath: %s\nVertex: %d\nTurret model id:%d\n\nThis probably means the turret was not specified in ships.tbl", sip->pof_file, pm->paths[i].name, j, ptindex );
4672 sip->flags |= SIF_PATH_FIXUP;
4675 // reset the damage record fields (for scoring purposes)
4676 shipp->total_damage_received = 0.0f;
4677 for(i=0;i<MAX_DAMAGE_SLOTS;i++){
4678 shipp->damage_ship[i] = 0.0f;
4679 shipp->damage_ship_id[i] = -1;
4682 // Add this ship to Ship_obj_list
4683 shipp->ship_list_index = ship_obj_list_add(objnum);
4685 // Set time when ship is created
4686 shipp->create_time = timer_get_milliseconds();
4688 ship_make_create_time_unique(shipp);
4690 // set the team select index to be -1
4691 shipp->ts_index = -1;
4693 shipp->wing_status_wing_index = -1; // wing index (0-4) in wingman status gauge
4694 shipp->wing_status_wing_pos = -1; // wing position (0-5) in wingman status gauge
4696 // call the contrail system
4697 ct_ship_create(shipp);
4702 // ----------------------------------------------------------------
4703 // ship_model_change()
4705 // Change the ship model for a ship to that for ship class 'ship_type'
4707 // input: n => index of ship in Ships[] array
4708 // ship_type => ship class (index into Ship_info[])
4710 void ship_model_change(int n, int ship_type)
4717 SDL_assert( n >= 0 && n < MAX_SHIPS );
4719 sip = &(Ship_info[ship_type]);
4721 model_num = model_load(sip->pof_file, sip->n_subsystems, &sip->subsystems[0]); // use the highest detail level
4725 model_page_in_textures(model_num, ship_type);
4728 Objects[sp->objnum].radius = model_get_radius(model_num);
4729 sip->modelnum = model_num;
4730 sp->modelnum = model_num;
4733 pm = model_get(sp->modelnum);
4735 ship_copy_subsystem_fixup(sip);
4737 if ( sip->num_detail_levels < pm->n_detail_levels ) {
4738 Warning(LOCATION, "For ship '%s', detail level\nmismatch (POF needs %d)", sip->name, pm->n_detail_levels );
4740 for (i=0; i<pm->n_detail_levels; i++ ) {
4741 sip->detail_distance[i] = 0;
4745 for (i=0; i<sip->num_detail_levels; i++ ) {
4746 pm->detail_depth[i] = i2fl(sip->detail_distance[i]);
4750 // ----------------------------------------------------------------
4751 // change_ship_type()
4753 // Change the ship class on a ship, and changing all required information
4754 // for consistency (ie textures, subsystems, weapons, physics)
4756 // input: n => index of ship in Ships[] array
4757 // ship_type => ship class (index into Ship_info[])
4759 void change_ship_type(int n, int ship_type)
4766 SDL_assert( n >= 0 && n < MAX_SHIPS );
4768 sip = &(Ship_info[ship_type]);
4769 objp = &Objects[sp->objnum];
4771 // point to new ship data
4772 sp->ship_info_index = ship_type;
4774 ship_model_change(n, ship_type);
4776 // if the subsystem list is not currently empty, then we need to clear it out first.
4777 if ( NOT_EMPTY(&sp->subsys_list) ) {
4778 ship_subsys *ship_system, *tmp;
4780 for ( ship_system = GET_FIRST(&sp->subsys_list); ship_system != END_OF_LIST(&sp->subsys_list); ) {
4781 tmp = GET_NEXT(ship_system);
4782 list_remove( &sp->subsys_list, ship_system );
4783 list_append( &ship_subsys_free_list, ship_system );
4787 // fix up the subsystems
4788 subsys_set( sp->objnum );
4790 // set the correct hull strength
4792 objp->hull_strength = 100.0f;
4794 objp->hull_strength = sip->initial_hull_strength;
4797 // set the correct shields strength
4799 objp->shields[0] = 100.0f;
4801 set_shield_strength(objp, sip->shields);
4804 sp->afterburner_fuel = sip->afterburner_fuel_capacity;
4806 ship_set_default_weapons(sp, sip);
4807 physics_ship_init(&Objects[sp->objnum]);
4808 ets_init_ship(&Objects[sp->objnum]);
4809 // mwa removed the next line in favor of simply setting the ai_class in AI_info. ai_object_init
4810 // was trashing mode in ai_info when it was valid due to goals.
4811 //ai_object_init(&Objects[sp->objnum], sp->ai_index);
4812 Ai_info[sp->ai_index].ai_class = sip->ai_class;
4816 // Fire the debug laser
4817 int ship_fire_primary_debug(object *objp)
4820 ship *shipp = &Ships[objp->instance];
4823 if ( !timestamp_elapsed(shipp->weapons.next_primary_fire_stamp[0]) )
4826 // do timestamp stuff for next firing time
4827 shipp->weapons.next_primary_fire_stamp[0] = timestamp(250);
4829 // Debug code! Make the single laser fire only one bolt and from the object center!
4830 for (i=0; i<MAX_WEAPONS; i++)
4831 if (!SDL_strcasecmp(Weapon_info[i].name, NOX("Debug Laser")))
4834 vm_vec_add(&wpos, &objp->pos, &(objp->orient.v.fvec) );
4835 if (i != MAX_WEAPONS) {
4837 weapon_objnum = weapon_create( &wpos, &objp->orient, i, OBJ_INDEX(objp), 0 );
4838 weapon_set_tracking_info(weapon_objnum, OBJ_INDEX(objp), Ai_info[shipp->ai_index].target_objnum);
4845 // Launch countermeasures from object *objp. rand_val is used in multiplayer to ensure that all
4846 // clients in the game fire countermeasure the same way
4847 int ship_launch_countermeasure(object *objp, int rand_val)
4849 int fired, check_count, cmeasure_count;
4853 shipp = &Ships[objp->instance];
4855 // in the case where the server is an observer, he can launch countermeasures unless we do this.
4856 if( objp->type == OBJ_OBSERVER){
4860 if ( !timestamp_elapsed(shipp->cmeasure_fire_stamp) ){
4864 shipp->cmeasure_fire_stamp = timestamp(CMEASURE_WAIT); // Can launch every half second.
4866 if (Weapon_energy_cheat) {
4867 shipp->cmeasure_count++;
4871 // we might check the count of countermeasures left depending on game state. Multiplayer clients
4872 // do not need to check any objects other than themselves for the count
4875 if ( MULTIPLAYER_CLIENT && (objp != Player_obj) ){
4879 if (check_count && (shipp->cmeasure_count <= 0) ) {
4880 if ( objp == Player_obj ) {
4881 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "No more countermeasure charges.", 485));
4882 snd_play( &Snds[SND_OUT_OF_MISSLES], 0.0f );
4885 // if we have a player ship, then send the fired packet anyway so that the player
4886 // who fired will get his 'out of countermeasures' sound
4888 if ( objp->flags & OF_PLAYER_SHIP ){
4889 goto send_countermeasure_fired;
4895 cmeasure_count = shipp->cmeasure_count;
4896 shipp->cmeasure_count--;
4898 vm_vec_scale_add(&pos, &objp->pos, &objp->orient.v.fvec, -objp->radius/2.0f);
4900 // cmeasure_create fires 1 countermeasure. returns -1 if not fired, otherwise a non-negative
4902 fired = cmeasure_create( objp, &pos, shipp->current_cmeasure, rand_val );
4904 // Play sound effect for counter measure launch
4905 SDL_assert(shipp->current_cmeasure < Num_cmeasure_types);
4906 if ( Cmeasure_info[shipp->current_cmeasure].launch_sound != -1 ) {
4907 snd_play_3d( &Snds[Cmeasure_info[shipp->current_cmeasure].launch_sound], &pos, &View_position );
4911 send_countermeasure_fired:
4912 // the new way of doing things
4913 // if(Netgame.debug_flags & NETD_FLAG_CLIENT_FIRING){
4914 if(Game_mode & GM_MULTIPLAYER){
4915 send_NEW_countermeasure_fired_packet( objp, cmeasure_count, fired );
4918 // the old way of doing things
4920 // if ( MULTIPLAYER_MASTER ){
4921 // send_countermeasure_fired_packet( objp, cmeasure_count, fired );
4925 return (fired>0); // return 0 if not fired, 1 otherwise
4928 // internal function.. see if enough time has elapsed to play fail sound again
4929 int ship_maybe_play_primary_fail_sound()
4931 hud_start_flash_weapon(Player_ship->weapons.current_primary_bank);
4933 if ( timestamp_elapsed(Laser_energy_out_snd_timer) ) {
4934 Laser_energy_out_snd_timer = timestamp(50);
4935 snd_play( &Snds[SND_OUT_OF_WEAPON_ENERGY]);
4941 // internal function.. see if enough time has elapsed to play fail sound again
4942 int ship_maybe_play_secondary_fail_sound(weapon_info *wip)
4944 hud_start_flash_weapon(Player_ship->weapons.num_primary_banks + Player_ship->weapons.current_secondary_bank);
4946 if ( timestamp_elapsed(Missile_out_snd_timer) ) {
4948 if ( wip->wi_flags & WIF_SWARM ) {
4949 Missile_out_snd_timer = timestamp(500);
4951 Missile_out_snd_timer = timestamp(50);
4953 snd_play( &Snds[SND_OUT_OF_MISSLES] );
4959 // internal function.. see if weapon for ship can fire based on weapons subystem
4962 // returns: 1 => weapon failed to fire
4963 // 0 => weapon can fire
4964 int ship_weapon_maybe_fail(ship *sp)
4967 float weapons_subsys_str;
4969 // If playing on lowest skill level, weapons will not fail due to subsystem damage
4970 if ( Game_skill_level == 0 ){
4975 weapons_subsys_str = ship_get_subsystem_strength( sp, SUBSYSTEM_WEAPONS );
4976 if ( weapons_subsys_str < SUBSYS_WEAPONS_STR_FIRE_FAIL ) {
4979 else if ( weapons_subsys_str < SUBSYS_WEAPONS_STR_FIRE_OK ) {
4980 // chance to fire depends on weapons subsystem strength
4981 if ( (frand()-0.2f) > weapons_subsys_str )
4986 // is subsystem disrupted?
4987 if ( ship_subsys_disrupted(sp, SUBSYSTEM_WEAPONS) ) {
4995 // create a moving tracer based upon a weapon which just fired
4997 float t_len = 10.0f;
4999 float t_min = 150.0f;
5000 float t_max = 300.0f;
5003 dc_get_arg(ARG_FLOAT);
5004 t_rad = Dc_arg_float;
5008 dc_get_arg(ARG_FLOAT);
5009 t_len = Dc_arg_float;
5013 dc_get_arg(ARG_FLOAT);
5014 t_vel = Dc_arg_float;
5018 dc_get_arg(ARG_FLOAT);
5019 t_min = Dc_arg_float;
5023 dc_get_arg(ARG_FLOAT);
5024 t_max = Dc_arg_float;
5026 void ship_fire_tracer(int weapon_objnum)
5028 particle_info pinfo;
5029 object *objp = &Objects[weapon_objnum];
5030 weapon_info *wip = &Weapon_info[Weapons[Objects[weapon_objnum].instance].weapon_info_index];
5032 // setup particle info
5033 memset(&pinfo, 0, sizeof(particle_info));
5034 pinfo.pos = objp->pos;
5035 pinfo.vel = objp->phys_info.vel;
5036 vm_vec_scale(&pinfo.vel, t_vel);
5037 pinfo.lifetime = wip->lifetime;
5039 pinfo.type = PARTICLE_BITMAP;
5040 pinfo.optional_data = wip->laser_bitmap;
5041 pinfo.tracer_length = t_len;
5043 pinfo.attached_objnum = -1;
5044 pinfo.attached_sig = 0;
5046 // create the particle
5047 particle_create(&pinfo);
5050 // Multiplicative delay factors for increasing skill levels.
5051 float Ship_fire_delay_scale_hostile[NUM_SKILL_LEVELS] = {4.0f, 2.5f, 1.75f, 1.25f, 1.0f};
5052 float Ship_fire_delay_scale_friendly[NUM_SKILL_LEVELS] = {2.0f, 1.4f, 1.25f, 1.1f, 1.0f};
5054 int tracers[MAX_SHIPS][4][4];
5056 // fires a primary weapon for the given object. It also handles multiplayer cases.
5057 // in multiplayer, the starting network signature, and number of banks fired are sent
5058 // to all the clients in the game. All the info is passed to send_primary at the end of
5059 // the function. The check_energy parameter (defaults to 1) tells us whether or not
5060 // we should check the energy. It will be 0 when a multiplayer client is firing an AI
5062 int ship_fire_primary(object * obj, int stream_weapons, int force)
5064 vector gun_point, pnt, firing_pos;
5065 int n = obj->instance;
5069 int weapon, i, j, weapon_objnum;
5070 int bank_to_fire, num_fired = 0;
5071 int banks_fired;//, have_timeout; // used for multiplayer to help determine whether or not to send packet
5072 // have_timeout = 0; // used to help tell us whether or not we need to send a packet
5073 banks_fired = 0; // used in multiplayer -- bitfield of banks that were fired
5075 int sound_played; // used to track what sound is played. If the player is firing two banks
5076 // of the same laser, we only want to play one sound
5077 SDL_assert( obj != NULL );
5083 // in the case where the server is an observer, he can fire (which) would be bad - unless we do this.
5084 if( obj->type == OBJ_OBSERVER){
5088 SDL_assert( obj->type == OBJ_SHIP );
5089 SDL_assert( n >= 0 );
5090 SDL_assert( Ships[n].objnum == OBJ_INDEX(obj));
5091 if((obj->type != OBJ_SHIP) || (n < 0) || (n >= MAX_SHIPS) || (Ships[n].objnum != OBJ_INDEX(obj))){
5096 swp = &shipp->weapons;
5099 if((shipp->ship_info_index < 0) || (shipp->ship_info_index >= Num_ship_types)){
5102 if((shipp->ai_index < 0) || (shipp->ai_index >= MAX_AI_INFO)){
5106 aip = &Ai_info[shipp->ai_index];
5108 if ( swp->num_primary_banks <= 0 ) {
5112 if ( swp->current_primary_bank < 0 ){
5118 // Fire the correct primary bank. If primaries are linked (SF_PRIMARY_LINKED set), then fire
5119 // both primary banks.
5120 int num_primary_banks;
5122 if ( shipp->flags & SF_PRIMARY_LINKED ) {
5123 num_primary_banks = swp->num_primary_banks;
5125 num_primary_banks = SDL_min(1, swp->num_primary_banks);
5128 SDL_assert(num_primary_banks > 0);
5129 if (num_primary_banks < 1){
5133 // if we're firing stream weapons, but the trigger is not down, do nothing
5134 if(stream_weapons && !(shipp->flags & SF_TRIGGER_DOWN)){
5138 for ( i = 0; i < num_primary_banks; i++ ) {
5139 bank_to_fire = (swp->current_primary_bank+i)%2; // Max supported banks is 2
5141 weapon = swp->primary_bank_weapons[bank_to_fire];
5142 SDL_assert( weapon >= 0 && weapon < MAX_WEAPONS );
5143 if ( (weapon < 0) || (weapon >= MAX_WEAPON_TYPES) ) {
5144 Int3(); // why would a ship try to fire a weapon that doesn't exist?
5147 weapon_info* winfo_p = &Weapon_info[weapon];
5149 // if this is a targeting laser, start it up
5150 if((winfo_p->wi_flags & WIF_BEAM) && (winfo_p->b_info.beam_type == BEAM_TYPE_C)){
5151 ship_start_targeting_laser(shipp);
5155 // if we're firing stream weapons and this is a non stream weapon, skip it
5156 if(stream_weapons && !(winfo_p->wi_flags & WIF_STREAM)){
5159 // if we're firing non stream weapons and this is a stream weapon, skip it
5160 if(!stream_weapons && (winfo_p->wi_flags & WIF_STREAM)){
5164 // only non-multiplayer clients (single, multi-host) need to do timestamp checking
5165 if ( !timestamp_elapsed(swp->next_primary_fire_stamp[bank_to_fire]) ) {
5166 if (timestamp_until(swp->next_primary_fire_stamp[bank_to_fire]) > 5000){
5167 swp->next_primary_fire_stamp[bank_to_fire] = timestamp(1000);
5170 // have_timeout = 1;
5174 //nprintf(("AI", "Time = %7.3f, firing %s\n", f2fl(Missiontime), Weapon_info[weapon].name));
5176 // do timestamp stuff for next firing time
5177 float next_fire_delay = (float) winfo_p->fire_wait * 1000.0f;
5178 if (!(obj->flags & OF_PLAYER_SHIP)) {
5179 if (shipp->team == Ships[Player_obj->instance].team){
5180 next_fire_delay *= Ship_fire_delay_scale_friendly[Game_skill_level];
5182 next_fire_delay *= Ship_fire_delay_scale_hostile[Game_skill_level];
5186 next_fire_delay *= 1.0f + (num_primary_banks - 1) * 0.5f; // 50% time penalty if banks linked
5188 // MK, 2/4/98: Since you probably were allowed to fire earlier, but couldn't fire until your frame interval
5189 // rolled around, subtract out up to half the previous frametime.
5190 // Note, unless we track whether the fire button has been held down, and not tapped, it's hard to
5191 // know how much time to subtract off. It could be this fire is "late" because the user didn't want to fire.
5192 if (next_fire_delay > 0.0f) {
5193 if (obj->flags & OF_PLAYER_SHIP) {
5194 int t = timestamp_until(swp->next_primary_fire_stamp[bank_to_fire]);
5198 tx = (float) t/-1000.0f;
5199 if (tx > flFrametime/2.0f){
5200 tx = 1000.0f * flFrametime * 0.7f;
5202 next_fire_delay -= tx;
5205 if ((int) next_fire_delay < 1){
5206 next_fire_delay = 1.0f;
5210 swp->next_primary_fire_stamp[bank_to_fire] = timestamp((int)(next_fire_delay));
5213 // Here is where we check if weapons subsystem is capable of firing the weapon.
5214 // Note that we can have partial bank firing, if the weapons subsystem is partially
5215 // functional, which should be cool.
5216 if ( ship_weapon_maybe_fail(shipp) && !force) {
5217 if ( obj == Player_obj ) {
5218 if ( ship_maybe_play_primary_fail_sound() ) {
5224 polymodel *po = model_get( Ship_info[shipp->ship_info_index].modelnum );
5225 if ( po->n_guns > 0 ) {
5226 int num_slots = po->gun_banks[bank_to_fire].num_slots;
5228 // fail unless we're forcing (energy based primaries)
5229 if ( (shipp->weapon_energy < num_slots*winfo_p->energy_consumed) && !force) {
5230 if ( obj == Player_obj ) {
5231 swp->next_primary_fire_stamp[bank_to_fire] = timestamp(swp->next_primary_fire_stamp[bank_to_fire]);
5232 if ( ship_maybe_play_primary_fail_sound() ) {
5238 // deplete the weapon reserve energy by the amount of energy used to fire the weapon
5239 shipp->weapon_energy -= num_slots*winfo_p->energy_consumed;
5240 if(shipp->weapon_energy < 0.0f){
5241 shipp->weapon_energy = 0.0f;
5244 // Mark all these weapons as in the same group
5245 int new_group_id = weapon_create_group_id();
5247 for ( j = 0; j < num_slots; j++ ) {
5248 pnt = po->gun_banks[bank_to_fire].pnt[j];
5249 vm_vec_unrotate(&gun_point, &pnt, &obj->orient);
5250 vm_vec_add(&firing_pos, &gun_point, &obj->pos);
5252 // create the weapon -- the network signature for multiplayer is created inside
5254 weapon_objnum = weapon_create( &firing_pos, &obj->orient, weapon, OBJ_INDEX(obj),0, new_group_id );
5255 weapon_set_tracking_info(weapon_objnum, OBJ_INDEX(obj), aip->target_objnum, aip->current_target_is_locked, aip->targeted_subsys);
5257 // create the muzzle flash effect
5258 shipfx_flash_create( obj, shipp, &pnt, &obj->orient.v.fvec, 1, weapon );
5260 // maybe shudder the ship - if its me
5261 if((winfo_p->wi_flags & WIF_SHUDDER) && (obj == Player_obj) && !(Game_mode & GM_STANDALONE_SERVER)){
5262 // calculate some arbitrary value between 100
5263 // (mass * velocity) / 10
5264 game_shudder_apply(500, (winfo_p->mass * winfo_p->max_speed) / 10.0f);
5270 banks_fired |= (1<<bank_to_fire); // mark this bank as fired.
5273 // Only play the weapon fired sound if it hasn't been played yet. This is to
5274 // avoid playing the same sound multiple times when banks are linked with the
5276 if ( sound_played != winfo_p->launch_snd ) {
5277 sound_played = winfo_p->launch_snd;
5278 if ( obj == Player_obj ) {
5279 if ( winfo_p->launch_snd != -1 ) {
5284 if(winfo_p->launch_snd == SND_AUTOCANNON_SHOT){
5285 snd_play( &Snds[winfo_p->launch_snd], 0.0f, 1.0f, SND_PRIORITY_TRIPLE_INSTANCE );
5287 snd_play( &Snds[winfo_p->launch_snd], 0.0f, 1.0f, SND_PRIORITY_MUST_PLAY );
5289 // snd_play( &Snds[winfo_p->launch_snd] );
5291 swp2 = &Player_ship->weapons;
5292 if (swp2->current_primary_bank >= 0) {
5293 wip = &Weapon_info[swp->primary_bank_weapons[swp2->current_primary_bank]];
5294 joy_ff_play_primary_shoot((int) ((wip->armor_factor + wip->shield_factor * 0.2f) * (wip->damage * wip->damage - 7.5f) * 0.45f + 0.6f) * 10 + 2000);
5299 if ( winfo_p->launch_snd != -1 ) {
5300 snd_play_3d( &Snds[winfo_p->launch_snd], &obj->pos, &View_position );
5304 } // end for (go to next primary bank)
5306 // if multiplayer and we're client-side firing, send the packet
5307 // if((Game_mode & GM_MULTIPLAYER) && (Netgame.debug_flags & NETD_FLAG_CLIENT_FIRING)){
5308 if(Game_mode & GM_MULTIPLAYER){
5309 // if i'm a client, and this is not me, don't send
5310 if(!(MULTIPLAYER_CLIENT && (shipp != Player_ship))){
5311 send_NEW_primary_fired_packet( shipp, banks_fired );
5315 // post a primary fired event
5316 if(Game_mode & GM_DEMO_RECORD){
5317 demo_POST_primary_fired(obj, swp->current_primary_bank, shipp->flags & SF_PRIMARY_LINKED);
5321 if (obj->flags & OF_PLAYER_SHIP) {
5322 // in multiplayer -- only the server needs to keep track of the stats. Call the cool
5323 // function to find the player given the object *. It had better return a valid player
5324 // or our internal structure as messed up.
5325 if( Game_mode & GM_MULTIPLAYER ) {
5326 if ( Net_player->flags & NETINFO_FLAG_AM_MASTER ) {
5329 player_num = multi_find_player_by_object ( obj );
5330 SDL_assert ( player_num != -1 );
5332 Net_players[player_num].player->stats.mp_shots_fired += num_fired;
5335 Player->stats.mp_shots_fired += num_fired;
5342 void ship_start_targeting_laser(ship *shipp)
5344 int bank0_laser = 0;
5345 int bank1_laser = 0;
5347 // determine if either of our banks have a targeting laser
5348 if((shipp->weapons.primary_bank_weapons[0] >= 0) && (Weapon_info[shipp->weapons.primary_bank_weapons[0]].wi_flags & WIF_BEAM) && (Weapon_info[shipp->weapons.primary_bank_weapons[0]].b_info.beam_type == BEAM_TYPE_C)){
5351 if((shipp->weapons.primary_bank_weapons[1] >= 0) && (Weapon_info[shipp->weapons.primary_bank_weapons[1]].wi_flags & WIF_BEAM) && (Weapon_info[shipp->weapons.primary_bank_weapons[1]].b_info.beam_type == BEAM_TYPE_C)){
5355 // if primary banks are linked
5356 if(shipp->flags & SF_PRIMARY_LINKED){
5358 shipp->targeting_laser_bank = 0;
5362 shipp->targeting_laser_bank = 1;
5366 // if we only have 1 bank selected
5368 if(bank0_laser && (shipp->weapons.current_primary_bank == 0)){
5369 shipp->targeting_laser_bank = 0;
5372 if(bank1_laser && (shipp->weapons.current_primary_bank == 1)){
5373 shipp->targeting_laser_bank = 1;
5379 void ship_stop_targeting_laser(ship *shipp)
5381 shipp->targeting_laser_bank = -1;
5382 shipp->targeting_laser_objnum = -1;
5385 void ship_process_targeting_lasers()
5387 beam_fire_info fire_info;
5392 // interate over all ships
5393 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
5398 if(Objects[so->objnum].type != OBJ_SHIP){
5401 if(Objects[so->objnum].instance < 0){
5404 shipp = &Ships[Objects[so->objnum].instance];
5406 // if our trigger is no longer down, switch it off
5407 if(!(shipp->flags & SF_TRIGGER_DOWN)){
5408 ship_stop_targeting_laser(shipp);
5412 // if we have a bank to fire - fire it
5413 if((shipp->targeting_laser_bank >= 0) && (shipp->targeting_laser_bank < 2)){
5414 // try and get the model
5415 m = model_get(shipp->modelnum);
5420 // fire a targeting laser
5421 fire_info.accuracy = 0.0f;
5422 fire_info.beam_info_index = shipp->weapons.primary_bank_weapons[(int)shipp->targeting_laser_bank];
5423 fire_info.beam_info_override = NULL;
5424 fire_info.shooter = &Objects[shipp->objnum];
5425 fire_info.target = NULL;
5426 fire_info.target_subsys = NULL;
5427 fire_info.turret = NULL;
5428 fire_info.targeting_laser_offset = m->gun_banks[(int)shipp->targeting_laser_bank].pnt[0];
5429 shipp->targeting_laser_objnum = beam_fire_targeting(&fire_info);
5431 // hmm, why didn't it fire?
5432 if(shipp->targeting_laser_objnum < 0){
5434 ship_stop_targeting_laser(shipp);
5440 // Attempt to detonate weapon last fired by *shipp.
5441 // Only used for weapons that support remote detonation.
5442 // Return true if detonated, else return false.
5443 // Calls weapon_hit() to detonate weapon.
5444 // If it's a weapon that spawns particles, those will be released.
5445 int maybe_detonate_weapon(ship_weapon *swp, object *src)
5447 int objnum = swp->last_fired_weapon_index;
5451 objp = &Objects[objnum];
5453 if (objp->type != OBJ_WEAPON){
5457 if ((objp->instance < 0) || (objp->instance > MAX_WEAPONS)){
5461 // check to make sure that the weapon to detonate still exists
5462 if ( swp->last_fired_weapon_signature != objp->signature ){
5466 SDL_assert(Weapons[objp->instance].weapon_info_index != -1);
5467 wip = &Weapon_info[Weapons[objp->instance].weapon_info_index];
5469 if (wip->wi_flags & WIF_REMOTE) {
5471 if ((objnum >= 0) && (objnum < MAX_OBJECTS)) {
5474 weapon_sig = objp->signature;
5476 if (swp->last_fired_weapon_signature == weapon_sig) {
5477 weapon_detonate(objp);
5478 swp->last_fired_weapon_index = -1;
5481 if (src == Player_obj) {
5482 char missile_name[NAME_LENGTH];
5483 strcpy(missile_name, wip->name);
5484 hud_end_string_at_first_hash_symbol(missile_name);
5485 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "Detonated %s!", 486), missile_name);
5497 // Maybe detonate secondary weapon that's already out.
5498 // Return true if we detonate it, false if not.
5499 int ship_fire_secondary_detonate(object *obj, ship_weapon *swp)
5501 if (swp->last_fired_weapon_index != -1)
5502 if (timestamp_elapsed(swp->detonate_weapon_time)) {
5503 object *first_objp = &Objects[swp->last_fired_weapon_index];
5504 if (maybe_detonate_weapon(swp, obj)) {
5505 // If dual fire was set, there could be another weapon to detonate. Scan all weapons.
5508 //nprintf(("AI", "Weapon %i detonated\n", first_objp-Objects));
5510 // check for currently locked missiles (highest precedence)
5511 for ( mo = GET_FIRST(&Missile_obj_list); mo != END_OF_LIST(&Missile_obj_list); mo = GET_NEXT(mo) ) {
5513 SDL_assert(mo->objnum >= 0 && mo->objnum < MAX_OBJECTS);
5514 mobjp = &Objects[mo->objnum];
5515 if ((mobjp != first_objp) && (mobjp->parent_sig == obj->parent_sig)) {
5516 if (Weapon_info[Weapons[mobjp->instance].weapon_info_index].wi_flags & WIF_REMOTE) {
5517 //nprintf(("AI", "Also detonating weapon %i whose parent is %s\n", mobjp-Objects, Ships[Objects[mobjp->parent].instance].ship_name));
5518 weapon_detonate(mobjp);
5530 // Try to switch to a secondary bank that has ammo
5531 int ship_select_next_valid_secondary_bank(ship_weapon *swp)
5535 int ns = swp->num_secondary_banks;
5538 int i,j=swp->current_secondary_bank+1;
5539 for (i=0; i<ns; i++) {
5544 if ( swp->secondary_bank_ammo[j] > 0 ) {
5545 swp->current_secondary_bank=j;
5558 extern void ai_maybe_announce_shockwave_weapon(object *firing_objp, int weapon_index);
5560 // Object *obj fires its secondary weapon, if it can.
5561 // If its most recently fired weapon is a remotely detonatable weapon, detonate it.
5562 // Returns number of weapons fired. Note, for swarmers, returns 1 if it is allowed
5563 // to fire the missiles when allow_swarm is NOT set. They don't actually get fired on a call here unless allow_swarm is set.
5564 // When you want to fire swarmers, you call this function with allow_swarm NOT set and frame interval
5565 // code comes aruond and fires it.
5566 // allow_swarm -> default value is 0... since swarm missiles are fired over several frames,
5567 // need to avoid firing when normally called
5568 int ship_fire_secondary( object *obj, int allow_swarm )
5570 int n, weapon, j, bank, starting_bank_count = -1, num_fired;
5571 // int have_timeout;
5572 ushort starting_sig = 0;
5578 vector missile_point, pnt, firing_pos;
5580 SDL_assert( obj != NULL );
5582 // in the case where the server is an observer, he can fire (which would be bad) - unless we do this.
5583 if( obj->type == OBJ_OBSERVER ){
5587 // in the case where the object is a ghost (a delayed fire packet from right before he died, for instance)
5588 if( (obj->type == OBJ_GHOST) || (obj->type == OBJ_NONE) ){
5592 SDL_assert( obj->type == OBJ_SHIP );
5593 if(obj->type != OBJ_SHIP){
5597 SDL_assert( n >= 0 && n < MAX_SHIPS );
5598 if((n < 0) || (n >= MAX_SHIPS)){
5601 SDL_assert( Ships[n].objnum == OBJ_INDEX(obj));
5602 if(Ships[n].objnum != OBJ_INDEX(obj)){
5607 swp = &shipp->weapons;
5608 aip = &Ai_info[shipp->ai_index];
5610 // if no secondary weapons are present on ship, return
5611 if ( swp->num_secondary_banks <= 0 ){
5615 // If ship is being repaired/rearmed, it cannot fire missiles
5616 if ( aip->ai_flags & AIF_BEING_REPAIRED ) {
5620 num_fired = 0; // tracks how many missiles actually fired
5622 bank = swp->current_secondary_bank;
5627 weapon = swp->secondary_bank_weapons[bank];
5628 SDL_assert( (swp->secondary_bank_weapons[bank] >= 0) && (swp->secondary_bank_weapons[bank] < MAX_WEAPON_TYPES) );
5629 if((swp->secondary_bank_weapons[bank] < 0) || (swp->secondary_bank_weapons[bank] >= MAX_WEAPON_TYPES)){
5632 wip = &Weapon_info[swp->secondary_bank_weapons[bank]];
5634 // have_timeout = 0; // used to help tell whether or not we have a timeout
5635 if ( MULTIPLAYER_MASTER ) {
5636 starting_sig = multi_get_next_network_signature( MULTI_SIG_NON_PERMANENT );
5637 starting_bank_count = swp->secondary_bank_ammo[bank];
5640 if (ship_fire_secondary_detonate(obj, swp)) {
5641 // in multiplayer, master sends a secondary fired packet with starting signature of -1 -- indicates
5642 // to client code to set the detonate timer to 0.
5643 if ( MULTIPLAYER_MASTER ) {
5644 // MWA -- 4/6/98 SDL_assert invalid since the bank count could have gone to 0.
5645 //SDL_assert(starting_bank_count != 0);
5646 send_secondary_fired_packet( shipp, 0, starting_bank_count, 1, allow_swarm );
5649 // For all banks, if ok to fire a weapon, make it wait a bit.
5650 // Solves problem of fire button likely being down next frame and
5651 // firing weapon despite fire causing detonation of existing weapon.
5652 if (swp->current_secondary_bank >= 0) {
5653 if (timestamp_elapsed(swp->next_secondary_fire_stamp[bank])){
5654 swp->next_secondary_fire_stamp[bank] = timestamp(SDL_max((int) flFrametime*3000, 250));
5660 if ( swp->current_secondary_bank < 0 ){
5664 if ( !timestamp_elapsed(swp->next_secondary_fire_stamp[bank]) && !allow_swarm) {
5665 if (timestamp_until(swp->next_secondary_fire_stamp[bank]) > 60000){
5666 swp->next_secondary_fire_stamp[bank] = timestamp(1000);
5668 // have_timeout = 1;
5669 goto done_secondary;
5672 // Ensure if this is a "require-lock" missile, that a lock actually exists
5673 if ( wip->wi_flags & WIF_NO_DUMBFIRE ) {
5674 if ( aip->current_target_is_locked <= 0 ) {
5675 if ( obj == Player_obj ) {
5676 if ( !Weapon_energy_cheat ) {
5677 if ((aip->target_objnum != -1) && (vm_vec_dist_quick(&obj->pos, &Objects[aip->target_objnum].pos) > wip->lifetime * wip->max_speed)) {
5678 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "Too far from target to acquire lock", 487));
5680 char missile_name[NAME_LENGTH];
5681 SDL_strlcpy(missile_name, wip->name, SDL_arraysize(missile_name));
5682 hud_end_string_at_first_hash_symbol(missile_name);
5683 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "Cannot fire %s without a lock", 488), missile_name);
5686 snd_play( &Snds[SND_OUT_OF_MISSLES] );
5687 swp->next_secondary_fire_stamp[bank] = timestamp(800); // to avoid repeating messages
5691 // multiplayer clients should always fire the weapon here, so return only if not
5692 // a multiplayer client.
5693 if ( !MULTIPLAYER_CLIENT ){
5700 // if trying to fire a swarm missile, make sure being called from right place
5701 if ( (wip->wi_flags & WIF_SWARM) && !allow_swarm ) {
5702 SDL_assert(wip->swarm_count > 0);
5703 if(wip->swarm_count <= 0){
5704 shipp->num_swarm_missiles_to_fire += SWARM_DEFAULT_NUM_MISSILES_FIRED;
5706 shipp->num_swarm_missiles_to_fire += wip->swarm_count;
5708 return 1; // Note: Missiles didn't get fired, but the frame interval code will fire them.
5711 // if trying to fire a corkscrew missile, make sure being called from right place
5712 if ( (wip->wi_flags & WIF_CORKSCREW) && !allow_swarm ) {
5713 shipp->num_corkscrew_to_fire = (ubyte)(shipp->num_corkscrew_to_fire + (ubyte)Corkscrew_num_missiles_fired);
5714 return 1; // Note: Missiles didn't get fired, but the frame interval code will fire them.
5717 swp->next_secondary_fire_stamp[bank] = timestamp((int)(Weapon_info[weapon].fire_wait * 1000.0f)); // They can fire 5 times a second
5719 // Here is where we check if weapons subsystem is capable of firing the weapon.
5720 // do only in single plyaer or if I am the server of a multiplayer game
5721 if ( !(Game_mode & GM_MULTIPLAYER) || MULTIPLAYER_MASTER ) {
5722 if ( ship_weapon_maybe_fail(shipp) ) {
5723 if ( obj == Player_obj )
5724 if ( ship_maybe_play_secondary_fail_sound(wip) ) {
5725 char missile_name[NAME_LENGTH];
5726 SDL_strlcpy(missile_name, Weapon_info[weapon].name, SDL_arraysize(missile_name));
5727 hud_end_string_at_first_hash_symbol(missile_name);
5728 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "Cannot fire %s due to weapons system damage", 489), missile_name);
5730 goto done_secondary;
5734 po = model_get( Ship_info[shipp->ship_info_index].modelnum );
5735 if ( po->n_missiles > 0 ) {
5736 int check_ammo; // used to tell if we should check ammo counts or not
5739 if ( bank > po->n_missiles ) {
5740 nprintf(("WARNING","WARNING ==> Tried to fire bank %d, but ship has only %d banks\n", bank+1, po->n_missiles));
5741 return 0; // we can make a quick out here!!!
5744 num_slots = po->missile_banks[bank].num_slots;
5746 // determine if there is enough ammo left to fire weapons on this bank. As with primary
5747 // weapons, we might or might not check ammo counts depending on game mode, who is firing,
5748 // and if I am a client in multiplayer
5750 if ( MULTIPLAYER_CLIENT && (obj != Player_obj) ){
5754 if ( check_ammo && ( swp->secondary_bank_ammo[bank] <= 0) ) {
5755 if ( shipp->objnum == OBJ_INDEX(Player_obj) ) {
5756 if ( ship_maybe_play_secondary_fail_sound(wip) ) {
5757 // HUD_sourced_printf(HUD_SOURCE_HIDDEN, "No %s missiles left in bank", Weapon_info[swp->secondary_bank_weapons[bank]].name);
5761 // TODO: AI switch secondary weapon / re-arm?
5763 goto done_secondary;
5766 int start_slot, end_slot;
5768 if ( shipp->flags & SF_SECONDARY_DUAL_FIRE ) {
5769 start_slot = swp->secondary_next_slot[bank];
5770 // AL 11-19-97: Ensure enough ammo remains when firing linked secondary weapons
5771 if ( check_ammo && (swp->secondary_bank_ammo[bank] < 2) ) {
5772 end_slot = start_slot;
5774 end_slot = start_slot+1;
5777 start_slot = swp->secondary_next_slot[bank];
5778 end_slot = start_slot;
5781 int pnt_index=start_slot;
5782 for ( j = start_slot; j <= end_slot; j++ ) {
5785 swp->secondary_next_slot[bank]++;
5786 if ( swp->secondary_next_slot[bank] > (num_slots-1) ){
5787 swp->secondary_next_slot[bank] = 0;
5790 if ( pnt_index >= num_slots ){
5793 pnt = po->missile_banks[bank].pnt[pnt_index++];
5794 vm_vec_unrotate(&missile_point, &pnt, &obj->orient);
5795 vm_vec_add(&firing_pos, &missile_point, &obj->pos);
5797 if ( Game_mode & GM_MULTIPLAYER ) {
5798 SDL_assert( Weapon_info[weapon].subtype == WP_MISSILE );
5801 // create the weapon -- for multiplayer, the net_signature is assigned inside
5803 weapon_num = weapon_create( &firing_pos, &obj->orient, weapon, OBJ_INDEX(obj), 0, -1, aip->current_target_is_locked);
5804 weapon_set_tracking_info(weapon_num, OBJ_INDEX(obj), aip->target_objnum, aip->current_target_is_locked, aip->targeted_subsys);
5806 // create the muzzle flash effect
5807 shipfx_flash_create( obj, shipp, &pnt, &obj->orient.v.fvec, 0, weapon );
5810 if ( weapon_num != -1 )
5811 Demo_fire_secondary_requests++; // testing for demo
5814 swp->last_fired_weapon_index = weapon_num;
5815 swp->detonate_weapon_time = timestamp(500); // Can detonate 1/2 second later.
5816 if (weapon_num != -1) {
5817 swp->last_fired_weapon_signature = Objects[weapon_num].signature;
5820 // subtract the number of missiles fired
5821 if ( Weapon_energy_cheat == 0 ){
5822 swp->secondary_bank_ammo[bank]--;
5827 if ( obj == Player_obj ) {
5828 if ( Weapon_info[weapon].launch_snd != -1 ) {
5832 snd_play( &Snds[Weapon_info[weapon].launch_snd], 0.0f, 1.0f, SND_PRIORITY_MUST_PLAY );
5833 swp2 = &Player_ship->weapons;
5834 if (swp2->current_secondary_bank >= 0) {
5835 wip2 = &Weapon_info[swp2->secondary_bank_weapons[swp2->current_secondary_bank]];
5836 if (Player_ship->flags & SF_SECONDARY_DUAL_FIRE){
5837 joy_ff_play_secondary_shoot((int) (wip2->cargo_size * 2.0f));
5839 joy_ff_play_secondary_shoot((int) wip2->cargo_size);
5845 if ( Weapon_info[weapon].launch_snd != -1 ) {
5846 snd_play_3d( &Snds[Weapon_info[weapon].launch_snd], &obj->pos, &View_position );
5853 // if I am the master of a multiplayer game, send a secondary fired packet along with the
5854 // first network signatures for the newly created weapons. if nothing got fired, send a failed
5856 if ( MULTIPLAYER_MASTER ) {
5857 SDL_assert(starting_sig != 0);
5858 send_secondary_fired_packet( shipp, starting_sig, starting_bank_count, num_fired, allow_swarm );
5862 if (obj->flags & OF_PLAYER_SHIP) {
5863 // in multiplayer -- only the server needs to keep track of the stats. Call the cool
5864 // function to find the player given the object *. It had better return a valid player
5865 // or our internal structure as messed up.
5866 if( Game_mode & GM_MULTIPLAYER ) {
5867 if ( Net_player->flags & NETINFO_FLAG_AM_MASTER ) {
5870 player_num = multi_find_player_by_object ( obj );
5871 SDL_assert ( player_num != -1 );
5873 Net_players[player_num].player->stats.ms_shots_fired += num_fired;
5876 Player->stats.ms_shots_fired += num_fired;
5879 // maybe announce a shockwave weapon
5880 ai_maybe_announce_shockwave_weapon(obj, weapon);
5883 // AL 3-7-98: Move to next valid secondary bank if out of ammo
5884 if ( (obj->flags & OF_PLAYER_SHIP) && (swp->secondary_bank_ammo[bank] <= 0) ) {
5885 int fire_wait = (int)(Weapon_info[weapon].fire_wait * 1000.0f);
5886 if ( ship_select_next_valid_secondary_bank(swp) ) {
5887 swp->next_secondary_fire_stamp[swp->current_secondary_bank] = SDL_max(timestamp(250),timestamp(fire_wait)); // 1/4 second delay until can fire
5888 if ( obj == Player_obj ) {
5889 snd_play( &Snds[SND_SECONDARY_CYCLE] );
5897 // ------------------------------------------------------------------------------
5898 // ship_select_next_primary()
5900 // Return true if a new index gets selected.
5902 // parameters: objp => pointer to object for ship cycling primary
5903 // direction => forward == CYCLE_PRIMARY_NEXT, backward == CYCLE_PRIMARY_PREV
5905 // NOTE: This code can be called for any arbitrary ship. HUD messages and sounds are only used
5906 // for the player ship.
5907 int ship_select_next_primary(object *objp, int direction)
5912 SDL_assert(objp != NULL);
5913 SDL_assert(objp->type == OBJ_SHIP);
5914 SDL_assert(objp->instance >= 0 && objp->instance < MAX_SHIPS);
5916 shipp = &Ships[objp->instance];
5917 swp = &shipp->weapons;
5919 SDL_assert(direction == CYCLE_PRIMARY_NEXT || direction == CYCLE_PRIMARY_PREV);
5921 switch ( swp->num_primary_banks ) {
5924 if ( objp == Player_obj ) {
5925 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "This ship has no primary weapons", 490));
5926 gamesnd_play_error_beep();
5932 if ( objp == Player_obj ) {
5933 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "This ship has only one primary weapon: %s", 491),Weapon_info[swp->primary_bank_weapons[swp->current_primary_bank]].name, swp->current_primary_bank + 1);
5934 gamesnd_play_error_beep();
5940 if ( shipp->flags & SF_PRIMARY_LINKED ) {
5941 shipp->flags &= ~SF_PRIMARY_LINKED;
5942 if ( direction == CYCLE_PRIMARY_NEXT ) {
5943 swp->current_primary_bank = 0;
5945 swp->current_primary_bank = 1;
5948 switch ( swp->current_primary_bank ) {
5950 if ( direction == CYCLE_PRIMARY_NEXT ) {
5951 swp->current_primary_bank = 1;
5953 shipp->flags |= SF_PRIMARY_LINKED;
5958 if ( direction == CYCLE_PRIMARY_NEXT ) {
5959 shipp->flags |= SF_PRIMARY_LINKED;
5961 swp->current_primary_bank = 0;
5966 Int3(); // should never happen, get Alan if it does
5974 Int3(); // should never happen, get Alan if it does
5979 if ( objp == Player_obj ) {
5980 snd_play( &Snds[SND_PRIMARY_CYCLE], 0.0f );
5983 ship_primary_changed(shipp);
5987 // ------------------------------------------------------------------------------
5988 // ship_select_next_secondary() selects the next secondary bank with missles
5990 // returns: 1 => The secondary bank was switched
5991 // 0 => The secondary bank stayed the same
5993 // If a secondary bank has no missles left, it is skipped.
5995 // NOTE: This can be called for an arbitrary ship. HUD messages and sounds are only used
5996 // for the player ship.
5997 int ship_select_next_secondary(object *objp)
5999 SDL_assert(objp != NULL);
6000 SDL_assert(objp->type == OBJ_SHIP);
6001 SDL_assert(objp->instance >= 0 && objp->instance < MAX_SHIPS);
6003 int original_bank, new_bank, i;
6007 shipp = &Ships[objp->instance];
6008 swp = &shipp->weapons;
6010 switch ( swp->num_secondary_banks ) {
6012 if ( objp == Player_obj ) {
6013 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "This ship has no secondary weapons", 492));
6014 gamesnd_play_error_beep();
6020 if ( objp == Player_obj ) {
6021 HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR( "This ship has only one secondary weapon: %s", 493), Weapon_info[swp->secondary_bank_weapons[swp->current_secondary_bank]].name, swp->current_secondary_bank + 1);
6022 gamesnd_play_error_beep();
6029 SDL_assert(swp->current_secondary_bank < swp->num_secondary_banks);
6030 original_bank = swp->current_secondary_bank;
6032 for ( i = 1; i < swp->num_secondary_banks; i++ ) {
6033 new_bank = (swp->current_secondary_bank+i) % swp->num_secondary_banks;
6034 if ( swp->secondary_bank_ammo[new_bank] <= 0 )
6036 swp->current_secondary_bank = new_bank;
6040 if ( swp->current_secondary_bank != original_bank ) {
6041 if ( objp == Player_obj ) {
6042 snd_play( &Snds[SND_SECONDARY_CYCLE], 0.0f );
6044 ship_secondary_changed(shipp);
6051 Int3(); // should never happen, get Alan if it does
6056 // If we've reached this point, must have failed
6060 // Stuff list of weapon indices for object *objp in list *outlist.
6061 // Return number of weapons in list.
6062 int get_available_secondary_weapons(object *objp, int *outlist, int *outbanklist)
6068 SDL_assert(objp->type == OBJ_SHIP);
6069 SDL_assert((objp->instance >= 0) && (objp->instance < MAX_SHIPS));
6070 shipp = &Ships[objp->instance];
6072 for (i=0; i<shipp->weapons.num_secondary_banks; i++)
6073 if (shipp->weapons.secondary_bank_ammo[i]) {
6074 outbanklist[count] = i;
6075 outlist[count++] = shipp->weapons.secondary_bank_weapons[i];
6081 // Return the object index of the ship with name *name.
6082 int wing_name_lookup(const char *name, int ignore_count)
6087 wing_limit = MAX_WINGS;
6089 wing_limit = num_wings;
6091 if (Fred_running || ignore_count ) { // current_count not used for Fred..
6092 for (i=0; i<wing_limit; i++)
6093 if (Wings[i].wave_count && !SDL_strcasecmp(Wings[i].name, name))
6097 for (i=0; i<wing_limit; i++)
6098 if (Wings[i].current_count && !SDL_strcasecmp(Wings[i].name, name))
6105 // this function is needed in addition to wing_name_lookup because it does a straight lookup without
6106 // caring about how many ships are in the wing, etc.
6107 int wing_lookup(const char *name)
6110 for(idx=0;idx<num_wings;idx++)
6111 if(strcmp(Wings[idx].name,name)==0)
6117 // Return the index of Ship_info[].name that is *name.
6118 int ship_info_lookup(const char *name)
6122 for (i=0; i < Num_ship_types; i++)
6123 if (!SDL_strcasecmp(name, Ship_info[i].name))
6129 // Return the index of Ship_info[].name which is the *base* ship of a ship copy
6130 int ship_info_base_lookup(int si_index)
6133 char name[NAME_LENGTH], *p;
6135 SDL_strlcpy( name, Ship_info[si_index].name, SDL_arraysize(name) );
6136 p = SDL_strchr( name, '#' );
6137 SDL_assert( p ); // get allender -- something bogus with ship copy
6140 i = ship_info_lookup( name );
6141 SDL_assert( i != -1 ); // get allender -- there had better be a base ship!
6146 // Return the ship index of the ship with name *name.
6147 int ship_name_lookup(const char *name, int inc_players)
6156 for (i=0; i<MAX_SHIPS; i++){
6157 if (Ships[i].objnum >= 0){
6158 if (Objects[Ships[i].objnum].type == OBJ_SHIP || (Objects[Ships[i].objnum].type == OBJ_START && inc_players)){
6159 if (!SDL_strcasecmp(name, Ships[i].ship_name)){
6170 int ship_type_name_lookup(const char *name)
6179 // look through the Ship_type_names array
6180 for(idx=0; idx<MAX_SHIP_TYPE_COUNTS; idx++){
6181 if(!SDL_strcasecmp(name, Ship_type_names[idx])){
6190 // checks the (arrival & departure) state of a ship. Return values:
6191 // -1: has yet to arrive in mission
6192 // 0: is currently in mission
6193 // 1: has been destroyed, departed, or never existsed
6194 int ship_query_state(char *name)
6204 for (i=0; i<MAX_SHIPS; i++){
6205 if (Ships[i].objnum >= 0){
6206 if ((Objects[Ships[i].objnum].type == OBJ_SHIP) || (Objects[Ships[i].objnum].type == OBJ_START)){
6207 if (!SDL_strcasecmp(name, Ships[i].ship_name)){
6214 objp = GET_FIRST(&ship_arrival_list);
6215 while (objp != END_OF_LIST(&ship_arrival_list)) {
6216 if (!SDL_strcasecmp(name, objp->name)){
6220 objp = GET_NEXT(objp);
6226 // Note: This is not a general purpose routine.
6227 // It is specifically used for targeting.
6228 // It only returns a subsystem position if it has shields.
6229 // Return true/false for subsystem found/not found.
6230 // Stuff vector *pos with absolute position.
6231 // subsysp is a pointer to the subsystem.
6232 int get_subsystem_pos(vector *pos, object *objp, ship_subsys *subsysp)
6235 model_subsystem *psub;
6238 SDL_assert(objp->type == OBJ_SHIP);
6240 SDL_assert ( subsysp != NULL );
6242 psub = subsysp->system_info;
6243 vm_copy_transpose_matrix(&m, &objp->orient);
6245 vm_vec_rotate(&pnt, &psub->pnt, &m);
6246 vm_vec_add2(&pnt, &objp->pos);
6255 //=================================================
6256 // Takes all the angle info from the ship structure and stuffs it
6257 // into the model data so that the model code has all the correct
6258 // angles and stuff that it needs. This is a poorly designed
6259 // system that should be re-engineered so that all the model functions
6260 // accept a list of angles and everyone passes them through, but
6261 // that would require some major code revision.
6262 // So, anytime you are using a model that has rotating parts, you
6263 // need to do a ship_model_start before any model_ functions are
6264 // called and a ship_model_stop after you're done. Even for
6265 // collision detection and stuff, not just rendering.
6266 // See John for details.
6268 void ship_model_start(object *objp)
6270 model_subsystem *psub;
6274 shipp = &Ships[objp->instance];
6276 // First clear all the angles in the model to zero
6277 model_clear_instance(shipp->modelnum);
6279 // Go through all subsystems and bash the model angles for all
6280 // the subsystems that need it.
6281 for ( pss = GET_FIRST(&shipp->subsys_list); pss != END_OF_LIST(&shipp->subsys_list); pss = GET_NEXT(pss) ) {
6282 psub = pss->system_info;
6283 switch (psub->type) {
6284 case SUBSYSTEM_RADAR:
6285 case SUBSYSTEM_NAVIGATION:
6286 case SUBSYSTEM_COMMUNICATION:
6287 case SUBSYSTEM_UNKNOWN:
6288 case SUBSYSTEM_ENGINE:
6289 case SUBSYSTEM_SENSORS:
6290 case SUBSYSTEM_WEAPONS:
6291 case SUBSYSTEM_SOLAR:
6293 case SUBSYSTEM_GAS_COLLECT:
6294 case SUBSYSTEM_ACTIVATION:
6297 case SUBSYSTEM_TURRET:
6298 SDL_assert( !(psub->flags & MSS_FLAG_ROTATES) ); // Turrets can't rotate!!! See John!
6301 Error(LOCATION, "Illegal subsystem type.\n");
6305 if ( psub->subobj_num > -1 ) {
6306 model_set_instance(shipp->modelnum, psub->subobj_num, &pss->submodel_info_1 );
6309 if ( (psub->subobj_num != psub->turret_gun_sobj) && (psub->turret_gun_sobj >-1) ) {
6310 model_set_instance(shipp->modelnum, psub->turret_gun_sobj, &pss->submodel_info_2 );
6316 //==========================================================
6317 // Clears all the instance specific stuff out of the model info
6318 void ship_model_stop(object *objp)
6322 shipp = &Ships[objp->instance];
6324 // Then, clear all the angles in the model to zero
6325 model_clear_instance(shipp->modelnum);
6329 //==========================================================
6330 // Finds the number of crew points in a ship
6331 int ship_find_num_crewpoints(object *objp)
6334 model_subsystem *psub;
6338 shipp = &Ships[objp->instance];
6340 // Go through all subsystems and record the model angles for all
6341 // the subsystems that need it.
6342 for ( pss = GET_FIRST(&shipp->subsys_list); pss != END_OF_LIST(&shipp->subsys_list); pss = GET_NEXT(pss) ) {
6343 psub = pss->system_info;
6344 switch (psub->type) {
6345 case SUBSYSTEM_TURRET:
6346 if ( psub->flags & MSS_FLAG_CREWPOINT )
6347 n++; // fall through
6349 case SUBSYSTEM_RADAR:
6350 case SUBSYSTEM_NAVIGATION:
6351 case SUBSYSTEM_COMMUNICATION:
6352 case SUBSYSTEM_UNKNOWN:
6353 case SUBSYSTEM_ENGINE:
6355 case SUBSYSTEM_GAS_COLLECT:
6356 case SUBSYSTEM_ACTIVATION:
6360 Error(LOCATION, "Illegal subsystem type.\n");
6366 //==========================================================
6367 // Finds the number of turrets in a ship
6368 int ship_find_num_turrets(object *objp)
6371 model_subsystem *psub;
6375 shipp = &Ships[objp->instance];
6377 // Go through all subsystems and record the model angles for all
6378 // the subsystems that need it.
6379 for ( pss = GET_FIRST(&shipp->subsys_list); pss != END_OF_LIST(&shipp->subsys_list); pss = GET_NEXT(pss) ) {
6380 psub = pss->system_info;
6381 switch (psub->type) {
6382 case SUBSYSTEM_TURRET:
6383 n++; // drop through
6385 case SUBSYSTEM_RADAR:
6386 case SUBSYSTEM_NAVIGATION:
6387 case SUBSYSTEM_COMMUNICATION:
6388 case SUBSYSTEM_UNKNOWN:
6389 case SUBSYSTEM_ENGINE:
6391 case SUBSYSTEM_GAS_COLLECT:
6392 case SUBSYSTEM_ACTIVATION:
6396 Error(LOCATION, "Illegal subsystem type.\n");
6402 // Modify the matrix orient by the slew angles a.
6403 void compute_slew_matrix(matrix *orient, angles *a)
6409 t1.h = 0.0f; t1.b = 0.0f;
6410 t2.p = 0.0f; t2.b = 0.0f;
6412 // put in p & b like normal
6413 vm_angles_2_matrix(&tmp, &t1 );
6414 vm_matrix_x_matrix( &tmp2, orient, &tmp);
6416 // Put in heading separately
6417 vm_angles_2_matrix(&tmp, &t2 );
6418 vm_matrix_x_matrix( orient, &tmp2, &tmp );
6420 vm_orthogonalize_matrix(orient);
6423 // calculates the eye position for this ship in the global reference frame. Uses the
6424 // view_positions array in the model. The 0th element is the noral viewing position.
6425 // the vector of the eye is returned in the parameter 'eye'. The orientation of the
6426 // eye is returned in orient. (NOTE: this is kind of bogus for now since non 0th element
6427 // eyes have no defined up vector)
6428 void ship_get_eye( vector *eye_pos, matrix *eye_orient, object *obj )
6435 shipp = &Ships[obj->instance];
6436 pm = model_get( shipp->modelnum );
6438 // check to be sure that we have a view eye to look at.....spit out nasty debug message
6439 if ( pm->n_view_positions == 0 ) {
6440 // nprintf (("Warning", "No eye position found for model %s. Find artist to get fixed.\n", pm->filename ));
6441 *eye_pos = obj->pos;
6442 *eye_orient = obj->orient;
6445 ep = &(pm->view_positions[0] );
6447 // eye points are stored in an array -- the normal viewing position for a ship is the current_eye_index
6449 model_find_world_point( eye_pos, &ep->pnt, shipp->modelnum, ep->parent, &obj->orient, &obj->pos );
6450 // if ( shipp->current_eye_index == 0 ) {
6451 *eye_orient = obj->orient;
6453 // model_find_world_dir( &vec, &ep->norm, shipp->modelnum, ep->parent, &obj->orient, &obj->pos );
6454 // kind of bogus, but use the objects uvec to avoid totally stupid looking behavior.
6455 // vm_vector_2_matrix(eye_orient,&vec,&obj->orient.v.uvec,NULL);
6458 // Modify the orientation based on head orientation.
6459 if ( Viewer_obj == obj ) {
6460 if ( Viewer_mode & VM_PADLOCK_ANY ) {
6461 player_get_padlock_orient(eye_orient);
6463 compute_slew_matrix(eye_orient, &Viewer_slew_angles);
6468 // of attackers to make this decision.
6470 // NOTE: This function takes into account how many ships are attacking a subsystem, and will
6471 // prefer an ignored subsystem over a subsystem that is in line of sight, if the in-sight
6472 // subsystem is attacked by more than MAX_SUBSYS_ATTACKERS
6474 // sp => ship pointer to parent of subsystem
6475 // subsys_type => what kind of subsystem this is
6476 // attacker_pos => the world coords of the attacker of this subsystem
6478 // returns: pointer to subsystem if one found, NULL otherwise
6479 #define MAX_SUBSYS_ATTACKERS 3
6480 ship_subsys *ship_get_best_subsys_to_attack(ship *sp, int subsys_type, vector *attacker_pos)
6483 ship_subsys *best_in_sight_subsys, *lowest_attacker_subsys, *ss_return;
6484 int lowest_num_attackers, lowest_in_sight_attackers, num_attackers;
6488 lowest_in_sight_attackers = lowest_num_attackers = 1000;
6489 ss_return = best_in_sight_subsys = lowest_attacker_subsys = NULL;
6491 for (ss = GET_FIRST(&sp->subsys_list); ss != END_OF_LIST(&sp->subsys_list); ss = GET_NEXT(ss) ) {
6492 if ( (ss->system_info->type == subsys_type) && (ss->current_hits > 0) ) {
6494 // get world pos of subsystem
6495 vm_vec_unrotate(&gsubpos, &ss->system_info->pnt, &Objects[sp->objnum].orient);
6496 vm_vec_add2(&gsubpos, &Objects[sp->objnum].pos);
6498 // now find the number of ships attacking this subsystem by iterating through the ships list,
6499 // and checking if aip->targeted_subsys matches the subsystem we're checking
6501 sop = GET_FIRST(&Ship_obj_list);
6502 while(sop != END_OF_LIST(&Ship_obj_list)){
6503 if ( Ai_info[Ships[Objects[sop->objnum].instance].ai_index].targeted_subsys == ss ) {
6506 sop = GET_NEXT(sop);
6509 if ( num_attackers < lowest_num_attackers ) {
6510 lowest_num_attackers = num_attackers;
6511 lowest_attacker_subsys = ss;
6514 if ( ship_subsystem_in_sight(&Objects[sp->objnum], ss, attacker_pos, &gsubpos) ) {
6515 if ( num_attackers < lowest_in_sight_attackers ) {
6516 lowest_in_sight_attackers = num_attackers;
6517 best_in_sight_subsys = ss;
6523 if ( best_in_sight_subsys == NULL ) {
6524 // no subsystems are in sight, so return the subsystem with the lowest # of attackers
6525 ss_return = lowest_attacker_subsys;
6527 if ( lowest_in_sight_attackers > MAX_SUBSYS_ATTACKERS ) {
6528 ss_return = lowest_attacker_subsys;
6530 ss_return = best_in_sight_subsys;
6537 // function to return a pointer to the 'nth' ship_subsys structure in a ship's linked list
6539 // attacker_pos => world pos of attacker (default value NULL). If value is non-NULL, try
6540 // to select the best subsystem to attack of that type (using line-of-sight)
6541 // and based on the number of ships already attacking the subsystem
6542 ship_subsys *ship_get_indexed_subsys( ship *sp, int index, vector *attacker_pos )
6547 // first, special code to see if the index < 0. If so, we are looking for one of several possible
6548 // engines or one of several possible turrets. If we enter this if statement, we will always return
6553 subsys_type = -index;
6554 if ( sp->subsys_info[subsys_type].current_hits == 0.0f ) // if there are no hits, no subsystem to attack.
6557 if ( attacker_pos != NULL ) {
6558 ss = ship_get_best_subsys_to_attack(sp, subsys_type, attacker_pos);
6561 // next, scan the list of subsystems and search for the first subsystem of the particular
6562 // type which has > 0 hits remaining.
6563 for (ss = GET_FIRST(&sp->subsys_list); ss != END_OF_LIST(&sp->subsys_list); ss = GET_NEXT(ss) ) {
6564 if ( (ss->system_info->type == subsys_type) && (ss->current_hits > 0) )
6569 Int3(); // maybe we shouldn't get here, but with possible floating point rounding, I suppose we could
6575 ss = GET_FIRST(&sp->subsys_list);
6576 while ( ss != END_OF_LIST( &sp->subsys_list ) ) {
6577 if ( count == index )
6580 ss = GET_NEXT( ss );
6582 Int3(); // get allender -- turret ref didn't fixup correctly!!!!
6586 // Given a pointer to a subsystem and an associated object, return the index.
6587 int ship_get_index_from_subsys(ship_subsys *ssp, int objnum, int error_bypass)
6596 SDL_assert(objnum >= 0);
6597 SDL_assert(Objects[objnum].instance >= 0);
6599 shipp = &Ships[Objects[objnum].instance];
6602 ss = GET_FIRST(&shipp->subsys_list);
6603 while ( ss != END_OF_LIST( &shipp->subsys_list ) ) {
6607 ss = GET_NEXT( ss );
6609 if ( !error_bypass )
6610 Int3(); // get allender -- turret ref didn't fixup correctly!!!!
6615 // function which returns the index number of the ship_subsys parameter
6616 int ship_get_subsys_index(ship *sp, char *ss_name, int error_bypass)
6622 ss = GET_FIRST(&sp->subsys_list);
6623 while ( ss != END_OF_LIST( &sp->subsys_list ) ) {
6624 if ( !SDL_strcasecmp(ss->system_info->subobj_name, ss_name) )
6627 ss = GET_NEXT( ss );
6636 // routine to return the strength of a subsystem. We keep a total hit tally for all subsystems
6637 // which are similar (i.e. a total for all engines). These routines will return a number between
6638 // 0.0 and 1.0 which is the relative combined strength of the given subsystem type. The number
6639 // calculated for the engines is slightly different. Once an engine reaches < 15% of it's hits, it's
6640 // output drops to that %. A dead engine has no output.
6641 float ship_get_subsystem_strength( ship *shipp, int type )
6646 SDL_assert ( (type >= 0) && (type < SUBSYSTEM_MAX) );
6647 if ( shipp->subsys_info[type].total_hits == 0.0f )
6650 // For a dying ship, all subsystem strengths are zero.
6651 if (Objects[shipp->objnum].hull_strength <= 0.0f)
6654 strength = shipp->subsys_info[type].current_hits / shipp->subsys_info[type].total_hits;
6656 if ( strength == 0.0f ) // short circuit 0
6659 if ( (type == SUBSYSTEM_ENGINE) && (strength < 1.0f) ) {
6663 ssp = GET_FIRST(&shipp->subsys_list);
6664 while ( ssp != END_OF_LIST( &shipp->subsys_list ) ) {
6666 if ( ssp->system_info->type == SUBSYSTEM_ENGINE ) {
6669 ratio = ssp->current_hits / ssp->system_info->max_hits;
6670 if ( ratio < ENGINE_MIN_STR )
6671 ratio = ENGINE_MIN_STR;
6675 ssp = GET_NEXT( ssp );
6677 strength = percent / (float)shipp->subsys_info[type].num;
6683 // set the strength of a subsystem on a given ship. The strength passed as a
6684 // parameter is between 0.0 and 1.0
6686 // NOTE: this function was made to be called by the debug function dcf_set_subsys(). If
6687 // you want to use this, be sure that you test it for all cases.
6688 void ship_set_subsystem_strength( ship *shipp, int type, float strength )
6690 float total_current_hits, diff;
6693 SDL_assert ( (type >= 0) && (type < SUBSYSTEM_MAX) );
6694 if ( shipp->subsys_info[type].total_hits == 0.0f )
6697 total_current_hits = 0.0f;
6698 ssp = GET_FIRST(&shipp->subsys_list);
6699 while ( ssp != END_OF_LIST( &shipp->subsys_list ) ) {
6701 if ( ssp->system_info->type == type ) {
6702 ssp->current_hits = strength * ssp->system_info->max_hits;
6703 total_current_hits += ssp->current_hits;
6705 ssp = GET_NEXT( ssp );
6708 // update the objects integrity, needed since we've bashed the strength of a subsysem
6709 diff = total_current_hits - shipp->subsys_info[type].current_hits;
6710 Objects[shipp->objnum].hull_strength += diff;
6711 // fix up the shipp->subsys_info[type] current_hits value
6712 shipp->subsys_info[type].current_hits = total_current_hits;
6715 #define SHIELD_REPAIR_RATE 0.20f // Percent of shield repaired per second.
6716 #define HULL_REPAIR_RATE 0.15f // Percent of hull repaired per second.
6717 #define SUBSYS_REPAIR_RATE 0.10f // Percent of subsystems repaired per second.
6719 // ==================================================================================
6720 // ship_do_rearm_frame()
6722 // function to rearm a ship. This function gets called from the ai code ai_do_rearm_frame (or
6723 // some function of a similar name). Returns 1 when ship is fully repaired and rearmed, 0 otherwise
6726 #define REARM_NUM_MISSILES_PER_BATCH 4 // how many missiles are dropped in per load sound
6728 int ship_do_rearm_frame( object *objp, float frametime )
6730 int i, banks_full, subsys_type, subsys_all_ok;
6731 float shield_str, repair_delta, repair_allocated;
6738 shipp = &Ships[objp->instance];
6739 swp = &shipp->weapons;
6740 sip = &Ship_info[shipp->ship_info_index];
6741 aip = &Ai_info[shipp->ai_index];
6743 // AL 10-31-97: Add missing primary weapons to the ship. This is required since designers
6744 // want to have ships that start with no primaries, but can get them through
6746 if ( swp->num_primary_banks < sip->num_primary_banks ) {
6747 for ( i = swp->num_primary_banks; i < sip->num_primary_banks; i++ ) {
6748 swp->primary_bank_weapons[i] = sip->primary_bank_weapons[i];
6750 swp->num_primary_banks = sip->num_primary_banks;
6753 // AL 12-30-97: Repair broken warp drive
6754 if ( shipp->flags & SF_WARP_BROKEN ) {
6755 // TODO: maybe do something here like informing player warp is fixed?
6756 shipp->flags &= ~SF_WARP_BROKEN;
6759 // AL 1-16-97: Replenish countermeasures
6760 shipp->cmeasure_count = sip->cmeasure_max;
6762 // Do shield repair here
6763 if ( !(objp->flags & OF_NO_SHIELDS) ) {
6764 shield_str = get_shield_strength(objp);
6765 if ( shield_str < sip->shields ) {
6766 if ( objp == Player_obj ) {
6767 player_maybe_start_repair_sound();
6769 shield_str += sip->shields * frametime * SHIELD_REPAIR_RATE;
6770 if ( shield_str > sip->shields ) {
6771 shield_str = sip->shields;
6773 set_shield_strength(objp, shield_str);
6777 // Repair the ship integrity (subsystems + hull). This works by applying the repair points
6778 // to the subsystems. Ships integrity is stored is objp->hull_strength, so that always is
6779 // incremented by repair_allocated
6780 repair_allocated = sip->initial_hull_strength * frametime * HULL_REPAIR_RATE;
6783 AL 11-24-97: remove increase to hull integrity
6785 objp->hull_strength += repair_allocated;
6786 if ( objp->hull_strength > sip->initial_hull_strength ) {
6787 repair_allocated -= ( sip->initial_hull_strength - objp->hull_strength);
6788 objp->hull_strength = sip->initial_hull_strength;
6792 // check the subsystems of the ship.
6794 ssp = GET_FIRST(&shipp->subsys_list);
6795 while ( ssp != END_OF_LIST( &shipp->subsys_list ) ) {
6797 if ( ssp->current_hits < ssp->system_info->max_hits && repair_allocated > 0 ) {
6799 subsys_type = ssp->system_info->type;
6801 if ( objp == Player_obj ) {
6802 player_maybe_start_repair_sound();
6805 repair_delta = ssp->system_info->max_hits - ssp->current_hits;
6806 if ( repair_delta > repair_allocated ) {
6807 repair_delta = repair_allocated;
6809 repair_allocated -= repair_delta;
6810 SDL_assert(repair_allocated >= 0.0f);
6812 // add repair to current strength of single subsystem
6813 ssp->current_hits += repair_delta;
6814 if ( ssp->current_hits > ssp->system_info->max_hits ) {
6815 ssp->current_hits = ssp->system_info->max_hits;
6818 // add repair to aggregate strength of subsystems of that type
6819 shipp->subsys_info[subsys_type].current_hits += repair_delta;
6820 if ( shipp->subsys_info[subsys_type].current_hits > shipp->subsys_info[subsys_type].total_hits )
6821 shipp->subsys_info[subsys_type].current_hits = shipp->subsys_info[subsys_type].total_hits;
6823 if ( ssp->current_hits > ssp->system_info->max_hits )
6824 ssp->current_hits = ssp->system_info->max_hits;
6826 // check to see if this subsystem was totally non functional before -- if so, then
6828 if ( (ssp->system_info->type == SUBSYSTEM_ENGINE) && (shipp->flags & SF_DISABLED) ) {
6829 shipp->flags &= ~SF_DISABLED;
6830 ship_reset_disabled_physics(objp, shipp->ship_info_index);
6834 ssp = GET_NEXT( ssp );
6837 // now deal with rearming the player. All secondary weapons have a certain rate at which
6838 // they can be rearmed. We can rearm multiple banks at once.
6840 if ( subsys_all_ok ) {
6841 for (i = 0; i < swp->num_secondary_banks; i++ ) {
6842 if ( swp->secondary_bank_ammo[i] < swp->secondary_bank_start_ammo[i] ) {
6845 if ( objp == Player_obj ) {
6846 hud_gauge_popup_start(HUD_WEAPONS_GAUGE);
6849 if ( timestamp_elapsed(swp->secondary_bank_rearm_time[i]) ) {
6851 // Have to do some gymnastics to play the sound effects properly. There is a
6852 // one time sound effect which is the missile loading start, then for each missile
6853 // loaded there is a sound effect. These are only played for the player.
6855 rearm_time = Weapon_info[swp->secondary_bank_weapons[i]].rearm_rate;
6856 if ( aip->rearm_first_missile == TRUE ) {
6860 swp->secondary_bank_rearm_time[i] = timestamp( (int)(rearm_time * 1000.f) );
6862 // Acutal loading of missiles is preceded by a sound effect which is the missile
6863 // loading equipment moving into place
6864 if ( aip->rearm_first_missile == TRUE ) {
6865 snd_play_3d( &Snds[SND_MISSILE_START_LOAD], &objp->pos, &View_position );
6866 aip->rearm_first_missile = FALSE;
6869 snd_play_3d( &Snds[SND_MISSILE_LOAD], &objp->pos, &View_position );
6870 if (objp == Player_obj)
6871 joy_ff_play_reload_effect();
6873 swp->secondary_bank_ammo[i] += REARM_NUM_MISSILES_PER_BATCH;
6874 if ( swp->secondary_bank_ammo[i] > swp->secondary_bank_start_ammo[i] )
6875 swp->secondary_bank_ammo[i] = swp->secondary_bank_start_ammo[i];
6882 } // end if (subsys_all_ok)
6884 if ( banks_full == swp->num_secondary_banks ) {
6885 aip->rearm_first_missile = TRUE;
6888 int shields_full = 0;
6889 if ( (objp->flags & OF_NO_SHIELDS) ) {
6892 if ( get_shield_strength(objp) >= sip->shields )
6896 // return 1 if at end of subsystem list, hull damage at 0, and shields full and all secondary banks full.
6897 // if ( ((ssp = END_OF_LIST(&shipp->subsys_list)) != NULL )&&(objp->hull_strength == sip->initial_hull_strength)&&(shields_full) ) {
6898 if ( subsys_all_ok && shields_full ) {
6900 if ( objp == Player_obj ) {
6901 player_stop_repair_sound();
6904 if (!aip->rearm_release_delay)
6905 aip->rearm_release_delay = timestamp(1200);
6907 if ( banks_full == swp->num_secondary_banks ) {
6909 if ( timestamp_elapsed(aip->rearm_release_delay) )
6913 aip->rearm_release_delay = timestamp(1200);
6920 // function which is used to find a repair ship to repair requester_obj. the way repair ships will work
6922 // if repair ship present and available, return pointer to that object.
6923 // If repair ship present and busy, possibly return that object if he can satisfy the request soon enough.
6924 // If repair ship present and busy and cannot satisfy request, return NULL to warp a new one in if below max number
6925 // if no repair ship present, return NULL to force a new one to be warped in.
6926 #define MAX_SUPPORT_SHIPS_PER_TEAM 1
6928 object *ship_find_repair_ship( object *requester_obj )
6931 ship *requester_ship;
6932 int num_support_ships, num_available_support_ships;
6933 float min_dist = 99999.0f;
6934 object *nearest_support_ship = NULL;
6935 int support_ships[MAX_SUPPORT_SHIPS_PER_TEAM];
6937 SDL_assert(requester_obj->type == OBJ_SHIP);
6938 SDL_assert((requester_obj->instance >= 0) && (requester_obj->instance < MAX_OBJECTS));
6940 SDL_zero(support_ships);
6942 // if support ships are not allowed, then no support ship can repair!
6943 if ( !is_support_allowed(requester_obj) )
6946 num_support_ships = 0;
6947 num_available_support_ships = 0;
6949 requester_ship = &Ships[requester_obj->instance];
6950 for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
6951 if ((objp->type == OBJ_SHIP) && !(objp->flags & OF_SHOULD_BE_DEAD)) {
6956 SDL_assert((objp->instance >= 0) && (objp->instance < MAX_SHIPS));
6958 shipp = &Ships[objp->instance];
6959 sip = &Ship_info[shipp->ship_info_index];
6961 if ( shipp->team != requester_ship->team )
6964 if ( !(sip->flags & SIF_SUPPORT) )
6967 // don't deal with dying support ships
6968 if ( shipp->flags & (SF_DYING | SF_DEPARTING) )
6971 dist = vm_vec_dist_quick(&objp->pos, &requester_obj->pos);
6972 support_ships[num_support_ships] = objp-Objects;
6974 if (!(Ai_info[shipp->ai_index].ai_flags & AIF_REPAIRING)) {
6975 num_available_support_ships++;
6976 if (dist < min_dist) {
6978 nearest_support_ship = objp;
6982 if ( num_support_ships >= MAX_SUPPORT_SHIPS_PER_TEAM ) {
6983 mprintf(("Why is there more than %d support ships in this mission?\n",MAX_SUPPORT_SHIPS_PER_TEAM));
6986 support_ships[num_support_ships] = OBJ_INDEX(objp);
6987 num_support_ships++;
6992 if (nearest_support_ship != NULL)
6993 return nearest_support_ship;
6994 else if (num_support_ships >= MAX_SUPPORT_SHIPS_PER_TEAM) {
6995 SDL_assert(&Objects[support_ships[0]] != NULL);
6996 return &Objects[support_ships[0]];
6998 SDL_assert(num_support_ships < MAX_SUPPORT_SHIPS_PER_TEAM);
7005 // -------------------------------------------------------------------------------------------------
7008 // called in game_shutdown() to free malloced memory
7010 // NOTE: do not call this function. It is only called from game_shutdown()
7015 for (i=0; i<MAX_SHIPS; i++ ) {
7016 if ( Ships[i].shield_integrity != NULL && Ships[i].objnum != -1 ) {
7017 free( Ships[i].shield_integrity );
7018 Ships[i].shield_integrity = NULL;
7022 // free memory alloced for subsystem storage
7023 for ( i = 0; i < Num_ship_types; i++ ) {
7024 if ( Ship_info[i].subsystems != NULL ) {
7025 free(Ship_info[i].subsystems);
7029 // free info from parsed table data
7030 for (i=0; i<MAX_SHIP_TYPES; i++) {
7031 if(Ship_info[i].type_str != NULL){
7032 free(Ship_info[i].type_str);
7033 Ship_info[i].type_str = NULL;
7035 if(Ship_info[i].maneuverability_str != NULL){
7036 free(Ship_info[i].maneuverability_str);
7037 Ship_info[i].maneuverability_str = NULL;
7039 if(Ship_info[i].armor_str != NULL){
7040 free(Ship_info[i].armor_str);
7041 Ship_info[i].armor_str = NULL;
7043 if(Ship_info[i].manufacturer_str != NULL){
7044 free(Ship_info[i].manufacturer_str);
7045 Ship_info[i].manufacturer_str = NULL;
7047 if(Ship_info[i].desc != NULL){
7048 free(Ship_info[i].desc);
7049 Ship_info[i].desc = NULL;
7051 if(Ship_info[i].tech_desc != NULL){
7052 free(Ship_info[i].tech_desc);
7053 Ship_info[i].tech_desc = NULL;
7055 if(Ship_info[i].ship_length != NULL){
7056 free(Ship_info[i].ship_length);
7057 Ship_info[i].ship_length = NULL;
7059 if(Ship_info[i].gun_mounts != NULL){
7060 free(Ship_info[i].gun_mounts);
7061 Ship_info[i].gun_mounts = NULL;
7063 if(Ship_info[i].missile_banks != NULL){
7064 free(Ship_info[i].missile_banks);
7065 Ship_info[i].missile_banks = NULL;
7069 // NOTE: pm->ship_bay is free'd is modelread.cpp, model_unload().
7074 // -------------------------------------------------------------------------------------------------
7075 // ship_assign_sound()
7077 // Assign object-linked sound to a particular ship
7079 void ship_assign_sound(ship *sp)
7084 ship_subsys *moveup;
7086 SDL_assert( sp->objnum >= 0 );
7090 objp = &Objects[sp->objnum];
7091 sip = &Ship_info[sp->ship_info_index];
7093 if ( sip->engine_snd != -1 ) {
7094 vm_vec_copy_scale(&engine_pos, &objp->orient.v.fvec, -objp->radius/2.0f);
7096 obj_snd_assign(sp->objnum, sip->engine_snd, &engine_pos, 1);
7099 // if he's got any specific engine subsystems. go for it.
7100 moveup = GET_FIRST(&sp->subsys_list);
7101 while(moveup != END_OF_LIST(&sp->subsys_list)){
7102 // check the name of the subsystem
7103 if(strstr(moveup->system_info->name, "enginelarge")){
7104 obj_snd_assign(sp->objnum, SND_ENGINE_LOOP_LARGE, &moveup->system_info->pnt, 0);
7105 } else if(strstr(moveup->system_info->name, "enginehuge")){
7106 obj_snd_assign(sp->objnum, SND_ENGINE_LOOP_HUGE, &moveup->system_info->pnt, 0);
7110 moveup = GET_NEXT(moveup);
7114 // -------------------------------------------------------------------------------------------------
7115 // ship_assign_sound_all()
7117 // Assign object-linked sounds to all ships currently in the obj_used_list
7119 void ship_assign_sound_all()
7122 int idx, has_sounds;
7124 for ( objp = GET_FIRST(&obj_used_list); objp !=END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
7125 if ( objp->type == OBJ_SHIP && Player_obj != objp) {
7128 // check to make sure this guy hasn't got sounds already assigned to him
7129 for(idx=0; idx<MAX_OBJECT_SOUNDS; idx++){
7130 if(objp->objsnd_num[idx] != -1){
7137 // actually assign the sound
7139 ship_assign_sound(&Ships[objp->instance]);
7146 // ---------------------------------------------------------------------------------------
7149 // Debug console function to set the shield for the player ship
7151 DCF(set_shield,"Change player ship shield strength")
7155 sip = &Ship_info[Ships[Player_obj->instance].ship_info_index];
7157 dc_get_arg(ARG_FLOAT|ARG_NONE);
7159 if ( Dc_arg_type & ARG_FLOAT ) {
7160 if ( Dc_arg_float < 0 )
7161 Dc_arg_float = 0.0f;
7162 if ( Dc_arg_float > 1.0 )
7163 Dc_arg_float = 1.0f;
7164 set_shield_strength(Player_obj, Dc_arg_float * sip->shields);
7165 dc_printf("Shields set to %.2f\n", get_shield_strength(Player_obj) );
7170 dc_printf ("Usage: set_shield [num]\n");
7171 dc_printf ("[num] -- shield percentage 0.0 -> 1.0 of max\n");
7172 dc_printf ("with no parameters, displays shield strength\n");
7177 dc_printf( "Shields are currently %.2f", get_shield_strength(Player_obj) );
7181 // ---------------------------------------------------------------------------------------
7184 // Debug console function to set the hull for the player ship
7186 DCF(set_hull, "Change player ship hull strength")
7190 sip = &Ship_info[Ships[Player_obj->instance].ship_info_index];
7192 dc_get_arg(ARG_FLOAT|ARG_NONE);
7194 if ( Dc_arg_type & ARG_FLOAT ) {
7195 if ( Dc_arg_float < 0 )
7196 Dc_arg_float = 0.0f;
7197 if ( Dc_arg_float > 1.0 )
7198 Dc_arg_float = 1.0f;
7199 Player_obj->hull_strength = Dc_arg_float * sip->initial_hull_strength;
7200 dc_printf("Hull set to %.2f\n", Player_obj->hull_strength );
7205 dc_printf ("Usage: set_hull [num]\n");
7206 dc_printf ("[num] -- hull percentage 0.0 -> 1.0 of max\n");
7207 dc_printf ("with no parameters, displays hull strength\n");
7212 dc_printf( "Hull is currently %.2f", Player_obj->hull_strength );
7216 // ---------------------------------------------------------------------------------------
7219 // Debug console function to set the strength of a particular subsystem
7222 DCF(set_subsys, "Set the strength of a particular subsystem on player ship" )
7225 dc_get_arg(ARG_STRING);
7226 if ( !SDL_strcasecmp( Dc_arg, "weapons" )) {
7227 dc_get_arg(ARG_FLOAT);
7228 if ( (Dc_arg_float < 0.0f) || (Dc_arg_float > 1.0f) ) {
7231 ship_set_subsystem_strength( Player_ship, SUBSYSTEM_WEAPONS, Dc_arg_float );
7233 } else if ( !SDL_strcasecmp( Dc_arg, "engine" )) {
7234 dc_get_arg(ARG_FLOAT);
7235 if ( (Dc_arg_float < 0.0f) || (Dc_arg_float > 1.0f) ) {
7238 ship_set_subsystem_strength( Player_ship, SUBSYSTEM_ENGINE, Dc_arg_float );
7239 if ( Dc_arg_float < ENGINE_MIN_STR ) {
7240 Player_ship->flags |= SF_DISABLED; // add the disabled flag
7242 Player_ship->flags &= (~SF_DISABLED); // add the disabled flag
7245 } else if ( !SDL_strcasecmp( Dc_arg, "sensors" )) {
7246 dc_get_arg(ARG_FLOAT);
7247 if ( (Dc_arg_float < 0.0f) || (Dc_arg_float > 1.0f) ) {
7250 ship_set_subsystem_strength( Player_ship, SUBSYSTEM_SENSORS, Dc_arg_float );
7252 } else if ( !SDL_strcasecmp( Dc_arg, "communication" )) {
7253 dc_get_arg(ARG_FLOAT);
7254 if ( (Dc_arg_float < 0.0f) || (Dc_arg_float > 1.0f) ) {
7257 ship_set_subsystem_strength( Player_ship, SUBSYSTEM_COMMUNICATION, Dc_arg_float );
7259 } else if ( !SDL_strcasecmp( Dc_arg, "navigation" )) {
7260 dc_get_arg(ARG_FLOAT);
7261 if ( (Dc_arg_float < 0.0f) || (Dc_arg_float > 1.0f) ) {
7264 ship_set_subsystem_strength( Player_ship, SUBSYSTEM_NAVIGATION, Dc_arg_float );
7266 } else if ( !SDL_strcasecmp( Dc_arg, "radar" )) {
7267 dc_get_arg(ARG_FLOAT);
7268 if ( (Dc_arg_float < 0.0f) || (Dc_arg_float > 1.0f) ) {
7271 ship_set_subsystem_strength( Player_ship, SUBSYSTEM_RADAR, Dc_arg_float );
7280 dc_printf( "Usage: set_subsys type X\nWhere X is value between 0 and 1.0, and type can be:\n" );
7281 dc_printf( "weapons\n" );
7282 dc_printf( "engine\n" );
7283 dc_printf( "sensors\n" );
7284 dc_printf( "communication\n" );
7285 dc_printf( "navigation\n" );
7286 dc_printf( "radar\n" );
7287 Dc_status = 0; // don't print status if help is printed. Too messy.
7292 // console function to toggle whether auto-repair for subsystems is active
7294 DCF_BOOL( auto_repair, Ship_auto_repair );
7297 // two functions to keep track of counting ships of particular types. Maybe we should be rolling this
7298 // thing into the stats section?? The first function adds a ship of a particular type to the overall
7299 // count of ships of that type (called from MissionParse.cpp). The second function adds to the kill total
7300 // of ships of a particular type. Note that we use the ship_info flags structure member to determine
7301 // what is happening.
7302 void ship_add_ship_type_count( int ship_info_flag, int num )
7304 if ( ship_info_flag & SIF_CARGO )
7305 Ship_counts[SHIP_TYPE_CARGO].total += num;
7306 else if ( (ship_info_flag & SIF_FIGHTER) || (ship_info_flag & SIF_BOMBER) )
7307 Ship_counts[SHIP_TYPE_FIGHTER_BOMBER].total += num;
7308 else if ( ship_info_flag & SIF_CRUISER )
7309 Ship_counts[SHIP_TYPE_CRUISER].total += num;
7310 else if ( ship_info_flag & SIF_CORVETTE )
7311 Ship_counts[SHIP_TYPE_CORVETTE].total += num;
7312 else if ( ship_info_flag & SIF_GAS_MINER )
7313 Ship_counts[SHIP_TYPE_GAS_MINER].total += num;
7314 else if ( ship_info_flag & SIF_AWACS )
7315 Ship_counts[SHIP_TYPE_AWACS].total += num;
7316 else if ( ship_info_flag & SIF_FREIGHTER )
7317 Ship_counts[SHIP_TYPE_FREIGHTER].total += num;
7318 else if ( ship_info_flag & SIF_CAPITAL )
7319 Ship_counts[SHIP_TYPE_CAPITAL].total += num;
7320 else if ( ship_info_flag & SIF_TRANSPORT )
7321 Ship_counts[SHIP_TYPE_TRANSPORT].total += num;
7322 else if ( ship_info_flag & SIF_SUPPORT )
7323 Ship_counts[SHIP_TYPE_REPAIR_REARM].total += num;
7324 else if ( ship_info_flag & SIF_NO_SHIP_TYPE )
7325 Ship_counts[SHIP_TYPE_NONE].total += num;
7326 else if ( ship_info_flag & SIF_NAVBUOY ) {
7327 Ship_counts[SHIP_TYPE_NAVBUOY].total += num;
7328 } else if ( ship_info_flag & SIF_SENTRYGUN ) {
7329 Ship_counts[SHIP_TYPE_SENTRYGUN].total += num;
7330 } else if ( ship_info_flag & SIF_ESCAPEPOD ) {
7331 Ship_counts[SHIP_TYPE_ESCAPEPOD].total += num;
7332 } else if ( ship_info_flag & SIF_SUPERCAP ) {
7333 Ship_counts[SHIP_TYPE_SUPERCAP].total += num;
7334 } else if ( ship_info_flag & SIF_DRYDOCK ) {
7335 Ship_counts[SHIP_TYPE_DRYDOCK].total += num;
7336 } else if ( ship_info_flag & SIF_KNOSSOS_DEVICE){
7337 Ship_counts[SHIP_TYPE_KNOSSOS_DEVICE].total += num;
7340 Int3(); //get allender -- unknown ship type
7343 void ship_add_ship_type_kill_count( int ship_info_flag )
7345 if ( ship_info_flag & SIF_CARGO )
7346 Ship_counts[SHIP_TYPE_CARGO].killed++;
7347 else if ( (ship_info_flag & SIF_FIGHTER) || (ship_info_flag & SIF_BOMBER) )
7348 Ship_counts[SHIP_TYPE_FIGHTER_BOMBER].killed++;
7349 else if ( ship_info_flag & SIF_CRUISER )
7350 Ship_counts[SHIP_TYPE_CRUISER].killed++;
7351 else if ( ship_info_flag & SIF_CORVETTE )
7352 Ship_counts[SHIP_TYPE_CORVETTE].killed++;
7353 else if ( ship_info_flag & SIF_AWACS )
7354 Ship_counts[SHIP_TYPE_AWACS].killed++;
7355 else if ( ship_info_flag & SIF_GAS_MINER )
7356 Ship_counts[SHIP_TYPE_GAS_MINER].killed++;
7357 else if ( ship_info_flag & SIF_FREIGHTER )
7358 Ship_counts[SHIP_TYPE_FREIGHTER].killed++;
7359 else if ( ship_info_flag & SIF_CAPITAL )
7360 Ship_counts[SHIP_TYPE_CAPITAL].killed++;
7361 else if ( ship_info_flag & SIF_TRANSPORT )
7362 Ship_counts[SHIP_TYPE_TRANSPORT].killed++;
7363 else if ( ship_info_flag & SIF_SUPPORT )
7364 Ship_counts[SHIP_TYPE_REPAIR_REARM].killed++;
7365 else if ( ship_info_flag & SIF_SENTRYGUN )
7366 Ship_counts[SHIP_TYPE_SENTRYGUN].killed++;
7367 else if ( ship_info_flag & SIF_ESCAPEPOD )
7368 Ship_counts[SHIP_TYPE_ESCAPEPOD].killed++;
7369 else if ( ship_info_flag & SIF_NO_SHIP_TYPE )
7370 Ship_counts[SHIP_TYPE_NONE].killed++;
7371 else if ( ship_info_flag & SIF_SUPERCAP )
7372 Ship_counts[SHIP_TYPE_SUPERCAP].killed++;
7373 else if ( ship_info_flag & SIF_DRYDOCK )
7374 Ship_counts[SHIP_TYPE_DRYDOCK].killed++;
7375 else if ( ship_info_flag & SIF_KNOSSOS_DEVICE )
7376 Ship_counts[SHIP_TYPE_KNOSSOS_DEVICE].killed++;
7378 Int3(); //get allender -- unknown ship type
7381 int ship_query_general_type(int ship)
7383 return ship_query_general_type(&Ships[ship]);
7386 int ship_query_general_type(ship *shipp)
7390 flags = Ship_info[shipp->ship_info_index].flags;
7391 switch (flags & SIF_ALL_SHIP_TYPES) {
7393 return SHIP_TYPE_CARGO;
7397 return SHIP_TYPE_FIGHTER_BOMBER;
7400 return SHIP_TYPE_CRUISER;
7403 return SHIP_TYPE_FREIGHTER;
7406 return SHIP_TYPE_CAPITAL;
7409 return SHIP_TYPE_TRANSPORT;
7411 case SIF_NO_SHIP_TYPE:
7412 return SHIP_TYPE_NONE;
7415 return SHIP_TYPE_REPAIR_REARM;
7418 return SHIP_TYPE_NAVBUOY;
7421 return SHIP_TYPE_SENTRYGUN;
7424 return SHIP_TYPE_ESCAPEPOD;
7427 return SHIP_TYPE_SUPERCAP;
7430 return SHIP_TYPE_DRYDOCK;
7433 return SHIP_TYPE_CORVETTE;
7436 return SHIP_TYPE_AWACS;
7439 return SHIP_TYPE_GAS_MINER;
7441 case SIF_KNOSSOS_DEVICE:
7442 return SHIP_TYPE_KNOSSOS_DEVICE;
7445 Error(LOCATION, "Ship type flag is unknown. Flags value is 0x%x", flags);
7446 return SHIP_TYPE_NONE;
7449 // returns true if the docker can (is allowed) to dock with dockee
7450 int ship_docking_valid(int docker, int dockee)
7452 int docker_type, dockee_type;
7454 SDL_assert(docker >= 0 && docker < MAX_SHIPS);
7455 SDL_assert(dockee >= 0 && dockee < MAX_SHIPS);
7456 docker_type = ship_query_general_type(docker);
7457 dockee_type = ship_query_general_type(dockee);
7459 // escape pods can dock with transports, freighters, cruisers.
7460 if ( docker_type == SHIP_TYPE_ESCAPEPOD ) {
7461 if ( (dockee_type == SHIP_TYPE_TRANSPORT) || (dockee_type == SHIP_TYPE_CRUISER) || (dockee_type == SHIP_TYPE_FREIGHTER) || (dockee_type == SHIP_TYPE_DRYDOCK) || (dockee_type == SHIP_TYPE_CORVETTE) || (dockee_type == SHIP_TYPE_GAS_MINER) || (dockee_type == SHIP_TYPE_AWACS)){
7466 // docket == freighter
7467 if (docker_type == SHIP_TYPE_FREIGHTER) {
7468 if ( (dockee_type == SHIP_TYPE_CARGO) || (dockee_type == SHIP_TYPE_CRUISER) || (dockee_type == SHIP_TYPE_CAPITAL) || (dockee_type == SHIP_TYPE_SUPERCAP) || (dockee_type == SHIP_TYPE_DRYDOCK) || (dockee_type == SHIP_TYPE_CORVETTE) || (dockee_type == SHIP_TYPE_GAS_MINER) || (dockee_type == SHIP_TYPE_AWACS)){
7473 // docker == cruiser
7474 if ( (docker_type == SHIP_TYPE_CRUISER) || (docker_type == SHIP_TYPE_CORVETTE) || (docker_type == SHIP_TYPE_GAS_MINER) || (docker_type == SHIP_TYPE_AWACS)){
7475 if ( (dockee_type == SHIP_TYPE_CARGO) || (dockee_type == SHIP_TYPE_CRUISER) || (dockee_type == SHIP_TYPE_CAPITAL) || (dockee_type == SHIP_TYPE_SUPERCAP) || (dockee_type == SHIP_TYPE_DRYDOCK) || (dockee_type == SHIP_TYPE_CORVETTE) || (dockee_type == SHIP_TYPE_GAS_MINER) || (dockee_type == SHIP_TYPE_AWACS)){
7480 if (docker_type == SHIP_TYPE_TRANSPORT) {
7481 if ( (dockee_type == SHIP_TYPE_CARGO) || (dockee_type == SHIP_TYPE_CRUISER)
7482 || (dockee_type == SHIP_TYPE_FREIGHTER) || (dockee_type == SHIP_TYPE_TRANSPORT)
7483 || (dockee_type == SHIP_TYPE_CAPITAL) || (dockee_type == SHIP_TYPE_ESCAPEPOD)
7484 || (dockee_type == SHIP_TYPE_SUPERCAP) || (dockee_type == SHIP_TYPE_DRYDOCK) || (dockee_type == SHIP_TYPE_CORVETTE) || (dockee_type == SHIP_TYPE_GAS_MINER) || (dockee_type == SHIP_TYPE_AWACS)){
7489 if (docker_type == SHIP_TYPE_REPAIR_REARM) {
7490 if ((dockee_type == SHIP_TYPE_FIGHTER_BOMBER) || (dockee_type == SHIP_TYPE_STEALTH)){
7498 // function to return a random ship in a starting player wing. Returns -1 if a suitable
7499 // one cannot be found
7500 // input: max_dist => OPTIONAL PARAMETER (default value 0.0f) max range ship can be from player
7501 // input: persona => OPTIONAL PARAMETER (default to -1) which persona to get
7502 int ship_get_random_player_wing_ship( int flags, float max_dist, int persona_index, int get_first, int multi_team )
7504 int i, j, ship_index, count;
7505 int slist[MAX_SHIPS_PER_WING * MAX_STARTING_WINGS], which_one;
7507 // iterate through starting wings of player. Add ship indices of ships which meet
7510 for (i = 0; i < num_wings; i++ ) {
7516 if(multi_team >= 0){
7517 if(!SDL_strcasecmp(Wings[i].name, multi_team == 0 ? "alpha" : "zeta")){
7523 // first check for a player starting wing (alpha, beta, gamma)
7524 for ( j = 0; j < MAX_PLAYER_WINGS; j++ ) {
7525 if ( i == Starting_wings[j] ) {
7531 // if not found, the delta and epsilon count too
7532 if ( wingnum == -1 ) {
7533 if ( !SDL_strcasecmp(Wings[i].name, NOX("delta")) || !SDL_strcasecmp(Wings[i].name, NOX("epsilon")) ) {
7538 if ( wingnum == -1 ){
7543 for ( j = 0; j < Wings[wingnum].current_count; j++ ) {
7544 ship_index = Wings[wingnum].ship_index[j];
7545 SDL_assert( ship_index != -1 );
7547 if ( Ships[ship_index].flags & SF_DYING ) {
7551 // see if ship meets our criterea
7552 if ( (flags == SHIP_GET_NO_PLAYERS) && (Objects[Ships[ship_index].objnum].flags & OF_PLAYER_SHIP) ){
7556 // don't process ships on a different team
7558 if ( Player_ship->team != Ships[ship_index].team ){
7563 // see if ship is within max_dist units
7564 if ( (max_dist > 0) && (multi_team < 0) ) {
7566 dist = vm_vec_dist_quick(&Objects[Ships[ship_index].objnum].pos, &Player_obj->pos);
7567 if ( dist > max_dist ) {
7572 // if we should be checking persona's, then don't add ships that don't have the proper persona
7573 if ( persona_index != -1 ) {
7574 if ( Ships[ship_index].persona_index != persona_index ){
7579 // return the first ship with correct persona
7584 slist[count] = ship_index;
7593 // now get a random one from the list
7594 which_one = (rand() % count);
7595 ship_index = slist[which_one];
7597 SDL_assert ( Ships[ship_index].objnum != -1 );
7602 // like above function, but returns a random ship in the given wing -- no restrictions
7603 // input: max_dist => OPTIONAL PARAMETER (default value 0.0f) max range ship can be from player
7604 int ship_get_random_ship_in_wing(int wingnum, int flags, float max_dist, int get_first)
7606 int i, ship_index, slist[MAX_SHIPS_PER_WING], count, which_one;
7609 for ( i = 0; i < Wings[wingnum].current_count; i++ ) {
7610 ship_index = Wings[wingnum].ship_index[i];
7611 SDL_assert( ship_index != -1 );
7613 if ( Ships[ship_index].flags & SF_DYING ) {
7617 // see if ship meets our criterea
7618 if ( (flags == SHIP_GET_NO_PLAYERS) && (Objects[Ships[ship_index].objnum].flags & OF_PLAYER_SHIP) )
7621 // see if ship is within max_dist units
7622 if ( max_dist > 0 ) {
7624 dist = vm_vec_dist_quick(&Objects[Ships[ship_index].objnum].pos, &Player_obj->pos);
7625 if ( dist > max_dist ) {
7630 // return the first ship in wing
7635 slist[count] = ship_index;
7643 // now get a random one from the list
7644 which_one = (rand() % count);
7645 ship_index = slist[which_one];
7647 SDL_assert ( Ships[ship_index].objnum != -1 );
7653 // this function returns a random index into the Ship array of a ship of the given team
7654 // cargo containers are not counted as ships for the purposes of this function. Why???
7655 // because now it is only used for getting a random ship for a message and cargo containers
7656 // can't send mesages. This function is an example of kind of bad coding :-(
7657 // input: max_dist => OPTIONAL PARAMETER (default value 0.0f) max range ship can be from player
7658 int ship_get_random_team_ship( int team, int flags, float max_dist )
7661 object *objp, *obj_list[MAX_SHIPS];
7663 // for any allied, go through the ships list and find all of the ships on that team
7665 for ( objp = GET_FIRST(&obj_used_list); objp != END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
7666 if ( objp->type != OBJ_SHIP )
7669 // series of conditionals one per line for easy reading
7670 // don't process ships on wrong team
7671 // don't process cargo's or navbuoys
7672 // don't process player ships if flags are set
7673 if ( Ships[objp->instance].team != team )
7675 else if ( Ship_info[Ships[objp->instance].ship_info_index].flags & SIF_NOT_FLYABLE )
7677 else if ( (flags == SHIP_GET_NO_PLAYERS) && (objp->flags & OF_PLAYER_SHIP) )
7679 else if ( (flags == SHIP_GET_ONLY_PLAYERS) && !(objp->flags & OF_PLAYER_SHIP) )
7682 if ( Ships[objp->instance].flags & SF_DYING ) {
7686 // see if ship is within max_dist units
7687 if ( max_dist > 0 ) {
7689 dist = vm_vec_dist_quick(&objp->pos, &Player_obj->pos);
7690 if ( dist > max_dist ) {
7695 obj_list[num] = objp;
7702 which_one = (rand() % num);
7703 objp = obj_list[which_one];
7705 SDL_assert ( objp->instance != -1 );
7707 return objp->instance;
7710 // -----------------------------------------------------------------------
7711 // ship_secondary_bank_has_ammo()
7713 // check if currently selected secondary bank has ammo
7715 // input: shipnum => index into Ships[] array for ship to check
7717 int ship_secondary_bank_has_ammo(int shipnum)
7721 SDL_assert(shipnum >= 0 && shipnum < MAX_SHIPS);
7722 swp = &Ships[shipnum].weapons;
7724 if ( swp->current_secondary_bank == -1 )
7727 SDL_assert(swp->current_secondary_bank >= 0 && swp->current_secondary_bank < MAX_SECONDARY_BANKS );
7728 if ( swp->secondary_bank_ammo[swp->current_secondary_bank] <= 0 )
7734 // see if there is enough engine power to allow the ship to warp
7735 // returns 1 if ship is able to warp, otherwise return 0
7736 int ship_can_warp(ship *sp)
7740 engine_str = ship_get_subsystem_strength( sp, SUBSYSTEM_ENGINE );
7741 // Note that ship can always warp at lowest skill level
7742 if ( (Game_skill_level > 0) && (engine_str >= SHIP_MIN_ENGINES_TO_WARP) ){
7750 // Calculate the normal vector from a subsystem position and it's first path point
7751 // input: sp => pointer to ship that is parent of subsystem
7752 // ss => pointer to subsystem of interest
7753 // norm => output parameter... vector from subsys to first path point
7755 // exit: 0 => a valid vector was placed in norm
7756 // !0 => an path normal could not be calculated
7758 int ship_return_subsys_path_normal(ship *sp, ship_subsys *ss, vector *gsubpos, vector *norm)
7760 if ( ss->system_info->path_num >= 0 ) {
7765 pm = model_get(sp->modelnum);
7766 mp = &pm->paths[ss->system_info->path_num];
7767 if ( mp->nverts >= 2 ) {
7768 // path_point = &mp->verts[mp->nverts-1].pos;
7769 path_point = &mp->verts[0].pos;
7770 // get path point in world coords
7771 vm_vec_unrotate(&gpath_point, path_point, &Objects[sp->objnum].orient);
7772 vm_vec_add2(&gpath_point, &Objects[sp->objnum].pos);
7773 // get unit vector pointing from subsys pos to first path point
7774 vm_vec_normalized_dir(norm, &gpath_point, gsubpos);
7782 // Determine if the subsystem can be viewed from eye_pos. The method is to check where the
7783 // vector from eye_pos to the subsystem hits the ship. If distance from the hit position and
7784 // the center of the subsystem is within a range (currently the subsystem radius) it is considered
7785 // in view (return true). If not in view, return false.
7787 // input: objp => object that is the ship with the subsystem on it
7788 // subsys => pointer to the subsystem of interest
7789 // eye_pos => world coord for the eye looking at the subsystem
7790 // subsys_pos => world coord for the center of the subsystem of interest
7791 // do_facing_check => OPTIONAL PARAMETER (default value is 1), do a dot product check to see if subsystem fvec is facing
7792 // towards the eye position
7793 // dot_out => OPTIONAL PARAMETER, output parameter, will return dot between subsys fvec and subsys_to_eye_vec
7794 // (only filled in if do_facing_check is true)
7795 // vec_out => OPTIONAL PARAMETER, vector from eye_pos to absolute subsys_pos. (only filled in if do_facing_check is true)
7796 int ship_subsystem_in_sight(object* objp, ship_subsys* subsys, vector *eye_pos, vector* subsys_pos, int do_facing_check, float *dot_out, vector *vec_out)
7800 vector terminus, eye_to_pos, subsys_fvec, subsys_to_eye_vec;
7802 if (objp->type != OBJ_SHIP)
7805 // See if we are at least facing the subsystem
7806 if ( do_facing_check ) {
7807 if ( ship_return_subsys_path_normal(&Ships[objp->instance], subsys, subsys_pos, &subsys_fvec) ) {
7808 // non-zero return value means that we couldn't generate a normal from path info... so use inaccurate method
7809 vm_vec_normalized_dir(&subsys_fvec, subsys_pos, &objp->pos);
7812 vm_vec_normalized_dir(&subsys_to_eye_vec, eye_pos, subsys_pos);
7813 dot = vm_vec_dot(&subsys_fvec, &subsys_to_eye_vec);
7819 *vec_out = subsys_to_eye_vec;
7820 vm_vec_negate(vec_out);
7827 // See if ray from eye to subsystem actually hits close enough to the subsystem position
7828 vm_vec_normalized_dir(&eye_to_pos, subsys_pos, eye_pos);
7829 vm_vec_scale_add(&terminus, eye_pos, &eye_to_pos, 100000.0f);
7831 ship_model_start(objp);
7833 mc.model_num = Ships[objp->instance].modelnum; // Fill in the model to check
7834 mc.orient = &objp->orient; // The object's orientation
7835 mc.pos = &objp->pos; // The object's position
7836 mc.p0 = eye_pos; // Point 1 of ray to check
7837 mc.p1 = &terminus; // Point 2 of ray to check
7838 mc.flags = MC_CHECK_MODEL;
7842 ship_model_stop(objp);
7844 if ( !mc.num_hits ) {
7848 // determine if hitpos is close enough to subsystem
7849 dist = vm_vec_dist(&mc.hit_point_world, subsys_pos);
7851 if ( dist <= subsys->system_info->radius ) {
7858 // try to find a subsystem matching 'type' inside the ship, and that is
7859 // not destroyed. If cannot find one, return NULL.
7860 ship_subsys *ship_return_next_subsys(ship *shipp, int type, vector *attacker_pos)
7864 SDL_assert ( type >= 0 && type < SUBSYSTEM_MAX );
7866 // If aggregate total is 0, that means no subsystem is alive of that type
7867 if ( shipp->subsys_info[type].total_hits <= 0.0f )
7870 // loop through all the subsystems, if we find a match that has some strength, return it
7871 ssp = ship_get_best_subsys_to_attack(shipp, type, attacker_pos);
7876 // Return the shield strength in the quadrant hit on hit_objp, based on global hitpos
7878 // input: hit_objp => object pointer to ship getting hit
7879 // hitpos => global position of impact
7881 // exit: strength of shields in the quadrant that was hit as a percentage, between 0 and 1.0
7883 // Assumes: that hitpos is a valid global hit position
7884 float ship_quadrant_shield_strength(object *hit_objp, vector *hitpos)
7886 int quadrant_num, i;
7888 vector tmpv1, tmpv2;
7890 // If ship doesn't have shield mesh, then return
7891 if ( hit_objp->flags & OF_NO_SHIELDS ) {
7895 // Check if all the shield quadrants are all already 0, if so return 0
7896 for ( i = 0; i < 4; i++ ) {
7897 if ( hit_objp->shields[i] > 0 )
7905 // convert hitpos to position in model coordinates
7906 vm_vec_sub(&tmpv1, hitpos, &hit_objp->pos);
7907 vm_vec_rotate(&tmpv2, &tmpv1, &hit_objp->orient);
7908 quadrant_num = get_quadrant(&tmpv2);
7909 //nprintf(("Alan","Quadrant hit: %d\n", quadrant_num));
7911 if ( quadrant_num < 0 )
7914 max_quadrant = Ship_info[Ships[hit_objp->instance].ship_info_index].shields / 4.0f;
7915 if ( max_quadrant <= 0 ) {
7919 SDL_assert(hit_objp->shields[quadrant_num] <= max_quadrant);
7921 return hit_objp->shields[quadrant_num]/max_quadrant;
7924 // Determine if a ship is threatened by any dumbfire projectiles (laser or missile)
7925 // input: sp => pointer to ship that might be threatened
7926 // exit: 0 => no dumbfire threats
7927 // 1 => at least one dumbfire threat
7929 // NOTE: Currently this function is only called periodically from the HUD code for the
7931 int ship_dumbfire_threat(ship *sp)
7933 if ( (Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_OBSERVER) ) {
7937 if (ai_endangered_by_weapon(&Ai_info[sp->ai_index]) > 0) {
7944 // Return !0 if there is a missile in the air homing on shipp
7945 int ship_has_homing_missile_locked(ship *shipp)
7947 object *locked_objp, *A;
7952 SDL_assert(shipp->objnum >= 0 && shipp->objnum < MAX_OBJECTS);
7953 locked_objp = &Objects[shipp->objnum];
7955 // check for currently locked missiles (highest precedence)
7956 for ( mo = GET_NEXT(&Missile_obj_list); mo != END_OF_LIST(&Missile_obj_list); mo = GET_NEXT(mo) ) {
7957 SDL_assert(mo->objnum >= 0 && mo->objnum < MAX_OBJECTS);
7958 A = &Objects[mo->objnum];
7960 if (A->type != OBJ_WEAPON)
7963 SDL_assert((A->instance >= 0) && (A->instance < MAX_WEAPONS));
7964 wp = &Weapons[A->instance];
7965 wip = &Weapon_info[wp->weapon_info_index];
7967 if ( wip->subtype != WP_MISSILE )
7970 if ( !(wip->wi_flags & (WIF_HOMING_ASPECT|WIF_HOMING_HEAT) ) )
7973 if (wp->homing_object == locked_objp) {
7981 // Return !0 if there is some ship attempting to lock onto shipp
7982 int ship_is_getting_locked(ship *shipp)
7988 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
7989 objp = &Objects[so->objnum];
7990 aip = &Ai_info[Ships[objp->instance].ai_index];
7992 if ( aip->target_objnum == shipp->objnum ) {
7993 if ( aip->aspect_locked_time > 0.1f ) {
7994 float dist, wep_range;
7995 dist = vm_vec_dist_quick(&objp->pos, &Objects[shipp->objnum].pos);
7996 wep_range = ship_get_secondary_weapon_range(&Ships[objp->instance]);
7997 if ( wep_range > dist ) {
7998 nprintf(("Alan","AI ship is seeking lock\n"));
8008 // Determine if a ship is threatened by attempted lock or actual lock
8009 // input: sp => pointer to ship that might be threatened
8010 // exit: 0 => no lock threats of any kind
8011 // 1 => at least one attempting lock (no actual locks)
8012 // 2 => at least one lock (possible other attempting locks)
8014 // NOTE: Currently this function is only called periodically from the HUD code for the
8016 int ship_lock_threat(ship *sp)
8018 if ( ship_has_homing_missile_locked(sp) ) {
8022 if ( ship_is_getting_locked(sp) ) {
8029 // converts a bitmask, such as 0x08, into the bit number this would be (3 in this case)
8030 // NOTE: Should move file to something like Math_utils.
8031 int bitmask_2_bitnum(int num)
8035 for (i=0; i<32; i++)
8042 // Get a text description of a ships orders.
8044 // input: outbuf => buffer to hold orders string
8045 // sp => ship pointer to extract orders from
8047 // exit: NULL => printable orders are not applicable
8048 // non-NULL => pointer to string that was passed in originally
8050 // This function is called from HUD code to get a text description
8051 // of what a ship's orders are. Feel free to use this function if
8052 // it suits your needs for something.
8054 char *ship_return_orders(char *outbuf, const int max_outbuf, ship *sp)
8058 const char *order_text;
8060 SDL_assert(sp->ai_index >= 0);
8061 aip = &Ai_info[sp->ai_index];
8063 // The active goal is always in the first element of aip->goals[]
8064 aigp = &aip->goals[0];
8066 if ( aigp->ai_mode < 0 )
8069 order_text = Ai_goal_text(bitmask_2_bitnum(aigp->ai_mode));
8070 if ( order_text == NULL )
8073 SDL_strlcpy(outbuf, order_text, max_outbuf);
8074 switch (aigp->ai_mode ) {
8076 case AI_GOAL_FORM_ON_WING:
8077 case AI_GOAL_GUARD_WING:
8078 case AI_GOAL_CHASE_WING:
8079 if ( aigp->ship_name ) {
8080 SDL_strlcat(outbuf, aigp->ship_name, max_outbuf);
8081 SDL_strlcat(outbuf, XSTR( " Wing", 494), max_outbuf);
8083 SDL_strlcpy(outbuf, XSTR( "no orders", 495), max_outbuf);
8089 case AI_GOAL_UNDOCK:
8091 case AI_GOAL_DISABLE_SHIP:
8092 case AI_GOAL_DISARM_SHIP:
8093 case AI_GOAL_EVADE_SHIP:
8094 case AI_GOAL_REARM_REPAIR:
8095 if ( aigp->ship_name ) {
8096 SDL_strlcat(outbuf, aigp->ship_name, max_outbuf);
8098 SDL_strlcpy(outbuf, XSTR( "no orders", 495), max_outbuf);
8102 case AI_GOAL_DESTROY_SUBSYSTEM: {
8103 char name[NAME_LENGTH];
8104 if ( aip->targeted_subsys != NULL ) {
8105 SDL_snprintf(outbuf, max_outbuf, XSTR( "atk %s %s", 496), aigp->ship_name, hud_targetbox_truncate_subsys_name(aip->targeted_subsys->system_info->name, SDL_arraysize(aip->targeted_subsys->system_info->name)));
8106 SDL_strlcat(outbuf, name, max_outbuf);
8108 SDL_strlcpy(outbuf, XSTR( "no orders", 495), max_outbuf);
8113 case AI_GOAL_WAYPOINTS:
8114 case AI_GOAL_WAYPOINTS_ONCE:
8115 // don't do anything, all info is in order_text
8125 // return the amount of time until ship reaches it's goal (in MM:SS format)
8126 // input: outbuf => buffer to hold orders string
8127 // sp => ship pointer to extract orders from
8129 // exit: NULL => printable orders are not applicable
8130 // non-NULL => pointer to string that was passed in originally
8132 // This function is called from HUD code to get a text description
8133 // of what a ship's orders are. Feel free to use this function if
8134 // it suits your needs for something.
8135 char *ship_return_time_to_goal(char *outbuf, const int max_outbuf, ship *sp)
8138 int time, seconds, minutes;
8143 objp = &Objects[sp->objnum];
8144 aip = &Ai_info[sp->ai_index];
8146 //min_speed = objp->phys_info.speed;
8148 if ( aip->mode == AIM_WAYPOINTS ) {
8150 min_speed = 0.9f * sp->current_max_speed;
8151 if (aip->wp_list >= 0) {
8152 wpl = &Waypoint_lists[aip->wp_list];
8153 dist += vm_vec_dist_quick(&objp->pos, &wpl->waypoints[aip->wp_index]);
8154 for (int i=aip->wp_index; i<wpl->count-1; i++) {
8155 dist += vm_vec_dist_quick(&wpl->waypoints[i], &wpl->waypoints[i+1]);
8163 if ( (Objects[sp->objnum].phys_info.speed <= 0) || (sp->current_max_speed <= 0.0f) ) {
8168 speed = objp->phys_info.speed;
8170 if (speed < min_speed)
8172 time = fl2i(dist/speed);
8175 } else if ( (aip->mode == AIM_DOCK) && (aip->submode < AIS_DOCK_4) ) {
8176 time = hud_support_get_dock_time( OBJ_INDEX(objp) );
8178 // don't return anytime for time to except for waypoints and actual docking.
8183 } else if ( aip->goal_objnum >= 0 ) {
8184 dist = vm_vec_dist_quick(&Objects[aip->goal_objnum].pos, &objp->pos);
8185 min_speed = sip->max_speed/4.0f;
8186 } else if ( aip->target_objnum >= 0 ) {
8187 if ( aip->guard_objnum < 0 ) {
8188 dist = vm_vec_dist_quick(&Objects[aip->target_objnum].pos, &objp->pos);
8189 min_speed = sip->max_speed/4.0f;
8197 if ( minutes > 99 ) {
8201 SDL_snprintf(outbuf, max_outbuf, NOX("%02d:%02d"), minutes, seconds);
8203 SDL_strlcpy( outbuf, XSTR( "Unknown", 497), max_outbuf );
8210 // Called to check if any AI ships might reveal the cargo of any cargo containers.
8212 // This is called once a frame, but a global timer 'Ship_cargo_check_timer' will limit this
8213 // function to being called every SHIP_CARGO_CHECK_INTERVAL ms. I think that should be sufficient.
8215 // NOTE: This function uses CARGO_REVEAL_DISTANCE from the HUD code... which is a multiple of
8216 // the ship radius that is used to determine when cargo is detected. AI ships do not
8217 // have to have the ship targeted to reveal cargo. The player is ignored in this function.
8218 #define SHIP_CARGO_CHECK_INTERVAL 1000
8219 void ship_check_cargo_all()
8222 ship_obj *cargo_so, *ship_so;
8223 ship *cargo_sp, *ship_sp;
8224 float dist_squared, limit_squared;
8226 // I don't want to do this check every frame, so I made a global timer to limit check to
8227 // every SHIP_CARGO_CHECK_INTERVAL ms.
8228 if ( !timestamp_elapsed(Ship_cargo_check_timer) ) {
8231 Ship_cargo_check_timer = timestamp(SHIP_CARGO_CHECK_INTERVAL);
8234 // Check all friendly fighter/bombers against all non-friendly cargo containers that don't have
8237 // for now just locate a captial ship on the same team:
8238 cargo_so = GET_FIRST(&Ship_obj_list);
8239 while(cargo_so != END_OF_LIST(&Ship_obj_list)){
8240 cargo_sp = &Ships[Objects[cargo_so->objnum].instance];
8241 if ( (Ship_info[cargo_sp->ship_info_index].flags & SIF_CARGO) && !(cargo_sp->team & TEAM_FRIENDLY) ) {
8243 // If the cargo is revealed, continue on to next hostile cargo
8244 if ( cargo_sp->flags & SF_CARGO_REVEALED ) {
8248 // check against friendly fighter/bombers + cruiser/freighter/transport
8249 // IDEA: could cull down to fighter/bomber if we want this to run a bit quicker
8250 for ( ship_so=GET_FIRST(&Ship_obj_list); ship_so != END_OF_LIST(&Ship_obj_list); ship_so=GET_NEXT(ship_so) ) {
8251 ship_sp = &Ships[Objects[ship_so->objnum].instance];
8252 // only consider friendly ships
8253 if ( !(ship_sp->team & TEAM_FRIENDLY) ) {
8257 // ignore the player
8258 if ( ship_so->objnum == OBJ_INDEX(Player_obj) ) {
8262 // if this ship is a small or big ship
8263 if ( Ship_info[ship_sp->ship_info_index].flags & (SIF_SMALL_SHIP|SIF_BIG_SHIP) ) {
8264 cargo_objp = &Objects[cargo_sp->objnum];
8265 // use square of distance, faster than getting real distance (which will use sqrt)
8266 dist_squared = vm_vec_dist_squared(&cargo_objp->pos, &Objects[ship_sp->objnum].pos);
8267 limit_squared = (cargo_objp->radius+CARGO_RADIUS_DELTA)*(cargo_objp->radius+CARGO_RADIUS_DELTA);
8268 if ( dist_squared <= SDL_max(limit_squared, CARGO_REVEAL_MIN_DIST*CARGO_REVEAL_MIN_DIST) ) {
8269 ship_do_cargo_revealed( cargo_sp );
8270 break; // break out of for loop, move on to next hostile cargo
8276 cargo_so = GET_NEXT(cargo_so);
8281 // Maybe warn player about this attacking ship. This is called once per frame, and the
8282 // information about the closest attacking ship comes for free, since this function is called
8283 // from HUD code which has already determined the closest enemy attacker and the distance.
8285 // input: enemy_sp => ship pointer to the TEAM_ENEMY ship attacking the player
8286 // dist => the distance of the enemy to the player
8288 // NOTE: there are no filters on enemy_sp, so it could be any ship type
8290 #define PLAYER_ALLOW_WARN_INTERVAL 60000 // minimum time between warnings
8291 #define PLAYER_CHECK_WARN_INTERVAL 300 // how often we check for warnings
8292 #define PLAYER_MAX_WARNINGS 2 // max number of warnings player can receive in a mission
8293 #define PLAYER_MIN_WARN_DIST 100 // minimum distance attacking ship can be from player and still allow warning
8294 #define PLAYER_MAX_WARN_DIST 1000 // maximum distance attacking ship can be from plyaer and still allow warning
8296 void ship_maybe_warn_player(ship *enemy_sp, float dist)
8298 float fdot; //, rdot, udot;
8299 vector vec_to_target;
8300 int msg_type; //, on_right;
8302 // First check if the player has reached the maximum number of warnings for a mission
8303 if ( Player->warn_count >= PLAYER_MAX_WARNINGS ) {
8307 // Check if enough time has elapsed since last warning, if not - leave
8308 if ( !timestamp_elapsed(Player->allow_warn_timestamp) ) {
8312 // Check to see if check timer has elapsed. Necessary, since we don't want to check each frame
8313 if ( !timestamp_elapsed(Player->check_warn_timestamp ) ) {
8316 Player->check_warn_timestamp = timestamp(PLAYER_CHECK_WARN_INTERVAL);
8318 // only allow warnings if within a certain distance range
8319 if ( dist < PLAYER_MIN_WARN_DIST || dist > PLAYER_MAX_WARN_DIST ) {
8323 // only warn if a fighter or bomber is attacking the player
8324 if ( !(Ship_info[enemy_sp->ship_info_index].flags & SIF_SMALL_SHIP) ) {
8328 // get vector from player to target
8329 vm_vec_normalized_dir(&vec_to_target, &Objects[enemy_sp->objnum].pos, &Eye_position);
8331 // ensure that enemy fighter is oriented towards player
8332 fdot = vm_vec_dot(&Objects[enemy_sp->objnum].orient.v.fvec, &vec_to_target);
8333 if ( fdot > -0.7 ) {
8337 fdot = vm_vec_dot(&Player_obj->orient.v.fvec, &vec_to_target);
8339 // check if attacking ship is on six. return if not far enough behind player.
8343 msg_type = MESSAGE_CHECK_6;
8345 goto warn_player_done;
8348 // see if attacking ship is in front of ship (then do nothing)
8353 // ok, ship is on 3 or 9. Find out which
8354 rdot = vm_vec_dot(&Player_obj->orient.v.rvec, &vec_to_target);
8361 // now determine if ship is high or low
8362 udot = vm_vec_dot(&Player_obj->orient.v.uvec, &vec_to_target);
8363 if ( udot < -0.8 ) {
8364 return; // if ship is attacking from directly below, no warning given
8369 msg_type = MESSAGE_CHECK_3_HIGH;
8371 msg_type = MESSAGE_CHECK_9_HIGH;
8375 msg_type = MESSAGE_CHECK_3_LOW;
8377 msg_type = MESSAGE_CHECK_9_LOW;
8384 if ( msg_type != -1 ) {
8387 // multiplayer tvt - this is client side.
8388 if((Game_mode & GM_MULTIPLAYER) && (Netgame.type_flags & NG_TYPE_TEAM) && (Net_player != NULL)){
8389 ship_index = ship_get_random_player_wing_ship( SHIP_GET_NO_PLAYERS, 0.0f, -1, 0, Net_player->p_info.team );
8391 ship_index = ship_get_random_player_wing_ship( SHIP_GET_NO_PLAYERS );
8394 if ( ship_index >= 0 ) {
8395 // multiplayer - make sure I just send to myself
8396 if(Game_mode & GM_MULTIPLAYER){
8397 message_send_builtin_to_player(msg_type, &Ships[ship_index], MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, MY_NET_PLAYER_NUM, -1);
8399 message_send_builtin_to_player(msg_type, &Ships[ship_index], MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, -1, -1);
8401 Player->allow_warn_timestamp = timestamp(PLAYER_ALLOW_WARN_INTERVAL);
8402 Player->warn_count++;
8403 // nprintf(("Alan","Warning given for ship name: %s\n", enemy_sp->ship_name));
8408 // player has just killed a ship, maybe offer send a 'good job' message
8409 #define PLAYER_MAX_PRAISES 10 // max number of praises player can receive in a mission
8410 void ship_maybe_praise_player(ship *deader_sp)
8416 // First check if the player has reached the maximum number of praises for a mission
8417 if ( Player->praise_count >= PLAYER_MAX_PRAISES ) {
8421 // Check if enough time has elapsed since last praise, if not - leave
8422 if ( !timestamp_elapsed(Player->allow_praise_timestamp) ) {
8426 if ( !(Player_ship->team & TEAM_FRIENDLY) ) {
8430 if ( deader_sp->team == Player_ship->team ) { // only praise if killing an enemy!
8434 // don't praise the destruction of navbuoys, cargo or other non-flyable ship types
8435 if ( Ship_info[deader_sp->ship_info_index].flags & SIF_NOT_FLYABLE ) {
8439 // There is already a praise pending
8440 if ( Player->praise_delay_timestamp ) {
8444 // We don't want to praise the player right away.. it is more realistic to wait a moment
8445 Player->praise_delay_timestamp = timestamp_rand(1000, 2000);
8448 // player has just killed a ship, maybe offer send a 'good job' message
8449 #define PLAYER_ASK_HELP_INTERVAL 60000 // minimum time between praises
8450 #define PLAYER_MAX_ASK_HELP 10 // max number of warnings player can receive in a mission
8451 #define ASK_HELP_SHIELD_PERCENT 0.1 // percent shields at which ship will ask for help
8452 #define ASK_HELP_HULL_PERCENT 0.3 // percent hull at which ship will ask for help
8453 #define AWACS_HELP_HULL_HI 0.75 // percent hull at which ship will ask for help
8454 #define AWACS_HELP_HULL_LOW 0.25 // percent hull at which ship will ask for help
8456 // -----------------------------------------------------------------------------
8457 void awacs_maybe_ask_for_help(ship *sp, int multi_team_filter)
8461 objp = &Objects[sp->objnum];
8463 if ( objp->hull_strength < ( (AWACS_HELP_HULL_LOW + 0.01f *(static_rand(objp-Objects) & 5)) * Ship_info[sp->ship_info_index].initial_hull_strength) ) {
8464 // awacs ship below 25 + (0-4) %
8465 if (!(sp->awacs_warning_flag & AWACS_WARN_25)) {
8466 message = MESSAGE_AWACS_25;
8467 sp->awacs_warning_flag |= AWACS_WARN_25;
8469 } else if ( objp->hull_strength < ( (AWACS_HELP_HULL_HI + 0.01f*(static_rand(objp-Objects) & 5)) * Ship_info[sp->ship_info_index].initial_hull_strength) ) {
8470 // awacs ship below 75 + (0-4) %
8471 if (!(sp->awacs_warning_flag & AWACS_WARN_75)) {
8472 message = MESSAGE_AWACS_75;
8473 sp->awacs_warning_flag |= AWACS_WARN_75;
8478 message_send_builtin_to_player(message, sp, MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, -1, multi_team_filter);
8479 Player->allow_ask_help_timestamp = timestamp(PLAYER_ASK_HELP_INTERVAL);
8480 Player->ask_help_count++;
8484 // -----------------------------------------------------------------------------
8485 void ship_maybe_ask_for_help(ship *sp)
8488 int multi_team_filter = -1;
8490 // First check if the player has reached the maximum number of ask_help's for a mission
8491 if ( Player->ask_help_count >= PLAYER_MAX_ASK_HELP ) {
8495 // Check if enough time has elapsed since last help request, if not - leave
8496 if ( !timestamp_elapsed(Player->allow_ask_help_timestamp) ) {
8500 if ( !(Player_ship->team & TEAM_FRIENDLY) ) {
8504 SDL_assert(sp->team & TEAM_FRIENDLY );
8505 objp = &Objects[sp->objnum];
8507 if ( objp->flags & OF_PLAYER_SHIP ) {// don't let the player ask for help!
8511 // determine team filter if TvT
8512 if((Game_mode & GM_MULTIPLAYER) && (Netgame.type_flags & NG_TYPE_TEAM)){
8513 if(sp->team == TEAM_FRIENDLY){
8514 multi_team_filter = 0;
8515 } else if(sp->team == TEAM_HOSTILE){
8516 multi_team_filter = 1;
8520 // handle awacs ship as a special case
8521 if (Ship_info[sp->ship_info_index].flags & SIF_HAS_AWACS) {
8522 awacs_maybe_ask_for_help(sp, multi_team_filter);
8526 // for now, only have wingman ships request help
8527 if ( !(sp->flags & SF_FROM_PLAYER_WING) ) {
8531 // first check if hull is at a critical level
8532 if ( objp->hull_strength < ASK_HELP_HULL_PERCENT * Ship_info[sp->ship_info_index].initial_hull_strength ) {
8536 // check if shields are near critical level
8537 if ( objp->flags & OF_NO_SHIELDS ) {
8538 return; // no shields on ship, no don't check shield levels
8541 if ( get_shield_strength(objp) > (ASK_HELP_SHIELD_PERCENT * Ship_info[sp->ship_info_index].shields) ) {
8547 SDL_assert(Ship_info[sp->ship_info_index].flags & (SIF_FIGHTER|SIF_BOMBER) ); // get Alan
8548 message_send_builtin_to_player(MESSAGE_HELP, sp, MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, -1, multi_team_filter);
8549 Player->allow_ask_help_timestamp = timestamp(PLAYER_ASK_HELP_INTERVAL);
8551 if ( timestamp_until(Player->allow_scream_timestamp) < 15000 ) {
8552 Player->allow_scream_timestamp = timestamp(15000); // prevent overlap with death message
8555 Player->ask_help_count++;
8558 // The player has just entered death roll, maybe have wingman mourn the loss of the player
8559 void ship_maybe_lament()
8563 // no. because in multiplayer, its funny
8564 if(Game_mode & GM_MULTIPLAYER){
8568 if ( rand()%4 == 0 ) {
8569 ship_index = ship_get_random_player_wing_ship( SHIP_GET_NO_PLAYERS );
8570 if ( ship_index >= 0 ) {
8571 message_send_builtin_to_player(MESSAGE_PLAYED_DIED, &Ships[ship_index], MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, -1, -1);
8576 #define PLAYER_SCREAM_INTERVAL 60000
8577 #define PLAYER_MAX_SCREAMS 10
8579 // play a death scream for a ship
8580 void ship_scream(ship *sp)
8582 int multi_team_filter = -1;
8590 if((Game_mode & GM_MULTIPLAYER) && (Netgame.type_flags & NG_TYPE_TEAM)){
8591 if(sp->team == TEAM_FRIENDLY){
8592 multi_team_filter = 0;
8593 } else if(sp->team == TEAM_HOSTILE){
8594 multi_team_filter = 1;
8598 message_send_builtin_to_player(MESSAGE_WINGMAN_SCREAM, sp, MESSAGE_PRIORITY_HIGH, MESSAGE_TIME_IMMEDIATE, 0, 0, -1, multi_team_filter);
8599 Player->allow_scream_timestamp = timestamp(PLAYER_SCREAM_INTERVAL);
8600 Player->scream_count++;
8601 sp->flags |= SF_SHIP_HAS_SCREAMED;
8603 // prevent overlap with help messages
8604 if ( timestamp_until(Player->allow_ask_help_timestamp) < 15000 ) {
8605 Player->allow_ask_help_timestamp = timestamp(15000); // prevent overlap with death message
8609 // ship has just died, maybe play a scream.
8611 // NOTE: this is only called for ships that are in a player wing (and not player ship)
8612 void ship_maybe_scream(ship *sp)
8617 // First check if the player has reached the maximum number of screams for a mission
8618 if ( Player->scream_count >= PLAYER_MAX_SCREAMS ) {
8622 // if on different teams (i.e. team v. team games in multiplayer), no scream
8623 if ( sp->team != Player_ship->team ) {
8627 // Check if enough time has elapsed since last scream, if not - leave
8628 if ( !timestamp_elapsed(Player->allow_scream_timestamp) ) {
8635 // maybe tell player that we've requested a support ship
8636 #define PLAYER_REQUEST_REPAIR_MSG_INTERVAL 240000
8637 void ship_maybe_tell_about_rearm(ship *sp)
8639 if ( !timestamp_elapsed(Player->request_repair_timestamp) ) {
8643 if ( !(Player_ship->team & TEAM_FRIENDLY) ) {
8647 // AL 1-4-98: If ship integrity is low, tell player you want to get repaired. Otherwise, tell
8648 // the player you want to get re-armed.
8650 int message_type = -1;
8651 int heavily_damaged = 0;
8652 if ( Objects[sp->objnum].hull_strength/Ship_info[sp->ship_info_index].initial_hull_strength < 0.4 ) {
8653 heavily_damaged = 1;
8656 if ( heavily_damaged || (sp->flags & SF_DISABLED) ) {
8657 message_type = MESSAGE_REPAIR_REQUEST;
8663 for ( i = 0; i < swp->num_secondary_banks; i++ ) {
8664 if (swp->secondary_bank_start_ammo[i] > 0) {
8665 if ( swp->secondary_bank_ammo[i]/swp->secondary_bank_start_ammo[i] < 0.5f ) {
8666 message_type = MESSAGE_REARM_REQUEST;
8673 int multi_team_filter = -1;
8676 if((Game_mode & GM_MULTIPLAYER) && (Netgame.type_flags & NG_TYPE_TEAM)){
8677 if(sp->team == TEAM_FRIENDLY){
8678 multi_team_filter = 0;
8679 } else if(sp->team == TEAM_HOSTILE){
8680 multi_team_filter = 1;
8684 if ( message_type >= 0 ) {
8686 message_send_builtin_to_player(message_type, sp, MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_SOON, 0, 0, -1, multi_team_filter);
8688 Player->request_repair_timestamp = timestamp(PLAYER_REQUEST_REPAIR_MSG_INTERVAL);
8692 // The current primary weapon or link status for a ship has changed.. notify clients if multiplayer
8694 // input: sp => pointer to ship that modified primaries
8695 void ship_primary_changed(ship *sp)
8700 // we only need to deal with multiplayer issues for now, so bail it not multiplayer
8701 if ( !(Game_mode & GM_MULTIPLAYER) )
8708 if ( MULTIPLAYER_MASTER )
8709 send_ship_weapon_change( sp, MULTI_PRIMARY_CHANGED, swp->current_primary_bank, (sp->flags & SF_PRIMARY_LINKED)?1:0 );
8713 // The current secondary weapon or dual-fire status for a ship has changed.. notify clients if multiplayer
8715 // input: sp => pointer to ship that modified secondaries
8716 void ship_secondary_changed(ship *sp)
8721 // we only need to deal with multiplayer issues for now, so bail it not multiplayer
8722 if ( !(Game_mode & GM_MULTIPLAYER) ){
8729 if ( MULTIPLAYER_MASTER )
8730 send_ship_weapon_change( sp, MULTI_SECONDARY_CHANGED, swp->current_secondary_bank, (sp->flags & SF_SECONDARY_DUAL_FIRE)?1:0 );
8734 int ship_get_SIF(ship *shipp)
8736 return Ship_info[shipp->ship_info_index].flags;
8739 int ship_get_SIF(int sh)
8741 return Ship_info[Ships[sh].ship_info_index].flags;
8744 int ship_get_by_signature(int signature)
8748 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
8749 // if we found a matching ship object signature
8750 if((Objects[so->objnum].signature == signature) && (Objects[so->objnum].type == OBJ_SHIP)){
8751 return Objects[so->objnum].instance;
8755 // couldn't find the ship
8759 // function which gets called when the cargo of a ship is revealed. Happens at two different locations
8760 // (at least when this function was written), one for the player, and one for AI ships. Need to send stuff
8761 // to clients in multiplayer game.
8762 void ship_do_cargo_revealed( ship *shipp, int from_network )
8764 // don't do anything if we already know the cargo
8765 if ( shipp->flags & SF_CARGO_REVEALED ){
8769 nprintf(("Network", "Revealing cargo for %s\n", shipp->ship_name));
8771 // send the packet if needed
8772 if ( (Game_mode & GM_MULTIPLAYER) && !from_network ){
8773 send_cargo_revealed_packet( shipp );
8776 shipp->flags |= SF_CARGO_REVEALED;
8777 shipp->time_cargo_revealed = Missiontime;
8779 // if the cargo is something other than "nothing", then make a log entry
8780 if ( SDL_strcasecmp(Cargo_names[shipp->cargo1 & CARGO_INDEX_MASK], NOX("nothing")) ){
8781 mission_log_add_entry(LOG_CARGO_REVEALED, shipp->ship_name, NULL, (shipp->cargo1 & CARGO_INDEX_MASK) );
8785 void ship_do_cap_subsys_cargo_revealed( ship *shipp, ship_subsys *subsys, int from_network )
8787 if ( subsys->subsys_cargo_revealed ) {
8792 nprintf(("Network", "Revealing cap ship subsys cargo for %s\n", shipp->ship_name));
8794 // send the packet if needed
8795 if ( (Game_mode & GM_MULTIPLAYER) && !from_network ){
8796 int subsystem_index = ship_get_index_from_subsys(subsys, shipp->objnum);
8797 send_subsystem_cargo_revealed_packet( shipp, subsystem_index );
8800 subsys->subsys_cargo_revealed = 1;
8802 // if the cargo is something other than "nothing", then make a log entry
8803 if ( (subsys->subsys_cargo_name > 0) && SDL_strcasecmp(Cargo_names[subsys->subsys_cargo_name], NOX("nothing")) ){
8804 mission_log_add_entry(LOG_CAP_SUBSYS_CARGO_REVEALED, shipp->ship_name, subsys->system_info->name, subsys->subsys_cargo_name );
8809 // Return the range of the currently selected secondary weapon
8810 // NOTE: If there is no missiles left in the current bank, range returned is 0
8811 float ship_get_secondary_weapon_range(ship *shipp)
8816 swp = &shipp->weapons;
8817 if ( swp->current_secondary_bank >= 0 ) {
8819 int bank=swp->current_secondary_bank;
8820 wip = &Weapon_info[swp->secondary_bank_weapons[bank]];
8821 if ( swp->secondary_bank_ammo[bank] > 0 ) {
8822 srange = wip->max_speed * wip->lifetime;
8829 // Determine the number of secondary ammo units (missile/bomb) allowed max for a ship
8831 int get_max_ammo_count_for_bank(int ship_class, int bank, int ammo_type)
8833 float capacity, size;
8835 capacity = (float) Ship_info[ship_class].secondary_bank_ammo_capacity[bank];
8836 size = (float) Weapon_info[ammo_type].cargo_size;
8837 return (int) (capacity / size);
8842 // Page in bitmaps for all the ships in this level
8846 int num_subsystems_needed = 0;
8848 int ship_class_used[MAX_SHIP_TYPES];
8850 // Mark all ship classes as not used
8851 for (i=0; i<MAX_SHIP_TYPES; i++ ) {
8852 ship_class_used[i] = 0;
8855 // Mark any support ship types as used
8857 for (i=0; i<Num_ship_types; i++ ) {
8858 if ( Ship_info[i].flags & SIF_SUPPORT ) {
8859 nprintf(( "Paging", "Found support ship '%s'\n", Ship_info[i].name ));
8860 ship_class_used[i]++;
8862 num_subsystems_needed += Ship_info[i].n_subsystems;
8866 // Mark any ships in the mission as used
8868 for (i=0; i<MAX_SHIPS; i++) {
8869 if (Ships[i].objnum > -1) {
8870 nprintf(( "Paging","Found ship '%s'\n", Ships[i].ship_name ));
8871 ship_class_used[Ships[i].ship_info_index]++;
8873 num_subsystems_needed += Ship_info[Ships[i].ship_info_index].n_subsystems;
8877 // Mark any ships that might warp in in the future as used
8880 for( p_objp = GET_FIRST(&ship_arrival_list); p_objp != END_OF_LIST(&ship_arrival_list); p_objp = GET_NEXT(p_objp) ) {
8881 nprintf(( "Paging","Found future arrival ship '%s'\n", p_objp->name ));
8882 ship_class_used[p_objp->ship_class]++;
8884 num_subsystems_needed += Ship_info[p_objp->ship_class].n_subsystems;
8888 // Page in all the ship classes that are used on this level
8890 int num_ship_types_used = 0;
8892 for (i=0; i<MAX_SHIP_TYPES; i++ ) {
8893 if ( ship_class_used[i] ) {
8894 ship_info *si = &Ship_info[i];
8896 num_ship_types_used++;
8898 // Page in the small hud icons for each ship
8900 extern void hud_ship_icon_page_in(ship_info *sip);
8902 hud_ship_icon_page_in(si);
8906 // See if this model was previously loaded by another ship
8907 int model_previously_loaded = -1;
8908 int ship_previously_loaded = -1;
8909 for (j=0; j<MAX_SHIP_TYPES; j++ ) {
8910 if ( (Ship_info[j].modelnum > -1) && !SDL_strcasecmp(si->pof_file, Ship_info[j].pof_file) ) {
8911 // Model already loaded
8912 model_previously_loaded = Ship_info[j].modelnum;
8913 ship_previously_loaded = j;
8918 // If the model is previously loaded...
8919 if ( model_previously_loaded > -1 ) {
8921 // If previously loaded model isn't the same ship class...)
8922 if ( ship_previously_loaded != i ) {
8924 // update the model number.
8925 si->modelnum = model_previously_loaded;
8927 for ( j = 0; j < si->n_subsystems; j++ ) {
8928 si->subsystems[j].model_num = -1;
8931 ship_copy_subsystem_fixup(si);
8934 for ( j = 0; j < si->n_subsystems; j++ ) {
8935 SDL_assert( si->subsystems[j].model_num == si->modelnum );
8940 // Just to be safe (I mean to check that my code works...)
8941 SDL_assert( si->modelnum > -1 );
8942 SDL_assert( si->modelnum == model_previously_loaded );
8945 for ( j = 0; j < si->n_subsystems; j++ ) {
8946 SDL_assert( si->subsystems[j].model_num == si->modelnum );
8951 // Model not loaded... so load it and page in its textures
8952 si->modelnum = model_load(si->pof_file, si->n_subsystems, &si->subsystems[0]);
8954 SDL_assert( si->modelnum > -1 );
8956 // Verify that all the subsystem model numbers are updated
8958 for ( j = 0; j < si->n_subsystems; j++ ) {
8959 SDL_assert( si->subsystems[j].model_num == si->modelnum ); // JAS
8968 for (i=0; i<MAX_SHIP_TYPES; i++ ) {
8969 if ( ship_class_used[i] ) {
8970 ship_info *si = &Ship_info[i];
8972 if ( si->modelnum > -1 ) {
8973 polymodel *pm = model_get(si->modelnum);
8975 nprintf(( "Paging", "Paging in textures for model '%s'\n", si->pof_file ));
8977 for (j=0; j<pm->n_textures; j++ ) {
8978 int bitmap_num = pm->original_textures[j];
8980 if ( bitmap_num > -1 ) {
8981 bm_page_in_texture( bitmap_num );
8986 nprintf(( "Paging", "Couldn't load model '%s'\n", si->pof_file ));
8991 nprintf(( "Paging", "There are %d ship classes used in this mission.\n", num_ship_types_used ));
8992 mprintf(( "This mission requires %d Ship_subsystems. See #define MAX_SHIP_SUBOBJECTS.\n", num_subsystems_needed ));
8994 // JAS: If you hit this, then MAX_SHIP_SUBOBJECTS is set too low.
8995 // I added this code in to detect an error that wasn't getting detected any other
8997 SDL_assert(num_subsystems_needed < MAX_SHIP_SUBOBJECTS );
8999 // Page in the thruster effects
9002 // Make sure thrusters are loaded
9003 if ( !Thrust_anim_inited ) ship_init_thrusters();
9005 for ( i = 0; i < NUM_THRUST_ANIMS; i++ ) {
9006 thrust_anim *ta = &Thrust_anims[i];
9007 for ( j = 0; j<ta->num_frames; j++ ) {
9008 bm_page_in_texture( ta->first_frame + j );
9012 for ( i = 0; i < NUM_THRUST_GLOW_ANIMS; i++ ) {
9013 thrust_anim *ta = &Thrust_glow_anims[i];
9014 // glows are really not anims
9015 bm_page_in_texture( ta->first_frame );
9018 // page in insignia bitmaps
9019 if(Game_mode & GM_MULTIPLAYER){
9020 for(i=0; i<MAX_PLAYERS; i++){
9021 if(MULTI_CONNECTED(Net_players[i]) && (Net_players[i].player != NULL) && (Net_players[i].player->insignia_texture >= 0)){
9022 bm_page_in_xparent_texture(Net_players[i].player->insignia_texture);
9026 if((Player != NULL) && (Player->insignia_texture >= 0)){
9027 bm_page_in_xparent_texture(Player->insignia_texture);
9032 // function to return true if support ships are allowed in the mission for the given object.
9033 // In single player, must be friendly and not Shivan.
9034 // In multiplayer -- to be coded by Mark Allender after 5/4/98 -- MK, 5/4/98
9035 int is_support_allowed(object *objp)
9037 if (The_mission.disallow_support){
9041 if ( Game_mode & GM_NORMAL ) {
9042 if (Ships[objp->instance].team != TEAM_FRIENDLY){
9046 switch (Ship_info[Ships[objp->instance].ship_info_index].species) {
9047 case SPECIES_TERRAN:
9049 case SPECIES_VASUDAN:
9051 case SPECIES_SHIVAN:
9059 // multiplayer version behaves differently. Depending on mode:
9060 // 1) coop mode -- only available to friendly
9061 // 2) team v team mode -- availble to either side
9062 // 3) dogfight -- never
9064 if(Netgame.type_flags & NG_TYPE_DOGFIGHT){
9068 if ( IS_MISSION_MULTI_COOP ) {
9069 if ( Ships[objp->instance].team != TEAM_FRIENDLY ){
9079 // return ship index
9080 int ship_get_random_ship()
9087 // get the # of ships on the list
9088 num_ships = ship_get_num_ships();
9090 // get a random ship on the list
9091 rand_ship = (int)frand_range(0.0f, (float)(num_ships - 1));
9095 if(rand_ship > num_ships){
9096 rand_ship = num_ships;
9100 so = GET_FIRST(&Ship_obj_list);
9101 for(idx=0; idx<rand_ship; idx++) {
9105 return Objects[so->objnum].instance;
9108 // forcible jettison cargo from a ship
9109 void ship_jettison_cargo(ship *shipp)
9113 vector impulse, pos;
9115 // make sure we are docked with a valid object
9116 if(shipp->objnum < 0){
9119 objp = &Objects[shipp->objnum];
9120 if(Ai_info[shipp->ai_index].dock_objnum == -1){
9123 if(Objects[Ai_info[shipp->ai_index].dock_objnum].type != OBJ_SHIP){
9127 if(Ai_info[Ships[Objects[Ai_info[shipp->ai_index].dock_objnum].instance].ai_index].dock_objnum != OBJ_INDEX(objp)){
9130 cargo_objp = &Objects[Ai_info[shipp->ai_index].dock_objnum];
9132 // undock the objects
9133 ai_do_objects_undocked_stuff( objp, cargo_objp );
9136 vm_vec_sub(&pos, &cargo_objp->pos, &objp->pos);
9138 vm_vec_scale(&impulse, 100.0f);
9139 vm_vec_normalize(&pos);
9142 physics_apply_whack(&impulse, &pos, &cargo_objp->phys_info, &cargo_objp->orient, cargo_objp->phys_info.mass);
9145 float ship_get_exp_damage(object* objp)
9147 SDL_assert(objp->type == OBJ_SHIP);
9150 ship *shipp = &Ships[objp->instance];
9152 if (shipp->special_exp_index != -1) {
9153 damage = (float) atoi(Sexp_variables[shipp->special_exp_index+DAMAGE].text);
9155 damage = Ship_info[shipp->ship_info_index].damage;
9161 int ship_get_exp_propagates(ship *sp)
9163 return Ship_info[sp->ship_info_index].explosion_propagates;
9166 float ship_get_exp_outer_rad(object *ship_objp)
9169 SDL_assert(ship_objp->type == OBJ_SHIP);
9171 if (Ships[ship_objp->instance].special_exp_index == -1) {
9172 outer_rad = Ship_info[Ships[ship_objp->instance].ship_info_index].outer_rad;
9174 outer_rad = (float) atoi(Sexp_variables[Ships[ship_objp->instance].special_exp_index+OUTER_RAD].text);
9180 int valid_cap_subsys_cargo_list(char *subsys)
9182 if (strstr(subsys, "nav")
9183 || strstr(subsys, "comm")
9184 || strstr(subsys, "engines")
9185 || strstr(subsys, "fighter") // fighter bays
9186 || strstr(subsys, "sensors")
9187 || strstr(subsys, "weapons")) {
9195 // determine turret status of a given subsystem, returns 0 for no turret, 1 for "fixed turret", 2 for "rotating" turret
9196 int ship_get_turret_type(ship_subsys *subsys)
9198 // not a turret at all
9199 if(subsys->system_info->type != SUBSYSTEM_TURRET){
9204 if(subsys->system_info->turret_turning_rate > 0.0f){
9212 ship_subsys *ship_get_subsys(ship *shipp, char *subsys_name)
9214 ship_subsys *lookup;
9217 if((shipp == NULL) || (subsys_name == NULL)){
9221 lookup = GET_FIRST(&shipp->subsys_list);
9222 while(lookup != END_OF_LIST(&shipp->subsys_list)){
9224 if(!strcmp(lookup->system_info->subobj_name, subsys_name)){
9229 lookup = GET_NEXT(lookup);
9236 // returns 0 if no conflict, 1 if conflict, -1 on some kind of error with wing struct
9237 int wing_has_conflicting_teams(int wing_index)
9239 int first_team, idx;
9242 SDL_assert((wing_index >= 0) && (wing_index < num_wings) && (Wings[wing_index].current_count > 0));
9243 if((wing_index < 0) || (wing_index >= num_wings) || (Wings[wing_index].current_count <= 0)){
9248 SDL_assert(Wings[wing_index].ship_index[0] >= 0);
9249 if(Wings[wing_index].ship_index[0] < 0){
9252 first_team = Ships[Wings[wing_index].ship_index[0]].team;
9253 for(idx=1; idx<Wings[wing_index].current_count; idx++){
9254 // more sanity checks
9255 SDL_assert(Wings[wing_index].ship_index[idx] >= 0);
9256 if(Wings[wing_index].ship_index[idx] < 0){
9260 // if we've got a team conflict
9261 if(first_team != Ships[Wings[wing_index].ship_index[idx]].team){
9270 // get the team of a reinforcement item
9271 int ship_get_reinforcement_team(int r_index)
9277 SDL_assert((r_index >= 0) && (r_index < Num_reinforcements));
9278 if((r_index < 0) || (r_index >= Num_reinforcements)){
9282 // if the reinforcement is a ship
9283 objp = mission_parse_get_arrival_ship( Reinforcements[r_index].name );
9288 // if the reinforcement is a ship
9289 wing_index = wing_lookup(Reinforcements[r_index].name);
9290 if(wing_index >= 0){
9291 // go through the ship arrival list and find the first ship in this wing
9292 objp = GET_FIRST(&ship_arrival_list);
9293 while( objp != END_OF_LIST(&ship_arrival_list) ) {
9295 if (objp->wingnum == wing_index) {
9300 objp = GET_NEXT(objp);
9308 // determine if the given texture is used by a ship type. return ship info index, or -1 if not used by a ship
9309 int ship_get_texture(int bitmap)
9313 // check all ship types
9314 for(idx=0; idx<Num_ship_types; idx++){
9315 if((Ship_info[idx].modelnum >= 0) && model_find_texture(Ship_info[idx].modelnum, bitmap) == 1){
9320 // couldn't find the texture
9324 extern void ssm_create(vector *target, vector *start, int ssm_index, ssm_firing_info *override);
9326 // update artillery lock info
9327 #define CLEAR_ARTILLERY_AND_CONTINUE() { if(aip != NULL){ aip->artillery_objnum = -1; aip->artillery_sig = -1; aip->artillery_lock_time = 0.0f;} continue; }
9328 float artillery_dist = 10.0f;
9331 dc_get_arg(ARG_FLOAT);
9332 artillery_dist = Dc_arg_float;
9334 void ship_update_artillery_lock()
9336 #if defined(MULTIPLAYER_BETA_BUILD) || defined(FS2_DEMO) || defined(FS1_DEMO)
9339 ai_info *aip = NULL;
9340 mc_info *cinfo = NULL;
9342 vector temp, local_hit;
9347 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ){
9349 if((so->objnum >= 0) && (Objects[so->objnum].type == OBJ_SHIP) && (Objects[so->objnum].instance >= 0)){
9350 shipp = &Ships[Objects[so->objnum].instance];
9356 if(shipp->ai_index >= 0){
9357 aip = &Ai_info[shipp->ai_index];
9362 // if the ship has no targeting laser firing
9363 if((shipp->targeting_laser_objnum < 0) || (shipp->targeting_laser_bank < 0)){
9364 CLEAR_ARTILLERY_AND_CONTINUE();
9367 // if he didn't hit any objects this frame
9368 if(beam_get_num_collisions(shipp->targeting_laser_objnum) <= 0){
9369 CLEAR_ARTILLERY_AND_CONTINUE();
9372 // get weapon info for the targeting laser he's firing
9373 SDL_assert((shipp->weapons.current_primary_bank >= 0) && (shipp->weapons.current_primary_bank < 2));
9374 if((shipp->weapons.current_primary_bank < 0) || (shipp->weapons.current_primary_bank >= 2)){
9377 SDL_assert(shipp->weapons.primary_bank_weapons[shipp->weapons.current_primary_bank] >= 0);
9378 if(shipp->weapons.primary_bank_weapons[shipp->weapons.current_primary_bank] < 0){
9381 SDL_assert((Weapon_info[shipp->weapons.primary_bank_weapons[shipp->weapons.current_primary_bank]].wi_flags & WIF_BEAM) && (Weapon_info[shipp->weapons.primary_bank_weapons[shipp->weapons.current_primary_bank]].b_info.beam_type == BEAM_TYPE_C));
9382 if(!(Weapon_info[shipp->weapons.primary_bank_weapons[shipp->weapons.current_primary_bank]].wi_flags & WIF_BEAM) || (Weapon_info[shipp->weapons.primary_bank_weapons[shipp->weapons.current_primary_bank]].b_info.beam_type != BEAM_TYPE_C)){
9386 // get collision info
9387 if(!beam_get_collision(shipp->targeting_laser_objnum, 0, &c_objnum, &cinfo)){
9388 CLEAR_ARTILLERY_AND_CONTINUE();
9390 if((c_objnum < 0) || (cinfo == NULL)){
9391 CLEAR_ARTILLERY_AND_CONTINUE();
9394 // get the position we hit this guy with in his local coords
9395 vm_vec_sub(&temp, &cinfo->hit_point_world, &Objects[c_objnum].pos);
9396 vm_vec_rotate(&local_hit, &temp, &Objects[c_objnum].orient);
9398 // if we are hitting a different guy now, reset the lock
9399 if((c_objnum != aip->artillery_objnum) || (Objects[c_objnum].signature != aip->artillery_sig)){
9400 aip->artillery_objnum = c_objnum;
9401 aip->artillery_sig = Objects[c_objnum].signature;
9402 aip->artillery_lock_time = 0.0f;
9403 aip->artillery_lock_pos = local_hit;
9409 // otherwise we're hitting the same guy. check to see if we've strayed too far
9410 if(vm_vec_dist_quick(&local_hit, &aip->artillery_lock_pos) > artillery_dist){
9411 // hmmm. reset lock time, but don't reset the lock itself
9412 aip->artillery_lock_time = 0.0f;
9416 // finally - just increment the lock time
9417 aip->artillery_lock_time += flFrametime;
9420 if(aip->artillery_lock_time >= 2.0f){
9422 HUD_printf("Firing artillery");
9424 vm_vec_unrotate(&temp, &aip->artillery_lock_pos, &Objects[aip->artillery_objnum].orient);
9425 vm_vec_add2(&temp, &Objects[aip->artillery_objnum].pos);
9426 ssm_create(&temp, &Objects[so->objnum].pos, 0, NULL);
9428 // reset the artillery
9429 aip->artillery_lock_time = 0.0f;
9435 // checks if a world point is inside the extended bounding box of a ship
9436 // may not work if delta box is large and negative (ie, adjusted box crosses over on itself - min > max)
9437 int check_world_pt_in_expanded_ship_bbox(vector *world_pt, object *objp, float delta_box)
9439 SDL_assert(objp->type == OBJ_SHIP);
9441 vector temp, ship_pt;
9443 vm_vec_sub(&temp, world_pt, &objp->pos);
9444 vm_vec_rotate(&ship_pt, &temp, &objp->orient);
9446 pm = model_get(Ships[objp->instance].modelnum);
9449 (ship_pt.xyz.x > pm->mins.xyz.x - delta_box) && (ship_pt.xyz.x < pm->maxs.xyz.x + delta_box)
9450 && (ship_pt.xyz.y > pm->mins.xyz.y - delta_box) && (ship_pt.xyz.y < pm->maxs.xyz.y + delta_box)
9451 && (ship_pt.xyz.z > pm->mins.xyz.z - delta_box) && (ship_pt.xyz.z < pm->maxs.xyz.z + delta_box)
9456 // returns true when objp is ship and is tagged
9457 int ship_is_tagged(object *objp)
9460 if (objp->type == OBJ_SHIP) {
9461 shipp = &Ships[objp->instance];
9462 if ( (shipp->tag_left > 0) || (shipp->level2_tag_left > 0) ) {
9470 // get maximum ship speed (when not warping in or out)
9471 float ship_get_max_speed(ship *shipp)
9475 int ship_info_index = shipp->ship_info_index;
9478 max_speed = Ship_info[ship_info_index].max_overclocked_speed;
9481 max_speed = SDL_max(max_speed, Ship_info[ship_info_index].max_vel.xyz.z);
9484 max_speed = SDL_max(max_speed, Ship_info[ship_info_index].afterburner_max_vel.xyz.z);
9489 // determin warp speed of ship
9490 float ship_get_warp_speed(object *objp)
9492 SDL_assert(objp->type == OBJ_SHIP);
9493 float shipfx_calculate_warp_speed(object *);
9494 return shipfx_calculate_warp_speed(objp);
9497 // returns true if ship is beginning to speed up in warpout
9498 int ship_is_beginning_warpout_speedup(object *objp)
9500 SDL_assert(objp->type == OBJ_SHIP);
9504 aip = &Ai_info[Ships[objp->instance].ai_index];
9506 if (aip->mode == AIM_WARP_OUT) {
9507 if ( (aip->submode == AIS_WARP_3) || (aip->submode == AIS_WARP_4) || (aip->submode == AIS_WARP_5) ) {
9515 // given a ship info type, return a species
9516 int ship_get_species_by_type(int ship_info_index)
9519 if((ship_info_index < 0) || (ship_info_index >= Num_ship_types)){
9524 return Ship_info[ship_info_index].species;
9527 // return the length of a ship
9528 float ship_get_length(ship* shipp)
9530 polymodel *pm = model_get(shipp->modelnum);
9531 return (pm->maxs.xyz.z - pm->mins.xyz.z);