X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_cmds.c;h=01386fd8852bf6a4cb7593980a2f0d68e71cf183;hp=490a0c81c46e0507e94b413a62b08d6f97d323a2;hb=a4b2173c8cc9c70725bb032e6165ae4ea8addd3c;hpb=6565597d1fb3cdf77b34f2497e6a0d54c544a9c5

diff --git a/prvm_cmds.c b/prvm_cmds.c
index 490a0c81..01386fd8 100644
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -187,9 +187,14 @@ void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const f
 		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)
+	if (!ed->priv.server->skeleton.model || !ed->priv.server->skeleton.model->num_bones)
+	{
+		if(ed->priv.server->skeleton.relativetransforms)
+			Mem_Free(ed->priv.server->skeleton.relativetransforms);
+		ed->priv.server->skeleton.relativetransforms = NULL;
+		return;
+	}
+
 	{
 		int skeletonindex = -1;
 		skeleton_t *skeleton;
@@ -198,30 +203,15 @@ void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const f
 		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)
+			if (!ed->priv.server->skeleton.relativetransforms)
+				ed->priv.server->skeleton.relativetransforms = (matrix4x4_t *)Mem_Alloc(prog->progs_mempool, ed->priv.server->skeleton.model->num_bones * sizeof(matrix4x4_t));
 			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 short *framebones6s;
-			float lerp;
-			float scale = ed->priv.server->skeleton.model->num_posescale;
-			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;
-				framebones6s = ed->priv.server->skeleton.model->data_poses6s + 6 * frameblend[blendindex].subframe * numbones;
-				for (bonenum = 0;bonenum < numbones;bonenum++)
-				{
-					Matrix4x4_FromBonePose6s(&matrix, scale, framebones6s + 6 * bonenum);
-					Matrix4x4_Accumulate(&ed->priv.server->skeleton.relativetransforms[bonenum], &matrix, lerp);
-				}
-			}
+			if(ed->priv.server->skeleton.relativetransforms)
+				Mem_Free(ed->priv.server->skeleton.relativetransforms);
+			ed->priv.server->skeleton.relativetransforms = NULL;
 		}
 	}
 }
@@ -269,7 +259,7 @@ checkextension(extensionname)
 static qboolean checkextension(const char *name)
 {
 	int len;
-	char *e, *start;
+	const char *e, *start;
 	len = (int)strlen(name);
 
 	for (e = prog->extensionstring;*e;e++)
@@ -282,7 +272,18 @@ static qboolean checkextension(const char *name)
 		while (*e && *e != ' ')
 			e++;
 		if ((e - start) == len && !strncasecmp(start, name, len))
+		{
+			// special sheck for ODE
+			if (!strncasecmp("DP_PHYSICS_ODE", name, 14))
+			{
+#ifdef USEODE
+				return ode_dll ? true : false;
+#else
+				return false;
+#endif
+			}
 			return true;
+		}
 	}
 	return false;
 }
@@ -873,7 +874,7 @@ void VM_ftoe(void)
 	VM_SAFEPARMCOUNT(1, VM_ftoe);
 
 	ent = (int)PRVM_G_FLOAT(OFS_PARM0);
-	if (ent < 0 || ent >= MAX_EDICTS || PRVM_PROG_TO_EDICT(ent)->priv.required->free)
+	if (ent < 0 || ent >= prog->max_edicts || PRVM_PROG_TO_EDICT(ent)->priv.required->free)
 		ent = 0; // return world instead of a free or invalid entity
 
 	PRVM_G_INT(OFS_RETURN) = ent;
@@ -973,12 +974,12 @@ void VM_remove (void)
 	ed = PRVM_G_EDICT(OFS_PARM0);
 	if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
 	{
-		if (developer.integer)
+		if (developer.integer > 0)
 			VM_Warning( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
 	}
 	else if( ed->priv.required->free )
 	{
-		if (developer.integer)
+		if (developer.integer > 0)
 			VM_Warning( "VM_remove: tried to remove an already freed entity!\n" );
 	}
 	else
@@ -3234,7 +3235,7 @@ void VM_precache_pic(void)
 	VM_CheckEmptyString (s);
 
 	// AK Draw_CachePic is supposed to always return a valid pointer
-	if( Draw_CachePic_Flags(s, CACHEPICFLAG_NOTPERSISTENT)->tex == r_texture_notexture )
+	if( Draw_CachePic_Flags(s, 0)->tex == r_texture_notexture )
 		PRVM_G_INT(OFS_RETURN) = OFS_NULL;
 }
 
@@ -3277,9 +3278,9 @@ dp_font_t *getdrawfont(void)
 	if(prog->globaloffsets.drawfont >= 0)
 	{
 		int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
-		if(f < 0 || f >= MAX_FONTS)
+		if(f < 0 || f >= dp_fonts.maxsize)
 			return FONT_DEFAULT;
-		return &dp_fonts[f];
+		return &dp_fonts.f[f];
 	}
 	else
 		return FONT_DEFAULT;
@@ -3384,22 +3385,42 @@ void VM_drawstring(void)
 VM_drawcolorcodedstring
 
 float	drawcolorcodedstring(vector position, string text, vector scale, float alpha, float flag)
