X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=clvm_cmds.c;h=cedd20815f1da92d18f43f4d1356a13b75d530a6;hp=26a5eaa7c278d0911d2131dea4054d7193e4ba93;hb=135f08ba52321984c05e36cdf42ad81420a4d2fd;hpb=deb439e4d0f954489242e932c0fefee5cc2b3f77

diff --git a/clvm_cmds.c b/clvm_cmds.c
index 26a5eaa7..cedd2081 100644
--- a/clvm_cmds.c
+++ b/clvm_cmds.c
@@ -29,13 +29,12 @@ void Sbar_SortFrags (void);
 void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
 void CSQC_RelinkAllEntities (int drawmask);
 void CSQC_RelinkCSQCEntities (void);
-const char *Key_GetBind (int key);
 
 // #1 void(vector ang) makevectors
 static void VM_CL_makevectors (void)
 {
 	VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
-	AngleVectors (PRVM_G_VECTOR(OFS_PARM0), prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up);
+	AngleVectors (PRVM_G_VECTOR(OFS_PARM0), PRVM_clientglobalvector(v_forward), PRVM_clientglobalvector(v_right), PRVM_clientglobalvector(v_up));
 }
 
 // #2 void(entity e, vector o) setorigin
@@ -57,7 +56,7 @@ void VM_CL_setorigin (void)
 		return;
 	}
 	org = PRVM_G_VECTOR(OFS_PARM1);
-	VectorCopy (org, e->fields.client->origin);
+	VectorCopy (org, PRVM_clientedictvector(e, origin));
 	CL_LinkEdict(e);
 }
 
@@ -70,9 +69,9 @@ static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max)
 			PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
 
 	// set derived values
-	VectorCopy (min, e->fields.client->mins);
-	VectorCopy (max, e->fields.client->maxs);
-	VectorSubtract (max, min, e->fields.client->size);
+	VectorCopy (min, PRVM_clientedictvector(e, mins));
+	VectorCopy (max, PRVM_clientedictvector(e, maxs));
+	VectorSubtract (max, min, PRVM_clientedictvector(e, size));
 
 	CL_LinkEdict (e);
 }
@@ -88,8 +87,8 @@ void VM_CL_setmodel (void)
 	VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
 
 	e = PRVM_G_EDICT(OFS_PARM0);
-	e->fields.client->modelindex = 0;
-	e->fields.client->model = 0;
+	PRVM_clientedictfloat(e, modelindex) = 0;
+	PRVM_clientedictstring(e, model) = 0;
 
 	m = PRVM_G_STRING(OFS_PARM1);
 	mod = NULL;
@@ -98,8 +97,8 @@ void VM_CL_setmodel (void)
 		if (!strcmp(cl.csqc_model_precache[i]->name, m))
 		{
 			mod = cl.csqc_model_precache[i];
-			e->fields.client->model = PRVM_SetEngineString(mod->name);
-			e->fields.client->modelindex = -(i+1);
+			PRVM_clientedictstring(e, model) = PRVM_SetEngineString(mod->name);
+			PRVM_clientedictfloat(e, modelindex) = -(i+1);
 			break;
 		}
 	}
@@ -110,8 +109,8 @@ void VM_CL_setmodel (void)
 			mod = cl.model_precache[i];
 			if (mod && !strcmp(mod->name, m))
 			{
-				e->fields.client->model = PRVM_SetEngineString(mod->name);
-				e->fields.client->modelindex = i;
+				PRVM_clientedictstring(e, model) = PRVM_SetEngineString(mod->name);
+				PRVM_clientedictfloat(e, modelindex) = i;
 				break;
 			}
 		}
@@ -235,10 +234,8 @@ static void VM_CL_spawn (void)
 
 void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
 {
-	prvm_eval_t *val;
 	VM_SetTraceGlobals(trace);
-	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_networkentity)))
-		val->_float = svent;
+	PRVM_clientglobalfloat(trace_networkentity) = svent;
 }
 
 #define CL_HitNetworkBrushModels(move) !((move) == MOVE_WORLDONLY)
@@ -252,6 +249,8 @@ static void VM_CL_traceline (void)
 	int		move, svent;
 	prvm_edict_t	*ent;
 
+//	R_TimeReport("pretraceline");
+
 	VM_SAFEPARMCOUNTRANGE(4, 4, VM_CL_traceline);
 
 	prog->xfunction->builtinsprofile += 30;
