qf/newtree
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/newtree synced 2024-11-28 23:02:31 +00:00
Code Issues Projects Releases Packages Wiki Activity

now only svs is reverenced where it shouldn't be, and that's to set info

Browse source 
strings (skybox and *progs). skybox is easy to take care of (aditional parse
functions), but I haven't yet decided what to do with *progs. Also, progs code
needs a bit of a cleanup, but that will come later.
This commit is contained in:
Bill Currie 2001-01-02 03:22:46 +00:00
parent ff89f60c74
commit 2debf6f669
13 changed files with 160 additions and 135 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
include/progs.h
View file

@ -93,22 +93,22 @@ ddef_t *ED_FindField (struct progs_s *pr, char *name);
dfunction_t *ED_FindFunction (struct progs_s *pr, char *name); dfunction_t *ED_FindFunction (struct progs_s *pr, char *name);
//define EDICT_NUM(p,n) ((edict_t *)(sv.edicts+ (n)*(p)->pr_edict_size)) //define EDICT_NUM(p,n) ((edict_t *)(*(p)->edicts+ (n)*(p)->pr_edict_size))
//define NUM_FOR_EDICT(p,e) (((byte *)(e) - sv.edicts)/(p)->pr_edict_size) //define NUM_FOR_EDICT(p,e) (((byte *)(e) - *(p)->edicts)/(p)->pr_edict_size)
edict_t *EDICT_NUM(struct progs_s *pr, int n); edict_t *EDICT_NUM(struct progs_s *pr, int n);
int NUM_FOR_EDICT(struct progs_s *pr, edict_t *e); int NUM_FOR_EDICT(struct progs_s *pr, edict_t *e);
#define NEXT_EDICT(p,e) ((edict_t *)( (byte *)e + (p)->pr_edict_size)) #define NEXT_EDICT(p,e) ((edict_t *)( (byte *)e + (p)->pr_edict_size))
#define EDICT_TO_PROG(e) ((byte *)e - (byte *)sv.edicts) #define EDICT_TO_PROG(p,e) ((byte *)e - (byte *)*(p)->edicts)
#define PROG_TO_EDICT(e) ((edict_t *)((byte *)sv.edicts + e)) #define PROG_TO_EDICT(p,e) ((edict_t *)((byte *)*(p)->edicts + e))
//============================================================================ //============================================================================
#define G_FLOAT(p,o) ((p)->pr_globals[o]) #define G_FLOAT(p,o) ((p)->pr_globals[o])
#define G_INT(p,o) (*(int *)&(p)->pr_globals[o]) #define G_INT(p,o) (*(int *)&(p)->pr_globals[o])
#define G_EDICT(p,o) ((edict_t *)((byte *)sv.edicts+ *(int *)&(p)->pr_globals[o])) #define G_EDICT(p,o) ((edict_t *)((byte *)*(p)->edicts+ *(int *)&(p)->pr_globals[o]))
#define G_EDICTNUM(p,o) NUM_FOR_EDICT(p,G_EDICT(p, o)) #define G_EDICTNUM(p,o) NUM_FOR_EDICT(p,G_EDICT(p, o))
#define G_VECTOR(p,o) (&(p)->pr_globals[o]) #define G_VECTOR(p,o) (&(p)->pr_globals[o])
#define G_STRING(p,o) (PR_GetString(pr,*(string_t *)&(p)->pr_globals[o])) #define G_STRING(p,o) (PR_GetString(pr,*(string_t *)&(p)->pr_globals[o]))
@ -137,6 +137,11 @@ void PR_RunError (struct progs_s *pr, char *error, ...) __attribute__((format(pr
void ED_PrintEdicts (struct progs_s *pr); void ED_PrintEdicts (struct progs_s *pr);
void ED_PrintNum (struct progs_s *pr, int ent); void ED_PrintNum (struct progs_s *pr, int ent);
void ED_Count (struct progs_s *pr);
void ED_PrintEdict_f (void);
void ED_PrintEdicts_f (void);
void ED_Count_f (void);
void PR_Profile (struct progs_s *pr);
eval_t *GetEdictFieldValue(struct progs_s *pr, edict_t *ed, char *field); eval_t *GetEdictFieldValue(struct progs_s *pr, edict_t *ed, char *field);
@ -185,6 +190,11 @@ typedef struct progs_s {
int localstack[LOCALSTACK_SIZE]; int localstack[LOCALSTACK_SIZE];
int localstack_used; int localstack_used;
edict_t **edicts;
int *num_edicts;
double *time;
int null_bad;
} progs_t; } progs_t;
#endif // _PROGS_H #endif // _PROGS_H

1
include/server.h
View file

@ -404,6 +404,7 @@ extern progs_t sv_progs;
void SV_Error (char *error, ...) __attribute__((format(printf,1,2))); void SV_Error (char *error, ...) __attribute__((format(printf,1,2)));
void SV_Init (void); void SV_Init (void);
void SV_Progs_Init (void);
void Con_Printf (char *fmt, ...) __attribute__((format(printf,1,2))); void Con_Printf (char *fmt, ...) __attribute__((format(printf,1,2)));
void Con_DPrintf (char *fmt, ...) __attribute__((format(printf,1,2))); void Con_DPrintf (char *fmt, ...) __attribute__((format(printf,1,2)));

26
source/pr_cmds.c
View file

@ -38,7 +38,7 @@
#include "world.h" #include "world.h"
#include "va.h" #include "va.h"
#define RETURN_EDICT(p, e) (((int *)(p)->pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e)) #define RETURN_EDICT(p, e) (((int *)(p)->pr_globals)[OFS_RETURN] = EDICT_TO_PROG(p, e))
#define RETURN_STRING(p, s) (((int *)(p)->pr_globals)[OFS_RETURN] = PR_SetString((p), s)) #define RETURN_STRING(p, s) (((int *)(p)->pr_globals)[OFS_RETURN] = PR_SetString((p), s))
/* /*
@ -81,7 +81,7 @@ PF_error (progs_t *pr)
s = PF_VarString (pr, 0); s = PF_VarString (pr, 0);
Con_Printf ("======SERVER ERROR in %s:\n%s\n", Con_Printf ("======SERVER ERROR in %s:\n%s\n",
PR_GetString (pr, pr->pr_xfunction->s_name), s); PR_GetString (pr, pr->pr_xfunction->s_name), s);
ed = PROG_TO_EDICT (pr->pr_global_struct->self); ed = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
ED_Print (pr, ed); ED_Print (pr, ed);
SV_Error ("Program error"); SV_Error ("Program error");
@ -104,7 +104,7 @@ PF_objerror (progs_t *pr)
s = PF_VarString (pr, 0); s = PF_VarString (pr, 0);
Con_Printf ("======OBJECT ERROR in %s:\n%s\n", Con_Printf ("======OBJECT ERROR in %s:\n%s\n",
PR_GetString (pr, pr->pr_xfunction->s_name), s); PR_GetString (pr, pr->pr_xfunction->s_name), s);
ed = PROG_TO_EDICT (pr->pr_global_struct->self); ed = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
ED_Print (pr, ed); ED_Print (pr, ed);
ED_Free (pr, ed); ED_Free (pr, ed);
@ -529,9 +529,9 @@ PF_traceline (progs_t *pr)
VectorCopy (trace.plane.normal, pr->pr_global_struct->trace_plane_normal); VectorCopy (trace.plane.normal, pr->pr_global_struct->trace_plane_normal);
pr->pr_global_struct->trace_plane_dist = trace.plane.dist; pr->pr_global_struct->trace_plane_dist = trace.plane.dist;
if (trace.ent) if (trace.ent)
pr->pr_global_struct->trace_ent = EDICT_TO_PROG (trace.ent); pr->pr_global_struct->trace_ent = EDICT_TO_PROG (pr, trace.ent);
else else
pr->pr_global_struct->trace_ent = EDICT_TO_PROG (sv.edicts); pr->pr_global_struct->trace_ent = EDICT_TO_PROG (pr, sv.edicts);
} }
/* /*
@ -636,7 +636,7 @@ PF_checkclient (progs_t *pr)
return; return;
} }
// if current entity can't possibly see the check entity, return 0 // if current entity can't possibly see the check entity, return 0
self = PROG_TO_EDICT (pr->pr_global_struct->self); self = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
VectorAdd (self->v.origin, self->v.view_ofs, view); VectorAdd (self->v.origin, self->v.view_ofs, view);
leaf = Mod_PointInLeaf (view, sv.worldmodel); leaf = Mod_PointInLeaf (view, sv.worldmodel);
l = (leaf - sv.worldmodel->leafs) - 1; l = (leaf - sv.worldmodel->leafs) - 1;
@ -786,7 +786,7 @@ PF_findradius (progs_t *pr)
if (Length (eorg) > rad) if (Length (eorg) > rad)
continue; continue;
ent->v.chain = EDICT_TO_PROG (chain); ent->v.chain = EDICT_TO_PROG (pr, chain);
chain = ent; chain = ent;
} }
@ -1000,7 +1000,7 @@ PF_walkmove (progs_t *pr)
dfunction_t *oldf; dfunction_t *oldf;
int oldself; int oldself;
ent = PROG_TO_EDICT (pr->pr_global_struct->self); ent = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
yaw = G_FLOAT (pr, OFS_PARM0); yaw = G_FLOAT (pr, OFS_PARM0);
dist = G_FLOAT (pr, OFS_PARM1); dist = G_FLOAT (pr, OFS_PARM1);
@ -1039,7 +1039,7 @@ PF_droptofloor (progs_t *pr)
vec3_t end; vec3_t end;
trace_t trace; trace_t trace;
ent = PROG_TO_EDICT (pr->pr_global_struct->self); ent = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
VectorCopy (ent->v.origin, end); VectorCopy (ent->v.origin, end);
end[2] -= 256; end[2] -= 256;
@ -1052,7 +1052,7 @@ PF_droptofloor (progs_t *pr)
VectorCopy (trace.endpos, ent->v.origin); VectorCopy (trace.endpos, ent->v.origin);
SV_LinkEdict (ent, false); SV_LinkEdict (ent, false);
ent->v.flags = (int) ent->v.flags | FL_ONGROUND; ent->v.flags = (int) ent->v.flags | FL_ONGROUND;
ent->v.groundentity = EDICT_TO_PROG (trace.ent); ent->v.groundentity = EDICT_TO_PROG (pr, trace.ent);
G_FLOAT (pr, OFS_RETURN) = 1; G_FLOAT (pr, OFS_RETURN) = 1;
} }
} }
@ -1262,7 +1262,7 @@ PF_changeyaw (progs_t *pr)
edict_t *ent; edict_t *ent;
float ideal, current, move, speed; float ideal, current, move, speed;
ent = PROG_TO_EDICT (pr->pr_global_struct->self); ent = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
current = anglemod (ent->v.angles[1]); current = anglemod (ent->v.angles[1]);
ideal = ent->v.ideal_yaw; ideal = ent->v.ideal_yaw;
speed = ent->v.yaw_speed; speed = ent->v.yaw_speed;
@ -1315,7 +1315,7 @@ WriteDest (progs_t *pr)
case MSG_ONE: case MSG_ONE:
SV_Error ("Shouldn't be at MSG_ONE"); SV_Error ("Shouldn't be at MSG_ONE");
#if 0 #if 0
ent = PROG_TO_EDICT (pr->pr_global_struct->msg_entity); ent = PROG_TO_EDICT (pr, pr->pr_global_struct->msg_entity);
entnum = NUM_FOR_EDICT (pr, ent); entnum = NUM_FOR_EDICT (pr, ent);
if (entnum < 1 || entnum > MAX_CLIENTS) if (entnum < 1 || entnum > MAX_CLIENTS)
PR_RunError (pr, "WriteDest: not a client"); PR_RunError (pr, "WriteDest: not a client");
@ -1348,7 +1348,7 @@ Write_GetClient (progs_t *pr)
int entnum; int entnum;
edict_t *ent; edict_t *ent;
ent = PROG_TO_EDICT (pr->pr_global_struct->msg_entity); ent = PROG_TO_EDICT (pr, pr->pr_global_struct->msg_entity);
entnum = NUM_FOR_EDICT (pr, ent); entnum = NUM_FOR_EDICT (pr, ent);
if (entnum < 1 || entnum > MAX_CLIENTS) if (entnum < 1 || entnum > MAX_CLIENTS)
PR_RunError (pr, "Write_GetClient: not a client"); PR_RunError (pr, "Write_GetClient: not a client");

60
source/pr_edict.c
View file

@ -105,11 +105,11 @@ ED_Alloc (progs_t *pr)
int i; int i;
edict_t *e; edict_t *e;
for (i = MAX_CLIENTS + 1; i < sv.num_edicts; i++) { for (i = MAX_CLIENTS + 1; i < *(pr)->num_edicts; i++) {
e = EDICT_NUM (pr, i); e = EDICT_NUM (pr, i);
// the first couple seconds of server time can involve a lot of // the first couple seconds of server time can involve a lot of
// freeing and allocating, so relax the replacement policy // freeing and allocating, so relax the replacement policy
if (e->free && (e->freetime < 2 || sv.time - e->freetime > 0.5)) { if (e->free && (e->freetime < 2 || *(pr)->time - e->freetime > 0.5)) {
ED_ClearEdict (pr, e); ED_ClearEdict (pr, e);
return e; return e;
} }
@ -121,7 +121,7 @@ ED_Alloc (progs_t *pr)
e = EDICT_NUM (pr, i); e = EDICT_NUM (pr, i);
SV_UnlinkEdict (e); SV_UnlinkEdict (e);
} else } else
sv.num_edicts++; (*(pr)->num_edicts)++;
e = EDICT_NUM (pr, i); e = EDICT_NUM (pr, i);
ED_ClearEdict (pr, e); ED_ClearEdict (pr, e);
@ -151,7 +151,7 @@ ED_Free (progs_t *pr, edict_t *ed)
ed->v.nextthink = -1; ed->v.nextthink = -1;
ed->v.solid = 0; ed->v.solid = 0;
ed->freetime = sv.time; ed->freetime = *(pr)->time;
} }
//=========================================================================== //===========================================================================
@ -292,7 +292,7 @@ PR_ValueString (progs_t *pr, etype_t type, eval_t *val)
break; break;
case ev_entity: case ev_entity:
snprintf (line, sizeof (line), "entity %i", snprintf (line, sizeof (line), "entity %i",
NUM_FOR_EDICT (pr, PROG_TO_EDICT (val->edict))); NUM_FOR_EDICT (pr, PROG_TO_EDICT (pr, val->edict)));
break; break;
case ev_function: case ev_function:
f = pr->pr_functions + val->function; f = pr->pr_functions + val->function;
@ -344,7 +344,7 @@ PR_UglyValueString (progs_t *pr, etype_t type, eval_t *val)
break; break;
case ev_entity: case ev_entity:
snprintf (line, sizeof (line), "%i", snprintf (line, sizeof (line), "%i",
NUM_FOR_EDICT (pr, PROG_TO_EDICT (val->edict))); NUM_FOR_EDICT (pr, PROG_TO_EDICT (pr, val->edict)));
break; break;
case ev_function: case ev_function:
f = pr->pr_functions + val->function; f = pr->pr_functions + val->function;
@ -534,32 +534,12 @@ ED_PrintEdicts (progs_t *pr)
{ {
int i; int i;
Con_Printf ("%i entities\n", sv.num_edicts); Con_Printf ("%i entities\n", *(pr)->num_edicts);
for (i = 0; i < sv.num_edicts; i++) { for (i = 0; i < *(pr)->num_edicts; i++) {
Con_Printf ("\nEDICT %i:\n", i); Con_Printf ("\nEDICT %i:\n", i);
ED_PrintNum (pr, i); ED_PrintNum (pr, i);
} }
} }
void
ED_PrintEdicts_f (void)
{
ED_PrintEdicts (&sv_progs);
}
/*
ED_PrintEdict_f
For debugging, prints a single edicy
*/
void
ED_PrintEdict_f (void)
{
int i;
i = atoi (Cmd_Argv (1));
Con_Printf ("\n EDICT %i:\n", i);
ED_PrintNum (&sv_progs, i);
}
/* /*
ED_Count ED_Count
@ -574,7 +554,7 @@ ED_Count (progs_t *pr)
int active, models, solid, step; int active, models, solid, step;
active = models = solid = step = 0; active = models = solid = step = 0;
for (i = 0; i < sv.num_edicts; i++) { for (i = 0; i < *(pr)->num_edicts; i++) {
ent = EDICT_NUM (pr, i); ent = EDICT_NUM (pr, i);
if (ent->free) if (ent->free)
continue; continue;
@ -587,7 +567,7 @@ ED_Count (progs_t *pr)
step++; step++;
} }
Con_Printf ("num_edicts:%3i\n", sv.num_edicts); Con_Printf ("num_edicts:%3i\n", *(pr)->num_edicts);
Con_Printf ("active :%3i\n", active); Con_Printf ("active :%3i\n", active);
Con_Printf ("view :%3i\n", models); Con_Printf ("view :%3i\n", models);
Con_Printf ("touch :%3i\n", solid); Con_Printf ("touch :%3i\n", solid);
@ -595,12 +575,6 @@ ED_Count (progs_t *pr)
} }
void
ED_Count_f (void)
{
ED_Count (&sv_progs);
}
/* /*
============================================================================== ==============================================================================
@ -750,7 +724,7 @@ ED_ParseEpair (progs_t *pr, void *base, ddef_t *key, char *s)
break; break;
case ev_entity: case ev_entity:
*(int *) d = EDICT_TO_PROG (EDICT_NUM (pr, atoi (s))); *(int *) d = EDICT_TO_PROG (pr, EDICT_NUM (pr, atoi (s)));
break; break;
case ev_field: case ev_field:
@ -795,7 +769,7 @@ ED_ParseEdict (progs_t *pr, char *data, edict_t *ent)
init = false; init = false;
// clear it // clear it
if (ent != sv.edicts) // hack if (ent != *(pr)->edicts) // hack
memset (&ent->v, 0, pr->progs->entityfields * 4); memset (&ent->v, 0, pr->progs->entityfields * 4);
// go through all the dictionary pairs // go through all the dictionary pairs
@ -896,7 +870,7 @@ ED_LoadFromFile (progs_t *pr, char *data)
ent = NULL; ent = NULL;
inhibit = 0; inhibit = 0;
pr->pr_global_struct->time = sv.time; pr->pr_global_struct->time = *(pr)->time;
// parse ents // parse ents
while (1) { while (1) {
@ -938,7 +912,7 @@ ED_LoadFromFile (progs_t *pr, char *data)
continue; continue;
} }
pr->pr_global_struct->self = EDICT_TO_PROG (ent); pr->pr_global_struct->self = EDICT_TO_PROG (pr, ent);
PR_ExecuteProgram (pr, func - pr->pr_functions); PR_ExecuteProgram (pr, func - pr->pr_functions);
SV_FlushSignon (); SV_FlushSignon ();
} }
@ -1186,7 +1160,7 @@ EDICT_NUM (progs_t *pr, int n)
{ {
if (n < 0 || n >= MAX_EDICTS) if (n < 0 || n >= MAX_EDICTS)
SV_Error ("EDICT_NUM: bad number %i", n); SV_Error ("EDICT_NUM: bad number %i", n);
return (edict_t *) ((byte *) sv.edicts + (n) * pr->pr_edict_size); return (edict_t *) ((byte *) *(pr)->edicts + (n) * pr->pr_edict_size);
} }
int int
@ -1194,10 +1168,10 @@ NUM_FOR_EDICT (progs_t *pr, edict_t *e)
{ {
int b; int b;
b = (byte *) e - (byte *) sv.edicts; b = (byte *) e - (byte *) *(pr)->edicts;
b = b / pr->pr_edict_size; b = b / pr->pr_edict_size;
if (b < 0 || b >= sv.num_edicts) if (b < 0 || b >= *(pr)->num_edicts)
SV_Error ("NUM_FOR_EDICT: bad pointer"); SV_Error ("NUM_FOR_EDICT: bad pointer");
return b; return b;
} }

37
source/pr_exec.c
View file

@ -226,13 +226,6 @@ PR_Profile (progs_t *pr)
} while (best); } while (best);
} }
void
PR_Profile_f (void)
{
PR_Profile (&sv_progs);
}
/* /*
PR_RunError PR_RunError
@ -354,7 +347,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
if (!fnum || fnum >= pr->progs->numfunctions) { if (!fnum || fnum >= pr->progs->numfunctions) {
if (pr->pr_global_struct->self) if (pr->pr_global_struct->self)
ED_Print (pr, PROG_TO_EDICT (pr->pr_global_struct->self)); ED_Print (pr, PROG_TO_EDICT (pr, pr->pr_global_struct->self));
SV_Error ("PR_ExecuteProgram: NULL function"); SV_Error ("PR_ExecuteProgram: NULL function");
} }
@ -457,7 +450,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
OPC->_float = !OPA->function; OPC->_float = !OPA->function;
break; break;
case OP_NOT_ENT: case OP_NOT_ENT:
OPC->_float = (PROG_TO_EDICT (OPA->edict) == sv.edicts); OPC->_float = (PROG_TO_EDICT (pr, OPA->edict) == *pr->edicts);
break; break;
case OP_EQ_F: case OP_EQ_F:
OPC->_float = OPA->_float == OPB->_float; OPC->_float = OPA->_float == OPB->_float;
@ -525,14 +518,14 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
return; return;
} }
if (pr_boundscheck->int_val && (OPB->_int % pr->pr_edict_size < if (pr_boundscheck->int_val && (OPB->_int % pr->pr_edict_size <
((byte *) & sv.edicts->v - ((byte *) & (*pr->edicts)->v -
(byte *) sv.edicts))) { (byte *) *pr->edicts))) {
pr->pr_xstatement = st - pr->pr_statements; pr->pr_xstatement = st - pr->pr_statements;
PR_RunError PR_RunError
(pr, "Progs attempted to write to an engine edict field\n"); (pr, "Progs attempted to write to an engine edict field\n");
return; return;
} }
ptr = (eval_t *) ((byte *) sv.edicts + OPB->_int); ptr = (eval_t *) ((byte *) *pr->edicts + OPB->_int);
ptr->_int = OPA->_int; ptr->_int = OPA->_int;
break; break;
case OP_STOREP_V: case OP_STOREP_V:
@ -543,7 +536,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
(pr, "Progs attempted to write to an out of bounds edict\n"); (pr, "Progs attempted to write to an out of bounds edict\n");
return; return;
} }
ptr = (eval_t *) ((byte *) sv.edicts + OPB->_int); ptr = (eval_t *) ((byte *) *pr->edicts + OPB->_int);
ptr->vector[0] = OPA->vector[0]; ptr->vector[0] = OPA->vector[0];
ptr->vector[1] = OPA->vector[1]; ptr->vector[1] = OPA->vector[1];
ptr->vector[2] = OPA->vector[2]; ptr->vector[2] = OPA->vector[2];
@ -557,7 +550,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
return; return;
} }
if (pr_boundscheck->int_val if (pr_boundscheck->int_val
&& (OPA->edict == 0 && sv.state == ss_active)) { && (OPA->edict == 0 && pr->null_bad)) {
pr->pr_xstatement = st - pr->pr_statements; pr->pr_xstatement = st - pr->pr_statements;
PR_RunError (pr, "assignment to world entity"); PR_RunError (pr, "assignment to world entity");
return; return;
@ -569,9 +562,9 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
(pr, "Progs attempted to address an invalid field in an edict\n"); (pr, "Progs attempted to address an invalid field in an edict\n");
return; return;
} }
ed = PROG_TO_EDICT (OPA->edict); ed = PROG_TO_EDICT (pr, OPA->edict);
OPC->_int = OPC->_int =
(byte *) ((int *) &ed->v + OPB->_int) - (byte *) sv.edicts; (byte *) ((int *) &ed->v + OPB->_int) - (byte *) *pr->edicts;
break; break;
case OP_LOAD_F: case OP_LOAD_F:
case OP_LOAD_FLD: case OP_LOAD_FLD:
@ -592,7 +585,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
(pr, "Progs attempted to read an invalid field in an edict\n"); (pr, "Progs attempted to read an invalid field in an edict\n");
return; return;
} }
ed = PROG_TO_EDICT (OPA->edict); ed = PROG_TO_EDICT (pr, OPA->edict);
OPC->_int = ((eval_t *) ((int *) &ed->v + OPB->_int))->_int; OPC->_int = ((eval_t *) ((int *) &ed->v + OPB->_int))->_int;
break; break;
case OP_LOAD_V: case OP_LOAD_V:
@ -610,7 +603,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
(pr, "Progs attempted to read an invalid field in an edict\n"); (pr, "Progs attempted to read an invalid field in an edict\n");
return; return;
} }
ed = PROG_TO_EDICT (OPA->edict); ed = PROG_TO_EDICT (pr, OPA->edict);
OPC->vector[0] = OPC->vector[0] =
((eval_t *) ((int *) &ed->v + OPB->_int))->vector[0]; ((eval_t *) ((int *) &ed->v + OPB->_int))->vector[0];
OPC->vector[1] = OPC->vector[1] =
@ -671,7 +664,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
return; // all done return; // all done
break; break;
case OP_STATE: case OP_STATE:
ed = PROG_TO_EDICT (pr->pr_global_struct->self); ed = PROG_TO_EDICT (pr, pr->pr_global_struct->self);
ed->v.nextthink = pr->pr_global_struct->time + 0.1; ed->v.nextthink = pr->pr_global_struct->time + 0.1;
ed->v.frame = OPA->_float; ed->v.frame = OPA->_float;
ed->v.think = OPB->function; ed->v.think = OPB->function;
@ -840,13 +833,13 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
} }
if (pr_boundscheck->int_val if (pr_boundscheck->int_val
&& (OPB->_int % pr->pr_edict_size < && (OPB->_int % pr->pr_edict_size <
((byte *) & sv.edicts->v - (byte *) sv.edicts))) { ((byte *) & (*pr->edicts)->v - (byte *) *pr->edicts))) {
pr->pr_xstatement = st - pr->pr_statements; pr->pr_xstatement = st - pr->pr_statements;
PR_RunError PR_RunError
(pr, "Progs attempted to write to an engine edict field\n"); (pr, "Progs attempted to write to an engine edict field\n");
return; return;
} }
ptr = (eval_t *) ((byte *) sv.edicts + OPB->_int); ptr = (eval_t *) ((byte *) *pr->edicts + OPB->_int);
ptr->_int = OPA->_int; ptr->_int = OPA->_int;
break; break;
case OP_LOAD_I: case OP_LOAD_I:
@ -864,7 +857,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum)
(pr, "Progs attempted to read an invalid field in an edict\n"); (pr, "Progs attempted to read an invalid field in an edict\n");
return; return;
} }
ed = PROG_TO_EDICT (OPA->edict); ed = PROG_TO_EDICT (pr, OPA->edict);
OPC->_int = ((eval_t *) ((int *) &ed->v + OPB->_int))->_int; OPC->_int = ((eval_t *) ((int *) &ed->v + OPB->_int))->_int;
break; break;

5
source/sv_init.c
View file

@ -192,7 +192,7 @@ SV_SaveSpawnparms (void)
host_client->state = cs_connected; host_client->state = cs_connected;
// call the progs to get default spawn parms for the new client // call the progs to get default spawn parms for the new client
sv_progs.pr_global_struct->self = EDICT_TO_PROG (host_client->edict); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, host_client->edict);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->SetChangeParms); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->SetChangeParms);
for (j = 0; j < NUM_SPAWN_PARMS; j++) for (j = 0; j < NUM_SPAWN_PARMS; j++)
host_client->spawn_parms[j] = (&sv_progs.pr_global_struct->parm1)[j]; host_client->spawn_parms[j] = (&sv_progs.pr_global_struct->parm1)[j];
@ -316,6 +316,7 @@ SV_SpawnServer (char *server)
// restarted // restarted
sv.state = ss_dead; sv.state = ss_dead;
sv_progs.null_bad = 0;
Mod_ClearAll (); Mod_ClearAll ();
Hunk_FreeToLowMark (host_hunklevel); Hunk_FreeToLowMark (host_hunklevel);
@ -391,6 +392,7 @@ SV_SpawnServer (char *server)
// precache and static commands can be issued during // precache and static commands can be issued during
// map initialization // map initialization
sv.state = ss_loading; sv.state = ss_loading;
sv_progs.null_bad = 0;
ent = EDICT_NUM (&sv_progs, 0); ent = EDICT_NUM (&sv_progs, 0);
ent->free = false; ent->free = false;
@ -415,6 +417,7 @@ SV_SpawnServer (char *server)
// all spawning is completed, any further precache statements // all spawning is completed, any further precache statements
// or prog writes to the signon message are errors // or prog writes to the signon message are errors
sv.state = ss_active; sv.state = ss_active;
sv_progs.null_bad = 1;
// run two frames to allow everything to settle // run two frames to allow everything to settle
sv_frametime = 0.1; sv_frametime = 0.1;

5
source/sv_main.c
View file

@ -250,12 +250,12 @@ SV_DropClient (client_t *drop)
if (!drop->spectator) { if (!drop->spectator) {
// call the prog function for removing a client // call the prog function for removing a client
// this will set the body to a dead frame, among other things // this will set the body to a dead frame, among other things
sv_progs.pr_global_struct->self = EDICT_TO_PROG (drop->edict); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, drop->edict);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->ClientDisconnect); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->ClientDisconnect);
} else if (SpectatorDisconnect) { } else if (SpectatorDisconnect) {
// call the prog function for removing a client // call the prog function for removing a client
// this will set the body to a dead frame, among other things // this will set the body to a dead frame, among other things
sv_progs.pr_global_struct->self = EDICT_TO_PROG (drop->edict); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, drop->edict);
PR_ExecuteProgram (&sv_progs, SpectatorDisconnect); PR_ExecuteProgram (&sv_progs, SpectatorDisconnect);
} }
} }
@ -1907,6 +1907,7 @@ SV_Init (void)
COM_Init (); COM_Init ();
PR_Init (); PR_Init ();
SV_Progs_Init ();
Mod_Init (); Mod_Init ();
SV_InitNet (); SV_InitNet ();

12
source/sv_move.c
View file

@ -140,11 +140,11 @@ SV_movestep (edict_t *ent, vec3_t move, qboolean relink)
// try one move with vertical motion, then one without // try one move with vertical motion, then one without
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
VectorAdd (ent->v.origin, move, neworg); VectorAdd (ent->v.origin, move, neworg);
enemy = PROG_TO_EDICT (ent->v.enemy); enemy = PROG_TO_EDICT (&sv_progs, ent->v.enemy);
if (i == 0 && enemy != sv.edicts) { if (i == 0 && enemy != sv.edicts) {
dz = dz =
ent->v.origin[2] - ent->v.origin[2] -
PROG_TO_EDICT (ent->v.enemy)->v.origin[2]; PROG_TO_EDICT (&sv_progs, ent->v.enemy)->v.origin[2];
if (dz > 40) if (dz > 40)
neworg[2] -= 8; neworg[2] -= 8;
if (dz < 30) if (dz < 30)
@ -220,7 +220,7 @@ SV_movestep (edict_t *ent, vec3_t move, qboolean relink)
// Con_Printf ("back on ground\n"); // Con_Printf ("back on ground\n");
ent->v.flags = (int) ent->v.flags & ~FL_PARTIALGROUND; ent->v.flags = (int) ent->v.flags & ~FL_PARTIALGROUND;
} }
ent->v.groundentity = EDICT_TO_PROG (trace.ent); ent->v.groundentity = EDICT_TO_PROG (&sv_progs, trace.ent);
// the move is ok // the move is ok
if (relink) if (relink)
@ -402,8 +402,8 @@ SV_MoveToGoal (progs_t *pr)
edict_t *ent, *goal; edict_t *ent, *goal;
float dist; float dist;
ent = PROG_TO_EDICT (sv_progs.pr_global_struct->self); ent = PROG_TO_EDICT (&sv_progs, sv_progs.pr_global_struct->self);
goal = PROG_TO_EDICT (ent->v.goalentity); goal = PROG_TO_EDICT (&sv_progs, ent->v.goalentity);
dist = G_FLOAT (&sv_progs, OFS_PARM0); dist = G_FLOAT (&sv_progs, OFS_PARM0);
if (!((int) ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) { if (!((int) ent->v.flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) {
@ -411,7 +411,7 @@ SV_MoveToGoal (progs_t *pr)
return; return;
} }
// if the next step hits the enemy, return immediately // if the next step hits the enemy, return immediately
if (PROG_TO_EDICT (ent->v.enemy) != sv.edicts if (PROG_TO_EDICT (&sv_progs, ent->v.enemy) != sv.edicts
&& SV_CloseEnough (ent, goal, dist)) return; && SV_CloseEnough (ent, goal, dist)) return;
// bump around... // bump around...

44
source/sv_phys.c
View file

@ -163,8 +163,8 @@ SV_RunThink (edict_t *ent)
// by a trigger with a local time. // by a trigger with a local time.
ent->v.nextthink = 0; ent->v.nextthink = 0;
sv_progs.pr_global_struct->time = thinktime; sv_progs.pr_global_struct->time = thinktime;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (ent); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, ent);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, sv.edicts);
PR_ExecuteProgram (&sv_progs, ent->v.think); PR_ExecuteProgram (&sv_progs, ent->v.think);
if (ent->free) if (ent->free)
@ -191,14 +191,14 @@ SV_Impact (edict_t *e1, edict_t *e2)
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
if (e1->v.touch && e1->v.solid != SOLID_NOT) { if (e1->v.touch && e1->v.solid != SOLID_NOT) {
sv_progs.pr_global_struct->self = EDICT_TO_PROG (e1); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, e1);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (e2); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, e2);
PR_ExecuteProgram (&sv_progs, e1->v.touch); PR_ExecuteProgram (&sv_progs, e1->v.touch);
} }
if (e2->v.touch && e2->v.solid != SOLID_NOT) { if (e2->v.touch && e2->v.solid != SOLID_NOT) {
sv_progs.pr_global_struct->self = EDICT_TO_PROG (e2); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, e2);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (e1); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, e1);
PR_ExecuteProgram (&sv_progs, e2->v.touch); PR_ExecuteProgram (&sv_progs, e2->v.touch);
} }
@ -309,7 +309,7 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace)
if ((trace.ent->v.solid == SOLID_BSP) if ((trace.ent->v.solid == SOLID_BSP)
|| (trace.ent->v.movetype == MOVETYPE_PPUSH)) { || (trace.ent->v.movetype == MOVETYPE_PPUSH)) {
ent->v.flags = (int) ent->v.flags | FL_ONGROUND; ent->v.flags = (int) ent->v.flags | FL_ONGROUND;
ent->v.groundentity = EDICT_TO_PROG (trace.ent); ent->v.groundentity = EDICT_TO_PROG (&sv_progs, trace.ent);
} }
} }
if (!trace.plane.normal[2]) { if (!trace.plane.normal[2]) {
@ -491,7 +491,7 @@ SV_Push (edict_t *pusher, vec3_t move)
// if the entity is standing on the pusher, it will definately be // if the entity is standing on the pusher, it will definately be
// moved // moved
if (!(((int) check->v.flags & FL_ONGROUND) if (!(((int) check->v.flags & FL_ONGROUND)
&& PROG_TO_EDICT (check->v.groundentity) == pusher)) { && PROG_TO_EDICT (&sv_progs, check->v.groundentity) == pusher)) {
if (check->v.absmin[0] >= maxs[0] if (check->v.absmin[0] >= maxs[0]
|| check->v.absmin[1] >= maxs[1] || check->v.absmin[1] >= maxs[1]
|| check->v.absmin[2] >= maxs[2] || check->v.absmin[2] >= maxs[2]
@ -541,8 +541,8 @@ SV_Push (edict_t *pusher, vec3_t move)
// if the pusher has a "blocked" function, call it // if the pusher has a "blocked" function, call it
// otherwise, just stay in place until the obstacle is gone // otherwise, just stay in place until the obstacle is gone
if (pusher->v.blocked) { if (pusher->v.blocked) {
sv_progs.pr_global_struct->self = EDICT_TO_PROG (pusher); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, pusher);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (check); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, check);
PR_ExecuteProgram (&sv_progs, pusher->v.blocked); PR_ExecuteProgram (&sv_progs, pusher->v.blocked);
} }
// move back any entities we already moved // move back any entities we already moved
@ -616,8 +616,8 @@ SV_Physics_Pusher (edict_t *ent)
VectorCopy (ent->v.origin, oldorg); VectorCopy (ent->v.origin, oldorg);
ent->v.nextthink = 0; ent->v.nextthink = 0;
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (ent); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, ent);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, sv.edicts);
PR_ExecuteProgram (&sv_progs, ent->v.think); PR_ExecuteProgram (&sv_progs, ent->v.think);
if (ent->free) if (ent->free)
return; return;
@ -764,7 +764,7 @@ SV_Physics_Toss (edict_t *ent)
if (trace.plane.normal[2] > 0.7) { if (trace.plane.normal[2] > 0.7) {
if (ent->v.velocity[2] < 60 || ent->v.movetype != MOVETYPE_BOUNCE) { if (ent->v.velocity[2] < 60 || ent->v.movetype != MOVETYPE_BOUNCE) {
ent->v.flags = (int) ent->v.flags | FL_ONGROUND; ent->v.flags = (int) ent->v.flags | FL_ONGROUND;
ent->v.groundentity = EDICT_TO_PROG (trace.ent); ent->v.groundentity = EDICT_TO_PROG (&sv_progs, trace.ent);
VectorCopy (vec3_origin, ent->v.velocity); VectorCopy (vec3_origin, ent->v.velocity);
VectorCopy (vec3_origin, ent->v.avelocity); VectorCopy (vec3_origin, ent->v.avelocity);
} }
@ -881,8 +881,8 @@ SV_PPushMove (edict_t *pusher, float movetime) // player push
// Stage 4: Yes, it must be. Fail the move. // Stage 4: Yes, it must be. Fail the move.
VectorCopy (pusher->v.origin, pusher->v.oldorigin); // Revert VectorCopy (pusher->v.origin, pusher->v.oldorigin); // Revert
if (pusher->v.blocked) { // Blocked func? if (pusher->v.blocked) { // Blocked func?
sv_progs.pr_global_struct->self = EDICT_TO_PROG (pusher); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, pusher);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (check); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, check);
PR_ExecuteProgram (&sv_progs, pusher->v.blocked); PR_ExecuteProgram (&sv_progs, pusher->v.blocked);
} }
@ -918,8 +918,8 @@ SV_Physics_PPusher (edict_t *ent)
if (thinktime > oldltime && thinktime <= ent->v.ltime) { if (thinktime > oldltime && thinktime <= ent->v.ltime) {
ent->v.nextthink = 0; ent->v.nextthink = 0;
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (ent); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, ent);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, sv.edicts);
PR_ExecuteProgram (&sv_progs, ent->v.think); PR_ExecuteProgram (&sv_progs, ent->v.think);
if (ent->free) if (ent->free)
return; return;
@ -932,8 +932,8 @@ void
SV_ProgStartFrame (void) SV_ProgStartFrame (void)
{ {
// let the progs know that a new frame has started // let the progs know that a new frame has started
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv.edicts);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, sv.edicts);
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->StartFrame); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->StartFrame);
} }
@ -991,7 +991,7 @@ SV_RunNewmis (void)
if (!sv_progs.pr_global_struct->newmis) if (!sv_progs.pr_global_struct->newmis)
return; return;
ent = PROG_TO_EDICT (sv_progs.pr_global_struct->newmis); ent = PROG_TO_EDICT (&sv_progs, sv_progs.pr_global_struct->newmis);
sv_frametime = 0.05; sv_frametime = 0.05;
sv_progs.pr_global_struct->newmis = 0; sv_progs.pr_global_struct->newmis = 0;
@ -1049,8 +1049,8 @@ SV_Physics (void)
// 2000-01-02 EndFrame function by Maddes/FrikaC start // 2000-01-02 EndFrame function by Maddes/FrikaC start
if (EndFrame) { if (EndFrame) {
// let the progs know that the frame has ended // let the progs know that the frame has ended
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv.edicts);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (sv.edicts); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, sv.edicts);
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
PR_ExecuteProgram (&sv_progs, EndFrame); PR_ExecuteProgram (&sv_progs, EndFrame);
} }

45
source/sv_progs.c
View file

@ -30,7 +30,9 @@
# include "config.h" # include "config.h"
#endif #endif
#include "cmd.h"
#include "progs.h" #include "progs.h"
#include "server.h"
int eval_alpha, eval_scale, eval_glowsize, eval_glowcolor, eval_colormod; int eval_alpha, eval_scale, eval_glowsize, eval_glowcolor, eval_colormod;
progs_t sv_progs; progs_t sv_progs;
@ -67,4 +69,45 @@ FindEdictFieldOffsets (progs_t *pr)
eval_glowcolor = FindFieldOffset (&sv_progs, "glow_color"); eval_glowcolor = FindFieldOffset (&sv_progs, "glow_color");
eval_colormod = FindFieldOffset (&sv_progs, "colormod"); eval_colormod = FindFieldOffset (&sv_progs, "colormod");
} }
}; }
void
SV_Progs_Init (void)
{
sv_progs.edicts = &sv.edicts;
sv_progs.num_edicts = &sv.num_edicts;
sv_progs.time = &sv.time;
}
void
ED_PrintEdicts_f (void)
{
ED_PrintEdicts (&sv_progs);
}
/*
ED_PrintEdict_f
For debugging, prints a single edicy
*/
void
ED_PrintEdict_f (void)
{
int i;
i = atoi (Cmd_Argv (1));
Con_Printf ("\n EDICT %i:\n", i);
ED_PrintNum (&sv_progs, i);
}
void
ED_Count_f (void)
{
ED_Count (&sv_progs);
}
void
PR_Profile_f (void)
{
PR_Profile (&sv_progs);
}

2
source/sv_send.c
View file

@ -527,7 +527,7 @@ SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg)
} }
// send a damage message if the player got hit this frame // send a damage message if the player got hit this frame
if (ent->v.dmg_take || ent->v.dmg_save) { if (ent->v.dmg_take || ent->v.dmg_save) {
other = PROG_TO_EDICT (ent->v.dmg_inflictor); other = PROG_TO_EDICT (&sv_progs, ent->v.dmg_inflictor);
MSG_WriteByte (msg, svc_damage); MSG_WriteByte (msg, svc_damage);
MSG_WriteByte (msg, ent->v.dmg_save); MSG_WriteByte (msg, ent->v.dmg_save);
MSG_WriteByte (msg, ent->v.dmg_take); MSG_WriteByte (msg, ent->v.dmg_take);

30
source/sv_user.c
View file

@ -498,7 +498,7 @@ SV_Begin_f (void)
// call the spawn function // call the spawn function
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, SpectatorConnect); PR_ExecuteProgram (&sv_progs, SpectatorConnect);
} }
} else { } else {
@ -508,12 +508,12 @@ SV_Begin_f (void)
// call the spawn function // call the spawn function
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->ClientConnect); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->ClientConnect);
// actually spawn the player // actually spawn the player
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->PutClientInServer); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->PutClientInServer);
} }
@ -946,7 +946,7 @@ SV_Kill_f (void)
} }
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->ClientKill); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->ClientKill);
} }
@ -1054,7 +1054,7 @@ SV_PTrack_f (void)
host_client->spec_track = 0; host_client->spec_track = 0;
ent = EDICT_NUM (&sv_progs, host_client - svs.clients + 1); ent = EDICT_NUM (&sv_progs, host_client - svs.clients + 1);
tent = EDICT_NUM (&sv_progs, 0); tent = EDICT_NUM (&sv_progs, 0);
ent->v.goalentity = EDICT_TO_PROG (tent); ent->v.goalentity = EDICT_TO_PROG (&sv_progs, tent);
return; return;
} }
@ -1065,14 +1065,14 @@ SV_PTrack_f (void)
host_client->spec_track = 0; host_client->spec_track = 0;
ent = EDICT_NUM (&sv_progs, host_client - svs.clients + 1); ent = EDICT_NUM (&sv_progs, host_client - svs.clients + 1);
tent = EDICT_NUM (&sv_progs, 0); tent = EDICT_NUM (&sv_progs, 0);
ent->v.goalentity = EDICT_TO_PROG (tent); ent->v.goalentity = EDICT_TO_PROG (&sv_progs, tent);
return; return;
} }
host_client->spec_track = i + 1; // now tracking host_client->spec_track = i + 1; // now tracking
ent = EDICT_NUM (&sv_progs, host_client - svs.clients + 1); ent = EDICT_NUM (&sv_progs, host_client - svs.clients + 1);
tent = EDICT_NUM (&sv_progs, i + 1); tent = EDICT_NUM (&sv_progs, i + 1);
ent->v.goalentity = EDICT_TO_PROG (tent); ent->v.goalentity = EDICT_TO_PROG (&sv_progs, tent);
} }
@ -1324,7 +1324,7 @@ AddLinksToPmove (areanode_t *node)
int i; int i;
physent_t *pe; physent_t *pe;
pl = EDICT_TO_PROG (sv_player); pl = EDICT_TO_PROG (&sv_progs, sv_player);
// touch linked edicts // touch linked edicts
for (l = node->solid_edicts.next; l != &node->solid_edicts; l = next) { for (l = node->solid_edicts.next; l != &node->solid_edicts; l = next) {
@ -1390,7 +1390,7 @@ AddAllEntsToPmove (void)
physent_t *pe; physent_t *pe;
int pl; int pl;
pl = EDICT_TO_PROG (sv_player); pl = EDICT_TO_PROG (&sv_progs, sv_player);
check = NEXT_EDICT (&sv_progs, sv.edicts); check = NEXT_EDICT (&sv_progs, sv.edicts);
for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_progs, check)) { for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_progs, check)) {
if (check->free) if (check->free)
@ -1534,7 +1534,7 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside)
sv_progs.pr_global_struct->frametime = sv_frametime; sv_progs.pr_global_struct->frametime = sv_frametime;
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->PlayerPreThink); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->PlayerPreThink);
SV_RunThink (sv_player); SV_RunThink (sv_player);
@ -1591,7 +1591,7 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside)
if (onground != -1) { if (onground != -1) {
sv_player->v.flags = (int) sv_player->v.flags | FL_ONGROUND; sv_player->v.flags = (int) sv_player->v.flags | FL_ONGROUND;
sv_player->v.groundentity = sv_player->v.groundentity =
EDICT_TO_PROG (EDICT_NUM (&sv_progs, pmove.physents[onground].info)); EDICT_TO_PROG (&sv_progs, EDICT_NUM (&sv_progs, pmove.physents[onground].info));
} else { } else {
sv_player->v.flags = (int) sv_player->v.flags & ~FL_ONGROUND; sv_player->v.flags = (int) sv_player->v.flags & ~FL_ONGROUND;
} }
@ -1619,8 +1619,8 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside)
ent = EDICT_NUM (&sv_progs, n); ent = EDICT_NUM (&sv_progs, n);
if (!ent->v.touch || (playertouch[n / 8] & (1 << (n % 8)))) if (!ent->v.touch || (playertouch[n / 8] & (1 << (n % 8))))
continue; continue;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (ent); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, ent);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, ent->v.touch); PR_ExecuteProgram (&sv_progs, ent->v.touch);
playertouch[n / 8] |= 1 << (n % 8); playertouch[n / 8] |= 1 << (n % 8);
} }
@ -1640,12 +1640,12 @@ SV_PostRunCmd (void)
if (!host_client->spectator) { if (!host_client->spectator) {
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->PlayerPostThink); PR_ExecuteProgram (&sv_progs, sv_progs.pr_global_struct->PlayerPostThink);
SV_RunNewmis (); SV_RunNewmis ();
} else if (SpectatorThink) { } else if (SpectatorThink) {
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (sv_player); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, sv_player);
PR_ExecuteProgram (&sv_progs, SpectatorThink); PR_ExecuteProgram (&sv_progs, SpectatorThink);
} }
} }