+/
+float	drawcolorcodedstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
 =========
 */
 void VM_drawcolorcodedstring(void)
 {
-	float *pos,*scale;
+	float *pos, *scale;
 	const char  *string;
 	int flag;
-	float sx, sy;
-	VM_SAFEPARMCOUNT(5,VM_drawstring);
+	vec3_t rgb;
+	float sx, sy, alpha;
 
-	string = PRVM_G_STRING(OFS_PARM1);
-	pos = PRVM_G_VECTOR(OFS_PARM0);
-	scale = PRVM_G_VECTOR(OFS_PARM2);
-	flag = (int)PRVM_G_FLOAT(OFS_PARM4);
+	VM_SAFEPARMCOUNTRANGE(5,6,VM_drawcolorcodedstring);
 
-	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+	if (prog->argc == 6) // full 6 parms, like normal drawstring
+	{
+		pos = PRVM_G_VECTOR(OFS_PARM0);
+		string = PRVM_G_STRING(OFS_PARM1);
+		scale = PRVM_G_VECTOR(OFS_PARM2);
+		VectorCopy(PRVM_G_VECTOR(OFS_PARM3), rgb); 
+		alpha = PRVM_G_FLOAT(OFS_PARM4);
+		flag = (int)PRVM_G_FLOAT(OFS_PARM5);
+	}
+	else
+	{
+		pos = PRVM_G_VECTOR(OFS_PARM0);
+		string = PRVM_G_STRING(OFS_PARM1);
+		scale = PRVM_G_VECTOR(OFS_PARM2);
+		rgb[0] = 1.0;
+		rgb[1] = 1.0;
+		rgb[2] = 1.0;
+		alpha = PRVM_G_FLOAT(OFS_PARM3);
+		flag = (int)PRVM_G_FLOAT(OFS_PARM4);
+	}
+
+	if(flag < DRAWFLAG_NORMAL || flag >= DRAWFLAG_NUMFLAGS)
 	{
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
 		VM_Warning("VM_drawcolorcodedstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
@@ -3417,8 +3438,11 @@ 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")));
 
 	getdrawfontscale(&sx, &sy);
-	DrawQ_String_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;
+	DrawQ_String_Scale(pos[0], pos[1], string, 0, scale[0], scale[1], sx, sy, rgb[0], rgb[1], rgb[2], alpha, flag, NULL, false, getdrawfont());
+	if (prog->argc == 6) // also return vector of last color
+		VectorCopy(DrawQ_Color, PRVM_G_VECTOR(OFS_RETURN));
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 /*
 =========
@@ -3478,8 +3502,176 @@ void VM_stringwidth(void)
 
 	PRVM_G_FLOAT(OFS_RETURN) = DrawQ_TextWidth(string, 0, !colors, getdrawfont()) * mult; // 1x1 characters, don't actually draw
 */
+}
+
+/*
+=========
+VM_findfont
+
+float findfont(string s)
+=========
+*/
+
+float getdrawfontnum(const char *fontname)
+{
+	int i;
+
+	for(i = 0; i < dp_fonts.maxsize; ++i)
+		if(!strcmp(dp_fonts.f[i].title, fontname))
+			return i;
+	return -1;
+}
+
+void VM_findfont(void)
+{
+	VM_SAFEPARMCOUNT(1,VM_findfont);
+	PRVM_G_FLOAT(OFS_RETURN) = getdrawfontnum(PRVM_G_STRING(OFS_PARM0));
+}
+
+/*
+=========
+VM_loadfont
+
+float loadfont(string fontname, string fontmaps, string sizes, float slot)
+=========
+*/
+
+dp_font_t *FindFont(const char *title, qboolean allocate_new);
+void LoadFont(qboolean override, const char *name, dp_font_t *fnt, float scale, float voffset);
+void VM_loadfont(void)
+{
+	const char *fontname, *filelist, *sizes, *c, *cm;
+	char mainfont[MAX_QPATH];
+	int i, numsizes;
+	float sz, scale, voffset;
+	dp_font_t *f;
+
+	VM_SAFEPARMCOUNTRANGE(3,6,VM_loadfont);
+
+	fontname = PRVM_G_STRING(OFS_PARM0);
+	if (!fontname[0])
+		fontname = "default";
+
+	filelist = PRVM_G_STRING(OFS_PARM1);
+	if (!filelist[0])
+		filelist = "gfx/conchars";
+
+	sizes = PRVM_G_STRING(OFS_PARM2);
+	if (!sizes[0])
+		sizes = "10";
+
+	// find a font
+	f = NULL;
+	if (prog->argc >= 4)
+	{
+		i = PRVM_G_FLOAT(OFS_PARM3);
+		if (i >= 0 && i < dp_fonts.maxsize)
+		{
+			f = &dp_fonts.f[i];
+			strlcpy(f->title, fontname, sizeof(f->title)); // replace name
+		}
+	}
+	if (!f)
+		f = FindFont(fontname, true);
+	if (!f)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = -1;
+		return; // something go wrong
+	}
+
+	memset(f->fallbacks, 0, sizeof(f->fallbacks));
+	memset(f->fallback_faces, 0, sizeof(f->fallback_faces));
+
+	// first font is handled "normally"
+	c = strchr(filelist, ':');
+	cm = strchr(filelist, ',');
+	if(c && (!cm || c < cm))
+		f->req_face = atoi(c+1);
+	else
+	{
+		f->req_face = 0;
+		c = cm;
+	}
+	if(!c || (c - filelist) > MAX_QPATH)
+		strlcpy(mainfont, filelist, sizeof(mainfont));
+	else
+	{
+		memcpy(mainfont, filelist, c - filelist);
+		mainfont[c - filelist] = 0;
+	}
+
+	// handle fallbacks
+	for(i = 0; i < MAX_FONT_FALLBACKS; ++i)
+	{
+		c = strchr(filelist, ',');
+		if(!c)
+			break;
+		filelist = c + 1;
+		if(!*filelist)
+			break;
+		c = strchr(filelist, ':');
+		cm = strchr(filelist, ',');
+		if(c && (!cm || c < cm))
+			f->fallback_faces[i] = atoi(c+1);
+		else
+		{
+			f->fallback_faces[i] = 0; // f->req_face; could make it stick to the default-font's face index
+			c = cm;
+		}
+		if(!c || (c-filelist) > MAX_QPATH)
+		{
+			strlcpy(f->fallbacks[i], filelist, sizeof(mainfont));
+		}
+		else
+		{
+			memcpy(f->fallbacks[i], filelist, c - filelist);
+			f->fallbacks[i][c - filelist] = 0;
+		}
+	}
+
+	// handle sizes
+	for(i = 0; i < MAX_FONT_SIZES; ++i)
+		f->req_sizes[i] = -1;
+	for (numsizes = 0,c = sizes;;)
+	{
+		if (!COM_ParseToken_VM_Tokenize(&c, 0))
+			break;
+		sz = atof(com_token);
+		// detect crap size
+		if (sz < 0.001f || sz > 1000.0f)
+		{
+			VM_Warning("VM_loadfont: crap size %s", com_token);
+			continue;
+		}
+		// check overflow
+		if (numsizes == MAX_FONT_SIZES)
+		{
+			VM_Warning("VM_loadfont: MAX_FONT_SIZES = %i exceeded", MAX_FONT_SIZES);
+			break;
+		}
+		f->req_sizes[numsizes] = sz;
+		numsizes++;
+	}
+
+	// additional scale/hoffset parms
+	scale = 1;
+	voffset = 0;
+	if (prog->argc >= 5)
+	{
+		scale = PRVM_G_FLOAT(OFS_PARM4);
+		if (scale <= 0)
+			scale = 1;
+	}
+	if (prog->argc >= 6)
+		voffset = PRVM_G_FLOAT(OFS_PARM5);
+
+	// load
+	LoadFont(true, mainfont, f, scale, voffset);
 
+	// return index of loaded font
+	PRVM_G_FLOAT(OFS_RETURN) = (f - dp_fonts.f);
 }
+
 /*
 =========
 VM_drawpic
@@ -3521,7 +3713,7 @@ void VM_drawpic(void)
 	if(pos[2] || size[2])
 		Con_Printf("VM_drawpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
 
-	DrawQ_Pic(pos[0], pos[1], Draw_CachePic (picname), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
+	DrawQ_Pic(pos[0], pos[1], Draw_CachePic_Flags (picname, CACHEPICFLAG_NOTPERSISTENT), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 /*
@@ -3566,7 +3758,7 @@ void VM_drawrotpic(void)
 	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);
+	DrawQ_RotPic(pos[0], pos[1], Draw_CachePic_Flags(picname, CACHEPICFLAG_NOTPERSISTENT), 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;
 }
 /*
@@ -3614,7 +3806,7 @@ void VM_drawsubpic(void)
 	if(pos[2] || size[2])
 		Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
 
-	DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic (picname),
+	DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic_Flags (picname, CACHEPICFLAG_NOTPERSISTENT),
 		size[0], size[1],
 		srcPos[0],              srcPos[1],              rgb[0], rgb[1], rgb[2], alpha,
 		srcPos[0] + srcSize[0], srcPos[1],              rgb[0], rgb[1], rgb[2], alpha,
@@ -3734,31 +3926,35 @@ void VM_keynumtostring (void)
 =========
 VM_findkeysforcommand
 
-string	findkeysforcommand(string command)
+string	findkeysforcommand(string command, float bindmap)
 
 the returned string is an altstring
 =========
 */
-#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
-
+#define FKFC_NUMKEYS 5
 void M_FindKeysForCommand(const char *command, int *keys);
 void VM_findkeysforcommand(void)
 {
 	const char *cmd;
 	char ret[VM_STRINGTEMP_LENGTH];
-	int keys[NUMKEYS];
+	int keys[FKFC_NUMKEYS];
 	int i;
+	int bindmap;
 
-	VM_SAFEPARMCOUNT(1, VM_findkeysforcommand);
+	VM_SAFEPARMCOUNTRANGE(1, 2, VM_findkeysforcommand);
 
 	cmd = PRVM_G_STRING(OFS_PARM0);
+	if(prog->argc == 2)
+		bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM1), MAX_BINDMAPS-1);
+	else
+		bindmap = 0; // consistent to "bind"
 
 	VM_CheckEmptyString(cmd);
 
