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 mfunction_t             *pr_functions;
  26 char                    *pr_strings;
  27 int                             pr_stringssize;
  28 ddef_t                  *pr_fielddefs;
  29 ddef_t                  *pr_globaldefs;
  30 dstatement_t    *pr_statements;
  31 globalvars_t    *pr_global_struct;
  32 float                   *pr_globals;                    // same as pr_global_struct
  33 int                             pr_edict_size;                  // in bytes
  34 int                             pr_edictareasize;               // LordHavoc: in bytes
  35
  36 int                             pr_maxknownstrings;
  37 int                             pr_numknownstrings;
  38 const char              **pr_knownstrings;
  39
  40 unsigned short  pr_crc;
  41
  42 mempool_t               *serverprogs_mempool;
  43
  44 int             type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4};
  45
  46 ddef_t *ED_FieldAtOfs(int ofs);
  47 qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s);
  48
  49 cvar_t  pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1"};
  50 cvar_t  nomonsters = {0, "nomonsters", "0"};
  51 cvar_t  gamecfg = {0, "gamecfg", "0"};
  52 cvar_t  scratch1 = {0, "scratch1", "0"};
  53 cvar_t  scratch2 = {0,"scratch2", "0"};
  54 cvar_t  scratch3 = {0, "scratch3", "0"};
  55 cvar_t  scratch4 = {0, "scratch4", "0"};
  56 cvar_t  savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0"};
  57 cvar_t  saved1 = {CVAR_SAVE, "saved1", "0"};
  58 cvar_t  saved2 = {CVAR_SAVE, "saved2", "0"};
  59 cvar_t  saved3 = {CVAR_SAVE, "saved3", "0"};
  60 cvar_t  saved4 = {CVAR_SAVE, "saved4", "0"};
  61 cvar_t  decors = {0, "decors", "0"};
  62 cvar_t  nehx00 = {0, "nehx00", "0"};cvar_t      nehx01 = {0, "nehx01", "0"};
  63 cvar_t  nehx02 = {0, "nehx02", "0"};cvar_t      nehx03 = {0, "nehx03", "0"};
  64 cvar_t  nehx04 = {0, "nehx04", "0"};cvar_t      nehx05 = {0, "nehx05", "0"};
  65 cvar_t  nehx06 = {0, "nehx06", "0"};cvar_t      nehx07 = {0, "nehx07", "0"};
  66 cvar_t  nehx08 = {0, "nehx08", "0"};cvar_t      nehx09 = {0, "nehx09", "0"};
  67 cvar_t  nehx10 = {0, "nehx10", "0"};cvar_t      nehx11 = {0, "nehx11", "0"};
  68 cvar_t  nehx12 = {0, "nehx12", "0"};cvar_t      nehx13 = {0, "nehx13", "0"};
  69 cvar_t  nehx14 = {0, "nehx14", "0"};cvar_t      nehx15 = {0, "nehx15", "0"};
  70 cvar_t  nehx16 = {0, "nehx16", "0"};cvar_t      nehx17 = {0, "nehx17", "0"};
  71 cvar_t  nehx18 = {0, "nehx18", "0"};cvar_t      nehx19 = {0, "nehx19", "0"};
  72 cvar_t  cutscene = {0, "cutscene", "1"};
  73 // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
  74 cvar_t  pr_boundscheck = {0, "pr_boundscheck", "1"};
  75 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
  76 cvar_t  pr_traceqc = {0, "pr_traceqc", "0"};
  77
  78 #define MAX_FIELD_LEN   64
  79 #define GEFV_CACHESIZE  2
  80
  81 typedef struct {
  82         ddef_t  *pcache;
  83         char    field[MAX_FIELD_LEN];
  84 } gefv_cache;
  85
  86 static gefv_cache       gefvCache[GEFV_CACHESIZE] = {{NULL, ""}, {NULL, ""}};
  87
  88 ddef_t *ED_FindField (const char *name);
  89 mfunction_t *ED_FindFunction (const char *name);
  90
  91 // LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue...  these are defined as externs in progs.h
  92 int eval_gravity;
  93 int eval_button3;
  94 int eval_button4;
  95 int eval_button5;
  96 int eval_button6;
  97 int eval_button7;
  98 int eval_button8;
  99 int eval_buttonuse;
 100 int eval_buttonchat;
 101 int eval_glow_size;
 102 int eval_glow_trail;
 103 int eval_glow_color;
 104 int eval_items2;
 105 int eval_scale;
 106 int eval_alpha;
 107 int eval_renderamt; // HalfLife support
 108 int eval_rendermode; // HalfLife support
 109 int eval_fullbright;
 110 int eval_ammo_shells1;
 111 int eval_ammo_nails1;
 112 int eval_ammo_lava_nails;
 113 int eval_ammo_rockets1;
 114 int eval_ammo_multi_rockets;
 115 int eval_ammo_cells1;
 116 int eval_ammo_plasma;
 117 int eval_idealpitch;
 118 int eval_pitch_speed;
 119 int eval_viewmodelforclient;
 120 int eval_nodrawtoclient;
 121 int eval_exteriormodeltoclient;
 122 int eval_drawonlytoclient;
 123 int eval_ping;
 124 int eval_movement;
 125 int eval_pmodel;
 126 int eval_punchvector;
 127 int eval_viewzoom;
 128 int eval_clientcolors;
 129 int eval_tag_entity;
 130 int eval_tag_index;
 131 int eval_light_lev;
 132 int eval_color;
 133 int eval_style;
 134 int eval_pflags;
 135 int eval_cursor_active;
 136 int eval_cursor_screen;
 137 int eval_cursor_trace_start;
 138 int eval_cursor_trace_endpos;
 139 int eval_cursor_trace_ent;
 140 int eval_colormod;
 141 int eval_playermodel;
 142 int eval_playerskin;
 143
 144 mfunction_t *SV_PlayerPhysicsQC;
 145 mfunction_t *EndFrameQC;
 146 //KrimZon - SERVER COMMANDS IN QUAKEC
 147 mfunction_t *SV_ParseClientCommandQC;
 148
 149 int FindFieldOffset(const char *field)
 150 {
 151         ddef_t *d;
 152         d = ED_FindField(field);
 153         if (!d)
 154                 return 0;
 155         return d->ofs*4;
 156 }
 157
 158 void FindEdictFieldOffsets(void)
 159 {
 160         eval_gravity = FindFieldOffset("gravity");
 161         eval_button3 = FindFieldOffset("button3");
 162         eval_button4 = FindFieldOffset("button4");
 163         eval_button5 = FindFieldOffset("button5");
 164         eval_button6 = FindFieldOffset("button6");
 165         eval_button7 = FindFieldOffset("button7");
 166         eval_button8 = FindFieldOffset("button8");
 167         eval_buttonuse = FindFieldOffset("buttonuse");
 168         eval_buttonchat = FindFieldOffset("buttonchat");
 169         eval_glow_size = FindFieldOffset("glow_size");
 170         eval_glow_trail = FindFieldOffset("glow_trail");
 171         eval_glow_color = FindFieldOffset("glow_color");
 172         eval_items2 = FindFieldOffset("items2");
 173         eval_scale = FindFieldOffset("scale");
 174         eval_alpha = FindFieldOffset("alpha");
 175         eval_renderamt = FindFieldOffset("renderamt"); // HalfLife support
 176         eval_rendermode = FindFieldOffset("rendermode"); // HalfLife support
 177         eval_fullbright = FindFieldOffset("fullbright");
 178         eval_ammo_shells1 = FindFieldOffset("ammo_shells1");
 179         eval_ammo_nails1 = FindFieldOffset("ammo_nails1");
 180         eval_ammo_lava_nails = FindFieldOffset("ammo_lava_nails");
 181         eval_ammo_rockets1 = FindFieldOffset("ammo_rockets1");
 182         eval_ammo_multi_rockets = FindFieldOffset("ammo_multi_rockets");
 183         eval_ammo_cells1 = FindFieldOffset("ammo_cells1");
 184         eval_ammo_plasma = FindFieldOffset("ammo_plasma");
 185         eval_idealpitch = FindFieldOffset("idealpitch");
 186         eval_pitch_speed = FindFieldOffset("pitch_speed");
 187         eval_viewmodelforclient = FindFieldOffset("viewmodelforclient");
 188         eval_nodrawtoclient = FindFieldOffset("nodrawtoclient");
 189         eval_exteriormodeltoclient = FindFieldOffset("exteriormodeltoclient");
 190         eval_drawonlytoclient = FindFieldOffset("drawonlytoclient");
 191         eval_ping = FindFieldOffset("ping");
 192         eval_movement = FindFieldOffset("movement");
 193         eval_pmodel = FindFieldOffset("pmodel");
 194         eval_punchvector = FindFieldOffset("punchvector");
 195         eval_viewzoom = FindFieldOffset("viewzoom");
 196         eval_clientcolors = FindFieldOffset("clientcolors");
 197         eval_tag_entity = FindFieldOffset("tag_entity");
 198         eval_tag_index = FindFieldOffset("tag_index");
 199         eval_light_lev = FindFieldOffset("light_lev");
 200         eval_color = FindFieldOffset("color");
 201         eval_style = FindFieldOffset("style");
 202         eval_pflags = FindFieldOffset("pflags");
 203         eval_cursor_active = FindFieldOffset("cursor_active");
 204         eval_cursor_screen = FindFieldOffset("cursor_screen");
 205         eval_cursor_trace_start = FindFieldOffset("cursor_trace_start");
 206         eval_cursor_trace_endpos = FindFieldOffset("cursor_trace_endpos");
 207         eval_cursor_trace_ent = FindFieldOffset("cursor_trace_ent");
 208         eval_colormod = FindFieldOffset("colormod");
 209         eval_playermodel = FindFieldOffset("playermodel");
 210         eval_playerskin = FindFieldOffset("playerskin");
 211
 212         // LordHavoc: allowing QuakeC to override the player movement code
 213         SV_PlayerPhysicsQC = ED_FindFunction ("SV_PlayerPhysics");
 214         // LordHavoc: support for endframe
 215         EndFrameQC = ED_FindFunction ("EndFrame");
 216         //KrimZon - SERVER COMMANDS IN QUAKEC
 217         SV_ParseClientCommandQC = ED_FindFunction ("SV_ParseClientCommand");
 218 }
 219
 220 /*
 221 =================
 222 ED_ClearEdict
 223
 224 Sets everything to NULL
 225 =================
 226 */
 227 void ED_ClearEdict (edict_t *e)
 228 {
 229         int num;
 230         memset (e->v, 0, progs->entityfields * 4);
 231         e->e->free = false;
 232         // LordHavoc: for consistency set these here
 233         num = NUM_FOR_EDICT(e) - 1;
 234         if (num >= 0 && num < svs.maxclients)
 235         {
 236                 eval_t *val;
 237                 // set colormap and team on newly created player entity
 238                 e->v->colormap = num + 1;
 239                 e->v->team = (svs.clients[num].colors & 15) + 1;
 240                 // set netname/clientcolors back to client values so that
 241                 // DP_SV_CLIENTNAME and DPV_SV_CLIENTCOLORS will not immediately
 242                 // reset them
 243                 e->v->netname = PR_SetEngineString(svs.clients[num].name);
 244                 if ((val = GETEDICTFIELDVALUE(e, eval_clientcolors)))
 245                         val->_float = svs.clients[num].colors;
 246                 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
 247                 if( eval_playermodel )
 248                         GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PR_SetEngineString(svs.clients[num].playermodel);
 249                 if( eval_playerskin )
 250                         GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PR_SetEngineString(svs.clients[num].playerskin);
 251         }
 252 }
 253
 254 /*
 255 =================
 256 ED_Alloc
 257
 258 Either finds a free edict, or allocates a new one.
 259 Try to avoid reusing an entity that was recently freed, because it
 260 can cause the client to think the entity morphed into something else
 261 instead of being removed and recreated, which can cause interpolated
 262 angles and bad trails.
 263 =================
 264 */
 265 edict_t *ED_Alloc (void)
 266 {
 267         int                     i;
 268         edict_t         *e;
 269
 270         for (i = svs.maxclients + 1;i < sv.num_edicts;i++)
 271         {
 272                 e = EDICT_NUM(i);
 273                 // the first couple seconds of server time can involve a lot of
 274                 // freeing and allocating, so relax the replacement policy
 275                 if (e->e->free && ( e->e->freetime < 2 || sv.time - e->e->freetime > 0.5 ) )
 276                 {
 277                         ED_ClearEdict (e);
 278                         return e;
 279                 }
 280         }
 281
 282         if (i == MAX_EDICTS)
 283                 Host_Error ("ED_Alloc: no free edicts");
 284
 285         sv.num_edicts++;
 286         if (sv.num_edicts >= sv.max_edicts)
 287                 SV_IncreaseEdicts();
 288         e = EDICT_NUM(i);
 289         ED_ClearEdict (e);
 290
 291         return e;
 292 }
 293
 294 /*
 295 =================
 296 ED_Free
 297
 298 Marks the edict as free
 299 FIXME: walk all entities and NULL out references to this entity
 300 =================
 301 */
 302 void ED_Free (edict_t *ed)
 303 {
 304         SV_UnlinkEdict (ed);            // unlink from world bsp
 305
 306         ed->e->free = true;
 307         ed->v->model = 0;
 308         ed->v->takedamage = 0;
 309         ed->v->modelindex = 0;
 310         ed->v->colormap = 0;
 311         ed->v->skin = 0;
 312         ed->v->frame = 0;
 313         VectorClear(ed->v->origin);
 314         VectorClear(ed->v->angles);
 315         ed->v->nextthink = -1;
 316         ed->v->solid = 0;
 317
 318         ed->e->freetime = sv.time;
 319 }
 320
 321 //===========================================================================
 322
 323 /*
 324 ============
 325 ED_GlobalAtOfs
 326 ============
 327 */
 328 ddef_t *ED_GlobalAtOfs (int ofs)
 329 {
 330         ddef_t          *def;
 331         int                     i;
 332
 333         for (i=0 ; i<progs->numglobaldefs ; i++)
 334         {
 335                 def = &pr_globaldefs[i];
 336                 if (def->ofs == ofs)
 337                         return def;
 338         }
 339         return NULL;
 340 }
 341
 342 /*
 343 ============
 344 ED_FieldAtOfs
 345 ============
 346 */
 347 ddef_t *ED_FieldAtOfs (int ofs)
 348 {
 349         ddef_t          *def;
 350         int                     i;
 351
 352         for (i=0 ; i<progs->numfielddefs ; i++)
 353         {
 354                 def = &pr_fielddefs[i];
 355                 if (def->ofs == ofs)
 356                         return def;
 357         }
 358         return NULL;
 359 }
 360
 361 /*
 362 ============
 363 ED_FindField
 364 ============
 365 */
 366 ddef_t *ED_FindField (const char *name)
 367 {
 368         ddef_t *def;
 369         int i;
 370
 371         for (i=0 ; i<progs->numfielddefs ; i++)
 372         {
 373                 def = &pr_fielddefs[i];
 374                 if (!strcmp(PR_GetString(def->s_name), name))
 375                         return def;
 376         }
 377         return NULL;
 378 }
 379
 380 /*
 381 ============
 382 ED_FindGlobal
 383 ============
 384 */
 385 ddef_t *ED_FindGlobal (const char *name)
 386 {
 387         ddef_t *def;
 388         int i;
 389
 390         for (i=0 ; i<progs->numglobaldefs ; i++)
 391         {
 392                 def = &pr_globaldefs[i];
 393                 if (!strcmp(PR_GetString(def->s_name), name))
 394                         return def;
 395         }
 396         return NULL;
 397 }
 398
 399
 400 /*
 401 ============
 402 ED_FindFunction
 403 ============
 404 */
 405 mfunction_t *ED_FindFunction (const char *name)
 406 {
 407         mfunction_t             *func;
 408         int                             i;
 409
 410         for (i=0 ; i<progs->numfunctions ; i++)
 411         {
 412                 func = &pr_functions[i];
 413                 if (!strcmp(PR_GetString(func->s_name), name))
 414                         return func;
 415         }
 416         return NULL;
 417 }
 418
 419
 420 /*
 421 ============
 422 PR_ValueString
 423
 424 Returns a string describing *data in a type specific manner
 425 =============
 426 */
 427 //int NoCrash_NUM_FOR_EDICT(edict_t *e);
 428 char *PR_ValueString (etype_t type, eval_t *val)
 429 {
 430         static char line[1024]; // LordHavoc: enlarged a bit (was 256)
 431         ddef_t *def;
 432         mfunction_t *f;
 433         int n;
 434
 435         type &= ~DEF_SAVEGLOBAL;
 436
 437         switch (type)
 438         {
 439         case ev_string:
 440                 strlcpy (line, PR_GetString (val->string), sizeof (line));
 441                 break;
 442         case ev_entity:
 443                 //n = NoCrash_NUM_FOR_EDICT(PROG_TO_EDICT(val->edict));
 444                 n = val->edict;
 445                 if (n < 0 || n >= MAX_EDICTS)
 446                         dpsnprintf (line, sizeof (line), "entity %i (invalid!)", n);
 447                 else
 448                         dpsnprintf (line, sizeof (line), "entity %i", n);
 449                 break;
 450         case ev_function:
 451                 f = pr_functions + val->function;
 452                 dpsnprintf (line, sizeof (line), "%s()", PR_GetString(f->s_name));
 453                 break;
 454         case ev_field:
 455                 def = ED_FieldAtOfs ( val->_int );
 456                 dpsnprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name));
 457                 break;
 458         case ev_void:
 459                 dpsnprintf (line, sizeof (line), "void");
 460                 break;
 461         case ev_float:
 462                 // LordHavoc: changed from %5.1f to %10.4f
 463                 dpsnprintf (line, sizeof (line), "%10.4f", val->_float);
 464                 break;
 465         case ev_vector:
 466                 // LordHavoc: changed from %5.1f to %10.4f
 467                 dpsnprintf (line, sizeof (line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
 468                 break;
 469         case ev_pointer:
 470                 dpsnprintf (line, sizeof (line), "pointer");
 471                 break;
 472         default:
 473                 dpsnprintf (line, sizeof (line), "bad type %i", type);
 474                 break;
 475         }
 476
 477         return line;
 478 }
 479
 480 /*
 481 ============
 482 PR_UglyValueString
 483
 484 Returns a string describing *data in a type specific manner
 485 Easier to parse than PR_ValueString
 486 =============
 487 */
 488 char *PR_UglyValueString (etype_t type, eval_t *val)
 489 {
 490         static char line[4096];
 491         int i;
 492         const char *s;
 493         ddef_t *def;
 494         mfunction_t *f;
 495
 496         type &= ~DEF_SAVEGLOBAL;
 497
 498         switch (type)
 499         {
 500         case ev_string:
 501                 // Parse the string a bit to turn special characters
 502                 // (like newline, specifically) into escape codes,
 503                 // this fixes saving games from various mods
 504                 s = PR_GetString (val->string);
 505                 for (i = 0;i < (int)sizeof(line) - 2 && *s;)
 506                 {
 507                         if (*s == '\n')
 508                         {
 509                                 line[i++] = '\\';
 510                                 line[i++] = 'n';
 511                         }
 512                         else if (*s == '\r')
 513                         {
 514                                 line[i++] = '\\';
 515                                 line[i++] = 'r';
 516                         }
 517                         else
 518                                 line[i++] = *s;
 519                         s++;
 520                 }
 521                 line[i] = '\0';
 522                 break;
 523         case ev_entity:
 524                 dpsnprintf (line, sizeof (line), "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
 525                 break;
 526         case ev_function:
 527                 f = pr_functions + val->function;
 528                 strlcpy (line, PR_GetString (f->s_name), sizeof (line));
 529                 break;
 530         case ev_field:
 531                 def = ED_FieldAtOfs ( val->_int );
 532                 dpsnprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name));
 533                 break;
 534         case ev_void:
 535                 dpsnprintf (line, sizeof (line), "void");
 536                 break;
 537         case ev_float:
 538                 dpsnprintf (line, sizeof (line), "%f", val->_float);
 539                 break;
 540         case ev_vector:
 541                 dpsnprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
 542                 break;
 543         default:
 544                 dpsnprintf (line, sizeof (line), "bad type %i", type);
 545                 break;
 546         }
 547
 548         return line;
 549 }
 550
 551 /*
 552 ============
 553 PR_GlobalString
 554
 555 Returns a string with a description and the contents of a global,
 556 padded to 20 field width
 557 ============
 558 */
 559 char *PR_GlobalString (int ofs)
 560 {
 561         char    *s;
 562         int             i;
 563         ddef_t  *def;
 564         void    *val;
 565         static char     line[128];
 566
 567         val = (void *)&pr_globals[ofs];
 568         def = ED_GlobalAtOfs(ofs);
 569         if (!def)
 570                 dpsnprintf (line, sizeof (line), "%i(?)", ofs);
 571         else
 572         {
 573                 s = PR_ValueString (def->type, val);
 574                 dpsnprintf (line, sizeof (line), "%i(%s)%s", ofs, PR_GetString(def->s_name), s);
 575         }
 576
 577         i = strlen(line);
 578         for ( ; i<20 ; i++)
 579                 strlcat (line, " ", sizeof (line));
 580         strlcat (line, " ", sizeof (line));
 581
 582         return line;
 583 }
 584
 585 char *PR_GlobalStringNoContents (int ofs)
 586 {
 587         int             i;
 588         ddef_t  *def;
 589         static char     line[128];
 590
 591         def = ED_GlobalAtOfs(ofs);
 592         if (!def)
 593                 dpsnprintf (line, sizeof (line), "%i(?)", ofs);
 594         else
 595                 dpsnprintf (line, sizeof (line), "%i(%s)", ofs, PR_GetString(def->s_name));
 596
 597         i = strlen(line);
 598         for ( ; i<20 ; i++)
 599                 strlcat (line, " ", sizeof (line));
 600         strlcat (line, " ", sizeof (line));
 601
 602         return line;
 603 }
 604
 605
 606 /*
 607 =============
 608 ED_Print
 609
 610 For debugging
 611 =============
 612 */
 613 // LordHavoc: optimized this to print out much more quickly (tempstring)
 614 // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
 615 void ED_Print(edict_t *ed)
 616 {
 617         int             l;
 618         ddef_t  *d;
 619         int             *v;
 620         int             i, j;
 621         const char      *name;
 622         int             type;
 623         char    tempstring[8192], tempstring2[260]; // temporary string buffers
 624
 625         if (ed->e->free)
 626         {
 627                 Con_Print("FREE\n");
 628                 return;
 629         }
 630
 631         tempstring[0] = 0;
 632         dpsnprintf (tempstring, sizeof (tempstring), "\nEDICT %i:\n", NUM_FOR_EDICT(ed));
 633         for (i=1 ; i<progs->numfielddefs ; i++)
 634         {
 635                 d = &pr_fielddefs[i];
 636                 name = PR_GetString(d->s_name);
 637                 if (name[strlen(name)-2] == '_')
 638                         continue;       // skip _x, _y, _z vars
 639
 640                 v = (int *)((char *)ed->v + d->ofs*4);
 641
 642         // if the value is still all 0, skip the field
 643                 type = d->type & ~DEF_SAVEGLOBAL;
 644
 645                 for (j=0 ; j<type_size[type] ; j++)
 646                         if (v[j])
 647                                 break;
 648                 if (j == type_size[type])
 649                         continue;
 650
 651                 if (strlen(name) > 256)
 652                 {
 653                         memcpy (tempstring2, name, 256);
 654                         tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
 655                         tempstring2[259] = 0;
 656                         name = tempstring2;
 657                 }
 658                 strlcat (tempstring, name, sizeof (tempstring));
 659                 for (l = strlen(name);l < 14;l++)
 660                         strcat(tempstring, " ");
 661                 strcat(tempstring, " ");
 662
 663                 name = PR_ValueString(d->type, (eval_t *)v);
 664                 if (strlen(name) > 256)
 665                 {
 666                         memcpy(tempstring2, name, 256);
 667                         tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
 668                         tempstring2[259] = 0;
 669                         name = tempstring2;
 670                 }
 671                 strlcat (tempstring, name, sizeof (tempstring));
 672                 strlcat (tempstring, "\n", sizeof (tempstring));
 673                 if (strlen(tempstring) >= 4096)
 674                 {
 675                         Con_Print(tempstring);
 676                         tempstring[0] = 0;
 677                 }
 678         }
 679         if (tempstring[0])
 680                 Con_Print(tempstring);
 681 }
 682
 683 /*
 684 =============
 685 ED_Write
 686
 687 For savegames
 688 =============
 689 */
 690 void ED_Write (qfile_t *f, edict_t *ed)
 691 {
 692         ddef_t  *d;
 693         int             *v;
 694         int             i, j;
 695         const char      *name;
 696         int             type;
 697
 698         FS_Print(f, "{\n");
 699
 700         if (ed->e->free)
 701         {
 702                 FS_Print(f, "}\n");
 703                 return;
 704         }
 705
 706         for (i=1 ; i<progs->numfielddefs ; i++)
 707         {
 708                 d = &pr_fielddefs[i];
 709                 name = PR_GetString(d->s_name);
 710                 if (name[strlen(name)-2] == '_')
 711                         continue;       // skip _x, _y, _z vars
 712
 713                 v = (int *)((char *)ed->v + d->ofs*4);
 714
 715         // if the value is still all 0, skip the field
 716                 type = d->type & ~DEF_SAVEGLOBAL;
 717                 for (j=0 ; j<type_size[type] ; j++)
 718                         if (v[j])
 719                                 break;
 720                 if (j == type_size[type])
 721                         continue;
 722
 723                 FS_Printf(f,"\"%s\" ",name);
 724                 FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v));
 725         }
 726
 727         FS_Print(f, "}\n");
 728 }
 729
 730 void ED_PrintNum (int ent)
 731 {
 732         ED_Print(EDICT_NUM(ent));
 733 }
 734
 735 /*
 736 =============
 737 ED_PrintEdicts
 738
 739 For debugging, prints all the entities in the current server
 740 =============
 741 */
 742 void ED_PrintEdicts (void)
 743 {
 744         int             i;
 745
 746         Con_Printf("%i entities\n", sv.num_edicts);
 747         for (i=0 ; i<sv.num_edicts ; i++)
 748                 ED_PrintNum (i);
 749 }
 750
 751 /*
 752 =============
 753 ED_PrintEdict_f
 754
 755 For debugging, prints a single edict
 756 =============
 757 */
 758 void ED_PrintEdict_f (void)
 759 {
 760         int             i;
 761
 762         i = atoi (Cmd_Argv(1));
 763         if (i < 0 || i >= sv.num_edicts)
 764         {
 765                 Con_Print("Bad edict number\n");
 766                 return;
 767         }
 768         ED_PrintNum (i);
 769 }
 770
 771 /*
 772 =============
 773 ED_Count
 774
 775 For debugging
 776 =============
 777 */
 778 void ED_Count (void)
 779 {
 780         int             i;
 781         edict_t *ent;
 782         int             active, models, solid, step;
 783
 784         active = models = solid = step = 0;
 785         for (i=0 ; i<sv.num_edicts ; i++)
 786         {
 787                 ent = EDICT_NUM(i);
 788                 if (ent->e->free)
 789                         continue;
 790                 active++;
 791                 if (ent->v->solid)
 792                         solid++;
 793                 if (ent->v->model)
 794                         models++;
 795                 if (ent->v->movetype == MOVETYPE_STEP)
 796                         step++;
 797         }
 798
 799         Con_Printf("num_edicts:%3i\n", sv.num_edicts);
 800         Con_Printf("active    :%3i\n", active);
 801         Con_Printf("view      :%3i\n", models);
 802         Con_Printf("touch     :%3i\n", solid);
 803         Con_Printf("step      :%3i\n", step);
 804
 805 }
 806
 807 /*
 808 ==============================================================================
 809
 810                                         ARCHIVING GLOBALS
 811
 812 FIXME: need to tag constants, doesn't really work
 813 ==============================================================================
 814 */
 815
 816 /*
 817 =============
 818 ED_WriteGlobals
 819 =============
 820 */
 821 void ED_WriteGlobals (qfile_t *f)
 822 {
 823         ddef_t          *def;
 824         int                     i;
 825         const char              *name;
 826         int                     type;
 827
 828         FS_Print(f,"{\n");
 829         for (i=0 ; i<progs->numglobaldefs ; i++)
 830         {
 831                 def = &pr_globaldefs[i];
 832                 type = def->type;
 833                 if ( !(def->type & DEF_SAVEGLOBAL) )
 834                         continue;
 835                 type &= ~DEF_SAVEGLOBAL;
 836
 837                 if (type != ev_string && type != ev_float && type != ev_entity)
 838                         continue;
 839
 840                 name = PR_GetString(def->s_name);
 841                 FS_Printf(f,"\"%s\" ", name);
 842                 FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
 843         }
 844         FS_Print(f,"}\n");
 845 }
 846
 847 /*
 848 =============
 849 ED_EdictSet_f
 850
 851 Console command to set a field of a specified edict
 852 =============
 853 */
 854 void ED_EdictSet_f(void)
 855 {
 856         edict_t *ed;
 857         ddef_t *key;
 858
 859         if(Cmd_Argc() != 4)
 860         {
 861                 Con_Print("edictset <edict number> <field> <value>\n");
 862                 return;
 863         }
 864         ed = EDICT_NUM(atoi(Cmd_Argv(1)));
 865
 866         if((key = ED_FindField(Cmd_Argv(2))) == 0)
 867         {
 868                 Con_Printf("Key %s not found !\n", Cmd_Argv(2));
 869                 return;
 870         }
 871
 872         ED_ParseEpair(ed, key, Cmd_Argv(3));
 873 }
 874
 875 /*
 876 =============
 877 ED_ParseGlobals
 878 =============
 879 */
 880 void ED_ParseGlobals (const char *data)
 881 {
 882         char keyname[1024]; // LordHavoc: good idea? bad idea?  was 64
 883         ddef_t *key;
 884
 885         while (1)
 886         {
 887                 // parse key
 888                 if (!COM_ParseToken(&data, false))
 889                         Host_Error ("ED_ParseEntity: EOF without closing brace");
 890                 if (com_token[0] == '}')
 891                         break;
 892
 893                 strcpy (keyname, com_token);
 894
 895                 // parse value
 896                 if (!COM_ParseToken(&data, false))
 897                         Host_Error ("ED_ParseEntity: EOF without closing brace");
 898
 899                 if (com_token[0] == '}')
 900                         Host_Error ("ED_ParseEntity: closing brace without data");
 901
 902                 key = ED_FindGlobal (keyname);
 903                 if (!key)
 904                 {
 905                         Con_DPrintf("'%s' is not a global\n", keyname);
 906                         continue;
 907                 }
 908
 909                 if (!ED_ParseEpair(NULL, key, com_token))
 910                         Host_Error ("ED_ParseGlobals: parse error");
 911         }
 912 }
 913
 914 //============================================================================
 915
 916
 917 /*
 918 =============
 919 ED_ParseEval
 920
 921 Can parse either fields or globals
 922 returns false if error
 923 =============
 924 */
 925 qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s)
 926 {
 927         int i, l;
 928         char *new_p;
 929         ddef_t *def;
 930         eval_t *val;
 931         mfunction_t *func;
 932
 933         if (ent)
 934                 val = (eval_t *)((int *)ent->v + key->ofs);
 935         else
 936                 val = (eval_t *)((int *)pr_globals + key->ofs);
 937         switch (key->type & ~DEF_SAVEGLOBAL)
 938         {
 939         case ev_string:
 940                 l = strlen(s) + 1;
 941                 new_p = PR_AllocString(l);
 942                 val->string = PR_SetQCString(new_p);
 943                 for (i = 0;i < l;i++)
 944                 {
 945                         if (s[i] == '\\' && i < l-1)
 946                         {
 947                                 i++;
 948                                 if (s[i] == 'n')
 949                                         *new_p++ = '\n';
 950                                 else if (s[i] == 'r')
 951                                         *new_p++ = '\r';
 952                                 else
 953                                         *new_p++ = s[i];
 954                         }
 955                         else
 956                                 *new_p++ = s[i];
 957                 }
 958                 break;
 959
 960         case ev_float:
 961                 while (*s && *s <= ' ')
 962                         s++;
 963                 val->_float = atof(s);
 964                 break;
 965
 966         case ev_vector:
 967                 for (i = 0;i < 3;i++)
 968                 {
 969                         while (*s && *s <= ' ')
 970                                 s++;
 971                         if (*s)
 972                                 val->vector[i] = atof(s);
 973                         else
 974                                 val->vector[i] = 0;
 975                         while (*s > ' ')
 976                                 s++;
 977                 }
 978                 break;
 979
 980         case ev_entity:
 981                 while (*s && *s <= ' ')
 982                         s++;
 983                 i = atoi(s);
 984                 if (i < 0 || i >= MAX_EDICTS)
 985                         Con_Printf("ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i)\n", i, MAX_EDICTS);
 986                 while (i >= sv.max_edicts)
 987                         SV_IncreaseEdicts();
 988                 // if SV_IncreaseEdicts was called the base pointer needs to be updated
 989                 if (ent)
 990                         val = (eval_t *)((int *)ent->v + key->ofs);
 991                 val->edict = EDICT_TO_PROG(EDICT_NUM(i));
 992                 break;
 993
 994         case ev_field:
 995                 def = ED_FindField(s);
 996                 if (!def)
 997                 {
 998                         Con_DPrintf("ED_ParseEpair: Can't find field %s\n", s);
 999                         return false;
1000                 }
1001                 //val->_int = G_INT(def->ofs); // AK Please check this - seems to be an org. quake bug
1002                 val->_int = def->ofs;
1003                 break;
1004
1005         case ev_function:
1006                 func = ED_FindFunction(s);
1007                 if (!func)
1008                 {
1009                         Con_Printf("ED_ParseEpair: Can't find function %s\n", s);
1010                         return false;
1011                 }
1012                 val->function = func - pr_functions;
1013                 break;
1014
1015         default:
1016                 Con_Printf("ED_ParseEpair: Unknown key->type %i for key \"%s\"\n", key->type, PR_GetString(key->s_name));
1017                 return false;
1018         }
1019         return true;
1020 }
1021
1022 /*
1023 ====================
1024 ED_ParseEdict
1025
1026 Parses an edict out of the given string, returning the new position
1027 ed should be a properly initialized empty edict.
1028 Used for initial level load and for savegames.
1029 ====================
1030 */
1031 const char *ED_ParseEdict (const char *data, edict_t *ent)
1032 {
1033         ddef_t *key;
1034         qboolean anglehack;
1035         qboolean init;
1036         char keyname[256];
1037         int n;
1038
1039         init = false;
1040
1041 // clear it
1042         if (ent != sv.edicts)   // hack
1043                 memset (ent->v, 0, progs->entityfields * 4);
1044
1045 // go through all the dictionary pairs
1046         while (1)
1047         {
1048         // parse key
1049                 if (!COM_ParseToken(&data, false))
1050                         Host_Error ("ED_ParseEntity: EOF without closing brace");
1051                 if (com_token[0] == '}')
1052                         break;
1053
1054                 // anglehack is to allow QuakeEd to write single scalar angles
1055                 // and allow them to be turned into vectors. (FIXME...)
1056                 anglehack = !strcmp (com_token, "angle");
1057                 if (anglehack)
1058                         strlcpy (com_token, "angles", sizeof (com_token));
1059
1060                 // FIXME: change light to _light to get rid of this hack
1061                 if (!strcmp(com_token, "light"))
1062                         strlcpy (com_token, "light_lev", sizeof (com_token));   // hack for single light def
1063
1064                 strlcpy (keyname, com_token, sizeof (keyname));
1065
1066                 // another hack to fix heynames with trailing spaces
1067                 n = strlen(keyname);
1068                 while (n && keyname[n-1] == ' ')
1069                 {
1070                         keyname[n-1] = 0;
1071                         n--;
1072                 }
1073
1074         // parse value
1075                 if (!COM_ParseToken(&data, false))
1076                         Host_Error ("ED_ParseEntity: EOF without closing brace");
1077
1078                 if (com_token[0] == '}')
1079                         Host_Error ("ED_ParseEntity: closing brace without data");
1080
1081                 init = true;
1082
1083 // keynames with a leading underscore are used for utility comments,
1084 // and are immediately discarded by quake
1085                 if (keyname[0] == '_')
1086                         continue;
1087
1088                 key = ED_FindField (keyname);
1089                 if (!key)
1090                 {
1091                         Con_DPrintf("'%s' is not a field\n", keyname);
1092                         continue;
1093                 }
1094
1095                 if (anglehack)
1096                 {
1097                         char    temp[32];
1098                         strlcpy (temp, com_token, sizeof (temp));
1099                         dpsnprintf (com_token, sizeof (com_token), "0 %s 0", temp);
1100                 }
1101
1102                 if (!ED_ParseEpair(ent, key, com_token))
1103                         Host_Error ("ED_ParseEdict: parse error");
1104         }
1105
1106         if (!init)
1107                 ent->e->free = true;
1108
1109         return data;
1110 }
1111
1112
1113 /*
1114 ================
1115 ED_LoadFromFile
1116
1117 The entities are directly placed in the array, rather than allocated with
1118 ED_Alloc, because otherwise an error loading the map would have entity
1119 number references out of order.
1120
1121 Creates a server's entity / program execution context by
1122 parsing textual entity definitions out of an ent file.
1123
1124 Used for both fresh maps and savegame loads.  A fresh map would also need
1125 to call ED_CallSpawnFunctions () to let the objects initialize themselves.
1126 ================
1127 */
1128 void ED_LoadFromFile (const char *data)
1129 {
1130         edict_t *ent;
1131         int parsed, inhibited, spawned, died;
1132         mfunction_t *func;
1133
1134         ent = NULL;
1135         parsed = 0;
1136         inhibited = 0;
1137         spawned = 0;
1138         died = 0;
1139         pr_global_struct->time = sv.time;
1140
1141 // parse ents
1142         while (1)
1143         {
1144 // parse the opening brace
1145                 if (!COM_ParseToken(&data, false))
1146                         break;
1147                 if (com_token[0] != '{')
1148                         Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
1149
1150                 if (!ent)
1151                         ent = EDICT_NUM(0);
1152                 else
1153                         ent = ED_Alloc ();
1154                 data = ED_ParseEdict (data, ent);
1155                 parsed++;
1156
1157 // remove things from different skill levels or deathmatch
1158                 if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
1159                 {
1160                         if (deathmatch.integer)
1161                         {
1162                                 if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
1163                                 {
1164                                         ED_Free (ent);
1165                                         inhibited++;
1166                                         continue;
1167                                 }
1168                         }
1169                         else if ((current_skill <= 0 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_EASY  ))
1170                                 || (current_skill == 1 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_MEDIUM))
1171                                 || (current_skill >= 2 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_HARD  )))
1172                         {
1173                                 ED_Free (ent);
1174                                 inhibited++;
1175                                 continue;
1176                         }
1177                 }
1178 //
1179 // immediately call spawn function
1180 //
1181                 if (!ent->v->classname)
1182                 {
1183                         Con_Print("No classname for:\n");
1184                         ED_Print(ent);
1185                         ED_Free (ent);
1186                         continue;
1187                 }
1188
1189         // look for the spawn function
1190                 func = ED_FindFunction (PR_GetString(ent->v->classname));
1191
1192                 if (!func)
1193                 {
1194                         if (developer.integer) // don't confuse non-developers with errors
1195                         {
1196                                 Con_Print("No spawn function for:\n");
1197                                 ED_Print(ent);
1198                         }
1199                         ED_Free (ent);
1200                         continue;
1201                 }
1202
1203                 pr_global_struct->self = EDICT_TO_PROG(ent);
1204                 PR_ExecuteProgram (func - pr_functions, "QC function spawn is missing");
1205                 spawned++;
1206                 if (ent->e->free)
1207                         died++;
1208         }
1209
1210         Con_DPrintf("%i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", parsed, inhibited, spawned, died, spawned - died);
1211 }
1212
1213
1214 typedef struct dpfield_s
1215 {
1216         int type;
1217         char *string;
1218 }
1219 dpfield_t;
1220
1221 #define DPFIELDS (sizeof(dpfields) / sizeof(dpfield_t))
1222
1223 dpfield_t dpfields[] =
1224 {
1225         {ev_entity, "cursor_trace_ent"},
1226         {ev_entity, "drawonlytoclient"},
1227         {ev_entity, "exteriormodeltoclient"},
1228         {ev_entity, "nodrawtoclient"},
1229         {ev_entity, "tag_entity"},
1230         {ev_entity, "viewmodelforclient"},
1231         {ev_float, "alpha"},
1232         {ev_float, "ammo_cells1"},
1233         {ev_float, "ammo_lava_nails"},
1234         {ev_float, "ammo_multi_rockets"},
1235         {ev_float, "ammo_nails1"},
1236         {ev_float, "ammo_plasma"},
1237         {ev_float, "ammo_rockets1"},
1238         {ev_float, "ammo_shells1"},
1239         {ev_float, "button3"},
1240         {ev_float, "button4"},
1241         {ev_float, "button5"},
1242         {ev_float, "button6"},
1243         {ev_float, "button7"},
1244         {ev_float, "button8"},
1245         {ev_float, "buttonchat"},
1246         {ev_float, "buttonuse"},
1247         {ev_float, "clientcolors"},
1248         {ev_float, "cursor_active"},
1249         {ev_float, "fullbright"},
1250         {ev_float, "glow_color"},
1251         {ev_float, "glow_size"},
1252         {ev_float, "glow_trail"},
1253         {ev_float, "gravity"},
1254         {ev_float, "idealpitch"},
1255         {ev_float, "items2"},
1256         {ev_float, "light_lev"},
1257         {ev_float, "pflags"},
1258         {ev_float, "ping"},
1259         {ev_float, "pitch_speed"},
1260         {ev_float, "pmodel"},
1261         {ev_float, "renderamt"}, // HalfLife support
1262         {ev_float, "rendermode"}, // HalfLife support
1263         {ev_float, "scale"},
1264         {ev_float, "style"},
1265         {ev_float, "tag_index"},
1266         {ev_float, "viewzoom"},
1267         {ev_vector, "color"},
1268         {ev_vector, "colormod"},
1269         {ev_vector, "cursor_screen"},
1270         {ev_vector, "cursor_trace_endpos"},
1271         {ev_vector, "cursor_trace_start"},
1272         {ev_vector, "movement"},
1273         {ev_vector, "punchvector"},
1274         {ev_string, "playermodel"},
1275         {ev_string, "playerskin"}
1276 };
1277
1278 /*
1279 ===============
1280 PR_LoadProgs
1281 ===============
1282 */
1283 extern void PR_Cmd_Reset (void);
1284 void PR_LoadProgs (const char *progsname)
1285 {
1286         int i;
1287         dstatement_t *st;
1288         ddef_t *infielddefs;
1289         dfunction_t *dfunctions;
1290
1291         if (!progsname || !*progsname)
1292                 Host_Error("PR_LoadProgs: passed empty progsname");
1293
1294 // flush the non-C variable lookup cache
1295         for (i=0 ; i<GEFV_CACHESIZE ; i++)
1296                 gefvCache[i].field[0] = 0;
1297
1298         PR_FreeAll();
1299
1300         progs = (dprograms_t *)FS_LoadFile (progsname, serverprogs_mempool, false);
1301         if (!progs)
1302                 Host_Error ("PR_LoadProgs: couldn't load %s", progsname);
1303
1304         Con_DPrintf("Programs occupy %iK.\n", fs_filesize/1024);
1305
1306         pr_crc = CRC_Block((qbyte *)progs, fs_filesize);
1307
1308 // byte swap the header
1309         for (i = 0;i < (int) sizeof(*progs) / 4;i++)
1310                 ((int *)progs)[i] = LittleLong ( ((int *)progs)[i] );
1311
1312         if (progs->version != PROG_VERSION)
1313                 Host_Error ("progs.dat has wrong version number (%i should be %i)", progs->version, PROG_VERSION);
1314         if (progs->crc != PROGHEADER_CRC && progs->crc != 32401) // tenebrae crc also allowed
1315                 Host_Error ("progs.dat system vars have been modified, progdefs.h is out of date");
1316
1317         //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
1318         dfunctions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
1319
1320         pr_strings = (char *)progs + progs->ofs_strings;
1321         pr_stringssize = 0;
1322         for (i = 0;i < progs->numstrings;i++)
1323         {
1324                 if (progs->ofs_strings + pr_stringssize >= fs_filesize)
1325                         Host_Error ("progs.dat strings go past end of file\n");
1326                 pr_stringssize += strlen (pr_strings + pr_stringssize) + 1;
1327         }
1328         pr_numknownstrings = 0;
1329         pr_maxknownstrings = 0;
1330         pr_knownstrings = NULL;
1331
1332         pr_globaldefs = (ddef_t *)((qbyte *)progs + progs->ofs_globaldefs);
1333
1334         // we need to expand the fielddefs list to include all the engine fields,
1335         // so allocate a new place for it
1336         infielddefs = (ddef_t *)((qbyte *)progs + progs->ofs_fielddefs);
1337         pr_fielddefs = PR_Alloc((progs->numfielddefs + DPFIELDS) * sizeof(ddef_t));
1338         pr_functions = PR_Alloc(sizeof(mfunction_t) * progs->numfunctions);
1339
1340         pr_statements = (dstatement_t *)((qbyte *)progs + progs->ofs_statements);
1341
1342         // moved edict_size calculation down below field adding code
1343
1344         pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals);
1345         pr_globals = (float *)pr_global_struct;
1346
1347 // byte swap the lumps
1348         for (i=0 ; i<progs->numstatements ; i++)
1349         {
1350                 pr_statements[i].op = LittleShort(pr_statements[i].op);
1351                 pr_statements[i].a = LittleShort(pr_statements[i].a);
1352                 pr_statements[i].b = LittleShort(pr_statements[i].b);
1353                 pr_statements[i].c = LittleShort(pr_statements[i].c);
1354         }
1355
1356         for (i = 0;i < progs->numfunctions;i++)
1357         {
1358                 pr_functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
1359                 pr_functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
1360                 pr_functions[i].s_name = LittleLong (dfunctions[i].s_name);
1361                 pr_functions[i].s_file = LittleLong (dfunctions[i].s_file);
1362                 pr_functions[i].numparms = LittleLong (dfunctions[i].numparms);
1363                 pr_functions[i].locals = LittleLong (dfunctions[i].locals);
1364                 memcpy(pr_functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
1365         }
1366
1367         for (i=0 ; i<progs->numglobaldefs ; i++)
1368         {
1369                 pr_globaldefs[i].type = LittleShort (pr_globaldefs[i].type);
1370                 pr_globaldefs[i].ofs = LittleShort (pr_globaldefs[i].ofs);
1371                 pr_globaldefs[i].s_name = LittleLong (pr_globaldefs[i].s_name);
1372         }
1373
1374         // copy the progs fields to the new fields list
1375         for (i = 0;i < progs->numfielddefs;i++)
1376         {
1377                 pr_fielddefs[i].type = LittleShort (infielddefs[i].type);
1378                 if (pr_fielddefs[i].type & DEF_SAVEGLOBAL)
1379                         Host_Error ("PR_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL");
1380                 pr_fielddefs[i].ofs = LittleShort (infielddefs[i].ofs);
1381                 pr_fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
1382         }
1383
1384         // append the darkplaces fields
1385         for (i = 0;i < (int) DPFIELDS;i++)
1386         {
1387                 pr_fielddefs[progs->numfielddefs].type = dpfields[i].type;
1388                 pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields;
1389                 pr_fielddefs[progs->numfielddefs].s_name = PR_SetEngineString(dpfields[i].string);
1390                 if (pr_fielddefs[progs->numfielddefs].type == ev_vector)
1391                         progs->entityfields += 3;
1392                 else
1393                         progs->entityfields++;
1394                 progs->numfielddefs++;
1395         }
1396
1397         for (i=0 ; i<progs->numglobals ; i++)
1398                 ((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);
1399
1400         // moved edict_size calculation down here, below field adding code
1401         // LordHavoc: this no longer includes the edict_t header
1402         pr_edict_size = progs->entityfields * 4;
1403         pr_edictareasize = pr_edict_size * MAX_EDICTS;
1404
1405         // LordHavoc: bounds check anything static
1406         for (i = 0,st = pr_statements;i < progs->numstatements;i++,st++)
1407         {
1408                 switch (st->op)
1409                 {
1410                 case OP_IF:
1411                 case OP_IFNOT:
1412                         if ((unsigned short) st->a >= progs->numglobals || st->b + i < 0 || st->b + i >= progs->numstatements)
1413                                 Host_Error("PR_LoadProgs: out of bounds IF/IFNOT (statement %d)\n", i);
1414                         break;
1415                 case OP_GOTO:
1416                         if (st->a + i < 0 || st->a + i >= progs->numstatements)
1417                                 Host_Error("PR_LoadProgs: out of bounds GOTO (statement %d)\n", i);
1418                         break;
1419                 // global global global
1420                 case OP_ADD_F:
1421                 case OP_ADD_V:
1422                 case OP_SUB_F:
1423                 case OP_SUB_V:
1424                 case OP_MUL_F:
1425                 case OP_MUL_V:
1426                 case OP_MUL_FV:
1427                 case OP_MUL_VF:
1428                 case OP_DIV_F:
1429                 case OP_BITAND:
1430                 case OP_BITOR:
1431                 case OP_GE:
1432                 case OP_LE:
1433                 case OP_GT:
1434                 case OP_LT:
1435                 case OP_AND:
1436                 case OP_OR:
1437                 case OP_EQ_F:
1438                 case OP_EQ_V:
1439                 case OP_EQ_S:
1440                 case OP_EQ_E:
1441                 case OP_EQ_FNC:
1442                 case OP_NE_F:
1443                 case OP_NE_V:
1444                 case OP_NE_S:
1445                 case OP_NE_E:
1446                 case OP_NE_FNC:
1447                 case OP_ADDRESS:
1448                 case OP_LOAD_F:
1449                 case OP_LOAD_FLD:
1450                 case OP_LOAD_ENT:
1451                 case OP_LOAD_S:
1452                 case OP_LOAD_FNC:
1453                 case OP_LOAD_V:
1454                         if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->b >= progs->numglobals || (unsigned short) st->c >= progs->numglobals)
1455                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1456                         break;
1457                 // global none global
1458                 case OP_NOT_F:
1459                 case OP_NOT_V:
1460                 case OP_NOT_S:
1461                 case OP_NOT_FNC:
1462                 case OP_NOT_ENT:
1463                         if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->c >= progs->numglobals)
1464                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1465                         break;
1466                 // 2 globals
1467                 case OP_STOREP_F:
1468                 case OP_STOREP_ENT:
1469                 case OP_STOREP_FLD:
1470                 case OP_STOREP_S:
1471                 case OP_STOREP_FNC:
1472                 case OP_STORE_F:
1473                 case OP_STORE_ENT:
1474                 case OP_STORE_FLD:
1475                 case OP_STORE_S:
1476                 case OP_STORE_FNC:
1477                 case OP_STATE:
1478                 case OP_STOREP_V:
1479                 case OP_STORE_V:
1480                         if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->b >= progs->numglobals)
1481                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1482                         break;
1483                 // 1 global
1484                 case OP_CALL0:
1485                 case OP_CALL1:
1486                 case OP_CALL2:
1487                 case OP_CALL3:
1488                 case OP_CALL4:
1489                 case OP_CALL5:
1490                 case OP_CALL6:
1491                 case OP_CALL7:
1492                 case OP_CALL8:
1493                 case OP_DONE:
1494                 case OP_RETURN:
1495                         if ((unsigned short) st->a >= progs->numglobals)
1496                                 Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
1497                         break;
1498                 default:
1499                         Host_Error("PR_LoadProgs: unknown opcode %d at statement %d\n", st->op, i);
1500                         break;
1501                 }
1502         }
1503
1504         FindEdictFieldOffsets(); // LordHavoc: update field offset list
1505         PR_Execute_ProgsLoaded();
1506         PR_Cmd_Reset();
1507 }
1508
1509
1510 void PR_Fields_f (void)
1511 {
1512         int i, j, ednum, used, usedamount;
1513         int *counts;
1514         const char *name;
1515         char tempstring[5000], tempstring2[260];
1516         edict_t *ed;
1517         ddef_t *d;
1518         int *v;
1519         if (!sv.active)
1520         {
1521                 Con_Print("no progs loaded\n");
1522                 return;
1523         }
1524         counts = Mem_Alloc(tempmempool, progs->numfielddefs * sizeof(int));
1525         for (ednum = 0;ednum < sv.max_edicts;ednum++)
1526         {
1527                 ed = EDICT_NUM(ednum);
1528                 if (ed->e->free)
1529                         continue;
1530                 for (i = 1;i < progs->numfielddefs;i++)
1531                 {
1532                         d = &pr_fielddefs[i];
1533                         name = PR_GetString(d->s_name);
1534                         if (name[strlen(name)-2] == '_')
1535                                 continue;       // skip _x, _y, _z vars
1536                         v = (int *)((char *)ed->v + d->ofs*4);
1537                         // if the value is still all 0, skip the field
1538                         for (j = 0;j < type_size[d->type & ~DEF_SAVEGLOBAL];j++)
1539                         {
1540                                 if (v[j])
1541                                 {
1542                                         counts[i]++;
1543                                         break;
1544                                 }
1545                         }
1546                 }
1547         }
1548         used = 0;
1549         usedamount = 0;
1550         tempstring[0] = 0;
1551         for (i = 0;i < progs->numfielddefs;i++)
1552         {
1553                 d = &pr_fielddefs[i];
1554                 name = PR_GetString(d->s_name);
1555                 if (name[strlen(name)-2] == '_')
1556                         continue;       // skip _x, _y, _z vars
1557                 switch(d->type & ~DEF_SAVEGLOBAL)
1558                 {
1559                 case ev_string:
1560                         strlcat (tempstring, "string   ", sizeof (tempstring));
1561                         break;
1562                 case ev_entity:
1563                         strlcat (tempstring, "entity   ", sizeof (tempstring));
1564                         break;
1565                 case ev_function:
1566                         strlcat (tempstring, "function ", sizeof (tempstring));
1567                         break;
1568                 case ev_field:
1569                         strlcat (tempstring, "field    ", sizeof (tempstring));
1570                         break;
1571                 case ev_void:
1572                         strlcat (tempstring, "void     ", sizeof (tempstring));
1573                         break;
1574                 case ev_float:
1575                         strlcat (tempstring, "float    ", sizeof (tempstring));
1576                         break;
1577                 case ev_vector:
1578                         strlcat (tempstring, "vector   ", sizeof (tempstring));
1579                         break;
1580                 case ev_pointer:
1581                         strlcat (tempstring, "pointer  ", sizeof (tempstring));
1582                         break;
1583                 default:
1584                         dpsnprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
1585                         strlcat (tempstring, tempstring2, sizeof (tempstring));
1586                         break;
1587                 }
1588                 if (strlen(name) > 256)
1589                 {
1590                         memcpy(tempstring2, name, 256);
1591                         tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
1592                         tempstring2[259] = 0;
1593                         name = tempstring2;
1594                 }
1595                 strcat (tempstring, name);
1596                 for (j = strlen(name);j < 25;j++)
1597                         strcat(tempstring, " ");
1598                 dpsnprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]);
1599                 strlcat (tempstring, tempstring2, sizeof (tempstring));
1600                 strlcat (tempstring, "\n", sizeof (tempstring));
1601                 if (strlen(tempstring) >= 4096)
1602                 {
1603                         Con_Print(tempstring);
1604                         tempstring[0] = 0;
1605                 }
1606                 if (counts[i])
1607                 {
1608                         used++;
1609                         usedamount += type_size[d->type & ~DEF_SAVEGLOBAL];
1610                 }
1611         }
1612         Mem_Free(counts);
1613         Con_Printf("%i entity fields (%i in use), totalling %i bytes per edict (%i in use), %i edicts allocated, %i bytes total spent on edict fields (%i needed)\n", progs->entityfields, used, progs->entityfields * 4, usedamount * 4, sv.max_edicts, progs->entityfields * 4 * sv.max_edicts, usedamount * 4 * sv.max_edicts);
1614 }
1615
1616 void PR_Globals_f (void)
1617 {
1618         int i;
1619         if (!sv.active)
1620         {
1621                 Con_Print("no progs loaded\n");
1622                 return;
1623         }
1624         for (i = 0;i < progs->numglobaldefs;i++)
1625                 Con_Printf("%s\n", PR_GetString(pr_globaldefs[i].s_name));
1626         Con_Printf("%i global variables, totalling %i bytes\n", progs->numglobals, progs->numglobals * 4);
1627 }
1628
1629 /*
1630 ===============
1631 PR_Init
1632 ===============
1633 */
1634 extern void PR_Cmd_Init(void);
1635 void PR_Init (void)
1636 {
1637         Cmd_AddCommand ("edict", ED_PrintEdict_f);
1638         Cmd_AddCommand ("edicts", ED_PrintEdicts);
1639         Cmd_AddCommand ("edictcount", ED_Count);
1640         Cmd_AddCommand ("edictset", ED_EdictSet_f);
1641         Cmd_AddCommand ("profile", PR_Profile_f);
1642         Cmd_AddCommand ("pr_fields", PR_Fields_f);
1643         Cmd_AddCommand ("pr_globals", PR_Globals_f);
1644         Cvar_RegisterVariable (&pr_checkextension);
1645         Cvar_RegisterVariable (&nomonsters);
1646         Cvar_RegisterVariable (&gamecfg);
1647         Cvar_RegisterVariable (&scratch1);
1648         Cvar_RegisterVariable (&scratch2);
1649         Cvar_RegisterVariable (&scratch3);
1650         Cvar_RegisterVariable (&scratch4);
1651         Cvar_RegisterVariable (&savedgamecfg);
1652         Cvar_RegisterVariable (&saved1);
1653         Cvar_RegisterVariable (&saved2);
1654         Cvar_RegisterVariable (&saved3);
1655         Cvar_RegisterVariable (&saved4);
1656         // LordHavoc: for DarkPlaces, this overrides the number of decors (shell casings, gibs, etc)
1657         Cvar_RegisterVariable (&decors);
1658         // LordHavoc: Nehahra uses these to pass data around cutscene demos
1659         if (gamemode == GAME_NEHAHRA)
1660         {
1661                 Cvar_RegisterVariable (&nehx00);Cvar_RegisterVariable (&nehx01);
1662                 Cvar_RegisterVariable (&nehx02);Cvar_RegisterVariable (&nehx03);
1663                 Cvar_RegisterVariable (&nehx04);Cvar_RegisterVariable (&nehx05);
1664                 Cvar_RegisterVariable (&nehx06);Cvar_RegisterVariable (&nehx07);
1665                 Cvar_RegisterVariable (&nehx08);Cvar_RegisterVariable (&nehx09);
1666                 Cvar_RegisterVariable (&nehx10);Cvar_RegisterVariable (&nehx11);
1667                 Cvar_RegisterVariable (&nehx12);Cvar_RegisterVariable (&nehx13);
1668                 Cvar_RegisterVariable (&nehx14);Cvar_RegisterVariable (&nehx15);
1669                 Cvar_RegisterVariable (&nehx16);Cvar_RegisterVariable (&nehx17);
1670                 Cvar_RegisterVariable (&nehx18);Cvar_RegisterVariable (&nehx19);
1671         }
1672         Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
1673         // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
1674         Cvar_RegisterVariable (&pr_boundscheck);
1675         Cvar_RegisterVariable (&pr_traceqc);
1676
1677         serverprogs_mempool = Mem_AllocPool("server progs", 0, NULL);
1678
1679         PR_Cmd_Init();
1680 }
1681
1682 /*
1683 ===============
1684 PR_Shutdown
1685 ===============
1686 */
1687 extern void PR_Cmd_Shutdown(void);
1688 void PR_Shutdown (void)
1689 {
1690         PR_Cmd_Shutdown();
1691
1692         Mem_FreePool(&serverprogs_mempool);
1693 }
1694
1695 void *_PR_Alloc(size_t buffersize, const char *filename, int fileline)
1696 {
1697         return _Mem_Alloc(serverprogs_mempool, buffersize, filename, fileline);
1698 }
1699
1700 void _PR_Free(void *buffer, const char *filename, int fileline)
1701 {
1702         _Mem_Free(buffer, filename, fileline);
1703 }
1704
1705 void _PR_FreeAll(const char *filename, int fileline)
1706 {
1707         progs = NULL;
1708         pr_fielddefs = NULL;
1709         pr_functions = NULL;
1710         _Mem_EmptyPool(serverprogs_mempool, filename, fileline);
1711 }
1712
1713 // LordHavoc: turned EDICT_NUM into a #define for speed reasons
1714 edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline)
1715 {
1716         Host_Error ("EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline);
1717         return NULL;
1718 }
1719
1720 /*
1721 int NUM_FOR_EDICT_ERROR(edict_t *e)
1722 {
1723         Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts);
1724         return 0;
1725 }
1726
1727 int NUM_FOR_EDICT(edict_t *e)
1728 {
1729         int n;
1730         n = e - sv.edicts;
1731         if ((unsigned int)n >= MAX_EDICTS)
1732                 Host_Error ("NUM_FOR_EDICT: bad pointer");
1733         return n;
1734 }
1735
1736 //int NoCrash_NUM_FOR_EDICT(edict_t *e)
1737 //{
1738 //      return e - sv.edicts;
1739 //}
1740
1741 //#define       EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields))
1742 //#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4)))
1743 int EDICT_TO_PROG(edict_t *e)
1744 {
1745         int n;
1746         n = e - sv.edicts;
1747         if ((unsigned int)n >= (unsigned int)sv.max_edicts)
1748                 Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts);
1749         return n;// EXPERIMENTAL
1750         //return (qbyte *)e->v - (qbyte *)sv.edictsfields;
1751 }
1752 edict_t *PROG_TO_EDICT(int n)
1753 {
1754         if ((unsigned int)n >= (unsigned int)sv.max_edicts)
1755                 Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n);
1756         return sv.edicts + n; // EXPERIMENTAL
1757         //return sv.edicts + ((n) / (progs->entityfields * 4));
1758 }
1759 */
1760
1761 const char *PR_GetString(int num)
1762 {
1763         if (num >= 0 && num < pr_stringssize)
1764                 return pr_strings + num;
1765         else if (num < 0 && num >= -pr_numknownstrings)
1766         {
1767                 num = -1 - num;
1768                 if (!pr_knownstrings[num])
1769                         Host_Error("PR_GetString: attempt to get string that is already freed\n");
1770                 return pr_knownstrings[num];
1771         }
1772         else
1773         {
1774                 Host_Error("PR_GetString: invalid string offset %i\n", num);
1775                 return "";
1776         }
1777 }
1778
1779 int PR_SetQCString(const char *s)
1780 {
1781         int i;
1782         if (!s)
1783                 return 0;
1784         if (s >= pr_strings && s <= pr_strings + pr_stringssize)
1785                 return s - pr_strings;
1786         for (i = 0;i < pr_numknownstrings;i++)
1787                 if (pr_knownstrings[i] == s)
1788                         return -1 - i;
1789         Host_Error("PR_SetQCString: unknown string\n");
1790         return -1 - i;
1791 }
1792
1793 int PR_SetEngineString(const char *s)
1794 {
1795         int i;
1796         if (!s)
1797                 return 0;
1798         if (s >= pr_strings && s <= pr_strings + pr_stringssize)
1799                 Host_Error("PR_SetEngineString: s in pr_strings area\n");
1800         for (i = 0;i < pr_numknownstrings;i++)
1801                 if (pr_knownstrings[i] == s)
1802                         return -1 - i;
1803         // new unknown engine string
1804         if (developer.integer >= 3)
1805                 Con_Printf("new engine string %p\n", s);
1806         for (i = 0;i < pr_numknownstrings;i++)
1807                 if (!pr_knownstrings[i])
1808                         break;
1809         if (i >= pr_numknownstrings)
1810         {
1811                 if (i >= pr_maxknownstrings)
1812                 {
1813                         const char **oldstrings = pr_knownstrings;
1814                         pr_maxknownstrings += 128;
1815                         pr_knownstrings = PR_Alloc(pr_maxknownstrings * sizeof(char *));
1816                         if (pr_numknownstrings)
1817                                 memcpy((char **)pr_knownstrings, oldstrings, pr_numknownstrings * sizeof(char *));
1818                 }
1819                 pr_numknownstrings++;
1820         }
1821         pr_knownstrings[i] = s;
1822         return -1 - i;
1823 }
1824
1825 char *PR_AllocString(int bufferlength)
1826 {
1827         int i;
1828         if (!bufferlength)
1829                 return 0;
1830         for (i = 0;i < pr_numknownstrings;i++)
1831                 if (!pr_knownstrings[i])
1832                         break;
1833         if (i >= pr_numknownstrings)
1834         {
1835                 if (i >= pr_maxknownstrings)
1836                 {
1837                         const char **oldstrings = pr_knownstrings;
1838                         pr_maxknownstrings += 128;
1839                         pr_knownstrings = PR_Alloc(pr_maxknownstrings * sizeof(char *));
1840                         if (pr_numknownstrings)
1841                                 memcpy((char **)pr_knownstrings, oldstrings, pr_numknownstrings * sizeof(char *));
1842                 }
1843                 pr_numknownstrings++;
1844         }
1845         return (char *)(pr_knownstrings[i] = PR_Alloc(bufferlength));
1846 }
1847
1848 void PR_FreeString(char *s)
1849 {
1850         int i;
1851         if (!s)
1852                 Host_Error("PR_FreeString: attempt to free a NULL string\n");
1853         if (s >= pr_strings && s <= pr_strings + pr_stringssize)
1854                 Host_Error("PR_FreeString: attempt to free a constant string\n");
1855         for (i = 0;i < pr_numknownstrings;i++)
1856                 if (pr_knownstrings[i] == s)
1857                         break;
1858         if (i == pr_numknownstrings)
1859                 Host_Error("PR_FreeString: attempt to free a non-existent or already freed string\n");
1860         PR_Free((char *)pr_knownstrings[i]);
1861         pr_knownstrings[i] = NULL;
1862 }
1863