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