-	M_FindKeysForCommand(cmd, keys);
+	Key_FindKeysForCommand(cmd, keys, FKFC_NUMKEYS, bindmap);
 
 	ret[0] = 0;
-	for(i = 0; i < NUMKEYS; i++)
+	for(i = 0; i < FKFC_NUMKEYS; i++)
 		strlcat(ret, va(" \'%i\'", keys[i]), sizeof(ret));
 
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(ret);
@@ -3775,7 +3971,80 @@ void VM_stringtokeynum (void)
 {
 	VM_SAFEPARMCOUNT( 1, VM_keynumtostring );
 
-	PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0));
+	PRVM_G_FLOAT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0));
+}
+
+/*
+=========
+VM_getkeybind
+
+string getkeybind(float key, float bindmap)
+=========
+*/
+void VM_getkeybind (void)
+{
+	int bindmap;
+	VM_SAFEPARMCOUNTRANGE(1, 2, VM_CL_getkeybind);
+	if(prog->argc == 2)
+		bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM1), MAX_BINDMAPS-1);
+	else
+		bindmap = 0; // consistent to "bind"
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0), bindmap));
+}
+
+/*
+=========
+VM_setkeybind
+
+float setkeybind(float key, string cmd, float bindmap)
+=========
+*/
+void VM_setkeybind (void)
+{
+	int bindmap;
+	VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_setkeybind);
+	if(prog->argc == 3)
+		bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM2), MAX_BINDMAPS-1);
+	else
+		bindmap = 0; // consistent to "bind"
+
+	PRVM_G_FLOAT(OFS_RETURN) = 0;
+	if(Key_SetBinding((int)PRVM_G_FLOAT(OFS_PARM0), bindmap, PRVM_G_STRING(OFS_PARM1)))
+		PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+
+/*
+=========
+VM_getbindmap
+
+vector getbindmaps()
+=========
+*/
+void VM_getbindmaps (void)
+{
+	int fg, bg;
+	VM_SAFEPARMCOUNT(0, VM_CL_getbindmap);
+	Key_GetBindMap(&fg, &bg);
+	PRVM_G_VECTOR(OFS_RETURN)[0] = fg;
+	PRVM_G_VECTOR(OFS_RETURN)[1] = bg;
+	PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+}
+
+/*
+=========
+VM_setbindmap
+
+float setbindmaps(vector bindmap)
+=========
+*/
+void VM_setbindmaps (void)
+{
+	VM_SAFEPARMCOUNT(1, VM_CL_setbindmap);
+	PRVM_G_FLOAT(OFS_RETURN) = 0;
+	if(PRVM_G_VECTOR(OFS_PARM0)[2] == 0)
+		if(Key_SetBindMap((int)PRVM_G_VECTOR(OFS_PARM0)[0], (int)PRVM_G_VECTOR(OFS_PARM0)[1]))
+			PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
 // CL_Video interface functions
@@ -3800,7 +4069,7 @@ void VM_cin_open( void )
 	VM_CheckEmptyString( file );
     VM_CheckEmptyString( name );
 
-	if( CL_OpenVideo( file, name, MENUOWNER ) )
+	if( CL_OpenVideo( file, name, MENUOWNER, "" ) )
 		PRVM_G_FLOAT( OFS_RETURN ) = 1;
 	else
 		PRVM_G_FLOAT( OFS_RETURN ) = 0;
@@ -4463,8 +4732,8 @@ static int BufStr_SortStringsUP (const void *in1, const void *in2)
 	const char *a, *b;
 	a = *((const char **) in1);
 	b = *((const char **) in2);
-	if(!a[0])	return 1;
-	if(!b[0])	return -1;
+	if(!a || !a[0])	return 1;
+	if(!b || !b[0])	return -1;
 	return strncmp(a, b, stringbuffers_sortlength);
 }
 
