X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_cmds.c;h=3d6cec40bdfe641e2b960affc620e67f02c36c30;hp=bdaf712bd31a3c790946fde5bc33d1ac11666fd7;hb=b580442d0be79e1c4c78b9cb568fe30cf3e03f76;hpb=facaed0509e7b7c30d6ec3f9d3438ee21f77c6e8

diff --git a/prvm_cmds.c b/prvm_cmds.c
index bdaf712b..3d6cec40 100644
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -7,8 +7,11 @@
 #include "quakedef.h"
 
 #include "prvm_cmds.h"
+#include "libcurl.h"
 #include <time.h>
 
+#include "ft2.h"
+
 extern cvar_t prvm_backtraceforwarnings;
 
 // LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
@@ -22,7 +25,7 @@ void VM_Warning(const char *fmt, ...)
 	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 	va_end(argptr);
 
-	Con_Printf(msg);
+	Con_Print(msg);
 
 	// TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
 	if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
@@ -44,10 +47,193 @@ void VM_Warning(const char *fmt, ...)
 
 void VM_CheckEmptyString (const char *s)
 {
-	if (s[0] <= ' ')
+	if (ISWHITESPACE(s[0]))
 		PRVM_ERROR ("%s: Bad string", PRVM_NAME);
 }
 
+void VM_GenerateFrameGroupBlend(framegroupblend_t *framegroupblend, const prvm_edict_t *ed)
+{
+	prvm_eval_t *val;
+	// self.frame is the interpolation target (new frame)
+	// self.frame1time is the animation base time for the interpolation target
+	// self.frame2 is the interpolation start (previous frame)
+	// self.frame2time is the animation base time for the interpolation start
+	// self.lerpfrac is the interpolation strength for self.frame2
+	// self.lerpfrac3 is the interpolation strength for self.frame3
+	// self.lerpfrac4 is the interpolation strength for self.frame4
+	// pitch angle on a player model where the animator set up 5 sets of
+	// animations and the csqc simply lerps between sets)
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame))) framegroupblend[0].frame = (int) val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame2))) framegroupblend[1].frame = (int) val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame3))) framegroupblend[2].frame = (int) val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame4))) framegroupblend[3].frame = (int) val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame1time))) framegroupblend[0].start = val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame2time))) framegroupblend[1].start = val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame3time))) framegroupblend[2].start = val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.frame4time))) framegroupblend[3].start = val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac))) framegroupblend[1].lerp = val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac3))) framegroupblend[2].lerp = val->_float;
+	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.lerpfrac4))) framegroupblend[3].lerp = val->_float;
+	// assume that the (missing) lerpfrac1 is whatever remains after lerpfrac2+lerpfrac3+lerpfrac4 are summed
+	framegroupblend[0].lerp = 1 - framegroupblend[1].lerp - framegroupblend[2].lerp - framegroupblend[3].lerp;
+}
+
+// LordHavoc: quite tempting to break apart this function to reuse the
+//            duplicated code, but I suspect it is better for performance
+//            this way
+void VM_FrameBlendFromFrameGroupBlend(frameblend_t *frameblend, const framegroupblend_t *framegroupblend, const dp_model_t *model)
+{
+	int sub2, numframes, f, i, k;
+	int isfirstframegroup = true;
+	int nolerp;
+	double sublerp, lerp, d;
+	const animscene_t *scene;
+	const framegroupblend_t *g;
+	frameblend_t *blend = frameblend;
+
+	memset(blend, 0, MAX_FRAMEBLENDS * sizeof(*blend));
+
+	if (!model || !model->surfmesh.isanimated)
+	{
+		blend[0].lerp = 1;
+		return;
+	}
+
+	nolerp = (model->type == mod_sprite) ? !r_lerpsprites.integer : !r_lerpmodels.integer;
+	numframes = model->numframes;
+	for (k = 0, g = framegroupblend;k < MAX_FRAMEGROUPBLENDS;k++, g++)
+	{
+		f = g->frame;
+		if ((unsigned int)f >= (unsigned int)numframes)
+		{
+			Con_DPrintf("VM_FrameBlendFromFrameGroupBlend: no such frame %d in model %s\n", f, model->name);
+			f = 0;
+		}
+		d = lerp = g->lerp;
+		if (lerp <= 0)
+			continue;
+		if (nolerp)
+		{
+			if (isfirstframegroup)
+			{
+				d = lerp = 1;
+				isfirstframegroup = false;
+			}
+			else
+				continue;
+		}
+		if (model->animscenes)
+		{
+			scene = model->animscenes + f;
+			f = scene->firstframe;
+			if (scene->framecount > 1)
+			{
+				// this code path is only used on .zym models and torches
+				sublerp = scene->framerate * (cl.time - g->start);
+				f = (int) floor(sublerp);
+				sublerp -= f;
+				sub2 = f + 1;
+				if (sublerp < (1.0 / 65536.0f))
+					sublerp = 0;
+				if (sublerp > (65535.0f / 65536.0f))
+					sublerp = 1;
+				if (nolerp)
+					sublerp = 0;
+				if (scene->loop)
+				{
+					f = (f % scene->framecount);
+					sub2 = (sub2 % scene->framecount);
+				}
+				f = bound(0, f, (scene->framecount - 1)) + scene->firstframe;
+				sub2 = bound(0, sub2, (scene->framecount - 1)) + scene->firstframe;
+				d = sublerp * lerp;
+				// two framelerps produced from one animation
+				if (d > 0)
+				{
+					for (i = 0;i < MAX_FRAMEBLENDS;i++)
+					{
+						if (blend[i].lerp <= 0 || blend[i].subframe == sub2)
+						{
+							blend[i].subframe = sub2;
+							blend[i].lerp += d;
+							break;
+						}
+					}
+				}
+				d = (1 - sublerp) * lerp;
+			}
+		}
+		if (d > 0)
+		{
+			for (i = 0;i < MAX_FRAMEBLENDS;i++)
+			{
+				if (blend[i].lerp <= 0 || blend[i].subframe == f)
+				{
+					blend[i].subframe = f;
+					blend[i].lerp += d;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const frameblend_t *frameblend)
+{
+	if (ed->priv.server->skeleton.model != edmodel)
+	{
+		VM_RemoveEdictSkeleton(ed);
+		ed->priv.server->skeleton.model = edmodel;
+	}
+	if (!ed->priv.server->skeleton.relativetransforms && ed->priv.server->skeleton.model && ed->priv.server->skeleton.model->num_bones)
+		ed->priv.server->skeleton.relativetransforms = Mem_Alloc(prog->progs_mempool, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
+	if (ed->priv.server->skeleton.relativetransforms)
+	{
+		int skeletonindex = 0;
+		skeleton_t *skeleton;
+		prvm_eval_t *val;
+		if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.skeletonindex))) skeletonindex = (int)val->_float;
+		if (skeletonindex > 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones)
+		{
+			// custom skeleton controlled by the game (FTE_CSQC_SKELETONOBJECTS)
+			memcpy(ed->priv.server->skeleton.relativetransforms, skeleton->relativetransforms, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
+		}
+		else
+		{
+			// generated skeleton from frame animation
+			int blendindex;
+			int bonenum;
+			int numbones = ed->priv.server->skeleton.model->num_bones;
+			const float *poses = ed->priv.server->skeleton.model->data_poses;
+			const float *framebones;
+			float lerp;
+			matrix4x4_t *relativetransforms = ed->priv.server->skeleton.relativetransforms;
+			matrix4x4_t matrix;
+			memset(relativetransforms, 0, numbones * sizeof(matrix4x4_t));
+			for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++)
+			{
+				lerp = frameblend[blendindex].lerp;
+				framebones = poses + 12 * frameblend[blendindex].subframe * numbones;
+				for (bonenum = 0;bonenum < numbones;bonenum++)
+				{
+					Matrix4x4_FromArray12FloatD3D(&matrix, framebones + 12 * bonenum);
+					Matrix4x4_Accumulate(&ed->priv.server->skeleton.relativetransforms[bonenum], &matrix, lerp);
+				}
+			}
+		}
+	}
+}
+
+void VM_RemoveEdictSkeleton(prvm_edict_t *ed)
+{
+	if (ed->priv.server->skeleton.relativetransforms)
+		Mem_Free(ed->priv.server->skeleton.relativetransforms);
+	memset(&ed->priv.server->skeleton, 0, sizeof(ed->priv.server->skeleton));
+}
+
+
+
+
 //============================================================================
 //BUILT-IN FUNCTIONS
 
@@ -412,6 +598,13 @@ void VM_localcmd (void)
 	Cbuf_AddText(string);
 }
 
+static qboolean PRVM_Cvar_ReadOk(const char *string)
+{
+	cvar_t *cvar;
+	cvar = Cvar_FindVar(string);
+	return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0));
+}
+
 /*
 =================
 VM_cvar
@@ -425,7 +618,7 @@ void VM_cvar (void)
 	VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
 	VM_VarString(0, string, sizeof(string));
 	VM_CheckEmptyString(string);
-	PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(string);
+	PRVM_G_FLOAT(OFS_RETURN) = PRVM_Cvar_ReadOk(string) ? Cvar_VariableValue(string) : 0;
 }
 
 /*
@@ -438,6 +631,7 @@ float CVAR_TYPEFLAG_SAVED = 2;
 float CVAR_TYPEFLAG_PRIVATE = 4;
 float CVAR_TYPEFLAG_ENGINE = 8;
 float CVAR_TYPEFLAG_HASDESCRIPTION = 16;
+float CVAR_TYPEFLAG_READONLY = 32;
 =================
 */
 void VM_cvar_type (void)
