tech
/
engine
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Some changes. QC execution has been tweeked a little. It needs further work still. 

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@925 fc73d0e0-1445-4013-8a0c-d673dee63da5
This commit is contained in:
Spoike 2005-03-28 00:11:59 +00:00
parent 0b3fc5c57f
commit d7bb31a516
66 changed files with 2345 additions and 2036 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
engine/Makefile
View File

@ -35,7 +35,7 @@ QUX_DIR=$(BASE_DIR)/qux
RELEASE_DIR=$(BASE_DIR)/release
DEBUG_DIR=$(BASE_DIR)/debug
DO_CC=$(CC) $(BASE_CFLAGS) $(WCFLAGS) -o $@ -c $< $(CFLAGS)
DO_CC=$(CC) $(CFLAGS) $(BASE_CFLAGS) $(WCFLAGS) -o $@ -c $<
ifeq ($(USEASM),true)
ifdef windir
DO_AS=$(CC) $(BASE_CFLAGS) $(WCFLAGS) -x assembler-with-cpp -o $@ -c $< $(CFLAGS)
@ -542,13 +542,13 @@ debugdir:
@-mkdir $(OUT_DIR)
endif
ifneq ($(shell grep all ../plugins/Makefile),)
plugins:
ifneq ($(shell grep all ../plugins/Makefile),)
$(MAKE) -C ../plugins
else
plugins:
else
@-echo no plugins directory installed
endif
endif
plugins:
help:
@-echo "Specfic targets:"

39
engine/client/cl_cam.c
View File

