X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=csprogs.c;h=4bacb5632e8a595d00d98ed5962766a128b7a67a;hp=5816a3c6f0b7a687d9854220fca0c258465bbe66;hb=2f5dfa4708db4112f682b31146a8db1d456a0482;hpb=9fde8925b467809f91376ba9e6008f39dbe0d2d6

diff --git a/csprogs.c b/csprogs.c
index 5816a3c6..4bacb563 100644
--- a/csprogs.c
+++ b/csprogs.c
@@ -1,3 +1,23 @@
+/*
+Copyright (C) 2006-2021 DarkPlaces contributors
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
 #include "quakedef.h"
 #include "progsvm.h"
 #include "clprogdefs.h"
@@ -11,7 +31,7 @@
 // Client prog handling
 //[515]: omg !!! optimize it ! a lot of hacks here and there also :P
 
-#define CSQC_RETURNVAL	prog->globals.generic[OFS_RETURN]
+#define CSQC_RETURNVAL	prog->globals.fp[OFS_RETURN]
 #define CSQC_BEGIN
 #define CSQC_END
 
@@ -20,10 +40,10 @@ void CL_VM_PreventInformationLeaks(void)
 	prvm_prog_t *prog = CLVM_prog;
 	if(!cl.csqc_loaded)
 		return;
-	CSQC_BEGIN
-		VM_ClearTraceGlobals(prog);
-		PRVM_clientglobalfloat(trace_networkentity) = 0;
-	CSQC_END
+CSQC_BEGIN
+	VM_ClearTraceGlobals(prog);
+	PRVM_clientglobalfloat(trace_networkentity) = 0;
+CSQC_END
 }
 
 //[515]: these are required funcs
@@ -221,12 +241,14 @@ void CSQC_UpdateNetworkTimes(double newtime, double oldtime)
 }
 
 //[515]: set globals before calling R_UpdateView, WEIRD CRAP
-static void CSQC_SetGlobals (void)
+static void CSQC_SetGlobals (double frametime)
 {
+	vec3_t pmove_org;
 	prvm_prog_t *prog = CLVM_prog;
 	CSQC_BEGIN
 		PRVM_clientglobalfloat(time) = cl.time;
-		PRVM_clientglobalfloat(frametime) = max(0, cl.time - cl.oldtime);
+		PRVM_clientglobalfloat(cltime) = host.realtime; // Spike named it that way.
+		PRVM_clientglobalfloat(frametime) = frametime;
 		PRVM_clientglobalfloat(servercommandframe) = cls.servermovesequence;
 		PRVM_clientglobalfloat(clientcommandframe) = cl.movecmd[0].sequence;
 		VectorCopy(cl.viewangles, PRVM_clientglobalvector(input_angles));
@@ -236,10 +258,11 @@ static void CSQC_SetGlobals (void)
 		VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
 		VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
 
-		// LordHavoc: Spike says not to do this, but without pmove_org the
+		// LadyHavoc: Spike says not to do this, but without pmove_org the
 		// CSQC is useless as it can't alter the view origin without
 		// completely replacing it
-		Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, PRVM_clientglobalvector(pmove_org));
+		Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, pmove_org);
+		VectorCopy(pmove_org, PRVM_clientglobalvector(pmove_org));
 		VectorCopy(cl.movement_velocity, PRVM_clientglobalvector(pmove_vel));
 		PRVM_clientglobalfloat(pmove_onground) = cl.onground;
 		PRVM_clientglobalfloat(pmove_inwater) = cl.inwater;
@@ -249,6 +272,8 @@ static void CSQC_SetGlobals (void)
 		VectorCopy(cl.punchvector, PRVM_clientglobalvector(view_punchvector));
 		PRVM_clientglobalfloat(maxclients) = cl.maxclients;
 
+		PRVM_clientglobalfloat(player_localentnum) = cl.viewentity;
+
 		CSQC_R_RecalcView();
 	CSQC_END
 }
@@ -281,15 +306,15 @@ void CSQC_Think (prvm_edict_t *ed)
 }
 
 extern cvar_t cl_noplayershadow;
-extern cvar_t r_equalize_entities_fullbright;
-qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
+qbool CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 {
 	prvm_prog_t *prog = CLVM_prog;
 	int renderflags;
 	int c;
 	float scale;
 	entity_render_t *entrender;
-	dp_model_t *model;
+	model_t *model;
+	prvm_vec3_t modellight_origin;
 
 	model = CL_GetModelFromEdict(ed);
 	if (!model)
@@ -341,12 +366,14 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 	if (!VectorLength2(entrender->glowmod))
 		VectorSet(entrender->glowmod, 1, 1, 1);
 
-	// LordHavoc: use the CL_GetTagMatrix function on self to ensure consistent behavior (duplicate code would be bad)
-	CL_GetTagMatrix(prog, &entrender->matrix, ed, 0);
+	// LadyHavoc: use the CL_GetTagMatrix function on self to ensure consistent behavior (duplicate code would be bad)
+	// this also sets the custommodellight_origin for us
+	CL_GetTagMatrix(prog, &entrender->matrix, ed, 0, modellight_origin);
+	VectorCopy(modellight_origin, entrender->custommodellight_origin);
 
 	// set up the animation data
 	VM_GenerateFrameGroupBlend(prog, ed->priv.server->framegroupblend, ed);
-	VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
+	VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model, cl.time);
 	VM_UpdateEdictSkeleton(prog, ed, model, ed->priv.server->frameblend);
 	if (PRVM_clientedictfloat(ed, shadertime)) // hack for csprogs.dat files that do not set shadertime, leaves the value at entity spawn time
 		entrender->shadertime = PRVM_clientedictfloat(ed, shadertime);
@@ -358,9 +385,9 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 	// model light
 	if (renderflags & RF_MODELLIGHT)
 	{
-		if(PRVM_clientedictvector(ed, modellight_ambient)) VectorCopy(PRVM_clientedictvector(ed, modellight_ambient), entrender->modellight_ambient);
-		if(PRVM_clientedictvector(ed, modellight_diffuse)) VectorCopy(PRVM_clientedictvector(ed, modellight_diffuse), entrender->modellight_diffuse);
-		if(PRVM_clientedictvector(ed, modellight_dir))     VectorCopy(PRVM_clientedictvector(ed, modellight_dir), entrender->modellight_lightdir);
+		if (PRVM_clientedictvector(ed, modellight_ambient)) VectorCopy(PRVM_clientedictvector(ed, modellight_ambient), entrender->custommodellight_ambient); else VectorClear(entrender->custommodellight_ambient);
+		if (PRVM_clientedictvector(ed, modellight_diffuse)) VectorCopy(PRVM_clientedictvector(ed, modellight_diffuse), entrender->custommodellight_diffuse); else VectorClear(entrender->custommodellight_diffuse);
+		if (PRVM_clientedictvector(ed, modellight_dir))     VectorCopy(PRVM_clientedictvector(ed, modellight_dir), entrender->custommodellight_lightdir);    else VectorClear(entrender->custommodellight_lightdir);
 		entrender->flags |= RENDER_CUSTOMIZEDMODELLIGHT;
 	}
 
@@ -371,11 +398,9 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 		if(renderflags & RF_WORLDOBJECT) entrender->flags |= RENDER_WORLDOBJECT;
 		if(renderflags & RF_DEPTHHACK) entrender->flags |= RENDER_NODEPTHTEST;
 		if(renderflags & RF_ADDITIVE) entrender->flags |= RENDER_ADDITIVE;
+		if(renderflags & RF_DYNAMICMODELLIGHT) entrender->flags |= RENDER_DYNAMICMODELLIGHT;
 	}
 
-	if(edictnum == CL_VM_GetViewEntity())
-		entrender->flags |= RENDER_EXTERIORMODEL;
-
 	c = (int)PRVM_clientedictfloat(ed, colormap);
 	if (c <= 0)
 		CL_SetEntityColormapColors(entrender, -1);
@@ -390,8 +415,6 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 	{
 		if (!(entrender->effects & EF_FULLBRIGHT) && !(renderflags & RF_FULLBRIGHT))
 			entrender->flags |= RENDER_LIGHT;
-		else if(r_equalize_entities_fullbright.integer)
-			entrender->flags |= RENDER_LIGHT | RENDER_EQUALIZE;
 	}
 	// hide player shadow during intermission or nehahra movie
 	if (!(entrender->effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST))
@@ -410,10 +433,13 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 		entrender->flags |= RENDER_ADDITIVE;
 	if (entrender->effects & EF_DOUBLESIDED)
 		entrender->flags |= RENDER_DOUBLESIDED;
+	if (entrender->effects & EF_DYNAMICMODELLIGHT)
+		entrender->flags |= RENDER_DYNAMICMODELLIGHT;
 
 	// make the other useful stuff
 	memcpy(entrender->framegroupblend, ed->priv.server->framegroupblend, sizeof(ed->priv.server->framegroupblend));
 	CL_UpdateRenderEntity(entrender);
+
 	// override animation data with full control
 	memcpy(entrender->frameblend, ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend));
 	if (ed->priv.server->skeleton.relativetransforms)
@@ -428,34 +454,34 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
 // 1 = keyup, key, character (EXT_CSQC)
 // 2 = mousemove relative, x, y (EXT_CSQC)
 // 3 = mousemove absolute, x, y (DP_CSQC)
-qboolean CL_VM_InputEvent (int eventtype, int x, int y)
+qbool CL_VM_InputEvent (int eventtype, float x, float y)
 {
 	prvm_prog_t *prog = CLVM_prog;
-	qboolean r;
+	qbool r;
 
 	if(!cl.csqc_loaded)
 		return false;
 
-	CSQC_BEGIN
-		if (!PRVM_clientfunction(CSQC_InputEvent))
-			r = false;
-		else
-		{
-			PRVM_clientglobalfloat(time) = cl.time;
-			PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-			PRVM_G_FLOAT(OFS_PARM0) = eventtype;
-			PRVM_G_FLOAT(OFS_PARM1) = x; // key or x
-			PRVM_G_FLOAT(OFS_PARM2) = y; // ascii or y
-			prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
-			r = CSQC_RETURNVAL != 0;
-		}
-	CSQC_END
+CSQC_BEGIN
+	if (!PRVM_clientfunction(CSQC_InputEvent))
+		r = false;
+	else
+	{
+		PRVM_clientglobalfloat(time) = cl.time;
+		PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
+		PRVM_G_FLOAT(OFS_PARM0) = eventtype;
+		PRVM_G_FLOAT(OFS_PARM1) = x; // key or x
+		PRVM_G_FLOAT(OFS_PARM2) = y; // ascii or y
+		prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
+		r = CSQC_RETURNVAL != 0;
+	}
+CSQC_END
 	return r;
 }
 
 extern r_refdef_view_t csqc_original_r_refdef_view;
 extern r_refdef_view_t csqc_main_r_refdef_view;
-qboolean CL_VM_UpdateView (void)
+qbool CL_VM_UpdateView (double frametime)
 {
 	prvm_prog_t *prog = CLVM_prog;
 	vec3_t emptyvector;
@@ -467,20 +493,30 @@ qboolean CL_VM_UpdateView (void)
 		return false;
 	R_TimeReport("pre-UpdateView");
 	CSQC_BEGIN
-		r_refdef.view.ismain = true;
 		csqc_original_r_refdef_view = r_refdef.view;
 		csqc_main_r_refdef_view = r_refdef.view;
 		//VectorCopy(cl.viewangles, oldangles);
 		PRVM_clientglobalfloat(time) = cl.time;
 		PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-		CSQC_SetGlobals();
+		CSQC_SetGlobals(frametime);
 		// clear renderable entity and light lists to prevent crashes if the
 		// CSQC_UpdateView function does not call R_ClearScene as it should
 		r_refdef.scene.numentities = 0;
 		r_refdef.scene.numlights = 0;
-		// pass in width and height as parameters (EXT_CSQC_1)
+		// polygonbegin without draw2d arg has to guess
+		prog->polygonbegin_guess2d = false;
+		// free memory for resources that are no longer referenced
+		PRVM_GarbageCollection(prog);
+		// pass in width and height and menu/focus state as parameters (EXT_CSQC_1)
 		PRVM_G_FLOAT(OFS_PARM0) = vid.width;
 		PRVM_G_FLOAT(OFS_PARM1) = vid.height;
+		/*
+		 * This should be fine for now but FTEQW uses flags for keydest
+		 * and checks that an array called "eyeoffset" is 0
+		 * 
+		 * Just a note in case there's compatibility problems later
+		 */
+		PRVM_G_FLOAT(OFS_PARM2) = key_dest == key_game;
 		prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_UpdateView), "QC function CSQC_UpdateView is missing");
 		//VectorCopy(oldangles, cl.viewangles);
 		// Dresk : Reset Dmg Globals Here