@@ -465,8 +659,10 @@ void VM_cvar_type (void)
 		ret |= 4; // CVAR_TYPE_PRIVATE
 	if(!(cvar->flags & CVAR_ALLOCATED))
 		ret |= 8; // CVAR_TYPE_ENGINE
-	if(strcmp(cvar->description, "custom cvar")) // has to match Cvar_Get's placeholder string
+	if(cvar->description != cvar_dummy_description)
 		ret |= 16; // CVAR_TYPE_HASDESCRIPTION
+	if(cvar->flags & CVAR_READONLY)
+		ret |= 32; // CVAR_TYPE_READONLY
 	
 	PRVM_G_FLOAT(OFS_RETURN) = ret;
 }
@@ -484,7 +680,7 @@ void VM_cvar_string(void)
 	VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_string);
 	VM_VarString(0, string, sizeof(string));
 	VM_CheckEmptyString(string);
-	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableString(string));
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_Cvar_ReadOk(string) ? Cvar_VariableString(string) : "");
 }
 
 
@@ -503,6 +699,22 @@ void VM_cvar_defstring (void)
 	VM_CheckEmptyString(string);
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDefString(string));
 }
+
+/*
+========================
+VM_cvar_defstring
+
+const string	VM_cvar_description (string, ...)
+========================
+*/
+void VM_cvar_description (void)
+{
+	char string[VM_STRINGTEMP_LENGTH];
+	VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar_description);
+	VM_VarString(0, string, sizeof(string));
+	VM_CheckEmptyString(string);
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Cvar_VariableDescription(string));
+}
 /*
 =================
 VM_cvar_set
@@ -561,9 +773,9 @@ void VM_ftos (void)
 	v = PRVM_G_FLOAT(OFS_PARM0);
 
 	if ((float)((int)v) == v)
-		sprintf(s, "%i", (int)v);
+		dpsnprintf(s, sizeof(s), "%i", (int)v);
 	else
-		sprintf(s, "%f", v);
+		dpsnprintf(s, sizeof(s), "%f", v);
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
 }
 
@@ -599,7 +811,7 @@ void VM_vtos (void)
 
 	VM_SAFEPARMCOUNT(1,VM_vtos);
 
-	sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
+	dpsnprintf (s, sizeof(s), "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
 }
 
@@ -617,7 +829,7 @@ void VM_etos (void)
 
 	VM_SAFEPARMCOUNT(1, VM_etos);
 
-	sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
+	dpsnprintf (s, sizeof(s), "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(s);
 }
 
@@ -691,23 +903,40 @@ string strftime(float uselocaltime, string[, string ...])
 void VM_strftime(void)
 {
 	time_t t;
+#if _MSC_VER >= 1400
+	struct tm tm;
+	int tmresult;
+#else
 	struct tm *tm;
+#endif
 	char fmt[VM_STRINGTEMP_LENGTH];
 	char result[VM_STRINGTEMP_LENGTH];
 	VM_SAFEPARMCOUNTRANGE(2, 8, VM_strftime);
 	VM_VarString(1, fmt, sizeof(fmt));
 	t = time(NULL);
+#if _MSC_VER >= 1400
+	if (PRVM_G_FLOAT(OFS_PARM0))
+		tmresult = localtime_s(&tm, &t);
+	else
+		tmresult = gmtime_s(&tm, &t);
+	if (!tmresult)
+#else
 	if (PRVM_G_FLOAT(OFS_PARM0))
 		tm = localtime(&t);
 	else
 		tm = gmtime(&t);
 	if (!tm)
+#endif
 	{
-		PRVM_G_FLOAT(OFS_RETURN) = 0;
+		PRVM_G_INT(OFS_RETURN) = 0;
 		return;
 	}
+#if _MSC_VER >= 1400
+	strftime(result, sizeof(result), fmt, &tm);
+#else
 	strftime(result, sizeof(result), fmt, tm);
-	PRVM_G_FLOAT(OFS_RETURN) = PRVM_SetTempString(result);
+#endif
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(result);
 }
 
 /*
@@ -854,11 +1083,16 @@ void VM_findchain (void)
 	int		f;
 	const char	*s, *t;
 	prvm_edict_t	*ent, *chain;
+	int chainfield;
 
-	VM_SAFEPARMCOUNT(2,VM_findchain);
+	VM_SAFEPARMCOUNTRANGE(2,3,VM_findchain);
 
-	if (prog->fieldoffsets.chain < 0)
-		PRVM_ERROR("VM_findchain: %s doesnt have a chain field !", PRVM_NAME);
+	if(prog->argc == 3)
+		chainfield = PRVM_G_INT(OFS_PARM2);
+	else
+		chainfield = prog->fieldoffsets.chain;
+	if (chainfield < 0)
+		PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
 
 	chain = prog->edicts;
 
@@ -881,7 +1115,7 @@ void VM_findchain (void)
 		if (strcmp(t,s))
 			continue;
 
-		PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_NUM_FOR_EDICT(chain);
+		PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_NUM_FOR_EDICT(chain);
 		chain = ent;
 	}
 
@@ -904,11 +1138,16 @@ void VM_findchainfloat (void)
 	int		f;
 	float	s;
 	prvm_edict_t	*ent, *chain;
+	int chainfield;
 
-	VM_SAFEPARMCOUNT(2, VM_findchainfloat);
+	VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainfloat);
 
-	if (prog->fieldoffsets.chain < 0)
-		PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !", PRVM_NAME);
+	if(prog->argc == 3)
+		chainfield = PRVM_G_INT(OFS_PARM2);
+	else
+		chainfield = prog->fieldoffsets.chain;
+	if (chainfield < 0)
+		PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
 
 	chain = (prvm_edict_t *)prog->edicts;
 
@@ -924,7 +1163,7 @@ void VM_findchainfloat (void)
 		if (PRVM_E_FLOAT(ent,f) != s)
 			continue;
 
-		PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
+		PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
 		chain = ent;
 	}
 
@@ -985,11 +1224,16 @@ void VM_findchainflags (void)
 	int		f;
 	int		s;
 	prvm_edict_t	*ent, *chain;
+	int chainfield;
 
-	VM_SAFEPARMCOUNT(2, VM_findchainflags);
+	VM_SAFEPARMCOUNTRANGE(2, 3, VM_findchainflags);
 
-	if (prog->fieldoffsets.chain < 0)
-		PRVM_ERROR("VM_findchainflags: %s doesnt have a chain field !", PRVM_NAME);
+	if(prog->argc == 3)
+		chainfield = PRVM_G_INT(OFS_PARM2);
+	else
+		chainfield = prog->fieldoffsets.chain;
+	if (chainfield < 0)
+		PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
 
 	chain = (prvm_edict_t *)prog->edicts;
 
@@ -1007,7 +1251,7 @@ void VM_findchainflags (void)
 		if (!((int)PRVM_E_FLOAT(ent,f) & s))
 			continue;
 
-		PRVM_EDICTFIELDVALUE(ent,prog->fieldoffsets.chain)->edict = PRVM_EDICT_TO_PROG(chain);
+		PRVM_EDICTFIELDVALUE(ent,chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
 		chain = ent;
 	}
 
@@ -1029,9 +1273,9 @@ void VM_precache_sound (void)
 
 	s = PRVM_G_STRING(OFS_PARM0);
 	PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
-	VM_CheckEmptyString(s);
+	//VM_CheckEmptyString(s);
 
-	if(snd_initialized.integer && !S_PrecacheSound(s, true, false))
+	if(snd_initialized.integer && !S_PrecacheSound(s, true, true))
 	{
 		VM_Warning("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
 		return;
@@ -1421,7 +1665,7 @@ void VM_registercvar (void)
 		return;
 	}
 
-	Cvar_Get(name, value, flags);
+	Cvar_Get(name, value, flags, NULL);
 
 	PRVM_G_FLOAT(OFS_RETURN) = 1; // success
 }
@@ -1509,6 +1753,12 @@ void VM_pow (void)
 	PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
 }
 
+void VM_log (void)
+{
+	VM_SAFEPARMCOUNT(1,VM_log);
+	PRVM_G_FLOAT(OFS_RETURN) = log(PRVM_G_FLOAT(OFS_PARM0));
+}
+
 void VM_Files_Init(void)
 {
 	int i;
@@ -1568,28 +1818,29 @@ void VM_fopen(void)
 		VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES);
 		return;
 	}
+	filename = PRVM_G_STRING(OFS_PARM0);
 	mode = (int)PRVM_G_FLOAT(OFS_PARM1);
 	switch(mode)
 	{
 	case 0: // FILE_READ
 		modestring = "rb";
+		prog->openfiles[filenum] = FS_OpenVirtualFile(va("data/%s", filename), false);
+		if (prog->openfiles[filenum] == NULL)
+			prog->openfiles[filenum] = FS_OpenVirtualFile(va("%s", filename), false);
 		break;
 	case 1: // FILE_APPEND
-		modestring = "ab";
+		modestring = "a";
+		prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false);
 		break;
 	case 2: // FILE_WRITE
-		modestring = "wb";
+		modestring = "w";
+		prog->openfiles[filenum] = FS_OpenRealFile(va("data/%s", filename), modestring, false);
 		break;
 	default:
 		PRVM_G_FLOAT(OFS_RETURN) = -3;
 		VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
 		return;
 	}
-	filename = PRVM_G_STRING(OFS_PARM0);
-
-	prog->openfiles[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
-	if (prog->openfiles[filenum] == NULL && mode == 0)
-		prog->openfiles[filenum] = FS_Open(va("%s", filename), modestring, false, false);
 
 	if (prog->openfiles[filenum] == NULL)
 	{
@@ -1602,6 +1853,7 @@ void VM_fopen(void)
 		PRVM_G_FLOAT(OFS_RETURN) = filenum;
 		if (developer.integer >= 100)
 			Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
+		prog->openfiles_origin[filenum] = PRVM_AllocationOrigin();
 	}
 }
 
@@ -1632,6 +1884,8 @@ void VM_fclose(void)
 	}
 	FS_Close(prog->openfiles[filenum]);
 	prog->openfiles[filenum] = NULL;
+	if(prog->openfiles_origin[filenum])
+		PRVM_Free((char *)prog->openfiles_origin[filenum]);
 	if (developer.integer >= 100)
 		Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
 }
@@ -1754,6 +2008,155 @@ void VM_writetofile(void)
 	PRVM_ED_Write (file, ent);
 }
 
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_numentityfields
+
+float() numentityfields
+Return the number of entity fields - NOT offsets
+=========
+*/
+void VM_numentityfields(void)
+{
+	PRVM_G_FLOAT(OFS_RETURN) = prog->progs->numfielddefs;
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_entityfieldname
+
+string(float fieldnum) entityfieldname
+Return name of the specified field as a string, or empty if the field is invalid (warning)
+=========
+*/
+void VM_entityfieldname(void)
+{
+	ddef_t *d;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+	
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+        VM_Warning("VM_entityfieldname: %s: field index out of bounds\n", PRVM_NAME);
+        PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+	
+	d = &prog->fielddefs[i];
+	PRVM_G_INT(OFS_RETURN) = d->s_name; // presuming that s_name points to a string already
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_entityfieldtype
+
+float(float fieldnum) entityfieldtype
+=========
+*/
+void VM_entityfieldtype(void)
+{
+	ddef_t *d;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+	
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+		VM_Warning("VM_entityfieldtype: %s: field index out of bounds\n", PRVM_NAME);
+		PRVM_G_FLOAT(OFS_RETURN) = -1.0;
+		return;
+	}
+	
+	d = &prog->fielddefs[i];
+	PRVM_G_FLOAT(OFS_RETURN) = (float)d->type;
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_getentityfieldstring
+
+string(float fieldnum, entity ent) getentityfieldstring
+=========
+*/
+void VM_getentityfieldstring(void)
+{
+	// put the data into a string
+	ddef_t *d;
+	int type, j;
+	int *v;
+	prvm_edict_t * ent;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+	
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+        VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME);
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+	
+	d = &prog->fielddefs[i];
+	
+	// get the entity
+	ent = PRVM_G_EDICT(OFS_PARM1);
+	if(ent->priv.required->free)
+	{
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+		return;
+	}
+	v = (int *)((char *)ent->fields.vp + d->ofs*4);
+	
+	// if it's 0 or blank, return an empty string
+	type = d->type & ~DEF_SAVEGLOBAL;
+	for (j=0 ; j<prvm_type_size[type] ; j++)
+		if (v[j])
+			break;
+	if (j == prvm_type_size[type])
+	{
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+		
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
+}
+
+// KrimZon - DP_QC_ENTITYDATA
+/*
+=========
+VM_putentityfieldstring
+
+float(float fieldnum, entity ent, string s) putentityfieldstring
+=========
+*/
+void VM_putentityfieldstring(void)
+{
+	ddef_t *d;
+	prvm_edict_t * ent;
+	int i = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	if (i < 0 || i >= prog->progs->numfielddefs)
+	{
+        VM_Warning("VM_entityfielddata: %s: field index out of bounds\n", PRVM_NAME);
+		PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
+		return;
+	}
+
+	d = &prog->fielddefs[i];
+
+	// get the entity
+	ent = PRVM_G_EDICT(OFS_PARM1);
+	if(ent->priv.required->free)
+	{
+		VM_Warning("VM_entityfielddata: %s: entity %i is free !\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
+		PRVM_G_FLOAT(OFS_RETURN) = 0.0f;
+		return;
+	}
+
+	// parse the string into the value
+	PRVM_G_FLOAT(OFS_RETURN) = ( PRVM_ED_ParseEpair(ent, d, PRVM_G_STRING(OFS_PARM2), false) ) ? 1.0f : 0.0f;
+}
+
 /*
 =========
 VM_strlen
@@ -1766,7 +2169,8 @@ void VM_strlen(void)
 {
 	VM_SAFEPARMCOUNT(1,VM_strlen);
 
-	PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0));
+	//PRVM_G_FLOAT(OFS_RETURN) = strlen(PRVM_G_STRING(OFS_PARM0));
+	PRVM_G_FLOAT(OFS_RETURN) = u8_strlen(PRVM_G_STRING(OFS_PARM0));
 }
 
 // DRESK - Decolorized String
@@ -1786,9 +2190,7 @@ void VM_strdecolorize(void)
 	// Prepare Strings
 	VM_SAFEPARMCOUNT(1,VM_strdecolorize);
 	szString = PRVM_G_STRING(OFS_PARM0);
-
 	COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
-
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
 }
 
@@ -1811,7 +2213,8 @@ void VM_strlennocol(void)
 
 	szString = PRVM_G_STRING(OFS_PARM0);
 
-	nCnt = COM_StringLengthNoColors(szString, 0, NULL);
+	//nCnt = COM_StringLengthNoColors(szString, 0, NULL);
+	nCnt = u8_COM_StringLengthNoColors(szString, 0, NULL);
 
 	PRVM_G_FLOAT(OFS_RETURN) = nCnt;
 }
@@ -1891,19 +2294,65 @@ string	substring(string s, float start, float length)
 // returns a section of a string as a tempstring
 void VM_substring(void)
 {
-	int i, start, length;
+	int start, length;
+	int u_slength = 0, u_start;
+	size_t u_length;
 	const char *s;
 	char string[VM_STRINGTEMP_LENGTH];
 
 	VM_SAFEPARMCOUNT(3,VM_substring);
 
+	/*
+	s = PRVM_G_STRING(OFS_PARM0);
+	start = (int)PRVM_G_FLOAT(OFS_PARM1);
+	length = (int)PRVM_G_FLOAT(OFS_PARM2);
+	slength = strlen(s);
+
+	if (start < 0) // FTE_STRINGS feature
+		start += slength;
+	start = bound(0, start, slength);
+
+	if (length < 0) // FTE_STRINGS feature
+		length += slength - start + 1;
+	maxlen = min((int)sizeof(string) - 1, slength - start);
+	length = bound(0, length, maxlen);
+
+	memcpy(string, s + start, length);
+	string[length] = 0;
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+	*/
+	
 	s = PRVM_G_STRING(OFS_PARM0);
 	start = (int)PRVM_G_FLOAT(OFS_PARM1);
 	length = (int)PRVM_G_FLOAT(OFS_PARM2);
-	for (i = 0;i < start && *s;i++, s++);
-	for (i = 0;i < (int)sizeof(string) - 1 && *s && i < length;i++, s++)
-		string[i] = *s;
-	string[i] = 0;
+
+	if (start < 0) // FTE_STRINGS feature
+	{
+		u_slength = u8_strlen(s);
+		start += u_slength;
+		start = bound(0, start, u_slength);
+	}
+
+	if (length < 0) // FTE_STRINGS feature
+	{
+		if (!u_slength) // it's not calculated when it's not needed above
+			u_slength = u8_strlen(s);
+		length += u_slength - start + 1;
+	}
+		
+	// positive start, positive length
+	u_start = u8_byteofs(s, start, NULL);
+	if (u_start < 0)
+	{
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+		return;
+	}
+	u_length = u8_bytelen(s + u_start, length);
+	if (u_length >= sizeof(string)-1)
+		u_length = sizeof(string)-1;
+	
+	memcpy(string, s + u_start, u_length);
+	string[u_length] = 0;
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
 }
 
@@ -2101,24 +2550,67 @@ float tokenize(string s)
 //float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
 //this function originally written by KrimZon, made shorter by LordHavoc
 //20040203: rewritten by LordHavoc (no longer uses allocations)
-int num_tokens = 0;
-int tokens[256];
+static int num_tokens = 0;
+static int tokens[VM_STRINGTEMP_LENGTH / 2];
+static int tokens_startpos[VM_STRINGTEMP_LENGTH / 2];
+static int tokens_endpos[VM_STRINGTEMP_LENGTH / 2];
+static char tokenize_string[VM_STRINGTEMP_LENGTH];
 void VM_tokenize (void)
 {
 	const char *p;
-	static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
 
 	VM_SAFEPARMCOUNT(1,VM_tokenize);
 
-	strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
-	p = string;
+	strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+	p = tokenize_string;
+
+	num_tokens = 0;
+	for(;;)
+	{
+		if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
+			break;
+
+		// skip whitespace here to find token start pos
+		while(*p && ISWHITESPACE(*p))
+			++p;
+
+		tokens_startpos[num_tokens] = p - tokenize_string;
+		if(!COM_ParseToken_VM_Tokenize(&p, false))
+			break;
+		tokens_endpos[num_tokens] = p - tokenize_string;
+		tokens[num_tokens] = PRVM_SetTempString(com_token);
+		++num_tokens;
+	}
+
+	PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
+}
+
+//float(string s) tokenize = #514; // takes apart a string into individal words (access them with argv), returns how many
+void VM_tokenize_console (void)
+{
+	const char *p;
+
+	VM_SAFEPARMCOUNT(1,VM_tokenize);
+
+	strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+	p = tokenize_string;
 
 	num_tokens = 0;
-	while(COM_ParseToken_VM_Tokenize(&p, false))
+	for(;;)
 	{
 		if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
 			break;
-		tokens[num_tokens++] = PRVM_SetTempString(com_token);
+
+		// skip whitespace here to find token start pos
+		while(*p && ISWHITESPACE(*p))
+			++p;
+
+		tokens_startpos[num_tokens] = p - tokenize_string;
+		if(!COM_ParseToken_Console(&p))
+			break;
+		tokens_endpos[num_tokens] = p - tokenize_string;
+		tokens[num_tokens] = PRVM_SetTempString(com_token);
+		++num_tokens;
 	}
 
 	PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
@@ -2144,17 +2636,16 @@ void VM_tokenizebyseparator (void)
 	int numseparators;
 	int separatorlen[7];
 	const char *separators[7];
-	const char *p;
+	const char *p, *p0;
 	const char *token;
 	char tokentext[MAX_INPUTLINE];
-	static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
 
 	VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
 
-	strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
-	p = string;
+	strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
+	p = tokenize_string;
 
-	numseparators = 0;;
+	numseparators = 0;
 	for (j = 1;j < prog->argc;j++)
 	{
 		// skip any blank separator strings
@@ -2172,6 +2663,8 @@ void VM_tokenizebyseparator (void)
 	while (num_tokens < (int)(sizeof(tokens)/sizeof(tokens[0])))
 	{
 		token = tokentext + j;
+		tokens_startpos[num_tokens] = p - tokenize_string;
+		p0 = p;
 		while (*p)
 		{
 			for (k = 0;k < numseparators;k++)
@@ -2187,7 +2680,9 @@ void VM_tokenizebyseparator (void)
 			if (j < (int)sizeof(tokentext)-1)
 				tokentext[j++] = *p;
 			p++;
+			p0 = p;
 		}
+		tokens_endpos[num_tokens] = p0 - tokenize_string;
 		if (j >= (int)sizeof(tokentext))
 			break;
 		tokentext[j++] = 0;
@@ -2209,12 +2704,51 @@ void VM_argv (void)
 
 	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
 
+	if(token_num < 0)
+		token_num += num_tokens;
+
 	if (token_num >= 0 && token_num < num_tokens)
 		PRVM_G_INT(OFS_RETURN) = tokens[token_num];
 	else
 		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
 }
 
+//float(float n) argv_start_index = #515; // returns the start index of a token
+void VM_argv_start_index (void)
+{
+	int token_num;
+
+	VM_SAFEPARMCOUNT(1,VM_argv);
+
+	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	if(token_num < 0)
+		token_num += num_tokens;
+
+	if (token_num >= 0 && token_num < num_tokens)
+		PRVM_G_FLOAT(OFS_RETURN) = tokens_startpos[token_num];
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = -1;
+}
+
+//float(float n) argv_end_index = #516; // returns the end index of a token
+void VM_argv_end_index (void)
+{
+	int token_num;
+
+	VM_SAFEPARMCOUNT(1,VM_argv);
+
+	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	if(token_num < 0)
+		token_num += num_tokens;
+
+	if (token_num >= 0 && token_num < num_tokens)
+		PRVM_G_FLOAT(OFS_RETURN) = tokens_endpos[token_num];
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = -1;
+}
+
 /*
 =========
 VM_isserver
@@ -2300,38 +2834,54 @@ void VM_getostype(void)
 
 /*
 =========
-VM_getmousepos
+VM_gettime
 
-vector	getmousepos()
+float	gettime(void)
 =========
 */
-void VM_getmousepos(void)
+extern double host_starttime;
+float CDAudio_GetPosition(void);
+void VM_gettime(void)
 {
-	VM_SAFEPARMCOUNT(0,VM_getmousepos);
+	int timer_index;
 
-	if (cl.csqc_wantsmousemove)
-		VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_windowmouse_x * vid_conwidth.integer / vid.width, in_windowmouse_y * vid_conheight.integer / vid.height, 0);
+	VM_SAFEPARMCOUNTRANGE(0,1,VM_gettime);
+
+	if(prog->argc == 0)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+	}
 	else
-		VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_mouse_x * vid_conwidth.integer / vid.width, in_mouse_y * vid_conheight.integer / vid.height, 0);
+	{
+		timer_index = (int) PRVM_G_FLOAT(OFS_PARM0);
+        switch(timer_index)
+        {
+            case 0: // GETTIME_FRAMESTART
+                PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+                break;
+            case 1: // GETTIME_REALTIME
+                PRVM_G_FLOAT(OFS_RETURN) = (float) Sys_DoubleTime();
+                break;
+            case 2: // GETTIME_HIRES
+                PRVM_G_FLOAT(OFS_RETURN) = (float) (Sys_DoubleTime() - realtime);
+                break;
+            case 3: // GETTIME_UPTIME
+                PRVM_G_FLOAT(OFS_RETURN) = (float) (Sys_DoubleTime() - host_starttime);
+                break;
+            case 4: // GETTIME_CDTRACK
+                PRVM_G_FLOAT(OFS_RETURN) = (float) CDAudio_GetPosition();
+                break;
+			default:
+				VM_Warning("VM_gettime: %s: unsupported timer specified, returning realtime\n", PRVM_NAME);
+				PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
+				break;
+		}
+	}
 }
 
 /*
 =========
-VM_gettime
-
-float	gettime(void)
-=========
-*/
-void VM_gettime(void)
-{
-	VM_SAFEPARMCOUNT(0,VM_gettime);
-
-	PRVM_G_FLOAT(OFS_RETURN) = (float) realtime;
-}
-
-/*
-=========
-VM_loadfromdata
+VM_loadfromdata
 
 loadfromdata(string data)
 =========
@@ -2478,7 +3028,10 @@ void VM_search_begin(void)
 	if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
 	else
+	{
+		prog->opensearches_origin[handle] = PRVM_AllocationOrigin();
 		PRVM_G_FLOAT(OFS_RETURN) = handle;
+	}
 }
 
 /*
@@ -2508,6 +3061,8 @@ void VM_search_end(void)
 
 	FS_FreeSearch(prog->opensearches[handle]);
 	prog->opensearches[handle] = NULL;
+	if(prog->opensearches_origin[handle])
+		PRVM_Free((char *)prog->opensearches_origin[handle]);
 }
 
 /*
@@ -2581,6 +3136,7 @@ string	chr(float ascii)
 */
 void VM_chr(void)
 {
+	/*
 	char tmp[2];
 	VM_SAFEPARMCOUNT(1, VM_chr);
 
@@ -2588,6 +3144,17 @@ void VM_chr(void)
 	tmp[1] = 0;
 
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp);
+	*/
+	
+	char tmp[8];
+	int len;
+	VM_SAFEPARMCOUNT(1, VM_chr);
+
+	len = u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0), tmp, sizeof(tmp));
+	if (len < 0)
+		len = 0;
+	tmp[len] = 0;
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(tmp);
 }
 
 //=============================================================================
