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

engine/Makefile

@@ -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
+	else
-plugins:
 	@-echo no plugins directory installed
-endif
+	endif
+plugins:
 
 help:
 	@-echo "Specfic targets:"

engine/client/cl_cam.c

@@ -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) 

engine/client/cl_ents.c

@@ -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;

engine/client/cl_input.c

@@ -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

engine/client/cl_pred.c

@@ -82,9 +82,9 @@ void CLQ2_CheckPredictionError (void)
 	}
 	else
 	{
-		if (/*cl_showmiss->value && */(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, 
+//			Con_Printf ("prediction miss on %i: %i\n", cl.q2frame.serverframe, 
-			delta[0] + delta[1] + delta[2]);
+//			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;	
 	}
 

engine/client/cl_tent.c

@@ -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 (pos);
-		MSG_ReadPos (&net_message, pos2);
+		MSG_ReadPos (pos2);
-		CL_DebugTrail (pos, 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);
+		VectorCopy (pos, ex->origin);
-		ex->type = ex_poly;
+//		ex->type = ex_poly;
-		ex->ent.flags = Q2RF_FULLBRIGHT;
+		ex->flags = Q2RF_FULLBRIGHT;
-		ex->start = cl.frame.servertime - 100;
 		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->angles[1] = rand() % 360;
-		ex->ent.model = cl_mod_explo4;
+		ex->model = Mod_ForName (q2tentmodels[q2cl_mod_explo4].modelname, false);
-		if (frand() < 0.5)
+		if (rand() < RAND_MAX/2)
-			ex->baseframe = 15;
+			ex->firstframe = 15;
-		ex->frames = 15;
+		ex->numframes = 15;
-		if (type == TE_ROCKET_EXPLOSION_WATER)
+		Q2S_StartSound (pos, 0, 0, S_PrecacheSound("weapons/rocklx1a.wav"), 1, ATTN_NORM, 0);
-			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);
 		break;
-
+/*
 	case Q2TE_FLASHLIGHT:
 		MSG_ReadPos(&net_message, pos);
 		ent = MSG_ReadShort(&net_message);

engine/client/m_single.c

@@ -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;

engine/client/menu.c

@@ -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.

engine/client/merged.h

@@ -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

engine/client/pr_csqc.c

@@ -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 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 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 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 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 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.frame = in->v->frame;
-	ent.oldframe = in->v.oldframe;
+	ent.oldframe = in->v->oldframe;
-	ent.lerpfrac = in->v.lerpfrac;
+	ent.lerpfrac = in->v->lerpfrac;
 
-	ent.angles[0] = in->v.angles[0];
+	ent.angles[0] = in->v->angles[0];
-	ent.angles[1] = in->v.angles[1];
+	ent.angles[1] = in->v->angles[1];
-	ent.angles[2] = in->v.angles[2];
+	ent.angles[2] = in->v->angles[2];
-	memcpy(ent.origin, in->v.origin, sizeof(vec3_t));
+	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.alpha = in->v->alpha;
-	ent.scale = in->v.scale;
+	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
 				}

engine/client/pr_menu.c

@@ -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

engine/client/renderer.c

@@ -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);

engine/client/sbar.c

@@ -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];

engine/client/wad.c

@@ -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];

engine/client/wad.h

@@ -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);

engine/client/zqtp.c

@@ -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));
 	}

engine/common/cmd.c

@@ -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 = (qbyte*)Z_Malloc(newmax);
-		cmd_text[level].buf.data = 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);
+	text = Cmd_ExpandString(text, dest, sizeof(dest), level, !Cmd_FromServer()?true:false);
-	Cmd_TokenizeString (text, level == RESTRICT_LOCAL, 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;
+	const char *end;
-	char *text = Cmd_Args();
+	const char *text;
+	int forceflags = 0;
+
 	if (Cmd_Argc()<3)
 	{
 		Con_TPrintf(TL_SETSYNTAX);
 		return;
 	}
 
-	while(*text <= ' ')	//first whitespace
+	var = Cvar_Get (Cmd_Argv(1), "0", 0, "Custom variables");
-		text++;
+
-	while(*text > ' ')	//first var
+	if (Cmd_FromServer())	//AAHHHH!!!
-		text++;
+	{
-	while(*text <= ' ')	//second whitespace
+		text = Cmd_Argv(3);
-		text++;
+		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
 	{

engine/common/cmd.h

@@ -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;
 

engine/common/common.c

@@ -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
+typedef enum {SPT_OS, SPT_PACK
-{
-	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] == '*')
 	{

engine/common/common.h

@@ -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);
+char *Info_ValueForKey (char *s, const char *key);
-void Info_RemoveKey (char *s, 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_SetValueForKey (char *s, const char *key, const char *value, int maxsize);
-void Info_SetValueForStarKey (char *s, char *key, 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);

engine/common/cvar.c

@@ -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 = (cvar_group_t*)Z_Malloc(sizeof(cvar_group_t));
-	g->name = gname;
+	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);
 	}
 

engine/common/cvar.h

@@ -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_ForceSet (cvar_t *var, const char *value);
-cvar_t 	*Cvar_Set (cvar_t *var, 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);
 

engine/common/gl_q2bsp.c

@@ -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
 	}

engine/common/huff.c

@@ -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] );
+			Huff_SwapTrees( tree2, (void**)tree2[2] );
-			a = tree2[5];
+			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];
+	d = (void**)tree[3];
-	c = d[2];
+	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;

engine/common/md5.c

@@ -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 MD5Init (MD5_CTX *ctx);
-void MD5Update PROTO_LIST
+void MD5Update (MD5_CTX *, unsigned char *, unsigned int);
-  ((MD5_CTX *, unsigned char *, unsigned int));
+void MD5Final (unsigned char [16], MD5_CTX *);
-void MD5Final PROTO_LIST ((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 MD5Transform (UINT4 [4], unsigned char [64]);
-static void Encode PROTO_LIST
+static void Encode (unsigned char *, UINT4 *, unsigned int);
-  ((unsigned char *, UINT4 *, unsigned int));
+static void Decode (UINT4 *, unsigned char *, unsigned int);
-static void Decode PROTO_LIST
-  ((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)
+void MD5Init (MD5_CTX *context)
-MD5_CTX *context;                                        /* 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)
+void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
-MD5_CTX *context;                                        /* context */
-unsigned char *input;                                /* input block */
-unsigned int inputLen;                     /* length of input block */
 {
   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)
