/* $Id: gamemine.c,v 1.23 2003/04/12 02:52:38 btb Exp $ */ /* THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE. COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED. */ /* * * Functions for loading mines in the game * * Old Log: * Revision 1.2 1995/10/31 10:15:58 allender * code for shareware levels * * Revision 1.1 1995/05/16 15:25:29 allender * Initial revision * * Revision 2.2 1995/03/06 15:23:14 john * New screen techniques. * * Revision 2.1 1995/02/27 13:13:37 john * Removed floating point. * * Revision 2.0 1995/02/27 11:27:45 john * New version 2.0, which has no anonymous unions, builds with * Watcom 10.0, and doesn't require parsing BITMAPS.TBL. * * Revision 1.70 1995/02/13 20:35:09 john * Lintized * * Revision 1.69 1995/02/07 17:12:03 rob * Added ifdef's for Editor. * * Revision 1.68 1995/02/07 16:51:48 mike * fix gray rock josh problem. * * Revision 1.67 1995/02/01 15:46:26 yuan * Fixed matcen_nums. * * Revision 1.66 1995/01/19 15:19:28 mike * new super-compressed registered file format. * * Revision 1.65 1994/12/10 16:44:59 matt * Added debugging code to track down door that turns into rock * * Revision 1.64 1994/12/10 14:58:24 yuan * *** empty log message *** * * Revision 1.63 1994/12/08 17:19:10 yuan * Cfiling stuff. * * Revision 1.62 1994/12/07 14:05:33 yuan * Fixed wall assert problem... Bashed highest_segment * _index before WALL_IS_DOORWAY check. * * Revision 1.61 1994/11/27 23:14:52 matt * Made changes for new mprintf calling convention * * Revision 1.60 1994/11/27 18:05:20 matt * Compile out LVL reader when editor compiled out * * Revision 1.59 1994/11/26 22:51:45 matt * Removed editor-only fields from segment structure when editor is compiled * out, and padded segment structure to even multiple of 4 bytes. * * Revision 1.58 1994/11/26 21:48:02 matt * Fixed saturation in short light value * * Revision 1.57 1994/11/20 22:11:49 mike * comment out an apparently unnecessary call to fuelcen_reset(). * * Revision 1.56 1994/11/18 21:56:42 john * Added a better, leaner pig format. * * Revision 1.55 1994/11/17 20:09:18 john * Added new compiled level format. * * Revision 1.54 1994/11/17 15:40:17 mike * Comment out mprintf which was causing important information to scroll away. * * Revision 1.53 1994/11/17 14:56:37 mike * moved segment validation functions from editor to main. * * Revision 1.52 1994/11/17 11:39:35 matt * Ripped out code to load old mines * * Revision 1.51 1994/11/14 20:47:53 john * Attempted to strip out all the code in the game * directory that uses any ui code. * * Revision 1.50 1994/11/14 16:05:38 matt * Fixed, maybe, again, errors when can't find texture during remap * * Revision 1.49 1994/11/14 14:34:03 matt * Fixed up handling when textures can't be found during remap * * Revision 1.48 1994/11/14 13:01:55 matt * Added Int3() when can't find texture * * Revision 1.47 1994/10/30 14:12:21 mike * rip out local segments stuff. * * Revision 1.46 1994/10/27 19:43:07 john * Disable the piglet option. * * Revision 1.45 1994/10/27 18:51:42 john * Added -piglet option that only loads needed textures for a * mine. Only saved ~1MB, and code still doesn't free textures * before you load a new mine. * * Revision 1.44 1994/10/20 12:47:22 matt * Replace old save files (MIN/SAV/HOT) with new LVL files * * Revision 1.43 1994/10/19 16:46:40 matt * Made tmap overrides for robots remap texture numbers * * Revision 1.42 1994/10/03 23:37:01 mike * Adapt to changed fuelcen_activate parameters. * * Revision 1.41 1994/09/23 22:14:49 matt * Took out obsolete structure fields * * Revision 1.40 1994/08/01 11:04:11 yuan * New materialization centers. * * Revision 1.39 1994/07/21 19:01:47 mike * Call Lsegment stuff. * * */ #ifdef HAVE_CONFIG_H #include #endif #ifdef RCS static char rcsid[] = "$Id: gamemine.c,v 1.23 2003/04/12 02:52:38 btb Exp $"; #endif #include #include #include #include #include "pstypes.h" #include "mono.h" #include "inferno.h" #include "segment.h" #include "textures.h" #include "wall.h" #include "object.h" #include "gamemine.h" #include "error.h" #include "gameseg.h" #include "switch.h" #include "game.h" #include "newmenu.h" #ifdef EDITOR #include "editor/editor.h" #endif #include "cfile.h" #include "fuelcen.h" #include "hash.h" #include "key.h" #include "piggy.h" #include "byteswap.h" #include "gamesave.h" #define REMOVE_EXT(s) (*(strchr( (s), '.' ))='\0') fix Level_shake_frequency = 0, Level_shake_duration = 0; int Secret_return_segment = 0; vms_matrix Secret_return_orient; struct mtfi mine_top_fileinfo; // Should be same as first two fields below... struct mfi mine_fileinfo; struct mh mine_header; struct me mine_editor; typedef struct v16_segment { #ifdef EDITOR short segnum; // segment number, not sure what it means #endif side sides[MAX_SIDES_PER_SEGMENT]; // 6 sides short children[MAX_SIDES_PER_SEGMENT]; // indices of 6 children segments, front, left, top, right, bottom, back short verts[MAX_VERTICES_PER_SEGMENT]; // vertex ids of 4 front and 4 back vertices #ifdef EDITOR short group; // group number to which the segment belongs. #endif short objects; // pointer to objects in this segment ubyte special; // what type of center this is byte matcen_num; // which center segment is associated with. short value; fix static_light; // average static light in segment #ifndef EDITOR short pad; // make structure longword aligned #endif } v16_segment; struct mfi_v19 { ushort fileinfo_signature; ushort fileinfo_version; int fileinfo_sizeof; int header_offset; // Stuff common to game & editor int header_size; int editor_offset; // Editor specific stuff int editor_size; int segment_offset; int segment_howmany; int segment_sizeof; int newseg_verts_offset; int newseg_verts_howmany; int newseg_verts_sizeof; int group_offset; int group_howmany; int group_sizeof; int vertex_offset; int vertex_howmany; int vertex_sizeof; int texture_offset; int texture_howmany; int texture_sizeof; int walls_offset; int walls_howmany; int walls_sizeof; int triggers_offset; int triggers_howmany; int triggers_sizeof; int links_offset; int links_howmany; int links_sizeof; int object_offset; // Object info int object_howmany; int object_sizeof; int unused_offset; // was: doors_offset int unused_howmamy; // was: doors_howmany int unused_sizeof; // was: doors_sizeof short level_shake_frequency; // Shakes every level_shake_frequency seconds short level_shake_duration; // for level_shake_duration seconds (on average, random). In 16ths second. int secret_return_segment; vms_matrix secret_return_orient; int dl_indices_offset; int dl_indices_howmany; int dl_indices_sizeof; int delta_light_offset; int delta_light_howmany; int delta_light_sizeof; }; 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 * textures whose names don't match between versions have extra spaces around "return" * 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; case 2: return 43; // grey case 3: return 1; case 4: return 43; // grey case 5: return 43; // grey case 6: return 270; // blue case 7: return 271; // yellow case 8: return 2; case 9: return 62; // purple (devil:179) case 10: return 272; // red case 11: return 117; case 12: return 12; //devil:43 case 13: return 3; case 14: return 4; case 15: return 5; case 16: return 6; case 17: return 52; case 18: return 129; case 19: return 7; case 20: return 22; case 21: return 9; case 22: return 8; case 23: return 9; case 24: return 10; case 25: return 12; //devil:35 case 26: return 11; case 27: return 12; case 28: return 11; //devil:43 case 29: return 13; case 30: return 14; case 31: return 15; case 32: return 16; case 33: return 17; case 34: return 18; case 35: return 19; case 36: return 20; case 37: return 21; case 38: return 163; //devil:27 case 39: return 31; //devil:147 case 40: return 22; case 41: return 266; case 42: return 23; case 43: return 24; case 44: return 136; //devil:135 case 45: return 25; case 46: return 26; case 47: return 27; case 48: return 28; case 49: return 43; //devil:60 case 50: return 131; //devil:138 case 51: return 29; case 52: return 30; case 53: return 31; case 54: return 32; case 55: return 165; //devil:193 case 56: return 33; case 57: return 132; //devil:119 // range handled by default case case 88: return 197; //devil:15 // range handled by default case case 132: return 167; case 133: return 107; case 134: return 108; case 135: return 109; case 136: return 110; case 137: return 111; case 138: return 112; case 139: return 113; case 140: return 114; case 141: return 110; //devil:106 case 142: return 115; case 143: return 116; case 144: return 117; case 145: return 118; case 146: return 119; case 147: return 93; case 148: return 120; case 149: return 121; case 150: return 122; case 151: return 123; case 152: return 124; case 153: return 125; case 154: return 27; case 155: return 126; //was: 66 case 156: return 200; case 157: return 201; case 158: return 186; //devil:227 case 159: return 190; //devil:246 case 160: return 206; case 161: return 114; //devil:206 case 162: return 202; case 163: return 203; case 164: return 204; case 165: return 205; case 166: return 206; case 167: return 206; case 168: return 206; case 169: return 206; case 170: return 227;//206; case 171: return 206;//227; case 172: return 207; case 173: return 208; case 174: return 202; case 175: return 206; case 176: return 209; case 177: return 210; case 178: return 211; case 179: return 212; case 180: return 213; case 181: return 214; case 182: return 215; case 183: return 216; case 184: return 217; case 185: return 217; case 186: return 218; case 187: return 219; case 188: return 220; case 189: return 221; case 190: return 222; case 191: return 223; case 192: return 224; case 193: return 206; case 194: return 203;//206; case 195: return 234; case 196: return 225; case 197: return 226; case 198: return 225; case 199: return 206; //devil:204 case 200: return 206; //devil:204 case 201: return 227; case 202: return 206; //devil:227 case 203: return 228; case 204: return 229; case 205: return 230; case 206: return 231; case 207: return 232; case 208: return 233; case 209: return 234; case 210: return 234; //devil:242 case 211: return 206; //devil:240 case 212: return 235; case 213: return 236; case 214: return 237; case 215: return 238; case 216: return 239; case 217: return 240; case 218: return 241; case 219: return 242; case 220: return 242; //devil:240 case 221: return 243; case 222: return 244; case 223: return 313; case 224: return 245; case 225: return 246; case 226: return 164;//247; matching names but not matching textures case 227: return 179; //devil:181 case 228: return 196;//248; matching names but not matching textures case 229: return 15; //devil:66 case 230: return 15; //devil:66 case 231: return 249; case 232: return 250; case 233: return 251; case 234: return 252; case 235: return 253; case 236: return 254; case 237: return 255; case 238: return 256; case 239: return 257; case 240: return 6; //devil:132 case 241: return 130; //devil:131 case 242: return 78; //devil:15 case 243: return 33; //devil:38 case 244: return 258; case 245: return 259; case 246: return 321; case 247: return 260; case 248: return 261; case 249: return 262; case 250: return 340; // white entrance case 251: return 412; // red entrance case 252: return 410; // blue entrance case 253: return 411; // yellow entrance case 254: return 263; case 255: return 264; case 256: return 265; case 257: return 249;//246; case 258: return 251;//246; case 259: return 252;//246; case 260: return 256;//246; case 261: return 273; case 262: return 274; case 263: return 281; case 264: return 275; case 265: return 276; case 266: return 279; //devil:291 // range handled by default case case 282: return 293; case 283: return 295; case 284: return 295; case 285: return 296; case 286: return 298; // range handled by default case case 298: return 364; //devil:374 // range handled by default case case 315: return 361; // broken producer // range handled by default case case 327: return 352; case 328: return 353; case 329: return 354; case 330: return 380; case 331: return 379;//373; matching names but not matching textures; case 332: return 355;//344; matching names but not matching textures case 333: return 409; // lava //devil:404 case 334: return 356; case 335: return 357; case 336: return 358; case 337: return 359; case 338: return 360; case 339: return 361; case 340: return 362; case 341: return 364; case 342: return 363; case 343: return 366; case 344: return 365; case 345: return 368; case 346: return 376; case 347: return 370; case 348: return 367; case 349: return 372; case 350: return 369; case 351: return 374;//429; matching names but not matching textures case 352: return 375;//387; matching names but not matching textures case 353: return 371; case 354: return 377;//425; matching names but not matching textures case 355: return 408; case 356: return 378; // lava02 case 357: return 383;//384; matching names but not matching textures case 358: return 384;//385; matching names but not matching textures case 359: return 385;//386; matching names but not matching textures case 360: return 386; case 361: return 387; case 362: return 388; // mntr04a (devil: -1) case 363: return 388; case 364: return 391; case 365: return 392; case 366: return 393; case 367: return 394; case 368: return 395; case 369: return 396; case 370: return 392; // mntr04b (devil: -1) // range 371 - 584 handled by default default: // ranges: if (d1_tmap_num >= 58 && d1_tmap_num <= 87) return d1_tmap_num - 24; if (d1_tmap_num >= 89 && d1_tmap_num <= 131) return d1_tmap_num - 25; if (d1_tmap_num >= 267 && d1_tmap_num <= 281) return d1_tmap_num + 10; if (d1_tmap_num >= 287 && d1_tmap_num <= 297) return d1_tmap_num + 13; if (d1_tmap_num >= 299 && d1_tmap_num <= 314) return d1_tmap_num + 12; if (d1_tmap_num >= 316 && d1_tmap_num <= 326) return d1_tmap_num + 11; // wall01 and door frames: if (d1_tmap_num > 370 && d1_tmap_num < 584) { if (New_file_format_load) return d1_tmap_num + 64; // d1 shareware needs special treatment: if (d1_tmap_num < 410) return d1_tmap_num + 68; if (d1_tmap_num < 417) return d1_tmap_num + 73; if (d1_tmap_num < 446) return d1_tmap_num + 91; if (d1_tmap_num < 453) return d1_tmap_num + 104; if (d1_tmap_num < 462) return d1_tmap_num + 111; if (d1_tmap_num < 486) return d1_tmap_num + 117; if (d1_tmap_num < 494) return d1_tmap_num + 141; if (d1_tmap_num < 584) return d1_tmap_num + 147; } { // handle rare case where orientation != 0 short tmap_num = d1_tmap_num & TMAP_NUM_MASK; short orient = d1_tmap_num & ~TMAP_NUM_MASK; if (orient != 0) { return orient | convert_d1_tmap_num(tmap_num); } else { Warning("can't convert unknown descent 1 texture #%d.\n", tmap_num); return d1_tmap_num; } } } } #ifdef EDITOR static char old_tmap_list[MAX_TEXTURES][FILENAME_LEN]; short tmap_xlate_table[MAX_TEXTURES]; static short tmap_times_used[MAX_TEXTURES]; // ----------------------------------------------------------------------------- //loads from an already-open file // returns 0=everything ok, 1=old version, -1=error int load_mine_data(CFILE *LoadFile) { int i, j,oldsizeadjust; short tmap_xlate; int translate; char *temptr; int mine_start = cftell(LoadFile); oldsizeadjust=(sizeof(int)*2)+sizeof (vms_matrix); fuelcen_reset(); for (i=0; i= 19) { mine_fileinfo.dl_indices_offset = -1; mine_fileinfo.dl_indices_howmany = 0; mine_fileinfo.dl_indices_sizeof = sizeof(dl_index); mine_fileinfo.delta_light_offset = -1; mine_fileinfo.delta_light_howmany = 0; mine_fileinfo.delta_light_sizeof = sizeof(delta_light); // } mine_fileinfo.segment2_offset = -1; mine_fileinfo.segment2_howmany = 0; mine_fileinfo.segment2_sizeof = sizeof(segment2); // Read in mine_top_fileinfo to get size of saved fileinfo. memset( &mine_top_fileinfo, 0, sizeof(mine_top_fileinfo) ); if (cfseek( LoadFile, mine_start, SEEK_SET )) Error( "Error moving to top of file in gamemine.c" ); if (cfread( &mine_top_fileinfo, sizeof(mine_top_fileinfo), 1, LoadFile )!=1) Error( "Error reading mine_top_fileinfo in gamemine.c" ); if (mine_top_fileinfo.fileinfo_signature != 0x2884) return -1; // Check version number if (mine_top_fileinfo.fileinfo_version < COMPATIBLE_VERSION ) return -1; // Now, Read in the fileinfo if (cfseek( LoadFile, mine_start, SEEK_SET )) Error( "Error seeking to top of file in gamemine.c" ); if (cfread( &mine_fileinfo, mine_top_fileinfo.fileinfo_sizeof, 1, LoadFile )!=1) Error( "Error reading mine_fileinfo in gamemine.c" ); if (mine_top_fileinfo.fileinfo_version < 18) { mprintf((1, "Old version, setting shake intensity to 0.\n")); Level_shake_frequency = 0; Level_shake_duration = 0; Secret_return_segment = 0; Secret_return_orient = vmd_identity_matrix; } else { Level_shake_frequency = mine_fileinfo.level_shake_frequency << 12; Level_shake_duration = mine_fileinfo.level_shake_duration << 12; Secret_return_segment = mine_fileinfo.secret_return_segment; Secret_return_orient = mine_fileinfo.secret_return_orient; } //===================== READ HEADER INFO ======================== // Set default values. mine_header.num_vertices = 0; mine_header.num_segments = 0; if (mine_fileinfo.header_offset > -1 ) { if (cfseek( LoadFile, mine_fileinfo.header_offset, SEEK_SET )) Error( "Error seeking to header_offset in gamemine.c" ); if (cfread( &mine_header, mine_fileinfo.header_size, 1, LoadFile )!=1) Error( "Error reading mine_header in gamemine.c" ); } //===================== READ EDITOR INFO ========================== // Set default values mine_editor.current_seg = 0; mine_editor.newsegment_offset = -1; // To be written mine_editor.newsegment_size = sizeof(segment); mine_editor.Curside = 0; mine_editor.Markedsegp = -1; mine_editor.Markedside = 0; if (mine_fileinfo.editor_offset > -1 ) { if (cfseek( LoadFile, mine_fileinfo.editor_offset, SEEK_SET )) Error( "Error seeking to editor_offset in gamemine.c" ); if (cfread( &mine_editor, mine_fileinfo.editor_size, 1, LoadFile )!=1) Error( "Error reading mine_editor in gamemine.c" ); } //===================== READ TEXTURE INFO ========================== if ( (mine_fileinfo.texture_offset > -1) && (mine_fileinfo.texture_howmany > 0)) { if (cfseek( LoadFile, mine_fileinfo.texture_offset, SEEK_SET )) Error( "Error seeking to texture_offset in gamemine.c" ); for (i=0; i< mine_fileinfo.texture_howmany; i++ ) { if (cfread( &old_tmap_list[i], mine_fileinfo.texture_sizeof, 1, LoadFile )!=1) Error( "Error reading old_tmap_list[i] in gamemine.c" ); } } //=============== GENERATE TEXTURE TRANSLATION TABLE =============== translate = 0; Assert (NumTextures < MAX_TEXTURES); { hashtable ht; hashtable_init( &ht, NumTextures ); // Remove all the file extensions in the textures list for (i=0;i= 0) tmap_times_used[tmap_xlate_table[j]]++; } { int count = 0; for (i=0; i MAX_VERTICES ) { mprintf((0, "Num vertices exceeds maximum. Loading MAX %d vertices\n", MAX_VERTICES)); mine_fileinfo.vertex_howmany = MAX_VERTICES; } if ( (mine_fileinfo.vertex_offset > -1) && (mine_fileinfo.vertex_howmany > 0)) { if (cfseek( LoadFile, mine_fileinfo.vertex_offset, SEEK_SET )) Error( "Error seeking to vertex_offset in gamemine.c" ); for (i=0; i< mine_fileinfo.vertex_howmany; i++ ) { // Set the default values for this vertex Vertices[i].x = 1; Vertices[i].y = 1; Vertices[i].z = 1; if (cfread( &Vertices[i], mine_fileinfo.vertex_sizeof, 1, LoadFile )!=1) Error( "Error reading Vertices[i] in gamemine.c" ); } } //==================== READ SEGMENT INFO =========================== // New check added to make sure we don't read in too many segments. if ( mine_fileinfo.segment_howmany > MAX_SEGMENTS ) { mprintf((0, "Num segments exceeds maximum. Loading MAX %d segments\n", MAX_SEGMENTS)); mine_fileinfo.segment_howmany = MAX_SEGMENTS; mine_fileinfo.segment2_howmany = MAX_SEGMENTS; } // [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(); if ( (mine_fileinfo.segment_offset > -1) && (mine_fileinfo.segment_howmany > 0)) { if (cfseek( LoadFile, mine_fileinfo.segment_offset,SEEK_SET )) Error( "Error seeking to segment_offset in gamemine.c" ); Highest_segment_index = mine_fileinfo.segment_howmany-1; for (i=0; i< mine_fileinfo.segment_howmany; i++ ) { // Set the default values for this segment (clear to zero ) //memset( &Segments[i], 0, sizeof(segment) ); if (mine_top_fileinfo.fileinfo_version < 20) { v16_segment v16_seg; Assert(mine_fileinfo.segment_sizeof == sizeof(v16_seg)); if (cfread( &v16_seg, mine_fileinfo.segment_sizeof, 1, LoadFile )!=1) Error( "Error reading segments in gamemine.c" ); #ifdef EDITOR Segments[i].segnum = v16_seg.segnum; // -- Segments[i].pad = v16_seg.pad; #endif for (j=0; j= 20) for (i=0; i<=Highest_segment_index; i++) { cfread(&Segment2s[i], sizeof(segment2), 1, LoadFile); fuelcen_activate( &Segments[i], Segment2s[i].special ); } } //===================== READ NEWSEGMENT INFO ===================== #ifdef EDITOR { // Default segment created. vms_vector sizevec; med_create_new_segment(vm_vec_make(&sizevec,DEFAULT_X_SIZE,DEFAULT_Y_SIZE,DEFAULT_Z_SIZE)); // New_segment = Segments[0]; //memset( &New_segment, 0, sizeof(segment) ); } if (mine_editor.newsegment_offset > -1) { if (cfseek( LoadFile, mine_editor.newsegment_offset,SEEK_SET )) Error( "Error seeking to newsegment_offset in gamemine.c" ); if (cfread( &New_segment, mine_editor.newsegment_size,1,LoadFile )!=1) Error( "Error reading new_segment in gamemine.c" ); } if ( (mine_fileinfo.newseg_verts_offset > -1) && (mine_fileinfo.newseg_verts_howmany > 0)) { if (cfseek( LoadFile, mine_fileinfo.newseg_verts_offset, SEEK_SET )) Error( "Error seeking to newseg_verts_offset in gamemine.c" ); for (i=0; i< mine_fileinfo.newseg_verts_howmany; i++ ) { // Set the default values for this vertex Vertices[NEW_SEGMENT_VERTICES+i].x = 1; Vertices[NEW_SEGMENT_VERTICES+i].y = 1; Vertices[NEW_SEGMENT_VERTICES+i].z = 1; if (cfread( &Vertices[NEW_SEGMENT_VERTICES+i], mine_fileinfo.newseg_verts_sizeof,1,LoadFile )!=1) Error( "Error reading Vertices[NEW_SEGMENT_VERTICES+i] in gamemine.c" ); New_segment.verts[i] = NEW_SEGMENT_VERTICES+i; } } #endif //========================= UPDATE VARIABLES ====================== #ifdef EDITOR // Setting to Markedsegp to NULL ignores Curside and Markedside, which // we want to do when reading in an old file. Markedside = mine_editor.Markedside; Curside = mine_editor.Curside; for (i=0;i<10;i++) Groupside[i] = mine_editor.Groupside[i]; if ( mine_editor.current_seg != -1 ) Cursegp = mine_editor.current_seg + Segments; else Cursegp = NULL; if (mine_editor.Markedsegp != -1 ) Markedsegp = mine_editor.Markedsegp + Segments; else Markedsegp = NULL; num_groups = 0; current_group = -1; #endif Num_vertices = mine_fileinfo.vertex_howmany; Num_segments = mine_fileinfo.segment_howmany; Highest_vertex_index = Num_vertices-1; Highest_segment_index = Num_segments-1; reset_objects(1); //one object, the player #ifdef EDITOR Highest_vertex_index = MAX_SEGMENT_VERTICES-1; Highest_segment_index = MAX_SEGMENTS-1; set_vertex_counts(); Highest_vertex_index = Num_vertices-1; Highest_segment_index = Num_segments-1; warn_if_concave_segments(); #endif #ifdef EDITOR validate_segment_all(); #endif //create_local_segment_data(); //gamemine_find_textures(); if (mine_top_fileinfo.fileinfo_version < MINE_VERSION ) return 1; //old version else return 0; } #endif #define COMPILED_MINE_VERSION 0 void read_children(int segnum,ubyte bit_mask,CFILE *LoadFile) { int bit; for (bit=0; bit>5, write as short, l>>1 write as short) for (i=0; i<4; i++ ) { temp_short = cfile_read_short(LoadFile); Segments[segnum].sides[sidenum].uvls[i].u = ((fix)temp_short) << 5; temp_short = cfile_read_short(LoadFile); Segments[segnum].sides[sidenum].uvls[i].v = ((fix)temp_short) << 5; temp_ushort = cfile_read_short(LoadFile); Segments[segnum].sides[sidenum].uvls[i].l = ((fix)temp_ushort) << 1; //cfread( &Segments[segnum].sides[sidenum].uvls[i].l, sizeof(fix), 1, LoadFile ); } } else { Segments[segnum].sides[sidenum].tmap_num = 0; Segments[segnum].sides[sidenum].tmap_num2 = 0; for (i=0; i<4; i++ ) { Segments[segnum].sides[sidenum].uvls[i].u = 0; Segments[segnum].sides[sidenum].uvls[i].v = 0; Segments[segnum].sides[sidenum].uvls[i].l = 0; } } } } #if 0 { FILE *fp; fp = fopen("segments.out", "wt"); for (i = 0; i <= Highest_segment_index; i++) { side sides[MAX_SIDES_PER_SEGMENT]; // 6 sides short children[MAX_SIDES_PER_SEGMENT]; // indices of 6 children segments, front, left, top, right, bottom, back short verts[MAX_VERTICES_PER_SEGMENT]; // vertex ids of 4 front and 4 back vertices int objects; // pointer to objects in this segment for (j = 0; j < MAX_SIDES_PER_SEGMENT; j++) { byte type; // replaces num_faces and tri_edge, 1 = quad, 2 = 0:2 triangulation, 3 = 1:3 triangulation ubyte pad; //keep us longword alligned short wall_num; short tmap_num; short tmap_num2; uvl uvls[4]; vms_vector normals[2]; // 2 normals, if quadrilateral, both the same. fprintf(fp, "%d\n", Segments[i].sides[j].type); fprintf(fp, "%d\n", Segments[i].sides[j].pad); fprintf(fp, "%d\n", Segments[i].sides[j].wall_num); fprintf(fp, "%d\n", Segments[i].tmap_num); } fclose(fp); } } #endif Highest_vertex_index = Num_vertices-1; Highest_segment_index = Num_segments-1; validate_segment_all(); // Fill in side type and normals. for (i=0; i 5) segment2_read(&Segment2s[i], LoadFile); fuelcen_activate( &Segments[i], Segment2s[i].special ); } reset_objects(1); //one object, the player return 0; }