fast i/o macros
[btb/d2x.git] / main / piggy.c
1 /*
2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
12 */
13
14 #ifdef HAVE_CONFIG_H
15 #include <conf.h>
16 #endif
17
18 #ifdef RCS
19 static char rcsid[] = "$Id: piggy.c,v 1.14 2002-08-02 04:57:19 btb Exp $";
20 #endif
21
22
23 #include <stdio.h>
24 #include <string.h>
25
26 #include "pstypes.h"
27 #include "strutil.h"
28 #include "inferno.h"
29 #include "gr.h"
30 #include "u_mem.h"
31 #include "iff.h"
32 #include "mono.h"
33 #include "error.h"
34 #include "sounds.h"
35 #include "songs.h"
36 #include "bm.h"
37 #include "bmread.h"
38 #include "hash.h"
39 #include "args.h"
40 #include "palette.h"
41 #include "gamefont.h"
42 #include "rle.h"
43 #include "screens.h"
44 #include "piggy.h"
45 #include "texmerge.h"
46 #include "paging.h"
47 #include "game.h"
48 #include "text.h"
49 #include "cfile.h"
50 #include "newmenu.h"
51 #include "byteswap.h"
52 #include "findfile.h"
53 #include "makesig.h"
54
55 #ifndef MACINTOSH
56 //      #include "unarj.h"
57 #else
58         #include <Strings.h>            // MacOS Toolbox header
59         #include <Files.h>
60         #include <unistd.h>
61 #endif
62
63 //#define NO_DUMP_SOUNDS        1               //if set, dump bitmaps but not sounds
64
65 #define DEFAULT_PIGFILE_REGISTERED      "groupa.pig"
66 #define DEFAULT_PIGFILE_SHAREWARE       "d2demo.pig"
67
68
69 #ifdef SHAREWARE
70         #define DEFAULT_HAMFILE         "d2demo.ham"
71         #define DEFAULT_PIGFILE         DEFAULT_PIGFILE_SHAREWARE
72         #define DEFAULT_SNDFILE                 DEFAULT_HAMFILE //"descent2.s11"
73 #else
74         #define DEFAULT_HAMFILE         "descent2.ham"
75         #define DEFAULT_PIGFILE         DEFAULT_PIGFILE_REGISTERED
76         #define DEFAULT_SNDFILE                 ((digi_sample_rate==SAMPLE_RATE_22K)?"descent2.s22":"descent2.s11")
77 #endif  // end of ifdef SHAREWARE
78
79 ubyte *BitmapBits = NULL;
80 ubyte *SoundBits = NULL;
81
82 typedef struct BitmapFile       {
83         char                    name[15];
84 } BitmapFile;
85
86 typedef struct SoundFile        {
87         char                    name[15];
88 } SoundFile;
89
90 hashtable AllBitmapsNames;
91 hashtable AllDigiSndNames;
92
93 int Num_bitmap_files = 0;
94 int Num_sound_files = 0;
95
96 digi_sound GameSounds[MAX_SOUND_FILES];
97 int SoundOffset[MAX_SOUND_FILES];
98 grs_bitmap GameBitmaps[MAX_BITMAP_FILES];
99
100 alias alias_list[MAX_ALIASES];
101 int Num_aliases=0;
102
103 int Must_write_hamfile = 0;
104 int Num_bitmap_files_new = 0;
105 int Num_sound_files_new = 0;
106 BitmapFile AllBitmaps[ MAX_BITMAP_FILES ];
107 static SoundFile AllSounds[ MAX_SOUND_FILES ];
108
109 int piggy_low_memory = 0;
110
111 int Piggy_bitmap_cache_size = 0;
112 int Piggy_bitmap_cache_next = 0;
113 ubyte * Piggy_bitmap_cache_data = NULL;
114 static int GameBitmapOffset[MAX_BITMAP_FILES];
115 static ubyte GameBitmapFlags[MAX_BITMAP_FILES];
116 ushort GameBitmapXlat[MAX_BITMAP_FILES];
117
118 #define PIGGY_BUFFER_SIZE (2400*1024)
119
120 #ifdef MACINTOSH
121 #define PIGGY_SMALL_BUFFER_SIZE (1400*1024)             // size of buffer when piggy_low_memory is set
122
123 #ifdef SHAREWARE
124 #undef PIGGY_BUFFER_SIZE
125 #undef PIGGY_SMALL_BUFFER_SIZE
126
127 #define PIGGY_BUFFER_SIZE (2000*1024)
128 #define PIGGY_SMALL_BUFFER_SIZE (1100 * 1024)
129 #endif          // SHAREWARE
130
131 #endif
132
133 int piggy_page_flushed = 0;
134
135 #define DBM_FLAG_ABM            64
136
137 ubyte BigPig = 0;
138
139 #ifdef MACINTOSH
140         extern short    cd_VRefNum;
141         extern void             ConcatPStr(StringPtr dst, StringPtr src);
142         extern int              ConvertPToCStr(StringPtr inPStr, char* outCStrBuf);
143         extern int              ConvertCToPStr(char* inCStr, StringPtr outPStrBuf);
144 #endif
145
146 int piggy_is_substitutable_bitmap( char * name, char * subst_name );
147
148 #ifdef EDITOR
149 void piggy_write_pigfile(char *filename);
150 static void write_int(int i,FILE *file);
151
152 void swap_0_255(grs_bitmap *bmp)
153 {
154         int i;
155
156         for (i = 0; i < bmp->bm_h * bmp->bm_w; i++) {
157                 if(bmp->bm_data[i] == 0)
158                         bmp->bm_data[i] = 255;
159                 else if (bmp->bm_data[i] == 255)
160                         bmp->bm_data[i] = 0;
161         }
162 }
163 #endif
164
165 bitmap_index piggy_register_bitmap( grs_bitmap * bmp, char * name, int in_file )
166 {
167         bitmap_index temp;
168         Assert( Num_bitmap_files < MAX_BITMAP_FILES );
169
170         temp.index = Num_bitmap_files;
171
172         if (!in_file)   {
173 #ifdef EDITOR
174                 if ( FindArg("-macdata") )
175                         swap_0_255( bmp );
176 #endif
177                 if ( !BigPig )  gr_bitmap_rle_compress( bmp );
178                 Num_bitmap_files_new++;
179         }
180
181         strncpy( AllBitmaps[Num_bitmap_files].name, name, 12 );
182         hashtable_insert( &AllBitmapsNames, AllBitmaps[Num_bitmap_files].name, Num_bitmap_files );
183         GameBitmaps[Num_bitmap_files] = *bmp;
184         if ( !in_file ) {
185                 GameBitmapOffset[Num_bitmap_files] = 0;
186                 GameBitmapFlags[Num_bitmap_files] = bmp->bm_flags;
187         }
188         Num_bitmap_files++;
189
190         return temp;
191 }
192
193 int piggy_register_sound( digi_sound * snd, char * name, int in_file )
194 {
195         int i;
196
197         Assert( Num_sound_files < MAX_SOUND_FILES );
198
199         strncpy( AllSounds[Num_sound_files].name, name, 12 );
200         hashtable_insert( &AllDigiSndNames, AllSounds[Num_sound_files].name, Num_sound_files );
201         GameSounds[Num_sound_files] = *snd;
202         if ( !in_file ) {
203                 SoundOffset[Num_sound_files] = 0;       
204         }
205
206         i = Num_sound_files;
207    
208         if (!in_file)
209                 Num_sound_files_new++;
210
211         Num_sound_files++;
212         return i;
213 }
214
215 bitmap_index piggy_find_bitmap( char * name )   
216 {
217         bitmap_index bmp;
218         int i;
219         char *t;
220
221         bmp.index = 0;
222
223         if ((t=strchr(name,'#'))!=NULL)
224                 *t=0;
225
226         for (i=0;i<Num_aliases;i++)
227                 if (stricmp(name,alias_list[i].alias_name)==0) {
228                         if (t) {                //extra stuff for ABMs
229                                 static char temp[FILENAME_LEN];
230                                 _splitpath(alias_list[i].file_name, NULL, NULL, temp, NULL );
231                                 name = temp;
232                                 strcat(name,"#");
233                                 strcat(name,t+1);
234                         }
235                         else
236                                 name=alias_list[i].file_name; 
237                         break;
238                 }
239
240         if (t)
241                 *t = '#';
242
243         i = hashtable_search( &AllBitmapsNames, name );
244         Assert( i != 0 );
245         if ( i < 0 )
246                 return bmp;
247
248         bmp.index = i;
249         return bmp;
250 }
251
252 int piggy_find_sound( char * name )     
253 {
254         int i;
255
256         i = hashtable_search( &AllDigiSndNames, name );
257
258         if ( i < 0 )
259                 return 255;
260
261         return i;
262 }
263
264 CFILE * Piggy_fp = NULL;
265
266 #define FILENAME_LEN 13
267
268 char Current_pigfile[FILENAME_LEN] = "";
269
270 void piggy_close_file()
271 {
272         if ( Piggy_fp ) {
273                 cfclose( Piggy_fp );
274                 Piggy_fp        = NULL;
275                 Current_pigfile[0] = 0;
276         }
277 }
278
279 int Pigfile_initialized=0;
280
281 #define PIGFILE_ID              MAKE_SIG('G','I','P','P') //PPIG
282 #define PIGFILE_VERSION         2
283
284 extern char CDROM_dir[];
285
286 int request_cd(void);
287
288
289 #ifdef MACINTOSH
290
291 //copies a pigfile from the CD to the current dir
292 //retuns file handle of new pig
293 CFILE *copy_pigfile_from_cd(char *filename)             // MACINTOSH VERSION
294 {
295         // C Stuff
296         char                    sourcePathAndFileCStr[255] = "";
297         char                    destPathAndFileCStr[255]        = "";
298         FILEFINDSTRUCT  find;
299         FILE*                   sourceFile      = NULL;
300         FILE*                   destFile        = NULL;
301         const int               BUF_SIZE = 4096;
302         ubyte                   buf[BUF_SIZE];
303
304         // Mac Stuff
305         Str255                  sourcePathAndFilePStr = "\p";
306         Str255                  destPathAndFilePStr = "\p";
307         Str255                  pigfileNamePStr = "\p";
308         HParamBlockRec  theSourcePigHFSParams;
309         HParamBlockRec  theDestPigHFSParams;
310         OSErr                   theErr = noErr;
311         char                    oldDirCStr[255] = "";
312
313         getcwd(oldDirCStr, 255);
314         
315         show_boxed_message("Copying bitmap data from CD...");
316         gr_palette_load(gr_palette);    //I don't think this line is really needed
317
318         chdir(":Data");
319         //First, delete all PIG files currently in the directory
320         if( !FileFindFirst( "*.pig", &find ) )
321         {
322                 do
323                 {
324                         remove(find.name);
325                 } while( !FileFindNext( &find ) );
326                 
327                 FileFindClose();
328         }
329         chdir(oldDirCStr);
330
331         //Now, copy over new pig
332         songs_stop_redbook();           //so we can read off the cd
333
334         // make the source path "<cd volume>:Data:filename.pig"
335 //MWA   ConvertCToPStr(filename, pigfileNamePStr);
336
337 //MWA   ConcatPStr(sourcePathAndFilePStr, "\pDescent II:Data:");        // volume ID is cd_VRefNum
338 //MWA   ConcatPStr(sourcePathAndFilePStr, pigfileNamePStr);
339
340         strupr(filename);
341         strcpy(sourcePathAndFileCStr, "Descent II:Data:");
342         strcat(sourcePathAndFileCStr, filename);
343         
344         // make the destination path "<default directory>:Data:filename.pig"
345 //MWA   ConcatPStr(destPathAndFilePStr, "\p:Data:");
346 //MWA   ConcatPStr(destPathAndFilePStr, pigfileNamePStr);
347 //MWA   ConvertPToCStr(sourcePathAndFilePStr, sourcePathAndFileCStr);
348 //MWA   ConvertPToCStr(destPathAndFilePStr, destPathAndFileCStr);
349
350         strcpy(destPathAndFileCStr, ":Data:");
351         strcat(destPathAndFileCStr, filename);
352
353         strcpy(sourcePathAndFilePStr, sourcePathAndFileCStr);
354         strcpy(destPathAndFilePStr, destPathAndFileCStr);
355         c2pstr(sourcePathAndFilePStr);
356         c2pstr(destPathAndFilePStr);
357         
358         do {
359                 // Open the source file
360                 sourceFile = fopen(sourcePathAndFileCStr,"rb");
361
362                 if (!sourceFile) {
363
364                         if (request_cd() == -1)
365                                 Error("Cannot load file <%s> from CD",filename);
366                 }
367
368         } while (!sourceFile);
369
370
371         // Get the time stamp from the source file
372         theSourcePigHFSParams.fileParam.ioCompletion    = nil;
373         theSourcePigHFSParams.fileParam.ioNamePtr               = sourcePathAndFilePStr;
374         theSourcePigHFSParams.fileParam.ioVRefNum               = cd_VRefNum;
375         theSourcePigHFSParams.fileParam.ioFDirIndex     = 0;
376         theSourcePigHFSParams.fileParam.ioDirID         = 0;
377         
378         theErr = PBHGetFInfo(&theSourcePigHFSParams, false);
379         if (theErr != noErr)
380         {
381                 // Error getting file time stamp!! Why? JTS
382                 Error("Can't get old file time stamp: <%s>\n", sourcePathAndFileCStr);
383         }
384         
385         // Copy the file over
386         // C Stuff......
387         
388         // Open the destination file
389         destFile = fopen(destPathAndFileCStr,"wb");
390         if (!destFile)
391         {
392                 Error("Cannot create file: <%s>\n", destPathAndFileCStr);
393         }
394         
395         // Copy bytes until the end of the source file
396         while (!feof(sourceFile))
397         {
398                 int bytes_read;
399                 int x;
400
401                 bytes_read = fread(buf,1,BUF_SIZE,sourceFile);
402                 if (ferror(sourceFile))
403                         Error("Cannot read from file <%s>: %s", sourcePathAndFileCStr, strerror(errno));
404
405 // Assert is bogus              Assert(bytes_read == BUF_SIZE || feof(sourceFile));
406
407                 fwrite(buf,1,bytes_read,destFile);
408                 if (ferror(destFile))
409                         Error("Cannot write to file <%s>: %s",destPathAndFileCStr, strerror(errno));
410         }
411
412         // close the source/dest files
413         if (fclose(sourceFile))
414                 Error("Error closing file <%s>: %s", sourcePathAndFileCStr, strerror(errno));
415         if (fclose(destFile))
416                 Error("Error closing file <%s>: %s", destPathAndFileCStr, strerror(errno));
417
418         // Get the current hfs data for the new file
419         theDestPigHFSParams.fileParam.ioCompletion      = nil;
420         theDestPigHFSParams.fileParam.ioNamePtr         = destPathAndFilePStr;
421         theDestPigHFSParams.fileParam.ioVRefNum         = 0;
422         theDestPigHFSParams.fileParam.ioFDirIndex       = 0;
423         theDestPigHFSParams.fileParam.ioDirID           = 0;
424         theErr = PBHGetFInfo(&theDestPigHFSParams, false);
425         if ((theErr != noErr) || (theDestPigHFSParams.fileParam.ioResult != noErr))
426         {
427                 // Error getting file time stamp!! Why? JTS
428                 Error("Can't get destination pig file information: <%s>\n", destPathAndFileCStr);
429         }
430
431         // Reset this data !!!!! or else the relative pathname won't work, could use just filename instead but, oh well.
432         theDestPigHFSParams.fileParam.ioNamePtr         = destPathAndFilePStr;
433         theDestPigHFSParams.fileParam.ioVRefNum         = 0;
434         theDestPigHFSParams.fileParam.ioFDirIndex       = 0;
435         theDestPigHFSParams.fileParam.ioDirID           = 0;
436
437         // Copy the time stamp from the source file info
438         theDestPigHFSParams.fileParam.ioFlCrDat = theSourcePigHFSParams.fileParam.ioFlCrDat;
439         theDestPigHFSParams.fileParam.ioFlMdDat = theSourcePigHFSParams.fileParam.ioFlMdDat;
440         theDestPigHFSParams.fileParam.ioFlFndrInfo.fdType = 'PGGY';
441         theDestPigHFSParams.fileParam.ioFlFndrInfo.fdCreator = 'DCT2';
442         
443         // Set the dest file's time stamp to the source file's time stamp values
444         theErr = PBHSetFInfo(&theDestPigHFSParams, false);
445
446         if ((theErr != noErr) || (theDestPigHFSParams.fileParam.ioResult != noErr))
447         {
448                 Error("Can't set destination pig file time stamp: <%s>\n", destPathAndFileCStr);
449         }
450
451         theErr = PBHGetFInfo(&theDestPigHFSParams, false);
452
453         return cfopen(destPathAndFileCStr, "rb");
454 }
455
456 #else   //PC Version of copy_pigfile_from_cd is below
457
458 //copies a pigfile from the CD to the current dir
459 //retuns file handle of new pig
460 CFILE *copy_pigfile_from_cd(char *filename)
461 {
462         char name[80];
463         FILEFINDSTRUCT find;
464         int ret;
465
466         return cfopen(filename, "rb");
467         show_boxed_message("Copying bitmap data from CD...");
468         gr_palette_load(gr_palette);    //I don't think this line is really needed
469
470         //First, delete all PIG files currently in the directory
471
472         if( !FileFindFirst( "*.pig", &find ) ) {
473                 do      {
474                         remove(find.name);
475                 } while( !FileFindNext( &find ) );
476                 FileFindClose();
477         }
478
479         //Now, copy over new pig
480
481         songs_stop_redbook();           //so we can read off the cd
482
483         //new code to unarj file
484         strcpy(name,CDROM_dir);
485         strcat(name,"descent2.sow");
486
487         do {
488 //              ret = unarj_specific_file(name,filename,filename);
489 // DPH:FIXME
490
491                 ret = !EXIT_SUCCESS;
492
493                 if (ret != EXIT_SUCCESS) {
494
495                         //delete file, so we don't leave partial file
496                         remove(filename);
497
498                         #ifndef MACINTOSH
499                         if (request_cd() == -1)
500                         #endif
501                                 //NOTE LINK TO ABOVE IF
502                                 Error("Cannot load file <%s> from CD",filename);
503                 }
504
505         } while (ret != EXIT_SUCCESS);
506
507         return cfopen(filename, "rb");
508 }
509
510 #endif // end of ifdef MAC around copy_pigfile_from_cd
511
512 //initialize a pigfile, reading headers
513 //returns the size of all the bitmap data
514 void piggy_init_pigfile(char *filename)
515 {
516         int i;
517         char temp_name[16];
518         char temp_name_read[16];
519         grs_bitmap temp_bitmap;
520         DiskBitmapHeader bmh;
521         int header_size, N_bitmaps, data_size, data_start;
522         #ifdef MACINTOSH
523         char name[255];         // filename + path for the mac
524         #endif
525
526         piggy_close_file();             //close old pig if still open
527
528         #ifdef SHAREWARE                //rename pigfile for shareware
529         if (stricmp(filename,DEFAULT_PIGFILE_REGISTERED)==0)
530                 filename = DEFAULT_PIGFILE_SHAREWARE;
531         #endif
532
533         #ifndef MACINTOSH
534                 Piggy_fp = cfopen( filename, "rb" );
535         #else
536                 sprintf(name, ":Data:%s", filename);
537                 Piggy_fp = cfopen( name, "rb" );
538         
539                 #ifdef SHAREWARE        // if we are in the shareware version, we must have the pig by now.
540                         if (Piggy_fp == NULL)
541                         {
542                                 Error("Cannot load required file <%s>",name);
543                         }
544                 #endif  // end of if def shareware
545         
546         #endif
547
548         if (!Piggy_fp) {
549                 #ifdef EDITOR
550                         return;         //if editor, ok to not have pig, because we'll build one
551                 #else
552                         Piggy_fp = copy_pigfile_from_cd(filename);
553                 #endif
554         }
555
556         if (Piggy_fp) {                         //make sure pig is valid type file & is up-to-date
557                 int pig_id,pig_version;
558
559                 pig_id = cfile_read_int(Piggy_fp);
560                 pig_version = cfile_read_int(Piggy_fp);
561                 if (pig_id != PIGFILE_ID || pig_version != PIGFILE_VERSION) {
562                         cfclose(Piggy_fp);              //out of date pig
563                         Piggy_fp = NULL;                        //..so pretend it's not here
564                 }
565         }
566
567         if (!Piggy_fp) {
568
569                 #ifdef EDITOR
570                         return;         //if editor, ok to not have pig, because we'll build one
571                 #else
572                         Error("Cannot load required file <%s>",filename);
573                 #endif
574         }
575
576         strncpy(Current_pigfile,filename,sizeof(Current_pigfile));
577
578         N_bitmaps = cfile_read_int(Piggy_fp);
579
580         header_size = N_bitmaps*DISKBITMAPHEADER_SIZE;
581
582         data_start = header_size + cftell(Piggy_fp);
583
584         data_size = cfilelength(Piggy_fp) - data_start;
585
586         Num_bitmap_files = 1;
587
588         for (i=0; i<N_bitmaps; i++ )    {
589                 DiskBitmapHeader_read(&bmh, Piggy_fp);
590                 memcpy( temp_name_read, bmh.name, 8 );
591                 temp_name_read[8] = 0;
592                 if ( bmh.dflags & DBM_FLAG_ABM )        
593                         sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
594                 else
595                         strcpy( temp_name, temp_name_read );
596                 memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
597                 temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
598                 temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
599                 temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
600                 temp_bitmap.avg_color = bmh.avg_color;
601                 temp_bitmap.bm_data = Piggy_bitmap_cache_data;
602
603                 GameBitmapFlags[i+1] = 0;
604                 if ( bmh.flags & BM_FLAG_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_TRANSPARENT;
605                 if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_SUPER_TRANSPARENT;
606                 if ( bmh.flags & BM_FLAG_NO_LIGHTING ) GameBitmapFlags[i+1] |= BM_FLAG_NO_LIGHTING;
607                 if ( bmh.flags & BM_FLAG_RLE ) GameBitmapFlags[i+1] |= BM_FLAG_RLE;
608                 if ( bmh.flags & BM_FLAG_RLE_BIG ) GameBitmapFlags[i+1] |= BM_FLAG_RLE_BIG;
609
610                 GameBitmapOffset[i+1] = bmh.offset + data_start;
611                 Assert( (i+1) == Num_bitmap_files );
612                 piggy_register_bitmap( &temp_bitmap, temp_name, 1 );
613         }
614
615 #ifdef EDITOR
616         Piggy_bitmap_cache_size = data_size + (data_size/10);   //extra mem for new bitmaps
617         Assert( Piggy_bitmap_cache_size > 0 );
618 #else
619         Piggy_bitmap_cache_size = PIGGY_BUFFER_SIZE;
620         #ifdef MACINTOSH
621         if (piggy_low_memory)
622                 Piggy_bitmap_cache_size = PIGGY_SMALL_BUFFER_SIZE;
623         #endif
624 #endif
625         BitmapBits = d_malloc( Piggy_bitmap_cache_size );
626         if ( BitmapBits == NULL )
627                 Error( "Not enough memory to load bitmaps\n" );
628         Piggy_bitmap_cache_data = BitmapBits;   
629         Piggy_bitmap_cache_next = 0;
630         
631         #if defined(MACINTOSH) && defined(SHAREWARE)
632 //      load_exit_models();
633         #endif
634
635         Pigfile_initialized=1;  
636 }
637
638 #define FILENAME_LEN 13
639 #define MAX_BITMAPS_PER_BRUSH 30
640
641 extern int compute_average_pixel(grs_bitmap *new);
642
643 //reads in a new pigfile (for new palette)
644 //returns the size of all the bitmap data
645 void piggy_new_pigfile(char *pigname)
646 {
647         int i;
648         char temp_name[16];
649         char temp_name_read[16];
650         grs_bitmap temp_bitmap;
651         DiskBitmapHeader bmh;
652         int header_size, N_bitmaps, data_size, data_start;
653         int must_rewrite_pig = 0;
654         #ifdef MACINTOSH
655         char name[255];
656         #endif
657
658         strlwr(pigname);
659
660         #ifdef SHAREWARE                //rename pigfile for shareware
661         if (stricmp(pigname,DEFAULT_PIGFILE_REGISTERED)==0)
662                 pigname = DEFAULT_PIGFILE_SHAREWARE;
663         #endif
664
665         if (strnicmp(Current_pigfile,pigname,sizeof(Current_pigfile))==0)
666                 return;         //already have correct pig
667
668         if (!Pigfile_initialized) {                     //have we ever opened a pigfile?
669                 piggy_init_pigfile(pigname);            //..no, so do initialization stuff
670                 return;
671         }
672         else
673                 piggy_close_file();             //close old pig if still open
674
675         Piggy_bitmap_cache_next = 0;            //free up cache
676
677         strncpy(Current_pigfile,pigname,sizeof(Current_pigfile));
678
679         #ifndef MACINTOSH
680                 Piggy_fp = cfopen( pigname, "rb" );
681         #else
682                 sprintf(name, ":Data:%s", pigname);
683                 Piggy_fp = cfopen( name, "rb" );
684
685                 #ifdef SHAREWARE        // if we are in the shareware version, we must have the pig by now.
686                         if (Piggy_fp == NULL)
687                         {
688                                 Error("Cannot load required file <%s>",name);
689                         }
690                 #endif  // end of if def shareware
691         #endif
692
693         #ifndef EDITOR
694         if (!Piggy_fp)
695                 Piggy_fp = copy_pigfile_from_cd(pigname);
696         #endif
697
698         if (Piggy_fp) {                         //make sure pig is valid type file & is up-to-date
699                 int pig_id,pig_version;
700
701                 pig_id = cfile_read_int(Piggy_fp);
702                 pig_version = cfile_read_int(Piggy_fp);
703                 if (pig_id != PIGFILE_ID || pig_version != PIGFILE_VERSION) {
704                         cfclose(Piggy_fp);              //out of date pig
705                         Piggy_fp = NULL;                        //..so pretend it's not here
706                 }
707         }
708
709         #ifndef EDITOR
710         if (!Piggy_fp) Error ("Piggy_fp not defined in piggy_new_pigfile.");
711         #endif
712
713         if (Piggy_fp) {
714
715                 N_bitmaps = cfile_read_int(Piggy_fp);
716         
717                 header_size = N_bitmaps*DISKBITMAPHEADER_SIZE;
718         
719                 data_start = header_size + cftell(Piggy_fp);
720
721                 data_size = cfilelength(Piggy_fp) - data_start;
722         
723                 for (i=1; i<=N_bitmaps; i++ )   {
724                         DiskBitmapHeader_read(&bmh, Piggy_fp);
725                         memcpy( temp_name_read, bmh.name, 8 );
726                         temp_name_read[8] = 0;
727         
728                         if ( bmh.dflags & DBM_FLAG_ABM )        
729                                 sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
730                         else
731                                 strcpy( temp_name, temp_name_read );
732         
733                         //Make sure name matches
734                         if (strcmp(temp_name,AllBitmaps[i].name)) {
735                                 //Int3();       //this pig is out of date.  Delete it
736                                 must_rewrite_pig=1;
737                         }
738         
739                         strcpy(AllBitmaps[i].name,temp_name);
740
741                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
742         
743                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
744                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
745                         temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
746                         temp_bitmap.avg_color = bmh.avg_color;
747                         temp_bitmap.bm_data = Piggy_bitmap_cache_data;
748         
749                         GameBitmapFlags[i] = 0;
750         
751                         if ( bmh.flags & BM_FLAG_TRANSPARENT ) GameBitmapFlags[i] |= BM_FLAG_TRANSPARENT;
752                         if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) GameBitmapFlags[i] |= BM_FLAG_SUPER_TRANSPARENT;
753                         if ( bmh.flags & BM_FLAG_NO_LIGHTING ) GameBitmapFlags[i] |= BM_FLAG_NO_LIGHTING;
754                         if ( bmh.flags & BM_FLAG_RLE ) GameBitmapFlags[i] |= BM_FLAG_RLE;
755                         if ( bmh.flags & BM_FLAG_RLE_BIG ) GameBitmapFlags[i] |= BM_FLAG_RLE_BIG;
756         
757                         GameBitmapOffset[i] = bmh.offset + data_start;
758         
759                         GameBitmaps[i] = temp_bitmap;
760                 }
761         }
762         else
763                 N_bitmaps = 0;          //no pigfile, so no bitmaps
764
765         #ifndef EDITOR
766
767         Assert(N_bitmaps == Num_bitmap_files-1);
768
769         #else
770
771         if (must_rewrite_pig || (N_bitmaps < Num_bitmap_files-1)) {
772                 int size;
773
774                 //re-read the bitmaps that aren't in this pig
775
776                 for (i=N_bitmaps+1;i<Num_bitmap_files;i++) {
777                         char *p;
778
779                         p = strchr(AllBitmaps[i].name,'#');
780
781                         if (p) {                //this is an ABM
782                                 char abmname[FILENAME_LEN];
783                                 int fnum;
784                                 grs_bitmap * bm[MAX_BITMAPS_PER_BRUSH];
785                                 int iff_error;          //reference parm to avoid warning message
786                                 ubyte newpal[768];
787                                 char basename[FILENAME_LEN];
788                                 int nframes;
789                         
790                                 strcpy(basename,AllBitmaps[i].name);
791                                 basename[p-AllBitmaps[i].name] = 0;             //cut off "#nn" part
792                                 
793                                 sprintf( abmname, "%s.abm", basename );
794
795                       iff_error = iff_read_animbrush(abmname,bm,MAX_BITMAPS_PER_BRUSH,&nframes,newpal);
796
797                                 if (iff_error != IFF_NO_ERROR)  {
798                                         mprintf((1,"File %s - IFF error: %s",abmname,iff_errormsg(iff_error)));
799                                         Error("File %s - IFF error: %s",abmname,iff_errormsg(iff_error));
800                                 }
801                         
802                                 for (fnum=0;fnum<nframes; fnum++)       {
803                                         char tempname[20];
804                                         int SuperX;
805
806                                         sprintf( tempname, "%s#%d", basename, fnum );
807
808                                         //SuperX = (GameBitmaps[i+fnum].bm_flags&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
809                                         SuperX = (GameBitmapFlags[i+fnum]&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
810                                         //above makes assumption that supertransparent color is 254
811
812                                         if ( iff_has_transparency )
813                                                 gr_remap_bitmap_good( bm[fnum], newpal, iff_transparent_color, SuperX );
814                                         else
815                                                 gr_remap_bitmap_good( bm[fnum], newpal, -1, SuperX );
816                         
817                                         bm[fnum]->avg_color = compute_average_pixel(bm[fnum]);
818
819 #ifdef EDITOR
820                                         if ( FindArg("-macdata") )
821                                                 swap_0_255( bm[fnum] );
822 #endif
823                                         if ( !BigPig ) gr_bitmap_rle_compress( bm[fnum] );
824
825                                         if (bm[fnum]->bm_flags & BM_FLAG_RLE)
826                                                 size = *((int *) bm[fnum]->bm_data);
827                                         else
828                                                 size = bm[fnum]->bm_w * bm[fnum]->bm_h;
829
830                                         memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],bm[fnum]->bm_data,size);
831                                         d_free(bm[fnum]->bm_data);
832                                         bm[fnum]->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
833                                         Piggy_bitmap_cache_next += size;
834
835                                         GameBitmaps[i+fnum] = *bm[fnum];
836
837                                         // -- mprintf( (0, "U" ));
838                                         d_free( bm[fnum] );
839                                 }
840
841                                 i += nframes-1;         //filled in multiple bitmaps
842                         }
843                         else {          //this is a BBM
844
845                                 grs_bitmap * new;
846                                 ubyte newpal[256*3];
847                                 int iff_error;
848                                 char bbmname[FILENAME_LEN];
849                                 int SuperX;
850
851                                 MALLOC( new, grs_bitmap, 1 );
852
853                                 sprintf( bbmname, "%s.bbm", AllBitmaps[i].name );
854                                 iff_error = iff_read_bitmap(bbmname,new,BM_LINEAR,newpal);
855
856                                 new->bm_handle=0;
857                                 if (iff_error != IFF_NO_ERROR)          {
858                                         mprintf((1, "File %s - IFF error: %s",bbmname,iff_errormsg(iff_error)));
859                                         Error("File %s - IFF error: %s",bbmname,iff_errormsg(iff_error));
860                                 }
861                         
862                                 SuperX = (GameBitmapFlags[i]&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
863                                 //above makes assumption that supertransparent color is 254
864
865                                 if ( iff_has_transparency )
866                                         gr_remap_bitmap_good( new, newpal, iff_transparent_color, SuperX );
867                                 else
868                                         gr_remap_bitmap_good( new, newpal, -1, SuperX );
869                         
870                                 new->avg_color = compute_average_pixel(new);
871                         
872 #ifdef EDITOR
873                                         if ( FindArg("-macdata") )
874                                                 swap_0_255( new );
875 #endif
876                                 if ( !BigPig )  gr_bitmap_rle_compress( new );
877
878                                 if (new->bm_flags & BM_FLAG_RLE)
879                                         size = *((int *) new->bm_data);
880                                 else
881                                         size = new->bm_w * new->bm_h;
882
883                                 memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],new->bm_data,size);
884                                 d_free(new->bm_data);
885                                 new->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
886                                 Piggy_bitmap_cache_next += size;
887
888                                 GameBitmaps[i] = *new;
889         
890                                 d_free( new );
891
892                                 // -- mprintf( (0, "U" ));
893                         }
894                 }
895
896                 //@@Dont' do these things which are done when writing
897                 //@@for (i=0; i < Num_bitmap_files; i++ )       {
898                 //@@    bitmap_index bi;
899                 //@@    bi.index = i;
900                 //@@    PIGGY_PAGE_IN( bi );
901                 //@@}
902                 //@@
903                 //@@piggy_close_file();
904
905                 piggy_write_pigfile(pigname);
906
907                 Current_pigfile[0] = 0;                 //say no pig, to force reload
908
909                 piggy_new_pigfile(pigname);             //read in just-generated pig
910
911
912         }
913         #endif  //ifdef EDITOR
914
915 }
916
917 ubyte bogus_data[64*64];
918 grs_bitmap bogus_bitmap;
919 ubyte bogus_bitmap_initialized=0;
920 digi_sound bogus_sound;
921
922 #define HAMFILE_ID              MAKE_SIG('!','M','A','H') //HAM!
923 #ifdef SHAREWARE
924 #define HAMFILE_VERSION 2
925 #else
926 #define HAMFILE_VERSION 3
927 #endif
928 //version 1 -> 2:  save marker_model_num
929 //version 2 -> 3:  removed sound files
930
931 #define SNDFILE_ID              MAKE_SIG('D','N','S','D') //DSND
932 #define SNDFILE_VERSION 1
933
934 int read_hamfile()
935 {
936         CFILE * ham_fp = NULL;
937         int ham_id,ham_version;
938         int sound_offset = 0;
939         #ifdef MACINTOSH
940         char name[255];
941         #endif
942
943         #ifndef MACINTOSH
944         ham_fp = cfopen( DEFAULT_HAMFILE, "rb" );
945         #else
946         sprintf(name, ":Data:%s", DEFAULT_HAMFILE );
947         ham_fp = cfopen( name, "rb" );
948         #endif
949
950         if (ham_fp == NULL) {
951                 Must_write_hamfile = 1;
952                 return 0;
953         }
954
955         //make sure ham is valid type file & is up-to-date
956         ham_id = cfile_read_int(ham_fp);
957         ham_version = cfile_read_int(ham_fp);
958         if (ham_id != HAMFILE_ID || ham_version != HAMFILE_VERSION) {
959                 Must_write_hamfile = 1;
960                 cfclose(ham_fp);                                                //out of date ham
961                 return 0;
962         }
963
964         if (ham_version < 3) // hamfile contains sound info
965                 sound_offset = cfile_read_int(ham_fp);
966
967         #ifndef EDITOR
968         {
969                 //int i;
970
971                 bm_read_all(ham_fp, ham_version);
972                 cfread( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
973                 // no swap here?
974                 //for (i = 0; i < MAX_BITMAP_FILES; i++) {
975                         //GameBitmapXlat[i] = INTEL_SHORT(GameBitmapXlat[i]);
976                         //printf("GameBitmapXlat[%d] = %d\n", i, GameBitmapXlat[i]);
977                 //}
978         }
979         #endif
980
981         if (ham_version < 3) {
982                 int N_sounds;
983                 int sound_start;
984                 int header_size;
985                 int i;
986                 DiskSoundHeader sndh;
987                 digi_sound temp_sound;
988                 char temp_name_read[16];
989                 int sbytes = 0;
990
991                 cfseek(ham_fp, sound_offset, SEEK_SET);
992                 N_sounds = cfile_read_int(ham_fp);
993
994                 sound_start = cftell(ham_fp);
995
996                 header_size = N_sounds * DISKSOUNDHEADER_SIZE;
997
998                 //Read sounds
999
1000                 for (i=0; i<N_sounds; i++ ) {
1001                         DiskSoundHeader_read(&sndh, ham_fp);
1002                         temp_sound.length = sndh.length;
1003                         temp_sound.data = (ubyte *)(sndh.offset + header_size + sound_start);
1004                         SoundOffset[Num_sound_files] = sndh.offset + header_size + sound_start;
1005                         memcpy( temp_name_read, sndh.name, 8 );
1006                         temp_name_read[8] = 0;
1007                         piggy_register_sound( &temp_sound, temp_name_read, 1 );
1008 #ifdef MACINTOSH
1009                         if (piggy_is_needed(i))
1010 #endif          // note link to if.
1011                                 sbytes += sndh.length;
1012                         //mprintf(( 0, "%d bytes of sound\n", sbytes ));
1013                 }
1014
1015                 SoundBits = d_malloc( sbytes + 16 );
1016                 if ( SoundBits == NULL )
1017                         Error( "Not enough memory to load sounds\n" );
1018
1019                 mprintf(( 0, "\nBitmaps: %d KB   Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
1020
1021                 //      piggy_read_sounds(ham_fp);
1022
1023         }
1024
1025         cfclose(ham_fp);
1026
1027         return 1;
1028
1029 }
1030
1031 int read_sndfile()
1032 {
1033         CFILE * snd_fp = NULL;
1034         int snd_id,snd_version;
1035         int N_sounds;
1036         int sound_start;
1037         int header_size;
1038         int i,size, length;
1039         DiskSoundHeader sndh;
1040         digi_sound temp_sound;
1041         char temp_name_read[16];
1042         int sbytes = 0;
1043         #ifdef MACINTOSH
1044         char name[255];
1045         #endif
1046
1047         #ifndef MACINTOSH
1048         snd_fp = cfopen( DEFAULT_SNDFILE, "rb" );
1049         #else
1050         sprintf( name, ":Data:%s", DEFAULT_SNDFILE );
1051         snd_fp = cfopen( name, "rb");
1052         #endif
1053         
1054         if (snd_fp == NULL)
1055                 return 0;
1056
1057         //make sure soundfile is valid type file & is up-to-date
1058         snd_id = cfile_read_int(snd_fp);
1059         snd_version = cfile_read_int(snd_fp);
1060         if (snd_id != SNDFILE_ID || snd_version != SNDFILE_VERSION) {
1061                 cfclose(snd_fp);                                                //out of date sound file
1062                 return 0;
1063         }
1064
1065         N_sounds = cfile_read_int(snd_fp);
1066
1067         sound_start = cftell(snd_fp);
1068         size = cfilelength(snd_fp) - sound_start;
1069         length = size;
1070         mprintf( (0, "\nReading data (%d KB) ", size/1024 ));
1071
1072         header_size = N_sounds*sizeof(DiskSoundHeader);
1073
1074         //Read sounds
1075
1076         for (i=0; i<N_sounds; i++ ) {
1077                 DiskSoundHeader_read(&sndh, snd_fp);
1078                 //size -= sizeof(DiskSoundHeader);
1079                 temp_sound.length = sndh.length;
1080                 temp_sound.data = (ubyte *)(sndh.offset + header_size + sound_start);
1081                 SoundOffset[Num_sound_files] = sndh.offset + header_size + sound_start;
1082                 memcpy( temp_name_read, sndh.name, 8 );
1083                 temp_name_read[8] = 0;
1084                 piggy_register_sound( &temp_sound, temp_name_read, 1 );
1085                 #ifdef MACINTOSH
1086                 if (piggy_is_needed(i))
1087                 #endif          // note link to if.
1088                 sbytes += sndh.length;
1089                 //mprintf(( 0, "%d bytes of sound\n", sbytes ));
1090         }
1091
1092         SoundBits = d_malloc( sbytes + 16 );
1093         if ( SoundBits == NULL )
1094                 Error( "Not enough memory to load sounds\n" );
1095
1096         mprintf(( 0, "\nBitmaps: %d KB   Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
1097
1098 //      piggy_read_sounds(snd_fp);
1099
1100         cfclose(snd_fp);
1101
1102         return 1;
1103 }
1104
1105 int piggy_init(void)
1106 {
1107         int ham_ok=0,snd_ok=0;
1108         int i;
1109
1110         hashtable_init( &AllBitmapsNames, MAX_BITMAP_FILES );
1111         hashtable_init( &AllDigiSndNames, MAX_SOUND_FILES );
1112
1113         for (i=0; i<MAX_SOUND_FILES; i++ )      {
1114                 GameSounds[i].length = 0;
1115                 GameSounds[i].data = NULL;
1116                 SoundOffset[i] = 0;
1117         }
1118
1119         for (i=0; i<MAX_BITMAP_FILES; i++ )     
1120                 GameBitmapXlat[i] = i;
1121
1122         if ( !bogus_bitmap_initialized )        {
1123                 int i;
1124                 ubyte c;
1125                 bogus_bitmap_initialized = 1;
1126                 memset( &bogus_bitmap, 0, sizeof(grs_bitmap) );
1127                 bogus_bitmap.bm_w = bogus_bitmap.bm_h = bogus_bitmap.bm_rowsize = 64;
1128                 bogus_bitmap.bm_data = bogus_data;
1129                 c = gr_find_closest_color( 0, 0, 63 );
1130                 for (i=0; i<4096; i++ ) bogus_data[i] = c;
1131                 c = gr_find_closest_color( 63, 0, 0 );
1132                 // Make a big red X !
1133                 for (i=0; i<64; i++ )   {
1134                         bogus_data[i*64+i] = c;
1135                         bogus_data[i*64+(63-i)] = c;
1136                 }
1137                 piggy_register_bitmap( &bogus_bitmap, "bogus", 1 );
1138                 bogus_sound.length = 64*64;
1139                 bogus_sound.data = bogus_data;
1140                 GameBitmapOffset[0] = 0;
1141         }
1142
1143         if ( FindArg( "-bigpig" ))
1144                 BigPig = 1;
1145
1146         if ( FindArg( "-lowmem" ))
1147                 piggy_low_memory = 1;
1148
1149         if ( FindArg( "-nolowmem" ))
1150                 piggy_low_memory = 0;
1151
1152         if (piggy_low_memory)
1153                 digi_lomem = 1;
1154
1155         WIN(DDGRLOCK(dd_grd_curcanv));
1156                 gr_set_curfont( SMALL_FONT );
1157                 gr_set_fontcolor(gr_find_closest_color_current( 20, 20, 20 ),-1 );
1158                 gr_printf( 0x8000, grd_curcanv->cv_h-20, "%s...", TXT_LOADING_DATA );
1159         WIN(DDGRUNLOCK(dd_grd_curcanv));
1160
1161         #ifdef EDITOR
1162         piggy_init_pigfile(DEFAULT_PIGFILE);
1163         #endif
1164
1165 #ifndef SHAREWARE
1166         ham_ok = read_hamfile();
1167         snd_ok = read_sndfile();
1168 #else
1169         snd_ok = ham_ok = read_hamfile();
1170 #endif
1171
1172         atexit(piggy_close);
1173
1174         mprintf ((0,"HamOk=%d SndOk=%d\n",ham_ok,snd_ok));
1175         return (ham_ok && snd_ok);               //read ok
1176 }
1177
1178 int piggy_is_needed(int soundnum)
1179 {
1180         int i;
1181
1182         if ( !digi_lomem ) return 1;
1183
1184         for (i=0; i<MAX_SOUNDS; i++ )   {
1185                 if ( (AltSounds[i] < 255) && (Sounds[AltSounds[i]] == soundnum) )
1186                         return 1;
1187         }
1188         return 0;
1189 }
1190
1191
1192 void piggy_read_sounds(void)
1193 {
1194         CFILE * fp = NULL;
1195         ubyte * ptr;
1196         int i, sbytes;
1197         #ifdef MACINTOSH
1198         char name[255];
1199         #endif
1200
1201         ptr = SoundBits;
1202         sbytes = 0;
1203
1204         #ifndef MACINTOSH
1205         fp = cfopen( DEFAULT_SNDFILE, "rb" );
1206         #else
1207         sprintf( name, ":Data:%s", DEFAULT_SNDFILE );
1208         fp = cfopen( name, "rb");
1209         #endif
1210
1211         if (fp == NULL)
1212                 return;
1213
1214         for (i=0; i<Num_sound_files; i++ )      {
1215                 digi_sound *snd = &GameSounds[i];
1216
1217                 if ( SoundOffset[i] > 0 )       {
1218                         if ( piggy_is_needed(i) )       {
1219                                 cfseek( fp, SoundOffset[i], SEEK_SET );
1220         
1221                                 // Read in the sound data!!!
1222                                 snd->data = ptr;
1223                                 ptr += snd->length;
1224                                 sbytes += snd->length;
1225                                 cfread( snd->data, snd->length, 1, fp );
1226                         }
1227                         else
1228                                 snd->data = (ubyte *) -1;
1229                 }
1230         }
1231
1232         cfclose(fp);
1233
1234         mprintf(( 0, "\nActual Sound usage: %d KB\n", sbytes/1024 ));
1235
1236 }
1237
1238
1239 extern int descent_critical_error;
1240 extern unsigned descent_critical_deverror;
1241 extern unsigned descent_critical_errcode;
1242
1243 char * crit_errors[13] = { "Write Protected", "Unknown Unit", "Drive Not Ready", "Unknown Command", "CRC Error", \
1244 "Bad struct length", "Seek Error", "Unknown media type", "Sector not found", "Printer out of paper", "Write Fault", \
1245 "Read fault", "General Failure" };
1246
1247 void piggy_critical_error()
1248 {
1249         grs_canvas * save_canv;
1250         grs_font * save_font;
1251         int i;
1252         save_canv = grd_curcanv;
1253         save_font = grd_curcanv->cv_font;
1254         gr_palette_load( gr_palette );
1255         i = nm_messagebox( "Disk Error", 2, "Retry", "Exit", "%s\non drive %c:", crit_errors[descent_critical_errcode&0xf], (descent_critical_deverror&0xf)+'A'  );
1256         if ( i == 1 )
1257                 exit(1);
1258         gr_set_current_canvas(save_canv);
1259         grd_curcanv->cv_font = save_font;
1260 }
1261
1262 void piggy_bitmap_page_in( bitmap_index bitmap )
1263 {
1264         grs_bitmap * bmp;
1265         int i,org_i,temp;
1266
1267         org_i = 0;
1268                         
1269         i = bitmap.index;
1270         Assert( i >= 0 );
1271         Assert( i < MAX_BITMAP_FILES );
1272         Assert( i < Num_bitmap_files );
1273         Assert( Piggy_bitmap_cache_size > 0 );
1274
1275         if ( i < 1 ) return;
1276         if ( i >= MAX_BITMAP_FILES ) return;
1277         if ( i >= Num_bitmap_files ) return;
1278         
1279         if ( GameBitmapOffset[i] == 0 ) return;         // A read-from-disk bitmap!!!
1280
1281         if ( piggy_low_memory ) {
1282                 org_i = i;
1283                 i = GameBitmapXlat[i];          // Xlat for low-memory settings!
1284         }
1285         
1286         bmp = &GameBitmaps[i];
1287
1288         if ( bmp->bm_flags & BM_FLAG_PAGED_OUT )        {
1289                 stop_time();
1290
1291         ReDoIt:
1292                 descent_critical_error = 0;
1293                 cfseek( Piggy_fp, GameBitmapOffset[i], SEEK_SET );
1294                 if ( descent_critical_error )   {
1295                         piggy_critical_error();
1296                         goto ReDoIt;
1297                 }
1298                 
1299                 bmp->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1300                 bmp->bm_flags = GameBitmapFlags[i];
1301         
1302                 if ( bmp->bm_flags & BM_FLAG_RLE )      {
1303                         int zsize = 0;
1304                         descent_critical_error = 0;
1305                         zsize = cfile_read_int(Piggy_fp);
1306                         if ( descent_critical_error )   {
1307                                 piggy_critical_error();
1308                                 goto ReDoIt;
1309                         }
1310         
1311                         // GET JOHN NOW IF YOU GET THIS ASSERT!!!
1312                         //Assert( Piggy_bitmap_cache_next+zsize < Piggy_bitmap_cache_size );      
1313                         if ( Piggy_bitmap_cache_next+zsize >= Piggy_bitmap_cache_size ) {
1314                                 Int3();
1315                                 piggy_bitmap_page_out_all();
1316                                 goto ReDoIt;
1317                         }
1318                         memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], &zsize, sizeof(int) );
1319                         Piggy_bitmap_cache_next += sizeof(int);
1320                         descent_critical_error = 0;
1321                         temp = cfread( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], 1, zsize-4, Piggy_fp );
1322                         if ( descent_critical_error )   {
1323                                 piggy_critical_error();
1324                                 goto ReDoIt;
1325                         }
1326                         Piggy_bitmap_cache_next += zsize-4;
1327                 } else {
1328                         // GET JOHN NOW IF YOU GET THIS ASSERT!!!
1329                         Assert( Piggy_bitmap_cache_next+(bmp->bm_h*bmp->bm_w) < Piggy_bitmap_cache_size );      
1330                         if ( Piggy_bitmap_cache_next+(bmp->bm_h*bmp->bm_w) >= Piggy_bitmap_cache_size ) {
1331                                 piggy_bitmap_page_out_all();
1332                                 goto ReDoIt;
1333                         }
1334                         descent_critical_error = 0;
1335                         temp = cfread( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], 1, bmp->bm_h*bmp->bm_w, Piggy_fp );
1336                         if ( descent_critical_error )   {
1337                                 piggy_critical_error();
1338                                 goto ReDoIt;
1339                         }
1340                         Piggy_bitmap_cache_next+=bmp->bm_h*bmp->bm_w;
1341                 }
1342         
1343                 //@@if ( bmp->bm_selector ) {
1344                 //@@#if !defined(WINDOWS) && !defined(MACINTOSH)
1345                 //@@    if (!dpmi_modify_selector_base( bmp->bm_selector, bmp->bm_data ))
1346                 //@@            Error( "Error modifying selector base in piggy.c\n" );
1347                 //@@#endif
1348                 //@@}
1349
1350                 start_time();
1351         }
1352
1353         if ( piggy_low_memory ) {
1354                 if ( org_i != i )
1355                         GameBitmaps[org_i] = GameBitmaps[i];
1356         }
1357
1358 //@@Removed from John's code:
1359 //@@#ifndef WINDOWS
1360 //@@    if ( bmp->bm_selector ) {
1361 //@@            if (!dpmi_modify_selector_base( bmp->bm_selector, bmp->bm_data ))
1362 //@@                    Error( "Error modifying selector base in piggy.c\n" );
1363 //@@    }
1364 //@@#endif
1365
1366 }
1367
1368 void piggy_bitmap_page_out_all()
1369 {
1370         int i;
1371         
1372         Piggy_bitmap_cache_next = 0;
1373
1374         piggy_page_flushed++;
1375
1376         texmerge_flush();
1377         rle_cache_flush();
1378
1379         for (i=0; i<Num_bitmap_files; i++ )             {
1380                 if ( GameBitmapOffset[i] > 0 )  {       // Don't page out bitmaps read from disk!!!
1381                         GameBitmaps[i].bm_flags = BM_FLAG_PAGED_OUT;
1382                         GameBitmaps[i].bm_data = Piggy_bitmap_cache_data;
1383                 }
1384         }
1385
1386         mprintf(( 0, "Flushing piggy bitmap cache\n" ));
1387 }
1388
1389 void piggy_load_level_data()
1390 {
1391         piggy_bitmap_page_out_all();
1392         paging_touch_all();
1393 }
1394
1395 #ifdef EDITOR
1396
1397 void change_filename_ext( char *dest, char *src, char *ext );
1398
1399 void piggy_write_pigfile(char *filename)
1400 {
1401         FILE *pig_fp;
1402         int bitmap_data_start,data_offset;
1403         DiskBitmapHeader bmh;
1404         int org_offset;
1405         char subst_name[32];
1406         int i;
1407         FILE *fp1,*fp2;
1408         char tname[FILENAME_LEN];
1409
1410         // -- mprintf( (0, "Paging in all piggy bitmaps..." ));
1411         for (i=0; i < Num_bitmap_files; i++ )   {
1412                 bitmap_index bi;
1413                 bi.index = i;
1414                 PIGGY_PAGE_IN( bi );
1415         }
1416         // -- mprintf( (0, "\n" ));
1417
1418         piggy_close_file();
1419
1420         // -- mprintf( (0, "Creating %s...",filename ));
1421
1422         pig_fp = fopen( filename, "wb" );       //open PIG file
1423         Assert( pig_fp!=NULL );
1424
1425         write_int(PIGFILE_ID,pig_fp);
1426         write_int(PIGFILE_VERSION,pig_fp);
1427
1428         Num_bitmap_files--;
1429         fwrite( &Num_bitmap_files, sizeof(int), 1, pig_fp );
1430         Num_bitmap_files++;
1431
1432         bitmap_data_start = ftell(pig_fp);
1433         bitmap_data_start += (Num_bitmap_files-1)*DISKBITMAPHEADER_SIZE; 
1434         data_offset = bitmap_data_start;
1435
1436         change_filename_ext(tname,filename,"lst");
1437         fp1 = fopen( tname, "wt" );
1438         change_filename_ext(tname,filename,"all");
1439         fp2 = fopen( tname, "wt" );
1440
1441         for (i=1; i < Num_bitmap_files; i++ )   {
1442                 int *size;
1443                 grs_bitmap *bmp;
1444
1445                 {               
1446                         char * p, *p1;
1447                         p = strchr(AllBitmaps[i].name,'#');
1448                         if (p)  {
1449                                 int n;
1450                                 p1 = p; p1++; 
1451                                 n = atoi(p1);
1452                                 *p = 0;
1453                                 if (fp2 && n==0)
1454                                         fprintf( fp2, "%s.abm\n", AllBitmaps[i].name );
1455                                 memcpy( bmh.name, AllBitmaps[i].name, 8 );
1456                                 Assert( n <= 63 );
1457                                 bmh.dflags = DBM_FLAG_ABM + n;
1458                                 *p = '#';
1459                         }else {
1460                                 if (fp2)
1461                                         fprintf( fp2, "%s.bbm\n", AllBitmaps[i].name );
1462                                 memcpy( bmh.name, AllBitmaps[i].name, 8 );
1463                                 bmh.dflags = 0;
1464                         }
1465                 }
1466                 bmp = &GameBitmaps[i];
1467
1468                 Assert( !(bmp->bm_flags&BM_FLAG_PAGED_OUT) );
1469
1470                 if (fp1)
1471                         fprintf( fp1, "BMP: %s, size %d bytes", AllBitmaps[i].name, bmp->bm_rowsize * bmp->bm_h );
1472                 org_offset = ftell(pig_fp);
1473                 bmh.offset = data_offset - bitmap_data_start;
1474                 fseek( pig_fp, data_offset, SEEK_SET );
1475
1476                 if ( bmp->bm_flags & BM_FLAG_RLE )      {
1477                         size = (int *)bmp->bm_data;
1478                         fwrite( bmp->bm_data, sizeof(ubyte), *size, pig_fp );
1479                         data_offset += *size;
1480                         if (fp1)
1481                                 fprintf( fp1, ", and is already compressed to %d bytes.\n", *size );
1482                 } else {
1483                         fwrite( bmp->bm_data, sizeof(ubyte), bmp->bm_rowsize * bmp->bm_h, pig_fp );
1484                         data_offset += bmp->bm_rowsize * bmp->bm_h;
1485                         if (fp1)
1486                                 fprintf( fp1, ".\n" );
1487                 }
1488                 fseek( pig_fp, org_offset, SEEK_SET );
1489                 Assert( GameBitmaps[i].bm_w < 4096 );
1490                 bmh.width = (GameBitmaps[i].bm_w & 0xff);
1491                 bmh.wh_extra = ((GameBitmaps[i].bm_w >> 8) & 0x0f);
1492                 Assert( GameBitmaps[i].bm_h < 4096 );
1493                 bmh.height = GameBitmaps[i].bm_h;
1494                 bmh.wh_extra |= ((GameBitmaps[i].bm_h >> 4) & 0xf0);
1495                 bmh.flags = GameBitmaps[i].bm_flags;
1496                 if (piggy_is_substitutable_bitmap( AllBitmaps[i].name, subst_name ))    {
1497                         bitmap_index other_bitmap;
1498                         other_bitmap = piggy_find_bitmap( subst_name );
1499                         GameBitmapXlat[i] = other_bitmap.index;
1500                         bmh.flags |= BM_FLAG_PAGED_OUT;
1501                         //mprintf(( 0, "Skipping bitmap %d\n", i ));
1502                         //mprintf(( 0, "Marking '%s' as substitutible\n", AllBitmaps[i].name ));
1503                 } else  {
1504                         bmh.flags &= ~BM_FLAG_PAGED_OUT;
1505                 }
1506                 bmh.avg_color=GameBitmaps[i].avg_color;
1507                 fwrite( &bmh, DISKBITMAPHEADER_SIZE, 1, pig_fp );                    // Mark as a bitmap
1508         }
1509
1510         fclose(pig_fp);
1511
1512         mprintf( (0, " Dumped %d assorted bitmaps.\n", Num_bitmap_files ));
1513         fprintf( fp1, " Dumped %d assorted bitmaps.\n", Num_bitmap_files );
1514
1515         fclose(fp1);
1516         fclose(fp2);
1517
1518 }
1519
1520 static void write_int(int i,FILE *file)
1521 {
1522         if (fwrite( &i, sizeof(i), 1, file) != 1)
1523                 Error( "Error reading int in gamesave.c" );
1524
1525 }
1526
1527 void piggy_dump_all()
1528 {
1529         int i, xlat_offset;
1530         FILE * ham_fp;
1531         int org_offset,data_offset=0;
1532         DiskSoundHeader sndh;
1533         int sound_data_start=0;
1534         FILE *fp1,*fp2;
1535
1536         #ifdef NO_DUMP_SOUNDS
1537         Num_sound_files = 0;
1538         Num_sound_files_new = 0;
1539         #endif
1540
1541         if (!Must_write_hamfile && (Num_bitmap_files_new == 0) && (Num_sound_files_new == 0) )
1542                 return;
1543
1544         fp1 = fopen( "ham.lst", "wt" );
1545         fp2 = fopen( "ham.all", "wt" );
1546
1547         if (Must_write_hamfile || Num_bitmap_files_new) {
1548
1549                 mprintf( (0, "Creating %s...",DEFAULT_HAMFILE));
1550         
1551                 ham_fp = fopen( DEFAULT_HAMFILE, "wb" );                       //open HAM file
1552                 Assert( ham_fp!=NULL );
1553         
1554                 write_int(HAMFILE_ID,ham_fp);
1555                 write_int(HAMFILE_VERSION,ham_fp);
1556         
1557                 bm_write_all(ham_fp);
1558                 xlat_offset = ftell(ham_fp);
1559                 fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1560                 //Dump bitmaps
1561         
1562                 if (Num_bitmap_files_new)
1563                         piggy_write_pigfile(DEFAULT_PIGFILE);
1564         
1565                 //free up memeory used by new bitmaps
1566                 for (i=Num_bitmap_files-Num_bitmap_files_new;i<Num_bitmap_files;i++)
1567                         d_free(GameBitmaps[i].bm_data);
1568         
1569                 //next thing must be done after pig written
1570                 fseek( ham_fp, xlat_offset, SEEK_SET );
1571                 fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1572         
1573                 fclose(ham_fp);
1574                 mprintf( (0, "\n" ));
1575         }
1576         
1577         if (Num_sound_files_new) {
1578
1579                 mprintf( (0, "Creating %s...",DEFAULT_HAMFILE));
1580                 // Now dump sound file
1581                 ham_fp = fopen( DEFAULT_SNDFILE, "wb" );
1582                 Assert( ham_fp!=NULL );
1583         
1584                 write_int(SNDFILE_ID,ham_fp);
1585                 write_int(SNDFILE_VERSION,ham_fp);
1586
1587                 fwrite( &Num_sound_files, sizeof(int), 1, ham_fp );
1588         
1589                 mprintf( (0, "\nDumping sounds..." ));
1590         
1591                 sound_data_start = ftell(ham_fp);
1592                 sound_data_start += Num_sound_files*sizeof(DiskSoundHeader);
1593                 data_offset = sound_data_start;
1594         
1595                 for (i=0; i < Num_sound_files; i++ )    {
1596                         digi_sound *snd;
1597         
1598                         snd = &GameSounds[i];
1599                         strcpy( sndh.name, AllSounds[i].name );
1600                         sndh.length = GameSounds[i].length;
1601                         sndh.offset = data_offset - sound_data_start;
1602         
1603                         org_offset = ftell(ham_fp);
1604                         fseek( ham_fp, data_offset, SEEK_SET );
1605         
1606                         sndh.data_length = GameSounds[i].length;
1607                         fwrite( snd->data, sizeof(ubyte), snd->length, ham_fp );
1608                         data_offset += snd->length;
1609                         fseek( ham_fp, org_offset, SEEK_SET );
1610                         fwrite( &sndh, sizeof(DiskSoundHeader), 1, ham_fp );                    // Mark as a bitmap
1611         
1612                         fprintf( fp1, "SND: %s, size %d bytes\n", AllSounds[i].name, snd->length );
1613                         fprintf( fp2, "%s.raw\n", AllSounds[i].name );
1614                 }
1615
1616                 fclose(ham_fp);
1617                 mprintf( (0, "\n" ));
1618         }
1619
1620         fprintf( fp1, "Total sound size: %d bytes\n", data_offset-sound_data_start);
1621         mprintf( (0, " Dumped %d assorted sounds.\n", Num_sound_files ));
1622         fprintf( fp1, " Dumped %d assorted sounds.\n", Num_sound_files );
1623
1624         fclose(fp1);
1625         fclose(fp2);
1626
1627         // Never allow the game to run after building ham.
1628         exit(0);
1629 }
1630
1631 #endif
1632
1633 void piggy_close()
1634 {
1635         piggy_close_file();
1636
1637         if (BitmapBits)
1638                 d_free(BitmapBits);
1639
1640         if ( SoundBits )
1641                 d_free( SoundBits );
1642
1643         hashtable_free( &AllBitmapsNames );
1644         hashtable_free( &AllDigiSndNames );
1645
1646 }
1647
1648 int piggy_does_bitmap_exist_slow( char * name )
1649 {
1650         int i;
1651
1652         for (i=0; i<Num_bitmap_files; i++ )     {
1653                 if ( !strcmp( AllBitmaps[i].name, name) )
1654                         return 1;
1655         }
1656         return 0;
1657 }
1658
1659
1660 #define NUM_GAUGE_BITMAPS 23
1661 char * gauge_bitmap_names[NUM_GAUGE_BITMAPS] = {
1662         "gauge01", "gauge01b",
1663         "gauge02", "gauge02b",
1664         "gauge06", "gauge06b",
1665         "targ01", "targ01b",
1666         "targ02", "targ02b", 
1667         "targ03", "targ03b",
1668         "targ04", "targ04b",
1669         "targ05", "targ05b",
1670         "targ06", "targ06b",
1671         "gauge18", "gauge18b",
1672         "gauss1", "helix1",
1673         "phoenix1"
1674 };
1675
1676
1677 int piggy_is_gauge_bitmap( char * base_name )
1678 {
1679         int i;
1680         for (i=0; i<NUM_GAUGE_BITMAPS; i++ )    {
1681                 if ( !stricmp( base_name, gauge_bitmap_names[i] ))      
1682                         return 1;
1683         }
1684
1685         return 0;       
1686 }
1687
1688 int piggy_is_substitutable_bitmap( char * name, char * subst_name )
1689 {
1690         int frame;
1691         char * p;
1692         char base_name[ 16 ];
1693         
1694         strcpy( subst_name, name );
1695         p = strchr( subst_name, '#' );
1696         if ( p )        {
1697                 frame = atoi( &p[1] );
1698                 *p = 0;
1699                 strcpy( base_name, subst_name );
1700                 if ( !piggy_is_gauge_bitmap( base_name ))       {
1701                         sprintf( subst_name, "%s#%d", base_name, frame+1 );
1702                         if ( piggy_does_bitmap_exist_slow( subst_name )  )      {
1703                                 if ( frame & 1 ) {
1704                                         sprintf( subst_name, "%s#%d", base_name, frame-1 );
1705                                         return 1;
1706                                 }
1707                         }
1708                 }
1709         }
1710         strcpy( subst_name, name );
1711         return 0;
1712 }
1713
1714
1715
1716 #ifdef WINDOWS
1717 //      New Windows stuff
1718
1719 //      windows bitmap page in
1720 //              Page in a bitmap, if ddraw, then page it into a ddsurface in 
1721 //              'video' memory.  if that fails, page it in normally.
1722
1723 void piggy_bitmap_page_in_w( bitmap_index bitmap, int ddraw )
1724 {
1725 }
1726
1727
1728 //      Essential when switching video modes!
1729
1730 void piggy_bitmap_page_out_all_w()
1731 {
1732 }
1733
1734 #endif
1735
1736 #ifndef FAST_FILE_IO
1737 /*
1738  * reads a bitmap_index structure from a CFILE
1739  */
1740 void bitmap_index_read(bitmap_index *bi, CFILE *fp)
1741 {
1742         bi->index = cfile_read_short(fp);
1743 }
1744
1745 /*
1746  * reads n bitmap_index structs from a CFILE
1747  */
1748 int bitmap_index_read_n(bitmap_index *bi, int n, CFILE *fp)
1749 {
1750         int i;
1751
1752         for (i = 0; i < n; i++)
1753                 bi[i].index = cfile_read_short(fp);
1754         return i;
1755 }
1756
1757 /*
1758  * reads a DiskBitmapHeader structure from a CFILE
1759  */
1760 void DiskBitmapHeader_read(DiskBitmapHeader *dbh, CFILE *fp)
1761 {
1762         cfread(dbh->name, 8, 1, fp);
1763         dbh->dflags = cfile_read_byte(fp);
1764         dbh->width = cfile_read_byte(fp);
1765         dbh->height = cfile_read_byte(fp);
1766         dbh->wh_extra = cfile_read_byte(fp);
1767         dbh->flags = cfile_read_byte(fp);
1768         dbh->avg_color = cfile_read_byte(fp);
1769         dbh->offset = cfile_read_int(fp);
1770 }
1771
1772 /*
1773  * reads a DiskSoundHeader structure from a CFILE
1774  */
1775 void DiskSoundHeader_read(DiskSoundHeader *dsh, CFILE *fp)
1776 {
1777         cfread(dsh->name, 8, 1, fp);
1778         dsh->length = cfile_read_int(fp);
1779         dsh->data_length = cfile_read_int(fp);
1780         dsh->offset = cfile_read_int(fp);
1781 }
1782 #endif