@@ -493,33 +529,17 @@ qboolean CL_VM_UpdateView (void)
 	return true;
 }
 
-qboolean CL_VM_ConsoleCommand (const char *cmd)
+qbool CL_VM_ConsoleCommand (const char *text)
 {
 	prvm_prog_t *prog = CLVM_prog;
-	int restorevm_tempstringsbuf_cursize;
-	qboolean r = false;
-	if(!cl.csqc_loaded)
-		return false;
-	CSQC_BEGIN
-	if (PRVM_clientfunction(CSQC_ConsoleCommand))
-	{
-		PRVM_clientglobalfloat(time) = cl.time;
-		PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
-		restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
-		PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, cmd);
-		prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
-		prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
-		r = CSQC_RETURNVAL != 0;
-	}
-	CSQC_END
-	return r;
+	return PRVM_ConsoleCommand(prog, text, &prog->funcoffsets.CSQC_ConsoleCommand, false, cl.csqc_server2csqcentitynumber[cl.playerentity], cl.time, cl.csqc_loaded, "QC function CSQC_ConsoleCommand is missing");
 }
 
-qboolean CL_VM_Parse_TempEntity (void)
+qbool CL_VM_Parse_TempEntity (void)
 {
 	prvm_prog_t *prog = CLVM_prog;
 	int			t;
-	qboolean	r = false;
+	qbool	r = false;
 	if(!cl.csqc_loaded)
 		return false;
 	CSQC_BEGIN
@@ -553,12 +573,10 @@ void CL_VM_Parse_StuffCmd (const char *msg)
 		// temporarily so that it can be set by the cvar command,
 		// and then reprotect it afterwards
 		int crcflags = csqc_progcrc.flags;
-		int sizeflags = csqc_progcrc.flags;
-		csqc_progcrc.flags &= ~CVAR_READONLY;
-		csqc_progsize.flags &= ~CVAR_READONLY;
-		Cmd_ExecuteString (msg, src_command, true);
-		csqc_progcrc.flags = crcflags;
-		csqc_progsize.flags = sizeflags;
+		csqc_progcrc.flags &= ~CF_READONLY;
+		csqc_progsize.flags &= ~CF_READONLY;
+		Cmd_ExecuteString(cmd_local, msg, src_local, true);
+		csqc_progcrc.flags = csqc_progsize.flags = crcflags;
 		return;
 	}
 
