X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=prvm_cmds.c;h=6ff3db2530af56e649e4260d2200934f6aa5e9aa;hb=a19dce25671ecfa28e4eb3861f8636750bf3ba68;hp=e82fa7f7442fee53c955fbf01d5c8dcc029c6e1c;hpb=7403ba135fe27515470bfc6a7f8980869ccfee76;p=xonotic%2Fdarkplaces.git

diff --git a/prvm_cmds.c b/prvm_cmds.c
index e82fa7f7..6ff3db25 100644
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -6,6 +6,22 @@
 
 #include "prvm_cmds.h"
 
+// LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
+void VM_Warning(const char *fmt, ...)
+{
+	va_list argptr;
+	char msg[MAX_INPUTLINE];
+
+	va_start(argptr,fmt);
+	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
+	va_end(argptr);
+
+	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]
+	//PRVM_PrintState();
+}
+
+
 //============================================================================
 // Common
 
@@ -14,20 +30,8 @@
 static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH];
 static int vm_string_tempindex = 0;
 
-// qc file handling
-#define MAX_VMFILES		256
-#define MAX_PRVMFILES	MAX_VMFILES * PRVM_MAXPROGS
-#define VM_FILES ((qfile_t**)(vm_files + PRVM_GetProgNr() * MAX_VMFILES))
-
-qfile_t *vm_files[MAX_PRVMFILES];
-
-// qc fs search handling
-#define MAX_VMSEARCHES 128
-#define TOTAL_VMSEARCHES MAX_VMSEARCHES * PRVM_MAXPROGS
-#define VM_SEARCHLIST ((fssearch_t**)(vm_fssearchlist + PRVM_GetProgNr() * MAX_VMSEARCHES))
-
-fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES];
-
+// TODO: (move vm_files and vm_fssearchlist to prvm_prog_t struct)
+// TODO: move vm_files and vm_fssearchlist back [9/13/2006 Black]
 char *VM_GetTempString(void)
 {
 	char *s;
@@ -116,14 +120,14 @@ void VM_error (void)
 	char string[VM_STRINGTEMP_LENGTH];
 
 	VM_VarString(0, string, sizeof(string));
-	Con_Printf("======%S ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+	Con_Printf("======%s ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 	if(prog->self)
 	{
 		ed = PRVM_G_EDICT(prog->self->ofs);
 		PRVM_ED_Print(ed);
 	}
 
-	PRVM_ERROR ("%s: Program error", PRVM_NAME);
+	PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 }
 
 /*
@@ -142,7 +146,7 @@ void VM_objerror (void)
 	char string[VM_STRINGTEMP_LENGTH];
 
 	VM_VarString(0, string, sizeof(string));
-	Con_Printf("======%s OBJECT ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+	Con_Printf("======OBJECT ERROR======\n"); // , PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
 	if(prog->self)
 	{
 		ed = PRVM_G_EDICT (prog->self->ofs);
@@ -153,6 +157,7 @@ void VM_objerror (void)
 	else
 		// objerror has to display the object fields -> else call
 		PRVM_ERROR ("VM_objecterror: self not defined !");
+	Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 }
 
 /*
@@ -187,7 +192,7 @@ void VM_bprint (void)
 
 	if(!sv.active)
 	{
-		Con_Printf("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
+		VM_Warning("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
 		return;
 	}
 
@@ -211,17 +216,20 @@ void VM_sprint (void)
 	char string[VM_STRINGTEMP_LENGTH];
 
 	//find client for this entity
-	clientnum = PRVM_G_FLOAT(OFS_PARM0);
+	clientnum = (int)PRVM_G_FLOAT(OFS_PARM0);
 	if (!sv.active  || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
 	{
-		Con_Printf("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
+		VM_Warning("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
 		return;
 	}
 
 	client = svs.clients + clientnum;
+	if (!client->netconnection)
+		return;
+
 	VM_VarString(1, string, sizeof(string));
-	MSG_WriteChar(&client->message,svc_print);
-	MSG_WriteString(&client->message, string);
+	MSG_WriteChar(&client->netconnection->message,svc_print);
+	MSG_WriteString(&client->netconnection->message, string);
 }
 
 /*
@@ -438,8 +446,8 @@ void VM_localsound(void)
 
 	if(!S_LocalSound (s))
 	{
-		Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
 		PRVM_G_FLOAT(OFS_RETURN) = -4;
+		VM_Warning("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
 		return;
 	}
 
@@ -466,15 +474,15 @@ VM_localcmd
 
 Sends text over to the client's execution buffer
 
-[localcmd (string) or]
-cmd (string)
+[localcmd (string, ...) or]
+cmd (string, ...)
 =================
 */
 void VM_localcmd (void)
 {
-	VM_SAFEPARMCOUNT(1,VM_localcmd);
-
-	Cbuf_AddText(PRVM_G_STRING(OFS_PARM0));
+	char string[VM_STRINGTEMP_LENGTH];
+	VM_VarString(0, string, sizeof(string));
+	Cbuf_AddText(string);
 }
 
 /*
@@ -516,7 +524,7 @@ void VM_cvar_string(void)
 
 	cvar_string = Cvar_VariableString(name);
 
-	strcpy(out, cvar_string);
+	strlcpy(out, cvar_string, VM_STRINGTEMP_LENGTH);
 
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out);
 }
@@ -547,7 +555,7 @@ void VM_cvar_defstring (void)
 
 	cvar_string = Cvar_VariableDefString(name);
 
-	strcpy(out, cvar_string);
+	strlcpy(out, cvar_string, VM_STRINGTEMP_LENGTH);
 
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(out);
 }
@@ -696,19 +704,19 @@ void VM_itof(void)
 
 /*
 ========================
-VM_itoe
+VM_ftoe
 
-intt ftoi(float num)
+entity ftoe(float num)
 ========================
 */
-void VM_ftoi(void)
+void VM_ftoe(void)
 {
 	int ent;
-	VM_SAFEPARMCOUNT(1, VM_ftoi);
+	VM_SAFEPARMCOUNT(1, VM_ftoe);
 
-	ent = PRVM_G_FLOAT(OFS_PARM0);
-	if(PRVM_PROG_TO_EDICT(ent)->priv.required->free)
-		PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!", PRVM_NAME, ent);
+	ent = (int)PRVM_G_FLOAT(OFS_PARM0);
+	if (ent < 0 || ent >= 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;
 }
@@ -745,13 +753,18 @@ void VM_remove (void)
 	VM_SAFEPARMCOUNT(1, VM_remove);
 
 	ed = PRVM_G_EDICT(OFS_PARM0);
-	if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) {
-		Con_DPrint( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
-	} else if( ed->priv.required->free ) {
-		Con_DPrint( "VM_remove: tried to remove an already freed entity!\n" );
-	} else {
-		PRVM_ED_Free (ed);
+	if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
+	{
+		if (developer.integer >= 1)
+			VM_Warning( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
 	}
+	else if( ed->priv.required->free )
+	{
+		if (developer.integer >= 1)
+			VM_Warning( "VM_remove: tried to remove an already freed entity!\n" );
+	}
+	else
+		PRVM_ED_Free (ed);
 //	if (ed == prog->edicts)
 //		PRVM_ERROR ("remove: tried to remove world");
 //	if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients)
@@ -779,12 +792,11 @@ void VM_find (void)
 	f = PRVM_G_INT(OFS_PARM1);
 	s = PRVM_G_STRING(OFS_PARM2);
 
-	if (!s || !s[0])
-	{
-		// return reserved edict 0 (could be used for whatever the prog wants)
-		VM_RETURN_EDICT(prog->edicts);
-		return;
-	}
+	// LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
+	// expects it to find all the monsters, so we must be careful to support
+	// searching for ""
+	if (!s)
+		s = "";
 
 	for (e++ ; e < prog->num_edicts ; e++)
 	{
@@ -794,7 +806,7 @@ void VM_find (void)
 			continue;
 		t = PRVM_E_STRING(ed,f);
 		if (!t)
-			continue;
+			t = "";
 		if (!strcmp(t,s))
 		{
 			VM_RETURN_EDICT(ed);
@@ -872,11 +884,12 @@ void VM_findchain (void)
 
 	f = PRVM_G_INT(OFS_PARM0);
 	s = PRVM_G_STRING(OFS_PARM1);
-	if (!s || !s[0])
-	{
-		VM_RETURN_EDICT(prog->edicts);
-		return;
-	}
+
+	// LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
+	// expects it to find all the monsters, so we must be careful to support
+	// searching for ""
+	if (!s)
+		s = "";
 
 	ent = PRVM_NEXT_EDICT(prog->edicts);
 	for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
@@ -886,7 +899,7 @@ void VM_findchain (void)
 			continue;
 		t = PRVM_E_STRING(ent,f);
 		if (!t)
-			continue;
+			t = "";
 		if (strcmp(t,s))
 			continue;
 
@@ -971,6 +984,8 @@ void VM_findflags (void)
 		ed = PRVM_EDICT_NUM(e);
 		if (ed->priv.required->free)
 			continue;
+		if (!PRVM_E_FLOAT(ed,f))
+			continue;
 		if ((int)PRVM_E_FLOAT(ed,f) & s)
 		{
 			VM_RETURN_EDICT(ed);
@@ -1015,6 +1030,8 @@ void VM_findchainflags (void)
 		prog->xfunction->builtinsprofile++;
 		if (ent->priv.required->free)
 			continue;
+		if (!PRVM_E_FLOAT(ent,f))
+			continue;
 		if (!((int)PRVM_E_FLOAT(ent,f) & s))
 			continue;
 
@@ -1122,15 +1139,14 @@ float	rint(float)
 */
 void VM_rint (void)
 {
-	float	f;
-
+	float f;
 	VM_SAFEPARMCOUNT(1,VM_rint);
 
 	f = PRVM_G_FLOAT(OFS_PARM0);
 	if (f > 0)
-		PRVM_G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
+		PRVM_G_FLOAT(OFS_RETURN) = floor(f + 0.5);
 	else
-		PRVM_G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
+		PRVM_G_FLOAT(OFS_RETURN) = ceil(f - 0.5);
 }
 
 /*
@@ -1211,7 +1227,7 @@ void VM_changelevel (void)
 
 	if(!sv.active)
 	{
-		Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
+		VM_Warning("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
 		return;
 	}
 
@@ -1262,6 +1278,67 @@ void VM_sqrt (void)
 	PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0));
 }
 
+/*
+=========
+VM_asin
+
+float	asin(float)
+=========
+*/
+void VM_asin (void)
+{
+	VM_SAFEPARMCOUNT(1,VM_asin);
+	PRVM_G_FLOAT(OFS_RETURN) = asin(PRVM_G_FLOAT(OFS_PARM0));
+}
+
+/*
+=========
+VM_acos
+float	acos(float)
+=========
+*/
+void VM_acos (void)
+{
+	VM_SAFEPARMCOUNT(1,VM_acos);
+	PRVM_G_FLOAT(OFS_RETURN) = acos(PRVM_G_FLOAT(OFS_PARM0));
+}
+
+/*
+=========
+VM_atan
+float	atan(float)
+=========
+*/
+void VM_atan (void)
+{
+	VM_SAFEPARMCOUNT(1,VM_atan);
+	PRVM_G_FLOAT(OFS_RETURN) = atan(PRVM_G_FLOAT(OFS_PARM0));
+}
+
+/*
+=========
+VM_atan2
+float	atan2(float,float)
+=========
+*/
+void VM_atan2 (void)
+{
+	VM_SAFEPARMCOUNT(2,VM_atan2);
+	PRVM_G_FLOAT(OFS_RETURN) = atan2(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
+}
+
+/*
+=========
+VM_tan
+float	tan(float)
+=========
+*/
+void VM_tan (void)
+{
+	VM_SAFEPARMCOUNT(1,VM_tan);
+	PRVM_G_FLOAT(OFS_RETURN) = tan(PRVM_G_FLOAT(OFS_PARM0));
+}
+
 /*
 =================
 VM_randomvec
@@ -1316,7 +1393,7 @@ void VM_registercvar (void)
 
 	name = PRVM_G_STRING(OFS_PARM0);
 	value = PRVM_G_STRING(OFS_PARM1);
-	flags = PRVM_G_FLOAT(OFS_PARM2);
+	flags = (int)PRVM_G_FLOAT(OFS_PARM2);
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
 
 	if(flags > CVAR_MAXFLAGSVAL)
@@ -1329,7 +1406,7 @@ void VM_registercvar (void)
 // check for overlap with a command
 	if (Cmd_Exists (name))
 	{
-		Con_Printf("VM_registercvar: %s is a command\n", name);
+		VM_Warning("VM_registercvar: %s is a command\n", name);
 		return;
 	}
 
@@ -1478,34 +1555,35 @@ setcolor(clientent, value)
 
 void VM_Files_Init(void)
 {
-	memset(VM_FILES, 0, sizeof(qfile_t*[MAX_VMFILES]));
+	int i;
+	for (i = 0;i < PRVM_MAX_OPENFILES;i++)
+		prog->openfiles[i] = NULL;
 }
 
 void VM_Files_CloseAll(void)
 {
 	int i;
-	for (i = 0;i < MAX_VMFILES;i++)
+	for (i = 0;i < PRVM_MAX_OPENFILES;i++)
 	{
-		if (VM_FILES[i])
-			FS_Close(VM_FILES[i]);
-		//VM_FILES[i] = NULL;
+		if (prog->openfiles[i])
+			FS_Close(prog->openfiles[i]);
+		prog->openfiles[i] = NULL;
 	}
-	memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?)
 }
 
 qfile_t *VM_GetFileHandle( int index )
 {
-	if (index < 0 || index >= MAX_VMFILES)
+	if (index < 0 || index >= PRVM_MAX_OPENFILES)
 	{
 		Con_Printf("VM_GetFileHandle: invalid file handle %i used in %s\n", index, PRVM_NAME);
 		return NULL;
 	}
-	if (VM_FILES[index] == NULL)
+	if (prog->openfiles[index] == NULL)
 	{
 		Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, PRVM_NAME);
 		return NULL;
 	}
-	return VM_FILES[index];
+	return prog->openfiles[index];
 }
 
 /*
@@ -1525,16 +1603,16 @@ void VM_fopen(void)
 
 	VM_SAFEPARMCOUNT(2,VM_fopen);
 
-	for (filenum = 0;filenum < MAX_VMFILES;filenum++)
-		if (VM_FILES[filenum] == NULL)
+	for (filenum = 0;filenum < PRVM_MAX_OPENFILES;filenum++)
+		if (prog->openfiles[filenum] == NULL)
 			break;
-	if (filenum >= MAX_VMFILES)
+	if (filenum >= PRVM_MAX_OPENFILES)
 	{
-		Con_Printf("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES);
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENFILES);
 		return;
 	}
-	mode = PRVM_G_FLOAT(OFS_PARM1);
+	mode = (int)PRVM_G_FLOAT(OFS_PARM1);
 	switch(mode)
 	{
 	case 0: // FILE_READ
@@ -1547,27 +1625,27 @@ void VM_fopen(void)
 		modestring = "wb";
 		break;
 	default:
-		Con_Printf("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
 		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);
 
-	VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
-	if (VM_FILES[filenum] == NULL && mode == 0)
-		VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false, false);
+	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 (VM_FILES[filenum] == NULL)
+	if (prog->openfiles[filenum] == NULL)
 	{
-		if (developer.integer)
-			Con_Printf("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
+		if (developer.integer >= 100)
+			VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
 	}
 	else
 	{
-		if (developer.integer)
-			Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
 		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);
 	}
 }
 
@@ -1585,21 +1663,21 @@ void VM_fclose(void)
 
 	VM_SAFEPARMCOUNT(1,VM_fclose);
 
-	filenum = PRVM_G_FLOAT(OFS_PARM0);
-	if (filenum < 0 || filenum >= MAX_VMFILES)
+	filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
+	if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
 	{
-		Con_Printf("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
 		return;
 	}
-	if (VM_FILES[filenum] == NULL)
+	if (prog->openfiles[filenum] == NULL)
 	{
-		Con_Printf("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
 		return;
 	}
-	if (developer.integer)
+	FS_Close(prog->openfiles[filenum]);
+	prog->openfiles[filenum] = NULL;
+	if (developer.integer >= 100)
 		Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
-	FS_Close(VM_FILES[filenum]);
-	VM_FILES[filenum] = NULL;
 }
 
 /*
@@ -1618,21 +1696,21 @@ void VM_fgets(void)
 
 	VM_SAFEPARMCOUNT(1,VM_fgets);
 
-	filenum = PRVM_G_FLOAT(OFS_PARM0);
-	if (filenum < 0 || filenum >= MAX_VMFILES)
+	filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
+	if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
 	{
-		Con_Printf("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
 		return;
 	}
-	if (VM_FILES[filenum] == NULL)
+	if (prog->openfiles[filenum] == NULL)
 	{
-		Con_Printf("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
 		return;
 	}
 	end = 0;
 	for (;;)
 	{
-		c = FS_Getc(VM_FILES[filenum]);
+		c = FS_Getc(prog->openfiles[filenum]);
 		if (c == '\r' || c == '\n' || c < 0)
 			break;
 		if (end < VM_STRINGTEMP_LENGTH - 1)
@@ -1642,11 +1720,11 @@ void VM_fgets(void)
 	// remove \n following \r
 	if (c == '\r')
 	{
-		c = FS_Getc(VM_FILES[filenum]);
+		c = FS_Getc(prog->openfiles[filenum]);
 		if (c != '\n')
-			FS_UnGetc(VM_FILES[filenum], (unsigned char)c);
+			FS_UnGetc(prog->openfiles[filenum], (unsigned char)c);
 	}
-	if (developer.integer >= 3)
+	if (developer.integer >= 100)
 		Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
 	if (c >= 0 || end)
 		PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string);
@@ -1670,21 +1748,21 @@ void VM_fputs(void)
 
 	VM_SAFEPARMCOUNT(2,VM_fputs);
 
-	filenum = PRVM_G_FLOAT(OFS_PARM0);
-	if (filenum < 0 || filenum >= MAX_VMFILES)
+	filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
+	if (filenum < 0 || filenum >= PRVM_MAX_OPENFILES)
 	{
-		Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
 		return;
 	}
-	if (VM_FILES[filenum] == NULL)
+	if (prog->openfiles[filenum] == NULL)
 	{
-		Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
 		return;
 	}
 	VM_VarString(1, string, sizeof(string));
 	if ((stringlength = (int)strlen(string)))
-		FS_Write(VM_FILES[filenum], string, stringlength);
-	if (developer.integer)
+		FS_Write(prog->openfiles[filenum], string, stringlength);
+	if (developer.integer >= 100)
 		Con_Printf("fputs: %s: %s\n", PRVM_NAME, string);
 }
 
@@ -1709,6 +1787,138 @@ void VM_strlen(void)
 		PRVM_G_FLOAT(OFS_RETURN) = 0;
 }
 
+// DRESK - Decolorized String
+/*
+=========
+VM_strdecolorize
+
+string	strdecolorize(string s)
+=========
+*/
+// string (string s) strdecolorize = #472; // returns the passed in string with color codes stripped
+void VM_strdecolorize(void)
+{
+	char *szNewString;
+	const char *szString;
+	size_t nCnt;
+	int nPos;
+	int nFillPos;
+	int bFinished;
+		nPos = 0;
+		nFillPos = 0;
+		nCnt = 0;
+		bFinished = 0;
+
+	// Prepare Strings
+	VM_SAFEPARMCOUNT(1,VM_strdecolorize);
+	szString = PRVM_G_STRING(OFS_PARM0);
+	szNewString = VM_GetTempString();
+
+	while(!bFinished)
+	{ // Traverse through String
+		if( szString[nPos] == '\n' || szString[nPos] == '\r' || szString[nPos] <= 0)
+		{ // String End Found
+			szNewString[nFillPos++] = szString[nPos];
+			bFinished = 1;
+		}
+		else
+		if( szString[nPos] == STRING_COLOR_TAG)
+		{ // Color Code Located
+			if( szString[nPos + 1] == STRING_COLOR_TAG)
+			{ // Valid Characters to Include
+				szNewString[nFillPos++] = szString[nPos];
+				nPos = nPos + 1;
+				szNewString[nFillPos++] = szString[nPos];
+			}
+			else
+			if( szString[nPos + 1] >= '0' && szString[nPos + 1] <= '9' )
+			{ // Color Code Found; Increment Position
+				nPos = nPos + 1;
+			}
+			else
+			{ // Unknown Color Code; Include
+				szNewString[nFillPos++] = szString[nPos];
+				nPos = nPos + 1;
+			}
+		}
+		else
+			// Include Character
+			szNewString[nFillPos++] = szString[nPos];
+
+			// Increment Position
+			nPos = nPos + 1;
+	}
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(szNewString);
+}
+
+// DRESK - String Length (not counting color codes)
+/*
+=========
+VM_strlennocol
+
+float	strlennocol(string s)
+=========
+*/
+// float(string s) strlennocol = #471; // returns how many characters are in a string not including color codes
+// For example, ^2Dresk returns a length of 5
+void VM_strlennocol(void)
+{
+	const char *szString;
+	size_t nCnt;
+	int nPos;
+	int bFinished;
+		nPos = 0;
+		nCnt = 0;
+		bFinished = 0;
+
+	VM_SAFEPARMCOUNT(1,VM_strlennocol);
+
+	szString = PRVM_G_STRING(OFS_PARM0);
+	if(szString)
+	{ // Valid String
+		while(!bFinished)
+		{ // Count Characters
+			// SV_BroadcastPrintf("Position '%d'; Character '%c'; Length '%d'\n", nPos, szString[nPos], nCnt);
+
+			if( szString[nPos] == '\n' || szString[nPos] == '\r' || szString[nPos] <= 0)
+			{ // String End Found
+				// SV_BroadcastPrintf("Found End of String at '%d'\n", nPos);
+				bFinished = 1;
+			}
+			else
+			if( szString[nPos] == STRING_COLOR_TAG)
+			{ // Color Code Located
+				if( szString[nPos + 1] == STRING_COLOR_TAG)
+				{ // Increment Length; Skip Color Code
+					nCnt = nCnt + 1;
+					nPos = nPos + 1;
+				}
+				else
+				if( szString[nPos + 1] >= '0' && szString[nPos + 1] <= '9' )
+				{ // Color Code Found; Increment Position
+					// SV_BroadcastPrintf("Found Color Codes at '%d'\n", nPos);
+					nPos = nPos + 1;
+				}
+				else
+				{ // Unknown Color Code; Increment Length!
+					nPos = nPos + 1;
+					nCnt = nCnt + 1;
+				}
+			}
+			else
+				// Increment String Length
+				nCnt = nCnt + 1;
+
+			// Increment Position
+			nPos = nPos + 1;
+		}
+		PRVM_G_FLOAT(OFS_RETURN) = nCnt;
+	}
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = 0;
+}
+
 /*
 =========
 VM_strcat
@@ -1750,8 +1960,8 @@ void VM_substring(void)
 
 	string = VM_GetTempString();
 	s = PRVM_G_STRING(OFS_PARM0);
-	start = PRVM_G_FLOAT(OFS_PARM1);
-	length = PRVM_G_FLOAT(OFS_PARM2);
+	start = (int)PRVM_G_FLOAT(OFS_PARM1);
+	length = (int)PRVM_G_FLOAT(OFS_PARM2);
 	if (!s)
 		s = "";
 	for (i = 0;i < start && *s;i++, s++);
@@ -1786,17 +1996,19 @@ VM_strzone
 string	strzone(string s)
 =========
 */
-//string(string s) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
+//string(string s, ...) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
 void VM_strzone(void)
 {
-	const char *in;
 	char *out;
+	char string[VM_STRINGTEMP_LENGTH];
+	size_t alloclen;
 
 	VM_SAFEPARMCOUNT(1,VM_strzone);
 
-	in = PRVM_G_STRING(OFS_PARM0);
-	PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(strlen(in) + 1, &out);
-	strcpy(out, in);
+	VM_VarString(0, string, sizeof(string));
+	alloclen = strlen(string) + 1;
+	PRVM_G_INT(OFS_RETURN) = PRVM_AllocString(alloclen, &out);
+	memcpy(out, string, alloclen);
 }
 
 /*
@@ -1829,10 +2041,10 @@ void VM_clcommand (void)
 
 	VM_SAFEPARMCOUNT(2,VM_clcommand);
 
-	i = PRVM_G_FLOAT(OFS_PARM0);
+	i = (int)PRVM_G_FLOAT(OFS_PARM0);
 	if (!sv.active  || i < 0 || i >= svs.maxclients || !svs.clients[i].active)
 	{
-		Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
+		VM_Warning("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
 		return;
 	}
 
@@ -1868,13 +2080,15 @@ void VM_tokenize (void)
 	pos = 0;
 	while(COM_ParseToken(&p, false))
 	{
+		size_t tokenlen;
 		if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
 			break;
-		if (pos + strlen(com_token) + 1 > sizeof(tokenbuf))
+		tokenlen = strlen(com_token) + 1;
+		if (pos + tokenlen > sizeof(tokenbuf))
 			break;
 		tokens[num_tokens++] = tokenbuf + pos;
-		strcpy(tokenbuf + pos, com_token);
-		pos += strlen(com_token) + 1;
+		memcpy(tokenbuf + pos, com_token, tokenlen);
+		pos += tokenlen;
 	}
 
 	PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
@@ -1888,7 +2102,7 @@ void VM_argv (void)
 
 	VM_SAFEPARMCOUNT(1,VM_argv);
 
-	token_num = PRVM_G_FLOAT(OFS_PARM0);
+	token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
 
 	if (token_num >= 0 && token_num < num_tokens)
 		PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]);
@@ -1999,9 +2213,9 @@ void VM_getostype(void)
 	OS_MAC - not supported
 	*/
 
-#ifdef _WIN32
+#ifdef WIN32
 	PRVM_G_FLOAT(OFS_RETURN) = 0;
-#elif defined _MAC
+#elif defined(MACOSX)
 	PRVM_G_FLOAT(OFS_RETURN) = 2;
 #else
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
@@ -2075,7 +2289,7 @@ void VM_parseentitydata(void)
 	data = PRVM_G_STRING(OFS_PARM1);
 
     // parse the opening brace
-	if (!COM_ParseToken(&data, false) || com_token[0] != '{' )
+	if (!COM_ParseTokenConsole(&data) || com_token[0] != '{' )
 		PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data );
 
 	PRVM_ED_ParseEdict (data, ent);
@@ -2102,8 +2316,8 @@ void VM_loadfromfile(void)
 	// \ is a windows-ism (so it's naughty to use it, / works on all platforms)
 	if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
 	{
-		Con_Printf("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
 		PRVM_G_FLOAT(OFS_RETURN) = -4;
+		VM_Warning("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
 		return;
 	}
 
@@ -2139,17 +2353,21 @@ void VM_modulo(void)
 
 void VM_Search_Init(void)
 {
-	memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
+	int i;
+	for (i = 0;i < PRVM_MAX_OPENSEARCHES;i++)
+		prog->opensearches[i] = NULL;
 }
 
 void VM_Search_Reset(void)
 {
 	int i;
 	// reset the fssearch list
-	for(i = 0; i < MAX_VMSEARCHES; i++)
-		if(VM_SEARCHLIST[i])
-			FS_FreeSearch(VM_SEARCHLIST[i]);
-	memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
+	for(i = 0; i < PRVM_MAX_OPENSEARCHES; i++)
+	{
+		if(prog->opensearches[i])
+			FS_FreeSearch(prog->opensearches[i]);
+		prog->opensearches[i] = NULL;
+	}
 }
 
 /*
@@ -2171,21 +2389,21 @@ void VM_search_begin(void)
 
 	VM_CheckEmptyString(pattern);
 
-	caseinsens = PRVM_G_FLOAT(OFS_PARM1);
-	quiet = PRVM_G_FLOAT(OFS_PARM2);
+	caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1);
+	quiet = (int)PRVM_G_FLOAT(OFS_PARM2);
 
-	for(handle = 0; handle < MAX_VMSEARCHES; handle++)
-		if(!VM_SEARCHLIST[handle])
+	for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++)
+		if(!prog->opensearches[handle])
 			break;
 
-	if(handle >= MAX_VMSEARCHES)
+	if(handle >= PRVM_MAX_OPENSEARCHES)
 	{
-		Con_Printf("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, PRVM_MAX_OPENSEARCHES);
 		return;
 	}
 
-	if(!(VM_SEARCHLIST[handle] = FS_Search(pattern,caseinsens, quiet)))
+	if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
 	else
 		PRVM_G_FLOAT(OFS_RETURN) = handle;
@@ -2203,21 +2421,21 @@ void VM_search_end(void)
 	int handle;
 	VM_SAFEPARMCOUNT(1, VM_search_end);
 
-	handle = PRVM_G_FLOAT(OFS_PARM0);
+	handle = (int)PRVM_G_FLOAT(OFS_PARM0);
 
-	if(handle < 0 || handle >= MAX_VMSEARCHES)
+	if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
 	{
-		Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
+		VM_Warning("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
 		return;
 	}
-	if(VM_SEARCHLIST[handle] == NULL)
+	if(prog->opensearches[handle] == NULL)
 	{
-		Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
+		VM_Warning("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
 		return;
 	}
 
-	FS_FreeSearch(VM_SEARCHLIST[handle]);
-	VM_SEARCHLIST[handle] = NULL;
+	FS_FreeSearch(prog->opensearches[handle]);
+	prog->opensearches[handle] = NULL;
 }
 
 /*
@@ -2232,20 +2450,20 @@ void VM_search_getsize(void)
 	int handle;
 	VM_SAFEPARMCOUNT(1, VM_M_search_getsize);
 
-	handle = PRVM_G_FLOAT(OFS_PARM0);
+	handle = (int)PRVM_G_FLOAT(OFS_PARM0);
 
-	if(handle < 0 || handle >= MAX_VMSEARCHES)
+	if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
 	{
-		Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
+		VM_Warning("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
 		return;
 	}
-	if(VM_SEARCHLIST[handle] == NULL)
+	if(prog->opensearches[handle] == NULL)
 	{
-		Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
+		VM_Warning("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
 		return;
 	}
 
-	PRVM_G_FLOAT(OFS_RETURN) = VM_SEARCHLIST[handle]->numfilenames;
+	PRVM_G_FLOAT(OFS_RETURN) = prog->opensearches[handle]->numfilenames;
 }
 
 /*
@@ -2261,27 +2479,27 @@ void VM_search_getfilename(void)
 	char *tmp;
 	VM_SAFEPARMCOUNT(2, VM_search_getfilename);
 
-	handle = PRVM_G_FLOAT(OFS_PARM0);
-	filenum = PRVM_G_FLOAT(OFS_PARM1);
+	handle = (int)PRVM_G_FLOAT(OFS_PARM0);
+	filenum = (int)PRVM_G_FLOAT(OFS_PARM1);
 
-	if(handle < 0 || handle >= MAX_VMSEARCHES)
+	if(handle < 0 || handle >= PRVM_MAX_OPENSEARCHES)
 	{
-		Con_Printf("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
+		VM_Warning("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
 		return;
 	}
-	if(VM_SEARCHLIST[handle] == NULL)
+	if(prog->opensearches[handle] == NULL)
 	{
-		Con_Printf("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
+		VM_Warning("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
 		return;
 	}
-	if(filenum < 0 || filenum >= VM_SEARCHLIST[handle]->numfilenames)
+	if(filenum < 0 || filenum >= prog->opensearches[handle]->numfilenames)
 	{
-		Con_Printf("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
+		VM_Warning("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
 		return;
 	}
 
 	tmp = VM_GetTempString();
-	strcpy(tmp, VM_SEARCHLIST[handle]->filenames[filenum]);
+	strlcpy(tmp, prog->opensearches[handle]->filenames[filenum], VM_STRINGTEMP_LENGTH);
 
 	PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
 }
@@ -2365,7 +2583,7 @@ void VM_freepic(void)
 	s = PRVM_G_STRING(OFS_PARM0);
 
 	if(!s)
-		PRVM_ERROR ("VM_freepic: %s: NULL");
+		PRVM_ERROR ("VM_freepic: NULL");
 
 	VM_CheckEmptyString (s);
 
@@ -2389,8 +2607,8 @@ void VM_drawcharacter(void)
 	character = (char) PRVM_G_FLOAT(OFS_PARM1);
 	if(character == 0)
 	{
-		Con_Printf("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
+		VM_Warning("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
 		return;
 	}
 
@@ -2401,8 +2619,8 @@ void VM_drawcharacter(void)
 
 	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
 	{
-		Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		return;
 	}
 
@@ -2411,8 +2629,8 @@ void VM_drawcharacter(void)
 
 	if(!scale[0] || !scale[1])
 	{
-		Con_Printf("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
 		PRVM_G_FLOAT(OFS_RETURN) = -3;
+		VM_Warning("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
 		return;
 	}
 
@@ -2437,8 +2655,8 @@ void VM_drawstring(void)
 	string = PRVM_G_STRING(OFS_PARM1);
 	if(!string)
 	{
-		Con_Printf("VM_drawstring: %s passed null string !\n",PRVM_NAME);
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
+		VM_Warning("VM_drawstring: %s passed null string !\n",PRVM_NAME);
 		return;
 	}
 
@@ -2451,20 +2669,20 @@ void VM_drawstring(void)
 
 	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
 	{
-		Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		return;
 	}
 
 	if(!scale[0] || !scale[1])
 	{
-		Con_Printf("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
 		PRVM_G_FLOAT(OFS_RETURN) = -3;
+		VM_Warning("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
 		return;
 	}
 
 	if(pos[2] || scale[2])
-		Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
+		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 (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
@@ -2478,28 +2696,28 @@ float	drawpic(vector position, string pic, vector size, vector rgb, float alpha,
 */
 void VM_drawpic(void)
 {
-	const char *pic;
+	const char *picname;
 	float *size, *pos, *rgb;
 	int flag;
 
 	VM_SAFEPARMCOUNT(6,VM_drawpic);
 
-	pic = PRVM_G_STRING(OFS_PARM1);
+	picname = PRVM_G_STRING(OFS_PARM1);
 
-	if(!pic)
+	if(!picname)
 	{
-		Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
 		PRVM_G_FLOAT(OFS_RETURN) = -1;
+		VM_Warning("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
 		return;
 	}
 
-	VM_CheckEmptyString (pic);
+	VM_CheckEmptyString (picname);
 
 	// is pic cached ? no function yet for that
 	if(!1)
 	{
-		Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, pic);
 		PRVM_G_FLOAT(OFS_RETURN) = -4;
+		VM_Warning("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname);
 		return;
 	}
 
@@ -2510,15 +2728,15 @@ void VM_drawpic(void)
 
 	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
 	{
-		Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_drawpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		return;
 	}
 
 	if(pos[2] || size[2])
-		Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+		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], pic, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
+	DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
@@ -2544,15 +2762,15 @@ void VM_drawfill(void)
 
 	if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
 	{
-		Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		PRVM_G_FLOAT(OFS_RETURN) = -2;
+		VM_Warning("VM_drawfill: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
 		return;
 	}
 
 	if(pos[2] || size[2])
-		Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+		Con_Printf("VM_drawfill: 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], 0, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
+	DrawQ_Pic(pos[0], pos[1], NULL, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
 	PRVM_G_FLOAT(OFS_RETURN) = 1;
 }
 
@@ -2618,6 +2836,45 @@ void VM_getimagesize(void)
 	PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
 }
 
+/*
+=========
+VM_keynumtostring
+
+string keynumtostring(float keynum)
+=========
+*/
+void VM_keynumtostring (void)
+{
+	int keynum;
+	char *tmp;
+	VM_SAFEPARMCOUNT(1, VM_keynumtostring);
+
+	keynum = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+	tmp = VM_GetTempString();
+
+	strlcpy(tmp, Key_KeynumToString(keynum), VM_STRINGTEMP_LENGTH);
+
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
+}
+
+/*
+=========
+VM_stringtokeynum
+
+float stringtokeynum(string key)
+=========
+*/
+void VM_stringtokeynum (void)
+{
+	const char *str;
+	VM_SAFEPARMCOUNT( 1, VM_keynumtostring );
+
+	str = PRVM_G_STRING( OFS_PARM0 );
+
+	PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str );
+}
+
 // CL_Video interface functions
 
 /*
@@ -2662,7 +2919,7 @@ void VM_cin_close( void )
 	name = PRVM_G_STRING( OFS_PARM0 );
 	VM_CheckEmptyString( name );
 
-	CL_CloseVideo( CL_GetVideo( name ) );
+	CL_CloseVideo( CL_GetVideoByName( name ) );
 }
 
 /*
@@ -2684,7 +2941,7 @@ void VM_cin_setstate( void )
 
 	state = (clvideostate_t)((int)PRVM_G_FLOAT( OFS_PARM1 ));
 
-	video = CL_GetVideo( name );
+	video = CL_GetVideoByName( name );
 	if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
 		CL_SetVideoState( video, state );
 }
@@ -2706,7 +2963,7 @@ void VM_cin_getstate( void )
 	name = PRVM_G_STRING( OFS_PARM0 );
 	VM_CheckEmptyString( name );
 
-	video = CL_GetVideo( name );
+	video = CL_GetVideoByName( name );
 	if( video )
 		PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state;
 	else
@@ -2730,11 +2987,327 @@ void VM_cin_restart( void )
 	name = PRVM_G_STRING( OFS_PARM0 );
 	VM_CheckEmptyString( name );
 
-	video = CL_GetVideo( name );
+	video = CL_GetVideoByName( name );
 	if( video )
 		CL_RestartVideo( video );
 }
 
+/*
+==============
+VM_vectorvectors
+
+Writes new values for v_forward, v_up, and v_right based on the given forward vector
+vectorvectors(vector, vector)
+==============
+*/
+void VM_vectorvectors (void)
+{
+	VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), prog->globals.server->v_forward);
+	VectorVectors(prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up);
+}
+
+/*
+========================
+VM_drawline
+
+void drawline(float width, vector pos1, vector pos2, vector rgb, float alpha, float flags)
+========================
+*/
+void VM_drawline (void)
+{
+	float	*c1, *c2, *rgb;
+	float	alpha, width;
+	unsigned char	flags;
+
+	VM_SAFEPARMCOUNT(6, VM_drawline);
+	width	= PRVM_G_FLOAT(OFS_PARM0);
+	c1		= PRVM_G_VECTOR(OFS_PARM1);
+	c2		= PRVM_G_VECTOR(OFS_PARM2);
+	rgb		= PRVM_G_VECTOR(OFS_PARM3);
+	alpha	= PRVM_G_FLOAT(OFS_PARM4);
+	flags	= (int)PRVM_G_FLOAT(OFS_PARM5);
+	DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags);
+}
+
+//====================
+//QC POLYGON functions
+//====================
+
+typedef struct
+{
+	rtexture_t		*tex;
+	float			data[36];	//[515]: enough for polygons
+	unsigned char			flags;	//[515]: + VM_POLYGON_2D and VM_POLYGON_FL4V flags
+}vm_polygon_t;
+
+//static float			vm_polygon_linewidth = 1;
+static mempool_t		*vm_polygons_pool = NULL;
+static unsigned char			vm_current_vertices = 0;
+static qboolean			vm_polygons_initialized = false;
+static vm_polygon_t		*vm_polygons = NULL;
+static unsigned long	vm_polygons_num = 0, vm_drawpolygons_num = 0;	//[515]: ok long on 64bit ?
+static qboolean			vm_polygonbegin = false;	//[515]: for "no-crap-on-the-screen" check
+#define VM_DEFPOLYNUM 64	//[515]: enough for default ?
+
+#define VM_POLYGON_FL3V		16	//more than 2 vertices (used only for lines)
+#define VM_POLYGON_FLLINES	32
+#define VM_POLYGON_FL2D		64
+#define VM_POLYGON_FL4V		128	//4 vertices
+
+void VM_InitPolygons (void)
+{
+	vm_polygons_pool = Mem_AllocPool("VMPOLY", 0, NULL);
+	vm_polygons = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, VM_DEFPOLYNUM*sizeof(vm_polygon_t));
+	memset(vm_polygons, 0, VM_DEFPOLYNUM*sizeof(vm_polygon_t));
+	vm_polygons_num = VM_DEFPOLYNUM;
+	vm_drawpolygons_num = 0;
+	vm_polygonbegin = false;
+	vm_polygons_initialized = true;
+}
+
+void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
+{
+	int surfacelistindex;
+	// LordHavoc: FIXME: this is stupid code
+	for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
+	{
+		const vm_polygon_t	*p = &vm_polygons[surfacelist[surfacelistindex]];
+		int					flags = p->flags & 0x0f;
+
+		if(flags == DRAWFLAG_ADDITIVE)
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+		else if(flags == DRAWFLAG_MODULATE)
+			GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
+		else if(flags == DRAWFLAG_2XMODULATE)
+			GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
+		else
+			GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		R_Mesh_TexBind(0, R_GetTexture(p->tex));
+
+		CHECKGLERROR
+		//[515]: is speed is max ?
+		if(p->flags & VM_POLYGON_FLLINES)	//[515]: lines
+		{
+			qglLineWidth(p->data[13]);CHECKGLERROR
+			qglBegin(GL_LINE_LOOP);
+				qglTexCoord1f	(p->data[12]);
+				qglColor4f		(p->data[20], p->data[21], p->data[22], p->data[23]);
+				qglVertex3f		(p->data[0] , p->data[1],  p->data[2]);
+
+				qglTexCoord1f	(p->data[14]);
+				qglColor4f		(p->data[24], p->data[25], p->data[26], p->data[27]);
+				qglVertex3f		(p->data[3] , p->data[4],  p->data[5]);
+
+				if(p->flags & VM_POLYGON_FL3V)
+				{
+					qglTexCoord1f	(p->data[16]);
+					qglColor4f		(p->data[28], p->data[29], p->data[30], p->data[31]);
+					qglVertex3f		(p->data[6] , p->data[7],  p->data[8]);
+
+					if(p->flags & VM_POLYGON_FL4V)
+					{
+						qglTexCoord1f	(p->data[18]);
+						qglColor4f		(p->data[32], p->data[33], p->data[34], p->data[35]);
+						qglVertex3f		(p->data[9] , p->data[10],  p->data[11]);
+					}
+				}
+			qglEnd();
+			CHECKGLERROR
+		}
+		else
+		{
+			qglBegin(GL_POLYGON);
+				qglTexCoord2f	(p->data[12], p->data[13]);
+				qglColor4f		(p->data[20], p->data[21], p->data[22], p->data[23]);
+				qglVertex3f		(p->data[0] , p->data[1],  p->data[2]);
+
+				qglTexCoord2f	(p->data[14], p->data[15]);
+				qglColor4f		(p->data[24], p->data[25], p->data[26], p->data[27]);
+				qglVertex3f		(p->data[3] , p->data[4],  p->data[5]);
+
+				qglTexCoord2f	(p->data[16], p->data[17]);
+				qglColor4f		(p->data[28], p->data[29], p->data[30], p->data[31]);
+				qglVertex3f		(p->data[6] , p->data[7],  p->data[8]);
+
+				if(p->flags & VM_POLYGON_FL4V)
+				{
+					qglTexCoord2f	(p->data[18], p->data[19]);
+					qglColor4f		(p->data[32], p->data[33], p->data[34], p->data[35]);
+					qglVertex3f		(p->data[9] , p->data[10],  p->data[11]);
+				}
+			qglEnd();
+			CHECKGLERROR
+		}
+	}
+}
+
+void VM_AddPolygonTo2DScene (vm_polygon_t *p)
+{
+	drawqueuemesh_t	mesh;
+	static int		picelements[6] = {0, 1, 2, 0, 2, 3};
+
+	mesh.texture = p->tex;
+	mesh.data_element3i = picelements;
+	mesh.data_vertex3f = p->data;
+	mesh.data_texcoord2f = p->data + 12;
+	mesh.data_color4f = p->data + 20;
+	if(p->flags & VM_POLYGON_FL4V)
+	{
+		mesh.num_vertices = 4;
+		mesh.num_triangles = 2;
+	}
+	else
+	{
+		mesh.num_vertices = 3;
+		mesh.num_triangles = 1;
+	}
+	if(p->flags & VM_POLYGON_FLLINES)	//[515]: lines
+		DrawQ_LineLoop (&mesh, (p->flags&0x0f));
+	else
+		DrawQ_Mesh (&mesh, (p->flags&0x0f));
+}
+
+//void(string texturename, float flag, float 2d, float lines) R_BeginPolygon
+void VM_R_PolygonBegin (void)
+{
+	vm_polygon_t	*p;
+	const char		*picname;
+	if(prog->argc < 2)
+		VM_SAFEPARMCOUNT(2, VM_R_PolygonBegin);
+
+	if(!vm_polygons_initialized)
+		VM_InitPolygons();
+	if(vm_polygonbegin)
+	{
+		VM_Warning("VM_R_PolygonBegin: called twice without VM_R_PolygonEnd after first\n");
+		return;
+	}
+	if(vm_drawpolygons_num >= vm_polygons_num)
+	{
+		p = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, 2 * vm_polygons_num * sizeof(vm_polygon_t));
+		memset(p, 0, 2 * vm_polygons_num * sizeof(vm_polygon_t));
+		memcpy(p, vm_polygons, vm_polygons_num * sizeof(vm_polygon_t));
+		Mem_Free(vm_polygons);
+		vm_polygons = p;
+		vm_polygons_num *= 2;
+	}
+	p = &vm_polygons[vm_drawpolygons_num];
+	picname = PRVM_G_STRING(OFS_PARM0);
+	if(picname[0])
+		p->tex = Draw_CachePic(picname, true)->tex;
+	else
+		p->tex = r_texture_white;
+	p->flags = (unsigned char)PRVM_G_FLOAT(OFS_PARM1);
+	vm_current_vertices = 0;
+	vm_polygonbegin = true;
+	if(prog->argc >= 3)
+	{
+		if(PRVM_G_FLOAT(OFS_PARM2))
+			p->flags |= VM_POLYGON_FL2D;
+		if(prog->argc >= 4 && PRVM_G_FLOAT(OFS_PARM3))
+		{
+			p->data[13] = PRVM_G_FLOAT(OFS_PARM3);	//[515]: linewidth
+			p->flags |= VM_POLYGON_FLLINES;
+		}
+	}
+}
+
+//void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
+void VM_R_PolygonVertex (void)
+{
+	float			*coords, *tx, *rgb, alpha;
+	vm_polygon_t	*p;
+	VM_SAFEPARMCOUNT(4, VM_R_PolygonVertex);
+
+	if(!vm_polygonbegin)
+	{
+		VM_Warning("VM_R_PolygonVertex: VM_R_PolygonBegin wasn't called\n");
+		return;
+	}
+	coords	= PRVM_G_VECTOR(OFS_PARM0);
+	tx		= PRVM_G_VECTOR(OFS_PARM1);
+	rgb		= PRVM_G_VECTOR(OFS_PARM2);
+	alpha = PRVM_G_FLOAT(OFS_PARM3);
+
+	p = &vm_polygons[vm_drawpolygons_num];
+	if(vm_current_vertices > 4)
+	{
+		VM_Warning("VM_R_PolygonVertex: may have 4 vertices max\n");
+		return;
+	}
+
+	p->data[vm_current_vertices*3]		= coords[0];
+	p->data[1+vm_current_vertices*3]	= coords[1];
+	p->data[2+vm_current_vertices*3]	= coords[2];
+
+	p->data[12+vm_current_vertices*2]	= tx[0];
+	if(!(p->flags & VM_POLYGON_FLLINES))
+		p->data[13+vm_current_vertices*2]	= tx[1];
+
+	p->data[20+vm_current_vertices*4]	= rgb[0];
+	p->data[21+vm_current_vertices*4]	= rgb[1];
+	p->data[22+vm_current_vertices*4]	= rgb[2];
+	p->data[23+vm_current_vertices*4]	= alpha;
+
+	vm_current_vertices++;
+	if(vm_current_vertices == 4)
+		p->flags |= VM_POLYGON_FL4V;
+	else
+		if(vm_current_vertices == 3)
+			p->flags |= VM_POLYGON_FL3V;
+}
+
+//void() R_EndPolygon
+void VM_R_PolygonEnd (void)
+{
+	if(!vm_polygonbegin)
+	{
+		VM_Warning("VM_R_PolygonEnd: VM_R_PolygonBegin wasn't called\n");
+		return;
+	}
+	vm_polygonbegin = false;
+	if(vm_current_vertices > 2 || (vm_current_vertices >= 2 && vm_polygons[vm_drawpolygons_num].flags & VM_POLYGON_FLLINES))
+	{
+		if(vm_polygons[vm_drawpolygons_num].flags & VM_POLYGON_FL2D)	//[515]: don't use qcpolygons memory if 2D
+			VM_AddPolygonTo2DScene(&vm_polygons[vm_drawpolygons_num]);
+		else
+			vm_drawpolygons_num++;
+	}
+	else
+		VM_Warning("VM_R_PolygonEnd: %i vertices isn't a good choice\n", vm_current_vertices);
+}
+
+void VM_AddPolygonsToMeshQueue (void)
+{
+	unsigned int i;
+	if(!vm_drawpolygons_num)
+		return;
+	for(i = 0;i < vm_drawpolygons_num;i++)
+		VM_DrawPolygonCallback(NULL, NULL, i, NULL);
+	vm_drawpolygons_num = 0;
+}
+
+
+
+
+// float(float number, float quantity) bitshift (EXT_BITSHIFT)
+void VM_bitshift (void)
+{
+	int n1, n2;
+	VM_SAFEPARMCOUNT(2, VM_bitshift);
+
+	n1 = (int)fabs((int)PRVM_G_FLOAT(OFS_PARM0));
+	n2 = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(!n1)
+		PRVM_G_FLOAT(OFS_RETURN) = n1;
+	else
+	if(n2 < 0)
+		PRVM_G_FLOAT(OFS_RETURN) = (n1 >> -n2);
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = (n1 << n2);
+}
+
 ////////////////////////////////////////
 // AltString functions
 ////////////////////////////////////////
@@ -2818,7 +3391,7 @@ void VM_altstr_get( void )
 	altstr = PRVM_G_STRING( OFS_PARM0 );
 	//VM_CheckEmptyString( altstr );
 
-	count = PRVM_G_FLOAT( OFS_PARM1 );
+	count = (int)PRVM_G_FLOAT( OFS_PARM1 );
 	count = count * 2 + 1;
 
 	for( pos = altstr ; *pos && count ; pos++ )
@@ -2868,7 +3441,7 @@ void VM_altstr_set( void )
 	altstr = PRVM_G_STRING( OFS_PARM0 );
 	//VM_CheckEmptyString( altstr );
 
-	num = PRVM_G_FLOAT( OFS_PARM1 );
+	num = (int)PRVM_G_FLOAT( OFS_PARM1 );
 
 	str = PRVM_G_STRING( OFS_PARM2 );
 	//VM_CheckEmptyString( str );
@@ -2899,7 +3472,7 @@ void VM_altstr_set( void )
 		return;
 	}
 
-	strcpy( out, in );
+	strlcpy(out, in, VM_STRINGTEMP_LENGTH);
 	PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
 }
 
@@ -2921,7 +3494,7 @@ void VM_altstr_ins(void)
 	char *out;
 
 	in = instr = PRVM_G_STRING( OFS_PARM0 );
-	num = PRVM_G_FLOAT( OFS_PARM1 );
+	num = (int)PRVM_G_FLOAT( OFS_PARM1 );
 	set = setstr = PRVM_G_STRING( OFS_PARM2 );
 
 	out = outstr = VM_GetTempString();
@@ -2938,15 +3511,501 @@ void VM_altstr_ins(void)
 	for( ; *set ; *out++ = *set++ );
 	*out++ = '\'';
 
-	strcpy( out, in );
+	strlcpy(out, in, VM_STRINGTEMP_LENGTH);
 	PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( outstr );
 }
 
+
+////////////////////////////////////////
+// BufString functions
+////////////////////////////////////////
+//[515]: string buffers support
+#define MAX_QCSTR_BUFFERS 128
+#define MAX_QCSTR_STRINGS 1024
+
+typedef struct
+{
+	int		num_strings;
+	char	*strings[MAX_QCSTR_STRINGS];
+}qcstrbuffer_t;
+
+static qcstrbuffer_t	*qcstringbuffers[MAX_QCSTR_BUFFERS];
+static int				num_qcstringbuffers;
+static int				buf_sortpower;
+
+#define BUFSTR_BUFFER(a) (a>=MAX_QCSTR_BUFFERS) ? NULL : (qcstringbuffers[a])
+#define BUFSTR_ISFREE(a) (a<MAX_QCSTR_BUFFERS&&qcstringbuffers[a]&&qcstringbuffers[a]->num_strings<=0) ? 1 : 0
+
+static int BufStr_FindFreeBuffer (void)
+{
+	int	i;
+	if(num_qcstringbuffers == MAX_QCSTR_BUFFERS)
+		return -1;
+	for(i=0;i<MAX_QCSTR_BUFFERS;i++)
+		if(!qcstringbuffers[i])
+		{
+			qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
+			memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
+			return i;
+		}
+	return -1;
+}
+
+static void BufStr_ClearBuffer (int index)
+{
+	qcstrbuffer_t	*b = qcstringbuffers[index];
+	int				i;
+
+	if(b)
+	{
+		if(b->num_strings > 0)
+		{
+			for(i=0;i<b->num_strings;i++)
+				if(b->strings[i])
+					Z_Free(b->strings[i]);
+			num_qcstringbuffers--;
+		}
+		Z_Free(qcstringbuffers[index]);
+		qcstringbuffers[index] = NULL;
+	}
+}
+
+static int BufStr_FindFreeString (qcstrbuffer_t *b)
+{
+	int				i;
+	for(i=0;i<b->num_strings;i++)
+		if(!b->strings[i] || !b->strings[i][0])
+			return i;
+	if(i == MAX_QCSTR_STRINGS)	return -1;
+	else						return i;
+}
+
+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;
+	return strncmp(a, b, buf_sortpower);
+}
+
+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;
+	return strncmp(b, a, buf_sortpower);
+}
+
+#ifdef REMOVETHIS
+static void VM_BufStr_Init (void)
+{
+	memset(qcstringbuffers, 0, sizeof(qcstringbuffers));
+	num_qcstringbuffers = 0;
+}
+
+static void VM_BufStr_ShutDown (void)
+{
+	int i;
+	for(i=0;i<MAX_QCSTR_BUFFERS && num_qcstringbuffers;i++)
+		BufStr_ClearBuffer(i);
+}
+#endif
+
+/*
+========================
+VM_buf_create
+creates new buffer, and returns it's index, returns -1 if failed
+float buf_create(void) = #460;
+========================
+*/
+void VM_buf_create (void)
+{
+	int i;
+	VM_SAFEPARMCOUNT(0, VM_buf_create);
+	i = BufStr_FindFreeBuffer();
+	if(i >= 0)
+		num_qcstringbuffers++;
+	//else
+		//Con_Printf("VM_buf_create: buffers overflow in %s\n", PRVM_NAME);
+	PRVM_G_FLOAT(OFS_RETURN) = i;
+}
+
+/*
+========================
+VM_buf_del
+deletes buffer and all strings in it
+void buf_del(float bufhandle) = #461;
+========================
+*/
+void VM_buf_del (void)
+{
+	VM_SAFEPARMCOUNT(1, VM_buf_del);
+	if(BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0)))
+		BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0));
+	else
+	{
+		VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+}
+
+/*
+========================
+VM_buf_getsize
+how many strings are stored in buffer
+float buf_getsize(float bufhandle) = #462;
+========================
+*/
+void VM_buf_getsize (void)
+{
+	qcstrbuffer_t	*b;
+	VM_SAFEPARMCOUNT(1, VM_buf_getsize);
+
+	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!b)
+	{
+		PRVM_G_FLOAT(OFS_RETURN) = -1;
+		VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	else
+		PRVM_G_FLOAT(OFS_RETURN) = b->num_strings;
+}
+
+/*
+========================
+VM_buf_copy
+copy all content from one buffer to another, make sure it exists
+void buf_copy(float bufhandle_from, float bufhandle_to) = #463;
+========================
+*/
+void VM_buf_copy (void)
+{
+	qcstrbuffer_t	*b1, *b2;
+	int				i;
+	VM_SAFEPARMCOUNT(2, VM_buf_copy);
+
+	b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!b1)
+	{
+		VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	i = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(i == (int)PRVM_G_FLOAT(OFS_PARM0))
+	{
+		VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
+		return;
+	}
+	b2 = BUFSTR_BUFFER(i);
+	if(!b2)
+	{
+		VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
+		return;
+	}
+
+	BufStr_ClearBuffer(i);
+	qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
+	memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
+	b2->num_strings = b1->num_strings;
+
+	for(i=0;i<b1->num_strings;i++)
+		if(b1->strings[i] && b1->strings[i][0])
+		{
+			size_t stringlen;
+			stringlen = strlen(b1->strings[i]) + 1;
+			b2->strings[i] = (char *)Z_Malloc(stringlen);
+			if(!b2->strings[i])
+			{
+				VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
+				break;
+			}
+			memcpy(b2->strings[i], b1->strings[i], stringlen);
+		}
+}
+
+/*
+========================
+VM_buf_sort
+sort buffer by beginnings of strings (sortpower defaults it's lenght)
+"backward == TRUE" means that sorting goes upside-down
+void buf_sort(float bufhandle, float sortpower, float backward) = #464;
+========================
+*/
+void VM_buf_sort (void)
+{
+	qcstrbuffer_t	*b;
+	int				i;
+	VM_SAFEPARMCOUNT(3, VM_buf_sort);
+
+	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!b)
+	{
+		VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	if(b->num_strings <= 0)
+	{
+		VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(buf_sortpower <= 0)
+		buf_sortpower = 99999999;
+
+	if(!PRVM_G_FLOAT(OFS_PARM2))
+		qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsUP);
+	else
+		qsort(b->strings, b->num_strings, sizeof(char*), BufStr_SortStringsDOWN);
+
+	for(i=b->num_strings-1;i>=0;i--)	//[515]: delete empty lines
+		if(b->strings)
+		{
+			if(b->strings[i][0])
+				break;
+			else
+			{
+				Z_Free(b->strings[i]);
+				--b->num_strings;
+				b->strings[i] = NULL;
+			}
+		}
+		else
+			--b->num_strings;
+}
+
+/*
+========================
+VM_buf_implode
+concantenates all buffer string into one with "glue" separator and returns it as tempstring
+string buf_implode(float bufhandle, string glue) = #465;
+========================
+*/
+void VM_buf_implode (void)
+{
+	qcstrbuffer_t	*b;
+	char			*k;
+	const char		*sep;
+	int				i;
+	size_t			l;
+	VM_SAFEPARMCOUNT(2, VM_buf_implode);
+
+	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	PRVM_G_INT(OFS_RETURN) = 0;
+	if(!b)
+	{
+		VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	if(!b->num_strings)
+		return;
+	sep = PRVM_G_STRING(OFS_PARM1);
+	k = VM_GetTempString();
+	k[0] = 0;
+	for(l=i=0;i<b->num_strings;i++)
+		if(b->strings[i])
+		{
+			l += strlen(b->strings[i]);
+			if(l>=4095)
+				break;
+			strlcat(k, b->strings[i], VM_STRINGTEMP_LENGTH);
+			if(sep && (i != b->num_strings-1))
+			{
+				l += strlen(sep);
+				if(l>=4095)
+					break;
+				strlcat(k, sep, VM_STRINGTEMP_LENGTH);
+			}
+		}
+	PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(k);
+}
+
+/*
+========================
+VM_bufstr_get
+get a string from buffer, returns direct pointer, dont str_unzone it!
+string bufstr_get(float bufhandle, float string_index) = #465;
+========================
+*/
+void VM_bufstr_get (void)
+{
+	qcstrbuffer_t	*b;
+	int				strindex;
+	VM_SAFEPARMCOUNT(2, VM_bufstr_get);
+
+	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!b)
+	{
+		VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+	{
+		VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+		return;
+	}
+	PRVM_G_INT(OFS_RETURN) = 0;
+	if(b->num_strings <= strindex)
+		return;
+	if(b->strings[strindex])
+		PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(b->strings[strindex]);
+}
+
+/*
+========================
+VM_bufstr_set
+copies a string into selected slot of buffer
+void bufstr_set(float bufhandle, float string_index, string str) = #466;
+========================
+*/
+void VM_bufstr_set (void)
+{
+	int				bufindex, strindex;
+	qcstrbuffer_t	*b;
+	const char		*news;
+	size_t			alloclen;
+
+	VM_SAFEPARMCOUNT(3, VM_bufstr_set);
+
+	bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
+	b = BUFSTR_BUFFER(bufindex);
+	if(!b)
+	{
+		VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+		return;
+	}
+	strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
+	{
+		VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+		return;
+	}
+	news = PRVM_G_STRING(OFS_PARM2);
+	if(!news)
+	{
+		VM_Warning("VM_bufstr_set: null string used in %s\n", PRVM_NAME);
+		return;
+	}
+	if(b->strings[strindex])
+		Z_Free(b->strings[strindex]);
+	alloclen = strlen(news) + 1;
+	b->strings[strindex] = (char *)Z_Malloc(alloclen);
+	memcpy(b->strings[strindex], news, alloclen);
+}
+
+/*
+========================
+VM_bufstr_add
+adds string to buffer in nearest free slot and returns it
+"order == TRUE" means that string will be added after last "full" slot
+float bufstr_add(float bufhandle, string str, float order) = #467;
+========================
+*/
+void VM_bufstr_add (void)
+{
+	int				bufindex, order, strindex;
+	qcstrbuffer_t	*b;
+	const char		*string;
+	size_t			alloclen;
+
+	VM_SAFEPARMCOUNT(3, VM_bufstr_add);
+
+	bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
+	b = BUFSTR_BUFFER(bufindex);
+	PRVM_G_FLOAT(OFS_RETURN) = -1;
+	if(!b)
+	{
+		VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+		return;
+	}
+	string = PRVM_G_STRING(OFS_PARM1);
+	if(!string)
+	{
+		VM_Warning("VM_bufstr_add: null string used in %s\n", PRVM_NAME);
+		return;
+	}
+
+	order = (int)PRVM_G_FLOAT(OFS_PARM2);
+	if(order)
+		strindex = b->num_strings;
+	else
+	{
+		strindex = BufStr_FindFreeString(b);
+		if(strindex < 0)
+		{
+			VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
+			return;
+		}
+	}
+
+	while(b->num_strings <= strindex)
+	{
+		if(b->num_strings == MAX_QCSTR_STRINGS)
+		{
+			VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
+			return;
+		}
+		b->strings[b->num_strings] = NULL;
+		b->num_strings++;
+	}
+	if(b->strings[strindex])
+		Z_Free(b->strings[strindex]);
+	alloclen = strlen(string) + 1;
+	b->strings[strindex] = (char *)Z_Malloc(alloclen);
+	memcpy(b->strings[strindex], string, alloclen);
+	PRVM_G_FLOAT(OFS_RETURN) = strindex;
+}
+
+/*
+========================
+VM_bufstr_free
+delete string from buffer
+void bufstr_free(float bufhandle, float string_index) = #468;
+========================
+*/
+void VM_bufstr_free (void)
+{
+	int				i;
+	qcstrbuffer_t	*b;
+	VM_SAFEPARMCOUNT(2, VM_bufstr_free);
+
+	b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
+	if(!b)
+	{
+		VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+		return;
+	}
+	i = (int)PRVM_G_FLOAT(OFS_PARM1);
+	if(i < 0 || i > MAX_QCSTR_STRINGS)
+	{
+		VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
+		return;
+	}
+	if(b->strings[i])
+		Z_Free(b->strings[i]);
+	b->strings[i] = NULL;
+	if(i+1 == b->num_strings)
+		--b->num_strings;
+}
+
+//=============
+
 void VM_Cmd_Init(void)
 {
 	// only init the stuff for the current prog
 	VM_Files_Init();
 	VM_Search_Init();
+//	VM_BufStr_Init();
+	if(vm_polygons_initialized)
+	{
+		Mem_FreePool(&vm_polygons_pool);
+		vm_polygons_initialized = false;
+	}
 }
 
 void VM_Cmd_Reset(void)
@@ -2954,6 +4013,11 @@ void VM_Cmd_Reset(void)
 	CL_PurgeOwner( MENUOWNER );
 	VM_Search_Reset();
 	VM_Files_CloseAll();
+//	VM_BufStr_ShutDown();
+	if(vm_polygons_initialized)
+	{
+		Mem_FreePool(&vm_polygons_pool);
+		vm_polygons_initialized = false;
+	}
 }
 
-