int eval_pmodel;
int eval_punchvector;
int eval_viewzoom;
+int eval_clientcolors;
+int eval_tag_entity;
+int eval_tag_index;
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");
// 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);
+ }
}
/*
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;
}
}
-
+
if (i == MAX_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);
{
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;
VectorClear(ed->v->angles);
ed->v->nextthink = -1;
ed->v->solid = 0;
-
- ed->freetime = sv.time;
+
+ ed->e->freetime = sv.time;
}
//===========================================================================
{
ddef_t *def;
int i;
-
+
for (i=0 ; i<progs->numglobaldefs ; i++)
{
def = &pr_globaldefs[i];
{
ddef_t *def;
int i;
-
+
for (i=0 ; i<progs->numfielddefs ; i++)
{
def = &pr_fielddefs[i];
sprintf (line, "%s", PR_GetString(val->string));
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);
else
int type;
char tempstring[8192], tempstring2[260]; // temporary string buffers
- if (ed->free)
+ if (ed->e->free)
{
Con_Printf ("FREE\n");
return;
FS_Printf (f, "{\n");
- if (ed->free)
+ if (ed->e->free)
{
FS_Printf (f, "}\n");
return;
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)
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\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
}
FS_Printf (f,"}\n");
}
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] == '}')
case ev_string:
*(string_t *)d = PR_SetString(ED_NewString(s));
break;
-
+
case ev_float:
*(float *)d = atof (s);
break;
-
+
case ev_vector:
strcpy (string, s);
v = string;
break;
case ev_entity:
- *(int *)d = EDICT_TO_PROG(EDICT_NUM(atoi (s)));
+ i = atoi (s);
+ if (i < 0 || i >= MAX_EDICTS)
+ Con_DPrintf("ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i)\n", i, MAX_EDICTS);
+ while (i >= sv.max_edicts)
+ SV_IncreaseEdicts();
+ *(int *)d = EDICT_TO_PROG(EDICT_NUM(i));
break;
case ev_field:
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;
}
// parse value
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
}
if (!init)
- ent->free = true;
+ ent->e->free = true;
return data;
}
void ED_LoadFromFile (const char *data)
{
edict_t *ent;
- int inhibit;
+ 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
- if (!COM_ParseToken (&data))
+ if (!COM_ParseToken(&data, false))
break;
if (com_token[0] != '{')
Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
else
ent = ED_Alloc ();
data = ED_ParseEdict (data, ent);
+ parsed++;
// remove things from different skill levels or deathmatch
if (deathmatch.integer)
{
if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
{
- ED_Free (ent);
- inhibit++;
+ ED_Free (ent);
+ inhibited++;
continue;
}
}
|| (current_skill >= 2 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_HARD )))
{
ED_Free (ent);
- inhibit++;
+ inhibited++;
continue;
}
pr_global_struct->self = EDICT_TO_PROG(ent);
PR_ExecuteProgram (func - pr_functions, "");
+ 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);
}
{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"}
};
/*
PR_LoadProgs
===============
*/
+extern void PR_Cmd_Reset (void);
void PR_LoadProgs (void)
{
int i;
FindEdictFieldOffsets(); // LordHavoc: update field offset list
PR_Execute_ProgsLoaded();
+ PR_Cmd_Reset();
}
for (ednum = 0;ednum < MAX_EDICTS;ednum++)
{
ed = EDICT_NUM(ednum);
- if (ed->free)
+ if (ed->e->free)
continue;
for (i = 1;i < progs->numfielddefs;i++)
{
PR_Init
===============
*/
+extern void PR_Cmd_Init(void);
void PR_Init (void)
{
Cmd_AddCommand ("edict", ED_PrintEdict_f);
progs_mempool = Mem_AllocPool("progs.dat");
edictstring_mempool = Mem_AllocPool("edict strings");
+
+ PR_Cmd_Init();
}
// 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));
}
+*/