X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_edict.c;h=d00023dd11ee68e2d101f0c93ce773e491f41dd0;hp=5da0a8fbd6adaf0a0e34050bd70d2274aaff5166;hb=a19aff1dcea954e83a41c92af13882234c7fc9fd;hpb=d05ade804ec1789157049868deef2fc1aa09f45f

diff --git a/prvm_edict.c b/prvm_edict.c
index 5da0a8fb..d00023dd 100644
--- a/prvm_edict.c
+++ b/prvm_edict.c
@@ -31,21 +31,22 @@ int		prvm_type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(v
 ddef_t *PRVM_ED_FieldAtOfs(int ofs);
 qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash);
 
+cvar_t prvm_language = {CVAR_SAVE, "prvm_language", "", "when set, loads progs.dat.LANGUAGENAME.po for string translations; when set to dump, progs.dat.pot is written from the strings in the progs"};
 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
 cvar_t prvm_traceqc = {0, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"};
 // LordHavoc: counts usage of each QuakeC statement
 cvar_t prvm_statementprofiling = {0, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"};
+cvar_t prvm_timeprofiling = {0, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"};
 cvar_t prvm_backtraceforwarnings = {0, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"};
 cvar_t prvm_leaktest = {0, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"};
 cvar_t prvm_leaktest_ignore_classnames = {0, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"};
 cvar_t prvm_errordump = {0, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"};
+cvar_t prvm_reuseedicts_startuptime = {0, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"};
+cvar_t prvm_reuseedicts_neverinsameframe = {0, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"};
 
+static double prvm_reuseedicts_always_allow = 0;
 qboolean prvm_runawaycheck = true;
 
-// LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
-// enables detection of out of bounds memory access in the QuakeC code being run (in other words, prevents really exceedingly bad QuakeC code from doing nasty things to your computer)
-qboolean prvm_boundscheck = true;
-
 extern sizebuf_t vm_tempstringsbuf;
 
 //============================================================================
@@ -75,13 +76,14 @@ void PRVM_MEM_Alloc(void)
 	prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
 
 	// alloc edict fields
-	prog->edictsfields = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edict_size);
+	prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
+	prog->edictsfields = (vec_t *)Mem_Alloc(prog->progs_mempool, prog->entityfieldsarea * sizeof(vec_t));
 
 	// set edict pointers
 	for(i = 0; i < prog->max_edicts; i++)
 	{
 		prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
-		prog->edicts[i].fields.vp = (void*)((unsigned char *)prog->edictsfields + i * prog->edict_size);
+		prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
 	}
 }
 
@@ -93,9 +95,6 @@ PRVM_MEM_IncreaseEdicts
 void PRVM_MEM_IncreaseEdicts(void)
 {
 	int		i;
-	int		oldmaxedicts = prog->max_edicts;
-	void	*oldedictsfields = prog->edictsfields;
-	void	*oldedictprivate = prog->edictprivate;
 
 	if(prog->max_edicts >= prog->limit_edicts)
 		return;
@@ -105,23 +104,18 @@ void PRVM_MEM_IncreaseEdicts(void)
 	// increase edicts
 	prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
 
-	prog->edictsfields = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edict_size);
-	prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
-
-	memcpy(prog->edictsfields, oldedictsfields, oldmaxedicts * prog->edict_size);
-	memcpy(prog->edictprivate, oldedictprivate, oldmaxedicts * prog->edictprivate_size);
+	prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
+	prog->edictsfields = (vec_t*)Mem_Realloc(prog->progs_mempool, (void *)prog->edictsfields, prog->entityfieldsarea * sizeof(vec_t));
+	prog->edictprivate = (void *)Mem_Realloc(prog->progs_mempool, (void *)prog->edictprivate, prog->max_edicts * prog->edictprivate_size);
 
 	//set e and v pointers
 	for(i = 0; i < prog->max_edicts; i++)
 	{
 		prog->edicts[i].priv.required  = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
-		prog->edicts[i].fields.vp = (void*)((unsigned char *)prog->edictsfields + i * prog->edict_size);
+		prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
 	}
 
 	PRVM_GCALL(end_increase_edicts)();
-
-	Mem_Free(oldedictsfields);
-	Mem_Free(oldedictprivate);
 }
 
 //============================================================================
@@ -224,7 +218,7 @@ void PRVM_ED_ClearEdict (prvm_edict_t *e)
 	PRVM_GCALL(init_edict)(e);
 }
 
-const char *PRVM_AllocationOrigin()
+const char *PRVM_AllocationOrigin(void)
 {
 	char *buf = NULL;
 	if(prog->leaktest_active)
@@ -247,7 +241,11 @@ qboolean PRVM_ED_CanAlloc(prvm_edict_t *e)
 {
 	if(!e->priv.required->free)
 		return false;
-	if(e->priv.required->freetime < prog->starttime + 2)
+	if(prvm_reuseedicts_always_allow == realtime)
+		return true;
+	if(realtime <= e->priv.required->freetime && prvm_reuseedicts_neverinsameframe.integer)
+		return false; // never allow reuse in same frame (causes networking trouble)
+	if(e->priv.required->freetime < prog->starttime + prvm_reuseedicts_startuptime.value)
 		return true;
 	if(realtime > e->priv.required->freetime + 1)
 		return true;
@@ -448,7 +446,7 @@ char *PRVM_ValueString (etype_t type, prvm_eval_t *val)
 		break;
 	case ev_entity:
 		n = val->edict;
-		if (n < 0 || n >= prog->limit_edicts)
+		if (n < 0 || n >= prog->max_edicts)
 			dpsnprintf (line, sizeof(line), "entity %i (invalid!)", n);
 		else
 			dpsnprintf (line, sizeof(line), "entity %i", n);
@@ -551,10 +549,10 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val)
 		dpsnprintf (line, sizeof (line), "void");
 		break;
 	case ev_float:
-		dpsnprintf (line, sizeof (line), "%f", val->_float);
+		dpsnprintf (line, sizeof (line), "%.9g", val->_float);
 		break;
 	case ev_vector:
-		dpsnprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
+		dpsnprintf (line, sizeof (line), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]);
 		break;
 	default:
 		dpsnprintf (line, sizeof (line), "bad type %i", type);
@@ -650,7 +648,7 @@ void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname)
 	{
 		d = &prog->fielddefs[i];
 		name = PRVM_GetString(d->s_name);
-		if (name[strlen(name)-2] == '_')
+		if(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z')
 			continue;	// skip _x, _y, _z vars
 
 		// Check Field Name Wildcard
@@ -659,7 +657,7 @@ void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname)
 				// Didn't match; skip
 				continue;
 
-		v = (int *)((char *)ed->fields.vp + d->ofs*4);
+		v = (int *)(ed->fields.vp + d->ofs);
 
 	// if the value is still all 0, skip the field
 		type = d->type & ~DEF_SAVEGLOBAL;
@@ -734,10 +732,11 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 		if(developer_entityparsing.integer)
 			Con_Printf("PRVM_ED_Write: at entity %d field %s\n", PRVM_NUM_FOR_EDICT(ed), name);
 
-		if (name[strlen(name)-2] == '_')
-			continue;	// skip _x, _y, _z vars
+		//if(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z')
+		if(strlen(name) > 1 && name[strlen(name)-2] == '_')
+			continue;	// skip _x, _y, _z vars, and ALSO other _? vars as some mods expect them to be never saved (TODO: a gameplayfix for using the "more precise" condition above?)
 
-		v = (int *)((char *)ed->fields.vp + d->ofs*4);
+		v = (int *)(ed->fields.vp + d->ofs);
 
 	// if the value is still all 0, skip the field
 		type = d->type & ~DEF_SAVEGLOBAL;
@@ -991,9 +990,9 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qbool
 	mfunction_t *func;
 
 	if (ent)
-		val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
+		val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
 	else
-		val = (prvm_eval_t *)((int *)prog->globals.generic + key->ofs);
+		val = (prvm_eval_t *)(prog->globals.generic + key->ofs);
 	switch (key->type & ~DEF_SAVEGLOBAL)
 	{
 	case ev_string:
@@ -1042,12 +1041,12 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qbool
 			s++;
 		i = atoi(s);
 		if (i >= prog->limit_edicts)
-			Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, (unsigned int)MAX_EDICTS, PRVM_NAME);
+			Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, prog->limit_edicts, PRVM_NAME);
 		while (i >= prog->max_edicts)
 			PRVM_MEM_IncreaseEdicts();
 		// if IncreaseEdicts was called the base pointer needs to be updated
 		if (ent)
-			val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
+			val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
 		val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i));
 		break;
 
@@ -1148,6 +1147,105 @@ void PRVM_GameCommand_Menu_f(void)
 	PRVM_GameCommand("menu", "menu_cmd");
 }
 
+/*
+=============
+PRVM_ED_EdictGet_f
+
+Console command to load a field of a specified edict
+=============
+*/
+void PRVM_ED_EdictGet_f(void)
+{
+	prvm_edict_t *ed;
+	ddef_t *key;
+	const char *s;
+	prvm_eval_t *v;
+
+	if(Cmd_Argc() != 4 && Cmd_Argc() != 5)
+	{
+		Con_Print("prvm_edictget <program name> <edict number> <field> [<cvar>]\n");
+		return;
+	}
+
+	PRVM_Begin;
+	if(!PRVM_SetProgFromString(Cmd_Argv(1)))
+	{
+		Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
+		return;
+	}
+
+	ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
+
+	if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0)
+	{
+		Con_Printf("Key %s not found !\n", Cmd_Argv(3));
+		goto fail;
+	}
+
+	v = (prvm_eval_t *)(ed->fields.vp + key->ofs);
+	s = PRVM_UglyValueString((etype_t)key->type, v);
+	if(Cmd_Argc() == 5)
+	{
+		cvar_t *cvar = Cvar_FindVar(Cmd_Argv(4));
+		if (cvar && cvar->flags & CVAR_READONLY)
+		{
+			Con_Printf("prvm_edictget: %s is read-only\n", cvar->name);
+			goto fail;
+		}
+		Cvar_Get(Cmd_Argv(4), s, 0, NULL);
+	}
+	else
+		Con_Printf("%s\n", s);
+
+fail:
+	PRVM_End;
+}
+
+void PRVM_ED_GlobalGet_f(void)
+{
+	ddef_t *key;
+	const char *s;
+	prvm_eval_t *v;
+
+	if(Cmd_Argc() != 3 && Cmd_Argc() != 4)
+	{
+		Con_Print("prvm_globalget <program name> <global> [<cvar>]\n");
+		return;
+	}
+
+	PRVM_Begin;
+	if(!PRVM_SetProgFromString(Cmd_Argv(1)))
+	{
+		Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
+		return;
+	}
+
+	key = PRVM_ED_FindGlobal(Cmd_Argv(2));
+	if(!key)
+	{
+		Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
+		goto fail;
+	}
+
+	v = (prvm_eval_t *) &prog->globals.generic[key->ofs];
+	s = PRVM_UglyValueString((etype_t)key->type, v);
+	if(Cmd_Argc() == 4)
+	{
+		cvar_t *cvar = Cvar_FindVar(Cmd_Argv(3));
+		if (cvar && cvar->flags & CVAR_READONLY)
+		{
+			Con_Printf("prvm_globalget: %s is read-only\n", cvar->name);
+			goto fail;
+		}
+		Cvar_Get(Cmd_Argv(3), s, 0, NULL);
+	}
+	else
+		Con_Printf("%s\n", s);
+
+fail:
+	PRVM_End;
+}
+
 /*
 =============
 PRVM_ED_EdictSet_f
@@ -1309,6 +1407,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 	spawned = 0;
 	died = 0;
 
+	prvm_reuseedicts_always_allow = realtime;
 
 // parse ents
 	while (1)
@@ -1389,7 +1488,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 				}
 				else
 				{
-					if (developer.integer) // don't confuse non-developers with errors
+					if (developer.integer > 0) // don't confuse non-developers with errors
 					{
 						Con_Print("No spawn function for:\n");
 						PRVM_ED_Print(ent, NULL);
@@ -1420,6 +1519,8 @@ void PRVM_ED_LoadFromFile (const char *data)
 	}
 
 	Con_DPrintf("%s: %i new entities parsed, %i new inhibited, %i (%i new) spawned (whereas %i removed self, %i stayed)\n", PRVM_NAME, parsed, inhibited, prog->num_edicts, spawned, died, spawned - died);
+
+	prvm_reuseedicts_always_allow = 0;
 }
 
 void PRVM_FindOffsets(void)
@@ -1476,6 +1577,7 @@ void PRVM_FindOffsets(void)
 	prog->fieldoffsets.dimension_hit                  = PRVM_ED_FindFieldOffset("dimension_hit");
 	prog->fieldoffsets.dimension_solid                = PRVM_ED_FindFieldOffset("dimension_solid");
 	prog->fieldoffsets.disableclientprediction        = PRVM_ED_FindFieldOffset("disableclientprediction");
+	prog->fieldoffsets.discardabledemo                = PRVM_ED_FindFieldOffset("discardabledemo");
 	prog->fieldoffsets.dphitcontentsmask              = PRVM_ED_FindFieldOffset("dphitcontentsmask");
 	prog->fieldoffsets.drawonlytoclient               = PRVM_ED_FindFieldOffset("drawonlytoclient");
 	prog->fieldoffsets.exteriormodeltoclient          = PRVM_ED_FindFieldOffset("exteriormodeltoclient");
@@ -1493,6 +1595,7 @@ void PRVM_FindOffsets(void)
 	prog->fieldoffsets.glow_color                     = PRVM_ED_FindFieldOffset("glow_color");
 	prog->fieldoffsets.glow_size                      = PRVM_ED_FindFieldOffset("glow_size");
 	prog->fieldoffsets.glow_trail                     = PRVM_ED_FindFieldOffset("glow_trail");
+	prog->fieldoffsets.glowmod                        = PRVM_ED_FindFieldOffset("glowmod");
 	prog->fieldoffsets.gravity                        = PRVM_ED_FindFieldOffset("gravity");
 	prog->fieldoffsets.groundentity                   = PRVM_ED_FindFieldOffset("groundentity");
 	prog->fieldoffsets.hull                           = PRVM_ED_FindFieldOffset("hull");
@@ -1512,6 +1615,8 @@ void PRVM_FindOffsets(void)
 	prog->fieldoffsets.nodrawtoclient                 = PRVM_ED_FindFieldOffset("nodrawtoclient");
 	prog->fieldoffsets.pflags                         = PRVM_ED_FindFieldOffset("pflags");
 	prog->fieldoffsets.ping                           = PRVM_ED_FindFieldOffset("ping");
+	prog->fieldoffsets.packetloss                     = PRVM_ED_FindFieldOffset("ping_packetloss");
+	prog->fieldoffsets.movementloss                   = PRVM_ED_FindFieldOffset("ping_movementloss");
 	prog->fieldoffsets.pitch_speed                    = PRVM_ED_FindFieldOffset("pitch_speed");
 	prog->fieldoffsets.playermodel                    = PRVM_ED_FindFieldOffset("playermodel");
 	prog->fieldoffsets.playerskin                     = PRVM_ED_FindFieldOffset("playerskin");
@@ -1522,6 +1627,7 @@ void PRVM_FindOffsets(void)
 	prog->fieldoffsets.rendermode                     = PRVM_ED_FindFieldOffset("rendermode"); // HalfLife support
 	prog->fieldoffsets.scale                          = PRVM_ED_FindFieldOffset("scale");
 	prog->fieldoffsets.shadertime                     = PRVM_ED_FindFieldOffset("shadertime");
+	prog->fieldoffsets.skeletonindex                  = PRVM_ED_FindFieldOffset("skeletonindex");
 	prog->fieldoffsets.style                          = PRVM_ED_FindFieldOffset("style");
 	prog->fieldoffsets.tag_entity                     = PRVM_ED_FindFieldOffset("tag_entity");
 	prog->fieldoffsets.tag_index                      = PRVM_ED_FindFieldOffset("tag_index");
@@ -1531,6 +1637,38 @@ void PRVM_FindOffsets(void)
 	prog->fieldoffsets.yaw_speed                      = PRVM_ED_FindFieldOffset("yaw_speed");
 	prog->fieldoffsets.bouncefactor                   = PRVM_ED_FindFieldOffset("bouncefactor");
 	prog->fieldoffsets.bouncestop                     = PRVM_ED_FindFieldOffset("bouncestop");
+
+	prog->fieldoffsets.solid                          = PRVM_ED_FindFieldOffset("solid");
+	prog->fieldoffsets.movetype                       = PRVM_ED_FindFieldOffset("movetype");
+	prog->fieldoffsets.modelindex                     = PRVM_ED_FindFieldOffset("modelindex");
+	prog->fieldoffsets.mins                           = PRVM_ED_FindFieldOffset("mins");
+	prog->fieldoffsets.maxs                           = PRVM_ED_FindFieldOffset("maxs");
+	prog->fieldoffsets.mass                           = PRVM_ED_FindFieldOffset("mass");
+	prog->fieldoffsets.origin                         = PRVM_ED_FindFieldOffset("origin");
+	prog->fieldoffsets.velocity                       = PRVM_ED_FindFieldOffset("velocity");
+	//prog->fieldoffsets.axis_forward                   = PRVM_ED_FindFieldOffset("axis_forward");
+	//prog->fieldoffsets.axis_left                      = PRVM_ED_FindFieldOffset("axis_left");
+	//prog->fieldoffsets.axis_up                        = PRVM_ED_FindFieldOffset("axis_up");
+	//prog->fieldoffsets.spinvelocity                   = PRVM_ED_FindFieldOffset("spinvelocity");
+	prog->fieldoffsets.angles                         = PRVM_ED_FindFieldOffset("angles");
+	prog->fieldoffsets.avelocity                      = PRVM_ED_FindFieldOffset("avelocity");
+	prog->fieldoffsets.aiment                         = PRVM_ED_FindFieldOffset("aiment");
+	prog->fieldoffsets.enemy                          = PRVM_ED_FindFieldOffset("enemy");
+	prog->fieldoffsets.jointtype                      = PRVM_ED_FindFieldOffset("jointtype");
+	prog->fieldoffsets.movedir                        = PRVM_ED_FindFieldOffset("movedir");
+
+	prog->fieldoffsets.camera_transform               = PRVM_ED_FindFieldOffset("camera_transform");
+	prog->fieldoffsets.userwavefunc_param0            = PRVM_ED_FindFieldOffset("userwavefunc_param0");
+	prog->fieldoffsets.userwavefunc_param1            = PRVM_ED_FindFieldOffset("userwavefunc_param1");
+	prog->fieldoffsets.userwavefunc_param2            = PRVM_ED_FindFieldOffset("userwavefunc_param2");
+	prog->fieldoffsets.userwavefunc_param3            = PRVM_ED_FindFieldOffset("userwavefunc_param3");
+
+	prog->fieldoffsets.crypto_keyfp                   = PRVM_ED_FindFieldOffset("crypto_keyfp");
+	prog->fieldoffsets.crypto_mykeyfp                 = PRVM_ED_FindFieldOffset("crypto_mykeyfp");
+	prog->fieldoffsets.crypto_idfp                    = PRVM_ED_FindFieldOffset("crypto_idfp");
+	prog->fieldoffsets.crypto_encryptmethod           = PRVM_ED_FindFieldOffset("crypto_encryptmethod");
+	prog->fieldoffsets.crypto_signmethod              = PRVM_ED_FindFieldOffset("crypto_signmethod");
+
 	prog->funcoffsets.CSQC_ConsoleCommand             = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand");
 	prog->funcoffsets.CSQC_Ent_Remove                 = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove");
 	prog->funcoffsets.CSQC_Ent_Spawn                  = PRVM_ED_FindFunctionOffset("CSQC_Ent_Spawn");
@@ -1565,12 +1703,14 @@ void PRVM_FindOffsets(void)
 	prog->globaloffsets.dmg_save                      = PRVM_ED_FindGlobalOffset("dmg_save");
 	prog->globaloffsets.dmg_take                      = PRVM_ED_FindGlobalOffset("dmg_take");
 	prog->globaloffsets.drawfont                      = PRVM_ED_FindGlobalOffset("drawfont");
+	prog->globaloffsets.drawfontscale                 = PRVM_ED_FindGlobalOffset("drawfontscale");
 	prog->globaloffsets.gettaginfo_forward            = PRVM_ED_FindGlobalOffset("gettaginfo_forward");
 	prog->globaloffsets.gettaginfo_name               = PRVM_ED_FindGlobalOffset("gettaginfo_name");
 	prog->globaloffsets.gettaginfo_offset             = PRVM_ED_FindGlobalOffset("gettaginfo_offset");
 	prog->globaloffsets.gettaginfo_parent             = PRVM_ED_FindGlobalOffset("gettaginfo_parent");
 	prog->globaloffsets.gettaginfo_right              = PRVM_ED_FindGlobalOffset("gettaginfo_right");
 	prog->globaloffsets.gettaginfo_up                 = PRVM_ED_FindGlobalOffset("gettaginfo_up");
+	prog->globaloffsets.transparent_offset            = PRVM_ED_FindGlobalOffset("transparent_offset");
 	prog->globaloffsets.intermission                  = PRVM_ED_FindGlobalOffset("intermission");
 	prog->globaloffsets.require_spawnfunc_prefix      = PRVM_ED_FindGlobalOffset("require_spawnfunc_prefix");
 	prog->globaloffsets.sb_showscores                 = PRVM_ED_FindGlobalOffset("sb_showscores");
@@ -1597,7 +1737,13 @@ void PRVM_FindOffsets(void)
 	prog->globaloffsets.v_right                       = PRVM_ED_FindGlobalOffset("v_right");
 	prog->globaloffsets.v_up                          = PRVM_ED_FindGlobalOffset("v_up");
 	prog->globaloffsets.view_angles                   = PRVM_ED_FindGlobalOffset("view_angles");
+	prog->globaloffsets.view_punchangle               = PRVM_ED_FindGlobalOffset("view_punchangle");
+	prog->globaloffsets.view_punchvector              = PRVM_ED_FindGlobalOffset("view_punchvector");
 	prog->globaloffsets.worldstatus                   = PRVM_ED_FindGlobalOffset("worldstatus");
+	prog->globaloffsets.particles_alphamin            = PRVM_ED_FindGlobalOffset("particles_alphamin");
+	prog->globaloffsets.particles_alphamax            = PRVM_ED_FindGlobalOffset("particles_alphamax");
+	prog->globaloffsets.particles_colormin            = PRVM_ED_FindGlobalOffset("particles_colormin");
+	prog->globaloffsets.particles_colormax            = PRVM_ED_FindGlobalOffset("particles_colormax");
 
 	// menu qc only uses some functions, nothing else
 	prog->funcoffsets.m_draw                          = PRVM_ED_FindFunctionOffset("m_draw");
@@ -1606,6 +1752,7 @@ void PRVM_FindOffsets(void)
 	prog->funcoffsets.m_keyup                         = PRVM_ED_FindFunctionOffset("m_keyup");
 	prog->funcoffsets.m_shutdown                      = PRVM_ED_FindFunctionOffset("m_shutdown");
 	prog->funcoffsets.m_toggle                        = PRVM_ED_FindFunctionOffset("m_toggle");
+	prog->funcoffsets.m_newmap                        = PRVM_ED_FindFunctionOffset("m_newmap");
 }
 
 // not used
@@ -1630,12 +1777,255 @@ PRVM_ResetProg
 ===============
 */
 