+void MD5Final (unsigned char digest[16], MD5_CTX *context)
-unsigned char digest[16];                         /* message digest */
-MD5_CTX *context;                                       /* 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)
+static void MD5Transform (UINT4 state[4], unsigned char block[64])
-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)
+static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
-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)
+static void Decode (UINT4 *output, unsigned char *input, unsigned int len)
-UINT4 *output;
-unsigned char *input;
-unsigned int len;
 {
   unsigned int i, j;
 

engine/common/q1bsp.c

@@ -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);
 }
 

engine/common/zone.c

@@ -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;

engine/email/sv_pop3.c

@@ -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)

engine/ftequake/FTEQuake.dev

@@ -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

engine/gl/gl_alias.c

@@ -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");

engine/gl/gl_backend.c

@@ -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);
 	}
 }
 

engine/gl/gl_model.c

@@ -719,10 +719,10 @@ qbyte	*mod_base;
 #endif
 
 char *advtexturedesc;
-char *mapsection;
+const char *mapsection;
-char *defaultsection;
+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] = "";

engine/gl/gl_model.h

@@ -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

engine/gl/gl_ppl.c

@@ -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])
+		if (r_inmirror)
-			continue;
+		{
+			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))
+				j = cl.lerpents[j].tagent;
-			continue;
+			}
+			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)

engine/gl/gl_shader.c

@@ -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;
 	}

engine/http/iweb.h

@@ -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);

engine/http/iwebiface.c

@@ -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);

engine/qclib/execloop.h

@@ -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);

engine/qclib/execloop16d.h

@@ -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_VI:
-			case OP_MUL_FI:
+		OPC->vector[0] = OPA->vector[0] * OPB->_int;
-			case OP_MUL_VI:
+		OPC->vector[1] = OPA->vector[0] * OPB->_int;
-			case OP_DIV_IF:
+		OPC->vector[2] = OPA->vector[0] * OPB->_int;
-			case OP_DIV_FI:
+		break;
-			case OP_BITAND_IF:
+	case OP_MUL_IV:
-			case OP_BITOR_IF:
+		OPC->vector[0] = OPB->_int * OPA->vector[0];
-			case OP_BITAND_FI:
+		OPC->vector[1] = OPB->_int * OPA->vector[1];
-			case OP_BITOR_FI:
+		OPC->vector[2] = OPB->_int * OPA->vector[2];
-			case OP_AND_I:
+		break;
-			case OP_OR_I:
+
-			case OP_AND_IF:
+	case OP_DIV_IF:
-			case OP_OR_IF:
+		OPC->_float = (OPA->_int / OPB->_float);
-			case OP_AND_FI:
+		break;
-			case OP_OR_FI:
+	case OP_DIV_FI:
-			case OP_NOT_I:
+		OPC->_float = (OPA->_float / OPB->_int);
-			case OP_NE_IF:
+		break;
-			case OP_NE_FI:
+
-			case OP_GSTOREP_I:
+	case OP_AND_I:
-			case OP_GSTOREP_F:
+		OPC->_int = (OPA->_int && OPB->_int);
-			case OP_GSTOREP_ENT:
+		break;
-			case OP_GSTOREP_FLD:		// integers
+	case OP_OR_I:
-			case OP_GSTOREP_S:
+		OPC->_int = (OPA->_int || OPB->_int);
-			case OP_GSTOREP_FNC:		// pointers
+		break;
-			case OP_GSTOREP_V:
+
-			case OP_GADDRESS:
+	case OP_AND_IF:
-			case OP_GLOAD_I:
+		OPC->_int = (OPA->_int && OPB->_float);
-			case OP_GLOAD_F:
+		break;
-			case OP_GLOAD_FLD:
+	case OP_OR_IF:
-			case OP_GLOAD_ENT:
+		OPC->_int = (OPA->_int || OPB->_float);
-			case OP_GLOAD_S:
+		break;
-			case OP_GLOAD_FNC:
+
-			case OP_BOUNDCHECK:
+	case OP_AND_FI:
-PR_RunError(progfuncs, "Extra opcode not implemented\n");
+		OPC->_int = (OPA->_float && OPB->_int);
-				break;
+		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

engine/qclib/execloop32.h

@@ -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_VI:
-			case OP_MUL_FI:
+		OPC->vector[0] = OPA->vector[0] * OPB->_int;
-			case OP_MUL_VI:
+		OPC->vector[1] = OPA->vector[0] * OPB->_int;
-			case OP_DIV_IF:
+		OPC->vector[2] = OPA->vector[0] * OPB->_int;
-			case OP_DIV_FI:
+		break;
-			case OP_BITAND_IF:
+	case OP_MUL_IV:
-			case OP_BITOR_IF:
+		OPC->vector[0] = OPB->_int * OPA->vector[0];
-			case OP_BITAND_FI:
+		OPC->vector[1] = OPB->_int * OPA->vector[1];
-			case OP_BITOR_FI:
+		OPC->vector[2] = OPB->_int * OPA->vector[2];
-			case OP_AND_I:
+		break;
-			case OP_OR_I:
+
-			case OP_AND_IF:
+	case OP_DIV_IF:
-			case OP_OR_IF:
+		OPC->_float = (OPA->_int / OPB->_float);
-			case OP_AND_FI:
+		break;
-			case OP_OR_FI:
+	case OP_DIV_FI:
-			case OP_NOT_I:
+		OPC->_float = (OPA->_float / OPB->_int);
-			case OP_NE_IF:
+		break;
-			case OP_NE_FI:
+
-			case OP_GSTOREP_I:
+	case OP_AND_I:
-			case OP_GSTOREP_F:
+		OPC->_int = (OPA->_int && OPB->_int);
-			case OP_GSTOREP_ENT:
+		break;
-			case OP_GSTOREP_FLD:		// integers
+	case OP_OR_I:
-			case OP_GSTOREP_S:
+		OPC->_int = (OPA->_int || OPB->_int);
-			case OP_GSTOREP_FNC:		// pointers
+		break;
-			case OP_GSTOREP_V:
+
-			case OP_GADDRESS:
+	case OP_AND_IF:
-			case OP_GLOAD_I:
+		OPC->_int = (OPA->_int && OPB->_float);
-			case OP_GLOAD_F:
+		break;
-			case OP_GLOAD_FLD:
+	case OP_OR_IF:
-			case OP_GLOAD_ENT:
+		OPC->_int = (OPA->_int || OPB->_float);
-			case OP_GLOAD_S:
+		break;
-			case OP_GLOAD_FNC:
+
-			case OP_BOUNDCHECK:
+	case OP_AND_FI:
-PR_RunError(progfuncs, "Extra opcode not implemented\n");
+		OPC->_int = (OPA->_float && OPB->_int);
-				break;
+		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

engine/qclib/execloop32d.h

@@ -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_VI:
-			case OP_MUL_FI:
+		OPC->vector[0] = OPA->vector[0] * OPB->_int;
-			case OP_MUL_VI:
+		OPC->vector[1] = OPA->vector[0] * OPB->_int;
-			case OP_DIV_IF:
+		OPC->vector[2] = OPA->vector[0] * OPB->_int;
-			case OP_DIV_FI:
+		break;
-			case OP_BITAND_IF:
+	case OP_MUL_IV:
-			case OP_BITOR_IF:
+		OPC->vector[0] = OPB->_int * OPA->vector[0];
-			case OP_BITAND_FI:
+		OPC->vector[1] = OPB->_int * OPA->vector[1];
-			case OP_BITOR_FI:
+		OPC->vector[2] = OPB->_int * OPA->vector[2];
-			case OP_AND_I:
+		break;
-			case OP_OR_I:
+
-			case OP_AND_IF:
+	case OP_DIV_IF:
-			case OP_OR_IF:
+		OPC->_float = (OPA->_int / OPB->_float);
-			case OP_AND_FI:
+		break;
-			case OP_OR_FI:
+	case OP_DIV_FI:
-			case OP_NOT_I:
+		OPC->_float = (OPA->_float / OPB->_int);
-			case OP_NE_IF:
+		break;
-			case OP_NE_FI:
+
-			case OP_GSTOREP_I:
+	case OP_AND_I:
-			case OP_GSTOREP_F:
+		OPC->_int = (OPA->_int && OPB->_int);
-			case OP_GSTOREP_ENT:
+		break;
-			case OP_GSTOREP_FLD:		// integers
+	case OP_OR_I:
-			case OP_GSTOREP_S:
+		OPC->_int = (OPA->_int || OPB->_int);
-			case OP_GSTOREP_FNC:		// pointers
+		break;
-			case OP_GSTOREP_V:
+
-			case OP_GADDRESS:
+	case OP_AND_IF:
-			case OP_GLOAD_I:
+		OPC->_int = (OPA->_int && OPB->_float);
-			case OP_GLOAD_F:
+		break;
-			case OP_GLOAD_FLD:
+	case OP_OR_IF:
-			case OP_GLOAD_ENT:
+		OPC->_int = (OPA->_int || OPB->_float);
-			case OP_GLOAD_S:
+		break;
-			case OP_GLOAD_FNC:
+
-			case OP_BOUNDCHECK:
+	case OP_AND_FI:
-PR_RunError(progfuncs, "Extra opcode not implemented\n");
+		OPC->_int = (OPA->_float && OPB->_int);
-				break;
+		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

engine/qclib/hash.c

@@ -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;

engine/qclib/initlib.c

@@ -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);
-		prmemb_t *mem;
+	mem = memalloc(ammount);
-		ammount = sizeof(prmemb_t)+((ammount + 3)&~3);
+	memset(mem, 0, ammount);
-		mem = memalloc(ammount);
+	mem->prev = memb;
-		memset(mem, 0, ammount);
+	if (!memb)
-		mem->prev = memb;
+		mem->level = 1;
-		if (!memb)
+	else
-			mem->level = 1;
+		mem->level = ((prmemb_t *)memb)->level+1;
-		else
+	memb = mem;
-			mem->level = ((prmemb_t *)memb)->level+1;
-		memb = mem;
 
-		return ((char *)mem)+sizeof(prmemb_t);
+	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;
 }
 
 int PRHunkMark(progfuncs_t *progfuncs)
 {
-	if (!progshunk)
+	return ((prmemb_t *)memb)->level;
-	{
-		return ((prmemb_t *)memb)->level;
-	}
-	return hunkused;
 }
 void PRHunkFree(progfuncs_t *progfuncs, int mark)
 {
-	if (!progshunk)
+	prmemb_t *omem;
+	while(memb)
 	{
-		prmemb_t *omem;
+		if (memb->level <= mark)
-		while(memb)
+			return;
-		{
-			if (memb->level <= mark)
-				return;
 
-			omem = memb;
+		omem = memb;
-			memb = memb->prev;
+		memb = memb->prev;
-			memfree(omem);
+		memfree(omem);
-		}
-		return;
 	}
-	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;
+	max_fields_size = fields_size;
-
-	pr_max_edict_size = pr_edict_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;
+	max_fields_size=0;
-	pr_edict_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.
-
+	if (addressable_size<0)
-//three conditions.
+		addressable_size = 8*1024*1024;
-//mem + size uses new hunk space
+	PRAddressableFlush(progfuncs, addressable_size);
-//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;
 
 	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 *)&(
+		return (eval_t *) &(((int*)(((edictrun_t*)ed)->fields))[var->ofs]);
-			((int*)((char *)ed + externs->edictsize))
-			[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 *)
+		return (eval_t *) &(((int*)(((edictrun_t*)ed)->fields))[var->ofs]);
-			&((int*)((char *)ed + externs->edictsize))
-			[var->ofs];
 	}
 	if (cache->ofs32 == NULL)
 		return NULL;
-	return (eval_t *)
+	return (eval_t *) &(((int*)(((edictrun_t*)ed)->fields))[cache->ofs32->ofs]);
-		&((int*)((char *)ed + externs->edictsize))
-		[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));

engine/qclib/pr_edict.c

@@ -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 entnum;
-			int valofs;
+//			int valofs;
-			if (val->edict == 0)
+			if (val->_int == 0)
 			{
 				sprintf (line, "NULL pointer");
 				break;
 			}
-			entnum = ((qbyte *)val->edict - (qbyte *)sv_edicts) / pr_edict_size;
+		//FIXME: :/
-			valofs = (int *)val->edict - (int *)edvars(EDICT_NUM(progfuncs, entnum));
+			sprintf(line, "UNKNOWN");
-			fielddef = ED_FieldAtOfs (progfuncs, valofs );
+//			entnum = ((qbyte *)val->edict - (qbyte *)sv_edicts) / pr_edict_size;
-			if (!fielddef)
+//			valofs = (int *)val->edict - (int *)edvars(EDICT_NUM(progfuncs, entnum));
-				sprintf(line, "ent%i.%s", entnum, "UNKNOWN");
+//			fielddef = ED_FieldAtOfs (progfuncs, valofs );
-			else
+//			if (!fielddef)
-				sprintf(line, "ent%i.%s", entnum, fielddef->s_name);
+//				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)
-	{
+	{			
-		if (pr_types)
+		for (i=0 ; i<pr_progs->numtypes ; i++)
-		{			
+		{	
-			for (i=0 ; i<pr_progs->numtypes ; i++)
-			{	
 #ifndef NOENDIAN
-				pr_types[i].type = LittleLong(current_progstate->types[i].type);
+			pr_types[i].type = LittleLong(current_progstate->types[i].type);
-				pr_types[i].next = LittleLong(current_progstate->types[i].next);
+			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].aux_type = LittleLong(current_progstate->types[i].aux_type);
-				pr_types[i].num_parms = LittleLong(current_progstate->types[i].num_parms);
+			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].ofs = LittleLong(current_progstate->types[i].ofs);
-				pr_types[i].size = LittleLong(current_progstate->types[i].size);
+			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].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.
+//ifstring fixes arn't performed anymore. 
-//we need to search through the statements, looking for if statements.
+//the following switch just fixes endian and hexen2 calling conventions (by using different opcodes).
-//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)
 	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_CALL1 && pr_statements32[i].op <= OP_CALL8)
-			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].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;
 	}
 

engine/qclib/pr_exec.c

@@ -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:

engine/qclib/pr_multi.c

@@ -196,9 +196,9 @@ int QC_RegisterFieldVar(progfuncs_t *progfuncs, unsigned int type, char *name, i
 
 	int fnum;
 
-	if (!name)
+	if (!name)	//engine can use this to offset all progs fields
-	{
+	{			//which fixes constant field offsets (some ktpro arrays)
-		progfuncs->fieldadjust = pr_edict_size/4;
+		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)
+		if (fields_size < (ofs+type_size[type])*4)
-			pr_edict_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;
 

engine/qclib/progsint.h

@@ -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	EDICT_TO_PROG(pf, e) (((edictrun_t*)e)->entnum)
-#define PROG_TO_EDICT(e) ((edictrun_t *)((qbyte *)sv_edicts + e))
+#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
+var(int, fields_size);	// in bytes
-#define pr_edict_size prinst->pr_edict_size
+#define fields_size prinst->fields_size
-var(int, pr_max_edict_size);
+var(int, max_fields_size);
-#define pr_max_edict_size prinst->pr_max_edict_size
+#define max_fields_size prinst->max_fields_size
 
 
 //initlib.c
-var(char *, progshunk);
+var(char *, addressablehunk);
-#define progshunk prinst->progshunk
+#define addressablehunk prinst->addressablehunk
-var(int, hunkused);
+var(int, addressableused);
-#define hunkused prinst->hunkused
+#define addressableused prinst->addressableused
-var(int, hunksize);
+var(int, addressablesize);
-#define hunksize prinst->hunksize
+#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);
 

engine/qclib/progslib.h

@@ -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)

engine/server/net_preparse.c

@@ -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[0]);
-					ClientReliableWrite_Coord(cl, cl->edict->v.origin[1]);
+					ClientReliableWrite_Coord(cl, cl->edict->v->origin[1]);
-					ClientReliableWrite_Coord(cl, cl->edict->v.origin[2]+cl->edict->v.view_ofs[2]);
+					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[0]);
-					ClientReliableWrite_Angle(cl, cl->edict->v.angles[1]);
+					ClientReliableWrite_Angle(cl, cl->edict->v->angles[1]);
-					ClientReliableWrite_Angle(cl, cl->edict->v.angles[2]);
+					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->origin, org);
-					VectorCopy(cl->edict->v.angles, ang);
+					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));

engine/server/pr_cmds.c

@@ -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_see = 255;
-	ent->v.dimension_seen = 255;
+	ent->v->dimension_seen = 255;
-	ent->v.dimension_ghost = 0;
+	ent->v->dimension_ghost = 0;
-	ent->v.dimension_solid = 255;
+	ent->v->dimension_solid = 255;
-	ent->v.dimension_hit = 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->model = 0;
-	ed->v.takedamage = 0;
+	ed->v->takedamage = 0;
-	ed->v.modelindex = 0;
+	ed->v->modelindex = 0;
-	ed->v.colormap = 0;
+	ed->v->colormap = 0;
-	ed->v.skin = 0;
+	ed->v->skin = 0;
-	ed->v.frame = 0;
+	ed->v->frame = 0;
-	VectorCopy (vec3_origin, ed->v.origin);
+	VectorCopy (vec3_origin, ed->v->origin);
-	VectorCopy (vec3_origin, ed->v.angles);
+	VectorCopy (vec3_origin, ed->v->angles);
-	ed->v.nextthink = 0;
+	ed->v->nextthink = 0;
-	ed->v.think = 0;
+	ed->v->think = 0;
-	ed->v.solid = 0;
+	ed->v->solid = 0;
 
-	ed->v.SendEntity = 0;
+	ed->v->SendEntity = 0;
-	sv.csqcentversion[ed->entnum] = ed->v.Version+1;
+	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 (min, e->v->mins);
-	VectorCopy (max, e->v.maxs);
+	VectorCopy (max, e->v->maxs);
-	VectorSubtract (max, min, e->v.size);
+	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->model = PR_SetString(prinst, sv.model_precache[i]);
-	e->v.modelindex = 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->mins, e->v->mins);
-		VectorCopy (mod->maxs, e->v.maxs);
+		VectorCopy (mod->maxs, e->v->maxs);
-		VectorSubtract (mod->maxs, mod->mins, e->v.size);
+		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[0] = 0;
-		e->v.mins[1] = 0;
+		e->v->mins[1] = 0;
-		e->v.mins[2] = 0;
+		e->v->mins[2] = 0;
 
-		e->v.maxs[0] = 0;
+		e->v->maxs[0] = 0;
-		e->v.maxs[1] = 0;
+		e->v->maxs[1] = 0;
-		e->v.maxs[2] = 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->mins, e->v->mins);
-				VectorCopy (mod->maxs, e->v.maxs);
+				VectorCopy (mod->maxs, e->v->maxs);
-				VectorSubtract (mod->maxs, mod->mins, e->v.size);
+				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[0] = 
-				e->v.mins[1] =
+				e->v->mins[1] =
-				e->v.mins[2] = -16;
+				e->v->mins[2] = -16;
-				e->v.maxs[0] = 
+				e->v->maxs[0] = 
-				e->v.maxs[1] =
+				e->v->maxs[1] =
-				e->v.maxs[2] = 16;
+				e->v->maxs[2] = 16;
-				VectorSubtract (e->v.maxs, e->v.mins, e->v.size);
+				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->mins, e->v->mins);
-				VectorCopy (mod->maxs, e->v.maxs);
+				VectorCopy (mod->maxs, e->v->maxs);
-				VectorSubtract (mod->maxs, mod->mins, e->v.size);
+				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;
+	savedhull = ent->v->hull;
-	ent->v.hull = 0;
+	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;
+	savedhull = ent->v->hull;
-	ent->v.hull = 0;
+	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;
+	savedhull = ent->v->hull;
-	ent->v.hull = 0;
+	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);
+	VectorCopy (ent->v->origin, start);
-	trace = SV_Move (start, ent->v.mins, ent->v.maxs, end, MOVE_NORMAL, ent);
+	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->flags = (int)ent->v->flags | FL_ONGROUND;
-		ent->v.groundentity = EDICT_TO_PROG(prinst, trace.ent);
+		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
+	if (tr.ent && tr.ent->v->takedamage == DAMAGE_AIM
-	&& (!teamplay.value || ent->v.team <=0 || ent->v.team != tr.ent->v.team) )
+	&& (!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]
+			end[j] = check->v->origin[j]
-			+ 0.5*(check->v.mins[j] + check->v.maxs[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] );
+	current = anglemod( ent->v->angles[1] );
-	ideal = ent->v.ideal_yaw;
+	ideal = ent->v->ideal_yaw;
-	speed = ent->v.yaw_speed;
+	speed = ent->v->yaw_speed;
 	
 	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->origin, state->origin);
-		VectorCopy (ent->v.angles, state->angles);
+		VectorCopy (ent->v->angles, state->angles);
-		state->modelindex = mdlindex;//ent->v.modelindex;
+		state->modelindex = mdlindex;//ent->v->modelindex;
-		state->frame = ent->v.frame;
+		state->frame = ent->v->frame;
-		state->colormap = ent->v.colormap;
+		state->colormap = ent->v->colormap;
-		state->skinnum = ent->v.skin;
+		state->skinnum = ent->v->skin;
-		state->effects = ent->v.effects;
+		state->effects = ent->v->effects;
-		state->drawflags = ent->v.drawflags;
+		state->drawflags = ent->v->drawflags;
-		state->abslight = (int)(ent->v.abslight*255) & 255;
+		state->abslight = (int)(ent->v->abslight*255) & 255;
-		state->trans = ent->v.alpha;
+		state->trans = ent->v->alpha;
 		if (!state->trans)
 			state->trans = 1;
-		state->fatness = ent->v.fatness;
+		state->fatness = ent->v->fatness;
-		state->scale = ent->v.scale;
+		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, ent->v->frame);
-		MSG_WriteByte (&sv.signon, (int)ent->v.colormap);
+		MSG_WriteByte (&sv.signon, (int)ent->v->colormap);
-		MSG_WriteByte (&sv.signon, (int)ent->v.skin);
+		MSG_WriteByte (&sv.signon, (int)ent->v->skin);
 		for (i=0 ; i<3 ; i++)
 		{
-			MSG_WriteCoord(&sv.signon, ent->v.origin[i]);
+			MSG_WriteCoord(&sv.signon, ent->v->origin[i]);
-			MSG_WriteAngle(&sv.signon, ent->v.angles[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))||
+	if ((Start<End&&(Ent->v->frame < Start || Ent->v->frame > End))||
-		(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++;
+		Ent->v->frame++;
-		if (Ent->v.frame == End) 
+		if (Ent->v->frame == End) 
 			Result = 2;
 		else 
 			Result = 0;
 	}
 	else if(End<Start)
 	{  // Reverse Advance
-		Ent->v.frame--;
+		Ent->v->frame--;
-		if (Ent->v.frame == End)
+		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--;
+		Ent->v->frame--;
-		if (Ent->v.frame == End) Result = 2;
+		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)) ||
+	if ((endframe > startframe && (ent->v->weaponframe > endframe || ent->v->weaponframe < startframe)) ||
-	(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[0] = dot*pitch;
-	actor->v.angles[2] = (1-fabs(dot))*pitch*mod;
+	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 fieldfloat(name) PR_RegisterFieldVar(svprogfuncs, ev_float, #name, (int)&((entvars_t*)0)->name, -1)
-#define fieldvector(name) PR_RegisterFieldVar(svprogfuncs, ev_vector, #name, (int)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -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)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -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)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -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)&((edict_t*)0)->v.name - (int)&((edict_t*)0)->v, -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, "buttonforward", (int)&((entvars_t*)0)->movement[0], -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, "buttonright", (int)&((entvars_t*)0)->movement[1], -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, "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, "fieldcolor", (int)&((entvars_t*)0)->seefcolour, -1);
-	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizex", (int)&((edict_t*)0)->v.seefsizex - (int)&((edict_t*)0)->v, -1);
+	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizex", (int)&((entvars_t*)0)->seefsizex, -1);
-	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizey", (int)&((edict_t*)0)->v.seefsizey - (int)&((edict_t*)0)->v, -1);
+	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizey", (int)&((entvars_t*)0)->seefsizey, -1);
-	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizez", (int)&((edict_t*)0)->v.seefsizez - (int)&((edict_t*)0)->v, -1);
+	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldsizez", (int)&((entvars_t*)0)->seefsizez, -1);
-	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldoffset", (int)&((edict_t*)0)->v.seefoffset - (int)&((edict_t*)0)->v, -1);
+	PR_RegisterFieldVar(svprogfuncs, ev_float, "fieldoffset", (int)&((entvars_t*)0)->seefoffset, -1);
 
 //hexen 2 stuff
 	fieldfloat(playerclass);

engine/server/progs.h

@@ -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;
   

engine/server/savegame.c

@@ -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);
 

engine/server/server.h

@@ -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);
 

engine/server/sv_ccmds.c

@@ -299,8 +299,8 @@ void SV_God_f (void)
 	if (!SV_SetPlayer ())
 		return;
 
-	sv_player->v.flags = (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)
+	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;

engine/server/sv_chat.c

@@ -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 <= ' ')

engine/server/sv_ents.c

@@ -116,8 +116,8 @@ int csqcnuments;
 
 qboolean SV_AddNailUpdate (edict_t *ent)
 {
-	if (ent->v.modelindex != sv_nailmodel
+	if (ent->v->modelindex != sv_nailmodel
-		&& ent->v.modelindex != sv_supernailmodel)
+		&& 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;
+			x = (int)(ent->v->origin[0]+4096)>>1;
-			y = (int)(ent->v.origin[1]+4096)>>1;
+			y = (int)(ent->v->origin[1]+4096)>>1;
-			z = (int)(ent->v.origin[2]+4096)>>1;
+			z = (int)(ent->v->origin[2]+4096)>>1;
-			p = (int)(16*ent->v.angles[0]/360)&15;
+			p = (int)(16*ent->v->angles[0]/360)&15;
-			yaw = (int)(256*ent->v.angles[1]/360)&255;
+			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;
+		x = (int)(ent->v->origin[0]+4096)>>1;
-		y = (int)(ent->v.origin[1]+4096)>>1;
+		y = (int)(ent->v->origin[1]+4096)>>1;
-		z = (int)(ent->v.origin[2]+4096)>>1;
+		z = (int)(ent->v->origin[2]+4096)>>1;
-		p = (int)(16*ent->v.angles[0]/360)&15;
+		p = (int)(16*ent->v->angles[0]/360)&15;
-		yaw = (int)(256*ent->v.angles[1]/360)&255;
+		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])
+		if ((int)ent->v->Version < sv.csqcentversion[ent->entnum])
-			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->offset = ent->v->seefoffset;
-	ef->size[0] = ent->v.seefsizex;
+	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->origin, dcl->info.origin);
-			VectorCopy(vent->v.angles, dcl->info.angles);
+			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.skinnum = ent->v->skin;
-				dcl->info.effects = ent->v.effects;
+				dcl->info.effects = ent->v->effects;
-				dcl->info.weaponframe = ent->v.weaponframe;
+				dcl->info.weaponframe = ent->v->weaponframe;
-				dcl->info.model = ent->v.modelindex;
+				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.modelindex = vent->v->modelindex;
-			clst.modelindex2 = vent->v.vweapmodelindex;
+			clst.modelindex2 = vent->v->vweapmodelindex;
-			clst.frame = vent->v.frame;
+			clst.frame = vent->v->frame;
-			clst.weaponframe = ent->v.weaponframe;
+			clst.weaponframe = ent->v->weaponframe;
-			clst.angles = ent->v.angles;
+			clst.angles = ent->v->angles;
-			clst.origin = vent->v.origin;
+			clst.origin = vent->v->origin;
-			clst.velocity = vent->v.velocity;
+			clst.velocity = vent->v->velocity;
-			clst.effects = ent->v.effects;
+			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.skin = vent->v->skin;
-			clst.mins = vent->v.mins;
+			clst.mins = vent->v->mins;
-			clst.hull = vent->v.hull;
+			clst.hull = vent->v->hull;
-			clst.maxs = vent->v.maxs;
+			clst.maxs = vent->v->maxs;
-			clst.scale = vent->v.scale;
+			clst.scale = vent->v->scale;
-			clst.transparency = vent->v.alpha;
+			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_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_seen & ~(int)ent->v->dimension_ghost)) )
 				{
-					if (ent->v.dimension_ghost_alpha)
+					if (ent->v->dimension_ghost_alpha)
-						clst.transparency *= 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.mins = svs.clients[client->spec_track-1].edict->v->mins;
-						clst.maxs = svs.clients[client->spec_track-1].edict->v.maxs;
+						clst.maxs = svs.clients[client->spec_track-1].edict->v->maxs;
-						clst.health = svs.clients[client->spec_track-1].edict->v.health;
+						clst.health = svs.clients[client->spec_track-1].edict->v->health;
-						clst.weaponframe = svs.clients[client->spec_track-1].edict->v.weaponframe;
+						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 != ent->v->alpha)
-			if (!(ent->baseline.trans == 1 && !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_MODEL)		MSG_WriteByte (msg,	ent->v->modelindex);
-	if (bits & NQU_FRAME)		MSG_WriteByte (msg, ent->v.frame);
+	if (bits & NQU_FRAME)		MSG_WriteByte (msg, ent->v->frame);
-	if (bits & NQU_COLORMAP)	MSG_WriteByte (msg, ent->v.colormap);
+	if (bits & NQU_COLORMAP)	MSG_WriteByte (msg, ent->v->colormap);
-	if (bits & NQU_SKIN)		MSG_WriteByte (msg, ent->v.skin);
+	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_ORIGIN1)		MSG_WriteCoord (msg, ent->v->origin[0]);		
-	if (bits & NQU_ANGLE1)		MSG_WriteAngle(msg, ent->v.angles[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_ORIGIN2)		MSG_WriteCoord (msg, ent->v->origin[1]);
-	if (bits & NQU_ANGLE2)		MSG_WriteAngle(msg, ent->v.angles[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_ORIGIN3)		MSG_WriteCoord (msg, ent->v->origin[2]);
-	if (bits & NQU_ANGLE3)		MSG_WriteAngle(msg, ent->v.angles[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_ALPHA)		MSG_WriteByte(msg, ent->v->alpha*255);
-	if (bits & DPU_SCALE)		MSG_WriteByte(msg, ent->v.scale*16);
+	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_FRAME2)		MSG_WriteByte(msg, (int)ent->v->frame >> 8);
-	if (bits & DPU_MODEL2)		MSG_WriteByte(msg, (int)ent->v.modelindex >> 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 indx = ent->v->modelindex;
-	int frame = ent->v.frame;
+	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)
+		if (clent->v->view2)
-			sv.worldmodel->funcs.FatPVS(PROG_TO_EDICT(svprogfuncs, clent->v.view2)->v.origin, true);
+			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)
+			if (clent->v->view2)
-				SV_Q1BSP_AddToFatPVS (PROG_TO_EDICT(svprogfuncs, clent->v.view2)->v.origin, sv.worldmodel->nodes);	//add a little more...
+				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->origin, state->origin);
-		VectorCopy (clent->v.angles, state->angles);
+		VectorCopy (clent->v->angles, state->angles);
-		state->modelindex = clent->v.modelindex;
+		state->modelindex = clent->v->modelindex;
-		state->frame = clent->v.frame;
+		state->frame = clent->v->frame;
-		state->colormap = clent->v.colormap;
+		state->colormap = clent->v->colormap;
-		state->skinnum = clent->v.skin;
+		state->skinnum = clent->v->skin;
-		state->effects = clent->v.effects;
+		state->effects = clent->v->effects;
-		state->drawflags = clent->v.drawflags;
+		state->drawflags = clent->v->drawflags;
-		state->abslight = clent->v.abslight;
+		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)	//DP extension.
-			if (ent->v.nodrawtoclient == EDICT_TO_PROG(svprogfuncs, client->edict))
+			if (ent->v->nodrawtoclient == EDICT_TO_PROG(svprogfuncs, client->edict))
 				continue;
-		if (ent->v.drawonlytoclient)
+		if (ent->v->drawonlytoclient)
-			if (ent->v.drawonlytoclient != EDICT_TO_PROG(svprogfuncs, client->edict))
+			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);
+			VectorAdd(ent->v->absmin, ent->v->absmax, org);
-			VectorMA(clent->v.origin, -0.5, org, 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->origin, state->origin);
-		VectorCopy (ent->v.angles, state->angles);
+		VectorCopy (ent->v->angles, state->angles);
-		state->modelindex = ent->v.modelindex;
+		state->modelindex = ent->v->modelindex;
-		state->frame = ent->v.frame;
+		state->frame = ent->v->frame;
-		state->colormap = ent->v.colormap;
+		state->colormap = ent->v->colormap;
-		state->skinnum = ent->v.skin;
+		state->skinnum = ent->v->skin;
-		state->effects = ent->v.effects;
+		state->effects = ent->v->effects;
-		state->drawflags = ent->v.drawflags;
+		state->drawflags = ent->v->drawflags;
-		state->abslight = (int)(ent->v.abslight*255) & 255;
+		state->abslight = (int)(ent->v->abslight*255) & 255;
-		if ((int)ent->v.flags & FL_CLASS_DEPENDENT && client->playerclass)
+		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_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_seen & ~(int)ent->v->dimension_ghost)) )
 				{
-					if (ent->v.dimension_ghost_alpha)
+					if (ent->v->dimension_ghost_alpha)
-						state->trans *= 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)
+		if ((int)ent->v->effects & EF_MUZZLEFLASH)
-			ent->v.effects = (int)ent->v.effects & ~EF_MUZZLEFLASH;
+			ent->v->effects = (int)ent->v->effects & ~EF_MUZZLEFLASH;
 	}
 	needcleanup=0;
 }

engine/server/sv_init.c

@@ -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->origin, svent->baseline.origin);
-		VectorCopy (svent->v.angles, svent->baseline.angles);
+		VectorCopy (svent->v->angles, svent->baseline.angles);
-		svent->baseline.frame = svent->v.frame;
+		svent->baseline.frame = svent->v->frame;
-		svent->baseline.skinnum = svent->v.skin;
+		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->origin, svent->baseline.origin);
-		VectorCopy (svent->v.angles, svent->baseline.angles);
+		VectorCopy (svent->v->angles, svent->baseline.angles);
-		svent->baseline.frame = svent->v.frame;
+		svent->baseline.frame = svent->v->frame;
-		svent->baseline.skinnum = svent->v.skin;
+		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->model = PR_SetString(svprogfuncs, sv.worldmodel->name);
-		ent->v.modelindex = 1;		// world model
+		ent->v->modelindex = 1;		// world model
-		ent->v.solid = SOLID_BSP;
+		ent->v->solid = SOLID_BSP;
-		ent->v.movetype = MOVETYPE_PUSH;
+		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->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->impulse = 0;//QWE_VERNUM;
-			ent->v.items = 103;
+			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)
 		{

engine/server/sv_main.c

@@ -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);
 

engine/server/sv_move.c

@@ -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->mins, mins);
-	VectorAdd (ent->v.origin, ent->v.maxs, maxs);
+	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;
+			savedhull = ent->v->hull;
-			ent->v.hull = 0;
+			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);
+	VectorCopy (ent->v->origin, oldorg);
-	VectorAdd (ent->v.origin, move, neworg);
+	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];
+	deltax = enemy->v->origin[0] - actor->v->origin[0];
-	deltay = enemy->v.origin[1] - actor->v.origin[1];
+	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);
 	}

engine/server/sv_send.c

@@ -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_save);
-		MSG_WriteByte (msg, ent->v.dmg_take);
+		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_take = 0;
-		ent->v.dmg_save = 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] );
+			MSG_WriteAngle (msg, ent->v->angles[i] );
-		ent->v.fixangle = 0;
+		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_WriteShort (msg, ent->v->health);
-	MSG_WriteByte (msg, ent->v.currentammo);
+	MSG_WriteByte (msg, ent->v->currentammo);
-	MSG_WriteByte (msg, ent->v.ammo_shells);
+	MSG_WriteByte (msg, ent->v->ammo_shells);
-	MSG_WriteByte (msg, ent->v.ammo_nails);
+	MSG_WriteByte (msg, ent->v->ammo_nails);
-	MSG_WriteByte (msg, ent->v.ammo_rockets);
+	MSG_WriteByte (msg, ent->v->ammo_rockets);
-	MSG_WriteByte (msg, ent->v.ammo_cells);
+	MSG_WriteByte (msg, ent->v->ammo_cells);
 	
-	//if (other && other->v.weapon)		
+	//if (other && other->v->weapon)		
-		//MSG_WriteByte (msg, 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_HEALTH] = ent->v->health;
-	stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v.weaponmodel));
+	stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v->weaponmodel));
-	stats[STAT_AMMO] = ent->v.currentammo;
+	stats[STAT_AMMO] = ent->v->currentammo;
-	stats[STAT_ARMOR] = ent->v.armorvalue;
+	stats[STAT_ARMOR] = ent->v->armorvalue;
-	stats[STAT_SHELLS] = ent->v.ammo_shells;
+	stats[STAT_SHELLS] = ent->v->ammo_shells;
-	stats[STAT_NAILS] = ent->v.ammo_nails;
+	stats[STAT_NAILS] = ent->v->ammo_nails;
-	stats[STAT_ROCKETS] = ent->v.ammo_rockets;
+	stats[STAT_ROCKETS] = ent->v->ammo_rockets;
-	stats[STAT_CELLS] = ent->v.ammo_cells;
+	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)
+	if (ent->v->view2)
-		stats[STAT_VIEW2] = NUM_FOR_EDICT(svprogfuncs, PROG_TO_EDICT(svprogfuncs, 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)
+			if (ent->v->hasted)
-				newval*=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_HEALTH] = ent->v->health;
-		stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v.weaponmodel));
+		stats[STAT_WEAPON] = SV_ModelIndex(PR_GetString(svprogfuncs, ent->v->weaponmodel));
-		stats[STAT_AMMO] = ent->v.currentammo;
+		stats[STAT_AMMO] = ent->v->currentammo;
-		stats[STAT_ARMOR] = ent->v.armorvalue;
+		stats[STAT_ARMOR] = ent->v->armorvalue;
-		stats[STAT_SHELLS] = ent->v.ammo_shells;
+		stats[STAT_SHELLS] = ent->v->ammo_shells;
-		stats[STAT_NAILS] = ent->v.ammo_nails;
+		stats[STAT_NAILS] = ent->v->ammo_nails;
-		stats[STAT_ROCKETS] = ent->v.ammo_rockets;
+		stats[STAT_ROCKETS] = ent->v->ammo_rockets;
-		stats[STAT_CELLS] = ent->v.ammo_cells;
+		stats[STAT_CELLS] = ent->v->ammo_cells;
-		stats[STAT_ACTIVEWEAPON] = ent->v.weapon;
+		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])

engine/server/world.c

@@ -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)
+		if (ent->v->movetype != MOVETYPE_PUSH)
-			SV_Error ("SOLID_BSP without MOVETYPE_PUSH (%s)", ent->v.classname + svprogfuncs->stringtable);
+			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->mins, maxs, hullmins);
-		VectorSubtract (ent->v.maxs, mins, hullmaxs);
+		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]
+		if (ent->v->absmin[0] > touch->v->absmax[0]
-		|| ent->v.absmin[1] > touch->v.absmax[1]
+		|| ent->v->absmin[1] > touch->v->absmax[1]
-		|| ent->v.absmin[2] > touch->v.absmax[2]
+		|| ent->v->absmin[2] > touch->v->absmax[2]
-		|| ent->v.absmax[0] < touch->v.absmin[0]
+		|| ent->v->absmax[0] < touch->v->absmin[0]
-		|| ent->v.absmax[1] < touch->v.absmin[1]
+		|| ent->v->absmax[1] < touch->v->absmin[1]
-		|| ent->v.absmax[2] < touch->v.absmin[2] )
+		|| 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]
+		if (ent->v->absmin[0] > touch->v->absmax[0]
-		|| ent->v.absmin[1] > touch->v.absmax[1]
+		|| ent->v->absmin[1] > touch->v->absmax[1]
-		|| ent->v.absmin[2] > touch->v.absmax[2]
+		|| ent->v->absmin[2] > touch->v->absmax[2]
-		|| ent->v.absmax[0] < touch->v.absmin[0]
+		|| ent->v->absmax[0] < touch->v->absmin[0]
-		|| ent->v.absmax[1] < touch->v.absmin[1]
+		|| ent->v->absmax[1] < touch->v->absmin[1]
-		|| ent->v.absmax[2] < touch->v.absmin[2] )
+		|| 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 && 
+	if (ent->v->solid == SOLID_BSP && 
-	(ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )
+	(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;
+			ent->v->angles[0]*=-1;
-			AngleVectors(ent->v.angles, f,r,u);
+			AngleVectors(ent->v->angles, f,r,u);
-			ent->v.angles[0]*=-1;
+			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[0] = DotProduct(ent->v->mins, f);
-		mn[1] = -DotProduct(ent->v.mins, r);
+		mn[1] = -DotProduct(ent->v->mins, r);
-		mn[2] = DotProduct(ent->v.mins, u);
+		mn[2] = DotProduct(ent->v->mins, u);
 		
-		mx[0] = DotProduct(ent->v.maxs, f);
+		mx[0] = DotProduct(ent->v->maxs, f);
-		mx[1] = -DotProduct(ent->v.maxs, r);
+		mx[1] = -DotProduct(ent->v->maxs, r);
-		mx[2] = DotProduct(ent->v.maxs, u);
+		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->absmin[i] = ent->v->origin[i]+mn[i]-0.1;
-				ent->v.absmax[i] = ent->v.origin[i]+mx[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->absmin[i] = ent->v->origin[i]+mx[i]-0.1;
-				ent->v.absmax[i] = ent->v.origin[i]+mn[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->mins, ent->v->absmin);	
-		VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
+		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[0] -= 15;
-		ent->v.absmin[1] -= 15;
+		ent->v->absmin[1] -= 15;
-		ent->v.absmax[0] += 15;
+		ent->v->absmax[0] += 15;
-		ent->v.absmax[1] += 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[0] -= 1;
-		ent->v.absmin[1] -= 1;
+		ent->v->absmin[1] -= 1;
-		ent->v.absmin[2] -= 1;
+		ent->v->absmin[2] -= 1;
-		ent->v.absmax[0] += 1;
+		ent->v->absmax[0] += 1;
-		ent->v.absmax[1] += 1;
+		ent->v->absmax[1] += 1;
-		ent->v.absmax[2] += 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 (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 (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;
+		ent->v->angles[0]*=-1;
-		TransformedHullCheck(hull, start_l, end_l, &trace, ent->v.angles);
+		TransformedHullCheck(hull, start_l, end_l, &trace, ent->v->angles);
-		ent->v.angles[0]*=-1;
+		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]
+		if (check->v->absmin[0] > area_maxs[0]
-		|| check->v.absmin[1] > area_maxs[1]
+		|| check->v->absmin[1] > area_maxs[1]
-		|| check->v.absmin[2] > area_maxs[2]
+		|| check->v->absmin[2] > area_maxs[2]
-		|| check->v.absmax[0] < area_mins[0]
+		|| check->v->absmax[0] < area_mins[0]
-		|| check->v.absmax[1] < area_mins[1]
+		|| check->v->absmax[1] < area_mins[1]
-		|| check->v.absmax[2] < area_mins[2])
+		|| 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;
+		angles = touch->v->angles;
-		if (touch->v.solid != SOLID_BSP)
+		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]
+		if (clip->boxmins[0] > touch->v->absmax[0]
-		|| clip->boxmins[1] > touch->v.absmax[1]
+		|| clip->boxmins[1] > touch->v->absmax[1]
-		|| clip->boxmins[2] > touch->v.absmax[2]
+		|| clip->boxmins[2] > touch->v->absmax[2]
-		|| clip->boxmaxs[0] < touch->v.absmin[0]
+		|| clip->boxmaxs[0] < touch->v->absmin[0]
-		|| clip->boxmaxs[1] < touch->v.absmin[1]
+		|| clip->boxmaxs[1] < touch->v->absmin[1]
-		|| clip->boxmaxs[2] < touch->v.absmin[2] )
+		|| 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)
+	if (passedict->v->hull)
-		hullnum = passedict->v.hull;
+		hullnum = passedict->v->hull;
 	else if (sv_compatablehulls.value)
 		hullnum = 0;
 	else

engine/sw/d_polyse.c

@@ -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)
+		stv = pst + ptri[i].st_index[2];
-{
+		index2->v[2] = stv->s;
-	mtriangle_t		*ptri;
+		index2->v[3] = stv->t;
-	finalvert_t		*pfv, *index0, *index1, *index2;
-	mstvert_t		*pst;
-	int				i;
-	int				lnumtriangles;
 
-	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_PolysetRecursiveTriangleC (lp3, lp1, new);
-	D_PolysetRecursiveTriangle (lp3, new, lp2);
+	D_PolysetRecursiveTriangleC (lp3, new, lp2);
 }
 
-#endif	// !id386
-
 
 /*
 ================

engine/sw/r_alias.c

@@ -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
+//		else
-			D_PolysetDrawFinalVertsC (pfinalverts, r_anumverts);
+//			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

engine/sw/r_surf.c

@@ -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 )
+//		if ( cl.worldmodel->surfaces[i].flags & SURF_DRAWSKY )
-			P_EmitSkyEffectTris(cl.worldmodel, &cl.worldmodel->surfaces[i]);
+//			P_EmitSkyEffectTris(cl.worldmodel, &cl.worldmodel->surfaces[i]);
 		SWR_CreateSurfaceLightmap(surf);
 	}
 }