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