@@ -589,7 +607,7 @@ void CL_VM_Parse_StuffCmd (const char *msg)
 				l = sizeof(buf) - 1;
 			strlcpy(buf, p, l + 1); // strlcpy needs a + 1 as it includes the newline!
 
-			Cmd_ExecuteString(buf, src_command, true);
+			Cmd_ExecuteString(cmd_local, buf, src_local, true);
 
 			p += l;
 			if(*p == '\n')
@@ -597,13 +615,13 @@ void CL_VM_Parse_StuffCmd (const char *msg)
 			else
 				break; // end of string or overflow
 		}
-		Cmd_ExecuteString("curl --clear_autodownload", src_command, true); // don't inhibit CSQC loading
+		Cmd_ExecuteString(cmd_local, "curl --clear_autodownload", src_local, true); // don't inhibit CSQC loading
 		return;
 	}
 
 	if(!cl.csqc_loaded)
 	{
-		Cbuf_AddText(msg);
+		Cbuf_AddText(cmd_local, msg);
 		return;
 	}
 	CSQC_BEGIN
@@ -617,7 +635,7 @@ void CL_VM_Parse_StuffCmd (const char *msg)
 		prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
 	}
 	else
-		Cbuf_AddText(msg);
+		Cbuf_AddText(cmd_local, msg);
 	CSQC_END
 }
 
