X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=prvm_cmds.c;h=e3e1b322dbc1c3bde3c307a4c10a449d886821cc;hb=e86d9d2f088b3ec10cb0ffee10135017844e71f7;hp=c1be177c09848e343e02748396319cbabc23541b;hpb=cf22ff4047c6cac2ee44bb3ecf554ca0f9eed819;p=xonotic%2Fdarkplaces.git

diff --git a/prvm_cmds.c b/prvm_cmds.c
index c1be177c..e3e1b322 100644
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -10,6 +10,8 @@
 #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
@@ -49,6 +51,189 @@ void VM_CheckEmptyString (const char *s)
 		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
 
@@ -1088,7 +1273,7 @@ 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, true))
 	{
@@ -1568,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;
@@ -1978,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
@@ -2021,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;
 }
@@ -2101,12 +2294,15 @@ string	substring(string s, float start, float length)
 // returns a section of a string as a tempstring
 void VM_substring(void)
 {
-	int start, length, slength, maxlen;
+	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);
@@ -2124,6 +2320,40 @@ void VM_substring(void)
 	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);
+
+	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);
 }
 
 /*
@@ -2906,6 +3136,7 @@ string	chr(float ascii)
 */
 void VM_chr(void)
 {
+	/*
 	char tmp[2];
 	VM_SAFEPARMCOUNT(1, VM_chr);
 
@@ -2913,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);
 }
 
 //=============================================================================
@@ -2974,7 +3216,7 @@ void VM_freepic(void)
 	Draw_FreePic(s);
 }
 
-dp_font_t *getdrawfont()
+dp_font_t *getdrawfont(void)
 {
 	if(prog->globaloffsets.drawfont >= 0)
 	{
@@ -3073,6 +3315,7 @@ void VM_drawstring(void)
 		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());
+	//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;
 }
 
@@ -3120,19 +3363,52 @@ void VM_drawcolorcodedstring(void)
 =========
 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 x[200];
+	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;
+	}
+	x[180] = 3;
 
 	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_Size(string, szv[0], szv[1], 0, !colors, getdrawfont()) * 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()) * mult; // 1x1 characters, don't actually draw
+*/
+
 }
 /*
 =========
@@ -3866,7 +4142,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;
@@ -4729,6 +5005,7 @@ void VM_strstrofs (void)
 	instr = PRVM_G_STRING(OFS_PARM0);
 	match = PRVM_G_STRING(OFS_PARM1);
 	firstofs = (prog->argc > 2)?(int)PRVM_G_FLOAT(OFS_PARM2):0;
+	firstofs = u8_bytelen(instr, firstofs);
 
 	if (firstofs && (firstofs < 0 || firstofs > (int)strlen(instr)))
 	{
@@ -4747,10 +5024,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;
 }
@@ -4758,6 +5042,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);
@@ -4765,6 +5050,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)
@@ -5033,6 +5331,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)
@@ -5236,3 +5566,103 @@ void VM_netaddress_resolve (void)
 	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;
+}