@@ -2649,11 +3216,26 @@ void VM_freepic(void)
 	Draw_FreePic(s);
 }
 
-dp_font_t *getdrawfont()
+void getdrawfontscale(float *sx, float *sy)
+{
+	vec3_t v;
+	*sx = *sy = 1;
+	if(prog->globaloffsets.drawfontscale >= 0)
+	{
+		VectorCopy(PRVM_G_VECTOR(prog->globaloffsets.drawfontscale), v);
+		if(VectorLength2(v) > 0)
+		{
+			*sx = v[0];
+			*sy = v[1];
+		}
+	}
+}
+
+dp_font_t *getdrawfont(void)
 {
 	if(prog->globaloffsets.drawfont >= 0)
 	{
-		int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+		int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
 		if(f < 0 || f >= MAX_FONTS)
 			return FONT_DEFAULT;
 		return &dp_fonts[f];
@@ -2674,6 +3256,7 @@ void VM_drawcharacter(void)
 	float *pos,*scale,*rgb;
 	char   character;
 	int flag;
+	float sx, sy;
 	VM_SAFEPARMCOUNT(6,VM_drawcharacter);
 
 	character = (char) PRVM_G_FLOAT(OFS_PARM1);
@@ -2706,7 +3289,8 @@ void VM_drawcharacter(void)
 		return;
 	}
 
-	DrawQ_String_Font(pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
+	getdrawfontscale(&sx, &sy);
+	DrawQ_String_Font_Scale(pos[0], pos[1], &character, 1, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
@@ -2722,6 +3306,7 @@ void VM_drawstring(void)
 	float *pos,*scale,*rgb;
 	const char  *string;
 	int flag;
+	float sx, sy;
 	VM_SAFEPARMCOUNT(6,VM_drawstring);
 
 	string = PRVM_G_STRING(OFS_PARM1);
@@ -2747,7 +3332,9 @@ void VM_drawstring(void)
 	if(pos[2] || scale[2])
 		Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
 
-	DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
+	getdrawfontscale(&sx, &sy);
+	DrawQ_String_Font_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
+	//Font_DrawString(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
@@ -2763,12 +3350,13 @@ void VM_drawcolorcodedstring(void)
 	float *pos,*scale;
 	const char  *string;
 	int flag,color;
+	float sx, sy;
 	VM_SAFEPARMCOUNT(5,VM_drawstring);
 
 	string = PRVM_G_STRING(OFS_PARM1);
 	pos = PRVM_G_VECTOR(OFS_PARM0);
 	scale = PRVM_G_VECTOR(OFS_PARM2);
-	flag = (int)PRVM_G_FLOAT(OFS_PARM5);
+	flag = (int)PRVM_G_FLOAT(OFS_PARM4);
 
 	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
 	{
@@ -2788,26 +3376,61 @@ void VM_drawcolorcodedstring(void)
 		Con_Printf("VM_drawcolorcodedstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
 
 	color = -1;
-	DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont());
+	getdrawfontscale(&sx, &sy);
+	DrawQ_String_Font_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont());
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 /*
 =========
 VM_stringwidth
 
-float	stringwidth(string text, float allowColorCodes)
+float	stringwidth(string text, float allowColorCodes, float size)
 =========
 */
 void VM_stringwidth(void)
 {
 	const char  *string;
+	float *szv;
+	float mult; // sz is intended font size so we can later add freetype support, mult is font size multiplier in pixels per character cell
 	int colors;
-	VM_SAFEPARMCOUNT(2,VM_drawstring);
+	float sx, sy;
+	size_t maxlen = 0;
+	VM_SAFEPARMCOUNTRANGE(2,3,VM_drawstring);
+
+	if(prog->argc == 3)
+	{
+		szv = PRVM_G_VECTOR(OFS_PARM2);
+		mult = 1;
+	}
+	else
+	{
+		static float defsize[] = {0, 0};
+		szv = defsize;
+		mult = 1;
+	}
+	getdrawfontscale(&sx, &sy);
+
+	string = PRVM_G_STRING(OFS_PARM0);
+	colors = (int)PRVM_G_FLOAT(OFS_PARM1);
+
+	PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font_UntilWidth_TrackColors_Size_Scale(string, szv[0], szv[1], sx, sy, &maxlen, NULL, !colors, getdrawfont(), 1000000000) * mult; // 1x1 characters, don't actually draw
+/*
+	if(prog->argc == 3)
+	{
+		mult = sz = PRVM_G_FLOAT(OFS_PARM2);
+	}
+	else
+	{
+		sz = 8;
+		mult = 1;
+	}
 
 	string = PRVM_G_STRING(OFS_PARM0);
 	colors = (int)PRVM_G_FLOAT(OFS_PARM1);
 
-	PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()); // 1x1 characters, don't actually draw
+	PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth_Font(string, 0, !colors, getdrawfont()) * mult; // 1x1 characters, don't actually draw
+*/
+
 }
 /*
 =========
@@ -2855,6 +3478,51 @@ void VM_drawpic(void)
 }
 /*
 =========
+VM_drawrotpic
+
+float	drawrotpic(vector position, string pic, vector size, vector org, float angle, vector rgb, float alpha, float flag)
+=========
+*/
+void VM_drawrotpic(void)
+{
+	const char *picname;
+	float *size, *pos, *org, *rgb;
+	int flag;
+
+	VM_SAFEPARMCOUNT(8,VM_drawrotpic);
+
+	picname = PRVM_G_STRING(OFS_PARM1);
+	VM_CheckEmptyString (picname);
+
+	// is pic cached ? no function yet for that
+	if(!1)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = -4;
+		VM_Warning("VM_drawrotpic: %s: %s not cached !\n", PRVM_NAME, picname);
+		return;
+	}
+
+	pos = PRVM_G_VECTOR(OFS_PARM0);
+	size = PRVM_G_VECTOR(OFS_PARM2);
+	org = PRVM_G_VECTOR(OFS_PARM3);
+	rgb = PRVM_G_VECTOR(OFS_PARM5);
+	flag = (int) PRVM_G_FLOAT(OFS_PARM7);
+
+	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_drawrotpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
+		return;
+	}
+
+	if(pos[2] || size[2] || org[2])
+		Con_Printf("VM_drawrotpic: z value from pos/size/org discarded\n");
+
+	DrawQ_RotPic(pos[0], pos[1], Draw_CachePic(picname), size[0], size[1], org[0], org[1], PRVM_G_FLOAT(OFS_PARM4), rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM6), flag);
+	PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+/*
+=========
 VM_drawsubpic
 
 float	drawsubpic(vector position, vector size, string pic, vector srcPos, vector srcSize, vector rgb, float alpha, float flag)
@@ -3014,6 +3682,40 @@ void VM_keynumtostring (void)
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_KeynumToString((int)PRVM_G_FLOAT(OFS_PARM0)));
 }
 
+/*
+=========
+VM_findkeysforcommand
+
+string	findkeysforcommand(string command)
+
+the returned string is an altstring
+=========
+*/
+#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
+
+void M_FindKeysForCommand(const char *command, int *keys);
+void VM_findkeysforcommand(void)
+{
+	const char *cmd;
+	char ret[VM_STRINGTEMP_LENGTH];
+	int keys[NUMKEYS];
+	int i;
+
+	VM_SAFEPARMCOUNT(1, VM_findkeysforcommand);
+
+	cmd = PRVM_G_STRING(OFS_PARM0);
+
+	VM_CheckEmptyString(cmd);
+
+	M_FindKeysForCommand(cmd, keys);
+
+	ret[0] = 0;
+	for(i = 0; i < NUMKEYS; i++)
+		strlcat(ret, va(" \'%i\'", keys[i]), sizeof(ret));
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(ret);
+}
+
 /*
 =========
 VM_stringtokeynum
@@ -3300,7 +4002,7 @@ void VM_gecko_keyevent( void ) {
 		return;
 	}
 
-	PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
+	PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, (keynum_t) key, eventtype ) == true);
 }
 
 /*
@@ -3353,7 +4055,7 @@ void VM_gecko_resize( void ) {
 	if( !instance ) {
 		return;
 	}
-	CL_Gecko_Resize( instance, w, h );
+	CL_Gecko_Resize( instance, (int) w, (int) h );
 }
 
 
@@ -3462,7 +4164,7 @@ void VM_bitshift (void)
 	int n1, n2;
 	VM_SAFEPARMCOUNT(2, VM_bitshift);
 
-	n1 = (int)fabs((int)PRVM_G_FLOAT(OFS_PARM0));
+	n1 = (int)fabs((float)((int)PRVM_G_FLOAT(OFS_PARM0)));
 	n2 = (int)PRVM_G_FLOAT(OFS_PARM1);
 	if(!n1)
 		PRVM_G_FLOAT(OFS_RETURN) = n1;
@@ -3686,7 +4388,7 @@ static void BufStr_Expand(prvm_stringbuffer_t *stringbuffer, int strindex)
 		stringbuffer->max_strings = max(stringbuffer->max_strings * 2, 128);
 		while (stringbuffer->max_strings <= strindex)
 			stringbuffer->max_strings *= 2;
-		stringbuffer->strings = Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
+		stringbuffer->strings = (char **) Mem_Alloc(prog->progs_mempool, stringbuffer->max_strings * sizeof(stringbuffer->strings[0]));
 		if (stringbuffer->num_strings > 0)
 			memcpy(stringbuffer->strings, oldstrings, stringbuffer->num_strings * sizeof(stringbuffer->strings[0]));
 		if (oldstrings)
@@ -3742,8 +4444,9 @@ void VM_buf_create (void)
 	prvm_stringbuffer_t *stringbuffer;
 	int i;
 	VM_SAFEPARMCOUNT(0, VM_buf_create);
-	stringbuffer = Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
+	stringbuffer = (prvm_stringbuffer_t *) Mem_ExpandableArray_AllocRecord(&prog->stringbuffersarray);
 	for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
+	stringbuffer->origin = PRVM_AllocationOrigin();
 	PRVM_G_FLOAT(OFS_RETURN) = i;
 }
 
@@ -3767,6 +4470,8 @@ void VM_buf_del (void)
 				Mem_Free(stringbuffer->strings[i]);
 		if (stringbuffer->strings)
 			Mem_Free(stringbuffer->strings);
+		if(stringbuffer->origin)
+			PRVM_Free((char *)stringbuffer->origin);
 		Mem_ExpandableArray_FreeRecord(&prog->stringbuffersarray, stringbuffer);
 	}
 	else
@@ -4089,6 +4794,91 @@ void VM_bufstr_free (void)
 	BufStr_Shrink(stringbuffer);
 }
 
+
+
+
+
+
+
+void VM_buf_cvarlist(void)
+{
+	cvar_t *cvar;
+	const char *partial, *antipartial;
+	size_t len, antilen;
+	size_t alloclen;
+	qboolean ispattern, antiispattern;
+	int n;
+	prvm_stringbuffer_t	*stringbuffer;
+	VM_SAFEPARMCOUNTRANGE(2, 3, VM_buf_cvarlist);
+
+	stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, (int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!stringbuffer)
+	{
+		VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+
+	partial = PRVM_G_STRING(OFS_PARM1);
+	if(!partial)
+		len = 0;
+	else
+		len = strlen(partial);
+
+	if(prog->argc == 3)
+		antipartial = PRVM_G_STRING(OFS_PARM2);
+	else
+		antipartial = NULL;
+	if(!antipartial)
+		antilen = 0;
+	else
+		antilen = strlen(antipartial);
+	
+	for (n = 0;n < stringbuffer->num_strings;n++)
+		if (stringbuffer->strings[n])
+			Mem_Free(stringbuffer->strings[n]);
+	if (stringbuffer->strings)
+		Mem_Free(stringbuffer->strings);
+	stringbuffer->strings = NULL;
+
+	ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
+	antiispattern = antipartial && (strchr(antipartial, '*') || strchr(antipartial, '?'));
+
+	n = 0;
+	for(cvar = cvar_vars; cvar; cvar = cvar->next)
+	{
+		if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
+			continue;
+
+		if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
+			continue;
+
+		++n;
+	}
+
+	stringbuffer->max_strings = stringbuffer->num_strings = n;
+	if (stringbuffer->max_strings)
+		stringbuffer->strings = (char **)Mem_Alloc(prog->progs_mempool, sizeof(stringbuffer->strings[0]) * stringbuffer->max_strings);
+	
+	n = 0;
+	for(cvar = cvar_vars; cvar; cvar = cvar->next)
+	{
+		if(len && (ispattern ? !matchpattern_with_separator(cvar->name, partial, false, "", false) : strncmp(partial, cvar->name, len)))
+			continue;
+
+		if(antilen && (antiispattern ? matchpattern_with_separator(cvar->name, antipartial, false, "", false) : !strncmp(antipartial, cvar->name, antilen)))
+			continue;
+
+		alloclen = strlen(cvar->name) + 1;
+		stringbuffer->strings[n] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
+		memcpy(stringbuffer->strings[n], cvar->name, alloclen);
+
+		++n;
+	}
+}
+
+
+
+
 //=============
 
 /*
@@ -4213,50 +5003,18 @@ void VM_changepitch (void)
 	PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0] = ANGLEMOD (current + move);
 }
 
-// TODO: adapt all static function names to use a single naming convention... [12/3/2007 Black]
-static int Is_Text_Color (char c, char t)
-{
-	int a = 0;
-	char c2 = c - (c & 128);
-	char t2 = t - (t & 128);
-
-	if(c != STRING_COLOR_TAG && c2 != STRING_COLOR_TAG)		return 0;
-	if(t >= '0' && t <= '9')		a = 1;
-	if(t2 >= '0' && t2 <= '9')		a = 1;
-/*	if(t >= 'A' && t <= 'Z')		a = 2;
-	if(t2 >= 'A' && t2 <= 'Z')		a = 2;
-
-	if(a == 1 && scr_colortext.integer > 0)
-		return 1;
-	if(a == 2 && scr_multifonts.integer > 0)
-		return 2;
-*/
-	return a;
-}
 
 void VM_uncolorstring (void)
 {
-	const char	*in;
-	char		out[VM_STRINGTEMP_LENGTH];
-	int			k = 0, i = 0;
+	char szNewString[VM_STRINGTEMP_LENGTH];
+	const char *szString;
 
+	// Prepare Strings
 	VM_SAFEPARMCOUNT(1, VM_uncolorstring);
-	in = PRVM_G_STRING(OFS_PARM0);
-	VM_CheckEmptyString (in);
-
-	while (in[k])
-	{
-		if(in[k+1])
-		if(Is_Text_Color(in[k], in[k+1]) == 1/* || (in[k] == '&' && in[k+1] == 'r')*/)
-		{
-			k += 2;
-			continue;
-		}
-		out[i] = in[k];
-		++k;
-		++i;
-	}
-	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(out);
+	szString = PRVM_G_STRING(OFS_PARM0);
+	COM_StringDecolorize(szString, 0, szNewString, sizeof(szNewString), TRUE);
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(szNewString);
+	
 }
 
 // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
