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