src/mission/missioncampaign.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/Mission/MissionCampaign.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * source for dealing with campaigns
  16  *
  17  * $Log$
  18  * Revision 1.8  2003/06/11 18:30:33  taylor
  19  * plug memory leaks
  20  *
  21  * Revision 1.7  2003/05/25 02:30:42  taylor
  22  * Freespace 1 support
  23  *
  24  * Revision 1.6  2002/07/24 00:20:42  relnev
  25  * nothing interesting
  26  *
  27  * Revision 1.5  2002/06/21 03:34:05  relnev
  28  * implemented a stub and fixed a path
  29  *
  30  * Revision 1.4  2002/06/09 04:41:22  relnev
  31  * added copyright header
  32  *
  33  * Revision 1.3  2002/06/09 03:16:04  relnev
  34  * added _splitpath.
  35  *
  36  * removed unneeded asm, old sdl 2d setup.
  37  *
  38  * fixed crash caused by opengl_get_region.
  39  *
  40  * Revision 1.2  2002/06/02 04:26:34  relnev
  41  * warning cleanup
  42  *
  43  * Revision 1.1.1.1  2002/05/03 03:28:09  root
  44  * Initial import.
  45  *
  46  *
  47  * 23    9/14/99 4:35a Dave
  48  * Argh. Added all kinds of code to handle potential crashes in debriefing
  49  * code.
  50  *
  51  * 22    9/09/99 11:40p Dave
  52  * Handle an SDL_assert() in beam code. Added supernova sounds. Play the right
  53  * 2 end movies properly, based upon what the player did in the mission.
  54  *
  55  * 21    9/09/99 9:34a Jefff
  56  * fixed a potential exit-loop bug
  57  *
  58  * 20    9/07/99 6:55p Jefff
  59  * functionality to break out of a loop.  hacked functionality to jump to
  60  * a specific mission in a campaign -- doesnt grant ships/weapons from
  61  * skipped missions tho.
  62  *
  63  * 19    9/07/99 2:19p Jefff
  64  * clear skip mission player vars on mission skip
  65  *
  66  * 18    9/06/99 9:45p Jefff
  67  * break out of loop and skip mission support
  68  *
  69  * 17    9/06/99 6:38p Dave
  70  * Improved CD detection code.
  71  *
  72  * 16    9/03/99 1:32a Dave
  73  * CD checking by act. Added support to play 2 cutscenes in a row
  74  * seamlessly. Fixed super low level cfile bug related to files in the
  75  * root directory of a CD. Added cheat code to set campaign mission # in
  76  * main hall.
  77  *
  78  * 15    8/27/99 12:04a Dave
  79  * Campaign loop screen.
  80  *
  81  * 14    8/04/99 5:36p Andsager
  82  * Show upsell screens at end of demo campaign before returning to main
  83  * hall.
  84  *
  85  * 13    2/05/99 3:50p Anoop
  86  * Removed dumb campaign mission stats saving from multiplayer.
  87  *
  88  * 12    12/17/98 2:43p Andsager
  89  * Modify fred campaign save file to include optional mission loops
  90  *
  91  * 11    12/12/98 3:17p Andsager
  92  * Clean up mission eval, goal, event and mission scoring.
  93  *
  94  * 10    12/10/98 9:59a Andsager
  95  * Fix some bugs with mission loops
  96  *
  97  * 9     12/09/98 1:56p Andsager
  98  * Initial checkin of mission loop
  99  *
 100  * 8     11/05/98 5:55p Dave
 101  * Big pass at reducing #includes
 102  *
 103  * 7     11/03/98 4:48p Johnson
 104  * Fixed campaign file versioning bug left over from Silent Threat port.
 105  *
 106  * 6     10/23/98 3:51p Dave
 107  * Full support for tstrings.tbl and foreign languages. All that remains
 108  * is to make it active in Fred.
 109  *
 110  * 5     10/13/98 2:47p Andsager
 111  * Remove reference to Tech_shivan_species_avail
 112  *
 113  * 4     10/13/98 9:28a Dave
 114  * Started neatening up freespace.h. Many variables renamed and
 115  * reorganized. Added AlphaColors.[h,cpp]
 116  *
 117  * 3     10/07/98 6:27p Dave
 118  * Globalized mission and campaign file extensions. Removed Silent Threat
 119  * special code. Moved \cache \players and \multidata into the \data
 120  * directory.
 121  *
 122  * 2     10/07/98 10:53a Dave
 123  * Initial checkin.
 124  *
 125  * 1     10/07/98 10:49a Dave
 126  *
 127  * 95    9/10/98 1:17p Dave
 128  * Put in code to flag missions and campaigns as being MD or not in Fred
 129  * and Freespace. Put in multiplayer support for filtering out MD
 130  * missions. Put in multiplayer popups for warning of non-valid missions.
 131  *
 132  * 94    9/01/98 4:25p Dave
 133  * Put in total (I think) backwards compatibility between mission disk
 134  * freespace and non mission disk freespace, including pilot files and
 135  * campaign savefiles.
 136  *
 137  * 93    7/06/98 4:10p Hoffoss
 138  * Fixed some bugs that presented themselves when trying to use a pilot
 139  * that has a no longer existent campaign active.  Also expanded the
 140  * campaign load code to actually return a proper error code, instead of
 141  * always trapping errors internally and crashing, and always returning 0.
 142  *
 143  * 92    6/17/98 9:30a Allender
 144  * fixed red alert replay stats clearing problem
 145  *
 146  * 91    6/01/98 11:43a John
 147  * JAS & MK:  Classified all strings for localization.
 148  *
 149  * 90    5/25/98 1:29p Allender
 150  * end mission sequencing
 151  *
 152  * 89    5/21/98 9:25p Allender
 153  * endgame movie always viewable at end of campaign
 154  *
 155  * 88    5/13/98 5:14p Allender
 156  * red alert support to go back to previous mission
 157  *
 158  * 87    5/12/98 4:16p Hoffoss
 159  * Fixed bug where not all missions in all campaigns were being filtered
 160  * out of stand alone mission listing in simulator room.
 161  *
 162  * 86    5/05/98 3:29p Hoffoss
 163  * Changed code so description is BEFORE num players in campaign file.
 164  * Other code is relying on this ordering.
 165  *
 166  * 85    5/05/98 12:19p Dave
 167  * campaign description goes *after* num players
 168  *
 169  * 84    5/04/98 5:52p Comet
 170  * Fixed bug with Galatea/Bastion selection when finishing missions.
 171  *
 172  * 83    5/01/98 2:46p Duncan
 173  * fix a cfile problem with campaigns related to the new cfile stuff
 174  *
 175  * 82    5/01/98 12:34p John
 176  * Added code to force FreeSpace to run in the same dir as exe and made
 177  * all the parse error messages a little nicer.
 178  *
 179  * 81    4/30/98 7:01p Duncan
 180  * AL: don't allow deletion of campaign files in multiplayer
 181  *
 182  * 80    4/30/98 4:53p John
 183  * Restructured and cleaned up cfile code.  Added capability to read off
 184  * of CD-ROM drive and out of multiple pack files.
 185  *
 186  * $NoKeywords: $
 187  */
 188
 189 #include <stdio.h>
 190 #ifndef PLAT_UNIX
 191 #include <direct.h>
 192 #include <io.h>
 193 #else
 194 #include <sys/types.h>
 195 #include <sys/stat.h>
 196 #include <unistd.h>
 197 #include <dirent.h>
 198 #include <fnmatch.h>
 199 #endif
 200 #include <string.h>
 201 #include <errno.h>
 202
 203 #include "key.h"
 204 #include "ui.h"
 205 #include "missioncampaign.h"
 206 #include "gamesequence.h"
 207 #include "2d.h"
 208 #include "parselo.h"
 209 #include "missionload.h"
 210 #include "freespace.h"
 211 #include "sexp.h"
 212 #include "cfile.h"
 213 #include "player.h"
 214 #include "missiongoals.h"
 215 #include "movie.h"
 216 #include "multi.h"
 217 #include "techmenu.h"
 218 #include "eventmusic.h"
 219 #include "alphacolors.h"
 220 #include "localize.h"
 221 #include "supernova.h"
 222
 223 // mission disk stuff
 224 #define CAMPAIGN_SAVEFILE_MAX_SHIPS_OLD                                         75
 225 #define CAMPAIGN_SAVEFILE_MAX_WEAPONS_OLD                                               44
 226
 227 #define CAMPAIGN_INITIAL_RELEASE_FILE_VERSION                           6
 228
 229 // campaign wasn't ended
 230 int Campaign_ended_in_mission = 0;
 231
 232 // stuff for selecting campaigns.  We need to keep both arrays around since we display the
 233 // list of campaigns by name, but must load campaigns by filename
 234 char *Campaign_names[MAX_CAMPAIGNS];
 235 char *Campaign_file_names[MAX_CAMPAIGNS];
 236 int     Num_campaigns;
 237
 238 const char *campaign_types[MAX_CAMPAIGN_TYPES] =
 239 {
 240 //XSTR:OFF
 241         "single",
 242         "multi coop",
 243         "multi teams"
 244 //XSTR:ON
 245 };
 246
 247 // modules local variables to deal with getting new ships/weapons available to the player
 248 int Num_granted_ships, Num_granted_weapons;             // per mission counts of new ships and weapons
 249 int Granted_ships[MAX_SHIP_TYPES];
 250 int Granted_weapons[MAX_WEAPON_TYPES];
 251
 252 // variables to control the UI stuff for loading campaigns
 253 static UI_WINDOW Campaign_window;
 254 static UI_LISTBOX Campaign_listbox;
 255 static UI_BUTTON Campaign_okb, Campaign_cancelb;
 256
 257 // the campaign!!!!!
 258 campaign Campaign;
 259
 260 // variables with deal with the campaign save file
 261 #define CAMPAIGN_FILE_VERSION                                                   12
 262 //#define CAMPAIGN_FILE_COMPATIBLE_VERSION              CAMPAIGN_INITIAL_RELEASE_FILE_VERSION
 263 #define CAMPAIGN_FILE_COMPATIBLE_VERSION                        CAMPAIGN_FILE_VERSION
 264 #define CAMPAIGN_FILE_ID                                                                0xbeefcafe
 265
 266 // variables with deal with the campaign stats save file
 267 #define CAMPAIGN_STATS_FILE_VERSION                                     1
 268 #define CAMPAIGN_STATS_FILE_COMPATIBLE_VERSION  1
 269 #define CAMPAIGN_STATS_FILE_ID                                          0xabbadaad
 270
 271 // mission_campaign_get_name returns a string (which is malloced in this routine) of the name
 272 // of the given freespace campaign file.  In the type field, we return if the campaign is a single
 273 // player or multiplayer campaign.  The type field will only be valid if the name returned is non-NULL
 274 int mission_campaign_get_info(const char *filename, char *name, int *type, int *max_players, char **desc)
 275 {
 276         int i;
 277         char campaign_type[NAME_LENGTH], fname[MAX_FILENAME_LEN];
 278
 279         SDL_assert( name != NULL );
 280         SDL_assert( type != NULL );
 281
 282         // open localization
 283         lcl_ext_open();
 284
 285         SDL_strlcpy(fname, filename, SDL_arraysize(fname));
 286         if ((strlen(fname) < 4) || SDL_strcasecmp(fname + strlen(fname) - 4, FS_CAMPAIGN_FILE_EXT)){
 287                 SDL_strlcat(fname, FS_CAMPAIGN_FILE_EXT, SDL_arraysize(fname));
 288         }
 289
 290         SDL_assert(strlen(fname) < MAX_FILENAME_LEN);
 291
 292         try {
 293                 read_file_text( fname );
 294                 reset_parse();
 295                 required_string("$Name:");
 296
 297                 stuff_string( name, F_NAME, NULL );
 298                 if ( name == NULL ) {
 299                         Int3();
 300                         nprintf(("Warning", "No name found for campaign file %s\n", filename));
 301
 302                         // close localization
 303                         lcl_ext_close();
 304
 305                         return 0;
 306                 }
 307
 308                 required_string( "$Type:" );
 309                 stuff_string( campaign_type, F_NAME, NULL );
 310
 311                 *type = -1;
 312                 for (i=0; i<MAX_CAMPAIGN_TYPES; i++) {
 313                         if ( !SDL_strcasecmp(campaign_type, campaign_types[i]) ) {
 314                                 *type = i;
 315                         }
 316                 }
 317
 318                 if (desc) {
 319                         *desc = NULL;
 320                         if (optional_string("+Description:")) {
 321                                 *desc = stuff_and_malloc_string(F_MULTITEXT, NULL, MISSION_DESC_LENGTH);
 322                         }
 323                 }
 324
 325                 // if this is a multiplayer campaign, get the max players
 326                 if ((*type) > 0) {
 327                         skip_to_string("+Num Players:");
 328                         stuff_int(max_players);
 329                 }
 330
 331                 // if we found a valid campaign type
 332                 if ((*type) >= 0) {
 333                         // close localization
 334                         lcl_ext_close();
 335
 336                         return 1;
 337                 }
 338         } catch (parse_error_t rval) {
 339                 if (rval == PARSE_ERROR_FILE_NOT_FOUND) {
 340                         // close localization
 341                         lcl_ext_close();
 342
 343                         return 0;
 344                 }
 345
 346                 Error(LOCATION, "Error parsing '%s'\r\nError code = %i.\r\n", fname, (int)rval);
 347         }
 348
 349         Int3();         // get Allender -- incorrect type found
 350
 351         // close localization
 352         lcl_ext_close();
 353
 354         return 0;
 355 }
 356
 357 // parses campaign and returns a list of missions in it.  Returns number of missions added to
 358 // the 'list', and up to 'max' missions may be added to 'list'.  Returns negative on error.
 359 //
 360 int mission_campaign_get_mission_list(const char *filename, char **list, int max)
 361 {
 362         int i, num = 0;
 363         char name[NAME_LENGTH];
 364
 365         filename = cf_add_ext(filename, FS_CAMPAIGN_FILE_EXT);
 366
 367         // read the mission file and get the list of mission filenames
 368         try {
 369                 read_file_text(filename);
 370                 reset_parse();
 371
 372                 while (skip_to_string("$Mission:") > 0) {
 373                         stuff_string(name, F_NAME, NULL);
 374                         if (num < max)
 375                                 list[num++] = strdup(name);
 376                 }
 377         } catch (parse_error_t) {
 378                 // since we can't return count of allocated elements, free them instead
 379                 for (i=0; i<num; i++)
 380                         free(list[i]);
 381
 382                 return -1;
 383         }
 384
 385         return num;
 386 }
 387
 388 // gets optional ship/weapon information
 389 void mission_campaign_get_sw_info()
 390 {
 391         int i, count, ship_list[MAX_SHIP_TYPES], weapon_list[MAX_WEAPON_TYPES];
 392
 393         // set allowable ships to the SIF_PLAYER_SHIPs
 394         memset( Campaign.ships_allowed, 0, sizeof(Campaign.ships_allowed) );
 395         for (i = 0; i < MAX_SHIP_TYPES; i++ ) {
 396                 if ( Ship_info[i].flags & SIF_PLAYER_SHIP )
 397                         Campaign.ships_allowed[i] = 1;
 398         }
 399
 400         for (i = 0; i < MAX_WEAPON_TYPES; i++ )
 401                 Campaign.weapons_allowed[i] = 1;
 402
 403         if ( optional_string("+Starting Ships:") ) {
 404                 for (i = 0; i < MAX_SHIP_TYPES; i++ )
 405                         Campaign.ships_allowed[i] = 0;
 406
 407                 count = stuff_int_list(ship_list, MAX_SHIP_TYPES, SHIP_INFO_TYPE);
 408
 409                 // now set the array elements stating which ships we are allowed
 410                 for (i = 0; i < count; i++ ) {
 411                         if ( Ship_info[ship_list[i]].flags & SIF_PLAYER_SHIP )
 412                                 Campaign.ships_allowed[ship_list[i]] = 1;
 413                 }
 414         }
 415
 416         if ( optional_string("+Starting Weapons:") ) {
 417                 for (i = 0; i < MAX_WEAPON_TYPES; i++ )
 418                         Campaign.weapons_allowed[i] = 0;
 419
 420                 count = stuff_int_list(weapon_list, MAX_WEAPON_TYPES, WEAPON_POOL_TYPE);
 421
 422                 // now set the array elements stating which ships we are allowed
 423                 for (i = 0; i < count; i++ )
 424                         Campaign.weapons_allowed[weapon_list[i]] = 1;
 425         }
 426 }
 427
 428 // mission_campaign_load starts a new campaign.  It reads in the mission information in the campaign file
 429 // It also sets up all variables needed inside of the game to deal with starting mission numbers, etc
 430 //
 431 // Note: Due to difficulties in generalizing this function, parts of it are duplicated throughout
 432 // this file.  If you change the format of the campaign file, you should be sure these related
 433 // functions work properly and update them if it breaks them.
 434 int mission_campaign_load( const char *filename, int load_savefile )
 435 {
 436         int len, i;
 437         char name[NAME_LENGTH], type[NAME_LENGTH];
 438
 439         filename = cf_add_ext(filename, FS_CAMPAIGN_FILE_EXT);
 440
 441         // open localization
 442         lcl_ext_open();
 443
 444         // read the mission file and get the list of mission filenames
 445         try {
 446                 // be sure to remove all old malloced strings of Mission_names
 447                 // we must also free any goal stuff that was from a previous campaign
 448                 // this also frees sexpressions so the next call to init_sexp will be able to reclaim
 449                 // nodes previously used by another campaign.
 450                 mission_campaign_close();
 451
 452                 SDL_strlcpy( Campaign.filename, filename, SDL_arraysize(Campaign.filename) );
 453
 454                 // only initialize the sexpression stuff when Fred isn't running.  It'll screw things up major
 455                 // if it does
 456                 if ( !Fred_running ){
 457                         init_sexp();            // must initialize the sexpression stuff
 458                 }
 459
 460                 read_file_text( filename );
 461                 reset_parse();
 462                 memset( &Campaign, 0, sizeof(Campaign) );
 463
 464                 // copy filename to campaign structure minus the extension
 465                 len = min(strlen(filename) - 4 + 1, SDL_arraysize(Campaign.filename));
 466                 SDL_strlcpy(Campaign.filename, filename, len);
 467
 468                 required_string("$Name:");
 469                 stuff_string( name, F_NAME, NULL );
 470
 471                 //Store campaign name in the global struct
 472                 SDL_strlcpy( Campaign.name, name, SDL_arraysize(Campaign.name) );
 473
 474                 required_string( "$Type:" );
 475                 stuff_string( type, F_NAME, NULL );
 476
 477                 for (i = 0; i < MAX_CAMPAIGN_TYPES; i++ ) {
 478                         if ( !SDL_strcasecmp(type, campaign_types[i]) ) {
 479                                 Campaign.type = i;
 480                                 break;
 481                         }
 482                 }
 483
 484                 if ( i == MAX_CAMPAIGN_TYPES )
 485                         Error(LOCATION, "Unknown campaign type %s!", type);
 486
 487                 Campaign.desc = NULL;
 488                 if (optional_string("+Description:"))
 489                         Campaign.desc = stuff_and_malloc_string(F_MULTITEXT, NULL, MISSION_DESC_LENGTH);
 490
 491                 // if the type is multiplayer -- get the number of players
 492                 Campaign.num_players = 0;
 493                 if ( Campaign.type != CAMPAIGN_TYPE_SINGLE) {
 494                         required_string("+Num players:");
 495                         stuff_int( &(Campaign.num_players) );
 496                 }
 497
 498 #ifdef MAKE_FS1
 499                 // check if mission disk -
 500                 // doesn't do anything but prevent non fatal error messages
 501                 optional_string("+Missiondisk");
 502 #endif
 503
 504                 // parse the optional ship/weapon information
 505                 mission_campaign_get_sw_info();
 506
 507                 // parse the mission file and actually read in the mission stuff
 508                 Campaign.num_missions = 0;
 509                 while ( required_string_either("#End", "$Mission:") ) {
 510                         cmission *cm;
 511
 512                         required_string("$Mission:");
 513                         stuff_string(name, F_NAME, NULL);
 514                         cm = &Campaign.missions[Campaign.num_missions];
 515                         cm->name = strdup(name);
 516
 517                         cm->briefing_cutscene[0] = 0;
 518                         if ( optional_string("+Briefing Cutscene:") )
 519                                 stuff_string( cm->briefing_cutscene, F_NAME, NULL );
 520
 521                         cm->flags = 0;
 522                         if (optional_string("+Flags:"))
 523                                 stuff_int(&cm->flags);
 524
 525                         cm->formula = -1;
 526                         if ( optional_string("+Formula:") ) {
 527                                 cm->formula = get_sexp_main();
 528                                 if ( !Fred_running ) {
 529                                         SDL_assert ( cm->formula != -1 );
 530                                         sexp_mark_persistent( cm->formula );
 531
 532                                 } else {
 533                                         if ( cm->formula == -1 ){
 534                                                 // close localization
 535                                                 lcl_ext_close();
 536
 537                                                 return CAMPAIGN_ERROR_SEXP_EXHAUSTED;
 538                                         }
 539                                 }
 540                         }
 541
 542                         // Do misison looping stuff
 543                         cm->has_mission_loop = 0;
 544                         if ( optional_string("+Mission Loop:") ) {
 545                                 cm->has_mission_loop = 1;
 546                         }
 547
 548                         cm->mission_loop_desc = NULL;
 549                         if ( optional_string("+Mission Loop Text:")) {
 550                                 cm->mission_loop_desc = stuff_and_malloc_string(F_MULTITEXT, NULL, MISSION_DESC_LENGTH);
 551                         }
 552
 553                         cm->mission_loop_brief_anim = NULL;
 554                         if ( optional_string("+Mission Loop Brief Anim:")) {
 555                                 cm->mission_loop_brief_anim = stuff_and_malloc_string(F_MULTITEXT, NULL, MAX_FILENAME_LEN);
 556                         }
 557
 558                         cm->mission_loop_brief_sound = NULL;
 559                         if ( optional_string("+Mission Loop Brief Sound:")) {
 560                                 cm->mission_loop_brief_sound = stuff_and_malloc_string(F_MULTITEXT, NULL, MAX_FILENAME_LEN);
 561                         }
 562
 563                         cm->mission_loop_formula = -1;
 564                         if ( optional_string("+Formula:") ) {
 565                                 cm->mission_loop_formula = get_sexp_main();
 566                                 if ( !Fred_running ) {
 567                                         SDL_assert ( cm->mission_loop_formula != -1 );
 568                                         sexp_mark_persistent( cm->mission_loop_formula );
 569
 570                                 } else {
 571                                         if ( cm->mission_loop_formula == -1 ){
 572                                                 // close localization
 573                                                 lcl_ext_close();
 574
 575                                                 return CAMPAIGN_ERROR_SEXP_EXHAUSTED;
 576                                         }
 577                                 }
 578                         }
 579
 580                         if (optional_string("+Level:")) {
 581                                 stuff_int( &cm->level );
 582                                 if ( cm->level == 0 )  // check if the top (root) of the whole tree
 583                                         Campaign.next_mission = Campaign.num_missions;
 584
 585                         } else
 586                                 Campaign.realign_required = 1;
 587
 588                         if (optional_string("+Position:"))
 589                                 stuff_int( &cm->pos );
 590                         else
 591                                 Campaign.realign_required = 1;
 592
 593                         if (Fred_running) {
 594                                 cm->num_goals = -1;
 595                                 cm->num_events = -1;
 596                                 cm->notes = NULL;
 597
 598                         } else {
 599                                 cm->num_goals = 0;
 600                                 cm->num_events = 0;
 601                         }
 602
 603                         cm->goals = NULL;
 604                         cm->events = NULL;
 605                         Campaign.num_missions++;
 606                 }
 607         } catch (parse_error_t rval) {
 608                 (void)rval;     // suppress unused warning in release build
 609                 mprintf(("Error parsing '%s'\r\nError code = %i.\r\n", filename, (int)rval));
 610
 611                 // close localization
 612                 lcl_ext_close();
 613
 614                 return CAMPAIGN_ERROR_CORRUPT;
 615         }
 616
 617         // set up the other variables for the campaign stuff.  After initializing, we must try and load
 618         // the campaign save file for this player.  Since all campaign loads go through this routine, I
 619         // think this place should be the only necessary place to load the campaign save stuff.  The campaign
 620         // save file will get written when a mission has ended by player choice.
 621         Campaign.next_mission = 0;
 622         Campaign.prev_mission = -1;
 623         Campaign.current_mission = -1;
 624
 625         // loading the campaign will get us to the current and next mission that the player must fly
 626         // plus load all of the old goals that future missions might rely on.
 627         if (!Fred_running && load_savefile && (Campaign.type == CAMPAIGN_TYPE_SINGLE)) {
 628                 mission_campaign_savefile_load(Campaign.filename);
 629         }
 630
 631         // close localization
 632         lcl_ext_close();
 633
 634         return 0;
 635 }
 636
 637 // mission_campaign_load_by_name() loads up a freespace campaign given the filename.  This routine
 638 // is used to load up campaigns when a pilot file is loaded.  Generally, the
 639 // filename will probably be the freespace campaign file, but not necessarily.
 640 int mission_campaign_load_by_name( const char *filename )
 641 {
 642         char real_filename[MAX_FILENAME_LEN+1] = { 0 };
 643         char name[NAME_LENGTH],test[5];
 644         int type,max_players;
 645
 646         // make sure to tack on .fsc on the end if its not there already
 647         if(strlen(filename) > 0){
 648                 SDL_strlcpy(real_filename, filename, MAX_FILENAME_LEN);
 649
 650                 if(strlen(real_filename) > 4){
 651                         SDL_strlcpy(test, real_filename+(strlen(real_filename)-4), SDL_arraysize(test));
 652                         if(strcmp(test, FS_CAMPAIGN_FILE_EXT)!=0){
 653                                 SDL_strlcat(real_filename, FS_CAMPAIGN_FILE_EXT, SDL_arraysize(real_filename));
 654                         }
 655                 } else {
 656                         SDL_strlcat(real_filename, FS_CAMPAIGN_FILE_EXT, SDL_arraysize(real_filename));
 657                 }
 658         } else {
 659                 Error(LOCATION,"Tried to load campaign file with illegal length/extension!");
 660         }
 661
 662         if (!mission_campaign_get_info(real_filename, name, &type, &max_players)){
 663                 return -1;
 664         }
 665
 666         Num_campaigns = 0;
 667         Campaign_file_names[Num_campaigns] = real_filename;
 668         Campaign_names[Num_campaigns] = name;
 669         Num_campaigns++;
 670         mission_campaign_load(real_filename);
 671         return 0;
 672 }
 673
 674 int mission_campaign_load_by_name_csfe( const char *filename, const char *callsign )
 675 {
 676         Game_mode |= GM_NORMAL;
 677         SDL_strlcpy(Player->callsign, callsign, SDL_arraysize(Player->callsign));
 678         return mission_campaign_load_by_name( filename);
 679 }
 680
 681
 682 // mission_campaign_init initializes some variables then loads the default Freespace single player campaign.
 683 void mission_campaign_init()
 684 {
 685         memset(&Campaign, 0, sizeof(Campaign) );
 686 }
 687
 688 // Fill in the root of the campaign save filename
 689 void mission_campaign_savefile_generate_root(char *filename, const int max_len)
 690 {
 691         char base[MAX_FILENAME_LEN];
 692
 693         SDL_assert ( strlen(Campaign.filename) != 0 );
 694
 695         // build up the filename for the save file.  There could be a problem with filename length,
 696         // but this problem can get fixed in several ways -- ignore the problem for now though.
 697         base_filename(Campaign.filename, base, SDL_arraysize(base));
 698         SDL_assert ( (int)(strlen(base) + strlen(Player->callsign)) < max_len );
 699
 700         SDL_snprintf( filename, max_len, NOX("%s.%s."), Player->callsign, base );
 701 }
 702
 703 // mission_campaign_savefile_save saves the state of the campaign.  This function will probably always be called
 704 // then the player is done flying a mission in the campaign path.  It will save the missions played, the
 705 // state of the goals, etc.
 706
 707 int mission_campaign_savefile_save()
 708 {
 709         char filename[MAX_PATH_LEN];
 710         CFILE *fp;
 711         int i,j, mission_count;
 712
 713         memset(filename, 0, sizeof(filename));
 714         mission_campaign_savefile_generate_root(filename, SDL_arraysize(filename));
 715
 716         // name the file differently depending on whether we're in single player or multiplayer mode
 717         // single player : *.csg
 718         SDL_strlcat( filename, NOX("csg"), SDL_arraysize(filename) );
 719
 720         fp = cfopen(filename,"wb", CFILE_NORMAL, CF_TYPE_SINGLE_PLAYERS);
 721
 722         if (!fp)
 723                 return errno;
 724
 725         // Write out campaign file info
 726         cfwrite_int( CAMPAIGN_FILE_ID,fp );
 727         cfwrite_int( CAMPAIGN_FILE_VERSION,fp );
 728
 729         // put in the file signature (single or multiplayer campaign) - see MissionCampaign.h for the #defines
 730         cfwrite_int( CAMPAIGN_SINGLE_PLAYER_SIG, fp );
 731
 732         // do we need to write out the filename of the campaign?
 733         cfwrite_string_len( Campaign.filename, fp );
 734         cfwrite_int( Campaign.prev_mission, fp );
 735         cfwrite_int( Campaign.next_mission, fp );
 736         cfwrite_int( Campaign.loop_reentry, fp );
 737         cfwrite_int( Campaign.loop_enabled, fp );
 738
 739         // write out the information for ships/weapons which this player is allowed to use
 740         cfwrite_int(Num_ship_types, fp);
 741         cfwrite_int(Num_weapon_types, fp);
 742         for ( i = 0; i < Num_ship_types; i++ ){
 743                 cfwrite_char( Campaign.ships_allowed[i], fp );
 744         }
 745
 746         for ( i = 0; i < Num_weapon_types; i++ ){
 747                 cfwrite_char( Campaign.weapons_allowed[i], fp );
 748         }
 749
 750         // write out the completed mission matrix.  Used to tell which missions the player
 751         // can replay in the simulator.  Also, each completed mission contains a list of the goals
 752         // that were in the mission along with the goal completion status.
 753         cfwrite_int( Campaign.num_missions_completed, fp );
 754         for (i = 0; i < MAX_CAMPAIGN_MISSIONS; i++ ) {
 755                 if ( Campaign.missions[i].completed ) {
 756                         cfwrite_int( i, fp );
 757                         cfwrite_int( Campaign.missions[i].num_goals, fp );
 758                         for ( j = 0; j < Campaign.missions[i].num_goals; j++ ) {
 759                                 cfwrite_string_len( Campaign.missions[i].goals[j].name, fp );
 760                                 cfwrite_char( Campaign.missions[i].goals[j].status, fp );
 761                         }
 762                         cfwrite_int( Campaign.missions[i].num_events, fp );
 763                         for ( j = 0; j < Campaign.missions[i].num_events; j++ ) {
 764                                 cfwrite_string_len( Campaign.missions[i].events[j].name, fp );
 765                                 cfwrite_char( Campaign.missions[i].events[j].status, fp );
 766                         }
 767
 768                         // write flags
 769                         cfwrite_int(Campaign.missions[i].flags, fp);
 770                 }
 771         }
 772
 773         cfclose( fp );
 774
 775         // 6/17/98
 776         // ugh!  due to horrible bug, the stats saved at the end of every level were not written
 777         // out to disk.  Write out a seperate file to do this.  We will only read it in if we actually
 778         // find the file.
 779         memset(filename, 0, sizeof(filename));
 780         mission_campaign_savefile_generate_root(filename, SDL_arraysize(filename));
 781
 782         // name the file differently depending on whether we're in single player or multiplayer mode
 783         // single player : *.csg
 784         SDL_strlcat( filename, NOX("css"), SDL_arraysize(filename) );
 785
 786         fp = cfopen(filename,"wb", CFILE_NORMAL, CF_TYPE_SINGLE_PLAYERS);
 787
 788         if (!fp)
 789                 return errno;
 790
 791         // Write out campaign file info
 792         cfwrite_int( CAMPAIGN_STATS_FILE_ID,fp );
 793         cfwrite_int( CAMPAIGN_STATS_FILE_VERSION,fp );
 794
 795         // determine how many missions we are saving -- I think that this method is safer than the method
 796         // I used for release
 797         mission_count = 0;
 798         for ( i = 0; i < Campaign.num_missions; i++ ) {
 799                 if ( Campaign.missions[i].completed ) {
 800                         mission_count++;
 801                 }
 802         }
 803
 804         // write out the stats information to disk.
 805         cfwrite_int( mission_count, fp );
 806         for (i = 0; i < Campaign.num_missions; i++ ) {
 807                 if ( Campaign.missions[i].completed ) {
 808                         cfwrite_int( i, fp );
 809                         cfwrite( &Campaign.missions[i].stats, sizeof(scoring_struct), 1, fp );
 810                 }
 811         }
 812
 813         cfclose( fp );
 814
 815         return 0;
 816 }
 817
 818 // The following function always only ever ever ever called by CSFE!!!!!
 819 int campaign_savefile_save(const char *pname)
 820 {
 821         if (Campaign.type == CAMPAIGN_TYPE_SINGLE)
 822                 Game_mode &= ~GM_MULTIPLAYER;
 823         else
 824                 Game_mode |= GM_MULTIPLAYER;
 825
 826         SDL_strlcpy(Player->callsign, pname, SDL_arraysize(Player->callsign));
 827         //memcpy(&Campaign, camp, sizeof(campaign));
 828         return mission_campaign_savefile_save();
 829 }
 830
 831
 832 // the below two functions is internal to this module.  It is here so that I can group the save/load
 833 // functions together.
 834 //
 835
 836 // mission_campaign_savefile_delete deletes any save file in the players directory for the given
 837 // campaign filename
 838 void mission_campaign_savefile_delete( const char *cfilename, int is_multi )
 839 {
 840         char filename[MAX_PATH_LEN], base[MAX_FILENAME_LEN];
 841
 842         base_filename(cfilename, base, SDL_arraysize(base));
 843
 844         if ( Player->flags & PLAYER_FLAGS_IS_MULTI ) {
 845                 return; // no such thing as a multiplayer campaign savefile
 846         }
 847
 848         SDL_snprintf( filename, SDL_arraysize(filename), NOX("%s.%s.csg"), Player->callsign, base );
 849
 850         cf_delete( filename, CF_TYPE_SINGLE_PLAYERS );
 851 }
 852
 853 void campaign_delete_save( const char *cfn, const char *pname)
 854 {
 855         SDL_strlcpy(Player->callsign, pname, SDL_arraysize(Player->callsign));
 856         mission_campaign_savefile_delete(cfn);
 857 }
 858
 859 // next function deletes all the save files for this particular pilot.  Just call cfile function
 860 // which will delete multiple files
 861 // Player_select_mode tells us whether we are deleting single or multiplayer files
 862 void mission_campaign_delete_all_savefiles( const char *pilot_name, int is_multi )
 863 {
 864         int dir_type, num_files, i;
 865         char *names[MAX_CAMPAIGNS], spec[MAX_FILENAME_LEN + 2];
 866         const char *ext;
 867         char filename[1024];
 868         int (*filter_save)(const char *filename);
 869
 870         if ( is_multi ) {
 871                 return;                         // can't have multiplayer campaign save files
 872         }
 873
 874         ext = NOX(".csg");
 875         dir_type = CF_TYPE_SINGLE_PLAYERS;
 876
 877         SDL_snprintf(spec, SDL_arraysize(spec), NOX("%s.*%s"), pilot_name, ext);
 878
 879         // HACK HACK HACK HACK!!!!  cf_get_file_list is not reentrant.  Pretty dumb because it should
 880         // be.  I have to save any file filters
 881         filter_save = Get_file_list_filter;
 882         Get_file_list_filter = NULL;
 883         num_files = cf_get_file_list(MAX_CAMPAIGNS, names, dir_type, spec);
 884         Get_file_list_filter = filter_save;
 885
 886         for (i=0; i<num_files; i++) {
 887                 SDL_strlcpy(filename, names[i], SDL_arraysize(filename));
 888                 SDL_strlcat(filename, ext, SDL_arraysize(filename));
 889                 cf_delete(filename, dir_type);
 890                 free(names[i]);
 891         }
 892 }
 893
 894 // mission_campaign_savefile_load takes a filename of a campaign file as a parameter and loads all
 895 // of the information stored in the campaign file.
 896 void mission_campaign_savefile_load( const char *cfilename )
 897 {
 898         char filename[MAX_PATH_LEN], base[MAX_FILENAME_LEN];
 899         int version, i, num, j, num_stats_blocks;
 900         uint id, type_sig;
 901         CFILE *fp;
 902
 903         SDL_assert ( strlen(cfilename) != 0 );
 904
 905         // probably only called from single player games anymore!!! should be anyway
 906         SDL_assert( Game_mode & GM_NORMAL );            // get allender or DaveB.  trying to save campaign in multiplayer
 907
 908         // build up the filename for the save file.  There could be a problem with filename length,
 909         // but this problem can get fixed in several ways -- ignore the problem for now though.
 910         base_filename(cfilename, base, SDL_arraysize(base));
 911         SDL_assert ( (strlen(base) + strlen(Player->callsign)) < SDL_arraysize(filename) );
 912
 913         if(Game_mode & GM_MULTIPLAYER)
 914                 SDL_snprintf( filename, SDL_arraysize(filename), NOX("%s.%s.msg"), Player->callsign, base );
 915         else
 916                 SDL_snprintf( filename, SDL_arraysize(filename), NOX("%s.%s.csg"), Player->callsign, base );
 917
 918         fp = cfopen(filename, "rb", CFILE_NORMAL, CF_TYPE_SINGLE_PLAYERS );
 919         if ( !fp )
 920                 return;
 921
 922         id = cfread_int( fp );
 923         if ( id != CAMPAIGN_FILE_ID ) {
 924                 Warning(LOCATION, "Campaign save file has invalid signature");
 925                 cfclose( fp );
 926                 return;
 927         }
 928
 929         version = cfread_int( fp );
 930         if ( version < CAMPAIGN_FILE_COMPATIBLE_VERSION ) {
 931                 Warning(LOCATION, "Campaign save file too old -- not compatible.  Deleting file.\nYou can continue from here without trouble\n\n");
 932                 cfclose( fp );
 933                 cf_delete( filename, CF_TYPE_SINGLE_PLAYERS );
 934                 return;
 935         }
 936
 937         // verify that we are loading the correct type of campaign file for the mode that we are in.
 938         if(version >= 3)
 939                 type_sig = cfread_int( fp );
 940         else
 941                 type_sig = CAMPAIGN_SINGLE_PLAYER_SIG;
 942         // the actual check
 943         SDL_assert( ((Game_mode & GM_MULTIPLAYER) && (type_sig==CAMPAIGN_MULTI_PLAYER_SIG)) || (!(Game_mode & GM_MULTIPLAYER) && (type_sig==CAMPAIGN_SINGLE_PLAYER_SIG)) );
 944
 945         Campaign.type = type_sig == CAMPAIGN_SINGLE_PLAYER_SIG ? CAMPAIGN_TYPE_SINGLE : CAMPAIGN_TYPE_MULTI_COOP;
 946
 947         // read in the filename of the campaign and compare the filenames to be sure that
 948         // we are reading data that really belongs to this campaign.  I think that this check
 949         // is redundant.
 950         cfread_string_len( filename, SDL_arraysize(filename), fp );
 951         /*if ( SDL_strcasecmp( filename, cfilename) ) { //      Used to be !SDL_strcasecmp.  How did this ever work? --MK, 11/9/97
 952                 Warning(LOCATION, "Campaign save file appears corrupt because of mismatching filenames.");
 953                 cfclose(fp);
 954                 return;
 955         }*/
 956
 957         Campaign.prev_mission = cfread_int( fp );
 958         Campaign.next_mission = cfread_int( fp );
 959         Campaign.loop_reentry = cfread_int( fp );
 960         Campaign.loop_enabled = cfread_int( fp );
 961
 962         //  load information about ships/weapons allowed
 963         int ship_count, weapon_count;
 964
 965         // if earlier than mission disk version, use old MAX_SHIP_TYPES, otherwise read from the file
 966         if(version <= CAMPAIGN_INITIAL_RELEASE_FILE_VERSION){
 967                 ship_count = CAMPAIGN_SAVEFILE_MAX_SHIPS_OLD;
 968                 weapon_count = CAMPAIGN_SAVEFILE_MAX_WEAPONS_OLD;
 969         } else {
 970                 ship_count = cfread_int(fp);
 971                 weapon_count = cfread_int(fp);
 972         }
 973
 974         for ( i = 0; i < ship_count; i++ ){
 975                 Campaign.ships_allowed[i] = cfread_ubyte( fp );
 976         }
 977
 978         for ( i = 0; i < weapon_count; i++ ){
 979                 Campaign.weapons_allowed[i] = cfread_ubyte( fp );
 980         }
 981
 982         // read in the completed mission matrix.  Used to tell which missions the player
 983         // can replay in the simulator.  Also, each completed mission contains a list of the goals
 984         // that were in the mission along with the goal completion status.
 985         Campaign.num_missions_completed = cfread_int( fp );
 986         for (i = 0; i < Campaign.num_missions_completed; i++ ) {
 987                 num = cfread_int( fp );
 988                 Campaign.missions[num].completed = 1;
 989                 Campaign.missions[num].num_goals = cfread_int( fp );
 990
 991                 // be sure to malloc out space for the goals stuff, then zero the memory!!!  Don't do malloc
 992                 // if there are no goals
 993                 Campaign.missions[num].goals = (mgoal *)malloc( Campaign.missions[num].num_goals * sizeof(mgoal) );
 994                 if ( Campaign.missions[num].num_goals > 0 ) {
 995                         memset( Campaign.missions[num].goals, 0, sizeof(mgoal) * Campaign.missions[num].num_goals );
 996                         SDL_assert( Campaign.missions[num].goals != NULL );
 997                 }
 998
 999                 // now read in the goal information for this mission
1000                 for ( j = 0; j < Campaign.missions[num].num_goals; j++ ) {
1001                         cfread_string_len( Campaign.missions[num].goals[j].name, NAME_LENGTH, fp );
1002                         Campaign.missions[num].goals[j].status = cfread_char( fp );
1003                 }
1004
1005                 // get the events from the savefile
1006                 Campaign.missions[num].num_events = cfread_int( fp );
1007
1008                 // be sure to malloc out space for the events stuff, then zero the memory!!!  Don't do malloc
1009                 // if there are no events
1010 //              if (Campaign.missions[num].events < 0)
1011 //                      Campaign.missions[num].events = 0;
1012                 Campaign.missions[num].events = (mevent *)malloc( Campaign.missions[num].num_events * sizeof(mevent) );
1013                 if ( Campaign.missions[num].num_events > 0 ) {
1014                         memset( Campaign.missions[num].events, 0, sizeof(mevent) * Campaign.missions[num].num_events );
1015                         SDL_assert( Campaign.missions[num].events != NULL );
1016                 }
1017
1018                 // now read in the event information for this mission
1019                 for ( j = 0; j < Campaign.missions[num].num_events; j++ ) {
1020                         cfread_string_len( Campaign.missions[num].events[j].name, NAME_LENGTH, fp );
1021                         Campaign.missions[num].events[j].status = cfread_char( fp );
1022                 }
1023
1024                 // now read flags
1025                 Campaign.missions[num].flags = cfread_int(fp);
1026         }
1027
1028         cfclose( fp );
1029
1030         // 4/17/98
1031         // now, try and read in the campaign stats saved information.  This code was added for the 1.03 patch
1032         // since the stats data was never written out to disk.  We try and open the file, and if we cannot find
1033         // it, then simply return
1034         SDL_snprintf( filename, SDL_arraysize(filename), NOX("%s.%s.css"), Player->callsign, base );
1035
1036         fp = cfopen(filename, "rb", CFILE_NORMAL, CF_TYPE_SINGLE_PLAYERS );
1037         if ( !fp )
1038                 return;
1039
1040         id = cfread_int( fp );
1041         if ( id != CAMPAIGN_STATS_FILE_ID ) {
1042                 Warning(LOCATION, "Campaign stats save file has invalid signature");
1043                 cfclose( fp );
1044                 return;
1045         }
1046
1047         version = cfread_int( fp );
1048         if ( version < CAMPAIGN_STATS_FILE_COMPATIBLE_VERSION ) {
1049                 Warning(LOCATION, "Campaign save file too old -- not compatible.  Deleting file.\nYou can continue from here without trouble\n\n");
1050                 cfclose( fp );
1051                 cf_delete( filename, CF_TYPE_SINGLE_PLAYERS );
1052                 return;
1053         }
1054
1055         num_stats_blocks = cfread_int( fp );
1056         for (i = 0; i < num_stats_blocks; i++ ) {
1057                 num = cfread_int( fp );
1058                 cfread( &Campaign.missions[num].stats, sizeof(scoring_struct), 1, fp );
1059         }
1060
1061         cfclose(fp);
1062 }
1063
1064 // the following code only ever called by CSFE!!!!
1065 void campaign_savefile_load(const char *fname, const char *pname)
1066 {
1067         if (Campaign.type==CAMPAIGN_TYPE_SINGLE) {
1068                 Game_mode &= ~GM_MULTIPLAYER;
1069                 Game_mode &= GM_NORMAL;
1070         }
1071         else
1072                 Game_mode |= GM_MULTIPLAYER;
1073         SDL_strlcpy(Player->callsign, pname, SDL_arraysize(Player->callsign));
1074         mission_campaign_savefile_load(fname);
1075 }
1076
1077 // mission_campaign_next_mission sets up the internal veriables of the campaign
1078 // structure so the player can play the next mission.  If there are no more missions
1079 // available in the campaign, this function returns -1, else 0 if the mission was
1080 // set successfully
1081 int mission_campaign_next_mission()
1082 {
1083         if ( (Campaign.next_mission == -1) || (strlen(Campaign.name) == 0) ) // will be set to -1 when there is no next mission
1084                 return -1;
1085
1086         Campaign.current_mission = Campaign.next_mission;
1087         SDL_strlcpy( Game_current_mission_filename, Campaign.missions[Campaign.current_mission].name, MAX_FILENAME_LEN );
1088
1089         // check for end of loop.
1090         if (Campaign.current_mission == Campaign.loop_reentry) {
1091                 Campaign.loop_enabled = 0;
1092         }
1093
1094         // reset the number of persistent ships and weapons for the next campaign mission
1095         Num_granted_ships = 0;
1096         Num_granted_weapons = 0;
1097         return 0;
1098 }
1099
1100 // mission_campaign_previous_mission() gets called to go to the previous mission in
1101 // the campaign.  Used only for Red Alert missions
1102 int mission_campaign_previous_mission()
1103 {
1104         if ( !(Game_mode & GM_CAMPAIGN_MODE) )
1105                 return 0;
1106
1107         if ( Campaign.prev_mission == -1 )
1108                 return 0;
1109
1110         Campaign.current_mission = Campaign.prev_mission;
1111         Campaign.next_mission = Campaign.current_mission;
1112         Campaign.num_missions_completed--;
1113         Campaign.missions[Campaign.next_mission].completed = 0;
1114         mission_campaign_savefile_save();
1115
1116         // reset the player stats to be the stats from this level
1117         memcpy( &Player->stats, &Campaign.missions[Campaign.current_mission].stats, sizeof(Player->stats) );
1118
1119         SDL_strlcpy( Game_current_mission_filename, Campaign.missions[Campaign.current_mission].name, MAX_FILENAME_LEN );
1120         Num_granted_ships = 0;
1121         Num_granted_weapons = 0;
1122
1123         return 1;
1124 }
1125
1126 /*
1127 // determine what the next mission is after the current one.  Because this evaluates an sexp,
1128 // and that could check just about anything, the results are only going to be valid in
1129 // certain places.
1130 // DA 12/09/98 -- To allow for mission loops, need to maintain call with store stats
1131 int mission_campaign_eval_next_mission( int store_stats )
1132 {
1133         char *name;
1134         int cur, i;
1135         cmission *mission;
1136
1137         Campaign.next_mission = -1;
1138         cur = Campaign.current_mission;
1139         name = Campaign.missions[cur].name;
1140
1141         mission = &Campaign.missions[cur];
1142
1143         // first we must save the status of the current missions goals in the campaign mission structure.
1144         // After that, we can determine which mission is tagged as the next mission.  Finally, we
1145         // can save the campaign save file
1146         // we might have goal and event status if the player replayed a mission
1147         if ( mission->num_goals > 0 ) {
1148                 free( mission->goals );
1149         }
1150
1151         mission->num_goals = Num_goals;
1152         if ( mission->num_goals > 0 ) {
1153                 mission->goals = (mgoal *)malloc( sizeof(mgoal) * Num_goals );
1154                 SDL_assert( mission->goals != NULL );
1155         }
1156
1157         // copy the needed info from the Mission_goal struct to our internal structure
1158         for (i = 0; i < Num_goals; i++ ) {
1159                 if ( strlen(Mission_goals[i].name) == 0 ) {
1160                         char name[NAME_LENGTH];
1161
1162                         sprintf(name, NOX("Goal #%d"), i);
1163                         //Warning(LOCATION, "Mission goal in mission %s must have a +Name field! using %s for campaign save file\n", mission->name, name);
1164                         strcpy( mission->goals[i].name, name);
1165                 } else
1166                         strcpy( mission->goals[i].name, Mission_goals[i].name );
1167                 SDL_assert ( Mission_goals[i].satisfied != GOAL_INCOMPLETE );           // should be true or false at this point!!!
1168                 mission->goals[i].status = (char)Mission_goals[i].satisfied;
1169         }
1170
1171         // do the same thing for events as we did for goals
1172         // we might have goal and event status if the player replayed a mission
1173         if ( mission->num_events > 0 ) {
1174                 free( mission->events );
1175         }
1176
1177         mission->num_events = Num_mission_events;
1178         if ( mission->num_events > 0 ) {
1179                 mission->events = (mevent *)malloc( sizeof(mevent) * Num_mission_events );
1180                 SDL_assert( mission->events != NULL );
1181         }
1182
1183         // copy the needed info from the Mission_goal struct to our internal structure
1184         for (i = 0; i < Num_mission_events; i++ ) {
1185                 if ( strlen(Mission_events[i].name) == 0 ) {
1186                         char name[NAME_LENGTH];
1187
1188                         sprintf(name, NOX("Event #%d"), i);
1189                         nprintf(("Warning", "Mission goal in mission %s must have a +Name field! using %s for campaign save file\n", mission->name, name));
1190                         strcpy( mission->events[i].name, name);
1191                 } else
1192                         strcpy( mission->events[i].name, Mission_events[i].name );
1193
1194                 // getting status for the events is a little different.  If the formula value for the event entry
1195                 // is -1, then we know the value of the result field will never change.  If the formula is
1196                 // not -1 (i.e. still being evaluated at mission end time), we will write "incomplete" for the
1197                 // event evaluation
1198                 if ( Mission_events[i].formula == -1 ) {
1199                         if ( Mission_events[i].result )
1200                                 mission->events[i].status = EVENT_SATISFIED;
1201                         else
1202                                 mission->events[i].status = EVENT_FAILED;
1203                 } else
1204                         Int3();
1205         }
1206
1207         // maybe store the alltime stats which would be current at the end of this mission
1208         if ( store_stats ) {
1209                 memcpy( &mission->stats, &Player->stats, sizeof(Player->stats) );
1210                 scoring_backout_accept( &mission->stats );
1211         }
1212
1213         if ( store_stats ) {    // second (last) time through, so use choose loop_mission if chosen
1214                 if ( Campaign.loop_enabled ) {
1215                         Campaign.next_mission = Campaign.loop_mission;
1216                 } else {
1217                         // evaluate next mission (straight path)
1218                         if (Campaign.missions[cur].formula != -1) {
1219                                 flush_sexp_tree(Campaign.missions[cur].formula);  // force formula to be re-evaluated
1220                                 eval_sexp(Campaign.missions[cur].formula);  // this should reset Campaign.next_mission to proper value
1221                         }
1222                 }
1223         } else {
1224
1225                 // evaluate next mission (straight path)
1226                 if (Campaign.missions[cur].formula != -1) {
1227                         flush_sexp_tree(Campaign.missions[cur].formula);  // force formula to be re-evaluated
1228                         eval_sexp(Campaign.missions[cur].formula);  // this should reset Campaign.next_mission to proper value
1229                 }
1230
1231                 // evaluate mission loop mission (if any) so it can be used if chosen
1232                 if ( Campaign.missions[cur].has_mission_loop ) {
1233                         int copy_next_mission = Campaign.next_mission;
1234                         // Set temporarily to -1 so we know if loop formula fails to assign
1235                         Campaign.next_mission = -1;  // Cannot exit campaign from loop
1236                         if (Campaign.missions[cur].mission_loop_formula != -1) {
1237                                 flush_sexp_tree(Campaign.missions[cur].mission_loop_formula);  // force formula to be re-evaluated
1238                                 eval_sexp(Campaign.missions[cur].mission_loop_formula);  // this should reset Campaign.next_mission to proper value
1239                         }
1240
1241                         Campaign.loop_mission = Campaign.next_mission;
1242                         Campaign.next_mission = copy_next_mission;
1243                 }
1244         }
1245
1246         if (Campaign.next_mission == -1)
1247                 nprintf(("allender", "No next mission to proceed to.\n"));
1248         else
1249                 nprintf(("allender", "Next mission is number %d [%s]\n", Campaign.next_mission, Campaign.missions[Campaign.next_mission].name));
1250
1251         return Campaign.next_mission;
1252 } */
1253
1254 // Evaluate next campaign mission - set as Campaign.next_mission.  Also set Campaign.loop_mission
1255 void mission_campaign_eval_next_mission()
1256 {
1257         Campaign.next_mission = -1;
1258         int cur = Campaign.current_mission;
1259
1260         // evaluate next mission (straight path)
1261         if (Campaign.missions[cur].formula != -1) {
1262                 flush_sexp_tree(Campaign.missions[cur].formula);  // force formula to be re-evaluated
1263                 eval_sexp(Campaign.missions[cur].formula);  // this should reset Campaign.next_mission to proper value
1264         }
1265
1266         // evaluate mission loop mission (if any) so it can be used if chosen
1267         if ( Campaign.missions[cur].has_mission_loop ) {
1268                 int copy_next_mission = Campaign.next_mission;
1269                 // Set temporarily to -1 so we know if loop formula fails to assign
1270                 Campaign.next_mission = -1;
1271                 if (Campaign.missions[cur].mission_loop_formula != -1) {
1272                         flush_sexp_tree(Campaign.missions[cur].mission_loop_formula);  // force formula to be re-evaluated
1273                         eval_sexp(Campaign.missions[cur].mission_loop_formula);  // this should reset Campaign.next_mission to proper value
1274                 }
1275
1276                 Campaign.loop_mission = Campaign.next_mission;
1277                 Campaign.next_mission = copy_next_mission;
1278         }
1279
1280         if (Campaign.next_mission == -1) {
1281                 nprintf(("allender", "No next mission to proceed to.\n"));
1282         } else {
1283                 nprintf(("allender", "Next mission is number %d [%s]\n", Campaign.next_mission, Campaign.missions[Campaign.next_mission].name));
1284         }
1285
1286 }
1287
1288 // Store mission's goals and events in Campaign struct
1289 void mission_campaign_store_goals_and_events()
1290 {
1291         int cur, i;
1292         cmission *mission;
1293
1294         cur = Campaign.current_mission;
1295
1296         mission = &Campaign.missions[cur];
1297
1298         // first we must save the status of the current missions goals in the campaign mission structure.
1299         // After that, we can determine which mission is tagged as the next mission.  Finally, we
1300         // can save the campaign save file
1301         // we might have goal and event status if the player replayed a mission
1302         if ( mission->num_goals > 0 ) {
1303                 free( mission->goals );
1304         }
1305
1306         mission->num_goals = Num_goals;
1307         if ( mission->num_goals > 0 ) {
1308                 mission->goals = (mgoal *)malloc( sizeof(mgoal) * Num_goals );
1309                 SDL_assert( mission->goals != NULL );
1310         }
1311
1312         // copy the needed info from the Mission_goal struct to our internal structure
1313         for (i = 0; i < Num_goals; i++ ) {
1314                 if ( strlen(Mission_goals[i].name) == 0 ) {
1315                         char name[NAME_LENGTH];
1316
1317                         SDL_snprintf(name, SDL_arraysize(name), NOX("Goal #%d"), i);
1318                         //Warning(LOCATION, "Mission goal in mission %s must have a +Name field! using %s for campaign save file\n", mission->name, name);
1319                         SDL_strlcpy( mission->goals[i].name, name, SDL_arraysize(mission->goals[0].name));
1320                 } else
1321                         SDL_strlcpy( mission->goals[i].name, Mission_goals[i].name, SDL_arraysize(mission->goals[0].name) );
1322                 SDL_assert ( Mission_goals[i].satisfied != GOAL_INCOMPLETE );           // should be true or false at this point!!!
1323                 mission->goals[i].status = (char)Mission_goals[i].satisfied;
1324         }
1325
1326         // do the same thing for events as we did for goals
1327         // we might have goal and event status if the player replayed a mission
1328         if ( mission->num_events > 0 ) {
1329                 free( mission->events );
1330         }
1331
1332         mission->num_events = Num_mission_events;
1333         if ( mission->num_events > 0 ) {
1334                 mission->events = (mevent *)malloc( sizeof(mevent) * Num_mission_events );
1335                 SDL_assert( mission->events != NULL );
1336         }
1337
1338         // copy the needed info from the Mission_goal struct to our internal structure
1339         for (i = 0; i < Num_mission_events; i++ ) {
1340                 if ( strlen(Mission_events[i].name) == 0 ) {
1341                         char name[NAME_LENGTH];
1342
1343                         SDL_snprintf(name, SDL_arraysize(name), NOX("Event #%d"), i);
1344                         nprintf(("Warning", "Mission goal in mission %s must have a +Name field! using %s for campaign save file\n", mission->name, name));
1345                         SDL_strlcpy( mission->events[i].name, name, SDL_arraysize(mission->events[0].name));
1346                 } else
1347                         SDL_strlcpy( mission->events[i].name, Mission_events[i].name, SDL_arraysize(mission->events[0].name) );
1348
1349                 // getting status for the events is a little different.  If the formula value for the event entry
1350                 // is -1, then we know the value of the result field will never change.  If the formula is
1351                 // not -1 (i.e. still being evaluated at mission end time), we will write "incomplete" for the
1352                 // event evaluation
1353                 if ( Mission_events[i].formula == -1 ) {
1354                         if ( Mission_events[i].result )
1355                                 mission->events[i].status = EVENT_SATISFIED;
1356                         else
1357                                 mission->events[i].status = EVENT_FAILED;
1358                 } else
1359                         Int3();
1360         }
1361 }
1362
1363 // this function is called when the player's mission is over.  It updates the internal store of goals
1364 // and their status then saves the state of the campaign in the campaign file.  This gets called
1365 // after player accepts mission results in debriefing.
1366 void mission_campaign_mission_over()
1367 {
1368         int mission_num, i;
1369         cmission *mission;
1370
1371         // I don't think that we should have a record for these -- maybe we might??????  If we do,
1372         // then we should free them
1373         if ( !(Game_mode & GM_CAMPAIGN_MODE) ){
1374                 return;
1375         }
1376
1377         mission_num = Campaign.current_mission;
1378         SDL_assert( mission_num != -1 );
1379         mission = &Campaign.missions[mission_num];
1380
1381         // determine if any ships/weapons were granted this mission
1382         for ( i=0; i<Num_granted_ships; i++ ){
1383                 Campaign.ships_allowed[Granted_ships[i]] = 1;
1384         }
1385
1386         for ( i=0; i<Num_granted_weapons; i++ ){
1387                 Campaign.weapons_allowed[Granted_weapons[i]] = 1;
1388         }
1389
1390         // DKA 12/11/98 - Unneeded already evaluated and stored
1391         // determine what new mission we are moving to.
1392         //      mission_campaign_eval_next_mission(1);
1393
1394         // update campaign.mission stats (used to allow backout inRedAlert)
1395         memcpy( &mission->stats, &Player->stats, sizeof(Player->stats) );
1396         if(!(Game_mode & GM_MULTIPLAYER)){
1397                 scoring_backout_accept( &mission->stats );
1398         }
1399
1400         // if we are moving to a new mission, then change our data.  If we are staying on the same mission,
1401         // then we don't want to do anything.  Remove information about goals/events
1402         if ( Campaign.next_mission != mission_num ) {
1403                 Campaign.prev_mission = mission_num;
1404                 Campaign.current_mission = -1;
1405                 Campaign.num_missions_completed++;
1406                 Campaign.missions[mission_num].completed = 1;
1407
1408                 // save the scoring values from the previous mission at the start of this mission -- for red alert
1409
1410                 // save the state of the campaign in the campaign save file and move to the end_game state
1411                 if (Campaign.type == CAMPAIGN_TYPE_SINGLE) {
1412                         mission_campaign_savefile_save();
1413                 }
1414
1415         } else {
1416                 // free up the goals and events which were just malloced.  It's kind of like erasing any fact
1417                 // that the player played this mission in the campaign.
1418                 free( mission->goals );
1419                 mission->num_goals = 0;
1420
1421                 free( mission->events );
1422                 mission->num_events = 0;
1423
1424                 Sexp_nodes[mission->formula].value = SEXP_UNKNOWN;
1425         }
1426
1427         SDL_assert(Player);
1428         if (Campaign.missions[Campaign.next_mission].flags & CMISSION_FLAG_BASTION){
1429                 Player->on_bastion = 1;
1430         } else {
1431                 Player->on_bastion = 0;
1432         }
1433
1434         mission_campaign_next_mission();                        // sets up whatever needs to be set to actually play next mission
1435 }
1436
1437 // called when the game closes -- to get rid of memory errors for Bounds checker
1438 void mission_campaign_close()
1439 {
1440         int i;
1441
1442         if (Campaign.desc)
1443                 free(Campaign.desc);
1444
1445         // be sure to remove all old malloced strings of Mission_names
1446         // we must also free any goal stuff that was from a previous campaign
1447         for ( i=0; i<Campaign.num_missions; i++ ) {
1448                 if ( Campaign.missions[i].name ){
1449                         free(Campaign.missions[i].name);
1450                 }
1451
1452                 if (Campaign.missions[i].notes){
1453                         free(Campaign.missions[i].notes);
1454                 }
1455
1456                 if ( Campaign.missions[i].num_goals > 0 ){
1457                         free ( Campaign.missions[i].goals );
1458                 }
1459
1460                 if ( Campaign.missions[i].num_events > 0 ){
1461                         free ( Campaign.missions[i].events );
1462                 }
1463
1464                 // the next three are strdup'd return values from parselo.cpp
1465                 if (Campaign.missions[i].mission_loop_desc) {
1466                         free(Campaign.missions[i].mission_loop_desc);
1467                 }
1468
1469                 if (Campaign.missions[i].mission_loop_brief_anim) {
1470                         free(Campaign.missions[i].mission_loop_brief_anim);
1471                 }
1472
1473                 if (Campaign.missions[i].mission_loop_brief_sound) {
1474                         free(Campaign.missions[i].mission_loop_brief_sound);
1475                 }
1476
1477                 if ( !Fred_running ){
1478                         sexp_unmark_persistent(Campaign.missions[i].formula);           // free any sexpression nodes used by campaign.
1479                 }
1480
1481                 Campaign.missions[i].num_goals = 0;
1482                 Campaign.missions[i].num_events = 0;
1483         }
1484 }
1485
1486 // call from game_shutdown() ONLY!!!
1487 void mission_campaign_shutdown()
1488 {
1489         int i;
1490
1491         for (i=0; i<MAX_CAMPAIGNS; i++) {
1492                 if (Campaign_names[i] != NULL) {
1493                         free(Campaign_names[i]);
1494                         Campaign_names[i] = NULL;
1495                 }
1496
1497                 if (Campaign_file_names[i] != NULL) {
1498                         free(Campaign_file_names[i]);
1499                         Campaign_file_names[i] = NULL;
1500                 }
1501         }
1502 }
1503
1504 // extract the mission filenames for a campaign.
1505 //
1506 // filename     =>      name of campaign file
1507 //      dest            => storage for the mission filename, must be already allocated
1508 // num          => output parameter for the number of mission filenames in the campaign
1509 //
1510 // note that dest should allocate at least dest[MAX_CAMPAIGN_MISSIONS][NAME_LENGTH]
1511 int mission_campaign_get_filenames(const char *filename, char dest[][NAME_LENGTH], int *num)
1512 {
1513         // read the mission file and get the list of mission filenames
1514         try {
1515                 read_file_text(filename);
1516                 SDL_assert(strlen(filename) < MAX_FILENAME_LEN - 1);  // make sure no overflow
1517
1518                 reset_parse();
1519                 required_string("$Name:");
1520                 advance_to_eoln(NULL);
1521
1522                 required_string( "$Type:" );
1523                 advance_to_eoln(NULL);
1524
1525                 // parse the mission file and actually read in the mission stuff
1526                 *num = 0;
1527                 while ( skip_to_string("$Mission:") == 1 ) {
1528                         stuff_string(dest[*num], F_NAME, NULL);
1529                         (*num)++;
1530                 }
1531         } catch (parse_error_t rval) {
1532                 return (int)rval;
1533         }
1534
1535         return 0;
1536 }
1537
1538 // function to read the goals and events from a mission in a campaign file and store that information
1539 // in the campaign structure for use in the campaign editor, error checking, etc
1540 void read_mission_goal_list(int num)
1541 {
1542         char *filename, notes[NOTES_LENGTH], goals[MAX_GOALS][NAME_LENGTH];
1543         char events[MAX_MISSION_EVENTS][NAME_LENGTH];
1544         int i, z, event_count, count = 0;
1545
1546         filename = Campaign.missions[num].name;
1547
1548         // open localization
1549         lcl_ext_open();
1550
1551         // default counts to zero
1552         event_count = 0;
1553         count = 0;
1554
1555         try {
1556                 read_file_text(filename);
1557                 init_parse();
1558
1559                 // first, read the mission notes for this mission.  Used in campaign editor
1560                 if (skip_to_string("#Mission Info")) {
1561                         if (skip_to_string("$Notes:")) {
1562                                 stuff_string(notes, F_NOTES, NULL);
1563                                 if (Campaign.missions[num].notes){
1564                                         free(Campaign.missions[num].notes);
1565                                 }
1566
1567                                 Campaign.missions[num].notes = (char *) malloc(strlen(notes) + 1);
1568                                 SDL_strlcpy(Campaign.missions[num].notes, notes, strlen(notes) + 1);
1569                         }
1570                 }
1571
1572                 // skip to events section in the mission file.  Events come before goals, so we process them first
1573                 if ( skip_to_string("#Events") ) {
1574                         while (1) {
1575                                 if (skip_to_string("$Formula:", "#Goals") != 1){
1576                                         break;
1577                                 }
1578
1579                                 z = skip_to_string("+Name:", "$Formula:");
1580                                 if (!z){
1581                                         break;
1582                                 }
1583
1584                                 if (z == 1){
1585                                         stuff_string(events[event_count], F_NAME, NULL);
1586                                 } else {
1587                                         SDL_snprintf(events[event_count], NAME_LENGTH, NOX("Event #%d"), event_count + 1);
1588                                 }
1589
1590                                 event_count++;
1591                                 SDL_assert(event_count < MAX_MISSION_EVENTS);
1592                         }
1593                 }
1594
1595                 if (skip_to_string("#Goals")) {
1596                         while (1) {
1597                                 if (skip_to_string("$Type:", "#End") != 1){
1598                                         break;
1599                                 }
1600
1601                                 z = skip_to_string("+Name:", "$Type:");
1602                                 if (!z){
1603                                         break;
1604                                 }
1605
1606                                 if (z == 1){
1607                                         stuff_string(goals[count], F_NAME, NULL);
1608                                 } else {
1609                                         SDL_snprintf(goals[count], NAME_LENGTH, NOX("Goal #%d"), count + 1);
1610                                 }
1611
1612                                 count++;
1613                                 SDL_assert(count < MAX_GOALS);
1614                         }
1615                 }
1616         } catch (parse_error_t rval) {
1617                 Warning(LOCATION, "Error reading \"%s\" (code = %d)", filename, (int)rval);
1618         }
1619
1620         Campaign.missions[num].num_goals = count;
1621         if (count) {
1622                 Campaign.missions[num].goals = (mgoal *) malloc(count * sizeof(mgoal));
1623                 SDL_assert(Campaign.missions[num].goals);  // make sure we got the memory
1624                 memset(Campaign.missions[num].goals, 0, count * sizeof(mgoal));
1625
1626                 for (i=0; i<count; i++){
1627                         SDL_strlcpy(Campaign.missions[num].goals[i].name, goals[i], SDL_arraysize(Campaign.missions[num].goals[i].name));
1628                 }
1629         }
1630                 // copy the events
1631         Campaign.missions[num].num_events = event_count;
1632         if (event_count) {
1633                 Campaign.missions[num].events = (mevent *)malloc(event_count * sizeof(mevent));
1634                 SDL_assert ( Campaign.missions[num].events );
1635                 memset(Campaign.missions[num].events, 0, event_count * sizeof(mevent));
1636
1637                 for (i = 0; i < event_count; i++ ){
1638                         SDL_strlcpy(Campaign.missions[num].events[i].name, events[i], SDL_arraysize(Campaign.missions[num].events[i].name));
1639                 }
1640         }
1641
1642         // close localization
1643         lcl_ext_close();
1644 }
1645
1646 // function to return index into Campaign's list of missions of the mission with the given
1647 // filename.  This function tried to be a little smart about filename looking for the .fsm
1648 // extension since filenames are stored with the extension in the campaign file.  Returns
1649 // index of mission in campaign structure.  -1 if mission name not found.
1650 int mission_campaign_find_mission( const char *name )
1651 {
1652         int i;
1653         char realname[MAX_FILENAME_LEN];
1654
1655         // look for an extension on the file.  If no extension, add default ".fsm" onto the
1656         // end of the filename
1657         if ( SDL_strchr(name, '.') == NULL ){
1658                 SDL_snprintf(realname, SDL_arraysize(realname), NOX("%s%s"), name, FS_MISSION_FILE_EXT );
1659         } else {
1660                 SDL_strlcpy(realname, name, SDL_arraysize(realname));
1661         }
1662
1663         for (i = 0; i < Campaign.num_missions; i++ ) {
1664                 if ( !SDL_strcasecmp(realname, Campaign.missions[i].name) ){
1665                         return i;
1666                 }
1667         }
1668
1669         return -1;
1670 }
1671
1672 void mission_campaign_maybe_play_movie(int type)
1673 {
1674         int mission;
1675         char *filename;
1676
1677         // only support pre mission movies for now.
1678         SDL_assert ( type == CAMPAIGN_MOVIE_PRE_MISSION );
1679
1680         if ( !(Game_mode & GM_CAMPAIGN_MODE) )
1681                 return;
1682
1683         mission = Campaign.current_mission;
1684         SDL_assert( mission != -1 );
1685
1686         // get a possible filename for a movie to play.
1687         filename = NULL;
1688         switch( type ) {
1689         case CAMPAIGN_MOVIE_PRE_MISSION:
1690                 if ( strlen(Campaign.missions[mission].briefing_cutscene) )
1691                         filename = Campaign.missions[mission].briefing_cutscene;
1692                 break;
1693
1694         default:
1695                 Int3();
1696                 break;
1697         }
1698
1699         // no filename, no movie!
1700         if ( !filename )
1701                 return;
1702
1703         movie_play( filename );
1704 }
1705
1706 // return nonzero if the passed filename is a multiplayer campaign, 0 otherwise
1707 int mission_campaign_parse_is_multi(const char *filename, char *name, const int max_len)
1708 {
1709         int i;
1710         char temp[50];
1711
1712         try {
1713                 read_file_text( filename );
1714                 reset_parse();
1715
1716                 required_string("$Name:");
1717                 stuff_string( temp, F_NAME, NULL );
1718                 if ( name )
1719                         SDL_strlcpy( name, temp, max_len );
1720
1721                 required_string( "$Type:" );
1722                 stuff_string( temp, F_NAME, NULL );
1723
1724                 for (i = 0; i < MAX_CAMPAIGN_TYPES; i++ ) {
1725                         if ( !SDL_strcasecmp(temp, campaign_types[i]) ) {
1726                                 return i;
1727                         }
1728                 }
1729         } catch (parse_error_t rval) {
1730                 Error(LOCATION, "Unable to parse %s!  Code = %i.\n", filename, (int)rval);
1731         }
1732
1733         Error(LOCATION, "Unknown campaign type %s", temp );
1734         return -1;
1735 }
1736
1737 // functions to save persistent information during a mission -- which then might or might not get
1738 // saved out when the mission is over depending on whether player replays mission or commits.
1739 void mission_campaign_save_persistent( int type, int sindex )
1740 {
1741         // based on the type of information, save it off for possible saving into the campsign
1742         // savefile when the mission is over
1743         if ( type == CAMPAIGN_PERSISTENT_SHIP ) {
1744                 SDL_assert( Num_granted_ships < MAX_SHIP_TYPES );
1745                 Granted_ships[Num_granted_ships] = sindex;
1746                 Num_granted_ships++;
1747         } else if ( type == CAMPAIGN_PERSISTENT_WEAPON ) {
1748                 SDL_assert( Num_granted_weapons < MAX_WEAPON_TYPES );
1749                 Granted_weapons[Num_granted_weapons] = sindex;
1750                 Num_granted_weapons++;
1751         } else
1752                 Int3();
1753 }
1754
1755 // returns 0: loaded, !0: error
1756 int mission_load_up_campaign()
1757 {
1758         if (strlen(Player->current_campaign))
1759                 return mission_campaign_load(Player->current_campaign);
1760         else
1761                 return mission_campaign_load(BUILTIN_CAMPAIGN);
1762 }
1763
1764 // for end of campaign in the single player game.  Called when the end of campaign state is
1765 // entered, which is triggered when the end-campaign sexpression is hit
1766
1767 void mission_campaign_end_init()
1768 {
1769         // no need to do any initialization.
1770 }
1771
1772 void mission_campaign_end_do()
1773 {
1774         // play the movies
1775         event_music_level_close();
1776         mission_goal_fail_incomplete();
1777         scoring_level_close();
1778         mission_campaign_mission_over();
1779
1780 #ifdef MAKE_FS1
1781         movie_play("endgame.mve");
1782 #else
1783         // eventually we'll want to play one of two options (good ending or bad ending)
1784         // did the supernova blow?
1785         if(Supernova_status == SUPERNOVA_HIT){
1786                 movie_play_two("endpart1.mve", "endprt2b.mve");                 // good ending
1787         } else {
1788                 movie_play_two("endpart1.mve", "endprt2a.mve");                 // good ending
1789         }
1790 #endif
1791
1792 #if defined(FS2_DEMO) || defined(FS1_DEMO)
1793         gameseq_post_event( GS_EVENT_END_DEMO );
1794 #elif defined(MAKE_FS1)
1795         gameseq_post_event( GS_STATE_END_OF_CAMPAIGN );
1796 #else
1797         gameseq_post_event( GS_EVENT_MAIN_MENU );
1798 #endif
1799 }
1800
1801 void mission_campaign_end_close()
1802 {
1803         // nothing to do here.
1804 }
1805
1806
1807 // skip to the next mission in the campaign
1808 // this also posts the state change by default.  pass 0 to override that
1809 void mission_campaign_skip_to_next(int start_game)
1810 {
1811         // mark all goals/events complete
1812         // these do not really matter, since is-previous-event-* and is-previous-goal-* sexps check
1813         // to see if the mission was skipped, and use defaults accordingly.
1814         mission_goal_mark_objectives_complete();
1815         mission_goal_mark_events_complete();
1816
1817         // mark mission as skipped
1818         Campaign.missions[Campaign.current_mission].flags |= CMISSION_FLAG_SKIPPED;
1819
1820         // store
1821         mission_campaign_store_goals_and_events();
1822
1823         // now set the next mission
1824         mission_campaign_eval_next_mission();
1825
1826         // clear out relevant player vars
1827         Player->failures_this_session = 0;
1828         Player->show_skip_popup = 1;
1829
1830         if (start_game) {
1831                 // proceed to next mission or main hall
1832                 if ((Campaign.missions[Campaign.current_mission].has_mission_loop) && (Campaign.loop_mission != -1)) {
1833                         // go to loop solicitation
1834                         gameseq_post_event(GS_EVENT_LOOP_BRIEF);
1835                 } else {
1836                         // closes out mission stuff, sets up next one
1837                         mission_campaign_mission_over();
1838
1839                         if ( Campaign.next_mission == -1 ) {
1840                                 // go to main hall, tha campaign is over!
1841                                 gameseq_post_event(GS_EVENT_MAIN_MENU);
1842                         } else {
1843                                 // go to next mission
1844                                 gameseq_post_event(GS_EVENT_START_GAME);
1845                         }
1846                 }
1847         }
1848 }
1849
1850
1851 // breaks your ass out of the loop
1852 // this also posts the state change
1853 void mission_campaign_exit_loop()
1854 {
1855         // set campaign to loop reentry point
1856         Campaign.next_mission = Campaign.loop_reentry;
1857         Campaign.current_mission = -1;
1858         Campaign.loop_enabled = 0;
1859
1860         // set things up for next mission
1861         mission_campaign_next_mission();
1862         gameseq_post_event(GS_EVENT_START_GAME);
1863 }
1864
1865
1866 // used for jumping to a particular campaign mission
1867 // all pvs missions marked skipped
1868 // this relies on correct mission ordering in the campaign file
1869 void mission_campaign_jump_to_mission(const char *name)
1870 {
1871         int i = 0;
1872         char dest_name[64] = { 0 };
1873
1874         // load in the campaign junk
1875         mission_load_up_campaign();
1876
1877         // tack the .fs2 onto the input name
1878         SDL_strlcpy(dest_name, cf_add_ext(name, FS_MISSION_FILE_EXT), SDL_arraysize(dest_name));
1879
1880         // search for our mission
1881         for (i=0; i<Campaign.num_missions; i++) {
1882                 if ((Campaign.missions[i].name != NULL) && !SDL_strcasecmp(Campaign.missions[i].name, dest_name) ) {
1883                         Campaign.next_mission = i;
1884                         Campaign.prev_mission = i-1;
1885                         mission_campaign_next_mission();
1886                         Game_mode |= GM_CAMPAIGN_MODE;
1887                         gameseq_post_event(GS_EVENT_START_GAME);
1888                         return;
1889                 } else {
1890                         Campaign.missions[i].flags |= CMISSION_FLAG_SKIPPED;
1891                         Campaign.num_missions_completed = i;
1892                 }
1893         }
1894
1895         // if we got here, no match was found
1896         // restart the campaign
1897         mission_campaign_savefile_delete(Campaign.filename);
1898         mission_campaign_load(Campaign.filename);
1899 }
1900