main/piggy.c

   1 /* $Id: piggy.c,v 1.31 2003-03-29 22:35:00 btb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * Functions for managing the pig files.
  18  *
  19  * Old Log:
  20  * Revision 1.16  1995/11/09  17:27:47  allender
  21  * put in missing quote on new gauge name
  22  *
  23  * Revision 1.15  1995/11/08  17:28:03  allender
  24  * add PC gauges to gauge list of non-substitutatble bitmaps
  25  *
  26  * Revision 1.14  1995/11/08  15:14:49  allender
  27  * fixed horrible bug where the piggy cache size was incorrect
  28  * for mac shareware
  29  *
  30  * Revision 1.13  1995/11/03  12:53:37  allender
  31  * shareware changes
  32  *
  33  * Revision 1.12  1995/10/21  22:25:14  allender
  34  * added bald guy cheat
  35  *
  36  * Revision 1.11  1995/10/20  22:42:15  allender
  37  * changed load path of descent.pig to :data:descent.pig
  38  *
  39  * Revision 1.10  1995/10/20  00:08:01  allender
  40  * put in event loop calls when loading data (hides it nicely
  41  * from user) so TM can get it's strokes stuff
  42  *
  43  * Revision 1.9  1995/09/13  08:48:01  allender
  44  * added lower memory requirement to load alternate bitmaps
  45  *
  46  * Revision 1.8  1995/08/16  09:39:13  allender
  47  * moved "loading" text up a little
  48  *
  49  * Revision 1.7  1995/08/08  13:54:26  allender
  50  * added macsys header file
  51  *
  52  * Revision 1.6  1995/07/12  12:49:56  allender
  53  * total hack for bitmaps > 512 bytes wide -- check these by name
  54  *
  55  * Revision 1.5  1995/07/05  16:47:05  allender
  56  * kitchen stuff
  57  *
  58  * Revision 1.4  1995/06/23  08:55:28  allender
  59  * make "loading data" text y loc based off of curcanv
  60  *
  61  * Revision 1.3  1995/06/08  14:08:52  allender
  62  * PPC aligned data sets
  63  *
  64  * Revision 1.2  1995/05/26  06:54:27  allender
  65  * removed refences to sound data at end of pig file (since they will
  66  * now be Macintosh snd resources for effects
  67  *
  68  * Revision 1.1  1995/05/16  15:29:51  allender
  69  * Initial revision
  70  *
  71  * Revision 2.10  1995/10/07  13:17:26  john
  72  * Made all bitmaps paged out by default.
  73  *
  74  * Revision 2.9  1995/04/14  14:05:24  john
  75  * *** empty log message ***
  76  *
  77  * Revision 2.8  1995/04/12  13:39:37  john
  78  * Fixed bug with -lowmem not working.
  79  *
  80  * Revision 2.7  1995/03/29  23:23:17  john
  81  * Fixed major bug with sounds not building into pig right.
  82  *
  83  * Revision 2.6  1995/03/28  18:05:00  john
  84  * Fixed it so you don't have to delete pig after changing bitmaps.tbl
  85  *
  86  * Revision 2.5  1995/03/16  23:13:06  john
  87  * Fixed bug with piggy paging in bitmap not checking for disk
  88  * error, hence bogifying textures if you pull the CD out.
  89  *
  90  * Revision 2.4  1995/03/14  16:22:27  john
  91  * Added cdrom alternate directory stuff.
  92  *
  93  * Revision 2.3  1995/03/06  15:23:20  john
  94  * New screen techniques.
  95  *
  96  * Revision 2.2  1995/02/27  13:13:40  john
  97  * Removed floating point.
  98  *
  99  * Revision 2.1  1995/02/27  12:31:25  john
 100  * Made work without editor.
 101  *
 102  * Revision 2.0  1995/02/27  11:28:02  john
 103  * New version 2.0, which has no anonymous unions, builds with
 104  * Watcom 10.0, and doesn't require parsing BITMAPS.TBL.
 105  *
 106  * Revision 1.85  1995/02/09  12:54:24  john
 107  * Made paged out bitmaps have bm_data be a valid pointer
 108  * instead of NULL, in case anyone accesses it.
 109  *
 110  * Revision 1.84  1995/02/09  12:50:59  john
 111  * Bullet-proofed the piggy loading code.
 112  *
 113  * Revision 1.83  1995/02/07  17:08:51  john
 114  * Added some error handling stuff instead of asserts.
 115  *
 116  * Revision 1.82  1995/02/03  17:06:48  john
 117  * Changed sound stuff to allow low memory usage.
 118  * Also, changed so that Sounds isn't an array of digi_sounds, it
 119  * is a ubyte pointing into GameSounds, this way the digi.c code that
 120  * locks sounds won't accidentally unlock a sound that is already playing, but
 121  * since it's Sounds[soundno] is different, it would erroneously be unlocked.
 122  *
 123  * Revision 1.81  1995/02/02  21:56:39  matt
 124  * Added data for new gauge bitmaps
 125  *
 126  * Revision 1.80  1995/02/01  23:31:57  john
 127  * Took out loading bar.
 128  *
 129  * Revision 1.79  1995/01/28  15:13:18  allender
 130  * bumped up Piggy_bitmap_cache_size
 131  *
 132  * Revision 1.78  1995/01/26  12:30:43  john
 133  * Took out prev.
 134  *
 135  * Revision 1.77  1995/01/26  12:12:17  john
 136  * Made buffer be big for bitmaps.
 137  *
 138  * Revision 1.76  1995/01/25  20:15:38  john
 139  * Made editor allocate all mem.
 140  *
 141  * Revision 1.75  1995/01/25  14:52:56  john
 142  * Made bitmap buffer be 1.5 MB.
 143  *
 144  * Revision 1.74  1995/01/22  16:03:19  mike
 145  * localization.
 146  *
 147  * Revision 1.73  1995/01/22  15:58:36  mike
 148  * localization
 149  *
 150  * Revision 1.72  1995/01/18  20:51:20  john
 151  * Took out warnings.
 152  *
 153  * Revision 1.71  1995/01/18  20:47:21  john
 154  * Added code to allocate sounds & bitmaps into diff
 155  * buffers, also made sounds not be compressed for registered.
 156  *
 157  * Revision 1.70  1995/01/18  15:08:41  john
 158  * Added start/stop time around paging.
 159  * Made paging clear screen around globe.
 160  *
 161  * Revision 1.69  1995/01/18  10:07:51  john
 162  *
 163  * Took out debugging mprintfs.
 164  *
 165  * Revision 1.68  1995/01/17  14:27:42  john
 166  * y
 167  *
 168  * Revision 1.67  1995/01/17  12:14:39  john
 169  * Made walls, object explosion vclips load at level start.
 170  *
 171  * Revision 1.66  1995/01/15  13:15:44  john
 172  * Made so that paging always happens, lowmem just loads less.
 173  * Also, make KB load print to hud.
 174  *
 175  * Revision 1.65  1995/01/15  11:56:28  john
 176  * Working version of paging.
 177  *
 178  * Revision 1.64  1995/01/14  19:17:07  john
 179  * First version of new bitmap paging code.
 180  *
 181  * Revision 1.63  1994/12/15  12:26:44  john
 182  * Added -nolowmem function.
 183  *
 184  * Revision 1.62  1994/12/14  21:12:26  john
 185  * Fixed bug with page fault when exiting and using
 186  * -nosound.
 187  *
 188  * Revision 1.61  1994/12/14  11:35:31  john
 189  * Evened out thermometer for pig read.
 190  *
 191  * Revision 1.60  1994/12/14  10:51:00  john
 192  * Sped up sound loading.
 193  *
 194  * Revision 1.59  1994/12/14  10:12:08  john
 195  * Sped up pig loading.
 196  *
 197  * Revision 1.58  1994/12/13  09:14:47  john
 198  * *** empty log message ***
 199  *
 200  * Revision 1.57  1994/12/13  09:12:57  john
 201  * Made the bar always fill up.
 202  *
 203  * Revision 1.56  1994/12/13  03:49:08  john
 204  * Made -lowmem not load the unnecessary bitmaps.
 205  *
 206  * Revision 1.55  1994/12/06  16:06:35  john
 207  * Took out piggy sorting.
 208  *
 209  * Revision 1.54  1994/12/06  15:11:14  john
 210  * Fixed bug with reading pigs.
 211  *
 212  * Revision 1.53  1994/12/06  14:14:47  john
 213  * Added code to set low mem based on memory.
 214  *
 215  * Revision 1.52  1994/12/06  14:01:10  john
 216  * Fixed bug that was causing -lowmem all the time..
 217  *
 218  * Revision 1.51  1994/12/06  13:33:48  john
 219  * Added lowmem option.
 220  *
 221  * Revision 1.50  1994/12/05  19:40:10  john
 222  * If -nosound or no sound card selected, don't load sounds from pig.
 223  *
 224  * Revision 1.49  1994/12/05  12:17:44  john
 225  * Added code that locks/unlocks digital sounds on demand.
 226  *
 227  * Revision 1.48  1994/12/05  11:39:03  matt
 228  * Fixed little mistake
 229  *
 230  * Revision 1.47  1994/12/05  09:29:22  john
 231  * Added clength to the sound field.
 232  *
 233  * Revision 1.46  1994/12/04  15:27:15  john
 234  * Fixed my stupid bug that looked at -nosound instead of digi_driver_card
 235  * to see whether or not to lock down sound memory.
 236  *
 237  * Revision 1.45  1994/12/03  14:17:00  john
 238  * Took out my debug mprintf.
 239  *
 240  * Revision 1.44  1994/12/03  13:32:37  john
 241  * Fixed bug with offscreen bitmap.
 242  *
 243  * Revision 1.43  1994/12/03  13:07:13  john
 244  * Made the pig read/write compressed sounds.
 245  *
 246  * Revision 1.42  1994/12/03  11:48:51  matt
 247  * Added option to not dump sounds to pigfile
 248  *
 249  * Revision 1.41  1994/12/02  20:02:20  matt
 250  * Made sound files constant match constant for table
 251  *
 252  * Revision 1.40  1994/11/29  11:03:09  adam
 253  * upped # of sounds
 254  *
 255  * Revision 1.39  1994/11/27  23:13:51  matt
 256  * Made changes for new mprintf calling convention
 257  *
 258  * Revision 1.38  1994/11/20  18:40:34  john
 259  * MAde the piggy.lst and piggy.all not dump for release.
 260  *
 261  * Revision 1.37  1994/11/19  23:54:45  mike
 262  * up number of bitmaps for shareware version.
 263  *
 264  * Revision 1.36  1994/11/19  19:53:05  mike
 265  * change MAX_BITMAP_FILES
 266  *
 267  * Revision 1.35  1994/11/19  10:42:56  matt
 268  * Increased number of bitmaps for non-shareware version
 269  *
 270  * Revision 1.34  1994/11/19  09:11:52  john
 271  * Added avg_color to bitmaps saved in pig.
 272  *
 273  * Revision 1.33  1994/11/19  00:07:05  john
 274  * Fixed bug with 8 char sound filenames not getting read from pig.
 275  *
 276  * Revision 1.32  1994/11/18  22:24:54  john
 277  * Added -bigpig command line that doesn't rle your pig.
 278  *
 279  * Revision 1.31  1994/11/18  21:56:53  john
 280  * Added a better, leaner pig format.
 281  *
 282  * Revision 1.30  1994/11/16  12:06:16  john
 283  * Fixed bug with calling .bbms abms.
 284  *
 285  * Revision 1.29  1994/11/16  12:00:56  john
 286  * Added piggy.all dump.
 287  *
 288  * Revision 1.28  1994/11/10  21:16:02  adam
 289  * nothing important
 290  *
 291  * Revision 1.27  1994/11/10  13:42:00  john
 292  * Made sounds not lock down if using -nosound.
 293  *
 294  * Revision 1.26  1994/11/09  19:55:40  john
 295  * Added full rle support with texture rle caching.
 296  *
 297  * Revision 1.25  1994/11/09  16:36:42  john
 298  * First version with RLE bitmaps in Pig.
 299  *
 300  * Revision 1.24  1994/10/27  19:42:59  john
 301  * Disable the piglet option.
 302  *
 303  * Revision 1.23  1994/10/27  18:51:40  john
 304  * Added -piglet option that only loads needed textures for a
 305  * mine.  Only saved ~1MB, and code still doesn't free textures
 306  * before you load a new mine.
 307  *
 308  * Revision 1.22  1994/10/25  13:11:42  john
 309  * Made the sounds sort. Dumped piggy.lst.
 310  *
 311  * Revision 1.21  1994/10/06  17:06:23  john
 312  * Took out rle stuff.
 313  *
 314  * Revision 1.20  1994/10/06  15:45:36  adam
 315  * bumped MAX_BITMAP_FILES again!
 316  *
 317  * Revision 1.19  1994/10/06  11:01:17  yuan
 318  * Upped MAX_BITMAP_FILES
 319  *
 320  * Revision 1.18  1994/10/06  10:44:45  john
 321  * Added diagnostic message and psuedo run-length-encoder
 322  * to see how much memory we would save by storing bitmaps
 323  * in a RLE method.  Also, I commented out the code that
 324  * stores 4K bitmaps on a 4K boundry to reduce pig size
 325  * a bit.
 326  *
 327  * Revision 1.17  1994/10/04  20:03:13  matt
 328  * Upped maximum number of bitmaps
 329  *
 330  * Revision 1.16  1994/10/03  18:04:20  john
 331  * Fixed bug with data_offset not set right for bitmaps
 332  * that are 64x64 and not aligned on a 4k boundry.
 333  *
 334  * Revision 1.15  1994/09/28  11:30:55  john
 335  * changed inferno.pig to descent.pig, changed the way it
 336  * is read.
 337  *
 338  * Revision 1.14  1994/09/22  16:14:17  john
 339  * Redid intro sequecing.
 340  *
 341  * Revision 1.13  1994/09/19  14:42:47  john
 342  * Locked down sounds with Virtual memory.
 343  *
 344  * Revision 1.12  1994/09/10  17:31:52  mike
 345  * Increase number of loadable bitmaps.
 346  *
 347  * Revision 1.11  1994/09/01  19:32:49  mike
 348  * Boost texture map allocation.
 349  *
 350  * Revision 1.10  1994/08/16  11:51:02  john
 351  * Added grwased pigs.
 352  *
 353  * Revision 1.9  1994/07/06  09:18:03  adam
 354  * upped bitmap #s
 355  *
 356  * Revision 1.8  1994/06/20  22:02:15  matt
 357  * Fixed bug from last change
 358  *
 359  * Revision 1.7  1994/06/20  21:33:18  matt
 360  * Made bm.h not include sounds.h, to reduce dependencies
 361  *
 362  * Revision 1.6  1994/06/20  16:52:19  john
 363  * cleaned up init output a bit.
 364  *
 365  * Revision 1.5  1994/06/08  14:20:57  john
 366  * Made piggy dump before going into game.
 367  *
 368  * Revision 1.4  1994/06/02  18:59:22  matt
 369  * Clear selector field of bitmap loaded from pig file
 370  *
 371  * Revision 1.3  1994/05/06  15:31:41  john
 372  * Made name field a bit longer.
 373  *
 374  * Revision 1.2  1994/05/06  13:02:44  john
 375  * Added piggy stuff; worked on supertransparency
 376  *
 377  * Revision 1.1  1994/05/06  11:47:26  john
 378  * Initial revision
 379  *
 380  *
 381  */
 382
 383
 384 #ifdef HAVE_CONFIG_H
 385 #include <conf.h>
 386 #endif
 387
 388 #ifdef RCS
 389 static char rcsid[] = "$Id: piggy.c,v 1.31 2003-03-29 22:35:00 btb Exp $";
 390 #endif
 391
 392
 393 #include <stdio.h>
 394 #include <string.h>
 395
 396 #include "pstypes.h"
 397 #include "strutil.h"
 398 #include "inferno.h"
 399 #include "gr.h"
 400 #include "u_mem.h"
 401 #include "iff.h"
 402 #include "mono.h"
 403 #include "error.h"
 404 #include "sounds.h"
 405 #include "songs.h"
 406 #include "bm.h"
 407 #include "bmread.h"
 408 #include "hash.h"
 409 #include "args.h"
 410 #include "palette.h"
 411 #include "gamefont.h"
 412 #include "rle.h"
 413 #include "screens.h"
 414 #include "piggy.h"
 415 #include "texmerge.h"
 416 #include "paging.h"
 417 #include "game.h"
 418 #include "text.h"
 419 #include "cfile.h"
 420 #include "newmenu.h"
 421 #include "byteswap.h"
 422 #include "findfile.h"
 423 #include "makesig.h"
 424
 425 #ifndef MACINTOSH
 426 //      #include "unarj.h"
 427 #else
 428         #include <Strings.h>            // MacOS Toolbox header
 429         #include <Files.h>
 430         #include <unistd.h>
 431 #endif
 432
 433 //#define NO_DUMP_SOUNDS        1   //if set, dump bitmaps but not sounds
 434
 435 #define DEFAULT_PIGFILE_REGISTERED      "groupa.pig"
 436 #define DEFAULT_PIGFILE_SHAREWARE       "d2demo.pig"
 437 #define DEFAULT_HAMFILE_REGISTERED      "descent2.ham"
 438 #define DEFAULT_HAMFILE_SHAREWARE       "d2demo.ham"
 439
 440 #define D1_PALETTE "palette.256"
 441
 442 #define DEFAULT_PIGFILE (cfexist(DEFAULT_PIGFILE_REGISTERED)?DEFAULT_PIGFILE_REGISTERED:DEFAULT_PIGFILE_SHAREWARE)
 443 #define DEFAULT_HAMFILE (cfexist(DEFAULT_HAMFILE_REGISTERED)?DEFAULT_HAMFILE_REGISTERED:DEFAULT_HAMFILE_SHAREWARE)
 444 #define DEFAULT_SNDFILE ((Piggy_hamfile_version < 3)?DEFAULT_HAMFILE_SHAREWARE:(digi_sample_rate==SAMPLE_RATE_22K)?"descent2.s22":"descent2.s11")
 445
 446 #define MAC_ALIEN1_PIGSIZE      5013035
 447 #define MAC_ALIEN2_PIGSIZE      4909916
 448 #define MAC_FIRE_PIGSIZE        4969035
 449 #define MAC_GROUPA_PIGSIZE      4929684 // also used for mac shareware
 450 #define MAC_ICE_PIGSIZE         4923425
 451 #define MAC_WATER_PIGSIZE       4832403
 452
 453 ubyte *BitmapBits = NULL;
 454 ubyte *SoundBits = NULL;
 455
 456 typedef struct BitmapFile {
 457         char    name[15];
 458 } BitmapFile;
 459
 460 typedef struct SoundFile {
 461         char    name[15];
 462 } SoundFile;
 463
 464 hashtable AllBitmapsNames;
 465 hashtable AllDigiSndNames;
 466
 467 int Num_bitmap_files = 0;
 468 int Num_sound_files = 0;
 469
 470 digi_sound GameSounds[MAX_SOUND_FILES];
 471 int SoundOffset[MAX_SOUND_FILES];
 472 grs_bitmap GameBitmaps[MAX_BITMAP_FILES];
 473
 474 alias alias_list[MAX_ALIASES];
 475 int Num_aliases=0;
 476
 477 int Must_write_hamfile = 0;
 478 int Num_bitmap_files_new = 0;
 479 int Num_sound_files_new = 0;
 480 BitmapFile AllBitmaps[ MAX_BITMAP_FILES ];
 481 static SoundFile AllSounds[ MAX_SOUND_FILES ];
 482
 483 int Piggy_hamfile_version = 0;
 484
 485 int piggy_low_memory = 0;
 486
 487 int Piggy_bitmap_cache_size = 0;
 488 int Piggy_bitmap_cache_next = 0;
 489 ubyte * Piggy_bitmap_cache_data = NULL;
 490 static int GameBitmapOffset[MAX_BITMAP_FILES];
 491 static ubyte GameBitmapFlags[MAX_BITMAP_FILES];
 492 ushort GameBitmapXlat[MAX_BITMAP_FILES];
 493
 494 #define PIGGY_BUFFER_SIZE (2400*1024)
 495
 496 #ifdef MACINTOSH
 497 #define PIGGY_SMALL_BUFFER_SIZE (1400*1024)             // size of buffer when piggy_low_memory is set
 498
 499 #ifdef SHAREWARE
 500 #undef PIGGY_BUFFER_SIZE
 501 #undef PIGGY_SMALL_BUFFER_SIZE
 502
 503 #define PIGGY_BUFFER_SIZE (2000*1024)
 504 #define PIGGY_SMALL_BUFFER_SIZE (1100 * 1024)
 505 #endif          // SHAREWARE
 506
 507 #endif
 508
 509 int piggy_page_flushed = 0;
 510
 511 #define DBM_FLAG_ABM            64
 512
 513 ubyte BigPig = 0;
 514
 515 #ifdef MACINTOSH
 516         extern short    cd_VRefNum;
 517         extern void             ConcatPStr(StringPtr dst, StringPtr src);
 518         extern int              ConvertPToCStr(StringPtr inPStr, char* outCStrBuf);
 519         extern int              ConvertCToPStr(char* inCStr, StringPtr outPStrBuf);
 520 #endif
 521
 522 int piggy_is_substitutable_bitmap( char * name, char * subst_name );
 523
 524 #ifdef EDITOR
 525 void piggy_write_pigfile(char *filename);
 526 static void write_int(int i,FILE *file);
 527 #endif
 528
 529 void swap_0_255(grs_bitmap *bmp)
 530 {
 531         int i;
 532
 533         for (i = 0; i < bmp->bm_h * bmp->bm_w; i++) {
 534                 if(bmp->bm_data[i] == 0)
 535                         bmp->bm_data[i] = 255;
 536                 else if (bmp->bm_data[i] == 255)
 537                         bmp->bm_data[i] = 0;
 538         }
 539 }
 540
 541 bitmap_index piggy_register_bitmap( grs_bitmap * bmp, char * name, int in_file )
 542 {
 543         bitmap_index temp;
 544         Assert( Num_bitmap_files < MAX_BITMAP_FILES );
 545
 546         temp.index = Num_bitmap_files;
 547
 548         if (!in_file)   {
 549 #ifdef EDITOR
 550                 if ( FindArg("-macdata") )
 551                         swap_0_255( bmp );
 552 #endif
 553                 if ( !BigPig )  gr_bitmap_rle_compress( bmp );
 554                 Num_bitmap_files_new++;
 555         }
 556
 557         strncpy( AllBitmaps[Num_bitmap_files].name, name, 12 );
 558         hashtable_insert( &AllBitmapsNames, AllBitmaps[Num_bitmap_files].name, Num_bitmap_files );
 559         GameBitmaps[Num_bitmap_files] = *bmp;
 560         if ( !in_file ) {
 561                 GameBitmapOffset[Num_bitmap_files] = 0;
 562                 GameBitmapFlags[Num_bitmap_files] = bmp->bm_flags;
 563         }
 564         Num_bitmap_files++;
 565
 566         return temp;
 567 }
 568
 569 int piggy_register_sound( digi_sound * snd, char * name, int in_file )
 570 {
 571         int i;
 572
 573         Assert( Num_sound_files < MAX_SOUND_FILES );
 574
 575         strncpy( AllSounds[Num_sound_files].name, name, 12 );
 576         hashtable_insert( &AllDigiSndNames, AllSounds[Num_sound_files].name, Num_sound_files );
 577         GameSounds[Num_sound_files] = *snd;
 578         if ( !in_file ) {
 579                 SoundOffset[Num_sound_files] = 0;
 580         }
 581
 582         i = Num_sound_files;
 583
 584         if (!in_file)
 585                 Num_sound_files_new++;
 586
 587         Num_sound_files++;
 588         return i;
 589 }
 590
 591 bitmap_index piggy_find_bitmap( char * name )
 592 {
 593         bitmap_index bmp;
 594         int i;
 595         char *t;
 596
 597         bmp.index = 0;
 598
 599         if ((t=strchr(name,'#'))!=NULL)
 600                 *t=0;
 601
 602         for (i=0;i<Num_aliases;i++)
 603                 if (stricmp(name,alias_list[i].alias_name)==0) {
 604                         if (t) {                //extra stuff for ABMs
 605                                 static char temp[FILENAME_LEN];
 606                                 _splitpath(alias_list[i].file_name, NULL, NULL, temp, NULL );
 607                                 name = temp;
 608                                 strcat(name,"#");
 609                                 strcat(name,t+1);
 610                         }
 611                         else
 612                                 name=alias_list[i].file_name;
 613                         break;
 614                 }
 615
 616         if (t)
 617                 *t = '#';
 618
 619         i = hashtable_search( &AllBitmapsNames, name );
 620         Assert( i != 0 );
 621         if ( i < 0 )
 622                 return bmp;
 623
 624         bmp.index = i;
 625         return bmp;
 626 }
 627
 628 int piggy_find_sound( char * name )
 629 {
 630         int i;
 631
 632         i = hashtable_search( &AllDigiSndNames, name );
 633
 634         if ( i < 0 )
 635                 return 255;
 636
 637         return i;
 638 }
 639
 640 CFILE * Piggy_fp = NULL;
 641
 642 #define FILENAME_LEN 13
 643
 644 char Current_pigfile[FILENAME_LEN] = "";
 645
 646 void piggy_close_file()
 647 {
 648         if ( Piggy_fp ) {
 649                 cfclose( Piggy_fp );
 650                 Piggy_fp        = NULL;
 651                 Current_pigfile[0] = 0;
 652         }
 653 }
 654
 655 int Pigfile_initialized=0;
 656
 657 #define PIGFILE_ID              MAKE_SIG('G','I','P','P') //PPIG
 658 #define PIGFILE_VERSION         2
 659
 660 extern char CDROM_dir[];
 661
 662 int request_cd(void);
 663
 664
 665 #ifdef MACINTOSH
 666
 667 //copies a pigfile from the CD to the current dir
 668 //retuns file handle of new pig
 669 CFILE *copy_pigfile_from_cd(char *filename)             // MACINTOSH VERSION
 670 {
 671         // C Stuff
 672         char                    sourcePathAndFileCStr[255] = "";
 673         char                    destPathAndFileCStr[255]        = "";
 674         FILEFINDSTRUCT  find;
 675         FILE*                   sourceFile      = NULL;
 676         FILE*                   destFile        = NULL;
 677         const int               BUF_SIZE = 4096;
 678         ubyte                   buf[BUF_SIZE];
 679
 680         // Mac Stuff
 681         Str255                  sourcePathAndFilePStr = "\p";
 682         Str255                  destPathAndFilePStr = "\p";
 683         Str255                  pigfileNamePStr = "\p";
 684         HParamBlockRec  theSourcePigHFSParams;
 685         HParamBlockRec  theDestPigHFSParams;
 686         OSErr                   theErr = noErr;
 687         char                    oldDirCStr[255] = "";
 688
 689         getcwd(oldDirCStr, 255);
 690
 691         show_boxed_message("Copying bitmap data from CD...");
 692         gr_palette_load(gr_palette);    //I don't think this line is really needed
 693
 694         chdir(":Data");
 695         //First, delete all PIG files currently in the directory
 696         if( !FileFindFirst( "*.pig", &find ) )
 697         {
 698                 do
 699                 {
 700                         remove(find.name);
 701                 } while( !FileFindNext( &find ) );
 702
 703                 FileFindClose();
 704         }
 705         chdir(oldDirCStr);
 706
 707         //Now, copy over new pig
 708         songs_stop_redbook();           //so we can read off the cd
 709
 710         // make the source path "<cd volume>:Data:filename.pig"
 711 //MWA   ConvertCToPStr(filename, pigfileNamePStr);
 712
 713 //MWA   ConcatPStr(sourcePathAndFilePStr, "\pDescent II:Data:");        // volume ID is cd_VRefNum
 714 //MWA   ConcatPStr(sourcePathAndFilePStr, pigfileNamePStr);
 715
 716         strupr(filename);
 717         strcpy(sourcePathAndFileCStr, "Descent II:Data:");
 718         strcat(sourcePathAndFileCStr, filename);
 719
 720         // make the destination path "<default directory>:Data:filename.pig"
 721 //MWA   ConcatPStr(destPathAndFilePStr, "\p:Data:");
 722 //MWA   ConcatPStr(destPathAndFilePStr, pigfileNamePStr);
 723 //MWA   ConvertPToCStr(sourcePathAndFilePStr, sourcePathAndFileCStr);
 724 //MWA   ConvertPToCStr(destPathAndFilePStr, destPathAndFileCStr);
 725
 726         strcpy(destPathAndFileCStr, ":Data:");
 727         strcat(destPathAndFileCStr, filename);
 728
 729         strcpy(sourcePathAndFilePStr, sourcePathAndFileCStr);
 730         strcpy(destPathAndFilePStr, destPathAndFileCStr);
 731         c2pstr(sourcePathAndFilePStr);
 732         c2pstr(destPathAndFilePStr);
 733
 734         do {
 735                 // Open the source file
 736                 sourceFile = fopen(sourcePathAndFileCStr,"rb");
 737
 738                 if (!sourceFile) {
 739
 740                         if (request_cd() == -1)
 741                                 Error("Cannot load file <%s> from CD",filename);
 742                 }
 743
 744         } while (!sourceFile);
 745
 746
 747         // Get the time stamp from the source file
 748         theSourcePigHFSParams.fileParam.ioCompletion    = nil;
 749         theSourcePigHFSParams.fileParam.ioNamePtr               = sourcePathAndFilePStr;
 750         theSourcePigHFSParams.fileParam.ioVRefNum               = cd_VRefNum;
 751         theSourcePigHFSParams.fileParam.ioFDirIndex     = 0;
 752         theSourcePigHFSParams.fileParam.ioDirID         = 0;
 753
 754         theErr = PBHGetFInfo(&theSourcePigHFSParams, false);
 755         if (theErr != noErr)
 756         {
 757                 // Error getting file time stamp!! Why? JTS
 758                 Error("Can't get old file time stamp: <%s>\n", sourcePathAndFileCStr);
 759         }
 760
 761         // Copy the file over
 762         // C Stuff......
 763
 764         // Open the destination file
 765         destFile = fopen(destPathAndFileCStr,"wb");
 766         if (!destFile)
 767         {
 768                 Error("Cannot create file: <%s>\n", destPathAndFileCStr);
 769         }
 770
 771         // Copy bytes until the end of the source file
 772         while (!feof(sourceFile))
 773         {
 774                 int bytes_read;
 775                 int x;
 776
 777                 bytes_read = fread(buf,1,BUF_SIZE,sourceFile);
 778                 if (ferror(sourceFile))
 779                         Error("Cannot read from file <%s>: %s", sourcePathAndFileCStr, strerror(errno));
 780
 781 // Assert is bogus              Assert(bytes_read == BUF_SIZE || feof(sourceFile));
 782
 783                 fwrite(buf,1,bytes_read,destFile);
 784                 if (ferror(destFile))
 785                         Error("Cannot write to file <%s>: %s",destPathAndFileCStr, strerror(errno));
 786         }
 787
 788         // close the source/dest files
 789         if (fclose(sourceFile))
 790                 Error("Error closing file <%s>: %s", sourcePathAndFileCStr, strerror(errno));
 791         if (fclose(destFile))
 792                 Error("Error closing file <%s>: %s", destPathAndFileCStr, strerror(errno));
 793
 794         // Get the current hfs data for the new file
 795         theDestPigHFSParams.fileParam.ioCompletion      = nil;
 796         theDestPigHFSParams.fileParam.ioNamePtr         = destPathAndFilePStr;
 797         theDestPigHFSParams.fileParam.ioVRefNum         = 0;
 798         theDestPigHFSParams.fileParam.ioFDirIndex       = 0;
 799         theDestPigHFSParams.fileParam.ioDirID           = 0;
 800         theErr = PBHGetFInfo(&theDestPigHFSParams, false);
 801         if ((theErr != noErr) || (theDestPigHFSParams.fileParam.ioResult != noErr))
 802         {
 803                 // Error getting file time stamp!! Why? JTS
 804                 Error("Can't get destination pig file information: <%s>\n", destPathAndFileCStr);
 805         }
 806
 807         // Reset this data !!!!! or else the relative pathname won't work, could use just filename instead but, oh well.
 808         theDestPigHFSParams.fileParam.ioNamePtr         = destPathAndFilePStr;
 809         theDestPigHFSParams.fileParam.ioVRefNum         = 0;
 810         theDestPigHFSParams.fileParam.ioFDirIndex       = 0;
 811         theDestPigHFSParams.fileParam.ioDirID           = 0;
 812
 813         // Copy the time stamp from the source file info
 814         theDestPigHFSParams.fileParam.ioFlCrDat = theSourcePigHFSParams.fileParam.ioFlCrDat;
 815         theDestPigHFSParams.fileParam.ioFlMdDat = theSourcePigHFSParams.fileParam.ioFlMdDat;
 816         theDestPigHFSParams.fileParam.ioFlFndrInfo.fdType = 'PGGY';
 817         theDestPigHFSParams.fileParam.ioFlFndrInfo.fdCreator = 'DCT2';
 818
 819         // Set the dest file's time stamp to the source file's time stamp values
 820         theErr = PBHSetFInfo(&theDestPigHFSParams, false);
 821
 822         if ((theErr != noErr) || (theDestPigHFSParams.fileParam.ioResult != noErr))
 823         {
 824                 Error("Can't set destination pig file time stamp: <%s>\n", destPathAndFileCStr);
 825         }
 826
 827         theErr = PBHGetFInfo(&theDestPigHFSParams, false);
 828
 829         return cfopen(destPathAndFileCStr, "rb");
 830 }
 831
 832 #else   //PC Version of copy_pigfile_from_cd is below
 833
 834 //copies a pigfile from the CD to the current dir
 835 //retuns file handle of new pig
 836 CFILE *copy_pigfile_from_cd(char *filename)
 837 {
 838         char name[80];
 839         FILEFINDSTRUCT find;
 840         int ret;
 841
 842         return cfopen(filename, "rb");
 843         show_boxed_message("Copying bitmap data from CD...");
 844         gr_palette_load(gr_palette);    //I don't think this line is really needed
 845
 846         //First, delete all PIG files currently in the directory
 847
 848         if( !FileFindFirst( "*.pig", &find ) ) {
 849                 do      {
 850                         remove(find.name);
 851                 } while( !FileFindNext( &find ) );
 852                 FileFindClose();
 853         }
 854
 855         //Now, copy over new pig
 856
 857         songs_stop_redbook();           //so we can read off the cd
 858
 859         //new code to unarj file
 860         strcpy(name,CDROM_dir);
 861         strcat(name,"descent2.sow");
 862
 863         do {
 864 //              ret = unarj_specific_file(name,filename,filename);
 865 // DPH:FIXME
 866
 867                 ret = !EXIT_SUCCESS;
 868
 869                 if (ret != EXIT_SUCCESS) {
 870
 871                         //delete file, so we don't leave partial file
 872                         remove(filename);
 873
 874                         #ifndef MACINTOSH
 875                         if (request_cd() == -1)
 876                         #endif
 877                                 //NOTE LINK TO ABOVE IF
 878                                 Error("Cannot load file <%s> from CD",filename);
 879                 }
 880
 881         } while (ret != EXIT_SUCCESS);
 882
 883         return cfopen(filename, "rb");
 884 }
 885
 886 #endif // end of ifdef MAC around copy_pigfile_from_cd
 887
 888 //initialize a pigfile, reading headers
 889 //returns the size of all the bitmap data
 890 void piggy_init_pigfile(char *filename)
 891 {
 892         int i;
 893         char temp_name[16];
 894         char temp_name_read[16];
 895         grs_bitmap temp_bitmap;
 896         DiskBitmapHeader bmh;
 897         int header_size, N_bitmaps, data_size, data_start;
 898         #ifdef MACINTOSH
 899         char name[255];         // filename + path for the mac
 900         #endif
 901
 902         piggy_close_file();             //close old pig if still open
 903
 904         //rename pigfile for shareware
 905         if (stricmp(DEFAULT_PIGFILE, DEFAULT_PIGFILE_SHAREWARE) == 0 && !cfexist(filename))
 906                 filename = DEFAULT_PIGFILE_SHAREWARE;
 907
 908         #ifndef MACINTOSH
 909                 Piggy_fp = cfopen( filename, "rb" );
 910         #else
 911                 sprintf(name, ":Data:%s", filename);
 912                 Piggy_fp = cfopen( name, "rb" );
 913
 914                 #ifdef SHAREWARE        // if we are in the shareware version, we must have the pig by now.
 915                         if (Piggy_fp == NULL)
 916                         {
 917                                 Error("Cannot load required file <%s>",name);
 918                         }
 919                 #endif  // end of if def shareware
 920
 921         #endif
 922
 923         if (!Piggy_fp) {
 924                 #ifdef EDITOR
 925                         return;         //if editor, ok to not have pig, because we'll build one
 926                 #else
 927                         Piggy_fp = copy_pigfile_from_cd(filename);
 928                 #endif
 929         }
 930
 931         if (Piggy_fp) {                         //make sure pig is valid type file & is up-to-date
 932                 int pig_id,pig_version;
 933
 934                 pig_id = cfile_read_int(Piggy_fp);
 935                 pig_version = cfile_read_int(Piggy_fp);
 936                 if (pig_id != PIGFILE_ID || pig_version != PIGFILE_VERSION) {
 937                         cfclose(Piggy_fp);              //out of date pig
 938                         Piggy_fp = NULL;                        //..so pretend it's not here
 939                 }
 940         }
 941
 942         if (!Piggy_fp) {
 943
 944                 #ifdef EDITOR
 945                         return;         //if editor, ok to not have pig, because we'll build one
 946                 #else
 947                         Error("Cannot load required file <%s>",filename);
 948                 #endif
 949         }
 950
 951         strncpy(Current_pigfile,filename,sizeof(Current_pigfile));
 952
 953         N_bitmaps = cfile_read_int(Piggy_fp);
 954
 955         header_size = N_bitmaps*DISKBITMAPHEADER_SIZE;
 956
 957         data_start = header_size + cftell(Piggy_fp);
 958
 959         data_size = cfilelength(Piggy_fp) - data_start;
 960
 961         Num_bitmap_files = 1;
 962
 963         for (i=0; i<N_bitmaps; i++ )    {
 964                 DiskBitmapHeader_read(&bmh, Piggy_fp);
 965                 memcpy( temp_name_read, bmh.name, 8 );
 966                 temp_name_read[8] = 0;
 967                 if ( bmh.dflags & DBM_FLAG_ABM )
 968                         sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
 969                 else
 970                         strcpy( temp_name, temp_name_read );
 971                 memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
 972                 temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
 973                 temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
 974                 temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
 975                 temp_bitmap.avg_color = bmh.avg_color;
 976                 temp_bitmap.bm_data = Piggy_bitmap_cache_data;
 977
 978                 GameBitmapFlags[i+1] = 0;
 979                 if ( bmh.flags & BM_FLAG_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_TRANSPARENT;
 980                 if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) GameBitmapFlags[i+1] |= BM_FLAG_SUPER_TRANSPARENT;
 981                 if ( bmh.flags & BM_FLAG_NO_LIGHTING ) GameBitmapFlags[i+1] |= BM_FLAG_NO_LIGHTING;
 982                 if ( bmh.flags & BM_FLAG_RLE ) GameBitmapFlags[i+1] |= BM_FLAG_RLE;
 983                 if ( bmh.flags & BM_FLAG_RLE_BIG ) GameBitmapFlags[i+1] |= BM_FLAG_RLE_BIG;
 984
 985                 GameBitmapOffset[i+1] = bmh.offset + data_start;
 986                 Assert( (i+1) == Num_bitmap_files );
 987                 piggy_register_bitmap( &temp_bitmap, temp_name, 1 );
 988         }
 989
 990 #ifdef EDITOR
 991         Piggy_bitmap_cache_size = data_size + (data_size/10);   //extra mem for new bitmaps
 992         Assert( Piggy_bitmap_cache_size > 0 );
 993 #else
 994         Piggy_bitmap_cache_size = PIGGY_BUFFER_SIZE;
 995         #ifdef MACINTOSH
 996         if (piggy_low_memory)
 997                 Piggy_bitmap_cache_size = PIGGY_SMALL_BUFFER_SIZE;
 998         #endif
 999 #endif
1000         BitmapBits = d_malloc( Piggy_bitmap_cache_size );
1001         if ( BitmapBits == NULL )
1002                 Error( "Not enough memory to load bitmaps\n" );
1003         Piggy_bitmap_cache_data = BitmapBits;
1004         Piggy_bitmap_cache_next = 0;
1005
1006         #if defined(MACINTOSH) && defined(SHAREWARE)
1007 //      load_exit_models();
1008         #endif
1009
1010         Pigfile_initialized=1;
1011 }
1012
1013 #define FILENAME_LEN 13
1014 #define MAX_BITMAPS_PER_BRUSH 30
1015
1016 extern int compute_average_pixel(grs_bitmap *new);
1017
1018 //reads in a new pigfile (for new palette)
1019 //returns the size of all the bitmap data
1020 void piggy_new_pigfile(char *pigname)
1021 {
1022         int i;
1023         char temp_name[16];
1024         char temp_name_read[16];
1025         grs_bitmap temp_bitmap;
1026         DiskBitmapHeader bmh;
1027         int header_size, N_bitmaps, data_size, data_start;
1028         int must_rewrite_pig = 0;
1029         #ifdef MACINTOSH
1030         char name[255];
1031         #endif
1032
1033         strlwr(pigname);
1034
1035         //rename pigfile for shareware
1036         if (stricmp(DEFAULT_PIGFILE, DEFAULT_PIGFILE_SHAREWARE) == 0 && !cfexist(pigname))
1037                 pigname = DEFAULT_PIGFILE_SHAREWARE;
1038
1039         if (strnicmp(Current_pigfile,pigname,sizeof(Current_pigfile))==0)
1040                 return;         //already have correct pig
1041
1042         if (!Pigfile_initialized) {                     //have we ever opened a pigfile?
1043                 piggy_init_pigfile(pigname);            //..no, so do initialization stuff
1044                 return;
1045         }
1046         else
1047                 piggy_close_file();             //close old pig if still open
1048
1049         Piggy_bitmap_cache_next = 0;            //free up cache
1050
1051         strncpy(Current_pigfile,pigname,sizeof(Current_pigfile));
1052
1053         #ifndef MACINTOSH
1054                 Piggy_fp = cfopen( pigname, "rb" );
1055         #else
1056                 sprintf(name, ":Data:%s", pigname);
1057                 Piggy_fp = cfopen( name, "rb" );
1058
1059                 #ifdef SHAREWARE        // if we are in the shareware version, we must have the pig by now.
1060                         if (Piggy_fp == NULL)
1061                         {
1062                                 Error("Cannot load required file <%s>",name);
1063                         }
1064                 #endif  // end of if def shareware
1065         #endif
1066
1067         #ifndef EDITOR
1068         if (!Piggy_fp)
1069                 Piggy_fp = copy_pigfile_from_cd(pigname);
1070         #endif
1071
1072         if (Piggy_fp) {  //make sure pig is valid type file & is up-to-date
1073                 int pig_id,pig_version;
1074
1075                 pig_id = cfile_read_int(Piggy_fp);
1076                 pig_version = cfile_read_int(Piggy_fp);
1077                 if (pig_id != PIGFILE_ID || pig_version != PIGFILE_VERSION) {
1078                         cfclose(Piggy_fp);              //out of date pig
1079                         Piggy_fp = NULL;                        //..so pretend it's not here
1080                 }
1081         }
1082
1083         #ifndef EDITOR
1084         if (!Piggy_fp) Error ("Piggy_fp not defined in piggy_new_pigfile.");
1085         #endif
1086
1087         if (Piggy_fp) {
1088
1089                 N_bitmaps = cfile_read_int(Piggy_fp);
1090
1091                 header_size = N_bitmaps*DISKBITMAPHEADER_SIZE;
1092
1093                 data_start = header_size + cftell(Piggy_fp);
1094
1095                 data_size = cfilelength(Piggy_fp) - data_start;
1096
1097                 for (i=1; i<=N_bitmaps; i++ )   {
1098                         DiskBitmapHeader_read(&bmh, Piggy_fp);
1099                         memcpy( temp_name_read, bmh.name, 8 );
1100                         temp_name_read[8] = 0;
1101
1102                         if ( bmh.dflags & DBM_FLAG_ABM )
1103                                 sprintf( temp_name, "%s#%d", temp_name_read, bmh.dflags & 63 );
1104                         else
1105                                 strcpy( temp_name, temp_name_read );
1106
1107                         //Make sure name matches
1108                         if (strcmp(temp_name,AllBitmaps[i].name)) {
1109                                 //Int3();       //this pig is out of date.  Delete it
1110                                 must_rewrite_pig=1;
1111                         }
1112
1113                         strcpy(AllBitmaps[i].name,temp_name);
1114
1115                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
1116
1117                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
1118                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
1119                         temp_bitmap.bm_flags = BM_FLAG_PAGED_OUT;
1120                         temp_bitmap.avg_color = bmh.avg_color;
1121                         temp_bitmap.bm_data = Piggy_bitmap_cache_data;
1122
1123                         GameBitmapFlags[i] = 0;
1124
1125                         if ( bmh.flags & BM_FLAG_TRANSPARENT ) GameBitmapFlags[i] |= BM_FLAG_TRANSPARENT;
1126                         if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) GameBitmapFlags[i] |= BM_FLAG_SUPER_TRANSPARENT;
1127                         if ( bmh.flags & BM_FLAG_NO_LIGHTING ) GameBitmapFlags[i] |= BM_FLAG_NO_LIGHTING;
1128                         if ( bmh.flags & BM_FLAG_RLE ) GameBitmapFlags[i] |= BM_FLAG_RLE;
1129                         if ( bmh.flags & BM_FLAG_RLE_BIG ) GameBitmapFlags[i] |= BM_FLAG_RLE_BIG;
1130
1131                         GameBitmapOffset[i] = bmh.offset + data_start;
1132
1133                         GameBitmaps[i] = temp_bitmap;
1134                 }
1135         }
1136         else
1137                 N_bitmaps = 0;          //no pigfile, so no bitmaps
1138
1139         #ifndef EDITOR
1140
1141         Assert(N_bitmaps == Num_bitmap_files-1);
1142
1143         #else
1144
1145         if (must_rewrite_pig || (N_bitmaps < Num_bitmap_files-1)) {
1146                 int size;
1147
1148                 //re-read the bitmaps that aren't in this pig
1149
1150                 for (i=N_bitmaps+1;i<Num_bitmap_files;i++) {
1151                         char *p;
1152
1153                         p = strchr(AllBitmaps[i].name,'#');
1154
1155                         if (p) {                //this is an ABM
1156                                 char abmname[FILENAME_LEN];
1157                                 int fnum;
1158                                 grs_bitmap * bm[MAX_BITMAPS_PER_BRUSH];
1159                                 int iff_error;          //reference parm to avoid warning message
1160                                 ubyte newpal[768];
1161                                 char basename[FILENAME_LEN];
1162                                 int nframes;
1163
1164                                 strcpy(basename,AllBitmaps[i].name);
1165                                 basename[p-AllBitmaps[i].name] = 0;             //cut off "#nn" part
1166
1167                                 sprintf( abmname, "%s.abm", basename );
1168
1169                                 iff_error = iff_read_animbrush(abmname,bm,MAX_BITMAPS_PER_BRUSH,&nframes,newpal);
1170
1171                                 if (iff_error != IFF_NO_ERROR)  {
1172                                         mprintf((1,"File %s - IFF error: %s",abmname,iff_errormsg(iff_error)));
1173                                         Error("File %s - IFF error: %s",abmname,iff_errormsg(iff_error));
1174                                 }
1175
1176                                 for (fnum=0;fnum<nframes; fnum++)       {
1177                                         char tempname[20];
1178                                         int SuperX;
1179
1180                                         sprintf( tempname, "%s#%d", basename, fnum );
1181
1182                                         //SuperX = (GameBitmaps[i+fnum].bm_flags&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
1183                                         SuperX = (GameBitmapFlags[i+fnum]&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
1184                                         //above makes assumption that supertransparent color is 254
1185
1186                                         if ( iff_has_transparency )
1187                                                 gr_remap_bitmap_good( bm[fnum], newpal, iff_transparent_color, SuperX );
1188                                         else
1189                                                 gr_remap_bitmap_good( bm[fnum], newpal, -1, SuperX );
1190
1191                                         bm[fnum]->avg_color = compute_average_pixel(bm[fnum]);
1192
1193 #ifdef EDITOR
1194                                         if ( FindArg("-macdata") )
1195                                                 swap_0_255( bm[fnum] );
1196 #endif
1197                                         if ( !BigPig ) gr_bitmap_rle_compress( bm[fnum] );
1198
1199                                         if (bm[fnum]->bm_flags & BM_FLAG_RLE)
1200                                                 size = *((int *) bm[fnum]->bm_data);
1201                                         else
1202                                                 size = bm[fnum]->bm_w * bm[fnum]->bm_h;
1203
1204                                         memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],bm[fnum]->bm_data,size);
1205                                         d_free(bm[fnum]->bm_data);
1206                                         bm[fnum]->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1207                                         Piggy_bitmap_cache_next += size;
1208
1209                                         GameBitmaps[i+fnum] = *bm[fnum];
1210
1211                                         // -- mprintf( (0, "U" ));
1212                                         d_free( bm[fnum] );
1213                                 }
1214
1215                                 i += nframes-1;         //filled in multiple bitmaps
1216                         }
1217                         else {          //this is a BBM
1218
1219                                 grs_bitmap * new;
1220                                 ubyte newpal[256*3];
1221                                 int iff_error;
1222                                 char bbmname[FILENAME_LEN];
1223                                 int SuperX;
1224
1225                                 MALLOC( new, grs_bitmap, 1 );
1226
1227                                 sprintf( bbmname, "%s.bbm", AllBitmaps[i].name );
1228                                 iff_error = iff_read_bitmap(bbmname,new,BM_LINEAR,newpal);
1229
1230                                 new->bm_handle=0;
1231                                 if (iff_error != IFF_NO_ERROR)          {
1232                                         mprintf((1, "File %s - IFF error: %s",bbmname,iff_errormsg(iff_error)));
1233                                         Error("File %s - IFF error: %s",bbmname,iff_errormsg(iff_error));
1234                                 }
1235
1236                                 SuperX = (GameBitmapFlags[i]&BM_FLAG_SUPER_TRANSPARENT)?254:-1;
1237                                 //above makes assumption that supertransparent color is 254
1238
1239                                 if ( iff_has_transparency )
1240                                         gr_remap_bitmap_good( new, newpal, iff_transparent_color, SuperX );
1241                                 else
1242                                         gr_remap_bitmap_good( new, newpal, -1, SuperX );
1243
1244                                 new->avg_color = compute_average_pixel(new);
1245
1246 #ifdef EDITOR
1247                                 if ( FindArg("-macdata") )
1248                                         swap_0_255( new );
1249 #endif
1250                                 if ( !BigPig )  gr_bitmap_rle_compress( new );
1251
1252                                 if (new->bm_flags & BM_FLAG_RLE)
1253                                         size = *((int *) new->bm_data);
1254                                 else
1255                                         size = new->bm_w * new->bm_h;
1256
1257                                 memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next],new->bm_data,size);
1258                                 d_free(new->bm_data);
1259                                 new->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1260                                 Piggy_bitmap_cache_next += size;
1261
1262                                 GameBitmaps[i] = *new;
1263
1264                                 d_free( new );
1265
1266                                 // -- mprintf( (0, "U" ));
1267                         }
1268                 }
1269
1270                 //@@Dont' do these things which are done when writing
1271                 //@@for (i=0; i < Num_bitmap_files; i++ )       {
1272                 //@@    bitmap_index bi;
1273                 //@@    bi.index = i;
1274                 //@@    PIGGY_PAGE_IN( bi );
1275                 //@@}
1276                 //@@
1277                 //@@piggy_close_file();
1278
1279                 piggy_write_pigfile(pigname);
1280
1281                 Current_pigfile[0] = 0;                 //say no pig, to force reload
1282
1283                 piggy_new_pigfile(pigname);             //read in just-generated pig
1284
1285
1286         }
1287         #endif  //ifdef EDITOR
1288
1289 }
1290
1291 ubyte bogus_data[64*64];
1292 grs_bitmap bogus_bitmap;
1293 ubyte bogus_bitmap_initialized=0;
1294 digi_sound bogus_sound;
1295
1296 #define HAMFILE_ID              MAKE_SIG('!','M','A','H') //HAM!
1297 #define HAMFILE_VERSION 3
1298 //version 1 -> 2:  save marker_model_num
1299 //version 2 -> 3:  removed sound files
1300
1301 #define SNDFILE_ID              MAKE_SIG('D','N','S','D') //DSND
1302 #define SNDFILE_VERSION 1
1303
1304 int read_hamfile()
1305 {
1306         CFILE * ham_fp = NULL;
1307         int ham_id;
1308         int sound_offset = 0;
1309         #ifdef MACINTOSH
1310         char name[255];
1311         #endif
1312
1313         #ifndef MACINTOSH
1314         ham_fp = cfopen( DEFAULT_HAMFILE, "rb" );
1315         #else
1316         sprintf(name, ":Data:%s", DEFAULT_HAMFILE );
1317         ham_fp = cfopen( name, "rb" );
1318         #endif
1319
1320         if (ham_fp == NULL) {
1321                 Must_write_hamfile = 1;
1322                 return 0;
1323         }
1324
1325         //make sure ham is valid type file & is up-to-date
1326         ham_id = cfile_read_int(ham_fp);
1327         Piggy_hamfile_version = cfile_read_int(ham_fp);
1328         if (ham_id != HAMFILE_ID)
1329                 Error("Cannot open ham file %s\n", DEFAULT_HAMFILE);
1330 #if 0
1331         if (ham_id != HAMFILE_ID || Piggy_hamfile_version != HAMFILE_VERSION) {
1332                 Must_write_hamfile = 1;
1333                 cfclose(ham_fp);                                                //out of date ham
1334                 return 0;
1335         }
1336 #endif
1337
1338         if (Piggy_hamfile_version < 3) // hamfile contains sound info
1339                 sound_offset = cfile_read_int(ham_fp);
1340
1341         #ifndef EDITOR
1342         {
1343                 //int i;
1344
1345                 bm_read_all(ham_fp);
1346                 cfread( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1347                 // no swap here?
1348                 //for (i = 0; i < MAX_BITMAP_FILES; i++) {
1349                         //GameBitmapXlat[i] = INTEL_SHORT(GameBitmapXlat[i]);
1350                         //printf("GameBitmapXlat[%d] = %d\n", i, GameBitmapXlat[i]);
1351                 //}
1352         }
1353         #endif
1354
1355         if (Piggy_hamfile_version < 3) {
1356                 int N_sounds;
1357                 int sound_start;
1358                 int header_size;
1359                 int i;
1360                 DiskSoundHeader sndh;
1361                 digi_sound temp_sound;
1362                 char temp_name_read[16];
1363                 int sbytes = 0;
1364
1365                 cfseek(ham_fp, sound_offset, SEEK_SET);
1366                 N_sounds = cfile_read_int(ham_fp);
1367
1368                 sound_start = cftell(ham_fp);
1369
1370                 header_size = N_sounds * DISKSOUNDHEADER_SIZE;
1371
1372                 //Read sounds
1373
1374                 for (i=0; i<N_sounds; i++ ) {
1375                         DiskSoundHeader_read(&sndh, ham_fp);
1376                         temp_sound.length = sndh.length;
1377                         temp_sound.data = (ubyte *)(sndh.offset + header_size + sound_start);
1378                         SoundOffset[Num_sound_files] = sndh.offset + header_size + sound_start;
1379                         memcpy( temp_name_read, sndh.name, 8 );
1380                         temp_name_read[8] = 0;
1381                         piggy_register_sound( &temp_sound, temp_name_read, 1 );
1382 #ifdef MACINTOSH
1383                         if (piggy_is_needed(i))
1384 #endif          // note link to if.
1385                                 sbytes += sndh.length;
1386                         //mprintf(( 0, "%d bytes of sound\n", sbytes ));
1387                 }
1388
1389                 SoundBits = d_malloc( sbytes + 16 );
1390                 if ( SoundBits == NULL )
1391                         Error( "Not enough memory to load sounds\n" );
1392
1393                 mprintf(( 0, "\nBitmaps: %d KB   Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
1394
1395                 //      piggy_read_sounds(ham_fp);
1396
1397         }
1398
1399         cfclose(ham_fp);
1400
1401         return 1;
1402
1403 }
1404
1405 int read_sndfile()
1406 {
1407         CFILE * snd_fp = NULL;
1408         int snd_id,snd_version;
1409         int N_sounds;
1410         int sound_start;
1411         int header_size;
1412         int i,size, length;
1413         DiskSoundHeader sndh;
1414         digi_sound temp_sound;
1415         char temp_name_read[16];
1416         int sbytes = 0;
1417         #ifdef MACINTOSH
1418         char name[255];
1419         #endif
1420
1421         #ifndef MACINTOSH
1422         snd_fp = cfopen( DEFAULT_SNDFILE, "rb" );
1423         #else
1424         sprintf( name, ":Data:%s", DEFAULT_SNDFILE );
1425         snd_fp = cfopen( name, "rb");
1426         #endif
1427
1428         if (snd_fp == NULL)
1429                 return 0;
1430
1431         //make sure soundfile is valid type file & is up-to-date
1432         snd_id = cfile_read_int(snd_fp);
1433         snd_version = cfile_read_int(snd_fp);
1434         if (snd_id != SNDFILE_ID || snd_version != SNDFILE_VERSION) {
1435                 cfclose(snd_fp);                                                //out of date sound file
1436                 return 0;
1437         }
1438
1439         N_sounds = cfile_read_int(snd_fp);
1440
1441         sound_start = cftell(snd_fp);
1442         size = cfilelength(snd_fp) - sound_start;
1443         length = size;
1444         mprintf( (0, "\nReading data (%d KB) ", size/1024 ));
1445
1446         header_size = N_sounds*sizeof(DiskSoundHeader);
1447
1448         //Read sounds
1449
1450         for (i=0; i<N_sounds; i++ ) {
1451                 DiskSoundHeader_read(&sndh, snd_fp);
1452                 //size -= sizeof(DiskSoundHeader);
1453                 temp_sound.length = sndh.length;
1454                 temp_sound.data = (ubyte *)(sndh.offset + header_size + sound_start);
1455                 SoundOffset[Num_sound_files] = sndh.offset + header_size + sound_start;
1456                 memcpy( temp_name_read, sndh.name, 8 );
1457                 temp_name_read[8] = 0;
1458                 piggy_register_sound( &temp_sound, temp_name_read, 1 );
1459                 #ifdef MACINTOSH
1460                 if (piggy_is_needed(i))
1461                 #endif          // note link to if.
1462                 sbytes += sndh.length;
1463                 //mprintf(( 0, "%d bytes of sound\n", sbytes ));
1464         }
1465
1466         SoundBits = d_malloc( sbytes + 16 );
1467         if ( SoundBits == NULL )
1468                 Error( "Not enough memory to load sounds\n" );
1469
1470         mprintf(( 0, "\nBitmaps: %d KB   Sounds: %d KB\n", Piggy_bitmap_cache_size/1024, sbytes/1024 ));
1471
1472 //      piggy_read_sounds(snd_fp);
1473
1474         cfclose(snd_fp);
1475
1476         return 1;
1477 }
1478
1479 int piggy_init(void)
1480 {
1481         int ham_ok=0,snd_ok=0;
1482         int i;
1483
1484         hashtable_init( &AllBitmapsNames, MAX_BITMAP_FILES );
1485         hashtable_init( &AllDigiSndNames, MAX_SOUND_FILES );
1486
1487         for (i=0; i<MAX_SOUND_FILES; i++ )      {
1488                 GameSounds[i].length = 0;
1489                 GameSounds[i].data = NULL;
1490                 SoundOffset[i] = 0;
1491         }
1492
1493         for (i=0; i<MAX_BITMAP_FILES; i++ )
1494                 GameBitmapXlat[i] = i;
1495
1496         if ( !bogus_bitmap_initialized )        {
1497                 int i;
1498                 ubyte c;
1499                 bogus_bitmap_initialized = 1;
1500                 memset( &bogus_bitmap, 0, sizeof(grs_bitmap) );
1501                 bogus_bitmap.bm_w = bogus_bitmap.bm_h = bogus_bitmap.bm_rowsize = 64;
1502                 bogus_bitmap.bm_data = bogus_data;
1503                 c = gr_find_closest_color( 0, 0, 63 );
1504                 for (i=0; i<4096; i++ ) bogus_data[i] = c;
1505                 c = gr_find_closest_color( 63, 0, 0 );
1506                 // Make a big red X !
1507                 for (i=0; i<64; i++ )   {
1508                         bogus_data[i*64+i] = c;
1509                         bogus_data[i*64+(63-i)] = c;
1510                 }
1511                 piggy_register_bitmap( &bogus_bitmap, "bogus", 1 );
1512                 bogus_sound.length = 64*64;
1513                 bogus_sound.data = bogus_data;
1514                 GameBitmapOffset[0] = 0;
1515         }
1516
1517         if ( FindArg( "-bigpig" ))
1518                 BigPig = 1;
1519
1520         if ( FindArg( "-lowmem" ))
1521                 piggy_low_memory = 1;
1522
1523         if ( FindArg( "-nolowmem" ))
1524                 piggy_low_memory = 0;
1525
1526         if (piggy_low_memory)
1527                 digi_lomem = 1;
1528
1529         WIN(DDGRLOCK(dd_grd_curcanv));
1530                 gr_set_curfont( SMALL_FONT );
1531                 gr_set_fontcolor(gr_find_closest_color_current( 20, 20, 20 ),-1 );
1532                 gr_printf( 0x8000, grd_curcanv->cv_h-20, "%s...", TXT_LOADING_DATA );
1533         WIN(DDGRUNLOCK(dd_grd_curcanv));
1534
1535 #if 1 //def EDITOR //need for d1 mission briefings
1536         piggy_init_pigfile(DEFAULT_PIGFILE);
1537 #endif
1538
1539         snd_ok = ham_ok = read_hamfile();
1540
1541         if (Piggy_hamfile_version >= 3)
1542                 snd_ok = read_sndfile();
1543
1544         atexit(piggy_close);
1545
1546         mprintf ((0,"HamOk=%d SndOk=%d\n",ham_ok,snd_ok));
1547         return (ham_ok && snd_ok);               //read ok
1548 }
1549
1550 int piggy_is_needed(int soundnum)
1551 {
1552         int i;
1553
1554         if ( !digi_lomem ) return 1;
1555
1556         for (i=0; i<MAX_SOUNDS; i++ )   {
1557                 if ( (AltSounds[i] < 255) && (Sounds[AltSounds[i]] == soundnum) )
1558                         return 1;
1559         }
1560         return 0;
1561 }
1562
1563
1564 void piggy_read_sounds(void)
1565 {
1566         CFILE * fp = NULL;
1567         ubyte * ptr;
1568         int i, sbytes;
1569         #ifdef MACINTOSH
1570         char name[255];
1571         #endif
1572
1573         ptr = SoundBits;
1574         sbytes = 0;
1575
1576         #ifndef MACINTOSH
1577         fp = cfopen( DEFAULT_SNDFILE, "rb" );
1578         #else
1579         sprintf( name, ":Data:%s", DEFAULT_SNDFILE );
1580         fp = cfopen( name, "rb");
1581         #endif
1582
1583         if (fp == NULL)
1584                 return;
1585
1586         for (i=0; i<Num_sound_files; i++ )      {
1587                 digi_sound *snd = &GameSounds[i];
1588
1589                 if ( SoundOffset[i] > 0 )       {
1590                         if ( piggy_is_needed(i) )       {
1591                                 cfseek( fp, SoundOffset[i], SEEK_SET );
1592
1593                                 // Read in the sound data!!!
1594                                 snd->data = ptr;
1595                                 ptr += snd->length;
1596                                 sbytes += snd->length;
1597                                 cfread( snd->data, snd->length, 1, fp );
1598                         }
1599                         else
1600                                 snd->data = (ubyte *) -1;
1601                 }
1602         }
1603
1604         cfclose(fp);
1605
1606         mprintf(( 0, "\nActual Sound usage: %d KB\n", sbytes/1024 ));
1607
1608 }
1609
1610
1611 extern int descent_critical_error;
1612 extern unsigned descent_critical_deverror;
1613 extern unsigned descent_critical_errcode;
1614
1615 char * crit_errors[13] = { "Write Protected", "Unknown Unit", "Drive Not Ready", "Unknown Command", "CRC Error", \
1616 "Bad struct length", "Seek Error", "Unknown media type", "Sector not found", "Printer out of paper", "Write Fault", \
1617 "Read fault", "General Failure" };
1618
1619 void piggy_critical_error()
1620 {
1621         grs_canvas * save_canv;
1622         grs_font * save_font;
1623         int i;
1624         save_canv = grd_curcanv;
1625         save_font = grd_curcanv->cv_font;
1626         gr_palette_load( gr_palette );
1627         i = nm_messagebox( "Disk Error", 2, "Retry", "Exit", "%s\non drive %c:", crit_errors[descent_critical_errcode&0xf], (descent_critical_deverror&0xf)+'A'  );
1628         if ( i == 1 )
1629                 exit(1);
1630         gr_set_current_canvas(save_canv);
1631         grd_curcanv->cv_font = save_font;
1632 }
1633
1634 void piggy_bitmap_page_in( bitmap_index bitmap )
1635 {
1636         grs_bitmap * bmp;
1637         int i,org_i,temp;
1638
1639         org_i = 0;
1640
1641         i = bitmap.index;
1642         Assert( i >= 0 );
1643         Assert( i < MAX_BITMAP_FILES );
1644         Assert( i < Num_bitmap_files );
1645         Assert( Piggy_bitmap_cache_size > 0 );
1646
1647         if ( i < 1 ) return;
1648         if ( i >= MAX_BITMAP_FILES ) return;
1649         if ( i >= Num_bitmap_files ) return;
1650
1651         if ( GameBitmapOffset[i] == 0 ) return;         // A read-from-disk bitmap!!!
1652
1653         if ( piggy_low_memory ) {
1654                 org_i = i;
1655                 i = GameBitmapXlat[i];          // Xlat for low-memory settings!
1656         }
1657
1658         bmp = &GameBitmaps[i];
1659
1660         if ( bmp->bm_flags & BM_FLAG_PAGED_OUT )        {
1661                 stop_time();
1662
1663         ReDoIt:
1664                 descent_critical_error = 0;
1665                 cfseek( Piggy_fp, GameBitmapOffset[i], SEEK_SET );
1666                 if ( descent_critical_error )   {
1667                         piggy_critical_error();
1668                         goto ReDoIt;
1669                 }
1670
1671                 bmp->bm_data = &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next];
1672                 bmp->bm_flags = GameBitmapFlags[i];
1673
1674                 if ( bmp->bm_flags & BM_FLAG_RLE )      {
1675                         int zsize = 0;
1676                         descent_critical_error = 0;
1677                         zsize = cfile_read_int(Piggy_fp);
1678                         if ( descent_critical_error )   {
1679                                 piggy_critical_error();
1680                                 goto ReDoIt;
1681                         }
1682
1683                         // GET JOHN NOW IF YOU GET THIS ASSERT!!!
1684                         //Assert( Piggy_bitmap_cache_next+zsize < Piggy_bitmap_cache_size );
1685                         if ( Piggy_bitmap_cache_next+zsize >= Piggy_bitmap_cache_size ) {
1686                                 Int3();
1687                                 piggy_bitmap_page_out_all();
1688                                 goto ReDoIt;
1689                         }
1690                         descent_critical_error = 0;
1691                         temp = cfread( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next+4], 1, zsize-4, Piggy_fp );
1692                         if ( descent_critical_error )   {
1693                                 piggy_critical_error();
1694                                 goto ReDoIt;
1695                         }
1696
1697 #ifndef MACDATA
1698                         switch (cfilelength(Piggy_fp)) {
1699                         default:
1700                                 if (!FindArg("-macdata"))
1701                                         break;
1702                                 // otherwise, fall through...
1703                         case MAC_ALIEN1_PIGSIZE:
1704                         case MAC_ALIEN2_PIGSIZE:
1705                         case MAC_FIRE_PIGSIZE:
1706                         case MAC_GROUPA_PIGSIZE:
1707                         case MAC_ICE_PIGSIZE:
1708                         case MAC_WATER_PIGSIZE:
1709                                 rle_swap_0_255( bmp );
1710                                 memcpy(&zsize, bmp->bm_data, 4);
1711                                 break;
1712                         }
1713 #endif
1714
1715                         memcpy( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], &zsize, sizeof(int) );
1716                         Piggy_bitmap_cache_next += zsize;
1717                         if ( Piggy_bitmap_cache_next+zsize >= Piggy_bitmap_cache_size ) {
1718                                 Int3();
1719                                 piggy_bitmap_page_out_all();
1720                                 goto ReDoIt;
1721                         }
1722
1723                 } else {
1724                         // GET JOHN NOW IF YOU GET THIS ASSERT!!!
1725                         Assert( Piggy_bitmap_cache_next+(bmp->bm_h*bmp->bm_w) < Piggy_bitmap_cache_size );
1726                         if ( Piggy_bitmap_cache_next+(bmp->bm_h*bmp->bm_w) >= Piggy_bitmap_cache_size ) {
1727                                 piggy_bitmap_page_out_all();
1728                                 goto ReDoIt;
1729                         }
1730                         descent_critical_error = 0;
1731                         temp = cfread( &Piggy_bitmap_cache_data[Piggy_bitmap_cache_next], 1, bmp->bm_h*bmp->bm_w, Piggy_fp );
1732                         if ( descent_critical_error )   {
1733                                 piggy_critical_error();
1734                                 goto ReDoIt;
1735                         }
1736                         Piggy_bitmap_cache_next+=bmp->bm_h*bmp->bm_w;
1737
1738 #ifndef MACDATA
1739                         switch (cfilelength(Piggy_fp)) {
1740                         default:
1741                                 if (!FindArg("-macdata"))
1742                                         break;
1743                                 // otherwise, fall through...
1744                         case MAC_ALIEN1_PIGSIZE:
1745                         case MAC_ALIEN2_PIGSIZE:
1746                         case MAC_FIRE_PIGSIZE:
1747                         case MAC_GROUPA_PIGSIZE:
1748                         case MAC_ICE_PIGSIZE:
1749                         case MAC_WATER_PIGSIZE:
1750                                 swap_0_255( bmp );
1751                                 break;
1752                         }
1753 #endif
1754                 }
1755
1756                 //@@if ( bmp->bm_selector ) {
1757                 //@@#if !defined(WINDOWS) && !defined(MACINTOSH)
1758                 //@@    if (!dpmi_modify_selector_base( bmp->bm_selector, bmp->bm_data ))
1759                 //@@            Error( "Error modifying selector base in piggy.c\n" );
1760                 //@@#endif
1761                 //@@}
1762
1763                 start_time();
1764         }
1765
1766         if ( piggy_low_memory ) {
1767                 if ( org_i != i )
1768                         GameBitmaps[org_i] = GameBitmaps[i];
1769         }
1770
1771 //@@Removed from John's code:
1772 //@@#ifndef WINDOWS
1773 //@@    if ( bmp->bm_selector ) {
1774 //@@            if (!dpmi_modify_selector_base( bmp->bm_selector, bmp->bm_data ))
1775 //@@                    Error( "Error modifying selector base in piggy.c\n" );
1776 //@@    }
1777 //@@#endif
1778
1779 }
1780
1781 void piggy_bitmap_page_out_all()
1782 {
1783         int i;
1784
1785         Piggy_bitmap_cache_next = 0;
1786
1787         piggy_page_flushed++;
1788
1789         texmerge_flush();
1790         rle_cache_flush();
1791
1792         for (i=0; i<Num_bitmap_files; i++ )             {
1793                 if ( GameBitmapOffset[i] > 0 )  {       // Don't page out bitmaps read from disk!!!
1794                         GameBitmaps[i].bm_flags = BM_FLAG_PAGED_OUT;
1795                         GameBitmaps[i].bm_data = Piggy_bitmap_cache_data;
1796                 }
1797         }
1798
1799         mprintf(( 0, "Flushing piggy bitmap cache\n" ));
1800 }
1801
1802 void piggy_load_level_data()
1803 {
1804         piggy_bitmap_page_out_all();
1805         paging_touch_all();
1806 }
1807
1808 #ifdef EDITOR
1809
1810 void change_filename_ext( char *dest, char *src, char *ext );
1811
1812 void piggy_write_pigfile(char *filename)
1813 {
1814         FILE *pig_fp;
1815         int bitmap_data_start,data_offset;
1816         DiskBitmapHeader bmh;
1817         int org_offset;
1818         char subst_name[32];
1819         int i;
1820         FILE *fp1,*fp2;
1821         char tname[FILENAME_LEN];
1822
1823         // -- mprintf( (0, "Paging in all piggy bitmaps..." ));
1824         for (i=0; i < Num_bitmap_files; i++ )   {
1825                 bitmap_index bi;
1826                 bi.index = i;
1827                 PIGGY_PAGE_IN( bi );
1828         }
1829         // -- mprintf( (0, "\n" ));
1830
1831         piggy_close_file();
1832
1833         // -- mprintf( (0, "Creating %s...",filename ));
1834
1835         pig_fp = fopen( filename, "wb" );       //open PIG file
1836         Assert( pig_fp!=NULL );
1837
1838         write_int(PIGFILE_ID,pig_fp);
1839         write_int(PIGFILE_VERSION,pig_fp);
1840
1841         Num_bitmap_files--;
1842         fwrite( &Num_bitmap_files, sizeof(int), 1, pig_fp );
1843         Num_bitmap_files++;
1844
1845         bitmap_data_start = ftell(pig_fp);
1846         bitmap_data_start += (Num_bitmap_files-1)*DISKBITMAPHEADER_SIZE;
1847         data_offset = bitmap_data_start;
1848
1849         change_filename_ext(tname,filename,"lst");
1850         fp1 = fopen( tname, "wt" );
1851         change_filename_ext(tname,filename,"all");
1852         fp2 = fopen( tname, "wt" );
1853
1854         for (i=1; i < Num_bitmap_files; i++ )   {
1855                 int *size;
1856                 grs_bitmap *bmp;
1857
1858                 {
1859                         char * p, *p1;
1860                         p = strchr(AllBitmaps[i].name,'#');
1861                         if (p)  {
1862                                 int n;
1863                                 p1 = p; p1++;
1864                                 n = atoi(p1);
1865                                 *p = 0;
1866                                 if (fp2 && n==0)
1867                                         fprintf( fp2, "%s.abm\n", AllBitmaps[i].name );
1868                                 memcpy( bmh.name, AllBitmaps[i].name, 8 );
1869                                 Assert( n <= 63 );
1870                                 bmh.dflags = DBM_FLAG_ABM + n;
1871                                 *p = '#';
1872                         }else {
1873                                 if (fp2)
1874                                         fprintf( fp2, "%s.bbm\n", AllBitmaps[i].name );
1875                                 memcpy( bmh.name, AllBitmaps[i].name, 8 );
1876                                 bmh.dflags = 0;
1877                         }
1878                 }
1879                 bmp = &GameBitmaps[i];
1880
1881                 Assert( !(bmp->bm_flags&BM_FLAG_PAGED_OUT) );
1882
1883                 if (fp1)
1884                         fprintf( fp1, "BMP: %s, size %d bytes", AllBitmaps[i].name, bmp->bm_rowsize * bmp->bm_h );
1885                 org_offset = ftell(pig_fp);
1886                 bmh.offset = data_offset - bitmap_data_start;
1887                 fseek( pig_fp, data_offset, SEEK_SET );
1888
1889                 if ( bmp->bm_flags & BM_FLAG_RLE )      {
1890                         size = (int *)bmp->bm_data;
1891                         fwrite( bmp->bm_data, sizeof(ubyte), *size, pig_fp );
1892                         data_offset += *size;
1893                         if (fp1)
1894                                 fprintf( fp1, ", and is already compressed to %d bytes.\n", *size );
1895                 } else {
1896                         fwrite( bmp->bm_data, sizeof(ubyte), bmp->bm_rowsize * bmp->bm_h, pig_fp );
1897                         data_offset += bmp->bm_rowsize * bmp->bm_h;
1898                         if (fp1)
1899                                 fprintf( fp1, ".\n" );
1900                 }
1901                 fseek( pig_fp, org_offset, SEEK_SET );
1902                 Assert( GameBitmaps[i].bm_w < 4096 );
1903                 bmh.width = (GameBitmaps[i].bm_w & 0xff);
1904                 bmh.wh_extra = ((GameBitmaps[i].bm_w >> 8) & 0x0f);
1905                 Assert( GameBitmaps[i].bm_h < 4096 );
1906                 bmh.height = GameBitmaps[i].bm_h;
1907                 bmh.wh_extra |= ((GameBitmaps[i].bm_h >> 4) & 0xf0);
1908                 bmh.flags = GameBitmaps[i].bm_flags;
1909                 if (piggy_is_substitutable_bitmap( AllBitmaps[i].name, subst_name ))    {
1910                         bitmap_index other_bitmap;
1911                         other_bitmap = piggy_find_bitmap( subst_name );
1912                         GameBitmapXlat[i] = other_bitmap.index;
1913                         bmh.flags |= BM_FLAG_PAGED_OUT;
1914                         //mprintf(( 0, "Skipping bitmap %d\n", i ));
1915                         //mprintf(( 0, "Marking '%s' as substitutible\n", AllBitmaps[i].name ));
1916                 } else  {
1917                         bmh.flags &= ~BM_FLAG_PAGED_OUT;
1918                 }
1919                 bmh.avg_color=GameBitmaps[i].avg_color;
1920                 fwrite( &bmh, DISKBITMAPHEADER_SIZE, 1, pig_fp );                    // Mark as a bitmap
1921         }
1922
1923         fclose(pig_fp);
1924
1925         mprintf( (0, " Dumped %d assorted bitmaps.\n", Num_bitmap_files ));
1926         fprintf( fp1, " Dumped %d assorted bitmaps.\n", Num_bitmap_files );
1927
1928         fclose(fp1);
1929         fclose(fp2);
1930
1931 }
1932
1933 static void write_int(int i,FILE *file)
1934 {
1935         if (fwrite( &i, sizeof(i), 1, file) != 1)
1936                 Error( "Error reading int in gamesave.c" );
1937
1938 }
1939
1940 void piggy_dump_all()
1941 {
1942         int i, xlat_offset;
1943         FILE * ham_fp;
1944         int org_offset,data_offset=0;
1945         DiskSoundHeader sndh;
1946         int sound_data_start=0;
1947         FILE *fp1,*fp2;
1948
1949         #ifdef NO_DUMP_SOUNDS
1950         Num_sound_files = 0;
1951         Num_sound_files_new = 0;
1952         #endif
1953
1954         if (!Must_write_hamfile && (Num_bitmap_files_new == 0) && (Num_sound_files_new == 0) )
1955                 return;
1956
1957         fp1 = fopen( "ham.lst", "wt" );
1958         fp2 = fopen( "ham.all", "wt" );
1959
1960         if (Must_write_hamfile || Num_bitmap_files_new) {
1961
1962                 mprintf( (0, "Creating %s...",DEFAULT_HAMFILE));
1963
1964                 ham_fp = fopen( DEFAULT_HAMFILE, "wb" );                       //open HAM file
1965                 Assert( ham_fp!=NULL );
1966
1967                 write_int(HAMFILE_ID,ham_fp);
1968                 write_int(HAMFILE_VERSION,ham_fp);
1969
1970                 bm_write_all(ham_fp);
1971                 xlat_offset = ftell(ham_fp);
1972                 fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1973                 //Dump bitmaps
1974
1975                 if (Num_bitmap_files_new)
1976                         piggy_write_pigfile(DEFAULT_PIGFILE);
1977
1978                 //free up memeory used by new bitmaps
1979                 for (i=Num_bitmap_files-Num_bitmap_files_new;i<Num_bitmap_files;i++)
1980                         d_free(GameBitmaps[i].bm_data);
1981
1982                 //next thing must be done after pig written
1983                 fseek( ham_fp, xlat_offset, SEEK_SET );
1984                 fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, ham_fp );
1985
1986                 fclose(ham_fp);
1987                 mprintf( (0, "\n" ));
1988         }
1989
1990         if (Num_sound_files_new) {
1991
1992                 mprintf( (0, "Creating %s...",DEFAULT_HAMFILE));
1993                 // Now dump sound file
1994                 ham_fp = fopen( DEFAULT_SNDFILE, "wb" );
1995                 Assert( ham_fp!=NULL );
1996
1997                 write_int(SNDFILE_ID,ham_fp);
1998                 write_int(SNDFILE_VERSION,ham_fp);
1999
2000                 fwrite( &Num_sound_files, sizeof(int), 1, ham_fp );
2001
2002                 mprintf( (0, "\nDumping sounds..." ));
2003
2004                 sound_data_start = ftell(ham_fp);
2005                 sound_data_start += Num_sound_files*sizeof(DiskSoundHeader);
2006                 data_offset = sound_data_start;
2007
2008                 for (i=0; i < Num_sound_files; i++ )    {
2009                         digi_sound *snd;
2010
2011                         snd = &GameSounds[i];
2012                         strcpy( sndh.name, AllSounds[i].name );
2013                         sndh.length = GameSounds[i].length;
2014                         sndh.offset = data_offset - sound_data_start;
2015
2016                         org_offset = ftell(ham_fp);
2017                         fseek( ham_fp, data_offset, SEEK_SET );
2018
2019                         sndh.data_length = GameSounds[i].length;
2020                         fwrite( snd->data, sizeof(ubyte), snd->length, ham_fp );
2021                         data_offset += snd->length;
2022                         fseek( ham_fp, org_offset, SEEK_SET );
2023                         fwrite( &sndh, sizeof(DiskSoundHeader), 1, ham_fp );                    // Mark as a bitmap
2024
2025                         fprintf( fp1, "SND: %s, size %d bytes\n", AllSounds[i].name, snd->length );
2026                         fprintf( fp2, "%s.raw\n", AllSounds[i].name );
2027                 }
2028
2029                 fclose(ham_fp);
2030                 mprintf( (0, "\n" ));
2031         }
2032
2033         fprintf( fp1, "Total sound size: %d bytes\n", data_offset-sound_data_start);
2034         mprintf( (0, " Dumped %d assorted sounds.\n", Num_sound_files ));
2035         fprintf( fp1, " Dumped %d assorted sounds.\n", Num_sound_files );
2036
2037         fclose(fp1);
2038         fclose(fp2);
2039
2040         // Never allow the game to run after building ham.
2041         exit(0);
2042 }
2043
2044 #endif
2045
2046 void piggy_close()
2047 {
2048         piggy_close_file();
2049
2050         if (BitmapBits)
2051                 d_free(BitmapBits);
2052
2053         if ( SoundBits )
2054                 d_free( SoundBits );
2055
2056         hashtable_free( &AllBitmapsNames );
2057         hashtable_free( &AllDigiSndNames );
2058
2059 }
2060
2061 int piggy_does_bitmap_exist_slow( char * name )
2062 {
2063         int i;
2064
2065         for (i=0; i<Num_bitmap_files; i++ )     {
2066                 if ( !strcmp( AllBitmaps[i].name, name) )
2067                         return 1;
2068         }
2069         return 0;
2070 }
2071
2072
2073 #define NUM_GAUGE_BITMAPS 23
2074 char * gauge_bitmap_names[NUM_GAUGE_BITMAPS] = {
2075         "gauge01", "gauge01b",
2076         "gauge02", "gauge02b",
2077         "gauge06", "gauge06b",
2078         "targ01", "targ01b",
2079         "targ02", "targ02b",
2080         "targ03", "targ03b",
2081         "targ04", "targ04b",
2082         "targ05", "targ05b",
2083         "targ06", "targ06b",
2084         "gauge18", "gauge18b",
2085         "gauss1", "helix1",
2086         "phoenix1"
2087 };
2088
2089
2090 int piggy_is_gauge_bitmap( char * base_name )
2091 {
2092         int i;
2093         for (i=0; i<NUM_GAUGE_BITMAPS; i++ )    {
2094                 if ( !stricmp( base_name, gauge_bitmap_names[i] ))
2095                         return 1;
2096         }
2097
2098         return 0;
2099 }
2100
2101 int piggy_is_substitutable_bitmap( char * name, char * subst_name )
2102 {
2103         int frame;
2104         char * p;
2105         char base_name[ 16 ];
2106
2107         strcpy( subst_name, name );
2108         p = strchr( subst_name, '#' );
2109         if ( p )        {
2110                 frame = atoi( &p[1] );
2111                 *p = 0;
2112                 strcpy( base_name, subst_name );
2113                 if ( !piggy_is_gauge_bitmap( base_name ))       {
2114                         sprintf( subst_name, "%s#%d", base_name, frame+1 );
2115                         if ( piggy_does_bitmap_exist_slow( subst_name )  )      {
2116                                 if ( frame & 1 ) {
2117                                         sprintf( subst_name, "%s#%d", base_name, frame-1 );
2118                                         return 1;
2119                                 }
2120                         }
2121                 }
2122         }
2123         strcpy( subst_name, name );
2124         return 0;
2125 }
2126
2127
2128
2129 #ifdef WINDOWS
2130 //      New Windows stuff
2131
2132 //      windows bitmap page in
2133 //              Page in a bitmap, if ddraw, then page it into a ddsurface in
2134 //              'video' memory.  if that fails, page it in normally.
2135
2136 void piggy_bitmap_page_in_w( bitmap_index bitmap, int ddraw )
2137 {
2138 }
2139
2140
2141 //      Essential when switching video modes!
2142
2143 void piggy_bitmap_page_out_all_w()
2144 {
2145 }
2146
2147 #endif // WINDOWS
2148
2149
2150 /*
2151  * Functions for loading replacement textures
2152  *  1) From .pog files
2153  *  2) From descent.pig (for loading d1 levels)
2154  */
2155
2156 extern void change_filename_extension( char *dest, char *src, char *new_ext );
2157 extern char last_palette_loaded_pig[];
2158
2159 ubyte *Bitmap_replacement_data=NULL;
2160
2161 void free_bitmap_replacements()
2162 {
2163         if (Bitmap_replacement_data) {
2164                 d_free(Bitmap_replacement_data);
2165                 Bitmap_replacement_data = NULL;
2166         }
2167 }
2168
2169 void load_bitmap_replacements(char *level_name)
2170 {
2171         char ifile_name[FILENAME_LEN];
2172         CFILE *ifile;
2173         int i;
2174
2175         //first, free up data allocated for old bitmaps
2176         free_bitmap_replacements();
2177
2178         change_filename_extension(ifile_name, level_name, ".POG" );
2179
2180         ifile = cfopen(ifile_name,"rb");
2181
2182         if (ifile) {
2183                 int id,version,n_bitmaps;
2184                 int bitmap_data_size;
2185                 ushort *indices;
2186
2187                 id = cfile_read_int(ifile);
2188                 version = cfile_read_int(ifile);
2189
2190                 if (id != MAKE_SIG('G','O','P','D') || version != 1) {
2191                         cfclose(ifile);
2192                         return;
2193                 }
2194
2195                 n_bitmaps = cfile_read_int(ifile);
2196
2197                 MALLOC( indices, ushort, n_bitmaps );
2198
2199                 for (i = 0; i < n_bitmaps; i++)
2200                         indices[i] = cfile_read_short(ifile);
2201
2202                 bitmap_data_size = cfilelength(ifile) - cftell(ifile) - DISKBITMAPHEADER_SIZE * n_bitmaps;
2203                 MALLOC( Bitmap_replacement_data, ubyte, bitmap_data_size );
2204
2205                 for (i=0;i<n_bitmaps;i++) {
2206                         DiskBitmapHeader bmh;
2207                         grs_bitmap temp_bitmap;
2208
2209                         DiskBitmapHeader_read(&bmh, ifile);
2210
2211                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
2212
2213                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
2214                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
2215                         temp_bitmap.avg_color = bmh.avg_color;
2216                         temp_bitmap.bm_data = Bitmap_replacement_data + bmh.offset;
2217
2218                         if ( bmh.flags & BM_FLAG_TRANSPARENT ) temp_bitmap.bm_flags |= BM_FLAG_TRANSPARENT;
2219                         if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT ) temp_bitmap.bm_flags |= BM_FLAG_SUPER_TRANSPARENT;
2220                         if ( bmh.flags & BM_FLAG_NO_LIGHTING ) temp_bitmap.bm_flags |= BM_FLAG_NO_LIGHTING;
2221                         if ( bmh.flags & BM_FLAG_RLE ) temp_bitmap.bm_flags |= BM_FLAG_RLE;
2222                         if ( bmh.flags & BM_FLAG_RLE_BIG ) temp_bitmap.bm_flags |= BM_FLAG_RLE_BIG;
2223
2224                         GameBitmaps[indices[i]] = temp_bitmap;
2225                 }
2226
2227                 cfread(Bitmap_replacement_data,1,bitmap_data_size,ifile);
2228
2229                 d_free(indices);
2230
2231                 cfclose(ifile);
2232
2233                 last_palette_loaded_pig[0]= 0;  //force pig re-load
2234
2235                 texmerge_flush();       //for re-merging with new textures
2236         }
2237
2238         atexit(free_bitmap_replacements);
2239 }
2240
2241 #define FIRST_D1_TEXTURE 722
2242 #define LAST_D1_STATIC_TEXTURE 1042//1342 //afterwards, we have door frames and stuff
2243 #define FIRST_D2_TEXTURE 1243
2244
2245 void load_d1_bitmap_replacements()
2246 {
2247         CFILE * d1_Piggy_fp;
2248         grs_bitmap temp_bitmap;
2249         DiskBitmapHeader bmh;
2250         int pig_data_start, bitmap_header_start, bitmap_data_start;
2251         int N_bitmaps, zsize;
2252         int d1_index, d2_index;
2253         ubyte colormap[256];
2254         ubyte *next_bitmap; // to which address we write the next bitmap
2255
2256         d1_Piggy_fp = cfopen( D1_PIGFILE, "rb" );
2257
2258         if (!d1_Piggy_fp)
2259                 return; // use d2 bitmaps instead...
2260
2261         //first, free up data allocated for old bitmaps
2262         free_bitmap_replacements();
2263
2264         // read d1 palette, build colormap
2265         {
2266                 int freq[256];
2267                 ubyte d1_palette[256*3];
2268                 CFILE * palette_file = cfopen(D1_PALETTE, "rb" );
2269                 Assert( palette_file );
2270                 Assert( cfilelength( palette_file ) == 9472 );
2271                 cfread( d1_palette, 256, 3, palette_file);
2272                 cfclose( palette_file );
2273                 build_colormap_good( d1_palette, colormap, freq );
2274                 // don't change transparencies:
2275                 colormap[254] = 254;
2276                 colormap[255] = 255;
2277         }
2278
2279         switch (cfilelength(d1_Piggy_fp)) {
2280         case D1_SHAREWARE_10_PIGSIZE:
2281         case D1_SHAREWARE_PIGSIZE:
2282                 pig_data_start = 0;
2283                 break;
2284         default:
2285                 Int3();
2286         case D1_PIGSIZE:
2287         case D1_OEM_PIGSIZE:
2288         case D1_MAC_PIGSIZE:
2289         case D1_MAC_SHARE_PIGSIZE:
2290                 //int i;
2291                 pig_data_start = cfile_read_int(d1_Piggy_fp );
2292                 bm_read_all_d1( d1_Piggy_fp );
2293                 //for (i = 0; i < 1800; i++) GameBitmapXlat[i] = cfile_read_short(d1_Piggy_fp);
2294                 break;
2295         }
2296
2297         cfseek( d1_Piggy_fp, pig_data_start, SEEK_SET );
2298         N_bitmaps = cfile_read_int(d1_Piggy_fp);
2299         {
2300                 int N_sounds = cfile_read_int(d1_Piggy_fp);
2301                 int header_size = N_bitmaps * DISKBITMAPHEADER_D1_SIZE
2302                         + N_sounds * DISKSOUNDHEADER_SIZE;
2303                 bitmap_header_start = pig_data_start + 2 * sizeof(int);
2304                 bitmap_data_start = bitmap_header_start + header_size;
2305         }
2306
2307         MALLOC( Bitmap_replacement_data, ubyte, cfilelength(d1_Piggy_fp) - bitmap_data_start ); // too much
2308         //TODO: handle case where b_r_d == 0! (have to convert textures, return, not bm_read_all_d1)
2309
2310         next_bitmap = Bitmap_replacement_data;
2311
2312         for (d1_index=1; d1_index<=N_bitmaps; d1_index++ ) {
2313                 // only change wall texture bitmaps
2314                 if (d1_index >= FIRST_D1_TEXTURE && d1_index <= LAST_D1_STATIC_TEXTURE) {
2315                         d2_index = d1_index + FIRST_D2_TEXTURE - FIRST_D1_TEXTURE;
2316
2317                         cfseek(d1_Piggy_fp, bitmap_header_start + (d1_index-1) * DISKBITMAPHEADER_D1_SIZE, SEEK_SET);
2318                         DiskBitmapHeader_d1_read(&bmh, d1_Piggy_fp);
2319
2320                         memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
2321
2322                         temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
2323                         temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
2324                         temp_bitmap.avg_color = bmh.avg_color;
2325
2326                         //GameBitmapFlags[convert_d1_bitmap_num(d1_index)] = 0;
2327
2328                         if ( bmh.flags & BM_FLAG_TRANSPARENT )
2329                                 temp_bitmap.bm_flags |= BM_FLAG_TRANSPARENT;
2330                         if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT )
2331                                 temp_bitmap.bm_flags |= BM_FLAG_SUPER_TRANSPARENT;
2332                         if ( bmh.flags & BM_FLAG_NO_LIGHTING )
2333                                 temp_bitmap.bm_flags |= BM_FLAG_NO_LIGHTING;
2334                         if ( bmh.flags & BM_FLAG_RLE )
2335                                 temp_bitmap.bm_flags |= BM_FLAG_RLE;
2336                         if ( bmh.flags & BM_FLAG_RLE_BIG )
2337                                 temp_bitmap.bm_flags |= BM_FLAG_RLE_BIG;
2338
2339                         temp_bitmap.bm_data = next_bitmap;
2340
2341                         cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2342                         zsize = cfile_read_int(d1_Piggy_fp);
2343                         cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2344                         cfread(next_bitmap, 1, zsize, d1_Piggy_fp);
2345
2346                         switch(cfilelength(d1_Piggy_fp)) {
2347                         case D1_MAC_PIGSIZE:
2348                         case D1_MAC_SHARE_PIGSIZE:
2349                                 rle_swap_0_255(&temp_bitmap);
2350                         }
2351                         rle_remap(&temp_bitmap, colormap);
2352
2353                         GameBitmaps[d2_index] = temp_bitmap;
2354
2355                         memcpy(&zsize, temp_bitmap.bm_data, 4);
2356                         next_bitmap += zsize;
2357                 }
2358         }
2359
2360         cfclose(d1_Piggy_fp);
2361
2362         last_palette_loaded_pig[0]= 0;  //force pig re-load
2363
2364         texmerge_flush();       //for re-merging with new textures
2365
2366         atexit(free_bitmap_replacements);
2367 }
2368
2369
2370 extern int extra_bitmap_num;
2371
2372 /*
2373  * Find and load the named bitmap from descent.pig
2374  * similar to read_extra_bitmap_iff
2375  */
2376 bitmap_index read_extra_bitmap_d1_pig(char *name)
2377 {
2378         bitmap_index bitmap_num;
2379         grs_bitmap * new = &GameBitmaps[extra_bitmap_num];
2380
2381         bitmap_num.index = 0;
2382
2383         {
2384                 CFILE *d1_Piggy_fp;
2385                 int i;
2386                 DiskBitmapHeader bmh;
2387                 int pig_data_start, bitmap_header_start, bitmap_data_start;
2388                 int N_bitmaps, zsize;
2389                 ubyte colormap[256];
2390
2391                 d1_Piggy_fp = cfopen(D1_PIGFILE, "rb");
2392                 if (!d1_Piggy_fp)
2393                 {
2394                         con_printf(CON_DEBUG, "could not open %s\n", D1_PIGFILE);
2395                         return bitmap_num;
2396                 }
2397
2398                 // read d1 palette, build colormap
2399                 {
2400                         int freq[256];
2401                         ubyte d1_palette[256*3];
2402                         CFILE * palette_file = cfopen(D1_PALETTE, "rb");
2403                         if (!palette_file || cfilelength(palette_file) != 9472)
2404                         {
2405                                 con_printf(CON_DEBUG, "could not open %s\n", D1_PALETTE);
2406                                 return bitmap_num;
2407                         }
2408                         cfread( d1_palette, 256, 3, palette_file);
2409                         cfclose( palette_file );
2410                         build_colormap_good( d1_palette, colormap, freq );
2411                         // don't change transparencies:
2412                         colormap[254] = 254;
2413                         colormap[255] = 255;
2414                 }
2415
2416                 switch (cfilelength(d1_Piggy_fp)) {
2417                 case D1_SHAREWARE_10_PIGSIZE:
2418                 case D1_SHAREWARE_PIGSIZE:
2419                         pig_data_start = 0;
2420                         break;
2421                 default:
2422                         Int3();
2423                 case D1_PIGSIZE:
2424                 case D1_OEM_PIGSIZE:
2425                 case D1_MAC_PIGSIZE:
2426                 case D1_MAC_SHARE_PIGSIZE:
2427                         pig_data_start = cfile_read_int(d1_Piggy_fp);
2428                         break;
2429                 }
2430
2431                 cfseek(d1_Piggy_fp, pig_data_start, SEEK_SET);
2432                 N_bitmaps = cfile_read_int(d1_Piggy_fp);
2433                 {
2434                         int N_sounds = cfile_read_int(d1_Piggy_fp);
2435                         int header_size = N_bitmaps * DISKBITMAPHEADER_D1_SIZE
2436                                 + N_sounds * DISKSOUNDHEADER_SIZE;
2437                         bitmap_header_start = pig_data_start + 2 * sizeof(int);
2438                         bitmap_data_start = bitmap_header_start + header_size;
2439                 }
2440
2441                 for (i = 0; i < N_bitmaps; i++)
2442                 {
2443                         DiskBitmapHeader_d1_read(&bmh, d1_Piggy_fp);
2444                         if (!strnicmp(bmh.name, name, 8))
2445                                 break;
2446                 }
2447
2448                 if (strnicmp(bmh.name, name, 8))
2449                 {
2450                         con_printf(CON_DEBUG, "could not find bitmap %s\n", name);
2451                         return bitmap_num;
2452                 }
2453
2454                 memset( new, 0, sizeof(grs_bitmap) );
2455
2456                 new->bm_w = new->bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
2457                 new->bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
2458                 new->avg_color = bmh.avg_color;
2459
2460                 if ( bmh.flags & BM_FLAG_TRANSPARENT )
2461                         new->bm_flags |= BM_FLAG_TRANSPARENT;
2462                 if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT )
2463                         new->bm_flags |= BM_FLAG_SUPER_TRANSPARENT;
2464                 if ( bmh.flags & BM_FLAG_NO_LIGHTING )
2465                         new->bm_flags |= BM_FLAG_NO_LIGHTING;
2466                 if ( bmh.flags & BM_FLAG_RLE )
2467                         new->bm_flags |= BM_FLAG_RLE;
2468                 if ( bmh.flags & BM_FLAG_RLE_BIG )
2469                         new->bm_flags |= BM_FLAG_RLE_BIG;
2470
2471                 if ( bmh.flags & BM_FLAG_RLE )
2472                 {
2473                         cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2474                         zsize = cfile_read_int(d1_Piggy_fp);
2475                 }
2476                 else
2477                         zsize = new->bm_w * new->bm_h;
2478                 new->bm_data = d_malloc(zsize);
2479                 cfseek(d1_Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
2480                 cfread(new->bm_data, 1, zsize, d1_Piggy_fp);
2481
2482                 switch(cfilelength(d1_Piggy_fp)) {
2483                 case D1_MAC_PIGSIZE:
2484                 case D1_MAC_SHARE_PIGSIZE:
2485                         rle_swap_0_255(new);
2486                 }
2487                 rle_remap(new, colormap);
2488
2489                 cfclose(d1_Piggy_fp);
2490         }
2491
2492         new->avg_color = 0;     //compute_average_pixel(new);
2493
2494         bitmap_num.index = extra_bitmap_num;
2495
2496         GameBitmaps[extra_bitmap_num++] = *new;
2497
2498         return bitmap_num;
2499 }
2500
2501
2502 #ifndef FAST_FILE_IO
2503 /*
2504  * reads a bitmap_index structure from a CFILE
2505  */
2506 void bitmap_index_read(bitmap_index *bi, CFILE *fp)
2507 {
2508         bi->index = cfile_read_short(fp);
2509 }
2510
2511 /*
2512  * reads n bitmap_index structs from a CFILE
2513  */
2514 int bitmap_index_read_n(bitmap_index *bi, int n, CFILE *fp)
2515 {
2516         int i;
2517
2518         for (i = 0; i < n; i++)
2519                 bi[i].index = cfile_read_short(fp);
2520         return i;
2521 }
2522
2523 /*
2524  * reads a DiskBitmapHeader structure from a CFILE
2525  */
2526 void DiskBitmapHeader_read(DiskBitmapHeader *dbh, CFILE *fp)
2527 {
2528         cfread(dbh->name, 8, 1, fp);
2529         dbh->dflags = cfile_read_byte(fp);
2530         dbh->width = cfile_read_byte(fp);
2531         dbh->height = cfile_read_byte(fp);
2532         dbh->wh_extra = cfile_read_byte(fp);
2533         dbh->flags = cfile_read_byte(fp);
2534         dbh->avg_color = cfile_read_byte(fp);
2535         dbh->offset = cfile_read_int(fp);
2536 }
2537
2538 /*
2539  * reads a DiskSoundHeader structure from a CFILE
2540  */
2541 void DiskSoundHeader_read(DiskSoundHeader *dsh, CFILE *fp)
2542 {
2543         cfread(dsh->name, 8, 1, fp);
2544         dsh->length = cfile_read_int(fp);
2545         dsh->data_length = cfile_read_int(fp);
2546         dsh->offset = cfile_read_int(fp);
2547 }
2548 #endif // FAST_FILE_IO
2549
2550 /*
2551  * reads a descent 1 DiskBitmapHeader structure from a CFILE
2552  */
2553 void DiskBitmapHeader_d1_read(DiskBitmapHeader *dbh, CFILE *fp)
2554 {
2555         cfread(dbh->name, 8, 1, fp);
2556         dbh->dflags = cfile_read_byte(fp);
2557         dbh->width = cfile_read_byte(fp);
2558         dbh->height = cfile_read_byte(fp);
2559         dbh->wh_extra = 0;
2560         dbh->flags = cfile_read_byte(fp);
2561         dbh->avg_color = cfile_read_byte(fp);
2562         dbh->offset = cfile_read_int(fp);
2563 }