-void PRVM_LeakTest();
-void PRVM_ResetProg()
+#define PO_HASHSIZE 16384
+typedef struct po_string_s
+{
+	char *key, *value;
+	struct po_string_s *nextonhashchain;
+}
+po_string_t;
+typedef struct po_s
+{
+	po_string_t *hashtable[PO_HASHSIZE];
+}
+po_t;
+void PRVM_PO_UnparseString(char *out, const char *in, size_t outsize)
+{
+	for(;;)
+	{
+		switch(*in)
+		{
+			case 0:
+				*out++ = 0;
+				return;
+			case '\a': if(outsize >= 2) { *out++ = '\\'; *out++ = 'a'; outsize -= 2; } break;
+			case '\b': if(outsize >= 2) { *out++ = '\\'; *out++ = 'b'; outsize -= 2; } break;
+			case '\t': if(outsize >= 2) { *out++ = '\\'; *out++ = 't'; outsize -= 2; } break;
+			case '\r': if(outsize >= 2) { *out++ = '\\'; *out++ = 'r'; outsize -= 2; } break;
+			case '\n': if(outsize >= 2) { *out++ = '\\'; *out++ = 'n'; outsize -= 2; } break;
+			case '\\': if(outsize >= 2) { *out++ = '\\'; *out++ = '\\'; outsize -= 2; } break;
+			case '"': if(outsize >= 2) { *out++ = '\\'; *out++ = '"'; outsize -= 2; } break;
+			default:
+				if(*in >= 0 && *in <= 0x1F)
+				{
+					if(outsize >= 4)
+					{
+						*out++ = '\\';
+						*out++ = '0' + ((*in & 0700) >> 6);
+						*out++ = '0' + ((*in & 0070) >> 3);
+						*out++ = '0' + ((*in & 0007));
+						outsize -= 4;
+					}
+				}
+				else
+				{
+					if(outsize >= 1)
+					{
+						*out++ = *in;
+						outsize -= 1;
+					}
+				}
+				break;
+		}
+		++in;
+	}
+}
+void PRVM_PO_ParseString(char *out, const char *in, size_t outsize)
+{
+	for(;;)
+	{
+		switch(*in)
+		{
+			case 0:
+				*out++ = 0;
+				return;
+			case '\\':
+				++in;
+				switch(*in)
+				{
+					case 'a': if(outsize > 0) { *out++ = '\a'; --outsize; } break;
+					case 'b': if(outsize > 0) { *out++ = '\b'; --outsize; } break;
+					case 't': if(outsize > 0) { *out++ = '\t'; --outsize; } break;
+					case 'r': if(outsize > 0) { *out++ = '\r'; --outsize; } break;
+					case 'n': if(outsize > 0) { *out++ = '\n'; --outsize; } break;
+					case '\\': if(outsize > 0) { *out++ = '\\'; --outsize; } break;
+					case '"': if(outsize > 0) { *out++ = '"'; --outsize; } break;
+					case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
+						if(outsize > 0) 
+							*out = *in - '0';
+						++in;
+						if(*in >= '0' && *in <= '7')
+						{
+							if(outsize > 0)
+								*out = (*out << 3) | (*in - '0');
+							++in;
+						}
+						if(*in >= '0' && *in <= '7')
+						{
+							if(outsize > 0)
+								*out = (*out << 3) | (*in - '0');
+							++in;
+						}
+						--in;
+						if(outsize > 0)
+						{
+							++out;
+							--outsize;
+						}
+						break;
+					default:
+						if(outsize > 0) { *out++ = *in; --outsize; }
+						break;
+				}
+				break;
+			default:
+				if(outsize > 0)
+				{
+					*out++ = *in;
+					--outsize;
+				}
+				break;
+		}
+		++in;
+	}
+}
+po_t *PRVM_PO_Load(const char *filename, mempool_t *pool)
+{
+	po_t *po;
+	const char *p, *q;
+	int mode;
+	char inbuf[MAX_INPUTLINE];
+	char decodedbuf[MAX_INPUTLINE];
+	size_t decodedpos;
+	int hashindex;
+	po_string_t thisstr;
+	const char *buf = (const char *) FS_LoadFile(filename, pool, true, NULL);
+
+	if(!buf)
+		return NULL;
+
+	memset(&thisstr, 0, sizeof(thisstr)); // hush compiler warning
+
+	po = (po_t *)Mem_Alloc(pool, sizeof(*po));
+	memset(po, 0, sizeof(*po));
+
+	p = buf;
+	while(*p)
+	{
+		if(*p == '#')
+		{
+			// skip to newline
+			p = strchr(p, '\n');
+			if(!p)
+				break;
+			++p;
+			continue;
+		}
+		if(*p == '\r' || *p == '\n')
+		{
+			++p;
+			continue;
+		}
+		if(!strncmp(p, "msgid \"", 7))
+		{
+			mode = 0;
+			p += 6;
+		}
+		else if(!strncmp(p, "msgstr \"", 8))
+		{
+			mode = 1;
+			p += 7;
+		}
+		else
+		{
+			p = strchr(p, '\n');
+			if(!p)
+				break;
+			++p;
+			continue;
+		}
+		decodedpos = 0;
+		while(*p == '"')
+		{
+			++p;
+			q = strchr(p, '\n');
+			if(!q)
+				break;
+			if(*(q-1) == '\r')
+				--q;
+			if(*(q-1) != '"')
+				break;
+			if((size_t)(q - p) >= (size_t) sizeof(inbuf))
+				break;
+			strlcpy(inbuf, p, q - p); // not - 1, because this adds a NUL
+			PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos);
+			decodedpos += strlen(decodedbuf + decodedpos);
+			if(*q == '\r')
+				++q;
+			if(*q == '\n')
+				++q;
+			p = q;
+		}
+		if(mode == 0)
+		{
+			if(thisstr.key)
+				Mem_Free(thisstr.key);
+			thisstr.key = (char *)Mem_Alloc(pool, decodedpos + 1);
+			memcpy(thisstr.key, decodedbuf, decodedpos + 1);
+		}
+		else if(decodedpos > 0 && thisstr.key) // skip empty translation results
+		{
+			thisstr.value = (char *)Mem_Alloc(pool, decodedpos + 1);
+			memcpy(thisstr.value, decodedbuf, decodedpos + 1);
+			hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE;
+			thisstr.nextonhashchain = po->hashtable[hashindex];
+			po->hashtable[hashindex] = (po_string_t *)Mem_Alloc(pool, sizeof(thisstr));
+			memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr));
+			memset(&thisstr, 0, sizeof(thisstr));
+		}
+	}
+	
+	Mem_Free((char *) buf);
+	return po;
+}
+const char *PRVM_PO_Lookup(po_t *po, const char *str)
+{
+	int hashindex = CRC_Block((const unsigned char *) str, strlen(str)) % PO_HASHSIZE;
+	po_string_t *p = po->hashtable[hashindex];
+	while(p)
+	{
+		if(!strcmp(str, p->key))
+			return p->value;
+		p = p->nextonhashchain;
+	}
+	return NULL;
+}
+void PRVM_PO_Destroy(po_t *po)
+{
+	int i;
+	for(i = 0; i < PO_HASHSIZE; ++i)
+	{
+		po_string_t *p = po->hashtable[i];
+		while(p)
+		{
+			po_string_t *q = p;
+			p = p->nextonhashchain;
+			Mem_Free(q->key);
+			Mem_Free(q->value);
+			Mem_Free(q);
+		}
+	}
+	Mem_Free(po);
+}
+
+void PRVM_LeakTest(void);
+void PRVM_ResetProg(void)
 {
 	PRVM_LeakTest();
 	PRVM_GCALL(reset_cmd)();
 	Mem_FreePool(&prog->progs_mempool);
+	if(prog->po)
+		PRVM_PO_Destroy((po_t *) prog->po);
 	memset(prog,0,sizeof(prvm_prog_t));
 	prog->starttime = Sys_DoubleTime();
 }
