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