@@ -264,9 +263,10 @@ static void VM_CL_traceline (void)
 	if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v2[1]) || IS_NAN(v2[2]))
 		PRVM_ERROR("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
 
-	trace = CL_TraceLine(v1, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
+	trace = CL_TraceLine(v1, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true, false);
 
 	CL_VM_SetTraceGlobals(&trace, svent);
+//	R_TimeReport("traceline");
 }
 
 /*
@@ -288,6 +288,7 @@ static void VM_CL_tracebox (void)
 	int		move, svent;
 	prvm_edict_t	*ent;
 
+//	R_TimeReport("pretracebox");
 	VM_SAFEPARMCOUNTRANGE(6, 8, VM_CL_tracebox); // allow more parameters for future expansion
 
 	prog->xfunction->builtinsprofile += 30;
@@ -305,6 +306,7 @@ static void VM_CL_tracebox (void)
 	trace = CL_TraceBox(v1, m1, m2, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
 
 	CL_VM_SetTraceGlobals(&trace, svent);
+//	R_TimeReport("tracebox");
 }
 
 trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
@@ -316,38 +318,35 @@ trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
 	vec3_t original_velocity;
 	vec3_t original_angles;
 	vec3_t original_avelocity;
-	prvm_eval_t *val;
 	trace_t trace;
 
-	VectorCopy(tossent->fields.client->origin   , original_origin   );
-	VectorCopy(tossent->fields.client->velocity , original_velocity );
-	VectorCopy(tossent->fields.client->angles   , original_angles   );
-	VectorCopy(tossent->fields.client->avelocity, original_avelocity);
+	VectorCopy(PRVM_clientedictvector(tossent, origin)   , original_origin   );
+	VectorCopy(PRVM_clientedictvector(tossent, velocity) , original_velocity );
+	VectorCopy(PRVM_clientedictvector(tossent, angles)   , original_angles   );
+	VectorCopy(PRVM_clientedictvector(tossent, avelocity), original_avelocity);
 
-	val = PRVM_EDICTFIELDVALUE(tossent, prog->fieldoffsets.gravity);
-	if (val != NULL && val->_float != 0)
-		gravity = val->_float;
-	else
-		gravity = 1.0;
+	gravity = PRVM_clientedictfloat(tossent, gravity);
+	if (!gravity)
+		gravity = 1.0f;
 	gravity *= cl.movevars_gravity * 0.05;
 
 	for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
 	{
-		tossent->fields.client->velocity[2] -= gravity;
-		VectorMA (tossent->fields.client->angles, 0.05, tossent->fields.client->avelocity, tossent->fields.client->angles);
-		VectorScale (tossent->fields.client->velocity, 0.05, move);
-		VectorAdd (tossent->fields.client->origin, move, end);
-		trace = CL_TraceBox(tossent->fields.client->origin, tossent->fields.client->mins, tossent->fields.client->maxs, end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), true, true, NULL, true);
-		VectorCopy (trace.endpos, tossent->fields.client->origin);
+		PRVM_clientedictvector(tossent, velocity)[2] -= gravity;
+		VectorMA (PRVM_clientedictvector(tossent, angles), 0.05, PRVM_clientedictvector(tossent, avelocity), PRVM_clientedictvector(tossent, angles));
+		VectorScale (PRVM_clientedictvector(tossent, velocity), 0.05, move);
+		VectorAdd (PRVM_clientedictvector(tossent, origin), move, end);
+		trace = CL_TraceBox(PRVM_clientedictvector(tossent, origin), PRVM_clientedictvector(tossent, mins), PRVM_clientedictvector(tossent, maxs), end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), true, true, NULL, true);
+		VectorCopy (trace.endpos, PRVM_clientedictvector(tossent, origin));
 
 		if (trace.fraction < 1)
 			break;
 	}
 
-	VectorCopy(original_origin   , tossent->fields.client->origin   );
-	VectorCopy(original_velocity , tossent->fields.client->velocity );
-	VectorCopy(original_angles   , tossent->fields.client->angles   );
-	VectorCopy(original_avelocity, tossent->fields.client->avelocity);
+	VectorCopy(original_origin   , PRVM_clientedictvector(tossent, origin)   );
+	VectorCopy(original_velocity , PRVM_clientedictvector(tossent, velocity) );
+	VectorCopy(original_angles   , PRVM_clientedictvector(tossent, angles)   );
+	VectorCopy(original_avelocity, PRVM_clientedictvector(tossent, avelocity));
 
 	return trace;
 }
@@ -357,7 +356,7 @@ static void VM_CL_tracetoss (void)
 	trace_t	trace;
 	prvm_edict_t	*ent;
 	prvm_edict_t	*ignore;
-	int svent;
+	int svent = 0;
 
 	prog->xfunction->builtinsprofile += 600;
 
@@ -424,7 +423,7 @@ int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **li
 	{
 		if (ent->priv.required->free)
 			continue;
-		if(BoxesOverlap(mins, maxs, ent->fields.client->absmin, ent->fields.client->absmax))
+		if(BoxesOverlap(mins, maxs, PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax)))
 			list[k++] = ent;
 	}
 	return k;
@@ -473,23 +472,23 @@ static void VM_CL_findradius (void)
 		ent = touchedicts[i];
 		// Quake did not return non-solid entities but darkplaces does
 		// (note: this is the reason you can't blow up fallen zombies)
-		if (ent->fields.client->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
+		if (PRVM_clientedictfloat(ent, solid) == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
 			continue;
 		// LordHavoc: compare against bounding box rather than center so it
 		// doesn't miss large objects, and use DotProduct instead of Length
 		// for a major speedup
-		VectorSubtract(org, ent->fields.client->origin, eorg);
+		VectorSubtract(org, PRVM_clientedictvector(ent, origin), eorg);
 		if (sv_gameplayfix_findradiusdistancetobox.integer)
 		{
-			eorg[0] -= bound(ent->fields.client->mins[0], eorg[0], ent->fields.client->maxs[0]);
-			eorg[1] -= bound(ent->fields.client->mins[1], eorg[1], ent->fields.client->maxs[1]);
-			eorg[2] -= bound(ent->fields.client->mins[2], eorg[2], ent->fields.client->maxs[2]);
+			eorg[0] -= bound(PRVM_clientedictvector(ent, mins)[0], eorg[0], PRVM_clientedictvector(ent, maxs)[0]);
+			eorg[1] -= bound(PRVM_clientedictvector(ent, mins)[1], eorg[1], PRVM_clientedictvector(ent, maxs)[1]);
+			eorg[2] -= bound(PRVM_clientedictvector(ent, mins)[2], eorg[2], PRVM_clientedictvector(ent, maxs)[2]);
 		}
 		else
-			VectorMAMAM(1, eorg, -0.5f, ent->fields.client->mins, -0.5f, ent->fields.client->maxs, eorg);
+			VectorMAMAM(1, eorg, -0.5f, PRVM_clientedictvector(ent, mins), -0.5f, PRVM_clientedictvector(ent, maxs), eorg);
 		if (DotProduct(eorg, eorg) < radius2)
 		{
-			PRVM_EDICTFIELDVALUE(ent, chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
+			PRVM_EDICTFIELDEDICT(ent, chainfield) = PRVM_EDICT_TO_PROG(chain);
 			chain = ent;
 		}
 	}
@@ -501,7 +500,6 @@ static void VM_CL_findradius (void)
 static void VM_CL_droptofloor (void)
 {
 	prvm_edict_t		*ent;
-	prvm_eval_t			*val;
 	vec3_t				end;
 	trace_t				trace;
 
@@ -510,7 +508,7 @@ static void VM_CL_droptofloor (void)
 	// assume failure if it returns early
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
 
-	ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
+	ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));
 	if (ent == prog->edicts)
 	{
 		VM_Warning("droptofloor: can not modify world entity\n");
@@ -522,17 +520,16 @@ static void VM_CL_droptofloor (void)
 		return;
 	}
 
-	VectorCopy (ent->fields.client->origin, end);
+	VectorCopy (PRVM_clientedictvector(ent, origin), end);
 	end[2] -= 256;
 
-	trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
+	trace = CL_TraceBox(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
 
 	if (trace.fraction != 1)
 	{
-		VectorCopy (trace.endpos, ent->fields.client->origin);
-		ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.groundentity)))
-			val->edict = PRVM_EDICT_TO_PROG(trace.ent);
+		VectorCopy (trace.endpos, PRVM_clientedictvector(ent, origin));
+		PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) | FL_ONGROUND;
+		PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
 		PRVM_G_FLOAT(OFS_RETURN) = 1;
 		// if support is destroyed, keep suspended (gross hack for floating items in various maps)
 //		ent->priv.server->suspendedinairflag = true;
@@ -573,8 +570,8 @@ static void VM_CL_checkbottom (void)
 	ent = PRVM_G_EDICT(OFS_PARM0);
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
 
-	VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
-	VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
+	VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
+	VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);
 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks
@@ -604,7 +601,7 @@ realcheck:
 	start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
 	start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
 	stop[2] = start[2] - 2*sv_stepheight.value;
-	trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
+	trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true, false);
 
 	if (trace.fraction == 1.0)
 		return;
@@ -618,7 +615,7 @@ realcheck:
 			start[0] = stop[0] = x ? maxs[0] : mins[0];
 			start[1] = stop[1] = y ? maxs[1] : mins[1];
 
-			trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
+			trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true, false);
 
 			if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
 				bottom = trace.endpos[2];
@@ -663,33 +660,37 @@ static void VM_CL_ambientsound (void)
 	S_StaticSound (s, f, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3)*64);
 }
 
-// #92 vector(vector org) getlight (DP_QC_GETLIGHT)
+// #92 vector(vector org[, float lpflag]) getlight (DP_QC_GETLIGHT)
 static void VM_CL_getlight (void)
 {
 	vec3_t ambientcolor, diffusecolor, diffusenormal;
 	vec_t *p;
 
-	VM_SAFEPARMCOUNT(1, VM_CL_getlight);
+	VM_SAFEPARMCOUNTRANGE(1, 2, VM_CL_getlight);
 
 	p = PRVM_G_VECTOR(OFS_PARM0);
 	VectorClear(ambientcolor);
 	VectorClear(diffusecolor);
 	VectorClear(diffusenormal);
-	if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
+	if (prog->argc >= 2)
+		R_CompleteLightPoint(ambientcolor, diffusecolor, diffusenormal, p, PRVM_G_FLOAT(OFS_PARM1));
+	else if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
 		cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
 	VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
 }
 
-
 //============================================================================
 //[515]: SCENE MANAGER builtins
 extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed, int edictnum);//csprogs.c
 
-static void CSQC_R_RecalcView (void)
+void CSQC_R_RecalcView (void)
 {
-	extern matrix4x4_t viewmodelmatrix;
-	Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], 1);
-	Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], cl_viewmodel_scale.value);
+	extern matrix4x4_t viewmodelmatrix_nobob;
+	extern matrix4x4_t viewmodelmatrix_withbob;
+	Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, cl.csqc_vieworigin[0], cl.csqc_vieworigin[1], cl.csqc_vieworigin[2], cl.csqc_viewangles[0], cl.csqc_viewangles[1], cl.csqc_viewangles[2], 1);
+	Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
+	Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
+	Matrix4x4_Concat(&viewmodelmatrix_withbob, &r_refdef.view.matrix, &cl.csqc_viewmodelmatrixfromengine);
 }
 
 void CL_RelinkLightFlashes(void);
@@ -717,11 +718,12 @@ void VM_CL_R_ClearScene (void)
 	r_refdef.view.ortho_y = scr_fov.value * (3.0 / 4.0);
 	r_refdef.view.clear = true;
 	r_refdef.view.isoverlay = false;
-	// FIXME: restore cl.csqc_origin
-	// FIXME: restore cl.csqc_angles
-	cl.csqc_vidvars.drawworld = true;
+	VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
+	VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
+	cl.csqc_vidvars.drawworld = r_drawworld.integer != 0;
 	cl.csqc_vidvars.drawenginesbar = false;
 	cl.csqc_vidvars.drawcrosshair = false;
+	CSQC_R_RecalcView();
 }
 
 //#301 void(float mask) addentities (EXT_CSQC)
@@ -737,9 +739,11 @@ void VM_CL_R_AddEntities (void)
 	CSQC_RelinkAllEntities(drawmask);
 	CL_RelinkLightFlashes();
 
-	prog->globals.client->time = cl.time;
+	PRVM_clientglobalfloat(time) = cl.time;
 	for(i=1;i<prog->num_edicts;i++)
 	{
+		// so we can easily check if CSQC entity #edictnum is currently drawn
+		cl.csqcrenderentities[i].entitynumber = 0;
 		ed = &prog->edicts[i];
 		if(ed->priv.required->free)
 			continue;
@@ -750,13 +754,13 @@ void VM_CL_R_AddEntities (void)
 		CSQC_Predraw(ed);
 		if(ed->priv.required->free)
 			continue;
-		if(!((int)ed->fields.client->drawmask & drawmask))
+		if(!((int)PRVM_clientedictfloat(ed, drawmask) & drawmask))
 			continue;
 		CSQC_AddRenderEdict(ed, i);
 	}
 
 	// callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
-	prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
+	prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
 }
 
 //#302 void(entity ent) addentity (EXT_CSQC)
@@ -765,43 +769,146 @@ void VM_CL_R_AddEntity (void)
 	double t = Sys_DoubleTime();
 	VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntity);
 	CSQC_AddRenderEdict(PRVM_G_EDICT(OFS_PARM0), 0);
-	prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
+	prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
 }
 
 //#303 float(float property, ...) setproperty (EXT_CSQC)
+//#303 float(float property) getproperty
+//#303 vector(float property) getpropertyvec
+// VorteX: make this function be able to return previously set property if new value is not given
 void VM_CL_R_SetView (void)
 {
 	int		c;
 	float	*f;
 	float	k;
 
-	VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_SetView);
+	VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_R_SetView);
 
 	c = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	// return value?
+	if (prog->argc < 2)
+	{
+		switch(c)
+		{
+		case VF_MIN:
+			VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.x, r_refdef.view.y, 0);
+			break;
+		case VF_MIN_X:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.x;
+			break;
+		case VF_MIN_Y:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.y;
+			break;
+		case VF_SIZE:
+			VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.width, r_refdef.view.height, 0);
+			break;
+		case VF_SIZE_X:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.width;
+			break;
+		case VF_SIZE_Y:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.height;
+			break;
+		case VF_VIEWPORT:
+			VM_Warning("VM_CL_R_GetView : VF_VIEWPORT can't be retrieved, use VF_MIN/VF_SIZE instead\n");
+			break;
+		case VF_FOV:
+			VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.ortho_x, r_refdef.view.ortho_y, 0);
+			break;
+		case VF_FOVX:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ortho_x;
+			break;
+		case VF_FOVY:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ortho_y;
+			break;
+		case VF_ORIGIN:
+			VectorCopy(cl.csqc_vieworigin, PRVM_G_VECTOR(OFS_RETURN));
+			break;
+		case VF_ORIGIN_X:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vieworigin[0];
+			break;
+		case VF_ORIGIN_Y:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vieworigin[1];
+			break;
+		case VF_ORIGIN_Z:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vieworigin[2];
+			break;
+		case VF_ANGLES:
+			VectorCopy(cl.csqc_viewangles, PRVM_G_VECTOR(OFS_RETURN));
+			break;
+		case VF_ANGLES_X:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_viewangles[0];
+			break;
+		case VF_ANGLES_Y:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_viewangles[1];
+			break;
+		case VF_ANGLES_Z:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_viewangles[2];
+			break;
+		case VF_DRAWWORLD:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawworld;
+			break;
+		case VF_DRAWENGINESBAR:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawenginesbar;
+			break;
+		case VF_DRAWCROSSHAIR:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawcrosshair;
+			break;
+		case VF_CL_VIEWANGLES:
+			VectorCopy(cl.viewangles, PRVM_G_VECTOR(OFS_RETURN));;
+			break;
+		case VF_CL_VIEWANGLES_X:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[0];
+			break;
+		case VF_CL_VIEWANGLES_Y:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[1];
+			break;
+		case VF_CL_VIEWANGLES_Z:
+			PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[2];
+			break;
+		case VF_PERSPECTIVE:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.useperspective;
+			break;
+		case VF_CLEARSCREEN:
+			PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.isoverlay;
+			break;
+		default:
+			PRVM_G_FLOAT(OFS_RETURN) = 0;
+			VM_Warning("VM_CL_R_GetView : unknown parm %i\n", c);
+			return;
+		}
+		return;
+	}
+
 	f = PRVM_G_VECTOR(OFS_PARM1);
 	k = PRVM_G_FLOAT(OFS_PARM1);
-
 	switch(c)
 	{
 	case VF_MIN:
 		r_refdef.view.x = (int)(f[0]);
 		r_refdef.view.y = (int)(f[1]);
+		DrawQ_RecalcView();
 		break;
 	case VF_MIN_X:
 		r_refdef.view.x = (int)(k);
+		DrawQ_RecalcView();
 		break;
 	case VF_MIN_Y:
 		r_refdef.view.y = (int)(k);
+		DrawQ_RecalcView();
 		break;
 	case VF_SIZE:
 		r_refdef.view.width = (int)(f[0]);
 		r_refdef.view.height = (int)(f[1]);
+		DrawQ_RecalcView();
 		break;
 	case VF_SIZE_X:
 		r_refdef.view.width = (int)(k);
+		DrawQ_RecalcView();
 		break;
 	case VF_SIZE_Y:
 		r_refdef.view.height = (int)(k);
+		DrawQ_RecalcView();
 		break;
 	case VF_VIEWPORT:
 		r_refdef.view.x = (int)(f[0]);
@@ -809,6 +916,7 @@ void VM_CL_R_SetView (void)
 		f = PRVM_G_VECTOR(OFS_PARM2);
 		r_refdef.view.width = (int)(f[0]);
 		r_refdef.view.height = (int)(f[1]);
+		DrawQ_RecalcView();
 		break;
 	case VF_FOV:
 		r_refdef.view.frustum_x = tan(f[0] * M_PI / 360.0);r_refdef.view.ortho_x = f[0];
@@ -821,39 +929,39 @@ void VM_CL_R_SetView (void)
 		r_refdef.view.frustum_y = tan(k * M_PI / 360.0);r_refdef.view.ortho_y = k;
 		break;
 	case VF_ORIGIN:
-		VectorCopy(f, cl.csqc_origin);
+		VectorCopy(f, cl.csqc_vieworigin);
 		CSQC_R_RecalcView();
 		break;
 	case VF_ORIGIN_X:
-		cl.csqc_origin[0] = k;
+		cl.csqc_vieworigin[0] = k;
 		CSQC_R_RecalcView();
 		break;
 	case VF_ORIGIN_Y:
-		cl.csqc_origin[1] = k;
+		cl.csqc_vieworigin[1] = k;
 		CSQC_R_RecalcView();
 		break;
 	case VF_ORIGIN_Z:
-		cl.csqc_origin[2] = k;
+		cl.csqc_vieworigin[2] = k;
 		CSQC_R_RecalcView();
 		break;
 	case VF_ANGLES:
-		VectorCopy(f, cl.csqc_angles);
+		VectorCopy(f, cl.csqc_viewangles);
 		CSQC_R_RecalcView();
 		break;
 	case VF_ANGLES_X:
-		cl.csqc_angles[0] = k;
+		cl.csqc_viewangles[0] = k;
 		CSQC_R_RecalcView();
 		break;
 	case VF_ANGLES_Y:
-		cl.csqc_angles[1] = k;
+		cl.csqc_viewangles[1] = k;
 		CSQC_R_RecalcView();
 		break;
 	case VF_ANGLES_Z:
-		cl.csqc_angles[2] = k;
+		cl.csqc_viewangles[2] = k;
 		CSQC_R_RecalcView();
 		break;
 	case VF_DRAWWORLD:
-		cl.csqc_vidvars.drawworld = k != 0;
+		cl.csqc_vidvars.drawworld = ((k != 0) && r_drawworld.integer);
 		break;
 	case VF_DRAWENGINESBAR:
 		cl.csqc_vidvars.drawenginesbar = k != 0;
@@ -930,14 +1038,14 @@ void VM_CL_R_AddDynamicLight (void)
 	coronaintensity = (pflags & PFLAGS_CORONA) != 0;
 	castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
 
-	VectorScale(prog->globals.client->v_forward, radius, forward);
-	VectorScale(prog->globals.client->v_right, -radius, left);
-	VectorScale(prog->globals.client->v_up, radius, up);
+	VectorScale(PRVM_clientglobalvector(v_forward), radius, forward);
+	VectorScale(PRVM_clientglobalvector(v_right), -radius, left);
+	VectorScale(PRVM_clientglobalvector(v_up), radius, up);
 	Matrix4x4_FromVectors(&matrix, forward, left, up, org);
 
 	R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
-	r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights++];
-	prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
+	r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
+	prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
 }
 
 //============================================================================
@@ -950,12 +1058,12 @@ static void VM_CL_unproject (void)
 
 	VM_SAFEPARMCOUNT(1, VM_CL_unproject);
 	f = PRVM_G_VECTOR(OFS_PARM0);
-	if(v_flipped.integer)
-		f[0] = (2 * r_refdef.view.x + r_refdef.view.width) * (vid_conwidth.integer / (float) vid.width) - f[0];
 	VectorSet(temp,
 		f[2],
-		(-1.0 + 2.0 * (f[0] / (vid_conwidth.integer / (float) vid.width) - r_refdef.view.x) / r_refdef.view.width) * f[2] * -r_refdef.view.frustum_x,
-		(-1.0 + 2.0 * (f[1] / (vid_conheight.integer / (float) vid.height) - r_refdef.view.y) / r_refdef.view.height) * f[2] * -r_refdef.view.frustum_y);
+		(-1.0 + 2.0 * (f[0] / vid_conwidth.integer)) * f[2] * -r_refdef.view.frustum_x,
+		(-1.0 + 2.0 * (f[1] / vid_conheight.integer)) * f[2] * -r_refdef.view.frustum_y);
+	if(v_flipped.integer)
+		temp[1] = -temp[1];
 	Matrix4x4_Transform(&r_refdef.view.matrix, temp, PRVM_G_VECTOR(OFS_RETURN));
 }
 
@@ -973,9 +1081,12 @@ static void VM_CL_project (void)
 	if(v_flipped.integer)
 		v[1] = -v[1];
 	VectorSet(PRVM_G_VECTOR(OFS_RETURN),
-		(vid_conwidth.integer / (float) vid.width) * (r_refdef.view.x + r_refdef.view.width*0.5*(1.0+v[1]/v[0]/-r_refdef.view.frustum_x)),
-		(vid_conheight.integer / (float) vid.height) * (r_refdef.view.y + r_refdef.view.height*0.5*(1.0+v[2]/v[0]/-r_refdef.view.frustum_y)),
+		vid_conwidth.integer * (0.5*(1.0+v[1]/v[0]/-r_refdef.view.frustum_x)),
+		vid_conheight.integer * (0.5*(1.0+v[2]/v[0]/-r_refdef.view.frustum_y)),
 		v[0]);
+	// explanation:
+	// after transforming, relative position to viewport (0..1) = 0.5 * (1 + v[2]/v[0]/-frustum_{x \or y})
+	// as 2D drawing honors the viewport too, to get the same pixel, we simply multiply this by conwidth/height
 }
 
 //#330 float(float stnum) getstatf (EXT_CSQC)
@@ -1062,8 +1173,8 @@ static void VM_CL_setmodelindex (void)
 
 	i = (int)PRVM_G_FLOAT(OFS_PARM1);
 
-	t->fields.client->model = 0;
-	t->fields.client->modelindex = 0;
+	PRVM_clientedictstring(t, model) = 0;
+	PRVM_clientedictfloat(t, modelindex) = 0;
 
 	if (!i)
 		return;
@@ -1074,8 +1185,8 @@ static void VM_CL_setmodelindex (void)
 		VM_Warning("VM_CL_setmodelindex: null model\n");
 		return;
 	}
-	t->fields.client->model = PRVM_SetEngineString(model->name);
-	t->fields.client->modelindex = i;
+	PRVM_clientedictstring(t, model) = PRVM_SetEngineString(model->name);
+	PRVM_clientedictfloat(t, modelindex) = i;
 
 	// TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
 	if (model)
@@ -1124,29 +1235,72 @@ static void VM_CL_trailparticles (void)
 
 	if (i < 0)
 		return;
-	CL_ParticleEffect(i, VectorDistance(start, end), start, end, t->fields.client->velocity, t->fields.client->velocity, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
+	CL_ParticleEffect(i, 1, start, end, PRVM_clientedictvector(t, velocity), PRVM_clientedictvector(t, velocity), NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
 }
 
 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
 static void VM_CL_pointparticles (void)
 {
-	int			i, n;
+	int			i;
+	float n;
 	float		*f, *v;
 	VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_pointparticles);
 	i = (int)PRVM_G_FLOAT(OFS_PARM0);
 	f = PRVM_G_VECTOR(OFS_PARM1);
 	v = PRVM_G_VECTOR(OFS_PARM2);
-	n = (int)PRVM_G_FLOAT(OFS_PARM3);
+	n = PRVM_G_FLOAT(OFS_PARM3);
 	if (i < 0)
 		return;
 	CL_ParticleEffect(i, n, f, f, v, v, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
 }
 
-//#342 string(float keynum) getkeybind (EXT_CSQC)
-static void VM_CL_getkeybind (void)
+//#502 void(float effectnum, entity own, vector origin_from, vector origin_to, vector dir_from, vector dir_to, float count, float extflags) boxparticles (DP_CSQC_BOXPARTICLES)
+static void VM_CL_boxparticles (void)
+{
+	int effectnum;
+	// prvm_edict_t *own;
+	float *origin_from, *origin_to, *dir_from, *dir_to;
+	float count;
+	int flags;
+	float tintmins[4], tintmaxs[4];
+	VM_SAFEPARMCOUNTRANGE(7, 8, VM_CL_boxparticles);
+
+	effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
+	// own = PRVM_G_EDICT(OFS_PARM1); // TODO find use for this
+	origin_from = PRVM_G_VECTOR(OFS_PARM2);
+	origin_to = PRVM_G_VECTOR(OFS_PARM3);
+	dir_from = PRVM_G_VECTOR(OFS_PARM4);
+	dir_to = PRVM_G_VECTOR(OFS_PARM5);
+	count = PRVM_G_FLOAT(OFS_PARM6);
+	if(prog->argc >= 8)
+		flags = PRVM_G_FLOAT(OFS_PARM7);
+	else
+		flags = 0;
+	Vector4Set(tintmins, 1, 1, 1, 1);
+	Vector4Set(tintmaxs, 1, 1, 1, 1);
+	if(flags & 1) // read alpha
+	{
+		tintmins[3] = PRVM_clientglobalfloat(particles_alphamin);
+		tintmaxs[3] = PRVM_clientglobalfloat(particles_alphamax);
+	}
+	if(flags & 2) // read color
+	{
+		VectorCopy(PRVM_clientglobalvector(particles_colormin), tintmins);
+		VectorCopy(PRVM_clientglobalvector(particles_colormax), tintmaxs);
+	}
+	if (effectnum < 0)
+		return;
+	CL_ParticleTrail(effectnum, count, origin_from, origin_to, dir_from, dir_to, NULL, 0, true, true, tintmins, tintmaxs);
+}
+
+//#531 void(float pause) setpause
+static void VM_CL_setpause(void) 
 {
-	VM_SAFEPARMCOUNT(1, VM_CL_getkeybind);
-	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0)));
+	VM_SAFEPARMCOUNT(1, VM_CL_setpause);
+	if ((int)PRVM_G_FLOAT(OFS_PARM0) != 0)
+		cl.csqc_paused = true;
+	else
+		cl.csqc_paused = false;
 }
 
 //#343 void(float usecursor) setcursormode (EXT_CSQC)
@@ -1181,21 +1335,21 @@ static void VM_CL_getinputstate (void)
 	{
 		if (cl.movecmd[i].sequence == frame)
 		{
-			VectorCopy(cl.movecmd[i].viewangles, prog->globals.client->input_angles);
-			prog->globals.client->input_buttons = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
-			prog->globals.client->input_movevalues[0] = cl.movecmd[i].forwardmove;
-			prog->globals.client->input_movevalues[1] = cl.movecmd[i].sidemove;
-			prog->globals.client->input_movevalues[2] = cl.movecmd[i].upmove;
-			prog->globals.client->input_timelength = cl.movecmd[i].frametime;
+			VectorCopy(cl.movecmd[i].viewangles, PRVM_clientglobalvector(input_angles));
+			PRVM_clientglobalfloat(input_buttons) = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
+			PRVM_clientglobalvector(input_movevalues)[0] = cl.movecmd[i].forwardmove;
+			PRVM_clientglobalvector(input_movevalues)[1] = cl.movecmd[i].sidemove;
+			PRVM_clientglobalvector(input_movevalues)[2] = cl.movecmd[i].upmove;
+			PRVM_clientglobalfloat(input_timelength) = cl.movecmd[i].frametime;
 			if(cl.movecmd[i].crouch)
 			{
-				VectorCopy(cl.playercrouchmins, prog->globals.client->pmove_mins);
-				VectorCopy(cl.playercrouchmaxs, prog->globals.client->pmove_maxs);
+				VectorCopy(cl.playercrouchmins, PRVM_clientglobalvector(pmove_mins));
+				VectorCopy(cl.playercrouchmaxs, PRVM_clientglobalvector(pmove_maxs));
 			}
 			else
 			{
-				VectorCopy(cl.playerstandmins, prog->globals.client->pmove_mins);
-				VectorCopy(cl.playerstandmaxs, prog->globals.client->pmove_maxs);
+				VectorCopy(cl.playerstandmins, PRVM_clientglobalvector(pmove_mins));
+				VectorCopy(cl.playerstandmaxs, PRVM_clientglobalvector(pmove_maxs));
 			}
 			PRVM_G_FLOAT(OFS_RETURN) = true;
 		}
@@ -1264,18 +1418,25 @@ static void VM_CL_getplayerkey (void)
 	else
 		if(!strcasecmp(c, "viewentity"))
 			dpsnprintf(t, sizeof(t), "%i", i+1);
+	else
+		if(gamemode == GAME_XONOTIC && !strcasecmp(c, "TEMPHACK_origin"))
+		{
+			// PLEASE REMOVE THIS once deltalisten() of EXT_CSQC_1
+			// is implemented, or Xonotic uses CSQC-networked
+			// players, whichever comes first
+			entity_t *e = cl.entities + (i+1);
+			if(e->state_current.active)
+			{
+				vec3_t origin;
+				Matrix4x4_OriginFromMatrix(&e->render.matrix, origin);
+				dpsnprintf(t, sizeof(t), "%.9g %.9g %.9g", origin[0], origin[1], origin[2]);
+			}
+		}
 	if(!t[0])
 		return;
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
 }
 
-//#349 float() isdemo (EXT_CSQC)
-static void VM_CL_isdemo (void)
-{
-	VM_SAFEPARMCOUNT(0, VM_CL_isdemo);
-	PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
-}
-
 //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
 static void VM_CL_setlistener (void)
 {
@@ -1390,7 +1551,7 @@ static void VM_CL_ReadPicture (void)
 			// texture found and loaded
 			// skip over the jpeg as we don't need it
 			for(i = 0; i < size; ++i)
-				MSG_ReadByte();
+				(void) MSG_ReadByte();
 		}
 		else
 		{
@@ -1398,7 +1559,7 @@ static void VM_CL_ReadPicture (void)
 			// use the attached jpeg as texture
 			buf = (unsigned char *) Mem_Alloc(tempmempool, size);
 			MSG_ReadBytes(size, buf);
-			data = JPEG_LoadImage_BGRA(buf, size);
+			data = JPEG_LoadImage_BGRA(buf, size, NULL);
 			Mem_Free(buf);
 			Draw_NewPic(name, image_width, image_height, false, data);
 			Mem_Free(data);
@@ -1431,40 +1592,42 @@ static void VM_CL_makestatic (void)
 	if (cl.num_static_entities < cl.max_static_entities)
 	{
 		int renderflags;
-		prvm_eval_t *val;
 		entity_t *staticent = &cl.static_entities[cl.num_static_entities++];
 
 		// copy it to the current state
 		memset(staticent, 0, sizeof(*staticent));
-		staticent->render.model = CL_GetModelByIndex((int)ent->fields.client->modelindex);
-		staticent->render.framegroupblend[0].frame = (int)ent->fields.client->frame;
+		staticent->render.model = CL_GetModelByIndex((int)PRVM_clientedictfloat(ent, modelindex));
+		staticent->render.framegroupblend[0].frame = (int)PRVM_clientedictfloat(ent, frame);
 		staticent->render.framegroupblend[0].lerp = 1;
 		// make torchs play out of sync
 		staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
-		staticent->render.skinnum = (int)ent->fields.client->skin;
-		staticent->render.effects = (int)ent->fields.client->effects;
-		staticent->render.alpha = 1;
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)) && val->_float) staticent->render.alpha = val->_float;
-		staticent->render.scale = 1;
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)) && val->_float) staticent->render.scale = val->_float;
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod)) && VectorLength2(val->vector)) VectorCopy(val->vector, staticent->render.colormod);
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glowmod)) && VectorLength2(val->vector)) VectorCopy(val->vector, staticent->render.glowmod);
+		staticent->render.skinnum = (int)PRVM_clientedictfloat(ent, skin);
+		staticent->render.effects = (int)PRVM_clientedictfloat(ent, effects);
+		staticent->render.alpha = PRVM_clientedictfloat(ent, alpha);
+		staticent->render.scale = PRVM_clientedictfloat(ent, scale);
+		VectorCopy(PRVM_clientedictvector(ent, colormod), staticent->render.colormod);
+		VectorCopy(PRVM_clientedictvector(ent, glowmod), staticent->render.glowmod);
+
+		// sanitize values
+		if (!staticent->render.alpha)
+			staticent->render.alpha = 1.0f;
+		if (!staticent->render.scale)
+			staticent->render.scale = 1.0f;
 		if (!VectorLength2(staticent->render.colormod))
 			VectorSet(staticent->render.colormod, 1, 1, 1);
 		if (!VectorLength2(staticent->render.glowmod))
 			VectorSet(staticent->render.glowmod, 1, 1, 1);
 
-		renderflags = 0;
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderflags)) && val->_float) renderflags = (int)val->_float;
+		renderflags = (int)PRVM_clientedictfloat(ent, renderflags);
 		if (renderflags & RF_USEAXIS)
 		{
 			vec3_t left;
-			VectorNegate(prog->globals.client->v_right, left);
-			Matrix4x4_FromVectors(&staticent->render.matrix, prog->globals.client->v_forward, left, prog->globals.client->v_up, ent->fields.client->origin);
+			VectorNegate(PRVM_clientglobalvector(v_right), left);
+			Matrix4x4_FromVectors(&staticent->render.matrix, PRVM_clientglobalvector(v_forward), left, PRVM_clientglobalvector(v_up), PRVM_clientedictvector(ent, origin));
 			Matrix4x4_Scale(&staticent->render.matrix, staticent->render.scale, 1);
 		}
 		else
-			Matrix4x4_CreateFromQuakeEntity(&staticent->render.matrix, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], staticent->render.scale);
+			Matrix4x4_CreateFromQuakeEntity(&staticent->render.matrix, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], staticent->render.scale);
 
 		// either fullbright or lit
 		if(!r_fullbright.integer)
@@ -1531,7 +1694,7 @@ static void VM_CL_copyentity (void)
 		VM_Warning("copyentity: can not modify free entity\n");
 		return;
 	}
-	memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
+	memcpy(out->fields.vp, in->fields.vp, prog->entityfields * 4);
 	CL_LinkEdict(out);
 }
 
@@ -1939,233 +2102,14 @@ static void VM_CL_te_flamejet (void)
 }
 
 
-//====================================================================
-//DP_QC_GETSURFACE
-
-extern void clippointtosurface(dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
-
-static msurface_t *cl_getsurface(dp_model_t *model, int surfacenum)
-{
-	if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
-		return NULL;
-	return model->data_surfaces + surfacenum + model->firstmodelsurface;
-}
-
-// #434 float(entity e, float s) getsurfacenumpoints
-static void VM_CL_getsurfacenumpoints(void)
-{
-	dp_model_t *model;
-	msurface_t *surface;
-	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenumpoints);
-	// return 0 if no such surface
-	if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
-	{
-		PRVM_G_FLOAT(OFS_RETURN) = 0;
-		return;
-	}
-
-	// note: this (incorrectly) assumes it is a simple polygon
-	PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
-}
-
-// #435 vector(entity e, float s, float n) getsurfacepoint
-static void VM_CL_getsurfacepoint(void)
-{
-	prvm_edict_t *ed;
-	dp_model_t *model;
-	msurface_t *surface;
-	int pointnum;
-	VM_SAFEPARMCOUNT(3, VM_CL_getsurfacenumpoints);
-	VectorClear(PRVM_G_VECTOR(OFS_RETURN));
-	ed = PRVM_G_EDICT(OFS_PARM0);
-	if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
-		return;
-	// note: this (incorrectly) assumes it is a simple polygon
-	pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
-	if (pointnum < 0 || pointnum >= surface->num_vertices)
-		return;
-	// FIXME: implement rotation/scaling
-	VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
-}
-//PF_getsurfacepointattribute,     // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
-// float SPA_POSITION = 0;
-// float SPA_S_AXIS = 1;
-// float SPA_T_AXIS = 2;
-// float SPA_R_AXIS = 3; // same as SPA_NORMAL
-// float SPA_TEXCOORDS0 = 4;
-// float SPA_LIGHTMAP0_TEXCOORDS = 5;
-// float SPA_LIGHTMAP0_COLOR = 6;
-// TODO: add some wrapper code and merge VM_CL/SV_getsurface* [12/16/2007 Black]
-static void VM_CL_getsurfacepointattribute(void)
-{
-	prvm_edict_t *ed;
-	dp_model_t *model;
-	msurface_t *surface;
-	int pointnum;
-	int attributetype;
-
-	VM_SAFEPARMCOUNT(4, VM_CL_getsurfacenumpoints);
-	VectorClear(PRVM_G_VECTOR(OFS_RETURN));
-	ed = PRVM_G_EDICT(OFS_PARM0);
-	if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
-		return;
-	// note: this (incorrectly) assumes it is a simple polygon
-	pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
-	if (pointnum < 0 || pointnum >= surface->num_vertices)
-		return;
-
-	// FIXME: implement rotation/scaling
-	attributetype = (int) PRVM_G_FLOAT(OFS_PARM3);
-
-	switch( attributetype ) {
-		// float SPA_POSITION = 0;
-		case 0:
-			VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
-			break;
-		// float SPA_S_AXIS = 1;
-		case 1:
-			VectorCopy(&(model->surfmesh.data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
-			break;
-		// float SPA_T_AXIS = 2;
-		case 2:
-			VectorCopy(&(model->surfmesh.data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
-			break;
-		// float SPA_R_AXIS = 3; // same as SPA_NORMAL
-		case 3:
-			VectorCopy(&(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
-			break;
-		// float SPA_TEXCOORDS0 = 4;
-		case 4: {
-			float *ret = PRVM_G_VECTOR(OFS_RETURN);
-			float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2];
-			ret[0] = texcoord[0];
-			ret[1] = texcoord[1];
-			ret[2] = 0.0f;
-			break;
-		}
-		// float SPA_LIGHTMAP0_TEXCOORDS = 5;
-		case 5: {
-			float *ret = PRVM_G_VECTOR(OFS_RETURN);
-			float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2];
-			ret[0] = texcoord[0];
-			ret[1] = texcoord[1];
-			ret[2] = 0.0f;
-			break;
-		}
-		// float SPA_LIGHTMAP0_COLOR = 6;
-		case 6:
-			// ignore alpha for now..
-			VectorCopy( &(model->surfmesh.data_lightmapcolor4f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN));
-			break;
-		default:
-			VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f );
-			break;
-	}
-}
-// #436 vector(entity e, float s) getsurfacenormal
-static void VM_CL_getsurfacenormal(void)
-{
-	dp_model_t *model;
-	msurface_t *surface;
-	vec3_t normal;
-	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenormal);
-	VectorClear(PRVM_G_VECTOR(OFS_RETURN));
-	if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
-		return;
-	// FIXME: implement rotation/scaling
-	// note: this (incorrectly) assumes it is a simple polygon
-	// note: this only returns the first triangle, so it doesn't work very
-	// well for curved surfaces or arbitrary meshes
-	TriangleNormal((model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 3, (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
-	VectorNormalize(normal);
-	VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
-}
-
-// #437 string(entity e, float s) getsurfacetexture
-static void VM_CL_getsurfacetexture(void)
-{
-	dp_model_t *model;
-	msurface_t *surface;
-	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacetexture);
-	PRVM_G_INT(OFS_RETURN) = OFS_NULL;
-	if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
-		return;
-	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
-}
-
-// #438 float(entity e, vector p) getsurfacenearpoint
-static void VM_CL_getsurfacenearpoint(void)
-{
-	int surfacenum, best;
-	vec3_t clipped, p;
-	vec_t dist, bestdist;
-	prvm_edict_t *ed;
-	dp_model_t *model = NULL;
-	msurface_t *surface;
-	vec_t *point;
-	VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenearpoint);
-	PRVM_G_FLOAT(OFS_RETURN) = -1;
-	ed = PRVM_G_EDICT(OFS_PARM0);
-	if(!(model = CL_GetModelFromEdict(ed)) || !model->num_surfaces)
-		return;
-
-	// FIXME: implement rotation/scaling
-	point = PRVM_G_VECTOR(OFS_PARM1);
-	VectorSubtract(point, ed->fields.client->origin, p);
-	best = -1;
-	bestdist = 1000000000;
-	for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
-	{
-		surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
-		// first see if the nearest point on the surface's box is closer than the previous match
-		clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
-		clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
-		clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
-		dist = VectorLength2(clipped);
-		if (dist < bestdist)
-		{
-			// it is, check the nearest point on the actual geometry
-			clippointtosurface(model, surface, p, clipped);
-			VectorSubtract(clipped, p, clipped);
-			dist += VectorLength2(clipped);
-			if (dist < bestdist)
-			{
-				// that's closer too, store it as the best match
-				best = surfacenum;
-				bestdist = dist;
-			}
-		}
-	}
-	PRVM_G_FLOAT(OFS_RETURN) = best;
-}
-
-// #439 vector(entity e, float s, vector p) getsurfaceclippedpoint
-static void VM_CL_getsurfaceclippedpoint(void)
-{
-	prvm_edict_t *ed;
-	dp_model_t *model;
-	msurface_t *surface;
-	vec3_t p, out;
-	VM_SAFEPARMCOUNT(3, VM_CL_getsurfaceclippedpoint);
-	VectorClear(PRVM_G_VECTOR(OFS_RETURN));
-	ed = PRVM_G_EDICT(OFS_PARM0);
-	if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
-		return;
-	// FIXME: implement rotation/scaling
-	VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.client->origin, p);
-	clippointtosurface(model, surface, p, out);
-	// FIXME: implement rotation/scaling
-	VectorAdd(out, ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
-}
-
 // #443 void(entity e, entity tagentity, string tagname) setattachment
 void VM_CL_setattachment (void)
 {
 	prvm_edict_t *e;
 	prvm_edict_t *tagentity;
 	const char *tagname;
-	prvm_eval_t *v;
 	int modelindex;
+	int tagindex;
 	dp_model_t *model;
 	VM_SAFEPARMCOUNT(3, VM_CL_setattachment);
 
@@ -2187,26 +2131,23 @@ void VM_CL_setattachment (void)
 	if (tagentity == NULL)
 		tagentity = prog->edicts;
 
-	v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_entity);
-	if (v)
-		v->edict = PRVM_EDICT_TO_PROG(tagentity);
-
-	v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_index);
-	if (v)
-		v->_float = 0;
+	tagindex = 0;
 	if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
 	{
-		modelindex = (int)tagentity->fields.client->modelindex;
+		modelindex = (int)PRVM_clientedictfloat(tagentity, modelindex);
 		model = CL_GetModelByIndex(modelindex);
 		if (model)
 		{
-			v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.client->skin, tagname);
-			if (v->_float == 0)
+			tagindex = Mod_Alias_GetTagIndexForName(model, (int)PRVM_clientedictfloat(tagentity, skin), tagname);
+			if (tagindex == 0)
 				Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
 		}
 		else
 			Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
 	}
+
+	PRVM_clientedictedict(e, tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
+	PRVM_clientedictfloat(e, tag_index) = tagindex;
 }
 
 /////////////////////////////////////////
@@ -2216,7 +2157,7 @@ int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
 {
 	dp_model_t *model = CL_GetModelFromEdict(e);
 	if (model)
-		return Mod_Alias_GetTagIndexForName(model, (int)e->fields.client->skin, tagname);
+		return Mod_Alias_GetTagIndexForName(model, (int)PRVM_clientedictfloat(e, skin), tagname);
 	else
 		return -1;
 }
@@ -2234,7 +2175,7 @@ int CL_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, cons
 	 && (model = CL_GetModelFromEdict(e))
 	 && model->animscenes)
 	{
-		r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.client->skin, e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
+		r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)PRVM_clientedictfloat(e, skin), e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
 
 		if(!r) // success?
 			*parentindex += 1;
@@ -2255,22 +2196,31 @@ int CL_GetPitchSign(prvm_edict_t *ent)
 
 void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
 {
-	prvm_eval_t *val;
 	float scale;
 	float pitchsign = 1;
 
-	scale = 1;
-	val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale);
-	if (val && val->_float != 0)
-		scale = val->_float;
+	scale = PRVM_clientedictfloat(ent, scale);
+	if (!scale)
+		scale = 1.0f;
 
-	// TODO do we need the same weird angle inverting logic here as in the server side case?
 	if(viewmatrix)
-		Matrix4x4_CreateFromQuakeEntity(out, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], scale * cl_viewmodel_scale.value);
+		*out = r_refdef.view.matrix;
+	else if ((int)PRVM_clientedictfloat(ent, renderflags) & RF_USEAXIS)
+	{
+		vec3_t forward;
+		vec3_t left;
+		vec3_t up;
+		vec3_t origin;
+		VectorScale(PRVM_clientglobalvector(v_forward), scale, forward);
+		VectorScale(PRVM_clientglobalvector(v_right), -scale, left);
+		VectorScale(PRVM_clientglobalvector(v_up), scale, up);
+		VectorCopy(PRVM_clientedictvector(ent, origin), origin);
+		Matrix4x4_FromVectors(out, forward, left, up, origin);
+	}
 	else
 	{
 		pitchsign = CL_GetPitchSign(ent);
-		Matrix4x4_CreateFromQuakeEntity(out, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], pitchsign * ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], scale);
+		Matrix4x4_CreateFromQuakeEntity(out, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], pitchsign * PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], scale);
 	}
 }
 
@@ -2303,7 +2253,6 @@ extern cvar_t cl_bobup;
 int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 {
 	int ret;
-	prvm_eval_t *val;
 	int attachloop;
 	matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
 	dp_model_t *model;
@@ -2334,10 +2283,10 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 		Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
 		Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
 		// next iteration we process the parent entity
-		if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)) && val->edict)
+		if (PRVM_clientedictedict(ent, tag_entity))
 		{
-			tagindex = (int)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
-			ent = PRVM_EDICT_NUM(val->edict);
+			tagindex = (int)PRVM_clientedictfloat(ent, tag_index);
+			ent = PRVM_EDICT_NUM(PRVM_clientedictedict(ent, tag_entity));
 		}
 		else
 			break;
@@ -2345,7 +2294,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 	}
 
 	// RENDER_VIEWMODEL magic
-	if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderflags)) && (RF_VIEWMODEL & (int)val->_float))
+	if ((int)PRVM_clientedictfloat(ent, renderflags) & RF_VIEWMODEL)
 	{
 		Matrix4x4_Copy(&tagmatrix, out);
 
@@ -2354,7 +2303,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 
 		/*
 		// Cl_bob, ported from rendering code
-		if (ent->fields.client->health > 0 && cl_bob.value && cl_bobcycle.value)
+		if (PRVM_clientedictfloat(ent, health) > 0 && cl_bob.value && cl_bobcycle.value)
 		{
 			double bob, cycle;
 			// LordHavoc: this code is *weird*, but not replacable (I think it
@@ -2369,7 +2318,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 				cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
 			// bob is proportional to velocity in the xy plane
 			// (don't count Z, or jumping messes it up)
-			bob = sqrt(ent->fields.client->velocity[0]*ent->fields.client->velocity[0] + ent->fields.client->velocity[1]*ent->fields.client->velocity[1])*cl_bob.value;
+			bob = sqrt(PRVM_clientedictvector(ent, velocity)[0]*PRVM_clientedictvector(ent, velocity)[0] + PRVM_clientedictvector(ent, velocity)[1]*PRVM_clientedictvector(ent, velocity)[1])*cl_bob.value;
 			bob = bob*0.3 + bob*0.7*cycle;
 			Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
 		}
@@ -2407,7 +2356,7 @@ void VM_CL_gettagindex (void)
 	{
 		tag_index = CL_GetTagIndex(ent, tag_name);
 		if (tag_index == 0)
-			Con_Printf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
+			Con_DPrintf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
 	}
 	PRVM_G_FLOAT(OFS_RETURN) = tag_index;
 }
@@ -2422,7 +2371,6 @@ void VM_CL_gettaginfo (void)
 	int parentindex;
 	const char *tagname;
 	int returncode;
-	prvm_eval_t *val;
 	vec3_t fo, le, up, trans;
 	const dp_model_t *model;
 
@@ -2431,8 +2379,8 @@ void VM_CL_gettaginfo (void)
 	e = PRVM_G_EDICT(OFS_PARM0);
 	tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
 	returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
-	Matrix4x4_ToVectors(&tag_matrix, prog->globals.client->v_forward, le, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
-	VectorScale(le, -1, prog->globals.client->v_right);
+	Matrix4x4_ToVectors(&tag_matrix, PRVM_clientglobalvector(v_forward), le, PRVM_clientglobalvector(v_up), PRVM_G_VECTOR(OFS_RETURN));
+	VectorScale(le, -1, PRVM_clientglobalvector(v_right));
 	model = CL_GetModelFromEdict(e);
 	VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
 	VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
@@ -2440,18 +2388,12 @@ void VM_CL_gettaginfo (void)
 	CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
 	Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
 
-	if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_parent)))
-		val->_float = parentindex;
-	if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_name)))
-		val->string = tagname ? PRVM_SetTempString(tagname) : 0;
-	if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_offset)))
-		VectorCopy(trans, val->vector);
-	if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_forward)))
-		VectorCopy(fo, val->vector);
-	if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_right)))
-		VectorScale(le, -1, val->vector);
-	if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_up)))
-		VectorCopy(up, val->vector);
+	PRVM_clientglobalfloat(gettaginfo_parent) = parentindex;
+	PRVM_clientglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(tagname) : 0;
+	VectorCopy(trans, PRVM_clientglobalvector(gettaginfo_offset));
+	VectorCopy(fo, PRVM_clientglobalvector(gettaginfo_forward));
+	VectorScale(le, -1, PRVM_clientglobalvector(gettaginfo_right));
+	VectorCopy(up, PRVM_clientglobalvector(gettaginfo_up));
 
 	switch(returncode)
 	{
@@ -2492,8 +2434,8 @@ typedef struct vmparticletheme_s
 	int tex;
 	float size;
 	float sizeincrease;
-	int alpha;
-	int alphafade;
+	float alpha;
+	float alphafade;
 	float gravity;
 	float bounce;
 	float airfriction;
@@ -2506,8 +2448,12 @@ typedef struct vmparticletheme_s
 	int staincolor1;
 	int staincolor2;
 	int staintex;
+	float stainalpha;
+	float stainsize;
 	float delayspawn;
 	float delaycollision;
+	float angle;
+	float spin;
 }vmparticletheme_t;
 
 // particle spawner
@@ -2540,9 +2486,13 @@ typedef struct vmparticlespawner_s
 	float *particle_stretch;
 	float *particle_staincolor1;
 	float *particle_staincolor2;
+	float *particle_stainalpha;
+	float *particle_stainsize;
 	float *particle_staintex;
 	float *particle_delayspawn;
 	float *particle_delaycollision;
+	float *particle_angle;
+	float *particle_spin;
 }vmparticlespawner_t;
 
 vmparticlespawner_t vmpartspawner;
@@ -2550,8 +2500,6 @@ vmparticlespawner_t vmpartspawner;
 // TODO: automatic max_themes grow
 static void VM_InitParticleSpawner (int maxthemes)
 {
-	prvm_eval_t *val;
-
 	// bound max themes to not be an insane value
 	if (maxthemes < 4)
 		maxthemes = 4;
@@ -2569,32 +2517,35 @@ static void VM_InitParticleSpawner (int maxthemes)
 	vmpartspawner.initialized = true;
 	vmpartspawner.verified = true;
 	// get field addresses for fast querying (we can do 1000 calls of spawnparticle in a frame)
-	#define getglobal(v,s) val = PRVM_GLOBALFIELDVALUE(PRVM_ED_FindGlobalOffset(s)); if (val) { vmpartspawner.v = &val->_float; } else { VM_Warning("VM_InitParticleSpawner: missing global '%s', spawner cannot work\n", s); vmpartspawner.verified = false; }
-	#define getglobalvector(v,s) val = PRVM_GLOBALFIELDVALUE(PRVM_ED_FindGlobalOffset(s)); if (val) { vmpartspawner.v = (float *)val->vector; } else { VM_Warning("VM_InitParticleSpawner: missing global '%s', spawner cannot work\n", s); vmpartspawner.verified = false; }
-	getglobal(particle_type, "particle_type");
-	getglobal(particle_blendmode, "particle_blendmode");
-	getglobal(particle_orientation, "particle_orientation");
-	getglobalvector(particle_color1, "particle_color1");
-	getglobalvector(particle_color2, "particle_color2");
-	getglobal(particle_tex, "particle_tex");
-	getglobal(particle_size, "particle_size");
-	getglobal(particle_sizeincrease, "particle_sizeincrease");
-	getglobal(particle_alpha, "particle_alpha");
-	getglobal(particle_alphafade, "particle_alphafade");
-	getglobal(particle_time, "particle_time");
-	getglobal(particle_gravity, "particle_gravity");
-	getglobal(particle_bounce, "particle_bounce");
-	getglobal(particle_airfriction, "particle_airfriction");
-	getglobal(particle_liquidfriction, "particle_liquidfriction");
-	getglobal(particle_originjitter, "particle_originjitter");
-	getglobal(particle_velocityjitter, "particle_velocityjitter");
-	getglobal(particle_qualityreduction, "particle_qualityreduction");
-	getglobal(particle_stretch, "particle_stretch");
-	getglobalvector(particle_staincolor1, "particle_staincolor1");
-	getglobalvector(particle_staincolor2, "particle_staincolor2");
-	getglobal(particle_staintex, "particle_staintex");
-	getglobal(particle_delayspawn, "particle_delayspawn");
-	getglobal(particle_delaycollision, "particle_delaycollision");
+	vmpartspawner.particle_type = &PRVM_clientglobalfloat(particle_type);
+	vmpartspawner.particle_blendmode = &PRVM_clientglobalfloat(particle_blendmode);
+	vmpartspawner.particle_orientation = &PRVM_clientglobalfloat(particle_orientation);
+	vmpartspawner.particle_color1 = PRVM_clientglobalvector(particle_color1);
+	vmpartspawner.particle_color2 = PRVM_clientglobalvector(particle_color2);
+	vmpartspawner.particle_tex = &PRVM_clientglobalfloat(particle_tex);
+	vmpartspawner.particle_size = &PRVM_clientglobalfloat(particle_size);
+	vmpartspawner.particle_sizeincrease = &PRVM_clientglobalfloat(particle_sizeincrease);
+	vmpartspawner.particle_alpha = &PRVM_clientglobalfloat(particle_alpha);
+	vmpartspawner.particle_alphafade = &PRVM_clientglobalfloat(particle_alphafade);
+	vmpartspawner.particle_time = &PRVM_clientglobalfloat(particle_time);
+	vmpartspawner.particle_gravity = &PRVM_clientglobalfloat(particle_gravity);
+	vmpartspawner.particle_bounce = &PRVM_clientglobalfloat(particle_bounce);
+	vmpartspawner.particle_airfriction = &PRVM_clientglobalfloat(particle_airfriction);
+	vmpartspawner.particle_liquidfriction = &PRVM_clientglobalfloat(particle_liquidfriction);
+	vmpartspawner.particle_originjitter = &PRVM_clientglobalfloat(particle_originjitter);
+	vmpartspawner.particle_velocityjitter = &PRVM_clientglobalfloat(particle_velocityjitter);
+	vmpartspawner.particle_qualityreduction = &PRVM_clientglobalfloat(particle_qualityreduction);
+	vmpartspawner.particle_stretch = &PRVM_clientglobalfloat(particle_stretch);
+	vmpartspawner.particle_staincolor1 = PRVM_clientglobalvector(particle_staincolor1);
+	vmpartspawner.particle_staincolor2 = PRVM_clientglobalvector(particle_staincolor2);
+	vmpartspawner.particle_stainalpha = &PRVM_clientglobalfloat(particle_stainalpha);
+	vmpartspawner.particle_stainsize = &PRVM_clientglobalfloat(particle_stainsize);
+	vmpartspawner.particle_staintex = &PRVM_clientglobalfloat(particle_staintex);
+	vmpartspawner.particle_staintex = &PRVM_clientglobalfloat(particle_staintex);
+	vmpartspawner.particle_delayspawn = &PRVM_clientglobalfloat(particle_delayspawn);
+	vmpartspawner.particle_delaycollision = &PRVM_clientglobalfloat(particle_delaycollision);
+	vmpartspawner.particle_angle = &PRVM_clientglobalfloat(particle_angle);
+	vmpartspawner.particle_spin = &PRVM_clientglobalfloat(particle_spin);
 	#undef getglobal
 	#undef getglobalvector
 }
@@ -2627,6 +2578,8 @@ static void VM_ResetParticleTheme (vmparticletheme_t *theme)
 	theme->staintex = -1;
 	theme->delayspawn = 0.0f;
 	theme->delaycollision = 0.0f;
+	theme->angle = 0.0f;
+	theme->spin = 0.0f;
 }
 
 // particle theme -> QC globals
@@ -2644,8 +2597,8 @@ void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme)
 	*vmpartspawner.particle_tex = (float)theme->tex;
 	*vmpartspawner.particle_size = theme->size;
 	*vmpartspawner.particle_sizeincrease = theme->sizeincrease;
-	*vmpartspawner.particle_alpha = (float)theme->alpha/256;
-	*vmpartspawner.particle_alphafade = (float)theme->alphafade/256;
+	*vmpartspawner.particle_alpha = theme->alpha/256;
+	*vmpartspawner.particle_alphafade = theme->alphafade/256;
 	*vmpartspawner.particle_time = theme->lifetime;
 	*vmpartspawner.particle_gravity = theme->gravity;
 	*vmpartspawner.particle_bounce = theme->bounce;
@@ -2655,30 +2608,34 @@ void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme)
 	*vmpartspawner.particle_velocityjitter = theme->velocityjitter;
 	*vmpartspawner.particle_qualityreduction = theme->qualityreduction;
 	*vmpartspawner.particle_stretch = theme->stretch;
-	vmpartspawner.particle_staincolor1[0] = (theme->staincolor1 >> 16) & 0xFF;
-	vmpartspawner.particle_staincolor1[1] = (theme->staincolor1 >> 8) & 0xFF;
-	vmpartspawner.particle_staincolor1[2] = (theme->staincolor1 >> 0) & 0xFF;
-	vmpartspawner.particle_staincolor2[0] = (theme->staincolor2 >> 16) & 0xFF;
-	vmpartspawner.particle_staincolor2[1] = (theme->staincolor2 >> 8) & 0xFF;
-	vmpartspawner.particle_staincolor2[2] = (theme->staincolor2 >> 0) & 0xFF;
+	vmpartspawner.particle_staincolor1[0] = ((int)theme->staincolor1 >> 16) & 0xFF;
+	vmpartspawner.particle_staincolor1[1] = ((int)theme->staincolor1 >> 8) & 0xFF;
+	vmpartspawner.particle_staincolor1[2] = ((int)theme->staincolor1 >> 0) & 0xFF;
+	vmpartspawner.particle_staincolor2[0] = ((int)theme->staincolor2 >> 16) & 0xFF;
+	vmpartspawner.particle_staincolor2[1] = ((int)theme->staincolor2 >> 8) & 0xFF;
+	vmpartspawner.particle_staincolor2[2] = ((int)theme->staincolor2 >> 0) & 0xFF;
 	*vmpartspawner.particle_staintex = (float)theme->staintex;
+	*vmpartspawner.particle_stainalpha = (float)theme->stainalpha/256;
+	*vmpartspawner.particle_stainsize = (float)theme->stainsize;
 	*vmpartspawner.particle_delayspawn = theme->delayspawn;
 	*vmpartspawner.particle_delaycollision = theme->delaycollision;
+	*vmpartspawner.particle_angle = theme->angle;
+	*vmpartspawner.particle_spin = theme->spin;
 }
 
 // QC globals ->  particle theme
 void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
 {
 	theme->typeindex = (unsigned short)*vmpartspawner.particle_type;
-	theme->blendmode = (pblend_t)*vmpartspawner.particle_blendmode;
-	theme->orientation = (porientation_t)*vmpartspawner.particle_orientation;
+	theme->blendmode = (pblend_t)(int)*vmpartspawner.particle_blendmode;
+	theme->orientation = (porientation_t)(int)*vmpartspawner.particle_orientation;
 	theme->color1 = ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]);
 	theme->color2 = ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]);
 	theme->tex = (int)*vmpartspawner.particle_tex;
 	theme->size = *vmpartspawner.particle_size;
 	theme->sizeincrease = *vmpartspawner.particle_sizeincrease;
-	theme->alpha = (int)(*vmpartspawner.particle_alpha*256);
-	theme->alphafade = (int)(*vmpartspawner.particle_alphafade*256);
+	theme->alpha = *vmpartspawner.particle_alpha*256;
+	theme->alphafade = *vmpartspawner.particle_alphafade*256;
 	theme->lifetime = *vmpartspawner.particle_time;
 	theme->gravity = *vmpartspawner.particle_gravity;
 	theme->bounce = *vmpartspawner.particle_bounce;
@@ -2688,11 +2645,15 @@ void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
 	theme->velocityjitter = *vmpartspawner.particle_velocityjitter;
 	theme->qualityreduction = (*vmpartspawner.particle_qualityreduction) ? true : false;
 	theme->stretch = *vmpartspawner.particle_stretch;
-	theme->staincolor1 = vmpartspawner.particle_staincolor1[0]*65536 + vmpartspawner.particle_staincolor1[1]*256 + vmpartspawner.particle_staincolor1[2];
-	theme->staincolor2 = vmpartspawner.particle_staincolor2[0]*65536 + vmpartspawner.particle_staincolor2[1]*256 + vmpartspawner.particle_staincolor2[2];
+	theme->staincolor1 = ((int)vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]);
+	theme->staincolor2 = (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]);
 	theme->staintex =(int)*vmpartspawner.particle_staintex;
+	theme->stainalpha = *vmpartspawner.particle_stainalpha*256;
+	theme->stainsize = *vmpartspawner.particle_stainsize;
 	theme->delayspawn = *vmpartspawner.particle_delayspawn;
 	theme->delaycollision = *vmpartspawner.particle_delaycollision;
+	theme->angle = *vmpartspawner.particle_angle;
+	theme->spin = *vmpartspawner.particle_spin;
 }
 
 // init particle spawner interface
@@ -2839,7 +2800,7 @@ void VM_CL_SpawnParticle (void)
 	
 	if (prog->argc < 3) // global-set particle
 	{
-		part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
+		part = CL_NewParticle(org, (unsigned short)*vmpartspawner.particle_type, ((int)(vmpartspawner.particle_color1[0]) << 16) + ((int)(vmpartspawner.particle_color1[1]) << 8) + ((int)(vmpartspawner.particle_color1[2])), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, *vmpartspawner.particle_alpha*256, *vmpartspawner.particle_alphafade*256, *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)(int)*vmpartspawner.particle_blendmode, (porientation_t)(int)*vmpartspawner.particle_orientation, (int)(vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]), (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex, *vmpartspawner.particle_stainalpha*256, *vmpartspawner.particle_stainsize, *vmpartspawner.particle_angle, *vmpartspawner.particle_spin, NULL);
 		if (!part)
 		{
 			PRVM_G_FLOAT(OFS_RETURN) = 0; 
@@ -2847,8 +2808,8 @@ void VM_CL_SpawnParticle (void)
 		}
 		if (*vmpartspawner.particle_delayspawn)
 			part->delayedspawn = cl.time + *vmpartspawner.particle_delayspawn;
-		if (*vmpartspawner.particle_delaycollision)
-			part->delayedcollisions = cl.time + *vmpartspawner.particle_delaycollision;
+		//if (*vmpartspawner.particle_delaycollision)
+		//	part->delayedcollisions = cl.time + *vmpartspawner.particle_delaycollision;
 	}
 	else // quick themed particle
 	{
@@ -2860,7 +2821,7 @@ void VM_CL_SpawnParticle (void)
 			return;
 		}
 		theme = &vmpartspawner.themes[themenum];
-		part = CL_NewParticle(theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex);
+		part = CL_NewParticle(org, theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex, theme->stainalpha, theme->stainsize, theme->angle, theme->spin, NULL);
 		if (!part)
 		{
 			PRVM_G_FLOAT(OFS_RETURN) = 0; 
@@ -2868,8 +2829,8 @@ void VM_CL_SpawnParticle (void)
 		}
 		if (theme->delayspawn)
 			part->delayedspawn = cl.time + theme->delayspawn;
-		if (theme->delaycollision)
-			part->delayedcollisions = cl.time + theme->delaycollision;
+		//if (theme->delaycollision)
+		//	part->delayedcollisions = cl.time + theme->delaycollision;
 	}
 	PRVM_G_FLOAT(OFS_RETURN) = 1; 
 }
@@ -2893,7 +2854,7 @@ void VM_CL_SpawnParticleDelayed (void)
 	org = PRVM_G_VECTOR(OFS_PARM0);
 	dir = PRVM_G_VECTOR(OFS_PARM1);
 	if (prog->argc < 5) // global-set particle
-		part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
+		part = CL_NewParticle(org, (unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, *vmpartspawner.particle_alpha*256, *vmpartspawner.particle_alphafade*256, *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)(int)*vmpartspawner.particle_blendmode, (porientation_t)(int)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex, *vmpartspawner.particle_stainalpha*256, *vmpartspawner.particle_stainsize, *vmpartspawner.particle_angle, *vmpartspawner.particle_spin, NULL);
 	else // themed particle
 	{
 		themenum = (int)PRVM_G_FLOAT(OFS_PARM4);
@@ -2904,7 +2865,7 @@ void VM_CL_SpawnParticleDelayed (void)
 			return;
 		}
 		theme = &vmpartspawner.themes[themenum];
-		part = CL_NewParticle(theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex);
+		part = CL_NewParticle(org, theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex, theme->stainalpha, theme->stainsize, theme->angle, theme->spin, NULL);
 	}
 	if (!part) 
 	{ 
@@ -2912,11 +2873,92 @@ void VM_CL_SpawnParticleDelayed (void)
 		return; 
 	}
 	part->delayedspawn = cl.time + PRVM_G_FLOAT(OFS_PARM2);
-	part->delayedcollisions = cl.time + PRVM_G_FLOAT(OFS_PARM3);
+	//part->delayedcollisions = cl.time + PRVM_G_FLOAT(OFS_PARM3);
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
 }
 
-//
+//====================
+//CSQC engine entities query
+//====================
+
+// float(float entitynum, float whatfld) getentity;
+// vector(float entitynum, float whatfld) getentityvec;
+// querying engine-drawn entity
+// VorteX: currently it's only tested with whatfld = 1..7
+void VM_CL_GetEntity (void)
+{
+	int entnum, fieldnum;
+	float org[3], v1[3], v2[3];
+	VM_SAFEPARMCOUNT(2, VM_CL_GetEntityVec);
+
+	entnum = PRVM_G_FLOAT(OFS_PARM0);
+	if (entnum < 0 || entnum >= cl.num_entities)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = 0;
+		return;
+	}
+	fieldnum = PRVM_G_FLOAT(OFS_PARM1);
+	switch(fieldnum)
+	{
+		case 0: // active state
+			PRVM_G_FLOAT(OFS_RETURN) = cl.entities_active[entnum];
+			break;
+		case 1: // origin
+			Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, PRVM_G_VECTOR(OFS_RETURN));
+			break; 
+		case 2: // forward
+			Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, PRVM_G_VECTOR(OFS_RETURN), v1, v2, org);	
+			break;
+		case 3: // right
+			Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, v1, PRVM_G_VECTOR(OFS_RETURN), v2, org);	
+			break;
+		case 4: // up
+			Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, v1, v2, PRVM_G_VECTOR(OFS_RETURN), org);	
+			break;
+		case 5: // scale
+			PRVM_G_FLOAT(OFS_RETURN) = Matrix4x4_ScaleFromMatrix(&cl.entities[entnum].render.matrix);
+			break;	
+		case 6: // origin + v_forward, v_right, v_up
+			Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, PRVM_clientglobalvector(v_forward), PRVM_clientglobalvector(v_right), PRVM_clientglobalvector(v_up), PRVM_G_VECTOR(OFS_RETURN));	
+			break;	
+		case 7: // alpha
+			PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.alpha;
+			break;	
+		case 8: // colormor
+			VectorCopy(cl.entities[entnum].render.colormod, PRVM_G_VECTOR(OFS_RETURN));
+			break;
+		case 9: // pants colormod
+			VectorCopy(cl.entities[entnum].render.colormap_pantscolor, PRVM_G_VECTOR(OFS_RETURN));
+			break;
+		case 10: // shirt colormod
+			VectorCopy(cl.entities[entnum].render.colormap_shirtcolor, PRVM_G_VECTOR(OFS_RETURN));
+			break;
+		case 11: // skinnum
+			PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.skinnum;
+			break;	
+		case 12: // mins
+			VectorCopy(cl.entities[entnum].render.mins, PRVM_G_VECTOR(OFS_RETURN));		
+			break;	
+		case 13: // maxs
+			VectorCopy(cl.entities[entnum].render.maxs, PRVM_G_VECTOR(OFS_RETURN));		
+			break;	
+		case 14: // absmin
+			Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
+			VectorAdd(cl.entities[entnum].render.mins, org, PRVM_G_VECTOR(OFS_RETURN));		
+			break;	
+		case 15: // absmax
+			Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
+			VectorAdd(cl.entities[entnum].render.maxs, org, PRVM_G_VECTOR(OFS_RETURN));		
+			break;
+		case 16: // light
+			VectorMA(cl.entities[entnum].render.modellight_ambient, 0.5, cl.entities[entnum].render.modellight_diffuse, PRVM_G_VECTOR(OFS_RETURN));
+			break;	
+		default:
+			PRVM_G_FLOAT(OFS_RETURN) = 0;
+			break;
+	}
+}
+
 //====================
 //QC POLYGON functions
 //====================
@@ -2927,6 +2969,7 @@ typedef struct vmpolygons_triangle_s
 {
 	rtexture_t		*texture;
 	int				drawflag;
+	qboolean hasalpha;
 	unsigned short	elements[3];
 }vmpolygons_triangle_t;
 
@@ -2948,12 +2991,14 @@ typedef struct vmpolygons_s
 	unsigned short	*data_sortedelement3s;
 
 	qboolean		begin_active;
+	int	begin_draw2d;
 	rtexture_t		*begin_texture;
 	int				begin_drawflag;
 	int				begin_vertices;
 	float			begin_vertex[VMPOLYGONS_MAXPOINTS][3];
 	float			begin_color[VMPOLYGONS_MAXPOINTS][4];
 	float			begin_texcoord[VMPOLYGONS_MAXPOINTS][2];
+	qboolean		begin_texture_hasalpha;
 } vmpolygons_t;
 
 // FIXME: make VM_CL_R_Polygon functions use Debug_Polygon functions?
@@ -2979,7 +3024,7 @@ void VM_CL_R_RenderScene (void)
 	polys->progstarttime = prog->starttime;
 
 	// callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
-	prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
+	prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= Sys_DoubleTime() - t;
 }
 
 static void VM_ResizePolygons(vmpolygons_t *polys)
@@ -3033,32 +3078,20 @@ static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t
 	vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
 	if(polys->progstarttime != prog->starttime) // from other progs? won't draw these (this can cause crashes!)
 		return;
-	R_Mesh_ResetTextureState();
-	R_Mesh_Matrix(&identitymatrix);
+//	R_Mesh_ResetTextureState();
+	R_EntityMatrix(&identitymatrix);
 	GL_CullFace(GL_NONE);
-	R_Mesh_VertexPointer(polys->data_vertex3f, 0, 0);
-	R_Mesh_ColorPointer(polys->data_color4f, 0, 0);
-	R_Mesh_TexCoordPointer(0, 2, polys->data_texcoord2f, 0, 0);
-	R_SetupGenericShader(true);
+	GL_DepthTest(true); // polys in 3D space shall always have depth test
+	GL_DepthRange(0, 1);
+	R_Mesh_PrepareVertices_Generic_Arrays(polys->num_vertices, polys->data_vertex3f, polys->data_color4f, polys->data_texcoord2f);
 
 	for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
 	{
 		int numtriangles = 0;
 		rtexture_t *tex = polys->data_triangles[surfacelist[surfacelistindex]].texture;
 		int drawflag = polys->data_triangles[surfacelist[surfacelistindex]].drawflag;
-		// this can't call _DrawQ_ProcessDrawFlag, but should be in sync with it
-		// FIXME factor this out
-		if(drawflag == DRAWFLAG_ADDITIVE)
-			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
-		else if(drawflag == DRAWFLAG_MODULATE)
-			GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
-		else if(drawflag == DRAWFLAG_2XMODULATE)
-			GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
-		else if(drawflag == DRAWFLAG_SCREEN)
-			GL_BlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE);
-		else
-			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		R_Mesh_TexBind(0, R_GetTexture(tex));
+		DrawQ_ProcessDrawFlag(drawflag, polys->data_triangles[surfacelist[surfacelistindex]].hasalpha);
+		R_SetupShader_Generic(tex, NULL, GL_MODULATE, 1, false);
 		numtriangles = 0;
 		for (;surfacelistindex < numsurfaces;surfacelistindex++)
 		{
@@ -3067,13 +3100,22 @@ static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t
 			VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].elements, polys->data_sortedelement3s + 3*numtriangles);
 			numtriangles++;
 		}
-		R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, polys->data_sortedelement3s, 0, 0);
+		R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, NULL, 0, polys->data_sortedelement3s, NULL, 0);
 	}
 }
 
 void VMPolygons_Store(vmpolygons_t *polys)
 {
-	if (r_refdef.draw2dstage)
+	qboolean hasalpha;
+	int i;
+
+	// detect if we have alpha
+	hasalpha = polys->begin_texture_hasalpha;
+	for(i = 0; !hasalpha && (i < polys->begin_vertices); ++i)
+		if(polys->begin_color[i][3] < 1)
+			hasalpha = true;
+
+	if (polys->begin_draw2d)
 	{
 		// draw the polygon as 2D immediately
 		drawqueuemesh_t mesh;
@@ -3085,7 +3127,7 @@ void VMPolygons_Store(vmpolygons_t *polys)
 		mesh.data_vertex3f = polys->begin_vertex[0];
 		mesh.data_color4f = polys->begin_color[0];
 		mesh.data_texcoord2f = polys->begin_texcoord[0];
-		DrawQ_Mesh(&mesh, polys->begin_drawflag);
+		DrawQ_Mesh(&mesh, polys->begin_drawflag, hasalpha);
 	}
 	else
 	{
@@ -3093,7 +3135,8 @@ void VMPolygons_Store(vmpolygons_t *polys)
 		int i;
 		if (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
 		{
-			polys->max_triangles *= 2;
+			while (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
+				polys->max_triangles *= 2;
 			VM_ResizePolygons(polys);
 		}
 		if (polys->num_vertices + polys->begin_vertices <= polys->max_vertices)
@@ -3112,6 +3155,7 @@ void VMPolygons_Store(vmpolygons_t *polys)
 				polys->data_triangles[polys->num_triangles].elements[0] = polys->num_vertices;
 				polys->data_triangles[polys->num_triangles].elements[1] = polys->num_vertices + i+1;
 				polys->data_triangles[polys->num_triangles].elements[2] = polys->num_vertices + i+2;
+				polys->data_triangles[polys->num_triangles].hasalpha = hasalpha;
 				polys->num_triangles++;
 			}
 			polys->num_vertices += polys->begin_vertices;
@@ -3145,7 +3189,7 @@ void VM_CL_AddPolygonsToMeshQueue (void)
 	  polys->num_vertices = 0;  // otherwise it's not rendered at all and prints an error message --blub */
 }
 