@@ -4473,8 +4742,8 @@ static int BufStr_SortStringsDOWN (const void *in1, const void *in2)
 	const char *a, *b;
 	a = *((const char **) in1);
 	b = *((const char **) in2);
-	if(!a[0])	return 1;
-	if(!b[0])	return -1;
+	if(!a || !a[0])	return 1;
+	if(!b || !b[0])	return -1;
 	return strncmp(b, a, stringbuffers_sortlength);
 }
 
@@ -4504,7 +4773,7 @@ void VM_buf_create (void)
 	for (i = 0;stringbuffer != Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);i++);
 	stringbuffer->origin = PRVM_AllocationOrigin();
 	// optional flags parm
-	if(prog->argc == 2)
+	if (prog->argc >= 2)
 		stringbuffer->flags = (int)PRVM_G_FLOAT(OFS_PARM1) & 0xFF;
 	PRVM_G_FLOAT(OFS_RETURN) = i;
 }
@@ -4718,7 +4987,7 @@ void VM_bufstr_get (void)
 	strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
 	if (strindex < 0)
 	{
-		VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+		// VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
 		return;
 	}
 	if (strindex < stringbuffer->num_strings && stringbuffer->strings[strindex])
@@ -4734,6 +5003,7 @@ void bufstr_set(float bufhandle, float string_index, string str) = #466;
 */
 void VM_bufstr_set (void)
 {
+	size_t alloclen;
 	int				strindex;
 	prvm_stringbuffer_t *stringbuffer;
 	const char		*news;
@@ -4760,10 +5030,11 @@ void VM_bufstr_set (void)
 		Mem_Free(stringbuffer->strings[strindex]);
 	stringbuffer->strings[strindex] = NULL;
 
-	news = PRVM_G_STRING(OFS_PARM2);
-	if (news && news[0])
+	if(PRVM_G_INT(OFS_PARM2))
 	{
-		size_t alloclen = strlen(news) + 1;
+		// not the NULL string!
+		news = PRVM_G_STRING(OFS_PARM2);
+		alloclen = strlen(news) + 1;
 		stringbuffer->strings[strindex] = (char *)Mem_Alloc(prog->progs_mempool, alloclen);
 		memcpy(stringbuffer->strings[strindex], news, alloclen);
 	}
@@ -4795,12 +5066,12 @@ void VM_bufstr_add (void)
 		VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
-	string = PRVM_G_STRING(OFS_PARM1);
-	if(!string || !string[0])
+	if(!PRVM_G_INT(OFS_PARM1)) // NULL string
 	{
 		VM_Warning("VM_bufstr_add: can not add an empty string to buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
 		return;
 	}
+	string = PRVM_G_STRING(OFS_PARM1);
 	order = (int)PRVM_G_FLOAT(OFS_PARM2);
 	if(order)
 		strindex = stringbuffer->num_strings;
@@ -5483,7 +5754,7 @@ void VM_uri_escape (void)
 			|| (*p >= 'a' && *p <= 'z')
 			|| (*p >= '0' && *p <= '9')
 			|| (*p == '-')  || (*p == '_') || (*p == '.')
-			|| (*p == '!')  || (*p == '~') || (*p == '*')
+			|| (*p == '!')  || (*p == '~')
 			|| (*p == '\'') || (*p == '(') || (*p == ')'))
 			*q++ = *p;
 		else
@@ -5564,6 +5835,10 @@ typedef struct
 	double starttime;
 	float id;
 	char buffer[MAX_INPUTLINE];
+	unsigned char *postdata; // free when uri_to_prog_t is freed
+	size_t postlen;
+	char *sigdata; // free when uri_to_prog_t is freed
+	size_t siglen;
 }
 uri_to_prog_t;
 
