Fix crash if Num_walls=0
[btb/d2x.git] / main / mission.c
1 /* $Id: mission.c,v 1.42 2005-02-25 12:46:24 chris Exp $ */
2 /*
3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
13 */
14
15 /*
16  *
17  * Code to handle multiple missions
18  *
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <conf.h>
23 #endif
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <limits.h>
30
31 #include "pstypes.h"
32 #include "cfile.h"
33
34 #include "strutil.h"
35 #include "inferno.h"
36 #include "mission.h"
37 #include "gameseq.h"
38 #include "titles.h"
39 #include "songs.h"
40 #include "mono.h"
41 #include "error.h"
42 #include "config.h"
43 #include "newmenu.h"
44 #include "text.h"
45 #include "u_mem.h"
46 #include "ignorecase.h"
47
48 //values for d1 built-in mission
49 #define BIM_LAST_LEVEL          27
50 #define BIM_LAST_SECRET_LEVEL   -3
51 #define BIM_BRIEFING_FILE       "briefing.tex"
52 #define BIM_ENDING_FILE         "endreg.tex"
53
54 //mission list entry
55 typedef struct mle {
56         char    *filename;          // filename without extension
57         int     builtin_hogsize;    // if it's the built-in mission, used for determining the version
58         char    mission_name[MISSION_NAME_LEN+1];
59         ubyte   descent_version;    // descent 1 or descent 2?
60         ubyte   anarchy_only_flag;  // if true, mission is anarchy only
61         char    *path;                          // relative file path
62         int             location;           // see defines below
63 } mle;
64
65 //values that describe where a mission is located
66 #define ML_CURDIR       0
67 #define ML_MISSIONDIR   1
68 #define ML_CDROM        2
69
70 int num_missions = -1;
71
72 Mission *Current_mission = NULL; // currently loaded mission
73
74 //
75 //  Special versions of mission routines for d1 builtins
76 //
77
78 int load_mission_d1(void)
79 {
80         int i;
81
82         switch (cfile_size("descent.hog")) {
83         case D1_SHAREWARE_MISSION_HOGSIZE:
84         case D1_SHAREWARE_10_MISSION_HOGSIZE:
85                 N_secret_levels = 0;
86
87                 Last_level = 7;
88                 Last_secret_level = 0;
89
90                 //build level names
91                 for (i=0;i<Last_level;i++)
92                         sprintf(Level_names[i], "level%02d.sdl", i+1);
93
94                 break;
95         case D1_MAC_SHARE_MISSION_HOGSIZE:
96                 N_secret_levels = 0;
97
98                 Last_level = 3;
99                 Last_secret_level = 0;
100
101                 //build level names
102                 for (i=0;i<Last_level;i++)
103                         sprintf(Level_names[i], "level%02d.sdl", i+1);
104
105                 break;
106         case D1_OEM_MISSION_HOGSIZE:
107         case D1_OEM_10_MISSION_HOGSIZE:
108                 N_secret_levels = 1;
109
110                 Last_level = 15;
111                 Last_secret_level = -1;
112
113                 //build level names
114                 for (i=0; i < Last_level - 1; i++)
115                         sprintf(Level_names[i], "level%02d.rdl", i+1);
116                 sprintf(Level_names[i], "saturn%02d.rdl", i+1);
117                 for (i=0; i < -Last_secret_level; i++)
118                         sprintf(Secret_level_names[i], "levels%1d.rdl", i+1);
119
120                 Secret_level_table[0] = 10;
121
122                 break;
123         default:
124                 Int3(); // fall through
125         case D1_MISSION_HOGSIZE:
126         case D1_10_MISSION_HOGSIZE:
127         case D1_MAC_MISSION_HOGSIZE:
128                 N_secret_levels = 3;
129
130                 Last_level = BIM_LAST_LEVEL;
131                 Last_secret_level = BIM_LAST_SECRET_LEVEL;
132
133                 //build level names
134                 for (i=0;i<Last_level;i++)
135                         sprintf(Level_names[i], "level%02d.rdl", i+1);
136                 for (i=0;i<-Last_secret_level;i++)
137                         sprintf(Secret_level_names[i], "levels%1d.rdl", i+1);
138
139                 Secret_level_table[0] = 10;
140                 Secret_level_table[1] = 21;
141                 Secret_level_table[2] = 24;
142
143                 break;
144         }
145         strcpy(Briefing_text_filename,BIM_BRIEFING_FILE);
146         strcpy(Ending_text_filename,BIM_ENDING_FILE);
147
148         return 1;
149 }
150
151
152 //
153 //  Special versions of mission routines for shareware
154 //
155
156 int load_mission_shareware(void)
157 {
158     strcpy(Current_mission->mission_name, SHAREWARE_MISSION_NAME);
159     Current_mission->descent_version = 2;
160     Current_mission->anarchy_only_flag = 0;
161     
162     switch (Current_mission->builtin_hogsize) {
163         case MAC_SHARE_MISSION_HOGSIZE:
164                 N_secret_levels = 1;
165
166                 Last_level = 4;
167                 Last_secret_level = -1;
168
169                 // mac demo is using the regular hog and rl2 files
170                 strcpy(Level_names[0],"d2leva-1.rl2");
171                 strcpy(Level_names[1],"d2leva-2.rl2");
172                 strcpy(Level_names[2],"d2leva-3.rl2");
173                 strcpy(Level_names[3],"d2leva-4.rl2");
174                 strcpy(Secret_level_names[0],"d2leva-s.rl2");
175                 break;
176         default:
177                 Int3(); // fall through
178         case SHAREWARE_MISSION_HOGSIZE:
179                 N_secret_levels = 0;
180
181                 Last_level = 3;
182                 Last_secret_level = 0;
183
184                 strcpy(Level_names[0],"d2leva-1.sl2");
185                 strcpy(Level_names[1],"d2leva-2.sl2");
186                 strcpy(Level_names[2],"d2leva-3.sl2");
187         }
188
189         return 1;
190 }
191
192
193 //
194 //  Special versions of mission routines for Diamond/S3 version
195 //
196
197 int load_mission_oem(void)
198 {
199     strcpy(Current_mission->mission_name, OEM_MISSION_NAME);
200     Current_mission->descent_version = 2;
201     Current_mission->anarchy_only_flag = 0;
202     
203         N_secret_levels = 2;
204
205         Last_level = 8;
206         Last_secret_level = -2;
207
208         strcpy(Level_names[0],"d2leva-1.rl2");
209         strcpy(Level_names[1],"d2leva-2.rl2");
210         strcpy(Level_names[2],"d2leva-3.rl2");
211         strcpy(Level_names[3],"d2leva-4.rl2");
212
213         strcpy(Secret_level_names[0],"d2leva-s.rl2");
214
215         strcpy(Level_names[4],"d2levb-1.rl2");
216         strcpy(Level_names[5],"d2levb-2.rl2");
217         strcpy(Level_names[6],"d2levb-3.rl2");
218         strcpy(Level_names[7],"d2levb-4.rl2");
219
220         strcpy(Secret_level_names[1],"d2levb-s.rl2");
221
222         Secret_level_table[0] = 1;
223         Secret_level_table[1] = 5;
224
225         return 1;
226 }
227
228
229 //compare a string for a token. returns true if match
230 int istok(char *buf,char *tok)
231 {
232         return strnicmp(buf,tok,strlen(tok)) == 0;
233
234 }
235
236 //adds a terminating 0 after a string at the first white space
237 void add_term(char *s)
238 {
239         while (*s && !isspace(*s)) s++;
240
241         *s = 0;         //terminate!
242 }
243
244 //returns ptr to string after '=' & white space, or NULL if no '='
245 //adds 0 after parm at first white space
246 char *get_value(char *buf)
247 {
248         char *t;
249
250         t = strchr(buf,'=')+1;
251
252         if (t) {
253                 while (*t && isspace(*t)) t++;
254
255                 if (*t)
256                         return t;
257         }
258
259         return NULL;            //error!
260 }
261
262 //reads a line, returns ptr to value of passed parm.  returns NULL if none
263 char *get_parm_value(char *parm,CFILE *f)
264 {
265         static char buf[80];
266
267         if (!cfgets(buf,80,f))
268                 return NULL;
269
270         if (istok(buf,parm))
271                 return get_value(buf);
272         else
273                 return NULL;
274 }
275
276 int ml_sort_func(mle *e0,mle *e1)
277 {
278         return stricmp(e0->mission_name,e1->mission_name);
279
280 }
281
282 extern char CDROM_dir[];
283
284 //returns 1 if file read ok, else 0
285 int read_mission_file(mle *mission, char *filename, int location)
286 {
287         char filename2[100];
288         CFILE *mfile;
289
290         //printf("reading: %s\n", filename);
291
292         switch (location) {
293                 case ML_MISSIONDIR:
294                         strcpy(filename2,MISSION_DIR);
295                         break;
296
297                 case ML_CDROM:
298                         songs_stop_redbook();           //so we can read from the CD
299                         strcpy(filename2,CDROM_dir);
300                         break;
301
302                 default:
303                         Int3();         //fall through
304
305                 case ML_CURDIR:
306                         strcpy(filename2,"");
307                         break;
308         }
309         strcat(filename2,filename);
310
311         mfile = cfopen(filename2,"rb");
312
313         if (mfile) {
314                 char *p;
315                 char temp[PATH_MAX], *ext;
316
317                 strcpy(temp,filename);
318                 p = strrchr(temp, '/'); // get the filename at the end of the path
319                 if (!p)
320                         p = temp;
321                 else p++;
322                 
323                 if ((ext = strchr(p, '.')) == NULL)
324                         return 0;       //missing extension
325                 // look if it's .mn2 or .msn
326                 mission->descent_version = (ext[3] == '2') ? 2 : 1;
327                 *ext = 0;                       //kill extension
328
329                 mission->path = d_strdup(temp);
330                 mission->anarchy_only_flag = 0;
331                 mission->filename = mission->path + (p - temp);
332                 mission->location = location;
333
334                 p = get_parm_value("name",mfile);
335
336                 if (!p) {               //try enhanced mission
337                         cfseek(mfile,0,SEEK_SET);
338                         p = get_parm_value("xname",mfile);
339                 }
340
341                 if (!p) {       //try super-enhanced mission!
342                         cfseek(mfile,0,SEEK_SET);
343                         p = get_parm_value("zname",mfile);
344                 }
345
346                 if (p) {
347                         char *t;
348                         if ((t=strchr(p,';'))!=NULL)
349                                 *t=0;
350                         t = p + strlen(p)-1;
351                         while (isspace(*t))
352                                 *t-- = 0; // remove trailing whitespace
353                         if (strlen(p) > MISSION_NAME_LEN)
354                                 p[MISSION_NAME_LEN] = 0;
355                         strncpy(mission->mission_name, p, MISSION_NAME_LEN + 1);
356                 }
357                 else {
358                         cfclose(mfile);
359                         d_free(mission->path);
360                         return 0;
361                 }
362
363                 p = get_parm_value("type",mfile);
364
365                 //get mission type
366                 if (p)
367                         mission->anarchy_only_flag = istok(p,"anarchy");
368
369                 cfclose(mfile);
370
371                 return 1;
372         }
373
374         return 0;
375 }
376
377 void add_d1_builtin_mission_to_list(mle *mission)
378 {
379     int size;
380     
381         if (!cfexist("descent.hog"))
382                 return;
383
384         size = cfile_size("descent.hog");
385
386         switch (size) {
387         case D1_SHAREWARE_MISSION_HOGSIZE:
388         case D1_SHAREWARE_10_MISSION_HOGSIZE:
389         case D1_MAC_SHARE_MISSION_HOGSIZE:
390                 mission->filename = d_strdup(D1_MISSION_FILENAME);
391                 strcpy(mission->mission_name, D1_SHAREWARE_MISSION_NAME);
392                 mission->anarchy_only_flag = 0;
393                 break;
394         case D1_OEM_MISSION_HOGSIZE:
395         case D1_OEM_10_MISSION_HOGSIZE:
396                 mission->filename = d_strdup(D1_MISSION_FILENAME);
397                 strcpy(mission->mission_name, D1_OEM_MISSION_NAME);
398                 mission->anarchy_only_flag = 0;
399                 break;
400         default:
401                 Warning("Unknown D1 hogsize %d\n", size);
402                 Int3();
403                 // fall through
404         case D1_MISSION_HOGSIZE:
405         case D1_10_MISSION_HOGSIZE:
406         case D1_MAC_MISSION_HOGSIZE:
407                 mission->filename = d_strdup(D1_MISSION_FILENAME);
408                 strcpy(mission->mission_name, D1_MISSION_NAME);
409                 mission->anarchy_only_flag = 0;
410                 break;
411         }
412
413         mission->descent_version = 1;
414         mission->anarchy_only_flag = 0;
415         mission->builtin_hogsize = 0;
416         mission->path = mission->filename;
417         num_missions++;
418 }
419
420
421 void add_builtin_mission_to_list(mle *mission, char *name)
422 {
423     int size = cfile_size("descent2.hog");
424     
425         if (size == -1)
426                 size = cfile_size("d2demo.hog");
427
428         switch (size) {
429         case SHAREWARE_MISSION_HOGSIZE:
430         case MAC_SHARE_MISSION_HOGSIZE:
431                 mission->filename = d_strdup(SHAREWARE_MISSION_FILENAME);
432                 strcpy(mission->mission_name,SHAREWARE_MISSION_NAME);
433                 mission->anarchy_only_flag = 0;
434                 break;
435         case OEM_MISSION_HOGSIZE:
436                 mission->filename = d_strdup(OEM_MISSION_FILENAME);
437                 strcpy(mission->mission_name,OEM_MISSION_NAME);
438                 mission->anarchy_only_flag = 0;
439                 break;
440         default:
441                 Warning("Unknown hogsize %d, trying %s\n", size, FULL_MISSION_FILENAME ".mn2");
442                 Int3(); //fall through
443         case FULL_MISSION_HOGSIZE:
444         case FULL_10_MISSION_HOGSIZE:
445         case MAC_FULL_MISSION_HOGSIZE:
446                 if (!read_mission_file(mission, FULL_MISSION_FILENAME ".mn2", ML_CURDIR))
447                         Error("Could not find required mission file <%s>", FULL_MISSION_FILENAME ".mn2");
448         }
449
450         strcpy(name, mission->filename);
451     mission->builtin_hogsize = size;
452         mission->descent_version = 2;
453         mission->anarchy_only_flag = 0;
454         num_missions++;
455 }
456
457
458 void add_missions_to_list(mle *mission_list, char *path, char *rel_path, int anarchy_mode)
459 {
460         char **find, **i, *ext;
461
462         find = PHYSFS_enumerateFiles(path);
463
464         for (i = find; *i != NULL; i++)
465         {
466                 if (strlen(path) + strlen(*i) + 1 >= PATH_MAX)
467                         continue;       // path is too long
468
469                 strcat(rel_path, *i);
470                 if (PHYSFS_isDirectory(path))
471                 {
472                         strcat(rel_path, "/");
473                         add_missions_to_list(mission_list, path, rel_path, anarchy_mode);
474                         *(strrchr(path, '/')) = 0;
475                 }
476                 else if ((ext = strrchr(*i, '.')) && (!strnicmp(ext, ".msn", 4) || !strnicmp(ext, ".mn2", 4)))
477                         if (read_mission_file(&mission_list[num_missions], rel_path, ML_MISSIONDIR))
478                         {
479                                 if (anarchy_mode || !mission_list[num_missions].anarchy_only_flag)
480                                 {
481                                         mission_list[num_missions].builtin_hogsize = 0;
482                                         num_missions++;
483                                 }
484                                 else
485                                         d_free(mission_list[num_missions].path);
486                         }
487                 
488                 if (num_missions >= MAX_MISSIONS)
489                 {
490                         mprintf((0, "Warning: more missions than d2x can handle\n"));
491                         break;
492                 }
493
494                 (strrchr(path, '/'))[1] = 0;    // chop off the entry
495         }
496
497         PHYSFS_freeList(find);
498 }
499
500 /* move <mission_name> to <place> on mission list, increment <place> */
501 void promote (mle *mission_list, char * mission_name, int * top_place)
502 {
503         int i;
504         char name[FILENAME_LEN], * t;
505         strcpy(name, mission_name);
506         if ((t = strchr(name,'.')) != NULL)
507                 *t = 0; //kill extension
508         //printf("promoting: %s\n", name);
509         for (i = *top_place; i < num_missions; i++)
510                 if (!stricmp(mission_list[i].filename, name)) {
511                         //swap mission positions
512                         mle temp;
513
514                         temp = mission_list[*top_place];
515                         mission_list[*top_place] = mission_list[i];
516                         mission_list[i] = temp;
517                         ++(*top_place);
518                         break;
519                 }
520 }
521
522 void free_mission(void)
523 {
524     // May become more complex with the editor
525     if (Current_mission) {
526                 d_free(Current_mission->filename);
527         d_free(Current_mission);
528     }
529 }
530
531
532
533 //fills in the global list of missions.  Returns the number of missions
534 //in the list.  If anarchy_mode is set, then also add anarchy-only missions.
535
536 extern char CDROM_dir[];
537 #if 0
538 extern char AltHogDir[];
539 extern char AltHogdir_initialized;
540 #endif
541
542 mle *build_mission_list(int anarchy_mode)
543 {
544         mle *mission_list;
545         int top_place;
546     char        builtin_mission_filename[FILENAME_LEN];
547         char    search_str[PATH_MAX] = MISSION_DIR;
548
549         //now search for levels on disk
550
551 //@@Took out this code because after this routine was called once for
552 //@@a list of single-player missions, a subsequent call for a list of
553 //@@anarchy missions would not scan again, and thus would not find the
554 //@@anarchy-only missions.  If we retain the minimum level of install,
555 //@@we may want to put the code back in, having it always scan for all
556 //@@missions, and have the code that uses it sort out the ones it wants.
557 //@@    if (num_missions != -1) {
558 //@@            if (Current_mission_num != 0)
559 //@@                    load_mission(0);                                //set built-in mission as default
560 //@@            return num_missions;
561 //@@    }
562
563         MALLOC(mission_list, mle, MAX_MISSIONS);
564         num_missions = 0;
565         
566         add_builtin_mission_to_list(mission_list + num_missions, builtin_mission_filename);  //read built-in first
567         add_d1_builtin_mission_to_list(mission_list + num_missions);
568         add_missions_to_list(mission_list, search_str, search_str + strlen(search_str), anarchy_mode);
569         
570         // move original missions (in story-chronological order)
571         // to top of mission list
572         top_place = 0;
573         promote(mission_list, "descent", &top_place); // original descent 1 mission
574         promote(mission_list, builtin_mission_filename, &top_place); // d2 or d2demo
575         promote(mission_list, "d2x", &top_place); // vertigo
576
577         if (num_missions > top_place)
578                 qsort(&mission_list[top_place],
579                       num_missions - top_place,
580                       sizeof(*mission_list),
581                                 (int (*)( const void *, const void * ))ml_sort_func);
582
583
584         if (num_missions > top_place)
585                 qsort(&mission_list[top_place],
586                       num_missions - top_place,
587                       sizeof(*mission_list),
588                       (int (*)( const void *, const void * ))ml_sort_func);
589
590         //load_mission(0);   //set built-in mission as default
591
592     atexit(free_mission);
593
594         return mission_list;
595 }
596
597 void free_mission_list(mle *mission_list)
598 {
599         int i;
600
601         for (i = 0; i < num_missions; i++)
602                 d_free(mission_list[i].path);
603         
604         d_free(mission_list);
605         num_missions = 0;
606 }
607
608 void init_extra_robot_movie(char *filename);
609
610 //values for built-in mission
611
612 //loads the specfied mission from the mission list.
613 //build_mission_list() must have been called.
614 //Returns true if mission loaded ok, else false.
615 int load_mission(mle *mission)
616 {
617         CFILE *mfile;
618         char buf[PATH_MAX], *v;
619     int found_hogfile;
620
621     if (Current_mission)
622         free_mission();
623     Current_mission = d_malloc(sizeof(Mission));
624     if (!Current_mission) return 0;
625     *(mle *) Current_mission = *mission;
626         Current_mission->filename = d_strdup(mission->filename); // don't want to lose it
627
628     // for Descent 1 missions, load descent.hog
629     if (EMULATING_D1) {
630         if (!cfile_init("descent.hog"))
631             Warning("descent.hog not available, this mission may be missing some files required for briefings and exit sequence\n");
632         if (!stricmp(Current_mission_filename, D1_MISSION_FILENAME))
633             return load_mission_d1();
634     }
635
636     if (PLAYING_BUILTIN_MISSION) {
637                 switch (Current_mission->builtin_hogsize) {
638                 case SHAREWARE_MISSION_HOGSIZE:
639                 case MAC_SHARE_MISSION_HOGSIZE:
640                         return load_mission_shareware();
641                         break;
642                 case OEM_MISSION_HOGSIZE:
643                         return load_mission_oem();
644                         break;
645                 default:
646                         Int3(); // fall through
647                 case FULL_MISSION_HOGSIZE:
648                 case FULL_10_MISSION_HOGSIZE:
649                 case MAC_FULL_MISSION_HOGSIZE:
650                         // continue on... (use d2.mn2 from hogfile)
651                         break;
652                 }
653     }
654
655         mprintf(( 0, "Loading mission %s\n", Current_mission_filename ));
656
657         //read mission from file
658
659         switch (mission->location) {
660         case ML_MISSIONDIR:
661                 strcpy(buf,MISSION_DIR);
662                 break;
663         case ML_CDROM:
664                 strcpy(buf,CDROM_dir);
665                 break;
666         default:
667                 Int3();                                                 //fall through
668         case ML_CURDIR:
669                 strcpy(buf,"");
670                 break;
671         }
672         strcat(buf, mission->path);
673         if (mission->descent_version == 2)
674                 strcat(buf,".mn2");
675         else
676                 strcat(buf,".msn");
677
678         PHYSFSEXT_locateCorrectCase(buf);
679
680         mfile = cfopen(buf,"rb");
681         if (mfile == NULL) {
682         free_mission();
683                 return 0;               //error!
684         }
685
686     //for non-builtin missions, load HOG
687     if (!PLAYING_BUILTIN_MISSION) {
688
689         strcpy(buf+strlen(buf)-4,".hog");               //change extension
690
691                 PHYSFSEXT_locateCorrectCase(buf);
692
693                 found_hogfile = cfile_init(buf);
694
695 #ifdef RELEASE                          //for release, require mission to be in hogfile
696         if (! found_hogfile) {
697             cfclose(mfile);
698             free_mission();
699             return 0;
700         }
701 #endif
702     }
703
704     //init vars
705         Last_level = 0;
706         Last_secret_level = 0;
707         Briefing_text_filename[0] = 0;
708         Ending_text_filename[0] = 0;
709
710         while (cfgets(buf,80,mfile)) {
711
712                 if (istok(buf,"name")) {
713                         Current_mission->enhanced = 0;
714                         continue;                                               //already have name, go to next line
715                 }
716                 if (istok(buf,"xname")) {
717                         Current_mission->enhanced = 1;
718                         continue;                                               //already have name, go to next line
719                 }
720                 if (istok(buf,"zname")) {
721                         Current_mission->enhanced = 2;
722                         continue;                                               //already have name, go to next line
723                 }
724                 else if (istok(buf,"type"))
725                         continue;                                               //already have name, go to next line
726                 else if (istok(buf,"hog")) {
727                         char    *bufp = buf;
728
729                         while (*(bufp++) != '=')
730                                 ;
731
732                         if (*bufp == ' ')
733                                 while (*(++bufp) == ' ')
734                                         ;
735
736                         cfile_init(bufp);
737                         mprintf((0, "Hog file override = [%s]\n", bufp));
738                 }
739                 else if (istok(buf,"briefing")) {
740                         if ((v = get_value(buf)) != NULL) {
741                                 add_term(v);
742                                 if (strlen(v) < 13)
743                                         strcpy(Briefing_text_filename,v);
744                         }
745                 }
746                 else if (istok(buf,"ending")) {
747                         if ((v = get_value(buf)) != NULL) {
748                                 add_term(v);
749                                 if (strlen(v) < 13)
750                                         strcpy(Ending_text_filename,v);
751                         }
752                 }
753                 else if (istok(buf,"num_levels")) {
754
755                         if ((v=get_value(buf))!=NULL) {
756                                 int n_levels,i;
757
758                                 n_levels = atoi(v);
759
760                                 for (i=0;i<n_levels && cfgets(buf,80,mfile);i++) {
761
762                                         add_term(buf);
763                                         if (strlen(buf) <= 12) {
764                                                 strcpy(Level_names[i],buf);
765                                                 Last_level++;
766                                         }
767                                         else
768                                                 break;
769                                 }
770
771                         }
772                 }
773                 else if (istok(buf,"num_secrets")) {
774                         if ((v=get_value(buf))!=NULL) {
775                                 int i;
776
777                                 N_secret_levels = atoi(v);
778
779                                 Assert(N_secret_levels <= MAX_SECRET_LEVELS_PER_MISSION);
780
781                                 for (i=0;i<N_secret_levels && cfgets(buf,80,mfile);i++) {
782                                         char *t;
783
784                                         
785                                         if ((t=strchr(buf,','))!=NULL) *t++=0;
786                                         else
787                                                 break;
788
789                                         add_term(buf);
790                                         if (strlen(buf) <= 12) {
791                                                 strcpy(Secret_level_names[i],buf);
792                                                 Secret_level_table[i] = atoi(t);
793                                                 if (Secret_level_table[i]<1 || Secret_level_table[i]>Last_level)
794                                                         break;
795                                                 Last_secret_level--;
796                                         }
797                                         else
798                                                 break;
799                                 }
800
801                         }
802                 }
803
804         }
805
806         cfclose(mfile);
807
808         if (Last_level <= 0) {
809                 free_mission();         //no valid mission loaded
810                 return 0;
811         }
812
813         if (Current_mission->enhanced) {
814                 char t[50];
815                 extern void bm_read_extra_robots();
816                 sprintf(t,"%s.ham",Current_mission_filename);
817                 bm_read_extra_robots(t, Current_mission->enhanced);
818                 strncpy(t,Current_mission_filename,6);
819                 init_extra_robot_movie(t);
820         }
821
822         return 1;
823 }
824
825 //loads the named mission if exists.
826 //Returns true if mission loaded ok, else false.
827 int load_mission_by_name(char *mission_name)
828 {
829         int i;
830         mle *mission_list = build_mission_list(1);
831         bool found = 0;
832
833         for (i = 0; i < num_missions; i++)
834                 if (!stricmp(mission_name, mission_list[i].filename))
835                         found = load_mission(mission_list + i);
836
837         free_mission_list(mission_list);
838         return found;
839 }
840
841 int select_mission(int anarchy_mode, char *message)
842 {
843     mle *mission_list = build_mission_list(anarchy_mode);
844         int new_mission_num;
845
846     if (num_missions <= 1) {
847         new_mission_num = load_mission(mission_list) ? 0 : -1;
848     } else {
849         int i, default_mission;
850         char * m[MAX_MISSIONS];
851
852         default_mission = 0;
853         for (i = 0; i < num_missions; i++) {
854             m[i] = mission_list[i].mission_name;
855             if ( !stricmp( m[i], config_last_mission ) )
856                 default_mission = i;
857         }
858
859         new_mission_num = newmenu_listbox1( message, num_missions, m, 1, default_mission, NULL );
860
861         if (new_mission_num >= 0) {
862                         // Chose a mission
863                         strcpy(config_last_mission, m[new_mission_num]  );
864         
865                         if (!load_mission(mission_list + new_mission_num)) {
866                                 nm_messagebox( NULL, 1, TXT_OK, TXT_MISSION_ERROR);
867                                 new_mission_num = -1;
868                         }
869                 }
870     }
871
872         free_mission_list(mission_list);
873     return (new_mission_num >= 0);
874 }