corrected a few LittleLongs to LittleFloat in md3 loading (EEP those were bad)
[xonotic/darkplaces.git] / pr_cmds.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20
21 #include "quakedef.h"
22
23 cvar_t sv_aim = {CVAR_SAVE, "sv_aim", "2"}; //"0.93"}; // LordHavoc: disabled autoaim by default
24 cvar_t pr_zone_min_strings = {0, "pr_zone_min_strings", "64"};
25
26 mempool_t *pr_strings_mempool;
27
28 #define MAX_VARSTRING 4096
29
30 char pr_varstring_temp[MAX_VARSTRING];
31
32 #define RETURN_EDICT(e) (((int *)pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e))
33
34
35 /*
36 ===============================================================================
37
38                                                 BUILT-IN FUNCTIONS
39
40 ===============================================================================
41 */
42
43
44 char *PF_VarString (int first)
45 {
46         int i;
47         const char *s;
48         char *out, *outend;
49
50         out = pr_varstring_temp;
51         outend = pr_varstring_temp + sizeof(pr_varstring_temp) - 1;
52         for (i = first;i < pr_argc && out < outend;i++)
53         {
54                 s = G_STRING((OFS_PARM0+i*3));
55                 while (out < outend && *s)
56                         *out++ = *s++;
57         }
58         *out++ = 0;
59         return pr_varstring_temp;
60 }
61
62 char *ENGINE_EXTENSIONS =
63 "DP_CL_LOADSKY "
64 "DP_EF_NODRAW "
65 "DP_EF_ADDITIVE "
66 "DP_EF_BLUE "
67 "DP_EF_RED "
68 "DP_EF_FULLBRIGHT "
69 "DP_EF_FLAME "
70 "DP_EF_STARDUST "
71 "DP_ENT_ALPHA "
72 "DP_ENT_CUSTOMCOLORMAP "
73 "DP_ENT_EXTERIORMODELTOCLIENT "
74 "DP_ENT_LOWPRECISION "
75 "DP_ENT_GLOW "
76 "DP_ENT_SCALE "
77 "DP_ENT_VIEWMODEL "
78 "DP_GFX_EXTERNALTEXTURES "
79 "DP_GFX_FOG "
80 "DP_GFX_QUAKE3MODELTAGS "
81 "DP_GFX_SKINFILES "
82 "DP_GFX_SKYBOX "
83 "DP_HALFLIFE_MAP "
84 "DP_HALFLIFE_MAP_CVAR "
85 "DP_INPUTBUTTONS "
86 "DP_MONSTERWALK "
87 "DP_MOVETYPEBOUNCEMISSILE "
88 "DP_MOVETYPEFOLLOW "
89 "DP_QC_CHANGEPITCH "
90 "DP_QC_COPYENTITY "
91 "DP_QC_ETOS "
92 "DP_QC_FINDCHAIN "
93 "DP_QC_FINDCHAINFLOAT "
94 "DP_QC_FINDFLOAT "
95 "DP_QC_GETLIGHT "
96 "DP_QC_GETSURFACE "
97 "DP_QC_MINMAXBOUND "
98 "DP_QC_RANDOMVEC "
99 "DP_QC_SINCOSSQRTPOW "
100 "DP_QC_TRACEBOX "
101 "DP_QC_TRACETOSS "
102 "DP_QC_VECTORVECTORS "
103 "DP_QUAKE2_MODEL "
104 "DP_QUAKE3_MODEL "
105 "DP_REGISTERCVAR "
106 "DP_SOLIDCORPSE "
107 "DP_SPRITE32 "
108 "DP_SV_DRAWONLYTOCLIENT "
109 "DP_SV_EFFECT "
110 "DP_SV_EXTERIORMODELTOCLIENT "
111 "DP_SV_NODRAWTOCLIENT "
112 "DP_SV_PLAYERPHYSICS "
113 "DP_SV_SETCOLOR "
114 "DP_SV_SLOWMO "
115 "DP_TE_BLOOD "
116 "DP_TE_BLOODSHOWER "
117 "DP_TE_CUSTOMFLASH "
118 "DP_TE_EXPLOSIONRGB "
119 "DP_TE_FLAMEJET "
120 "DP_TE_PARTICLECUBE "
121 "DP_TE_PARTICLERAIN "
122 "DP_TE_PARTICLESNOW "
123 "DP_TE_PLASMABURN "
124 "DP_TE_QUADEFFECTS1 "
125 "DP_TE_SMALLFLASH "
126 "DP_TE_SPARK "
127 "DP_TE_STANDARDEFFECTBUILTINS "
128 "DP_VIEWZOOM "
129 "FRIK_FILE "
130 "KRIMZON_SV_PARSECLIENTCOMMAND "
131 "NEH_CMD_PLAY2 "
132 "NEH_RESTOREGAME "
133 "TW_SV_STEPCONTROL "
134 ;
135
136 qboolean checkextension(char *name)
137 {
138         int len;
139         char *e, *start;
140         len = strlen(name);
141         for (e = ENGINE_EXTENSIONS;*e;e++)
142         {
143                 while (*e == ' ')
144                         e++;
145                 if (!*e)
146                         break;
147                 start = e;
148                 while (*e && *e != ' ')
149                         e++;
150                 if (e - start == len)
151                         if (!strncasecmp(start, name, len))
152                                 return true;
153         }
154         return false;
155 }
156
157 /*
158 =================
159 PF_checkextension
160
161 returns true if the extension is supported by the server
162
163 checkextension(extensionname)
164 =================
165 */
166 void PF_checkextension (void)
167 {
168         G_FLOAT(OFS_RETURN) = checkextension(G_STRING(OFS_PARM0));
169 }
170
171 /*
172 =================
173 PF_error
174
175 This is a TERMINAL error, which will kill off the entire server.
176 Dumps self.
177
178 error(value)
179 =================
180 */
181 void PF_error (void)
182 {
183         char    *s;
184         edict_t *ed;
185
186         s = PF_VarString(0);
187         Con_Printf ("======SERVER ERROR in %s:\n%s\n", PR_GetString(pr_xfunction->s_name), s);
188         ed = PROG_TO_EDICT(pr_global_struct->self);
189         ED_Print (ed);
190
191         Host_Error ("Program error");
192 }
193
194 /*
195 =================
196 PF_objerror
197
198 Dumps out self, then an error message.  The program is aborted and self is
199 removed, but the level can continue.
200
201 objerror(value)
202 =================
203 */
204 void PF_objerror (void)
205 {
206         char    *s;
207         edict_t *ed;
208
209         s = PF_VarString(0);
210         Con_Printf ("======OBJECT ERROR in %s:\n%s\n", PR_GetString(pr_xfunction->s_name), s);
211         ed = PROG_TO_EDICT(pr_global_struct->self);
212         ED_Print (ed);
213         ED_Free (ed);
214 }
215
216
217 /*
218 ==============
219 PF_makevectors
220
221 Writes new values for v_forward, v_up, and v_right based on angles
222 makevectors(vector)
223 ==============
224 */
225 void PF_makevectors (void)
226 {
227         AngleVectors (G_VECTOR(OFS_PARM0), pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up);
228 }
229
230 /*
231 ==============
232 PF_vectorvectors
233
234 Writes new values for v_forward, v_up, and v_right based on the given forward vector
235 vectorvectors(vector, vector)
236 ==============
237 */
238 void PF_vectorvectors (void)
239 {
240         VectorNormalize2(G_VECTOR(OFS_PARM0), pr_global_struct->v_forward);
241         VectorVectors(pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up);
242 }
243
244 /*
245 =================
246 PF_setorigin
247
248 This is the only valid way to move an object without using the physics of the world (setting velocity and waiting).  Directly changing origin will not set internal links correctly, so clipping would be messed up.  This should be called when an object is spawned, and then only if it is teleported.
249
250 setorigin (entity, origin)
251 =================
252 */
253 void PF_setorigin (void)
254 {
255         edict_t *e;
256         float   *org;
257
258         e = G_EDICT(OFS_PARM0);
259         org = G_VECTOR(OFS_PARM1);
260         VectorCopy (org, e->v->origin);
261         SV_LinkEdict (e, false);
262 }
263
264
265 void SetMinMaxSize (edict_t *e, float *min, float *max, qboolean rotate)
266 {
267         int             i;
268
269         for (i=0 ; i<3 ; i++)
270                 if (min[i] > max[i])
271                         Host_Error ("backwards mins/maxs");
272
273 // set derived values
274         VectorCopy (min, e->v->mins);
275         VectorCopy (max, e->v->maxs);
276         VectorSubtract (max, min, e->v->size);
277
278         SV_LinkEdict (e, false);
279 }
280
281 /*
282 =================
283 PF_setsize
284
285 the size box is rotated by the current angle
286 LordHavoc: no it isn't...
287
288 setsize (entity, minvector, maxvector)
289 =================
290 */
291 void PF_setsize (void)
292 {
293         edict_t *e;
294         float   *min, *max;
295
296         e = G_EDICT(OFS_PARM0);
297         min = G_VECTOR(OFS_PARM1);
298         max = G_VECTOR(OFS_PARM2);
299         SetMinMaxSize (e, min, max, false);
300 }
301
302
303 /*
304 =================
305 PF_setmodel
306
307 setmodel(entity, model)
308 =================
309 */
310 void PF_setmodel (void)
311 {
312         edict_t *e;
313         char    *m, **check;
314         model_t *mod;
315         int             i;
316
317         e = G_EDICT(OFS_PARM0);
318         m = G_STRING(OFS_PARM1);
319
320 // check to see if model was properly precached
321         for (i=0, check = sv.model_precache ; *check ; i++, check++)
322                 if (!strcmp(*check, m))
323                         break;
324
325         if (!*check)
326                 Host_Error ("no precache: %s\n", m);
327
328
329         e->v->model = PR_SetString(*check);
330         e->v->modelindex = i;
331
332         mod = sv.models[ (int)e->v->modelindex];
333
334         if (mod)
335                 SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
336         else
337                 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
338 }
339
340 /*
341 =================
342 PF_bprint
343
344 broadcast print to everyone on server
345
346 bprint(value)
347 =================
348 */
349 void PF_bprint (void)
350 {
351         char            *s;
352
353         s = PF_VarString(0);
354         SV_BroadcastPrintf ("%s", s);
355 }
356
357 /*
358 =================
359 PF_sprint
360
361 single print to a specific client
362
363 sprint(clientent, value)
364 =================
365 */
366 void PF_sprint (void)
367 {
368         char            *s;
369         client_t        *client;
370         int                     entnum;
371
372         entnum = G_EDICTNUM(OFS_PARM0);
373         s = PF_VarString(1);
374
375         if (entnum < 1 || entnum > svs.maxclients)
376         {
377                 Con_Printf ("tried to sprint to a non-client\n");
378                 return;
379         }
380
381         client = &svs.clients[entnum-1];
382
383         MSG_WriteChar (&client->message,svc_print);
384         MSG_WriteString (&client->message, s );
385 }
386
387
388 /*
389 =================
390 PF_centerprint
391
392 single print to a specific client
393
394 centerprint(clientent, value)
395 =================
396 */
397 void PF_centerprint (void)
398 {
399         char            *s;
400         client_t        *client;
401         int                     entnum;
402
403         entnum = G_EDICTNUM(OFS_PARM0);
404         s = PF_VarString(1);
405
406         if (entnum < 1 || entnum > svs.maxclients)
407         {
408                 Con_Printf ("tried to sprint to a non-client\n");
409                 return;
410         }
411
412         client = &svs.clients[entnum-1];
413
414         MSG_WriteChar (&client->message,svc_centerprint);
415         MSG_WriteString (&client->message, s );
416 }
417
418
419 /*
420 =================
421 PF_normalize
422
423 vector normalize(vector)
424 =================
425 */
426 void PF_normalize (void)
427 {
428         float   *value1;
429         vec3_t  newvalue;
430         float   new;
431
432         value1 = G_VECTOR(OFS_PARM0);
433
434         new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
435         new = sqrt(new);
436
437         if (new == 0)
438                 newvalue[0] = newvalue[1] = newvalue[2] = 0;
439         else
440         {
441                 new = 1/new;
442                 newvalue[0] = value1[0] * new;
443                 newvalue[1] = value1[1] * new;
444                 newvalue[2] = value1[2] * new;
445         }
446
447         VectorCopy (newvalue, G_VECTOR(OFS_RETURN));
448 }
449
450 /*
451 =================
452 PF_vlen
453
454 scalar vlen(vector)
455 =================
456 */
457 void PF_vlen (void)
458 {
459         float   *value1;
460         float   new;
461
462         value1 = G_VECTOR(OFS_PARM0);
463
464         new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
465         new = sqrt(new);
466
467         G_FLOAT(OFS_RETURN) = new;
468 }
469
470 /*
471 =================
472 PF_vectoyaw
473
474 float vectoyaw(vector)
475 =================
476 */
477 void PF_vectoyaw (void)
478 {
479         float   *value1;
480         float   yaw;
481
482         value1 = G_VECTOR(OFS_PARM0);
483
484         if (value1[1] == 0 && value1[0] == 0)
485                 yaw = 0;
486         else
487         {
488                 yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
489                 if (yaw < 0)
490                         yaw += 360;
491         }
492
493         G_FLOAT(OFS_RETURN) = yaw;
494 }
495
496
497 /*
498 =================
499 PF_vectoangles
500
501 vector vectoangles(vector)
502 =================
503 */
504 void PF_vectoangles (void)
505 {
506         float   *value1;
507         float   forward;
508         float   yaw, pitch;
509
510         value1 = G_VECTOR(OFS_PARM0);
511
512         if (value1[1] == 0 && value1[0] == 0)
513         {
514                 yaw = 0;
515                 if (value1[2] > 0)
516                         pitch = 90;
517                 else
518                         pitch = 270;
519         }
520         else
521         {
522                 // LordHavoc: optimized a bit
523                 if (value1[0])
524                 {
525                         yaw = (atan2(value1[1], value1[0]) * 180 / M_PI);
526                         if (yaw < 0)
527                                 yaw += 360;
528                 }
529                 else if (value1[1] > 0)
530                         yaw = 90;
531                 else
532                         yaw = 270;
533
534                 forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]);
535                 pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
536                 if (pitch < 0)
537                         pitch += 360;
538         }
539
540         G_FLOAT(OFS_RETURN+0) = pitch;
541         G_FLOAT(OFS_RETURN+1) = yaw;
542         G_FLOAT(OFS_RETURN+2) = 0;
543 }
544
545 /*
546 =================
547 PF_Random
548
549 Returns a number from 0<= num < 1
550
551 random()
552 =================
553 */
554 void PF_random (void)
555 {
556         float           num;
557
558         num = (rand ()&0x7fff) / ((float)0x7fff);
559
560         G_FLOAT(OFS_RETURN) = num;
561 }
562
563 /*
564 =================
565 PF_particle
566
567 particle(origin, color, count)
568 =================
569 */
570 void PF_particle (void)
571 {
572         float           *org, *dir;
573         float           color;
574         float           count;
575
576         org = G_VECTOR(OFS_PARM0);
577         dir = G_VECTOR(OFS_PARM1);
578         color = G_FLOAT(OFS_PARM2);
579         count = G_FLOAT(OFS_PARM3);
580         SV_StartParticle (org, dir, color, count);
581 }
582
583
584 /*
585 =================
586 PF_ambientsound
587
588 =================
589 */
590 void PF_ambientsound (void)
591 {
592         char            **check;
593         char            *samp;
594         float           *pos;
595         float           vol, attenuation;
596         int                     i, soundnum, large;
597
598         pos = G_VECTOR (OFS_PARM0);
599         samp = G_STRING(OFS_PARM1);
600         vol = G_FLOAT(OFS_PARM2);
601         attenuation = G_FLOAT(OFS_PARM3);
602
603 // check to see if samp was properly precached
604         for (soundnum=0, check = sv.sound_precache ; *check ; check++, soundnum++)
605                 if (!strcmp(*check,samp))
606                         break;
607
608         if (!*check)
609         {
610                 Con_Printf ("no precache: %s\n", samp);
611                 return;
612         }
613
614         large = false;
615         if (soundnum >= 256)
616                 large = true;
617
618         // add an svc_spawnambient command to the level signon packet
619
620         if (large)
621                 MSG_WriteByte (&sv.signon, svc_spawnstaticsound2);
622         else
623                 MSG_WriteByte (&sv.signon, svc_spawnstaticsound);
624
625         for (i=0 ; i<3 ; i++)
626                 MSG_WriteDPCoord(&sv.signon, pos[i]);
627
628         if (large)
629                 MSG_WriteShort (&sv.signon, soundnum);
630         else
631                 MSG_WriteByte (&sv.signon, soundnum);
632
633         MSG_WriteByte (&sv.signon, vol*255);
634         MSG_WriteByte (&sv.signon, attenuation*64);
635
636 }
637
638 /*
639 =================
640 PF_sound
641
642 Each entity can have eight independant sound sources, like voice,
643 weapon, feet, etc.
644
645 Channel 0 is an auto-allocate channel, the others override anything
646 already running on that entity/channel pair.
647
648 An attenuation of 0 will play full volume everywhere in the level.
649 Larger attenuations will drop off.
650
651 =================
652 */
653 void PF_sound (void)
654 {
655         char            *sample;
656         int                     channel;
657         edict_t         *entity;
658         int             volume;
659         float attenuation;
660
661         entity = G_EDICT(OFS_PARM0);
662         channel = G_FLOAT(OFS_PARM1);
663         sample = G_STRING(OFS_PARM2);
664         volume = G_FLOAT(OFS_PARM3) * 255;
665         attenuation = G_FLOAT(OFS_PARM4);
666
667         if (volume < 0 || volume > 255)
668                 Host_Error ("SV_StartSound: volume = %i", volume);
669
670         if (attenuation < 0 || attenuation > 4)
671                 Host_Error ("SV_StartSound: attenuation = %f", attenuation);
672
673         if (channel < 0 || channel > 7)
674                 Host_Error ("SV_StartSound: channel = %i", channel);
675
676         SV_StartSound (entity, channel, sample, volume, attenuation);
677 }
678
679 /*
680 =================
681 PF_break
682
683 break()
684 =================
685 */
686 void PF_break (void)
687 {
688         Host_Error ("break statement");
689 }
690
691 /*
692 =================
693 PF_traceline
694
695 Used for use tracing and shot targeting
696 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
697 if the tryents flag is set.
698
699 traceline (vector1, vector2, tryents)
700 =================
701 */
702 void PF_traceline (void)
703 {
704         float   *v1, *v2;
705         trace_t trace;
706         int             nomonsters;
707         edict_t *ent;
708
709         pr_xfunction->builtinsprofile += 30;
710
711         v1 = G_VECTOR(OFS_PARM0);
712         v2 = G_VECTOR(OFS_PARM1);
713         nomonsters = G_FLOAT(OFS_PARM2);
714         ent = G_EDICT(OFS_PARM3);
715
716         trace = SV_Move (v1, vec3_origin, vec3_origin, v2, nomonsters, ent);
717
718         pr_global_struct->trace_allsolid = trace.allsolid;
719         pr_global_struct->trace_startsolid = trace.startsolid;
720         pr_global_struct->trace_fraction = trace.fraction;
721         pr_global_struct->trace_inwater = trace.inwater;
722         pr_global_struct->trace_inopen = trace.inopen;
723         VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
724         VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
725         pr_global_struct->trace_plane_dist =  trace.plane.dist;
726         if (trace.ent)
727                 pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
728         else
729                 pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
730         // FIXME: add trace_endcontents
731 }
732
733
734 /*
735 =================
736 PF_tracebox
737
738 Used for use tracing and shot targeting
739 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
740 if the tryents flag is set.
741
742 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
743 =================
744 */
745 // LordHavoc: added this for my own use, VERY useful, similar to traceline
746 void PF_tracebox (void)
747 {
748         float   *v1, *v2, *m1, *m2;
749         trace_t trace;
750         int             nomonsters;
751         edict_t *ent;
752
753         pr_xfunction->builtinsprofile += 30;
754
755         v1 = G_VECTOR(OFS_PARM0);
756         m1 = G_VECTOR(OFS_PARM1);
757         m2 = G_VECTOR(OFS_PARM2);
758         v2 = G_VECTOR(OFS_PARM3);
759         nomonsters = G_FLOAT(OFS_PARM4);
760         ent = G_EDICT(OFS_PARM5);
761
762         trace = SV_Move (v1, m1, m2, v2, nomonsters ? MOVE_NOMONSTERS : MOVE_NORMAL, ent);
763
764         pr_global_struct->trace_allsolid = trace.allsolid;
765         pr_global_struct->trace_startsolid = trace.startsolid;
766         pr_global_struct->trace_fraction = trace.fraction;
767         pr_global_struct->trace_inwater = trace.inwater;
768         pr_global_struct->trace_inopen = trace.inopen;
769         VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
770         VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
771         pr_global_struct->trace_plane_dist =  trace.plane.dist;
772         if (trace.ent)
773                 pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
774         else
775                 pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
776 }
777
778 extern trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore);
779 void PF_TraceToss (void)
780 {
781         trace_t trace;
782         edict_t *ent;
783         edict_t *ignore;
784
785         pr_xfunction->builtinsprofile += 600;
786
787         ent = G_EDICT(OFS_PARM0);
788         ignore = G_EDICT(OFS_PARM1);
789
790         trace = SV_Trace_Toss (ent, ignore);
791
792         pr_global_struct->trace_allsolid = trace.allsolid;
793         pr_global_struct->trace_startsolid = trace.startsolid;
794         pr_global_struct->trace_fraction = trace.fraction;
795         pr_global_struct->trace_inwater = trace.inwater;
796         pr_global_struct->trace_inopen = trace.inopen;
797         VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
798         VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
799         pr_global_struct->trace_plane_dist =  trace.plane.dist;
800         if (trace.ent)
801                 pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
802         else
803                 pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
804 }
805
806
807 /*
808 =================
809 PF_checkpos
810
811 Returns true if the given entity can move to the given position from it's
812 current position by walking or rolling.
813 FIXME: make work...
814 scalar checkpos (entity, vector)
815 =================
816 */
817 void PF_checkpos (void)
818 {
819 }
820
821 //============================================================================
822
823 qbyte checkpvs[MAX_MAP_LEAFS/8];
824
825 int PF_newcheckclient (int check)
826 {
827         int             i;
828         edict_t *ent;
829         vec3_t  org;
830
831 // cycle to the next one
832
833         if (check < 1)
834                 check = 1;
835         if (check > svs.maxclients)
836                 check = svs.maxclients;
837
838         if (check == svs.maxclients)
839                 i = 1;
840         else
841                 i = check + 1;
842
843         for ( ;  ; i++)
844         {
845                 pr_xfunction->builtinsprofile++;
846                 if (i == svs.maxclients+1)
847                         i = 1;
848
849                 ent = EDICT_NUM(i);
850
851                 if (i == check)
852                         break;  // didn't find anything else
853
854                 if (ent->e->free)
855                         continue;
856                 if (ent->v->health <= 0)
857                         continue;
858                 if ((int)ent->v->flags & FL_NOTARGET)
859                         continue;
860
861         // anything that is a client, or has a client as an enemy
862                 break;
863         }
864
865 // get the PVS for the entity
866         VectorAdd (ent->v->origin, ent->v->view_ofs, org);
867         memcpy (checkpvs, sv.worldmodel->brushq1.LeafPVS(sv.worldmodel, sv.worldmodel->brushq1.PointInLeaf(sv.worldmodel, org)), (sv.worldmodel->brushq1.numleafs+7)>>3 );
868
869         return i;
870 }
871
872 /*
873 =================
874 PF_checkclient
875
876 Returns a client (or object that has a client enemy) that would be a
877 valid target.
878
879 If there is more than one valid option, they are cycled each frame
880
881 If (self.origin + self.viewofs) is not in the PVS of the current target,
882 it is not returned at all.
883
884 name checkclient ()
885 =================
886 */
887 int c_invis, c_notvis;
888 void PF_checkclient (void)
889 {
890         edict_t *ent, *self;
891         mleaf_t *leaf;
892         int             l;
893         vec3_t  view;
894
895         // find a new check if on a new frame
896         if (sv.time - sv.lastchecktime >= 0.1)
897         {
898                 sv.lastcheck = PF_newcheckclient (sv.lastcheck);
899                 sv.lastchecktime = sv.time;
900         }
901
902         // return check if it might be visible
903         ent = EDICT_NUM(sv.lastcheck);
904         if (ent->e->free || ent->v->health <= 0)
905         {
906                 RETURN_EDICT(sv.edicts);
907                 return;
908         }
909
910         // if current entity can't possibly see the check entity, return 0
911         self = PROG_TO_EDICT(pr_global_struct->self);
912         VectorAdd (self->v->origin, self->v->view_ofs, view);
913         leaf = sv.worldmodel->brushq1.PointInLeaf(sv.worldmodel, view);
914         if (leaf)
915         {
916                 l = (leaf - sv.worldmodel->brushq1.leafs) - 1;
917                 if ( (l<0) || !(checkpvs[l>>3] & (1<<(l&7)) ) )
918                 {
919                         c_notvis++;
920                         RETURN_EDICT(sv.edicts);
921                         return;
922                 }
923         }
924
925         // might be able to see it
926         c_invis++;
927         RETURN_EDICT(ent);
928 }
929
930 //============================================================================
931
932
933 /*
934 =================
935 PF_stuffcmd
936
937 Sends text over to the client's execution buffer
938
939 stuffcmd (clientent, value)
940 =================
941 */
942 void PF_stuffcmd (void)
943 {
944         int             entnum;
945         char    *str;
946         client_t        *old;
947
948         entnum = G_EDICTNUM(OFS_PARM0);
949         if (entnum < 1 || entnum > svs.maxclients)
950                 Host_Error ("Parm 0 not a client");
951         str = G_STRING(OFS_PARM1);
952
953         old = host_client;
954         host_client = &svs.clients[entnum-1];
955         Host_ClientCommands ("%s", str);
956         host_client = old;
957 }
958
959 /*
960 =================
961 PF_localcmd
962
963 Sends text over to the client's execution buffer
964
965 localcmd (string)
966 =================
967 */
968 void PF_localcmd (void)
969 {
970         char    *str;
971
972         str = G_STRING(OFS_PARM0);
973         Cbuf_AddText (str);
974 }
975
976 /*
977 =================
978 PF_cvar
979
980 float cvar (string)
981 =================
982 */
983 void PF_cvar (void)
984 {
985         char    *str;
986
987         str = G_STRING(OFS_PARM0);
988
989         G_FLOAT(OFS_RETURN) = Cvar_VariableValue (str);
990 }
991
992 /*
993 =================
994 PF_cvar_set
995
996 float cvar (string)
997 =================
998 */
999 void PF_cvar_set (void)
1000 {
1001         char    *var, *val;
1002
1003         var = G_STRING(OFS_PARM0);
1004         val = G_STRING(OFS_PARM1);
1005
1006         Cvar_Set (var, val);
1007 }
1008
1009 /*
1010 =================
1011 PF_findradius
1012
1013 Returns a chain of entities that have origins within a spherical area
1014
1015 findradius (origin, radius)
1016 =================
1017 */
1018 void PF_findradius (void)
1019 {
1020         edict_t *ent, *chain;
1021         float radius;
1022         float radius2;
1023         float *org;
1024         float eorg[3];
1025         int i;
1026
1027         chain = (edict_t *)sv.edicts;
1028
1029         org = G_VECTOR(OFS_PARM0);
1030         radius = G_FLOAT(OFS_PARM1);
1031         radius2 = radius * radius;
1032
1033         ent = NEXT_EDICT(sv.edicts);
1034         for (i=1 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
1035         {
1036                 pr_xfunction->builtinsprofile++;
1037                 if (ent->e->free)
1038                         continue;
1039                 if (ent->v->solid == SOLID_NOT)
1040                         continue;
1041
1042                 // LordHavoc: compare against bounding box rather than center,
1043                 // and use DotProduct instead of Length, major speedup
1044                 eorg[0] = (org[0] - ent->v->origin[0]) - bound(ent->v->mins[0], (org[0] - ent->v->origin[0]), ent->v->maxs[0]);
1045                 eorg[1] = (org[1] - ent->v->origin[1]) - bound(ent->v->mins[1], (org[1] - ent->v->origin[1]), ent->v->maxs[1]);
1046                 eorg[2] = (org[2] - ent->v->origin[2]) - bound(ent->v->mins[2], (org[2] - ent->v->origin[2]), ent->v->maxs[2]);
1047                 if (DotProduct(eorg, eorg) > radius2)
1048                         continue;
1049
1050                 ent->v->chain = EDICT_TO_PROG(chain);
1051                 chain = ent;
1052         }
1053
1054         RETURN_EDICT(chain);
1055 }
1056
1057
1058 /*
1059 =========
1060 PF_dprint
1061 =========
1062 */
1063 void PF_dprint (void)
1064 {
1065         Con_DPrintf ("%s",PF_VarString(0));
1066 }
1067
1068 // LordHavoc: added this to semi-fix the problem of using many ftos calls in a print
1069 #define STRINGTEMP_BUFFERS 16
1070 #define STRINGTEMP_LENGTH 128
1071 static char pr_string_temp[STRINGTEMP_BUFFERS][STRINGTEMP_LENGTH];
1072 static int pr_string_tempindex = 0;
1073
1074 static char *PR_GetTempString(void)
1075 {
1076         char *s;
1077         s = pr_string_temp[pr_string_tempindex];
1078         pr_string_tempindex = (pr_string_tempindex + 1) % STRINGTEMP_BUFFERS;
1079         return s;
1080 }
1081
1082 void PF_ftos (void)
1083 {
1084         float v;
1085         char *s;
1086         v = G_FLOAT(OFS_PARM0);
1087
1088         s = PR_GetTempString();
1089         // LordHavoc: ftos improvement
1090         sprintf (s, "%g", v);
1091         G_INT(OFS_RETURN) = PR_SetString(s);
1092 }
1093
1094 void PF_fabs (void)
1095 {
1096         float   v;
1097         v = G_FLOAT(OFS_PARM0);
1098         G_FLOAT(OFS_RETURN) = fabs(v);
1099 }
1100
1101 void PF_vtos (void)
1102 {
1103         char *s;
1104         s = PR_GetTempString();
1105         sprintf (s, "'%5.1f %5.1f %5.1f'", G_VECTOR(OFS_PARM0)[0], G_VECTOR(OFS_PARM0)[1], G_VECTOR(OFS_PARM0)[2]);
1106         G_INT(OFS_RETURN) = PR_SetString(s);
1107 }
1108
1109 void PF_etos (void)
1110 {
1111         char *s;
1112         s = PR_GetTempString();
1113         sprintf (s, "entity %i", G_EDICTNUM(OFS_PARM0));
1114         G_INT(OFS_RETURN) = PR_SetString(s);
1115 }
1116
1117 void PF_Spawn (void)
1118 {
1119         edict_t *ed;
1120         pr_xfunction->builtinsprofile += 20;
1121         ed = ED_Alloc();
1122         RETURN_EDICT(ed);
1123 }
1124
1125 void PF_Remove (void)
1126 {
1127         edict_t *ed;
1128         pr_xfunction->builtinsprofile += 20;
1129
1130         ed = G_EDICT(OFS_PARM0);
1131         if (ed == sv.edicts)
1132                 Host_Error("remove: tried to remove world\n");
1133         if (NUM_FOR_EDICT(ed) <= svs.maxclients)
1134                 Host_Error("remove: tried to remove a client\n");
1135         ED_Free (ed);
1136 }
1137
1138
1139 // entity (entity start, .string field, string match) find = #5;
1140 void PF_Find (void)
1141 {
1142         int             e;
1143         int             f;
1144         char    *s, *t;
1145         edict_t *ed;
1146
1147         e = G_EDICTNUM(OFS_PARM0);
1148         f = G_INT(OFS_PARM1);
1149         s = G_STRING(OFS_PARM2);
1150         if (!s || !s[0])
1151         {
1152                 RETURN_EDICT(sv.edicts);
1153                 return;
1154         }
1155
1156         for (e++ ; e < sv.num_edicts ; e++)
1157         {
1158                 pr_xfunction->builtinsprofile++;
1159                 ed = EDICT_NUM(e);
1160                 if (ed->e->free)
1161                         continue;
1162                 t = E_STRING(ed,f);
1163                 if (!t)
1164                         continue;
1165                 if (!strcmp(t,s))
1166                 {
1167                         RETURN_EDICT(ed);
1168                         return;
1169                 }
1170         }
1171
1172         RETURN_EDICT(sv.edicts);
1173 }
1174
1175 // LordHavoc: added this for searching float, int, and entity reference fields
1176 void PF_FindFloat (void)
1177 {
1178         int             e;
1179         int             f;
1180         float   s;
1181         edict_t *ed;
1182
1183         e = G_EDICTNUM(OFS_PARM0);
1184         f = G_INT(OFS_PARM1);
1185         s = G_FLOAT(OFS_PARM2);
1186
1187         for (e++ ; e < sv.num_edicts ; e++)
1188         {
1189                 pr_xfunction->builtinsprofile++;
1190                 ed = EDICT_NUM(e);
1191                 if (ed->e->free)
1192                         continue;
1193                 if (E_FLOAT(ed,f) == s)
1194                 {
1195                         RETURN_EDICT(ed);
1196                         return;
1197                 }
1198         }
1199
1200         RETURN_EDICT(sv.edicts);
1201 }
1202
1203 // chained search for strings in entity fields
1204 // entity(.string field, string match) findchain = #402;
1205 void PF_findchain (void)
1206 {
1207         int             i;
1208         int             f;
1209         char    *s, *t;
1210         edict_t *ent, *chain;
1211
1212         chain = (edict_t *)sv.edicts;
1213
1214         f = G_INT(OFS_PARM0);
1215         s = G_STRING(OFS_PARM1);
1216         if (!s || !s[0])
1217         {
1218                 RETURN_EDICT(sv.edicts);
1219                 return;
1220         }
1221
1222         ent = NEXT_EDICT(sv.edicts);
1223         for (i = 1;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
1224         {
1225                 pr_xfunction->builtinsprofile++;
1226                 if (ent->e->free)
1227                         continue;
1228                 t = E_STRING(ent,f);
1229                 if (!t)
1230                         continue;
1231                 if (strcmp(t,s))
1232                         continue;
1233
1234                 ent->v->chain = EDICT_TO_PROG(chain);
1235                 chain = ent;
1236         }
1237
1238         RETURN_EDICT(chain);
1239 }
1240
1241 // LordHavoc: chained search for float, int, and entity reference fields
1242 // entity(.string field, float match) findchainfloat = #403;
1243 void PF_findchainfloat (void)
1244 {
1245         int             i;
1246         int             f;
1247         float   s;
1248         edict_t *ent, *chain;
1249
1250         chain = (edict_t *)sv.edicts;
1251
1252         f = G_INT(OFS_PARM0);
1253         s = G_FLOAT(OFS_PARM1);
1254
1255         ent = NEXT_EDICT(sv.edicts);
1256         for (i = 1;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
1257         {
1258                 pr_xfunction->builtinsprofile++;
1259                 if (ent->e->free)
1260                         continue;
1261                 if (E_FLOAT(ent,f) != s)
1262                         continue;
1263
1264                 ent->v->chain = EDICT_TO_PROG(chain);
1265                 chain = ent;
1266         }
1267
1268         RETURN_EDICT(chain);
1269 }
1270
1271 void PR_CheckEmptyString (char *s)
1272 {
1273         if (s[0] <= ' ')
1274                 Host_Error ("Bad string");
1275 }
1276
1277 void PF_precache_file (void)
1278 {       // precache_file is only used to copy files with qcc, it does nothing
1279         G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
1280 }
1281
1282 void PF_precache_sound (void)
1283 {
1284         char    *s;
1285         int             i;
1286
1287         if (sv.state != ss_loading)
1288                 Host_Error ("PF_Precache_*: Precache can only be done in spawn functions");
1289
1290         s = G_STRING(OFS_PARM0);
1291         G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
1292         PR_CheckEmptyString (s);
1293
1294         for (i=0 ; i<MAX_SOUNDS ; i++)
1295         {
1296                 if (!sv.sound_precache[i])
1297                 {
1298                         sv.sound_precache[i] = s;
1299                         return;
1300                 }
1301                 if (!strcmp(sv.sound_precache[i], s))
1302                         return;
1303         }
1304         Host_Error ("PF_precache_sound: overflow");
1305 }
1306
1307 void PF_precache_model (void)
1308 {
1309         char    *s;
1310         int             i;
1311
1312         if (sv.state != ss_loading)
1313                 Host_Error ("PF_Precache_*: Precache can only be done in spawn functions");
1314
1315         s = G_STRING(OFS_PARM0);
1316         if (sv.worldmodel->brushq1.ishlbsp && ((!s) || (!s[0])))
1317                 return;
1318         G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
1319         PR_CheckEmptyString (s);
1320
1321         for (i=0 ; i<MAX_MODELS ; i++)
1322         {
1323                 if (!sv.model_precache[i])
1324                 {
1325                         sv.model_precache[i] = s;
1326                         sv.models[i] = Mod_ForName (s, true, false, false);
1327                         return;
1328                 }
1329                 if (!strcmp(sv.model_precache[i], s))
1330                         return;
1331         }
1332         Host_Error ("PF_precache_model: overflow");
1333 }
1334
1335
1336 void PF_coredump (void)
1337 {
1338         ED_PrintEdicts ();
1339 }
1340
1341 void PF_traceon (void)
1342 {
1343         pr_trace = true;
1344 }
1345
1346 void PF_traceoff (void)
1347 {
1348         pr_trace = false;
1349 }
1350
1351 void PF_eprint (void)
1352 {
1353         ED_PrintNum (G_EDICTNUM(OFS_PARM0));
1354 }
1355
1356 /*
1357 ===============
1358 PF_walkmove
1359
1360 float(float yaw, float dist) walkmove
1361 ===============
1362 */
1363 void PF_walkmove (void)
1364 {
1365         edict_t *ent;
1366         float   yaw, dist;
1367         vec3_t  move;
1368         mfunction_t     *oldf;
1369         int     oldself;
1370
1371         ent = PROG_TO_EDICT(pr_global_struct->self);
1372         yaw = G_FLOAT(OFS_PARM0);
1373         dist = G_FLOAT(OFS_PARM1);
1374
1375         if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
1376         {
1377                 G_FLOAT(OFS_RETURN) = 0;
1378                 return;
1379         }
1380
1381         yaw = yaw*M_PI*2 / 360;
1382
1383         move[0] = cos(yaw)*dist;
1384         move[1] = sin(yaw)*dist;
1385         move[2] = 0;
1386
1387 // save program state, because SV_movestep may call other progs
1388         oldf = pr_xfunction;
1389         oldself = pr_global_struct->self;
1390
1391         G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true);
1392
1393
1394 // restore program state
1395         pr_xfunction = oldf;
1396         pr_global_struct->self = oldself;
1397 }
1398
1399 /*
1400 ===============
1401 PF_droptofloor
1402
1403 void() droptofloor
1404 ===============
1405 */
1406 void PF_droptofloor (void)
1407 {
1408         edict_t         *ent;
1409         vec3_t          end;
1410         trace_t         trace;
1411
1412         ent = PROG_TO_EDICT(pr_global_struct->self);
1413
1414         VectorCopy (ent->v->origin, end);
1415         end[2] -= 256;
1416
1417         trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
1418
1419         if (trace.fraction == 1)
1420                 G_FLOAT(OFS_RETURN) = 0;
1421         else
1422         {
1423                 VectorCopy (trace.endpos, ent->v->origin);
1424                 SV_LinkEdict (ent, false);
1425                 ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
1426                 ent->v->groundentity = EDICT_TO_PROG(trace.ent);
1427                 G_FLOAT(OFS_RETURN) = 1;
1428                 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
1429                 ent->e->suspendedinairflag = true;
1430         }
1431 }
1432
1433 /*
1434 ===============
1435 PF_lightstyle
1436
1437 void(float style, string value) lightstyle
1438 ===============
1439 */
1440 void PF_lightstyle (void)
1441 {
1442         int             style;
1443         char    *val;
1444         client_t        *client;
1445         int                     j;
1446
1447         style = G_FLOAT(OFS_PARM0);
1448         val = G_STRING(OFS_PARM1);
1449
1450 // change the string in sv
1451         sv.lightstyles[style] = val;
1452
1453 // send message to all clients on this server
1454         if (sv.state != ss_active)
1455                 return;
1456
1457         for (j=0, client = svs.clients ; j<svs.maxclients ; j++, client++)
1458                 if (client->active || client->spawned)
1459                 {
1460                         MSG_WriteChar (&client->message, svc_lightstyle);
1461                         MSG_WriteChar (&client->message,style);
1462                         MSG_WriteString (&client->message, val);
1463                 }
1464 }
1465
1466 void PF_rint (void)
1467 {
1468         float   f;
1469         f = G_FLOAT(OFS_PARM0);
1470         if (f > 0)
1471                 G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
1472         else
1473                 G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
1474 }
1475 void PF_floor (void)
1476 {
1477         G_FLOAT(OFS_RETURN) = floor(G_FLOAT(OFS_PARM0));
1478 }
1479 void PF_ceil (void)
1480 {
1481         G_FLOAT(OFS_RETURN) = ceil(G_FLOAT(OFS_PARM0));
1482 }
1483
1484
1485 /*
1486 =============
1487 PF_checkbottom
1488 =============
1489 */
1490 void PF_checkbottom (void)
1491 {
1492         G_FLOAT(OFS_RETURN) = SV_CheckBottom (G_EDICT(OFS_PARM0));
1493 }
1494
1495 /*
1496 =============
1497 PF_pointcontents
1498 =============
1499 */
1500 void PF_pointcontents (void)
1501 {
1502         G_FLOAT(OFS_RETURN) = SV_PointContents(G_VECTOR(OFS_PARM0));
1503 }
1504
1505 /*
1506 =============
1507 PF_nextent
1508
1509 entity nextent(entity)
1510 =============
1511 */
1512 void PF_nextent (void)
1513 {
1514         int             i;
1515         edict_t *ent;
1516
1517         i = G_EDICTNUM(OFS_PARM0);
1518         while (1)
1519         {
1520                 pr_xfunction->builtinsprofile++;
1521                 i++;
1522                 if (i == sv.num_edicts)
1523                 {
1524                         RETURN_EDICT(sv.edicts);
1525                         return;
1526                 }
1527                 ent = EDICT_NUM(i);
1528                 if (!ent->e->free)
1529                 {
1530                         RETURN_EDICT(ent);
1531                         return;
1532                 }
1533         }
1534 }
1535
1536 /*
1537 =============
1538 PF_aim
1539
1540 Pick a vector for the player to shoot along
1541 vector aim(entity, missilespeed)
1542 =============
1543 */
1544 void PF_aim (void)
1545 {
1546         edict_t *ent, *check, *bestent;
1547         vec3_t  start, dir, end, bestdir;
1548         int             i, j;
1549         trace_t tr;
1550         float   dist, bestdist;
1551         float   speed;
1552
1553         ent = G_EDICT(OFS_PARM0);
1554         speed = G_FLOAT(OFS_PARM1);
1555
1556         VectorCopy (ent->v->origin, start);
1557         start[2] += 20;
1558
1559 // try sending a trace straight
1560         VectorCopy (pr_global_struct->v_forward, dir);
1561         VectorMA (start, 2048, dir, end);
1562         tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent);
1563         if (tr.ent && ((edict_t *)tr.ent)->v->takedamage == DAMAGE_AIM
1564         && (!teamplay.integer || ent->v->team <=0 || ent->v->team != ((edict_t *)tr.ent)->v->team) )
1565         {
1566                 VectorCopy (pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
1567                 return;
1568         }
1569
1570
1571 // try all possible entities
1572         VectorCopy (dir, bestdir);
1573         bestdist = sv_aim.value;
1574         bestent = NULL;
1575
1576         check = NEXT_EDICT(sv.edicts);
1577         for (i=1 ; i<sv.num_edicts ; i++, check = NEXT_EDICT(check) )
1578         {
1579                 pr_xfunction->builtinsprofile++;
1580                 if (check->v->takedamage != DAMAGE_AIM)
1581                         continue;
1582                 if (check == ent)
1583                         continue;
1584                 if (teamplay.integer && ent->v->team > 0 && ent->v->team == check->v->team)
1585                         continue;       // don't aim at teammate
1586                 for (j=0 ; j<3 ; j++)
1587                         end[j] = check->v->origin[j]
1588                         + 0.5*(check->v->mins[j] + check->v->maxs[j]);
1589                 VectorSubtract (end, start, dir);
1590                 VectorNormalize (dir);
1591                 dist = DotProduct (dir, pr_global_struct->v_forward);
1592                 if (dist < bestdist)
1593                         continue;       // to far to turn
1594                 tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent);
1595                 if (tr.ent == check)
1596                 {       // can shoot at this one
1597                         bestdist = dist;
1598                         bestent = check;
1599                 }
1600         }
1601
1602         if (bestent)
1603         {
1604                 VectorSubtract (bestent->v->origin, ent->v->origin, dir);
1605                 dist = DotProduct (dir, pr_global_struct->v_forward);
1606                 VectorScale (pr_global_struct->v_forward, dist, end);
1607                 end[2] = dir[2];
1608                 VectorNormalize (end);
1609                 VectorCopy (end, G_VECTOR(OFS_RETURN));
1610         }
1611         else
1612         {
1613                 VectorCopy (bestdir, G_VECTOR(OFS_RETURN));
1614         }
1615 }
1616
1617 /*
1618 ==============
1619 PF_changeyaw
1620
1621 This was a major timewaster in progs, so it was converted to C
1622 ==============
1623 */
1624 void PF_changeyaw (void)
1625 {
1626         edict_t         *ent;
1627         float           ideal, current, move, speed;
1628
1629         ent = PROG_TO_EDICT(pr_global_struct->self);
1630         current = ANGLEMOD(ent->v->angles[1]);
1631         ideal = ent->v->ideal_yaw;
1632         speed = ent->v->yaw_speed;
1633
1634         if (current == ideal)
1635                 return;
1636         move = ideal - current;
1637         if (ideal > current)
1638         {
1639                 if (move >= 180)
1640                         move = move - 360;
1641         }
1642         else
1643         {
1644                 if (move <= -180)
1645                         move = move + 360;
1646         }
1647         if (move > 0)
1648         {
1649                 if (move > speed)
1650                         move = speed;
1651         }
1652         else
1653         {
1654                 if (move < -speed)
1655                         move = -speed;
1656         }
1657
1658         ent->v->angles[1] = ANGLEMOD (current + move);
1659 }
1660
1661 /*
1662 ==============
1663 PF_changepitch
1664 ==============
1665 */
1666 void PF_changepitch (void)
1667 {
1668         edict_t         *ent;
1669         float           ideal, current, move, speed;
1670         eval_t          *val;
1671
1672         ent = G_EDICT(OFS_PARM0);
1673         current = ANGLEMOD( ent->v->angles[0] );
1674         if ((val = GETEDICTFIELDVALUE(ent, eval_idealpitch)))
1675                 ideal = val->_float;
1676         else
1677         {
1678                 Host_Error ("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch");
1679                 return;
1680         }
1681         if ((val = GETEDICTFIELDVALUE(ent, eval_pitch_speed)))
1682                 speed = val->_float;
1683         else
1684         {
1685                 Host_Error ("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch");
1686                 return;
1687         }
1688
1689         if (current == ideal)
1690                 return;
1691         move = ideal - current;
1692         if (ideal > current)
1693         {
1694                 if (move >= 180)
1695                         move = move - 360;
1696         }
1697         else
1698         {
1699                 if (move <= -180)
1700                         move = move + 360;
1701         }
1702         if (move > 0)
1703         {
1704                 if (move > speed)
1705                         move = speed;
1706         }
1707         else
1708         {
1709                 if (move < -speed)
1710                         move = -speed;
1711         }
1712
1713         ent->v->angles[0] = ANGLEMOD (current + move);
1714 }
1715
1716 /*
1717 ===============================================================================
1718
1719 MESSAGE WRITING
1720
1721 ===============================================================================
1722 */
1723
1724 #define MSG_BROADCAST   0               // unreliable to all
1725 #define MSG_ONE                 1               // reliable to one (msg_entity)
1726 #define MSG_ALL                 2               // reliable to all
1727 #define MSG_INIT                3               // write to the init string
1728
1729 sizebuf_t *WriteDest (void)
1730 {
1731         int             entnum;
1732         int             dest;
1733         edict_t *ent;
1734
1735         dest = G_FLOAT(OFS_PARM0);
1736         switch (dest)
1737         {
1738         case MSG_BROADCAST:
1739                 return &sv.datagram;
1740
1741         case MSG_ONE:
1742                 ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
1743                 entnum = NUM_FOR_EDICT(ent);
1744                 if (entnum < 1 || entnum > svs.maxclients)
1745                         Host_Error ("WriteDest: not a client");
1746                 return &svs.clients[entnum-1].message;
1747
1748         case MSG_ALL:
1749                 return &sv.reliable_datagram;
1750
1751         case MSG_INIT:
1752                 return &sv.signon;
1753
1754         default:
1755                 Host_Error ("WriteDest: bad destination");
1756                 break;
1757         }
1758
1759         return NULL;
1760 }
1761
1762 void PF_WriteByte (void)
1763 {
1764         MSG_WriteByte (WriteDest(), G_FLOAT(OFS_PARM1));
1765 }
1766
1767 void PF_WriteChar (void)
1768 {
1769         MSG_WriteChar (WriteDest(), G_FLOAT(OFS_PARM1));
1770 }
1771
1772 void PF_WriteShort (void)
1773 {
1774         MSG_WriteShort (WriteDest(), G_FLOAT(OFS_PARM1));
1775 }
1776
1777 void PF_WriteLong (void)
1778 {
1779         MSG_WriteLong (WriteDest(), G_FLOAT(OFS_PARM1));
1780 }
1781
1782 void PF_WriteAngle (void)
1783 {
1784         MSG_WriteAngle (WriteDest(), G_FLOAT(OFS_PARM1));
1785 }
1786
1787 void PF_WriteCoord (void)
1788 {
1789         MSG_WriteDPCoord (WriteDest(), G_FLOAT(OFS_PARM1));
1790 }
1791
1792 void PF_WriteString (void)
1793 {
1794         MSG_WriteString (WriteDest(), G_STRING(OFS_PARM1));
1795 }
1796
1797
1798 void PF_WriteEntity (void)
1799 {
1800         MSG_WriteShort (WriteDest(), G_EDICTNUM(OFS_PARM1));
1801 }
1802
1803 //=============================================================================
1804
1805 void PF_makestatic (void)
1806 {
1807         edict_t *ent;
1808         int i, large;
1809
1810         ent = G_EDICT(OFS_PARM0);
1811
1812         large = false;
1813         if (ent->v->modelindex >= 256 || ent->v->frame >= 256)
1814                 large = true;
1815
1816         if (large)
1817         {
1818                 MSG_WriteByte (&sv.signon,svc_spawnstatic2);
1819                 MSG_WriteShort (&sv.signon, ent->v->modelindex);
1820                 MSG_WriteShort (&sv.signon, ent->v->frame);
1821         }
1822         else
1823         {
1824                 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1825                 MSG_WriteByte (&sv.signon, ent->v->modelindex);
1826                 MSG_WriteByte (&sv.signon, ent->v->frame);
1827         }
1828
1829         MSG_WriteByte (&sv.signon, ent->v->colormap);
1830         MSG_WriteByte (&sv.signon, ent->v->skin);
1831         for (i=0 ; i<3 ; i++)
1832         {
1833                 MSG_WriteDPCoord(&sv.signon, ent->v->origin[i]);
1834                 MSG_WriteAngle(&sv.signon, ent->v->angles[i]);
1835         }
1836
1837 // throw the entity away now
1838         ED_Free (ent);
1839 }
1840
1841 //=============================================================================
1842
1843 /*
1844 ==============
1845 PF_setspawnparms
1846 ==============
1847 */
1848 void PF_setspawnparms (void)
1849 {
1850         edict_t *ent;
1851         int             i;
1852         client_t        *client;
1853
1854         ent = G_EDICT(OFS_PARM0);
1855         i = NUM_FOR_EDICT(ent);
1856         if (i < 1 || i > svs.maxclients)
1857                 Host_Error ("Entity is not a client");
1858
1859         // copy spawn parms out of the client_t
1860         client = svs.clients + (i-1);
1861
1862         for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1863                 (&pr_global_struct->parm1)[i] = client->spawn_parms[i];
1864 }
1865
1866 /*
1867 ==============
1868 PF_changelevel
1869 ==============
1870 */
1871 void PF_changelevel (void)
1872 {
1873         char    *s;
1874
1875 // make sure we don't issue two changelevels
1876         if (svs.changelevel_issued)
1877                 return;
1878         svs.changelevel_issued = true;
1879
1880         s = G_STRING(OFS_PARM0);
1881         Cbuf_AddText (va("changelevel %s\n",s));
1882 }
1883
1884 void PF_sin (void)
1885 {
1886         G_FLOAT(OFS_RETURN) = sin(G_FLOAT(OFS_PARM0));
1887 }
1888
1889 void PF_cos (void)
1890 {
1891         G_FLOAT(OFS_RETURN) = cos(G_FLOAT(OFS_PARM0));
1892 }
1893
1894 void PF_sqrt (void)
1895 {
1896         G_FLOAT(OFS_RETURN) = sqrt(G_FLOAT(OFS_PARM0));
1897 }
1898
1899 /*
1900 =================
1901 PF_RandomVec
1902
1903 Returns a vector of length < 1
1904
1905 randomvec()
1906 =================
1907 */
1908 void PF_randomvec (void)
1909 {
1910         vec3_t          temp;
1911         do
1912         {
1913                 temp[0] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1914                 temp[1] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1915                 temp[2] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1916         }
1917         while (DotProduct(temp, temp) >= 1);
1918         VectorCopy (temp, G_VECTOR(OFS_RETURN));
1919 }
1920
1921 void SV_LightPoint (vec3_t color, vec3_t p);
1922 /*
1923 =================
1924 PF_GetLight
1925
1926 Returns a color vector indicating the lighting at the requested point.
1927
1928 (Internal Operation note: actually measures the light beneath the point, just like
1929                           the model lighting on the client)
1930
1931 getlight(vector)
1932 =================
1933 */
1934 void PF_GetLight (void)
1935 {
1936         vec3_t          color;
1937         vec_t*          p;
1938         p = G_VECTOR(OFS_PARM0);
1939         SV_LightPoint (color, p);
1940         VectorCopy (color, G_VECTOR(OFS_RETURN));
1941 }
1942
1943 #define MAX_QC_CVARS 128
1944 cvar_t qc_cvar[MAX_QC_CVARS];
1945 int currentqc_cvar;
1946
1947 void PF_registercvar (void)
1948 {
1949         char *name, *value;
1950         cvar_t *variable;
1951         name = G_STRING(OFS_PARM0);
1952         value = G_STRING(OFS_PARM1);
1953         G_FLOAT(OFS_RETURN) = 0;
1954 // first check to see if it has already been defined
1955         if (Cvar_FindVar (name))
1956                 return;
1957
1958 // check for overlap with a command
1959         if (Cmd_Exists (name))
1960         {
1961                 Con_Printf ("PF_registercvar: %s is a command\n", name);
1962                 return;
1963         }
1964
1965         if (currentqc_cvar >= MAX_QC_CVARS)
1966                 Host_Error ("PF_registercvar: ran out of cvar slots (%i)\n", MAX_QC_CVARS);
1967
1968 // copy the name and value
1969         variable = &qc_cvar[currentqc_cvar++];
1970         variable->name = Z_Malloc (strlen(name)+1);
1971         strcpy (variable->name, name);
1972         variable->string = Z_Malloc (strlen(value)+1);
1973         strcpy (variable->string, value);
1974         variable->value = atof (value);
1975
1976         Cvar_RegisterVariable(variable);
1977         G_FLOAT(OFS_RETURN) = 1; // success
1978 }
1979
1980 /*
1981 =================
1982 PF_min
1983
1984 returns the minimum of two supplied floats
1985
1986 min(a, b)
1987 =================
1988 */
1989 void PF_min (void)
1990 {
1991         // LordHavoc: 3+ argument enhancement suggested by FrikaC
1992         if (pr_argc == 2)
1993                 G_FLOAT(OFS_RETURN) = min(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
1994         else if (pr_argc >= 3)
1995         {
1996                 int i;
1997                 float f = G_FLOAT(OFS_PARM0);
1998                 for (i = 1;i < pr_argc;i++)
1999                         if (G_FLOAT((OFS_PARM0+i*3)) < f)
2000                                 f = G_FLOAT((OFS_PARM0+i*3));
2001                 G_FLOAT(OFS_RETURN) = f;
2002         }
2003         else
2004                 Host_Error("min: must supply at least 2 floats\n");
2005 }
2006
2007 /*
2008 =================
2009 PF_max
2010
2011 returns the maximum of two supplied floats
2012
2013 max(a, b)
2014 =================
2015 */
2016 void PF_max (void)
2017 {
2018         // LordHavoc: 3+ argument enhancement suggested by FrikaC
2019         if (pr_argc == 2)
2020                 G_FLOAT(OFS_RETURN) = max(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
2021         else if (pr_argc >= 3)
2022         {
2023                 int i;
2024                 float f = G_FLOAT(OFS_PARM0);
2025                 for (i = 1;i < pr_argc;i++)
2026                         if (G_FLOAT((OFS_PARM0+i*3)) > f)
2027                                 f = G_FLOAT((OFS_PARM0+i*3));
2028                 G_FLOAT(OFS_RETURN) = f;
2029         }
2030         else
2031                 Host_Error("max: must supply at least 2 floats\n");
2032 }
2033
2034 /*
2035 =================
2036 PF_bound
2037
2038 returns number bounded by supplied range
2039
2040 min(min, value, max)
2041 =================
2042 */
2043 void PF_bound (void)
2044 {
2045         G_FLOAT(OFS_RETURN) = bound(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1), G_FLOAT(OFS_PARM2));
2046 }
2047
2048 /*
2049 =================
2050 PF_pow
2051
2052 returns a raised to power b
2053
2054 pow(a, b)
2055 =================
2056 */
2057 void PF_pow (void)
2058 {
2059         G_FLOAT(OFS_RETURN) = pow(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
2060 }
2061
2062 /*
2063 =================
2064 PF_copyentity
2065
2066 copies data from one entity to another
2067
2068 copyentity(src, dst)
2069 =================
2070 */
2071 void PF_copyentity (void)
2072 {
2073         edict_t *in, *out;
2074         in = G_EDICT(OFS_PARM0);
2075         out = G_EDICT(OFS_PARM1);
2076         memcpy(out->v, in->v, progs->entityfields * 4);
2077 }
2078
2079 /*
2080 =================
2081 PF_setcolor
2082
2083 sets the color of a client and broadcasts the update to all connected clients
2084
2085 setcolor(clientent, value)
2086 =================
2087 */
2088 void PF_setcolor (void)
2089 {
2090         client_t *client;
2091         int entnum, i;
2092         eval_t *val;
2093
2094         entnum = G_EDICTNUM(OFS_PARM0);
2095         i = G_FLOAT(OFS_PARM1);
2096
2097         if (entnum < 1 || entnum > svs.maxclients)
2098         {
2099                 Con_Printf ("tried to setcolor a non-client\n");
2100                 return;
2101         }
2102
2103         client = &svs.clients[entnum-1];
2104         if ((val = GETEDICTFIELDVALUE(client->edict, eval_clientcolors)))
2105                 val->_float = i;
2106         client->colors = i;
2107         client->old_colors = i;
2108         client->edict->v->team = (i & 15) + 1;
2109
2110         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
2111         MSG_WriteByte (&sv.reliable_datagram, entnum - 1);
2112         MSG_WriteByte (&sv.reliable_datagram, i);
2113 }
2114
2115 /*
2116 =================
2117 PF_effect
2118
2119 effect(origin, modelname, startframe, framecount, framerate)
2120 =================
2121 */
2122 void PF_effect (void)
2123 {
2124         char *s;
2125         s = G_STRING(OFS_PARM1);
2126         if (!s || !s[0])
2127                 Host_Error("effect: no model specified\n");
2128
2129         SV_StartEffect(G_VECTOR(OFS_PARM0), SV_ModelIndex(s), G_FLOAT(OFS_PARM2), G_FLOAT(OFS_PARM3), G_FLOAT(OFS_PARM4));
2130 }
2131
2132 void PF_te_blood (void)
2133 {
2134         if (G_FLOAT(OFS_PARM2) < 1)
2135                 return;
2136         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2137         MSG_WriteByte(&sv.datagram, TE_BLOOD);
2138         // origin
2139         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2140         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2141         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2142         // velocity
2143         MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[0], 127));
2144         MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[1], 127));
2145         MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[2], 127));
2146         // count
2147         MSG_WriteByte(&sv.datagram, bound(0, (int) G_FLOAT(OFS_PARM2), 255));
2148 }
2149
2150 void PF_te_bloodshower (void)
2151 {
2152         if (G_FLOAT(OFS_PARM3) < 1)
2153                 return;
2154         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2155         MSG_WriteByte(&sv.datagram, TE_BLOODSHOWER);
2156         // min
2157         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2158         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2159         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2160         // max
2161         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2162         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2163         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2164         // speed
2165         MSG_WriteDPCoord(&sv.datagram, G_FLOAT(OFS_PARM2));
2166         // count
2167         MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
2168 }
2169
2170 void PF_te_explosionrgb (void)
2171 {
2172         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2173         MSG_WriteByte(&sv.datagram, TE_EXPLOSIONRGB);
2174         // origin
2175         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2176         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2177         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2178         // color
2179         MSG_WriteByte(&sv.datagram, bound(0, (int) (G_VECTOR(OFS_PARM1)[0] * 255), 255));
2180         MSG_WriteByte(&sv.datagram, bound(0, (int) (G_VECTOR(OFS_PARM1)[1] * 255), 255));
2181         MSG_WriteByte(&sv.datagram, bound(0, (int) (G_VECTOR(OFS_PARM1)[2] * 255), 255));
2182 }
2183
2184 void PF_te_particlecube (void)
2185 {
2186         if (G_FLOAT(OFS_PARM3) < 1)
2187                 return;
2188         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2189         MSG_WriteByte(&sv.datagram, TE_PARTICLECUBE);
2190         // min
2191         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2192         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2193         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2194         // max
2195         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2196         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2197         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2198         // velocity
2199         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2200         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2201         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2202         // count
2203         MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
2204         // color
2205         MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM4));
2206         // gravity true/false
2207         MSG_WriteByte(&sv.datagram, ((int) G_FLOAT(OFS_PARM5)) != 0);
2208         // randomvel
2209         MSG_WriteDPCoord(&sv.datagram, G_FLOAT(OFS_PARM6));
2210 }
2211
2212 void PF_te_particlerain (void)
2213 {
2214         if (G_FLOAT(OFS_PARM3) < 1)
2215                 return;
2216         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2217         MSG_WriteByte(&sv.datagram, TE_PARTICLERAIN);
2218         // min
2219         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2220         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2221         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2222         // max
2223         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2224         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2225         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2226         // velocity
2227         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2228         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2229         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2230         // count
2231         MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
2232         // color
2233         MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM4));
2234 }
2235
2236 void PF_te_particlesnow (void)
2237 {
2238         if (G_FLOAT(OFS_PARM3) < 1)
2239                 return;
2240         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2241         MSG_WriteByte(&sv.datagram, TE_PARTICLESNOW);
2242         // min
2243         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2244         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2245         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2246         // max
2247         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2248         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2249         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2250         // velocity
2251         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2252         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2253         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2254         // count
2255         MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
2256         // color
2257         MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM4));
2258 }
2259
2260 void PF_te_spark (void)
2261 {
2262         if (G_FLOAT(OFS_PARM2) < 1)
2263                 return;
2264         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2265         MSG_WriteByte(&sv.datagram, TE_SPARK);
2266         // origin
2267         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2268         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2269         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2270         // velocity
2271         MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[0], 127));
2272         MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[1], 127));
2273         MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[2], 127));
2274         // count
2275         MSG_WriteByte(&sv.datagram, bound(0, (int) G_FLOAT(OFS_PARM2), 255));
2276 }
2277
2278 void PF_te_gunshotquad (void)
2279 {
2280         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2281         MSG_WriteByte(&sv.datagram, TE_GUNSHOTQUAD);
2282         // origin
2283         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2284         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2285         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2286 }
2287
2288 void PF_te_spikequad (void)
2289 {
2290         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2291         MSG_WriteByte(&sv.datagram, TE_SPIKEQUAD);
2292         // origin
2293         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2294         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2295         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2296 }
2297
2298 void PF_te_superspikequad (void)
2299 {
2300         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2301         MSG_WriteByte(&sv.datagram, TE_SUPERSPIKEQUAD);
2302         // origin
2303         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2304         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2305         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2306 }
2307
2308 void PF_te_explosionquad (void)
2309 {
2310         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2311         MSG_WriteByte(&sv.datagram, TE_EXPLOSIONQUAD);
2312         // origin
2313         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2314         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2315         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2316 }
2317
2318 void PF_te_smallflash (void)
2319 {
2320         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2321         MSG_WriteByte(&sv.datagram, TE_SMALLFLASH);
2322         // origin
2323         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2324         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2325         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2326 }
2327
2328 void PF_te_customflash (void)
2329 {
2330         if (G_FLOAT(OFS_PARM1) < 8 || G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
2331                 return;
2332         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2333         MSG_WriteByte(&sv.datagram, TE_CUSTOMFLASH);
2334         // origin
2335         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2336         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2337         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2338         // radius
2339         MSG_WriteByte(&sv.datagram, bound(0, G_FLOAT(OFS_PARM1) / 8 - 1, 255));
2340         // lifetime
2341         MSG_WriteByte(&sv.datagram, bound(0, G_FLOAT(OFS_PARM2) / 256 - 1, 255));
2342         // color
2343         MSG_WriteByte(&sv.datagram, bound(0, G_VECTOR(OFS_PARM3)[0] * 255, 255));
2344         MSG_WriteByte(&sv.datagram, bound(0, G_VECTOR(OFS_PARM3)[1] * 255, 255));
2345         MSG_WriteByte(&sv.datagram, bound(0, G_VECTOR(OFS_PARM3)[2] * 255, 255));
2346 }
2347
2348 void PF_te_gunshot (void)
2349 {
2350         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2351         MSG_WriteByte(&sv.datagram, TE_GUNSHOT);
2352         // origin
2353         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2354         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2355         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2356 }
2357
2358 void PF_te_spike (void)
2359 {
2360         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2361         MSG_WriteByte(&sv.datagram, TE_SPIKE);
2362         // origin
2363         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2364         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2365         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2366 }
2367
2368 void PF_te_superspike (void)
2369 {
2370         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2371         MSG_WriteByte(&sv.datagram, TE_SUPERSPIKE);
2372         // origin
2373         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2374         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2375         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2376 }
2377
2378 void PF_te_explosion (void)
2379 {
2380         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2381         MSG_WriteByte(&sv.datagram, TE_EXPLOSION);
2382         // origin
2383         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2384         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2385         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2386 }
2387
2388 void PF_te_tarexplosion (void)
2389 {
2390         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2391         MSG_WriteByte(&sv.datagram, TE_TAREXPLOSION);
2392         // origin
2393         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2394         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2395         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2396 }
2397
2398 void PF_te_wizspike (void)
2399 {
2400         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2401         MSG_WriteByte(&sv.datagram, TE_WIZSPIKE);
2402         // origin
2403         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2404         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2405         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2406 }
2407
2408 void PF_te_knightspike (void)
2409 {
2410         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2411         MSG_WriteByte(&sv.datagram, TE_KNIGHTSPIKE);
2412         // origin
2413         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2414         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2415         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2416 }
2417
2418 void PF_te_lavasplash (void)
2419 {
2420         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2421         MSG_WriteByte(&sv.datagram, TE_LAVASPLASH);
2422         // origin
2423         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2424         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2425         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2426 }
2427
2428 void PF_te_teleport (void)
2429 {
2430         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2431         MSG_WriteByte(&sv.datagram, TE_TELEPORT);
2432         // origin
2433         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2434         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2435         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2436 }
2437
2438 void PF_te_explosion2 (void)
2439 {
2440         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2441         MSG_WriteByte(&sv.datagram, TE_EXPLOSION2);
2442         // origin
2443         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2444         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2445         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2446         // color
2447         MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM1));
2448 }
2449
2450 void PF_te_lightning1 (void)
2451 {
2452         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2453         MSG_WriteByte(&sv.datagram, TE_LIGHTNING1);
2454         // owner entity
2455         MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
2456         // start
2457         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2458         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2459         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2460         // end
2461         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2462         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2463         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2464 }
2465
2466 void PF_te_lightning2 (void)
2467 {
2468         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2469         MSG_WriteByte(&sv.datagram, TE_LIGHTNING2);
2470         // owner entity
2471         MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
2472         // start
2473         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2474         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2475         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2476         // end
2477         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2478         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2479         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2480 }
2481
2482 void PF_te_lightning3 (void)
2483 {
2484         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2485         MSG_WriteByte(&sv.datagram, TE_LIGHTNING3);
2486         // owner entity
2487         MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
2488         // start
2489         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2490         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2491         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2492         // end
2493         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2494         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2495         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2496 }
2497
2498 void PF_te_beam (void)
2499 {
2500         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2501         MSG_WriteByte(&sv.datagram, TE_BEAM);
2502         // owner entity
2503         MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
2504         // start
2505         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0]);
2506         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1]);
2507         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2]);
2508         // end
2509         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0]);
2510         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1]);
2511         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2]);
2512 }
2513
2514 void PF_te_plasmaburn (void)
2515 {
2516         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2517         MSG_WriteByte(&sv.datagram, TE_PLASMABURN);
2518         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0]);
2519         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1]);
2520         MSG_WriteDPCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2]);
2521 }
2522
2523 static void clippointtosurface(msurface_t *surf, vec3_t p, vec3_t out)
2524 {
2525         int i, j;
2526         vec3_t v1, clipplanenormal, normal;
2527         vec_t clipplanedist, clipdist;
2528         VectorCopy(p, out);
2529         if (surf->flags & SURF_PLANEBACK)
2530                 VectorNegate(surf->plane->normal, normal);
2531         else
2532                 VectorCopy(surf->plane->normal, normal);
2533         for (i = 0, j = surf->poly_numverts - 1;i < surf->poly_numverts;j = i, i++)
2534         {
2535                 VectorSubtract(&surf->poly_verts[j * 3], &surf->poly_verts[i * 3], v1);
2536                 VectorNormalizeFast(v1);
2537                 CrossProduct(v1, normal, clipplanenormal);
2538                 clipplanedist = DotProduct(&surf->poly_verts[i * 3], clipplanenormal);
2539                 clipdist = DotProduct(out, clipplanenormal) - clipplanedist;
2540                 if (clipdist > 0)
2541                 {
2542                         clipdist = -clipdist;
2543                         VectorMA(out, clipdist, clipplanenormal, out);
2544                 }
2545         }
2546 }
2547
2548 static msurface_t *getsurface(edict_t *ed, int surfnum)
2549 {
2550         int modelindex;
2551         model_t *model;
2552         if (!ed || ed->e->free)
2553                 return NULL;
2554         modelindex = ed->v->modelindex;
2555         if (modelindex < 1 || modelindex >= MAX_MODELS)
2556                 return NULL;
2557         model = sv.models[modelindex];
2558         if (model->type != mod_brush)
2559                 return NULL;
2560         if (surfnum < 0 || surfnum >= model->brushq1.nummodelsurfaces)
2561                 return NULL;
2562         return model->brushq1.surfaces + surfnum + model->brushq1.firstmodelsurface;
2563 }
2564
2565
2566 //PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434;
2567 void PF_getsurfacenumpoints(void)
2568 {
2569         msurface_t *surf;
2570         // return 0 if no such surface
2571         if (!(surf = getsurface(G_EDICT(OFS_PARM0), G_FLOAT(OFS_PARM1))))
2572         {
2573                 G_FLOAT(OFS_RETURN) = 0;
2574                 return;
2575         }
2576
2577         G_FLOAT(OFS_RETURN) = surf->poly_numverts;
2578 }
2579 //PF_getsurfacepoint,     // #435 vector(entity e, float s, float n) getsurfacepoint = #435;
2580 void PF_getsurfacepoint(void)
2581 {
2582         edict_t *ed;
2583         msurface_t *surf;
2584         int pointnum;
2585         VectorClear(G_VECTOR(OFS_RETURN));
2586         ed = G_EDICT(OFS_PARM0);
2587         if (!ed || ed->e->free)
2588                 return;
2589         if (!(surf = getsurface(ed, G_FLOAT(OFS_PARM1))))
2590                 return;
2591         pointnum = G_FLOAT(OFS_PARM2);
2592         if (pointnum < 0 || pointnum >= surf->poly_numverts)
2593                 return;
2594         // FIXME: implement rotation/scaling
2595         VectorAdd(&surf->poly_verts[pointnum * 3], ed->v->origin, G_VECTOR(OFS_RETURN));
2596 }
2597 //PF_getsurfacenormal,    // #436 vector(entity e, float s) getsurfacenormal = #436;
2598 void PF_getsurfacenormal(void)
2599 {
2600         msurface_t *surf;
2601         VectorClear(G_VECTOR(OFS_RETURN));
2602         if (!(surf = getsurface(G_EDICT(OFS_PARM0), G_FLOAT(OFS_PARM1))))
2603                 return;
2604         // FIXME: implement rotation/scaling
2605         if (surf->flags & SURF_PLANEBACK)
2606                 VectorNegate(surf->plane->normal, G_VECTOR(OFS_RETURN));
2607         else
2608                 VectorCopy(surf->plane->normal, G_VECTOR(OFS_RETURN));
2609 }
2610 //PF_getsurfacetexture,   // #437 string(entity e, float s) getsurfacetexture = #437;
2611 void PF_getsurfacetexture(void)
2612 {
2613         msurface_t *surf;
2614         G_INT(OFS_RETURN) = 0;
2615         if (!(surf = getsurface(G_EDICT(OFS_PARM0), G_FLOAT(OFS_PARM1))))
2616                 return;
2617         G_INT(OFS_RETURN) = PR_SetString(surf->texinfo->texture->name);
2618 }
2619 //PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438;
2620 void PF_getsurfacenearpoint(void)
2621 {
2622         int surfnum, best, modelindex;
2623         vec3_t clipped, p;
2624         vec_t dist, bestdist;
2625         edict_t *ed;
2626         model_t *model;
2627         msurface_t *surf;
2628         vec_t *point;
2629         G_FLOAT(OFS_RETURN) = -1;
2630         ed = G_EDICT(OFS_PARM0);
2631         point = G_VECTOR(OFS_PARM1);
2632
2633         if (!ed || ed->e->free)
2634                 return;
2635         modelindex = ed->v->modelindex;
2636         if (modelindex < 1 || modelindex >= MAX_MODELS)
2637                 return;
2638         model = sv.models[modelindex];
2639         if (model->type != mod_brush)
2640                 return;
2641
2642         // FIXME: implement rotation/scaling
2643         VectorSubtract(point, ed->v->origin, p);
2644         best = -1;
2645         bestdist = 1000000000;
2646         for (surfnum = 0;surfnum < model->brushq1.nummodelsurfaces;surfnum++)
2647         {
2648                 surf = model->brushq1.surfaces + surfnum + model->brushq1.firstmodelsurface;
2649                 dist = PlaneDiff(p, surf->plane);
2650                 dist = dist * dist;
2651                 if (dist < bestdist)
2652                 {
2653                         clippointtosurface(surf, p, clipped);
2654                         VectorSubtract(clipped, p, clipped);
2655                         dist += DotProduct(clipped, clipped);
2656                         if (dist < bestdist)
2657                         {
2658                                 best = surfnum;
2659                                 bestdist = dist;
2660                         }
2661                 }
2662         }
2663         G_FLOAT(OFS_RETURN) = best;
2664 }
2665 //PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439;
2666 void PF_getsurfaceclippedpoint(void)
2667 {
2668         edict_t *ed;
2669         msurface_t *surf;
2670         vec3_t p, out;
2671         VectorClear(G_VECTOR(OFS_RETURN));
2672         ed = G_EDICT(OFS_PARM0);
2673         if (!ed || ed->e->free)
2674                 return;
2675         if (!(surf = getsurface(ed, G_FLOAT(OFS_PARM1))))
2676                 return;
2677         // FIXME: implement rotation/scaling
2678         VectorSubtract(G_VECTOR(OFS_PARM2), ed->v->origin, p);
2679         clippointtosurface(surf, p, out);
2680         // FIXME: implement rotation/scaling
2681         VectorAdd(out, ed->v->origin, G_VECTOR(OFS_RETURN));
2682 }
2683
2684 #define MAX_PRFILES 256
2685
2686 qfile_t *pr_files[MAX_PRFILES];
2687
2688 void PR_Files_Init(void)
2689 {
2690         memset(pr_files, 0, sizeof(pr_files));
2691 }
2692
2693 void PR_Files_CloseAll(void)
2694 {
2695         int i;
2696         for (i = 0;i < MAX_PRFILES;i++)
2697         {
2698                 if (pr_files[i])
2699                         FS_Close(pr_files[i]);
2700                 pr_files[i] = NULL;
2701         }
2702 }
2703
2704 //float(string s) stof = #81; // get numerical value from a string
2705 void PF_stof(void)
2706 {
2707         char *s = PF_VarString(0);
2708         G_FLOAT(OFS_RETURN) = atof(s);
2709 }
2710
2711 //float(string filename, float mode) fopen = #110; // opens a file inside quake/gamedir/data/ (mode is FILE_READ, FILE_APPEND, or FILE_WRITE), returns fhandle >= 0 if successful, or fhandle < 0 if unable to open file for any reason
2712 void PF_fopen(void)
2713 {
2714         int filenum, mode;
2715         char *modestring, *filename;
2716         for (filenum = 0;filenum < MAX_PRFILES;filenum++)
2717                 if (pr_files[filenum] == NULL)
2718                         break;
2719         if (filenum >= MAX_PRFILES)
2720         {
2721                 Con_Printf("PF_fopen: ran out of file handles (%i)\n", MAX_PRFILES);
2722                 G_FLOAT(OFS_RETURN) = -2;
2723                 return;
2724         }
2725         mode = G_FLOAT(OFS_PARM1);
2726         switch(mode)
2727         {
2728         case 0: // FILE_READ
2729                 modestring = "rb";
2730                 break;
2731         case 1: // FILE_APPEND
2732                 modestring = "ab";
2733                 break;
2734         case 2: // FILE_WRITE
2735                 modestring = "wb";
2736                 break;
2737         default:
2738                 Con_Printf("PF_fopen: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", mode);
2739                 G_FLOAT(OFS_RETURN) = -3;
2740                 return;
2741         }
2742         filename = G_STRING(OFS_PARM0);
2743         // .. is parent directory on many platforms
2744         // / is parent directory on Amiga
2745         // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea)
2746         // \ is a windows-ism (so it's naughty to use it, / works on all platforms)
2747         if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
2748         {
2749                 Con_Printf("PF_fopen: dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", filename);
2750                 G_FLOAT(OFS_RETURN) = -4;
2751                 return;
2752         }
2753         pr_files[filenum] = FS_Open(va("data/%s", filename), modestring, false);
2754         if (pr_files[filenum] == NULL)
2755                 G_FLOAT(OFS_RETURN) = -1;
2756         else
2757                 G_FLOAT(OFS_RETURN) = filenum;
2758 }
2759
2760 //void(float fhandle) fclose = #111; // closes a file
2761 void PF_fclose(void)
2762 {
2763         int filenum = G_FLOAT(OFS_PARM0);
2764         if (filenum < 0 || filenum >= MAX_PRFILES)
2765         {
2766                 Con_Printf("PF_fclose: invalid file handle %i\n", filenum);
2767                 return;
2768         }
2769         if (pr_files[filenum] == NULL)
2770         {
2771                 Con_Printf("PF_fclose: no such file handle %i (or file has been closed)\n", filenum);
2772                 return;
2773         }
2774         FS_Close(pr_files[filenum]);
2775         pr_files[filenum] = NULL;
2776 }
2777
2778 //string(float fhandle) fgets = #112; // reads a line of text from the file and returns as a tempstring
2779 void PF_fgets(void)
2780 {
2781         int c, end;
2782         static char string[MAX_VARSTRING];
2783         int filenum = G_FLOAT(OFS_PARM0);
2784         if (filenum < 0 || filenum >= MAX_PRFILES)
2785         {
2786                 Con_Printf("PF_fgets: invalid file handle %i\n", filenum);
2787                 return;
2788         }
2789         if (pr_files[filenum] == NULL)
2790         {
2791                 Con_Printf("PF_fgets: no such file handle %i (or file has been closed)\n", filenum);
2792                 return;
2793         }
2794         end = 0;
2795         for (;;)
2796         {
2797                 c = FS_Getc(pr_files[filenum]);
2798                 if (c == '\r' || c == '\n' || c < 0)
2799                         break;
2800                 if (end < MAX_VARSTRING - 1)
2801                         string[end++] = c;
2802         }
2803         string[end] = 0;
2804         // remove \n following \r
2805         if (c == '\r')
2806                 c = FS_Getc(pr_files[filenum]);
2807         if (developer.integer)
2808                 Con_Printf("fgets: %s\n", string);
2809         if (c >= 0)
2810                 G_INT(OFS_RETURN) = PR_SetString(string);
2811         else
2812                 G_INT(OFS_RETURN) = 0;
2813 }
2814
2815 //void(float fhandle, string s) fputs = #113; // writes a line of text to the end of the file
2816 void PF_fputs(void)
2817 {
2818         int stringlength;
2819         char *s = PF_VarString(1);
2820         int filenum = G_FLOAT(OFS_PARM0);
2821         if (filenum < 0 || filenum >= MAX_PRFILES)
2822         {
2823                 Con_Printf("PF_fputs: invalid file handle %i\n", filenum);
2824                 return;
2825         }
2826         if (pr_files[filenum] == NULL)
2827         {
2828                 Con_Printf("PF_fputs: no such file handle %i (or file has been closed)\n", filenum);
2829                 return;
2830         }
2831         if ((stringlength = strlen(s)))
2832                 FS_Write(pr_files[filenum], s, stringlength);
2833         if (developer.integer)
2834                 Con_Printf("fputs: %s\n", s);
2835 }
2836
2837 //float(string s) strlen = #114; // returns how many characters are in a string
2838 void PF_strlen(void)
2839 {
2840         char *s;
2841         s = G_STRING(OFS_PARM0);
2842         if (s)
2843                 G_FLOAT(OFS_RETURN) = strlen(s);
2844         else
2845                 G_FLOAT(OFS_RETURN) = 0;
2846 }
2847
2848 //string(string s1, string s2) strcat = #115; // concatenates two strings (for example "abc", "def" would return "abcdef") and returns as a tempstring
2849 void PF_strcat(void)
2850 {
2851         char *s = PF_VarString(0);
2852         G_INT(OFS_RETURN) = PR_SetString(s);
2853 }
2854
2855 //string(string s, float start, float length) substring = #116; // returns a section of a string as a tempstring
2856 void PF_substring(void)
2857 {
2858         int i, start, end;
2859         char *s, string[MAX_VARSTRING];
2860         s = G_STRING(OFS_PARM0);
2861         start = G_FLOAT(OFS_PARM1);
2862         end = G_FLOAT(OFS_PARM2) + start;
2863         if (!s)
2864                 s = "";
2865         for (i = 0;i < start && *s;i++, s++);
2866         for (i = 0;i < MAX_VARSTRING - 1 && *s && i < end;i++, s++)
2867                 string[i] = *s;
2868         string[i] = 0;
2869         G_INT(OFS_RETURN) = PR_SetString(string);
2870 }
2871
2872 //vector(string s) stov = #117; // returns vector value from a string
2873 void PF_stov(void)
2874 {
2875         Math_atov(PF_VarString(0), G_VECTOR(OFS_RETURN));
2876 }
2877
2878 //string(string s) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
2879 void PF_strzone(void)
2880 {
2881         char *in, *out;
2882         in = G_STRING(OFS_PARM0);
2883         out = Mem_Alloc(pr_strings_mempool, strlen(in) + 1);
2884         strcpy(out, in);
2885         G_INT(OFS_RETURN) = PR_SetString(out);
2886 }
2887
2888 //void(string s) strunzone = #119; // removes a copy of a string from the string zone (you can not use that string again or it may crash!!!)
2889 void PF_strunzone(void)
2890 {
2891         Mem_Free(G_STRING(OFS_PARM0));
2892 }
2893
2894 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2895 //this function originally written by KrimZon, made shorter by LordHavoc
2896 void PF_clientcommand (void)
2897 {
2898         client_t *temp_client;
2899         int i;
2900
2901         //find client for this entity
2902         i = (NUM_FOR_EDICT(G_EDICT(OFS_PARM0)) - 1);
2903         if (i < 0 || i >= svs.maxclients)
2904                 Host_Error("PF_clientcommand: entity is not a client");
2905
2906         temp_client = host_client;
2907         host_client = &svs.clients[i];
2908         Cmd_ExecuteString (G_STRING(OFS_PARM1), src_client);
2909         host_client = temp_client;
2910 }
2911
2912 //float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
2913 //this function originally written by KrimZon, made shorter by LordHavoc
2914 char **tokens = NULL;
2915 int    max_tokens, num_tokens = 0;
2916 void PF_tokenize (void)
2917 {
2918         const char *p;
2919         char *str;
2920         str = G_STRING(OFS_PARM0);
2921
2922         if (tokens != NULL)
2923         {
2924                 int i;
2925                 for (i=0;i<num_tokens;i++)
2926                         Z_Free(tokens[i]);
2927                 Z_Free(tokens);
2928                 num_tokens = 0;
2929         }
2930
2931         tokens = Z_Malloc(strlen(str) * sizeof(char *));
2932         max_tokens = strlen(str);
2933
2934         for (p = str;COM_ParseToken(&p, false) && num_tokens < max_tokens;num_tokens++)
2935         {
2936                 tokens[num_tokens] = Z_Malloc(strlen(com_token) + 1);
2937                 strcpy(tokens[num_tokens], com_token);
2938         }
2939
2940         G_FLOAT(OFS_RETURN) = num_tokens;
2941 }
2942
2943 //string(float n) argv = #442; // returns a word from the tokenized string (returns nothing for an invalid index)
2944 //this function originally written by KrimZon, made shorter by LordHavoc
2945 void PF_argv (void)
2946 {
2947         int token_num = G_FLOAT(OFS_PARM0);
2948         if (token_num >= 0 && token_num < num_tokens)
2949                 G_INT(OFS_RETURN) = PR_SetString(tokens[token_num]);
2950         else
2951                 G_INT(OFS_RETURN) = PR_SetString("");
2952 }
2953
2954 //void(entity e, entity tagentity, string tagname) setattachment = #443; // attachs e to a tag on tagentity (note: use "" to attach to entity origin/angles instead of a tag)
2955 void PF_setattachment (void)
2956 {
2957         edict_t *e = G_EDICT(OFS_PARM0);
2958         edict_t *tagentity = G_EDICT(OFS_PARM1);
2959         char *tagname = G_STRING(OFS_PARM2);
2960         eval_t *v;
2961         int i, modelindex;
2962         model_t *model;
2963
2964         if (tagentity == NULL)
2965                 tagentity = sv.edicts;
2966
2967         v = GETEDICTFIELDVALUE(e, eval_tag_entity);
2968         if (v)
2969                 v->edict = EDICT_TO_PROG(tagentity);
2970
2971         v = GETEDICTFIELDVALUE(e, eval_tag_index);
2972         if (v)
2973                 v->_float = 0;
2974         if (tagentity != NULL && tagentity != sv.edicts && tagname && tagname[0])
2975         {
2976                 modelindex = (int)tagentity->v->modelindex;
2977                 if (modelindex >= 0 && modelindex < MAX_MODELS)
2978                 {
2979                         model = sv.models[modelindex];
2980                         if (model->data_overridetagnamesforskin && (unsigned int)tagentity->v->skin < model->numskins && model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames)
2981                                 for (i = 0;i < model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames;i++)
2982                                         if (!strcmp(tagname, model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].data_overridetagnames[i].name))
2983                                                 v->_float = i + 1;
2984                         if (v->_float == 0 && model->alias.aliasnum_tags)
2985                                 for (i = 0;i < model->alias.aliasnum_tags;i++)
2986                                         if (!strcmp(tagname, model->alias.aliasdata_tags[i].name))
2987                                                 v->_float = i + 1;
2988                         if (v->_float == 0)
2989                                 Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity), model->name);
2990                 }
2991                 else
2992                         Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity));
2993         }
2994 }
2995
2996
2997 builtin_t pr_builtin[] =
2998 {
2999 NULL,                                           // #0
3000 PF_makevectors,                         // #1 void(entity e) makevectors
3001 PF_setorigin,                           // #2 void(entity e, vector o) setorigin
3002 PF_setmodel,                            // #3 void(entity e, string m) setmodel
3003 PF_setsize,                                     // #4 void(entity e, vector min, vector max) setsize
3004 NULL,                                           // #5 void(entity e, vector min, vector max) setabssize
3005 PF_break,                                       // #6 void() break
3006 PF_random,                                      // #7 float() random
3007 PF_sound,                                       // #8 void(entity e, float chan, string samp) sound
3008 PF_normalize,                           // #9 vector(vector v) normalize
3009 PF_error,                                       // #10 void(string e) error
3010 PF_objerror,                            // #11 void(string e) objerror
3011 PF_vlen,                                        // #12 float(vector v) vlen
3012 PF_vectoyaw,                            // #13 float(vector v) vectoyaw
3013 PF_Spawn,                                       // #14 entity() spawn
3014 PF_Remove,                                      // #15 void(entity e) remove
3015 PF_traceline,                           // #16 float(vector v1, vector v2, float tryents) traceline
3016 PF_checkclient,                         // #17 entity() clientlist
3017 PF_Find,                                        // #18 entity(entity start, .string fld, string match) find
3018 PF_precache_sound,                      // #19 void(string s) precache_sound
3019 PF_precache_model,                      // #20 void(string s) precache_model
3020 PF_stuffcmd,                            // #21 void(entity client, string s)stuffcmd
3021 PF_findradius,                          // #22 entity(vector org, float rad) findradius
3022 PF_bprint,                                      // #23 void(string s) bprint
3023 PF_sprint,                                      // #24 void(entity client, string s) sprint
3024 PF_dprint,                                      // #25 void(string s) dprint
3025 PF_ftos,                                        // #26 void(string s) ftos
3026 PF_vtos,                                        // #27 void(string s) vtos
3027 PF_coredump,                            // #28 void() coredump
3028 PF_traceon,                                     // #29 void() traceon
3029 PF_traceoff,                            // #30 void() traceoff
3030 PF_eprint,                                      // #31 void(entity e) eprint
3031 PF_walkmove,                            // #32 float(float yaw, float dist) walkmove
3032 NULL,                                           // #33
3033 PF_droptofloor,                         // #34 float() droptofloor
3034 PF_lightstyle,                          // #35 void(float style, string value) lightstyle
3035 PF_rint,                                        // #36 float(float v) rint
3036 PF_floor,                                       // #37 float(float v) floor
3037 PF_ceil,                                        // #38 float(float v) ceil
3038 NULL,                                           // #39
3039 PF_checkbottom,                         // #40 float(entity e) checkbottom
3040 PF_pointcontents                ,       // #41 float(vector v) pointcontents
3041 NULL,                                           // #42
3042 PF_fabs,                                        // #43 float(float f) fabs
3043 PF_aim,                                         // #44 vector(entity e, float speed) aim
3044 PF_cvar,                                        // #45 float(string s) cvar
3045 PF_localcmd,                            // #46 void(string s) localcmd
3046 PF_nextent,                                     // #47 entity(entity e) nextent
3047 PF_particle,                            // #48 void(vector o, vector d, float color, float count) particle
3048 PF_changeyaw,                           // #49 void() ChangeYaw
3049 NULL,                                           // #50
3050 PF_vectoangles,                         // #51 vector(vector v) vectoangles
3051 PF_WriteByte,                           // #52 void(float to, float f) WriteByte
3052 PF_WriteChar,                           // #53 void(float to, float f) WriteChar
3053 PF_WriteShort,                          // #54 void(float to, float f) WriteShort
3054 PF_WriteLong,                           // #55 void(float to, float f) WriteLong
3055 PF_WriteCoord,                          // #56 void(float to, float f) WriteCoord
3056 PF_WriteAngle,                          // #57 void(float to, float f) WriteAngle
3057 PF_WriteString,                         // #58 void(float to, string s) WriteString
3058 PF_WriteEntity,                         // #59 void(float to, entity e) WriteEntity
3059 PF_sin,                                         // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW)
3060 PF_cos,                                         // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW)
3061 PF_sqrt,                                        // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW)
3062 PF_changepitch,                         // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH)
3063 PF_TraceToss,                           // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS)
3064 PF_etos,                                        // #65 string(entity ent) etos (DP_QC_ETOS)
3065 NULL,                                           // #66
3066 SV_MoveToGoal,                          // #67 void(float step) movetogoal
3067 PF_precache_file,                       // #68 string(string s) precache_file
3068 PF_makestatic,                          // #69 void(entity e) makestatic
3069 PF_changelevel,                         // #70 void(string s) changelevel
3070 NULL,                                           // #71
3071 PF_cvar_set,                            // #72 void(string var, string val) cvar_set
3072 PF_centerprint,                         // #73 void(entity client, strings) centerprint
3073 PF_ambientsound,                        // #74 void(vector pos, string samp, float vol, float atten) ambientsound
3074 PF_precache_model,                      // #75 string(string s) precache_model2
3075 PF_precache_sound,                      // #76 string(string s) precache_sound2
3076 PF_precache_file,                       // #77 string(string s) precache_file2
3077 PF_setspawnparms,                       // #78 void(entity e) setspawnparms
3078 NULL,                                           // #79
3079 NULL,                                           // #80
3080 PF_stof,                                        // #81 float(string s) stof (FRIK_FILE)
3081 NULL,                                           // #82
3082 NULL,                                           // #83
3083 NULL,                                           // #84
3084 NULL,                                           // #85
3085 NULL,                                           // #86
3086 NULL,                                           // #87
3087 NULL,                                           // #88
3088 NULL,                                           // #89
3089 PF_tracebox,                            // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
3090 PF_randomvec,                           // #91 vector() randomvec (DP_QC_RANDOMVEC)
3091 PF_GetLight,                            // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
3092 PF_registercvar,                        // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
3093 PF_min,                                         // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
3094 PF_max,                                         // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
3095 PF_bound,                                       // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
3096 PF_pow,                                         // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
3097 PF_FindFloat,                           // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
3098 PF_checkextension,                      // #99 float(string s) checkextension (the basis of the extension system)
3099 NULL,                                           // #100
3100 NULL,                                           // #101
3101 NULL,                                           // #102
3102 NULL,                                           // #103
3103 NULL,                                           // #104
3104 NULL,                                           // #105
3105 NULL,                                           // #106
3106 NULL,                                           // #107
3107 NULL,                                           // #108
3108 NULL,                                           // #109
3109 PF_fopen,                                       // #110 float(string filename, float mode) fopen (FRIK_FILE)
3110 PF_fclose,                                      // #111 void(float fhandle) fclose (FRIK_FILE)
3111 PF_fgets,                                       // #112 string(float fhandle) fgets (FRIK_FILE)
3112 PF_fputs,                                       // #113 void(float fhandle, string s) fputs (FRIK_FILE)
3113 PF_strlen,                                      // #114 float(string s) strlen (FRIK_FILE)
3114 PF_strcat,                                      // #115 string(string s1, string s2) strcat (FRIK_FILE)
3115 PF_substring,                           // #116 string(string s, float start, float length) substring (FRIK_FILE)
3116 PF_stov,                                        // #117 vector(string) stov (FRIK_FILE)
3117 PF_strzone,                                     // #118 string(string s) strzone (FRIK_FILE)
3118 PF_strunzone,                           // #119 void(string s) strunzone (FRIK_FILE)
3119 #define a NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
3120 a a a a a a a a                         // #120-199
3121 a a a a a a a a a a                     // #200-299
3122 a a a a a a a a a a                     // #300-399
3123 PF_copyentity,                          // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
3124 PF_setcolor,                            // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
3125 PF_findchain,                           // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
3126 PF_findchainfloat,                      // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
3127 PF_effect,                                      // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
3128 PF_te_blood,                            // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
3129 PF_te_bloodshower,                      // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
3130 PF_te_explosionrgb,                     // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
3131 PF_te_particlecube,                     // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
3132 PF_te_particlerain,                     // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
3133 PF_te_particlesnow,                     // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
3134 PF_te_spark,                            // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
3135 PF_te_gunshotquad,                      // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
3136 PF_te_spikequad,                        // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
3137 PF_te_superspikequad,           // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
3138 PF_te_explosionquad,            // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
3139 PF_te_smallflash,                       // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
3140 PF_te_customflash,                      // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
3141 PF_te_gunshot,                          // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
3142 PF_te_spike,                            // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
3143 PF_te_superspike,                       // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
3144 PF_te_explosion,                        // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
3145 PF_te_tarexplosion,                     // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
3146 PF_te_wizspike,                         // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
3147 PF_te_knightspike,                      // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
3148 PF_te_lavasplash,                       // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
3149 PF_te_teleport,                         // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
3150 PF_te_explosion2,                       // #427 void(vector org, float color) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
3151 PF_te_lightning1,                       // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
3152 PF_te_lightning2,                       // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
3153 PF_te_lightning3,                       // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
3154 PF_te_beam,                                     // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
3155 PF_vectorvectors,                       // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
3156 PF_te_plasmaburn,                       // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
3157 PF_getsurfacenumpoints,         // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
3158 PF_getsurfacepoint,                     // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
3159 PF_getsurfacenormal,            // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
3160 PF_getsurfacetexture,           // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
3161 PF_getsurfacenearpoint,         // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
3162 PF_getsurfaceclippedpoint,      // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
3163 PF_clientcommand,                       // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
3164 PF_tokenize,                            // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
3165 PF_argv,                                        // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
3166 PF_setattachment,                       // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
3167 NULL,                                           // #444
3168 NULL,                                           // #445
3169 NULL,                                           // #446
3170 NULL,                                           // #447
3171 NULL,                                           // #448
3172 NULL,                                           // #449
3173 a a a a a                                       // #450-499 (LordHavoc)
3174 };
3175
3176 builtin_t *pr_builtins = pr_builtin;
3177 int pr_numbuiltins = sizeof(pr_builtin)/sizeof(pr_builtin[0]);
3178
3179 void PR_Cmd_Init(void)
3180 {
3181         pr_strings_mempool = Mem_AllocPool("pr_stringszone");
3182         PR_Files_Init();
3183 }
3184
3185 void PR_Cmd_Reset(void)
3186 {
3187         Mem_EmptyPool(pr_strings_mempool);
3188         PR_Files_CloseAll();
3189 }
3190