added DP_QC_STRFTIME extension
[xonotic/darkplaces.git] / clvm_cmds.c
1 #include "prvm_cmds.h"
2 #include "csprogs.h"
3 #include "cl_collision.h"
4
5 //============================================================================
6 // Client
7 //[515]: unsolved PROBLEMS
8 //- finish player physics code (cs_runplayerphysics)
9 //- fix R_AddDynamicLight
10 //- EntWasFreed ?
11 //- RF_DEPTHHACK is not like it should be
12 //- add builtin that sets cl.viewangles instead of reading "input_angles" global
13 //- finish lines support for R_Polygon***
14 //- insert selecttraceline into traceline somehow
15
16 //4 feature darkplaces csqc: add builtin to clientside qc for reading triangles of model meshes (useful to orient a ui along a triangle of a model mesh)
17 //4 feature darkplaces csqc: add builtins to clientside qc for gl calls
18
19 //[515]: really need new list ?
20 char *vm_cl_extensions =
21 "BX_WAL_SUPPORT "
22 "DP_CON_SET "
23 "DP_CON_SETA "
24 "DP_CON_STARTMAP "
25 "DP_EF_ADDITIVE "
26 "DP_EF_BLUE "
27 "DP_EF_FLAME "
28 "DP_EF_FULLBRIGHT "
29 "DP_EF_NODEPTHTEST "
30 "DP_EF_NODRAW "
31 "DP_EF_NOSHADOW "
32 "DP_EF_RED "
33 "DP_EF_STARDUST "
34 "DP_ENT_ALPHA "
35 "DP_ENT_CUSTOMCOLORMAP "
36 "DP_ENT_GLOW "
37 "DP_ENT_SCALE "
38 "DP_GFX_EXTERNALTEXTURES "
39 "DP_GFX_EXTERNALTEXTURES_PERMAP "
40 "DP_GFX_FOG "
41 "DP_GFX_QUAKE3MODELTAGS "
42 "DP_GFX_SKINFILES "
43 "DP_GFX_SKYBOX "
44 "DP_HALFLIFE_MAP "
45 "DP_HALFLIFE_MAP_CVAR "
46 "DP_HALFLIFE_SPRITE "
47 "DP_INPUTBUTTONS "
48 "DP_LITSPRITES "
49 "DP_LITSUPPORT "
50 "DP_MONSTERWALK "
51 "DP_MOVETYPEBOUNCEMISSILE "
52 "DP_MOVETYPEFOLLOW "
53 "DP_QC_ASINACOSATANATAN2TAN "
54 "DP_QC_CHANGEPITCH "
55 "DP_QC_COPYENTITY "
56 "DP_QC_CVAR_STRING "
57 "DP_QC_ETOS "
58 "DP_QC_FINDCHAIN "
59 "DP_QC_FINDCHAINFLAGS "
60 "DP_QC_FINDCHAINFLOAT "
61 "DP_QC_FINDFLAGS "
62 "DP_QC_FINDFLOAT "
63 "DP_QC_FS_SEARCH " // Black: same as in the menu qc
64 "DP_QC_GETLIGHT "
65 "DP_QC_GETSURFACE "
66 "DP_QC_GETTAGINFO "
67 "DP_QC_MINMAXBOUND "
68 "DP_QC_MULTIPLETEMPSTRINGS "
69 "DP_QC_RANDOMVEC "
70 "DP_QC_SINCOSSQRTPOW "
71 //"DP_QC_STRINGBUFFERS "        //[515]: not needed ?
72 "DP_QC_STRFTIME "
73 "DP_QC_STRINGCOLORFUNCTIONS "
74 "DP_QC_TRACEBOX "
75 //"DP_QC_TRACETOSS "
76 "DP_QC_TRACE_MOVETYPE_HITMODEL "
77 "DP_QC_TRACE_MOVETYPE_WORLDONLY "
78 "DP_QC_UNLIMITEDTEMPSTRINGS "
79 "DP_QC_VECTORVECTORS "
80 "DP_QUAKE2_MODEL "
81 "DP_QUAKE2_SPRITE "
82 "DP_QUAKE3_MAP "
83 "DP_QUAKE3_MODEL "
84 "DP_REGISTERCVAR "
85 "DP_SND_DIRECTIONLESSATTNNONE "
86 "DP_SND_FAKETRACKS "
87 "DP_SND_OGGVORBIS "
88 "DP_SND_STEREOWAV "
89 "DP_SOLIDCORPSE "
90 "DP_SPRITE32 "
91 "DP_SV_EFFECT "
92 "DP_SV_ROTATINGBMODEL "
93 "DP_SV_SLOWMO "
94 "DP_TE_BLOOD "
95 "DP_TE_BLOODSHOWER "
96 "DP_TE_CUSTOMFLASH "
97 "DP_TE_EXPLOSIONRGB "
98 "DP_TE_FLAMEJET "
99 "DP_TE_PARTICLECUBE "
100 "DP_TE_PARTICLERAIN "
101 "DP_TE_PARTICLESNOW "
102 "DP_TE_PLASMABURN "
103 "DP_TE_QUADEFFECTS1 "
104 "DP_TE_SMALLFLASH "
105 "DP_TE_SPARK "
106 "DP_TE_STANDARDEFFECTBUILTINS "
107 "EXT_BITSHIFT "
108 "EXT_CSQC "
109 "FRIK_FILE "
110 "KRIMZON_SV_PARSECLIENTCOMMAND "
111 "NEH_CMD_PLAY2 "
112 "NXQ_GFX_LETTERBOX "
113 "PRYDON_CLIENTCURSOR "
114 "TENEBRAE_GFX_DLIGHTS "
115 "TW_SV_STEPCONTROL "
116 "NEXUIZ_PLAYERMODEL "
117 "NEXUIZ_PLAYERSKIN "
118 ;
119
120 sfx_t *S_FindName(const char *name);
121 void PF_registercvar (void);
122 int Sbar_GetPlayer (int index);
123 void Sbar_SortFrags (void);
124 void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
125 void CSQC_RelinkAllEntities (int drawmask);
126 void CSQC_RelinkCSQCEntities (void);
127 char *Key_GetBind (int key);
128 model_t *CSQC_GetModelByIndex(int modelindex);
129 model_t *CSQC_GetModelFromEntity(prvm_edict_t *ed);
130
131
132
133
134
135
136 // #1 void(vector ang) makevectors
137 void VM_CL_makevectors (void)
138 {
139         VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
140         AngleVectors (PRVM_G_VECTOR(OFS_PARM0), prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up);
141 }
142
143 // #2 void(entity e, vector o) setorigin
144 void VM_CL_setorigin (void)
145 {
146         prvm_edict_t    *e;
147         float   *org;
148
149         e = PRVM_G_EDICT(OFS_PARM0);
150         if (e == prog->edicts)
151         {
152                 VM_Warning("setorigin: can not modify world entity\n");
153                 return;
154         }
155         if (e->priv.required->free)
156         {
157                 VM_Warning("setorigin: can not modify free entity\n");
158                 return;
159         }
160         org = PRVM_G_VECTOR(OFS_PARM1);
161         VectorCopy (org, e->fields.client->origin);
162 }
163
164 // #3 void(entity e, string m) setmodel
165 void VM_CL_setmodel (void)
166 {
167         prvm_edict_t    *e;
168         const char              *m;
169         struct model_s  *mod;
170         int                             i;
171
172         VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
173
174         e = PRVM_G_EDICT(OFS_PARM0);
175         m = PRVM_G_STRING(OFS_PARM1);
176         for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
177         {
178                 if (!strcmp(cl.csqc_model_precache[i]->name, m))
179                 {
180                         e->fields.client->model = PRVM_SetEngineString(cl.csqc_model_precache[i]->name);
181                         e->fields.client->modelindex = -(i+1);
182                         return;
183                 }
184         }
185
186         for (i = 0;i < MAX_MODELS;i++)
187         {
188                 mod = cl.model_precache[i];
189                 if (mod && !strcmp(mod->name, m))
190                 {
191                         e->fields.client->model = PRVM_SetEngineString(mod->name);
192                         e->fields.client->modelindex = i;
193                         return;
194                 }
195         }
196
197         e->fields.client->modelindex = 0;
198         e->fields.client->model = 0;
199 }
200
201 // #4 void(entity e, vector min, vector max) setsize
202 void VM_CL_setsize (void)
203 {
204         prvm_edict_t    *e;
205         float                   *min, *max;
206         VM_SAFEPARMCOUNT(3, VM_CL_setsize);
207
208         e = PRVM_G_EDICT(OFS_PARM0);
209         if (e == prog->edicts)
210         {
211                 VM_Warning("setsize: can not modify world entity\n");
212                 return;
213         }
214         if (e->priv.server->free)
215         {
216                 VM_Warning("setsize: can not modify free entity\n");
217                 return;
218         }
219         min = PRVM_G_VECTOR(OFS_PARM1);
220         max = PRVM_G_VECTOR(OFS_PARM2);
221
222         VectorCopy (min, e->fields.client->mins);
223         VectorCopy (max, e->fields.client->maxs);
224         VectorSubtract (max, min, e->fields.client->size);
225 }
226
227 // #8 void(entity e, float chan, string samp) sound
228 void VM_CL_sound (void)
229 {
230         const char                      *sample;
231         int                                     channel;
232         prvm_edict_t            *entity;
233         int                             volume;
234         float                           attenuation;
235
236         VM_SAFEPARMCOUNT(5, VM_CL_sound);
237
238         entity = PRVM_G_EDICT(OFS_PARM0);
239         channel = (int)PRVM_G_FLOAT(OFS_PARM1);
240         sample = PRVM_G_STRING(OFS_PARM2);
241         volume = (int)(PRVM_G_FLOAT(OFS_PARM3)*255.0f);
242         attenuation = PRVM_G_FLOAT(OFS_PARM4);
243
244         if (volume < 0 || volume > 255)
245         {
246                 VM_Warning("VM_CL_sound: volume must be in range 0-1\n");
247                 return;
248         }
249
250         if (attenuation < 0 || attenuation > 4)
251         {
252                 VM_Warning("VM_CL_sound: attenuation must be in range 0-4\n");
253                 return;
254         }
255
256         if (channel < 0 || channel > 7)
257         {
258                 VM_Warning("VM_CL_sound: channel must be in range 0-7\n");
259                 return;
260         }
261
262         S_StartSound(32768 + PRVM_NUM_FOR_EDICT(entity), channel, S_FindName(sample), entity->fields.client->origin, volume, attenuation);
263 }
264
265 // #14 entity() spawn
266 void VM_CL_spawn (void)
267 {
268         prvm_edict_t *ed;
269         ed = PRVM_ED_Alloc();
270         ed->fields.client->entnum = PRVM_NUM_FOR_EDICT(ed);     //[515]: not needed any more ?
271         VM_RETURN_EDICT(ed);
272 }
273
274 // #16 float(vector v1, vector v2, float tryents) traceline
275 void VM_CL_traceline (void)
276 {
277         float   *v1, *v2;
278         trace_t trace;
279         int             ent;
280
281         v1 = PRVM_G_VECTOR(OFS_PARM0);
282         v2 = PRVM_G_VECTOR(OFS_PARM1);
283
284         trace = CL_TraceBox(v1, vec3_origin, vec3_origin, v2, 1, &ent, 1, false);
285
286         prog->globals.client->trace_allsolid = trace.allsolid;
287         prog->globals.client->trace_startsolid = trace.startsolid;
288         prog->globals.client->trace_fraction = trace.fraction;
289         prog->globals.client->trace_inwater = trace.inwater;
290         prog->globals.client->trace_inopen = trace.inopen;
291         VectorCopy (trace.endpos, prog->globals.client->trace_endpos);
292         VectorCopy (trace.plane.normal, prog->globals.client->trace_plane_normal);
293         prog->globals.client->trace_plane_dist =  trace.plane.dist;
294         if (ent)
295                 prog->globals.client->trace_ent = ent;
296         else
297                 prog->globals.client->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
298 }
299
300 // #19 void(string s) precache_sound
301 void VM_CL_precache_sound (void)
302 {
303         VM_SAFEPARMCOUNT(1, VM_CL_precache_sound);
304         S_PrecacheSound(PRVM_G_STRING(OFS_PARM0), true, false);
305 }
306
307 // #20 void(string s) precache_model
308 void VM_CL_precache_model (void)
309 {
310         const char      *name;
311         int                     i;
312         model_t         *m;
313
314         VM_SAFEPARMCOUNT(1, VM_CL_precache_model);
315
316         name = PRVM_G_STRING(OFS_PARM0);
317         for (i = 1;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
318         {
319                 if(!strcmp(cl.csqc_model_precache[i]->name, name))
320                 {
321                         PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
322                         return;
323                 }
324         }
325         PRVM_G_FLOAT(OFS_RETURN) = 0;
326         m = Mod_ForName(name, false, false, false);
327         if(m && m->loaded)
328         {
329                 for (i = 1;i < MAX_MODELS;i++)
330                 {
331                         if (!cl.csqc_model_precache[i])
332                         {
333                                 cl.csqc_model_precache[i] = (model_t*)m;
334                                 PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
335                                 return;
336                         }
337                 }
338                 VM_Warning("VM_CL_precache_model: no free models\n");
339                 return;
340         }
341         VM_Warning("VM_CL_precache_model: model \"%s\" not found\n", name);
342 }
343
344 int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **list)
345 {
346         prvm_edict_t    *ent;
347         int                             i, k;
348
349         ent = PRVM_NEXT_EDICT(prog->edicts);
350         for(k=0,i=1; i<prog->num_edicts ;i++, ent = PRVM_NEXT_EDICT(ent))
351         {
352                 if (ent->priv.required->free)
353                         continue;
354 //              VectorAdd(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->absmin);
355 //              VectorAdd(ent->fields.client->origin, ent->fields.client->maxs, ent->fields.client->absmax);
356                 if(BoxesOverlap(mins, maxs, ent->fields.client->absmin, ent->fields.client->absmax))
357                         list[k++] = ent;
358         }
359         return k;
360 }
361
362 // #22 entity(vector org, float rad) findradius
363 void VM_CL_findradius (void)
364 {
365         prvm_edict_t    *ent, *chain;
366         vec_t                   radius, radius2;
367         vec3_t                  org, eorg, mins, maxs;
368         int                             i, numtouchedicts;
369         prvm_edict_t    *touchedicts[MAX_EDICTS];
370
371         chain = (prvm_edict_t *)prog->edicts;
372
373         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
374         radius = PRVM_G_FLOAT(OFS_PARM1);
375         radius2 = radius * radius;
376
377         mins[0] = org[0] - (radius + 1);
378         mins[1] = org[1] - (radius + 1);
379         mins[2] = org[2] - (radius + 1);
380         maxs[0] = org[0] + (radius + 1);
381         maxs[1] = org[1] + (radius + 1);
382         maxs[2] = org[2] + (radius + 1);
383         numtouchedicts = CSQC_EntitiesInBox(mins, maxs, MAX_EDICTS, touchedicts);
384         if (numtouchedicts > MAX_EDICTS)
385         {
386                 // this never happens   //[515]: for what then ?
387                 Con_Printf("CSQC_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
388                 numtouchedicts = MAX_EDICTS;
389         }
390         for (i = 0;i < numtouchedicts;i++)
391         {
392                 ent = touchedicts[i];
393                 // Quake did not return non-solid entities but darkplaces does
394                 // (note: this is the reason you can't blow up fallen zombies)
395                 if (ent->fields.client->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
396                         continue;
397                 // LordHavoc: compare against bounding box rather than center so it
398                 // doesn't miss large objects, and use DotProduct instead of Length
399                 // for a major speedup
400                 VectorSubtract(org, ent->fields.client->origin, eorg);
401                 if (sv_gameplayfix_findradiusdistancetobox.integer)
402                 {
403                         eorg[0] -= bound(ent->fields.client->mins[0], eorg[0], ent->fields.client->maxs[0]);
404                         eorg[1] -= bound(ent->fields.client->mins[1], eorg[1], ent->fields.client->maxs[1]);
405                         eorg[2] -= bound(ent->fields.client->mins[2], eorg[2], ent->fields.client->maxs[2]);
406                 }
407                 else
408                         VectorMAMAM(1, eorg, 0.5f, ent->fields.client->mins, 0.5f, ent->fields.client->maxs, eorg);
409                 if (DotProduct(eorg, eorg) < radius2)
410                 {
411                         ent->fields.client->chain = PRVM_EDICT_TO_PROG(chain);
412                         chain = ent;
413                 }
414         }
415
416         VM_RETURN_EDICT(chain);
417 }
418
419 // #34 float() droptofloor
420 void VM_CL_droptofloor (void)
421 {
422         prvm_edict_t            *ent;
423         vec3_t                          end;
424         trace_t                         trace;
425         int                                     i;
426
427         // assume failure if it returns early
428         PRVM_G_FLOAT(OFS_RETURN) = 0;
429
430         ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
431         if (ent == prog->edicts)
432         {
433                 VM_Warning("droptofloor: can not modify world entity\n");
434                 return;
435         }
436         if (ent->priv.server->free)
437         {
438                 VM_Warning("droptofloor: can not modify free entity\n");
439                 return;
440         }
441
442         VectorCopy (ent->fields.client->origin, end);
443         end[2] -= 256;
444
445         trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, end, 1, &i, 1, false);
446
447         if (trace.fraction != 1)
448         {
449                 VectorCopy (trace.endpos, ent->fields.client->origin);
450                 ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;
451 //              ent->fields.client->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
452                 PRVM_G_FLOAT(OFS_RETURN) = 1;
453                 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
454 //              ent->priv.server->suspendedinairflag = true;
455         }
456 }
457
458 // #35 void(float style, string value) lightstyle
459 void VM_CL_lightstyle (void)
460 {
461         int                     i;
462         const char      *c;
463
464         VM_SAFEPARMCOUNT(2, VM_CL_lightstyle);
465
466         i = (int)PRVM_G_FLOAT(OFS_PARM0);
467         c = PRVM_G_STRING(OFS_PARM1);
468         if (i >= cl.max_lightstyle)
469         {
470                 VM_Warning("VM_CL_lightstyle >= MAX_LIGHTSTYLES\n");
471                 return;
472         }
473         strlcpy (cl.lightstyle[i].map,  MSG_ReadString(), sizeof (cl.lightstyle[i].map));
474         cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
475         cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
476 }
477
478 // #40 float(entity e) checkbottom
479 void VM_CL_checkbottom (void)
480 {
481         static int              cs_yes, cs_no;
482         prvm_edict_t    *ent;
483         vec3_t                  mins, maxs, start, stop;
484         trace_t                 trace;
485         int                             x, y, hit;
486         float                   mid, bottom;
487
488         VM_SAFEPARMCOUNT(1, VM_CL_checkbottom);
489         ent = PRVM_G_EDICT(OFS_PARM0);
490         PRVM_G_FLOAT(OFS_RETURN) = 0;
491
492         VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
493         VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
494
495 // if all of the points under the corners are solid world, don't bother
496 // with the tougher checks
497 // the corners must be within 16 of the midpoint
498         start[2] = mins[2] - 1;
499         for     (x=0 ; x<=1 ; x++)
500                 for     (y=0 ; y<=1 ; y++)
501                 {
502                         start[0] = x ? maxs[0] : mins[0];
503                         start[1] = y ? maxs[1] : mins[1];
504                         if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
505                                 goto realcheck;
506                 }
507
508         cs_yes++;
509         PRVM_G_FLOAT(OFS_RETURN) = true;
510         return;         // we got out easy
511
512 realcheck:
513         cs_no++;
514 //
515 // check it for real...
516 //
517         start[2] = mins[2];
518
519 // the midpoint must be within 16 of the bottom
520         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
521         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
522         stop[2] = start[2] - 2*sv_stepheight.value;
523         trace = CL_TraceBox (start, vec3_origin, vec3_origin, stop, 1, &hit, 1, true);
524
525         if (trace.fraction == 1.0)
526                 return;
527
528         mid = bottom = trace.endpos[2];
529
530 // the corners must be within 16 of the midpoint
531         for     (x=0 ; x<=1 ; x++)
532                 for     (y=0 ; y<=1 ; y++)
533                 {
534                         start[0] = stop[0] = x ? maxs[0] : mins[0];
535                         start[1] = stop[1] = y ? maxs[1] : mins[1];
536
537                         trace = CL_TraceBox (start, vec3_origin, vec3_origin, stop, 1, &hit, 1, true);
538
539                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
540                                 bottom = trace.endpos[2];
541                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
542                                 return;
543                 }
544
545         cs_yes++;
546         PRVM_G_FLOAT(OFS_RETURN) = true;
547 }
548
549 // #41 float(vector v) pointcontents
550 void VM_CL_pointcontents (void)
551 {
552         VM_SAFEPARMCOUNT(1, VM_CL_pointcontents);
553         PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, CL_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
554 }
555
556 // #48 void(vector o, vector d, float color, float count) particle
557 void VM_CL_particle (void)
558 {
559         float   *org, *dir;
560         int             count;
561         unsigned char   color;
562         VM_SAFEPARMCOUNT(4, VM_CL_particle);
563
564         org = PRVM_G_VECTOR(OFS_PARM0);
565         dir = PRVM_G_VECTOR(OFS_PARM1);
566         color = (int)PRVM_G_FLOAT(OFS_PARM2);
567         count = (int)PRVM_G_FLOAT(OFS_PARM3);
568         CL_ParticleEffect(EFFECT_SVC_PARTICLE, count, org, org, dir, dir, NULL, color);
569 }
570
571 // #49 void(entity ent, float ideal_yaw, float speed_yaw) ChangeYaw
572 void VM_CL_changeyaw (void)
573 {
574         prvm_edict_t    *ent;
575         float                   ideal, current, move, speed;
576         VM_SAFEPARMCOUNT(3, VM_CL_changeyaw);
577
578         ent = PRVM_G_EDICT(OFS_PARM0);
579         if (ent == prog->edicts)
580         {
581                 VM_Warning("changeyaw: can not modify world entity\n");
582                 return;
583         }
584         if (ent->priv.server->free)
585         {
586                 VM_Warning("changeyaw: can not modify free entity\n");
587                 return;
588         }
589         current = ANGLEMOD(ent->fields.client->angles[1]);
590         ideal = PRVM_G_FLOAT(OFS_PARM1);
591         speed = PRVM_G_FLOAT(OFS_PARM2);
592
593         if (current == ideal)
594                 return;
595         move = ideal - current;
596         if (ideal > current)
597         {
598                 if (move >= 180)
599                         move = move - 360;
600         }
601         else
602         {
603                 if (move <= -180)
604                         move = move + 360;
605         }
606         if (move > 0)
607         {
608                 if (move > speed)
609                         move = speed;
610         }
611         else
612         {
613                 if (move < -speed)
614                         move = -speed;
615         }
616
617         ent->fields.client->angles[1] = ANGLEMOD (current + move);
618 }
619
620 // #63 void(entity ent, float ideal_pitch, float speed_pitch) changepitch (DP_QC_CHANGEPITCH)
621 void VM_CL_changepitch (void)
622 {
623         prvm_edict_t            *ent;
624         float                           ideal, current, move, speed;
625         VM_SAFEPARMCOUNT(3, VM_CL_changepitch);
626
627         ent = PRVM_G_EDICT(OFS_PARM0);
628         if (ent == prog->edicts)
629         {
630                 VM_Warning("changepitch: can not modify world entity\n");
631                 return;
632         }
633         if (ent->priv.server->free)
634         {
635                 VM_Warning("changepitch: can not modify free entity\n");
636                 return;
637         }
638         current = ANGLEMOD( ent->fields.client->angles[0] );
639         ideal = PRVM_G_FLOAT(OFS_PARM1);
640         speed = PRVM_G_FLOAT(OFS_PARM2);
641
642         if (current == ideal)
643                 return;
644         move = ideal - current;
645         if (ideal > current)
646         {
647                 if (move >= 180)
648                         move = move - 360;
649         }
650         else
651         {
652                 if (move <= -180)
653                         move = move + 360;
654         }
655         if (move > 0)
656         {
657                 if (move > speed)
658                         move = speed;
659         }
660         else
661         {
662                 if (move < -speed)
663                         move = -speed;
664         }
665
666         ent->fields.client->angles[0] = ANGLEMOD (current + move);
667 }
668
669 // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS)
670 void VM_CL_tracetoss (void)
671 {
672 /*      trace_t trace;
673         prvm_edict_t    *ent;
674         prvm_edict_t    *ignore;
675
676         ent = PRVM_G_EDICT(OFS_PARM0);
677         if (ent == prog->edicts)
678         {
679                 VM_Warning("tracetoss: can not use world entity\n");
680                 return;
681         }
682         ignore = PRVM_G_EDICT(OFS_PARM1);
683
684 //FIXME
685         trace = SV_Trace_Toss (ent, ignore);
686
687         prog->globals.server->trace_allsolid = trace.allsolid;
688         prog->globals.server->trace_startsolid = trace.startsolid;
689         prog->globals.server->trace_fraction = trace.fraction;
690         prog->globals.server->trace_inwater = trace.inwater;
691         prog->globals.server->trace_inopen = trace.inopen;
692         VectorCopy (trace.endpos, prog->globals.server->trace_endpos);
693         VectorCopy (trace.plane.normal, prog->globals.server->trace_plane_normal);
694         prog->globals.server->trace_plane_dist =  trace.plane.dist;
695         if (trace.ent)
696                 prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(trace.ent);
697         else
698                 prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
699 */
700 }
701
702 // #74 void(vector pos, string samp, float vol, float atten) ambientsound
703 void VM_CL_ambientsound (void)
704 {
705         float   *f;
706         sfx_t   *s;
707         VM_SAFEPARMCOUNT(4, VM_CL_ambientsound);
708         s = S_FindName(PRVM_G_STRING(OFS_PARM0));
709         f = PRVM_G_VECTOR(OFS_PARM1);
710         S_StaticSound (s, f, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3)*64);
711 }
712
713 // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
714 void VM_CL_tracebox (void)
715 {
716         float   *v1, *v2, *m1, *m2;
717         trace_t trace;
718         int             ent;
719
720         v1 = PRVM_G_VECTOR(OFS_PARM0);
721         m1 = PRVM_G_VECTOR(OFS_PARM1);
722         m2 = PRVM_G_VECTOR(OFS_PARM2);
723         v2 = PRVM_G_VECTOR(OFS_PARM3);
724
725         trace = CL_TraceBox(v1, m1, m2, v2, 1, &ent, 1, false);
726
727         prog->globals.client->trace_allsolid = trace.allsolid;
728         prog->globals.client->trace_startsolid = trace.startsolid;
729         prog->globals.client->trace_fraction = trace.fraction;
730         prog->globals.client->trace_inwater = trace.inwater;
731         prog->globals.client->trace_inopen = trace.inopen;
732         VectorCopy (trace.endpos, prog->globals.client->trace_endpos);
733         VectorCopy (trace.plane.normal, prog->globals.client->trace_plane_normal);
734         prog->globals.client->trace_plane_dist =  trace.plane.dist;
735         if (ent)
736                 prog->globals.client->trace_ent = ent;
737         else
738                 prog->globals.client->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
739 }
740
741 // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
742 void VM_CL_getlight (void)
743 {
744         vec3_t ambientcolor, diffusecolor, diffusenormal;
745         vec_t *p;
746
747         VM_SAFEPARMCOUNT(1, VM_CL_getlight);
748
749         p = PRVM_G_VECTOR(OFS_PARM0);
750         VectorClear(ambientcolor);
751         VectorClear(diffusecolor);
752         VectorClear(diffusenormal);
753         if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
754                 cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
755         VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
756 }
757
758
759 //============================================================================
760 //[515]: SCENE MANAGER builtins
761 extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed);//csprogs.c
762
763 matrix4x4_t csqc_listenermatrix;
764 qboolean csqc_usecsqclistener = false;//[515]: per-frame
765
766 static void CSQC_R_RecalcView (void)
767 {
768         extern matrix4x4_t viewmodelmatrix;
769         viewmodelmatrix = identitymatrix;
770         r_view.matrix = identitymatrix;
771         Matrix4x4_CreateFromQuakeEntity(&r_view.matrix, csqc_origin[0], csqc_origin[1], csqc_origin[2], csqc_angles[0], csqc_angles[1], csqc_angles[2], 1);
772         Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, csqc_origin[0], csqc_origin[1], csqc_origin[2], csqc_angles[0], csqc_angles[1], csqc_angles[2], cl_viewmodel_scale.value);
773 }
774
775 //#300 void() clearscene (EXT_CSQC)
776 void VM_R_ClearScene (void)
777 {
778         VM_SAFEPARMCOUNT(0, VM_R_ClearScene);
779         r_refdef.numentities = 0;
780 }
781
782 //#301 void(float mask) addentities (EXT_CSQC)
783 extern void CSQC_Predraw (prvm_edict_t *ed);//csprogs.c
784 extern void CSQC_Think (prvm_edict_t *ed);//csprogs.c
785 void VM_R_AddEntities (void)
786 {
787         int                     i, drawmask;
788         prvm_edict_t *ed;
789         VM_SAFEPARMCOUNT(1, VM_R_AddEntities);
790         drawmask = (int)PRVM_G_FLOAT(OFS_PARM0);
791         CSQC_RelinkAllEntities(drawmask);
792
793         *prog->time = cl.time;
794         for(i=1;i<prog->num_edicts;i++)
795         {
796                 ed = &prog->edicts[i];
797                 if(ed->priv.required->free)
798                         continue;
799                 VectorAdd(ed->fields.client->origin, ed->fields.client->mins, ed->fields.client->absmin);
800                 VectorAdd(ed->fields.client->origin, ed->fields.client->maxs, ed->fields.client->absmax);
801                 CSQC_Think(ed);
802                 if(ed->priv.required->free)
803                         continue;
804                 // note that for RF_USEAXIS entities, Predraw sets v_forward/v_right/v_up globals that are read by CSQC_AddRenderEdict
805                 CSQC_Predraw(ed);
806                 if(ed->priv.required->free)
807                         continue;
808                 if(!((int)ed->fields.client->drawmask & drawmask))
809                         continue;
810                 CSQC_AddRenderEdict(ed);
811         }
812 }
813
814 //#302 void(entity ent) addentity (EXT_CSQC)
815 void VM_R_AddEntity (void)
816 {
817         VM_SAFEPARMCOUNT(1, VM_R_AddEntity);
818         CSQC_AddRenderEdict(PRVM_G_EDICT(OFS_PARM0));
819 }
820
821 //#303 float(float property, ...) setproperty (EXT_CSQC)
822 void VM_R_SetView (void)
823 {
824         int             c;
825         float   *f;
826         float   k;
827
828         if(prog->argc < 2)
829                 VM_SAFEPARMCOUNT(2, VM_R_SetView);
830
831         c = (int)PRVM_G_FLOAT(OFS_PARM0);
832         f = PRVM_G_VECTOR(OFS_PARM1);
833         k = PRVM_G_FLOAT(OFS_PARM1);
834
835         switch(c)
836         {
837         case VF_MIN:                    r_view.x = (int)f[0];
838                                                         r_view.y = (int)f[1];
839                                                         break;
840         case VF_MIN_X:                  r_view.x = (int)k;
841                                                         break;
842         case VF_MIN_Y:                  r_view.y = (int)k;
843                                                         break;
844         case VF_SIZE:                   r_view.width = (int)f[0];
845                                                         r_view.height = (int)f[1];
846                                                         break;
847         case VF_SIZE_Y:                 r_view.width = (int)k;
848                                                         break;
849         case VF_SIZE_X:                 r_view.height = (int)k;
850                                                         break;
851         case VF_VIEWPORT:               r_view.x = (int)f[0];
852                                                         r_view.y = (int)f[1];
853                                                         r_view.z = 0;
854                                                         // TODO: make sure that view_z and view_depth are set properly even if csqc does not set them!
855                                                         f = PRVM_G_VECTOR(OFS_PARM2);
856                                                         r_view.width = (int)f[0];
857                                                         r_view.height = (int)f[1];
858                                                         r_view.depth = 1;
859                                                         break;
860         case VF_FOV:                    //r_refdef.fov_x = f[0]; // FIXME!
861                                                         //r_refdef.fov_y = f[1]; // FIXME!
862                                                         break;
863         case VF_FOVX:                   //r_refdef.fov_x = k; // FIXME!
864                                                         break;
865         case VF_FOVY:                   //r_refdef.fov_y = k; // FIXME!
866                                                         break;
867         case VF_ORIGIN:                 VectorCopy(f, csqc_origin);
868                                                         CSQC_R_RecalcView();
869                                                         break;
870         case VF_ORIGIN_X:               csqc_origin[0] = k;
871                                                         CSQC_R_RecalcView();
872                                                         break;
873         case VF_ORIGIN_Y:               csqc_origin[1] = k;
874                                                         CSQC_R_RecalcView();
875                                                         break;
876         case VF_ORIGIN_Z:               csqc_origin[2] = k;
877                                                         CSQC_R_RecalcView();
878                                                         break;
879         case VF_ANGLES:                 VectorCopy(f, csqc_angles);
880                                                         CSQC_R_RecalcView();
881                                                         break;
882         case VF_ANGLES_X:               csqc_angles[0] = k;
883                                                         CSQC_R_RecalcView();
884                                                         break;
885         case VF_ANGLES_Y:               csqc_angles[1] = k;
886                                                         CSQC_R_RecalcView();
887                                                         break;
888         case VF_ANGLES_Z:               csqc_angles[2] = k;
889                                                         CSQC_R_RecalcView();
890                                                         break;
891         case VF_DRAWWORLD:              cl.csqc_vidvars.drawworld = k;
892                                                         break;
893         case VF_DRAWENGINESBAR: cl.csqc_vidvars.drawenginesbar = k;
894                                                         break;
895         case VF_DRAWCROSSHAIR:  cl.csqc_vidvars.drawcrosshair = k;
896                                                         break;
897
898         case VF_CL_VIEWANGLES:  VectorCopy(f, cl.viewangles);
899                                                         break;
900         case VF_CL_VIEWANGLES_X:cl.viewangles[0] = k;
901                                                         break;
902         case VF_CL_VIEWANGLES_Y:cl.viewangles[1] = k;
903                                                         break;
904         case VF_CL_VIEWANGLES_Z:cl.viewangles[2] = k;
905                                                         break;
906
907         default:                                PRVM_G_FLOAT(OFS_RETURN) = 0;
908                                                         VM_Warning("VM_R_SetView : unknown parm %i\n", c);
909                                                         return;
910         }
911         PRVM_G_FLOAT(OFS_RETURN) = 1;
912 }
913
914 //#304 void() renderscene (EXT_CSQC)
915 void VM_R_RenderScene (void) //#134
916 {
917         VM_SAFEPARMCOUNT(0, VM_R_RenderScene);
918         // update all renderable network entities
919         CL_UpdateEntities();
920         R_RenderView();
921 }
922
923 //#305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
924 void VM_R_AddDynamicLight (void)
925 {
926         float           *pos, *col;
927         matrix4x4_t     tempmatrix;
928         VM_SAFEPARMCOUNT(3, VM_R_AddDynamicLight);
929
930         pos = PRVM_G_VECTOR(OFS_PARM0);
931         col = PRVM_G_VECTOR(OFS_PARM2);
932         Matrix4x4_CreateTranslate(&tempmatrix, pos[0], pos[1], pos[2]);
933         CL_AllocDlight(NULL, &tempmatrix, PRVM_G_FLOAT(OFS_PARM1), col[0], col[1], col[2], 500, 0, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
934         //CL_AllocDlight(NULL, &tempmatrix, PRVM_G_FLOAT(OFS_PARM1), col[0], col[1], col[2], 500, 0.2, 0, -1, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
935 }
936
937 //============================================================================
938
939 //#310 vector (vector v) cs_unproject (EXT_CSQC)
940 void VM_CL_unproject (void)
941 {
942         float   *f;
943         vec3_t  temp;
944
945         VM_SAFEPARMCOUNT(1, VM_CL_unproject);
946         f = PRVM_G_VECTOR(OFS_PARM0);
947         VectorSet(temp, f[2], f[0] * f[2] * -r_view.frustum_x * 2.0 / r_view.width, f[1] * f[2] * -r_view.frustum_y * 2.0 / r_view.height);
948         Matrix4x4_Transform(&r_view.matrix, temp, PRVM_G_VECTOR(OFS_RETURN));
949 }
950
951 //#311 vector (vector v) cs_project (EXT_CSQC)
952 void VM_CL_project (void)
953 {
954         float   *f;
955         vec3_t  v;
956         matrix4x4_t m;
957
958         VM_SAFEPARMCOUNT(1, VM_CL_project);
959         f = PRVM_G_VECTOR(OFS_PARM0);
960         Matrix4x4_Invert_Simple(&m, &r_view.matrix);
961         Matrix4x4_Transform(&m, f, v);
962         VectorSet(PRVM_G_VECTOR(OFS_RETURN), v[1]/v[0]/-r_view.frustum_x*0.5*r_view.width, v[2]/v[0]/-r_view.frustum_y*r_view.height*0.5, v[0]);
963 }
964
965 //#330 float(float stnum) getstatf (EXT_CSQC)
966 void VM_CL_getstatf (void)
967 {
968         int i;
969         union
970         {
971                 float f;
972                 int l;
973         }dat;
974         VM_SAFEPARMCOUNT(1, VM_CL_getstatf);
975         i = (int)PRVM_G_FLOAT(OFS_PARM0);
976         if(i < 0 || i >= MAX_CL_STATS)
977         {
978                 VM_Warning("VM_CL_getstatf: index>=MAX_CL_STATS or index<0\n");
979                 return;
980         }
981         dat.l = cl.stats[i];
982         PRVM_G_FLOAT(OFS_RETURN) =  dat.f;
983 }
984
985 //#331 float(float stnum) getstati (EXT_CSQC)
986 void VM_CL_getstati (void)
987 {
988         int i, index;
989         VM_SAFEPARMCOUNT(1, VM_CL_getstati);
990         index = (int)PRVM_G_FLOAT(OFS_PARM0);
991
992         if(index < 0 || index >= MAX_CL_STATS)
993         {
994                 VM_Warning("VM_CL_getstati: index>=MAX_CL_STATS or index<0\n");
995                 return;
996         }
997         i = cl.stats[index];
998         PRVM_G_FLOAT(OFS_RETURN) = i;
999 }
1000
1001 //#332 string(float firststnum) getstats (EXT_CSQC)
1002 void VM_CL_getstats (void)
1003 {
1004         int i;
1005         char t[17];
1006         VM_SAFEPARMCOUNT(1, VM_CL_getstats);
1007         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1008         if(i < 0 || i > MAX_CL_STATS-4)
1009         {
1010                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1011                 VM_Warning("VM_CL_getstats: index>MAX_CL_STATS-4 or index<0\n");
1012                 return;
1013         }
1014         strlcpy(t, (char*)&cl.stats[i], sizeof(t));
1015         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
1016 }
1017
1018 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
1019 void VM_CL_setmodelindex (void)
1020 {
1021         int                             i;
1022         prvm_edict_t    *t;
1023         struct model_s  *model;
1024
1025         VM_SAFEPARMCOUNT(2, VM_CL_setmodelindex);
1026
1027         t = PRVM_G_EDICT(OFS_PARM0);
1028
1029         i = (int)PRVM_G_FLOAT(OFS_PARM1);
1030
1031         t->fields.client->model = 0;
1032         t->fields.client->modelindex = 0;
1033
1034         if (!i)
1035                 return;
1036
1037         model = CSQC_GetModelByIndex(i);
1038         if (!model)
1039         {
1040                 VM_Warning("VM_CL_setmodelindex: null model\n");
1041                 return;
1042         }
1043         t->fields.client->model = PRVM_SetEngineString(model->name);
1044         t->fields.client->modelindex = i;
1045 }
1046
1047 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
1048 void VM_CL_modelnameforindex (void)
1049 {
1050         model_t *model;
1051
1052         VM_SAFEPARMCOUNT(1, VM_CL_modelnameforindex);
1053
1054         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1055         model = CSQC_GetModelByIndex((int)PRVM_G_FLOAT(OFS_PARM0));
1056         PRVM_G_INT(OFS_RETURN) = model ? PRVM_SetEngineString(model->name) : 0;
1057 }
1058
1059 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
1060 void VM_CL_particleeffectnum (void)
1061 {
1062         int                     i;
1063         VM_SAFEPARMCOUNT(1, VM_CL_particleeffectnum);
1064         i = CL_ParticleEffectIndexForName(PRVM_G_STRING(OFS_PARM0));
1065         if (i == 0)
1066                 i = -1;
1067         PRVM_G_FLOAT(OFS_RETURN) = i;
1068 }
1069
1070 // #336 void(entity ent, float effectnum, vector start, vector end[, float color]) trailparticles (EXT_CSQC)
1071 void VM_CL_trailparticles (void)
1072 {
1073         int                             i;
1074         float                   *start, *end;
1075         prvm_edict_t    *t;
1076         VM_SAFEPARMCOUNT(4, VM_CL_trailparticles);
1077
1078         t = PRVM_G_EDICT(OFS_PARM0);
1079         i               = (int)PRVM_G_FLOAT(OFS_PARM1);
1080         start   = PRVM_G_VECTOR(OFS_PARM2);
1081         end             = PRVM_G_VECTOR(OFS_PARM3);
1082
1083         CL_ParticleEffect(i, VectorDistance(start, end), start, end, t->fields.client->velocity, t->fields.client->velocity, NULL, (int)PRVM_G_FLOAT(OFS_PARM4));
1084 }
1085
1086 //#337 void(float effectnum, vector origin, vector dir, float count) pointparticles (EXT_CSQC)
1087 void VM_CL_pointparticles (void)
1088 {
1089         int                     i, n;
1090         float           *f, *v;
1091         VM_SAFEPARMCOUNT(4, VM_CL_pointparticles);
1092         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1093         f = PRVM_G_VECTOR(OFS_PARM1);
1094         v = PRVM_G_VECTOR(OFS_PARM2);
1095         n = (int)PRVM_G_FLOAT(OFS_PARM3);
1096         CL_ParticleEffect(i, n, f, f, v, v, NULL, 0);
1097 }
1098
1099 //#338 void(string s) cprint (EXT_CSQC)
1100 void VM_CL_centerprint (void)
1101 {
1102         char s[VM_STRINGTEMP_LENGTH];
1103         if(prog->argc < 1)
1104                 VM_SAFEPARMCOUNT(1, VM_CL_centerprint);
1105         VM_VarString(0, s, sizeof(s));
1106         SCR_CenterPrint(s);
1107 }
1108
1109 //#342 string(float keynum) getkeybind (EXT_CSQC)
1110 void VM_CL_getkeybind (void)
1111 {
1112         VM_SAFEPARMCOUNT(1, VM_CL_getkeybind);
1113         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0)));
1114 }
1115
1116 //#343 void(float usecursor) setcursormode (EXT_CSQC)
1117 void VM_CL_setcursormode (void)
1118 {
1119         VM_SAFEPARMCOUNT(1, VM_CL_setcursormode);
1120         cl.csqc_wantsmousemove = PRVM_G_FLOAT(OFS_PARM0);
1121         cl_ignoremousemove = true;
1122 }
1123
1124 //#345 float(float framenum) getinputstate (EXT_CSQC)
1125 void VM_CL_getinputstate (void)
1126 {
1127         int i, frame;
1128         VM_SAFEPARMCOUNT(1, VM_CL_getinputstate);
1129         frame = (int)PRVM_G_FLOAT(OFS_PARM0);
1130         for (i = 0;i < cl.movement_numqueue;i++)
1131                 if (cl.movement_queue[i].sequence == frame)
1132                 {
1133                         VectorCopy(cl.movement_queue[i].viewangles, prog->globals.client->input_angles);
1134                         //prog->globals.client->input_buttons = cl.movement_queue[i].//FIXME
1135                         VectorCopy(cl.movement_queue[i].move, prog->globals.client->input_movevalues);
1136                         prog->globals.client->input_timelength = cl.movement_queue[i].frametime;
1137                         if(cl.movement_queue[i].crouch)
1138                         {
1139                                 VectorCopy(cl.playercrouchmins, prog->globals.client->pmove_mins);
1140                                 VectorCopy(cl.playercrouchmaxs, prog->globals.client->pmove_maxs);
1141                         }
1142                         else
1143                         {
1144                                 VectorCopy(cl.playerstandmins, prog->globals.client->pmove_mins);
1145                                 VectorCopy(cl.playerstandmaxs, prog->globals.client->pmove_maxs);
1146                         }
1147                 }
1148 }
1149
1150 //#346 void(float sens) setsensitivityscaler (EXT_CSQC)
1151 void VM_CL_setsensitivityscale (void)
1152 {
1153         VM_SAFEPARMCOUNT(1, VM_CL_setsensitivityscale);
1154         cl.sensitivityscale = PRVM_G_FLOAT(OFS_PARM0);
1155 }
1156
1157 //#347 void() runstandardplayerphysics (EXT_CSQC)
1158 void VM_CL_runplayerphysics (void)
1159 {
1160 }
1161
1162 //#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
1163 void VM_CL_getplayerkey (void)
1164 {
1165         int                     i;
1166         char            t[128];
1167         const char      *c;
1168
1169         VM_SAFEPARMCOUNT(2, VM_CL_getplayerkey);
1170
1171         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1172         c = PRVM_G_STRING(OFS_PARM1);
1173         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1174         Sbar_SortFrags();
1175
1176         i = Sbar_GetPlayer(i);
1177         if(i < 0)
1178                 return;
1179
1180         t[0] = 0;
1181
1182         if(!strcasecmp(c, "name"))
1183                 strlcpy(t, cl.scores[i].name, sizeof(t));
1184         else
1185                 if(!strcasecmp(c, "frags"))
1186                         sprintf(t, "%i", cl.scores[i].frags);
1187         else
1188                 if(!strcasecmp(c, "ping"))
1189                         sprintf(t, "%i", cl.scores[i].qw_ping);
1190         else
1191                 if(!strcasecmp(c, "entertime"))
1192                         sprintf(t, "%f", cl.scores[i].qw_entertime);
1193         else
1194                 if(!strcasecmp(c, "colors"))
1195                         sprintf(t, "%i", cl.scores[i].colors);
1196         else
1197                 if(!strcasecmp(c, "topcolor"))
1198                         sprintf(t, "%i", cl.scores[i].colors & 0xf0);
1199         else
1200                 if(!strcasecmp(c, "bottomcolor"))
1201                         sprintf(t, "%i", (cl.scores[i].colors &15)<<4);
1202         else
1203                 if(!strcasecmp(c, "viewentity"))
1204                         sprintf(t, "%i", i+1);
1205         if(!t[0])
1206                 return;
1207         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
1208 }
1209
1210 //#349 float() isdemo (EXT_CSQC)
1211 void VM_CL_isdemo (void)
1212 {
1213         PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
1214 }
1215
1216 //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
1217 void VM_CL_setlistener (void)
1218 {
1219         VM_SAFEPARMCOUNT(4, VM_CL_setlistener);
1220         Matrix4x4_FromVectors(&csqc_listenermatrix, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), PRVM_G_VECTOR(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0));
1221         csqc_usecsqclistener = true;    //use csqc listener at this frame
1222 }
1223
1224 //#352 void(string cmdname) registercommand (EXT_CSQC)
1225 void VM_CL_registercmd (void)
1226 {
1227         char *t;
1228         VM_SAFEPARMCOUNT(1, VM_CL_registercmd);
1229         if(!Cmd_Exists(PRVM_G_STRING(OFS_PARM0)))
1230         {
1231                 size_t alloclen;
1232
1233                 alloclen = strlen(PRVM_G_STRING(OFS_PARM0)) + 1;
1234                 t = (char *)Z_Malloc(alloclen);
1235                 memcpy(t, PRVM_G_STRING(OFS_PARM0), alloclen);
1236                 Cmd_AddCommand(t, NULL, "console command created by QuakeC");
1237         }
1238         else
1239                 Cmd_AddCommand(PRVM_G_STRING(OFS_PARM0), NULL, "console command created by QuakeC");
1240
1241 }
1242
1243 //#354 float() playernum (EXT_CSQC)
1244 void VM_CL_playernum (void)
1245 {
1246         int i, k;
1247
1248         VM_SAFEPARMCOUNT(0, VM_CL_playernum);
1249
1250         for(i=k=0 ; i<cl.maxclients ; i++)
1251                 if(cl.scores[i].name[0])
1252                         k++;
1253         PRVM_G_FLOAT(OFS_RETURN) = k;
1254 }
1255
1256 //#355 float() cl_onground (EXT_CSQC)
1257 void VM_CL_onground (void)
1258 {
1259         PRVM_G_FLOAT(OFS_RETURN) = cl.onground;
1260 }
1261
1262 //#360 float() readbyte (EXT_CSQC)
1263 void VM_CL_ReadByte (void)
1264 {
1265         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadByte();
1266 }
1267
1268 //#361 float() readchar (EXT_CSQC)
1269 void VM_CL_ReadChar (void)
1270 {
1271         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar();
1272 }
1273
1274 //#362 float() readshort (EXT_CSQC)
1275 void VM_CL_ReadShort (void)
1276 {
1277         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort();
1278 }
1279
1280 //#363 float() readlong (EXT_CSQC)
1281 void VM_CL_ReadLong (void)
1282 {
1283         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong();
1284 }
1285
1286 //#364 float() readcoord (EXT_CSQC)
1287 void VM_CL_ReadCoord (void)
1288 {
1289         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadCoord(cls.protocol);
1290 }
1291
1292 //#365 float() readangle (EXT_CSQC)
1293 void VM_CL_ReadAngle (void)
1294 {
1295         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadAngle(cls.protocol);
1296 }
1297
1298 //#366 string() readstring (EXT_CSQC)
1299 void VM_CL_ReadString (void)
1300 {
1301         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(MSG_ReadString());
1302 }
1303
1304 //#367 float() readfloat (EXT_CSQC)
1305 void VM_CL_ReadFloat (void)
1306 {
1307         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat();
1308 }
1309
1310 //=================================================================//
1311
1312 // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
1313 void VM_CL_effect (void)
1314 {
1315         VM_SAFEPARMCOUNT(5, VM_CL_effect);
1316         CL_Effect(PRVM_G_VECTOR(OFS_PARM0), (int)PRVM_G_FLOAT(OFS_PARM1), (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), PRVM_G_FLOAT(OFS_PARM4));
1317 }
1318
1319 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
1320 void VM_CL_te_blood (void)
1321 {
1322         float   *pos;
1323         vec3_t  pos2;
1324         VM_SAFEPARMCOUNT(3, VM_CL_te_blood);
1325         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1326                 return;
1327         pos = PRVM_G_VECTOR(OFS_PARM0);
1328         CL_FindNonSolidLocation(pos, pos2, 4);
1329         CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1330 }
1331
1332 // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
1333 void VM_CL_te_bloodshower (void)
1334 {
1335         vec_t speed;
1336         vec3_t vel1, vel2;
1337         VM_SAFEPARMCOUNT(4, VM_CL_te_bloodshower);
1338         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1339                 return;
1340         speed = PRVM_G_FLOAT(OFS_PARM2);
1341         vel1[0] = -speed;
1342         vel1[1] = -speed;
1343         vel1[2] = -speed;
1344         vel2[0] = speed;
1345         vel2[1] = speed;
1346         vel2[2] = speed;
1347         CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), vel1, vel2, NULL, 0);
1348 }
1349
1350 // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
1351 void VM_CL_te_explosionrgb (void)
1352 {
1353         float           *pos;
1354         vec3_t          pos2;
1355         matrix4x4_t     tempmatrix;
1356         VM_SAFEPARMCOUNT(2, VM_CL_te_explosionrgb);
1357         pos = PRVM_G_VECTOR(OFS_PARM0);
1358         CL_FindNonSolidLocation(pos, pos2, 10);
1359         CL_ParticleExplosion(pos2);
1360         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1361         CL_AllocDlight(NULL, &tempmatrix, 350, PRVM_G_VECTOR(OFS_PARM1)[0], PRVM_G_VECTOR(OFS_PARM1)[1], PRVM_G_VECTOR(OFS_PARM1)[2], 700, 0.5, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
1362 }
1363
1364 // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
1365 void VM_CL_te_particlecube (void)
1366 {
1367         VM_SAFEPARMCOUNT(7, VM_CL_te_particlecube);
1368         CL_ParticleCube(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), PRVM_G_FLOAT(OFS_PARM5), PRVM_G_FLOAT(OFS_PARM6));
1369 }
1370
1371 // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
1372 void VM_CL_te_particlerain (void)
1373 {
1374         VM_SAFEPARMCOUNT(5, VM_CL_te_particlerain);
1375         CL_ParticleRain(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 0);
1376 }
1377
1378 // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
1379 void VM_CL_te_particlesnow (void)
1380 {
1381         VM_SAFEPARMCOUNT(5, VM_CL_te_particlesnow);
1382         CL_ParticleRain(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 1);
1383 }
1384
1385 // #411 void(vector org, vector vel, float howmany) te_spark
1386 void VM_CL_te_spark (void)
1387 {
1388         float           *pos;
1389         vec3_t          pos2;
1390         VM_SAFEPARMCOUNT(3, VM_CL_te_spark);
1391
1392         pos = PRVM_G_VECTOR(OFS_PARM0);
1393         CL_FindNonSolidLocation(pos, pos2, 4);
1394         CL_ParticleEffect(EFFECT_TE_SPARK, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1395 }
1396
1397 // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
1398 void VM_CL_te_gunshotquad (void)
1399 {
1400         float           *pos;
1401         vec3_t          pos2;
1402         VM_SAFEPARMCOUNT(1, VM_CL_te_gunshotquad);
1403
1404         pos = PRVM_G_VECTOR(OFS_PARM0);
1405         CL_FindNonSolidLocation(pos, pos2, 4);
1406         CL_ParticleEffect(EFFECT_TE_GUNSHOTQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1407 }
1408
1409 // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
1410 void VM_CL_te_spikequad (void)
1411 {
1412         float           *pos;
1413         vec3_t          pos2;
1414         int                     rnd;
1415         VM_SAFEPARMCOUNT(1, VM_CL_te_spikequad);
1416
1417         pos = PRVM_G_VECTOR(OFS_PARM0);
1418         CL_FindNonSolidLocation(pos, pos2, 4);
1419         CL_ParticleEffect(EFFECT_TE_SPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1420         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1421         else
1422         {
1423                 rnd = rand() & 3;
1424                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1425                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1426                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1427         }
1428 }
1429
1430 // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
1431 void VM_CL_te_superspikequad (void)
1432 {
1433         float           *pos;
1434         vec3_t          pos2;
1435         int                     rnd;
1436         VM_SAFEPARMCOUNT(1, VM_CL_te_superspikequad);
1437
1438         pos = PRVM_G_VECTOR(OFS_PARM0);
1439         CL_FindNonSolidLocation(pos, pos2, 4);
1440         CL_ParticleEffect(EFFECT_TE_SUPERSPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1441         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos, 1, 1);
1442         else
1443         {
1444                 rnd = rand() & 3;
1445                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1446                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1447                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1448         }
1449 }
1450
1451 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
1452 void VM_CL_te_explosionquad (void)
1453 {
1454         float           *pos;
1455         vec3_t          pos2;
1456         VM_SAFEPARMCOUNT(1, VM_CL_te_explosionquad);
1457
1458         pos = PRVM_G_VECTOR(OFS_PARM0);
1459         CL_FindNonSolidLocation(pos, pos2, 10);
1460         CL_ParticleEffect(EFFECT_TE_EXPLOSIONQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1461         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1462 }
1463
1464 // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
1465 void VM_CL_te_smallflash (void)
1466 {
1467         float           *pos;
1468         vec3_t          pos2;
1469         VM_SAFEPARMCOUNT(1, VM_CL_te_smallflash);
1470
1471         pos = PRVM_G_VECTOR(OFS_PARM0);
1472         CL_FindNonSolidLocation(pos, pos2, 10);
1473         CL_ParticleEffect(EFFECT_TE_SMALLFLASH, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1474 }
1475
1476 // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
1477 void VM_CL_te_customflash (void)
1478 {
1479         float           *pos;
1480         vec3_t          pos2;
1481         matrix4x4_t     tempmatrix;
1482         VM_SAFEPARMCOUNT(4, VM_CL_te_customflash);
1483
1484         pos = PRVM_G_VECTOR(OFS_PARM0);
1485         CL_FindNonSolidLocation(pos, pos2, 4);
1486         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1487         CL_AllocDlight(NULL, &tempmatrix, PRVM_G_FLOAT(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM3)[0], PRVM_G_VECTOR(OFS_PARM3)[1], PRVM_G_VECTOR(OFS_PARM3)[2], PRVM_G_FLOAT(OFS_PARM1) / PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM2), 0, -1, true, 1, 0.25, 1, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
1488 }
1489
1490 // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
1491 void VM_CL_te_gunshot (void)
1492 {
1493         float           *pos;
1494         vec3_t          pos2;
1495         VM_SAFEPARMCOUNT(1, VM_CL_te_gunshot);
1496
1497         pos = PRVM_G_VECTOR(OFS_PARM0);
1498         CL_FindNonSolidLocation(pos, pos2, 4);
1499         CL_ParticleEffect(EFFECT_TE_GUNSHOT, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1500 }
1501
1502 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
1503 void VM_CL_te_spike (void)
1504 {
1505         float           *pos;
1506         vec3_t          pos2;
1507         int                     rnd;
1508         VM_SAFEPARMCOUNT(1, VM_CL_te_spike);
1509
1510         pos = PRVM_G_VECTOR(OFS_PARM0);
1511         CL_FindNonSolidLocation(pos, pos2, 4);
1512         CL_ParticleEffect(EFFECT_TE_SPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1513         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1514         else
1515         {
1516                 rnd = rand() & 3;
1517                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1518                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1519                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1520         }
1521 }
1522
1523 // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
1524 void VM_CL_te_superspike (void)
1525 {
1526         float           *pos;
1527         vec3_t          pos2;
1528         int                     rnd;
1529         VM_SAFEPARMCOUNT(1, VM_CL_te_superspike);
1530
1531         pos = PRVM_G_VECTOR(OFS_PARM0);
1532         CL_FindNonSolidLocation(pos, pos2, 4);
1533         CL_ParticleEffect(EFFECT_TE_SUPERSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1534         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1535         else
1536         {
1537                 rnd = rand() & 3;
1538                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1539                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1540                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1541         }
1542 }
1543
1544 // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
1545 void VM_CL_te_explosion (void)
1546 {
1547         float           *pos;
1548         vec3_t          pos2;
1549         VM_SAFEPARMCOUNT(1, VM_CL_te_explosion);
1550
1551         pos = PRVM_G_VECTOR(OFS_PARM0);
1552         CL_FindNonSolidLocation(pos, pos2, 10);
1553         CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1554         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1555 }
1556
1557 // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
1558 void VM_CL_te_tarexplosion (void)
1559 {
1560         float           *pos;
1561         vec3_t          pos2;
1562         VM_SAFEPARMCOUNT(1, VM_CL_te_tarexplosion);
1563
1564         pos = PRVM_G_VECTOR(OFS_PARM0);
1565         CL_FindNonSolidLocation(pos, pos2, 10);
1566         CL_ParticleEffect(EFFECT_TE_TAREXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1567         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1568 }
1569
1570 // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
1571 void VM_CL_te_wizspike (void)
1572 {
1573         float           *pos;
1574         vec3_t          pos2;
1575         VM_SAFEPARMCOUNT(1, VM_CL_te_wizspike);
1576
1577         pos = PRVM_G_VECTOR(OFS_PARM0);
1578         CL_FindNonSolidLocation(pos, pos2, 4);
1579         CL_ParticleEffect(EFFECT_TE_WIZSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1580         S_StartSound(-1, 0, cl.sfx_wizhit, pos2, 1, 1);
1581 }
1582
1583 // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
1584 void VM_CL_te_knightspike (void)
1585 {
1586         float           *pos;
1587         vec3_t          pos2;
1588         VM_SAFEPARMCOUNT(1, VM_CL_te_knightspike);
1589
1590         pos = PRVM_G_VECTOR(OFS_PARM0);
1591         CL_FindNonSolidLocation(pos, pos2, 4);
1592         CL_ParticleEffect(EFFECT_TE_KNIGHTSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1593         S_StartSound(-1, 0, cl.sfx_knighthit, pos2, 1, 1);
1594 }
1595
1596 // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
1597 void VM_CL_te_lavasplash (void)
1598 {
1599         VM_SAFEPARMCOUNT(1, VM_CL_te_lavasplash);
1600         CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
1601 }
1602
1603 // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
1604 void VM_CL_te_teleport (void)
1605 {
1606         VM_SAFEPARMCOUNT(1, VM_CL_te_teleport);
1607         CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
1608 }
1609
1610 // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
1611 void VM_CL_te_explosion2 (void)
1612 {
1613         float           *pos;
1614         vec3_t          pos2, color;
1615         matrix4x4_t     tempmatrix;
1616         int                     colorStart, colorLength;
1617         unsigned char           *tempcolor;
1618         VM_SAFEPARMCOUNT(3, VM_CL_te_explosion2);
1619
1620         pos = PRVM_G_VECTOR(OFS_PARM0);
1621         colorStart = (int)PRVM_G_FLOAT(OFS_PARM1);
1622         colorLength = (int)PRVM_G_FLOAT(OFS_PARM2);
1623         CL_FindNonSolidLocation(pos, pos2, 10);
1624         CL_ParticleExplosion2(pos2, colorStart, colorLength);
1625         tempcolor = (unsigned char *)&palette_complete[(rand()%colorLength) + colorStart];
1626         color[0] = tempcolor[0] * (2.0f / 255.0f);
1627         color[1] = tempcolor[1] * (2.0f / 255.0f);
1628         color[2] = tempcolor[2] * (2.0f / 255.0f);
1629         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1630         CL_AllocDlight(NULL, &tempmatrix, 350, color[0], color[1], color[2], 700, 0.5, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
1631         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1632 }
1633
1634
1635 // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
1636 void VM_CL_te_lightning1 (void)
1637 {
1638         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning1);
1639         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt, true);
1640 }
1641
1642 // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
1643 void VM_CL_te_lightning2 (void)
1644 {
1645         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning2);
1646         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt2, true);
1647 }
1648
1649 // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
1650 void VM_CL_te_lightning3 (void)
1651 {
1652         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning3);
1653         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt3, false);
1654 }
1655
1656 // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
1657 void VM_CL_te_beam (void)
1658 {
1659         VM_SAFEPARMCOUNT(3, VM_CL_te_beam);
1660         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_beam, false);
1661 }
1662
1663 // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
1664 void VM_CL_te_plasmaburn (void)
1665 {
1666         float           *pos;
1667         vec3_t          pos2;
1668         VM_SAFEPARMCOUNT(1, VM_CL_te_plasmaburn);
1669
1670         pos = PRVM_G_VECTOR(OFS_PARM0);
1671         CL_FindNonSolidLocation(pos, pos2, 4);
1672         CL_ParticleEffect(EFFECT_TE_PLASMABURN, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1673 }
1674
1675
1676 //====================================================================
1677 //DP_QC_GETSURFACE
1678
1679 extern void clippointtosurface(model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
1680
1681 static msurface_t *cl_getsurface(model_t *model, int surfacenum)
1682 {
1683         if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
1684                 return NULL;
1685         return model->data_surfaces + surfacenum + model->firstmodelsurface;
1686 }
1687
1688 // #434 float(entity e, float s) getsurfacenumpoints
1689 void VM_CL_getsurfacenumpoints(void)
1690 {
1691         model_t *model = CSQC_GetModelFromEntity(PRVM_G_EDICT(OFS_PARM0));
1692         msurface_t *surface;
1693         // return 0 if no such surface
1694         if (!model || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1695         {
1696                 PRVM_G_FLOAT(OFS_RETURN) = 0;
1697                 return;
1698         }
1699
1700         // note: this (incorrectly) assumes it is a simple polygon
1701         PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
1702 }
1703
1704 // #435 vector(entity e, float s, float n) getsurfacepoint
1705 void VM_CL_getsurfacepoint(void)
1706 {
1707         prvm_edict_t *ed;
1708         model_t *model;
1709         msurface_t *surface;
1710         int pointnum;
1711         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
1712         ed = PRVM_G_EDICT(OFS_PARM0);
1713         if (!(model = CSQC_GetModelFromEntity(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1714                 return;
1715         // note: this (incorrectly) assumes it is a simple polygon
1716         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
1717         if (pointnum < 0 || pointnum >= surface->num_vertices)
1718                 return;
1719         // FIXME: implement rotation/scaling
1720         VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
1721 }
1722
1723 // #436 vector(entity e, float s) getsurfacenormal
1724 void VM_CL_getsurfacenormal(void)
1725 {
1726         model_t *model;
1727         msurface_t *surface;
1728         vec3_t normal;
1729         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
1730         if (!(model = CSQC_GetModelFromEntity(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1731                 return;
1732         // FIXME: implement rotation/scaling
1733         // note: this (incorrectly) assumes it is a simple polygon
1734         // note: this only returns the first triangle, so it doesn't work very
1735         // well for curved surfaces or arbitrary meshes
1736         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);
1737         VectorNormalize(normal);
1738         VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
1739 }
1740
1741 // #437 string(entity e, float s) getsurfacetexture
1742 void VM_CL_getsurfacetexture(void)
1743 {
1744         model_t *model;
1745         msurface_t *surface;
1746         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1747         if (!(model = CSQC_GetModelFromEntity(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1748                 return;
1749         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
1750 }
1751
1752 // #438 float(entity e, vector p) getsurfacenearpoint
1753 void VM_CL_getsurfacenearpoint(void)
1754 {
1755         int surfacenum, best;
1756         vec3_t clipped, p;
1757         vec_t dist, bestdist;
1758         prvm_edict_t *ed;
1759         model_t *model = NULL;
1760         msurface_t *surface;
1761         vec_t *point;
1762         PRVM_G_FLOAT(OFS_RETURN) = -1;
1763         ed = PRVM_G_EDICT(OFS_PARM0);
1764         if(!(model = CSQC_GetModelFromEntity(ed)) || !model->num_surfaces)
1765                 return;
1766
1767         // FIXME: implement rotation/scaling
1768         point = PRVM_G_VECTOR(OFS_PARM1);
1769         VectorSubtract(point, ed->fields.client->origin, p);
1770         best = -1;
1771         bestdist = 1000000000;
1772         for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
1773         {
1774                 surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
1775                 // first see if the nearest point on the surface's box is closer than the previous match
1776                 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
1777                 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
1778                 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
1779                 dist = VectorLength2(clipped);
1780                 if (dist < bestdist)
1781                 {
1782                         // it is, check the nearest point on the actual geometry
1783                         clippointtosurface(model, surface, p, clipped);
1784                         VectorSubtract(clipped, p, clipped);
1785                         dist += VectorLength2(clipped);
1786                         if (dist < bestdist)
1787                         {
1788                                 // that's closer too, store it as the best match
1789                                 best = surfacenum;
1790                                 bestdist = dist;
1791                         }
1792                 }
1793         }
1794         PRVM_G_FLOAT(OFS_RETURN) = best;
1795 }
1796
1797 // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint
1798 void VM_CL_getsurfaceclippedpoint(void)
1799 {
1800         prvm_edict_t *ed;
1801         model_t *model;
1802         msurface_t *surface;
1803         vec3_t p, out;
1804         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
1805         ed = PRVM_G_EDICT(OFS_PARM0);
1806         if (!(model = CSQC_GetModelFromEntity(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1807                 return;
1808         // FIXME: implement rotation/scaling
1809         VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.client->origin, p);
1810         clippointtosurface(model, surface, p, out);
1811         // FIXME: implement rotation/scaling
1812         VectorAdd(out, ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
1813 }
1814
1815 // #443 void(entity e, entity tagentity, string tagname) setattachment
1816 void VM_CL_setattachment (void)
1817 {
1818         prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
1819         prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
1820         const char *tagname = PRVM_G_STRING(OFS_PARM2);
1821         prvm_eval_t *v;
1822         int modelindex;
1823         model_t *model;
1824
1825         if (e == prog->edicts)
1826         {
1827                 VM_Warning("setattachment: can not modify world entity\n");
1828                 return;
1829         }
1830         if (e->priv.server->free)
1831         {
1832                 VM_Warning("setattachment: can not modify free entity\n");
1833                 return;
1834         }
1835
1836         if (tagentity == NULL)
1837                 tagentity = prog->edicts;
1838
1839         v = PRVM_GETEDICTFIELDVALUE(e, csqc_fieldoff_tag_entity);
1840         if (v)
1841                 v->edict = PRVM_EDICT_TO_PROG(tagentity);
1842
1843         v = PRVM_GETEDICTFIELDVALUE(e, csqc_fieldoff_tag_index);
1844         if (v)
1845                 v->_float = 0;
1846         if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
1847         {
1848                 modelindex = (int)tagentity->fields.client->modelindex;
1849                 model = CSQC_GetModelByIndex(modelindex);
1850                 if (model)
1851                 {
1852                         v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.client->skin, tagname);
1853                         if (v->_float == 0)
1854                                 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);
1855                 }
1856                 else
1857                         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));
1858         }
1859 }
1860
1861 /////////////////////////////////////////
1862 // DP_MD3_TAGINFO extension coded by VorteX
1863
1864 int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
1865 {
1866         model_t *model = CSQC_GetModelFromEntity(e);
1867         if (model)
1868                 return Mod_Alias_GetTagIndexForName(model, (int)e->fields.client->skin, tagname);
1869         else
1870                 return -1;
1871 };
1872
1873 // Warnings/errors code:
1874 // 0 - normal (everything all-right)
1875 // 1 - world entity
1876 // 2 - free entity
1877 // 3 - null or non-precached model
1878 // 4 - no tags with requested index
1879 // 5 - runaway loop at attachment chain
1880 extern cvar_t cl_bob;
1881 extern cvar_t cl_bobcycle;
1882 extern cvar_t cl_bobup;
1883 int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
1884 {
1885         prvm_eval_t *val;
1886         int reqframe, attachloop;
1887         matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
1888         prvm_edict_t *attachent;
1889         model_t *model;
1890
1891         *out = identitymatrix; // warnings and errors return identical matrix
1892
1893         if (ent == prog->edicts)
1894                 return 1;
1895         if (ent->priv.server->free)
1896                 return 2;
1897
1898         model = CSQC_GetModelFromEntity(ent);
1899
1900         if(!model)
1901                 return 3;
1902
1903         if (ent->fields.client->frame >= 0 && ent->fields.client->frame < model->numframes && model->animscenes)
1904                 reqframe = model->animscenes[(int)ent->fields.client->frame].firstframe;
1905         else
1906                 reqframe = 0; // if model has wrong frame, engine automatically switches to model first frame
1907
1908         // get initial tag matrix
1909         if (tagindex)
1910         {
1911                 int ret = Mod_Alias_GetTagMatrix(model, reqframe, tagindex - 1, &tagmatrix);
1912                 if (ret)
1913                         return ret;
1914         }
1915         else
1916                 tagmatrix = identitymatrix;
1917
1918         if ((val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_tag_entity)) && val->edict)
1919         { // DP_GFX_QUAKE3MODELTAGS, scan all chain and stop on unattached entity
1920                 attachloop = 0;
1921                 do
1922                 {
1923                         attachent = PRVM_EDICT_NUM(val->edict); // to this it entity our entity is attached
1924                         val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_tag_index);
1925
1926                         model = CSQC_GetModelFromEntity(attachent);
1927
1928                         if (model && val->_float >= 1 && model->animscenes && attachent->fields.client->frame >= 0 && attachent->fields.client->frame < model->numframes)
1929                                 Mod_Alias_GetTagMatrix(model, model->animscenes[(int)attachent->fields.client->frame].firstframe, (int)val->_float - 1, &attachmatrix);
1930                         else
1931                                 attachmatrix = identitymatrix;
1932
1933                         // apply transformation by child entity matrix
1934                         val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_scale);
1935                         if (val->_float == 0)
1936                                 val->_float = 1;
1937                         Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], -ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], val->_float);
1938                         Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
1939                         Matrix4x4_Copy(&tagmatrix, out);
1940
1941                         // finally transformate by matrix of tag on parent entity
1942                         Matrix4x4_Concat(out, &attachmatrix, &tagmatrix);
1943                         Matrix4x4_Copy(&tagmatrix, out);
1944
1945                         ent = attachent;
1946                         attachloop += 1;
1947                         if (attachloop > 255) // prevent runaway looping
1948                                 return 5;
1949                 }
1950                 while ((val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_tag_entity)) && val->edict);
1951         }
1952
1953         // normal or RENDER_VIEWMODEL entity (or main parent entity on attach chain)
1954         val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_scale);
1955         if (val->_float == 0)
1956                 val->_float = 1;
1957         // Alias models have inverse pitch, bmodels can't have tags, so don't check for modeltype...
1958         Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], -ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], val->_float);
1959         Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
1960
1961         if ((val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_renderflags)) && (RF_VIEWMODEL & (int)val->_float))
1962         {// RENDER_VIEWMODEL magic
1963                 Matrix4x4_Copy(&tagmatrix, out);
1964
1965                 val = PRVM_GETEDICTFIELDVALUE(ent, csqc_fieldoff_scale);
1966                 if (val->_float == 0)
1967                         val->_float = 1;
1968
1969                 Matrix4x4_CreateFromQuakeEntity(&entitymatrix, csqc_origin[0], csqc_origin[1], csqc_origin[2], csqc_angles[0], csqc_angles[1], csqc_angles[2], val->_float);
1970                 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
1971
1972                 /*
1973                 // Cl_bob, ported from rendering code
1974                 if (ent->fields.client->health > 0 && cl_bob.value && cl_bobcycle.value)
1975                 {
1976                         double bob, cycle;
1977                         // LordHavoc: this code is *weird*, but not replacable (I think it
1978                         // should be done in QC on the server, but oh well, quake is quake)
1979                         // LordHavoc: figured out bobup: the time at which the sin is at 180
1980                         // degrees (which allows lengthening or squishing the peak or valley)
1981                         cycle = sv.time/cl_bobcycle.value;
1982                         cycle -= (int)cycle;
1983                         if (cycle < cl_bobup.value)
1984                                 cycle = sin(M_PI * cycle / cl_bobup.value);
1985                         else
1986                                 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
1987                         // bob is proportional to velocity in the xy plane
1988                         // (don't count Z, or jumping messes it up)
1989                         bob = sqrt(ent->fields.client->velocity[0]*ent->fields.client->velocity[0] + ent->fields.client->velocity[1]*ent->fields.client->velocity[1])*cl_bob.value;
1990                         bob = bob*0.3 + bob*0.7*cycle;
1991                         Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
1992                 }
1993                 */
1994         }
1995         return 0;
1996 }
1997
1998 // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
1999 void VM_CL_gettagindex (void)
2000 {
2001         prvm_edict_t *ent = PRVM_G_EDICT(OFS_PARM0);
2002         const char *tag_name = PRVM_G_STRING(OFS_PARM1);
2003         int modelindex, tag_index;
2004
2005         if (ent == prog->edicts)
2006         {
2007                 VM_Warning("gettagindex: can't affect world entity\n");
2008                 return;
2009         }
2010         if (ent->priv.server->free)
2011         {
2012                 VM_Warning("gettagindex: can't affect free entity\n");
2013                 return;
2014         }
2015
2016         modelindex = (int)ent->fields.client->modelindex;
2017         if(modelindex < 0)
2018                 modelindex = -(modelindex+1);
2019         tag_index = 0;
2020         if (modelindex <= 0 || modelindex >= MAX_MODELS)
2021                 Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2022         else
2023         {
2024                 tag_index = CL_GetTagIndex(ent, tag_name);
2025                 if (tag_index == 0)
2026                         Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2027         }
2028         PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2029 }
2030
2031 // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
2032 void VM_CL_gettaginfo (void)
2033 {
2034         prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
2035         int tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2036         matrix4x4_t tag_matrix;
2037         int returncode;
2038
2039         returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
2040         Matrix4x4_ToVectors(&tag_matrix, prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
2041
2042         switch(returncode)
2043         {
2044                 case 1:
2045                         VM_Warning("gettagindex: can't affect world entity\n");
2046                         break;
2047                 case 2:
2048                         VM_Warning("gettagindex: can't affect free entity\n");
2049                         break;
2050                 case 3:
2051                         Con_DPrintf("CL_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2052                         break;
2053                 case 4:
2054                         Con_DPrintf("CL_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2055                         break;
2056                 case 5:
2057                         Con_DPrintf("CL_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2058                         break;
2059         }
2060 }
2061
2062 //=================================================
2063 //[515]: here goes test/unfinished/etc.
2064
2065 //[515]: check if it is what it should be
2066 void VM_WasFreed (void)
2067 {
2068         prvm_edict_t    *e;
2069         VM_SAFEPARMCOUNT(1, VM_WasFreed);
2070
2071         e = PRVM_G_EDICT(OFS_PARM0);
2072         if (!e->priv.required->free || (e->priv.required->free && (e->priv.required->freetime < 2 || (*prog->time - e->priv.required->freetime) > 0.5 )))
2073                 PRVM_G_FLOAT(OFS_RETURN) = false;
2074         else
2075                 PRVM_G_FLOAT(OFS_RETURN) = true;
2076 }
2077
2078 void VM_CL_select_cube (void)
2079 {
2080         int             i;
2081         int             chain_of;
2082         float   *mins2, *maxs2;
2083         prvm_edict_t    *ent, *chain;
2084         vec3_t  mins1, maxs1;
2085
2086         VM_SAFEPARMCOUNT(2, VM_CL_select_cube);
2087
2088         // is the same like !(prog->flag & PRVM_FE_CHAIN) - even if the operator precedence is another
2089         if(!prog->flag & PRVM_FE_CHAIN)
2090                 PRVM_ERROR("VM_findchain: %s doesnt have a chain field !\n", PRVM_NAME);
2091
2092         chain_of = PRVM_ED_FindField("chain")->ofs;
2093         chain = prog->edicts;
2094
2095         mins2 = PRVM_G_VECTOR(OFS_PARM0);
2096         maxs2 = PRVM_G_VECTOR(OFS_PARM1);
2097
2098         ent = PRVM_NEXT_EDICT(prog->edicts);
2099         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
2100         {
2101                 if (ent->priv.required->free)
2102                         continue;
2103                 VectorCopy(ent->fields.client->origin, mins1);
2104                 VectorAdd(mins1, ent->fields.client->maxs, maxs1);
2105                 VectorAdd(mins1, ent->fields.client->mins, mins1);
2106                 if (mins1[0] > maxs2[0] || mins1[1] > maxs2[1] || mins1[2] > maxs2[2])
2107                         continue;
2108                 if (maxs1[0] < mins2[0] || maxs1[1] < mins2[1] || maxs1[2] < mins2[2])
2109                         continue;
2110                 PRVM_E_INT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain);
2111                 chain = ent;
2112         }
2113
2114         VM_RETURN_EDICT(chain);
2115 }
2116
2117 void VM_CL_select_super (void)
2118 {
2119 /*      int             i;
2120         int             chain_of;
2121         float   *v[8];
2122         prvm_edict_t    *ent, *chain;
2123         vec3_t  mins1, maxs1;
2124
2125         VM_SAFEPARMCOUNT(8, VM_findchain);
2126         for(i=0;i<8;i++)
2127                 v[i] = PRVM_G_VECTOR(OFS_PARM0+i*3);
2128
2129         // is the same like !(prog->flag & PRVM_FE_CHAIN) - even if the operator precedence is another
2130         if(!prog->flag & PRVM_FE_CHAIN)
2131                 PRVM_ERROR("VM_findchain: %s doesnt have a chain field !\n", PRVM_NAME);
2132
2133         chain_of = PRVM_ED_FindField("chain")->ofs;
2134         chain = prog->edicts;
2135
2136         mins2 = PRVM_G_VECTOR(OFS_PARM0);
2137         maxs2 = PRVM_G_VECTOR(OFS_PARM1);
2138
2139         ent = PRVM_NEXT_EDICT(prog->edicts);
2140         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
2141         {
2142                 if (ent->priv.required->free)
2143                         continue;
2144                 VectorCopy(ent->fields.client->origin, mins1);
2145                 VectorAdd(mins1, ent->fields.client->maxs, maxs1);
2146                 VectorAdd(mins1, ent->fields.client->mins, mins1);
2147                 if (mins1[0] > maxs2[0] || mins1[1] > maxs2[1] || mins1[2] > maxs2[2])
2148                         continue;
2149                 if (maxs1[0] < mins2[0] || maxs1[1] < mins2[1] || maxs1[2] < mins2[2])
2150                         continue;
2151                 PRVM_E_INT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain);
2152                 chain = ent;
2153         }
2154
2155         VM_RETURN_EDICT(chain);*/
2156 }
2157
2158 static int Is_Text_Color (char c, char t)
2159 {
2160         int a = 0;
2161         char c2 = c - (c & 128);
2162         char t2 = t - (t & 128);
2163
2164         if(c != STRING_COLOR_TAG && c2 != STRING_COLOR_TAG)             return 0;
2165         if(t >= '0' && t <= '9')                a = 1;
2166         if(t2 >= '0' && t2 <= '9')              a = 1;
2167 /*      if(t >= 'A' && t <= 'Z')                a = 2;
2168         if(t2 >= 'A' && t2 <= 'Z')              a = 2;
2169
2170         if(a == 1 && scr_colortext.integer > 0)
2171                 return 1;
2172         if(a == 2 && scr_multifonts.integer > 0)
2173                 return 2;
2174 */
2175         return a;
2176 }
2177
2178 void VM_uncolorstring (void) //#170
2179 {
2180         const char      *in;
2181         char            out[VM_STRINGTEMP_LENGTH];
2182         int                     k = 0, i = 0;
2183
2184         VM_SAFEPARMCOUNT(1, VM_uncolorstring);
2185         in = PRVM_G_STRING(OFS_PARM0);
2186         VM_CheckEmptyString (in);
2187
2188         while (in[k])
2189         {
2190                 if(in[k+1])
2191                 if(Is_Text_Color(in[k], in[k+1]) == 1/* || (in[k] == '&' && in[k+1] == 'r')*/)
2192                 {
2193                         k += 2;
2194                         continue;
2195                 }
2196                 out[i] = in[k];
2197                 ++k;
2198                 ++i;
2199         }
2200         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out);
2201 }
2202
2203 void VM_CL_selecttraceline (void)
2204 {
2205         float   *v1, *v2;
2206         int             ent, ignore, csqcents;
2207
2208         v1 = PRVM_G_VECTOR(OFS_PARM0);
2209         v2 = PRVM_G_VECTOR(OFS_PARM1);
2210         ignore = (int)PRVM_G_FLOAT(OFS_PARM2);
2211         csqcents = (int)PRVM_G_FLOAT(OFS_PARM3);
2212         ent = 0;
2213
2214         if (csqcents)
2215         {
2216                 VM_Warning("VM_CL_selecttraceline: csqcents flag not supported anymore, and this function is deprecated\n");
2217                 return;
2218         }
2219         prog->globals.client->trace_fraction = CL_SelectTraceLine(v1, v2, prog->globals.client->trace_endpos, prog->globals.client->trace_plane_normal, &ent, &cl.entities[ignore].render);
2220         PRVM_G_FLOAT(OFS_RETURN) = ent;
2221 }
2222
2223 void VM_charindex (void)
2224 {
2225         const char *s;
2226         s = PRVM_G_STRING(OFS_PARM0);
2227         if((unsigned)PRVM_G_FLOAT(OFS_PARM1) > strlen(s))
2228                 return;
2229         PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(int)PRVM_G_FLOAT(OFS_PARM1)];
2230 }
2231
2232 //#223 string(float c, ...) chr2str (FTE_STRINGS)
2233 void VM_chr2str (void)
2234 {
2235         char    t[128];
2236         int             i;
2237         for(i = 0;i < prog->argc && i < (int)sizeof(t) - 1;i++)
2238                 t[i] = (unsigned char)PRVM_G_FLOAT(OFS_PARM0+i*3);
2239         t[i] = 0;
2240         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
2241 }
2242
2243 //#228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
2244 void VM_strncmp (void)
2245 {
2246         const char *s1, *s2;
2247         VM_SAFEPARMCOUNT(1, VM_strncmp);
2248         s1 = PRVM_G_STRING(OFS_PARM0);
2249         s2 = PRVM_G_STRING(OFS_PARM1);
2250         PRVM_G_FLOAT(OFS_RETURN) = strncmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2));
2251 }
2252
2253 //============================================================================
2254 //============================================================================
2255
2256 prvm_builtin_t vm_cl_builtins[] = {
2257 0,  // to be consistent with the old vm
2258 VM_CL_makevectors,                      // #1 void(vector ang) makevectors
2259 VM_CL_setorigin,                        // #2 void(entity e, vector o) setorigin
2260 VM_CL_setmodel,                         // #3 void(entity e, string m) setmodel
2261 VM_CL_setsize,                          // #4 void(entity e, vector min, vector max) setsize
2262 0,
2263 VM_break,                                       // #6 void() break
2264 VM_random,                                      // #7 float() random
2265 VM_CL_sound,                            // #8 void(entity e, float chan, string samp) sound
2266 VM_normalize,                           // #9 vector(vector v) normalize
2267 VM_error,                                       // #10 void(string e) error
2268 VM_objerror,                            // #11 void(string e) objerror
2269 VM_vlen,                                        // #12 float(vector v) vlen
2270 VM_vectoyaw,                            // #13 float(vector v) vectoyaw
2271 VM_CL_spawn,                            // #14 entity() spawn
2272 VM_remove,                                      // #15 void(entity e) remove
2273 VM_CL_traceline,                        // #16 float(vector v1, vector v2, float tryents) traceline
2274 0,
2275 VM_find,                                        // #18 entity(entity start, .string fld, string match) find
2276 VM_CL_precache_sound,           // #19 void(string s) precache_sound
2277 VM_CL_precache_model,           // #20 void(string s) precache_model
2278 0,
2279 VM_CL_findradius,                       // #22 entity(vector org, float rad) findradius
2280 0,
2281 0,
2282 VM_dprint,                                      // #25 void(string s) dprint
2283 VM_ftos,                                        // #26 void(string s) ftos
2284 VM_vtos,                                        // #27 void(string s) vtos
2285 VM_coredump,                            // #28 void() coredump
2286 VM_traceon,                                     // #29 void() traceon
2287 VM_traceoff,                            // #30 void() traceoff
2288 VM_eprint,                                      // #31 void(entity e) eprint
2289 0,
2290 NULL,                                           // #33
2291 VM_CL_droptofloor,                      // #34 float() droptofloor
2292 VM_CL_lightstyle,                       // #35 void(float style, string value) lightstyle
2293 VM_rint,                                        // #36 float(float v) rint
2294 VM_floor,                                       // #37 float(float v) floor
2295 VM_ceil,                                        // #38 float(float v) ceil
2296 NULL,                                           // #39
2297 VM_CL_checkbottom,                      // #40 float(entity e) checkbottom
2298 VM_CL_pointcontents,            // #41 float(vector v) pointcontents
2299 NULL,                                           // #42
2300 VM_fabs,                                        // #43 float(float f) fabs
2301 0,
2302 VM_cvar,                                        // #45 float(string s) cvar
2303 VM_localcmd,                            // #46 void(string s) localcmd
2304 VM_nextent,                                     // #47 entity(entity e) nextent
2305 VM_CL_particle,                         // #48 void(vector o, vector d, float color, float count) particle
2306 VM_CL_changeyaw,                        // #49 void(entity ent, float ideal_yaw, float speed_yaw) ChangeYaw
2307 NULL,                                           // #50
2308 VM_vectoangles,                         // #51 vector(vector v) vectoangles
2309 0,                      // #52 void(float to, float f) WriteByte
2310 0,                      // #53 void(float to, float f) WriteChar
2311 0,                      // #54 void(float to, float f) WriteShort
2312 0,                      // #55 void(float to, float f) WriteLong
2313 0,                      // #56 void(float to, float f) WriteCoord
2314 0,                      // #57 void(float to, float f) WriteAngle
2315 0,                      // #58 void(float to, string s) WriteString
2316 0,
2317 VM_sin,                                         // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW)
2318 VM_cos,                                         // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW)
2319 VM_sqrt,                                        // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW)
2320 VM_CL_changepitch,                      // #63 void(entity ent, float ideal_pitch, float speed_pitch) changepitch (DP_QC_CHANGEPITCH)
2321 VM_CL_tracetoss,                        // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS)
2322 VM_etos,                                        // #65 string(entity ent) etos (DP_QC_ETOS)
2323 NULL,                                           // #66
2324 0,                                                              // #67
2325 0,                                                              // #68
2326 0,                                                              // #69
2327 0,                                                              // #70
2328 NULL,                                           // #71
2329 VM_cvar_set,                            // #72 void(string var, string val) cvar_set
2330 0,                                                              // #73
2331 VM_CL_ambientsound,                     // #74 void(vector pos, string samp, float vol, float atten) ambientsound
2332 VM_CL_precache_model,           // #75 string(string s) precache_model2
2333 VM_CL_precache_sound,           // #76 string(string s) precache_sound2
2334 0,                                                              // #77
2335 VM_chr,                                         // #78
2336 NULL,                                           // #79
2337 NULL,                                           // #80
2338 VM_stof,                                        // #81 float(string s) stof (FRIK_FILE)
2339 NULL,                                           // #82
2340 NULL,                                           // #83
2341 NULL,                                           // #84
2342 NULL,                                           // #85
2343 NULL,                                           // #86
2344 NULL,                                           // #87
2345 NULL,                                           // #88
2346 NULL,                                           // #89
2347 VM_CL_tracebox,                         // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
2348 VM_randomvec,                           // #91 vector() randomvec (DP_QC_RANDOMVEC)
2349 VM_CL_getlight,                         // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
2350 PF_registercvar,                        // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
2351 VM_min,                                         // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
2352 VM_max,                                         // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
2353 VM_bound,                                       // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
2354 VM_pow,                                         // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
2355 VM_findfloat,                           // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
2356 VM_checkextension,                      // #99 float(string s) checkextension (the basis of the extension system)
2357 NULL,                                           // #100
2358 NULL,                                           // #101
2359 NULL,                                           // #102
2360 NULL,                                           // #103
2361 NULL,                                           // #104
2362 NULL,                                           // #105
2363 NULL,                                           // #106
2364 NULL,                                           // #107
2365 NULL,                                           // #108
2366 NULL,                                           // #109
2367 VM_fopen,                                       // #110 float(string filename, float mode) fopen (FRIK_FILE)
2368 VM_fclose,                                      // #111 void(float fhandle) fclose (FRIK_FILE)
2369 VM_fgets,                                       // #112 string(float fhandle) fgets (FRIK_FILE)
2370 VM_fputs,                                       // #113 void(float fhandle, string s) fputs (FRIK_FILE)
2371 VM_strlen,                                      // #114 float(string s) strlen (FRIK_FILE)
2372 VM_strcat,                                      // #115 string(string s1, string s2) strcat (FRIK_FILE)
2373 VM_substring,                           // #116 string(string s, float start, float length) substring (FRIK_FILE)
2374 VM_stov,                                        // #117 vector(string) stov (FRIK_FILE)
2375 VM_strzone,                                     // #118 string(string s) strzone (FRIK_FILE)
2376 VM_strunzone,                           // #119 void(string s) strunzone (FRIK_FILE)
2377
2378 e10, e10, e10, e10, e10, e10, e10, e10,         // #120-199
2379 e10,    //#200-209
2380 0,      //#210
2381 0,      //#211
2382 0,      //#212
2383 0,      //#213
2384 0,      //#214
2385 0,      //#215
2386 0,      //#216
2387 0,      //#217
2388 VM_bitshift,                            //#218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
2389 0,      //#219
2390 0,      //#220
2391 0,      //#221
2392 VM_charindex,                           //#222 float(string str, float ofs) str2chr (FTE_STRINGS)
2393 VM_chr2str,                                     //#223 string(float c, ...) chr2str (FTE_STRINGS)
2394 0,      //#224
2395 0,      //#225
2396 0,      //#226
2397 0,      //#227
2398 VM_strncmp,                                     //#228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
2399 0,
2400 e10, e10, e10, e10, e10, e10, e10,      // #230-299
2401
2402 //======CSQC start=======//
2403 //3d world (buffer/buffering) operations
2404 VM_R_ClearScene,                        //#300 void() clearscene (EXT_CSQC)
2405 VM_R_AddEntities,                       //#301 void(float mask) addentities (EXT_CSQC)
2406 VM_R_AddEntity,                         //#302 void(entity ent) addentity (EXT_CSQC)
2407 VM_R_SetView,                           //#303 float(float property, ...) setproperty (EXT_CSQC)
2408 VM_R_RenderScene,                       //#304 void() renderscene (EXT_CSQC)
2409 VM_R_AddDynamicLight,           //#305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
2410 VM_R_PolygonBegin,                      //#306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
2411 VM_R_PolygonVertex,                     //#307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
2412 VM_R_PolygonEnd,                        //#308 void() R_EndPolygon
2413 0,                      //#309
2414
2415 //maths stuff that uses the current view settings
2416 VM_CL_unproject,                        //#310 vector (vector v) cs_unproject (EXT_CSQC)
2417 VM_CL_project,                          //#311 vector (vector v) cs_project (EXT_CSQC)
2418 0,                      //#312
2419 0,                      //#313
2420 0,                      //#314
2421
2422 //2d (immediate) operations
2423 VM_drawline,                            //#315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
2424 VM_iscachedpic,                         //#316 float(string name) iscachedpic (EXT_CSQC)
2425 VM_precache_pic,                        //#317 string(string name, float trywad) precache_pic (EXT_CSQC)
2426 VM_getimagesize,                        //#318 vector(string picname) draw_getimagesize (EXT_CSQC)
2427 VM_freepic,                                     //#319 void(string name) freepic (EXT_CSQC)
2428 VM_drawcharacter,                       //#320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
2429 VM_drawstring,                          //#321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
2430 VM_drawpic,                                     //#322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
2431 VM_drawfill,                            //#323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
2432 VM_drawsetcliparea,                     //#324 void(float x, float y, float width, float height) drawsetcliparea
2433 VM_drawresetcliparea,           //#325 void(void) drawresetcliparea
2434 0,                      //#326
2435 0,                      //#327
2436 0,                      //#328
2437 0,                      //#329
2438
2439 VM_CL_getstatf,                         //#330 float(float stnum) getstatf (EXT_CSQC)
2440 VM_CL_getstati,                         //#331 float(float stnum) getstati (EXT_CSQC)
2441 VM_CL_getstats,                         //#332 string(float firststnum) getstats (EXT_CSQC)
2442 VM_CL_setmodelindex,            //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
2443 VM_CL_modelnameforindex,        //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
2444 VM_CL_particleeffectnum,        //#335 float(string effectname) particleeffectnum (EXT_CSQC)
2445 VM_CL_trailparticles,           //#336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
2446 VM_CL_pointparticles,           //#337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
2447 VM_CL_centerprint,                      //#338 void(string s) cprint (EXT_CSQC)
2448 VM_print,                                       //#339 void(string s) print (EXT_CSQC)
2449 VM_keynumtostring,                      //#340 string(float keynum) keynumtostring (EXT_CSQC)
2450 VM_stringtokeynum,                      //#341 float(string keyname) stringtokeynum (EXT_CSQC)
2451 VM_CL_getkeybind,                       //#342 string(float keynum) getkeybind (EXT_CSQC)
2452 VM_CL_setcursormode,            //#343 void(float usecursor) setcursormode (EXT_CSQC)
2453 VM_getmousepos,                         //#344 vector() getmousepos (EXT_CSQC)
2454 VM_CL_getinputstate,            //#345 float(float framenum) getinputstate (EXT_CSQC)
2455 VM_CL_setsensitivityscale,      //#346 void(float sens) setsensitivityscaler (EXT_CSQC)
2456 VM_CL_runplayerphysics,         //#347 void() runstandardplayerphysics (EXT_CSQC)
2457 VM_CL_getplayerkey,                     //#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
2458 VM_CL_isdemo,                           //#349 float() isdemo (EXT_CSQC)
2459 VM_isserver,                            //#350 float() isserver (EXT_CSQC)
2460 VM_CL_setlistener,                      //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
2461 VM_CL_registercmd,                      //#352 void(string cmdname) registercommand (EXT_CSQC)
2462 VM_WasFreed,                            //#353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
2463 VM_CL_playernum,                        //#354 float() playernum
2464 VM_CL_onground,                         //#355 float() cl_onground (EXT_CSQC)
2465 VM_charindex,                           //#356 float(string s, float num) charindex
2466 VM_CL_selecttraceline,          //#357 float(vector start, vector end, float ignore, float csqcents) selecttraceline
2467 0,                      //#358
2468 0,                      //#359
2469 VM_CL_ReadByte,                         //#360 float() readbyte (EXT_CSQC)
2470 VM_CL_ReadChar,                         //#361 float() readchar (EXT_CSQC)
2471 VM_CL_ReadShort,                        //#362 float() readshort (EXT_CSQC)
2472 VM_CL_ReadLong,                         //#363 float() readlong (EXT_CSQC)
2473 VM_CL_ReadCoord,                        //#364 float() readcoord (EXT_CSQC)
2474 VM_CL_ReadAngle,                        //#365 float() readangle (EXT_CSQC)
2475 VM_CL_ReadString,                       //#366 string() readstring (EXT_CSQC)
2476 VM_CL_ReadFloat,                        //#367 float() readfloat (EXT_CSQC)
2477 0,                      //#368
2478 0,                      //#369
2479 0,                      //#370
2480 0,                      //#371
2481 0,                      //#372
2482 0,                      //#373
2483 0,                      //#374
2484 0,                      //#375
2485 0,                      //#376
2486 0,                      //#377
2487 0,                      //#378
2488 0,                      //#379
2489 0,                      //#380
2490 0,                      //#381
2491 0,                      //#382
2492 0,                      //#383
2493 0,                      //#384
2494 0,                      //#385
2495 0,                      //#386
2496 0,                      //#387
2497 0,                      //#388
2498 0,                      //#389
2499 0,                      //#390
2500 0,                      //#391
2501 0,                      //#392
2502 0,                      //#393
2503 0,                      //#394
2504 0,                      //#395
2505 0,                      //#396
2506 0,                      //#397
2507 0,                      //#398
2508 0,                      //#399
2509 //=========CSQC end========//
2510
2511 VM_copyentity,                                  // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
2512 0,
2513 VM_findchain,                                   // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
2514 VM_findchainfloat,                              // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
2515 VM_CL_effect,                                   // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
2516 VM_CL_te_blood,                                 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
2517 VM_CL_te_bloodshower,                   // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
2518 VM_CL_te_explosionrgb,                  // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
2519 VM_CL_te_particlecube,                  // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
2520 VM_CL_te_particlerain,                  // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
2521 VM_CL_te_particlesnow,                  // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
2522 VM_CL_te_spark,                                 // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
2523 VM_CL_te_gunshotquad,                   // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
2524 VM_CL_te_spikequad,                             // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
2525 VM_CL_te_superspikequad,                // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
2526 VM_CL_te_explosionquad,                 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
2527 VM_CL_te_smallflash,                    // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
2528 VM_CL_te_customflash,                   // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
2529 VM_CL_te_gunshot,                               // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
2530 VM_CL_te_spike,                                 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
2531 VM_CL_te_superspike,                    // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
2532 VM_CL_te_explosion,                             // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
2533 VM_CL_te_tarexplosion,                  // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
2534 VM_CL_te_wizspike,                              // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
2535 VM_CL_te_knightspike,                   // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
2536 VM_CL_te_lavasplash,                    // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
2537 VM_CL_te_teleport,                              // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
2538 VM_CL_te_explosion2,                    // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
2539 VM_CL_te_lightning1,                    // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
2540 VM_CL_te_lightning2,                    // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
2541 VM_CL_te_lightning3,                    // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
2542 VM_CL_te_beam,                                  // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
2543 VM_vectorvectors,                               // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
2544 VM_CL_te_plasmaburn,                    // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
2545 VM_CL_getsurfacenumpoints,              // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
2546 VM_CL_getsurfacepoint,                  // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
2547 VM_CL_getsurfacenormal,                 // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
2548 VM_CL_getsurfacetexture,                // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
2549 VM_CL_getsurfacenearpoint,              // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
2550 VM_CL_getsurfaceclippedpoint,   // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
2551 0,                                                                      // #440
2552 VM_tokenize,                            // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
2553 VM_argv,                                        // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
2554 VM_CL_setattachment,            // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
2555 VM_search_begin,                        // #444 float(string pattern, float caseinsensitive, float quiet) search_begin (DP_FS_SEARCH)
2556 VM_search_end,                          // #445 void(float handle) search_end (DP_FS_SEARCH)
2557 VM_search_getsize,                      // #446 float(float handle) search_getsize (DP_FS_SEARCH)
2558 VM_search_getfilename,          // #447 string(float handle, float num) search_getfilename (DP_FS_SEARCH)
2559 VM_cvar_string,                         // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
2560 VM_findflags,                           // #449 entity(entity start, .float fld, float match) findflags (DP_QC_FINDFLAGS)
2561 VM_findchainflags,                      // #450 entity(.float fld, float match) findchainflags (DP_QC_FINDCHAINFLAGS)
2562 VM_CL_gettagindex,                      // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
2563 VM_CL_gettaginfo,                       // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
2564 0,                                                              // #453
2565 0,                                                              // #454
2566 0,                                                              // #455
2567 NULL,                                           // #456
2568 NULL,                                           // #457
2569 NULL,                                           // #458
2570 NULL,                                           // #459
2571 VM_buf_create,                          // #460 float() buf_create (DP_QC_STRINGBUFFERS)
2572 VM_buf_del,                                     // #461 void(float bufhandle) buf_del (DP_QC_STRINGBUFFERS)
2573 VM_buf_getsize,                         // #462 float(float bufhandle) buf_getsize (DP_QC_STRINGBUFFERS)
2574 VM_buf_copy,                            // #463 void(float bufhandle_from, float bufhandle_to) buf_copy (DP_QC_STRINGBUFFERS)
2575 VM_buf_sort,                            // #464 void(float bufhandle, float sortpower, float backward) buf_sort (DP_QC_STRINGBUFFERS)
2576 VM_buf_implode,                         // #465 string(float bufhandle, string glue) buf_implode (DP_QC_STRINGBUFFERS)
2577 VM_bufstr_get,                          // #466 string(float bufhandle, float string_index) bufstr_get (DP_QC_STRINGBUFFERS)
2578 VM_bufstr_set,                          // #467 void(float bufhandle, float string_index, string str) bufstr_set (DP_QC_STRINGBUFFERS)
2579 VM_bufstr_add,                          // #468 float(float bufhandle, string str, float order) bufstr_add (DP_QC_STRINGBUFFERS)
2580 VM_bufstr_free,                         // #469 void(float bufhandle, float string_index) bufstr_free (DP_QC_STRINGBUFFERS)
2581 NULL,                                           // #470
2582 VM_asin,                                        // #471 float(float s) VM_asin (DP_QC_ASINACOSATANATAN2TAN)
2583 VM_acos,                                        // #472 float(float c) VM_acos (DP_QC_ASINACOSATANATAN2TAN)
2584 VM_atan,                                        // #473 float(float t) VM_atan (DP_QC_ASINACOSATANATAN2TAN)
2585 VM_atan2,                                       // #474 float(float c, float s) VM_atan2 (DP_QC_ASINACOSATANATAN2TAN)
2586 VM_tan,                                         // #475 float(float a) VM_tan (DP_QC_ASINACOSATANATAN2TAN)
2587 VM_strlennocol,                         // #476 float(string s) : DRESK - String Length (not counting color codes) (DP_QC_STRINGCOLORFUNCTIONS)
2588 VM_strdecolorize,                       // #477 string(string s) : DRESK - Decolorized String (DP_QC_STRINGCOLORFUNCTIONS)
2589 VM_strftime,                            // #478 string(float uselocaltime, string format, ...) (DP_QC_STRFTIME)
2590 NULL,                                           // #479
2591 e10, e10                        // #480-499 (LordHavoc)
2592 };
2593
2594 const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
2595
2596 void VM_CL_Cmd_Init(void)
2597 {
2598 }
2599
2600 void VM_CL_Cmd_Reset(void)
2601 {
2602 }
2603