src/hud/hud.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Hud/HUD.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * C module that contains all the HUD functions at a high level
  16  *
  17  * $Log$
  18  * Revision 1.9  2005/10/01 22:04:58  taylor
  19  * fix FS1 (de)briefing voices, the directory names are different in FS1
  20  * hard code the table values so that the fs1.vp file isn't needed
  21  * hard code a mission fix for sm2-08a since a have no idea how to fix it otherwise
  22  * generally cleanup some FS1 code
  23  * fix volume sliders in the options screen that never went all the way up
  24  *
  25  * Revision 1.8  2004/09/20 01:31:44  theoddone33
  26  * GCC 3.4 fixes.
  27  *
  28  * Revision 1.7  2003/08/03 16:10:29  taylor
  29  * cleanup; compile warning fixes
  30  *
  31  * Revision 1.6  2003/06/03 04:00:40  taylor
  32  * Polish language support (Janusz Dziemidowicz)
  33  *
  34  * Revision 1.5  2003/05/25 02:30:42  taylor
  35  * Freespace 1 support
  36  *
  37  * Revision 1.4  2003/05/18 03:55:30  taylor
  38  * automatic language selection support
  39  *
  40  * Revision 1.3  2002/06/17 06:33:09  relnev
  41  * ryan's struct patch for gcc 2.95
  42  *
  43  * Revision 1.2  2002/06/09 04:41:21  relnev
  44  * added copyright header
  45  *
  46  * Revision 1.1.1.1  2002/05/03 03:28:09  root
  47  * Initial import.
  48  *
  49  *
  50  * 58    10/28/99 2:04a Jefff
  51  * some german specific coords.
  52  *
  53  * 57    10/25/99 5:43p Jefff
  54  * added (and subsequently commented) some scoring debug code.  checked in
  55  * to work on later
  56  *
  57  * 56    9/09/99 3:55a Andsager
  58  * Reset Hud_support_objnum to -1 when guage stops displaying
  59  *
  60  * 55    9/01/99 11:16a Andsager
  61  * Fix bug where support ship guage would not show up if second support
  62  * ship called in whlile 1st one dying.
  63  *
  64  * 54    8/23/99 1:49p Dave
  65  * Fixed damage popup (hopefully)
  66  *
  67  * 53    8/23/99 11:34a Dave
  68  * Fixed shield intensity rendering problems.
  69  *
  70  * 52    8/19/99 6:16p Jefff
  71  *
  72  * 51    8/17/99 7:15p Jefff
  73  * auto-target & auto-speed text drawn in code
  74  *
  75  * 50    8/16/99 4:04p Dave
  76  * Big honking checkin.
  77  *
  78  * 49    8/09/99 3:47p Dave
  79  * Fixed incorrect nebula regeneration. Default HUD to low-contrast in
  80  * non-nebula missions.
  81  *
  82  * 48    8/09/99 3:14p Dave
  83  * Make "launch" warning gauge draw in code.
  84  *
  85  * 47    8/05/99 2:05a Dave
  86  * Fixes. Optimized detail level stuff.
  87  *
  88  * 46    8/04/99 2:56p Jefff
  89  * fixed black box behind pilot head in hi-res
  90  *
  91  * 45    8/04/99 9:54a Andsager
  92  * Auto target turrets on big ships.
  93  *
  94  * 44    8/01/99 12:39p Dave
  95  * Added HUD contrast control key (for nebula).
  96  *
  97  * 43    7/31/99 4:15p Dave
  98  * Fixed supernova particle velocities. Handle OBJ_NONE in target
  99  * monitoring view. Properly use objectives notify gauge colors.
 100  *
 101  * 42    7/31/99 1:16p Dave
 102  * Use larger font for 1024 HUD flash text box. Make beam weapons aware of
 103  * weapon subsystem damage on firing ship.
 104  *
 105  * 41    7/26/99 10:41a Jefff
 106  * added call to hud_maybe_show_damage() in hud_render_2d().  not sure how
 107  * this got out in the 1st place.
 108  *
 109  * 40    7/24/99 1:54p Dave
 110  * Hud text flash gauge. Reworked dead popup to use 4 buttons in red-alert
 111  * missions.
 112  *
 113  * 39    7/22/99 4:00p Dave
 114  * Fixed beam weapon muzzle glow rendering. Externalized hud shield info.
 115  *
 116  * 38    7/21/99 8:10p Dave
 117  * First run of supernova effect.
 118  *
 119  * 37    7/21/99 3:19p Jefff
 120  * adjusted subspace and red alert popup text coords
 121  *
 122  * 36    7/19/99 2:13p Dave
 123  * Added some new strings for Heiko.
 124  *
 125  * 35    7/19/99 11:48a Jefff
 126  * Countermeasure success sound added
 127  *
 128  * 34    7/16/99 12:22p Jefff
 129  * Added sound FX to objective popups
 130  *
 131  * 33    7/15/99 7:16p Jefff
 132  * Red Alert box is now red
 133  *
 134  * 32    7/09/99 12:00a Andsager
 135  * Added target box with distance for remote detonate weapons
 136  *
 137  * 31    6/28/99 4:33p Jasenw
 138  * Fixed coords for hi res engine wash gauge
 139  *
 140  * 30    6/11/99 11:13a Dave
 141  * last minute changes before press tour build.
 142  *
 143  * 29    6/10/99 3:43p Dave
 144  * Do a better job of syncing text colors to HUD gauges.
 145  *
 146  * 28    6/08/99 1:14a Dave
 147  * Multi colored hud test.
 148  *
 149  * 27    6/07/99 4:20p Andsager
 150  * Add HUD color for tagged object.  Apply to target and radar.
 151  *
 152  * 26    5/28/99 5:36p Andsager
 153  * stupid comment
 154  *
 155  * 25    5/28/99 10:00a Andsager
 156  * Make player hud target affected by Nebula range
 157  *
 158  * 24    5/22/99 5:35p Dave
 159  * Debrief and chatbox screens. Fixed small hi-res HUD bug.
 160  *
 161  * 23    5/21/99 5:36p Andsager
 162  * Put in high res engine wash gauge and approx coords
 163  *
 164  * 22    5/21/99 1:44p Andsager
 165  * Add engine wash gauge
 166  *
 167  * 21    4/20/99 6:39p Dave
 168  * Almost done with artillery targeting. Added support for downloading
 169  * images on the PXO screen.
 170  *
 171  * 20    2/25/99 4:19p Dave
 172  * Added multiplayer_beta defines. Added cd_check define. Fixed a few
 173  * release build warnings. Added more data to the squad war request and
 174  * response packets.
 175  *
 176  * 19    2/24/99 4:02p Dave
 177  * Fixed weapon locking and homing problems for multiplayer dogfight mode.
 178  *
 179  * 18    2/17/99 2:10p Dave
 180  * First full run of squad war. All freespace and tracker side stuff
 181  * works.
 182  *
 183  * 17    2/03/99 8:37a Jasen
 184  * Fixed dock in coords
 185  *
 186  * 16    2/01/99 9:24a Jasen
 187  * Fixed subspace and objectives displays for hi res.
 188  *
 189  * 15    1/25/99 5:03a Dave
 190  * First run of stealth, AWACS and TAG missile support. New mission type
 191  * :)
 192  *
 193  * 14    1/21/99 9:28p Dave
 194  * Fixed damage gauge coords.
 195  *
 196  * 13    1/07/99 9:05a Jasen
 197  * coords, coords, coords
 198  *
 199  * 12    1/06/99 3:24p Dave
 200  * Fixed stupid code.
 201  *
 202  * 11    1/06/99 3:14p Jasen
 203  * more new coords
 204  *
 205  * 10    1/06/99 2:33p Jasen
 206  * updated coords
 207  *
 208  * 9     1/06/99 1:27p Dave
 209  * Removed duplicate global var.
 210  *
 211  * 8     1/06/99 1:26p Dave
 212  * Put in seperate X coords for "dock in" and the associated time value
 213  * for the support ship gauge.
 214  *
 215  * 7     12/28/98 3:17p Dave
 216  * Support for multiple hud bitmap filenames for hi-res mode.
 217  *
 218  * 6     12/21/98 5:02p Dave
 219  * Modified all hud elements to be multi-resolution friendly.
 220  *
 221  * 5     12/18/98 1:13a Dave
 222  * Rough 1024x768 support for Direct3D. Proper detection and usage through
 223  * the launcher.
 224  *
 225  * 4     11/05/98 4:18p Dave
 226  * First run nebula support. Beefed up localization a bit. Removed all
 227  * conditional compiles for foreign versions. Modified mission file
 228  * format.
 229  *
 230  * 3     10/13/98 9:28a Dave
 231  * Started neatening up freespace.h. Many variables renamed and
 232  * reorganized. Added AlphaColors.[h,cpp]
 233  *
 234  * 2     10/07/98 10:53a Dave
 235  * Initial checkin.
 236  *
 237  * 1     10/07/98 10:49a Dave
 238  *
 239  * 223   8/28/98 3:28p Dave
 240  * EMP effect done. AI effects may need some tweaking as required.
 241  *
 242  * 222   8/25/98 1:48p Dave
 243  * First rev of EMP effect. Player side stuff basically done. Next comes
 244  * AI code.
 245  *
 246  * 221   8/09/98 4:45p Lawrance
 247  * center various HUD text - fixes problems in the German version
 248  *
 249  * 220   6/18/98 10:10a Allender
 250  * fixed compiler warnings
 251  *
 252  * 219   6/17/98 11:03a Lawrance
 253  * position subspace notify correctly for german version
 254  *
 255  * 218   6/13/98 10:48p Lawrance
 256  * Changed code to utilize proper fixed-space 1 character.
 257  *
 258  * 217   6/13/98 6:01p Hoffoss
 259  * Externalized all new (or forgot to be added) strings to all the code.
 260  *
 261  * 216   6/12/98 2:49p Dave
 262  * Patch 1.02 changes.
 263  *
 264  * 215   6/09/98 10:31a Hoffoss
 265  * Created index numbers for all xstr() references.  Any new xstr() stuff
 266  * added from here on out should be added to the end if the list.  The
 267  * current list count can be found in FreeSpace.cpp (search for
 268  * XSTR_SIZE).
 269  *
 270  * 214   6/01/98 11:43a John
 271  * JAS & MK:  Classified all strings for localization.
 272  *
 273  * 213   5/23/98 4:14p John
 274  * Added code to preload textures to video card for AGP.   Added in code
 275  * to page in some bitmaps that weren't getting paged in at level start.
 276  *
 277  * 212   5/17/98 3:32p Lawrance
 278  * Allow red alert orders to get downloaded when in an out-of-cockpit view
 279  *
 280  * 211   5/15/98 8:36p Lawrance
 281  * Add 'target ship that last sent transmission' target key
 282  *
 283  * 210   5/10/98 5:28p Lawrance
 284  * Ensure hud messages and talking heads show up when viewing from another
 285  * ship
 286  *
 287  * 209   5/10/98 12:11a Lawrance
 288  * Fix a couple of problems with 2D gauges showing up in external views
 289  *
 290  * 208   5/09/98 4:52p Lawrance
 291  * Implement padlock view (up/rear/left/right)
 292  *
 293  * 207   5/09/98 12:20a Lawrance
 294  * Show hud messages in all views
 295  *
 296  * 206   5/08/98 5:32p Lawrance
 297  * Allow cargo scanning even if target gauge is disabled
 298  *
 299  * 205   5/08/98 10:13a Lawrance
 300  * Don't allow targeting of ships that have SF_EXPLODED flag set
 301  *
 302  * 204   5/07/98 1:01a Chad
 303  * Yet another hud gauage which shouldn't be rendered as a multiplayer
 304  * observer.
 305  *
 306  * 203   5/04/98 12:08p Ed
 307  * from allender:  move hud_target_change_check() after code which does
 308  * possible auto target change.  Fixed multiplayer problem where locking
 309  * subsys does not match ship currently targeted
 310  *
 311  * 202   5/04/98 6:12p Lawrance
 312  * Write generic function hud_end_string_at_first_hash_symbol(), to use in
 313  * various spots on the HUD
 314  *
 315  * 201   4/30/98 3:32p Lawrance
 316  * Cull dead/departed ships from escort ship in hud_update_frame()
 317  *
 318  * 200   4/23/98 10:24p Mike
 319  * Int3(), then recover gracefully from some error in which ship to be
 320  * repaired is killed.
 321  *
 322  * $NoKeywords: $
 323  *
 324 */
 325
 326 #include "pstypes.h"
 327 #include "freespace.h"
 328 #include "systemvars.h"
 329 #include "hud.h"
 330 #include "hudtarget.h"
 331 #include "hudreticle.h"
 332 #include "hudmessage.h"
 333 #include "sound.h"
 334 #include "player.h"
 335 #include "multi.h"
 336 #include "multiutil.h"
 337 #include "gamesnd.h"
 338 #include "hudsquadmsg.h"
 339 #include "timer.h"
 340 #include "eventmusic.h"
 341 #include "hudlock.h"
 342 #include "hudets.h"
 343 #include "2d.h"
 344 #include "3d.h"
 345 #include "ai.h"
 346 #include "aigoals.h"
 347 #include "hudescort.h"
 348 #include "hudshield.h"
 349 #include "linklist.h"
 350 #include "hudtargetbox.h"
 351 #include "missionmessage.h"
 352 #include "missiontraining.h"
 353 #include "bmpman.h"
 354 #include "radar.h"
 355 #include "hudobserver.h"
 356 #include "hudtargetbox.h"
 357 #include "hudconfig.h"
 358 #include "missiongoals.h"
 359 #include "asteroid.h"
 360 #include "starfield.h"
 361 #include "hudwingmanstatus.h"
 362 #include "multi_voice.h"
 363 #include "multi_pmsg.h"
 364 #include "redalert.h"
 365 #include "emp.h"
 366 #include "alphacolors.h"
 367 #include "localize.h"
 368 #include "supernova.h"
 369 #include "font.h"
 370
 371 // new values for HUD alpha
 372 #define HUD_NEW_ALPHA_DIM                               80
 373 #define HUD_NEW_ALPHA_NORMAL                    120
 374 #define HUD_NEW_ALPHA_BRIGHT                    220
 375
 376 // high contrast
 377 #define HUD_NEW_ALPHA_DIM_HI                    130
 378 #define HUD_NEW_ALPHA_NORMAL_HI         190
 379 #define HUD_NEW_ALPHA_BRIGHT_HI         255
 380
 381 // globals that will control the color of the HUD gauges
 382 int HUD_color_red = 0;
 383 int HUD_color_green = 255;
 384 int HUD_color_blue = 0;
 385 int HUD_color_alpha = HUD_COLOR_ALPHA_DEFAULT;          // 1 -> HUD_COLOR_ALPHA_USER_MAX
 386
 387 int HUD_contrast = 0;                                                                           // high or lo contrast (for nebula, etc)
 388
 389 color HUD_color_defaults[HUD_NUM_COLOR_LEVELS];         // array of colors with different alpha blending
 390 color HUD_color_debug;                                                                          // grey debug text shown on HUD
 391
 392 static int Player_engine_snd_loop = -1;
 393
 394 // animations for damages gauges
 395 hud_anim Target_static;
 396 hud_anim        Radar_static;
 397
 398 // HUD render frame offsets
 399 float HUD_offset_x = 0.0f;
 400 float HUD_offset_y = 0.0f;
 401
 402 // Global: integrity of player's target
 403 float Pl_target_integrity;
 404
 405 static int Hud_last_can_target; // whether Player is able to target in the last frame
 406 static int Hud_can_target_timer;        // timestamp to allow target gauge to draw static once targeting functions are not allowed
 407
 408 // centered text message gauges (collision, emp, etc)
 409 char Hud_text_flash[512] = "";
 410 int Hud_text_flash_coords[GR_NUM_RESOLUTIONS][2] = {
 411         { // GR_640
 412                 -1, 172
 413         },
 414         { // GR_1024
 415                 -1, 275
 416         }
 417 };
 418 void hud_init_text_flash_gauge();
 419 void hud_start_text_flash(const char *txt, int t);
 420 void hud_maybe_show_text_flash_icon();
 421
 422
 423 // multiplayer messaging text
 424 int Multi_msg_coords[GR_NUM_RESOLUTIONS][2] = {
 425         { // GR_640
 426                 5, 150
 427         },
 428         { // GR_1024
 429                 8, 240
 430         }
 431 };
 432
 433 // multiplayer voice stuff
 434 int Voice_coords[GR_NUM_RESOLUTIONS][2] = {
 435         { // GR_640
 436                 5, 165
 437         },
 438         { // GR_1024
 439                 8, 255
 440         }
 441 };
 442
 443 // redalert downloading new orders text
 444 int Red_text_coords[GR_NUM_RESOLUTIONS][2] = {
 445         { // GR_640
 446                 -1, 116
 447         },
 448         { // GR_1024
 449                 -1, 186
 450         }
 451 };
 452 int Red_text_val_coords[GR_NUM_RESOLUTIONS][2] = {
 453         { // GR_640
 454                 -1, 124
 455         },
 456         { // GR_1024
 457                 -1, 194
 458         }
 459 };
 460
 461 // subspace popup
 462 int Subspace_text_coords[GR_NUM_RESOLUTIONS][2] = {
 463         { // GR_640
 464                 -1, 116
 465         },
 466         { // GR_1024
 467                 -1, 186
 468         }
 469 };
 470 int Subspace_text_val_coords[GR_NUM_RESOLUTIONS][2] = {
 471         { // GR_640
 472                 100, 124
 473         },
 474         { // GR_1024
 475                 140, 194
 476         }
 477 };
 478
 479 // message text coords
 480 int Head_message_coords[GR_NUM_RESOLUTIONS][2] = {
 481         { // GR_640
 482                 7, 37
 483         },
 484         { // GR_1024
 485                 11, 57
 486         }
 487 };
 488
 489 // ping text coords
 490 int Ping_coords[GR_NUM_RESOLUTIONS][2] = {
 491         { // GR_640
 492                 560, 3
 493         },
 494         { // GR_1024
 495                 896, 5
 496         }
 497 };
 498
 499 // supernova coords
 500 int Supernova_coords[GR_NUM_RESOLUTIONS][2] = {
 501         { // GR_640
 502                 100, 100
 503         },
 504         { // GR_1024
 505                 170, 170
 506         }
 507 };
 508
 509 // used to draw the netlag icon on the HUD
 510 hud_frames Netlag_icon;
 511 int Netlag_icon_loaded=0;
 512 int Netlag_coords[GR_NUM_RESOLUTIONS][2] = {
 513         { // GR_640
 514                 386, 331
 515         },
 516         { // GR_1024
 517                 627, 529
 518         }
 519 };
 520 const char *Netlag_fname[GR_NUM_RESOLUTIONS] = {
 521         "netlag1",
 522         "netlag1"
 523 };
 524
 525 // used to draw the kills gauge
 526 hud_frames Kills_gauge;
 527 int Kills_gauge_loaded = 0;
 528 int Kills_gauge_coords[GR_NUM_RESOLUTIONS][2] = {
 529         { // GR_640
 530                 497, 361
 531         },
 532         { // GR_1024
 533                 880, 624
 534         }
 535 };
 536 int Kills_text_coords[GR_NUM_RESOLUTIONS][2] = {
 537         { // GR_640
 538                 503, 365
 539         },
 540         { // GR_1024
 541                 886, 628
 542         }
 543 };
 544
 545 // for German version
 546 int Kills_text_val_coords_gr[GR_NUM_RESOLUTIONS][2] = {
 547         { // GR_640
 548                 615, 365
 549         },
 550         { // GR_1024
 551                 984, 628
 552         }
 553 };
 554
 555 int Kills_text_val_coords[GR_NUM_RESOLUTIONS][2] = {
 556         { // GR_640
 557                 571, 365
 558         },
 559         { // GR_1024
 560                 954, 628
 561         }
 562 };
 563
 564 const char *Kills_fname[GR_NUM_RESOLUTIONS] = {
 565         "kills1",
 566         "kills1"
 567 };
 568
 569 // used to draw border around a talking head
 570 static hud_frames Head_frame_gauge;
 571 static int Head_frame_gauge_loaded = 0;
 572 int Head_frame_coords[GR_NUM_RESOLUTIONS][2] = {
 573         { // GR_640
 574                 5, 35
 575         },
 576         { // GR_1024
 577                 5, 56
 578         }
 579 };
 580 const char *Head_fname[GR_NUM_RESOLUTIONS] = {
 581         "head1",
 582         "head1"
 583 };
 584
 585 // mission time frame
 586 static hud_frames Mission_time_gauge;
 587 static int Mission_time_gauge_loaded = 0;
 588 int Mission_time_coords[GR_NUM_RESOLUTIONS][2] = {
 589         { // GR_640
 590                 587, 448
 591         },
 592         { // GR_1024
 593                 969, 716
 594         }
 595 };
 596 int Mission_time_text_coords[GR_NUM_RESOLUTIONS][2] = {
 597         { // GR_640
 598                 591, 452
 599         },
 600         { // GR_1024
 601                 973, 720
 602         }
 603 };
 604 int Mission_time_text_val_coords[GR_NUM_RESOLUTIONS][2] = {
 605         { // GR_640
 606                 613, 460
 607         },
 608         { // GR_640
 609                 995, 728
 610         }
 611 };
 612 const char *Mission_time_fname[GR_NUM_RESOLUTIONS] = {
 613         "time1",
 614         "time1"
 615 };
 616
 617 // used to draw the hud support view
 618 static hud_frames Support_view_gauge;
 619 static int Support_view_gauge_loaded = 0;
 620 static int Hud_support_view_active;
 621 static int Hud_support_view_abort;              // active when we need to display abort message
 622 static int Hud_support_view_fade;               // timer
 623 static int Hud_support_obj_sig, Hud_support_objnum, Hud_support_target_sig;
 624 int Support_view_coords[GR_NUM_RESOLUTIONS][2] = {
 625         { // GR_640
 626                 265, 334
 627         },
 628         { // GR_1024
 629                 459, 534
 630         }
 631 };
 632 int Support_text_coords[GR_NUM_RESOLUTIONS][2] = {
 633         { // GR_640
 634                 267, 335
 635         },
 636         { // GR_1024
 637                 462, 536
 638         }
 639 };
 640 int Support_text_val_coords[GR_NUM_RESOLUTIONS][2] = {
 641         { // GR_640
 642                 -1, 348
 643         },
 644         { // GR_1024
 645                 -1, 546
 646         }
 647 };
 648 int Support_text_dock_coords[GR_NUM_RESOLUTIONS][2] = {                 // "dock in" x coord
 649         { // GR_640
 650                 270, -1
 651         },
 652         { // GR_1024
 653                 465, -1
 654         }
 655 };
 656 int Support_text_dock_val_coords[GR_NUM_RESOLUTIONS][2] = {             // time value for "dock in" x coord
 657         { // GR_640
 658                 328, -1
 659         },
 660         { // GR_1024
 661                 524, -1
 662         }
 663 };
 664 const char *Support_fname[GR_NUM_RESOLUTIONS] = {
 665         "support1",
 666         "support1"
 667 };
 668
 669 // damage gauge stuff
 670 #define NUM_DAMAGE_GAUGES       3
 671 static hud_frames Damage_gauges[NUM_DAMAGE_GAUGES];
 672 static int Damage_gauges_loaded = 0;
 673 const char *Damage_gauge_fnames[GR_NUM_RESOLUTIONS][NUM_DAMAGE_GAUGES] =
 674 {
 675         //XSTR:OFF
 676         { // GR_640
 677                 "damage1",
 678                 "damage2",
 679                 "damage3",
 680         },
 681         { // GR_1024
 682                 "damage1",
 683                 "damage2",
 684                 "damage3",
 685         }
 686 //XSTR:ON
 687 };
 688 int Damage_gauge_line_h[GR_NUM_RESOLUTIONS] = {
 689         9,
 690         9
 691 };
 692 int Damage_gauge_coords[GR_NUM_RESOLUTIONS][2][2] = {
 693         { // GR_640
 694                 {245, 38},
 695                 {245, 63}
 696         },
 697         { // GR_1024
 698                 {440, 61},
 699                 {440, 86}
 700         }
 701         // These #'s seem to work, although I really don't know why. Frankly, it frightens me,
 702         // because it means the 640 coords _shouldn't_. This may be due to D3D strangeness, so
 703         // we'll have to investigate when we get hi-res Glide in.
 704 };
 705 int Damage_text_coords[GR_NUM_RESOLUTIONS][2] = {
 706         { // GR_640
 707                 248, 40
 708         },
 709         { // GR_1024
 710                 443, 63
 711         }
 712 };
 713 int Hull_integ_coords[GR_NUM_RESOLUTIONS][2] = {
 714         { // GR_640
 715                 249, 53
 716         },
 717         { // GR_1024
 718                 444, 76
 719         }
 720 };
 721 int Hull_integ_val_coords[GR_NUM_RESOLUTIONS][2] = {
 722         { // GR_640
 723                 387, 53
 724         },
 725         { // GR_1024
 726                 582, 76
 727         },
 728 };
 729 int Damage_subsys_text_coords[GR_NUM_RESOLUTIONS][2] = {
 730         { // GR_640
 731                 249, 65
 732         },
 733         { // GR_1024
 734                 444, 88
 735         }
 736 };
 737
 738
 739 // flashing gauges
 740 #define HUD_GAUGE_FLASH_DURATION                5000
 741 #define HUD_GAUGE_FLASH_INTERVAL                200
 742 int HUD_gauge_flash_duration[NUM_HUD_GAUGES];
 743 int HUD_gauge_flash_next[NUM_HUD_GAUGES];
 744 int HUD_gauge_bright;
 745
 746 // Objective display
 747 typedef struct objective_display_info
 748 {
 749         int display_timer;
 750         int goal_type;
 751         int goal_status;
 752         int goal_ntotal;
 753         int goal_nresolved;
 754
 755 } objective_display_info;
 756
 757 static objective_display_info Objective_display;
 758
 759 static int                      Objective_display_gauge_inited=0;
 760 static hud_frames       Objective_display_gauge;
 761 int Objective_display_coords[GR_NUM_RESOLUTIONS][2] = {
 762         { // GR_640
 763                 245, 114
 764         },
 765         { // GR_1024
 766                 436, 184
 767         }
 768 };
 769 int Objective_text_coords[GR_NUM_RESOLUTIONS][2] = {
 770         { // GR_640
 771                 -1, 116
 772         },
 773         { // GR_1024
 774                 -1, 186
 775         }
 776 };
 777 int Objective_text_val_coords[GR_NUM_RESOLUTIONS][2] = {
 778         { // GR_640
 779                 -1, 125
 780         },
 781         { // GR_1024
 782                 -1, 195
 783         }
 784 };
 785 char Objective_fname[GR_NUM_RESOLUTIONS][MAX_FILENAME_LEN] = {
 786         "objective1",
 787         "objective1"
 788 };
 789
 790 // Subspace notify display
 791 static int Subspace_notify_active;
 792 static int Objective_notify_active;
 793 static int HUD_abort_subspace_timer = 1;
 794
 795 // used to track how player subsystems are getting damaged
 796 typedef struct hud_subsys_info
 797 {
 798         float   last_str;
 799         int     flash_duration_timestamp;
 800 } hud_subsys_info;
 801
 802 static hud_subsys_info  Pl_hud_subsys_info[SUBSYSTEM_MAX];
 803 static int                                      Pl_hud_next_flash_timestamp;
 804 static int                                      Pl_hud_is_bright;
 805
 806 #define SUBSYS_DAMAGE_FLASH_DURATION    1800
 807 #define SUBSYS_DAMAGE_FLASH_INTERVAL    100
 808
 809 // timers used for popup gauges
 810 int HUD_popup_timers[NUM_HUD_GAUGES];
 811
 812 // forward declarations
 813 void update_throttle_sound();
 814 void hud_show_damage_popup();
 815 void hud_damage_popup_init();
 816 void hud_support_view_init();
 817 void hud_gauge_flash_init();
 818 void hud_objective_message_init();
 819 void hud_maybe_display_objective_message();
 820 void hud_stop_subspace_notify();
 821 void hud_start_subspace_notify();
 822 void hud_stop_objective_notify();
 823 void hud_start_objective_notify();
 824 int hud_subspace_notify_active();
 825 int hud_objective_notify_active();
 826 void hud_subspace_notify_abort();
 827 void hud_maybe_display_subspace_notify();
 828 void hud_init_netlag_icon();
 829 void hud_maybe_show_netlag_icon();
 830 void hud_maybe_display_red_alert();
 831 void hud_init_kills_gauge();
 832 void hud_show_kills_gauge();
 833 int hud_maybe_render_emp_icon();
 834 void hud_init_emp_icon();
 835
 836 //      Saturate a value in minv..maxv.
 837 void saturate(int *i, int minv, int maxv)
 838 {
 839         if (*i < minv)
 840                 *i = minv;
 841         else if (*i > maxv)
 842                 *i = maxv;
 843 }
 844
 845 // init the colors used for the different shades of the HUD
 846 void HUD_init_hud_color_array()
 847 {
 848         int i;
 849
 850         for ( i = 0; i < HUD_NUM_COLOR_LEVELS; i++ ) {
 851                 gr_init_alphacolor( &HUD_color_defaults[i], HUD_color_red, HUD_color_green, HUD_color_blue, (i+1)*16, AC_TYPE_HUD );
 852         }
 853 }
 854
 855 // HUD_init will call all the various HUD gauge init functions.  This function is called at the
 856 // start of each mission (level)
 857 void HUD_init_colors()
 858 {
 859         saturate(&HUD_color_red, 0, 255);
 860         saturate(&HUD_color_green, 0, 255);
 861         saturate(&HUD_color_blue, 0, 255);
 862         saturate(&HUD_color_alpha, 0, HUD_COLOR_ALPHA_USER_MAX);
 863
 864         gr_init_alphacolor( &HUD_color_debug, 128, 255, 128, HUD_color_alpha*16, AC_TYPE_HUD );
 865         HUD_init_hud_color_array();
 866
 867         hud_init_targeting_colors();
 868         hud_gauge_flash_init();
 869 }
 870
 871 // The following global data is used to determine if we should change the engine sound.
 872 // We only check if the throttle has changed every THROTTLE_SOUND_CHECK_INTERVAL ms, and
 873 // then we make sure that the throttle has actually changed.  If it has changed, we start
 874 // a new sound and/or adjust the volume.  This occurs in update_throttle_sound()
 875 //
 876 static float last_percent_throttle;
 877 #define THROTTLE_SOUND_CHECK_INTERVAL   50      // in ms
 878 static int throttle_sound_check_id;
 879
 880 // used for the display of damaged subsystems
 881 typedef struct hud_subsys_damage
 882 {
 883         int     str;
 884         int     type;
 885         char    *name;
 886 } hud_subsys_damage;
 887
 888 #define DAMAGE_FLASH_TIME 150
 889 static int Damage_flash_bright;
 890 static int Damage_flash_timer;
 891
 892 // initialize the timers used for popup gauges
 893 void hud_init_popup_timers()
 894 {
 895         int i;
 896         for (i=0; i<NUM_HUD_GAUGES; i++) {
 897                 HUD_popup_timers[i] = timestamp(0);
 898         }
 899 }
 900
 901 // Load in the bitmap for the talking head gauge if required
 902 void hud_init_talking_head_gauge()
 903 {
 904         // ensure the talking head border is loaded
 905         if ( !Head_frame_gauge_loaded ) {
 906                 Head_frame_gauge.first_frame = bm_load_animation(Head_fname[gr_screen.res], &Head_frame_gauge.num_frames);
 907                 if ( Head_frame_gauge.first_frame == -1 ) {
 908                         Warning(LOCATION, "Could not load in ani: Head_fname[gr_screen.res]\n");
 909                 }
 910                 Head_frame_gauge_loaded = 1;
 911         }
 912 }
 913
 914 // Load in the bitmap for the mission time gauge if required
 915 void hud_init_mission_time_gauge()
 916 {
 917         // ensure the talking head border is loaded
 918         if ( !Mission_time_gauge_loaded ) {
 919                 Mission_time_gauge.first_frame = bm_load_animation(Mission_time_fname[gr_screen.res], &Mission_time_gauge.num_frames);
 920                 if ( Mission_time_gauge.first_frame == -1 ) {
 921                         Warning(LOCATION, "Could not load in ani: Mission_time_fname[gr_screen.res]\n");
 922                 }
 923                 Mission_time_gauge_loaded = 1;
 924         }
 925 }
 926
 927 // ----------------------------------------------------------------------
 928 // HUD_init()
 929 //
 930 // Called each level to initalize HUD systems
 931 //
 932 void HUD_init()
 933 {
 934         HUD_init_colors();
 935         hud_init_msg_window();
 936         hud_init_targeting();
 937         hud_init_reticle();
 938         hud_shield_level_init();
 939         hud_init_ets();
 940         hud_targetbox_init();
 941         hud_escort_init();
 942         hud_damage_popup_init();
 943         hud_support_view_init();
 944         hud_init_squadmsg();            // initialize the vars needed for squadmate messaging
 945         hud_init_popup_timers();
 946         hud_objective_message_init();
 947         hud_init_wingman_status_gauge();
 948         hud_anim_init(&Target_static, Target_window_coords[gr_screen.res][0], Target_window_coords[gr_screen.res][1], NOX("TargetStatic"));
 949         hud_targetbox_static_init();
 950         hud_init_text_flash_gauge();
 951         hud_init_netlag_icon();
 952         hud_init_talking_head_gauge();
 953         hud_init_mission_time_gauge();
 954         hud_init_kills_gauge();
 955         hud_stop_subspace_notify();
 956         hud_stop_objective_notify();
 957         hud_target_last_transmit_level_init();
 958
 959         throttle_sound_check_id = timestamp(THROTTLE_SOUND_CHECK_INTERVAL);
 960         HUD_abort_subspace_timer = 1;
 961         Hud_last_can_target = 1;
 962         Hud_can_target_timer = 1;
 963         last_percent_throttle = 0.0f;
 964
 965         // default to high contrast in the nebula
 966         HUD_contrast = 0;
 967         if(The_mission.flags & MISSION_FLAG_FULLNEB){
 968                 HUD_contrast = 1;
 969         }
 970 }
 971
 972 // return !0 if HUD is disabled (ie no gauges are shown/usable), otherwise return 0
 973 int hud_disabled()
 974 {
 975         // if ( Ship_info[Player_ship->ship_info_index].species != SPECIES_TERRAN ) {
 976                 //return 1;
 977         //}
 978
 979         return 0;
 980 }
 981
 982 // Determine if we should popup the weapons gauge on the HUD.
 983 void hud_maybe_popup_weapons_gauge()
 984 {
 985         if ( hud_gauge_is_popup(HUD_WEAPONS_GAUGE) ) {
 986                 ship_weapon *swp = &Player_ship->weapons;
 987                 int                     i;
 988
 989                 for ( i = 0; i < swp->num_secondary_banks; i++ ) {
 990                         if ( swp->secondary_bank_ammo[i] > 0 ) {
 991                                 int ms_till_fire = timestamp_until(swp->next_secondary_fire_stamp[i]);
 992                                 if ( ms_till_fire >= 1000 ) {
 993                                         hud_gauge_popup_start(HUD_WEAPONS_GAUGE, 2500);
 994                                 }
 995                         }
 996                 }
 997         }
 998 }
 999