@@ -1692,7 +2082,7 @@ void PRVM_LoadLNO( const char *progname ) {
 PRVM_LoadProgs
 ===============
 */
-void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global)
+void PRVM_LoadProgs (const char * filename, int numrequiredfunc, const char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global)
 {
 	int i;
 	dstatement_t *st;
@@ -1707,6 +2097,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 	prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
 	if (prog->progs == NULL || filesize < (fs_offset_t)sizeof(dprograms_t))
 		PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME);
+	// TODO bounds check header fields (e.g. numstatements), they must never go behind end of file
 
 	Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024));
 
@@ -1748,8 +2139,6 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 
 	prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof(*prog->statement_profile));
 
-	// moved edict_size calculation down below field adding code
-
 	//pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals);
 	prog->globals.generic = (float *)((unsigned char *)prog->progs + prog->progs->ofs_globals);
 
@@ -1772,6 +2161,9 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		prog->functions[i].numparms = LittleLong (dfunctions[i].numparms);
 		prog->functions[i].locals = LittleLong (dfunctions[i].locals);
 		memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
+		if(prog->functions[i].first_statement >= prog->progs->numstatements)
+			PRVM_ERROR("PRVM_LoadProgs: out of bounds function statement (function %d) in %s", i, PRVM_NAME);
+		// TODO bounds check parm_start, s_name, s_file, numparms, locals, parm_size
 	}
 
 	for (i=0 ; i<prog->progs->numglobaldefs ; i++)