@@ -4268,7 +5026,8 @@ void VM_strstrofs (void)
 	VM_SAFEPARMCOUNTRANGE(2, 3, VM_strstrofs);
 	instr = PRVM_G_STRING(OFS_PARM0);
 	match = PRVM_G_STRING(OFS_PARM1);
-	firstofs = (prog->argc > 2)?PRVM_G_FLOAT(OFS_PARM2):0;
+	firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
+	firstofs = u8_bytelen(instr, firstofs);
 
 	if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
 	{
@@ -4287,10 +5046,17 @@ void VM_strstrofs (void)
 void VM_str2chr (void)
 {
 	const char *s;
+	Uchar ch;
+	int index;
 	VM_SAFEPARMCOUNT(2, VM_str2chr);
 	s = PRVM_G_STRING(OFS_PARM0);
-	if((unsigned)PRVM_G_FLOAT(OFS_PARM1) < strlen(s))
-		PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(unsigned)PRVM_G_FLOAT(OFS_PARM1)];
+	index = u8_bytelen(s, (int)PRVM_G_FLOAT(OFS_PARM1));
+
+	if((unsigned)index < strlen(s))
+	{
+		ch = u8_getchar(s + index, NULL);
+		PRVM_G_FLOAT(OFS_RETURN) = ch;
+	}
 	else
 		PRVM_G_FLOAT(OFS_RETURN) = 0;
 }
