X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=pr_edict.c;h=c789469f4979a2e32c9bedc66b8ce81bf0905b07;hp=f327bac204ebffe4230b9de2d3d6299cfac11877;hb=ac947d2fbb445473c266390a1fca26c8be8611c4;hpb=8dcce44300385b12c46d494c06aadcfa35a8bc14 diff --git a/pr_edict.c b/pr_edict.c index f327bac2..c789469f 100644 --- a/pr_edict.c +++ b/pr_edict.c @@ -8,7 +8,7 @@ of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -22,7 +22,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" dprograms_t *progs; -dfunction_t *pr_functions; +mfunction_t *pr_functions; char *pr_strings; ddef_t *pr_fielddefs; ddef_t *pr_globaldefs; @@ -32,38 +32,44 @@ float *pr_globals; // same as pr_global_struct int pr_edict_size; // in bytes int pr_edictareasize; // LordHavoc: in bytes -unsigned short pr_crc; +unsigned short pr_crc; + +mempool_t *progs_mempool; +mempool_t *edictstring_mempool; int type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4}; -ddef_t *ED_FieldAtOfs (int ofs); -qboolean ED_ParseEpair (void *base, ddef_t *key, char *s); - -cvar_t nomonsters = {"nomonsters", "0"}; -cvar_t gamecfg = {"gamecfg", "0"}; -cvar_t scratch1 = {"scratch1", "0"}; -cvar_t scratch2 = {"scratch2", "0"}; -cvar_t scratch3 = {"scratch3", "0"}; -cvar_t scratch4 = {"scratch4", "0"}; -cvar_t savedgamecfg = {"savedgamecfg", "0", true}; -cvar_t saved1 = {"saved1", "0", true}; -cvar_t saved2 = {"saved2", "0", true}; -cvar_t saved3 = {"saved3", "0", true}; -cvar_t saved4 = {"saved4", "0", true}; -cvar_t decors = {"decors", "0"}; -cvar_t nehx00 = {"nehx00", "0"};cvar_t nehx01 = {"nehx01", "0"}; -cvar_t nehx02 = {"nehx02", "0"};cvar_t nehx03 = {"nehx03", "0"}; -cvar_t nehx04 = {"nehx04", "0"};cvar_t nehx05 = {"nehx05", "0"}; -cvar_t nehx06 = {"nehx06", "0"};cvar_t nehx07 = {"nehx07", "0"}; -cvar_t nehx08 = {"nehx08", "0"};cvar_t nehx09 = {"nehx09", "0"}; -cvar_t nehx10 = {"nehx10", "0"};cvar_t nehx11 = {"nehx11", "0"}; -cvar_t nehx12 = {"nehx12", "0"};cvar_t nehx13 = {"nehx13", "0"}; -cvar_t nehx14 = {"nehx14", "0"};cvar_t nehx15 = {"nehx15", "0"}; -cvar_t nehx16 = {"nehx16", "0"};cvar_t nehx17 = {"nehx17", "0"}; -cvar_t nehx18 = {"nehx18", "0"};cvar_t nehx19 = {"nehx19", "0"}; -cvar_t cutscene = {"cutscene", "1"}; +ddef_t *ED_FieldAtOfs(int ofs); +qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s); + +cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1"}; +cvar_t nomonsters = {0, "nomonsters", "0"}; +cvar_t gamecfg = {0, "gamecfg", "0"}; +cvar_t scratch1 = {0, "scratch1", "0"}; +cvar_t scratch2 = {0,"scratch2", "0"}; +cvar_t scratch3 = {0, "scratch3", "0"}; +cvar_t scratch4 = {0, "scratch4", "0"}; +cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0"}; +cvar_t saved1 = {CVAR_SAVE, "saved1", "0"}; +cvar_t saved2 = {CVAR_SAVE, "saved2", "0"}; +cvar_t saved3 = {CVAR_SAVE, "saved3", "0"}; +cvar_t saved4 = {CVAR_SAVE, "saved4", "0"}; +cvar_t decors = {0, "decors", "0"}; +cvar_t nehx00 = {0, "nehx00", "0"};cvar_t nehx01 = {0, "nehx01", "0"}; +cvar_t nehx02 = {0, "nehx02", "0"};cvar_t nehx03 = {0, "nehx03", "0"}; +cvar_t nehx04 = {0, "nehx04", "0"};cvar_t nehx05 = {0, "nehx05", "0"}; +cvar_t nehx06 = {0, "nehx06", "0"};cvar_t nehx07 = {0, "nehx07", "0"}; +cvar_t nehx08 = {0, "nehx08", "0"};cvar_t nehx09 = {0, "nehx09", "0"}; +cvar_t nehx10 = {0, "nehx10", "0"};cvar_t nehx11 = {0, "nehx11", "0"}; +cvar_t nehx12 = {0, "nehx12", "0"};cvar_t nehx13 = {0, "nehx13", "0"}; +cvar_t nehx14 = {0, "nehx14", "0"};cvar_t nehx15 = {0, "nehx15", "0"}; +cvar_t nehx16 = {0, "nehx16", "0"};cvar_t nehx17 = {0, "nehx17", "0"}; +cvar_t nehx18 = {0, "nehx18", "0"};cvar_t nehx19 = {0, "nehx19", "0"}; +cvar_t cutscene = {0, "cutscene", "1"}; // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others)) -cvar_t pr_boundscheck = {"pr_boundscheck", "1"}; +cvar_t pr_boundscheck = {0, "pr_boundscheck", "1"}; +// LordHavoc: prints every opcode as it executes - warning: this is significant spew +cvar_t pr_traceqc = {0, "pr_traceqc", "0"}; #define MAX_FIELD_LEN 64 #define GEFV_CACHESIZE 2 @@ -75,8 +81,8 @@ typedef struct { static gefv_cache gefvCache[GEFV_CACHESIZE] = {{NULL, ""}, {NULL, ""}}; -ddef_t *ED_FindField (char *name); -dfunction_t *ED_FindFunction (char *name); +ddef_t *ED_FindField (const char *name); +mfunction_t *ED_FindFunction (const char *name); // LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue... these are defined as externs in progs.h int eval_gravity; @@ -86,12 +92,16 @@ int eval_button5; int eval_button6; int eval_button7; int eval_button8; +int eval_buttonuse; +int eval_buttonchat; int eval_glow_size; int eval_glow_trail; int eval_glow_color; int eval_items2; int eval_scale; int eval_alpha; +int eval_renderamt; // HalfLife support +int eval_rendermode; // HalfLife support int eval_fullbright; int eval_ammo_shells1; int eval_ammo_nails1; @@ -104,15 +114,35 @@ int eval_idealpitch; int eval_pitch_speed; int eval_viewmodelforclient; int eval_nodrawtoclient; +int eval_exteriormodeltoclient; int eval_drawonlytoclient; -int eval_colormod; int eval_ping; int eval_movement; +int eval_pmodel; +int eval_punchvector; +int eval_viewzoom; +int eval_clientcolors; +int eval_tag_entity; +int eval_tag_index; +int eval_light_lev; +int eval_color; +int eval_style; +int eval_pflags; +int eval_cursor_active; +int eval_cursor_screen; +int eval_cursor_trace_start; +int eval_cursor_trace_endpos; +int eval_cursor_trace_ent; +int eval_colormod; +int eval_playermodel; +int eval_playerskin; -dfunction_t *SV_PlayerPhysicsQC; -dfunction_t *EndFrameQC; +mfunction_t *SV_PlayerPhysicsQC; +mfunction_t *EndFrameQC; +//KrimZon - SERVER COMMANDS IN QUAKEC +mfunction_t *SV_ParseClientCommandQC; -int FindFieldOffset(char *field) +int FindFieldOffset(const char *field) { ddef_t *d; d = ED_FindField(field); @@ -121,7 +151,7 @@ int FindFieldOffset(char *field) return d->ofs*4; } -void FindEdictFieldOffsets() +void FindEdictFieldOffsets(void) { eval_gravity = FindFieldOffset("gravity"); eval_button3 = FindFieldOffset("button3"); @@ -130,12 +160,16 @@ void FindEdictFieldOffsets() eval_button6 = FindFieldOffset("button6"); eval_button7 = FindFieldOffset("button7"); eval_button8 = FindFieldOffset("button8"); + eval_buttonuse = FindFieldOffset("buttonuse"); + eval_buttonchat = FindFieldOffset("buttonchat"); eval_glow_size = FindFieldOffset("glow_size"); eval_glow_trail = FindFieldOffset("glow_trail"); eval_glow_color = FindFieldOffset("glow_color"); eval_items2 = FindFieldOffset("items2"); eval_scale = FindFieldOffset("scale"); eval_alpha = FindFieldOffset("alpha"); + eval_renderamt = FindFieldOffset("renderamt"); // HalfLife support + eval_rendermode = FindFieldOffset("rendermode"); // HalfLife support eval_fullbright = FindFieldOffset("fullbright"); eval_ammo_shells1 = FindFieldOffset("ammo_shells1"); eval_ammo_nails1 = FindFieldOffset("ammo_nails1"); @@ -148,16 +182,36 @@ void FindEdictFieldOffsets() eval_pitch_speed = FindFieldOffset("pitch_speed"); eval_viewmodelforclient = FindFieldOffset("viewmodelforclient"); eval_nodrawtoclient = FindFieldOffset("nodrawtoclient"); + eval_exteriormodeltoclient = FindFieldOffset("exteriormodeltoclient"); eval_drawonlytoclient = FindFieldOffset("drawonlytoclient"); - eval_colormod = FindFieldOffset("colormod"); eval_ping = FindFieldOffset("ping"); eval_movement = FindFieldOffset("movement"); + eval_pmodel = FindFieldOffset("pmodel"); + eval_punchvector = FindFieldOffset("punchvector"); + eval_viewzoom = FindFieldOffset("viewzoom"); + eval_clientcolors = FindFieldOffset("clientcolors"); + eval_tag_entity = FindFieldOffset("tag_entity"); + eval_tag_index = FindFieldOffset("tag_index"); + eval_light_lev = FindFieldOffset("light_lev"); + eval_color = FindFieldOffset("color"); + eval_style = FindFieldOffset("style"); + eval_pflags = FindFieldOffset("pflags"); + eval_cursor_active = FindFieldOffset("cursor_active"); + eval_cursor_screen = FindFieldOffset("cursor_screen"); + eval_cursor_trace_start = FindFieldOffset("cursor_trace_start"); + eval_cursor_trace_endpos = FindFieldOffset("cursor_trace_endpos"); + eval_cursor_trace_ent = FindFieldOffset("cursor_trace_ent"); + eval_colormod = FindFieldOffset("colormod"); + eval_playermodel = FindFieldOffset("playermodel"); + eval_playerskin = FindFieldOffset("playerskin"); // LordHavoc: allowing QuakeC to override the player movement code SV_PlayerPhysicsQC = ED_FindFunction ("SV_PlayerPhysics"); // LordHavoc: support for endframe EndFrameQC = ED_FindFunction ("EndFrame"); -}; + //KrimZon - SERVER COMMANDS IN QUAKEC + SV_ParseClientCommandQC = ED_FindFunction ("SV_ParseClientCommand"); +} /* ================= @@ -168,8 +222,29 @@ Sets everything to NULL */ void ED_ClearEdict (edict_t *e) { - memset (&e->v, 0, progs->entityfields * 4); - e->free = false; + int num; + memset (e->v, 0, progs->entityfields * 4); + e->e->free = false; + // LordHavoc: for consistency set these here + num = NUM_FOR_EDICT(e) - 1; + if (num >= 0 && num < svs.maxclients) + { + eval_t *val; + // set colormap and team on newly created player entity + e->v->colormap = num + 1; + e->v->team = (svs.clients[num].colors & 15) + 1; + // set netname/clientcolors back to client values so that + // DP_SV_CLIENTNAME and DPV_SV_CLIENTCOLORS will not immediately + // reset them + e->v->netname = PR_SetString(svs.clients[num].name); + if ((val = GETEDICTFIELDVALUE(e, eval_clientcolors))) + val->_float = svs.clients[num].colors; + // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN + if( eval_playermodel ) + GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PR_SetString(svs.clients[num].playermodel); + if( eval_playerskin ) + GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PR_SetString(svs.clients[num].playerskin); + } } /* @@ -188,22 +263,24 @@ edict_t *ED_Alloc (void) int i; edict_t *e; - for ( i=svs.maxclients+1 ; ifree && ( e->freetime < 2 || sv.time - e->freetime > 0.5 ) ) + if (e->e->free && ( e->e->freetime < 2 || sv.time - e->e->freetime > 0.5 ) ) { ED_ClearEdict (e); return e; } } - + if (i == MAX_EDICTS) - Sys_Error ("ED_Alloc: no free edicts"); - + Host_Error ("ED_Alloc: no free edicts"); + sv.num_edicts++; + if (sv.num_edicts >= sv.max_edicts) + SV_IncreaseEdicts(); e = EDICT_NUM(i); ED_ClearEdict (e); @@ -222,19 +299,19 @@ void ED_Free (edict_t *ed) { SV_UnlinkEdict (ed); // unlink from world bsp - ed->free = true; - ed->v.model = 0; - ed->v.takedamage = 0; - ed->v.modelindex = 0; - ed->v.colormap = 0; - ed->v.skin = 0; - ed->v.frame = 0; - VectorCopy (vec3_origin, ed->v.origin); - VectorCopy (vec3_origin, ed->v.angles); - ed->v.nextthink = -1; - ed->v.solid = 0; - - ed->freetime = sv.time; + ed->e->free = true; + ed->v->model = 0; + ed->v->takedamage = 0; + ed->v->modelindex = 0; + ed->v->colormap = 0; + ed->v->skin = 0; + ed->v->frame = 0; + VectorClear(ed->v->origin); + VectorClear(ed->v->angles); + ed->v->nextthink = -1; + ed->v->solid = 0; + + ed->e->freetime = sv.time; } //=========================================================================== @@ -248,7 +325,7 @@ ddef_t *ED_GlobalAtOfs (int ofs) { ddef_t *def; int i; - + for (i=0 ; inumglobaldefs ; i++) { def = &pr_globaldefs[i]; @@ -267,7 +344,7 @@ ddef_t *ED_FieldAtOfs (int ofs) { ddef_t *def; int i; - + for (i=0 ; inumfielddefs ; i++) { def = &pr_fielddefs[i]; @@ -282,35 +359,34 @@ ddef_t *ED_FieldAtOfs (int ofs) ED_FindField ============ */ -ddef_t *ED_FindField (char *name) +ddef_t *ED_FindField (const char *name) { - ddef_t *def; - int i; - + ddef_t *def; + int i; + for (i=0 ; inumfielddefs ; i++) { def = &pr_fielddefs[i]; - if (!strcmp(pr_strings + def->s_name,name) ) + if (!strcmp(PR_GetString(def->s_name), name)) return def; } return NULL; } - /* ============ ED_FindGlobal ============ */ -ddef_t *ED_FindGlobal (char *name) +ddef_t *ED_FindGlobal (const char *name) { - ddef_t *def; - int i; - + ddef_t *def; + int i; + for (i=0 ; inumglobaldefs ; i++) { def = &pr_globaldefs[i]; - if (!strcmp(pr_strings + def->s_name,name) ) + if (!strcmp(PR_GetString(def->s_name), name)) return def; } return NULL; @@ -322,54 +398,21 @@ ddef_t *ED_FindGlobal (char *name) ED_FindFunction ============ */ -dfunction_t *ED_FindFunction (char *name) +mfunction_t *ED_FindFunction (const char *name) { - dfunction_t *func; + mfunction_t *func; int i; - + for (i=0 ; inumfunctions ; i++) { func = &pr_functions[i]; - if (!strcmp(pr_strings + func->s_name,name) ) + if (!strcmp(PR_GetString(func->s_name), name)) return func; } return NULL; } -/* -eval_t *GetEdictFieldValue(edict_t *ed, char *field) -{ - ddef_t *def = NULL; - int i; - static int rep = 0; - - for (i=0 ; iv + def->ofs*4); -} -*/ - /* ============ PR_ValueString @@ -377,47 +420,56 @@ PR_ValueString Returns a string describing *data in a type specific manner ============= */ +//int NoCrash_NUM_FOR_EDICT(edict_t *e); char *PR_ValueString (etype_t type, eval_t *val) { - static char line[256]; - ddef_t *def; - dfunction_t *f; - + static char line[1024]; // LordHavoc: enlarged a bit (was 256) + ddef_t *def; + mfunction_t *f; + int n; + type &= ~DEF_SAVEGLOBAL; switch (type) { case ev_string: - sprintf (line, "%s", pr_strings + val->string); + strlcpy (line, PR_GetString (val->string), sizeof (line)); break; - case ev_entity: - sprintf (line, "entity %i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)) ); + case ev_entity: + //n = NoCrash_NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)); + n = val->edict; + if (n < 0 || n >= MAX_EDICTS) + snprintf (line, sizeof (line), "entity %i (invalid!)", n); + else + snprintf (line, sizeof (line), "entity %i", n); break; case ev_function: f = pr_functions + val->function; - sprintf (line, "%s()", pr_strings + f->s_name); + snprintf (line, sizeof (line), "%s()", PR_GetString(f->s_name)); break; case ev_field: def = ED_FieldAtOfs ( val->_int ); - sprintf (line, ".%s", pr_strings + def->s_name); + snprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name)); break; case ev_void: - sprintf (line, "void"); + snprintf (line, sizeof (line), "void"); break; case ev_float: - sprintf (line, "%5.1f", val->_float); + // LordHavoc: changed from %5.1f to %10.4f + snprintf (line, sizeof (line), "%10.4f", val->_float); break; case ev_vector: - sprintf (line, "'%5.1f %5.1f %5.1f'", val->vector[0], val->vector[1], val->vector[2]); + // LordHavoc: changed from %5.1f to %10.4f + snprintf (line, sizeof (line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]); break; case ev_pointer: - sprintf (line, "pointer"); + snprintf (line, sizeof (line), "pointer"); break; default: - sprintf (line, "bad type %i", type); + snprintf (line, sizeof (line), "bad type %i", type); break; } - + return line; } @@ -431,42 +483,64 @@ Easier to parse than PR_ValueString */ char *PR_UglyValueString (etype_t type, eval_t *val) { - static char line[256]; - ddef_t *def; - dfunction_t *f; - + static char line[4096]; + int i; + char *s; + ddef_t *def; + mfunction_t *f; + type &= ~DEF_SAVEGLOBAL; switch (type) { case ev_string: - sprintf (line, "%s", pr_strings + val->string); + // Parse the string a bit to turn special characters + // (like newline, specifically) into escape codes, + // this fixes saving games from various mods + s = PR_GetString (val->string); + for (i = 0;i < (int)sizeof(line) - 2 && *s;) + { + if (*s == '\n') + { + line[i++] = '\\'; + line[i++] = 'n'; + } + else if (*s == '\r') + { + line[i++] = '\\'; + line[i++] = 'r'; + } + else + line[i++] = *s; + s++; + } + line[i] = '\0'; break; - case ev_entity: - sprintf (line, "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict))); + case ev_entity: + snprintf (line, sizeof (line), "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict))); break; case ev_function: f = pr_functions + val->function; - sprintf (line, "%s", pr_strings + f->s_name); + strlcpy (line, PR_GetString (f->s_name), sizeof (line)); break; case ev_field: def = ED_FieldAtOfs ( val->_int ); - sprintf (line, "%s", pr_strings + def->s_name); + snprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name)); break; case ev_void: - sprintf (line, "void"); + snprintf (line, sizeof (line), "void"); break; case ev_float: - sprintf (line, "%f", val->_float); + snprintf (line, sizeof (line), "%f", val->_float); break; case ev_vector: - sprintf (line, "%f %f %f", val->vector[0], val->vector[1], val->vector[2]); + snprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]); break; default: - sprintf (line, "bad type %i", type); + snprintf (line, sizeof (line), "bad type %i", type); break; } - + return line; } @@ -485,22 +559,22 @@ char *PR_GlobalString (int ofs) ddef_t *def; void *val; static char line[128]; - + val = (void *)&pr_globals[ofs]; def = ED_GlobalAtOfs(ofs); if (!def) - sprintf (line,"%i(???)", ofs); + snprintf (line, sizeof (line), "%i(?)", ofs); else { s = PR_ValueString (def->type, val); - sprintf (line,"%i(%s)%s", ofs, pr_strings + def->s_name, s); + snprintf (line, sizeof (line), "%i(%s)%s", ofs, PR_GetString(def->s_name), s); } - + i = strlen(line); for ( ; i<20 ; i++) - strcat (line," "); - strcat (line," "); - + strlcat (line, " ", sizeof (line)); + strlcat (line, " ", sizeof (line)); + return line; } @@ -509,18 +583,18 @@ char *PR_GlobalStringNoContents (int ofs) int i; ddef_t *def; static char line[128]; - + def = ED_GlobalAtOfs(ofs); if (!def) - sprintf (line,"%i(???)", ofs); + snprintf (line, sizeof (line), "%i(?)", ofs); else - sprintf (line,"%i(%s)", ofs, pr_strings + def->s_name); - + snprintf (line, sizeof (line), "%i(%s)", ofs, PR_GetString(def->s_name)); + i = strlen(line); for ( ; i<20 ; i++) - strcat (line," "); - strcat (line," "); - + strlcat (line, " ", sizeof (line)); + strlcat (line, " ", sizeof (line)); + return line; } @@ -532,8 +606,9 @@ ED_Print For debugging ============= */ -// LordHavoc: optimized this to print out much more quickly -void ED_Print (edict_t *ed) +// LordHavoc: optimized this to print out much more quickly (tempstring) +// LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print) +void ED_Print(edict_t *ed) { int l; ddef_t *d; @@ -541,43 +616,64 @@ void ED_Print (edict_t *ed) int i, j; char *name; int type; - char tempstring[8192]; // temporary string buffer + char tempstring[8192], tempstring2[260]; // temporary string buffers - if (ed->free) + if (ed->e->free) { - Con_Printf ("FREE\n"); + Con_Print("FREE\n"); return; } tempstring[0] = 0; - sprintf(tempstring, "\nEDICT %i:\n", NUM_FOR_EDICT(ed)); + snprintf (tempstring, sizeof (tempstring), "\nEDICT %i:\n", NUM_FOR_EDICT(ed)); for (i=1 ; inumfielddefs ; i++) { d = &pr_fielddefs[i]; - name = pr_strings + d->s_name; + name = PR_GetString(d->s_name); if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - - v = (int *)((char *)&ed->v + d->ofs*4); + + v = (int *)((char *)ed->v + d->ofs*4); // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; - + for (j=0 ; j 256) + { + memcpy (tempstring2, name, 256); + tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; + tempstring2[259] = 0; + name = tempstring2; + } + strlcat (tempstring, name, sizeof (tempstring)); + for (l = strlen(name);l < 14;l++) strcat(tempstring, " "); + strcat(tempstring, " "); - strcat(tempstring, PR_ValueString(d->type, (eval_t *)v)); - strcat(tempstring, "\n"); + name = PR_ValueString(d->type, (eval_t *)v); + if (strlen(name) > 256) + { + memcpy(tempstring2, name, 256); + tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; + tempstring2[259] = 0; + name = tempstring2; + } + strlcat (tempstring, name, sizeof (tempstring)); + strlcat (tempstring, "\n", sizeof (tempstring)); + if (strlen(tempstring) >= 4096) + { + Con_Print(tempstring); + tempstring[0] = 0; + } } - Con_Printf(tempstring); + if (tempstring[0]) + Con_Print(tempstring); } /* @@ -587,7 +683,7 @@ ED_Write For savegames ============= */ -void ED_Write (FILE *f, edict_t *ed) +void ED_Write (qfile_t *f, edict_t *ed) { ddef_t *d; int *v; @@ -595,22 +691,22 @@ void ED_Write (FILE *f, edict_t *ed) char *name; int type; - fprintf (f, "{\n"); + FS_Print(f, "{\n"); - if (ed->free) + if (ed->e->free) { - fprintf (f, "}\n"); + FS_Print(f, "}\n"); return; } - + for (i=1 ; inumfielddefs ; i++) { d = &pr_fielddefs[i]; - name = pr_strings + d->s_name; + name = PR_GetString(d->s_name); if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - - v = (int *)((char *)&ed->v + d->ofs*4); + + v = (int *)((char *)ed->v + d->ofs*4); // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; @@ -619,17 +715,17 @@ void ED_Write (FILE *f, edict_t *ed) break; if (j == type_size[type]) continue; - - fprintf (f,"\"%s\" ",name); - fprintf (f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v)); + + FS_Printf(f,"\"%s\" ",name); + FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v)); } - fprintf (f, "}\n"); + FS_Print(f, "}\n"); } void ED_PrintNum (int ent) { - ED_Print (EDICT_NUM(ent)); + ED_Print(EDICT_NUM(ent)); } /* @@ -642,8 +738,8 @@ For debugging, prints all the entities in the current server void ED_PrintEdicts (void) { int i; - - Con_Printf ("%i entities\n", sv.num_edicts); + + Con_Printf("%i entities\n", sv.num_edicts); for (i=0 ; i= sv.num_edicts) + if (i < 0 || i >= sv.num_edicts) { - Con_Printf("Bad edict number\n"); + Con_Print("Bad edict number\n"); return; } ED_PrintNum (i); @@ -685,22 +781,22 @@ void ED_Count (void) for (i=0 ; ifree) + if (ent->e->free) continue; active++; - if (ent->v.solid) + if (ent->v->solid) solid++; - if (ent->v.model) + if (ent->v->model) models++; - if (ent->v.movetype == MOVETYPE_STEP) + if (ent->v->movetype == MOVETYPE_STEP) step++; } - Con_Printf ("num_edicts:%3i\n", sv.num_edicts); - Con_Printf ("active :%3i\n", active); - Con_Printf ("view :%3i\n", models); - Con_Printf ("touch :%3i\n", solid); - Con_Printf ("step :%3i\n", step); + Con_Printf("num_edicts:%3i\n", sv.num_edicts); + Con_Printf("active :%3i\n", active); + Con_Printf("view :%3i\n", models); + Con_Printf("touch :%3i\n", solid); + Con_Printf("step :%3i\n", step); } @@ -718,14 +814,14 @@ FIXME: need to tag constants, doesn't really work ED_WriteGlobals ============= */ -void ED_WriteGlobals (FILE *f) +void ED_WriteGlobals (qfile_t *f) { ddef_t *def; int i; char *name; int type; - fprintf (f,"{\n"); + FS_Print(f,"{\n"); for (i=0 ; inumglobaldefs ; i++) { def = &pr_globaldefs[i]; @@ -734,16 +830,42 @@ void ED_WriteGlobals (FILE *f) continue; type &= ~DEF_SAVEGLOBAL; - if (type != ev_string - && type != ev_float - && type != ev_entity) + if (type != ev_string && type != ev_float && type != ev_entity) continue; - name = pr_strings + def->s_name; - fprintf (f,"\"%s\" ", name); - fprintf (f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs])); + name = PR_GetString(def->s_name); + FS_Printf(f,"\"%s\" ", name); + FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs])); + } + FS_Print(f,"}\n"); +} + +/* +============= +ED_EdictSet_f + +Console command to set a field of a specified edict +============= +*/ +void ED_EdictSet_f(void) +{ + edict_t *ed; + ddef_t *key; + + if(Cmd_Argc() != 4) + { + Con_Print("edictset \n"); + return; + } + ed = EDICT_NUM(atoi(Cmd_Argv(1))); + + if((key = ED_FindField(Cmd_Argv(2))) == 0) + { + Con_Printf("Key %s not found !\n", Cmd_Argv(2)); + return; } - fprintf (f,"}\n"); + + ED_ParseEpair(ed, key, Cmd_Argv(3)); } /* @@ -751,25 +873,23 @@ void ED_WriteGlobals (FILE *f) ED_ParseGlobals ============= */ -void ED_ParseGlobals (char *data) +void ED_ParseGlobals (const char *data) { - char keyname[64]; - ddef_t *key; + char keyname[1024]; // LordHavoc: good idea? bad idea? was 64 + ddef_t *key; while (1) - { - // parse key - data = COM_Parse (data); + { + // parse key + if (!COM_ParseToken(&data, false)) + Host_Error ("ED_ParseEntity: EOF without closing brace"); if (com_token[0] == '}') break; - if (!data) - Host_Error ("ED_ParseEntity: EOF without closing brace"); strcpy (keyname, com_token); - // parse value - data = COM_Parse (data); - if (!data) + // parse value + if (!COM_ParseToken(&data, false)) Host_Error ("ED_ParseEntity: EOF without closing brace"); if (com_token[0] == '}') @@ -778,11 +898,11 @@ void ED_ParseGlobals (char *data) key = ED_FindGlobal (keyname); if (!key) { - Con_DPrintf ("'%s' is not a global\n", keyname); + Con_DPrintf("'%s' is not a global\n", keyname); continue; } - if (!ED_ParseEpair ((void *)pr_globals, key, com_token)) + if (!ED_ParseEpair(NULL, key, com_token)) Host_Error ("ED_ParseGlobals: parse error"); } } @@ -795,13 +915,13 @@ void ED_ParseGlobals (char *data) ED_NewString ============= */ -char *ED_NewString (char *string) +char *ED_NewString (const char *string) { - char *new, *new_p; - int i,l; - + char *new, *new_p; + int i,l; + l = strlen(string) + 1; - new = Hunk_Alloc (l); + new = Mem_Alloc(edictstring_mempool, l); new_p = new; for (i=0 ; i< l ; i++) @@ -817,7 +937,7 @@ char *ED_NewString (char *string) else *new_p++ = string[i]; } - + return new; } @@ -830,69 +950,81 @@ Can parse either fields or globals returns false if error ============= */ -qboolean ED_ParseEpair (void *base, ddef_t *key, char *s) +qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s) { - int i; - char string[128]; - ddef_t *def; - char *v, *w; - void *d; - dfunction_t *func; - - d = (void *)((int *)base + key->ofs); - + int i; + ddef_t *def; + eval_t *val; + mfunction_t *func; + + if (ent) + val = (eval_t *)((int *)ent->v + key->ofs); + else + val = (eval_t *)((int *)pr_globals + key->ofs); switch (key->type & ~DEF_SAVEGLOBAL) { case ev_string: - *(string_t *)d = ED_NewString (s) - pr_strings; + val->string = PR_SetString(ED_NewString(s)); break; - + case ev_float: - *(float *)d = atof (s); + while (*s && *s <= ' ') + s++; + val->_float = atof(s); break; - + case ev_vector: - strcpy (string, s); - v = string; - w = string; - for (i=0 ; i<3 ; i++) + for (i = 0;i < 3;i++) { - while (*v && *v != ' ') - v++; - *v = 0; - ((float *)d)[i] = atof (w); - w = v = v+1; + while (*s && *s <= ' ') + s++; + if (*s) + val->vector[i] = atof(s); + else + val->vector[i] = 0; + while (*s > ' ') + s++; } break; - + case ev_entity: - *(int *)d = EDICT_TO_PROG(EDICT_NUM(atoi (s))); + while (*s && *s <= ' ') + s++; + i = atoi(s); + if (i < 0 || i >= MAX_EDICTS) + Con_Printf("ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i)\n", i, MAX_EDICTS); + while (i >= sv.max_edicts) + SV_IncreaseEdicts(); + // if SV_IncreaseEdicts was called the base pointer needs to be updated + if (ent) + val = (eval_t *)((int *)ent->v + key->ofs); + val->edict = EDICT_TO_PROG(EDICT_NUM(i)); break; - + case ev_field: - def = ED_FindField (s); + def = ED_FindField(s); if (!def) { - // LordHavoc: don't warn about worldspawn sky/fog fields because they don't require mod support - if (strcmp(s, "sky") && strncmp(s, "fog_", 4) && strcmp(s, "skyboxsize")) - Con_DPrintf ("Can't find field %s\n", s); + Con_DPrintf("ED_ParseEpair: Can't find field %s\n", s); return false; } - *(int *)d = G_INT(def->ofs); + //val->_int = G_INT(def->ofs); // AK Please check this - seems to be an org. quake bug + val->_int = def->ofs; break; - + case ev_function: - func = ED_FindFunction (s); + func = ED_FindFunction(s); if (!func) { - Con_DPrintf ("Can't find function %s\n", s); + Con_Printf("ED_ParseEpair: Can't find function %s\n", s); return false; } - *(func_t *)d = func - pr_functions; + val->function = func - pr_functions; break; - + default: - break; + Con_Printf("ED_ParseEpair: Unknown key->type %i for key \"%s\"\n", key->type, PR_GetString(key->s_name)); + return false; } return true; } @@ -906,45 +1038,40 @@ ed should be a properly initialized empty edict. Used for initial level load and for savegames. ==================== */ -char *ED_ParseEdict (char *data, edict_t *ent) +const char *ED_ParseEdict (const char *data, edict_t *ent) { - ddef_t *key; - qboolean anglehack; - qboolean init; - char keyname[256]; - int n; + ddef_t *key; + qboolean anglehack; + qboolean init; + char keyname[256]; + int n; init = false; // clear it if (ent != sv.edicts) // hack - memset (&ent->v, 0, progs->entityfields * 4); + memset (ent->v, 0, progs->entityfields * 4); // go through all the dictionary pairs while (1) - { + { // parse key - data = COM_Parse (data); + if (!COM_ParseToken(&data, false)) + Host_Error ("ED_ParseEntity: EOF without closing brace"); if (com_token[0] == '}') break; - if (!data) - Host_Error ("ED_ParseEntity: EOF without closing brace"); - -// anglehack is to allow QuakeEd to write single scalar angles -// and allow them to be turned into vectors. (FIXME...) -if (!strcmp(com_token, "angle")) -{ - strcpy (com_token, "angles"); - anglehack = true; -} -else - anglehack = false; -// FIXME: change light to _light to get rid of this hack -if (!strcmp(com_token, "light")) - strcpy (com_token, "light_lev"); // hack for single light def + // anglehack is to allow QuakeEd to write single scalar angles + // and allow them to be turned into vectors. (FIXME...) + anglehack = !strcmp (com_token, "angle"); + if (anglehack) + strlcpy (com_token, "angles", sizeof (com_token)); - strcpy (keyname, com_token); + // FIXME: change light to _light to get rid of this hack + if (!strcmp(com_token, "light")) + strlcpy (com_token, "light_lev", sizeof (com_token)); // hack for single light def + + strlcpy (keyname, com_token, sizeof (keyname)); // another hack to fix heynames with trailing spaces n = strlen(keyname); @@ -954,41 +1081,40 @@ if (!strcmp(com_token, "light")) n--; } - // parse value - data = COM_Parse (data); - if (!data) + // parse value + if (!COM_ParseToken(&data, false)) Host_Error ("ED_ParseEntity: EOF without closing brace"); if (com_token[0] == '}') Host_Error ("ED_ParseEntity: closing brace without data"); - init = true; + init = true; // keynames with a leading underscore are used for utility comments, // and are immediately discarded by quake if (keyname[0] == '_') continue; - + key = ED_FindField (keyname); if (!key) { - Con_DPrintf ("'%s' is not a field\n", keyname); + Con_DPrintf("'%s' is not a field\n", keyname); continue; } -if (anglehack) -{ -char temp[32]; -strcpy (temp, com_token); -sprintf (com_token, "0 %s 0", temp); -} + if (anglehack) + { + char temp[32]; + strlcpy (temp, com_token, sizeof (temp)); + snprintf (com_token, sizeof (com_token), "0 %s 0", temp); + } - if (!ED_ParseEpair ((void *)&ent->v, key, com_token)) + if (!ED_ParseEpair(ent, key, com_token)) Host_Error ("ED_ParseEdict: parse error"); } if (!init) - ent->free = true; + ent->e->free = true; return data; } @@ -1009,126 +1135,210 @@ Used for both fresh maps and savegame loads. A fresh map would also need to call ED_CallSpawnFunctions () to let the objects initialize themselves. ================ */ -void ED_LoadFromFile (char *data) -{ - edict_t *ent; - int inhibit; - dfunction_t *func; - +void ED_LoadFromFile (const char *data) +{ + edict_t *ent; + int parsed, inhibited, spawned, died; + mfunction_t *func; + ent = NULL; - inhibit = 0; + parsed = 0; + inhibited = 0; + spawned = 0; + died = 0; pr_global_struct->time = sv.time; - + // parse ents while (1) { -// parse the opening brace - data = COM_Parse (data); - if (!data) +// parse the opening brace + if (!COM_ParseToken(&data, false)) break; if (com_token[0] != '{') - Sys_Error ("ED_LoadFromFile: found %s when expecting {",com_token); + Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token); if (!ent) ent = EDICT_NUM(0); else ent = ED_Alloc (); data = ED_ParseEdict (data, ent); + parsed++; // remove things from different skill levels or deathmatch - if (deathmatch.value) + if (deathmatch.integer) { - if (((int)ent->v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH)) + if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH)) { - ED_Free (ent); - inhibit++; + ED_Free (ent); + inhibited++; continue; } } - else if ((current_skill == 0 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_EASY )) - || (current_skill == 1 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_MEDIUM)) - || (current_skill >= 2 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_HARD ))) + else if ((current_skill == 0 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_EASY )) + || (current_skill == 1 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_MEDIUM)) + || (current_skill >= 2 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_HARD ))) { - ED_Free (ent); - inhibit++; + ED_Free (ent); + inhibited++; continue; } // // immediately call spawn function // - if (!ent->v.classname) + if (!ent->v->classname) { - Con_Printf ("No classname for:\n"); - ED_Print (ent); + Con_Print("No classname for:\n"); + ED_Print(ent); ED_Free (ent); continue; } // look for the spawn function - func = ED_FindFunction ( pr_strings + ent->v.classname ); + func = ED_FindFunction (PR_GetString(ent->v->classname)); if (!func) { - if (developer.value) // don't confuse non-developers with errors + if (developer.integer) // don't confuse non-developers with errors { - Con_Printf ("No spawn function for:\n"); - ED_Print (ent); + Con_Print("No spawn function for:\n"); + ED_Print(ent); } ED_Free (ent); continue; } pr_global_struct->self = EDICT_TO_PROG(ent); - PR_ExecuteProgram (func - pr_functions); - } + PR_ExecuteProgram (func - pr_functions, "QC function spawn is missing"); + spawned++; + if (ent->e->free) + died++; + } - Con_DPrintf ("%i entities inhibited\n", inhibit); + Con_DPrintf("%i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", parsed, inhibited, spawned, died, spawned - died); } +typedef struct dpfield_s +{ + int type; + char *string; +} +dpfield_t; + +#define DPFIELDS (sizeof(dpfields) / sizeof(dpfield_t)) + +dpfield_t dpfields[] = +{ + {ev_entity, "cursor_trace_ent"}, + {ev_entity, "drawonlytoclient"}, + {ev_entity, "exteriormodeltoclient"}, + {ev_entity, "nodrawtoclient"}, + {ev_entity, "tag_entity"}, + {ev_entity, "viewmodelforclient"}, + {ev_float, "alpha"}, + {ev_float, "ammo_cells1"}, + {ev_float, "ammo_lava_nails"}, + {ev_float, "ammo_multi_rockets"}, + {ev_float, "ammo_nails1"}, + {ev_float, "ammo_plasma"}, + {ev_float, "ammo_rockets1"}, + {ev_float, "ammo_shells1"}, + {ev_float, "button3"}, + {ev_float, "button4"}, + {ev_float, "button5"}, + {ev_float, "button6"}, + {ev_float, "button7"}, + {ev_float, "button8"}, + {ev_float, "buttonchat"}, + {ev_float, "buttonuse"}, + {ev_float, "clientcolors"}, + {ev_float, "cursor_active"}, + {ev_float, "fullbright"}, + {ev_float, "glow_color"}, + {ev_float, "glow_size"}, + {ev_float, "glow_trail"}, + {ev_float, "gravity"}, + {ev_float, "idealpitch"}, + {ev_float, "items2"}, + {ev_float, "light_lev"}, + {ev_float, "pflags"}, + {ev_float, "ping"}, + {ev_float, "pitch_speed"}, + {ev_float, "pmodel"}, + {ev_float, "renderamt"}, // HalfLife support + {ev_float, "rendermode"}, // HalfLife support + {ev_float, "scale"}, + {ev_float, "style"}, + {ev_float, "tag_index"}, + {ev_float, "viewzoom"}, + {ev_vector, "color"}, + {ev_vector, "colormod"}, + {ev_vector, "cursor_screen"}, + {ev_vector, "cursor_trace_endpos"}, + {ev_vector, "cursor_trace_start"}, + {ev_vector, "movement"}, + {ev_vector, "punchvector"}, + {ev_string, "playermodel"}, + {ev_string, "playerskin"} +}; + /* =============== PR_LoadProgs =============== */ -void PR_LoadProgs (void) +extern void PR_Cmd_Reset (void); +void PR_LoadProgs (const char *progsname) { - int i; + int i; dstatement_t *st; + ddef_t *infielddefs; + dfunction_t *dfunctions; + + if (!progsname || !*progsname) + Host_Error("PR_LoadProgs: passed empty progsname"); // flush the non-C variable lookup cache for (i=0 ; iversion != PROG_VERSION) Host_Error ("progs.dat has wrong version number (%i should be %i)", progs->version, PROG_VERSION); - if (progs->crc != PROGHEADER_CRC) + if (progs->crc != PROGHEADER_CRC && progs->crc != 32401) // tenebrae crc also allowed Host_Error ("progs.dat system vars have been modified, progdefs.h is out of date"); - pr_functions = (dfunction_t *)((byte *)progs + progs->ofs_functions); + //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions); + dfunctions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions); pr_strings = (char *)progs + progs->ofs_strings; - pr_globaldefs = (ddef_t *)((byte *)progs + progs->ofs_globaldefs); - pr_fielddefs = (ddef_t *)((byte *)progs + progs->ofs_fielddefs); - pr_statements = (dstatement_t *)((byte *)progs + progs->ofs_statements); + pr_globaldefs = (ddef_t *)((qbyte *)progs + progs->ofs_globaldefs); - pr_global_struct = (globalvars_t *)((byte *)progs + progs->ofs_globals); - pr_globals = (float *)pr_global_struct; - - pr_edict_size = progs->entityfields * 4 + sizeof (edict_t) - sizeof(entvars_t); + // we need to expand the fielddefs list to include all the engine fields, + // so allocate a new place for it + infielddefs = (ddef_t *)((qbyte *)progs + progs->ofs_fielddefs); + pr_fielddefs = Mem_Alloc(progs_mempool, (progs->numfielddefs + DPFIELDS) * sizeof(ddef_t)); - pr_edictareasize = pr_edict_size * MAX_EDICTS; + pr_statements = (dstatement_t *)((qbyte *)progs + progs->ofs_statements); + + // moved edict_size calculation down below field adding code + + pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals); + pr_globals = (float *)pr_global_struct; // byte swap the lumps for (i=0 ; inumstatements ; i++) @@ -1139,15 +1349,17 @@ void PR_LoadProgs (void) pr_statements[i].c = LittleShort(pr_statements[i].c); } - for (i=0 ; inumfunctions; i++) + pr_functions = Mem_Alloc(progs_mempool, sizeof(mfunction_t) * progs->numfunctions); + for (i = 0;i < progs->numfunctions;i++) { - pr_functions[i].first_statement = LittleLong (pr_functions[i].first_statement); - pr_functions[i].parm_start = LittleLong (pr_functions[i].parm_start); - pr_functions[i].s_name = LittleLong (pr_functions[i].s_name); - pr_functions[i].s_file = LittleLong (pr_functions[i].s_file); - pr_functions[i].numparms = LittleLong (pr_functions[i].numparms); - pr_functions[i].locals = LittleLong (pr_functions[i].locals); - } + pr_functions[i].first_statement = LittleLong (dfunctions[i].first_statement); + pr_functions[i].parm_start = LittleLong (dfunctions[i].parm_start); + pr_functions[i].s_name = LittleLong (dfunctions[i].s_name); + pr_functions[i].s_file = LittleLong (dfunctions[i].s_file); + pr_functions[i].numparms = LittleLong (dfunctions[i].numparms); + pr_functions[i].locals = LittleLong (dfunctions[i].locals); + memcpy(pr_functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size)); + } for (i=0 ; inumglobaldefs ; i++) { @@ -1156,18 +1368,37 @@ void PR_LoadProgs (void) pr_globaldefs[i].s_name = LittleLong (pr_globaldefs[i].s_name); } - for (i=0 ; inumfielddefs ; i++) + // copy the progs fields to the new fields list + for (i = 0;i < progs->numfielddefs;i++) { - pr_fielddefs[i].type = LittleShort (pr_fielddefs[i].type); + pr_fielddefs[i].type = LittleShort (infielddefs[i].type); if (pr_fielddefs[i].type & DEF_SAVEGLOBAL) Host_Error ("PR_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL"); - pr_fielddefs[i].ofs = LittleShort (pr_fielddefs[i].ofs); - pr_fielddefs[i].s_name = LittleLong (pr_fielddefs[i].s_name); + pr_fielddefs[i].ofs = LittleShort (infielddefs[i].ofs); + pr_fielddefs[i].s_name = LittleLong (infielddefs[i].s_name); + } + + // append the darkplaces fields + for (i = 0;i < (int) DPFIELDS;i++) + { + pr_fielddefs[progs->numfielddefs].type = dpfields[i].type; + pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields; + pr_fielddefs[progs->numfielddefs].s_name = PR_SetString(dpfields[i].string); + if (pr_fielddefs[progs->numfielddefs].type == ev_vector) + progs->entityfields += 3; + else + progs->entityfields++; + progs->numfielddefs++; } for (i=0 ; inumglobals ; i++) ((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]); + // moved edict_size calculation down here, below field adding code + // LordHavoc: this no longer includes the edict_t header + pr_edict_size = progs->entityfields * 4; + pr_edictareasize = pr_edict_size * MAX_EDICTS; + // LordHavoc: bounds check anything static for (i = 0,st = pr_statements;i < progs->numstatements;i++,st++) { @@ -1268,20 +1499,145 @@ void PR_LoadProgs (void) } FindEdictFieldOffsets(); // LordHavoc: update field offset list + PR_Execute_ProgsLoaded(); + PR_Cmd_Reset(); +} + + +void PR_Fields_f (void) +{ + int i, j, ednum, used, usedamount; + int *counts; + char tempstring[5000], tempstring2[260], *name; + edict_t *ed; + ddef_t *d; + int *v; + if (!sv.active) + { + Con_Print("no progs loaded\n"); + return; + } + counts = Mem_Alloc(tempmempool, progs->numfielddefs * sizeof(int)); + for (ednum = 0;ednum < sv.max_edicts;ednum++) + { + ed = EDICT_NUM(ednum); + if (ed->e->free) + continue; + for (i = 1;i < progs->numfielddefs;i++) + { + d = &pr_fielddefs[i]; + name = PR_GetString(d->s_name); + if (name[strlen(name)-2] == '_') + continue; // skip _x, _y, _z vars + v = (int *)((char *)ed->v + d->ofs*4); + // if the value is still all 0, skip the field + for (j = 0;j < type_size[d->type & ~DEF_SAVEGLOBAL];j++) + { + if (v[j]) + { + counts[i]++; + break; + } + } + } + } + used = 0; + usedamount = 0; + tempstring[0] = 0; + for (i = 0;i < progs->numfielddefs;i++) + { + d = &pr_fielddefs[i]; + name = PR_GetString(d->s_name); + if (name[strlen(name)-2] == '_') + continue; // skip _x, _y, _z vars + switch(d->type & ~DEF_SAVEGLOBAL) + { + case ev_string: + strlcat (tempstring, "string ", sizeof (tempstring)); + break; + case ev_entity: + strlcat (tempstring, "entity ", sizeof (tempstring)); + break; + case ev_function: + strlcat (tempstring, "function ", sizeof (tempstring)); + break; + case ev_field: + strlcat (tempstring, "field ", sizeof (tempstring)); + break; + case ev_void: + strlcat (tempstring, "void ", sizeof (tempstring)); + break; + case ev_float: + strlcat (tempstring, "float ", sizeof (tempstring)); + break; + case ev_vector: + strlcat (tempstring, "vector ", sizeof (tempstring)); + break; + case ev_pointer: + strlcat (tempstring, "pointer ", sizeof (tempstring)); + break; + default: + snprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL); + strlcat (tempstring, tempstring2, sizeof (tempstring)); + break; + } + if (strlen(name) > 256) + { + memcpy(tempstring2, name, 256); + tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; + tempstring2[259] = 0; + name = tempstring2; + } + strcat (tempstring, name); + for (j = strlen(name);j < 25;j++) + strcat(tempstring, " "); + snprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]); + strlcat (tempstring, tempstring2, sizeof (tempstring)); + strlcat (tempstring, "\n", sizeof (tempstring)); + if (strlen(tempstring) >= 4096) + { + Con_Print(tempstring); + tempstring[0] = 0; + } + if (counts[i]) + { + used++; + usedamount += type_size[d->type & ~DEF_SAVEGLOBAL]; + } + } + Mem_Free(counts); + 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); } +void PR_Globals_f (void) +{ + int i; + if (!sv.active) + { + Con_Print("no progs loaded\n"); + return; + } + for (i = 0;i < progs->numglobaldefs;i++) + Con_Printf("%s\n", PR_GetString(pr_globaldefs[i].s_name)); + Con_Printf("%i global variables, totalling %i bytes\n", progs->numglobals, progs->numglobals * 4); +} /* =============== PR_Init =============== */ +extern void PR_Cmd_Init(void); void PR_Init (void) { Cmd_AddCommand ("edict", ED_PrintEdict_f); Cmd_AddCommand ("edicts", ED_PrintEdicts); Cmd_AddCommand ("edictcount", ED_Count); + Cmd_AddCommand ("edictset", ED_EdictSet_f); Cmd_AddCommand ("profile", PR_Profile_f); + Cmd_AddCommand ("pr_fields", PR_Fields_f); + Cmd_AddCommand ("pr_globals", PR_Globals_f); + Cvar_RegisterVariable (&pr_checkextension); Cvar_RegisterVariable (&nomonsters); Cvar_RegisterVariable (&gamecfg); Cvar_RegisterVariable (&scratch1); @@ -1296,7 +1652,7 @@ void PR_Init (void) // LordHavoc: for DarkPlaces, this overrides the number of decors (shell casings, gibs, etc) Cvar_RegisterVariable (&decors); // LordHavoc: Nehahra uses these to pass data around cutscene demos - if (nehahra) + if (gamemode == GAME_NEHAHRA) { Cvar_RegisterVariable (&nehx00);Cvar_RegisterVariable (&nehx01); Cvar_RegisterVariable (&nehx02);Cvar_RegisterVariable (&nehx03); @@ -1312,31 +1668,73 @@ void PR_Init (void) Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others)) Cvar_RegisterVariable (&pr_boundscheck); + Cvar_RegisterVariable (&pr_traceqc); + + progs_mempool = Mem_AllocPool("progs.dat", 0, NULL); + edictstring_mempool = Mem_AllocPool("edict strings", 0, NULL); + + PR_Cmd_Init(); +} + +/* +=============== +PR_Shutdown +=============== +*/ +extern void PR_Cmd_Shutdown(void); +void PR_Shutdown (void) +{ + PR_Cmd_Shutdown(); + + Mem_FreePool(&edictstring_mempool); + Mem_FreePool(&progs_mempool); } // LordHavoc: turned EDICT_NUM into a #define for speed reasons -edict_t *EDICT_NUM_ERROR(int n) +edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline) { - Sys_Error ("EDICT_NUM: bad number %i", n); + Host_Error ("EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline); return NULL; } + /* -edict_t *EDICT_NUM(int n) +int NUM_FOR_EDICT_ERROR(edict_t *e) { - if (n < 0 || n >= sv.max_edicts) - Sys_Error ("EDICT_NUM: bad number %i", n); - return (edict_t *)((byte *)sv.edicts+ (n)*pr_edict_size); + Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts); + return 0; } -*/ int NUM_FOR_EDICT(edict_t *e) { - int b; - - b = (byte *)e - (byte *)sv.edicts; - b = b / pr_edict_size; - - if (b < 0 || b >= sv.num_edicts) - Sys_Error ("NUM_FOR_EDICT: bad pointer"); - return b; + int n; + n = e - sv.edicts; + if ((unsigned int)n >= MAX_EDICTS) + Host_Error ("NUM_FOR_EDICT: bad pointer"); + return n; } + +//int NoCrash_NUM_FOR_EDICT(edict_t *e) +//{ +// return e - sv.edicts; +//} + +//#define EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields)) +//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4))) +int EDICT_TO_PROG(edict_t *e) +{ + int n; + n = e - sv.edicts; + if ((unsigned int)n >= (unsigned int)sv.max_edicts) + Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts); + return n;// EXPERIMENTAL + //return (qbyte *)e->v - (qbyte *)sv.edictsfields; +} +edict_t *PROG_TO_EDICT(int n) +{ + if ((unsigned int)n >= (unsigned int)sv.max_edicts) + Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n); + return sv.edicts + n; // EXPERIMENTAL + //return sv.edicts + ((n) / (progs->entityfields * 4)); +} +*/ +