src/network/multi_fstracker.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 2005.  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 the
   6  * source.
   7  *
   8 */
   9
  10 /*
  11  * $Logfile: /Freespace2/code/Network/multi_fstracker.cpp $
  12  * $Revision: 19 $
  13  * $Date: 9/13/99 11:30a $
  14  * $Author: Dave $
  15  *
  16  * $Log: /Freespace2/code/Network/multi_fstracker.cpp $
  17  *
  18  * 19    9/13/99 11:30a Dave
  19  * Added checkboxes and functionality for disabling PXO banners as well as
  20  * disabling d3d zbuffer biasing.
  21  *
  22  * 18    8/30/99 5:01p Dave
  23  * Made d3d do less state changing in the nebula. Use new chat server for
  24  * PXO.
  25  *
  26  * 17    8/25/99 4:38p Dave
  27  * Updated PXO stuff. Make squad war report stuff much more nicely.
  28  *
  29  * 16    8/19/99 10:59a Dave
  30  * Packet loss detection.
  31  *
  32  * 15    6/07/99 11:30p Dave
  33  * Whoops.
  34  *
  35  * 14    4/30/99 12:18p Dave
  36  * Several minor bug fixes.
  37  *
  38  * 13    4/09/99 2:21p Dave
  39  * Multiplayer beta stuff. CD checking.
  40  *
  41  * 12    2/25/99 4:19p Dave
  42  * Added multiplayer_beta defines. Added cd_check define. Fixed a few
  43  * release build warnings. Added more data to the squad war request and
  44  * response packets.
  45  *
  46  * 11    2/24/99 2:25p Dave
  47  * Fixed up chatbox bugs. Made squad war reporting better. Fixed a respawn
  48  * bug for dogfight more.
  49  *
  50  * 10    2/17/99 2:11p Dave
  51  * First full run of squad war. All freespace and tracker side stuff
  52  * works.
  53  *
  54  * 9     2/12/99 6:16p Dave
  55  * Pre-mission Squad War code is 95% done.
  56  *
  57  * 8     2/11/99 3:08p Dave
  58  * PXO refresh button. Very preliminary squad war support.
  59  *
  60  * 7     2/08/99 5:07p Dave
  61  * FS2 chat server support. FS2 specific validated missions.
  62  *
  63  * 6     2/04/99 6:29p Dave
  64  * First full working rev of FS2 PXO support.  Fixed Glide lighting
  65  * problems.
  66  *
  67  * 5     2/03/99 6:06p Dave
  68  * Groundwork for FS2 PXO usertracker support.  Gametracker support next.
  69  *
  70  * 4     12/03/98 5:22p Dave
  71  * Ported over Freespace 1 multiplayer ships.tbl and weapons.tbl
  72  * checksumming.
  73  *
  74  * 3     10/19/98 11:15a Dave
  75  * Changed requirements for stats storing in PXO mode.
  76  *
  77  * 2     10/07/98 10:53a Dave
  78  * Initial checkin.
  79  *
  80  * 1     10/07/98 10:50a Dave
  81  *
  82  * 46    9/18/98 2:22a Dave
  83  * Fixed freespace-side PXO api to correctly handle length 10 id strings.
  84  * Fixed team select screen to handle alpha/beta/gamma ships which are not
  85  * marked as OF_PLAYER_SHIP
  86  *
  87  * 45    9/16/98 6:54p Dave
  88  * Upped  max sexpression nodes to 1800 (from 1600). Changed FRED to sort
  89  * the ship list box. Added code so that tracker stats are not stored with
  90  * only 1 player.
  91  *
  92  * 44    9/15/98 7:24p Dave
  93  * Minor UI changes. Localized bunch of new text.
  94  *
  95  * 43    9/11/98 4:14p Dave
  96  * Fixed file checksumming of < file_size. Put in more verbose kicking and
  97  * PXO stats store reporting.
  98  *
  99  * 42    9/10/98 1:17p Dave
 100  * Put in code to flag missions and campaigns as being MD or not in Fred
 101  * and Freespace. Put in multiplayer support for filtering out MD
 102  * missions. Put in multiplayer popups for warning of non-valid missions.
 103  *
 104  * 41    9/09/98 5:53p Dave
 105  * Put in new tracker packets in API. Change cfile to be able to checksum
 106  * portions of a file.
 107  *
 108  * 40    9/04/98 3:51p Dave
 109  * Put in validated mission updating and application during stats
 110  * updating.
 111  *
 112  * 39    9/01/98 6:48p Dave
 113  * Energy suck weapon. Removed a couple of now-bogus asserts in tracker
 114  * code.
 115  *
 116  * 38    8/21/98 1:14p Dave
 117  * Put in log system hooks in useful places.
 118  *
 119  * 37    8/07/98 10:39a Allender
 120  * fixed debug standalone problem where stats would continually get sent
 121  * to tracker.  more debug code to help find stats problem
 122  *
 123  * 36    7/24/98 11:14a Allender
 124  * preparation for validated missions
 125  *
 126  * 35    6/17/98 10:56a Dave
 127  * Put in debug code for detecting potential tracker stats update
 128  * problems.
 129  *
 130  * 34    6/13/98 9:32p Mike
 131  * Kill last character in file which caused "Find in Files" to report the
 132  * file as "not a text file."
 133  *
 134  * 33    6/13/98 6:01p Hoffoss
 135  * Externalized all new (or forgot to be added) strings to all the code.
 136  *
 137  * 32    5/24/98 11:33a Dave
 138  * Simplified the stats store process somewhat. Put in checks to find
 139  * invalid situations.
 140  *
 141  * 31    5/24/98 10:36a Dave
 142  * Put in more checks/verifications for tracker stats updating.
 143  *
 144  * 30    5/22/98 9:35p Dave
 145  * Put in channel based support for PXO. Put in "shutdown" button for
 146  * standalone. UI tweaks for TvT
 147  *
 148  * 29    5/21/98 9:45p Dave
 149  * Lengthened tracker polling times. Put in initial support for PXO
 150  * servers with channel filters. Fixed several small UI bugs.
 151  *
 152  * 28    5/21/98 1:52a Dave
 153  * Remove obsolete command line functions. Reduce shield explosion packets
 154  * drastically. Tweak PXO screen even more. Fix file xfer system so that
 155  * we can guarantee file uniqueness.
 156  *
 157  * 27    5/20/98 2:24a Dave
 158  * Fixed server side voice muting. Tweaked multi debrief/endgame
 159  * sequencing a bit. Much friendlier for stats tossing/accepting now.
 160  *
 161  * 26    5/18/98 9:15p Dave
 162  * Put in network config file support.
 163  *
 164  * 25    5/18/98 10:39a Dave
 165  * Put in support for new tracker stats.
 166  *
 167  * 24    5/14/98 12:40a Dave
 168  * Still more additions to the PXO screen. Updated tracker code.
 169  *
 170  * 23    5/13/98 6:54p Dave
 171  * More sophistication to PXO interface. Changed respawn checking so
 172  * there's no window for desynchronization between the server and the
 173  * clients.
 174  *
 175  * 22    5/08/98 7:08p Dave
 176  * Lots of UI tweaking.
 177  *
 178  * 21    5/07/98 6:26p Dave
 179  * Fix strange boundary conditions which arise when players die/respawn
 180  * while the game is being ended. Spiff up the chatbox doskey thing a bit.
 181  *
 182  * 20    5/05/98 3:12p Chad
 183  * Process _all_ server entries in a tracker game_list struct.
 184  *
 185  * 19    5/05/98 2:10p Dave
 186  * Verify campaign support for testing. More new tracker code.
 187  *
 188  * 18    5/04/98 10:39p Dave
 189  * Put in endgame sequencing.  Need to check campaign situations.
 190  * Realigned ship info on team select screen.
 191  *
 192  * 17    5/04/98 1:43p Dave
 193  * Fixed up a standalone resetting problem. Fixed multiplayer stats
 194  * collection for clients. Make sure all multiplayer ui screens have the
 195  * correct palette at all times.
 196  *
 197  * 16    5/02/98 5:38p Dave
 198  * Put in new tracker API code. Put in ship information on mp team select
 199  * screen. Make standalone server name permanent. Fixed standalone server
 200  * text messages.
 201  *
 202  * 15    4/30/98 12:57a Dave
 203  * Put in new mode for ship/weapon selection. Rearranged how game querying
 204  * is done a bit.
 205  *
 206  * 14    4/29/98 12:11a Dave
 207  * Put in first rev of full API support for new master tracker.
 208  *
 209  * 13    4/28/98 7:50p Dave
 210  * Fixing a broken makefile.
 211  *
 212  * 12    4/28/98 5:10p Dave
 213  * Fixed multi_quit_game() client side sequencing problem. Turn off
 214  * afterburners when ending multiplayer mission. Begin integration of mt
 215  * API from Kevin Bentley.
 216  *
 217  * 11    4/04/98 4:22p Dave
 218  * First rev of UDP reliable sockets is done. Seems to work well if not
 219  * overly burdened.
 220  *
 221  * 10    3/15/98 4:17p Dave
 222  * Fixed oberver hud problems. Put in handy netplayer macros. Reduced size
 223  * of network orientation matrices.
 224  *
 225  * 9     2/10/98 8:39p Dave
 226  * Fixed bugs. Made endgame sequencing more clear.
 227  *
 228  * 8     2/07/98 1:51p Dave
 229  * Centralized single and multiplayer stats tallying.
 230  *
 231  * 7     2/05/98 7:13p Dave
 232  * Added some more security to MT communications.
 233  *
 234  * 6     2/04/98 6:35p Dave
 235  * Changed psnet to use raw data with no headers. Started putting in
 236  * support for master tracker security measures.
 237  *
 238  * 5     2/03/98 8:18p Dave
 239  * More MT stats transfer stuff.
 240  *
 241  * 4     2/02/98 8:44p Dave
 242  * Finished redoing master tracker stats transfer.
 243  *
 244  * 3     1/31/98 4:32p Dave
 245  * Put in new support for VMT player validation, game logging in, and game
 246  * logging out. Need to finish stats transfer.
 247  *
 248  * 2     1/30/98 5:53p Dave
 249  * Revamped master tracker API
 250  *
 251  * 1     1/30/98 5:50p Dave
 252  *
 253  * $NoKeywords: $
 254  */
 255
 256
 257 #ifdef PLAT_UNIX
 258 #include <netinet/in.h>
 259 #endif
 260
 261 #include "freespace.h"
 262 #include "timer.h"
 263 #include "gamesequence.h"
 264 #include "popup.h"
 265 #include "psnet.h"
 266 #include "valid.h"                                              // tracker API
 267 #include "gtrack.h"                                             // tracker API
 268 #include "ptrack.h"                                             // tracker API
 269 #include "multi.h"
 270 #include "multi_fstracker.h"
 271 #include "multiutil.h"
 272 #include "multiui.h"
 273 #include "multimsgs.h"
 274 #include "multi_log.h"
 275 #include "stand_server.h"
 276 #include "multi_pmsg.h"
 277
 278 // -----------------------------------------------------------------------------------
 279 // FREESPACE MASTER TRACKER DEFINES/VARS
 280 //
 281
 282 // if the fs tracker module has been successfully initialized
 283 int Multi_fs_tracker_inited = 0;
 284
 285 // if we're currently performing some operation with the tracker
 286 int Multi_fs_tracker_busy = 0;
 287
 288 // channel to associate when creating a server
 289 char Multi_fs_tracker_channel[255] = "";
 290
 291 // channel to use when polling the tracker for games
 292 char Multi_fs_tracker_filter[255] = "";
 293
 294
 295 // -----------------------------------------------------------------------------------
 296 // FREESPACE MASTER TRACKER FORWARD DECLARATIONS
 297 //
 298
 299 // used with popup_till_condition() for validating freespace pilots
 300 #define MT_VALIDATE_NOT_DONE                            0                                                               // still in the process of validation
 301 #define MT_VALIDATE_SUCCEED                             1                                                               // successfully validated the pilot
 302 #define MT_VALIDATE_FAIL                                        2                                                               // failed in validating the pilot
 303 #define MT_VALIDATE_TIMEOUT                             3                                                               // timedout on contacting the tracker
 304 #define MT_VALIDATE_CANCEL                                      4                                                               // if the action was cancelled
 305 #define MT_PILOT_VAL_TIMEOUT                            5000                                                    // timeout for validating a pilot
 306 int Multi_validate_mode;                                                                                                        // 0 == getting player id, 1 == getting player stats
 307 int multi_fs_validate_process();
 308
 309 // used with popup_till_condition() for logging in freespace games
 310 #define MT_LOGIN_NOT_DONE                                       0                                                               // still in the process of logging in
 311 #define MT_LOGIN_SUCCEED                                        1                                                               // successfully logged the game in
 312 #define MT_LOGIN_TIMEOUT                                        2                                                               // timedout on contacting the tracker
 313
 314 // used with popup_till_condition() for storing player stats at the end of a freespace game
 315 #define MT_STATS_NOT_DONE                                       0                                                               // still in the process of storing stats
 316 #define MT_STATS_SUCCEED                                        1                                                               // successfully logged all player stats
 317
 318 // used with popup_till_condition() for validating missions
 319 #define MT_MVALID_NOT_DONE                                      0                                                               // still in the process of validating
 320 #define MT_MVALID_VALID                                         1                                                               // mission is valid
 321 #define MT_MVALID_INVALID                                       2                                                               // mission is invalid
 322 #define MT_MVALID_ERROR                                         3                                                               // error while performing operation. assume invalid
 323
 324 // store stats mode defined
 325 #define MT_STORE_STATS_VALIDATE                 0
 326 #define MT_STORE_STATS_GET_STATS                        1
 327 #define MT_STORE_STATS_ACCEPT                           2
 328 #define MT_STORE_STATS_SEND_STATS               3
 329
 330 int Multi_store_stats_mode;                                                                                             // 0 == initial request for player stats, 1 == waiting for player stats, 2 == tallying stats locally, 3 == sending stats to tracker
 331 int Multi_store_stats_player_index;                                                                             // player we're currently working with
 332 int Multi_store_stats_player_flag;                                                                              // if we're finished with the current guy
 333 vmt_stats_struct Multi_store_stats_stats;                                               //
 334 int multi_fs_store_stats_do();                                                                                  // manage all master tracker stats storing
 335 int multi_fs_store_stats_get_next_player(int cur_player);
 336
 337 int Multi_tracker_player_is_valid = 0;
 338 int Multi_tracker_got_response = 0;
 339
 340 // copy a freespace stats struct to a tracker-freespace stats struct
 341 void multi_stats_fs_to_tracker(scoring_struct *fs, vmt_stats_struct *vmt, player *pl, int tracker_id);
 342
 343 // copy a tracker-freespace stats struct to a freespace stats struct
 344 void multi_stats_tracker_to_fs(vmt_stats_struct *vmt, scoring_struct *fs);
 345
 346 // process an incoming active game item
 347 void multi_fs_tracker_process_game_item(game_list *gl);
 348
 349 // verify that there are no duplicate tracker id's to this one
 350 void multi_fs_tracker_check_dup(int tracker_id,int player_index);
 351
 352 // verify that there are no duplicate pilot callsigns
 353 void multi_fs_tracker_check_dup_callsign(net_player *player,int player_index);
 354
 355 // report on the results of the stats store procedure
 356 void multi_fs_tracker_report_stats_results();
 357
 358 // tracker specific data structures
 359 pxo_net_game_data Multi_tracker_game_data;
 360 vmt_stats_struct Multi_tracker_fs_pilot;
 361 squad_war_response Multi_tracker_sw_response;
 362
 363 // -----------------------------------------------------------------------------------
 364 // FREESPACE MASTER TRACKER DEFINITIONS
 365 //
 366
 367 // give some processor time to the tracker API
 368 void multi_fs_tracker_process()
 369 {
 370         game_list *gl;
 371
 372 #ifndef MAKE_FS1
 373         PSNET_TOP_LAYER_PROCESS();
 374 #endif
 375
 376         if(Multi_fs_tracker_inited){
 377                 // pilot validation system
 378                 ValidIdle();
 379
 380                 // pilot tracing system
 381                 PollPTrackNet();
 382
 383                 // game tracking system
 384                 IdleGameTracker();
 385
 386                 // set if we've got any pending game list items
 387                 gl = GetGameList();
 388                 if(gl != NULL){
 389                         multi_fs_tracker_process_game_item(gl);
 390                         gl = NULL;
 391                 }
 392         }
 393 }
 394
 395 // initialize the master tracker API for Freespace
 396 void multi_fs_tracker_init()
 397 {
 398         // don't do anything if we're already initialized
 399         if(Multi_fs_tracker_inited){
 400                 return;
 401         }
 402
 403         // initialize the low-level validation stuff
 404         if(!InitValidateClient()){
 405                 ml_printf("Error initializing tracker api (validateclient)\n");
 406                 return;
 407         }
 408
 409         // initialize the low-level pilot tracking stuff
 410         if(!InitPilotTrackerClient()){
 411                 ml_printf("Error initializing tracker api (pilotclient)\n");
 412                 return;
 413         }
 414
 415         // intialize the low-level game tracking stuff
 416 #ifndef MAKE_FS1
 417         if(!InitGameTrackerClient(GT_FREESPACE2)){
 418 #else
 419         if(!InitGameTrackerClient(GT_FREESPACE)){
 420 #endif
 421                 ml_printf("Error initializing tracker api (gameclient)\n");
 422                 return;
 423         }
 424
 425         nprintf(("Network","Successfully initialized tracker api\n"));
 426
 427         // we've successfully initialized the tracker stuff
 428         Multi_fs_tracker_inited = 1;
 429 }
 430
 431 // validate the current player with the master tracker (will create the pilot on the MT if necessary)
 432 int multi_fs_tracker_validate(int show_error)
 433 {
 434         validate_id_request vir;
 435
 436         if(!Multi_fs_tracker_inited){
 437                 popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR("Warning, Parallax Online startup failed. Will not be able to play tracker games!",666));
 438                 return 0;
 439         }
 440
 441         // set this to false for now
 442         Multi_tracker_player_is_valid = 0;
 443         Multi_tracker_got_response = 0;
 444
 445         // mark the module as busy
 446         Multi_fs_tracker_busy = 1;
 447
 448         while(1){
 449                 // validate our pilot on the master tracker if possible
 450                 memset(&vir,0,sizeof(vir));
 451                 SDL_zero(Multi_tracker_id_string);
 452                 SDL_strlcpy(vir.login, Multi_tracker_login, SDL_arraysize(vir.login));
 453                 SDL_strlcpy(vir.password, Multi_tracker_passwd, SDL_arraysize(vir.password));
 454                 ValidateUser(&vir,Multi_tracker_id_string);
 455
 456                 // set validation mode
 457                 Multi_validate_mode = 0;
 458
 459                 int rval = popup_till_condition(multi_fs_validate_process,XSTR("&Cancel",667),XSTR("Attempting to validate pilot ...",668));
 460                 switch(rval){
 461                 // if we failed for one reason or another
 462                 case MT_VALIDATE_FAIL :
 463                         // if we're supposed to show error codes
 464                         if(show_error){
 465                                 popup(PF_USE_AFFIRMATIVE_ICON | PF_BODY_BIG,1,XSTR("&Ok",669),XSTR("Pilot rejected by Parallax Online!",670));
 466                         }
 467
 468                         Multi_validate_mode = -1;
 469
 470                         Multi_fs_tracker_busy = 0;
 471                         return 0;
 472
 473                 case MT_VALIDATE_SUCCEED :
 474                         // notify the user
 475                         if(Multi_tracker_fs_pilot.virgin_pilot){
 476                                 multi_common_add_notify(XSTR("Successfully created and validated new pilot!",671));
 477                         } else {
 478                                 multi_common_add_notify(XSTR("Parallax Online pilot validation succeeded!",672));
 479                         }
 480
 481                         // copy my statistics into my pilot file
 482                         multi_stats_tracker_to_fs(&Multi_tracker_fs_pilot,&Player->stats);
 483
 484                         Multi_validate_mode = -1;
 485
 486                         Multi_fs_tracker_busy = 0;
 487                         return 1;
 488
 489                 case MT_VALIDATE_TIMEOUT :
 490                         rval = popup(PF_USE_AFFIRMATIVE_ICON | PF_USE_NEGATIVE_ICON | PF_BODY_BIG,2,XSTR("&Abort",673),XSTR("&Retry",674),XSTR("Validation timed out",675));
 491
 492                         // if the user clicked abort, then leave. otherwise try again
 493                         if(rval == 0){
 494                                 Multi_validate_mode = -1;
 495
 496                                 Multi_fs_tracker_busy = 0;
 497                                 return 0;
 498                         }
 499                         break;
 500
 501                 default :
 502                         Multi_validate_mode = -1;
 503
 504                         Multi_fs_tracker_busy = 0;
 505
 506                         // essentially, cancel
 507                         return -1;
 508                 }
 509         }
 510 }
 511
 512 // attempt to log the current game server in with the master tracker
 513 void multi_fs_tracker_login_freespace()
 514 {
 515         if(!Multi_fs_tracker_inited){
 516                 popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR("Warning, Parallax Online startup failed. Will not be able to play tracker games!",666));
 517                 return;
 518         }
 519
 520         // if we're already logged into a game, don't do anything
 521         if ( !(Net_player->flags & NETINFO_FLAG_AM_MASTER) || (Net_player->flags & NETINFO_FLAG_MT_CONNECTED) ) {
 522                 return;
 523         }
 524
 525         // pretty much all we do is make 1 call
 526         memset(&Multi_tracker_game_data, 0, sizeof(Multi_tracker_game_data));
 527         SDL_strlcpy(Multi_tracker_game_data.game_name, Netgame.name, SDL_arraysize(Multi_tracker_game_data.game_name));
 528         Multi_tracker_game_data.difficulty = 99;
 529         Multi_tracker_game_data.type = 0;
 530         Multi_tracker_game_data.state = 1;
 531         Multi_tracker_game_data.max_players = 12;
 532         Multi_tracker_game_data.current_num_players = 0;
 533
 534         // if we have a valid channel string, use it
 535         if(strlen(Multi_fs_tracker_channel)){
 536                 SDL_strlcpy(Multi_tracker_game_data.channel, Multi_fs_tracker_channel, SDL_arraysize(Multi_tracker_game_data.channel));
 537         }
 538
 539         StartTrackerGame(&Multi_tracker_game_data);
 540         Net_player->flags |= NETINFO_FLAG_MT_CONNECTED;
 541
 542         // NETLOG
 543         ml_string(NOX("Server connected to Game Tracker"));
 544 }
 545
 546 // attempt to update all player statistics and scores on the tracker
 547 int multi_fs_tracker_store_stats()
 548 {
 549         int idx;
 550
 551         // NETLOG
 552         ml_string(NOX("Server storing stats on User Tracker"));
 553
 554         // retrieve stats from tracker
 555         Multi_store_stats_mode = MT_STORE_STATS_VALIDATE;
 556
 557         // multi_fs_store_stats_do() will handle all details of negotiating stats transfer with the tracker
 558         Multi_store_stats_player_index = -1;
 559         Multi_store_stats_player_flag = 1;
 560
 561         // mark the module as busy
 562         Multi_fs_tracker_busy = 1;
 563
 564         // unmark everyone's GET_FAILED flag
 565         for(idx=0;idx<MAX_PLAYERS;idx++){
 566                 Net_players[idx].flags &= ~(NETINFO_FLAG_MT_GET_FAILED);
 567                 Net_players[idx].flags &= ~(NETINFO_FLAG_MT_SEND_FAILED);
 568                 Net_players[idx].flags &= ~(NETINFO_FLAG_MT_DONE);
 569         }
 570
 571 #ifdef RELEASE_REAL
 572         // if playing with an invalid ships.tbl
 573         if(!Game_ships_tbl_valid){
 574                 send_game_chat_packet(Net_player, XSTR("<Server detected a hacked ships.tbl. Stats will not be saved>", 1044), MULTI_MSG_ALL, NULL, NULL, 1);
 575                 multi_display_chat_msg(XSTR("<Server detected a hacked ships.tbl. Stats will not be saved>", 1044), 0, 0);
 576                 popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR("You are playing with a hacked ships.tbl, your stats will not be saved", 1045) );
 577                 multi_fs_tracker_report_stats_results();
 578                 Multi_fs_tracker_busy = 0;
 579                 return 0;
 580         }
 581
 582         // if playing with an invalid weapons.tbl
 583         if(!Game_weapons_tbl_valid){
 584                 send_game_chat_packet(Net_player, XSTR("<Server detected a hacked weapons.tbl. Stats will not be saved>", 1046), MULTI_MSG_ALL, NULL, NULL, 1);
 585                 multi_display_chat_msg(XSTR("<Server detected a hacked weapons.tbl. Stats will not be saved>", 1046), 0, 0);
 586                 popup(PF_USE_AFFIRMATIVE_ICON, 1, POPUP_OK, XSTR("You are playing with a hacked weapons.tbl, your stats will not be saved", 1047) );
 587                 multi_fs_tracker_report_stats_results();
 588                 Multi_fs_tracker_busy = 0;
 589                 return 0;
 590         }
 591
 592         // if there is only 1 player, don't store the stats
 593         if((multi_num_players() <= 1) && (Multi_num_players_at_start <= 1)){
 594                 send_game_chat_packet(Net_player, XSTR("<Not enough players were present at game start or end, stats will not be saved>", 1048), MULTI_MSG_ALL, NULL, NULL, 1);
 595                 multi_display_chat_msg(XSTR("<Not enough players were present at game start or end, stats will not be saved>", 1048), 0, 0);
 596                 multi_fs_tracker_report_stats_results();
 597                 Multi_fs_tracker_busy = 0;
 598                 return 0;
 599         }
 600
 601         // if any players have hacked info
 602         for(idx=0; idx<MAX_PLAYERS; idx++){
 603                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].flags & NETINFO_FLAG_HAXOR)){
 604                         return 0;
 605                 }
 606         }
 607
 608         // check to see if the mission is valid
 609         if(multi_fs_tracker_validate_mission(Game_current_mission_filename) != MVALID_STATUS_VALID){
 610                 send_game_chat_packet(Net_player, XSTR("<Server detected a non PXO validated mission. Stats will not be saved>", 1049), MULTI_MSG_ALL, NULL, NULL, 1);
 611                 multi_display_chat_msg(XSTR("<Server detected a non PXO validated mission. Stats will not be saved>", 1049), 0, 0);
 612                 popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK, XSTR("This is not a PXO validated mission, your stats will not be saved", 1050));
 613                 Multi_fs_tracker_busy = 0;
 614                 return 0;
 615         }
 616 #endif
 617
 618         popup_till_condition(multi_fs_store_stats_do,XSTR("&Cancel",667), XSTR("Sending player stats requests ...",676));
 619
 620         // send appropriate chat messages indicating stats store failure
 621         multi_fs_tracker_report_stats_results();
 622
 623         // mark the module as not busy anymore
 624         Multi_fs_tracker_busy = 0;
 625
 626         return 1;
 627 }
 628
 629 // attempt to update all player statistics (standalone mode)
 630 int multi_fs_std_tracker_store_stats()
 631 {
 632         int ret_val;
 633         int idx;
 634
 635         // don't do anything if this is a tracker game
 636         if(!(MULTI_IS_TRACKER_GAME)){
 637                 return 0;
 638         }
 639
 640         if(!Multi_fs_tracker_inited){
 641                 return 0;
 642         }
 643
 644         // NETLOG
 645         ml_string(NOX("Standalone server storing stats on User Tracker"));
 646
 647         // retrieve stats from tracker
 648         Multi_store_stats_mode = MT_STORE_STATS_VALIDATE;
 649
 650         // multi_fs_store_stats_do() will handle all details of negotiating stats transfer with the tracker
 651         Multi_store_stats_player_index = -1;
 652         Multi_store_stats_player_flag = 1;
 653
 654         // mark the module as busy
 655         Multi_fs_tracker_busy = 1;
 656
 657         // unmark everyone's GET_FAILED flag
 658         for(idx=0;idx<MAX_PLAYERS;idx++){
 659                 Net_players[idx].flags &= ~(NETINFO_FLAG_MT_GET_FAILED);
 660                 Net_players[idx].flags &= ~(NETINFO_FLAG_MT_SEND_FAILED);
 661                 Net_players[idx].flags &= ~(NETINFO_FLAG_MT_DONE);
 662         }
 663
 664 #ifdef RELEASE_REAL
 665         // if playing with an invalid ships.tbl
 666         if(!Game_ships_tbl_valid){
 667                 send_game_chat_packet(Net_player, XSTR("<Server detected a hacked ships.tbl. Stats will not be saved>", 1044), MULTI_MSG_ALL, NULL, NULL, 1);
 668                 multi_display_chat_msg(XSTR("<Server detected a hacked ships.tbl. Stats will not be saved>", 1044), 0, 0);
 669                 multi_fs_tracker_report_stats_results();
 670                 Multi_fs_tracker_busy = 0;
 671                 return 0;
 672         }
 673
 674         // if playing with an invalid weapons.tbl
 675         if(!Game_weapons_tbl_valid){
 676                 send_game_chat_packet(Net_player, XSTR("<Server detected a hacked weapons.tbl. Stats will not be saved>", 1046), MULTI_MSG_ALL, NULL, NULL, 1);
 677                 multi_display_chat_msg(XSTR("<Server detected a hacked weapons.tbl. Stats will not be saved>", 1046), 0, 0);
 678                 multi_fs_tracker_report_stats_results();
 679                 Multi_fs_tracker_busy = 0;
 680                 return 0;
 681         }
 682
 683         // if any players have hacked info
 684         for(idx=0; idx<MAX_PLAYERS; idx++){
 685                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && (Net_players[idx].flags & NETINFO_FLAG_HAXOR)){
 686                         return 0;
 687                 }
 688         }
 689
 690         // if there is only 1 player, don't store the stats
 691         if((multi_num_players() <= 1) && (Multi_num_players_at_start <= 1)){
 692                 send_game_chat_packet(Net_player, XSTR("<Not enough players were present at game start or end, stats will not be saved>", 1048), MULTI_MSG_ALL, NULL, NULL, 1);
 693                 multi_display_chat_msg(XSTR("<Not enough players were present at game start or end, stats will not be saved>", 1048), 0, 0);
 694                 multi_fs_tracker_report_stats_results();
 695                 Multi_fs_tracker_busy = 0;
 696                 return 0;
 697         }
 698
 699         // check to see if the mission is valid
 700         if(multi_fs_tracker_validate_mission(Game_current_mission_filename) != MVALID_STATUS_VALID){
 701                 send_game_chat_packet(Net_player, XSTR("<Server detected a non PXO validated mission. Stats will not be saved>", 1049), MULTI_MSG_ALL, NULL, NULL, 1);
 702                 multi_display_chat_msg(XSTR("<Server detected a non PXO validated mission. Stats will not be saved>", 1049), 0, 0);
 703                 Multi_fs_tracker_busy = 0;
 704                 return 0;
 705         }
 706 #endif
 707
 708         // multi_fs_store_stats_do() will handle all details of negotiating stats transfer with the tracker
 709         do {
 710                 ret_val = multi_fs_store_stats_do();
 711                 game_set_frametime(GS_STATE_STANDALONE_POSTGAME);
 712                 multi_do_frame();
 713         } while(ret_val == MT_STATS_NOT_DONE);
 714
 715         // report on the results
 716         multi_fs_tracker_report_stats_results();
 717
 718         // mark the module as no longer busy
 719         Multi_fs_tracker_busy = 0;
 720
 721         return 1;
 722 }
 723
 724 // log freespace out of the tracker
 725 void multi_fs_tracker_logout()
 726 {
 727         if(!Multi_fs_tracker_inited){
 728                 return;
 729         }
 730
 731         // make sure we're connected
 732         if(!(Net_player->flags & NETINFO_FLAG_AM_MASTER) || !(Net_player->flags & NETINFO_FLAG_MT_CONNECTED)){
 733                 return;
 734         }
 735
 736         // otherwise, log us out
 737         SendGameOver();
 738
 739         // clear our data
 740         memset(&Multi_tracker_game_data, 0, sizeof(Multi_tracker_game_data));
 741         Net_player->flags &= ~(NETINFO_FLAG_MT_CONNECTED);
 742
 743         // NETLOG
 744         ml_string(NOX("Server disconnecting from Game Tracker"));
 745 }
 746
 747 // send a request for a list of games
 748 void multi_fs_tracker_send_game_request()
 749 {
 750         filter_game_list_struct filter;
 751         int len;
 752
 753         // if we're not initialized, don't do anything
 754         if(!Multi_fs_tracker_inited){
 755                 return;
 756         }
 757
 758         // if we have a valid filter, use that instead
 759         len = strlen(Multi_fs_tracker_filter);
 760         if((len > 0) && (len < CHANNEL_LEN-1) ){
 761                 memset(&filter,0,sizeof(filter_game_list_struct));
 762
 763                 SDL_strlcpy(filter.channel, Multi_fs_tracker_filter, SDL_arraysize(filter.channel));
 764                 RequestGameListWithFilter(&filter);
 765         } else {
 766                 // simple API call
 767                 RequestGameList();
 768         }
 769 }
 770
 771 // if the API has successfully been initialized and is running
 772 int multi_fs_tracker_inited()
 773 {
 774         return Multi_fs_tracker_inited;
 775 }
 776
 777 // update our settings on the tracker regarding the current netgame stuff
 778 void multi_fs_tracker_update_game(netgame_info *ng)
 779 {
 780         if(!Multi_fs_tracker_inited){
 781                 return;
 782         }
 783
 784         // copy in the relevant data
 785         Multi_tracker_game_data.max_players = ng->max_players;
 786         Multi_tracker_game_data.current_num_players = multi_num_players();
 787
 788 #ifdef MAKE_FS1
 789         memset(Multi_tracker_game_data.players, 0 ,MAX_FREESPACE_PLAYERS * MAX_FREESPACE_PLAYER_NAME_LEN);
 790         int count = 0, idx;
 791         for(idx=0;idx<MAX_PLAYERS;idx++){
 792                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx])){
 793                         strcpy(Multi_tracker_game_data.players[count], Net_players[idx].player->callsign);
 794                         Multi_tracker_game_data.player_rank[count] = Net_players[idx].player->stats.rank;
 795                         count++;
 796                 }
 797         }
 798 #endif
 799
 800         SDL_strlcpy(Multi_tracker_game_data.mission_name, ng->name, SDL_arraysize(Multi_tracker_game_data.mission_name));
 801
 802         // NETLOG
 803         ml_string(NOX("Server updating netgame info for Game Tracker"));
 804 }
 805
 806 // if we're currently busy performing some tracker operation (ie, you should wait or not)
 807 int multi_fs_tracker_busy()
 808 {
 809         return Multi_fs_tracker_busy;
 810 }
 811
 812
 813 // -----------------------------------------------------------------------------------
 814 // FREESPACE MASTER TRACKER FORWARD DEFINITIONS
 815 //
 816
 817 // used with popup_till_condition() for validating freespace pilots
 818 int multi_fs_validate_process()
 819 {
 820         // should never be here if this is not true
 821         SDL_assert(Multi_fs_tracker_inited);
 822
 823 #ifndef MAKE_FS1
 824         PSNET_TOP_LAYER_PROCESS();
 825 #endif
 826
 827         // if we're still in player validation mode
 828         if(Multi_validate_mode == 0){
 829                 switch(ValidateUser(NULL,NULL)){
 830                 // timeout on waiting for response
 831                 case -2 :
 832                         return MT_VALIDATE_TIMEOUT;
 833
 834                 // user invalid
 835                 case -1:
 836                         // set tracker id to -1
 837                         SDL_strlcpy(Multi_tracker_id_string, "-1", SDL_arraysize(Multi_tracker_id_string));
 838                         Multi_tracker_id = -1;
 839                         return MT_VALIDATE_FAIL;
 840
 841                 // still waiting
 842                 case 0:
 843                         return MT_VALIDATE_NOT_DONE;
 844
 845                 // user valid
 846                 case 1:
 847                         // now we need to try and receive stats
 848
 849                         // mark me as being valid
 850                         Multi_tracker_player_is_valid = 1;
 851
 852                         // change the popup text
 853                         popup_change_text(XSTR("Attempting to get pilot stats ...",679));
 854
 855                         // get my tracker id#
 856                         Multi_tracker_id = atoi(Multi_tracker_id_string);
 857                         SDL_assert(Multi_tracker_id != -1);
 858
 859                         GetFSPilotData((vmt_stats_struct*)0xffffffff,NULL,NULL,0);
 860                         GetFSPilotData(&Multi_tracker_fs_pilot,Player->callsign,Multi_tracker_id_string,1);
 861
 862                         // set to mode 1
 863                         Multi_validate_mode = 1;
 864                         return MT_VALIDATE_NOT_DONE;
 865
 866                 default :
 867                         Int3();
 868                 }
 869         } else {
 870                 switch(GetFSPilotData(NULL,NULL,NULL,0)){
 871                 // timedout
 872                 case -1:
 873                         return MT_VALIDATE_TIMEOUT;
 874
 875                 // still waiting
 876                 case 0:
 877                         return MT_VALIDATE_NOT_DONE;
 878
 879                 // got data
 880                 case 1:
 881                         return MT_VALIDATE_SUCCEED;
 882
 883                 // failure
 884                 case 3:
 885                         return MT_VALIDATE_FAIL;
 886                 }
 887         }
 888
 889         // we're not done yet - probably should never get here
 890         return MT_VALIDATE_NOT_DONE;
 891 }
 892
 893 // used with popup_till_condition() for storing player stats at the end of a freespace game
 894 int multi_fs_store_stats_do()
 895 {
 896         char tracker_id_string[512];
 897         char popup_text[100];
 898
 899         SDL_assert(Multi_fs_tracker_inited);
 900
 901 #ifndef MAKE_FS1
 902         PSNET_TOP_LAYER_PROCESS();
 903 #endif
 904
 905         switch(Multi_store_stats_mode){
 906         // get stats for all players
 907         case MT_STORE_STATS_VALIDATE :
 908                 Multi_store_stats_mode = MT_STORE_STATS_GET_STATS;
 909                 break;
 910
 911         case MT_STORE_STATS_GET_STATS:
 912                 // if we need to get the next player
 913                 if(Multi_store_stats_player_flag){
 914                         Multi_store_stats_player_index = multi_fs_store_stats_get_next_player(Multi_store_stats_player_index);
 915
 916                         // if it returns < 0 we're done with all players and should move onto the next stage (applying mission stats)
 917                         if(Multi_store_stats_player_index < 0){
 918                                 Multi_store_stats_mode = MT_STORE_STATS_ACCEPT;
 919                                 return MT_STATS_NOT_DONE;
 920                         }
 921
 922                         // unset this flag so we process the request
 923                         Multi_store_stats_player_flag = 0;
 924
 925                         // fill out the information request
 926                         memset(tracker_id_string,0,512);
 927                         SDL_assert(Net_players[Multi_store_stats_player_index].tracker_player_id > 0);
 928
 929                         // verify that there are no duplicate tracker id's to this one
 930                         multi_fs_tracker_check_dup(Net_players[Multi_store_stats_player_index].tracker_player_id,Multi_store_stats_player_index);
 931                         multi_fs_tracker_check_dup_callsign(&Net_players[Multi_store_stats_player_index],Multi_store_stats_player_index);
 932
 933                         SDL_snprintf(tracker_id_string, SDL_arraysize(tracker_id_string), "%d", Net_players[Multi_store_stats_player_index].tracker_player_id);
 934                         Net_players[Multi_store_stats_player_index].s_info.tracker_security_last = -1;
 935                         Net_players[Multi_store_stats_player_index].s_info.tracker_checksum = 0;
 936
 937                         // send the request itself
 938                         GetFSPilotData((vmt_stats_struct*)0xffffffff, NULL, NULL,0);
 939                         memset(&Multi_store_stats_stats, 0, sizeof(Multi_store_stats_stats));
 940                         if(GetFSPilotData(&Multi_store_stats_stats, Net_players[Multi_store_stats_player_index].player->callsign,tracker_id_string,1) != 0){
 941                                 Int3();
 942
 943                                 // move onto the next player
 944                                 Multi_store_stats_player_flag = 1;
 945                                 return MT_STATS_NOT_DONE;
 946                         }
 947
 948                         // set the popup text
 949                         if(!(Game_mode & GM_STANDALONE_SERVER)){
 950                                 SDL_snprintf(popup_text, SDL_arraysize(popup_text), XSTR("Getting player stats for %s...\n", 680), Net_players[Multi_store_stats_player_index].player->callsign);
 951                                 popup_change_text(popup_text);
 952                         }
 953                         return MT_STATS_NOT_DONE;
 954                 }
 955
 956                 // process the request
 957                 switch(GetFSPilotData(NULL,NULL,NULL,0)){
 958                 // got data
 959                 case 1:
 960                         // copy his stats, then flag him as done so we move onto the next guys
 961                         multi_stats_tracker_to_fs(&Multi_store_stats_stats,&Net_players[Multi_store_stats_player_index].player->stats);
 962
 963                         // make sure we apply his mission stats now
 964                         scoring_do_accept(&Net_players[Multi_store_stats_player_index].player->stats);
 965
 966 #ifndef NDEBUG
 967                         {
 968                                 // debug code to check for bogus stats
 969                                 scoring_struct *ssp = &(Net_players[Multi_store_stats_player_index].player->stats);
 970                                 vmt_stats_struct *vmt = &Multi_store_stats_stats;
 971
 972                                 if ( (ssp->missions_flown < vmt->missions_flown) || (ssp->flight_time < ssp->flight_time) || (ssp->kill_count < vmt->kill_count) ) {
 973                                         Int3();
 974                                 }
 975                         }
 976 #endif
 977
 978                         // flag him as being completed
 979                         Multi_store_stats_player_flag = 1;
 980
 981                         // also store this last security value so we can properly update him
 982                         Net_players[Multi_store_stats_player_index].s_info.tracker_security_last = Multi_store_stats_stats.security;
 983                         Net_players[Multi_store_stats_player_index].s_info.tracker_checksum = Multi_store_stats_stats.checksum;
 984                         break;
 985
 986                 // in progress
 987                 case 0:
 988                         break;
 989
 990                 // failure
 991                 case 3: case -2: case 2: case -3: case -1:
 992                         // this shouldn't be happening under most conditions. For debugging....
 993                         Int3();
 994
 995                         // flag him as done so we move onto the next guy
 996                         Multi_store_stats_player_flag = 1;
 997                         Net_players[Multi_store_stats_player_index].s_info.tracker_security_last = -1;
 998                         Net_players[Multi_store_stats_player_index].s_info.tracker_checksum = 0;
 999
1000                         // mark down that the stats get for him failed
1001                         Net_players[Multi_store_stats_player_index].flags |= NETINFO_FLAG_MT_GET_FAILED;
1002                         Net_players[Multi_store_stats_player_index].flags |= NETINFO_FLAG_MT_DONE;
1003                         break;
1004                 }
1005                 break;
1006
1007         // update all stats for all players locally and on client machines
1008         case MT_STORE_STATS_ACCEPT :
1009                 // tell everyone to save their stats
1010                 send_store_stats_packet(1);
1011
1012                 // reset status flags and indices
1013                 Multi_store_stats_player_index = -1;
1014                 Multi_store_stats_player_flag = 1;
1015
1016                 Multi_store_stats_mode = MT_STORE_STATS_SEND_STATS;
1017                 break;
1018
1019         // send stats to the tracker
1020         case MT_STORE_STATS_SEND_STATS:
1021                 // if we need to get the next player
1022                 if(Multi_store_stats_player_flag){
1023                         Multi_store_stats_player_index = multi_fs_store_stats_get_next_player(Multi_store_stats_player_index);
1024
1025                         // if it returns < 0 we need to move onto the next player
1026                         if(Multi_store_stats_player_index < 0){
1027                                 return MT_STATS_SUCCEED;
1028                         }
1029
1030                         Multi_store_stats_player_flag = 0;
1031
1032                         // fill in the information
1033                         memset(&Multi_store_stats_stats,0,sizeof(Multi_store_stats_stats));
1034
1035                         SDL_assert(Net_players[Multi_store_stats_player_index].tracker_player_id > 0);
1036
1037                         // verify that there are no duplicate tracker id's to this one
1038                         multi_fs_tracker_check_dup(Net_players[Multi_store_stats_player_index].tracker_player_id,Multi_store_stats_player_index);
1039                         multi_fs_tracker_check_dup_callsign(&Net_players[Multi_store_stats_player_index],Multi_store_stats_player_index);
1040                         multi_stats_fs_to_tracker(&Net_players[Multi_store_stats_player_index].player->stats,&Multi_store_stats_stats,Net_players[Multi_store_stats_player_index].player,Net_players[Multi_store_stats_player_index].tracker_player_id);
1041
1042                         Multi_store_stats_stats.security = Net_players[Multi_store_stats_player_index].s_info.tracker_security_last;
1043
1044                         // SDL_assert(Net_players[Multi_store_stats_player_index].s_info.tracker_checksum != 0);
1045                         Multi_store_stats_stats.checksum = Net_players[Multi_store_stats_player_index].s_info.tracker_checksum;
1046
1047                         // send the request
1048                         SendFSPilotData((vmt_stats_struct*)0xffffffff);
1049                         if(SendFSPilotData(&Multi_store_stats_stats) != 0){
1050                                 Int3();
1051
1052                                 // failed to send, try another player the next time around
1053                                 Multi_store_stats_player_flag = 1;
1054                                 return MT_STATS_NOT_DONE;
1055                         }
1056
1057                         // set the popup text
1058                         if(!(Game_mode & GM_STANDALONE_SERVER)){
1059                                 SDL_snprintf(popup_text, SDL_arraysize(popup_text), XSTR("Updating player stats for %s...\n", 681), Net_players[Multi_store_stats_player_index].player->callsign);
1060                                 popup_change_text(popup_text);
1061                         }
1062
1063                         return MT_STATS_NOT_DONE;
1064                 }
1065
1066                 // otherwise check on his status
1067                 switch(SendFSPilotData(NULL)){
1068                 // error
1069                 case -1: case -2: case -3: case 2: case 3:
1070                         // flag him as done so we move onto the next guy
1071                         Multi_store_stats_player_flag = 1;
1072
1073                         Net_players[Multi_store_stats_player_index].flags |= NETINFO_FLAG_MT_SEND_FAILED;
1074                         Net_players[Multi_store_stats_player_index].flags |= NETINFO_FLAG_MT_DONE;
1075                         break;
1076
1077                 // got data
1078                 case 1:
1079                         // flag him as done so we move onto the next guys
1080                         Multi_store_stats_player_flag = 1;
1081                         Net_players[Multi_store_stats_player_index].flags |= NETINFO_FLAG_MT_DONE;
1082                         break;
1083                 }
1084
1085                 break;
1086         }
1087
1088         // return not done yet
1089         return MT_STATS_NOT_DONE;
1090 }
1091
1092 // copy a freespace stats struct to a tracker-freespace stats struct
1093 void multi_stats_fs_to_tracker(scoring_struct *fs, vmt_stats_struct *vmt, player *pl, int tracker_id)
1094 {
1095         char tracker_id_string[256];
1096
1097         // tracker id string
1098         SDL_snprintf(tracker_id_string, SDL_arraysize(tracker_id_string),"%d", tracker_id);
1099         SDL_strlcpy(vmt->tracker_id, tracker_id_string, SDL_arraysize(vmt->tracker_id));
1100
1101         // pilot callsign
1102         SDL_strlcpy(vmt->pilot_name, pl->callsign, SDL_arraysize(vmt->pilot_name));
1103
1104         // score, rank and medals
1105         vmt->score = fs->score;
1106         vmt->rank = fs->rank;
1107 #ifndef MAKE_FS1
1108         SDL_assert(MAX_FS2_MEDALS == NUM_MEDALS);
1109         memcpy(vmt->medals, fs->medals, sizeof(int) * MAX_FS2_MEDALS);
1110         vmt->num_medals = MAX_FS2_MEDALS;
1111 #else
1112         memcpy(vmt->medals, fs->medals, sizeof(int) * MAX_FS_MEDALS);
1113 #endif
1114
1115         // kills and assists
1116 #ifndef MAKE_FS1
1117         SDL_assert(MAX_FS2_SHIP_TYPES == MAX_SHIP_TYPES);
1118         memcpy(vmt->kills, fs->kills, sizeof(ushort) * MAX_FS2_SHIP_TYPES);
1119         vmt->num_ship_types = MAX_FS2_SHIP_TYPES;
1120 #else
1121         memcpy(vmt->kills, fs->kills, sizeof(int) * MAX_FS_SHIP_TYPES);
1122 #endif
1123         vmt->assists = fs->assists;
1124         vmt->kill_count = fs->kill_count;
1125         vmt->kill_count_ok = fs->kill_count_ok;
1126
1127
1128         // shot statistics
1129         vmt->p_shots_fired = fs->p_shots_fired;
1130         vmt->s_shots_fired = fs->s_shots_fired;
1131         vmt->p_shots_hit = fs->p_shots_hit;
1132         vmt->s_shots_hit = fs->s_shots_hit;
1133         vmt->p_bonehead_hits = fs->p_bonehead_hits;
1134         vmt->s_bonehead_hits = fs->s_bonehead_hits;
1135         vmt->bonehead_kills = fs->bonehead_kills;
1136
1137         // missions flown information
1138         vmt->missions_flown = fs->missions_flown;
1139         vmt->flight_time = fs->flight_time;
1140         vmt->last_flown = (unsigned int)fs->last_flown;
1141 }
1142
1143 // copy a tracker-freespace stats struct to a freespace stats struct
1144 void multi_stats_tracker_to_fs(vmt_stats_struct *vmt,scoring_struct *fs)
1145 {
1146 #ifndef MAKE_FS1
1147         int num_medals, num_ship_types;
1148 #endif
1149
1150         // score, rank and medals
1151         fs->score = vmt->score;
1152         fs->rank = vmt->rank;
1153 #ifndef MAKE_FS1
1154         num_medals = vmt->num_medals;
1155         if(num_medals > NUM_MEDALS){
1156                 Int3();
1157                 num_medals = NUM_MEDALS;
1158         }
1159         memset(fs->medals, 0, sizeof(int) * NUM_MEDALS);
1160         memcpy(fs->medals, vmt->medals, sizeof(int) * num_medals);
1161 #else
1162         SDL_zero(fs->medals);
1163         memcpy(fs->medals, vmt->medals, sizeof(int) * NUM_MEDALS);
1164 #endif
1165
1166         // kills and assists
1167 #ifndef MAKE_FS1
1168         num_ship_types = vmt->num_ship_types;
1169         if(num_ship_types > MAX_SHIP_TYPES){
1170                 Int3();
1171                 num_ship_types = MAX_SHIP_TYPES;
1172         }
1173         memset(fs->kills, 0, sizeof(ushort) * MAX_SHIP_TYPES);
1174         memcpy(fs->kills, vmt->kills, sizeof(ushort) * num_ship_types);
1175 #else
1176         SDL_zero(fs->kills);
1177         memcpy(fs->kills, vmt->kills, sizeof(int) * MAX_SHIP_TYPES);
1178 #endif
1179         fs->assists = vmt->assists;
1180         fs->kill_count = vmt->kill_count;
1181         fs->kill_count_ok = vmt->kill_count_ok;
1182
1183         // shot statistics
1184         fs->p_shots_fired = vmt->p_shots_fired;
1185         fs->s_shots_fired = vmt->s_shots_fired;
1186         fs->p_shots_hit = vmt->p_shots_hit;
1187         fs->s_shots_hit = vmt->s_shots_hit;
1188         fs->p_bonehead_hits = vmt->p_bonehead_hits;
1189         fs->s_bonehead_hits = vmt->s_bonehead_hits;
1190         fs->bonehead_kills = vmt->bonehead_kills;
1191
1192         // missions flown information
1193         fs->missions_flown = vmt->missions_flown;
1194         fs->flight_time = vmt->flight_time;
1195         fs->last_flown = (fs_time_t)vmt->last_flown;
1196         if(fs->last_flown < 0){
1197                 fs->last_flown = 0;
1198         }
1199 }
1200
1201 // process an incoming active game item
1202 void multi_fs_tracker_process_game_item(game_list *gl)
1203 {
1204         active_game ag;
1205         int idx;
1206
1207         for(idx=0;idx<MAX_GAME_LISTS_PER_PACKET;idx++){
1208                 // skip null server addresses
1209                 if(gl->game_server[idx] == 0){
1210                         continue;
1211                 }
1212
1213                 // package up the game information
1214                 memset(&ag,0,sizeof(active_game));
1215                 SDL_strlcpy(ag.name, gl->game_name[idx], SDL_arraysize(ag.name));
1216                 memcpy(&ag.server_addr.addr[0], &gl->game_server[idx], IP_ADDRESS_LENGTH);
1217                 ag.server_addr.type = NET_TCP;
1218                 ag.server_addr.port = DEFAULT_GAME_PORT;
1219
1220                 // add to the active game list
1221                 // multi_update_active_games(&ag);
1222
1223                 // query this server
1224                 send_server_query(&ag.server_addr);
1225         }
1226 }
1227
1228 int multi_fs_store_stats_get_next_player(int cur_player)
1229 {
1230         int idx;
1231
1232         // if we're at the end of the list
1233         if(cur_player == (MAX_PLAYERS - 1)){
1234                 return -2;
1235         }
1236
1237         // find the next player
1238         for(idx=cur_player+1;idx<MAX_PLAYERS;idx++){
1239                 // STANDALONE_ONLY
1240                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx]) && (Net_players[idx].tracker_player_id != -1) && !(Net_players[idx].flags & NETINFO_FLAG_MT_GET_FAILED) ){
1241                         return idx;
1242                 }
1243         }
1244
1245         // couldn't find one
1246         return -2;
1247 }
1248
1249 // verify that there are no duplicate tracker id's to this one
1250 void multi_fs_tracker_check_dup(int tracker_id,int player_index)
1251 {
1252         int idx;
1253
1254         // compare against all players except the passed player_index
1255         for(idx=0;idx<MAX_PLAYERS;idx++){
1256                 if(idx == player_index){
1257                         continue;
1258                 }
1259
1260                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx]) && (Net_players[idx].tracker_player_id != -1)){
1261                         SDL_assert(Net_players[idx].tracker_player_id != tracker_id);
1262                 }
1263         }
1264 }
1265
1266 // verify that there are no duplicate pilot callsigns
1267 void multi_fs_tracker_check_dup_callsign(net_player *player,int player_index)
1268 {
1269         int idx;
1270
1271         // compare against all players except the passed player_index
1272         for(idx=0;idx<MAX_PLAYERS;idx++){
1273                 if(idx == player_index){
1274                         continue;
1275                 }
1276
1277                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx]) && (Net_players[idx].tracker_player_id != -1)){
1278                         SDL_assert(strcmp(player->player->callsign,Net_players[idx].player->callsign));
1279                 }
1280         }
1281 }
1282
1283 // return an MVALID_STATUS_* constant
1284 int multi_fs_tracker_validate_mission_std()
1285 {
1286         int ret_val;
1287
1288         // wait for a response from the tracker
1289         do {
1290                 ret_val = ValidateMission(NULL);
1291         } while(ret_val == 0);
1292
1293         // report on the results
1294         switch(ret_val){
1295         // timeout
1296         case -2:
1297                 return MVALID_STATUS_UNKNOWN;
1298
1299         // invalid
1300         case -1:
1301                 return MVALID_STATUS_INVALID;
1302
1303         // valid, success
1304         case 1:
1305                 return MVALID_STATUS_VALID;
1306         }
1307
1308         Int3();
1309         return 0;
1310 }
1311
1312 // special return values :
1313 // 1 for timeout
1314 // 2 for invalid
1315 // 3 for valid
1316 int multi_fs_tracker_validate_mission_normal()
1317 {
1318         switch(ValidateMission(NULL)){
1319         // timeout
1320         case -2:
1321                 return 1;
1322
1323         // invalid
1324         case -1 :
1325                 return 2;
1326
1327         // valid
1328         case 1:
1329                 return 3;
1330         }
1331
1332         // not done yet
1333         return 0;
1334 }
1335
1336 // return an MVALID_STATUS_* (see multiui.h) value, or -2 if the user has "cancelled"
1337 int multi_fs_tracker_validate_mission(char *filename)
1338 {
1339         vmt_validate_mission_req_struct mission;
1340         char popup_string[512] = "";
1341
1342         if(!Multi_fs_tracker_inited){
1343                 return MVALID_STATUS_UNKNOWN;
1344         }
1345
1346         // get the checksum of the local file
1347         memset(&mission, 0, sizeof(mission));
1348         SDL_strlcpy(mission.file_name, filename, SDL_arraysize(mission.file_name));
1349         if(!cf_chksum_long(mission.file_name, (uint*)&mission.checksum)){
1350                 return MVALID_STATUS_UNKNOWN;
1351         }
1352
1353         // try and validate the mission
1354         if(ValidateMission(&mission) != 0){
1355                 return MVALID_STATUS_UNKNOWN;
1356         }
1357
1358         // do frames for standalone and non-standalone
1359         if(Game_mode & GM_STANDALONE_SERVER){
1360                 int ret_code;
1361
1362                 // set the filename in the dialog
1363                 std_gen_set_text(filename, 2);
1364
1365                 // validate the mission
1366                 ret_code = multi_fs_tracker_validate_mission_std();
1367
1368                 // if the dialog is no longer active, cancel everything
1369                 //if(!std_gen_is_active()){
1370                 //      return MVALID_STATUS_UNKNOWN;
1371                 //}
1372
1373                 return ret_code;
1374         } else {
1375                 SDL_snprintf(popup_string, SDL_arraysize(popup_string), XSTR("Validating mission %s", 1074), filename);
1376
1377                 // run a popup
1378                 switch(popup_till_condition(multi_fs_tracker_validate_mission_normal, XSTR("&Cancel", 667), popup_string)){
1379                 // cancel
1380                 case 0:
1381                         // bash some API values here so that next time we try and verify, everything works
1382                         extern int MissionValidState;
1383                         MissionValidState = VALID_STATE_IDLE;
1384                         return -2;
1385
1386                 // timeout
1387                 case 1:
1388                         return MVALID_STATUS_UNKNOWN;
1389
1390                 // invalid
1391                 case 2:
1392                         return MVALID_STATUS_INVALID;
1393
1394                 // valid
1395                 case 3:
1396                         return MVALID_STATUS_VALID;
1397                 }
1398         }
1399
1400         return MVALID_STATUS_UNKNOWN;
1401 }
1402
1403 // report on the results of the stats store procedure
1404 void multi_fs_tracker_report_stats_results()
1405 {
1406         int idx;
1407         char str[512] = "";
1408
1409         // tell everyone stats store is complete
1410         SDL_strlcpy(str, XSTR("<PXO stats store process complete>", 1001), SDL_arraysize(str));
1411         send_game_chat_packet(Net_player, str, MULTI_MSG_ALL, NULL, NULL, 1);
1412         multi_display_chat_msg(str, 0, 0);
1413         ml_string(str);
1414
1415         // for all players
1416         for(idx=0; idx<MAX_PLAYERS; idx++){
1417                 // for all players who we care about
1418                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx])){
1419                         // if the stats get or send failed for any player, report as such
1420                         if(((Net_players[idx].tracker_player_id <= 0) || (Net_players[idx].flags & NETINFO_FLAG_MT_GET_FAILED) || (Net_players[idx].flags & NETINFO_FLAG_MT_SEND_FAILED) || !(Net_players[idx].flags & NETINFO_FLAG_MT_DONE)) && (Net_players[idx].player != NULL)){
1421                                 SDL_snprintf(str, SDL_arraysize(str), XSTR("<PXO stats store failed for player %s>", 1002), Net_players[idx].player->callsign);
1422                                 send_game_chat_packet(Net_player, str, MULTI_MSG_ALL, NULL, NULL, 1);
1423
1424                                 multi_display_chat_msg(str, 0, 0);
1425                                 ml_string(str);
1426                         }
1427                 }
1428         }
1429 }
1430
1431 // return an MSW_STATUS_* constant
1432 int multi_fs_tracker_validate_sw_std()
1433 {
1434         int ret_val;
1435
1436         // wait for a response from the tracker
1437         do {
1438                 ret_val = ValidateSquadWar(NULL, &Multi_tracker_sw_response);
1439         } while(ret_val == 0);
1440
1441         // report on the results
1442         switch(ret_val){
1443         // timeout
1444         case -2:
1445                 return MVALID_STATUS_UNKNOWN;
1446
1447         // invalid
1448         case -1:
1449                 return MVALID_STATUS_INVALID;
1450
1451         // valid, success
1452         case 1:
1453                 return MVALID_STATUS_VALID;
1454         }
1455
1456         return MVALID_STATUS_UNKNOWN;
1457 }
1458
1459 // special return values :
1460 // 1 for timeout
1461 // 2 for invalid
1462 // 3 for valid
1463 int multi_fs_tracker_validate_sw_normal()
1464 {
1465         switch(ValidateSquadWar(NULL, &Multi_tracker_sw_response)){
1466         // timeout
1467         case -2:
1468                 return 1;
1469
1470         // invalid
1471         case -1 :
1472                 return 2;
1473
1474         // valid
1475         case 1:
1476                 return 3;
1477         }
1478
1479         // not done yet
1480         return 0;
1481 }
1482
1483 #define STUFF_SW_RESPONSE(_c, _len) do {\
1484         SDL_strlcpy(_c, "", _len);\
1485         int _idx;\
1486         int _bogus = 1;\
1487         for(_idx=0; _idx<MAX_SQUAD_RESPONSE_LEN; _idx++){\
1488                 if(Multi_tracker_sw_response.reason[_idx] == '\0'){\
1489                         _bogus = 0;\
1490                         break;\
1491                 }\
1492         }\
1493         if(!_bogus){\
1494                 SDL_strlcpy(_c, Multi_tracker_sw_response.reason, _len);\
1495         }\
1496 } while(0);
1497
1498 // return an MSW_STATUS_* value
1499 int multi_fs_tracker_validate_sw(squad_war_request *sw_req, char *bad_reply, const int max_reply_len)
1500 {
1501         char popup_string[512] = "";
1502
1503         if(!Multi_fs_tracker_inited){
1504                 return MSW_STATUS_UNKNOWN;
1505         }
1506
1507         // zero the response
1508         memset(&Multi_tracker_sw_response, 0, sizeof(Multi_tracker_sw_response));
1509
1510         // try and validate the mission
1511         if(ValidateSquadWar(sw_req, &Multi_tracker_sw_response) != 0){
1512                 SDL_strlcpy(bad_reply, "Error sending request for Squad War validation", max_reply_len);
1513
1514                 return MSW_STATUS_UNKNOWN;
1515         }
1516
1517         // do frames for standalone and non-standalone
1518         if(Game_mode & GM_STANDALONE_SERVER){
1519                 int ret_code;
1520
1521                 // validate the mission
1522                 ret_code = multi_fs_tracker_validate_sw_std();
1523
1524                 // copy the return code
1525                 STUFF_SW_RESPONSE(bad_reply, max_reply_len);
1526
1527                 return ret_code;
1528         } else {
1529                 SDL_strlcpy(popup_string, XSTR("Validating squad war", 1075), SDL_arraysize(popup_string));
1530
1531                 // run a popup
1532                 switch(popup_till_condition(multi_fs_tracker_validate_sw_normal, XSTR("&Cancel", 645), popup_string)){
1533                 // cancel
1534                 case -1:
1535                 case 0:
1536                         // bash some API values here so that next time we try and verify, everything works
1537                         extern int SquadWarValidState;
1538                         SquadWarValidState = VALID_STATE_IDLE;
1539
1540                         // copy the return code
1541                         STUFF_SW_RESPONSE(bad_reply, max_reply_len);
1542                         return -2;
1543
1544                 // timeout
1545                 case 1:
1546                         // copy the return code
1547                         SDL_strlcpy(bad_reply, "Timeout", max_reply_len);
1548                         return MSW_STATUS_UNKNOWN;
1549
1550                 // invalid
1551                 case 2:
1552                         // copy the return code
1553                         STUFF_SW_RESPONSE(bad_reply, max_reply_len);
1554                         return MSW_STATUS_INVALID;
1555
1556                 // valid
1557                 case 3:
1558                         // copy the return code
1559                         STUFF_SW_RESPONSE(bad_reply, max_reply_len);
1560                         return MSW_STATUS_VALID;
1561                 }
1562         }
1563
1564         SDL_strlcpy(bad_reply, "Unknown error", max_reply_len);
1565         return MSW_STATUS_UNKNOWN;
1566 }
1567
1568 // popup do function
1569 // -3   Error -- Called with NULL, but no request is waiting
1570 // -2   Error -- Already sending data (hasn't timed out yet)
1571 // -1   Timeout trying to send pilot data
1572 // 0    Sending
1573 // 1    Data succesfully sent
1574 // 2    Send Cancelled (data may still have been written already, we just haven't been ACK'd yet)
1575 // 3    Pilot not written (for some reason)
1576
1577 int multi_fs_tracker_store_sw_do()
1578 {
1579         switch(SendSWData(NULL, &Multi_tracker_sw_response)){
1580         // failure
1581         case -3:
1582         case -2:
1583         case -1:
1584         case 2:
1585         case 3:
1586                 return 1;
1587
1588         // success
1589         case 1:
1590                 return 10;
1591         }
1592
1593         // not done
1594         return 0;
1595 }
1596
1597 // store the results of a squad war mission on PXO, return 1 on success
1598 int multi_fs_tracker_store_sw(squad_war_result *sw_res, char *bad_reply, const int max_reply_len)
1599 {
1600         char popup_string[512] = "";
1601
1602         // clear any old requests
1603         SendSWData((squad_war_result*)0xffffffff, NULL);
1604
1605         // send this new request
1606         SendSWData(sw_res, &Multi_tracker_sw_response);
1607
1608         // standalone
1609         if(Game_mode & GM_STANDALONE_SERVER){
1610                 int ret_code;
1611                 do {
1612                         ret_code = SendSWData(NULL, &Multi_tracker_sw_response);
1613                 } while(ret_code == 0);
1614
1615                 // success
1616                 if(ret_code == 1){
1617                         return 1;
1618                 }
1619         }
1620         // non-standalone
1621         else {
1622                 SDL_strlcpy(popup_string, XSTR("Storing SquadWar results", 1078), SDL_arraysize(popup_string));
1623
1624                 // wait for a response
1625                 if(popup_till_condition(multi_fs_tracker_store_sw_do, XSTR("&Cancel", 645), popup_string) == 10){
1626                         // success
1627                         return 1;
1628                 }
1629         }
1630
1631         // failure
1632         return 0;
1633 }
1634