@@ -4298,6 +5064,7 @@ void VM_str2chr (void)
 //#223 string(float c, ...) chr2str (FTE_STRINGS)
 void VM_chr2str (void)
 {
+	/*
 	char	t[9];
 	int		i;
 	VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str);
@@ -4305,6 +5072,19 @@ void VM_chr2str (void)
 		t[i] = (unsigned char)PRVM_G_FLOAT(OFS_PARM0+i*3);
 	t[i] = 0;
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
+	*/
+	char t[9 * 4 + 1];
+	int i;
+	size_t len = 0;
+	VM_SAFEPARMCOUNTRANGE(0, 8, VM_chr2str);
+	for(i = 0; i < prog->argc && len < sizeof(t)-1; ++i)
+	{
+		int add = u8_fromchar((Uchar)PRVM_G_FLOAT(OFS_PARM0+i*3), t + len, sizeof(t)-1);
+		if(add > 0)
+			len += add;
+	}
+	t[len] = 0;
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
 }
 
 static int chrconv_number(int i, int base, int conv)
@@ -4397,9 +5177,9 @@ void VM_strconv (void)
 
 	VM_SAFEPARMCOUNTRANGE(3, 8, VM_strconv);
 
-	ccase = PRVM_G_FLOAT(OFS_PARM0);	//0 same, 1 lower, 2 upper
-	redalpha = PRVM_G_FLOAT(OFS_PARM1);	//0 same, 1 white, 2 red,  5 alternate, 6 alternate-alternate
-	rednum = PRVM_G_FLOAT(OFS_PARM2);	//0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
+	ccase = (int) PRVM_G_FLOAT(OFS_PARM0);	//0 same, 1 lower, 2 upper
+	redalpha = (int) PRVM_G_FLOAT(OFS_PARM1);	//0 same, 1 white, 2 red,  5 alternate, 6 alternate-alternate
+	rednum = (int) PRVM_G_FLOAT(OFS_PARM2);	//0 same, 1 white, 2 red, 3 redspecial, 4 whitespecial, 5 alternate, 6 alternate-alternate
 	VM_VarString(3, (char *) resbuf, sizeof(resbuf));
 	len = strlen((char *) resbuf);
 
