prvm_cmds.c

   1 // AK
   2 // Basically every vm builtin cmd should be in here.
   3 // All 3 builtin and extension lists can be found here
   4 // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
   5 // also applies here
   6
   7 #include "quakedef.h"
   8
   9 #include "prvm_cmds.h"
  10 #include "libcurl.h"
  11 #include <time.h>
  12
  13 #include "cl_collision.h"
  14 #include "clvm_cmds.h"
  15 #include "csprogs.h"
  16 #include "ft2.h"
  17 #include "mdfour.h"
  18
  19 extern cvar_t prvm_backtraceforwarnings;
  20 #ifdef USEODE
  21 extern dllhandle_t ode_dll;
  22 #endif
  23
  24 // LadyHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
  25 void VM_Warning(prvm_prog_t *prog, const char *fmt, ...)
  26 {
  27         va_list argptr;
  28         char msg[MAX_INPUTLINE];
  29         static double recursive = -1;
  30         int outfd = sys.outfd;
  31
  32         // set output to stderr
  33         sys.outfd = fileno(stderr);
  34
  35         va_start(argptr,fmt);
  36         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
  37         va_end(argptr);
  38
  39         Con_Printf(CON_WARN "%s VM warning: %s", prog->name, msg);
  40
  41         // TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
  42         if(prvm_backtraceforwarnings.integer && recursive != host.realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
  43         {
  44                 recursive = host.realtime;
  45                 PRVM_PrintState(prog, 0);
  46                 recursive = -1;
  47         }
  48
  49         // restore configured outfd
  50         sys.outfd = outfd;
  51 }
  52
  53
  54 //============================================================================
  55 // Common
  56
  57 // TODO DONE: move vm_files and vm_fssearchlist to prvm_prog_t struct
  58 // TODO: move vm_files and vm_fssearchlist back [9/13/2006 Black]
  59 // TODO: (move vm_files and vm_fssearchlist to prvm_prog_t struct again) [2007-01-23 LadyHavoc]
  60 // TODO: will this war ever end? [2007-01-23 LadyHavoc]
  61
  62 void VM_CheckEmptyString(prvm_prog_t *prog, const char *s)
  63 {
  64         if (ISWHITESPACE(s[0]))
  65                 prog->error_cmd("%s: Bad string", prog->name);
  66 }
  67
  68 qbool PRVM_ConsoleCommand (prvm_prog_t *prog, const char *text, int *func, qbool preserve_self, int curself, double ptime, qbool prog_loaded, const char *error_message)
  69 {
  70         int restorevm_tempstringsbuf_cursize;
  71         int save_self = 0; // hush compiler warning
  72         qbool r = false;
  73
  74         if(!prog_loaded)
  75                 return false;
  76
  77         if(func)
  78         {
  79                 if(preserve_self)
  80                         save_self = PRVM_gameglobaledict(self);
  81                 if(ptime)
  82                         PRVM_gameglobalfloat(time) = ptime;
  83                 PRVM_gameglobaledict(self) = curself;
  84                 restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
  85                 PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, text);
  86                 prog->ExecuteProgram(prog, *func, error_message);
  87                 prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
  88                 if(preserve_self)
  89                         PRVM_gameglobaledict(self) = save_self;
  90                 r = (int) PRVM_G_FLOAT(OFS_RETURN) != 0;
  91         }
  92
  93         return r;
  94 }
  95
  96 void VM_GenerateFrameGroupBlend(prvm_prog_t *prog, framegroupblend_t *framegroupblend, const prvm_edict_t *ed)
  97 {
  98         // self.frame is the interpolation target (new frame)
  99         // self.frame1time is the animation base time for the interpolation target
 100         // self.frame2 is the interpolation start (previous frame)
 101         // self.frame2time is the animation base time for the interpolation start
 102         // self.lerpfrac is the interpolation strength for self.frame2
 103         // self.lerpfrac3 is the interpolation strength for self.frame3
 104         // self.lerpfrac4 is the interpolation strength for self.frame4
 105         // pitch angle on a player model where the animator set up 5 sets of
 106         // animations and the csqc simply lerps between sets)
 107         framegroupblend[0].frame = (int) PRVM_gameedictfloat(ed, frame     );
 108         framegroupblend[1].frame = (int) PRVM_gameedictfloat(ed, frame2    );
 109         framegroupblend[2].frame = (int) PRVM_gameedictfloat(ed, frame3    );
 110         framegroupblend[3].frame = (int) PRVM_gameedictfloat(ed, frame4    );
 111         framegroupblend[0].start =       PRVM_gameedictfloat(ed, frame1time);
 112         framegroupblend[1].start =       PRVM_gameedictfloat(ed, frame2time);
 113         framegroupblend[2].start =       PRVM_gameedictfloat(ed, frame3time);
 114         framegroupblend[3].start =       PRVM_gameedictfloat(ed, frame4time);
 115         framegroupblend[1].lerp  =       PRVM_gameedictfloat(ed, lerpfrac  );
 116         framegroupblend[2].lerp  =       PRVM_gameedictfloat(ed, lerpfrac3 );
 117         framegroupblend[3].lerp  =       PRVM_gameedictfloat(ed, lerpfrac4 );
 118         // assume that the (missing) lerpfrac1 is whatever remains after lerpfrac2+lerpfrac3+lerpfrac4 are summed
 119         framegroupblend[0].lerp = 1 - framegroupblend[1].lerp - framegroupblend[2].lerp - framegroupblend[3].lerp;
 120 }
 121
 122 // LadyHavoc: quite tempting to break apart this function to reuse the
 123 //            duplicated code, but I suspect it is better for performance
 124 //            this way
 125 void VM_FrameBlendFromFrameGroupBlend(frameblend_t *frameblend, const framegroupblend_t *framegroupblend, const model_t *model, double curtime)
 126 {
 127         int sub2, numframes, f, i, k;
 128         int isfirstframegroup = true;
 129         int nolerp;
 130         double sublerp, lerp, d;
 131         const animscene_t *scene;
 132         const framegroupblend_t *g;
 133         frameblend_t *blend = frameblend;
 134
 135         memset(blend, 0, MAX_FRAMEBLENDS * sizeof(*blend));
 136
 137         // rpolzer: Not testing isanimated here - a model might have
 138         // "animations" that move no vertices (but only bones), thus rendering
 139         // may assume it's not animated while processing can't.
 140         if (!model)
 141         {
 142                 blend[0].lerp = 1;
 143                 return;
 144         }
 145
 146         nolerp = ((model->type == mod_sprite) ? !r_lerpsprites.integer : !r_lerpmodels.integer) || (model->nolerp == true);
 147         numframes = model->numframes;
 148         for (k = 0, g = framegroupblend;k < MAX_FRAMEGROUPBLENDS;k++, g++)
 149         {
 150                 f = g->frame;
 151                 if ((unsigned int)f >= (unsigned int)numframes)
 152                 {
 153                         if (developer_extra.integer)
 154                                 Con_DPrintf("VM_FrameBlendFromFrameGroupBlend: no such frame %d in model %s\n", f, model->name);
 155                         f = 0;
 156                 }
 157                 d = lerp = g->lerp;
 158                 if (lerp <= 0)
 159                         continue;
 160                 if (nolerp)
 161                 {
 162                         if (isfirstframegroup)
 163                         {
 164                                 d = lerp = 1;
 165                                 isfirstframegroup = false;
 166                         }
 167                         else
 168                                 continue;
 169                 }
 170                 if (model->animscenes)
 171                 {
 172                         scene = model->animscenes + f;
 173                         f = scene->firstframe;
 174                         if (scene->framecount > 1)
 175                         {
 176                                 // this code path is only used on .zym models and torches
 177                                 sublerp = scene->framerate * (curtime - g->start);
 178                                 f = (int) floor(sublerp);
 179                                 sublerp -= f;
 180                                 sub2 = f + 1;
 181                                 if (sublerp < (1.0 / 65536.0f))
 182                                         sublerp = 0;
 183                                 if (sublerp > (65535.0f / 65536.0f))
 184                                         sublerp = 1;
 185                                 if (nolerp)
 186                                         sublerp = 0;
 187                                 if (scene->loop)
 188                                 {
 189                                         f = (f % scene->framecount);
 190                                         sub2 = (sub2 % scene->framecount);
 191                                 }
 192                                 f = bound(0, f, (scene->framecount - 1)) + scene->firstframe;
 193                                 sub2 = bound(0, sub2, (scene->framecount - 1)) + scene->firstframe;
 194                                 d = sublerp * lerp;
 195                                 // two framelerps produced from one animation
 196                                 if (d > 0)
 197                                 {
 198                                         for (i = 0;i < MAX_FRAMEBLENDS;i++)
 199                                         {
 200                                                 if (blend[i].lerp <= 0 || blend[i].subframe == sub2)
 201                                                 {
 202                                                         blend[i].subframe = sub2;
 203                                                         blend[i].lerp += d;
 204                                                         break;
 205                                                 }
 206                                         }
 207                                 }
 208                                 d = (1 - sublerp) * lerp;
 209                         }
 210                 }
 211                 if (d > 0)
 212                 {
 213                         for (i = 0;i < MAX_FRAMEBLENDS;i++)
 214                         {
 215                                 if (blend[i].lerp <= 0 || blend[i].subframe == f)
 216                                 {
 217                                         blend[i].subframe = f;
 218                                         blend[i].lerp += d;
 219                                         break;
 220                                 }
 221                         }
 222                 }
 223         }
 224 }
 225
 226 void VM_UpdateEdictSkeleton(prvm_prog_t *prog, prvm_edict_t *ed, const model_t *edmodel, const frameblend_t *frameblend)
 227 {
 228         if (ed->priv.server->skeleton.model != edmodel)
 229         {
 230                 VM_RemoveEdictSkeleton(prog, ed);
 231                 ed->priv.server->skeleton.model = edmodel;
 232         }
 233         if (!ed->priv.server->skeleton.model || !ed->priv.server->skeleton.model->num_bones)
 234         {
 235                 if(ed->priv.server->skeleton.relativetransforms)
 236                         Mem_Free(ed->priv.server->skeleton.relativetransforms);
 237                 ed->priv.server->skeleton.relativetransforms = NULL;
 238                 return;
 239         }
 240
 241         {
 242                 int skeletonindex = -1;
 243                 skeleton_t *skeleton;
 244                 skeletonindex = (int)PRVM_gameedictfloat(ed, skeletonindex) - 1;
 245                 if (skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones)
 246                 {
 247                         // custom skeleton controlled by the game (FTE_CSQC_SKELETONOBJECTS)
 248                         if (!ed->priv.server->skeleton.relativetransforms)
 249                                 ed->priv.server->skeleton.relativetransforms = (matrix4x4_t *)Mem_Alloc(prog->progs_mempool, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
 250                         memcpy(ed->priv.server->skeleton.relativetransforms, skeleton->relativetransforms, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
 251                 }
 252                 else
 253                 {
 254                         if(ed->priv.server->skeleton.relativetransforms)
 255                                 Mem_Free(ed->priv.server->skeleton.relativetransforms);
 256                         ed->priv.server->skeleton.relativetransforms = NULL;
 257                 }
 258         }
 259 }
 260
 261 void VM_RemoveEdictSkeleton(prvm_prog_t *prog, prvm_edict_t *ed)
 262 {
 263         if (ed->priv.server->skeleton.relativetransforms)
 264                 Mem_Free(ed->priv.server->skeleton.relativetransforms);
 265         memset(&ed->priv.server->skeleton, 0, sizeof(ed->priv.server->skeleton));
 266 }
 267
 268
 269
 270
 271 //============================================================================
 272 //BUILT-IN FUNCTIONS
 273
 274 void VM_VarString(prvm_prog_t *prog, int first, char *out, int outlength)
 275 {
 276         int i;
 277         const char *s;
 278         char *outend;
 279
 280         outend = out + outlength - 1;
 281         for (i = first;i < prog->argc && out < outend;i++)
 282         {
 283                 s = PRVM_G_STRING((OFS_PARM0+i*3));
 284                 while (out < outend && *s)
 285                         *out++ = *s++;
 286         }
 287         *out++ = 0;
 288 }
 289
 290 /*
 291 =================
 292 VM_checkextension
 293
 294 returns true if the extension is supported by the server
 295
 296 checkextension(extensionname)
 297 =================
 298 */
 299
 300 // kind of helper function
 301 static qbool checkextension(prvm_prog_t *prog, const char *name)
 302 {
 303         const char **e;
 304
 305         for (e = prog->extensionstring;*e;e++)
 306         {
 307                 if(!strcasecmp(*e, name))
 308                 {
 309 #ifdef USEODE
 310                         // special sheck for ODE
 311                         if (!strncasecmp("DP_PHYSICS_ODE", name, 14))
 312                         {
 313 #ifndef LINK_TO_LIBODE
 314                                 return ode_dll ? true : false;
 315 #else
 316 #ifdef LINK_TO_LIBODE
 317                                 return true;
 318 #else
 319                                 return false;
 320 #endif
 321 #endif
 322                         }
 323 #endif
 324
 325                         // special sheck for d0_blind_id
 326                         if (!strcasecmp("DP_CRYPTO", name))
 327                                 return Crypto_Available();
 328                         if (!strcasecmp("DP_QC_DIGEST_SHA256", name))
 329                                 return Crypto_Available();
 330
 331                         // special shreck for libcurl
 332                         if (!strcasecmp("DP_QC_URI_GET", name) || !strcasecmp("DP_QC_URI_POST", name))
 333                                 return Curl_Available();
 334
 335                         return true;
 336                 }
 337         }
 338         return false;
 339 }
 340
 341 void VM_checkextension(prvm_prog_t *prog)
 342 {
 343         VM_SAFEPARMCOUNT(1,VM_checkextension);
 344
 345         PRVM_G_FLOAT(OFS_RETURN) = checkextension(prog, PRVM_G_STRING(OFS_PARM0));
 346 }
 347
 348 /*
 349 =================
 350 VM_error
 351
 352 This is a TERMINAL error, which will kill off the entire prog.
 353 Dumps self.
 354
 355 error(value)
 356 =================
 357 */
 358 void VM_error(prvm_prog_t *prog)
 359 {
 360         prvm_edict_t    *ed;
 361         char string[VM_STRINGTEMP_LENGTH];
 362
 363         VM_VarString(prog, 0, string, sizeof(string));
 364         Con_Printf(CON_ERROR "======%s ERROR in %s:\n%s\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
 365         ed = PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self));
 366         PRVM_ED_Print(prog, ed, NULL);
 367
 368         prog->error_cmd("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
 369 }
 370
 371 /*
 372 =================
 373 VM_objerror
 374
 375 Dumps out self, then an error message.  The program is aborted and self is
 376 removed, but the level can continue.
 377
 378 objerror(value)
 379 =================
 380 */
 381 void VM_objerror(prvm_prog_t *prog)
 382 {
 383         prvm_edict_t    *ed;
 384         char string[VM_STRINGTEMP_LENGTH];
 385
 386         VM_VarString(prog, 0, string, sizeof(string));
 387         Con_Printf(CON_ERROR "======OBJECT ERROR======\n"); // , prog->name, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
 388         ed = PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self));
 389         PRVM_ED_Print(prog, ed, NULL);
 390         PRVM_ED_Free (prog, ed);
 391         Con_Printf(CON_ERROR "%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
 392 }
 393
 394 /*
 395 =================
 396 VM_print
 397
 398 print to console
 399
 400 print(...[string])
 401 =================
 402 */
 403 void VM_print(prvm_prog_t *prog)
 404 {
 405         char string[VM_STRINGTEMP_LENGTH];
 406
 407         VM_VarString(prog, 0, string, sizeof(string));
 408         Con_Print(string);
 409 }
 410
 411 /*
 412 =================
 413 VM_bprint
 414
 415 broadcast print to everyone on server
 416
 417 bprint(...[string])
 418 =================
 419 */
 420 void VM_bprint(prvm_prog_t *prog)
 421 {
 422         char string[VM_STRINGTEMP_LENGTH];
 423
 424         if(!sv.active)
 425         {
 426                 VM_Warning(prog, "VM_bprint: game is not server(%s) !\n", prog->name);
 427                 return;
 428         }
 429
 430         VM_VarString(prog, 0, string, sizeof(string));
 431         SV_BroadcastPrint(string);
 432 }
 433
 434 /*
 435 =================
 436 VM_sprint (menu & client but only if server.active == true)
 437
 438 single print to a specific client
 439
 440 sprint(float clientnum,...[string])
 441 =================
 442 */
 443 void VM_sprint(prvm_prog_t *prog)
 444 {
 445         client_t        *client;
 446         int                     clientnum;
 447         char string[VM_STRINGTEMP_LENGTH];
 448
 449         VM_SAFEPARMCOUNTRANGE(1, 8, VM_sprint);
 450
 451         //find client for this entity
 452         clientnum = (int)PRVM_G_FLOAT(OFS_PARM0);
 453         if (!sv.active  || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
 454         {
 455                 VM_Warning(prog, "VM_sprint: %s: invalid client or server is not active !\n", prog->name);
 456                 return;
 457         }
 458
 459         client = svs.clients + clientnum;
 460         if (!client->netconnection)
 461                 return;
 462
 463         VM_VarString(prog, 1, string, sizeof(string));
 464         MSG_WriteChar(&client->netconnection->message,svc_print);
 465         MSG_WriteString(&client->netconnection->message, string);
 466 }
 467
 468 /*
 469 =================
 470 VM_centerprint
 471
 472 single print to the screen
 473
 474 centerprint(value)
 475 =================
 476 */
 477 void VM_centerprint(prvm_prog_t *prog)
 478 {
 479         char string[VM_STRINGTEMP_LENGTH];
 480
 481         VM_SAFEPARMCOUNTRANGE(1, 8, VM_centerprint);
 482         VM_VarString(prog, 0, string, sizeof(string));
 483         SCR_CenterPrint(string);
 484 }
 485
 486 /*
 487 =================
 488 VM_normalize
 489
 490 vector normalize(vector)
 491 =================
 492 */
 493 void VM_normalize(prvm_prog_t *prog)
 494 {
 495         prvm_vec_t      *value1;
 496         vec3_t  newvalue;
 497         double  f;
 498
 499         VM_SAFEPARMCOUNT(1,VM_normalize);
 500
 501         value1 = PRVM_G_VECTOR(OFS_PARM0);
 502
 503         f = VectorLength2(value1);
 504         if (f)
 505         {
 506                 f = 1.0 / sqrt(f);
 507                 VectorScale(value1, f, newvalue);
 508         }
 509         else
 510                 VectorClear(newvalue);
 511
 512         VectorCopy (newvalue, PRVM_G_VECTOR(OFS_RETURN));
 513 }
 514
 515 /*
 516 =================
 517 VM_vlen
 518
 519 scalar vlen(vector)
 520 =================
 521 */
 522 void VM_vlen(prvm_prog_t *prog)
 523 {
 524         VM_SAFEPARMCOUNT(1,VM_vlen);
 525         PRVM_G_FLOAT(OFS_RETURN) = VectorLength(PRVM_G_VECTOR(OFS_PARM0));
 526 }
 527
 528 /*
 529 =================
 530 VM_vectoyaw
 531
 532 float vectoyaw(vector)
 533 =================
 534 */
 535 void VM_vectoyaw(prvm_prog_t *prog)
 536 {
 537         prvm_vec_t      *value1;
 538         prvm_vec_t      yaw;
 539
 540         VM_SAFEPARMCOUNT(1,VM_vectoyaw);
 541
 542         value1 = PRVM_G_VECTOR(OFS_PARM0);
 543
 544         if (value1[1] == 0 && value1[0] == 0)
 545                 yaw = 0;
 546         else
 547         {
 548                 yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
 549                 if (yaw < 0)
 550                         yaw += 360;
 551         }
 552
 553         PRVM_G_FLOAT(OFS_RETURN) = yaw;
 554 }
 555
 556
 557 /*
 558 =================
 559 VM_vectoangles
 560
 561 vector vectoangles(vector[, vector])
 562 =================
 563 */
 564 void VM_vectoangles(prvm_prog_t *prog)
 565 {
 566         vec3_t result, forward, up;
 567         VM_SAFEPARMCOUNTRANGE(1, 2,VM_vectoangles);
 568
 569         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), forward);
 570         if (prog->argc >= 2)
 571         {
 572                 VectorCopy(PRVM_G_VECTOR(OFS_PARM1), up);
 573                 AnglesFromVectors(result, forward, up, true);
 574         }
 575         else
 576                 AnglesFromVectors(result, forward, NULL, true);
 577         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
 578 }
 579
 580 /*
 581 =================
 582 VM_random
 583
 584 Returns a random number > 0 and < 1
 585
 586 float random()
 587 =================
 588 */
 589 void VM_random(prvm_prog_t *prog)
 590 {
 591         VM_SAFEPARMCOUNT(0,VM_random);
 592
 593         PRVM_G_FLOAT(OFS_RETURN) = lhrandom(0, 1);
 594 }
 595
 596 /*
 597 =========
 598 VM_localsound
 599
 600 localsound(string sample, float chan, float vol)
 601 =========
 602 */
 603 void VM_localsound(prvm_prog_t *prog)
 604 {
 605         const char *s;
 606         float chan, vol;
 607
 608         VM_SAFEPARMCOUNTRANGE(1, 3,VM_localsound);
 609
 610         s = PRVM_G_STRING(OFS_PARM0);
 611         if(prog->argc == 3)
 612         {
 613                 chan = PRVM_G_FLOAT(OFS_PARM1);
 614                 vol = PRVM_G_FLOAT(OFS_PARM2) == 0 ? 1 : PRVM_G_FLOAT(OFS_PARM2);
 615                 if(!S_LocalSoundEx(s, chan, vol))
 616                 {
 617                         PRVM_G_FLOAT(OFS_RETURN) = -4;
 618                         VM_Warning(prog, "VM_localsound: Failed to play %s for %s !\n", s, prog->name);
 619                         return;
 620                 }
 621         }
 622         else if(!S_LocalSound (s))
 623         {
 624                 PRVM_G_FLOAT(OFS_RETURN) = -4;
 625                 VM_Warning(prog, "VM_localsound: Failed to play %s for %s !\n", s, prog->name);
 626                 return;
 627         }
 628
 629         PRVM_G_FLOAT(OFS_RETURN) = 1;
 630 }
 631
 632 /*
 633 =================
 634 VM_break
 635
 636 break()
 637 =================
 638 */
 639 void VM_break(prvm_prog_t *prog)
 640 {
 641         prog->error_cmd("%s: break statement", prog->name);
 642 }
 643
 644 //============================================================================
 645
 646 /*
 647 =================
 648 VM_localcmd_local
 649
 650 Sends text over to the client's execution buffer
 651
 652 [localcmd (string, ...) or]
 653 cmd (string, ...)
 654 =================
 655 */
 656 void VM_localcmd_local(prvm_prog_t *prog)
 657 {
 658         char string[VM_STRINGTEMP_LENGTH];
 659         VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_local);
 660         VM_VarString(prog, 0, string, sizeof(string));
 661         Cbuf_AddText(cmd_local, string);
 662 }
 663
 664 /*
 665 =================
 666 VM_localcmd_server
 667
 668 Sends text over to the server's execution buffer
 669
 670 [localcmd (string, ...) or]
 671 cmd (string, ...)
 672 =================
 673 */
 674 void VM_localcmd_server(prvm_prog_t *prog)
 675 {
 676         char string[VM_STRINGTEMP_LENGTH];
 677         VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_server);
 678         VM_VarString(prog, 0, string, sizeof(string));
 679         Cbuf_AddText(cmd_local, string);
 680 }
 681
 682 static qbool PRVM_Cvar_ReadOk(prvm_prog_t *prog, const char *string)
 683 {
 684         cvar_t *cvar;
 685         cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask);
 686         return ((cvar) && ((cvar->flags & CF_PRIVATE) == 0));
 687 }
 688
 689 /*
 690 =================
 691 VM_cvar
 692
 693 float cvar (string)
 694 =================
 695 */
 696 void VM_cvar(prvm_prog_t *prog)
 697 {
 698         char string[VM_STRINGTEMP_LENGTH];
 699         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
 700         VM_VarString(prog, 0, string, sizeof(string));
 701         VM_CheckEmptyString(prog, string);
 702         PRVM_G_FLOAT(OFS_RETURN) = PRVM_Cvar_ReadOk(prog, string) ? Cvar_VariableValue(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask) : 0;
 703 }
 704
 705 /*
 706 =================
 707 VM_cvar
 708
 709 float cvar_type (string)
 710 float CVAR_TYPEFLAG_EXISTS = 1;
 711 float CVAR_TYPEFLAG_SAVED = 2;
 712 float CVAR_TYPEFLAG_PRIVATE = 4;
 713 float CVAR_TYPEFLAG_ENGINE = 8;
 714 float CVAR_TYPEFLAG_HASDESCRIPTION = 16;
 715 float CVAR_TYPEFLAG_READONLY = 32;
 716 =================
 717 */
 718 void VM_cvar_type(prvm_prog_t *prog)
 719 {
 720         char string[VM_STRINGTEMP_LENGTH];
 721         cvar_t *cvar;
 722         int ret;
 723
 724         VM_SAFEPARMCOUNTRANGE(1, 8, VM_cvar_type);
 725         VM_VarString(prog, 0, string, sizeof(string));
 726         VM_CheckEmptyString(prog, string);
 727         cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask);
 728
 729
 730         if(!cvar)
 731         {
 732                 PRVM_G_FLOAT(OFS_RETURN) = 0;
 733                 return; // CVAR_TYPE_NONE
 734         }
 735
 736         ret = 1; // CVAR_EXISTS
 737         if(cvar->flags & CF_ARCHIVE)
 738                 ret |= 2; // CVAR_TYPE_SAVED
 739         if(cvar->flags & CF_PRIVATE)
 740                 ret |= 4; // CVAR_TYPE_PRIVATE
 741         if(!(cvar->flags & CF_ALLOCATED))
 742                 ret |= 8; // CVAR_TYPE_ENGINE
 743         if(cvar->description != cvar_dummy_description)
 744                 ret |= 16; // CVAR_TYPE_HASDESCRIPTION
 745         if(cvar->flags & CF_READONLY)
 746                 ret |= 32; // CVAR_TYPE_READONLY
 747
 748         PRVM_G_FLOAT(OFS_RETURN) = ret;
 749 }
 750
 751 /*
 752 =================
 753 VM_cvar_string
 754
 755 const string    VM_cvar_string (string, ...)
 756 =================
 757 */
 758 void VM_cvar_string(prvm_prog_t *prog)
 759 {
 760         char string[VM_STRINGTEMP_LENGTH];
 761         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_string);
 762         VM_VarString(prog, 0, string, sizeof(string));
 763         VM_CheckEmptyString(prog, string);
 764         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, PRVM_Cvar_ReadOk(prog, string) ? Cvar_VariableString(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask) : "");
 765 }
 766
 767
 768 /*
 769 ========================
 770 VM_cvar_defstring
 771
 772 const string    VM_cvar_defstring (string, ...)
 773 ========================
 774 */
 775 void VM_cvar_defstring(prvm_prog_t *prog)
 776 {
 777         char string[VM_STRINGTEMP_LENGTH];
 778         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_defstring);
 779         VM_VarString(prog, 0, string, sizeof(string));
 780         VM_CheckEmptyString(prog, string);
 781         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, Cvar_VariableDefString(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask));
 782 }
 783
 784 /*
 785 ========================
 786 VM_cvar_defstring
 787
 788 const string    VM_cvar_description (string, ...)
 789 ========================
 790 */
 791 void VM_cvar_description(prvm_prog_t *prog)
 792 {
 793         char string[VM_STRINGTEMP_LENGTH];
 794         VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_description);
 795         VM_VarString(prog, 0, string, sizeof(string));
 796         VM_CheckEmptyString(prog, string);
 797         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, Cvar_VariableDescription(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask));
 798 }
 799 /*
 800 =================
 801 VM_cvar_set
 802
 803 void cvar_set (string,string, ...)
 804 =================
 805 */
 806 void VM_cvar_set(prvm_prog_t *prog)
 807 {
 808         const char *name;
 809         char string[VM_STRINGTEMP_LENGTH];
 810         VM_SAFEPARMCOUNTRANGE(2,8,VM_cvar_set);
 811         VM_VarString(prog, 1, string, sizeof(string));
 812         name = PRVM_G_STRING(OFS_PARM0);
 813         VM_CheckEmptyString(prog, name);
 814         Cvar_Set(prog->console_cmd->cvars, name, string);
 815 }
 816
 817 /*
 818 =========
 819 VM_dprint
 820
 821 dprint(...[string])
 822 =========
 823 */
 824 void VM_dprint(prvm_prog_t *prog)
 825 {
 826         char string[VM_STRINGTEMP_LENGTH];
 827         VM_SAFEPARMCOUNTRANGE(1, 8, VM_dprint);
 828         VM_VarString(prog, 0, string, sizeof(string));
 829 #if 1
 830         Con_DPrintf("%s", string);
 831 #else
 832         Con_DPrintf("%s: %s", prog->name, string);
 833 #endif
 834 }
 835
 836 /*
 837 =========
 838 VM_ftos
 839
 840 string  ftos(float)
 841 =========
 842 */
 843
 844 void VM_ftos(prvm_prog_t *prog)
 845 {
 846         prvm_vec_t v;
 847         char s[128];
 848
 849         VM_SAFEPARMCOUNT(1, VM_ftos);
 850
 851         v = PRVM_G_FLOAT(OFS_PARM0);
 852
 853         if ((prvm_vec_t)((prvm_int_t)v) == v)
 854                 dpsnprintf(s, sizeof(s), "%.0f", v);
 855         else
 856                 dpsnprintf(s, sizeof(s), "%f", v);
 857         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, s);
 858 }
 859
 860 /*
 861 =========
 862 VM_fabs
 863
 864 float   fabs(float)
 865 =========
 866 */
 867
 868 void VM_fabs(prvm_prog_t *prog)
 869 {
 870         prvm_vec_t v;
 871
 872         VM_SAFEPARMCOUNT(1,VM_fabs);
 873
 874         v = PRVM_G_FLOAT(OFS_PARM0);
 875         PRVM_G_FLOAT(OFS_RETURN) = fabs(v);
 876 }
 877
 878 /*
 879 =========
 880 VM_vtos
 881
 882 string  vtos(vector)
 883 =========
 884 */
 885
 886 void VM_vtos(prvm_prog_t *prog)
 887 {
 888         char s[512];
 889
 890         VM_SAFEPARMCOUNT(1,VM_vtos);
 891
 892         dpsnprintf (s, sizeof(s), "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
 893         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, s);
 894 }
 895
 896 /*
 897 =========
 898 VM_etos
 899
 900 string  etos(entity)
 901 =========
 902 */
 903
 904 void VM_etos(prvm_prog_t *prog)
 905 {
 906         char s[128];
 907
 908         VM_SAFEPARMCOUNT(1, VM_etos);
 909
 910         dpsnprintf (s, sizeof(s), "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
 911         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, s);
 912 }
 913
 914 /*
 915 =========
 916 VM_stof
 917
 918 float stof(...[string])
 919 =========
 920 */
 921 void VM_stof(prvm_prog_t *prog)
 922 {
 923         char string[VM_STRINGTEMP_LENGTH];
 924         VM_SAFEPARMCOUNTRANGE(1, 8, VM_stof);
 925         VM_VarString(prog, 0, string, sizeof(string));
 926         PRVM_G_FLOAT(OFS_RETURN) = atof(string);
 927 }
 928
 929 /*
 930 ========================
 931 VM_itof
 932
 933 float itof(int ent)
 934 ========================
 935 */
 936 void VM_itof(prvm_prog_t *prog)
 937 {
 938         VM_SAFEPARMCOUNT(1, VM_itof);
 939         PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
 940 }
 941
 942 /*
 943 ========================
 944 VM_ftoe
 945
 946 entity ftoe(float num)
 947 ========================
 948 */
 949 void VM_ftoe(prvm_prog_t *prog)
 950 {
 951         prvm_int_t ent;
 952         VM_SAFEPARMCOUNT(1, VM_ftoe);
 953
 954         ent = (prvm_int_t)PRVM_G_FLOAT(OFS_PARM0);
 955         if (ent < 0 || ent >= prog->max_edicts || PRVM_PROG_TO_EDICT(ent)->free)
 956                 ent = 0; // return world instead of a free or invalid entity
 957
 958         PRVM_G_INT(OFS_RETURN) = ent;
 959 }
 960
 961 /*
 962 ========================
 963 VM_etof
 964
 965 float etof(entity ent)
 966 ========================
 967 */
 968 void VM_etof(prvm_prog_t *prog)
 969 {
 970         VM_SAFEPARMCOUNT(1, VM_etof);
 971         PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICTNUM(OFS_PARM0);
 972 }
 973
 974 /*
 975 =========
 976 VM_strftime
 977
 978 string strftime(float uselocaltime, string[, string ...])
 979 =========
 980 */
 981 void VM_strftime(prvm_prog_t *prog)
 982 {
 983         time_t t;
 984 #if _MSC_VER >= 1400
 985         struct tm tm;
 986         int tmresult;
 987 #else
 988         struct tm *tm;
 989 #endif
 990         char fmt[VM_STRINGTEMP_LENGTH];
 991         char result[VM_STRINGTEMP_LENGTH];
 992         VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime);
 993         VM_VarString(prog, 1, fmt, sizeof(fmt));
 994         t = time(NULL);
 995 #if _MSC_VER >= 1400
 996         if (PRVM_G_FLOAT(OFS_PARM0))
 997                 tmresult = localtime_s(&tm, &t);
 998         else
 999                 tmresult = gmtime_s(&tm, &t);