@@ -5574,6 +5849,10 @@ static void uri_to_string_callback(int status, size_t length_received, unsigned
 	if(!PRVM_ProgLoaded(handle->prognr))
 	{
 		// curl reply came too late... so just drop it
+		if(handle->postdata)
+			Z_Free(handle->postdata);
+		if(handle->sigdata)
+			Z_Free(handle->sigdata);
 		Z_Free(handle);
 		return;
 	}
@@ -5593,6 +5872,10 @@ static void uri_to_string_callback(int status, size_t length_received, unsigned
 		}
 	PRVM_End;
 	
+	if(handle->postdata)
+		Z_Free(handle->postdata);
+	if(handle->sigdata)
+		Z_Free(handle->sigdata);
 	Z_Free(handle);
 }
 
@@ -5604,26 +5887,157 @@ void VM_uri_get (void)
 	float id;
 	qboolean ret;
 	uri_to_prog_t *handle;
+	const char *posttype = NULL;
+	const char *postseparator = NULL;
+	int poststringbuffer = -1;
+	int postkeyid = -1;
+	const char *query_string = NULL;
+	size_t lq;
 
 	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);
+	VM_SAFEPARMCOUNTRANGE(2, 6, VM_uri_get);
 
 	url = PRVM_G_STRING(OFS_PARM0);
 	id = PRVM_G_FLOAT(OFS_PARM1);
+	if(prog->argc >= 3)
+		posttype = PRVM_G_STRING(OFS_PARM2);
+	if(prog->argc >= 4)
+		postseparator = PRVM_G_STRING(OFS_PARM3);
+	if(prog->argc >= 5)
+		poststringbuffer = PRVM_G_FLOAT(OFS_PARM4);
+	if(prog->argc >= 6)
+		postkeyid = PRVM_G_FLOAT(OFS_PARM5);
 	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!
 
+	query_string = strchr(url, '?');
+	if(query_string)
+		++query_string;
+	lq = query_string ? strlen(query_string) : 0;
+
 	handle->prognr = PRVM_GetProgNr();
 	handle->starttime = prog->starttime;
 	handle->id = id;
