Remove -Wno-unused-but-set-variable
[xonotic/netradiant.git] / tools / quake3 / common / bspfile.c
1 /*
2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22
23 #include "cmdlib.h"
24 #include "mathlib.h"
25 #include "inout.h"
26 #include "bspfile.h"
27 #include "scriplib.h"
28
29 void GetLeafNums( void );
30
31 //=============================================================================
32
33 int bsp_version = Q3_BSP_VERSION;
34
35 int nummodels;
36 dmodel_t dmodels[MAX_MAP_MODELS];
37
38 int numShaders;
39 dshader_t dshaders[MAX_MAP_SHADERS];
40
41 int entdatasize;
42 char dentdata[MAX_MAP_ENTSTRING];
43
44 int numleafs;
45 dleaf_t dleafs[MAX_MAP_LEAFS];
46
47 int numplanes;
48 dplane_t dplanes[MAX_MAP_PLANES];
49
50 int numnodes;
51 dnode_t dnodes[MAX_MAP_NODES];
52
53 int numleafsurfaces;
54 int dleafsurfaces[MAX_MAP_LEAFFACES];
55
56 int numleafbrushes;
57 int dleafbrushes[MAX_MAP_LEAFBRUSHES];
58
59 int numbrushes;
60 dbrush_t dbrushes[MAX_MAP_BRUSHES];
61
62 int numbrushsides;
63 dbrushside_t dbrushsides[MAX_MAP_BRUSHSIDES];
64
65 int numLightBytes;
66 byte        *lightBytes;
67
68 int numGridPoints;
69 byte        *gridData;
70
71 int numVisBytes;
72 byte visBytes[MAX_MAP_VISIBILITY];
73
74 int numDrawVerts = 0;
75 int numDrawVertsBuffer = 0;
76 drawVert_t  *drawVerts = NULL;
77
78 int numDrawIndexes;
79 int drawIndexes[MAX_MAP_DRAW_INDEXES];
80
81 int numDrawSurfaces;
82 int numDrawSurfacesBuffer = 0;
83 dsurface_t  *drawSurfaces = NULL;
84
85 int numFogs;
86 dfog_t dfogs[MAX_MAP_FOGS];
87
88 void SetLightBytes( int n ){
89         if ( lightBytes != 0 ) {
90                 free( lightBytes );
91         }
92
93         numLightBytes = n;
94
95         if ( n == 0 ) {
96                 return;
97         }
98
99         lightBytes = safe_malloc_info( numLightBytes, "SetLightBytes" );
100
101         memset( lightBytes, 0, numLightBytes );
102 }
103
104 void SetGridPoints( int n ){
105         if ( gridData != 0 ) {
106                 free( gridData );
107         }
108
109         numGridPoints = n;
110
111         if ( n == 0 ) {
112                 return;
113         }
114
115         gridData = safe_malloc_info( numGridPoints * 8, "SetGridPoints" );
116
117         memset( gridData, 0, numGridPoints * 8 );
118 }
119
120 void IncDrawVerts(){
121         numDrawVerts++;
122
123         if ( drawVerts == 0 ) {
124                 numDrawVertsBuffer = MAX_MAP_DRAW_VERTS / 37;
125
126                 drawVerts = safe_malloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" );
127
128         }
129         else if ( numDrawVerts > numDrawVertsBuffer ) {
130                 numDrawVertsBuffer *= 3; // multiply by 1.5
131                 numDrawVertsBuffer /= 2;
132
133                 if ( numDrawVertsBuffer > MAX_MAP_DRAW_VERTS ) {
134                         numDrawVertsBuffer = MAX_MAP_DRAW_VERTS;
135                 }
136
137                 drawVerts = realloc( drawVerts, sizeof( drawVert_t ) * numDrawVertsBuffer );
138
139                 if ( !drawVerts ) {
140                         Error( "realloc() failed (IncDrawVerts)" );
141                 }
142         }
143
144         memset( drawVerts + ( numDrawVerts - 1 ), 0, sizeof( drawVert_t ) );
145 }
146
147 void SetDrawVerts( int n ){
148         if ( drawVerts != 0 ) {
149                 free( drawVerts );
150         }
151
152         numDrawVerts = n;
153         numDrawVertsBuffer = numDrawVerts;
154
155         drawVerts = safe_malloc_info( sizeof( drawVert_t ) * numDrawVertsBuffer, "IncDrawVerts" );
156
157         memset( drawVerts, 0, n * sizeof( drawVert_t ) );
158 }
159
160 void SetDrawSurfacesBuffer(){
161         if ( drawSurfaces != 0 ) {
162                 free( drawSurfaces );
163         }
164
165         numDrawSurfacesBuffer = MAX_MAP_DRAW_SURFS;
166
167         drawSurfaces = safe_malloc_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" );
168
169         memset( drawSurfaces, 0, MAX_MAP_DRAW_SURFS * sizeof( drawVert_t ) );
170 }
171
172 void SetDrawSurfaces( int n ){
173         if ( drawSurfaces != 0 ) {
174                 free( drawSurfaces );
175         }
176
177         numDrawSurfaces = n;
178         numDrawSurfacesBuffer = numDrawSurfaces;
179
180         drawSurfaces = safe_malloc_info( sizeof( dsurface_t ) * numDrawSurfacesBuffer, "IncDrawSurfaces" );
181
182         memset( drawSurfaces, 0, n * sizeof( drawVert_t ) );
183 }
184
185 void BspFilesCleanup(){
186         if ( drawVerts != 0 ) {
187                 free( drawVerts );
188         }
189         if ( drawSurfaces != 0 ) {
190                 free( drawSurfaces );
191         }
192         if ( lightBytes != 0 ) {
193                 free( lightBytes );
194         }
195         if ( gridData != 0 ) {
196                 free( gridData );
197         }
198 }
199
200 //=============================================================================
201
202 /*
203    =============
204    SwapBlock
205
206    If all values are 32 bits, this can be used to swap everything
207    =============
208  */
209 void SwapBlock( int *block, int sizeOfBlock ) {
210         int i;
211
212         sizeOfBlock >>= 2;
213         for ( i = 0 ; i < sizeOfBlock ; i++ ) {
214                 block[i] = LittleLong( block[i] );
215         }
216 }
217
218 /*
219    =============
220    SwapBSPFile
221
222    Byte swaps all data in a bsp file.
223    =============
224  */
225 void SwapBSPFile( void ) {
226         int i;
227
228         // models
229         SwapBlock( (int *)dmodels, nummodels * sizeof( dmodels[0] ) );
230
231         // shaders (don't swap the name)
232         for ( i = 0 ; i < numShaders ; i++ ) {
233                 dshaders[i].contentFlags = LittleLong( dshaders[i].contentFlags );
234                 dshaders[i].surfaceFlags = LittleLong( dshaders[i].surfaceFlags );
235         }
236
237         // planes
238         SwapBlock( (int *)dplanes, numplanes * sizeof( dplanes[0] ) );
239
240         // nodes
241         SwapBlock( (int *)dnodes, numnodes * sizeof( dnodes[0] ) );
242
243         // leafs
244         SwapBlock( (int *)dleafs, numleafs * sizeof( dleafs[0] ) );
245
246         // leaffaces
247         SwapBlock( (int *)dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
248
249         // leafbrushes
250         SwapBlock( (int *)dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
251
252         // brushes
253         SwapBlock( (int *)dbrushes, numbrushes * sizeof( dbrushes[0] ) );
254
255         // brushsides
256         SwapBlock( (int *)dbrushsides, numbrushsides * sizeof( dbrushsides[0] ) );
257
258         // vis
259         ( (int *)&visBytes )[0] = LittleLong( ( (int *)&visBytes )[0] );
260         ( (int *)&visBytes )[1] = LittleLong( ( (int *)&visBytes )[1] );
261
262         // drawverts (don't swap colors )
263         for ( i = 0 ; i < numDrawVerts ; i++ ) {
264                 drawVerts[i].lightmap[0] = LittleFloat( drawVerts[i].lightmap[0] );
265                 drawVerts[i].lightmap[1] = LittleFloat( drawVerts[i].lightmap[1] );
266                 drawVerts[i].st[0] = LittleFloat( drawVerts[i].st[0] );
267                 drawVerts[i].st[1] = LittleFloat( drawVerts[i].st[1] );
268                 drawVerts[i].xyz[0] = LittleFloat( drawVerts[i].xyz[0] );
269                 drawVerts[i].xyz[1] = LittleFloat( drawVerts[i].xyz[1] );
270                 drawVerts[i].xyz[2] = LittleFloat( drawVerts[i].xyz[2] );
271                 drawVerts[i].normal[0] = LittleFloat( drawVerts[i].normal[0] );
272                 drawVerts[i].normal[1] = LittleFloat( drawVerts[i].normal[1] );
273                 drawVerts[i].normal[2] = LittleFloat( drawVerts[i].normal[2] );
274         }
275
276         // drawindexes
277         SwapBlock( (int *)drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
278
279         // drawsurfs
280         SwapBlock( (int *)drawSurfaces, numDrawSurfaces * sizeof( drawSurfaces[0] ) );
281
282         // fogs
283         for ( i = 0 ; i < numFogs ; i++ ) {
284                 dfogs[i].brushNum = LittleLong( dfogs[i].brushNum );
285                 dfogs[i].visibleSide = LittleLong( dfogs[i].visibleSide );
286         }
287 }
288
289
290
291 /*
292    =============
293    GetLumpElements
294    =============
295  */
296 int GetLumpElements( dheader_t  *header, int lump, int size ) {
297         int length = header->lumps[lump].filelen;
298
299         if ( length % size ) {
300                 Error( "LoadBSPFile: odd lump size" );
301         }
302
303         return length / size;
304 }
305
306 /*
307    =============
308    CopyLump
309    =============
310  */
311 int CopyLump( dheader_t *header, int lump, void *dest, int size ) {
312         int length, ofs;
313
314         length = header->lumps[lump].filelen;
315         ofs = header->lumps[lump].fileofs;
316
317         if ( length == 0 ) {
318                 return 0;
319         }
320
321         if ( length % size ) {
322                 Error( "LoadBSPFile: odd lump size" );
323         }
324
325         memcpy( dest, (byte *)header + ofs, length );
326
327         return length / size;
328 }
329
330 /*
331    =============
332    LoadBSPFile
333    =============
334  */
335 void    LoadBSPFile( const char *filename ) {
336         dheader_t   *header;
337
338         // load the file header
339         LoadFile( filename, (void **)&header );
340
341         // swap the header
342         SwapBlock( (int *)header, sizeof( *header ) );
343
344         if ( header->ident != BSP_IDENT ) {
345                 Error( "%s is not a IBSP file", filename );
346         }
347         if ( header->version != bsp_version ) {
348                 Error( "%s is version %i, not %i", filename, header->version, bsp_version );
349         }
350
351         numShaders = CopyLump( header, LUMP_SHADERS, dshaders, sizeof( dshader_t ) );
352         nummodels = CopyLump( header, LUMP_MODELS, dmodels, sizeof( dmodel_t ) );
353         numplanes = CopyLump( header, LUMP_PLANES, dplanes, sizeof( dplane_t ) );
354         numleafs = CopyLump( header, LUMP_LEAFS, dleafs, sizeof( dleaf_t ) );
355         numnodes = CopyLump( header, LUMP_NODES, dnodes, sizeof( dnode_t ) );
356         numleafsurfaces = CopyLump( header, LUMP_LEAFSURFACES, dleafsurfaces, sizeof( dleafsurfaces[0] ) );
357         numleafbrushes = CopyLump( header, LUMP_LEAFBRUSHES, dleafbrushes, sizeof( dleafbrushes[0] ) );
358         numbrushes = CopyLump( header, LUMP_BRUSHES, dbrushes, sizeof( dbrush_t ) );
359         numbrushsides = CopyLump( header, LUMP_BRUSHSIDES, dbrushsides, sizeof( dbrushside_t ) );
360         numDrawVerts = GetLumpElements( header, LUMP_DRAWVERTS, sizeof( drawVert_t ) );
361         SetDrawVerts( numDrawVerts );
362         CopyLump( header, LUMP_DRAWVERTS, drawVerts, sizeof( drawVert_t ) );
363         numDrawSurfaces = GetLumpElements( header, LUMP_SURFACES, sizeof( dsurface_t ) );
364         SetDrawSurfaces( numDrawSurfaces );
365         numDrawSurfaces = CopyLump( header, LUMP_SURFACES, drawSurfaces, sizeof( dsurface_t ) );
366         numFogs = CopyLump( header, LUMP_FOGS, dfogs, sizeof( dfog_t ) );
367         numDrawIndexes = CopyLump( header, LUMP_DRAWINDEXES, drawIndexes, sizeof( drawIndexes[0] ) );
368
369         numVisBytes = CopyLump( header, LUMP_VISIBILITY, visBytes, 1 );
370         numLightBytes = GetLumpElements( header, LUMP_LIGHTMAPS, 1 );
371         SetLightBytes( numLightBytes );
372         CopyLump( header, LUMP_LIGHTMAPS, lightBytes, 1 );
373         entdatasize = CopyLump( header, LUMP_ENTITIES, dentdata, 1 );
374
375         numGridPoints = GetLumpElements( header, LUMP_LIGHTGRID, 8 );
376         SetGridPoints( numGridPoints );
377         CopyLump( header, LUMP_LIGHTGRID, gridData, 8 );
378
379
380         free( header );     // everything has been copied out
381
382         // swap everything
383         SwapBSPFile();
384 }
385
386
387 //============================================================================
388
389 /*
390    =============
391    AddLump
392    =============
393  */
394 void AddLump( FILE *bspfile, dheader_t *header, int lumpnum, const void *data, int len ) {
395         lump_t *lump;
396
397         lump = &header->lumps[lumpnum];
398
399         lump->fileofs = LittleLong( ftell( bspfile ) );
400         lump->filelen = LittleLong( len );
401         SafeWrite( bspfile, data, ( len + 3 ) & ~3 );
402 }
403
404 /*
405    =============
406    WriteBSPFile
407
408    Swaps the bsp file in place, so it should not be referenced again
409    =============
410  */
411 void    WriteBSPFile( const char *filename ) {
412         dheader_t outheader, *header;
413         FILE        *bspfile;
414
415         header = &outheader;
416         memset( header, 0, sizeof( dheader_t ) );
417
418         SwapBSPFile();
419
420         header->ident = LittleLong( BSP_IDENT );
421         header->version = LittleLong( bsp_version );
422
423         bspfile = SafeOpenWrite( filename );
424         SafeWrite( bspfile, header, sizeof( dheader_t ) );    // overwritten later
425
426         AddLump( bspfile, header, LUMP_SHADERS, dshaders, numShaders * sizeof( dshader_t ) );
427         AddLump( bspfile, header, LUMP_PLANES, dplanes, numplanes * sizeof( dplane_t ) );
428         AddLump( bspfile, header, LUMP_LEAFS, dleafs, numleafs * sizeof( dleaf_t ) );
429         AddLump( bspfile, header, LUMP_NODES, dnodes, numnodes * sizeof( dnode_t ) );
430         AddLump( bspfile, header, LUMP_BRUSHES, dbrushes, numbrushes * sizeof( dbrush_t ) );
431         AddLump( bspfile, header, LUMP_BRUSHSIDES, dbrushsides, numbrushsides * sizeof( dbrushside_t ) );
432         AddLump( bspfile, header, LUMP_LEAFSURFACES, dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
433         AddLump( bspfile, header, LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
434         AddLump( bspfile, header, LUMP_MODELS, dmodels, nummodels * sizeof( dmodel_t ) );
435         AddLump( bspfile, header, LUMP_DRAWVERTS, drawVerts, numDrawVerts * sizeof( drawVert_t ) );
436         AddLump( bspfile, header, LUMP_SURFACES, drawSurfaces, numDrawSurfaces * sizeof( dsurface_t ) );
437         AddLump( bspfile, header, LUMP_VISIBILITY, visBytes, numVisBytes );
438         AddLump( bspfile, header, LUMP_LIGHTMAPS, lightBytes, numLightBytes );
439         AddLump( bspfile, header, LUMP_LIGHTGRID, gridData, 8 * numGridPoints );
440         AddLump( bspfile, header, LUMP_ENTITIES, dentdata, entdatasize );
441         AddLump( bspfile, header, LUMP_FOGS, dfogs, numFogs * sizeof( dfog_t ) );
442         AddLump( bspfile, header, LUMP_DRAWINDEXES, drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
443
444         fseek( bspfile, 0, SEEK_SET );
445         SafeWrite( bspfile, header, sizeof( dheader_t ) );
446         fclose( bspfile );
447 }
448
449 //============================================================================
450
451 /*
452    =============
453    PrintBSPFileSizes
454
455    Dumps info about current file
456    =============
457  */
458 void PrintBSPFileSizes( void ) {
459         if ( !num_entities ) {
460                 ParseEntities();
461         }
462
463         Sys_Printf( "%6i models       %7i\n"
464                                 ,nummodels, (int)( nummodels * sizeof( dmodel_t ) ) );
465         Sys_Printf( "%6i shaders      %7i\n"
466                                 ,numShaders, (int)( numShaders * sizeof( dshader_t ) ) );
467         Sys_Printf( "%6i brushes      %7i\n"
468                                 ,numbrushes, (int)( numbrushes * sizeof( dbrush_t ) ) );
469         Sys_Printf( "%6i brushsides   %7i\n"
470                                 ,numbrushsides, (int)( numbrushsides * sizeof( dbrushside_t ) ) );
471         Sys_Printf( "%6i fogs         %7i\n"
472                                 ,numFogs, (int)( numFogs * sizeof( dfog_t ) ) );
473         Sys_Printf( "%6i planes       %7i\n"
474                                 ,numplanes, (int)( numplanes * sizeof( dplane_t ) ) );
475         Sys_Printf( "%6i entdata      %7i\n", num_entities, entdatasize );
476
477         Sys_Printf( "\n" );
478
479         Sys_Printf( "%6i nodes        %7i\n"
480                                 ,numnodes, (int)( numnodes * sizeof( dnode_t ) ) );
481         Sys_Printf( "%6i leafs        %7i\n"
482                                 ,numleafs, (int)( numleafs * sizeof( dleaf_t ) ) );
483         Sys_Printf( "%6i leafsurfaces %7i\n"
484                                 ,numleafsurfaces, (int)( numleafsurfaces * sizeof( dleafsurfaces[0] ) ) );
485         Sys_Printf( "%6i leafbrushes  %7i\n"
486                                 ,numleafbrushes, (int)( numleafbrushes * sizeof( dleafbrushes[0] ) ) );
487         Sys_Printf( "%6i drawverts    %7i\n"
488                                 ,numDrawVerts, (int)( numDrawVerts * sizeof( drawVerts[0] ) ) );
489         Sys_Printf( "%6i drawindexes  %7i\n"
490                                 ,numDrawIndexes, (int)( numDrawIndexes * sizeof( drawIndexes[0] ) ) );
491         Sys_Printf( "%6i drawsurfaces %7i\n"
492                                 ,numDrawSurfaces, (int)( numDrawSurfaces * sizeof( drawSurfaces[0] ) ) );
493
494         Sys_Printf( "%6i lightmaps    %7i\n"
495                                 ,numLightBytes / ( LIGHTMAP_WIDTH * LIGHTMAP_HEIGHT * 3 ), numLightBytes );
496         Sys_Printf( "       visibility   %7i\n"
497                                 , numVisBytes );
498 }
499
500
501 //============================================
502
503 int num_entities;
504 entity_t entities[MAX_MAP_ENTITIES];
505
506 void StripTrailing( char *e ) {
507         char    *s;
508
509         s = e + strlen( e ) - 1;
510         while ( s >= e && *s <= 32 )
511         {
512                 *s = 0;
513                 s--;
514         }
515 }
516
517 /*
518    =================
519    ParseEpair
520    =================
521  */
522 epair_t *ParseEpair( void ) {
523         epair_t *e;
524
525         e = safe_malloc( sizeof( epair_t ) );
526         memset( e, 0, sizeof( epair_t ) );
527
528         if ( strlen( token ) >= MAX_KEY - 1 ) {
529                 Error( "ParseEpar: token too long" );
530         }
531         e->key = copystring( token );
532         GetToken( qfalse );
533         if ( strlen( token ) >= MAX_VALUE - 1 ) {
534                 Error( "ParseEpar: token too long" );
535         }
536         e->value = copystring( token );
537
538         // strip trailing spaces that sometimes get accidentally
539         // added in the editor
540         StripTrailing( e->key );
541         StripTrailing( e->value );
542
543         return e;
544 }
545
546
547 /*
548    ================
549    ParseEntity
550    ================
551  */
552 qboolean    ParseEntity( void ) {
553         epair_t     *e;
554         entity_t    *mapent;
555
556         if ( !GetToken( qtrue ) ) {
557                 return qfalse;
558         }
559
560         if ( strcmp( token, "{" ) ) {
561                 Error( "ParseEntity: { not found" );
562         }
563         if ( num_entities == MAX_MAP_ENTITIES ) {
564                 Error( "num_entities == MAX_MAP_ENTITIES" );
565         }
566         mapent = &entities[num_entities];
567         num_entities++;
568
569         do {
570                 if ( !GetToken( qtrue ) ) {
571                         Error( "ParseEntity: EOF without closing brace" );
572                 }
573                 if ( !strcmp( token, "}" ) ) {
574                         break;
575                 }
576                 e = ParseEpair();
577                 e->next = mapent->epairs;
578                 mapent->epairs = e;
579         } while ( 1 );
580
581         return qtrue;
582 }
583
584 /*
585    ================
586    ParseEntities
587
588    Parses the dentdata string into entities
589    ================
590  */
591 void ParseEntities( void ) {
592         num_entities = 0;
593         ParseFromMemory( dentdata, entdatasize );
594
595         while ( ParseEntity() ) {
596         }
597 }
598
599
600 /*
601    ================
602    UnparseEntities
603
604    Generates the dentdata string from all the entities
605    This allows the utilities to add or remove key/value pairs
606    to the data created by the map editor.
607    ================
608  */
609 void UnparseEntities( void ) {
610         char    *buf, *end;
611         epair_t *ep;
612         char line[2048];
613         int i;
614         char key[1024], value[1024];
615
616         buf = dentdata;
617         end = buf;
618         *end = 0;
619
620         for ( i = 0 ; i < num_entities ; i++ ) {
621                 ep = entities[i].epairs;
622                 if ( !ep ) {
623                         continue;   // ent got removed
624                 }
625
626                 strcat( end,"{\n" );
627                 end += 2;
628
629                 for ( ep = entities[i].epairs ; ep ; ep = ep->next ) {
630                         strcpy( key, ep->key );
631                         StripTrailing( key );
632                         strcpy( value, ep->value );
633                         StripTrailing( value );
634
635                         sprintf( line, "\"%s\" \"%s\"\n", key, value );
636                         strcat( end, line );
637                         end += strlen( line );
638                 }
639                 strcat( end,"}\n" );
640                 end += 2;
641
642                 if ( end > buf + MAX_MAP_ENTSTRING ) {
643                         Error( "Entity text too long" );
644                 }
645         }
646         entdatasize = end - buf + 1;
647 }
648
649 void PrintEntity( const entity_t *ent ) {
650         epair_t *ep;
651
652         Sys_Printf( "------- entity %p -------\n", ent );
653         for ( ep = ent->epairs ; ep ; ep = ep->next ) {
654                 Sys_Printf( "%s = %s\n", ep->key, ep->value );
655         }
656
657 }
658
659 void    SetKeyValue( entity_t *ent, const char *key, const char *value ) {
660         epair_t *ep;
661
662         for ( ep = ent->epairs ; ep ; ep = ep->next ) {
663                 if ( !strcmp( ep->key, key ) ) {
664                         free( ep->value );
665                         ep->value = copystring( value );
666                         return;
667                 }
668         }
669         ep = safe_malloc( sizeof( *ep ) );
670         ep->next = ent->epairs;
671         ent->epairs = ep;
672         ep->key = copystring( key );
673         ep->value = copystring( value );
674 }
675
676 const char  *ValueForKey( const entity_t *ent, const char *key ) {
677         epair_t *ep;
678
679         for ( ep = ent->epairs ; ep ; ep = ep->next ) {
680                 if ( !strcmp( ep->key, key ) ) {
681                         return ep->value;
682                 }
683         }
684         return "";
685 }
686
687 vec_t   FloatForKey( const entity_t *ent, const char *key ) {
688         const char  *k;
689
690         k = ValueForKey( ent, key );
691         return atof( k );
692 }
693
694 void    GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec ) {
695         const char  *k;
696         double v1, v2, v3;
697
698         k = ValueForKey( ent, key );
699
700         // scanf into doubles, then assign, so it is vec_t size independent
701         v1 = v2 = v3 = 0;
702         sscanf( k, "%lf %lf %lf", &v1, &v2, &v3 );
703         vec[0] = v1;
704         vec[1] = v2;
705         vec[2] = v3;
706 }