3 //============================================================================
8 char *vm_sv_extensions =
13 "DP_CON_ALIASPARAMETERS "
31 "DP_ENT_CUSTOMCOLORMAP "
32 "DP_ENT_EXTERIORMODELTOCLIENT "
34 "DP_ENT_LOWPRECISION "
37 "DP_GFX_EXTERNALTEXTURES "
38 "DP_GFX_EXTERNALTEXTURES_PERMAP "
40 "DP_GFX_QUAKE3MODELTAGS "
44 "DP_HALFLIFE_MAP_CVAR "
50 "DP_MOVETYPEBOUNCEMISSILE "
52 "DP_QC_ASINACOSATANATAN2TAN "
55 "DP_QC_CVAR_DEFSTRING "
59 "DP_QC_FINDCHAINFLAGS "
60 "DP_QC_FINDCHAINFLOAT "
68 "DP_QC_MULTIPLETEMPSTRINGS "
70 "DP_QC_SINCOSSQRTPOW "
72 "DP_QC_STRING_CASE_FUNCTIONS "
73 "DP_QC_STRINGBUFFERS "
74 "DP_QC_STRINGCOLORFUNCTIONS "
75 "DP_QC_TOKENIZEBYSEPARATOR "
78 "DP_QC_TRACE_MOVETYPE_HITMODEL "
79 "DP_QC_TRACE_MOVETYPE_WORLDONLY "
80 "DP_QC_UNLIMITEDTEMPSTRINGS "
81 "DP_QC_VECTORVECTORS "
87 "DP_SND_DIRECTIONLESSATTNNONE "
96 "DP_SV_CUSTOMIZEENTITYFORCLIENT "
97 "DP_SV_DRAWONLYTOCLIENT "
100 "DP_SV_ENTITYCONTENTSTRANSITION "
101 "DP_SV_ONENTITYNOSPAWNFUNCTION "
102 "DP_SV_MODELFLAGS_AS_EFFECTS "
104 "DP_SV_NODRAWTOCLIENT "
106 "DP_SV_PLAYERPHYSICS "
107 "DP_SV_POINTPARTICLES "
109 "DP_SV_PRECACHEANYTIME "
112 "DP_SV_ROTATINGBMODEL "
115 "DP_SV_WRITEUNTERMINATEDSTRING "
119 "DP_TE_EXPLOSIONRGB "
121 "DP_TE_PARTICLECUBE "
122 "DP_TE_PARTICLERAIN "
123 "DP_TE_PARTICLESNOW "
125 "DP_TE_QUADEFFECTS1 "
128 "DP_TE_STANDARDEFFECTBUILTINS "
129 "DP_TRACE_HITCONTENTSMASK_SURFACEINFO "
132 //"EXT_CSQC " // not ready yet
134 "KRIMZON_SV_PARSECLIENTCOMMAND "
137 "NEXUIZ_PLAYERMODEL "
139 "PRYDON_CLIENTCURSOR "
140 "TENEBRAE_GFX_DLIGHTS "
152 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.
154 setorigin (entity, origin)
157 static void VM_SV_setorigin (void)
162 VM_SAFEPARMCOUNT(2, VM_setorigin);
164 e = PRVM_G_EDICT(OFS_PARM0);
165 if (e == prog->edicts)
167 VM_Warning("setorigin: can not modify world entity\n");
170 if (e->priv.server->free)
172 VM_Warning("setorigin: can not modify free entity\n");
175 org = PRVM_G_VECTOR(OFS_PARM1);
176 VectorCopy (org, e->fields.server->origin);
177 SV_LinkEdict (e, false);
181 void SetMinMaxSize (prvm_edict_t *e, float *min, float *max, qboolean rotate)
185 for (i=0 ; i<3 ; i++)
187 PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
189 // set derived values
190 VectorCopy (min, e->fields.server->mins);
191 VectorCopy (max, e->fields.server->maxs);
192 VectorSubtract (max, min, e->fields.server->size);
194 SV_LinkEdict (e, false);
201 the size box is rotated by the current angle
202 LordHavoc: no it isn't...
204 setsize (entity, minvector, maxvector)
207 static void VM_SV_setsize (void)
212 VM_SAFEPARMCOUNT(3, VM_setsize);
214 e = PRVM_G_EDICT(OFS_PARM0);
215 if (e == prog->edicts)
217 VM_Warning("setsize: can not modify world entity\n");
220 if (e->priv.server->free)
222 VM_Warning("setsize: can not modify free entity\n");
225 min = PRVM_G_VECTOR(OFS_PARM1);
226 max = PRVM_G_VECTOR(OFS_PARM2);
227 SetMinMaxSize (e, min, max, false);
235 setmodel(entity, model)
238 static vec3_t quakemins = {-16, -16, -16}, quakemaxs = {16, 16, 16};
239 static void VM_SV_setmodel (void)
245 VM_SAFEPARMCOUNT(2, VM_setmodel);
247 e = PRVM_G_EDICT(OFS_PARM0);
248 if (e == prog->edicts)
250 VM_Warning("setmodel: can not modify world entity\n");
253 if (e->priv.server->free)
255 VM_Warning("setmodel: can not modify free entity\n");
258 i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);
259 e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
260 e->fields.server->modelindex = i;
266 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
267 SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
269 SetMinMaxSize (e, quakemins, quakemaxs, true);
272 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
279 single print to a specific client
281 sprint(clientent, value)
284 static void VM_SV_sprint (void)
288 char string[VM_STRINGTEMP_LENGTH];
290 VM_VarString(1, string, sizeof(string));
292 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_sprint);
294 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
295 // LordHavoc: div0 requested that sprintto world operate like print
302 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
304 VM_Warning("tried to centerprint to a non-client\n");
308 client = svs.clients + entnum-1;
309 if (!client->netconnection)
312 MSG_WriteChar(&client->netconnection->message,svc_print);
313 MSG_WriteString(&client->netconnection->message, string);
321 single print to a specific client
323 centerprint(clientent, value)
326 static void VM_SV_centerprint (void)
330 char string[VM_STRINGTEMP_LENGTH];
332 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_centerprint);
334 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
336 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
338 VM_Warning("tried to centerprint to a non-client\n");
342 client = svs.clients + entnum-1;
343 if (!client->netconnection)
346 VM_VarString(1, string, sizeof(string));
347 MSG_WriteChar(&client->netconnection->message,svc_centerprint);
348 MSG_WriteString(&client->netconnection->message, string);
355 particle(origin, color, count)
358 static void VM_SV_particle (void)
364 VM_SAFEPARMCOUNT(4, VM_SV_particle);
366 org = PRVM_G_VECTOR(OFS_PARM0);
367 dir = PRVM_G_VECTOR(OFS_PARM1);
368 color = PRVM_G_FLOAT(OFS_PARM2);
369 count = PRVM_G_FLOAT(OFS_PARM3);
370 SV_StartParticle (org, dir, (int)color, (int)count);
380 static void VM_SV_ambientsound (void)
384 float vol, attenuation;
387 VM_SAFEPARMCOUNT(4, VM_SV_ambientsound);
389 pos = PRVM_G_VECTOR (OFS_PARM0);
390 samp = PRVM_G_STRING(OFS_PARM1);
391 vol = PRVM_G_FLOAT(OFS_PARM2);
392 attenuation = PRVM_G_FLOAT(OFS_PARM3);
394 // check to see if samp was properly precached
395 soundnum = SV_SoundIndex(samp, 1);
403 // add an svc_spawnambient command to the level signon packet
406 MSG_WriteByte (&sv.signon, svc_spawnstaticsound2);
408 MSG_WriteByte (&sv.signon, svc_spawnstaticsound);
410 MSG_WriteVector(&sv.signon, pos, sv.protocol);
412 if (large || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
413 MSG_WriteShort (&sv.signon, soundnum);
415 MSG_WriteByte (&sv.signon, soundnum);
417 MSG_WriteByte (&sv.signon, (int)(vol*255));
418 MSG_WriteByte (&sv.signon, (int)(attenuation*64));
426 Each entity can have eight independant sound sources, like voice,
429 Channel 0 is an auto-allocate channel, the others override anything
430 already running on that entity/channel pair.
432 An attenuation of 0 will play full volume everywhere in the level.
433 Larger attenuations will drop off.
437 static void VM_SV_sound (void)
441 prvm_edict_t *entity;
445 VM_SAFEPARMCOUNTRANGE(4, 5, VM_SV_sound);
447 entity = PRVM_G_EDICT(OFS_PARM0);
448 channel = (int)PRVM_G_FLOAT(OFS_PARM1);
449 sample = PRVM_G_STRING(OFS_PARM2);
450 volume = (int)(PRVM_G_FLOAT(OFS_PARM3) * 255);
451 attenuation = PRVM_G_FLOAT(OFS_PARM4);
454 Con_DPrintf("VM_SV_sound: given only 4 parameters, expected 5, assuming attenuation = ATTN_NORMAL\n");
458 if (volume < 0 || volume > 255)
460 VM_Warning("SV_StartSound: volume must be in range 0-1\n");
464 if (attenuation < 0 || attenuation > 4)
466 VM_Warning("SV_StartSound: attenuation must be in range 0-4\n");
470 if (channel < 0 || channel > 7)
472 VM_Warning("SV_StartSound: channel must be in range 0-7\n");
476 SV_StartSound (entity, channel, sample, volume, attenuation);
483 Follows the same logic as VM_SV_sound, except instead of
484 an entity, an origin for the sound is provided, and channel
485 is omitted (since no entity is being tracked).
489 static void VM_SV_pointsound(void)
496 VM_SAFEPARMCOUNT(4, VM_SV_pointsound);
498 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
499 sample = PRVM_G_STRING(OFS_PARM1);
500 volume = (int)(PRVM_G_FLOAT(OFS_PARM2) * 255);
501 attenuation = PRVM_G_FLOAT(OFS_PARM3);
503 if (volume < 0 || volume > 255)
505 VM_Warning("SV_StartPointSound: volume must be in range 0-1\n");
509 if (attenuation < 0 || attenuation > 4)
511 VM_Warning("SV_StartPointSound: attenuation must be in range 0-4\n");
515 SV_StartPointSound (org, sample, volume, attenuation);
522 Used for use tracing and shot targeting
523 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
524 if the tryents flag is set.
526 traceline (vector1, vector2, movetype, ignore)
529 static void VM_SV_traceline (void)
536 VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_traceline); // allow more parameters for future expansion
538 prog->xfunction->builtinsprofile += 30;
540 v1 = PRVM_G_VECTOR(OFS_PARM0);
541 v2 = PRVM_G_VECTOR(OFS_PARM1);
542 move = (int)PRVM_G_FLOAT(OFS_PARM2);
543 ent = PRVM_G_EDICT(OFS_PARM3);
545 if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v1[2]) || IS_NAN(v2[2]))
546 PRVM_ERROR("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
548 trace = SV_Move (v1, vec3_origin, vec3_origin, v2, move, ent, SV_GenericHitSuperContentsMask(ent));
550 VM_SetTraceGlobals(&trace);
558 Used for use tracing and shot targeting
559 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
560 if the tryents flag is set.
562 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
565 // LordHavoc: added this for my own use, VERY useful, similar to traceline
566 static void VM_SV_tracebox (void)
568 float *v1, *v2, *m1, *m2;
573 VM_SAFEPARMCOUNTRANGE(6, 8, VM_SV_tracebox); // allow more parameters for future expansion
575 prog->xfunction->builtinsprofile += 30;
577 v1 = PRVM_G_VECTOR(OFS_PARM0);
578 m1 = PRVM_G_VECTOR(OFS_PARM1);
579 m2 = PRVM_G_VECTOR(OFS_PARM2);
580 v2 = PRVM_G_VECTOR(OFS_PARM3);
581 move = (int)PRVM_G_FLOAT(OFS_PARM4);
582 ent = PRVM_G_EDICT(OFS_PARM5);
584 if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v1[2]) || IS_NAN(v2[2]))
585 PRVM_ERROR("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], m1[0], m1[1], m1[2], m2[0], m2[1], m2[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
587 trace = SV_Move (v1, m1, m2, v2, move, ent, SV_GenericHitSuperContentsMask(ent));
589 VM_SetTraceGlobals(&trace);
592 static trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
597 vec3_t original_origin;
598 vec3_t original_velocity;
599 vec3_t original_angles;
600 vec3_t original_avelocity;
604 VectorCopy(tossent->fields.server->origin , original_origin );
605 VectorCopy(tossent->fields.server->velocity , original_velocity );
606 VectorCopy(tossent->fields.server->angles , original_angles );
607 VectorCopy(tossent->fields.server->avelocity, original_avelocity);
609 val = PRVM_EDICTFIELDVALUE(tossent, prog->fieldoffsets.gravity);
610 if (val != NULL && val->_float != 0)
611 gravity = val->_float;
614 gravity *= sv_gravity.value * 0.05;
616 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
618 SV_CheckVelocity (tossent);
619 tossent->fields.server->velocity[2] -= gravity;
620 VectorMA (tossent->fields.server->angles, 0.05, tossent->fields.server->avelocity, tossent->fields.server->angles);
621 VectorScale (tossent->fields.server->velocity, 0.05, move);
622 VectorAdd (tossent->fields.server->origin, move, end);
623 trace = SV_Move (tossent->fields.server->origin, tossent->fields.server->mins, tossent->fields.server->maxs, end, MOVE_NORMAL, tossent, SV_GenericHitSuperContentsMask(tossent));
624 VectorCopy (trace.endpos, tossent->fields.server->origin);
626 if (trace.fraction < 1)
630 VectorCopy(original_origin , tossent->fields.server->origin );
631 VectorCopy(original_velocity , tossent->fields.server->velocity );
632 VectorCopy(original_angles , tossent->fields.server->angles );
633 VectorCopy(original_avelocity, tossent->fields.server->avelocity);
638 static void VM_SV_tracetoss (void)
642 prvm_edict_t *ignore;
644 VM_SAFEPARMCOUNT(2, VM_SV_tracetoss);
646 prog->xfunction->builtinsprofile += 600;
648 ent = PRVM_G_EDICT(OFS_PARM0);
649 if (ent == prog->edicts)
651 VM_Warning("tracetoss: can not use world entity\n");
654 ignore = PRVM_G_EDICT(OFS_PARM1);
656 trace = SV_Trace_Toss (ent, ignore);
658 VM_SetTraceGlobals(&trace);
661 //============================================================================
663 static int checkpvsbytes;
664 static unsigned char checkpvs[MAX_MAP_LEAFS/8];
666 static int VM_SV_newcheckclient (int check)
672 // cycle to the next one
674 check = bound(1, check, svs.maxclients);
675 if (check == svs.maxclients)
683 prog->xfunction->builtinsprofile++;
685 if (i == svs.maxclients+1)
687 // look up the client's edict
688 ent = PRVM_EDICT_NUM(i);
689 // check if it is to be ignored, but never ignore the one we started on (prevent infinite loop)
690 if (i != check && (ent->priv.server->free || ent->fields.server->health <= 0 || ((int)ent->fields.server->flags & FL_NOTARGET)))
692 // found a valid client (possibly the same one again)
696 // get the PVS for the entity
697 VectorAdd(ent->fields.server->origin, ent->fields.server->view_ofs, org);
699 if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
700 checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs), false);
709 Returns a client (or object that has a client enemy) that would be a
712 If there is more than one valid option, they are cycled each frame
714 If (self.origin + self.viewofs) is not in the PVS of the current target,
715 it is not returned at all.
720 int c_invis, c_notvis;
721 static void VM_SV_checkclient (void)
723 prvm_edict_t *ent, *self;
726 VM_SAFEPARMCOUNT(0, VM_SV_checkclient);
728 // find a new check if on a new frame
729 if (sv.time - sv.lastchecktime >= 0.1)
731 sv.lastcheck = VM_SV_newcheckclient (sv.lastcheck);
732 sv.lastchecktime = sv.time;
735 // return check if it might be visible
736 ent = PRVM_EDICT_NUM(sv.lastcheck);
737 if (ent->priv.server->free || ent->fields.server->health <= 0)
739 VM_RETURN_EDICT(prog->edicts);
743 // if current entity can't possibly see the check entity, return 0
744 self = PRVM_PROG_TO_EDICT(prog->globals.server->self);
745 VectorAdd(self->fields.server->origin, self->fields.server->view_ofs, view);
746 if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
749 VM_RETURN_EDICT(prog->edicts);
753 // might be able to see it
755 VM_RETURN_EDICT(ent);
758 //============================================================================
765 Sends text over to the client's execution buffer
767 stuffcmd (clientent, value, ...)
770 static void VM_SV_stuffcmd (void)
774 char string[VM_STRINGTEMP_LENGTH];
776 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_stuffcmd);
778 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
779 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
781 VM_Warning("Can't stuffcmd to a non-client\n");
785 VM_VarString(1, string, sizeof(string));
788 host_client = svs.clients + entnum-1;
789 Host_ClientCommands ("%s", string);
797 Returns a chain of entities that have origins within a spherical area
799 findradius (origin, radius)
802 static void VM_SV_findradius (void)
804 prvm_edict_t *ent, *chain;
805 vec_t radius, radius2;
806 vec3_t org, eorg, mins, maxs;
809 prvm_edict_t *touchedicts[MAX_EDICTS];
811 VM_SAFEPARMCOUNT(2, VM_SV_findradius);
813 chain = (prvm_edict_t *)prog->edicts;
815 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
816 radius = PRVM_G_FLOAT(OFS_PARM1);
817 radius2 = radius * radius;
819 mins[0] = org[0] - (radius + 1);
820 mins[1] = org[1] - (radius + 1);
821 mins[2] = org[2] - (radius + 1);
822 maxs[0] = org[0] + (radius + 1);
823 maxs[1] = org[1] + (radius + 1);
824 maxs[2] = org[2] + (radius + 1);
825 numtouchedicts = World_EntitiesInBox(&sv.world, mins, maxs, MAX_EDICTS, touchedicts);
826 if (numtouchedicts > MAX_EDICTS)
828 // this never happens
829 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
830 numtouchedicts = MAX_EDICTS;
832 for (i = 0;i < numtouchedicts;i++)
834 ent = touchedicts[i];
835 prog->xfunction->builtinsprofile++;
836 // Quake did not return non-solid entities but darkplaces does
837 // (note: this is the reason you can't blow up fallen zombies)
838 if (ent->fields.server->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
840 // LordHavoc: compare against bounding box rather than center so it
841 // doesn't miss large objects, and use DotProduct instead of Length
842 // for a major speedup
843 VectorSubtract(org, ent->fields.server->origin, eorg);
844 if (sv_gameplayfix_findradiusdistancetobox.integer)
846 eorg[0] -= bound(ent->fields.server->mins[0], eorg[0], ent->fields.server->maxs[0]);
847 eorg[1] -= bound(ent->fields.server->mins[1], eorg[1], ent->fields.server->maxs[1]);
848 eorg[2] -= bound(ent->fields.server->mins[2], eorg[2], ent->fields.server->maxs[2]);
851 VectorMAMAM(1, eorg, -0.5f, ent->fields.server->mins, -0.5f, ent->fields.server->maxs, eorg);
852 if (DotProduct(eorg, eorg) < radius2)
854 ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
859 VM_RETURN_EDICT(chain);
862 static void VM_SV_precache_sound (void)
864 VM_SAFEPARMCOUNT(1, VM_SV_precache_sound);
865 SV_SoundIndex(PRVM_G_STRING(OFS_PARM0), 2);
866 PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
869 static void VM_SV_precache_model (void)
871 VM_SAFEPARMCOUNT(1, VM_SV_precache_model);
872 SV_ModelIndex(PRVM_G_STRING(OFS_PARM0), 2);
873 PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
880 float(float yaw, float dist[, settrace]) walkmove
883 static void VM_SV_walkmove (void)
892 VM_SAFEPARMCOUNTRANGE(2, 3, VM_SV_walkmove);
894 // assume failure if it returns early
895 PRVM_G_FLOAT(OFS_RETURN) = 0;
897 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
898 if (ent == prog->edicts)
900 VM_Warning("walkmove: can not modify world entity\n");
903 if (ent->priv.server->free)
905 VM_Warning("walkmove: can not modify free entity\n");
908 yaw = PRVM_G_FLOAT(OFS_PARM0);
909 dist = PRVM_G_FLOAT(OFS_PARM1);
910 settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
912 if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
915 yaw = yaw*M_PI*2 / 360;
917 move[0] = cos(yaw)*dist;
918 move[1] = sin(yaw)*dist;
921 // save program state, because SV_movestep may call other progs
922 oldf = prog->xfunction;
923 oldself = prog->globals.server->self;
925 PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true, false, settrace);
928 // restore program state
929 prog->xfunction = oldf;
930 prog->globals.server->self = oldself;
940 static void VM_SV_droptofloor (void)
946 VM_SAFEPARMCOUNTRANGE(0, 2, VM_SV_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
948 // assume failure if it returns early
949 PRVM_G_FLOAT(OFS_RETURN) = 0;
951 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
952 if (ent == prog->edicts)
954 VM_Warning("droptofloor: can not modify world entity\n");
957 if (ent->priv.server->free)
959 VM_Warning("droptofloor: can not modify free entity\n");
963 VectorCopy (ent->fields.server->origin, end);
966 trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
968 if (trace.fraction != 1 || (trace.startsolid && sv_gameplayfix_droptofloorstartsolid.integer))
970 if (trace.fraction < 1)
971 VectorCopy (trace.endpos, ent->fields.server->origin);
972 SV_LinkEdict (ent, false);
973 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
974 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
975 PRVM_G_FLOAT(OFS_RETURN) = 1;
976 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
977 ent->priv.server->suspendedinairflag = true;
985 void(float style, string value) lightstyle
988 static void VM_SV_lightstyle (void)
995 VM_SAFEPARMCOUNT(2, VM_SV_lightstyle);
997 style = (int)PRVM_G_FLOAT(OFS_PARM0);
998 val = PRVM_G_STRING(OFS_PARM1);
1000 if( (unsigned) style >= MAX_LIGHTSTYLES ) {
1001 PRVM_ERROR( "PF_lightstyle: style: %i >= 64", style );
1004 // change the string in sv
1005 strlcpy(sv.lightstyles[style], val, sizeof(sv.lightstyles[style]));
1007 // send message to all clients on this server
1008 if (sv.state != ss_active)
1011 for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1013 if (client->active && client->netconnection)
1015 MSG_WriteChar (&client->netconnection->message, svc_lightstyle);
1016 MSG_WriteChar (&client->netconnection->message,style);
1017 MSG_WriteString (&client->netconnection->message, val);
1027 static void VM_SV_checkbottom (void)
1029 VM_SAFEPARMCOUNT(1, VM_SV_checkbottom);
1030 PRVM_G_FLOAT(OFS_RETURN) = SV_CheckBottom (PRVM_G_EDICT(OFS_PARM0));
1038 static void VM_SV_pointcontents (void)
1040 VM_SAFEPARMCOUNT(1, VM_SV_pointcontents);
1041 PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
1048 Pick a vector for the player to shoot along
1049 vector aim(entity, missilespeed)
1052 static void VM_SV_aim (void)
1054 prvm_edict_t *ent, *check, *bestent;
1055 vec3_t start, dir, end, bestdir;
1058 float dist, bestdist;
1061 VM_SAFEPARMCOUNT(2, VM_SV_aim);
1063 // assume failure if it returns early
1064 VectorCopy(prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
1065 // if sv_aim is so high it can't possibly accept anything, skip out early
1066 if (sv_aim.value >= 1)
1069 ent = PRVM_G_EDICT(OFS_PARM0);
1070 if (ent == prog->edicts)
1072 VM_Warning("aim: can not use world entity\n");
1075 if (ent->priv.server->free)
1077 VM_Warning("aim: can not use free entity\n");
1080 speed = PRVM_G_FLOAT(OFS_PARM1);
1082 VectorCopy (ent->fields.server->origin, start);
1085 // try sending a trace straight
1086 VectorCopy (prog->globals.server->v_forward, dir);
1087 VectorMA (start, 2048, dir, end);
1088 tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
1089 if (tr.ent && ((prvm_edict_t *)tr.ent)->fields.server->takedamage == DAMAGE_AIM
1090 && (!teamplay.integer || ent->fields.server->team <=0 || ent->fields.server->team != ((prvm_edict_t *)tr.ent)->fields.server->team) )
1092 VectorCopy (prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
1097 // try all possible entities
1098 VectorCopy (dir, bestdir);
1099 bestdist = sv_aim.value;
1102 check = PRVM_NEXT_EDICT(prog->edicts);
1103 for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
1105 prog->xfunction->builtinsprofile++;
1106 if (check->fields.server->takedamage != DAMAGE_AIM)
1110 if (teamplay.integer && ent->fields.server->team > 0 && ent->fields.server->team == check->fields.server->team)
1111 continue; // don't aim at teammate
1112 for (j=0 ; j<3 ; j++)
1113 end[j] = check->fields.server->origin[j]
1114 + 0.5*(check->fields.server->mins[j] + check->fields.server->maxs[j]);
1115 VectorSubtract (end, start, dir);
1116 VectorNormalize (dir);
1117 dist = DotProduct (dir, prog->globals.server->v_forward);
1118 if (dist < bestdist)
1119 continue; // to far to turn
1120 tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
1121 if (tr.ent == check)
1122 { // can shoot at this one
1130 VectorSubtract (bestent->fields.server->origin, ent->fields.server->origin, dir);
1131 dist = DotProduct (dir, prog->globals.server->v_forward);
1132 VectorScale (prog->globals.server->v_forward, dist, end);
1134 VectorNormalize (end);
1135 VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));
1139 VectorCopy (bestdir, PRVM_G_VECTOR(OFS_RETURN));
1144 ===============================================================================
1148 ===============================================================================
1151 #define MSG_BROADCAST 0 // unreliable to all
1152 #define MSG_ONE 1 // reliable to one (msg_entity)
1153 #define MSG_ALL 2 // reliable to all
1154 #define MSG_INIT 3 // write to the init string
1155 #define MSG_ENTITY 5
1157 sizebuf_t *WriteDest (void)
1163 dest = (int)PRVM_G_FLOAT(OFS_PARM0);
1167 return &sv.datagram;
1170 ent = PRVM_PROG_TO_EDICT(prog->globals.server->msg_entity);
1171 entnum = PRVM_NUM_FOR_EDICT(ent);
1172 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active || !svs.clients[entnum-1].netconnection)
1174 VM_Warning ("WriteDest: tried to write to non-client\n");
1175 return &sv.reliable_datagram;
1178 return &svs.clients[entnum-1].netconnection->message;
1181 VM_Warning ("WriteDest: bad destination\n");
1183 return &sv.reliable_datagram;
1189 return sv.writeentitiestoclient_msg;
1195 static void VM_SV_WriteByte (void)
1197 VM_SAFEPARMCOUNT(2, VM_SV_WriteByte);
1198 MSG_WriteByte (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1201 static void VM_SV_WriteChar (void)
1203 VM_SAFEPARMCOUNT(2, VM_SV_WriteChar);
1204 MSG_WriteChar (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1207 static void VM_SV_WriteShort (void)
1209 VM_SAFEPARMCOUNT(2, VM_SV_WriteShort);
1210 MSG_WriteShort (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1213 static void VM_SV_WriteLong (void)
1215 VM_SAFEPARMCOUNT(2, VM_SV_WriteLong);
1216 MSG_WriteLong (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1219 static void VM_SV_WriteAngle (void)
1221 VM_SAFEPARMCOUNT(2, VM_SV_WriteAngle);
1222 MSG_WriteAngle (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1225 static void VM_SV_WriteCoord (void)
1227 VM_SAFEPARMCOUNT(2, VM_SV_WriteCoord);
1228 MSG_WriteCoord (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1231 static void VM_SV_WriteString (void)
1233 VM_SAFEPARMCOUNT(2, VM_SV_WriteString);
1234 MSG_WriteString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
1237 static void VM_SV_WriteUnterminatedString (void)
1239 VM_SAFEPARMCOUNT(2, VM_SV_WriteUnterminatedString);
1240 MSG_WriteUnterminatedString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
1244 static void VM_SV_WriteEntity (void)
1246 VM_SAFEPARMCOUNT(2, VM_SV_WriteEntity);
1247 MSG_WriteShort (WriteDest(), PRVM_G_EDICTNUM(OFS_PARM1));
1250 //////////////////////////////////////////////////////////
1252 static void VM_SV_makestatic (void)
1257 // allow 0 parameters due to an id1 qc bug in which this function is used
1258 // with no parameters (but directly after setmodel with self in OFS_PARM0)
1259 VM_SAFEPARMCOUNTRANGE(0, 1, VM_SV_makestatic);
1261 if (prog->argc >= 1)
1262 ent = PRVM_G_EDICT(OFS_PARM0);
1264 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
1265 if (ent == prog->edicts)
1267 VM_Warning("makestatic: can not modify world entity\n");
1270 if (ent->priv.server->free)
1272 VM_Warning("makestatic: can not modify free entity\n");
1277 if (ent->fields.server->modelindex >= 256 || ent->fields.server->frame >= 256)
1282 MSG_WriteByte (&sv.signon,svc_spawnstatic2);
1283 MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
1284 MSG_WriteShort (&sv.signon, (int)ent->fields.server->frame);
1286 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1288 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1289 MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
1290 MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
1294 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1295 MSG_WriteByte (&sv.signon, (int)ent->fields.server->modelindex);
1296 MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
1299 MSG_WriteByte (&sv.signon, (int)ent->fields.server->colormap);
1300 MSG_WriteByte (&sv.signon, (int)ent->fields.server->skin);
1301 for (i=0 ; i<3 ; i++)
1303 MSG_WriteCoord(&sv.signon, ent->fields.server->origin[i], sv.protocol);
1304 MSG_WriteAngle(&sv.signon, ent->fields.server->angles[i], sv.protocol);
1307 // throw the entity away now
1311 //=============================================================================
1318 static void VM_SV_setspawnparms (void)
1324 VM_SAFEPARMCOUNT(1, VM_SV_setspawnparms);
1326 ent = PRVM_G_EDICT(OFS_PARM0);
1327 i = PRVM_NUM_FOR_EDICT(ent);
1328 if (i < 1 || i > svs.maxclients || !svs.clients[i-1].active)
1330 Con_Print("tried to setspawnparms on a non-client\n");
1334 // copy spawn parms out of the client_t
1335 client = svs.clients + i-1;
1336 for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1337 (&prog->globals.server->parm1)[i] = client->spawn_parms[i];
1344 Returns a color vector indicating the lighting at the requested point.
1346 (Internal Operation note: actually measures the light beneath the point, just like
1347 the model lighting on the client)
1352 static void VM_SV_getlight (void)
1354 vec3_t ambientcolor, diffusecolor, diffusenormal;
1356 VM_SAFEPARMCOUNT(1, VM_SV_getlight);
1357 p = PRVM_G_VECTOR(OFS_PARM0);
1358 VectorClear(ambientcolor);
1359 VectorClear(diffusecolor);
1360 VectorClear(diffusenormal);
1361 if (sv.worldmodel && sv.worldmodel->brush.LightPoint)
1362 sv.worldmodel->brush.LightPoint(sv.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
1363 VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
1368 unsigned char type; // 1/2/8 or other value if isn't used
1372 static customstat_t *vm_customstats = NULL; //[515]: it starts from 0, not 32
1373 static int vm_customstats_last;
1375 void VM_CustomStats_Clear (void)
1379 Z_Free(vm_customstats);
1380 vm_customstats = NULL;
1381 vm_customstats_last = -1;
1385 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1393 for(i=0; i<vm_customstats_last+1 ;i++)
1395 if(!vm_customstats[i].type)
1397 switch(vm_customstats[i].type)
1399 //string as 16 bytes
1402 strlcpy(s, PRVM_E_STRING(ent, vm_customstats[i].fieldoffset), 16);
1403 stats[i+32] = s[ 0] + s[ 1] * 256 + s[ 2] * 65536 + s[ 3] * 16777216;
1404 stats[i+33] = s[ 4] + s[ 5] * 256 + s[ 6] * 65536 + s[ 7] * 16777216;
1405 stats[i+34] = s[ 8] + s[ 9] * 256 + s[10] * 65536 + s[11] * 16777216;
1406 stats[i+35] = s[12] + s[13] * 256 + s[14] * 65536 + s[15] * 16777216;
1408 //float field sent as-is
1410 stats[i+32] = PRVM_E_INT(ent, vm_customstats[i].fieldoffset);
1412 //integer value of float field
1414 stats[i+32] = (int)PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
1422 // void(float index, float type, .void field) SV_AddStat = #232;
1423 // Set up an auto-sent player stat.
1424 // Client's get thier own fields sent to them. Index may not be less than 32.
1425 // Type is a value equating to the ev_ values found in qcc to dictate types. Valid ones are:
1426 // 1: string (4 stats carrying a total of 16 charactures)
1427 // 2: float (one stat, float converted to an integer for transportation)
1428 // 8: integer (one stat, not converted to an int, so this can be used to transport floats as floats - what a unique idea!)
1429 static void VM_SV_AddStat (void)
1434 VM_SAFEPARMCOUNT(3, VM_SV_AddStat);
1438 vm_customstats = (customstat_t *)Z_Malloc((MAX_CL_STATS-32) * sizeof(customstat_t));
1441 VM_Warning("PF_SV_AddStat: not enough memory\n");
1445 i = (int)PRVM_G_FLOAT(OFS_PARM0);
1446 type = (int)PRVM_G_FLOAT(OFS_PARM1);
1447 off = PRVM_G_INT (OFS_PARM2);
1452 VM_Warning("PF_SV_AddStat: index may not be less than 32\n");
1455 if(i >= (MAX_CL_STATS-32))
1457 VM_Warning("PF_SV_AddStat: index >= MAX_CL_STATS\n");
1460 if(i > (MAX_CL_STATS-32-4) && type == 1)
1462 VM_Warning("PF_SV_AddStat: index > (MAX_CL_STATS-4) with string\n");
1465 vm_customstats[i].type = type;
1466 vm_customstats[i].fieldoffset = off;
1467 if(vm_customstats_last < i)
1468 vm_customstats_last = i;
1475 copies data from one entity to another
1477 copyentity(src, dst)
1480 static void VM_SV_copyentity (void)
1482 prvm_edict_t *in, *out;
1483 VM_SAFEPARMCOUNT(2, VM_SV_copyentity);
1484 in = PRVM_G_EDICT(OFS_PARM0);
1485 if (in == prog->edicts)
1487 VM_Warning("copyentity: can not read world entity\n");
1490 if (in->priv.server->free)
1492 VM_Warning("copyentity: can not read free entity\n");
1495 out = PRVM_G_EDICT(OFS_PARM1);
1496 if (out == prog->edicts)
1498 VM_Warning("copyentity: can not modify world entity\n");
1501 if (out->priv.server->free)
1503 VM_Warning("copyentity: can not modify free entity\n");
1506 memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
1507 SV_LinkEdict(out, false);
1515 sets the color of a client and broadcasts the update to all connected clients
1517 setcolor(clientent, value)
1520 static void VM_SV_setcolor (void)
1526 VM_SAFEPARMCOUNT(2, VM_SV_setcolor);
1527 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
1528 i = (int)PRVM_G_FLOAT(OFS_PARM1);
1530 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
1532 Con_Print("tried to setcolor a non-client\n");
1536 client = svs.clients + entnum-1;
1539 if ((val = PRVM_EDICTFIELDVALUE(client->edict, prog->fieldoffsets.clientcolors)))
1541 client->edict->fields.server->team = (i & 15) + 1;
1544 if (client->old_colors != client->colors)
1546 client->old_colors = client->colors;
1547 // send notification to all clients
1548 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1549 MSG_WriteByte (&sv.reliable_datagram, client - svs.clients);
1550 MSG_WriteByte (&sv.reliable_datagram, client->colors);
1558 effect(origin, modelname, startframe, framecount, framerate)
1561 static void VM_SV_effect (void)
1565 VM_SAFEPARMCOUNT(5, VM_SV_effect);
1566 s = PRVM_G_STRING(OFS_PARM1);
1569 VM_Warning("effect: no model specified\n");
1573 i = SV_ModelIndex(s, 1);
1576 VM_Warning("effect: model not precached\n");
1580 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1582 VM_Warning("effect: framecount < 1\n");
1586 if (PRVM_G_FLOAT(OFS_PARM4) < 1)
1588 VM_Warning("effect: framerate < 1\n");
1592 SV_StartEffect(PRVM_G_VECTOR(OFS_PARM0), i, (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4));
1595 static void VM_SV_te_blood (void)
1597 VM_SAFEPARMCOUNT(3, VM_SV_te_blood);
1598 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1600 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1601 MSG_WriteByte(&sv.datagram, TE_BLOOD);
1603 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1604 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1605 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1607 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1608 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1609 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1611 MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1612 SV_FlushBroadcastMessages();
1615 static void VM_SV_te_bloodshower (void)
1617 VM_SAFEPARMCOUNT(4, VM_SV_te_bloodshower);
1618 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1620 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1621 MSG_WriteByte(&sv.datagram, TE_BLOODSHOWER);
1623 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1624 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1625 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1627 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1628 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1629 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1631 MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM2), sv.protocol);
1633 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1634 SV_FlushBroadcastMessages();
1637 static void VM_SV_te_explosionrgb (void)
1639 VM_SAFEPARMCOUNT(2, VM_SV_te_explosionrgb);
1640 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1641 MSG_WriteByte(&sv.datagram, TE_EXPLOSIONRGB);
1643 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1644 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1645 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1647 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[0] * 255), 255));
1648 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[1] * 255), 255));
1649 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[2] * 255), 255));
1650 SV_FlushBroadcastMessages();
1653 static void VM_SV_te_particlecube (void)
1655 VM_SAFEPARMCOUNT(7, VM_SV_te_particlecube);
1656 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1658 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1659 MSG_WriteByte(&sv.datagram, TE_PARTICLECUBE);
1661 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1662 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1663 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1665 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1666 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1667 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1669 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1670 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1671 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1673 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1675 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1676 // gravity true/false
1677 MSG_WriteByte(&sv.datagram, ((int) PRVM_G_FLOAT(OFS_PARM5)) != 0);
1679 MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM6), sv.protocol);
1680 SV_FlushBroadcastMessages();
1683 static void VM_SV_te_particlerain (void)
1685 VM_SAFEPARMCOUNT(5, VM_SV_te_particlerain);
1686 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1688 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1689 MSG_WriteByte(&sv.datagram, TE_PARTICLERAIN);
1691 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1692 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1693 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1695 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1696 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1697 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1699 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1700 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1701 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1703 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1705 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1706 SV_FlushBroadcastMessages();
1709 static void VM_SV_te_particlesnow (void)
1711 VM_SAFEPARMCOUNT(5, VM_SV_te_particlesnow);
1712 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1714 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1715 MSG_WriteByte(&sv.datagram, TE_PARTICLESNOW);
1717 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1718 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1719 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1721 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1722 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1723 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1725 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1726 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1727 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1729 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1731 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1732 SV_FlushBroadcastMessages();
1735 static void VM_SV_te_spark (void)
1737 VM_SAFEPARMCOUNT(3, VM_SV_te_spark);
1738 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1740 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1741 MSG_WriteByte(&sv.datagram, TE_SPARK);
1743 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1744 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1745 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1747 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1748 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1749 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1751 MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1752 SV_FlushBroadcastMessages();
1755 static void VM_SV_te_gunshotquad (void)
1757 VM_SAFEPARMCOUNT(1, VM_SV_te_gunshotquad);
1758 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1759 MSG_WriteByte(&sv.datagram, TE_GUNSHOTQUAD);
1761 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1762 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1763 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1764 SV_FlushBroadcastMessages();
1767 static void VM_SV_te_spikequad (void)
1769 VM_SAFEPARMCOUNT(1, VM_SV_te_spikequad);
1770 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1771 MSG_WriteByte(&sv.datagram, TE_SPIKEQUAD);
1773 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1774 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1775 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1776 SV_FlushBroadcastMessages();
1779 static void VM_SV_te_superspikequad (void)
1781 VM_SAFEPARMCOUNT(1, VM_SV_te_superspikequad);
1782 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1783 MSG_WriteByte(&sv.datagram, TE_SUPERSPIKEQUAD);
1785 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1786 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1787 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1788 SV_FlushBroadcastMessages();
1791 static void VM_SV_te_explosionquad (void)
1793 VM_SAFEPARMCOUNT(1, VM_SV_te_explosionquad);
1794 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1795 MSG_WriteByte(&sv.datagram, TE_EXPLOSIONQUAD);
1797 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1798 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1799 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1800 SV_FlushBroadcastMessages();
1803 static void VM_SV_te_smallflash (void)
1805 VM_SAFEPARMCOUNT(1, VM_SV_te_smallflash);
1806 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1807 MSG_WriteByte(&sv.datagram, TE_SMALLFLASH);
1809 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1810 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1811 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1812 SV_FlushBroadcastMessages();
1815 static void VM_SV_te_customflash (void)
1817 VM_SAFEPARMCOUNT(4, VM_SV_te_customflash);
1818 if (PRVM_G_FLOAT(OFS_PARM1) < 8 || PRVM_G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
1820 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1821 MSG_WriteByte(&sv.datagram, TE_CUSTOMFLASH);
1823 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1824 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1825 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1827 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM1) / 8 - 1, 255));
1829 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM2) * 256 - 1, 255));
1831 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[0] * 255, 255));
1832 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[1] * 255, 255));
1833 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[2] * 255, 255));
1834 SV_FlushBroadcastMessages();
1837 static void VM_SV_te_gunshot (void)
1839 VM_SAFEPARMCOUNT(1, VM_SV_te_gunshot);
1840 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1841 MSG_WriteByte(&sv.datagram, TE_GUNSHOT);
1843 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1844 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1845 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1846 SV_FlushBroadcastMessages();
1849 static void VM_SV_te_spike (void)
1851 VM_SAFEPARMCOUNT(1, VM_SV_te_spike);
1852 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1853 MSG_WriteByte(&sv.datagram, TE_SPIKE);
1855 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1856 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1857 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1858 SV_FlushBroadcastMessages();
1861 static void VM_SV_te_superspike (void)
1863 VM_SAFEPARMCOUNT(1, VM_SV_te_superspike);
1864 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1865 MSG_WriteByte(&sv.datagram, TE_SUPERSPIKE);
1867 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1868 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1869 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1870 SV_FlushBroadcastMessages();
1873 static void VM_SV_te_explosion (void)
1875 VM_SAFEPARMCOUNT(1, VM_SV_te_explosion);
1876 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1877 MSG_WriteByte(&sv.datagram, TE_EXPLOSION);
1879 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1880 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1881 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1882 SV_FlushBroadcastMessages();
1885 static void VM_SV_te_tarexplosion (void)
1887 VM_SAFEPARMCOUNT(1, VM_SV_te_tarexplosion);
1888 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1889 MSG_WriteByte(&sv.datagram, TE_TAREXPLOSION);
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 SV_FlushBroadcastMessages();
1897 static void VM_SV_te_wizspike (void)
1899 VM_SAFEPARMCOUNT(1, VM_SV_te_wizspike);
1900 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1901 MSG_WriteByte(&sv.datagram, TE_WIZSPIKE);
1903 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1904 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1905 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1906 SV_FlushBroadcastMessages();
1909 static void VM_SV_te_knightspike (void)
1911 VM_SAFEPARMCOUNT(1, VM_SV_te_knightspike);
1912 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1913 MSG_WriteByte(&sv.datagram, TE_KNIGHTSPIKE);
1915 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1916 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1917 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1918 SV_FlushBroadcastMessages();
1921 static void VM_SV_te_lavasplash (void)
1923 VM_SAFEPARMCOUNT(1, VM_SV_te_lavasplash);
1924 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1925 MSG_WriteByte(&sv.datagram, TE_LAVASPLASH);
1927 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1928 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1929 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1930 SV_FlushBroadcastMessages();
1933 static void VM_SV_te_teleport (void)
1935 VM_SAFEPARMCOUNT(1, VM_SV_te_teleport);
1936 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1937 MSG_WriteByte(&sv.datagram, TE_TELEPORT);
1939 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1940 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1941 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1942 SV_FlushBroadcastMessages();
1945 static void VM_SV_te_explosion2 (void)
1947 VM_SAFEPARMCOUNT(3, VM_SV_te_explosion2);
1948 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1949 MSG_WriteByte(&sv.datagram, TE_EXPLOSION2);
1951 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1952 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1953 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1955 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
1956 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
1957 SV_FlushBroadcastMessages();
1960 static void VM_SV_te_lightning1 (void)
1962 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning1);
1963 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1964 MSG_WriteByte(&sv.datagram, TE_LIGHTNING1);
1966 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
1968 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1969 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1970 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1972 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1973 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1974 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1975 SV_FlushBroadcastMessages();
1978 static void VM_SV_te_lightning2 (void)
1980 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning2);
1981 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1982 MSG_WriteByte(&sv.datagram, TE_LIGHTNING2);
1984 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
1986 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1987 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1988 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1990 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1991 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1992 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1993 SV_FlushBroadcastMessages();
1996 static void VM_SV_te_lightning3 (void)
1998 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning3);
1999 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2000 MSG_WriteByte(&sv.datagram, TE_LIGHTNING3);
2002 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2004 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2005 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2006 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2008 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2009 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2010 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2011 SV_FlushBroadcastMessages();
2014 static void VM_SV_te_beam (void)
2016 VM_SAFEPARMCOUNT(3, VM_SV_te_beam);
2017 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2018 MSG_WriteByte(&sv.datagram, TE_BEAM);
2020 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2022 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2023 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2024 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2026 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2027 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2028 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2029 SV_FlushBroadcastMessages();
2032 static void VM_SV_te_plasmaburn (void)
2034 VM_SAFEPARMCOUNT(1, VM_SV_te_plasmaburn);
2035 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2036 MSG_WriteByte(&sv.datagram, TE_PLASMABURN);
2037 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2038 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2039 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2040 SV_FlushBroadcastMessages();
2043 static void VM_SV_te_flamejet (void)
2045 VM_SAFEPARMCOUNT(3, VM_SV_te_flamejet);
2046 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2047 MSG_WriteByte(&sv.datagram, TE_FLAMEJET);
2049 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2050 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2051 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2053 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2054 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2055 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2057 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
2058 SV_FlushBroadcastMessages();
2061 void clippointtosurface(model_t *model, msurface_t *surface, vec3_t p, vec3_t out)
2064 float *v[3], facenormal[3], edgenormal[3], sidenormal[3], temp[3], offsetdist, dist, bestdist;
2066 bestdist = 1000000000;
2068 for (i = 0, e = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);i < surface->num_triangles;i++, e += 3)
2070 // clip original point to each triangle of the surface and find the
2071 // triangle that is closest
2072 v[0] = model->surfmesh.data_vertex3f + e[0] * 3;
2073 v[1] = model->surfmesh.data_vertex3f + e[1] * 3;
2074 v[2] = model->surfmesh.data_vertex3f + e[2] * 3;
2075 TriangleNormal(v[0], v[1], v[2], facenormal);
2076 VectorNormalize(facenormal);
2077 offsetdist = DotProduct(v[0], facenormal) - DotProduct(p, facenormal);
2078 VectorMA(p, offsetdist, facenormal, temp);
2079 for (j = 0, k = 2;j < 3;k = j, j++)
2081 VectorSubtract(v[k], v[j], edgenormal);
2082 CrossProduct(edgenormal, facenormal, sidenormal);
2083 VectorNormalize(sidenormal);
2084 offsetdist = DotProduct(v[k], sidenormal) - DotProduct(temp, sidenormal);
2086 VectorMA(temp, offsetdist, sidenormal, temp);
2088 dist = VectorDistance2(temp, p);
2089 if (bestdist > dist)
2092 VectorCopy(temp, out);
2097 static model_t *getmodel(prvm_edict_t *ed)
2100 if (!ed || ed->priv.server->free)
2102 modelindex = (int)ed->fields.server->modelindex;
2103 if (modelindex < 1 || modelindex >= MAX_MODELS)
2105 return sv.models[modelindex];
2108 static msurface_t *getsurface(model_t *model, int surfacenum)
2110 if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
2112 return model->data_surfaces + surfacenum + model->firstmodelsurface;
2116 //PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434;
2117 static void VM_SV_getsurfacenumpoints(void)
2120 msurface_t *surface;
2121 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenumpoints);
2122 // return 0 if no such surface
2123 if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2125 PRVM_G_FLOAT(OFS_RETURN) = 0;
2129 // note: this (incorrectly) assumes it is a simple polygon
2130 PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
2132 //PF_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint = #435;
2133 static void VM_SV_getsurfacepoint(void)
2137 msurface_t *surface;
2139 VM_SAFEPARMCOUNT(3, VM_SV_getsurfacepoint);
2140 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2141 ed = PRVM_G_EDICT(OFS_PARM0);
2142 if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2144 // note: this (incorrectly) assumes it is a simple polygon
2145 pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
2146 if (pointnum < 0 || pointnum >= surface->num_vertices)
2148 // FIXME: implement rotation/scaling
2149 VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2151 //PF_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal = #436;
2152 static void VM_SV_getsurfacenormal(void)
2155 msurface_t *surface;
2157 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenormal);
2158 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2159 if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2161 // FIXME: implement rotation/scaling
2162 // note: this (incorrectly) assumes it is a simple polygon
2163 // note: this only returns the first triangle, so it doesn't work very
2164 // well for curved surfaces or arbitrary meshes
2165 TriangleNormal((model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 3, (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
2166 VectorNormalize(normal);
2167 VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
2169 //PF_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture = #437;
2170 static void VM_SV_getsurfacetexture(void)
2173 msurface_t *surface;
2174 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacetexture);
2175 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2176 if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2178 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
2180 //PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438;
2181 static void VM_SV_getsurfacenearpoint(void)
2183 int surfacenum, best;
2185 vec_t dist, bestdist;
2188 msurface_t *surface;
2190 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenearpoint);
2191 PRVM_G_FLOAT(OFS_RETURN) = -1;
2192 ed = PRVM_G_EDICT(OFS_PARM0);
2193 point = PRVM_G_VECTOR(OFS_PARM1);
2195 if (!ed || ed->priv.server->free)
2197 model = getmodel(ed);
2198 if (!model || !model->num_surfaces)
2201 // FIXME: implement rotation/scaling
2202 VectorSubtract(point, ed->fields.server->origin, p);
2204 bestdist = 1000000000;
2205 for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
2207 surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
2208 // first see if the nearest point on the surface's box is closer than the previous match
2209 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
2210 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
2211 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
2212 dist = VectorLength2(clipped);
2213 if (dist < bestdist)
2215 // it is, check the nearest point on the actual geometry
2216 clippointtosurface(model, surface, p, clipped);
2217 VectorSubtract(clipped, p, clipped);
2218 dist += VectorLength2(clipped);
2219 if (dist < bestdist)
2221 // that's closer too, store it as the best match
2227 PRVM_G_FLOAT(OFS_RETURN) = best;
2229 //PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439;
2230 static void VM_SV_getsurfaceclippedpoint(void)
2234 msurface_t *surface;
2236 VM_SAFEPARMCOUNT(3, VM_SV_te_getsurfaceclippedpoint);
2237 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2238 ed = PRVM_G_EDICT(OFS_PARM0);
2239 if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2241 // FIXME: implement rotation/scaling
2242 VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.server->origin, p);
2243 clippointtosurface(model, surface, p, out);
2244 // FIXME: implement rotation/scaling
2245 VectorAdd(out, ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2248 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2249 //this function originally written by KrimZon, made shorter by LordHavoc
2250 static void VM_SV_clientcommand (void)
2252 client_t *temp_client;
2254 VM_SAFEPARMCOUNT(2, VM_SV_clientcommand);
2256 //find client for this entity
2257 i = (PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0)) - 1);
2258 if (i < 0 || i >= svs.maxclients || !svs.clients[i].active)
2260 Con_Print("PF_clientcommand: entity is not a client\n");
2264 temp_client = host_client;
2265 host_client = svs.clients + i;
2266 Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client);
2267 host_client = temp_client;
2270 //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)
2271 static void VM_SV_setattachment (void)
2273 prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
2274 prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
2275 const char *tagname = PRVM_G_STRING(OFS_PARM2);
2279 VM_SAFEPARMCOUNT(3, VM_SV_setattachment);
2281 if (e == prog->edicts)
2283 VM_Warning("setattachment: can not modify world entity\n");
2286 if (e->priv.server->free)
2288 VM_Warning("setattachment: can not modify free entity\n");
2292 if (tagentity == NULL)
2293 tagentity = prog->edicts;
2295 v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_entity);
2297 v->edict = PRVM_EDICT_TO_PROG(tagentity);
2299 v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_index);
2302 if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2304 modelindex = (int)tagentity->fields.server->modelindex;
2305 if (modelindex >= 0 && modelindex < MAX_MODELS && (model = sv.models[modelindex]))
2307 v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.server->skin, tagname);
2309 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);
2312 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));
2316 /////////////////////////////////////////
2317 // DP_MD3_TAGINFO extension coded by VorteX
2319 int SV_GetTagIndex (prvm_edict_t *e, const char *tagname)
2324 i = (int)e->fields.server->modelindex;
2325 if (i < 1 || i >= MAX_MODELS)
2327 model = sv.models[i];
2329 return Mod_Alias_GetTagIndexForName(model, (int)e->fields.server->skin, tagname);
2332 void SV_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2334 float scale = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float;
2338 Matrix4x4_CreateFromQuakeEntity(out, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] + ent->fields.server->view_ofs[2], ent->fields.server->v_angle[0], ent->fields.server->v_angle[1], ent->fields.server->v_angle[2], scale);
2340 Matrix4x4_CreateFromQuakeEntity(out, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2], -ent->fields.server->angles[0], ent->fields.server->angles[1], ent->fields.server->angles[2], scale * cl_viewmodel_scale.value);
2343 int SV_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2349 && (modelindex = (int)ent->fields.server->modelindex) >= 1 && modelindex < MAX_MODELS
2350 && (model = sv.models[(int)ent->fields.server->modelindex])
2351 && model->animscenes)
2353 // if model has wrong frame, engine automatically switches to model first frame
2354 frame = (int)ent->fields.server->frame;
2355 if (frame < 0 || frame >= model->numframes)
2357 return Mod_Alias_GetTagMatrix(model, model->animscenes[frame].firstframe, tagindex, out);
2359 *out = identitymatrix;
2363 // Warnings/errors code:
2364 // 0 - normal (everything all-right)
2367 // 3 - null or non-precached model
2368 // 4 - no tags with requested index
2369 // 5 - runaway loop at attachment chain
2370 extern cvar_t cl_bob;
2371 extern cvar_t cl_bobcycle;
2372 extern cvar_t cl_bobup;
2373 int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
2377 int modelindex, attachloop;
2378 matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2381 *out = identitymatrix; // warnings and errors return identical matrix
2383 if (ent == prog->edicts)
2385 if (ent->priv.server->free)
2388 modelindex = (int)ent->fields.server->modelindex;
2389 if (modelindex <= 0 || modelindex > MAX_MODELS)
2392 model = sv.models[modelindex];
2394 tagmatrix = identitymatrix;
2395 // DP_GFX_QUAKE3MODELTAGS, scan all chain and stop on unattached entity
2399 if (attachloop >= 256) // prevent runaway looping
2401 // apply transformation by child's tagindex on parent entity and then
2402 // by parent entity itself
2403 ret = SV_GetEntityLocalTagMatrix(ent, tagindex - 1, &attachmatrix);
2404 if (ret && attachloop == 0)
2406 Matrix4x4_Concat(out, &attachmatrix, &tagmatrix);
2407 SV_GetEntityMatrix(ent, &entitymatrix, false);
2408 Matrix4x4_Concat(&tagmatrix, &entitymatrix, out);
2409 // next iteration we process the parent entity
2410 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)) && val->edict)
2412 tagindex = (int)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
2413 ent = PRVM_EDICT_NUM(val->edict);
2420 // RENDER_VIEWMODEL magic
2421 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)) && val->edict)
2423 Matrix4x4_Copy(&tagmatrix, out);
2424 ent = PRVM_EDICT_NUM(val->edict);
2426 SV_GetEntityMatrix(ent, &entitymatrix, true);
2427 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2430 // Cl_bob, ported from rendering code
2431 if (ent->fields.server->health > 0 && cl_bob.value && cl_bobcycle.value)
2434 // LordHavoc: this code is *weird*, but not replacable (I think it
2435 // should be done in QC on the server, but oh well, quake is quake)
2436 // LordHavoc: figured out bobup: the time at which the sin is at 180
2437 // degrees (which allows lengthening or squishing the peak or valley)
2438 cycle = sv.time/cl_bobcycle.value;
2439 cycle -= (int)cycle;
2440 if (cycle < cl_bobup.value)
2441 cycle = sin(M_PI * cycle / cl_bobup.value);
2443 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2444 // bob is proportional to velocity in the xy plane
2445 // (don't count Z, or jumping messes it up)
2446 bob = sqrt(ent->fields.server->velocity[0]*ent->fields.server->velocity[0] + ent->fields.server->velocity[1]*ent->fields.server->velocity[1])*cl_bob.value;
2447 bob = bob*0.3 + bob*0.7*cycle;
2448 Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2455 //float(entity ent, string tagname) gettagindex;
2457 static void VM_SV_gettagindex (void)
2460 const char *tag_name;
2461 int modelindex, tag_index;
2463 VM_SAFEPARMCOUNT(2, VM_SV_gettagindex);
2465 ent = PRVM_G_EDICT(OFS_PARM0);
2466 tag_name = PRVM_G_STRING(OFS_PARM1);
2468 if (ent == prog->edicts)
2470 VM_Warning("gettagindex: can't affect world entity\n");
2473 if (ent->priv.server->free)
2475 VM_Warning("gettagindex: can't affect free entity\n");
2479 modelindex = (int)ent->fields.server->modelindex;
2481 if (modelindex <= 0 || modelindex > MAX_MODELS)
2482 Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2485 tag_index = SV_GetTagIndex(ent, tag_name);
2487 Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2489 PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2492 //vector(entity ent, float tagindex) gettaginfo;
2493 static void VM_SV_gettaginfo (void)
2497 matrix4x4_t tag_matrix;
2500 VM_SAFEPARMCOUNT(2, VM_SV_gettaginfo);
2502 e = PRVM_G_EDICT(OFS_PARM0);
2503 tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2505 returncode = SV_GetTagMatrix(&tag_matrix, e, tagindex);
2506 Matrix4x4_ToVectors(&tag_matrix, prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up, PRVM_G_VECTOR(OFS_RETURN));
2511 VM_Warning("gettagindex: can't affect world entity\n");
2514 VM_Warning("gettagindex: can't affect free entity\n");
2517 Con_DPrintf("SV_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2520 Con_DPrintf("SV_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2523 Con_DPrintf("SV_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2528 //void(entity clent) dropclient (DP_SV_DROPCLIENT)
2529 static void VM_SV_dropclient (void)
2532 client_t *oldhostclient;
2533 VM_SAFEPARMCOUNT(1, VM_SV_dropclient);
2534 clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2535 if (clientnum < 0 || clientnum >= svs.maxclients)
2537 VM_Warning("dropclient: not a client\n");
2540 if (!svs.clients[clientnum].active)
2542 VM_Warning("dropclient: that client slot is not connected\n");
2545 oldhostclient = host_client;
2546 host_client = svs.clients + clientnum;
2547 SV_DropClient(false);
2548 host_client = oldhostclient;
2551 //entity() spawnclient (DP_SV_BOTCLIENT)
2552 static void VM_SV_spawnclient (void)
2556 VM_SAFEPARMCOUNT(0, VM_SV_spawnclient);
2557 prog->xfunction->builtinsprofile += 2;
2559 for (i = 0;i < svs.maxclients;i++)
2561 if (!svs.clients[i].active)
2563 prog->xfunction->builtinsprofile += 100;
2564 SV_ConnectClient (i, NULL);
2565 // this has to be set or else ClientDisconnect won't be called
2566 // we assume the qc will call ClientConnect...
2567 svs.clients[i].clientconnectcalled = true;
2568 ed = PRVM_EDICT_NUM(i + 1);
2572 VM_RETURN_EDICT(ed);
2575 //float(entity clent) clienttype (DP_SV_BOTCLIENT)
2576 static void VM_SV_clienttype (void)
2579 VM_SAFEPARMCOUNT(1, VM_SV_clienttype);
2580 clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2581 if (clientnum < 0 || clientnum >= svs.maxclients)
2582 PRVM_G_FLOAT(OFS_RETURN) = 3;
2583 else if (!svs.clients[clientnum].active)
2584 PRVM_G_FLOAT(OFS_RETURN) = 0;
2585 else if (svs.clients[clientnum].netconnection)
2586 PRVM_G_FLOAT(OFS_RETURN) = 1;
2588 PRVM_G_FLOAT(OFS_RETURN) = 2;
2595 string(string key) serverkey
2598 void VM_SV_serverkey(void)
2600 char string[VM_STRINGTEMP_LENGTH];
2601 VM_SAFEPARMCOUNT(1, VM_SV_serverkey);
2602 InfoString_GetValue(svs.serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
2603 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
2606 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
2607 static void VM_SV_setmodelindex (void)
2612 VM_SAFEPARMCOUNT(2, VM_SV_setmodelindex);
2614 e = PRVM_G_EDICT(OFS_PARM0);
2615 if (e == prog->edicts)
2617 VM_Warning("setmodelindex: can not modify world entity\n");
2620 if (e->priv.server->free)
2622 VM_Warning("setmodelindex: can not modify free entity\n");
2625 i = (int)PRVM_G_FLOAT(OFS_PARM1);
2626 if (i <= 0 || i > MAX_MODELS)
2628 VM_Warning("setmodelindex: invalid modelindex\n");
2631 if (!sv.model_precache[i][0])
2633 VM_Warning("setmodelindex: model not precached\n");
2637 e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
2638 e->fields.server->modelindex = i;
2644 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
2645 SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
2647 SetMinMaxSize (e, quakemins, quakemaxs, true);
2650 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
2653 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
2654 static void VM_SV_modelnameforindex (void)
2657 VM_SAFEPARMCOUNT(1, VM_SV_modelnameforindex);
2659 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2661 i = (int)PRVM_G_FLOAT(OFS_PARM0);
2662 if (i <= 0 || i > MAX_MODELS)
2664 VM_Warning("modelnameforindex: invalid modelindex\n");
2667 if (!sv.model_precache[i][0])
2669 VM_Warning("modelnameforindex: model not precached\n");
2673 PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(sv.model_precache[i]);
2676 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
2677 static void VM_SV_particleeffectnum (void)
2680 VM_SAFEPARMCOUNT(1, VM_SV_particleeffectnum);
2681 i = SV_ParticleEffectIndex(PRVM_G_STRING(OFS_PARM0));
2684 PRVM_G_FLOAT(OFS_RETURN) = i;
2687 // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
2688 static void VM_SV_trailparticles (void)
2690 VM_SAFEPARMCOUNT(4, VM_SV_trailparticles);
2692 MSG_WriteByte(&sv.datagram, svc_trailparticles);
2693 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2694 MSG_WriteShort(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
2695 MSG_WriteVector(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2), sv.protocol);
2696 MSG_WriteVector(&sv.datagram, PRVM_G_VECTOR(OFS_PARM3), sv.protocol);
2697 SV_FlushBroadcastMessages();
2700 //#337 void(float effectnum, vector origin, vector dir, float count) pointparticles (EXT_CSQC)
2701 static void VM_SV_pointparticles (void)
2703 int effectnum, count;
2705 VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_pointparticles);
2706 effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
2707 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), org);
2708 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
2709 count = bound(0, (int)PRVM_G_FLOAT(OFS_PARM3), 65535);
2710 if (count == 1 && !VectorLength2(vel))
2713 MSG_WriteByte(&sv.datagram, svc_pointparticles1);
2714 MSG_WriteShort(&sv.datagram, effectnum);
2715 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2719 // 1+2+12+12+2=29 bytes
2720 MSG_WriteByte(&sv.datagram, svc_pointparticles);
2721 MSG_WriteShort(&sv.datagram, effectnum);
2722 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2723 MSG_WriteVector(&sv.datagram, vel, sv.protocol);
2724 MSG_WriteShort(&sv.datagram, count);
2727 SV_FlushBroadcastMessages();
2730 prvm_builtin_t vm_sv_builtins[] = {
2731 NULL, // #0 NULL function (not callable) (QUAKE)
2732 VM_makevectors, // #1 void(vector ang) makevectors (QUAKE)
2733 VM_SV_setorigin, // #2 void(entity e, vector o) setorigin (QUAKE)
2734 VM_SV_setmodel, // #3 void(entity e, string m) setmodel (QUAKE)
2735 VM_SV_setsize, // #4 void(entity e, vector min, vector max) setsize (QUAKE)
2736 NULL, // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
2737 VM_break, // #6 void() break (QUAKE)
2738 VM_random, // #7 float() random (QUAKE)
2739 VM_SV_sound, // #8 void(entity e, float chan, string samp) sound (QUAKE)
2740 VM_normalize, // #9 vector(vector v) normalize (QUAKE)
2741 VM_error, // #10 void(string e) error (QUAKE)
2742 VM_objerror, // #11 void(string e) objerror (QUAKE)
2743 VM_vlen, // #12 float(vector v) vlen (QUAKE)
2744 VM_vectoyaw, // #13 float(vector v) vectoyaw (QUAKE)
2745 VM_spawn, // #14 entity() spawn (QUAKE)
2746 VM_remove, // #15 void(entity e) remove (QUAKE)
2747 VM_SV_traceline, // #16 float(vector v1, vector v2, float tryents) traceline (QUAKE)
2748 VM_SV_checkclient, // #17 entity() checkclient (QUAKE)
2749 VM_find, // #18 entity(entity start, .string fld, string match) find (QUAKE)
2750 VM_SV_precache_sound, // #19 void(string s) precache_sound (QUAKE)
2751 VM_SV_precache_model, // #20 void(string s) precache_model (QUAKE)
2752 VM_SV_stuffcmd, // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
2753 VM_SV_findradius, // #22 entity(vector org, float rad) findradius (QUAKE)
2754 VM_bprint, // #23 void(string s, ...) bprint (QUAKE)
2755 VM_SV_sprint, // #24 void(entity client, string s, ...) sprint (QUAKE)
2756 VM_dprint, // #25 void(string s, ...) dprint (QUAKE)
2757 VM_ftos, // #26 string(float f) ftos (QUAKE)
2758 VM_vtos, // #27 string(vector v) vtos (QUAKE)
2759 VM_coredump, // #28 void() coredump (QUAKE)
2760 VM_traceon, // #29 void() traceon (QUAKE)
2761 VM_traceoff, // #30 void() traceoff (QUAKE)
2762 VM_eprint, // #31 void(entity e) eprint (QUAKE)
2763 VM_SV_walkmove, // #32 float(float yaw, float dist) walkmove (QUAKE)
2764 NULL, // #33 (QUAKE)
2765 VM_SV_droptofloor, // #34 float() droptofloor (QUAKE)
2766 VM_SV_lightstyle, // #35 void(float style, string value) lightstyle (QUAKE)
2767 VM_rint, // #36 float(float v) rint (QUAKE)
2768 VM_floor, // #37 float(float v) floor (QUAKE)
2769 VM_ceil, // #38 float(float v) ceil (QUAKE)
2770 NULL, // #39 (QUAKE)
2771 VM_SV_checkbottom, // #40 float(entity e) checkbottom (QUAKE)
2772 VM_SV_pointcontents, // #41 float(vector v) pointcontents (QUAKE)
2773 NULL, // #42 (QUAKE)
2774 VM_fabs, // #43 float(float f) fabs (QUAKE)
2775 VM_SV_aim, // #44 vector(entity e, float speed) aim (QUAKE)
2776 VM_cvar, // #45 float(string s) cvar (QUAKE)
2777 VM_localcmd, // #46 void(string s) localcmd (QUAKE)
2778 VM_nextent, // #47 entity(entity e) nextent (QUAKE)
2779 VM_SV_particle, // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
2780 VM_changeyaw, // #49 void() ChangeYaw (QUAKE)
2781 NULL, // #50 (QUAKE)
2782 VM_vectoangles, // #51 vector(vector v) vectoangles (QUAKE)
2783 VM_SV_WriteByte, // #52 void(float to, float f) WriteByte (QUAKE)
2784 VM_SV_WriteChar, // #53 void(float to, float f) WriteChar (QUAKE)
2785 VM_SV_WriteShort, // #54 void(float to, float f) WriteShort (QUAKE)
2786 VM_SV_WriteLong, // #55 void(float to, float f) WriteLong (QUAKE)
2787 VM_SV_WriteCoord, // #56 void(float to, float f) WriteCoord (QUAKE)
2788 VM_SV_WriteAngle, // #57 void(float to, float f) WriteAngle (QUAKE)
2789 VM_SV_WriteString, // #58 void(float to, string s) WriteString (QUAKE)
2790 VM_SV_WriteEntity, // #59 void(float to, entity e) WriteEntity (QUAKE)
2791 VM_sin, // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW) (QUAKE)
2792 VM_cos, // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW) (QUAKE)
2793 VM_sqrt, // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW) (QUAKE)
2794 VM_changepitch, // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH) (QUAKE)
2795 VM_SV_tracetoss, // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS) (QUAKE)
2796 VM_etos, // #65 string(entity ent) etos (DP_QC_ETOS) (QUAKE)
2797 NULL, // #66 (QUAKE)
2798 SV_MoveToGoal, // #67 void(float step) movetogoal (QUAKE)
2799 VM_precache_file, // #68 string(string s) precache_file (QUAKE)
2800 VM_SV_makestatic, // #69 void(entity e) makestatic (QUAKE)
2801 VM_changelevel, // #70 void(string s) changelevel (QUAKE)
2802 NULL, // #71 (QUAKE)
2803 VM_cvar_set, // #72 void(string var, string val) cvar_set (QUAKE)
2804 VM_SV_centerprint, // #73 void(entity client, strings) centerprint (QUAKE)
2805 VM_SV_ambientsound, // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
2806 VM_SV_precache_model, // #75 string(string s) precache_model2 (QUAKE)
2807 VM_SV_precache_sound, // #76 string(string s) precache_sound2 (QUAKE)
2808 VM_precache_file, // #77 string(string s) precache_file2 (QUAKE)
2809 VM_SV_setspawnparms, // #78 void(entity e) setspawnparms (QUAKE)
2810 NULL, // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
2811 NULL, // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
2812 VM_stof, // #81 float(string s) stof (FRIK_FILE)
2813 NULL, // #82 void(vector where, float set) multicast (QUAKEWORLD)
2814 NULL, // #83 (QUAKE)
2815 NULL, // #84 (QUAKE)
2816 NULL, // #85 (QUAKE)
2817 NULL, // #86 (QUAKE)
2818 NULL, // #87 (QUAKE)
2819 NULL, // #88 (QUAKE)
2820 NULL, // #89 (QUAKE)
2821 VM_SV_tracebox, // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
2822 VM_randomvec, // #91 vector() randomvec (DP_QC_RANDOMVEC)
2823 VM_SV_getlight, // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
2824 VM_registercvar, // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
2825 VM_min, // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
2826 VM_max, // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
2827 VM_bound, // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
2828 VM_pow, // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
2829 VM_findfloat, // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
2830 VM_checkextension, // #99 float(string s) checkextension (the basis of the extension system)
2831 // FrikaC and Telejano range #100-#199
2842 VM_fopen, // #110 float(string filename, float mode) fopen (FRIK_FILE)
2843 VM_fclose, // #111 void(float fhandle) fclose (FRIK_FILE)
2844 VM_fgets, // #112 string(float fhandle) fgets (FRIK_FILE)
2845 VM_fputs, // #113 void(float fhandle, string s) fputs (FRIK_FILE)
2846 VM_strlen, // #114 float(string s) strlen (FRIK_FILE)
2847 VM_strcat, // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
2848 VM_substring, // #116 string(string s, float start, float length) substring (FRIK_FILE)
2849 VM_stov, // #117 vector(string) stov (FRIK_FILE)
2850 VM_strzone, // #118 string(string s) strzone (FRIK_FILE)
2851 VM_strunzone, // #119 void(string s) strunzone (FRIK_FILE)
2932 // FTEQW range #200-#299
2951 VM_bitshift, // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
2954 VM_strstrofs, // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
2955 VM_str2chr, // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
2956 VM_chr2str, // #223 string(float c, ...) chr2str (FTE_STRINGS)
2957 VM_strconv, // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
2958 VM_strpad, // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
2959 VM_infoadd, // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
2960 VM_infoget, // #227 string(string info, string key) infoget (FTE_STRINGS)
2961 VM_strncmp, // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
2962 VM_strncasecmp, // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
2963 VM_strncasecmp, // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
2965 VM_SV_AddStat, // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
3033 // CSQC range #300-#399
3034 NULL, // #300 void() clearscene (EXT_CSQC)
3035 NULL, // #301 void(float mask) addentities (EXT_CSQC)
3036 NULL, // #302 void(entity ent) addentity (EXT_CSQC)
3037 NULL, // #303 float(float property, ...) setproperty (EXT_CSQC)
3038 NULL, // #304 void() renderscene (EXT_CSQC)
3039 NULL, // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
3040 NULL, // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
3041 NULL, // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3042 NULL, // #308 void() R_EndPolygon
3044 NULL, // #310 vector (vector v) cs_unproject (EXT_CSQC)
3045 NULL, // #311 vector (vector v) cs_project (EXT_CSQC)
3049 NULL, // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
3050 NULL, // #316 float(string name) iscachedpic (EXT_CSQC)
3051 NULL, // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
3052 NULL, // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
3053 NULL, // #319 void(string name) freepic (EXT_CSQC)
3054 NULL, // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
3055 NULL, // #321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
3056 NULL, // #322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
3057 NULL, // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
3058 NULL, // #324 void(float x, float y, float width, float height) drawsetcliparea
3059 NULL, // #325 void(void) drawresetcliparea
3064 NULL, // #330 float(float stnum) getstatf (EXT_CSQC)
3065 NULL, // #331 float(float stnum) getstati (EXT_CSQC)
3066 NULL, // #332 string(float firststnum) getstats (EXT_CSQC)
3067 VM_SV_setmodelindex, // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
3068 VM_SV_modelnameforindex, // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
3069 VM_SV_particleeffectnum, // #335 float(string effectname) particleeffectnum (EXT_CSQC)
3070 VM_SV_trailparticles, // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
3071 VM_SV_pointparticles, // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
3072 NULL, // #338 void(string s, ...) centerprint (EXT_CSQC)
3073 VM_print, // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
3074 NULL, // #340 string(float keynum) keynumtostring (EXT_CSQC)
3075 NULL, // #341 float(string keyname) stringtokeynum (EXT_CSQC)
3076 NULL, // #342 string(float keynum) getkeybind (EXT_CSQC)
3077 NULL, // #343 void(float usecursor) setcursormode (EXT_CSQC)
3078 NULL, // #344 vector() getmousepos (EXT_CSQC)
3079 NULL, // #345 float(float framenum) getinputstate (EXT_CSQC)
3080 NULL, // #346 void(float sens) setsensitivityscaler (EXT_CSQC)
3081 NULL, // #347 void() runstandardplayerphysics (EXT_CSQC)
3082 NULL, // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
3083 NULL, // #349 float() isdemo (EXT_CSQC)
3084 VM_isserver, // #350 float() isserver (EXT_CSQC)
3085 NULL, // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
3086 NULL, // #352 void(string cmdname) registercommand (EXT_CSQC)
3087 VM_wasfreed, // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
3088 VM_SV_serverkey, // #354 string(string key) serverkey (EXT_CSQC)
3094 NULL, // #360 float() readbyte (EXT_CSQC)
3095 NULL, // #361 float() readchar (EXT_CSQC)
3096 NULL, // #362 float() readshort (EXT_CSQC)
3097 NULL, // #363 float() readlong (EXT_CSQC)
3098 NULL, // #364 float() readcoord (EXT_CSQC)
3099 NULL, // #365 float() readangle (EXT_CSQC)
3100 NULL, // #366 string() readstring (EXT_CSQC)
3101 NULL, // #367 float() readfloat (EXT_CSQC)
3134 // LordHavoc's range #400-#499
3135 VM_SV_copyentity, // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
3136 VM_SV_setcolor, // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
3137 VM_findchain, // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
3138 VM_findchainfloat, // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
3139 VM_SV_effect, // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
3140 VM_SV_te_blood, // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
3141 VM_SV_te_bloodshower, // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
3142 VM_SV_te_explosionrgb, // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
3143 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)
3144 VM_SV_te_particlerain, // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
3145 VM_SV_te_particlesnow, // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
3146 VM_SV_te_spark, // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
3147 VM_SV_te_gunshotquad, // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
3148 VM_SV_te_spikequad, // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
3149 VM_SV_te_superspikequad, // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
3150 VM_SV_te_explosionquad, // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
3151 VM_SV_te_smallflash, // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
3152 VM_SV_te_customflash, // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
3153 VM_SV_te_gunshot, // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
3154 VM_SV_te_spike, // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
3155 VM_SV_te_superspike, // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
3156 VM_SV_te_explosion, // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
3157 VM_SV_te_tarexplosion, // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
3158 VM_SV_te_wizspike, // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
3159 VM_SV_te_knightspike, // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
3160 VM_SV_te_lavasplash, // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
3161 VM_SV_te_teleport, // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
3162 VM_SV_te_explosion2, // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
3163 VM_SV_te_lightning1, // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
3164 VM_SV_te_lightning2, // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
3165 VM_SV_te_lightning3, // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
3166 VM_SV_te_beam, // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
3167 VM_vectorvectors, // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
3168 VM_SV_te_plasmaburn, // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
3169 VM_SV_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
3170 VM_SV_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
3171 VM_SV_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
3172 VM_SV_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
3173 VM_SV_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
3174 VM_SV_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
3175 VM_SV_clientcommand, // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
3176 VM_tokenize, // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
3177 VM_argv, // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
3178 VM_SV_setattachment, // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
3179 VM_search_begin, // #444 float(string pattern, float caseinsensitive, float quiet) search_begin (DP_QC_FS_SEARCH)
3180 VM_search_end, // #445 void(float handle) search_end (DP_QC_FS_SEARCH)
3181 VM_search_getsize, // #446 float(float handle) search_getsize (DP_QC_FS_SEARCH)
3182 VM_search_getfilename, // #447 string(float handle, float num) search_getfilename (DP_QC_FS_SEARCH)
3183 VM_cvar_string, // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
3184 VM_findflags, // #449 entity(entity start, .float fld, float match) findflags (DP_QC_FINDFLAGS)
3185 VM_findchainflags, // #450 entity(.float fld, float match) findchainflags (DP_QC_FINDCHAINFLAGS)
3186 VM_SV_gettagindex, // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
3187 VM_SV_gettaginfo, // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
3188 VM_SV_dropclient, // #453 void(entity clent) dropclient (DP_SV_DROPCLIENT)
3189 VM_SV_spawnclient, // #454 entity() spawnclient (DP_SV_BOTCLIENT)
3190 VM_SV_clienttype, // #455 float(entity clent) clienttype (DP_SV_BOTCLIENT)
3191 VM_SV_WriteUnterminatedString, // #456 void(float to, string s) WriteUnterminatedString (DP_SV_WRITEUNTERMINATEDSTRING)
3192 VM_SV_te_flamejet, // #457 void(vector org, vector vel, float howmany) te_flamejet = #457 (DP_TE_FLAMEJET)
3194 VM_ftoe, // #459 entity(float num) entitybyindex (DP_QC_EDICT_NUM)
3195 VM_buf_create, // #460 float() buf_create (DP_QC_STRINGBUFFERS)
3196 VM_buf_del, // #461 void(float bufhandle) buf_del (DP_QC_STRINGBUFFERS)
3197 VM_buf_getsize, // #462 float(float bufhandle) buf_getsize (DP_QC_STRINGBUFFERS)
3198 VM_buf_copy, // #463 void(float bufhandle_from, float bufhandle_to) buf_copy (DP_QC_STRINGBUFFERS)
3199 VM_buf_sort, // #464 void(float bufhandle, float sortpower, float backward) buf_sort (DP_QC_STRINGBUFFERS)
3200 VM_buf_implode, // #465 string(float bufhandle, string glue) buf_implode (DP_QC_STRINGBUFFERS)
3201 VM_bufstr_get, // #466 string(float bufhandle, float string_index) bufstr_get (DP_QC_STRINGBUFFERS)
3202 VM_bufstr_set, // #467 void(float bufhandle, float string_index, string str) bufstr_set (DP_QC_STRINGBUFFERS)
3203 VM_bufstr_add, // #468 float(float bufhandle, string str, float order) bufstr_add (DP_QC_STRINGBUFFERS)
3204 VM_bufstr_free, // #469 void(float bufhandle, float string_index) bufstr_free (DP_QC_STRINGBUFFERS)
3206 VM_asin, // #471 float(float s) VM_asin (DP_QC_ASINACOSATANATAN2TAN)
3207 VM_acos, // #472 float(float c) VM_acos (DP_QC_ASINACOSATANATAN2TAN)
3208 VM_atan, // #473 float(float t) VM_atan (DP_QC_ASINACOSATANATAN2TAN)
3209 VM_atan2, // #474 float(float c, float s) VM_atan2 (DP_QC_ASINACOSATANATAN2TAN)
3210 VM_tan, // #475 float(float a) VM_tan (DP_QC_ASINACOSATANATAN2TAN)
3211 VM_strlennocol, // #476 float(string s) : DRESK - String Length (not counting color codes) (DP_QC_STRINGCOLORFUNCTIONS)
3212 VM_strdecolorize, // #477 string(string s) : DRESK - Decolorized String (DP_SV_STRINGCOLORFUNCTIONS)
3213 VM_strftime, // #478 string(float uselocaltime, string format, ...) (DP_QC_STRFTIME)
3214 VM_tokenizebyseparator, // #479 float(string s) tokenizebyseparator (DP_QC_TOKENIZEBYSEPARATOR)
3215 VM_strtolower, // #480 string(string s) VM_strtolower (DP_QC_STRING_CASE_FUNCTIONS)
3216 VM_strtoupper, // #481 string(string s) VM_strtoupper (DP_QC_STRING_CASE_FUNCTIONS)
3217 VM_cvar_defstring, // #482 string(string s) cvar_defstring (DP_QC_CVAR_DEFSTRING)
3218 VM_SV_pointsound, // #483 void(vector origin, string sample, float volume, float attenuation) (DP_SV_POINTSOUND)
3237 const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t);
3239 void VM_SV_Cmd_Init(void)
3244 void VM_SV_Cmd_Reset(void)