@@ -1779,6 +2171,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		prog->globaldefs[i].type = LittleShort (prog->globaldefs[i].type);
 		prog->globaldefs[i].ofs = LittleShort (prog->globaldefs[i].ofs);
 		prog->globaldefs[i].s_name = LittleLong (prog->globaldefs[i].s_name);
+		// TODO bounds check ofs, s_name
 	}
 
 	// copy the progs fields to the new fields list
@@ -1789,6 +2182,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 			PRVM_ERROR ("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", PRVM_NAME);
 		prog->fielddefs[i].ofs = LittleShort (infielddefs[i].ofs);
 		prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
+		// TODO bounds check ofs, s_name
 	}
 
 	// append the required fields
@@ -1797,12 +2191,14 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 		prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type;
 		prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields;
 		prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name);
+		// TODO bounds check ofs, s_name
 		if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector)
 			prog->progs->entityfields += 3;
 		else
 			prog->progs->entityfields++;
 		prog->progs->numfielddefs++;
 	}
+	prog->entityfields = prog->progs->entityfields;
 
 	// check required functions
 	for(i=0 ; i < numrequiredfunc ; i++)
@@ -1817,11 +2213,6 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 	for (i=0 ; i<prog->progs->numglobals ; i++)
 		((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]);
 
