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