Debian Codegraph @

svvm_cmds.c

raw ◀ ▶
Source reconstructed at patch state 0 of 1 — not the installed (fully patched) source.
1 Debian patch touch this file
1 #include "quakedef.h"
2
3 #include "prvm_cmds.h"
4 #include "jpeg.h"
5
6 //============================================================================
7 // Server
8
9
10
11 const char *vm_sv_extensions =
12 "BX_WAL_SUPPORT "
13 "DP_BUTTONCHAT "
14 "DP_BUTTONUSE "
15 "DP_CL_LOADSKY "
16 "DP_CON_ALIASPARAMETERS "
17 "DP_CON_BESTWEAPON "
18 "DP_CON_EXPANDCVAR "
19 "DP_CON_SET "
20 "DP_CON_SETA "
21 "DP_CON_STARTMAP "
22 "DP_COVERAGE "
23 "DP_CRYPTO "
24 "DP_CSQC_BINDMAPS "
25 "DP_CSQC_ENTITYWORLDOBJECT "
26 "DP_CSQC_ENTITYMODELLIGHT "
27 "DP_CSQC_ENTITYTRANSPARENTSORTING_OFFSET "
28 "DP_CSQC_MAINVIEW "
29 "DP_CSQC_MINFPS_QUALITY "
30 "DP_CSQC_MULTIFRAME_INTERPOLATION "
31 "DP_CSQC_BOXPARTICLES "
32 "DP_CSQC_SPAWNPARTICLE "
33 "DP_CSQC_QUERYRENDERENTITY "
34 "DP_CSQC_ROTATEMOVES "
35 "DP_CSQC_SETPAUSE "
36 "DP_CSQC_V_CALCREFDEF_WIP1 "
37 "DP_CSQC_V_CALCREFDEF_WIP2 "
38 "DP_EF_ADDITIVE "
39 "DP_EF_BLUE "
40 "DP_EF_DOUBLESIDED "
41 "DP_EF_DYNAMICMODELLIGHT "
42 "DP_EF_FLAME "
43 "DP_EF_FULLBRIGHT "
44 "DP_EF_NODEPTHTEST "
45 "DP_EF_NODRAW "
46 "DP_EF_NOGUNBOB "
47 "DP_EF_NOSELFSHADOW "
48 "DP_EF_NOSHADOW "
49 "DP_EF_RED "
50 "DP_EF_RESTARTANIM_BIT "
51 "DP_EF_STARDUST "
52 "DP_EF_TELEPORT_BIT "
53 "DP_ENT_ALPHA "
54 "DP_ENT_COLORMOD "
55 "DP_ENT_CUSTOMCOLORMAP "
56 "DP_ENT_EXTERIORMODELTOCLIENT "
57 "DP_ENT_GLOW "
58 "DP_ENT_GLOWMOD "
59 "DP_ENT_LOWPRECISION "
60 "DP_ENT_SCALE "
61 "DP_ENT_TRAILEFFECTNUM "
62 "DP_ENT_VIEWMODEL "
63 "DP_GFX_EXTERNALTEXTURES "
64 "DP_GFX_EXTERNALTEXTURES_PERMAP "
65 "DP_GFX_FOG "
66 "DP_GFX_MODEL_INTERPOLATION "
67 "DP_GFX_QUAKE3MODELTAGS "
68 "DP_GFX_SKINFILES "
69 "DP_GFX_SKYBOX "
70 "DP_GFX_FONTS "
71 "DP_GFX_FONTS_FREETYPE "
72 "DP_UTF8 "
73 "DP_FONT_VARIABLEWIDTH "
74 "DP_HALFLIFE_MAP "
75 "DP_HALFLIFE_MAP_CVAR "
76 "DP_HALFLIFE_SPRITE "
77 "DP_INPUTBUTTONS "
78 "DP_LIGHTSTYLE_STATICVALUE "
79 "DP_LITSPRITES "
80 "DP_LITSUPPORT "
81 "DP_MONSTERWALK "
82 "DP_MOVETYPEBOUNCEMISSILE "
83 "DP_MOVETYPEFLYWORLDONLY "
84 "DP_MOVETYPEFOLLOW "
85 "DP_NULL_MODEL "
86 "DP_QC_ASINACOSATANATAN2TAN "
87 "DP_QC_AUTOCVARS "
88 "DP_QC_CHANGEPITCH "
89 "DP_QC_CMD "
90 "DP_QC_COPYENTITY "
91 "DP_QC_CRC16 "
92 "DP_QC_CVAR_DEFSTRING "
93 "DP_QC_CVAR_DESCRIPTION "
94 "DP_QC_CVAR_STRING "
95 "DP_QC_CVAR_TYPE "
96 "DP_QC_DIGEST "
97 "DP_QC_DIGEST_SHA256 "
98 "DP_QC_EDICT_NUM "
99 "DP_QC_ENTITYDATA "
100 "DP_QC_ENTITYSTRING "
101 "DP_QC_ETOS "
102 "DP_QC_EXTRESPONSEPACKET "
103 "DP_QC_FINDCHAIN "
104 "DP_QC_FINDCHAINFLAGS "
105 "DP_QC_FINDCHAINFLOAT "
106 "DP_QC_FINDCHAIN_TOFIELD "
107 "DP_QC_FINDFLAGS "
108 "DP_QC_FINDFLOAT "
109 "DP_QC_FS_SEARCH "
110 "DP_QC_GETLIGHT "
111 "DP_QC_GETSURFACE "
112 "DP_QC_GETSURFACETRIANGLE "
113 "DP_QC_GETSURFACEPOINTATTRIBUTE "
114 "DP_QC_GETTAGINFO "
115 "DP_QC_GETTAGINFO_BONEPROPERTIES "
116 "DP_QC_GETTIME "
117 "DP_QC_GETTIME_CDTRACK "
118 "DP_QC_I18N "
119 "DP_QC_LOG "
120 "DP_QC_MINMAXBOUND "
121 "DP_QC_MULTIPLETEMPSTRINGS "
122 "DP_QC_NUM_FOR_EDICT "
123 "DP_QC_RANDOMVEC "
124 "DP_QC_SINCOSSQRTPOW "
125 "DP_QC_SPRINTF "
126 "DP_QC_STRFTIME "
127 "DP_QC_STRINGBUFFERS "
128 "DP_QC_STRINGBUFFERS_CVARLIST "
129 "DP_QC_STRINGBUFFERS_EXT_WIP "
130 "DP_QC_STRINGCOLORFUNCTIONS "
131 "DP_QC_STRING_CASE_FUNCTIONS "
132 "DP_QC_STRREPLACE "
133 "DP_QC_TOKENIZEBYSEPARATOR "
134 "DP_QC_TOKENIZE_CONSOLE "
135 "DP_QC_TRACEBOX "
136 "DP_QC_TRACETOSS "
137 "DP_QC_TRACE_MOVETYPE_HITMODEL "
138 "DP_QC_TRACE_MOVETYPE_WORLDONLY "
139 "DP_QC_UNLIMITEDTEMPSTRINGS "
140 "DP_QC_URI_ESCAPE "
141 "DP_QC_URI_GET "
142 "DP_QC_URI_POST "
143 "DP_QC_VECTOANGLES_WITH_ROLL "
144 "DP_QC_VECTORVECTORS "
145 "DP_QC_WHICHPACK "
146 "DP_QUAKE2_MODEL "
147 "DP_QUAKE2_SPRITE "
148 "DP_QUAKE3_MAP "
149 "DP_QUAKE3_MODEL "
150 "DP_REGISTERCVAR "
151 "DP_SKELETONOBJECTS "
152 "DP_SND_DIRECTIONLESSATTNNONE "
153 "DP_SND_FAKETRACKS "
154 "DP_SND_SOUND7_WIP1 "
155 "DP_SND_SOUND7_WIP2 "
156 "DP_SND_OGGVORBIS "
157 "DP_SND_SETPARAMS "
158 "DP_SND_STEREOWAV "
159 "DP_SND_GETSOUNDTIME "
160 "DP_VIDEO_DPV "
161 "DP_VIDEO_SUBTITLES "
162 "DP_SOLIDCORPSE "
163 "DP_SPRITE32 "
164 "DP_SV_BOTCLIENT "
165 "DP_SV_BOUNCEFACTOR "
166 "DP_SV_CLIENTCAMERA "
167 "DP_SV_CLIENTCOLORS "
168 "DP_SV_CLIENTNAME "
169 "DP_SV_CMD "
170 "DP_SV_CUSTOMIZEENTITYFORCLIENT "
171 "DP_SV_DISABLECLIENTPREDICTION "
172 "DP_SV_DISCARDABLEDEMO "
173 "DP_SV_DRAWONLYTOCLIENT "
174 "DP_SV_DROPCLIENT "
175 "DP_SV_EFFECT "
176 "DP_SV_ENTITYCONTENTSTRANSITION "
177 "DP_SV_MODELFLAGS_AS_EFFECTS "
178 "DP_SV_MOVETYPESTEP_LANDEVENT "
179 "DP_SV_NETADDRESS "
180 "DP_SV_NODRAWTOCLIENT "
181 "DP_SV_ONENTITYNOSPAWNFUNCTION "
182 "DP_SV_ONENTITYPREPOSTSPAWNFUNCTION "
183 "DP_SV_PING "
184 "DP_SV_PING_PACKETLOSS "
185 "DP_SV_PLAYERPHYSICS "
186 "DP_PHYSICS_ODE "
187 "DP_SV_POINTPARTICLES "
188 "DP_SV_POINTSOUND "
189 "DP_SV_PRECACHEANYTIME "
190 "DP_SV_PRINT "
191 "DP_SV_PUNCHVECTOR "
192 "DP_SV_QCSTATUS "
193 "DP_SV_ROTATINGBMODEL "
194 "DP_SV_SETCOLOR "
195 "DP_SV_SHUTDOWN "
196 "DP_SV_SLOWMO "
197 "DP_SV_SPAWNFUNC_PREFIX "
198 "DP_SV_WRITEPICTURE "
199 "DP_SV_WRITEUNTERMINATEDSTRING "
200 "DP_TE_BLOOD "
201 "DP_TE_BLOODSHOWER "
202 "DP_TE_CUSTOMFLASH "
203 "DP_TE_EXPLOSIONRGB "
204 "DP_TE_FLAMEJET "
205 "DP_TE_PARTICLECUBE "
206 "DP_TE_PARTICLERAIN "
207 "DP_TE_PARTICLESNOW "
208 "DP_TE_PLASMABURN "
209 "DP_TE_QUADEFFECTS1 "
210 "DP_TE_SMALLFLASH "
211 "DP_TE_SPARK "
212 "DP_TE_STANDARDEFFECTBUILTINS "
213 "DP_TRACE_HITCONTENTSMASK_SURFACEINFO "
214 "DP_USERMOVETYPES "
215 "DP_VIEWZOOM "
216 "EXT_BITSHIFT "
217 "FRIK_FILE "
218 "FTE_CSQC_SKELETONOBJECTS "
219 "FTE_QC_CHECKPVS "
220 "FTE_STRINGS "
221 "KRIMZON_SV_PARSECLIENTCOMMAND "
222 "NEH_CMD_PLAY2 "
223 "NEH_RESTOREGAME "
224 "NEXUIZ_PLAYERMODEL "
225 "NXQ_GFX_LETTERBOX "
226 "PRYDON_CLIENTCURSOR "
227 "TENEBRAE_GFX_DLIGHTS "
228 "TW_SV_STEPCONTROL "
229 "ZQ_PAUSE "
230 //"EXT_CSQC " // not ready yet
231 ;
232
233 /*
234 =================
235 VM_SV_setorigin
236
237 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.
238
239 setorigin (entity, origin)
240 =================
241 */
242 static void VM_SV_setorigin(prvm_prog_t *prog)
243 {
244 prvm_edict_t *e;
245
246 VM_SAFEPARMCOUNT(2, VM_setorigin);
247
248 e = PRVM_G_EDICT(OFS_PARM0);
249 if (e == prog->edicts)
250 {
251 VM_Warning(prog, "setorigin: can not modify world entity\n");
252 return;
253 }
254 if (e->priv.server->free)
255 {
256 VM_Warning(prog, "setorigin: can not modify free entity\n");
257 return;
258 }
259 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), PRVM_serveredictvector(e, origin));
260 if(e->priv.required->mark == PRVM_EDICT_MARK_WAIT_FOR_SETORIGIN)
261 e->priv.required->mark = PRVM_EDICT_MARK_SETORIGIN_CAUGHT;
262 SV_LinkEdict(e);
263 }
264
265 // TODO: rotate param isnt used.. could be a bug. please check this and remove it if possible [1/10/2008 Black]
266 static void SetMinMaxSize (prvm_prog_t *prog, prvm_edict_t *e, float *min, float *max, qboolean rotate)
267 {
268 int i;
269
270 for (i=0 ; i<3 ; i++)
271 if (min[i] > max[i])
272 prog->error_cmd("SetMinMaxSize: backwards mins/maxs");
273
274 // set derived values
275 VectorCopy (min, PRVM_serveredictvector(e, mins));
276 VectorCopy (max, PRVM_serveredictvector(e, maxs));
277 VectorSubtract (max, min, PRVM_serveredictvector(e, size));
278
279 SV_LinkEdict(e);
280 }
281
282 /*
283 =================
284 VM_SV_setsize
285
286 the size box is rotated by the current angle
287 LordHavoc: no it isn't...
288
289 setsize (entity, minvector, maxvector)
290 =================
291 */
292 static void VM_SV_setsize(prvm_prog_t *prog)
293 {
294 prvm_edict_t *e;
295 vec3_t mins, maxs;
296
297 VM_SAFEPARMCOUNT(3, VM_setsize);
298
299 e = PRVM_G_EDICT(OFS_PARM0);
300 if (e == prog->edicts)
301 {
302 VM_Warning(prog, "setsize: can not modify world entity\n");
303 return;
304 }
305 if (e->priv.server->free)
306 {
307 VM_Warning(prog, "setsize: can not modify free entity\n");
308 return;
309 }
310 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), mins);
311 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), maxs);
312 SetMinMaxSize(prog, e, mins, maxs, false);
313 }
314
315
316 /*
317 =================
318 VM_SV_setmodel
319
320 setmodel(entity, model)
321 =================
322 */
323 static vec3_t quakemins = {-16, -16, -16}, quakemaxs = {16, 16, 16};
324 static void VM_SV_setmodel(prvm_prog_t *prog)
325 {
326 prvm_edict_t *e;
327 dp_model_t *mod;
328 int i;
329
330 VM_SAFEPARMCOUNT(2, VM_setmodel);
331
332 e = PRVM_G_EDICT(OFS_PARM0);
333 if (e == prog->edicts)
334 {
335 VM_Warning(prog, "setmodel: can not modify world entity\n");
336 return;
337 }
338 if (e->priv.server->free)
339 {
340 VM_Warning(prog, "setmodel: can not modify free entity\n");
341 return;
342 }
343 i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);
344 PRVM_serveredictstring(e, model) = PRVM_SetEngineString(prog, sv.model_precache[i]);
345 PRVM_serveredictfloat(e, modelindex) = i;
346
347 mod = SV_GetModelByIndex(i);
348
349 if (mod)
350 {
351 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
352 SetMinMaxSize(prog, e, mod->normalmins, mod->normalmaxs, true);
353 else
354 SetMinMaxSize(prog, e, quakemins, quakemaxs, true);
355 }
356 else
357 SetMinMaxSize(prog, e, vec3_origin, vec3_origin, true);
358 }
359
360 /*
361 =================
362 VM_SV_sprint
363
364 single print to a specific client
365
366 sprint(clientent, value)
367 =================
368 */
369 static void VM_SV_sprint(prvm_prog_t *prog)
370 {
371 client_t *client;
372 int entnum;
373 char string[VM_STRINGTEMP_LENGTH];
374
375 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_sprint);
376
377 VM_VarString(prog, 1, string, sizeof(string));
378
379 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
380 // LordHavoc: div0 requested that sprintto world operate like print
381 if (entnum == 0)
382 {
383 Con_Print(string);
384 return;
385 }
386
387 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
388 {
389 VM_Warning(prog, "tried to centerprint to a non-client\n");
390 return;
391 }
392
393 client = svs.clients + entnum-1;
394 if (!client->netconnection)
395 return;
396
397 MSG_WriteChar(&client->netconnection->message,svc_print);
398 MSG_WriteString(&client->netconnection->message, string);
399 }
400
401
402 /*
403 =================
404 VM_SV_centerprint
405
406 single print to a specific client
407
408 centerprint(clientent, value)
409 =================
410 */
411 static void VM_SV_centerprint(prvm_prog_t *prog)
412 {
413 client_t *client;
414 int entnum;
415 char string[VM_STRINGTEMP_LENGTH];
416
417 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_centerprint);
418
419 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
420
421 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
422 {
423 VM_Warning(prog, "tried to centerprint to a non-client\n");
424 return;
425 }
426
427 client = svs.clients + entnum-1;
428 if (!client->netconnection)
429 return;
430
431 VM_VarString(prog, 1, string, sizeof(string));
432 MSG_WriteChar(&client->netconnection->message,svc_centerprint);
433 MSG_WriteString(&client->netconnection->message, string);
434 }
435
436 /*
437 =================
438 VM_SV_particle
439
440 particle(origin, color, count)
441 =================
442 */
443 static void VM_SV_particle(prvm_prog_t *prog)
444 {
445 vec3_t org, dir;
446 int color;
447 int count;
448
449 VM_SAFEPARMCOUNT(4, VM_SV_particle);
450
451 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
452 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), dir);
453 color = (int)PRVM_G_FLOAT(OFS_PARM2);
454 count = (int)PRVM_G_FLOAT(OFS_PARM3);
455 SV_StartParticle (org, dir, color, count);
456 }
457
458
459 /*
460 =================
461 VM_SV_ambientsound
462
463 =================
464 */
465 static void VM_SV_ambientsound(prvm_prog_t *prog)
466 {
467 const char *samp;
468 vec3_t pos;
469 prvm_vec_t vol, attenuation;
470 int soundnum, large;
471
472 VM_SAFEPARMCOUNT(4, VM_SV_ambientsound);
473
474 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
475 samp = PRVM_G_STRING(OFS_PARM1);
476 vol = PRVM_G_FLOAT(OFS_PARM2);
477 attenuation = PRVM_G_FLOAT(OFS_PARM3);
478
479 // check to see if samp was properly precached
480 soundnum = SV_SoundIndex(samp, 1);
481 if (!soundnum)
482 return;
483
484 large = false;
485 if (soundnum >= 256)
486 large = true;
487
488 // add an svc_spawnambient command to the level signon packet
489
490 if (large)
491 MSG_WriteByte (&sv.signon, svc_spawnstaticsound2);
492 else
493 MSG_WriteByte (&sv.signon, svc_spawnstaticsound);
494
495 MSG_WriteVector(&sv.signon, pos, sv.protocol);
496
497 if (large || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
498 MSG_WriteShort (&sv.signon, soundnum);
499 else
500 MSG_WriteByte (&sv.signon, soundnum);
501
502 MSG_WriteByte (&sv.signon, (int)(vol*255));
503 MSG_WriteByte (&sv.signon, (int)(attenuation*64));
504
505 }
506
507 /*
508 =================
509 VM_SV_sound
510
511 Each entity can have eight independant sound sources, like voice,
512 weapon, feet, etc.
513
514 Channel 0 is an auto-allocate channel, the others override anything
515 already running on that entity/channel pair.
516
517 An attenuation of 0 will play full volume everywhere in the level.
518 Larger attenuations will drop off.
519
520 =================
521 */
522 static void VM_SV_sound(prvm_prog_t *prog)
523 {
524 const char *sample;
525 int channel;
526 prvm_edict_t *entity;
527 int nvolume;
528 int flags;
529 float attenuation;
530 float pitchchange;
531
532 VM_SAFEPARMCOUNTRANGE(4, 7, VM_SV_sound);
533
534 entity = PRVM_G_EDICT(OFS_PARM0);
535 channel = (int)PRVM_G_FLOAT(OFS_PARM1);
536 sample = PRVM_G_STRING(OFS_PARM2);
537 nvolume = (int)(PRVM_G_FLOAT(OFS_PARM3) * 255);
538 if (prog->argc < 5)
539 {
540 Con_DPrintf("VM_SV_sound: given only 4 parameters, expected 5, assuming attenuation = ATTN_NORMAL\n");
541 attenuation = 1;
542 }
543 else
544 attenuation = PRVM_G_FLOAT(OFS_PARM4);
545 if (prog->argc < 6)
546 pitchchange = 0;
547 else
548 pitchchange = PRVM_G_FLOAT(OFS_PARM5) * 0.01f;
549
550 if (prog->argc < 7)
551 {
552 flags = 0;
553 if(channel >= 8 && channel <= 15) // weird QW feature
554 {
555 flags |= CHANNELFLAG_RELIABLE;
556 channel -= 8;
557 }
558 }
559 else
560 {
561 // LordHavoc: we only let the qc set certain flags, others are off-limits
562 flags = (int)PRVM_G_FLOAT(OFS_PARM6) & (CHANNELFLAG_RELIABLE | CHANNELFLAG_FORCELOOP | CHANNELFLAG_PAUSED | CHANNELFLAG_FULLVOLUME);
563 }
564
565 if (nvolume < 0 || nvolume > 255)
566 {
567 VM_Warning(prog, "SV_StartSound: volume must be in range 0-1\n");
568 return;
569 }
570
571 if (attenuation < 0 || attenuation > 4)
572 {
573 VM_Warning(prog, "SV_StartSound: attenuation must be in range 0-4\n");
574 return;
575 }
576
577 channel = CHAN_USER2ENGINE(channel);
578
579 if (!IS_CHAN(channel))
580 {
581 VM_Warning(prog, "SV_StartSound: channel must be in range 0-127\n");
582 return;
583 }
584
585 SV_StartSound (entity, channel, sample, nvolume, attenuation, flags & CHANNELFLAG_RELIABLE, pitchchange);
586 }
587
588 /*
589 =================
590 VM_SV_pointsound
591
592 Follows the same logic as VM_SV_sound, except instead of
593 an entity, an origin for the sound is provided, and channel
594 is omitted (since no entity is being tracked).
595
596 =================
597 */
598 static void VM_SV_pointsound(prvm_prog_t *prog)
599 {
600 const char *sample;
601 int nvolume;
602 float attenuation;
603 float pitchchange;
604 vec3_t org;
605
606 VM_SAFEPARMCOUNTRANGE(4, 5, VM_SV_pointsound);
607
608 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
609 sample = PRVM_G_STRING(OFS_PARM1);
610 nvolume = (int)(PRVM_G_FLOAT(OFS_PARM2) * 255);
611 attenuation = PRVM_G_FLOAT(OFS_PARM3);
612 pitchchange = prog->argc < 5 ? 0 : PRVM_G_FLOAT(OFS_PARM4) * 0.01f;
613
614 if (nvolume < 0 || nvolume > 255)
615 {
616 VM_Warning(prog, "SV_StartPointSound: volume must be in range 0-1\n");
617 return;
618 }
619
620 if (attenuation < 0 || attenuation > 4)
621 {
622 VM_Warning(prog, "SV_StartPointSound: attenuation must be in range 0-4\n");
623 return;
624 }
625
626 SV_StartPointSound (org, sample, nvolume, attenuation, pitchchange);
627 }
628
629 /*
630 =================
631 VM_SV_traceline
632
633 Used for use tracing and shot targeting
634 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
635 if the tryents flag is set.
636
637 traceline (vector1, vector2, movetype, ignore)
638 =================
639 */
640 static void VM_SV_traceline(prvm_prog_t *prog)
641 {
642 vec3_t v1, v2;
643 trace_t trace;
644 int move;
645 prvm_edict_t *ent;
646
647 VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_traceline); // allow more parameters for future expansion
648
649 prog->xfunction->builtinsprofile += 30;
650
651 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), v1);
652 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), v2);
653 move = (int)PRVM_G_FLOAT(OFS_PARM2);
654 ent = PRVM_G_EDICT(OFS_PARM3);
655
656 if (VEC_IS_NAN(v1[0]) || VEC_IS_NAN(v1[1]) || VEC_IS_NAN(v1[2]) || VEC_IS_NAN(v2[0]) || VEC_IS_NAN(v2[1]) || VEC_IS_NAN(v2[2]))
657 prog->error_cmd("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", prog->name, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
658
659 trace = SV_TraceLine(v1, v2, move, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendtracelinelength.value);
660
661 VM_SetTraceGlobals(prog, &trace);
662 }
663
664
665 /*
666 =================
667 VM_SV_tracebox
668
669 Used for use tracing and shot targeting
670 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
671 if the tryents flag is set.
672
673 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
674 =================
675 */
676 // LordHavoc: added this for my own use, VERY useful, similar to traceline
677 static void VM_SV_tracebox(prvm_prog_t *prog)
678 {
679 vec3_t v1, v2, m1, m2;
680 trace_t trace;
681 int move;
682 prvm_edict_t *ent;
683
684 VM_SAFEPARMCOUNTRANGE(6, 8, VM_SV_tracebox); // allow more parameters for future expansion
685
686 prog->xfunction->builtinsprofile += 30;
687
688 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), v1);
689 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), m1);
690 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), m2);
691 VectorCopy(PRVM_G_VECTOR(OFS_PARM3), v2);
692 move = (int)PRVM_G_FLOAT(OFS_PARM4);
693 ent = PRVM_G_EDICT(OFS_PARM5);
694
695 if (VEC_IS_NAN(v1[0]) || VEC_IS_NAN(v1[1]) || VEC_IS_NAN(v1[2]) || VEC_IS_NAN(v2[0]) || VEC_IS_NAN(v2[1]) || VEC_IS_NAN(v2[2]))
696 prog->error_cmd("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", prog->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));
697
698 trace = SV_TraceBox(v1, m1, m2, v2, move, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendtraceboxlength.value);
699
700 VM_SetTraceGlobals(prog, &trace);
701 }
702
703 static trace_t SV_Trace_Toss(prvm_prog_t *prog, prvm_edict_t *tossent, prvm_edict_t *ignore)
704 {
705 int i;
706 float gravity;
707 vec3_t move, end, tossentorigin, tossentmins, tossentmaxs;
708 vec3_t original_origin;
709 vec3_t original_velocity;
710 vec3_t original_angles;
711 vec3_t original_avelocity;
712 trace_t trace;
713
714 VectorCopy(PRVM_serveredictvector(tossent, origin) , original_origin );
715 VectorCopy(PRVM_serveredictvector(tossent, velocity) , original_velocity );
716 VectorCopy(PRVM_serveredictvector(tossent, angles) , original_angles );
717 VectorCopy(PRVM_serveredictvector(tossent, avelocity), original_avelocity);
718
719 gravity = PRVM_serveredictfloat(tossent, gravity);
720 if (!gravity)
721 gravity = 1.0f;
722 gravity *= sv_gravity.value * 0.025;
723
724 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
725 {
726 SV_CheckVelocity (tossent);
727 PRVM_serveredictvector(tossent, velocity)[2] -= gravity;
728 VectorMA (PRVM_serveredictvector(tossent, angles), 0.05, PRVM_serveredictvector(tossent, avelocity), PRVM_serveredictvector(tossent, angles));
729 VectorScale (PRVM_serveredictvector(tossent, velocity), 0.05, move);
730 VectorAdd (PRVM_serveredictvector(tossent, origin), move, end);
731 VectorCopy(PRVM_serveredictvector(tossent, origin), tossentorigin);
732 VectorCopy(PRVM_serveredictvector(tossent, mins), tossentmins);
733 VectorCopy(PRVM_serveredictvector(tossent, maxs), tossentmaxs);
734 trace = SV_TraceBox(tossentorigin, tossentmins, tossentmaxs, end, MOVE_NORMAL, tossent, SV_GenericHitSuperContentsMask(tossent), 0, 0, collision_extendmovelength.value);
735 VectorCopy (trace.endpos, PRVM_serveredictvector(tossent, origin));
736 PRVM_serveredictvector(tossent, velocity)[2] -= gravity;
737
738 if (trace.fraction < 1)
739 break;
740 }
741
742 VectorCopy(original_origin , PRVM_serveredictvector(tossent, origin) );
743 VectorCopy(original_velocity , PRVM_serveredictvector(tossent, velocity) );
744 VectorCopy(original_angles , PRVM_serveredictvector(tossent, angles) );
745 VectorCopy(original_avelocity, PRVM_serveredictvector(tossent, avelocity));
746
747 return trace;
748 }
749
750 static void VM_SV_tracetoss(prvm_prog_t *prog)
751 {
752 trace_t trace;
753 prvm_edict_t *ent;
754 prvm_edict_t *ignore;
755
756 VM_SAFEPARMCOUNT(2, VM_SV_tracetoss);
757
758 prog->xfunction->builtinsprofile += 600;
759
760 ent = PRVM_G_EDICT(OFS_PARM0);
761 if (ent == prog->edicts)
762 {
763 VM_Warning(prog, "tracetoss: can not use world entity\n");
764 return;
765 }
766 ignore = PRVM_G_EDICT(OFS_PARM1);
767
768 trace = SV_Trace_Toss(prog, ent, ignore);
769
770 VM_SetTraceGlobals(prog, &trace);
771 }
772
773 //============================================================================
774
775 static int checkpvsbytes;
776 static unsigned char checkpvs[MAX_MAP_LEAFS/8];
777
778 static int VM_SV_newcheckclient(prvm_prog_t *prog, int check)
779 {
780 int i;
781 prvm_edict_t *ent;
782 vec3_t org;
783
784 // cycle to the next one
785
786 check = bound(1, check, svs.maxclients);
787 if (check == svs.maxclients)
788 i = 1;
789 else
790 i = check + 1;
791
792 for ( ; ; i++)
793 {
794 // count the cost
795 prog->xfunction->builtinsprofile++;
796 // wrap around
797 if (i == svs.maxclients+1)
798 i = 1;
799 // look up the client's edict
800 ent = PRVM_EDICT_NUM(i);
801 // check if it is to be ignored, but never ignore the one we started on (prevent infinite loop)
802 if (i != check && (ent->priv.server->free || PRVM_serveredictfloat(ent, health) <= 0 || ((int)PRVM_serveredictfloat(ent, flags) & FL_NOTARGET)))
803 continue;
804 // found a valid client (possibly the same one again)
805 break;
806 }
807
808 // get the PVS for the entity
809 VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, view_ofs), org);
810 checkpvsbytes = 0;
811 if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
812 checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs), false);
813
814 return i;
815 }
816
817 /*
818 =================
819 VM_SV_checkclient
820
821 Returns a client (or object that has a client enemy) that would be a
822 valid target.
823
824 If there is more than one valid option, they are cycled each frame
825
826 If (self.origin + self.viewofs) is not in the PVS of the current target,
827 it is not returned at all.
828
829 name checkclient ()
830 =================
831 */
832 int c_invis, c_notvis;
833 static void VM_SV_checkclient(prvm_prog_t *prog)
834 {
835 prvm_edict_t *ent, *self;
836 vec3_t view;
837
838 VM_SAFEPARMCOUNT(0, VM_SV_checkclient);
839
840 // find a new check if on a new frame
841 if (sv.time - sv.lastchecktime >= 0.1)
842 {
843 sv.lastcheck = VM_SV_newcheckclient(prog, sv.lastcheck);
844 sv.lastchecktime = sv.time;
845 }
846
847 // return check if it might be visible
848 ent = PRVM_EDICT_NUM(sv.lastcheck);
849 if (ent->priv.server->free || PRVM_serveredictfloat(ent, health) <= 0)
850 {
851 VM_RETURN_EDICT(prog->edicts);
852 return;
853 }
854
855 // if current entity can't possibly see the check entity, return 0
856 self = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
857 VectorAdd(PRVM_serveredictvector(self, origin), PRVM_serveredictvector(self, view_ofs), view);
858 if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
859 {
860 c_notvis++;
861 VM_RETURN_EDICT(prog->edicts);
862 return;
863 }
864
865 // might be able to see it
866 c_invis++;
867 VM_RETURN_EDICT(ent);
868 }
869
870 //============================================================================
871
872 /*
873 =================
874 VM_SV_checkpvs
875
876 Checks if an entity is in a point's PVS.
877 Should be fast but can be inexact.
878
879 float checkpvs(vector viewpos, entity viewee) = #240;
880 =================
881 */
882 static void VM_SV_checkpvs(prvm_prog_t *prog)
883 {
884 vec3_t viewpos, absmin, absmax;
885 prvm_edict_t *viewee;
886 #if 1
887 unsigned char *pvs;
888 #else
889 int fatpvsbytes;
890 unsigned char fatpvs[MAX_MAP_LEAFS/8];
891 #endif
892
893 VM_SAFEPARMCOUNT(2, VM_SV_checkpvs);
894 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), viewpos);
895 viewee = PRVM_G_EDICT(OFS_PARM1);
896
897 if(viewee->priv.server->free)
898 {
899 VM_Warning(prog, "checkpvs: can not check free entity\n");
900 PRVM_G_FLOAT(OFS_RETURN) = 4;
901 return;
902 }
903
904 #if 1
905 if(!sv.worldmodel || !sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)
906 {
907 // no PVS support on this worldmodel... darn
908 PRVM_G_FLOAT(OFS_RETURN) = 3;
909 return;
910 }
911 pvs = sv.worldmodel->brush.GetPVS(sv.worldmodel, viewpos);
912 if(!pvs)
913 {
914 // viewpos isn't in any PVS... darn
915 PRVM_G_FLOAT(OFS_RETURN) = 2;
916 return;
917 }
918 VectorCopy(PRVM_serveredictvector(viewee, absmin), absmin);
919 VectorCopy(PRVM_serveredictvector(viewee, absmax), absmax);
920 PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, pvs, absmin, absmax);
921 #else
922 // using fat PVS like FTEQW does (slow)
923 if(!sv.worldmodel || !sv.worldmodel->brush.FatPVS || !sv.worldmodel->brush.BoxTouchingPVS)
924 {
925 // no PVS support on this worldmodel... darn
926 PRVM_G_FLOAT(OFS_RETURN) = 3;
927 return;
928 }
929 fatpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, viewpos, 8, fatpvs, sizeof(fatpvs), false);
930 if(!fatpvsbytes)
931 {
932 // viewpos isn't in any PVS... darn
933 PRVM_G_FLOAT(OFS_RETURN) = 2;
934 return;
935 }
936 VectorCopy(PRVM_serveredictvector(viewee, absmin), absmin);
937 VectorCopy(PRVM_serveredictvector(viewee, absmax), absmax);
938 PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, absmin, absmax);
939 #endif
940 }
941
942
943 /*
944 =================
945 VM_SV_stuffcmd
946
947 Sends text over to the client's execution buffer
948
949 stuffcmd (clientent, value, ...)
950 =================
951 */
952 static void VM_SV_stuffcmd(prvm_prog_t *prog)
953 {
954 int entnum;
955 client_t *old;
956 char string[VM_STRINGTEMP_LENGTH];
957
958 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_stuffcmd);
959
960 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
961 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
962 {
963 VM_Warning(prog, "Can't stuffcmd to a non-client\n");
964 return;
965 }
966
967 VM_VarString(prog, 1, string, sizeof(string));
968
969 old = host_client;
970 host_client = svs.clients + entnum-1;
971 Host_ClientCommands ("%s", string);
972 host_client = old;
973 }
974
975 /*
976 =================
977 VM_SV_findradius
978
979 Returns a chain of entities that have origins within a spherical area
980
981 findradius (origin, radius)
982 =================
983 */
984 static void VM_SV_findradius(prvm_prog_t *prog)
985 {
986 prvm_edict_t *ent, *chain;
987 vec_t radius, radius2;
988 vec3_t org, eorg, mins, maxs;
989 int i;
990 int numtouchedicts;
991 static prvm_edict_t *touchedicts[MAX_EDICTS];
992 int chainfield;
993
994 VM_SAFEPARMCOUNTRANGE(2, 3, VM_SV_findradius);
995
996 if(prog->argc == 3)
997 chainfield = PRVM_G_INT(OFS_PARM2);
998 else
999 chainfield = prog->fieldoffsets.chain;
1000 if (chainfield < 0)
1001 prog->error_cmd("VM_findchain: %s doesnt have the specified chain field !", prog->name);
1002
1003 chain = (prvm_edict_t *)prog->edicts;
1004
1005 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
1006 radius = PRVM_G_FLOAT(OFS_PARM1);
1007 radius2 = radius * radius;
1008
1009 mins[0] = org[0] - (radius + 1);
1010 mins[1] = org[1] - (radius + 1);
1011 mins[2] = org[2] - (radius + 1);
1012 maxs[0] = org[0] + (radius + 1);
1013 maxs[1] = org[1] + (radius + 1);
1014 maxs[2] = org[2] + (radius + 1);
1015 numtouchedicts = SV_EntitiesInBox(mins, maxs, MAX_EDICTS, touchedicts);
1016 if (numtouchedicts > MAX_EDICTS)
1017 {
1018 // this never happens
1019 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
1020 numtouchedicts = MAX_EDICTS;
1021 }
1022 for (i = 0;i < numtouchedicts;i++)
1023 {
1024 ent = touchedicts[i];
1025 prog->xfunction->builtinsprofile++;
1026 // Quake did not return non-solid entities but darkplaces does
1027 // (note: this is the reason you can't blow up fallen zombies)
1028 if (PRVM_serveredictfloat(ent, solid) == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
1029 continue;
1030 // LordHavoc: compare against bounding box rather than center so it
1031 // doesn't miss large objects, and use DotProduct instead of Length
1032 // for a major speedup
1033 VectorSubtract(org, PRVM_serveredictvector(ent, origin), eorg);
1034 if (sv_gameplayfix_findradiusdistancetobox.integer)
1035 {
1036 eorg[0] -= bound(PRVM_serveredictvector(ent, mins)[0], eorg[0], PRVM_serveredictvector(ent, maxs)[0]);
1037 eorg[1] -= bound(PRVM_serveredictvector(ent, mins)[1], eorg[1], PRVM_serveredictvector(ent, maxs)[1]);
1038 eorg[2] -= bound(PRVM_serveredictvector(ent, mins)[2], eorg[2], PRVM_serveredictvector(ent, maxs)[2]);
1039 }
1040 else
1041 VectorMAMAM(1, eorg, -0.5f, PRVM_serveredictvector(ent, mins), -0.5f, PRVM_serveredictvector(ent, maxs), eorg);
1042 if (DotProduct(eorg, eorg) < radius2)
1043 {
1044 PRVM_EDICTFIELDEDICT(ent,chainfield) = PRVM_EDICT_TO_PROG(chain);
1045 chain = ent;
1046 }
1047 }
1048
1049 VM_RETURN_EDICT(chain);
1050 }
1051
1052 static void VM_SV_precache_sound(prvm_prog_t *prog)
1053 {
1054 VM_SAFEPARMCOUNT(1, VM_SV_precache_sound);
1055 PRVM_G_FLOAT(OFS_RETURN) = SV_SoundIndex(PRVM_G_STRING(OFS_PARM0), 2);
1056 }
1057
1058 static void VM_SV_precache_model(prvm_prog_t *prog)
1059 {
1060 VM_SAFEPARMCOUNT(1, VM_SV_precache_model);
1061 SV_ModelIndex(PRVM_G_STRING(OFS_PARM0), 2);
1062 PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1063 }
1064
1065 /*
1066 ===============
1067 VM_SV_walkmove
1068
1069 float(float yaw, float dist[, settrace]) walkmove
1070 ===============
1071 */
1072 static void VM_SV_walkmove(prvm_prog_t *prog)
1073 {
1074 prvm_edict_t *ent;
1075 float yaw, dist;
1076 vec3_t move;
1077 mfunction_t *oldf;
1078 int oldself;
1079 qboolean settrace;
1080
1081 VM_SAFEPARMCOUNTRANGE(2, 3, VM_SV_walkmove);
1082
1083 // assume failure if it returns early
1084 PRVM_G_FLOAT(OFS_RETURN) = 0;
1085
1086 ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
1087 if (ent == prog->edicts)
1088 {
1089 VM_Warning(prog, "walkmove: can not modify world entity\n");
1090 return;
1091 }
1092 if (ent->priv.server->free)
1093 {
1094 VM_Warning(prog, "walkmove: can not modify free entity\n");
1095 return;
1096 }
1097 yaw = PRVM_G_FLOAT(OFS_PARM0);
1098 dist = PRVM_G_FLOAT(OFS_PARM1);
1099 settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
1100
1101 if ( !( (int)PRVM_serveredictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
1102 return;
1103
1104 yaw = yaw*M_PI*2 / 360;
1105
1106 move[0] = cos(yaw)*dist;
1107 move[1] = sin(yaw)*dist;
1108 move[2] = 0;
1109
1110 // save program state, because SV_movestep may call other progs
1111 oldf = prog->xfunction;
1112 oldself = PRVM_serverglobaledict(self);
1113
1114 PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true, false, settrace);
1115
1116
1117 // restore program state
1118 prog->xfunction = oldf;
1119 PRVM_serverglobaledict(self) = oldself;
1120 }
1121
1122 /*
1123 ===============
1124 VM_SV_droptofloor
1125
1126 void() droptofloor
1127 ===============
1128 */
1129
1130 static void VM_SV_droptofloor(prvm_prog_t *prog)
1131 {
1132 prvm_edict_t *ent;
1133 vec3_t end, entorigin, entmins, entmaxs;
1134 trace_t trace;
1135
1136 VM_SAFEPARMCOUNTRANGE(0, 2, VM_SV_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
1137
1138 // assume failure if it returns early
1139 PRVM_G_FLOAT(OFS_RETURN) = 0;
1140
1141 ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
1142 if (ent == prog->edicts)
1143 {
1144 VM_Warning(prog, "droptofloor: can not modify world entity\n");
1145 return;
1146 }
1147 if (ent->priv.server->free)
1148 {
1149 VM_Warning(prog, "droptofloor: can not modify free entity\n");
1150 return;
1151 }
1152
1153 VectorCopy (PRVM_serveredictvector(ent, origin), end);
1154 end[2] -= 256;
1155
1156 if (sv_gameplayfix_droptofloorstartsolid_nudgetocorrect.integer)
1157 SV_NudgeOutOfSolid(ent);
1158
1159 VectorCopy(PRVM_serveredictvector(ent, origin), entorigin);
1160 VectorCopy(PRVM_serveredictvector(ent, mins), entmins);
1161 VectorCopy(PRVM_serveredictvector(ent, maxs), entmaxs);
1162 trace = SV_TraceBox(entorigin, entmins, entmaxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
1163 if (trace.startsolid && sv_gameplayfix_droptofloorstartsolid.integer)
1164 {
1165 vec3_t offset, org;
1166 VectorSet(offset, 0.5f * (PRVM_serveredictvector(ent, mins)[0] + PRVM_serveredictvector(ent, maxs)[0]), 0.5f * (PRVM_serveredictvector(ent, mins)[1] + PRVM_serveredictvector(ent, maxs)[1]), PRVM_serveredictvector(ent, mins)[2]);
1167 VectorAdd(PRVM_serveredictvector(ent, origin), offset, org);
1168 trace = SV_TraceLine(org, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value);
1169 VectorSubtract(trace.endpos, offset, trace.endpos);
1170 if (trace.startsolid)
1171 {
1172 Con_DPrintf("droptofloor at %f %f %f - COULD NOT FIX BADLY PLACED ENTITY\n", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
1173 SV_LinkEdict(ent);
1174 PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
1175 PRVM_serveredictedict(ent, groundentity) = 0;
1176 PRVM_G_FLOAT(OFS_RETURN) = 1;
1177 }
1178 else if (trace.fraction < 1)
1179 {
1180 Con_DPrintf("droptofloor at %f %f %f - FIXED BADLY PLACED ENTITY\n", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
1181 VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));
1182 if (sv_gameplayfix_droptofloorstartsolid_nudgetocorrect.integer)
1183 SV_NudgeOutOfSolid(ent);
1184 SV_LinkEdict(ent);
1185 PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
1186 PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
1187 PRVM_G_FLOAT(OFS_RETURN) = 1;
1188 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
1189 ent->priv.server->suspendedinairflag = true;
1190 }
1191 }
1192 else
1193 {
1194 if (!trace.allsolid && trace.fraction < 1)
1195 {
1196 VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));
1197 SV_LinkEdict(ent);
1198 PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
1199 PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
1200 PRVM_G_FLOAT(OFS_RETURN) = 1;
1201 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
1202 ent->priv.server->suspendedinairflag = true;
1203 }
1204 }
1205 }
1206
1207 /*
1208 ===============
1209 VM_SV_lightstyle
1210
1211 void(float style, string value) lightstyle
1212 ===============
1213 */
1214 static void VM_SV_lightstyle(prvm_prog_t *prog)
1215 {
1216 int style;
1217 const char *val;
1218 client_t *client;
1219 int j;
1220
1221 VM_SAFEPARMCOUNT(2, VM_SV_lightstyle);
1222
1223 style = (int)PRVM_G_FLOAT(OFS_PARM0);
1224 val = PRVM_G_STRING(OFS_PARM1);
1225
1226 if( (unsigned) style >= MAX_LIGHTSTYLES ) {
1227 prog->error_cmd( "PF_lightstyle: style: %i >= 64", style );
1228 }
1229
1230 // change the string in sv
1231 strlcpy(sv.lightstyles[style], val, sizeof(sv.lightstyles[style]));
1232
1233 // send message to all clients on this server
1234 if (sv.state != ss_active)
1235 return;
1236
1237 for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1238 {
1239 if (client->active && client->netconnection)
1240 {
1241 MSG_WriteChar (&client->netconnection->message, svc_lightstyle);
1242 MSG_WriteChar (&client->netconnection->message,style);
1243 MSG_WriteString (&client->netconnection->message, val);
1244 }
1245 }
1246 }
1247
1248 /*
1249 =============
1250 VM_SV_checkbottom
1251 =============
1252 */
1253 static void VM_SV_checkbottom(prvm_prog_t *prog)
1254 {
1255 VM_SAFEPARMCOUNT(1, VM_SV_checkbottom);
1256 PRVM_G_FLOAT(OFS_RETURN) = SV_CheckBottom (PRVM_G_EDICT(OFS_PARM0));
1257 }
1258
1259 /*
1260 =============
1261 VM_SV_pointcontents
1262 =============
1263 */
1264 static void VM_SV_pointcontents(prvm_prog_t *prog)
1265 {
1266 vec3_t point;
1267 VM_SAFEPARMCOUNT(1, VM_SV_pointcontents);
1268 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), point);
1269 PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(SV_PointSuperContents(point));
1270 }
1271
1272 /*
1273 =============
1274 VM_SV_aim
1275
1276 Pick a vector for the player to shoot along
1277 vector aim(entity, missilespeed)
1278 =============
1279 */
1280 static void VM_SV_aim(prvm_prog_t *prog)
1281 {
1282 prvm_edict_t *ent, *check, *bestent;
1283 vec3_t start, dir, end, bestdir;
1284 int i, j;
1285 trace_t tr;
1286 float dist, bestdist;
1287 //float speed;
1288
1289 VM_SAFEPARMCOUNT(2, VM_SV_aim);
1290
1291 // assume failure if it returns early
1292 VectorCopy(PRVM_serverglobalvector(v_forward), PRVM_G_VECTOR(OFS_RETURN));
1293 // if sv_aim is so high it can't possibly accept anything, skip out early
1294 if (sv_aim.value >= 1)
1295 return;
1296
1297 ent = PRVM_G_EDICT(OFS_PARM0);
1298 if (ent == prog->edicts)
1299 {
1300 VM_Warning(prog, "aim: can not use world entity\n");
1301 return;
1302 }
1303 if (ent->priv.server->free)
1304 {
1305 VM_Warning(prog, "aim: can not use free entity\n");
1306 return;
1307 }
1308 //speed = PRVM_G_FLOAT(OFS_PARM1);
1309
1310 VectorCopy (PRVM_serveredictvector(ent, origin), start);
1311 start[2] += 20;
1312
1313 // try sending a trace straight
1314 VectorCopy (PRVM_serverglobalvector(v_forward), dir);
1315 VectorMA (start, 2048, dir, end);
1316 tr = SV_TraceLine(start, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY, 0, 0, collision_extendmovelength.value);
1317 if (tr.ent && PRVM_serveredictfloat(((prvm_edict_t *)tr.ent), takedamage) == DAMAGE_AIM
1318 && (!teamplay.integer || PRVM_serveredictfloat(ent, team) <=0 || PRVM_serveredictfloat(ent, team) != PRVM_serveredictfloat(((prvm_edict_t *)tr.ent), team)) )
1319 {
1320 VectorCopy (PRVM_serverglobalvector(v_forward), PRVM_G_VECTOR(OFS_RETURN));
1321 return;
1322 }
1323
1324
1325 // try all possible entities
1326 VectorCopy (dir, bestdir);
1327 bestdist = sv_aim.value;
1328 bestent = NULL;
1329
1330 check = PRVM_NEXT_EDICT(prog->edicts);
1331 for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
1332 {
1333 prog->xfunction->builtinsprofile++;
1334 if (PRVM_serveredictfloat(check, takedamage) != DAMAGE_AIM)
1335 continue;
1336 if (check == ent)
1337 continue;
1338 if (teamplay.integer && PRVM_serveredictfloat(ent, team) > 0 && PRVM_serveredictfloat(ent, team) == PRVM_serveredictfloat(check, team))
1339 continue; // don't aim at teammate
1340 for (j=0 ; j<3 ; j++)
1341 end[j] = PRVM_serveredictvector(check, origin)[j]
1342 + 0.5*(PRVM_serveredictvector(check, mins)[j] + PRVM_serveredictvector(check, maxs)[j]);
1343 VectorSubtract (end, start, dir);
1344 VectorNormalize (dir);
1345 dist = DotProduct (dir, PRVM_serverglobalvector(v_forward));
1346 if (dist < bestdist)
1347 continue; // to far to turn
1348 tr = SV_TraceLine(start, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY, 0, 0, collision_extendmovelength.value);
1349 if (tr.ent == check)
1350 { // can shoot at this one
1351 bestdist = dist;
1352 bestent = check;
1353 }
1354 }
1355
1356 if (bestent)
1357 {
1358 VectorSubtract (PRVM_serveredictvector(bestent, origin), PRVM_serveredictvector(ent, origin), dir);
1359 dist = DotProduct (dir, PRVM_serverglobalvector(v_forward));
1360 VectorScale (PRVM_serverglobalvector(v_forward), dist, end);
1361 end[2] = dir[2];
1362 VectorNormalize (end);
1363 VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));
1364 }
1365 else
1366 {
1367 VectorCopy (bestdir, PRVM_G_VECTOR(OFS_RETURN));
1368 }
1369 }
1370
1371 /*
1372 ===============================================================================
1373
1374 MESSAGE WRITING
1375
1376 ===============================================================================
1377 */
1378
1379 #define MSG_BROADCAST 0 // unreliable to all
1380 #define MSG_ONE 1 // reliable to one (msg_entity)
1381 #define MSG_ALL 2 // reliable to all
1382 #define MSG_INIT 3 // write to the init string
1383 #define MSG_ENTITY 5
1384
1385 static sizebuf_t *WriteDest(prvm_prog_t *prog)
1386 {
1387 int entnum;
1388 int dest;
1389 prvm_edict_t *ent;
1390
1391 dest = (int)PRVM_G_FLOAT(OFS_PARM0);
1392 switch (dest)
1393 {
1394 case MSG_BROADCAST:
1395 return &sv.datagram;
1396
1397 case MSG_ONE:
1398 ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(msg_entity));
1399 entnum = PRVM_NUM_FOR_EDICT(ent);
1400 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active || !svs.clients[entnum-1].netconnection)
1401 {
1402 VM_Warning(prog, "WriteDest: tried to write to non-client\n");
1403 return &sv.reliable_datagram;
1404 }
1405 else
1406 return &svs.clients[entnum-1].netconnection->message;
1407
1408 default:
1409 VM_Warning(prog, "WriteDest: bad destination\n");
1410 case MSG_ALL:
1411 return &sv.reliable_datagram;
1412
1413 case MSG_INIT:
1414 return &sv.signon;
1415
1416 case MSG_ENTITY:
1417 return sv.writeentitiestoclient_msg;
1418 }
1419
1420 //return NULL;
1421 }
1422
1423 static void VM_SV_WriteByte(prvm_prog_t *prog)
1424 {
1425 VM_SAFEPARMCOUNT(2, VM_SV_WriteByte);
1426 MSG_WriteByte (WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM1));
1427 }
1428
1429 static void VM_SV_WriteChar(prvm_prog_t *prog)
1430 {
1431 VM_SAFEPARMCOUNT(2, VM_SV_WriteChar);
1432 MSG_WriteChar (WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM1));
1433 }
1434
1435 static void VM_SV_WriteShort(prvm_prog_t *prog)
1436 {
1437 VM_SAFEPARMCOUNT(2, VM_SV_WriteShort);
1438 MSG_WriteShort (WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM1));
1439 }
1440
1441 static void VM_SV_WriteLong(prvm_prog_t *prog)
1442 {
1443 VM_SAFEPARMCOUNT(2, VM_SV_WriteLong);
1444 MSG_WriteLong (WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM1));
1445 }
1446
1447 static void VM_SV_WriteAngle(prvm_prog_t *prog)
1448 {
1449 VM_SAFEPARMCOUNT(2, VM_SV_WriteAngle);
1450 MSG_WriteAngle (WriteDest(prog), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1451 }
1452
1453 static void VM_SV_WriteCoord(prvm_prog_t *prog)
1454 {
1455 VM_SAFEPARMCOUNT(2, VM_SV_WriteCoord);
1456 MSG_WriteCoord (WriteDest(prog), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1457 }
1458
1459 static void VM_SV_WriteString(prvm_prog_t *prog)
1460 {
1461 VM_SAFEPARMCOUNT(2, VM_SV_WriteString);
1462 MSG_WriteString (WriteDest(prog), PRVM_G_STRING(OFS_PARM1));
1463 }
1464
1465 static void VM_SV_WriteUnterminatedString(prvm_prog_t *prog)
1466 {
1467 VM_SAFEPARMCOUNT(2, VM_SV_WriteUnterminatedString);
1468 MSG_WriteUnterminatedString (WriteDest(prog), PRVM_G_STRING(OFS_PARM1));
1469 }
1470
1471
1472 static void VM_SV_WriteEntity(prvm_prog_t *prog)
1473 {
1474 VM_SAFEPARMCOUNT(2, VM_SV_WriteEntity);
1475 MSG_WriteShort (WriteDest(prog), PRVM_G_EDICTNUM(OFS_PARM1));
1476 }
1477
1478 // writes a picture as at most size bytes of data
1479 // message:
1480 // IMGNAME \0 SIZE(short) IMGDATA
1481 // if failed to read/compress:
1482 // IMGNAME \0 \0 \0
1483 //#501 void(float dest, string name, float maxsize) WritePicture (DP_SV_WRITEPICTURE))
1484 static void VM_SV_WritePicture(prvm_prog_t *prog)
1485 {
1486 const char *imgname;
1487 void *buf;
1488 size_t size;
1489
1490 VM_SAFEPARMCOUNT(3, VM_SV_WritePicture);
1491
1492 imgname = PRVM_G_STRING(OFS_PARM1);
1493 size = (size_t) PRVM_G_FLOAT(OFS_PARM2);
1494 if(size > 65535)
1495 size = 65535;
1496
1497 MSG_WriteString(WriteDest(prog), imgname);
1498 if(Image_Compress(imgname, size, &buf, &size))
1499 {
1500 // actual picture
1501 MSG_WriteShort(WriteDest(prog), (int)size);
1502 SZ_Write(WriteDest(prog), (unsigned char *) buf, (int)size);
1503 }
1504 else
1505 {
1506 // placeholder
1507 MSG_WriteShort(WriteDest(prog), 0);
1508 }
1509 }
1510
1511 //////////////////////////////////////////////////////////
1512
1513 static void VM_SV_makestatic(prvm_prog_t *prog)
1514 {
1515 prvm_edict_t *ent;
1516 int i, large;
1517
1518 // allow 0 parameters due to an id1 qc bug in which this function is used
1519 // with no parameters (but directly after setmodel with self in OFS_PARM0)
1520 VM_SAFEPARMCOUNTRANGE(0, 1, VM_SV_makestatic);
1521
1522 if (prog->argc >= 1)
1523 ent = PRVM_G_EDICT(OFS_PARM0);
1524 else
1525 ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
1526 if (ent == prog->edicts)
1527 {
1528 VM_Warning(prog, "makestatic: can not modify world entity\n");
1529 return;
1530 }
1531 if (ent->priv.server->free)
1532 {
1533 VM_Warning(prog, "makestatic: can not modify free entity\n");
1534 return;
1535 }
1536
1537 large = false;
1538 if (PRVM_serveredictfloat(ent, modelindex) >= 256 || PRVM_serveredictfloat(ent, frame) >= 256)
1539 large = true;
1540
1541 if (large)
1542 {
1543 MSG_WriteByte (&sv.signon,svc_spawnstatic2);
1544 MSG_WriteShort (&sv.signon, (int)PRVM_serveredictfloat(ent, modelindex));
1545 MSG_WriteShort (&sv.signon, (int)PRVM_serveredictfloat(ent, frame));
1546 }
1547 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1548 {
1549 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1550 MSG_WriteShort (&sv.signon, (int)PRVM_serveredictfloat(ent, modelindex));
1551 MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, frame));
1552 }
1553 else
1554 {
1555 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1556 MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, modelindex));
1557 MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, frame));
1558 }
1559
1560 MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, colormap));
1561 MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, skin));
1562 for (i=0 ; i<3 ; i++)
1563 {
1564 MSG_WriteCoord(&sv.signon, PRVM_serveredictvector(ent, origin)[i], sv.protocol);
1565 MSG_WriteAngle(&sv.signon, PRVM_serveredictvector(ent, angles)[i], sv.protocol);
1566 }
1567
1568 // throw the entity away now
1569 PRVM_ED_Free(prog, ent);
1570 }
1571
1572 //=============================================================================
1573
1574 /*
1575 ==============
1576 VM_SV_setspawnparms
1577 ==============
1578 */
1579 static void VM_SV_setspawnparms(prvm_prog_t *prog)
1580 {
1581 prvm_edict_t *ent;
1582 int i;
1583 client_t *client;
1584
1585 VM_SAFEPARMCOUNT(1, VM_SV_setspawnparms);
1586
1587 ent = PRVM_G_EDICT(OFS_PARM0);
1588 i = PRVM_NUM_FOR_EDICT(ent);
1589 if (i < 1 || i > svs.maxclients || !svs.clients[i-1].active)
1590 {
1591 Con_Print("tried to setspawnparms on a non-client\n");
1592 return;
1593 }
1594
1595 // copy spawn parms out of the client_t
1596 client = svs.clients + i-1;
1597 for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1598 (&PRVM_serverglobalfloat(parm1))[i] = client->spawn_parms[i];
1599 }
1600
1601 /*
1602 =================
1603 VM_SV_getlight
1604
1605 Returns a color vector indicating the lighting at the requested point.
1606
1607 (Internal Operation note: actually measures the light beneath the point, just like
1608 the model lighting on the client)
1609
1610 getlight(vector)
1611 =================
1612 */
1613 static void VM_SV_getlight(prvm_prog_t *prog)
1614 {
1615 vec3_t ambientcolor, diffusecolor, diffusenormal;
1616 vec3_t p;
1617 VM_SAFEPARMCOUNT(1, VM_SV_getlight);
1618 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), p);
1619 VectorClear(ambientcolor);
1620 VectorClear(diffusecolor);
1621 VectorClear(diffusenormal);
1622 if (sv.worldmodel && sv.worldmodel->brush.LightPoint)
1623 sv.worldmodel->brush.LightPoint(sv.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
1624 VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
1625 }
1626
1627 typedef struct
1628 {
1629 unsigned char type; // 1/2/8 or other value if isn't used
1630 int fieldoffset;
1631 }customstat_t;
1632
1633 static customstat_t *vm_customstats = NULL; //[515]: it starts from 0, not 32
1634 static int vm_customstats_last;
1635
1636 void VM_CustomStats_Clear (void)
1637 {
1638 if(vm_customstats)
1639 {
1640 Z_Free(vm_customstats);
1641 vm_customstats = NULL;
1642 vm_customstats_last = -1;
1643 }
1644 }
1645
1646 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1647 {
1648 prvm_prog_t *prog = SVVM_prog;
1649 int i;
1650 char s[17];
1651 union {
1652 int i;
1653 float f;
1654 } u;
1655
1656 if(!vm_customstats)
1657 return;
1658
1659 for(i=0; i<vm_customstats_last+1 ;i++)
1660 {
1661 if(!vm_customstats[i].type)
1662 continue;
1663 switch(vm_customstats[i].type)
1664 {
1665 //string as 16 bytes
1666 case 1:
1667 memset(s, 0, 17);
1668 strlcpy(s, PRVM_E_STRING(ent, vm_customstats[i].fieldoffset), 16);
1669 stats[i+32] = s[ 0] + s[ 1] * 256 + s[ 2] * 65536 + s[ 3] * 16777216;
1670 stats[i+33] = s[ 4] + s[ 5] * 256 + s[ 6] * 65536 + s[ 7] * 16777216;
1671 stats[i+34] = s[ 8] + s[ 9] * 256 + s[10] * 65536 + s[11] * 16777216;
1672 stats[i+35] = s[12] + s[13] * 256 + s[14] * 65536 + s[15] * 16777216;
1673 break;
1674 //float field sent as-is
1675 case 8:
1676 // can't directly use PRVM_E_INT on the field because it may be PRVM_64 and a double is not the representation we want to send
1677 u.f = PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
1678 stats[i+32] = u.i;
1679 break;
1680 //integer value of float field
1681 case 2:
1682 stats[i+32] = (int)PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
1683 break;
1684 default:
1685 break;
1686 }
1687 }
1688 }
1689
1690 // void(float index, float type, .void field) SV_AddStat = #232;
1691 // Set up an auto-sent player stat.
1692 // Client's get thier own fields sent to them. Index may not be less than 32.
1693 // Type is a value equating to the ev_ values found in qcc to dictate types. Valid ones are:
1694 // 1: string (4 stats carrying a total of 16 charactures)
1695 // 2: float (one stat, float converted to an integer for transportation)
1696 // 8: integer (one stat, not converted to an int, so this can be used to transport floats as floats - what a unique idea!)
1697 static void VM_SV_AddStat(prvm_prog_t *prog)
1698 {
1699 int off, i;
1700 unsigned char type;
1701
1702 VM_SAFEPARMCOUNT(3, VM_SV_AddStat);
1703
1704 if(!vm_customstats)
1705 {
1706 vm_customstats = (customstat_t *)Z_Malloc((MAX_CL_STATS-32) * sizeof(customstat_t));
1707 if(!vm_customstats)
1708 {
1709 VM_Warning(prog, "PF_SV_AddStat: not enough memory\n");
1710 return;
1711 }
1712 }
1713 i = (int)PRVM_G_FLOAT(OFS_PARM0);
1714 type = (int)PRVM_G_FLOAT(OFS_PARM1);
1715 off = PRVM_G_INT (OFS_PARM2);
1716 i -= 32;
1717
1718 if(i < 0)
1719 {
1720 VM_Warning(prog, "PF_SV_AddStat: index may not be less than 32\n");
1721 return;
1722 }
1723 if(i >= (MAX_CL_STATS-32))
1724 {
1725 VM_Warning(prog, "PF_SV_AddStat: index >= MAX_CL_STATS\n");
1726 return;
1727 }
1728 if(i > (MAX_CL_STATS-32-4) && type == 1)
1729 {
1730 VM_Warning(prog, "PF_SV_AddStat: index > (MAX_CL_STATS-4) with string\n");
1731 return;
1732 }
1733 vm_customstats[i].type = type;
1734 vm_customstats[i].fieldoffset = off;
1735 if(vm_customstats_last < i)
1736 vm_customstats_last = i;
1737 }
1738
1739 /*
1740 =================
1741 VM_SV_copyentity
1742
1743 copies data from one entity to another
1744
1745 copyentity(src, dst)
1746 =================
1747 */
1748 static void VM_SV_copyentity(prvm_prog_t *prog)
1749 {
1750 prvm_edict_t *in, *out;
1751 VM_SAFEPARMCOUNT(2, VM_SV_copyentity);
1752 in = PRVM_G_EDICT(OFS_PARM0);
1753 if (in == prog->edicts)
1754 {
1755 VM_Warning(prog, "copyentity: can not read world entity\n");
1756 return;
1757 }
1758 if (in->priv.server->free)
1759 {
1760 VM_Warning(prog, "copyentity: can not read free entity\n");
1761 return;
1762 }
1763 out = PRVM_G_EDICT(OFS_PARM1);
1764 if (out == prog->edicts)
1765 {
1766 VM_Warning(prog, "copyentity: can not modify world entity\n");
1767 return;
1768 }
1769 if (out->priv.server->free)
1770 {
1771 VM_Warning(prog, "copyentity: can not modify free entity\n");
1772 return;
1773 }
1774 memcpy(out->fields.fp, in->fields.fp, prog->entityfields * sizeof(prvm_vec_t));
1775 SV_LinkEdict(out);
1776 }
1777
1778
1779 /*
1780 =================
1781 VM_SV_setcolor
1782
1783 sets the color of a client and broadcasts the update to all connected clients
1784
1785 setcolor(clientent, value)
1786 =================
1787 */
1788 static void VM_SV_setcolor(prvm_prog_t *prog)
1789 {
1790 client_t *client;
1791 int entnum, i;
1792
1793 VM_SAFEPARMCOUNT(2, VM_SV_setcolor);
1794 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
1795 i = (int)PRVM_G_FLOAT(OFS_PARM1);
1796
1797 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
1798 {
1799 Con_Print("tried to setcolor a non-client\n");
1800 return;
1801 }
1802
1803 client = svs.clients + entnum-1;
1804 if (client->edict)
1805 {
1806 PRVM_serveredictfloat(client->edict, clientcolors) = i;
1807 PRVM_serveredictfloat(client->edict, team) = (i & 15) + 1;
1808 }
1809 client->colors = i;
1810 if (client->old_colors != client->colors)
1811 {
1812 client->old_colors = client->colors;
1813 // send notification to all clients
1814 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1815 MSG_WriteByte (&sv.reliable_datagram, client - svs.clients);
1816 MSG_WriteByte (&sv.reliable_datagram, client->colors);
1817 }
1818 }
1819
1820 /*
1821 =================
1822 VM_SV_effect
1823
1824 effect(origin, modelname, startframe, framecount, framerate)
1825 =================
1826 */
1827 static void VM_SV_effect(prvm_prog_t *prog)
1828 {
1829 int i;
1830 const char *s;
1831 vec3_t org;
1832 VM_SAFEPARMCOUNT(5, VM_SV_effect);
1833 s = PRVM_G_STRING(OFS_PARM1);
1834 if (!s[0])
1835 {
1836 VM_Warning(prog, "effect: no model specified\n");
1837 return;
1838 }
1839
1840 i = SV_ModelIndex(s, 1);
1841 if (!i)
1842 {
1843 VM_Warning(prog, "effect: model not precached\n");
1844 return;
1845 }
1846
1847 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1848 {
1849 VM_Warning(prog, "effect: framecount < 1\n");
1850 return;
1851 }
1852
1853 if (PRVM_G_FLOAT(OFS_PARM4) < 1)
1854 {
1855 VM_Warning(prog, "effect: framerate < 1\n");
1856 return;
1857 }
1858
1859 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
1860 SV_StartEffect(org, i, (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4));
1861 }
1862
1863 static void VM_SV_te_blood(prvm_prog_t *prog)
1864 {
1865 VM_SAFEPARMCOUNT(3, VM_SV_te_blood);
1866 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1867 return;
1868 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1869 MSG_WriteByte(&sv.datagram, TE_BLOOD);
1870 // origin
1871 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1872 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1873 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1874 // velocity
1875 MSG_WriteChar(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1876 MSG_WriteChar(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1877 MSG_WriteChar(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1878 // count
1879 MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1880 SV_FlushBroadcastMessages();
1881 }
1882
1883 static void VM_SV_te_bloodshower(prvm_prog_t *prog)
1884 {
1885 VM_SAFEPARMCOUNT(4, VM_SV_te_bloodshower);
1886 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1887 return;
1888 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1889 MSG_WriteByte(&sv.datagram, TE_BLOODSHOWER);
1890 // min
1891 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1892 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1893 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1894 // max
1895 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1896 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1897 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1898 // speed
1899 MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM2), sv.protocol);
1900 // count
1901 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1902 SV_FlushBroadcastMessages();
1903 }
1904
1905 static void VM_SV_te_explosionrgb(prvm_prog_t *prog)
1906 {
1907 VM_SAFEPARMCOUNT(2, VM_SV_te_explosionrgb);
1908 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1909 MSG_WriteByte(&sv.datagram, TE_EXPLOSIONRGB);
1910 // origin
1911 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1912 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1913 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1914 // color
1915 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[0] * 255), 255));
1916 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[1] * 255), 255));
1917 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[2] * 255), 255));
1918 SV_FlushBroadcastMessages();
1919 }
1920
1921 static void VM_SV_te_particlecube(prvm_prog_t *prog)
1922 {
1923 VM_SAFEPARMCOUNT(7, VM_SV_te_particlecube);
1924 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1925 return;
1926 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1927 MSG_WriteByte(&sv.datagram, TE_PARTICLECUBE);
1928 // min
1929 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1930 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1931 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1932 // max
1933 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1934 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1935 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1936 // velocity
1937 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1938 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1939 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1940 // count
1941 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1942 // color
1943 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1944 // gravity true/false
1945 MSG_WriteByte(&sv.datagram, ((int) PRVM_G_FLOAT(OFS_PARM5)) != 0);
1946 // randomvel
1947 MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM6), sv.protocol);
1948 SV_FlushBroadcastMessages();
1949 }
1950
1951 static void VM_SV_te_particlerain(prvm_prog_t *prog)
1952 {
1953 VM_SAFEPARMCOUNT(5, VM_SV_te_particlerain);
1954 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1955 return;
1956 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1957 MSG_WriteByte(&sv.datagram, TE_PARTICLERAIN);
1958 // min
1959 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1960 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1961 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1962 // max
1963 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1964 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1965 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1966 // velocity
1967 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1968 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1969 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1970 // count
1971 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1972 // color
1973 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1974 SV_FlushBroadcastMessages();
1975 }
1976
1977 static void VM_SV_te_particlesnow(prvm_prog_t *prog)
1978 {
1979 VM_SAFEPARMCOUNT(5, VM_SV_te_particlesnow);
1980 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1981 return;
1982 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1983 MSG_WriteByte(&sv.datagram, TE_PARTICLESNOW);
1984 // min
1985 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1986 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1987 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1988 // max
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 // velocity
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 // count
1997 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1998 // color
1999 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
2000 SV_FlushBroadcastMessages();
2001 }
2002
2003 static void VM_SV_te_spark(prvm_prog_t *prog)
2004 {
2005 VM_SAFEPARMCOUNT(3, VM_SV_te_spark);
2006 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
2007 return;
2008 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2009 MSG_WriteByte(&sv.datagram, TE_SPARK);
2010 // origin
2011 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2012 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2013 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2014 // velocity
2015 MSG_WriteChar(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
2016 MSG_WriteChar(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
2017 MSG_WriteChar(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
2018 // count
2019 MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
2020 SV_FlushBroadcastMessages();
2021 }
2022
2023 static void VM_SV_te_gunshotquad(prvm_prog_t *prog)
2024 {
2025 VM_SAFEPARMCOUNT(1, VM_SV_te_gunshotquad);
2026 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2027 MSG_WriteByte(&sv.datagram, TE_GUNSHOTQUAD);
2028 // origin
2029 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2030 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2031 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2032 SV_FlushBroadcastMessages();
2033 }
2034
2035 static void VM_SV_te_spikequad(prvm_prog_t *prog)
2036 {
2037 VM_SAFEPARMCOUNT(1, VM_SV_te_spikequad);
2038 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2039 MSG_WriteByte(&sv.datagram, TE_SPIKEQUAD);
2040 // origin
2041 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2042 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2043 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2044 SV_FlushBroadcastMessages();
2045 }
2046
2047 static void VM_SV_te_superspikequad(prvm_prog_t *prog)
2048 {
2049 VM_SAFEPARMCOUNT(1, VM_SV_te_superspikequad);
2050 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2051 MSG_WriteByte(&sv.datagram, TE_SUPERSPIKEQUAD);
2052 // origin
2053 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2054 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2055 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2056 SV_FlushBroadcastMessages();
2057 }
2058
2059 static void VM_SV_te_explosionquad(prvm_prog_t *prog)
2060 {
2061 VM_SAFEPARMCOUNT(1, VM_SV_te_explosionquad);
2062 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2063 MSG_WriteByte(&sv.datagram, TE_EXPLOSIONQUAD);
2064 // origin
2065 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2066 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2067 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2068 SV_FlushBroadcastMessages();
2069 }
2070
2071 static void VM_SV_te_smallflash(prvm_prog_t *prog)
2072 {
2073 VM_SAFEPARMCOUNT(1, VM_SV_te_smallflash);
2074 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2075 MSG_WriteByte(&sv.datagram, TE_SMALLFLASH);
2076 // origin
2077 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2078 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2079 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2080 SV_FlushBroadcastMessages();
2081 }
2082
2083 static void VM_SV_te_customflash(prvm_prog_t *prog)
2084 {
2085 VM_SAFEPARMCOUNT(4, VM_SV_te_customflash);
2086 if (PRVM_G_FLOAT(OFS_PARM1) < 8 || PRVM_G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
2087 return;
2088 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2089 MSG_WriteByte(&sv.datagram, TE_CUSTOMFLASH);
2090 // origin
2091 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2092 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2093 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2094 // radius
2095 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM1) / 8 - 1, 255));
2096 // lifetime
2097 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM2) * 256 - 1, 255));
2098 // color
2099 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[0] * 255, 255));
2100 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[1] * 255, 255));
2101 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[2] * 255, 255));
2102 SV_FlushBroadcastMessages();
2103 }
2104
2105 static void VM_SV_te_gunshot(prvm_prog_t *prog)
2106 {
2107 VM_SAFEPARMCOUNT(1, VM_SV_te_gunshot);
2108 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2109 MSG_WriteByte(&sv.datagram, TE_GUNSHOT);
2110 // origin
2111 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2112 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2113 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2114 SV_FlushBroadcastMessages();
2115 }
2116
2117 static void VM_SV_te_spike(prvm_prog_t *prog)
2118 {
2119 VM_SAFEPARMCOUNT(1, VM_SV_te_spike);
2120 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2121 MSG_WriteByte(&sv.datagram, TE_SPIKE);
2122 // origin
2123 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2124 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2125 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2126 SV_FlushBroadcastMessages();
2127 }
2128
2129 static void VM_SV_te_superspike(prvm_prog_t *prog)
2130 {
2131 VM_SAFEPARMCOUNT(1, VM_SV_te_superspike);
2132 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2133 MSG_WriteByte(&sv.datagram, TE_SUPERSPIKE);
2134 // origin
2135 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2136 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2137 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2138 SV_FlushBroadcastMessages();
2139 }
2140
2141 static void VM_SV_te_explosion(prvm_prog_t *prog)
2142 {
2143 VM_SAFEPARMCOUNT(1, VM_SV_te_explosion);
2144 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2145 MSG_WriteByte(&sv.datagram, TE_EXPLOSION);
2146 // origin
2147 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2148 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2149 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2150 SV_FlushBroadcastMessages();
2151 }
2152
2153 static void VM_SV_te_tarexplosion(prvm_prog_t *prog)
2154 {
2155 VM_SAFEPARMCOUNT(1, VM_SV_te_tarexplosion);
2156 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2157 MSG_WriteByte(&sv.datagram, TE_TAREXPLOSION);
2158 // origin
2159 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2160 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2161 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2162 SV_FlushBroadcastMessages();
2163 }
2164
2165 static void VM_SV_te_wizspike(prvm_prog_t *prog)
2166 {
2167 VM_SAFEPARMCOUNT(1, VM_SV_te_wizspike);
2168 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2169 MSG_WriteByte(&sv.datagram, TE_WIZSPIKE);
2170 // origin
2171 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2172 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2173 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2174 SV_FlushBroadcastMessages();
2175 }
2176
2177 static void VM_SV_te_knightspike(prvm_prog_t *prog)
2178 {
2179 VM_SAFEPARMCOUNT(1, VM_SV_te_knightspike);
2180 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2181 MSG_WriteByte(&sv.datagram, TE_KNIGHTSPIKE);
2182 // origin
2183 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2184 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2185 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2186 SV_FlushBroadcastMessages();
2187 }
2188
2189 static void VM_SV_te_lavasplash(prvm_prog_t *prog)
2190 {
2191 VM_SAFEPARMCOUNT(1, VM_SV_te_lavasplash);
2192 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2193 MSG_WriteByte(&sv.datagram, TE_LAVASPLASH);
2194 // origin
2195 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2196 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2197 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2198 SV_FlushBroadcastMessages();
2199 }
2200
2201 static void VM_SV_te_teleport(prvm_prog_t *prog)
2202 {
2203 VM_SAFEPARMCOUNT(1, VM_SV_te_teleport);
2204 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2205 MSG_WriteByte(&sv.datagram, TE_TELEPORT);
2206 // origin
2207 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2208 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2209 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2210 SV_FlushBroadcastMessages();
2211 }
2212
2213 static void VM_SV_te_explosion2(prvm_prog_t *prog)
2214 {
2215 VM_SAFEPARMCOUNT(3, VM_SV_te_explosion2);
2216 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2217 MSG_WriteByte(&sv.datagram, TE_EXPLOSION2);
2218 // origin
2219 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2220 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2221 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2222 // color
2223 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
2224 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
2225 SV_FlushBroadcastMessages();
2226 }
2227
2228 static void VM_SV_te_lightning1(prvm_prog_t *prog)
2229 {
2230 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning1);
2231 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2232 MSG_WriteByte(&sv.datagram, TE_LIGHTNING1);
2233 // owner entity
2234 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2235 // start
2236 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2237 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2238 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2239 // end
2240 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2241 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2242 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2243 SV_FlushBroadcastMessages();
2244 }
2245
2246 static void VM_SV_te_lightning2(prvm_prog_t *prog)
2247 {
2248 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning2);
2249 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2250 MSG_WriteByte(&sv.datagram, TE_LIGHTNING2);
2251 // owner entity
2252 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2253 // start
2254 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2255 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2256 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2257 // end
2258 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2259 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2260 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2261 SV_FlushBroadcastMessages();
2262 }
2263
2264 static void VM_SV_te_lightning3(prvm_prog_t *prog)
2265 {
2266 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning3);
2267 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2268 MSG_WriteByte(&sv.datagram, TE_LIGHTNING3);
2269 // owner entity
2270 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2271 // start
2272 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2273 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2274 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2275 // end
2276 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2277 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2278 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2279 SV_FlushBroadcastMessages();
2280 }
2281
2282 static void VM_SV_te_beam(prvm_prog_t *prog)
2283 {
2284 VM_SAFEPARMCOUNT(3, VM_SV_te_beam);
2285 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2286 MSG_WriteByte(&sv.datagram, TE_BEAM);
2287 // owner entity
2288 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2289 // start
2290 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2291 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2292 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2293 // end
2294 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2295 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2296 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2297 SV_FlushBroadcastMessages();
2298 }
2299
2300 static void VM_SV_te_plasmaburn(prvm_prog_t *prog)
2301 {
2302 VM_SAFEPARMCOUNT(1, VM_SV_te_plasmaburn);
2303 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2304 MSG_WriteByte(&sv.datagram, TE_PLASMABURN);
2305 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2306 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2307 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2308 SV_FlushBroadcastMessages();
2309 }
2310
2311 static void VM_SV_te_flamejet(prvm_prog_t *prog)
2312 {
2313 VM_SAFEPARMCOUNT(3, VM_SV_te_flamejet);
2314 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2315 MSG_WriteByte(&sv.datagram, TE_FLAMEJET);
2316 // org
2317 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2318 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2319 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2320 // vel
2321 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2322 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2323 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2324 // count
2325 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
2326 SV_FlushBroadcastMessages();
2327 }
2328
2329 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2330 //this function originally written by KrimZon, made shorter by LordHavoc
2331 static void VM_SV_clientcommand(prvm_prog_t *prog)
2332 {
2333 client_t *temp_client;
2334 int i;
2335 VM_SAFEPARMCOUNT(2, VM_SV_clientcommand);
2336
2337 //find client for this entity
2338 i = (PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0)) - 1);
2339 if (i < 0 || i >= svs.maxclients || !svs.clients[i].active)
2340 {
2341 Con_Print("PF_clientcommand: entity is not a client\n");
2342 return;
2343 }
2344
2345 temp_client = host_client;
2346 host_client = svs.clients + i;
2347 Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client, true);
2348 host_client = temp_client;
2349 }
2350
2351 //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)
2352 static void VM_SV_setattachment(prvm_prog_t *prog)
2353 {
2354 prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
2355 prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
2356 const char *tagname = PRVM_G_STRING(OFS_PARM2);
2357 dp_model_t *model;
2358 int tagindex;
2359 VM_SAFEPARMCOUNT(3, VM_SV_setattachment);
2360
2361 if (e == prog->edicts)
2362 {
2363 VM_Warning(prog, "setattachment: can not modify world entity\n");
2364 return;
2365 }
2366 if (e->priv.server->free)
2367 {
2368 VM_Warning(prog, "setattachment: can not modify free entity\n");
2369 return;
2370 }
2371
2372 if (tagentity == NULL)
2373 tagentity = prog->edicts;
2374
2375 tagindex = 0;
2376
2377 if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2378 {
2379 model = SV_GetModelFromEdict(tagentity);
2380 if (model)
2381 {
2382 tagindex = Mod_Alias_GetTagIndexForName(model, (int)PRVM_serveredictfloat(tagentity, skin), tagname);
2383 if (tagindex == 0)
2384 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);
2385 }
2386 else
2387 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));
2388 }
2389
2390 PRVM_serveredictedict(e, tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
2391 PRVM_serveredictfloat(e, tag_index) = tagindex;
2392 }
2393
2394 /////////////////////////////////////////
2395 // DP_MD3_TAGINFO extension coded by VorteX
2396
2397 static int SV_GetTagIndex (prvm_prog_t *prog, prvm_edict_t *e, const char *tagname)
2398 {
2399 int i;
2400
2401 i = (int)PRVM_serveredictfloat(e, modelindex);
2402 if (i < 1 || i >= MAX_MODELS)
2403 return -1;
2404
2405 return Mod_Alias_GetTagIndexForName(SV_GetModelByIndex(i), (int)PRVM_serveredictfloat(e, skin), tagname);
2406 }
2407
2408 static int SV_GetExtendedTagInfo (prvm_prog_t *prog, prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
2409 {
2410 int r;
2411 dp_model_t *model;
2412
2413 *tagname = NULL;
2414 *parentindex = 0;
2415 Matrix4x4_CreateIdentity(tag_localmatrix);
2416
2417 if (tagindex >= 0 && (model = SV_GetModelFromEdict(e)) && model->num_bones)
2418 {
2419 r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)PRVM_serveredictfloat(e, skin), e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
2420
2421 if(!r) // success?
2422 *parentindex += 1;
2423
2424 return r;
2425 }
2426
2427 return 1;
2428 }
2429
2430 void SV_GetEntityMatrix (prvm_prog_t *prog, prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2431 {
2432 float scale;
2433 float pitchsign = 1;
2434
2435 scale = PRVM_serveredictfloat(ent, scale);
2436 if (!scale)
2437 scale = 1.0f;
2438
2439 if (viewmatrix)
2440 Matrix4x4_CreateFromQuakeEntity(out, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2] + PRVM_serveredictvector(ent, view_ofs)[2], PRVM_serveredictvector(ent, v_angle)[0], PRVM_serveredictvector(ent, v_angle)[1], PRVM_serveredictvector(ent, v_angle)[2], scale * cl_viewmodel_scale.value);
2441 else
2442 {
2443 pitchsign = SV_GetPitchSign(prog, ent);
2444 Matrix4x4_CreateFromQuakeEntity(out, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2], pitchsign * PRVM_serveredictvector(ent, angles)[0], PRVM_serveredictvector(ent, angles)[1], PRVM_serveredictvector(ent, angles)[2], scale);
2445 }
2446 }
2447
2448 static int SV_GetEntityLocalTagMatrix(prvm_prog_t *prog, prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2449 {
2450 dp_model_t *model;
2451 if (tagindex >= 0 && (model = SV_GetModelFromEdict(ent)) && model->animscenes)
2452 {
2453 VM_GenerateFrameGroupBlend(prog, ent->priv.server->framegroupblend, ent);
2454 VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model, sv.time);
2455 VM_UpdateEdictSkeleton(prog, ent, model, ent->priv.server->frameblend);
2456 return Mod_Alias_GetTagMatrix(model, ent->priv.server->frameblend, &ent->priv.server->skeleton, tagindex, out);
2457 }
2458 *out = identitymatrix;
2459 return 0;
2460 }
2461
2462 // Warnings/errors code:
2463 // 0 - normal (everything all-right)
2464 // 1 - world entity
2465 // 2 - free entity
2466 // 3 - null or non-precached model
2467 // 4 - no tags with requested index
2468 // 5 - runaway loop at attachment chain
2469 extern cvar_t cl_bob;
2470 extern cvar_t cl_bobcycle;
2471 extern cvar_t cl_bobup;
2472 static int SV_GetTagMatrix (prvm_prog_t *prog, matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
2473 {
2474 int ret;
2475 int modelindex, attachloop;
2476 matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2477 dp_model_t *model;
2478
2479 *out = identitymatrix; // warnings and errors return identical matrix
2480
2481 if (ent == prog->edicts)
2482 return 1;
2483 if (ent->priv.server->free)
2484 return 2;
2485
2486 modelindex = (int)PRVM_serveredictfloat(ent, modelindex);
2487 if (modelindex <= 0 || modelindex >= MAX_MODELS)
2488 return 3;
2489
2490 model = SV_GetModelByIndex(modelindex);
2491
2492 VM_GenerateFrameGroupBlend(prog, ent->priv.server->framegroupblend, ent);
2493 VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model, sv.time);
2494 VM_UpdateEdictSkeleton(prog, ent, model, ent->priv.server->frameblend);
2495
2496 tagmatrix = identitymatrix;
2497 // DP_GFX_QUAKE3MODELTAGS, scan all chain and stop on unattached entity
2498 attachloop = 0;
2499 for (;;)
2500 {
2501 if (attachloop >= 256) // prevent runaway looping
2502 return 5;
2503 // apply transformation by child's tagindex on parent entity and then
2504 // by parent entity itself
2505 ret = SV_GetEntityLocalTagMatrix(prog, ent, tagindex - 1, &attachmatrix);
2506 if (ret && attachloop == 0)
2507 return ret;
2508 SV_GetEntityMatrix(prog, ent, &entitymatrix, false);
2509 Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
2510 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2511 // next iteration we process the parent entity
2512 if (PRVM_serveredictedict(ent, tag_entity))
2513 {
2514 tagindex = (int)PRVM_serveredictfloat(ent, tag_index);
2515 ent = PRVM_EDICT_NUM(PRVM_serveredictedict(ent, tag_entity));
2516 }
2517 else
2518 break;
2519 attachloop++;
2520 }
2521
2522 // RENDER_VIEWMODEL magic
2523 if (PRVM_serveredictedict(ent, viewmodelforclient))
2524 {
2525 Matrix4x4_Copy(&tagmatrix, out);
2526 ent = PRVM_EDICT_NUM(PRVM_serveredictedict(ent, viewmodelforclient));
2527
2528 SV_GetEntityMatrix(prog, ent, &entitymatrix, true);
2529 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2530
2531 /*
2532 // Cl_bob, ported from rendering code
2533 if (PRVM_serveredictfloat(ent, health) > 0 && cl_bob.value && cl_bobcycle.value)
2534 {
2535 double bob, cycle;
2536 // LordHavoc: this code is *weird*, but not replacable (I think it
2537 // should be done in QC on the server, but oh well, quake is quake)
2538 // LordHavoc: figured out bobup: the time at which the sin is at 180
2539 // degrees (which allows lengthening or squishing the peak or valley)
2540 cycle = sv.time/cl_bobcycle.value;
2541 cycle -= (int)cycle;
2542 if (cycle < cl_bobup.value)
2543 cycle = sin(M_PI * cycle / cl_bobup.value);
2544 else
2545 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2546 // bob is proportional to velocity in the xy plane
2547 // (don't count Z, or jumping messes it up)
2548 bob = sqrt(PRVM_serveredictvector(ent, velocity)[0]*PRVM_serveredictvector(ent, velocity)[0] + PRVM_serveredictvector(ent, velocity)[1]*PRVM_serveredictvector(ent, velocity)[1])*cl_bob.value;
2549 bob = bob*0.3 + bob*0.7*cycle;
2550 Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2551 }
2552 */
2553 }
2554 return 0;
2555 }
2556
2557 //float(entity ent, string tagname) gettagindex;
2558
2559 static void VM_SV_gettagindex(prvm_prog_t *prog)
2560 {
2561 prvm_edict_t *ent;
2562 const char *tag_name;
2563 int tag_index;
2564
2565 VM_SAFEPARMCOUNT(2, VM_SV_gettagindex);
2566
2567 ent = PRVM_G_EDICT(OFS_PARM0);
2568 tag_name = PRVM_G_STRING(OFS_PARM1);
2569
2570 if (ent == prog->edicts)
2571 {
2572 VM_Warning(prog, "VM_SV_gettagindex(entity #%i): can't affect world entity\n", PRVM_NUM_FOR_EDICT(ent));
2573 return;
2574 }
2575 if (ent->priv.server->free)
2576 {
2577 VM_Warning(prog, "VM_SV_gettagindex(entity #%i): can't affect free entity\n", PRVM_NUM_FOR_EDICT(ent));
2578 return;
2579 }
2580
2581 tag_index = 0;
2582 if (!SV_GetModelFromEdict(ent))
2583 Con_DPrintf("VM_SV_gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2584 else
2585 {
2586 tag_index = SV_GetTagIndex(prog, ent, tag_name);
2587 if (tag_index == 0)
2588 if(developer_extra.integer)
2589 Con_DPrintf("VM_SV_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2590 }
2591 PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2592 }
2593
2594 //vector(entity ent, float tagindex) gettaginfo;
2595 static void VM_SV_gettaginfo(prvm_prog_t *prog)
2596 {
2597 prvm_edict_t *e;
2598 int tagindex;
2599 matrix4x4_t tag_matrix;
2600 matrix4x4_t tag_localmatrix;
2601 int parentindex;
2602 const char *tagname;
2603 int returncode;
2604 vec3_t forward, left, up, origin;
2605 const dp_model_t *model;
2606
2607 VM_SAFEPARMCOUNT(2, VM_SV_gettaginfo);
2608
2609 e = PRVM_G_EDICT(OFS_PARM0);
2610 tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2611
2612 returncode = SV_GetTagMatrix(prog, &tag_matrix, e, tagindex);
2613 Matrix4x4_ToVectors(&tag_matrix, forward, left, up, origin);
2614 VectorCopy(forward, PRVM_serverglobalvector(v_forward));
2615 VectorNegate(left, PRVM_serverglobalvector(v_right));
2616 VectorCopy(up, PRVM_serverglobalvector(v_up));
2617 VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
2618 model = SV_GetModelFromEdict(e);
2619 VM_GenerateFrameGroupBlend(prog, e->priv.server->framegroupblend, e);
2620 VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model, sv.time);
2621 VM_UpdateEdictSkeleton(prog, e, model, e->priv.server->frameblend);
2622 SV_GetExtendedTagInfo(prog, e, tagindex, &parentindex, &tagname, &tag_localmatrix);
2623 Matrix4x4_ToVectors(&tag_localmatrix, forward, left, up, origin);
2624
2625 PRVM_serverglobalfloat(gettaginfo_parent) = parentindex;
2626 PRVM_serverglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(prog, tagname) : 0;
2627 VectorCopy(forward, PRVM_serverglobalvector(gettaginfo_forward));
2628 VectorNegate(left, PRVM_serverglobalvector(gettaginfo_right));
2629 VectorCopy(up, PRVM_serverglobalvector(gettaginfo_up));
2630 VectorCopy(origin, PRVM_serverglobalvector(gettaginfo_offset));
2631
2632 switch(returncode)
2633 {
2634 case 1:
2635 VM_Warning(prog, "gettagindex: can't affect world entity\n");
2636 break;
2637 case 2:
2638 VM_Warning(prog, "gettagindex: can't affect free entity\n");
2639 break;
2640 case 3:
2641 Con_DPrintf("SV_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2642 break;
2643 case 4:
2644 Con_DPrintf("SV_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2645 break;
2646 case 5:
2647 Con_DPrintf("SV_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2648 break;
2649 }
2650 }
2651
2652 //void(entity clent) dropclient (DP_SV_DROPCLIENT)
2653 static void VM_SV_dropclient(prvm_prog_t *prog)
2654 {
2655 int clientnum;
2656 client_t *oldhostclient;
2657 VM_SAFEPARMCOUNT(1, VM_SV_dropclient);
2658 clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2659 if (clientnum < 0 || clientnum >= svs.maxclients)
2660 {
2661 VM_Warning(prog, "dropclient: not a client\n");
2662 return;
2663 }
2664 if (!svs.clients[clientnum].active)
2665 {
2666 VM_Warning(prog, "dropclient: that client slot is not connected\n");
2667 return;
2668 }
2669 oldhostclient = host_client;
2670 host_client = svs.clients + clientnum;
2671 SV_DropClient(false);
2672 host_client = oldhostclient;
2673 }
2674
2675 //entity() spawnclient (DP_SV_BOTCLIENT)
2676 static void VM_SV_spawnclient(prvm_prog_t *prog)
2677 {
2678 int i;
2679 prvm_edict_t *ed;
2680 VM_SAFEPARMCOUNT(0, VM_SV_spawnclient);
2681 prog->xfunction->builtinsprofile += 2;
2682 ed = prog->edicts;
2683 for (i = 0;i < svs.maxclients;i++)
2684 {
2685 if (!svs.clients[i].active)
2686 {
2687 prog->xfunction->builtinsprofile += 100;
2688 SV_ConnectClient (i, NULL);
2689 // this has to be set or else ClientDisconnect won't be called
2690 // we assume the qc will call ClientConnect...
2691 svs.clients[i].clientconnectcalled = true;
2692 ed = PRVM_EDICT_NUM(i + 1);
2693 break;
2694 }
2695 }
2696 VM_RETURN_EDICT(ed);
2697 }
2698
2699 //float(entity clent) clienttype (DP_SV_BOTCLIENT)
2700 static void VM_SV_clienttype(prvm_prog_t *prog)
2701 {
2702 int clientnum;
2703 VM_SAFEPARMCOUNT(1, VM_SV_clienttype);
2704 clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2705 if (clientnum < 0 || clientnum >= svs.maxclients)
2706 PRVM_G_FLOAT(OFS_RETURN) = 3;
2707 else if (!svs.clients[clientnum].active)
2708 PRVM_G_FLOAT(OFS_RETURN) = 0;
2709 else if (svs.clients[clientnum].netconnection)
2710 PRVM_G_FLOAT(OFS_RETURN) = 1;
2711 else
2712 PRVM_G_FLOAT(OFS_RETURN) = 2;
2713 }
2714
2715 /*
2716 ===============
2717 VM_SV_serverkey
2718
2719 string(string key) serverkey
2720 ===============
2721 */
2722 static void VM_SV_serverkey(prvm_prog_t *prog)
2723 {
2724 char string[VM_STRINGTEMP_LENGTH];
2725 VM_SAFEPARMCOUNT(1, VM_SV_serverkey);
2726 InfoString_GetValue(svs.serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
2727 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
2728 }
2729
2730 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
2731 static void VM_SV_setmodelindex(prvm_prog_t *prog)
2732 {
2733 prvm_edict_t *e;
2734 dp_model_t *mod;
2735 int i;
2736 VM_SAFEPARMCOUNT(2, VM_SV_setmodelindex);
2737
2738 e = PRVM_G_EDICT(OFS_PARM0);
2739 if (e == prog->edicts)
2740 {
2741 VM_Warning(prog, "setmodelindex: can not modify world entity\n");
2742 return;
2743 }
2744 if (e->priv.server->free)
2745 {
2746 VM_Warning(prog, "setmodelindex: can not modify free entity\n");
2747 return;
2748 }
2749 i = (int)PRVM_G_FLOAT(OFS_PARM1);
2750 if (i <= 0 || i >= MAX_MODELS)
2751 {
2752 VM_Warning(prog, "setmodelindex: invalid modelindex\n");
2753 return;
2754 }
2755 if (!sv.model_precache[i][0])
2756 {
2757 VM_Warning(prog, "setmodelindex: model not precached\n");
2758 return;
2759 }
2760
2761 PRVM_serveredictstring(e, model) = PRVM_SetEngineString(prog, sv.model_precache[i]);
2762 PRVM_serveredictfloat(e, modelindex) = i;
2763
2764 mod = SV_GetModelByIndex(i);
2765
2766 if (mod)
2767 {
2768 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
2769 SetMinMaxSize(prog, e, mod->normalmins, mod->normalmaxs, true);
2770 else
2771 SetMinMaxSize(prog, e, quakemins, quakemaxs, true);
2772 }
2773 else
2774 SetMinMaxSize(prog, e, vec3_origin, vec3_origin, true);
2775 }
2776
2777 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
2778 static void VM_SV_modelnameforindex(prvm_prog_t *prog)
2779 {
2780 int i;
2781 VM_SAFEPARMCOUNT(1, VM_SV_modelnameforindex);
2782
2783 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2784
2785 i = (int)PRVM_G_FLOAT(OFS_PARM0);
2786 if (i <= 0 || i >= MAX_MODELS)
2787 {
2788 VM_Warning(prog, "modelnameforindex: invalid modelindex\n");
2789 return;
2790 }
2791 if (!sv.model_precache[i][0])
2792 {
2793 VM_Warning(prog, "modelnameforindex: model not precached\n");
2794 return;
2795 }
2796
2797 PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(prog, sv.model_precache[i]);
2798 }
2799
2800 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
2801 static void VM_SV_particleeffectnum(prvm_prog_t *prog)
2802 {
2803 int i;
2804 VM_SAFEPARMCOUNT(1, VM_SV_particleeffectnum);
2805 i = SV_ParticleEffectIndex(PRVM_G_STRING(OFS_PARM0));
2806 if (i == 0)
2807 i = -1;
2808 PRVM_G_FLOAT(OFS_RETURN) = i;
2809 }
2810
2811 // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
2812 static void VM_SV_trailparticles(prvm_prog_t *prog)
2813 {
2814 vec3_t start, end;
2815 VM_SAFEPARMCOUNT(4, VM_SV_trailparticles);
2816
2817 if ((int)PRVM_G_FLOAT(OFS_PARM0) < 0)
2818 return;
2819
2820 MSG_WriteByte(&sv.datagram, svc_trailparticles);
2821 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2822 MSG_WriteShort(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
2823 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), start);
2824 VectorCopy(PRVM_G_VECTOR(OFS_PARM3), end);
2825 MSG_WriteVector(&sv.datagram, start, sv.protocol);
2826 MSG_WriteVector(&sv.datagram, end, sv.protocol);
2827 SV_FlushBroadcastMessages();
2828 }
2829
2830 //#337 void(float effectnum, vector origin, vector dir, float count) pointparticles (EXT_CSQC)
2831 static void VM_SV_pointparticles(prvm_prog_t *prog)
2832 {
2833 int effectnum, count;
2834 vec3_t org, vel;
2835 VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_pointparticles);
2836
2837 if ((int)PRVM_G_FLOAT(OFS_PARM0) < 0)
2838 return;
2839
2840 effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
2841 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), org);
2842 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
2843 count = bound(0, (int)PRVM_G_FLOAT(OFS_PARM3), 65535);
2844 if (count == 1 && !VectorLength2(vel))
2845 {
2846 // 1+2+12=15 bytes
2847 MSG_WriteByte(&sv.datagram, svc_pointparticles1);
2848 MSG_WriteShort(&sv.datagram, effectnum);
2849 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2850 }
2851 else
2852 {
2853 // 1+2+12+12+2=29 bytes
2854 MSG_WriteByte(&sv.datagram, svc_pointparticles);
2855 MSG_WriteShort(&sv.datagram, effectnum);
2856 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2857 MSG_WriteVector(&sv.datagram, vel, sv.protocol);
2858 MSG_WriteShort(&sv.datagram, count);
2859 }
2860
2861 SV_FlushBroadcastMessages();
2862 }
2863
2864 //PF_setpause, // void(float pause) setpause = #531;
2865 static void VM_SV_setpause(prvm_prog_t *prog) {
2866 int pauseValue;
2867 pauseValue = (int)PRVM_G_FLOAT(OFS_PARM0);
2868 if (pauseValue != 0) { //pause the game
2869 sv.paused = 1;
2870 sv.pausedstart = realtime;
2871 } else { //disable pause, in case it was enabled
2872 if (sv.paused != 0) {
2873 sv.paused = 0;
2874 sv.pausedstart = 0;
2875 }
2876 }
2877 // send notification to all clients
2878 MSG_WriteByte(&sv.reliable_datagram, svc_setpause);
2879 MSG_WriteByte(&sv.reliable_datagram, sv.paused);
2880 }
2881
2882 // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
2883 static void VM_SV_skel_create(prvm_prog_t *prog)
2884 {
2885 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
2886 dp_model_t *model = SV_GetModelByIndex(modelindex);
2887 skeleton_t *skeleton;
2888 int i;
2889 PRVM_G_FLOAT(OFS_RETURN) = 0;
2890 if (!model || !model->num_bones)
2891 return;
2892 for (i = 0;i < MAX_EDICTS;i++)
2893 if (!prog->skeletons[i])
2894 break;
2895 if (i == MAX_EDICTS)
2896 return;
2897 prog->skeletons[i] = skeleton = (skeleton_t *)Mem_Alloc(prog->progs_mempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
2898 PRVM_G_FLOAT(OFS_RETURN) = i + 1;
2899 skeleton->model = model;
2900 skeleton->relativetransforms = (matrix4x4_t *)(skeleton+1);
2901 // initialize to identity matrices
2902 for (i = 0;i < skeleton->model->num_bones;i++)
2903 skeleton->relativetransforms[i] = identitymatrix;
2904 }
2905
2906 // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
2907 static void VM_SV_skel_build(prvm_prog_t *prog)
2908 {
2909 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
2910 skeleton_t *skeleton;
2911 prvm_edict_t *ed = PRVM_G_EDICT(OFS_PARM1);
2912 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM2);
2913 float retainfrac = PRVM_G_FLOAT(OFS_PARM3);
2914 int firstbone = PRVM_G_FLOAT(OFS_PARM4) - 1;
2915 int lastbone = PRVM_G_FLOAT(OFS_PARM5) - 1;
2916 dp_model_t *model = SV_GetModelByIndex(modelindex);
2917 int numblends;
2918 int bonenum;
2919 int blendindex;
2920 framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
2921 frameblend_t frameblend[MAX_FRAMEBLENDS];
2922 matrix4x4_t bonematrix;
2923 matrix4x4_t matrix;
2924 PRVM_G_FLOAT(OFS_RETURN) = 0;
2925 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
2926 return;
2927 firstbone = max(0, firstbone);
2928 lastbone = min(lastbone, model->num_bones - 1);
2929 lastbone = min(lastbone, skeleton->model->num_bones - 1);
2930 VM_GenerateFrameGroupBlend(prog, framegroupblend, ed);
2931 VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model, sv.time);
2932 for (numblends = 0;numblends < MAX_FRAMEBLENDS && frameblend[numblends].lerp;numblends++)
2933 ;
2934 for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
2935 {
2936 memset(&bonematrix, 0, sizeof(bonematrix));
2937 for (blendindex = 0;blendindex < numblends;blendindex++)
2938 {
2939 Matrix4x4_FromBonePose7s(&matrix, model->num_posescale, model->data_poses7s + 7 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
2940 Matrix4x4_Accumulate(&bonematrix, &matrix, frameblend[blendindex].lerp);
2941 }
2942 Matrix4x4_Normalize3(&bonematrix, &bonematrix);
2943 Matrix4x4_Interpolate(&skeleton->relativetransforms[bonenum], &bonematrix, &skeleton->relativetransforms[bonenum], retainfrac);
2944 }
2945 PRVM_G_FLOAT(OFS_RETURN) = skeletonindex + 1;
2946 }
2947
2948 // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
2949 static void VM_SV_skel_get_numbones(prvm_prog_t *prog)
2950 {
2951 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
2952 skeleton_t *skeleton;
2953 PRVM_G_FLOAT(OFS_RETURN) = 0;
2954 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
2955 return;
2956 PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->num_bones;
2957 }
2958
2959 // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
2960 static void VM_SV_skel_get_bonename(prvm_prog_t *prog)
2961 {
2962 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
2963 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
2964 skeleton_t *skeleton;
2965 PRVM_G_INT(OFS_RETURN) = 0;
2966 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
2967 return;
2968 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
2969 return;
2970 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, skeleton->model->data_bones[bonenum].name);
2971 }
2972
2973 // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, 0 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
2974 static void VM_SV_skel_get_boneparent(prvm_prog_t *prog)
2975 {
2976 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
2977 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
2978 skeleton_t *skeleton;
2979 PRVM_G_FLOAT(OFS_RETURN) = 0;
2980 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
2981 return;
2982 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
2983 return;
2984 PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->data_bones[bonenum].parent + 1;
2985 }
2986
2987 // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
2988 static void VM_SV_skel_find_bone(prvm_prog_t *prog)
2989 {
2990 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
2991 const char *tagname = PRVM_G_STRING(OFS_PARM1);
2992 skeleton_t *skeleton;
2993 PRVM_G_FLOAT(OFS_RETURN) = 0;
2994 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
2995 return;
2996 PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname) + 1;
2997 }
2998
2999 // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
3000 static void VM_SV_skel_get_bonerel(prvm_prog_t *prog)
3001 {
3002 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3003 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3004 skeleton_t *skeleton;
3005 matrix4x4_t matrix;
3006 vec3_t forward, left, up, origin;
3007 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
3008 VectorClear(PRVM_clientglobalvector(v_forward));
3009 VectorClear(PRVM_clientglobalvector(v_right));
3010 VectorClear(PRVM_clientglobalvector(v_up));
3011 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3012 return;
3013 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3014 return;
3015 matrix = skeleton->relativetransforms[bonenum];
3016 Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
3017 VectorCopy(forward, PRVM_clientglobalvector(v_forward));
3018 VectorNegate(left, PRVM_clientglobalvector(v_right));
3019 VectorCopy(up, PRVM_clientglobalvector(v_up));
3020 VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
3021 }
3022
3023 // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
3024 static void VM_SV_skel_get_boneabs(prvm_prog_t *prog)
3025 {
3026 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3027 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3028 skeleton_t *skeleton;
3029 matrix4x4_t matrix;
3030 matrix4x4_t temp;
3031 vec3_t forward, left, up, origin;
3032 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
3033 VectorClear(PRVM_clientglobalvector(v_forward));
3034 VectorClear(PRVM_clientglobalvector(v_right));
3035 VectorClear(PRVM_clientglobalvector(v_up));
3036 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3037 return;
3038 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3039 return;
3040 matrix = skeleton->relativetransforms[bonenum];
3041 // convert to absolute
3042 while ((bonenum = skeleton->model->data_bones[bonenum].parent) >= 0)
3043 {
3044 temp = matrix;
3045 Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
3046 }
3047 Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
3048 VectorCopy(forward, PRVM_clientglobalvector(v_forward));
3049 VectorNegate(left, PRVM_clientglobalvector(v_right));
3050 VectorCopy(up, PRVM_clientglobalvector(v_up));
3051 VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
3052 }
3053
3054 // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
3055 static void VM_SV_skel_set_bone(prvm_prog_t *prog)
3056 {
3057 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3058 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3059 vec3_t forward, left, up, origin;
3060 skeleton_t *skeleton;
3061 matrix4x4_t matrix;
3062 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3063 return;
3064 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3065 return;
3066 VectorCopy(PRVM_clientglobalvector(v_forward), forward);
3067 VectorNegate(PRVM_clientglobalvector(v_right), left);
3068 VectorCopy(PRVM_clientglobalvector(v_up), up);
3069 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
3070 Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
3071 skeleton->relativetransforms[bonenum] = matrix;
3072 }
3073
3074 // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
3075 static void VM_SV_skel_mul_bone(prvm_prog_t *prog)
3076 {
3077 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3078 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3079 vec3_t forward, left, up, origin;
3080 skeleton_t *skeleton;
3081 matrix4x4_t matrix;
3082 matrix4x4_t temp;
3083 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3084 return;
3085 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3086 return;
3087 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
3088 VectorCopy(PRVM_clientglobalvector(v_forward), forward);
3089 VectorNegate(PRVM_clientglobalvector(v_right), left);
3090 VectorCopy(PRVM_clientglobalvector(v_up), up);
3091 Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
3092 temp = skeleton->relativetransforms[bonenum];
3093 Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
3094 }
3095
3096 // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
3097 static void VM_SV_skel_mul_bones(prvm_prog_t *prog)
3098 {
3099 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3100 int firstbone = PRVM_G_FLOAT(OFS_PARM1) - 1;
3101 int lastbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
3102 int bonenum;
3103 vec3_t forward, left, up, origin;
3104 skeleton_t *skeleton;
3105 matrix4x4_t matrix;
3106 matrix4x4_t temp;
3107 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3108 return;
3109 VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
3110 VectorCopy(PRVM_clientglobalvector(v_forward), forward);
3111 VectorNegate(PRVM_clientglobalvector(v_right), left);
3112 VectorCopy(PRVM_clientglobalvector(v_up), up);
3113 Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
3114 firstbone = max(0, firstbone);
3115 lastbone = min(lastbone, skeleton->model->num_bones - 1);
3116 for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
3117 {
3118 temp = skeleton->relativetransforms[bonenum];
3119 Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
3120 }
3121 }
3122
3123 // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
3124 static void VM_SV_skel_copybones(prvm_prog_t *prog)
3125 {
3126 int skeletonindexdst = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3127 int skeletonindexsrc = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3128 int firstbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
3129 int lastbone = PRVM_G_FLOAT(OFS_PARM3) - 1;
3130 int bonenum;
3131 skeleton_t *skeletondst;
3132 skeleton_t *skeletonsrc;
3133 if (skeletonindexdst < 0 || skeletonindexdst >= MAX_EDICTS || !(skeletondst = prog->skeletons[skeletonindexdst]))
3134 return;
3135 if (skeletonindexsrc < 0 || skeletonindexsrc >= MAX_EDICTS || !(skeletonsrc = prog->skeletons[skeletonindexsrc]))
3136 return;
3137 firstbone = max(0, firstbone);
3138 lastbone = min(lastbone, skeletondst->model->num_bones - 1);
3139 lastbone = min(lastbone, skeletonsrc->model->num_bones - 1);
3140 for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
3141 skeletondst->relativetransforms[bonenum] = skeletonsrc->relativetransforms[bonenum];
3142 }
3143
3144 // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
3145 static void VM_SV_skel_delete(prvm_prog_t *prog)
3146 {
3147 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3148 skeleton_t *skeleton;
3149 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3150 return;
3151 Mem_Free(skeleton);
3152 prog->skeletons[skeletonindex] = NULL;
3153 }
3154
3155 // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
3156 static void VM_SV_frameforname(prvm_prog_t *prog)
3157 {
3158 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
3159 dp_model_t *model = SV_GetModelByIndex(modelindex);
3160 const char *name = PRVM_G_STRING(OFS_PARM1);
3161 int i;
3162 PRVM_G_FLOAT(OFS_RETURN) = -1;
3163 if (!model || !model->animscenes)
3164 return;
3165 for (i = 0;i < model->numframes;i++)
3166 {
3167 if (!strcasecmp(model->animscenes[i].name, name))
3168 {
3169 PRVM_G_FLOAT(OFS_RETURN) = i;
3170 break;
3171 }
3172 }
3173 }
3174
3175 // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
3176 static void VM_SV_frameduration(prvm_prog_t *prog)
3177 {
3178 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
3179 dp_model_t *model = SV_GetModelByIndex(modelindex);
3180 int framenum = (int)PRVM_G_FLOAT(OFS_PARM1);
3181 PRVM_G_FLOAT(OFS_RETURN) = 0;
3182 if (!model || !model->animscenes || framenum < 0 || framenum >= model->numframes)
3183 return;
3184 if (model->animscenes[framenum].framerate)
3185 PRVM_G_FLOAT(OFS_RETURN) = model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
3186 }
3187
3188
3189 prvm_builtin_t vm_sv_builtins[] = {
3190 NULL, // #0 NULL function (not callable) (QUAKE)
3191 VM_makevectors, // #1 void(vector ang) makevectors (QUAKE)
3192 VM_SV_setorigin, // #2 void(entity e, vector o) setorigin (QUAKE)
3193 VM_SV_setmodel, // #3 void(entity e, string m) setmodel (QUAKE)
3194 VM_SV_setsize, // #4 void(entity e, vector min, vector max) setsize (QUAKE)
3195 NULL, // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
3196 VM_break, // #6 void() break (QUAKE)
3197 VM_random, // #7 float() random (QUAKE)
3198 VM_SV_sound, // #8 void(entity e, float chan, string samp) sound (QUAKE)
3199 VM_normalize, // #9 vector(vector v) normalize (QUAKE)
3200 VM_error, // #10 void(string e) error (QUAKE)
3201 VM_objerror, // #11 void(string e) objerror (QUAKE)
3202 VM_vlen, // #12 float(vector v) vlen (QUAKE)
3203 VM_vectoyaw, // #13 float(vector v) vectoyaw (QUAKE)
3204 VM_spawn, // #14 entity() spawn (QUAKE)
3205 VM_remove, // #15 void(entity e) remove (QUAKE)
3206 VM_SV_traceline, // #16 void(vector v1, vector v2, float tryents) traceline (QUAKE)
3207 VM_SV_checkclient, // #17 entity() checkclient (QUAKE)
3208 VM_find, // #18 entity(entity start, .string fld, string match) find (QUAKE)
3209 VM_SV_precache_sound, // #19 void(string s) precache_sound (QUAKE)
3210 VM_SV_precache_model, // #20 void(string s) precache_model (QUAKE)
3211 VM_SV_stuffcmd, // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
3212 VM_SV_findradius, // #22 entity(vector org, float rad) findradius (QUAKE)
3213 VM_bprint, // #23 void(string s, ...) bprint (QUAKE)
3214 VM_SV_sprint, // #24 void(entity client, string s, ...) sprint (QUAKE)
3215 VM_dprint, // #25 void(string s, ...) dprint (QUAKE)
3216 VM_ftos, // #26 string(float f) ftos (QUAKE)
3217 VM_vtos, // #27 string(vector v) vtos (QUAKE)
3218 VM_coredump, // #28 void() coredump (QUAKE)
3219 VM_traceon, // #29 void() traceon (QUAKE)
3220 VM_traceoff, // #30 void() traceoff (QUAKE)
3221 VM_eprint, // #31 void(entity e) eprint (QUAKE)
3222 VM_SV_walkmove, // #32 float(float yaw, float dist) walkmove (QUAKE)
3223 NULL, // #33 (QUAKE)
3224 VM_SV_droptofloor, // #34 float() droptofloor (QUAKE)
3225 VM_SV_lightstyle, // #35 void(float style, string value) lightstyle (QUAKE)
3226 VM_rint, // #36 float(float v) rint (QUAKE)
3227 VM_floor, // #37 float(float v) floor (QUAKE)
3228 VM_ceil, // #38 float(float v) ceil (QUAKE)
3229 NULL, // #39 (QUAKE)
3230 VM_SV_checkbottom, // #40 float(entity e) checkbottom (QUAKE)
3231 VM_SV_pointcontents, // #41 float(vector v) pointcontents (QUAKE)
3232 NULL, // #42 (QUAKE)
3233 VM_fabs, // #43 float(float f) fabs (QUAKE)
3234 VM_SV_aim, // #44 vector(entity e, float speed) aim (QUAKE)
3235 VM_cvar, // #45 float(string s) cvar (QUAKE)
3236 VM_localcmd, // #46 void(string s) localcmd (QUAKE)
3237 VM_nextent, // #47 entity(entity e) nextent (QUAKE)
3238 VM_SV_particle, // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
3239 VM_changeyaw, // #49 void() ChangeYaw (QUAKE)
3240 NULL, // #50 (QUAKE)
3241 VM_vectoangles, // #51 vector(vector v) vectoangles (QUAKE)
3242 VM_SV_WriteByte, // #52 void(float to, float f) WriteByte (QUAKE)
3243 VM_SV_WriteChar, // #53 void(float to, float f) WriteChar (QUAKE)
3244 VM_SV_WriteShort, // #54 void(float to, float f) WriteShort (QUAKE)
3245 VM_SV_WriteLong, // #55 void(float to, float f) WriteLong (QUAKE)
3246 VM_SV_WriteCoord, // #56 void(float to, float f) WriteCoord (QUAKE)
3247 VM_SV_WriteAngle, // #57 void(float to, float f) WriteAngle (QUAKE)
3248 VM_SV_WriteString, // #58 void(float to, string s) WriteString (QUAKE)
3249 VM_SV_WriteEntity, // #59 void(float to, entity e) WriteEntity (QUAKE)
3250 VM_sin, // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW) (QUAKE)
3251 VM_cos, // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW) (QUAKE)
3252 VM_sqrt, // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW) (QUAKE)
3253 VM_changepitch, // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH) (QUAKE)
3254 VM_SV_tracetoss, // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS) (QUAKE)
3255 VM_etos, // #65 string(entity ent) etos (DP_QC_ETOS) (QUAKE)
3256 NULL, // #66 (QUAKE)
3257 VM_SV_MoveToGoal, // #67 void(float step) movetogoal (QUAKE)
3258 VM_precache_file, // #68 string(string s) precache_file (QUAKE)
3259 VM_SV_makestatic, // #69 void(entity e) makestatic (QUAKE)
3260 VM_changelevel, // #70 void(string s) changelevel (QUAKE)
3261 NULL, // #71 (QUAKE)
3262 VM_cvar_set, // #72 void(string var, string val) cvar_set (QUAKE)
3263 VM_SV_centerprint, // #73 void(entity client, strings) centerprint (QUAKE)
3264 VM_SV_ambientsound, // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
3265 VM_SV_precache_model, // #75 string(string s) precache_model2 (QUAKE)
3266 VM_SV_precache_sound, // #76 string(string s) precache_sound2 (QUAKE)
3267 VM_precache_file, // #77 string(string s) precache_file2 (QUAKE)
3268 VM_SV_setspawnparms, // #78 void(entity e) setspawnparms (QUAKE)
3269 NULL, // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
3270 NULL, // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
3271 VM_stof, // #81 float(string s) stof (FRIK_FILE)
3272 NULL, // #82 void(vector where, float set) multicast (QUAKEWORLD)
3273 NULL, // #83 (QUAKE)
3274 NULL, // #84 (QUAKE)
3275 NULL, // #85 (QUAKE)
3276 NULL, // #86 (QUAKE)
3277 NULL, // #87 (QUAKE)
3278 NULL, // #88 (QUAKE)
3279 NULL, // #89 (QUAKE)
3280 VM_SV_tracebox, // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
3281 VM_randomvec, // #91 vector() randomvec (DP_QC_RANDOMVEC)
3282 VM_SV_getlight, // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
3283 VM_registercvar, // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
3284 VM_min, // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
3285 VM_max, // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
3286 VM_bound, // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
3287 VM_pow, // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
3288 VM_findfloat, // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
3289 VM_checkextension, // #99 float(string s) checkextension (the basis of the extension system)
3290 // FrikaC and Telejano range #100-#199
3291 NULL, // #100
3292 NULL, // #101
3293 NULL, // #102
3294 NULL, // #103
3295 NULL, // #104
3296 NULL, // #105
3297 NULL, // #106
3298 NULL, // #107
3299 NULL, // #108
3300 NULL, // #109
3301 VM_fopen, // #110 float(string filename, float mode) fopen (FRIK_FILE)
3302 VM_fclose, // #111 void(float fhandle) fclose (FRIK_FILE)
3303 VM_fgets, // #112 string(float fhandle) fgets (FRIK_FILE)
3304 VM_fputs, // #113 void(float fhandle, string s) fputs (FRIK_FILE)
3305 VM_strlen, // #114 float(string s) strlen (FRIK_FILE)
3306 VM_strcat, // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
3307 VM_substring, // #116 string(string s, float start, float length) substring (FRIK_FILE)
3308 VM_stov, // #117 vector(string) stov (FRIK_FILE)
3309 VM_strzone, // #118 string(string s) strzone (FRIK_FILE)
3310 VM_strunzone, // #119 void(string s) strunzone (FRIK_FILE)
3311 NULL, // #120
3312 NULL, // #121
3313 NULL, // #122
3314 NULL, // #123
3315 NULL, // #124
3316 NULL, // #125
3317 NULL, // #126
3318 NULL, // #127
3319 NULL, // #128
3320 NULL, // #129
3321 NULL, // #130
3322 NULL, // #131
3323 NULL, // #132
3324 NULL, // #133
3325 NULL, // #134
3326 NULL, // #135
3327 NULL, // #136
3328 NULL, // #137
3329 NULL, // #138
3330 NULL, // #139
3331 NULL, // #140
3332 NULL, // #141
3333 NULL, // #142
3334 NULL, // #143
3335 NULL, // #144
3336 NULL, // #145
3337 NULL, // #146
3338 NULL, // #147
3339 NULL, // #148
3340 NULL, // #149
3341 NULL, // #150
3342 NULL, // #151
3343 NULL, // #152
3344 NULL, // #153
3345 NULL, // #154
3346 NULL, // #155
3347 NULL, // #156
3348 NULL, // #157
3349 NULL, // #158
3350 NULL, // #159
3351 NULL, // #160
3352 NULL, // #161
3353 NULL, // #162
3354 NULL, // #163
3355 NULL, // #164
3356 NULL, // #165
3357 NULL, // #166
3358 NULL, // #167
3359 NULL, // #168
3360 NULL, // #169
3361 NULL, // #170
3362 NULL, // #171
3363 NULL, // #172
3364 NULL, // #173
3365 NULL, // #174
3366 NULL, // #175
3367 NULL, // #176
3368 NULL, // #177
3369 NULL, // #178
3370 NULL, // #179
3371 NULL, // #180
3372 NULL, // #181
3373 NULL, // #182
3374 NULL, // #183
3375 NULL, // #184
3376 NULL, // #185
3377 NULL, // #186
3378 NULL, // #187
3379 NULL, // #188
3380 NULL, // #189
3381 NULL, // #190
3382 NULL, // #191
3383 NULL, // #192
3384 NULL, // #193
3385 NULL, // #194
3386 NULL, // #195
3387 NULL, // #196
3388 NULL, // #197
3389 NULL, // #198
3390 NULL, // #199
3391 // FTEQW range #200-#299
3392 NULL, // #200
3393 NULL, // #201
3394 NULL, // #202
3395 NULL, // #203
3396 NULL, // #204
3397 NULL, // #205
3398 NULL, // #206
3399 NULL, // #207
3400 NULL, // #208
3401 NULL, // #209
3402 NULL, // #210
3403 NULL, // #211
3404 NULL, // #212
3405 NULL, // #213
3406 NULL, // #214
3407 NULL, // #215
3408 NULL, // #216
3409 NULL, // #217
3410 VM_bitshift, // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
3411 NULL, // #219
3412 NULL, // #220
3413 VM_strstrofs, // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
3414 VM_str2chr, // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
3415 VM_chr2str, // #223 string(float c, ...) chr2str (FTE_STRINGS)
3416 VM_strconv, // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
3417 VM_strpad, // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
3418 VM_infoadd, // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
3419 VM_infoget, // #227 string(string info, string key) infoget (FTE_STRINGS)
3420 VM_strncmp, // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
3421 VM_strncasecmp, // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
3422 VM_strncasecmp, // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
3423 NULL, // #231
3424 VM_SV_AddStat, // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
3425 NULL, // #233
3426 NULL, // #234
3427 NULL, // #235
3428 NULL, // #236
3429 NULL, // #237
3430 NULL, // #238
3431 NULL, // #239
3432 VM_SV_checkpvs, // #240 float(vector viewpos, entity viewee) checkpvs;
3433 NULL, // #241
3434 NULL, // #242
3435 NULL, // #243
3436 NULL, // #244
3437 NULL, // #245
3438 NULL, // #246
3439 NULL, // #247
3440 NULL, // #248
3441 NULL, // #249
3442 NULL, // #250
3443 NULL, // #251
3444 NULL, // #252
3445 NULL, // #253
3446 NULL, // #254
3447 NULL, // #255
3448 NULL, // #256
3449 NULL, // #257
3450 NULL, // #258
3451 NULL, // #259
3452 NULL, // #260
3453 NULL, // #261
3454 NULL, // #262
3455 VM_SV_skel_create, // #263 float(float modlindex) skel_create = #263; // (DP_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
3456 VM_SV_skel_build, // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (DP_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
3457 VM_SV_skel_get_numbones, // #265 float(float skel) skel_get_numbones = #265; // (DP_SKELETONOBJECTS) returns how many bones exist in the created skeleton
3458 VM_SV_skel_get_bonename, // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (DP_SKELETONOBJECTS) returns name of bone (as a tempstring)
3459 VM_SV_skel_get_boneparent, // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (DP_SKELETONOBJECTS) returns parent num for supplied bonenum, -1 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
3460 VM_SV_skel_find_bone, // #268 float(float skel, string tagname) skel_find_bone = #268; // (DP_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
3461 VM_SV_skel_get_bonerel, // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (DP_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
3462 VM_SV_skel_get_boneabs, // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (DP_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
3463 VM_SV_skel_set_bone, // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (DP_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
3464 VM_SV_skel_mul_bone, // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (DP_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
3465 VM_SV_skel_mul_bones, // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (DP_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
3466 VM_SV_skel_copybones, // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (DP_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
3467 VM_SV_skel_delete, // #275 void(float skel) skel_delete = #275; // (DP_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
3468 VM_SV_frameforname, // #276 float(float modlindex, string framename) frameforname = #276; // (DP_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
3469 VM_SV_frameduration, // #277 float(float modlindex, float framenum) frameduration = #277; // (DP_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
3470 NULL, // #278
3471 NULL, // #279
3472 NULL, // #280
3473 NULL, // #281
3474 NULL, // #282
3475 NULL, // #283
3476 NULL, // #284
3477 NULL, // #285
3478 NULL, // #286
3479 NULL, // #287
3480 NULL, // #288
3481 NULL, // #289
3482 NULL, // #290
3483 NULL, // #291
3484 NULL, // #292
3485 NULL, // #293
3486 NULL, // #294
3487 NULL, // #295
3488 NULL, // #296
3489 NULL, // #297
3490 NULL, // #298
3491 NULL, // #299
3492 // CSQC range #300-#399
3493 NULL, // #300 void() clearscene (EXT_CSQC)
3494 NULL, // #301 void(float mask) addentities (EXT_CSQC)
3495 NULL, // #302 void(entity ent) addentity (EXT_CSQC)
3496 NULL, // #303 float(float property, ...) setproperty (EXT_CSQC)
3497 NULL, // #304 void() renderscene (EXT_CSQC)
3498 NULL, // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
3499 NULL, // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
3500 NULL, // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3501 NULL, // #308 void() R_EndPolygon
3502 NULL, // #309
3503 NULL, // #310 vector (vector v) cs_unproject (EXT_CSQC)
3504 NULL, // #311 vector (vector v) cs_project (EXT_CSQC)
3505 NULL, // #312
3506 NULL, // #313
3507 NULL, // #314
3508 NULL, // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
3509 NULL, // #316 float(string name) iscachedpic (EXT_CSQC)
3510 NULL, // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
3511 NULL, // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
3512 NULL, // #319 void(string name) freepic (EXT_CSQC)
3513 NULL, // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
3514 NULL, // #321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
3515 NULL, // #322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
3516 NULL, // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
3517 NULL, // #324 void(float x, float y, float width, float height) drawsetcliparea
3518 NULL, // #325 void(void) drawresetcliparea
3519 NULL, // #326
3520 NULL, // #327
3521 NULL, // #328
3522 NULL, // #329
3523 NULL, // #330 float(float stnum) getstatf (EXT_CSQC)
3524 NULL, // #331 float(float stnum) getstati (EXT_CSQC)
3525 NULL, // #332 string(float firststnum) getstats (EXT_CSQC)
3526 VM_SV_setmodelindex, // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
3527 VM_SV_modelnameforindex, // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
3528 VM_SV_particleeffectnum, // #335 float(string effectname) particleeffectnum (EXT_CSQC)
3529 VM_SV_trailparticles, // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
3530 VM_SV_pointparticles, // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
3531 NULL, // #338 void(string s, ...) centerprint (EXT_CSQC)
3532 VM_print, // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
3533 NULL, // #340 string(float keynum) keynumtostring (EXT_CSQC)
3534 NULL, // #341 float(string keyname) stringtokeynum (EXT_CSQC)
3535 NULL, // #342 string(float keynum) getkeybind (EXT_CSQC)
3536 NULL, // #343 void(float usecursor) setcursormode (EXT_CSQC)
3537 NULL, // #344 vector() getmousepos (EXT_CSQC)
3538 NULL, // #345 float(float framenum) getinputstate (EXT_CSQC)
3539 NULL, // #346 void(float sens) setsensitivityscaler (EXT_CSQC)
3540 NULL, // #347 void() runstandardplayerphysics (EXT_CSQC)
3541 NULL, // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
3542 NULL, // #349 float() isdemo (EXT_CSQC)
3543 VM_isserver, // #350 float() isserver (EXT_CSQC)
3544 NULL, // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
3545 NULL, // #352 void(string cmdname) registercommand (EXT_CSQC)
3546 VM_wasfreed, // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
3547 VM_SV_serverkey, // #354 string(string key) serverkey (EXT_CSQC)
3548 NULL, // #355
3549 NULL, // #356
3550 NULL, // #357
3551 NULL, // #358
3552 NULL, // #359
3553 NULL, // #360 float() readbyte (EXT_CSQC)
3554 NULL, // #361 float() readchar (EXT_CSQC)
3555 NULL, // #362 float() readshort (EXT_CSQC)
3556 NULL, // #363 float() readlong (EXT_CSQC)
3557 NULL, // #364 float() readcoord (EXT_CSQC)
3558 NULL, // #365 float() readangle (EXT_CSQC)
3559 NULL, // #366 string() readstring (EXT_CSQC)
3560 NULL, // #367 float() readfloat (EXT_CSQC)
3561 NULL, // #368
3562 NULL, // #369
3563 NULL, // #370
3564 NULL, // #371
3565 NULL, // #372
3566 NULL, // #373
3567 NULL, // #374
3568 NULL, // #375
3569 NULL, // #376
3570 NULL, // #377
3571 NULL, // #378
3572 NULL, // #379
3573 NULL, // #380
3574 NULL, // #381
3575 NULL, // #382
3576 NULL, // #383
3577 NULL, // #384
3578 NULL, // #385
3579 NULL, // #386
3580 NULL, // #387
3581 NULL, // #388
3582 NULL, // #389
3583 NULL, // #390
3584 NULL, // #391
3585 NULL, // #392
3586 NULL, // #393
3587 NULL, // #394
3588 NULL, // #395
3589 NULL, // #396
3590 NULL, // #397
3591 NULL, // #398
3592 NULL, // #399
3593 // LordHavoc's range #400-#499
3594 VM_SV_copyentity, // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
3595 VM_SV_setcolor, // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
3596 VM_findchain, // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
3597 VM_findchainfloat, // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
3598 VM_SV_effect, // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
3599 VM_SV_te_blood, // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
3600 VM_SV_te_bloodshower, // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
3601 VM_SV_te_explosionrgb, // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
3602 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)
3603 VM_SV_te_particlerain, // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
3604 VM_SV_te_particlesnow, // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
3605 VM_SV_te_spark, // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
3606 VM_SV_te_gunshotquad, // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
3607 VM_SV_te_spikequad, // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
3608 VM_SV_te_superspikequad, // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
3609 VM_SV_te_explosionquad, // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
3610 VM_SV_te_smallflash, // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
3611 VM_SV_te_customflash, // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
3612 VM_SV_te_gunshot, // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
3613 VM_SV_te_spike, // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
3614 VM_SV_te_superspike, // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
3615 VM_SV_te_explosion, // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
3616 VM_SV_te_tarexplosion, // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
3617 VM_SV_te_wizspike, // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
3618 VM_SV_te_knightspike, // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
3619 VM_SV_te_lavasplash, // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
3620 VM_SV_te_teleport, // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
3621 VM_SV_te_explosion2, // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
3622 VM_SV_te_lightning1, // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
3623 VM_SV_te_lightning2, // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
3624 VM_SV_te_lightning3, // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
3625 VM_SV_te_beam, // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
3626 VM_vectorvectors, // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
3627 VM_SV_te_plasmaburn, // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
3628 VM_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
3629 VM_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
3630 VM_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
3631 VM_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
3632 VM_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
3633 VM_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
3634 VM_SV_clientcommand, // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
3635 VM_tokenize, // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
3636 VM_argv, // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
3637 VM_SV_setattachment, // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
3638 VM_search_begin, // #444 float(string pattern, float caseinsensitive, float quiet) search_begin (DP_QC_FS_SEARCH)
3639 VM_search_end, // #445 void(float handle) search_end (DP_QC_FS_SEARCH)
3640 VM_search_getsize, // #446 float(float handle) search_getsize (DP_QC_FS_SEARCH)
3641 VM_search_getfilename, // #447 string(float handle, float num) search_getfilename (DP_QC_FS_SEARCH)
3642 VM_cvar_string, // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
3643 VM_findflags, // #449 entity(entity start, .float fld, float match) findflags (DP_QC_FINDFLAGS)
3644 VM_findchainflags, // #450 entity(.float fld, float match) findchainflags (DP_QC_FINDCHAINFLAGS)
3645 VM_SV_gettagindex, // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
3646 VM_SV_gettaginfo, // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
3647 VM_SV_dropclient, // #453 void(entity clent) dropclient (DP_SV_DROPCLIENT)
3648 VM_SV_spawnclient, // #454 entity() spawnclient (DP_SV_BOTCLIENT)
3649 VM_SV_clienttype, // #455 float(entity clent) clienttype (DP_SV_BOTCLIENT)
3650 VM_SV_WriteUnterminatedString, // #456 void(float to, string s) WriteUnterminatedString (DP_SV_WRITEUNTERMINATEDSTRING)
3651 VM_SV_te_flamejet, // #457 void(vector org, vector vel, float howmany) te_flamejet = #457 (DP_TE_FLAMEJET)
3652 NULL, // #458
3653 VM_ftoe, // #459 entity(float num) entitybyindex (DP_QC_EDICT_NUM)
3654 VM_buf_create, // #460 float() buf_create (DP_QC_STRINGBUFFERS)
3655 VM_buf_del, // #461 void(float bufhandle) buf_del (DP_QC_STRINGBUFFERS)
3656 VM_buf_getsize, // #462 float(float bufhandle) buf_getsize (DP_QC_STRINGBUFFERS)
3657 VM_buf_copy, // #463 void(float bufhandle_from, float bufhandle_to) buf_copy (DP_QC_STRINGBUFFERS)
3658 VM_buf_sort, // #464 void(float bufhandle, float sortpower, float backward) buf_sort (DP_QC_STRINGBUFFERS)
3659 VM_buf_implode, // #465 string(float bufhandle, string glue) buf_implode (DP_QC_STRINGBUFFERS)
3660 VM_bufstr_get, // #466 string(float bufhandle, float string_index) bufstr_get (DP_QC_STRINGBUFFERS)
3661 VM_bufstr_set, // #467 void(float bufhandle, float string_index, string str) bufstr_set (DP_QC_STRINGBUFFERS)
3662 VM_bufstr_add, // #468 float(float bufhandle, string str, float order) bufstr_add (DP_QC_STRINGBUFFERS)
3663 VM_bufstr_free, // #469 void(float bufhandle, float string_index) bufstr_free (DP_QC_STRINGBUFFERS)
3664 NULL, // #470
3665 VM_asin, // #471 float(float s) VM_asin (DP_QC_ASINACOSATANATAN2TAN)
3666 VM_acos, // #472 float(float c) VM_acos (DP_QC_ASINACOSATANATAN2TAN)
3667 VM_atan, // #473 float(float t) VM_atan (DP_QC_ASINACOSATANATAN2TAN)
3668 VM_atan2, // #474 float(float c, float s) VM_atan2 (DP_QC_ASINACOSATANATAN2TAN)
3669 VM_tan, // #475 float(float a) VM_tan (DP_QC_ASINACOSATANATAN2TAN)
3670 VM_strlennocol, // #476 float(string s) : DRESK - String Length (not counting color codes) (DP_QC_STRINGCOLORFUNCTIONS)
3671 VM_strdecolorize, // #477 string(string s) : DRESK - Decolorized String (DP_SV_STRINGCOLORFUNCTIONS)
3672 VM_strftime, // #478 string(float uselocaltime, string format, ...) (DP_QC_STRFTIME)
3673 VM_tokenizebyseparator, // #479 float(string s) tokenizebyseparator (DP_QC_TOKENIZEBYSEPARATOR)
3674 VM_strtolower, // #480 string(string s) VM_strtolower (DP_QC_STRING_CASE_FUNCTIONS)
3675 VM_strtoupper, // #481 string(string s) VM_strtoupper (DP_QC_STRING_CASE_FUNCTIONS)
3676 VM_cvar_defstring, // #482 string(string s) cvar_defstring (DP_QC_CVAR_DEFSTRING)
3677 VM_SV_pointsound, // #483 void(vector origin, string sample, float volume, float attenuation) (DP_SV_POINTSOUND)
3678 VM_strreplace, // #484 string(string search, string replace, string subject) strreplace (DP_QC_STRREPLACE)
3679 VM_strireplace, // #485 string(string search, string replace, string subject) strireplace (DP_QC_STRREPLACE)
3680 VM_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
3681 NULL, // #487
3682 NULL, // #488
3683 NULL, // #489
3684 NULL, // #490
3685 NULL, // #491
3686 NULL, // #492
3687 NULL, // #493
3688 VM_crc16, // #494 float(float caseinsensitive, string s, ...) crc16 = #494 (DP_QC_CRC16)
3689 VM_cvar_type, // #495 float(string name) cvar_type = #495; (DP_QC_CVAR_TYPE)
3690 VM_numentityfields, // #496 float() numentityfields = #496; (DP_QC_ENTITYDATA)
3691 VM_entityfieldname, // #497 string(float fieldnum) entityfieldname = #497; (DP_QC_ENTITYDATA)
3692 VM_entityfieldtype, // #498 float(float fieldnum) entityfieldtype = #498; (DP_QC_ENTITYDATA)
3693 VM_getentityfieldstring, // #499 string(float fieldnum, entity ent) getentityfieldstring = #499; (DP_QC_ENTITYDATA)
3694 VM_putentityfieldstring, // #500 float(float fieldnum, entity ent, string s) putentityfieldstring = #500; (DP_QC_ENTITYDATA)
3695 VM_SV_WritePicture, // #501
3696 NULL, // #502
3697 VM_whichpack, // #503 string(string) whichpack = #503;
3698 NULL, // #504
3699 NULL, // #505
3700 NULL, // #506
3701 NULL, // #507
3702 NULL, // #508
3703 NULL, // #509
3704 VM_uri_escape, // #510 string(string in) uri_escape = #510;
3705 VM_uri_unescape, // #511 string(string in) uri_unescape = #511;
3706 VM_etof, // #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT)
3707 VM_uri_get, // #513 float(string uri, float id, [string post_contenttype, string post_delim, [float buf]]) uri_get = #513; (DP_QC_URI_GET, DP_QC_URI_POST)
3708 VM_tokenize_console, // #514 float(string str) tokenize_console = #514; (DP_QC_TOKENIZE_CONSOLE)
3709 VM_argv_start_index, // #515 float(float idx) argv_start_index = #515; (DP_QC_TOKENIZE_CONSOLE)
3710 VM_argv_end_index, // #516 float(float idx) argv_end_index = #516; (DP_QC_TOKENIZE_CONSOLE)
3711 VM_buf_cvarlist, // #517 void(float buf, string prefix, string antiprefix) buf_cvarlist = #517; (DP_QC_STRINGBUFFERS_CVARLIST)
3712 VM_cvar_description, // #518 float(string name) cvar_description = #518; (DP_QC_CVAR_DESCRIPTION)
3713 VM_gettime, // #519 float(float timer) gettime = #519; (DP_QC_GETTIME)
3714 NULL, // #520
3715 NULL, // #521
3716 NULL, // #522
3717 NULL, // #523
3718 NULL, // #524
3719 NULL, // #525
3720 NULL, // #526
3721 NULL, // #527
3722 NULL, // #528
3723 VM_loadfromdata, // #529
3724 VM_loadfromfile, // #530
3725 VM_SV_setpause, // #531 void(float pause) setpause = #531;
3726 VM_log, // #532
3727 VM_getsoundtime, // #533 float(entity e, float channel) getsoundtime = #533; (DP_SND_GETSOUNDTIME)
3728 VM_soundlength, // #534 float(string sample) soundlength = #534; (DP_SND_GETSOUNDTIME)
3729 VM_buf_loadfile, // #535 float(string filename, float bufhandle) buf_loadfile (DP_QC_STRINGBUFFERS_EXT_WIP)
3730 VM_buf_writefile, // #536 float(float filehandle, float bufhandle, float startpos, float numstrings) buf_writefile (DP_QC_STRINGBUFFERS_EXT_WIP)
3731 VM_bufstr_find, // #537 float(float bufhandle, string match, float matchrule, float startpos) bufstr_find (DP_QC_STRINGBUFFERS_EXT_WIP)
3732 VM_matchpattern, // #538 float(string s, string pattern, float matchrule) matchpattern (DP_QC_STRINGBUFFERS_EXT_WIP)
3733 NULL, // #539
3734 VM_physics_enable, // #540 void(entity e, float physics_enabled) physics_enable = #540; (DP_PHYSICS_ODE)
3735 VM_physics_addforce, // #541 void(entity e, vector force, vector relative_ofs) physics_addforce = #541; (DP_PHYSICS_ODE)
3736 VM_physics_addtorque, // #542 void(entity e, vector torque) physics_addtorque = #542; (DP_PHYSICS_ODE)
3737 NULL, // #543
3738 NULL, // #544
3739 NULL, // #545
3740 NULL, // #546
3741 NULL, // #547
3742 NULL, // #548
3743 NULL, // #549
3744 NULL, // #550
3745 NULL, // #551
3746 NULL, // #552
3747 NULL, // #553
3748 NULL, // #554
3749 NULL, // #555
3750 NULL, // #556
3751 NULL, // #557
3752 NULL, // #558
3753 NULL, // #559
3754 NULL, // #560
3755 NULL, // #561
3756 NULL, // #562
3757 NULL, // #563
3758 NULL, // #564
3759 NULL, // #565
3760 NULL, // #566
3761 NULL, // #567
3762 NULL, // #568
3763 NULL, // #569
3764 NULL, // #570
3765 NULL, // #571
3766 NULL, // #572
3767 NULL, // #573
3768 NULL, // #574
3769 NULL, // #575
3770 NULL, // #576
3771 NULL, // #577
3772 NULL, // #578
3773 NULL, // #579
3774 NULL, // #580
3775 NULL, // #581
3776 NULL, // #582
3777 NULL, // #583
3778 NULL, // #584
3779 NULL, // #585
3780 NULL, // #586
3781 NULL, // #587
3782 NULL, // #588
3783 NULL, // #589
3784 NULL, // #590
3785 NULL, // #591
3786 NULL, // #592
3787 NULL, // #593
3788 NULL, // #594
3789 NULL, // #595
3790 NULL, // #596
3791 NULL, // #597
3792 NULL, // #598
3793 NULL, // #599
3794 NULL, // #600
3795 NULL, // #601
3796 NULL, // #602
3797 NULL, // #603
3798 NULL, // #604
3799 VM_callfunction, // #605
3800 VM_writetofile, // #606
3801 VM_isfunction, // #607
3802 NULL, // #608
3803 NULL, // #609
3804 NULL, // #610
3805 NULL, // #611
3806 NULL, // #612
3807 VM_parseentitydata, // #613
3808 NULL, // #614
3809 NULL, // #615
3810 NULL, // #616
3811 NULL, // #617
3812 NULL, // #618
3813 NULL, // #619
3814 NULL, // #620
3815 NULL, // #621
3816 NULL, // #622
3817 NULL, // #623
3818 VM_SV_getextresponse, // #624 string getextresponse(void)
3819 NULL, // #625
3820 NULL, // #626
3821 VM_sprintf, // #627 string sprintf(string format, ...)
3822 VM_getsurfacenumtriangles, // #628 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACETRIANGLE)
3823 VM_getsurfacetriangle, // #629 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACETRIANGLE)
3824 NULL, // #630
3825 NULL, // #631
3826 NULL, // #632
3827 NULL, // #633
3828 NULL, // #634
3829 NULL, // #635
3830 NULL, // #636
3831 NULL, // #637
3832 NULL, // #638
3833 VM_digest_hex, // #639
3834 NULL, // #640
3835 NULL, // #641
3836 VM_coverage, // #642
3837 NULL, // #643
3838 };
3839
3840 const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t);
3841
3842 void SVVM_init_cmd(prvm_prog_t *prog)
3843 {
3844 VM_Cmd_Init(prog);
3845 }
3846
3847 void SVVM_reset_cmd(prvm_prog_t *prog)
3848 {
3849 World_End(&sv.world);
3850
3851 if(prog->loaded && PRVM_serverfunction(SV_Shutdown))
3852 {
3853 func_t s = PRVM_serverfunction(SV_Shutdown);
3854 PRVM_serverglobalfloat(time) = sv.time;
3855 PRVM_serverfunction(SV_Shutdown) = 0; // prevent it from getting called again
3856 prog->ExecuteProgram(prog, s,"SV_Shutdown() required");
3857 }
3858
3859 VM_Cmd_Reset(prog);
3860 }