-	ret = Curl_Begin_ToMemory(url, 0, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
+	if(postseparator)
+	{
+		size_t l = strlen(postseparator);
+		if(poststringbuffer >= 0)
+		{
+			size_t ltotal;
+			int i;
+			// "implode"
+			prvm_stringbuffer_t *stringbuffer;
+			stringbuffer = (prvm_stringbuffer_t *)Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, poststringbuffer);
+			if(!stringbuffer)
+			{
+				VM_Warning("uri_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+				return;
+			}
+			ltotal = 0;
+			for(i = 0;i < stringbuffer->num_strings;i++)
+			{
+				if(i > 0)
+					ltotal += l;
+				if(stringbuffer->strings[i])
+					ltotal += strlen(stringbuffer->strings[i]);
+			}
+			handle->postdata = (unsigned char *)Z_Malloc(ltotal + 1 + lq);
+			handle->postlen = ltotal;
+			ltotal = 0;
+			for(i = 0;i < stringbuffer->num_strings;i++)
+			{
+				if(i > 0)
+				{
+					memcpy(handle->postdata + ltotal, postseparator, l);
+					ltotal += l;
+				}
+				if(stringbuffer->strings[i])
+				{
+					memcpy(handle->postdata + ltotal, stringbuffer->strings[i], strlen(stringbuffer->strings[i]));
+					ltotal += strlen(stringbuffer->strings[i]);
+				}
+			}
+			if(ltotal != handle->postlen)
+				PRVM_ERROR ("%s: string buffer content size mismatch, possible overrun", PRVM_NAME);
+		}
+		else
+		{
+			handle->postdata = (unsigned char *)Z_Malloc(l + 1 + lq);
+			handle->postlen = l;
+			memcpy(handle->postdata, postseparator, l);
+		}
+		handle->postdata[handle->postlen] = 0;
+		if(query_string)
+			memcpy(handle->postdata + handle->postlen + 1, query_string, lq);
+		if(postkeyid >= 0)
+		{
+			// POST: we sign postdata \0 query string
+			size_t ll;
+			handle->sigdata = (char *)Z_Malloc(8192);
+			strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
+			l = strlen(handle->sigdata);
+			handle->siglen = Crypto_SignDataDetached(handle->postdata, handle->postlen + 1 + lq, postkeyid, handle->sigdata + l, 8192 - l);
+			if(!handle->siglen)
+			{
+				Z_Free(handle->sigdata);
+				handle->sigdata = NULL;
+				goto out1;
+			}
+			ll = base64_encode((unsigned char *) (handle->sigdata + l), handle->siglen, 8192 - l - 1);
+			if(!ll)
+			{
+				Z_Free(handle->sigdata);
+				handle->sigdata = NULL;
+				goto out1;
+			}
+			handle->siglen = l + ll;
+			handle->sigdata[handle->siglen] = 0;
+		}
+out1:
+		ret = Curl_Begin_ToMemory_POST(url, handle->sigdata, 0, posttype, handle->postdata, handle->postlen, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
+	}
+	else
+	{
+		if(postkeyid >= 0 && query_string)
+		{
+			// GET: we sign JUST the query string
+			size_t l, ll;
+			handle->sigdata = (char *)Z_Malloc(8192);
+			strlcpy(handle->sigdata, "X-D0-Blind-ID-Detached-Signature: ", 8192);
+			l = strlen(handle->sigdata);
+			handle->siglen = Crypto_SignDataDetached(query_string, lq, postkeyid, handle->sigdata + l, 8192 - l);
+			if(!handle->siglen)
+			{
+				Z_Free(handle->sigdata);
+				handle->sigdata = NULL;
+				goto out2;
+			}
+			ll = base64_encode((unsigned char *) (handle->sigdata + l), handle->siglen, 8192 - l - 1);
+			if(!ll)
+			{
+				Z_Free(handle->sigdata);
+				handle->sigdata = NULL;
+				goto out2;
+			}
+			handle->siglen = l + ll;
+			handle->sigdata[handle->siglen] = 0;
+		}
+out2:
+		handle->postdata = NULL;
+		handle->postlen = 0;
+		ret = Curl_Begin_ToMemory(url, 0, (unsigned char *) handle->buffer, sizeof(handle->buffer), uri_to_string_callback, handle);
+	}
 	if(ret)
 	{
 		PRVM_G_INT(OFS_RETURN) = 1;
 	}
 	else
 	{
+		if(handle->postdata)
+			Z_Free(handle->postdata);
+		if(handle->sigdata)
+			Z_Free(handle->sigdata);
 		Z_Free(handle);
 		PRVM_G_INT(OFS_RETURN) = 0;
 	}
@@ -5680,6 +6094,26 @@ void VM_SV_getextresponse (void)
 	}
 }
 
+/*
+=========
+Common functions between menu.dat and clsprogs
+=========
+*/
+
+//#349 float() isdemo 
+void VM_CL_isdemo (void)
+{
+	VM_SAFEPARMCOUNT(0, VM_CL_isdemo);
+	PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
+}
+
+//#355 float() videoplaying 
+void VM_CL_videoplaying (void)
+{
+	VM_SAFEPARMCOUNT(0, VM_CL_videoplaying);
+	PRVM_G_FLOAT(OFS_RETURN) = cl_videoplaying;
+}
+
 /*
 =========
 VM_M_callfunction
@@ -5766,7 +6200,7 @@ void VM_sprintf(void)
 	int width, precision, thisarg, flags;
 	char formatbuf[16];
 	char *f;
-	qboolean isfloat;
+	int isfloat;
 	static int dummyivec[3] = {0, 0, 0};
 	static float dummyvec[3] = {0, 0, 0};
 
@@ -5806,6 +6240,7 @@ void VM_sprintf(void)
 				precision = -1;
 				thisarg = -1;
 				flags = 0;
+				isfloat = -1;
 
 				// is number following?
 				if(*s >= '0' && *s <= '9')
@@ -5928,14 +6363,13 @@ noflags:
 					}
 				}
 
-				isfloat = true;
 				for(;;)
 				{
 					switch(*s)
 					{
-						case 'h': isfloat = true; break;
-						case 'l': isfloat = false; break;
-						case 'L': isfloat = false; break;
+						case 'h': isfloat = 1; break;
+						case 'l': isfloat = 0; break;
+						case 'L': isfloat = 0; break;
 						case 'j': break;
 						case 'z': break;
 						case 't': break;
@@ -5946,6 +6380,15 @@ noflags:
 				}
 nolength:
 
+				// now s points to the final directive char and is no longer changed
+				if(isfloat < 0)
+				{
+					if(*s == 'i')
+						isfloat = 0;
+					else
+						isfloat = 1;
+				}
+
 				if(thisarg < 0)
 					thisarg = argpos++;
 
@@ -5959,8 +6402,11 @@ nolength:
 					if(flags & PRINTF_SPACEPOSITIVE) *f++ = ' ';
 					if(flags & PRINTF_SIGNPOSITIVE) *f++ = '+';
 					*f++ = '*';
-					*f++ = '.';
-					*f++ = '*';
+					if(precision >= 0)
+					{
+						*f++ = '.';
+						*f++ = '*';
+					}
 					*f++ = *s;
 					*f++ = 0;
 
@@ -5971,50 +6417,70 @@ nolength:
 					{
 						case 'd': case 'i':
 							if(precision < 0) // not set
-								precision = 1;
-							o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (int) GETARG_FLOAT(thisarg) : (int) GETARG_INT(thisarg)));
+								o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? (int) GETARG_FLOAT(thisarg) : (int) GETARG_INT(thisarg)));
+							else
+								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':
 							if(precision < 0) // not set
-								precision = 1;
-							o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+								o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+							else
+								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) // not set
-								precision = 6;
-							o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
+								o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
+							else
+								o += dpsnprintf(o, end - o, formatbuf, width, precision, (isfloat ? (double) GETARG_FLOAT(thisarg) : (double) GETARG_INT(thisarg)));
 							break;
 						case 'v': case 'V':
 							f[-2] += 'g' - 'v';
 							if(precision < 0) // not set
-								precision = 6;
-							o += dpsnprintf(o, end - o, va("%s %s %s", /* NESTED SPRINTF IS NESTED */ formatbuf, formatbuf, formatbuf),
-								width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[0] : (double) GETARG_INTVECTOR(thisarg)[0]),
-								width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[1] : (double) GETARG_INTVECTOR(thisarg)[1]),
-								width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[2] : (double) GETARG_INTVECTOR(thisarg)[2])
-							);
+								o += dpsnprintf(o, end - o, va("%s %s %s", /* NESTED SPRINTF IS NESTED */ formatbuf, formatbuf, formatbuf),
+									width, (isfloat ? (double) GETARG_VECTOR(thisarg)[0] : (double) GETARG_INTVECTOR(thisarg)[0]),
+									width, (isfloat ? (double) GETARG_VECTOR(thisarg)[1] : (double) GETARG_INTVECTOR(thisarg)[1]),
+									width, (isfloat ? (double) GETARG_VECTOR(thisarg)[2] : (double) GETARG_INTVECTOR(thisarg)[2])
+								);
+							else
+								o += dpsnprintf(o, end - o, va("%s %s %s", /* NESTED SPRINTF IS NESTED */ formatbuf, formatbuf, formatbuf),
+									width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[0] : (double) GETARG_INTVECTOR(thisarg)[0]),
+									width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[1] : (double) GETARG_INTVECTOR(thisarg)[1]),
+									width, precision, (isfloat ? (double) GETARG_VECTOR(thisarg)[2] : (double) GETARG_INTVECTOR(thisarg)[2])
+								);
 							break;
 						case 'c':