-//void(string texturename, float flag) R_BeginPolygon
+//void(string texturename, float flag[, float is2d]) R_BeginPolygon
 void VM_CL_R_PolygonBegin (void)
 {
 	const char		*picname;
@@ -3157,7 +3201,7 @@ void VM_CL_R_PolygonBegin (void)
 	// better management of flags, and is more suited for 3D rendering), what
 	// about supporting Q3 shaders?
 
-	VM_SAFEPARMCOUNT(2, VM_CL_R_PolygonBegin);
+	VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_PolygonBegin);
 
 	if (!polys->initialized)
 		VM_InitPolygons(polys);
@@ -3195,9 +3239,11 @@ void VM_CL_R_PolygonBegin (void)
 	}
 
 	polys->begin_texture = (sf && sf->base) ? sf->base : r_texture_white;
+	polys->begin_texture_hasalpha = (sf && sf->base) ? sf->hasalpha : false;
 	polys->begin_drawflag = (int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MASK;
 	polys->begin_vertices = 0;
 	polys->begin_active = true;
+	polys->begin_draw2d = (prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : r_refdef.draw2dstage);
 }
 
 //void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
@@ -3260,7 +3306,7 @@ void Debug_PolygonBegin(const char *picname, int drawflag)
 		Con_Printf("Debug_PolygonBegin: called twice without Debug_PolygonEnd after first\n");
 		return;
 	}