@@ -637,13 +655,8 @@ void CSQC_AddPrintText (const char *msg)
 {
 	prvm_prog_t *prog = CLVM_prog;
 	size_t i;
-	if(!cl.csqc_loaded)
-	{
-		Con_Print(msg);
-		return;
-	}
 	CSQC_BEGIN
-	if(PRVM_clientfunction(CSQC_Parse_Print))
+	if(cl.csqc_loaded && PRVM_clientfunction(CSQC_Parse_Print))
 	{
 		// FIXME: is this bugged?
 		i = strlen(msg)-1;
@@ -671,13 +684,8 @@ void CL_VM_Parse_CenterPrint (const char *msg)
 {
 	prvm_prog_t *prog = CLVM_prog;
 	int restorevm_tempstringsbuf_cursize;
-	if(!cl.csqc_loaded)
-	{
-		SCR_CenterPrint(msg);
-		return;
-	}
 	CSQC_BEGIN
-	if(PRVM_clientfunction(CSQC_Parse_CenterPrint))
+	if(cl.csqc_loaded && PRVM_clientfunction(CSQC_Parse_CenterPrint))
 	{
 		PRVM_clientglobalfloat(time) = cl.time;
 		PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
@@ -711,10 +719,10 @@ void CL_VM_UpdateShowingScoresState (int showingscores)
 		CSQC_END
 	}
 }
-qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed)
+qbool CL_VM_Event_Sound(int sound_num, float fvolume, int channel, float attenuation, int ent, vec3_t pos, int flags, float speed)
 {
 	prvm_prog_t *prog = CLVM_prog;
-	qboolean r = false;
+	qbool r = false;
 	if(cl.csqc_loaded)
 	{
 		CSQC_BEGIN
@@ -725,7 +733,7 @@ qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float atten
 			PRVM_G_FLOAT(OFS_PARM0) = ent;
 			PRVM_G_FLOAT(OFS_PARM1) = CHAN_ENGINE2USER(channel);
 			PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(prog, cl.sound_name[sound_num] );
-			PRVM_G_FLOAT(OFS_PARM3) = volume;
+			PRVM_G_FLOAT(OFS_PARM3) = fvolume;
 			PRVM_G_FLOAT(OFS_PARM4) = attenuation;
 			VectorCopy(pos, PRVM_G_VECTOR(OFS_PARM5) );
 			PRVM_G_FLOAT(OFS_PARM6) = speed * 100.0f;
@@ -821,7 +829,7 @@ void CSQC_ReadEntities (void)
 				}
 				else
 				{
-					// LordHavoc: removing an entity that is already gone on
+					// LadyHavoc: removing an entity that is already gone on
 					// the csqc side is possible for legitimate reasons (such
 					// as a repeat of the remove message), so no warning is
 					// needed
@@ -875,7 +883,7 @@ static void CLVM_end_increase_edicts(prvm_prog_t *prog)
 
 	// link every entity except world
 	for (i = 1, ent = prog->edicts;i < prog->num_edicts;i++, ent++)
-		if (!ent->priv.server->free)
+		if (!ent->free && !VectorCompare(PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax)))
 			CL_LinkEdict(ent);
 }
 
@@ -896,10 +904,12 @@ static void CLVM_free_edict(prvm_prog_t *prog, prvm_edict_t *ed)
 	R_DecalSystem_Reset(&entrender->decalsystem);
 	memset(entrender, 0, sizeof(*entrender));
 	World_UnlinkEdict(ed);
-	memset(ed->fields.vp, 0, prog->entityfields * 4);
+	memset(ed->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
 	VM_RemoveEdictSkeleton(prog, ed);
+#ifdef USEODE
 	World_Physics_RemoveFromEntity(&cl.world, ed);
 	World_Physics_RemoveJointFromEntity(&cl.world, ed);
+#endif
 }
 
 static void CLVM_count_edicts(prvm_prog_t *prog)
@@ -911,7 +921,7 @@ static void CLVM_count_edicts(prvm_prog_t *prog)
 	for (i=0 ; i<prog->num_edicts ; i++)
 	{
 		ent = PRVM_EDICT_NUM(i);
-		if (ent->priv.server->free)
+		if (ent->free)
 			continue;
 		active++;
 		if (PRVM_clientedictfloat(ent, solid))
@@ -926,17 +936,17 @@ static void CLVM_count_edicts(prvm_prog_t *prog)
 	Con_Printf("touch     :%3i\n", solid);
 }
 
-static qboolean CLVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
+static qbool CLVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
 {
 	return true;
 }
 
 // returns true if the packet is valid, false if end of file is reached
 // used for dumping the CSQC download into demo files
-qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t len, int crc, int cnt, sizebuf_t *buf, int protocol)
+qbool MakeDownloadPacket(const char *filename, unsigned char *data, size_t len, int crc, int cnt, sizebuf_t *buf, int protocol)
 {
 	int packetsize = buf->maxsize - 7; // byte short long
-	int npackets = (len + packetsize - 1) / (packetsize);
+	int npackets = ((int)len + packetsize - 1) / (packetsize);
 	char vabuf[1024];
 
 	if(protocol == PROTOCOL_QUAKEWORLD)
@@ -952,7 +962,7 @@ qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t le
 	else if(cnt >= 1 && cnt <= npackets)
 	{
 		unsigned long thispacketoffset = (cnt - 1) * packetsize;
-		int thispacketsize = len - thispacketoffset;
+		int thispacketsize = (int)len - thispacketoffset;
 		if(thispacketsize > packetsize)
 			thispacketsize = packetsize;
 
@@ -995,11 +1005,22 @@ void CL_VM_Init (void)
 		return;
 
 	// see if the requested csprogs.dat file matches the requested crc
-	csprogsdatacrc = -1;
 	if (!cls.demoplayback || csqc_usedemoprogs.integer)
 	{
 		csprogsfn = va(vabuf, sizeof(vabuf), "dlcache/%s.%i.%i", csqc_progname.string, requiredsize, requiredcrc);
-		csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
+		if(cls.caughtcsprogsdata && cls.caughtcsprogsdatasize == requiredsize && CRC_Block(cls.caughtcsprogsdata, (size_t)cls.caughtcsprogsdatasize) == requiredcrc)
+		{
+			Con_DPrintf("Using buffered \"%s\"\n", csprogsfn);
+			csprogsdata = cls.caughtcsprogsdata;
+			csprogsdatasize = cls.caughtcsprogsdatasize;
+			cls.caughtcsprogsdata = NULL;
+			cls.caughtcsprogsdatasize = 0;
+		}
+		else
+		{
+			Con_DPrintf("Not using buffered \"%s\" (buffered: %p, %d)\n", csprogsfn, (void *)cls.caughtcsprogsdata, (int) cls.caughtcsprogsdatasize);
+			csprogsdata = FS_LoadFile(csprogsfn, tempmempool, true, &csprogsdatasize);
+		}
 	}
 	if (!csprogsdata)
 	{
@@ -1013,7 +1034,7 @@ void CL_VM_Init (void)
 		{
 			if (cls.demoplayback)
 			{
-				Con_Printf("^1Warning: Your %s is not the same version as the demo was recorded with (CRC/size are %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
+				Con_Printf(CON_WARN "Warning: Your %s is not the same version as the demo was recorded with (CRC/size are %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
 				// Mem_Free(csprogsdata);
 				// return;
 				// We WANT to continue here, and play the demo with different csprogs!
@@ -1022,8 +1043,7 @@ void CL_VM_Init (void)
 			else
 			{
 				Mem_Free(csprogsdata);
-				Con_Printf("^1Your %s is not the same version as the server (CRC is %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
-				CL_Disconnect();
+				CL_DisconnectEx(false, "Your %s is not the same version as the server (CRC is %i/%i but should be %i/%i)\n", csqc_progname.string, csprogsdatacrc, (int)csprogsdatasize, requiredcrc, requiredsize);
 				return;
 			}
 		}
@@ -1031,17 +1051,11 @@ void CL_VM_Init (void)
 	else
 	{
 		if (requiredcrc >= 0)
-		{
-			if (cls.demoplayback)
-				Con_Printf("CL_VM_Init: demo requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
-			else
-				Con_Printf("CL_VM_Init: server requires CSQC, but \"%s\" wasn't found\n", csqc_progname.string);
-			CL_Disconnect();
-		}
+			CL_DisconnectEx(false, CON_ERROR "CL_VM_Init: %s requires CSQC, but \"%s\" wasn't found\n", cls.demoplayback ? "demo" : "server", csqc_progname.string);
 		return;
 	}
 
-	PRVM_Prog_Init(prog);
+	PRVM_Prog_Init(prog, cmd_local);
 
 	// allocate the mempools
 	prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
@@ -1069,19 +1083,14 @@ void CL_VM_Init (void)
 	prog->error_cmd             = Host_Error;
 	prog->ExecuteProgram        = CLVM_ExecuteProgram;
 
-	PRVM_Prog_Load(prog, csprogsfn, cl_numrequiredfunc, cl_required_func, CL_REQFIELDS, cl_reqfields, CL_REQGLOBALS, cl_reqglobals);
+	PRVM_Prog_Load(prog, csprogsfn, csprogsdata, csprogsdatasize, cl_numrequiredfunc, cl_required_func, CL_REQFIELDS, cl_reqfields, CL_REQGLOBALS, cl_reqglobals);
 
 	if (!prog->loaded)
 	{
-		Host_Error("CSQC %s ^2failed to load\n", csprogsfn);
-		if(!sv.active)
-			CL_Disconnect();
 		Mem_Free(csprogsdata);
-		return;
+		Host_Error("CSQC %s failed to load\n", csprogsfn);
 	}
 
-	Con_DPrintf("CSQC %s ^5loaded (crc=%i, size=%i)\n", csprogsfn, csprogsdatacrc, (int)csprogsdatasize);
-
 	if(cls.demorecording)
 	{
 		if(cls.demo_lastcsprogssize != csprogsdatasize || cls.demo_lastcsprogscrc != csprogsdatacrc)
@@ -1115,16 +1124,22 @@ void CL_VM_Init (void)
 	PRVM_clientglobaledict(self) = 0;
 
 	PRVM_clientglobalstring(mapname) = PRVM_SetEngineString(prog, cl.worldname);
-	PRVM_clientglobalfloat(player_localentnum) = cl.playerentity;
+	PRVM_clientglobalfloat(player_localnum) = cl.realplayerentity - 1;
+	PRVM_clientglobalfloat(player_localentnum) = cl.viewentity;
 
 	// set map description (use world entity 0)
 	PRVM_clientedictstring(prog->edicts, message) = PRVM_SetEngineString(prog, cl.worldmessage);
 	VectorCopy(cl.world.mins, PRVM_clientedictvector(prog->edicts, mins));
 	VectorCopy(cl.world.maxs, PRVM_clientedictvector(prog->edicts, maxs));
+	VectorCopy(cl.world.mins, PRVM_clientedictvector(prog->edicts, absmin));
+	VectorCopy(cl.world.maxs, PRVM_clientedictvector(prog->edicts, absmax));
 
 	// call the prog init
 	prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Init), "QC function CSQC_Init is missing");
 
+	// Once CSQC_Init was called, we consider csqc code fully initialized.
+	prog->inittime = host.realtime;
+
 	cl.csqc_loaded = true;
 
 	cl.csqc_vidvars.drawcrosshair = false;
@@ -1137,41 +1152,42 @@ void CL_VM_Init (void)
 void CL_VM_ShutDown (void)
 {
 	prvm_prog_t *prog = CLVM_prog;
-	Cmd_ClearCsqcFuncs();
+	Cmd_ClearCSQCCommands(cmd_local);
 	//Cvar_SetValueQuick(&csqc_progcrc, -1);
 	//Cvar_SetValueQuick(&csqc_progsize, -1);
 	if(!cl.csqc_loaded)
 		return;
-	CSQC_BEGIN
+CSQC_BEGIN
+	if (prog->loaded)
+	{
 		PRVM_clientglobalfloat(time) = cl.time;
 		PRVM_clientglobaledict(self) = 0;
 		if (PRVM_clientfunction(CSQC_Shutdown))
 			prog->ExecuteProgram(prog, PRVM_clientfunction(CSQC_Shutdown), "QC function CSQC_Shutdown is missing");
-		PRVM_Prog_Reset(prog);
-	CSQC_END
+	}
+	PRVM_Prog_Reset(prog);
+CSQC_END
 	Con_DPrint("CSQC ^1unloaded\n");
 	cl.csqc_loaded = false;
 }
 
-qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
+qbool CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
 {
 	prvm_prog_t *prog = CLVM_prog;
 	prvm_edict_t *ed;
-	dp_model_t *mod;
+	model_t *mod;
 	matrix4x4_t matrix;
-	qboolean r = 0;
+	qbool r = 0;
 
 	CSQC_BEGIN;
 
-	// FIXME consider attachments here!
-
 	ed = PRVM_EDICT_NUM(entnum - MAX_EDICTS);
 
-	if(!ed->priv.required->free)
+	if(!ed->free)
 	{
 		mod = CL_GetModelFromEdict(ed);
 		VectorCopy(PRVM_clientedictvector(ed, origin), out);
-		if(CL_GetTagMatrix(prog, &matrix, ed, 0) == 0)
+		if(CL_GetTagMatrix(prog, &matrix, ed, 0, NULL) == 0)
 			Matrix4x4_OriginFromMatrix(&matrix, out);
 		if (mod && mod->soundfromcenter)
 			VectorMAMAM(1.0f, out, 0.5f, mod->normalmins, 0.5f, mod->normalmaxs, out);
@@ -1183,10 +1199,10 @@ qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
 	return r;
 }
 
-qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clipplane, vec3_t visorigin)
+qbool CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clipplane, vec3_t visorigin)
 {
 	prvm_prog_t *prog = CLVM_prog;
-	qboolean ret = false;
+	qbool ret = false;
 	prvm_edict_t *ed;
 	vec3_t forward, left, up, origin, ang;
 	matrix4x4_t mat, matq;
@@ -1198,7 +1214,7 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
 		if(PRVM_clientedictfunction(ed, camera_transform))
 		{
 			ret = true;
-			if(viewmatrix || clipplane || visorigin)
+			if(viewmatrix && clipplane && visorigin)
 			{
 				Matrix4x4_ToVectors(viewmatrix, forward, left, up, origin);
 				AnglesFromVectors(ang, forward, up, false);
@@ -1219,7 +1235,7 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
 				Matrix4x4_Invert_Full(&mat, viewmatrix);
 				Matrix4x4_FromVectors(viewmatrix, forward, left, up, origin);
 				Matrix4x4_Concat(&matq, viewmatrix, &mat);
-				Matrix4x4_TransformPositivePlane(&matq, clipplane->normal[0], clipplane->normal[1], clipplane->normal[2], clipplane->dist, &clipplane->normal[0]);
+				Matrix4x4_TransformPositivePlane(&matq, clipplane->normal[0], clipplane->normal[1], clipplane->normal[2], clipplane->dist, clipplane->normal_and_dist);
 			}
 		}
 	CSQC_END
@@ -1230,6 +1246,6 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
 int CL_VM_GetViewEntity(void)
 {
 	if(cl.csqc_server2csqcentitynumber[cl.viewentity])
-		return cl.csqc_server2csqcentitynumber[cl.viewentity];
+		return cl.csqc_server2csqcentitynumber[cl.viewentity] + MAX_EDICTS;
 	return cl.viewentity;
 }