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