-	debugPolys.begin_texture = picname[0] ? Draw_CachePic (picname)->tex : r_texture_white;
+	debugPolys.begin_texture = picname[0] ? Draw_CachePic_Flags (picname, CACHEPICFLAG_NOTPERSISTENT)->tex : r_texture_white;
 	debugPolys.begin_drawflag = drawflag;
 	debugPolys.begin_vertices = 0;
 	debugPolys.begin_active = true;
@@ -3322,8 +3368,8 @@ qboolean CL_CheckBottom (prvm_edict_t *ent)
 	int		x, y;
 	float	mid, bottom;
 
-	VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
-	VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
+	VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
+	VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);
 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks
@@ -3350,7 +3396,7 @@ realcheck:
 	start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
 	start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
 	stop[2] = start[2] - 2*sv_stepheight.value;
-	trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true);
+	trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true, false);
 
 	if (trace.fraction == 1.0)
 		return false;
@@ -3363,7 +3409,7 @@ realcheck:
 			start[0] = stop[0] = x ? maxs[0] : mins[0];
 			start[1] = stop[1] = y ? maxs[1] : mins[1];
 
-			trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true);
+			trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true, false);
 
 			if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
 				bottom = trace.endpos[2];
@@ -3390,39 +3436,38 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
 	trace_t		trace;
 	int			i, svent;
 	prvm_edict_t		*enemy;