-	// moved edict_size calculation down here, below field adding code
-	// LordHavoc: this no longer includes the prvm_edict_t header
-	prog->edict_size = prog->progs->entityfields * 4;
-	prog->edictareasize = prog->edict_size * prog->limit_edicts;
-
 	// LordHavoc: bounds check anything static
 	for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++)
 	{
@@ -1920,11 +2311,188 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 			break;
 		}
 	}
+	if(prog->progs->numstatements < 1)
+	{
+		PRVM_ERROR("PRVM_LoadProgs: empty program in %s", PRVM_NAME);
+	}
+	else switch(prog->statements[prog->progs->numstatements - 1].op)
+	{
+		case OP_RETURN:
+		case OP_GOTO:
+		case OP_DONE:
+			break;
+		default:
+			PRVM_ERROR("PRVM_LoadProgs: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", PRVM_NAME);
+			break;
+	}
 
 	PRVM_LoadLNO(filename);
 
 	PRVM_Init_Exec();
 
+	if(*prvm_language.string)
+	// in CSQC we really shouldn't be able to change how stuff works... sorry for now
+	// later idea: include a list of authorized .po file checksums with the csprogs
+	{
+		qboolean deftrans = !!strcmp(PRVM_NAME, "client");
+		if(deftrans) // once we have dotranslate_ strings, ALWAYS use the opt-in method!
+		{
+			for (i=0 ; i<prog->progs->numglobaldefs ; i++)
+			{
+				const char *name;
+				name = PRVM_GetString(prog->globaldefs[i].s_name);
+				if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
+				if(name && !strncmp(name, "dotranslate_", 12))
+				{
+					deftrans = false;
+					break;
+				}
+			}
+		}
+		if(!strcmp(prvm_language.string, "dump"))
+		{
+			qfile_t *f = FS_OpenRealFile(va("%s.pot", filename), "w", false);
+			Con_Printf("Dumping to %s.pot\n", filename);
+			if(f)
+			{
+				for (i=0 ; i<prog->progs->numglobaldefs ; i++)
+				{
+					const char *name;
+					name = PRVM_GetString(prog->globaldefs[i].s_name);
+					if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12)))
+					if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
+					{
+						prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs);
+						const char *value = PRVM_GetString(val->string);
+						if(*value)
+						{
+							char buf[MAX_INPUTLINE];
+							PRVM_PO_UnparseString(buf, value, sizeof(buf));
+							FS_Printf(f, "msgid \"%s\"\nmsgstr \"\"\n\n", buf);
+						}
+					}
+				}
+				FS_Close(f);
+			}
+		}
+		else
+		{
+			po_t *po = PRVM_PO_Load(va("%s.%s.po", filename, prvm_language.string), prog->progs_mempool);
+			if(po)
+			{
+				for (i=0 ; i<prog->progs->numglobaldefs ; i++)
+				{
+					const char *name;
+					name = PRVM_GetString(prog->globaldefs[i].s_name);
+					if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12)))
+					if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
+					{
+						prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs);
+						const char *value = PRVM_GetString(val->string);
+						if(*value)
+						{
+							value = PRVM_PO_Lookup(po, value);
+							if(value)
+								val->string = PRVM_SetEngineString(value);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	for (i=0 ; i<prog->progs->numglobaldefs ; i++)
+	{
+		const char *name;
+		name = PRVM_GetString(prog->globaldefs[i].s_name);
+		//Con_Printf("found var %s\n", name);
+		if(name
+			&& !strncmp(name, "autocvar_", 9)
+			&& !(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z'))
+		)
+		{
+			prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs);
+			cvar_t *cvar = Cvar_FindVar(name + 9);
+			//Con_Printf("PRVM_LoadProgs: autocvar global %s in %s, processing...\n", name, PRVM_NAME);
+			if(!cvar)
+			{
+				const char *value;
+				char buf[64];
+				Con_DPrintf("PRVM_LoadProgs: no cvar for autocvar global %s in %s, creating...\n", name, PRVM_NAME);
+				switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
+				{
+					case ev_float:
+						if((float)((int)(val->_float)) == val->_float)
+							dpsnprintf(buf, sizeof(buf), "%i", (int)(val->_float));
+						else
+							dpsnprintf(buf, sizeof(buf), "%.9g", val->_float);
+						value = buf;
+						break;
+					case ev_vector:
+						dpsnprintf(buf, sizeof(buf), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]); value = buf;
+						break;
+					case ev_string:
+						value = PRVM_GetString(val->string);
+						break;
+					default:
+						Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, PRVM_NAME);
+						goto fail;
+				}
+				cvar = Cvar_Get(name + 9, value, 0, NULL);
+				if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
+				{
+					val->string = PRVM_SetEngineString(cvar->string);
+					cvar->globaldefindex_stringno[prog - prog_list] = val->string;
+				}
+				if(!cvar)
+					PRVM_ERROR("PRVM_LoadProgs: could not create cvar for autocvar global %s in %s", name, PRVM_NAME);
+				cvar->globaldefindex_progid[prog - prog_list] = prog->id;
+				cvar->globaldefindex[prog - prog_list] = i;
+			}
+			else if((cvar->flags & CVAR_PRIVATE) == 0)
+			{
+				// MUST BE SYNCED WITH cvar.c Cvar_Set
+				int j;
+				const char *s;
+				switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
+				{
+					case ev_float:
+						val->_float = cvar->value;
+						break;
+					case ev_vector:
+						s = cvar->string;
+						VectorClear(val->vector);
+						for (j = 0;j < 3;j++)
+						{
+							while (*s && ISWHITESPACE(*s))
+								s++;
+							if (!*s)
+								break;
+							val->vector[j] = atof(s);
+							while (!ISWHITESPACE(*s))
+								s++;
+							if (!*s)
+								break;
+						}
+						break;
+					case ev_string:
+						val->string = PRVM_SetEngineString(cvar->string);
+						cvar->globaldefindex_stringno[prog - prog_list] = val->string;
+						break;
+					default:
+						Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, PRVM_NAME);
+						goto fail;
+				}
+				cvar->globaldefindex_progid[prog - prog_list] = prog->id;
+				cvar->globaldefindex[prog - prog_list] = i;
+			}
+			else
+				Con_Printf("PRVM_LoadProgs: private cvar for autocvar global %s in %s\n", name, PRVM_NAME);
+		}
+fail:
+		;
+	}
+
 	prog->loaded = TRUE;
 
 	// set flags & ddef_ts in prog