@@ -4442,7 +5222,7 @@ void VM_strpad (void)
 	char destbuf[VM_STRINGTEMP_LENGTH];
 	int pad;
 	VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
-	pad = PRVM_G_FLOAT(OFS_PARM0);
+	pad = (int) PRVM_G_FLOAT(OFS_PARM0);
 	VM_VarString(1, src, sizeof(src));
 
 	// note: < 0 = left padding, > 0 = right padding,
@@ -4573,6 +5353,38 @@ void VM_SetTraceGlobals(const trace_t *trace)
 		val->string = trace->hittexture ? PRVM_SetTempString(trace->hittexture->name) : 0;
 }
 
+void VM_ClearTraceGlobals(void)
+{
+	// clean up all trace globals when leaving the VM (anti-triggerbot safeguard)
+	prvm_eval_t *val;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_allsolid)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_startsolid)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_fraction)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_inwater)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_inopen)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_endpos)))
+		VectorClear(val->vector);
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_plane_normal)))
+		VectorClear(val->vector);
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_plane_dist)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_ent)))
+		val->edict = PRVM_EDICT_TO_PROG(prog->edicts);
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dpstartcontents)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitcontents)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphitq3surfaceflags)))
+		val->_float = 0;
+	if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_dphittexturename)))
+		val->string = 0;
+}
+
 //=============
 
 void VM_Cmd_Init(void)