-							if(precision < 0) // not set
-								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)));
+							{
+								if(precision < 0) // not set
+									o += dpsnprintf(o, end - o, formatbuf, width, (isfloat ? (unsigned int) GETARG_FLOAT(thisarg) : (unsigned int) GETARG_INT(thisarg)));
+								else
+									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 = "";
+								if(precision < 0) // not set
+									precision = end - o - 1;
 								o += u8_strpad(o, end - o, buf, (flags & PRINTF_LEFT) != 0, width, precision);
 							}
 							break;
 						case 's':
-							if(precision < 0) // not set
-								precision = end - o - 1;
 							if(flags & PRINTF_ALTERNATE)
-								o += dpsnprintf(o, end - o, formatbuf, width, precision, GETARG_STRING(thisarg));
+							{
+								if(precision < 0) // not set
+									o += dpsnprintf(o, end - o, formatbuf, width, GETARG_STRING(thisarg));
+								else
+									o += dpsnprintf(o, end - o, formatbuf, width, precision, GETARG_STRING(thisarg));
+							}
 							else
+							{
+								if(precision < 0) // not set
+									precision = end - o - 1;
 								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);
@@ -6077,7 +6543,7 @@ void animatemodel(dp_model_t *model, prvm_edict_t *ed)
 	skeleton_t *skeleton;
 	int skeletonindex = -1;
 	qboolean need = false;
-	if(!model->AnimateVertices)
+	if(!(model->surfmesh.isanimated && model->AnimateVertices))
 	{
 		animatemodel_cache.data_vertex3f = model->surfmesh.data_vertex3f;
 		animatemodel_cache.data_svector3f = model->surfmesh.data_svector3f;
@@ -6090,13 +6556,13 @@ void animatemodel(dp_model_t *model, prvm_edict_t *ed)
 	need |= (animatemodel_cache.model != model);
 	VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed);
 	VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
-	need |= (memcmp(&animatemodel_cache.frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend)));
+	need |= (memcmp(&animatemodel_cache.frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend))) != 0;
 	if ((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.skeletonindex))) skeletonindex = (int)val->_float - 1;
 	if (!(skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones))
 		skeleton = NULL;
 	need |= (animatemodel_cache.skeleton_p != skeleton);
 	if(skeleton)
-		need |= (memcmp(&animatemodel_cache.skeleton, skeleton, sizeof(ed->priv.server->skeleton)));
+		need |= (memcmp(&animatemodel_cache.skeleton, skeleton, sizeof(ed->priv.server->skeleton))) != 0;
 	if(!need)
 		return;
 	if(model->surfmesh.num_vertices > animatemodel_cache.max_vertices)
@@ -6106,10 +6572,10 @@ void animatemodel(dp_model_t *model, prvm_edict_t *ed)
 		if(animatemodel_cache.buf_svector3f) Mem_Free(animatemodel_cache.buf_svector3f);
 		if(animatemodel_cache.buf_tvector3f) Mem_Free(animatemodel_cache.buf_tvector3f);
 		if(animatemodel_cache.buf_normal3f) Mem_Free(animatemodel_cache.buf_normal3f);
