diff --git a/include/progs.h b/include/progs.h index 7a452113d..101fb3b2a 100644 --- a/include/progs.h +++ b/include/progs.h @@ -130,7 +130,7 @@ int NUM_FOR_EDICT(progs_t *pr, edict_t *e); #define E_FLOAT(e,o) E_var (e, o, float) #define E_INT(e,o) E_var (e, o, int) -#define E_VECTOR(e,o) (&E_FLOAT (e, o)) +#define E_VECTOR(e,o) E_var (e, o, vector) #define E_STRING(p,e,o) (PR_GetString (p, E_var (e, o, string))) extern int type_size[8]; diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index cdc1f4902..de79439b0 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -33,7 +33,6 @@ #define __sv_progs_h #include "progs.h" -#include "progdefs.h" typedef struct { int *self; @@ -82,4 +81,90 @@ typedef struct { extern sv_funcs_t sv_funcs; +typedef struct +{ + int modelindex; //float * + int absmin; //vec3_t * * + int absmax; //vec3_t * + int ltime; //float * + int lastruntime; //float * + int movetype; //float * + int solid; //float * + int origin; //vec3_t * + int oldorigin; //vec3_t * + int velocity; //vec3_t * + int angles; //vec3_t * + int avelocity; //vec3_t * + int classname; //string_t + int model; //string_t * + int frame; //float * + int skin; //float * + int effects; //float * + int mins; //vec3_t * + int maxs; //vec3_t * + int size; //vec3_t * + int touch; //func_t * + //int use; //func_t + int think; //func_t * + int blocked; //func_t * + int nextthink; //float * + int groundentity; //int * + int health; //float * + int frags; //float * + int weapon; //float * + int weaponmodel; //string_t * + int weaponframe; //float * + int currentammo; //float + int ammo_shells; //float * + int ammo_nails; //float * + int ammo_rockets; //float * + int ammo_cells; //float * + int items; //float * + int takedamage; //float + int chain; //int * + //int deadflag; //float + int view_ofs; //vec3_t * + int button0; //float * + int button1; //float * + int button2; //float * + int impulse; //float + int fixangle; //float * + int v_angle; //vec3_t * + int netname; //string_t * + int enemy; //int * + int flags; //float * + int colormap; //float * + int team; //float + //int max_health; //float + int teleport_time; //float * + //int armortype; //float + int armorvalue; //float * + int waterlevel; //float * + int watertype; //float * + int ideal_yaw; //float * + int yaw_speed; //float * + //int aiment; //int + int goalentity; //int * + int spawnflags; //float * + //int target; //string_t + //int targetname; //string_t + int dmg_take; //float * + int dmg_save; //float * + int dmg_inflictor; //int * + int owner; //int + //int movedir; //vec3_t + int message; //string_t + int sounds; //float + //int noise; //string_t + //int noise1; //string_t + //int noise2; //string_t + //int noise3; //string_t +} sv_fields_t; + +extern sv_fields_t sv_fields; + +#define SVFIELD(e,f,t) E_var (e, sv_fields.f, t) + +#define PROGHEADER_CRC 54730 + #endif // __sv_progs_h diff --git a/qw/source/sv_ccmds.c b/qw/source/sv_ccmds.c index 7687ba4f7..0aa8327a1 100644 --- a/qw/source/sv_ccmds.c +++ b/qw/source/sv_ccmds.c @@ -217,8 +217,8 @@ SV_God_f (void) if (!SV_SetPlayer ()) return; - ((entvars_t*)&sv_player->v)->flags = (int) ((entvars_t*)&sv_player->v)->flags ^ FL_GODMODE; - if (!((int) ((entvars_t*)&sv_player->v)->flags & FL_GODMODE)) + SVFIELD (sv_player, flags, float) = (int) SVFIELD (sv_player, flags, float) ^ FL_GODMODE; + if (!((int) SVFIELD (sv_player, flags, float) & FL_GODMODE)) SV_ClientPrintf (host_client, PRINT_HIGH, "godmode OFF\n"); else SV_ClientPrintf (host_client, PRINT_HIGH, "godmode ON\n"); @@ -237,11 +237,11 @@ SV_Noclip_f (void) if (!SV_SetPlayer ()) return; - if (((entvars_t*)&sv_player->v)->movetype != MOVETYPE_NOCLIP) { - ((entvars_t*)&sv_player->v)->movetype = MOVETYPE_NOCLIP; + if (SVFIELD (sv_player, movetype, float) != MOVETYPE_NOCLIP) { + SVFIELD (sv_player, movetype, float) = MOVETYPE_NOCLIP; SV_ClientPrintf (host_client, PRINT_HIGH, "noclip ON\n"); } else { - ((entvars_t*)&sv_player->v)->movetype = MOVETYPE_WALK; + SVFIELD (sv_player, movetype, float) = MOVETYPE_WALK; SV_ClientPrintf (host_client, PRINT_HIGH, "noclip OFF\n"); } } @@ -277,24 +277,24 @@ SV_Give_f (void) case '7': case '8': case '9': - ((entvars_t*)&sv_player->v)->items = - (int) ((entvars_t*)&sv_player->v)->items | IT_SHOTGUN << (t[0] - '2'); + SVFIELD (sv_player, items, float) = + (int) SVFIELD (sv_player, items, float) | IT_SHOTGUN << (t[0] - '2'); break; case 's': - ((entvars_t*)&sv_player->v)->ammo_shells = v; + SVFIELD (sv_player, ammo_shells, float) = v; break; case 'n': - ((entvars_t*)&sv_player->v)->ammo_nails = v; + SVFIELD (sv_player, ammo_nails, float) = v; break; case 'r': - ((entvars_t*)&sv_player->v)->ammo_rockets = v; + SVFIELD (sv_player, ammo_rockets, float) = v; break; case 'h': - ((entvars_t*)&sv_player->v)->health = v; + SVFIELD (sv_player, health, float) = v; break; case 'c': - ((entvars_t*)&sv_player->v)->ammo_cells = v; + SVFIELD (sv_player, ammo_cells, float) = v; break; } } @@ -415,7 +415,7 @@ SV_Status_f (void) Con_Printf ("%-16.16s ", cl->name); - Con_Printf ("%6i %5i", cl->userid, (int) ((entvars_t*)&cl->edict->v)->frags); + Con_Printf ("%6i %5i", cl->userid, (int) SVFIELD (cl->edict, frags, float)); if (cl->spectator) Con_Printf (" (s)\n"); else @@ -445,7 +445,7 @@ SV_Status_f (void) for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++) { if (!cl->state) continue; - Con_Printf ("%5i %6i ", (int) ((entvars_t*)&cl->edict->v)->frags, cl->userid); + Con_Printf ("%5i %6i ", (int) SVFIELD (cl->edict, frags, float), cl->userid); s = NET_BaseAdrToString (cl->netchan.remote_address); diff --git a/qw/source/sv_ents.c b/qw/source/sv_ents.c index 026b160ee..109cf3fa5 100644 --- a/qw/source/sv_ents.c +++ b/qw/source/sv_ents.c @@ -118,8 +118,8 @@ extern int sv_nailmodel, sv_supernailmodel, sv_playermodel; qboolean SV_AddNailUpdate (edict_t *ent) { - if (((entvars_t*)&ent->v)->modelindex != sv_nailmodel - && ((entvars_t*)&ent->v)->modelindex != sv_supernailmodel) return false; + if (SVFIELD (ent, modelindex, float) != sv_nailmodel + && SVFIELD (ent, modelindex, float) != sv_supernailmodel) return false; if (numnails == MAX_NAILS) return true; nails[numnails] = ent; @@ -143,11 +143,11 @@ SV_EmitNailUpdate (sizebuf_t *msg) for (n = 0; n < numnails; n++) { ent = nails[n]; - x = (int) (((entvars_t*)&ent->v)->origin[0] + 4096) >> 1; - y = (int) (((entvars_t*)&ent->v)->origin[1] + 4096) >> 1; - z = (int) (((entvars_t*)&ent->v)->origin[2] + 4096) >> 1; - p = (int) (16 * ((entvars_t*)&ent->v)->angles[0] / 360) & 15; - yaw = (int) (256 * ((entvars_t*)&ent->v)->angles[1] / 360) & 255; + x = (int) (SVFIELD (ent, origin, vector)[0] + 4096) >> 1; + y = (int) (SVFIELD (ent, origin, vector)[1] + 4096) >> 1; + z = (int) (SVFIELD (ent, origin, vector)[2] + 4096) >> 1; + p = (int) (16 * SVFIELD (ent, angles, vector)[0] / 360) & 15; + yaw = (int) (256 * SVFIELD (ent, angles, vector)[1] / 360) & 255; bits[0] = x; bits[1] = (x >> 8) | (y << 4); @@ -417,18 +417,18 @@ SV_WritePlayersToClient (client_t *client, edict_t *clent, byte * pvs, pflags = PF_MSEC | PF_COMMAND; - if (((entvars_t*)&ent->v)->modelindex != sv_playermodel) + if (SVFIELD (ent, modelindex, float) != sv_playermodel) pflags |= PF_MODEL; for (i = 0; i < 3; i++) - if (((entvars_t*)&ent->v)->velocity[i]) + if (SVFIELD (ent, velocity, vector)[i]) pflags |= PF_VELOCITY1 << i; - if (((entvars_t*)&ent->v)->effects) + if (SVFIELD (ent, effects, float)) pflags |= PF_EFFECTS; - if (((entvars_t*)&ent->v)->skin) + if (SVFIELD (ent, skin, float)) pflags |= PF_SKINNUM; - if (((entvars_t*)&ent->v)->health <= 0) + if (SVFIELD (ent, health, float) <= 0) pflags |= PF_DEAD; - if (((entvars_t*)&ent->v)->mins[2] != -24) + if (SVFIELD (ent, mins, vector)[2] != -24) pflags |= PF_GIB; if (cl->spectator) { // only sent origin and velocity to @@ -437,21 +437,21 @@ SV_WritePlayersToClient (client_t *client, edict_t *clent, byte * pvs, } else if (ent == clent) { // don't send a lot of data on // personal entity pflags &= ~(PF_MSEC | PF_COMMAND); - if (((entvars_t*)&ent->v)->weaponframe) + if (SVFIELD (ent, weaponframe, float)) pflags |= PF_WEAPONFRAME; } if (client->spec_track && client->spec_track - 1 == j && - ((entvars_t*)&ent->v)->weaponframe) pflags |= PF_WEAPONFRAME; + SVFIELD (ent, weaponframe, float)) pflags |= PF_WEAPONFRAME; MSG_WriteByte (msg, svc_playerinfo); MSG_WriteByte (msg, j); MSG_WriteShort (msg, pflags); for (i = 0; i < 3; i++) - MSG_WriteCoord (msg, ((entvars_t*)&ent->v)->origin[i]); + MSG_WriteCoord (msg, SVFIELD (ent, origin, vector)[i]); - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->frame); + MSG_WriteByte (msg, SVFIELD (ent, frame, float)); if (pflags & PF_MSEC) { msec = 1000 * (sv.time - cl->localtime); @@ -463,10 +463,10 @@ SV_WritePlayersToClient (client_t *client, edict_t *clent, byte * pvs, if (pflags & PF_COMMAND) { cmd = cl->lastcmd; - if (((entvars_t*)&ent->v)->health <= 0) { // don't show the corpse looking + if (SVFIELD (ent, health, float) <= 0) { // don't show the corpse looking // around... cmd.angles[0] = 0; - cmd.angles[1] = ((entvars_t*)&ent->v)->angles[1]; + cmd.angles[1] = SVFIELD (ent, angles, vector)[1]; cmd.angles[0] = 0; } @@ -478,19 +478,19 @@ SV_WritePlayersToClient (client_t *client, edict_t *clent, byte * pvs, for (i = 0; i < 3; i++) if (pflags & (PF_VELOCITY1 << i)) - MSG_WriteShort (msg, ((entvars_t*)&ent->v)->velocity[i]); + MSG_WriteShort (msg, SVFIELD (ent, velocity, vector)[i]); if (pflags & PF_MODEL) - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->modelindex); + MSG_WriteByte (msg, SVFIELD (ent, modelindex, float)); if (pflags & PF_SKINNUM) - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->skin); + MSG_WriteByte (msg, SVFIELD (ent, skin, float)); if (pflags & PF_EFFECTS) - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->effects); + MSG_WriteByte (msg, SVFIELD (ent, effects, float)); if (pflags & PF_WEAPONFRAME) - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->weaponframe); + MSG_WriteByte (msg, SVFIELD (ent, weaponframe, float)); } } @@ -520,7 +520,7 @@ SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg) // find the client's PVS clent = client->edict; - VectorAdd (((entvars_t*)&clent->v)->origin, ((entvars_t*)&clent->v)->view_ofs, org); + VectorAdd (SVFIELD (clent, origin, vector), SVFIELD (clent, view_ofs, vector), org); pvs = SV_FatPVS (org); // send over the players in the PVS @@ -536,7 +536,7 @@ SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg) for (e = MAX_CLIENTS + 1, ent = EDICT_NUM (&sv_pr_state, e); e < sv.num_edicts; e++, ent = NEXT_EDICT (&sv_pr_state, ent)) { // ignore ents without visible models - if (!((entvars_t*)&ent->v)->modelindex || !*PR_GetString (&sv_pr_state, ((entvars_t*)&ent->v)->model)) + if (!SVFIELD (ent, modelindex, float) || !*PR_GetString (&sv_pr_state, SVFIELD (ent, model, string))) continue; // ignore if not touching a PV leaf @@ -559,13 +559,13 @@ SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg) state->number = e; state->flags = 0; - VectorCopy (((entvars_t*)&ent->v)->origin, state->origin); - VectorCopy (((entvars_t*)&ent->v)->angles, state->angles); - state->modelindex = ((entvars_t*)&ent->v)->modelindex; - state->frame = ((entvars_t*)&ent->v)->frame; - state->colormap = ((entvars_t*)&ent->v)->colormap; - state->skinnum = ((entvars_t*)&ent->v)->skin; - state->effects = ((entvars_t*)&ent->v)->effects; + VectorCopy (SVFIELD (ent, origin, vector), state->origin); + VectorCopy (SVFIELD (ent, angles, vector), state->angles); + state->modelindex = SVFIELD (ent, modelindex, float); + state->frame = SVFIELD (ent, frame, float); + state->colormap = SVFIELD (ent, colormap, float); + state->skinnum = SVFIELD (ent, skin, float); + state->effects = SVFIELD (ent, effects, float); // LordHavoc: cleaned up Endy's coding style, shortened the code, // and implemented missing effects diff --git a/qw/source/sv_init.c b/qw/source/sv_init.c index 372eeca48..187462534 100644 --- a/qw/source/sv_init.c +++ b/qw/source/sv_init.c @@ -111,23 +111,23 @@ SV_CreateBaseline (void) continue; // create baselines for all player slots, // and any other edict that has a visible model - if (entnum > MAX_CLIENTS && !((entvars_t*)&svent->v)->modelindex) + if (entnum > MAX_CLIENTS && !SVFIELD (svent, modelindex, float)) continue; // // create entity baseline // - VectorCopy (((entvars_t*)&svent->v)->origin, ((entity_state_t*)svent->data)->origin); - VectorCopy (((entvars_t*)&svent->v)->angles, ((entity_state_t*)svent->data)->angles); - ((entity_state_t*)svent->data)->frame = ((entvars_t*)&svent->v)->frame; - ((entity_state_t*)svent->data)->skinnum = ((entvars_t*)&svent->v)->skin; + VectorCopy (SVFIELD (svent, origin, vector), ((entity_state_t*)svent->data)->origin); + VectorCopy (SVFIELD (svent, angles, vector), ((entity_state_t*)svent->data)->angles); + ((entity_state_t*)svent->data)->frame = SVFIELD (svent, frame, float); + ((entity_state_t*)svent->data)->skinnum = SVFIELD (svent, skin, float); if (entnum > 0 && entnum <= MAX_CLIENTS) { ((entity_state_t*)svent->data)->colormap = entnum; ((entity_state_t*)svent->data)->modelindex = SV_ModelIndex ("progs/player.mdl"); } else { ((entity_state_t*)svent->data)->colormap = 0; ((entity_state_t*)svent->data)->modelindex = - SV_ModelIndex (PR_GetString (&sv_pr_state, ((entvars_t*)&svent->v)->model)); + SV_ModelIndex (PR_GetString (&sv_pr_state, SVFIELD (svent, model, string))); } // LordHavoc: setup baseline to include new effects ((entity_state_t*)svent->data)->alpha = 255; @@ -397,10 +397,10 @@ SV_SpawnServer (char *server) ent = EDICT_NUM (&sv_pr_state, 0); ent->free = false; - ((entvars_t*)&ent->v)->model = PR_SetString (&sv_pr_state, sv.worldmodel->name); - ((entvars_t*)&ent->v)->modelindex = 1; // world model - ((entvars_t*)&ent->v)->solid = SOLID_BSP; - ((entvars_t*)&ent->v)->movetype = MOVETYPE_PUSH; + SVFIELD (ent, model, string) = PR_SetString (&sv_pr_state, sv.worldmodel->name); + SVFIELD (ent, modelindex, float) = 1; // world model + SVFIELD (ent, solid, float) = SOLID_BSP; + SVFIELD (ent, movetype, float) = MOVETYPE_PUSH; *sv_globals.mapname = PR_SetString (&sv_pr_state, sv.name); // serverflags are for cross level information (sigils) diff --git a/qw/source/sv_main.c b/qw/source/sv_main.c index 839cb97fe..ed4157078 100644 --- a/qw/source/sv_main.c +++ b/qw/source/sv_main.c @@ -279,7 +279,7 @@ SV_DropClient (client_t *drop) drop->connection_started = realtime; // for zombie timeout drop->old_frags = 0; - ((entvars_t*)&drop->edict->v)->frags = 0; + SVFIELD (drop->edict, frags, float) = 0; drop->name[0] = 0; memset (drop->userinfo, 0, sizeof (drop->userinfo)); diff --git a/qw/source/sv_move.c b/qw/source/sv_move.c index 327fe9bec..31ddf1fbc 100644 --- a/qw/source/sv_move.c +++ b/qw/source/sv_move.c @@ -58,8 +58,8 @@ SV_CheckBottom (edict_t *ent) int x, y; float mid, bottom; - VectorAdd (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, mins); - VectorAdd (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->maxs, maxs); + VectorAdd (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), mins); + VectorAdd (SVFIELD (ent, origin, vector), SVFIELD (ent, maxs, vector), maxs); // if all of the points under the corners are solid world, don't bother // with the tougher checks @@ -130,34 +130,34 @@ SV_movestep (edict_t *ent, vec3_t move, qboolean relink) edict_t *enemy; // try the move - VectorCopy (((entvars_t*)&ent->v)->origin, oldorg); - VectorAdd (((entvars_t*)&ent->v)->origin, move, neworg); + VectorCopy (SVFIELD (ent, origin, vector), oldorg); + VectorAdd (SVFIELD (ent, origin, vector), move, neworg); // flying monsters don't step up - if ((int) ((entvars_t*)&ent->v)->flags & (FL_SWIM | FL_FLY)) { + if ((int) SVFIELD (ent, flags, float) & (FL_SWIM | FL_FLY)) { // try one move with vertical motion, then one without for (i = 0; i < 2; i++) { - VectorAdd (((entvars_t*)&ent->v)->origin, move, neworg); - enemy = PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&ent->v)->enemy); + VectorAdd (SVFIELD (ent, origin, vector), move, neworg); + enemy = PROG_TO_EDICT (&sv_pr_state, SVFIELD (ent, enemy, int)); if (i == 0 && enemy != sv.edicts) { dz = - ((entvars_t*)&ent->v)->origin[2] - - ((entvars_t*)&PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&ent->v)->enemy)->v)->origin[2]; + SVFIELD (ent, origin, vector)[2] - + SVFIELD (PROG_TO_EDICT (&sv_pr_state, SVFIELD (ent, enemy, int)), origin, vector)[2]; if (dz > 40) neworg[2] -= 8; if (dz < 30) neworg[2] += 8; } trace = - SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, neworg, false, + SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), neworg, false, ent); if (trace.fraction == 1) { - if (((int) ((entvars_t*)&ent->v)->flags & FL_SWIM) + if (((int) SVFIELD (ent, flags, float) & FL_SWIM) && SV_PointContents (trace.endpos) == CONTENTS_EMPTY) return false; // swim monster left water - VectorCopy (trace.endpos, ((entvars_t*)&ent->v)->origin); + VectorCopy (trace.endpos, SVFIELD (ent, origin, vector)); if (relink) SV_LinkEdict (ent, true); return true; @@ -174,24 +174,24 @@ SV_movestep (edict_t *ent, vec3_t move, qboolean relink) VectorCopy (neworg, end); end[2] -= STEPSIZE * 2; - trace = SV_Move (neworg, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, false, ent); + trace = SV_Move (neworg, SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, false, ent); if (trace.allsolid) return false; if (trace.startsolid) { neworg[2] -= STEPSIZE; - trace = SV_Move (neworg, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, false, ent); + trace = SV_Move (neworg, SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, false, ent); if (trace.allsolid || trace.startsolid) return false; } if (trace.fraction == 1) { // if monster had the ground pulled out, go ahead and fall - if ((int) ((entvars_t*)&ent->v)->flags & FL_PARTIALGROUND) { - VectorAdd (((entvars_t*)&ent->v)->origin, move, ((entvars_t*)&ent->v)->origin); + if ((int) SVFIELD (ent, flags, float) & FL_PARTIALGROUND) { + VectorAdd (SVFIELD (ent, origin, vector), move, SVFIELD (ent, origin, vector)); if (relink) SV_LinkEdict (ent, true); - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags & ~FL_ONGROUND; + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) & ~FL_ONGROUND; // Con_Printf ("fall down\n"); return true; } @@ -199,10 +199,10 @@ SV_movestep (edict_t *ent, vec3_t move, qboolean relink) return false; // walked off an edge } // check point traces down for dangling corners - VectorCopy (trace.endpos, ((entvars_t*)&ent->v)->origin); + VectorCopy (trace.endpos, SVFIELD (ent, origin, vector)); if (!SV_CheckBottom (ent)) { - if ((int) ((entvars_t*)&ent->v)->flags & FL_PARTIALGROUND) { // entity had floor + if ((int) SVFIELD (ent, flags, float) & FL_PARTIALGROUND) { // entity had floor // mostly pulled out // from underneath it // and is trying to correct @@ -210,15 +210,15 @@ SV_movestep (edict_t *ent, vec3_t move, qboolean relink) SV_LinkEdict (ent, true); return true; } - VectorCopy (oldorg, ((entvars_t*)&ent->v)->origin); + VectorCopy (oldorg, SVFIELD (ent, origin, vector)); return false; } - if ((int) ((entvars_t*)&ent->v)->flags & FL_PARTIALGROUND) { + if ((int) SVFIELD (ent, flags, float) & FL_PARTIALGROUND) { // Con_Printf ("back on ground\n"); - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags & ~FL_PARTIALGROUND; + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) & ~FL_PARTIALGROUND; } - ((entvars_t*)&ent->v)->groundentity = EDICT_TO_PROG (&sv_pr_state, trace.ent); + SVFIELD (ent, groundentity, int) = EDICT_TO_PROG (&sv_pr_state, trace.ent); // the move is ok if (relink) @@ -241,7 +241,7 @@ SV_StepDirection (edict_t *ent, float yaw, float dist) vec3_t move, oldorigin; float delta; - ((entvars_t*)&ent->v)->ideal_yaw = yaw; + SVFIELD (ent, ideal_yaw, float) = yaw; PF_changeyaw (&sv_pr_state); yaw = yaw * M_PI * 2 / 360; @@ -249,12 +249,12 @@ SV_StepDirection (edict_t *ent, float yaw, float dist) move[1] = sin (yaw) * dist; move[2] = 0; - VectorCopy (((entvars_t*)&ent->v)->origin, oldorigin); + VectorCopy (SVFIELD (ent, origin, vector), oldorigin); if (SV_movestep (ent, move, false)) { - delta = ((entvars_t*)&ent->v)->angles[YAW] - ((entvars_t*)&ent->v)->ideal_yaw; + delta = SVFIELD (ent, angles, vector)[YAW] - SVFIELD (ent, ideal_yaw, float); if (delta > 45 && delta < 315) { // not turned far enough, so // don't take the step - VectorCopy (oldorigin, ((entvars_t*)&ent->v)->origin); + VectorCopy (oldorigin, SVFIELD (ent, origin, vector)); } SV_LinkEdict (ent, true); return true; @@ -272,7 +272,7 @@ SV_FixCheckBottom (edict_t *ent) { // Con_Printf ("SV_FixCheckBottom\n"); - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags | FL_PARTIALGROUND; + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) | FL_PARTIALGROUND; } @@ -288,11 +288,11 @@ SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist) float d[3]; float tdir, olddir, turnaround; - olddir = anglemod ((int) (((entvars_t*)&actor->v)->ideal_yaw / 45) * 45); + olddir = anglemod ((int) (SVFIELD (actor, ideal_yaw, float) / 45) * 45); turnaround = anglemod (olddir - 180); - deltax = ((entvars_t*)&enemy->v)->origin[0] - ((entvars_t*)&actor->v)->origin[0]; - deltay = ((entvars_t*)&enemy->v)->origin[1] - ((entvars_t*)&actor->v)->origin[1]; + deltax = SVFIELD (enemy, origin, vector)[0] - SVFIELD (actor, origin, vector)[0]; + deltay = SVFIELD (enemy, origin, vector)[1] - SVFIELD (actor, origin, vector)[1]; if (deltax > 10) d[1] = 0; else if (deltax < -10) @@ -348,7 +348,7 @@ SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist) if (turnaround != DI_NODIR && SV_StepDirection (actor, turnaround, dist)) return; - ((entvars_t*)&actor->v)->ideal_yaw = olddir; // can't move + SVFIELD (actor, ideal_yaw, float) = olddir; // can't move // if a bridge was pulled out from underneath a monster, it may not have // a valid standing position at all @@ -367,9 +367,9 @@ SV_CloseEnough (edict_t *ent, edict_t *goal, float dist) int i; for (i = 0; i < 3; i++) { - if (((entvars_t*)&goal->v)->absmin[i] > ((entvars_t*)&ent->v)->absmax[i] + dist) + if (SVFIELD (goal, absmin, vector)[i] > SVFIELD (ent, absmax, vector)[i] + dist) return false; - if (((entvars_t*)&goal->v)->absmax[i] < ((entvars_t*)&ent->v)->absmin[i] - dist) + if (SVFIELD (goal, absmax, vector)[i] < SVFIELD (ent, absmin, vector)[i] - dist) return false; } return true; @@ -385,19 +385,19 @@ SV_MoveToGoal (progs_t *pr) float dist; ent = PROG_TO_EDICT (&sv_pr_state, *sv_globals.self); - goal = PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&ent->v)->goalentity); + goal = PROG_TO_EDICT (&sv_pr_state, SVFIELD (ent, goalentity, int)); dist = G_FLOAT (&sv_pr_state, OFS_PARM0); - if (!((int) ((entvars_t*)&ent->v)->flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) { + if (!((int) SVFIELD (ent, flags, float) & (FL_ONGROUND | FL_FLY | FL_SWIM))) { G_FLOAT (&sv_pr_state, OFS_RETURN) = 0; return; } // if the next step hits the enemy, return immediately - if (PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&ent->v)->enemy) != sv.edicts + if (PROG_TO_EDICT (&sv_pr_state, SVFIELD (ent, enemy, int)) != sv.edicts && SV_CloseEnough (ent, goal, dist)) return; // bump around... - if ((rand () & 3) == 1 || !SV_StepDirection (ent, ((entvars_t*)&ent->v)->ideal_yaw, dist)) { + if ((rand () & 3) == 1 || !SV_StepDirection (ent, SVFIELD (ent, ideal_yaw, float), dist)) { SV_NewChaseDir (ent, goal, dist); } } diff --git a/qw/source/sv_phys.c b/qw/source/sv_phys.c index e1d760221..f85ddfcb6 100644 --- a/qw/source/sv_phys.c +++ b/qw/source/sv_phys.c @@ -87,9 +87,9 @@ SV_CheckAllEnts (void) for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; - if (((entvars_t*)&check->v)->movetype == MOVETYPE_PUSH - || ((entvars_t*)&check->v)->movetype == MOVETYPE_NONE - || ((entvars_t*)&check->v)->movetype == MOVETYPE_NOCLIP) continue; + if (SVFIELD (check, movetype, float) == MOVETYPE_PUSH + || SVFIELD (check, movetype, float) == MOVETYPE_NONE + || SVFIELD (check, movetype, float) == MOVETYPE_NOCLIP) continue; if (SV_TestEntityPosition (check)) Con_Printf ("entity in invalid position\n"); @@ -109,23 +109,23 @@ SV_CheckVelocity (edict_t *ent) // bound velocity // for (i = 0; i < 3; i++) { - if (IS_NAN (((entvars_t*)&ent->v)->velocity[i])) { + if (IS_NAN (SVFIELD (ent, velocity, vector)[i])) { Con_Printf ("Got a NaN velocity on %s\n", - PR_GetString (&sv_pr_state, ((entvars_t*)&ent->v)->classname)); - ((entvars_t*)&ent->v)->velocity[i] = 0; + PR_GetString (&sv_pr_state, SVFIELD (ent, classname, string))); + SVFIELD (ent, velocity, vector)[i] = 0; } - if (IS_NAN (((entvars_t*)&ent->v)->origin[i])) { + if (IS_NAN (SVFIELD (ent, origin, vector)[i])) { Con_Printf ("Got a NaN origin on %s\n", - PR_GetString (&sv_pr_state, ((entvars_t*)&ent->v)->classname)); - ((entvars_t*)&ent->v)->origin[i] = 0; + PR_GetString (&sv_pr_state, SVFIELD (ent, classname, string))); + SVFIELD (ent, origin, vector)[i] = 0; } } // 1999-10-18 SV_MAXVELOCITY fix by Maddes start - wishspeed = Length (((entvars_t*)&ent->v)->velocity); + wishspeed = Length (SVFIELD (ent, velocity, vector)); if (wishspeed > sv_maxvelocity->value) { - VectorScale (((entvars_t*)&ent->v)->velocity, sv_maxvelocity->value / wishspeed, - ((entvars_t*)&ent->v)->velocity); + VectorScale (SVFIELD (ent, velocity, vector), sv_maxvelocity->value / wishspeed, + SVFIELD (ent, velocity, vector)); } // 1999-10-18 SV_MAXVELOCITY fix by Maddes end } @@ -144,7 +144,7 @@ SV_RunThink (edict_t *ent) float thinktime; do { - thinktime = ((entvars_t*)&ent->v)->nextthink; + thinktime = SVFIELD (ent, nextthink, float); if (thinktime <= 0) return true; if (thinktime > sv.time + sv_frametime) @@ -154,11 +154,11 @@ SV_RunThink (edict_t *ent) thinktime = sv.time; // don't let things stay in the past. // it is possible to start that way // by a trigger with a local time. - ((entvars_t*)&ent->v)->nextthink = 0; + SVFIELD (ent, nextthink, float) = 0; *sv_globals.time = thinktime; *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv.edicts); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&ent->v)->think); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (ent, think, func)); if (ent->free) return false; @@ -181,16 +181,16 @@ SV_Impact (edict_t *e1, edict_t *e2) old_other = *sv_globals.other; *sv_globals.time = sv.time; - if (((entvars_t*)&e1->v)->touch && ((entvars_t*)&e1->v)->solid != SOLID_NOT) { + if (SVFIELD (e1, touch, func) && SVFIELD (e1, solid, float) != SOLID_NOT) { *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, e1); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, e2); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&e1->v)->touch); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (e1, touch, func)); } - if (((entvars_t*)&e2->v)->touch && ((entvars_t*)&e2->v)->solid != SOLID_NOT) { + if (SVFIELD (e2, touch, func) && SVFIELD (e2, solid, float) != SOLID_NOT) { *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, e2); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, e1); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&e2->v)->touch); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (e2, touch, func)); } *sv_globals.self = old_self; @@ -259,27 +259,27 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) numbumps = 4; blocked = 0; - VectorCopy (((entvars_t*)&ent->v)->velocity, original_velocity); - VectorCopy (((entvars_t*)&ent->v)->velocity, primal_velocity); + VectorCopy (SVFIELD (ent, velocity, vector), original_velocity); + VectorCopy (SVFIELD (ent, velocity, vector), primal_velocity); numplanes = 0; time_left = time; for (bumpcount = 0; bumpcount < numbumps; bumpcount++) { for (i = 0; i < 3; i++) - end[i] = ((entvars_t*)&ent->v)->origin[i] + time_left * ((entvars_t*)&ent->v)->velocity[i]; + end[i] = SVFIELD (ent, origin, vector)[i] + time_left * SVFIELD (ent, velocity, vector)[i]; trace = - SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, false, ent); + SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, false, ent); if (trace.allsolid) { // entity is trapped in another solid - VectorCopy (vec3_origin, ((entvars_t*)&ent->v)->velocity); + VectorCopy (vec3_origin, SVFIELD (ent, velocity, vector)); return 3; } if (trace.fraction > 0) { // actually covered some distance - VectorCopy (trace.endpos, ((entvars_t*)&ent->v)->origin); - VectorCopy (((entvars_t*)&ent->v)->velocity, original_velocity); + VectorCopy (trace.endpos, SVFIELD (ent, origin, vector)); + VectorCopy (SVFIELD (ent, velocity, vector), original_velocity); numplanes = 0; } @@ -291,10 +291,10 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) if (trace.plane.normal[2] > 0.7) { blocked |= 1; // floor - if ((((entvars_t*)&trace.ent->v)->solid == SOLID_BSP) - || (((entvars_t*)&trace.ent->v)->movetype == MOVETYPE_PPUSH)) { - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags | FL_ONGROUND; - ((entvars_t*)&ent->v)->groundentity = EDICT_TO_PROG (&sv_pr_state, trace.ent); + if ((SVFIELD (trace.ent, solid, float) == SOLID_BSP) + || (SVFIELD (trace.ent, movetype, float) == MOVETYPE_PPUSH)) { + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) | FL_ONGROUND; + SVFIELD (ent, groundentity, int) = EDICT_TO_PROG (&sv_pr_state, trace.ent); } } if (!trace.plane.normal[2]) { @@ -314,7 +314,7 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) // cliped to another plane if (numplanes >= MAX_CLIP_PLANES) { // this shouldn't really happen - VectorCopy (vec3_origin, ((entvars_t*)&ent->v)->velocity); + VectorCopy (vec3_origin, SVFIELD (ent, velocity, vector)); return 3; } @@ -336,24 +336,24 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) } if (i != numplanes) { // go along this plane - VectorCopy (new_velocity, ((entvars_t*)&ent->v)->velocity); + VectorCopy (new_velocity, SVFIELD (ent, velocity, vector)); } else { // go along the crease if (numplanes != 2) { // Con_Printf ("clip velocity, numplanes == %i\n",numplanes); - VectorCopy (vec3_origin, ((entvars_t*)&ent->v)->velocity); + VectorCopy (vec3_origin, SVFIELD (ent, velocity, vector)); return 7; } CrossProduct (planes[0], planes[1], dir); - d = DotProduct (dir, ((entvars_t*)&ent->v)->velocity); - VectorScale (dir, d, ((entvars_t*)&ent->v)->velocity); + d = DotProduct (dir, SVFIELD (ent, velocity, vector)); + VectorScale (dir, d, SVFIELD (ent, velocity, vector)); } // // if original velocity is against the original velocity, stop dead // to avoid tiny occilations in sloping corners // - if (DotProduct (((entvars_t*)&ent->v)->velocity, primal_velocity) <= 0) { - VectorCopy (vec3_origin, ((entvars_t*)&ent->v)->velocity); + if (DotProduct (SVFIELD (ent, velocity, vector), primal_velocity) <= 0) { + VectorCopy (vec3_origin, SVFIELD (ent, velocity, vector)); return blocked; } } @@ -368,7 +368,7 @@ SV_FlyMove (edict_t *ent, float time, trace_t *steptrace) void SV_AddGravity (edict_t *ent, float scale) { - ((entvars_t*)&ent->v)->velocity[2] -= scale * movevars.gravity * sv_frametime; + SVFIELD (ent, velocity, vector)[2] -= scale * movevars.gravity * sv_frametime; } /* @@ -386,23 +386,23 @@ SV_PushEntity (edict_t *ent, vec3_t push) trace_t trace; vec3_t end; - VectorAdd (((entvars_t*)&ent->v)->origin, push, end); + VectorAdd (SVFIELD (ent, origin, vector), push, end); - if (((entvars_t*)&ent->v)->movetype == MOVETYPE_FLYMISSILE) + if (SVFIELD (ent, movetype, float) == MOVETYPE_FLYMISSILE) trace = - SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, MOVE_MISSILE, + SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, MOVE_MISSILE, ent); - else if (((entvars_t*)&ent->v)->solid == SOLID_TRIGGER || ((entvars_t*)&ent->v)->solid == SOLID_NOT) + else if (SVFIELD (ent, solid, float) == SOLID_TRIGGER || SVFIELD (ent, solid, float) == SOLID_NOT) // only clip against bmodels trace = - SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, + SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, MOVE_NOMONSTERS, ent); else trace = - SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, MOVE_NORMAL, + SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, MOVE_NORMAL, ent); - VectorCopy (trace.endpos, ((entvars_t*)&ent->v)->origin); + VectorCopy (trace.endpos, SVFIELD (ent, origin, vector)); SV_LinkEdict (ent, true); if (trace.ent) @@ -430,15 +430,15 @@ SV_Push (edict_t *pusher, vec3_t move) // --KB for (i = 0; i < 3; i++) { - mins[i] = ((entvars_t*)&pusher->v)->absmin[i] + move[i]; - maxs[i] = ((entvars_t*)&pusher->v)->absmax[i] + move[i]; + mins[i] = SVFIELD (pusher, absmin, vector)[i] + move[i]; + maxs[i] = SVFIELD (pusher, absmax, vector)[i] + move[i]; } - VectorCopy (((entvars_t*)&pusher->v)->origin, pushorig); + VectorCopy (SVFIELD (pusher, origin, vector), pushorig); // move the pusher to it's final position - VectorAdd (((entvars_t*)&pusher->v)->origin, move, ((entvars_t*)&pusher->v)->origin); + VectorAdd (SVFIELD (pusher, origin, vector), move, SVFIELD (pusher, origin, vector)); SV_LinkEdict (pusher, false); // see if any solid entities are inside the final position @@ -447,30 +447,30 @@ SV_Push (edict_t *pusher, vec3_t move) for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; - if (((entvars_t*)&check->v)->movetype == MOVETYPE_PUSH - || ((entvars_t*)&check->v)->movetype == MOVETYPE_NONE - || ((entvars_t*)&check->v)->movetype == MOVETYPE_PPUSH - || ((entvars_t*)&check->v)->movetype == MOVETYPE_NOCLIP) continue; + if (SVFIELD (check, movetype, float) == MOVETYPE_PUSH + || SVFIELD (check, movetype, float) == MOVETYPE_NONE + || SVFIELD (check, movetype, float) == MOVETYPE_PPUSH + || SVFIELD (check, movetype, float) == MOVETYPE_NOCLIP) continue; // Don't assume SOLID_BSP ! --KB - solid_save = ((entvars_t*)&pusher->v)->solid; - ((entvars_t*)&pusher->v)->solid = SOLID_NOT; + solid_save = SVFIELD (pusher, solid, float); + SVFIELD (pusher, solid, float) = SOLID_NOT; block = SV_TestEntityPosition (check); - // ((entvars_t*)&pusher->v)->solid = SOLID_BSP; - ((entvars_t*)&pusher->v)->solid = solid_save; + // SVFIELD (pusher, solid, float) = SOLID_BSP; + SVFIELD (pusher, solid, float) = solid_save; if (block) continue; // if the entity is standing on the pusher, it will definately be // moved - if (!(((int) ((entvars_t*)&check->v)->flags & FL_ONGROUND) - && PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&check->v)->groundentity) == pusher)) { - if (((entvars_t*)&check->v)->absmin[0] >= maxs[0] - || ((entvars_t*)&check->v)->absmin[1] >= maxs[1] - || ((entvars_t*)&check->v)->absmin[2] >= maxs[2] - || ((entvars_t*)&check->v)->absmax[0] <= mins[0] - || ((entvars_t*)&check->v)->absmax[1] <= mins[1] - || ((entvars_t*)&check->v)->absmax[2] <= mins[2]) + if (!(((int) SVFIELD (check, flags, float) & FL_ONGROUND) + && PROG_TO_EDICT (&sv_pr_state, SVFIELD (check, groundentity, int)) == pusher)) { + if (SVFIELD (check, absmin, vector)[0] >= maxs[0] + || SVFIELD (check, absmin, vector)[1] >= maxs[1] + || SVFIELD (check, absmin, vector)[2] >= maxs[2] + || SVFIELD (check, absmax, vector)[0] <= mins[0] + || SVFIELD (check, absmax, vector)[1] <= mins[1] + || SVFIELD (check, absmax, vector)[2] <= mins[2]) continue; // see if the ent's bbox is inside the pusher's final position @@ -478,49 +478,49 @@ SV_Push (edict_t *pusher, vec3_t move) continue; } - VectorCopy (((entvars_t*)&check->v)->origin, moved_from[num_moved]); + VectorCopy (SVFIELD (check, origin, vector), moved_from[num_moved]); moved_edict[num_moved] = check; num_moved++; // try moving the contacted entity - VectorAdd (((entvars_t*)&check->v)->origin, move, ((entvars_t*)&check->v)->origin); + VectorAdd (SVFIELD (check, origin, vector), move, SVFIELD (check, origin, vector)); block = SV_TestEntityPosition (check); if (!block) { // pushed ok SV_LinkEdict (check, false); continue; } // if it is ok to leave in the old position, do it - VectorSubtract (((entvars_t*)&check->v)->origin, move, ((entvars_t*)&check->v)->origin); + VectorSubtract (SVFIELD (check, origin, vector), move, SVFIELD (check, origin, vector)); block = SV_TestEntityPosition (check); if (!block) { num_moved--; continue; } // if it is still inside the pusher, block - if (((entvars_t*)&check->v)->mins[0] == ((entvars_t*)&check->v)->maxs[0]) { + if (SVFIELD (check, mins, vector)[0] == SVFIELD (check, maxs, vector)[0]) { SV_LinkEdict (check, false); continue; } - if (((entvars_t*)&check->v)->solid == SOLID_NOT || ((entvars_t*)&check->v)->solid == SOLID_TRIGGER) { // corpse - ((entvars_t*)&check->v)->mins[0] = ((entvars_t*)&check->v)->mins[1] = 0; - VectorCopy (((entvars_t*)&check->v)->mins, ((entvars_t*)&check->v)->maxs); + if (SVFIELD (check, solid, float) == SOLID_NOT || SVFIELD (check, solid, float) == SOLID_TRIGGER) { // corpse + SVFIELD (check, mins, vector)[0] = SVFIELD (check, mins, vector)[1] = 0; + VectorCopy (SVFIELD (check, mins, vector), SVFIELD (check, maxs, vector)); SV_LinkEdict (check, false); continue; } - VectorCopy (pushorig, ((entvars_t*)&pusher->v)->origin); + VectorCopy (pushorig, SVFIELD (pusher, origin, vector)); SV_LinkEdict (pusher, false); // if the pusher has a "blocked" function, call it // otherwise, just stay in place until the obstacle is gone - if (((entvars_t*)&pusher->v)->blocked) { + if (SVFIELD (pusher, blocked, func)) { *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, pusher); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, check); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&pusher->v)->blocked); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (pusher, blocked, func)); } // move back any entities we already moved for (i = 0; i < num_moved; i++) { - VectorCopy (moved_from[i], ((entvars_t*)&moved_edict[i]->v)->origin); + VectorCopy (moved_from[i], SVFIELD (moved_edict[i], origin, vector)); SV_LinkEdict (moved_edict[i], false); } return false; @@ -538,17 +538,17 @@ SV_PushMove (edict_t *pusher, float movetime) int i; vec3_t move; - if (!((entvars_t*)&pusher->v)->velocity[0] && !((entvars_t*)&pusher->v)->velocity[1] - && !((entvars_t*)&pusher->v)->velocity[2]) { - ((entvars_t*)&pusher->v)->ltime += movetime; + if (!SVFIELD (pusher, velocity, vector)[0] && !SVFIELD (pusher, velocity, vector)[1] + && !SVFIELD (pusher, velocity, vector)[2]) { + SVFIELD (pusher, ltime, float) += movetime; return; } for (i = 0; i < 3; i++) - move[i] = ((entvars_t*)&pusher->v)->velocity[i] * movetime; + move[i] = SVFIELD (pusher, velocity, vector)[i] * movetime; if (SV_Push (pusher, move)) - ((entvars_t*)&pusher->v)->ltime += movetime; + SVFIELD (pusher, ltime, float) += movetime; } @@ -564,36 +564,36 @@ SV_Physics_Pusher (edict_t *ent) vec3_t oldorg, move; float l; - oldltime = ((entvars_t*)&ent->v)->ltime; + oldltime = SVFIELD (ent, ltime, float); - thinktime = ((entvars_t*)&ent->v)->nextthink; - if (thinktime < ((entvars_t*)&ent->v)->ltime + sv_frametime) { - movetime = thinktime - ((entvars_t*)&ent->v)->ltime; + thinktime = SVFIELD (ent, nextthink, float); + if (thinktime < SVFIELD (ent, ltime, float) + sv_frametime) { + movetime = thinktime - SVFIELD (ent, ltime, float); if (movetime < 0) movetime = 0; } else movetime = sv_frametime; if (movetime) { - SV_PushMove (ent, movetime); // advances ((entvars_t*)&ent->v)->ltime if not + SV_PushMove (ent, movetime); // advances SVFIELD (ent, ltime, float) if not // blocked } - if (thinktime > oldltime && thinktime <= ((entvars_t*)&ent->v)->ltime) { - VectorCopy (((entvars_t*)&ent->v)->origin, oldorg); - ((entvars_t*)&ent->v)->nextthink = 0; + if (thinktime > oldltime && thinktime <= SVFIELD (ent, ltime, float)) { + VectorCopy (SVFIELD (ent, origin, vector), oldorg); + SVFIELD (ent, nextthink, float) = 0; *sv_globals.time = sv.time; *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv.edicts); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&ent->v)->think); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (ent, think, func)); if (ent->free) return; - VectorSubtract (((entvars_t*)&ent->v)->origin, oldorg, move); + VectorSubtract (SVFIELD (ent, origin, vector), oldorg, move); l = Length (move); if (l > 1.0 / 64) { // Con_Printf ("**** snap: %f\n", Length (l)); - VectorCopy (oldorg, ((entvars_t*)&ent->v)->origin); + VectorCopy (oldorg, SVFIELD (ent, origin, vector)); SV_Push (ent, move); } } @@ -625,8 +625,8 @@ SV_Physics_Noclip (edict_t *ent) if (!SV_RunThink (ent)) return; - VectorMA (((entvars_t*)&ent->v)->angles, sv_frametime, ((entvars_t*)&ent->v)->avelocity, ((entvars_t*)&ent->v)->angles); - VectorMA (((entvars_t*)&ent->v)->origin, sv_frametime, ((entvars_t*)&ent->v)->velocity, ((entvars_t*)&ent->v)->origin); + VectorMA (SVFIELD (ent, angles, vector), sv_frametime, SVFIELD (ent, avelocity, vector), SVFIELD (ent, angles, vector)); + VectorMA (SVFIELD (ent, origin, vector), sv_frametime, SVFIELD (ent, velocity, vector), SVFIELD (ent, origin, vector)); SV_LinkEdict (ent, false); } @@ -643,27 +643,27 @@ SV_CheckWaterTransition (edict_t *ent) { int cont; - cont = SV_PointContents (((entvars_t*)&ent->v)->origin); - if (!((entvars_t*)&ent->v)->watertype) { // just spawned here - ((entvars_t*)&ent->v)->watertype = cont; - ((entvars_t*)&ent->v)->waterlevel = 1; + cont = SV_PointContents (SVFIELD (ent, origin, vector)); + if (!SVFIELD (ent, watertype, float)) { // just spawned here + SVFIELD (ent, watertype, float) = cont; + SVFIELD (ent, waterlevel, float) = 1; return; } if (cont <= CONTENTS_WATER) { - if (((entvars_t*)&ent->v)->watertype == CONTENTS_EMPTY) { // just crossed into + if (SVFIELD (ent, watertype, float) == CONTENTS_EMPTY) { // just crossed into // water SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1); } - ((entvars_t*)&ent->v)->watertype = cont; - ((entvars_t*)&ent->v)->waterlevel = 1; + SVFIELD (ent, watertype, float) = cont; + SVFIELD (ent, waterlevel, float) = 1; } else { - if (((entvars_t*)&ent->v)->watertype != CONTENTS_EMPTY) { // just crossed into + if (SVFIELD (ent, watertype, float) != CONTENTS_EMPTY) { // just crossed into // water SV_StartSound (ent, 0, "misc/h2ohit1.wav", 255, 1); } - ((entvars_t*)&ent->v)->watertype = CONTENTS_EMPTY; - ((entvars_t*)&ent->v)->waterlevel = cont; + SVFIELD (ent, watertype, float) = CONTENTS_EMPTY; + SVFIELD (ent, waterlevel, float) = cont; } } @@ -683,45 +683,45 @@ SV_Physics_Toss (edict_t *ent) if (!SV_RunThink (ent)) return; - if (((entvars_t*)&ent->v)->velocity[2] > 0) - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags & ~FL_ONGROUND; + if (SVFIELD (ent, velocity, vector)[2] > 0) + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) & ~FL_ONGROUND; // if onground, return without moving - if (((int) ((entvars_t*)&ent->v)->flags & FL_ONGROUND)) + if (((int) SVFIELD (ent, flags, float) & FL_ONGROUND)) return; SV_CheckVelocity (ent); // add gravity - if (((entvars_t*)&ent->v)->movetype != MOVETYPE_FLY - && ((entvars_t*)&ent->v)->movetype != MOVETYPE_FLYMISSILE) SV_AddGravity (ent, 1.0); + if (SVFIELD (ent, movetype, float) != MOVETYPE_FLY + && SVFIELD (ent, movetype, float) != MOVETYPE_FLYMISSILE) SV_AddGravity (ent, 1.0); // move angles - VectorMA (((entvars_t*)&ent->v)->angles, sv_frametime, ((entvars_t*)&ent->v)->avelocity, ((entvars_t*)&ent->v)->angles); + VectorMA (SVFIELD (ent, angles, vector), sv_frametime, SVFIELD (ent, avelocity, vector), SVFIELD (ent, angles, vector)); // move origin - VectorScale (((entvars_t*)&ent->v)->velocity, sv_frametime, move); + VectorScale (SVFIELD (ent, velocity, vector), sv_frametime, move); trace = SV_PushEntity (ent, move); if (trace.fraction == 1) return; if (ent->free) return; - if (((entvars_t*)&ent->v)->movetype == MOVETYPE_BOUNCE) + if (SVFIELD (ent, movetype, float) == MOVETYPE_BOUNCE) backoff = 1.5; else backoff = 1; - ClipVelocity (((entvars_t*)&ent->v)->velocity, trace.plane.normal, ((entvars_t*)&ent->v)->velocity, + ClipVelocity (SVFIELD (ent, velocity, vector), trace.plane.normal, SVFIELD (ent, velocity, vector), backoff); // stop if on ground if (trace.plane.normal[2] > 0.7) { - if (((entvars_t*)&ent->v)->velocity[2] < 60 || ((entvars_t*)&ent->v)->movetype != MOVETYPE_BOUNCE) { - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags | FL_ONGROUND; - ((entvars_t*)&ent->v)->groundentity = EDICT_TO_PROG (&sv_pr_state, trace.ent); - VectorCopy (vec3_origin, ((entvars_t*)&ent->v)->velocity); - VectorCopy (vec3_origin, ((entvars_t*)&ent->v)->avelocity); + if (SVFIELD (ent, velocity, vector)[2] < 60 || SVFIELD (ent, movetype, float) != MOVETYPE_BOUNCE) { + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) | FL_ONGROUND; + SVFIELD (ent, groundentity, int) = EDICT_TO_PROG (&sv_pr_state, trace.ent); + VectorCopy (vec3_origin, SVFIELD (ent, velocity, vector)); + VectorCopy (vec3_origin, SVFIELD (ent, avelocity, vector)); } } // check for in water @@ -748,8 +748,8 @@ SV_Physics_Step (edict_t *ent) qboolean hitsound; // freefall if not on ground - if (!((int) ((entvars_t*)&ent->v)->flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) { - if (((entvars_t*)&ent->v)->velocity[2] < movevars.gravity * -0.1) + if (!((int) SVFIELD (ent, flags, float) & (FL_ONGROUND | FL_FLY | FL_SWIM))) { + if (SVFIELD (ent, velocity, vector)[2] < movevars.gravity * -0.1) hitsound = true; else hitsound = false; @@ -759,7 +759,7 @@ SV_Physics_Step (edict_t *ent) SV_FlyMove (ent, sv_frametime, NULL); SV_LinkEdict (ent, true); - if ((int) ((entvars_t*)&ent->v)->flags & FL_ONGROUND) // just hit ground + if ((int) SVFIELD (ent, flags, float) & FL_ONGROUND) // just hit ground { if (hitsound) SV_StartSound (ent, 0, "demon/dland2.wav", 255, 1); @@ -782,27 +782,27 @@ SV_PPushMove (edict_t *pusher, float movetime) // player push SV_CheckVelocity (pusher); for (i = 0; i < 3; i++) { - move[i] = ((entvars_t*)&pusher->v)->velocity[i] * movetime; - mins[i] = ((entvars_t*)&pusher->v)->absmin[i] + move[i]; - maxs[i] = ((entvars_t*)&pusher->v)->absmax[i] + move[i]; + move[i] = SVFIELD (pusher, velocity, vector)[i] * movetime; + mins[i] = SVFIELD (pusher, absmin, vector)[i] + move[i]; + maxs[i] = SVFIELD (pusher, absmax, vector)[i] + move[i]; } - VectorCopy (((entvars_t*)&pusher->v)->origin, ((entvars_t*)&pusher->v)->oldorigin); // Backup origin + VectorCopy (SVFIELD (pusher, origin, vector), SVFIELD (pusher, oldorigin, vector)); // Backup origin trace = - SV_Move (((entvars_t*)&pusher->v)->origin, ((entvars_t*)&pusher->v)->mins, ((entvars_t*)&pusher->v)->maxs, move, + SV_Move (SVFIELD (pusher, origin, vector), SVFIELD (pusher, mins, vector), SVFIELD (pusher, maxs, vector), move, MOVE_NOMONSTERS, pusher); if (trace.fraction == 1) { - VectorCopy (((entvars_t*)&pusher->v)->origin, ((entvars_t*)&pusher->v)->oldorigin); // Revert + VectorCopy (SVFIELD (pusher, origin, vector), SVFIELD (pusher, oldorigin, vector)); // Revert return; } - VectorAdd (((entvars_t*)&pusher->v)->origin, move, ((entvars_t*)&pusher->v)->origin); // Move + VectorAdd (SVFIELD (pusher, origin, vector), move, SVFIELD (pusher, origin, vector)); // Move SV_LinkEdict (pusher, false); - ((entvars_t*)&pusher->v)->ltime += movetime; + SVFIELD (pusher, ltime, float) += movetime; - oldsolid = ((entvars_t*)&pusher->v)->solid; + oldsolid = SVFIELD (pusher, solid, float); check = NEXT_EDICT (&sv_pr_state, sv.edicts); for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, check)) { @@ -814,25 +814,25 @@ SV_PPushMove (edict_t *pusher, float movetime) // player push continue; // Stage 2: Is it a player we can push? - if (((entvars_t*)&check->v)->movetype == MOVETYPE_WALK) { + if (SVFIELD (check, movetype, float) == MOVETYPE_WALK) { Con_Printf ("Pusher encountered a player\n"); // Yes!@#!@ - ((entvars_t*)&pusher->v)->solid = SOLID_NOT; + SVFIELD (pusher, solid, float) = SOLID_NOT; SV_PushEntity (check, move); - ((entvars_t*)&pusher->v)->solid = oldsolid; + SVFIELD (pusher, solid, float) = oldsolid; continue; } // Stage 3: No.. Is it something that blocks us? - if (((entvars_t*)&check->v)->mins[0] == ((entvars_t*)&check->v)->maxs[0]) + if (SVFIELD (check, mins, vector)[0] == SVFIELD (check, maxs, vector)[0]) continue; - if (((entvars_t*)&check->v)->solid == SOLID_NOT || ((entvars_t*)&check->v)->solid == SOLID_TRIGGER) + if (SVFIELD (check, solid, float) == SOLID_NOT || SVFIELD (check, solid, float) == SOLID_TRIGGER) continue; // Stage 4: Yes, it must be. Fail the move. - VectorCopy (((entvars_t*)&pusher->v)->origin, ((entvars_t*)&pusher->v)->oldorigin); // Revert - if (((entvars_t*)&pusher->v)->blocked) { // Blocked func? + VectorCopy (SVFIELD (pusher, origin, vector), SVFIELD (pusher, oldorigin, vector)); // Revert + if (SVFIELD (pusher, blocked, func)) { // Blocked func? *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, pusher); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, check); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&pusher->v)->blocked); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (pusher, blocked, func)); } return; @@ -848,11 +848,11 @@ SV_Physics_PPusher (edict_t *ent) // float l; - oldltime = ((entvars_t*)&ent->v)->ltime; + oldltime = SVFIELD (ent, ltime, float); - thinktime = ((entvars_t*)&ent->v)->nextthink; - if (thinktime < ((entvars_t*)&ent->v)->ltime + sv_frametime) { - movetime = thinktime - ((entvars_t*)&ent->v)->ltime; + thinktime = SVFIELD (ent, nextthink, float); + if (thinktime < SVFIELD (ent, ltime, float) + sv_frametime) { + movetime = thinktime - SVFIELD (ent, ltime, float); if (movetime < 0) movetime = 0; } else @@ -860,16 +860,16 @@ SV_Physics_PPusher (edict_t *ent) // if (movetime) // { - SV_PPushMove (ent, 0.0009); // advances ((entvars_t*)&ent->v)->ltime if not + SV_PPushMove (ent, 0.0009); // advances SVFIELD (ent, ltime, float) if not // blocked // } - if (thinktime > oldltime && thinktime <= ((entvars_t*)&ent->v)->ltime) { - ((entvars_t*)&ent->v)->nextthink = 0; + if (thinktime > oldltime && thinktime <= SVFIELD (ent, ltime, float)) { + SVFIELD (ent, nextthink, float) = 0; *sv_globals.time = sv.time; *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv.edicts); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&ent->v)->think); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (ent, think, func)); if (ent->free) return; } @@ -893,11 +893,11 @@ SV_ProgStartFrame (void) void SV_RunEntity (edict_t *ent) { - if (((entvars_t*)&ent->v)->lastruntime == (float) realtime) + if (SVFIELD (ent, lastruntime, float) == (float) realtime) return; - ((entvars_t*)&ent->v)->lastruntime = (float) realtime; + SVFIELD (ent, lastruntime, float) = (float) realtime; - switch ((int) ((entvars_t*)&ent->v)->movetype) { + switch ((int) SVFIELD (ent, movetype, float)) { case MOVETYPE_PUSH: SV_Physics_Pusher (ent); break; @@ -920,7 +920,7 @@ SV_RunEntity (edict_t *ent) SV_Physics_Toss (ent); break; default: - SV_Error ("SV_Physics: bad movetype %i", (int) ((entvars_t*)&ent->v)->movetype); + SV_Error ("SV_Physics: bad movetype %i", (int) SVFIELD (ent, movetype, float)); } } diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index a5e043dc4..1d617d898 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -80,7 +80,7 @@ PF_error (progs_t *pr) s = PF_VarString (pr, 0); Con_Printf ("======SERVER ERROR in %s:\n%s\n", PR_GetString (pr, pr->pr_xfunction->s_name), s); - ed = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->self); + ed = PROG_TO_EDICT (pr, *sv_globals.self); ED_Print (pr, ed); SV_Error ("Program error"); @@ -103,7 +103,7 @@ PF_objerror (progs_t *pr) s = PF_VarString (pr, 0); Con_Printf ("======OBJECT ERROR in %s:\n%s\n", PR_GetString (pr, pr->pr_xfunction->s_name), s); - ed = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->self); + ed = PROG_TO_EDICT (pr, *sv_globals.self); ED_Print (pr, ed); ED_Free (pr, ed); @@ -121,8 +121,8 @@ PF_objerror (progs_t *pr) void PF_makevectors (progs_t *pr) { - AngleVectors (G_VECTOR (pr, OFS_PARM0), ((globalvars_t*)pr->pr_globals)->v_forward, - ((globalvars_t*)pr->pr_globals)->v_right, ((globalvars_t*)pr->pr_globals)->v_up); + AngleVectors (G_VECTOR (pr, OFS_PARM0), *sv_globals.v_forward, + *sv_globals.v_right, *sv_globals.v_up); } /* @@ -140,7 +140,7 @@ PF_setorigin (progs_t *pr) e = G_EDICT (pr, OFS_PARM0); org = G_VECTOR (pr, OFS_PARM1); - VectorCopy (org, ((entvars_t*)&e->v)->origin); + VectorCopy (org, SVFIELD (e, origin, vector)); SV_LinkEdict (e, false); } @@ -161,9 +161,9 @@ PF_setsize (progs_t *pr) e = G_EDICT (pr, OFS_PARM0); min = G_VECTOR (pr, OFS_PARM1); max = G_VECTOR (pr, OFS_PARM2); - VectorCopy (min, ((entvars_t*)&e->v)->mins); - VectorCopy (max, ((entvars_t*)&e->v)->maxs); - VectorSubtract (max, min, ((entvars_t*)&e->v)->size); + VectorCopy (min, SVFIELD (e, mins, vector)); + VectorCopy (max, SVFIELD (e, maxs, vector)); + VectorSubtract (max, min, SVFIELD (e, size, vector)); SV_LinkEdict (e, false); } @@ -193,15 +193,15 @@ PF_setmodel (progs_t *pr) if (!*check) PR_RunError (pr, "no precache: %s\n", m); - ((entvars_t*)&e->v)->model = PR_SetString (pr, m); - ((entvars_t*)&e->v)->modelindex = i; + SVFIELD (e, model, string) = PR_SetString (pr, m); + SVFIELD (e, modelindex, float) = i; // if it is an inline model, get the size information for it if (m[0] == '*') { mod = Mod_ForName (m, true); - VectorCopy (mod->mins, ((entvars_t*)&e->v)->mins); - VectorCopy (mod->maxs, ((entvars_t*)&e->v)->maxs); - VectorSubtract (mod->maxs, mod->mins, ((entvars_t*)&e->v)->size); + VectorCopy (mod->mins, SVFIELD (e, mins, vector)); + VectorCopy (mod->maxs, SVFIELD (e, maxs, vector)); + VectorSubtract (mod->maxs, mod->mins, SVFIELD (e, size, vector)); SV_LinkEdict (e, false); } @@ -519,18 +519,18 @@ PF_traceline (progs_t *pr) trace = SV_Move (v1, vec3_origin, vec3_origin, v2, nomonsters, ent); - ((globalvars_t*)pr->pr_globals)->trace_allsolid = trace.allsolid; - ((globalvars_t*)pr->pr_globals)->trace_startsolid = trace.startsolid; - ((globalvars_t*)pr->pr_globals)->trace_fraction = trace.fraction; - ((globalvars_t*)pr->pr_globals)->trace_inwater = trace.inwater; - ((globalvars_t*)pr->pr_globals)->trace_inopen = trace.inopen; - VectorCopy (trace.endpos, ((globalvars_t*)pr->pr_globals)->trace_endpos); - VectorCopy (trace.plane.normal, ((globalvars_t*)pr->pr_globals)->trace_plane_normal); - ((globalvars_t*)pr->pr_globals)->trace_plane_dist = trace.plane.dist; + *sv_globals.trace_allsolid = trace.allsolid; + *sv_globals.trace_startsolid = trace.startsolid; + *sv_globals.trace_fraction = trace.fraction; + *sv_globals.trace_inwater = trace.inwater; + *sv_globals.trace_inopen = trace.inopen; + VectorCopy (trace.endpos, *sv_globals.trace_endpos); + VectorCopy (trace.plane.normal, *sv_globals.trace_plane_normal); + *sv_globals.trace_plane_dist = trace.plane.dist; if (trace.ent) - ((globalvars_t*)pr->pr_globals)->trace_ent = EDICT_TO_PROG (pr, trace.ent); + *sv_globals.trace_ent = EDICT_TO_PROG (pr, trace.ent); else - ((globalvars_t*)pr->pr_globals)->trace_ent = EDICT_TO_PROG (pr, sv.edicts); + *sv_globals.trace_ent = EDICT_TO_PROG (pr, sv.edicts); } /* @@ -582,9 +582,9 @@ PF_newcheckclient (progs_t *pr, int check) if (ent->free) continue; - if (((entvars_t*)&ent->v)->health <= 0) + if (SVFIELD (ent, health, float) <= 0) continue; - if ((int) ((entvars_t*)&ent->v)->flags & FL_NOTARGET) + if ((int) SVFIELD (ent, flags, float) & FL_NOTARGET) continue; // anything that is a client, or has a client as an enemy @@ -592,7 +592,7 @@ PF_newcheckclient (progs_t *pr, int check) } // get the PVS for the entity - VectorAdd (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->view_ofs, org); + VectorAdd (SVFIELD (ent, origin, vector), SVFIELD (ent, view_ofs, vector), org); leaf = Mod_PointInLeaf (org, sv.worldmodel); pvs = Mod_LeafPVS (leaf, sv.worldmodel); memcpy (checkpvs, pvs, (sv.worldmodel->numleafs + 7) >> 3); @@ -630,13 +630,13 @@ PF_checkclient (progs_t *pr) } // return check if it might be visible ent = EDICT_NUM (pr, sv.lastcheck); - if (ent->free || ((entvars_t*)&ent->v)->health <= 0) { + if (ent->free || SVFIELD (ent, health, float) <= 0) { RETURN_EDICT (pr, sv.edicts); return; } // if current entity can't possibly see the check entity, return 0 - self = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->self); - VectorAdd (((entvars_t*)&self->v)->origin, ((entvars_t*)&self->v)->view_ofs, view); + self = PROG_TO_EDICT (pr, *sv_globals.self); + VectorAdd (SVFIELD (self, origin, vector), SVFIELD (self, view_ofs, vector), view); leaf = Mod_PointInLeaf (view, sv.worldmodel); l = (leaf - sv.worldmodel->leafs) - 1; if ((l < 0) || !(checkpvs[l >> 3] & (1 << (l & 7)))) { @@ -780,16 +780,16 @@ PF_findradius (progs_t *pr) for (i = 1; i < sv.num_edicts; i++, ent = NEXT_EDICT (pr, ent)) { if (ent->free) continue; - if (((entvars_t*)&ent->v)->solid == SOLID_NOT) + if (SVFIELD (ent, solid, float) == SOLID_NOT) continue; for (j = 0; j < 3; j++) eorg[j] = - org[j] - (((entvars_t*)&ent->v)->origin[j] + - (((entvars_t*)&ent->v)->mins[j] + ((entvars_t*)&ent->v)->maxs[j]) * 0.5); + org[j] - (SVFIELD (ent, origin, vector)[j] + + (SVFIELD (ent, mins, vector)[j] + SVFIELD (ent, maxs, vector)[j]) * 0.5); if (Length (eorg) > rad) continue; - ((entvars_t*)&ent->v)->chain = EDICT_TO_PROG (pr, chain); + SVFIELD (ent, chain, int) = EDICT_TO_PROG (pr, chain); chain = ent; } @@ -1003,11 +1003,11 @@ PF_walkmove (progs_t *pr) dfunction_t *oldf; int oldself; - ent = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->self); + ent = PROG_TO_EDICT (pr, *sv_globals.self); yaw = G_FLOAT (pr, OFS_PARM0); dist = G_FLOAT (pr, OFS_PARM1); - if (!((int) ((entvars_t*)&ent->v)->flags & (FL_ONGROUND | FL_FLY | FL_SWIM))) { + if (!((int) SVFIELD (ent, flags, float) & (FL_ONGROUND | FL_FLY | FL_SWIM))) { G_FLOAT (pr, OFS_RETURN) = 0; return; } @@ -1020,14 +1020,14 @@ PF_walkmove (progs_t *pr) // save program state, because SV_movestep may call other progs oldf = pr->pr_xfunction; - oldself = ((globalvars_t*)pr->pr_globals)->self; + oldself = *sv_globals.self; G_FLOAT (pr, OFS_RETURN) = SV_movestep (ent, move, true); // restore program state pr->pr_xfunction = oldf; - ((globalvars_t*)pr->pr_globals)->self = oldself; + *sv_globals.self = oldself; } /* @@ -1042,20 +1042,20 @@ PF_droptofloor (progs_t *pr) vec3_t end; trace_t trace; - ent = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->self); + ent = PROG_TO_EDICT (pr, *sv_globals.self); - VectorCopy (((entvars_t*)&ent->v)->origin, end); + VectorCopy (SVFIELD (ent, origin, vector), end); end[2] -= 256; - trace = SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, end, false, ent); + trace = SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), end, false, ent); if (trace.fraction == 1 || trace.allsolid) G_FLOAT (pr, OFS_RETURN) = 0; else { - VectorCopy (trace.endpos, ((entvars_t*)&ent->v)->origin); + VectorCopy (trace.endpos, SVFIELD (ent, origin, vector)); SV_LinkEdict (ent, false); - ((entvars_t*)&ent->v)->flags = (int) ((entvars_t*)&ent->v)->flags | FL_ONGROUND; - ((entvars_t*)&ent->v)->groundentity = EDICT_TO_PROG (pr, trace.ent); + SVFIELD (ent, flags, float) = (int) SVFIELD (ent, flags, float) | FL_ONGROUND; + SVFIELD (ent, groundentity, int) = EDICT_TO_PROG (pr, trace.ent); G_FLOAT (pr, OFS_RETURN) = 1; } } @@ -1190,7 +1190,7 @@ PF_aim (progs_t *pr) ent = G_EDICT (pr, OFS_PARM0); speed = G_FLOAT (pr, OFS_PARM1); - VectorCopy (((entvars_t*)&ent->v)->origin, start); + VectorCopy (SVFIELD (ent, origin, vector), start); start[2] += 20; // noaim option @@ -1198,18 +1198,18 @@ PF_aim (progs_t *pr) if (i > 0 && i < MAX_CLIENTS) { noaim = Info_ValueForKey (svs.clients[i - 1].userinfo, "noaim"); if (atoi (noaim) > 0) { - VectorCopy (((globalvars_t*)pr->pr_globals)->v_forward, G_VECTOR (pr, OFS_RETURN)); + VectorCopy (*sv_globals.v_forward, G_VECTOR (pr, OFS_RETURN)); return; } } // try sending a trace straight - VectorCopy (((globalvars_t*)pr->pr_globals)->v_forward, dir); + VectorCopy (*sv_globals.v_forward, dir); VectorMA (start, 2048, dir, end); tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent); - if (tr.ent && ((entvars_t*)&tr.ent->v)->takedamage == DAMAGE_AIM - && (!teamplay->int_val || ((entvars_t*)&ent->v)->team <= 0 - || ((entvars_t*)&ent->v)->team != ((entvars_t*)&tr.ent->v)->team)) { - VectorCopy (((globalvars_t*)pr->pr_globals)->v_forward, G_VECTOR (pr, OFS_RETURN)); + if (tr.ent && SVFIELD (tr.ent, takedamage, float) == DAMAGE_AIM + && (!teamplay->int_val || SVFIELD (ent, team, float) <= 0 + || SVFIELD (ent, team, float) != SVFIELD (tr.ent, team, float))) { + VectorCopy (*sv_globals.v_forward, G_VECTOR (pr, OFS_RETURN)); return; } @@ -1220,19 +1220,19 @@ PF_aim (progs_t *pr) check = NEXT_EDICT (pr, sv.edicts); for (i = 1; i < sv.num_edicts; i++, check = NEXT_EDICT (pr, check)) { - if (((entvars_t*)&check->v)->takedamage != DAMAGE_AIM) + if (SVFIELD (check, takedamage, float) != DAMAGE_AIM) continue; if (check == ent) continue; - if (teamplay->int_val && ((entvars_t*)&ent->v)->team > 0 - && ((entvars_t*)&ent->v)->team == ((entvars_t*)&check->v)->team) continue; // don't aim at + if (teamplay->int_val && SVFIELD (ent, team, float) > 0 + && SVFIELD (ent, team, float) == SVFIELD (check, team, float)) continue; // don't aim at // teammate for (j = 0; j < 3; j++) - end[j] = ((entvars_t*)&check->v)->origin[j] - + 0.5 * (((entvars_t*)&check->v)->mins[j] + ((entvars_t*)&check->v)->maxs[j]); + end[j] = SVFIELD (check, origin, vector)[j] + + 0.5 * (SVFIELD (check, mins, vector)[j] + SVFIELD (check, maxs, vector)[j]); VectorSubtract (end, start, dir); VectorNormalize (dir); - dist = DotProduct (dir, ((globalvars_t*)pr->pr_globals)->v_forward); + dist = DotProduct (dir, *sv_globals.v_forward); if (dist < bestdist) continue; // to far to turn tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent); @@ -1243,9 +1243,9 @@ PF_aim (progs_t *pr) } if (bestent) { - VectorSubtract (((entvars_t*)&bestent->v)->origin, ((entvars_t*)&ent->v)->origin, dir); - dist = DotProduct (dir, ((globalvars_t*)pr->pr_globals)->v_forward); - VectorScale (((globalvars_t*)pr->pr_globals)->v_forward, dist, end); + VectorSubtract (SVFIELD (bestent, origin, vector), SVFIELD (ent, origin, vector), dir); + dist = DotProduct (dir, *sv_globals.v_forward); + VectorScale (*sv_globals.v_forward, dist, end); end[2] = dir[2]; VectorNormalize (end); VectorCopy (end, G_VECTOR (pr, OFS_RETURN)); @@ -1265,10 +1265,10 @@ PF_changeyaw (progs_t *pr) edict_t *ent; float ideal, current, move, speed; - ent = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->self); - current = anglemod (((entvars_t*)&ent->v)->angles[1]); - ideal = ((entvars_t*)&ent->v)->ideal_yaw; - speed = ((entvars_t*)&ent->v)->yaw_speed; + ent = PROG_TO_EDICT (pr, *sv_globals.self); + current = anglemod (SVFIELD (ent, angles, vector)[1]); + ideal = SVFIELD (ent, ideal_yaw, float); + speed = SVFIELD (ent, yaw_speed, float); if (current == ideal) return; @@ -1288,7 +1288,7 @@ PF_changeyaw (progs_t *pr) move = -speed; } - ((entvars_t*)&ent->v)->angles[1] = anglemod (current + move); + SVFIELD (ent, angles, vector)[1] = anglemod (current + move); } /* @@ -1314,7 +1314,7 @@ WriteDest (progs_t *pr) case MSG_ONE: SV_Error ("Shouldn't be at MSG_ONE"); #if 0 - ent = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->msg_entity); + ent = PROG_TO_EDICT (pr, *sv_globals.msg_entity); entnum = NUM_FOR_EDICT (pr, ent); if (entnum < 1 || entnum > MAX_CLIENTS) PR_RunError (pr, "WriteDest: not a client"); @@ -1347,7 +1347,7 @@ Write_GetClient (progs_t *pr) int entnum; edict_t *ent; - ent = PROG_TO_EDICT (pr, ((globalvars_t*)pr->pr_globals)->msg_entity); + ent = PROG_TO_EDICT (pr, *sv_globals.msg_entity); entnum = NUM_FOR_EDICT (pr, ent); if (entnum < 1 || entnum > MAX_CLIENTS) PR_RunError (pr, "Write_GetClient: not a client"); @@ -1466,14 +1466,14 @@ PF_makestatic (progs_t *pr) MSG_WriteByte (&sv.signon, svc_spawnstatic); - MSG_WriteByte (&sv.signon, SV_ModelIndex (PR_GetString (pr, ((entvars_t*)&ent->v)->model))); + MSG_WriteByte (&sv.signon, SV_ModelIndex (PR_GetString (pr, SVFIELD (ent, model, float)))); - MSG_WriteByte (&sv.signon, ((entvars_t*)&ent->v)->frame); - MSG_WriteByte (&sv.signon, ((entvars_t*)&ent->v)->colormap); - MSG_WriteByte (&sv.signon, ((entvars_t*)&ent->v)->skin); + MSG_WriteByte (&sv.signon, SVFIELD (ent, frame, float)); + MSG_WriteByte (&sv.signon, SVFIELD (ent, colormap, float)); + MSG_WriteByte (&sv.signon, SVFIELD (ent, skin, float)); for (i = 0; i < 3; i++) { - MSG_WriteCoord (&sv.signon, ((entvars_t*)&ent->v)->origin[i]); - MSG_WriteAngle (&sv.signon, ((entvars_t*)&ent->v)->angles[i]); + MSG_WriteCoord (&sv.signon, SVFIELD (ent, origin, vector)[i]); + MSG_WriteAngle (&sv.signon, SVFIELD (ent, angles, vector)[i]); } // throw the entity away now @@ -1501,7 +1501,7 @@ PF_setspawnparms (progs_t *pr) client = svs.clients + (i - 1); for (i = 0; i < NUM_SPAWN_PARMS; i++) - (&((globalvars_t*)pr->pr_globals)->parm1)[i] = client->spawn_parms[i]; + sv_globals.parms[i] = client->spawn_parms[i]; } /* diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index a1bed95fe..180423f54 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -39,11 +39,13 @@ #include "cmd.h" #include "server.h" +#include "progdefs.h" #include "sv_progs.h" #include "world.h" sv_globals_t sv_globals; sv_funcs_t sv_funcs; +sv_fields_t sv_fields; int eval_alpha; int eval_scale; @@ -94,7 +96,7 @@ FindEdictFieldOffsets (progs_t *pr) int ED_Prune_Edict (progs_t *pr, edict_t *ent) { - if (((int) ((entvars_t*)&ent->v)->spawnflags & SPAWNFLAG_NOT_DEATHMATCH)) + if (((int) SVFIELD (ent, spawnflags, float) & SPAWNFLAG_NOT_DEATHMATCH)) return 1; return 0; } @@ -233,6 +235,71 @@ SV_LoadProgs (void) ED_FindFunction (&sv_pr_state, "SetNewParms") - sv_pr_state.pr_functions; sv_funcs.SetChangeParms = ED_FindFunction (&sv_pr_state, "SetChangeParms") - sv_pr_state.pr_functions; + + sv_fields.modelindex = ED_FindField (&sv_pr_state, "modelindex")->ofs; + sv_fields.absmin = ED_FindField (&sv_pr_state, "absmin")->ofs; + sv_fields.absmax = ED_FindField (&sv_pr_state, "absmax")->ofs; + sv_fields.ltime = ED_FindField (&sv_pr_state, "ltime")->ofs; + sv_fields.lastruntime = ED_FindField (&sv_pr_state, "lastruntime")->ofs; + sv_fields.movetype = ED_FindField (&sv_pr_state, "movetype")->ofs; + sv_fields.solid = ED_FindField (&sv_pr_state, "solid")->ofs; + sv_fields.origin = ED_FindField (&sv_pr_state, "origin")->ofs; + sv_fields.oldorigin = ED_FindField (&sv_pr_state, "oldorigin")->ofs; + sv_fields.velocity = ED_FindField (&sv_pr_state, "velocity")->ofs; + sv_fields.angles = ED_FindField (&sv_pr_state, "angles")->ofs; + sv_fields.avelocity = ED_FindField (&sv_pr_state, "avelocity")->ofs; + sv_fields.classname = ED_FindField (&sv_pr_state, "classname")->ofs; + sv_fields.model = ED_FindField (&sv_pr_state, "model")->ofs; + sv_fields.frame = ED_FindField (&sv_pr_state, "frame")->ofs; + sv_fields.skin = ED_FindField (&sv_pr_state, "skin")->ofs; + sv_fields.effects = ED_FindField (&sv_pr_state, "effects")->ofs; + sv_fields.mins = ED_FindField (&sv_pr_state, "mins")->ofs; + sv_fields.maxs = ED_FindField (&sv_pr_state, "maxs")->ofs; + sv_fields.size = ED_FindField (&sv_pr_state, "size")->ofs; + sv_fields.touch = ED_FindField (&sv_pr_state, "touch")->ofs; + sv_fields.think = ED_FindField (&sv_pr_state, "think")->ofs; + sv_fields.blocked = ED_FindField (&sv_pr_state, "blocked")->ofs; + sv_fields.nextthink = ED_FindField (&sv_pr_state, "nextthink")->ofs; + sv_fields.groundentity = ED_FindField (&sv_pr_state, "groundentity")->ofs; + sv_fields.health = ED_FindField (&sv_pr_state, "health")->ofs; + sv_fields.frags = ED_FindField (&sv_pr_state, "frags")->ofs; + sv_fields.weapon = ED_FindField (&sv_pr_state, "weapon")->ofs; + sv_fields.weaponmodel = ED_FindField (&sv_pr_state, "weaponmodel")->ofs; + sv_fields.weaponframe = ED_FindField (&sv_pr_state, "weaponframe")->ofs; + sv_fields.currentammo = ED_FindField (&sv_pr_state, "currentammo")->ofs; + sv_fields.ammo_shells = ED_FindField (&sv_pr_state, "ammo_shells")->ofs; + sv_fields.ammo_nails = ED_FindField (&sv_pr_state, "ammo_nails")->ofs; + sv_fields.ammo_rockets = ED_FindField (&sv_pr_state, "ammo_rockets")->ofs; + sv_fields.ammo_cells = ED_FindField (&sv_pr_state, "ammo_cells")->ofs; + sv_fields.items = ED_FindField (&sv_pr_state, "items")->ofs; + sv_fields.takedamage = ED_FindField (&sv_pr_state, "takedamage")->ofs; + sv_fields.chain = ED_FindField (&sv_pr_state, "chain")->ofs; + sv_fields.view_ofs = ED_FindField (&sv_pr_state, "view_ofs")->ofs; + sv_fields.button0 = ED_FindField (&sv_pr_state, "button0")->ofs; + sv_fields.button1 = ED_FindField (&sv_pr_state, "button1")->ofs; + sv_fields.button2 = ED_FindField (&sv_pr_state, "button2")->ofs; + sv_fields.impulse = ED_FindField (&sv_pr_state, "impulse")->ofs; + sv_fields.fixangle = ED_FindField (&sv_pr_state, "fixangle")->ofs; + sv_fields.v_angle = ED_FindField (&sv_pr_state, "v_angle")->ofs; + sv_fields.netname = ED_FindField (&sv_pr_state, "netname")->ofs; + sv_fields.enemy = ED_FindField (&sv_pr_state, "enemy")->ofs; + sv_fields.flags = ED_FindField (&sv_pr_state, "flags")->ofs; + sv_fields.colormap = ED_FindField (&sv_pr_state, "colormap")->ofs; + sv_fields.team = ED_FindField (&sv_pr_state, "team")->ofs; + sv_fields.teleport_time = ED_FindField (&sv_pr_state, "teleport_time")->ofs; + sv_fields.armorvalue = ED_FindField (&sv_pr_state, "armorvalue")->ofs; + sv_fields.waterlevel = ED_FindField (&sv_pr_state, "waterlevel")->ofs; + sv_fields.watertype = ED_FindField (&sv_pr_state, "watertype")->ofs; + sv_fields.ideal_yaw = ED_FindField (&sv_pr_state, "ideal_yaw")->ofs; + sv_fields.yaw_speed = ED_FindField (&sv_pr_state, "yaw_speed")->ofs; + sv_fields.goalentity = ED_FindField (&sv_pr_state, "goalentity")->ofs; + sv_fields.spawnflags = ED_FindField (&sv_pr_state, "spawnflags")->ofs; + sv_fields.dmg_take = ED_FindField (&sv_pr_state, "dmg_take")->ofs; + sv_fields.dmg_save = ED_FindField (&sv_pr_state, "dmg_save")->ofs; + sv_fields.dmg_inflictor = ED_FindField (&sv_pr_state, "dmg_inflictor")->ofs; + sv_fields.owner = ED_FindField (&sv_pr_state, "owner")->ofs; + sv_fields.message = ED_FindField (&sv_pr_state, "message")->ofs; + sv_fields.sounds = ED_FindField (&sv_pr_state, "sounds")->ofs; } void diff --git a/qw/source/sv_send.c b/qw/source/sv_send.c index 715e8c8e8..318ce76f4 100644 --- a/qw/source/sv_send.c +++ b/qw/source/sv_send.c @@ -333,12 +333,12 @@ SV_Multicast (vec3_t origin, int to) if (to == MULTICAST_PHS_R || to == MULTICAST_PHS) { vec3_t delta; - VectorSubtract (origin, ((entvars_t*)&client->edict->v)->origin, delta); + VectorSubtract (origin, SVFIELD (client->edict, origin, vector), delta); if (Length (delta) <= 1024) goto inrange; } - leaf = Mod_PointInLeaf (((entvars_t*)&client->edict->v)->origin, sv.worldmodel); + leaf = Mod_PointInLeaf (SVFIELD (client->edict, origin, vector), sv.worldmodel); if (leaf) { // -1 is because pvs rows are 1 based, not 0 based like leafs leafnum = leaf - sv.worldmodel->leafs - 1; @@ -430,13 +430,13 @@ SV_StartSound (edict_t *entity, int channel, char *sample, int volume, channel |= SND_ATTENUATION; // use the entity origin unless it is a bmodel - if (((entvars_t*)&entity->v)->solid == SOLID_BSP) { + if (SVFIELD (entity, solid, float) == SOLID_BSP) { for (i = 0; i < 3; i++) origin[i] = - ((entvars_t*)&entity->v)->origin[i] + 0.5 * (((entvars_t*)&entity->v)->mins[i] + - ((entvars_t*)&entity->v)->maxs[i]); + SVFIELD (entity, origin, vector)[i] + 0.5 * (SVFIELD (entity, mins, vector)[i] + + SVFIELD (entity, maxs, vector)[i]); } else { - VectorCopy (((entvars_t*)&entity->v)->origin, origin); + VectorCopy (SVFIELD (entity, origin, vector), origin); } MSG_WriteByte (&sv.multicast, svc_sound); @@ -503,25 +503,25 @@ SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg) client->chokecount = 0; } // send a damage message if the player got hit this frame - if (((entvars_t*)&ent->v)->dmg_take || ((entvars_t*)&ent->v)->dmg_save) { - other = PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&ent->v)->dmg_inflictor); + if (SVFIELD (ent, dmg_take, float) || SVFIELD (ent, dmg_save, float)) { + other = PROG_TO_EDICT (&sv_pr_state, SVFIELD (ent, dmg_inflictor, int)); MSG_WriteByte (msg, svc_damage); - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->dmg_save); - MSG_WriteByte (msg, ((entvars_t*)&ent->v)->dmg_take); + MSG_WriteByte (msg, SVFIELD (ent, dmg_save, float)); + MSG_WriteByte (msg, SVFIELD (ent, dmg_take, float)); for (i = 0; i < 3; i++) MSG_WriteCoord (msg, - ((entvars_t*)&other->v)->origin[i] + 0.5 * (((entvars_t*)&other->v)->mins[i] + - ((entvars_t*)&other->v)->maxs[i])); + SVFIELD (other, origin, vector)[i] + 0.5 * (SVFIELD (other, mins, vector)[i] + + SVFIELD (other, maxs, vector)[i])); - ((entvars_t*)&ent->v)->dmg_take = 0; - ((entvars_t*)&ent->v)->dmg_save = 0; + SVFIELD (ent, dmg_take, float) = 0; + SVFIELD (ent, dmg_save, float) = 0; } // a fixangle might get lost in a dropped packet. Oh well. - if (((entvars_t*)&ent->v)->fixangle) { + if (SVFIELD (ent, fixangle, float)) { MSG_WriteByte (msg, svc_setangle); for (i = 0; i < 3; i++) - MSG_WriteAngle (msg, ((entvars_t*)&ent->v)->angles[i]); - ((entvars_t*)&ent->v)->fixangle = 0; + MSG_WriteAngle (msg, SVFIELD (ent, angles, vector)[i]); + SVFIELD (ent, fixangle, float) = 0; } } @@ -546,29 +546,29 @@ SV_UpdateClientStats (client_t *client) if (client->spectator && client->spec_track > 0) ent = svs.clients[client->spec_track - 1].edict; - stats[STAT_HEALTH] = ((entvars_t*)&ent->v)->health; - stats[STAT_WEAPON] = SV_ModelIndex (PR_GetString (&sv_pr_state, ((entvars_t*)&ent->v)->weaponmodel)); - stats[STAT_AMMO] = ((entvars_t*)&ent->v)->currentammo; - stats[STAT_ARMOR] = ((entvars_t*)&ent->v)->armorvalue; - stats[STAT_SHELLS] = ((entvars_t*)&ent->v)->ammo_shells; - stats[STAT_NAILS] = ((entvars_t*)&ent->v)->ammo_nails; - stats[STAT_ROCKETS] = ((entvars_t*)&ent->v)->ammo_rockets; - stats[STAT_CELLS] = ((entvars_t*)&ent->v)->ammo_cells; + stats[STAT_HEALTH] = SVFIELD (ent, health, float); + stats[STAT_WEAPON] = SV_ModelIndex (PR_GetString (&sv_pr_state, SVFIELD (ent, weaponmodel, string))); + stats[STAT_AMMO] = SVFIELD (ent, currentammo, float); + stats[STAT_ARMOR] = SVFIELD (ent, armorvalue, float); + stats[STAT_SHELLS] = SVFIELD (ent, ammo_shells, float); + stats[STAT_NAILS] = SVFIELD (ent, ammo_nails, float); + stats[STAT_ROCKETS] = SVFIELD (ent, ammo_rockets, float); + stats[STAT_CELLS] = SVFIELD (ent, ammo_cells, float); if (!client->spectator) - stats[STAT_ACTIVEWEAPON] = ((entvars_t*)&ent->v)->weapon; + stats[STAT_ACTIVEWEAPON] = SVFIELD (ent, weapon, float); // stuff the sigil bits into the high bits of items for sbar stats[STAT_ITEMS] = - (int) ((entvars_t*)&ent->v)->items | ((int) *sv_globals.serverflags << 28); + (int) SVFIELD (ent, items, float) | ((int) *sv_globals.serverflags << 28); // Extensions to the QW 2.40 protocol for Mega2k --KB - stats[STAT_VIEWHEIGHT] = (int) ((entvars_t*)&ent->v)->view_ofs[2]; + stats[STAT_VIEWHEIGHT] = (int) SVFIELD (ent, view_ofs, vector)[2]; // FIXME: this should become a * key! --KB - if (((entvars_t*)&ent->v)->movetype == MOVETYPE_FLY && !atoi (Info_ValueForKey + if (SVFIELD (ent, movetype, float) == MOVETYPE_FLY && !atoi (Info_ValueForKey (svs.info, "playerfly"))) - ((entvars_t*)&ent->v)->movetype = MOVETYPE_WALK; + SVFIELD (ent, movetype, float) = MOVETYPE_WALK; - stats[STAT_FLYMODE] = (((entvars_t*)&ent->v)->movetype == MOVETYPE_FLY); + stats[STAT_FLYMODE] = (SVFIELD (ent, movetype, float) == MOVETYPE_FLY); for (i = 0; i < MAX_CL_STATS; i++) @@ -650,16 +650,16 @@ SV_UpdateToReliableMessages (void) host_client->sendinfo = false; SV_FullClientUpdate (host_client, &sv.reliable_datagram); } - if (host_client->old_frags != ((entvars_t*)&host_client->edict->v)->frags) { + if (host_client->old_frags != SVFIELD (host_client->edict, frags, float)) { for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++) { if (client->state < cs_connected) continue; ClientReliableWrite_Begin (client, svc_updatefrags, 4); ClientReliableWrite_Byte (client, i); - ClientReliableWrite_Short (client, ((entvars_t*)&host_client->edict->v)->frags); + ClientReliableWrite_Short (client, SVFIELD (host_client->edict, frags, float)); } - host_client->old_frags = ((entvars_t*)&host_client->edict->v)->frags; + host_client->old_frags = SVFIELD (host_client->edict, frags, float); } // maxspeed/entgravity changes ent = host_client->edict; diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index dd3e18958..cedecf297 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -132,7 +132,7 @@ SV_New_f (void) // send full levelname MSG_WriteString (&host_client->netchan.message, - PR_GetString (&sv_pr_state, ((entvars_t*)&sv.edicts->v)->message)); + PR_GetString (&sv_pr_state, SVFIELD (sv.edicts, message, string))); // send the movevars MSG_WriteFloat (&host_client->netchan.message, movevars.gravity); @@ -148,7 +148,7 @@ SV_New_f (void) // send music MSG_WriteByte (&host_client->netchan.message, svc_cdtrack); - MSG_WriteByte (&host_client->netchan.message, ((entvars_t*)&sv.edicts->v)->sounds); + MSG_WriteByte (&host_client->netchan.message, SVFIELD (sv.edicts, sounds, float)); // send server info string MSG_WriteByte (&host_client->netchan.message, svc_stufftext); @@ -379,9 +379,9 @@ SV_Spawn_f (void) ent = host_client->edict; memset (&ent->v, 0, sv_pr_state.progs->entityfields * 4); - ((entvars_t*)&ent->v)->colormap = NUM_FOR_EDICT (&sv_pr_state, ent); - ((entvars_t*)&ent->v)->team = 0; // FIXME - ((entvars_t*)&ent->v)->netname = PR_SetString (&sv_pr_state, host_client->name); + SVFIELD (ent, colormap, float) = NUM_FOR_EDICT (&sv_pr_state, ent); + SVFIELD (ent, team, float) = 0; // FIXME + SVFIELD (ent, netname, string) = PR_SetString (&sv_pr_state, host_client->name); host_client->entgravity = 1.0; val = GetEdictFieldValue (&sv_pr_state, ent, "gravity"); @@ -428,15 +428,15 @@ SV_SpawnSpectator (void) int i; edict_t *e; - VectorCopy (vec3_origin, ((entvars_t*)&sv_player->v)->origin); - VectorCopy (vec3_origin, ((entvars_t*)&sv_player->v)->view_ofs); - ((entvars_t*)&sv_player->v)->view_ofs[2] = 22; + VectorCopy (vec3_origin, SVFIELD (sv_player, origin, vector)); + VectorCopy (vec3_origin, SVFIELD (sv_player, view_ofs, vector)); + SVFIELD (sv_player, view_ofs, vector)[2] = 22; // search for an info_playerstart to spawn the spectator at for (i = MAX_CLIENTS - 1; i < sv.num_edicts; i++) { e = EDICT_NUM (&sv_pr_state, i); - if (!strcmp (PR_GetString (&sv_pr_state, ((entvars_t*)&e->v)->classname), "info_player_start")) { - VectorCopy (((entvars_t*)&e->v)->origin, ((entvars_t*)&sv_player->v)->origin); + if (!strcmp (PR_GetString (&sv_pr_state, SVFIELD (e, classname, string)), "info_player_start")) { + VectorCopy (SVFIELD (e, origin, vector), SVFIELD (sv_player, origin, vector)); return; } } @@ -525,7 +525,7 @@ SV_Begin_f (void) ent = EDICT_NUM (&sv_pr_state, 1 + (host_client - svs.clients)); MSG_WriteByte (&host_client->netchan.message, svc_setangle); for (i = 0; i < 2; i++) - MSG_WriteAngle (&host_client->netchan.message, ((entvars_t*)&ent->v)->angles[i]); + MSG_WriteAngle (&host_client->netchan.message, SVFIELD (ent, angles, vector)[i]); MSG_WriteAngle (&host_client->netchan.message, 0); #endif } @@ -899,7 +899,7 @@ SV_Pings_f (void) void SV_Kill_f (void) { - if (((entvars_t*)&sv_player->v)->health <= 0) { + if (SVFIELD (sv_player, health, float) <= 0) { SV_BeginRedirect (RD_CLIENT); SV_ClientPrintf (host_client, PRINT_HIGH, "Can't suicide -- already dead!\n"); @@ -1008,7 +1008,7 @@ SV_PTrack_f (void) host_client->spec_track = 0; ent = EDICT_NUM (&sv_pr_state, host_client - svs.clients + 1); tent = EDICT_NUM (&sv_pr_state, 0); - ((entvars_t*)&ent->v)->goalentity = EDICT_TO_PROG (&sv_pr_state, tent); + SVFIELD (ent, goalentity, int) = EDICT_TO_PROG (&sv_pr_state, tent); return; } @@ -1019,14 +1019,14 @@ SV_PTrack_f (void) host_client->spec_track = 0; ent = EDICT_NUM (&sv_pr_state, host_client - svs.clients + 1); tent = EDICT_NUM (&sv_pr_state, 0); - ((entvars_t*)&ent->v)->goalentity = EDICT_TO_PROG (&sv_pr_state, tent); + SVFIELD (ent, goalentity, int) = EDICT_TO_PROG (&sv_pr_state, tent); return; } host_client->spec_track = i + 1; // now tracking ent = EDICT_NUM (&sv_pr_state, host_client - svs.clients + 1); tent = EDICT_NUM (&sv_pr_state, i + 1); - ((entvars_t*)&ent->v)->goalentity = EDICT_TO_PROG (&sv_pr_state, tent); + SVFIELD (ent, goalentity, int) = EDICT_TO_PROG (&sv_pr_state, tent); } @@ -1287,16 +1287,16 @@ AddLinksToPmove (areanode_t *node) next = l->next; check = EDICT_FROM_AREA (l); - if (((entvars_t*)&check->v)->owner == pl) + if (SVFIELD (check, owner, int) == pl) continue; // player's own missile - if (((entvars_t*)&check->v)->solid == SOLID_BSP - || ((entvars_t*)&check->v)->solid == SOLID_BBOX || ((entvars_t*)&check->v)->solid == SOLID_SLIDEBOX) { + if (SVFIELD (check, solid, float) == SOLID_BSP + || SVFIELD (check, solid, float) == SOLID_BBOX || SVFIELD (check, solid, float) == SOLID_SLIDEBOX) { if (check == sv_player) continue; for (i = 0; i < 3; i++) - if (((entvars_t*)&check->v)->absmin[i] > pmove_maxs[i] - || ((entvars_t*)&check->v)->absmax[i] < pmove_mins[i]) + if (SVFIELD (check, absmin, vector)[i] > pmove_maxs[i] + || SVFIELD (check, absmax, vector)[i] < pmove_mins[i]) break; if (i != 3) continue; @@ -1305,15 +1305,15 @@ AddLinksToPmove (areanode_t *node) pe = &pmove.physents[pmove.numphysent]; pmove.numphysent++; - VectorCopy (((entvars_t*)&check->v)->origin, pe->origin); + VectorCopy (SVFIELD (check, origin, vector), pe->origin); pe->info = NUM_FOR_EDICT (&sv_pr_state, check); - if (((entvars_t*)&check->v)->solid == SOLID_BSP) { - pe->model = sv.models[(int) (((entvars_t*)&check->v)->modelindex)]; + if (SVFIELD (check, solid, float) == SOLID_BSP) { + pe->model = sv.models[(int) (SVFIELD (check, modelindex, float))]; } else { pe->model = NULL; - VectorCopy (((entvars_t*)&check->v)->mins, pe->mins); - VectorCopy (((entvars_t*)&check->v)->maxs, pe->maxs); + VectorCopy (SVFIELD (check, mins, vector), pe->mins); + VectorCopy (SVFIELD (check, maxs, vector), pe->maxs); } } } @@ -1350,30 +1350,30 @@ AddAllEntsToPmove (void) check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; - if (((entvars_t*)&check->v)->owner == pl) + if (SVFIELD (check, owner, int) == pl) continue; - if (((entvars_t*)&check->v)->solid == SOLID_BSP - || ((entvars_t*)&check->v)->solid == SOLID_BBOX - || ((entvars_t*)&check->v)->solid == SOLID_SLIDEBOX) { + if (SVFIELD (check, solid, float) == SOLID_BSP + || SVFIELD (check, solid, float) == SOLID_BBOX + || SVFIELD (check, solid, float) == SOLID_SLIDEBOX) { if (check == sv_player) continue; for (i = 0; i < 3; i++) - if (((entvars_t*)&check->v)->absmin[i] > pmove_maxs[i] - || ((entvars_t*)&check->v)->absmax[i] < pmove_mins[i]) + if (SVFIELD (check, absmin, vector)[i] > pmove_maxs[i] + || SVFIELD (check, absmax, vector)[i] < pmove_mins[i]) break; if (i != 3) continue; pe = &pmove.physents[pmove.numphysent]; - VectorCopy (((entvars_t*)&check->v)->origin, pe->origin); + VectorCopy (SVFIELD (check, origin, vector), pe->origin); pmove.physents[pmove.numphysent].info = e; - if (((entvars_t*)&check->v)->solid == SOLID_BSP) - pe->model = sv.models[(int) (((entvars_t*)&check->v)->modelindex)]; + if (SVFIELD (check, solid, float) == SOLID_BSP) + pe->model = sv.models[(int) (SVFIELD (check, modelindex, float))]; else { pe->model = NULL; - VectorCopy (((entvars_t*)&check->v)->mins, pe->mins); - VectorCopy (((entvars_t*)&check->v)->maxs, pe->maxs); + VectorCopy (SVFIELD (check, mins, vector), pe->mins); + VectorCopy (SVFIELD (check, maxs, vector), pe->maxs); } if (++pmove.numphysent == MAX_PHYSENTS) @@ -1456,29 +1456,29 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside) return; } - if (!((entvars_t*)&sv_player->v)->fixangle) - VectorCopy (ucmd->angles, ((entvars_t*)&sv_player->v)->v_angle); + if (!SVFIELD (sv_player, fixangle, float)) + VectorCopy (ucmd->angles, SVFIELD (sv_player, v_angle, vector)); - ((entvars_t*)&sv_player->v)->button0 = ucmd->buttons & 1; + SVFIELD (sv_player, button0, float) = ucmd->buttons & 1; // 1999-10-29 +USE fix by Maddes start if (!nouse) { - ((entvars_t*)&sv_player->v)->button1 = (ucmd->buttons & 4) >> 2; + SVFIELD (sv_player, button1, float) = (ucmd->buttons & 4) >> 2; } // 1999-10-29 +USE fix by Maddes end - ((entvars_t*)&sv_player->v)->button2 = (ucmd->buttons & 2) >> 1; + SVFIELD (sv_player, button2, float) = (ucmd->buttons & 2) >> 1; if (ucmd->impulse) - ((entvars_t*)&sv_player->v)->impulse = ucmd->impulse; + SVFIELD (sv_player, impulse, float) = ucmd->impulse; // // angles // show 1/3 the pitch angle and all the roll angle - if (((entvars_t*)&sv_player->v)->health > 0) { - if (!((entvars_t*)&sv_player->v)->fixangle) { - ((entvars_t*)&sv_player->v)->angles[PITCH] = -((entvars_t*)&sv_player->v)->v_angle[PITCH] / 3; - ((entvars_t*)&sv_player->v)->angles[YAW] = ((entvars_t*)&sv_player->v)->v_angle[YAW]; + if (SVFIELD (sv_player, health, float) > 0) { + if (!SVFIELD (sv_player, fixangle, float)) { + SVFIELD (sv_player, angles, vector)[PITCH] = -SVFIELD (sv_player, v_angle, vector)[PITCH] / 3; + SVFIELD (sv_player, angles, vector)[YAW] = SVFIELD (sv_player, v_angle, vector)[YAW]; } - ((entvars_t*)&sv_player->v)->angles[ROLL] = - SV_CalcRoll (((entvars_t*)&sv_player->v)->angles, ((entvars_t*)&sv_player->v)->velocity) * 4; + SVFIELD (sv_player, angles, vector)[ROLL] = + SV_CalcRoll (SVFIELD (sv_player, angles, vector), SVFIELD (sv_player, velocity, vector)) * 4; } sv_frametime = min (0.1, ucmd->msec * 0.001); @@ -1497,18 +1497,18 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside) for (i = 0; i < 3; i++) pmove.origin[i] = - ((entvars_t*)&sv_player->v)->origin[i] - + (((entvars_t*)&sv_player->v)->mins[i] - player_mins[i]); - VectorCopy (((entvars_t*)&sv_player->v)->velocity, pmove.velocity); - VectorCopy (((entvars_t*)&sv_player->v)->v_angle, pmove.angles); + SVFIELD (sv_player, origin, vector)[i] + + (SVFIELD (sv_player, mins, vector)[i] - player_mins[i]); + VectorCopy (SVFIELD (sv_player, velocity, vector), pmove.velocity); + VectorCopy (SVFIELD (sv_player, v_angle, vector), pmove.angles); - pmove.flying = ((entvars_t*)&sv_player->v)->movetype == MOVETYPE_FLY; + pmove.flying = SVFIELD (sv_player, movetype, float) == MOVETYPE_FLY; pmove.spectator = host_client->spectator; - pmove.waterjumptime = ((entvars_t*)&sv_player->v)->teleport_time; + pmove.waterjumptime = SVFIELD (sv_player, teleport_time, float); pmove.numphysent = 1; pmove.physents[0].model = sv.worldmodel; pmove.cmd = *ucmd; - pmove.dead = ((entvars_t*)&sv_player->v)->health <= 0; + pmove.dead = SVFIELD (sv_player, health, float) <= 0; pmove.oldbuttons = host_client->oldbuttons; movevars.entgravity = host_client->entgravity; @@ -1533,7 +1533,7 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside) PlayerMove (); after = PM_TestPlayerPosition (pmove.origin); - if (((entvars_t*)&sv_player->v)->health > 0 && before && !after) + if (SVFIELD (sv_player, health, float) > 0 && before && !after) Con_Printf ("player %s got stuck in playermove!!!!\n", host_client->name); } @@ -1542,29 +1542,29 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside) #endif host_client->oldbuttons = pmove.oldbuttons; - ((entvars_t*)&sv_player->v)->teleport_time = pmove.waterjumptime; - ((entvars_t*)&sv_player->v)->waterlevel = waterlevel; - ((entvars_t*)&sv_player->v)->watertype = watertype; + SVFIELD (sv_player, teleport_time, float) = pmove.waterjumptime; + SVFIELD (sv_player, waterlevel, float) = waterlevel; + SVFIELD (sv_player, watertype, float) = watertype; if (onground != -1) { - ((entvars_t*)&sv_player->v)->flags = (int) ((entvars_t*)&sv_player->v)->flags | FL_ONGROUND; - ((entvars_t*)&sv_player->v)->groundentity = + SVFIELD (sv_player, flags, float) = (int) SVFIELD (sv_player, flags, float) | FL_ONGROUND; + SVFIELD (sv_player, groundentity, int) = EDICT_TO_PROG (&sv_pr_state, EDICT_NUM (&sv_pr_state, pmove.physents[onground].info)); } else { - ((entvars_t*)&sv_player->v)->flags = (int) ((entvars_t*)&sv_player->v)->flags & ~FL_ONGROUND; + SVFIELD (sv_player, flags, float) = (int) SVFIELD (sv_player, flags, float) & ~FL_ONGROUND; } for (i = 0; i < 3; i++) - ((entvars_t*)&sv_player->v)->origin[i] = - pmove.origin[i] - (((entvars_t*)&sv_player->v)->mins[i] - player_mins[i]); + SVFIELD (sv_player, origin, vector)[i] = + pmove.origin[i] - (SVFIELD (sv_player, mins, vector)[i] - player_mins[i]); #if 0 // truncate velocity the same way the net protocol will for (i = 0; i < 3; i++) - ((entvars_t*)&sv_player->v)->velocity[i] = (int) pmove.velocity[i]; + SVFIELD (sv_player, velocity, vector)[i] = (int) pmove.velocity[i]; #else - VectorCopy (pmove.velocity, ((entvars_t*)&sv_player->v)->velocity); + VectorCopy (pmove.velocity, SVFIELD (sv_player, velocity, vector)); #endif - VectorCopy (pmove.angles, ((entvars_t*)&sv_player->v)->v_angle); + VectorCopy (pmove.angles, SVFIELD (sv_player, v_angle, vector)); if (!host_client->spectator) { // link into place and touch triggers @@ -1574,11 +1574,11 @@ SV_RunCmd (usercmd_t *ucmd, qboolean inside) for (i = 0; i < pmove.numtouch; i++) { n = pmove.physents[pmove.touchindex[i]].info; ent = EDICT_NUM (&sv_pr_state, n); - if (!((entvars_t*)&ent->v)->touch || (playertouch[n / 8] & (1 << (n % 8)))) + if (!SVFIELD (ent, touch, func) || (playertouch[n / 8] & (1 << (n % 8)))) continue; *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, ent); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, sv_player); - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&ent->v)->touch); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (ent, touch, func)); playertouch[n / 8] |= 1 << (n % 8); } } @@ -1746,7 +1746,7 @@ SV_ExecuteClientMessage (client_t *cl) o[2] = MSG_ReadCoord (net_message); // only allowed by spectators if (host_client->spectator) { - VectorCopy (o, ((entvars_t*)&sv_player->v)->origin); + VectorCopy (o, SVFIELD (sv_player, origin, vector)); SV_LinkEdict (sv_player, false); } break; diff --git a/qw/source/world.c b/qw/source/world.c index 60126178d..d3d5c4795 100644 --- a/qw/source/world.c +++ b/qw/source/world.c @@ -151,12 +151,12 @@ SV_HullForEntity (edict_t *ent, vec3_t mins, vec3_t maxs, vec3_t offset) hull_t *hull; // decide which clipping hull to use, based on the size - if (((entvars_t*)&ent->v)->solid == SOLID_BSP) { + if (SVFIELD (ent, solid, float) == SOLID_BSP) { // explicit hulls in the BSP model - if (((entvars_t*)&ent->v)->movetype != MOVETYPE_PUSH) + if (SVFIELD (ent, movetype, float) != MOVETYPE_PUSH) SV_Error ("SOLID_BSP without MOVETYPE_PUSH"); - model = sv.models[(int) ((entvars_t*)&ent->v)->modelindex]; + model = sv.models[(int) SVFIELD (ent, modelindex, float)]; if (!model || model->type != mod_brush) SV_Error ("SOLID_BSP with a non bsp model"); @@ -171,15 +171,15 @@ SV_HullForEntity (edict_t *ent, vec3_t mins, vec3_t maxs, vec3_t offset) // calculate an offset value to center the origin VectorSubtract (hull->clip_mins, mins, offset); - VectorAdd (offset, ((entvars_t*)&ent->v)->origin, offset); + VectorAdd (offset, SVFIELD (ent, origin, vector), offset); } else { // create a temp hull from bounding // box sizes - VectorSubtract (((entvars_t*)&ent->v)->mins, maxs, hullmins); - VectorSubtract (((entvars_t*)&ent->v)->maxs, mins, hullmaxs); + VectorSubtract (SVFIELD (ent, mins, vector), maxs, hullmins); + VectorSubtract (SVFIELD (ent, maxs, vector), mins, hullmaxs); hull = SV_HullForBox (hullmins, hullmaxs); - VectorCopy (((entvars_t*)&ent->v)->origin, offset); + VectorCopy (SVFIELD (ent, origin, vector), offset); } @@ -279,14 +279,14 @@ SV_TouchLinks (edict_t *ent, areanode_t *node) touch = EDICT_FROM_AREA (l); if (touch == ent) continue; - if (!((entvars_t*)&touch->v)->touch || ((entvars_t*)&touch->v)->solid != SOLID_TRIGGER) + if (!SVFIELD (touch, touch, func) || SVFIELD (touch, solid, float) != SOLID_TRIGGER) continue; - if (((entvars_t*)&ent->v)->absmin[0] > ((entvars_t*)&touch->v)->absmax[0] - || ((entvars_t*)&ent->v)->absmin[1] > ((entvars_t*)&touch->v)->absmax[1] - || ((entvars_t*)&ent->v)->absmin[2] > ((entvars_t*)&touch->v)->absmax[2] - || ((entvars_t*)&ent->v)->absmax[0] < ((entvars_t*)&touch->v)->absmin[0] - || ((entvars_t*)&ent->v)->absmax[1] < ((entvars_t*)&touch->v)->absmin[1] - || ((entvars_t*)&ent->v)->absmax[2] < ((entvars_t*)&touch->v)->absmin[2]) + if (SVFIELD (ent, absmin, vector)[0] > SVFIELD (touch, absmax, vector)[0] + || SVFIELD (ent, absmin, vector)[1] > SVFIELD (touch, absmax, vector)[1] + || SVFIELD (ent, absmin, vector)[2] > SVFIELD (touch, absmax, vector)[2] + || SVFIELD (ent, absmax, vector)[0] < SVFIELD (touch, absmin, vector)[0] + || SVFIELD (ent, absmax, vector)[1] < SVFIELD (touch, absmin, vector)[1] + || SVFIELD (ent, absmax, vector)[2] < SVFIELD (touch, absmin, vector)[2]) continue; old_self = *sv_globals.self; @@ -295,7 +295,7 @@ SV_TouchLinks (edict_t *ent, areanode_t *node) *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, touch); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, ent); *sv_globals.time = sv.time; - PR_ExecuteProgram (&sv_pr_state, ((entvars_t*)&touch->v)->touch); + PR_ExecuteProgram (&sv_pr_state, SVFIELD (touch, touch, func)); *sv_globals.self = old_self; *sv_globals.other = old_other; @@ -305,9 +305,9 @@ SV_TouchLinks (edict_t *ent, areanode_t *node) if (node->axis == -1) return; - if (((entvars_t*)&ent->v)->absmax[node->axis] > node->dist) + if (SVFIELD (ent, absmax, vector)[node->axis] > node->dist) SV_TouchLinks (ent, node->children[0]); - if (((entvars_t*)&ent->v)->absmin[node->axis] < node->dist) + if (SVFIELD (ent, absmin, vector)[node->axis] < node->dist) SV_TouchLinks (ent, node->children[1]); } @@ -342,7 +342,7 @@ SV_FindTouchedLeafs (edict_t *ent, mnode_t *node) // NODE_MIXED splitplane = node->plane; - sides = BOX_ON_PLANE_SIDE (((entvars_t*)&ent->v)->absmin, ((entvars_t*)&ent->v)->absmax, splitplane); + sides = BOX_ON_PLANE_SIDE (SVFIELD (ent, absmin, vector), SVFIELD (ent, absmax, vector), splitplane); // recurse down the contacted sides if (sides & 1) @@ -370,35 +370,35 @@ SV_LinkEdict (edict_t *ent, qboolean touch_triggers) return; // set the abs box - VectorAdd (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->absmin); - VectorAdd (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->maxs, ((entvars_t*)&ent->v)->absmax); + VectorAdd (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, absmin, vector)); + VectorAdd (SVFIELD (ent, origin, vector), SVFIELD (ent, maxs, vector), SVFIELD (ent, absmax, vector)); // // to make items easier to pick up and allow them to be grabbed off // of shelves, the abs sizes are expanded // - if ((int) ((entvars_t*)&ent->v)->flags & FL_ITEM) { - ((entvars_t*)&ent->v)->absmin[0] -= 15; - ((entvars_t*)&ent->v)->absmin[1] -= 15; - ((entvars_t*)&ent->v)->absmax[0] += 15; - ((entvars_t*)&ent->v)->absmax[1] += 15; + if ((int) SVFIELD (ent, flags, float) & FL_ITEM) { + SVFIELD (ent, absmin, vector)[0] -= 15; + SVFIELD (ent, absmin, vector)[1] -= 15; + SVFIELD (ent, absmax, vector)[0] += 15; + SVFIELD (ent, absmax, vector)[1] += 15; } else { // because movement is clipped an // epsilon away from an actual edge, // we must fully check even when bounding boxes don't quite touch - ((entvars_t*)&ent->v)->absmin[0] -= 1; - ((entvars_t*)&ent->v)->absmin[1] -= 1; - ((entvars_t*)&ent->v)->absmin[2] -= 1; - ((entvars_t*)&ent->v)->absmax[0] += 1; - ((entvars_t*)&ent->v)->absmax[1] += 1; - ((entvars_t*)&ent->v)->absmax[2] += 1; + SVFIELD (ent, absmin, vector)[0] -= 1; + SVFIELD (ent, absmin, vector)[1] -= 1; + SVFIELD (ent, absmin, vector)[2] -= 1; + SVFIELD (ent, absmax, vector)[0] += 1; + SVFIELD (ent, absmax, vector)[1] += 1; + SVFIELD (ent, absmax, vector)[2] += 1; } // link to PVS leafs ent->num_leafs = 0; - if (((entvars_t*)&ent->v)->modelindex) + if (SVFIELD (ent, modelindex, float)) SV_FindTouchedLeafs (ent, sv.worldmodel->nodes); - if (((entvars_t*)&ent->v)->solid == SOLID_NOT) + if (SVFIELD (ent, solid, float) == SOLID_NOT) return; // find the first node that the ent's box crosses @@ -406,9 +406,9 @@ SV_LinkEdict (edict_t *ent, qboolean touch_triggers) while (1) { if (node->axis == -1) break; - if (((entvars_t*)&ent->v)->absmin[node->axis] > node->dist) + if (SVFIELD (ent, absmin, vector)[node->axis] > node->dist) node = node->children[0]; - else if (((entvars_t*)&ent->v)->absmax[node->axis] < node->dist) + else if (SVFIELD (ent, absmax, vector)[node->axis] < node->dist) node = node->children[1]; else break; // crosses the node @@ -416,7 +416,7 @@ SV_LinkEdict (edict_t *ent, qboolean touch_triggers) // link it in - if (((entvars_t*)&ent->v)->solid == SOLID_TRIGGER) + if (SVFIELD (ent, solid, float) == SOLID_TRIGGER) InsertLinkBefore (&ent->area, &node->trigger_edicts); else InsertLinkBefore (&ent->area, &node->solid_edicts); @@ -490,7 +490,7 @@ SV_TestEntityPosition (edict_t *ent) trace_t trace; trace = - SV_Move (((entvars_t*)&ent->v)->origin, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, ((entvars_t*)&ent->v)->origin, 0, + SV_Move (SVFIELD (ent, origin, vector), SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), SVFIELD (ent, origin, vector), 0, ent); if (trace.startsolid) @@ -699,38 +699,38 @@ SV_ClipToLinks (areanode_t *node, moveclip_t * clip) for (l = node->solid_edicts.next; l != &node->solid_edicts; l = next) { next = l->next; touch = EDICT_FROM_AREA (l); - if (((entvars_t*)&touch->v)->solid == SOLID_NOT) + if (SVFIELD (touch, solid, float) == SOLID_NOT) continue; if (touch == clip->passedict) continue; - if (((entvars_t*)&touch->v)->solid == SOLID_TRIGGER) + if (SVFIELD (touch, solid, float) == SOLID_TRIGGER) SV_Error ("Trigger in clipping list"); - if (clip->type == MOVE_NOMONSTERS && ((entvars_t*)&touch->v)->solid != SOLID_BSP) + if (clip->type == MOVE_NOMONSTERS && SVFIELD (touch, solid, float) != SOLID_BSP) continue; - if (clip->boxmins[0] > ((entvars_t*)&touch->v)->absmax[0] - || clip->boxmins[1] > ((entvars_t*)&touch->v)->absmax[1] - || clip->boxmins[2] > ((entvars_t*)&touch->v)->absmax[2] - || clip->boxmaxs[0] < ((entvars_t*)&touch->v)->absmin[0] - || clip->boxmaxs[1] < ((entvars_t*)&touch->v)->absmin[1] - || clip->boxmaxs[2] < ((entvars_t*)&touch->v)->absmin[2]) + if (clip->boxmins[0] > SVFIELD (touch, absmax, vector)[0] + || clip->boxmins[1] > SVFIELD (touch, absmax, vector)[1] + || clip->boxmins[2] > SVFIELD (touch, absmax, vector)[2] + || clip->boxmaxs[0] < SVFIELD (touch, absmin, vector)[0] + || clip->boxmaxs[1] < SVFIELD (touch, absmin, vector)[1] + || clip->boxmaxs[2] < SVFIELD (touch, absmin, vector)[2]) continue; - if (clip->passedict != 0 && ((entvars_t*)&clip->passedict->v)->size[0] - && !((entvars_t*)&touch->v)->size[0]) continue; // points never interact + if (clip->passedict != 0 && SVFIELD (clip->passedict, size, vector)[0] + && !SVFIELD (touch, size, vector)[0]) continue; // points never interact // might intersect, so do an exact clip if (clip->trace.allsolid) return; if (clip->passedict) { - if (PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&touch->v)->owner) == clip->passedict) + if (PROG_TO_EDICT (&sv_pr_state, SVFIELD (touch, owner, int)) == clip->passedict) continue; // don't clip against own missiles - if (PROG_TO_EDICT (&sv_pr_state, ((entvars_t*)&clip->passedict->v)->owner) == touch) + if (PROG_TO_EDICT (&sv_pr_state, SVFIELD (clip->passedict, owner, int)) == touch) continue; // don't clip against owner } - if ((int) ((entvars_t*)&touch->v)->flags & FL_MONSTER) + if ((int) SVFIELD (touch, flags, float) & FL_MONSTER) trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins2, clip->maxs2, clip->end); @@ -849,30 +849,30 @@ SV_TestPlayerPosition (edict_t *ent, vec3_t origin) CONTENTS_EMPTY) return sv.edicts; // check all entities - VectorAdd (origin, ((entvars_t*)&ent->v)->mins, boxmins); - VectorAdd (origin, ((entvars_t*)&ent->v)->maxs, boxmaxs); + VectorAdd (origin, SVFIELD (ent, mins, vector), boxmins); + VectorAdd (origin, SVFIELD (ent, maxs, vector), boxmaxs); check = NEXT_EDICT (&sv_pr_state, sv.edicts); for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; - if (((entvars_t*)&check->v)->solid != SOLID_BSP && - ((entvars_t*)&check->v)->solid != SOLID_BBOX && ((entvars_t*)&check->v)->solid != SOLID_SLIDEBOX) + if (SVFIELD (check, solid, float) != SOLID_BSP && + SVFIELD (check, solid, float) != SOLID_BBOX && SVFIELD (check, solid, float) != SOLID_SLIDEBOX) continue; - if (boxmins[0] > ((entvars_t*)&check->v)->absmax[0] - || boxmins[1] > ((entvars_t*)&check->v)->absmax[1] - || boxmins[2] > ((entvars_t*)&check->v)->absmax[2] - || boxmaxs[0] < ((entvars_t*)&check->v)->absmin[0] - || boxmaxs[1] < ((entvars_t*)&check->v)->absmin[1] - || boxmaxs[2] < ((entvars_t*)&check->v)->absmin[2]) + if (boxmins[0] > SVFIELD (check, absmax, vector)[0] + || boxmins[1] > SVFIELD (check, absmax, vector)[1] + || boxmins[2] > SVFIELD (check, absmax, vector)[2] + || boxmaxs[0] < SVFIELD (check, absmin, vector)[0] + || boxmaxs[1] < SVFIELD (check, absmin, vector)[1] + || boxmaxs[2] < SVFIELD (check, absmin, vector)[2]) continue; if (check == ent) continue; // get the clipping hull - hull = SV_HullForEntity (check, ((entvars_t*)&ent->v)->mins, ((entvars_t*)&ent->v)->maxs, offset); + hull = SV_HullForEntity (check, SVFIELD (ent, mins, vector), SVFIELD (ent, maxs, vector), offset); VectorSubtract (origin, offset, offset);