@ -444,6 +444,40 @@ void Cam_Track(int pnum, usercmd_t *cmd)
}
}
void Cam_TrackCrosshairedPlayer(int pnum)
{
frame_t *frame;
player_state_t *player;
int i;
float dot = 0.1, bestdot;
int best = -1;
vec3_t selforg;
vec3_t dir;
frame = &cl.frames[cl.validsequence & UPDATE_MASK];
player = frame->playerstate + cl.playernum[pnum];
VectorCopy(player->origin, selforg);
for (i = 0; i < MAX_CLIENTS; i++)
{
player = frame->playerstate + i;
VectorSubtract(player->origin, selforg, dir);
VectorNormalize(dir);
dot = DotProduct(vpn, dir);
if (dot > bestdot)
{
bestdot = dot;
best = i;
}
}
Con_Printf("Track %i? %f\n", best, bestdot);
if (best != -1) //did we actually get someone?
{
autocam[pnum]++;
Cam_Lock(pnum, best);
}
}
void Cam_FinishMove(int pnum, usercmd_t *cmd)
{
int i;
@ -478,7 +512,12 @@ void Cam_FinishMove(int pnum, usercmd_t *cmd)
{
oldbuttons[pnum] &= ~BUTTON_ATTACK;
if (!autocam[pnum])
{
if ((cmd->buttons & BUTTON_JUMP) && !(oldbuttons[pnum] & BUTTON_JUMP))
Cam_TrackCrosshairedPlayer(pnum);
oldbuttons[pnum] = (oldbuttons[pnum]&~BUTTON_JUMP) | (cmd->buttons & BUTTON_JUMP);
return;
}
}
if (autocam[pnum] && cl_hightrack.value)

4
engine/client/cl_ents.c
View File

@ -1497,12 +1497,14 @@ void CL_LinkPacketEntities (void)
AngleVectors(angles, ent->axis[0], ent->axis[1], ent->axis[2]);
VectorInverse(ent->axis[1]);
if (cl.lerpents[s1->number].tagent)
{ //ent is attached to a tag, rotate this ent accordingly.
CL_RotateAroundTag(ent, s1->number, cl.lerpents[s1->number].tagent, cl.lerpents[s1->number].tagindex);
}
if (ent->keynum <= MAX_CLIENTS)
ent->keynum += MAX_EDICTS;
// add automatic particle trails
if (!model || (!(model->flags&~EF_ROTATE) && model->particletrail<0))
continue;

12
engine/client/cl_input.c
View File

@ -1103,17 +1103,21 @@ void CL_SendCmd (float frametime)
}
#endif
if (msecs>150) //q2 has 200 slop.
msecs=150;
msecs += frametime*1000;
// Con_Printf("%f\n", msecs);
if (msecs>1000) //come on... That's just stupid.
msecs=1000;
if (msecs<0)
msecs=0; //erm.
// if (cls.state < ca_active)
// msecs = 0;
msecstouse = (int)msecs; //casts round down.
if (!CL_FilterTime(msecstouse, cl_netfps.value<=0?cl_maxfps.value:cl_netfps.value) && msecstouse<255)
if (!CL_FilterTime(msecstouse, cl_netfps.value<=0?cl_maxfps.value:cl_netfps.value) && msecstouse<255 && cls.state == ca_active)
{
usercmd_t new;
@ -1155,6 +1159,8 @@ void CL_SendCmd (float frametime)
if (msecstouse > 255)
msecstouse = 255;
// Con_Printf("sending %i msecs\n", msecstouse);
for (plnum = 0; plnum < cl.splitclients; plnum++)
{
// save this command off for prediction

8
engine/client/cl_pred.c
View File

@ -82,9 +82,9 @@ void CLQ2_CheckPredictionError (void)
}
else
{
if (/*cl_showmiss->value && */(delta[0] || delta[1] || delta[2]) )
Con_Printf ("prediction miss on %i: %i\n", cl.q2frame.serverframe,
delta[0] + delta[1] + delta[2]);
// if (/*cl_showmiss->value && */(delta[0] || delta[1] || delta[2]) )
// Con_Printf ("prediction miss on %i: %i\n", cl.q2frame.serverframe,
// delta[0] + delta[1] + delta[2]);
VectorCopy (cl.q2frame.playerstate.pmove.origin, cl_predicted_origins[frame]);
@ -274,7 +274,7 @@ void CLQ2_PredictMovement (void) //q2 doesn't support split clients.
if (current - ack >= UPDATE_MASK)
{
// if (cl_showmiss->value)
Con_Printf ("exceeded CMD_BACKUP\n");
// Con_Printf ("exceeded CMD_BACKUP\n");
return;
}

46
engine/client/cl_tent.c
View File

@ -28,7 +28,7 @@ entity_state_t *CL_FindPacketEntity(int num);
#ifdef Q2CLIENT
typedef enum
{
Q2TE_GUNSHOT,
Q2TE_GUNSHOT, //0
Q2TE_BLOOD,
Q2TE_BLASTER,
Q2TE_RAILTRAIL,
@ -38,7 +38,7 @@ typedef enum
Q2TE_ROCKET_EXPLOSION,
Q2TE_GRENADE_EXPLOSION,
Q2TE_SPARKS,
Q2TE_SPLASH,
Q2TE_SPLASH, //10
Q2TE_BUBBLETRAIL,
Q2TE_SCREEN_SPARKS,
Q2TE_SHIELD_SPARKS,
@ -48,7 +48,7 @@ typedef enum
Q2TE_ROCKET_EXPLOSION_WATER,
Q2TE_GRENADE_EXPLOSION_WATER,
Q2TE_MEDIC_CABLE_ATTACK,
Q2TE_BFG_EXPLOSION,
Q2TE_BFG_EXPLOSION, //20
Q2TE_BFG_BIGEXPLOSION,
Q2TE_BOSSTPORT, // used as '22' in a map, so DON'T RENUMBER!!!
Q2TE_BFG_LASER,
@ -59,7 +59,7 @@ typedef enum
Q2TE_PLASMA_EXPLOSION,
Q2TE_TUNNEL_SPARKS,
//ROGUE
Q2TE_BLASTER2,
Q2TE_BLASTER2, //30
Q2TE_RAILTRAIL2,
Q2TE_FLAME,
Q2TE_LIGHTNING,
@ -69,7 +69,7 @@ typedef enum
Q2TE_FORCEWALL,
Q2TE_HEATBEAM,
Q2TE_MONSTER_HEATBEAM,
Q2TE_STEAM,
Q2TE_STEAM, //40
Q2TE_BUBBLETRAIL2,
Q2TE_MOREBLOOD,
Q2TE_HEATBEAM_SPARKS,
@ -79,7 +79,7 @@ typedef enum
Q2TE_TRACKER_EXPLOSION,
Q2TE_TELEPORT_EFFECT,
Q2TE_DBALL_GOAL,
Q2TE_WIDOWBEAMOUT,
Q2TE_WIDOWBEAMOUT, //50
Q2TE_NUKEBLAST,
Q2TE_WIDOWSPLASH,
Q2TE_EXPLOSION1_BIG,
@ -1701,36 +1701,32 @@ void CLQ2_ParseTEnt (void)
ent = CL_ParseLightning (cl_mod_lightning);
S_StartSound (NULL, ent, CHAN_WEAPON, cl_sfx_lightning, 1, ATTN_NORM, 0);
break;
*/
case Q2TE_DEBUGTRAIL:
MSG_ReadPos (&net_message, pos);
MSG_ReadPos (&net_message, pos2);
CL_DebugTrail (pos, pos2);
MSG_ReadPos (pos);
MSG_ReadPos (pos2);
P_ParticleTrail(pos, pos2, P_AllocateParticleType("te_debugtrail"), NULL);
break;
case Q2TE_PLAIN_EXPLOSION:
MSG_ReadPos (&net_message, pos);
MSG_ReadPos (pos);
ex = CL_AllocExplosion ();
VectorCopy (pos, ex->ent.origin);
ex->type = ex_poly;
ex->ent.flags = Q2RF_FULLBRIGHT;
ex->start = cl.frame.servertime - 100;
VectorCopy (pos, ex->origin);
// ex->type = ex_poly;
ex->flags = Q2RF_FULLBRIGHT;
ex->light = 350;
ex->lightcolor[0] = 1.0;
ex->lightcolor[1] = 0.5;
ex->lightcolor[2] = 0.5;
ex->ent.angles[1] = rand() % 360;
ex->ent.model = cl_mod_explo4;
if (frand() < 0.5)
ex->baseframe = 15;
ex->frames = 15;
if (type == TE_ROCKET_EXPLOSION_WATER)
S_StartSound (pos, 0, 0, cl_sfx_watrexp, 1, ATTN_NORM, 0);
else
S_StartSound (pos, 0, 0, cl_sfx_rockexp, 1, ATTN_NORM, 0);
ex->angles[1] = rand() % 360;
ex->model = Mod_ForName (q2tentmodels[q2cl_mod_explo4].modelname, false);
if (rand() < RAND_MAX/2)
ex->firstframe = 15;
ex->numframes = 15;
Q2S_StartSound (pos, 0, 0, S_PrecacheSound("weapons/rocklx1a.wav"), 1, ATTN_NORM, 0);
break;
/*
case Q2TE_FLASHLIGHT:
MSG_ReadPos(&net_message, pos);
ent = MSG_ReadShort(&net_message);

32
engine/client/m_single.c
View File

@ -424,7 +424,7 @@ void M_Menu_Demos_f (void)
//we don't support them, but if we were to ask quizmo to decode them for us, we could do.
info->numext = 4;
MC_AddWhiteText(menu, 24, 8, "Demos", false);
MC_AddWhiteText(menu, 24, 8, "Choose a Demo", false);
MC_AddWhiteText(menu, 16, 24, "\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37", false);
info->list = MC_AddCustom(menu, 0, 32, NULL);
@ -436,6 +436,36 @@ void M_Menu_Demos_f (void)
ShowDemoMenu(menu, "");
}
void M_Menu_ParticleSets_f (void)
{
demomenu_t *info;
menu_t *menu;
key_dest = key_menu;
m_state = m_complex;
m_entersound = true;
menu = M_CreateMenu(sizeof(demomenu_t));
menu->remove = M_Demo_Remove;
info = menu->data;
info->command[0] = "r_particlesdesc";
info->ext[0] = ".cfg";
info->command[1] = "playdemo";
info->numext = 1;
MC_AddWhiteText(menu, 24, 8, "Choose a Particle Set", false);
MC_AddWhiteText(menu, 16, 24, "\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37", false);
info->list = MC_AddCustom(menu, 0, 32, NULL);
info->list->draw = M_DemoDraw;
info->list->key = M_DemoKey;
menu->selecteditem = (menuoption_t*)info->list;
ShowDemoMenu(menu, "particles/");
}
void M_Menu_MediaFiles_f (void)
{
demomenu_t *info;

3
engine/client/menu.c
View File

@ -796,6 +796,7 @@ void M_Menu_Quit_f (void)
void M_Menu_MediaFiles_f (void);
void M_Menu_FPS_f (void);
void M_Menu_Particles_f (void);
void M_Menu_ParticleSets_f (void);
void M_Menu_Audio_Speakers_f (void);
static qboolean internalmenusregistered;
void M_Init_Internal (void)
@ -838,6 +839,7 @@ void M_Init_Internal (void)
Cmd_AddRemCommand ("menu_speakers", M_Menu_Audio_Speakers_f);
Cmd_AddRemCommand ("menu_fps", M_Menu_FPS_f);
Cmd_AddRemCommand ("menu_particles", M_Menu_Particles_f);
Cmd_AddRemCommand ("menu_particlesets", M_Menu_ParticleSets_f);
}
void M_DeInit_Internal (void)
@ -876,6 +878,7 @@ void M_DeInit_Internal (void)
Cmd_RemoveCommand ("menu_audio");
Cmd_RemoveCommand ("menu_fps");
Cmd_RemoveCommand ("menu_particles");
Cmd_RemoveCommand ("menu_particlesets");
}
//menu.dat is loaded later... after the video and everything is up.

2
engine/client/merged.h
View File

@ -108,7 +108,7 @@ extern int (*Mod_TagNumForName) (struct model_s *model, char *name);
#undef FNC
void Draw_FunString(int x, int y, char *str);
void Draw_FunString(int x, int y, unsigned char *str);
#ifdef SERVERONLY

59
engine/client/pr_csqc.c
View File

@ -126,8 +126,9 @@ typedef struct csqcedict_s
float freetime; // sv.time when the object was freed
int entnum;
qboolean readonly; //world
csqcentvars_t v;
csqcentvars_t *v;
//add whatever you wish here
} csqcedict_t;
csqcedict_t *csqc_edicts; //consider this 'world'
@ -135,11 +136,11 @@ csqcedict_t *csqc_edicts; //consider this 'world'
void CSQC_InitFields(void)
{ //CHANGING THIS FUNCTION REQUIRES CHANGES TO csqcentvars_t
#define fieldfloat(name) PR_RegisterFieldVar(csqcprogs, ev_float, #name, (int)&((csqcedict_t*)0)->v.name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldvector(name) PR_RegisterFieldVar(csqcprogs, ev_vector, #name, (int)&((csqcedict_t*)0)->v.name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldentity(name) PR_RegisterFieldVar(csqcprogs, ev_entity, #name, (int)&((csqcedict_t*)0)->v.name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldstring(name) PR_RegisterFieldVar(csqcprogs, ev_string, #name, (int)&((csqcedict_t*)0)->v.name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldfunction(name) PR_RegisterFieldVar(csqcprogs, ev_function, #name, (int)&((csqcedict_t*)0)->v.name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldfloat(name) PR_RegisterFieldVar(csqcprogs, ev_float, #name, (int)&((csqcedict_t*)0)->v->name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldvector(name) PR_RegisterFieldVar(csqcprogs, ev_vector, #name, (int)&((csqcedict_t*)0)->v->name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldentity(name) PR_RegisterFieldVar(csqcprogs, ev_entity, #name, (int)&((csqcedict_t*)0)->v->name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldstring(name) PR_RegisterFieldVar(csqcprogs, ev_string, #name, (int)&((csqcedict_t*)0)->v->name - (int)&((csqcedict_t*)0)->v, -1)
#define fieldfunction(name) PR_RegisterFieldVar(csqcprogs, ev_function, #name, (int)&((csqcedict_t*)0)->v->name - (int)&((csqcedict_t*)0)->v, -1)
csqcfields
#undef fieldfloat
#undef fieldvector
@ -297,15 +298,15 @@ static void PF_R_AddEntity(progfuncs_t *prinst, struct globalvars_s *pr_globals)
int i;
model_t *model;
if (in->v.predraw)
if (in->v->predraw)
{
int oldself = *csqcg.self;
*csqcg.self = EDICT_TO_PROG(prinst, (void*)in);
PR_ExecuteProgram(prinst, in->v.predraw);
PR_ExecuteProgram(prinst, in->v->predraw);
*csqcg.self = oldself;
}
i = in->v.modelindex;
i = in->v->modelindex;
if (i == 0)
return;
else if (i > 0 && i < MAX_MODELS)
@ -325,19 +326,19 @@ static void PF_R_AddEntity(progfuncs_t *prinst, struct globalvars_s *pr_globals)
}
ent.frame = in->v.frame;
ent.oldframe = in->v.oldframe;
ent.lerpfrac = in->v.lerpfrac;
ent.frame = in->v->frame;
ent.oldframe = in->v->oldframe;
ent.lerpfrac = in->v->lerpfrac;
ent.angles[0] = in->v.angles[0];
ent.angles[1] = in->v.angles[1];
ent.angles[2] = in->v.angles[2];
memcpy(ent.origin, in->v.origin, sizeof(vec3_t));
ent.angles[0] = in->v->angles[0];
ent.angles[1] = in->v->angles[1];
ent.angles[2] = in->v->angles[2];
memcpy(ent.origin, in->v->origin, sizeof(vec3_t));
AngleVectors(ent.angles, ent.axis[0], ent.axis[1], ent.axis[2]);
VectorInverse(ent.axis[1]);
ent.alpha = in->v.alpha;
ent.scale = in->v.scale;
ent.alpha = in->v->alpha;
ent.scale = in->v->scale;
V_AddEntity(&ent);
}
@ -363,7 +364,7 @@ static void PF_R_AddEntityMask(progfuncs_t *prinst, struct globalvars_s *pr_glob
if (ent->isfree)
continue;
if ((int)ent->v.drawmask & mask)
if ((int)ent->v->drawmask & mask)
{
G_INT(OFS_PARM0) = EDICT_TO_PROG(prinst, (void*)ent);
PF_R_AddEntity(prinst, pr_globals);
@ -618,7 +619,7 @@ static void PF_CSQC_SetOrigin(progfuncs_t *prinst, struct globalvars_s *pr_globa
{
csqcedict_t *ent = (void*)G_EDICT(prinst, OFS_PARM0);
float *org = G_VECTOR(OFS_PARM1);
VectorCopy(org, ent->v.origin);
VectorCopy(org, ent->v->origin);
//fixme: add some sort of fast area grid
}
@ -746,22 +747,22 @@ static void PF_CSQC_SetModel(progfuncs_t *prinst, struct globalvars_s *pr_global
cl.model_csqcprecache[-freei] = Mod_ForName(cl.model_csqcname[-freei], false);
}
ent->v.modelindex = modelindex;
ent->v->modelindex = modelindex;
if (modelindex < 0)
ent->v.model = PR_SetString(prinst, cl.model_csqcname[-modelindex]);
ent->v->model = PR_SetString(prinst, cl.model_csqcname[-modelindex]);
else
ent->v.model = PR_SetString(prinst, cl.model_name[modelindex]);
ent->v->model = PR_SetString(prinst, cl.model_name[modelindex]);
}
static void PF_CSQC_SetModelIndex(progfuncs_t *prinst, struct globalvars_s *pr_globals)
{
csqcedict_t *ent = (void*)G_EDICT(prinst, OFS_PARM0);
int modelindex = G_FLOAT(OFS_PARM1);
ent->v.modelindex = modelindex;
ent->v->modelindex = modelindex;
if (modelindex < 0)
ent->v.model = PR_SetString(prinst, cl.model_csqcname[-modelindex]);
ent->v->model = PR_SetString(prinst, cl.model_csqcname[-modelindex]);
else
ent->v.model = PR_SetString(prinst, cl.model_name[modelindex]);
ent->v->model = PR_SetString(prinst, cl.model_name[modelindex]);
}
static void PF_CSQC_PrecacheModel(progfuncs_t *prinst, struct globalvars_s *pr_globals)
{
@ -1330,7 +1331,7 @@ qboolean CSQC_Init (unsigned int checksum)
{
in_sensitivityscale = 1;
csqcprogs = InitProgs(&csqcprogparms);
PR_Configure(csqcprogs, NULL, -1, 1);
PR_Configure(csqcprogs, -1, 1);
CSQC_InitFields(); //let the qclib know the field order that the engine needs.
@ -1514,7 +1515,7 @@ void CSQC_ParseEntities(void)
#ifndef CLIENTONLY
if (sv.state)
{
Con_Printf("Server classname: \"%s\"\n", svprogfuncs->stringtable+EDICT_NUM(svprogfuncs, entnum)->v.classname);
Con_Printf("Server classname: \"%s\"\n", svprogfuncs->stringtable+EDICT_NUM(svprogfuncs, entnum)->v->classname);
}
#endif
}

3
engine/client/pr_menu.c
View File

@ -14,6 +14,7 @@ typedef struct menuedict_s
float freetime; // sv.time when the object was freed
int entnum;
qboolean readonly; //world
void *fields;
} menuedict_t;
#define RETURN_SSTRING(s) (*(char **)&((int *)pr_globals)[OFS_RETURN] = PR_SetString(prinst, s)) //static - exe will not change it.
@ -1399,7 +1400,7 @@ void MP_Init (void)
if (!menuprogs)
{
menuprogs = InitProgs(&menuprogparms);
PR_Configure(menuprogs, NULL, -1, 1);
PR_Configure(menuprogs, -1, 1);
if (PR_LoadProgs(menuprogs, "menu.dat", 10020, NULL, 0) < 0) //no per-progs builtins.
{
//failed to load or something

2
engine/client/renderer.c
View File

@ -1566,7 +1566,7 @@ TRACE(("dbg: R_ApplyRenderer: clearing world\n"));
}
ent = sv.edicts;
ent->v.model = PR_SetString(svprogfuncs, sv.worldmodel->name); //FIXME: is this a problem for normal ents?
ent->v->model = PR_SetString(svprogfuncs, sv.worldmodel->name); //FIXME: is this a problem for normal ents?
for (i=0 ; i<sv.num_edicts ; i++)
{
ent = EDICT_NUM(svprogfuncs, i);

4
engine/client/sbar.c
View File

@ -108,7 +108,7 @@ void Sbar_TeamOverlay (void);
void Sbar_MiniDeathmatchOverlay (void);
void Sbar_ChatModeOverlay(void);
void Draw_FunString(int x, int y, char *str)
void Draw_FunString(int x, int y, unsigned char *str)
{
int ext = COLOR_WHITE<<8;
int extstack[4];
@ -175,7 +175,7 @@ void Draw_FunString(int x, int y, char *str)
}
}
void Draw_FunStringLen(int x, int y, char *str, int len)
void Draw_FunStringLen(int x, int y, unsigned char *str, int len)
{
int ext = COLOR_WHITE<<8;
int extstack[4];

4
engine/client/wad.c
View File

@ -458,11 +458,11 @@ qbyte *W_GetTexture(char *name, int *width, int *height, qboolean *usesalpha)//r
return NULL;
}
char *COM_ParseToken (char *data);
//extern model_t *loadmodel;
char wads[4096];
void Mod_ParseInfoFromEntityLump(char *data) //actually, this should be in the model code.
void Mod_ParseInfoFromEntityLump(const char *data) //actually, this should be in the model code.
{
extern model_t *loadmodel;
char key[128];

2
engine/client/wad.h
View File

@ -94,6 +94,6 @@ void SwapPic (qpic_t *pic);
void Mod_ParseWadsFromEntityLump(char *data);
qbyte *W_ConvertWAD3Texture(miptex_t *tex, int *width, int *height, qboolean *usesalpha);
void Mod_ParseInfoFromEntityLump(char *data);
void Mod_ParseInfoFromEntityLump(const char *data);
qboolean Wad_NextDownload (void);
qbyte *W_GetTexture(char *name, int *width, int *height, qboolean *usesalpha);

12
engine/client/zqtp.c
View File

@ -797,6 +797,13 @@ static char *Macro_Match_Type (void)
return "ffa";
}
static char *Macro_Version (void)
{
/* you probably don't need date, but it's included as this is likly to be used by
q2 servers checking for cheats. */
return va("%.2f "DISTRIBUTION" ["__DATE__"] (%i)", VERSION, build_number());
}
/*
$droploc
Tells location of the dropped flag.
@ -846,6 +853,7 @@ $triggermatch is the last chat message that exec'd a msg_trigger.
static void TP_InitMacros(void)
{
Cmd_AddMacro("version", Macro_Version, false);
Cmd_AddMacro("qt", Macro_Quote, false);
Cmd_AddMacro("latency", Macro_Latency, false);
Cmd_AddMacro("health", Macro_Health, true);
@ -1225,7 +1233,7 @@ static char *TP_LocationName (vec3_t location)
}
recursive = true;
Cmd_ExpandString (locdata[minnum].name, buf, sizeof(buf), Cmd_ExecLevel);
Cmd_ExpandString (locdata[minnum].name, buf, sizeof(buf), Cmd_ExecLevel, false);
recursive = false;
return buf;
@ -2649,7 +2657,7 @@ static void CL_Say (qboolean team, char *extra)
!strchr(s, '\x0d') /* explicit $\ in message overrides cl_fakename */)
{
char buf[1024];
Cmd_ExpandString (cl_fakename.string, buf, sizeof(buf), Cmd_ExecLevel);
Cmd_ExpandString (cl_fakename.string, buf, sizeof(buf), Cmd_ExecLevel, true);
strcpy (buf, TP_ParseMacroString (buf));
Q_snprintfz (sendtext, sizeof(sendtext), "\x0d%s: ", TP_ParseFunChars(buf, true));
}

109
engine/common/cmd.c
View File

@ -186,13 +186,12 @@ void Cbuf_AddText (const char *text, int level)
if (!cmd_text[level].buf.maxsize)
{
cmd_text[level].buf.data = Z_Malloc(8192);
cmd_text[level].buf.data = (qbyte*)Z_Malloc(8192);
cmd_text[level].buf.maxsize = 8192;
}
if (cmd_text[level].buf.cursize + l >= cmd_text[level].buf.maxsize)
{
int newmax;
char *newbuf;
newmax = cmd_text[level].buf.maxsize*2;
@ -203,8 +202,7 @@ void Cbuf_AddText (const char *text, int level)
}
while (newmax < cmd_text[level].buf.cursize + l)
newmax*=2;
newbuf = Z_Malloc(newmax);
cmd_text[level].buf.data = Z_Malloc(newmax);
cmd_text[level].buf.data = (qbyte*)Z_Malloc(newmax);
cmd_text[level].buf.maxsize = newmax;
}
SZ_Write (&cmd_text[level].buf, text, Q_strlen (text));
@ -235,7 +233,7 @@ void Cbuf_InsertText (const char *text, int level)
templen = cmd_text[level].buf.cursize;
if (templen)
{
temp = Z_Malloc (templen+1);
temp = (char*)Z_Malloc (templen+1);
Q_memcpy (temp, cmd_text[level].buf.data, templen);
SZ_Clear (&cmd_text[level].buf);
}
@ -315,7 +313,7 @@ start:
char *Cbuf_StripText(int level) //remove all text in the command buffer and return it (so it can be readded later)
{
char *buf;
buf = Z_Malloc(cmd_text[level].buf.cursize+1);
buf = (char*)Z_Malloc(cmd_text[level].buf.cursize+1);
Q_memcpy (buf, cmd_text[level].buf.data, cmd_text[level].buf.cursize);
cmd_text[level].buf.cursize = 0;
return buf;
@ -422,7 +420,7 @@ void Cmd_StuffCmds (void)
if (!s)
return;
text = Z_Malloc (s+1);
text = (char*)Z_Malloc (s+1);
text[0] = 0;
for (i=1 ; i<com_argc ; i++)
{
@ -434,7 +432,7 @@ void Cmd_StuffCmds (void)
}
// pull out the commands
build = Z_Malloc (s+1);
build = (char*)Z_Malloc (s+1);
build[0] = 0;
for (i=0 ; i<s-1 ; i++)
@ -530,7 +528,7 @@ char *CopyString (char *in)
{
char *out;
out = Z_Malloc (strlen(in)+1);
out = (char*)Z_Malloc (strlen(in)+1);
strcpy (out, in);
return out;
}
@ -658,7 +656,7 @@ void Cmd_Alias_f (void)
if (!a)
{
a = Z_Malloc (sizeof(cmdalias_t));
a = (cmdalias_t*)Z_Malloc (sizeof(cmdalias_t));
a->next = cmd_alias;
cmd_alias = a;
}
@ -715,7 +713,7 @@ void Cmd_Alias_f (void)
}
if (a->value)
{
newv = Z_Malloc(strlen(a->value) + strlen(s) + 2);
newv = (char*)Z_Malloc(strlen(a->value) + strlen(s) + 2);
sprintf(newv, "%s;%s", a->value, s);
Z_Free(a->value);
a->value = newv;
@ -1031,7 +1029,7 @@ If not SERVERONLY, also expands $macro expressions
Note: dest must point to a 1024 byte buffer
================
*/
char *Cmd_ExpandString (char *data, char *dest, int destlen, int maxaccesslevel)
char *Cmd_ExpandString (char *data, char *dest, int destlen, int maxaccesslevel, qboolean expandmacros)
{
unsigned int c;
char buf[255];
@ -1054,7 +1052,7 @@ char *Cmd_ExpandString (char *data, char *dest, int destlen, int maxaccesslevel)
{
data++;
striptrailing = *data == '-';
striptrailing = (*data == '-')?true:false;
// Copy the text after '$' to a temp buffer
i = 0;
@ -1075,7 +1073,7 @@ char *Cmd_ExpandString (char *data, char *dest, int destlen, int maxaccesslevel)
bestvar = var;
}
#ifndef SERVERONLY
if ((str = TP_MacroString (buf+striptrailing, &macro_length)))
if (expandmacros && (str = TP_MacroString (buf+striptrailing, &macro_length)))
bestmacro = str;
#endif
}
@ -1181,7 +1179,7 @@ void Cmd_TokenizeString (char *text, qboolean expandmacros, qboolean qctokenize)
if (cmd_argc < MAX_ARGS)
{
cmd_argv[cmd_argc] = Z_Malloc (Q_strlen(com_token)+1);
cmd_argv[cmd_argc] = (char*)Z_Malloc (Q_strlen(com_token)+1);
Q_strcpy (cmd_argv[cmd_argc], com_token);
cmd_argc++;
}
@ -1219,7 +1217,7 @@ qboolean Cmd_AddCommand (char *cmd_name, xcommand_t function)
}
}
cmd = Hunk_AllocName (sizeof(cmd_function_t), cmd_name);
cmd = (cmd_function_t*)Hunk_AllocName (sizeof(cmd_function_t), cmd_name);
cmd->name = cmd_name;
cmd->function = function;
cmd->next = cmd_functions;
@ -1250,7 +1248,7 @@ qboolean Cmd_AddRemCommand (char *cmd_name, xcommand_t function)
}
}
cmd = Z_Malloc (sizeof(cmd_function_t)+strlen(cmd_name)+1);
cmd = (cmd_function_t*)Z_Malloc (sizeof(cmd_function_t)+strlen(cmd_name)+1);
cmd->name = (char*)(cmd+1);
strcpy(cmd->name, cmd_name);
cmd->function = function;
@ -1486,7 +1484,7 @@ char *Cmd_CompleteCommand (char *partial, qboolean fullonly, int matchnum)
if (matchnum == -1)
len++;
match.allowcutdown = !fullonly;
match.allowcutdown = !fullonly?true:false;
match.cutdown = false;
if (matchnum)
match.matchnum = matchnum;
@ -1611,8 +1609,8 @@ void Cmd_ExecuteString (char *text, int level)
Cmd_ExecLevel = level;
text = Cmd_ExpandString(text, dest, sizeof(dest), level);
Cmd_TokenizeString (text, level == RESTRICT_LOCAL, false);
text = Cmd_ExpandString(text, dest, sizeof(dest), level, !Cmd_FromServer()?true:false);
Cmd_TokenizeString (text, level == RESTRICT_LOCAL?true:false, false);
// execute the command line
if (!Cmd_Argc())
@ -1785,38 +1783,38 @@ tempstack_t *If_Token_GetMark (void)
}
char *retstring(char *s)
const char *retstring(const char *s)
{
// return s;
tempstack_t *ret;
ret = Z_Malloc(sizeof(tempstack_t)+strlen(s));
ret = (tempstack_t*)Z_Malloc(sizeof(tempstack_t)+strlen(s));
ret->next = ifstack;
ifstack=ret;
strcpy(ret->str, s);
return ret->str;
}
char *retfloat(float f)
const char *retfloat(float f)
{
char s[1024];
tempstack_t *ret;
if (!f)
return "";
sprintf(s, "%f", f);
ret = Z_Malloc(sizeof(tempstack_t)+strlen(s));
ret = (tempstack_t*)Z_Malloc(sizeof(tempstack_t)+strlen(s));
ret->next = ifstack;
ifstack=ret;
strcpy(ret->str, s);
return ret->str;
}
qboolean is_numeric (char *c)
qboolean is_numeric (const char *c)
{
return (*c >= '0' && *c <= '9') ||
((*c == '-' || *c == '+') && (c[1] == '.' || (c[1]>='0' && c[1]<='9'))) ||
(*c == '.' && (c[1]>='0' && c[1]<='9'));
(*c == '.' && (c[1]>='0' && c[1]<='9'))?true:false;
}
char *If_Token(char *func, char **end)
const char *If_Token(const char *func, const char **end)
{
char *s, *s2;
const char *s, *s2;
cvar_t *var;
int level;
while(*func <= ' ' && *func)
@ -2036,7 +2034,7 @@ void Cbuf_ExecBlock(int level)
if (exectext)
{
char *newv;
newv = Z_Malloc(strlen(exectext) + strlen(line) + 2);
newv = (char*)Z_Malloc(strlen(exectext) + strlen(line) + 2);
sprintf(newv, "%s;%s", exectext, line);
Z_Free(exectext);
exectext = newv;
@ -2107,8 +2105,9 @@ void Cbuf_SkipBlock(int level)
void Cmd_if_f(void)
{
char *text = Cmd_Args();
char *ret, *ws;
const char *ret;
char *end;
char *ws;
int level;
qboolean trueblock=false;
tempstack_t *ts;
@ -2124,7 +2123,7 @@ void Cmd_if_f(void)
elseif:
// Con_Printf("if %s\n", text);
for(ret = If_Token(text, &end); *ret; ret++) {if (*ret != '0' && *ret != '.')break;}
for(ret = If_Token(text, (const char **)&end); *ret; ret++) {if (*ret != '0' && *ret != '.')break;}
if (!end)
{
Con_TPrintf(TL_IFSYNTAXERROR);
@ -2210,20 +2209,41 @@ skipblock:
void Cmd_set_f(void)
{
cvar_t *var;
char *end;
char *text = Cmd_Args();
const char *end;
const char *text;
int forceflags = 0;
if (Cmd_Argc()<3)
{
Con_TPrintf(TL_SETSYNTAX);
return;
}
while(*text <= ' ') //first whitespace
text++;
while(*text > ' ') //first var
text++;
while(*text <= ' ') //second whitespace
text++;
var = Cvar_Get (Cmd_Argv(1), "0", 0, "Custom variables");
if (Cmd_FromServer()) //AAHHHH!!!
{
text = Cmd_Argv(3);
if (!strcmp(text, "u"))
forceflags = CVAR_USERINFO;
else if (!strcmp(text, "s"))
forceflags = CVAR_SERVERINFO;
else if (*text) //err
return;
text = Cmd_Argv(2);
}
else
{
text = Cmd_Args();
forceflags = 0;
while(*text <= ' ' && *text) //first whitespace
text++;
while(*text > ' ') //first var
text++;
while(*text <= ' ' && *text) //second whitespace
text++;
}
//second var
var = Cvar_FindVar (Cmd_Argv(1));
@ -2236,11 +2256,20 @@ void Cmd_set_f(void)
return;
}
text = If_Token(text, &end);
if (Cmd_FromServer())
{
if (forceflags)
{
var->flags &=~(CVAR_USERINFO|CVAR_SERVERINFO);
var->flags |= forceflags;
}
Cvar_LockFromServer(var, text);
}
else
{
text = If_Token(text, &end);
Cvar_Set(var, text);
}
}
else
{

2
engine/common/cmd.h
View File

@ -137,7 +137,7 @@ void Cmd_MessageTrigger (char *message, int type);
void Cmd_ShiftArgs (int ammount, qboolean expandstring);
char *Cmd_ExpandString (char *data, char *dest, int destlen, int maxaccesslevel);
char *Cmd_ExpandString (char *data, char *dest, int destlen, int maxaccesslevel, qboolean expandmacros);
extern cvar_t rcon_level;

105
engine/common/common.c
View File

@ -70,9 +70,9 @@ cvar_t registered = {"registered","0"};
qboolean com_modified; // set true if using non-id files
int static_registered = 1; // only for startup check, then set
qboolean static_registered = true; // only for startup check, then set
qboolean msg_suppress_1 = 0;
qboolean msg_suppress_1 = false;
void COM_InitFilesystem (void);
void COM_Path_f (void);
@ -604,7 +604,7 @@ void MSG_WriteChar (sizebuf_t *sb, int c)
Sys_Error ("MSG_WriteChar: range error");
#endif
buf = SZ_GetSpace (sb, 1);
buf = (qbyte*)SZ_GetSpace (sb, 1);
buf[0] = c;
}
@ -617,7 +617,7 @@ void MSG_WriteByte (sizebuf_t *sb, int c)
Sys_Error ("MSG_WriteByte: range error");
#endif
buf = SZ_GetSpace (sb, 1);
buf = (qbyte*)SZ_GetSpace (sb, 1);
buf[0] = c;
}
@ -630,7 +630,7 @@ void MSG_WriteShort (sizebuf_t *sb, int c)
Sys_Error ("MSG_WriteShort: range error");
#endif
buf = SZ_GetSpace (sb, 2);
buf = (qbyte*)SZ_GetSpace (sb, 2);
buf[0] = c&0xff;
buf[1] = c>>8;
}
@ -639,7 +639,7 @@ void MSG_WriteLong (sizebuf_t *sb, int c)
{
qbyte *buf;
buf = SZ_GetSpace (sb, 4);
buf = (qbyte*)SZ_GetSpace (sb, 4);
buf[0] = c&0xff;
buf[1] = (c>>8)&0xff;
buf[2] = (c>>16)&0xff;
@ -661,7 +661,7 @@ void MSG_WriteFloat (sizebuf_t *sb, float f)
SZ_Write (sb, &dat.l, 4);
}
void MSG_WriteString (sizebuf_t *sb, char *s)
void MSG_WriteString (sizebuf_t *sb, const char *s)
{
if (!s)
SZ_Write (sb, "", 1);
@ -1318,7 +1318,7 @@ void SZ_Print (sizebuf_t *buf, const char *data)
else
{
qbyte *msg;
msg = SZ_GetSpace(buf, len-1);
msg = (qbyte*)SZ_GetSpace(buf, len-1);
if (msg == buf->data) //whoops. SZ_GetSpace can return buf->data if it overflowed.
msg++;
Q_memcpy (msg-1,data,len); // write over trailing 0
@ -1400,7 +1400,7 @@ void COM_CleanUpPath(char *str)
critisize = 2;
}
}
while (dots = strstr(str, ".."))
while ((dots = strstr(str, "..")))
{
for (slash = dots-2; slash >= str; slash--)
{
@ -1643,7 +1643,7 @@ char *COM_StringParse (char *data, qboolean expandmacros, qboolean qctokenize)
{
int c;
int len;
unsigned char *s;
char *s;
len = 0;
com_token[0] = 0;
@ -1807,7 +1807,7 @@ skipwhite:
for (i = 1; i < sizeof(name); i++)
{
if (s[i] <= ' ' || s[i] == '$')
if (((unsigned char*)s)[i] <= ' ' || s[i] == '$')
break;
}
@ -1833,7 +1833,7 @@ skipwhite:
return data;
}
char *COM_ParseToken (char *data)
const char *COM_ParseToken (const char *data)
{
int c;
int len;
@ -2101,7 +2101,7 @@ void COM_CheckRegistered (void)
int i;
COM_FOpenFile("gfx/pop.lmp", &h);
static_registered = 0;
static_registered = false;
if (!h)
{
@ -2121,7 +2121,7 @@ void COM_CheckRegistered (void)
if (pop[i] != (unsigned short)BigShort (check[i]))
Sys_Error ("Corrupted data file.");
static_registered = 1;
static_registered = true;
Con_TPrintf (TL_REGISTEREDVERSION);
}
@ -2148,7 +2148,7 @@ void COM_InitArgv (int argc, char **argv) //not allowed to tprint
len = ftell(f);
fseek(f, 0, SEEK_SET);
buffer = malloc(len+1);
buffer = (char*)malloc(len+1);
fread(buffer, 1, len, f);
buffer[len] = '\0';
@ -2403,13 +2403,14 @@ char *Com_ReadFileInZip(zipfile_t *zip, int index, char *buffer);
void *com_pathforfile; //fread and stuff is preferable if null.
#endif
typedef struct searchpath_s
{
enum {SPT_OS, SPT_PACK
typedef enum {SPT_OS, SPT_PACK
#ifdef ZLIB
, SPT_ZIP
#endif
} type;
} searchpathtype_t;
typedef struct searchpath_s
{
searchpathtype_t type;
char filename[MAX_OSPATH];
union {
pack_t *pack; // only one of filename / pack will be used
@ -2665,7 +2666,7 @@ int FS_RebuildOSFSHash(char *filename, int filesize, void *data)
}
if (!Hash_GetInsensative(&filesystemhash, filename))
{
bucket_t *bucket = BZ_Malloc(sizeof(bucket_t) + strlen(filename)+1);
bucket_t *bucket = (bucket_t*)BZ_Malloc(sizeof(bucket_t) + strlen(filename)+1);
strcpy((char *)(bucket+1), filename);
#ifdef _WIN32
Q_strlwr((char *)(bucket+1));
@ -2710,7 +2711,7 @@ void FS_RebuildFSHash(void)
if (!filesystemhash.numbuckets)
{
filesystemhash.numbuckets = 1024;
filesystemhash.bucket = BZ_Malloc(Hash_BytesForBuckets(filesystemhash.numbuckets));
filesystemhash.bucket = (bucket_t**)BZ_Malloc(Hash_BytesForBuckets(filesystemhash.numbuckets));
}
else
{
@ -3041,7 +3042,7 @@ int FS_FLocateFile(char *filename, FSLF_ReturnType_e returntype, flocation_t *lo
{
if (com_fschanged)
FS_RebuildFSHash();
pf = Hash_GetInsensative(&filesystemhash, filename);
pf = (packfile_t*)Hash_GetInsensative(&filesystemhash, filename);
if (!pf)
goto fail;
}
@ -3272,7 +3273,7 @@ Allways appends a 0 qbyte to the loaded data.
*/
qbyte *COM_LoadFile (char *path, int usehunk)
{
char *buf;
qbyte *buf;
FILE *f;
int len;
char base[32];
@ -3298,24 +3299,24 @@ qbyte *COM_LoadFile (char *path, int usehunk)
COM_FileBase (path, base);
if (usehunk == 0)
buf = Z_Malloc (len+1);
buf = (qbyte*)Z_Malloc (len+1);
else if (usehunk == 1)
buf = Hunk_AllocName (len+1, base);
buf = (qbyte*)Hunk_AllocName (len+1, base);
else if (usehunk == 2)
buf = Hunk_TempAlloc (len+1);
buf = (qbyte*)Hunk_TempAlloc (len+1);
else if (usehunk == 3)
buf = Cache_Alloc (loadcache, len+1, base);
buf = (qbyte*)Cache_Alloc (loadcache, len+1, base);
else if (usehunk == 4)
{
if (len+1 > loadsize)
buf = Hunk_TempAlloc (len+1);
buf = (qbyte*)Hunk_TempAlloc (len+1);
else
buf = loadbuf;
}
else if (usehunk == 5)
buf = BZ_Malloc(len+1);
buf = (qbyte*)BZ_Malloc(len+1);
else if (usehunk == 6)
buf = Hunk_TempAllocMore (len+1);
buf = (qbyte*)Hunk_TempAllocMore (len+1);
else
{
Sys_Error ("COM_LoadFile: bad usehunk");
@ -3562,7 +3563,7 @@ pack_t *COM_LoadPackFile (char *packfile)
// if (numpackfiles != PAK0_COUNT)
// com_modified = true; // not the original file
newfiles = Z_Malloc (numpackfiles * sizeof(packfile_t));
newfiles = (packfile_t*)Z_Malloc (numpackfiles * sizeof(packfile_t));
fseek (packhandle, header.dirofs, SEEK_SET);
// fread (&info, 1, header.dirlen, packhandle);
@ -3573,7 +3574,7 @@ pack_t *COM_LoadPackFile (char *packfile)
// CRC_Init (&crc);
pack = Z_Malloc (sizeof (pack_t));
pack = (pack_t*)Z_Malloc (sizeof (pack_t));
#ifdef HASH_FILESYSTEM
Hash_InitTable(&pack->hash, numpackfiles+1, Z_Malloc(Hash_BytesForBuckets(numpackfiles+1)));
#endif
@ -3674,7 +3675,7 @@ qboolean COM_LoadMapPackFile (char *filename, int ofs)
if (!packhandle)
{
Con_Printf("Couldn't reopen file\n");
return -1;
return false;
}
fseek(packhandle, loc.offset, SEEK_SET);
@ -3692,11 +3693,11 @@ qboolean COM_LoadMapPackFile (char *filename, int ofs)
numpackfiles = header.dirlen / sizeof(dpackfile_t);
newfiles = Z_Malloc (numpackfiles * sizeof(packfile_t));
newfiles = (packfile_t*)Z_Malloc (numpackfiles * sizeof(packfile_t));
fseek (packhandle, header.dirofs+fstart, SEEK_SET);
pack = Z_Malloc (sizeof (pack_t));
pack = (pack_t*)Z_Malloc (sizeof (pack_t));
#ifdef HASH_FILESYSTEM
Hash_InitTable(&pack->hash, numpackfiles+1, Z_Malloc(Hash_BytesForBuckets(numpackfiles+1)));
#endif
@ -3723,7 +3724,7 @@ qboolean COM_LoadMapPackFile (char *filename, int ofs)
Con_TPrintf (TL_ADDEDPACKFILE, filename, numpackfiles);
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_PACK;
*search->filename = '*';
strcpy (search->filename+1, filename);
@ -3798,11 +3799,11 @@ qboolean COM_LoadWadFile (char *wadname)
numpackfiles = header.dirlen;
newfiles = Z_Malloc (numpackfiles * sizeof(packfile_t));
newfiles = (packfile_t*)Z_Malloc (numpackfiles * sizeof(packfile_t));
fseek (packhandle, header.dirofs+fstart, SEEK_SET);
pack = Z_Malloc (sizeof (pack_t));
pack = (pack_t*)Z_Malloc (sizeof (pack_t));
#ifdef HASH_FILESYSTEM
Hash_InitTable(&pack->hash, numpackfiles+1, Z_Malloc(Hash_BytesForBuckets(numpackfiles+1)));
#endif
@ -3928,7 +3929,7 @@ newsection:
Con_Printf ("Added wad file %s\n", wadname, numpackfiles);
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_PACK;
strcpy (search->filename, wadname);
search->u.pack = pack;
@ -4087,7 +4088,7 @@ void COM_AddPacks (char *descriptor)
pak = COM_LoadPackFile (pakfile);
if (!pak)
break;
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_PACK;
strcpy (search->filename, pakfile);
search->u.pack = pak;
@ -4115,7 +4116,7 @@ int COM_AddPacksWild (char *descriptor, int size, void *param)
pak = COM_LoadPackFile (pakfile);
if (!pak)
return true;
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_PACK;
strcpy (search->filename, pakfile);
search->u.pack = pak;
@ -4140,7 +4141,7 @@ void COM_AddZips (char *descriptor)
zip = COM_LoadZipFile (pakfile);
if (!zip)
break;
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_ZIP;
Q_strncpyz (search->filename, pakfile, sizeof(search->filename));
search->u.zip = zip;
@ -4222,7 +4223,7 @@ void COM_AddGameDirectory (char *dir)
//
// add the directory to the search path
//
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_OS;
strcpy (search->filename, dir);
search->next = com_searchpaths;
@ -4394,7 +4395,7 @@ void COM_Gamedir (char *dir)
//
// add the directory to the search path
//
search = Z_Malloc (sizeof(searchpath_t));
search = (searchpath_t*)Z_Malloc (sizeof(searchpath_t));
search->type = SPT_OS;
strcpy (search->filename, com_gamedir);
search->next = com_searchpaths;
@ -4563,7 +4564,7 @@ Searches the string for the given
key and returns the associated value, or an empty string.
===============
*/
char *Info_ValueForKey (char *s, char *key)
char *Info_ValueForKey (char *s, const char *key)
{
char pkey[1024];
static char value[4][1024]; // use two buffers so compares
@ -4625,7 +4626,7 @@ char *Info_ValueForKey (char *s, char *key)
}
}
void Info_RemoveKey (char *s, char *key)
void Info_RemoveKey (char *s, const char *key)
{
char *start;
char pkey[1024];
@ -4762,9 +4763,9 @@ void Info_RemoveNonStarKeys (char *start)
}
void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
void Info_SetValueForStarKey (char *s, const char *key, const char *value, int maxsize)
{
char new[1024], *v;
char newv[1024], *v;
int c;
#ifdef SERVERONLY
extern cvar_t sv_highchars;
@ -4809,9 +4810,9 @@ void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
if (!value || !strlen(value))
return;
_snprintf (new, sizeof(new), "\\%s\\%s", key, value);
_snprintf (newv, sizeof(newv), "\\%s\\%s", key, value);
if ((int)(strlen(new) + strlen(s) + 1) > maxsize)
if ((int)(strlen(newv) + strlen(s) + 1) > maxsize)
{
Con_TPrintf (TL_INFOSTRINGTOOLONG);
return;
@ -4819,7 +4820,7 @@ void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
// only copy ascii values
s += strlen(s);
v = new;
v = newv;
while (*v)
{
c = (unsigned char)*v++;
@ -4847,7 +4848,7 @@ void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize)
*s = 0;
}
void Info_SetValueForKey (char *s, char *key, char *value, int maxsize)
void Info_SetValueForKey (char *s, const char *key, const char *value, int maxsize)
{
if (key[0] == '*')
{

16
engine/common/common.h
View File

@ -27,7 +27,9 @@ typedef unsigned char qbyte;
#undef false
#ifdef __cplusplus
typedef enum qboolean;//false and true are forcivly defined.
typedef enum {qfalse, qtrue} qboolean;//false and true are forcivly defined.
#define true qtrue
#define false qfalse
#else
typedef enum {false, true} qboolean;
#endif
@ -130,7 +132,7 @@ void MSG_WriteByte (sizebuf_t *sb, int c);
void MSG_WriteShort (sizebuf_t *sb, int c);
void MSG_WriteLong (sizebuf_t *sb, int c);
void MSG_WriteFloat (sizebuf_t *sb, float f);
void MSG_WriteString (sizebuf_t *sb, char *s);
void MSG_WriteString (sizebuf_t *sb, const char *s);
void MSG_WriteCoord (sizebuf_t *sb, float f);
void MSG_WriteBigCoord (sizebuf_t *sb, float f);
void MSG_WriteAngle (sizebuf_t *sb, float f);
@ -216,7 +218,7 @@ extern qboolean com_eof;
char *COM_Parse (char *data);
char *COM_ParseCString (char *data);
char *COM_StringParse (char *data, qboolean expandmacros, qboolean qctokenize);
char *COM_ParseToken (char *data);
const char *COM_ParseToken (const char *data);
char *COM_TrimString(char *str);
@ -293,12 +295,12 @@ extern struct cvar_s registered;
extern qboolean standard_quake, rogue, hipnotic;
#define MAX_INFO_KEY 64
char *Info_ValueForKey (char *s, char *key);
void Info_RemoveKey (char *s, char *key);
char *Info_ValueForKey (char *s, const char *key);
void Info_RemoveKey (char *s, const char *key);
void Info_RemovePrefixedKeys (char *start, char prefix);
void Info_RemoveNonStarKeys (char *start);
void Info_SetValueForKey (char *s, char *key, char *value, int maxsize);
void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize);
void Info_SetValueForKey (char *s, const char *key, const char *value, int maxsize);
void Info_SetValueForStarKey (char *s, const char *key, const char *value, int maxsize);
void Info_Print (char *s);
unsigned Com_BlockChecksum (void *buffer, int length);

46
engine/common/cvar.c
View File

@ -31,7 +31,7 @@ char *cvar_null_string = "";
Cvar_FindVar
============
*/
cvar_t *Cvar_FindVar (char *var_name)
cvar_t *Cvar_FindVar (const char *var_name)
{
cvar_group_t *grp;
cvar_t *var;
@ -49,7 +49,7 @@ cvar_t *Cvar_FindVar (char *var_name)
return NULL;
}
cvar_group_t *Cvar_FindGroup (char *group_name)
cvar_group_t *Cvar_FindGroup (const char *group_name)
{
cvar_group_t *grp;
@ -59,7 +59,7 @@ cvar_group_t *Cvar_FindGroup (char *group_name)
return NULL;
}
cvar_group_t *Cvar_GetGroup(char *gname)
cvar_group_t *Cvar_GetGroup(const char *gname)
{
cvar_group_t *g;
if (!gname)
@ -68,8 +68,8 @@ cvar_group_t *Cvar_GetGroup(char *gname)
if (g)
return g;
g = Z_Malloc(sizeof(cvar_group_t));
g->name = gname;
g = (cvar_group_t*)Z_Malloc(sizeof(cvar_group_t));
g->name = (char*)gname;
g->next = NULL;
g->next = cvar_groups;
cvar_groups = g;
@ -101,7 +101,7 @@ void Cvar_List_f (void)
Cvar_VariableValue
============
*/
float Cvar_VariableValue (char *var_name)
float Cvar_VariableValue (const char *var_name)
{
cvar_t *var;
@ -117,7 +117,7 @@ float Cvar_VariableValue (char *var_name)
Cvar_VariableString
============
*/
char *Cvar_VariableString (char *var_name)
char *Cvar_VariableString (const char *var_name)
{
cvar_t *var;
@ -171,7 +171,7 @@ void SV_SendServerInfoChange(char *key, char *value);
Cvar_Set
============
*/
cvar_t *Cvar_SetCore (cvar_t *var, char *value, qboolean force)
cvar_t *Cvar_SetCore (cvar_t *var, const char *value, qboolean force)
{
char *latch=NULL;
@ -222,7 +222,7 @@ cvar_t *Cvar_SetCore (cvar_t *var, char *value, qboolean force)
var->latched_string = NULL;
return NULL;
}
var->latched_string = Z_Malloc(strlen(value)+1);
var->latched_string = (char*)Z_Malloc(strlen(value)+1);
strcpy(var->latched_string, value);
return NULL;
}
@ -263,7 +263,7 @@ cvar_t *Cvar_SetCore (cvar_t *var, char *value, qboolean force)
Z_Free (var->string); // free the old value string
}
var->string = Z_Malloc (Q_strlen(value)+1);
var->string = (char*)Z_Malloc (Q_strlen(value)+1);
Q_strcpy (var->string, value);
var->value = Q_atof (var->string);
@ -347,11 +347,11 @@ void Cvar_ApplyLatches(int latchflag)
}
}
cvar_t *Cvar_Set (cvar_t *var, char *value)
cvar_t *Cvar_Set (cvar_t *var, const char *value)
{
return Cvar_SetCore(var, value, false);
}
cvar_t *Cvar_ForceSet (cvar_t *var, char *value)
cvar_t *Cvar_ForceSet (cvar_t *var, const char *value)
{
return Cvar_SetCore(var, value, true);
}
@ -410,7 +410,7 @@ Cvar_RegisterVariable
Adds a freestanding variable to the variable list.
============
*/
void Cvar_Register (cvar_t *variable, char *groupname)
void Cvar_Register (cvar_t *variable, const char *groupname)
{
cvar_t *old;
cvar_group_t *group;
@ -436,10 +436,10 @@ void Cvar_Register (cvar_t *variable, char *groupname)
group->cvars = variable;
// make sure it can be zfreed
variable->string = Z_Malloc (1);
variable->string = (char*)Z_Malloc (1);
//cheat prevention - engine set default is the one that stays.
variable->defaultstr = Z_Malloc (strlen(value)+1); //give it it's default (for server controlled vars and things)
variable->defaultstr = (char*)Z_Malloc (strlen(value)+1); //give it it's default (for server controlled vars and things)
strcpy (variable->defaultstr, value);
// set it through the function to be consistant
@ -470,9 +470,9 @@ void Cvar_Register (cvar_t *variable, char *groupname)
variable->restriction = 0; //exe registered vars
group->cvars = variable;
variable->string = Z_Malloc (1);
variable->string = (char*)Z_Malloc (1);
variable->defaultstr = Z_Malloc (strlen(value)+1); //give it it's default (for server controlled vars and things)
variable->defaultstr = (char*)Z_Malloc (strlen(value)+1); //give it it's default (for server controlled vars and things)
strcpy (variable->defaultstr, value);
// set it through the function to be consistant
@ -484,7 +484,7 @@ void Cvar_RegisterVariable (cvar_t *variable)
Cvar_Register(variable, NULL);
}
*/
cvar_t *Cvar_Get(char *name, char *defaultvalue, int flags, char *group)
cvar_t *Cvar_Get(const char *name, const char *defaultvalue, int flags, const char *group)
{
cvar_t *var;
var = Cvar_FindVar(name);
@ -497,10 +497,10 @@ cvar_t *Cvar_Get(char *name, char *defaultvalue, int flags, char *group)
return var;
}
var = Z_Malloc(sizeof(cvar_t)+strlen(name)+1);
var = (cvar_t*)Z_Malloc(sizeof(cvar_t)+strlen(name)+1);
var->name = (char *)(var+1);
strcpy(var->name, name);
var->string = defaultvalue;
var->string = (char*)defaultvalue;
var->flags = flags|CVAR_POINTER|CVAR_USERCREATED;
Cvar_Register(var, group);
@ -509,11 +509,11 @@ cvar_t *Cvar_Get(char *name, char *defaultvalue, int flags, char *group)
}
//prevent the client from altering the cvar until they change map or the server resets the var to the default.
void Cvar_LockFromServer(cvar_t *var, char *str)
void Cvar_LockFromServer(cvar_t *var, const char *str)
{
char *oldlatch;
Con_DPrintf("Server taking control of cvar %s\n", var->name);
Con_DPrintf("Server taking control of cvar %s (%s)\n", var->name, str);
var->flags |= CVAR_SERVEROVERRIDE;
@ -522,7 +522,7 @@ void Cvar_LockFromServer(cvar_t *var, char *str)
var->latched_string = NULL;
else //taking control
{
oldlatch = Z_Malloc(strlen(var->string)+1);
oldlatch = (char*)Z_Malloc(strlen(var->string)+1);
strcpy(oldlatch, var->string);
}

22
engine/common/cvar.h
View File

@ -60,7 +60,7 @@ typedef struct cvar_s
char *string;
char *latched_string; // for CVAR_LATCH vars
int flags;
qboolean modified; // set each time the cvar is changed
int modified; // increased each time the cvar is changed
float value;
struct cvar_s *next;
@ -72,7 +72,7 @@ typedef struct cvar_s
typedef struct cvar_group_s
{
char *name;
const char *name;
struct cvar_group_s *next;
cvar_t *cvars;
@ -98,18 +98,18 @@ typedef struct cvar_group_s
#define CVAR_LATCHMASK (CVAR_LATCH|CVAR_RENDERERLATCH|CVAR_SERVEROVERRIDE|CVAR_CHEAT|CVAR_SEMICHEAT) //you're only allowed one of these.
#define CVAR_NEEDDEFAULT CVAR_CHEAT
cvar_t *Cvar_Get (char *var_name, char *value, int flags, char *groupname);
cvar_t *Cvar_Get (const char *var_name, const char *value, int flags, const char *groupname);
void Cvar_LockFromServer(cvar_t *var, char *str);
void Cvar_LockFromServer(cvar_t *var, const char *str);
void Cvar_Register (cvar_t *variable, char *cvargroup);
void Cvar_Register (cvar_t *variable, const char *cvargroup);
// registers a cvar that allready has the name, string, and optionally the
// archive elements set.
//#define Cvar_RegisterVariable(x) Cvar_Register(x,__FILE__);
cvar_t *Cvar_ForceSet (cvar_t *var, char *value);
cvar_t *Cvar_Set (cvar_t *var, char *value);
cvar_t *Cvar_ForceSet (cvar_t *var, const char *value);
cvar_t *Cvar_Set (cvar_t *var, const char *value);
// equivelant to "<name> <variable>" typed at the console
void Cvar_SetValue (cvar_t *var, float value);
@ -118,13 +118,13 @@ void Cvar_SetValue (cvar_t *var, float value);
void Cvar_ApplyLatches(int latchflag);
//sets vars to thier latched values
float Cvar_VariableValue (char *var_name);
float Cvar_VariableValue (const char *var_name);
// returns 0 if not defined or non numeric
char *Cvar_VariableString (char *var_name);
char *Cvar_VariableString (const char *var_name);
// returns an empty string if not defined
char *Cvar_CompleteVariable (char *partial);
char *Cvar_CompleteVariable (const char *partial);
// attempts to match a partial variable name for command line completion
// returns NULL if nothing fits
@ -137,7 +137,7 @@ void Cvar_WriteVariables (FILE *f, qboolean all);
// Writes lines containing "set variable value" for all variables
// with the archive flag set to true.
cvar_t *Cvar_FindVar (char *var_name);
cvar_t *Cvar_FindVar (const char *var_name);
void Cvar_Shutdown(void);

4
engine/common/gl_q2bsp.c
View File

@ -1200,7 +1200,7 @@ void CMod_LoadTexInfo (lump_t *l) //yes I know these load from the same place
{
for (lwr = in->texture; *lwr; lwr++)
{
if (*lwr >= 'A' || *lwr <= 'Z')
if (*lwr >= 'A' && *lwr <= 'Z')
*lwr = *lwr - 'A' + 'a';
}
_snprintf (name, sizeof(name), "textures/%s.wal", in->texture);
@ -1224,7 +1224,7 @@ void CMod_LoadTexInfo (lump_t *l) //yes I know these load from the same place
loadmodel->textures[texcount++] = out->texture;
}
#if !defined(SERVERONLY) && defined(RGLQUAKE)
else if (out->flags & SURF_SKY)
else if (out->flags & SURF_SKY && skytexturenum>=0)
out->texture = loadmodel->textures[skytexturenum];
#endif
}

92
engine/common/huff.c
View File

@ -130,7 +130,7 @@ static ID_INLINE void **Huff_GetNode( void **tree ) {
void **node;
int value;
node = tree[262];
node = (void**)tree[262];
if( !node ) {
value = VALUE( tree[1] )++;
node = &tree[value + 6407];
@ -149,7 +149,7 @@ Huff_Swap
static ID_INLINE void Huff_Swap( void **tree1, void **tree2, void **tree3 ) {
void **a, **b;
a = tree2[2];
a = (void**)tree2[2];
if( a ) {
if( a[0] == tree2 ) {
a[0] = tree3;
@ -160,7 +160,7 @@ static ID_INLINE void Huff_Swap( void **tree1, void **tree2, void **tree3 ) {
tree1[2] = tree3;
}
b = tree3[2];
b = (void**)tree3[2];
if( b ) {
if( b[0] == tree3 ) {
@ -189,11 +189,11 @@ Huff_SwapTrees
static ID_INLINE void Huff_SwapTrees( void **tree1, void **tree2 ) {
void **temp;
temp = tree1[3];
temp = (void**)tree1[3];
tree1[3] = tree2[3];
tree2[3] = temp;
temp = tree1[4];
temp = (void**)tree1[4];
tree1[4] = tree2[4];
tree2[4] = temp;
@ -205,22 +205,22 @@ static ID_INLINE void Huff_SwapTrees( void **tree1, void **tree2 ) {
tree2[3] = tree1;
}
temp = tree1[3];
temp = (void**)tree1[3];
if( temp ) {
temp[4] = tree1;
}
temp = tree2[3];
temp = (void**)tree2[3];
if( temp ) {
temp[4] = tree2;
}
temp = tree1[4];
temp = (void**)tree1[4];
if( temp ) {
temp[3] = tree1;
}
temp = tree2[4];
temp = (void**)tree2[4];
if( temp ) {
temp[3] = tree2;
}
@ -249,31 +249,31 @@ static void Huff_IncrementFreq_r( void **tree1, void **tree2 ) {
return;
}
a = tree2[3];
a = (void**)tree2[3];
if( a ) {
a = a[6];
a = (void**)a[6];
if( a == tree2[6] ) {
b = tree2[5];
b = (void**)tree2[5];
if( b[0] != tree2[2] ) {
Huff_Swap( tree1, b[0], tree2 );
Huff_Swap( tree1, (void**)b[0], tree2 );
}
Huff_SwapTrees( b[0], tree2 );
Huff_SwapTrees( (void**)b[0], tree2 );
}
}
a = tree2[4];
a = (void**)tree2[4];
if( a && a[6] == tree2[6] ) {
b = tree2[5];
b = (void**)tree2[5];
b[0] = a;
} else {
a = tree2[5];
a = (void**)tree2[5];
a[0] = 0;
Huff_DeleteNode( tree1, tree2[5] );
Huff_DeleteNode( tree1, (void**)tree2[5] );
}
VALUE( tree2[6] )++;
a = tree2[3];
a = (void**)tree2[3];
if( a && a[6] == tree2[6] ) {
tree2[5] = a[5];
} else {
@ -283,14 +283,14 @@ static void Huff_IncrementFreq_r( void **tree1, void **tree2 ) {
}
if( tree2[2] ) {
Huff_IncrementFreq_r( tree1, tree2[2] );
Huff_IncrementFreq_r( tree1, (void**)tree2[2] );
if( tree2[4] == tree2[2] ) {
Huff_SwapTrees( tree2, tree2[2] );
a = tree2[5];
Huff_SwapTrees( tree2, (void**)tree2[2] );
a = (void**)tree2[5];
if( a[0] == tree2 ) {
a[0] = tree2[2];
a[0] = (void**)tree2[2];
}
}
}
@ -309,7 +309,7 @@ static void Huff_AddReference( void **tree, int ch ) {
ch &= 255;
if( tree[ch + 5] ) {
Huff_IncrementFreq_r( tree, tree[ch + 5] );
Huff_IncrementFreq_r( tree, (void**)tree[ch + 5] );
return; // already added
}
@ -321,12 +321,12 @@ static void Huff_AddReference( void **tree, int ch ) {
a[7] = NODE_NEXT;
a[6] = NODE_START;
d = tree[3];
d = (void**)tree[3];
a[3] = d[3];
if( a[3] ) {
d = a[3];
d = (void**)a[3];
d[4] = a;
d = a[3];
d = (void**)a[3];
if( d[6] == NODE_START ) {
a[5] = d[5];
} else {
@ -341,15 +341,15 @@ static void Huff_AddReference( void **tree, int ch ) {
}
d = tree[3];
d = (void**)tree[3];
d[3] = a;
a[4] = tree[3];
a[4] = (void**)tree[3];
b[7] = NODE( ch );
b[6] = NODE_START;
d = tree[3];
d = (void**)tree[3];
b[3] = d[3];
if( b[3] ) {
d = b[3];
d = (void**)b[3];
d[4] = b;
if( d[6] == NODE_START ) {
b[5] = d[5];
@ -364,13 +364,13 @@ static void Huff_AddReference( void **tree, int ch ) {
d[0] = b;
}
d = tree[3];
d = (void**)tree[3];
d[3] = b;
b[4] = tree[3];
b[4] = (void**)tree[3];
b[1] = NULL;
b[0] = NULL;
d = tree[3];
c = d[2];
d = (void**)tree[3];
c = (void**)d[2];
if( c ) {
if( c[0] == tree[3] ) {
c[0] = a;
@ -382,15 +382,15 @@ static void Huff_AddReference( void **tree, int ch ) {
}
a[1] = b;
d = tree[3];
d = (void**)tree[3];
a[0] = d;
a[2] = d[2];
b[2] = a;
d = tree[3];
d = (void**)tree[3];
d[2] = a;
tree[ch + 5] = b;
Huff_IncrementFreq_r( tree, a[2] );
Huff_IncrementFreq_r( tree, (void**)a[2] );
}
/*
@ -440,7 +440,7 @@ Huff_EmitPathToByte
*/
static ID_INLINE void Huff_EmitPathToByte( void **tree, void **subtree, qbyte *buffer ) {
if( tree[2] ) {
Huff_EmitPathToByte( tree[2], tree, buffer );
Huff_EmitPathToByte( (void**)tree[2], tree, buffer );
}
if( !subtree ) {
@ -474,9 +474,9 @@ static ID_INLINE int Huff_GetByteFromTree( void **tree, qbyte *buffer ) {
//
while( tree[7] == NODE_NEXT ) {
if( !Huff_GetBit( buffer ) ) {
tree = tree[0];
tree = (void**)tree[0];
} else {
tree = tree[1];
tree = (void**)tree[1];
}
if( !tree ) {
@ -501,10 +501,10 @@ static void Huff_EmitByteDynamic( void **tree, int value, qbyte *buffer ) {
//
// if qbyte was already referenced, emit path to it
//
subtree = tree[value + 5];
subtree = (void**)tree[value + 5];
if( subtree ) {
if( subtree[2] ) {
Huff_EmitPathToByte( subtree[2], subtree, buffer );
Huff_EmitPathToByte( (void**)subtree[2], subtree, buffer );
}
return;
}
@ -606,7 +606,7 @@ void Huff_DecryptPacket( sizebuf_t *msg, int offset ) {
break;
}
ch = Huff_GetByteFromTree( tree[2], data );
ch = Huff_GetByteFromTree( (void**)tree[2], data );
if( ch == NOT_REFERENCED ) {
ch = 0; // just read 8 bits
@ -632,7 +632,7 @@ Huff_EmitByte
*/
void Huff_EmitByte( int ch, qbyte *buffer, int *count ) {
huffBitPos = *count;
Huff_EmitPathToByte( huffTree[ch + 5], NULL, buffer );
Huff_EmitPathToByte( (void**)huffTree[ch + 5], NULL, buffer );
*count = huffBitPos;
}
@ -645,7 +645,7 @@ int Huff_GetByte( qbyte *buffer, int *count ) {
int ch;
huffBitPos = *count;
ch = Huff_GetByteFromTree( huffTree[2], buffer );
ch = Huff_GetByteFromTree( (void**)huffTree[2], buffer );
*count = huffBitPos;
return ch;

62
engine/common/md5.c
View File

@ -33,16 +33,6 @@ documentation and/or software.
/* GLOBAL.H - RSAREF types and constants
*/
/* PROTOTYPES should be set to one if and only if the compiler supports
function argument prototyping.
The following makes PROTOTYPES default to 0 if it has not already
been defined with C compiler flags.
*/
#ifndef PROTOTYPES
#define PROTOTYPES 0
#endif
/* POINTER defines a generic pointer type */
typedef unsigned char *POINTER;
@ -52,17 +42,6 @@ typedef unsigned short int UINT2;
/* UINT4 defines a four byte word */
typedef unsigned long int UINT4;
/* PROTO_LIST is defined depending on how PROTOTYPES is defined above.
If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it
returns an empty list.
*/
#if PROTOTYPES
#define PROTO_LIST(list) list
#else
#define PROTO_LIST(list) ()
#endif
@ -101,10 +80,9 @@ typedef struct {
unsigned char buffer[64]; /* input buffer */
} MD5_CTX;
void MD5Init PROTO_LIST ((MD5_CTX *));
void MD5Update PROTO_LIST
((MD5_CTX *, unsigned char *, unsigned int));
void MD5Final PROTO_LIST ((unsigned char [16], MD5_CTX *));
void MD5Init (MD5_CTX *ctx);
void MD5Update (MD5_CTX *, unsigned char *, unsigned int);
void MD5Final (unsigned char [16], MD5_CTX *);
@ -137,11 +115,9 @@ void MD5Final PROTO_LIST ((unsigned char [16], MD5_CTX *));
#define S43 15
#define S44 21
static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
static void Encode PROTO_LIST
((unsigned char *, UINT4 *, unsigned int));
static void Decode PROTO_LIST
((UINT4 *, unsigned char *, unsigned int));
static void MD5Transform (UINT4 [4], unsigned char [64]);
static void Encode (unsigned char *, UINT4 *, unsigned int);
static void Decode (UINT4 *, unsigned char *, unsigned int);
static unsigned char PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -186,8 +162,7 @@ Rotation is separate from addition to prevent recomputation.
/* MD5 initialization. Begins an MD5 operation, writing a new context.
*/
void MD5Init (context)
MD5_CTX *context; /* context */
void MD5Init (MD5_CTX *context)
{
context->count[0] = context->count[1] = 0;
/* Load magic initialization constants.
@ -202,10 +177,7 @@ MD5_CTX *context; /* context */
operation, processing another message block, and updating the
context.
*/
void MD5Update (context, input, inputLen)
MD5_CTX *context; /* context */
unsigned char *input; /* input block */
unsigned int inputLen; /* length of input block */
void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
unsigned int i, index, partLen;
@ -245,9 +217,7 @@ unsigned int inputLen; /* length of input block */
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
the message digest and zeroizing the context.
*/
void MD5Final (digest, context)
unsigned char digest[16]; /* message digest */
MD5_CTX *context; /* context */
void MD5Final (unsigned char digest[16], MD5_CTX *context)
{
unsigned char bits[8];
unsigned int index, padLen;
@ -274,9 +244,7 @@ MD5_CTX *context; /* context */
/* MD5 basic transformation. Transforms state based on block.
*/
static void MD5Transform (state, block)
UINT4 state[4];
unsigned char block[64];
static void MD5Transform (UINT4 state[4], unsigned char block[64])
{
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
@ -369,10 +337,7 @@ unsigned char block[64];
/* Encodes input (UINT4) into output (unsigned char). Assumes len is
a multiple of 4.
*/
static void Encode (output, input, len)
unsigned char *output;
UINT4 *input;
unsigned int len;
static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
{
unsigned int i, j;
@ -387,10 +352,7 @@ unsigned int len;
/* Decodes input (unsigned char) into output (UINT4). Assumes len is
a multiple of 4.
*/
static void Decode (output, input, len)
UINT4 *output;
unsigned char *input;
unsigned int len;
static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
{
unsigned int i, j;

4
engine/common/q1bsp.c
View File

@ -370,7 +370,7 @@ void Q1BSP_RFindTouchedLeafs (edict_t *ent, mnode_t *node)
// NODE_MIXED
splitplane = node->plane;
sides = BOX_ON_PLANE_SIDE(ent->v.absmin, ent->v.absmax, splitplane);
sides = BOX_ON_PLANE_SIDE(ent->v->absmin, ent->v->absmax, splitplane);
// recurse down the contacted sides
if (sides & 1)
@ -382,7 +382,7 @@ void Q1BSP_RFindTouchedLeafs (edict_t *ent, mnode_t *node)
void Q1BSP_FindTouchedLeafs(edict_t *ent)
{
ent->num_leafs = 0;
if (ent->v.modelindex)
if (ent->v->modelindex)
Q1BSP_RFindTouchedLeafs (ent, sv.worldmodel->nodes);
}

14
engine/common/zone.c
View File

@ -282,9 +282,9 @@ void *Z_BaseTagMalloc (int size, int tag, qboolean clear)
vsprintf (buffer, descrip,argptr);
va_end (argptr);
nt = malloc(size + sizeof(zone_t)+strlen(buffer)+1 + ZONEDEBUG*2);
nt = (zone_t*)malloc(size + sizeof(zone_t)+strlen(buffer)+1 + ZONEDEBUG*2);
#else
nt = malloc(size + sizeof(zone_t)+ ZONEDEBUG*2);
nt = (zone_t*)malloc(size + sizeof(zone_t)+ ZONEDEBUG*2);
#endif
if (!nt)
Sys_Error("Z_BaseTagMalloc: failed on allocation of %i bytes", size);
@ -335,7 +335,7 @@ void *Z_MallocNamed (int size, char *file, int lineno)
void *Z_Malloc(int size)
{
qbyte *buf;
buf = Z_TagMalloc(size, 1);
buf = (qbyte*)Z_TagMalloc(size, 1);
if (!buf)
Sys_Error("Z_Malloc: Failed on allocation of %i bytes", size);
return buf;
@ -1169,7 +1169,7 @@ void *Hunk_TempAllocMore (int size)
#ifdef NOHIGH
#if TEMPDEBUG>0
hnktemps_t *nt;
nt = malloc(size + sizeof(hnktemps_t) + TEMPDEBUG*2);
nt = (hnktemps_t*)malloc(size + sizeof(hnktemps_t) + TEMPDEBUG*2);
nt->next = hnktemps;
nt->len = size;
hnktemps = nt;
@ -1181,7 +1181,7 @@ void *Hunk_TempAllocMore (int size)
return buf;
#else
hnktemps_t *nt;
nt = malloc(size + sizeof(hnktemps_t));
nt = (hnktemps_t*)malloc(size + sizeof(hnktemps_t));
nt->next = hnktemps;
hnktemps = nt;
buf = (void *)(nt+1);
@ -1321,7 +1321,7 @@ void *Cache_Alloc (cache_user_t *c, int size, char *name)
// size = (size + 15) & ~15;
nt = malloc(size + sizeof(cache_system_t) + CACHEDEBUG*2);
nt = (cache_system_t*)malloc(size + sizeof(cache_system_t) + CACHEDEBUG*2);
if (!nt)
Sys_Error("Cache_Alloc: failed on allocation of %i bytes", size);
nt->next = cache_head;
@ -1755,7 +1755,7 @@ void Memory_Init (void *buf, int size)
int zonesize = DYNAMIC_SIZE;
#endif
hunk_base = buf;
hunk_base = (qbyte*)buf;
hunk_size = size;
hunk_low_used = 0;
hunk_high_used = 0;

2
engine/email/sv_pop3.c
View File

@ -328,7 +328,7 @@ static qboolean SV_POP3_RunClient(svpop3client_t *cl) //true means client should
{
int read;
char *nl;
char *token;
const char *token;
int blankline;
if (cl->messagelump)

22
engine/ftequake/FTEQuake.dev
View File

@ -1,7 +1,7 @@
[Project]
FileName=FTEQuake.dev
Name=FTEQuake
UnitCount=143
UnitCount=142
Type=0
Ver=1
ObjFiles=""
@ -20,7 +20,7 @@ ObjectOutput=../../build
OverrideOutput=0
OverrideOutputName=FTEQuake.exe
HostApplication=
Folders=Client,Common,gl,inet,nq,qclib,server,x
Folders=Client,Common,gl,inet,nq,qclib,server
CommandLine=-basedir d:\quake\
IncludeVersionInfo=1
SupportXPThemes=0
@ -211,7 +211,7 @@ BuildCmd=
Major=2
Minor=5
Release=5
Build=32
Build=36
LanguageID=2057
CharsetID=1252
CompanyName=
@ -1423,9 +1423,9 @@ OverrideBuildCmd=0
BuildCmd=
[Unit139]
FileName=..\qux\m_x.c
FileName=..\client\pr_menu.c
CompileCpp=0
Folder=x
Folder=Client
Compile=1
Link=1
Priority=1000
@ -1433,9 +1433,9 @@ OverrideBuildCmd=0
BuildCmd=
[Unit140]
FileName=..\qux\x_reqs.c
FileName=..\common\plugin.c
CompileCpp=0
Folder=x
Folder=Common
Compile=1
Link=1
Priority=1000
@ -1443,9 +1443,9 @@ OverrideBuildCmd=0
BuildCmd=
[Unit141]
FileName=..\qux\x_res.c
FileName=..\client\pr_csqc.c
CompileCpp=0
Folder=x
Folder=Client
Compile=1
Link=1
Priority=1000
@ -1453,9 +1453,9 @@ OverrideBuildCmd=0
BuildCmd=
[Unit142]
FileName=..\client\pr_menu.c
FileName=..\gl\gl_shader.c
CompileCpp=0
Folder=Client
Folder=gl
Compile=1
Link=1
Priority=1000

9
engine/gl/gl_alias.c
View File

@ -696,7 +696,7 @@ static galiastexnum_t *GL_ChooseSkin(galiasinfo_t *inf, char *modelname, entity_
}
cm->texnum.bump = texnums[cm->skinnum].bump; //can't colour bumpmapping
if ((!texnums || skinname!=modelname) && e->scoreboard && e->scoreboard->skin)
if ((!texnums || !strcmp(modelname, "progs/player.mdl")) && e->scoreboard && e->scoreboard->skin)
{
original = Skin_Cache8(e->scoreboard->skin);
inwidth = e->scoreboard->skin->width;
@ -706,6 +706,7 @@ static galiastexnum_t *GL_ChooseSkin(galiasinfo_t *inf, char *modelname, entity_
{
original = NULL;
inwidth = 0;
inheight = 0;
}
if (!original)
{
@ -771,7 +772,7 @@ static galiastexnum_t *GL_ChooseSkin(galiasinfo_t *inf, char *modelname, entity_
fracstep = tinwidth*0x10000/scaled_width;
for (i=0 ; i<scaled_height ; i++, out += scaled_width)
{
inrow = original + inwidth*(i*tinheight/scaled_height);
inrow = original + inwidth*(i*inheight/scaled_height);
frac = fracstep >> 1;
for (j=0 ; j<scaled_width ; j+=4)
{
@ -798,7 +799,7 @@ static galiastexnum_t *GL_ChooseSkin(galiasinfo_t *inf, char *modelname, entity_
fracstep = tinwidth*0x10000/scaled_width;
for (i=0 ; i<scaled_height ; i++, out += scaled_width)
{
inrow = original + inwidth*(i*tinheight/scaled_height);
inrow = original + inwidth*(i*inheight/scaled_height);
frac = fracstep >> 1;
for (j=0 ; j<scaled_width ; j+=1)
{
@ -2744,7 +2745,7 @@ typedef struct {
//This is a hack. It uses an assuption about q3 player models.
void GL_ParseQ3SkinFile(char *out, char *surfname, char *modelname)
{
char *f, *p;
const char *f, *p;
char line[256];
COM_StripExtension(modelname, line);
strcat(line, "_default.skin");

8
engine/gl/gl_backend.c
View File

@ -375,7 +375,7 @@ static void Mesh_SetShaderpassState ( shaderpass_t *pass, qboolean mtex )
}
else
{
// qglDisable (GL_BLEND);
qglDisable (GL_BLEND);
}
if (pass->flags & SHADER_PASS_ALPHAFUNC)
@ -397,10 +397,10 @@ static void Mesh_SetShaderpassState ( shaderpass_t *pass, qboolean mtex )
}
else
{
// qglDisable (GL_ALPHA_TEST);
qglDisable (GL_ALPHA_TEST);
}
// qglDepthFunc (pass->depthfunc);
qglDepthFunc (pass->depthfunc);
if (pass->flags & SHADER_PASS_DEPTHWRITE)
{
@ -408,7 +408,7 @@ static void Mesh_SetShaderpassState ( shaderpass_t *pass, qboolean mtex )
}
else
{
// qglDepthMask (GL_FALSE);
qglDepthMask (GL_FALSE);
}
}

10
engine/gl/gl_model.c
View File

@ -719,10 +719,10 @@ qbyte *mod_base;
#endif
char *advtexturedesc;
char *mapsection;
char *defaultsection;
const char *mapsection;
const char *defaultsection;
static char *GLMod_TD_LeaveSection(char *file)
static const char *GLMod_TD_LeaveSection(const char *file)
{ //recursive routine to find the next }
while(file)
{
@ -735,7 +735,7 @@ static char *GLMod_TD_LeaveSection(char *file)
return NULL;
}
static char *GLMod_TD_Section(char *file, char *sectionname)
static const char *GLMod_TD_Section(const char *file, const char *sectionname)
{ //position within the open brace.
while(file)
{
@ -778,7 +778,7 @@ void GLMod_InitTextureDescs(char *mapname)
defaultsection = GLMod_TD_Section(advtexturedesc, "default");
}
}
void GLMod_LoadAdvancedTextureSection(char *section, char *name, int *base, int *norm, int *luma, int *gloss, int *alphamode, qboolean *cull) //fixme: add gloss
void GLMod_LoadAdvancedTextureSection(const char *section, char *name, int *base, int *norm, int *luma, int *gloss, int *alphamode, qboolean *cull) //fixme: add gloss
{
char stdname[MAX_QPATH] = "";
char flatname[MAX_QPATH] = "";

2
engine/gl/gl_model.h
View File

@ -822,7 +822,7 @@ int CM_HeadnodeForBox (vec3_t mins, vec3_t maxs);
struct trace_s CM_TransformedBoxTrace (vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int headnode, int brushmask, vec3_t origin, vec3_t angles);
struct model_s *CM_TempBoxModel(vec3_t mins, vec3_t maxs);
void Mod_ParseInfoFromEntityLump(char *data);
void Mod_ParseInfoFromEntityLump(const char *data);
void VARGS CMQ2_SetAreaPortalState (int portalnum, qboolean open);
#endif

92
engine/gl/gl_ppl.c
View File

@ -1620,7 +1620,7 @@ static void PPL_BaseTextureChain(msurface_t *first)
{
redraw = mb.fog != s->fog || mb.infokey != vi|| mb.shader->flags&SHADER_DEFORMV_BULGE;
if (redraw)
if (redraw)// || numIndexes + s->mesh->numindexes > MAX_ARRAY_INDEXES)
{
if (mb.mesh)
R_RenderMeshBuffer ( &mb, false );
@ -2409,7 +2409,7 @@ void PPL_LightBModelTextures(entity_t *e, dlight_t *light, vec3_t colour)
//draw the bumps on the models for each light.
void PPL_DrawEntLighting(dlight_t *light, vec3_t colour)
{
int i;
int i, j;
PPL_LightTextures(cl.worldmodel, r_worldentity.origin, light, colour);
@ -2420,29 +2420,38 @@ void PPL_DrawEntLighting(dlight_t *light, vec3_t colour)
{
currententity = &cl_visedicts[i];
if (cl.viewentity[r_refdef.currentplayernum] && currententity->keynum == cl.viewentity[r_refdef.currentplayernum])
continue;
if (r_inmirror)
{
if (currententity->flags & Q2RF_WEAPONMODEL)
continue;
}
else
{
j = currententity->keynum;
while(j)
{
if (j == (cl.viewentity[r_refdef.currentplayernum]?cl.viewentity[r_refdef.currentplayernum]:(cl.playernum[r_refdef.currentplayernum]+1)))
break;
if (!Cam_DrawPlayer(0, currententity->keynum-1))
continue;
j = cl.lerpents[j].tagent;
}
if (j)
continue;
if (cl.viewentity[r_refdef.currentplayernum] && currententity->keynum == cl.viewentity[r_refdef.currentplayernum])
continue;
if (!Cam_DrawPlayer(0, currententity->keynum-1))
continue;
}
if (currententity->flags & Q2RF_BEAM)
{
continue;
}
if (!currententity->model)
continue;
if (cls.allow_anyparticles || currententity->visframe) //allowed or static
{
if (currententity->model->particleeffect>=0)
{
if (currententity->model->particleengulphs)
{
if (gl_part_flame.value)
{
continue;
}
}
}
}
switch (currententity->model->type)
{
case mod_alias:
@ -3537,7 +3546,7 @@ void PPL_DrawBrushModel(dlight_t *dl, entity_t *e)
void PPL_DrawShadowMeshes(dlight_t *dl)
{
int i;
int i, j;
if (!r_drawentities.value)
return;
@ -3547,18 +3556,41 @@ void PPL_DrawShadowMeshes(dlight_t *dl)
{
currententity = &cl_visedicts[i];
if (cl.viewentity[r_refdef.currentplayernum] && currententity->keynum == cl.viewentity[r_refdef.currentplayernum])
continue;
if (!currententity->model)
continue;
if (dl->key == currententity->keynum)
continue;
if (currententity->flags & Q2RF_WEAPONMODEL)
continue; //weapon models don't cast shadows.
if (r_inmirror)
{
if (currententity->flags & Q2RF_WEAPONMODEL)
continue;
}
else
{
j = currententity->keynum;
while(j)
{
if (j == (cl.viewentity[r_refdef.currentplayernum]?cl.viewentity[r_refdef.currentplayernum]:(cl.playernum[r_refdef.currentplayernum]+1)))
break;
j = cl.lerpents[j].tagent;
}
if (j)
continue;
if (cl.viewentity[r_refdef.currentplayernum] && currententity->keynum == cl.viewentity[r_refdef.currentplayernum])
continue;
if (!Cam_DrawPlayer(0, currententity->keynum-1))
continue;
}
if (currententity->flags & Q2RF_BEAM)
{
continue;
}
if (!currententity->model)
continue;
if (cls.allow_anyparticles || currententity->visframe) //allowed or static
{
if (currententity->model->particleeffect>=0)

18
engine/gl/gl_shader.c
View File

@ -188,7 +188,8 @@ typedef struct shadercache_s {
} shadercache_t;
static shadercache_t *shader_hash[HASH_SIZE];
//static char shaderbuf[MAX_QPATH * 256];
static char shaderbuf[MAX_QPATH * 256];
int shaderbuflen;
shader_t r_shaders[MAX_SHADERS];
@ -896,21 +897,26 @@ static shaderkey_t shaderpasskeys[] =
int Shader_InitCallback (char *name, int size, void *param)
{
Shader_MakeCache(name+8);
name+=8; //skip the scripts/ part
strcpy(shaderbuf+shaderbuflen, name);
Shader_MakeCache(shaderbuf+shaderbuflen);
shaderbuflen += strlen(name)+1;
return true;
}
qboolean Shader_Init (void)
{
shaderbuflen = 0;
Con_Printf ( "Initializing Shaders:\n" );
COM_EnumerateFiles("scripts/*.shader", Shader_InitCallback, NULL);
/*
char *dirptr;
int i, dirlen, numdirs;
Con_Printf ( "Initializing Shaders:\n" );
numdirs = FS_GetFileList ( "scripts", "shader", shaderbuf, sizeof(shaderbuf) );
if ( !numdirs ) {
Con_Printf ("Could not find any shaders!");
@ -1699,13 +1705,13 @@ void Shader_DefaultBSP(char *shortname, shader_t *s)
pass->rgbgen = RGB_GEN_IDENTITY;
pass->numMergedPasses = 2;
if ( qglMTexCoord2fSGIS )
/* if ( qglMTexCoord2fSGIS )
{
pass->numMergedPasses = 2;
pass->flush = R_RenderMeshMultitextured;
}
else
{
*/ {
pass->numMergedPasses = 1;
pass->flush = R_RenderMeshGeneric;
}

2
engine/http/iweb.h
View File

@ -136,7 +136,7 @@ char *Q_strcpyline(char *out, char *in, int maxlen);
iwboolean FTP_StringToAdr (char *s, qbyte ip[4], qbyte port[2]);
iwboolean FTP_StringToAdr (const char *s, qbyte ip[4], qbyte port[2]);
//server tick/control functions
iwboolean FTP_ServerRun(iwboolean ftpserverwanted);

2
engine/http/iwebiface.c
View File

@ -607,7 +607,7 @@ iwboolean IWebAllowUpLoad(char *fname, char *uname) //called for partial write a
return false;
}
iwboolean FTP_StringToAdr (char *s, qbyte ip[4], qbyte port[2])
iwboolean FTP_StringToAdr (const char *s, qbyte ip[4], qbyte port[2])
{
s = COM_ParseToken(s);
ip[0] = atoi(com_token);

29
engine/qclib/execloop.h
View File

@ -179,7 +179,7 @@ reeval:
OPC->_float = (float)(!(OPA->function & ~0xff000000));
break;
case OP_NOT_ENT:
OPC->_float = (float)(PROG_TO_EDICT(OPA->edict) == (edictrun_t *)sv_edicts);
OPC->_float = (float)(PROG_TO_EDICT(progfuncs, OPA->edict) == (edictrun_t *)sv_edicts);
break;
case OP_EQ_F:
@ -385,7 +385,7 @@ reeval:
//get a pointer to a field var
case OP_ADDRESS:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -404,7 +404,7 @@ reeval:
case OP_LOAD_ENT:
case OP_LOAD_S:
case OP_LOAD_FNC:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -413,7 +413,7 @@ reeval:
break;
case OP_LOAD_V:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -650,7 +650,7 @@ reeval:
//array/structure reading/riting.
case OP_GLOBALADDRESS:
case OP_GLOBALADDRESS:
OPC->_int = (int)(&((int)(OPA->_int)) + OPB->_int);
break;
case OP_POINTER_ADD: //pointer to 32 bit (remember to *3 for vectors)
@ -692,26 +692,11 @@ reeval:
case OP_LOADP_ENT:
case OP_LOADP_S:
case OP_LOADP_FNC:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->_int = ptr->_int;
break;
case OP_LOADP_V:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int + 2 >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->vector[0] = ptr->vector[0];
OPC->vector[1] = ptr->vector[1];
@ -763,7 +748,7 @@ reeval:
break;
case OP_THINKTIME:
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(OPA->edict), OPB->_float);
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, OPA->edict), OPB->_float);
break;
@ -993,7 +978,7 @@ reeval:
break;
case OP_BOUNDCHECK:
if (OPA->_int < st->c || OPA->_int >= st->b)
if ((unsigned int)OPA->_int < (unsigned int)st->c || (unsigned int)OPA->_int >= (unsigned int)st->b)
{
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs boundcheck failed. Value is %i.", OPA->_int);

180
engine/qclib/execloop16d.h
View File

@ -179,7 +179,7 @@ reeval:
OPC->_float = (float)(!(OPA->function & ~0xff000000));
break;
case OP_NOT_ENT:
OPC->_float = (float)(PROG_TO_EDICT(OPA->edict) == (edictrun_t *)sv_edicts);
OPC->_float = (float)(PROG_TO_EDICT(progfuncs, OPA->edict) == (edictrun_t *)sv_edicts);
break;
case OP_EQ_F:
@ -385,7 +385,7 @@ reeval:
//get a pointer to a field var
case OP_ADDRESS:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -404,7 +404,7 @@ reeval:
case OP_LOAD_ENT:
case OP_LOAD_S:
case OP_LOAD_FNC:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -413,7 +413,7 @@ reeval:
break;
case OP_LOAD_V:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -531,7 +531,7 @@ reeval:
else
{
i -= externs->numglobalbuiltins;
if (i > current_progstate->numbuiltins)
if (i >= current_progstate->numbuiltins)
{
if (newf->first_statement == -0x7fffffff)
((builtin_t)newf->profile) (progfuncs, (struct globalvars_s *)current_progstate->globals);
@ -572,8 +572,8 @@ reeval:
static char buffer[1024*1024*8];
int size = sizeof buffer;
progfuncs->save_ents(progfuncs, buffer, &size, 0);
}*/
}
*/
s = PR_LeaveFunction (progfuncs);
st = &pr_statements[s];
if (pr_depth == prinst->exitdepth)
@ -692,26 +692,11 @@ reeval:
case OP_LOADP_ENT:
case OP_LOADP_S:
case OP_LOADP_FNC:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->_int = ptr->_int;
break;
case OP_LOADP_V:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int + 2 >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->vector[0] = ptr->vector[0];
OPC->vector[1] = ptr->vector[1];
@ -763,7 +748,7 @@ reeval:
break;
case OP_THINKTIME:
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(OPA->edict), OPB->_float);
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, OPA->edict), OPB->_float);
break;
@ -904,43 +889,120 @@ reeval:
case OP_BITAND_IF:
OPC->_int = (OPA->_int & (int)OPB->_float);
break;
case OP_BITOR_IF:
OPC->_int = (OPA->_int | (int)OPB->_float);
break;
case OP_BITAND_FI:
OPC->_int = ((int)OPA->_float & OPB->_int);
break;
case OP_BITOR_FI:
OPC->_int = ((int)OPA->_float | OPB->_int);
break;
case OP_MUL_IF:
OPC->_float = (OPA->_int * OPB->_float);
break;
case OP_MUL_FI:
OPC->_float = (OPA->_float * OPB->_int);
break;
case OP_MUL_IF:
case OP_MUL_FI:
case OP_MUL_VI:
case OP_DIV_IF:
case OP_DIV_FI:
case OP_BITAND_IF:
case OP_BITOR_IF:
case OP_BITAND_FI:
case OP_BITOR_FI:
case OP_AND_I:
case OP_OR_I:
case OP_AND_IF:
case OP_OR_IF:
case OP_AND_FI:
case OP_OR_FI:
case OP_NOT_I:
case OP_NE_IF:
case OP_NE_FI:
case OP_GSTOREP_I:
case OP_GSTOREP_F:
case OP_GSTOREP_ENT:
case OP_GSTOREP_FLD: // integers
case OP_GSTOREP_S:
case OP_GSTOREP_FNC: // pointers
case OP_GSTOREP_V:
case OP_GADDRESS:
case OP_GLOAD_I:
case OP_GLOAD_F:
case OP_GLOAD_FLD:
case OP_GLOAD_ENT:
case OP_GLOAD_S:
case OP_GLOAD_FNC:
case OP_BOUNDCHECK:
PR_RunError(progfuncs, "Extra opcode not implemented\n");
break;
case OP_MUL_VI:
OPC->vector[0] = OPA->vector[0] * OPB->_int;
OPC->vector[1] = OPA->vector[0] * OPB->_int;
OPC->vector[2] = OPA->vector[0] * OPB->_int;
break;
case OP_MUL_IV:
OPC->vector[0] = OPB->_int * OPA->vector[0];
OPC->vector[1] = OPB->_int * OPA->vector[1];
OPC->vector[2] = OPB->_int * OPA->vector[2];
break;
case OP_DIV_IF:
OPC->_float = (OPA->_int / OPB->_float);
break;
case OP_DIV_FI:
OPC->_float = (OPA->_float / OPB->_int);
break;
case OP_AND_I:
OPC->_int = (OPA->_int && OPB->_int);
break;
case OP_OR_I:
OPC->_int = (OPA->_int || OPB->_int);
break;
case OP_AND_IF:
OPC->_int = (OPA->_int && OPB->_float);
break;
case OP_OR_IF:
OPC->_int = (OPA->_int || OPB->_float);
break;
case OP_AND_FI:
OPC->_int = (OPA->_float && OPB->_int);
break;
case OP_OR_FI:
OPC->_int = (OPA->_float || OPB->_int);
break;
case OP_NOT_I:
OPC->_int = !OPA->_int;
break;
case OP_NE_IF:
OPC->_int = (OPA->_int != OPB->_float);
break;
case OP_NE_FI:
OPC->_int = (OPA->_float != OPB->_int);
break;
case OP_GSTOREP_I:
case OP_GSTOREP_F:
case OP_GSTOREP_ENT:
case OP_GSTOREP_FLD: // integers
case OP_GSTOREP_S:
case OP_GSTOREP_FNC: // pointers
case OP_GSTOREP_V:
case OP_GADDRESS:
case OP_GLOAD_I:
case OP_GLOAD_F:
case OP_GLOAD_FLD:
case OP_GLOAD_ENT:
case OP_GLOAD_S:
case OP_GLOAD_FNC:
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Extra opcode not implemented\n");
break;
case OP_BOUNDCHECK:
if ((unsigned int)OPA->_int < (unsigned int)st->c || (unsigned int)OPA->_int >= (unsigned int)st->b)
{
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs boundcheck failed. Value is %i.", OPA->_int);
}
break;
case OP_PUSH:
OPC->_int = (int)&localstack[localstack_used+pr_spushed];
pr_spushed += OPA->_int;
if (pr_spushed + localstack_used >= LOCALSTACK_SIZE)
{
pr_spushed = 0;
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs pushed too much");
}
break;
case OP_POP:
pr_spushed -= OPA->_int;
if (pr_spushed < 0)
{
pr_spushed = 0;
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs poped more than it pushed");
}
break;
default:
if (st->op & 0x8000) //break point!
@ -960,7 +1022,7 @@ PR_RunError(progfuncs, "Extra opcode not implemented\n");
fakeop.op &= ~0x8000;
st = &fakeop; //a little remapping...
#else
st->op &= ~0x8000;
st->op &= ~0x8000; //just remove the breakpoint and go around again, but this time in the debugger.
#endif
goto reeval; //reexecute

180
engine/qclib/execloop32.h
View File

@ -179,7 +179,7 @@ reeval:
OPC->_float = (float)(!(OPA->function & ~0xff000000));
break;
case OP_NOT_ENT:
OPC->_float = (float)(PROG_TO_EDICT(OPA->edict) == (edictrun_t *)sv_edicts);
OPC->_float = (float)(PROG_TO_EDICT(progfuncs, OPA->edict) == (edictrun_t *)sv_edicts);
break;
case OP_EQ_F:
@ -385,7 +385,7 @@ reeval:
//get a pointer to a field var
case OP_ADDRESS:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -404,7 +404,7 @@ reeval:
case OP_LOAD_ENT:
case OP_LOAD_S:
case OP_LOAD_FNC:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -413,7 +413,7 @@ reeval:
break;
case OP_LOAD_V:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -531,7 +531,7 @@ reeval:
else
{
i -= externs->numglobalbuiltins;
if (i > current_progstate->numbuiltins)
if (i >= current_progstate->numbuiltins)
{
if (newf->first_statement == -0x7fffffff)
((builtin_t)newf->profile) (progfuncs, (struct globalvars_s *)current_progstate->globals);
@ -572,8 +572,8 @@ reeval:
static char buffer[1024*1024*8];
int size = sizeof buffer;
progfuncs->save_ents(progfuncs, buffer, &size, 0);
}*/
}
*/
s = PR_LeaveFunction (progfuncs);
st = &pr_statements[s];
if (pr_depth == prinst->exitdepth)
@ -692,26 +692,11 @@ reeval:
case OP_LOADP_ENT:
case OP_LOADP_S:
case OP_LOADP_FNC:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->_int = ptr->_int;
break;
case OP_LOADP_V:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int + 2 >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->vector[0] = ptr->vector[0];
OPC->vector[1] = ptr->vector[1];
@ -763,7 +748,7 @@ reeval:
break;
case OP_THINKTIME:
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(OPA->edict), OPB->_float);
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, OPA->edict), OPB->_float);
break;
@ -904,43 +889,120 @@ reeval:
case OP_BITAND_IF:
OPC->_int = (OPA->_int & (int)OPB->_float);
break;
case OP_BITOR_IF:
OPC->_int = (OPA->_int | (int)OPB->_float);
break;
case OP_BITAND_FI:
OPC->_int = ((int)OPA->_float & OPB->_int);
break;
case OP_BITOR_FI:
OPC->_int = ((int)OPA->_float | OPB->_int);
break;
case OP_MUL_IF:
OPC->_float = (OPA->_int * OPB->_float);
break;
case OP_MUL_FI:
OPC->_float = (OPA->_float * OPB->_int);
break;
case OP_MUL_IF:
case OP_MUL_FI:
case OP_MUL_VI:
case OP_DIV_IF:
case OP_DIV_FI:
case OP_BITAND_IF:
case OP_BITOR_IF:
case OP_BITAND_FI:
case OP_BITOR_FI:
case OP_AND_I:
case OP_OR_I:
case OP_AND_IF:
case OP_OR_IF:
case OP_AND_FI:
case OP_OR_FI:
case OP_NOT_I:
case OP_NE_IF:
case OP_NE_FI:
case OP_GSTOREP_I:
case OP_GSTOREP_F:
case OP_GSTOREP_ENT:
case OP_GSTOREP_FLD: // integers
case OP_GSTOREP_S:
case OP_GSTOREP_FNC: // pointers
case OP_GSTOREP_V:
case OP_GADDRESS:
case OP_GLOAD_I:
case OP_GLOAD_F:
case OP_GLOAD_FLD:
case OP_GLOAD_ENT:
case OP_GLOAD_S:
case OP_GLOAD_FNC:
case OP_BOUNDCHECK:
PR_RunError(progfuncs, "Extra opcode not implemented\n");
break;
case OP_MUL_VI:
OPC->vector[0] = OPA->vector[0] * OPB->_int;
OPC->vector[1] = OPA->vector[0] * OPB->_int;
OPC->vector[2] = OPA->vector[0] * OPB->_int;
break;
case OP_MUL_IV:
OPC->vector[0] = OPB->_int * OPA->vector[0];
OPC->vector[1] = OPB->_int * OPA->vector[1];
OPC->vector[2] = OPB->_int * OPA->vector[2];
break;
case OP_DIV_IF:
OPC->_float = (OPA->_int / OPB->_float);
break;
case OP_DIV_FI:
OPC->_float = (OPA->_float / OPB->_int);
break;
case OP_AND_I:
OPC->_int = (OPA->_int && OPB->_int);
break;
case OP_OR_I:
OPC->_int = (OPA->_int || OPB->_int);
break;
case OP_AND_IF:
OPC->_int = (OPA->_int && OPB->_float);
break;
case OP_OR_IF:
OPC->_int = (OPA->_int || OPB->_float);
break;
case OP_AND_FI:
OPC->_int = (OPA->_float && OPB->_int);
break;
case OP_OR_FI:
OPC->_int = (OPA->_float || OPB->_int);
break;
case OP_NOT_I:
OPC->_int = !OPA->_int;
break;
case OP_NE_IF:
OPC->_int = (OPA->_int != OPB->_float);
break;
case OP_NE_FI:
OPC->_int = (OPA->_float != OPB->_int);
break;
case OP_GSTOREP_I:
case OP_GSTOREP_F:
case OP_GSTOREP_ENT:
case OP_GSTOREP_FLD: // integers
case OP_GSTOREP_S:
case OP_GSTOREP_FNC: // pointers
case OP_GSTOREP_V:
case OP_GADDRESS:
case OP_GLOAD_I:
case OP_GLOAD_F:
case OP_GLOAD_FLD:
case OP_GLOAD_ENT:
case OP_GLOAD_S:
case OP_GLOAD_FNC:
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Extra opcode not implemented\n");
break;
case OP_BOUNDCHECK:
if ((unsigned int)OPA->_int < (unsigned int)st->c || (unsigned int)OPA->_int >= (unsigned int)st->b)
{
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs boundcheck failed. Value is %i.", OPA->_int);
}
break;
case OP_PUSH:
OPC->_int = (int)&localstack[localstack_used+pr_spushed];
pr_spushed += OPA->_int;
if (pr_spushed + localstack_used >= LOCALSTACK_SIZE)
{
pr_spushed = 0;
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs pushed too much");
}
break;
case OP_POP:
pr_spushed -= OPA->_int;
if (pr_spushed < 0)
{
pr_spushed = 0;
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs poped more than it pushed");
}
break;
default:
if (st->op & 0x8000) //break point!
@ -960,7 +1022,7 @@ PR_RunError(progfuncs, "Extra opcode not implemented\n");
fakeop.op &= ~0x8000;
st = &fakeop; //a little remapping...
#else
st->op &= ~0x8000;
st->op &= ~0x8000; //just remove the breakpoint and go around again, but this time in the debugger.
#endif
goto reeval; //reexecute

180
engine/qclib/execloop32d.h
View File

@ -179,7 +179,7 @@ reeval:
OPC->_float = (float)(!(OPA->function & ~0xff000000));
break;
case OP_NOT_ENT:
OPC->_float = (float)(PROG_TO_EDICT(OPA->edict) == (edictrun_t *)sv_edicts);
OPC->_float = (float)(PROG_TO_EDICT(progfuncs, OPA->edict) == (edictrun_t *)sv_edicts);
break;
case OP_EQ_F:
@ -385,7 +385,7 @@ reeval:
//get a pointer to a field var
case OP_ADDRESS:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -404,7 +404,7 @@ reeval:
case OP_LOAD_ENT:
case OP_LOAD_S:
case OP_LOAD_FNC:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -413,7 +413,7 @@ reeval:
break;
case OP_LOAD_V:
ed = PROG_TO_EDICT(OPA->edict);
ed = PROG_TO_EDICT(progfuncs, OPA->edict);
#ifdef PARANOID
NUM_FOR_EDICT(ed); // make sure it's in range
#endif
@ -531,7 +531,7 @@ reeval:
else
{
i -= externs->numglobalbuiltins;
if (i > current_progstate->numbuiltins)
if (i >= current_progstate->numbuiltins)
{
if (newf->first_statement == -0x7fffffff)
((builtin_t)newf->profile) (progfuncs, (struct globalvars_s *)current_progstate->globals);
@ -572,8 +572,8 @@ reeval:
static char buffer[1024*1024*8];
int size = sizeof buffer;
progfuncs->save_ents(progfuncs, buffer, &size, 0);
}*/
}
*/
s = PR_LeaveFunction (progfuncs);
st = &pr_statements[s];
if (pr_depth == prinst->exitdepth)
@ -692,26 +692,11 @@ reeval:
case OP_LOADP_ENT:
case OP_LOADP_S:
case OP_LOADP_FNC:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->_int = ptr->_int;
break;
case OP_LOADP_V:
#ifdef PRBOUNDSCHECK
if (OPB->_int < 0 || OPB->_int + 2 >= pr_edict_size/4)
{
Host_Error("Progs attempted to read an invalid field in an edict (%i)\n", OPB->_int);
return;
}
#endif
ptr = (eval_t *)(((int)(OPA->_int)) + OPB->_int);
OPC->vector[0] = ptr->vector[0];
OPC->vector[1] = ptr->vector[1];
@ -763,7 +748,7 @@ reeval:
break;
case OP_THINKTIME:
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(OPA->edict), OPB->_float);
externs->thinktimeop(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, OPA->edict), OPB->_float);
break;
@ -904,43 +889,120 @@ reeval:
case OP_BITAND_IF:
OPC->_int = (OPA->_int & (int)OPB->_float);
break;
case OP_BITOR_IF:
OPC->_int = (OPA->_int | (int)OPB->_float);
break;
case OP_BITAND_FI:
OPC->_int = ((int)OPA->_float & OPB->_int);
break;
case OP_BITOR_FI:
OPC->_int = ((int)OPA->_float | OPB->_int);
break;
case OP_MUL_IF:
OPC->_float = (OPA->_int * OPB->_float);
break;
case OP_MUL_FI:
OPC->_float = (OPA->_float * OPB->_int);
break;
case OP_MUL_IF:
case OP_MUL_FI:
case OP_MUL_VI:
case OP_DIV_IF:
case OP_DIV_FI:
case OP_BITAND_IF:
case OP_BITOR_IF:
case OP_BITAND_FI:
case OP_BITOR_FI:
case OP_AND_I:
case OP_OR_I:
case OP_AND_IF:
case OP_OR_IF:
case OP_AND_FI:
case OP_OR_FI:
case OP_NOT_I:
case OP_NE_IF:
case OP_NE_FI:
case OP_GSTOREP_I:
case OP_GSTOREP_F:
case OP_GSTOREP_ENT:
case OP_GSTOREP_FLD: // integers
case OP_GSTOREP_S:
case OP_GSTOREP_FNC: // pointers
case OP_GSTOREP_V:
case OP_GADDRESS:
case OP_GLOAD_I:
case OP_GLOAD_F:
case OP_GLOAD_FLD:
case OP_GLOAD_ENT:
case OP_GLOAD_S:
case OP_GLOAD_FNC:
case OP_BOUNDCHECK:
PR_RunError(progfuncs, "Extra opcode not implemented\n");
break;
case OP_MUL_VI:
OPC->vector[0] = OPA->vector[0] * OPB->_int;
OPC->vector[1] = OPA->vector[0] * OPB->_int;
OPC->vector[2] = OPA->vector[0] * OPB->_int;
break;
case OP_MUL_IV:
OPC->vector[0] = OPB->_int * OPA->vector[0];
OPC->vector[1] = OPB->_int * OPA->vector[1];
OPC->vector[2] = OPB->_int * OPA->vector[2];
break;
case OP_DIV_IF:
OPC->_float = (OPA->_int / OPB->_float);
break;
case OP_DIV_FI:
OPC->_float = (OPA->_float / OPB->_int);
break;
case OP_AND_I:
OPC->_int = (OPA->_int && OPB->_int);
break;
case OP_OR_I:
OPC->_int = (OPA->_int || OPB->_int);
break;
case OP_AND_IF:
OPC->_int = (OPA->_int && OPB->_float);
break;
case OP_OR_IF:
OPC->_int = (OPA->_int || OPB->_float);
break;
case OP_AND_FI:
OPC->_int = (OPA->_float && OPB->_int);
break;
case OP_OR_FI:
OPC->_int = (OPA->_float || OPB->_int);
break;
case OP_NOT_I:
OPC->_int = !OPA->_int;
break;
case OP_NE_IF:
OPC->_int = (OPA->_int != OPB->_float);
break;
case OP_NE_FI:
OPC->_int = (OPA->_float != OPB->_int);
break;
case OP_GSTOREP_I:
case OP_GSTOREP_F:
case OP_GSTOREP_ENT:
case OP_GSTOREP_FLD: // integers
case OP_GSTOREP_S:
case OP_GSTOREP_FNC: // pointers
case OP_GSTOREP_V:
case OP_GADDRESS:
case OP_GLOAD_I:
case OP_GLOAD_F:
case OP_GLOAD_FLD:
case OP_GLOAD_ENT:
case OP_GLOAD_S:
case OP_GLOAD_FNC:
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Extra opcode not implemented\n");
break;
case OP_BOUNDCHECK:
if ((unsigned int)OPA->_int < (unsigned int)st->c || (unsigned int)OPA->_int >= (unsigned int)st->b)
{
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs boundcheck failed. Value is %i.", OPA->_int);
}
break;
case OP_PUSH:
OPC->_int = (int)&localstack[localstack_used+pr_spushed];
pr_spushed += OPA->_int;
if (pr_spushed + localstack_used >= LOCALSTACK_SIZE)
{
pr_spushed = 0;
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs pushed too much");
}
break;
case OP_POP:
pr_spushed -= OPA->_int;
if (pr_spushed < 0)
{
pr_spushed = 0;
pr_xstatement = st-pr_statements;
PR_RunError(progfuncs, "Progs poped more than it pushed");
}
break;
default:
if (st->op & 0x8000) //break point!
@ -960,7 +1022,7 @@ PR_RunError(progfuncs, "Extra opcode not implemented\n");
fakeop.op &= ~0x8000;
st = &fakeop; //a little remapping...
#else
st->op &= ~0x8000;
st->op &= ~0x8000; //just remove the breakpoint and go around again, but this time in the debugger.
#endif
goto reeval; //reexecute

6
engine/qclib/hash.c
View File

@ -2,6 +2,12 @@
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#ifndef stricmp
#define stricmp strcasecmp
#endif
#endif
void Hash_InitTable(hashtable_t *table, int numbucks, void *mem)
{
table->numbuckets = numbucks;

153
engine/qclib/initlib.c
View File

@ -8,54 +8,75 @@ typedef struct prmemb_s {
} prmemb_t;
void *PRHunkAlloc(progfuncs_t *progfuncs, int ammount)
{
if (!progshunk)
{
prmemb_t *mem;
ammount = sizeof(prmemb_t)+((ammount + 3)&~3);
mem = memalloc(ammount);
memset(mem, 0, ammount);
mem->prev = memb;
if (!memb)
mem->level = 1;
else
mem->level = ((prmemb_t *)memb)->level+1;
memb = mem;
prmemb_t *mem;
ammount = sizeof(prmemb_t)+((ammount + 3)&~3);
mem = memalloc(ammount);
memset(mem, 0, ammount);
mem->prev = memb;
if (!memb)
mem->level = 1;
else
mem->level = ((prmemb_t *)memb)->level+1;
memb = mem;
return ((char *)mem)+sizeof(prmemb_t);
}
hunkused+=ammount;
if (hunkused > hunksize)
Sys_Error("QCLIB: Out of hunk");
memset(progshunk + hunkused-ammount, 0, ammount);
return progshunk + hunkused-ammount;
return ((char *)mem)+sizeof(prmemb_t);
}
int PRHunkMark(progfuncs_t *progfuncs)
{
if (!progshunk)
{
return ((prmemb_t *)memb)->level;
}
return hunkused;
return ((prmemb_t *)memb)->level;
}
void PRHunkFree(progfuncs_t *progfuncs, int mark)
{
if (!progshunk)
prmemb_t *omem;
while(memb)
{
prmemb_t *omem;
while(memb)
{
if (memb->level <= mark)
return;
if (memb->level <= mark)
return;
omem = memb;
memb = memb->prev;
memfree(omem);
}
return;
omem = memb;
memb = memb->prev;
memfree(omem);
}
hunkused = mark;
return;
}
//for 64bit systems. :)
//addressable memory is memory available to the vm itself for writing.
//once allocated, it cannot be freed for the lifetime of the VM.
void *PRAddressableAlloc(progfuncs_t *progfuncs, int ammount)
{
ammount = (ammount + 4)&~3; //round up to 4
if (addressableused + ammount > addressablesize)
Sys_Error("Not enough addressable memory for progs VM");
addressableused += ammount;
#ifdef _WIN32
if (!VirtualAlloc (addressablehunk, addressableused, MEM_COMMIT, PAGE_READWRITE))
Sys_Error("VirtualAlloc failed. Blame windows.");
#endif
return &addressablehunk[addressableused-ammount];
}
void PRAddressableFlush(progfuncs_t *progfuncs, int totalammount)
{
addressableused = 0;
if (totalammount < 0) //flush
{
totalammount = addressablesize;
// return;
}
if (addressablehunk)
#ifdef _WIN32
VirtualFree(addressablehunk, 0, MEM_RELEASE); //doesn't this look complicated? :p
addressablehunk = VirtualAlloc (NULL, totalammount, MEM_RESERVE, PAGE_NOACCESS);
#else
free(addressablehunk);
addressablehunk = malloc(totalammount); //linux will allocate-on-use anyway, which is handy.
#endif
addressablesize = totalammount;
}
int PR_InitEnts(progfuncs_t *progfuncs, int max_ents)
@ -64,26 +85,25 @@ int PR_InitEnts(progfuncs_t *progfuncs, int max_ents)
sv_num_edicts = 0;
pr_edict_size += externs->edictsize;
pr_max_edict_size = pr_edict_size;
max_fields_size = fields_size;
prinst->edicttable = PRHunkAlloc(progfuncs, maxedicts*sizeof(struct edicts_s *));
sv_edicts = PRHunkAlloc(progfuncs, pr_edict_size);
sv_edicts = PRHunkAlloc(progfuncs, externs->edictsize);
prinst->edicttable[0] = sv_edicts;
((edictrun_t*)prinst->edicttable[0])->fields = PRAddressableAlloc(progfuncs, max_fields_size);
sv_num_edicts = 1;
return pr_edict_size;
return max_fields_size;
}
char tempedicts[2048]; //used as a safty buffer
void PR_Configure (progfuncs_t *progfuncs, void *mem, int mem_size, int max_progs) //can be used to wipe all memory
void PR_Configure (progfuncs_t *progfuncs, int addressable_size, int max_progs) //can be used to wipe all memory
{
int i;
edictrun_t *e;
// int a;
pr_max_edict_size=0;
pr_edict_size = 0;
max_fields_size=0;
fields_size = 0;
progfuncs->stringtable = 0;
QC_StartShares(progfuncs);
QC_InitShares(progfuncs);
@ -98,25 +118,9 @@ void PR_Configure (progfuncs_t *progfuncs, void *mem, int mem_size, int max_prog
}
PRHunkFree(progfuncs, 0); //clear mem - our hunk may not be a real hunk.
//three conditions.
//mem + size uses new hunk space
//size>=0 uses previous hunk space
//size < 0 uses memalloc for mem, then emulates a hunk.
if (mem == NULL)
{
if (mem_size < 0)
{
progshunk = NULL;
hunksize = 0;
}
}
else
{
progshunk = mem;
hunksize = mem_size;
}
hunkused = 0;
if (addressable_size<0)
addressable_size = 8*1024*1024;
PRAddressableFlush(progfuncs, addressable_size);
pr_progstate = PRHunkAlloc(progfuncs, sizeof(progstate_t) * max_progs);
@ -134,6 +138,7 @@ void PR_Configure (progfuncs_t *progfuncs, void *mem, int mem_size, int max_prog
maxedicts = 1;
sv_num_edicts = 1; //set up a safty buffer so things won't go horribly wrong too often
sv_edicts=(struct edict_s *)tempedicts;
((edictrun_t*)sv_edicts)->readonly = true;
}
@ -221,7 +226,7 @@ eval_t *PR_FindGlobal(progfuncs_t *progfuncs, char *globname, progsnum_t pnum)
void SetGlobalEdict(progfuncs_t *progfuncs, struct edict_s *ed, int ofs)
{
((int*)pr_globals)[ofs] = EDICT_TO_PROG(ed);
((int*)pr_globals)[ofs] = EDICT_TO_PROG(progfuncs, ed);
}
char *PR_VarString (progfuncs_t *progfuncs, int first)
@ -255,9 +260,7 @@ eval_t *GetEdictFieldValue(progfuncs_t *progfuncs, struct edict_s *ed, char *nam
var = ED_FindField(progfuncs, name);
if (!var)
return NULL;
return (eval_t *)&(
((int*)((char *)ed + externs->edictsize))
[var->ofs]);
return (eval_t *) &(((int*)(((edictrun_t*)ed)->fields))[var->ofs]);
}
if (!cache->varname)
{
@ -269,24 +272,20 @@ eval_t *GetEdictFieldValue(progfuncs_t *progfuncs, struct edict_s *ed, char *nam
return NULL;
}
cache->ofs32 = var;
return (eval_t *)
&((int*)((char *)ed + externs->edictsize))
[var->ofs];
return (eval_t *) &(((int*)(((edictrun_t*)ed)->fields))[var->ofs]);
}
if (cache->ofs32 == NULL)
return NULL;
return (eval_t *)
&((int*)((char *)ed + externs->edictsize))
[cache->ofs32->ofs];
return (eval_t *) &(((int*)(((edictrun_t*)ed)->fields))[cache->ofs32->ofs]);
}
struct edict_s *ProgsToEdict (progfuncs_t *progfuncs, int progs)
{
return (struct edict_s *)PROG_TO_EDICT(progs);
return (struct edict_s *)PROG_TO_EDICT(progfuncs, progs);
}
int EdictToProgs (progfuncs_t *progfuncs, struct edict_s *ed)
{
return EDICT_TO_PROG(ed);
return EDICT_TO_PROG(progfuncs, ed);
}
@ -505,7 +504,7 @@ progfuncs_t * InitProgs(progexterns_t *ext)
#undef memalloc
#undef pr_trace
funcs = ext->memalloc(sizeof(progfuncs_t));
memcpy(funcs, &deffuncs, sizeof(progfuncs_t));
memcpy(funcs, &deffuncs, sizeof(progfuncs_t));
funcs->prinst = ext->memalloc(sizeof(prinst_t));
memset(funcs->prinst,0, sizeof(prinst_t));

183
engine/qclib/pr_edict.c
View File

@ -55,7 +55,7 @@ Sets everything to NULL
void ED_ClearEdict (progfuncs_t *progfuncs, edictrun_t *e)
{
int num = e->entnum;
memset (edvars(e), 0, pr_edict_size-externs->edictsize);
memset (e->fields, 0, fields_size);
e->isfree = false;
e->entnum = num;
}
@ -85,7 +85,8 @@ struct edict_s *ED_Alloc (progfuncs_t *progfuncs)
{
if (!e)
{
prinst->edicttable[i] = *(struct edict_s **)&e = (void*)memalloc(pr_edict_size);
prinst->edicttable[i] = *(struct edict_s **)&e = (void*)memalloc(externs->edictsize);
e->fields = PRAddressableAlloc(progfuncs, fields_size);
e->entnum = i;
}
@ -108,7 +109,8 @@ struct edict_s *ED_Alloc (progfuncs_t *progfuncs)
{
if (!e)
{
prinst->edicttable[i] = *(struct edict_s **)&e = (void*)memalloc(pr_edict_size);
prinst->edicttable[i] = *(struct edict_s **)&e = (void*)memalloc(externs->edictsize);
e->fields = PRAddressableAlloc(progfuncs, fields_size);
e->entnum = i;
}
@ -135,7 +137,8 @@ struct edict_s *ED_Alloc (progfuncs_t *progfuncs)
if (!e)
{
prinst->edicttable[i] = *(struct edict_s **)&e = (void*)memalloc(pr_edict_size);
prinst->edicttable[i] = *(struct edict_s **)&e = (void*)memalloc(externs->edictsize);
e->fields = PRAddressableAlloc(progfuncs, fields_size);
e->entnum = i;
}
@ -485,7 +488,7 @@ char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
sprintf (line, "%s", val->string+progfuncs->stringtable);
break;
case ev_entity:
sprintf (line, "entity %i", NUM_FOR_EDICT(progfuncs, (struct edict_s *)PROG_TO_EDICT(val->edict)) );
sprintf (line, "entity %i", NUM_FOR_EDICT(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, val->edict)) );
break;
case ev_function:
if (!val->function)
@ -520,20 +523,22 @@ char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
case ev_pointer:
sprintf (line, "pointer");
{
int entnum;
int valofs;
if (val->edict == 0)
// int entnum;
// int valofs;
if (val->_int == 0)
{
sprintf (line, "NULL pointer");
break;
}
entnum = ((qbyte *)val->edict - (qbyte *)sv_edicts) / pr_edict_size;
valofs = (int *)val->edict - (int *)edvars(EDICT_NUM(progfuncs, entnum));
fielddef = ED_FieldAtOfs (progfuncs, valofs );
if (!fielddef)
sprintf(line, "ent%i.%s", entnum, "UNKNOWN");
else
sprintf(line, "ent%i.%s", entnum, fielddef->s_name);
//FIXME: :/
sprintf(line, "UNKNOWN");
// entnum = ((qbyte *)val->edict - (qbyte *)sv_edicts) / pr_edict_size;
// valofs = (int *)val->edict - (int *)edvars(EDICT_NUM(progfuncs, entnum));
// fielddef = ED_FieldAtOfs (progfuncs, valofs );
// if (!fielddef)
// sprintf(line, "ent%i.%s", entnum, "UNKNOWN");
// else
// sprintf(line, "ent%i.%s", entnum, fielddef->s_name);
}
break;
default:
@ -578,7 +583,7 @@ char *PR_UglyValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
sprintf (line, "%s", val->string+progfuncs->stringtable);
break;
case ev_entity:
sprintf (line, "%i", NUM_FOR_EDICT(progfuncs, (struct edict_s *)PROG_TO_EDICT(val->edict)));
sprintf (line, "%i", NUM_FOR_EDICT(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, val->edict)));
break;
case ev_function:
i = (val->function & 0xff000000)>>24;
@ -646,7 +651,7 @@ char *PR_UglyOldValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val)
sprintf (line, "%s", val->string+progfuncs->stringtable);
break;
case ev_entity:
sprintf (line, "%i", NUM_FOR_EDICT(progfuncs, (struct edict_s *)PROG_TO_EDICT(val->edict)));
sprintf (line, "%i", NUM_FOR_EDICT(progfuncs, (struct edict_s *)PROG_TO_EDICT(progfuncs, val->edict)));
break;
case ev_function:
f = pr_progstate[(val->function & 0xff000000)>>24].functions + (val->function & ~0xff000000);
@ -1033,7 +1038,7 @@ pbool ED_ParseEpair (progfuncs_t *progfuncs, void *base, ddefXX_t *key, char *s,
break;
case ev_entity:
*(int *)d = EDICT_TO_PROG(EDICT_NUM(progfuncs, atoi (s)));
*(int *)d = EDICT_TO_PROG(progfuncs, EDICT_NUM(progfuncs, atoi (s)));
break;
case ev_field:
@ -1146,7 +1151,7 @@ char *ED_ParseEdict (progfuncs_t *progfuncs, char *data, edictrun_t *ent)
}
cont:
if (!ED_ParseEpair (progfuncs, (void *)(((char *)ent)+externs->edictsize), (ddefXX_t*)key, qcc_token, 32))
if (!ED_ParseEpair (progfuncs, ent->fields, (ddefXX_t*)key, qcc_token, 32))
Sys_Error ("ED_ParseEdict: parse error on entities");
}
@ -1331,7 +1336,7 @@ char *ED_WriteEdict(progfuncs_t *progfuncs, edictrun_t *ed, char *buffer, pbool
if (name[len-2] == '_' && (name[len-1] == 'x' || name[len-1] == 'y' || name[len-1] == 'z'))
continue; // skip _x, _y, _z vars
v = (int *)(((char *)ed + externs->edictsize) + d->ofs*4);
v = (int *)((char*)ed->fields + d->ofs*4);
// if the value is still all 0, skip the field
#ifdef DEF_SAVEGLOBAL
@ -1417,7 +1422,7 @@ char *SaveCallStack (progfuncs_t *progfuncs, char *s)
sprintf(buffer, "\t\t\"%s\"\t\"entity INVALID POINTER\"\n", local->s_name);
for (n = 0; n < sv_num_edicts; n++)
{
if (prinst->edicttable[n] == (struct edict_s *)PROG_TO_EDICT(((eval_t*)(globalbase - f->locals+arg))->edict))
if (prinst->edicttable[n] == (struct edict_s *)PROG_TO_EDICT(progfuncs, ((eval_t*)(globalbase - f->locals+arg))->edict))
{
sprintf(buffer, "\t\t\"%s\" \"entity %i\"\n", local->s_name, n);
break;
@ -1646,7 +1651,8 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
if (!ed)
{
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(pr_edict_size);
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(externs->edictsize);
ed->fields = PRAddressableAlloc(progfuncs, fields_size);
ed->entnum = num;
ed->isfree = true;
}
@ -1667,7 +1673,8 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
if (!ed)
{
Sys_Error("Edict was not allocated\n");
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(pr_edict_size);
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(externs->edictsize);
ed->fields = PRAddressableAlloc(progfuncs, fields_size);
ed->entnum = num;
}
}
@ -1696,7 +1703,7 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
if (f)
{
var = (eval_t *)((int *)pr_globals + ED_FindGlobalOfs(progfuncs, "self"));
var->edict = EDICT_TO_PROG(ed);
var->edict = EDICT_TO_PROG(progfuncs, ed);
PR_ExecuteProgram(progfuncs, f-pr_functions);
}
}
@ -1759,7 +1766,8 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
if (!ed)
{
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(pr_edict_size);
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(externs->edictsize);
ed->fields = PRAddressableAlloc(progfuncs, fields_size);
ed->entnum = num;
ed->isfree = true;
}
@ -1823,7 +1831,7 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
QC_StartShares(progfuncs);
// QC_InitShares(); //forget stuff
// pr_edict_size = 0;
pr_max_edict_size=0;
max_fields_size=0;
file = QCC_COM_Parse(file);
if (qcc_token[0] != '{')
@ -1851,7 +1859,7 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
Sys_Error("Bad key \"%s\" in general block", qcc_token);
}
hunkused = 0;
PRAddressableFlush(progfuncs, -1);
resethunk=true;
pr_progstate = PRHunkAlloc(progfuncs, sizeof(progstate_t) * maxprogs);
@ -1859,6 +1867,7 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
sv_num_edicts = 1; //set up a safty buffer so things won't go horribly wrong too often
sv_edicts=(struct edict_s *)tempedicts;
((edictrun_t*)sv_edicts)->readonly = true;
sv_num_edicts = numents; //should be fine
@ -1915,7 +1924,8 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
ed = (edictrun_t *)EDICT_NUM(progfuncs, numents);
if (!ed)
{
prinst->edicttable[numents] = *(struct edict_s **)&ed = (void*)memalloc(pr_edict_size);
prinst->edicttable[numents] = *(struct edict_s **)&ed = (void*)memalloc(externs->edictsize);
ed->fields = PRAddressableAlloc(progfuncs, fields_size);
ed->entnum = numents;
ed->isfree = true;
}
@ -1939,7 +1949,8 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
if (!ed)
{
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(pr_edict_size);
prinst->edicttable[num] = *(struct edict_s **)&ed = (void*)memalloc(externs->edictsize);
ed->fields = PRAddressableAlloc(progfuncs, fields_size);
ed->entnum = num;
ed->isfree = true;
}
@ -1998,7 +2009,7 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
}
selfvar = (eval_t *)((int *)pr_globals + ED_FindGlobalOfs(progfuncs, "self"));
selfvar->edict = EDICT_TO_PROG(ed);
selfvar->edict = EDICT_TO_PROG(progfuncs, ed);
f = PR_FindFunc(progfuncs, var->string+progfuncs->stringtable, -2);
if (f)
@ -2043,7 +2054,7 @@ int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags)
return entsize;
}
else
return pr_edict_size;
return max_fields_size;
}
#define AddS(str) strcpy(s, str);s+=strlen(str);
@ -2397,7 +2408,7 @@ retry:
if (pr_progs->blockscompressed & 16) //string table
{
len=sizeof(char)*pr_progs->numstrings;
s = PRHunkAlloc(progfuncs, len);
s = PRAddressableAlloc(progfuncs, len);
QC_decode(progfuncs, LittleLong(*(int *)pr_strings), len, 2, (char *)(((int *)pr_strings)+1), s);
pr_strings = (char *)s;
@ -2405,12 +2416,12 @@ retry:
if (pr_progs->blockscompressed & 32) //globals
{
len=sizeof(float)*pr_progs->numglobals;
s = PRHunkAlloc(progfuncs, len);
s = PRAddressableAlloc(progfuncs, len);
QC_decode(progfuncs, LittleLong(*(int *)pr_globals), len, 2, (char *)(((int *)pr_globals)+1), s);
glob = current_progstate->globals = (float *)s;
}
if (pr_progs->ofslinenums && pr_progs->blockscompressed & 64) //line numbers
if (pr_linenums && pr_progs->blockscompressed & 64) //line numbers
{
len=sizeof(int)*pr_progs->numstatements;
s = PRHunkAlloc(progfuncs, len);
@ -2520,23 +2531,20 @@ retry:
((int *)glob)[i] = LittleLong (((int *)glob)[i]);
#endif
if (pr_progs->version == PROG_EXTENDEDVERSION)
{
if (pr_types)
{
for (i=0 ; i<pr_progs->numtypes ; i++)
{
if (pr_types)
{
for (i=0 ; i<pr_progs->numtypes ; i++)
{
#ifndef NOENDIAN
pr_types[i].type = LittleLong(current_progstate->types[i].type);
pr_types[i].next = LittleLong(current_progstate->types[i].next);
pr_types[i].aux_type = LittleLong(current_progstate->types[i].aux_type);
pr_types[i].num_parms = LittleLong(current_progstate->types[i].num_parms);
pr_types[i].ofs = LittleLong(current_progstate->types[i].ofs);
pr_types[i].size = LittleLong(current_progstate->types[i].size);
pr_types[i].name = (string_t)LittleLong((long)current_progstate->types[i].name);
pr_types[i].type = LittleLong(current_progstate->types[i].type);
pr_types[i].next = LittleLong(current_progstate->types[i].next);
pr_types[i].aux_type = LittleLong(current_progstate->types[i].aux_type);
pr_types[i].num_parms = LittleLong(current_progstate->types[i].num_parms);
pr_types[i].ofs = LittleLong(current_progstate->types[i].ofs);
pr_types[i].size = LittleLong(current_progstate->types[i].size);
pr_types[i].name = (string_t)LittleLong((long)current_progstate->types[i].name);
#endif
pr_types[i].name += (int)pr_strings;
}
pr_types[i].name += (int)pr_strings;
}
}
@ -2547,6 +2555,7 @@ retry:
{
case 24:
case 16:
//byteswap the globals and fix name offsets
for (i=0 ; i<pr_progs->numglobaldefs ; i++)
{
#ifndef NOENDIAN
@ -2557,6 +2566,7 @@ retry:
gd16[i].s_name += (int)pr_strings;
}
//byteswap fields and fix name offets. Also register the fields (which will result in some offset adjustments in the globals segment).
for (i=0 ; i<pr_progs->numfielddefs ; i++)
{
#ifndef NOENDIAN
@ -2617,11 +2627,8 @@ retry:
Sys_Error("Bad int size");
}
//this is a little over complicated and slow.
//we need to search through the statements, looking for if statements.
//if the if statement works on a string, we need to adjust the opcode a little.
//This way, if (string) works properly, rather than always being true.
//if only compilers expanded to if (string!=string_null)
//ifstring fixes arn't performed anymore.
//the following switch just fixes endian and hexen2 calling conventions (by using different opcodes).
switch(current_progstate->intsize)
{
case 16:
@ -2633,30 +2640,6 @@ retry:
st16[i].b = LittleShort(st16[i].b);
st16[i].c = LittleShort(st16[i].c);
#endif
/*
if (st16[i].op == OP_IF || st16[i].op == OP_IFNOT) //strings are dodgy. if("") can evaluate to true
{
ddef16_t *gd;
gd = ED_GlobalAtOfs16(progfuncs, st16[i].a);
if (!gd)
continue;
if (pr_types)
type = pr_types[gd->type & ~(DEF_SHARED|DEF_SAVEGLOBAL)].type;
else
type = gd->type & ~(DEF_SHARED|DEF_SAVEGLOBAL);
if (type == ev_string)
{ //fix it.
// printf("Fixing if\n");
if (st16[i].op == OP_IF)
st16[i].op = OP_IFS;
else if (st16[i].op == OP_IFNOT)
st16[i].op = OP_IFNOTS;
}
}
else
*/
if (st16[i].op >= OP_CALL1 && st16[i].op <= OP_CALL8)
{
if (st16[i].b)
@ -2666,7 +2649,6 @@ retry:
}
if (hexencalling)
{
printf("Detected Hexen2 calling convention\n");
for (i=0 ; i<pr_progs->numstatements ; i++)
{
if (st16[i].op >= OP_CALL1 && st16[i].op <= OP_CALL8)
@ -2684,28 +2666,7 @@ retry:
pr_statements32[i].b = LittleLong(pr_statements32[i].b);
pr_statements32[i].c = LittleLong(pr_statements32[i].c);
#endif
/*
if (pr_statements32[i].op == OP_IF || pr_statements32[i].op == OP_IFNOT) //strings are dodgy. if("") can evaluate to true
{
ddef16_t *gd;
gd = ED_GlobalAtOfs16(progfuncs, pr_statements32[i].a);
if (!gd)
continue;
if (pr_types)
type = pr_types[gd->type & ~(DEF_SHARED|DEF_SAVEGLOBAL)].type;
else
type = gd->type & ~(DEF_SHARED|DEF_SAVEGLOBAL);
if (type == ev_string)
{ //fix it.
// printf("Fixing if\n");
pr_statements32[i].op = pr_statements32[i].op - OP_IF + OP_IFS;
}
}
else
*/
if (pr_statements32[i].op >= OP_CALL1 && pr_statements32[i].op <= OP_CALL8)
if (pr_statements32[i].op >= OP_CALL1 && pr_statements32[i].op <= OP_CALL8)
{
if (pr_statements32[i].b)
hexencalling = true;
@ -2722,17 +2683,29 @@ retry:
}
break;
case 32:
#ifndef NOENDIAN
for (i=0 ; i<pr_progs->numstatements ; i++)
{
#ifndef NOENDIAN
pr_statements32[i].op = LittleLong(pr_statements32[i].op);
pr_statements32[i].a = LittleLong(pr_statements32[i].a);
pr_statements32[i].b = LittleLong(pr_statements32[i].b);
pr_statements32[i].c = LittleLong(pr_statements32[i].c);
//don't bother fixing if(string). The FTE compiler fixes it with if(string != string_null)
}
#endif
if (pr_statements32[i].op >= OP_CALL1 && pr_statements32[i].op <= OP_CALL8)
{
if (pr_statements32[i].b)
hexencalling = true;
}
}
if (hexencalling)
{
for (i=0 ; i<pr_progs->numstatements ; i++)
{
if (pr_statements32[i].op >= OP_CALL1 && pr_statements32[i].op <= OP_CALL8)
pr_statements32[i].op += OP_CALL1H - OP_CALL1;
}
}
break;
}

4
engine/qclib/pr_exec.c
View File

@ -436,7 +436,7 @@ char *EvaluateDebugString(progfuncs_t *progfuncs, char *key)
if (c)*c = '.';
if (!fdef)
return "(Bad string)";
val = (eval_t *) (((char *)PROG_TO_EDICT(val->_int) + externs->edictsize) + fdef->ofs*4);
val = (eval_t *) (((char *)PROG_TO_EDICT(progfuncs, val->_int) + externs->edictsize) + fdef->ofs*4);
def->type = fdef->type;
}
@ -472,7 +472,7 @@ char *EvaluateDebugString(progfuncs_t *progfuncs, char *key)
break;
*/
case ev_entity:
*(int *)val = EDICT_TO_PROG(EDICT_NUM(progfuncs, atoi (assignment)));
*(int *)val = EDICT_TO_PROG(progfuncs, EDICT_NUM(progfuncs, atoi (assignment)));
break;
case ev_field:

14
engine/qclib/pr_multi.c
View File

@ -196,9 +196,9 @@ int QC_RegisterFieldVar(progfuncs_t *progfuncs, unsigned int type, char *name, i
int fnum;
if (!name)
{
progfuncs->fieldadjust = pr_edict_size/4;
if (!name) //engine can use this to offset all progs fields
{ //which fixes constant field offsets (some ktpro arrays)
progfuncs->fieldadjust = fields_size/4;
return 0;
}
@ -277,12 +277,12 @@ int QC_RegisterFieldVar(progfuncs_t *progfuncs, unsigned int type, char *name, i
field[fnum].ofs = ofs = requestedpos/4;
}
else
field[fnum].ofs = ofs = pr_edict_size/4;
field[fnum].ofs = ofs = fields_size/4;
// if (type != ev_vector)
if (pr_edict_size < (ofs+type_size[type])*4)
pr_edict_size = (ofs+type_size[type])*4;
if (fields_size < (ofs+type_size[type])*4)
fields_size = (ofs+type_size[type])*4;
if (pr_max_edict_size && pr_edict_size > pr_max_edict_size)
if (max_fields_size && fields_size > max_fields_size)
Sys_Error("Allocated too many additional fields after ents were inited.");
field[fnum].type = type;

30
engine/qclib/progsint.h
View File

@ -83,6 +83,7 @@ extern QCC_opcode_t pr_opcodes[]; // sized by initialization
int PRHunkMark(progfuncs_t *progfuncs);
void PRHunkFree(progfuncs_t *progfuncs, int mark);
void *PRHunkAlloc(progfuncs_t *progfuncs, int size);
void *PRAddressableAlloc(progfuncs_t *progfuncs, int ammount);
//void *HunkAlloc (int size);
char *VARGS qcva (char *text, ...);
@ -96,7 +97,7 @@ int PR_ToggleBreakpoint(progfuncs_t *progfuncs, char *filename, int linenum, int
void StripExtension (char *path);
#define edvars(ed) (((char *)ed)+externs->edictsize) //pointer to the field vars, given an edict
#define edvars(ed) (((edictrun_t*)ed)->fields) //pointer to the field vars, given an edict
@ -133,6 +134,7 @@ typedef struct edictrun_s
float freetime; // realtime when the object was freed
int entnum;
pbool readonly; //causes error when QC tries writing to it. (quake's world entity)
void *fields;
// other fields from progs come immediately after
} edictrun_t;
@ -246,8 +248,8 @@ int NUM_FOR_EDICT(progfuncs_t *progfuncs, struct edict_s *e);
//#define NEXT_EDICT(e) ((edictrun_t *)( (byte *)e + pr_edict_size))
#define EDICT_TO_PROG(e) ((qbyte *)e - (qbyte *)sv_edicts)
#define PROG_TO_EDICT(e) ((edictrun_t *)((qbyte *)sv_edicts + e))
#define EDICT_TO_PROG(pf, e) (((edictrun_t*)e)->entnum)
#define PROG_TO_EDICT(pf, e) ((struct edictrun_s *)prinst->edicttable[e])
//============================================================================
@ -396,19 +398,19 @@ var(evalc_t, spawnflagscache);
var(int, pr_edict_size); // in bytes
#define pr_edict_size prinst->pr_edict_size
var(int, pr_max_edict_size);
#define pr_max_edict_size prinst->pr_max_edict_size
var(int, fields_size); // in bytes
#define fields_size prinst->fields_size
var(int, max_fields_size);
#define max_fields_size prinst->max_fields_size
//initlib.c
var(char *, progshunk);
#define progshunk prinst->progshunk
var(int, hunkused);
#define hunkused prinst->hunkused
var(int, hunksize);
#define hunksize prinst->hunksize
var(char *, addressablehunk);
#define addressablehunk prinst->addressablehunk
var(int, addressableused);
#define addressableused prinst->addressableused
var(int, addressablesize);
#define addressablesize prinst->addressablesize
var(extensionbuiltin_t *, extensionbuiltin);
@ -426,7 +428,7 @@ ddef32_t *ED_FindGlobalFromProgs32 (progfuncs_t *progfuncs, char *name, progsnum
fdef_t *ED_FindField (progfuncs_t *progfuncs, char *name);
dfunction_t *ED_FindFunction (progfuncs_t *progfuncs, char *name, int *pnum, int fromprogs);
func_t PR_FindFunc(progfuncs_t *progfncs, char *funcname, progsnum_t pnum);
void PR_Configure (progfuncs_t *progfncs, void *mem, int mem_size, int max_progs);
void PR_Configure (progfuncs_t *progfncs, int addressable_size, int max_progs);
int PR_InitEnts(progfuncs_t *progfncs, int maxents);
char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val);

9
engine/qclib/progslib.h
View File

@ -47,7 +47,7 @@ struct progfuncs_s {
int progsversion; //PROGSTRUCT_VERSION
void (*Configure) (progfuncs_t *prinst, void *mem, int memsize, int max_progs); //configure buffers and memory. Used to reset and must be called first.
void (*Configure) (progfuncs_t *prinst, int addressablesize, int max_progs); //configure buffers and memory. Used to reset and must be called first. Flushes a running VM.
progsnum_t (*LoadProgs) (progfuncs_t *prinst, char *s, int headercrc, builtin_t *builtins, int numbuiltins); //load a progs
int (*InitEnts) (progfuncs_t *prinst, int max_ents); //returns size of edicts for use with nextedict macro
void (*ExecuteProgram) (progfuncs_t *prinst, func_t fnum); //start execution
@ -69,9 +69,6 @@ struct progfuncs_s {
char *(*VarString) (progfuncs_t *prinst, int first); //returns a string made up of multiple arguments
struct progstate_s **progstate; //these are so the macros work properly
// struct edict_s **sv_edicts;
// int *sv_num_edicts;
func_t (*FindFunction) (progfuncs_t *prinst, char *funcname, progsnum_t num);
@ -194,11 +191,11 @@ typedef union eval_s
#define PR_CURRENT -1
#define PR_ANY -2 //not always valid. Use for finding funcs
#define PROGSTRUCT_VERSION 1
#define PROGSTRUCT_VERSION 2
#ifndef DLL_PROG
#define PR_Configure(pf, mem, memsize, max_progs) (*pf->Configure) (pf, mem, memsize, max_progs)
#define PR_Configure(pf, memsize, max_progs) (*pf->Configure) (pf, memsize, max_progs)
#define PR_LoadProgs(pf, s, headercrc, builtins, numb) (*pf->LoadProgs) (pf, s, headercrc, builtins, numb)
#define PR_InitEnts(pf, maxents) (*pf->InitEnts) (pf, maxents)
#define PR_ExecuteProgram(pf, fnum) (*pf->ExecuteProgram) (pf, fnum)

18
engine/server/net_preparse.c
View File

@ -110,12 +110,12 @@ void NPP_Flush(void)
ClientReliableCheckBlock(cl, 7);
ClientReliableWrite_Byte(cl, svc_intermission);
ClientReliableWrite_Coord(cl, cl->edict->v.origin[0]);
ClientReliableWrite_Coord(cl, cl->edict->v.origin[1]);
ClientReliableWrite_Coord(cl, cl->edict->v.origin[2]+cl->edict->v.view_ofs[2]);
ClientReliableWrite_Angle(cl, cl->edict->v.angles[0]);
ClientReliableWrite_Angle(cl, cl->edict->v.angles[1]);
ClientReliableWrite_Angle(cl, cl->edict->v.angles[2]);
ClientReliableWrite_Coord(cl, cl->edict->v->origin[0]);
ClientReliableWrite_Coord(cl, cl->edict->v->origin[1]);
ClientReliableWrite_Coord(cl, cl->edict->v->origin[2]+cl->edict->v->view_ofs[2]);
ClientReliableWrite_Angle(cl, cl->edict->v->angles[0]);
ClientReliableWrite_Angle(cl, cl->edict->v->angles[1]);
ClientReliableWrite_Angle(cl, cl->edict->v->angles[2]);
}
}
@ -741,8 +741,8 @@ void NPP_QWFlush(void)
ang[2] = (*(qbyte*)&buffer[7+2])*360.0/255;
//move nq players to origin + angle
VectorCopy(cl->edict->v.origin, org);
VectorCopy(cl->edict->v.angles, ang);
VectorCopy(cl->edict->v->origin, org);
VectorCopy(cl->edict->v->angles, ang);
}
}
}
@ -763,7 +763,7 @@ void NPP_QWFlush(void)
short data;
float org[3];
edict_t *ent = EDICT_NUM(svprogfuncs, (*(short*)&buffer[1]));
VectorCopy(ent->v.origin, org);
VectorCopy(ent->v->origin, org);
data = LittleShort((short)(org[0]*8));
NPP_AddData(&data, sizeof(short));

342
engine/server/pr_cmds.c
View File

@ -136,13 +136,13 @@ pbool QC_WriteFile(char *name, void *data, int len)
void ED_Spawned (struct edict_s *ent)
{
ent->v.dimension_see = 255;
ent->v.dimension_seen = 255;
ent->v.dimension_ghost = 0;
ent->v.dimension_solid = 255;
ent->v.dimension_hit = 255;
ent->v->dimension_see = 255;
ent->v->dimension_seen = 255;
ent->v->dimension_ghost = 0;
ent->v->dimension_solid = 255;
ent->v->dimension_hit = 255;
ent->v.Version = sv.csqcentversion[ent->entnum]+1;
ent->v->Version = sv.csqcentversion[ent->entnum]+1;
}
pbool ED_CanFree (edict_t *ed)
@ -161,27 +161,27 @@ pbool ED_CanFree (edict_t *ed)
}
SV_UnlinkEdict (ed); // unlink from world bsp
ed->v.model = 0;
ed->v.takedamage = 0;
ed->v.modelindex = 0;
ed->v.colormap = 0;
ed->v.skin = 0;
ed->v.frame = 0;
VectorCopy (vec3_origin, ed->v.origin);
VectorCopy (vec3_origin, ed->v.angles);
ed->v.nextthink = 0;
ed->v.think = 0;
ed->v.solid = 0;
ed->v->model = 0;
ed->v->takedamage = 0;
ed->v->modelindex = 0;
ed->v->colormap = 0;
ed->v->skin = 0;
ed->v->frame = 0;
VectorCopy (vec3_origin, ed->v->origin);
VectorCopy (vec3_origin, ed->v->angles);
ed->v->nextthink = 0;
ed->v->think = 0;
ed->v->solid = 0;
ed->v.SendEntity = 0;
sv.csqcentversion[ed->entnum] = ed->v.Version+1;
ed->v->SendEntity = 0;
sv.csqcentversion[ed->entnum] = ed->v->Version+1;
return true;
}
void StateOp (progfuncs_t *prinst, float var, func_t func)
{
entvars_t *vars = &PROG_TO_EDICT(prinst, pr_global_struct->self)->v;
entvars_t *vars = PROG_TO_EDICT(prinst, pr_global_struct->self)->v;
if (progstype == PROG_H2)
vars->nextthink = pr_global_struct->time+0.05;
else
@ -191,7 +191,7 @@ void StateOp (progfuncs_t *prinst, float var, func_t func)
}
void CStateOp (progfuncs_t *prinst, float startFrame, float endFrame, func_t currentfunc)
{
entvars_t *vars = &PROG_TO_EDICT(prinst, pr_global_struct->self)->v;
entvars_t *vars = PROG_TO_EDICT(prinst, pr_global_struct->self)->v;
vars->nextthink = pr_global_struct->time+0.05;
vars->think = currentfunc;
@ -227,7 +227,7 @@ void CStateOp (progfuncs_t *prinst, float startFrame, float endFrame, func_t cur
}
void CWStateOp (progfuncs_t *prinst, float startFrame, float endFrame, func_t currentfunc)
{
entvars_t *vars = &PROG_TO_EDICT(prinst, pr_global_struct->self)->v;
entvars_t *vars = PROG_TO_EDICT(prinst, pr_global_struct->self)->v;
vars->nextthink = pr_global_struct->time+0.05;
vars->think = currentfunc;
@ -264,7 +264,7 @@ void CWStateOp (progfuncs_t *prinst, float startFrame, float endFrame, func_t cu
void ThinkTimeOp (progfuncs_t *prinst, edict_t *ed, float var)
{
entvars_t *vars = &ed->v;
entvars_t *vars = ed->v;
#ifdef PARANOID
NUM_FOR_EDICT(ed); // Make sure it's in range
#endif
@ -339,7 +339,7 @@ void Q_SetProgsParms(qboolean forcompiler)
svprogparms.printf = (void *)Con_Printf;//Con_Printf;//void (*printf) (char *, ...);
svprogparms.Sys_Error = Sys_Error;
svprogparms.Abort = SV_Error;
svprogparms.edictsize = sizeof(edict_t)-sizeof(entvars_t);
svprogparms.edictsize = sizeof(edict_t);
svprogparms.entspawn = ED_Spawned;//void (*entspawn) (struct edict_s *ent); //ent has been spawned, but may not have all the extra variables (that may need to be set) set
svprogparms.entcanfree = ED_CanFree;//bool (*entcanfree) (struct edict_s *ent); //return true to stop ent from being freed
@ -734,7 +734,7 @@ void PR_ApplyCompilation_f (void)
s = PR_SaveEnts(svprogfuncs, NULL, &len, 1);
PR_Configure(svprogfuncs, NULL, -1, MAX_PROGS);
PR_Configure(svprogfuncs, -1, MAX_PROGS);
PR_RegisterFields();
PR_InitEnts(svprogfuncs, sv.max_edicts);
@ -854,7 +854,7 @@ void Q_InitProgs(void)
// load progs to get entity field count
PR_Configure(svprogfuncs, NULL, -1, MAX_PROGS);
PR_Configure(svprogfuncs, -1, MAX_PROGS);
PR_RegisterFields();
@ -1292,7 +1292,7 @@ qboolean PR_ConsoleCmd(void)
if (sv_redirected != RD_OBLIVION)
{
pr_global_struct->time = sv.time;
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, sv_player);
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, sv.edicts);
}
PR_ExecuteProgram (svprogfuncs, mod_ConsoleCmd);
@ -1688,7 +1688,7 @@ void PF_setorigin (progfuncs_t *prinst, struct globalvars_s *pr_globals)
e = G_EDICT(prinst, OFS_PARM0);
org = G_VECTOR(OFS_PARM1);
VectorCopy (org, e->v.origin);
VectorCopy (org, e->v->origin);
SV_LinkEdict (e, false);
}
@ -1716,9 +1716,9 @@ void PF_setsize (progfuncs_t *prinst, struct globalvars_s *pr_globals)
}
min = G_VECTOR(OFS_PARM1);
max = G_VECTOR(OFS_PARM2);
VectorCopy (min, e->v.mins);
VectorCopy (max, e->v.maxs);
VectorSubtract (max, min, e->v.size);
VectorCopy (min, e->v->mins);
VectorCopy (max, e->v->maxs);
VectorSubtract (max, min, e->v->size);
SV_LinkEdict (e, false);
}
@ -1771,16 +1771,16 @@ void PF_setmodel (progfuncs_t *prinst, struct globalvars_s *pr_globals)
}
}
e->v.model = PR_SetString(prinst, sv.model_precache[i]);
e->v.modelindex = i;
e->v->model = PR_SetString(prinst, sv.model_precache[i]);
e->v->modelindex = i;
// if it is an inline model, get the size information for it
if (m[0] == '*' || (*m&&progstype == PROG_H2))
{
mod = Mod_ForName (m, true);
VectorCopy (mod->mins, e->v.mins);
VectorCopy (mod->maxs, e->v.maxs);
VectorSubtract (mod->maxs, mod->mins, e->v.size);
VectorCopy (mod->mins, e->v->mins);
VectorCopy (mod->maxs, e->v->maxs);
VectorSubtract (mod->maxs, mod->mins, e->v->size);
SV_LinkEdict (e, false);
return;
@ -1788,15 +1788,15 @@ void PF_setmodel (progfuncs_t *prinst, struct globalvars_s *pr_globals)
if (progstype == PROG_H2)
{
e->v.mins[0] = 0;
e->v.mins[1] = 0;
e->v.mins[2] = 0;
e->v->mins[0] = 0;
e->v->mins[1] = 0;
e->v->mins[2] = 0;
e->v.maxs[0] = 0;
e->v.maxs[1] = 0;
e->v.maxs[2] = 0;
e->v->maxs[0] = 0;
e->v->maxs[1] = 0;
e->v->maxs[2] = 0;
VectorSubtract (e->v.maxs, e->v.mins, e->v.size);
VectorSubtract (e->v->maxs, e->v->mins, e->v->size);
}
else
{
@ -1809,9 +1809,9 @@ void PF_setmodel (progfuncs_t *prinst, struct globalvars_s *pr_globals)
mod = sv.models[i];
if (mod)
{
VectorCopy (mod->mins, e->v.mins);
VectorCopy (mod->maxs, e->v.maxs);
VectorSubtract (mod->maxs, mod->mins, e->v.size);
VectorCopy (mod->mins, e->v->mins);
VectorCopy (mod->maxs, e->v->maxs);
VectorSubtract (mod->maxs, mod->mins, e->v->size);
SV_LinkEdict (e, false);
}
else
@ -1820,13 +1820,13 @@ void PF_setmodel (progfuncs_t *prinst, struct globalvars_s *pr_globals)
//seing as dedicated servers don't want to load mdls,
//imitate the behaviour of setting the size (which nq can only have as +/- 16)
//hell, this works with quakerally so why not use it.
e->v.mins[0] =
e->v.mins[1] =
e->v.mins[2] = -16;
e->v.maxs[0] =
e->v.maxs[1] =
e->v.maxs[2] = 16;
VectorSubtract (e->v.maxs, e->v.mins, e->v.size);
e->v->mins[0] =
e->v->mins[1] =
e->v->mins[2] = -16;
e->v->maxs[0] =
e->v->maxs[1] =
e->v->maxs[2] = 16;
VectorSubtract (e->v->maxs, e->v->mins, e->v->size);
SV_LinkEdict (e, false);
}
}
@ -1835,9 +1835,9 @@ void PF_setmodel (progfuncs_t *prinst, struct globalvars_s *pr_globals)
if (sv.models[i])
{
mod = Mod_ForName (m, true);
VectorCopy (mod->mins, e->v.mins);
VectorCopy (mod->maxs, e->v.maxs);
VectorSubtract (mod->maxs, mod->mins, e->v.size);
VectorCopy (mod->mins, e->v->mins);
VectorCopy (mod->maxs, e->v->maxs);
VectorSubtract (mod->maxs, mod->mins, e->v->size);
SV_LinkEdict (e, false);
}
//qw was fixed - it never sets the size of an alias model.
@ -2606,10 +2606,10 @@ static void PF_traceline (progfuncs_t *prinst, struct globalvars_s *pr_globals)
maxs = vec3_origin;
}
savedhull = ent->v.hull;
ent->v.hull = 0;
savedhull = ent->v->hull;
ent->v->hull = 0;
trace = SV_Move (v1, mins, maxs, v2, nomonsters, ent);
ent->v.hull = savedhull;
ent->v->hull = savedhull;
pr_global_struct->trace_allsolid = trace.allsolid;
pr_global_struct->trace_startsolid = trace.startsolid;
@ -2643,10 +2643,10 @@ static void PF_traceboxh2 (progfuncs_t *prinst, struct globalvars_s *pr_globals)
nomonsters = G_FLOAT(OFS_PARM4);
ent = G_EDICT(prinst, OFS_PARM5);
savedhull = ent->v.hull;
ent->v.hull = 0;
savedhull = ent->v->hull;
ent->v->hull = 0;
trace = SV_Move (v1, mins, maxs, v2, nomonsters, ent);
ent->v.hull = savedhull;
ent->v->hull = savedhull;
pr_global_struct->trace_allsolid = trace.allsolid;
pr_global_struct->trace_startsolid = trace.startsolid;
@ -2680,10 +2680,10 @@ static void PF_traceboxdp (progfuncs_t *prinst, struct globalvars_s *pr_globals)
nomonsters = G_FLOAT(OFS_PARM4);
ent = G_EDICT(prinst, OFS_PARM5);
savedhull = ent->v.hull;
ent->v.hull = 0;
savedhull = ent->v->hull;
ent->v->hull = 0;
trace = SV_Move (v1, mins, maxs, v2, nomonsters, ent);
ent->v.hull = savedhull;
ent->v->hull = savedhull;
pr_global_struct->trace_allsolid = trace.allsolid;
pr_global_struct->trace_startsolid = trace.startsolid;
@ -2781,9 +2781,9 @@ int PF_newcheckclient (progfuncs_t *prinst, int check)
if (ent->isfree)
continue;
if (ent->v.health <= 0)
if (ent->v->health <= 0)
continue;
if ((int)ent->v.flags & FL_NOTARGET)
if ((int)ent->v->flags & FL_NOTARGET)
continue;
// anything that is a client, or has a client as an enemy
@ -2791,7 +2791,7 @@ int PF_newcheckclient (progfuncs_t *prinst, int check)
}
// get the PVS for the entity
VectorAdd (ent->v.origin, ent->v.view_ofs, org);
VectorAdd (ent->v->origin, ent->v->view_ofs, org);
leaf = sv.worldmodel->funcs.LeafForPoint(org, sv.worldmodel);
checkpvs = sv.worldmodel->funcs.LeafPVS (leaf, sv.worldmodel, checkpvsbuffer);
@ -2830,7 +2830,7 @@ void PF_checkclient (progfuncs_t *prinst, struct globalvars_s *pr_globals)
// return check if it might be visible
ent = EDICT_NUM(prinst, sv.lastcheck);
if (ent->isfree || ent->v.health <= 0)
if (ent->isfree || ent->v->health <= 0)
{
RETURN_EDICT(prinst, sv.edicts);
return;
@ -2838,7 +2838,7 @@ void PF_checkclient (progfuncs_t *prinst, struct globalvars_s *pr_globals)
// if current entity can't possibly see the check entity, return 0
self = PROG_TO_EDICT(prinst, pr_global_struct->self);
VectorAdd (self->v.origin, self->v.view_ofs, view);
VectorAdd (self->v->origin, self->v->view_ofs, view);
l = sv.worldmodel->funcs.LeafForPoint(view, sv.worldmodel)-1;
if ( (l<0) || !(checkpvs[l>>3] & (1<<(l&7)) ) )
{
@ -3113,14 +3113,14 @@ void PF_findradius (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ent = EDICT_NUM(svprogfuncs, i);
if (ent->isfree)
continue;
if (ent->v.solid == SOLID_NOT)
if (ent->v->solid == SOLID_NOT)
continue;
for (j=0 ; j<3 ; j++)
eorg[j] = org[j] - (ent->v.origin[j] + (ent->v.mins[j] + ent->v.maxs[j])*0.5);
eorg[j] = org[j] - (ent->v->origin[j] + (ent->v->mins[j] + ent->v->maxs[j])*0.5);
if (Length(eorg) > rad)
continue;
ent->v.chain = EDICT_TO_PROG(prinst, chain);
ent->v->chain = EDICT_TO_PROG(prinst, chain);
chain = ent;
}
@ -3290,7 +3290,6 @@ void PF_FindString (progfuncs_t *prinst, struct globalvars_s *pr_globals)
e = G_EDICTNUM(prinst, OFS_PARM0);
f = G_INT(OFS_PARM1)+prinst->fieldadjust;
f += prinst->parms->edictsize/4;
s = PR_GetStringOfs(prinst, OFS_PARM2);
if (!s)
{
@ -3303,7 +3302,7 @@ void PF_FindString (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ed = EDICT_NUM(prinst, e);
if (ed->isfree)
continue;
t = ((string_t *)ed)[f];
t = ((string_t *)ed->v)[f];
if (!t)
continue;
if (!strcmp(t+prinst->stringtable,s))
@ -3505,7 +3504,7 @@ void PF_walkmove (progfuncs_t *prinst, struct globalvars_s *pr_globals)
else
settrace = NULL;
if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
{
G_FLOAT(OFS_RETURN) = 0;
return;
@ -3554,20 +3553,20 @@ void PF_droptofloor (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ent = PROG_TO_EDICT(prinst, pr_global_struct->self);
VectorCopy (ent->v.origin, end);
VectorCopy (ent->v->origin, end);
end[2] -= 512;
VectorCopy (ent->v.origin, start);
trace = SV_Move (start, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
VectorCopy (ent->v->origin, start);
trace = SV_Move (start, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
if (trace.fraction == 1 || trace.allsolid)
G_FLOAT(OFS_RETURN) = 0;
else
{
VectorCopy (trace.endpos, ent->v.origin);
VectorCopy (trace.endpos, ent->v->origin);
SV_LinkEdict (ent, false);
ent->v.flags = (int)ent->v.flags | FL_ONGROUND;
ent->v.groundentity = EDICT_TO_PROG(prinst, trace.ent);
ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
ent->v->groundentity = EDICT_TO_PROG(prinst, trace.ent);
G_FLOAT(OFS_RETURN) = 1;
}
}
@ -3867,7 +3866,7 @@ void PF_aim (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ent = G_EDICT(prinst, OFS_PARM0);
speed = G_FLOAT(OFS_PARM1);
VectorCopy (ent->v.origin, start);
VectorCopy (ent->v->origin, start);
start[2] += 20;
// noaim option
@ -3886,8 +3885,8 @@ void PF_aim (progfuncs_t *prinst, struct globalvars_s *pr_globals)
VectorCopy (P_VEC(v_forward), dir);
VectorMA (start, 2048, dir, end);
tr = SV_Move (start, vec3_origin, vec3_origin, end, false, ent);
if (tr.ent && tr.ent->v.takedamage == DAMAGE_AIM
&& (!teamplay.value || ent->v.team <=0 || ent->v.team != tr.ent->v.team) )
if (tr.ent && tr.ent->v->takedamage == DAMAGE_AIM
&& (!teamplay.value || ent->v->team <=0 || ent->v->team != tr.ent->v->team) )
{
VectorCopy (P_VEC(v_forward), G_VECTOR(OFS_RETURN));
return;
@ -3902,15 +3901,15 @@ void PF_aim (progfuncs_t *prinst, struct globalvars_s *pr_globals)
for (i=1 ; i<sv.num_edicts ; i++ )
{
check = EDICT_NUM(prinst, i);
if (check->v.takedamage != DAMAGE_AIM)
if (check->v->takedamage != DAMAGE_AIM)
continue;
if (check == ent)
continue;
if (teamplay.value && ent->v.team > 0 && ent->v.team == check->v.team)
if (teamplay.value && ent->v->team > 0 && ent->v->team == check->v->team)
continue; // don't aim at teammate
for (j=0 ; j<3 ; j++)
end[j] = check->v.origin[j]
+ 0.5*(check->v.mins[j] + check->v.maxs[j]);
end[j] = check->v->origin[j]
+ 0.5*(check->v->mins[j] + check->v->maxs[j]);
VectorSubtract (end, start, dir);
VectorNormalize (dir);
dist = DotProduct (dir, P_VEC(v_forward));
@ -3926,7 +3925,7 @@ void PF_aim (progfuncs_t *prinst, struct globalvars_s *pr_globals)
if (bestent)
{
VectorSubtract (bestent->v.origin, ent->v.origin, dir);
VectorSubtract (bestent->v->origin, ent->v->origin, dir);
dist = DotProduct (dir, P_VEC(v_forward));
VectorScale (P_VEC(v_forward), dist, end);
end[2] = dir[2];
@ -3952,9 +3951,9 @@ void PF_changeyaw (progfuncs_t *prinst, struct globalvars_s *pr_globals)
float ideal, current, move, speed;
ent = PROG_TO_EDICT(prinst, pr_global_struct->self);
current = anglemod( ent->v.angles[1] );
ideal = ent->v.ideal_yaw;
speed = ent->v.yaw_speed;
current = anglemod( ent->v->angles[1] );
ideal = ent->v->ideal_yaw;
speed = ent->v->yaw_speed;
if (current == ideal)
return;
@ -3980,7 +3979,7 @@ void PF_changeyaw (progfuncs_t *prinst, struct globalvars_s *pr_globals)
move = -speed;
}
ent->v.angles[1] = anglemod (current + move);
ent->v->angles[1] = anglemod (current + move);
}
//void() changepitch = #63;
@ -3991,7 +3990,7 @@ void PF_changepitch (progfuncs_t *prinst, struct globalvars_s *pr_globals)
eval_t *eval;
ent = PROG_TO_EDICT(prinst, pr_global_struct->self);
current = anglemod( ent->v.angles[1] );
current = anglemod( ent->v->angles[1] );
eval = prinst->GetEdictFieldValue(prinst, ent, "idealpitch", &evalc_idealpitch);
if (eval)
@ -4028,7 +4027,7 @@ void PF_changepitch (progfuncs_t *prinst, struct globalvars_s *pr_globals)
move = -speed;
}
ent->v.angles[1] = anglemod (current + move);
ent->v->angles[1] = anglemod (current + move);
}
/*
===============================================================================
@ -4628,9 +4627,9 @@ void PF_makestatic (progfuncs_t *prinst, struct globalvars_s *pr_globals)
SV_FlushSignon ();
mdlindex = SV_ModelIndex(PR_GetString(prinst, ent->v.model));
mdlindex = SV_ModelIndex(PR_GetString(prinst, ent->v->model));
if (ent->v.drawflags || ent->v.alpha || mdlindex > 255 || ent->v.frame > 255 || ent->v.scale || ent->v.abslight)
if (ent->v->drawflags || ent->v->alpha || mdlindex > 255 || ent->v->frame > 255 || ent->v->scale || ent->v->abslight)
{
if (sv.numextrastatics==sizeof(sv.extendedstatics)/sizeof(sv.extendedstatics[0]))
return; //fail the whole makestatic thing.
@ -4639,20 +4638,20 @@ void PF_makestatic (progfuncs_t *prinst, struct globalvars_s *pr_globals)
memset(state, 0, sizeof(*state));
state->number = sv.numextrastatics;
state->flags = 0;
VectorCopy (ent->v.origin, state->origin);
VectorCopy (ent->v.angles, state->angles);
state->modelindex = mdlindex;//ent->v.modelindex;
state->frame = ent->v.frame;
state->colormap = ent->v.colormap;
state->skinnum = ent->v.skin;
state->effects = ent->v.effects;
state->drawflags = ent->v.drawflags;
state->abslight = (int)(ent->v.abslight*255) & 255;
state->trans = ent->v.alpha;
VectorCopy (ent->v->origin, state->origin);
VectorCopy (ent->v->angles, state->angles);
state->modelindex = mdlindex;//ent->v->modelindex;
state->frame = ent->v->frame;
state->colormap = ent->v->colormap;
state->skinnum = ent->v->skin;
state->effects = ent->v->effects;
state->drawflags = ent->v->drawflags;
state->abslight = (int)(ent->v->abslight*255) & 255;
state->trans = ent->v->alpha;
if (!state->trans)
state->trans = 1;
state->fatness = ent->v.fatness;
state->scale = ent->v.scale;
state->fatness = ent->v->fatness;
state->scale = ent->v->scale;
if (progstype != PROG_QW) //don't send extra nq effects to a qw client.
state->effects &= EF_BRIGHTLIGHT | EF_DIMLIGHT;
@ -4663,13 +4662,13 @@ void PF_makestatic (progfuncs_t *prinst, struct globalvars_s *pr_globals)
MSG_WriteByte (&sv.signon, mdlindex&255);
MSG_WriteByte (&sv.signon, ent->v.frame);
MSG_WriteByte (&sv.signon, (int)ent->v.colormap);
MSG_WriteByte (&sv.signon, (int)ent->v.skin);
MSG_WriteByte (&sv.signon, ent->v->frame);
MSG_WriteByte (&sv.signon, (int)ent->v->colormap);
MSG_WriteByte (&sv.signon, (int)ent->v->skin);
for (i=0 ; i<3 ; i++)
{
MSG_WriteCoord(&sv.signon, ent->v.origin[i]);
MSG_WriteAngle(&sv.signon, ent->v.angles[i]);
MSG_WriteCoord(&sv.signon, ent->v->origin[i]);
MSG_WriteAngle(&sv.signon, ent->v->angles[i]);
}
}
@ -5489,19 +5488,19 @@ void PF_fgets (progfuncs_t *prinst, struct globalvars_s *pr_globals)
RETURN_SSTRING(pr_string_temp);
if (fnum < 0 || fnum >= MAX_QC_FILES)
{
Con_Printf("PF_fgets: File out of range\n");
PR_BIError(prinst, "PF_fgets: File out of range\n");
return; //out of range
}
if (!pf_fopen_files[fnum].data)
{
Con_Printf("PF_fgets: File is not open\n");
PR_BIError(prinst, "PF_fgets: File is not open\n");
return; //not open
}
if (pf_fopen_files[fnum].prinst != prinst)
{
Con_Printf("PF_fgets: File is from wrong instance\n");
PR_BIError(prinst, "PF_fgets: File is from wrong instance\n");
return; //this just isn't ours.
}
@ -6393,7 +6392,6 @@ void PF_findchain (progfuncs_t *prinst, struct globalvars_s *pr_globals)
chain = (edict_t *) *prinst->parms->sv_edicts;
f = G_INT(OFS_PARM0)+prinst->fieldadjust;
f += prinst->parms->edictsize/4;
s = PR_GetStringOfs(prinst, OFS_PARM1);
for (i = 1; i < *prinst->parms->sv_num_edicts; i++)
@ -6401,13 +6399,13 @@ void PF_findchain (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ent = EDICT_NUM(prinst, i);
if (ent->isfree)
continue;
t = *(string_t *)&((float*)ent)[f] + prinst->stringtable;
t = *(string_t *)&((float*)ent->v)[f] + prinst->stringtable;
if (!t)
continue;
if (strcmp(t, s))
continue;
ent->v.chain = EDICT_TO_PROG(prinst, chain);
ent->v->chain = EDICT_TO_PROG(prinst, chain);
chain = ent;
}
@ -6427,7 +6425,6 @@ void PF_findchainfloat (progfuncs_t *prinst, struct globalvars_s *pr_globals)
chain = (edict_t *) *prinst->parms->sv_edicts;
f = G_INT(OFS_PARM0)+prinst->fieldadjust;
f += prinst->parms->edictsize/4;
s = G_FLOAT(OFS_PARM1);
for (i = 1; i < *prinst->parms->sv_num_edicts; i++)
@ -6435,10 +6432,10 @@ void PF_findchainfloat (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ent = EDICT_NUM(prinst, i);
if (ent->isfree)
continue;
if (((float *)ent)[f] != s)
if (((float *)ent->v)[f] != s)
continue;
ent->v.chain = EDICT_TO_PROG(prinst, chain);
ent->v->chain = EDICT_TO_PROG(prinst, chain);
chain = ent;
}
@ -6458,7 +6455,6 @@ void PF_findchainflags (progfuncs_t *prinst, struct globalvars_s *pr_globals)
chain = (edict_t *) *prinst->parms->sv_edicts;
f = G_INT(OFS_PARM0)+prinst->fieldadjust;
f += prinst->parms->edictsize/4;
s = G_FLOAT(OFS_PARM1);
for (i = 1; i < *prinst->parms->sv_num_edicts; i++)
@ -6466,10 +6462,10 @@ void PF_findchainflags (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ent = EDICT_NUM(prinst, i);
if (ent->isfree)
continue;
if (!((int)((float *)ent)[f] & s))
if (!((int)((float *)ent->v)[f] & s))
continue;
ent->v.chain = EDICT_TO_PROG(prinst, chain);
ent->v->chain = EDICT_TO_PROG(prinst, chain);
chain = ent;
}
@ -6493,7 +6489,6 @@ void PF_FindFloat (progfuncs_t *prinst, struct globalvars_s *pr_globals)
e = G_EDICTNUM(prinst, OFS_PARM0);
f = G_INT(OFS_PARM1)+prinst->fieldadjust;
f += prinst->parms->edictsize/4;
s = G_INT(OFS_PARM2);
for (e++; e < *prinst->parms->sv_num_edicts; e++)
@ -6501,7 +6496,7 @@ void PF_FindFloat (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ed = EDICT_NUM(prinst, e);
if (ed->isfree)
continue;
if (((int *)ed)[f] == s)
if (((int *)ed->v)[f] == s)
{
RETURN_EDICT(prinst, ed);
return;
@ -6522,7 +6517,6 @@ void PF_FindFlags (progfuncs_t *prinst, struct globalvars_s *pr_globals)
e = G_EDICTNUM(prinst, OFS_PARM0);
f = G_INT(OFS_PARM1)+prinst->fieldadjust;
f += prinst->parms->edictsize/4;
s = G_FLOAT(OFS_PARM2);
for (e++; e < *prinst->parms->sv_num_edicts; e++)
@ -6530,7 +6524,7 @@ void PF_FindFlags (progfuncs_t *prinst, struct globalvars_s *pr_globals)
ed = EDICT_NUM(prinst, e);
if (ed->isfree)
continue;
if ((int)((float *)ed)[f] & s)
if ((int)((float *)ed->v)[f] & s)
{
RETURN_EDICT(prinst, ed);
return;
@ -6676,36 +6670,36 @@ void PF_AdvanceFrame(progfuncs_t *prinst, struct globalvars_s *pr_globals)
Start = G_FLOAT(OFS_PARM0);
End = G_FLOAT(OFS_PARM1);
if ((Start<End&&(Ent->v.frame < Start || Ent->v.frame > End))||
(Start>End&&(Ent->v.frame > Start || Ent->v.frame < End)))
if ((Start<End&&(Ent->v->frame < Start || Ent->v->frame > End))||
(Start>End&&(Ent->v->frame > Start || Ent->v->frame < End)))
{ // Didn't start in the range
Ent->v.frame = Start;
Ent->v->frame = Start;
Result = 0;
}
else if(Ent->v.frame == End)
else if(Ent->v->frame == End)
{ // Wrapping
Ent->v.frame = Start;
Ent->v->frame = Start;
Result = 1;
}
else if(End>Start)
{ // Regular Advance
Ent->v.frame++;
if (Ent->v.frame == End)
Ent->v->frame++;
if (Ent->v->frame == End)
Result = 2;
else
Result = 0;
}
else if(End<Start)
{ // Reverse Advance
Ent->v.frame--;
if (Ent->v.frame == End)
Ent->v->frame--;
if (Ent->v->frame == End)
Result = 2;
else
Result = 0;
}
else
{
Ent->v.frame=End;
Ent->v->frame=End;
Result = 1;
}
@ -6721,20 +6715,20 @@ void PF_RewindFrame(progfuncs_t *prinst, struct globalvars_s *pr_globals)
Start = G_FLOAT(OFS_PARM0);
End = G_FLOAT(OFS_PARM1);
if (Ent->v.frame > Start || Ent->v.frame < End)
if (Ent->v->frame > Start || Ent->v->frame < End)
{ // Didn't start in the range
Ent->v.frame = Start;
Ent->v->frame = Start;
Result = 0;
}
else if(Ent->v.frame == End)
else if(Ent->v->frame == End)
{ // Wrapping
Ent->v.frame = Start;
Ent->v->frame = Start;
Result = 1;
}
else
{ // Regular Advance
Ent->v.frame--;
if (Ent->v.frame == End) Result = 2;
Ent->v->frame--;
if (Ent->v->frame == End) Result = 2;
else Result = 0;
}
@ -6756,25 +6750,25 @@ void PF_advanceweaponframe (progfuncs_t *prinst, struct globalvars_s *pr_globals
startframe = G_FLOAT(OFS_PARM0);
endframe = G_FLOAT(OFS_PARM1);
if ((endframe > startframe && (ent->v.weaponframe > endframe || ent->v.weaponframe < startframe)) ||
(endframe < startframe && (ent->v.weaponframe < endframe || ent->v.weaponframe > startframe)) )
if ((endframe > startframe && (ent->v->weaponframe > endframe || ent->v->weaponframe < startframe)) ||
(endframe < startframe && (ent->v->weaponframe < endframe || ent->v->weaponframe > startframe)) )
{
ent->v.weaponframe=startframe;
ent->v->weaponframe=startframe;
state = WF_CYCLE_STARTED;
}
else if(ent->v.weaponframe==endframe)
else if(ent->v->weaponframe==endframe)
{
ent->v.weaponframe=startframe;
ent->v->weaponframe=startframe;
state = WF_CYCLE_WRAPPED;
}
else
{
if (startframe > endframe)
ent->v.weaponframe = ent->v.weaponframe - 1;
ent->v->weaponframe = ent->v->weaponframe - 1;
else if (startframe < endframe)
ent->v.weaponframe = ent->v.weaponframe + 1;
ent->v->weaponframe = ent->v->weaponframe + 1;
if (ent->v.weaponframe==endframe)
if (ent->v->weaponframe==endframe)
state = WF_LAST_FRAME;
else
state = WF_NORMAL_ADVANCE;
@ -6805,7 +6799,7 @@ void PF_setclass (progfuncs_t *prinst, struct globalvars_s *pr_globals)
client = &svs.clients[entnum-1];
e->v.playerclass = NewClass;
e->v->playerclass = NewClass;
client->playerclass = NewClass;
sprintf(temp,"%d",(int)NewClass);
@ -6959,7 +6953,7 @@ void PF_matchAngleToSlope(progfuncs_t *prinst, struct globalvars_s *pr_globals)
// OFS_PARM0 is used by PF_vectoangles below
actor = G_EDICT(prinst, OFS_PARM1);
AngleVectors(actor->v.angles, old_forward, old_right, P_VEC(v_up));
AngleVectors(actor->v->angles, old_forward, old_right, P_VEC(v_up));
PF_vectoangles(prinst, pr_globals);
@ -6978,8 +6972,8 @@ void PF_matchAngleToSlope(progfuncs_t *prinst, struct globalvars_s *pr_globals)
dot = DotProduct(v_forward, old_forward);
actor->v.angles[0] = dot*pitch;
actor->v.angles[2] = (1-fabs(dot))*pitch*mod;
actor->v->angles[0] = dot*pitch;
actor->v->angles[2] = (1-fabs(dot))*pitch*mod;
}
void PF_starteffect(progfuncs_t *prinst, struct globalvars_s *pr_globals)
@ -7513,7 +7507,7 @@ void PF_setcolors (progfuncs_t *prinst, struct globalvars_s *pr_globals)
}
client = &svs.clients[entnum-1];
client->edict->v.team = (i & 15) + 1;
client->edict->v->team = (i & 15) + 1;
#ifdef NQPROT
MSG_WriteByte (&sv.nqreliable_datagram, svc_updatecolors);
MSG_WriteByte (&sv.nqreliable_datagram, entnum - 1);
@ -7811,7 +7805,7 @@ void PF_setattachment(progfuncs_t *prinst, struct globalvars_s *pr_globals)
if (tagentity != sv.edicts && tagname && tagname[0])
{
modelindex = (int)tagentity->v.modelindex;
modelindex = (int)tagentity->v->modelindex;
if (modelindex > 0 && modelindex < MAX_MODELS && (model = SV_GetTags(modelindex, &tagcount)))
{
for (i = 0;i < tagcount;i++)
@ -8403,11 +8397,11 @@ void PR_RegisterSVBuiltins(void)
void PR_RegisterFields(void) //it's just easier to do it this way.
{
#define fieldfloat(name) PR_RegisterFieldVar(svprogfuncs, ev_float, #name, (int)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -1)
#define fieldvector(name) PR_RegisterFieldVar(svprogfuncs, ev_vector, #name, (int)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -1)
#define fieldentity(name) PR_RegisterFieldVar(svprogfuncs, ev_entity, #name, (int)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -1)
#define fieldstring(name) PR_RegisterFieldVar(svprogfuncs, ev_string, #name, (int)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -1)
#define fieldfunction(name) PR_RegisterFieldVar(svprogfuncs, ev_function, #name, (int)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -1)
#define fieldfloat(name) PR_RegisterFieldVar(svprogfuncs, ev_float, #name, (int)&((entvars_t*)0)->name, -1)
#define fieldvector(name) PR_RegisterFieldVar(svprogfuncs, ev_vector, #name, (int)&((entvars_t*)0)->name, -1)
#define fieldentity(name) PR_RegisterFieldVar(svprogfuncs, ev_entity, #name, (int)&((entvars_t*)0)->name, -1)
#define fieldstring(name) PR_RegisterFieldVar(svprogfuncs, ev_string, #name, (int)&((entvars_t*)0)->name, -1)
#define fieldfunction(name) PR_RegisterFieldVar(svprogfuncs, ev_function, #name, (int)&((entvars_t*)0)->name, -1)
fieldfloat(modelindex);
fieldvector(absmin);
@ -8502,9 +8496,9 @@ void PR_RegisterFields(void) //it's just easier to do it this way.
fieldfloat(fatness);
fieldentity(view2);
fieldvector(movement);
PR_RegisterFieldVar(svprogfuncs, ev_float, "buttonforward", (int)&((edict_t*)0)->v.movement[0] - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "buttonright", (int)&((edict_t*)0)->v.movement[1] - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "buttonup", (int)&((edict_t*)0)->v.movement[2] - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "buttonforward", (int)&((entvars_t*)0)->movement[0], -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "buttonright", (int)&((entvars_t*)0)->movement[1], -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "buttonup", (int)&((entvars_t*)0)->movement[2], -1);
fieldfloat(fteflags);
fieldfloat(vweapmodelindex);
@ -8513,11 +8507,11 @@ void PR_RegisterFields(void) //it's just easier to do it this way.
fieldentity(drawonlytoclient);
//UDC_EXTEFFECT... yuckie
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldcolor", (int)&((edict_t*)0)->v.seefcolour - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizex", (int)&((edict_t*)0)->v.seefsizex - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizey", (int)&((edict_t*)0)->v.seefsizey - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizez", (int)&((edict_t*)0)->v.seefsizez - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldoffset", (int)&((edict_t*)0)->v.seefoffset - (int)&((edict_t*)0)->v, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldcolor", (int)&((entvars_t*)0)->seefcolour, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizex", (int)&((entvars_t*)0)->seefsizex, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizey", (int)&((entvars_t*)0)->seefsizey, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizez", (int)&((entvars_t*)0)->seefsizez, -1);
PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldoffset", (int)&((entvars_t*)0)->seefoffset, -1);
//hexen 2 stuff
fieldfloat(playerclass);

5
engine/server/progs.h
View File

@ -63,10 +63,14 @@ extern int pr_edict_size;
#define MAX_ENT_LEAFS 16
typedef struct edict_s
{
//these 5 shared with qclib
qboolean isfree;
float freetime; // sv.time when the object was freed
int entnum;
qboolean readonly; //world
entvars_t *v;
//the rest is free for adaption
link_t area; // linked to a division node or leaf
int solidtype;
@ -82,7 +86,6 @@ typedef struct edict_s
unsigned short tagent;
unsigned short tagindex;
entvars_t v; // C exported fields from progs
// other fields from progs come immediately after
} edict_t;

2
engine/server/savegame.c
View File

@ -585,7 +585,7 @@ qboolean SV_LoadLevelCache(char *level, char *startspot, qboolean ignoreplayers)
Q_SetProgsParms(false);
PR_Configure(svprogfuncs, NULL, -1, MAX_PROGS);
PR_Configure(svprogfuncs, -1, MAX_PROGS);
PR_RegisterFields();
PR_InitEnts(svprogfuncs, sv.max_edicts);

2
engine/server/server.h
View File

@ -947,7 +947,7 @@ void VARGS SV_ClientTPrintf (client_t *cl, int level, translation_t text, ...);
void VARGS SV_BroadcastPrintf (int level, char *fmt, ...);
void VARGS SV_BroadcastTPrintf (int level, translation_t fmt, ...);
void VARGS SV_BroadcastCommand (char *fmt, ...);
void SV_SendServerInfoChange(char *key, char *value);
void SV_SendServerInfoChange(char *key, const char *value);
void SV_SendMessagesToAll (void);
void SV_FindModelNumbers (void);

24
engine/server/sv_ccmds.c
View File

@ -299,8 +299,8 @@ void SV_God_f (void)
if (!SV_SetPlayer ())
return;
sv_player->v.flags = (int)sv_player->v.flags ^ FL_GODMODE;
if ((int)sv_player->v.flags & FL_GODMODE)
sv_player->v->flags = (int)sv_player->v->flags ^ FL_GODMODE;
if ((int)sv_player->v->flags & FL_GODMODE)
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_GODON);
else
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_GODOFF);
@ -318,14 +318,14 @@ void SV_Noclip_f (void)
if (!SV_SetPlayer ())
return;
if (sv_player->v.movetype != MOVETYPE_NOCLIP)
if (sv_player->v->movetype != MOVETYPE_NOCLIP)
{
sv_player->v.movetype = MOVETYPE_NOCLIP;
sv_player->v->movetype = MOVETYPE_NOCLIP;
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_NOCLIPON);
}
else
{
sv_player->v.movetype = MOVETYPE_WALK;
sv_player->v->movetype = MOVETYPE_WALK;
SV_ClientTPrintf (host_client, PRINT_HIGH, STL_NOCLIPOFF);
}
}
@ -373,23 +373,23 @@ void SV_Give_f (void)
case '7':
case '8':
case '9':
sv_player->v.items = (int)sv_player->v.items | IT_SHOTGUN<< (t[0] - '2');
sv_player->v->items = (int)sv_player->v->items | IT_SHOTGUN<< (t[0] - '2');
break;
case 's':
sv_player->v.ammo_shells = v;
sv_player->v->ammo_shells = v;
break;
case 'n':
sv_player->v.ammo_nails = v;
sv_player->v->ammo_nails = v;
break;
case 'r':
sv_player->v.ammo_rockets = v;
sv_player->v->ammo_rockets = v;
break;
case 'h':
sv_player->v.health = v;
sv_player->v->health = v;
break;
case 'c':
sv_player->v.ammo_cells = v;
sv_player->v->ammo_cells = v;
break;
default:
{
@ -1086,7 +1086,7 @@ void SV_Heartbeat_f (void)
svs.last_heartbeat = -9999;
}
void SV_SendServerInfoChange(char *key, char *value)
void SV_SendServerInfoChange(char *key, const char *value)
{
if (!sv.state)
return;

7
engine/server/sv_chat.c
View File

@ -69,7 +69,7 @@ the qc code:
#define SENDDELAY 1
float SV_ChatFunc(char *func);
float SV_ChatFunc(const char *func);
void Chat_GetTag(char *filename, float tag, char **text, char **condition, char **options)
{
char *file; char *s;
@ -169,12 +169,13 @@ float SV_ChatSetValue(char *name, float newval)
return newval;
}
float SV_ChatFunc(char *func) //parse a condition/function
float SV_ChatFunc(const char *func) //parse a condition/function
{
globalvars_t *pr_globals;
float result;
int noted = false;
char *s, *os, namebuf[64];
const char *s, *os;
char namebuf[64];
func_t f;
int parm;
while (*func <= ' ')

332
engine/server/sv_ents.c
View File

@ -116,8 +116,8 @@ int csqcnuments;
qboolean SV_AddNailUpdate (edict_t *ent)
{
if (ent->v.modelindex != sv_nailmodel
&& ent->v.modelindex != sv_supernailmodel)
if (ent->v->modelindex != sv_nailmodel
&& ent->v->modelindex != sv_supernailmodel)
return false;
if (sv_nailhack.value)
return false;
@ -146,7 +146,7 @@ qboolean SV_DemoNailUpdate (int i)
#ifdef PEXT_LIGHTUPDATES
qboolean SV_AddLightUpdate (edict_t *ent)
{
if (ent->v.modelindex != sv_lightningmodel)
if (ent->v->modelindex != sv_lightningmodel)
return false;
if (numlight == MAX_NAILS)
return true;
@ -172,11 +172,11 @@ void SV_EmitNailUpdate (sizebuf_t *msg, qboolean recorder)
for (n=0 ; n<numlight ; n++)
{
ent = light[n];
x = (int)(ent->v.origin[0]+4096)>>1;
y = (int)(ent->v.origin[1]+4096)>>1;
z = (int)(ent->v.origin[2]+4096)>>1;
p = (int)(16*ent->v.angles[0]/360)&15;
yaw = (int)(256*ent->v.angles[1]/360)&255;
x = (int)(ent->v->origin[0]+4096)>>1;
y = (int)(ent->v->origin[1]+4096)>>1;
z = (int)(ent->v->origin[2]+4096)>>1;
p = (int)(16*ent->v->angles[0]/360)&15;
yaw = (int)(256*ent->v->angles[1]/360)&255;
bits[0] = x;
bits[1] = (x>>8) | (y<<4);
@ -236,18 +236,18 @@ void SV_EmitNailUpdate (sizebuf_t *msg, qboolean recorder)
{
ent = nails[n];
if (recorder) {
if (!ent->v.colormap) {
if (!ent->v->colormap) {
if (!((++nailcount)&255)) nailcount++;
ent->v.colormap = nailcount&255;
ent->v->colormap = nailcount&255;
}
MSG_WriteByte (msg, (qbyte)ent->v.colormap);
MSG_WriteByte (msg, (qbyte)ent->v->colormap);
}
x = (int)(ent->v.origin[0]+4096)>>1;
y = (int)(ent->v.origin[1]+4096)>>1;
z = (int)(ent->v.origin[2]+4096)>>1;
p = (int)(16*ent->v.angles[0]/360)&15;
yaw = (int)(256*ent->v.angles[1]/360)&255;
x = (int)(ent->v->origin[0]+4096)>>1;
y = (int)(ent->v->origin[1]+4096)>>1;
z = (int)(ent->v->origin[2]+4096)>>1;
p = (int)(16*ent->v->angles[0]/360)&15;
yaw = (int)(256*ent->v->angles[1]/360)&255;
bits[0] = x;
bits[1] = (x>>8) | (y<<4);
@ -281,7 +281,7 @@ static qboolean SV_AddCSQCUpdate (client_t *client, edict_t *ent)
if (!(client->csqcactive))
return false;
if (!ent->v.SendEntity)
if (!ent->v->SendEntity)
return false;
csqcent[csqcnuments++] = ent;
@ -318,10 +318,10 @@ void SV_EmitCSQCUpdate(client_t *client, sizebuf_t *msg)
ent = csqcent[en];
//prevent mishaps with entities being respawned and things.
if ((int)ent->v.Version < sv.csqcentversion[ent->entnum])
ent->v.Version = sv.csqcentversion[ent->entnum];
if ((int)ent->v->Version < sv.csqcentversion[ent->entnum])
ent->v->Version = sv.csqcentversion[ent->entnum];
else
sv.csqcentversion[ent->entnum] = (int)ent->v.Version;
sv.csqcentversion[ent->entnum] = (int)ent->v->Version;
//If it's not changed, don't send
if (client->csqcentversions[ent->entnum] == sv.csqcentversion[ent->entnum])
@ -332,7 +332,7 @@ void SV_EmitCSQCUpdate(client_t *client, sizebuf_t *msg)
//Ask CSQC to write a buffer for it.
G_INT(OFS_PARM0) = EDICT_TO_PROG(svprogfuncs, client->edict);
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, ent);
PR_ExecuteProgram(svprogfuncs, ent->v.SendEntity);
PR_ExecuteProgram(svprogfuncs, ent->v->SendEntity);
if (G_INT(OFS_RETURN)) //0 means not to tell the client about it.
{
if (msg->cursize + csqcmsgbuffer.cursize+5 >= msg->maxsize)
@ -350,7 +350,7 @@ void SV_EmitCSQCUpdate(client_t *client, sizebuf_t *msg)
if (sv.csqcdebug) //optional extra.
{
if (!csqcmsgbuffer.cursize)
Con_Printf("Warning: empty csqc packet on %s\n", svprogfuncs->stringtable+ent->v.classname);
Con_Printf("Warning: empty csqc packet on %s\n", svprogfuncs->stringtable+ent->v->classname);
MSG_WriteShort(msg, csqcmsgbuffer.cursize);
}
//FIXME: Add a developer mode to write the length of each entity.
@ -1068,7 +1068,7 @@ void SV_AddEffect(client_t *to, edict_t *ent, int seefno)
{
if (ef->entnum == en && ef->efnum == 1<<seefno)
{
if (ef->colour != ent->v.seefcolour || ef->offset != ent->v.seefoffset || ef->size[0] != ent->v.seefsizex || ef->size[1] != ent->v.seefsizey || ef->size[2] != ent->v.seefsizez || ef->die < sv.time)
if (ef->colour != ent->v->seefcolour || ef->offset != ent->v->seefoffset || ef->size[0] != ent->v->seefsizex || ef->size[1] != ent->v->seefsizey || ef->size[2] != ent->v->seefsizez || ef->die < sv.time)
{
if (prev)
prev->next = ef->next;
@ -1089,17 +1089,17 @@ void SV_AddEffect(client_t *to, edict_t *ent, int seefno)
to->enteffects = ef;
ef->efnum = 1<<seefno;
ef->entnum = en;
ef->colour = ent->v.seefcolour;
ef->colour = ent->v->seefcolour;
if (!ef->colour)
ef->colour = 111;
ef->offset = ent->v.seefoffset;
ef->size[0] = ent->v.seefsizex;
ef->offset = ent->v->seefoffset;
ef->size[0] = ent->v->seefsizex;
if (!ef->size[0])
ef->offset = 64;
ef->size[1] = ent->v.seefsizey;
ef->size[1] = ent->v->seefsizey;
if (!ef->size[1])
ef->offset = 64;
ef->size[2] = ent->v.seefsizez;
ef->size[2] = ent->v->seefsizez;
if (!ef->size[2])
ef->offset = 64;
@ -1136,24 +1136,24 @@ void SV_SendExtraEntEffects(client_t *to, edict_t *ent)
{
if (progstype != PROG_QW)
{
if ((int)ent->v.effects & (EF_BRIGHTFIELD|EFNQ_DARKLIGHT|EFNQ_DARKFIELD|EFNQ_LIGHT) || to->enteffects)
if ((int)ent->v->effects & (EF_BRIGHTFIELD|EFNQ_DARKLIGHT|EFNQ_DARKFIELD|EFNQ_LIGHT) || to->enteffects)
{
if ((int)ent->v.effects & EF_BRIGHTFIELD)
if ((int)ent->v->effects & EF_BRIGHTFIELD)
SV_AddEffect(to, ent, SEEF_BRIGHTFIELD);
else
removeeffects |= 1<<SEEF_BRIGHTFIELD;
if ((int)ent->v.effects & EFNQ_DARKLIGHT)
if ((int)ent->v->effects & EFNQ_DARKLIGHT)
SV_AddEffect(to, ent, SEEF_DARKLIGHT);
else
removeeffects |= 1<<SEEF_DARKLIGHT;
if ((int)ent->v.effects & EFNQ_DARKFIELD)
if ((int)ent->v->effects & EFNQ_DARKFIELD)
SV_AddEffect(to, ent, SEEF_DARKFIELD);
else
removeeffects |= 1<<SEEF_DARKFIELD;
if ((int)ent->v.effects & EFNQ_LIGHT)
if ((int)ent->v->effects & EFNQ_LIGHT)
SV_AddEffect(to, ent, SEEF_LIGHT);
else
removeeffects |= 1<<SEEF_LIGHT;
@ -1161,24 +1161,24 @@ void SV_SendExtraEntEffects(client_t *to, edict_t *ent)
}
else
{
if ((int)ent->v.effects & (EF_BRIGHTFIELD|EFQW_DARKLIGHT|EFQW_DARKFIELD|EFQW_LIGHT) || to->enteffects)
if ((int)ent->v->effects & (EF_BRIGHTFIELD|EFQW_DARKLIGHT|EFQW_DARKFIELD|EFQW_LIGHT) || to->enteffects)
{
if ((int)ent->v.effects & EF_BRIGHTFIELD)
if ((int)ent->v->effects & EF_BRIGHTFIELD)
SV_AddEffect(to, ent, SEEF_BRIGHTFIELD);
else
removeeffects |= 1<<SEEF_BRIGHTFIELD;
if ((int)ent->v.effects & EFQW_DARKLIGHT)
if ((int)ent->v->effects & EFQW_DARKLIGHT)
SV_AddEffect(to, ent, SEEF_DARKLIGHT);
else
removeeffects |= 1<<SEEF_DARKLIGHT;
if ((int)ent->v.effects & EFQW_DARKFIELD)
if ((int)ent->v->effects & EFQW_DARKFIELD)
SV_AddEffect(to, ent, SEEF_DARKFIELD);
else
removeeffects |= 1<<SEEF_DARKFIELD;
if ((int)ent->v.effects & EFQW_LIGHT)
if ((int)ent->v->effects & EFQW_LIGHT)
SV_AddEffect(to, ent, SEEF_LIGHT);
else
removeeffects |= 1<<SEEF_LIGHT;
@ -1231,14 +1231,14 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
if (progstype != PROG_QW)
{
if ((int)ent->v.effects & EF_MUZZLEFLASH)
if ((int)ent->v->effects & EF_MUZZLEFLASH)
{
if (needcleanup < (j+1))
{
needcleanup = (j+1);
MSG_WriteByte(&sv.multicast, svc_muzzleflash);
MSG_WriteShort(&sv.multicast, (j+1));
SV_Multicast(ent->v.origin, MULTICAST_PVS);
SV_Multicast(ent->v->origin, MULTICAST_PVS);
}
}
}
@ -1248,15 +1248,15 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
dcl->parsecount = demo.parsecount;
VectorCopy(vent->v.origin, dcl->info.origin);
VectorCopy(vent->v.angles, dcl->info.angles);
VectorCopy(vent->v->origin, dcl->info.origin);
VectorCopy(vent->v->angles, dcl->info.angles);
dcl->info.angles[0] *= -3;
dcl->info.angles[2] = 0; // no roll angle
if (ent->v.health <= 0)
if (ent->v->health <= 0)
{ // don't show the corpse looking around...
dcl->info.angles[0] = 0;
dcl->info.angles[1] = vent->v.angles[1];
dcl->info.angles[1] = vent->v->angles[1];
dcl->info.angles[2] = 0;
}
@ -1267,21 +1267,21 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
}
else
{
dcl->info.skinnum = ent->v.skin;
dcl->info.effects = ent->v.effects;
dcl->info.weaponframe = ent->v.weaponframe;
dcl->info.model = ent->v.modelindex;
dcl->info.skinnum = ent->v->skin;
dcl->info.effects = ent->v->effects;
dcl->info.weaponframe = ent->v->weaponframe;
dcl->info.model = ent->v->modelindex;
}
dcl->sec = sv.time - cl->localtime;
dcl->frame = ent->v.frame;
dcl->frame = ent->v->frame;
dcl->flags = 0;
dcl->cmdtime = cl->localtime;
dcl->fixangle = demo.fixangle[j];
demo.fixangle[j] = 0;
if (ent->v.health <= 0)
if (ent->v->health <= 0)
dcl->flags |= DF_DEAD;
if (ent->v.mins[2] != -24)
if (ent->v->mins[2] != -24)
dcl->flags |= DF_GIB;
continue;
}
@ -1450,17 +1450,17 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
if (progstype != PROG_QW)
{
if (progstype == PROG_H2 && (int)ent->v.effects & EF_NODRAW && ent != clent)
if (progstype == PROG_H2 && (int)ent->v->effects & EF_NODRAW && ent != clent)
continue;
if ((int)ent->v.effects & EF_MUZZLEFLASH)
if ((int)ent->v->effects & EF_MUZZLEFLASH)
{
if (needcleanup < (j+1))
{
needcleanup = (j+1);
MSG_WriteByte(&sv.multicast, svc_muzzleflash);
MSG_WriteShort(&sv.multicast, (j+1));
SV_Multicast(ent->v.origin, MULTICAST_PVS);
SV_Multicast(ent->v->origin, MULTICAST_PVS);
}
}
}
@ -1481,7 +1481,7 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
continue; // not visible
}
if (!((int)clent->v.dimension_see & ((int)ent->v.dimension_seen | (int)ent->v.dimension_ghost)))
if (!((int)clent->v->dimension_see & ((int)ent->v->dimension_seen | (int)ent->v->dimension_ghost)))
continue; //not in this dimension - sorry...
}
@ -1491,43 +1491,43 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
{
clstate_t clst;
clst.playernum = j;
clst.onladder = (int)ent->v.fteflags&FF_LADDER;
clst.onladder = (int)ent->v->fteflags&FF_LADDER;
clst.lastcmd = &cl->lastcmd;
clst.modelindex = vent->v.modelindex;
clst.modelindex2 = vent->v.vweapmodelindex;
clst.frame = vent->v.frame;
clst.weaponframe = ent->v.weaponframe;
clst.angles = ent->v.angles;
clst.origin = vent->v.origin;
clst.velocity = vent->v.velocity;
clst.effects = ent->v.effects;
clst.modelindex = vent->v->modelindex;
clst.modelindex2 = vent->v->vweapmodelindex;
clst.frame = vent->v->frame;
clst.weaponframe = ent->v->weaponframe;
clst.angles = ent->v->angles;
clst.origin = vent->v->origin;
clst.velocity = vent->v->velocity;
clst.effects = ent->v->effects;
if (((int)vent->v.effects & EF_NODRAW) && progstype == PROG_H2)
if (((int)vent->v->effects & EF_NODRAW) && progstype == PROG_H2)
{
clst.effects = 0;
clst.modelindex = 0;
}
clst.skin = vent->v.skin;
clst.mins = vent->v.mins;
clst.hull = vent->v.hull;
clst.maxs = vent->v.maxs;
clst.scale = vent->v.scale;
clst.transparency = vent->v.alpha;
clst.skin = vent->v->skin;
clst.mins = vent->v->mins;
clst.hull = vent->v->hull;
clst.maxs = vent->v->maxs;
clst.scale = vent->v->scale;
clst.transparency = vent->v->alpha;
//QSG_DIMENSION_PLANES - if the only shared dimensions are ghost dimensions, Set half alpha.
if (((int)clent->v.dimension_see & (int)ent->v.dimension_ghost))
if (!((int)clent->v.dimension_see & ((int)ent->v.dimension_seen & ~(int)ent->v.dimension_ghost)) )
if (((int)clent->v->dimension_see & (int)ent->v->dimension_ghost))
if (!((int)clent->v->dimension_see & ((int)ent->v->dimension_seen & ~(int)ent->v->dimension_ghost)) )
{
if (ent->v.dimension_ghost_alpha)
clst.transparency *= ent->v.dimension_ghost_alpha;
if (ent->v->dimension_ghost_alpha)
clst.transparency *= ent->v->dimension_ghost_alpha;
else
clst.transparency *= 0.5;
}
clst.fatness = vent->v.fatness;
clst.fatness = vent->v->fatness;
clst.localtime = cl->localtime;
clst.health = ent->v.health;
clst.health = ent->v->health;
clst.spectator = 0;
clst.fteext = client->fteprotocolextensions;
clst.zext = client->zquake_extensions;
@ -1549,10 +1549,10 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
if (client->spec_track)
{
clst.spectator = 2;
clst.mins = svs.clients[client->spec_track-1].edict->v.mins;
clst.maxs = svs.clients[client->spec_track-1].edict->v.maxs;
clst.health = svs.clients[client->spec_track-1].edict->v.health;
clst.weaponframe = svs.clients[client->spec_track-1].edict->v.weaponframe;
clst.mins = svs.clients[client->spec_track-1].edict->v->mins;
clst.maxs = svs.clients[client->spec_track-1].edict->v->maxs;
clst.health = svs.clients[client->spec_track-1].edict->v->health;
clst.weaponframe = svs.clients[client->spec_track-1].edict->v->weaponframe;
}
else
{
@ -1580,10 +1580,10 @@ void SV_WritePlayersToClient (client_t *client, edict_t *clent, qbyte *pvs, size
//FIXME: Name flags
//player is visible, now would be a good time to update what the player is like.
pflags = 0;
if (client->fteprotocolextensions & PEXT_VWEAP && client->otherclientsknown[j].vweap != ent->v.vweapmodelindex)
if (client->fteprotocolextensions & PEXT_VWEAP && client->otherclientsknown[j].vweap != ent->v->vweapmodelindex)
{
pflags |= 1;
client->otherclientsknown[j].vweap = ent->v.vweapmodelindex;
client->otherclientsknown[j].vweap = ent->v->vweapmodelindex;
}
if (pflags)
{
@ -1650,7 +1650,7 @@ eval_t *val;
int glowsize, glowcolor;
if (ent->v.modelindex >= 256) //as much as protocols can handle
if (ent->v->modelindex >= 256) //as much as protocols can handle
return;
if (entnum >= 768) //too many for a conventional nq client.
@ -1658,38 +1658,38 @@ int glowsize, glowcolor;
for (i=0 ; i<3 ; i++)
{
miss = ent->v.origin[i] - ent->baseline.origin[i];
miss = ent->v->origin[i] - ent->baseline.origin[i];
if ( miss < -0.1 || miss > 0.1 )
bits |= NQU_ORIGIN1<<i;
}
if (ent->v.angles[0] != ent->baseline.angles[0] )
if (ent->v->angles[0] != ent->baseline.angles[0] )
bits |= NQU_ANGLE1;
if (ent->v.angles[1] != ent->baseline.angles[1] )
if (ent->v->angles[1] != ent->baseline.angles[1] )
bits |= NQU_ANGLE2;
if (ent->v.angles[2] != ent->baseline.angles[2] )
if (ent->v->angles[2] != ent->baseline.angles[2] )
bits |= NQU_ANGLE3;
if ((ent->v.movetype == MOVETYPE_STEP || (ent->v.movetype == MOVETYPE_PUSH)) && (bits & (U_ANGLE1|U_ANGLE2|U_ANGLE3)))
if ((ent->v->movetype == MOVETYPE_STEP || (ent->v->movetype == MOVETYPE_PUSH)) && (bits & (U_ANGLE1|U_ANGLE2|U_ANGLE3)))
bits |= NQU_NOLERP; // don't mess up the step animation
if (ent->baseline.colormap != ent->v.colormap && ent->v.colormap>=0)
if (ent->baseline.colormap != ent->v->colormap && ent->v->colormap>=0)
bits |= NQU_COLORMAP;
if (ent->baseline.skinnum != ent->v.skin)
if (ent->baseline.skinnum != ent->v->skin)
bits |= NQU_SKIN;
if (ent->baseline.frame != ent->v.frame)
if (ent->baseline.frame != ent->v->frame)
bits |= NQU_FRAME;
eff = ent->v.effects;
eff = ent->v->effects;
if ((ent->baseline.effects & 0x00ff) != ((int)eff & 0x00ff))
bits |= NQU_EFFECTS;
if (/*ent->baseline.modelindex !=*/ ent->v.modelindex)
if (/*ent->baseline.modelindex !=*/ ent->v->modelindex)
bits |= NQU_MODEL;
if (entnum >= 256)
@ -1698,10 +1698,10 @@ int glowsize, glowcolor;
// if (usedpextensions)
{
if (ent->baseline.trans != ent->v.alpha)
if (!(ent->baseline.trans == 1 && !ent->v.alpha))
if (ent->baseline.trans != ent->v->alpha)
if (!(ent->baseline.trans == 1 && !ent->v->alpha))
bits |= DPU_ALPHA;
if (ent->baseline.scale != ent->v.scale)
if (ent->baseline.scale != ent->v->scale)
bits |= DPU_SCALE;
if ((ent->baseline.effects&0xff00) != ((int)eff & 0xff00))
@ -1752,26 +1752,26 @@ int glowsize, glowcolor;
else
MSG_WriteByte (msg,entnum);
if (bits & NQU_MODEL) MSG_WriteByte (msg, ent->v.modelindex);
if (bits & NQU_FRAME) MSG_WriteByte (msg, ent->v.frame);
if (bits & NQU_COLORMAP) MSG_WriteByte (msg, ent->v.colormap);
if (bits & NQU_SKIN) MSG_WriteByte (msg, ent->v.skin);
if (bits & NQU_MODEL) MSG_WriteByte (msg, ent->v->modelindex);
if (bits & NQU_FRAME) MSG_WriteByte (msg, ent->v->frame);
if (bits & NQU_COLORMAP) MSG_WriteByte (msg, ent->v->colormap);
if (bits & NQU_SKIN) MSG_WriteByte (msg, ent->v->skin);
if (bits & NQU_EFFECTS) MSG_WriteByte (msg, eff & 0x00ff);
if (bits & NQU_ORIGIN1) MSG_WriteCoord (msg, ent->v.origin[0]);
if (bits & NQU_ANGLE1) MSG_WriteAngle(msg, ent->v.angles[0]);
if (bits & NQU_ORIGIN2) MSG_WriteCoord (msg, ent->v.origin[1]);
if (bits & NQU_ANGLE2) MSG_WriteAngle(msg, ent->v.angles[1]);
if (bits & NQU_ORIGIN3) MSG_WriteCoord (msg, ent->v.origin[2]);
if (bits & NQU_ANGLE3) MSG_WriteAngle(msg, ent->v.angles[2]);
if (bits & NQU_ORIGIN1) MSG_WriteCoord (msg, ent->v->origin[0]);
if (bits & NQU_ANGLE1) MSG_WriteAngle(msg, ent->v->angles[0]);
if (bits & NQU_ORIGIN2) MSG_WriteCoord (msg, ent->v->origin[1]);
if (bits & NQU_ANGLE2) MSG_WriteAngle(msg, ent->v->angles[1]);
if (bits & NQU_ORIGIN3) MSG_WriteCoord (msg, ent->v->origin[2]);
if (bits & NQU_ANGLE3) MSG_WriteAngle(msg, ent->v->angles[2]);
if (bits & DPU_ALPHA) MSG_WriteByte(msg, ent->v.alpha*255);
if (bits & DPU_SCALE) MSG_WriteByte(msg, ent->v.scale*16);
if (bits & DPU_ALPHA) MSG_WriteByte(msg, ent->v->alpha*255);
if (bits & DPU_SCALE) MSG_WriteByte(msg, ent->v->scale*16);
if (bits & DPU_EFFECTS2) MSG_WriteByte(msg, eff >> 8);
if (bits & DPU_GLOWSIZE) MSG_WriteByte(msg, glowsize);
if (bits & DPU_GLOWCOLOR) MSG_WriteByte(msg, glowcolor);
// if (bits & DPU_COLORMOD) MSG_WriteByte(msg, colormod);
if (bits & DPU_FRAME2) MSG_WriteByte(msg, (int)ent->v.frame >> 8);
if (bits & DPU_MODEL2) MSG_WriteByte(msg, (int)ent->v.modelindex >> 8);
if (bits & DPU_FRAME2) MSG_WriteByte(msg, (int)ent->v->frame >> 8);
if (bits & DPU_MODEL2) MSG_WriteByte(msg, (int)ent->v->modelindex >> 8);
}
typedef struct gibfilter_s {
@ -1843,8 +1843,8 @@ void SV_GibFilterInit(void)
}
qboolean SV_GibFilter(edict_t *ent)
{
int indx = ent->v.modelindex;
int frame = ent->v.frame;
int indx = ent->v->modelindex;
int frame = ent->v->frame;
gibfilter_t *gf;
for (gf = gibfilter; gf; gf=gf->next)
@ -1942,16 +1942,16 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
if (!ignorepvs)
{
clent = client->edict;
VectorAdd (clent->v.origin, clent->v.view_ofs, org);
VectorAdd (clent->v->origin, clent->v->view_ofs, org);
sv.worldmodel->funcs.FatPVS(org, false);
#ifdef PEXT_VIEW2
if (clent->v.view2)
sv.worldmodel->funcs.FatPVS(PROG_TO_EDICT(svprogfuncs, clent->v.view2)->v.origin, true);
if (clent->v->view2)
sv.worldmodel->funcs.FatPVS(PROG_TO_EDICT(svprogfuncs, clent->v->view2)->v->origin, true);
#endif
for (split = client->controlled; split; split = split->controlled)
sv.worldmodel->funcs.FatPVS(split->edict->v.origin, true);
sv.worldmodel->funcs.FatPVS(split->edict->v->origin, true);
/*
if (sv.worldmodel->fromgame == fg_doom)
{
@ -1972,11 +1972,11 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
SV_Q1BSP_FatPVS (org);
#ifdef PEXT_VIEW2
if (clent->v.view2)
SV_Q1BSP_AddToFatPVS (PROG_TO_EDICT(svprogfuncs, clent->v.view2)->v.origin, sv.worldmodel->nodes); //add a little more...
if (clent->v->view2)
SV_Q1BSP_AddToFatPVS (PROG_TO_EDICT(svprogfuncs, clent->v->view2)->v->origin, sv.worldmodel->nodes); //add a little more...
#endif
for (split = client->controlled; split; split = split->controlled)
SV_Q1BSP_AddToFatPVS (split->edict->v.origin, sv.worldmodel->nodes); //add a little more...
SV_Q1BSP_AddToFatPVS (split->edict->v->origin, sv.worldmodel->nodes); //add a little more...
}
*/
}
@ -2073,26 +2073,26 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
state->number = client - svs.clients + 1;
state->flags = 0;
VectorCopy (clent->v.origin, state->origin);
VectorCopy (clent->v.angles, state->angles);
state->modelindex = clent->v.modelindex;
state->frame = clent->v.frame;
state->colormap = clent->v.colormap;
state->skinnum = clent->v.skin;
state->effects = clent->v.effects;
state->drawflags = clent->v.drawflags;
state->abslight = clent->v.abslight;
VectorCopy (clent->v->origin, state->origin);
VectorCopy (clent->v->angles, state->angles);
state->modelindex = clent->v->modelindex;
state->frame = clent->v->frame;
state->colormap = clent->v->colormap;
state->skinnum = clent->v->skin;
state->effects = clent->v->effects;
state->drawflags = clent->v->drawflags;
state->abslight = clent->v->abslight;
#ifdef PEXT_SCALE
state->scale = clent->v.scale;
state->scale = clent->v->scale;
#endif
#ifdef PEXT_TRANS
state->trans = clent->v.alpha;
state->trans = clent->v->alpha;
if (!state->trans)
state->trans = 1;
#endif
#ifdef PEXT_FATNESS
state->fatness = clent->v.fatness;
state->fatness = clent->v->fatness;
#endif
if (state->effects & EF_FLAG1)
@ -2126,21 +2126,21 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
ent = EDICT_NUM(svprogfuncs, e);
// ignore ents without visible models
if (!ent->v.SendEntity && (!ent->v.modelindex || !*PR_GetString(svprogfuncs, ent->v.model)))
if (!ent->v->SendEntity && (!ent->v->modelindex || !*PR_GetString(svprogfuncs, ent->v->model)))
continue;
if (progstype != PROG_QW)
{
if (progstype == PROG_H2 && (int)ent->v.effects & EF_NODRAW)
if (progstype == PROG_H2 && (int)ent->v->effects & EF_NODRAW)
continue;
if ((int)ent->v.effects & EF_MUZZLEFLASH)
if ((int)ent->v->effects & EF_MUZZLEFLASH)
{
if (needcleanup < e)
{
needcleanup = e;
MSG_WriteByte(&sv.multicast, svc_muzzleflash);
MSG_WriteShort(&sv.multicast, e);
SV_Multicast(ent->v.origin, MULTICAST_PVS);
SV_Multicast(ent->v->origin, MULTICAST_PVS);
}
}
}
@ -2173,20 +2173,20 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
if (client->gibfilter && SV_GibFilter(ent))
continue;
// if (strstr(sv.model_precache[(int)ent->v.modelindex], "gib"))
// if (strstr(sv.model_precache[(int)ent->v->modelindex], "gib"))
// continue;
if (ent->v.nodrawtoclient) //DP extension.
if (ent->v.nodrawtoclient == EDICT_TO_PROG(svprogfuncs, client->edict))
if (ent->v->nodrawtoclient) //DP extension.
if (ent->v->nodrawtoclient == EDICT_TO_PROG(svprogfuncs, client->edict))
continue;
if (ent->v.drawonlytoclient)
if (ent->v.drawonlytoclient != EDICT_TO_PROG(svprogfuncs, client->edict))
if (ent->v->drawonlytoclient)
if (ent->v->drawonlytoclient != EDICT_TO_PROG(svprogfuncs, client->edict))
{
client_t *split;
for (split = client->controlled; split; split=split->controlled)
{
if (split->edict->v.view2 == EDICT_TO_PROG(svprogfuncs, ent))
if (split->edict->v->view2 == EDICT_TO_PROG(svprogfuncs, ent))
break;
}
if (!split)
@ -2195,7 +2195,7 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
//QSG_DIMENSION_PLANES
if (client->edict)
if (!((int)client->edict->v.dimension_see & ((int)ent->v.dimension_seen | (int)ent->v.dimension_ghost)))
if (!((int)client->edict->v->dimension_see & ((int)ent->v->dimension_seen | (int)ent->v->dimension_ghost)))
continue; //not in this dimension - sorry...
if (SV_AddCSQCUpdate(client, ent)) //csqc took it.
@ -2222,15 +2222,15 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
continue;
if (e >= 1024 && !(client->fteprotocolextensions & PEXT_ENTITYDBL2))
continue;
if (ent->v.modelindex >= 256 && !(client->fteprotocolextensions & PEXT_MODELDBL))
if (ent->v->modelindex >= 256 && !(client->fteprotocolextensions & PEXT_MODELDBL))
continue;
#ifdef DEPTHOPTIMISE
if (clent)
{
//find distance based upon absolute mins/maxs so bsps are treated fairly.
VectorAdd(ent->v.absmin, ent->v.absmax, org);
VectorMA(clent->v.origin, -0.5, org, org);
VectorAdd(ent->v->absmin, ent->v->absmax, org);
VectorMA(clent->v->origin, -0.5, org, org);
dist = Length(org);
// add to the packetentities
@ -2282,16 +2282,16 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
state->number = e;
state->flags = 0;
VectorCopy (ent->v.origin, state->origin);
VectorCopy (ent->v.angles, state->angles);
state->modelindex = ent->v.modelindex;
state->frame = ent->v.frame;
state->colormap = ent->v.colormap;
state->skinnum = ent->v.skin;
state->effects = ent->v.effects;
state->drawflags = ent->v.drawflags;
state->abslight = (int)(ent->v.abslight*255) & 255;
if ((int)ent->v.flags & FL_CLASS_DEPENDENT && client->playerclass)
VectorCopy (ent->v->origin, state->origin);
VectorCopy (ent->v->angles, state->angles);
state->modelindex = ent->v->modelindex;
state->frame = ent->v->frame;
state->colormap = ent->v->colormap;
state->skinnum = ent->v->skin;
state->effects = ent->v->effects;
state->drawflags = ent->v->drawflags;
state->abslight = (int)(ent->v->abslight*255) & 255;
if ((int)ent->v->flags & FL_CLASS_DEPENDENT && client->playerclass)
{
char modname[MAX_QPATH];
Q_strncpyz(modname, sv.model_precache[state->modelindex], sizeof(modname));
@ -2301,7 +2301,7 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
state->modelindex = SV_ModelIndex(modname);
}
}
if (progstype == PROG_H2 && ent->v.solid == SOLID_BSP)
if (progstype == PROG_H2 && ent->v->solid == SOLID_BSP)
state->angles[0]*=-1;
if (state->effects & EF_FULLBRIGHT)
@ -2313,26 +2313,26 @@ void SV_WriteEntitiesToClient (client_t *client, sizebuf_t *msg, qboolean ignore
state->effects &= EF_BRIGHTLIGHT | EF_DIMLIGHT;
#ifdef PEXT_SCALE
state->scale = ent->v.scale;
state->scale = ent->v->scale;
#endif
#ifdef PEXT_TRANS
state->trans = ent->v.alpha;
state->trans = ent->v->alpha;
if (!state->trans)
state->trans = 1;
//QSG_DIMENSION_PLANES - if the only shared dimensions are ghost dimensions, Set half alpha.
if (client->edict)
if (((int)client->edict->v.dimension_see & (int)ent->v.dimension_ghost))
if (!((int)client->edict->v.dimension_see & ((int)ent->v.dimension_seen & ~(int)ent->v.dimension_ghost)) )
if (((int)client->edict->v->dimension_see & (int)ent->v->dimension_ghost))
if (!((int)client->edict->v->dimension_see & ((int)ent->v->dimension_seen & ~(int)ent->v->dimension_ghost)) )
{
if (ent->v.dimension_ghost_alpha)
state->trans *= ent->v.dimension_ghost_alpha;
if (ent->v->dimension_ghost_alpha)
state->trans *= ent->v->dimension_ghost_alpha;
else
state->trans *= 0.5;
}
#endif
#ifdef PEXT_FATNESS
state->fatness = ent->v.fatness;
state->fatness = ent->v->fatness;
#endif
}
#ifdef NQPROT
@ -2370,8 +2370,8 @@ void SV_CleanupEnts(void)
for (e=1 ; e<=needcleanup ; e++)
{
ent = EDICT_NUM(svprogfuncs, e);
if ((int)ent->v.effects & EF_MUZZLEFLASH)
ent->v.effects = (int)ent->v.effects & ~EF_MUZZLEFLASH;
if ((int)ent->v->effects & EF_MUZZLEFLASH)
ent->v->effects = (int)ent->v->effects & ~EF_MUZZLEFLASH;
}
needcleanup=0;
}

42
engine/server/sv_init.c
View File

@ -143,16 +143,16 @@ baseline will be transmitted
continue;
// create baselines for all player slots,
// and any other edict that has a visible model
if (entnum > MAX_CLIENTS && !svent->v.modelindex)
if (entnum > MAX_CLIENTS && !svent->v->modelindex)
continue;
//
// create entity baseline
//
VectorCopy (svent->v.origin, svent->baseline.origin);
VectorCopy (svent->v.angles, svent->baseline.angles);
svent->baseline.frame = svent->v.frame;
svent->baseline.skinnum = svent->v.skin;
VectorCopy (svent->v->origin, svent->baseline.origin);
VectorCopy (svent->v->angles, svent->baseline.angles);
svent->baseline.frame = svent->v->frame;
svent->baseline.skinnum = svent->v->skin;
if (entnum > 0 && entnum <= MAX_CLIENTS)
{
svent->baseline.colormap = entnum;
@ -162,7 +162,7 @@ baseline will be transmitted
{
svent->baseline.colormap = 0;
svent->baseline.modelindex =
SV_ModelIndex(PR_GetString(svent->v.model))&255;
SV_ModelIndex(PR_GetString(svent->v->model))&255;
}
#ifdef PEXT_SCALE
svent->baseline.scale = 1;
@ -220,16 +220,16 @@ void SVNQ_CreateBaseline (void)
continue;
// create baselines for all player slots,
// and any other edict that has a visible model
if (entnum > sv.allocated_client_slots && !svent->v.modelindex)
if (entnum > sv.allocated_client_slots && !svent->v->modelindex)
continue;
//
// create entity baseline
//
VectorCopy (svent->v.origin, svent->baseline.origin);
VectorCopy (svent->v.angles, svent->baseline.angles);
svent->baseline.frame = svent->v.frame;
svent->baseline.skinnum = svent->v.skin;
VectorCopy (svent->v->origin, svent->baseline.origin);
VectorCopy (svent->v->angles, svent->baseline.angles);
svent->baseline.frame = svent->v->frame;
svent->baseline.skinnum = svent->v->skin;
if (entnum > 0 && entnum <= sv.allocated_client_slots)
{
if (entnum > 0 && entnum <= 16)
@ -243,7 +243,7 @@ void SVNQ_CreateBaseline (void)
{
svent->baseline.colormap = 0;
svent->baseline.modelindex =
SV_ModelIndex(PR_GetString(svprogfuncs, svent->v.model));
SV_ModelIndex(PR_GetString(svprogfuncs, svent->v->model));
}
svent->baseline.modelindex&=255;
}
@ -864,18 +864,18 @@ void SV_SpawnServer (char *server, char *startspot, qboolean noents, qboolean us
eval_t *eval;
ent = EDICT_NUM(svprogfuncs, 0);
ent->isfree = false;
ent->v.model = PR_SetString(svprogfuncs, sv.worldmodel->name);
ent->v.modelindex = 1; // world model
ent->v.solid = SOLID_BSP;
ent->v.movetype = MOVETYPE_PUSH;
ent->v->model = PR_SetString(svprogfuncs, sv.worldmodel->name);
ent->v->modelindex = 1; // world model
ent->v->solid = SOLID_BSP;
ent->v->movetype = MOVETYPE_PUSH;
if (progstype == PROG_QW && pr_imitatemvdsv.value>0)
{
ent->v.targetname = PR_SetString(svprogfuncs, "mvdsv");
ent->v->targetname = PR_SetString(svprogfuncs, "mvdsv");
s = DISTRIBUTIONLONG;
ent->v.netname = PR_NewString(svprogfuncs, va("%s %f %s, build %d\nBuild date: " __DATE__ ", " __TIME__ "", DISTRIBUTIONLONG, VERSION, PLATFORM, build_number()));
ent->v.impulse = 0;//QWE_VERNUM;
ent->v.items = 103;
ent->v->netname = PR_NewString(svprogfuncs, va("%s %f %s, build %d\nBuild date: " __DATE__ ", " __TIME__ "", DISTRIBUTIONLONG, VERSION, PLATFORM, build_number()));
ent->v->impulse = 0;//QWE_VERNUM;
ent->v->items = 103;
}
@ -1004,7 +1004,7 @@ void SV_SpawnServer (char *server, char *startspot, qboolean noents, qboolean us
{
eval_t *val;
ent = EDICT_NUM(svprogfuncs, 0);
ent->v.angles[0] = ent->v.angles[1] = ent->v.angles[2] = 0;
ent->v->angles[0] = ent->v->angles[1] = ent->v->angles[2] = 0;
val = svprogfuncs->GetEdictFieldValue(svprogfuncs, ent, "message", NULL);
if (val)
{

10
engine/server/sv_main.c
View File

@ -406,7 +406,7 @@ void SV_DropClient (client_t *drop)
drop->kills = 0;
drop->deaths = 0;
if (svprogfuncs && drop->edict)
drop->edict->v.frags = 0;
drop->edict->v->frags = 0;
drop->name[0] = 0;
memset (drop->userinfo, 0, sizeof(drop->userinfo));
@ -2711,7 +2711,7 @@ void SV_Impulse_f (void)
SetUpClientEdict(&svs.clients[i], svs.clients[i].edict);
svs.clients[i].edict->v.netname = PR_SetString(svprogfuncs, "Console");
svs.clients[i].edict->v->netname = PR_SetString(svprogfuncs, "Console");
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, pr_global_struct->ClientConnect);
@ -2723,16 +2723,16 @@ void SV_Impulse_f (void)
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, pr_global_struct->PlayerPreThink);
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, svs.clients[i].edict->v.think);
PR_ExecuteProgram (svprogfuncs, svs.clients[i].edict->v->think);
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, pr_global_struct->PlayerPostThink);
svs.clients[i].edict->v.impulse = atoi(Cmd_Argv(1));
svs.clients[i].edict->v->impulse = atoi(Cmd_Argv(1));
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, pr_global_struct->PlayerPreThink);
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, svs.clients[i].edict->v.think);
PR_ExecuteProgram (svprogfuncs, svs.clients[i].edict->v->think);
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, svs.clients[i].edict);
PR_ExecuteProgram (svprogfuncs, pr_global_struct->PlayerPostThink);

80
engine/server/sv_move.c
View File

@ -42,8 +42,8 @@ qboolean SV_CheckBottom (edict_t *ent)
int x, y;
float mid, bottom;
VectorAdd (ent->v.origin, ent->v.mins, mins);
VectorAdd (ent->v.origin, ent->v.maxs, maxs);
VectorAdd (ent->v->origin, ent->v->mins, mins);
VectorAdd (ent->v->origin, ent->v->maxs, maxs);
// if all of the points under the corners are solid world, don't bother
// with the tougher checks
@ -85,10 +85,10 @@ realcheck:
start[0] = stop[0] = x ? maxs[0] : mins[0];
start[1] = stop[1] = y ? maxs[1] : mins[1];
savedhull = ent->v.hull;
ent->v.hull = 0;
savedhull = ent->v->hull;
ent->v->hull = 0;
trace = SV_Move (start, vec3_origin, vec3_origin, stop, true, ent);
ent->v.hull = savedhull;
ent->v->hull = savedhull;
if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
bottom = trace.endpos[2];
@ -136,38 +136,38 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink, qboolean noene
edict_t *enemy = sv.edicts;
// try the move
VectorCopy (ent->v.origin, oldorg);
VectorAdd (ent->v.origin, move, neworg);
VectorCopy (ent->v->origin, oldorg);
VectorAdd (ent->v->origin, move, neworg);
// flying monsters don't step up
if ( (int)ent->v.flags & (FL_SWIM | FL_FLY) )
if ( (int)ent->v->flags & (FL_SWIM | FL_FLY) )
{
// try one move with vertical motion, then one without
for (i=0 ; i<2 ; i++)
{
VectorAdd (ent->v.origin, move, neworg);
VectorAdd (ent->v->origin, move, neworg);
if (!noenemy)
{
enemy = PROG_TO_EDICT(svprogfuncs, ent->v.enemy);
enemy = PROG_TO_EDICT(svprogfuncs, ent->v->enemy);
if (i == 0 && enemy != sv.edicts)
{
dz = ent->v.origin[2] - PROG_TO_EDICT(svprogfuncs, ent->v.enemy)->v.origin[2];
dz = ent->v->origin[2] - PROG_TO_EDICT(svprogfuncs, ent->v->enemy)->v->origin[2];
if (dz > 40)
neworg[2] -= 8;
if (dz < 30)
neworg[2] += 8;
}
}
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, neworg, false, ent);
trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, neworg, false, ent);
if (set_trace)
set_move_trace(&trace, set_trace);
if (trace.fraction == 1)
{
if ( ((int)ent->v.flags & FL_SWIM) && !(SV_PointContents(trace.endpos) & FTECONTENTS_FLUID))
if ( ((int)ent->v->flags & FL_SWIM) && !(SV_PointContents(trace.endpos) & FTECONTENTS_FLUID))
return false; // swim monster left water
VectorCopy (trace.endpos, ent->v.origin);
VectorCopy (trace.endpos, ent->v->origin);
if (relink)
SV_LinkEdict (ent, true);
return true;
@ -185,7 +185,7 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink, qboolean noene
VectorCopy (neworg, end);
end[2] -= pm_stepheight*2;
trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, false, ent);
trace = SV_Move (neworg, ent->v->mins, ent->v->maxs, end, false, ent);
if (set_trace)
set_move_trace(&trace, set_trace);
@ -195,7 +195,7 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink, qboolean noene
if (trace.startsolid)
{
neworg[2] -= pm_stepheight;
trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, false, ent);
trace = SV_Move (neworg, ent->v->mins, ent->v->maxs, end, false, ent);
if (set_trace)
set_move_trace(&trace, set_trace);
if (trace.allsolid || trace.startsolid)
@ -204,12 +204,12 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink, qboolean noene
if (trace.fraction == 1)
{
// if monster had the ground pulled out, go ahead and fall
if ( (int)ent->v.flags & FL_PARTIALGROUND )
if ( (int)ent->v->flags & FL_PARTIALGROUND )
{
VectorAdd (ent->v.origin, move, ent->v.origin);
VectorAdd (ent->v->origin, move, ent->v->origin);
if (relink)
SV_LinkEdict (ent, true);
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
// Con_Printf ("fall down\n");
return true;
}
@ -218,27 +218,27 @@ qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink, qboolean noene
}
// check point traces down for dangling corners
VectorCopy (trace.endpos, ent->v.origin);
VectorCopy (trace.endpos, ent->v->origin);
if (!SV_CheckBottom (ent))
{
if ( (int)ent->v.flags & FL_PARTIALGROUND )
if ( (int)ent->v->flags & FL_PARTIALGROUND )
{ // entity had floor mostly pulled out from underneath it
// and is trying to correct
if (relink)
SV_LinkEdict (ent, true);
return true;
}
VectorCopy (oldorg, ent->v.origin);
VectorCopy (oldorg, ent->v->origin);
return false;
}
if ( (int)ent->v.flags & FL_PARTIALGROUND )
if ( (int)ent->v->flags & FL_PARTIALGROUND )
{
// Con_Printf ("back on ground\n");
ent->v.flags = (int)ent->v.flags & ~FL_PARTIALGROUND;
ent->v->flags = (int)ent->v->flags & ~FL_PARTIALGROUND;
}
ent->v.groundentity = EDICT_TO_PROG(svprogfuncs, trace.ent);
ent->v->groundentity = EDICT_TO_PROG(svprogfuncs, trace.ent);
// the move is ok
if (relink)
@ -264,7 +264,7 @@ qboolean SV_StepDirection (edict_t *ent, float yaw, float dist, struct globalvar
vec3_t move, oldorigin;
float delta;
ent->v.ideal_yaw = yaw;
ent->v->ideal_yaw = yaw;
PF_changeyaw(svprogfuncs, pr_globals);
@ -273,13 +273,13 @@ qboolean SV_StepDirection (edict_t *ent, float yaw, float dist, struct globalvar
move[1] = sin(yaw)*dist;
move[2] = 0;
VectorCopy (ent->v.origin, oldorigin);
VectorCopy (ent->v->origin, oldorigin);
if (SV_movestep (ent, move, false, false, NULL))
{
delta = ent->v.angles[YAW] - ent->v.ideal_yaw;
delta = ent->v->angles[YAW] - ent->v->ideal_yaw;
if (delta > 45 && delta < 315)
{ // not turned far enough, so don't take the step
VectorCopy (oldorigin, ent->v.origin);
VectorCopy (oldorigin, ent->v->origin);
}
SV_LinkEdict (ent, true);
return true;
@ -299,7 +299,7 @@ void SV_FixCheckBottom (edict_t *ent)
{
// Con_Printf ("SV_FixCheckBottom\n");
ent->v.flags = (int)ent->v.flags | FL_PARTIALGROUND;
ent->v->flags = (int)ent->v->flags | FL_PARTIALGROUND;
}
@ -319,11 +319,11 @@ void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist, struct globalva
float d[3];
float tdir, olddir, turnaround;
olddir = anglemod( (int)(actor->v.ideal_yaw/45)*45 );
olddir = anglemod( (int)(actor->v->ideal_yaw/45)*45 );
turnaround = anglemod(olddir - 180);
deltax = enemy->v.origin[0] - actor->v.origin[0];
deltay = enemy->v.origin[1] - actor->v.origin[1];
deltax = enemy->v->origin[0] - actor->v->origin[0];
deltay = enemy->v->origin[1] - actor->v->origin[1];
if (deltax>10)
d[1]= 0;
else if (deltax<-10)
@ -386,7 +386,7 @@ void SV_NewChaseDir (edict_t *actor, edict_t *enemy, float dist, struct globalva
if (turnaround != DI_NODIR && NEWSV_StepDirection(actor, turnaround, dist, pr_globals) )
return;
actor->v.ideal_yaw = olddir; // can't move
actor->v->ideal_yaw = olddir; // can't move
// if a bridge was pulled out from underneath a monster, it may not have
// a valid standing position at all
@ -408,9 +408,9 @@ qboolean SV_CloseEnough (edict_t *ent, edict_t *goal, float dist)
for (i=0 ; i<3 ; i++)
{
if (goal->v.absmin[i] > ent->v.absmax[i] + dist)
if (goal->v->absmin[i] > ent->v->absmax[i] + dist)
return false;
if (goal->v.absmax[i] < ent->v.absmin[i] - dist)
if (goal->v->absmax[i] < ent->v->absmin[i] - dist)
return false;
}
return true;
@ -428,22 +428,22 @@ void SV_MoveToGoal (progfuncs_t *prinst, struct globalvars_s *pr_globals)
float dist;
ent = PROG_TO_EDICT(svprogfuncs, pr_global_struct->self);
goal = PROG_TO_EDICT(svprogfuncs, ent->v.goalentity);
goal = PROG_TO_EDICT(svprogfuncs, ent->v->goalentity);
dist = G_FLOAT(OFS_PARM0);
if ( !( (int)ent->v.flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
{
G_FLOAT(OFS_RETURN) = 0;
return;
}
// if the next step hits the enemy, return immediately
if ( PROG_TO_EDICT(svprogfuncs, ent->v.enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
if ( PROG_TO_EDICT(svprogfuncs, ent->v->enemy) != sv.edicts && SV_CloseEnough (ent, goal, dist) )
return;
// bump around...
if ( (rand()&3)==1 ||
!NEWSV_StepDirection (ent, ent->v.ideal_yaw, dist, pr_globals))
!NEWSV_StepDirection (ent, ent->v->ideal_yaw, dist, pr_globals))
{
SV_NewChaseDir (ent, goal, dist, pr_globals);
}

666
engine/server/sv_phys.c
View File

File diff suppressed because it is too large Load Diff

168
engine/server/sv_send.c
View File

@ -517,7 +517,7 @@ void SV_MulticastProtExt(vec3_t origin, multicast_t to, int dimension_mask, int
leafnum = CM_PointLeafnum (client->q2edict->s.origin);
else
#endif
leafnum = CM_PointLeafnum (client->edict->v.origin);
leafnum = CM_PointLeafnum (client->edict->v->origin);
cluster = CM_LeafCluster (leafnum);
area2 = CM_LeafArea (leafnum);
if (!CM_AreasConnected (area1, area2))
@ -605,17 +605,17 @@ void SV_MulticastProtExt(vec3_t origin, multicast_t to, int dimension_mask, int
}
if (svprogfuncs)
if (!((int)client->edict->v.dimension_see & dimension_mask))
if (!((int)client->edict->v->dimension_see & dimension_mask))
continue;
if (to == MULTICAST_PHS_R || to == MULTICAST_PHS) {
vec3_t delta;
VectorSubtract(origin, client->edict->v.origin, delta);
VectorSubtract(origin, client->edict->v->origin, delta);
if (Length(delta) <= 1024)
goto inrange;
}
leaf = Mod_PointInLeaf (client->edict->v.origin, sv.worldmodel);
leaf = Mod_PointInLeaf (client->edict->v->origin, sv.worldmodel);
if (leaf)
{
// -1 is because pvs rows are 1 based, not 0 based like leafs
@ -765,14 +765,14 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
channel |= SND_ATTENUATION;
// use the entity origin unless it is a bmodel
if (entity->v.solid == SOLID_BSP)
if (entity->v->solid == SOLID_BSP)
{
for (i=0 ; i<3 ; i++)
origin[i] = entity->v.origin[i]+0.5*(entity->v.mins[i]+entity->v.maxs[i]);
origin[i] = entity->v->origin[i]+0.5*(entity->v->mins[i]+entity->v->maxs[i]);
}
else
{
VectorCopy (entity->v.origin, origin);
VectorCopy (entity->v->origin, origin);
}
MSG_WriteByte (&sv.multicast, svc_sound);
@ -798,9 +798,9 @@ void SV_StartSound (edict_t *entity, int channel, char *sample, int volume,
MSG_WriteCoord (&sv.nqmulticast, origin[i]);
#endif
if (use_phs)
SV_MulticastProtExt(origin, reliable ? MULTICAST_PHS_R : MULTICAST_PHS, entity->v.dimension_seen, 0, 0);
SV_MulticastProtExt(origin, reliable ? MULTICAST_PHS_R : MULTICAST_PHS, entity->v->dimension_seen, 0, 0);
else
SV_MulticastProtExt(origin, reliable ? MULTICAST_ALL_R : MULTICAST_ALL, entity->v.dimension_seen, 0, 0);
SV_MulticastProtExt(origin, reliable ? MULTICAST_ALL_R : MULTICAST_ALL, entity->v->dimension_seen, 0, 0);
}
/*
@ -853,26 +853,26 @@ void SV_WriteEntityDataToMessage (client_t *client, sizebuf_t *msg, int pnum)
ent = client->edict;
// send a damage message if the player got hit this frame
if (ent->v.dmg_take || ent->v.dmg_save)
if (ent->v->dmg_take || ent->v->dmg_save)
{
other = PROG_TO_EDICT(svprogfuncs, ent->v.dmg_inflictor);
other = PROG_TO_EDICT(svprogfuncs, ent->v->dmg_inflictor);
if (pnum)
{
MSG_WriteByte(msg, svc_choosesplitclient);
MSG_WriteByte(msg, pnum);
}
MSG_WriteByte (msg, svc_damage);
MSG_WriteByte (msg, ent->v.dmg_save);
MSG_WriteByte (msg, ent->v.dmg_take);
MSG_WriteByte (msg, ent->v->dmg_save);
MSG_WriteByte (msg, ent->v->dmg_take);
for (i=0 ; i<3 ; i++)
MSG_WriteCoord (msg, other->v.origin[i] + 0.5*(other->v.mins[i] + other->v.maxs[i]));
MSG_WriteCoord (msg, other->v->origin[i] + 0.5*(other->v->mins[i] + other->v->maxs[i]));
ent->v.dmg_take = 0;
ent->v.dmg_save = 0;
ent->v->dmg_take = 0;
ent->v->dmg_save = 0;
}
// a fixangle might get lost in a dropped packet. Oh well.
if ( ent->v.fixangle )
if ( ent->v->fixangle )
{
if (pnum)
{
@ -881,8 +881,8 @@ void SV_WriteEntityDataToMessage (client_t *client, sizebuf_t *msg, int pnum)
}
MSG_WriteByte (msg, svc_setangle);
for (i=0 ; i < 3 ; i++)
MSG_WriteAngle (msg, ent->v.angles[i] );
ent->v.fixangle = 0;
MSG_WriteAngle (msg, ent->v->angles[i] );
ent->v->fixangle = 0;
}
}
@ -960,10 +960,10 @@ void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg)
#define SU_ARMOR (1<<13)
#define SU_WEAPON (1<<14)
if (ent->v.view_ofs[2] != DEFAULT_VIEWHEIGHT)
if (ent->v->view_ofs[2] != DEFAULT_VIEWHEIGHT)
bits |= SU_VIEWHEIGHT;
// if (ent->v.idealpitch)
// if (ent->v->idealpitch)
// bits |= SU_IDEALPITCH;
// stuff the sigil bits into the high bits of items for sbar, or else
@ -971,34 +971,34 @@ void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg)
// val = GetEdictFieldValue(ent, "items2", &items2cache);
// if (val)
// items = (int)ent->v.items | ((int)val->_float << 23);
// items = (int)ent->v->items | ((int)val->_float << 23);
// else
items = (int)ent->v.items | ((int)pr_global_struct->serverflags << 28);
items = (int)ent->v->items | ((int)pr_global_struct->serverflags << 28);
bits |= SU_ITEMS;
if ( (int)ent->v.flags & FL_ONGROUND)
if ( (int)ent->v->flags & FL_ONGROUND)
bits |= SU_ONGROUND;
if ( ent->v.waterlevel >= 2)
if ( ent->v->waterlevel >= 2)
bits |= SU_INWATER;
for (i=0 ; i<3 ; i++)
{
// if (ent->v.punchangle[i])
// if (ent->v->punchangle[i])
// bits |= (SU_PUNCH1<<i);
if (ent->v.velocity[i])
if (ent->v->velocity[i])
bits |= (SU_VELOCITY1<<i);
}
if (ent->v.weaponframe)
if (ent->v->weaponframe)
bits |= SU_WEAPONFRAME;
if (ent->v.armorvalue)
if (ent->v->armorvalue)
bits |= SU_ARMOR;
// if (ent->v.weapon)
// if (ent->v->weapon)
bits |= SU_WEAPON;
// send the data
@ -1007,55 +1007,55 @@ void SV_WriteClientdataToMessage (client_t *client, sizebuf_t *msg)
MSG_WriteShort (msg, bits);
if (bits & SU_VIEWHEIGHT)
MSG_WriteChar (msg, ent->v.view_ofs[2]);
MSG_WriteChar (msg, ent->v->view_ofs[2]);
// if (bits & SU_IDEALPITCH)
// MSG_WriteChar (msg, ent->v.idealpitch);
// MSG_WriteChar (msg, ent->v->idealpitch);
for (i=0 ; i<3 ; i++)
{
// if (bits & (SU_PUNCH1<<i))
// MSG_WriteChar (msg, ent->v.punchangle[i]);
// MSG_WriteChar (msg, ent->v->punchangle[i]);
if (bits & (SU_VELOCITY1<<i))
MSG_WriteChar (msg, ent->v.velocity[i]/16);
MSG_WriteChar (msg, ent->v->velocity[i]/16);
}
// [always sent] if (bits & SU_ITEMS)
MSG_WriteLong (msg, items);
if (bits & SU_WEAPONFRAME)
MSG_WriteByte (msg, ent->v.weaponframe);
MSG_WriteByte (msg, ent->v->weaponframe);
if (bits & SU_ARMOR)
{
if (ent->v.armorvalue>255)
if (ent->v->armorvalue>255)
MSG_WriteByte (msg, 255);
else
MSG_WriteByte (msg, ent->v.armorvalue);
MSG_WriteByte (msg, ent->v->armorvalue);
}
if (bits & SU_WEAPON)
MSG_WriteByte (msg, SV_ModelIndex(ent->v.weaponmodel + svprogfuncs->stringtable));
MSG_WriteByte (msg, SV_ModelIndex(ent->v->weaponmodel + svprogfuncs->stringtable));
MSG_WriteShort (msg, ent->v.health);
MSG_WriteByte (msg, ent->v.currentammo);
MSG_WriteByte (msg, ent->v.ammo_shells);
MSG_WriteByte (msg, ent->v.ammo_nails);
MSG_WriteByte (msg, ent->v.ammo_rockets);
MSG_WriteByte (msg, ent->v.ammo_cells);
MSG_WriteShort (msg, ent->v->health);
MSG_WriteByte (msg, ent->v->currentammo);
MSG_WriteByte (msg, ent->v->ammo_shells);
MSG_WriteByte (msg, ent->v->ammo_nails);
MSG_WriteByte (msg, ent->v->ammo_rockets);
MSG_WriteByte (msg, ent->v->ammo_cells);
//if (other && other->v.weapon)
//MSG_WriteByte (msg, other->v.weapon);
//if (other && other->v->weapon)
//MSG_WriteByte (msg, other->v->weapon);
//else
//{
if (standard_quake)
{
MSG_WriteByte (msg, ent->v.weapon);
MSG_WriteByte (msg, ent->v->weapon);
}
else
{
for(i=0;i<32;i++)
{
if ( ((int)ent->v.weapon) & (1<<i) )
if ( ((int)ent->v->weapon) & (1<<i) )
{
MSG_WriteByte (msg, i);
break;
@ -1158,27 +1158,27 @@ void SV_UpdateClientStats (client_t *client, int pnum)
if (client->spectator && client->spec_track > 0)
ent = svs.clients[client->spec_track - 1].edict;
stats[STAT_HEALTH] = ent->v.health;
stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v.weaponmodel));
stats[STAT_AMMO] = ent->v.currentammo;
stats[STAT_ARMOR] = ent->v.armorvalue;
stats[STAT_SHELLS] = ent->v.ammo_shells;
stats[STAT_NAILS] = ent->v.ammo_nails;
stats[STAT_ROCKETS] = ent->v.ammo_rockets;
stats[STAT_CELLS] = ent->v.ammo_cells;
stats[STAT_HEALTH] = ent->v->health;
stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v->weaponmodel));
stats[STAT_AMMO] = ent->v->currentammo;
stats[STAT_ARMOR] = ent->v->armorvalue;
stats[STAT_SHELLS] = ent->v->ammo_shells;
stats[STAT_NAILS] = ent->v->ammo_nails;
stats[STAT_ROCKETS] = ent->v->ammo_rockets;
stats[STAT_CELLS] = ent->v->ammo_cells;
if (!client->spectator)
stats[STAT_ACTIVEWEAPON] = ent->v.weapon;
stats[STAT_ACTIVEWEAPON] = ent->v->weapon;
// stuff the sigil bits into the high bits of items for sbar
if (pr_items2)
stats[STAT_ITEMS] = (int)ent->v.items | ((int)ent->v.items2 << 23);
stats[STAT_ITEMS] = (int)ent->v->items | ((int)ent->v->items2 << 23);
else
stats[STAT_ITEMS] = (int)ent->v.items | ((int)pr_global_struct->serverflags << 28);
stats[STAT_ITEMS] = (int)ent->v->items | ((int)pr_global_struct->serverflags << 28);
stats[STAT_VIEWHEIGHT] = ent->v.view_ofs[2];
stats[STAT_VIEWHEIGHT] = ent->v->view_ofs[2];
#ifdef PEXT_VIEW2
if (ent->v.view2)
stats[STAT_VIEW2] = NUM_FOR_EDICT(svprogfuncs, PROG_TO_EDICT(svprogfuncs, ent->v.view2));
if (ent->v->view2)
stats[STAT_VIEW2] = NUM_FOR_EDICT(svprogfuncs, PROG_TO_EDICT(svprogfuncs, ent->v->view2));
else
stats[STAT_VIEW2] = 0;
#endif
@ -1381,7 +1381,7 @@ void SV_UpdateToReliableMessages (void)
{
if (!host_client->state && host_client->name[0]) //if this is a bot
{
if (host_client->old_frags != (int)host_client->edict->v.frags)
if (host_client->old_frags != (int)host_client->edict->v->frags)
{
for (j=0, client = svs.clients ; j<MAX_CLIENTS ; j++, client++)
{
@ -1389,7 +1389,7 @@ void SV_UpdateToReliableMessages (void)
continue;
ClientReliableWrite_Begin(client, svc_updatefrags, 4);
ClientReliableWrite_Byte(client, i);
ClientReliableWrite_Short(client, host_client->edict->v.frags);
ClientReliableWrite_Short(client, host_client->edict->v->frags);
}
if (sv.mvdrecording)
@ -1397,10 +1397,10 @@ void SV_UpdateToReliableMessages (void)
MVDWrite_Begin(dem_all, 0, 4);
MSG_WriteByte((sizebuf_t*)demo.dbuf, svc_updatefrags);
MSG_WriteByte((sizebuf_t*)demo.dbuf, i);
MSG_WriteShort((sizebuf_t*)demo.dbuf, host_client->edict->v.frags);
MSG_WriteShort((sizebuf_t*)demo.dbuf, host_client->edict->v->frags);
}
host_client->old_frags = host_client->edict->v.frags;
host_client->old_frags = host_client->edict->v->frags;
}
}
continue;
@ -1412,7 +1412,7 @@ void SV_UpdateToReliableMessages (void)
host_client->sendinfo = false;
SV_FullClientUpdate (host_client, &sv.reliable_datagram);
}
if (host_client->old_frags != (int)host_client->edict->v.frags)
if (host_client->old_frags != (int)host_client->edict->v->frags)
{
for (j=0, client = svs.clients ; j<MAX_CLIENTS ; j++, client++)
{
@ -1422,7 +1422,7 @@ void SV_UpdateToReliableMessages (void)
continue;
ClientReliableWrite_Begin(client, svc_updatefrags, 4);
ClientReliableWrite_Byte(client, i);
ClientReliableWrite_Short(client, host_client->edict->v.frags);
ClientReliableWrite_Short(client, host_client->edict->v->frags);
}
if (sv.mvdrecording)
@ -1430,10 +1430,10 @@ void SV_UpdateToReliableMessages (void)
MVDWrite_Begin(dem_all, 0, 4);
MSG_WriteByte((sizebuf_t*)demo.dbuf, svc_updatefrags);
MSG_WriteByte((sizebuf_t*)demo.dbuf, i);
MSG_WriteShort((sizebuf_t*)demo.dbuf, host_client->edict->v.frags);
MSG_WriteShort((sizebuf_t*)demo.dbuf, host_client->edict->v->frags);
}
host_client->old_frags = host_client->edict->v.frags;
host_client->old_frags = host_client->edict->v->frags;
}
}
@ -1443,7 +1443,7 @@ void SV_UpdateToReliableMessages (void)
// maxspeed/entgravity changes
ent = host_client->edict;
newval = ent->v.gravity*sv_gravity.value;
newval = ent->v->gravity*sv_gravity.value;
if (progstype == PROG_NQ)
{
if (!newval)
@ -1456,14 +1456,14 @@ void SV_UpdateToReliableMessages (void)
ClientReliableWrite_Float(sp, newval/movevars.gravity); //lie to the client in a cunning way
host_client->entgravity = newval;
}
newval = ent->v.maxspeed;
newval = ent->v->maxspeed;
if (progstype == PROG_NQ)
{
if (!newval)
newval = sv_maxspeed.value;
}
if (ent->v.hasted)
newval*=ent->v.hasted;
if (ent->v->hasted)
newval*=ent->v->hasted;
#ifdef SVCHAT //enforce a no moving time when chatting. Prevent client prediction going mad.
if (host_client->chat.active)
newval = 0;
@ -1781,19 +1781,19 @@ void SV_SendMVDMessage(void)
ent = c->edict;
memset (stats, 0, sizeof(stats));
stats[STAT_HEALTH] = ent->v.health;
stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v.weaponmodel));
stats[STAT_AMMO] = ent->v.currentammo;
stats[STAT_ARMOR] = ent->v.armorvalue;
stats[STAT_SHELLS] = ent->v.ammo_shells;
stats[STAT_NAILS] = ent->v.ammo_nails;
stats[STAT_ROCKETS] = ent->v.ammo_rockets;
stats[STAT_CELLS] = ent->v.ammo_cells;
stats[STAT_ACTIVEWEAPON] = ent->v.weapon;
stats[STAT_HEALTH] = ent->v->health;
stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v->weaponmodel));
stats[STAT_AMMO] = ent->v->currentammo;
stats[STAT_ARMOR] = ent->v->armorvalue;
stats[STAT_SHELLS] = ent->v->ammo_shells;
stats[STAT_NAILS] = ent->v->ammo_nails;
stats[STAT_ROCKETS] = ent->v->ammo_rockets;
stats[STAT_CELLS] = ent->v->ammo_cells;
stats[STAT_ACTIVEWEAPON] = ent->v->weapon;
// stuff the sigil bits into the high bits of items for sbar
stats[STAT_ITEMS] = (int)ent->v.items | ((int)pr_global_struct->serverflags << 28);
stats[STAT_ITEMS] = (int)ent->v->items | ((int)pr_global_struct->serverflags << 28);
for (j=0 ; j<MAX_QW_STATS ; j++)
if (stats[j] != demo.stats[i][j])

478
engine/server/sv_user.c
View File

File diff suppressed because it is too large Load Diff

220
engine/server/world.c
View File

@ -139,12 +139,12 @@ hull_t *SV_HullForEntity (edict_t *ent, int hullnum, vec3_t mins, vec3_t maxs, v
hull_t *hull;
// decide which clipping hull to use, based on the size
if (ent->v.solid == SOLID_BSP)
if (ent->v->solid == SOLID_BSP)
{ // explicit hulls in the BSP model
if (ent->v.movetype != MOVETYPE_PUSH)
SV_Error ("SOLID_BSP without MOVETYPE_PUSH (%s)", ent->v.classname + svprogfuncs->stringtable);
if (ent->v->movetype != MOVETYPE_PUSH)
SV_Error ("SOLID_BSP without MOVETYPE_PUSH (%s)", ent->v->classname + svprogfuncs->stringtable);
model = sv.models[ (int)ent->v.modelindex ];
model = sv.models[ (int)ent->v->modelindex ];
if (!model || model->type != mod_brush)
SV_Error ("SOLID_BSP with a non bsp model");
@ -183,16 +183,16 @@ hull_t *SV_HullForEntity (edict_t *ent, int hullnum, vec3_t mins, vec3_t maxs, v
// calculate an offset value to center the origin
VectorSubtract (hull->clip_mins, mins, offset);
VectorAdd (offset, ent->v.origin, offset);
VectorAdd (offset, ent->v->origin, offset);
}
else
{ // create a temp hull from bounding box sizes
VectorSubtract (ent->v.mins, maxs, hullmins);
VectorSubtract (ent->v.maxs, mins, hullmaxs);
VectorSubtract (ent->v->mins, maxs, hullmins);
VectorSubtract (ent->v->maxs, mins, hullmaxs);
hull = SV_HullForBox (hullmins, hullmaxs);
VectorCopy (ent->v.origin, offset);
VectorCopy (ent->v->origin, offset);
}
@ -374,18 +374,18 @@ void SV_TouchLinks ( edict_t *ent, areanode_t *node )
if (touch == ent)
continue;
if (!touch->v.touch || touch->v.solid != SOLID_TRIGGER)
if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
continue;
if (ent->v.absmin[0] > touch->v.absmax[0]
|| ent->v.absmin[1] > touch->v.absmax[1]
|| ent->v.absmin[2] > touch->v.absmax[2]
|| ent->v.absmax[0] < touch->v.absmin[0]
|| ent->v.absmax[1] < touch->v.absmin[1]
|| ent->v.absmax[2] < touch->v.absmin[2] )
if (ent->v->absmin[0] > touch->v->absmax[0]
|| ent->v->absmin[1] > touch->v->absmax[1]
|| ent->v->absmin[2] > touch->v->absmax[2]
|| ent->v->absmax[0] < touch->v->absmin[0]
|| ent->v->absmax[1] < touch->v->absmin[1]
|| ent->v->absmax[2] < touch->v->absmin[2] )
continue;
if (!((int)ent->v.dimension_solid & (int)touch->v.dimension_hit))
if (!((int)ent->v->dimension_solid & (int)touch->v->dimension_hit))
continue;
nodelinks[linkcount++] = touch;
@ -402,23 +402,23 @@ void SV_TouchLinks ( edict_t *ent, areanode_t *node )
//make sure nothing moved it away
if (touch->isfree)
continue;
if (!touch->v.touch || touch->v.solid != SOLID_TRIGGER)
if (!touch->v->touch || touch->v->solid != SOLID_TRIGGER)
continue;
if (ent->v.absmin[0] > touch->v.absmax[0]
|| ent->v.absmin[1] > touch->v.absmax[1]
|| ent->v.absmin[2] > touch->v.absmax[2]
|| ent->v.absmax[0] < touch->v.absmin[0]
|| ent->v.absmax[1] < touch->v.absmin[1]
|| ent->v.absmax[2] < touch->v.absmin[2] )
if (ent->v->absmin[0] > touch->v->absmax[0]
|| ent->v->absmin[1] > touch->v->absmax[1]
|| ent->v->absmin[2] > touch->v->absmax[2]
|| ent->v->absmax[0] < touch->v->absmin[0]
|| ent->v->absmax[1] < touch->v->absmin[1]
|| ent->v->absmax[2] < touch->v->absmin[2] )
continue;
if (!((int)ent->v.dimension_solid & (int)touch->v.dimension_hit)) //didn't change did it?...
if (!((int)ent->v->dimension_solid & (int)touch->v->dimension_hit)) //didn't change did it?...
continue;
pr_global_struct->self = EDICT_TO_PROG(svprogfuncs, touch);
pr_global_struct->other = EDICT_TO_PROG(svprogfuncs, ent);
pr_global_struct->time = sv.time;
PR_ExecuteProgram (svprogfuncs, touch->v.touch);
PR_ExecuteProgram (svprogfuncs, touch->v->touch);
if (ent->isfree)
break;
@ -431,9 +431,9 @@ void SV_TouchLinks ( edict_t *ent, areanode_t *node )
if (node->axis == -1 || ent->isfree)
return;
if ( ent->v.absmax[node->axis] > node->dist )
if ( ent->v->absmax[node->axis] > node->dist )
SV_TouchLinks ( ent, node->children[0] );
if ( ent->v.absmin[node->axis] < node->dist )
if ( ent->v->absmin[node->axis] < node->dist )
SV_TouchLinks ( ent, node->children[1] );
}
@ -454,7 +454,7 @@ void Q2BSP_FindTouchedLeafs(edict_t *ent)
ent->areanum2 = 0;
//get all leafs, including solids
num_leafs = CM_BoxLeafnums (ent->v.absmin, ent->v.absmax,
num_leafs = CM_BoxLeafnums (ent->v->absmin, ent->v->absmax,
leafs, MAX_TOTAL_ENT_LEAFS, &topnode);
// set areas
@ -469,7 +469,7 @@ void Q2BSP_FindTouchedLeafs(edict_t *ent)
{
if (ent->areanum2 && ent->areanum2 != area && sv.state == ss_loading)
Con_DPrintf ("Object touching 3 areas at %f %f %f\n",
ent->v.absmin[0], ent->v.absmin[1], ent->v.absmin[2]);
ent->v->absmin[0], ent->v->absmin[1], ent->v->absmin[2]);
ent->areanum2 = area;
}
else
@ -521,7 +521,7 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
if (ent->area.prev)
SV_UnlinkEdict (ent); // unlink from old position
ent->solidtype = ent->v.solid;
ent->solidtype = ent->v->solid;
if (ent == sv.edicts)
return; // don't add the world
@ -530,8 +530,8 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
return;
// set the abs box
if (ent->v.solid == SOLID_BSP &&
(ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )
if (ent->v->solid == SOLID_BSP &&
(ent->v->angles[0] || ent->v->angles[1] || ent->v->angles[2]) )
{ // expand for rotation
int i;
@ -542,60 +542,60 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
if (progstype == PROG_H2)
{
ent->v.angles[0]*=-1;
AngleVectors(ent->v.angles, f,r,u);
ent->v.angles[0]*=-1;
ent->v->angles[0]*=-1;
AngleVectors(ent->v->angles, f,r,u);
ent->v->angles[0]*=-1;
}
else
AngleVectors(ent->v.angles, f,r,u);
AngleVectors(ent->v->angles, f,r,u);
mn[0] = DotProduct(ent->v.mins, f);
mn[1] = -DotProduct(ent->v.mins, r);
mn[2] = DotProduct(ent->v.mins, u);
mn[0] = DotProduct(ent->v->mins, f);
mn[1] = -DotProduct(ent->v->mins, r);
mn[2] = DotProduct(ent->v->mins, u);
mx[0] = DotProduct(ent->v.maxs, f);
mx[1] = -DotProduct(ent->v.maxs, r);
mx[2] = DotProduct(ent->v.maxs, u);
mx[0] = DotProduct(ent->v->maxs, f);
mx[1] = -DotProduct(ent->v->maxs, r);
mx[2] = DotProduct(ent->v->maxs, u);
for (i = 0; i < 3; i++)
{
if (mn[i] < mx[i])
{
ent->v.absmin[i] = ent->v.origin[i]+mn[i]-0.1;
ent->v.absmax[i] = ent->v.origin[i]+mx[i]+0.1;
ent->v->absmin[i] = ent->v->origin[i]+mn[i]-0.1;
ent->v->absmax[i] = ent->v->origin[i]+mx[i]+0.1;
}
else
{ //box went inside out
ent->v.absmin[i] = ent->v.origin[i]+mx[i]-0.1;
ent->v.absmax[i] = ent->v.origin[i]+mn[i]+0.1;
ent->v->absmin[i] = ent->v->origin[i]+mx[i]-0.1;
ent->v->absmax[i] = ent->v->origin[i]+mn[i]+0.1;
}
}
}
else
{
VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
VectorAdd (ent->v->origin, ent->v->mins, ent->v->absmin);
VectorAdd (ent->v->origin, ent->v->maxs, ent->v->absmax);
}
//
// to make items easier to pick up and allow them to be grabbed off
// of shelves, the abs sizes are expanded
//
if ((int)ent->v.flags & FL_ITEM)
if ((int)ent->v->flags & FL_ITEM)
{
ent->v.absmin[0] -= 15;
ent->v.absmin[1] -= 15;
ent->v.absmax[0] += 15;
ent->v.absmax[1] += 15;
ent->v->absmin[0] -= 15;
ent->v->absmin[1] -= 15;
ent->v->absmax[0] += 15;
ent->v->absmax[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
ent->v.absmin[0] -= 1;
ent->v.absmin[1] -= 1;
ent->v.absmin[2] -= 1;
ent->v.absmax[0] += 1;
ent->v.absmax[1] += 1;
ent->v.absmax[2] += 1;
ent->v->absmin[0] -= 1;
ent->v->absmin[1] -= 1;
ent->v->absmin[2] -= 1;
ent->v->absmax[0] += 1;
ent->v->absmax[1] += 1;
ent->v->absmax[2] += 1;
}
// link to PVS leafs
@ -613,7 +613,7 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
Q1BSP_FindTouchedLeafs(ent);
*/
if (ent->v.solid == SOLID_NOT)
if (ent->v->solid == SOLID_NOT)
return;
// find the first node that the ent's box crosses
@ -622,9 +622,9 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
{
if (node->axis == -1)
break;
if (ent->v.absmin[node->axis] > node->dist)
if (ent->v->absmin[node->axis] > node->dist)
node = node->children[0];
else if (ent->v.absmax[node->axis] < node->dist)
else if (ent->v->absmax[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
@ -632,7 +632,7 @@ void SV_LinkEdict (edict_t *ent, qboolean touch_triggers)
// link it in
if (ent->v.solid == SOLID_TRIGGER || ent->v.solid == SOLID_LADDER)
if (ent->v->solid == SOLID_TRIGGER || ent->v->solid == SOLID_LADDER)
InsertLinkBefore (&ent->area, &node->trigger_edicts);
else
InsertLinkBefore (&ent->area, &node->solid_edicts);
@ -1048,7 +1048,7 @@ edict_t *SV_TestEntityPosition (edict_t *ent)
{
trace_t trace;
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, ent->v.origin, 0, ent);
trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, ent->v->origin, 0, ent);
if (trace.startsolid)
return sv.edicts;
@ -1123,10 +1123,10 @@ trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t max
#ifdef Q2BSPS
if (ent->v.solid == SOLID_BSP)
if (sv.models[(int)ent->v.modelindex] && (sv.models[(int)ent->v.modelindex]->fromgame == fg_quake2 || sv.models[(int)ent->v.modelindex]->fromgame == fg_quake3))
if (ent->v->solid == SOLID_BSP)
if (sv.models[(int)ent->v->modelindex] && (sv.models[(int)ent->v->modelindex]->fromgame == fg_quake2 || sv.models[(int)ent->v->modelindex]->fromgame == fg_quake3))
{
trace = CM_TransformedBoxTrace (start, end, mins, maxs, sv.models[(int)ent->v.modelindex]->hulls[0].firstclipnode, MASK_PLAYERSOLID, ent->v.origin, ent->v.angles);
trace = CM_TransformedBoxTrace (start, end, mins, maxs, sv.models[(int)ent->v->modelindex]->hulls[0].firstclipnode, MASK_PLAYERSOLID, ent->v->origin, ent->v->angles);
if (trace.fraction < 1 || trace.startsolid )
trace.ent = ent;
return trace;
@ -1147,15 +1147,15 @@ trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t max
VectorSubtract (end, offset, end_l);
// trace a line through the apropriate clipping hull
if (progstype == PROG_H2 && ent->v.solid == SOLID_BSP)
if (progstype == PROG_H2 && ent->v->solid == SOLID_BSP)
{
ent->v.angles[0]*=-1;
TransformedHullCheck(hull, start_l, end_l, &trace, ent->v.angles);
ent->v.angles[0]*=-1;
ent->v->angles[0]*=-1;
TransformedHullCheck(hull, start_l, end_l, &trace, ent->v->angles);
ent->v->angles[0]*=-1;
}
else
{
TransformedHullCheck(hull, start_l, end_l, &trace, ent->v.angles);
TransformedHullCheck(hull, start_l, end_l, &trace, ent->v->angles);
}
// fix trace up by the offset
@ -1243,14 +1243,14 @@ void SV_AreaEdicts_r (areanode_t *node)
next = l->next;
check = EDICT_FROM_AREA(l);
if (check->v.solid == SOLID_NOT)
if (check->v->solid == SOLID_NOT)
continue; // deactivated
if (check->v.absmin[0] > area_maxs[0]
|| check->v.absmin[1] > area_maxs[1]
|| check->v.absmin[2] > area_maxs[2]
|| check->v.absmax[0] < area_mins[0]
|| check->v.absmax[1] < area_mins[1]
|| check->v.absmax[2] < area_mins[2])
if (check->v->absmin[0] > area_maxs[0]
|| check->v->absmin[1] > area_maxs[1]
|| check->v->absmin[2] > area_maxs[2]
|| check->v->absmax[0] < area_mins[0]
|| check->v->absmax[1] < area_mins[1]
|| check->v->absmax[2] < area_mins[2])
continue; // not touching
if (area_count == area_maxcount)
@ -1384,9 +1384,9 @@ int SV_HeadnodeForEntity (edict_t *ent)
model_t *model;
// decide which clipping hull to use, based on the size
if (ent->v.solid == SOLID_BSP)
if (ent->v->solid == SOLID_BSP)
{ // explicit hulls in the BSP model
model = sv.models[ (int)ent->v.modelindex ];
model = sv.models[ (int)ent->v->modelindex ];
if (!model)
SV_Error ("MOVETYPE_PUSH with a non bsp model");
@ -1396,7 +1396,7 @@ int SV_HeadnodeForEntity (edict_t *ent)
// create a temp hull from bounding box sizes
return CM_HeadnodeForBox (ent->v.mins, ent->v.maxs);
return CM_HeadnodeForBox (ent->v->mins, ent->v->maxs);
}
#ifdef Q2SERVER
@ -1439,7 +1439,7 @@ void SV_ClipMoveToEntities ( moveclip_t *clip )
for (i=0 ; i<num ; i++)
{
touch = touchlist[i];
if (touch->v.solid == SOLID_NOT)
if (touch->v->solid == SOLID_NOT)
continue;
if (touch == clip->passedict)
continue;
@ -1447,23 +1447,23 @@ void SV_ClipMoveToEntities ( moveclip_t *clip )
return;
if (clip->passedict)
{
if (touch->v.owner == passed)
if (touch->v->owner == passed)
continue; // don't clip against own missiles
if (clip->passedict->v.owner == EDICT_TO_PROG(svprogfuncs, touch))
if (clip->passedict->v->owner == EDICT_TO_PROG(svprogfuncs, touch))
continue; // don't clip against owner
}
if (clip->type & MOVE_NOMONSTERS && touch->v.solid != SOLID_BSP)
if (clip->type & MOVE_NOMONSTERS && touch->v->solid != SOLID_BSP)
continue;
// don't clip corpse against character
if (clip->passedict->v.solid == SOLID_CORPSE && (touch->v.solid == SOLID_SLIDEBOX || touch->v.solid == SOLID_CORPSE))
if (clip->passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
continue;
// don't clip character against corpse
if (clip->passedict->v.solid == SOLID_SLIDEBOX && touch->v.solid == SOLID_CORPSE)
if (clip->passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
continue;
if (!((int)clip->passedict->v.dimension_hit & (int)touch->v.dimension_solid))
if (!((int)clip->passedict->v->dimension_hit & (int)touch->v->dimension_solid))
continue;
// if ( !(clip->contentmask & CONTENTS_DEADMONSTER)
@ -1472,8 +1472,8 @@ void SV_ClipMoveToEntities ( moveclip_t *clip )
// might intersect, so do an exact clip
headnode = SV_HeadnodeForEntity (touch);
angles = touch->v.angles;
if (touch->v.solid != SOLID_BSP)
angles = touch->v->angles;
if (touch->v->solid != SOLID_BSP)
angles = vec3_origin; // boxes don't rotate
/* if (touch->svflags & SVF_MONSTER)
@ -1483,7 +1483,7 @@ void SV_ClipMoveToEntities ( moveclip_t *clip )
else
*/ trace = CM_TransformedBoxTrace (clip->start, clip->end,
clip->mins, clip->maxs, headnode, MASK_PLAYERSOLID,
touch->v.origin, angles);
touch->v->origin, angles);
if (trace.allsolid || trace.startsolid ||
trace.fraction < clip->trace.fraction)
@ -1590,35 +1590,35 @@ void SV_ClipToLinks ( areanode_t *node, moveclip_t *clip )
{
next = l->next;
touch = EDICT_FROM_AREA(l);
if (touch->v.solid == SOLID_NOT)
if (touch->v->solid == SOLID_NOT)
continue;
if (touch == clip->passedict)
continue;
if (touch->v.solid == SOLID_TRIGGER || touch->v.solid == SOLID_LADDER)
if (touch->v->solid == SOLID_TRIGGER || touch->v->solid == SOLID_LADDER)
SV_Error ("Trigger in clipping list");
if (clip->type & MOVE_NOMONSTERS && touch->v.solid != SOLID_BSP)
if (clip->type & MOVE_NOMONSTERS && touch->v->solid != SOLID_BSP)
continue;
// don't clip corpse against character
if (clip->passedict->v.solid == SOLID_CORPSE && (touch->v.solid == SOLID_SLIDEBOX || touch->v.solid == SOLID_CORPSE))
if (clip->passedict->v->solid == SOLID_CORPSE && (touch->v->solid == SOLID_SLIDEBOX || touch->v->solid == SOLID_CORPSE))
continue;
// don't clip character against corpse
if (clip->passedict->v.solid == SOLID_SLIDEBOX && touch->v.solid == SOLID_CORPSE)
if (clip->passedict->v->solid == SOLID_SLIDEBOX && touch->v->solid == SOLID_CORPSE)
continue;
if (clip->boxmins[0] > touch->v.absmax[0]
|| clip->boxmins[1] > touch->v.absmax[1]
|| clip->boxmins[2] > touch->v.absmax[2]
|| clip->boxmaxs[0] < touch->v.absmin[0]
|| clip->boxmaxs[1] < touch->v.absmin[1]
|| clip->boxmaxs[2] < touch->v.absmin[2] )
if (clip->boxmins[0] > touch->v->absmax[0]
|| clip->boxmins[1] > touch->v->absmax[1]
|| clip->boxmins[2] > touch->v->absmax[2]
|| clip->boxmaxs[0] < touch->v->absmin[0]
|| clip->boxmaxs[1] < touch->v->absmin[1]
|| clip->boxmaxs[2] < touch->v->absmin[2] )
continue;
if (clip->passedict && clip->passedict->v.size[0] && !touch->v.size[0])
if (clip->passedict && clip->passedict->v->size[0] && !touch->v->size[0])
continue; // points never interact
if (!((int)clip->passedict->v.dimension_hit & (int)touch->v.dimension_solid))
if (!((int)clip->passedict->v->dimension_hit & (int)touch->v->dimension_solid))
continue;
// might intersect, so do an exact clip
@ -1626,13 +1626,13 @@ void SV_ClipToLinks ( areanode_t *node, moveclip_t *clip )
return;
if (clip->passedict)
{
if (PROG_TO_EDICT(svprogfuncs, touch->v.owner) == clip->passedict)
if (PROG_TO_EDICT(svprogfuncs, touch->v->owner) == clip->passedict)
continue; // don't clip against own missiles
if (PROG_TO_EDICT(svprogfuncs, clip->passedict->v.owner) == touch)
if (PROG_TO_EDICT(svprogfuncs, clip->passedict->v->owner) == touch)
continue; // don't clip against owner
}
if ((int)touch->v.flags & FL_MONSTER)
if ((int)touch->v->flags & FL_MONSTER)
trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins2, clip->maxs2, clip->end, clip->hullnum);
else
trace = SV_ClipMoveToEntity (touch, clip->start, clip->mins, clip->maxs, clip->end, clip->hullnum);
@ -1778,8 +1778,8 @@ trace_t SV_Move (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int type, e
memset ( &clip, 0, sizeof ( moveclip_t ) );
if (passedict->v.hull)
hullnum = passedict->v.hull;
if (passedict->v->hull)
hullnum = passedict->v->hull;
else if (sv_compatablehulls.value)
hullnum = 0;
else

118
engine/sw/d_polyse.c
View File

@ -20,6 +20,22 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// d_polyset.c: routines for drawing sets of polygons sharing the same
// texture (used for Alias models)
/*
There are three ways to draw a triangle, reflecting the three possible values of trivial accept.
accept 0 draws spanned triangles. The triangles are clipped to the screen before the spans are generated. Hrm.
accept 1 draws triangle spans. There's no clipping to the screen except the 8 bounding box points.
accept 3 compleatly on screen. Triangles are not spanned but recursivly subdivided to fill.
0 is used on meshes that arn't fully on screen
1 is used for near meshes
3 is used for more distant meshes.
Note that the C routines cover all methods as does the asm. However, the asm doesn't support any blending or any depth other than 8bit.
C functions ending C are for C drawing only and shouldn't branch into the asm. Functions ending ASM will never be used in the pure C code.
Texture coords are 16.16, not 0-1. Alternate skins thus need prescaling, but can be over-sized without too many changes.
*/
//changes include stvertexes now being seperatly number from the triangles.
//this allows q2 models to be supported.
#include "quakedef.h"
@ -131,11 +147,10 @@ void D_PolysetCalcGradientsC (int skinwidth);
void D_PolysetCalcGradientsAsm (int skinwidth);
void D_DrawSubdiv (void);
void D_DrawSubdivC (void);
void D_DrawSubdiv32C (void);
void D_DrawNonSubdiv (void);
void D_DrawNonSubdivC (void);
void D_DrawNonSubdiv32C (void);
void D_PolysetRecursiveTriangle (int *p1, int *p2, int *p3);
void D_PolysetRecursiveTriangleC (int *p1, int *p2, int *p3);
void D_PolysetSetEdgeTable (void);
void D_RasterizeAliasPolySmooth8Asm (void);
void D_RasterizeAliasPolySmooth8C (void);
@ -1172,7 +1187,7 @@ void D_PolysetDraw32 (void)
if (r_affinetridesc.drawtype)
{
D_DrawSubdiv32C ();
D_DrawSubdivC ();
}
else
{
@ -1263,6 +1278,9 @@ void D_PolysetDrawFinalVertsC (finalvert_t *fv, int numverts)
================
D_DrawSubdiv
================
recursivly draws triangles (as opposed to spanned triangles).
used on distant models as it's cheaper than generating spans on small models.
*/
void D_DrawSubdivC (void)
{
@ -1272,7 +1290,10 @@ void D_DrawSubdivC (void)
int lnumtriangles;
void (*drawfnc) (int *p1, int *p2, int *p3);
mstvert_t *pst, *stv;
pst = r_affinetridesc.pstverts;
pfv = r_affinetridesc.pfinalverts;
ptri = r_affinetridesc.ptriangles;
lnumtriangles = r_affinetridesc.numtriangles;
@ -1294,7 +1315,7 @@ void D_DrawSubdivC (void)
}
else
#endif
drawfnc = D_PolysetRecursiveTriangle;
drawfnc = D_PolysetRecursiveTriangleC;
for (i=0 ; i<lnumtriangles ; i++)
{
@ -1310,42 +1331,68 @@ void D_DrawSubdivC (void)
continue;
}
d_pcolormap = &((qbyte *)acolormap)[index0->v[4] & 0xFF00];
stv = pst + ptri[i].st_index[0];
index0->v[2] = stv->s;
index0->v[3] = stv->t;
D_PolysetRecursiveTriangle(index0->v, index1->v, index2->v);
}
}
stv = pst + ptri[i].st_index[1];
index1->v[2] = stv->s;
index1->v[3] = stv->t;
void D_DrawSubdiv32C (void)
{
mtriangle_t *ptri;
finalvert_t *pfv, *index0, *index1, *index2;
mstvert_t *pst;
int i;
int lnumtriangles;
stv = pst + ptri[i].st_index[2];
index2->v[2] = stv->s;
index2->v[3] = stv->t;
pst = r_affinetridesc.pstverts;
pfv = r_affinetridesc.pfinalverts;
ptri = r_affinetridesc.ptriangles;
lnumtriangles = r_affinetridesc.numtriangles;
for (i=0 ; i<lnumtriangles ; i++)
{
index0 = pfv + ptri[i].xyz_index[0];
index1 = pfv + ptri[i].xyz_index[1];
index2 = pfv + ptri[i].xyz_index[2];
if (((index0->v[1]-index1->v[1]) * //is this back face culling?
(index0->v[0]-index2->v[0]) -
(index0->v[0]-index1->v[0]) *
(index0->v[1]-index2->v[1])) >= 0)
{
continue;
int z;
short *zbuf;
z = index0->v[5]>>16;
zbuf = zspantable[index0->v[1]] + index0->v[0];
if (z >= *zbuf)
{
int pix;
*zbuf = z;
pix = skintable[index0->v[3]>>16][index0->v[2]>>16];
pix = ((qbyte *)acolormap)[pix + (index0->v[4] & 0xFF00) ];
d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]] = pix;//Trans(d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]], pix);
}
}
{
int z;
short *zbuf;
z = index1->v[5]>>16;
zbuf = zspantable[index1->v[1]] + index1->v[0];
if (z >= *zbuf)
{
int pix;
*zbuf = z;
pix = skintable[index1->v[3]>>16][index1->v[2]>>16];
pix = ((qbyte *)acolormap)[pix + (index0->v[4] & 0xFF00) ];
d_viewbuffer[d_scantable[index1->v[1]] + index1->v[0]] = pix;//Trans(d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]], pix);
}
}
{
int z;
short *zbuf;
z = index2->v[5]>>16;
zbuf = zspantable[index2->v[1]] + index2->v[0];
if (z >= *zbuf)
{
int pix;
*zbuf = z;
pix = skintable[index2->v[3]>>16][index2->v[2]>>16];
pix = ((qbyte *)acolormap)[pix + (index0->v[4] & 0xFF00) ];
d_viewbuffer[d_scantable[index2->v[1]] + index2->v[0]] = pix;//Trans(d_viewbuffer[d_scantable[index0->v[1]] + index0->v[0]], pix);
}
}
d_pcolormap = &((qbyte *)acolormap)[index0->v[4] & 0xFF00];
D_PolysetRecursiveTriangle32Trans(index0->v, index1->v, index2->v);
drawfnc(index0->v, index1->v, index2->v);
}
}
@ -1471,13 +1518,12 @@ void D_DrawNonSubdiv32C (void)
}
}
#if !id386
/*
================
D_PolysetRecursiveTriangle
================
*/
void D_PolysetRecursiveTriangle (int *lp1, int *lp2, int *lp3)
void D_PolysetRecursiveTriangleC (int *lp1, int *lp2, int *lp3)
{
int *temp;
int d;
@ -1550,12 +1596,10 @@ split:
nodraw:
// recursively continue
D_PolysetRecursiveTriangle (lp3, lp1, new);
D_PolysetRecursiveTriangle (lp3, new, lp2);
D_PolysetRecursiveTriangleC (lp3, lp1, new);
D_PolysetRecursiveTriangleC (lp3, new, lp2);
}
#endif // !id386
/*
================

10
engine/sw/r_alias.c
View File

@ -270,7 +270,7 @@ qboolean R_AliasCheckBBox (void)
{
if (minz > (r_aliastransition + (pmdl->size * r_resfudge)))
{
// currententity->trivial_accept |= 2;
currententity->trivial_accept |= 2;
}
}
@ -601,12 +601,12 @@ void R_AliasPrepareUnclippedPoints (void)
{
if (r_pixbytes == 4)
D_PolysetDrawFinalVerts32Trans (pfinalverts, r_anumverts);
#if id386
#if 0//id386
else if (t_state & TT_ONE)
D_PolysetDrawFinalVertsAsm (pfinalverts, r_anumverts);
#endif
else
D_PolysetDrawFinalVertsC (pfinalverts, r_anumverts);
// else
// D_PolysetDrawFinalVertsC (pfinalverts, r_anumverts);
}
r_affinetridesc.pfinalverts = pfinalverts;
@ -616,7 +616,7 @@ void R_AliasPrepareUnclippedPoints (void)
if (r_pixbytes == 4)
D_PolysetDraw32 ();
#if id386
#if 0//id386
else if (t_state & TT_ONE)
D_PolysetDrawAsm ();
#endif

4
engine/sw/r_surf.c
View File

@ -401,8 +401,8 @@ void SWR_BuildLightmaps(void)
surf = cl.worldmodel->surfaces;
for (i=0 ; i<cl.worldmodel->numsurfaces ; i++, surf++)
{
if ( cl.worldmodel->surfaces[i].flags & SURF_DRAWSKY )
P_EmitSkyEffectTris(cl.worldmodel, &cl.worldmodel->surfaces[i]);
// if ( cl.worldmodel->surfaces[i].flags & SURF_DRAWSKY )
// P_EmitSkyEffectTris(cl.worldmodel, &cl.worldmodel->surfaces[i]);
SWR_CreateSurfaceLightmap(surf);
}
}