print ""gettagindex(entity #%i): tag \"%s\" not found" console spam only if developer...
[divverent/darkplaces.git] / svvm_cmds.c
1 #include "quakedef.h"
2
3 #include "prvm_cmds.h"
4
5 //============================================================================
6 // Server
7
8
9
10 char *vm_sv_extensions =
11 "BX_WAL_SUPPORT "
12 "DP_BUTTONCHAT "
13 "DP_BUTTONUSE "
14 "DP_CL_LOADSKY "
15 "DP_CON_ALIASPARAMETERS "
16 "DP_CON_EXPANDCVAR "
17 "DP_CON_SET "
18 "DP_CON_SETA "
19 "DP_CON_STARTMAP "
20 "DP_EF_ADDITIVE "
21 "DP_EF_BLUE "
22 "DP_EF_DOUBLESIDED "
23 "DP_EF_FLAME "
24 "DP_EF_FULLBRIGHT "
25 "DP_EF_NODEPTHTEST "
26 "DP_EF_NODRAW "
27 "DP_EF_NOSHADOW "
28 "DP_EF_NOGUNBOB "
29 "DP_EF_RED "
30 "DP_EF_STARDUST "
31 "DP_ENT_ALPHA "
32 "DP_ENT_COLORMOD "
33 "DP_ENT_CUSTOMCOLORMAP "
34 "DP_ENT_EXTERIORMODELTOCLIENT "
35 "DP_ENT_GLOW "
36 "DP_ENT_LOWPRECISION "
37 "DP_ENT_SCALE "
38 "DP_ENT_VIEWMODEL "
39 "DP_GFX_EXTERNALTEXTURES "
40 "DP_GFX_EXTERNALTEXTURES_PERMAP "
41 "DP_GFX_FOG "
42 "DP_GFX_QUAKE3MODELTAGS "
43 "DP_GFX_SKINFILES "
44 "DP_GFX_SKYBOX "
45 "DP_HALFLIFE_MAP "
46 "DP_HALFLIFE_MAP_CVAR "
47 "DP_HALFLIFE_SPRITE "
48 "DP_INPUTBUTTONS "
49 "DP_LITSPRITES "
50 "DP_LITSUPPORT "
51 "DP_MONSTERWALK "
52 "DP_MOVETYPEBOUNCEMISSILE "
53 "DP_MOVETYPEFOLLOW "
54 "DP_QC_ASINACOSATANATAN2TAN "
55 "DP_QC_CHANGEPITCH "
56 "DP_QC_COPYENTITY "
57 "DP_QC_CVAR_DEFSTRING "
58 "DP_QC_CVAR_STRING "
59 "DP_QC_ETOS "
60 "DP_QC_FINDCHAIN "
61 "DP_QC_FINDCHAINFLAGS "
62 "DP_QC_FINDCHAINFLOAT "
63 "DP_QC_FINDFLAGS "
64 "DP_QC_FINDFLOAT "
65 "DP_QC_FS_SEARCH "
66 "DP_QC_GETLIGHT "
67 "DP_QC_GETSURFACE "
68 "DP_QC_GETTAGINFO "
69 "DP_QC_MINMAXBOUND "
70 "DP_QC_MULTIPLETEMPSTRINGS "
71 "DP_QC_RANDOMVEC "
72 "DP_QC_SINCOSSQRTPOW "
73 "DP_QC_STRFTIME "
74 "DP_QC_STRING_CASE_FUNCTIONS "
75 "DP_QC_STRINGBUFFERS "
76 "DP_QC_STRINGCOLORFUNCTIONS "
77 "DP_QC_TOKENIZEBYSEPARATOR "
78 "DP_QC_TRACEBOX "
79 "DP_QC_TRACETOSS "
80 "DP_QC_TRACE_MOVETYPE_HITMODEL "
81 "DP_QC_TRACE_MOVETYPE_WORLDONLY "
82 "DP_QC_UNLIMITEDTEMPSTRINGS "
83 "DP_QC_VECTOANGLES_WITH_ROLL "
84 "DP_QC_VECTORVECTORS "
85 "DP_QUAKE2_MODEL "
86 "DP_QUAKE2_SPRITE "
87 "DP_QUAKE3_MAP "
88 "DP_QUAKE3_MODEL "
89 "DP_REGISTERCVAR "
90 "DP_SND_DIRECTIONLESSATTNNONE "
91 "DP_SND_FAKETRACKS "
92 "DP_SND_OGGVORBIS "
93 "DP_SND_STEREOWAV "
94 "DP_SOLIDCORPSE "
95 "DP_SPRITE32 "
96 "DP_SV_BOTCLIENT "
97 "DP_SV_CLIENTCOLORS "
98 "DP_SV_CLIENTNAME "
99 "DP_SV_CUSTOMIZEENTITYFORCLIENT "
100 "DP_SV_DRAWONLYTOCLIENT "
101 "DP_SV_DROPCLIENT "
102 "DP_SV_EFFECT "
103 "DP_SV_ENTITYCONTENTSTRANSITION "
104 "DP_SV_ONENTITYNOSPAWNFUNCTION "
105 "DP_SV_MODELFLAGS_AS_EFFECTS "
106 "DP_SV_NETADDRESS "
107 "DP_SV_NODRAWTOCLIENT "
108 "DP_SV_PING "
109 "DP_SV_PLAYERPHYSICS "
110 "DP_SV_POINTPARTICLES "
111 "DP_SV_POINTSOUND "
112 "DP_SV_PRECACHEANYTIME "
113 "DP_SV_PRINT "
114 "DP_SV_PUNCHVECTOR "
115 "DP_SV_ROTATINGBMODEL "
116 "DP_SV_SETCOLOR "
117 "DP_SV_SLOWMO "
118 "DP_SV_WRITEUNTERMINATEDSTRING "
119 "DP_TE_BLOOD "
120 "DP_TE_BLOODSHOWER "
121 "DP_TE_CUSTOMFLASH "
122 "DP_TE_EXPLOSIONRGB "
123 "DP_TE_FLAMEJET "
124 "DP_TE_PARTICLECUBE "
125 "DP_TE_PARTICLERAIN "
126 "DP_TE_PARTICLESNOW "
127 "DP_TE_PLASMABURN "
128 "DP_TE_QUADEFFECTS1 "
129 "DP_TE_SMALLFLASH "
130 "DP_TE_SPARK "
131 "DP_TE_STANDARDEFFECTBUILTINS "
132 "DP_TRACE_HITCONTENTSMASK_SURFACEINFO "
133 "DP_VIEWZOOM "
134 "EXT_BITSHIFT "
135 //"EXT_CSQC " // not ready yet
136 "FRIK_FILE "
137 "KRIMZON_SV_PARSECLIENTCOMMAND "
138 "NEH_CMD_PLAY2 "
139 "NEH_RESTOREGAME "
140 "NEXUIZ_PLAYERMODEL "
141 "NXQ_GFX_LETTERBOX "
142 "PRYDON_CLIENTCURSOR "
143 "TENEBRAE_GFX_DLIGHTS "
144 "TW_SV_STEPCONTROL "
145 "DP_SV_CMD "
146 "DP_QC_CMD "
147 "FTE_STRINGS "
148 "DP_CON_BESTWEAPON "
149 "DP_QC_STRREPLACE "
150 ;
151
152 /*
153 =================
154 VM_SV_setorigin
155
156 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.
157
158 setorigin (entity, origin)
159 =================
160 */
161 static void VM_SV_setorigin (void)
162 {
163         prvm_edict_t    *e;
164         float   *org;
165
166         VM_SAFEPARMCOUNT(2, VM_setorigin);
167
168         e = PRVM_G_EDICT(OFS_PARM0);
169         if (e == prog->edicts)
170         {
171                 VM_Warning("setorigin: can not modify world entity\n");
172                 return;
173         }
174         if (e->priv.server->free)
175         {
176                 VM_Warning("setorigin: can not modify free entity\n");
177                 return;
178         }
179         org = PRVM_G_VECTOR(OFS_PARM1);
180         VectorCopy (org, e->fields.server->origin);
181         SV_LinkEdict (e, false);
182 }
183
184
185 void SetMinMaxSize (prvm_edict_t *e, float *min, float *max, qboolean rotate)
186 {
187         int             i;
188
189         for (i=0 ; i<3 ; i++)
190                 if (min[i] > max[i])
191                         PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
192
193 // set derived values
194         VectorCopy (min, e->fields.server->mins);
195         VectorCopy (max, e->fields.server->maxs);
196         VectorSubtract (max, min, e->fields.server->size);
197
198         SV_LinkEdict (e, false);
199 }
200
201 /*
202 =================
203 VM_SV_setsize
204
205 the size box is rotated by the current angle
206 LordHavoc: no it isn't...
207
208 setsize (entity, minvector, maxvector)
209 =================
210 */
211 static void VM_SV_setsize (void)
212 {
213         prvm_edict_t    *e;
214         float   *min, *max;
215
216         VM_SAFEPARMCOUNT(3, VM_setsize);
217
218         e = PRVM_G_EDICT(OFS_PARM0);
219         if (e == prog->edicts)
220         {
221                 VM_Warning("setsize: can not modify world entity\n");
222                 return;
223         }
224         if (e->priv.server->free)
225         {
226                 VM_Warning("setsize: can not modify free entity\n");
227                 return;
228         }
229         min = PRVM_G_VECTOR(OFS_PARM1);
230         max = PRVM_G_VECTOR(OFS_PARM2);
231         SetMinMaxSize (e, min, max, false);
232 }
233
234
235 /*
236 =================
237 VM_SV_setmodel
238
239 setmodel(entity, model)
240 =================
241 */
242 static vec3_t quakemins = {-16, -16, -16}, quakemaxs = {16, 16, 16};
243 static void VM_SV_setmodel (void)
244 {
245         prvm_edict_t    *e;
246         model_t *mod;
247         int             i;
248
249         VM_SAFEPARMCOUNT(2, VM_setmodel);
250
251         e = PRVM_G_EDICT(OFS_PARM0);
252         if (e == prog->edicts)
253         {
254                 VM_Warning("setmodel: can not modify world entity\n");
255                 return;
256         }
257         if (e->priv.server->free)
258         {
259                 VM_Warning("setmodel: can not modify free entity\n");
260                 return;
261         }
262         i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);
263         e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
264         e->fields.server->modelindex = i;
265
266         mod = sv.models[i];
267
268         if (mod)
269         {
270                 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
271                         SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
272                 else
273                         SetMinMaxSize (e, quakemins, quakemaxs, true);
274         }
275         else
276                 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
277 }
278
279 /*
280 =================
281 VM_SV_sprint
282
283 single print to a specific client
284
285 sprint(clientent, value)
286 =================
287 */
288 static void VM_SV_sprint (void)
289 {
290         client_t        *client;
291         int                     entnum;
292         char string[VM_STRINGTEMP_LENGTH];
293
294         VM_VarString(1, string, sizeof(string));
295
296         VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_sprint);
297
298         entnum = PRVM_G_EDICTNUM(OFS_PARM0);
299         // LordHavoc: div0 requested that sprintto world  operate like print
300         if (entnum == 0)
301         {
302                 Con_Print(string);
303                 return;
304         }
305
306         if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
307         {
308                 VM_Warning("tried to centerprint to a non-client\n");
309                 return;
310         }
311
312         client = svs.clients + entnum-1;
313         if (!client->netconnection)
314                 return;
315
316         MSG_WriteChar(&client->netconnection->message,svc_print);
317         MSG_WriteString(&client->netconnection->message, string);
318 }
319
320
321 /*
322 =================
323 VM_SV_centerprint
324
325 single print to a specific client
326
327 centerprint(clientent, value)
328 =================
329 */
330 static void VM_SV_centerprint (void)
331 {
332         client_t        *client;
333         int                     entnum;
334         char string[VM_STRINGTEMP_LENGTH];
335
336         VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_centerprint);
337
338         entnum = PRVM_G_EDICTNUM(OFS_PARM0);
339
340         if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
341         {
342                 VM_Warning("tried to centerprint to a non-client\n");
343                 return;
344         }
345
346         client = svs.clients + entnum-1;
347         if (!client->netconnection)
348                 return;
349
350         VM_VarString(1, string, sizeof(string));
351         MSG_WriteChar(&client->netconnection->message,svc_centerprint);
352         MSG_WriteString(&client->netconnection->message, string);
353 }
354
355 /*
356 =================
357 VM_SV_particle
358
359 particle(origin, color, count)
360 =================
361 */
362 static void VM_SV_particle (void)
363 {
364         float           *org, *dir;
365         float           color;
366         float           count;
367
368         VM_SAFEPARMCOUNT(4, VM_SV_particle);
369
370         org = PRVM_G_VECTOR(OFS_PARM0);
371         dir = PRVM_G_VECTOR(OFS_PARM1);
372         color = PRVM_G_FLOAT(OFS_PARM2);
373         count = PRVM_G_FLOAT(OFS_PARM3);
374         SV_StartParticle (org, dir, (int)color, (int)count);
375 }
376
377
378 /*
379 =================
380 VM_SV_ambientsound
381
382 =================
383 */
384 static void VM_SV_ambientsound (void)
385 {
386         const char      *samp;
387         float           *pos;
388         float           vol, attenuation;
389         int                     soundnum, large;
390
391         VM_SAFEPARMCOUNT(4, VM_SV_ambientsound);
392
393         pos = PRVM_G_VECTOR (OFS_PARM0);
394         samp = PRVM_G_STRING(OFS_PARM1);
395         vol = PRVM_G_FLOAT(OFS_PARM2);
396         attenuation = PRVM_G_FLOAT(OFS_PARM3);
397
398 // check to see if samp was properly precached
399         soundnum = SV_SoundIndex(samp, 1);
400         if (!soundnum)
401                 return;
402
403         large = false;
404         if (soundnum >= 256)
405                 large = true;
406
407         // add an svc_spawnambient command to the level signon packet
408
409         if (large)
410                 MSG_WriteByte (&sv.signon, svc_spawnstaticsound2);
411         else
412                 MSG_WriteByte (&sv.signon, svc_spawnstaticsound);
413
414         MSG_WriteVector(&sv.signon, pos, sv.protocol);
415
416         if (large || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
417                 MSG_WriteShort (&sv.signon, soundnum);
418         else
419                 MSG_WriteByte (&sv.signon, soundnum);
420
421         MSG_WriteByte (&sv.signon, (int)(vol*255));
422         MSG_WriteByte (&sv.signon, (int)(attenuation*64));
423
424 }
425
426 /*
427 =================
428 VM_SV_sound
429
430 Each entity can have eight independant sound sources, like voice,
431 weapon, feet, etc.
432
433 Channel 0 is an auto-allocate channel, the others override anything
434 already running on that entity/channel pair.
435
436 An attenuation of 0 will play full volume everywhere in the level.
437 Larger attenuations will drop off.
438
439 =================
440 */
441 static void VM_SV_sound (void)
442 {
443         const char      *sample;
444         int                     channel;
445         prvm_edict_t            *entity;
446         int             volume;
447         float attenuation;
448
449         VM_SAFEPARMCOUNTRANGE(4, 5, VM_SV_sound);
450
451         entity = PRVM_G_EDICT(OFS_PARM0);
452         channel = (int)PRVM_G_FLOAT(OFS_PARM1);
453         sample = PRVM_G_STRING(OFS_PARM2);
454         volume = (int)(PRVM_G_FLOAT(OFS_PARM3) * 255);
455         attenuation = PRVM_G_FLOAT(OFS_PARM4);
456         if (prog->argc < 5)
457         {
458                 Con_DPrintf("VM_SV_sound: given only 4 parameters, expected 5, assuming attenuation = ATTN_NORMAL\n");
459                 attenuation = 1;
460         }
461
462         if (volume < 0 || volume > 255)
463         {
464                 VM_Warning("SV_StartSound: volume must be in range 0-1\n");
465                 return;
466         }
467
468         if (attenuation < 0 || attenuation > 4)
469         {
470                 VM_Warning("SV_StartSound: attenuation must be in range 0-4\n");
471                 return;
472         }
473
474         if (channel < 0 || channel > 7)
475         {
476                 VM_Warning("SV_StartSound: channel must be in range 0-7\n");
477                 return;
478         }
479
480         SV_StartSound (entity, channel, sample, volume, attenuation);
481 }
482
483 /*
484 =================
485 VM_SV_pointsound
486
487 Follows the same logic as VM_SV_sound, except instead of
488 an entity, an origin for the sound is provided, and channel
489 is omitted (since no entity is being tracked).
490
491 =================
492 */
493 static void VM_SV_pointsound(void)
494 {
495         const char      *sample;
496         int             volume;
497         float           attenuation;
498         vec3_t          org;
499
500         VM_SAFEPARMCOUNT(4, VM_SV_pointsound);
501
502         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
503         sample = PRVM_G_STRING(OFS_PARM1);
504         volume = (int)(PRVM_G_FLOAT(OFS_PARM2) * 255);
505         attenuation = PRVM_G_FLOAT(OFS_PARM3);
506
507         if (volume < 0 || volume > 255)
508         {
509                 VM_Warning("SV_StartPointSound: volume must be in range 0-1\n");
510                 return;
511         }
512
513         if (attenuation < 0 || attenuation > 4)
514         {
515                 VM_Warning("SV_StartPointSound: attenuation must be in range 0-4\n");
516                 return;
517         }
518
519         SV_StartPointSound (org, sample, volume, attenuation);
520 }
521
522 /*
523 =================
524 VM_SV_traceline
525
526 Used for use tracing and shot targeting
527 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
528 if the tryents flag is set.
529
530 traceline (vector1, vector2, movetype, ignore)
531 =================
532 */
533 static void VM_SV_traceline (void)
534 {
535         float   *v1, *v2;
536         trace_t trace;
537         int             move;
538         prvm_edict_t    *ent;
539
540         VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_traceline); // allow more parameters for future expansion
541
542         prog->xfunction->builtinsprofile += 30;
543
544         v1 = PRVM_G_VECTOR(OFS_PARM0);
545         v2 = PRVM_G_VECTOR(OFS_PARM1);
546         move = (int)PRVM_G_FLOAT(OFS_PARM2);
547         ent = PRVM_G_EDICT(OFS_PARM3);
548
549         if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v1[2]) || IS_NAN(v2[2]))
550                 PRVM_ERROR("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
551
552         trace = SV_Move (v1, vec3_origin, vec3_origin, v2, move, ent, SV_GenericHitSuperContentsMask(ent));
553
554         VM_SetTraceGlobals(&trace);
555 }
556
557
558 /*
559 =================
560 VM_SV_tracebox
561
562 Used for use tracing and shot targeting
563 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
564 if the tryents flag is set.
565
566 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
567 =================
568 */
569 // LordHavoc: added this for my own use, VERY useful, similar to traceline
570 static void VM_SV_tracebox (void)
571 {
572         float   *v1, *v2, *m1, *m2;
573         trace_t trace;
574         int             move;
575         prvm_edict_t    *ent;
576
577         VM_SAFEPARMCOUNTRANGE(6, 8, VM_SV_tracebox); // allow more parameters for future expansion
578
579         prog->xfunction->builtinsprofile += 30;
580
581         v1 = PRVM_G_VECTOR(OFS_PARM0);
582         m1 = PRVM_G_VECTOR(OFS_PARM1);
583         m2 = PRVM_G_VECTOR(OFS_PARM2);
584         v2 = PRVM_G_VECTOR(OFS_PARM3);
585         move = (int)PRVM_G_FLOAT(OFS_PARM4);
586         ent = PRVM_G_EDICT(OFS_PARM5);
587
588         if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v1[2]) || IS_NAN(v2[2]))
589                 PRVM_ERROR("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], m1[0], m1[1], m1[2], m2[0], m2[1], m2[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
590
591         trace = SV_Move (v1, m1, m2, v2, move, ent, SV_GenericHitSuperContentsMask(ent));
592
593         VM_SetTraceGlobals(&trace);
594 }
595
596 static trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
597 {
598         int i;
599         float gravity;
600         vec3_t move, end;
601         vec3_t original_origin;
602         vec3_t original_velocity;
603         vec3_t original_angles;
604         vec3_t original_avelocity;
605         prvm_eval_t *val;
606         trace_t trace;
607
608         VectorCopy(tossent->fields.server->origin   , original_origin   );
609         VectorCopy(tossent->fields.server->velocity , original_velocity );
610         VectorCopy(tossent->fields.server->angles   , original_angles   );
611         VectorCopy(tossent->fields.server->avelocity, original_avelocity);
612
613         val = PRVM_EDICTFIELDVALUE(tossent, prog->fieldoffsets.gravity);
614         if (val != NULL && val->_float != 0)
615                 gravity = val->_float;
616         else
617                 gravity = 1.0;
618         gravity *= sv_gravity.value * 0.05;
619
620         for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
621         {
622                 SV_CheckVelocity (tossent);
623                 tossent->fields.server->velocity[2] -= gravity;
624                 VectorMA (tossent->fields.server->angles, 0.05, tossent->fields.server->avelocity, tossent->fields.server->angles);
625                 VectorScale (tossent->fields.server->velocity, 0.05, move);
626                 VectorAdd (tossent->fields.server->origin, move, end);
627                 trace = SV_Move (tossent->fields.server->origin, tossent->fields.server->mins, tossent->fields.server->maxs, end, MOVE_NORMAL, tossent, SV_GenericHitSuperContentsMask(tossent));
628                 VectorCopy (trace.endpos, tossent->fields.server->origin);
629
630                 if (trace.fraction < 1)
631                         break;
632         }
633
634         VectorCopy(original_origin   , tossent->fields.server->origin   );
635         VectorCopy(original_velocity , tossent->fields.server->velocity );
636         VectorCopy(original_angles   , tossent->fields.server->angles   );
637         VectorCopy(original_avelocity, tossent->fields.server->avelocity);
638
639         return trace;
640 }
641
642 static void VM_SV_tracetoss (void)
643 {
644         trace_t trace;
645         prvm_edict_t    *ent;
646         prvm_edict_t    *ignore;
647
648         VM_SAFEPARMCOUNT(2, VM_SV_tracetoss);
649
650         prog->xfunction->builtinsprofile += 600;
651
652         ent = PRVM_G_EDICT(OFS_PARM0);
653         if (ent == prog->edicts)
654         {
655                 VM_Warning("tracetoss: can not use world entity\n");
656                 return;
657         }
658         ignore = PRVM_G_EDICT(OFS_PARM1);
659
660         trace = SV_Trace_Toss (ent, ignore);
661
662         VM_SetTraceGlobals(&trace);
663 }
664
665 //============================================================================
666
667 static int checkpvsbytes;
668 static unsigned char checkpvs[MAX_MAP_LEAFS/8];
669
670 static int VM_SV_newcheckclient (int check)
671 {
672         int             i;
673         prvm_edict_t    *ent;
674         vec3_t  org;
675
676 // cycle to the next one
677
678         check = bound(1, check, svs.maxclients);
679         if (check == svs.maxclients)
680                 i = 1;
681         else
682                 i = check + 1;
683
684         for ( ;  ; i++)
685         {
686                 // count the cost
687                 prog->xfunction->builtinsprofile++;
688                 // wrap around
689                 if (i == svs.maxclients+1)
690                         i = 1;
691                 // look up the client's edict
692                 ent = PRVM_EDICT_NUM(i);
693                 // check if it is to be ignored, but never ignore the one we started on (prevent infinite loop)
694                 if (i != check && (ent->priv.server->free || ent->fields.server->health <= 0 || ((int)ent->fields.server->flags & FL_NOTARGET)))
695                         continue;
696                 // found a valid client (possibly the same one again)
697                 break;
698         }
699
700 // get the PVS for the entity
701         VectorAdd(ent->fields.server->origin, ent->fields.server->view_ofs, org);
702         checkpvsbytes = 0;
703         if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
704                 checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs), false);
705
706         return i;
707 }
708
709 /*
710 =================
711 VM_SV_checkclient
712
713 Returns a client (or object that has a client enemy) that would be a
714 valid target.
715
716 If there is more than one valid option, they are cycled each frame
717
718 If (self.origin + self.viewofs) is not in the PVS of the current target,
719 it is not returned at all.
720
721 name checkclient ()
722 =================
723 */
724 int c_invis, c_notvis;
725 static void VM_SV_checkclient (void)
726 {
727         prvm_edict_t    *ent, *self;
728         vec3_t  view;
729
730         VM_SAFEPARMCOUNT(0, VM_SV_checkclient);
731
732         // find a new check if on a new frame
733         if (sv.time - sv.lastchecktime >= 0.1)
734         {
735                 sv.lastcheck = VM_SV_newcheckclient (sv.lastcheck);
736                 sv.lastchecktime = sv.time;
737         }
738
739         // return check if it might be visible
740         ent = PRVM_EDICT_NUM(sv.lastcheck);
741         if (ent->priv.server->free || ent->fields.server->health <= 0)
742         {
743                 VM_RETURN_EDICT(prog->edicts);
744                 return;
745         }
746
747         // if current entity can't possibly see the check entity, return 0
748         self = PRVM_PROG_TO_EDICT(prog->globals.server->self);
749         VectorAdd(self->fields.server->origin, self->fields.server->view_ofs, view);
750         if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
751         {
752                 c_notvis++;
753                 VM_RETURN_EDICT(prog->edicts);
754                 return;
755         }
756
757         // might be able to see it
758         c_invis++;
759         VM_RETURN_EDICT(ent);
760 }
761
762 //============================================================================
763
764
765 /*
766 =================
767 VM_SV_stuffcmd
768
769 Sends text over to the client's execution buffer
770
771 stuffcmd (clientent, value, ...)
772 =================
773 */
774 static void VM_SV_stuffcmd (void)
775 {
776         int             entnum;
777         client_t        *old;
778         char    string[VM_STRINGTEMP_LENGTH];
779
780         VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_stuffcmd);
781
782         entnum = PRVM_G_EDICTNUM(OFS_PARM0);
783         if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
784         {
785                 VM_Warning("Can't stuffcmd to a non-client\n");
786                 return;
787         }
788
789         VM_VarString(1, string, sizeof(string));
790
791         old = host_client;
792         host_client = svs.clients + entnum-1;
793         Host_ClientCommands ("%s", string);
794         host_client = old;
795 }
796
797 /*
798 =================
799 VM_SV_findradius
800
801 Returns a chain of entities that have origins within a spherical area
802
803 findradius (origin, radius)
804 =================
805 */
806 static void VM_SV_findradius (void)
807 {
808         prvm_edict_t *ent, *chain;
809         vec_t radius, radius2;
810         vec3_t org, eorg, mins, maxs;
811         int i;
812         int numtouchedicts;
813         prvm_edict_t *touchedicts[MAX_EDICTS];
814
815         VM_SAFEPARMCOUNT(2, VM_SV_findradius);
816
817         chain = (prvm_edict_t *)prog->edicts;
818
819         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
820         radius = PRVM_G_FLOAT(OFS_PARM1);
821         radius2 = radius * radius;
822
823         mins[0] = org[0] - (radius + 1);
824         mins[1] = org[1] - (radius + 1);
825         mins[2] = org[2] - (radius + 1);
826         maxs[0] = org[0] + (radius + 1);
827         maxs[1] = org[1] + (radius + 1);
828         maxs[2] = org[2] + (radius + 1);
829         numtouchedicts = World_EntitiesInBox(&sv.world, mins, maxs, MAX_EDICTS, touchedicts);
830         if (numtouchedicts > MAX_EDICTS)
831         {
832                 // this never happens
833                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
834                 numtouchedicts = MAX_EDICTS;
835         }
836         for (i = 0;i < numtouchedicts;i++)
837         {
838                 ent = touchedicts[i];
839                 prog->xfunction->builtinsprofile++;
840                 // Quake did not return non-solid entities but darkplaces does
841                 // (note: this is the reason you can't blow up fallen zombies)
842                 if (ent->fields.server->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
843                         continue;
844                 // LordHavoc: compare against bounding box rather than center so it
845                 // doesn't miss large objects, and use DotProduct instead of Length
846                 // for a major speedup
847                 VectorSubtract(org, ent->fields.server->origin, eorg);
848                 if (sv_gameplayfix_findradiusdistancetobox.integer)
849                 {
850                         eorg[0] -= bound(ent->fields.server->mins[0], eorg[0], ent->fields.server->maxs[0]);
851                         eorg[1] -= bound(ent->fields.server->mins[1], eorg[1], ent->fields.server->maxs[1]);
852                         eorg[2] -= bound(ent->fields.server->mins[2], eorg[2], ent->fields.server->maxs[2]);
853                 }
854                 else
855                         VectorMAMAM(1, eorg, -0.5f, ent->fields.server->mins, -0.5f, ent->fields.server->maxs, eorg);
856                 if (DotProduct(eorg, eorg) < radius2)
857                 {
858                         ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
859                         chain = ent;
860                 }
861         }
862
863         VM_RETURN_EDICT(chain);
864 }
865
866 static void VM_SV_precache_sound (void)
867 {
868         VM_SAFEPARMCOUNT(1, VM_SV_precache_sound);
869         SV_SoundIndex(PRVM_G_STRING(OFS_PARM0), 2);
870         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
871 }
872
873 static void VM_SV_precache_model (void)
874 {
875         VM_SAFEPARMCOUNT(1, VM_SV_precache_model);
876         SV_ModelIndex(PRVM_G_STRING(OFS_PARM0), 2);
877         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
878 }
879
880 /*
881 ===============
882 VM_SV_walkmove
883
884 float(float yaw, float dist[, settrace]) walkmove
885 ===============
886 */
887 static void VM_SV_walkmove (void)
888 {
889         prvm_edict_t    *ent;
890         float   yaw, dist;
891         vec3_t  move;
892         mfunction_t     *oldf;
893         int     oldself;
894         qboolean        settrace;
895
896         VM_SAFEPARMCOUNTRANGE(2, 3, VM_SV_walkmove);
897
898         // assume failure if it returns early
899         PRVM_G_FLOAT(OFS_RETURN) = 0;
900
901         ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
902         if (ent == prog->edicts)
903         {
904                 VM_Warning("walkmove: can not modify world entity\n");
905                 return;
906         }
907         if (ent->priv.server->free)
908         {
909                 VM_Warning("walkmove: can not modify free entity\n");
910                 return;
911         }
912         yaw = PRVM_G_FLOAT(OFS_PARM0);
913         dist = PRVM_G_FLOAT(OFS_PARM1);
914         settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
915
916         if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
917                 return;
918
919         yaw = yaw*M_PI*2 / 360;
920
921         move[0] = cos(yaw)*dist;
922         move[1] = sin(yaw)*dist;
923         move[2] = 0;
924
925 // save program state, because SV_movestep may call other progs
926         oldf = prog->xfunction;
927         oldself = prog->globals.server->self;
928
929         PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true, false, settrace);
930
931
932 // restore program state
933         prog->xfunction = oldf;
934         prog->globals.server->self = oldself;
935 }
936
937 /*
938 ===============
939 VM_SV_droptofloor
940
941 void() droptofloor
942 ===============
943 */
944 static void VM_SV_droptofloor (void)
945 {
946         prvm_edict_t            *ent;
947         vec3_t          end;
948         trace_t         trace;
949
950         VM_SAFEPARMCOUNTRANGE(0, 2, VM_SV_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
951
952         // assume failure if it returns early
953         PRVM_G_FLOAT(OFS_RETURN) = 0;
954
955         ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
956         if (ent == prog->edicts)
957         {
958                 VM_Warning("droptofloor: can not modify world entity\n");
959                 return;
960         }
961         if (ent->priv.server->free)
962         {
963                 VM_Warning("droptofloor: can not modify free entity\n");
964                 return;
965         }
966
967         VectorCopy (ent->fields.server->origin, end);
968         end[2] -= 256;
969
970         trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
971
972         if (trace.fraction != 1 || (trace.startsolid && sv_gameplayfix_droptofloorstartsolid.integer))
973         {
974                 if (trace.fraction < 1)
975                         VectorCopy (trace.endpos, ent->fields.server->origin);
976                 SV_LinkEdict (ent, false);
977                 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
978                 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
979                 PRVM_G_FLOAT(OFS_RETURN) = 1;
980                 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
981                 ent->priv.server->suspendedinairflag = true;
982         }
983 }
984
985 /*
986 ===============
987 VM_SV_lightstyle
988
989 void(float style, string value) lightstyle
990 ===============
991 */
992 static void VM_SV_lightstyle (void)
993 {
994         int             style;
995         const char      *val;
996         client_t        *client;
997         int                     j;
998
999         VM_SAFEPARMCOUNT(2, VM_SV_lightstyle);
1000
1001         style = (int)PRVM_G_FLOAT(OFS_PARM0);
1002         val = PRVM_G_STRING(OFS_PARM1);
1003
1004         if( (unsigned) style >= MAX_LIGHTSTYLES ) {
1005                 PRVM_ERROR( "PF_lightstyle: style: %i >= 64", style );
1006         }
1007
1008 // change the string in sv
1009         strlcpy(sv.lightstyles[style], val, sizeof(sv.lightstyles[style]));
1010
1011 // send message to all clients on this server
1012         if (sv.state != ss_active)
1013                 return;
1014
1015         for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1016         {
1017                 if (client->active && client->netconnection)
1018                 {
1019                         MSG_WriteChar (&client->netconnection->message, svc_lightstyle);
1020                         MSG_WriteChar (&client->netconnection->message,style);
1021                         MSG_WriteString (&client->netconnection->message, val);
1022                 }
1023         }
1024 }
1025
1026 /*
1027 =============
1028 VM_SV_checkbottom
1029 =============
1030 */
1031 static void VM_SV_checkbottom (void)
1032 {
1033         VM_SAFEPARMCOUNT(1, VM_SV_checkbottom);
1034         PRVM_G_FLOAT(OFS_RETURN) = SV_CheckBottom (PRVM_G_EDICT(OFS_PARM0));
1035 }
1036
1037 /*
1038 =============
1039 VM_SV_pointcontents
1040 =============
1041 */
1042 static void VM_SV_pointcontents (void)
1043 {
1044         VM_SAFEPARMCOUNT(1, VM_SV_pointcontents);
1045         PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
1046 }
1047
1048 /*
1049 =============
1050 VM_SV_aim
1051
1052 Pick a vector for the player to shoot along
1053 vector aim(entity, missilespeed)
1054 =============
1055 */
1056 static void VM_SV_aim (void)
1057 {
1058         prvm_edict_t    *ent, *check, *bestent;
1059         vec3_t  start, dir, end, bestdir;
1060         int             i, j;
1061         trace_t tr;
1062         float   dist, bestdist;
1063         float   speed;
1064
1065         VM_SAFEPARMCOUNT(2, VM_SV_aim);
1066
1067         // assume failure if it returns early
1068         VectorCopy(prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
1069         // if sv_aim is so high it can't possibly accept anything, skip out early
1070         if (sv_aim.value >= 1)
1071                 return;
1072
1073         ent = PRVM_G_EDICT(OFS_PARM0);
1074         if (ent == prog->edicts)
1075         {
1076                 VM_Warning("aim: can not use world entity\n");
1077                 return;
1078         }
1079         if (ent->priv.server->free)
1080         {
1081                 VM_Warning("aim: can not use free entity\n");
1082                 return;
1083         }
1084         speed = PRVM_G_FLOAT(OFS_PARM1);
1085
1086         VectorCopy (ent->fields.server->origin, start);
1087         start[2] += 20;
1088
1089 // try sending a trace straight
1090         VectorCopy (prog->globals.server->v_forward, dir);
1091         VectorMA (start, 2048, dir, end);
1092         tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
1093         if (tr.ent && ((prvm_edict_t *)tr.ent)->fields.server->takedamage == DAMAGE_AIM
1094         && (!teamplay.integer || ent->fields.server->team <=0 || ent->fields.server->team != ((prvm_edict_t *)tr.ent)->fields.server->team) )
1095         {
1096                 VectorCopy (prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
1097                 return;
1098         }
1099
1100
1101 // try all possible entities
1102         VectorCopy (dir, bestdir);
1103         bestdist = sv_aim.value;
1104         bestent = NULL;
1105
1106         check = PRVM_NEXT_EDICT(prog->edicts);
1107         for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
1108         {
1109                 prog->xfunction->builtinsprofile++;
1110                 if (check->fields.server->takedamage != DAMAGE_AIM)
1111                         continue;
1112                 if (check == ent)
1113                         continue;
1114                 if (teamplay.integer && ent->fields.server->team > 0 && ent->fields.server->team == check->fields.server->team)
1115                         continue;       // don't aim at teammate
1116                 for (j=0 ; j<3 ; j++)
1117                         end[j] = check->fields.server->origin[j]
1118                         + 0.5*(check->fields.server->mins[j] + check->fields.server->maxs[j]);
1119                 VectorSubtract (end, start, dir);
1120                 VectorNormalize (dir);
1121                 dist = DotProduct (dir, prog->globals.server->v_forward);
1122                 if (dist < bestdist)
1123                         continue;       // to far to turn
1124                 tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
1125                 if (tr.ent == check)
1126                 {       // can shoot at this one
1127                         bestdist = dist;
1128                         bestent = check;
1129                 }
1130         }
1131
1132         if (bestent)
1133         {
1134                 VectorSubtract (bestent->fields.server->origin, ent->fields.server->origin, dir);
1135                 dist = DotProduct (dir, prog->globals.server->v_forward);
1136                 VectorScale (prog->globals.server->v_forward, dist, end);
1137                 end[2] = dir[2];
1138                 VectorNormalize (end);
1139                 VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));
1140         }
1141         else
1142         {
1143                 VectorCopy (bestdir, PRVM_G_VECTOR(OFS_RETURN));
1144         }
1145 }
1146
1147 /*
1148 ===============================================================================
1149
1150 MESSAGE WRITING
1151
1152 ===============================================================================
1153 */
1154
1155 #define MSG_BROADCAST   0               // unreliable to all
1156 #define MSG_ONE                 1               // reliable to one (msg_entity)
1157 #define MSG_ALL                 2               // reliable to all
1158 #define MSG_INIT                3               // write to the init string
1159 #define MSG_ENTITY              5
1160
1161 sizebuf_t *WriteDest (void)
1162 {
1163         int             entnum;
1164         int             dest;
1165         prvm_edict_t    *ent;
1166
1167         dest = (int)PRVM_G_FLOAT(OFS_PARM0);
1168         switch (dest)
1169         {
1170         case MSG_BROADCAST:
1171                 return &sv.datagram;
1172
1173         case MSG_ONE:
1174                 ent = PRVM_PROG_TO_EDICT(prog->globals.server->msg_entity);
1175                 entnum = PRVM_NUM_FOR_EDICT(ent);
1176                 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active || !svs.clients[entnum-1].netconnection)
1177                 {
1178                         VM_Warning ("WriteDest: tried to write to non-client\n");
1179                         return &sv.reliable_datagram;
1180                 }
1181                 else
1182                         return &svs.clients[entnum-1].netconnection->message;
1183
1184         default:
1185                 VM_Warning ("WriteDest: bad destination\n");
1186         case MSG_ALL:
1187                 return &sv.reliable_datagram;
1188
1189         case MSG_INIT:
1190                 return &sv.signon;
1191
1192         case MSG_ENTITY:
1193                 return sv.writeentitiestoclient_msg;
1194         }
1195
1196         return NULL;
1197 }
1198
1199 static void VM_SV_WriteByte (void)
1200 {
1201         VM_SAFEPARMCOUNT(2, VM_SV_WriteByte);
1202         MSG_WriteByte (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1203 }
1204
1205 static void VM_SV_WriteChar (void)
1206 {
1207         VM_SAFEPARMCOUNT(2, VM_SV_WriteChar);
1208         MSG_WriteChar (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1209 }
1210
1211 static void VM_SV_WriteShort (void)
1212 {
1213         VM_SAFEPARMCOUNT(2, VM_SV_WriteShort);
1214         MSG_WriteShort (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1215 }
1216
1217 static void VM_SV_WriteLong (void)
1218 {
1219         VM_SAFEPARMCOUNT(2, VM_SV_WriteLong);
1220         MSG_WriteLong (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1221 }
1222
1223 static void VM_SV_WriteAngle (void)
1224 {
1225         VM_SAFEPARMCOUNT(2, VM_SV_WriteAngle);
1226         MSG_WriteAngle (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1227 }
1228
1229 static void VM_SV_WriteCoord (void)
1230 {
1231         VM_SAFEPARMCOUNT(2, VM_SV_WriteCoord);
1232         MSG_WriteCoord (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1233 }
1234
1235 static void VM_SV_WriteString (void)
1236 {
1237         VM_SAFEPARMCOUNT(2, VM_SV_WriteString);
1238         MSG_WriteString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
1239 }
1240
1241 static void VM_SV_WriteUnterminatedString (void)
1242 {
1243         VM_SAFEPARMCOUNT(2, VM_SV_WriteUnterminatedString);
1244         MSG_WriteUnterminatedString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
1245 }
1246
1247
1248 static void VM_SV_WriteEntity (void)
1249 {
1250         VM_SAFEPARMCOUNT(2, VM_SV_WriteEntity);
1251         MSG_WriteShort (WriteDest(), PRVM_G_EDICTNUM(OFS_PARM1));
1252 }
1253
1254 //////////////////////////////////////////////////////////
1255
1256 static void VM_SV_makestatic (void)
1257 {
1258         prvm_edict_t *ent;
1259         int i, large;
1260
1261         // allow 0 parameters due to an id1 qc bug in which this function is used
1262         // with no parameters (but directly after setmodel with self in OFS_PARM0)
1263         VM_SAFEPARMCOUNTRANGE(0, 1, VM_SV_makestatic);
1264
1265         if (prog->argc >= 1)
1266                 ent = PRVM_G_EDICT(OFS_PARM0);
1267         else
1268                 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
1269         if (ent == prog->edicts)
1270         {
1271                 VM_Warning("makestatic: can not modify world entity\n");
1272                 return;
1273         }
1274         if (ent->priv.server->free)
1275         {
1276                 VM_Warning("makestatic: can not modify free entity\n");
1277                 return;
1278         }
1279
1280         large = false;
1281         if (ent->fields.server->modelindex >= 256 || ent->fields.server->frame >= 256)
1282                 large = true;
1283
1284         if (large)
1285         {
1286                 MSG_WriteByte (&sv.signon,svc_spawnstatic2);
1287                 MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
1288                 MSG_WriteShort (&sv.signon, (int)ent->fields.server->frame);
1289         }
1290         else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1291         {
1292                 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1293                 MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
1294                 MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
1295         }
1296         else
1297         {
1298                 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1299                 MSG_WriteByte (&sv.signon, (int)ent->fields.server->modelindex);
1300                 MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
1301         }
1302
1303         MSG_WriteByte (&sv.signon, (int)ent->fields.server->colormap);
1304         MSG_WriteByte (&sv.signon, (int)ent->fields.server->skin);
1305         for (i=0 ; i<3 ; i++)
1306         {
1307                 MSG_WriteCoord(&sv.signon, ent->fields.server->origin[i], sv.protocol);
1308                 MSG_WriteAngle(&sv.signon, ent->fields.server->angles[i], sv.protocol);
1309         }
1310
1311 // throw the entity away now
1312         PRVM_ED_Free (ent);
1313 }
1314
1315 //=============================================================================
1316
1317 /*
1318 ==============
1319 VM_SV_setspawnparms
1320 ==============
1321 */
1322 static void VM_SV_setspawnparms (void)
1323 {
1324         prvm_edict_t    *ent;
1325         int             i;
1326         client_t        *client;
1327
1328         VM_SAFEPARMCOUNT(1, VM_SV_setspawnparms);
1329
1330         ent = PRVM_G_EDICT(OFS_PARM0);
1331         i = PRVM_NUM_FOR_EDICT(ent);
1332         if (i < 1 || i > svs.maxclients || !svs.clients[i-1].active)
1333         {
1334                 Con_Print("tried to setspawnparms on a non-client\n");
1335                 return;
1336         }
1337
1338         // copy spawn parms out of the client_t
1339         client = svs.clients + i-1;
1340         for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1341                 (&prog->globals.server->parm1)[i] = client->spawn_parms[i];
1342 }
1343
1344 /*
1345 =================
1346 VM_SV_getlight
1347
1348 Returns a color vector indicating the lighting at the requested point.
1349
1350 (Internal Operation note: actually measures the light beneath the point, just like
1351                           the model lighting on the client)
1352
1353 getlight(vector)
1354 =================
1355 */
1356 static void VM_SV_getlight (void)
1357 {
1358         vec3_t ambientcolor, diffusecolor, diffusenormal;
1359         vec_t *p;
1360         VM_SAFEPARMCOUNT(1, VM_SV_getlight);
1361         p = PRVM_G_VECTOR(OFS_PARM0);
1362         VectorClear(ambientcolor);
1363         VectorClear(diffusecolor);
1364         VectorClear(diffusenormal);
1365         if (sv.worldmodel && sv.worldmodel->brush.LightPoint)
1366                 sv.worldmodel->brush.LightPoint(sv.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
1367         VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
1368 }
1369
1370 typedef struct
1371 {
1372         unsigned char   type;   // 1/2/8 or other value if isn't used
1373         int             fieldoffset;
1374 }customstat_t;
1375
1376 static customstat_t *vm_customstats = NULL;     //[515]: it starts from 0, not 32
1377 static int vm_customstats_last;
1378
1379 void VM_CustomStats_Clear (void)
1380 {
1381         if(vm_customstats)
1382         {
1383                 Z_Free(vm_customstats);
1384                 vm_customstats = NULL;
1385                 vm_customstats_last = -1;
1386         }
1387 }
1388
1389 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1390 {
1391         int                     i;
1392         char            s[17];
1393
1394         if(!vm_customstats)
1395                 return;
1396
1397         for(i=0; i<vm_customstats_last+1 ;i++)
1398         {
1399                 if(!vm_customstats[i].type)
1400                         continue;
1401                 switch(vm_customstats[i].type)
1402                 {
1403                 //string as 16 bytes
1404                 case 1:
1405                         memset(s, 0, 17);
1406                         strlcpy(s, PRVM_E_STRING(ent, vm_customstats[i].fieldoffset), 16);
1407                         stats[i+32] = s[ 0] + s[ 1] * 256 + s[ 2] * 65536 + s[ 3] * 16777216;
1408                         stats[i+33] = s[ 4] + s[ 5] * 256 + s[ 6] * 65536 + s[ 7] * 16777216;
1409                         stats[i+34] = s[ 8] + s[ 9] * 256 + s[10] * 65536 + s[11] * 16777216;
1410                         stats[i+35] = s[12] + s[13] * 256 + s[14] * 65536 + s[15] * 16777216;
1411                         break;
1412                 //float field sent as-is
1413                 case 2:
1414                         stats[i+32] = PRVM_E_INT(ent, vm_customstats[i].fieldoffset);
1415                         break;
1416                 //integer value of float field
1417                 case 8:
1418                         stats[i+32] = (int)PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
1419                         break;
1420                 default:
1421                         break;
1422                 }
1423         }
1424 }
1425
1426 // void(float index, float type, .void field) SV_AddStat = #232;
1427 // Set up an auto-sent player stat.
1428 // Client's get thier own fields sent to them. Index may not be less than 32.
1429 // Type is a value equating to the ev_ values found in qcc to dictate types. Valid ones are:
1430 //          1: string (4 stats carrying a total of 16 charactures)
1431 //          2: float (one stat, float converted to an integer for transportation)
1432 //          8: integer (one stat, not converted to an int, so this can be used to transport floats as floats - what a unique idea!)
1433 static void VM_SV_AddStat (void)
1434 {
1435         int             off, i;
1436         unsigned char   type;
1437
1438         VM_SAFEPARMCOUNT(3, VM_SV_AddStat);
1439
1440         if(!vm_customstats)
1441         {
1442                 vm_customstats = (customstat_t *)Z_Malloc((MAX_CL_STATS-32) * sizeof(customstat_t));
1443                 if(!vm_customstats)
1444                 {
1445                         VM_Warning("PF_SV_AddStat: not enough memory\n");
1446                         return;
1447                 }
1448         }
1449         i               = (int)PRVM_G_FLOAT(OFS_PARM0);
1450         type    = (int)PRVM_G_FLOAT(OFS_PARM1);
1451         off             = PRVM_G_INT  (OFS_PARM2);
1452         i -= 32;
1453
1454         if(i < 0)
1455         {
1456                 VM_Warning("PF_SV_AddStat: index may not be less than 32\n");
1457                 return;
1458         }
1459         if(i >= (MAX_CL_STATS-32))
1460         {
1461                 VM_Warning("PF_SV_AddStat: index >= MAX_CL_STATS\n");
1462                 return;
1463         }
1464         if(i > (MAX_CL_STATS-32-4) && type == 1)
1465         {
1466                 VM_Warning("PF_SV_AddStat: index > (MAX_CL_STATS-4) with string\n");
1467                 return;
1468         }
1469         vm_customstats[i].type          = type;
1470         vm_customstats[i].fieldoffset   = off;
1471         if(vm_customstats_last < i)
1472                 vm_customstats_last = i;
1473 }
1474
1475 /*
1476 =================
1477 VM_SV_copyentity
1478
1479 copies data from one entity to another
1480
1481 copyentity(src, dst)
1482 =================
1483 */
1484 static void VM_SV_copyentity (void)
1485 {
1486         prvm_edict_t *in, *out;
1487         VM_SAFEPARMCOUNT(2, VM_SV_copyentity);
1488         in = PRVM_G_EDICT(OFS_PARM0);
1489         if (in == prog->edicts)
1490         {
1491                 VM_Warning("copyentity: can not read world entity\n");
1492                 return;
1493         }
1494         if (in->priv.server->free)
1495         {
1496                 VM_Warning("copyentity: can not read free entity\n");
1497                 return;
1498         }
1499         out = PRVM_G_EDICT(OFS_PARM1);
1500         if (out == prog->edicts)
1501         {
1502                 VM_Warning("copyentity: can not modify world entity\n");
1503                 return;
1504         }
1505         if (out->priv.server->free)
1506         {
1507                 VM_Warning("copyentity: can not modify free entity\n");
1508                 return;
1509         }
1510         memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
1511         SV_LinkEdict(out, false);
1512 }
1513
1514
1515 /*
1516 =================
1517 VM_SV_setcolor
1518
1519 sets the color of a client and broadcasts the update to all connected clients
1520
1521 setcolor(clientent, value)
1522 =================
1523 */
1524 static void VM_SV_setcolor (void)
1525 {
1526         client_t *client;
1527         int entnum, i;
1528         prvm_eval_t *val;
1529
1530         VM_SAFEPARMCOUNT(2, VM_SV_setcolor);
1531         entnum = PRVM_G_EDICTNUM(OFS_PARM0);
1532         i = (int)PRVM_G_FLOAT(OFS_PARM1);
1533
1534         if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
1535         {
1536                 Con_Print("tried to setcolor a non-client\n");
1537                 return;
1538         }
1539
1540         client = svs.clients + entnum-1;
1541         if (client->edict)
1542         {
1543                 if ((val = PRVM_EDICTFIELDVALUE(client->edict, prog->fieldoffsets.clientcolors)))
1544                         val->_float = i;
1545                 client->edict->fields.server->team = (i & 15) + 1;
1546         }
1547         client->colors = i;
1548         if (client->old_colors != client->colors)
1549         {
1550                 client->old_colors = client->colors;
1551                 // send notification to all clients
1552                 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1553                 MSG_WriteByte (&sv.reliable_datagram, client - svs.clients);
1554                 MSG_WriteByte (&sv.reliable_datagram, client->colors);
1555         }
1556 }
1557
1558 /*
1559 =================
1560 VM_SV_effect
1561
1562 effect(origin, modelname, startframe, framecount, framerate)
1563 =================
1564 */
1565 static void VM_SV_effect (void)
1566 {
1567         int i;
1568         const char *s;
1569         VM_SAFEPARMCOUNT(5, VM_SV_effect);
1570         s = PRVM_G_STRING(OFS_PARM1);
1571         if (!s[0])
1572         {
1573                 VM_Warning("effect: no model specified\n");
1574                 return;
1575         }
1576
1577         i = SV_ModelIndex(s, 1);
1578         if (!i)
1579         {
1580                 VM_Warning("effect: model not precached\n");
1581                 return;
1582         }
1583
1584         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1585         {
1586                 VM_Warning("effect: framecount < 1\n");
1587                 return;
1588         }
1589
1590         if (PRVM_G_FLOAT(OFS_PARM4) < 1)
1591         {
1592                 VM_Warning("effect: framerate < 1\n");
1593                 return;
1594         }
1595
1596         SV_StartEffect(PRVM_G_VECTOR(OFS_PARM0), i, (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4));
1597 }
1598
1599 static void VM_SV_te_blood (void)
1600 {
1601         VM_SAFEPARMCOUNT(3, VM_SV_te_blood);
1602         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1603                 return;
1604         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1605         MSG_WriteByte(&sv.datagram, TE_BLOOD);
1606         // origin
1607         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1608         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1609         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1610         // velocity
1611         MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1612         MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1613         MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1614         // count
1615         MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1616         SV_FlushBroadcastMessages();
1617 }
1618
1619 static void VM_SV_te_bloodshower (void)
1620 {
1621         VM_SAFEPARMCOUNT(4, VM_SV_te_bloodshower);
1622         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1623                 return;
1624         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1625         MSG_WriteByte(&sv.datagram, TE_BLOODSHOWER);
1626         // min
1627         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1628         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1629         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1630         // max
1631         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1632         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1633         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1634         // speed
1635         MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM2), sv.protocol);
1636         // count
1637         MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1638         SV_FlushBroadcastMessages();
1639 }
1640
1641 static void VM_SV_te_explosionrgb (void)
1642 {
1643         VM_SAFEPARMCOUNT(2, VM_SV_te_explosionrgb);
1644         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1645         MSG_WriteByte(&sv.datagram, TE_EXPLOSIONRGB);
1646         // origin
1647         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1648         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1649         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1650         // color
1651         MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[0] * 255), 255));
1652         MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[1] * 255), 255));
1653         MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[2] * 255), 255));
1654         SV_FlushBroadcastMessages();
1655 }
1656
1657 static void VM_SV_te_particlecube (void)
1658 {
1659         VM_SAFEPARMCOUNT(7, VM_SV_te_particlecube);
1660         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1661                 return;
1662         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1663         MSG_WriteByte(&sv.datagram, TE_PARTICLECUBE);
1664         // min
1665         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1666         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1667         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1668         // max
1669         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1670         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1671         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1672         // velocity
1673         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1674         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1675         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1676         // count
1677         MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1678         // color
1679         MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1680         // gravity true/false
1681         MSG_WriteByte(&sv.datagram, ((int) PRVM_G_FLOAT(OFS_PARM5)) != 0);
1682         // randomvel
1683         MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM6), sv.protocol);
1684         SV_FlushBroadcastMessages();
1685 }
1686
1687 static void VM_SV_te_particlerain (void)
1688 {
1689         VM_SAFEPARMCOUNT(5, VM_SV_te_particlerain);
1690         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1691                 return;
1692         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1693         MSG_WriteByte(&sv.datagram, TE_PARTICLERAIN);
1694         // min
1695         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1696         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1697         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1698         // max
1699         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1700         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1701         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1702         // velocity
1703         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1704         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1705         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1706         // count
1707         MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1708         // color
1709         MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1710         SV_FlushBroadcastMessages();
1711 }
1712
1713 static void VM_SV_te_particlesnow (void)
1714 {
1715         VM_SAFEPARMCOUNT(5, VM_SV_te_particlesnow);
1716         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1717                 return;
1718         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1719         MSG_WriteByte(&sv.datagram, TE_PARTICLESNOW);
1720         // min
1721         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1722         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1723         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1724         // max
1725         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1726         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1727         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1728         // velocity
1729         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1730         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1731         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1732         // count
1733         MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1734         // color
1735         MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1736         SV_FlushBroadcastMessages();
1737 }
1738
1739 static void VM_SV_te_spark (void)
1740 {
1741         VM_SAFEPARMCOUNT(3, VM_SV_te_spark);
1742         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1743                 return;
1744         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1745         MSG_WriteByte(&sv.datagram, TE_SPARK);
1746         // origin
1747         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1748         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1749         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1750         // velocity
1751         MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1752         MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1753         MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1754         // count
1755         MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1756         SV_FlushBroadcastMessages();
1757 }
1758
1759 static void VM_SV_te_gunshotquad (void)
1760 {
1761         VM_SAFEPARMCOUNT(1, VM_SV_te_gunshotquad);
1762         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1763         MSG_WriteByte(&sv.datagram, TE_GUNSHOTQUAD);
1764         // origin
1765         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1766         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1767         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1768         SV_FlushBroadcastMessages();
1769 }
1770
1771 static void VM_SV_te_spikequad (void)
1772 {
1773         VM_SAFEPARMCOUNT(1, VM_SV_te_spikequad);
1774         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1775         MSG_WriteByte(&sv.datagram, TE_SPIKEQUAD);
1776         // origin
1777         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1778         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1779         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1780         SV_FlushBroadcastMessages();
1781 }
1782
1783 static void VM_SV_te_superspikequad (void)
1784 {
1785         VM_SAFEPARMCOUNT(1, VM_SV_te_superspikequad);
1786         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1787         MSG_WriteByte(&sv.datagram, TE_SUPERSPIKEQUAD);
1788         // origin
1789         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1790         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1791         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1792         SV_FlushBroadcastMessages();
1793 }
1794
1795 static void VM_SV_te_explosionquad (void)
1796 {
1797         VM_SAFEPARMCOUNT(1, VM_SV_te_explosionquad);
1798         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1799         MSG_WriteByte(&sv.datagram, TE_EXPLOSIONQUAD);
1800         // origin
1801         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1802         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1803         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1804         SV_FlushBroadcastMessages();
1805 }
1806
1807 static void VM_SV_te_smallflash (void)
1808 {
1809         VM_SAFEPARMCOUNT(1, VM_SV_te_smallflash);
1810         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1811         MSG_WriteByte(&sv.datagram, TE_SMALLFLASH);
1812         // origin
1813         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1814         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1815         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1816         SV_FlushBroadcastMessages();
1817 }
1818
1819 static void VM_SV_te_customflash (void)
1820 {
1821         VM_SAFEPARMCOUNT(4, VM_SV_te_customflash);
1822         if (PRVM_G_FLOAT(OFS_PARM1) < 8 || PRVM_G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
1823                 return;
1824         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1825         MSG_WriteByte(&sv.datagram, TE_CUSTOMFLASH);
1826         // origin
1827         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1828         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1829         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1830         // radius
1831         MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM1) / 8 - 1, 255));
1832         // lifetime
1833         MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM2) * 256 - 1, 255));
1834         // color
1835         MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[0] * 255, 255));
1836         MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[1] * 255, 255));
1837         MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[2] * 255, 255));
1838         SV_FlushBroadcastMessages();
1839 }
1840
1841 static void VM_SV_te_gunshot (void)
1842 {
1843         VM_SAFEPARMCOUNT(1, VM_SV_te_gunshot);
1844         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1845         MSG_WriteByte(&sv.datagram, TE_GUNSHOT);
1846         // origin
1847         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1848         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1849         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1850         SV_FlushBroadcastMessages();
1851 }
1852
1853 static void VM_SV_te_spike (void)
1854 {
1855         VM_SAFEPARMCOUNT(1, VM_SV_te_spike);
1856         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1857         MSG_WriteByte(&sv.datagram, TE_SPIKE);
1858         // origin
1859         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1860         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1861         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1862         SV_FlushBroadcastMessages();
1863 }
1864
1865 static void VM_SV_te_superspike (void)
1866 {
1867         VM_SAFEPARMCOUNT(1, VM_SV_te_superspike);
1868         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1869         MSG_WriteByte(&sv.datagram, TE_SUPERSPIKE);
1870         // origin
1871         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1872         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1873         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1874         SV_FlushBroadcastMessages();
1875 }
1876
1877 static void VM_SV_te_explosion (void)
1878 {
1879         VM_SAFEPARMCOUNT(1, VM_SV_te_explosion);
1880         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1881         MSG_WriteByte(&sv.datagram, TE_EXPLOSION);
1882         // origin
1883         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1884         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1885         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1886         SV_FlushBroadcastMessages();
1887 }
1888
1889 static void VM_SV_te_tarexplosion (void)
1890 {
1891         VM_SAFEPARMCOUNT(1, VM_SV_te_tarexplosion);
1892         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1893         MSG_WriteByte(&sv.datagram, TE_TAREXPLOSION);
1894         // origin
1895         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1896         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1897         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1898         SV_FlushBroadcastMessages();
1899 }
1900
1901 static void VM_SV_te_wizspike (void)
1902 {
1903         VM_SAFEPARMCOUNT(1, VM_SV_te_wizspike);
1904         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1905         MSG_WriteByte(&sv.datagram, TE_WIZSPIKE);
1906         // origin
1907         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1908         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1909         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1910         SV_FlushBroadcastMessages();
1911 }
1912
1913 static void VM_SV_te_knightspike (void)
1914 {
1915         VM_SAFEPARMCOUNT(1, VM_SV_te_knightspike);
1916         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1917         MSG_WriteByte(&sv.datagram, TE_KNIGHTSPIKE);
1918         // origin
1919         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1920         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1921         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1922         SV_FlushBroadcastMessages();
1923 }
1924
1925 static void VM_SV_te_lavasplash (void)
1926 {
1927         VM_SAFEPARMCOUNT(1, VM_SV_te_lavasplash);
1928         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1929         MSG_WriteByte(&sv.datagram, TE_LAVASPLASH);
1930         // origin
1931         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1932         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1933         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1934         SV_FlushBroadcastMessages();
1935 }
1936
1937 static void VM_SV_te_teleport (void)
1938 {
1939         VM_SAFEPARMCOUNT(1, VM_SV_te_teleport);
1940         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1941         MSG_WriteByte(&sv.datagram, TE_TELEPORT);
1942         // origin
1943         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1944         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1945         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1946         SV_FlushBroadcastMessages();
1947 }
1948
1949 static void VM_SV_te_explosion2 (void)
1950 {
1951         VM_SAFEPARMCOUNT(3, VM_SV_te_explosion2);
1952         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1953         MSG_WriteByte(&sv.datagram, TE_EXPLOSION2);
1954         // origin
1955         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1956         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1957         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1958         // color
1959         MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
1960         MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
1961         SV_FlushBroadcastMessages();
1962 }
1963
1964 static void VM_SV_te_lightning1 (void)
1965 {
1966         VM_SAFEPARMCOUNT(3, VM_SV_te_lightning1);
1967         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1968         MSG_WriteByte(&sv.datagram, TE_LIGHTNING1);
1969         // owner entity
1970         MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
1971         // start
1972         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1973         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1974         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1975         // end
1976         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1977         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1978         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1979         SV_FlushBroadcastMessages();
1980 }
1981
1982 static void VM_SV_te_lightning2 (void)
1983 {
1984         VM_SAFEPARMCOUNT(3, VM_SV_te_lightning2);
1985         MSG_WriteByte(&sv.datagram, svc_temp_entity);
1986         MSG_WriteByte(&sv.datagram, TE_LIGHTNING2);
1987         // owner entity
1988         MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
1989         // start
1990         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1991         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1992         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1993         // end
1994         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1995         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1996         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1997         SV_FlushBroadcastMessages();
1998 }
1999
2000 static void VM_SV_te_lightning3 (void)
2001 {
2002         VM_SAFEPARMCOUNT(3, VM_SV_te_lightning3);
2003         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2004         MSG_WriteByte(&sv.datagram, TE_LIGHTNING3);
2005         // owner entity
2006         MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2007         // start
2008         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2009         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2010         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2011         // end
2012         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2013         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2014         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2015         SV_FlushBroadcastMessages();
2016 }
2017
2018 static void VM_SV_te_beam (void)
2019 {
2020         VM_SAFEPARMCOUNT(3, VM_SV_te_beam);
2021         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2022         MSG_WriteByte(&sv.datagram, TE_BEAM);
2023         // owner entity
2024         MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2025         // start
2026         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2027         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2028         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2029         // end
2030         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2031         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2032         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2033         SV_FlushBroadcastMessages();
2034 }
2035
2036 static void VM_SV_te_plasmaburn (void)
2037 {
2038         VM_SAFEPARMCOUNT(1, VM_SV_te_plasmaburn);
2039         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2040         MSG_WriteByte(&sv.datagram, TE_PLASMABURN);
2041         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2042         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2043         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2044         SV_FlushBroadcastMessages();
2045 }
2046
2047 static void VM_SV_te_flamejet (void)
2048 {
2049         VM_SAFEPARMCOUNT(3, VM_SV_te_flamejet);
2050         MSG_WriteByte(&sv.datagram, svc_temp_entity);
2051         MSG_WriteByte(&sv.datagram, TE_FLAMEJET);
2052         // org
2053         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2054         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2055         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2056         // vel
2057         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2058         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2059         MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2060         // count
2061         MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
2062         SV_FlushBroadcastMessages();
2063 }
2064
2065 void clippointtosurface(model_t *model, msurface_t *surface, vec3_t p, vec3_t out)
2066 {
2067         int i, j, k;
2068         float *v[3], facenormal[3], edgenormal[3], sidenormal[3], temp[3], offsetdist, dist, bestdist;
2069         const int *e;
2070         bestdist = 1000000000;
2071         VectorCopy(p, out);
2072         for (i = 0, e = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);i < surface->num_triangles;i++, e += 3)
2073         {
2074                 // clip original point to each triangle of the surface and find the
2075                 // triangle that is closest
2076                 v[0] = model->surfmesh.data_vertex3f + e[0] * 3;
2077                 v[1] = model->surfmesh.data_vertex3f + e[1] * 3;
2078                 v[2] = model->surfmesh.data_vertex3f + e[2] * 3;
2079                 TriangleNormal(v[0], v[1], v[2], facenormal);
2080                 VectorNormalize(facenormal);
2081                 offsetdist = DotProduct(v[0], facenormal) - DotProduct(p, facenormal);
2082                 VectorMA(p, offsetdist, facenormal, temp);
2083                 for (j = 0, k = 2;j < 3;k = j, j++)
2084                 {
2085                         VectorSubtract(v[k], v[j], edgenormal);
2086                         CrossProduct(edgenormal, facenormal, sidenormal);
2087                         VectorNormalize(sidenormal);
2088                         offsetdist = DotProduct(v[k], sidenormal) - DotProduct(temp, sidenormal);
2089                         if (offsetdist < 0)
2090                                 VectorMA(temp, offsetdist, sidenormal, temp);
2091                 }
2092                 dist = VectorDistance2(temp, p);
2093                 if (bestdist > dist)
2094                 {
2095                         bestdist = dist;
2096                         VectorCopy(temp, out);
2097                 }
2098         }
2099 }
2100
2101 static model_t *getmodel(prvm_edict_t *ed)
2102 {
2103         int modelindex;
2104         if (!ed || ed->priv.server->free)
2105                 return NULL;
2106         modelindex = (int)ed->fields.server->modelindex;
2107         if (modelindex < 1 || modelindex >= MAX_MODELS)
2108                 return NULL;
2109         return sv.models[modelindex];
2110 }
2111
2112 static msurface_t *getsurface(model_t *model, int surfacenum)
2113 {
2114         if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
2115                 return NULL;
2116         return model->data_surfaces + surfacenum + model->firstmodelsurface;
2117 }
2118
2119
2120 //PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434;
2121 static void VM_SV_getsurfacenumpoints(void)
2122 {
2123         model_t *model;
2124         msurface_t *surface;
2125         VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenumpoints);
2126         // return 0 if no such surface
2127         if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2128         {
2129                 PRVM_G_FLOAT(OFS_RETURN) = 0;
2130                 return;
2131         }
2132
2133         // note: this (incorrectly) assumes it is a simple polygon
2134         PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
2135 }
2136 //PF_getsurfacepoint,     // #435 vector(entity e, float s, float n) getsurfacepoint = #435;
2137 static void VM_SV_getsurfacepoint(void)
2138 {
2139         prvm_edict_t *ed;
2140         model_t *model;
2141         msurface_t *surface;
2142         int pointnum;
2143         VM_SAFEPARMCOUNT(3, VM_SV_getsurfacepoint);
2144         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2145         ed = PRVM_G_EDICT(OFS_PARM0);
2146         if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2147                 return;
2148         // note: this (incorrectly) assumes it is a simple polygon
2149         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
2150         if (pointnum < 0 || pointnum >= surface->num_vertices)
2151                 return;
2152         // FIXME: implement rotation/scaling
2153         VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2154 }
2155 //PF_getsurfacepointattribute,     // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
2156 // float SPA_POSITION = 0;
2157 // float SPA_S_AXIS = 1;
2158 // float SPA_R_AXIS = 2;
2159 // float SPA_T_AXIS = 3; // same as SPA_NORMAL
2160 // float SPA_TEXCOORDS0 = 4;
2161 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
2162 // float SPA_LIGHTMAP0_COLOR = 6;
2163 static void VM_SV_getsurfacepointattribute(void)
2164 {
2165         prvm_edict_t *ed;
2166         model_t *model;
2167         msurface_t *surface;
2168         int pointnum;
2169         int attributetype;
2170
2171         VM_SAFEPARMCOUNT(3, VM_SV_getsurfacepoint);
2172         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2173         ed = PRVM_G_EDICT(OFS_PARM0);
2174         if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2175                 return;
2176         // note: this (incorrectly) assumes it is a simple polygon
2177         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
2178         if (pointnum < 0 || pointnum >= surface->num_vertices)
2179                 return;
2180         // FIXME: implement rotation/scaling
2181         attributetype = (int) PRVM_G_FLOAT(OFS_PARM3);
2182
2183         switch( attributetype ) {
2184                 // float SPA_POSITION = 0;
2185                 case 0:
2186                         VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2187                         break;
2188                 // float SPA_S_AXIS = 1;
2189                 case 1:
2190                         VectorCopy(&(model->surfmesh.data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2191                         break;
2192                 // float SPA_R_AXIS = 2;
2193                 case 2:
2194                         VectorCopy(&(model->surfmesh.data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2195                         break;
2196                 // float SPA_T_AXIS = 3; // same as SPA_NORMAL
2197                 case 3:
2198                         VectorCopy(&(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2199                         break;
2200                 // float SPA_TEXCOORDS0 = 4;
2201                 case 4: {
2202                         float *ret = PRVM_G_VECTOR(OFS_RETURN);
2203                         float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2];
2204                         ret[0] = texcoord[0];
2205                         ret[1] = texcoord[1];
2206                         ret[2] = 0.0f;
2207                         break;
2208                 }
2209                 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
2210                 case 5: {
2211                         float *ret = PRVM_G_VECTOR(OFS_RETURN);
2212                         float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2];
2213                         ret[0] = texcoord[0];
2214                         ret[1] = texcoord[1];
2215                         ret[2] = 0.0f;
2216                         break;
2217                 }
2218                 // float SPA_LIGHTMAP0_COLOR = 6;
2219                 case 6:
2220                         // ignore alpha for now..
2221                         VectorCopy( &(model->surfmesh.data_normal3f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN));
2222                         break;
2223                 default:
2224                         VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f );
2225                         break;
2226         }
2227 }
2228 //PF_getsurfacenormal,    // #436 vector(entity e, float s) getsurfacenormal = #436;
2229 static void VM_SV_getsurfacenormal(void)
2230 {
2231         model_t *model;
2232         msurface_t *surface;
2233         vec3_t normal;
2234         VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenormal);
2235         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2236         if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2237                 return;
2238         // FIXME: implement rotation/scaling
2239         // note: this (incorrectly) assumes it is a simple polygon
2240         // note: this only returns the first triangle, so it doesn't work very
2241         // well for curved surfaces or arbitrary meshes
2242         TriangleNormal((model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 3, (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
2243         VectorNormalize(normal);
2244         VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
2245 }
2246 //PF_getsurfacetexture,   // #437 string(entity e, float s) getsurfacetexture = #437;
2247 static void VM_SV_getsurfacetexture(void)
2248 {
2249         model_t *model;
2250         msurface_t *surface;
2251         VM_SAFEPARMCOUNT(2, VM_SV_getsurfacetexture);
2252         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2253         if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2254                 return;
2255         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
2256 }
2257 //PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438;
2258 static void VM_SV_getsurfacenearpoint(void)
2259 {
2260         int surfacenum, best;
2261         vec3_t clipped, p;
2262         vec_t dist, bestdist;
2263         prvm_edict_t *ed;
2264         model_t *model;
2265         msurface_t *surface;
2266         vec_t *point;
2267         VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenearpoint);
2268         PRVM_G_FLOAT(OFS_RETURN) = -1;
2269         ed = PRVM_G_EDICT(OFS_PARM0);
2270         point = PRVM_G_VECTOR(OFS_PARM1);
2271
2272         if (!ed || ed->priv.server->free)
2273                 return;
2274         model = getmodel(ed);
2275         if (!model || !model->num_surfaces)
2276                 return;
2277
2278         // FIXME: implement rotation/scaling
2279         VectorSubtract(point, ed->fields.server->origin, p);
2280         best = -1;
2281         bestdist = 1000000000;
2282         for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
2283         {
2284                 surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
2285                 // first see if the nearest point on the surface's box is closer than the previous match
2286                 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
2287                 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
2288                 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
2289                 dist = VectorLength2(clipped);
2290                 if (dist < bestdist)
2291                 {
2292                         // it is, check the nearest point on the actual geometry
2293                         clippointtosurface(model, surface, p, clipped);
2294                         VectorSubtract(clipped, p, clipped);
2295                         dist += VectorLength2(clipped);
2296                         if (dist < bestdist)
2297                         {
2298                                 // that's closer too, store it as the best match
2299                                 best = surfacenum;
2300                                 bestdist = dist;
2301                         }
2302                 }
2303         }
2304         PRVM_G_FLOAT(OFS_RETURN) = best;
2305 }
2306 //PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439;
2307 static void VM_SV_getsurfaceclippedpoint(void)
2308 {
2309         prvm_edict_t *ed;
2310         model_t *model;
2311         msurface_t *surface;
2312         vec3_t p, out;
2313         VM_SAFEPARMCOUNT(3, VM_SV_te_getsurfaceclippedpoint);
2314         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2315         ed = PRVM_G_EDICT(OFS_PARM0);
2316         if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2317                 return;
2318         // FIXME: implement rotation/scaling
2319         VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.server->origin, p);
2320         clippointtosurface(model, surface, p, out);
2321         // FIXME: implement rotation/scaling
2322         VectorAdd(out, ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2323 }
2324
2325 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2326 //this function originally written by KrimZon, made shorter by LordHavoc
2327 static void VM_SV_clientcommand (void)
2328 {
2329         client_t *temp_client;
2330         int i;
2331         VM_SAFEPARMCOUNT(2, VM_SV_clientcommand);
2332
2333         //find client for this entity
2334         i = (PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0)) - 1);
2335         if (i < 0 || i >= svs.maxclients || !svs.clients[i].active)
2336         {
2337                 Con_Print("PF_clientcommand: entity is not a client\n");
2338                 return;
2339         }
2340
2341         temp_client = host_client;
2342         host_client = svs.clients + i;
2343         Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client);
2344         host_client = temp_client;
2345 }
2346
2347 //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)
2348 static void VM_SV_setattachment (void)
2349 {
2350         prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
2351         prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
2352         const char *tagname = PRVM_G_STRING(OFS_PARM2);
2353         prvm_eval_t *v;
2354         int modelindex;
2355         model_t *model;
2356         VM_SAFEPARMCOUNT(3, VM_SV_setattachment);
2357
2358         if (e == prog->edicts)
2359         {
2360                 VM_Warning("setattachment: can not modify world entity\n");
2361                 return;
2362         }
2363         if (e->priv.server->free)
2364         {
2365                 VM_Warning("setattachment: can not modify free entity\n");
2366                 return;
2367         }
2368
2369         if (tagentity == NULL)
2370                 tagentity = prog->edicts;
2371
2372         v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_entity);
2373         if (v)
2374                 v->edict = PRVM_EDICT_TO_PROG(tagentity);
2375
2376         v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_index);
2377         if (v)
2378                 v->_float = 0;
2379         if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2380         {
2381                 modelindex = (int)tagentity->fields.server->modelindex;
2382                 if (modelindex >= 0 && modelindex < MAX_MODELS && (model = sv.models[modelindex]))
2383                 {
2384                         v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.server->skin, tagname);
2385                         if (v->_float == 0)
2386                                 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", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
2387                 }
2388                 else
2389                         Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
2390         }
2391 }
2392
2393 /////////////////////////////////////////
2394 // DP_MD3_TAGINFO extension coded by VorteX
2395
2396 int SV_GetTagIndex (prvm_edict_t *e, const char *tagname)
2397 {
2398         int i;
2399         model_t *model;
2400
2401         i = (int)e->fields.server->modelindex;
2402         if (i < 1 || i >= MAX_MODELS)
2403                 return -1;
2404         model = sv.models[i];
2405
2406         return Mod_Alias_GetTagIndexForName(model, (int)e->fields.server->skin, tagname);
2407 };
2408
2409 void SV_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2410 {
2411         float scale = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float;
2412         if (scale == 0)
2413                 scale = 1;
2414         if (viewmatrix)
2415                 Matrix4x4_CreateFromQuakeEntity(out, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] + ent->fields.server->view_ofs[2], ent->fields.server->v_angle[0], ent->fields.server->v_angle[1], ent->fields.server->v_angle[2], scale);
2416         else
2417                 Matrix4x4_CreateFromQuakeEntity(out, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2], -ent->fields.server->angles[0], ent->fields.server->angles[1], ent->fields.server->angles[2], scale * cl_viewmodel_scale.value);
2418 }
2419
2420 int SV_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2421 {
2422         int modelindex;
2423         int frame;
2424         model_t *model;
2425         if (tagindex >= 0
2426          && (modelindex = (int)ent->fields.server->modelindex) >= 1 && modelindex < MAX_MODELS
2427          && (model = sv.models[(int)ent->fields.server->modelindex])
2428          && model->animscenes)
2429         {
2430                 // if model has wrong frame, engine automatically switches to model first frame
2431                 frame = (int)ent->fields.server->frame;
2432                 if (frame < 0 || frame >= model->numframes)
2433                         frame = 0;
2434                 return Mod_Alias_GetTagMatrix(model, model->animscenes[frame].firstframe, tagindex, out);
2435         }
2436         *out = identitymatrix;
2437         return 0;
2438 }
2439
2440 // Warnings/errors code:
2441 // 0 - normal (everything all-right)
2442 // 1 - world entity
2443 // 2 - free entity
2444 // 3 - null or non-precached model
2445 // 4 - no tags with requested index
2446 // 5 - runaway loop at attachment chain
2447 extern cvar_t cl_bob;
2448 extern cvar_t cl_bobcycle;
2449 extern cvar_t cl_bobup;
2450 int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
2451 {
2452         int ret;
2453         prvm_eval_t *val;
2454         int modelindex, attachloop;
2455         matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2456         model_t *model;
2457
2458         *out = identitymatrix; // warnings and errors return identical matrix
2459
2460         if (ent == prog->edicts)
2461                 return 1;
2462         if (ent->priv.server->free)
2463                 return 2;
2464
2465         modelindex = (int)ent->fields.server->modelindex;
2466         if (modelindex <= 0 || modelindex > MAX_MODELS)
2467                 return 3;
2468
2469         model = sv.models[modelindex];
2470
2471         tagmatrix = identitymatrix;
2472         // DP_GFX_QUAKE3MODELTAGS, scan all chain and stop on unattached entity
2473         attachloop = 0;
2474         for (;;)
2475         {
2476                 if (attachloop >= 256) // prevent runaway looping
2477                         return 5;
2478                 // apply transformation by child's tagindex on parent entity and then
2479                 // by parent entity itself
2480                 ret = SV_GetEntityLocalTagMatrix(ent, tagindex - 1, &attachmatrix);
2481                 if (ret && attachloop == 0)
2482                         return ret;
2483                 Matrix4x4_Concat(out, &attachmatrix, &tagmatrix);
2484                 SV_GetEntityMatrix(ent, &entitymatrix, false);
2485                 Matrix4x4_Concat(&tagmatrix, &entitymatrix, out);
2486                 // next iteration we process the parent entity
2487                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)) && val->edict)
2488                 {
2489                         tagindex = (int)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
2490                         ent = PRVM_EDICT_NUM(val->edict);
2491                 }
2492                 else
2493                         break;
2494                 attachloop++;
2495         }
2496
2497         // RENDER_VIEWMODEL magic
2498         if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)) && val->edict)
2499         {
2500                 Matrix4x4_Copy(&tagmatrix, out);
2501                 ent = PRVM_EDICT_NUM(val->edict);
2502
2503                 SV_GetEntityMatrix(ent, &entitymatrix, true);
2504                 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2505
2506                 /*
2507                 // Cl_bob, ported from rendering code
2508                 if (ent->fields.server->health > 0 && cl_bob.value && cl_bobcycle.value)
2509                 {
2510                         double bob, cycle;
2511                         // LordHavoc: this code is *weird*, but not replacable (I think it
2512                         // should be done in QC on the server, but oh well, quake is quake)
2513                         // LordHavoc: figured out bobup: the time at which the sin is at 180
2514                         // degrees (which allows lengthening or squishing the peak or valley)
2515                         cycle = sv.time/cl_bobcycle.value;
2516                         cycle -= (int)cycle;
2517                         if (cycle < cl_bobup.value)
2518                                 cycle = sin(M_PI * cycle / cl_bobup.value);
2519                         else
2520                                 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2521                         // bob is proportional to velocity in the xy plane
2522                         // (don't count Z, or jumping messes it up)
2523                         bob = sqrt(ent->fields.server->velocity[0]*ent->fields.server->velocity[0] + ent->fields.server->velocity[1]*ent->fields.server->velocity[1])*cl_bob.value;
2524                         bob = bob*0.3 + bob*0.7*cycle;
2525                         Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2526                 }
2527                 */
2528         }
2529         return 0;
2530 }
2531
2532 //float(entity ent, string tagname) gettagindex;
2533
2534 static void VM_SV_gettagindex (void)
2535 {
2536         prvm_edict_t *ent;
2537         const char *tag_name;
2538         int modelindex, tag_index;
2539
2540         VM_SAFEPARMCOUNT(2, VM_SV_gettagindex);
2541
2542         ent = PRVM_G_EDICT(OFS_PARM0);
2543         tag_name = PRVM_G_STRING(OFS_PARM1);
2544
2545         if (ent == prog->edicts)
2546         {
2547                 VM_Warning("gettagindex: can't affect world entity\n");
2548                 return;
2549         }
2550         if (ent->priv.server->free)
2551         {
2552                 VM_Warning("gettagindex: can't affect free entity\n");
2553                 return;
2554         }
2555
2556         modelindex = (int)ent->fields.server->modelindex;
2557         tag_index = 0;
2558         if (modelindex <= 0 || modelindex > MAX_MODELS)
2559                 Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2560         else
2561         {
2562                 tag_index = SV_GetTagIndex(ent, tag_name);
2563                 if (tag_index == 0)
2564                         if(developer.integer >= 100)
2565                                 Con_Printf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2566         }
2567         PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2568 };
2569
2570 //vector(entity ent, float tagindex) gettaginfo;
2571 static void VM_SV_gettaginfo (void)
2572 {
2573         prvm_edict_t *e;
2574         int tagindex;
2575         matrix4x4_t tag_matrix;
2576         int returncode;
2577
2578         VM_SAFEPARMCOUNT(2, VM_SV_gettaginfo);
2579
2580         e = PRVM_G_EDICT(OFS_PARM0);
2581         tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2582
2583         returncode = SV_GetTagMatrix(&tag_matrix, e, tagindex);
2584         Matrix4x4_ToVectors(&tag_matrix, prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up, PRVM_G_VECTOR(OFS_RETURN));
2585
2586         switch(returncode)
2587         {
2588                 case 1:
2589                         VM_Warning("gettagindex: can't affect world entity\n");
2590                         break;
2591                 case 2:
2592                         VM_Warning("gettagindex: can't affect free entity\n");
2593                         break;
2594                 case 3:
2595                         Con_DPrintf("SV_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2596                         break;
2597                 case 4:
2598                         Con_DPrintf("SV_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2599                         break;
2600                 case 5:
2601                         Con_DPrintf("SV_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2602                         break;
2603         }
2604 }
2605
2606 //void(entity clent) dropclient (DP_SV_DROPCLIENT)
2607 static void VM_SV_dropclient (void)
2608 {
2609         int clientnum;
2610         client_t *oldhostclient;
2611         VM_SAFEPARMCOUNT(1, VM_SV_dropclient);
2612         clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2613         if (clientnum < 0 || clientnum >= svs.maxclients)
2614         {
2615                 VM_Warning("dropclient: not a client\n");
2616                 return;
2617         }
2618         if (!svs.clients[clientnum].active)
2619         {
2620                 VM_Warning("dropclient: that client slot is not connected\n");
2621                 return;
2622         }
2623         oldhostclient = host_client;
2624         host_client = svs.clients + clientnum;
2625         SV_DropClient(false);
2626         host_client = oldhostclient;
2627 }
2628
2629 //entity() spawnclient (DP_SV_BOTCLIENT)
2630 static void VM_SV_spawnclient (void)
2631 {
2632         int i;
2633         prvm_edict_t    *ed;
2634         VM_SAFEPARMCOUNT(0, VM_SV_spawnclient);
2635         prog->xfunction->builtinsprofile += 2;
2636         ed = prog->edicts;
2637         for (i = 0;i < svs.maxclients;i++)
2638         {
2639                 if (!svs.clients[i].active)
2640                 {
2641                         prog->xfunction->builtinsprofile += 100;
2642                         SV_ConnectClient (i, NULL);
2643                         // this has to be set or else ClientDisconnect won't be called
2644                         // we assume the qc will call ClientConnect...
2645                         svs.clients[i].clientconnectcalled = true;
2646                         ed = PRVM_EDICT_NUM(i + 1);
2647                         break;
2648                 }
2649         }
2650         VM_RETURN_EDICT(ed);
2651 }
2652
2653 //float(entity clent) clienttype (DP_SV_BOTCLIENT)
2654 static void VM_SV_clienttype (void)
2655 {
2656         int clientnum;
2657         VM_SAFEPARMCOUNT(1, VM_SV_clienttype);
2658         clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2659         if (clientnum < 0 || clientnum >= svs.maxclients)
2660                 PRVM_G_FLOAT(OFS_RETURN) = 3;
2661         else if (!svs.clients[clientnum].active)
2662                 PRVM_G_FLOAT(OFS_RETURN) = 0;
2663         else if (svs.clients[clientnum].netconnection)
2664                 PRVM_G_FLOAT(OFS_RETURN) = 1;
2665         else
2666                 PRVM_G_FLOAT(OFS_RETURN) = 2;
2667 }
2668
2669 /*
2670 ===============
2671 VM_SV_serverkey
2672
2673 string(string key) serverkey
2674 ===============
2675 */
2676 void VM_SV_serverkey(void)
2677 {
2678         char string[VM_STRINGTEMP_LENGTH];
2679         VM_SAFEPARMCOUNT(1, VM_SV_serverkey);
2680         InfoString_GetValue(svs.serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
2681         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
2682 }
2683
2684 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
2685 static void VM_SV_setmodelindex (void)
2686 {
2687         prvm_edict_t    *e;
2688         model_t *mod;
2689         int             i;
2690         VM_SAFEPARMCOUNT(2, VM_SV_setmodelindex);
2691
2692         e = PRVM_G_EDICT(OFS_PARM0);
2693         if (e == prog->edicts)
2694         {
2695                 VM_Warning("setmodelindex: can not modify world entity\n");
2696                 return;
2697         }
2698         if (e->priv.server->free)
2699         {
2700                 VM_Warning("setmodelindex: can not modify free entity\n");
2701                 return;
2702         }
2703         i = (int)PRVM_G_FLOAT(OFS_PARM1);
2704         if (i <= 0 || i > MAX_MODELS)
2705         {
2706                 VM_Warning("setmodelindex: invalid modelindex\n");
2707                 return;
2708         }
2709         if (!sv.model_precache[i][0])
2710         {
2711                 VM_Warning("setmodelindex: model not precached\n");
2712                 return;
2713         }
2714
2715         e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
2716         e->fields.server->modelindex = i;
2717
2718         mod = sv.models[i];
2719
2720         if (mod)
2721         {
2722                 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
2723                         SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
2724                 else
2725                         SetMinMaxSize (e, quakemins, quakemaxs, true);
2726         }
2727         else
2728                 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
2729 }
2730
2731 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
2732 static void VM_SV_modelnameforindex (void)
2733 {
2734         int i;
2735         VM_SAFEPARMCOUNT(1, VM_SV_modelnameforindex);
2736
2737         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2738
2739         i = (int)PRVM_G_FLOAT(OFS_PARM0);
2740         if (i <= 0 || i > MAX_MODELS)
2741         {
2742                 VM_Warning("modelnameforindex: invalid modelindex\n");
2743                 return;
2744         }
2745         if (!sv.model_precache[i][0])
2746         {
2747                 VM_Warning("modelnameforindex: model not precached\n");
2748                 return;
2749         }
2750
2751         PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(sv.model_precache[i]);
2752 }
2753
2754 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
2755 static void VM_SV_particleeffectnum (void)
2756 {
2757         int                     i;
2758         VM_SAFEPARMCOUNT(1, VM_SV_particleeffectnum);
2759         i = SV_ParticleEffectIndex(PRVM_G_STRING(OFS_PARM0));
2760         if (i == 0)
2761                 i = -1;
2762         PRVM_G_FLOAT(OFS_RETURN) = i;
2763 }
2764
2765 // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
2766 static void VM_SV_trailparticles (void)
2767 {
2768         VM_SAFEPARMCOUNT(4, VM_SV_trailparticles);
2769
2770         MSG_WriteByte(&sv.datagram, svc_trailparticles);
2771         MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2772         MSG_WriteShort(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
2773         MSG_WriteVector(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2), sv.protocol);
2774         MSG_WriteVector(&sv.datagram, PRVM_G_VECTOR(OFS_PARM3), sv.protocol);
2775         SV_FlushBroadcastMessages();
2776 }
2777
2778 //#337 void(float effectnum, vector origin, vector dir, float count) pointparticles (EXT_CSQC)
2779 static void VM_SV_pointparticles (void)
2780 {
2781         int effectnum, count;
2782         vec3_t org, vel;
2783         VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_pointparticles);
2784         effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
2785         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), org);
2786         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
2787         count = bound(0, (int)PRVM_G_FLOAT(OFS_PARM3), 65535);
2788         if (count == 1 && !VectorLength2(vel))
2789         {
2790                 // 1+2+12=15 bytes
2791                 MSG_WriteByte(&sv.datagram, svc_pointparticles1);
2792                 MSG_WriteShort(&sv.datagram, effectnum);
2793                 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2794         }
2795         else
2796         {
2797                 // 1+2+12+12+2=29 bytes
2798                 MSG_WriteByte(&sv.datagram, svc_pointparticles);
2799                 MSG_WriteShort(&sv.datagram, effectnum);
2800                 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2801                 MSG_WriteVector(&sv.datagram, vel, sv.protocol);
2802                 MSG_WriteShort(&sv.datagram, count);
2803         }
2804
2805         SV_FlushBroadcastMessages();
2806 }
2807
2808 prvm_builtin_t vm_sv_builtins[] = {
2809 NULL,                                                   // #0 NULL function (not callable) (QUAKE)
2810 VM_makevectors,                                 // #1 void(vector ang) makevectors (QUAKE)
2811 VM_SV_setorigin,                                // #2 void(entity e, vector o) setorigin (QUAKE)
2812 VM_SV_setmodel,                                 // #3 void(entity e, string m) setmodel (QUAKE)
2813 VM_SV_setsize,                                  // #4 void(entity e, vector min, vector max) setsize (QUAKE)
2814 NULL,                                                   // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
2815 VM_break,                                               // #6 void() break (QUAKE)
2816 VM_random,                                              // #7 float() random (QUAKE)
2817 VM_SV_sound,                                    // #8 void(entity e, float chan, string samp) sound (QUAKE)
2818 VM_normalize,                                   // #9 vector(vector v) normalize (QUAKE)
2819 VM_error,                                               // #10 void(string e) error (QUAKE)
2820 VM_objerror,                                    // #11 void(string e) objerror (QUAKE)
2821 VM_vlen,                                                // #12 float(vector v) vlen (QUAKE)
2822 VM_vectoyaw,                                    // #13 float(vector v) vectoyaw (QUAKE)
2823 VM_spawn,                                               // #14 entity() spawn (QUAKE)
2824 VM_remove,                                              // #15 void(entity e) remove (QUAKE)
2825 VM_SV_traceline,                                // #16 float(vector v1, vector v2, float tryents) traceline (QUAKE)
2826 VM_SV_checkclient,                              // #17 entity() checkclient (QUAKE)
2827 VM_find,                                                // #18 entity(entity start, .string fld, string match) find (QUAKE)
2828 VM_SV_precache_sound,                   // #19 void(string s) precache_sound (QUAKE)
2829 VM_SV_precache_model,                   // #20 void(string s) precache_model (QUAKE)
2830 VM_SV_stuffcmd,                                 // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
2831 VM_SV_findradius,                               // #22 entity(vector org, float rad) findradius (QUAKE)
2832 VM_bprint,                                              // #23 void(string s, ...) bprint (QUAKE)
2833 VM_SV_sprint,                                   // #24 void(entity client, string s, ...) sprint (QUAKE)
2834 VM_dprint,                                              // #25 void(string s, ...) dprint (QUAKE)
2835 VM_ftos,                                                // #26 string(float f) ftos (QUAKE)
2836 VM_vtos,                                                // #27 string(vector v) vtos (QUAKE)
2837 VM_coredump,                                    // #28 void() coredump (QUAKE)
2838 VM_traceon,                                             // #29 void() traceon (QUAKE)
2839 VM_traceoff,                                    // #30 void() traceoff (QUAKE)
2840 VM_eprint,                                              // #31 void(entity e) eprint (QUAKE)
2841 VM_SV_walkmove,                                 // #32 float(float yaw, float dist) walkmove (QUAKE)
2842 NULL,                                                   // #33 (QUAKE)
2843 VM_SV_droptofloor,                              // #34 float() droptofloor (QUAKE)
2844 VM_SV_lightstyle,                               // #35 void(float style, string value) lightstyle (QUAKE)
2845 VM_rint,                                                // #36 float(float v) rint (QUAKE)
2846 VM_floor,                                               // #37 float(float v) floor (QUAKE)
2847 VM_ceil,                                                // #38 float(float v) ceil (QUAKE)
2848 NULL,                                                   // #39 (QUAKE)
2849 VM_SV_checkbottom,                              // #40 float(entity e) checkbottom (QUAKE)
2850 VM_SV_pointcontents,                    // #41 float(vector v) pointcontents (QUAKE)
2851 NULL,                                                   // #42 (QUAKE)
2852 VM_fabs,                                                // #43 float(float f) fabs (QUAKE)
2853 VM_SV_aim,                                              // #44 vector(entity e, float speed) aim (QUAKE)
2854 VM_cvar,                                                // #45 float(string s) cvar (QUAKE)
2855 VM_localcmd,                                    // #46 void(string s) localcmd (QUAKE)
2856 VM_nextent,                                             // #47 entity(entity e) nextent (QUAKE)
2857 VM_SV_particle,                                 // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
2858 VM_changeyaw,                                   // #49 void() ChangeYaw (QUAKE)
2859 NULL,                                                   // #50 (QUAKE)
2860 VM_vectoangles,                                 // #51 vector(vector v) vectoangles (QUAKE)
2861 VM_SV_WriteByte,                                // #52 void(float to, float f) WriteByte (QUAKE)
2862 VM_SV_WriteChar,                                // #53 void(float to, float f) WriteChar (QUAKE)
2863 VM_SV_WriteShort,                               // #54 void(float to, float f) WriteShort (QUAKE)
2864 VM_SV_WriteLong,                                // #55 void(float to, float f) WriteLong (QUAKE)
2865 VM_SV_WriteCoord,                               // #56 void(float to, float f) WriteCoord (QUAKE)
2866 VM_SV_WriteAngle,                               // #57 void(float to, float f) WriteAngle (QUAKE)
2867 VM_SV_WriteString,                              // #58 void(float to, string s) WriteString (QUAKE)
2868 VM_SV_WriteEntity,                              // #59 void(float to, entity e) WriteEntity (QUAKE)
2869 VM_sin,                                                 // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW) (QUAKE)
2870 VM_cos,                                                 // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW) (QUAKE)
2871 VM_sqrt,                                                // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW) (QUAKE)
2872 VM_changepitch,                                 // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH) (QUAKE)
2873 VM_SV_tracetoss,                                // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS) (QUAKE)
2874 VM_etos,                                                // #65 string(entity ent) etos (DP_QC_ETOS) (QUAKE)
2875 NULL,                                                   // #66 (QUAKE)
2876 SV_MoveToGoal,                                  // #67 void(float step) movetogoal (QUAKE)
2877 VM_precache_file,                               // #68 string(string s) precache_file (QUAKE)
2878 VM_SV_makestatic,                               // #69 void(entity e) makestatic (QUAKE)
2879 VM_changelevel,                                 // #70 void(string s) changelevel (QUAKE)
2880 NULL,                                                   // #71 (QUAKE)
2881 VM_cvar_set,                                    // #72 void(string var, string val) cvar_set (QUAKE)
2882 VM_SV_centerprint,                              // #73 void(entity client, strings) centerprint (QUAKE)
2883 VM_SV_ambientsound,                             // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
2884 VM_SV_precache_model,                   // #75 string(string s) precache_model2 (QUAKE)
2885 VM_SV_precache_sound,                   // #76 string(string s) precache_sound2 (QUAKE)
2886 VM_precache_file,                               // #77 string(string s) precache_file2 (QUAKE)
2887 VM_SV_setspawnparms,                    // #78 void(entity e) setspawnparms (QUAKE)
2888 NULL,                                                   // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
2889 NULL,                                                   // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
2890 VM_stof,                                                // #81 float(string s) stof (FRIK_FILE)
2891 NULL,                                                   // #82 void(vector where, float set) multicast (QUAKEWORLD)
2892 NULL,                                                   // #83 (QUAKE)
2893 NULL,                                                   // #84 (QUAKE)
2894 NULL,                                                   // #85 (QUAKE)
2895 NULL,                                                   // #86 (QUAKE)
2896 NULL,                                                   // #87 (QUAKE)
2897 NULL,                                                   // #88 (QUAKE)
2898 NULL,                                                   // #89 (QUAKE)
2899 VM_SV_tracebox,                                 // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
2900 VM_randomvec,                                   // #91 vector() randomvec (DP_QC_RANDOMVEC)
2901 VM_SV_getlight,                                 // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
2902 VM_registercvar,                                // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
2903 VM_min,                                                 // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
2904 VM_max,                                                 // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
2905 VM_bound,                                               // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
2906 VM_pow,                                                 // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
2907 VM_findfloat,                                   // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
2908 VM_checkextension,                              // #99 float(string s) checkextension (the basis of the extension system)
2909 // FrikaC and Telejano range  #100-#199
2910 NULL,                                                   // #100
2911 NULL,                                                   // #101
2912 NULL,                                                   // #102
2913 NULL,                                                   // #103
2914 NULL,                                                   // #104
2915 NULL,                                                   // #105
2916 NULL,                                                   // #106
2917 NULL,                                                   // #107
2918 NULL,                                                   // #108
2919 NULL,                                                   // #109
2920 VM_fopen,                                               // #110 float(string filename, float mode) fopen (FRIK_FILE)
2921 VM_fclose,                                              // #111 void(float fhandle) fclose (FRIK_FILE)
2922 VM_fgets,                                               // #112 string(float fhandle) fgets (FRIK_FILE)
2923 VM_fputs,                                               // #113 void(float fhandle, string s) fputs (FRIK_FILE)
2924 VM_strlen,                                              // #114 float(string s) strlen (FRIK_FILE)
2925 VM_strcat,                                              // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
2926 VM_substring,                                   // #116 string(string s, float start, float length) substring (FRIK_FILE)
2927 VM_stov,                                                // #117 vector(string) stov (FRIK_FILE)
2928 VM_strzone,                                             // #118 string(string s) strzone (FRIK_FILE)
2929 VM_strunzone,                                   // #119 void(string s) strunzone (FRIK_FILE)
2930 NULL,                                                   // #120
2931 NULL,                                                   // #121
2932 NULL,                                                   // #122
2933 NULL,                                                   // #123
2934 NULL,                                                   // #124
2935 NULL,                                                   // #125
2936 NULL,                                                   // #126
2937 NULL,                                                   // #127
2938 NULL,                                                   // #128
2939 NULL,                                                   // #129
2940 NULL,                                                   // #130
2941 NULL,                                                   // #131
2942 NULL,                                                   // #132
2943 NULL,                                                   // #133
2944 NULL,                                                   // #134
2945 NULL,                                                   // #135
2946 NULL,                                                   // #136
2947 NULL,                                                   // #137
2948 NULL,                                                   // #138
2949 NULL,                                                   // #139
2950 NULL,                                                   // #140
2951 NULL,                                                   // #141
2952 NULL,                                                   // #142
2953 NULL,                                                   // #143
2954 NULL,                                                   // #144
2955 NULL,                                                   // #145
2956 NULL,                                                   // #146
2957 NULL,                                                   // #147
2958 NULL,                                                   // #148
2959 NULL,                                                   // #149
2960 NULL,                                                   // #150
2961 NULL,                                                   // #151
2962 NULL,                                                   // #152
2963 NULL,                                                   // #153
2964 NULL,                                                   // #154
2965 NULL,                                                   // #155
2966 NULL,                                                   // #156
2967 NULL,                                                   // #157
2968 NULL,                                                   // #158
2969 NULL,                                                   // #159
2970 NULL,                                                   // #160
2971 NULL,                                                   // #161
2972 NULL,                                                   // #162
2973 NULL,                                                   // #163
2974 NULL,                                                   // #164
2975 NULL,                                                   // #165
2976 NULL,                                                   // #166
2977 NULL,                                                   // #167
2978 NULL,                                                   // #168
2979 NULL,                                                   // #169
2980 NULL,                                                   // #170
2981 NULL,                                                   // #171
2982 NULL,                                                   // #172
2983 NULL,                                                   // #173
2984 NULL,                                                   // #174
2985 NULL,                                                   // #175
2986 NULL,                                                   // #176
2987 NULL,                                                   // #177
2988 NULL,                                                   // #178
2989 NULL,                                                   // #179
2990 NULL,                                                   // #180
2991 NULL,                                                   // #181
2992 NULL,                                                   // #182
2993 NULL,                                                   // #183
2994 NULL,                                                   // #184
2995 NULL,                                                   // #185
2996 NULL,                                                   // #186
2997 NULL,                                                   // #187
2998 NULL,                                                   // #188
2999 NULL,                                                   // #189
3000 NULL,                                                   // #190
3001 NULL,                                                   // #191
3002 NULL,                                                   // #192
3003 NULL,                                                   // #193
3004 NULL,                                                   // #194
3005 NULL,                                                   // #195
3006 NULL,                                                   // #196
3007 NULL,                                                   // #197
3008 NULL,                                                   // #198
3009 NULL,                                                   // #199
3010 // FTEQW range #200-#299
3011 NULL,                                                   // #200
3012 NULL,                                                   // #201
3013 NULL,                                                   // #202
3014 NULL,                                                   // #203
3015 NULL,                                                   // #204
3016 NULL,                                                   // #205
3017 NULL,                                                   // #206
3018 NULL,                                                   // #207
3019 NULL,                                                   // #208
3020 NULL,                                                   // #209
3021 NULL,                                                   // #210
3022 NULL,                                                   // #211
3023 NULL,                                                   // #212
3024 NULL,                                                   // #213
3025 NULL,                                                   // #214
3026 NULL,                                                   // #215
3027 NULL,                                                   // #216
3028 NULL,                                                   // #217
3029 VM_bitshift,                                    // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
3030 NULL,                                                   // #219
3031 NULL,                                                   // #220
3032 VM_strstrofs,                                   // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
3033 VM_str2chr,                                             // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
3034 VM_chr2str,                                             // #223 string(float c, ...) chr2str (FTE_STRINGS)
3035 VM_strconv,                                             // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
3036 VM_strpad,                                              // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
3037 VM_infoadd,                                             // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
3038 VM_infoget,                                             // #227 string(string info, string key) infoget (FTE_STRINGS)
3039 VM_strncmp,                                             // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
3040 VM_strncasecmp,                                 // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
3041 VM_strncasecmp,                                 // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
3042 NULL,                                                   // #231
3043 VM_SV_AddStat,                                  // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
3044 NULL,                                                   // #233
3045 NULL,                                                   // #234
3046 NULL,                                                   // #235
3047 NULL,                                                   // #236
3048 NULL,                                                   // #237
3049 NULL,                                                   // #238
3050 NULL,                                                   // #239
3051 NULL,                                                   // #240
3052 NULL,                                                   // #241
3053 NULL,                                                   // #242
3054 NULL,                                                   // #243
3055 NULL,                                                   // #244
3056 NULL,                                                   // #245
3057 NULL,                                                   // #246
3058 NULL,                                                   // #247
3059 NULL,                                                   // #248
3060 NULL,                                                   // #249
3061 NULL,                                                   // #250
3062 NULL,                                                   // #251
3063 NULL,                                                   // #252
3064 NULL,                                                   // #253
3065 NULL,                                                   // #254
3066 NULL,                                                   // #255
3067 NULL,                                                   // #256
3068 NULL,                                                   // #257
3069 NULL,                                                   // #258
3070 NULL,                                                   // #259
3071 NULL,                                                   // #260
3072 NULL,                                                   // #261
3073 NULL,                                                   // #262
3074 NULL,                                                   // #263
3075 NULL,                                                   // #264
3076 NULL,                                                   // #265
3077 NULL,                                                   // #266
3078 NULL,                                                   // #267
3079 NULL,                                                   // #268
3080 NULL,                                                   // #269
3081 NULL,                                                   // #270
3082 NULL,                                                   // #271
3083 NULL,                                                   // #272
3084 NULL,                                                   // #273
3085 NULL,                                                   // #274
3086 NULL,                                                   // #275
3087 NULL,                                                   // #276
3088 NULL,                                                   // #277
3089 NULL,                                                   // #278
3090 NULL,                                                   // #279
3091 NULL,                                                   // #280
3092 NULL,                                                   // #281
3093 NULL,                                                   // #282
3094 NULL,                                                   // #283
3095 NULL,                                                   // #284
3096 NULL,                                                   // #285
3097 NULL,                                                   // #286
3098 NULL,                                                   // #287
3099 NULL,                                                   // #288
3100 NULL,                                                   // #289
3101 NULL,                                                   // #290
3102 NULL,                                                   // #291
3103 NULL,                                                   // #292
3104 NULL,                                                   // #293
3105 NULL,                                                   // #294
3106 NULL,                                                   // #295
3107 NULL,                                                   // #296
3108 NULL,                                                   // #297
3109 NULL,                                                   // #298
3110 NULL,                                                   // #299
3111 // CSQC range #300-#399
3112 NULL,                                                   // #300 void() clearscene (EXT_CSQC)
3113 NULL,                                                   // #301 void(float mask) addentities (EXT_CSQC)
3114 NULL,                                                   // #302 void(entity ent) addentity (EXT_CSQC)
3115 NULL,                                                   // #303 float(float property, ...) setproperty (EXT_CSQC)
3116 NULL,                                                   // #304 void() renderscene (EXT_CSQC)
3117 NULL,                                                   // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
3118 NULL,                                                   // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
3119 NULL,                                                   // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3120 NULL,                                                   // #308 void() R_EndPolygon
3121 NULL,                                                   // #309
3122 NULL,                                                   // #310 vector (vector v) cs_unproject (EXT_CSQC)
3123 NULL,                                                   // #311 vector (vector v) cs_project (EXT_CSQC)
3124 NULL,                                                   // #312
3125 NULL,                                                   // #313
3126 NULL,                                                   // #314
3127 NULL,                                                   // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
3128 NULL,                                                   // #316 float(string name) iscachedpic (EXT_CSQC)
3129 NULL,                                                   // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
3130 NULL,                                                   // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
3131 NULL,                                                   // #319 void(string name) freepic (EXT_CSQC)
3132 NULL,                                                   // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
3133 NULL,                                                   // #321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
3134 NULL,                                                   // #322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
3135 NULL,                                                   // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
3136 NULL,                                                   // #324 void(float x, float y, float width, float height) drawsetcliparea
3137 NULL,                                                   // #325 void(void) drawresetcliparea
3138 NULL,                                                   // #326
3139 NULL,                                                   // #327
3140 NULL,                                                   // #328
3141 NULL,                                                   // #329
3142 NULL,                                                   // #330 float(float stnum) getstatf (EXT_CSQC)
3143 NULL,                                                   // #331 float(float stnum) getstati (EXT_CSQC)
3144 NULL,                                                   // #332 string(float firststnum) getstats (EXT_CSQC)
3145 VM_SV_setmodelindex,                    // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
3146 VM_SV_modelnameforindex,                // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
3147 VM_SV_particleeffectnum,                // #335 float(string effectname) particleeffectnum (EXT_CSQC)
3148 VM_SV_trailparticles,                   // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
3149 VM_SV_pointparticles,                   // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
3150 NULL,                                                   // #338 void(string s, ...) centerprint (EXT_CSQC)
3151 VM_print,                                               // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
3152 NULL,                                                   // #340 string(float keynum) keynumtostring (EXT_CSQC)
3153 NULL,                                                   // #341 float(string keyname) stringtokeynum (EXT_CSQC)
3154 NULL,                                                   // #342 string(float keynum) getkeybind (EXT_CSQC)
3155 NULL,                                                   // #343 void(float usecursor) setcursormode (EXT_CSQC)
3156 NULL,                                                   // #344 vector() getmousepos (EXT_CSQC)
3157 NULL,                                                   // #345 float(float framenum) getinputstate (EXT_CSQC)
3158 NULL,                                                   // #346 void(float sens) setsensitivityscaler (EXT_CSQC)
3159 NULL,                                                   // #347 void() runstandardplayerphysics (EXT_CSQC)
3160 NULL,                                                   // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
3161 NULL,                                                   // #349 float() isdemo (EXT_CSQC)
3162 VM_isserver,                                    // #350 float() isserver (EXT_CSQC)
3163 NULL,                                                   // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
3164 NULL,                                                   // #352 void(string cmdname) registercommand (EXT_CSQC)
3165 VM_wasfreed,                                    // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
3166 VM_SV_serverkey,                                // #354 string(string key) serverkey (EXT_CSQC)
3167 NULL,                                                   // #355
3168 NULL,                                                   // #356
3169 NULL,                                                   // #357
3170 NULL,                                                   // #358
3171 NULL,                                                   // #359
3172 NULL,                                                   // #360 float() readbyte (EXT_CSQC)
3173 NULL,                                                   // #361 float() readchar (EXT_CSQC)
3174 NULL,                                                   // #362 float() readshort (EXT_CSQC)
3175 NULL,                                                   // #363 float() readlong (EXT_CSQC)
3176 NULL,                                                   // #364 float() readcoord (EXT_CSQC)
3177 NULL,                                                   // #365 float() readangle (EXT_CSQC)
3178 NULL,                                                   // #366 string() readstring (EXT_CSQC)
3179 NULL,                                                   // #367 float() readfloat (EXT_CSQC)
3180 NULL,                                                   // #368
3181 NULL,                                                   // #369
3182 NULL,                                                   // #370
3183 NULL,                                                   // #371
3184 NULL,                                                   // #372
3185 NULL,                                                   // #373
3186 NULL,                                                   // #374
3187 NULL,                                                   // #375
3188 NULL,                                                   // #376
3189 NULL,                                                   // #377
3190 NULL,                                                   // #378
3191 NULL,                                                   // #379
3192 NULL,                                                   // #380
3193 NULL,                                                   // #381
3194 NULL,                                                   // #382
3195 NULL,                                                   // #383
3196 NULL,                                                   // #384
3197 NULL,                                                   // #385
3198 NULL,                                                   // #386
3199 NULL,                                                   // #387
3200 NULL,                                                   // #388
3201 NULL,                                                   // #389
3202 NULL,                                                   // #390
3203 NULL,                                                   // #391
3204 NULL,                                                   // #392
3205 NULL,                                                   // #393
3206 NULL,                                                   // #394
3207 NULL,                                                   // #395
3208 NULL,                                                   // #396
3209 NULL,                                                   // #397
3210 NULL,                                                   // #398
3211 NULL,                                                   // #399
3212 // LordHavoc's range #400-#499
3213 VM_SV_copyentity,                               // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
3214 VM_SV_setcolor,                                 // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
3215 VM_findchain,                                   // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
3216 VM_findchainfloat,                              // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
3217 VM_SV_effect,                                   // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
3218 VM_SV_te_blood,                                 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
3219 VM_SV_te_bloodshower,                   // #406 void(vector mincorner,