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