-		animatemodel_cache.buf_vertex3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
-		animatemodel_cache.buf_svector3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
-		animatemodel_cache.buf_tvector3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
-		animatemodel_cache.buf_normal3f = Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
+		animatemodel_cache.buf_vertex3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
+		animatemodel_cache.buf_svector3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
+		animatemodel_cache.buf_tvector3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
+		animatemodel_cache.buf_normal3f = (float *)Mem_Alloc(prog->progs_mempool, sizeof(float[3]) * animatemodel_cache.max_vertices);
 	}
 	animatemodel_cache.data_vertex3f = animatemodel_cache.buf_vertex3f;
 	animatemodel_cache.data_svector3f = animatemodel_cache.buf_svector3f;
@@ -6159,7 +6625,7 @@ static void applytransform_inverted(const vec3_t in, prvm_edict_t *ed, vec3_t ou
 {
 	matrix4x4_t m, n;
 	getmatrix(ed, &m);
-	Matrix4x4_Invert_Full(&m, &n);
+	Matrix4x4_Invert_Full(&n, &m);
 	Matrix4x4_Transform3x3(&n, in, out);
 }
 
@@ -6456,3 +6922,103 @@ void VM_getsurfacetriangle(void)
        // FIXME: implement rotation/scaling
        VectorMA(&(model->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[trinum * 3], surface->num_firstvertex, d, PRVM_G_VECTOR(OFS_RETURN));
 }
+
+//
+// physics builtins
+//
+
+void World_Physics_ApplyCmd(prvm_edict_t *ed, edict_odefunc_t *f);
+
+#define VM_physics_ApplyCmd(ed,f) if (!ed->priv.server->ode_body) VM_physics_newstackfunction(ed, f); else World_Physics_ApplyCmd(ed, f)
+
+edict_odefunc_t *VM_physics_newstackfunction(prvm_edict_t *ed, edict_odefunc_t *f)
+{
+	edict_odefunc_t *newfunc, *func;
+
+	newfunc = (edict_odefunc_t *)Mem_Alloc(prog->progs_mempool, sizeof(edict_odefunc_t));
+	memcpy(newfunc, f, sizeof(edict_odefunc_t));
+	newfunc->next = NULL;
+	if (!ed->priv.server->ode_func)
+		ed->priv.server->ode_func = newfunc;
+	else
+	{
+		for (func = ed->priv.server->ode_func; func->next; func = func->next);
+		func->next = newfunc;
+	}
+	return newfunc;
+}
+
+// void(entity e, float physics_enabled) physics_enable = #;
+void VM_physics_enable(void)
+{
+	prvm_edict_t *ed;
+	edict_odefunc_t f;
+	
+	VM_SAFEPARMCOUNT(2, VM_physics_enable);
+	ed = PRVM_G_EDICT(OFS_PARM0);
+	if (!ed)
+	{
+		if (developer.integer > 0)
+			VM_Warning("VM_physics_enable: null entity!\n");
+		return;
+	}
+	// entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
+	if (ed->fields.server->movetype != MOVETYPE_PHYSICS)
+	{
+		VM_Warning("VM_physics_enable: entity is not MOVETYPE_PHYSICS!\n");
+		return;
+	}
+	f.type = PRVM_G_FLOAT(OFS_PARM1) == 0 ? ODEFUNC_DISABLE : ODEFUNC_ENABLE;
+	VM_physics_ApplyCmd(ed, &f);
+}
+
+// void(entity e, vector force, vector relative_ofs) physics_addforce = #;
+void VM_physics_addforce(void)
+{
+	prvm_edict_t *ed;
+	edict_odefunc_t f;
+	
+	VM_SAFEPARMCOUNT(3, VM_physics_addforce);
+	ed = PRVM_G_EDICT(OFS_PARM0);
+	if (!ed)
+	{
+		if (developer.integer > 0)
+			VM_Warning("VM_physics_addforce: null entity!\n");
+		return;
+	}
+	// entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
+	if (ed->fields.server->movetype != MOVETYPE_PHYSICS)
+	{
+		VM_Warning("VM_physics_addforce: entity is not MOVETYPE_PHYSICS!\n");
+		return;
+	}
+	f.type = ODEFUNC_RELFORCEATPOS;
+	VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
+	VectorSubtract(ed->fields.server->origin, PRVM_G_VECTOR(OFS_PARM2), f.v2);
+	VM_physics_ApplyCmd(ed, &f);
+}
+
+// void(entity e, vector torque) physics_addtorque = #;
+void VM_physics_addtorque(void)
+{
+	prvm_edict_t *ed;
+	edict_odefunc_t f;
+	
+	VM_SAFEPARMCOUNT(2, VM_physics_addtorque);
+	ed = PRVM_G_EDICT(OFS_PARM0);
+	if (!ed)
+	{
+		if (developer.integer > 0)
+			VM_Warning("VM_physics_addtorque: null entity!\n");
+		return;
+	}
+	// entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
+	if (ed->fields.server->movetype != MOVETYPE_PHYSICS)
+	{
+		VM_Warning("VM_physics_addtorque: entity is not MOVETYPE_PHYSICS!\n");
+		return;
+	}
+	f.type = ODEFUNC_RELTORQUE;
+	VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
+	VM_physics_ApplyCmd(ed, &f);
+}