pr_edict.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 // sv_edict.c -- entity dictionary
  21
  22 #include "quakedef.h"
  23
  24 dprograms_t             *progs;
  25 dfunction_t             *pr_functions;
  26 char                    *pr_strings;
  27 ddef_t                  *pr_fielddefs;
  28 ddef_t                  *pr_globaldefs;
  29 dstatement_t    *pr_statements;
  30 globalvars_t    *pr_global_struct;
  31 float                   *pr_globals;                    // same as pr_global_struct
  32 int                             pr_edict_size;                  // in bytes
  33 int                             pr_edictareasize;               // LordHavoc: in bytes
  34
  35 unsigned short          pr_crc;
  36
  37 int             type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4};
  38
  39 ddef_t *ED_FieldAtOfs (int ofs);
  40 qboolean        ED_ParseEpair (void *base, ddef_t *key, char *s);
  41
  42 cvar_t  nomonsters = {"nomonsters", "0"};
  43 cvar_t  gamecfg = {"gamecfg", "0"};
  44 cvar_t  scratch1 = {"scratch1", "0"};
  45 cvar_t  scratch2 = {"scratch2", "0"};
  46 cvar_t  scratch3 = {"scratch3", "0"};
  47 cvar_t  scratch4 = {"scratch4", "0"};
  48 cvar_t  savedgamecfg = {"savedgamecfg", "0", true};
  49 cvar_t  saved1 = {"saved1", "0", true};
  50 cvar_t  saved2 = {"saved2", "0", true};
  51 cvar_t  saved3 = {"saved3", "0", true};
  52 cvar_t  saved4 = {"saved4", "0", true};
  53 cvar_t  decors = {"decors", "0"};
  54 cvar_t  nehx00 = {"nehx00", "0"};cvar_t nehx01 = {"nehx01", "0"};
  55 cvar_t  nehx02 = {"nehx02", "0"};cvar_t nehx03 = {"nehx03", "0"};
  56 cvar_t  nehx04 = {"nehx04", "0"};cvar_t nehx05 = {"nehx05", "0"};
  57 cvar_t  nehx06 = {"nehx06", "0"};cvar_t nehx07 = {"nehx07", "0"};
  58 cvar_t  nehx08 = {"nehx08", "0"};cvar_t nehx09 = {"nehx09", "0"};
  59 cvar_t  nehx10 = {"nehx10", "0"};cvar_t nehx11 = {"nehx11", "0"};
  60 cvar_t  nehx12 = {"nehx12", "0"};cvar_t nehx13 = {"nehx13", "0"};
  61 cvar_t  nehx14 = {"nehx14", "0"};cvar_t nehx15 = {"nehx15", "0"};
  62 cvar_t  nehx16 = {"nehx16", "0"};cvar_t nehx17 = {"nehx17", "0"};
  63 cvar_t  nehx18 = {"nehx18", "0"};cvar_t nehx19 = {"nehx19", "0"};
  64 cvar_t  cutscene = {"cutscene", "1"};
  65 // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
  66 cvar_t  pr_boundscheck = {"pr_boundscheck", "1"};
  67
  68 #define MAX_FIELD_LEN   64
  69 #define GEFV_CACHESIZE  2
  70
  71 typedef struct {
  72         ddef_t  *pcache;
  73         char    field[MAX_FIELD_LEN];
  74 } gefv_cache;
  75
  76 static gefv_cache       gefvCache[GEFV_CACHESIZE] = {{NULL, ""}, {NULL, ""}};
  77
  78 ddef_t *ED_FindField (char *name);
  79 dfunction_t *ED_FindFunction (char *name);
  80
  81 // LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue...  these are defined as externs in progs.h
  82 int eval_gravity;
  83 int eval_button3;
  84 int eval_button4;
  85 int eval_button5;
  86 int eval_button6;
  87 int eval_button7;
  88 int eval_button8;
  89 int eval_glow_size;
  90 int eval_glow_trail;
  91 int eval_glow_color;
  92 int eval_items2;
  93 int eval_scale;
  94 int eval_alpha;
  95 int eval_fullbright;
  96 int eval_ammo_shells1;
  97 int eval_ammo_nails1;
  98 int eval_ammo_lava_nails;
  99 int eval_ammo_rockets1;
 100 int eval_ammo_multi_rockets;
 101 int eval_ammo_cells1;
 102 int eval_ammo_plasma;
 103 int eval_idealpitch;
 104 int eval_pitch_speed;
 105 int eval_viewmodelforclient;
 106 int eval_nodrawtoclient;
 107 int eval_drawonlytoclient;
 108 int eval_colormod;
 109 int eval_ping;
 110 int eval_movement;
 111 int eval_pmodel;
 112
 113 dfunction_t *SV_PlayerPhysicsQC;
 114 dfunction_t *EndFrameQC;
 115
 116 int FindFieldOffset(char *field)
 117 {
 118         ddef_t *d;
 119         d = ED_FindField(field);
 120         if (!d)
 121                 return 0;
 122         return d->ofs*4;
 123 }
 124
 125 void FindEdictFieldOffsets()
 126 {
 127         eval_gravity = FindFieldOffset("gravity");
 128         eval_button3 = FindFieldOffset("button3");
 129         eval_button4 = FindFieldOffset("button4");
 130         eval_button5 = FindFieldOffset("button5");
 131         eval_button6 = FindFieldOffset("button6");
 132         eval_button7 = FindFieldOffset("button7");
 133         eval_button8 = FindFieldOffset("button8");
 134         eval_glow_size = FindFieldOffset("glow_size");
 135         eval_glow_trail = FindFieldOffset("glow_trail");
 136         eval_glow_color = FindFieldOffset("glow_color");
 137         eval_items2 = FindFieldOffset("items2");
 138         eval_scale = FindFieldOffset("scale");
 139         eval_alpha = FindFieldOffset("alpha");
 140         eval_fullbright = FindFieldOffset("fullbright");
 141         eval_ammo_shells1 = FindFieldOffset("ammo_shells1");
 142         eval_ammo_nails1 = FindFieldOffset("ammo_nails1");
 143         eval_ammo_lava_nails = FindFieldOffset("ammo_lava_nails");
 144         eval_ammo_rockets1 = FindFieldOffset("ammo_rockets1");
 145         eval_ammo_multi_rockets = FindFieldOffset("ammo_multi_rockets");
 146         eval_ammo_cells1 = FindFieldOffset("ammo_cells1");
 147         eval_ammo_plasma = FindFieldOffset("ammo_plasma");
 148         eval_idealpitch = FindFieldOffset("idealpitch");
 149         eval_pitch_speed = FindFieldOffset("pitch_speed");
 150         eval_viewmodelforclient = FindFieldOffset("viewmodelforclient");
 151         eval_nodrawtoclient = FindFieldOffset("nodrawtoclient");
 152         eval_drawonlytoclient = FindFieldOffset("drawonlytoclient");
 153         eval_colormod = FindFieldOffset("colormod");
 154         eval_ping = FindFieldOffset("ping");
 155         eval_movement = FindFieldOffset("movement");
 156         eval_pmodel = FindFieldOffset("pmodel");
 157
 158         // LordHavoc: allowing QuakeC to override the player movement code
 159         SV_PlayerPhysicsQC = ED_FindFunction ("SV_PlayerPhysics");
 160         // LordHavoc: support for endframe
 161         EndFrameQC = ED_FindFunction ("EndFrame");
 162 };
 163
 164 /*
 165 =================
 166 ED_ClearEdict
 167
 168 Sets everything to NULL
 169 =================
 170 */
 171 void ED_ClearEdict (edict_t *e)
 172 {
 173         memset (&e->v, 0, progs->entityfields * 4);
 174         e->free = false;
 175 }
 176
 177 /*
 178 =================
 179 ED_Alloc
 180
 181 Either finds a free edict, or allocates a new one.
 182 Try to avoid reusing an entity that was recently freed, because it
 183 can cause the client to think the entity morphed into something else
 184 instead of being removed and recreated, which can cause interpolated
 185 angles and bad trails.
 186 =================
 187 */
 188 edict_t *ED_Alloc (void)
 189 {
 190         int                     i;
 191         edict_t         *e;
 192
 193         for ( i=svs.maxclients+1 ; i<sv.num_edicts ; i++)
 194         {
 195                 e = EDICT_NUM(i);
 196                 // the first couple seconds of server time can involve a lot of
 197                 // freeing and allocating, so relax the replacement policy
 198                 if (e->free && ( e->freetime < 2 || sv.time - e->freetime > 0.5 ) )
 199                 {
 200                         ED_ClearEdict (e);
 201                         return e;
 202                 }
 203         }
 204
 205         if (i == MAX_EDICTS)
 206                 Sys_Error ("ED_Alloc: no free edicts");
 207
 208         sv.num_edicts++;
 209         e = EDICT_NUM(i);
 210         ED_ClearEdict (e);
 211
 212         return e;
 213 }
 214
 215 /*
 216 =================
 217 ED_Free
 218
 219 Marks the edict as free
 220 FIXME: walk all entities and NULL out references to this entity
 221 =================
 222 */
 223 void ED_Free (edict_t *ed)
 224 {
 225         SV_UnlinkEdict (ed);            // unlink from world bsp
 226
 227         ed->free = true;
 228         ed->v.model = 0;
 229         ed->v.takedamage = 0;
 230         ed->v.modelindex = 0;
 231         ed->v.colormap = 0;
 232         ed->v.skin = 0;
 233         ed->v.frame = 0;
 234         VectorCopy (vec3_origin, ed->v.origin);
 235         VectorCopy (vec3_origin, ed->v.angles);
 236         ed->v.nextthink = -1;
 237         ed->v.solid = 0;
 238
 239         ed->freetime = sv.time;
 240 }
 241
 242 //===========================================================================
 243
 244 /*
 245 ============
 246 ED_GlobalAtOfs
 247 ============
 248 */
 249 ddef_t *ED_GlobalAtOfs (int ofs)
 250 {
 251         ddef_t          *def;
 252         int                     i;
 253
 254         for (i=0 ; i<progs->numglobaldefs ; i++)
 255         {
 256                 def = &pr_globaldefs[i];
 257                 if (def->ofs == ofs)
 258                         return def;
 259         }
 260         return NULL;
 261 }
 262
 263 /*
 264 ============
 265 ED_FieldAtOfs
 266 ============
 267 */
 268 ddef_t *ED_FieldAtOfs (int ofs)
 269 {
 270         ddef_t          *def;
 271         int                     i;
 272
 273         for (i=0 ; i<progs->numfielddefs ; i++)
 274         {
 275                 def = &pr_fielddefs[i];
 276                 if (def->ofs == ofs)
 277                         return def;
 278         }
 279         return NULL;
 280 }
 281
 282 /*
 283 ============
 284 ED_FindField
 285 ============
 286 */
 287 ddef_t *ED_FindField (char *name)
 288 {
 289         ddef_t          *def;
 290         int                     i;
 291
 292         for (i=0 ; i<progs->numfielddefs ; i++)
 293         {
 294                 def = &pr_fielddefs[i];
 295                 if (!strcmp(pr_strings + def->s_name,name) )
 296                         return def;
 297         }
 298         return NULL;
 299 }
 300
 301
 302 /*
 303 ============
 304 ED_FindGlobal
 305 ============
 306 */
 307 ddef_t *ED_FindGlobal (char *name)
 308 {
 309         ddef_t          *def;
 310         int                     i;
 311
 312         for (i=0 ; i<progs->numglobaldefs ; i++)
 313         {
 314                 def = &pr_globaldefs[i];
 315                 if (!strcmp(pr_strings + def->s_name,name) )
 316                         return def;
 317         }
 318         return NULL;
 319 }
 320
 321
 322 /*
 323 ============
 324 ED_FindFunction
 325 ============
 326 */
 327 dfunction_t *ED_FindFunction (char *name)
 328 {
 329         dfunction_t             *func;
 330         int                             i;
 331
 332         for (i=0 ; i<progs->numfunctions ; i++)
 333         {
 334                 func = &pr_functions[i];
 335                 if (!strcmp(pr_strings + func->s_name,name) )
 336                         return func;
 337         }
 338         return NULL;
 339 }
 340
 341
 342 /*
 343 eval_t *GetEdictFieldValue(edict_t *ed, char *field)
 344 {
 345         ddef_t                  *def = NULL;
 346         int                             i;
 347         static int              rep = 0;
 348
 349         for (i=0 ; i<GEFV_CACHESIZE ; i++)
 350         {
 351                 if (!strcmp(field, gefvCache[i].field))
 352                 {
 353                         def = gefvCache[i].pcache;
 354                         goto Done;
 355                 }
 356         }
 357
 358         def = ED_FindField (field);
 359
 360         if (strlen(field) < MAX_FIELD_LEN)
 361         {
 362                 gefvCache[rep].pcache = def;
 363                 strcpy (gefvCache[rep].field, field);
 364                 rep ^= 1;
 365         }
 366
 367 Done:
 368         if (!def)
 369                 return NULL;
 370
 371         return (eval_t *)((char *)&ed->v + def->ofs*4);
 372 }
 373 */
 374
 375 /*
 376 ============
 377 PR_ValueString
 378
 379 Returns a string describing *data in a type specific manner
 380 =============
 381 */
 382 char *PR_ValueString (etype_t type, eval_t *val)
 383 {
 384         static char     line[256];
 385         ddef_t          *def;
 386         dfunction_t     *f;
 387
 388         type &= ~DEF_SAVEGLOBAL;
 389
 390         switch (type)
 391         {
 392         case ev_string:
 393                 sprintf (line, "%s", pr_strings + val->string);
 394                 break;
 395         case ev_entity:
 396                 sprintf (line, "entity %i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)) );
 397                 break;
 398         case ev_function:
 399                 f = pr_functions + val->function;
 400                 sprintf (line, "%s()", pr_strings + f->s_name);
 401                 break;
 402         case ev_field:
 403                 def = ED_FieldAtOfs ( val->_int );
 404                 sprintf (line, ".%s", pr_strings + def->s_name);
 405                 break;
 406         case ev_void:
 407                 sprintf (line, "void");
 408                 break;
 409         case ev_float:
 410                 sprintf (line, "%5.1f", val->_float);
 411                 break;
 412         case ev_vector:
 413                 sprintf (line, "'%5.1f %5.1f %5.1f'", val->vector[0], val->vector[1], val->vector[2]);
 414                 break;
 415         case ev_pointer:
 416                 sprintf (line, "pointer");
 417                 break;
 418         default:
 419                 sprintf (line, "bad type %i", type);
 420                 break;
 421         }
 422
 423         return line;
 424 }
 425
 426 /*
 427 ============
 428 PR_UglyValueString
 429
 430 Returns a string describing *data in a type specific manner
 431 Easier to parse than PR_ValueString
 432 =============
 433 */
 434 char *PR_UglyValueString (etype_t type, eval_t *val)
 435 {
 436         static char     line[256];
 437         ddef_t          *def;
 438         dfunction_t     *f;
 439
 440         type &= ~DEF_SAVEGLOBAL;
 441
 442         switch (type)
 443         {
 444         case ev_string:
 445                 sprintf (line, "%s", pr_strings + val->string);
 446                 break;
 447         case ev_entity:
 448                 sprintf (line, "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
 449                 break;
 450         case ev_function:
 451                 f = pr_functions + val->function;
 452                 sprintf (line, "%s", pr_strings + f->s_name);
 453                 break;
 454         case ev_field:
 455                 def = ED_FieldAtOfs ( val->_int );
 456                 sprintf (line, "%s", pr_strings + def->s_name);
 457                 break;
 458         case ev_void:
 459                 sprintf (line, "void");
 460                 break;
 461         case ev_float:
 462                 sprintf (line, "%f", val->_float);
 463                 break;
 464         case ev_vector:
 465                 sprintf (line, "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
 466                 break;
 467         default:
 468                 sprintf (line, "bad type %i", type);
 469                 break;
 470         }
 471
 472         return line;
 473 }
 474
 475 /*
 476 ============
 477 PR_GlobalString
 478
 479 Returns a string with a description and the contents of a global,
 480 padded to 20 field width
 481 ============
 482 */
 483 char *PR_GlobalString (int ofs)
 484 {
 485         char    *s;
 486         int             i;
 487         ddef_t  *def;
 488         void    *val;
 489         static char     line[128];
 490
 491         val = (void *)&pr_globals[ofs];
 492         def = ED_GlobalAtOfs(ofs);
 493         if (!def)
 494                 sprintf (line,"%i(???)", ofs);
 495         else
 496         {
 497                 s = PR_ValueString (def->type, val);
 498                 sprintf (line,"%i(%s)%s", ofs, pr_strings + def->s_name, s);
 499         }
 500
 501         i = strlen(line);
 502         for ( ; i<20 ; i++)
 503                 strcat (line," ");
 504         strcat (line," ");
 505
 506         return line;
 507 }
 508
 509 char *PR_GlobalStringNoContents (int ofs)
 510 {
 511         int             i;
 512         ddef_t  *def;
 513         static char     line[128];
 514
 515         def = ED_GlobalAtOfs(ofs);
 516         if (!def)
 517                 sprintf (line,"%i(???)", ofs);
 518         else
 519                 sprintf (line,"%i(%s)", ofs, pr_strings + def->s_name);
 520
 521         i = strlen(line);
 522         for ( ; i<20 ; i++)
 523                 strcat (line," ");
 524         strcat (line," ");
 525
 526         return line;
 527 }
 528
 529
 530 /*
 531 =============
 532 ED_Print
 533
 534 For debugging
 535 =============
 536 */
 537 // LordHavoc: optimized this to print out much more quickly
 538 void ED_Print (edict_t *ed)
 539 {
 540         int             l;
 541         ddef_t  *d;
 542         int             *v;
 543         int             i, j;
 544         char    *name;
 545         int             type;
 546         char    tempstring[8192]; // temporary string buffer
 547
 548         if (ed->free)
 549         {
 550                 Con_Printf ("FREE\n");
 551                 return;
 552         }
 553
 554         tempstring[0] = 0;
 555         sprintf(tempstring, "\nEDICT %i:\n", NUM_FOR_EDICT(ed));
 556         for (i=1 ; i<progs->numfielddefs ; i++)
 557         {
 558                 d = &pr_fielddefs[i];
 559                 name = pr_strings + d->s_name;
 560                 if (name[strlen(name)-2] == '_')
 561                         continue;       // skip _x, _y, _z vars
 562
 563                 v = (int *)((char *)&ed->v + d->ofs*4);
 564
 565         // if the value is still all 0, skip the field
 566                 type = d->type & ~DEF_SAVEGLOBAL;
 567
 568                 for (j=0 ; j<type_size[type] ; j++)
 569                         if (v[j])
 570                                 break;
 571                 if (j == type_size[type])
 572                         continue;
 573
 574                 strcat(tempstring, name);
 575                 l = strlen (name);
 576                 while (l++ < 15)
 577                         strcat(tempstring, " ");
 578
 579                 strcat(tempstring, PR_ValueString(d->type, (eval_t *)v));
 580                 strcat(tempstring, "\n");
 581         }
 582         Con_Printf(tempstring);
 583 }
 584
 585 /*
 586 =============
 587 ED_Write
 588
 589 For savegames
 590 =============
 591 */
 592 void ED_Write (FILE *f, edict_t *ed)
 593 {
 594         ddef_t  *d;
 595         int             *v;
 596         int             i, j;
 597         char    *name;
 598         int             type;
 599
 600         fprintf (f, "{\n");
 601
 602         if (ed->free)
 603         {
 604                 fprintf (f, "}\n");
 605                 return;
 606         }
 607
 608         for (i=1 ; i<progs->numfielddefs ; i++)
 609         {
 610                 d = &pr_fielddefs[i];
 611                 name = pr_strings + d->s_name;
 612                 if (name[strlen(name)-2] == '_')
 613                         continue;       // skip _x, _y, _z vars
 614
 615                 v = (int *)((char *)&ed->v + d->ofs*4);
 616
 617         // if the value is still all 0, skip the field
 618                 type = d->type & ~DEF_SAVEGLOBAL;
 619                 for (j=0 ; j<type_size[type] ; j++)
 620                         if (v[j])
 621                                 break;
 622                 if (j == type_size[type])
 623                         continue;
 624
 625                 fprintf (f,"\"%s\" ",name);
 626                 fprintf (f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v));
 627         }
 628
 629         fprintf (f, "}\n");
 630 }
 631
 632 void ED_PrintNum (int ent)
 633 {
 634         ED_Print (EDICT_NUM(ent));
 635 }
 636
 637 /*
 638 =============
 639 ED_PrintEdicts
 640
 641 For debugging, prints all the entities in the current server
 642 =============
 643 */
 644 void ED_PrintEdicts (void)
 645 {
 646         int             i;
 647
 648         Con_Printf ("%i entities\n", sv.num_edicts);
 649         for (i=0 ; i<sv.num_edicts ; i++)
 650                 ED_PrintNum (i);
 651 }
 652
 653 /*
 654 =============
 655 ED_PrintEdict_f
 656
 657 For debugging, prints a single edicy
 658 =============
 659 */
 660 void ED_PrintEdict_f (void)
 661 {
 662         int             i;
 663
 664         i = atoi (Cmd_Argv(1));
 665         if (i >= sv.num_edicts)
 666         {
 667                 Con_Printf("Bad edict number\n");
 668                 return;
 669         }
 670         ED_PrintNum (i);
 671 }
 672
 673 /*
 674 =============
 675 ED_Count
 676
 677 For debugging
 678 =============
 679 */
 680 void ED_Count (void)
 681 {
 682         int             i;
 683         edict_t *ent;
 684         int             active, models, solid, step;
 685
 686         active = models = solid = step = 0;
 687         for (i=0 ; i<sv.num_edicts ; i++)
 688         {
 689                 ent = EDICT_NUM(i);
 690                 if (ent->free)
 691                         continue;
 692                 active++;
 693                 if (ent->v.solid)
 694                         solid++;
 695                 if (ent->v.model)
 696                         models++;
 697                 if (ent->v.movetype == MOVETYPE_STEP)
 698                         step++;
 699         }
 700
 701         Con_Printf ("num_edicts:%3i\n", sv.num_edicts);
 702         Con_Printf ("active    :%3i\n", active);
 703         Con_Printf ("view      :%3i\n", models);
 704         Con_Printf ("touch     :%3i\n", solid);
 705         Con_Printf ("step      :%3i\n", step);
 706
 707 }
 708
 709 /*
 710 ==============================================================================
 711
 712                                         ARCHIVING GLOBALS
 713
 714 FIXME: need to tag constants, doesn't really work
 715 ==============================================================================
 716 */
 717
 718 /*
 719 =============
 720 ED_WriteGlobals
 721 =============
 722 */
 723 void ED_WriteGlobals (FILE *f)
 724 {
 725         ddef_t          *def;
 726         int                     i;
 727         char            *name;
 728         int                     type;
 729
 730         fprintf (f,"{\n");
 731         for (i=0 ; i<progs->numglobaldefs ; i++)
 732         {
 733                 def = &pr_globaldefs[i];
 734                 type = def->type;
 735                 if ( !(def->type & DEF_SAVEGLOBAL) )
 736                         continue;
 737                 type &= ~DEF_SAVEGLOBAL;
 738
 739                 if (type != ev_string
 740                 && type != ev_float
 741                 && type != ev_entity)
 742                         continue;
 743
 744                 name = pr_strings + def->s_name;
 745                 fprintf (f,"\"%s\" ", name);
 746                 fprintf (f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
 747         }
 748         fprintf (f,"}\n");
 749 }
 750
 751 /*
 752 =============
 753 ED_ParseGlobals
 754 =============
 755 */
 756 void ED_ParseGlobals (char *data)
 757 {
 758         char    keyname[64];
 759         ddef_t  *key;
 760
 761         while (1)
 762         {
 763         // parse key
 764                 data = COM_Parse (data);
 765                 if (com_token[0] == '}')
 766                         break;
 767                 if (!data)
 768                         Host_Error ("ED_ParseEntity: EOF without closing brace");
 769
 770                 strcpy (keyname, com_token);
 771
 772         // parse value
 773                 data = COM_Parse (data);
 774                 if (!data)
 775                         Host_Error ("ED_ParseEntity: EOF without closing brace");
 776
 777                 if (com_token[0] == '}')
 778                         Host_Error ("ED_ParseEntity: closing brace without data");
 779
 780                 key = ED_FindGlobal (keyname);
 781                 if (!key)
 782                 {
 783                         Con_DPrintf ("'%s' is not a global\n", keyname);
 784                         continue;
 785                 }
 786
 787                 if (!ED_ParseEpair ((void *)pr_globals, key, com_token))
 788                         Host_Error ("ED_ParseGlobals: parse error");
 789         }
 790 }
 791
 792 //============================================================================
 793
 794
 795 /*
 796 =============
 797 ED_NewString
 798 =============
 799 */
 800 char *ED_NewString (char *string)
 801 {
 802         char    *new, *new_p;
 803         int             i,l;
 804
 805         l = strlen(string) + 1;
 806         new = Hunk_Alloc (l);
 807         new_p = new;
 808
 809         for (i=0 ; i< l ; i++)
 810         {
 811                 if (string[i] == '\\' && i < l-1)
 812                 {
 813                         i++;
 814                         if (string[i] == 'n')
 815                                 *new_p++ = '\n';
 816                         else
 817                                 *new_p++ = '\\';
 818                 }
 819                 else
 820                         *new_p++ = string[i];
 821         }
 822
 823         return new;
 824 }
 825
 826
 827 /*
 828 =============
 829 ED_ParseEval
 830
 831 Can parse either fields or globals
 832 returns false if error
 833 =============
 834 */
 835 qboolean        ED_ParseEpair (void *base, ddef_t *key, char *s)
 836 {
 837         int             i;
 838         char    string[128];
 839         ddef_t  *def;
 840         char    *v, *w;
 841         void    *d;
 842         dfunction_t     *func;
 843
 844         d = (void *)((int *)base + key->ofs);
 845
 846         switch (key->type & ~DEF_SAVEGLOBAL)
 847         {
 848         case ev_string:
 849                 *(string_t *)d = ED_NewString (s) - pr_strings;
 850                 break;
 851
 852         case ev_float:
 853                 *(float *)d = atof (s);
 854                 break;
 855
 856         case ev_vector:
 857                 strcpy (string, s);
 858                 v = string;
 859                 w = string;
 860                 for (i=0 ; i<3 ; i++)
 861                 {
 862                         while (*v && *v != ' ')
 863                                 v++;
 864                         *v = 0;
 865                         ((float *)d)[i] = atof (w);
 866                         w = v = v+1;
 867                 }
 868                 break;
 869
 870         case ev_entity:
 871                 *(int *)d = EDICT_TO_PROG(EDICT_NUM(atoi (s)));
 872                 break;
 873
 874         case ev_field:
 875                 def = ED_FindField (s);
 876                 if (!def)
 877                 {
 878                         // LordHavoc: don't warn about worldspawn sky/fog fields because they don't require mod support
 879                         if (strcmp(s, "sky") && strncmp(s, "fog_", 4) && strcmp(s, "skyboxsize"))
 880                                 Con_DPrintf ("Can't find field %s\n", s);
 881                         return false;
 882                 }
 883                 *(int *)d = G_INT(def->ofs);
 884                 break;
 885
 886         case ev_function:
 887                 func = ED_FindFunction (s);
 888                 if (!func)
 889                 {
 890                         Con_DPrintf ("Can't find function %s\n", s);
 891                         return false;
 892                 }
 893                 *(func_t *)d = func - pr_functions;
 894                 break;
 895
 896         default:
 897                 break;
 898         }
 899         return true;
 900 }
 901
 902 /*
 903 ====================
 904 ED_ParseEdict
 905
 906 Parses an edict out of the given string, returning the new position
 907 ed should be a properly initialized empty edict.
 908 Used for initial level load and for savegames.
 909 ====================
 910 */
 911 char *ED_ParseEdict (char *data, edict_t *ent)
 912 {
 913         ddef_t          *key;
 914         qboolean        anglehack;
 915         qboolean        init;
 916         char            keyname[256];
 917         int                     n;
 918
 919         init = false;
 920
 921 // clear it
 922         if (ent != sv.edicts)   // hack
 923                 memset (&ent->v, 0, progs->entityfields * 4);
 924
 925 // go through all the dictionary pairs
 926         while (1)
 927         {
 928         // parse key
 929                 data = COM_Parse (data);
 930                 if (com_token[0] == '}')
 931                         break;
 932                 if (!data)
 933                         Host_Error ("ED_ParseEntity: EOF without closing brace");
 934
 935 // anglehack is to allow QuakeEd to write single scalar angles
 936 // and allow them to be turned into vectors. (FIXME...)
 937 if (!strcmp(com_token, "angle"))
 938 {
 939         strcpy (com_token, "angles");
 940         anglehack = true;
 941 }
 942 else
 943         anglehack = false;
 944
 945 // FIXME: change light to _light to get rid of this hack
 946 if (!strcmp(com_token, "light"))
 947         strcpy (com_token, "light_lev");        // hack for single light def
 948
 949                 strcpy (keyname, com_token);
 950
 951                 // another hack to fix heynames with trailing spaces
 952                 n = strlen(keyname);
 953                 while (n && keyname[n-1] == ' ')
 954                 {
 955                         keyname[n-1] = 0;
 956                         n--;
 957                 }
 958
 959         // parse value
 960                 data = COM_Parse (data);
 961                 if (!data)
 962                         Host_Error ("ED_ParseEntity: EOF without closing brace");
 963
 964                 if (com_token[0] == '}')
 965                         Host_Error ("ED_ParseEntity: closing brace without data");
 966
 967                 init = true;
 968
 969 // keynames with a leading underscore are used for utility comments,
 970 // and are immediately discarded by quake
 971                 if (keyname[0] == '_')
 972                         continue;
 973
 974                 key = ED_FindField (keyname);
 975                 if (!key)
 976                 {
 977                         Con_DPrintf ("'%s' is not a field\n", keyname);
 978                         continue;
 979                 }
 980
 981 if (anglehack)
 982 {
 983 char    temp[32];
 984 strcpy (temp, com_token);
 985 sprintf (com_token, "0 %s 0", temp);
 986 }
 987
 988                 if (!ED_ParseEpair ((void *)&ent->v, key, com_token))
 989                         Host_Error ("ED_ParseEdict: parse error");
 990         }
 991
 992         if (!init)
 993                 ent->free = true;
 994
 995         return data;
 996 }
 997
 998
 999 /*
1000 ================
1001 ED_LoadFromFile
1002
1003 The entities are directly placed in the array, rather than allocated with
1004 ED_Alloc, because otherwise an error loading the map would have entity
1005 number references out of order.
1006
1007 Creates a server's entity / program execution context by
1008 parsing textual entity definitions out of an ent file.
1009
1010 Used for both fresh maps and savegame loads.  A fresh map would also need
1011 to call ED_CallSpawnFunctions () to let the objects initialize themselves.
1012 ================
1013 */
1014 void ED_LoadFromFile (char *data)
1015 {
1016         edict_t         *ent;
1017         int                     inhibit;
1018         dfunction_t     *func;
1019
1020         ent = NULL;
1021         inhibit = 0;
1022         pr_global_struct->time = sv.time;
1023
1024 // parse ents
1025         while (1)
1026         {
1027 // parse the opening brace
1028                 data = COM_Parse (data);
1029                 if (!data)
1030                         break;
1031                 if (com_token[0] != '{')
1032                         Sys_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
1033
1034                 if (!ent)
1035                         ent = EDICT_NUM(0);
1036                 else
1037                         ent = ED_Alloc ();
1038                 data = ED_ParseEdict (data, ent);
1039
1040 // remove things from different skill levels or deathmatch
1041                 if (deathmatch.value)
1042                 {
1043                         if (((int)ent->v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
1044                         {
1045                                 ED_Free (ent);
1046                                 inhibit++;
1047                                 continue;
1048                         }
1049                 }
1050                 else if ((current_skill == 0 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_EASY  ))
1051                           || (current_skill == 1 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_MEDIUM))
1052                           || (current_skill >= 2 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_HARD  )))
1053                 {
1054                         ED_Free (ent);
1055                         inhibit++;
1056                         continue;
1057                 }
1058
1059 //
1060 // immediately call spawn function
1061 //
1062                 if (!ent->v.classname)
1063                 {
1064                         Con_Printf ("No classname for:\n");
1065                         ED_Print (ent);
1066                         ED_Free (ent);
1067                         continue;
1068                 }
1069
1070         // look for the spawn function
1071                 func = ED_FindFunction ( pr_strings + ent->v.classname );
1072
1073                 if (!func)
1074                 {
1075                         if (developer.value) // don't confuse non-developers with errors
1076                         {
1077                                 Con_Printf ("No spawn function for:\n");
1078                                 ED_Print (ent);
1079                         }
1080                         ED_Free (ent);
1081                         continue;
1082                 }
1083
1084                 pr_global_struct->self = EDICT_TO_PROG(ent);
1085                 PR_ExecuteProgram (func - pr_functions);
1086         }
1087
1088         Con_DPrintf ("%i entities inhibited\n", inhibit);
1089 }
1090
1091
1092 /*
1093 ===============
1094 PR_LoadProgs
1095 ===============
1096 */
1097 void PR_LoadProgs (void)
1098 {
1099         int             i;
1100         dstatement_t *st;
1101
1102 // flush the non-C variable lookup cache
1103         for (i=0 ; i<GEFV_CACHESIZE ; i++)
1104                 gefvCache[i].field[0] = 0;
1105
1106         progs = (dprograms_t *)COM_LoadHunkFile ("progs.dat", false);
1107         if (!progs)
1108                 Host_Error ("PR_LoadProgs: couldn't load progs.dat");
1109         Con_DPrintf ("Programs occupy %iK.\n", com_filesize/1024);
1110
1111         pr_crc = CRC_Block((byte *)progs, com_filesize);
1112
1113 // byte swap the header
1114         for (i=0 ; i<sizeof(*progs)/4 ; i++)
1115                 ((int *)progs)[i] = LittleLong ( ((int *)progs)[i] );
1116
1117         if (progs->version != PROG_VERSION)
1118                 Host_Error ("progs.dat has wrong version number (%i should be %i)", progs->version, PROG_VERSION);
1119         if (progs->crc != PROGHEADER_CRC)
1120                 Host_Error ("progs.dat system vars have been modified, progdefs.h is out of date");
1121
1122         pr_functions = (dfunction_t *)((byte *)progs + progs->ofs_functions);
1123         pr_strings = (char *)progs + progs->ofs_strings;
1124         pr_globaldefs = (ddef_t *)((byte *)progs + progs->ofs_globaldefs);
1125         pr_fielddefs = (ddef_t *)((byte *)progs + progs->ofs_fielddefs);
1126         pr_statements = (dstatement_t *)((byte *)progs + progs->ofs_statements);
1127
1128         pr_global_struct = (globalvars_t *)((byte *)progs + progs->ofs_globals);
1129         pr_globals = (float *)pr_global_struct;
1130
1131         pr_edict_size = progs->entityfields * 4 + sizeof (edict_t) - sizeof(entvars_t);
1132
1133         pr_edictareasize = pr_edict_size * MAX_EDICTS;
1134
1135 // byte swap the lumps
1136         for (i=0 ; i<progs->numstatements ; i++)
1137         {
1138                 pr_statements[i].op = LittleShort(pr_statements[i].op);
1139                 pr_statements[i].a = LittleShort(pr_statements[i].a);
1140                 pr_statements[i].b = LittleShort(pr_statements[i].b);
1141                 pr_statements[i].c = LittleShort(pr_statements[i].c);
1142         }
1143
1144         for (i=0 ; i<progs->numfunctions; i++)
1145         {
1146                 pr_functions[i].first_statement = LittleLong (pr_functions[i].first_statement);
1147                 pr_functions[i].parm_start = LittleLong (pr_functions[i].parm_start);
1148                 pr_functions[i].s_name = LittleLong (pr_functions[i].s_name);
1149                 pr_functions[i].s_file = LittleLong (pr_functions[i].s_file);
1150                 pr_functions[i].numparms = LittleLong (pr_functions[i].numparms);
1151                 pr_functions[i].locals = LittleLong (pr_functions[i].locals);
1152         }
1153
1154         for (i=0 ; i<progs->numglobaldefs ; i++)
1155         {
1156                 pr_globaldefs[i].type = LittleShort (pr_globaldefs[i].type);
1157                 pr_globaldefs[i].ofs = LittleShort (pr_globaldefs[i].ofs);
1158                 pr_globaldefs[i].s_name = LittleLong (pr_globaldefs[i].s_name);
1159         }
1160
1161         for (i=0 ; i<progs->numfielddefs ; i++)
1162         {
1163                 pr_fielddefs[i].type = LittleShort (pr_fielddefs[i].type);
1164                 if (pr_fielddefs[i].type & DEF_SAVEGLOBAL)
1165                         Host_Error ("PR_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL");
1166                 pr_fielddefs[i].ofs = LittleShort (pr_fielddefs[i].ofs);
1167                 pr_fielddefs[i].s_name = LittleLong (pr_fielddefs[i].s_name);
1168         }
1169
1170         for (i=0 ; i<progs->numglobals ; i++)
1171                 ((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);
1172
1173         // LordHavoc: bounds check anything static
1174         for (i = 0,st = pr_statements;i < progs->numstatements;i++,st++)
1175         {
1176                 switch (st->op)
1177                 {
1178                 case OP_IF:
1179                 case OP_IFNOT:
1180                         if ((unsigned short) st->a >= progs->numglobals || st->b + i < 0 || st->b + i >= progs->numstatements)
1181                                 Host_Error("PR_LoadProgs: out of bounds IF/IFNOT (statement %d)\n", i);
1182                         break;
1183                 case OP_GOTO:
1184                         if (st->a + i < 0 || st->a + i >= progs->numstatements)
1185                                 Host_Error("PR_LoadProgs: out of bounds GOTO (statement %d)\n", i);
1186                         break;
1187                 // global global global
1188                 case OP_ADD_F:
1189                 case OP_ADD_V:
1190                 case OP_SUB_F:
1191                 case OP_SUB_V:
1192                 case OP_MUL_F:
1193                 case OP_MUL_V:
1194                 case OP_MUL_FV:
1195                 case OP_MUL_VF:
1196                 case OP_DIV_F:
1197                 case OP_BITAND:
1198                 case OP_BITOR:
1199                 case OP_GE:
1200                 case OP_LE:
1201                 case OP_GT:
1202                 case OP_LT:
1203                 case OP_AND:
1204                 case OP_OR:
1205                 case OP_EQ_F:
1206                 case OP_EQ_V:
1207                 case OP_EQ_S:
1208                 case OP_EQ_E:
1209                 case OP_EQ_FNC:
1210                 case OP_NE_F:
1211                 case OP_NE_V:
1212                 case OP_NE_S:
1213                 case OP_NE_E:
1214                 case OP_NE_FNC:
1215                 case OP_ADDRESS:
1216                 case OP_LOAD_F:
1217                 case OP_LOAD_FLD:
1218                 case OP_LOAD_ENT:
1219                 case OP_LOAD_S:
1220                 case OP_LOAD_FNC:
1221                 case OP_LOAD_V:
1222                         if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->b >= progs->numglobals || (unsigned short) st->c >= progs->numglobals)
1223                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1224                         break;
1225                 // global none global
1226                 case OP_NOT_F:
1227                 case OP_NOT_V:
1228                 case OP_NOT_S:
1229                 case OP_NOT_FNC:
1230                 case OP_NOT_ENT:
1231                         if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->c >= progs->numglobals)
1232                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1233                         break;
1234                 // 2 globals
1235                 case OP_STOREP_F:
1236                 case OP_STOREP_ENT:
1237                 case OP_STOREP_FLD:
1238                 case OP_STOREP_S:
1239                 case OP_STOREP_FNC:
1240                 case OP_STORE_F:
1241                 case OP_STORE_ENT:
1242                 case OP_STORE_FLD:
1243                 case OP_STORE_S:
1244                 case OP_STORE_FNC:
1245                 case OP_STATE:
1246                 case OP_STOREP_V:
1247                 case OP_STORE_V:
1248                         if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->b >= progs->numglobals)
1249                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1250                         break;
1251                 // 1 global
1252                 case OP_CALL0:
1253                 case OP_CALL1:
1254                 case OP_CALL2:
1255                 case OP_CALL3:
1256                 case OP_CALL4:
1257                 case OP_CALL5:
1258                 case OP_CALL6:
1259                 case OP_CALL7:
1260                 case OP_CALL8:
1261                 case OP_DONE:
1262                 case OP_RETURN:
1263                         if ((unsigned short) st->a >= progs->numglobals)
1264                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1265                         break;
1266                 default:
1267                         Host_Error("PR_LoadProgs: unknown opcode %d at statement %d\n", st->op, i);
1268                         break;
1269                 }
1270         }
1271
1272         FindEdictFieldOffsets(); // LordHavoc: update field offset list
1273 }
1274
1275
1276 /*
1277 ===============
1278 PR_Init
1279 ===============
1280 */
1281 void PR_Init (void)
1282 {
1283         Cmd_AddCommand ("edict", ED_PrintEdict_f);
1284         Cmd_AddCommand ("edicts", ED_PrintEdicts);
1285         Cmd_AddCommand ("edictcount", ED_Count);
1286         Cmd_AddCommand ("profile", PR_Profile_f);
1287         Cvar_RegisterVariable (&nomonsters);
1288         Cvar_RegisterVariable (&gamecfg);
1289         Cvar_RegisterVariable (&scratch1);
1290         Cvar_RegisterVariable (&scratch2);
1291         Cvar_RegisterVariable (&scratch3);
1292         Cvar_RegisterVariable (&scratch4);
1293         Cvar_RegisterVariable (&savedgamecfg);
1294         Cvar_RegisterVariable (&saved1);
1295         Cvar_RegisterVariable (&saved2);
1296         Cvar_RegisterVariable (&saved3);
1297         Cvar_RegisterVariable (&saved4);
1298         // LordHavoc: for DarkPlaces, this overrides the number of decors (shell casings, gibs, etc)
1299         Cvar_RegisterVariable (&decors);
1300         // LordHavoc: Nehahra uses these to pass data around cutscene demos
1301         if (nehahra)
1302         {
1303                 Cvar_RegisterVariable (&nehx00);Cvar_RegisterVariable (&nehx01);
1304                 Cvar_RegisterVariable (&nehx02);Cvar_RegisterVariable (&nehx03);
1305                 Cvar_RegisterVariable (&nehx04);Cvar_RegisterVariable (&nehx05);
1306                 Cvar_RegisterVariable (&nehx06);Cvar_RegisterVariable (&nehx07);
1307                 Cvar_RegisterVariable (&nehx08);Cvar_RegisterVariable (&nehx09);
1308                 Cvar_RegisterVariable (&nehx10);Cvar_RegisterVariable (&nehx11);
1309                 Cvar_RegisterVariable (&nehx12);Cvar_RegisterVariable (&nehx13);
1310                 Cvar_RegisterVariable (&nehx14);Cvar_RegisterVariable (&nehx15);
1311                 Cvar_RegisterVariable (&nehx16);Cvar_RegisterVariable (&nehx17);
1312                 Cvar_RegisterVariable (&nehx18);Cvar_RegisterVariable (&nehx19);
1313         }
1314         Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
1315         // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
1316         Cvar_RegisterVariable (&pr_boundscheck);
1317 }
1318
1319 // LordHavoc: turned EDICT_NUM into a #define for speed reasons
1320 edict_t *EDICT_NUM_ERROR(int n)
1321 {
1322         Sys_Error ("EDICT_NUM: bad number %i", n);
1323         return NULL;
1324 }
1325 /*
1326 edict_t *EDICT_NUM(int n)
1327 {
1328         if (n < 0 || n >= sv.max_edicts)
1329                 Sys_Error ("EDICT_NUM: bad number %i", n);
1330         return (edict_t *)((byte *)sv.edicts+ (n)*pr_edict_size);
1331 }
1332 */
1333
1334 int NUM_FOR_EDICT(edict_t *e)
1335 {
1336         int             b;
1337
1338         b = (byte *)e - (byte *)sv.edicts;
1339         b = b / pr_edict_size;
1340
1341         if (b < 0 || b >= sv.num_edicts)
1342                 Sys_Error ("NUM_FOR_EDICT: bad pointer");
1343         return b;
1344 }