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