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 "
153 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.
155 setorigin (entity, origin)
158 static void VM_SV_setorigin (void)
163 VM_SAFEPARMCOUNT(2, VM_setorigin);
165 e = PRVM_G_EDICT(OFS_PARM0);
166 if (e == prog->edicts)
168 VM_Warning("setorigin: can not modify world entity\n");
171 if (e->priv.server->free)
173 VM_Warning("setorigin: can not modify free entity\n");
176 org = PRVM_G_VECTOR(OFS_PARM1);
177 VectorCopy (org, e->fields.server->origin);
178 SV_LinkEdict (e, false);
182 void SetMinMaxSize (prvm_edict_t *e, float *min, float *max, qboolean rotate)
186 for (i=0 ; i<3 ; i++)
188 PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
190 // set derived values
191 VectorCopy (min, e->fields.server->mins);
192 VectorCopy (max, e->fields.server->maxs);
193 VectorSubtract (max, min, e->fields.server->size);
195 SV_LinkEdict (e, false);
202 the size box is rotated by the current angle
203 LordHavoc: no it isn't...
205 setsize (entity, minvector, maxvector)
208 static void VM_SV_setsize (void)
213 VM_SAFEPARMCOUNT(3, VM_setsize);
215 e = PRVM_G_EDICT(OFS_PARM0);
216 if (e == prog->edicts)
218 VM_Warning("setsize: can not modify world entity\n");
221 if (e->priv.server->free)
223 VM_Warning("setsize: can not modify free entity\n");
226 min = PRVM_G_VECTOR(OFS_PARM1);
227 max = PRVM_G_VECTOR(OFS_PARM2);
228 SetMinMaxSize (e, min, max, false);
236 setmodel(entity, model)
239 static vec3_t quakemins = {-16, -16, -16}, quakemaxs = {16, 16, 16};
240 static void VM_SV_setmodel (void)
246 VM_SAFEPARMCOUNT(2, VM_setmodel);
248 e = PRVM_G_EDICT(OFS_PARM0);
249 if (e == prog->edicts)
251 VM_Warning("setmodel: can not modify world entity\n");
254 if (e->priv.server->free)
256 VM_Warning("setmodel: can not modify free entity\n");
259 i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);
260 e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
261 e->fields.server->modelindex = i;
267 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
268 SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
270 SetMinMaxSize (e, quakemins, quakemaxs, true);
273 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
280 single print to a specific client
282 sprint(clientent, value)
285 static void VM_SV_sprint (void)
289 char string[VM_STRINGTEMP_LENGTH];
291 VM_VarString(1, string, sizeof(string));
293 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_sprint);
295 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
296 // LordHavoc: div0 requested that sprintto world operate like print
303 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
305 VM_Warning("tried to centerprint to a non-client\n");
309 client = svs.clients + entnum-1;
310 if (!client->netconnection)
313 MSG_WriteChar(&client->netconnection->message,svc_print);
314 MSG_WriteString(&client->netconnection->message, string);
322 single print to a specific client
324 centerprint(clientent, value)
327 static void VM_SV_centerprint (void)
331 char string[VM_STRINGTEMP_LENGTH];
333 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_centerprint);
335 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
337 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
339 VM_Warning("tried to centerprint to a non-client\n");
343 client = svs.clients + entnum-1;
344 if (!client->netconnection)
347 VM_VarString(1, string, sizeof(string));
348 MSG_WriteChar(&client->netconnection->message,svc_centerprint);
349 MSG_WriteString(&client->netconnection->message, string);
356 particle(origin, color, count)
359 static void VM_SV_particle (void)
365 VM_SAFEPARMCOUNT(4, VM_SV_particle);
367 org = PRVM_G_VECTOR(OFS_PARM0);
368 dir = PRVM_G_VECTOR(OFS_PARM1);
369 color = PRVM_G_FLOAT(OFS_PARM2);
370 count = PRVM_G_FLOAT(OFS_PARM3);
371 SV_StartParticle (org, dir, (int)color, (int)count);
381 static void VM_SV_ambientsound (void)
385 float vol, attenuation;
388 VM_SAFEPARMCOUNT(4, VM_SV_ambientsound);
390 pos = PRVM_G_VECTOR (OFS_PARM0);
391 samp = PRVM_G_STRING(OFS_PARM1);
392 vol = PRVM_G_FLOAT(OFS_PARM2);
393 attenuation = PRVM_G_FLOAT(OFS_PARM3);
395 // check to see if samp was properly precached
396 soundnum = SV_SoundIndex(samp, 1);
404 // add an svc_spawnambient command to the level signon packet
407 MSG_WriteByte (&sv.signon, svc_spawnstaticsound2);
409 MSG_WriteByte (&sv.signon, svc_spawnstaticsound);
411 MSG_WriteVector(&sv.signon, pos, sv.protocol);
413 if (large || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
414 MSG_WriteShort (&sv.signon, soundnum);
416 MSG_WriteByte (&sv.signon, soundnum);
418 MSG_WriteByte (&sv.signon, (int)(vol*255));
419 MSG_WriteByte (&sv.signon, (int)(attenuation*64));
427 Each entity can have eight independant sound sources, like voice,
430 Channel 0 is an auto-allocate channel, the others override anything
431 already running on that entity/channel pair.
433 An attenuation of 0 will play full volume everywhere in the level.
434 Larger attenuations will drop off.
438 static void VM_SV_sound (void)
442 prvm_edict_t *entity;
446 VM_SAFEPARMCOUNTRANGE(4, 5, VM_SV_sound);
448 entity = PRVM_G_EDICT(OFS_PARM0);
449 channel = (int)PRVM_G_FLOAT(OFS_PARM1);
450 sample = PRVM_G_STRING(OFS_PARM2);
451 volume = (int)(PRVM_G_FLOAT(OFS_PARM3) * 255);
452 attenuation = PRVM_G_FLOAT(OFS_PARM4);
455 Con_DPrintf("VM_SV_sound: given only 4 parameters, expected 5, assuming attenuation = ATTN_NORMAL\n");
459 if (volume < 0 || volume > 255)
461 VM_Warning("SV_StartSound: volume must be in range 0-1\n");
465 if (attenuation < 0 || attenuation > 4)
467 VM_Warning("SV_StartSound: attenuation must be in range 0-4\n");
471 if (channel < 0 || channel > 7)
473 VM_Warning("SV_StartSound: channel must be in range 0-7\n");
477 SV_StartSound (entity, channel, sample, volume, attenuation);
484 Follows the same logic as VM_SV_sound, except instead of
485 an entity, an origin for the sound is provided, and channel
486 is omitted (since no entity is being tracked).
490 static void VM_SV_pointsound(void)
497 VM_SAFEPARMCOUNT(4, VM_SV_pointsound);
499 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
500 sample = PRVM_G_STRING(OFS_PARM1);
501 volume = (int)(PRVM_G_FLOAT(OFS_PARM2) * 255);
502 attenuation = PRVM_G_FLOAT(OFS_PARM3);
504 if (volume < 0 || volume > 255)
506 VM_Warning("SV_StartPointSound: volume must be in range 0-1\n");
510 if (attenuation < 0 || attenuation > 4)
512 VM_Warning("SV_StartPointSound: attenuation must be in range 0-4\n");
516 SV_StartPointSound (org, sample, volume, attenuation);
523 Used for use tracing and shot targeting
524 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
525 if the tryents flag is set.
527 traceline (vector1, vector2, movetype, ignore)
530 static void VM_SV_traceline (void)
537 VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_traceline); // allow more parameters for future expansion
539 prog->xfunction->builtinsprofile += 30;
541 v1 = PRVM_G_VECTOR(OFS_PARM0);
542 v2 = PRVM_G_VECTOR(OFS_PARM1);
543 move = (int)PRVM_G_FLOAT(OFS_PARM2);
544 ent = PRVM_G_EDICT(OFS_PARM3);
546 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]))
547 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));
549 trace = SV_Move (v1, vec3_origin, vec3_origin, v2, move, ent, SV_GenericHitSuperContentsMask(ent));
551 VM_SetTraceGlobals(&trace);
559 Used for use tracing and shot targeting
560 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
561 if the tryents flag is set.
563 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
566 // LordHavoc: added this for my own use, VERY useful, similar to traceline
567 static void VM_SV_tracebox (void)
569 float *v1, *v2, *m1, *m2;
574 VM_SAFEPARMCOUNTRANGE(6, 8, VM_SV_tracebox); // allow more parameters for future expansion
576 prog->xfunction->builtinsprofile += 30;
578 v1 = PRVM_G_VECTOR(OFS_PARM0);
579 m1 = PRVM_G_VECTOR(OFS_PARM1);
580 m2 = PRVM_G_VECTOR(OFS_PARM2);
581 v2 = PRVM_G_VECTOR(OFS_PARM3);
582 move = (int)PRVM_G_FLOAT(OFS_PARM4);
583 ent = PRVM_G_EDICT(OFS_PARM5);
585 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]))
586 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));
588 trace = SV_Move (v1, m1, m2, v2, move, ent, SV_GenericHitSuperContentsMask(ent));
590 VM_SetTraceGlobals(&trace);
593 static trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
598 vec3_t original_origin;
599 vec3_t original_velocity;
600 vec3_t original_angles;
601 vec3_t original_avelocity;
605 VectorCopy(tossent->fields.server->origin , original_origin );
606 VectorCopy(tossent->fields.server->velocity , original_velocity );
607 VectorCopy(tossent->fields.server->angles , original_angles );
608 VectorCopy(tossent->fields.server->avelocity, original_avelocity);
610 val = PRVM_EDICTFIELDVALUE(tossent, prog->fieldoffsets.gravity);
611 if (val != NULL && val->_float != 0)
612 gravity = val->_float;
615 gravity *= sv_gravity.value * 0.05;
617 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
619 SV_CheckVelocity (tossent);
620 tossent->fields.server->velocity[2] -= gravity;
621 VectorMA (tossent->fields.server->angles, 0.05, tossent->fields.server->avelocity, tossent->fields.server->angles);
622 VectorScale (tossent->fields.server->velocity, 0.05, move);
623 VectorAdd (tossent->fields.server->origin, move, end);
624 trace = SV_Move (tossent->fields.server->origin, tossent->fields.server->mins, tossent->fields.server->maxs, end, MOVE_NORMAL, tossent, SV_GenericHitSuperContentsMask(tossent));
625 VectorCopy (trace.endpos, tossent->fields.server->origin);
627 if (trace.fraction < 1)
631 VectorCopy(original_origin , tossent->fields.server->origin );
632 VectorCopy(original_velocity , tossent->fields.server->velocity );
633 VectorCopy(original_angles , tossent->fields.server->angles );
634 VectorCopy(original_avelocity, tossent->fields.server->avelocity);
639 static void VM_SV_tracetoss (void)
643 prvm_edict_t *ignore;
645 VM_SAFEPARMCOUNT(2, VM_SV_tracetoss);
647 prog->xfunction->builtinsprofile += 600;
649 ent = PRVM_G_EDICT(OFS_PARM0);
650 if (ent == prog->edicts)
652 VM_Warning("tracetoss: can not use world entity\n");
655 ignore = PRVM_G_EDICT(OFS_PARM1);
657 trace = SV_Trace_Toss (ent, ignore);
659 VM_SetTraceGlobals(&trace);
662 //============================================================================
664 static int checkpvsbytes;
665 static unsigned char checkpvs[MAX_MAP_LEAFS/8];
667 static int VM_SV_newcheckclient (int check)
673 // cycle to the next one
675 check = bound(1, check, svs.maxclients);
676 if (check == svs.maxclients)
684 prog->xfunction->builtinsprofile++;
686 if (i == svs.maxclients+1)
688 // look up the client's edict
689 ent = PRVM_EDICT_NUM(i);
690 // check if it is to be ignored, but never ignore the one we started on (prevent infinite loop)
691 if (i != check && (ent->priv.server->free || ent->fields.server->health <= 0 || ((int)ent->fields.server->flags & FL_NOTARGET)))
693 // found a valid client (possibly the same one again)
697 // get the PVS for the entity
698 VectorAdd(ent->fields.server->origin, ent->fields.server->view_ofs, org);
700 if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
701 checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs), false);
710 Returns a client (or object that has a client enemy) that would be a
713 If there is more than one valid option, they are cycled each frame
715 If (self.origin + self.viewofs) is not in the PVS of the current target,
716 it is not returned at all.
721 int c_invis, c_notvis;
722 static void VM_SV_checkclient (void)
724 prvm_edict_t *ent, *self;
727 VM_SAFEPARMCOUNT(0, VM_SV_checkclient);
729 // find a new check if on a new frame
730 if (sv.time - sv.lastchecktime >= 0.1)
732 sv.lastcheck = VM_SV_newcheckclient (sv.lastcheck);
733 sv.lastchecktime = sv.time;
736 // return check if it might be visible
737 ent = PRVM_EDICT_NUM(sv.lastcheck);
738 if (ent->priv.server->free || ent->fields.server->health <= 0)
740 VM_RETURN_EDICT(prog->edicts);
744 // if current entity can't possibly see the check entity, return 0
745 self = PRVM_PROG_TO_EDICT(prog->globals.server->self);
746 VectorAdd(self->fields.server->origin, self->fields.server->view_ofs, view);
747 if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
750 VM_RETURN_EDICT(prog->edicts);
754 // might be able to see it
756 VM_RETURN_EDICT(ent);
759 //============================================================================
766 Sends text over to the client's execution buffer
768 stuffcmd (clientent, value, ...)
771 static void VM_SV_stuffcmd (void)
775 char string[VM_STRINGTEMP_LENGTH];
777 VM_SAFEPARMCOUNTRANGE(2, 8, VM_SV_stuffcmd);
779 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
780 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
782 VM_Warning("Can't stuffcmd to a non-client\n");
786 VM_VarString(1, string, sizeof(string));
789 host_client = svs.clients + entnum-1;
790 Host_ClientCommands ("%s", string);
798 Returns a chain of entities that have origins within a spherical area
800 findradius (origin, radius)
803 static void VM_SV_findradius (void)
805 prvm_edict_t *ent, *chain;
806 vec_t radius, radius2;
807 vec3_t org, eorg, mins, maxs;
810 prvm_edict_t *touchedicts[MAX_EDICTS];
812 VM_SAFEPARMCOUNT(2, VM_SV_findradius);
814 chain = (prvm_edict_t *)prog->edicts;
816 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
817 radius = PRVM_G_FLOAT(OFS_PARM1);
818 radius2 = radius * radius;
820 mins[0] = org[0] - (radius + 1);
821 mins[1] = org[1] - (radius + 1);
822 mins[2] = org[2] - (radius + 1);
823 maxs[0] = org[0] + (radius + 1);
824 maxs[1] = org[1] + (radius + 1);
825 maxs[2] = org[2] + (radius + 1);
826 numtouchedicts = World_EntitiesInBox(&sv.world, mins, maxs, MAX_EDICTS, touchedicts);
827 if (numtouchedicts > MAX_EDICTS)
829 // this never happens
830 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
831 numtouchedicts = MAX_EDICTS;
833 for (i = 0;i < numtouchedicts;i++)
835 ent = touchedicts[i];
836 prog->xfunction->builtinsprofile++;
837 // Quake did not return non-solid entities but darkplaces does
838 // (note: this is the reason you can't blow up fallen zombies)
839 if (ent->fields.server->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
841 // LordHavoc: compare against bounding box rather than center so it
842 // doesn't miss large objects, and use DotProduct instead of Length
843 // for a major speedup
844 VectorSubtract(org, ent->fields.server->origin, eorg);
845 if (sv_gameplayfix_findradiusdistancetobox.integer)
847 eorg[0] -= bound(ent->fields.server->mins[0], eorg[0], ent->fields.server->maxs[0]);
848 eorg[1] -= bound(ent->fields.server->mins[1], eorg[1], ent->fields.server->maxs[1]);
849 eorg[2] -= bound(ent->fields.server->mins[2], eorg[2], ent->fields.server->maxs[2]);
852 VectorMAMAM(1, eorg, -0.5f, ent->fields.server->mins, -0.5f, ent->fields.server->maxs, eorg);
853 if (DotProduct(eorg, eorg) < radius2)
855 ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
860 VM_RETURN_EDICT(chain);
863 static void VM_SV_precache_sound (void)
865 VM_SAFEPARMCOUNT(1, VM_SV_precache_sound);
866 SV_SoundIndex(PRVM_G_STRING(OFS_PARM0), 2);
867 PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
870 static void VM_SV_precache_model (void)
872 VM_SAFEPARMCOUNT(1, VM_SV_precache_model);
873 SV_ModelIndex(PRVM_G_STRING(OFS_PARM0), 2);
874 PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
881 float(float yaw, float dist[, settrace]) walkmove
884 static void VM_SV_walkmove (void)
893 VM_SAFEPARMCOUNTRANGE(2, 3, VM_SV_walkmove);
895 // assume failure if it returns early
896 PRVM_G_FLOAT(OFS_RETURN) = 0;
898 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
899 if (ent == prog->edicts)
901 VM_Warning("walkmove: can not modify world entity\n");
904 if (ent->priv.server->free)
906 VM_Warning("walkmove: can not modify free entity\n");
909 yaw = PRVM_G_FLOAT(OFS_PARM0);
910 dist = PRVM_G_FLOAT(OFS_PARM1);
911 settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
913 if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
916 yaw = yaw*M_PI*2 / 360;
918 move[0] = cos(yaw)*dist;
919 move[1] = sin(yaw)*dist;
922 // save program state, because SV_movestep may call other progs
923 oldf = prog->xfunction;
924 oldself = prog->globals.server->self;
926 PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true, false, settrace);
929 // restore program state
930 prog->xfunction = oldf;
931 prog->globals.server->self = oldself;
941 static void VM_SV_droptofloor (void)
947 VM_SAFEPARMCOUNTRANGE(0, 2, VM_SV_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
949 // assume failure if it returns early
950 PRVM_G_FLOAT(OFS_RETURN) = 0;
952 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
953 if (ent == prog->edicts)
955 VM_Warning("droptofloor: can not modify world entity\n");
958 if (ent->priv.server->free)
960 VM_Warning("droptofloor: can not modify free entity\n");
964 VectorCopy (ent->fields.server->origin, end);
967 trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
969 if (trace.fraction != 1 || (trace.startsolid && sv_gameplayfix_droptofloorstartsolid.integer))
971 if (trace.fraction < 1)
972 VectorCopy (trace.endpos, ent->fields.server->origin);
973 SV_LinkEdict (ent, false);
974 ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
975 ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
976 PRVM_G_FLOAT(OFS_RETURN) = 1;
977 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
978 ent->priv.server->suspendedinairflag = true;
986 void(float style, string value) lightstyle
989 static void VM_SV_lightstyle (void)
996 VM_SAFEPARMCOUNT(2, VM_SV_lightstyle);
998 style = (int)PRVM_G_FLOAT(OFS_PARM0);
999 val = PRVM_G_STRING(OFS_PARM1);
1001 if( (unsigned) style >= MAX_LIGHTSTYLES ) {
1002 PRVM_ERROR( "PF_lightstyle: style: %i >= 64", style );
1005 // change the string in sv
1006 strlcpy(sv.lightstyles[style], val, sizeof(sv.lightstyles[style]));
1008 // send message to all clients on this server
1009 if (sv.state != ss_active)
1012 for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1014 if (client->active && client->netconnection)
1016 MSG_WriteChar (&client->netconnection->message, svc_lightstyle);
1017 MSG_WriteChar (&client->netconnection->message,style);
1018 MSG_WriteString (&client->netconnection->message, val);
1028 static void VM_SV_checkbottom (void)
1030 VM_SAFEPARMCOUNT(1, VM_SV_checkbottom);
1031 PRVM_G_FLOAT(OFS_RETURN) = SV_CheckBottom (PRVM_G_EDICT(OFS_PARM0));
1039 static void VM_SV_pointcontents (void)
1041 VM_SAFEPARMCOUNT(1, VM_SV_pointcontents);
1042 PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
1049 Pick a vector for the player to shoot along
1050 vector aim(entity, missilespeed)
1053 static void VM_SV_aim (void)
1055 prvm_edict_t *ent, *check, *bestent;
1056 vec3_t start, dir, end, bestdir;
1059 float dist, bestdist;
1062 VM_SAFEPARMCOUNT(2, VM_SV_aim);
1064 // assume failure if it returns early
1065 VectorCopy(prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
1066 // if sv_aim is so high it can't possibly accept anything, skip out early
1067 if (sv_aim.value >= 1)
1070 ent = PRVM_G_EDICT(OFS_PARM0);
1071 if (ent == prog->edicts)
1073 VM_Warning("aim: can not use world entity\n");
1076 if (ent->priv.server->free)
1078 VM_Warning("aim: can not use free entity\n");
1081 speed = PRVM_G_FLOAT(OFS_PARM1);
1083 VectorCopy (ent->fields.server->origin, start);
1086 // try sending a trace straight
1087 VectorCopy (prog->globals.server->v_forward, dir);
1088 VectorMA (start, 2048, dir, end);
1089 tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
1090 if (tr.ent && ((prvm_edict_t *)tr.ent)->fields.server->takedamage == DAMAGE_AIM
1091 && (!teamplay.integer || ent->fields.server->team <=0 || ent->fields.server->team != ((prvm_edict_t *)tr.ent)->fields.server->team) )
1093 VectorCopy (prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
1098 // try all possible entities
1099 VectorCopy (dir, bestdir);
1100 bestdist = sv_aim.value;
1103 check = PRVM_NEXT_EDICT(prog->edicts);
1104 for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
1106 prog->xfunction->builtinsprofile++;
1107 if (check->fields.server->takedamage != DAMAGE_AIM)
1111 if (teamplay.integer && ent->fields.server->team > 0 && ent->fields.server->team == check->fields.server->team)
1112 continue; // don't aim at teammate
1113 for (j=0 ; j<3 ; j++)
1114 end[j] = check->fields.server->origin[j]
1115 + 0.5*(check->fields.server->mins[j] + check->fields.server->maxs[j]);
1116 VectorSubtract (end, start, dir);
1117 VectorNormalize (dir);
1118 dist = DotProduct (dir, prog->globals.server->v_forward);
1119 if (dist < bestdist)
1120 continue; // to far to turn
1121 tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
1122 if (tr.ent == check)
1123 { // can shoot at this one
1131 VectorSubtract (bestent->fields.server->origin, ent->fields.server->origin, dir);
1132 dist = DotProduct (dir, prog->globals.server->v_forward);
1133 VectorScale (prog->globals.server->v_forward, dist, end);
1135 VectorNormalize (end);
1136 VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));
1140 VectorCopy (bestdir, PRVM_G_VECTOR(OFS_RETURN));
1145 ===============================================================================
1149 ===============================================================================
1152 #define MSG_BROADCAST 0 // unreliable to all
1153 #define MSG_ONE 1 // reliable to one (msg_entity)
1154 #define MSG_ALL 2 // reliable to all
1155 #define MSG_INIT 3 // write to the init string
1156 #define MSG_ENTITY 5
1158 sizebuf_t *WriteDest (void)
1164 dest = (int)PRVM_G_FLOAT(OFS_PARM0);
1168 return &sv.datagram;
1171 ent = PRVM_PROG_TO_EDICT(prog->globals.server->msg_entity);
1172 entnum = PRVM_NUM_FOR_EDICT(ent);
1173 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active || !svs.clients[entnum-1].netconnection)
1175 VM_Warning ("WriteDest: tried to write to non-client\n");
1176 return &sv.reliable_datagram;
1179 return &svs.clients[entnum-1].netconnection->message;
1182 VM_Warning ("WriteDest: bad destination\n");
1184 return &sv.reliable_datagram;
1190 return sv.writeentitiestoclient_msg;
1196 static void VM_SV_WriteByte (void)
1198 VM_SAFEPARMCOUNT(2, VM_SV_WriteByte);
1199 MSG_WriteByte (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1202 static void VM_SV_WriteChar (void)
1204 VM_SAFEPARMCOUNT(2, VM_SV_WriteChar);
1205 MSG_WriteChar (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1208 static void VM_SV_WriteShort (void)
1210 VM_SAFEPARMCOUNT(2, VM_SV_WriteShort);
1211 MSG_WriteShort (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1214 static void VM_SV_WriteLong (void)
1216 VM_SAFEPARMCOUNT(2, VM_SV_WriteLong);
1217 MSG_WriteLong (WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM1));
1220 static void VM_SV_WriteAngle (void)
1222 VM_SAFEPARMCOUNT(2, VM_SV_WriteAngle);
1223 MSG_WriteAngle (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1226 static void VM_SV_WriteCoord (void)
1228 VM_SAFEPARMCOUNT(2, VM_SV_WriteCoord);
1229 MSG_WriteCoord (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
1232 static void VM_SV_WriteString (void)
1234 VM_SAFEPARMCOUNT(2, VM_SV_WriteString);
1235 MSG_WriteString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
1238 static void VM_SV_WriteUnterminatedString (void)
1240 VM_SAFEPARMCOUNT(2, VM_SV_WriteUnterminatedString);
1241 MSG_WriteUnterminatedString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
1245 static void VM_SV_WriteEntity (void)
1247 VM_SAFEPARMCOUNT(2, VM_SV_WriteEntity);
1248 MSG_WriteShort (WriteDest(), PRVM_G_EDICTNUM(OFS_PARM1));
1251 //////////////////////////////////////////////////////////
1253 static void VM_SV_makestatic (void)
1258 // allow 0 parameters due to an id1 qc bug in which this function is used
1259 // with no parameters (but directly after setmodel with self in OFS_PARM0)
1260 VM_SAFEPARMCOUNTRANGE(0, 1, VM_SV_makestatic);
1262 if (prog->argc >= 1)
1263 ent = PRVM_G_EDICT(OFS_PARM0);
1265 ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
1266 if (ent == prog->edicts)
1268 VM_Warning("makestatic: can not modify world entity\n");
1271 if (ent->priv.server->free)
1273 VM_Warning("makestatic: can not modify free entity\n");
1278 if (ent->fields.server->modelindex >= 256 || ent->fields.server->frame >= 256)
1283 MSG_WriteByte (&sv.signon,svc_spawnstatic2);
1284 MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
1285 MSG_WriteShort (&sv.signon, (int)ent->fields.server->frame);
1287 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1289 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1290 MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
1291 MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
1295 MSG_WriteByte (&sv.signon,svc_spawnstatic);
1296 MSG_WriteByte (&sv.signon, (int)ent->fields.server->modelindex);
1297 MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
1300 MSG_WriteByte (&sv.signon, (int)ent->fields.server->colormap);
1301 MSG_WriteByte (&sv.signon, (int)ent->fields.server->skin);
1302 for (i=0 ; i<3 ; i++)
1304 MSG_WriteCoord(&sv.signon, ent->fields.server->origin[i], sv.protocol);
1305 MSG_WriteAngle(&sv.signon, ent->fields.server->angles[i], sv.protocol);
1308 // throw the entity away now
1312 //=============================================================================
1319 static void VM_SV_setspawnparms (void)
1325 VM_SAFEPARMCOUNT(1, VM_SV_setspawnparms);
1327 ent = PRVM_G_EDICT(OFS_PARM0);
1328 i = PRVM_NUM_FOR_EDICT(ent);
1329 if (i < 1 || i > svs.maxclients || !svs.clients[i-1].active)
1331 Con_Print("tried to setspawnparms on a non-client\n");
1335 // copy spawn parms out of the client_t
1336 client = svs.clients + i-1;
1337 for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1338 (&prog->globals.server->parm1)[i] = client->spawn_parms[i];
1345 Returns a color vector indicating the lighting at the requested point.
1347 (Internal Operation note: actually measures the light beneath the point, just like
1348 the model lighting on the client)
1353 static void VM_SV_getlight (void)
1355 vec3_t ambientcolor, diffusecolor, diffusenormal;
1357 VM_SAFEPARMCOUNT(1, VM_SV_getlight);
1358 p = PRVM_G_VECTOR(OFS_PARM0);
1359 VectorClear(ambientcolor);
1360 VectorClear(diffusecolor);
1361 VectorClear(diffusenormal);
1362 if (sv.worldmodel && sv.worldmodel->brush.LightPoint)
1363 sv.worldmodel->brush.LightPoint(sv.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
1364 VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
1369 unsigned char type; // 1/2/8 or other value if isn't used
1373 static customstat_t *vm_customstats = NULL; //[515]: it starts from 0, not 32
1374 static int vm_customstats_last;
1376 void VM_CustomStats_Clear (void)
1380 Z_Free(vm_customstats);
1381 vm_customstats = NULL;
1382 vm_customstats_last = -1;
1386 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1394 for(i=0; i<vm_customstats_last+1 ;i++)
1396 if(!vm_customstats[i].type)
1398 switch(vm_customstats[i].type)
1400 //string as 16 bytes
1403 strlcpy(s, PRVM_E_STRING(ent, vm_customstats[i].fieldoffset), 16);
1404 stats[i+32] = s[ 0] + s[ 1] * 256 + s[ 2] * 65536 + s[ 3] * 16777216;
1405 stats[i+33] = s[ 4] + s[ 5] * 256 + s[ 6] * 65536 + s[ 7] * 16777216;
1406 stats[i+34] = s[ 8] + s[ 9] * 256 + s[10] * 65536 + s[11] * 16777216;
1407 stats[i+35] = s[12] + s[13] * 256 + s[14] * 65536 + s[15] * 16777216;
1409 //float field sent as-is
1411 stats[i+32] = PRVM_E_INT(ent, vm_customstats[i].fieldoffset);
1413 //integer value of float field
1415 stats[i+32] = (int)PRVM_E_FLOAT(ent, vm_customstats[i].fieldoffset);
1423 // void(float index, float type, .void field) SV_AddStat = #232;
1424 // Set up an auto-sent player stat.
1425 // Client's get thier own fields sent to them. Index may not be less than 32.
1426 // Type is a value equating to the ev_ values found in qcc to dictate types. Valid ones are:
1427 // 1: string (4 stats carrying a total of 16 charactures)
1428 // 2: float (one stat, float converted to an integer for transportation)
1429 // 8: integer (one stat, not converted to an int, so this can be used to transport floats as floats - what a unique idea!)
1430 static void VM_SV_AddStat (void)
1435 VM_SAFEPARMCOUNT(3, VM_SV_AddStat);
1439 vm_customstats = (customstat_t *)Z_Malloc((MAX_CL_STATS-32) * sizeof(customstat_t));
1442 VM_Warning("PF_SV_AddStat: not enough memory\n");
1446 i = (int)PRVM_G_FLOAT(OFS_PARM0);
1447 type = (int)PRVM_G_FLOAT(OFS_PARM1);
1448 off = PRVM_G_INT (OFS_PARM2);
1453 VM_Warning("PF_SV_AddStat: index may not be less than 32\n");
1456 if(i >= (MAX_CL_STATS-32))
1458 VM_Warning("PF_SV_AddStat: index >= MAX_CL_STATS\n");
1461 if(i > (MAX_CL_STATS-32-4) && type == 1)
1463 VM_Warning("PF_SV_AddStat: index > (MAX_CL_STATS-4) with string\n");
1466 vm_customstats[i].type = type;
1467 vm_customstats[i].fieldoffset = off;
1468 if(vm_customstats_last < i)
1469 vm_customstats_last = i;
1476 copies data from one entity to another
1478 copyentity(src, dst)
1481 static void VM_SV_copyentity (void)
1483 prvm_edict_t *in, *out;
1484 VM_SAFEPARMCOUNT(2, VM_SV_copyentity);
1485 in = PRVM_G_EDICT(OFS_PARM0);
1486 if (in == prog->edicts)
1488 VM_Warning("copyentity: can not read world entity\n");
1491 if (in->priv.server->free)
1493 VM_Warning("copyentity: can not read free entity\n");
1496 out = PRVM_G_EDICT(OFS_PARM1);
1497 if (out == prog->edicts)
1499 VM_Warning("copyentity: can not modify world entity\n");
1502 if (out->priv.server->free)
1504 VM_Warning("copyentity: can not modify free entity\n");
1507 memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
1508 SV_LinkEdict(out, false);
1516 sets the color of a client and broadcasts the update to all connected clients
1518 setcolor(clientent, value)
1521 static void VM_SV_setcolor (void)
1527 VM_SAFEPARMCOUNT(2, VM_SV_setcolor);
1528 entnum = PRVM_G_EDICTNUM(OFS_PARM0);
1529 i = (int)PRVM_G_FLOAT(OFS_PARM1);
1531 if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
1533 Con_Print("tried to setcolor a non-client\n");
1537 client = svs.clients + entnum-1;
1540 if ((val = PRVM_EDICTFIELDVALUE(client->edict, prog->fieldoffsets.clientcolors)))
1542 client->edict->fields.server->team = (i & 15) + 1;
1545 if (client->old_colors != client->colors)
1547 client->old_colors = client->colors;
1548 // send notification to all clients
1549 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1550 MSG_WriteByte (&sv.reliable_datagram, client - svs.clients);
1551 MSG_WriteByte (&sv.reliable_datagram, client->colors);
1559 effect(origin, modelname, startframe, framecount, framerate)
1562 static void VM_SV_effect (void)
1566 VM_SAFEPARMCOUNT(5, VM_SV_effect);
1567 s = PRVM_G_STRING(OFS_PARM1);
1570 VM_Warning("effect: no model specified\n");
1574 i = SV_ModelIndex(s, 1);
1577 VM_Warning("effect: model not precached\n");
1581 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1583 VM_Warning("effect: framecount < 1\n");
1587 if (PRVM_G_FLOAT(OFS_PARM4) < 1)
1589 VM_Warning("effect: framerate < 1\n");
1593 SV_StartEffect(PRVM_G_VECTOR(OFS_PARM0), i, (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4));
1596 static void VM_SV_te_blood (void)
1598 VM_SAFEPARMCOUNT(3, VM_SV_te_blood);
1599 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1601 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1602 MSG_WriteByte(&sv.datagram, TE_BLOOD);
1604 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1605 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1606 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1608 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1609 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1610 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1612 MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1613 SV_FlushBroadcastMessages();
1616 static void VM_SV_te_bloodshower (void)
1618 VM_SAFEPARMCOUNT(4, VM_SV_te_bloodshower);
1619 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1621 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1622 MSG_WriteByte(&sv.datagram, TE_BLOODSHOWER);
1624 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1625 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1626 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1628 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1629 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1630 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1632 MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM2), sv.protocol);
1634 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1635 SV_FlushBroadcastMessages();
1638 static void VM_SV_te_explosionrgb (void)
1640 VM_SAFEPARMCOUNT(2, VM_SV_te_explosionrgb);
1641 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1642 MSG_WriteByte(&sv.datagram, TE_EXPLOSIONRGB);
1644 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1645 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1646 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1648 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[0] * 255), 255));
1649 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[1] * 255), 255));
1650 MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[2] * 255), 255));
1651 SV_FlushBroadcastMessages();
1654 static void VM_SV_te_particlecube (void)
1656 VM_SAFEPARMCOUNT(7, VM_SV_te_particlecube);
1657 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1659 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1660 MSG_WriteByte(&sv.datagram, TE_PARTICLECUBE);
1662 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1663 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1664 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1666 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1667 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1668 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1670 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1671 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1672 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1674 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1676 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1677 // gravity true/false
1678 MSG_WriteByte(&sv.datagram, ((int) PRVM_G_FLOAT(OFS_PARM5)) != 0);
1680 MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM6), sv.protocol);
1681 SV_FlushBroadcastMessages();
1684 static void VM_SV_te_particlerain (void)
1686 VM_SAFEPARMCOUNT(5, VM_SV_te_particlerain);
1687 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1689 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1690 MSG_WriteByte(&sv.datagram, TE_PARTICLERAIN);
1692 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1693 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1694 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1696 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1697 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1698 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1700 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1701 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1702 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1704 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1706 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1707 SV_FlushBroadcastMessages();
1710 static void VM_SV_te_particlesnow (void)
1712 VM_SAFEPARMCOUNT(5, VM_SV_te_particlesnow);
1713 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1715 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1716 MSG_WriteByte(&sv.datagram, TE_PARTICLESNOW);
1718 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1719 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1720 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1722 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1723 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1724 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1726 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1727 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1728 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1730 MSG_WriteShort(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
1732 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM4));
1733 SV_FlushBroadcastMessages();
1736 static void VM_SV_te_spark (void)
1738 VM_SAFEPARMCOUNT(3, VM_SV_te_spark);
1739 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1741 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1742 MSG_WriteByte(&sv.datagram, TE_SPARK);
1744 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1745 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1746 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1748 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
1749 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
1750 MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
1752 MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
1753 SV_FlushBroadcastMessages();
1756 static void VM_SV_te_gunshotquad (void)
1758 VM_SAFEPARMCOUNT(1, VM_SV_te_gunshotquad);
1759 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1760 MSG_WriteByte(&sv.datagram, TE_GUNSHOTQUAD);
1762 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1763 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1764 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1765 SV_FlushBroadcastMessages();
1768 static void VM_SV_te_spikequad (void)
1770 VM_SAFEPARMCOUNT(1, VM_SV_te_spikequad);
1771 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1772 MSG_WriteByte(&sv.datagram, TE_SPIKEQUAD);
1774 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1775 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1776 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1777 SV_FlushBroadcastMessages();
1780 static void VM_SV_te_superspikequad (void)
1782 VM_SAFEPARMCOUNT(1, VM_SV_te_superspikequad);
1783 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1784 MSG_WriteByte(&sv.datagram, TE_SUPERSPIKEQUAD);
1786 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1787 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1788 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1789 SV_FlushBroadcastMessages();
1792 static void VM_SV_te_explosionquad (void)
1794 VM_SAFEPARMCOUNT(1, VM_SV_te_explosionquad);
1795 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1796 MSG_WriteByte(&sv.datagram, TE_EXPLOSIONQUAD);
1798 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1799 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1800 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1801 SV_FlushBroadcastMessages();
1804 static void VM_SV_te_smallflash (void)
1806 VM_SAFEPARMCOUNT(1, VM_SV_te_smallflash);
1807 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1808 MSG_WriteByte(&sv.datagram, TE_SMALLFLASH);
1810 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1811 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1812 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1813 SV_FlushBroadcastMessages();
1816 static void VM_SV_te_customflash (void)
1818 VM_SAFEPARMCOUNT(4, VM_SV_te_customflash);
1819 if (PRVM_G_FLOAT(OFS_PARM1) < 8 || PRVM_G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
1821 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1822 MSG_WriteByte(&sv.datagram, TE_CUSTOMFLASH);
1824 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1825 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1826 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1828 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM1) / 8 - 1, 255));
1830 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_FLOAT(OFS_PARM2) * 256 - 1, 255));
1832 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[0] * 255, 255));
1833 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[1] * 255, 255));
1834 MSG_WriteByte(&sv.datagram, (int)bound(0, PRVM_G_VECTOR(OFS_PARM3)[2] * 255, 255));
1835 SV_FlushBroadcastMessages();
1838 static void VM_SV_te_gunshot (void)
1840 VM_SAFEPARMCOUNT(1, VM_SV_te_gunshot);
1841 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1842 MSG_WriteByte(&sv.datagram, TE_GUNSHOT);
1844 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1845 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1846 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1847 SV_FlushBroadcastMessages();
1850 static void VM_SV_te_spike (void)
1852 VM_SAFEPARMCOUNT(1, VM_SV_te_spike);
1853 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1854 MSG_WriteByte(&sv.datagram, TE_SPIKE);
1856 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1857 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1858 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1859 SV_FlushBroadcastMessages();
1862 static void VM_SV_te_superspike (void)
1864 VM_SAFEPARMCOUNT(1, VM_SV_te_superspike);
1865 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1866 MSG_WriteByte(&sv.datagram, TE_SUPERSPIKE);
1868 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1869 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1870 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1871 SV_FlushBroadcastMessages();
1874 static void VM_SV_te_explosion (void)
1876 VM_SAFEPARMCOUNT(1, VM_SV_te_explosion);
1877 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1878 MSG_WriteByte(&sv.datagram, TE_EXPLOSION);
1880 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1881 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1882 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1883 SV_FlushBroadcastMessages();
1886 static void VM_SV_te_tarexplosion (void)
1888 VM_SAFEPARMCOUNT(1, VM_SV_te_tarexplosion);
1889 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1890 MSG_WriteByte(&sv.datagram, TE_TAREXPLOSION);
1892 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1893 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1894 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1895 SV_FlushBroadcastMessages();
1898 static void VM_SV_te_wizspike (void)
1900 VM_SAFEPARMCOUNT(1, VM_SV_te_wizspike);
1901 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1902 MSG_WriteByte(&sv.datagram, TE_WIZSPIKE);
1904 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1905 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1906 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1907 SV_FlushBroadcastMessages();
1910 static void VM_SV_te_knightspike (void)
1912 VM_SAFEPARMCOUNT(1, VM_SV_te_knightspike);
1913 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1914 MSG_WriteByte(&sv.datagram, TE_KNIGHTSPIKE);
1916 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1917 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1918 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1919 SV_FlushBroadcastMessages();
1922 static void VM_SV_te_lavasplash (void)
1924 VM_SAFEPARMCOUNT(1, VM_SV_te_lavasplash);
1925 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1926 MSG_WriteByte(&sv.datagram, TE_LAVASPLASH);
1928 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1929 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1930 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1931 SV_FlushBroadcastMessages();
1934 static void VM_SV_te_teleport (void)
1936 VM_SAFEPARMCOUNT(1, VM_SV_te_teleport);
1937 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1938 MSG_WriteByte(&sv.datagram, TE_TELEPORT);
1940 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1941 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1942 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1943 SV_FlushBroadcastMessages();
1946 static void VM_SV_te_explosion2 (void)
1948 VM_SAFEPARMCOUNT(3, VM_SV_te_explosion2);
1949 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1950 MSG_WriteByte(&sv.datagram, TE_EXPLOSION2);
1952 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
1953 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
1954 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
1956 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
1957 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
1958 SV_FlushBroadcastMessages();
1961 static void VM_SV_te_lightning1 (void)
1963 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning1);
1964 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1965 MSG_WriteByte(&sv.datagram, TE_LIGHTNING1);
1967 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
1969 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1970 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1971 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1973 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1974 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1975 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1976 SV_FlushBroadcastMessages();
1979 static void VM_SV_te_lightning2 (void)
1981 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning2);
1982 MSG_WriteByte(&sv.datagram, svc_temp_entity);
1983 MSG_WriteByte(&sv.datagram, TE_LIGHTNING2);
1985 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
1987 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
1988 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
1989 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
1991 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
1992 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
1993 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
1994 SV_FlushBroadcastMessages();
1997 static void VM_SV_te_lightning3 (void)
1999 VM_SAFEPARMCOUNT(3, VM_SV_te_lightning3);
2000 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2001 MSG_WriteByte(&sv.datagram, TE_LIGHTNING3);
2003 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2005 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2006 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2007 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2009 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2010 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2011 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2012 SV_FlushBroadcastMessages();
2015 static void VM_SV_te_beam (void)
2017 VM_SAFEPARMCOUNT(3, VM_SV_te_beam);
2018 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2019 MSG_WriteByte(&sv.datagram, TE_BEAM);
2021 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2023 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2024 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2025 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2027 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
2028 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
2029 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
2030 SV_FlushBroadcastMessages();
2033 static void VM_SV_te_plasmaburn (void)
2035 VM_SAFEPARMCOUNT(1, VM_SV_te_plasmaburn);
2036 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2037 MSG_WriteByte(&sv.datagram, TE_PLASMABURN);
2038 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2039 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2040 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2041 SV_FlushBroadcastMessages();
2044 static void VM_SV_te_flamejet (void)
2046 VM_SAFEPARMCOUNT(3, VM_SV_te_flamejet);
2047 MSG_WriteByte(&sv.datagram, svc_temp_entity);
2048 MSG_WriteByte(&sv.datagram, TE_FLAMEJET);
2050 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
2051 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
2052 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
2054 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
2055 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
2056 MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
2058 MSG_WriteByte(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM2));
2059 SV_FlushBroadcastMessages();
2062 void clippointtosurface(model_t *model, msurface_t *surface, vec3_t p, vec3_t out)
2065 float *v[3], facenormal[3], edgenormal[3], sidenormal[3], temp[3], offsetdist, dist, bestdist;
2067 bestdist = 1000000000;
2069 for (i = 0, e = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);i < surface->num_triangles;i++, e += 3)
2071 // clip original point to each triangle of the surface and find the
2072 // triangle that is closest
2073 v[0] = model->surfmesh.data_vertex3f + e[0] * 3;
2074 v[1] = model->surfmesh.data_vertex3f + e[1] * 3;
2075 v[2] = model->surfmesh.data_vertex3f + e[2] * 3;
2076 TriangleNormal(v[0], v[1], v[2], facenormal);
2077 VectorNormalize(facenormal);
2078 offsetdist = DotProduct(v[0], facenormal) - DotProduct(p, facenormal);
2079 VectorMA(p, offsetdist, facenormal, temp);
2080 for (j = 0, k = 2;j < 3;k = j, j++)
2082 VectorSubtract(v[k], v[j], edgenormal);
2083 CrossProduct(edgenormal, facenormal, sidenormal);
2084 VectorNormalize(sidenormal);
2085 offsetdist = DotProduct(v[k], sidenormal) - DotProduct(temp, sidenormal);
2087 VectorMA(temp, offsetdist, sidenormal, temp);
2089 dist = VectorDistance2(temp, p);
2090 if (bestdist > dist)
2093 VectorCopy(temp, out);
2098 static model_t *getmodel(prvm_edict_t *ed)
2101 if (!ed || ed->priv.server->free)
2103 modelindex = (int)ed->fields.server->modelindex;
2104 if (modelindex < 1 || modelindex >= MAX_MODELS)
2106 return sv.models[modelindex];
2109 static msurface_t *getsurface(model_t *model, int surfacenum)
2111 if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
2113 return model->data_surfaces + surfacenum + model->firstmodelsurface;
2117 //PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434;
2118 static void VM_SV_getsurfacenumpoints(void)
2121 msurface_t *surface;
2122 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenumpoints);
2123 // return 0 if no such surface
2124 if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2126 PRVM_G_FLOAT(OFS_RETURN) = 0;
2130 // note: this (incorrectly) assumes it is a simple polygon
2131 PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
2133 //PF_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint = #435;
2134 static void VM_SV_getsurfacepoint(void)
2138 msurface_t *surface;
2140 VM_SAFEPARMCOUNT(3, VM_SV_getsurfacepoint);
2141 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2142 ed = PRVM_G_EDICT(OFS_PARM0);
2143 if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2145 // note: this (incorrectly) assumes it is a simple polygon
2146 pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
2147 if (pointnum < 0 || pointnum >= surface->num_vertices)
2149 // FIXME: implement rotation/scaling
2150 VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2152 //PF_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal = #436;
2153 static void VM_SV_getsurfacenormal(void)
2156 msurface_t *surface;
2158 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenormal);
2159 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2160 if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2162 // FIXME: implement rotation/scaling
2163 // note: this (incorrectly) assumes it is a simple polygon
2164 // note: this only returns the first triangle, so it doesn't work very
2165 // well for curved surfaces or arbitrary meshes
2166 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);
2167 VectorNormalize(normal);
2168 VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
2170 //PF_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture = #437;
2171 static void VM_SV_getsurfacetexture(void)
2174 msurface_t *surface;
2175 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacetexture);
2176 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2177 if (!(model = getmodel(PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2179 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
2181 //PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438;
2182 static void VM_SV_getsurfacenearpoint(void)
2184 int surfacenum, best;
2186 vec_t dist, bestdist;
2189 msurface_t *surface;
2191 VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenearpoint);
2192 PRVM_G_FLOAT(OFS_RETURN) = -1;
2193 ed = PRVM_G_EDICT(OFS_PARM0);
2194 point = PRVM_G_VECTOR(OFS_PARM1);
2196 if (!ed || ed->priv.server->free)
2198 model = getmodel(ed);
2199 if (!model || !model->num_surfaces)
2202 // FIXME: implement rotation/scaling
2203 VectorSubtract(point, ed->fields.server->origin, p);
2205 bestdist = 1000000000;
2206 for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
2208 surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
2209 // first see if the nearest point on the surface's box is closer than the previous match
2210 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
2211 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
2212 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
2213 dist = VectorLength2(clipped);
2214 if (dist < bestdist)
2216 // it is, check the nearest point on the actual geometry
2217 clippointtosurface(model, surface, p, clipped);
2218 VectorSubtract(clipped, p, clipped);
2219 dist += VectorLength2(clipped);
2220 if (dist < bestdist)
2222 // that's closer too, store it as the best match
2228 PRVM_G_FLOAT(OFS_RETURN) = best;
2230 //PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439;
2231 static void VM_SV_getsurfaceclippedpoint(void)
2235 msurface_t *surface;
2237 VM_SAFEPARMCOUNT(3, VM_SV_te_getsurfaceclippedpoint);
2238 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2239 ed = PRVM_G_EDICT(OFS_PARM0);
2240 if (!(model = getmodel(ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2242 // FIXME: implement rotation/scaling
2243 VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.server->origin, p);
2244 clippointtosurface(model, surface, p, out);
2245 // FIXME: implement rotation/scaling
2246 VectorAdd(out, ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
2249 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2250 //this function originally written by KrimZon, made shorter by LordHavoc
2251 static void VM_SV_clientcommand (void)
2253 client_t *temp_client;
2255 VM_SAFEPARMCOUNT(2, VM_SV_clientcommand);
2257 //find client for this entity
2258 i = (PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0)) - 1);
2259 if (i < 0 || i >= svs.maxclients || !svs.clients[i].active)
2261 Con_Print("PF_clientcommand: entity is not a client\n");
2265 temp_client = host_client;
2266 host_client = svs.clients + i;
2267 Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client);
2268 host_client = temp_client;
2271 //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)
2272 static void VM_SV_setattachment (void)
2274 prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
2275 prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
2276 const char *tagname = PRVM_G_STRING(OFS_PARM2);
2280 VM_SAFEPARMCOUNT(3, VM_SV_setattachment);
2282 if (e == prog->edicts)
2284 VM_Warning("setattachment: can not modify world entity\n");
2287 if (e->priv.server->free)
2289 VM_Warning("setattachment: can not modify free entity\n");
2293 if (tagentity == NULL)
2294 tagentity = prog->edicts;
2296 v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_entity);
2298 v->edict = PRVM_EDICT_TO_PROG(tagentity);
2300 v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_index);
2303 if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2305 modelindex = (int)tagentity->fields.server->modelindex;
2306 if (modelindex >= 0 && modelindex < MAX_MODELS && (model = sv.models[modelindex]))
2308 v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.server->skin, tagname);
2310 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);
2313 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));
2317 /////////////////////////////////////////
2318 // DP_MD3_TAGINFO extension coded by VorteX
2320 int SV_GetTagIndex (prvm_edict_t *e, const char *tagname)
2325 i = (int)e->fields.server->modelindex;
2326 if (i < 1 || i >= MAX_MODELS)
2328 model = sv.models[i];
2330 return Mod_Alias_GetTagIndexForName(model, (int)e->fields.server->skin, tagname);
2333 void SV_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2335 float scale = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float;
2339 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);
2341 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);
2344 int SV_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2350 && (modelindex = (int)ent->fields.server->modelindex) >= 1 && modelindex < MAX_MODELS
2351 && (model = sv.models[(int)ent->fields.server->modelindex])
2352 && model->animscenes)
2354 // if model has wrong frame, engine automatically switches to model first frame
2355 frame = (int)ent->fields.server->frame;
2356 if (frame < 0 || frame >= model->numframes)
2358 return Mod_Alias_GetTagMatrix(model, model->animscenes[frame].firstframe, tagindex, out);
2360 *out = identitymatrix;
2364 // Warnings/errors code:
2365 // 0 - normal (everything all-right)
2368 // 3 - null or non-precached model
2369 // 4 - no tags with requested index
2370 // 5 - runaway loop at attachment chain
2371 extern cvar_t cl_bob;
2372 extern cvar_t cl_bobcycle;
2373 extern cvar_t cl_bobup;
2374 int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
2378 int modelindex, attachloop;
2379 matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2382 *out = identitymatrix; // warnings and errors return identical matrix
2384 if (ent == prog->edicts)
2386 if (ent->priv.server->free)
2389 modelindex = (int)ent->fields.server->modelindex;
2390 if (modelindex <= 0 || modelindex > MAX_MODELS)
2393 model = sv.models[modelindex];
2395 tagmatrix = identitymatrix;
2396 // DP_GFX_QUAKE3MODELTAGS, scan all chain and stop on unattached entity
2400 if (attachloop >= 256) // prevent runaway looping
2402 // apply transformation by child's tagindex on parent entity and then
2403 // by parent entity itself
2404 ret = SV_GetEntityLocalTagMatrix(ent, tagindex - 1, &attachmatrix);
2405 if (ret && attachloop == 0)
2407 Matrix4x4_Concat(out, &attachmatrix, &tagmatrix);
2408 SV_GetEntityMatrix(ent, &entitymatrix, false);
2409 Matrix4x4_Concat(&tagmatrix, &entitymatrix, out);
2410 // next iteration we process the parent entity
2411 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)) && val->edict)
2413 tagindex = (int)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
2414 ent = PRVM_EDICT_NUM(val->edict);
2421 // RENDER_VIEWMODEL magic
2422 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)) && val->edict)
2424 Matrix4x4_Copy(&tagmatrix, out);
2425 ent = PRVM_EDICT_NUM(val->edict);
2427 SV_GetEntityMatrix(ent, &entitymatrix, true);
2428 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2431 // Cl_bob, ported from rendering code
2432 if (ent->fields.server->health > 0 && cl_bob.value && cl_bobcycle.value)
2435 // LordHavoc: this code is *weird*, but not replacable (I think it
2436 // should be done in QC on the server, but oh well, quake is quake)
2437 // LordHavoc: figured out bobup: the time at which the sin is at 180
2438 // degrees (which allows lengthening or squishing the peak or valley)
2439 cycle = sv.time/cl_bobcycle.value;
2440 cycle -= (int)cycle;
2441 if (cycle < cl_bobup.value)
2442 cycle = sin(M_PI * cycle / cl_bobup.value);
2444 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2445 // bob is proportional to velocity in the xy plane
2446 // (don't count Z, or jumping messes it up)
2447 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;
2448 bob = bob*0.3 + bob*0.7*cycle;
2449 Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2456 //float(entity ent, string tagname) gettagindex;
2458 static void VM_SV_gettagindex (void)
2461 const char *tag_name;
2462 int modelindex, tag_index;
2464 VM_SAFEPARMCOUNT(2, VM_SV_gettagindex);
2466 ent = PRVM_G_EDICT(OFS_PARM0);
2467 tag_name = PRVM_G_STRING(OFS_PARM1);
2469 if (ent == prog->edicts)
2471 VM_Warning("gettagindex: can't affect world entity\n");
2474 if (ent->priv.server->free)
2476 VM_Warning("gettagindex: can't affect free entity\n");
2480 modelindex = (int)ent->fields.server->modelindex;
2482 if (modelindex <= 0 || modelindex > MAX_MODELS)
2483 Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2486 tag_index = SV_GetTagIndex(ent, tag_name);
2488 Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2490 PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2493 //vector(entity ent, float tagindex) gettaginfo;
2494 static void VM_SV_gettaginfo (void)
2498 matrix4x4_t tag_matrix;
2501 VM_SAFEPARMCOUNT(2, VM_SV_gettaginfo);
2503 e = PRVM_G_EDICT(OFS_PARM0);
2504 tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2506 returncode = SV_GetTagMatrix(&tag_matrix, e, tagindex);
2507 Matrix4x4_ToVectors(&tag_matrix, prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up, PRVM_G_VECTOR(OFS_RETURN));
2512 VM_Warning("gettagindex: can't affect world entity\n");
2515 VM_Warning("gettagindex: can't affect free entity\n");
2518 Con_DPrintf("SV_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2521 Con_DPrintf("SV_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2524 Con_DPrintf("SV_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2529 //void(entity clent) dropclient (DP_SV_DROPCLIENT)
2530 static void VM_SV_dropclient (void)
2533 client_t *oldhostclient;
2534 VM_SAFEPARMCOUNT(1, VM_SV_dropclient);
2535 clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2536 if (clientnum < 0 || clientnum >= svs.maxclients)
2538 VM_Warning("dropclient: not a client\n");
2541 if (!svs.clients[clientnum].active)
2543 VM_Warning("dropclient: that client slot is not connected\n");
2546 oldhostclient = host_client;
2547 host_client = svs.clients + clientnum;
2548 SV_DropClient(false);
2549 host_client = oldhostclient;
2552 //entity() spawnclient (DP_SV_BOTCLIENT)
2553 static void VM_SV_spawnclient (void)
2557 VM_SAFEPARMCOUNT(0, VM_SV_spawnclient);
2558 prog->xfunction->builtinsprofile += 2;
2560 for (i = 0;i < svs.maxclients;i++)
2562 if (!svs.clients[i].active)
2564 prog->xfunction->builtinsprofile += 100;
2565 SV_ConnectClient (i, NULL);
2566 // this has to be set or else ClientDisconnect won't be called
2567 // we assume the qc will call ClientConnect...
2568 svs.clients[i].clientconnectcalled = true;
2569 ed = PRVM_EDICT_NUM(i + 1);
2573 VM_RETURN_EDICT(ed);
2576 //float(entity clent) clienttype (DP_SV_BOTCLIENT)
2577 static void VM_SV_clienttype (void)
2580 VM_SAFEPARMCOUNT(1, VM_SV_clienttype);
2581 clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
2582 if (clientnum < 0 || clientnum >= svs.maxclients)
2583 PRVM_G_FLOAT(OFS_RETURN) = 3;
2584 else if (!svs.clients[clientnum].active)
2585 PRVM_G_FLOAT(OFS_RETURN) = 0;
2586 else if (svs.clients[clientnum].netconnection)
2587 PRVM_G_FLOAT(OFS_RETURN) = 1;
2589 PRVM_G_FLOAT(OFS_RETURN) = 2;
2596 string(string key) serverkey
2599 void VM_SV_serverkey(void)
2601 char string[VM_STRINGTEMP_LENGTH];
2602 VM_SAFEPARMCOUNT(1, VM_SV_serverkey);
2603 InfoString_GetValue(svs.serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
2604 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
2607 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
2608 static void VM_SV_setmodelindex (void)
2613 VM_SAFEPARMCOUNT(2, VM_SV_setmodelindex);
2615 e = PRVM_G_EDICT(OFS_PARM0);
2616 if (e == prog->edicts)
2618 VM_Warning("setmodelindex: can not modify world entity\n");
2621 if (e->priv.server->free)
2623 VM_Warning("setmodelindex: can not modify free entity\n");
2626 i = (int)PRVM_G_FLOAT(OFS_PARM1);
2627 if (i <= 0 || i > MAX_MODELS)
2629 VM_Warning("setmodelindex: invalid modelindex\n");
2632 if (!sv.model_precache[i][0])
2634 VM_Warning("setmodelindex: model not precached\n");
2638 e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
2639 e->fields.server->modelindex = i;
2645 if (mod->type != mod_alias || sv_gameplayfix_setmodelrealbox.integer)
2646 SetMinMaxSize (e, mod->normalmins, mod->normalmaxs, true);
2648 SetMinMaxSize (e, quakemins, quakemaxs, true);
2651 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
2654 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
2655 static void VM_SV_modelnameforindex (void)
2658 VM_SAFEPARMCOUNT(1, VM_SV_modelnameforindex);
2660 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2662 i = (int)PRVM_G_FLOAT(OFS_PARM0);
2663 if (i <= 0 || i > MAX_MODELS)
2665 VM_Warning("modelnameforindex: invalid modelindex\n");
2668 if (!sv.model_precache[i][0])
2670 VM_Warning("modelnameforindex: model not precached\n");
2674 PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(sv.model_precache[i]);
2677 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
2678 static void VM_SV_particleeffectnum (void)
2681 VM_SAFEPARMCOUNT(1, VM_SV_particleeffectnum);
2682 i = SV_ParticleEffectIndex(PRVM_G_STRING(OFS_PARM0));
2685 PRVM_G_FLOAT(OFS_RETURN) = i;
2688 // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
2689 static void VM_SV_trailparticles (void)
2691 VM_SAFEPARMCOUNT(4, VM_SV_trailparticles);
2693 MSG_WriteByte(&sv.datagram, svc_trailparticles);
2694 MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
2695 MSG_WriteShort(&sv.datagram, (int)PRVM_G_FLOAT(OFS_PARM1));
2696 MSG_WriteVector(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2), sv.protocol);
2697 MSG_WriteVector(&sv.datagram, PRVM_G_VECTOR(OFS_PARM3), sv.protocol);
2698 SV_FlushBroadcastMessages();
2701 //#337 void(float effectnum, vector origin, vector dir, float count) pointparticles (EXT_CSQC)
2702 static void VM_SV_pointparticles (void)
2704 int effectnum, count;
2706 VM_SAFEPARMCOUNTRANGE(4, 8, VM_SV_pointparticles);
2707 effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
2708 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), org);
2709 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
2710 count = bound(0, (int)PRVM_G_FLOAT(OFS_PARM3), 65535);
2711 if (count == 1 && !VectorLength2(vel))
2714 MSG_WriteByte(&sv.datagram, svc_pointparticles1);
2715 MSG_WriteShort(&sv.datagram, effectnum);
2716 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2720 // 1+2+12+12+2=29 bytes
2721 MSG_WriteByte(&sv.datagram, svc_pointparticles);
2722 MSG_WriteShort(&sv.datagram, effectnum);
2723 MSG_WriteVector(&sv.datagram, org, sv.protocol);
2724 MSG_WriteVector(&sv.datagram, vel, sv.protocol);
2725 MSG_WriteShort(&sv.datagram, count);
2728 SV_FlushBroadcastMessages();
2731 prvm_builtin_t vm_sv_builtins[] = {
2732 NULL, // #0 NULL function (not callable) (QUAKE)
2733 VM_makevectors, // #1 void(vector ang) makevectors (QUAKE)
2734 VM_SV_setorigin, // #2 void(entity e, vector o) setorigin (QUAKE)
2735 VM_SV_setmodel, // #3 void(entity e, string m) setmodel (QUAKE)
2736 VM_SV_setsize, // #4 void(entity e, vector min, vector max) setsize (QUAKE)
2737 NULL, // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
2738 VM_break, // #6 void() break (QUAKE)
2739 VM_random, // #7 float() random (QUAKE)
2740 VM_SV_sound, // #8 void(entity e, float chan, string samp) sound (QUAKE)
2741 VM_normalize, // #9 vector(vector v) normalize (QUAKE)
2742 VM_error, // #10 void(string e) error (QUAKE)
2743 VM_objerror, // #11 void(string e) objerror (QUAKE)
2744 VM_vlen, // #12 float(vector v) vlen (QUAKE)
2745 VM_vectoyaw, // #13 float(vector v) vectoyaw (QUAKE)
2746 VM_spawn, // #14 entity() spawn (QUAKE)
2747 VM_remove, // #15 void(entity e) remove (QUAKE)
2748 VM_SV_traceline, // #16 float(vector v1, vector v2, float tryents) traceline (QUAKE)
2749 VM_SV_checkclient, // #17 entity() checkclient (QUAKE)
2750 VM_find, // #18 entity(entity start, .string fld, string match) find (QUAKE)
2751 VM_SV_precache_sound, // #19 void(string s) precache_sound (QUAKE)
2752 VM_SV_precache_model, // #20 void(string s) precache_model (QUAKE)
2753 VM_SV_stuffcmd, // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
2754 VM_SV_findradius, // #22 entity(vector org, float rad) findradius (QUAKE)
2755 VM_bprint, // #23 void(string s, ...) bprint (QUAKE)
2756 VM_SV_sprint, // #24 void(entity client, string s, ...) sprint (QUAKE)
2757 VM_dprint, // #25 void(string s, ...) dprint (QUAKE)
2758 VM_ftos, // #26 string(float f) ftos (QUAKE)
2759 VM_vtos, // #27 string(vector v) vtos (QUAKE)
2760 VM_coredump, // #28 void() coredump (QUAKE)
2761 VM_traceon, // #29 void() traceon (QUAKE)
2762 VM_traceoff, // #30 void() traceoff (QUAKE)
2763 VM_eprint, // #31 void(entity e) eprint (QUAKE)
2764 VM_SV_walkmove, // #32 float(float yaw, float dist) walkmove (QUAKE)
2765 NULL, // #33 (QUAKE)
2766 VM_SV_droptofloor, // #34 float() droptofloor (QUAKE)
2767 VM_SV_lightstyle, // #35 void(float style, string value) lightstyle (QUAKE)
2768 VM_rint, // #36 float(float v) rint (QUAKE)
2769 VM_floor, // #37 float(float v) floor (QUAKE)
2770 VM_ceil, // #38 float(float v) ceil (QUAKE)
2771 NULL, // #39 (QUAKE)
2772 VM_SV_checkbottom, // #40 float(entity e) checkbottom (QUAKE)
2773 VM_SV_pointcontents, // #41 float(vector v) pointcontents (QUAKE)
2774 NULL, // #42 (QUAKE)
2775 VM_fabs, // #43 float(float f) fabs (QUAKE)
2776 VM_SV_aim, // #44 vector(entity e, float speed) aim (QUAKE)
2777 VM_cvar, // #45 float(string s) cvar (QUAKE)
2778 VM_localcmd, // #46 void(string s) localcmd (QUAKE)
2779 VM_nextent, // #47 entity(entity e) nextent (QUAKE)
2780 VM_SV_particle, // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
2781 VM_changeyaw, // #49 void() ChangeYaw (QUAKE)
2782 NULL, // #50 (QUAKE)
2783 VM_vectoangles, // #51 vector(vector v) vectoangles (QUAKE)
2784 VM_SV_WriteByte, // #52 void(float to, float f) WriteByte (QUAKE)
2785 VM_SV_WriteChar, // #53 void(float to, float f) WriteChar (QUAKE)
2786 VM_SV_WriteShort, // #54 void(float to, float f) WriteShort (QUAKE)
2787 VM_SV_WriteLong, // #55 void(float to, float f) WriteLong (QUAKE)
2788 VM_SV_WriteCoord, // #56 void(float to, float f) WriteCoord (QUAKE)
2789 VM_SV_WriteAngle, // #57 void(float to, float f) WriteAngle (QUAKE)
2790 VM_SV_WriteString, // #58 void(float to, string s) WriteString (QUAKE)
2791 VM_SV_WriteEntity, // #59 void(float to, entity e) WriteEntity (QUAKE)
2792 VM_sin, // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW) (QUAKE)
2793 VM_cos, // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW) (QUAKE)
2794 VM_sqrt, // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW) (QUAKE)
2795 VM_changepitch, // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH) (QUAKE)
2796 VM_SV_tracetoss, // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS) (QUAKE)
2797 VM_etos, // #65 string(entity ent) etos (DP_QC_ETOS) (QUAKE)
2798 NULL, // #66 (QUAKE)
2799 SV_MoveToGoal, // #67 void(float step) movetogoal (QUAKE)
2800 VM_precache_file, // #68 string(string s) precache_file (QUAKE)
2801 VM_SV_makestatic, // #69 void(entity e) makestatic (QUAKE)
2802 VM_changelevel, // #70 void(string s) changelevel (QUAKE)
2803 NULL, // #71 (QUAKE)
2804 VM_cvar_set, // #72 void(string var, string val) cvar_set (QUAKE)
2805 VM_SV_centerprint, // #73 void(entity client, strings) centerprint (QUAKE)
2806 VM_SV_ambientsound, // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
2807 VM_SV_precache_model, // #75 string(string s) precache_model2 (QUAKE)
2808 VM_SV_precache_sound, // #76 string(string s) precache_sound2 (QUAKE)
2809 VM_precache_file, // #77 string(string s) precache_file2 (QUAKE)
2810 VM_SV_setspawnparms, // #78 void(entity e) setspawnparms (QUAKE)
2811 NULL, // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
2812 NULL, // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
2813 VM_stof, // #81 float(string s) stof (FRIK_FILE)
2814 NULL, // #82 void(vector where, float set) multicast (QUAKEWORLD)
2815 NULL, // #83 (QUAKE)
2816 NULL, // #84 (QUAKE)
2817 NULL, // #85 (QUAKE)
2818 NULL, // #86 (QUAKE)
2819 NULL, // #87 (QUAKE)
2820 NULL, // #88 (QUAKE)
2821 NULL, // #89 (QUAKE)
2822 VM_SV_tracebox, // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
2823 VM_randomvec, // #91 vector() randomvec (DP_QC_RANDOMVEC)
2824 VM_SV_getlight, // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
2825 VM_registercvar, // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
2826 VM_min, // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
2827 VM_max, // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
2828 VM_bound, // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
2829 VM_pow, // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
2830 VM_findfloat, // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
2831 VM_checkextension, // #99 float(string s) checkextension (the basis of the extension system)
2832 // FrikaC and Telejano range #100-#199
2843 VM_fopen, // #110 float(string filename, float mode) fopen (FRIK_FILE)
2844 VM_fclose, // #111 void(float fhandle) fclose (FRIK_FILE)
2845 VM_fgets, // #112 string(float fhandle) fgets (FRIK_FILE)
2846 VM_fputs, // #113 void(float fhandle, string s) fputs (FRIK_FILE)
2847 VM_strlen, // #114 float(string s) strlen (FRIK_FILE)
2848 VM_strcat, // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
2849 VM_substring, // #116 string(string s, float start, float length) substring (FRIK_FILE)
2850 VM_stov, // #117 vector(string) stov (FRIK_FILE)
2851 VM_strzone, // #118 string(string s) strzone (FRIK_FILE)
2852 VM_strunzone, // #119 void(string s) strunzone (FRIK_FILE)
2933 // FTEQW range #200-#299
2952 VM_bitshift, // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
2955 VM_strstrofs, // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
2956 VM_str2chr, // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
2957 VM_chr2str, // #223 string(float c, ...) chr2str (FTE_STRINGS)
2958 VM_strconv, // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
2959 VM_strpad, // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
2960 VM_infoadd, // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
2961 VM_infoget, // #227 string(string info, string key) infoget (FTE_STRINGS)
2962 VM_strncmp, // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
2963 VM_strncasecmp, // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
2964 VM_strncasecmp, // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
2966 VM_SV_AddStat, // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
3034 // CSQC range #300-#399
3035 NULL, // #300 void() clearscene (EXT_CSQC)
3036 NULL, // #301 void(float mask) addentities (EXT_CSQC)
3037 NULL, // #302 void(entity ent) addentity (EXT_CSQC)
3038 NULL, // #303 float(float property, ...) setproperty (EXT_CSQC)
3039 NULL, // #304 void() renderscene (EXT_CSQC)
3040 NULL, // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
3041 NULL, // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
3042 NULL, // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3043 NULL, // #308 void() R_EndPolygon
3045 NULL, // #310 vector (vector v) cs_unproject (EXT_CSQC)
3046 NULL, // #311 vector (vector v) cs_project (EXT_CSQC)
3050 NULL, // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
3051 NULL, // #316 float(string name) iscachedpic (EXT_CSQC)
3052 NULL, // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
3053 NULL, // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
3054 NULL, // #319 void(string name) freepic (EXT_CSQC)
3055 NULL, // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
3056 NULL, // #321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
3057 NULL, // #322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
3058 NULL, // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
3059 NULL, // #324 void(float x, float y, float width, float height) drawsetcliparea
3060 NULL, // #325 void(void) drawresetcliparea
3065 NULL, // #330 float(float stnum) getstatf (EXT_CSQC)
3066 NULL, // #331 float(float stnum) getstati (EXT_CSQC)
3067 NULL, // #332 string(float firststnum) getstats (EXT_CSQC)
3068 VM_SV_setmodelindex, // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
3069 VM_SV_modelnameforindex, // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
3070 VM_SV_particleeffectnum, // #335 float(string effectname) particleeffectnum (EXT_CSQC)
3071 VM_SV_trailparticles, // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
3072 VM_SV_pointparticles, // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
3073 NULL, // #338 void(string s, ...) centerprint (EXT_CSQC)
3074 VM_print, // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
3075 NULL, // #340 string(float keynum) keynumtostring (EXT_CSQC)
3076 NULL, // #341 float(string keyname) stringtokeynum (EXT_CSQC)
3077 NULL, // #342 string(float keynum) getkeybind (EXT_CSQC)
3078 NULL, // #343 void(float usecursor) setcursormode (EXT_CSQC)
3079 NULL, // #344 vector() getmousepos (EXT_CSQC)
3080 NULL, // #345 float(float framenum) getinputstate (EXT_CSQC)
3081 NULL, // #346 void(float sens) setsensitivityscaler (EXT_CSQC)
3082 NULL, // #347 void() runstandardplayerphysics (EXT_CSQC)
3083 NULL, // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
3084 NULL, // #349 float() isdemo (EXT_CSQC)
3085 VM_isserver, // #350 float() isserver (EXT_CSQC)
3086 NULL, // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
3087 NULL, // #352 void(string cmdname) registercommand (EXT_CSQC)
3088 VM_wasfreed, // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
3089 VM_SV_serverkey, // #354 string(string key) serverkey (EXT_CSQC)
3095 NULL, // #360 float() readbyte (EXT_CSQC)
3096 NULL, // #361 float() readchar (EXT_CSQC)
3097 NULL, // #362 float() readshort (EXT_CSQC)
3098 NULL, // #363 float() readlong (EXT_CSQC)
3099 NULL, // #364 float() readcoord (EXT_CSQC)
3100 NULL, // #365 float() readangle (EXT_CSQC)
3101 NULL, // #366 string() readstring (EXT_CSQC)
3102 NULL, // #367 float() readfloat (EXT_CSQC)
3135 // LordHavoc's range #400-#499
3136 VM_SV_copyentity, // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
3137 VM_SV_setcolor, // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
3138 VM_findchain, // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
3139 VM_findchainfloat, // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
3140 VM_SV_effect, // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
3141 VM_SV_te_blood, // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
3142 VM_SV_te_bloodshower, // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
3143 VM_SV_te_explosionrgb, // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
3144 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)
3145 VM_SV_te_particlerain, // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
3146 VM_SV_te_particlesnow, // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
3147 VM_SV_te_spark, // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
3148 VM_SV_te_gunshotquad, // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
3149 VM_SV_te_spikequad, // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
3150 VM_SV_te_superspikequad, // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
3151 VM_SV_te_explosionquad, // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
3152 VM_SV_te_smallflash, // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
3153 VM_SV_te_customflash, // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
3154 VM_SV_te_gunshot, // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
3155 VM_SV_te_spike, // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
3156 VM_SV_te_superspike, // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
3157 VM_SV_te_explosion, // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
3158 VM_SV_te_tarexplosion, // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
3159 VM_SV_te_wizspike, // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
3160 VM_SV_te_knightspike, // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
3161 VM_SV_te_lavasplash, // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
3162 VM_SV_te_teleport, // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
3163 VM_SV_te_explosion2, // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
3164 VM_SV_te_lightning1, // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
3165 VM_SV_te_lightning2, // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
3166 VM_SV_te_lightning3, // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
3167 VM_SV_te_beam, // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
3168 VM_vectorvectors, // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
3169 VM_SV_te_plasmaburn, // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
3170 VM_SV_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
3171 VM_SV_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
3172 VM_SV_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
3173 VM_SV_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
3174 VM_SV_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
3175 VM_SV_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
3176 VM_SV_clientcommand, // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
3177 VM_tokenize, // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
3178 VM_argv, // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
3179 VM_SV_setattachment, // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
3180 VM_search_begin, // #444 float(string pattern, float caseinsensitive, float quiet) search_begin (DP_QC_FS_SEARCH)
3181 VM_search_end, // #445 void(float handle) search_end (DP_QC_FS_SEARCH)
3182 VM_search_getsize, // #446 float(float handle) search_getsize (DP_QC_FS_SEARCH)
3183 VM_search_getfilename, // #447 string(float handle, float num) search_getfilename (DP_QC_FS_SEARCH)
3184 VM_cvar_string, // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
3185 VM_findflags, // #449 entity(entity start, .float fld, float match) findflags (DP_QC_FINDFLAGS)
3186 VM_findchainflags, // #450 entity(.float fld, float match) findchainflags (DP_QC_FINDCHAINFLAGS)
3187 VM_SV_gettagindex, // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
3188 VM_SV_gettaginfo, // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
3189 VM_SV_dropclient, // #453 void(entity clent) dropclient (DP_SV_DROPCLIENT)
3190 VM_SV_spawnclient, // #454 entity() spawnclient (DP_SV_BOTCLIENT)
3191 VM_SV_clienttype, // #455 float(entity clent) clienttype (DP_SV_BOTCLIENT)
3192 VM_SV_WriteUnterminatedString, // #456 void(float to, string s) WriteUnterminatedString (DP_SV_WRITEUNTERMINATEDSTRING)
3193 VM_SV_te_flamejet, // #457 void(vector org, vector vel, float howmany) te_flamejet = #457 (DP_TE_FLAMEJET)
3195 VM_ftoe, // #459 entity(float num) entitybyindex (DP_QC_EDICT_NUM)
3196 VM_buf_create, // #460 float() buf_create (DP_QC_STRINGBUFFERS)
3197 VM_buf_del, // #461 void(float bufhandle) buf_del (DP_QC_STRINGBUFFERS)
3198 VM_buf_getsize, // #462 float(float bufhandle) buf_getsize (DP_QC_STRINGBUFFERS)
3199 VM_buf_copy, // #463 void(float bufhandle_from, float bufhandle_to) buf_copy (DP_QC_STRINGBUFFERS)
3200 VM_buf_sort, // #464 void(float bufhandle, float sortpower, float backward) buf_sort (DP_QC_STRINGBUFFERS)
3201 VM_buf_implode, // #465 string(float bufhandle, string glue) buf_implode (DP_QC_STRINGBUFFERS)
3202 VM_bufstr_get, // #466 string(float bufhandle, float string_index) bufstr_get (DP_QC_STRINGBUFFERS)
3203 VM_bufstr_set, // #467 void(float bufhandle, float string_index, string str) bufstr_set (DP_QC_STRINGBUFFERS)
3204 VM_bufstr_add, // #468 float(float bufhandle, string str, float order) bufstr_add (DP_QC_STRINGBUFFERS)
3205 VM_bufstr_free, // #469 void(float bufhandle, float string_index) bufstr_free (DP_QC_STRINGBUFFERS)
3207 VM_asin, // #471 float(float s) VM_asin (DP_QC_ASINACOSATANATAN2TAN)
3208 VM_acos, // #472 float(float c) VM_acos (DP_QC_ASINACOSATANATAN2TAN)
3209 VM_atan, // #473 float(float t) VM_atan (DP_QC_ASINACOSATANATAN2TAN)
3210 VM_atan2, // #474 float(float c, float s) VM_atan2 (DP_QC_ASINACOSATANATAN2TAN)
3211 VM_tan, // #475 float(float a) VM_tan (DP_QC_ASINACOSATANATAN2TAN)
3212 VM_strlennocol, // #476 float(string s) : DRESK - String Length (not counting color codes) (DP_QC_STRINGCOLORFUNCTIONS)
3213 VM_strdecolorize, // #477 string(string s) : DRESK - Decolorized String (DP_SV_STRINGCOLORFUNCTIONS)
3214 VM_strftime, // #478 string(float uselocaltime, string format, ...) (DP_QC_STRFTIME)
3215 VM_tokenizebyseparator, // #479 float(string s) tokenizebyseparator (DP_QC_TOKENIZEBYSEPARATOR)
3216 VM_strtolower, // #480 string(string s) VM_strtolower (DP_QC_STRING_CASE_FUNCTIONS)
3217 VM_strtoupper, // #481 string(string s) VM_strtoupper (DP_QC_STRING_CASE_FUNCTIONS)
3218 VM_cvar_defstring, // #482 string(string s) cvar_defstring (DP_QC_CVAR_DEFSTRING)
3219 VM_SV_pointsound, // #483 void(vector origin, string sample, float volume, float attenuation) (DP_SV_POINTSOUND)
3220 VM_strreplace, // #484 string(string search, string replace, string subject) strreplace (DP_QC_STRREPLACE)
3221 VM_strireplace, // #485 string(string search, string replace, string subject) strireplace (DP_QC_STRREPLACE)
3238 const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t);
3240 void VM_SV_Cmd_Init(void)
3245 void VM_SV_Cmd_Reset(void)