main/gamemine.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #ifdef RCS
  15 static char rcsid[] = "$Id: gamemine.c,v 1.1.1.1 2001-01-19 03:30:01 bradleyb Exp $";
  16 #endif
  17
  18 #include <conf.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <math.h>
  22 #include <string.h>
  23
  24 #include "pstypes.h"
  25 #include "mono.h"
  26
  27 #include "inferno.h"
  28 #include "segment.h"
  29 #include "textures.h"
  30 #include "wall.h"
  31 #include "object.h"
  32 #include "gamemine.h"
  33 #include "error.h"
  34 #include "gameseg.h"
  35 #include "switch.h"
  36
  37 #include "game.h"
  38 #include "newmenu.h"
  39
  40 #ifdef EDITOR
  41 #include "editor\editor.h"
  42 #endif
  43
  44 #include "cfile.h"
  45 #include "fuelcen.h"
  46
  47 #include "hash.h"
  48 #include "key.h"
  49 #include "piggy.h"
  50
  51 #include "byteswap.h"
  52
  53 #define REMOVE_EXT(s)  (*(strchr( (s), '.' ))='\0')
  54
  55 fix     Level_shake_frequency = 0, Level_shake_duration = 0;
  56 int     Secret_return_segment = 0;
  57 vms_matrix      Secret_return_orient;
  58
  59 struct mtfi mine_top_fileinfo;    // Should be same as first two fields below...
  60 struct mfi mine_fileinfo;
  61 struct mh mine_header;
  62 struct me mine_editor;
  63
  64 typedef struct v16_segment {
  65         #ifdef  EDITOR
  66         short           segnum;                                                         // segment number, not sure what it means
  67         #endif
  68         side            sides[MAX_SIDES_PER_SEGMENT];   // 6 sides
  69         short           children[MAX_SIDES_PER_SEGMENT];        // indices of 6 children segments, front, left, top, right, bottom, back
  70         short           verts[MAX_VERTICES_PER_SEGMENT];        // vertex ids of 4 front and 4 back vertices
  71         #ifdef  EDITOR
  72         short           group;                                                          // group number to which the segment belongs.
  73         #endif
  74         short           objects;                                                                // pointer to objects in this segment
  75         ubyte           special;                                                                // what type of center this is
  76         byte            matcen_num;                                                     //      which center segment is associated with.
  77         short           value;
  78         fix             static_light;                                           //average static light in segment
  79         #ifndef EDITOR
  80         short           pad;                    //make structure longword aligned
  81         #endif
  82 } v16_segment;
  83
  84 struct mfi_v19 {
  85         ushort  fileinfo_signature;
  86         ushort  fileinfo_version;
  87         int             fileinfo_sizeof;
  88         int             header_offset;          // Stuff common to game & editor
  89         int             header_size;
  90         int             editor_offset;   // Editor specific stuff
  91         int             editor_size;
  92         int             segment_offset;
  93         int             segment_howmany;
  94         int             segment_sizeof;
  95         int             newseg_verts_offset;
  96         int             newseg_verts_howmany;
  97         int             newseg_verts_sizeof;
  98         int             group_offset;
  99         int             group_howmany;
 100         int             group_sizeof;
 101         int             vertex_offset;
 102         int             vertex_howmany;
 103         int             vertex_sizeof;
 104         int             texture_offset;
 105         int             texture_howmany;
 106         int             texture_sizeof;
 107         int             walls_offset;
 108         int             walls_howmany;
 109         int             walls_sizeof;
 110         int             triggers_offset;
 111         int             triggers_howmany;
 112         int             triggers_sizeof;
 113         int             links_offset;
 114         int             links_howmany;
 115         int             links_sizeof;
 116         int             object_offset;                          // Object info
 117         int             object_howmany;
 118         int             object_sizeof;
 119         int             unused_offset;                  //was: doors_offset
 120         int             unused_howmamy;         //was: doors_howmany
 121         int             unused_sizeof;                  //was: doors_sizeof
 122         short           level_shake_frequency, level_shake_duration;    //      Shakes every level_shake_frequency seconds
 123                                                                                                                                                         // for level_shake_duration seconds (on average, random).  In 16ths second.
 124         int             secret_return_segment;
 125         vms_matrix      secret_return_orient;
 126
 127         int             dl_indices_offset;
 128         int             dl_indices_howmany;
 129         int             dl_indices_sizeof;
 130
 131         int             delta_light_offset;
 132         int             delta_light_howmany;
 133         int             delta_light_sizeof;
 134
 135 };
 136
 137 int CreateDefaultNewSegment();
 138
 139 // hmm.. moved here by allender from gamesave.c -- We should really put these
 140 // routines into the cfile library (i.e. cfile_read_int, etc....)
 141 // This is yet another quick and dirty hack....yeech
 142
 143 static fix read_fix(CFILE *file)
 144 {
 145         fix f;
 146
 147         if (cfread( &f, sizeof(f), 1, file) != 1)
 148                 Error( "Error reading fix in gamesave.c" );
 149
 150         f = (fix)INTEL_INT((int)f);
 151         return f;
 152 }
 153
 154 static void read_vector(vms_vector *v,CFILE *file)
 155 {
 156         v->x = read_fix(file);
 157         v->y = read_fix(file);
 158         v->z = read_fix(file);
 159 }
 160
 161 static short read_short(CFILE *file)
 162 {
 163         short s;
 164
 165         if (cfread( &s, sizeof(s), 1, file) != 1)
 166                 Error( "Error reading short in gamesave.c" );
 167
 168         s = INTEL_SHORT(s);
 169         return s;
 170 }
 171
 172 static byte read_byte(CFILE *file)
 173 {
 174         byte b;
 175
 176         if (cfread( &b, sizeof(b), 1, file) != 1)
 177                 Error( "Error reading byte in gamesave.c" );
 178
 179         return b;
 180 }
 181
 182 #ifdef EDITOR
 183
 184 static char old_tmap_list[MAX_TEXTURES][FILENAME_LEN];
 185 short tmap_xlate_table[MAX_TEXTURES];
 186 static short tmap_times_used[MAX_TEXTURES];
 187
 188 // -----------------------------------------------------------------------------
 189 //loads from an already-open file
 190 // returns 0=everything ok, 1=old version, -1=error
 191 int load_mine_data(CFILE *LoadFile)
 192 {
 193         int   i, j,oldsizeadjust;
 194         short tmap_xlate;
 195         int     translate;
 196         char    *temptr;
 197         int     mine_start = cftell(LoadFile);
 198
 199         oldsizeadjust=(sizeof(int)*2)+sizeof (vms_matrix);
 200         fuelcen_reset();
 201
 202         for (i=0; i<MAX_TEXTURES; i++ )
 203                 tmap_times_used[i] = 0;
 204
 205         #ifdef EDITOR
 206         // Create a new mine to initialize things.
 207         //texpage_goto_first();
 208         create_new_mine();
 209         #endif
 210
 211         //===================== READ FILE INFO ========================
 212
 213         // These are the default values... version and fileinfo_sizeof
 214         // don't have defaults.
 215         mine_fileinfo.header_offset     =   -1;
 216         mine_fileinfo.header_size       =   sizeof(mine_header);
 217         mine_fileinfo.editor_offset     =   -1;
 218         mine_fileinfo.editor_size       =   sizeof(mine_editor);
 219         mine_fileinfo.vertex_offset     =   -1;
 220         mine_fileinfo.vertex_howmany    =   0;
 221         mine_fileinfo.vertex_sizeof     =   sizeof(vms_vector);
 222         mine_fileinfo.segment_offset    =   -1;
 223         mine_fileinfo.segment_howmany   =   0;
 224         mine_fileinfo.segment_sizeof    =   sizeof(segment);
 225         mine_fileinfo.newseg_verts_offset     =   -1;
 226         mine_fileinfo.newseg_verts_howmany    =   0;
 227         mine_fileinfo.newseg_verts_sizeof     =   sizeof(vms_vector);
 228         mine_fileinfo.group_offset                =     -1;
 229         mine_fileinfo.group_howmany       =     0;
 230         mine_fileinfo.group_sizeof                =     sizeof(group);
 231         mine_fileinfo.texture_offset    =   -1;
 232         mine_fileinfo.texture_howmany   =   0;
 233         mine_fileinfo.texture_sizeof    =   FILENAME_LEN;  // num characters in a name
 234         mine_fileinfo.walls_offset                =     -1;
 235         mine_fileinfo.walls_howmany       =     0;
 236         mine_fileinfo.walls_sizeof                =     sizeof(wall);
 237         mine_fileinfo.triggers_offset     =     -1;
 238         mine_fileinfo.triggers_howmany  =       0;
 239         mine_fileinfo.triggers_sizeof     =     sizeof(trigger);
 240         mine_fileinfo.object_offset             =       -1;
 241         mine_fileinfo.object_howmany            =       1;
 242         mine_fileinfo.object_sizeof             =       sizeof(object);
 243
 244         mine_fileinfo.level_shake_frequency             =       0;
 245         mine_fileinfo.level_shake_duration              =       0;
 246
 247         //      Delta light stuff for blowing out light sources.
 248 //      if (mine_top_fileinfo.fileinfo_version >= 19) {
 249                 mine_fileinfo.dl_indices_offset         =       -1;
 250                 mine_fileinfo.dl_indices_howmany                =       0;
 251                 mine_fileinfo.dl_indices_sizeof         =       sizeof(dl_index);
 252
 253                 mine_fileinfo.delta_light_offset                =       -1;
 254                 mine_fileinfo.delta_light_howmany               =       0;
 255                 mine_fileinfo.delta_light_sizeof                =       sizeof(delta_light);
 256
 257 //      }
 258
 259         mine_fileinfo.segment2_offset           = -1;
 260         mine_fileinfo.segment2_howmany  = 0;
 261         mine_fileinfo.segment2_sizeof    = sizeof(segment2);
 262
 263         // Read in mine_top_fileinfo to get size of saved fileinfo.
 264
 265         memset( &mine_top_fileinfo, 0, sizeof(mine_top_fileinfo) );
 266
 267         if (cfseek( LoadFile, mine_start, SEEK_SET ))
 268                 Error( "Error moving to top of file in gamemine.c" );
 269
 270         if (cfread( &mine_top_fileinfo, sizeof(mine_top_fileinfo), 1, LoadFile )!=1)
 271                 Error( "Error reading mine_top_fileinfo in gamemine.c" );
 272
 273         if (mine_top_fileinfo.fileinfo_signature != 0x2884)
 274                 return -1;
 275
 276         // Check version number
 277         if (mine_top_fileinfo.fileinfo_version < COMPATIBLE_VERSION )
 278                 return -1;
 279
 280         // Now, Read in the fileinfo
 281         if (cfseek( LoadFile, mine_start, SEEK_SET ))
 282                 Error( "Error seeking to top of file in gamemine.c" );
 283
 284         if (cfread( &mine_fileinfo, mine_top_fileinfo.fileinfo_sizeof, 1, LoadFile )!=1)
 285                 Error( "Error reading mine_fileinfo in gamemine.c" );
 286
 287         if (mine_top_fileinfo.fileinfo_version < 18) {
 288                 mprintf((1, "Old version, setting shake intensity to 0.\n"));
 289                 Level_shake_frequency = 0;
 290                 Level_shake_duration = 0;
 291                 Secret_return_segment = 0;
 292                 Secret_return_orient = vmd_identity_matrix;
 293         } else {
 294                 Level_shake_frequency = mine_fileinfo.level_shake_frequency << 12;
 295                 Level_shake_duration = mine_fileinfo.level_shake_duration << 12;
 296                 Secret_return_segment = mine_fileinfo.secret_return_segment;
 297                 Secret_return_orient = mine_fileinfo.secret_return_orient;
 298         }
 299
 300         //===================== READ HEADER INFO ========================
 301
 302         // Set default values.
 303         mine_header.num_vertices        =   0;
 304         mine_header.num_segments        =   0;
 305
 306         if (mine_fileinfo.header_offset > -1 )
 307         {
 308                 if (cfseek( LoadFile, mine_fileinfo.header_offset, SEEK_SET ))
 309                         Error( "Error seeking to header_offset in gamemine.c" );
 310
 311                 if (cfread( &mine_header, mine_fileinfo.header_size, 1, LoadFile )!=1)
 312                         Error( "Error reading mine_header in gamemine.c" );
 313         }
 314
 315         //===================== READ EDITOR INFO ==========================
 316
 317         // Set default values
 318         mine_editor.current_seg         =   0;
 319         mine_editor.newsegment_offset   =   -1; // To be written
 320         mine_editor.newsegment_size     =   sizeof(segment);
 321         mine_editor.Curside             =   0;
 322         mine_editor.Markedsegp          =   -1;
 323         mine_editor.Markedside          =   0;
 324
 325         if (mine_fileinfo.editor_offset > -1 )
 326         {
 327                 if (cfseek( LoadFile, mine_fileinfo.editor_offset, SEEK_SET ))
 328                         Error( "Error seeking to editor_offset in gamemine.c" );
 329
 330                 if (cfread( &mine_editor, mine_fileinfo.editor_size, 1, LoadFile )!=1)
 331                         Error( "Error reading mine_editor in gamemine.c" );
 332         }
 333
 334         //===================== READ TEXTURE INFO ==========================
 335
 336         if ( (mine_fileinfo.texture_offset > -1) && (mine_fileinfo.texture_howmany > 0))
 337         {
 338                 if (cfseek( LoadFile, mine_fileinfo.texture_offset, SEEK_SET ))
 339                         Error( "Error seeking to texture_offset in gamemine.c" );
 340
 341                 for (i=0; i< mine_fileinfo.texture_howmany; i++ )
 342                 {
 343                         if (cfread( &old_tmap_list[i], mine_fileinfo.texture_sizeof, 1, LoadFile )!=1)
 344                                 Error( "Error reading old_tmap_list[i] in gamemine.c" );
 345                 }
 346         }
 347
 348         //=============== GENERATE TEXTURE TRANSLATION TABLE ===============
 349
 350         translate = 0;
 351
 352         Assert (NumTextures < MAX_TEXTURES);
 353
 354         {
 355                 hashtable ht;
 356
 357                 hashtable_init( &ht, NumTextures );
 358
 359                 // Remove all the file extensions in the textures list
 360
 361                 for (i=0;i<NumTextures;i++)     {
 362                         temptr = strchr(TmapInfo[i].filename, '.');
 363                         if (temptr) *temptr = '\0';
 364                         hashtable_insert( &ht, TmapInfo[i].filename, i );
 365                 }
 366
 367                 // For every texture, search through the texture list
 368                 // to find a matching name.
 369                 for (j=0;j<mine_fileinfo.texture_howmany;j++)   {
 370                         // Remove this texture name's extension
 371                         temptr = strchr(old_tmap_list[j], '.');
 372                         if (temptr) *temptr = '\0';
 373
 374                         tmap_xlate_table[j] = hashtable_search( &ht,old_tmap_list[j]);
 375                         if (tmap_xlate_table[j] < 0 )   {
 376                                 //tmap_xlate_table[j] = 0;
 377                                 // mprintf( (0, "Couldn't find texture '%s'\n", old_tmap_list[j] ));
 378                                 ;
 379                         }
 380                         if (tmap_xlate_table[j] != j ) translate = 1;
 381                         if (tmap_xlate_table[j] >= 0)
 382                                 tmap_times_used[tmap_xlate_table[j]]++;
 383                 }
 384
 385                 {
 386                         int count = 0;
 387                         for (i=0; i<MAX_TEXTURES; i++ )
 388                                 if (tmap_times_used[i])
 389                                         count++;
 390                         mprintf( (0, "This mine has %d unique textures in it (~%d KB)\n", count, (count*4096) /1024 ));
 391                 }
 392
 393                 // -- mprintf( (0, "Translate=%d\n", translate ));
 394
 395                 hashtable_free( &ht );
 396         }
 397
 398         //====================== READ VERTEX INFO ==========================
 399
 400         // New check added to make sure we don't read in too many vertices.
 401         if ( mine_fileinfo.vertex_howmany > MAX_VERTICES )
 402                 {
 403                 mprintf((0, "Num vertices exceeds maximum.  Loading MAX %d vertices\n", MAX_VERTICES));
 404                 mine_fileinfo.vertex_howmany = MAX_VERTICES;
 405                 }
 406
 407         if ( (mine_fileinfo.vertex_offset > -1) && (mine_fileinfo.vertex_howmany > 0))
 408         {
 409                 if (cfseek( LoadFile, mine_fileinfo.vertex_offset, SEEK_SET ))
 410                         Error( "Error seeking to vertex_offset in gamemine.c" );
 411
 412                 for (i=0; i< mine_fileinfo.vertex_howmany; i++ )
 413                 {
 414                         // Set the default values for this vertex
 415                         Vertices[i].x = 1;
 416                         Vertices[i].y = 1;
 417                         Vertices[i].z = 1;
 418
 419                         if (cfread( &Vertices[i], mine_fileinfo.vertex_sizeof, 1, LoadFile )!=1)
 420                                 Error( "Error reading Vertices[i] in gamemine.c" );
 421                 }
 422         }
 423
 424         //==================== READ SEGMENT INFO ===========================
 425
 426         // New check added to make sure we don't read in too many segments.
 427         if ( mine_fileinfo.segment_howmany > MAX_SEGMENTS ) {
 428                 mprintf((0, "Num segments exceeds maximum.  Loading MAX %d segments\n", MAX_SEGMENTS));
 429                 mine_fileinfo.segment_howmany = MAX_SEGMENTS;
 430                 mine_fileinfo.segment2_howmany = MAX_SEGMENTS;
 431         }
 432
 433         // [commented out by mk on 11/20/94 (weren't we supposed to hit final in October?) because it looks redundant.  I think I'll test it now...]  fuelcen_reset();
 434
 435         if ( (mine_fileinfo.segment_offset > -1) && (mine_fileinfo.segment_howmany > 0))        {
 436
 437                 if (cfseek( LoadFile, mine_fileinfo.segment_offset,SEEK_SET ))
 438
 439                         Error( "Error seeking to segment_offset in gamemine.c" );
 440
 441                 Highest_segment_index = mine_fileinfo.segment_howmany-1;
 442
 443                 for (i=0; i< mine_fileinfo.segment_howmany; i++ ) {
 444
 445                         // Set the default values for this segment (clear to zero )
 446                         //memset( &Segments[i], 0, sizeof(segment) );
 447
 448                         if (mine_top_fileinfo.fileinfo_version < 20) {
 449                                 v16_segment v16_seg;
 450
 451                                 Assert(mine_fileinfo.segment_sizeof == sizeof(v16_seg));
 452
 453                                 if (cfread( &v16_seg, mine_fileinfo.segment_sizeof, 1, LoadFile )!=1)
 454                                         Error( "Error reading segments in gamemine.c" );
 455
 456                                 #ifdef EDITOR
 457                                 Segments[i].segnum = v16_seg.segnum;
 458                                 // -- Segments[i].pad = v16_seg.pad;
 459                                 #endif
 460
 461                                 for (j=0; j<MAX_SIDES_PER_SEGMENT; j++)
 462                                         Segments[i].sides[j] = v16_seg.sides[j];
 463
 464                                 for (j=0; j<MAX_SIDES_PER_SEGMENT; j++)
 465                                         Segments[i].children[j] = v16_seg.children[j];
 466
 467                                 for (j=0; j<MAX_VERTICES_PER_SEGMENT; j++)
 468                                         Segments[i].verts[j] = v16_seg.verts[j];
 469
 470                                 Segment2s[i].special = v16_seg.special;
 471                                 Segment2s[i].value = v16_seg.value;
 472                                 Segment2s[i].s2_flags = 0;
 473                                 Segment2s[i].matcen_num = v16_seg.matcen_num;
 474                                 Segment2s[i].static_light = v16_seg.static_light;
 475                                 fuelcen_activate( &Segments[i], Segment2s[i].special );
 476
 477                         } else  {
 478                                 if (cfread( &Segments[i], mine_fileinfo.segment_sizeof, 1, LoadFile )!=1)
 479                                         Error("Unable to read segment %i\n", i);
 480                         }
 481
 482                         Segments[i].objects = -1;
 483                         #ifdef EDITOR
 484                         Segments[i].group = -1;
 485                         #endif
 486
 487                         if (mine_top_fileinfo.fileinfo_version < 15) {  //used old uvl ranges
 488                                 int sn,uvln;
 489
 490                                 for (sn=0;sn<MAX_SIDES_PER_SEGMENT;sn++)
 491                                         for (uvln=0;uvln<4;uvln++) {
 492                                                 Segments[i].sides[sn].uvls[uvln].u /= 64;
 493                                                 Segments[i].sides[sn].uvls[uvln].v /= 64;
 494                                                 Segments[i].sides[sn].uvls[uvln].l /= 32;
 495                                         }
 496                         }
 497
 498                         if (translate == 1)
 499                                 for (j=0;j<MAX_SIDES_PER_SEGMENT;j++) {
 500                                         unsigned short orient;
 501                                         tmap_xlate = Segments[i].sides[j].tmap_num;
 502                                         Segments[i].sides[j].tmap_num = tmap_xlate_table[tmap_xlate];
 503                                         if ((WALL_IS_DOORWAY(&Segments[i],j) & WID_RENDER_FLAG))
 504                                                 if (Segments[i].sides[j].tmap_num < 0)  {
 505                                                         mprintf( (0, "Couldn't find texture '%s' for Segment %d, side %d\n", old_tmap_list[tmap_xlate],i,j));
 506                                                         Int3();
 507                                                         Segments[i].sides[j].tmap_num = NumTextures-1;
 508                                                 }
 509                                         tmap_xlate = Segments[i].sides[j].tmap_num2 & 0x3FFF;
 510                                         orient = Segments[i].sides[j].tmap_num2 & (~0x3FFF);
 511                                         if (tmap_xlate != 0) {
 512                                                 int xlated_tmap = tmap_xlate_table[tmap_xlate];
 513
 514                                                 if ((WALL_IS_DOORWAY(&Segments[i],j) & WID_RENDER_FLAG))
 515                                                         if (xlated_tmap <= 0)   {
 516                                                                 mprintf( (0, "Couldn't find texture '%s' for Segment %d, side %d\n", old_tmap_list[tmap_xlate],i,j));
 517                                                                 Int3();
 518                                                                 Segments[i].sides[j].tmap_num2 = NumTextures-1;
 519                                                         }
 520                                                 Segments[i].sides[j].tmap_num2 = xlated_tmap | orient;
 521                                         }
 522                                 }
 523                 }
 524
 525
 526                 if (mine_top_fileinfo.fileinfo_version >= 20)
 527                         for (i=0; i<=Highest_segment_index; i++) {
 528                                 cfread(&Segment2s[i], sizeof(segment2), 1, LoadFile);
 529                                 fuelcen_activate( &Segments[i], Segment2s[i].special );
 530                         }
 531         }
 532
 533         //===================== READ NEWSEGMENT INFO =====================
 534
 535         #ifdef EDITOR
 536
 537         {               // Default segment created.
 538                 vms_vector      sizevec;
 539                 med_create_new_segment(vm_vec_make(&sizevec,DEFAULT_X_SIZE,DEFAULT_Y_SIZE,DEFAULT_Z_SIZE));             // New_segment = Segments[0];
 540                 //memset( &New_segment, 0, sizeof(segment) );
 541         }
 542
 543         if (mine_editor.newsegment_offset > -1)
 544         {
 545                 if (cfseek( LoadFile, mine_editor.newsegment_offset,SEEK_SET ))
 546                         Error( "Error seeking to newsegment_offset in gamemine.c" );
 547                 if (cfread( &New_segment, mine_editor.newsegment_size,1,LoadFile )!=1)
 548                         Error( "Error reading new_segment in gamemine.c" );
 549         }
 550
 551         if ( (mine_fileinfo.newseg_verts_offset > -1) && (mine_fileinfo.newseg_verts_howmany > 0))
 552         {
 553                 if (cfseek( LoadFile, mine_fileinfo.newseg_verts_offset, SEEK_SET ))
 554                         Error( "Error seeking to newseg_verts_offset in gamemine.c" );
 555                 for (i=0; i< mine_fileinfo.newseg_verts_howmany; i++ )
 556                 {
 557                         // Set the default values for this vertex
 558                         Vertices[NEW_SEGMENT_VERTICES+i].x = 1;
 559                         Vertices[NEW_SEGMENT_VERTICES+i].y = 1;
 560                         Vertices[NEW_SEGMENT_VERTICES+i].z = 1;
 561
 562                         if (cfread( &Vertices[NEW_SEGMENT_VERTICES+i], mine_fileinfo.newseg_verts_sizeof,1,LoadFile )!=1)
 563                                 Error( "Error reading Vertices[NEW_SEGMENT_VERTICES+i] in gamemine.c" );
 564
 565                         New_segment.verts[i] = NEW_SEGMENT_VERTICES+i;
 566                 }
 567         }
 568
 569         #endif
 570
 571         //========================= UPDATE VARIABLES ======================
 572
 573         #ifdef EDITOR
 574
 575         // Setting to Markedsegp to NULL ignores Curside and Markedside, which
 576         // we want to do when reading in an old file.
 577
 578         Markedside = mine_editor.Markedside;
 579         Curside = mine_editor.Curside;
 580         for (i=0;i<10;i++)
 581                 Groupside[i] = mine_editor.Groupside[i];
 582
 583         if ( mine_editor.current_seg != -1 )
 584                 Cursegp = mine_editor.current_seg + Segments;
 585         else
 586                 Cursegp = NULL;
 587
 588         if (mine_editor.Markedsegp != -1 )
 589                 Markedsegp = mine_editor.Markedsegp + Segments;
 590         else
 591                 Markedsegp = NULL;
 592
 593         num_groups = 0;
 594         current_group = -1;
 595
 596         #endif
 597
 598         Num_vertices = mine_fileinfo.vertex_howmany;
 599         Num_segments = mine_fileinfo.segment_howmany;
 600         Highest_vertex_index = Num_vertices-1;
 601         Highest_segment_index = Num_segments-1;
 602
 603         reset_objects(1);               //one object, the player
 604
 605         #ifdef EDITOR
 606         Highest_vertex_index = MAX_SEGMENT_VERTICES-1;
 607         Highest_segment_index = MAX_SEGMENTS-1;
 608         set_vertex_counts();
 609         Highest_vertex_index = Num_vertices-1;
 610         Highest_segment_index = Num_segments-1;
 611
 612         warn_if_concave_segments();
 613         #endif
 614
 615         #ifdef EDITOR
 616                 validate_segment_all();
 617         #endif
 618
 619         //create_local_segment_data();
 620
 621         //gamemine_find_textures();
 622
 623         if (mine_top_fileinfo.fileinfo_version < MINE_VERSION )
 624                 return 1;               //old version
 625         else
 626                 return 0;
 627
 628 }
 629 #endif
 630
 631 #define COMPILED_MINE_VERSION 0
 632
 633 void read_children(int segnum,ubyte bit_mask,CFILE *LoadFile)
 634 {
 635         int bit;
 636
 637         for (bit=0; bit<MAX_SIDES_PER_SEGMENT; bit++) {
 638                 if (bit_mask & (1 << bit)) {
 639                         Segments[segnum].children[bit] = read_short(LoadFile);
 640 //                      cfread( &Segments[segnum].children[bit], sizeof(short), 1, LoadFile );
 641                 } else
 642                         Segments[segnum].children[bit] = -1;
 643         }
 644 }
 645
 646 void read_verts(int segnum,CFILE *LoadFile)
 647 {
 648         int i;
 649         // Read short Segments[segnum].verts[MAX_VERTICES_PER_SEGMENT]
 650 //      cfread( Segments[segnum].verts, sizeof(short), MAX_VERTICES_PER_SEGMENT, LoadFile );
 651         for (i = 0; i < MAX_VERTICES_PER_SEGMENT; i++)
 652                 Segments[segnum].verts[i] = read_short(LoadFile);
 653 }
 654
 655 // -- void read_special(int segnum,ubyte bit_mask,CFILE *LoadFile)
 656 // -- {
 657 // --   if (bit_mask & (1 << MAX_SIDES_PER_SEGMENT)) {
 658 // --           // Read ubyte   Segments[segnum].special
 659 // -- //                cfread( &Segments[segnum].special, sizeof(ubyte), 1, LoadFile );
 660 // --           Segment2s[segnum].special = read_byte(LoadFile);
 661 // --           // Read byte    Segments[segnum].matcen_num
 662 // -- //                cfread( &Segments[segnum].matcen_num, sizeof(ubyte), 1, LoadFile );
 663 // --           Segment2s[segnum].matcen_num = read_byte(LoadFile);
 664 // --           // Read short   Segments[segnum].value
 665 // -- //                cfread( &Segments[segnum].value, sizeof(short), 1, LoadFile );
 666 // --           Segment2s[segnum].value = read_short(LoadFile);
 667 // --   } else {
 668 // --           Segment2s[segnum].special = 0;
 669 // --           Segment2s[segnum].matcen_num = -1;
 670 // --           Segment2s[segnum].value = 0;
 671 // --   }
 672 // -- }
 673
 674 int load_mine_data_compiled(CFILE *LoadFile)
 675 {
 676         int             i,segnum,sidenum;
 677         ubyte           version;
 678         short           temp_short;
 679         ushort  temp_ushort;
 680         ubyte           bit_mask;
 681
 682         //      For compiled levels, textures map to themselves, prevent tmap_override always being gray,
 683         //      bug which Matt and John refused to acknowledge, so here is Mike, fixing it.
 684 #ifdef EDITOR
 685         for (i=0; i<MAX_TEXTURES; i++)
 686                 tmap_xlate_table[i] = i;
 687 #endif
 688
 689 //      memset( Segments, 0, sizeof(segment)*MAX_SEGMENTS );
 690         fuelcen_reset();
 691
 692         //=============================== Reading part ==============================
 693 //      cfread( &version, sizeof(ubyte), 1, LoadFile );                                         // 1 byte = compiled version
 694         version = read_byte(LoadFile);
 695         Assert( version==COMPILED_MINE_VERSION );
 696
 697 //      cfread( &temp_ushort, sizeof(ushort), 1, LoadFile );                                    // 2 bytes = Num_vertices
 698 //      Num_vertices = temp_ushort;
 699         Num_vertices = read_short(LoadFile);
 700         Assert( Num_vertices <= MAX_VERTICES );
 701
 702 //      cfread( &temp_ushort, sizeof(ushort), 1, LoadFile );                                    // 2 bytes = Num_segments
 703 //      Num_segments = INTEL_SHORT(temp_ushort);
 704         Num_segments = read_short(LoadFile);
 705         Assert( Num_segments <= MAX_SEGMENTS );
 706
 707 //      cfread( Vertices, sizeof(vms_vector), Num_vertices, LoadFile );
 708
 709         for (i = 0; i < Num_vertices; i++)
 710                 read_vector( &(Vertices[i]), LoadFile);
 711
 712         for (segnum=0; segnum<Num_segments; segnum++ )  {
 713
 714                 #ifdef EDITOR
 715                 Segments[segnum].segnum = segnum;
 716                 Segments[segnum].group = 0;
 717                 #endif
 718
 719                 cfread( &bit_mask, sizeof(ubyte), 1, LoadFile );
 720
 721                 #if defined(SHAREWARE) && !defined(MACINTOSH)
 722                         // -- read_special(segnum,bit_mask,LoadFile);
 723                         read_verts(segnum,LoadFile);
 724                         read_children(segnum,bit_mask,LoadFile);
 725                 #else
 726                         read_children(segnum,bit_mask,LoadFile);
 727                         read_verts(segnum,LoadFile);
 728                         // --read_special(segnum,bit_mask,LoadFile);
 729                 #endif
 730
 731                 Segments[segnum].objects = -1;
 732
 733                 // Read fix     Segments[segnum].static_light (shift down 5 bits, write as short)
 734 //              cfread( &temp_ushort, sizeof(temp_ushort), 1, LoadFile );
 735 //              temp_ushort = read_short(LoadFile);
 736 //              Segment2s[segnum].static_light  = ((fix)temp_ushort) << 4;
 737                 //cfread( &Segments[segnum].static_light, sizeof(fix), 1, LoadFile );
 738
 739                 // Read the walls as a 6 byte array
 740                 for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ )      {
 741                         Segments[segnum].sides[sidenum].pad = 0;
 742                 }
 743
 744                 cfread( &bit_mask, sizeof(ubyte), 1, LoadFile );
 745                 for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++) {
 746                         ubyte byte_wallnum;
 747
 748                         if (bit_mask & (1 << sidenum)) {
 749                                 cfread( &byte_wallnum, sizeof(ubyte), 1, LoadFile );
 750                                 if ( byte_wallnum == 255 )
 751                                         Segments[segnum].sides[sidenum].wall_num = -1;
 752                                 else
 753                                         Segments[segnum].sides[sidenum].wall_num = byte_wallnum;
 754                         } else
 755                                         Segments[segnum].sides[sidenum].wall_num = -1;
 756                 }
 757
 758                 for (sidenum=0; sidenum<MAX_SIDES_PER_SEGMENT; sidenum++ )      {
 759
 760                         if ( (Segments[segnum].children[sidenum]==-1) || (Segments[segnum].sides[sidenum].wall_num!=-1) )       {
 761                                 // Read short Segments[segnum].sides[sidenum].tmap_num;
 762 //                              cfread( &temp_ushort, sizeof(ushort), 1, LoadFile );
 763                                 temp_ushort = read_short(LoadFile);
 764                                 Segments[segnum].sides[sidenum].tmap_num = temp_ushort & 0x7fff;
 765
 766                                 if (!(temp_ushort & 0x8000))
 767                                         Segments[segnum].sides[sidenum].tmap_num2 = 0;
 768                                 else {
 769                                         // Read short Segments[segnum].sides[sidenum].tmap_num2;
 770 //                                      cfread( &Segments[segnum].sides[sidenum].tmap_num2, sizeof(short), 1, LoadFile );
 771                                         Segments[segnum].sides[sidenum].tmap_num2 = read_short(LoadFile);
 772                                 }
 773
 774                                 // Read uvl Segments[segnum].sides[sidenum].uvls[4] (u,v>>5, write as short, l>>1 write as short)
 775                                 for (i=0; i<4; i++ )    {
 776 //                                      cfread( &temp_short, sizeof(short), 1, LoadFile );
 777                                         temp_short = read_short(LoadFile);
 778                                         Segments[segnum].sides[sidenum].uvls[i].u = ((fix)temp_short) << 5;
 779 //                                      cfread( &temp_short, sizeof(short), 1, LoadFile );
 780                                         temp_short = read_short(LoadFile);
 781                                         Segments[segnum].sides[sidenum].uvls[i].v = ((fix)temp_short) << 5;
 782 //                                      cfread( &temp_ushort, sizeof(temp_ushort), 1, LoadFile );
 783                                         temp_ushort = read_short(LoadFile);
 784                                         Segments[segnum].sides[sidenum].uvls[i].l = ((fix)temp_ushort) << 1;
 785                                         //cfread( &Segments[segnum].sides[sidenum].uvls[i].l, sizeof(fix), 1, LoadFile );
 786                                 }
 787                         } else {
 788                                 Segments[segnum].sides[sidenum].tmap_num = 0;
 789                                 Segments[segnum].sides[sidenum].tmap_num2 = 0;
 790                                 for (i=0; i<4; i++ )    {
 791                                         Segments[segnum].sides[sidenum].uvls[i].u = 0;
 792                                         Segments[segnum].sides[sidenum].uvls[i].v = 0;
 793                                         Segments[segnum].sides[sidenum].uvls[i].l = 0;
 794                                 }
 795                         }
 796                 }
 797         }
 798
 799 #if 0
 800         {
 801                 FILE *fp;
 802
 803                 fp = fopen("segments.out", "wt");
 804                 for (i = 0; i <= Highest_segment_index; i++) {
 805
 806         side            sides[MAX_SIDES_PER_SEGMENT];   // 6 sides
 807         short           children[MAX_SIDES_PER_SEGMENT];        // indices of 6 children segments, front, left, top, right, bottom, back
 808         short           verts[MAX_VERTICES_PER_SEGMENT];        // vertex ids of 4 front and 4 back vertices
 809         int             objects;                                                                // pointer to objects in this segment
 810
 811                         for (j = 0; j < MAX_SIDES_PER_SEGMENT; j++) {
 812         byte            type;                                                                   // replaces num_faces and tri_edge, 1 = quad, 2 = 0:2 triangulation, 3 = 1:3 triangulation
 813         ubyte           pad;                                                                    //keep us longword alligned
 814         short           wall_num;
 815         short           tmap_num;
 816         short           tmap_num2;
 817         uvl             uvls[4];
 818         vms_vector      normals[2];                                             // 2 normals, if quadrilateral, both the same.
 819                                 fprintf(fp, "%d\n", Segments[i].sides[j].type;
 820                                 fprintf(fp, "%d\n", Segments[i].sides[j].pad;
 821                                 fprintf(fp, "%d\n", Segments[i].sides[j].wall_num;
 822                                 fprintf(fp, "%d\n", Segments[i].tmap_num
 823
 824                 }
 825                 fclose(fp);
 826         }
 827 #endif
 828
 829         Highest_vertex_index = Num_vertices-1;
 830         Highest_segment_index = Num_segments-1;
 831
 832         validate_segment_all();                 // Fill in side type and normals.
 833
 834 // MIKE!!!!! You should know better than this when the mac is involved!!!!!!
 835
 836         for (i=0; i<Num_segments; i++) {
 837 // NO NO!!!!            cfread( &Segment2s[i], sizeof(segment2), 1, LoadFile );
 838                 Segment2s[i].special = read_byte(LoadFile);
 839                 Segment2s[i].matcen_num = read_byte(LoadFile);
 840                 Segment2s[i].value = read_byte(LoadFile);
 841                 Segment2s[i].s2_flags = read_byte(LoadFile);
 842                 Segment2s[i].static_light = read_fix(LoadFile);
 843                 fuelcen_activate( &Segments[i], Segment2s[i].special );
 844         }
 845
 846         reset_objects(1);               //one object, the player
 847
 848         return 0;
 849 }