int eval_movement;
int eval_pmodel;
int eval_punchvector;
+int eval_viewzoom;
dfunction_t *SV_PlayerPhysicsQC;
dfunction_t *EndFrameQC;
eval_movement = FindFieldOffset("movement");
eval_pmodel = FindFieldOffset("pmodel");
eval_punchvector = FindFieldOffset("punchvector");
+ eval_viewzoom = FindFieldOffset("viewzoom");
// LordHavoc: allowing QuakeC to override the player movement code
SV_PlayerPhysicsQC = ED_FindFunction ("SV_PlayerPhysics");
// LordHavoc: support for endframe
EndFrameQC = ED_FindFunction ("EndFrame");
-};
+}
/*
=================
}
-/*
-eval_t *GetEdictFieldValue(edict_t *ed, char *field)
-{
- ddef_t *def = NULL;
- int i;
- static int rep = 0;
-
- for (i=0 ; i<GEFV_CACHESIZE ; i++)
- {
- if (!strcmp(field, gefvCache[i].field))
- {
- def = gefvCache[i].pcache;
- goto Done;
- }
- }
-
- def = ED_FindField (field);
-
- if (strlen(field) < MAX_FIELD_LEN)
- {
- gefvCache[rep].pcache = def;
- strcpy (gefvCache[rep].field, field);
- rep ^= 1;
- }
-
-Done:
- if (!def)
- return NULL;
-
- return (eval_t *)((char *)&ed->v + def->ofs*4);
-}
-*/
-
/*
============
PR_ValueString
sprintf (line, "bad type %i", type);
break;
}
-
+
return line;
}
*/
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;
+ dfunction_t *f;
+
type &= ~DEF_SAVEGLOBAL;
switch (type)
break;
case ev_field:
def = ED_FieldAtOfs ( val->_int );
- sprintf (line, "%s", pr_strings + def->s_name);
+ // LordHavoc: parse the string a bit to turn special characters
+ // (like newline, specifically) into escape codes,
+ // this fixes saving games from various mods
+ //sprintf (line, "%s", pr_strings + def->s_name);
+ s = pr_strings + def->s_name;
+ for (i = 0;i < 4095 && *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_void:
sprintf (line, "void");
sprintf (line, "bad type %i", type);
break;
}
-
+
return line;
}
val = (void *)&pr_globals[ofs];
def = ED_GlobalAtOfs(ofs);
if (!def)
- sprintf (line,"%i(\?\?\?)", ofs); // LordHavoc: escaping the ?s so it is not a trigraph
+ sprintf (line,"%i(?)", ofs);
else
{
s = PR_ValueString (def->type, val);
def = ED_GlobalAtOfs(ofs);
if (!def)
- sprintf (line,"%i(\?\?\?)", ofs); // LordHavoc: escaping the ?s so it is not a trigraph
+ sprintf (line,"%i(?)", ofs);
else
sprintf (line,"%i(%s)", ofs, pr_strings + def->s_name);
name = pr_strings + 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
Qprintf (f, "}\n");
return;
}
-
+
for (i=1 ; i<progs->numfielddefs ; i++)
{
d = &pr_fielddefs[i];
void ED_PrintEdicts (void)
{
int i;
-
+
Con_Printf ("%i entities\n", sv.num_edicts);
for (i=0 ; i<sv.num_edicts ; i++)
ED_PrintNum (i);
=============
ED_PrintEdict_f
-For debugging, prints a single edicy
+For debugging, prints a single edict
=============
*/
void ED_PrintEdict_f (void)
{
int i;
-
+
i = atoi (Cmd_Argv(1));
if (i >= sv.num_edicts)
{
ddef_t *key;
while (1)
- {
+ {
// parse key
data = COM_Parse (data);
if (com_token[0] == '}')
case ev_entity:
*(int *)d = EDICT_TO_PROG(EDICT_NUM(atoi (s)));
break;
-
+
case ev_field:
def = ED_FindField (s);
if (!def)
// parse ents
while (1)
{
-// parse the opening brace
+// parse the opening brace
data = COM_Parse (data);
if (!data)
break;
Con_DPrintf ("Programs occupy %iK.\n", com_filesize/1024);
- pr_crc = CRC_Block((byte *)progs, com_filesize);
+ pr_crc = CRC_Block((qbyte *)progs, com_filesize);
// byte swap the header
for (i=0 ; i<sizeof(*progs)/4 ; i++)
if (progs->crc != PROGHEADER_CRC)
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);
pr_strings = (char *)progs + progs->ofs_strings;
- pr_globaldefs = (ddef_t *)((byte *)progs + progs->ofs_globaldefs);
+ pr_globaldefs = (ddef_t *)((qbyte *)progs + progs->ofs_globaldefs);
// we need to expand the fielddefs list to include all the engine fields,
// so allocate a new place for it
- infielddefs = (ddef_t *)((byte *)progs + progs->ofs_fielddefs);
+ infielddefs = (ddef_t *)((qbyte *)progs + progs->ofs_fielddefs);
pr_fielddefs = Mem_Alloc(progs_mempool, (progs->numfielddefs + DPFIELDS) * sizeof(ddef_t));
- pr_statements = (dstatement_t *)((byte *)progs + progs->ofs_statements);
+ pr_statements = (dstatement_t *)((qbyte *)progs + progs->ofs_statements);
// moved edict_size calculation down below field adding code
- pr_global_struct = (globalvars_t *)((byte *)progs + progs->ofs_globals);
+ pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals);
pr_globals = (float *)pr_global_struct;
// byte swap the lumps
}
FindEdictFieldOffsets(); // LordHavoc: update field offset list
+ PR_Execute_ProgsLoaded();
}
void PR_Fields_f (void)
{
- int i;
+ 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_Printf("no progs loaded\n");
return;
}
+ counts = Mem_Alloc(tempmempool, progs->numfielddefs * sizeof(int));
+ for (ednum = 0;ednum < MAX_EDICTS;ednum++)
+ {
+ ed = EDICT_NUM(ednum);
+ if (ed->free)
+ continue;
+ for (i = 1;i < progs->numfielddefs;i++)
+ {
+ d = &pr_fielddefs[i];
+ name = pr_strings + 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++)
- Con_Printf("%s\n", (pr_strings + pr_fielddefs[i].s_name));
- Con_Printf("%i entity fields, totalling %i bytes per edict, %i edicts, %i bytes total spent on edict fields\n", progs->entityfields, progs->entityfields * 4, MAX_EDICTS, progs->entityfields * 4 * MAX_EDICTS);
+ {
+ d = &pr_fielddefs[i];
+ name = pr_strings + d->s_name;
+ if (name[strlen(name)-2] == '_')
+ continue; // skip _x, _y, _z vars
+ switch(d->type & ~DEF_SAVEGLOBAL)
+ {
+ case ev_string:
+ strcat(tempstring, "string ");
+ break;
+ case ev_entity:
+ strcat(tempstring, "entity ");
+ break;
+ case ev_function:
+ strcat(tempstring, "function ");
+ break;
+ case ev_field:
+ strcat(tempstring, "field ");
+ break;
+ case ev_void:
+ strcat(tempstring, "void ");
+ break;
+ case ev_float:
+ strcat(tempstring, "float ");
+ break;
+ case ev_vector:
+ strcat(tempstring, "vector ");
+ break;
+ case ev_pointer:
+ strcat(tempstring, "pointer ");
+ break;
+ default:
+ sprintf (tempstring2, "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
+ strcat(tempstring, tempstring2);
+ break;
+ }
+ if (strlen(name) > 256)
+ {
+ strncpy(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, " ");
+ sprintf(tempstring2, "%5d", counts[i]);
+ strcat(tempstring, tempstring2);
+ strcat(tempstring, "\n");
+ if (strlen(tempstring) >= 4096)
+ {
+ Con_Printf("%s", 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, %i bytes total spent on edict fields (%i needed)\n", progs->entityfields, used, progs->entityfields * 4, usedamount * 4, MAX_EDICTS, progs->entityfields * 4 * MAX_EDICTS, usedamount * 4 * MAX_EDICTS);
}
void PR_Globals_f (void)
Host_Error ("EDICT_NUM: bad number %i", n);
return NULL;
}
-/*
-edict_t *EDICT_NUM(int n)
-{
- 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);
-}
-*/
int NUM_FOR_EDICT(edict_t *e)
{
int b;
- b = (byte *)e - (byte *)sv.edicts;
+ b = (qbyte *)e - (qbyte *)sv.edicts;
b = b / pr_edict_size;
if (b < 0 || b >= sv.num_edicts)
{
int b;
- b = (byte *)e - (byte *)sv.edicts;
+ b = (qbyte *)e - (qbyte *)sv.edicts;
b = b / pr_edict_size;
return b;
}
+