8
source/world.c
View file

@ -316,8 +316,8 @@ SV_TouchLinks (edict_t *ent, areanode_t *node)
old_self = sv_progs.pr_global_struct->self; old_self = sv_progs.pr_global_struct->self;
old_other = sv_progs.pr_global_struct->other; old_other = sv_progs.pr_global_struct->other;
sv_progs.pr_global_struct->self = EDICT_TO_PROG (touch); sv_progs.pr_global_struct->self = EDICT_TO_PROG (&sv_progs, touch);
sv_progs.pr_global_struct->other = EDICT_TO_PROG (ent); sv_progs.pr_global_struct->other = EDICT_TO_PROG (&sv_progs, ent);
sv_progs.pr_global_struct->time = sv.time; sv_progs.pr_global_struct->time = sv.time;
PR_ExecuteProgram (&sv_progs, touch->v.touch); PR_ExecuteProgram (&sv_progs, touch->v.touch);
@ -777,9 +777,9 @@ SV_ClipToLinks (areanode_t *node, moveclip_t * clip)
if (clip->trace.allsolid) if (clip->trace.allsolid)
return; return;
if (clip->passedict) { if (clip->passedict) {
if (PROG_TO_EDICT (touch->v.owner) == clip->passedict) if (PROG_TO_EDICT (&sv_progs, touch->v.owner) == clip->passedict)
continue; // don't clip against own missiles continue; // don't clip against own missiles
if (PROG_TO_EDICT (clip->passedict->v.owner) == touch) if (PROG_TO_EDICT (&sv_progs, clip->passedict->v.owner) == touch)
continue; // don't clip against owner continue; // don't clip against owner
} }