-	prvm_eval_t	*val;
 
 // try the move
-	VectorCopy (ent->fields.client->origin, oldorg);
-	VectorAdd (ent->fields.client->origin, move, neworg);
+	VectorCopy (PRVM_clientedictvector(ent, origin), oldorg);
+	VectorAdd (PRVM_clientedictvector(ent, origin), move, neworg);
 
 // flying monsters don't step up
-	if ( (int)ent->fields.client->flags & (FL_SWIM | FL_FLY) )
+	if ( (int)PRVM_clientedictfloat(ent, flags) & (FL_SWIM | FL_FLY) )
 	{
 	// try one move with vertical motion, then one without
 		for (i=0 ; i<2 ; i++)
 		{
-			VectorAdd (ent->fields.client->origin, move, neworg);
-			enemy = PRVM_PROG_TO_EDICT(ent->fields.client->enemy);
+			VectorAdd (PRVM_clientedictvector(ent, origin), move, neworg);
+			enemy = PRVM_PROG_TO_EDICT(PRVM_clientedictedict(ent, enemy));
 			if (i == 0 && enemy != prog->edicts)
 			{
-				dz = ent->fields.client->origin[2] - PRVM_PROG_TO_EDICT(ent->fields.client->enemy)->fields.client->origin[2];
+				dz = PRVM_clientedictvector(ent, origin)[2] - PRVM_clientedictvector(PRVM_PROG_TO_EDICT(PRVM_clientedictedict(ent, enemy)), origin)[2];
 				if (dz > 40)
 					neworg[2] -= 8;
 				if (dz < 30)
 					neworg[2] += 8;
 			}
-			trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
+			trace = CL_TraceBox(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
 			if (settrace)
 				CL_VM_SetTraceGlobals(&trace, svent);
 
 			if (trace.fraction == 1)
 			{
 				VectorCopy(trace.endpos, traceendpos);
-				if (((int)ent->fields.client->flags & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
+				if (((int)PRVM_clientedictfloat(ent, flags) & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
 					return false;	// swim monster left water
 
-				VectorCopy (traceendpos, ent->fields.client->origin);
+				VectorCopy (traceendpos, PRVM_clientedictvector(ent, origin));
 				if (relink)
 					CL_LinkEdict(ent);
 				return true;
@@ -3440,14 +3485,14 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
 	VectorCopy (neworg, end);
 	end[2] -= sv_stepheight.value*2;
 
-	trace = CL_TraceBox(neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
+	trace = CL_TraceBox(neworg, PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
 	if (settrace)
 		CL_VM_SetTraceGlobals(&trace, svent);
 
 	if (trace.startsolid)
 	{
 		neworg[2] -= sv_stepheight.value;
-		trace = CL_TraceBox(neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
+		trace = CL_TraceBox(neworg, PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
 		if (settrace)
 			CL_VM_SetTraceGlobals(&trace, svent);
 		if (trace.startsolid)
@@ -3456,12 +3501,12 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
 	if (trace.fraction == 1)
 	{
 	// if monster had the ground pulled out, go ahead and fall
-		if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
+		if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
 		{
-			VectorAdd (ent->fields.client->origin, move, ent->fields.client->origin);
+			VectorAdd (PRVM_clientedictvector(ent, origin), move, PRVM_clientedictvector(ent, origin));
 			if (relink)
 				CL_LinkEdict(ent);
-			ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_ONGROUND;
+			PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) & ~FL_ONGROUND;
 			return true;
 		}
 
@@ -3469,26 +3514,25 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
 	}
 
 // check point traces down for dangling corners
-	VectorCopy (trace.endpos, ent->fields.client->origin);
+	VectorCopy (trace.endpos, PRVM_clientedictvector(ent, origin));
 
 	if (!CL_CheckBottom (ent))
 	{
-		if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
+		if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
 		{	// entity had floor mostly pulled out from underneath it
 			// and is trying to correct
 			if (relink)
 				CL_LinkEdict(ent);
 			return true;
 		}
-		VectorCopy (oldorg, ent->fields.client->origin);
+		VectorCopy (oldorg, PRVM_clientedictvector(ent, origin));
 		return false;
 	}
 
-	if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
-		ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_PARTIALGROUND;
+	if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
+		PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) & ~FL_PARTIALGROUND;
 
-	if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.groundentity)))
-		val->edict = PRVM_EDICT_TO_PROG(trace.ent);
+	PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
 
 // the move is ok
 	if (relink)
@@ -3517,7 +3561,7 @@ static void VM_CL_walkmove (void)
 	// assume failure if it returns early
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
 
-	ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
+	ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));
 	if (ent == prog->edicts)
 	{
 		VM_Warning("walkmove: can not modify world entity\n");
@@ -3532,7 +3576,7 @@ static void VM_CL_walkmove (void)
 	dist = PRVM_G_FLOAT(OFS_PARM1);
 	settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
 
-	if ( !( (int)ent->fields.client->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
+	if ( !( (int)PRVM_clientedictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
 		return;
 
 	yaw = yaw*M_PI*2 / 360;
@@ -3543,14 +3587,14 @@ static void VM_CL_walkmove (void)
 
 // save program state, because CL_movestep may call other progs
 	oldf = prog->xfunction;
-	oldself = prog->globals.client->self;
+	oldself = PRVM_clientglobaledict(self);
 
 	PRVM_G_FLOAT(OFS_RETURN) = CL_movestep(ent, move, true, false, settrace);
 
 
 // restore program state
 	prog->xfunction = oldf;
-	prog->globals.client->self = oldself;
+	PRVM_clientglobaledict(self) = oldself;
 }
 
 /*
@@ -3601,8 +3645,8 @@ static void VM_CL_checkpvs (void)
 		return;
 	}
 
-	VectorAdd(viewee->fields.server->origin, viewee->fields.server->mins, mi);
-	VectorAdd(viewee->fields.server->origin, viewee->fields.server->maxs, ma);
+	VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, mins), mi);
+	VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, maxs), ma);
 
 #if 1
 	if(!sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)
@@ -3653,13 +3697,13 @@ static void VM_CL_skel_create(void)
 			break;
 	if (i == MAX_EDICTS)
 		return;
-	prog->skeletons[i] = skeleton = Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
+	prog->skeletons[i] = skeleton = (skeleton_t *)Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
+	PRVM_G_FLOAT(OFS_RETURN) = i + 1;
 	skeleton->model = model;
 	skeleton->relativetransforms = (matrix4x4_t *)(skeleton+1);
 	// initialize to identity matrices
 	for (i = 0;i < skeleton->model->num_bones;i++)
 		skeleton->relativetransforms[i] = identitymatrix;
-	PRVM_G_FLOAT(OFS_RETURN) = i + 1;
 }
 
 // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
@@ -3670,8 +3714,8 @@ static void VM_CL_skel_build(void)
 	prvm_edict_t *ed = PRVM_G_EDICT(OFS_PARM1);
 	int modelindex = (int)PRVM_G_FLOAT(OFS_PARM2);
 	float retainfrac = PRVM_G_FLOAT(OFS_PARM3);
-	int firstbone = PRVM_G_FLOAT(OFS_PARM4);
-	int lastbone = PRVM_G_FLOAT(OFS_PARM5);
+	int firstbone = PRVM_G_FLOAT(OFS_PARM4) - 1;
+	int lastbone = PRVM_G_FLOAT(OFS_PARM5) - 1;
 	dp_model_t *model = CL_GetModelByIndex(modelindex);
 	float blendfrac;
 	int numblends;
@@ -3698,12 +3742,12 @@ static void VM_CL_skel_build(void)
 		Matrix4x4_Accumulate(&blendedmatrix, &skeleton->relativetransforms[bonenum], retainfrac);
 		for (blendindex = 0;blendindex < numblends;blendindex++)
 		{
-			Matrix4x4_FromArray12FloatD3D(&matrix, model->data_poses + 12 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
+			Matrix4x4_FromBonePose6s(&matrix, model->num_posescale, model->data_poses6s + 6 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
 			Matrix4x4_Accumulate(&blendedmatrix, &matrix, frameblend[blendindex].lerp);
 		}
 		skeleton->relativetransforms[bonenum] = blendedmatrix;
 	}
-	PRVM_G_FLOAT(OFS_RETURN) = skeletonindex;
+	PRVM_G_FLOAT(OFS_RETURN) = skeletonindex + 1;
 }
 
 // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
@@ -3754,7 +3798,7 @@ static void VM_CL_skel_find_bone(void)
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
 	if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
 		return;
-	PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname) + 1;
+	PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname);
 }
 
 // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
@@ -3766,18 +3810,18 @@ static void VM_CL_skel_get_bonerel(void)
 	matrix4x4_t matrix;
 	vec3_t forward, left, up, origin;
 	VectorClear(PRVM_G_VECTOR(OFS_RETURN));
-	VectorClear(prog->globals.client->v_forward);
-	VectorClear(prog->globals.client->v_right);
-	VectorClear(prog->globals.client->v_up);
+	VectorClear(PRVM_clientglobalvector(v_forward));
+	VectorClear(PRVM_clientglobalvector(v_right));
+	VectorClear(PRVM_clientglobalvector(v_up));
 	if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
 		return;
 	if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
 		return;
 	matrix = skeleton->relativetransforms[bonenum];
 	Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
-	VectorCopy(forward, prog->globals.client->v_forward);
-	VectorNegate(left, prog->globals.client->v_right);
-	VectorCopy(up, prog->globals.client->v_up);
+	VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+	VectorNegate(left, PRVM_clientglobalvector(v_right));
+	VectorCopy(up, PRVM_clientglobalvector(v_up));
 	VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
 }
 
@@ -3791,9 +3835,9 @@ static void VM_CL_skel_get_boneabs(void)
 	matrix4x4_t temp;
 	vec3_t forward, left, up, origin;
 	VectorClear(PRVM_G_VECTOR(OFS_RETURN));
-	VectorClear(prog->globals.client->v_forward);
-	VectorClear(prog->globals.client->v_right);
-	VectorClear(prog->globals.client->v_up);
+	VectorClear(PRVM_clientglobalvector(v_forward));
+	VectorClear(PRVM_clientglobalvector(v_right));
+	VectorClear(PRVM_clientglobalvector(v_up));
 	if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
 		return;
 	if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
@@ -3806,9 +3850,9 @@ static void VM_CL_skel_get_boneabs(void)
 		Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
 	}
 	Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
-	VectorCopy(forward, prog->globals.client->v_forward);
-	VectorNegate(left, prog->globals.client->v_right);
-	VectorCopy(up, prog->globals.client->v_up);
+	VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+	VectorNegate(left, PRVM_clientglobalvector(v_right));
+	VectorCopy(up, PRVM_clientglobalvector(v_up));
 	VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
 }
 
@@ -3824,9 +3868,9 @@ static void VM_CL_skel_set_bone(void)
 		return;
 	if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
 		return;
-	VectorCopy(prog->globals.client->v_forward, forward);
-	VectorNegate(prog->globals.client->v_right, left);
-	VectorCopy(prog->globals.client->v_up, up);
+	VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+	VectorNegate(PRVM_clientglobalvector(v_right), left);
+	VectorCopy(PRVM_clientglobalvector(v_up), up);
 	VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
 	Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
 	skeleton->relativetransforms[bonenum] = matrix;
@@ -3846,9 +3890,9 @@ static void VM_CL_skel_mul_bone(void)
 	if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
 		return;
 	VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
-	VectorCopy(prog->globals.client->v_forward, forward);
-	VectorNegate(prog->globals.client->v_right, left);
-	VectorCopy(prog->globals.client->v_up, up);
+	VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+	VectorNegate(PRVM_clientglobalvector(v_right), left);
+	VectorCopy(PRVM_clientglobalvector(v_up), up);
 	Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
 	temp = skeleton->relativetransforms[bonenum];
 	Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
@@ -3868,9 +3912,9 @@ static void VM_CL_skel_mul_bones(void)
 	if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
 		return;
 	VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
-	VectorCopy(prog->globals.client->v_forward, forward);
-	VectorNegate(prog->globals.client->v_right, left);
-	VectorCopy(prog->globals.client->v_up, up);
+	VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+	VectorNegate(PRVM_clientglobalvector(v_right), left);
+	VectorCopy(PRVM_clientglobalvector(v_up), up);
 	Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
 	firstbone = max(0, firstbone);
 	lastbone = min(lastbone, skeleton->model->num_bones - 1);
@@ -3946,6 +3990,54 @@ static void VM_CL_frameduration(void)
 		PRVM_G_FLOAT(OFS_RETURN) = model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
 }
 
+void VM_CL_RotateMoves(void)
+{
+	/*
+	 * Obscure builtin used by GAME_XONOTIC.
+	 *
+	 * Edits the input history of cl_movement by rotating all move commands
+	 * currently in the queue using the given transform.
+	 *
+	 * The vector passed is an "angles transform" as used by warpzonelib, i.e.
+	 * v_angle-like (non-inverted) euler angles that perform the rotation
+	 * of the space that is to be done.
+	 *
+	 * This is meant to be used as a fixangle replacement after passing
+	 * through a warpzone/portal: the client is told about the warp transform,
+	 * and calls this function in the same frame as the one on which the
+	 * client's origin got changed by the serverside teleport. Then this code
+	 * transforms the pre-warp input (which matches the empty space behind
+	 * the warp plane) into post-warp input (which matches the target area
+	 * of the warp). Also, at the same time, the client has to use
+	 * R_SetView to adjust VF_CL_VIEWANGLES according to the same transform.
+	 *
+	 * This together allows warpzone motion to be perfectly predicted by
+	 * the client!
+	 *
+	 * Furthermore, for perfect warpzone behaviour, the server side also
+	 * has to detect input the client sent before it received the origin
+	 * update, but after the warp occurred on the server, and has to adjust
+	 * input appropriately.
+    */
+	matrix4x4_t m;
+	vec3_t v = {0, 0, 0};
+	vec3_t x, y, z;
+	VM_SAFEPARMCOUNT(1, VM_CL_RotateMoves);
+	AngleVectorsFLU(PRVM_G_VECTOR(OFS_PARM0), x, y, z);
+	Matrix4x4_FromVectors(&m, x, y, z, v);
+	CL_RotateMoves(&m);
+}
+
+// #358 void(string cubemapname) loadcubemap
+static void VM_CL_loadcubemap(void)
+{
+	const char *name;
+
+	VM_SAFEPARMCOUNT(1, VM_CL_loadcubemap);
+	name = PRVM_G_STRING(OFS_PARM0);
+	R_GetCubemap(name);
+}
+
 //============================================================================
 
 // To create a almost working builtin file from this replace:
@@ -4265,7 +4357,7 @@ VM_CL_R_AddEntity,				// #302 void(entity ent) addentity (EXT_CSQC)
 VM_CL_R_SetView,				// #303 float(float property, ...) setproperty (EXT_CSQC)
 VM_CL_R_RenderScene,			// #304 void() renderscene (EXT_CSQC)
 VM_CL_R_AddDynamicLight,		// #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
-VM_CL_R_PolygonBegin,			// #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
+VM_CL_R_PolygonBegin,			// #306 void(string texturename, float flag, float is2d[NYI: , float lines]) R_BeginPolygon
 VM_CL_R_PolygonVertex,			// #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
 VM_CL_R_PolygonEnd,				// #308 void() R_EndPolygon
 NULL /* R_LoadWorldModel in menu VM, should stay unassigned in client*/, // #309
@@ -4301,7 +4393,7 @@ VM_centerprint,					// #338 void(string s, ...) centerprint (EXT_CSQC)
 VM_print,						// #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
 VM_keynumtostring,				// #340 string(float keynum) keynumtostring (EXT_CSQC)
 VM_stringtokeynum,				// #341 float(string keyname) stringtokeynum (EXT_CSQC)
-VM_CL_getkeybind,				// #342 string(float keynum) getkeybind (EXT_CSQC)
+VM_getkeybind,					// #342 string(float keynum[, float bindmap]) getkeybind (EXT_CSQC)
 VM_CL_setcursormode,			// #343 void(float usecursor) setcursormode (EXT_CSQC)
 VM_CL_getmousepos,				// #344 vector() getmousepos (EXT_CSQC)
 VM_CL_getinputstate,			// #345 float(float framenum) getinputstate (EXT_CSQC)
@@ -4314,10 +4406,10 @@ VM_CL_setlistener,				// #351 void(vector origin, vector forward, vector right,
 VM_CL_registercmd,				// #352 void(string cmdname) registercommand (EXT_CSQC)
 VM_wasfreed,					// #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
 VM_CL_serverkey,				// #354 string(string key) serverkey (EXT_CSQC)
-NULL,							// #355
-NULL,							// #356
-NULL,							// #357
-NULL,							// #358
+VM_CL_videoplaying,				// #355
+VM_findfont,					// #356 float(string fontname) loadfont (DP_GFX_FONTS)
+VM_loadfont,					// #357 float(string fontname, string fontmaps, string sizes, float slot) loadfont (DP_GFX_FONTS)
+VM_CL_loadcubemap,				// #358 void(string cubemapname) loadcubemap (DP_GFX_)
 NULL,							// #359
 VM_CL_ReadByte,					// #360 float() readbyte (EXT_CSQC)
 VM_CL_ReadChar,					// #361 float() readchar (EXT_CSQC)
@@ -4394,12 +4486,12 @@ VM_CL_te_lightning3,			// #430 void(entity own, vector start, vector end) te_lig
 VM_CL_te_beam,					// #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
 VM_vectorvectors,				// #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
 VM_CL_te_plasmaburn,			// #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
-VM_CL_getsurfacenumpoints,		// #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
-VM_CL_getsurfacepoint,			// #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
-VM_CL_getsurfacenormal,			// #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
-VM_CL_getsurfacetexture,		// #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
-VM_CL_getsurfacenearpoint,		// #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
-VM_CL_getsurfaceclippedpoint,	// #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
+VM_getsurfacenumpoints,		// #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
+VM_getsurfacepoint,			// #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
+VM_getsurfacenormal,			// #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
+VM_getsurfacetexture,		// #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
+VM_getsurfacenearpoint,		// #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
+VM_getsurfaceclippedpoint,	// #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
 NULL,							// #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
 VM_tokenize,					// #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
 VM_argv,						// #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
@@ -4446,7 +4538,7 @@ VM_cvar_defstring,				// #482 string(string s) cvar_defstring (DP_QC_CVAR_DEFSTR
 VM_CL_pointsound,				// #483 void(vector origin, string sample, float volume, float attenuation) pointsound (DP_SV_POINTSOUND)
 VM_strreplace,					// #484 string(string search, string replace, string subject) strreplace (DP_QC_STRREPLACE)
 VM_strireplace,					// #485 string(string search, string replace, string subject) strireplace (DP_QC_STRREPLACE)
-VM_CL_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute
+VM_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute
 VM_gecko_create,					// #487 float gecko_create( string name )
 VM_gecko_destroy,					// #488 void gecko_destroy( string name )
 VM_gecko_navigate,				// #489 void gecko_navigate( string name, string URI )
@@ -4462,9 +4554,9 @@ VM_entityfieldtype,				// #498 float(float fieldnum) entityfieldtype = #498; (DP
 VM_getentityfieldstring,		// #499 string(float fieldnum, entity ent) getentityfieldstring = #499; (DP_QC_ENTITYDATA)
 VM_putentityfieldstring,		// #500 float(float fieldnum, entity ent, string s) putentityfieldstring = #500; (DP_QC_ENTITYDATA)
 VM_CL_ReadPicture,				// #501 string() ReadPicture = #501;
-NULL,							// #502
+VM_CL_boxparticles,				// #502 void(float effectnum, entity own, vector origin_from, vector origin_to, vector dir_from, vector dir_to, float count) boxparticles (DP_CSQC_BOXPARTICLES)
 VM_whichpack,					// #503 string(string) whichpack = #503;
-NULL,							// #504
+VM_CL_GetEntity,				// #504 float(float entitynum, float fldnum) getentity = #504; vector(float entitynum, float fldnum) getentityvec = #504;
 NULL,							// #505
 NULL,							// #506
 NULL,							// #507
@@ -4473,7 +4565,7 @@ NULL,							// #509
 VM_uri_escape,					// #510 string(string in) uri_escape = #510;
 VM_uri_unescape,				// #511 string(string in) uri_unescape = #511;
 VM_etof,					// #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT)
-VM_uri_get,						// #513 float(string uril, float id) uri_get = #512; (DP_QC_URI_GET)
+VM_uri_get,						// #513 float(string uri, float id, [string post_contenttype, string post_delim, [float buf]]) uri_get = #513; (DP_QC_URI_GET, DP_QC_URI_POST)
 VM_tokenize_console,					// #514 float(string str) tokenize_console = #514; (DP_QC_TOKENIZE_CONSOLE)
 VM_argv_start_index,					// #515 float(float idx) argv_start_index = #515; (DP_QC_TOKENIZE_CONSOLE)
 VM_argv_end_index,						// #516 float(float idx) argv_end_index = #516; (DP_QC_TOKENIZE_CONSOLE)
@@ -4481,7 +4573,7 @@ VM_buf_cvarlist,						// #517 void(float buf, string prefix, string antiprefix)
 VM_cvar_description,					// #518 float(string name) cvar_description = #518; (DP_QC_CVAR_DESCRIPTION)
 VM_gettime,						// #519 float(float timer) gettime = #519; (DP_QC_GETTIME)
 VM_keynumtostring,				// #520 string keynumtostring(float keynum)
-VM_findkeysforcommand,			// #521 string findkeysforcommand(string command)
+VM_findkeysforcommand,			// #521 string findkeysforcommand(string command[, float bindmap])
 VM_CL_InitParticleSpawner,		// #522 void(float max_themes) initparticlespawner (DP_CSQC_SPAWNPARTICLE)
 VM_CL_ResetParticle,			// #523 void() resetparticle (DP_CSQC_SPAWNPARTICLE)
 VM_CL_ParticleTheme,			// #524 void(float theme) particletheme (DP_CSQC_SPAWNPARTICLE)
@@ -4491,18 +4583,18 @@ VM_CL_SpawnParticle,			// #527 float(vector org, vector vel, [float theme]) part
 VM_CL_SpawnParticleDelayed,		// #528 float(vector org, vector vel, float delay, float collisiondelay, [float theme]) delayedparticle (DP_CSQC_SPAWNPARTICLE)
 VM_loadfromdata,				// #529
 VM_loadfromfile,				// #530
-NULL,							// #531
+VM_CL_setpause,					// #531 float(float ispaused) setpause = #531 (DP_CSQC_SETPAUSE)
 VM_log,							// #532
-NULL,							// #533
-NULL,							// #534
+VM_getsoundtime,				// #533 float(entity e, float channel) getsoundtime = #533; (DP_SND_GETSOUNDTIME)
+VM_soundlength,					// #534 float(string sample) soundlength = #534; (DP_SND_GETSOUNDTIME)
 NULL,							// #535
 NULL,							// #536
 NULL,							// #537
 NULL,							// #538
 NULL,							// #539
-NULL,							// #540
-NULL,							// #541
-NULL,							// #542
+VM_physics_enable,				// #540 void(entity e, float physics_enabled) physics_enable = #540; (DP_PHYSICS_ODE)
+VM_physics_addforce,			// #541 void(entity e, vector force, vector relative_ofs) physics_addforce = #541; (DP_PHYSICS_ODE)
+VM_physics_addtorque,			// #542 void(entity e, vector torque) physics_addtorque = #542; (DP_PHYSICS_ODE)
 NULL,							// #543
 NULL,							// #544
 NULL,							// #545
@@ -4570,7 +4662,7 @@ VM_writetofile,					// #606
 VM_isfunction,					// #607
 NULL,							// #608
 NULL,							// #609
-NULL,							// #610
+VM_findkeysforcommand,			// #610 string findkeysforcommand(string command[, float bindmap])
 NULL,							// #611
 NULL,							// #612
 VM_parseentitydata,				// #613
@@ -4586,6 +4678,20 @@ NULL,							// #622
 NULL,							// #623
 VM_CL_getextresponse,			// #624 string getextresponse(void)
 NULL,							// #625
+NULL,							// #626
+VM_sprintf,                     // #627 string sprintf(string format, ...)
+VM_getsurfacenumtriangles,		// #628 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACETRIANGLE)
+VM_getsurfacetriangle,			// #629 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACETRIANGLE)
+VM_setkeybind,						// #630 float(float key, string bind[, float bindmap]) setkeybind
+VM_getbindmaps,						// #631 vector(void) getbindmap
+VM_setbindmaps,						// #632 float(vector bm) setbindmap
+NULL,							// #633
+NULL,							// #634
+NULL,							// #635
+NULL,							// #636
+NULL,							// #637
+VM_CL_RotateMoves,					// #638
+NULL,							// #639
 };
 
 const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);