1000 // hud_update_frame() will update hud systems
1001 //
1002 // This function updates those parts of the hud that are not dependant on the
1003 // rendering of the hud.
1004 void hud_update_frame()
1005 {
1006         object  *targetp;
1007         int             can_target;
1008
1009         update_throttle_sound();
1010         hud_check_reticle_list();
1011         hud_wingman_status_update();
1012
1013         // Check hotkey selections to see if any ships need to be removed
1014         hud_prune_hotkeys();
1015
1016         // Remove dead/departed ships from the escort list
1017         hud_escort_cull_list();
1018
1019         hud_update_reticle( Player );
1020         hud_shield_hit_update();
1021         hud_maybe_popup_weapons_gauge();
1022
1023         // if emp is active we have to allow targeting by the "random emp" system
1024         // we will intercept player targeting requests in hud_sensors_ok() when checking key commands
1025         // DB - 8/24/98
1026         can_target = hud_sensors_ok(Player_ship, 0);
1027         if(emp_active_local()){
1028                 can_target = 1;
1029         }
1030         if ( !can_target && Hud_last_can_target ) {
1031                 Hud_can_target_timer = timestamp(1200);
1032         }
1033         Hud_last_can_target = can_target;
1034
1035         if ( timestamp_elapsed(Hud_can_target_timer) ) {
1036                 if ( (Player_ai->target_objnum != -1) && !can_target ){
1037                         Player_ai->target_objnum = -1;
1038                 }
1039         }
1040
1041         // if there is no target, check if auto-targeting is enabled, and select new target
1042         int retarget = 0;
1043         int retarget_turret = 0;
1044
1045         if (Player_ai->target_objnum == -1){
1046                 retarget = 1;
1047         } else if (Objects[Player_ai->target_objnum].type == OBJ_SHIP) {
1048                 if (Ships[Objects[Player_ai->target_objnum].instance].flags & SF_DYING){
1049                         if (timestamp_elapsed(Ships[Objects[Player_ai->target_objnum].instance].final_death_time)) {
1050                                 retarget = 1;
1051                         }
1052                 }
1053         }
1054
1055         // check if big ship and currently selected subsys is turret and turret is dead
1056         // only do this is not retargeting
1057         if ((!retarget) && (Player_ai->target_objnum != -1)) {
1058                 if (Objects[Player_ai->target_objnum].type == OBJ_SHIP) {
1059                         if ( !(Ships[Objects[Player_ai->target_objnum].instance].flags & SF_DYING) ) {
1060                                 if ( Ship_info[Ships[Objects[Player_ai->target_objnum].instance].ship_info_index].flags & (SIF_BIG_SHIP | SIF_HUGE_SHIP) ) {
1061                                         ship_subsys *ss = Player_ai->targeted_subsys;
1062                                         if (ss != NULL) {
1063                                                 if ((ss->system_info->type == SUBSYSTEM_TURRET) && (ss->current_hits == 0)) {
1064                                                         retarget_turret = 1;
1065                                                 }
1066                                         }
1067                                 }
1068                         }
1069                 }
1070         }
1071
1072         if ( retarget && can_target ) {
1073                 Player_ai->current_target_is_locked = 0;
1074                 if ( Players[Player_num].flags & PLAYER_FLAGS_AUTO_TARGETING ) {
1075                         Player_ai->target_objnum = -1;
1076                         hud_target_auto_target_next();
1077                 }
1078         }
1079
1080         if (retarget_turret && can_target) {
1081                 Assert(!retarget);
1082                 // get closest weighted live turret
1083                 // hud_target_closest(OBJ_INDEX(Player_obj), FALSE, FALSE);
1084                 void hud_update_closest_turret();
1085                 hud_update_closest_turret();
1086         }
1087
1088         hud_target_change_check();
1089
1090         if (Player_ai->target_objnum == -1) {
1091                 if ( Target_static_looping != -1 ) {
1092                         snd_stop(Target_static_looping);
1093                 }
1094                 return;
1095         }
1096
1097         targetp = &Objects[Player_ai->target_objnum];
1098
1099
1100         int stop_targetting_this_thing = 0;
1101
1102         // check to see if the target is still alive
1103         if ( targetp->flags&OF_SHOULD_BE_DEAD ) {
1104                 stop_targetting_this_thing = 1;
1105         }
1106
1107         Player->target_is_dying = FALSE;
1108         ship    *target_shipp = NULL;
1109
1110         if ( targetp->type == OBJ_SHIP ) {
1111                 Assert ( targetp->instance >=0 && targetp->instance < MAX_SHIPS );
1112                 target_shipp = &Ships[targetp->instance];
1113                 Player->target_is_dying = target_shipp->flags & SF_DYING;
1114
1115                 // If it is warping out (or exploded), turn off targeting
1116                 if ( target_shipp->flags & (SF_DEPART_WARP|SF_EXPLODED) ) {
1117                         stop_targetting_this_thing = 1;
1118                 }
1119         }
1120
1121         // Check if can still be seen in Nebula
1122         if ( hud_target_invalid_awacs(targetp) ) {
1123                 stop_targetting_this_thing = 1;
1124         }
1125
1126         // If this was found to be something we shouldn't
1127         // target anymore, just remove it
1128         if ( stop_targetting_this_thing )       {
1129                 Player_ai->target_objnum = -1;
1130                 Player_ai->targeted_subsys = NULL;
1131                 hud_stop_looped_locking_sounds();
1132         }
1133
1134         if (Player->target_is_dying) {
1135                 hud_stop_looped_locking_sounds();
1136                 if ( Players[Player_num].flags & PLAYER_FLAGS_AUTO_TARGETING ) {
1137                         hud_target_auto_target_next();
1138                 }
1139         }
1140
1141         // Switch to battle track when a targeted ship is hostile and within BATTLE_START_MIN_TARGET_DIST
1142         if (targetp->type == OBJ_SHIP && Event_Music_battle_started == 0 ) {
1143                 Assert( target_shipp != NULL );
1144
1145                 if (opposing_team_mask(Player_ship->team)) {
1146                         float   dist_to_target;
1147
1148                         dist_to_target = vm_vec_dist_quick(&targetp->pos, &Player_obj->pos);
1149                         if (dist_to_target < BATTLE_START_MIN_TARGET_DIST) {
1150
1151                                 // If the target has an AI class of none, it is a Cargo, NavBuoy or other non-aggressive
1152                                 // ship, so don't start the battle music
1153                                 if (stricmp(Ai_class_names[Ai_info[target_shipp->ai_index].ai_class], NOX("none")))
1154                                         event_music_battle_start();
1155                         }
1156                 }
1157         }
1158
1159         // Since we need to reference the player's target integrity in several places this upcoming
1160         // frame, only calculate once here
1161         if ( target_shipp ) {
1162                 float initial_hull;
1163                 initial_hull = Ship_info[target_shipp->ship_info_index].initial_hull_strength;
1164                 if (  initial_hull <= 0 ) {
1165                         Int3(); // illegal initial hull strength
1166                         Pl_target_integrity = 0.0f;
1167                 } else {
1168                         Pl_target_integrity = targetp->hull_strength / initial_hull;
1169                         if (Pl_target_integrity < 0)
1170                                 Pl_target_integrity = 0.0f;
1171                 }
1172         }
1173
1174         hud_update_cargo_scan_sound();
1175
1176 }
1177
1178 void HUD_render_forward_icon(object *objp)
1179 {
1180         vertex  v0;
1181         vector  p0;
1182
1183         vm_vec_scale_add(&p0, &objp->pos, &objp->orient.v.fvec, 100.0f);
1184         g3_rotate_vertex(&v0, &p0);
1185
1186         gr_set_color(255, 0, 0);
1187         if ((!(v0.flags & PF_OVERFLOW)) && (v0.codes == 0)) // make sure point projected
1188                 g3_draw_sphere(&v0, 1.25f);
1189         else if (v0.codes != 0) { // target center is not on screen
1190                 // draw the offscreen indicator at the edge of the screen where the target is closest to
1191                 hud_draw_offscreen_indicator(&v0, &p0);
1192         }
1193 }
1194
1195 // Draw white brackets around asteroids which has the AF_DRAW_BRACKETS flag set
1196 void hud_show_asteroid_brackets()
1197 {
1198         if ( hud_sensors_ok(Player_ship, 0) ) {
1199                 asteroid_show_brackets();
1200         }
1201 }
1202
1203 // Draw radar gauge on the HUD
1204 void hud_show_radar()
1205 {
1206         if ( hud_disabled() ) {
1207                 return;
1208         }
1209
1210         if (!(Viewer_mode & (VM_EXTERNAL | VM_SLEWED | VM_CHASE | VM_DEAD_VIEW | VM_WARP_CHASE | VM_PADLOCK_ANY ))) {
1211                 if ( Game_detail_flags & DETAIL_FLAG_HUD )      {
1212                         if ( hud_gauge_active(HUD_RADAR) ) {
1213                                 HUD_reset_clip();
1214                                 radar_frame_render(flFrametime);
1215                         }
1216                 }
1217         }
1218 }
1219
1220 // Render model of target in the target view box
1221 void hud_show_target_model()
1222 {
1223         if ( hud_disabled() ) {
1224                 return;
1225         }
1226
1227         // display the miniature model of the target in the target box and shade
1228         if ( Game_detail_flags & DETAIL_FLAG_HUD )      {
1229                 if (!(Viewer_mode & (VM_EXTERNAL | VM_SLEWED | VM_CHASE | VM_DEAD_VIEW | VM_WARP_CHASE | VM_PADLOCK_ANY)))
1230                         hud_render_target_model();
1231         }
1232 }
1233
1234 void hud_show_common_3d_gauges(float frametime, int in_cockpit)
1235 {
1236         // draw boxes around current selection set, if any
1237         hud_show_selection_set();
1238
1239         // draw the targeting data around any message sender
1240         hud_show_message_sender();
1241
1242         // draw brackets around asteroids is necessary
1243         hud_show_asteroid_brackets();
1244
1245         // draw targetting data around the current target
1246         hud_show_targeting_gauges(frametime, in_cockpit);
1247
1248         // draw brackets and distance to remote detonate missile
1249         hud_show_remote_detonate_missile();
1250 }
1251
1252 // Render gauges that need to be between a g3_start_frame() and a g3_end_frame()
1253 void HUD_render_3d(float frametime)
1254 {
1255         Player->subsys_in_view = -1;
1256
1257         if ( hud_disabled() ) {
1258                 return;
1259         }
1260
1261         if (!(Viewer_mode & (VM_EXTERNAL | VM_SLEWED | VM_CHASE | VM_DEAD_VIEW | VM_WARP_CHASE | VM_PADLOCK_ANY))) {
1262
1263                 hud_show_common_3d_gauges(frametime, 1);
1264
1265                 //      Show all homing missiles locked onto the player.
1266                 //      Currently not supporting a way to toggle this as I'm not sure we'll stick wtih this gauge. -- MK, 3/17/97.
1267                 if ( hud_gauge_active(HUD_MISSILE_WARNING_ARROW) ) {
1268                         hud_show_homing_missiles();
1269                 }
1270
1271         } else if ( Viewer_mode & (VM_CHASE | VM_EXTERNAL | VM_WARP_CHASE | VM_PADLOCK_ANY ) ) {
1272                 // If the player is warping out, don't draw the targeting gauges
1273                 Assert(Player != NULL);
1274                 if ( Player->control_mode != PCM_NORMAL ) {
1275                         return;
1276                 }
1277
1278                 hud_show_common_3d_gauges(frametime, 0);
1279         }
1280
1281         if (Viewer_mode & VM_SLEWED) {
1282                 HUD_render_forward_icon(Player_obj);
1283         }
1284 }
1285
1286
1287 // call from HUD_render_2d() when in gameplay, and call when in navmap
1288 void hud_show_messages()
1289 {
1290         // draw the message window
1291         hud_show_msg_window();
1292         hud_show_fixed_text();
1293 }
1294
1295 // decide if we want to blit damage status to the screen
1296 void hud_maybe_show_damage()
1297 {
1298         if ( !hud_gauge_active(HUD_DAMAGE_GAUGE) ) {
1299                 return;
1300         }
1301
1302         // display the current weapon info for the player ship, with ammo/energy counts
1303         if ( hud_gauge_active(HUD_DAMAGE_GAUGE) ) {
1304                 int show_gauge_flag;
1305
1306                 if ( (Ship_info[Player_ship->ship_info_index].initial_hull_strength - Player_obj->hull_strength) > 1.0f ) {
1307                         show_gauge_flag = 1;
1308                 } else {
1309                         show_gauge_flag = 0;
1310                 }
1311
1312                 // is gauge configured as a popup?
1313                 if ( hud_gauge_is_popup(HUD_DAMAGE_GAUGE) ) {
1314                         if ( !hud_gauge_popup_active(HUD_DAMAGE_GAUGE) ) {
1315                                 show_gauge_flag=0;
1316                         }
1317                 }
1318
1319                 if ( show_gauge_flag ) {
1320                         hud_show_damage_popup();
1321                 }
1322         }
1323 }
1324
1325 // The damage toggle button was pressed, so change state
1326 void hud_damage_popup_toggle()
1327 {
1328         snd_play(&Snds[SND_SQUADMSGING_ON]);
1329
1330         // If gague is disabled (off), make it on all the time
1331         if ( !hud_gauge_active(HUD_DAMAGE_GAUGE) ) {
1332                 hud_config_set_gauge_flags(HUD_DAMAGE_GAUGE,1,0);
1333                 return;
1334         }
1335
1336         // if gauge is popup, turn it off if it is current up, otherwise force it to be up
1337         if ( hud_gauge_is_popup(HUD_DAMAGE_GAUGE) ) {
1338                 if ( Player_obj->hull_strength == Ship_info[Player_ship->ship_info_index].initial_hull_strength ) {
1339                         hud_config_set_gauge_flags(HUD_DAMAGE_GAUGE,1,0);
1340                 } else {
1341                         hud_config_set_gauge_flags(HUD_DAMAGE_GAUGE,0,0);
1342                 }
1343                 return;
1344         }
1345
1346         // gauge is on, without any popup... so force it to be off
1347         hud_config_set_gauge_flags(HUD_DAMAGE_GAUGE,0,0);
1348 }
1349
1350
1351 // Display the current mission time in MM:SS format
1352 void hud_show_mission_time()
1353 {
1354         float mission_time, time_comp;
1355         int minutes=0;
1356         int seconds=0;
1357
1358         mission_time = f2fl(Missiontime);  // convert to seconds
1359
1360         minutes=(int)(mission_time/60);
1361         seconds=(int)mission_time%60;
1362
1363         hud_set_gauge_color(HUD_MISSION_TIME);
1364
1365         // blit background frame
1366         if ( Mission_time_gauge.first_frame >= 0 ) {
1367                 GR_AABITMAP(Mission_time_gauge.first_frame, Mission_time_coords[gr_screen.res][0], Mission_time_coords[gr_screen.res][1]);
1368         }
1369
1370         // print out mission time in MM:SS format
1371         gr_printf(Mission_time_text_coords[gr_screen.res][0], Mission_time_text_coords[gr_screen.res][1], NOX("%02d:%02d"), minutes, seconds);
1372
1373         // display time compression as xN
1374         time_comp = f2fl(Game_time_compression);
1375         if ( time_comp < 1 ) {
1376                 gr_printf(Mission_time_text_val_coords[gr_screen.res][0], Mission_time_text_val_coords[gr_screen.res][1], XSTR( "x%.1f", 215), time_comp);
1377         } else {
1378                 gr_printf(Mission_time_text_val_coords[gr_screen.res][0], Mission_time_text_val_coords[gr_screen.res][1], XSTR( "x%.0f", 216), time_comp);
1379         }
1380 }
1381
1382 // If a head animation is playing, then blit a border around it
1383 void hud_maybe_blit_head_border()
1384 {
1385         if ( Head_frame_gauge.first_frame == -1 ){
1386                 return;
1387         }
1388
1389         if ( message_anim_is_playing() ) {
1390                 // draw frame
1391                 // hud_set_default_color();
1392                 hud_set_gauge_color(HUD_TALKING_HEAD);
1393
1394                 GR_AABITMAP(Head_frame_gauge.first_frame, Head_frame_coords[gr_screen.res][0], Head_frame_coords[gr_screen.res][1]);
1395
1396                 // draw title
1397                 gr_string(Head_message_coords[gr_screen.res][0], Head_message_coords[gr_screen.res][1], XSTR("message", 217));
1398         }
1399 }
1400
1401 // Black out area behind head animation
1402 void hud_maybe_clear_head_area()
1403 {
1404         if ( Head_frame_gauge.first_frame == -1 ) {
1405                 return;
1406         }
1407
1408         if ( message_anim_is_playing() ) {
1409                 // clear
1410                 if (gr_screen.res == GR_640) {
1411                         HUD_set_clip(7, 45, 160, 120);          // these coords are set in MissionMessage.cpp
1412                 } else {
1413                         HUD_set_clip(7, 66, 160, 120);
1414                 }
1415                 gr_clear();
1416                 HUD_reset_clip();
1417         }
1418 }
1419
1420 void hud_maybe_display_supernova()
1421 {
1422         float time_left;
1423
1424         // if there's a supernova coming
1425         time_left = supernova_time_left();
1426         if(time_left < 0.0f){
1427                 return;
1428         }
1429
1430         gr_set_color_fast(&Color_bright_red);
1431         if(Lcl_pl) {
1432             gr_printf(Supernova_coords[gr_screen.res][0], Supernova_coords[gr_screen.res][1], "Wybuch supernowej : %.2f s", time_left);
1433         } else {
1434             gr_printf(Supernova_coords[gr_screen.res][0], Supernova_coords[gr_screen.res][1], "Supernova Warning : %.2f s", time_left);
1435         }
1436 }
1437
1438 // render multiplayer ping time to the server if appropriate
1439 void hud_render_multi_ping()
1440 {
1441         // if we shouldn't be displaying a ping time, return here
1442         if(!multi_show_ingame_ping()){
1443                 return;
1444         }
1445
1446         // if we're in multiplayer mode, display our ping time to the server
1447         if((Game_mode & GM_MULTIPLAYER) && (Net_player != NULL) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER)){
1448                 char ping_str[50];
1449                 memset(ping_str,0,50);
1450
1451                 // if our ping is positive, display it
1452                 if((Netgame.server != NULL) && (Netgame.server->s_info.ping.ping_avg > 0)){
1453                         // get the string
1454                         if(Netgame.server->s_info.ping.ping_avg >= 1000){
1455                                 strcpy(ping_str,XSTR("> 1 sec",628));
1456                         } else {
1457                                 sprintf(ping_str,XSTR("%d ms",629),Netgame.server->s_info.ping.ping_avg);
1458                         }
1459
1460                         // blit the string out
1461                         hud_set_default_color();
1462                         gr_string(Ping_coords[gr_screen.res][0], Ping_coords[gr_screen.res][1], ping_str);
1463                 }
1464         }
1465 }
1466
1467 // render all the 2D gauges on the HUD
1468 void HUD_render_2d(float frametime)
1469 {
1470         int show_gauge_flag;
1471
1472         HUD_reset_clip();
1473
1474 /*
1475         // show some scoring debug stuff
1476         {
1477                 extern char Scoring_debug_text[];
1478                 gr_string( 10, 40, Scoring_debug_text );
1479         }
1480 */
1481         if ( hud_disabled() ) {
1482                 return;
1483         }
1484
1485         if (!(Viewer_mode & (VM_EXTERNAL | VM_SLEWED | VM_CHASE | VM_DEAD_VIEW | VM_WARP_CHASE | VM_PADLOCK_ANY ))) {
1486                 // display Energy Transfer System gauges
1487                 if ( hud_gauge_active(HUD_ETS_GAUGE) ) {
1488                         show_gauge_flag=1;
1489                         // is gauge configured as a popup?
1490                         if ( hud_gauge_is_popup(HUD_ETS_GAUGE) ) {
1491                                 if ( !hud_gauge_popup_active(HUD_ETS_GAUGE) ) {
1492                                         show_gauge_flag=0;
1493                                 }
1494                         }
1495
1496                         if ( show_gauge_flag ) {
1497                                 hud_show_ets();
1498                         }
1499                 }
1500
1501                 // display afterburner fuel gauge
1502                 if ( hud_gauge_active(HUD_AFTERBURNER_ENERGY) ) {
1503                         hud_set_gauge_color(HUD_AFTERBURNER_ENERGY);
1504                         hud_show_afterburner_gauge();
1505                 }
1506
1507                 // text flash gauge
1508                 hud_maybe_show_text_flash_icon();
1509
1510                 // maybe show the netlag icon
1511                 if(Game_mode & GM_MULTIPLAYER){
1512                         hud_maybe_show_netlag_icon();
1513
1514                         if(Net_player->flags & NETINFO_FLAG_OBSERVER){
1515                                 hud_render_observer();
1516                         }
1517                 }
1518
1519                 // draw the reticle
1520                 hud_show_reticle();
1521
1522                 /*
1523                 // why is this here twice?
1524                 // display Energy Transfer System gauges
1525                 if ( hud_gauge_active(HUD_ETS_GAUGE) ) {
1526                         show_gauge_flag=1;
1527                         // is gauge configured as a popup?
1528                         if ( hud_gauge_is_popup(HUD_ETS_GAUGE) ) {
1529                                 if ( !hud_gauge_popup_active(HUD_ETS_GAUGE) ) {
1530                                         show_gauge_flag=0;
1531                                 }
1532                         }
1533
1534                         if ( show_gauge_flag ) {
1535                                 hud_show_ets();
1536                         }
1537                 }
1538                 */
1539
1540                 // display info on the ships in the escort list
1541                 if ( hud_gauge_active(HUD_ESCORT_VIEW) ) {
1542                         show_gauge_flag=1;
1543                         // is gauge configured as a popup?
1544                         if ( hud_gauge_is_popup(HUD_ESCORT_VIEW) ) {
1545                                 if ( !hud_gauge_popup_active(HUD_ESCORT_VIEW) ) {
1546                                         show_gauge_flag=0;
1547                                 }
1548                         }
1549
1550                         if ( show_gauge_flag ) {
1551                                 hud_set_gauge_color(HUD_ESCORT_VIEW);
1552                                 hud_display_escort();
1553                         }
1554                 }
1555
1556                 // display the current weapon info for the player ship, with ammo/energy counts
1557                 if ( hud_gauge_active(HUD_WEAPONS_GAUGE) ) {
1558                         show_gauge_flag=1;
1559                         // is gauge configured as a popup?
1560                         if ( hud_gauge_is_popup(HUD_WEAPONS_GAUGE) ) {
1561                                 if ( !hud_gauge_popup_active(HUD_WEAPONS_GAUGE) ) {
1562                                         show_gauge_flag=0;
1563                                 }
1564                         }
1565
1566                         if ( show_gauge_flag ) {
1567                                 hud_show_weapons();
1568                         }
1569                 }
1570
1571                 // display player countermeasures count
1572                 if ( hud_gauge_active(HUD_CMEASURE_GAUGE) ) {
1573                         show_gauge_flag=1;
1574                         // is gauge configured as a popup?
1575                         if ( hud_gauge_is_popup(HUD_CMEASURE_GAUGE) ) {
1576                                 if ( !hud_gauge_popup_active(HUD_CMEASURE_GAUGE) ) {
1577                                         show_gauge_flag=0;
1578                                 }
1579                         }
1580
1581                         if ( show_gauge_flag ) {
1582                                 hud_show_cmeasure_gague();
1583                         }
1584                 }
1585
1586                 if ( hud_gauge_active(HUD_WEAPONS_ENERGY) ) {
1587                         hud_show_weapon_energy_gauge();
1588                 }
1589
1590                 // show the auto-target icons
1591                 hud_show_auto_icons();
1592
1593                 // draw a border around a talking head if it is playing
1594                 hud_maybe_blit_head_border();
1595
1596                 // draw the status of support ship servicing the player
1597                 hud_support_view_blit();
1598
1599                 // draw the damage status
1600                 hud_maybe_show_damage();
1601
1602                 // show mission time
1603                 if ( hud_gauge_active(HUD_MISSION_TIME) ) {
1604                         hud_show_mission_time();
1605                 }
1606
1607                 // show subspace notify gauge
1608                 hud_maybe_display_subspace_notify();
1609
1610                 // show objective status gauge
1611                 if ( hud_gauge_active(HUD_OBJECTIVES_NOTIFY_GAUGE) ) {
1612                         hud_maybe_display_objective_message();
1613                 }
1614
1615                 if ( hud_gauge_active(HUD_WINGMEN_STATUS) ) {
1616                         hud_wingman_status_render();
1617                 }
1618
1619                 if ( hud_gauge_active(HUD_KILLS_GAUGE) ) {
1620                         show_gauge_flag=1;
1621                         // is gauge configured as a popup?
1622                         if ( hud_gauge_is_popup(HUD_KILLS_GAUGE) ) {
1623                                 if ( !hud_gauge_popup_active(HUD_KILLS_GAUGE) ) {
1624                                         show_gauge_flag=0;
1625                                 }
1626                         }
1627
1628                         if ( show_gauge_flag ) {
1629                                 hud_show_kills_gauge();
1630                         }
1631                 }
1632
1633                 // show the player shields
1634                 if ( hud_gauge_active(HUD_PLAYER_SHIELD_ICON) ) {
1635                         hud_shield_show(Player_obj);
1636                 }
1637
1638                 // show the directives popup and/or training popup
1639                 message_training_display();
1640
1641                 // if this is a multiplayer game, blit any icons/bitmaps indicating voice recording or playback
1642                 if(Game_mode & GM_MULTIPLAYER){
1643                         hud_show_voice_status();
1644                 }
1645         }
1646
1647         hud_show_messages();
1648
1649         // maybe render any necessary multiplayer text messaging strings being entered
1650         hud_maybe_render_multi_text();
1651
1652         // show red alert notify gauge when moving to red alert
1653         hud_maybe_display_red_alert();
1654
1655         // display supernova warning
1656         hud_maybe_display_supernova();
1657
1658         // check to see if we are in messaging mode.  If so, send the key to the code
1659         // to deal with the message.  hud_sqaudmsg_do_frame will return 0 if the key
1660         // wasn't used in messaging mode, otherwise 1.  In the event the key was used,
1661         // return immediately out of this function.
1662         if ( Players->flags & PLAYER_FLAGS_MSG_MODE ) {
1663                 if ( hud_squadmsg_do_frame() ){
1664                         return;
1665                 }
1666         }
1667
1668         hud_render_multi_ping();
1669 }
1670
1671
1672 // hud_stop_looped_engine_sounds()
1673 //
1674 // This function will set the loop id's for the engine noises to -1, this will force any
1675 // looping engine sounds to stop.  This should only be called when the game decides to
1676 // stop all looping sounds
1677 //
1678
1679 void hud_stop_looped_engine_sounds()
1680 {
1681         if ( Player_engine_snd_loop > -1 )      {
1682                 snd_stop(Player_engine_snd_loop);
1683                 //snd_chg_loop_status(Player_engine_snd_loop, 0);
1684                 Player_engine_snd_loop = -1;
1685         }
1686 }
1687
1688 #define ZERO_PERCENT                    0.01f
1689 #define ENGINE_MAX_VOL          1.0f
1690 #define ENGINE_MAX_PITCH        44100
1691
1692 void update_throttle_sound()
1693 {
1694         // determine what engine sound to play
1695         float percent_throttle;
1696 //      float throttle_pitch;
1697
1698         // if we're a multiplayer observer, stop any engine sounds from playing and return
1699         if((Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_OBSERVER)){
1700                 // stop engine sound if it is playing
1701                 if(Player_engine_snd_loop != -1){
1702                         snd_stop(Player_engine_snd_loop);
1703                         Player_engine_snd_loop = -1;
1704                 }
1705
1706                 // return
1707                 return;
1708         }
1709
1710         if ( timestamp_elapsed(throttle_sound_check_id) ) {
1711
1712                 throttle_sound_check_id = timestamp(THROTTLE_SOUND_CHECK_INTERVAL);
1713
1714                 if ( Ships[Player_obj->instance].current_max_speed == 0 ) {
1715                         percent_throttle = Player_obj->phys_info.fspeed / Ship_info[Ships[Player_obj->instance].ship_info_index].max_speed;
1716                 } else {
1717                         percent_throttle = Player_obj->phys_info.fspeed / Ships[Player_obj->instance].current_max_speed;
1718                 }
1719
1720                 // If the throttle has changed, modify the sound
1721                 if ( percent_throttle != last_percent_throttle || Player_engine_snd_loop == -1 ) {
1722
1723                         if ( percent_throttle < ZERO_PERCENT ) {
1724                                 if ( Player_engine_snd_loop > -1 )      {
1725                                         snd_chg_loop_status(Player_engine_snd_loop, 0);
1726                                         Player_engine_snd_loop = -1;
1727                                 }
1728                         }
1729                         else {
1730                                 if ( Player_engine_snd_loop == -1 ){
1731                                         Player_engine_snd_loop = snd_play_looping( &Snds[SND_ENGINE], 0.0f, percent_throttle * ENGINE_MAX_VOL );
1732                                 } else {
1733                                         // The sound may have been trashed at the low-level if sound channel overflow.
1734                                         // TODO: implement system where certain sounds cannot be interrupted (priority?)
1735                                         if ( snd_is_playing(Player_engine_snd_loop) ) {
1736                                                 snd_set_volume(Player_engine_snd_loop, percent_throttle * ENGINE_MAX_VOL);
1737                                         }
1738                                         else {
1739                                                 Player_engine_snd_loop = -1;
1740                                         }
1741                                 }
1742                         }
1743
1744 //                      throttle_pitch = snd_get_pitch(Player_engine_snd_loop);
1745 //                      if ( percent_throttle > 0.5f ) {
1746 //                              snd_set_pitch(Player_engine_snd_loop, 1.0f + (percent_throttle-0.5f)*1.0f));
1747 //                      }
1748
1749                 }       // end if (percent_throttle != last_percent_throttle)
1750
1751                 last_percent_throttle = percent_throttle;
1752
1753         }       // end if ( timestamp_elapsed(throttle_sound_check_id) )
1754 }
1755
1756 // called at the beginning of each level.  Loads frame data in once, and initializes any damage
1757 // gauge specific data
1758 void hud_damage_popup_init()
1759 {
1760         int i;
1761
1762         if ( !Damage_gauges_loaded ) {
1763                 for ( i = 0; i < NUM_DAMAGE_GAUGES; i++ ) {
1764                         Damage_gauges[i].first_frame = bm_load_animation(Damage_gauge_fnames[gr_screen.res][i], &Damage_gauges[i].num_frames);
1765                         if ( Damage_gauges[i].first_frame == -1 ) {
1766                                 Warning(LOCATION, "Could not load in the ani: %s\n", Damage_gauge_fnames[gr_screen.res][i]);
1767                                 return;
1768                         }
1769                 }
1770                 Damage_gauges_loaded = 1;
1771         }
1772
1773         Damage_flash_bright = 0;
1774         Damage_flash_timer =    1;
1775
1776         for ( i = 0; i < SUBSYSTEM_MAX; i++ ) {
1777                 Pl_hud_subsys_info[i].last_str = 1000.0f;
1778                 Pl_hud_subsys_info[i].flash_duration_timestamp = 1;
1779                 Pl_hud_next_flash_timestamp = 1;
1780                 Pl_hud_is_bright = 0;
1781         }
1782 }
1783
1784 // ---------------------------------------------------------
1785 // show player damage status via a popup window
1786
1787 void hud_show_damage_popup()
1788 {
1789         model_subsystem *psub;
1790         ship_subsys                     *pss;
1791         ship_info                       *sip;
1792         int                                     sx, sy, bx, by, w, h, screen_integrity, num, best_str, best_index;
1793         float                                   strength, shield, integrity;
1794         char                                    buf[128];
1795         hud_subsys_damage       hud_subsys_list[SUBSYSTEM_MAX];
1796
1797         if ( Damage_gauges[0].first_frame == -1 ) {
1798                 return;
1799         }
1800
1801         if ( (The_mission.game_type & MISSION_TYPE_TRAINING) && Training_msg_visible ){
1802                 return;
1803         }
1804
1805         sip = &Ship_info[Player_ship->ship_info_index];
1806         hud_get_target_strength(Player_obj, &shield, &integrity);
1807         screen_integrity = fl2i(integrity*100);
1808
1809         if ( hud_gauge_is_popup(HUD_DAMAGE_GAUGE) ) {
1810                 if ( screen_integrity >= 100 ) {
1811                         return;
1812                 }
1813         }
1814
1815         if ( timestamp_elapsed(Damage_flash_timer) ) {
1816                 Damage_flash_timer = timestamp(DAMAGE_FLASH_TIME);
1817                 Damage_flash_bright ^= 1;
1818         }
1819
1820         hud_set_gauge_color(HUD_DAMAGE_GAUGE);
1821
1822         // draw the top of the damage pop-up
1823         GR_AABITMAP(Damage_gauges[0].first_frame, Damage_gauge_coords[gr_screen.res][0][0], Damage_gauge_coords[gr_screen.res][0][1]);
1824         gr_string(Damage_text_coords[gr_screen.res][0], Damage_text_coords[gr_screen.res][1], XSTR( "damage", 218));
1825
1826         // show hull integrity
1827         if ( screen_integrity < 100 ) {
1828                 if ( screen_integrity == 0 ) {
1829                         screen_integrity = 1;
1830                 }
1831                 sprintf(buf, XSTR( "%d%%", 219), screen_integrity);
1832                 hud_num_make_mono(buf);
1833                 gr_get_string_size(&w, &h, buf);
1834                 if ( screen_integrity < 30 ) {
1835                         gr_set_color_fast(&Color_red);
1836                 }
1837                 gr_string(Hull_integ_coords[gr_screen.res][0], Hull_integ_coords[gr_screen.res][1], XSTR( "Hull Integrity", 220));
1838                 gr_string(Hull_integ_val_coords[gr_screen.res][0] - w, Hull_integ_val_coords[gr_screen.res][1], buf);
1839         }
1840
1841         // show damaged subsystems
1842         sx = Damage_subsys_text_coords[gr_screen.res][0];
1843         sy = Damage_subsys_text_coords[gr_screen.res][1];
1844         bx = Damage_gauge_coords[gr_screen.res][1][0];
1845         by = Damage_gauge_coords[gr_screen.res][1][1];
1846
1847         num = 0;
1848         for ( pss = GET_FIRST(&Player_ship->subsys_list); pss !=END_OF_LIST(&Player_ship->subsys_list); pss = GET_NEXT(pss) ) {
1849                 psub = pss->system_info;
1850                 strength = ship_get_subsystem_strength(Player_ship, psub->type);
1851                 if ( strength < 1 ) {
1852                         screen_integrity = fl2i(strength*100);
1853                         if ( screen_integrity == 0 ) {
1854                                 if ( strength > 0 ) {
1855                                         screen_integrity = 1;
1856                                 }
1857                         }
1858                         hud_subsys_list[num].name = psub->name;
1859                         hud_subsys_list[num].str  = screen_integrity;
1860                         hud_subsys_list[num].type = psub->type;
1861                         num++;
1862
1863                         if ( strength < Pl_hud_subsys_info[psub->type].last_str ) {
1864                                 Pl_hud_subsys_info[psub->type].flash_duration_timestamp = timestamp(SUBSYS_DAMAGE_FLASH_DURATION);
1865                         }
1866                         Pl_hud_subsys_info[psub->type].last_str = strength;
1867                 }
1868         }
1869
1870         int type;
1871         for ( int i = 0; i < num; i++ ) {
1872                 best_str = 1000;
1873                 best_index = -1;
1874                 for ( int j = 0; j < num-i; j++ ) {
1875                         if ( hud_subsys_list[j].str < best_str ) {
1876                                 best_str = hud_subsys_list[j].str;
1877                                 best_index = j;
1878                         }
1879                 }
1880
1881                 Assert(best_index >= 0);
1882                 Assert(best_str >= 0);
1883
1884                 // display strongest subsystem left in list
1885                 // draw the bitmap
1886                 // hud_set_default_color();
1887                 hud_set_gauge_color(HUD_DAMAGE_GAUGE);
1888
1889                 GR_AABITMAP(Damage_gauges[1].first_frame, bx, by);
1890                 by += Damage_gauge_line_h[gr_screen.res];
1891
1892                 type = hud_subsys_list[best_index].type;
1893                 if ( !timestamp_elapsed( Pl_hud_subsys_info[type].flash_duration_timestamp ) ) {
1894                         if ( timestamp_elapsed( Pl_hud_next_flash_timestamp ) ) {
1895                                 Pl_hud_is_bright ^= 1;
1896                                 Pl_hud_next_flash_timestamp = timestamp(SUBSYS_DAMAGE_FLASH_INTERVAL);
1897                         }
1898
1899                         if ( Pl_hud_is_bright ) {
1900                                 int alpha_color;
1901                                 alpha_color = min(HUD_COLOR_ALPHA_MAX,HUD_color_alpha+HUD_BRIGHT_DELTA);
1902                                 // gr_set_color_fast(&HUD_color_defaults[alpha_color]);
1903
1904                                 hud_set_gauge_color(HUD_DAMAGE_GAUGE, alpha_color);
1905                         } else {
1906                                 hud_set_gauge_color(HUD_DAMAGE_GAUGE);
1907                         }
1908                 }
1909
1910                 // draw the text
1911                 if ( best_str < 30 ) {
1912                         if ( best_str <= 0 ) {
1913                                 if ( Damage_flash_bright ) {
1914                                         gr_set_color_fast(&Color_bright_red);
1915                                 } else {
1916                                         gr_set_color_fast(&Color_red);
1917                                 }
1918
1919                         } else {
1920                                 gr_set_color_fast(&Color_red);
1921                         }
1922                 } else {
1923                         hud_set_gauge_color(HUD_DAMAGE_GAUGE);
1924                 }
1925
1926                 gr_string(sx, sy, hud_targetbox_truncate_subsys_name(hud_subsys_list[best_index].name));
1927                 sprintf(buf, XSTR( "%d%%", 219), best_str);
1928                 hud_num_make_mono(buf);
1929                 gr_get_string_size(&w, &h, buf);
1930                 gr_string(Hull_integ_val_coords[gr_screen.res][0] - w, sy, buf);
1931                 sy += Damage_gauge_line_h[gr_screen.res];
1932
1933                 // remove it from hud_subsys_list
1934                 if ( best_index < (num-i-1) ) {
1935                         hud_subsys_list[best_index] = hud_subsys_list[num-i-1];
1936                 }
1937         }
1938
1939         // draw the bottom of the gauge
1940         // hud_set_default_color();
1941         hud_set_gauge_color(HUD_DAMAGE_GAUGE);
1942
1943         GR_AABITMAP(Damage_gauges[2].first_frame, bx, by);
1944 }
1945
1946 // init the members of the hud_anim struct to default values
1947 void hud_anim_init(hud_anim *ha, int sx, int sy, const char *filename)
1948 {
1949         ha->first_frame = -1;
1950         ha->num_frames          = 0;
1951         ha->total_time          = 0.0f;
1952         ha->time_elapsed        = 0.0f;
1953         ha->sx                          = sx;
1954         ha->sy                          = sy;
1955         strcpy(ha->name, filename);
1956 }
1957
1958 // call to unload the targetbox static animation
1959 void hud_anim_release(hud_anim *ha)
1960 {
1961         int i;
1962
1963         if (ha->first_frame < 0)
1964                 return;
1965
1966         for ( i = 0; i < ha->num_frames; i++ ) {
1967                 bm_unload(ha->first_frame + i);
1968         }
1969 }
1970
1971 // load a hud_anim
1972 // return 0 is successful, otherwise return -1
1973 int hud_anim_load(hud_anim *ha)
1974 {
1975         int             fps;
1976
1977         ha->first_frame = bm_load_animation(ha->name, &ha->num_frames, &fps);
1978         if ( ha->first_frame == -1 ) {
1979                 Int3(); // couldn't load animation file in
1980                 return -1;
1981         }
1982         Assert(fps != 0);
1983         ha->total_time = i2fl(ha->num_frames)/fps;
1984         return 0;
1985 }
1986
1987 // render out a frame of the targetbox static animation, based on how much time has
1988 // elapsed
1989 // input:       ha                              =>      pointer to hud anim info
1990 //                              frametime       =>      seconds elapsed since last frame
1991 //                              draw_alpha      =>      draw bitmap as alpha-bitmap (default 0)
1992 //                              loop                    =>      anim should loop (default 1)
1993 //                              hold_last       =>      should last frame be held (default 0)
1994 //                              reverse         =>      play animation in reverse (default 0)
1995 int hud_anim_render(hud_anim *ha, float frametime, int draw_alpha, int loop, int hold_last, int reverse)
1996 {
1997         int framenum;
1998
1999         if ( ha->num_frames <= 0 ) {
2000                 if ( hud_anim_load(ha) == -1 )
2001                         return 0;
2002         }
2003
2004         ha->time_elapsed += frametime;
2005         if ( ha->time_elapsed > ha->total_time ) {
2006                 if ( loop ) {
2007                         ha->time_elapsed = 0.0f;
2008                 } else {
2009                         if ( !hold_last ) {
2010                                 return 0;
2011                         }
2012                 }
2013         }
2014
2015         // draw the correct frame of animation
2016         framenum = fl2i( (ha->time_elapsed * ha->num_frames) / ha->total_time );
2017         if (reverse) {
2018                 framenum = (ha->num_frames-1) - framenum;
2019         }
2020
2021         if ( framenum < 0 )
2022                 framenum = 0;
2023         if ( framenum >= ha->num_frames )
2024                 framenum = ha->num_frames-1;
2025
2026         // Blit the bitmap for this frame
2027         if(emp_should_blit_gauge()){
2028                 gr_set_bitmap(ha->first_frame + framenum, GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
2029                 if ( draw_alpha ){
2030                         gr_aabitmap(ha->sx, ha->sy);
2031                 } else {
2032                         gr_bitmap(ha->sx, ha->sy);
2033                 }
2034         }
2035
2036         return 1;
2037 }
2038
2039 // convert a number string to use mono-spaced 1 character
2040 void hud_num_make_mono(char *num_str)
2041 {
2042         int len, i, sc;
2043         len = strlen(num_str);
2044
2045         sc = Lcl_special_chars;
2046         for ( i = 0; i < len; i++ ) {
2047                 if ( num_str[i] == '1' ) {
2048                         num_str[i] = (char)(sc + 1);
2049                 }
2050         }
2051 }
2052
2053 // flashing text gauge
2054 void hud_init_text_flash_gauge()
2055 {
2056 }
2057
2058 void hud_start_text_flash(const char *txt, int t)
2059 {
2060         // bogus
2061         if(txt == NULL){
2062                 strcpy(Hud_text_flash, "");
2063                 return;
2064         }
2065
2066         // HACK. don't override EMP if its still going    :)
2067         if(!strcmp(Hud_text_flash, NOX("Emp")) && !hud_targetbox_flash_expired(TBOX_FLASH_CMEASURE)){
2068                 return;
2069         }
2070
2071         strncpy(Hud_text_flash, txt, 500);
2072         hud_targetbox_start_flash(TBOX_FLASH_CMEASURE, t);
2073 }
2074
2075 void hud_maybe_show_text_flash_icon()
2076 {
2077         int bright;
2078
2079         if ( hud_targetbox_flash_expired(TBOX_FLASH_CMEASURE) ) {
2080                 return;
2081         }
2082
2083         hud_targetbox_maybe_flash(TBOX_FLASH_CMEASURE);
2084
2085         // bright?
2086         bright = hud_targetbox_is_bright(TBOX_FLASH_CMEASURE);
2087
2088         // draw
2089         hud_show_text_flash_icon(Hud_text_flash, Hud_text_flash_coords[gr_screen.res][1], bright);
2090 }
2091
2092 void hud_show_text_flash_icon(const char *txt, int y, int bright)
2093 {
2094         int w, h;
2095
2096 #ifndef MAKE_FS1
2097         // different font size in hi-res
2098         if(gr_screen.res != GR_640){
2099                 gr_set_font(FONT3);
2100         }
2101 #endif
2102
2103         // set color
2104         if(bright){
2105                 hud_set_gauge_color(HUD_TEXT_FLASH, HUD_C_DIM);
2106         } else {
2107                 gr_set_color_fast(&Color_black);
2108         }
2109
2110         // string size
2111         gr_get_string_size(&w, &h, txt);
2112
2113         // draw the box
2114         gr_rect( (int)((((float)gr_screen.max_w / 2.0f) - ((float)w / 2.0f)) - 1.0f), (int)((float)y - 1.0f), w + 2, h + 1);
2115
2116         // string
2117         hud_set_gauge_color(HUD_TEXT_FLASH, HUD_C_BRIGHT);
2118         gr_string(0x8000, y, txt);
2119
2120         // go back to normal font
2121         gr_set_font(FONT1);
2122 }
2123
2124 // maybe display the kills gauge on the HUD
2125 void hud_show_kills_gauge()
2126 {
2127         if ( Kills_gauge.first_frame < 0 ) {
2128                 return;
2129         }
2130
2131         // hud_set_default_color();
2132         hud_set_gauge_color(HUD_KILLS_GAUGE);
2133
2134         // draw background
2135         GR_AABITMAP(Kills_gauge.first_frame, Kills_gauge_coords[gr_screen.res][0], Kills_gauge_coords[gr_screen.res][1]);
2136
2137         gr_string(Kills_text_coords[gr_screen.res][0], Kills_text_coords[gr_screen.res][1], XSTR( "kills:", 223));
2138
2139         // display how many kills the player has so far
2140         char    num_kills_string[32];
2141         int     w,h;
2142
2143         if ( !Player ) {
2144                 Int3();
2145                 return;
2146         }
2147
2148         sprintf(num_kills_string, "%d", Player->stats.m_kill_count_ok);
2149
2150         gr_get_string_size(&w, &h, num_kills_string);
2151         if (Lcl_gr) {
2152                 gr_string(Kills_text_val_coords_gr[gr_screen.res][0]-w, Kills_text_val_coords_gr[gr_screen.res][1], num_kills_string);
2153         } else {
2154                 gr_string(Kills_text_val_coords[gr_screen.res][0]-w, Kills_text_val_coords[gr_screen.res][1], num_kills_string);
2155         }
2156 }
2157
2158 // maybe show the netlag icon on the hud
2159 void hud_maybe_show_netlag_icon()
2160 {
2161         int lag_status;
2162
2163         if ( Netlag_icon.first_frame == -1 ) {
2164                 Int3();
2165                 return;
2166         }
2167
2168         lag_status = multi_query_lag_status();
2169
2170         switch(lag_status) {
2171         case 0:
2172                 // draw the net lag icon flashing
2173                 hud_targetbox_start_flash(TBOX_FLASH_NETLAG);
2174                 if(hud_targetbox_maybe_flash(TBOX_FLASH_NETLAG)){
2175                         hud_set_gauge_color(HUD_LAG_GAUGE, HUD_C_BRIGHT);
2176                 } else {
2177                         hud_set_gauge_color(HUD_LAG_GAUGE);
2178                 }
2179                 gr_set_bitmap(Netlag_icon.first_frame, GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
2180                 break;
2181         case 1:
2182                 // draw the disconnected icon flashing fast
2183                 if(hud_targetbox_maybe_flash(TBOX_FLASH_NETLAG,1)){
2184                         hud_set_gauge_color(HUD_LAG_GAUGE, HUD_C_BRIGHT);
2185                 } else {
2186                         hud_set_gauge_color(HUD_LAG_GAUGE);
2187                 }
2188                 gr_set_bitmap(Netlag_icon.first_frame+1, GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
2189                 break;
2190         default:
2191                 // nothing to draw
2192                 return;
2193         }
2194
2195         if(emp_should_blit_gauge()){
2196                 gr_aabitmap(Netlag_coords[gr_screen.res][0], Netlag_coords[gr_screen.res][1]);
2197         }
2198 }
2199
2200 // load in kills gauge if required
2201 void hud_init_kills_gauge()
2202 {
2203         if ( !Kills_gauge_loaded ) {
2204                 Kills_gauge.first_frame = bm_load_animation(Kills_fname[gr_screen.res], &Kills_gauge.num_frames);
2205                 if ( Kills_gauge.first_frame == -1 ) {
2206                         Warning(LOCATION, "Could not load in the kills ani: Kills_fname[gr_screen.res]\n");
2207                         return;
2208                 }
2209                 Kills_gauge_loaded = 1;
2210         }
2211 }
2212
2213 // load in netlag icon if required
2214 void hud_init_netlag_icon()
2215 {
2216         if ( !Netlag_icon_loaded ) {
2217                 Netlag_icon.first_frame = bm_load_animation(Netlag_fname[gr_screen.res], &Netlag_icon.num_frames);
2218                 if ( Netlag_icon.first_frame == -1 ) {
2219                         Warning(LOCATION, "Could not load in the netlag ani: Netlag_fname[gr_screen.res]\n");
2220                         return;
2221                 }
2222                 Netlag_icon_loaded = 1;
2223         }
2224 }
2225
2226 // called at mission start to init data, and load support view bitmap if required
2227 void hud_support_view_init()
2228 {
2229         Hud_support_view_fade = 1;
2230         Hud_support_obj_sig = -1;
2231         Hud_support_target_sig = -1;
2232         Hud_support_objnum = -1;
2233         Hud_support_view_active = 0;
2234         Hud_support_view_abort = 0;
2235
2236         // ensure the talking head border is loaded
2237         if ( !Support_view_gauge_loaded ) {
2238                 Support_view_gauge.first_frame = bm_load_animation(Support_fname[gr_screen.res], &Support_view_gauge.num_frames);
2239                 if ( Support_view_gauge.first_frame == -1 ) {
2240                         Warning(LOCATION, "Could not load in ani: Support_fname[gr_screen.res]\n");
2241                 }
2242                 Support_view_gauge_loaded = 1;
2243         }
2244 }
2245
2246 // start displaying the support view pop-up.  This will remain up until hud_support_view_stop is called.
2247 // input:       objnum  =>              object number for the support ship
2248 void hud_support_view_start()
2249 {
2250         Hud_support_view_active = 1;
2251         Hud_support_view_fade = 1;
2252 }
2253
2254 // stop displaying the support view pop-up
2255 void hud_support_view_stop(int stop_now)
2256 {
2257         if ( stop_now ) {
2258                 Hud_support_view_active = 0;
2259                 Hud_support_view_fade = 1;
2260                 Hud_support_view_abort = 0;
2261         } else {
2262                 Hud_support_view_fade = timestamp(2000);
2263         }
2264
2265         Hud_support_obj_sig = -1;
2266         Hud_support_target_sig = -1;
2267         Hud_support_objnum = -1;
2268 }
2269
2270 void hud_support_view_abort()
2271 {
2272         hud_support_view_stop(0);
2273         Hud_support_view_abort = 1;
2274 }
2275
2276 // return the number of seconds until repair ship will dock with player, return -1 if error
2277 //
2278 // mwa made this function more general purpose
2279 //
2280 // NOTE: This function is pretty stupid now.  It just assumes the player is sitting still, and
2281 //                 the support ship is moving directly to the player.
2282 int hud_support_get_dock_time( int objnum )
2283 {
2284         ai_info *aip;
2285         object  *support_objp, *other_objp;
2286         float           dist, rel_speed, support_speed;
2287         vector  rel_vel;
2288
2289         support_objp = &Objects[objnum];
2290         aip = &Ai_info[Ships[support_objp->instance].ai_index];
2291
2292         // if the ship is docked, return 0
2293         if ( aip->ai_flags & AIF_DOCKED )
2294                 return 0;
2295
2296         // get the dockee object pointer
2297         if (aip->goal_objnum == -1) {
2298                 Int3(); //      Shouldn't happen, but let's recover gracefully.
2299                 return 0;
2300         }
2301
2302         other_objp = &Objects[aip->goal_objnum];
2303
2304         vm_vec_sub(&rel_vel, &support_objp->phys_info.vel, &other_objp->phys_info.vel);
2305         rel_speed = vm_vec_mag_quick(&rel_vel);
2306
2307         dist = vm_vec_dist_quick(&other_objp->pos, &support_objp->pos);
2308
2309         support_speed = support_objp->phys_info.speed;
2310
2311         if ( rel_speed <= support_speed/2.0f) { //      This means the player is moving away fast from the support ship.
2312                 return (int) (dist/support_speed);
2313         } else {
2314                 float   d1;
2315                 float   d = dist;
2316                 float   time = 0.0f;
2317
2318                 if (rel_speed < 20.0f)
2319                         rel_speed = 20.0f;
2320
2321                 //      When faraway, use max speed, not current speed.  Might not have sped up yet.
2322                 if (d > 100.0f) {
2323                         time += (d - 100.0f)/support_objp->phys_info.max_vel.xyz.z;
2324                 }
2325
2326                 //      For mid-range, use current speed.
2327                 if (d > 60.0f) {
2328                         d1 = min(d, 100.0f);
2329
2330                         time += (d1 - 60.0f)/rel_speed;
2331                 }
2332
2333                 //      For nearby, ship will have to slow down a bit for docking maneuver.
2334                 if (d > 30.0f) {
2335                         d1 = min(d, 60.0f);
2336
2337                         time += (d1 - 30.0f)/5.0f;
2338                 }
2339
2340                 //      For very nearby, ship moves quite slowly.
2341                 d1 = min(d, 30.0f);
2342                 time += d1/7.5f;
2343
2344                 return fl2i(time);
2345         }
2346 }
2347
2348 // Locate the closest support ship which is trying to dock with player, return -1 if there is no support
2349 // ship currently trying to dock with the player
2350 // MA:  4/22/98 -- pass in objp to find support ship trying to dock with objp
2351 int hud_support_find_closest( int objnum )
2352 {
2353         ship_obj                *sop;
2354         ai_info         *aip;
2355         object          *objp;
2356         int i;
2357
2358         objp = &Objects[objnum];
2359
2360         sop = GET_FIRST(&Ship_obj_list);
2361         while(sop != END_OF_LIST(&Ship_obj_list)){
2362                 if ( Ship_info[Ships[Objects[sop->objnum].instance].ship_info_index].flags & SIF_SUPPORT ) {
2363                         int pship_index, sindex;
2364
2365                         // make sure support ship is not dying
2366                         if ( !(Ships[Objects[sop->objnum].instance].flags & (SF_DYING|SF_EXPLODED)) ) {
2367
2368                                 Assert( objp->type == OBJ_SHIP );
2369                                 aip = &Ai_info[Ships[Objects[sop->objnum].instance].ai_index];
2370                                 pship_index = objp->instance;
2371
2372                                 // we must check all goals for this support ship -- not just the first one
2373                                 for ( i = 0; i < MAX_AI_GOALS; i++ ) {
2374
2375                                         // we can use == in the next statement (and should) since a ship will only ever be
2376                                         // following one order at a time.
2377                                         if ( aip->goals[i].ai_mode == AI_GOAL_REARM_REPAIR ) {
2378                                                 Assert( aip->goals[i].ship_name );
2379                                                 sindex = ship_name_lookup( aip->goals[i].ship_name );
2380                                                 if ( sindex == pship_index )
2381                                                         return sop->objnum;
2382                                         }
2383                                 }
2384                         }
2385                 }
2386                 sop = GET_NEXT(sop);
2387         }
2388
2389         return -1;
2390 }
2391
2392 // dipaly the hud_support view popup
2393 void hud_support_view_blit()
2394 {
2395         int     show_time;
2396         char    outstr[64];
2397
2398         if ( !Hud_support_view_active ) {
2399                 return;
2400         }
2401
2402         // don't render this gauge for multiplayer observers
2403         if((Game_mode & GM_MULTIPLAYER) && ((Net_player->flags & NETINFO_FLAG_OBSERVER) || (Player_obj->type == OBJ_OBSERVER))){
2404                 return;
2405         }
2406
2407         // If we haven't determined yet who the rearm ship is, try to!
2408         if (Hud_support_objnum == -1) {
2409                 Hud_support_objnum = hud_support_find_closest( OBJ_INDEX(Player_obj) );
2410                 if ( Hud_support_objnum >= 0 ) {
2411                         Hud_support_obj_sig = Objects[Hud_support_objnum].signature;
2412                         Hud_support_target_sig = Player_obj->signature;
2413                 }
2414         } else {
2415                 // check to see if support ship is still alive
2416                 if ( (Objects[Hud_support_objnum].signature != Hud_support_obj_sig) || (Hud_support_target_sig != Player_obj->signature) ) {
2417                         hud_support_view_stop(1);
2418                         return;
2419                 }
2420         }
2421
2422         // set hud color
2423         hud_set_gauge_color(HUD_SUPPORT_GAUGE);
2424
2425         GR_AABITMAP(Support_view_gauge.first_frame, Support_view_coords[gr_screen.res][0], Support_view_coords[gr_screen.res][1]);
2426
2427         gr_string(Support_text_coords[gr_screen.res][0], Support_text_coords[gr_screen.res][1], XSTR( "support", 224));
2428
2429         if ( Hud_support_view_fade > 1 ) {
2430                 if ( !timestamp_elapsed(Hud_support_view_fade) ) {
2431                         if ( Hud_support_view_abort){
2432                                 gr_string(0x8000, Support_text_val_coords[gr_screen.res][1], XSTR( "aborted", 225));
2433                         } else {
2434                                 gr_string(0x8000, Support_text_val_coords[gr_screen.res][1], XSTR( "complete", 1407));
2435                         }
2436                         return;
2437                 } else {
2438                         Hud_support_view_abort = 0;
2439                         Hud_support_view_active = 0;
2440                         Hud_support_view_fade = 1;
2441                         Hud_support_objnum = -1;
2442                         return;
2443                 }
2444         }
2445
2446         show_time = 0;
2447         if ( Player_ai->ai_flags & AIF_BEING_REPAIRED ) {
2448                 Assert(Ship_info[Player_ship->ship_info_index].initial_hull_strength > 0);
2449                 if (  (ship_get_subsystem_strength(Player_ship, SUBSYSTEM_ENGINE) < 1.0 ) ||
2450                                 (ship_get_subsystem_strength(Player_ship, SUBSYSTEM_SENSORS) < 1.0 ) ||
2451                                 (ship_get_subsystem_strength(Player_ship, SUBSYSTEM_WEAPONS) < 1.0 ) ||
2452                                 (ship_get_subsystem_strength(Player_ship, SUBSYSTEM_COMMUNICATION) < 1.0 ) ) {
2453                         strcpy(outstr, XSTR( "repairing", 227));
2454                 } else {
2455                         strcpy(outstr, XSTR( "rearming", 228));
2456                 }
2457                 gr_string(0x8000, Support_text_val_coords[gr_screen.res][1], outstr);
2458         } else if (Player_ai->ai_flags & AIF_REPAIR_OBSTRUCTED) {
2459                 strcpy(outstr, XSTR( "obstructed", 229));
2460                 gr_string(0x8000, Support_text_val_coords[gr_screen.res][1], outstr);
2461         } else {
2462                 if ( Hud_support_objnum == -1 ) {
2463                         strcpy(outstr, XSTR( "warping in", 230));
2464                         gr_string(0x8000, Support_text_val_coords[gr_screen.res][1], outstr);
2465                 } else {
2466                         ai_info *aip;
2467
2468                         // display "busy" when support ship isn't actually enroute to me
2469                         aip = &Ai_info[Ships[Objects[Hud_support_objnum].instance].ai_index];
2470                         if ( aip->goal_objnum != OBJ_INDEX(Player_obj) ) {
2471                                 strcpy(outstr, XSTR( "busy", 231));
2472                                 show_time = 0;
2473
2474                         } else {
2475                                 strcpy(outstr, XSTR( "dock in:", 232));
2476                                 show_time = 1;
2477                         }
2478
2479                         if (!show_time) {
2480                                 gr_string(Support_text_dock_coords[gr_screen.res][0], Support_text_val_coords[gr_screen.res][1], outstr);
2481                         } else {
2482                                 gr_string(Support_text_dock_coords[gr_screen.res][0], Support_text_val_coords[gr_screen.res][1], outstr);
2483                         }
2484                 }
2485         }
2486
2487         if ( show_time ) {
2488                 int seconds, minutes;
2489
2490                 Assert( Hud_support_objnum != -1 );
2491
2492                 // ensure support ship is still alive
2493                 if ( (Objects[Hud_support_objnum].signature != Hud_support_obj_sig) || (Hud_support_target_sig != Player_obj->signature) ) {
2494                         hud_support_view_stop(1);
2495                         seconds = 0;
2496                 } else {
2497                         seconds = hud_support_get_dock_time( Hud_support_objnum );
2498                 }
2499
2500                 if ( seconds >= 0 ) {
2501                         minutes = seconds/60;
2502                         seconds = seconds%60;
2503                         if ( minutes > 99 ) {
2504                                 minutes = 99;
2505                                 seconds = 99;
2506                         }
2507                 } else {
2508                         minutes = 99;
2509                         seconds = 99;
2510                 }
2511                 gr_printf(Support_text_dock_val_coords[gr_screen.res][0], Support_text_val_coords[gr_screen.res][1], NOX("%02d:%02d"), minutes, seconds);
2512         }
2513 }
2514
2515 // Set the current color to the default HUD color (with default alpha)
2516 void hud_set_default_color()
2517 {
2518         Assert(HUD_color_alpha >= 0 && HUD_color_alpha < HUD_NUM_COLOR_LEVELS);
2519         gr_set_color_fast(&HUD_color_defaults[HUD_color_alpha]);
2520 }
2521
2522 // Set the current color to a bright HUD color (ie high alpha)
2523 void hud_set_bright_color()
2524 {
2525         int alpha_color;
2526         alpha_color = min(HUD_COLOR_ALPHA_MAX,HUD_color_alpha+HUD_BRIGHT_DELTA);
2527         gr_set_color_fast(&HUD_color_defaults[alpha_color]);
2528 }
2529
2530 // Set the current color to a dim HUD color (ie low alpha)
2531 void hud_set_dim_color()
2532 {
2533         if ( HUD_color_alpha > 2 ) {
2534                 gr_set_color_fast(&HUD_color_defaults[2]);
2535         }
2536 }
2537
2538 // hud_set_iff_color() will set the color to the IFF color based on the team
2539 //
2540 // input:       team                    =>              team to base color on
2541 //                              is_bright       =>              default parameter (value 0) which uses bright version of IFF color
2542 void hud_set_iff_color(object *objp, int is_bright)
2543 {
2544         // AL 12-26-97: it seems IFF color needs to be set relative to the player team.  If
2545         //                                              the team in question is the same as the player, then it should be
2546         //                                              drawn friendly.  If the team is different than the players, then draw the
2547         //                                              appropriate IFF.
2548         int team;
2549         team = obj_team(objp);
2550
2551         if ( ship_is_tagged(objp) ) {
2552                 gr_set_color_fast(&IFF_colors[IFF_COLOR_TAGGED][is_bright]);
2553         } else if ( (team == Player_ship->team) && (Player_ship->team != TEAM_TRAITOR) ) {
2554                 gr_set_color_fast(&IFF_colors[IFF_COLOR_FRIENDLY][is_bright]);
2555         } else {
2556                 switch (team) {
2557                 case TEAM_NEUTRAL:
2558                         gr_set_color_fast(&IFF_colors[IFF_COLOR_NEUTRAL][is_bright]);
2559                         break;
2560                 case TEAM_UNKNOWN:
2561                         gr_set_color_fast(&IFF_colors[IFF_COLOR_UNKNOWN][is_bright]);
2562                         break;
2563                 case TEAM_HOSTILE:
2564                 case TEAM_FRIENDLY:
2565                 case TEAM_TRAITOR:
2566                         gr_set_color_fast(&IFF_colors[IFF_COLOR_HOSTILE][is_bright]);
2567                         break;
2568                 default:
2569                         Int3();
2570                         gr_set_color_fast(&IFF_colors[IFF_COLOR_UNKNOWN][is_bright]);
2571                         break;
2572                 }
2573         }
2574 }
2575
2576 // Determine if ship team should be ignored, based on
2577 // team filter
2578 // input:       team_filter     =>      team mask used to select friendly or hostile ships
2579 //                              ship_team       =>      team of the ship in question
2580 // exit:                1                               =>      ship_team matches filter from player perspective
2581 //                              0                               =>      ship_team does match team filter
2582 int hud_team_matches_filter(int team_filter, int ship_team)
2583 {
2584         return team_filter & ship_team;
2585 }
2586
2587
2588 // reset gauge flashing data
2589 void hud_gauge_flash_init()
2590 {
2591         int i;
2592         for ( i=0; i<NUM_HUD_GAUGES; i++ ) {
2593                 HUD_gauge_flash_duration[i]=timestamp(0);
2594                 HUD_gauge_flash_next[i]=timestamp(0);
2595         }
2596         HUD_gauge_bright=0;
2597 }
2598
2599 #define NUM_VM_OTHER_SHIP_GAUGES 5
2600 static int Vm_other_ship_gauges[NUM_VM_OTHER_SHIP_GAUGES] =
2601 {
2602         HUD_CENTER_RETICLE,
2603         HUD_TARGET_MONITOR,
2604         HUD_TARGET_MONITOR_EXTRA_DATA,
2605         HUD_MESSAGE_LINES,
2606         HUD_TALKING_HEAD
2607 };
2608
2609 // determine if the specified HUD gauge should be displayed
2610 int hud_gauge_active(int gauge_index)
2611 {
2612         Assert(gauge_index >=0 && gauge_index < NUM_HUD_GAUGES);
2613
2614         // AL: Special code: Only show two gauges when not viewing from own ship
2615         if ( Viewer_mode & VM_OTHER_SHIP ) {
2616                 for ( int i = 0; i < NUM_VM_OTHER_SHIP_GAUGES; i++ ) {
2617                         if ( gauge_index == Vm_other_ship_gauges[i] ) {
2618                                 return 1;
2619                         }
2620                 }
2621                 return 0;
2622         }
2623
2624         return hud_config_show_flag_is_set(gauge_index);
2625 }
2626
2627 // determine if gauge is in pop-up mode or not
2628 int hud_gauge_is_popup(int gauge_index)
2629 {
2630         Assert(gauge_index >=0 && gauge_index < NUM_HUD_GAUGES);
2631         return hud_config_popup_flag_is_set(gauge_index);
2632 }
2633
2634 // determine if a popup gauge should be drawn
2635 int hud_gauge_popup_active(int gauge_index)
2636 {
2637         Assert(gauge_index >=0 && gauge_index < NUM_HUD_GAUGES);
2638         if ( !hud_gauge_is_popup(gauge_index) ) {
2639                 return 0;
2640         }
2641
2642         if ( !timestamp_elapsed(HUD_popup_timers[gauge_index]) ) {
2643                 return 1;
2644         } else {
2645                 return 0;
2646         }
2647 }
2648
2649 // start a gauge to popup
2650 void hud_gauge_popup_start(int gauge_index, int time)
2651 {
2652         Assert(gauge_index >=0 && gauge_index < NUM_HUD_GAUGES);
2653         if ( !hud_gauge_is_popup(gauge_index) ) {
2654                 return;
2655         }
2656
2657         HUD_popup_timers[gauge_index] = timestamp(time);
2658
2659 }
2660
2661 // call HUD function to flash gauge
2662 void hud_gauge_start_flash(int gauge_index)
2663 {
2664         Assert(gauge_index >=0 && gauge_index < NUM_HUD_GAUGES);
2665         HUD_gauge_flash_duration[gauge_index] = timestamp(HUD_GAUGE_FLASH_DURATION);
2666         HUD_gauge_flash_next[gauge_index] = 1;
2667 }
2668
2669 // Set the HUD color for the gauge, based on whether it is flashing or not
2670 void hud_set_gauge_color(int gauge_index, int bright_index)
2671 {
2672         color use_color;
2673         int flash_status = hud_gauge_maybe_flash(gauge_index);
2674         use_color = HUD_config.clr[gauge_index];
2675         int alpha;
2676
2677         // if we're drawing it as bright
2678         if(bright_index != HUD_C_NONE){
2679                 switch(bright_index){
2680                 case HUD_C_DIM:
2681                         alpha = HUD_contrast ? HUD_NEW_ALPHA_DIM_HI : HUD_NEW_ALPHA_DIM;
2682                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2683                         break;
2684
2685                 case HUD_C_NORMAL:
2686                         alpha = HUD_contrast ? HUD_NEW_ALPHA_NORMAL_HI : HUD_NEW_ALPHA_NORMAL;
2687                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2688                         break;
2689
2690                 case HUD_C_BRIGHT:
2691                         alpha = HUD_contrast ? HUD_NEW_ALPHA_BRIGHT_HI : HUD_NEW_ALPHA_BRIGHT;
2692                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2693                         break;
2694
2695                 // intensity
2696                 default:
2697                         Assert((bright_index >= 0) && (bright_index < HUD_NUM_COLOR_LEVELS));
2698                         if(bright_index < 0){
2699                                 bright_index = 0;
2700                         }
2701                         if(bright_index >= HUD_NUM_COLOR_LEVELS){
2702                                 bright_index = HUD_NUM_COLOR_LEVELS - 1;
2703                         }
2704
2705                         // alpha = 255 - (255 / (bright_index + 1));
2706                         // alpha = (int)((float)alpha * 1.5f);
2707                         int level = 255 / (HUD_NUM_COLOR_LEVELS);
2708                         alpha = level * bright_index;
2709                         if(alpha > 255){
2710                                 alpha = 255;
2711                         }
2712                         if(alpha < 0){
2713                                 alpha = 0;
2714                         }
2715                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2716                         break;
2717                 }
2718         } else {
2719                 switch(flash_status) {
2720                 case 0:
2721                         alpha = HUD_contrast ? HUD_NEW_ALPHA_DIM_HI : HUD_NEW_ALPHA_DIM;
2722                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2723                         break;
2724                 case 1:
2725                         alpha = HUD_contrast ? HUD_NEW_ALPHA_BRIGHT_HI : HUD_NEW_ALPHA_BRIGHT;
2726                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2727                         break;
2728                 default:
2729                         alpha = HUD_contrast ? HUD_NEW_ALPHA_NORMAL_HI : HUD_NEW_ALPHA_NORMAL;
2730                         gr_init_alphacolor(&use_color, use_color.red, use_color.green, use_color.blue, alpha, AC_TYPE_HUD);
2731                         break;
2732                 }
2733         }
2734
2735         gr_set_color_fast(&use_color);
2736 }
2737
2738 // set the color for a gauge that may be flashing
2739 // exit:        -1      =>      gauge is not flashing
2740 //                      0       =>      gauge is flashing, draw dim
2741 //                      1       =>      gauge is flashing, draw bright
2742 int hud_gauge_maybe_flash(int gauge_index)
2743 {
2744         Assert(gauge_index >=0 && gauge_index < NUM_HUD_GAUGES);
2745         int flash_status=-1;
2746         if ( !timestamp_elapsed(HUD_gauge_flash_duration[gauge_index]) ) {
2747                 if ( timestamp_elapsed(HUD_gauge_flash_next[gauge_index]) ) {
2748                         HUD_gauge_flash_next[gauge_index] = timestamp(HUD_GAUGE_FLASH_INTERVAL);
2749                         HUD_gauge_bright ^= (1<<gauge_index);   // toggle between default and bright frames
2750                 }
2751
2752                 if ( HUD_gauge_bright & (1<<gauge_index) ) {
2753                         flash_status=1;
2754                 } else {
2755                         flash_status=0;
2756                 }
2757         }
2758         return flash_status;
2759 }
2760
2761 // Init the objective message display data
2762 void hud_objective_message_init()
2763 {
2764         // ensure the talking head border is loaded
2765         if ( !Objective_display_gauge_inited ) {
2766                 Objective_display_gauge.first_frame = bm_load_animation(Objective_fname[gr_screen.res], &Objective_display_gauge.num_frames);
2767                 if ( Objective_display_gauge.first_frame == -1 ) {
2768                         Warning(LOCATION, "Could not load in ani: Objective_fname[gr_screen.res]\n");
2769                 }
2770                 Objective_display_gauge_inited = 1;
2771         }
2772
2773         Objective_display.display_timer=timestamp(0);
2774 }
2775
2776 // Display objective status on the HUD
2777 // input:       type                    =>      type of goal, one of:   PRIMARY_GOAL
2778 //                                                                                                                                      SECONDARY_GOAL
2779 //                                                                                                                                      BONUS_GOAL
2780 //
2781 //                              status          => status of goal, one of:      GOAL_FAILED
2782 //                                                                                                                                      GOAL_COMPLETE
2783 //                                                                                                                                      GOAL_INCOMPLETE
2784 //
2785 void hud_add_objective_messsage(int type, int status)
2786 {
2787         Objective_display.display_timer=timestamp(7000);
2788         Objective_display.goal_type=type;
2789         Objective_display.goal_status=status;
2790
2791         // if this is a multiplayer tvt game
2792         if((Game_mode & GM_MULTIPLAYER) && (Netgame.type_flags & NG_TYPE_TEAM) && (Net_player != NULL)){
2793                 mission_goal_fetch_num_resolved(type, &Objective_display.goal_nresolved, &Objective_display.goal_ntotal, Net_player->p_info.team);
2794         } else {
2795                 mission_goal_fetch_num_resolved(type, &Objective_display.goal_nresolved, &Objective_display.goal_ntotal);
2796         }
2797
2798         // TODO: play a sound?
2799 }
2800
2801 // maybe display the 'subspace drive engaged' message
2802 void hud_maybe_display_subspace_notify()
2803 {
2804         int warp_aborted = 0;
2805         // maybe make gauge active
2806         if ( (Player->control_mode == PCM_WARPOUT_STAGE1) || (Player->control_mode == PCM_WARPOUT_STAGE2) || (Player->control_mode == PCM_WARPOUT_STAGE3) ) {
2807                 if (!hud_subspace_notify_active()) {
2808                         // keep sound from being played 1e06 times
2809                         hud_start_subspace_notify();
2810                 }
2811         } else {
2812                 if ( !timestamp_elapsed(HUD_abort_subspace_timer) ) {
2813                         warp_aborted = 1;
2814                 } else {
2815                         hud_stop_subspace_notify();
2816                 }
2817         }
2818
2819         if ( !hud_subspace_notify_active() ) {
2820                 return;
2821         }
2822
2823         if ( Objective_display_gauge.first_frame < 0 ) {
2824                 return;
2825         }
2826
2827         // blit the background
2828         hud_set_gauge_color(HUD_OBJECTIVES_NOTIFY_GAUGE);
2829         GR_AABITMAP(Objective_display_gauge.first_frame, Objective_display_coords[gr_screen.res][0], Objective_display_coords[gr_screen.res][1]);
2830
2831         hud_targetbox_start_flash(TBOX_FLASH_OBJECTIVE);
2832         if(hud_targetbox_maybe_flash(TBOX_FLASH_OBJECTIVE)){
2833                 hud_set_gauge_color(HUD_OBJECTIVES_NOTIFY_GAUGE, HUD_C_BRIGHT);
2834         } else {
2835                 hud_set_gauge_color(HUD_OBJECTIVES_NOTIFY_GAUGE);
2836         }
2837
2838
2839         gr_string(0x8000, Subspace_text_coords[gr_screen.res][1],XSTR( "subspace drive", 233));
2840         if ( warp_aborted ) {
2841                 gr_string(0x8000, Subspace_text_val_coords[gr_screen.res][1],XSTR( "aborted", 225));
2842         } else {
2843                 gr_string(0x8000, Subspace_text_val_coords[gr_screen.res][1],XSTR( "engaged", 234));
2844         }
2845 }
2846
2847 // maybe display the 'Downloading new orders' message
2848 void hud_maybe_display_red_alert()
2849 {
2850         if ( !red_alert_check_status() ) {
2851                 return;
2852         }
2853
2854         if ( Objective_display_gauge.first_frame < 0 ) {
2855                 return;
2856         }
2857
2858         if ( hud_subspace_notify_active() ) {
2859                 return;
2860         }
2861
2862         if ( hud_objective_notify_active() ) {
2863                 return;
2864         }
2865
2866         // blit the background
2867         gr_set_color_fast(&Color_red);          // color box red, cuz its an emergency for cryin out loud
2868
2869         GR_AABITMAP(Objective_display_gauge.first_frame, Objective_display_coords[gr_screen.res][0], Objective_display_coords[gr_screen.res][1]);
2870
2871         hud_targetbox_start_flash(TBOX_FLASH_OBJECTIVE);
2872         if(hud_targetbox_maybe_flash(TBOX_FLASH_OBJECTIVE)) {
2873                 gr_set_color_fast(&Color_red);
2874         } else {
2875                 gr_set_color_fast(&Color_bright_red);
2876         }
2877
2878         gr_string(0x8000, Red_text_coords[gr_screen.res][1], XSTR( "downloading new", 235));
2879         gr_string(0x8000, Red_text_val_coords[gr_screen.res][1], XSTR( "orders...", 236));
2880
2881         // TODO: play a sound?
2882 }
2883
2884 // Maybe show an objective status update on the HUD
2885 void hud_maybe_display_objective_message()
2886 {
2887         char buf[128];
2888
2889         if ( timestamp_elapsed(Objective_display.display_timer) ) {
2890                 hud_stop_objective_notify();
2891                 return;
2892         }
2893
2894         if ( Objective_display_gauge.first_frame < 0 ) {
2895                 return;
2896         }
2897
2898         if ( hud_subspace_notify_active() ) {
2899                 return;
2900         }
2901
2902         if (!hud_objective_notify_active()) {
2903                 hud_start_objective_notify();
2904         }
2905
2906         // blit the background
2907         hud_set_gauge_color(HUD_OBJECTIVES_NOTIFY_GAUGE);
2908         GR_AABITMAP(Objective_display_gauge.first_frame, Objective_display_coords[gr_screen.res][0], Objective_display_coords[gr_screen.res][1]);
2909
2910         hud_targetbox_start_flash(TBOX_FLASH_OBJECTIVE);
2911         if(hud_targetbox_maybe_flash(TBOX_FLASH_OBJECTIVE)){
2912                 hud_set_gauge_color(HUD_OBJECTIVES_NOTIFY_GAUGE, HUD_C_BRIGHT);
2913         } else {
2914                 hud_set_gauge_color(HUD_OBJECTIVES_NOTIFY_GAUGE);
2915         }
2916
2917         // draw the correct goal type
2918         switch(Objective_display.goal_type) {
2919         case PRIMARY_GOAL:
2920                 gr_string(0x8000, Objective_text_coords[gr_screen.res][1],XSTR( "primary objective", 237));
2921                 break;
2922         case SECONDARY_GOAL:
2923                 gr_string(0x8000, Objective_text_coords[gr_screen.res][1],XSTR( "secondary objective", 238));
2924                 break;
2925         case BONUS_GOAL:
2926                 gr_string(0x8000, Objective_text_coords[gr_screen.res][1],XSTR( "bonus objective", 239));
2927                 break;
2928         }
2929
2930         // show the status
2931         switch(Objective_display.goal_type) {
2932         case PRIMARY_GOAL:
2933         case SECONDARY_GOAL:
2934                 switch(Objective_display.goal_status) {
2935                 case GOAL_FAILED:
2936                         sprintf(buf, XSTR( "failed (%d/%d)", 240), Objective_display.goal_nresolved, Objective_display.goal_ntotal);
2937                         gr_string(0x8000, Objective_text_val_coords[gr_screen.res][1], buf);
2938                         break;
2939                 default:
2940                         sprintf(buf, XSTR( "complete (%d/%d)", 241), Objective_display.goal_nresolved, Objective_display.goal_ntotal);
2941                         gr_string(0x8000, Objective_text_val_coords[gr_screen.res][1], buf);
2942                         break;
2943                 }
2944                 break;
2945         case BONUS_GOAL:
2946                 switch(Objective_display.goal_status) {
2947                 case GOAL_FAILED:
2948                         gr_string(0x8000, Objective_text_val_coords[gr_screen.res][1], XSTR( "failed", 242));
2949                         break;
2950                 default:
2951                         gr_string(0x8000, Objective_text_val_coords[gr_screen.res][1], XSTR( "complete", 226));
2952                         break;
2953                 }
2954                 break;
2955         }
2956 }
2957
2958 // return wing slot (0->3) based on name of ship.  Assumes ship is from Alpha,Beta, or
2959 // Gamma wings
2960 int hud_wing_slot_from_name(const char *name)
2961 {
2962         int     rval;
2963         char    num[2];
2964
2965         num[0]=name[strlen(name)-1];
2966         num[1]=0;
2967
2968         rval = num[0] - '1';
2969         Assert(rval >= 0 && rval < 4);
2970         return rval;
2971 }
2972
2973 // return index in starting wings (0->11) for specified ship.
2974 int hud_wing_index_from_ship(int shipnum)
2975 {
2976         int     i;
2977         ship    *shipp;
2978
2979         shipp = &Ships[shipnum];
2980
2981         int wing_num=0, wing_slot=0;
2982
2983         for (i=0; i<3; i++) {
2984                 if ( Starting_wings[i] < 0 ) {
2985                         continue;
2986                 }
2987
2988                 if (shipp->wingnum == Starting_wings[i]) {
2989                         wing_num=i;
2990                         break;
2991                 }
2992         }
2993
2994         if ( i==3 ) {
2995                 Int3();
2996         }
2997
2998         wing_slot = hud_wing_slot_from_name(shipp->ship_name);
2999         return (i*4+wing_slot);
3000 }
3001
3002 void hud_show_voice_status()
3003 {
3004         char play_callsign[CALLSIGN_LEN+5];
3005
3006         // if we are currently playing a rtvoice sound stream from another player back
3007         memset(play_callsign,0,CALLSIGN_LEN+5);
3008         switch(multi_voice_status()){
3009         // the player has been denied the voice token
3010         case MULTI_VOICE_STATUS_DENIED:
3011                 // show a red indicator or something
3012                 gr_string(Voice_coords[gr_screen.res][0], Voice_coords[gr_screen.res][1], XSTR( "[voice denied]", 243));
3013                 break;
3014
3015         // the player is currently recording
3016         case MULTI_VOICE_STATUS_RECORDING:
3017                 gr_string(Voice_coords[gr_screen.res][0], Voice_coords[gr_screen.res][1], XSTR( "[recording voice]", 244));
3018                 break;
3019
3020         // the player is current playing back voice from someone
3021         case MULTI_VOICE_STATUS_PLAYING:
3022                 gr_string(Voice_coords[gr_screen.res][0], Voice_coords[gr_screen.res][1], XSTR( "[playing voice]", 245));
3023                 break;
3024
3025         // nothing voice related is happening on my machine
3026         case MULTI_VOICE_STATUS_IDLE:
3027                 // probably shouldn't be displaying anything
3028                 break;
3029         }
3030 }
3031
3032 void hud_subspace_notify_abort()
3033 {
3034         HUD_abort_subspace_timer = timestamp(1500);
3035 }
3036
3037 void hud_stop_subspace_notify()
3038 {
3039         Subspace_notify_active=0;
3040 }
3041
3042 void hud_start_subspace_notify()
3043 {
3044
3045         Subspace_notify_active=1;
3046 }
3047
3048 int hud_subspace_notify_active()
3049 {
3050         return Subspace_notify_active;
3051 }
3052
3053 void hud_stop_objective_notify()
3054 {
3055         Objective_notify_active = 0;
3056 }
3057
3058 void hud_start_objective_notify()
3059 {
3060         snd_play(&(Snds[SND_DIRECTIVE_COMPLETE]));
3061         Objective_notify_active = 1;
3062 }
3063
3064 int hud_objective_notify_active()
3065 {
3066         return Objective_notify_active;
3067 }
3068
3069 // render multiplayer text message currently being entered if any
3070 void hud_maybe_render_multi_text()
3071 {
3072         char txt[MULTI_MSG_MAX_TEXT_LEN+20];
3073
3074         // clear the text
3075         memset(txt,0,MULTI_MSG_MAX_TEXT_LEN+1);
3076
3077         // if there is valid multiplayer message text to be displayed
3078         if(multi_msg_message_text(txt)){
3079                 gr_set_color_fast(&Color_normal);
3080                 gr_string(Multi_msg_coords[gr_screen.res][0], Multi_msg_coords[gr_screen.res][1], txt);
3081         }
3082 }
3083
3084 // cut any text off after (and including) '#' char
3085 void hud_end_string_at_first_hash_symbol(char *src)
3086 {
3087         char *pointer_to_last_char;
3088
3089         pointer_to_last_char = strstr(src, NOX("#"));
3090
3091         if ( pointer_to_last_char ) {
3092                 *pointer_to_last_char = 0;
3093         }
3094 }
3095
3096 // set the offset values for this render frame
3097 void HUD_set_offsets(object *viewer_obj, int wiggedy_wack)
3098 {
3099         if ( (viewer_obj == Player_obj) && wiggedy_wack ){
3100                 vector tmp;
3101                 vertex pt;
3102                 ubyte flags;
3103
3104                 HUD_offset_x = 0.0f;
3105                 HUD_offset_y = 0.0f;
3106
3107                 vm_vec_scale_add( &tmp, &Viewer_obj->pos, &Viewer_obj->orient.v.fvec, 100.0f );
3108
3109                 flags = g3_rotate_vertex(&pt,&tmp);
3110
3111                 if (flags == 0) {
3112
3113                         g3_project_vertex(&pt);
3114
3115                         if (!(pt.flags & PF_OVERFLOW))  {
3116                                 HUD_offset_x -= 0.45f * (i2fl(gr_screen.clip_width)*0.5f - pt.sx);
3117                                 HUD_offset_y -= 0.45f * (i2fl(gr_screen.clip_height)*0.5f - pt.sy);
3118                         }
3119                 }
3120
3121                 if ( HUD_offset_x > 100.0f )    {
3122                         HUD_offset_x = 100.0f;
3123                 } else if ( HUD_offset_x < -100.0f )    {
3124                         HUD_offset_x += 100.0f;
3125                 }
3126
3127                 if ( HUD_offset_y > 100.0f )    {
3128                         HUD_offset_y = 100.0f;
3129                 } else if ( HUD_offset_y < -100.0f )    {
3130                         HUD_offset_y += 100.0f;
3131                 }
3132
3133         } else {
3134                 HUD_offset_x = 0.0f;
3135                 HUD_offset_y = 0.0f;
3136         }
3137 }
3138
3139 // Basically like gr_reset_clip only it accounts for hud jittering
3140 void HUD_reset_clip()
3141 {
3142         int hx = fl2i(HUD_offset_x);
3143         int hy = fl2i(HUD_offset_y);
3144
3145         gr_set_clip(hx, hy, gr_screen.max_w, gr_screen.max_h );
3146 }
3147
3148 // Basically like gr_set_clip only it accounts for hud jittering
3149 void HUD_set_clip(int x, int y, int w, int h)
3150 {
3151         int hx = fl2i(HUD_offset_x);
3152         int hy = fl2i(HUD_offset_y);
3153
3154         gr_set_clip(hx+x, hy+y, w, h );
3155 }
3156
3157 void hud_toggle_contrast()
3158 {
3159         HUD_contrast = !HUD_contrast;
3160 }
3161
3162 void hud_set_contrast(int high)
3163 {
3164         HUD_contrast = high;
3165 }
3166
3167 // Paging functions for the rest of the hud code
3168 extern void hudwingmanstatus_page_in();
3169 extern void hudescort_page_in();
3170 extern void hudets_page_in();
3171 extern void hudlock_page_in();
3172 extern void hudreticle_page_in();
3173 extern void hudshield_page_in();
3174 extern void hudsquadmsg_page_in();
3175 extern void hudtarget_page_in();
3176 extern void hudtargetbox_page_in();
3177
3178 // Page in all hud bitmaps
3179 void hud_page_in()
3180 {
3181         int i;
3182
3183         bm_page_in_aabitmap( Kills_gauge.first_frame, Kills_gauge.num_frames );
3184         bm_page_in_aabitmap( Head_frame_gauge.first_frame, Head_frame_gauge.num_frames );
3185         bm_page_in_aabitmap( Mission_time_gauge.first_frame, Mission_time_gauge.num_frames );
3186         for ( i = 0; i < NUM_DAMAGE_GAUGES; i++ ) {
3187                 bm_page_in_aabitmap( Damage_gauges[i].first_frame, Damage_gauges[i].num_frames);
3188         }
3189
3190         bm_page_in_aabitmap( Netlag_icon.first_frame, Netlag_icon.num_frames);
3191         bm_page_in_aabitmap( Support_view_gauge.first_frame, Support_view_gauge.num_frames);
3192         bm_page_in_aabitmap( Objective_display_gauge.first_frame, Objective_display_gauge.num_frames);
3193
3194         // Paging functions for the rest of the hud code
3195         hudwingmanstatus_page_in();
3196         hudescort_page_in();
3197         hudets_page_in();
3198         hudlock_page_in();
3199         hudreticle_page_in();
3200         hudshield_page_in();
3201         hudsquadmsg_page_in();
3202         hudtarget_page_in();
3203         hudtargetbox_page_in();
3204 }
3205