@@ -1981,7 +2549,7 @@ void PRVM_Fields_f (void)
 			name = PRVM_GetString(d->s_name);
 			if (name[strlen(name)-2] == '_')
 				continue;	// skip _x, _y, _z vars
-			v = (int *)((char *)ed->fields.vp + d->ofs*4);
+			v = (int *)(ed->fields.vp + d->ofs);
 			// if the value is still all 0, skip the field
 			for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
 			{
@@ -2168,26 +2736,30 @@ void PRVM_Init (void)
 	Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
+	Cmd_AddCommand ("prvm_childprofile", PRVM_ChildProfile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu), sorted by time taken in function with child calls");
 	Cmd_AddCommand ("prvm_callprofile", PRVM_CallProfile_f, "prints execution statistics about the most time consuming QuakeC calls from the engine in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)");
+	Cmd_AddCommand ("prvm_edictget", PRVM_ED_EdictGet_f, "retrieves the value of a specified property of a specified entity in the selected VM (server, client menu) into a cvar or to the console");
+	Cmd_AddCommand ("prvm_globalget", PRVM_ED_GlobalGet_f, "retrieves the value of a specified global variable in the selected VM (server, client menu) into a cvar or to the console");
 	Cmd_AddCommand ("prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)");
 	Cmd_AddCommand ("cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument");
 	Cmd_AddCommand ("menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument");
 	Cmd_AddCommand ("sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument");
 
-	// COMMANDLINEOPTION: PRVM: -noboundscheck disables the bounds checks (security hole if CSQC is in use!)
-	prvm_boundscheck = !COM_CheckParm("-noboundscheck");
-
+	Cvar_RegisterVariable (&prvm_language);
 	Cvar_RegisterVariable (&prvm_traceqc);
 	Cvar_RegisterVariable (&prvm_statementprofiling);
+	Cvar_RegisterVariable (&prvm_timeprofiling);
 	Cvar_RegisterVariable (&prvm_backtraceforwarnings);
 	Cvar_RegisterVariable (&prvm_leaktest);
 	Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames);
 	Cvar_RegisterVariable (&prvm_errordump);
