if descent.pig available, load d1 textures for d1 levels
authorBradley Bell <btb@icculus.org>
Wed, 19 Mar 2003 22:44:15 +0000 (22:44 +0000)
committerBradley Bell <btb@icculus.org>
Wed, 19 Mar 2003 22:44:15 +0000 (22:44 +0000)
2d/rle.c
ChangeLog
include/gr.h
include/rle.h
main/bm.c
main/bm.h
main/gamemine.c
main/gamemine.h
main/gameseq.c
main/piggy.c
main/piggy.h

index 024a561..f61e38f 100644 (file)
--- a/2d/rle.c
+++ b/2d/rle.c
@@ -1,4 +1,4 @@
-/* $Id: rle.c,v 1.14 2003-03-14 09:19:48 btb Exp $ */
+/* $Id: rle.c,v 1.15 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -125,7 +125,7 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #endif
 
 #ifdef RCS
-static char rcsid[] = "$Id: rle.c,v 1.14 2003-03-14 09:19:48 btb Exp $";
+static char rcsid[] = "$Id: rle.c,v 1.15 2003-03-19 22:44:15 btb Exp $";
 #endif
 
 #include <stdlib.h>
@@ -147,6 +147,8 @@ static char rcsid[] = "$Id: rle.c,v 1.14 2003-03-14 09:19:48 btb Exp $";
 #define RLE_CODE        0xE0
 #define NOT_RLE_CODE    31
 
+#define IS_RLE_CODE(x) (((x) & RLE_CODE) == RLE_CODE)
+
 #if !defined(NO_ASM) && defined(__WATCOMC__)
 #define RLE_DECODE_ASM
 
@@ -295,7 +297,7 @@ void gr_rle_decode( ubyte * src, ubyte * dest )
 
        while(1) {
                data = *src++;
-               if ( (data & RLE_CODE) != RLE_CODE ) {
+               if ( ! IS_RLE_CODE(data) ) {
                        *dest++ = data;
                } else {
                        count = data & NOT_RLE_CODE;
@@ -364,7 +366,7 @@ void gr_rle_expand_scanline_masked( ubyte *dest, ubyte *src, int x1, int x2  )
        while ( i < x1 )        {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE)==RLE_CODE )     {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & (~RLE_CODE);
                        color = *src++;
                } else {
@@ -390,7 +392,7 @@ void gr_rle_expand_scanline_masked( ubyte *dest, ubyte *src, int x1, int x2  )
        while( i <= x2 )                {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == (RLE_CODE) ) {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & (~RLE_CODE);
                        color = *src++;
                } else {
@@ -424,7 +426,7 @@ void gr_rle_expand_scanline( ubyte *dest, ubyte *src, int x1, int x2  )
        while ( i < x1 )        {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE)==RLE_CODE )     {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & (~RLE_CODE);
                        color = *src++;
                } else {
@@ -450,7 +452,7 @@ void gr_rle_expand_scanline( ubyte *dest, ubyte *src, int x1, int x2  )
        while( i <= x2 )                {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE)==RLE_CODE )     {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & (~RLE_CODE);
                        color = *src++;
                } else {
@@ -487,7 +489,7 @@ int gr_rle_encode( int org_size, ubyte *src, ubyte *dest )
                c = *src++;
                if ( c!=oc )    {
                        if ( count )    {
-                               if ( (count==1) && ((oc & RLE_CODE)!=RLE_CODE) )        {
+                               if ( (count==1) && (! IS_RLE_CODE(oc)) )        {
                                        *dest++ = oc;
                                        Assert( oc != RLE_CODE );
                                } else {
@@ -508,7 +510,7 @@ int gr_rle_encode( int org_size, ubyte *src, ubyte *dest )
                }
        }
        if (count)      {
-               if ( (count==1) && ((oc & RLE_CODE)!=RLE_CODE) )        {
+               if ( (count==1) && (! IS_RLE_CODE(oc)) )        {
                        *dest++ = oc;
                        Assert( oc != RLE_CODE );
                } else {
@@ -537,7 +539,7 @@ int gr_rle_getsize( int org_size, ubyte *src )
                c = *src++;
                if ( c!=oc )    {
                        if ( count )    {
-                               if ( (count==1) && ((oc & RLE_CODE)!=RLE_CODE) )        {
+                               if ( (count==1) && (! IS_RLE_CODE(oc)) )        {
                                        dest_size++;
                                } else {
                                        dest_size++;
@@ -555,7 +557,7 @@ int gr_rle_getsize( int org_size, ubyte *src )
                }
        }
        if (count)      {
-               if ( (count==1) && ((oc & RLE_CODE)!=RLE_CODE) )        {
+               if ( (count==1) && (! IS_RLE_CODE(oc)) )        {
                        dest_size++;
                } else {
                        dest_size++;
@@ -776,7 +778,7 @@ void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *s
        while ( i < x1 )        {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == RLE_CODE )   {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & NOT_RLE_CODE;
                        color = *src++;
                } else {
@@ -803,7 +805,7 @@ void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, ubyte *s
        while( i <= x2 )                {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == RLE_CODE )   {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & NOT_RLE_CODE;
                        color = *src++;
                } else {
@@ -836,7 +838,7 @@ void gr_rle_expand_scanline_generic_masked( grs_bitmap * dest, int dx, int dy, u
        while ( i < x1 )        {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == RLE_CODE )   {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & NOT_RLE_CODE;
                        color = *src++;
                } else {
@@ -868,7 +870,7 @@ void gr_rle_expand_scanline_generic_masked( grs_bitmap * dest, int dx, int dy, u
        while( i <= x2 )                {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == RLE_CODE )   {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & NOT_RLE_CODE;
                        color = *src++;
                } else {
@@ -923,7 +925,7 @@ void gr_rle_expand_scanline_svga_masked( grs_bitmap * dest, int dx, int dy, ubyt
        while ( i < x1 )        {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == RLE_CODE )   {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & NOT_RLE_CODE;
                        color = *src++;
                } else {
@@ -973,7 +975,7 @@ void gr_rle_expand_scanline_svga_masked( grs_bitmap * dest, int dx, int dy, ubyt
        while( i <= x2 )                {
                color = *src++;
                if ( color == RLE_CODE ) return;
-               if ( (color & RLE_CODE) == RLE_CODE )   {
+               if ( IS_RLE_CODE(color) )       {
                        count = color & NOT_RLE_CODE;
                        color = *src++;
                } else {
@@ -1053,7 +1055,7 @@ void rle_swap_0_255(grs_bitmap *bmp)
                else
                        line_size = bmp->bm_data[4 + i];
                for (j = 0; j < line_size; j++) {
-                       if ((ptr[j] & RLE_CODE) != RLE_CODE) {
+                       if ( ! IS_RLE_CODE(ptr[j]) ) {
                                if (ptr[j] == 0) {
                                        *ptr2++ = RLE_CODE | 1;
                                        *ptr2++ = 255;
@@ -1072,6 +1074,57 @@ void rle_swap_0_255(grs_bitmap *bmp)
                                        *ptr2++ = ptr[j];
                        }
                }
+               if (rle_big)                // set line size
+                       *((unsigned short *)&temp[4 + 2 * i]) = ptr2 - start;
+               else
+                       temp[4 + i] = ptr2 - start;
+               ptr += line_size;           // go to next line
+       }
+       len = ptr2 - temp;
+       *((int *)temp) = len;           // set total size
+       memcpy(bmp->bm_data, temp, len);
+       d_free(temp);
+}
+
+/*
+ * remaps all entries using colormap in an RLE bitmap without uncompressing it
+ */
+void rle_remap(grs_bitmap *bmp, ubyte *colormap)
+{
+       int i, j, len, rle_big;
+       unsigned char *ptr, *ptr2, *temp, *start;
+       unsigned short line_size;
+
+       rle_big = bmp->bm_flags & BM_FLAG_RLE_BIG;
+
+       temp = d_malloc(4 + bmp->bm_h + (bmp->bm_w + 1) * bmp->bm_h + 30000);
+
+       if (rle_big) {                  // set ptrs to first lines
+               ptr = bmp->bm_data + 4 + 2 * bmp->bm_h;
+               ptr2 = temp + 4 + 2 * bmp->bm_h;
+       } else {
+               ptr = bmp->bm_data + 4 + bmp->bm_h;
+               ptr2 = temp + 4 + bmp->bm_h;
+       }
+       for (i = 0; i < bmp->bm_h; i++) {
+               start = ptr2;
+               if (rle_big)
+                       line_size = *((unsigned short *)&bmp->bm_data[4 + 2 * i]);
+               else
+                       line_size = bmp->bm_data[4 + i];
+               for (j = 0; j < line_size; j++) {
+                       if ( ! IS_RLE_CODE(ptr[j])) {
+                               if (IS_RLE_CODE(colormap[ptr[j]])) 
+                                       *ptr2++ = RLE_CODE | 1; // add "escape sequence"
+                               *ptr2++ = colormap[ptr[j]]; // translate
+                       } else {
+                               *ptr2++ = ptr[j]; // just copy current rle code
+                               if ((ptr[j] & NOT_RLE_CODE) == 0)
+                                       break;
+                               j++;
+                               *ptr2++ = colormap[ptr[j]]; // translate
+                       }
+               }
                if (rle_big)                // set line size
                        *((unsigned short *)&temp[4 + 2 * i]) = INTEL_SHORT(ptr2 - start);
                else
index 2396f53..eba514d 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2003-03-19  Martin Schaffner <maschaffner@gmx.ch>
+
+       * 2d/rle.c, include/gr.h, include/rle.h, main/bm.c, main/bm.h,
+       main/gamemine.c, main/gamemine.h, main/gameseq.c, main/piggy.c,
+       main/piggy.h: if descent.pig available, load d1 textures for d1
+       levels
+
 2003-03-19  Bradley Bell  <btb@icculus.org>
 
        * 2d/font.c, 2d/palette.c, 3d/interp.c, 3d/setup.c,
index a41217c..5900fe4 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: gr.h,v 1.18 2002-09-18 18:16:13 btb Exp $ */
+/* $Id: gr.h,v 1.19 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -424,6 +424,8 @@ extern void gr_remap_bitmap( grs_bitmap * bmp, ubyte * palette, int transparent_
 // 18-bit accurracy instead of 15bit when translating colors.
 extern void gr_remap_bitmap_good( grs_bitmap * bmp, ubyte * palette, int transparent_color, int super_transparent_color );
 
+extern void build_colormap_good( ubyte * palette, ubyte * colormap, int * freq );
+
 extern void gr_palette_step_up( int r, int g, int b );
 
 extern void gr_bitmap_check_transparency( grs_bitmap * bmp );
index fe03aa6..5d51758 100644 (file)
@@ -57,4 +57,6 @@ void rle_cache_flush();
 
 void rle_swap_0_255(grs_bitmap *bmp);
 
+void rle_remap(grs_bitmap *bmp, ubyte *colormap);
+
 #endif
index de7f9cd..5fa8869 100644 (file)
--- a/main/bm.c
+++ b/main/bm.c
@@ -1,4 +1,4 @@
-/* $Id: bm.c,v 1.21 2003-02-21 07:14:32 btb Exp $ */
+/* $Id: bm.c,v 1.22 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -121,6 +121,20 @@ int tmap_info_read_n(tmap_info *ti, int n, CFILE *fp)
 }
 #endif
 
+int tmap_info_read_n_d1(tmap_info *ti, int n, CFILE *fp)
+{
+       int i;
+
+       for (i = 0; i < n; i++) {
+               cfseek(fp, 13, SEEK_CUR);// skip filename
+               ti[i].flags = cfile_read_byte(fp);
+               ti[i].lighting = cfile_read_fix(fp);
+               ti[i].damage = cfile_read_fix(fp);
+               ti[i].eclip_num = cfile_read_int(fp);
+       }
+       return i;
+}
+
 extern int Num_bitmap_files;
 int extra_bitmap_num;
 
@@ -345,6 +359,146 @@ void bm_read_all(CFILE * fp)
 
 }
 
+#define D1_MAX_TEXTURES 800
+#define D1_MAX_SOUNDS 250
+#define D1_MAX_VCLIPS 70
+#define D1_MAX_EFFECTS 60
+#define D1_MAX_WALL_ANIMS 30
+#define D1_MAX_ROBOT_TYPES 30
+#define D1_MAX_ROBOT_JOINTS 600
+#define D1_MAX_WEAPON_TYPES 30
+#define D1_MAX_POWERUP_TYPES 29
+#define D1_MAX_GAUGE_BMS 80
+#define D1_MAX_OBJ_BITMAPS 210
+#define D1_MAX_COCKPIT_BITMAPS 4
+#define D1_MAX_OBJTYPE 100
+#define D1_MAX_POLYGON_MODELS 85
+
+#define D1_TMAP_INFO_SIZE 26
+#define D1_VCLIP_SIZE 66
+#define D1_ROBOT_INFO_SIZE 486
+#define D1_WEAPON_INFO_SIZE 115
+
+#define D1_LAST_STATIC_TMAP_NUM 324
+short *d2_Textures_backup = NULL;
+
+void undo_bm_read_all_d1() {
+       if (d2_Textures_backup) {
+               int i;
+               for (i = 0; i < D1_LAST_STATIC_TMAP_NUM; i++)
+                       Textures[i].index = d2_Textures_backup[i];
+               d_free(d2_Textures_backup);
+               d2_Textures_backup = NULL;
+       }
+}
+
+/*
+ * used by piggy_d1_init to read in descent 1 pigfile
+ */
+void bm_read_all_d1(CFILE * fp)
+{
+       int i;
+
+       /*NumTextures = */ cfile_read_int(fp);
+       //bitmap_index_read_n(Textures, D1_MAX_TEXTURES, fp );
+       //for (i = 0; i < D1_MAX_TEXTURES; i++)
+       //      Textures[i].index = cfile_read_short(fp) + 600;  
+       //cfseek(fp, D1_MAX_TEXTURES * sizeof(short), SEEK_CUR);
+       MALLOC(d2_Textures_backup, short, D1_LAST_STATIC_TMAP_NUM);
+       for (i = 0; i < D1_LAST_STATIC_TMAP_NUM; i++) {
+               d2_Textures_backup[i] = Textures[i].index;
+               Textures[i].index = cfile_read_short(fp) + 521;
+       }
+       cfseek(fp, (D1_MAX_TEXTURES - D1_LAST_STATIC_TMAP_NUM) * sizeof(short), SEEK_CUR);
+
+       //tmap_info_read_n_d1(TmapInfo, D1_MAX_TEXTURES, fp);
+       cfseek(fp, D1_MAX_TEXTURES * D1_TMAP_INFO_SIZE, SEEK_CUR);
+
+       /*
+       cfread( Sounds, sizeof(ubyte), D1_MAX_SOUNDS, fp );
+       cfread( AltSounds, sizeof(ubyte), D1_MAX_SOUNDS, fp );
+       */cfseek(fp, D1_MAX_SOUNDS * 2, SEEK_CUR);
+
+       /*Num_vclips = */ cfile_read_int(fp);
+       //vclip_read_n(Vclip, D1_MAX_VCLIPS, fp);
+       cfseek(fp, D1_MAX_VCLIPS * D1_VCLIP_SIZE, SEEK_CUR);
+
+       /*
+       Num_effects = cfile_read_int(fp);
+       eclip_read_n(Effects, D1_MAX_EFFECTS, fp);
+
+       Num_wall_anims = cfile_read_int(fp);
+       wclip_read_n_d1(WallAnims, D1_MAX_WALL_ANIMS, fp);
+       */
+
+       /*
+       N_robot_types = cfile_read_int(fp);
+       //robot_info_read_n(Robot_info, D1_MAX_ROBOT_TYPES, fp);
+       cfseek(fp, D1_MAX_ROBOT_TYPES * D1_ROBOT_INFO_SIZE, SEEK_CUR);
+
+       N_robot_joints = cfile_read_int(fp);
+       jointpos_read_n(Robot_joints, D1_MAX_ROBOT_JOINTS, fp);
+
+       N_weapon_types = cfile_read_int(fp);
+       //weapon_info_read_n(Weapon_info, D1_MAX_WEAPON_TYPES, fp, Piggy_hamfile_version);
+       cfseek(fp, D1_MAX_WEAPON_TYPES * D1_WEAPON_INFO_SIZE, SEEK_CUR);
+
+       N_powerup_types = cfile_read_int(fp);
+       powerup_type_info_read_n(Powerup_info, D1_MAX_POWERUP_TYPES, fp);
+       */
+
+       /* in the following code are bugs, solved by hack
+       N_polygon_models = cfile_read_int(fp);
+       polymodel_read_n(Polygon_models, N_polygon_models, fp);
+       for (i=0; i<N_polygon_models; i++ )
+               polygon_model_data_read(&Polygon_models[i], fp);
+       */cfseek(fp, 521490-160, SEEK_SET); // OK, I admit, this is a dirty hack
+       //bitmap_index_read_n(Gauges, D1_MAX_GAUGE_BMS, fp);
+       cfseek(fp, D1_MAX_GAUGE_BMS * sizeof(bitmap_index), SEEK_CUR);
+
+       /*
+       for (i = 0; i < D1_MAX_POLYGON_MODELS; i++)
+               Dying_modelnums[i] = cfile_read_int(fp);
+       for (i = 0; i < D1_MAX_POLYGON_MODELS; i++)
+               Dead_modelnums[i] = cfile_read_int(fp);
+       */ cfseek(fp, D1_MAX_POLYGON_MODELS * 8, SEEK_CUR);
+
+       //bitmap_index_read_n(ObjBitmaps, D1_MAX_OBJ_BITMAPS, fp);
+       cfseek(fp, D1_MAX_OBJ_BITMAPS * sizeof(bitmap_index), SEEK_CUR);
+       for (i = 0; i < D1_MAX_OBJ_BITMAPS; i++)
+               cfseek(fp, 2, SEEK_CUR);//ObjBitmapPtrs[i] = cfile_read_short(fp);
+
+       //player_ship_read(&only_player_ship, fp);
+       cfseek(fp, sizeof(player_ship), SEEK_CUR);
+
+       /*Num_cockpits = */ cfile_read_int(fp);
+       //bitmap_index_read_n(cockpit_bitmap, D1_MAX_COCKPIT_BITMAPS, fp);
+       cfseek(fp, D1_MAX_COCKPIT_BITMAPS * sizeof(bitmap_index), SEEK_CUR);
+
+       /*
+       cfread( Sounds, sizeof(ubyte), D1_MAX_SOUNDS, fp );
+       cfread( AltSounds, sizeof(ubyte), D1_MAX_SOUNDS, fp );
+       */cfseek(fp, D1_MAX_SOUNDS * 2, SEEK_CUR);
+
+       /*Num_total_object_types = */ cfile_read_int( fp );
+       /*
+       cfread( ObjType, sizeof(byte), D1_MAX_OBJTYPE, fp );
+       cfread( ObjId, sizeof(byte), D1_MAX_OBJTYPE, fp );
+       for (i=0; i<D1_MAX_OBJTYPE; i++ )
+               ObjStrength[i] = cfile_read_int( fp );
+       */ cfseek(fp, D1_MAX_OBJTYPE * 6, SEEK_CUR);
+
+       /*First_multi_bitmap_num =*/ cfile_read_int(fp);
+       /*Reactors[0].n_guns = */ cfile_read_int( fp );
+       /*for (i=0; i<4; i++)
+               cfile_read_vector(&(Reactors[0].gun_points[i]), fp);
+       for (i=0; i<4; i++)
+               cfile_read_vector(&(Reactors[0].gun_dirs[i]), fp);
+       */cfseek(fp, 8 * 12, SEEK_CUR);
+
+       /*exit_modelnum = */ cfile_read_int(fp);
+       /*destroyed_exit_modelnum = */ cfile_read_int(fp);
+}
 
 //these values are the number of each item in the release of d2
 //extra items added after the release get written in an additional hamfile
index 989bfec..72fa936 100644 (file)
--- a/main/bm.h
+++ b/main/bm.h
@@ -1,4 +1,4 @@
-/* $Id: bm.h,v 1.7 2003-03-14 21:24:03 btb Exp $ */
+/* $Id: bm.h,v 1.8 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -96,6 +96,9 @@ int bm_init_use_tbl(void);
 
 extern void bm_read_all(CFILE * fp);
 
+extern void bm_read_all_d1(CFILE * fp);
+extern void undo_bm_read_all_d1(void);
+
 int load_exit_models();
 void free_exit_model_data();
 
index aa22ad8..71c6703 100644 (file)
@@ -17,7 +17,7 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #endif
 
 #ifdef RCS
-static char rcsid[] = "$Id: gamemine.c,v 1.20 2003-03-14 22:08:22 btb Exp $";
+static char rcsid[] = "$Id: gamemine.c,v 1.21 2003-03-19 22:44:15 btb Exp $";
 #endif
 
 #include <stdio.h>
@@ -143,6 +143,8 @@ int CreateDefaultNewSegment();
 
 int New_file_format_load = 1; // "new file format" is everything newer than d1 shareware
 
+int d1_pig_loaded = 0; // can descent.pig from descent 1 be loaded?
+
 #define TMAP_NUM_MASK 0x3FFF
 
 /* converts descent 1 texture numbers to descent 2 texture numbers
@@ -150,6 +152,8 @@ int New_file_format_load = 1; // "new file format" is everything newer than d1 s
  * updated using the file config/convtabl.ini from the devil 2.2 level editor
  */
 short convert_d1_tmap_num(short d1_tmap_num) {
+       if (d1_pig_loaded && d1_tmap_num < 324) // we use original d1 textures for non-animated textures
+               return d1_tmap_num;
        switch (d1_tmap_num) {
        case   0:  return  43; // grey (devil:95)
        case   1: return 0;
index c70b747..11a572a 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: gamemine.h,v 1.3 2002-08-02 23:28:40 btb Exp $ */
+/* $Id: gamemine.h,v 1.4 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -119,4 +119,6 @@ extern short tmap_xlate_table[];
 extern fix Level_shake_frequency, Level_shake_duration;
 extern int Secret_return_segment;
 extern vms_matrix Secret_return_orient;
-#endif
+extern int d1_pig_loaded; // has descent.pig from descent 1 been loaded?
+
+#endif // _GAMEMINE_H
index 36d29ee..89fc01a 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: gameseq.c,v 1.18 2003-03-15 03:55:52 btb Exp $ */
+/* $Id: gameseq.c,v 1.19 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -17,7 +17,7 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #endif
 
 #ifdef RCS
-char gameseq_rcsid[] = "$Id: gameseq.c,v 1.18 2003-03-15 03:55:52 btb Exp $";
+char gameseq_rcsid[] = "$Id: gameseq.c,v 1.19 2003-03-19 22:44:15 btb Exp $";
 #endif
 
 #ifdef WINDOWS
@@ -110,6 +110,7 @@ char gameseq_rcsid[] = "$Id: gameseq.c,v 1.18 2003-03-15 03:55:52 btb Exp $";
 #include "movie.h"
 #include "controls.h"
 #include "credits.h"
+#include "gamemine.h"
 
 #if defined(POLY_ACC)
 #include "poly_acc.h"
@@ -121,8 +122,10 @@ char gameseq_rcsid[] = "$Id: gameseq.c,v 1.18 2003-03-15 03:55:52 btb Exp $";
 #ifdef EDITOR
 #include "editor/editor.h"
 #endif
+
 #include "makesig.h"
 #include "strutil.h"
+#include "rle.h"
 
 void StartNewLevelSecret(int level_num, int page_in_textures);
 void InitPlayerPosition(int random_flag);
@@ -828,6 +831,14 @@ void free_bitmap_replacements()
        }
 }
 
+void clear_bitmap_replacement()
+{
+       if (Bitmap_replacement_data) {
+               d_free(Bitmap_replacement_data);
+               Bitmap_replacement_data = NULL;
+       }
+}
+
 void load_bitmap_replacements(char *level_name)
 {
        char ifile_name[FILENAME_LEN];
@@ -900,6 +911,121 @@ void load_bitmap_replacements(char *level_name)
        atexit(free_bitmap_replacements);
 }
 
+#define FIRST_D1_TEXTURE 722
+#define LAST_D1_STATIC_TEXTURE 1042//1342 //afterwards, we have door frames and stuff
+#define FIRST_D2_TEXTURE 1243
+
+void load_d1_bitmap_replacements()
+{
+       CFILE * Piggy_fp;
+       int i;
+       grs_bitmap temp_bitmap;
+       DiskBitmapHeader bmh;
+       int current_pos, zsize;
+       int bitmap_data_start, pig_data_start;
+       int N_bitmaps;
+       ubyte colormap[256];
+       ubyte *next_bitmap; // where we write the next bitmap to
+
+#ifndef MACINTOSH
+       Piggy_fp = cfopen( "descent.pig", "rb" );
+#else
+       Piggy_fp = cfopen( "Data:Descent.pig", "rb" );
+#endif  // end of ifndef/else MACINTOSH
+
+       if (!Piggy_fp)
+               return; // use d2 bitmaps instead...
+
+       clear_bitmap_replacement();
+
+       // read d1 palette, build colormap
+       {
+               int freq[256];
+               ubyte d1_palette[256*3];
+               CFILE * palette_file = cfopen( "palette.256", "rb" );
+               Assert( palette_file );
+               Assert( cfilelength( palette_file ) == 9472 );
+               cfread( d1_palette, 256, 3, palette_file);
+               cfclose( palette_file );
+               build_colormap_good( d1_palette, colormap, freq );
+               // don't change transparencies:
+               colormap[254] = 254;
+               colormap[255] = 255;
+       }
+
+
+       if (0) //TODO: put here cfilelength(Piggy_fp) == D1_PIG_SHARE
+               pig_data_start = 0;
+       else {
+               //int i;
+               pig_data_start = cfile_read_int(Piggy_fp );
+               bm_read_all_d1( Piggy_fp );
+               //for (i = 0; i < 1800; i++) GameBitmapXlat[i] = cfile_read_short(Piggy_fp);
+       }
+       cfseek( Piggy_fp, pig_data_start, SEEK_SET );
+       N_bitmaps = cfile_read_int(Piggy_fp);
+       {
+               int N_sounds = cfile_read_int(Piggy_fp);
+               int header_size = N_bitmaps * DISKBITMAPHEADER_D1_SIZE
+                               + N_sounds * DISKSOUNDHEADER_SIZE;
+               bitmap_data_start = pig_data_start + 2*sizeof(int) + header_size;
+       }
+       
+       MALLOC( Bitmap_replacement_data, ubyte, cfilelength(Piggy_fp) - bitmap_data_start ); // too much
+       //TODO: handle case where b_r_d == 0! (have to convert textures, return, not bm_read_all_d1)
+
+       next_bitmap = Bitmap_replacement_data;
+
+       for (i=1; i<=N_bitmaps; i++ ) {
+               DiskBitmapHeader_d1_read(&bmh, Piggy_fp);
+
+               // only change wall texture bitmaps
+               if (i >= FIRST_D1_TEXTURE && i <= LAST_D1_STATIC_TEXTURE) {
+                       current_pos = cftell(Piggy_fp);
+                       memset( &temp_bitmap, 0, sizeof(grs_bitmap) );
+               
+                       temp_bitmap.bm_w = temp_bitmap.bm_rowsize = bmh.width + ((short) (bmh.wh_extra&0x0f)<<8);
+                       temp_bitmap.bm_h = bmh.height + ((short) (bmh.wh_extra&0xf0)<<4);
+                       temp_bitmap.avg_color = bmh.avg_color;
+
+                       //GameBitmapFlags[convert_d1_bitmap_num(i)] = 0;
+                       
+                       if ( bmh.flags & BM_FLAG_TRANSPARENT )
+                               temp_bitmap.bm_flags |= BM_FLAG_TRANSPARENT;
+                       if ( bmh.flags & BM_FLAG_SUPER_TRANSPARENT )
+                               temp_bitmap.bm_flags |= BM_FLAG_SUPER_TRANSPARENT;
+                       if ( bmh.flags & BM_FLAG_NO_LIGHTING )
+                               temp_bitmap.bm_flags |= BM_FLAG_NO_LIGHTING;
+                       if ( bmh.flags & BM_FLAG_RLE )
+                               temp_bitmap.bm_flags |= BM_FLAG_RLE;
+                       if ( bmh.flags & BM_FLAG_RLE_BIG )
+                               temp_bitmap.bm_flags |= BM_FLAG_RLE_BIG;
+                               
+                       temp_bitmap.bm_data = next_bitmap;
+
+                       cfseek(Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
+                       zsize = cfile_read_int(Piggy_fp);
+                       cfseek(Piggy_fp, bitmap_data_start + bmh.offset, SEEK_SET);
+                       cfread(next_bitmap, 1, zsize, Piggy_fp);
+                       cfseek(Piggy_fp, current_pos, SEEK_SET);
+
+                       //rle_swap_0_255(&temp_bitmap);
+                       rle_remap(&temp_bitmap, colormap);
+                       GameBitmaps[i + FIRST_D2_TEXTURE - FIRST_D1_TEXTURE] = temp_bitmap;
+
+                       memcpy(&zsize, temp_bitmap.bm_data, 4);
+                       next_bitmap += zsize;
+               }
+       }
+
+       cfclose(Piggy_fp);
+
+       last_palette_loaded_pig[0]= 0;  //force pig re-load
+
+       texmerge_flush();               //for re-merging with new textures
+}
+
+
 void load_robot_replacements(char *level_name);
 int read_hamfile();
 extern int Robot_replacements_loaded;
@@ -920,6 +1046,9 @@ void LoadLevel(int level_num,int page_in_textures)
        else                                    //normal level
                level_name = Level_names[level_num-1];
 
+       undo_bm_read_all_d1();
+       d1_pig_loaded = cfexist("descent.pig");
+
        #ifdef WINDOWS
                dd_gr_set_current_canvas(NULL);
                dd_gr_clear_canvas(BM_XRGB(0,0,0));
@@ -957,6 +1086,9 @@ void LoadLevel(int level_num,int page_in_textures)
        if ( page_in_textures )
                piggy_load_level_data();
 
+       if (Mission_list[Current_mission_num].descent_version == 1)
+               load_d1_bitmap_replacements();
+       else 
        load_bitmap_replacements(level_name);
 
        if (Robot_replacements_loaded) {
index 6eb5e08..30d33e6 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: piggy.c,v 1.22 2003-03-14 21:59:19 btb Exp $ */
+/* $Id: piggy.c,v 1.23 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -17,7 +17,7 @@ COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #endif
 
 #ifdef RCS
-static char rcsid[] = "$Id: piggy.c,v 1.22 2003-03-14 21:59:19 btb Exp $";
+static char rcsid[] = "$Id: piggy.c,v 1.23 2003-03-19 22:44:15 btb Exp $";
 #endif
 
 
@@ -1828,3 +1828,18 @@ void DiskSoundHeader_read(DiskSoundHeader *dsh, CFILE *fp)
        dsh->offset = cfile_read_int(fp);
 }
 #endif // FAST_FILE_IO
+
+/*
+ * reads a descent 1 DiskBitmapHeader structure from a CFILE
+ */
+void DiskBitmapHeader_d1_read(DiskBitmapHeader *dbh, CFILE *fp)
+{
+       cfread(dbh->name, 8, 1, fp);
+       dbh->dflags = cfile_read_byte(fp);
+       dbh->width = cfile_read_byte(fp);
+       dbh->height = cfile_read_byte(fp);
+       dbh->wh_extra = 0;
+       dbh->flags = cfile_read_byte(fp);
+       dbh->avg_color = cfile_read_byte(fp);
+       dbh->offset = cfile_read_int(fp);
+}
index ac45244..e50044e 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: piggy.h,v 1.10 2002-08-27 04:14:58 btb Exp $ */
+/* $Id: piggy.h,v 1.11 2003-03-19 22:44:15 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -32,6 +32,7 @@ extern int Num_aliases;
 
 extern int Piggy_hamfile_version;
 
+// an index into the bitmap collection of the piggy file
 typedef struct bitmap_index {
        ushort index;
 } __pack__ bitmap_index;
@@ -48,6 +49,7 @@ typedef struct DiskBitmapHeader {
 } __pack__ DiskBitmapHeader;
 
 #define DISKBITMAPHEADER_SIZE 18 // for disk i/o
+#define DISKBITMAPHEADER_D1_SIZE 17 // for disk i/o
 
 typedef struct DiskSoundHeader {
        char name[8];
@@ -139,6 +141,11 @@ void DiskBitmapHeader_read(DiskBitmapHeader *dbh, CFILE *fp);
  * reads a DiskSoundHeader structure from a CFILE
  */
 void DiskSoundHeader_read(DiskSoundHeader *dsh, CFILE *fp);
-#endif
+#endif // FAST_FILE_IO
 
-#endif
+/*
+ * reads a descent 1 DiskBitmapHeader structure from a CFILE
+ */
+void DiskBitmapHeader_d1_read(DiskBitmapHeader *dbh, CFILE *fp);
+
+#endif //_PIGGY_H