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, const char *s);
+ddef_t *ED_FieldAtOfs(int ofs);
+qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s);
-cvar_t pr_checkextension = {0, "pr_checkextension", "1"};
+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"};
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;
mfunction_t *SV_PlayerPhysicsQC;
mfunction_t *EndFrameQC;
+//KrimZon - SERVER COMMANDS IN QUAKEC
+mfunction_t *SV_ParseClientCommandQC;
int FindFieldOffset(const char *field)
{
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");
// 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");
}
/*
*/
void ED_ClearEdict (edict_t *e)
{
+ int num;
memset (e->v, 0, progs->entityfields * 4);
- e->free = false;
+ e->e->free = false;
+ // LordHavoc: for consistency set these here
+ num = NUM_FOR_EDICT(e) - 1;
+ if (num >= 0 && num < svs.maxclients)
+ {
+ e->v->colormap = num + 1;
+ e->v->team = (svs.clients[num].colors & 15) + 1;
+ e->v->netname = PR_SetString(svs.clients[num].name);
+ }
}
/*
int i;
edict_t *e;
- for ( i=svs.maxclients+1 ; i<sv.num_edicts ; i++)
+ for (i = svs.maxclients + 1;i < sv.num_edicts;i++)
{
e = EDICT_NUM(i);
// the first couple seconds of server time can involve a lot of
// freeing and allocating, so relax the replacement policy
- if (e->free && ( 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;
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);
{
SV_UnlinkEdict (ed); // unlink from world bsp
- ed->free = true;
+ ed->e->free = true;
ed->v->model = 0;
ed->v->takedamage = 0;
ed->v->modelindex = 0;
ed->v->nextthink = -1;
ed->v->solid = 0;
- ed->freetime = sv.time;
+ ed->e->freetime = sv.time;
}
//===========================================================================
Returns a string describing *data in a type specific manner
=============
*/
-int NoCrash_NUM_FOR_EDICT(edict_t *e);
+//int NoCrash_NUM_FOR_EDICT(edict_t *e);
char *PR_ValueString (etype_t type, eval_t *val)
{
static char line[1024]; // LordHavoc: enlarged a bit (was 256)
switch (type)
{
case ev_string:
- sprintf (line, "%s", PR_GetString(val->string));
+ strncpy(line, PR_GetString(val->string), sizeof(line));
break;
case ev_entity:
- n = NoCrash_NUM_FOR_EDICT(PROG_TO_EDICT(val->edict));
+ //n = NoCrash_NUM_FOR_EDICT(PROG_TO_EDICT(val->edict));
+ n = val->edict;
if (n < 0 || n >= MAX_EDICTS)
- sprintf (line, "entity %i (invalid!)", n);
+ snprintf (line, sizeof (line), "entity %i (invalid!)", n);
else
- sprintf (line, "entity %i", n);
+ snprintf (line, sizeof (line), "entity %i", n);
break;
case ev_function:
f = pr_functions + val->function;
- sprintf (line, "%s()", PR_GetString(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_GetString(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:
// LordHavoc: changed from %5.1f to %10.4f
- sprintf (line, "%10.4f", val->_float);
+ snprintf (line, sizeof (line), "%10.4f", val->_float);
break;
case ev_vector:
// LordHavoc: changed from %5.1f to %10.4f
- sprintf (line, "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
+ 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;
}
switch (type)
{
case ev_string:
- sprintf (line, "%s", PR_GetString(val->string));
- break;
- case ev_entity:
- sprintf (line, "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
- break;
- case ev_function:
- f = pr_functions + val->function;
- sprintf (line, "%s", PR_GetString(f->s_name));
- break;
- case ev_field:
- def = ED_FieldAtOfs ( val->_int );
- // LordHavoc: parse the string a bit to turn special characters
+ // 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_GetString(def->s_name));
- s = PR_GetString(def->s_name);
- for (i = 0;i < 4095 && *s;)
+ s = PR_GetString (val->string);
+ for (i = 0;i < (int)sizeof(line) - 2 && *s;)
{
if (*s == '\n')
{
line[i++] = 'r';
}
else
- line[i] = *s;
+ line[i++] = *s;
s++;
}
- line[i++] = 0;
+ line[i] = '\0';
+ break;
+ 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;
+ strncpy(line, PR_GetString(f->s_name), sizeof(line));
+ break;
+ case ev_field:
+ def = ED_FieldAtOfs ( val->_int );
+ 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;
}
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_GetString(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;
}
def = ED_GlobalAtOfs(ofs);
if (!def)
- sprintf (line,"%i(?)", ofs);
+ snprintf (line, sizeof (line), "%i(?)", ofs);
else
- sprintf (line,"%i(%s)", ofs, PR_GetString(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;
}
*/
// 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)
+void ED_Print(edict_t *ed)
{
int l;
ddef_t *d;
int type;
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 ; i<progs->numfielddefs ; i++)
{
d = &pr_fielddefs[i];
tempstring2[259] = 0;
name = tempstring2;
}
- strcat(tempstring, name);
+ strlcat (tempstring, name, sizeof (tempstring));
for (l = strlen(name);l < 14;l++)
strcat(tempstring, " ");
strcat(tempstring, " ");
tempstring2[259] = 0;
name = tempstring2;
}
- strcat(tempstring, name);
- strcat(tempstring, "\n");
+ strlcat (tempstring, name, sizeof (tempstring));
+ strlcat (tempstring, "\n", sizeof (tempstring));
if (strlen(tempstring) >= 4096)
{
- Con_Printf("%s", tempstring);
+ Con_Print(tempstring);
tempstring[0] = 0;
}
}
if (tempstring[0])
- Con_Printf("%s", tempstring);
+ Con_Print(tempstring);
}
/*
char *name;
int type;
- FS_Printf (f, "{\n");
+ FS_Print(f, "{\n");
- if (ed->free)
+ if (ed->e->free)
{
- FS_Printf (f, "}\n");
+ FS_Print(f, "}\n");
return;
}
if (j == type_size[type])
continue;
- FS_Printf (f,"\"%s\" ",name);
- FS_Printf (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));
}
- FS_Printf (f, "}\n");
+ FS_Print(f, "}\n");
}
void ED_PrintNum (int ent)
{
- ED_Print (EDICT_NUM(ent));
+ ED_Print(EDICT_NUM(ent));
}
/*
{
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 ; i++)
ED_PrintNum (i);
}
int i;
i = atoi (Cmd_Argv(1));
- if (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);
for (i=0 ; i<sv.num_edicts ; i++)
{
ent = EDICT_NUM(i);
- if (ent->free)
+ if (ent->e->free)
continue;
active++;
if (ent->v->solid)
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);
}
char *name;
int type;
- FS_Printf (f,"{\n");
+ FS_Print(f,"{\n");
for (i=0 ; i<progs->numglobaldefs ; i++)
{
def = &pr_globaldefs[i];
continue;
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_Printf(f,"\"%s\" ", name);
+ FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
}
- FS_Printf (f,"}\n");
+ 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 <edict number> <field> <value>\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;
+ }
+
+ ED_ParseEpair(ed, key, Cmd_Argv(3));
}
/*
while (1)
{
// parse key
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
break;
strcpy (keyname, com_token);
// parse value
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
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");
}
}
returns false if error
=============
*/
-qboolean ED_ParseEpair (void *base, ddef_t *key, const 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;
- mfunction_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 = PR_SetString(ED_NewString(s));
+ 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)
+ break;
+ val->vector[i] = atof(s);
+ while (*s > ' ')
+ s++;
+ if (!*s)
+ break;
}
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") && strcmp(s, "fog") && strncmp(s, "fog_", 4) && strcmp(s, "farclip"))
- 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);
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;
}
while (1)
{
// parse key
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
break;
// 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;
+ anglehack = !strcmp (com_token, "angle");
+ if (anglehack)
+ strlcpy (com_token, "angles", sizeof (com_token));
// 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
+ strlcpy (com_token, "light_lev", sizeof (com_token)); // hack for single light def
- strcpy (keyname, com_token);
+ strlcpy (keyname, com_token, sizeof (keyname));
// another hack to fix heynames with trailing spaces
n = strlen(keyname);
}
// parse value
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
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);
+ 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;
}
while (1)
{
// parse the opening brace
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
break;
if (com_token[0] != '{')
Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
//
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;
}
{
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, "");
spawned++;
- if (ent->free)
+ if (ent->e->free)
died++;
}
- Con_DPrintf ("%i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", parsed, inhibited, spawned, died, spawned - died);
+ Con_DPrintf("%i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", parsed, inhibited, spawned, died, spawned - died);
}
{ev_float, "ping"},
{ev_vector, "movement"},
{ev_float, "pmodel"},
- {ev_vector, "punchvector"}
+ {ev_vector, "punchvector"},
+ {ev_float, "clientcolors"},
+ {ev_entity, "tag_entity"},
+ {ev_float, "tag_index"},
+ {ev_float, "light_lev"},
+ {ev_float, "color"},
+ {ev_float, "style"},
+ {ev_float, "pflags"}
};
/*
int i;
dstatement_t *st;
ddef_t *infielddefs;
- void *temp;
dfunction_t *dfunctions;
// flush the non-C variable lookup cache
Mem_EmptyPool(progs_mempool);
Mem_EmptyPool(edictstring_mempool);
- temp = FS_LoadFile ("progs.dat", false);
- if (!temp)
+ progs = (dprograms_t *)FS_LoadFile ("progs.dat", progs_mempool, false);
+ if (!progs)
Host_Error ("PR_LoadProgs: couldn't load progs.dat");
- progs = (dprograms_t *)Mem_Alloc(progs_mempool, fs_filesize);
-
- memcpy(progs, temp, fs_filesize);
- Mem_Free(temp);
-
- Con_DPrintf ("Programs occupy %iK.\n", fs_filesize/1024);
+ Con_DPrintf("Programs occupy %iK.\n", fs_filesize/1024);
pr_crc = CRC_Block((qbyte *)progs, fs_filesize);
if (progs->version != 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 *)((qbyte *)progs + progs->ofs_functions);
int *v;
if (!sv.active)
{
- Con_Printf("no progs loaded\n");
+ Con_Print("no progs loaded\n");
return;
}
counts = Mem_Alloc(tempmempool, progs->numfielddefs * sizeof(int));
- for (ednum = 0;ednum < MAX_EDICTS;ednum++)
+ for (ednum = 0;ednum < sv.max_edicts;ednum++)
{
ed = EDICT_NUM(ednum);
- if (ed->free)
+ if (ed->e->free)
continue;
for (i = 1;i < progs->numfielddefs;i++)
{
switch(d->type & ~DEF_SAVEGLOBAL)
{
case ev_string:
- strcat(tempstring, "string ");
+ strlcat (tempstring, "string ", sizeof (tempstring));
break;
case ev_entity:
- strcat(tempstring, "entity ");
+ strlcat (tempstring, "entity ", sizeof (tempstring));
break;
case ev_function:
- strcat(tempstring, "function ");
+ strlcat (tempstring, "function ", sizeof (tempstring));
break;
case ev_field:
- strcat(tempstring, "field ");
+ strlcat (tempstring, "field ", sizeof (tempstring));
break;
case ev_void:
- strcat(tempstring, "void ");
+ strlcat (tempstring, "void ", sizeof (tempstring));
break;
case ev_float:
- strcat(tempstring, "float ");
+ strlcat (tempstring, "float ", sizeof (tempstring));
break;
case ev_vector:
- strcat(tempstring, "vector ");
+ strlcat (tempstring, "vector ", sizeof (tempstring));
break;
case ev_pointer:
- strcat(tempstring, "pointer ");
+ strlcat (tempstring, "pointer ", sizeof (tempstring));
break;
default:
- sprintf (tempstring2, "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
- strcat(tempstring, tempstring2);
+ snprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
+ strlcat (tempstring, tempstring2, sizeof (tempstring));
break;
}
if (strlen(name) > 256)
tempstring2[259] = 0;
name = tempstring2;
}
- strcat(tempstring, name);
+ strcat (tempstring, name);
for (j = strlen(name);j < 25;j++)
strcat(tempstring, " ");
- sprintf(tempstring2, "%5d", counts[i]);
- strcat(tempstring, tempstring2);
- strcat(tempstring, "\n");
+ snprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]);
+ strlcat (tempstring, tempstring2, sizeof (tempstring));
+ strlcat (tempstring, "\n", sizeof (tempstring));
if (strlen(tempstring) >= 4096)
{
- Con_Printf("%s", tempstring);
+ Con_Print(tempstring);
tempstring[0] = 0;
}
if (counts[i])
}
}
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);
+ 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_Printf("no progs loaded\n");
+ Con_Print("no progs loaded\n");
return;
}
for (i = 0;i < progs->numglobaldefs;i++)
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);
}
// 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)
{
- Host_Error ("EDICT_NUM: bad number %i", n);
+ Host_Error ("EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline);
return NULL;
}
+/*
+int NUM_FOR_EDICT_ERROR(edict_t *e)
+{
+ 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 n;
return n;
}
-int NoCrash_NUM_FOR_EDICT(edict_t *e)
-{
- return e - sv.edicts;
-}
+//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.edictstable[(e) / (progs->entityfields * 4)])
+//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4)))
int EDICT_TO_PROG(edict_t *e)
{
int n;
{
if ((unsigned int)n >= (unsigned int)sv.max_edicts)
Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n);
- return sv.edictstable[n]; // EXPERIMENTAL
- //return sv.edictstable[(n) / (progs->entityfields * 4)];
+ return sv.edicts + n; // EXPERIMENTAL
+ //return sv.edicts + ((n) / (progs->entityfields * 4));
}
+*/
projects / xonotic / darkplaces.git / blobdiff