+	Cvar_RegisterVariable (&prvm_reuseedicts_startuptime);
+	Cvar_RegisterVariable (&prvm_reuseedicts_neverinsameframe);
 
 	// COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!)
 	prvm_runawaycheck = !COM_CheckParm("-norunaway");
@@ -2202,6 +2774,8 @@ PRVM_InitProg
 */
 void PRVM_InitProg(int prognr)
 {
+	static unsigned int progid = 0;
+
 	if(prognr < 0 || prognr >= PRVM_MAXPROGS)
 		Sys_Error("PRVM_InitProg: Invalid program number %i",prognr);
 
@@ -2212,19 +2786,20 @@ void PRVM_InitProg(int prognr)
 
 	memset(prog, 0, sizeof(prvm_prog_t));
 	prog->starttime = Sys_DoubleTime();
+	prog->id = ++progid;
 
 	prog->error_cmd = Host_Error;
-	prog->leaktest_active = prvm_leaktest.integer;
+	prog->leaktest_active = prvm_leaktest.integer != 0;
 }
 
-int PRVM_GetProgNr()
+int PRVM_GetProgNr(void)
 {
 	return prog - prog_list;
 }
 
 void *_PRVM_Alloc(size_t buffersize, const char *filename, int fileline)
 {
-	return _Mem_Alloc(prog->progs_mempool, buffersize, filename, fileline);
+	return _Mem_Alloc(prog->progs_mempool, NULL, buffersize, 16, filename, fileline);
 }
 
 void _PRVM_Free(void *buffer, const char *filename, int fileline)
@@ -2241,101 +2816,45 @@ void _PRVM_FreeAll(const char *filename, int fileline)
 }
 
 // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
-unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, char *filename, int fileline)
+unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, const char *filename, int fileline)
 {
 	PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline);
 	return 0;
 }
 
-/*
-int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
-{
-	PRVM_ERROR ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
-	return 0;
-}
-
-int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
-{
-	int n;
-	n = e - prog->edicts;
-	if ((unsigned int)n >= prog->limit_edicts)
-		Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
-	return n;
-}
-
-//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
-//{
-//	return e - prog->edicts;
-//}
-
-//#define	PRVM_EDICT_TO_PROG(e) ((unsigned char *)(((prvm_edict_t *)e)->v) - (unsigned char *)(prog->edictsfields))
-//#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
-int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
-{
-	int n;
-	n = e - prog->edicts;
-	if ((unsigned int)n >= (unsigned int)prog->max_edicts)
-		Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)", e, n, prog->edicts);
-	return n;// EXPERIMENTAL
-	//return (unsigned char *)e->v - (unsigned char *)prog->edictsfields;
-}
-prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
-{
-	if ((unsigned int)n >= (unsigned int)prog->max_edicts)
-		Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i", n);
-	return prog->edicts + n; // EXPERIMENTAL
-	//return prog->edicts + ((n) / (progs->entityfields * 4));
-}
-*/
-
-
 sizebuf_t vm_tempstringsbuf;
