Games/Quake/pr_cmds.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #include "quakedef.h"
  22
  23 #define RETURN_EDICT(e) (((int *)pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e))
  24
  25 /*
  26 ===============================================================================
  27
  28                                                 BUILT-IN FUNCTIONS
  29
  30 ===============================================================================
  31 */
  32
  33 char *PF_VarString (int first)
  34 {
  35         int             i;
  36         static char out[256];
  37
  38         out[0] = 0;
  39         for (i=first ; i<pr_argc ; i++)
  40         {
  41                 strcat (out, G_STRING((OFS_PARM0+i*3)));
  42         }
  43         return out;
  44 }
  45
  46
  47 /*
  48 =================
  49 PF_errror
  50
  51 This is a TERMINAL error, which will kill off the entire server.
  52 Dumps self.
  53
  54 error(value)
  55 =================
  56 */
  57 void PF_error (void)
  58 {
  59         char    *s;
  60         edict_t *ed;
  61
  62         s = PF_VarString(0);
  63         Con_Printf ("======SERVER ERROR in %s:\n%s\n"
  64         ,pr_strings + pr_xfunction->s_name,s);
  65         ed = PROG_TO_EDICT(pr_global_struct->self);
  66         ED_Print (ed);
  67
  68         Host_Error ("Program error");
  69 }
  70
  71 /*
  72 =================
  73 PF_objerror
  74
  75 Dumps out self, then an error message.  The program is aborted and self is
  76 removed, but the level can continue.
  77
  78 objerror(value)
  79 =================
  80 */
  81 void PF_objerror (void)
  82 {
  83         char    *s;
  84         edict_t *ed;
  85
  86         s = PF_VarString(0);
  87         Con_Printf ("======OBJECT ERROR in %s:\n%s\n"
  88         ,pr_strings + pr_xfunction->s_name,s);
  89         ed = PROG_TO_EDICT(pr_global_struct->self);
  90         ED_Print (ed);
  91         ED_Free (ed);
  92
  93         Host_Error ("Program error");
  94 }
  95
  96
  97
  98 /*
  99 ==============
 100 PF_makevectors
 101
 102 Writes new values for v_forward, v_up, and v_right based on angles
 103 makevectors(vector)
 104 ==============
 105 */
 106 void PF_makevectors (void)
 107 {
 108         AngleVectors (G_VECTOR(OFS_PARM0), pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up);
 109 }
 110
 111 /*
 112 =================
 113 PF_setorigin
 114
 115 This is the only valid way to move an object without using the physics of the world (setting velocity and waiting).  Directly changing origin will not set internal links correctly, so clipping would be messed up.  This should be called when an object is spawned, and then only if it is teleported.
 116
 117 setorigin (entity, origin)
 118 =================
 119 */
 120 void PF_setorigin (void)
 121 {
 122         edict_t *e;
 123         float   *org;
 124
 125         e = G_EDICT(OFS_PARM0);
 126         org = G_VECTOR(OFS_PARM1);
 127         VectorCopy (org, e->v.origin);
 128         SV_LinkEdict (e, false);
 129 }
 130
 131
 132 void SetMinMaxSize (edict_t *e, float *min, float *max, qboolean rotate)
 133 {
 134         float   *angles;
 135         vec3_t  rmin, rmax;
 136         float   bounds[2][3];
 137         float   xvector[2], yvector[2];
 138         float   a;
 139         vec3_t  base, transformed;
 140         int             i, j, k, l;
 141
 142         for (i=0 ; i<3 ; i++)
 143                 if (min[i] > max[i])
 144                         PR_RunError ("backwards mins/maxs");
 145
 146         rotate = false;         // FIXME: implement rotation properly again
 147
 148         if (!rotate)
 149         {
 150                 VectorCopy (min, rmin);
 151                 VectorCopy (max, rmax);
 152         }
 153         else
 154         {
 155         // find min / max for rotations
 156                 angles = e->v.angles;
 157
 158                 a = angles[1]/180 * M_PI;
 159
 160                 xvector[0] = cos(a);
 161                 xvector[1] = sin(a);
 162                 yvector[0] = -sin(a);
 163                 yvector[1] = cos(a);
 164
 165                 VectorCopy (min, bounds[0]);
 166                 VectorCopy (max, bounds[1]);
 167
 168                 rmin[0] = rmin[1] = rmin[2] = 9999;
 169                 rmax[0] = rmax[1] = rmax[2] = -9999;
 170
 171                 for (i=0 ; i<= 1 ; i++)
 172                 {
 173                         base[0] = bounds[i][0];
 174                         for (j=0 ; j<= 1 ; j++)
 175                         {
 176                                 base[1] = bounds[j][1];
 177                                 for (k=0 ; k<= 1 ; k++)
 178                                 {
 179                                         base[2] = bounds[k][2];
 180
 181                                 // transform the point
 182                                         transformed[0] = xvector[0]*base[0] + yvector[0]*base[1];
 183                                         transformed[1] = xvector[1]*base[0] + yvector[1]*base[1];
 184                                         transformed[2] = base[2];
 185
 186                                         for (l=0 ; l<3 ; l++)
 187                                         {
 188                                                 if (transformed[l] < rmin[l])
 189                                                         rmin[l] = transformed[l];
 190                                                 if (transformed[l] > rmax[l])
 191                                                         rmax[l] = transformed[l];
 192                                         }
 193                                 }
 194                         }
 195                 }
 196         }
 197
 198 // set derived values
 199         VectorCopy (rmin, e->v.mins);
 200         VectorCopy (rmax, e->v.maxs);
 201         VectorSubtract (max, min, e->v.size);
 202
 203         SV_LinkEdict (e, false);
 204 }
 205
 206 /*
 207 =================
 208 PF_setsize
 209
 210 the size box is rotated by the current angle
 211
 212 setsize (entity, minvector, maxvector)
 213 =================
 214 */
 215 void PF_setsize (void)
 216 {
 217         edict_t *e;
 218         float   *min, *max;
 219
 220         e = G_EDICT(OFS_PARM0);
 221         min = G_VECTOR(OFS_PARM1);
 222         max = G_VECTOR(OFS_PARM2);
 223         SetMinMaxSize (e, min, max, false);
 224 }
 225
 226
 227 /*
 228 =================
 229 PF_setmodel
 230
 231 setmodel(entity, model)
 232 =================
 233 */
 234 void PF_setmodel (void)
 235 {
 236         edict_t *e;
 237         char    *m, **check;
 238         model_t *mod;
 239         int             i;
 240
 241         e = G_EDICT(OFS_PARM0);
 242         m = G_STRING(OFS_PARM1);
 243
 244 // check to see if model was properly precached
 245         for (i=0, check = sv.model_precache ; *check ; i++, check++)
 246                 if (!strcmp(*check, m))
 247                         break;
 248
 249         if (!*check)
 250                 PR_RunError ("no precache: %s\n", m);
 251
 252
 253         e->v.model = m - pr_strings;
 254         e->v.modelindex = i; //SV_ModelIndex (m);
 255
 256         mod = sv.models[ (int)e->v.modelindex];  // Mod_ForName (m, true);
 257
 258         if (mod)
 259                 SetMinMaxSize (e, mod->mins, mod->maxs, true);
 260         else
 261                 SetMinMaxSize (e, vec3_origin, vec3_origin, true);
 262 }
 263
 264 /*
 265 =================
 266 PF_bprint
 267
 268 broadcast print to everyone on server
 269
 270 bprint(value)
 271 =================
 272 */
 273 void PF_bprint (void)
 274 {
 275         char            *s;
 276
 277         s = PF_VarString(0);
 278         SV_BroadcastPrintf ("%s", s);
 279 }
 280
 281 /*
 282 =================
 283 PF_sprint
 284
 285 single print to a specific client
 286
 287 sprint(clientent, value)
 288 =================
 289 */
 290 void PF_sprint (void)
 291 {
 292         char            *s;
 293         client_t        *client;
 294         int                     entnum;
 295
 296         entnum = G_EDICTNUM(OFS_PARM0);
 297         s = PF_VarString(1);
 298
 299         if (entnum < 1 || entnum > svs.maxclients)
 300         {
 301                 Con_Printf ("tried to sprint to a non-client\n");
 302                 return;
 303         }
 304
 305         client = &svs.clients[entnum-1];
 306
 307         MSG_WriteChar (&client->message,svc_print);
 308         MSG_WriteString (&client->message, s );
 309 }
 310
 311
 312 /*
 313 =================
 314 PF_centerprint
 315
 316 single print to a specific client
 317
 318 centerprint(clientent, value)
 319 =================
 320 */
 321 void PF_centerprint (void)
 322 {
 323         char            *s;
 324         client_t        *client;
 325         int                     entnum;
 326
 327         entnum = G_EDICTNUM(OFS_PARM0);
 328         s = PF_VarString(1);
 329
 330         if (entnum < 1 || entnum > svs.maxclients)
 331         {
 332                 Con_Printf ("tried to sprint to a non-client\n");
 333                 return;
 334         }
 335
 336         client = &svs.clients[entnum-1];
 337
 338         MSG_WriteChar (&client->message,svc_centerprint);
 339         MSG_WriteString (&client->message, s );
 340 }
 341
 342
 343 /*
 344 =================
 345 PF_normalize
 346
 347 vector normalize(vector)
 348 =================
 349 */
 350 void PF_normalize (void)
 351 {
 352         float   *value1;
 353         vec3_t  newvalue;
 354         float   new;
 355
 356         value1 = G_VECTOR(OFS_PARM0);
 357
 358         new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
 359         new = sqrt(new);
 360
 361         if (new == 0)
 362                 newvalue[0] = newvalue[1] = newvalue[2] = 0;
 363         else
 364         {
 365                 new = 1/new;
 366                 newvalue[0] = value1[0] * new;
 367                 newvalue[1] = value1[1] * new;
 368                 newvalue[2] = value1[2] * new;
 369         }
 370
 371         VectorCopy (newvalue, G_VECTOR(OFS_RETURN));
 372 }
 373
 374 /*
 375 =================
 376 PF_vlen
 377
 378 scalar vlen(vector)
 379 =================
 380 */
 381 void PF_vlen (void)
 382 {
 383         float   *value1;
 384         float   new;
 385
 386         value1 = G_VECTOR(OFS_PARM0);
 387
 388         new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
 389         new = sqrt(new);
 390
 391         G_FLOAT(OFS_RETURN) = new;
 392 }
 393
 394 /*
 395 =================
 396 PF_vectoyaw
 397
 398 float vectoyaw(vector)
 399 =================
 400 */
 401 void PF_vectoyaw (void)
 402 {
 403         float   *value1;
 404         float   yaw;
 405
 406         value1 = G_VECTOR(OFS_PARM0);
 407
 408         if (value1[1] == 0 && value1[0] == 0)
 409                 yaw = 0;
 410         else
 411         {
 412                 yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
 413                 if (yaw < 0)
 414                         yaw += 360;
 415         }
 416
 417         G_FLOAT(OFS_RETURN) = yaw;
 418 }
 419
 420
 421 /*
 422 =================
 423 PF_vectoangles
 424
 425 vector vectoangles(vector)
 426 =================
 427 */
 428 void PF_vectoangles (void)
 429 {
 430         float   *value1;
 431         float   forward;
 432         float   yaw, pitch;
 433
 434         value1 = G_VECTOR(OFS_PARM0);
 435
 436         if (value1[1] == 0 && value1[0] == 0)
 437         {
 438                 yaw = 0;
 439                 if (value1[2] > 0)
 440                         pitch = 90;
 441                 else
 442                         pitch = 270;
 443         }
 444         else
 445         {
 446                 yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
 447                 if (yaw < 0)
 448                         yaw += 360;
 449
 450                 forward = sqrt (value1[0]*value1[0] + value1[1]*value1[1]);
 451                 pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
 452                 if (pitch < 0)
 453                         pitch += 360;
 454         }
 455
 456         G_FLOAT(OFS_RETURN+0) = pitch;
 457         G_FLOAT(OFS_RETURN+1) = yaw;
 458         G_FLOAT(OFS_RETURN+2) = 0;
 459 }
 460
 461 /*
 462 =================
 463 PF_Random
 464
 465 Returns a number from 0<= num < 1
 466
 467 random()
 468 =================
 469 */
 470 void PF_random (void)
 471 {
 472         float           num;
 473
 474         num = (rand ()&0x7fff) / ((float)0x7fff);
 475
 476         G_FLOAT(OFS_RETURN) = num;
 477 }
 478
 479 /*
 480 =================
 481 PF_particle
 482
 483 particle(origin, color, count)
 484 =================
 485 */
 486 void PF_particle (void)
 487 {
 488         float           *org, *dir;
 489         float           color;
 490         float           count;
 491
 492         org = G_VECTOR(OFS_PARM0);
 493         dir = G_VECTOR(OFS_PARM1);
 494         color = G_FLOAT(OFS_PARM2);
 495         count = G_FLOAT(OFS_PARM3);
 496         SV_StartParticle (org, dir, color, count);
 497 }
 498
 499
 500 /*
 501 =================
 502 PF_ambientsound
 503
 504 =================
 505 */
 506 void PF_ambientsound (void)
 507 {
 508         char            **check;
 509         char            *samp;
 510         float           *pos;
 511         float           vol, attenuation;
 512         int                     i, soundnum;
 513
 514         pos = G_VECTOR (OFS_PARM0);
 515         samp = G_STRING(OFS_PARM1);
 516         vol = G_FLOAT(OFS_PARM2);
 517         attenuation = G_FLOAT(OFS_PARM3);
 518
 519 // check to see if samp was properly precached
 520         for (soundnum=0, check = sv.sound_precache ; *check ; check++, soundnum++)
 521                 if (!strcmp(*check,samp))
 522                         break;
 523
 524         if (!*check)
 525         {
 526                 Con_Printf ("no precache: %s\n", samp);
 527                 return;
 528         }
 529
 530 // add an svc_spawnambient command to the level signon packet
 531
 532         MSG_WriteByte (&sv.signon,svc_spawnstaticsound);
 533         for (i=0 ; i<3 ; i++)
 534                 MSG_WriteCoord(&sv.signon, pos[i]);
 535
 536         MSG_WriteByte (&sv.signon, soundnum);
 537
 538         MSG_WriteByte (&sv.signon, vol*255);
 539         MSG_WriteByte (&sv.signon, attenuation*64);
 540
 541 }
 542
 543 /*
 544 =================
 545 PF_sound
 546
 547 Each entity can have eight independant sound sources, like voice,
 548 weapon, feet, etc.
 549
 550 Channel 0 is an auto-allocate channel, the others override anything
 551 allready running on that entity/channel pair.
 552
 553 An attenuation of 0 will play full volume everywhere in the level.
 554 Larger attenuations will drop off.
 555
 556 =================
 557 */
 558 void PF_sound (void)
 559 {
 560         char            *sample;
 561         int                     channel;
 562         edict_t         *entity;
 563         int             volume;
 564         float attenuation;
 565
 566         entity = G_EDICT(OFS_PARM0);
 567         channel = G_FLOAT(OFS_PARM1);
 568         sample = G_STRING(OFS_PARM2);
 569         volume = G_FLOAT(OFS_PARM3) * 255;
 570         attenuation = G_FLOAT(OFS_PARM4);
 571
 572         if (volume < 0 || volume > 255)
 573                 Sys_Error ("SV_StartSound: volume = %i", volume);
 574
 575         if (attenuation < 0 || attenuation > 4)
 576                 Sys_Error ("SV_StartSound: attenuation = %f", attenuation);
 577
 578         if (channel < 0 || channel > 7)
 579                 Sys_Error ("SV_StartSound: channel = %i", channel);
 580
 581         SV_StartSound (entity, channel, sample, volume, attenuation);
 582 }
 583
 584 /*
 585 =================
 586 PF_break
 587
 588 break()
 589 =================
 590 */
 591 void PF_break (void)
 592 {
 593 Con_Printf ("break statement\n");
 594 *(int *)-4 = 0; // dump to debugger
 595 //      PR_RunError ("break statement");
 596 }
 597
 598 /*
 599 =================
 600 PF_traceline
 601
 602 Used for use tracing and shot targeting
 603 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
 604 if the tryents flag is set.
 605
 606 traceline (vector1, vector2, tryents)
 607 =================
 608 */
 609 void PF_traceline (void)
 610 {
 611         float   *v1, *v2;
 612         trace_t trace;
 613         int             nomonsters;
 614         edict_t *ent;
 615
 616         v1 = G_VECTOR(OFS_PARM0);
 617         v2 = G_VECTOR(OFS_PARM1);
 618         nomonsters = G_FLOAT(OFS_PARM2);
 619         ent = G_EDICT(OFS_PARM3);
 620
 621         trace = SV_Move (v1, vec3_origin, vec3_origin, v2, nomonsters, ent);
 622
 623         pr_global_struct->trace_allsolid = trace.allsolid;
 624         pr_global_struct->trace_startsolid = trace.startsolid;
 625         pr_global_struct->trace_fraction = trace.fraction;
 626         pr_global_struct->trace_inwater = trace.inwater;
 627         pr_global_struct->trace_inopen = trace.inopen;
 628         VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
 629         VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
 630         pr_global_struct->trace_plane_dist =  trace.plane.dist;
 631         if (trace.ent)
 632                 pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
 633         else
 634                 pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
 635 }
 636
 637
 638 #ifdef QUAKE2
 639 extern trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore);
 640
 641 void PF_TraceToss (void)
 642 {
 643         trace_t trace;
 644         edict_t *ent;
 645         edict_t *ignore;
 646
 647         ent = G_EDICT(OFS_PARM0);
 648         ignore = G_EDICT(OFS_PARM1);
 649
 650         trace = SV_Trace_Toss (ent, ignore);
 651
 652         pr_global_struct->trace_allsolid = trace.allsolid;
 653         pr_global_struct->trace_startsolid = trace.startsolid;
 654         pr_global_struct->trace_fraction = trace.fraction;
 655         pr_global_struct->trace_inwater = trace.inwater;
 656         pr_global_struct->trace_inopen = trace.inopen;
 657         VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
 658         VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
 659         pr_global_struct->trace_plane_dist =  trace.plane.dist;
 660         if (trace.ent)
 661                 pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
 662         else
 663                 pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
 664 }
 665 #endif
 666
 667
 668 /*
 669 =================
 670 PF_checkpos
 671
 672 Returns true if the given entity can move to the given position from it's
 673 current position by walking or rolling.
 674 FIXME: make work...
 675 scalar checkpos (entity, vector)
 676 =================
 677 */
 678 void PF_checkpos (void)
 679 {
 680 }
 681
 682 //============================================================================
 683
 684 byte    checkpvs[MAX_MAP_LEAFS/8];
 685
 686 int PF_newcheckclient (int check)
 687 {
 688         int             i;
 689         byte    *pvs;
 690         edict_t *ent;
 691         mleaf_t *leaf;
 692         vec3_t  org;
 693
 694 // cycle to the next one
 695
 696         if (check < 1)
 697                 check = 1;
 698         if (check > svs.maxclients)
 699                 check = svs.maxclients;
 700
 701         if (check == svs.maxclients)
 702                 i = 1;
 703         else
 704                 i = check + 1;
 705
 706         for ( ;  ; i++)
 707         {
 708                 if (i == svs.maxclients+1)
 709                         i = 1;
 710
 711                 ent = EDICT_NUM(i);
 712
 713                 if (i == check)
 714                         break;  // didn't find anything else
 715
 716                 if (ent->free)
 717                         continue;
 718                 if (ent->v.health <= 0)
 719                         continue;
 720                 if ((int)ent->v.flags & FL_NOTARGET)
 721                         continue;
 722
 723         // anything that is a client, or has a client as an enemy
 724                 break;
 725         }
 726
 727 // get the PVS for the entity
 728         VectorAdd (ent->v.origin, ent->v.view_ofs, org);
 729         leaf = Mod_PointInLeaf (org, sv.worldmodel);
 730         pvs = Mod_LeafPVS (leaf, sv.worldmodel);
 731         memcpy (checkpvs, pvs, (sv.worldmodel->numleafs+7)>>3 );
 732
 733         return i;
 734 }
 735
 736 /*
 737 =================
 738 PF_checkclient
 739
 740 Returns a client (or object that has a client enemy) that would be a
 741 valid target.
 742
 743 If there are more than one valid options, they are cycled each frame
 744
 745 If (self.origin + self.viewofs) is not in the PVS of the current target,
 746 it is not returned at all.
 747
 748 name checkclient ()
 749 =================
 750 */
 751 #define MAX_CHECK       16
 752 int c_invis, c_notvis;
 753 void PF_checkclient (void)
 754 {
 755         edict_t *ent, *self;
 756         mleaf_t *leaf;
 757         int             l;
 758         vec3_t  view;
 759
 760 // find a new check if on a new frame
 761         if (sv.time - sv.lastchecktime >= 0.1)
 762         {
 763                 sv.lastcheck = PF_newcheckclient (sv.lastcheck);
 764                 sv.lastchecktime = sv.time;
 765         }
 766
 767 // return check if it might be visible
 768         ent = EDICT_NUM(sv.lastcheck);
 769         if (ent->free || ent->v.health <= 0)
 770         {
 771                 RETURN_EDICT(sv.edicts);
 772                 return;
 773         }
 774
 775 // if current entity can't possibly see the check entity, return 0
 776         self = PROG_TO_EDICT(pr_global_struct->self);
 777         VectorAdd (self->v.origin, self->v.view_ofs, view);
 778         leaf = Mod_PointInLeaf (view, sv.worldmodel);
 779         l = (leaf - sv.worldmodel->leafs) - 1;
 780         if ( (l<0) || !(checkpvs[l>>3] & (1<<(l&7)) ) )
 781         {
 782 c_notvis++;
 783                 RETURN_EDICT(sv.edicts);
 784                 return;
 785         }
 786
 787 // might be able to see it
 788 c_invis++;
 789         RETURN_EDICT(ent);
 790 }
 791
 792 //============================================================================
 793
 794
 795 /*
 796 =================
 797 PF_stuffcmd
 798
 799 Sends text over to the client's execution buffer
 800
 801 stuffcmd (clientent, value)
 802 =================
 803 */
 804 void PF_stuffcmd (void)
 805 {
 806         int             entnum;
 807         char    *str;
 808         client_t        *old;
 809
 810         entnum = G_EDICTNUM(OFS_PARM0);
 811         if (entnum < 1 || entnum > svs.maxclients)
 812                 PR_RunError ("Parm 0 not a client");
 813         str = G_STRING(OFS_PARM1);
 814
 815         old = host_client;
 816         host_client = &svs.clients[entnum-1];
 817         Host_ClientCommands ("%s", str);
 818         host_client = old;
 819 }
 820
 821 /*
 822 =================
 823 PF_localcmd
 824
 825 Sends text over to the client's execution buffer
 826
 827 localcmd (string)
 828 =================
 829 */
 830 void PF_localcmd (void)
 831 {
 832         char    *str;
 833
 834         str = G_STRING(OFS_PARM0);
 835         Cbuf_AddText (str);
 836 }
 837
 838 /*
 839 =================
 840 PF_cvar
 841
 842 float cvar (string)
 843 =================
 844 */
 845 void PF_cvar (void)
 846 {
 847         char    *str;
 848
 849         str = G_STRING(OFS_PARM0);
 850
 851         G_FLOAT(OFS_RETURN) = Cvar_VariableValue (str);
 852 }
 853
 854 /*
 855 =================
 856 PF_cvar_set
 857
 858 float cvar (string)
 859 =================
 860 */
 861 void PF_cvar_set (void)
 862 {
 863         char    *var, *val;
 864
 865         var = G_STRING(OFS_PARM0);
 866         val = G_STRING(OFS_PARM1);
 867
 868         Cvar_Set (var, val);
 869 }
 870
 871 /*
 872 =================
 873 PF_findradius
 874
 875 Returns a chain of entities that have origins within a spherical area
 876
 877 findradius (origin, radius)
 878 =================
 879 */
 880 void PF_findradius (void)
 881 {
 882         edict_t *ent, *chain;
 883         float   rad;
 884         float   *org;
 885         vec3_t  eorg;
 886         int             i, j;
 887
 888         chain = (edict_t *)sv.edicts;
 889
 890         org = G_VECTOR(OFS_PARM0);
 891         rad = G_FLOAT(OFS_PARM1);
 892
 893         ent = NEXT_EDICT(sv.edicts);
 894         for (i=1 ; i<sv.num_edicts ; i++, ent = NEXT_EDICT(ent))
 895         {
 896                 if (ent->free)
 897                         continue;
 898                 if (ent->v.solid == SOLID_NOT)
 899                         continue;
 900                 for (j=0 ; j<3 ; j++)
 901                         eorg[j] = org[j] - (ent->v.origin[j] + (ent->v.mins[j] + ent->v.maxs[j])*0.5);
 902                 if (Length(eorg) > rad)
 903                         continue;
 904
 905                 ent->v.chain = EDICT_TO_PROG(chain);
 906                 chain = ent;
 907         }
 908
 909         RETURN_EDICT(chain);
 910 }
 911
 912
 913 /*
 914 =========
 915 PF_dprint
 916 =========
 917 */
 918 void PF_dprint (void)
 919 {
 920         Con_DPrintf ("%s",PF_VarString(0));
 921 }
 922
 923 char    pr_string_temp[128];
 924
 925 void PF_ftos (void)
 926 {
 927         float   v;
 928         v = G_FLOAT(OFS_PARM0);
 929
 930         if (v == (int)v)
 931                 sprintf (pr_string_temp, "%d",(int)v);
 932         else
 933                 sprintf (pr_string_temp, "%5.1f",v);
 934         G_INT(OFS_RETURN) = pr_string_temp - pr_strings;
 935 }
 936
 937 void PF_fabs (void)
 938 {
 939         float   v;
 940         v = G_FLOAT(OFS_PARM0);
 941         G_FLOAT(OFS_RETURN) = fabs(v);
 942 }
 943
 944 void PF_vtos (void)
 945 {
 946         sprintf (pr_string_temp, "'%5.1f %5.1f %5.1f'", G_VECTOR(OFS_PARM0)[0], G_VECTOR(OFS_PARM0)[1], G_VECTOR(OFS_PARM0)[2]);
 947         G_INT(OFS_RETURN) = pr_string_temp - pr_strings;
 948 }
 949
 950 #ifdef QUAKE2
 951 void PF_etos (void)
 952 {
 953         sprintf (pr_string_temp, "entity %i", G_EDICTNUM(OFS_PARM0));
 954         G_INT(OFS_RETURN) = pr_string_temp - pr_strings;
 955 }
 956 #endif
 957
 958 void PF_Spawn (void)
 959 {
 960         edict_t *ed;
 961         ed = ED_Alloc();
 962         RETURN_EDICT(ed);
 963 }
 964
 965 void PF_Remove (void)
 966 {
 967         edict_t *ed;
 968
 969         ed = G_EDICT(OFS_PARM0);
 970         ED_Free (ed);
 971 }
 972
 973
 974 // entity (entity start, .string field, string match) find = #5;
 975 void PF_Find (void)
 976 #ifdef QUAKE2
 977 {
 978         int             e;
 979         int             f;
 980         char    *s, *t;
 981         edict_t *ed;
 982         edict_t *first;
 983         edict_t *second;
 984         edict_t *last;
 985
 986         first = second = last = (edict_t *)sv.edicts;
 987         e = G_EDICTNUM(OFS_PARM0);
 988         f = G_INT(OFS_PARM1);
 989         s = G_STRING(OFS_PARM2);
 990         if (!s)
 991                 PR_RunError ("PF_Find: bad search string");
 992
 993         for (e++ ; e < sv.num_edicts ; e++)
 994         {
 995                 ed = EDICT_NUM(e);
 996                 if (ed->free)
 997                         continue;
 998                 t = E_STRING(ed,f);
 999                 if (!t)
1000                         continue;
1001                 if (!strcmp(t,s))
1002                 {
1003                         if (first == (edict_t *)sv.edicts)
1004                                 first = ed;
1005                         else if (second == (edict_t *)sv.edicts)
1006                                 second = ed;
1007                         ed->v.chain = EDICT_TO_PROG(last);
1008                         last = ed;
1009                 }
1010         }
1011
1012         if (first != last)
1013         {
1014                 if (last != second)
1015                         first->v.chain = last->v.chain;
1016                 else
1017                         first->v.chain = EDICT_TO_PROG(last);
1018                 last->v.chain = EDICT_TO_PROG((edict_t *)sv.edicts);
1019                 if (second && second != last)
1020                         second->v.chain = EDICT_TO_PROG(last);
1021         }
1022         RETURN_EDICT(first);
1023 }
1024 #else
1025 {
1026         int             e;
1027         int             f;
1028         char    *s, *t;
1029         edict_t *ed;
1030
1031         e = G_EDICTNUM(OFS_PARM0);
1032         f = G_INT(OFS_PARM1);
1033         s = G_STRING(OFS_PARM2);
1034         if (!s)
1035                 PR_RunError ("PF_Find: bad search string");
1036
1037         for (e++ ; e < sv.num_edicts ; e++)
1038         {
1039                 ed = EDICT_NUM(e);
1040                 if (ed->free)
1041                         continue;
1042                 t = E_STRING(ed,f);
1043                 if (!t)
1044                         continue;
1045                 if (!strcmp(t,s))
1046                 {
1047                         RETURN_EDICT(ed);
1048                         return;
1049                 }
1050         }
1051
1052         RETURN_EDICT(sv.edicts);
1053 }
1054 #endif
1055
1056 void PR_CheckEmptyString (char *s)
1057 {
1058         if (s[0] <= ' ')
1059                 PR_RunError ("Bad string");
1060 }
1061
1062 void PF_precache_file (void)
1063 {       // precache_file is only used to copy files with qcc, it does nothing
1064         G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
1065 }
1066
1067 void PF_precache_sound (void)
1068 {
1069         char    *s;
1070         int             i;
1071
1072         if (sv.state != ss_loading)
1073                 PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");
1074
1075         s = G_STRING(OFS_PARM0);
1076         G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
1077         PR_CheckEmptyString (s);
1078
1079         for (i=0 ; i<MAX_SOUNDS ; i++)
1080         {
1081                 if (!sv.sound_precache[i])
1082                 {
1083                         sv.sound_precache[i] = s;
1084                         return;
1085                 }
1086                 if (!strcmp(sv.sound_precache[i], s))
1087                         return;
1088         }
1089         PR_RunError ("PF_precache_sound: overflow");
1090 }
1091
1092 void PF_precache_model (void)
1093 {
1094         char    *s;
1095         int             i;
1096
1097         if (sv.state != ss_loading)
1098                 PR_RunError ("PF_Precache_*: Precache can only be done in spawn functions");
1099
1100         s = G_STRING(OFS_PARM0);
1101         G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
1102         PR_CheckEmptyString (s);
1103
1104         for (i=0 ; i<MAX_MODELS ; i++)
1105         {
1106                 if (!sv.model_precache[i])
1107                 {
1108                         sv.model_precache[i] = s;
1109                         sv.models[i] = Mod_ForName (s, true);
1110                         return;
1111                 }
1112                 if (!strcmp(sv.model_precache[i], s))
1113                         return;
1114         }
1115         PR_RunError ("PF_precache_model: overflow");
1116 }
1117
1118
1119 void PF_coredump (void)
1120 {
1121         ED_PrintEdicts ();
1122 }
1123
1124 void PF_traceon (void)
1125 {
1126         pr_trace = true;
1127 }
1128
1129 void PF_traceoff (void)
1130 {
1131         pr_trace = false;
1132 }
1133
1134 void PF_eprint (void)
1135 {
1136         ED_PrintNum (G_EDICTNUM(OFS_PARM0));
1137 }
1138
1139 /*
1140 ===============
1141 PF_walkmove
1142
1143 float(float yaw, float dist) walkmove
1144 ===============
1145 */
1146 void PF_walkmove (void)
1147 {
1148         edict_t *ent;
1149         float   yaw, dist;
1150         vec3_t  move;
1151         dfunction_t     *oldf;
1152         int     oldself;
1153
1154         ent = PROG_TO_EDICT(pr_global_struct->self);
1155         yaw = G_FLOAT(OFS_PARM0);
1156         dist = G_FLOAT(OFS_PARM1);
1157
1158         if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
1159         {
1160                 G_FLOAT(OFS_RETURN) = 0;
1161                 return;
1162         }
1163
1164         yaw = yaw*M_PI*2 / 360;
1165
1166         move[0] = cos(yaw)*dist;
1167         move[1] = sin(yaw)*dist;
1168         move[2] = 0;
1169
1170 // save program state, because SV_movestep may call other progs
1171         oldf = pr_xfunction;
1172         oldself = pr_global_struct->self;
1173
1174         G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true);
1175
1176
1177 // restore program state
1178         pr_xfunction = oldf;
1179         pr_global_struct->self = oldself;
1180 }
1181
1182 /*
1183 ===============
1184 PF_droptofloor
1185
1186 void() droptofloor
1187 ===============
1188 */
1189 void PF_droptofloor (void)
1190 {
1191         edict_t         *ent;
1192         vec3_t          end;
1193         trace_t         trace;
1194
1195         ent = PROG_TO_EDICT(pr_global_struct->self);
1196
1197         VectorCopy (ent->v.origin, end);
1198         end[2] -= 256;
1199
1200         trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, end, false, ent);
1201
1202         if (trace.fraction == 1 || trace.allsolid)
1203                 G_FLOAT(OFS_RETURN) = 0;
1204         else
1205         {
1206                 VectorCopy (trace.endpos, ent->v.origin);
1207                 SV_LinkEdict (ent, false);
1208                 ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
1209                 ent->v.groundentity = EDICT_TO_PROG(trace.ent);
1210                 G_FLOAT(OFS_RETURN) = 1;
1211         }
1212 }
1213
1214 /*
1215 ===============
1216 PF_lightstyle
1217
1218 void(float style, string value) lightstyle
1219 ===============
1220 */
1221 void PF_lightstyle (void)
1222 {
1223         int             style;
1224         char    *val;
1225         client_t        *client;
1226         int                     j;
1227
1228         style = G_FLOAT(OFS_PARM0);
1229         val = G_STRING(OFS_PARM1);
1230
1231 // change the string in sv
1232         sv.lightstyles[style] = val;
1233
1234 // send message to all clients on this server
1235         if (sv.state != ss_active)
1236                 return;
1237
1238         for (j=0, client = svs.clients ; j<svs.maxclients ; j++, client++)
1239                 if (client->active || client->spawned)
1240                 {
1241                         MSG_WriteChar (&client->message, svc_lightstyle);
1242                         MSG_WriteChar (&client->message,style);
1243                         MSG_WriteString (&client->message, val);
1244                 }
1245 }
1246
1247 void PF_rint (void)
1248 {
1249         float   f;
1250         f = G_FLOAT(OFS_PARM0);
1251         if (f > 0)
1252                 G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
1253         else
1254                 G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
1255 }
1256 void PF_floor (void)
1257 {
1258         G_FLOAT(OFS_RETURN) = floor(G_FLOAT(OFS_PARM0));
1259 }
1260 void PF_ceil (void)
1261 {
1262         G_FLOAT(OFS_RETURN) = ceil(G_FLOAT(OFS_PARM0));
1263 }
1264
1265
1266 /*
1267 =============
1268 PF_checkbottom
1269 =============
1270 */
1271 void PF_checkbottom (void)
1272 {
1273         edict_t *ent;
1274
1275         ent = G_EDICT(OFS_PARM0);
1276
1277         G_FLOAT(OFS_RETURN) = SV_CheckBottom (ent);
1278 }
1279
1280 /*
1281 =============
1282 PF_pointcontents
1283 =============
1284 */
1285 void PF_pointcontents (void)
1286 {
1287         float   *v;
1288
1289         v = G_VECTOR(OFS_PARM0);
1290
1291         G_FLOAT(OFS_RETURN) = SV_PointContents (v);
1292 }
1293
1294 /*
1295 =============
1296 PF_nextent
1297
1298 entity nextent(entity)
1299 =============
1300 */
1301 void PF_nextent (void)
1302 {
1303         int             i;
1304         edict_t *ent;
1305
1306         i = G_EDICTNUM(OFS_PARM0);
1307         while (1)
1308         {
1309                 i++;
1310                 if (i == sv.num_edicts)
1311                 {
1312                         RETURN_EDICT(sv.edicts);
1313                         return;
1314                 }
1315                 ent = EDICT_NUM(i);
1316                 if (!ent->free)
1317                 {
1318                         RETURN_EDICT(ent);
1319                         return;
1320                 }
1321         }
1322 }
1323
1324 /*
1325 =============
1326 PF_aim
1327
1328 Pick a vector for the player to shoot along
1329 vector aim(entity, missilespeed)
1330 =============
1331 */
1332 cvar_t  sv_aim = {"sv_aim", "0.93"};
1333 void PF_aim (void)
1334 {
1335         edict_t *ent, *check, *bestent;
1336         vec3_t  start, dir, end, bestdir;
1337         int             i, j;
1338         trace_t tr;
1339         float   dist, bestdist;
1340
1341         ent = G_EDICT(OFS_PARM0);
1342
1343         VectorCopy (ent->v.origin, start);
1344         start[2] += 20;
1345
1346 // try sending a trace straight
1347         VectorCopy (pr_global_struct->v_forward, dir);
1348         VectorMA (start, 2048, dir, end);
1349         tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent);
1350         if (tr.ent && tr.ent->v.takedamage == DAMAGE_AIM
1351         && (!teamplay.value || ent->v.team <=0 || ent->v.team != tr.ent->v.team) )
1352         {
1353                 VectorCopy (pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
1354                 return;
1355         }
1356
1357
1358 // try all possible entities
1359         VectorCopy (dir, bestdir);
1360         bestdist = sv_aim.value;
1361         bestent = NULL;
1362
1363         check = NEXT_EDICT(sv.edicts);
1364         for (i=1 ; i<sv.num_edicts ; i++, check = NEXT_EDICT(check) )
1365         {
1366                 if (check->v.takedamage != DAMAGE_AIM)
1367                         continue;
1368                 if (check == ent)
1369                         continue;
1370                 if (teamplay.value && ent->v.team > 0 && ent->v.team == check->v.team)
1371                         continue;       // don't aim at teammate
1372                 for (j=0 ; j<3 ; j++)
1373                         end[j] = check->v.origin[j]
1374                         + 0.5*(check->v.mins[j] + check->v.maxs[j]);
1375                 VectorSubtract (end, start, dir);
1376                 VectorNormalize (dir);
1377                 dist = DotProduct (dir, pr_global_struct->v_forward);
1378                 if (dist < bestdist)
1379                         continue;       // to far to turn
1380                 tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent);
1381                 if (tr.ent == check)
1382                 {       // can shoot at this one
1383                         bestdist = dist;
1384                         bestent = check;
1385                 }
1386         }
1387
1388         if (bestent)
1389         {
1390                 VectorSubtract (bestent->v.origin, ent->v.origin, dir);
1391                 dist = DotProduct (dir, pr_global_struct->v_forward);
1392                 VectorScale (pr_global_struct->v_forward, dist, end);
1393                 end[2] = dir[2];
1394                 VectorNormalize (end);
1395                 VectorCopy (end, G_VECTOR(OFS_RETURN));
1396         }
1397         else
1398         {
1399                 VectorCopy (bestdir, G_VECTOR(OFS_RETURN));
1400         }
1401 }
1402
1403 /*
1404 ==============
1405 PF_changeyaw
1406
1407 This was a major timewaster in progs, so it was converted to C
1408 ==============
1409 */
1410 void PF_changeyaw (void)
1411 {
1412         edict_t         *ent;
1413         float           ideal, current, move, speed;
1414
1415         ent = PROG_TO_EDICT(pr_global_struct->self);
1416         current = anglemod( ent->v.angles[1] );
1417         ideal = ent->v.ideal_yaw;
1418         speed = ent->v.yaw_speed;
1419
1420         if (current == ideal)
1421                 return;
1422         move = ideal - current;
1423         if (ideal > current)
1424         {
1425                 if (move >= 180)
1426                         move = move - 360;
1427         }
1428         else
1429         {
1430                 if (move <= -180)
1431                         move = move + 360;
1432         }
1433         if (move > 0)
1434         {
1435                 if (move > speed)
1436                         move = speed;
1437         }
1438         else
1439         {
1440                 if (move < -speed)
1441                         move = -speed;
1442         }
1443
1444         ent->v.angles[1] = anglemod (current + move);
1445 }
1446
1447 #ifdef QUAKE2
1448 /*
1449 ==============
1450 PF_changepitch
1451 ==============
1452 */
1453 void PF_changepitch (void)
1454 {
1455         edict_t         *ent;
1456         float           ideal, current, move, speed;
1457
1458         ent = G_EDICT(OFS_PARM0);
1459         current = anglemod( ent->v.angles[0] );
1460         ideal = ent->v.idealpitch;
1461         speed = ent->v.pitch_speed;
1462
1463         if (current == ideal)
1464                 return;
1465         move = ideal - current;
1466         if (ideal > current)
1467         {
1468                 if (move >= 180)
1469                         move = move - 360;
1470         }
1471         else
1472         {
1473                 if (move <= -180)
1474                         move = move + 360;
1475         }
1476         if (move > 0)
1477         {
1478                 if (move > speed)
1479                         move = speed;
1480         }
1481         else
1482         {
1483                 if (move < -speed)
1484                         move = -speed;
1485         }
1486
1487         ent->v.angles[0] = anglemod (current + move);
1488 }
1489 #endif
1490
1491 /*
1492 ===============================================================================
1493
1494 MESSAGE WRITING
1495
1496 ===============================================================================
1497 */
1498
1499 #define MSG_BROADCAST   0               // unreliable to all
1500 #define MSG_ONE                 1               // reliable to one (msg_entity)
1501 #define MSG_ALL                 2               // reliable to all
1502 #define MSG_INIT                3               // write to the init string
1503
1504 sizebuf_t *WriteDest (void)
1505 {
1506         int             entnum;
1507         int             dest;
1508         edict_t *ent;
1509
1510         dest = G_FLOAT(OFS_PARM0);
1511         switch (dest)
1512         {
1513         case MSG_BROADCAST:
1514                 return &sv.datagram;
1515
1516         case MSG_ONE:
1517                 ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
1518                 entnum = NUM_FOR_EDICT(ent);
1519                 if (entnum < 1 || entnum > svs.maxclients)
1520                         PR_RunError ("WriteDest: not a client");
1521                 return &svs.clients[entnum-1].message;
1522
1523         case MSG_ALL:
1524                 return &sv.reliable_datagram;
1525
1526         case MSG_INIT:
1527                 return &sv.signon;
1528
1529         default:
1530                 PR_RunError ("WriteDest: bad destination");
1531                 break;
1532         }
1533
1534         return NULL;
1535 }
1536
1537 void PF_WriteByte (void)
1538 {
1539         MSG_WriteByte (WriteDest(), G_FLOAT(OFS_PARM1));
1540 }
1541
1542 void PF_WriteChar (void)
1543 {
1544         MSG_WriteChar (WriteDest(), G_FLOAT(OFS_PARM1));
1545 }
1546
1547 void PF_WriteShort (void)
1548 {
1549         MSG_WriteShort (WriteDest(), G_FLOAT(OFS_PARM1));
1550 }
1551
1552 void PF_WriteLong (void)
1553 {
1554         MSG_WriteLong (WriteDest(), G_FLOAT(OFS_PARM1));
1555 }
1556
1557 void PF_WriteAngle (void)
1558 {
1559         MSG_WriteAngle (WriteDest(), G_FLOAT(OFS_PARM1));
1560 }
1561
1562 void PF_WriteCoord (void)
1563 {
1564         MSG_WriteCoord (WriteDest(), G_FLOAT(OFS_PARM1));
1565 }
1566
1567 void PF_WriteString (void)
1568 {
1569         MSG_WriteString (WriteDest(), G_STRING(OFS_PARM1));
1570 }
1571
1572
1573 void PF_WriteEntity (void)
1574 {
1575         MSG_WriteShort (WriteDest(), G_EDICTNUM(OFS_PARM1));
1576 }
1577
1578 //=============================================================================
1579
1580 int SV_ModelIndex (char *name);
1581
1582 void PF_makestatic (void)
1583 {
1584         edict_t *ent;
1585         int             i;
1586
1587         ent = G_EDICT(OFS_PARM0);
1588
1589         MSG_WriteByte (&sv.signon,svc_spawnstatic);
1590
1591         MSG_WriteByte (&sv.signon, SV_ModelIndex(pr_strings + ent->v.model));
1592
1593         MSG_WriteByte (&sv.signon, ent->v.frame);
1594         MSG_WriteByte (&sv.signon, ent->v.colormap);
1595         MSG_WriteByte (&sv.signon, ent->v.skin);
1596         for (i=0 ; i<3 ; i++)
1597         {
1598                 MSG_WriteCoord(&sv.signon, ent->v.origin[i]);
1599                 MSG_WriteAngle(&sv.signon, ent->v.angles[i]);
1600         }
1601
1602 // throw the entity away now
1603         ED_Free (ent);
1604 }
1605
1606 //=============================================================================
1607
1608 /*
1609 ==============
1610 PF_setspawnparms
1611 ==============
1612 */
1613 void PF_setspawnparms (void)
1614 {
1615         edict_t *ent;
1616         int             i;
1617         client_t        *client;
1618
1619         ent = G_EDICT(OFS_PARM0);
1620         i = NUM_FOR_EDICT(ent);
1621         if (i < 1 || i > svs.maxclients)
1622                 PR_RunError ("Entity is not a client");
1623
1624         // copy spawn parms out of the client_t
1625         client = svs.clients + (i-1);
1626
1627         for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
1628                 (&pr_global_struct->parm1)[i] = client->spawn_parms[i];
1629 }
1630
1631 /*
1632 ==============
1633 PF_changelevel
1634 ==============
1635 */
1636 void PF_changelevel (void)
1637 {
1638 #ifdef QUAKE2
1639         char    *s1, *s2;
1640
1641         if (svs.changelevel_issued)
1642                 return;
1643         svs.changelevel_issued = true;
1644
1645         s1 = G_STRING(OFS_PARM0);
1646         s2 = G_STRING(OFS_PARM1);
1647
1648         if ((int)pr_global_struct->serverflags & (SFL_NEW_UNIT | SFL_NEW_EPISODE))
1649                 Cbuf_AddText (va("changelevel %s %s\n",s1, s2));
1650         else
1651                 Cbuf_AddText (va("changelevel2 %s %s\n",s1, s2));
1652 #else
1653         char    *s;
1654
1655 // make sure we don't issue two changelevels
1656         if (svs.changelevel_issued)
1657                 return;
1658         svs.changelevel_issued = true;
1659
1660         s = G_STRING(OFS_PARM0);
1661         Cbuf_AddText (va("changelevel %s\n",s));
1662 #endif
1663 }
1664
1665
1666 #ifdef QUAKE2
1667
1668 #define CONTENT_WATER   -3
1669 #define CONTENT_SLIME   -4
1670 #define CONTENT_LAVA    -5
1671
1672 #define FL_IMMUNE_WATER 131072
1673 #define FL_IMMUNE_SLIME 262144
1674 #define FL_IMMUNE_LAVA  524288
1675
1676 #define CHAN_VOICE      2
1677 #define CHAN_BODY       4
1678
1679 #define ATTN_NORM       1
1680
1681 void PF_WaterMove (void)
1682 {
1683         edict_t         *self;
1684         int                     flags;
1685         int                     waterlevel;
1686         int                     watertype;
1687         float           drownlevel;
1688         float           damage = 0.0;
1689
1690         self = PROG_TO_EDICT(pr_global_struct->self);
1691
1692         if (self->v.movetype == MOVETYPE_NOCLIP)
1693         {
1694                 self->v.air_finished = sv.time + 12;
1695                 G_FLOAT(OFS_RETURN) = damage;
1696                 return;
1697         }
1698
1699         if (self->v.health < 0)
1700         {
1701                 G_FLOAT(OFS_RETURN) = damage;
1702                 return;
1703         }
1704
1705         if (self->v.deadflag == DEAD_NO)
1706                 drownlevel = 3;
1707         else
1708                 drownlevel = 1;
1709
1710         flags = (int)self->v.flags;
1711         waterlevel = (int)self->v.waterlevel;
1712         watertype = (int)self->v.watertype;
1713
1714         if (!(flags & (FL_IMMUNE_WATER + FL_GODMODE)))
1715                 if (((flags & FL_SWIM) && (waterlevel < drownlevel)) || (waterlevel >= drownlevel))
1716                 {
1717                         if (self->v.air_finished < sv.time)
1718                                 if (self->v.pain_finished < sv.time)
1719                                 {
1720                                         self->v.dmg = self->v.dmg + 2;
1721                                         if (self->v.dmg > 15)
1722                                                 self->v.dmg = 10;
1723 //                                      T_Damage (self, world, world, self.dmg, 0, FALSE);
1724                                         damage = self->v.dmg;
1725                                         self->v.pain_finished = sv.time + 1.0;
1726                                 }
1727                 }
1728                 else
1729                 {
1730                         if (self->v.air_finished < sv.time)
1731 //                              sound (self, CHAN_VOICE, "player/gasp2.wav", 1, ATTN_NORM);
1732                                 SV_StartSound (self, CHAN_VOICE, "player/gasp2.wav", 255, ATTN_NORM);
1733                         else if (self->v.air_finished < sv.time + 9)
1734 //                              sound (self, CHAN_VOICE, "player/gasp1.wav", 1, ATTN_NORM);
1735                                 SV_StartSound (self, CHAN_VOICE, "player/gasp1.wav", 255, ATTN_NORM);
1736                         self->v.air_finished = sv.time + 12.0;
1737                         self->v.dmg = 2;
1738                 }
1739
1740         if (!waterlevel)
1741         {
1742                 if (flags & FL_INWATER)
1743                 {
1744                         // play leave water sound
1745 //                      sound (self, CHAN_BODY, "misc/outwater.wav", 1, ATTN_NORM);
1746                         SV_StartSound (self, CHAN_BODY, "misc/outwater.wav", 255, ATTN_NORM);
1747                         self->v.flags = (float)(flags &~FL_INWATER);
1748                 }
1749                 self->v.air_finished = sv.time + 12.0;
1750                 G_FLOAT(OFS_RETURN) = damage;
1751                 return;
1752         }
1753
1754         if (watertype == CONTENT_LAVA)
1755         {       // do damage
1756                 if (!(flags & (FL_IMMUNE_LAVA + FL_GODMODE)))
1757                         if (self->v.dmgtime < sv.time)
1758                         {
1759                                 if (self->v.radsuit_finished < sv.time)
1760                                         self->v.dmgtime = sv.time + 0.2;
1761                                 else
1762                                         self->v.dmgtime = sv.time + 1.0;
1763 //                              T_Damage (self, world, world, 10*self.waterlevel, 0, TRUE);
1764                                 damage = (float)(10*waterlevel);
1765                         }
1766         }
1767         else if (watertype == CONTENT_SLIME)
1768         {       // do damage
1769                 if (!(flags & (FL_IMMUNE_SLIME + FL_GODMODE)))
1770                         if (self->v.dmgtime < sv.time && self->v.radsuit_finished < sv.time)
1771                         {
1772                                 self->v.dmgtime = sv.time + 1.0;
1773 //                              T_Damage (self, world, world, 4*self.waterlevel, 0, TRUE);
1774                                 damage = (float)(4*waterlevel);
1775                         }
1776         }
1777
1778         if ( !(flags & FL_INWATER) )
1779         {
1780
1781 // player enter water sound
1782                 if (watertype == CONTENT_LAVA)
1783 //                      sound (self, CHAN_BODY, "player/inlava.wav", 1, ATTN_NORM);
1784                         SV_StartSound (self, CHAN_BODY, "player/inlava.wav", 255, ATTN_NORM);
1785                 if (watertype == CONTENT_WATER)
1786 //                      sound (self, CHAN_BODY, "player/inh2o.wav", 1, ATTN_NORM);
1787                         SV_StartSound (self, CHAN_BODY, "player/inh2o.wav", 255, ATTN_NORM);
1788                 if (watertype == CONTENT_SLIME)
1789 //                      sound (self, CHAN_BODY, "player/slimbrn2.wav", 1, ATTN_NORM);
1790                         SV_StartSound (self, CHAN_BODY, "player/slimbrn2.wav", 255, ATTN_NORM);
1791
1792                 self->v.flags = (float)(flags | FL_INWATER);
1793                 self->v.dmgtime = 0;
1794         }
1795
1796         if (! (flags & FL_WATERJUMP) )
1797         {
1798 //              self.velocity = self.velocity - 0.8*self.waterlevel*frametime*self.velocity;
1799                 VectorMA (self->v.velocity, -0.8 * self->v.waterlevel * host_frametime, self->v.velocity, self->v.velocity);
1800         }
1801
1802         G_FLOAT(OFS_RETURN) = damage;
1803 }
1804
1805
1806 void PF_sin (void)
1807 {
1808         G_FLOAT(OFS_RETURN) = sin(G_FLOAT(OFS_PARM0));
1809 }
1810
1811 void PF_cos (void)
1812 {
1813         G_FLOAT(OFS_RETURN) = cos(G_FLOAT(OFS_PARM0));
1814 }
1815
1816 void PF_sqrt (void)
1817 {
1818         G_FLOAT(OFS_RETURN) = sqrt(G_FLOAT(OFS_PARM0));
1819 }
1820 #endif
1821
1822 void PF_Fixme (void)
1823 {
1824         PR_RunError ("unimplemented bulitin");
1825 }
1826
1827
1828
1829 builtin_t pr_builtin[] =
1830 {
1831 PF_Fixme,
1832 PF_makevectors, // void(entity e)       makevectors             = #1;
1833 PF_setorigin,   // void(entity e, vector o) setorigin   = #2;
1834 PF_setmodel,    // void(entity e, string m) setmodel    = #3;
1835 PF_setsize,     // void(entity e, vector min, vector max) setsize = #4;
1836 PF_Fixme,       // void(entity e, vector min, vector max) setabssize = #5;
1837 PF_break,       // void() break                                         = #6;
1838 PF_random,      // float() random                                               = #7;
1839 PF_sound,       // void(entity e, float chan, string samp) sound = #8;
1840 PF_normalize,   // vector(vector v) normalize                   = #9;
1841 PF_error,       // void(string e) error                         = #10;
1842 PF_objerror,    // void(string e) objerror                              = #11;
1843 PF_vlen,        // float(vector v) vlen                         = #12;
1844 PF_vectoyaw,    // float(vector v) vectoyaw             = #13;
1845 PF_Spawn,       // entity() spawn                                               = #14;
1846 PF_Remove,      // void(entity e) remove                                = #15;
1847 PF_traceline,   // float(vector v1, vector v2, float tryents) traceline = #16;
1848 PF_checkclient, // entity() clientlist                                  = #17;
1849 PF_Find,        // entity(entity start, .string fld, string match) find = #18;
1850 PF_precache_sound,      // void(string s) precache_sound                = #19;
1851 PF_precache_model,      // void(string s) precache_model                = #20;
1852 PF_stuffcmd,    // void(entity client, string s)stuffcmd = #21;
1853 PF_findradius,  // entity(vector org, float rad) findradius = #22;
1854 PF_bprint,      // void(string s) bprint                                = #23;
1855 PF_sprint,      // void(entity client, string s) sprint = #24;
1856 PF_dprint,      // void(string s) dprint                                = #25;
1857 PF_ftos,        // void(string s) ftos                          = #26;
1858 PF_vtos,        // void(string s) vtos                          = #27;
1859 PF_coredump,
1860 PF_traceon,
1861 PF_traceoff,
1862 PF_eprint,      // void(entity e) debug print an entire entity
1863 PF_walkmove, // float(float yaw, float dist) walkmove
1864 PF_Fixme, // float(float yaw, float dist) walkmove
1865 PF_droptofloor,
1866 PF_lightstyle,
1867 PF_rint,
1868 PF_floor,
1869 PF_ceil,
1870 PF_Fixme,
1871 PF_checkbottom,
1872 PF_pointcontents,
1873 PF_Fixme,
1874 PF_fabs,
1875 PF_aim,
1876 PF_cvar,
1877 PF_localcmd,
1878 PF_nextent,
1879 PF_particle,
1880 PF_changeyaw,
1881 PF_Fixme,
1882 PF_vectoangles,
1883
1884 PF_WriteByte,
1885 PF_WriteChar,
1886 PF_WriteShort,
1887 PF_WriteLong,
1888 PF_WriteCoord,
1889 PF_WriteAngle,
1890 PF_WriteString,
1891 PF_WriteEntity,
1892
1893 #ifdef QUAKE2
1894 PF_sin,
1895 PF_cos,
1896 PF_sqrt,
1897 PF_changepitch,
1898 PF_TraceToss,
1899 PF_etos,
1900 PF_WaterMove,
1901 #else
1902 PF_Fixme,
1903 PF_Fixme,
1904 PF_Fixme,
1905 PF_Fixme,
1906 PF_Fixme,
1907 PF_Fixme,
1908 PF_Fixme,
1909 #endif
1910
1911 SV_MoveToGoal,
1912 PF_precache_file,
1913 PF_makestatic,
1914
1915 PF_changelevel,
1916 PF_Fixme,
1917
1918 PF_cvar_set,
1919 PF_centerprint,
1920
1921 PF_ambientsound,
1922
1923 PF_precache_model,
1924 PF_precache_sound,              // precache_sound2 is different only for qcc
1925 PF_precache_file,
1926
1927 PF_setspawnparms
1928 };
1929
1930 builtin_t *pr_builtins = pr_builtin;
1931 int pr_numbuiltins = sizeof(pr_builtin)/sizeof(pr_builtin[0]);
1932