1000         if (!tmresult)
1001 #else
1002         if (PRVM_G_FLOAT(OFS_PARM0))
1003                 tm = localtime(&t);
1004         else
1005                 tm = gmtime(&t);
1006         if (!tm)
1007 #endif
1008         {
1009                 PRVM_G_INT(OFS_RETURN) = 0;
1010                 return;
1011         }
1012 #if _MSC_VER >= 1400
1013         strftime(result, sizeof(result), fmt, &tm);
1014 #else
1015         strftime(result, sizeof(result), fmt, tm);
1016 #endif
1017         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, result);
1018 }
1019
1020 /*
1021 =========
1022 VM_spawn
1023
1024 entity spawn()
1025 =========
1026 */
1027
1028 void VM_spawn(prvm_prog_t *prog)
1029 {
1030         prvm_edict_t    *ed;
1031         VM_SAFEPARMCOUNT(0, VM_spawn);
1032         prog->xfunction->builtinsprofile += 20;
1033         ed = PRVM_ED_Alloc(prog);
1034         VM_RETURN_EDICT(ed);
1035 }
1036
1037 /*
1038 =========
1039 VM_remove
1040
1041 remove(entity e)
1042 =========
1043 */
1044
1045 void VM_remove(prvm_prog_t *prog)
1046 {
1047         prvm_edict_t    *ed;
1048         prog->xfunction->builtinsprofile += 20;
1049
1050         VM_SAFEPARMCOUNT(1, VM_remove);
1051
1052         ed = PRVM_G_EDICT(OFS_PARM0);
1053         if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
1054         {
1055                 if (developer.integer > 0)
1056                         VM_Warning(prog, "VM_remove: tried to remove the null entity or a reserved entity!\n" );
1057         }
1058         else if( ed->free )
1059         {
1060                 if (developer.integer > 0)
1061                         VM_Warning(prog, "VM_remove: tried to remove an already freed entity!\n" );
1062         }
1063         else
1064                 PRVM_ED_Free (prog, ed);
1065 }
1066
1067 /*
1068 =========
1069 VM_find
1070
1071 entity  find(entity start, .string field, string match)
1072 =========
1073 */
1074
1075 void VM_find(prvm_prog_t *prog)
1076 {
1077         int             e;
1078         int             f;
1079         const char      *s, *t;
1080         prvm_edict_t    *ed;
1081
1082         VM_SAFEPARMCOUNT(3,VM_find);
1083
1084         e = PRVM_G_EDICTNUM(OFS_PARM0);
1085         f = PRVM_G_INT(OFS_PARM1);
1086         s = PRVM_G_STRING(OFS_PARM2);
1087
1088         // LadyHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
1089         // expects it to find all the monsters, so we must be careful to support
1090         // searching for ""
1091
1092         for (e++ ; e < prog->num_edicts ; e++)
1093         {
1094                 prog->xfunction->builtinsprofile++;
1095                 ed = PRVM_EDICT_NUM(e);
1096                 if (ed->free)
1097                         continue;
1098                 t = PRVM_E_STRING(ed,f);
1099                 if (!t)
1100                         t = "";
1101                 if (!strcmp(t,s))
1102                 {
1103                         VM_RETURN_EDICT(ed);
1104                         return;
1105                 }
1106         }
1107
1108         VM_RETURN_EDICT(prog->edicts);
1109 }
1110
1111 /*
1112 =========
1113 VM_findfloat
1114
1115   entity        findfloat(entity start, .float field, float match)
1116   entity        findentity(entity start, .entity field, entity match)
1117 =========
1118 */
1119 // LadyHavoc: added this for searching float, int, and entity reference fields
1120 void VM_findfloat(prvm_prog_t *prog)
1121 {
1122         int             e;
1123         int             f;
1124         prvm_vec_t      s;
1125         prvm_edict_t    *ed;
1126
1127         VM_SAFEPARMCOUNT(3,VM_findfloat);
1128
1129         e = PRVM_G_EDICTNUM(OFS_PARM0);
1130         f = PRVM_G_INT(OFS_PARM1);
1131         s = PRVM_G_FLOAT(OFS_PARM2);
1132
1133         for (e++ ; e < prog->num_edicts ; e++)
1134         {
1135                 prog->xfunction->builtinsprofile++;
1136                 ed = PRVM_EDICT_NUM(e);
1137                 if (ed->free)
1138                         continue;
1139                 if (PRVM_E_FLOAT(ed,f) == s)
1140                 {
1141                         VM_RETURN_EDICT(ed);
1142                         return;
1143                 }
1144         }
1145
1146         VM_RETURN_EDICT(prog->edicts);
1147 }
1148
1149 /*
1150 =========
1151 VM_findchain
1152
1153 entity  findchain(.string field, string match)
1154 =========
1155 */
1156 // chained search for strings in entity fields
1157 // entity(.string field, string match) findchain = #402;
1158 void VM_findchain(prvm_prog_t *prog)
1159 {
1160         int             i;
1161         int             f;
1162         const char      *s, *t;
1163         prvm_edict_t    *ent, *chain;
1164         int chainfield;
1165
1166         VM_SAFEPARMCOUNTRANGE(2,3,VM_findchain);
1167
1168         if(prog->argc == 3)
1169                 chainfield = PRVM_G_INT(OFS_PARM2);
1170         else
1171                 chainfield = prog->fieldoffsets.chain;
1172         if (chainfield < 0)
1173                 prog->error_cmd("VM_findchain: %s doesnt have the specified chain field !", prog->name);
1174
1175         chain = prog->edicts;
1176
1177         f = PRVM_G_INT(OFS_PARM0);
1178         s = PRVM_G_STRING(OFS_PARM1);
1179
1180         // LadyHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
1181         // expects it to find all the monsters, so we must be careful to support
1182         // searching for ""
1183
1184         ent = PRVM_NEXT_EDICT(prog->edicts);
1185         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1186         {
1187                 prog->xfunction->builtinsprofile++;
1188                 if (ent->free)
1189                         continue;
1190                 t = PRVM_E_STRING(ent,f);
1191                 if (!t)
1192                         t = "";
1193                 if (strcmp(t,s))
1194                         continue;
1195
1196                 PRVM_EDICTFIELDEDICT(ent,chainfield) = PRVM_NUM_FOR_EDICT(chain);
1197                 chain = ent;
1198         }
1199
1200         VM_RETURN_EDICT(chain);
1201 }
1202
1203 /*
1204 =========
1205 VM_findchainfloat
1206
1207 entity  findchainfloat(.string field, float match)
1208 entity  findchainentity(.string field, entity match)
1209 =========
1210 */
1211 // LadyHavoc: chained search for float, int, and entity reference fields
1212 // entity(.string field, float match) findchainfloat = #403;
1213 void VM_findchainfloat(prvm_prog_t *prog)
1214 {
1215         int             i;
1216         int             f;
1217         prvm_vec_t      s;
1218         prvm_edict_t    *ent, *chain;
1219         int chainfield;
1220
1221         VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainfloat);
1222
1223         if(prog->argc == 3)
1224                 chainfield = PRVM_G_INT(OFS_PARM2);
1225         else
1226                 chainfield = prog->fieldoffsets.chain;
1227         if (chainfield < 0)
1228                 prog->error_cmd("VM_findchainfloat: %s doesnt have the specified chain field !", prog->name);
1229
1230         chain = (prvm_edict_t *)prog->edicts;
1231
1232         f = PRVM_G_INT(OFS_PARM0);
1233         s = PRVM_G_FLOAT(OFS_PARM1);
1234
1235         ent = PRVM_NEXT_EDICT(prog->edicts);
1236         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1237         {
1238                 prog->xfunction->builtinsprofile++;
1239                 if (ent->free)
1240                         continue;
1241                 if (PRVM_E_FLOAT(ent,f) != s)
1242                         continue;
1243
1244                 PRVM_EDICTFIELDEDICT(ent,chainfield) = PRVM_EDICT_TO_PROG(chain);
1245                 chain = ent;
1246         }
1247
1248         VM_RETURN_EDICT(chain);
1249 }
1250
1251 /*
1252 ========================
1253 VM_findflags
1254
1255 entity  findflags(entity start, .float field, float match)
1256 ========================
1257 */
1258 // LadyHavoc: search for flags in float fields
1259 void VM_findflags(prvm_prog_t *prog)
1260 {
1261         prvm_int_t      e;
1262         prvm_int_t      f;
1263         prvm_int_t      s;
1264         prvm_edict_t    *ed;
1265
1266         VM_SAFEPARMCOUNT(3, VM_findflags);
1267
1268
1269         e = PRVM_G_EDICTNUM(OFS_PARM0);
1270         f = PRVM_G_INT(OFS_PARM1);
1271         s = (prvm_int_t)PRVM_G_FLOAT(OFS_PARM2);
1272
1273         for (e++ ; e < prog->num_edicts ; e++)
1274         {
1275                 prog->xfunction->builtinsprofile++;
1276                 ed = PRVM_EDICT_NUM(e);
1277                 if (ed->free)
1278                         continue;
1279                 if (!PRVM_E_FLOAT(ed,f))
1280                         continue;
1281                 if ((prvm_int_t)PRVM_E_FLOAT(ed,f) & s)
1282                 {
1283                         VM_RETURN_EDICT(ed);
1284                         return;
1285                 }
1286         }
1287
1288         VM_RETURN_EDICT(prog->edicts);
1289 }
1290
1291 /*
1292 ========================
1293 VM_findchainflags
1294
1295 entity  findchainflags(.float field, float match)
1296 ========================
1297 */
1298 // LadyHavoc: chained search for flags in float fields
1299 void VM_findchainflags(prvm_prog_t *prog)
1300 {
1301         prvm_int_t              i;
1302         prvm_int_t              f;
1303         prvm_int_t              s;
1304         prvm_edict_t    *ent, *chain;
1305         int chainfield;
1306
1307         VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainflags);
1308
1309         if(prog->argc == 3)
1310                 chainfield = PRVM_G_INT(OFS_PARM2);
1311         else
1312                 chainfield = prog->fieldoffsets.chain;
1313         if (chainfield < 0)
1314                 prog->error_cmd("VM_findchainflags: %s doesnt have the specified chain field !", prog->name);
1315
1316         chain = (prvm_edict_t *)prog->edicts;
1317
1318         f = PRVM_G_INT(OFS_PARM0);
1319         s = (prvm_int_t)PRVM_G_FLOAT(OFS_PARM1);
1320
1321         ent = PRVM_NEXT_EDICT(prog->edicts);
1322         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1323         {
1324                 prog->xfunction->builtinsprofile++;
1325                 if (ent->free)
1326                         continue;
1327                 if (!PRVM_E_FLOAT(ent,f))
1328                         continue;
1329                 if (!((prvm_int_t)PRVM_E_FLOAT(ent,f) & s))
1330                         continue;
1331
1332                 PRVM_EDICTFIELDEDICT(ent,chainfield) = PRVM_EDICT_TO_PROG(chain);
1333                 chain = ent;
1334         }
1335
1336         VM_RETURN_EDICT(chain);
1337 }
1338
1339 /*
1340 =========
1341 VM_precache_sound
1342
1343 string  precache_sound (string sample)
1344 =========
1345 */
1346 void VM_precache_sound(prvm_prog_t *prog)
1347 {
1348         const char *s;
1349
1350         VM_SAFEPARMCOUNT(1, VM_precache_sound);
1351
1352         s = PRVM_G_STRING(OFS_PARM0);
1353         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1354         //VM_CheckEmptyString(prog, s);
1355
1356         if(snd_initialized.integer && !S_PrecacheSound(s, true, true))
1357         {
1358                 VM_Warning(prog, "VM_precache_sound: Failed to load %s for %s\n", s, prog->name);
1359                 return;
1360         }
1361 }
1362
1363 /*
1364 =================
1365 VM_precache_file
1366
1367 returns the same string as output
1368
1369 does nothing, only used by qcc to build .pak archives
1370 =================
1371 */
1372 void VM_precache_file(prvm_prog_t *prog)
1373 {
1374         VM_SAFEPARMCOUNT(1,VM_precache_file);
1375         // precache_file is only used to copy files with qcc, it does nothing
1376         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1377 }
1378
1379 /*
1380 =========
1381 VM_coredump
1382
1383 coredump()
1384 =========
1385 */
1386 void VM_coredump(prvm_prog_t *prog)
1387 {
1388         VM_SAFEPARMCOUNT(0,VM_coredump);
1389
1390         Cbuf_AddText(cmd_local, "prvm_edicts ");
1391         Cbuf_AddText(cmd_local, prog->name);
1392         Cbuf_AddText(cmd_local, "\n");
1393 }
1394
1395 /*
1396 =========
1397 VM_stackdump
1398
1399 stackdump()
1400 =========
1401 */
1402 void VM_stackdump(prvm_prog_t *prog)
1403 {
1404         VM_SAFEPARMCOUNT(0, VM_stackdump);
1405
1406         PRVM_StackTrace(prog);
1407 }
1408
1409 /*
1410 =========
1411 VM_crash
1412
1413 crash()
1414 =========
1415 */
1416
1417 void VM_crash(prvm_prog_t *prog)
1418 {
1419         VM_SAFEPARMCOUNT(0, VM_crash);
1420
1421         prog->error_cmd("Crash called by %s",prog->name);
1422 }
1423
1424 /*
1425 =========
1426 VM_traceon
1427
1428 traceon()
1429 =========
1430 */
1431 void VM_traceon(prvm_prog_t *prog)
1432 {
1433         VM_SAFEPARMCOUNT(0,VM_traceon);
1434
1435         prog->trace = true;
1436 }
1437
1438 /*
1439 =========
1440 VM_traceoff
1441
1442 traceoff()
1443 =========
1444 */
1445 void VM_traceoff(prvm_prog_t *prog)
1446 {
1447         VM_SAFEPARMCOUNT(0,VM_traceoff);
1448
1449         prog->trace = false;
1450 }
1451
1452 /*
1453 =========
1454 VM_eprint
1455
1456 eprint(entity e)
1457 =========
1458 */
1459 void VM_eprint(prvm_prog_t *prog)
1460 {
1461         VM_SAFEPARMCOUNT(1,VM_eprint);
1462
1463         PRVM_ED_PrintNum (prog, PRVM_G_EDICTNUM(OFS_PARM0), NULL);
1464 }
1465
1466 /*
1467 =========
1468 VM_rint
1469
1470 float   rint(float)
1471 =========
1472 */
1473 void VM_rint(prvm_prog_t *prog)
1474 {
1475         prvm_vec_t f;
1476         VM_SAFEPARMCOUNT(1,VM_rint);
1477
1478         f = PRVM_G_FLOAT(OFS_PARM0);
1479         if (f > 0)
1480                 PRVM_G_FLOAT(OFS_RETURN) = floor(f + 0.5);
1481         else
1482                 PRVM_G_FLOAT(OFS_RETURN) = ceil(f - 0.5);
1483 }
1484
1485 /*
1486 =========
1487 VM_floor
1488
1489 float   floor(float)
1490 =========
1491 */
1492 void VM_floor(prvm_prog_t *prog)
1493 {
1494         VM_SAFEPARMCOUNT(1,VM_floor);
1495
1496         PRVM_G_FLOAT(OFS_RETURN) = floor(PRVM_G_FLOAT(OFS_PARM0));
1497 }
1498
1499 /*
1500 =========
1501 VM_ceil
1502
1503 float   ceil(float)
1504 =========
1505 */
1506 void VM_ceil(prvm_prog_t *prog)
1507 {
1508         VM_SAFEPARMCOUNT(1,VM_ceil);
1509
1510         PRVM_G_FLOAT(OFS_RETURN) = ceil(PRVM_G_FLOAT(OFS_PARM0));
1511 }
1512
1513
1514 /*
1515 =============
1516 VM_nextent
1517
1518 entity  nextent(entity)
1519 =============
1520 */
1521 void VM_nextent(prvm_prog_t *prog)
1522 {
1523         int             i;
1524         prvm_edict_t    *ent;
1525
1526         VM_SAFEPARMCOUNT(1, VM_nextent);
1527
1528         i = PRVM_G_EDICTNUM(OFS_PARM0);
1529         while (1)
1530         {
1531                 prog->xfunction->builtinsprofile++;
1532                 i++;
1533                 if (i == prog->num_edicts)
1534                 {
1535                         VM_RETURN_EDICT(prog->edicts);
1536                         return;
1537                 }
1538                 ent = PRVM_EDICT_NUM(i);
1539                 if (!ent->free)
1540                 {
1541                         VM_RETURN_EDICT(ent);
1542                         return;
1543                 }
1544         }
1545 }
1546
1547 //=============================================================================
1548
1549 /*
1550 ==============
1551 VM_changelevel
1552 server and menu
1553
1554 changelevel(string map)
1555 ==============
1556 */
1557 void VM_changelevel(prvm_prog_t *prog)
1558 {
1559         char vabuf[1024];
1560         VM_SAFEPARMCOUNT(1, VM_changelevel);
1561
1562         if(!sv.active)
1563         {
1564                 VM_Warning(prog, "VM_changelevel: game is not server (%s)\n", prog->name);
1565                 return;
1566         }
1567
1568 // make sure we don't issue two changelevels
1569         if (svs.changelevel_issued)
1570                 return;
1571         svs.changelevel_issued = true;
1572
1573         Cbuf_AddText(cmd_local, va(vabuf, sizeof(vabuf), "changelevel %s\n", PRVM_G_STRING(OFS_PARM0)));
1574 }
1575
1576 /*
1577 =========
1578 VM_sin
1579
1580 float   sin(float)
1581 =========
1582 */
1583 void VM_sin(prvm_prog_t *prog)
1584 {
1585         VM_SAFEPARMCOUNT(1,VM_sin);
1586         PRVM_G_FLOAT(OFS_RETURN) = sin(PRVM_G_FLOAT(OFS_PARM0));
1587 }
1588
1589 /*
1590 =========
1591 VM_cos
1592 float   cos(float)
1593 =========
1594 */
1595 void VM_cos(prvm_prog_t *prog)
1596 {
1597         VM_SAFEPARMCOUNT(1,VM_cos);
1598         PRVM_G_FLOAT(OFS_RETURN) = cos(PRVM_G_FLOAT(OFS_PARM0));
1599 }
1600
1601 /*
1602 =========
1603 VM_sqrt
1604
1605 float   sqrt(float)
1606 =========
1607 */
1608 void VM_sqrt(prvm_prog_t *prog)
1609 {
1610         VM_SAFEPARMCOUNT(1,VM_sqrt);
1611         PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0));
1612 }
1613
1614 /*
1615 =========
1616 VM_asin
1617
1618 float   asin(float)
1619 =========
1620 */
1621 void VM_asin(prvm_prog_t *prog)
1622 {
1623         VM_SAFEPARMCOUNT(1,VM_asin);
1624         PRVM_G_FLOAT(OFS_RETURN) = asin(PRVM_G_FLOAT(OFS_PARM0));
1625 }
1626
1627 /*
1628 =========
1629 VM_acos
1630 float   acos(float)
1631 =========
1632 */
1633 void VM_acos(prvm_prog_t *prog)
1634 {
1635         VM_SAFEPARMCOUNT(1,VM_acos);
1636         PRVM_G_FLOAT(OFS_RETURN) = acos(PRVM_G_FLOAT(OFS_PARM0));
1637 }
1638
1639 /*
1640 =========
1641 VM_atan
1642 float   atan(float)
1643 =========
1644 */
1645 void VM_atan(prvm_prog_t *prog)
1646 {
1647         VM_SAFEPARMCOUNT(1,VM_atan);
1648         PRVM_G_FLOAT(OFS_RETURN) = atan(PRVM_G_FLOAT(OFS_PARM0));
1649 }
1650
1651 /*
1652 =========
1653 VM_atan2
1654 float   atan2(float,float)
1655 =========
1656 */
1657 void VM_atan2(prvm_prog_t *prog)
1658 {
1659         VM_SAFEPARMCOUNT(2,VM_atan2);
1660         PRVM_G_FLOAT(OFS_RETURN) = atan2(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1661 }
1662
1663 /*
1664 =========
1665 VM_tan
1666 float   tan(float)
1667 =========
1668 */
1669 void VM_tan(prvm_prog_t *prog)
1670 {
1671         VM_SAFEPARMCOUNT(1,VM_tan);
1672         PRVM_G_FLOAT(OFS_RETURN) = tan(PRVM_G_FLOAT(OFS_PARM0));
1673 }
1674
1675 /*
1676 =================
1677 VM_randomvec
1678
1679 Returns a vector of length < 1 and > 0
1680
1681 vector randomvec()
1682 =================
1683 */
1684 void VM_randomvec(prvm_prog_t *prog)
1685 {
1686         vec3_t temp;
1687         VM_SAFEPARMCOUNT(0, VM_randomvec);
1688         VectorRandom(temp);
1689         VectorCopy(temp, PRVM_G_VECTOR(OFS_RETURN));
1690 }
1691
1692 //=============================================================================
1693
1694 /*
1695 =========
1696 VM_registercvar
1697
1698 float   registercvar (string name, string value[, float flags])
1699 =========
1700 */
1701 void VM_registercvar(prvm_prog_t *prog)
1702 {
1703         const char *name, *value;
1704         int     flags;
1705
1706         VM_SAFEPARMCOUNTRANGE(2, 3, VM_registercvar);
1707
1708         name = PRVM_G_STRING(OFS_PARM0);
1709         value = PRVM_G_STRING(OFS_PARM1);
1710         flags = prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : 0;
1711         PRVM_G_FLOAT(OFS_RETURN) = 0;
1712
1713         if(flags > CF_MAXFLAGSVAL)
1714                 return;
1715
1716 // first check to see if it has already been defined
1717         if (Cvar_FindVar (prog->console_cmd->cvars, name, prog->console_cmd->cvars_flagsmask))
1718                 return;
1719
1720 // check for overlap with a command
1721         if (Cmd_Exists(cmd_local, name))
1722         {
1723                 VM_Warning(prog, "VM_registercvar: %s is a command\n", name);
1724                 return;
1725         }
1726
1727         Cvar_Get(prog->console_cmd->cvars, name, value, prog->console_cmd->cvars_flagsmask | flags, NULL);
1728
1729         PRVM_G_FLOAT(OFS_RETURN) = 1; // success
1730 }
1731
1732
1733 /*
1734 =================
1735 VM_min
1736
1737 returns the minimum of two supplied floats
1738
1739 float min(float a, float b, ...[float])
1740 =================
1741 */
1742 void VM_min(prvm_prog_t *prog)
1743 {
1744         VM_SAFEPARMCOUNTRANGE(2, 8, VM_min);
1745         // LadyHavoc: 3+ argument enhancement suggested by FrikaC
1746         if (prog->argc >= 3)
1747         {
1748                 int i;
1749                 float f = PRVM_G_FLOAT(OFS_PARM0);
1750                 for (i = 1;i < prog->argc;i++)
1751                         if (f > PRVM_G_FLOAT((OFS_PARM0+i*3)))
1752                                 f = PRVM_G_FLOAT((OFS_PARM0+i*3));
1753                 PRVM_G_FLOAT(OFS_RETURN) = f;
1754         }
1755         else
1756                 PRVM_G_FLOAT(OFS_RETURN) = min(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1757 }
1758
1759 /*
1760 =================
1761 VM_max
1762
1763 returns the maximum of two supplied floats
1764
1765 float   max(float a, float b, ...[float])
1766 =================
1767 */
1768 void VM_max(prvm_prog_t *prog)
1769 {
1770         VM_SAFEPARMCOUNTRANGE(2, 8, VM_max);
1771         // LadyHavoc: 3+ argument enhancement suggested by FrikaC
1772         if (prog->argc >= 3)
1773         {
1774                 int i;
1775                 float f = PRVM_G_FLOAT(OFS_PARM0);
1776                 for (i = 1;i < prog->argc;i++)
1777                         if (f < PRVM_G_FLOAT((OFS_PARM0+i*3)))
1778                                 f = PRVM_G_FLOAT((OFS_PARM0+i*3));
1779                 PRVM_G_FLOAT(OFS_RETURN) = f;
1780         }
1781         else
1782                 PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1783 }
1784
1785 /*
1786 =================
1787 VM_bound
1788
1789 returns number bounded by supplied range
1790
1791 float   bound(float min, float value, float max)
1792 =================
1793 */
1794 void VM_bound(prvm_prog_t *prog)
1795 {
1796         VM_SAFEPARMCOUNT(3,VM_bound);
1797         PRVM_G_FLOAT(OFS_RETURN) = bound(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1), PRVM_G_FLOAT(OFS_PARM2));
1798 }
1799
1800 /*
1801 =================
1802 VM_pow
1803
1804 returns a raised to power b
1805
1806 float   pow(float a, float b)
1807 =================
1808 */
1809 void VM_pow(prvm_prog_t *prog)
1810 {
1811         VM_SAFEPARMCOUNT(2,VM_pow);
1812         PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1813 }
1814
1815 void VM_log(prvm_prog_t *prog)
1816 {
1817         VM_SAFEPARMCOUNT(1,VM_log);
1818         PRVM_G_FLOAT(OFS_RETURN) = log(PRVM_G_FLOAT(OFS_PARM0));
1819 }
1820
1821 void VM_Files_Init(prvm_prog_t *prog)
1822 {
1823         int i;
1824         for (i = 0;i < PRVM_MAX_OPENFILES;i++)
1825                 prog->openfiles[i] = NULL;
1826 }
1827
1828 void VM_Files_CloseAll(prvm_prog_t *prog)
1829 {
1830         int i;
1831         for (i = 0;i < PRVM_MAX_OPENFILES;i++)
1832         {
1833                 if (prog->openfiles[i])
1834                         FS_Close(prog->openfiles[i]);
1835                 prog->openfiles[i] = NULL;
1836         }
1837 }
1838
1839 static qfile_t *VM_GetFileHandle(prvm_prog_t *prog, int index)
1840 {
1841         if (index < 0 || index >= PRVM_MAX_OPENFILES)
1842         {
1843                 Con_Printf("VM_GetFileHandle: invalid file handle %i used in %s\n", index, prog->name);
1844                 return NULL;
1845         }
1846         if (prog->openfiles[index] == NULL)
1847         {
1848                 Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, prog->name);
1849                 return NULL;
1850         }
1851         return prog->openfiles[index];
1852 }
1853
1854 /*
1855 =========
1856 VM_fopen
1857
1858 float   fopen(string filename, float mode)
1859 =========
1860 */
1861 // float(string filename, float mode) fopen = #110;
1862 // opens a file inside quake/gamedir/data/ (mode is FILE_READ, FILE_APPEND, or FILE_WRITE),
1863 // returns fhandle >= 0 if successful, or fhandle < 0 if unable to open file for any reason
1864 void VM_fopen(prvm_prog_t *prog)
1865 {
1866         int filenum, mode;
1867         const char *modestring, *filename;
1868         char vabuf[1024];
1869
1870         VM_SAFEPARMCOUNT(2,VM_fopen);
1871
1872         for (filenum = 0;filenum < PRVM_MAX_OPENFILES;filenum++)
1873                 if (prog->openfiles[filenum] == NULL)
1874                         break;
1875         if (filenum >= PRVM_MAX_OPENFILES)
1876         {
1877                 PRVM_G_FLOAT(OFS_RETURN) = -2;
1878                 VM_Warning(prog, "VM_fopen: %s ran out of file handles (%i)\n", prog->name, PRVM_MAX_OPENFILES);
1879                 return;
1880         }
1881         filename = PRVM_G_STRING(OFS_PARM0);
1882         mode = (int)PRVM_G_FLOAT(OFS_PARM1);
1883         switch(mode)
1884         {
1885         case 0: // FILE_READ
1886                 modestring = "rb";
1887                 prog->openfiles[filenum] = FS_OpenVirtualFile(va(vabuf, sizeof(vabuf), "data/%s", filename), false);
1888                 if (prog->openfiles[filenum] == NULL)
1889                         prog->openfiles[filenum] = FS_OpenVirtualFile(va(vabuf, sizeof(vabuf), "%s", filename), false);
1890                 break;
1891         case 1: // FILE_APPEND
1892                 modestring = "a";
1893                 prog->openfiles[filenum] = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "data/%s", filename), modestring, false);
1894                 break;
1895         case 2: // FILE_WRITE
1896                 modestring = "w";
1897                 prog->openfiles[filenum] = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "data/%s", filename), modestring, false);
1898                 break;
1899         default:
1900                 PRVM_G_FLOAT(OFS_RETURN) = -3;
1901                 VM_Warning(prog, "VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", prog->name, mode);
1902                 return;
1903         }
1904
1905         if (prog->openfiles[filenum] == NULL)
1906         {
1907                 PRVM_G_FLOAT(OFS_RETURN) = -1;
1908                 if (developer_extra.integer)
1909                         VM_Warning(prog, "VM_fopen: %s: %s mode %s failed\n", prog->name, filename, modestring);
1910         }
1911         else
1912         {
1913                 PRVM_G_FLOAT(OFS_RETURN) = filenum;
1914                 if (developer_extra.integer)
1915                         Con_DPrintf("VM_fopen: %s: %s mode %s opened as #%i\n", prog->name, filename, modestring, filenum);
1916                 prog->openfiles_origin[filenum] = PRVM_AllocationOrigin(prog);
1917         }
1918 }
1919
1920 /*
1921 =========
1922 VM_fclose
1923
1924 fclose(float fhandle)
1925 =========
1926 */
1927 //void(float fhandle) fclose = #111; // closes a file
1928 void VM_fclose(prvm_prog_t *prog)
1929 {
1930         int filenum;
1931
1932         VM_SAFEPARMCOUNT(1,VM_fclose);
1933
1934         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
1935         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
1936         {
1937                 VM_Warning(prog, "VM_fclose: invalid file handle %i used in %s\n", filenum, prog->name);
1938                 return;
1939         }
1940         if (prog->openfiles[filenum] == NULL)
1941         {
1942                 VM_Warning(prog, "VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, prog->name);
1943                 return;
1944         }
1945         FS_Close(prog->openfiles[filenum]);
1946         prog->openfiles[filenum] = NULL;
1947         if(prog->openfiles_origin[filenum])
1948                 PRVM_Free((char *)prog->openfiles_origin[filenum]);
1949         if (developer_extra.integer)
1950                 Con_DPrintf("VM_fclose: %s: #%i closed\n", prog->name, filenum);
1951 }
1952
1953 /*
1954 =========
1955 VM_fgets
1956
1957 string  fgets(float fhandle)
1958 =========
1959 */
1960 //string(float fhandle) fgets = #112; // reads a line of text from the file and returns as a tempstring
1961 void VM_fgets(prvm_prog_t *prog)
1962 {
1963         int c, end;
1964         char string[VM_STRINGTEMP_LENGTH];
1965         int filenum;
1966
1967         VM_SAFEPARMCOUNT(1,VM_fgets);
1968
1969         // set the return value regardless of any possible errors
1970         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1971
1972         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
1973         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
1974         {
1975                 VM_Warning(prog, "VM_fgets: invalid file handle %i used in %s\n", filenum, prog->name);
1976                 return;
1977         }
1978         if (prog->openfiles[filenum] == NULL)
1979         {
1980                 VM_Warning(prog, "VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, prog->name);
1981                 return;
1982         }
1983         end = 0;
1984         for (;;)
1985         {
1986                 c = FS_Getc(prog->openfiles[filenum]);
1987                 if (c == '\r' || c == '\n' || c < 0)
1988                         break;
1989                 if (end < VM_STRINGTEMP_LENGTH - 1)
1990                         string[end++] = c;
1991         }
1992         string[end] = 0;
1993         // remove \n following \r
1994         if (c == '\r')
1995         {
1996                 c = FS_Getc(prog->openfiles[filenum]);
1997                 if (c != '\n')
1998                         FS_UnGetc(prog->openfiles[filenum], (unsigned char)c);
1999         }
2000         if (developer_extra.integer)
2001                 Con_DPrintf("fgets: %s: %s\n", prog->name, string);
2002         if (c >= 0 || end)
2003                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
2004 }
2005
2006 /*
2007 =========
2008 VM_fputs
2009
2010 fputs(float fhandle, string s)
2011 =========
2012 */
2013 //void(float fhandle, string s) fputs = #113; // writes a line of text to the end of the file
2014 void VM_fputs(prvm_prog_t *prog)
2015 {
2016         int stringlength;
2017         char string[VM_STRINGTEMP_LENGTH];
2018         int filenum;
2019
2020         VM_SAFEPARMCOUNT(2,VM_fputs);
2021
2022         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2023         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
2024         {
2025                 VM_Warning(prog, "VM_fputs: invalid file handle %i used in %s\n", filenum, prog->name);
2026                 return;
2027         }
2028         if (prog->openfiles[filenum] == NULL)
2029         {
2030                 VM_Warning(prog, "VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, prog->name);
2031                 return;
2032         }
2033         VM_VarString(prog, 1, string, sizeof(string));
2034         if ((stringlength = (int)strlen(string)))
2035                 FS_Write(prog->openfiles[filenum], string, stringlength);
2036         if (developer_extra.integer)
2037                 Con_DPrintf("fputs: %s: %s\n", prog->name, string);
2038 }
2039
2040 /*
2041 =========
2042 VM_writetofile
2043
2044         writetofile(float fhandle, entity ent)
2045 =========
2046 */
2047 void VM_writetofile(prvm_prog_t *prog)
2048 {
2049         prvm_edict_t * ent;
2050         qfile_t *file;
2051
2052         VM_SAFEPARMCOUNT(2, VM_writetofile);
2053
2054         file = VM_GetFileHandle(prog, (int)PRVM_G_FLOAT(OFS_PARM0));
2055         if( !file )
2056         {
2057                 VM_Warning(prog, "VM_writetofile: invalid or closed file handle\n");
2058                 return;
2059         }
2060
2061         ent = PRVM_G_EDICT(OFS_PARM1);
2062         if(ent->free)
2063         {
2064                 VM_Warning(prog, "VM_writetofile: %s: entity %i is free !\n", prog->name, PRVM_NUM_FOR_EDICT(ent));
2065                 return;
2066         }
2067
2068         PRVM_ED_Write (prog, file, ent);
2069 }
2070
2071 // KrimZon - DP_QC_ENTITYDATA
2072 /*
2073 =========
2074 VM_numentityfields
2075
2076 float() numentityfields
2077 Return the number of entity fields - NOT offsets
2078 =========
2079 */
2080 void VM_numentityfields(prvm_prog_t *prog)
2081 {
2082         PRVM_G_FLOAT(OFS_RETURN) = prog->numfielddefs;
2083 }
2084
2085 // KrimZon - DP_QC_ENTITYDATA
2086 /*
2087 =========
2088 VM_entityfieldname
2089
2090 string(float fieldnum) entityfieldname
2091 Return name of the specified field as a string, or empty if the field is invalid (warning)
2092 =========
2093 */
2094 void VM_entityfieldname(prvm_prog_t *prog)
2095 {
2096         mdef_t *d;
2097         int i = (int)PRVM_G_FLOAT(OFS_PARM0);
2098
2099         if (i < 0 || i >= prog->numfielddefs)
2100         {
2101                 VM_Warning(prog, "VM_entityfieldname: %s: field index out of bounds\n", prog->name);
2102                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
2103                 return;
2104         }
2105
2106         d = &prog->fielddefs[i];
2107         PRVM_G_INT(OFS_RETURN) = d->s_name; // presuming that s_name points to a string already
2108 }
2109
2110 // KrimZon - DP_QC_ENTITYDATA
2111 /*
2112 =========
2113 VM_entityfieldtype
2114
2115 float(float fieldnum) entityfieldtype
2116 =========
2117 */
2118 void VM_entityfieldtype(prvm_prog_t *prog)
2119 {
2120         mdef_t *d;
2121         int i = (int)PRVM_G_FLOAT(OFS_PARM0);
2122
2123         if (i < 0 || i >= prog->numfielddefs)
2124         {
2125                 VM_Warning(prog, "VM_entityfieldtype: %s: field index out of bounds\n", prog->name);
2126                 PRVM_G_FLOAT(OFS_RETURN) = -1.0;
2127                 return;
2128         }
2129
2130         d = &prog->fielddefs[i];
2131         PRVM_G_FLOAT(OFS_RETURN) = (prvm_vec_t)d->type;
2132 }
2133
2134 // KrimZon - DP_QC_ENTITYDATA
2135 /*
2136 =========
2137 VM_getentityfieldstring
2138
2139 string(float fieldnum, entity ent) getentityfieldstring
2140 =========
2141 */
2142 void VM_getentityfieldstring(prvm_prog_t *prog)
2143 {
2144         // put the data into a string
2145         mdef_t *d;
2146         int type, j;
2147         prvm_eval_t *val;
2148         prvm_edict_t * ent;
2149         int i = (int)PRVM_G_FLOAT(OFS_PARM0);
2150         char valuebuf[MAX_INPUTLINE];
2151
2152         if (i < 0 || i >= prog->numfielddefs)
2153         {
2154         VM_Warning(prog, "VM_entityfielddata: %s: field index out of bounds\n", prog->name);
2155                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
2156                 return;
2157         }
2158
2159         d = &prog->fielddefs[i];
2160
2161         // get the entity
2162         ent = PRVM_G_EDICT(OFS_PARM1);
2163         if(ent->free)
2164         {
2165                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
2166                 VM_Warning(prog, "VM_entityfielddata: %s: entity %i is free !\n", prog->name, PRVM_NUM_FOR_EDICT(ent));
2167                 return;
2168         }
2169         val = (prvm_eval_t *)(ent->fields.fp + d->ofs);
2170
2171         // if it's 0 or blank, return an empty string
2172         type = d->type & ~DEF_SAVEGLOBAL;
2173         for (j=0 ; j<prvm_type_size[type] ; j++)
2174                 if (val->ivector[j])
2175                         break;
2176         if (j == prvm_type_size[type])
2177         {
2178                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
2179                 return;
2180         }
2181
2182         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, PRVM_UglyValueString(prog, (etype_t)d->type, val, valuebuf, sizeof(valuebuf)));
2183 }
2184
2185 // KrimZon - DP_QC_ENTITYDATA
2186 /*
2187 =========
2188 VM_putentityfieldstring
2189
2190 float(float fieldnum, entity ent, string s) putentityfieldstring
2191 =========
2192 */
2193 void VM_putentityfieldstring(prvm_prog_t *prog)
2194 {
2195         mdef_t *d;
2196         prvm_edict_t * ent;
2197         int i = (int)PRVM_G_FLOAT(OFS_PARM0);
2198
2199         if (i < 0 || i >= prog->numfielddefs)
2200         {
2201         VM_Warning(prog, "VM_entityfielddata: %s: field index out of bounds\n", prog->name);
2202                 PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
2203                 return;
2204         }
2205
2206         d = &prog->fielddefs[i];
2207
2208         // get the entity
2209         ent = PRVM_G_EDICT(OFS_PARM1);
2210         if(ent->free)
2211         {
2212                 VM_Warning(prog, "VM_entityfielddata: %s: entity %i is free !\n", prog->name, PRVM_NUM_FOR_EDICT(ent));
2213                 PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
2214                 return;
2215         }
2216
2217         // parse the string into the value
2218         PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(prog, ent, d, PRVM_G_STRING(OFS_PARM2), false) ) ? 1.0f : 0.0f;
2219 }
2220
2221 /*
2222 =========
2223 VM_strlen
2224
2225 float   strlen(string s)
2226 =========
2227 */
2228 //float(string s) strlen = #114; // returns how many characters are in a string
2229 void VM_strlen(prvm_prog_t *prog)
2230 {
2231         VM_SAFEPARMCOUNT(1,VM_strlen);
2232
2233         //PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0));
2234         PRVM_G_FLOAT(OFS_RETURN) = u8_strlen(PRVM_G_STRING(OFS_PARM0));
2235 }
2236
2237 // DRESK - Decolorized String
2238 /*
2239 =========
2240 VM_strdecolorize
2241
2242 string  strdecolorize(string s)
2243 =========
2244 */
2245 // string (string s) strdecolorize = #472; // returns the passed in string with color codes stripped
2246 void VM_strdecolorize(prvm_prog_t *prog)
2247 {
2248         char szNewString[VM_STRINGTEMP_LENGTH];
2249         const char *szString;
2250
2251         // Prepare Strings
2252         VM_SAFEPARMCOUNT(1,VM_strdecolorize);
2253         szString = PRVM_G_STRING(OFS_PARM0);
2254         COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), true);
2255         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, szNewString);
2256 }
2257
2258 // DRESK - String Length (not counting color codes)
2259 /*
2260 =========
2261 VM_strlennocol
2262
2263 float   strlennocol(string s)
2264 =========
2265 */
2266 // float(string s) strlennocol = #471; // returns how many characters are in a string not including color codes
2267 // For example, ^2Dresk returns a length of 5
2268 void VM_strlennocol(prvm_prog_t *prog)
2269 {
2270         const char *szString;
2271         int nCnt;
2272
2273         VM_SAFEPARMCOUNT(1,VM_strlennocol);
2274
2275         szString = PRVM_G_STRING(OFS_PARM0);
2276
2277         //nCnt = (int)COM_StringLengthNoColors(szString, 0, NULL);
2278         nCnt = (int)u8_COM_StringLengthNoColors(szString, 0, NULL);
2279
2280         PRVM_G_FLOAT(OFS_RETURN) = nCnt;
2281 }
2282
2283 // DRESK - String to Uppercase and Lowercase
2284 /*
2285 =========
2286 VM_strtolower
2287
2288 string  strtolower(string s)
2289 =========
2290 */
2291 // string (string s) strtolower = #480; // returns passed in string in lowercase form
2292 void VM_strtolower(prvm_prog_t *prog)
2293 {
2294         char szNewString[VM_STRINGTEMP_LENGTH];
2295         const char *szString;
2296
2297         // Prepare Strings
2298         VM_SAFEPARMCOUNT(1,VM_strtolower);
2299         szString = PRVM_G_STRING(OFS_PARM0);
2300
2301         COM_ToLowerString(szString, szNewString, sizeof(szNewString) );
2302
2303         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, szNewString);
2304 }
2305
2306 /*
2307 =========
2308 VM_strtoupper
2309
2310 string  strtoupper(string s)
2311 =========
2312 */
2313 // string (string s) strtoupper = #481; // returns passed in string in uppercase form
2314 void VM_strtoupper(prvm_prog_t *prog)
2315 {
2316         char szNewString[VM_STRINGTEMP_LENGTH];
2317         const char *szString;
2318
2319         // Prepare Strings
2320         VM_SAFEPARMCOUNT(1,VM_strtoupper);
2321         szString = PRVM_G_STRING(OFS_PARM0);
2322
2323         COM_ToUpperString(szString, szNewString, sizeof(szNewString) );
2324
2325         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, szNewString);
2326 }
2327
2328 /*
2329 =========
2330 VM_strcat
2331
2332 string strcat(string s, string...)
2333 =========
2334 */
2335 //string(string s, string...) strcat = #115;
2336 // concatenates strings (for example "abc", "def" would return "abcdef")
2337 // and returns as a tempstring
2338 void VM_strcat(prvm_prog_t *prog)
2339 {
2340         char s[VM_STRINGTEMP_LENGTH];
2341         VM_SAFEPARMCOUNTRANGE(1, 8, VM_strcat);
2342
2343         VM_VarString(prog, 0, s, sizeof(s));
2344         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, s);
2345 }
2346
2347 /*
2348 =========
2349 VM_substring
2350
2351 string  substring(string s, float start, float length)
2352 =========
2353 */
2354 // string(string s, float start, float length) substring = #116;
2355 // returns a section of a string as a tempstring
2356 void VM_substring(prvm_prog_t *prog)
2357 {
2358         int start, length;
2359         int u_slength = 0, u_start;
2360         size_t u_length;
2361         const char *s;
2362         char string[VM_STRINGTEMP_LENGTH];
2363
2364         VM_SAFEPARMCOUNT(3,VM_substring);
2365
2366         /*
2367         s = PRVM_G_STRING(OFS_PARM0);
2368         start = (int)PRVM_G_FLOAT(OFS_PARM1);
2369         length = (int)PRVM_G_FLOAT(OFS_PARM2);
2370         slength = strlen(s);
2371
2372         if (start < 0) // FTE_STRINGS feature
2373                 start += slength;
2374         start = bound(0, start, slength);
2375
2376         if (length < 0) // FTE_STRINGS feature
2377                 length += slength - start + 1;
2378         maxlen = min((int)sizeof(string) - 1, slength - start);
2379         length = bound(0, length, maxlen);
2380
2381         memcpy(string, s + start, length);
2382         string[length] = 0;
2383         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
2384         */
2385
2386         s = PRVM_G_STRING(OFS_PARM0);
2387         start = (int)PRVM_G_FLOAT(OFS_PARM1);
2388         length = (int)PRVM_G_FLOAT(OFS_PARM2);
2389
2390         if (start < 0) // FTE_STRINGS feature
2391         {
2392                 u_slength = (int)u8_strlen(s);
2393                 start += u_slength;
2394                 start = bound(0, start, u_slength);
2395         }
2396
2397         if (length < 0) // FTE_STRINGS feature
2398         {
2399                 if (!u_slength) // it's not calculated when it's not needed above
2400                         u_slength = (int)u8_strlen(s);
2401                 length += u_slength - start + 1;
2402         }
2403
2404         // positive start, positive length
2405         u_start = u8_byteofs(s, start, NULL);
2406         if (u_start < 0)
2407         {
2408                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
2409                 return;
2410         }
2411         u_length = u8_bytelen(s + u_start, length);
2412         if (u_length >= sizeof(string)-1)
2413                 u_length = sizeof(string)-1;
2414
2415         memcpy(string, s + u_start, u_length);
2416         string[u_length] = 0;
2417         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
2418 }
2419
2420 /*
2421 =========
2422 VM_strreplace
2423
2424 string(string search, string replace, string subject) strreplace = #484;
2425 =========
2426 */
2427 // replaces all occurrences of search with replace in the string subject, and returns the result
2428 void VM_strreplace(prvm_prog_t *prog)
2429 {
2430         int i, j, si;
2431         const char *search, *replace, *subject;
2432         char string[VM_STRINGTEMP_LENGTH];
2433         int search_len, replace_len, subject_len;
2434
2435         VM_SAFEPARMCOUNT(3,VM_strreplace);
2436
2437         search = PRVM_G_STRING(OFS_PARM0);
2438         replace = PRVM_G_STRING(OFS_PARM1);
2439         subject = PRVM_G_STRING(OFS_PARM2);
2440
2441         search_len = (int)strlen(search);
2442         replace_len = (int)strlen(replace);
2443         subject_len = (int)strlen(subject);
2444
2445         si = 0;
2446         for (i = 0; i <= subject_len - search_len; i++)
2447         {
2448                 for (j = 0; j < search_len; j++) // thus, i+j < subject_len
2449                         if (subject[i+j] != search[j])
2450                                 break;
2451                 if (j == search_len)
2452                 {
2453                         // NOTE: if search_len == 0, we always hit THIS case, and never the other
2454                         // found it at offset 'i'
2455                         for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
2456                                 string[si++] = replace[j];
2457                         if(search_len > 0)
2458                         {
2459                                 i += search_len - 1;
2460                         }
2461                         else
2462                         {
2463                                 // the above would subtract 1 from i... so we
2464                                 // don't do that, but instead output the next
2465                                 // char
2466                                 if (si < (int)sizeof(string) - 1)
2467                                         string[si++] = subject[i];
2468                         }
2469                 }
2470                 else
2471                 {
2472                         // in THIS case, we know search_len > 0, thus i < subject_len
2473                         // not found
2474                         if (si < (int)sizeof(string) - 1)
2475                                 string[si++] = subject[i];
2476                 }
2477         }
2478         // remaining chars (these cannot match)
2479         for (; i < subject_len; i++)
2480                 if (si < (int)sizeof(string) - 1)
2481                         string[si++] = subject[i];
2482         string[si] = '\0';
2483
2484         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
2485 }
2486
2487 /*
2488 =========
2489 VM_strireplace
2490
2491 string(string search, string replace, string subject) strireplace = #485;
2492 =========
2493 */
2494 // case-insensitive version of strreplace
2495 void VM_strireplace(prvm_prog_t *prog)
2496 {
2497         int i, j, si;
2498         const char *search, *replace, *subject;
2499         char string[VM_STRINGTEMP_LENGTH];
2500         int search_len, replace_len, subject_len;
2501
2502         VM_SAFEPARMCOUNT(3, VM_strireplace);
2503
2504         search = PRVM_G_STRING(OFS_PARM0);
2505         replace = PRVM_G_STRING(OFS_PARM1);
2506         subject = PRVM_G_STRING(OFS_PARM2);
2507
2508         search_len = (int)strlen(search);
2509         replace_len = (int)strlen(replace);
2510         subject_len = (int)strlen(subject);
2511
2512         si = 0;
2513         for (i = 0; i <= subject_len - search_len; i++)
2514         {
2515                 for (j = 0; j < search_len; j++) // thus, i+j < subject_len
2516                         if (tolower(subject[i+j]) != tolower(search[j]))
2517                                 break;
2518                 if (j == search_len)
2519                 {
2520                         // NOTE: if search_len == 0, we always hit THIS case, and never the other
2521                         // found it at offset 'i'
2522                         for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
2523                                 string[si++] = replace[j];
2524                         if(search_len > 0)
2525                         {
2526                                 i += search_len - 1;
2527                         }
2528                         else
2529                         {
2530                                 // the above would subtract 1 from i... so we
2531                                 // don't do that, but instead output the next
2532                                 // char
2533                                 if (si < (int)sizeof(string) - 1)
2534                                         string[si++] = subject[i];
2535                         }
2536                 }
2537                 else
2538                 {
2539                         // in THIS case, we know search_len > 0, thus i < subject_len
2540                         // not found
2541                         if (si < (int)sizeof(string) - 1)
2542                                 string[si++] = subject[i];
2543                 }
2544         }
2545         // remaining chars (these cannot match)
2546         for (; i < subject_len; i++)
2547                 if (si < (int)sizeof(string) - 1)
2548                         string[si++] = subject[i];
2549         string[si] = '\0';
2550
2551         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
2552 }
2553
2554 /*
2555 =========
2556 VM_stov
2557
2558 vector  stov(string s)
2559 =========
2560 */
2561 //vector(string s) stov = #117; // returns vector value from a string
2562 void VM_stov(prvm_prog_t *prog)
2563 {
2564         char string[VM_STRINGTEMP_LENGTH];
2565
2566         VM_SAFEPARMCOUNT(1,VM_stov);
2567
2568         VM_VarString(prog, 0, string, sizeof(string));
2569         Math_atov(string, PRVM_G_VECTOR(OFS_RETURN));
2570 }
2571
2572 /*
2573 =========
2574 VM_strzone
2575
2576 string  strzone(string s)
2577 =========
2578 */
2579 //string(string s, ...) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
2580 void VM_strzone(prvm_prog_t *prog)
2581 {
2582         char *out;
2583         char string[VM_STRINGTEMP_LENGTH];
2584         size_t alloclen;
2585
2586         VM_SAFEPARMCOUNT(1,VM_strzone);
2587
2588         VM_VarString(prog, 0, string, sizeof(string));
2589         alloclen = strlen(string) + 1;
2590         PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(prog, alloclen, &out);
2591         memcpy(out, string, alloclen);
2592 }
2593
2594 /*
2595 =========
2596 VM_strunzone
2597
2598 strunzone(string s)
2599 =========
2600 */
2601 //void(string s) strunzone = #119; // removes a copy of a string from the string zone (you can not use that string again or it may crash!!!)
2602 void VM_strunzone(prvm_prog_t *prog)
2603 {
2604         VM_SAFEPARMCOUNT(1,VM_strunzone);
2605         PRVM_FreeString(prog, PRVM_G_INT(OFS_PARM0));
2606 }
2607
2608 /*
2609 =========
2610 VM_tokenize
2611
2612 float tokenize(string s)
2613 =========
2614 */
2615 //float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
2616 //this function originally written by KrimZon, made shorter by LadyHavoc
2617 //20040203: rewritten by LadyHavoc (no longer uses allocations)
2618 static int num_tokens = 0;
2619 static int tokens[VM_STRINGTEMP_LENGTH / 2];
2620 static int tokens_startpos[VM_STRINGTEMP_LENGTH / 2];
2621 static int tokens_endpos[VM_STRINGTEMP_LENGTH / 2];
2622 static char tokenize_string[VM_STRINGTEMP_LENGTH];
2623 void VM_tokenize (prvm_prog_t *prog)
2624 {
2625         const char *p;
2626
2627         VM_SAFEPARMCOUNT(1,VM_tokenize);
2628
2629         strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
2630         p = tokenize_string;
2631
2632         num_tokens = 0;
2633         for(;;)
2634         {
2635                 if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
2636                         break;
2637
2638                 // skip whitespace here to find token start pos
2639                 while(*p && ISWHITESPACE(*p))
2640                         ++p;
2641
2642                 tokens_startpos[num_tokens] = p - tokenize_string;
2643                 if(!COM_ParseToken_VM_Tokenize(&p, false))
2644                         break;
2645                 tokens_endpos[num_tokens] = p - tokenize_string;
2646                 tokens[num_tokens] = PRVM_SetTempString(prog, com_token);
2647                 ++num_tokens;
2648         }
2649
2650         PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
2651 }
2652
2653 //float(string s) tokenize = #514; // takes apart a string into individal words (access them with argv), returns how many
2654 void VM_tokenize_console (prvm_prog_t *prog)
2655 {
2656         const char *p;
2657
2658         VM_SAFEPARMCOUNT(1, VM_tokenize_console);
2659
2660         strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
2661         p = tokenize_string;
2662
2663         num_tokens = 0;
2664         for(;;)
2665         {
2666                 if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
2667                         break;
2668
2669                 // skip whitespace here to find token start pos
2670                 while(*p && ISWHITESPACE(*p))
2671                         ++p;
2672
2673                 tokens_startpos[num_tokens] = p - tokenize_string;
2674                 if(!COM_ParseToken_Console(&p))
2675                         break;
2676                 tokens_endpos[num_tokens] = p - tokenize_string;
2677                 tokens[num_tokens] = PRVM_SetTempString(prog, com_token);
2678                 ++num_tokens;
2679         }
2680
2681         PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
2682 }
2683
2684 /*
2685 =========
2686 VM_tokenizebyseparator
2687
2688 float tokenizebyseparator(string s, string separator1, ...)
2689 =========
2690 */
2691 //float(string s, string separator1, ...) tokenizebyseparator = #479; // takes apart a string into individal words (access them with argv), returns how many
2692 //this function returns the token preceding each instance of a separator (of
2693 //which there can be multiple), and the text following the last separator
2694 //useful for parsing certain kinds of data like IP addresses
2695 //example:
2696 //numnumbers = tokenizebyseparator("10.1.2.3", ".");
2697 //returns 4 and the tokens "10" "1" "2" "3".
2698 void VM_tokenizebyseparator (prvm_prog_t *prog)
2699 {
2700         int j, k;
2701         int numseparators;
2702         int separatorlen[7];
2703         const char *separators[7];
2704         const char *p, *p0;
2705         const char *token;
2706         char tokentext[MAX_INPUTLINE];
2707
2708         VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
2709
2710         strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
2711         p = tokenize_string;
2712
2713         numseparators = 0;
2714         for (j = 1;j < prog->argc;j++)
2715         {
2716                 // skip any blank separator strings
2717                 const char *s = PRVM_G_STRING(OFS_PARM0+j*3);
2718                 if (!s[0])
2719                         continue;
2720                 separators[numseparators] = s;
2721                 separatorlen[numseparators] = (int)strlen(s);
2722                 numseparators++;
2723         }
2724
2725         num_tokens = 0;
2726         j = 0;
2727
2728         while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0])))
2729         {
2730                 token = tokentext + j;
2731                 tokens_startpos[num_tokens] = p - tokenize_string;
2732                 p0 = p;
2733                 while (*p)
2734                 {
2735                         for (k = 0;k < numseparators;k++)
2736                         {
2737                                 if (!strncmp(p, separators[k], separatorlen[k]))
2738                                 {
2739                                         p += separatorlen[k];
2740                                         break;
2741                                 }
2742                         }
2743                         if (k < numseparators)
2744                                 break;
2745                         if (j < (int)sizeof(tokentext)-1)
2746                                 tokentext[j++] = *p;
2747                         p++;
2748                         p0 = p;
2749                 }
2750                 tokens_endpos[num_tokens] = p0 - tokenize_string;
2751                 if (j >= (int)sizeof(tokentext))
2752                         break;
2753                 tokentext[j++] = 0;
2754                 tokens[num_tokens++] = PRVM_SetTempString(prog, token);
2755                 if (!*p)
2756                         break;
2757         }
2758
2759         PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
2760 }
2761
2762 //string(float n) argv = #442; // returns a word from the tokenized string (returns nothing for an invalid index)
2763 //this function originally written by KrimZon, made shorter by LadyHavoc
2764 void VM_argv (prvm_prog_t *prog)
2765 {
2766         int token_num;
2767
2768         VM_SAFEPARMCOUNT(1,VM_argv);
2769
2770         token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
2771
2772         if(token_num < 0)
2773                 token_num += num_tokens;
2774
2775         if (token_num >= 0 && token_num < num_tokens)
2776                 PRVM_G_INT(OFS_RETURN) = tokens[token_num];
2777         else
2778                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2779 }
2780
2781 //float(float n) argv_start_index = #515; // returns the start index of a token
2782 void VM_argv_start_index (prvm_prog_t *prog)
2783 {
2784         int token_num;
2785
2786         VM_SAFEPARMCOUNT(1,VM_argv);
2787
2788         token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
2789
2790         if(token_num < 0)
2791                 token_num += num_tokens;
2792
2793         if (token_num >= 0 && token_num < num_tokens)
2794                 PRVM_G_FLOAT(OFS_RETURN) = tokens_startpos[token_num];
2795         else
2796                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2797 }
2798
2799 //float(float n) argv_end_index = #516; // returns the end index of a token
2800 void VM_argv_end_index (prvm_prog_t *prog)
2801 {
2802         int token_num;
2803
2804         VM_SAFEPARMCOUNT(1,VM_argv);
2805
2806         token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
2807
2808         if(token_num < 0)
2809                 token_num += num_tokens;
2810
2811         if (token_num >= 0 && token_num < num_tokens)
2812                 PRVM_G_FLOAT(OFS_RETURN) = tokens_endpos[token_num];
2813         else
2814                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2815 }
2816
2817 /*
2818 =========
2819 VM_isserver
2820
2821 float   isserver()
2822 =========
2823 */
2824 void VM_isserver(prvm_prog_t *prog)
2825 {
2826         VM_SAFEPARMCOUNT(0, VM_isserver);
2827
2828         PRVM_G_FLOAT(OFS_RETURN) = sv.active;
2829 }
2830
2831 /*
2832 =========
2833 VM_clientcount
2834
2835 float   clientcount()
2836 =========
2837 */
2838 void VM_clientcount(prvm_prog_t *prog)
2839 {
2840         VM_SAFEPARMCOUNT(0,VM_clientcount);
2841
2842         PRVM_G_FLOAT(OFS_RETURN) = svs.maxclients;
2843 }
2844
2845 /*
2846 =========
2847 VM_clientstate
2848
2849 float   clientstate()
2850 =========
2851 */
2852 void VM_clientstate(prvm_prog_t *prog)
2853 {
2854         VM_SAFEPARMCOUNT(0,VM_clientstate);
2855
2856
2857         switch( cls.state ) {
2858                 case ca_uninitialized:
2859                 case ca_dedicated:
2860                         PRVM_G_FLOAT(OFS_RETURN) = 0;
2861                         break;
2862                 case ca_disconnected:
2863                         PRVM_G_FLOAT(OFS_RETURN) = 1;
2864                         break;
2865                 case ca_connected:
2866                         PRVM_G_FLOAT(OFS_RETURN) = 2;
2867                         break;
2868                 default:
2869                         // should never be reached!
2870                         break;
2871         }
2872 }
2873
2874 /*
2875 =========
2876 VM_getostype
2877
2878 float   getostype(prvm_prog_t *prog)
2879 =========
2880 */ // not used at the moment -> not included in the common list
2881 void VM_getostype(prvm_prog_t *prog)
2882 {
2883         VM_SAFEPARMCOUNT(0,VM_getostype);
2884
2885         /*
2886         OS_WINDOWS
2887         OS_LINUX
2888         OS_MAC - not supported
2889         */
2890
2891 #ifdef WIN32
2892         PRVM_G_FLOAT(OFS_RETURN) = 0;
2893 #elif defined(MACOSX)
2894         PRVM_G_FLOAT(OFS_RETURN) = 2;
2895 #else
2896         PRVM_G_FLOAT(OFS_RETURN) = 1;
2897 #endif
2898 }
2899
2900 /*
2901 =========
2902 VM_gettime
2903
2904 float   gettime(prvm_prog_t *prog)
2905 =========
2906 */
2907 float CDAudio_GetPosition(void);
2908 void VM_gettime(prvm_prog_t *prog)
2909 {
2910         int timer_index;
2911
2912         VM_SAFEPARMCOUNTRANGE(0,1,VM_gettime);
2913
2914         if(prog->argc == 0)
2915         {
2916                 PRVM_G_FLOAT(OFS_RETURN) = (prvm_vec_t) host.realtime;
2917         }
2918         else
2919         {
2920                 timer_index = (int) PRVM_G_FLOAT(OFS_PARM0);
2921                 switch(timer_index)
2922                 {
2923                         case 0: // GETTIME_FRAMESTART
2924                                 PRVM_G_FLOAT(OFS_RETURN) = host.realtime;
2925                                 break;
2926                         case 1: // GETTIME_REALTIME
2927                                 PRVM_G_FLOAT(OFS_RETURN) = Sys_DirtyTime();
2928                                 break;
2929                         case 2: // GETTIME_HIRES
2930                                 PRVM_G_FLOAT(OFS_RETURN) = (Sys_DirtyTime() - host.dirtytime);
2931                                 break;
2932                         case 3: // GETTIME_UPTIME
2933                                 PRVM_G_FLOAT(OFS_RETURN) = host.realtime;
2934                                 break;
2935                         case 4: // GETTIME_CDTRACK
2936                                 PRVM_G_FLOAT(OFS_RETURN) = CDAudio_GetPosition();
2937                                 break;
2938                         default:
2939                                 VM_Warning(prog, "VM_gettime: %s: unsupported timer specified, returning realtime\n", prog->name);
2940                                 PRVM_G_FLOAT(OFS_RETURN) = host.realtime;
2941                                 break;
2942                 }
2943         }
2944 }
2945
2946 /*
2947 =========
2948 VM_getsoundtime
2949
2950 float   getsoundtime(prvm_prog_t *prog)
2951 =========
2952 */
2953
2954 void VM_getsoundtime (prvm_prog_t *prog)
2955 {
2956         int entnum, entchannel;
2957         VM_SAFEPARMCOUNT(2,VM_getsoundtime);
2958
2959         if (prog == SVVM_prog)
2960                 entnum = PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0));
2961         else if (prog == CLVM_prog)
2962                 entnum = MAX_EDICTS + PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0));
2963         else
2964         {
2965                 VM_Warning(prog, "VM_getsoundtime: %s: not supported on this progs\n", prog->name);
2966                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2967                 return;
2968         }
2969         entchannel = (int)PRVM_G_FLOAT(OFS_PARM1);
2970         entchannel = CHAN_USER2ENGINE(entchannel);
2971         if (!IS_CHAN(entchannel))
2972                 VM_Warning(prog, "VM_getsoundtime: %s: bad channel %i\n", prog->name, entchannel);
2973         PRVM_G_FLOAT(OFS_RETURN) = (prvm_vec_t)S_GetEntChannelPosition(entnum, entchannel);
2974 }
2975
2976 /*
2977 =========
2978 VM_GetSoundLen
2979
2980 string  soundlength (string sample)
2981 =========
2982 */
2983 void VM_soundlength (prvm_prog_t *prog)
2984 {
2985         const char *s;
2986
2987         VM_SAFEPARMCOUNT(1, VM_soundlength);
2988
2989         s = PRVM_G_STRING(OFS_PARM0);
2990         PRVM_G_FLOAT(OFS_RETURN) = S_SoundLength(s);
2991 }
2992
2993 /*
2994 =========
2995 VM_loadfromdata
2996
2997 loadfromdata(string data)
2998 =========
2999 */
3000 void VM_loadfromdata(prvm_prog_t *prog)
3001 {
3002         VM_SAFEPARMCOUNT(1, VM_loadfromdata);
3003
3004         PRVM_ED_LoadFromFile(prog, PRVM_G_STRING(OFS_PARM0));
3005 }
3006
3007 /*
3008 ========================
3009 VM_parseentitydata
3010
3011 parseentitydata(entity ent, string data)
3012 ========================
3013 */
3014 void VM_parseentitydata(prvm_prog_t *prog)
3015 {
3016         prvm_edict_t *ent;
3017         const char *data;
3018
3019         VM_SAFEPARMCOUNT(2, VM_parseentitydata);
3020
3021         // get edict and test it
3022         ent = PRVM_G_EDICT(OFS_PARM0);
3023         if (ent->free)
3024                 prog->error_cmd("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!", prog->name, PRVM_NUM_FOR_EDICT(ent));
3025
3026         data = PRVM_G_STRING(OFS_PARM1);
3027
3028         // parse the opening brace
3029         if (!COM_ParseToken_Simple(&data, false, false, true) || com_token[0] != '{' )
3030                 prog->error_cmd("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", prog->name, data );
3031
3032         PRVM_ED_ParseEdict (prog, data, ent);
3033 }
3034
3035 /*
3036 =========
3037 VM_loadfromfile
3038
3039 loadfromfile(string file)
3040 =========
3041 */
3042 void VM_loadfromfile(prvm_prog_t *prog)
3043 {
3044         const char *filename;
3045         char *data;
3046
3047         VM_SAFEPARMCOUNT(1,VM_loadfromfile);
3048
3049         filename = PRVM_G_STRING(OFS_PARM0);
3050         if (FS_CheckNastyPath(filename, false))
3051         {
3052                 PRVM_G_FLOAT(OFS_RETURN) = -4;
3053                 VM_Warning(prog, "VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", prog->name, filename);
3054                 return;
3055         }
3056
3057         // not conform with VM_fopen
3058         data = (char *)FS_LoadFile(filename, tempmempool, false, NULL);
3059         if (data == NULL)
3060                 PRVM_G_FLOAT(OFS_RETURN) = -1;
3061
3062         PRVM_ED_LoadFromFile(prog, data);
3063
3064         if(data)
3065                 Mem_Free(data);
3066 }
3067
3068
3069 /*
3070 =========
3071 VM_modulo
3072
3073 float   mod(float val, float m)
3074 =========
3075 */
3076 void VM_modulo(prvm_prog_t *prog)
3077 {
3078         vec_t val, m;
3079
3080         VM_SAFEPARMCOUNT(2, VM_modulo);
3081
3082         val = PRVM_G_FLOAT(OFS_PARM0);
3083         m   = PRVM_G_FLOAT(OFS_PARM1);
3084
3085         // matches how gmqcc implements % when mod() builtin isn't defined, and FTEQW mod()
3086         if (m)
3087                 PRVM_G_FLOAT(OFS_RETURN) = val - m * (prvm_int_t)(val / m);
3088         else
3089         {
3090                 VM_Warning(prog, "Attempted modulo of %f by zero\n", val);
3091                 PRVM_G_FLOAT(OFS_RETURN) = 0;
3092         }
3093 }
3094
3095 static void VM_Search_Init(prvm_prog_t *prog)
3096 {
3097         int i;
3098         for (i = 0;i < PRVM_MAX_OPENSEARCHES;i++)
3099                 prog->opensearches[i] = NULL;
3100 }
3101
3102 static void VM_Search_Reset(prvm_prog_t *prog)
3103 {
3104         int i;
3105         // reset the fssearch list
3106         for(i = 0; i < PRVM_MAX_OPENSEARCHES; i++)
3107         {
3108                 if(prog->opensearches[i])
3109                         FS_FreeSearch(prog->opensearches[i]);
3110                 prog->opensearches[i] = NULL;
3111         }
3112 }
3113
3114 /*
3115 =========
3116 VM_search_begin
3117
3118 float search_begin(string pattern, float caseinsensitive, float quiet[, string packfile])
3119 =========
3120 */
3121 void VM_search_begin(prvm_prog_t *prog)
3122 {
3123         int handle;
3124         const char *packfile = NULL, *pattern;
3125         int caseinsens, quiet;
3126
3127         VM_SAFEPARMCOUNTRANGE(3, 4, VM_search_begin);
3128
3129         pattern = PRVM_G_STRING(OFS_PARM0);
3130
3131         VM_CheckEmptyString(prog, pattern);
3132
3133         caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1);
3134         quiet = (int)PRVM_G_FLOAT(OFS_PARM2);
3135
3136         // optional packfile parameter (DP_QC_FS_SEARCH_PACKFILE)
3137         if(prog->argc >= 4)
3138                 packfile = PRVM_G_STRING(OFS_PARM3);
3139
3140         for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++)
3141                 if(!prog->opensearches[handle])
3142                         break;
3143
3144         if(handle >= PRVM_MAX_OPENSEARCHES)
3145         {
3146                 PRVM_G_FLOAT(OFS_RETURN) = -2;
3147                 VM_Warning(prog, "VM_search_begin: %s ran out of search handles (%i)\n", prog->name, PRVM_MAX_OPENSEARCHES);
3148                 return;
3149         }
3150
3151         if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet, packfile)))
3152                 PRVM_G_FLOAT(OFS_RETURN) = -1;
3153         else
3154         {
3155                 prog->opensearches_origin[handle] = PRVM_AllocationOrigin(prog);
3156                 PRVM_G_FLOAT(OFS_RETURN) = handle;
3157         }
3158 }
3159
3160 /*
3161 =========
3162 VM_search_end
3163
3164 void    search_end(float handle)
3165 =========
3166 */
3167 void VM_search_end(prvm_prog_t *prog)
3168 {
3169         int handle;
3170         VM_SAFEPARMCOUNT(1, VM_search_end);
3171
3172         handle = (int)PRVM_G_FLOAT(OFS_PARM0);
3173
3174         if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
3175         {
3176                 VM_Warning(prog, "VM_search_end: invalid handle %i used in %s\n", handle, prog->name);
3177                 return;
3178         }
3179         if(prog->opensearches[handle] == NULL)
3180         {
3181                 VM_Warning(prog, "VM_search_end: no such handle %i in %s\n", handle, prog->name);
3182                 return;
3183         }
3184
3185         FS_FreeSearch(prog->opensearches[handle]);
3186         prog->opensearches[handle] = NULL;
3187         if(prog->opensearches_origin[handle])
3188                 PRVM_Free((char *)prog->opensearches_origin[handle]);
3189 }
3190
3191 /*
3192 =========
3193 VM_search_getsize
3194
3195 float   search_getsize(float handle)
3196 =========
3197 */
3198 void VM_search_getsize(prvm_prog_t *prog)
3199 {
3200         int handle;
3201         VM_SAFEPARMCOUNT(1, VM_search_getsize);
3202
3203         handle = (int)PRVM_G_FLOAT(OFS_PARM0);
3204
3205         if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
3206         {
3207                 VM_Warning(prog, "VM_search_getsize: invalid handle %i used in %s\n", handle, prog->name);
3208                 return;
3209         }
3210         if(prog->opensearches[handle] == NULL)
3211         {
3212                 VM_Warning(prog, "VM_search_getsize: no such handle %i in %s\n", handle, prog->name);
3213                 return;
3214         }
3215
3216         PRVM_G_FLOAT(OFS_RETURN) = prog->opensearches[handle]->numfilenames;
3217 }
3218
3219 /*
3220 =========
3221 VM_search_getfilename
3222
3223 string  search_getfilename(float handle, float num)
3224 =========
3225 */
3226 void VM_search_getfilename(prvm_prog_t *prog)
3227 {
3228         int handle, filenum;
3229         VM_SAFEPARMCOUNT(2, VM_search_getfilename);
3230
3231         handle = (int)PRVM_G_FLOAT(OFS_PARM0);
3232         filenum = (int)PRVM_G_FLOAT(OFS_PARM1);
3233
3234         if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
3235         {
3236                 VM_Warning(prog, "VM_search_getfilename: invalid handle %i used in %s\n", handle, prog->name);
3237                 return;
3238         }
3239         if(prog->opensearches[handle] == NULL)
3240         {
3241                 VM_Warning(prog, "VM_search_getfilename: no such handle %i in %s\n", handle, prog->name);
3242                 return;
3243         }
3244         if(filenum < 0 || filenum >= prog->opensearches[handle]->numfilenames)
3245         {
3246                 VM_Warning(prog, "VM_search_getfilename: invalid filenum %i in %s\n", filenum, prog->name);
3247                 return;
3248         }
3249
3250         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, prog->opensearches[handle]->filenames[filenum]);
3251 }
3252
3253 /*
3254 =========
3255 VM_chr
3256
3257 string  chr(float ascii)
3258 =========
3259 */
3260 void VM_chr(prvm_prog_t *prog)
3261 {
3262         /*
3263         char tmp[2];
3264         VM_SAFEPARMCOUNT(1, VM_chr);
3265
3266         tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0);
3267         tmp[1] = 0;
3268
3269         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, tmp);
3270         */
3271
3272         char tmp[8];
3273         int len;
3274         VM_SAFEPARMCOUNT(1, VM_chr);
3275
3276         len = u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0), tmp, sizeof(tmp));
3277         tmp[len] = 0;
3278         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, tmp);
3279 }
3280
3281 /*
3282 =========
3283 VM_keynumtostring
3284
3285 string keynumtostring(float keynum)
3286 =========
3287 */
3288 void VM_keynumtostring (prvm_prog_t *prog)
3289 {
3290         char tinystr[TINYSTR_LEN];
3291         VM_SAFEPARMCOUNT(1, VM_keynumtostring);
3292
3293         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0), tinystr, TINYSTR_LEN));
3294 }
3295
3296 /*
3297 =========
3298 VM_findkeysforcommand
3299
3300 string  findkeysforcommand(string command, float bindmap)
3301
3302 the returned string is an altstring
3303 =========
3304 */
3305 #define FKFC_NUMKEYS 5
3306 void M_FindKeysForCommand(const char *command, int *keys);
3307 void VM_findkeysforcommand(prvm_prog_t *prog)
3308 {
3309         const char *cmd;
3310         char ret[VM_STRINGTEMP_LENGTH];
3311         int keys[FKFC_NUMKEYS];
3312         int i;
3313         int bindmap;
3314         char vabuf[1024];
3315
3316         VM_SAFEPARMCOUNTRANGE(1, 2, VM_findkeysforcommand);
3317
3318         cmd = PRVM_G_STRING(OFS_PARM0);
3319         if(prog->argc == 2)
3320                 bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM1), MAX_BINDMAPS-1);
3321         else
3322                 bindmap = 0; // consistent to "bind"
3323
3324         VM_CheckEmptyString(prog, cmd);
3325
3326         Key_FindKeysForCommand(cmd, keys, FKFC_NUMKEYS, bindmap);
3327
3328         ret[0] = 0;
3329         for(i = 0; i < FKFC_NUMKEYS; i++)
3330                 strlcat(ret, va(vabuf, sizeof(vabuf), " \'%i\'", keys[i]), sizeof(ret));
3331
3332         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, ret);
3333 }
3334
3335 /*
3336 =========
3337 VM_stringtokeynum
3338
3339 float stringtokeynum(string key)
3340 =========
3341 */
3342 void VM_stringtokeynum (prvm_prog_t *prog)
3343 {
3344         VM_SAFEPARMCOUNT( 1, VM_stringtokeynum );
3345
3346         PRVM_G_FLOAT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0));
3347 }
3348
3349 /*
3350 =========
3351 VM_getkeybind
3352
3353 string getkeybind(float key, float bindmap)
3354 =========
3355 */
3356 void VM_getkeybind (prvm_prog_t *prog)
3357 {
3358         int bindmap;
3359         VM_SAFEPARMCOUNTRANGE(1, 2, VM_getkeybind);
3360         if(prog->argc == 2)
3361                 bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM1), MAX_BINDMAPS-1);
3362         else
3363                 bindmap = 0; // consistent to "bind"
3364
3365         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0), bindmap));
3366 }
3367
3368 /*
3369 =========
3370 VM_setkeybind
3371
3372 float setkeybind(float key, string cmd, float bindmap)
3373 =========
3374 */
3375 void VM_setkeybind (prvm_prog_t *prog)
3376 {
3377         int bindmap;
3378         VM_SAFEPARMCOUNTRANGE(2, 3, VM_setkeybind);
3379         if(prog->argc == 3)
3380                 bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM2), MAX_BINDMAPS-1);
3381         else
3382                 bindmap = 0; // consistent to "bind"
3383
3384         PRVM_G_FLOAT(OFS_RETURN) = 0;
3385         if(Key_SetBinding((int)PRVM_G_FLOAT(OFS_PARM0), bindmap, PRVM_G_STRING(OFS_PARM1)))
3386                 PRVM_G_FLOAT(OFS_RETURN) = 1;
3387 }
3388
3389 /*
3390 =========
3391 VM_getbindmap
3392
3393 vector getbindmaps()
3394 =========
3395 */
3396 void VM_getbindmaps (prvm_prog_t *prog)
3397 {
3398         int fg, bg;
3399         VM_SAFEPARMCOUNT(0, VM_getbindmaps);
3400         Key_GetBindMap(&fg, &bg);
3401         PRVM_G_VECTOR(OFS_RETURN)[0] = fg;
3402         PRVM_G_VECTOR(OFS_RETURN)[1] = bg;
3403         PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
3404 }
3405
3406 /*
3407 =========
3408 VM_setbindmap
3409
3410 float setbindmaps(vector bindmap)
3411 =========
3412 */
3413 void VM_setbindmaps (prvm_prog_t *prog)
3414 {
3415         VM_SAFEPARMCOUNT(1, VM_setbindmaps);
3416         PRVM_G_FLOAT(OFS_RETURN) = 0;
3417         if(PRVM_G_VECTOR(OFS_PARM0)[2] == 0)
3418                 if(Key_SetBindMap((int)PRVM_G_VECTOR(OFS_PARM0)[0], (int)PRVM_G_VECTOR(OFS_PARM0)[1]))
3419                         PRVM_G_FLOAT(OFS_RETURN) = 1;
3420 }
3421
3422 /*
3423 ========================
3424 VM_gecko_create
3425
3426 float[bool] gecko_create( string name )
3427 ========================
3428 */
3429 void VM_gecko_create(prvm_prog_t *prog) {
3430         // REMOVED
3431         PRVM_G_FLOAT( OFS_RETURN ) = 0;
3432 }
3433
3434 /*
3435 ========================
3436 VM_gecko_destroy
3437
3438 void gecko_destroy( string name )
3439 ========================
3440 */
3441 void VM_gecko_destroy(prvm_prog_t *prog) {
3442         // REMOVED
3443 }
3444
3445 /*
3446 ========================
3447 VM_gecko_navigate
3448
3449 void gecko_navigate( string name, string URI )
3450 ========================
3451 */
3452 void VM_gecko_navigate(prvm_prog_t *prog) {
3453         // REMOVED
3454 }
3455
3456 /*
3457 ========================
3458 VM_gecko_keyevent
3459
3460 float[bool] gecko_keyevent( string name, float key, float eventtype )
3461 ========================
3462 */
3463 void VM_gecko_keyevent(prvm_prog_t *prog) {
3464         // REMOVED
3465         PRVM_G_FLOAT( OFS_RETURN ) = 0;
3466 }
3467
3468 /*
3469 ========================
3470 VM_gecko_movemouse
3471
3472 void gecko_mousemove( string name, float x, float y )
3473 ========================
3474 */
3475 void VM_gecko_movemouse(prvm_prog_t *prog) {
3476         // REMOVED
3477 }
3478
3479
3480 /*
3481 ========================
3482 VM_gecko_resize
3483
3484 void gecko_resize( string name, float w, float h )
3485 ========================
3486 */
3487 void VM_gecko_resize(prvm_prog_t *prog) {
3488         // REMOVED
3489 }
3490
3491
3492 /*
3493 ========================
3494 VM_gecko_get_texture_extent
3495
3496 vector gecko_get_texture_extent( string name )
3497 ========================
3498 */
3499 void VM_gecko_get_texture_extent(prvm_prog_t *prog) {
3500         // REMOVED
3501         PRVM_G_VECTOR(OFS_RETURN)[0] = 0;
3502         PRVM_G_VECTOR(OFS_RETURN)[1] = 0;
3503 }
3504
3505
3506
3507 /*
3508 ==============
3509 VM_makevectors
3510
3511 Writes new values for v_forward, v_up, and v_right based on angles
3512 void makevectors(vector angle)
3513 ==============
3514 */
3515 void VM_makevectors (prvm_prog_t *prog)
3516 {
3517         vec3_t angles, forward, right, up;
3518         VM_SAFEPARMCOUNT(1, VM_makevectors);
3519         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), angles);
3520         AngleVectors(angles, forward, right, up);
3521         VectorCopy(forward, PRVM_gameglobalvector(v_forward));
3522         VectorCopy(right, PRVM_gameglobalvector(v_right));
3523         VectorCopy(up, PRVM_gameglobalvector(v_up));
3524 }
3525
3526 /*
3527 ==============
3528 VM_vectorvectors
3529
3530 Writes new values for v_forward, v_up, and v_right based on the given forward vector
3531 vectorvectors(vector)
3532 ==============
3533 */
3534 void VM_vectorvectors (prvm_prog_t *prog)
3535 {
3536         vec3_t forward, right, up;
3537         VM_SAFEPARMCOUNT(1, VM_vectorvectors);
3538         VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), forward);
3539         VectorVectors(forward, right, up);
3540         VectorCopy(forward, PRVM_gameglobalvector(v_forward));
3541         VectorCopy(right, PRVM_gameglobalvector(v_right));
3542         VectorCopy(up, PRVM_gameglobalvector(v_up));
3543 }
3544
3545 // float(float number, float quantity) bitshift (EXT_BITSHIFT)
3546 void VM_bitshift (prvm_prog_t *prog)
3547 {
3548         prvm_int_t n1, n2;
3549         VM_SAFEPARMCOUNT(2, VM_bitshift);
3550
3551         n1 = (prvm_int_t)fabs((prvm_vec_t)((prvm_int_t)PRVM_G_FLOAT(OFS_PARM0)));
3552         n2 = (prvm_int_t)PRVM_G_FLOAT(OFS_PARM1);
3553         if(!n1)
3554                 PRVM_G_FLOAT(OFS_RETURN) = n1;
3555         else
3556         if(n2 < 0)
3557                 PRVM_G_FLOAT(OFS_RETURN) = (n1 >> -n2);
3558         else
3559                 PRVM_G_FLOAT(OFS_RETURN) = (n1 << n2);
3560 }
3561
3562 ////////////////////////////////////////
3563 // AltString functions
3564 ////////////////////////////////////////
3565
3566 /*
3567 ========================
3568 VM_altstr_count
3569
3570 float altstr_count(string)
3571 ========================
3572 */
3573 void VM_altstr_count(prvm_prog_t *prog)
3574 {
3575         const char *altstr, *pos;
3576         int     count;
3577
3578         VM_SAFEPARMCOUNT( 1, VM_altstr_count );
3579
3580         altstr = PRVM_G_STRING( OFS_PARM0 );
3581         //VM_CheckEmptyString(prog,  altstr );
3582
3583         for( count = 0, pos = altstr ; *pos ; pos++ ) {
3584                 if( *pos == '\\' ) {
3585                         if( !*++pos ) {
3586                                 break;
3587                         }
3588                 } else if( *pos == '\'' ) {
3589                         count++;
3590                 }
3591         }
3592
3593         PRVM_G_FLOAT( OFS_RETURN ) = (prvm_vec_t) (count / 2);
3594 }
3595
3596 /*
3597 ========================
3598 VM_altstr_prepare
3599
3600 string altstr_prepare(string)
3601 ========================
3602 */
3603 void VM_altstr_prepare(prvm_prog_t *prog)
3604 {
3605         const char *instr, *in;
3606         char outstr[VM_STRINGTEMP_LENGTH];
3607         size_t outpos;
3608
3609         VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
3610
3611         instr = PRVM_G_STRING( OFS_PARM0 );
3612
3613         for (in = instr, outpos = 0; *in && outpos < sizeof(outstr) - 1; ++in)
3614         {
3615                 if (*in == '\'' && outpos < sizeof(outstr) - 2)
3616                 {
3617                         outstr[outpos++] = '\\';
3618                         outstr[outpos++] = '\'';
3619                 }
3620                 else
3621                         outstr[outpos++] = *in;
3622         }
3623         outstr[outpos] = 0;
3624
3625         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog,  outstr );
3626 }
3627
3628 /*
3629 ========================
3630 VM_altstr_get
3631
3632 string altstr_get(string, float)
3633 ========================
3634 */
3635 void VM_altstr_get(prvm_prog_t *prog)
3636 {
3637         const char *altstr, *pos;
3638         char *out;
3639         int count, size;
3640         char outstr[VM_STRINGTEMP_LENGTH];
3641
3642         VM_SAFEPARMCOUNT( 2, VM_altstr_get );
3643
3644         altstr = PRVM_G_STRING( OFS_PARM0 );
3645
3646         count = (int)PRVM_G_FLOAT( OFS_PARM1 );
3647         count = count * 2 + 1;
3648
3649         for( pos = altstr ; *pos && count ; pos++ )
3650                 if( *pos == '\\' ) {
3651                         if( !*++pos )
3652                                 break;
3653                 } else if( *pos == '\'' )
3654                         count--;
3655
3656         if( !*pos ) {
3657                 PRVM_G_INT( OFS_RETURN ) = 0;
3658                 return;
3659         }
3660
3661         for( out = outstr, size = sizeof(outstr) - 1 ; size && *pos ; size--, pos++, out++ )
3662                 if( *pos == '\\' ) {
3663                         if( !*++pos )
3664                                 break;
3665                         *out = *pos;
3666                         size--;
3667                 } else if( *pos == '\'' )
3668                         break;
3669                 else
3670                         *out = *pos;
3671
3672         *out = 0;
3673         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog,  outstr );
3674 }
3675
3676 /*
3677 ========================
3678 VM_altstr_set
3679
3680 string altstr_set(string altstr, float num, string set)
3681 ========================
3682 */
3683 void VM_altstr_set(prvm_prog_t *prog)
3684 {
3685     int num;
3686         const char *altstr, *str;
3687         const char *in;
3688         char *out;
3689         char outstr[VM_STRINGTEMP_LENGTH];
3690
3691         VM_SAFEPARMCOUNT( 3, VM_altstr_set );
3692
3693         altstr = PRVM_G_STRING( OFS_PARM0 );
3694
3695         num = (int)PRVM_G_FLOAT( OFS_PARM1 );
3696
3697         str = PRVM_G_STRING( OFS_PARM2 );
3698
3699         out = outstr;
3700         for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ )
3701                 if( *in == '\\' ) {
3702                         if( !*++in ) {
3703                                 break;
3704                         }
3705                 } else if( *in == '\'' ) {
3706                         num--;
3707                 }
3708
3709         // copy set in
3710         for( ; *str; *out++ = *str++ );
3711         // now jump over the old content
3712         for( ; *in ; in++ )
3713                 if( *in == '\'' || (*in == '\\' && !*++in) )
3714                         break;
3715
3716         strlcpy(out, in, outstr + sizeof(outstr) - out);
3717         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog,  outstr );
3718 }
3719
3720 /*
3721 ========================
3722 VM_altstr_ins
3723 insert after num
3724 string  altstr_ins(string altstr, float num, string set)
3725 ========================
3726 */
3727 void VM_altstr_ins(prvm_prog_t *prog)
3728 {
3729         int num;
3730         const char *set;
3731         const char *in;
3732         char *out;
3733         char outstr[VM_STRINGTEMP_LENGTH];
3734
3735         VM_SAFEPARMCOUNT(3, VM_altstr_ins);
3736
3737         in = PRVM_G_STRING( OFS_PARM0 );
3738         num = (int)PRVM_G_FLOAT( OFS_PARM1 );
3739         set = PRVM_G_STRING( OFS_PARM2 );
3740
3741         out = outstr;
3742         for( num = num * 2 + 2 ; *in && num > 0 ; *out++ = *in++ )
3743                 if( *in == '\\' ) {
3744                         if( !*++in ) {
3745                                 break;
3746                         }
3747                 } else if( *in == '\'' ) {
3748                         num--;
3749                 }
3750
3751         *out++ = '\'';
3752         for( ; *set ; *out++ = *set++ );
3753         *out++ = '\'';
3754
3755         strlcpy(out, in, outstr + sizeof(outstr) - out);
3756         PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog,  outstr );
3757 }
3758
3759
3760 ////////////////////////////////////////
3761 // BufString functions
3762 ////////////////////////////////////////
3763 //[515]: string buffers support
3764
3765 static size_t stringbuffers_sortlength;
3766
3767 static void BufStr_Expand(prvm_prog_t *prog, prvm_stringbuffer_t *stringbuffer, int strindex)
3768 {
3769         if (stringbuffer->max_strings <= strindex)
3770         {
3771                 char **oldstrings = stringbuffer->strings;
3772                 stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
3773                 while (stringbuffer->max_strings <= strindex)
3774                         stringbuffer->max_strings *= 2;
3775                 stringbuffer->strings = (char **) Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
3776                 if (stringbuffer->num_strings > 0)
3777                         memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0]));
3778                 if (oldstrings)
3779                         Mem_Free(oldstrings);
3780         }
3781 }
3782
3783 static void BufStr_Shrink(prvm_prog_t *prog, prvm_stringbuffer_t *stringbuffer)
3784 {
3785         // reduce num_strings if there are empty string slots at the end
3786         while (stringbuffer->num_strings > 0 && stringbuffer->strings[stringbuffer->num_strings - 1] == NULL)
3787                 stringbuffer->num_strings--;
3788
3789         // if empty, free the string pointer array
3790         if (stringbuffer->num_strings == 0)
3791         {
3792                 stringbuffer->max_strings = 0;
3793                 if (stringbuffer->strings)
3794                         Mem_Free(stringbuffer->strings);
3795                 stringbuffer->strings = NULL;
3796         }
3797 }
3798
3799 static int BufStr_SortStringsUP (const void *in1, const void *in2)
3800 {
3801         const char *a, *b;
3802         a = *((const char **) in1);
3803         b = *((const char **) in2);
3804         if(!a || !a[0]) return 1;
3805         if(!b || !b[0]) return -1;
3806         return strncmp(a, b, stringbuffers_sortlength);
3807 }
3808
3809 static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
3810 {
3811         const char *a, *b;
3812         a = *((const char **) in1);
3813         b = *((const char **) in2);
3814         if(!a || !a[0]) return 1;
3815         if(!b || !b[0]) return -1;
3816         return strncmp(b, a, stringbuffers_sortlength);
3817 }
3818
3819 prvm_stringbuffer_t *BufStr_FindCreateReplace (prvm_prog_t *prog, int bufindex, int flags, const char *format)
3820 {
3821         prvm_stringbuffer_t *stringbuffer;
3822         int i;
3823
3824         if (bufindex < 0)
3825                 return NULL;
3826
3827         // find buffer with wanted index
3828         if (bufindex < (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray))
3829         {
3830                 if ( (stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, bufindex)) )
3831                 {
3832                         if (stringbuffer->flags & STRINGBUFFER_TEMP)
3833                                 stringbuffer->flags = flags; // created but has not been used yet
3834                         return stringbuffer;
3835                 }
3836                 return NULL;
3837         }
3838
3839         // allocate new buffer with wanted index
3840         while(1)
3841         {
3842                 stringbuffer = (prvm_stringbuffer_t *) Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
3843                 stringbuffer->flags = STRINGBUFFER_TEMP;
3844                 for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
3845                 if (i == bufindex)
3846                 {
3847                         stringbuffer->flags = flags; // mark as used
3848                         break;
3849                 }
3850         }
3851         return stringbuffer;
3852 }
3853
3854 void BufStr_Set(prvm_prog_t *prog, prvm_stringbuffer_t *stringbuffer, int strindex, const char *str)
3855 {
3856         size_t  alloclen;
3857
3858         if (!stringbuffer || strindex < 0)
3859                 return;
3860
3861         BufStr_Expand(prog, stringbuffer, strindex);
3862         stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
3863         if (stringbuffer->strings[strindex])
3864                 Mem_Free(stringbuffer->strings[strindex]);
3865         stringbuffer->strings[strindex] = NULL;
3866
3867         if (str)
3868         {
3869                 // not the NULL string!
3870                 alloclen = strlen(str) + 1;
3871                 stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
3872                 memcpy(stringbuffer->strings[strindex], str, alloclen);
3873         }
3874
3875         BufStr_Shrink(prog, stringbuffer);
3876 }
3877
3878 void BufStr_Del(prvm_prog_t *prog, prvm_stringbuffer_t *stringbuffer)
3879 {
3880         int i;
3881
3882         if (!stringbuffer)
3883                 return;
3884
3885         for (i = 0;i < stringbuffer->num_strings;i++)
3886                 if (stringbuffer->strings[i])
3887                         Mem_Free(stringbuffer->strings[i]);
3888         if (stringbuffer->strings)
3889                 Mem_Free(stringbuffer->strings);
3890         if(stringbuffer->origin)
3891                 PRVM_Free((char *)stringbuffer->origin);
3892         Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer);
3893 }
3894
3895 void BufStr_Flush(prvm_prog_t *prog)
3896 {
3897         prvm_stringbuffer_t *stringbuffer;
3898         int i, numbuffers;
3899
3900         numbuffers = (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray);
3901         for (i = 0; i < numbuffers; i++)
3902                 if ( (stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i)) )
3903                         BufStr_Del(prog, stringbuffer);
3904         Mem_ExpandableArray_NewArray(&prog->stringbuffersarray, prog->progs_mempool, sizeof(prvm_stringbuffer_t), 64);
3905 }
3906
3907 /*
3908 ========================
3909 VM_buf_create
3910 creates new buffer, and returns it's index, returns -1 if failed
3911 float buf_create(prvm_prog_t *prog) = #460;
3912 float newbuf(string format, float flags) = #460;
3913 ========================
3914 */
3915
3916 void VM_buf_create (prvm_prog_t *prog)
3917 {
3918         prvm_stringbuffer_t *stringbuffer;
3919         int i;
3920
3921         VM_SAFEPARMCOUNTRANGE(0, 2, VM_buf_create);
3922
3923         // VorteX: optional parm1 (buffer format) is unfinished, to keep intact with future databuffers extension must be set to "string"
3924         if(prog->argc >= 1 && strcmp(PRVM_G_STRING(OFS_PARM0), "string"))
3925         {
3926                 PRVM_G_FLOAT(OFS_RETURN) = -1;
3927                 return;
3928         }
3929         stringbuffer = (prvm_stringbuffer_t *) Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
3930         for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
3931         stringbuffer->origin = PRVM_AllocationOrigin(prog);
3932         // optional flags parm
3933         if (prog->argc >= 2)
3934                 stringbuffer->flags = (int)PRVM_G_FLOAT(OFS_PARM1) & STRINGBUFFER_QCFLAGS;
3935         PRVM_G_FLOAT(OFS_RETURN) = i;
3936 }
3937
3938
3939
3940 /*
3941 ========================
3942 VM_buf_del
3943 deletes buffer and all strings in it
3944 void buf_del(float bufhandle) = #461;
3945 ========================
3946 */
3947 void VM_buf_del (prvm_prog_t *prog)
3948 {
3949         prvm_stringbuffer_t *stringbuffer;
3950         VM_SAFEPARMCOUNT(1, VM_buf_del);
3951         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3952         if (stringbuffer)
3953                 BufStr_Del(prog, stringbuffer);
3954         else
3955         {
3956                 VM_Warning(prog, "VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
3957                 return;
3958         }
3959 }
3960
3961 /*
3962 ========================
3963 VM_buf_getsize
3964 how many strings are stored in buffer
3965 float buf_getsize(float bufhandle) = #462;
3966 ========================
3967 */
3968 void VM_buf_getsize (prvm_prog_t *prog)
3969 {
3970         prvm_stringbuffer_t *stringbuffer;
3971         VM_SAFEPARMCOUNT(1, VM_buf_getsize);
3972
3973         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3974         if(!stringbuffer)
3975         {
3976                 PRVM_G_FLOAT(OFS_RETURN) = -1;
3977                 VM_Warning(prog, "VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
3978                 return;
3979         }
3980         else
3981                 PRVM_G_FLOAT(OFS_RETURN) = stringbuffer->num_strings;
3982 }
3983
3984 /*
3985 ========================
3986 VM_buf_copy
3987 copy all content from one buffer to another, make sure it exists
3988 void buf_copy(float bufhandle_from, float bufhandle_to) = #463;
3989 ========================
3990 */
3991 void VM_buf_copy (prvm_prog_t *prog)
3992 {
3993         prvm_stringbuffer_t *srcstringbuffer, *dststringbuffer;
3994         int i;
3995         VM_SAFEPARMCOUNT(2, VM_buf_copy);
3996
3997         srcstringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
3998         if(!srcstringbuffer)
3999         {
4000                 VM_Warning(prog, "VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4001                 return;
4002         }
4003         i = (int)PRVM_G_FLOAT(OFS_PARM1);
4004         if(i == (int)PRVM_G_FLOAT(OFS_PARM0))
4005         {
4006                 VM_Warning(prog, "VM_buf_copy: source == destination (%i) in %s\n", i, prog->name);
4007                 return;
4008         }
4009         dststringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4010         if(!dststringbuffer)
4011         {
4012                 VM_Warning(prog, "VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), prog->name);
4013                 return;
4014         }
4015
4016         for (i = 0;i < dststringbuffer->num_strings;i++)
4017                 if (dststringbuffer->strings[i])
4018                         Mem_Free(dststringbuffer->strings[i]);
4019         if (dststringbuffer->strings)
4020                 Mem_Free(dststringbuffer->strings);
4021         *dststringbuffer = *srcstringbuffer;
4022         if (dststringbuffer->max_strings)
4023                 dststringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(dststringbuffer->strings[0]) * dststringbuffer->max_strings);
4024
4025         for (i = 0;i < dststringbuffer->num_strings;i++)
4026         {
4027                 if (srcstringbuffer->strings[i])
4028                 {
4029                         size_t stringlen;
4030                         stringlen = strlen(srcstringbuffer->strings[i]) + 1;
4031                         dststringbuffer->strings[i] = (char *)Mem_Alloc(prog->progs_mempool, stringlen);
4032                         memcpy(dststringbuffer->strings[i], srcstringbuffer->strings[i], stringlen);
4033                 }
4034         }
4035 }
4036
4037 /*
4038 ========================
4039 VM_buf_sort
4040 sort buffer by beginnings of strings (cmplength defaults it's length)
4041 "backward == true" means that sorting goes upside-down
4042 void buf_sort(float bufhandle, float cmplength, float backward) = #464;
4043 ========================
4044 */
4045 void VM_buf_sort (prvm_prog_t *prog)
4046 {
4047         prvm_stringbuffer_t *stringbuffer;
4048         VM_SAFEPARMCOUNT(3, VM_buf_sort);
4049
4050         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4051         if(!stringbuffer)
4052         {
4053                 VM_Warning(prog, "VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4054                 return;
4055         }
4056         if(stringbuffer->num_strings <= 0)
4057         {
4058                 VM_Warning(prog, "VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4059                 return;
4060         }
4061         stringbuffers_sortlength = (int)PRVM_G_FLOAT(OFS_PARM1);
4062         if(stringbuffers_sortlength <= 0)
4063                 stringbuffers_sortlength = 0x7FFFFFFF;
4064
4065         if(!PRVM_G_FLOAT(OFS_PARM2))
4066                 qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsUP);
4067         else
4068                 qsort(stringbuffer->strings, stringbuffer->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
4069
4070         BufStr_Shrink(prog, stringbuffer);
4071 }
4072
4073 /*
4074 ========================
4075 VM_buf_implode
4076 concantenates all buffer string into one with "glue" separator and returns it as tempstring
4077 string buf_implode(float bufhandle, string glue) = #465;
4078 ========================
4079 */
4080 void VM_buf_implode (prvm_prog_t *prog)
4081 {
4082         prvm_stringbuffer_t *stringbuffer;
4083         char                    k[VM_STRINGTEMP_LENGTH];
4084         const char              *sep;
4085         int                             i;
4086         size_t                  l;
4087         VM_SAFEPARMCOUNT(2, VM_buf_implode);
4088
4089         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4090         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
4091         if(!stringbuffer)
4092         {
4093                 VM_Warning(prog, "VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4094                 return;
4095         }
4096         if(!stringbuffer->num_strings)
4097                 return;
4098         sep = PRVM_G_STRING(OFS_PARM1);
4099         k[0] = 0;
4100         for(l = i = 0;i < stringbuffer->num_strings;i++)
4101         {
4102                 if(stringbuffer->strings[i])
4103                 {
4104                         l += (i > 0 ? strlen(sep) : 0) + strlen(stringbuffer->strings[i]);
4105                         if (l >= sizeof(k) - 1)
4106                                 break;
4107                         strlcat(k, sep, sizeof(k));
4108                         strlcat(k, stringbuffer->strings[i], sizeof(k));
4109                 }
4110         }
4111         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, k);
4112 }
4113
4114 /*
4115 ========================
4116 VM_bufstr_get
4117 get a string from buffer, returns tempstring, dont str_unzone it!
4118 string bufstr_get(float bufhandle, float string_index) = #465;
4119 ========================
4120 */
4121 void VM_bufstr_get (prvm_prog_t *prog)
4122 {
4123         prvm_stringbuffer_t *stringbuffer;
4124         int                             strindex;
4125         VM_SAFEPARMCOUNT(2, VM_bufstr_get);
4126
4127         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
4128         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4129         if(!stringbuffer)
4130         {
4131                 VM_Warning(prog, "VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4132                 return;
4133         }
4134         strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
4135         if (strindex < 0)
4136         {
4137                 // VM_Warning(prog, "VM_bufstr_get: invalid string index %i used in %s\n", strindex, prog->name);
4138                 return;
4139         }
4140         if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex])
4141                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, stringbuffer->strings[strindex]);
4142 }
4143
4144 /*
4145 ========================
4146 VM_bufstr_set
4147 copies a string into selected slot of buffer
4148 void bufstr_set(float bufhandle, float string_index, string str) = #466;
4149 ========================
4150 */
4151 void VM_bufstr_set (prvm_prog_t *prog)
4152 {
4153         int                             strindex;
4154         prvm_stringbuffer_t *stringbuffer;
4155         const char              *news;
4156
4157         VM_SAFEPARMCOUNT(3, VM_bufstr_set);
4158
4159         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4160         if(!stringbuffer)
4161         {
4162                 VM_Warning(prog, "VM_bufstr_set: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4163                 return;
4164         }
4165         strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
4166         if(strindex < 0 || strindex >= 1000000) // huge number of strings
4167         {
4168                 VM_Warning(prog, "VM_bufstr_set: invalid string index %i used in %s\n", strindex, prog->name);
4169                 return;
4170         }
4171
4172         news = PRVM_G_STRING(OFS_PARM2);
4173         BufStr_Set(prog, stringbuffer, strindex, news);
4174 }
4175
4176 /*
4177 ========================
4178 VM_bufstr_add
4179 adds string to buffer in first free slot and returns its index
4180 "order == true" means that string will be added after last "full" slot
4181 float bufstr_add(float bufhandle, string str, float order) = #467;
4182 ========================
4183 */
4184 void VM_bufstr_add (prvm_prog_t *prog)
4185 {
4186         int                             order, strindex;
4187         prvm_stringbuffer_t *stringbuffer;
4188         const char              *string;
4189         size_t                  alloclen;
4190
4191         VM_SAFEPARMCOUNT(3, VM_bufstr_add);
4192
4193         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4194         PRVM_G_FLOAT(OFS_RETURN) = -1;
4195         if(!stringbuffer)
4196         {
4197                 VM_Warning(prog, "VM_bufstr_add: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4198                 return;
4199         }
4200         if(!PRVM_G_INT(OFS_PARM1)) // NULL string
4201         {
4202                 VM_Warning(prog, "VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4203                 return;
4204         }
4205         string = PRVM_G_STRING(OFS_PARM1);
4206         order = (int)PRVM_G_FLOAT(OFS_PARM2);
4207         if(order)
4208                 strindex = stringbuffer->num_strings;
4209         else
4210                 for (strindex = 0;strindex < stringbuffer->num_strings;strindex++)
4211                         if (stringbuffer->strings[strindex] == NULL)
4212                                 break;
4213
4214         BufStr_Expand(prog, stringbuffer, strindex);
4215
4216         stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
4217         alloclen = strlen(string) + 1;
4218         stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
4219         memcpy(stringbuffer->strings[strindex], string, alloclen);
4220
4221         PRVM_G_FLOAT(OFS_RETURN) = strindex;
4222 }
4223
4224 /*
4225 ========================
4226 VM_bufstr_free
4227 delete string from buffer
4228 void bufstr_free(float bufhandle, float string_index) = #468;
4229 ========================
4230 */
4231 void VM_bufstr_free (prvm_prog_t *prog)
4232 {
4233         int                             i;
4234         prvm_stringbuffer_t     *stringbuffer;
4235         VM_SAFEPARMCOUNT(2, VM_bufstr_free);
4236
4237         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4238         if(!stringbuffer)
4239         {
4240                 VM_Warning(prog, "VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4241                 return;
4242         }
4243         i = (int)PRVM_G_FLOAT(OFS_PARM1);
4244         if(i < 0)
4245         {
4246                 VM_Warning(prog, "VM_bufstr_free: invalid string index %i used in %s\n", i, prog->name);
4247                 return;
4248         }
4249
4250         if (i < stringbuffer->num_strings)
4251         {
4252                 if(stringbuffer->strings[i])
4253                         Mem_Free(stringbuffer->strings[i]);
4254                 stringbuffer->strings[i] = NULL;
4255         }
4256
4257         BufStr_Shrink(prog, stringbuffer);
4258 }
4259
4260 /*
4261 ========================
4262 VM_buf_loadfile
4263 load a file into string buffer, return 0 or 1
4264 float buf_loadfile(string filename, float bufhandle) = #535;
4265 ========================
4266 */
4267 void VM_buf_loadfile(prvm_prog_t *prog)
4268 {
4269         size_t alloclen;
4270         prvm_stringbuffer_t *stringbuffer;
4271         char string[VM_STRINGTEMP_LENGTH];
4272         int strindex, c, end;
4273         const char *filename;
4274         char vabuf[1024];
4275         qfile_t *file;
4276
4277         VM_SAFEPARMCOUNT(2, VM_buf_loadfile);
4278
4279         // get file
4280         filename = PRVM_G_STRING(OFS_PARM0);
4281         file = FS_OpenVirtualFile(va(vabuf, sizeof(vabuf), "data/%s", filename), false);
4282         if (file == NULL)
4283                 file = FS_OpenVirtualFile(va(vabuf, sizeof(vabuf), "%s", filename), false);
4284         if (file == NULL)
4285         {
4286                 if (developer_extra.integer)
4287                         VM_Warning(prog, "VM_buf_loadfile: failed to open file %s in %s\n", filename, prog->name);
4288                 PRVM_G_FLOAT(OFS_RETURN) = 0;
4289                 return;
4290         }
4291
4292         // get string buffer
4293         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM1));
4294         if(!stringbuffer)
4295         {
4296                 VM_Warning(prog, "VM_buf_loadfile: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), prog->name);
4297                 PRVM_G_FLOAT(OFS_RETURN) = 0;
4298                 return;
4299         }
4300
4301         // read file (append to the end of buffer)
4302         strindex = stringbuffer->num_strings;
4303         while(1)
4304         {
4305                 // read line
4306                 end = 0;
4307                 for (;;)
4308                 {
4309                         c = FS_Getc(file);
4310                         if (c == '\r' || c == '\n' || c < 0)
4311                                 break;
4312                         if (end < VM_STRINGTEMP_LENGTH - 1)
4313                                 string[end++] = c;
4314                 }
4315                 string[end] = 0;
4316                 // remove \n following \r
4317                 if (c == '\r')
4318                 {
4319                         c = FS_Getc(file);
4320                         if (c != '\n')
4321                                 FS_UnGetc(file, (unsigned char)c);
4322                 }
4323                 // add and continue
4324                 if (c >= 0 || end)
4325                 {
4326                         BufStr_Expand(prog, stringbuffer, strindex);
4327                         stringbuffer->num_strings = max(stringbuffer->num_strings, strindex + 1);
4328                         alloclen = strlen(string) + 1;
4329                         stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
4330                         memcpy(stringbuffer->strings[strindex], string, alloclen);
4331                         strindex = stringbuffer->num_strings;
4332                 }
4333                 else
4334                         break;
4335         }
4336
4337         // close file
4338         FS_Close(file);
4339         PRVM_G_FLOAT(OFS_RETURN) = 1;
4340 }
4341
4342 /*
4343 ========================
4344 VM_buf_writefile
4345 writes stringbuffer to a file, returns 0 or 1
4346 float buf_writefile(float filehandle, float bufhandle, [, float startpos, float numstrings]) = #468;
4347 ========================
4348 */
4349
4350 void VM_buf_writefile(prvm_prog_t *prog)
4351 {
4352         int filenum, strindex, strnum, strlength;
4353         prvm_stringbuffer_t *stringbuffer;
4354
4355         VM_SAFEPARMCOUNTRANGE(2, 4, VM_buf_writefile);
4356
4357         // get file
4358         filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
4359         if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
4360         {
4361                 VM_Warning(prog, "VM_buf_writefile: invalid file handle %i used in %s\n", filenum, prog->name);
4362                 return;
4363         }
4364         if (prog->openfiles[filenum] == NULL)
4365         {
4366                 VM_Warning(prog, "VM_buf_writefile: no such file handle %i (or file has been closed) in %s\n", filenum, prog->name);
4367                 return;
4368         }
4369
4370         // get string buffer
4371         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM1));
4372         if(!stringbuffer)
4373         {
4374                 VM_Warning(prog, "VM_buf_writefile: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), prog->name);
4375                 PRVM_G_FLOAT(OFS_RETURN) = 0;
4376                 return;
4377         }
4378
4379         // get start and end parms
4380         if (prog->argc > 3)
4381         {
4382                 strindex = (int)PRVM_G_FLOAT(OFS_PARM2);
4383                 strnum = (int)PRVM_G_FLOAT(OFS_PARM3);
4384         }
4385         else if (prog->argc > 2)
4386         {
4387                 strindex = (int)PRVM_G_FLOAT(OFS_PARM2);
4388                 strnum = stringbuffer->num_strings - strindex;
4389         }
4390         else
4391         {
4392                 strindex = 0;
4393                 strnum = stringbuffer->num_strings;
4394         }
4395         if (strindex < 0 || strindex >= stringbuffer->num_strings)
4396         {
4397                 VM_Warning(prog, "VM_buf_writefile: wrong start string index %i used in %s\n", strindex, prog->name);
4398                 PRVM_G_FLOAT(OFS_RETURN) = 0;
4399                 return;
4400         }
4401         if (strnum < 0)
4402         {
4403                 VM_Warning(prog, "VM_buf_writefile: wrong strings count %i used in %s\n", strnum, prog->name);
4404                 PRVM_G_FLOAT(OFS_RETURN) = 0;
4405                 return;
4406         }
4407
4408         // write
4409         while(strindex < stringbuffer->num_strings && strnum)
4410         {
4411                 if (stringbuffer->strings[strindex])
4412                 {
4413                         if ((strlength = (int)strlen(stringbuffer->strings[strindex])))
4414                                 FS_Write(prog->openfiles[filenum], stringbuffer->strings[strindex], strlength);
4415                         FS_Write(prog->openfiles[filenum], "\n", 1);
4416                 }
4417                 strindex++;
4418                 strnum--;
4419         }
4420
4421         PRVM_G_FLOAT(OFS_RETURN) = 1;
4422 }
4423
4424 #define MATCH_AUTO     0
4425 #define MATCH_WHOLE    1
4426 #define MATCH_LEFT     2
4427 #define MATCH_RIGHT    3
4428 #define MATCH_MIDDLE   4
4429 #define MATCH_PATTERN  5
4430
4431 static const char *detect_match_rule(char *pattern, int *matchrule)
4432 {
4433         char *ppos, *qpos;
4434         int patternlength;
4435
4436         patternlength = (int)strlen(pattern);
4437         ppos = strchr(pattern, '*');
4438         qpos = strchr(pattern, '?');
4439         // has ? - pattern
4440         if (qpos)
4441         {
4442                 *matchrule = MATCH_PATTERN;
4443                 return pattern;
4444         }
4445         // has * - left, mid, right or pattern
4446         if (ppos)
4447         {
4448                 // starts with * - may be right/mid or pattern
4449                 if ((ppos - pattern) == 0)
4450                 {
4451                         ppos = strchr(pattern+1, '*');
4452                         // *something
4453                         if (!ppos)
4454                         {
4455                                 *matchrule = MATCH_RIGHT;
4456                                 return pattern+1;
4457                         }
4458                         // *something*
4459                         if ((ppos - pattern) == patternlength)
4460                         {
4461                                 *matchrule = MATCH_MIDDLE;
4462                                 *ppos = 0;
4463                                 return pattern+1;
4464                         }
4465                         // *som*thing
4466                         *matchrule = MATCH_PATTERN;
4467                         return pattern;
4468                 }
4469                 // end with * - left
4470                 if ((ppos - pattern) == patternlength)
4471                 {
4472                         *matchrule = MATCH_LEFT;
4473                         *ppos = 0;
4474                         return pattern;
4475                 }
4476                 // som*thing
4477                 *matchrule = MATCH_PATTERN;
4478                 return pattern;
4479         }
4480         // have no wildcards - whole string
4481         *matchrule = MATCH_WHOLE;
4482         return pattern;
4483 }
4484
4485 // todo: support UTF8
4486 static qbool match_rule(const char *string, int max_string, const char *pattern, int patternlength, int rule)
4487 {
4488         const char *mid;
4489
4490         if (rule == 1)
4491                 return !strncmp(string, pattern, max_string) ? true : false;
4492         if (rule == 2)
4493                 return !strncmp(string, pattern, patternlength) ? true : false;
4494         if (rule == 3)
4495         {
4496                 mid = strstr(string, pattern);
4497                 return mid && !*(mid+patternlength);
4498         }
4499         if (rule == 4)
4500                 return strstr(string, pattern) ? true : false;
4501         // pattern
4502         return matchpattern_with_separator(string, pattern, false, "", false) ? true : false;
4503 }
4504
4505 /*
4506 ========================
4507 VM_bufstr_find
4508 find an index of bufstring matching rule
4509 float bufstr_find(float bufhandle, string match, float matchrule, float startpos, float step) = #468;
4510 ========================
4511 */
4512
4513 void VM_bufstr_find(prvm_prog_t *prog)
4514 {
4515         prvm_stringbuffer_t *stringbuffer;
4516         char string[VM_STRINGTEMP_LENGTH];
4517         int matchrule, matchlen, i, step;
4518         const char *match;
4519
4520         VM_SAFEPARMCOUNTRANGE(3, 5, VM_bufstr_find);
4521
4522         PRVM_G_FLOAT(OFS_RETURN) = -1;
4523
4524         // get string buffer
4525         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4526         if(!stringbuffer)
4527         {
4528                 VM_Warning(prog, "VM_bufstr_find: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4529                 return;
4530         }
4531
4532         // get pattern/rule
4533         matchrule = (int)PRVM_G_FLOAT(OFS_PARM2);
4534         if (matchrule < 0 || matchrule > 5)
4535         {
4536                 VM_Warning(prog, "VM_bufstr_find: invalid match rule %i in %s\n", matchrule, prog->name);
4537                 return;
4538         }
4539         if (matchrule)
4540                 match = PRVM_G_STRING(OFS_PARM1);
4541         else
4542         {
4543                 strlcpy(string, PRVM_G_STRING(OFS_PARM1), sizeof(string));
4544                 match = detect_match_rule(string, &matchrule);
4545         }
4546         matchlen = (int)strlen(match);
4547
4548         // find
4549         i = (prog->argc > 3) ? (int)PRVM_G_FLOAT(OFS_PARM3) : 0;
4550         step = (prog->argc > 4) ? (int)PRVM_G_FLOAT(OFS_PARM4) : 1;
4551         while(i < stringbuffer->num_strings)
4552         {
4553                 if (stringbuffer->strings[i] && match_rule(stringbuffer->strings[i], VM_STRINGTEMP_LENGTH, match, matchlen, matchrule))
4554                 {
4555                         PRVM_G_FLOAT(OFS_RETURN) = i;
4556                         break;
4557                 }
4558                 i += step;
4559         }
4560 }
4561
4562 /*
4563 ========================
4564 VM_matchpattern
4565 float matchpattern(string s, string pattern, float matchrule, float startpos) = #468;
4566 ========================
4567 */
4568 void VM_matchpattern(prvm_prog_t *prog)
4569 {
4570         const char *s, *match;
4571         char string[VM_STRINGTEMP_LENGTH];
4572         int matchrule, l;
4573
4574         VM_SAFEPARMCOUNTRANGE(2, 4, VM_matchpattern);
4575
4576         s = PRVM_G_STRING(OFS_PARM0);
4577
4578         // get pattern/rule
4579         matchrule = (int)PRVM_G_FLOAT(OFS_PARM2);
4580         if (matchrule < 0 || matchrule > 5)
4581         {
4582                 VM_Warning(prog, "VM_matchpattern: invalid match rule %i in %s\n", matchrule, prog->name);
4583                 return;
4584         }
4585         if (matchrule)
4586                 match = PRVM_G_STRING(OFS_PARM1);
4587         else
4588         {
4589                 strlcpy(string, PRVM_G_STRING(OFS_PARM1), sizeof(string));
4590                 match = detect_match_rule(string, &matchrule);
4591         }
4592
4593         // offset
4594         l = (int)strlen(match);
4595         if (prog->argc > 3)
4596                 s += max(0, min((unsigned int)PRVM_G_FLOAT(OFS_PARM3), strlen(s)-1));
4597
4598         // match
4599         PRVM_G_FLOAT(OFS_RETURN) = match_rule(s, VM_STRINGTEMP_LENGTH, match, l, matchrule);
4600 }
4601
4602 /*
4603 ========================
4604 VM_buf_cvarlist
4605 ========================
4606 */
4607
4608 void VM_buf_cvarlist(prvm_prog_t *prog)
4609 {
4610         cvar_t *cvar;
4611         const char *partial, *antipartial;
4612         size_t len, antilen;
4613         size_t alloclen;
4614         qbool ispattern, antiispattern;
4615         int n;
4616         prvm_stringbuffer_t     *stringbuffer;
4617         VM_SAFEPARMCOUNTRANGE(2, 3, VM_buf_cvarlist);
4618
4619         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
4620         if(!stringbuffer)
4621         {
4622                 VM_Warning(prog, "VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
4623                 return;
4624         }
4625
4626         partial = PRVM_G_STRING(OFS_PARM1);
4627         if(!partial)
4628                 len = 0;
4629         else
4630                 len = strlen(partial);
4631
4632         if(prog->argc == 3)
4633                 antipartial = PRVM_G_STRING(OFS_PARM2);
4634         else
4635                 antipartial = NULL;
4636         if(!antipartial)
4637                 antilen = 0;
4638         else
4639                 antilen = strlen(antipartial);
4640
4641         for (n = 0;n < stringbuffer->num_strings;n++)
4642                 if (stringbuffer->strings[n])
4643                         Mem_Free(stringbuffer->strings[n]);
4644         if (stringbuffer->strings)
4645                 Mem_Free(stringbuffer->strings);
4646         stringbuffer->strings = NULL;
4647
4648         ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
4649         antiispattern = antipartial && (strchr(antipartial, '*') || strchr(antipartial, '?'));
4650
4651         n = 0;
4652         for(cvar = prog->console_cmd->cvars->vars; cvar; cvar = cvar->next)
4653         {
4654                 if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
4655                         continue;
4656
4657                 if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
4658                         continue;
4659
4660                 ++n;
4661         }
4662
4663         stringbuffer->max_strings = stringbuffer->num_strings = n;
4664         if (stringbuffer->max_strings)
4665                 stringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(stringbuffer->strings[0]) * stringbuffer->max_strings);
4666
4667         n = 0;
4668         for(cvar = prog->console_cmd->cvars->vars; cvar; cvar = cvar->next)
4669         {
4670                 if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
4671                         continue;
4672
4673                 if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
4674                         continue;
4675
4676                 alloclen = strlen(cvar->name) + 1;
4677                 stringbuffer->strings[n] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
4678                 memcpy(stringbuffer->strings[n], cvar->name, alloclen);
4679
4680                 ++n;
4681         }
4682 }
4683
4684
4685
4686
4687 //=============
4688
4689 /*
4690 ==============
4691 VM_changeyaw
4692
4693 This was a major timewaster in progs, so it was converted to C
4694 ==============
4695 */
4696 void VM_changeyaw (prvm_prog_t *prog)
4697 {
4698         prvm_edict_t            *ent;
4699         float           ideal, current, move, speed;
4700
4701         // this is called (VERY HACKISHLY) by VM_SV_MoveToGoal, so it can not use any
4702         // parameters because they are the parameters to VM_SV_MoveToGoal, not this
4703         //VM_SAFEPARMCOUNT(0, VM_changeyaw);
4704
4705         ent = PRVM_PROG_TO_EDICT(PRVM_gameglobaledict(self));
4706         if (ent == prog->edicts)
4707         {
4708                 VM_Warning(prog, "changeyaw: can not modify world entity\n");
4709                 return;
4710         }
4711         if (ent->free)
4712         {
4713                 VM_Warning(prog, "changeyaw: can not modify free entity\n");
4714                 return;
4715         }
4716         current = PRVM_gameedictvector(ent, angles)[1];
4717         current = ANGLEMOD(current);
4718         ideal = PRVM_gameedictfloat(ent, ideal_yaw);
4719         speed = PRVM_gameedictfloat(ent, yaw_speed);
4720
4721         if (current == ideal)
4722                 return;
4723         move = ideal - current;
4724         if (ideal > current)
4725         {
4726                 if (move >= 180)
4727                         move = move - 360;
4728         }
4729         else
4730         {
4731                 if (move <= -180)
4732                         move = move + 360;
4733         }
4734         if (move > 0)
4735         {
4736                 if (move > speed)
4737                         move = speed;
4738         }
4739         else
4740         {
4741                 if (move < -speed)
4742                         move = -speed;
4743         }
4744
4745         current += move;
4746         PRVM_gameedictvector(ent, angles)[1] = ANGLEMOD(current);
4747 }
4748
4749 /*
4750 ==============
4751 VM_changepitch
4752 ==============
4753 */
4754 void VM_changepitch (prvm_prog_t *prog)
4755 {
4756         prvm_edict_t            *ent;
4757         float           ideal, current, move, speed;
4758
4759         VM_SAFEPARMCOUNT(1, VM_changepitch);
4760
4761         ent = PRVM_G_EDICT(OFS_PARM0);
4762         if (ent == prog->edicts)
4763         {
4764                 VM_Warning(prog, "changepitch: can not modify world entity\n");
4765                 return;
4766         }
4767         if (ent->free)
4768         {
4769                 VM_Warning(prog, "changepitch: can not modify free entity\n");
4770                 return;
4771         }
4772         current = PRVM_gameedictvector(ent, angles)[0];
4773         current = ANGLEMOD(current);
4774         ideal = PRVM_gameedictfloat(ent, idealpitch);
4775         speed = PRVM_gameedictfloat(ent, pitch_speed);
4776
4777         if (current == ideal)
4778                 return;
4779         move = ideal - current;
4780         if (ideal > current)
4781         {
4782                 if (move >= 180)
4783                         move = move - 360;
4784         }
4785         else
4786         {
4787                 if (move <= -180)
4788                         move = move + 360;
4789         }
4790         if (move > 0)
4791         {
4792                 if (move > speed)
4793                         move = speed;
4794         }
4795         else
4796         {
4797                 if (move < -speed)
4798                         move = -speed;
4799         }
4800
4801         current += move;
4802         PRVM_gameedictvector(ent, angles)[0] = ANGLEMOD(current);
4803 }
4804
4805
4806 void VM_uncolorstring (prvm_prog_t *prog)
4807 {
4808         char szNewString[VM_STRINGTEMP_LENGTH];
4809         const char *szString;
4810
4811         // Prepare Strings
4812         VM_SAFEPARMCOUNT(1, VM_uncolorstring);
4813         szString = PRVM_G_STRING(OFS_PARM0);
4814         COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), true);
4815         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, szNewString);
4816
4817 }
4818
4819 // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
4820 //strstr, without generating a new string. Use in conjunction with FRIK_FILE's substring for more similar strstr.
4821 void VM_strstrofs (prvm_prog_t *prog)
4822 {
4823         const char *instr, *match;
4824         int firstofs;
4825         VM_SAFEPARMCOUNTRANGE(2, 3, VM_strstrofs);
4826         instr = PRVM_G_STRING(OFS_PARM0);
4827         match = PRVM_G_STRING(OFS_PARM1);
4828         firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
4829         firstofs = (int)u8_bytelen(instr, firstofs);
4830
4831         if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
4832         {
4833                 PRVM_G_FLOAT(OFS_RETURN) = -1;
4834                 return;
4835         }
4836
4837         match = strstr(instr+firstofs, match);
4838         if (!match)
4839                 PRVM_G_FLOAT(OFS_RETURN) = -1;
4840         else
4841                 PRVM_G_FLOAT(OFS_RETURN) = u8_strnlen(instr, match-instr);
4842 }
4843
4844 //#222 string(string s, float index) str2chr (FTE_STRINGS)
4845 void VM_str2chr (prvm_prog_t *prog)
4846 {
4847         const char *s;
4848         Uchar ch;
4849         int index;
4850         VM_SAFEPARMCOUNT(2, VM_str2chr);
4851         s = PRVM_G_STRING(OFS_PARM0);
4852         index = (int)u8_bytelen(s, (int)PRVM_G_FLOAT(OFS_PARM1));
4853
4854         if((unsigned)index < strlen(s))
4855         {
4856                 if (utf8_enable.integer)
4857                         ch = u8_getchar_noendptr(s + index);
4858                 else
4859                         ch = (unsigned char)s[index];
4860                 PRVM_G_FLOAT(OFS_RETURN) = ch;
4861         }
4862         else
4863                 PRVM_G_FLOAT(OFS_RETURN) = 0;
4864 }
4865
4866 //#223 string(float c, ...) chr2str (FTE_STRINGS)
4867 void VM_chr2str (prvm_prog_t *prog)
4868 {
4869         /*
4870         char    t[9];
4871         int             i;
4872         VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str);
4873         for(i = 0;i < prog->argc && i < (int)sizeof(t) - 1;i++)
4874                 t[i] = (unsigned char)PRVM_G_FLOAT(OFS_PARM0+i*3);
4875         t[i] = 0;
4876         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, t);
4877         */
4878         char t[9 * 4 + 1];
4879         int i;
4880         size_t len = 0;
4881         VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str);
4882         for(i = 0; i < prog->argc && len < sizeof(t)-1; ++i)
4883                 len += u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0+i*3), t + len, sizeof(t)-1);
4884         t[len] = 0;
4885         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, t);
4886 }
4887
4888 static int chrconv_number(int i, int base, int conv)
4889 {
4890         i -= base;
4891         switch (conv)
4892         {
4893         default:
4894         case 5:
4895         case 6:
4896         case 0:
4897                 break;
4898         case 1:
4899                 base = '0';
4900                 break;
4901         case 2:
4902                 base = '0'+128;
4903                 break;
4904         case 3:
4905                 base = '0'-30;
4906                 break;
4907         case 4:
4908                 base = '0'+128-30;
4909                 break;
4910         }
4911         return i + base;
4912 }
4913 static int chrconv_punct(int i, int base, int conv)
4914 {
4915         i -= base;
4916         switch (conv)
4917         {
4918         default:
4919         case 0:
4920                 break;
4921         case 1:
4922                 base = 0;
4923                 break;
4924         case 2:
4925                 base = 128;
4926                 break;
4927         }
4928         return i + base;
4929 }
4930
4931 static int chrchar_alpha(int i, int basec, int baset, int convc, int convt, int charnum)
4932 {
4933         //convert case and colour seperatly...
4934
4935         i -= baset + basec;
4936         switch (convt)
4937         {
4938         default:
4939         case 0:
4940                 break;
4941         case 1:
4942                 baset = 0;
4943                 break;
4944         case 2:
4945                 baset = 128;
4946                 break;
4947
4948         case 5:
4949         case 6:
4950                 baset = 128*((charnum&1) == (convt-5));
4951                 break;
4952         }
4953
4954         switch (convc)
4955         {
4956         default:
4957         case 0:
4958                 break;
4959         case 1:
4960                 basec = 'a';
4961                 break;
4962         case 2:
4963                 basec = 'A';
4964                 break;
4965         }
4966         return i + basec + baset;
4967 }
4968 // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
4969 //bulk convert a string. change case or colouring.
4970 void VM_strconv (prvm_prog_t *prog)
4971 {
4972         int ccase, redalpha, rednum, len, i;
4973         unsigned char resbuf[VM_STRINGTEMP_LENGTH];
4974         unsigned char *result = resbuf;
4975
4976         VM_SAFEPARMCOUNTRANGE(3, 8, VM_strconv);
4977
4978         ccase = (int) PRVM_G_FLOAT(OFS_PARM0);  //0 same, 1 lower, 2 upper
4979         redalpha = (int) PRVM_G_FLOAT(OFS_PARM1);       //0 same, 1 white, 2 red,  5 alternate, 6 alternate-alternate
4980         rednum = (int) PRVM_G_FLOAT(OFS_PARM2); //0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
4981         VM_VarString(prog, 3, (char *) resbuf, sizeof(resbuf));
4982         len = (int)strlen((char *) resbuf);
4983
4984         for (i = 0; i < len; i++, result++)     //should this be done backwards?
4985         {
4986                 if (*result >= '0' && *result <= '9')   //normal numbers...
4987                         *result = chrconv_number(*result, '0', rednum);
4988                 else if (*result >= '0'+128 && *result <= '9'+128)
4989                         *result = chrconv_number(*result, '0'+128, rednum);
4990                 else if (*result >= '0'+128-30 && *result <= '9'+128-30)
4991                         *result = chrconv_number(*result, '0'+128-30, rednum);
4992                 else if (*result >= '0'-30 && *result <= '9'-30)
4993                         *result = chrconv_number(*result, '0'-30, rednum);
4994
4995                 else if (*result >= 'a' && *result <= 'z')      //normal numbers...
4996                         *result = chrchar_alpha(*result, 'a', 0, ccase, redalpha, i);
4997                 else if (*result >= 'A' && *result <= 'Z')      //normal numbers...
4998                         *result = chrchar_alpha(*result, 'A', 0, ccase, redalpha, i);
4999                 else if (*result >= 'a'+128 && *result <= 'z'+128)      //normal numbers...
5000                         *result = chrchar_alpha(*result, 'a', 128, ccase, redalpha, i);
5001                 else if (*result >= 'A'+128 && *result <= 'Z'+128)      //normal numbers...
5002                         *result = chrchar_alpha(*result, 'A', 128, ccase, redalpha, i);
5003
5004                 else if ((*result & 127) < 16 || !redalpha)     //special chars..
5005                         *result = *result;
5006                 else if (*result < 128)
5007                         *result = chrconv_punct(*result, 0, redalpha);
5008                 else
5009                         *result = chrconv_punct(*result, 128, redalpha);
5010         }
5011         *result = '\0';
5012
5013         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, (char *) resbuf);
5014 }
5015
5016 // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
5017 void VM_strpad (prvm_prog_t *prog)
5018 {
5019         char src[VM_STRINGTEMP_LENGTH];
5020         char destbuf[VM_STRINGTEMP_LENGTH];
5021         int pad;
5022         VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
5023         pad = (int) PRVM_G_FLOAT(OFS_PARM0);
5024         VM_VarString(prog, 1, src, sizeof(src));
5025
5026         // note: < 0 = left padding, > 0 = right padding,
5027         // this is reverse logic of printf!
5028         dpsnprintf(destbuf, sizeof(destbuf), "%*s", -pad, src);
5029
5030         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, destbuf);
5031 }
5032
5033 // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
5034 //uses qw style \key\value strings
5035 void VM_infoadd (prvm_prog_t *prog)
5036 {
5037         const char *info, *key;
5038         char value[VM_STRINGTEMP_LENGTH];
5039         char temp[VM_STRINGTEMP_LENGTH];
5040
5041         VM_SAFEPARMCOUNTRANGE(2, 8, VM_infoadd);
5042         info = PRVM_G_STRING(OFS_PARM0);
5043         key = PRVM_G_STRING(OFS_PARM1);
5044         VM_VarString(prog, 2, value, sizeof(value));
5045
5046         strlcpy(temp, info, VM_STRINGTEMP_LENGTH);
5047
5048         InfoString_SetValue(temp, VM_STRINGTEMP_LENGTH, key, value);
5049
5050         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, temp);
5051 }
5052
5053 // #227 string(string info, string key) infoget (FTE_STRINGS)
5054 //uses qw style \key\value strings
5055 void VM_infoget (prvm_prog_t *prog)
5056 {
5057         const char *info;
5058         const char *key;
5059         char value[VM_STRINGTEMP_LENGTH];
5060
5061         VM_SAFEPARMCOUNT(2, VM_infoget);
5062         info = PRVM_G_STRING(OFS_PARM0);
5063         key = PRVM_G_STRING(OFS_PARM1);
5064
5065         InfoString_GetValue(info, key, value, VM_STRINGTEMP_LENGTH);
5066
5067         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, value);
5068 }
5069
5070 //#228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
5071 // also float(string s1, string s2) strcmp (FRIK_FILE)
5072 void VM_strncmp (prvm_prog_t *prog)
5073 {
5074         const char *s1, *s2;
5075         VM_SAFEPARMCOUNTRANGE(2, 3, VM_strncmp);
5076         s1 = PRVM_G_STRING(OFS_PARM0);
5077         s2 = PRVM_G_STRING(OFS_PARM1);
5078         if (prog->argc > 2)
5079         {
5080                 PRVM_G_FLOAT(OFS_RETURN) = strncmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2));
5081         }
5082         else
5083         {
5084                 PRVM_G_FLOAT(OFS_RETURN) = strcmp(s1, s2);
5085         }
5086 }
5087
5088 // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
5089 // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
5090 void VM_strncasecmp (prvm_prog_t *prog)
5091 {
5092         const char *s1, *s2;
5093         VM_SAFEPARMCOUNTRANGE(2, 3, VM_strncasecmp);
5094         s1 = PRVM_G_STRING(OFS_PARM0);
5095         s2 = PRVM_G_STRING(OFS_PARM1);
5096         if (prog->argc > 2)
5097         {
5098                 PRVM_G_FLOAT(OFS_RETURN) = strncasecmp(s1, s2, (size_t)PRVM_G_FLOAT(OFS_PARM2));
5099         }
5100         else
5101         {
5102                 PRVM_G_FLOAT(OFS_RETURN) = strcasecmp(s1, s2);
5103         }
5104 }
5105
5106 // #494 float(float caseinsensitive, string s, ...) crc16
5107 void VM_crc16(prvm_prog_t *prog)
5108 {
5109         float insensitive;
5110         char s[VM_STRINGTEMP_LENGTH];
5111         VM_SAFEPARMCOUNTRANGE(2, 8, VM_crc16);
5112         insensitive = PRVM_G_FLOAT(OFS_PARM0);
5113         VM_VarString(prog, 1, s, sizeof(s));
5114         PRVM_G_FLOAT(OFS_RETURN) = (unsigned short) ((insensitive ? CRC_Block_CaseInsensitive : CRC_Block) ((unsigned char *) s, strlen(s)));
5115 }
5116
5117 // #639 float(string digest, string data, ...) digest_hex
5118 void VM_digest_hex(prvm_prog_t *prog)
5119 {
5120         const char *digest;
5121
5122         char out[32];
5123         char outhex[65];
5124         int outlen;
5125
5126         char s[VM_STRINGTEMP_LENGTH];
5127         int len;
5128
5129         VM_SAFEPARMCOUNTRANGE(2, 8, VM_digest_hex);
5130         digest = PRVM_G_STRING(OFS_PARM0);
5131         if(!digest)
5132                 digest = "";
5133         VM_VarString(prog, 1, s, sizeof(s));
5134         len = (int)strlen(s);
5135
5136         outlen = 0;
5137
5138         if(!strcmp(digest, "MD4"))
5139         {
5140                 outlen = 16;
5141                 mdfour((unsigned char *) out, (unsigned char *) s, len);
5142         }
5143         else if(!strcmp(digest, "SHA256") && Crypto_Available())
5144         {
5145                 outlen = 32;
5146                 sha256((unsigned char *) out, (unsigned char *) s, len);
5147         }
5148         // no warning needed on mismatch - we return string_null to QC
5149
5150         if(outlen)
5151         {
5152                 int i;
5153                 static const char *hexmap = "0123456789abcdef";
5154                 for(i = 0; i < outlen; ++i)
5155                 {
5156                         outhex[2*i]   = hexmap[(out[i] >> 4) & 15];
5157                         outhex[2*i+1] = hexmap[(out[i] >> 0) & 15];
5158                 }
5159                 outhex[2*i] = 0;
5160                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, outhex);
5161         }
5162         else
5163                 PRVM_G_INT(OFS_RETURN) = 0;
5164 }
5165
5166 void VM_wasfreed (prvm_prog_t *prog)
5167 {
5168         VM_SAFEPARMCOUNT(1, VM_wasfreed);
5169         PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_EDICT(OFS_PARM0)->free;
5170 }
5171
5172 void VM_SetTraceGlobals(prvm_prog_t *prog, const trace_t *trace)
5173 {
5174         PRVM_gameglobalfloat(trace_allsolid) = trace->allsolid;
5175         PRVM_gameglobalfloat(trace_startsolid) = trace->startsolid;
5176         PRVM_gameglobalfloat(trace_fraction) = trace->fraction;
5177         PRVM_gameglobalfloat(trace_inwater) = trace->inwater;
5178         PRVM_gameglobalfloat(trace_inopen) = trace->inopen;
5179         VectorCopy(trace->endpos, PRVM_gameglobalvector(trace_endpos));
5180         VectorCopy(trace->plane.normal, PRVM_gameglobalvector(trace_plane_normal));
5181         PRVM_gameglobalfloat(trace_plane_dist) = trace->plane.dist;
5182         PRVM_gameglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(trace->ent ? trace->ent : prog->edicts);
5183         PRVM_gameglobalfloat(trace_dpstartcontents) = trace->startsupercontents;
5184         PRVM_gameglobalfloat(trace_dphitcontents) = trace->hitsupercontents;
5185         PRVM_gameglobalfloat(trace_dphitq3surfaceflags) = trace->hitq3surfaceflags;
5186         PRVM_gameglobalstring(trace_dphittexturename) = trace->hittexture ? PRVM_SetTempString(prog, trace->hittexture->name) : 0;
5187 }
5188
5189 void VM_ClearTraceGlobals(prvm_prog_t *prog)
5190 {
5191         // clean up all trace globals when leaving the VM (anti-triggerbot safeguard)
5192         PRVM_gameglobalfloat(trace_allsolid) = 0;
5193         PRVM_gameglobalfloat(trace_startsolid) = 0;
5194         PRVM_gameglobalfloat(trace_fraction) = 0;
5195         PRVM_gameglobalfloat(trace_inwater) = 0;
5196         PRVM_gameglobalfloat(trace_inopen) = 0;
5197         VectorClear(PRVM_gameglobalvector(trace_endpos));
5198         VectorClear(PRVM_gameglobalvector(trace_plane_normal));
5199         PRVM_gameglobalfloat(trace_plane_dist) = 0;
5200         PRVM_gameglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(prog->edicts);
5201         PRVM_gameglobalfloat(trace_dpstartcontents) = 0;
5202         PRVM_gameglobalfloat(trace_dphitcontents) = 0;
5203         PRVM_gameglobalfloat(trace_dphitq3surfaceflags) = 0;
5204         PRVM_gameglobalstring(trace_dphittexturename) = 0;
5205 }
5206
5207 //=============
5208
5209 void VM_Cmd_Init(prvm_prog_t *prog)
5210 {
5211         // only init the stuff for the current prog
5212         VM_Files_Init(prog);
5213         VM_Search_Init(prog);
5214 }
5215
5216 static void animatemodel_reset(prvm_prog_t *prog);
5217
5218 void VM_Cmd_Reset(prvm_prog_t *prog)
5219 {
5220         CL_PurgeOwner( MENUOWNER );
5221         VM_Search_Reset(prog);
5222         VM_Files_CloseAll(prog);
5223         animatemodel_reset(prog);
5224 }
5225
5226 // #510 string(string input, ...) uri_escape (DP_QC_URI_ESCAPE)
5227 // does URI escaping on a string (replace evil stuff by %AB escapes)
5228 void VM_uri_escape (prvm_prog_t *prog)
5229 {
5230         char src[VM_STRINGTEMP_LENGTH];
5231         char dest[VM_STRINGTEMP_LENGTH];
5232         char *p, *q;
5233         static const char *hex = "0123456789ABCDEF";
5234
5235         VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_escape);
5236         VM_VarString(prog, 0, src, sizeof(src));
5237
5238         for(p = src, q = dest; *p && q < dest + sizeof(dest) - 3; ++p)
5239         {
5240                 if((*p >= 'A' && *p <= 'Z')
5241                         || (*p >= 'a' && *p <= 'z')
5242                         || (*p >= '0' && *p <= '9')
5243                         || (*p == '-')  || (*p == '_') || (*p == '.')
5244                         || (*p == '!')  || (*p == '~')
5245                         || (*p == '\'') || (*p == '(') || (*p == ')'))
5246                         *q++ = *p;
5247                 else
5248                 {
5249                         *q++ = '%';
5250                         *q++ = hex[(*(unsigned char *)p >> 4) & 0xF];
5251                         *q++ = hex[ *(unsigned char *)p       & 0xF];
5252                 }
5253         }
5254         *q++ = 0;
5255
5256         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, dest);
5257 }
5258
5259 // #510 string(string input, ...) uri_unescape (DP_QC_URI_ESCAPE)
5260 // does URI unescaping on a string (get back the evil stuff)
5261 void VM_uri_unescape (prvm_prog_t *prog)
5262 {
5263         char src[VM_STRINGTEMP_LENGTH];
5264         char dest[VM_STRINGTEMP_LENGTH];
5265         char *p, *q;
5266         int hi, lo;
5267
5268         VM_SAFEPARMCOUNTRANGE(1, 8, VM_uri_unescape);
5269         VM_VarString(prog, 0, src, sizeof(src));
5270
5271         for(p = src, q = dest; *p; ) // no need to check size, because unescape can't expand
5272         {
5273                 if(*p == '%')
5274                 {
5275                         if(p[1] >= '0' && p[1] <= '9')
5276                                 hi = p[1] - '0';
5277                         else if(p[1] >= 'a' && p[1] <= 'f')
5278                                 hi = p[1] - 'a' + 10;
5279                         else if(p[1] >= 'A' && p[1] <= 'F')
5280                                 hi = p[1] - 'A' + 10;
5281                         else
5282                                 goto nohex;
5283                         if(p[2] >= '0' && p[2] <= '9')
5284                                 lo = p[2] - '0';
5285                         else if(p[2] >= 'a' && p[2] <= 'f')
5286                                 lo = p[2] - 'a' + 10;
5287                         else if(p[2] >= 'A' && p[2] <= 'F')
5288                                 lo = p[2] - 'A' + 10;
5289                         else
5290                                 goto nohex;
5291                         if(hi != 0 || lo != 0) // don't unescape NUL bytes
5292                                 *q++ = (char) (hi * 0x10 + lo);
5293                         p += 3;
5294                         continue;
5295                 }
5296
5297 nohex:
5298                 // otherwise:
5299                 *q++ = *p++;
5300         }
5301         *q++ = 0;
5302
5303         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, dest);
5304 }
5305
5306 // #502 string(string filename) whichpack (DP_QC_WHICHPACK)
5307 // returns the name of the pack containing a file, or "" if it is not in any pack (but local or non-existant)
5308 void VM_whichpack (prvm_prog_t *prog)
5309 {
5310         const char *fn, *pack;
5311
5312         VM_SAFEPARMCOUNT(1, VM_whichpack);
5313         fn = PRVM_G_STRING(OFS_PARM0);
5314         pack = FS_WhichPack(fn);
5315
5316         PRVM_G_INT(OFS_RETURN) = pack ? PRVM_SetTempString(prog, pack) : 0;
5317 }
5318
5319 typedef struct
5320 {
5321         prvm_prog_t *prog;
5322         double starttime;
5323         float id;
5324         char buffer[MAX_INPUTLINE];
5325         char posttype[128];
5326         unsigned char *postdata; // free when uri_to_prog_t is freed
5327         size_t postlen;
5328         char *sigdata; // free when uri_to_prog_t is freed
5329         size_t siglen;
5330 }
5331 uri_to_prog_t;
5332
5333 static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata)
5334 {
5335         prvm_prog_t *prog;
5336         uri_to_prog_t *handle = (uri_to_prog_t *) cbdata;
5337
5338         prog = handle->prog;
5339         if(!prog->loaded)
5340         {
5341                 // curl reply came too late... so just drop it
5342                 if(handle->postdata)
5343                         Z_Free(handle->postdata);
5344                 if(handle->sigdata)
5345                         Z_Free(handle->sigdata);
5346                 Z_Free(handle);
5347                 return;
5348         }
5349
5350         if((prog->starttime == handle->starttime) && (PRVM_allfunction(URI_Get_Callback)))
5351         {
5352                 if(length_received >= sizeof(handle->buffer))
5353                         length_received = sizeof(handle->buffer) - 1;
5354                 handle->buffer[length_received] = 0;
5355
5356                 PRVM_G_FLOAT(OFS_PARM0) = handle->id;
5357                 PRVM_G_FLOAT(OFS_PARM1) = status;
5358                 PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(prog, handle->buffer);
5359                 prog->ExecuteProgram(prog, PRVM_allfunction(URI_Get_Callback), "QC function URI_Get_Callback is missing");
5360         }
5361
5362         if(handle->postdata)
5363                 Z_Free(handle->postdata);
5364         if(handle->sigdata)
5365                 Z_Free(handle->sigdata);
5366         Z_Free(handle);
5367 }
5368
5369 // uri_get() gets content from an URL and calls a callback "uri_get_callback" with it set as string; an unique ID of the transfer is returned
5370 // returns 1 on success, and then calls the callback with the ID, 0 or the HTTP status code, and the received data in a string
5371 void VM_uri_get (prvm_prog_t *prog)
5372 {
5373         const char *url;
5374         float id;
5375         qbool ret;
5376         uri_to_prog_t *handle;
5377         const char *posttype = NULL;
5378         const char *postseparator = NULL;
5379         int poststringbuffer = -1;
5380         int postkeyid = -1;
5381         const char *query_string = NULL;
5382         size_t lq;
5383
5384         if(!PRVM_allfunction(URI_Get_Callback))
5385                 prog->error_cmd("uri_get called by %s without URI_Get_Callback defined", prog->name);
5386
5387         VM_SAFEPARMCOUNTRANGE(2, 6, VM_uri_get);
5388
5389         url = PRVM_G_STRING(OFS_PARM0);
5390         id = PRVM_G_FLOAT(OFS_PARM1);
5391         if(prog->argc >= 3)
5392                 posttype = PRVM_G_STRING(OFS_PARM2);
5393         if(prog->argc >= 4)
5394                 postseparator = PRVM_G_STRING(OFS_PARM3);
5395         if(prog->argc >= 5)
5396                 poststringbuffer = PRVM_G_FLOAT(OFS_PARM4);
5397         if(prog->argc >= 6)
5398                 postkeyid = PRVM_G_FLOAT(OFS_PARM5);
5399         handle = (uri_to_prog_t *) Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later!
5400
5401         query_string = strchr(url, '?');
5402         if(query_string)
5403                 ++query_string;
5404         lq = query_string ? strlen(query_string) : 0;
5405
5406         handle->prog = prog;
5407         handle->starttime = prog->starttime;
5408         handle->id = id;
5409         if(postseparator && posttype && *posttype)
5410         {
5411                 size_t l = strlen(postseparator);
5412                 if(poststringbuffer >= 0)
5413                 {
5414                         size_t ltotal;
5415                         int i;
5416                         // "implode"
5417                         prvm_stringbuffer_t *stringbuffer;
5418                         stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, poststringbuffer);
5419                         if(!stringbuffer)
5420                         {
5421                                 VM_Warning(prog, "uri_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), prog->name);
5422                                 return;
5423                         }
5424                         ltotal = 0;
5425                         for(i = 0;i < stringbuffer->num_strings;i++)
5426                         {
5427                                 if(i > 0)
5428                                         ltotal += l;
5429                                 if(stringbuffer->strings[i])
5430                                         ltotal += strlen(stringbuffer->strings[i]);
5431                         }
5432                         handle->postdata = (unsigned char *)Z_Malloc(ltotal + 1 + lq);
5433                         handle->postlen = ltotal;
5434                         ltotal = 0;
5435                         for(i = 0;i < stringbuffer->num_strings;i++)
5436                         {
5437                                 if(i > 0)
5438                                 {
5439                                         memcpy(handle->postdata + ltotal, postseparator, l);
5440                                         ltotal += l;
5441                                 }
5442                                 if(stringbuffer->strings[i])
5443                                 {
5444                                         memcpy(handle->postdata + ltotal, stringbuffer->strings[i], strlen(stringbuffer->strings[i]));
5445                                         ltotal += strlen(stringbuffer->strings[i]);
5446                                 }
5447                         }
5448                         if(ltotal != handle->postlen)
5449                                 prog->error_cmd("%s: string buffer content size mismatch, possible overrun", prog->name);
5450                 }
5451                 else
5452                 {
5453                         handle->postdata = (unsigned char *)Z_Malloc(l + 1 + lq);
5454                         handle->postlen = l;
5455                         memcpy(handle->postdata, postseparator, l);
5456                 }
5457                 handle->postdata[handle->postlen] = 0;
5458                 if(query_string)
5459                         memcpy(handle->postdata + handle->postlen + 1, query_string, lq);
5460                 if(postkeyid >= 0)
5461                 {
5462                         // POST: we sign postdata \0 query string
5463                         size_t ll;
5464                         handle->sigdata = (char *)Z_Malloc(8192);
5465                         strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
5466                         l = strlen(handle->sigdata);
5467                         handle->siglen = Crypto_SignDataDetached(handle->postdata, handle->postlen + 1 + lq, postkeyid, handle->sigdata + l, 8192 - l);
5468                         if(!handle->siglen)
5469                         {
5470                                 Z_Free(handle->sigdata);
5471                                 handle->sigdata = NULL;
5472                                 goto out1;
5473                         }
5474                         ll = base64_encode((unsigned char *) (handle->sigdata + l), handle->siglen, 8192 - l - 1);
5475                         if(!ll)
5476                         {
5477                                 Z_Free(handle->sigdata);
5478                                 handle->sigdata = NULL;
5479                                 goto out1;
5480                         }
5481                         handle->siglen = l + ll;
5482                         handle->sigdata[handle->siglen] = 0;
5483                 }
5484 out1:
5485                 strlcpy(handle->posttype, posttype, sizeof(handle->posttype));
5486                 ret = Curl_Begin_ToMemory_POST(url, handle->sigdata, 0, handle->posttype, handle->postdata, handle->postlen, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
5487         }
5488         else
5489         {
5490                 if(postkeyid >= 0 && query_string)
5491                 {
5492                         // GET: we sign JUST the query string
5493                         size_t l, ll;
5494                         handle->sigdata = (char *)Z_Malloc(8192);
5495                         strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
5496                         l = strlen(handle->sigdata);
5497                         handle->siglen = Crypto_SignDataDetached(query_string, lq, postkeyid, handle->sigdata + l, 8192 - l);
5498                         if(!handle->siglen)
5499                         {
5500                                 Z_Free(handle->sigdata);
5501                                 handle->sigdata = NULL;
5502                                 goto out2;
5503                         }
5504                         ll = base64_encode((unsigned char *) (handle->sigdata + l), handle->siglen, 8192 - l - 1);
5505                         if(!ll)
5506                         {
5507                                 Z_Free(handle->sigdata);
5508                                 handle->sigdata = NULL;
5509                                 goto out2;
5510                         }
5511                         handle->siglen = l + ll;
5512                         handle->sigdata[handle->siglen] = 0;
5513                 }
5514 out2:
5515                 handle->postdata = NULL;
5516                 handle->postlen = 0;
5517                 ret = Curl_Begin_ToMemory_POST(url, handle->sigdata, 0, NULL, NULL, 0, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
5518         }
5519         if(ret)
5520         {
5521                 PRVM_G_INT(OFS_RETURN) = 1;
5522         }
5523         else
5524         {
5525                 if(handle->postdata)
5526                         Z_Free(handle->postdata);
5527                 if(handle->sigdata)
5528                         Z_Free(handle->sigdata);
5529                 Z_Free(handle);
5530                 PRVM_G_INT(OFS_RETURN) = 0;
5531         }
5532 }
5533
5534 void VM_netaddress_resolve (prvm_prog_t *prog)
5535 {
5536         const char *ip;
5537         char normalized[128];
5538         int port;
5539         lhnetaddress_t addr;
5540
5541         VM_SAFEPARMCOUNTRANGE(1, 2, VM_netaddress_resolve);
5542
5543         ip = PRVM_G_STRING(OFS_PARM0);
5544         port = 0;
5545         if(prog->argc > 1)
5546                 port = (int) PRVM_G_FLOAT(OFS_PARM1);
5547
5548         if(LHNETADDRESS_FromString(&addr, ip, port) && LHNETADDRESS_ToString(&addr, normalized, sizeof(normalized), prog->argc > 1))
5549                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, normalized);
5550         else
5551                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "");
5552 }
5553
5554 //string(prvm_prog_t *prog) getextresponse = #624; // returns the next extResponse packet that was sent to this client
5555 void VM_CL_getextresponse (prvm_prog_t *prog)
5556 {
5557         VM_SAFEPARMCOUNT(0,VM_argv);
5558
5559         if (cl_net_extresponse_count <= 0)
5560                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
5561         else
5562         {
5563                 int first;
5564                 --cl_net_extresponse_count;
5565                 first = (cl_net_extresponse_last + NET_EXTRESPONSE_MAX - cl_net_extresponse_count) % NET_EXTRESPONSE_MAX;
5566                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cl_net_extresponse[first]);
5567         }
5568 }
5569
5570 void VM_SV_getextresponse (prvm_prog_t *prog)
5571 {
5572         VM_SAFEPARMCOUNT(0,VM_argv);
5573
5574         if (sv_net_extresponse_count <= 0)
5575                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
5576         else
5577         {
5578                 int first;
5579                 --sv_net_extresponse_count;
5580                 first = (sv_net_extresponse_last + NET_EXTRESPONSE_MAX - sv_net_extresponse_count) % NET_EXTRESPONSE_MAX;
5581                 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, sv_net_extresponse[first]);
5582         }
5583 }
5584
5585 // DP_QC_NUDGEOUTOFSOLID
5586 // float(entity ent) nudgeoutofsolid = #567;
5587 void VM_nudgeoutofsolid(prvm_prog_t *prog)
5588 {
5589         prvm_edict_t *ent;
5590
5591         VM_SAFEPARMCOUNTRANGE(1, 1, VM_nudgeoutofsolid);
5592
5593         ent = PRVM_G_EDICT(OFS_PARM0);
5594         if (ent == prog->edicts)
5595         {
5596                 VM_Warning(prog, "nudgeoutofsolid: can not modify world entity\n");
5597                 PRVM_G_FLOAT(OFS_RETURN) = 0;
5598                 return;
5599         }
5600         if (ent->free)
5601         {
5602                 VM_Warning(prog, "nudgeoutofsolid: can not modify free entity\n");
5603                 PRVM_G_FLOAT(OFS_RETURN) = 0;
5604                 return;
5605         }
5606
5607         PRVM_G_FLOAT(OFS_RETURN) = PHYS_NudgeOutOfSolid(prog, ent);
5608
5609         if (PRVM_G_FLOAT(OFS_RETURN) > 0)
5610         {
5611                 if (prog == SVVM_prog)
5612                         SV_LinkEdict(ent);
5613                 else if (prog == CLVM_prog)
5614                         CL_LinkEdict(ent);
5615                 else
5616                         Sys_Error("PHYS_NudgeOutOfSolid: cannot be called from %s VM\n", prog->name);
5617         }
5618 }
5619
5620 /*
5621 =========
5622 Common functions between menu.dat and clsprogs
5623 =========
5624 */
5625
5626 //#349 float() isdemo
5627 void VM_CL_isdemo (prvm_prog_t *prog)
5628 {
5629         VM_SAFEPARMCOUNT(0, VM_CL_isdemo);
5630         PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
5631 }
5632
5633 //#355 float() videoplaying
5634 void VM_CL_videoplaying (prvm_prog_t *prog)
5635 {
5636         VM_SAFEPARMCOUNT(0, VM_CL_videoplaying);
5637         PRVM_G_FLOAT(OFS_RETURN) = cl_videoplaying;
5638 }
5639
5640 /*
5641 =========
5642 VM_M_callfunction
5643
5644         callfunction(...,string function_name)
5645 Extension: pass
5646 =========
5647 */
5648 void VM_callfunction(prvm_prog_t *prog)
5649 {
5650         mfunction_t *func;
5651         const char *s;
5652
5653         VM_SAFEPARMCOUNTRANGE(1, 8, VM_callfunction);
5654
5655         s = PRVM_G_STRING(OFS_PARM0+(prog->argc - 1)*3);
5656
5657         VM_CheckEmptyString(prog, s);
5658
5659         func = PRVM_ED_FindFunction(prog, s);
5660
5661         if(!func)
5662                 prog->error_cmd("VM_callfunction: function %s not found !", s);
5663         else if (func->first_statement < 0)
5664         {
5665                 // negative statements are built in functions
5666                 int builtinnumber = -func->first_statement;
5667                 prog->xfunction->builtinsprofile++;
5668                 if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
5669                         prog->builtins[builtinnumber](prog);
5670                 else
5671                         prog->error_cmd("No such builtin #%i in %s; most likely cause: outdated engine build. Try updating!", builtinnumber, prog->name);
5672         }
5673         else if(func - prog->functions > 0)
5674         {
5675                 prog->argc--;
5676                 prog->ExecuteProgram(prog, func - prog->functions,"");
5677                 prog->argc++;
5678         }
5679 }
5680
5681 /*
5682 =========
5683 VM_isfunction
5684
5685 float   isfunction(string function_name)
5686 =========
5687 */
5688 void VM_isfunction(prvm_prog_t *prog)
5689 {
5690         mfunction_t *func;
5691         const char *s;
5692
5693         VM_SAFEPARMCOUNT(1, VM_isfunction);
5694
5695         s = PRVM_G_STRING(OFS_PARM0);
5696
5697         VM_CheckEmptyString(prog, s);
5698
5699         func = PRVM_ED_FindFunction(prog, s);
5700
5701         if(!func)
5702                 PRVM_G_FLOAT(OFS_RETURN) = false;
5703         else
5704                 PRVM_G_FLOAT(OFS_RETURN) = true;
5705 }
5706
5707 /*
5708 =========
5709 VM_sprintf
5710
5711 string sprintf(string format, ...)
5712 =========
5713 */
5714
5715 void VM_sprintf(prvm_prog_t *prog)
5716 {
5717         const char *s, *s0;
5718         char outbuf[MAX_INPUTLINE];
5719         char *o = outbuf, *end = outbuf + sizeof(outbuf), *err;
5720         const char *p;
5721         int argpos = 1;
5722         int width, precision, thisarg, flags;
5723         char formatbuf[16];
5724         char *f;
5725         int isfloat;
5726         static prvm_int_t dummyivec[3] = {0, 0, 0};
5727         static prvm_vec_t dummyvec[3] = {0, 0, 0};
5728         char vabuf[1024];
5729
5730 #define PRINTF_ALTERNATE 1
5731 #define PRINTF_ZEROPAD 2
5732 #define PRINTF_LEFT 4
5733 #define PRINTF_SPACEPOSITIVE 8
5734 #define PRINTF_SIGNPOSITIVE 16
5735
5736         formatbuf[0] = '%';
5737
5738         s = PRVM_G_STRING(OFS_PARM0);
5739
5740 #define GETARG_FLOAT(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_FLOAT(OFS_PARM0 + 3 * (a))) : 0)
5741 #define GETARG_VECTOR(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_VECTOR(OFS_PARM0 + 3 * (a))) : dummyvec)
5742 #define GETARG_INT(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_INT(OFS_PARM0 + 3 * (a))) : 0)
5743 #define GETARG_INTVECTOR(a) (((a)>=1 && (a)<prog->argc) ? ((prvm_int_t*) PRVM_G_VECTOR(OFS_PARM0 + 3 * (a))) : dummyivec)
5744 #define GETARG_STRING(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_STRING(OFS_PARM0 + 3 * (a))) : "")
5745
5746         for(;;)
5747         {
5748                 s0 = s;
5749                 switch(*s)
5750                 {
5751                         case 0:
5752                                 goto finished;
5753                         case '%':
5754                                 ++s;
5755
5756                                 if(*s == '%')
5757                                         goto verbatim;
5758
5759                                 // complete directive format:
5760                                 // %3$*1$.*2$ld
5761
5762                                 width = -1;
5763                                 precision = -1;
5764                                 thisarg = -1;
5765                                 flags = 0;
5766                                 isfloat = -1;
5767
5768                                 // is number following?
5769                                 if(*s >= '0' && *s <= '9')
5770                                 {
5771                                         width = strtol(s, &err, 10);
5772                                         if(!err)
5773                                         {
5774                                                 VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
5775                                                 goto finished;
5776                                         }
5777                                         if(*err == '$')
5778                                         {
5779                                                 thisarg = width;
5780                                                 width = -1;
5781                                                 s = err + 1;
5782                                         }
5783                                         else
5784                                         {
5785                                                 if(*s == '0')
5786                                                 {
5787                                                         flags |= PRINTF_ZEROPAD;
5788                                                         if(width == 0)
5789                                                                 width = -1; // it was just a flag
5790                                                 }
5791                                                 s = err;
5792                                         }
5793                                 }
5794
5795                                 if(width < 0)
5796                                 {
5797                                         for(;;)
5798                                         {
5799                                                 switch(*s)
5800                                                 {
5801                                                         case '#': flags |= PRINTF_ALTERNATE; break;
5802                                                         case '0': flags |= PRINTF_ZEROPAD; break;
5803                                                         case '-': flags |= PRINTF_LEFT; break;
5804                                                         case ' ': flags |= PRINTF_SPACEPOSITIVE; break;
5805                                                         case '+': flags |= PRINTF_SIGNPOSITIVE; break;
5806                                                         default:
5807                                                                 goto noflags;
5808                                                 }
5809                                                 ++s;
5810                                         }
5811 noflags:
5812                                         if(*s == '*')
5813                                         {
5814                                                 ++s;
5815                                                 if(*s >= '0' && *s <= '9')
5816                                                 {
5817                                                         width = strtol(s, &err, 10);
5818                                                         if(!err || *err != '$')
5819                                                         {
5820                                                                 VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
5821                                                                 goto finished;
5822                                                         }
5823                                                         s = err + 1;
5824                                                 }
5825                                                 else
5826                                                         width = argpos++;
5827                                                 width = GETARG_FLOAT(width);
5828                                                 if(width < 0)
5829                                                 {
5830                                                         flags |= PRINTF_LEFT;
5831                                                         width = -width;
5832                                                 }
5833                                         }
5834                                         else if(*s >= '0' && *s <= '9')
5835                                         {
5836                                                 width = strtol(s, &err, 10);
5837                                                 if(!err)
5838                                                 {
5839                                                         VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
5840                                                         goto finished;
5841                                                 }
5842                                                 s = err;
5843                                                 if(width < 0)
5844                                                 {
5845                                                         flags |= PRINTF_LEFT;
5846                                                         width = -width;
5847                                                 }
5848                                         }
5849                                         // otherwise width stays -1
5850                                 }
5851
5852                                 if(*s == '.')
5853                                 {
5854                                         ++s;
5855                                         if(*s == '*')
5856                                         {
5857                                                 ++s;
5858                                                 if(*s >= '0' && *s <= '9')
5859                                                 {
5860                                                         precision = strtol(s, &err, 10);
5861                                                         if(!err || *err != '$')
5862                                                         {
5863                                                                 VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
5864                                                                 goto finished;
5865                                                         }
5866                                                         s = err + 1;
5867                                                 }
5868                                                 else
5869                                                         precision = argpos++;
5870                                                 precision = GETARG_FLOAT(precision);
5871                                         }
5872                                         else if(*s >= '0' && *s <= '9')
5873                                         {
5874                                                 precision = strtol(s, &err, 10);
5875                                                 if(!err)
5876                                                 {
5877                                                         VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
5878                                                         goto finished;
5879                                                 }
5880                                                 s = err;
5881                                         }
5882                                         else
5883                                         {
5884                                                 VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
5885                                                 goto finished;
5886                                         }
5887                                 }
5888
5889                                 for(;;)
5890                                 {
5891                                         switch(*s)
5892                                         {
5893                                                 case 'h': isfloat = 1; break;
5894                                                 case 'l': isfloat = 0; break;
5895                                                 case 'L': isfloat = 0; break;
5896                                                 case 'j': break;
5897                                                 case 'z': break;
5898                                                 case 't': break;
5899                                                 default:
5900                                                         goto nolength;
5901                                         }
5902                                         ++s;
5903                                 }
5904 nolength:
5905
5906                                 // now s points to the final directive char and is no longer changed
5907                                 if(isfloat < 0)
5908                                 {
5909                                         if(*s == 'i')
5910                                                 isfloat = 0;
5911                                         else
5912                                                 isfloat = 1;
5913                                 }
5914
5915                                 if(thisarg < 0)
5916                                         thisarg = argpos++;
5917
5918                                 if(o < end - 1)
5919                                 {
5920                                         f = &formatbuf[1];
5921                                         if(*s != 's' && *s != 'c')
5922                                                 if(flags & PRINTF_ALTERNATE) *f++ = '#';
5923                                         if(flags & PRINTF_ZEROPAD) *f++ = '0';
5924                                         if(flags & PRINTF_LEFT) *f++ = '-';
5925                                         if(flags & PRINTF_SPACEPOSITIVE) *f++ = ' ';
5926                                         if(flags & PRINTF_SIGNPOSITIVE) *f++ = '+';
5927                                         *f++ = '*';
5928                                         if(precision >= 0)
5929                                         {
5930                                                 *f++ = '.';
5931                                                 *f++ = '*';
5932                                         }
5933                                         if(*s == 'd' || *s == 'i' || *s == 'o' || *s == 'u' || *s == 'x' || *s == 'X')
5934                                         {
5935                                                 // make it use a good integer type
5936                                                 for(p = INT_LOSSLESS_FORMAT_SIZE; *p; )
5937                                                         *f++ = *p++;
5938                                         }
5939                                         *f++ = *s;
5940                                         *f++ = 0;
5941
5942                                         if(width < 0) // not set
5943                                                 width = 0;
5944
5945                                         switch(*s)
5946                                         {
5947                                                 case 'd': case 'i':
5948                                                         if(precision < 0) // not set
5949                                                                 o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? INT_LOSSLESS_FORMAT_CONVERT_S(GETARG_FLOAT(thisarg)) : INT_LOSSLESS_FORMAT_CONVERT_S(GETARG_INT(thisarg))));
5950                                                         else
5951                                                                 o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? INT_LOSSLESS_FORMAT_CONVERT_S(GETARG_FLOAT(thisarg)) : INT_LOSSLESS_FORMAT_CONVERT_S(GETARG_INT(thisarg))));
5952                                                         break;
5953                                                 case 'o': case 'u': case 'x': case 'X':
5954                                                         if(precision < 0) // not set
5955                                                                 o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? INT_LOSSLESS_FORMAT_CONVERT_U(GETARG_FLOAT(thisarg)) : INT_LOSSLESS_FORMAT_CONVERT_U(GETARG_INT(thisarg))));
5956                                                         else
5957                                                                 o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? INT_LOSSLESS_FORMAT_CONVERT_U(GETARG_FLOAT(thisarg)) : INT_LOSSLESS_FORMAT_CONVERT_U(GETARG_INT(thisarg))));
5958                                                         break;
5959                                                 case 'e': case 'E': case 'f': case 'F': case 'g': case 'G':
5960                                                         if(precision < 0) // not set
5961                                                                 o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
5962                                                         else
5963                                                                 o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
5964                                                         break;
5965                                                 case 'v': case 'V':
5966                                                         f[-2] += 'g' - 'v';
5967                                                         if(precision < 0) // not set
5968                                                                 o += dpsnprintf(o, end - o, va(vabuf, sizeof(vabuf), "%s %s %s", /* NESTED SPRINTF IS NESTED */ formatbuf, formatbuf, formatbuf),
5969                                                                         width, (isfloat ? (double) GETARG_VECTOR(thisarg)[0] : (double) GETARG_INTVECTOR(thisarg)[0]),
5970                                                                         width, (isfloat ? (double) GETARG_VECTOR(thisarg)[1] : (double) GETARG_INTVECTOR(thisarg)[1]),
5971                                                                         width, (isfloat ? (double) GETARG_VECTOR(thisarg)[2] : (double) GETARG_INTVECTOR(thisarg)[2])
5972                                                                 );
5973                                                         else
5974                                                                 o += dpsnprintf(o, end - o, va(vabuf, sizeof(vabuf), "%s %s %s", /* NESTED SPRINTF IS NESTED */ formatbuf, formatbuf, formatbuf),
5975                                                                         width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[0] : (double) GETARG_INTVECTOR(thisarg)[0]),
5976                                                                         width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[1] : (double) GETARG_INTVECTOR(thisarg)[1]),
5977                                                                         width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[2] : (double) GETARG_INTVECTOR(thisarg)[2])
5978                                                                 );
5979                                                         break;
5980                                                 case 'c':
5981                                                         if(flags & PRINTF_ALTERNATE)
5982                                                         {
5983                                                                 if(precision < 0) // not set
5984                                                                         o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
5985                                                                 else
5986                                                                         o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
5987                                                         }
5988                                                         else
5989                                                         {
5990                                                                 unsigned int c = (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg));
5991                                                                 char charbuf16[16];
5992                                                                 const char *buf = u8_encodech(c, NULL, charbuf16);
5993                                                                 if(!buf)
5994                                                                         buf = "";
5995                                                                 if(precision < 0) // not set
5996                                                                         precision = end - o - 1;
5997                                                                 o += u8_strpad(o, end - o, buf, (flags & PRINTF_LEFT) != 0, width, precision);
5998                                                         }
5999                                                         break;
6000                                                 //spike FIXME -- 'S' for quoted tokenize-safe-or-print escaping of strings so stuff can safely survive console commands.
6001                                                 case 's':
6002                                                         if(flags & PRINTF_ALTERNATE)
6003                                                         {
6004                                                                 if(precision < 0) // not set
6005                                                                         o += dpsnprintf(o, end - o, formatbuf, width, GETARG_STRING(thisarg));
6006                                                                 else
6007                                                                         o += dpsnprintf(o, end - o, formatbuf, width, precision, GETARG_STRING(thisarg));
6008                                                         }
6009                                                         else
6010                                                         {
6011                                                                 if(precision < 0) // not set
6012                                                                         precision = end - o - 1;
6013                                                                 if(flags & PRINTF_SIGNPOSITIVE)
6014                                                                         o += u8_strpad(o, end - o, GETARG_STRING(thisarg), (flags & PRINTF_LEFT) != 0, width, precision);
6015                                                                 else
6016                                                                         o += u8_strpad_colorcodes(o, end - o, GETARG_STRING(thisarg), (flags & PRINTF_LEFT) != 0, width, precision);
6017                                                         }
6018                                                         break;
6019                                                 default:
6020                                                         VM_Warning(prog, "VM_sprintf: invalid directive in %s: %s\n", prog->name, s0);
6021                                                         goto finished;
6022                                         }
6023                                 }
6024                                 ++s;
6025                                 break;
6026                         default:
6027 verbatim:
6028                                 if(o < end - 1)
6029                                         *o++ = *s;
6030                                 ++s;
6031                                 break;
6032                 }
6033         }
6034 finished:
6035         *o = 0;
6036         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, outbuf);
6037 }
6038
6039
6040 // surface querying
6041
6042 static model_t *getmodel(prvm_prog_t *prog, prvm_edict_t *ed)
6043 {
6044         if (prog == SVVM_prog)
6045                 return SV_GetModelFromEdict(ed);
6046         else if (prog == CLVM_prog)
6047                 return CL_GetModelFromEdict(ed);
6048         else
6049                 return NULL;
6050 }
6051
6052 struct animatemodel_cache
6053 {
6054         model_t *model;
6055         frameblend_t frameblend[MAX_FRAMEBLENDS];
6056         skeleton_t *skeleton_p;
6057         skeleton_t skeleton;
6058         float *data_vertex3f;
6059         float *data_svector3f;
6060         float *data_tvector3f;
6061         float *data_normal3f;
6062         int max_vertices;
6063         float *buf_vertex3f;
6064         float *buf_svector3f;
6065         float *buf_tvector3f;
6066         float *buf_normal3f;
6067 };
6068
6069 static void animatemodel_reset(prvm_prog_t *prog)
6070 {
6071         if (!prog->animatemodel_cache)
6072                 return;
6073         if(prog->animatemodel_cache->buf_vertex3f) Mem_Free(prog->animatemodel_cache->buf_vertex3f);
6074         if(prog->animatemodel_cache->buf_svector3f) Mem_Free(prog->animatemodel_cache->buf_svector3f);
6075         if(prog->animatemodel_cache->buf_tvector3f) Mem_Free(prog->animatemodel_cache->buf_tvector3f);
6076         if(prog->animatemodel_cache->buf_normal3f) Mem_Free(prog->animatemodel_cache->buf_normal3f);
6077         Mem_Free(prog->animatemodel_cache);
6078 }
6079
6080 static void animatemodel(prvm_prog_t *prog, model_t *model, prvm_edict_t *ed)
6081 {
6082         skeleton_t *skeleton;
6083         int skeletonindex = -1;
6084         qbool need = false;
6085         struct animatemodel_cache *animatemodel_cache;
6086         if (!prog->animatemodel_cache)
6087         {
6088                 prog->animatemodel_cache = (struct animatemodel_cache *)Mem_Alloc(prog->progs_mempool, sizeof(struct animatemodel_cache));
6089                 memset(prog->animatemodel_cache, 0, sizeof(struct animatemodel_cache));
6090         }
6091         animatemodel_cache = prog->animatemodel_cache;
6092         if(!(model->surfmesh.isanimated && model->AnimateVertices))
6093         {
6094                 animatemodel_cache->data_vertex3f = model->surfmesh.data_vertex3f;
6095                 animatemodel_cache->data_svector3f = model->surfmesh.data_svector3f;
6096                 animatemodel_cache->data_tvector3f = model->surfmesh.data_tvector3f;
6097                 animatemodel_cache->data_normal3f = model->surfmesh.data_normal3f;
6098                 return;
6099         }
6100         need |= (animatemodel_cache->model != model);
6101         VM_GenerateFrameGroupBlend(prog, ed->priv.server->framegroupblend, ed);
6102         VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model, PRVM_serverglobalfloat(time));
6103         need |= (memcmp(&animatemodel_cache->frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend))) != 0;
6104         skeletonindex = (int)PRVM_gameedictfloat(ed, skeletonindex) - 1;
6105         if (!(skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones))
6106                 skeleton = NULL;
6107         need |= (animatemodel_cache->skeleton_p != skeleton);
6108         if(skeleton)
6109                 need |= (memcmp(&animatemodel_cache->skeleton, skeleton, sizeof(ed->priv.server->skeleton))) != 0;
6110         if(!need)
6111                 return;
6112         if(model->surfmesh.num_vertices > animatemodel_cache->max_vertices)
6113         {
6114                 animatemodel_cache->max_vertices = model->surfmesh.num_vertices * 2;
6115                 if(animatemodel_cache->buf_vertex3f) Mem_Free(animatemodel_cache->buf_vertex3f);
6116                 if(animatemodel_cache->buf_svector3f) Mem_Free(animatemodel_cache->buf_svector3f);
6117                 if(animatemodel_cache->buf_tvector3f) Mem_Free(animatemodel_cache->buf_tvector3f);
6118                 if(animatemodel_cache->buf_normal3f) Mem_Free(animatemodel_cache->buf_normal3f);
6119                 animatemodel_cache->buf_vertex3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache->max_vertices);
6120                 animatemodel_cache->buf_svector3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache->max_vertices);
6121                 animatemodel_cache->buf_tvector3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache->max_vertices);
6122                 animatemodel_cache->buf_normal3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache->max_vertices);
6123         }
6124         animatemodel_cache->data_vertex3f = animatemodel_cache->buf_vertex3f;
6125         animatemodel_cache->data_svector3f = animatemodel_cache->buf_svector3f;
6126         animatemodel_cache->data_tvector3f = animatemodel_cache->buf_tvector3f;
6127         animatemodel_cache->data_normal3f = animatemodel_cache->buf_normal3f;
6128         VM_UpdateEdictSkeleton(prog, ed, model, ed->priv.server->frameblend);
6129         model->AnimateVertices(model, ed->priv.server->frameblend, &ed->priv.server->skeleton, animatemodel_cache->data_vertex3f, animatemodel_cache->data_normal3f, animatemodel_cache->data_svector3f, animatemodel_cache->data_tvector3f);
6130         animatemodel_cache->model = model;
6131         memcpy(&animatemodel_cache->frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend));
6132         animatemodel_cache->skeleton_p = skeleton;
6133         if(skeleton)
6134                 memcpy(&animatemodel_cache->skeleton, skeleton, sizeof(ed->priv.server->skeleton));
6135 }
6136
6137 static void getmatrix(prvm_prog_t *prog, prvm_edict_t *ed, matrix4x4_t *out)
6138 {
6139         if (prog == SVVM_prog)
6140                 SV_GetEntityMatrix(prog, ed, out, false);
6141         else if (prog == CLVM_prog)
6142                 CL_GetEntityMatrix(prog, ed, out, false);
6143         else
6144                 *out = identitymatrix;
6145 }
6146
6147 static void applytransform_forward(prvm_prog_t *prog, const vec3_t in, prvm_edict_t *ed, vec3_t out)
6148 {
6149         matrix4x4_t m;
6150         getmatrix(prog, ed, &m);
6151         Matrix4x4_Transform(&m, in, out);
6152 }
6153
6154 static void applytransform_forward_direction(prvm_prog_t *prog, const vec3_t in, prvm_edict_t *ed, vec3_t out)
6155 {
6156         matrix4x4_t m;
6157         getmatrix(prog, ed, &m);
6158         Matrix4x4_Transform3x3(&m, in, out);
6159 }
6160
6161 static void applytransform_inverted(prvm_prog_t *prog, const vec3_t in, prvm_edict_t *ed, vec3_t out)
6162 {
6163         matrix4x4_t m, n;
6164         getmatrix(prog, ed, &m);
6165         Matrix4x4_Invert_Full(&n, &m);
6166         Matrix4x4_Transform3x3(&n, in, out);
6167 }
6168
6169 static void applytransform_forward_normal(prvm_prog_t *prog, const vec3_t in, prvm_edict_t *ed, vec3_t out)
6170 {
6171         matrix4x4_t m;
6172         float p[4];
6173         getmatrix(prog, ed, &m);
6174         Matrix4x4_TransformPositivePlane(&m, in[0], in[1], in[2], 0, p);
6175         VectorCopy(p, out);
6176 }
6177
6178 static void clippointtosurface(prvm_prog_t *prog, prvm_edict_t *ed, model_t *model, msurface_t *surface, vec3_t p, vec3_t out)
6179 {
6180         int i, j, k;
6181         float *v[3], facenormal[3], edgenormal[3], sidenormal[3], temp[3], offsetdist, dist, bestdist;
6182         const int *e;
6183         animatemodel(prog, model, ed);
6184         bestdist = 1000000000;
6185         VectorCopy(p, out);
6186         for (i = 0, e = (model->surfmesh.data_element3i + 3 * surface->num_firsttriangle);i < surface->num_triangles;i++, e += 3)
6187         {
6188                 // clip original point to each triangle of the surface and find the
6189                 // triangle that is closest
6190                 v[0] = prog->animatemodel_cache->data_vertex3f + e[0] * 3;
6191                 v[1] = prog->animatemodel_cache->data_vertex3f + e[1] * 3;
6192                 v[2] = prog->animatemodel_cache->data_vertex3f + e[2] * 3;
6193                 TriangleNormal(v[0], v[1], v[2], facenormal);
6194                 VectorNormalize(facenormal);
6195                 offsetdist = DotProduct(v[0], facenormal) - DotProduct(p, facenormal);
6196                 VectorMA(p, offsetdist, facenormal, temp);
6197                 for (j = 0, k = 2;j < 3;k = j, j++)
6198                 {
6199                         VectorSubtract(v[k], v[j], edgenormal);
6200                         CrossProduct(edgenormal, facenormal, sidenormal);
6201                         VectorNormalize(sidenormal);
6202                         offsetdist = DotProduct(v[k], sidenormal) - DotProduct(temp, sidenormal);
6203                         if (offsetdist < 0)
6204                                 VectorMA(temp, offsetdist, sidenormal, temp);
6205                 }
6206                 dist = VectorDistance2(temp, p);
6207                 if (bestdist > dist)
6208                 {
6209                         bestdist = dist;
6210                         VectorCopy(temp, out);
6211                 }
6212         }
6213 }
6214
6215 static msurface_t *getsurface(model_t *model, int surfacenum)
6216 {
6217         if (surfacenum < 0 || surfacenum >= model->submodelsurfaces_end - model->submodelsurfaces_start)
6218                 return NULL;
6219         return model->data_surfaces + surfacenum + model->submodelsurfaces_start;
6220 }
6221
6222
6223 //PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434;
6224 void VM_getsurfacenumpoints(prvm_prog_t *prog)
6225 {
6226         model_t *model;
6227         msurface_t *surface;
6228         VM_SAFEPARMCOUNT(2, VM_getsurfacenumpoints);
6229         // return 0 if no such surface
6230         if (!(model = getmodel(prog, PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6231         {
6232                 PRVM_G_FLOAT(OFS_RETURN) = 0;
6233                 return;
6234         }
6235
6236         // note: this (incorrectly) assumes it is a simple polygon
6237         PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
6238 }
6239 //PF_getsurfacepoint,     // #435 vector(entity e, float s, float n) getsurfacepoint = #435;
6240 void VM_getsurfacepoint(prvm_prog_t *prog)
6241 {
6242         prvm_edict_t *ed;
6243         model_t *model;
6244         msurface_t *surface;
6245         int pointnum;
6246         vec3_t result;
6247         VM_SAFEPARMCOUNT(3, VM_getsurfacepoint);
6248         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
6249         ed = PRVM_G_EDICT(OFS_PARM0);
6250         if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6251                 return;
6252         // note: this (incorrectly) assumes it is a simple polygon
6253         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
6254         if (pointnum < 0 || pointnum >= surface->num_vertices)
6255                 return;
6256         animatemodel(prog, model, ed);
6257         applytransform_forward(prog, &(prog->animatemodel_cache->data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, result);
6258         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6259 }
6260 //PF_getsurfacepointattribute,     // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
6261 // float SPA_POSITION = 0;
6262 // float SPA_S_AXIS = 1;
6263 // float SPA_T_AXIS = 2;
6264 // float SPA_R_AXIS = 3; // same as SPA_NORMAL
6265 // float SPA_TEXCOORDS0 = 4;
6266 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
6267 // float SPA_LIGHTMAP0_COLOR = 6;
6268 void VM_getsurfacepointattribute(prvm_prog_t *prog)
6269 {
6270         prvm_edict_t *ed;
6271         model_t *model;
6272         msurface_t *surface;
6273         int pointnum;
6274         int attributetype;
6275         vec3_t result;
6276
6277         VM_SAFEPARMCOUNT(4, VM_getsurfacepointattribute);
6278         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
6279         ed = PRVM_G_EDICT(OFS_PARM0);
6280         if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6281                 return;
6282         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
6283         if (pointnum < 0 || pointnum >= surface->num_vertices)
6284                 return;
6285         attributetype = (int) PRVM_G_FLOAT(OFS_PARM3);
6286
6287         animatemodel(prog, model, ed);
6288
6289         switch( attributetype ) {
6290                 // float SPA_POSITION = 0;
6291                 case 0:
6292                         applytransform_forward(prog, &(prog->animatemodel_cache->data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, result);
6293                         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6294                         break;
6295                 // float SPA_S_AXIS = 1;
6296                 case 1:
6297                         applytransform_forward_direction(prog, &(prog->animatemodel_cache->data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, result);
6298                         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6299                         break;
6300                 // float SPA_T_AXIS = 2;
6301                 case 2:
6302                         applytransform_forward_direction(prog, &(prog->animatemodel_cache->data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, result);
6303                         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6304                         break;
6305                 // float SPA_R_AXIS = 3; // same as SPA_NORMAL
6306                 case 3:
6307                         applytransform_forward_direction(prog, &(prog->animatemodel_cache->data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], ed, result);
6308                         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6309                         break;
6310                 // float SPA_TEXCOORDS0 = 4;
6311                 case 4: {
6312                         float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2];
6313                         result[0] = texcoord[0];
6314                         result[1] = texcoord[1];
6315                         result[2] = 0.0f;
6316                         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6317                         break;
6318                 }
6319                 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
6320                 case 5: {
6321                         float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2];
6322                         result[0] = texcoord[0];
6323                         result[1] = texcoord[1];
6324                         result[2] = 0.0f;
6325                         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6326                         break;
6327                 }
6328                 // float SPA_LIGHTMAP0_COLOR = 6;
6329                 case 6:
6330                         // ignore alpha for now..
6331                         VectorCopy( &(model->surfmesh.data_lightmapcolor4f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN));
6332                         break;
6333                 default:
6334                         VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f );
6335                         break;
6336         }
6337 }
6338 //PF_getsurfacenormal,    // #436 vector(entity e, float s) getsurfacenormal = #436;
6339 void VM_getsurfacenormal(prvm_prog_t *prog)
6340 {
6341         model_t *model;
6342         msurface_t *surface;
6343         vec3_t normal;
6344         vec3_t result;
6345         VM_SAFEPARMCOUNT(2, VM_getsurfacenormal);
6346         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
6347         if (!(model = getmodel(prog, PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6348                 return;
6349         // note: this only returns the first triangle, so it doesn't work very
6350         // well for curved surfaces or arbitrary meshes
6351         animatemodel(prog, model, PRVM_G_EDICT(OFS_PARM0));
6352         TriangleNormal((prog->animatemodel_cache->data_vertex3f + 3 * surface->num_firstvertex), (prog->animatemodel_cache->data_vertex3f + 3 * surface->num_firstvertex) + 3, (prog->animatemodel_cache->data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
6353         applytransform_forward_normal(prog, normal, PRVM_G_EDICT(OFS_PARM0), result);
6354         VectorNormalize(result);
6355         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
6356 }
6357 //PF_getsurfacetexture,   // #437 string(entity e, float s) getsurfacetexture = #437;
6358 void VM_getsurfacetexture(prvm_prog_t *prog)
6359 {
6360         model_t *model;
6361         msurface_t *surface;
6362         VM_SAFEPARMCOUNT(2, VM_getsurfacetexture);
6363         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
6364         if (!(model = getmodel(prog, PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6365                 return;
6366         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, surface->texture->name);
6367 }
6368 //PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438;
6369 void VM_getsurfacenearpoint(prvm_prog_t *prog)
6370 {
6371         int surfacenum, best;
6372         vec3_t clipped, p;
6373         vec_t dist, bestdist;
6374         prvm_edict_t *ed;
6375         model_t *model;
6376         msurface_t *surface;
6377         vec3_t point;
6378         VM_SAFEPARMCOUNT(2, VM_getsurfacenearpoint);
6379         PRVM_G_FLOAT(OFS_RETURN) = -1;
6380         ed = PRVM_G_EDICT(OFS_PARM0);
6381         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), point);
6382
6383         if (!ed || ed->free)
6384                 return;
6385         model = getmodel(prog, ed);
6386         if (!model || !model->num_surfaces)
6387                 return;
6388
6389         animatemodel(prog, model, ed);
6390
6391         applytransform_inverted(prog, point, ed, p);
6392         best = -1;
6393         bestdist = 1000000000;
6394         for (surfacenum = model->submodelsurfaces_start;surfacenum < model->submodelsurfaces_end;surfacenum++)
6395         {
6396                 surface = model->data_surfaces + surfacenum;
6397                 // first see if the nearest point on the surface's box is closer than the previous match
6398                 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
6399                 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
6400                 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
6401                 dist = VectorLength2(clipped);
6402                 if (dist < bestdist)
6403                 {
6404                         // it is, check the nearest point on the actual geometry
6405                         clippointtosurface(prog, ed, model, surface, p, clipped);
6406                         VectorSubtract(clipped, p, clipped);
6407                         dist += VectorLength2(clipped);
6408                         if (dist < bestdist)
6409                         {
6410                                 // that's closer too, store it as the best match
6411                                 best = surfacenum - model->submodelsurfaces_start;
6412                                 bestdist = dist;
6413                         }
6414                 }
6415         }
6416         PRVM_G_FLOAT(OFS_RETURN) = best;
6417 }
6418 //PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439;
6419 void VM_getsurfaceclippedpoint(prvm_prog_t *prog)
6420 {
6421         prvm_edict_t *ed;
6422         model_t *model;
6423         msurface_t *surface;
6424         vec3_t p, out, inp;
6425         VM_SAFEPARMCOUNT(3, VM_getsurfaceclippedpoint);
6426         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
6427         ed = PRVM_G_EDICT(OFS_PARM0);
6428         if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6429                 return;
6430         animatemodel(prog, model, ed);
6431         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), inp);
6432         applytransform_inverted(prog, inp, ed, p);
6433         clippointtosurface(prog, ed, model, surface, p, out);
6434         VectorAdd(out, PRVM_serveredictvector(ed, origin), PRVM_G_VECTOR(OFS_RETURN));
6435 }
6436
6437 //PF_getsurfacenumtriangles, // #??? float(entity e, float s) getsurfacenumtriangles = #???;
6438 void VM_getsurfacenumtriangles(prvm_prog_t *prog)
6439 {
6440        model_t *model;
6441        msurface_t *surface;
6442        VM_SAFEPARMCOUNT(2, VM_getsurfacenumtriangles);
6443        // return 0 if no such surface
6444        if (!(model = getmodel(prog, PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6445        {
6446                PRVM_G_FLOAT(OFS_RETURN) = 0;
6447                return;
6448        }
6449
6450        PRVM_G_FLOAT(OFS_RETURN) = surface->num_triangles;
6451 }
6452 //PF_getsurfacetriangle,     // #??? vector(entity e, float s, float n) getsurfacetriangle = #???;
6453 void VM_getsurfacetriangle(prvm_prog_t *prog)
6454 {
6455        const vec3_t d = {-1, -1, -1};
6456        prvm_edict_t *ed;
6457        model_t *model;
6458        msurface_t *surface;
6459        int trinum;
6460        VM_SAFEPARMCOUNT(3, VM_getsurfacetriangle);
6461        VectorClear(PRVM_G_VECTOR(OFS_RETURN));
6462        ed = PRVM_G_EDICT(OFS_PARM0);
6463        if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
6464                return;
6465        trinum = (int)PRVM_G_FLOAT(OFS_PARM2);
6466        if (trinum < 0 || trinum >= surface->num_triangles)
6467                return;
6468        // FIXME: implement rotation/scaling
6469        VectorMA(&(model->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[trinum * 3], surface->num_firstvertex, d, PRVM_G_VECTOR(OFS_RETURN));
6470 }
6471
6472 //
6473 // physics builtins
6474 //
6475
6476 #ifdef USEODE
6477 #define VM_physics_ApplyCmd(ed,f) if (!ed->priv.server->ode_body) VM_physics_newstackfunction(prog, ed, f); else World_Physics_ApplyCmd(ed, f)
6478
6479 static edict_odefunc_t *VM_physics_newstackfunction(prvm_prog_t *prog, prvm_edict_t *ed, edict_odefunc_t *f)
6480 {
6481         edict_odefunc_t *newfunc, *func;
6482
6483         newfunc = (edict_odefunc_t *)Mem_Alloc(prog->progs_mempool, sizeof(edict_odefunc_t));
6484         memcpy(newfunc, f, sizeof(edict_odefunc_t));
6485         newfunc->next = NULL;
6486         if (!ed->priv.server->ode_func)
6487                 ed->priv.server->ode_func = newfunc;
6488         else
6489         {
6490                 for (func = ed->priv.server->ode_func; func->next; func = func->next);
6491                 func->next = newfunc;
6492         }
6493         return newfunc;
6494 }
6495 #endif
6496
6497 // void(entity e, float physics_enabled) physics_enable = #;
6498 void VM_physics_enable(prvm_prog_t *prog)
6499 {
6500 #ifdef USEODE
6501         prvm_edict_t *ed;
6502         edict_odefunc_t f;
6503 #endif
6504         VM_SAFEPARMCOUNT(2, VM_physics_enable);
6505 #ifdef USEODE
6506         ed = PRVM_G_EDICT(OFS_PARM0);
6507         if (!ed)
6508         {
6509                 if (developer.integer > 0)
6510                         VM_Warning(prog, "VM_physics_enable: null entity!\n");
6511                 return;
6512         }
6513         // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
6514         if (PRVM_serveredictfloat(ed, movetype) != MOVETYPE_PHYSICS)
6515         {
6516                 VM_Warning(prog, "VM_physics_enable: entity is not MOVETYPE_PHYSICS!\n");
6517                 return;
6518         }
6519         f.type = PRVM_G_FLOAT(OFS_PARM1) == 0 ? ODEFUNC_DISABLE : ODEFUNC_ENABLE;
6520         VM_physics_ApplyCmd(ed, &f);
6521 #endif
6522 }
6523
6524 // void(entity e, vector force, vector relative_ofs) physics_addforce = #;
6525 void VM_physics_addforce(prvm_prog_t *prog)
6526 {
6527 #ifdef USEODE
6528         prvm_edict_t *ed;
6529         edict_odefunc_t f;
6530 #endif
6531         VM_SAFEPARMCOUNT(3, VM_physics_addforce);
6532 #ifdef USEODE
6533         ed = PRVM_G_EDICT(OFS_PARM0);
6534         if (!ed)
6535         {
6536                 if (developer.integer > 0)
6537                         VM_Warning(prog, "VM_physics_addforce: null entity!\n");
6538                 return;
6539         }
6540         // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
6541         if (PRVM_serveredictfloat(ed, movetype) != MOVETYPE_PHYSICS)
6542         {
6543                 VM_Warning(prog, "VM_physics_addforce: entity is not MOVETYPE_PHYSICS!\n");
6544                 return;
6545         }
6546         f.type = ODEFUNC_FORCE;
6547         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
6548         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), f.v2);
6549         VM_physics_ApplyCmd(ed, &f);
6550 #endif
6551 }
6552
6553 // void(entity e, vector torque) physics_addtorque = #;
6554 void VM_physics_addtorque(prvm_prog_t *prog)
6555 {
6556 #ifdef USEODE
6557         prvm_edict_t *ed;
6558         edict_odefunc_t f;
6559 #endif
6560         VM_SAFEPARMCOUNT(2, VM_physics_addtorque);
6561 #ifdef USEODE
6562         ed = PRVM_G_EDICT(OFS_PARM0);
6563         if (!ed)
6564         {
6565                 if (developer.integer > 0)
6566                         VM_Warning(prog, "VM_physics_addtorque: null entity!\n");
6567                 return;
6568         }
6569         // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
6570         if (PRVM_serveredictfloat(ed, movetype) != MOVETYPE_PHYSICS)
6571         {
6572                 VM_Warning(prog, "VM_physics_addtorque: entity is not MOVETYPE_PHYSICS!\n");
6573                 return;
6574         }
6575         f.type = ODEFUNC_TORQUE;
6576         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
6577         VM_physics_ApplyCmd(ed, &f);
6578 #endif
6579 }
6580
6581 extern cvar_t prvm_coverage;
6582 void VM_coverage(prvm_prog_t *prog)
6583 {
6584         VM_SAFEPARMCOUNT(0, VM_coverage);
6585         if (prog->explicit_profile[prog->xstatement]++ == 0 && (prvm_coverage.integer & 2))
6586                 PRVM_ExplicitCoverageEvent(prog, prog->xfunction, prog->xstatement);
6587 }