src/hud/hudsquadmsg.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/HUDsquadmsg.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * File to control sqaudmate messaging
  16  *
  17  * $Log$
  18  * Revision 1.5  2005/08/12 08:52:32  taylor
  19  * various GCC4 warning fixes
  20  *
  21  * Revision 1.4  2002/07/13 06:46:48  theoddone33
  22  * Warning cleanups
  23  *
  24  * Revision 1.3  2002/06/09 04:41:21  relnev
  25  * added copyright header
  26  *
  27  * Revision 1.2  2002/05/07 03:16:45  theoddone33
  28  * The Great Newline Fix
  29  *
  30  * Revision 1.1.1.1  2002/05/03 03:28:09  root
  31  * Initial import.
  32  *
  33  *
  34  * 16    9/06/99 10:45a Andsager
  35  * Add freighter to player override of protected status.
  36  *
  37  * 15    9/06/99 10:32a Andsager
  38  * Allow attack of protected fighter, bomber, freighters, by player's
  39  * orders.
  40  *
  41  * 14    8/26/99 8:51p Dave
  42  * Gave multiplayer TvT messaging a heavy dose of sanity. Cheat codes.
  43  *
  44  * 13    7/30/99 10:31p Dave
  45  * Added comm menu to the configurable hud files.
  46  *
  47  * 12    7/09/99 5:54p Dave
  48  * Seperated cruiser types into individual types. Added tons of new
  49  * briefing icons. Campaign screen.
  50  *
  51  * 11    6/16/99 10:20a Dave
  52  * Added send-message-list sexpression.
  53  *
  54  * 10    6/09/99 9:53a Andsager
  55  * 1st pass at grey menu items when no ships/wings/fighters accepting
  56  * orders.
  57  *
  58  * 9     4/23/99 12:01p Johnson
  59  * Added SIF_HUGE_SHIP
  60  *
  61  * 8     4/16/99 5:54p Dave
  62  * Support for on/off style "stream" weapons. Real early support for
  63  * target-painting lasers.
  64  *
  65  * 7     3/30/99 5:40p Dave
  66  * Fixed reinforcements for TvT in multiplayer.
  67  *
  68  * 6     3/28/99 5:58p Dave
  69  * Added early demo code. Make objects move. Nice and framerate
  70  * independant, but not much else. Don't use yet unless you're me :)
  71  *
  72  * 5     1/07/99 9:07a Jasen
  73  * HUD coords
  74  *
  75  * 4     12/28/98 3:17p Dave
  76  * Support for multiple hud bitmap filenames for hi-res mode.
  77  *
  78  * 3     12/21/98 5:02p Dave
  79  * Modified all hud elements to be multi-resolution friendly.
  80  *
  81  * 2     10/07/98 10:53a Dave
  82  * Initial checkin.
  83  *
  84  * 1     10/07/98 10:49a Dave
  85  *
  86  * 198   9/11/98 2:05p Allender
  87  * make reinforcements work correctly in multiplayer games.  There still
  88  * may be a team vs team issue that I haven't thought of yet :-(
  89  *
  90  * 197   8/28/98 3:28p Dave
  91  * EMP effect done. AI effects may need some tweaking as required.
  92  *
  93  * 196   8/25/98 1:48p Dave
  94  * First rev of EMP effect. Player side stuff basically done. Next comes
  95  * AI code.
  96  *
  97  * 195   6/30/98 2:17p Dave
  98  * Revised object update system. Removed updates for all weapons. Put
  99  * button info back into control info packet.
 100  *
 101  * 194   6/09/98 10:31a Hoffoss
 102  * Created index numbers for all xstr() references.  Any new xstr() stuff
 103  * added from here on out should be added to the end if the list.  The
 104  * current list count can be found in FreeSpace.cpp (search for
 105  * XSTR_SIZE).
 106  *
 107  * 193   5/26/98 11:54a Allender
 108  * fix multiplayer problems and sexpression crash
 109  *
 110  * 192   5/24/98 4:27p Allender
 111  * fix bug when determine who could message in multiplayer
 112  *
 113  * 191   5/23/98 2:34a Lawrance
 114  * Fix problems with HUD squad messaging, don't save/restore bindings
 115  *
 116  * 190   5/22/98 12:41a Allender
 117  * don't save/restore key presses in comm menu
 118  *
 119  * 189   5/21/98 9:38p Allender
 120  * don't save/clear key bindings
 121  *
 122  * 188   5/21/98 3:32p Allender
 123  * don't allow comm menu in observer mode
 124  *
 125  * 187   5/19/98 12:19p Mike
 126  * Cheat codes!
 127  *
 128  * 186   5/18/98 10:08a Lawrance
 129  * increase MSG_KEY_EAT_TIME to 300ms
 130  *
 131  * 185   5/18/98 12:41a Allender
 132  * fixed subsystem problems on clients (i.e. not reporting properly on
 133  * damage indicator).  Fixed ingame join problem with respawns.  minor
 134  * comm menu stuff
 135  *
 136  * 184   5/13/98 5:08p Allender
 137  * fix code in which sometimes wings wouldn't respond in multiplayer when
 138  * doing a message all fighters
 139  *
 140  * 183   5/08/98 4:38p Allender
 141  * always allow player ships to count when counting fighters for
 142  * messaging.  Terran command will now always issue the shooting at
 143  * friendlies message
 144  *
 145  * 182   5/08/98 2:11p Mike
 146  * Add "/Repair Subsys" to "Rearm" option in Comm menu.
 147  *
 148  * 181   5/06/98 2:57p Allender
 149  * always allow rearm ship to be called in
 150  *
 151  * 180   5/05/98 2:04a Mike
 152  * Fix bug in support ship code.
 153  *
 154  * 179   5/05/98 1:41a Mike
 155  * Improve support ship availability.
 156  *
 157  * 178   5/04/98 12:59a Allender
 158  * players who are traitors shouldn't be allowed to rearm or use messaging
 159  * shortcuts
 160  *
 161  * 177   5/04/98 12:39a Allender
 162  * make page up and page down only active when > 10 items on menu
 163  *
 164  * 176   4/29/98 10:56p Allender
 165  * don't allow shortcuts in mutliplayer when player cannot message (except
 166  * for rearm repair)
 167  *
 168  * 175   4/23/98 10:06a Allender
 169  * don't use the word "player" in event log for rearm event.  Send
 170  * shipname instead (players only)
 171  *
 172  * 174   4/23/98 9:15a Allender
 173  * make rearm shortcut work for clients
 174  *
 175  * 173   4/23/98 1:49a Allender
 176  * major rearm/repair fixes for multiplayer.  Fixed respawning of AI ships
 177  * to not respawn until 5 seconds after they die.  Send escort information
 178  * to ingame joiners
 179  *
 180  * 172   4/22/98 4:59p Allender
 181  * new multiplayer dead popup.  big changes to the comm menu system for
 182  * team vs. team.  Start of debriefing stuff for team vs. team  Make form
 183  * on my wing work with individual ships who have high priority orders
 184  *
 185  * 171   4/21/98 12:15a Allender
 186  * don't allow observers to use shortcut messaging keys
 187  *
 188  * 170   4/20/98 12:36a Mike
 189  * Make team vs. team work when player is hostile.  Several targeting
 190  * problems.
 191  *
 192  * 169   4/13/98 12:51p Allender
 193  * made countermeasure succeed indicator work in multiplayer.  Make rearm
 194  * shortcut work more appropriately.
 195  *
 196  * 168   4/10/98 2:42p Johnson
 197  * (from allender)  when sending wing command, don't assert if ship to
 198  * send message not found -- don't send message.  Allow rearm message
 199  * shortcut even if comm destroyed
 200  *
 201  * 167   4/10/98 2:39p Johnson
 202  *
 203  * 166   4/10/98 12:47p Allender
 204  * changed working on replay popup.  Don't reference repair in comm menu.
 205  * Added Shift-R for repair me
 206  *
 207  * 165   4/09/98 12:35p Allender
 208  * disallow messaging to departing wings and departing/dying ships
 209  *
 210  * 164   4/08/98 4:06p Allender
 211  * make selection of wing Player team based, not TEAM_FRIENDLY.
 212  *
 213  * 163   4/07/98 5:30p Lawrance
 214  * Player can't send/receive messages when comm is destroyed.  Garble
 215  * messages when comm is damaged.
 216  *
 217  * 162   4/07/98 1:53p Lawrance
 218  * Fix uninitialized data bug.
 219  *
 220  * 161   4/06/98 12:11a Allender
 221  * prevent the comm menu keys from being held over after menu goes away
 222  *
 223  * 160   4/05/98 3:06p Allender
 224  * don't allow ships/wings to act on orders which they shouldn't receive
 225  *
 226  * 159   4/03/98 12:17a Allender
 227  * new sexpression to detect departed or destroyed.  optionally disallow
 228  * support ships.  Allow docking with escape pods
 229  *
 230  * 158   4/02/98 5:50p Dave
 231  * Put in support for standard comm messages to get sent to netplayers as
 232  * well as ai ships. Make critical button presses not get evaluated on the
 233  * observer.
 234  *
 235  * $NoKeywords: $
 236 */
 237
 238
 239 #include "freespace.h"
 240 #include "2d.h"
 241 #include "hud.h"
 242 #include "ship.h"
 243 #include "player.h"
 244 #include "key.h"
 245 #include "hudtarget.h"
 246 #include "timer.h"
 247 #include "hudsquadmsg.h"
 248 #include "controlsconfig.h"
 249 #include "parselo.h"
 250 #include "aigoals.h"
 251 #include "missionparse.h"
 252 #include "sexp.h"
 253 #include "linklist.h"
 254 #include "missionlog.h"
 255 #include "missionmessage.h"
 256 #include "hudtarget.h"
 257 #include "gamesnd.h"
 258 #include "sound.h"
 259 #include "missionparse.h"
 260 #include "multimsgs.h"
 261 #include "multiutil.h"
 262 #include "bmpman.h"
 263 #include "hudtargetbox.h"
 264 #include "multi_pmsg.h"
 265 #include "subsysdamage.h"
 266 #include "emp.h"
 267
 268 // defines for different modes in the squad messaging system
 269
 270 #define SM_MODE_TYPE_SELECT                     1               //am I going to message a ship or a wing
 271 #define SM_MODE_SHIP_SELECT                     2               //choosing actual ship
 272 #define SM_MODE_WING_SELECT                     3               //choosing actual wing
 273 #define SM_MODE_SHIP_COMMAND                    4               //which command to send to a ship
 274 #define SM_MODE_WING_COMMAND                    5               //which command to send to a wing
 275 #define SM_MODE_REINFORCEMENTS          6               //call for reinforcements
 276 #define SM_MODE_REPAIR_REARM                    7               //repair/rearm player ship
 277 #define SM_MODE_REPAIR_REARM_ABORT      8               //abort repair/rearm of player ship
 278 #define SM_MODE_ALL_FIGHTERS                    9               //message all fighters/bombers
 279
 280 #define DEFAULT_MSG_TIMEOUT             (8 * 1000)              // number of seconds * 1000 to get milliseconds
 281 #define MSG_KEY_EAT_TIME                        (300)
 282
 283 LOCAL int Squad_msg_mode;                                                       // current mode that the messaging system is in
 284 LOCAL int Msg_key_used;                                                         // local variable which tells if the key being processed
 285                                                                                                                         // with the messaging system was actually used
 286 LOCAL int Msg_key;                                                                      // global which indicates which key was currently pressed
 287 LOCAL int Msg_mode_timestamp;
 288 LOCAL int Msg_instance;                                         // variable which holds ship/wing instance to send the message to
 289 LOCAL int Msg_shortcut_command;                 // holds command when using a shortcut key
 290 LOCAL int Msg_target_objnum;                            // id of the current target of the player
 291 LOCAL ship_subsys *Msg_targeted_subsys;// pointer to current subsystem which is targeted
 292 //#ifndef NDEBUG
 293 LOCAL   int Msg_enemies;                                                // tells us whether or not to message enemy ships or friendlies
 294 //#endif
 295
 296 LOCAL int Msg_eat_key_timestamp;                        // used to temporarily "eat" keys
 297
 298 // defined to position the messaging box
 299 int Mbox_item_h[GR_NUM_RESOLUTIONS] = {
 300         10,
 301         10
 302 };
 303 int Mbox_item_xoffset[GR_NUM_RESOLUTIONS] = {
 304         17,
 305         17
 306 };
 307
 308 // top of the message box gauge
 309 int Mbox_top_coords[GR_NUM_RESOLUTIONS][2] = {
 310         { // GR_640
 311                 445, 5
 312         },
 313         { // GR_1024
 314                 827, 5
 315         }
 316 };
 317
 318 int Mbox_bmap_coords[GR_NUM_RESOLUTIONS][2] = {
 319         { // GR_640
 320                 445, 17
 321         },
 322         { // GR_1024
 323                 827, 17
 324         }
 325 };
 326
 327 // squadmsg menu pgup and pgdn
 328 int Menu_pgup_coords[GR_NUM_RESOLUTIONS][2] = {
 329         { // GR_640
 330                 590, 9
 331         },
 332         { // GR_1024
 333                 937, 9
 334         }
 335 };
 336 int Menu_pgdn_coords[GR_NUM_RESOLUTIONS][2] = {
 337         { // GR_640
 338                 590, 120
 339         },
 340         { // GR_1024
 341                 937, 120
 342         }
 343 };
 344
 345 // -----------
 346 // following defines/vars are used to build menus that are used in messaging mode
 347
 348 typedef struct mmode_item {
 349         int     instance;                                       // instance in Ships/Wings array of this menu item
 350         int     active;                                         // active items are in bold text -- inactive items greyed out
 351         char    text[NAME_LENGTH];              // text to display on the menu
 352 } mmode_item;
 353
 354 #define MAX_MENU_ITEMS          50                              // max number of items in the menu
 355 #define MAX_MENU_DISPLAY        10                              // max number that can be displayed
 356
 357 mmode_item MsgItems[MAX_MENU_ITEMS];
 358 int Num_menu_items = -1;                                        // number of items for a message menu
 359 int First_menu_item= -1;                                                        // index of first item in the menu
 360
 361 // -----------
 362 // following set of vars/defines are used to store/restore key bindings for keys that
 363 // are used in messaging mode
 364
 365 // array to temporarily store key bindings that will be in use for the messaging
 366 // system
 367 typedef struct key_store {
 368         int     option_num;                                     // which element in the Control_config array is this
 369         int     id;                                                     // which id (1 or 2) is this key.
 370         int     key_value;                                      // which key value to put there.
 371 } key_store;
 372
 373 #define MAX_KEYS_NO_SCROLL      10
 374 #define MAX_KEYS_USED           12              // maximum number of keys used for the messaging system
 375
 376 key_store key_save[MAX_KEYS_USED];              // array to save the key information during messaging mode
 377 int num_keys_saved = 0;                                 // number of keys that are saved.
 378
 379 // next array is the array of MAX_KEYS_USED size which are the keys to use for messaging mode
 380
 381 int keys_used[] = {     SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6, SDLK_7, SDLK_8, SDLK_9, SDLK_0,
 382                                                         SDLK_PAGEUP, SDLK_PAGEDOWN  };
 383
 384 #define ID1             1
 385 #define ID2             2
 386
 387 // following are defines and character strings that are used as part of messaging mode
 388
 389 #define TYPE_SHIP_ITEM                                          0
 390 #define TYPE_WING_ITEM                                          1
 391 #define TYPE_ALL_FIGHTERS_ITEM                  2
 392 #define TYPE_REINFORCEMENT_ITEM                 3
 393 #define TYPE_REPAIR_REARM_ITEM                  4
 394 #define TYPE_REPAIR_REARM_ABORT_ITEM    5
 395
 396 #define NUM_TYPE_SELECT         6
 397
 398 const char *type_select_str(int n)
 399 {
 400         #if NUM_TYPE_SELECT != 6
 401         #error type_select_Str is not up to date
 402         #endif
 403
 404         switch(n)       {
 405         case TYPE_SHIP_ITEM:
 406                 return XSTR( "Ships", 293);
 407         case TYPE_WING_ITEM:
 408                 return XSTR( "Wings", 294);
 409         case TYPE_ALL_FIGHTERS_ITEM:
 410                 return XSTR( "All Fighters", 295);
 411         case TYPE_REINFORCEMENT_ITEM:
 412                 return XSTR( "Reinforcements", 296);
 413         case TYPE_REPAIR_REARM_ITEM:
 414                 return XSTR( "Rearm/Repair Subsys", 297);
 415         case TYPE_REPAIR_REARM_ABORT_ITEM:
 416                 return XSTR( "Abort Rearm", 298);
 417         }
 418
 419         return NULL;
 420 }
 421
 422 // data structure to hold character string of commands for comm menu
 423 typedef struct comm_order {
 424         int     value;                          // used to match which command to display on the menu
 425 } comm_order;
 426
 427 // note: If you change this table at all, keep it in sync with version in IgnoreOrdersDlg.cpp
 428 // Also make sure you update comm_order_menu_text below this.
 429 // Also make sure you update MAX_SHIP_ORDERS in HUDsquadmsg.h
 430 comm_order Comm_orders[MAX_SHIP_ORDERS] = {
 431         { ATTACK_TARGET_ITEM },
 432         { DISABLE_TARGET_ITEM },
 433         { DISARM_TARGET_ITEM },
 434         { DISABLE_SUBSYSTEM_ITEM },
 435         { PROTECT_TARGET_ITEM },
 436         { IGNORE_TARGET_ITEM },
 437         { FORMATION_ITEM },
 438         { COVER_ME_ITEM },
 439         { ENGAGE_ENEMY_ITEM },
 440         { CAPTURE_TARGET_ITEM },
 441         { REARM_REPAIR_ME_ITEM },
 442         { ABORT_REARM_REPAIR_ITEM },
 443         { DEPART_ITEM }
 444 };
 445
 446 // Text to display on the menu
 447 // Given an index into the Comm_orders array, return the text associated with it.
 448 // MUST BE 1:1 with Comm_orders.
 449 const char      *comm_order_menu_text(int index)
 450 {
 451         switch( index ) {
 452         case 0: return XSTR( "Destroy my target", 299); break;
 453         case 1: return XSTR( "Disable my target", 300); break;
 454         case 2: return XSTR( "Disarm my target", 301); break;
 455         case 3: return XSTR( "Destroy subsystem", 302); break;
 456         case 4: return XSTR( "Protect my target", 303); break;
 457         case 5: return XSTR( "Ignore my target", 304); break;
 458         case 6: return XSTR( "Form on my wing", 305); break;
 459         case 7: return XSTR( "Cover me", 306); break;
 460         case 8: return XSTR( "Engage enemy", 307); break;
 461         case 9: return XSTR( "Capture my target", 308); break;
 462         case 10: return XSTR( "Rearm me", 309); break;
 463         case 11: return XSTR( "Abort rearm", 310); break;
 464         case 12: return XSTR( "Depart", 311); break;
 465         default:
 466                 Assert(0);
 467         }
 468         return NULL;
 469 }
 470
 471 // Text to display on the messaging menu when using the shortcut keys
 472 const char *comm_order_hotkey_text( int index )
 473 {
 474         int i;
 475
 476         for (i = 0; i < MAX_SHIP_ORDERS; i++ ) {
 477                 if ( Comm_orders[i].value == index )
 478                         return comm_order_menu_text(i);
 479         }
 480
 481         Int3();
 482         return NULL;
 483 }
 484
 485 // a define of who can receive message
 486 #define CAN_MESSAGE     (SIF_FIGHTER | SIF_BOMBER | SIF_CRUISER | SIF_FREIGHTER | SIF_TRANSPORT | SIF_CAPITAL | SIF_SUPPORT | SIF_SUPERCAP | SIF_DRYDOCK | SIF_GAS_MINER | SIF_AWACS | SIF_CORVETTE)
 487
 488 int squadmsg_history_index = 0;
 489 squadmsg_history Squadmsg_history[SQUADMSG_HISTORY_MAX];
 490
 491 // used for Message box gauge
 492 #define NUM_MBOX_FRAMES         3
 493
 494 static hud_frames Mbox_gauge[NUM_MBOX_FRAMES];
 495 static int Mbox_frames_loaded = 0;
 496 static const char *Mbox_fnames[GR_NUM_RESOLUTIONS][NUM_MBOX_FRAMES] =
 497 {
 498 //XSTR:OFF
 499         { // GR_640
 500                 "message1",             // top part of menu
 501                 "message2",             // middle part
 502                 "message3"              // bottom part
 503         },
 504         { // GR_1024
 505                 "message1",             // top part of menu
 506                 "message2",             // middle part
 507                 "message3"              // bottom part
 508         }
 509 //XSTR:ON
 510 };
 511
 512 static int Mbox_title_coord[GR_NUM_RESOLUTIONS][2] = {
 513         { // GR_640
 514                 447, 6
 515         },
 516         { // GR_1024
 517                 829, 6
 518         }
 519 };
 520 static int Mbox_item_coord[GR_NUM_RESOLUTIONS][2] = {
 521         { // GR_640
 522                 449, 18
 523         },
 524         { // GR_1024
 525                 831, 18
 526         }
 527 };
 528
 529 // define for trapping messages send to "all fighters"
 530 #define MESSAGE_ALL_FIGHTERS            -999
 531
 532 // forward declarations
 533 void hud_add_issued_order(const char *name, int order, const char *target);
 534 int hud_squadmsg_is_target_order_valid(int order, int find_order, ai_info *aip = NULL );
 535 int hud_squadmsg_ship_order_valid( int shipnum, int order );
 536
 537 // function to set up variables needed when messaging mode is started
 538 void hud_squadmsg_start()
 539 {
 540 //      int i;
 541
 542         //if ( num_keys_saved < 0 )  // save the keys if they haven't been saved yet
 543         hud_squadmsg_save_keys();
 544
 545         Msg_key = -1;
 546
 547 /*
 548         for (i=0; i<num_keys_saved; i++)
 549                 clear_key_binding ( (short) key_save[i].key_value );                            // removes all mention of this key from Control_config
 550 */
 551
 552         Num_menu_items = -1;                                                                                                    // reset the menu items
 553         First_menu_item = 0;
 554         Squad_msg_mode = SM_MODE_TYPE_SELECT;                                                   // start off at the base state
 555         Msg_mode_timestamp = timestamp(DEFAULT_MSG_TIMEOUT);            // initialize our timer to bogus value
 556         Msg_shortcut_command = -1;                                                                                      // assume no shortcut key being used
 557         Msg_target_objnum = Player_ai->target_objnum;                           // save the players target object number
 558         Msg_targeted_subsys = Player_ai->targeted_subsys;                               // save the players currently targted subsystem
 559 #ifndef NDEBUG
 560         Msg_enemies = 0;                                                                                                                // tells us if we are messaging enemy ships
 561 #endif
 562
 563         snd_play( &Snds[SND_SQUADMSGING_ON] );
 564 }
 565
 566 // functions which will restore all of the key binding stuff when messaging mode is done
 567 void hud_squadmsg_end()
 568 {
 569 /*
 570         int i;
 571         key_store *ksp;
 572
 573         // move through all keys saved and restore their orignal values.
 574         for ( i=0; i<num_keys_saved; i++ ) {
 575                 ksp = &key_save[i];
 576                 Control_config[ksp->option_num].key_id = (short) ksp->key_value;
 577         }
 578 */
 579
 580         if ( message_is_playing() == FALSE )
 581                 snd_play( &Snds[SND_SQUADMSGING_OFF] );
 582 }
 583
 584 // function which returns true if there are fighters/bombers on the players team
 585 // in the mission
 586 int hud_squadmsg_count_fighters( )
 587 {
 588         int count;
 589         int team;
 590         object *objp;
 591         ship *shipp;
 592
 593         // set up the team to compare for messaging.  In debug versions, we will allow messaging to enemies
 594         //team = TEAM_FRIENDLY;
 595         team = Player_ship->team;
 596 #ifndef NDEBUG
 597         if ( Msg_enemies )
 598                 team = opposing_team_mask(Player_ship->team);
 599 #endif
 600
 601         count = 0;
 602         for ( objp = GET_FIRST(&obj_used_list); objp != END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
 603                 if ( objp->type != OBJ_SHIP )
 604                         continue;
 605
 606                 shipp = &Ships[objp->instance];
 607                 // check fighter is accepting orders
 608                 if (shipp->orders_accepted != 0) {
 609                         // be sure ship is on correct team, not the player, and is a fighter/bomber
 610                         if ( (shipp->team == team) && (objp != Player_obj) && (Ship_info[shipp->ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER)) ) {
 611                                 return 1;
 612                         }
 613                 }
 614         }
 615
 616         return 0;
 617 }
 618
 619
 620 // function which counts the number of ships available for messaging.  Used to determine if
 621 // we should grey out a menu or allow a shortcut command to apply.  parameter "flag" is used
 622 // to tell us whether or not we should add the ship to a menu item or not.  We include the
 623 // flag so that we don't have to have conditions for messaging ships/wings in two places.
 624 int hud_squadmsg_count_ships( int add_to_menu )
 625 {
 626         int count;
 627         int team;
 628         ship *shipp;
 629         ship_obj *so;
 630
 631         // set up the team to compare for messaging.  In debug versions, we will allow messaging to enemies
 632         //team = TEAM_FRIENDLY;
 633         team = Player_ship->team;
 634 #ifndef NDEBUG
 635         if ( Msg_enemies )
 636                 team = opposing_team_mask(Player_ship->team);
 637 #endif
 638
 639         count = 0;
 640         for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
 641
 642                 shipp = &Ships[Objects[so->objnum].instance];
 643                 Assert ( shipp->objnum != -1 );
 644
 645                 // ships must be able to receive a message
 646                 if ( !(Ship_info[shipp->ship_info_index].flags & CAN_MESSAGE) )
 647                         continue;
 648
 649                 // must be on the same team
 650                 if ( shipp->team != team )
 651                         continue;
 652
 653                 // departing or dying ships cannot be on list
 654                 if ( shipp->flags & (SF_DEPARTING|SF_DYING) )
 655                         continue;
 656
 657                 // MULTI - changed to allow messaging of netplayers
 658
 659                 // cannot be my ship or an instructor
 660                 if ( (&Objects[so->objnum] == Player_obj) || is_instructor(&Objects[so->objnum]) )
 661                         continue;
 662
 663                 // ship must be accepting ship type orders
 664                 if ( shipp->orders_accepted == 0)
 665                         continue;
 666
 667                 // if it is a player ship, we must be in multiplayer
 668                 if ( (Objects[so->objnum].flags & OF_PLAYER_SHIP) && !(Game_mode & GM_MULTIPLAYER) )
 669                         continue;
 670
 671                 // if a messaging shortcut, be sure this ship can process the order
 672                 if ( Msg_shortcut_command != -1 ) {
 673                         if ( !(shipp->orders_accepted & Msg_shortcut_command) )
 674                                 continue;
 675                         else if ( !hud_squadmsg_ship_order_valid(Objects[so->objnum].instance, Msg_shortcut_command) )
 676                                 continue;
 677                 }
 678
 679                 count++;
 680                 if ( add_to_menu ) {
 681                         Assert ( Num_menu_items < MAX_MENU_ITEMS );
 682                         strcpy( MsgItems[Num_menu_items].text, shipp->ship_name );
 683                         MsgItems[Num_menu_items].instance = SHIP_INDEX(shipp);
 684                         MsgItems[Num_menu_items].active = 1;
 685                         Num_menu_items++;
 686
 687                 }
 688         }
 689
 690         // if adding to the menu and we have > 10 items, then don't allow page up and page down to be used.
 691         if ( add_to_menu && (Num_menu_items > MAX_MENU_DISPLAY) )
 692                 hud_squadmsg_save_keys(1);
 693         return count;
 694 }
 695
 696 // routine to return true if a wing should be put onto the messaging menu
 697 int hud_squadmsg_wing_valid( wing *wingp, int team )
 698 {
 699         // int player_count, j;
 700
 701         // a couple of special cases to account for before adding to count (or to menu).  The wing gone
 702         // flags is firm indication to skip this particular wing.  Also, skip if enemy wing
 703         if ( (wingp->flags  & WF_WING_GONE) || (wingp->current_count == 0) )
 704                 return 0;
 705
 706         // departing wings don't get attention either
 707         if ( wingp->flags & WF_WING_DEPARTING )
 708                 return 0;
 709
 710         // sanity check on ship_index field -- if check is successful, then check the team.
 711         Assert (wingp->ship_index[0] != -1 );
 712         if ( Ships[wingp->ship_index[0]].team != team )
 713                 return 0;
 714
 715         // if this wing is the players wing, and there is only one ship in the wing, then skip past it
 716         if ( (Ships[Player_obj->instance].wingnum == WING_INDEX(wingp)) && (wingp->current_count == 1) )
 717                 return 0;
 718
 719         // check if wing commander is accepting orders
 720         if ( Ships[wingp->ship_index[0]].orders_accepted == 0)
 721                 return 0;
 722
 723         // if doing a message shortcut is being used, be sure the wing can "accept" the command.  Only need
 724         // to look at the first ship in the wing.
 725         if ( Msg_shortcut_command != -1 ) {
 726                 if ( !(Ships[wingp->ship_index[0]].orders_accepted & Msg_shortcut_command) )
 727                         return 0;
 728         }
 729         // MULTI - changed to allow messaging of netplayers
 730         // don't count wings where all ships are player ships
 731         /*
 732         player_count = 0;
 733         for ( j = 0; j < wingp->current_count; j++ ) {
 734                 if ( Objects[Ships[wingp->ship_index[j]].objnum].flags & OF_PLAYER_SHIP )
 735                         player_count++;
 736         }
 737         if ( player_count == wingp->current_count )
 738                 return 0;
 739         */
 740
 741         return 1;
 742 }
 743
 744 // function like above, except for wings
 745 int hud_squadmsg_count_wings( int add_to_menu )
 746 {
 747         int count, i, j;
 748         int team;
 749
 750         // set up the team to compare for messaging.  In debug versions, we will allow messaging to enemies
 751         //team = TEAM_FRIENDLY;
 752         team = Player_ship->team;
 753 #ifndef NDEBUG
 754         if ( Msg_enemies )
 755                 team = opposing_team_mask(Player_ship->team);
 756 #endif
 757
 758         count = 0;
 759
 760         // add the player starting wings first
 761         for ( i = 0; i < MAX_STARTING_WINGS; i++ ) {
 762                 int wingnum;
 763
 764                 wingnum = Starting_wings[i];
 765                 if ( wingnum == -1 )
 766                         continue;
 767
 768                 if ( hud_squadmsg_wing_valid(&Wings[wingnum], team) ) {
 769                         count++;
 770                         if ( add_to_menu ) {
 771                                 Assert ( Num_menu_items < MAX_MENU_ITEMS );
 772                                 strcpy( MsgItems[Num_menu_items].text, Wings[wingnum].name );
 773                                 MsgItems[Num_menu_items].instance = wingnum;
 774                                 MsgItems[Num_menu_items].active = 1;
 775                                 Num_menu_items++;
 776                         }
 777                 }
 778         }
 779
 780         for ( i = 0; i < num_wings; i++ ) {
 781                 // if this wing is a player starting wing, skip it since we added it above
 782                 for ( j = 0; j < MAX_STARTING_WINGS; j++ ) {
 783                         if ( i == Starting_wings[j] )
 784                                 break;
 785                 }
 786                 if ( j < MAX_STARTING_WINGS )
 787                         continue;
 788
 789                 if ( hud_squadmsg_wing_valid(&Wings[i], team) ) {
 790                         count++;
 791                         if ( add_to_menu ) {
 792                                 Assert ( Num_menu_items < MAX_MENU_ITEMS );
 793                                 strcpy( MsgItems[Num_menu_items].text, Wings[i].name );
 794                                 MsgItems[Num_menu_items].instance = i;
 795                                 MsgItems[Num_menu_items].active = 1;
 796                                 Num_menu_items++;
 797                         }
 798                 }
 799         }
 800         return count;
 801 }
 802
 803
 804 // function to set the current submode in message mode -- also resets variables that
 805 // should be reset inbetween submodes
 806 void hud_squadmsg_do_mode( int mode )
 807 {
 808         Squad_msg_mode = mode;
 809         Num_menu_items = -1;
 810         First_menu_item = 0;
 811 }
 812
 813 void hud_squadmsg_page_down()
 814 {
 815         if ( (First_menu_item + MAX_MENU_DISPLAY) < Num_menu_items ) {
 816                 First_menu_item += MAX_MENU_DISPLAY;
 817                 Assert ( First_menu_item < Num_menu_items );
 818         }
 819 }
 820
 821 void hud_squadmsg_page_up()
 822 {
 823         if ( First_menu_item > 0 ) {
 824                 First_menu_item -= MAX_MENU_DISPLAY;
 825                 Assert (First_menu_item >= 0 );
 826         }
 827 }
 828
 829 int hud_squadmsg_get_total_keys()
 830 {
 831         int num_keys_used;
 832
 833         num_keys_used = MAX_KEYS_NO_SCROLL;
 834         if ( Num_menu_items > MAX_MENU_DISPLAY )
 835                 num_keys_used = MAX_KEYS_USED;
 836
 837         return num_keys_used;
 838 }
 839
 840 // function called from high level keyboard read code to give the squadmsg code a key.
 841 // return 1 is the key was used by the messaging code, 0 otherwise
 842 int hud_squadmsg_read_key( int k )
 843 {
 844         int i, key_found, num_keys_used;
 845
 846         num_keys_used = hud_squadmsg_get_total_keys();
 847
 848         if ( !(Player->flags & PLAYER_FLAGS_MSG_MODE) ) {
 849                 // check to see if any messaging keys are still down for some length of time
 850                 // after messaging is over.  Return true for a while.
 851                 if ( !timestamp_elapsed(Msg_eat_key_timestamp) ) {
 852                         for (i = 0; i < num_keys_used; i++ ) {
 853                                 if ( key_pressed(keys_used[i]) )
 854                                         return 1;
 855                         }
 856                 }
 857
 858                 return 0;
 859         }
 860
 861         key_found = 0;
 862         for (i = 0; i < num_keys_used; i++ ) {
 863                 if ( k == keys_used[i] ) {
 864                         if ( key_down_count(k) ) {
 865                                 Msg_key = k;
 866                                 key_found = 1;
 867                         }
 868
 869                         if ( key_pressed(k) ) {
 870                                 key_found = 1;
 871                         }
 872
 873 //                      key_down_count(k);
 874                         break;
 875                 }
 876         }
 877
 878         if ( key_found )
 879                 return 1;
 880
 881         return 0;
 882 }
 883
 884 // function which reads the keyboard array and determines if a menu key has been hit
 885 int hud_squadmsg_get_key()
 886 {
 887         int k, i, num_keys_used;
 888
 889         if ( Msg_key == -1 )
 890                 return -1;
 891
 892         k = Msg_key;
 893         Msg_key = -1;
 894
 895         num_keys_used = hud_squadmsg_get_total_keys();
 896
 897         // if the emp effect is active, never accept keypresses
 898         if(emp_active_local()){
 899                 return -1;
 900         }
 901
 902         for ( i = 0; i < num_keys_used; i++ ) {
 903                 if ( k == keys_used[i] ) {
 904                         Msg_key_used = 1;                                               // this variable will extend the timer
 905
 906                         // use a timestamp to prevent top level key code from possibly reprocessing this key
 907                         Msg_eat_key_timestamp = timestamp(MSG_KEY_EAT_TIME);
 908                         if ( k == SDLK_PAGEDOWN ) {                     // pageup and pagedown scroll the menu -- deal with these seperately!!
 909                                 hud_squadmsg_page_down();
 910                                 return -1;
 911                         } else if ( k == SDLK_PAGEUP ) {
 912                                 hud_squadmsg_page_up();
 913                                 return -1;
 914                         } else if ( k == SDLK_ESCAPE ) {
 915                                 hud_squadmsg_toggle();
 916                                 return -1;
 917                         } else if ( (i < Num_menu_items) && (Squad_msg_mode == SM_MODE_REINFORCEMENTS) )                // return any key if selecting reinforcement
 918                                 return i;
 919
 920                         // play general fail sound if inactive item hit.
 921                         else if ( (i < Num_menu_items) && !(MsgItems[i].active) )
 922                                 gamesnd_play_iface(SND_GENERAL_FAIL);
 923
 924                         else if ( (i < Num_menu_items) && (MsgItems[i].active) )        // only return keys that are associated with menu items
 925                                 return i;
 926
 927                         else {
 928                                 Msg_key_used = 0;                                       // if no #-key pressed for visible item, break and allow timer to
 929                                 break;                                                          // to continue as if no key was pressed
 930                         }
 931                 }
 932         }
 933
 934         return -1;
 935 }
 936
 937 // function which will essentially print out the contents of the current state of the messaging
 938 // menu.  Parameters will be a title.  The menu items and the number of items will be
 939 // in global vars since they don't get recomputed every frame.
 940 void hud_squadmsg_display_menu( const char *title )
 941 {
 942         int bx, by, sx, sy, i, nitems, none_valid, messaging_allowed;
 943
 944         // hud_set_bright_color();
 945         hud_set_gauge_color(HUD_MESSAGE_BOX, HUD_C_BRIGHT);
 946         if ( title ) {
 947                 gr_string(Mbox_title_coord[gr_screen.res][0], Mbox_title_coord[gr_screen.res][1], title);
 948         }
 949
 950         if ( Num_menu_items < MAX_MENU_DISPLAY )
 951                 nitems = Num_menu_items;
 952         else {
 953                 if ( First_menu_item == 0 )                                     // First_menu_item == 0 means first page of items
 954                         nitems = MAX_MENU_DISPLAY;
 955                 else if ( (Num_menu_items - First_menu_item) <= MAX_MENU_DISPLAY )      // check if remaining items fit on one page
 956                         nitems = Num_menu_items - First_menu_item;
 957                 else {
 958                         nitems = MAX_MENU_DISPLAY;
 959                 }
 960         }
 961
 962         sx = Mbox_item_coord[gr_screen.res][0];
 963         sy = Mbox_item_coord[gr_screen.res][1];
 964         bx = Mbox_bmap_coords[gr_screen.res][0];        // global x-offset where bitmap gets drawn
 965         by = Mbox_bmap_coords[gr_screen.res][1];                // global y-offset where bitmap gets drawn
 966
 967         none_valid = 1;         // variable to tell us whether all items in the menu are valid or not
 968
 969         // use another variable to tell us whether we can message or not.
 970         messaging_allowed = 1;
 971         if ( (Game_mode & GM_MULTIPLAYER) && !multi_can_message(Net_player) ){
 972                 messaging_allowed = 0;
 973         }
 974
 975         for ( i = 0; i < nitems; i++ ) {
 976                 int item_num;
 977                 char *text = MsgItems[First_menu_item+i].text;
 978
 979                 // blit the background
 980                 // hud_set_default_color();
 981                 hud_set_gauge_color(HUD_MESSAGE_BOX);
 982                 if ( Mbox_gauge[1].first_frame >= 0 ) {
 983                         GR_AABITMAP(Mbox_gauge[1].first_frame, bx, by);
 984                 }
 985                 by += Mbox_item_h[gr_screen.res];
 986
 987                 // set the text color
 988                 if ( MsgItems[First_menu_item+i].active ) {
 989                         // hud_set_bright_color();
 990                         hud_set_gauge_color(HUD_MESSAGE_BOX, HUD_C_BRIGHT);
 991                 } else {
 992                         /*
 993                         dim_index = min(5, HUD_color_alpha - 2);
 994                         if ( dim_index < 0 ) {
 995                                 dim_index = 0;
 996                         }
 997                         gr_set_color_fast(&HUD_color_defaults[dim_index]);
 998                         */
 999
1000                         hud_set_gauge_color(HUD_MESSAGE_BOX, HUD_C_DIM);
1001                 }
1002
1003                 // first do the number
1004                 item_num = (i+1) % MAX_MENU_DISPLAY;
1005                 emp_hud_printf(sx, sy, EG_SQ1 + i, NOX("%1d."), item_num );
1006
1007                 // then the text
1008                 emp_hud_string(sx+Mbox_item_xoffset[gr_screen.res], sy, EG_SQ1 + i, text);
1009
1010                 sy += Mbox_item_h[gr_screen.res];
1011
1012                 // if we have at least one item active, then set the variable so we don't display any
1013                 // message about no active items
1014                 if ( MsgItems[First_menu_item+i].active )
1015                         none_valid = 0;
1016         }
1017
1018         // maybe draw an extra line in to make room for [pgdn], or for the 'no active items'
1019         // display
1020         if ( !messaging_allowed || none_valid || ((First_menu_item + nitems) < Num_menu_items) || (Msg_shortcut_command != -1) ) {
1021                 // blit the background
1022                 // hud_set_default_color();
1023                 hud_set_gauge_color(HUD_MESSAGE_BOX);
1024                 if ( Mbox_gauge[1].first_frame >= 0 ) {
1025
1026                         GR_AABITMAP(Mbox_gauge[1].first_frame, bx, by);
1027                 }
1028                 by += Mbox_item_h[gr_screen.res];
1029         }
1030
1031         // draw the bottom of the frame
1032         // hud_set_default_color();
1033         hud_set_gauge_color(HUD_MESSAGE_BOX);
1034         if ( Mbox_gauge[2].first_frame >= 0 ) {
1035
1036                 GR_AABITMAP(Mbox_gauge[2].first_frame, bx, by);
1037         }
1038
1039         // determine if we should put the text "[more]" at top or bottom to indicate you can page up or down
1040         hud_targetbox_start_flash(TBOX_FLASH_SQUADMSG);
1041         hud_targetbox_maybe_flash(TBOX_FLASH_SQUADMSG);
1042         if ( First_menu_item > 0 ) {
1043                 gr_printf( Menu_pgup_coords[gr_screen.res][0], Menu_pgup_coords[gr_screen.res][1], XSTR( "[pgup]", 312) );
1044         }
1045
1046         if ( (First_menu_item + nitems) < Num_menu_items ) {
1047                 gr_printf( Menu_pgdn_coords[gr_screen.res][0], Menu_pgdn_coords[gr_screen.res][1], XSTR( "[pgdn]", 313));
1048         }
1049
1050         if ( messaging_allowed ) {
1051                 if ( none_valid ){
1052                         gr_printf( sx, by - Mbox_item_h[gr_screen.res] + 2, XSTR( "No valid items", 314));
1053                 } else if ( !none_valid && (Msg_shortcut_command != -1) ){
1054                         gr_printf( sx, by - Mbox_item_h[gr_screen.res] + 2, "%s", comm_order_hotkey_text(Msg_shortcut_command));
1055                 }
1056         } else {
1057                 // if this player is not allowed to message, then display message saying so
1058                 gr_printf( sx, by - Mbox_item_h[gr_screen.res] + 2, XSTR( "Not allowed to message", 315));
1059         }
1060
1061 }
1062
1063 // function to return true or false if the given ship can rearm, or be repaired
1064 int hud_squadmsg_can_rearm( ship *shipp )
1065 {
1066         // player ships which turns traitor cannot rearm
1067         if ( (shipp == Player_ship) && (Player_ship->team == TEAM_TRAITOR) )
1068                 return 0;
1069
1070         // 5/6/98 -- MWA  Decided to always be able to call in support.
1071         return 1;
1072 }
1073
1074 // calls for repair/rearm of the player ship.  Checks for the presense of the support
1075 // ship and does the appropriate action if found
1076 void hud_squadmsg_repair_rearm( int toggle_state, object *objp)
1077 {
1078         int robjnum;
1079         object *robjp;
1080         object *tobj;
1081         int multi_player_num;
1082
1083         // this is essentially a check for multiplayer server/client mode
1084         // in multiplayer mode, the server may have to issue this command when received from a client
1085         if(objp == NULL) {
1086                 tobj = Player_obj;
1087                 multi_player_num = -1;
1088         } else {
1089                 tobj = objp;
1090                 multi_player_num = multi_find_player_by_object(objp);
1091                 Assert(multi_player_num != -1);
1092         }
1093
1094         // see if player is already scheduled on arriving support ship.  If so, issues appripriate
1095         // message and bail
1096         if ( is_support_allowed(tobj) ) {
1097                 if ( mission_is_repair_scheduled( tobj ) ) {
1098                         message_send_builtin_to_player( MESSAGE_REARM_ON_WAY, NULL, MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_SOON, 0, 0, multi_player_num, -1 );
1099                 } else {
1100                         robjnum = hud_support_find_closest(OBJ_INDEX(tobj));
1101                         if ( robjnum != -1 ) {
1102                                 message_send_builtin_to_player( MESSAGE_REARM_ON_WAY, &Ships[Objects[robjnum].instance], MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_SOON, 0, 0, multi_player_num, -1 );
1103                         } else {
1104                                 // request a rearm.  Next function returns -1 if ship is warping in, objnum of repair ship otherwise
1105                                 robjnum = ai_issue_rearm_request( tobj );
1106                                 if ( robjnum != -1) {
1107                                         robjp = &Objects[robjnum];
1108                                         message_send_builtin_to_player( MESSAGE_ON_WAY, &Ships[robjp->instance], MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_SOON, 0, 0, multi_player_num, -1 );
1109
1110                                 } else {
1111                                         // if we are in this part of the if statment, a support ship has been warped in to
1112                                         // service us.  Issue appropriate message
1113                                         message_send_builtin_to_player( MESSAGE_REARM_WARP, NULL, MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_SOON, 0, 0, multi_player_num, -1 );
1114                                 }
1115
1116                                 mission_log_add_entry(LOG_PLAYER_REARM, Ships[tobj->instance].ship_name, NULL);
1117                         }
1118                 }
1119         }
1120
1121         //if ( multi_player_num == -1 )         // only do the hud display if it is for me!
1122         //      hud_support_view_start();
1123
1124         if ( toggle_state )
1125                 hud_squadmsg_toggle();                                          // take us out of message mode
1126 }
1127
1128 // function which gets called from keyboard code to issues a shortcut command for rearming.
1129 void hud_squadmsg_rearm_shortcut()
1130 {
1131         if ( !hud_squadmsg_can_rearm(Player_ship) )
1132                 return;
1133
1134         // multiplayer clients need to send this message to the server
1135         if ( MULTIPLAYER_CLIENT ) {
1136                 send_player_order_packet(SQUAD_MSG_SHIP, 0, REARM_REPAIR_ME_ITEM);
1137                 return;
1138         }
1139
1140         hud_squadmsg_repair_rearm(0);
1141 }
1142
1143 // code which is called when a player aborts his rearm request
1144 void hud_squadmsg_repair_rearm_abort( int toggle_state, object *obj)
1145 {
1146 //      ai_info *aip;
1147 //      object *robjp;
1148         object *tobj;
1149
1150         // this is essentially a check for multiplayer server/client mode
1151         // in multiplayer mode, the server may have to issue this command when received from a client
1152         if(obj == NULL)
1153                 tobj = Player_obj;
1154         else
1155                 tobj = obj;
1156
1157         // try to abort the request.  We shoudln't be in this function unless we are actually
1158         // queued for repair.  Send a message from support ship if the support ship is in the mission
1159         ai_abort_rearm_request( tobj );
1160
1161         // move the next statements outside of the above if-statement.  Seems like this place
1162         // is the right place, since we want to change state of the messaging system regardless
1163         // of what happened above.
1164         if ( toggle_state )
1165                 hud_squadmsg_toggle();                                          // take us out of message mode
1166 }
1167
1168 // returns 1 if an order is valid for a ship.  Applies to things like departure when engines are blown, etc.
1169 int hud_squadmsg_ship_order_valid( int shipnum, int order )
1170 {
1171         // disabled ships can't depart.
1172         if ( (order == DEPART_ITEM) && (Ships[shipnum].flags & SF_DISABLED) )
1173                 return 0;
1174
1175         return 1;
1176 }
1177
1178 // returns true or false if the Players target is valid for the given order
1179 // find_order is true when we need to search the comm_orders array for the order entry.  We have
1180 // to do this action in some cases since all we know is the actual "value" of the order
1181 int hud_squadmsg_is_target_order_valid(int order, int find_order, ai_info *aip )
1182 {
1183         int target_objnum, i;
1184         ship *shipp, *ordering_shipp;
1185         object *objp;
1186
1187         if ( aip == NULL )
1188                 aip = Player_ai;
1189
1190         // find the comm_menu item for this command
1191         if ( find_order ) {
1192                 for (i = 0; i < MAX_SHIP_ORDERS; i++ ) {
1193                         if ( Comm_orders[i].value == order )
1194                                 break;
1195                 }
1196                 Assert( i < MAX_SHIP_ORDERS );
1197                 order = i;
1198         }
1199
1200         // orders which don't operate on targets are always valid
1201         if ( !(Comm_orders[order].value & TARGET_MESSAGES) )
1202                 return 1;
1203
1204         target_objnum = aip->target_objnum;
1205
1206         // order isn't valid if there is no player target
1207         if ( target_objnum == -1 ) {
1208                 return 0;
1209         }
1210
1211         objp = &Objects[target_objnum];
1212
1213         ordering_shipp = &Ships[aip->shipnum];
1214
1215         // target isn't a ship, then return 0
1216         if ( (objp->type != OBJ_SHIP) && (objp->type != OBJ_WEAPON) )
1217                 return 0;
1218
1219         // if it's a weapon, then it needs to be a WIF_BOMB weapon.  Only attack order valid, and only
1220         // valid on bombs not on the player's team
1221         if ( objp->type == OBJ_WEAPON ) {
1222                 if ( (Comm_orders[order].value == ATTACK_TARGET_ITEM )
1223                         && (Weapon_info[Weapons[objp->instance].weapon_info_index].wi_flags & WIF_BOMB)
1224                         && (Weapons[objp->instance].team != ordering_shipp->team) )
1225
1226                         return 1;
1227
1228                 return 0;
1229         }
1230
1231         Assert( objp->type == OBJ_SHIP );
1232
1233         shipp = &Ships[objp->instance];
1234
1235         // if target is a navbouy, return 0
1236         if ( Ship_info[shipp->ship_info_index].flags & SIF_NAVBUOY ){
1237                 return 0;
1238         }
1239
1240         // if we are messaging a ship, and that ship is our target, no target type orders are ever active
1241         if ( (Squad_msg_mode == SM_MODE_SHIP_COMMAND) && (target_objnum == Msg_instance) ){
1242                 return 0;
1243         }
1244
1245         // if the order is a disable order or depart, and the ship is disabled, order isn't active
1246         if ( (Comm_orders[order].value == DISABLE_TARGET_ITEM) && (shipp->flags & SF_DISABLED) ){
1247                 return 0;
1248         }
1249
1250         // same as above except for disabled.
1251         if ( (Comm_orders[order].value == DISARM_TARGET_ITEM) && ((shipp->subsys_info[SUBSYSTEM_TURRET].num > 0) && (shipp->subsys_info[SUBSYSTEM_TURRET].current_hits == 0.0f)) ){
1252                 return 0;
1253         }
1254
1255         // if order is disable subsystem, and no subsystem targeted or no hits, then order not valid
1256         if ( (Comm_orders[order].value == DISABLE_SUBSYSTEM_ITEM) && ((aip->targeted_subsys == NULL) || (aip->targeted_subsys->current_hits <= 0.0f)) ){
1257                 return 0;
1258         }
1259
1260         // check based on target's and player's team
1261         if ( (shipp->team == ordering_shipp->team) && (Comm_orders[order].value & FRIENDLY_TARGET_MESSAGES) ){
1262                 return 1;
1263         } else if ( (shipp->team != ordering_shipp->team) && (Comm_orders[order].value & ENEMY_TARGET_MESSAGES) ){
1264                 return 1;
1265         } else {
1266                 return 0;
1267         }
1268 }
1269
1270 // function to send an order to all fighters/bombers.
1271 void hud_squadmsg_send_to_all_fighters( int command, int player_num )
1272 {
1273         ai_info *aip;
1274         ship *shipp, *ordering_shipp;
1275         int i, send_message, to_everyone, do_ship;
1276         object *objp;
1277
1278         // quick short circuit here because of actually showing comm menu even though you cannot message.
1279         // just a safety net.
1280         if ( (Game_mode & GM_MULTIPLAYER) && (player_num != -1) ) {
1281                 if ( !multi_can_message(&Net_players[player_num]) ) {
1282                         return;
1283                 }
1284         }
1285
1286         // check for multiplayer mode
1287         if((Game_mode & GM_MULTIPLAYER) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER)) {
1288                 send_player_order_packet(SQUAD_MSG_ALL, 0, command);
1289                 return;
1290         }
1291
1292         // to_everyone tells us whether the command should apply to all ships, or just to fighets/bombers.
1293         // when true, command goes to *all* friendlies.
1294         send_message = 1;                                                                       // internal flag to dictate who sends message
1295         to_everyone = 0;
1296         do_ship = 0;
1297         aip = Player_ai;
1298
1299         if ( player_num != -1 )
1300                 aip = &Ai_info[Ships[Objects[Net_players[player_num].player->objnum].instance].ai_index];
1301
1302         Assert( aip->shipnum != -1 );
1303         ordering_shipp = &Ships[aip->shipnum];
1304
1305         if ( command == IGNORE_TARGET_ITEM ) {
1306                 to_everyone = 1;
1307                 // if we were messaging a ship directly, set flag to send no messages.  We will send one
1308                 // specifically from the ship player is ordering
1309                 if ( (Msg_instance != MESSAGE_ALL_FIGHTERS) && (Squad_msg_mode == SM_MODE_SHIP_COMMAND) ) {
1310                         do_ship = 1;
1311                         send_message = 0;
1312                 }
1313         }
1314
1315         for ( i = 0; i < num_wings; i++ ) {
1316                 int shipnum;
1317
1318                 if ( (Wings[i].flags & WF_WING_GONE) || (Wings[i].current_count == 0) )
1319                         continue;
1320
1321                 if ( Wings[i].flags & WF_WING_DEPARTING )
1322                         continue;
1323
1324                 // get the first ship on the wing list and look at it's team and then it's type
1325                 shipnum = Wings[i].ship_index[0];
1326                 Assert( shipnum != -1 );
1327                 shipp = &Ships[shipnum];
1328
1329                 // can't message if not on players team
1330                 if ( shipp->team != ordering_shipp->team )
1331                         continue;
1332
1333                 // can't message if ship not fighter/bomber if the command isn't to everyone.
1334                 if ( !to_everyone && !(Ship_info[shipp->ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER)) )
1335                         continue;
1336
1337                 // don't send the command if the "wing" won't accept the command.  We do this by looking at
1338                 // the set of orders accepted for the first ship in the wing.
1339                 if ( !(command & shipp->orders_accepted) )
1340                         continue;
1341
1342                 // send the command to the wing
1343                 if ( Wings[i].current_count > 1 ) {
1344                         if ( hud_squadmsg_send_wing_command(i, command, send_message, player_num) ) {
1345                                 send_message = 0;
1346                         }
1347                 }
1348         }
1349
1350         // now find any friendly fighter/bomber ships not in wings
1351         for ( objp = GET_FIRST(&obj_used_list); objp != END_OF_LIST(&obj_used_list); objp = GET_NEXT(objp) ) {
1352                 if ( objp->type != OBJ_SHIP )
1353                         continue;
1354
1355                 // don't send messge to ships not on player's team, or that are in a wing.
1356                 shipp = &Ships[objp->instance];
1357                 if ( (shipp->team != ordering_shipp->team) || (shipp->wingnum != -1) )
1358                         continue;
1359
1360                 // don't send message to non fighter wings
1361                 if ( !to_everyone && !(Ship_info[shipp->ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER)) )
1362                         continue;
1363
1364                 // skip departing/dying ships
1365                 if ( shipp->flags & (SF_DEPARTING|SF_DYING) )
1366                         continue;
1367
1368                 // don't send command if ship won't accept if
1369                 if ( !(command & shipp->orders_accepted) )
1370                         continue;
1371
1372                 if ( hud_squadmsg_send_ship_command(objp->instance, command, send_message, player_num) ) {
1373                         send_message = 0;
1374                 }
1375         }
1376
1377         // we might send the ship command again if we are ignoring a target, and the guy
1378         // we ordered directly is a ship -- we want the response to come directly from the
1379         // guy we orders
1380         if ( do_ship ) {
1381                 Assert( Msg_instance != MESSAGE_ALL_FIGHTERS );
1382                 hud_squadmsg_send_ship_command( Msg_instance, command, 1 );
1383         }
1384 }
1385
1386 // Check if any enemy ships are in the mission
1387 int hud_squadmsg_enemies_present()
1388 {
1389         ship            *shipp;
1390         ship_obj *so;
1391
1392         for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
1393                 shipp = &Ships[Objects[so->objnum].instance];
1394                 if ( shipp->team != Player_ship->team )
1395                         return 1;
1396         }
1397
1398         return 0;
1399 }
1400
1401 #define OVERRIDE_PROTECT_SHIP_TYPE      (SIF_FIGHTER|SIF_BOMBER|SIF_FREIGHTER|SIF_TRANSPORT)
1402 // function which sends a message to a specific ship.  This routine can be called from one of two
1403 // places.  Either after selecting a ship when using a hotkey, or after selecting a command when
1404 // using the entire messaging menu system
1405 //
1406 // if local and addr are non-null, it means the function is being called by the (multiplayer) server in response to
1407 // a PLAYER_COMMAND_PACKET
1408 int hud_squadmsg_send_ship_command( int shipnum, int command, int send_message, int player_num )
1409 {
1410         ai_info *ainfo;
1411         int ai_mode, ai_submode;                                        // ai mode and submode needed for ship commands
1412         char *target_shipname;                                          // ship number of possible targets
1413         int message;
1414         int target_team, ship_team;                             // team id's for the ship getting message and any target the player has
1415         ship *ordering_shipp;
1416
1417         // quick short circuit here because of actually showing comm menu even though you cannot message.
1418         // just a safety net.
1419         if ( (Game_mode & GM_MULTIPLAYER) && (player_num != -1) ) {
1420                 if ( !multi_can_message(&Net_players[player_num]) ) {
1421                         return 0;
1422                 }
1423         }
1424
1425         // check for multiplayer mode
1426         if((Game_mode & GM_MULTIPLAYER) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER)){
1427                 send_player_order_packet(SQUAD_MSG_SHIP, shipnum, command);
1428                 return 0;
1429         }
1430
1431         ai_mode = AI_GOAL_NONE;                                                 // needs to be initialized
1432         ai_submode = -1234567;
1433         ainfo = Player_ai;
1434
1435         if ( player_num != -1 ){
1436                 ainfo = &Ai_info[Ships[Objects[Net_players[player_num].player->objnum].instance].ai_index];
1437         }
1438
1439         Assert( ainfo->shipnum != -1 );
1440         ordering_shipp = &Ships[ainfo->shipnum];
1441
1442         // a shortcut to save on repetitive coding.  If the order is a 'target' order, make the default
1443         // mesage be "no target"
1444         message = MESSAGE_NOSIR;
1445         if ( (command & TARGET_MESSAGES) && (ainfo->target_objnum == -1) )
1446                 message = MESSAGE_NO_TARGET;
1447
1448         if ( hud_squadmsg_is_target_order_valid(command, 1, ainfo) ) {
1449
1450                 target_shipname = NULL;
1451                 target_team = -1;
1452                 if ( ainfo->target_objnum != -1) {
1453                         if ( Objects[ainfo->target_objnum].type == OBJ_SHIP ) {
1454                                 if ( ainfo->target_objnum != Ships[shipnum].objnum ) {
1455                                         target_shipname = Ships[Objects[ainfo->target_objnum].instance].ship_name;              // I think this is right
1456                                         target_team = Ships[Objects[ainfo->target_objnum].instance].team;
1457                                 }
1458                         }
1459                 }
1460
1461                 Assert ( ainfo->shipnum != -1 );
1462                 ship_team = Ships[ainfo->shipnum].team;         // team of the ship issuing the message
1463
1464                 switch ( command ) {                                                                    // value of k matches the #defines for ship messages
1465                 case ATTACK_TARGET_ITEM:
1466                         if ( Objects[ainfo->target_objnum].type == OBJ_SHIP ) {
1467                                 Assert( target_shipname );
1468                                 Assert( ship_team != target_team );
1469
1470                                 // Orders to override protect
1471                                 if (Ship_info[Ships[Objects[ainfo->target_objnum].instance].ship_info_index].flags & OVERRIDE_PROTECT_SHIP_TYPE) {
1472                                         Objects[ainfo->target_objnum].flags &= ~OF_PROTECTED;
1473                                 }
1474
1475                                 ai_mode = AI_GOAL_CHASE;
1476                                 ai_submode = SM_ATTACK;
1477                         } else if ( Objects[ainfo->target_objnum].type == OBJ_WEAPON ) {
1478                                 ai_mode = AI_GOAL_CHASE_WEAPON;
1479                                 ai_submode = Objects[ainfo->target_objnum].instance;                    // store the instance of the weapon -- ai goals code will deal with it
1480                         } else
1481                                 Int3();
1482                         message = MESSAGE_ATTACK_TARGET;
1483                         break;
1484
1485                 case DISABLE_TARGET_ITEM:
1486                         Assert( target_shipname );
1487                         Assert( ship_team != target_team );
1488
1489                         // Orders to override protect
1490                         if (Ship_info[Ships[Objects[ainfo->target_objnum].instance].ship_info_index].flags & OVERRIDE_PROTECT_SHIP_TYPE) {
1491                                 Objects[ainfo->target_objnum].flags &= ~OF_PROTECTED;
1492                         }
1493
1494                         ai_mode = AI_GOAL_DISABLE_SHIP;
1495                         ai_submode = -SUBSYSTEM_ENGINE;
1496                         message = MESSAGE_DISABLE_TARGET;
1497                         break;
1498
1499                 case DISARM_TARGET_ITEM:
1500                         Assert( target_shipname );
1501                         Assert( ship_team != target_team );
1502
1503                         // Orders to override protect
1504                         if (Ship_info[Ships[Objects[ainfo->target_objnum].instance].ship_info_index].flags & OVERRIDE_PROTECT_SHIP_TYPE) {
1505                                 Objects[ainfo->target_objnum].flags &= ~OF_PROTECTED;
1506                         }
1507
1508                         ai_mode = AI_GOAL_DISARM_SHIP;
1509                         ai_submode = -SUBSYSTEM_TURRET;
1510                         message = MESSAGE_DISARM_TARGET;
1511                         break;
1512
1513                 case DISABLE_SUBSYSTEM_ITEM:
1514                         Assert( target_shipname );
1515                         Assert( ship_team != target_team );
1516                         Assert( ainfo->targeted_subsys != NULL );
1517                         Assert( ainfo->targeted_subsys->current_hits > 0.0f);
1518
1519                         // Orders to override protect
1520                         if (Ship_info[Ships[Objects[ainfo->target_objnum].instance].ship_info_index].flags & OVERRIDE_PROTECT_SHIP_TYPE) {
1521                                 Objects[ainfo->target_objnum].flags &= ~OF_PROTECTED;
1522                         }
1523
1524                         ai_mode = AI_GOAL_DESTROY_SUBSYSTEM;
1525                         ai_submode = ship_get_subsys_index( &Ships[Objects[ainfo->target_objnum].instance], ainfo->targeted_subsys->system_info->subobj_name );
1526                         message = MESSAGE_ATTACK_TARGET;
1527                         break;
1528
1529                 case CAPTURE_TARGET_ITEM:
1530                         Assert( target_shipname );
1531                         Assert( ship_team != target_team );
1532
1533                         Assert(ainfo->target_objnum > -1);
1534
1535                         Objects[ainfo->target_objnum].flags |= OF_PROTECTED;
1536
1537                         ai_mode = AI_GOAL_DOCK;
1538                         ai_submode = AIS_DOCK_0;
1539                         message = MESSAGE_DOCK_YES;
1540                         break;
1541
1542                 case PROTECT_TARGET_ITEM:
1543
1544                         // AL 31-3-98: Can't protect self... this can happen if all fighters
1545                         //                                      are told to protect another friendly ship
1546                         if ( ainfo->target_objnum == Ships[shipnum].objnum ) {
1547                                 return 0;
1548                         }
1549
1550                         Assert( target_shipname );
1551                         Assert( ship_team == target_team );
1552
1553                         ai_mode = AI_GOAL_GUARD;
1554                         ai_submode = AIS_GUARD_PATROL;
1555                         message = MESSAGE_YESSIR;
1556                         break;
1557
1558                 case IGNORE_TARGET_ITEM:
1559                         Assert( target_shipname );
1560                         Assert( ship_team != target_team );
1561
1562                         ai_mode = AI_GOAL_IGNORE;
1563                         ai_submode = 0;
1564                         message = MESSAGE_YESSIR;
1565                         break;
1566
1567                 case FORMATION_ITEM:
1568                         message = MESSAGE_YESSIR;
1569                         target_shipname = ordering_shipp->ship_name;
1570                         ai_mode = AI_GOAL_FORM_ON_WING;
1571                         ai_submode = 0;
1572                         break;
1573
1574                 case COVER_ME_ITEM:
1575                         ai_mode = AI_GOAL_GUARD;
1576                         ai_submode = AIS_GUARD_PATROL;
1577                         target_shipname = ordering_shipp->ship_name;
1578                         message = MESSAGE_YESSIR;
1579                         break;
1580
1581                 case ENGAGE_ENEMY_ITEM:
1582                         ai_mode = AI_GOAL_CHASE_ANY;
1583                         ai_submode = SM_ATTACK;
1584                         // if no enemies present, use the affirmative, instead of engaging enemies message
1585                         if ( hud_squadmsg_enemies_present() )
1586                                 message = MESSAGE_YESSIR;
1587                         else
1588                                 message = MESSAGE_ENGAGE;
1589                         target_shipname = NULL;
1590                         break;
1591
1592                 case DEPART_ITEM:
1593                         ai_mode = AI_GOAL_WARP;
1594                         ai_submode = -1;
1595                         message = MESSAGE_WARP_OUT;
1596                         break;
1597
1598                 // the following are support ship options!!!
1599                 case REARM_REPAIR_ME_ITEM:
1600                         if((Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_AM_MASTER) && (player_num != -1) ){
1601                                 hud_squadmsg_repair_rearm(0,&Objects[Net_players[player_num].player->objnum]);
1602                         } else {
1603                                 hud_squadmsg_repair_rearm(0);                           // note we return right away.  repair/rearm code handles messaging, etc
1604                         }
1605                         return 0;
1606
1607                 case ABORT_REARM_REPAIR_ITEM:
1608                         if((Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_AM_MASTER) && (player_num != -1) ){
1609                                 hud_squadmsg_repair_rearm_abort(0,&Objects[Net_players[player_num].player->objnum]);
1610                         } else {
1611                                 hud_squadmsg_repair_rearm_abort(0);             // note we return right away.  repair/rearm code handles messaging, etc
1612                         }
1613                         return 0;
1614
1615                 case STAY_NEAR_ME_ITEM:
1616                 case STAY_NEAR_TARGET_ITEM:             // can't attack anything on same team
1617
1618                         // cannot stay near a hostile ship(?)
1619                         if ( (command == STAY_NEAR_TARGET_ITEM) && (ship_team != target_team) )
1620                                 break;
1621
1622                         ai_mode = AI_GOAL_STAY_NEAR_SHIP;
1623                         ai_submode = -1;
1624                         message = MESSAGE_YESSIR;
1625                         if ( command == STAY_NEAR_ME_ITEM )
1626                                 target_shipname = ordering_shipp->ship_name;
1627                         break;
1628
1629                 case KEEP_SAFE_DIST_ITEM:
1630                         ai_mode = AI_GOAL_KEEP_SAFE_DISTANCE;
1631                         ai_submode = -1;
1632                         message = MESSAGE_YESSIR;
1633                         break;
1634
1635                 default:
1636                         Int3();                                                                         // get Allender -- illegal message
1637                         break;
1638
1639                 }
1640
1641                 // handle case of messaging one ship.  Deal with messaging all fighters next.
1642                 if ( ai_mode != AI_GOAL_NONE ) {
1643                         Assert(ai_submode != -1234567);
1644                         ai_add_ship_goal_player( AIG_TYPE_PLAYER_SHIP, ai_mode, ai_submode, target_shipname, &Ai_info[Ships[shipnum].ai_index] );
1645                         if( player_num == -1 )
1646                                 hud_add_issued_order(Ships[shipnum].ship_name, command, target_shipname);
1647                 }
1648         }
1649
1650         // if we're in multiplayer mode, and we're the server, determine if this virtual squadmate order should be
1651         // sent to other players in the game as an actual "order"
1652         if((Game_mode & GM_MULTIPLAYER) && (message != MESSAGE_NOSIR)){
1653                 // if the multi_msg system processed and sent this order to a player, we should not play a response
1654                 if(multi_msg_eval_ship_squadmsg(shipnum,command,ainfo,player_num)){
1655                         send_message = 0;
1656                 }
1657         }
1658
1659         // this is the _response_
1660         if ( send_message ){
1661                 message_send_builtin_to_player( message, &Ships[shipnum], MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_ANYTIME, 0, 0, player_num, -1 );
1662         }
1663
1664         return send_message;
1665 }
1666
1667 // function to send a command to a wing.  Like above function, called from one of two places
1668 //
1669 // if local and addr are non-null, it means the function is being called by the (multiplayer) server in response to
1670 // a PLAYER_COMMAND_PACKET
1671 //
1672 // returns whether or not a message was sent
1673 int hud_squadmsg_send_wing_command( int wingnum, int command, int send_message, int player_num )
1674 {
1675         ai_info *ainfo;
1676         int ai_mode, ai_submode;                                        // ai mode and submode needed for ship commands
1677         char *target_shipname;                                          // ship number of possible targets
1678         int message_sent, message;
1679         int target_team, wing_team;                             // team for the wing and the player's target
1680         ship *ordering_shipp;
1681
1682         // quick short circuit here because of actually showing comm menu even though you cannot message.
1683         // just a safety net.
1684         if ( (Game_mode & GM_MULTIPLAYER) && (player_num != -1) ) {
1685                 if ( !multi_can_message(&Net_players[player_num]) ) {
1686                         return 0;
1687                 }
1688         }
1689
1690         // check for multiplayer mode
1691         if((Game_mode & GM_MULTIPLAYER) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER)){
1692                 send_player_order_packet(SQUAD_MSG_WING, wingnum,command);
1693                 return 0;
1694         }
1695
1696         ai_mode = AI_GOAL_NONE;                                                 // needs to be initialized
1697         ai_submode = -1234567;
1698         ainfo = Player_ai;
1699
1700         if ( player_num != -1 )
1701                 ainfo = &Ai_info[Ships[Objects[Net_players[player_num].player->objnum].instance].ai_index];
1702
1703         Assert( ainfo->shipnum != -1 );
1704         ordering_shipp = &Ships[ainfo->shipnum];
1705
1706         // get the shipnum of the ship the player has targeted.  Used in enough places to do this just
1707         // once.  If the ship targeted is part of the wing that was messages -- bail out!!!
1708
1709         // a shortcut to save on repetative coding
1710         message = MESSAGE_NOSIR;
1711         if ( (command & TARGET_MESSAGES) && (ainfo->target_objnum == -1) )
1712                 message = MESSAGE_NO_TARGET;
1713
1714         if ( hud_squadmsg_is_target_order_valid(command, 1, ainfo) ) {
1715
1716                 target_shipname = NULL;
1717                 target_team = -1;
1718                 if ( ainfo->target_objnum != -1) {
1719                         if ( Objects[ainfo->target_objnum].type == OBJ_SHIP ) {
1720                                 target_shipname = Ships[Objects[ainfo->target_objnum].instance].ship_name;              // I think this is right
1721                                 target_team = Ships[Objects[ainfo->target_objnum].instance].team;
1722                         }
1723                 }
1724
1725                 Assert ( ainfo->shipnum != -1 );
1726                 Assert ( (wingnum >= 0) && (wingnum < num_wings) );
1727
1728                 // get the team for the wing
1729                 Assert ( Wings[wingnum].ship_index[0] != -1 );
1730                 wing_team = Ships[Wings[wingnum].ship_index[0]].team;
1731
1732                 switch ( command ) {                                                                    // value of k matches the #defines for ship messages
1733                 case ATTACK_TARGET_ITEM:
1734                         if ( Objects[ainfo->target_objnum].type == OBJ_SHIP ) {
1735                                 Assert( target_shipname );
1736                                 Assert( wing_team != target_team );
1737                                 if ( (Ships[Objects[ainfo->target_objnum].instance].wingnum != -1) && (Ships[Objects[ainfo->target_objnum].instance].wingnum == wingnum) ) {
1738                                         message = MESSAGE_NOSIR;
1739                                         ai_mode = AI_GOAL_NONE;
1740                                 } else {
1741                                         ai_mode = AI_GOAL_CHASE;
1742                                         ai_submode = SM_ATTACK;
1743                                         message = MESSAGE_ATTACK_TARGET;
1744                                 }
1745                         } else if ( Objects[ainfo->target_objnum].type == OBJ_WEAPON ) {
1746                                 ai_mode = AI_GOAL_CHASE_WEAPON;
1747                                 ai_submode = Objects[ainfo->target_objnum].instance;                    // store the instance of the weapon -- ai goals code will deal with it
1748                                 message = MESSAGE_ATTACK_TARGET;
1749                         } else
1750                                 Int3();
1751
1752                         break;
1753
1754                 case DISABLE_TARGET_ITEM:
1755                         Assert( target_shipname );
1756                         Assert( wing_team != target_team );
1757
1758                         ai_mode = AI_GOAL_DISABLE_SHIP;
1759                         ai_submode = -SUBSYSTEM_ENGINE;
1760                         message = MESSAGE_DISABLE_TARGET;
1761                         break;
1762
1763                 case DISARM_TARGET_ITEM:
1764                         Assert( target_shipname );
1765                         Assert( wing_team != target_team );
1766
1767                         ai_mode = AI_GOAL_DISARM_SHIP;
1768                         ai_submode = -SUBSYSTEM_TURRET;
1769                         message = MESSAGE_DISARM_TARGET;
1770                         break;
1771
1772                 case DISABLE_SUBSYSTEM_ITEM:
1773                         Assert( target_shipname );
1774                         Assert( wing_team != target_team );
1775                         Assert( ainfo->targeted_subsys != NULL );
1776                         Assert( ainfo->targeted_subsys->current_hits > 0.0f);
1777
1778                         ai_mode = AI_GOAL_DESTROY_SUBSYSTEM;
1779                         ai_submode = ship_get_subsys_index( &Ships[Objects[ainfo->target_objnum].instance], ainfo->targeted_subsys->system_info->subobj_name );
1780                         message = MESSAGE_ATTACK_TARGET;
1781                         break;
1782
1783
1784                 case PROTECT_TARGET_ITEM:
1785                         Assert( target_shipname );
1786                         Assert( wing_team == target_team );
1787
1788                         ai_mode = AI_GOAL_GUARD;
1789                         ai_submode = AIS_GUARD_PATROL;
1790                         message = MESSAGE_YESSIR;
1791                         break;
1792
1793                 case IGNORE_TARGET_ITEM:
1794                         Assert( target_shipname );
1795                         Assert( wing_team != target_team );
1796
1797                         ai_mode = AI_GOAL_IGNORE;
1798                         ai_submode = 0; //      actually, a don't care.
1799                         message = MESSAGE_YESSIR;
1800                         break;
1801
1802                 case FORMATION_ITEM:
1803                         message = MESSAGE_YESSIR;
1804                         target_shipname = ordering_shipp->ship_name;
1805                         ai_mode = AI_GOAL_FORM_ON_WING;
1806                         ai_submode = 0;
1807                         break;
1808
1809                 case COVER_ME_ITEM:
1810                         ai_mode = AI_GOAL_GUARD;
1811                         ai_submode = AIS_GUARD_PATROL;
1812                         target_shipname = ordering_shipp->ship_name;
1813                         message = MESSAGE_YESSIR;
1814                         break;
1815
1816                 case ENGAGE_ENEMY_ITEM:
1817                         ai_mode = AI_GOAL_CHASE_ANY;
1818                         ai_submode = SM_ATTACK;
1819                         if ( hud_squadmsg_enemies_present() )
1820                                 message = MESSAGE_YESSIR;
1821                         else
1822                                 message = MESSAGE_ENGAGE;
1823                         target_shipname = NULL;
1824                         break;
1825
1826                 case DEPART_ITEM:
1827                         ai_mode = AI_GOAL_WARP;
1828                         ai_submode = -1;
1829                         message = MESSAGE_WARP_OUT;
1830                         Wings[wingnum].flags |= WF_DEPARTURE_ORDERED;
1831                         break;
1832
1833                 case REARM_REPAIR_ME_ITEM:
1834                 case ABORT_REARM_REPAIR_ITEM:
1835                 case STAY_NEAR_ME_ITEM:
1836                 case STAY_NEAR_TARGET_ITEM:
1837                 case KEEP_SAFE_DIST_ITEM:
1838                         return 0;
1839
1840                 default:
1841                         Int3();                                                                         // get Allender -- illegal message
1842                         break;
1843
1844                 }
1845
1846                 if ( ai_mode != AI_GOAL_NONE ) {
1847                         Assert(ai_submode != -1234567);
1848                         ai_add_wing_goal_player( AIG_TYPE_PLAYER_WING, ai_mode, ai_submode, target_shipname, wingnum );
1849                 }
1850         }
1851
1852         // if we're in multiplayer mode, and we're the server, determine if this virtual squadmate order should be
1853         // sent to other players in the game as an actual "order"
1854         if((Game_mode & GM_MULTIPLAYER) && (message != MESSAGE_NOSIR)){
1855                 // if there's at least one ai ship which got the command, let the response come through
1856                 if(multi_msg_eval_wing_squadmsg(wingnum,command,ainfo,player_num)){
1857                         send_message = 0;
1858                 }
1859         }
1860
1861         // this is the _response_
1862         message_sent = 0;
1863         if ( send_message ) {
1864                 int ship_num;
1865
1866                 // get a random ship in the wing to send the message to the player
1867                 ship_num = ship_get_random_ship_in_wing( wingnum, SHIP_GET_NO_PLAYERS );
1868
1869                 // in multiplayer, its possible that all ships in a wing are players. so we'll just send from a random ship
1870                 if(ship_num == -1){
1871                         ship_num = ship_get_random_ship_in_wing(wingnum);
1872                 }
1873
1874                 // only send message if ship is found.  There appear to be cases where all ships
1875                 // in a wing die in the same frame causing the wing to appear valid in the message
1876                 // menu, but the get_random_ship* functions won't return dying ships.
1877                 if ( ship_num != -1 ) {
1878                         message_send_builtin_to_player( message, &Ships[ship_num], MESSAGE_PRIORITY_NORMAL, MESSAGE_TIME_ANYTIME, 0, 0, player_num, -1 );
1879                         message_sent = 1;
1880                 }
1881         }
1882
1883         return message_sent;
1884 }
1885
1886
1887 // return number of available reinforcements, 0 if none available
1888 int hud_squadmsg_reinforcements_available(int team)
1889 {
1890         int i, count = 0;
1891
1892         for (i = 0; i < Num_reinforcements; i++) {
1893                 int wingnum;
1894
1895                 // no more left
1896                 if ( Reinforcements[i].num_uses >= Reinforcements[i].uses ){
1897                         continue;
1898                 }
1899
1900                 // incorrect team
1901                 if ( team != ship_get_reinforcement_team(i) ){
1902                         continue;
1903                 }
1904
1905                 //  check the arrival cue sexpression of the ship/wing of this reinforcement.  If known
1906                 //  false, it doesn't count either
1907                 if ( (wingnum = wing_name_lookup(Reinforcements[i].name, 1)) != -1 ) {
1908                         Assert ( Wings[wingnum].arrival_cue >= 0 );
1909                         if ( Sexp_nodes[Wings[wingnum].arrival_cue].value == SEXP_KNOWN_FALSE ){
1910                                 continue;
1911                         }
1912                 } else {
1913                         p_object *p_objp;
1914
1915                         p_objp = mission_parse_get_arrival_ship( Reinforcements[i].name );
1916                         if ( p_objp != NULL ) {
1917                                 if ( Sexp_nodes[p_objp->arrival_cue].value == SEXP_KNOWN_FALSE ){
1918                                         continue;
1919                                 }
1920                         } else {
1921                                 Int3();                                                 // allender says bogus!  reinforcement should be here since it wasn't a wing!
1922                                 continue;
1923                         }
1924                 }
1925                 count++;
1926         }
1927
1928         return count;
1929 }
1930
1931 // function to put up window in upper right to allow for player to select the type
1932 // of entity to select for a message (i.e. a wing or a ship)
1933 void hud_squadmsg_type_select( )
1934 {
1935         int k, i;
1936
1937         First_menu_item = 0;
1938
1939         // Add the items
1940         for (i=0; i<NUM_TYPE_SELECT; i++ )      {
1941                 strcpy( MsgItems[i].text, type_select_str(i) );
1942                 MsgItems[i].active = 1;                                         // assume active
1943         }
1944         Num_menu_items = NUM_TYPE_SELECT;
1945
1946
1947         // check to see if the players team is TEAM_TRAITOR.  If so, then he is a "traitor", and will not
1948         // be able to do anything from this menu
1949         if ( Player_ship->team == TEAM_TRAITOR ) {
1950                 for (i = 0; i < MAX_MENU_ITEMS; i++ )
1951                         MsgItems[i].active = 0;
1952                 goto do_main_menu;
1953         }
1954
1955         // based on ship counts, wing counts, shortcut active, grey out possible menu choices
1956         if ( !hud_squadmsg_count_ships(0) )
1957                 MsgItems[TYPE_SHIP_ITEM].active = 0;
1958
1959         if ( !hud_squadmsg_count_wings(0) )
1960                 MsgItems[TYPE_WING_ITEM].active = 0;
1961
1962         // check to be sure that we have some fighters/bombers on the players team that we
1963         // can message
1964         if ( !hud_squadmsg_count_fighters() ){
1965                 MsgItems[TYPE_ALL_FIGHTERS_ITEM].active = 0;
1966         }
1967
1968         if ((Player_ship != NULL) && !hud_squadmsg_reinforcements_available(Player_ship->team)) {
1969                 MsgItems[TYPE_REINFORCEMENT_ITEM].active = 0;
1970         }
1971
1972         MsgItems[TYPE_REPAIR_REARM_ITEM].active = 1;                            // this item will always be available (I think)
1973         MsgItems[TYPE_REPAIR_REARM_ABORT_ITEM].active = 0;
1974
1975         // AL: 10/13/97
1976         // If the player ship communications are severely damaged, then the player
1977         // will only be able to call for repair/rearm ships
1978         //
1979         // also, only allow support ship if this player is not allowed to messaage.
1980         if ( (hud_communications_state(Player_ship) != COMM_OK) || ((Game_mode & GM_MULTIPLAYER) && !multi_can_message(Net_player)) ) {
1981                 for ( i = 0; i < MAX_MENU_ITEMS; i++ ){
1982                         MsgItems[i].active = 0;
1983                 }
1984
1985                 MsgItems[TYPE_REPAIR_REARM_ITEM].active = 1;
1986         }
1987
1988         // check to see if the player is awaiting repair or being repaired.  Active the abort and inactive the repair items
1989         // check to see if the player is scheduled to be repaired by incoming ship
1990         if ( Ai_info[Ships[Player_obj->instance].ai_index].ai_flags & (AIF_AWAITING_REPAIR | AIF_BEING_REPAIRED) ) {
1991                 MsgItems[TYPE_REPAIR_REARM_ITEM].active = 0;
1992                 MsgItems[TYPE_REPAIR_REARM_ABORT_ITEM].active = 1;
1993         } else if ( mission_is_repair_scheduled(Player_obj) ) {
1994                 MsgItems[TYPE_REPAIR_REARM_ITEM].active = 0;
1995                 MsgItems[TYPE_REPAIR_REARM_ABORT_ITEM].active = 1;
1996         }
1997
1998         // if no support available, can't call one in
1999         if ( !is_support_allowed(Player_obj) ) {
2000                 MsgItems[TYPE_REPAIR_REARM_ITEM].active = 0;
2001                 MsgItems[TYPE_REPAIR_REARM_ABORT_ITEM].active = 0;
2002         }
2003
2004         // de-activate the rearm/repair item if the player has a full load of missiles and
2005         // all subsystems at full strength.  We will only check if this item hasn't been marked
2006         // inactive because of some other reason
2007         if ( MsgItems[TYPE_REPAIR_REARM_ITEM].active ) {
2008
2009                 if ( !hud_squadmsg_can_rearm(Player_ship) ){
2010                         MsgItems[TYPE_REPAIR_REARM_ITEM].active = 0;
2011                 }
2012         }
2013
2014         // if using keyboard shortcut, these items are always inactive
2015         if ( Msg_shortcut_command != -1 ) {
2016                 MsgItems[TYPE_REPAIR_REARM_ITEM].active = 0;
2017                 MsgItems[TYPE_REINFORCEMENT_ITEM].active = 0;
2018                 MsgItems[TYPE_REPAIR_REARM_ABORT_ITEM].active = 0;
2019         }
2020
2021 do_main_menu:
2022         hud_squadmsg_display_menu( XSTR( "Message What", 316) );
2023         k = hud_squadmsg_get_key();
2024         if ( k != -1 ) {                                                        // when k != -1, we have a key that associates with menu item
2025                 Assert ( k < Num_menu_items );
2026                 if ( k == TYPE_SHIP_ITEM ){
2027                         hud_squadmsg_do_mode( SM_MODE_SHIP_SELECT );
2028                 } else if ( k == TYPE_WING_ITEM ) {
2029                         hud_squadmsg_do_mode( SM_MODE_WING_SELECT );
2030                 } else if ( k == TYPE_ALL_FIGHTERS_ITEM ) {
2031                         hud_squadmsg_do_mode( SM_MODE_ALL_FIGHTERS );
2032                 }
2033
2034                 if ( Msg_shortcut_command == -1 ) {
2035                         if ( k == TYPE_REINFORCEMENT_ITEM ) {
2036                                 hud_squadmsg_do_mode( SM_MODE_REINFORCEMENTS );
2037                                 player_set_next_all_alone_msg_timestamp();
2038                         } else if ( k == TYPE_REPAIR_REARM_ITEM ){
2039                                 hud_squadmsg_do_mode( SM_MODE_REPAIR_REARM );
2040                         } else if ( k == TYPE_REPAIR_REARM_ABORT_ITEM ) {
2041                                 hud_squadmsg_do_mode( SM_MODE_REPAIR_REARM_ABORT );
2042                         }
2043                 }
2044         }
2045 }
2046
2047 // function to display a list of ships to send a command to
2048 void hud_squadmsg_ship_select()
2049 {
2050         int k;
2051
2052         if ( Num_menu_items == -1 ) {
2053                 Num_menu_items = 0;
2054                 hud_squadmsg_count_ships( 1 );
2055         }
2056
2057         hud_squadmsg_display_menu( XSTR( "Select Ship", 317) );
2058         k = hud_squadmsg_get_key();
2059         if ( k != -1 ) {                                                // if true, we have selected a ship.
2060                 if ( Msg_shortcut_command == -1 ) {
2061                         Msg_instance = MsgItems[First_menu_item + k].instance;          // store the instance id in a global
2062                         hud_squadmsg_do_mode( SM_MODE_SHIP_COMMAND );                           // and move to a new mode
2063                 } else {
2064                         // we must convert the Msg_shortcut_command value to a value that the message
2065                         // system normally uses to select a command.  Since the menu
2066                         Assert( Msg_shortcut_command != IGNORE_TARGET_ITEM );
2067                         hud_squadmsg_send_ship_command( MsgItems[First_menu_item+k].instance, Msg_shortcut_command, 1 );
2068                         hud_squadmsg_toggle();
2069                 }
2070         }
2071
2072 }
2073
2074 // function to display a list of ships to send a command to
2075 void hud_squadmsg_wing_select()
2076 {
2077         int k;
2078
2079         if ( Num_menu_items == -1 ) {
2080                 Num_menu_items = 0;
2081                 hud_squadmsg_count_wings( 1 );
2082         }
2083
2084         hud_squadmsg_display_menu( XSTR( "Select Wing", 318) );
2085         k = hud_squadmsg_get_key();
2086         if ( k != -1 ) {                                                // if true, we have selected a ship.
2087                 if ( Msg_shortcut_command == -1 ) {                                                                     // do normal menu stuff when no hoykey active
2088                         Msg_instance = MsgItems[First_menu_item + k].instance;  // store the instance id in a global
2089                         hud_squadmsg_do_mode( SM_MODE_WING_COMMAND );                           // and move to a new mode
2090                 } else {
2091                         Assert( Msg_shortcut_command != IGNORE_TARGET_ITEM );
2092                         hud_squadmsg_send_wing_command( MsgItems[First_menu_item+k].instance, Msg_shortcut_command, 1 );
2093                         hud_squadmsg_toggle();
2094                 }
2095         }
2096
2097 }
2098
2099 // code which gives an order to all fighters/bombers.  If there is a message shortcut active, then
2100 // make that order apply to all fighters/bombers.  Otherwise, move to the ship_command menu
2101 void hud_squadmsg_msg_all_fighters()
2102 {
2103         if ( Msg_shortcut_command == -1 ) {
2104                 Msg_instance = MESSAGE_ALL_FIGHTERS;
2105                 hud_squadmsg_do_mode( SM_MODE_SHIP_COMMAND );
2106         } else {
2107                 hud_squadmsg_send_to_all_fighters( Msg_shortcut_command );
2108                 hud_squadmsg_toggle();
2109         }
2110 }
2111
2112 // called to actually bring in a reinforcement.  For single player games, always gets called.
2113 // for multiplayer games, always called on the server side.  Clients should never get here
2114 void hud_squadmsg_call_reinforcement(int reinforcement_num, int player_num)
2115 {
2116         int i, delay;
2117         reinforcements *rp;
2118         p_object *p_objp;
2119
2120         rp = &Reinforcements[reinforcement_num];
2121
2122         // safety net mainly for multiplayer servers in case some odd data desync occurs between
2123         // server and clients
2124         if ( MULTIPLAYER_MASTER && (rp->num_uses == rp->uses) ) {
2125                 return;
2126         }
2127
2128         // check to see if the reinforcement called was a wing.
2129         for (i = 0; i < num_wings; i++ ) {
2130                 if ( !stricmp(rp->name, Wings[i].name) ) {
2131                         // found a wingname.  Call the parse function to create all the ships in this wing
2132                         // we must set the arrival cue of the wing to true, otherwise, this won't work!!
2133                         Wings[i].flags &= ~WF_REINFORCEMENT;
2134                         Wings[i].flags |= WF_RESET_REINFORCEMENT;
2135
2136                         // set up the arrival delay.  If it is 0, then make is some random number of seconds
2137                         delay = rp->arrival_delay;
2138                         if ( delay == 0 )
2139                                 delay = (int)(frand() * 3.0) + 3;
2140                         Wings[i].arrival_delay = timestamp(delay * 1000);
2141                         break;
2142                 }
2143         }
2144
2145         // if we found no wing name that matched the reinforcement name, then look for a ship
2146         // of the same name
2147         if ( i == num_wings ) {
2148                 p_objp = mission_parse_get_arrival_ship( rp->name );
2149                 if ( p_objp ) {
2150                         // by resetting the reinforcement flag, we will allow code which normally handles arrivals
2151                         // to make this reinforcement arrive.  Doing so keeps the data structures clean.
2152                         p_objp->flags &= ~P_SF_REINFORCEMENT;
2153
2154                         // set up the arrival delay
2155                         delay = rp->arrival_delay;
2156                         if ( delay == 0 )
2157                                 delay = (int)(frand() * 3.0) + 3;               // between 3 and 6 seconds to arrive
2158                         p_objp->arrival_delay = timestamp(delay * 1000);
2159                 } else {
2160                         Int3();                         // get allender -- I don't think that this can happen!!!!
2161                         return;
2162                 }
2163         }
2164
2165         // increment the number of times this is used.  Incremented here on single player and multiplayer
2166         // server side only.  Clients keep track of own count when they actually call something in.
2167         rp->num_uses++;
2168
2169         // commented out on 9/9/98 because these messages simply are not used
2170         /*
2171         // now play a message (if there is one to play) for this reinforcement arrival.  The first for loop
2172         // determine how many messages there are to play, since the array is packet.  Then, if >= 1 message
2173         // to play, play one
2174         for (i = 0; i < MAX_REINFORCEMENT_MESSAGES; i++ )
2175                 if ( !strlen(rp->yes_messages[i]) )
2176                         break;
2177
2178         //if ( i > 0 )
2179         //      message_send_to_player( rp->yes_messages[myrand() % i], rp->name, MESSAGE_PRIORITY_NORMAL, HUD_SOURCE_FRIENDLY );
2180         */
2181
2182         mission_log_add_entry(LOG_PLAYER_REINFORCEMENT, rp->name, NULL);
2183 }
2184
2185 // function to display a list of reinforcements available to the player
2186 void hud_squadmsg_reinforcement_select()
2187 {
2188         int i, k;
2189         reinforcements *rp;
2190
2191         if ( Num_menu_items == -1 ) {
2192                 Num_menu_items = 0;
2193                 for (i = 0; i < Num_reinforcements; i++) {
2194                         rp = &Reinforcements[i];
2195
2196                         // don't put reinforcements onto the list that have already been used up.
2197                         if ( (rp->num_uses == rp->uses) ){
2198                                 continue;
2199                         }
2200
2201                         // don't put items which are not on my team
2202                         if((Player_ship != NULL) && (ship_get_reinforcement_team(i) != Player_ship->team)){
2203                                 continue;
2204                         }
2205
2206                         Assert ( Num_menu_items < MAX_MENU_ITEMS );
2207                         strcpy( MsgItems[Num_menu_items].text, rp->name );
2208                         MsgItems[Num_menu_items].instance = i;
2209                         MsgItems[Num_menu_items].active = 0;
2210
2211                         if ( rp->flags & RF_IS_AVAILABLE ) {
2212                                 MsgItems[Num_menu_items].active = 1;
2213                         }
2214
2215                         Num_menu_items++;
2216                 }
2217         }
2218
2219 //      hud_squadmsg_display_menu( "Select Reinforcement" );
2220         hud_squadmsg_display_menu( XSTR( "Select Ship/Wing", 319) );    // AL 11-14-97: Reinforcement didn't fit, so using this for now
2221         k = hud_squadmsg_get_key();
2222         if (k != -1) {
2223                 int rnum;
2224
2225                 hud_squadmsg_toggle();                                          // take us out of message mode
2226
2227                 rnum = MsgItems[First_menu_item + k].instance;
2228
2229                 // check to see if trying to call a reinforcement not yet available.  If so, maybe play message, but
2230                 // definately bail
2231                 if ( MsgItems[First_menu_item + k].active == 0 ) {
2232                         return;
2233                 }
2234
2235                 // in single player, or a multiplayer master, call in the reinforcement.  Clients send a packet to the
2236                 // server
2237                 if ( MULTIPLAYER_CLIENT ) {
2238                         Reinforcements[rnum].num_uses++;                        // increment this variable here since clients need to maintain a valid count
2239                         send_player_order_packet(SQUAD_MSG_REINFORCEMENT, rnum, 0);
2240                 } else {
2241                         hud_squadmsg_call_reinforcement(rnum);
2242                 }
2243         }
2244 }
2245
2246 // function to display list of commands for a ship
2247 void hud_squadmsg_ship_command()
2248 {
2249         int k;
2250         int i, orders, default_orders;
2251
2252         // when adding ship commands, we must look at the type of ship, and what messages that
2253         // ship allows.  First, place all messages that are possible onto the menu, then
2254
2255         // see if messaging all ships or just one.  Messaging all ships will mean all default orders
2256         // show on comm menu.
2257         if ( Msg_instance != MESSAGE_ALL_FIGHTERS ) {
2258                 orders = Ships[Msg_instance].orders_accepted;
2259                 default_orders = ship_get_default_orders_accepted( &Ship_info[Ships[Msg_instance].ship_info_index] );
2260         } else {
2261
2262                 default_orders = FIGHTER_MESSAGES;
2263                 orders = default_orders;
2264         }
2265
2266         First_menu_item = 0;
2267         Num_menu_items = 0;
2268         for ( i = 0; i < MAX_SHIP_ORDERS; i++ ) {
2269                 // check to see if the comm order should even be added to the menu -- if so, then add it
2270                 // the order will be activated if the bit is set for the ship.
2271                 if ( default_orders & Comm_orders[i].value ) {
2272                         Assert ( Num_menu_items < MAX_MENU_ITEMS );
2273                         strcpy( MsgItems[Num_menu_items].text, comm_order_menu_text(i) );
2274                         MsgItems[Num_menu_items].instance = Comm_orders[i].value;
2275                         MsgItems[Num_menu_items].active = 0;
2276                         // check the bit to see if the command is active
2277                         if ( orders & Comm_orders[i].value )
2278                                 MsgItems[Num_menu_items].active = 1;
2279
2280                         // if the order cannot be carried out by the ship, then item should be inactive
2281                         if ( (Msg_instance != MESSAGE_ALL_FIGHTERS) && !hud_squadmsg_ship_order_valid( Msg_instance, Comm_orders[i].value ) )
2282                                 MsgItems[Num_menu_items].active = 0;
2283
2284                         // do some other checks to possibly gray out other items.
2285                         // if no target, remove any items which are associated with the players target
2286                         if ( !hud_squadmsg_is_target_order_valid(i, 0) )
2287                                 MsgItems[Num_menu_items].active = 0;
2288
2289                         // if messaging all fighters, see if we should gray out the order if no one will accept it,
2290                         // or modify the text if only some of the ships will accept it
2291                         if ( Msg_instance == MESSAGE_ALL_FIGHTERS ) {
2292                                 ship_obj *so;
2293                                 ship *shipp;
2294                                 int partial_accept, all_accept;                 // value which tells us what to do with menu item
2295
2296                                 all_accept = Comm_orders[i].value;
2297                                 partial_accept = 0;
2298                                 for ( so = GET_FIRST(&Ship_obj_list); so != END_OF_LIST(&Ship_obj_list); so = GET_NEXT(so) ) {
2299
2300                                         // don't send messge to ships not on player's team, or that are in a wing.
2301                                         shipp = &Ships[Objects[so->objnum].instance];
2302                                         if ( shipp->team != Player_ship->team )
2303                                                 continue;
2304
2305                                         // don't send message to non fighter wings
2306                                         if ( !(Ship_info[shipp->ship_info_index].flags & (SIF_FIGHTER | SIF_BOMBER)) )
2307                                                 continue;
2308
2309                                         all_accept &= shipp->orders_accepted;           // 'and'ing will either keep this bit set or zero it properly
2310                                         partial_accept |= (shipp->orders_accepted & Comm_orders[i].value);      // 'or'ing will tell us if at least one accepts
2311                                 }
2312
2313                                 if ( !all_accept ) {
2314                                         // either modify the text if a partial accept, or grey it out if no one accepts
2315                                         if ( partial_accept ) {
2316                                                 strcat( MsgItems[Num_menu_items].text, XSTR( "(*)", 320) );
2317                                         } else {
2318                                                 MsgItems[Num_menu_items].active = 0;
2319                                         }
2320                                 }
2321                         }
2322
2323                         Num_menu_items++;
2324                 }
2325         }
2326
2327         hud_squadmsg_display_menu( XSTR( "What Command", 321) );
2328         k = hud_squadmsg_get_key();
2329
2330         // when we get a valid goal, we must add the goal to the ai ship's goal list
2331
2332         if ( k != -1 ) {
2333                 Assert ( k < Num_menu_items );
2334                 // when messaging all fighters or ignoring target, call the send_to_all_fighters routine
2335                 if ( (Msg_instance != MESSAGE_ALL_FIGHTERS) && (MsgItems[k].instance != IGNORE_TARGET_ITEM) )
2336                         hud_squadmsg_send_ship_command( Msg_instance, MsgItems[k].instance, 1 );
2337                 else
2338                         hud_squadmsg_send_to_all_fighters( MsgItems[k].instance );
2339                 hud_squadmsg_toggle();
2340         }
2341 }
2342
2343 // function to display list of command for a wing
2344 void hud_squadmsg_wing_command()
2345 {
2346         int k;
2347         wing *wingp;
2348         int default_orders, i, orders;
2349
2350         // when adding commands for wings, we will look at all of the ships in the wing, and create
2351         // the order list from that set of ships.  In the future, we may want to do something else....
2352
2353         wingp = &Wings[Msg_instance];
2354
2355         // or together all of the orders for all the ships in the wing
2356         default_orders = 0;
2357         for ( i = 0; i < wingp->current_count; i++ ) {
2358                 orders = ship_get_default_orders_accepted( &Ship_info[Ships[wingp->ship_index[i]].ship_info_index] );
2359                 default_orders |= orders;
2360         }
2361         default_orders &= ~CAPTURE_TARGET_ITEM;         // we cannot capture any target with a wing.
2362
2363         Num_menu_items = 0;
2364         orders = Ships[wingp->ship_index[0]].orders_accepted;           // get the orders that the first ship in the wing will accept
2365         for ( i = 0; i < MAX_SHIP_ORDERS; i++ ) {
2366                 // add the set of default orders to the comm menu.  We will currently allow all messages
2367                 // to be available in the wing.
2368                 if ( default_orders & Comm_orders[i].value ) {
2369                         Assert ( Num_menu_items < MAX_MENU_ITEMS );
2370                         strcpy( MsgItems[Num_menu_items].text, comm_order_menu_text(i) );
2371                         MsgItems[Num_menu_items].instance = Comm_orders[i].value;
2372                         MsgItems[Num_menu_items].active = 0;
2373
2374                         // possibly grey out the menu item depending on whether or not the "wing" will accept this order
2375                         // the "wing" won't accept the order if the first ship in the wing doesn't accept it.
2376                         if ( orders & Comm_orders[i].value )
2377                                 MsgItems[Num_menu_items].active = 1;
2378
2379                         // do some other checks to possibly gray out other items.
2380                         // if no target, remove any items which are associated with the players target
2381                         if ( !hud_squadmsg_is_target_order_valid(i, 0) )
2382                                 MsgItems[Num_menu_items].active = 0;
2383
2384                         Num_menu_items++;
2385                 }
2386         }
2387
2388         hud_squadmsg_display_menu( XSTR( "What Command", 321) );
2389         k = hud_squadmsg_get_key();
2390         if ( k != -1 ) {
2391
2392                 // ignore target gets sent to everyone.
2393                 if ( MsgItems[k].instance != IGNORE_TARGET_ITEM )
2394                         hud_squadmsg_send_wing_command( Msg_instance, MsgItems[k].instance, 1 );
2395                 else
2396                         hud_squadmsg_send_to_all_fighters( MsgItems[k].instance );
2397                 hud_squadmsg_toggle();
2398         }
2399 }
2400
2401
2402
2403 //----------------------------------------------------------
2404 // external entry points below!!!!
2405
2406 // when starting messaging mode, we must remove old bindings from the
2407 // keys that are used for messaging mode (which will get restored when
2408 // messaging mode is done).
2409
2410 // this code below will get called only the key config changes (from ControlsConfig.cpp)
2411 // or if the bindings haven't been saved yet.  This code doesn't remove the bindings
2412 // but just sets up the array so that the bindings can be removed when messaging
2413 // mode is entered.
2414 //
2415 // do_scroll indicates whether we should save the page up and page down keys
2416 void hud_squadmsg_save_keys( int do_scroll )
2417 {
2418 //      int i, j;
2419
2420         num_keys_saved = 0;
2421
2422 /*
2423         for ( j=0; j<MAX_KEYS_USED; j++ ) {
2424                 for ( i=0; Control_config[i].text[0]; i++ ) {   // the text field in this structure is empty at the end of the config list
2425                         if ( Control_config[i].key_id == keys_used[j] ) {               // this is true if we have a match
2426
2427                                 // if we are not saving scrolling keys and we are trying to match page up and page down
2428                                 // then skip them.
2429                                 if ( !do_scroll && ((keys_used[j] == KEY_PAGEDOWN) || (keys_used[j] == KEY_PAGEUP)) )
2430                                         continue;
2431
2432                                 Assert( num_keys_saved < MAX_KEYS_USED );
2433                                 key_save[num_keys_saved].option_num = i;
2434                                 key_save[num_keys_saved].key_value = keys_used[j];
2435                                 num_keys_saved++;
2436                                 break;  // done with this key -- move to next.
2437                         }
2438                 }
2439         }
2440 */
2441 }
2442
2443 // function is called once per mission start.  Initializes those values
2444 // which only need to be inited once per mission.
2445 void hud_init_squadmsg( void )
2446 {
2447         int i;
2448
2449         if ( !Mbox_frames_loaded ) {
2450                 for ( i = 0; i < NUM_MBOX_FRAMES; i++ ) {
2451                         Mbox_gauge[i].first_frame = bm_load_animation(Mbox_fnames[gr_screen.res][i], &Mbox_gauge[i].num_frames);
2452                         if ( Mbox_gauge[i].first_frame == -1 ) {
2453                                 Warning(LOCATION, "Could not load in ani: %s\n", Mbox_fnames[gr_screen.res][i]);
2454                                 return;
2455                         }
2456                 }
2457                 Mbox_frames_loaded = 1;
2458         }
2459
2460         Msg_eat_key_timestamp = timestamp(0);
2461 }
2462
2463 // external entry point into code which changes the messaging mode based on the
2464 // previous player flag value.  I thought it better to isolate all system changes
2465 // in this code.
2466 void hud_squadmsg_toggle()
2467 {
2468         // if the emp effect is active, always ignore this
2469         if(emp_active_local()){
2470                 return;
2471         }
2472
2473         // if entering this mode, must setup messaging system.  Don't start squadmessging if
2474         // the player is dead.
2475         if ( !(Player->flags & PLAYER_FLAGS_MSG_MODE) ) {
2476                 if ( Game_mode & GM_DEAD ){
2477                         return;
2478                 }
2479                 if ( (Game_mode & GM_MULTIPLAYER) && NETPLAYER_IS_OBSERVER(Net_player) ){
2480                         return;
2481                 }
2482                 hud_squadmsg_start();
2483         } else {
2484                 hud_squadmsg_end();
2485         }
2486
2487         Player->flags ^= PLAYER_FLAGS_MSG_MODE;
2488 }
2489
2490 //#ifndef NDEBUG
2491 // extern entry point to allow messaging of enemies
2492 void hud_enemymsg_toggle()
2493 {
2494         hud_squadmsg_toggle();
2495         // if we just entered message mode, turn on var that says to message enemies
2496         if ( Player->flags & PLAYER_FLAGS_MSG_MODE )
2497                 Msg_enemies = 1;
2498 }
2499 //#endif
2500
2501 // external entry point into code when a keyboard shortcut is used for a command
2502 // we are passed in an ID for the command to set internal variables.  This command
2503 // will be used in place of the last menu in the messaging code
2504 void hud_squadmsg_shortcut( int command )
2505 {
2506         // check if the communications system is capable of sending a message
2507         if ( (hud_communications_state(Player_ship, 1) != COMM_OK) && (command != REARM_REPAIR_ME_ITEM) ) {
2508                 return;
2509         }
2510
2511         // observers in multiplayer games cannot have this active either
2512         if ( (Game_mode & GM_MULTIPLAYER) && NETPLAYER_IS_OBSERVER(Net_player) )
2513                 return;
2514
2515         // in multiplayer and I cannot message, don't allow anything except calling in for rearm
2516         if ( (Game_mode & GM_MULTIPLAYER) && !multi_can_message(Net_player) && (command != REARM_REPAIR_ME_ITEM) )
2517                 gamesnd_play_error_beep();
2518
2519         // player ships which turns traitor cannot rearm
2520         if ( Player_ship->team == TEAM_TRAITOR )
2521                 return;
2522
2523         if ( Player->flags & PLAYER_FLAGS_MSG_MODE )            // we are already in messaging mode -- maybe do sometime more interesting?
2524                 return;
2525         hud_squadmsg_toggle();
2526         Msg_shortcut_command = command;                                                                 // save the command for later use
2527         if ( Msg_shortcut_command == CAPTURE_TARGET_ITEM )                      // some commands only apply to wings or ships
2528                 Squad_msg_mode = SM_MODE_SHIP_SELECT;                                           //  -- don't offer choice
2529         else if ( Msg_shortcut_command == IGNORE_TARGET_ITEM ) {        //  ignoring target applied to all ships
2530                 hud_squadmsg_toggle();                                                                                  // turns off mode which was turned on above
2531                 hud_squadmsg_send_to_all_fighters( Msg_shortcut_command );
2532         }
2533 }
2534
2535 // external entry point which is called when the player hits a selection key (1-0) while in messaging
2536 // mode.  If we are in messaging mode, send the shortcut command to the ships that are part of the
2537 // passed in selection set.  If there is no shortcut command, do nothing.  Returns 1 if the key
2538 // was used, else 0.  This return value is used to tell the key control system that it should
2539 // call the normal targeting selection stuff.
2540 int hud_squadmsg_hotkey_select( int k )
2541 {
2542         htarget_list *hitem, *plist;
2543         int send_message;
2544         object *objp;
2545
2546         Assert ( Player->flags & PLAYER_FLAGS_MSG_MODE );
2547
2548         if ( Msg_shortcut_command == -1 )
2549                 return 0;
2550
2551         Assert ( (k >= 0) && (k < MAX_KEYED_TARGETS) );
2552         plist = &(Player->keyed_targets[k]);
2553
2554         if ( EMPTY(plist) )             // be sure that we have at least one ship in the list
2555                 return 0;
2556
2557         send_message = 1;
2558         // for each ship in the selection set list, send the shortcut command that the player
2559         // previously entered.  Be sure to check that we are not trying to send a command to
2560         // an enemy ship.
2561         for ( hitem = GET_FIRST(plist); hitem != END_OF_LIST(plist); hitem = GET_NEXT(hitem) ) {
2562                 objp = hitem->objp;
2563                 Assert ( objp->type == OBJ_SHIP );
2564                 if ( Ships[objp->instance].team != TEAM_FRIENDLY )
2565                         continue;
2566
2567                 // be sure that this ship can accept this command
2568                 // DDOI - I changed this , to & which seeems to be in keeping
2569                 // with similar code.
2570                 if ( !(Msg_shortcut_command & Ships[objp->instance].orders_accepted) )
2571                         continue;
2572
2573                 hud_squadmsg_send_ship_command( objp->instance, Msg_shortcut_command, send_message );
2574                 send_message  = 0;
2575         }
2576
2577         hud_squadmsg_toggle();                  // turn off messaging mode
2578         return 1;
2579 }
2580
2581
2582 // the next function is called once a frame when the player is messaging someone
2583 // in his squad.  After a period of 5 seconds of inactivity (i.e. no keypress to
2584 // select something in the menu), the menu will disappear.  This function will only
2585 // get called if the player flag PLAYER_FLAG_MSG_MODE is set.  Parameter is the key
2586 // that was hit this frame
2587
2588 int hud_squadmsg_do_frame( )
2589 {
2590         int target_changed;
2591
2592         Assert ( Player->flags & PLAYER_FLAGS_MSG_MODE );               // be sure that messaging mode is set!!!
2593
2594         // if the player is now dead, or the timestamp elapsed, then get out of messaging mode.
2595         if ( (Game_mode & GM_DEAD) || timestamp_elapsed(Msg_mode_timestamp) ) {
2596                 hud_squadmsg_toggle();
2597                 return 0;
2598         }
2599
2600         Msg_key_used = 0;
2601
2602         // check the player's current target.  Change in target resets the timer
2603         target_changed = 0;
2604         if ( Msg_target_objnum != Player_ai->target_objnum ) {
2605                 Msg_target_objnum = Player_ai->target_objnum;
2606                 target_changed = 1;
2607         }
2608
2609         if ( Msg_targeted_subsys != Player_ai->targeted_subsys ) {
2610                 Msg_targeted_subsys = Player_ai->targeted_subsys;
2611                 target_changed = 1;
2612         }
2613
2614         // setup color/font info
2615         // hud_set_default_color();
2616         hud_set_gauge_color(HUD_MESSAGE_BOX);
2617
2618         // check for multiplayer mode - this is really a special case checker for support ship requesting and aborting
2619         if((Game_mode & GM_MULTIPLAYER) && !(Net_player->flags & NETINFO_FLAG_AM_MASTER) && (Squad_msg_mode == SM_MODE_REPAIR_REARM || Squad_msg_mode == SM_MODE_REPAIR_REARM_ABORT)){
2620                 char *subsys_name;
2621 //              int who_to_sig;
2622                 ushort net_sig;
2623
2624                 // who_to_sig = Objects[Ships[shipnum].objnum].net_signature;
2625                 if(Player_ai->target_objnum != -1)
2626                         net_sig = Objects[Player_ai->target_objnum].net_signature;
2627                 else
2628                         net_sig = 0;
2629
2630       if ((Player_ai->targeted_subsys != NULL) && (Player_ai->targeted_subsys->current_hits > 0.0f))
2631                         subsys_name = Player_ai->targeted_subsys->system_info->subobj_name;
2632                 else
2633                         subsys_name = NULL;
2634
2635                 // send the correct packet
2636                 if(Squad_msg_mode == SM_MODE_REPAIR_REARM)
2637                         send_player_order_packet(SQUAD_MSG_SHIP, 0, REARM_REPAIR_ME_ITEM);
2638                 else
2639                         send_player_order_packet(SQUAD_MSG_SHIP, 0, ABORT_REARM_REPAIR_ITEM);
2640
2641                 // make sure to toggle the mode off
2642                 hud_squadmsg_toggle();
2643
2644                 return 1;
2645         }
2646
2647         // draw top of frame
2648         if ( Mbox_gauge[0].first_frame >= 0 ) {
2649                 GR_AABITMAP(Mbox_gauge[0].first_frame, Mbox_top_coords[gr_screen.res][0], Mbox_top_coords[gr_screen.res][1]);
2650         }
2651
2652         switch( Squad_msg_mode ) {
2653
2654         case SM_MODE_TYPE_SELECT:
2655                 hud_squadmsg_type_select();
2656                 break;
2657
2658         case SM_MODE_SHIP_SELECT:
2659                 hud_squadmsg_ship_select();
2660                 break;
2661
2662         case SM_MODE_WING_SELECT:
2663                 hud_squadmsg_wing_select();
2664                 break;
2665
2666         case SM_MODE_SHIP_COMMAND:
2667                 hud_squadmsg_ship_command();
2668                 break;
2669
2670         case SM_MODE_WING_COMMAND:
2671                 hud_squadmsg_wing_command();
2672                 break;
2673
2674         case SM_MODE_REINFORCEMENTS:
2675                 hud_squadmsg_reinforcement_select();
2676                 break;
2677
2678         case SM_MODE_REPAIR_REARM:
2679                 //if((Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_AM_MASTER) && (addr != NULL)){
2680                 //      hud_squadmsg_repair_rearm(1,&Objects[Net_players[player_num].player->objnum]);
2681                 //} else {
2682                         hud_squadmsg_repair_rearm(1);                           // note we return right away.  repair/rearm code handles messaging, etc
2683                 //}
2684                 break;
2685
2686         case SM_MODE_REPAIR_REARM_ABORT:
2687                 //if((Game_mode & GM_MULTIPLAYER) && (Net_player->flags & NETINFO_FLAG_AM_MASTER) && (addr != NULL)){
2688                 //      hud_squadmsg_repair_rearm_abort(1,&Objects[Net_players[player_num].player->objnum]);
2689                 //} else {
2690                         hud_squadmsg_repair_rearm_abort(1);             // note we return right away.  repair/rearm code handles messaging, etc
2691                 //}
2692                 break;
2693
2694         case SM_MODE_ALL_FIGHTERS:
2695                 hud_squadmsg_msg_all_fighters();
2696                 break;
2697
2698         default:
2699                 Int3();         // get allender -- invalid mode in messaging system
2700                 break;
2701
2702         }
2703
2704         // be sure to reset the clip region
2705         HUD_reset_clip();               // JAS: Is this needed?
2706
2707         if ( Msg_key_used || target_changed ) {
2708                 Msg_mode_timestamp = timestamp(DEFAULT_MSG_TIMEOUT);
2709                 return 1;
2710         } else
2711                 return 0;
2712 }
2713
2714 void hud_add_issued_order(const char *name, int order, const char *target)
2715 {
2716         Squadmsg_history[squadmsg_history_index].ship = get_parse_name_index(name);
2717         Squadmsg_history[squadmsg_history_index].order = order;
2718         if (target)
2719                 Squadmsg_history[squadmsg_history_index].target = get_parse_name_index(target);
2720         else
2721                 Squadmsg_history[squadmsg_history_index].target = -1;
2722
2723         squadmsg_history_index++;
2724         if (squadmsg_history_index >= SQUADMSG_HISTORY_MAX)
2725                 squadmsg_history_index = 0;
2726 }
2727
2728 int hud_query_order_issued(const char *name, const char *order, const char *target)
2729 {
2730         int i, o=-1, ship, t;
2731
2732         ship = get_parse_name_index(name);
2733         t = -1;
2734         if (target)
2735                 t = get_parse_name_index(target);
2736
2737         for (i=0; i<MAX_SHIP_ORDERS; i++)
2738                 if (!stricmp(order, comm_order_menu_text(i)) )
2739                         o = Comm_orders[i].value;
2740
2741         Assert(i < MAX_SHIP_ORDERS);
2742         for (i=0; i<SQUADMSG_HISTORY_MAX; i++)
2743                 if (Squadmsg_history[i].order == o)
2744                         if (ship == Squadmsg_history[i].ship)
2745                                 if (Squadmsg_history[i].target == t)
2746                                         return 1;
2747
2748         return 0;
2749 }
2750
2751
2752 void hudsquadmsg_page_in()
2753 {
2754         int i;
2755
2756         for ( i = 0; i < NUM_MBOX_FRAMES; i++ ) {
2757                 bm_page_in_aabitmap( Mbox_gauge[i].first_frame, Mbox_gauge[i].num_frames );
2758         }
2759 }
2760