Author: rambetter
[divverent/netradiant.git] / tools / quake3 / q3map2 / bspfile_abstract.c
1 /* -------------------------------------------------------------------------------
2
3 Copyright (C) 1999-2007 id Software, Inc. and contributors.
4 For a list of contributors, see the accompanying CONTRIBUTORS file.
5
6 This file is part of GtkRadiant.
7
8 GtkRadiant is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 GtkRadiant is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GtkRadiant; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21
22 ----------------------------------------------------------------------------------
23
24 This code has been altered significantly from its original form, to support
25 several games based on the Quake III Arena engine, in the form of "Q3Map2."
26
27 ------------------------------------------------------------------------------- */
28
29
30
31 /* marker */
32 #define BSPFILE_ABSTRACT_C
33
34
35
36 /* dependencies */
37 #include "q3map2.h"
38
39
40
41
42 /* -------------------------------------------------------------------------------
43
44 this file was copied out of the common directory in order to not break
45 compatibility with the q3map 1.x tree. it was moved out in order to support
46 the raven bsp format (RBSP) used in soldier of fortune 2 and jedi knight 2.
47
48 since each game has its own set of particular features, the data structures
49 below no longer directly correspond to the binary format of a particular game.
50
51 the translation will be done at bsp load/save time to keep any sort of
52 special-case code messiness out of the rest of the program.
53
54 ------------------------------------------------------------------------------- */
55
56
57
58 /* FIXME: remove the functions below that handle memory management of bsp file chunks */
59
60 int numBSPDrawVertsBuffer = 0;
61 void IncDrawVerts()
62 {
63         numBSPDrawVerts++;
64
65         if(bspDrawVerts == 0)
66         {
67                 numBSPDrawVertsBuffer = 1024;
68                 
69                 bspDrawVerts = safe_malloc_info(sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer, "IncDrawVerts");
70
71         }
72         else if(numBSPDrawVerts > numBSPDrawVertsBuffer)
73         {
74                 numBSPDrawVertsBuffer *= 3; // multiply by 1.5
75                 numBSPDrawVertsBuffer /= 2;
76
77                 bspDrawVerts = realloc(bspDrawVerts, sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer);
78
79                 if(!bspDrawVerts)
80                         Error( "realloc() failed (IncDrawVerts)");
81         }
82
83         memset(bspDrawVerts + (numBSPDrawVerts - 1), 0, sizeof(bspDrawVert_t));
84 }
85
86 void SetDrawVerts(int n)
87 {
88         if(bspDrawVerts != 0)
89                 free(bspDrawVerts);
90
91         numBSPDrawVerts = n;
92         numBSPDrawVertsBuffer = numBSPDrawVerts;
93
94         bspDrawVerts = safe_malloc_info(sizeof(bspDrawVert_t) * numBSPDrawVertsBuffer, "IncDrawVerts");
95
96         memset(bspDrawVerts, 0, n * sizeof(bspDrawVert_t));
97 }
98
99 int numBSPDrawSurfacesBuffer = 0;
100 void SetDrawSurfacesBuffer()
101 {
102         if(bspDrawSurfaces != 0)
103                 free(bspDrawSurfaces);
104
105         numBSPDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
106
107         bspDrawSurfaces = safe_malloc_info(sizeof(bspDrawSurface_t) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces");
108
109         memset(bspDrawSurfaces, 0, MAX_MAP_DRAW_SURFS * sizeof(bspDrawVert_t));
110 }
111
112 void SetDrawSurfaces(int n)
113 {
114         if(bspDrawSurfaces != 0)
115                 free(bspDrawSurfaces);
116
117         numBSPDrawSurfaces = n;
118         numBSPDrawSurfacesBuffer = numBSPDrawSurfaces;
119
120         bspDrawSurfaces = safe_malloc_info(sizeof(bspDrawSurface_t) * numBSPDrawSurfacesBuffer, "IncDrawSurfaces");
121
122         memset(bspDrawSurfaces, 0, n * sizeof(bspDrawVert_t));
123 }
124
125 void BSPFilesCleanup()
126 {
127         if(bspDrawVerts != 0)
128                 free(bspDrawVerts);
129         if(bspDrawSurfaces != 0)
130                 free(bspDrawSurfaces);
131         if(bspLightBytes != 0)
132                 free(bspLightBytes);
133         if(bspGridPoints != 0)
134                 free(bspGridPoints);
135 }
136
137
138
139
140
141
142 /*
143 SwapBlock()
144 if all values are 32 bits, this can be used to swap everything
145 */
146
147 void SwapBlock( int *block, int size )
148 {
149         int             i;
150         
151         
152         /* dummy check */
153         if( block == NULL )
154                 return;
155         
156         /* swap */
157         size >>= 2;
158         for( i = 0; i < size; i++ )
159                 block[ i ] = LittleLong( block[ i ] );
160 }
161
162
163
164 /*
165 SwapBSPFile()
166 byte swaps all data in the abstract bsp
167 */
168
169 void SwapBSPFile( void )
170 {
171         int             i, j;
172         
173         
174         /* models */
175         SwapBlock( (int*) bspModels, numBSPModels * sizeof( bspModels[ 0 ] ) );
176
177         /* shaders (don't swap the name) */
178         for( i = 0; i < numBSPShaders ; i++ )
179         {
180                 bspShaders[ i ].contentFlags = LittleLong( bspShaders[ i ].contentFlags );
181                 bspShaders[ i ].surfaceFlags = LittleLong( bspShaders[ i ].surfaceFlags );
182         }
183
184         /* planes */
185         SwapBlock( (int*) bspPlanes, numBSPPlanes * sizeof( bspPlanes[ 0 ] ) );
186         
187         /* nodes */
188         SwapBlock( (int*) bspNodes, numBSPNodes * sizeof( bspNodes[ 0 ] ) );
189
190         /* leafs */
191         SwapBlock( (int*) bspLeafs, numBSPLeafs * sizeof( bspLeafs[ 0 ] ) );
192
193         /* leaffaces */
194         SwapBlock( (int*) bspLeafSurfaces, numBSPLeafSurfaces * sizeof( bspLeafSurfaces[ 0 ] ) );
195
196         /* leafbrushes */
197         SwapBlock( (int*) bspLeafBrushes, numBSPLeafBrushes * sizeof( bspLeafBrushes[ 0 ] ) );
198
199         // brushes
200         SwapBlock( (int*) bspBrushes, numBSPBrushes * sizeof( bspBrushes[ 0 ] ) );
201
202         // brushsides
203         SwapBlock( (int*) bspBrushSides, numBSPBrushSides * sizeof( bspBrushSides[ 0 ] ) );
204
205         // vis
206         ((int*) &bspVisBytes)[ 0 ] = LittleLong( ((int*) &bspVisBytes)[ 0 ] );
207         ((int*) &bspVisBytes)[ 1 ] = LittleLong( ((int*) &bspVisBytes)[ 1 ] );
208
209         /* drawverts (don't swap colors) */
210         for( i = 0; i < numBSPDrawVerts; i++ )
211         {
212                 bspDrawVerts[ i ].xyz[ 0 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 0 ] );
213                 bspDrawVerts[ i ].xyz[ 1 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 1 ] );
214                 bspDrawVerts[ i ].xyz[ 2 ] = LittleFloat( bspDrawVerts[ i ].xyz[ 2 ] );
215                 bspDrawVerts[ i ].normal[ 0 ] = LittleFloat( bspDrawVerts[ i ].normal[ 0 ] );
216                 bspDrawVerts[ i ].normal[ 1 ] = LittleFloat( bspDrawVerts[ i ].normal[ 1 ] );
217                 bspDrawVerts[ i ].normal[ 2 ] = LittleFloat( bspDrawVerts[ i ].normal[ 2 ] );
218                 bspDrawVerts[ i ].st[ 0 ] = LittleFloat( bspDrawVerts[ i ].st[ 0 ] );
219                 bspDrawVerts[ i ].st[ 1 ] = LittleFloat( bspDrawVerts[ i ].st[ 1 ] );
220                 for( j = 0; j < MAX_LIGHTMAPS; j++ )
221                 {
222                         bspDrawVerts[ i ].lightmap[ j ][ 0 ] = LittleFloat( bspDrawVerts[ i ].lightmap[ j ][ 0 ] );
223                         bspDrawVerts[ i ].lightmap[ j ][ 1 ] = LittleFloat( bspDrawVerts[ i ].lightmap[ j ][ 1 ] );
224                 }
225         }
226         
227         /* drawindexes */
228         SwapBlock( (int*) bspDrawIndexes, numBSPDrawIndexes * sizeof( bspDrawIndexes[0] ) );
229
230         /* drawsurfs */
231         /* note: rbsp files (and hence q3map2 abstract bsp) have byte lightstyles index arrays, this follows sof2map convention */
232         SwapBlock( (int*) bspDrawSurfaces, numBSPDrawSurfaces * sizeof( bspDrawSurfaces[ 0 ] ) );
233
234         /* fogs */
235         for( i = 0; i < numBSPFogs; i++ )
236         {
237                 bspFogs[ i ].brushNum = LittleLong( bspFogs[ i ].brushNum );
238                 bspFogs[ i ].visibleSide = LittleLong( bspFogs[ i ].visibleSide );
239         }
240
241         /* advertisements */
242         for( i = 0; i < numBSPAds; i++ )
243         {
244                 bspAds[ i ].cellId = LittleLong( bspAds[ i ].cellId );
245                 bspAds[ i ].normal[ 0 ] = LittleFloat( bspAds[ i ].normal[ 0 ] );
246                 bspAds[ i ].normal[ 1 ] = LittleFloat( bspAds[ i ].normal[ 1 ] );
247                 bspAds[ i ].normal[ 2 ] = LittleFloat( bspAds[ i ].normal[ 2 ] );
248
249                 for( j = 0; j < 4; j++ ) 
250                 {
251                         bspAds[ i ].rect[j][ 0 ] = LittleFloat( bspAds[ i ].rect[j][ 0 ] );
252                         bspAds[ i ].rect[j][ 1 ] = LittleFloat( bspAds[ i ].rect[j][ 1 ] );
253                         bspAds[ i ].rect[j][ 2 ] = LittleFloat( bspAds[ i ].rect[j][ 2 ] );
254                 }
255
256                 //bspAds[ i ].model[ MAX_QPATH ];
257         }
258 }
259
260
261
262 /*
263 GetLumpElements()
264 gets the number of elements in a bsp lump
265 */
266
267 int GetLumpElements( bspHeader_t *header, int lump, int size )
268 {
269         /* check for odd size */
270         if( header->lumps[ lump ].length % size )
271         {
272                 if( force )
273                 {
274                         Sys_Printf( "WARNING: GetLumpElements: odd lump size (%d) in lump %d\n", header->lumps[ lump ].length, lump );
275                         return 0;
276                 }
277                 else
278                         Error( "GetLumpElements: odd lump size (%d) in lump %d", header->lumps[ lump ].length, lump );
279         }
280         
281         /* return element count */
282         return header->lumps[ lump ].length / size;
283 }
284
285
286
287 /*
288 GetLump()
289 returns a pointer to the specified lump
290 */
291
292 void *GetLump( bspHeader_t *header, int lump )
293 {
294         return (void*)( (byte*) header + header->lumps[ lump ].offset);
295 }
296
297
298
299 /*
300 CopyLump()
301 copies a bsp file lump into a destination buffer
302 */
303
304 int CopyLump( bspHeader_t *header, int lump, void *dest, int size )
305 {
306         int             length, offset;
307         
308         
309         /* get lump length and offset */
310         length = header->lumps[ lump ].length;
311         offset = header->lumps[ lump ].offset;
312         
313         /* handle erroneous cases */
314         if( length == 0 )
315                 return 0;
316         if( length % size )
317         {
318                 if( force )
319                 {
320                         Sys_Printf( "WARNING: CopyLump: odd lump size (%d) in lump %d\n", length, lump );
321                         return 0;
322                 }
323                 else
324                         Error( "CopyLump: odd lump size (%d) in lump %d", length, lump );
325         }
326         
327         /* copy block of memory and return */
328         memcpy( dest, (byte*) header + offset, length );
329         return length / size;
330 }
331
332 int CopyLump_Allocate( bspHeader_t *header, int lump, void **dest, int size, int *allocationVariable )
333 {
334         /* get lump length and offset */
335         *allocationVariable = header->lumps[ lump ].length / size;
336         *dest = realloc(*dest, size * *allocationVariable);
337         return CopyLump(header, lump, *dest, size);
338 }
339
340
341 /*
342 AddLump()
343 adds a lump to an outgoing bsp file
344 */
345
346 void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length )
347 {
348         bspLump_t       *lump;
349         
350         
351         /* add lump to bsp file header */
352         lump = &header->lumps[ lumpNum ];
353         lump->offset = LittleLong( ftell( file ) );
354         lump->length = LittleLong( length );
355         
356         /* write lump to file */
357         SafeWrite( file, data, (length + 3) & ~3 );
358 }
359
360
361
362 /*
363 LoadBSPFile()
364 loads a bsp file into memory
365 */
366
367 void LoadBSPFile( const char *filename )
368 {
369         /* dummy check */
370         if( game == NULL || game->load == NULL )
371                 Error( "LoadBSPFile: unsupported BSP file format" );
372         
373         /* load it, then byte swap the in-memory version */
374         game->load( filename );
375         SwapBSPFile();
376 }
377
378
379
380 /*
381 WriteBSPFile()
382 writes a bsp file
383 */
384
385 void WriteBSPFile( const char *filename )
386 {
387         char    tempname[ 1024 ];
388         time_t  tm;
389         
390         
391         /* dummy check */
392         if( game == NULL || game->write == NULL )
393                 Error( "WriteBSPFile: unsupported BSP file format" );
394         
395         /* make fake temp name so existing bsp file isn't damaged in case write process fails */
396         time( &tm );
397         sprintf( tempname, "%s.%08X", filename, (int) tm );
398         
399         /* byteswap, write the bsp, then swap back so it can be manipulated further */
400         SwapBSPFile();
401         game->write( tempname );
402         SwapBSPFile();
403         
404         /* replace existing bsp file */
405         remove( filename );
406         rename( tempname, filename );
407 }
408
409
410
411 /*
412 PrintBSPFileSizes()
413 dumps info about current file
414 */
415
416 void PrintBSPFileSizes( void )
417 {
418         /* parse entities first */
419         if( numEntities <= 0 )
420                 ParseEntities();
421         
422         /* note that this is abstracted */
423         Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" );
424         
425         /* print various and sundry bits */
426         Sys_Printf( "%9d models        %9d\n",
427                 numBSPModels, (int) (numBSPModels * sizeof( bspModel_t )) );
428         Sys_Printf( "%9d shaders       %9d\n",
429                 numBSPShaders, (int) (numBSPShaders * sizeof( bspShader_t )) );
430         Sys_Printf( "%9d brushes       %9d\n",
431                 numBSPBrushes, (int) (numBSPBrushes * sizeof( bspBrush_t )) );
432         Sys_Printf( "%9d brushsides    %9d *\n",
433                 numBSPBrushSides, (int) (numBSPBrushSides * sizeof( bspBrushSide_t )) );
434         Sys_Printf( "%9d fogs          %9d\n",
435                 numBSPFogs, (int) (numBSPFogs * sizeof( bspFog_t ) ) );
436         Sys_Printf( "%9d planes        %9d\n",
437                 numBSPPlanes, (int) (numBSPPlanes * sizeof( bspPlane_t )) );
438         Sys_Printf( "%9d entdata       %9d\n",
439                 numEntities, bspEntDataSize );
440         Sys_Printf( "\n");
441         
442         Sys_Printf( "%9d nodes         %9d\n",
443                 numBSPNodes, (int) (numBSPNodes * sizeof( bspNode_t)) );
444         Sys_Printf( "%9d leafs         %9d\n",
445                 numBSPLeafs, (int) (numBSPLeafs * sizeof( bspLeaf_t )) );
446         Sys_Printf( "%9d leafsurfaces  %9d\n",
447                 numBSPLeafSurfaces, (int) (numBSPLeafSurfaces * sizeof( *bspLeafSurfaces )) );
448         Sys_Printf( "%9d leafbrushes   %9d\n",
449                 numBSPLeafBrushes, (int) (numBSPLeafBrushes * sizeof( *bspLeafBrushes )) );
450         Sys_Printf( "\n");
451         
452         Sys_Printf( "%9d drawsurfaces  %9d *\n",
453                 numBSPDrawSurfaces, (int) (numBSPDrawSurfaces * sizeof( *bspDrawSurfaces )) );
454         Sys_Printf( "%9d drawverts     %9d *\n",
455                 numBSPDrawVerts, (int) (numBSPDrawVerts * sizeof( *bspDrawVerts )) );
456         Sys_Printf( "%9d drawindexes   %9d\n",
457                 numBSPDrawIndexes, (int) (numBSPDrawIndexes * sizeof( *bspDrawIndexes )) );
458         Sys_Printf( "\n");
459         
460         Sys_Printf( "%9d lightmaps     %9d\n",
461                 numBSPLightBytes / (game->lightmapSize * game->lightmapSize * 3), numBSPLightBytes );
462         Sys_Printf( "%9d lightgrid     %9d *\n",
463                 numBSPGridPoints, (int) (numBSPGridPoints * sizeof( *bspGridPoints )) );
464         Sys_Printf( "          visibility    %9d\n",
465                 numBSPVisBytes );
466 }
467
468
469
470 /* -------------------------------------------------------------------------------
471
472 entity data handling
473
474 ------------------------------------------------------------------------------- */
475
476
477 /*
478 StripTrailing()
479 strips low byte chars off the end of a string
480 */
481
482 void StripTrailing( char *e )
483 {
484         char    *s;
485         
486         
487         s = e + strlen( e ) - 1;
488         while( s >= e && *s <= 32 )
489         {
490                 *s = 0;
491                 s--;
492         }
493 }
494
495
496
497 /*
498 ParseEpair()
499 parses a single quoted "key" "value" pair into an epair struct
500 */
501
502 epair_t *ParseEPair( void )
503 {
504         epair_t         *e;
505         
506         
507         /* allocate and clear new epair */
508         e = safe_malloc( sizeof( epair_t ) );
509         memset( e, 0, sizeof( epair_t ) );
510         
511         /* handle key */
512         if( strlen( token ) >= (MAX_KEY - 1) )
513                 Error( "ParseEPair: token too long" );
514         
515         e->key = copystring( token );
516         GetToken( qfalse );
517         
518         /* handle value */
519         if( strlen( token ) >= MAX_VALUE - 1 )
520                 Error( "ParseEpar: token too long" );
521         e->value = copystring( token );
522         
523         /* strip trailing spaces that sometimes get accidentally added in the editor */
524         StripTrailing( e->key );
525         StripTrailing( e->value );
526         
527         /* return it */
528         return e;
529 }
530
531
532
533 /*
534 ParseEntity()
535 parses an entity's epairs
536 */
537
538 qboolean ParseEntity( void )
539 {
540         epair_t         *e;
541         
542         
543         /* dummy check */
544         if( !GetToken( qtrue ) )
545                 return qfalse;
546         if( strcmp( token, "{" ) )
547                 Error( "ParseEntity: { not found" );
548         if( numEntities == MAX_MAP_ENTITIES )
549                 Error( "numEntities == MAX_MAP_ENTITIES" );
550         
551         /* create new entity */
552         mapEnt = &entities[ numEntities ];
553         numEntities++;
554         
555         /* parse */
556         while( 1 )
557         {
558                 if( !GetToken( qtrue ) )
559                         Error( "ParseEntity: EOF without closing brace" );
560                 if( !EPAIR_STRCMP( token, "}" ) )
561                         break;
562                 e = ParseEPair();
563                 e->next = mapEnt->epairs;
564                 mapEnt->epairs = e;
565         }
566         
567         /* return to sender */
568         return qtrue;
569 }
570
571
572
573 /*
574 ParseEntities()
575 parses the bsp entity data string into entities
576 */
577
578 void ParseEntities( void )
579 {
580         numEntities = 0;
581         ParseFromMemory( bspEntData, bspEntDataSize );
582         while( ParseEntity() );
583         
584         /* ydnar: set number of bsp entities in case a map is loaded on top */
585         numBSPEntities = numEntities;
586 }
587
588 /*
589  * must be called before UnparseEntities
590  */
591 void InjectCommandLine(char **argv, int beginArgs, int endArgs)
592 {
593         const char *previousCommandLine;
594         char newCommandLine[1024];
595         const char *inpos;
596         char *outpos = newCommandLine;
597         char *sentinel = newCommandLine + sizeof(newCommandLine) - 1;
598         int i;
599
600         previousCommandLine = ValueForKey(&entities[0], "_q3map2_cmdline");
601         if(previousCommandLine && *previousCommandLine)
602         {
603                 inpos = previousCommandLine;
604                 while(outpos != sentinel && *inpos)
605                         *outpos++ = *inpos++;
606                 if(outpos != sentinel)
607                         *outpos++ = ';';
608                 if(outpos != sentinel)
609                         *outpos++ = ' ';
610         }
611
612         for(i = beginArgs; i < endArgs; ++i)
613         {
614                 if(outpos != sentinel && i != beginArgs)
615                         *outpos++ = ' ';
616                 inpos = argv[i];
617                 while(outpos != sentinel && *inpos)
618                         if(*inpos != '\\' && *inpos != '"' && *inpos != ';' && (unsigned char) *inpos >= ' ')
619                                 *outpos++ = *inpos++;
620         }
621
622         *outpos = 0;
623         SetKeyValue(&entities[0], "_q3map2_cmdline", newCommandLine);
624         SetKeyValue(&entities[0], "_q3map2_version", Q3MAP_VERSION);
625 }
626
627 /*
628 UnparseEntities()
629 generates the dentdata string from all the entities.
630 this allows the utilities to add or remove key/value
631 pairs to the data created by the map editor
632 */
633
634 void UnparseEntities( void )
635 {
636         int                     i;
637         char            *buf, *end;
638         epair_t         *ep;
639         char            line[ 2048 ];
640         char            key[ 1024 ], value[ 1024 ];
641         const char      *value2;
642         
643         
644         /* setup */
645         AUTOEXPAND_BY_REALLOC(bspEntData, 0, allocatedBSPEntData, 1024);
646         buf = bspEntData;
647         end = buf;
648         *end = 0;
649
650         
651         /* run through entity list */
652         for( i = 0; i < numBSPEntities && i < numEntities; i++ )
653         {
654                 {
655                         int sz = end - buf;
656                         AUTOEXPAND_BY_REALLOC(bspEntData, sz + 65536, allocatedBSPEntData, 1024);
657                         buf = bspEntData;
658                         end = buf + sz;
659                 }
660
661                 /* get epair */
662                 ep = entities[ i ].epairs;
663                 if( ep == NULL )
664                         continue;       /* ent got removed */
665                 
666                 /* ydnar: certain entities get stripped from bsp file */
667                 value2 = ValueForKey( &entities[ i ], "classname" );
668                 if( !Q_stricmp( value2, "misc_model" ) ||
669                         !Q_stricmp( value2, "_decal" ) ||
670                         !Q_stricmp( value2, "_skybox" ) )
671                         continue;
672                 
673                 /* add beginning brace */
674                 strcat( end, "{\n" );
675                 end += 2;
676                 
677                 /* walk epair list */
678                 for( ep = entities[ i ].epairs; ep != NULL; ep = ep->next )
679                 {
680                         /* copy and clean */
681                         strcpy( key, ep->key );
682                         StripTrailing( key );
683                         strcpy( value, ep->value );
684                         StripTrailing( value );
685                         
686                         /* add to buffer */
687                         sprintf( line, "\"%s\" \"%s\"\n", key, value );
688                         strcat( end, line );
689                         end += strlen( line );
690                 }
691                 
692                 /* add trailing brace */
693                 strcat( end,"}\n" );
694                 end += 2;
695                 
696                 /* check for overflow */
697                 if( end > buf + allocatedBSPEntData )
698                         Error( "Entity text too long" );
699         }
700         
701         /* set size */
702         bspEntDataSize = end - buf + 1;
703 }
704
705
706
707 /*
708 PrintEntity()
709 prints an entity's epairs to the console
710 */
711
712 void PrintEntity( const entity_t *ent )
713 {
714         epair_t *ep;
715         
716
717         Sys_Printf( "------- entity %p -------\n", ent );
718         for( ep = ent->epairs; ep != NULL; ep = ep->next )
719                 Sys_Printf( "%s = %s\n", ep->key, ep->value );
720
721 }
722
723
724
725 /*
726 SetKeyValue()
727 sets an epair in an entity
728 */
729
730 void SetKeyValue( entity_t *ent, const char *key, const char *value )
731 {
732         epair_t *ep;
733         
734         
735         /* check for existing epair */
736         for( ep = ent->epairs; ep != NULL; ep = ep->next )
737         {
738                 if( !EPAIR_STRCMP( ep->key, key ) )
739                 {
740                         free( ep->value );
741                         ep->value = copystring( value );
742                         return;
743                 }
744         }
745         
746         /* create new epair */
747         ep = safe_malloc( sizeof( *ep ) );
748         ep->next = ent->epairs;
749         ent->epairs = ep;
750         ep->key = copystring( key );
751         ep->value = copystring( value );
752 }
753
754 /*
755 KeyExists()
756 returns true if entity has this key
757 */
758
759 qboolean KeyExists( const entity_t *ent, const char *key )
760 {
761         epair_t *ep;
762         
763         /* walk epair list */
764         for( ep = ent->epairs; ep != NULL; ep = ep->next )
765         {
766                 if( !EPAIR_STRCMP( ep->key, key ) )
767                         return qtrue;
768         }
769
770         /* no match */
771         return qfalse;
772 }
773
774 /*
775 ValueForKey()
776 gets the value for an entity key
777 */
778
779 const char *ValueForKey( const entity_t *ent, const char *key )
780 {
781         epair_t *ep;
782         
783         
784         /* dummy check */
785         if( ent == NULL )
786                 return "";
787         
788         /* walk epair list */
789         for( ep = ent->epairs; ep != NULL; ep = ep->next )
790         {
791                 if( !EPAIR_STRCMP( ep->key, key ) )
792                         return ep->value;
793         }
794         
795         /* if no match, return empty string */
796         return "";
797 }
798
799
800
801 /*
802 IntForKey()
803 gets the integer point value for an entity key
804 */
805
806 int IntForKey( const entity_t *ent, const char *key )
807 {
808         const char      *k;
809         
810         
811         k = ValueForKey( ent, key );
812         return atoi( k );
813 }
814
815
816
817 /*
818 FloatForKey()
819 gets the floating point value for an entity key
820 */
821
822 vec_t FloatForKey( const entity_t *ent, const char *key )
823 {
824         const char      *k;
825         
826         
827         k = ValueForKey( ent, key );
828         return atof( k );
829 }
830
831
832
833 /*
834 GetVectorForKey()
835 gets a 3-element vector value for an entity key
836 */
837
838 void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec )
839 {
840         const char      *k;
841         double          v1, v2, v3;
842         
843
844         /* get value */
845         k = ValueForKey( ent, key );
846         
847         /* scanf into doubles, then assign, so it is vec_t size independent */
848         v1 = v2 = v3 = 0.0;
849         sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );
850         vec[ 0 ] = v1;
851         vec[ 1 ] = v2;
852         vec[ 2 ] = v3;
853 }
854
855
856
857 /*
858 FindTargetEntity()
859 finds an entity target
860 */
861
862 entity_t *FindTargetEntity( const char *target )
863 {
864         int                     i;
865         const char      *n;
866
867         
868         /* walk entity list */
869         for( i = 0; i < numEntities; i++ )
870         {
871                 n = ValueForKey( &entities[ i ], "targetname" );
872                 if ( !strcmp( n, target ) )
873                         return &entities[ i ];
874         }
875         
876         /* nada */
877         return NULL;
878 }
879
880
881
882 /*
883 GetEntityShadowFlags() - ydnar
884 gets an entity's shadow flags
885 note: does not set them to defaults if the keys are not found!
886 */
887
888 void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows )
889 {
890         const char      *value;
891         
892         /* get cast shadows */
893         if( castShadows != NULL )
894         {
895                 value = ValueForKey( ent, "_castShadows" );
896                 if( value[ 0 ] == '\0' )
897                         value = ValueForKey( ent, "_cs" );
898                 if( value[ 0 ] == '\0' )
899                         value = ValueForKey( ent2, "_castShadows" );
900                 if( value[ 0 ] == '\0' )
901                         value = ValueForKey( ent2, "_cs" );
902                 if( value[ 0 ] != '\0' )
903                         *castShadows = atoi( value );
904         }
905         
906         /* receive */
907         if( recvShadows != NULL )
908         {
909                 value = ValueForKey( ent, "_receiveShadows" );
910                 if( value[ 0 ] == '\0' )
911                         value = ValueForKey( ent, "_rs" );
912                 if( value[ 0 ] == '\0' )
913                         value = ValueForKey( ent2, "_receiveShadows" );
914                 if( value[ 0 ] == '\0' )
915                         value = ValueForKey( ent2, "_rs" );
916                 if( value[ 0 ] != '\0' )
917                         *recvShadows = atoi( value );
918         }
919
920         /* vortex: game-specific default eneity keys */
921         value = ValueForKey( ent, "classname" );
922         if (!Q_stricmp( game->magic, "dq" ) || !Q_stricmp( game->magic, "prophecy" ) )
923         {
924                 /* vortex: deluxe quake default shadow flags */
925                 if (!Q_stricmp( value, "func_wall" ) )
926                 {
927                         if( recvShadows != NULL )
928                                 *recvShadows = 1;
929                         if( castShadows != NULL )
930                                 *castShadows = 1;
931                 }
932         }
933 }
934