+#define PRVM_KNOWNSTRINGBASE 0x40000000
 
 const char *PRVM_GetString(int num)
 {
-	if (num >= 0)
+	if (num < 0)
 	{
-		if (num < prog->stringssize)
-			return prog->strings + num;
-		else
-#if 1
-		if (num <= prog->stringssize + vm_tempstringsbuf.maxsize)
-		{
-			num -= prog->stringssize;
-			if (num < vm_tempstringsbuf.cursize)
-				return (char *)vm_tempstringsbuf.data + num;
-			else
-			{
-				VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
-				return "";
-			}
-		}
+		// invalid
+		VM_Warning("PRVM_GetString: Invalid string offset (%i < 0)\n", num);
+		return "";
+	}
+	else if (num < prog->stringssize)
+	{
+		// constant string from progs.dat
+		return prog->strings + num;
+	}
+	else if (num <= prog->stringssize + vm_tempstringsbuf.maxsize)
+	{
+		// tempstring returned by engine to QC (becomes invalid after returning to engine)
+		num -= prog->stringssize;
+		if (num < vm_tempstringsbuf.cursize)
+			return (char *)vm_tempstringsbuf.data + num;
 		else
-#endif
 		{
-			VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
+			VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
 			return "";
 		}
 	}
-	else
+	else if (num & PRVM_KNOWNSTRINGBASE)
 	{
-		num = -1 - num;
-#if 0
-		if (num >= (1<<30))
-		{
-			// special range reserved for tempstrings
-			num -= (1<<30);
-			if (num < vm_tempstringsbuf.cursize)
-				return (char *)vm_tempstringsbuf.data + num;
-			else
-			{
-				VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
-				return "";
-			}
-		}
-		else
-#endif
-		if (num < prog->numknownstrings)
+		// allocated string
+		num = num - PRVM_KNOWNSTRINGBASE;
+		if (num >= 0 && num < prog->numknownstrings)
 		{
 			if (!prog->knownstrings[num])
 			{
@@ -2350,6 +2869,23 @@ const char *PRVM_GetString(int num)
 			return "";
 		}
 	}
+	else
+	{
+		// invalid string offset
+		VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
+		return "";
+	}
+}
+
+const char *PRVM_ChangeEngineString(int i, const char *s)
+{
+	const char *old;
+	i = i - PRVM_KNOWNSTRINGBASE;
+	if(i < 0 || i >= prog->numknownstrings)
+		PRVM_ERROR("PRVM_ChangeEngineString: s is not an engine string");
+	old = prog->knownstrings[i];
+	prog->knownstrings[i] = s;
+	return old;
 }
 
 int PRVM_SetEngineString(const char *s)
@@ -2364,16 +2900,14 @@ int PRVM_SetEngineString(const char *s)
 	if (s >= (char *)vm_tempstringsbuf.data && s < (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.maxsize)
 #if 1
 		return prog->stringssize + (s - (char *)vm_tempstringsbuf.data);
-#else
-		return -1 - ((1<<30) + (s - (char *)vm_tempstringsbuf.data));
 #endif
 	// see if it's a known string address
 	for (i = 0;i < prog->numknownstrings;i++)
 		if (prog->knownstrings[i] == s)
-			return -1 - i;
+			return PRVM_KNOWNSTRINGBASE + i;
 	// new unknown engine string
-	if (developer.integer >= 200)
-		Con_Printf("new engine string %p = \"%s\"\n", s, s);
+	if (developer_insane.integer)
+		Con_DPrintf("new engine string %p = \"%s\"\n", s, s);
 	for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
 		if (!prog->knownstrings[i])
 			break;
@@ -2404,7 +2938,7 @@ int PRVM_SetEngineString(const char *s)
 	prog->knownstrings_freeable[i] = false;
 	if(prog->leaktest_active)
 		prog->knownstrings_origin[i] = NULL;
-	return -1 - i;
+	return PRVM_KNOWNSTRINGBASE + i;
 }
 
 // temp string handling
@@ -2423,8 +2957,8 @@ int PRVM_SetTempString(const char *s)
 	if (!s)
 		return 0;
 	size = (int)strlen(s) + 1;
-	if (developer.integer >= 300)
-		Con_Printf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size);
+	if (developer_insane.integer)
+		Con_DPrintf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size);
 	if (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size)
 	{
 		sizebuf_t old = vm_tempstringsbuf;
@@ -2435,8 +2969,7 @@ int PRVM_SetTempString(const char *s)
 			vm_tempstringsbuf.maxsize *= 2;
 		if (vm_tempstringsbuf.maxsize != old.maxsize || vm_tempstringsbuf.data == NULL)
 		{
-			if (developer.integer >= 100)
-				Con_Printf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024);
+			Con_DPrintf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024);
 			vm_tempstringsbuf.data = (unsigned char *) Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize);
 			if (old.cursize)
 				memcpy(vm_tempstringsbuf.data, old.data, old.cursize);
@@ -2477,7 +3010,12 @@ int PRVM_AllocString(size_t bufferlength, char **pointer)
 				if(prog->leaktest_active)
 					memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
 			}
-			// TODO why not Mem_Free the old ones?
+			if (oldstrings)
+				Mem_Free((char **)oldstrings);
+			if (oldstrings_freeable)
+				Mem_Free((unsigned char *)oldstrings_freeable);
+			if (oldstrings_origin)
+				Mem_Free((char **)oldstrings_origin);
 		}
 		prog->numknownstrings++;
 	}
@@ -2488,7 +3026,7 @@ int PRVM_AllocString(size_t bufferlength, char **pointer)
 		prog->knownstrings_origin[i] = PRVM_AllocationOrigin();
 	if (pointer)
 		*pointer = (char *)(prog->knownstrings[i]);
-	return -1 - i;
+	return PRVM_KNOWNSTRINGBASE + i;
 }
 
 void PRVM_FreeString(int num)
@@ -2497,9 +3035,9 @@ void PRVM_FreeString(int num)
 		PRVM_ERROR("PRVM_FreeString: attempt to free a NULL string");
 	else if (num >= 0 && num < prog->stringssize)
 		PRVM_ERROR("PRVM_FreeString: attempt to free a constant string");
-	else if (num < 0 && num >= -prog->numknownstrings)
+	else if (num >= PRVM_KNOWNSTRINGBASE && num < PRVM_KNOWNSTRINGBASE + prog->numknownstrings)
 	{
-		num = -1 - num;
+		num = num - PRVM_KNOWNSTRINGBASE;
 		if (!prog->knownstrings[num])
 			PRVM_ERROR("PRVM_FreeString: attempt to free a non-existent or already freed string");
 		if (!prog->knownstrings_freeable[num])
@@ -2539,7 +3077,7 @@ static qboolean PRVM_IsStringReferenced(string_t string)
 			ddef_t *d = &prog->fielddefs[i];
 			if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
 				continue;
-			if(string == ((prvm_eval_t *) &((float*)ed->fields.vp)[d->ofs])->string)
+			if(string == ((prvm_eval_t *) &ed->fields.vp[d->ofs])->string)
 				return true;
 		}
 	}
@@ -2646,7 +3184,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark)
 			ddef_t *d = &prog->fielddefs[i];
 			if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
 				continue;
-			if(edictnum == ((prvm_eval_t *) &((float*)ed->fields.vp)[d->ofs])->edict)
+			if(edictnum == ((prvm_eval_t *) &ed->fields.vp[d->ofs])->edict)
 				return true;
 		}
 	}
@@ -2654,7 +3192,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark)
 	return false;
 }
 
-static void PRVM_MarkReferencedEdicts()
+static void PRVM_MarkReferencedEdicts(void)
 {
 	int j;
 	qboolean found_new;
@@ -2691,7 +3229,7 @@ static void PRVM_MarkReferencedEdicts()
 	Con_DPrintf("leak check used %d stages to find all references\n", stage);
 }
 
-void PRVM_LeakTest()
+void PRVM_LeakTest(void)
 {
 	int i, j;
 	qboolean leaked = false;
@@ -2705,7 +3243,7 @@ void PRVM_LeakTest()
 		if(prog->knownstrings[i])
 		if(prog->knownstrings_freeable[i])
 		if(prog->knownstrings_origin[i])
-		if(!PRVM_IsStringReferenced(-1 - i))
+		if(!PRVM_IsStringReferenced(PRVM_KNOWNSTRINGBASE + i))
 		{
 			Con_Printf("Unreferenced string found!\n  Value: %s\n  Origin: %s\n", prog->knownstrings[i], prog->knownstrings_origin[i]);
 			leaked = true;