@@ -4673,3 +5485,468 @@ nohex:
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(dest);
 }
 
+// #502 string(string filename) whichpack (DP_QC_WHICHPACK)
+// returns the name of the pack containing a file, or "" if it is not in any pack (but local or non-existant)
+void VM_whichpack (void)
+{
+	const char *fn, *pack;
+
+	VM_SAFEPARMCOUNT(1, VM_whichpack);
+	fn = PRVM_G_STRING(OFS_PARM0);
+	pack = FS_WhichPack(fn);
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(pack ? pack : "");
+}
+
+typedef struct
+{
+	int prognr;
+	double starttime;
+	float id;
+	char buffer[MAX_INPUTLINE];
+}
+uri_to_prog_t;
+
+static void uri_to_string_callback(int status, size_t length_received, unsigned char *buffer, void *cbdata)
+{
+	uri_to_prog_t *handle = (uri_to_prog_t *) cbdata;
+
+	if(!PRVM_ProgLoaded(handle->prognr))
+	{
+		// curl reply came too late... so just drop it
+		Z_Free(handle);
+		return;
+	}
+		
+	PRVM_SetProg(handle->prognr);
+	PRVM_Begin;
+		if((prog->starttime == handle->starttime) && (prog->funcoffsets.URI_Get_Callback))
+		{
+			if(length_received >= sizeof(handle->buffer))
+				length_received = sizeof(handle->buffer) - 1;
+			handle->buffer[length_received] = 0;
+		
+			PRVM_G_FLOAT(OFS_PARM0) = handle->id;
+			PRVM_G_FLOAT(OFS_PARM1) = status;
+			PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(handle->buffer);
+			PRVM_ExecuteProgram(prog->funcoffsets.URI_Get_Callback, "QC function URI_Get_Callback is missing");
+		}
+	PRVM_End;
+	
+	Z_Free(handle);
+}
+
+// uri_get() gets content from an URL and calls a callback "uri_get_callback" with it set as string; an unique ID of the transfer is returned
+// returns 1 on success, and then calls the callback with the ID, 0 or the HTTP status code, and the received data in a string
+void VM_uri_get (void)
+{
+	const char *url;
+	float id;
+	qboolean ret;
+	uri_to_prog_t *handle;
+
+	if(!prog->funcoffsets.URI_Get_Callback)
+		PRVM_ERROR("uri_get called by %s without URI_Get_Callback defined", PRVM_NAME);
+
+	VM_SAFEPARMCOUNT(2, VM_uri_get);
+
+	url = PRVM_G_STRING(OFS_PARM0);
+	id = PRVM_G_FLOAT(OFS_PARM1);
+	handle = (uri_to_prog_t *) Z_Malloc(sizeof(*handle)); // this can't be the prog's mem pool, as curl may call the callback later!
+
+	handle->prognr = PRVM_GetProgNr();
+	handle->starttime = prog->starttime;
+	handle->id = id;
+	ret = Curl_Begin_ToMemory(url, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
+	if(ret)
+	{
+		PRVM_G_INT(OFS_RETURN) = 1;
+	}
+	else
+	{
+		Z_Free(handle);
+		PRVM_G_INT(OFS_RETURN) = 0;
+	}
+}
+
+void VM_netaddress_resolve (void)
+{
+	const char *ip;
+	char normalized[128];
+	int port;
+	lhnetaddress_t addr;
+
+	VM_SAFEPARMCOUNTRANGE(1, 2, VM_netaddress_resolve);
+
+	ip = PRVM_G_STRING(OFS_PARM0);
+	port = 0;
+	if(prog->argc > 1)
+		port = (int) PRVM_G_FLOAT(OFS_PARM1);
+
+	if(LHNETADDRESS_FromString(&addr, ip, port) && LHNETADDRESS_ToString(&addr, normalized, sizeof(normalized), prog->argc > 1))
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(normalized);
+	else
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString("");
+}
+
+//string(void) getextresponse = #624; // returns the next extResponse packet that was sent to this client
+void VM_CL_getextresponse (void)
+{
+	VM_SAFEPARMCOUNT(0,VM_argv);
+
+	if (cl_net_extresponse_count <= 0)
+		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+	else
+	{
+		int first;
+		--cl_net_extresponse_count;
+		first = (cl_net_extresponse_last + NET_EXTRESPONSE_MAX - cl_net_extresponse_count) % NET_EXTRESPONSE_MAX;
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(cl_net_extresponse[first]);
+	}
+}
+
+void VM_SV_getextresponse (void)
+{
+	VM_SAFEPARMCOUNT(0,VM_argv);
+
+	if (sv_net_extresponse_count <= 0)
+		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
+	else
+	{
+		int first;
+		--sv_net_extresponse_count;
+		first = (sv_net_extresponse_last + NET_EXTRESPONSE_MAX - sv_net_extresponse_count) % NET_EXTRESPONSE_MAX;
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(sv_net_extresponse[first]);
+	}
+}
+
+/*
+=========
+VM_M_callfunction
+
+	callfunction(...,string function_name)
+Extension: pass
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_callfunction(void)
+{
+	mfunction_t *func;
+	const char *s;
+
+	VM_SAFEPARMCOUNTRANGE(1, 8, VM_callfunction);
+
+	s = PRVM_G_STRING(OFS_PARM0+(prog->argc - 1)*3);
+
+	VM_CheckEmptyString(s);
+
+	func = PRVM_ED_FindFunction(s);
+
+	if(!func)
+		PRVM_ERROR("VM_callfunciton: function %s not found !", s);
+	else if (func->first_statement < 0)
+	{
+		// negative statements are built in functions
+		int builtinnumber = -func->first_statement;
+		prog->xfunction->builtinsprofile++;
+		if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
+			prog->builtins[builtinnumber]();
+		else
+			PRVM_ERROR("No such builtin #%i in %s; most likely cause: outdated engine build. Try updating!", builtinnumber, PRVM_NAME);
+	}
+	else if(func - prog->functions > 0)
+	{
+		prog->argc--;
+		PRVM_ExecuteProgram(func - prog->functions,"");
+		prog->argc++;
+	}
+}
+
+/*
+=========
+VM_isfunction
+
+float	isfunction(string function_name)
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_isfunction(void)
+{
+	mfunction_t *func;
+	const char *s;
+
+	VM_SAFEPARMCOUNT(1, VM_isfunction);
+
+	s = PRVM_G_STRING(OFS_PARM0);
+
+	VM_CheckEmptyString(s);
+
+	func = PRVM_ED_FindFunction(s);
+
+	if(!func)
+		PRVM_G_FLOAT(OFS_RETURN) = false;
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = true;
+}
+
+/*
+=========
+VM_sprintf
+
+string sprintf(string format, ...)
+=========
+*/
+
+void VM_sprintf(void)
+{
+	const char *s, *s0;
+	char outbuf[MAX_INPUTLINE];
+	char *o = outbuf, *end = outbuf + sizeof(outbuf), *err;
+	int argpos = 1;
+	int width, precision, thisarg, flags;
+	char formatbuf[16];
+	char *f;
+	qboolean isfloat;
+#define PRINTF_ALTERNATE 1
+#define PRINTF_ZEROPAD 2
+#define PRINTF_LEFT 4
+#define PRINTF_SPACEPOSITIVE 8
+#define PRINTF_SIGNPOSITIVE 16
+
+	formatbuf[0] = '%';
+
+	s = PRVM_G_STRING(OFS_PARM0);
+
+#define GETARG_FLOAT(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_FLOAT(OFS_PARM0 + 3 * (a))) : 0)
+#define GETARG_INT(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_INT(OFS_PARM0 + 3 * (a))) : 0)
+#define GETARG_STRING(a) (((a)>=1 && (a)<prog->argc) ? (PRVM_G_STRING(OFS_PARM0 + 3 * (a))) : "")
+
+	for(;;)
+	{
+		s0 = s;
+		switch(*s)
+		{
+			case 0:
+				goto finished;
+				break;
+			case '%':
+				++s;
+
+				if(*s == '%')
+					goto verbatim;
+
+				// complete directive format:
+				// %3$*1$.*2$ld
+				
+				width = -1;
+				precision = -1;
+				thisarg = -1;
+				flags = 0;
+
+				// is number following?
+				if(*s >= '0' && *s <= '9')
+				{
+					width = strtol(s, &err, 10);
+					if(!err)
+					{
+						VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+						goto finished;
+					}
+					if(*err == '$')
+					{
+						thisarg = width;
+						width = -1;
+						s = err + 1;
+					}
+					else
+					{
+						if(*s == '0')
+						{
+							flags |= PRINTF_ZEROPAD;
+							if(width == 0)
+								width = -1; // it was just a flag
+						}
+						s = err;
+					}
+				}
+
+				if(width < 0)
+				{
+					for(;;)
+					{
+						switch(*s)
+						{
+							case '#': flags |= PRINTF_ALTERNATE; break;
+							case '0': flags |= PRINTF_ZEROPAD; break;
+							case '-': flags |= PRINTF_LEFT; break;
+							case ' ': flags |= PRINTF_SPACEPOSITIVE; break;
+							case '+': flags |= PRINTF_SIGNPOSITIVE; break;
+							default:
+								goto noflags;
+						}
+						++s;
+					}
+noflags:
+					if(*s == '*')
+					{
+						++s;
+						if(*s >= '0' && *s <= '9')
+						{
+							width = strtol(s, &err, 10);
+							if(!err || *err != '$')
+							{
+								VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+								goto finished;
+							}
+							s = err + 1;
+						}
+						else
+							width = argpos++;
+						width = GETARG_FLOAT(width);
+					}
+					else if(*s >= '0' && *s <= '9')
+					{
+						width = strtol(s, &err, 10);
+						if(!err)
+						{
+							VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+							goto finished;
+						}
+						s = err;
+					}
+					if(width < 0)
+					{
+						flags |= PRINTF_LEFT;
+						width = -width;
+					}
+				}
+
+				if(*s == '.')
+				{
+					++s;
+					if(*s == '*')
+					{
+						++s;
+						if(*s >= '0' && *s <= '9')
+						{
+							precision = strtol(s, &err, 10);
+							if(!err || *err != '$')
+							{
+								VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+								goto finished;
+							}
+							s = err + 1;
+						}
+						else
+							precision = argpos++;
+						precision = GETARG_FLOAT(precision);
+					}
+					else if(*s >= '0' && *s <= '9')
+					{
+						precision = strtol(s, &err, 10);
+						if(!err)
+						{
+							VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+							goto finished;
+						}
+						s = err;
+					}
+					else
+					{
+						VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+						goto finished;
+					}
+				}
+
+				isfloat = true;
+				for(;;)
+				{
+					switch(*s)
+					{
+						case 'h': isfloat = true; break;
+						case 'l': isfloat = false; break;
+						case 'L': isfloat = false; break;
+						case 'j': break;
+						case 'z': break;
+						case 't': break;
+						default:
+							goto nolength;
+					}
+					++s;
+				}
+nolength:
+
+				if(thisarg < 0)
+					thisarg = argpos++;
+
+				if(o < end - 1)
+				{
+					f = &formatbuf[1];
+					if(*s != 's' && *s != 'c')
+						if(flags & PRINTF_ALTERNATE) *f++ = '#';
+					if(flags & PRINTF_ZEROPAD) *f++ = '0';
+					if(flags & PRINTF_LEFT) *f++ = '-';
+					if(flags & PRINTF_SPACEPOSITIVE) *f++ = ' ';
+					if(flags & PRINTF_SIGNPOSITIVE) *f++ = '+';
+					*f++ = '*';
+					*f++ = '.';
+					*f++ = '*';
+					*f++ = *s;
+					*f++ = 0;
+
+					if(width < 0)
+						width = 0;
+
+					switch(*s)
+					{
+						case 'd': case 'i':
+							o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (int) GETARG_FLOAT(thisarg) : (int) GETARG_INT(thisarg)));
+							break;
+						case 'o': case 'u': case 'x': case 'X':
+							o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+							break;
+						case 'e': case 'E': case 'f': case 'F': case 'g': case 'G':
+							if(precision < 0)
+								precision = 6;
+							o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
+							break;
+						case 'c':
+							if(precision < 0)
+								precision = end - o - 1;
+							if(flags & PRINTF_ALTERNATE)
+								o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+							else
+							{
+								unsigned int c = (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg));
+								const char *buf = u8_encodech(c, NULL);
+								if(!buf)
+									buf = "";
+								o += u8_strpad(o, end - o, buf, (flags & PRINTF_LEFT) != 0, width, precision);
+							}
+							break;
+						case 's':
+							if(precision < 0)
+								precision = end - o - 1;
+							if(flags & PRINTF_ALTERNATE)
+								o += dpsnprintf(o, end - o, formatbuf, width, precision, GETARG_STRING(thisarg));
+							else
+								o += u8_strpad(o, end - o, GETARG_STRING(thisarg), (flags & PRINTF_LEFT) != 0, width, precision);
+							break;
+						default:
+							VM_Warning("VM_sprintf: invalid directive in %s: %s\n", PRVM_NAME, s0);
+							goto finished;
+					}
+				}
+				++s;
+				break;
+			default:
+verbatim:
+				if(o < end - 1)
+					*o++ = *s++;
+				break;
+		}
+	}
+finished:
+	*o = 0;
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(outbuf);
+}