Fix engine not starting on Windows if linked against SDL > 2.0.5
[xonotic/darkplaces.git] / sv_main.c
index 87c8af6..0b81820 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -23,6 +23,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "sv_demo.h"
 #include "libcurl.h"
 #include "csprogs.h"
+#include "thread.h"
 
 static void SV_SaveEntFile_f(void);
 static void SV_StartDownload_f(void);
@@ -30,16 +31,19 @@ static void SV_Download_f(void);
 static void SV_VM_Setup(void);
 extern cvar_t net_connecttimeout;
 
-void VM_CustomStats_Clear (void);
-void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);
+cvar_t sv_worldmessage = {CVAR_READONLY, "sv_worldmessage", "", "title of current level"};
+cvar_t sv_worldname = {CVAR_READONLY, "sv_worldname", "", "name of current worldmodel"};
+cvar_t sv_worldnamenoextension = {CVAR_READONLY, "sv_worldnamenoextension", "", "name of current worldmodel without extension"};
+cvar_t sv_worldbasename = {CVAR_READONLY, "sv_worldbasename", "", "name of current worldmodel without maps/ prefix or extension"};
 
+cvar_t sv_disablenotify = {0, "sv_disablenotify", "1", "suppress broadcast prints when certain cvars are changed (CVAR_NOTIFY flag in engine code)"};
 cvar_t coop = {0, "coop","0", "coop mode, 0 = no coop, 1 = coop mode, multiple players playing through the singleplayer game (coop mode also shuts off deathmatch)"};
 cvar_t deathmatch = {0, "deathmatch","0", "deathmatch mode, values depend on mod but typically 0 = no deathmatch, 1 = normal deathmatch with respawning weapons, 2 = weapons stay (players can only pick up new weapons)"};
 cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};
 cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
 cvar_t noexit = {CVAR_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};
 cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
-cvar_t pausable = {0, "pausable","1", "allow players to pause or not"};
+cvar_t pausable = {0, "pausable","1", "allow players to pause or not (otherwise, only the server admin can)"};
 cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"};
 cvar_t samelevel = {CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
 cvar_t skill = {0, "skill","1", "difficulty level of game, affects monster layouts in levels, 0 = easy, 1 = normal, 2 = hard, 3 = nightmare (same layout as hard but monsters fire twice)"};
@@ -48,12 +52,17 @@ cvar_t slowmo = {0, "slowmo", "1.0", "controls game speed, 0.5 is half speed, 2
 cvar_t sv_accelerate = {0, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
 cvar_t sv_aim = {CVAR_SAVE, "sv_aim", "2", "maximum cosine angle for quake's vertical autoaim, a value above 1 completely disables the autoaim, quake used 0.93"};
 cvar_t sv_airaccel_qw = {0, "sv_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration; when < 0, the speed is clamped against the maximum allowed forward speed after the move"};
+cvar_t sv_airaccel_qw_stretchfactor = {0, "sv_airaccel_qw_stretchfactor", "0", "when set, the maximum acceleration increase the player may get compared to forward-acceleration when strafejumping"};
 cvar_t sv_airaccel_sideways_friction = {0, "sv_airaccel_sideways_friction", "", "anti-sideways movement stabilization (reduces speed gain when zigzagging); when < 0, only so much friction is applied that braking (by accelerating backwards) cannot be stronger"};
 cvar_t sv_airaccelerate = {0, "sv_airaccelerate", "-1", "rate at which a player accelerates to sv_maxairspeed while in the air, if less than 0 the sv_accelerate variable is used instead"};
 cvar_t sv_airstopaccelerate = {0, "sv_airstopaccelerate", "0", "when set, replacement for sv_airaccelerate when moving backwards"};
+cvar_t sv_airspeedlimit_nonqw = {0, "sv_airspeedlimit_nonqw", "0", "when set, this is a soft speed limit while in air when using airaccel_qw not equal to 1"};
 cvar_t sv_airstrafeaccelerate = {0, "sv_airstrafeaccelerate", "0", "when set, replacement for sv_airaccelerate when just strafing"};
 cvar_t sv_maxairstrafespeed = {0, "sv_maxairstrafespeed", "0", "when set, replacement for sv_maxairspeed when just strafing"};
+cvar_t sv_airstrafeaccel_qw = {0, "sv_airstrafeaccel_qw", "0", "when set, replacement for sv_airaccel_qw when just strafing"};
 cvar_t sv_aircontrol = {0, "sv_aircontrol", "0", "CPMA-style air control"};
+cvar_t sv_aircontrol_power = {0, "sv_aircontrol_power", "2", "CPMA-style air control exponent"};
+cvar_t sv_aircontrol_penalty = {0, "sv_aircontrol_penalty", "0", "deceleration while using CPMA-style air control"};
 cvar_t sv_allowdownloads = {0, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};
 cvar_t sv_allowdownloads_archive = {0, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};
 cvar_t sv_allowdownloads_config = {0, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};
@@ -72,6 +81,8 @@ cvar_t sv_cullentities_trace = {0, "sv_cullentities_trace", "0", "somewhat slow
 cvar_t sv_cullentities_trace_delay = {0, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
 cvar_t sv_cullentities_trace_delay_players = {0, "sv_cullentities_trace_delay_players", "0.2", "number of seconds until the entity gets actually culled if it is a player entity"};
 cvar_t sv_cullentities_trace_enlarge = {0, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
+cvar_t sv_cullentities_trace_expand = { 0, "sv_cullentities_trace_expand", "0", "box is expanded by this many units for entity culling" };
+cvar_t sv_cullentities_trace_eyejitter = {0, "sv_cullentities_trace_eyejitter", "16", "jitter the eye by this much for each trace"};
 cvar_t sv_cullentities_trace_prediction = {0, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};
 cvar_t sv_cullentities_trace_prediction_time = {0, "sv_cullentities_trace_prediction_time", "0.2", "how many seconds of prediction to use"};
 cvar_t sv_cullentities_trace_entityocclusion = {0, "sv_cullentities_trace_entityocclusion", "0", "also check if doors and other bsp models are in the way"};
@@ -86,7 +97,7 @@ cvar_t sv_fixedframeratesingleplayer = {0, "sv_fixedframeratesingleplayer", "1",
 cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
 cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4", "how fast you slow down"};
 cvar_t sv_gameplayfix_blowupfallenzombies = {0, "sv_gameplayfix_blowupfallenzombies", "1", "causes findradius to detect SOLID_NOT entities such as zombies and corpses on the floor, allowing splash damage to apply to them"};
-cvar_t sv_gameplayfix_consistentplayerprethink = {0, "sv_gameplayfix_consistentplayerprethink", "1", "improves fairness in multiplayer by running all PlayerPreThink functions (which fire weapons) before performing physics, then runing all PlayerPostThink functions"};
+cvar_t sv_gameplayfix_consistentplayerprethink = {0, "sv_gameplayfix_consistentplayerprethink", "0", "improves fairness in multiplayer by running all PlayerPreThink functions (which fire weapons) before performing physics, then running all PlayerPostThink functions"};
 cvar_t sv_gameplayfix_delayprojectiles = {0, "sv_gameplayfix_delayprojectiles", "1", "causes entities to not move on the same frame they are spawned, meaning that projectiles wait until the next frame to perform their first move, giving proper interpolation and rocket trails, but making weapons harder to use at low framerates"};
 cvar_t sv_gameplayfix_droptofloorstartsolid = {0, "sv_gameplayfix_droptofloorstartsolid", "1", "prevents items and monsters that start in a solid area from falling out of the level (makes droptofloor treat trace_startsolid as an acceptable outcome)"};
 cvar_t sv_gameplayfix_droptofloorstartsolid_nudgetocorrect = {0, "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect", "1", "tries to nudge stuck items and monsters out of walls before droptofloor is performed"};
@@ -97,20 +108,26 @@ cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebounc
 cvar_t sv_gameplayfix_multiplethinksperframe = {0, "sv_gameplayfix_multiplethinksperframe", "1", "allows entities to think more often than the server framerate, primarily useful for very high fire rate weapons"};
 cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1", "causes entities (corpses, items, etc) sitting ontop of moving entities (players) to fall when the moving entity (player) is no longer supporting them"};
 cvar_t sv_gameplayfix_noairborncorpse_allowsuspendeditems = {0, "sv_gameplayfix_noairborncorpse_allowsuspendeditems", "1", "causes entities sitting ontop of objects that are instantaneously remove to float in midair (special hack to allow a common level design trick for floating items)"};
-cvar_t sv_gameplayfix_nudgeoutofsolid = {0, "sv_gameplayfix_nudgeoutofsolid", "1", "attempts to fix physics errors (where an object ended up in solid for some reason)"};
-cvar_t sv_gameplayfix_nudgeoutofsolid_bias = {0, "sv_gameplayfix_nudgeoutofsolid_bias", "0", "over-correction on nudgeoutofsolid logic, to prevent constant contact"};
+cvar_t sv_gameplayfix_nudgeoutofsolid = {0, "sv_gameplayfix_nudgeoutofsolid", "0", "attempts to fix physics errors (where an object ended up in solid for some reason)"};
+cvar_t sv_gameplayfix_nudgeoutofsolid_separation = {0, "sv_gameplayfix_nudgeoutofsolid_separation", "0.03125", "keep objects this distance apart to prevent collision issues on seams"};
 cvar_t sv_gameplayfix_q2airaccelerate = {0, "sv_gameplayfix_q2airaccelerate", "0", "Quake2-style air acceleration"};
+cvar_t sv_gameplayfix_nogravityonground = {0, "sv_gameplayfix_nogravityonground", "0", "turn off gravity when on ground (to get rid of sliding)"};
 cvar_t sv_gameplayfix_setmodelrealbox = {0, "sv_gameplayfix_setmodelrealbox", "1", "fixes a bug in Quake that made setmodel always set the entity box to ('-16 -16 -16', '16 16 16') rather than properly checking the model box, breaks some poorly coded mods"};
 cvar_t sv_gameplayfix_slidemoveprojectiles = {0, "sv_gameplayfix_slidemoveprojectiles", "1", "allows MOVETYPE_FLY/FLYMISSILE/TOSS/BOUNCE/BOUNCEMISSILE entities to finish their move in a frame even if they hit something, fixes 'gravity accumulation' bug for grenades on steep slopes"};
 cvar_t sv_gameplayfix_stepdown = {0, "sv_gameplayfix_stepdown", "0", "attempts to step down stairs, not just up them (prevents the familiar thud..thud..thud.. when running down stairs and slopes)"};
-cvar_t sv_gameplayfix_stepwhilejumping = {0, "sv_gameplayfix_stepwhilejumping", "1", "applies step-up onto a ledge even while airborn, useful if you would otherwise just-miss the floor when running across small areas with gaps (for instance running across the moving platforms in dm2, or jumping to the megahealth and red armor in dm2 rather than using the bridge)"};
-cvar_t sv_gameplayfix_stepmultipletimes = {0, "sv_gameplayfix_stepmultipletimes", "1", "applies step-up onto a ledge more than once in a single frame, when running quickly up stairs"};
+cvar_t sv_gameplayfix_stepmultipletimes = {0, "sv_gameplayfix_stepmultipletimes", "0", "applies step-up onto a ledge more than once in a single frame, when running quickly up stairs"};
+cvar_t sv_gameplayfix_nostepmoveonsteepslopes = {0, "sv_gameplayfix_nostepmoveonsteepslopes", "0", "crude fix which prevents MOVETYPE_STEP (not swimming or flying) to move on slopes whose angle is bigger than 45 degree"};
 cvar_t sv_gameplayfix_swiminbmodels = {0, "sv_gameplayfix_swiminbmodels", "1", "causes pointcontents (used to determine if you are in a liquid) to check bmodel entities as well as the world model, so you can swim around in (possibly moving) water bmodel entities"};
 cvar_t sv_gameplayfix_upwardvelocityclearsongroundflag = {0, "sv_gameplayfix_upwardvelocityclearsongroundflag", "1", "prevents monsters, items, and most other objects from being stuck to the floor when pushed around by damage, and other situations in mods"};
 cvar_t sv_gameplayfix_downtracesupportsongroundflag = {0, "sv_gameplayfix_downtracesupportsongroundflag", "1", "prevents very short moves from clearing onground (which may make the player stick to the floor at high netfps)"};
+cvar_t sv_gameplayfix_q1bsptracelinereportstexture = {0, "sv_gameplayfix_q1bsptracelinereportstexture", "1", "enables mods to get accurate trace_texture results on q1bsp by using a surface-hitting traceline implementation rather than the standard solidbsp method, q3bsp always reports texture accurately"};
+cvar_t sv_gameplayfix_unstickplayers = {0, "sv_gameplayfix_unstickplayers", "1", "big hack to try and fix the rare case of MOVETYPE_WALK entities getting stuck in the world clipping hull."};
+cvar_t sv_gameplayfix_unstickentities = {0, "sv_gameplayfix_unstickentities", "1", "hack to check if entities are crossing world collision hull and try to move them to the right position"};
+cvar_t sv_gameplayfix_fixedcheckwatertransition = {0, "sv_gameplayfix_fixedcheckwatertransition", "1", "fix two very stupid bugs in SV_CheckWaterTransition when watertype is CONTENTS_EMPTY (the bugs causes waterlevel to be 1 on first frame, -1 on second frame - the fix makes it 0 on both frames)"};
 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
+cvar_t sv_init_frame_count = {0, "sv_init_frame_count", "2", "number of frames to run to allow everything to settle before letting clients connect"};
 cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};
-cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
+cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping"};
 cvar_t sv_jumpvelocity = {0, "sv_jumpvelocity", "270", "cvar that can be used by QuakeC code for jump velocity"};
 cvar_t sv_maxairspeed = {0, "sv_maxairspeed", "30", "maximum speed a player can accelerate to when airborn (note that it is possible to completely stop by moving the opposite direction)"};
 cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "1000000", "upper limit on client rate cvar, should reflect your network connection quality"};
@@ -135,9 +152,11 @@ cvar_t sv_warsowbunny_topspeed = {0, "sv_warsowbunny_topspeed", "925", "soft spe
 cvar_t sv_warsowbunny_turnaccel = {0, "sv_warsowbunny_turnaccel", "0", "max sharpness of turns (also master switch for the sv_warsowbunny_* mode; set this to 9 to enable)"};
 cvar_t sv_warsowbunny_backtosideratio = {0, "sv_warsowbunny_backtosideratio", "0.8", "lower values make it easier to change direction without losing speed; the drawback is \"understeering\" in sharp turns"};
 cvar_t sv_onlycsqcnetworking = {0, "sv_onlycsqcnetworking", "0", "disables legacy entity networking code for higher performance (except on clients, which can still be legacy)"};
+cvar_t sv_areadebug = {0, "sv_areadebug", "0", "disables physics culling for debugging purposes (only for development)"};
 cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.0138889", "how long a server frame is in seconds, 0.05 is 20fps server rate, 0.1 is 10fps (can not be set higher than 0.1), 0 runs as many server frames as possible (makes games against bots a little smoother, overwhelms network players), 0.0138889 matches QuakeWorld physics"};
 cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0", "teamplay mode, values depend on mod but typically 0 = no teams, 1 = no team damage no self damage, 2 = team damage and self damage, some mods support 3 = no team damage but can damage self"};
 cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};
+cvar_t sv_threaded = {0, "sv_threaded", "0", "enables a separate thread for server code, improving performance, especially when hosting a game while playing, EXPERIMENTAL, may be crashy"};
 
 cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
@@ -174,8 +193,11 @@ cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be use
 
 cvar_t sv_autodemo_perclient = {CVAR_SAVE, "sv_autodemo_perclient", "0", "set to 1 to enable autorecorded per-client demos (they'll start to record at the beginning of a match); set it to 2 to also record client->server packets (for debugging)"};
 cvar_t sv_autodemo_perclient_nameformat = {CVAR_SAVE, "sv_autodemo_perclient_nameformat", "sv_autodemos/%Y-%m-%d_%H-%M", "The format of the sv_autodemo_perclient filename, followed by the map name, the client number and the IP address + port number, separated by underscores (the date is encoded using strftime escapes)" };
+cvar_t sv_autodemo_perclient_discardable = {CVAR_SAVE, "sv_autodemo_perclient_discardable", "0", "Allow game code to decide whether a demo should be kept or discarded."};
 
 cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
+cvar_t sv_mapformat_is_quake2 = {0, "sv_mapformat_is_quake2", "0", "indicates the current map is q2bsp format (useful to know because of different entity behaviors, .frame on submodels and other things)"};
+cvar_t sv_mapformat_is_quake3 = {0, "sv_mapformat_is_quake3", "0", "indicates the current map is q2bsp format (useful to know because of different entity behaviors)"};
 
 server_t sv;
 server_static_t svs;
@@ -226,101 +248,176 @@ static const char *standardeffectnames[EFFECT_TOTAL] =
        "SVC_PARTICLE"
 };
 
-#define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t))
+#define SV_REQFUNCS 0
+#define sv_reqfuncs NULL
 
-prvm_required_field_t reqfields[] =
+//#define SV_REQFUNCS (sizeof(sv_reqfuncs) / sizeof(const char *))
+//static const char *sv_reqfuncs[] = {
+//};
+
+#define SV_REQFIELDS (sizeof(sv_reqfields) / sizeof(prvm_required_field_t))
+
+prvm_required_field_t sv_reqfields[] =
 {
-       {ev_entity, "cursor_trace_ent"},
-       {ev_entity, "drawonlytoclient"},
-       {ev_entity, "exteriormodeltoclient"},
-       {ev_entity, "nodrawtoclient"},
-       {ev_entity, "tag_entity"},
-       {ev_entity, "viewmodelforclient"},
-       {ev_float, "SendFlags"},
-       {ev_float, "Version"},
-       {ev_float, "alpha"},
-       {ev_float, "ammo_cells1"},
-       {ev_float, "ammo_lava_nails"},
-       {ev_float, "ammo_multi_rockets"},
-       {ev_float, "ammo_nails1"},
-       {ev_float, "ammo_plasma"},
-       {ev_float, "ammo_rockets1"},
-       {ev_float, "ammo_shells1"},
-       {ev_float, "button3"},
-       {ev_float, "button4"},
-       {ev_float, "button5"},
-       {ev_float, "button6"},
-       {ev_float, "button7"},
-       {ev_float, "button8"},
-       {ev_float, "button9"},
-       {ev_float, "button10"},
-       {ev_float, "button11"},
-       {ev_float, "button12"},
-       {ev_float, "button13"},
-       {ev_float, "button14"},
-       {ev_float, "button15"},
-       {ev_float, "button16"},
-       {ev_float, "buttonchat"},
-       {ev_float, "buttonuse"},
-       {ev_float, "clientcolors"},
-       {ev_float, "cursor_active"},
-       {ev_float, "disableclientprediction"},
-       {ev_float, "fullbright"},
-       {ev_float, "glow_color"},
-       {ev_float, "glow_size"},
-       {ev_float, "glow_trail"},
-       {ev_float, "gravity"},
-       {ev_float, "idealpitch"},
-       {ev_float, "items2"},
-       {ev_float, "light_lev"},
-       {ev_float, "modelflags"},
-       {ev_float, "pflags"},
-       {ev_float, "ping"},
-       {ev_float, "pitch_speed"},
-       {ev_float, "pmodel"},
-       {ev_float, "renderamt"}, // HalfLife support
-       {ev_float, "rendermode"}, // HalfLife support
-       {ev_float, "scale"},
-       {ev_float, "style"},
-       {ev_float, "tag_index"},
-       {ev_float, "viewzoom"},
-       {ev_function, "SendEntity"},
-       {ev_function, "contentstransition"}, // DRESK - Support for Entity Contents Transition Event
-       {ev_function, "customizeentityforclient"},
-       {ev_function, "movetypesteplandevent"}, // DRESK - Support for MOVETYPE_STEP Entity Land Event
-       {ev_string, "netaddress"},
-       {ev_string, "playermodel"},
-       {ev_string, "playerskin"},
-       {ev_vector, "color"},
-       {ev_vector, "colormod"},
-       {ev_vector, "cursor_screen"},
-       {ev_vector, "cursor_trace_endpos"},
-       {ev_vector, "cursor_trace_start"},
-       {ev_vector, "glowmod"},
-       {ev_vector, "movement"},
-       {ev_vector, "punchvector"},
-
-       // physics
-       //{ev_float, "solid"},
-       //{ev_float, "movetype"},
-       //{ev_float, "modelindex"},
-       {ev_vector, "mass"},
-       //{ev_vector, "origin"},
-       //{ev_vector, "velocity"},
-       //{ev_vector, "axis_forward"},
-       //{ev_vector, "axis_left"},
-       //{ev_vector, "axis_up"},
-       //{ev_vector, "spinvelocity"},
-       //{ev_vector, "angles"},
-       //{ev_vector, "avelocity"},
+#define PRVM_DECLARE_serverglobalfloat(x)
+#define PRVM_DECLARE_serverglobalvector(x)
+#define PRVM_DECLARE_serverglobalstring(x)
+#define PRVM_DECLARE_serverglobaledict(x)
+#define PRVM_DECLARE_serverglobalfunction(x)
+#define PRVM_DECLARE_clientglobalfloat(x)
+#define PRVM_DECLARE_clientglobalvector(x)
+#define PRVM_DECLARE_clientglobalstring(x)
+#define PRVM_DECLARE_clientglobaledict(x)
+#define PRVM_DECLARE_clientglobalfunction(x)
+#define PRVM_DECLARE_menuglobalfloat(x)
+#define PRVM_DECLARE_menuglobalvector(x)
+#define PRVM_DECLARE_menuglobalstring(x)
+#define PRVM_DECLARE_menuglobaledict(x)
+#define PRVM_DECLARE_menuglobalfunction(x)
+#define PRVM_DECLARE_serverfieldfloat(x) {ev_float, #x},
+#define PRVM_DECLARE_serverfieldvector(x) {ev_vector, #x},
+#define PRVM_DECLARE_serverfieldstring(x) {ev_string, #x},
+#define PRVM_DECLARE_serverfieldedict(x) {ev_entity, #x},
+#define PRVM_DECLARE_serverfieldfunction(x) {ev_function, #x},
+#define PRVM_DECLARE_clientfieldfloat(x)
+#define PRVM_DECLARE_clientfieldvector(x)
+#define PRVM_DECLARE_clientfieldstring(x)
+#define PRVM_DECLARE_clientfieldedict(x)
+#define PRVM_DECLARE_clientfieldfunction(x)
+#define PRVM_DECLARE_menufieldfloat(x)
+#define PRVM_DECLARE_menufieldvector(x)
+#define PRVM_DECLARE_menufieldstring(x)
+#define PRVM_DECLARE_menufieldedict(x)
+#define PRVM_DECLARE_menufieldfunction(x)
+#define PRVM_DECLARE_serverfunction(x)
+#define PRVM_DECLARE_clientfunction(x)
+#define PRVM_DECLARE_menufunction(x)
+#define PRVM_DECLARE_field(x)
+#define PRVM_DECLARE_global(x)
+#define PRVM_DECLARE_function(x)
+#include "prvm_offsets.h"
+#undef PRVM_DECLARE_serverglobalfloat
+#undef PRVM_DECLARE_serverglobalvector
+#undef PRVM_DECLARE_serverglobalstring
+#undef PRVM_DECLARE_serverglobaledict
+#undef PRVM_DECLARE_serverglobalfunction
+#undef PRVM_DECLARE_clientglobalfloat
+#undef PRVM_DECLARE_clientglobalvector
+#undef PRVM_DECLARE_clientglobalstring
+#undef PRVM_DECLARE_clientglobaledict
+#undef PRVM_DECLARE_clientglobalfunction
+#undef PRVM_DECLARE_menuglobalfloat
+#undef PRVM_DECLARE_menuglobalvector
+#undef PRVM_DECLARE_menuglobalstring
+#undef PRVM_DECLARE_menuglobaledict
+#undef PRVM_DECLARE_menuglobalfunction
+#undef PRVM_DECLARE_serverfieldfloat
+#undef PRVM_DECLARE_serverfieldvector
+#undef PRVM_DECLARE_serverfieldstring
+#undef PRVM_DECLARE_serverfieldedict
+#undef PRVM_DECLARE_serverfieldfunction
+#undef PRVM_DECLARE_clientfieldfloat
+#undef PRVM_DECLARE_clientfieldvector
+#undef PRVM_DECLARE_clientfieldstring
+#undef PRVM_DECLARE_clientfieldedict
+#undef PRVM_DECLARE_clientfieldfunction
+#undef PRVM_DECLARE_menufieldfloat
+#undef PRVM_DECLARE_menufieldvector
+#undef PRVM_DECLARE_menufieldstring
+#undef PRVM_DECLARE_menufieldedict
+#undef PRVM_DECLARE_menufieldfunction
+#undef PRVM_DECLARE_serverfunction
+#undef PRVM_DECLARE_clientfunction
+#undef PRVM_DECLARE_menufunction
+#undef PRVM_DECLARE_field
+#undef PRVM_DECLARE_global
+#undef PRVM_DECLARE_function
+};
 
+#define SV_REQGLOBALS (sizeof(sv_reqglobals) / sizeof(prvm_required_field_t))
+
+prvm_required_field_t sv_reqglobals[] =
+{
+#define PRVM_DECLARE_serverglobalfloat(x) {ev_float, #x},
+#define PRVM_DECLARE_serverglobalvector(x) {ev_vector, #x},
+#define PRVM_DECLARE_serverglobalstring(x) {ev_string, #x},
+#define PRVM_DECLARE_serverglobaledict(x) {ev_entity, #x},
+#define PRVM_DECLARE_serverglobalfunction(x) {ev_function, #x},
+#define PRVM_DECLARE_clientglobalfloat(x)
+#define PRVM_DECLARE_clientglobalvector(x)
+#define PRVM_DECLARE_clientglobalstring(x)
+#define PRVM_DECLARE_clientglobaledict(x)
+#define PRVM_DECLARE_clientglobalfunction(x)
+#define PRVM_DECLARE_menuglobalfloat(x)
+#define PRVM_DECLARE_menuglobalvector(x)
+#define PRVM_DECLARE_menuglobalstring(x)
+#define PRVM_DECLARE_menuglobaledict(x)
+#define PRVM_DECLARE_menuglobalfunction(x)
+#define PRVM_DECLARE_serverfieldfloat(x)
+#define PRVM_DECLARE_serverfieldvector(x)
+#define PRVM_DECLARE_serverfieldstring(x)
+#define PRVM_DECLARE_serverfieldedict(x)
+#define PRVM_DECLARE_serverfieldfunction(x)
+#define PRVM_DECLARE_clientfieldfloat(x)
+#define PRVM_DECLARE_clientfieldvector(x)
+#define PRVM_DECLARE_clientfieldstring(x)
+#define PRVM_DECLARE_clientfieldedict(x)
+#define PRVM_DECLARE_clientfieldfunction(x)
+#define PRVM_DECLARE_menufieldfloat(x)
+#define PRVM_DECLARE_menufieldvector(x)
+#define PRVM_DECLARE_menufieldstring(x)
+#define PRVM_DECLARE_menufieldedict(x)
+#define PRVM_DECLARE_menufieldfunction(x)
+#define PRVM_DECLARE_serverfunction(x)
+#define PRVM_DECLARE_clientfunction(x)
+#define PRVM_DECLARE_menufunction(x)
+#define PRVM_DECLARE_field(x)
+#define PRVM_DECLARE_global(x)
+#define PRVM_DECLARE_function(x)
+#include "prvm_offsets.h"
+#undef PRVM_DECLARE_serverglobalfloat
+#undef PRVM_DECLARE_serverglobalvector
+#undef PRVM_DECLARE_serverglobalstring
+#undef PRVM_DECLARE_serverglobaledict
+#undef PRVM_DECLARE_serverglobalfunction
+#undef PRVM_DECLARE_clientglobalfloat
+#undef PRVM_DECLARE_clientglobalvector
+#undef PRVM_DECLARE_clientglobalstring
+#undef PRVM_DECLARE_clientglobaledict
+#undef PRVM_DECLARE_clientglobalfunction
+#undef PRVM_DECLARE_menuglobalfloat
+#undef PRVM_DECLARE_menuglobalvector
+#undef PRVM_DECLARE_menuglobalstring
+#undef PRVM_DECLARE_menuglobaledict
+#undef PRVM_DECLARE_menuglobalfunction
+#undef PRVM_DECLARE_serverfieldfloat
+#undef PRVM_DECLARE_serverfieldvector
+#undef PRVM_DECLARE_serverfieldstring
+#undef PRVM_DECLARE_serverfieldedict
+#undef PRVM_DECLARE_serverfieldfunction
+#undef PRVM_DECLARE_clientfieldfloat
+#undef PRVM_DECLARE_clientfieldvector
+#undef PRVM_DECLARE_clientfieldstring
+#undef PRVM_DECLARE_clientfieldedict
+#undef PRVM_DECLARE_clientfieldfunction
+#undef PRVM_DECLARE_menufieldfloat
+#undef PRVM_DECLARE_menufieldvector
+#undef PRVM_DECLARE_menufieldstring
+#undef PRVM_DECLARE_menufieldedict
+#undef PRVM_DECLARE_menufieldfunction
+#undef PRVM_DECLARE_serverfunction
+#undef PRVM_DECLARE_clientfunction
+#undef PRVM_DECLARE_menufunction
+#undef PRVM_DECLARE_field
+#undef PRVM_DECLARE_global
+#undef PRVM_DECLARE_function
 };
 
 
 
 //============================================================================
 
-void SV_AreaStats_f(void)
+static void SV_AreaStats_f(void)
 {
        World_PrintAreaStats(&sv.world, "server");
 }
@@ -337,15 +434,24 @@ void SV_Init (void)
        extern cvar_t csqc_progname;    //[515]: csqc crc check and right csprogs name according to progs.dat
        extern cvar_t csqc_progcrc;
        extern cvar_t csqc_progsize;
+       extern cvar_t csqc_usedemoprogs;
+
+       Cvar_RegisterVariable(&sv_worldmessage);
+       Cvar_RegisterVariable(&sv_worldname);
+       Cvar_RegisterVariable(&sv_worldnamenoextension);
+       Cvar_RegisterVariable(&sv_worldbasename);
+
        Cvar_RegisterVariable (&csqc_progname);
        Cvar_RegisterVariable (&csqc_progcrc);
        Cvar_RegisterVariable (&csqc_progsize);
+       Cvar_RegisterVariable (&csqc_usedemoprogs);
 
        Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
        Cmd_AddCommand("sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
        Cmd_AddCommand_WithClientCommand("sv_startdownload", NULL, SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
        Cmd_AddCommand_WithClientCommand("download", NULL, SV_Download_f, "downloads a specified file from the server");
 
+       Cvar_RegisterVariable (&sv_disablenotify);
        Cvar_RegisterVariable (&coop);
        Cvar_RegisterVariable (&deathmatch);
        Cvar_RegisterVariable (&fraglimit);
@@ -360,12 +466,17 @@ void SV_Init (void)
        Cvar_RegisterVariable (&sv_accelerate);
        Cvar_RegisterVariable (&sv_aim);
        Cvar_RegisterVariable (&sv_airaccel_qw);
+       Cvar_RegisterVariable (&sv_airaccel_qw_stretchfactor);
        Cvar_RegisterVariable (&sv_airaccel_sideways_friction);
        Cvar_RegisterVariable (&sv_airaccelerate);
        Cvar_RegisterVariable (&sv_airstopaccelerate);
        Cvar_RegisterVariable (&sv_airstrafeaccelerate);
        Cvar_RegisterVariable (&sv_maxairstrafespeed);
+       Cvar_RegisterVariable (&sv_airstrafeaccel_qw);
+       Cvar_RegisterVariable (&sv_airspeedlimit_nonqw);
        Cvar_RegisterVariable (&sv_aircontrol);
+       Cvar_RegisterVariable (&sv_aircontrol_power);
+       Cvar_RegisterVariable (&sv_aircontrol_penalty);
        Cvar_RegisterVariable (&sv_allowdownloads);
        Cvar_RegisterVariable (&sv_allowdownloads_archive);
        Cvar_RegisterVariable (&sv_allowdownloads_config);
@@ -384,6 +495,8 @@ void SV_Init (void)
        Cvar_RegisterVariable (&sv_cullentities_trace_delay);
        Cvar_RegisterVariable (&sv_cullentities_trace_delay_players);
        Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
+       Cvar_RegisterVariable (&sv_cullentities_trace_expand);
+       Cvar_RegisterVariable (&sv_cullentities_trace_eyejitter);
        Cvar_RegisterVariable (&sv_cullentities_trace_entityocclusion);
        Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
        Cvar_RegisterVariable (&sv_cullentities_trace_prediction_time);
@@ -410,17 +523,23 @@ void SV_Init (void)
        Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
        Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse_allowsuspendeditems);
        Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid);
-       Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid_bias);
+       Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid_separation);
        Cvar_RegisterVariable (&sv_gameplayfix_q2airaccelerate);
+       Cvar_RegisterVariable (&sv_gameplayfix_nogravityonground);
        Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
        Cvar_RegisterVariable (&sv_gameplayfix_slidemoveprojectiles);
        Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
-       Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
        Cvar_RegisterVariable (&sv_gameplayfix_stepmultipletimes);
+       Cvar_RegisterVariable (&sv_gameplayfix_nostepmoveonsteepslopes);
        Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
        Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
        Cvar_RegisterVariable (&sv_gameplayfix_downtracesupportsongroundflag);
+       Cvar_RegisterVariable (&sv_gameplayfix_q1bsptracelinereportstexture);
+       Cvar_RegisterVariable (&sv_gameplayfix_unstickplayers);
+       Cvar_RegisterVariable (&sv_gameplayfix_unstickentities);
+       Cvar_RegisterVariable (&sv_gameplayfix_fixedcheckwatertransition);
        Cvar_RegisterVariable (&sv_gravity);
+       Cvar_RegisterVariable (&sv_init_frame_count);
        Cvar_RegisterVariable (&sv_idealpitchscale);
        Cvar_RegisterVariable (&sv_jumpstep);
        Cvar_RegisterVariable (&sv_jumpvelocity);
@@ -447,9 +566,11 @@ void SV_Init (void)
        Cvar_RegisterVariable (&sv_warsowbunny_turnaccel);
        Cvar_RegisterVariable (&sv_warsowbunny_backtosideratio);
        Cvar_RegisterVariable (&sv_onlycsqcnetworking);
+       Cvar_RegisterVariable (&sv_areadebug);
        Cvar_RegisterVariable (&sys_ticrate);
        Cvar_RegisterVariable (&teamplay);
        Cvar_RegisterVariable (&timelimit);
+       Cvar_RegisterVariable (&sv_threaded);
 
        Cvar_RegisterVariable (&saved1);
        Cvar_RegisterVariable (&saved2);
@@ -463,77 +584,48 @@ void SV_Init (void)
        Cvar_RegisterVariable (&temp1);
 
        // LordHavoc: Nehahra uses these to pass data around cutscene demos
-       if (gamemode == GAME_NEHAHRA)
-       {
-               Cvar_RegisterVariable (&nehx00);
-               Cvar_RegisterVariable (&nehx01);
-               Cvar_RegisterVariable (&nehx02);
-               Cvar_RegisterVariable (&nehx03);
-               Cvar_RegisterVariable (&nehx04);
-               Cvar_RegisterVariable (&nehx05);
-               Cvar_RegisterVariable (&nehx06);
-               Cvar_RegisterVariable (&nehx07);
-               Cvar_RegisterVariable (&nehx08);
-               Cvar_RegisterVariable (&nehx09);
-               Cvar_RegisterVariable (&nehx10);
-               Cvar_RegisterVariable (&nehx11);
-               Cvar_RegisterVariable (&nehx12);
-               Cvar_RegisterVariable (&nehx13);
-               Cvar_RegisterVariable (&nehx14);
-               Cvar_RegisterVariable (&nehx15);
-               Cvar_RegisterVariable (&nehx16);
-               Cvar_RegisterVariable (&nehx17);
-               Cvar_RegisterVariable (&nehx18);
-               Cvar_RegisterVariable (&nehx19);
-       }
+       Cvar_RegisterVariable (&nehx00);
+       Cvar_RegisterVariable (&nehx01);
+       Cvar_RegisterVariable (&nehx02);
+       Cvar_RegisterVariable (&nehx03);
+       Cvar_RegisterVariable (&nehx04);
+       Cvar_RegisterVariable (&nehx05);
+       Cvar_RegisterVariable (&nehx06);
+       Cvar_RegisterVariable (&nehx07);
+       Cvar_RegisterVariable (&nehx08);
+       Cvar_RegisterVariable (&nehx09);
+       Cvar_RegisterVariable (&nehx10);
+       Cvar_RegisterVariable (&nehx11);
+       Cvar_RegisterVariable (&nehx12);
+       Cvar_RegisterVariable (&nehx13);
+       Cvar_RegisterVariable (&nehx14);
+       Cvar_RegisterVariable (&nehx15);
+       Cvar_RegisterVariable (&nehx16);
+       Cvar_RegisterVariable (&nehx17);
+       Cvar_RegisterVariable (&nehx18);
+       Cvar_RegisterVariable (&nehx19);
        Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
 
        Cvar_RegisterVariable (&sv_autodemo_perclient);
        Cvar_RegisterVariable (&sv_autodemo_perclient_nameformat);
+       Cvar_RegisterVariable (&sv_autodemo_perclient_discardable);
 
        Cvar_RegisterVariable (&halflifebsp);
-
-       // any special defaults for gamemodes go here
-       if (gamemode == GAME_NEHAHRA)
-       {
-               // Nehahra pushable crates malfunction in some levels if this is on
-               Cvar_SetValueQuick (&sv_gameplayfix_upwardvelocityclearsongroundflag, 0);
-               // Nehahra NPC AI is confused by this feature
-               Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
-       }
-       if (gamemode == GAME_HIPNOTIC)
-       {
-               // hipnotic mission pack has issues in their 'friendly monster' ai, which seem to attempt to attack themselves for some reason when findradius() returns non-solid entities.
-               Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
-               // hipnotic mission pack has issues with bobbing water entities 'jittering' between different heights on alternate frames at the default 0.0138889 ticrate, 0.02 avoids this issue
-               Cvar_SetValueQuick (&sys_ticrate, 0.02);
-               // hipnotic mission pack has issues in their proximity mine sticking code, which causes them to bounce off.
-               Cvar_SetValueQuick (&sv_gameplayfix_slidemoveprojectiles, 0);
-       }
-       if (gamemode == GAME_ROGUE)
-       {
-               // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
-               Cvar_SetValueQuick (&sv_gameplayfix_findradiusdistancetobox, 0);
-       }
-       if (gamemode == GAME_NEXUIZ)
-       {
-               // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
-               Cvar_SetValueQuick (&sv_gameplayfix_q2airaccelerate, 1);
-       }
+       Cvar_RegisterVariable (&sv_mapformat_is_quake2);
+       Cvar_RegisterVariable (&sv_mapformat_is_quake3);
 
        sv_mempool = Mem_AllocPool("server", 0, NULL);
 }
 
 static void SV_SaveEntFile_f(void)
 {
-       char basename[MAX_QPATH];
+       char vabuf[1024];
        if (!sv.active || !sv.worldmodel)
        {
                Con_Print("Not running a server\n");
                return;
        }
-       FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
-       FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
+       FS_WriteFile(va(vabuf, sizeof(vabuf), "%s.ent", sv.worldnamenoextension), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
 }
 
 
@@ -622,13 +714,17 @@ Larger attenuations will drop off.  (max 4 attenuation)
 
 ==================
 */
-void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation)
+void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int nvolume, float attenuation, qboolean reliable, float speed)
 {
-       int sound_num, field_mask, i, ent;
+       prvm_prog_t *prog = SVVM_prog;
+       sizebuf_t *dest;
+       int sound_num, field_mask, i, ent, speed4000;
 
-       if (volume < 0 || volume > 255)
+       dest = (reliable ? &sv.reliable_datagram : &sv.datagram);
+
+       if (nvolume < 0 || nvolume > 255)
        {
-               Con_Printf ("SV_StartSound: volume = %i\n", volume);
+               Con_Printf ("SV_StartSound: volume = %i\n", nvolume);
                return;
        }
 
@@ -638,12 +734,14 @@ void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int v
                return;
        }
 
-       if (channel < 0 || channel > 7)
+       if (!IS_CHAN(channel))
        {
                Con_Printf ("SV_StartSound: channel = %i\n", channel);
                return;
        }
 
+       channel = CHAN_ENGINE2NET(channel);
+
        if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
                return;
 
@@ -654,37 +752,45 @@ void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int v
 
        ent = PRVM_NUM_FOR_EDICT(entity);
 
+       speed4000 = (int)floor(speed * 4000.0f + 0.5f);
        field_mask = 0;
-       if (volume != DEFAULT_SOUND_PACKET_VOLUME)
+       if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
                field_mask |= SND_VOLUME;
        if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
                field_mask |= SND_ATTENUATION;
-       if (ent >= 8192)
+       if (speed4000 && speed4000 != 4000)
+               field_mask |= SND_SPEEDUSHORT4000;
+       if (ent >= 8192 || channel < 0 || channel > 7)
                field_mask |= SND_LARGEENTITY;
-       if (sound_num >= 256 || channel >= 8)
+       if (sound_num >= 256)
                field_mask |= SND_LARGESOUND;
 
 // directed messages go only to the entity they are targeted on
-       MSG_WriteByte (&sv.datagram, svc_sound);
-       MSG_WriteByte (&sv.datagram, field_mask);
+       MSG_WriteByte (dest, svc_sound);
+       MSG_WriteByte (dest, field_mask);
        if (field_mask & SND_VOLUME)
-               MSG_WriteByte (&sv.datagram, volume);
+               MSG_WriteByte (dest, nvolume);
        if (field_mask & SND_ATTENUATION)
-               MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
+               MSG_WriteByte (dest, (int)(attenuation*64));
+       if (field_mask & SND_SPEEDUSHORT4000)
+               MSG_WriteShort (dest, speed4000);
        if (field_mask & SND_LARGEENTITY)
        {
-               MSG_WriteShort (&sv.datagram, ent);
-               MSG_WriteByte (&sv.datagram, channel);
+               MSG_WriteShort (dest, ent);
+               MSG_WriteChar (dest, channel);
        }
        else
-               MSG_WriteShort (&sv.datagram, (ent<<3) | channel);
+               MSG_WriteShort (dest, (ent<<3) | channel);
        if ((field_mask & SND_LARGESOUND) || sv.protocol == PROTOCOL_NEHAHRABJP2)
-               MSG_WriteShort (&sv.datagram, sound_num);
+               MSG_WriteShort (dest, sound_num);
        else
-               MSG_WriteByte (&sv.datagram, sound_num);
+               MSG_WriteByte (dest, sound_num);
        for (i = 0;i < 3;i++)
-               MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
-       SV_FlushBroadcastMessages();
+               MSG_WriteCoord (dest, PRVM_serveredictvector(entity, origin)[i]+0.5*(PRVM_serveredictvector(entity, mins)[i]+PRVM_serveredictvector(entity, maxs)[i]), sv.protocol);
+
+       // TODO do we have to do anything here when dest is &sv.reliable_datagram?
+       if(!reliable)
+               SV_FlushBroadcastMessages();
 }
 
 /*
@@ -700,13 +806,13 @@ function, therefore the check for it is omitted.
 
 ==================
 */
-void SV_StartPointSound (vec3_t origin, const char *sample, int volume, float attenuation)
+void SV_StartPointSound (vec3_t origin, const char *sample, int nvolume, float attenuation, float speed)
 {
-       int sound_num, field_mask, i;
+       int sound_num, field_mask, i, speed4000;
 
-       if (volume < 0 || volume > 255)
+       if (nvolume < 0 || nvolume > 255)
        {
-               Con_Printf ("SV_StartPointSound: volume = %i\n", volume);
+               Con_Printf ("SV_StartPointSound: volume = %i\n", nvolume);
                return;
        }
 
@@ -724,21 +830,26 @@ void SV_StartPointSound (vec3_t origin, const char *sample, int volume, float at
        if (!sound_num)
                return;
 
+       speed4000 = (int)(speed * 40.0f);
        field_mask = 0;
-       if (volume != DEFAULT_SOUND_PACKET_VOLUME)
+       if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
                field_mask |= SND_VOLUME;
        if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
                field_mask |= SND_ATTENUATION;
        if (sound_num >= 256)
                field_mask |= SND_LARGESOUND;
+       if (speed4000 && speed4000 != 4000)
+               field_mask |= SND_SPEEDUSHORT4000;
 
 // directed messages go only to the entity they are targeted on
        MSG_WriteByte (&sv.datagram, svc_sound);
        MSG_WriteByte (&sv.datagram, field_mask);
        if (field_mask & SND_VOLUME)
-               MSG_WriteByte (&sv.datagram, volume);
+               MSG_WriteByte (&sv.datagram, nvolume);
        if (field_mask & SND_ATTENUATION)
                MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
+       if (field_mask & SND_SPEEDUSHORT4000)
+               MSG_WriteShort (&sv.datagram, speed4000);
        // Always write entnum 0 for the world entity
        MSG_WriteShort (&sv.datagram, (0<<3) | 0);
        if (field_mask & SND_LARGESOUND)
@@ -768,8 +879,10 @@ This will be sent on the initial connection and upon each server load.
 */
 void SV_SendServerinfo (client_t *client)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int i;
        char message[128];
+       char vabuf[1024];
 
        // we know that this client has a netconnection and thus is not a bot
 
@@ -811,7 +924,6 @@ void SV_SendServerinfo (client_t *client)
        {
                client->csqcentityscope[i] = 0;
                client->csqcentitysendflags[i] = 0xFFFFFF;
-               client->csqcentityglobalhistory[i] = 0;
        }
        for (i = 0;i < NUM_CSQCENTITYDB_FRAMES;i++)
        {
@@ -827,23 +939,18 @@ void SV_SendServerinfo (client_t *client)
        MSG_WriteString (&client->netconnection->message,message);
 
        SV_StopDemoRecording(client); // to split up demos into different files
-       if(sv_autodemo_perclient.integer && client->netconnection)
+       if(sv_autodemo_perclient.integer)
        {
                char demofile[MAX_OSPATH];
-               char levelname[MAX_QPATH];
                char ipaddress[MAX_QPATH];
-               size_t i;
+               size_t j;
 
                // start a new demo file
-               strlcpy(levelname, FS_FileWithoutPath(sv.worldmodel->name), sizeof(levelname));
-               if (strrchr(levelname, '.'))
-                       *(strrchr(levelname, '.')) = 0;
-
                LHNETADDRESS_ToString(&(client->netconnection->peeraddress), ipaddress, sizeof(ipaddress), true);
-               for(i = 0; ipaddress[i]; ++i)
-                       if(!isalnum(ipaddress[i]))
-                               ipaddress[i] = '-';
-               dpsnprintf (demofile, sizeof(demofile), "%s_%s_%d_%s.dem", Sys_TimeString (sv_autodemo_perclient_nameformat.string), levelname, PRVM_NUM_FOR_EDICT(client->edict), ipaddress);
+               for(j = 0; ipaddress[j]; ++j)
+                       if(!isalnum(ipaddress[j]))
+                               ipaddress[j] = '-';
+               dpsnprintf (demofile, sizeof(demofile), "%s_%s_%d_%s.dem", Sys_TimeString (sv_autodemo_perclient_nameformat.string), sv.worldbasename, PRVM_NUM_FOR_EDICT(client->edict), ipaddress);
 
                SV_StartDemoRecording(client, demofile, -1);
        }
@@ -851,34 +958,32 @@ void SV_SendServerinfo (client_t *client)
        //[515]: init csprogs according to version of svprogs, check the crc, etc.
        if (sv.csqc_progname[0])
        {
-               prvm_eval_t *val;
                Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
                MSG_WriteByte (&client->netconnection->message, svc_stufftext);
-               MSG_WriteString (&client->netconnection->message, va("csqc_progname %s\n", sv.csqc_progname));
+               MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progname %s\n", sv.csqc_progname));
                MSG_WriteByte (&client->netconnection->message, svc_stufftext);
-               MSG_WriteString (&client->netconnection->message, va("csqc_progsize %i\n", sv.csqc_progsize));
+               MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progsize %i\n", sv.csqc_progsize));
                MSG_WriteByte (&client->netconnection->message, svc_stufftext);
-               MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i\n", sv.csqc_progcrc));
+               MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progcrc %i\n", sv.csqc_progcrc));
 
                if(client->sv_demo_file != NULL)
                {
-                       int i;
+                       int k;
                        static char buf[NET_MAXMESSAGE];
                        sizebuf_t sb;
 
                        sb.data = (unsigned char *) buf;
                        sb.maxsize = sizeof(buf);
-                       i = 0;
-                       while(MakeDownloadPacket(sv.csqc_progname, svs.csqc_progdata, sv.csqc_progsize, sv.csqc_progcrc, i++, &sb, sv.protocol))
+                       k = 0;
+                       while(MakeDownloadPacket(sv.csqc_progname, svs.csqc_progdata, sv.csqc_progsize, sv.csqc_progcrc, k++, &sb, sv.protocol))
                                SV_WriteDemoMessage(client, &sb, false);
                }
 
                //[515]: init stufftext string (it is sent before svc_serverinfo)
-               val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.SV_InitCmd);
-               if (val)
+               if (PRVM_GetString(prog, PRVM_serverglobalstring(SV_InitCmd)))
                {
                        MSG_WriteByte (&client->netconnection->message, svc_stufftext);
-                       MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(val->string)));
+                       MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "%s\n", PRVM_GetString(prog, PRVM_serverglobalstring(SV_InitCmd))));
                }
        }
 
@@ -908,7 +1013,7 @@ void SV_SendServerinfo (client_t *client)
        else
                MSG_WriteByte (&client->netconnection->message, GAME_COOP);
 
-       MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
+       MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)));
 
        for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
                MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
@@ -920,8 +1025,8 @@ void SV_SendServerinfo (client_t *client)
 
 // send music
        MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
-       MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
-       MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
+       MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
+       MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
 
 // set view
 // store this in clientcamera, too
@@ -932,7 +1037,9 @@ void SV_SendServerinfo (client_t *client)
        MSG_WriteByte (&client->netconnection->message, svc_signonnum);
        MSG_WriteByte (&client->netconnection->message, 1);
 
+       client->prespawned = false;             // need prespawn, spawn, etc
        client->spawned = false;                // need prespawn, spawn, etc
+       client->begun = false;                  // need prespawn, spawn, etc
        client->sendsignon = 1;                 // send this message, and increment to 2, 2 will be set to 0 by the prespawn command
 
        // clear movement info until client enters the new level properly
@@ -961,24 +1068,46 @@ once for a player each game, not once for each level change.
 */
 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
 {
+       prvm_prog_t *prog = SVVM_prog;
        client_t                *client;
        int                             i;
-       float                   spawn_parms[NUM_SPAWN_PARMS];
 
        client = svs.clients + clientnum;
 
 // set up the client_t
        if (sv.loadgame)
-               memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
-       memset (client, 0, sizeof(*client));
+       {
+               float backupparms[NUM_SPAWN_PARMS];
+               memcpy(backupparms, client->spawn_parms, sizeof(backupparms));
+               memset(client, 0, sizeof(*client));
+               memcpy(client->spawn_parms, backupparms, sizeof(backupparms));
+       }
+       else
+               memset(client, 0, sizeof(*client));
        client->active = true;
        client->netconnection = netconnection;
 
        Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
 
+       if(client->netconnection && client->netconnection->crypto.authenticated)
+       {
+               Con_Printf("%s connection to %s has been established: client is %s@%s%.*s, I am %.*s@%s%.*s\n",
+                               client->netconnection->crypto.use_aes ? "Encrypted" : "Authenticated",
+                               client->netconnection->address,
+                               client->netconnection->crypto.client_idfp[0] ? client->netconnection->crypto.client_idfp : "-",
+                               (client->netconnection->crypto.client_issigned || !client->netconnection->crypto.client_keyfp[0]) ? "" : "~",
+                               crypto_keyfp_recommended_length, client->netconnection->crypto.client_keyfp[0] ? client->netconnection->crypto.client_keyfp : "-",
+                               crypto_keyfp_recommended_length, client->netconnection->crypto.server_idfp[0] ? client->netconnection->crypto.server_idfp : "-",
+                               (client->netconnection->crypto.server_issigned || !client->netconnection->crypto.server_keyfp[0]) ? "" : "~",
+                               crypto_keyfp_recommended_length, client->netconnection->crypto.server_keyfp[0] ? client->netconnection->crypto.server_keyfp : "-"
+                               );
+       }
+
        strlcpy(client->name, "unconnected", sizeof(client->name));
        strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
+       client->prespawned = false;
        client->spawned = false;
+       client->begun = false;
        client->edict = PRVM_EDICT_NUM(clientnum+1);
        if (client->netconnection)
                client->netconnection->message.allowoverflow = true;            // we can catch it
@@ -987,24 +1116,20 @@ void SV_ConnectClient (int clientnum, netconn_t *netconnection)
        client->unreliablemsg.maxsize = sizeof(client->unreliablemsg_data);
        // updated by receiving "rate" command from client, this is also the default if not using a DP client
        client->rate = 1000000000;
-       // no limits for local player
-       if (client->netconnection && LHNETADDRESS_GetAddressType(&client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP)
-               client->rate = 1000000000;
        client->connecttime = realtime;
 
-       if (sv.loadgame)
-               memcpy (client->spawn_parms, spawn_parms, sizeof(spawn_parms));
-       else
+       if (!sv.loadgame)
        {
                // call the progs to get default spawn parms for the new client
                // set self to world to intentionally cause errors with broken SetNewParms code in some mods
-               prog->globals.server->self = 0;
-               PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
+               PRVM_serverglobalfloat(time) = sv.time;
+               PRVM_serverglobaledict(self) = 0;
+               prog->ExecuteProgram(prog, PRVM_serverfunction(SetNewParms), "QC function SetNewParms is missing");
                for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
-                       client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
+                       client->spawn_parms[i] = (&PRVM_serverglobalfloat(parm1))[i];
 
                // set up the entity for this client (including .colormap, .team, etc)
-               PRVM_ED_ClearEdict(client->edict);
+               PRVM_ED_ClearEdict(prog, client->edict);
        }
 
        // don't call SendServerinfo for a fresh botclient because its fields have
@@ -1012,7 +1137,7 @@ void SV_ConnectClient (int clientnum, netconn_t *netconnection)
        if (client->netconnection)
                SV_SendServerinfo (client);
        else
-               client->spawned = true;
+               client->prespawned = client->spawned = client->begun = true;
 }
 
 
@@ -1037,6 +1162,7 @@ crosses a waterline.
 
 static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int enumber)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int i;
        unsigned int sendflags;
        unsigned int version;
@@ -1044,49 +1170,50 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        unsigned int customizeentityforclient;
        unsigned int sendentity;
        float f;
+       prvm_vec_t *v;
        vec3_t cullmins, cullmaxs;
        dp_model_t *model;
-       prvm_eval_t *val, *val2;
 
        // fast path for games that do not use legacy entity networking
        // note: still networks clients even if they are legacy
-       sendentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.SendEntity)->function;
+       sendentity = PRVM_serveredictfunction(ent, SendEntity);
        if (sv_onlycsqcnetworking.integer && !sendentity && enumber > svs.maxclients)
                return false;
 
        // this 2 billion unit check is actually to detect NAN origins
        // (we really don't want to send those)
-       if (!(VectorLength2(ent->fields.server->origin) < 2000000000.0*2000000000.0))
+       if (!(VectorLength2(PRVM_serveredictvector(ent, origin)) < 2000000000.0*2000000000.0))
                return false;
 
        // EF_NODRAW prevents sending for any reason except for your own
        // client, so we must keep all clients in this superset
-       effects = (unsigned)ent->fields.server->effects;
+       effects = (unsigned)PRVM_serveredictfloat(ent, effects);
 
        // we can omit invisible entities with no effects that are not clients
        // LordHavoc: this could kill tags attached to an invisible entity, I
        // just hope we never have to support that case
-       i = (int)ent->fields.server->modelindex;
-       modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model) && sv.models[i]) ? i : 0;
+       i = (int)PRVM_serveredictfloat(ent, modelindex);
+       modelindex = (i >= 1 && i < MAX_MODELS && PRVM_serveredictstring(ent, model) && *PRVM_GetString(prog, PRVM_serveredictstring(ent, model)) && sv.models[i]) ? i : 0;
 
        flags = 0;
-       i = (int)(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_size)->_float * 0.25f);
+       i = (int)(PRVM_serveredictfloat(ent, glow_size) * 0.25f);
        glowsize = (unsigned char)bound(0, i, 255);
-       if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->_float)
+       if (PRVM_serveredictfloat(ent, glow_trail))
                flags |= RENDER_GLOWTRAIL;
-       if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict)
+       if (PRVM_serveredictedict(ent, viewmodelforclient))
                flags |= RENDER_VIEWMODEL;
 
-       f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[0]*256;
+       v = PRVM_serveredictvector(ent, color);
+       f = v[0]*256;
        light[0] = (unsigned short)bound(0, f, 65535);
-       f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[1]*256;
+       f = v[1]*256;
        light[1] = (unsigned short)bound(0, f, 65535);
-       f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[2]*256;
+       f = v[2]*256;
        light[2] = (unsigned short)bound(0, f, 65535);
-       f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.light_lev)->_float;
+       f = PRVM_serveredictfloat(ent, light_lev);
        light[3] = (unsigned short)bound(0, f, 65535);
-       lightstyle = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.style)->_float;
-       lightpflags = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pflags)->_float;
+       lightstyle = (unsigned char)PRVM_serveredictfloat(ent, style);
+       lightpflags = (unsigned char)PRVM_serveredictfloat(ent, pflags);
 
        if (gamemode == GAME_TENEBRAE)
        {
@@ -1137,61 +1264,62 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
 
        // early culling checks
        // (final culling is done by SV_MarkWriteEntityStateToClient)
-       customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function;
+       customizeentityforclient = PRVM_serveredictfunction(ent, customizeentityforclient);
        if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
                return false;
 
        *cs = defaultstate;
        cs->active = ACTIVE_NETWORK;
        cs->number = enumber;
-       VectorCopy(ent->fields.server->origin, cs->origin);
-       VectorCopy(ent->fields.server->angles, cs->angles);
+       VectorCopy(PRVM_serveredictvector(ent, origin), cs->origin);
+       VectorCopy(PRVM_serveredictvector(ent, angles), cs->angles);
        cs->flags = flags;
        cs->effects = effects;
-       cs->colormap = (unsigned)ent->fields.server->colormap;
+       cs->colormap = (unsigned)PRVM_serveredictfloat(ent, colormap);
        cs->modelindex = modelindex;
-       cs->skin = (unsigned)ent->fields.server->skin;
-       cs->frame = (unsigned)ent->fields.server->frame;
-       cs->viewmodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict;
-       cs->exteriormodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.exteriormodeltoclient)->edict;
-       cs->nodrawtoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict;
-       cs->drawonlytoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict;
+       cs->skin = (unsigned)PRVM_serveredictfloat(ent, skin);
+       cs->frame = (unsigned)PRVM_serveredictfloat(ent, frame);
+       cs->viewmodelforclient = PRVM_serveredictedict(ent, viewmodelforclient);
+       cs->exteriormodelforclient = PRVM_serveredictedict(ent, exteriormodeltoclient);
+       cs->nodrawtoclient = PRVM_serveredictedict(ent, nodrawtoclient);
+       cs->drawonlytoclient = PRVM_serveredictedict(ent, drawonlytoclient);
        cs->customizeentityforclient = customizeentityforclient;
-       cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict;
-       cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
+       cs->tagentity = PRVM_serveredictedict(ent, tag_entity);
+       cs->tagindex = (unsigned char)PRVM_serveredictfloat(ent, tag_index);
        cs->glowsize = glowsize;
+       cs->traileffectnum = PRVM_serveredictfloat(ent, traileffectnum);
 
        // don't need to init cs->colormod because the defaultstate did that for us
        //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
-       val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod);
-       if (val->vector[0] || val->vector[1] || val->vector[2])
+       v = PRVM_serveredictvector(ent, colormod);
+       if (VectorLength2(v))
        {
-               i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
-               i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
-               i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
+               i = (int)(v[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
+               i = (int)(v[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
+               i = (int)(v[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
        }
 
        // don't need to init cs->glowmod because the defaultstate did that for us
        //cs->glowmod[0] = cs->glowmod[1] = cs->glowmod[2] = 32;
-       val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glowmod);
-       if (val->vector[0] || val->vector[1] || val->vector[2])
+       v = PRVM_serveredictvector(ent, glowmod);
+       if (VectorLength2(v))
        {
-               i = (int)(val->vector[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);
-               i = (int)(val->vector[1] * 32.0f);cs->glowmod[1] = bound(0, i, 255);
-               i = (int)(val->vector[2] * 32.0f);cs->glowmod[2] = bound(0, i, 255);
+               i = (int)(v[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);
+               i = (int)(v[1] * 32.0f);cs->glowmod[1] = bound(0, i, 255);
+               i = (int)(v[2] * 32.0f);cs->glowmod[2] = bound(0, i, 255);
        }
 
        cs->modelindex = modelindex;
 
        cs->alpha = 255;
-       f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f);
+       f = (PRVM_serveredictfloat(ent, alpha) * 255.0f);
        if (f)
        {
                i = (int)f;
                cs->alpha = (unsigned char)bound(0, i, 255);
        }
        // halflife
-       f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float);
+       f = (PRVM_serveredictfloat(ent, renderamt));
        if (f)
        {
                i = (int)f;
@@ -1199,7 +1327,7 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        }
 
        cs->scale = 16;
-       f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f);
+       f = (PRVM_serveredictfloat(ent, scale) * 16.0f);
        if (f)
        {
                i = (int)f;
@@ -1207,26 +1335,46 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        }
 
        cs->glowcolor = 254;
-       f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float);
+       f = PRVM_serveredictfloat(ent, glow_color);
        if (f)
                cs->glowcolor = (int)f;
 
-       if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float)
+       if (PRVM_serveredictfloat(ent, fullbright))
                cs->effects |= EF_FULLBRIGHT;
 
-       val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.modelflags);
-       if (val && val->_float)
-               cs->effects |= ((unsigned int)val->_float & 0xff) << 24;
+       f = PRVM_serveredictfloat(ent, modelflags);
+       if (f)
+               cs->effects |= ((unsigned int)f & 0xff) << 24;
 
-       if (ent->fields.server->movetype == MOVETYPE_STEP)
+       if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP)
                cs->flags |= RENDER_STEP;
        if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767)
                cs->flags |= RENDER_LOWPRECISION;
-       if (ent->fields.server->colormap >= 1024)
+       if (PRVM_serveredictfloat(ent, colormap) >= 1024)
                cs->flags |= RENDER_COLORMAPPED;
        if (cs->viewmodelforclient)
                cs->flags |= RENDER_VIEWMODEL; // show relative to the view
 
+       if (PRVM_serveredictfloat(ent, sendcomplexanimation))
+       {
+               cs->flags |= RENDER_COMPLEXANIMATION;
+               if (PRVM_serveredictfloat(ent, skeletonindex) >= 1)
+                       cs->skeletonobject = ent->priv.server->skeleton;
+               cs->framegroupblend[0].frame = PRVM_serveredictfloat(ent, frame);
+               cs->framegroupblend[1].frame = PRVM_serveredictfloat(ent, frame2);
+               cs->framegroupblend[2].frame = PRVM_serveredictfloat(ent, frame3);
+               cs->framegroupblend[3].frame = PRVM_serveredictfloat(ent, frame4);
+               cs->framegroupblend[0].start = PRVM_serveredictfloat(ent, frame1time);
+               cs->framegroupblend[1].start = PRVM_serveredictfloat(ent, frame2time);
+               cs->framegroupblend[2].start = PRVM_serveredictfloat(ent, frame3time);
+               cs->framegroupblend[3].start = PRVM_serveredictfloat(ent, frame4time);
+               cs->framegroupblend[1].lerp = PRVM_serveredictfloat(ent, lerpfrac);
+               cs->framegroupblend[2].lerp = PRVM_serveredictfloat(ent, lerpfrac3);
+               cs->framegroupblend[3].lerp = PRVM_serveredictfloat(ent, lerpfrac4);
+               cs->framegroupblend[0].lerp = 1.0f - cs->framegroupblend[1].lerp - cs->framegroupblend[2].lerp - cs->framegroupblend[3].lerp;
+               cs->frame = 0; // don't need the legacy frame
+       }
+
        cs->light[0] = light[0];
        cs->light[1] = light[1];
        cs->light[2] = light[2];
@@ -1261,8 +1409,8 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        else
        {
                // if there is no model (or it could not be loaded), use the physics box
-               VectorAdd(cs->origin, ent->fields.server->mins, cullmins);
-               VectorAdd(cs->origin, ent->fields.server->maxs, cullmaxs);
+               VectorAdd(cs->origin, PRVM_serveredictvector(ent, mins), cullmins);
+               VectorAdd(cs->origin, PRVM_serveredictvector(ent, maxs), cullmaxs);
        }
        if (specialvisibilityradius)
        {
@@ -1300,14 +1448,11 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        // (to let the QC know that they've been read)
        if (sendentity)
        {
-               val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.SendFlags);
-               sendflags = (unsigned int)val->_float;
-               val->_float = 0;
+               sendflags = (unsigned int)PRVM_serveredictfloat(ent, SendFlags);
+               PRVM_serveredictfloat(ent, SendFlags) = 0;
                // legacy self.Version system
-               val2 = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.Version);
-               if (val2->_float)
+               if ((version = (unsigned int)PRVM_serveredictfloat(ent, Version)))
                {
-                       version = (unsigned int)val2->_float;
                        if (sv.csqcentityversion[enumber] != version)
                                sendflags = 0xFFFFFF;
                        sv.csqcentityversion[enumber] = version;
@@ -1323,8 +1468,9 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        return true;
 }
 
-void SV_PrepareEntitiesForSending(void)
+static void SV_PrepareEntitiesForSending(void)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int e;
        prvm_edict_t *ent;
        // send all entities that touch the pvs
@@ -1343,11 +1489,14 @@ void SV_PrepareEntitiesForSending(void)
 
 #define MAX_LINEOFSIGHTTRACES 64
 
-qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
+qboolean SV_CanSeeBox(int numtraces, vec_t eyejitter, vec_t enlarge, vec_t entboxexpand, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
 {
+       prvm_prog_t *prog = SVVM_prog;
        float pitchsign;
        float alpha;
        float starttransformed[3], endtransformed[3];
+       float boxminstransformed[3], boxmaxstransformed[3];
+       float localboxcenter[3], localboxextents[3], localboxmins[3], localboxmaxs[3];
        int blocked = 0;
        int traceindex;
        int originalnumtouchedicts;
@@ -1357,27 +1506,35 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
        dp_model_t *model;
        prvm_edict_t *touch;
        static prvm_edict_t *touchedicts[MAX_EDICTS];
+       vec3_t eyemins, eyemaxs, start;
        vec3_t boxmins, boxmaxs;
        vec3_t clipboxmins, clipboxmaxs;
        vec3_t endpoints[MAX_LINEOFSIGHTTRACES];
 
        numtraces = min(numtraces, MAX_LINEOFSIGHTTRACES);
 
+       // jitter the eye location within this box
+       eyemins[0] = eye[0] - eyejitter;
+       eyemaxs[0] = eye[0] + eyejitter;
+       eyemins[1] = eye[1] - eyejitter;
+       eyemaxs[1] = eye[1] + eyejitter;
+       eyemins[2] = eye[2] - eyejitter;
+       eyemaxs[2] = eye[2] + eyejitter;
        // expand the box a little
-       boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0];
-       boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0];
-       boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1];
-       boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1];
-       boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2];
-       boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2];
+       boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0] - entboxexpand;
+       boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0] + entboxexpand;
+       boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1] - entboxexpand;
+       boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1] + entboxexpand;
+       boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2] - entboxexpand;
+       boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2] + entboxexpand;
 
        VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, endpoints[0]);
        for (traceindex = 1;traceindex < numtraces;traceindex++)
                VectorSet(endpoints[traceindex], lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
 
        // calculate sweep box for the entire swarm of traces
-       VectorCopy(eye, clipboxmins);
-       VectorCopy(eye, clipboxmaxs);
+       VectorCopy(eyemins, clipboxmins);
+       VectorCopy(eyemaxs, clipboxmaxs);
        for (traceindex = 0;traceindex < numtraces;traceindex++)
        {
                clipboxmins[0] = min(clipboxmins[0], endpoints[traceindex][0]);
@@ -1390,7 +1547,7 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
 
        // get the list of entities in the sweep box
        if (sv_cullentities_trace_entityocclusion.integer)
-               numtouchedicts = World_EntitiesInBox(&sv.world, clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
+               numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
        if (numtouchedicts > MAX_EDICTS)
        {
                // this never happens
@@ -1403,16 +1560,16 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
        for (touchindex = 0;touchindex < originalnumtouchedicts;touchindex++)
        {
                touch = touchedicts[touchindex];
-               if (touch->fields.server->solid != SOLID_BSP)
+               if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
                        continue;
                model = SV_GetModelFromEdict(touch);
                if (!model || !model->brush.TraceLineOfSight)
                        continue;
                // skip obviously transparent entities
-               alpha = PRVM_EDICTFIELDVALUE(touch, prog->fieldoffsets.alpha)->_float;
+               alpha = PRVM_serveredictfloat(touch, alpha);
                if (alpha && alpha < 1)
                        continue;
-               if ((int)touch->fields.server->effects & EF_ADDITIVE)
+               if ((int)PRVM_serveredictfloat(touch, effects) & EF_ADDITIVE)
                        continue;
                touchedicts[numtouchedicts++] = touch;
        }
@@ -1423,9 +1580,10 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
 
        for (traceindex = 0;traceindex < numtraces;traceindex++)
        {
+               VectorSet(start, lhrandom(eyemins[0], eyemaxs[0]), lhrandom(eyemins[1], eyemaxs[1]), lhrandom(eyemins[2], eyemaxs[2]));
                // check world occlusion
                if (sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight)
-                       if (!sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, eye, endpoints[traceindex]))
+                       if (!sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, start, endpoints[traceindex], boxmins, boxmaxs))
                                continue;
                for (touchindex = 0;touchindex < numtouchedicts;touchindex++)
                {
@@ -1434,13 +1592,26 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
                        if(model && model->brush.TraceLineOfSight)
                        {
                                // get the entity matrix
-                               pitchsign = SV_GetPitchSign(touch);
-                               Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+                               pitchsign = SV_GetPitchSign(prog, touch);
+                               Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
                                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                                // see if the ray hits this entity
-                               Matrix4x4_Transform(&imatrix, eye, starttransformed);
+                               Matrix4x4_Transform(&imatrix, start, starttransformed);
                                Matrix4x4_Transform(&imatrix, endpoints[traceindex], endtransformed);
-                               if (!model->brush.TraceLineOfSight(model, starttransformed, endtransformed))
+                               Matrix4x4_Transform(&imatrix, boxmins, boxminstransformed);
+                               Matrix4x4_Transform(&imatrix, boxmaxs, boxmaxstransformed);
+                               // transform the AABB to local space
+                               VectorMAM(0.5f, boxminstransformed, 0.5f, boxmaxstransformed, localboxcenter);
+                               localboxextents[0] = fabs(boxmaxstransformed[0] - localboxcenter[0]);
+                               localboxextents[1] = fabs(boxmaxstransformed[1] - localboxcenter[1]);
+                               localboxextents[2] = fabs(boxmaxstransformed[2] - localboxcenter[2]);
+                               localboxmins[0] = localboxcenter[0] - localboxextents[0];
+                               localboxmins[1] = localboxcenter[1] - localboxextents[1];
+                               localboxmins[2] = localboxcenter[2] - localboxextents[2];
+                               localboxmaxs[0] = localboxcenter[0] + localboxextents[0];
+                               localboxmaxs[1] = localboxcenter[1] + localboxextents[1];
+                               localboxmaxs[2] = localboxcenter[2] + localboxextents[2];
+                               if (!model->brush.TraceLineOfSight(model, starttransformed, endtransformed, localboxmins, localboxmaxs))
                                {
                                        blocked++;
                                        break;
@@ -1458,8 +1629,9 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
        return false;
 }
 
-void SV_MarkWriteEntityStateToClient(entity_state_t *s)
+static void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int isbmodel;
        dp_model_t *model;
        prvm_edict_t *ed;
@@ -1470,9 +1642,10 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 
        if (s->customizeentityforclient)
        {
-               prog->globals.server->self = s->number;
-               prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
-               PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
+               PRVM_serverglobalfloat(time) = sv.time;
+               PRVM_serverglobaledict(self) = s->number;
+               PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;
+               prog->ExecuteProgram(prog, s->customizeentityforclient, "customizeentityforclient: NULL function");
                if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
                        return;
        }
@@ -1516,7 +1689,7 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
                        ed = PRVM_EDICT_NUM(s->number);
 
                        // if not touching a visible leaf
-                       if (sv_cullentities_pvs.integer && !r_novis.integer && sv.writeentitiestoclient_pvsbytes)
+                       if (sv_cullentities_pvs.integer && !r_novis.integer && !r_trippy.integer && sv.writeentitiestoclient_pvsbytes)
                        {
                                if (ed->priv.server->pvs_numclusters < 0)
                                {
@@ -1543,7 +1716,7 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
                        }
 
                        // or not seen by random tracelines
-                       if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel->brush.TraceLineOfSight)
+                       if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight && !r_trippy.integer)
                        {
                                int samples =
                                        s->number <= svs.maxclients
@@ -1558,7 +1731,7 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
                                {
                                        int eyeindex;
                                        for (eyeindex = 0;eyeindex < sv.writeentitiestoclient_numeyes;eyeindex++)
-                                               if(SV_CanSeeBox(samples, enlarge, sv.writeentitiestoclient_eyes[eyeindex], ed->priv.server->cullmins, ed->priv.server->cullmaxs))
+                                               if(SV_CanSeeBox(samples, sv_cullentities_trace_eyejitter.value, enlarge, sv_cullentities_trace_expand.value, sv.writeentitiestoclient_eyes[eyeindex], ed->priv.server->cullmins, ed->priv.server->cullmaxs))
                                                        break;
                                        if(eyeindex < sv.writeentitiestoclient_numeyes)
                                                svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number] =
@@ -1586,22 +1759,16 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 
 #if MAX_LEVELNETWORKEYES > 0
 #define MAX_EYE_RECURSION 1 // increase if recursion gets supported by portals
-void SV_AddCameraEyes(void)
+static void SV_AddCameraEyes(void)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int e, i, j, k;
        prvm_edict_t *ed;
-       int cameras[MAX_LEVELNETWORKEYES];
-       vec3_t camera_origins[MAX_LEVELNETWORKEYES];
-       int eye_levels[MAX_CLIENTNETWORKEYES];
+       static int cameras[MAX_LEVELNETWORKEYES];
+       static vec3_t camera_origins[MAX_LEVELNETWORKEYES];
+       static int eye_levels[MAX_CLIENTNETWORKEYES];
        int n_cameras = 0;
        vec3_t mi, ma;
-       prvm_eval_t *valendpos, *val;
-
-       if(!prog->fieldoffsets.camera_transform)
-               return;
-       valendpos = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_endpos);
-       if(!valendpos)
-               return;
 
        for(i = 0; i < sv.writeentitiestoclient_numeyes; ++i)
                eye_levels[i] = 0;
@@ -1611,20 +1778,23 @@ void SV_AddCameraEyes(void)
        {
                if (!ed->priv.server->free)
                {
-                       if((val = PRVM_EDICTFIELDVALUE(ed, prog->fieldoffsets.camera_transform)) && val->function)
+                       if(PRVM_serveredictfunction(ed, camera_transform))
                        {
-                               prog->globals.server->self = e;
-                               prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
-                               VectorCopy(sv.writeentitiestoclient_eyes[0], valendpos->vector);
+                               PRVM_serverglobalfloat(time) = sv.time;
+                               PRVM_serverglobaledict(self) = e;
+                               PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;
+                               VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_serverglobalvector(trace_endpos));
                                VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_G_VECTOR(OFS_PARM0));
                                VectorClear(PRVM_G_VECTOR(OFS_PARM1));
-                               PRVM_ExecuteProgram(val->function, "QC function e.camera_transform is missing");
-                               if(!VectorCompare(valendpos->vector, sv.writeentitiestoclient_eyes[0]))
-                                       VectorCopy(valendpos->vector, camera_origins[n_cameras]);
-                               cameras[n_cameras] = e;
-                               ++n_cameras;
-                               if(n_cameras >= MAX_LEVELNETWORKEYES)
-                                       break;
+                               prog->ExecuteProgram(prog, PRVM_serveredictfunction(ed, camera_transform), "QC function e.camera_transform is missing");
+                               if(!VectorCompare(PRVM_serverglobalvector(trace_endpos), sv.writeentitiestoclient_eyes[0]))
+                               {
+                                       VectorCopy(PRVM_serverglobalvector(trace_endpos), camera_origins[n_cameras]);
+                                       cameras[n_cameras] = e;
+                                       ++n_cameras;
+                                       if(n_cameras >= MAX_LEVELNETWORKEYES)
+                                               break;
+                               }
                        }
                }
        }
@@ -1639,12 +1809,12 @@ void SV_AddCameraEyes(void)
                if(!cameras[j])
                        continue;
                ed = PRVM_EDICT_NUM(cameras[j]);
-               VectorAdd(ed->fields.server->origin, ed->fields.server->mins, mi);
-               VectorAdd(ed->fields.server->origin, ed->fields.server->maxs, ma);
+               VectorAdd(PRVM_serveredictvector(ed, origin), PRVM_serveredictvector(ed, mins), mi);
+               VectorAdd(PRVM_serveredictvector(ed, origin), PRVM_serveredictvector(ed, maxs), ma);
                for(k = 0; k < sv.writeentitiestoclient_numeyes; ++k)
                if(eye_levels[k] <= MAX_EYE_RECURSION)
                {
-                       if(SV_CanSeeBox(sv_cullentities_trace_samples.integer, sv_cullentities_trace_enlarge.value, sv.writeentitiestoclient_eyes[k], mi, ma))
+                       if(SV_CanSeeBox(sv_cullentities_trace_samples.integer, sv_cullentities_trace_eyejitter.value, sv_cullentities_trace_enlarge.value, sv_cullentities_trace_expand.value, sv.writeentitiestoclient_eyes[k], mi, ma))
                        {
                                eye_levels[sv.writeentitiestoclient_numeyes] = eye_levels[k] + 1;
                                VectorCopy(camera_origins[j], sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);
@@ -1663,8 +1833,9 @@ void SV_AddCameraEyes(void)
 }
 #endif
 
-void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int maxsize)
+static void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int maxsize)
 {
+       prvm_prog_t *prog = SVVM_prog;
        qboolean need_empty = false;
        int i, numsendstates, numcsqcsendstates;
        entity_state_t *s;
@@ -1688,7 +1859,7 @@ void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *
        // get eye location
        sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
        camera = PRVM_EDICT_NUM( client->clientcamera );
-       VectorAdd(camera->fields.server->origin, clent->fields.server->view_ofs, eye);
+       VectorAdd(PRVM_serveredictvector(camera, origin), PRVM_serveredictvector(clent, view_ofs), eye);
        sv.writeentitiestoclient_pvsbytes = 0;
        // get the PVS values for the eye location, later FatPVS calls will merge
        if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
@@ -1703,8 +1874,8 @@ void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *
        {
                vec_t predtime = bound(0, host_client->ping, sv_cullentities_trace_prediction_time.value);
                vec3_t predeye;
-               VectorMA(eye, predtime, camera->fields.server->velocity, predeye);
-               if (SV_CanSeeBox(1, 0, eye, predeye, predeye))
+               VectorMA(eye, predtime, PRVM_serveredictvector(camera, velocity), predeye);
+               if (SV_CanSeeBox(1, 0, 0, 0, eye, predeye, predeye))
                {
                        VectorCopy(predeye, sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);
                        sv.writeentitiestoclient_numeyes++;
@@ -1758,8 +1929,17 @@ void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *
        else
                EntityFrameCSQC_WriteFrame(msg, maxsize, numcsqcsendstates, sv.writeentitiestoclient_csqcsendstates, 0);
 
-       if(client->num_skippedentityframes >= 10)
-               need_empty = true; // force every 10th frame to be not empty (or cl_movement replay takes too long)
+       // force every 16th frame to be not empty (or cl_movement replay takes
+       // too long)
+       // BTW, this should normally not kick in any more due to the check
+       // below, except if the client stopped sending movement frames
+       if(client->num_skippedentityframes >= 16)
+               need_empty = true;
+
+       // help cl_movement a bit more
+       if(client->movesequence != client->lastmovesequence)
+               need_empty = true;
+       client->lastmovesequence = client->movesequence;
 
        if (client->entitydatabase5)
                success = EntityFrame5_WriteFrame(msg, maxsize, client->entitydatabase5, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1, client->movesequence, need_empty);
@@ -1793,12 +1973,13 @@ SV_CleanupEnts
 */
 static void SV_CleanupEnts (void)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int             e;
        prvm_edict_t    *ent;
 
        ent = PRVM_NEXT_EDICT(prog->edicts);
        for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
-               ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
+               PRVM_serveredictfloat(ent, effects) = (int)PRVM_serveredictfloat(ent, effects) & ~EF_MUZZLEFLASH;
 }
 
 /*
@@ -1809,30 +1990,31 @@ SV_WriteClientdataToMessage
 */
 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int             bits;
        int             i;
        prvm_edict_t    *other;
        int             items;
-       prvm_eval_t     *val;
        vec3_t  punchvector;
        int             viewzoom;
        const char *s;
        float   *statsf = (float *)stats;
+       float gravity;
 
 //
 // send a damage message
 //
-       if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
+       if (PRVM_serveredictfloat(ent, dmg_take) || PRVM_serveredictfloat(ent, dmg_save))
        {
-               other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
+               other = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, dmg_inflictor));
                MSG_WriteByte (msg, svc_damage);
-               MSG_WriteByte (msg, (int)ent->fields.server->dmg_save);
-               MSG_WriteByte (msg, (int)ent->fields.server->dmg_take);
+               MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_save));
+               MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_take));
                for (i=0 ; i<3 ; i++)
-                       MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
+                       MSG_WriteCoord (msg, PRVM_serveredictvector(other, origin)[i] + 0.5*(PRVM_serveredictvector(other, mins)[i] + PRVM_serveredictvector(other, maxs)[i]), sv.protocol);
 
-               ent->fields.server->dmg_take = 0;
-               ent->fields.server->dmg_save = 0;
+               PRVM_serveredictfloat(ent, dmg_take) = 0;
+               PRVM_serveredictfloat(ent, dmg_save) = 0;
        }
 
 //
@@ -1841,15 +2023,15 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
        SV_SetIdealPitch ();            // how much to look up / down ideally
 
 // a fixangle might get lost in a dropped packet.  Oh well.
-       if(ent->fields.server->fixangle)
+       if(PRVM_serveredictfloat(ent, fixangle))
        {
                // angle fixing was requested by global thinking code...
                // so store the current angles for later use
-               memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
+               VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame
-               ent->fields.server->fixangle = 0;
+               PRVM_serveredictfloat(ent, fixangle) = 0;
        }
 
        if (host_client->fixangle_angles_set)
@@ -1860,78 +2042,75 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                host_client->fixangle_angles_set = FALSE;
        }
 
-       // stuff the sigil bits into the high bits of items for sbar, or else
-       // mix in items2
-       val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.items2);
-       if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
-               items = (int)ent->fields.server->items | ((int)val->_float << 23);
-       else
-               items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
+       // the runes are in serverflags, pack them into the items value, also pack
+       // in the items2 value for mission pack huds
+       // (used only in the mission packs, which do not use serverflags)
+       items = (int)PRVM_serveredictfloat(ent, items) | ((int)PRVM_serveredictfloat(ent, items2) << 23) | ((int)PRVM_serverglobalfloat(serverflags) << 28);
 
-       VectorClear(punchvector);
-       if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.punchvector)))
-               VectorCopy(val->vector, punchvector);
+       VectorCopy(PRVM_serveredictvector(ent, punchvector), punchvector);
 
        // cache weapon model name and index in client struct to save time
        // (this search can be almost 1% of cpu time!)
-       s = PRVM_GetString(ent->fields.server->weaponmodel);
+       s = PRVM_GetString(prog, PRVM_serveredictstring(ent, weaponmodel));
        if (strcmp(s, client->weaponmodel))
        {
                strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
                client->weaponmodelindex = SV_ModelIndex(s, 1);
        }
 
-       viewzoom = 255;
-       if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewzoom)))
-               viewzoom = (int)(val->_float * 255.0f);
+       viewzoom = (int)(PRVM_serveredictfloat(ent, viewzoom) * 255.0f);
        if (viewzoom == 0)
                viewzoom = 255;
 
        bits = 0;
 
-       if ((int)ent->fields.server->flags & FL_ONGROUND)
+       if ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)
                bits |= SU_ONGROUND;
-       if (ent->fields.server->waterlevel >= 2)
+       if (PRVM_serveredictfloat(ent, waterlevel) >= 2)
                bits |= SU_INWATER;
-       if (ent->fields.server->idealpitch)
+       if (PRVM_serveredictfloat(ent, idealpitch))
                bits |= SU_IDEALPITCH;
 
        for (i=0 ; i<3 ; i++)
        {
-               if (ent->fields.server->punchangle[i])
+               if (PRVM_serveredictvector(ent, punchangle)[i])
                        bits |= (SU_PUNCH1<<i);
                if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
                        if (punchvector[i])
                                bits |= (SU_PUNCHVEC1<<i);
-               if (ent->fields.server->velocity[i])
+               if (PRVM_serveredictvector(ent, velocity)[i])
                        bits |= (SU_VELOCITY1<<i);
        }
 
+       gravity = PRVM_serveredictfloat(ent, gravity);if (!gravity) gravity = 1.0f;
+
        memset(stats, 0, sizeof(int[MAX_CL_STATS]));
-       stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];
+       stats[STAT_VIEWHEIGHT] = (int)PRVM_serveredictvector(ent, view_ofs)[2];
        stats[STAT_ITEMS] = items;
-       stats[STAT_WEAPONFRAME] = (int)ent->fields.server->weaponframe;
-       stats[STAT_ARMOR] = (int)ent->fields.server->armorvalue;
+       stats[STAT_WEAPONFRAME] = (int)PRVM_serveredictfloat(ent, weaponframe);
+       stats[STAT_ARMOR] = (int)PRVM_serveredictfloat(ent, armorvalue);
        stats[STAT_WEAPON] = client->weaponmodelindex;
-       stats[STAT_HEALTH] = (int)ent->fields.server->health;
-       stats[STAT_AMMO] = (int)ent->fields.server->currentammo;
-       stats[STAT_SHELLS] = (int)ent->fields.server->ammo_shells;
-       stats[STAT_NAILS] = (int)ent->fields.server->ammo_nails;
-       stats[STAT_ROCKETS] = (int)ent->fields.server->ammo_rockets;
-       stats[STAT_CELLS] = (int)ent->fields.server->ammo_cells;
-       stats[STAT_ACTIVEWEAPON] = (int)ent->fields.server->weapon;
+       stats[STAT_HEALTH] = (int)PRVM_serveredictfloat(ent, health);
+       stats[STAT_AMMO] = (int)PRVM_serveredictfloat(ent, currentammo);
+       stats[STAT_SHELLS] = (int)PRVM_serveredictfloat(ent, ammo_shells);
+       stats[STAT_NAILS] = (int)PRVM_serveredictfloat(ent, ammo_nails);
+       stats[STAT_ROCKETS] = (int)PRVM_serveredictfloat(ent, ammo_rockets);
+       stats[STAT_CELLS] = (int)PRVM_serveredictfloat(ent, ammo_cells);
+       stats[STAT_ACTIVEWEAPON] = (int)PRVM_serveredictfloat(ent, weapon);
        stats[STAT_VIEWZOOM] = viewzoom;
-       stats[STAT_TOTALSECRETS] = (int)prog->globals.server->total_secrets;
-       stats[STAT_TOTALMONSTERS] = (int)prog->globals.server->total_monsters;
+       stats[STAT_TOTALSECRETS] = (int)PRVM_serverglobalfloat(total_secrets);
+       stats[STAT_TOTALMONSTERS] = (int)PRVM_serverglobalfloat(total_monsters);
        // the QC bumps these itself by sending svc_'s, so we have to keep them
        // zero or they'll be corrected by the engine
-       //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
-       //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
+       //stats[STAT_SECRETS] = PRVM_serverglobalfloat(found_secrets);
+       //stats[STAT_MONSTERS] = PRVM_serverglobalfloat(killed_monsters);
 
        // movement settings for prediction
        // note: these are not sent in protocols with lower MAX_CL_STATS limits
        stats[STAT_MOVEFLAGS] = MOVEFLAG_VALID
                | (sv_gameplayfix_q2airaccelerate.integer ? MOVEFLAG_Q2AIRACCELERATE : 0)
+               | (sv_gameplayfix_nogravityonground.integer ? MOVEFLAG_NOGRAVITYONGROUND : 0)
+               | (sv_gameplayfix_gravityunaffectedbyticrate.integer ? MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE : 0)
        ;
        statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
        statsf[STAT_MOVEVARS_TIMESCALE] = slowmo.value;
@@ -1942,25 +2121,29 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
        statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
        statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
        statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
-       val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.gravity);
-       statsf[STAT_MOVEVARS_ENTGRAVITY] = (val && val->_float != 0) ? val->_float : 1.0f;
+       statsf[STAT_MOVEVARS_ENTGRAVITY] = gravity;
        statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
        statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
        statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
        statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
        statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
+       statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR] = sv_airaccel_qw_stretchfactor.value;
        statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
        statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value;
        statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
        statsf[STAT_MOVEVARS_AIRSTOPACCELERATE] = sv_airstopaccelerate.value;
        statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE] = sv_airstrafeaccelerate.value;
        statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED] = sv_maxairstrafespeed.value;
+       statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW] = sv_airstrafeaccel_qw.value;
        statsf[STAT_MOVEVARS_AIRCONTROL] = sv_aircontrol.value;
+       statsf[STAT_MOVEVARS_AIRCONTROL_POWER] = sv_aircontrol_power.value;
+       statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY] = sv_aircontrol_penalty.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL] = sv_warsowbunny_airforwardaccel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL] = sv_warsowbunny_accel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED] = sv_warsowbunny_topspeed.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL] = sv_warsowbunny_turnaccel.value;
        statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO] = sv_warsowbunny_backtosideratio.value;
+       statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW] = sv_airspeedlimit_nonqw.value;
        statsf[STAT_FRAGLIMIT] = fraglimit.value;
        statsf[STAT_TIMELIMIT] = timelimit.value;
 
@@ -1994,16 +2177,16 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
 
        if (bits & SU_IDEALPITCH)
-               MSG_WriteChar (msg, (int)ent->fields.server->idealpitch);
+               MSG_WriteChar (msg, (int)PRVM_serveredictfloat(ent, idealpitch));
 
        for (i=0 ; i<3 ; i++)
        {
                if (bits & (SU_PUNCH1<<i))
                {
                        if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
-                               MSG_WriteChar(msg, (int)ent->fields.server->punchangle[i]);
+                               MSG_WriteChar(msg, (int)PRVM_serveredictvector(ent, punchangle)[i]);
                        else
-                               MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
+                               MSG_WriteAngle16i(msg, PRVM_serveredictvector(ent, punchangle)[i]);
                }
                if (bits & (SU_PUNCHVEC1<<i))
                {
@@ -2015,9 +2198,9 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                if (bits & (SU_VELOCITY1<<i))
                {
                        if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
-                               MSG_WriteChar(msg, (int)(ent->fields.server->velocity[i] * (1.0f / 16.0f)));
+                               MSG_WriteChar(msg, (int)(PRVM_serveredictvector(ent, velocity)[i] * (1.0f / 16.0f)));
                        else
-                               MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
+                               MSG_WriteCoord32f(msg, PRVM_serveredictvector(ent, velocity)[i]);
                }
        }
 
@@ -2061,7 +2244,7 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                MSG_WriteByte (msg, stats[STAT_NAILS]);
                MSG_WriteByte (msg, stats[STAT_ROCKETS]);
                MSG_WriteByte (msg, stats[STAT_CELLS]);
-               if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
+               if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_QUOTH || IS_OLDNEXUIZ_DERIVED(gamemode))
                {
                        for (i = 0;i < 32;i++)
                                if (stats[STAT_ACTIVEWEAPON] & (1<<i))
@@ -2088,7 +2271,7 @@ void SV_FlushBroadcastMessages(void)
                return;
        for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
        {
-               if (!client->spawned || !client->netconnection || client->unreliablemsg.cursize + sv.datagram.cursize > client->unreliablemsg.maxsize || client->unreliablemsg_splitpoints >= (int)(sizeof(client->unreliablemsg_splitpoint)/sizeof(client->unreliablemsg_splitpoint[0])))
+               if (!client->begun || !client->netconnection || client->unreliablemsg.cursize + sv.datagram.cursize > client->unreliablemsg.maxsize || client->unreliablemsg_splitpoints >= (int)(sizeof(client->unreliablemsg_splitpoint)/sizeof(client->unreliablemsg_splitpoint[0])))
                        continue;
                SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
                client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
@@ -2140,6 +2323,7 @@ static void SV_SendClientDatagram (client_t *client)
        sizebuf_t msg;
        int stats[MAX_CL_STATS];
        static unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE];
+       double timedelta;
 
        // obey rate limit by limiting packet frequency if the packet size
        // limiting fails
@@ -2187,13 +2371,31 @@ static void SV_SendClientDatagram (client_t *client)
                //
                // at very low rates (or very small sys_ticrate) the packet size is
                // not reduced below 128, but packets may be sent less often
-               maxsize = (int)(clientrate * sys_ticrate.value);
+
+               // how long are bursts?
+               timedelta = host_client->rate_burstsize / (double)client->rate;
+
+               // how much of the burst do we keep reserved?
+               timedelta *= 1 - net_burstreserve.value;
+
+               // only try to use excess time
+               timedelta = bound(0, realtime - host_client->netconnection->cleartime, timedelta);
+
+               // but we know next packet will be in sys_ticrate, so we can use up THAT bandwidth
+               timedelta += sys_ticrate.value;
+
+               // note: packet overhead (not counted in maxsize) is 28 bytes
+               maxsize = (int)(clientrate * timedelta) - 28;
+
+               // put it in sound bounds
                maxsize = bound(128, maxsize, 1400);
                maxsize2 = 1400;
+
                // csqc entities can easily exceed 128 bytes, so disable throttling in
                // mods that use csqc (they are likely to use less bandwidth anyway)
-               if (sv.csqc_progsize > 0)
+               if((net_usesizelimit.integer == 1) ? (sv.csqc_progsize > 0) : (net_usesizelimit.integer < 1))
                        maxsize = maxsize2;
+
                break;
        }
 
@@ -2216,7 +2418,7 @@ static void SV_SendClientDatagram (client_t *client)
        msg.cursize = 0;
        msg.allowoverflow = false;
 
-       if (host_client->spawned)
+       if (host_client->begun)
        {
                // the player is in the game
                MSG_WriteByte (&msg, svc_time);
@@ -2225,7 +2427,7 @@ static void SV_SendClientDatagram (client_t *client)
                // add the client specific data to the datagram
                SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
                // now update the stats[] array using any registered custom fields
-               VM_SV_UpdateCustomStats (client, client->edict, &msg, stats);
+               VM_SV_UpdateCustomStats(client, client->edict, &msg, stats);
                // set host_client->statsdeltabits
                Protocol_UpdateClientStats (stats);
 
@@ -2276,7 +2478,7 @@ static void SV_SendClientDatagram (client_t *client)
        SV_WriteDemoMessage(client, &msg, false);
 
 // send the datagram
-       NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->sendsignon == 2);
+       NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->rate_burstsize, client->sendsignon == 2);
        if (client->sendsignon == 1 && !client->netconnection->message.cursize)
                client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
 }
@@ -2288,12 +2490,13 @@ SV_UpdateToReliableMessages
 */
 static void SV_UpdateToReliableMessages (void)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int i, j;
        client_t *client;
-       prvm_eval_t *val;
        const char *name;
        const char *model;
        const char *skin;
+       int clientcamera;
 
 // check for changes to be sent over the reliable streams
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
@@ -2302,15 +2505,17 @@ static void SV_UpdateToReliableMessages (void)
                host_client->edict = PRVM_EDICT_NUM(i+1);
 
                // DP_SV_CLIENTNAME
-               name = PRVM_GetString(host_client->edict->fields.server->netname);
+               name = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, netname));
                if (name == NULL)
                        name = "";
                // always point the string back at host_client->name to keep it safe
-               strlcpy (host_client->name, name, sizeof (host_client->name));
-               host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
+               //strlcpy (host_client->name, name, sizeof (host_client->name));
+               if (name != host_client->name) // prevent buffer overlap SIGABRT on Mac OSX
+                       strlcpy (host_client->name, name, sizeof (host_client->name));
+               PRVM_serveredictstring(host_client->edict, netname) = PRVM_SetEngineString(prog, host_client->name);
                if (strcmp(host_client->old_name, host_client->name))
                {
-                       if (host_client->spawned)
+                       if (host_client->begun)
                                SV_BroadcastPrintf("%s ^7changed name to %s\n", host_client->old_name, host_client->name);
                        strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
                        // send notification to all clients
@@ -2321,9 +2526,7 @@ static void SV_UpdateToReliableMessages (void)
                }
 
                // DP_SV_CLIENTCOLORS
-               // this is always found (since it's added by the progs loader)
-               if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcolors)))
-                       host_client->colors = (int)val->_float;
+               host_client->colors = (int)PRVM_serveredictfloat(host_client->edict, clientcolors);
                if (host_client->old_colors != host_client->colors)
                {
                        host_client->old_colors = host_client->colors;
@@ -2334,44 +2537,45 @@ static void SV_UpdateToReliableMessages (void)
                }
 
                // NEXUIZ_PLAYERMODEL
-               if( prog->fieldoffsets.playermodel >= 0 ) {
-                       model = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string);
-                       if (model == NULL)
-                               model = "";
-                       // always point the string back at host_client->name to keep it safe
+               model = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, playermodel));
+               if (model == NULL)
+                       model = "";
+               // always point the string back at host_client->name to keep it safe
+               //strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
+               if (model != host_client->playermodel) // prevent buffer overlap SIGABRT on Mac OSX
                        strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
-                       PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
-               }
+               PRVM_serveredictstring(host_client->edict, playermodel) = PRVM_SetEngineString(prog, host_client->playermodel);
 
                // NEXUIZ_PLAYERSKIN
-               if( prog->fieldoffsets.playerskin >= 0 ) {
-                       skin = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string);
-                       if (skin == NULL)
-                               skin = "";
-                       // always point the string back at host_client->name to keep it safe
+               skin = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, playerskin));
+               if (skin == NULL)
+                       skin = "";
+               // always point the string back at host_client->name to keep it safe
+               //strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
+               if (skin != host_client->playerskin) // prevent buffer overlap SIGABRT on Mac OSX
                        strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
-                       PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
-               }
+               PRVM_serveredictstring(host_client->edict, playerskin) = PRVM_SetEngineString(prog, host_client->playerskin);
 
                // TODO: add an extension name for this [1/17/2008 Black]
-               if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcamera)) && val->edict > 0 ) {
+               clientcamera = PRVM_serveredictedict(host_client->edict, clientcamera);
+               if (clientcamera > 0)
+               {
                        int oldclientcamera = host_client->clientcamera;
-                       if( val->edict >= prog->max_edicts || PRVM_EDICT_NUM( val->edict )->priv.required->free ) {
-                               val->edict = host_client->clientcamera = PRVM_NUM_FOR_EDICT( host_client->edict );
-                       } else {
-                               host_client->clientcamera = val->edict;
-                       }
+                       if (clientcamera >= prog->max_edicts || PRVM_EDICT_NUM(clientcamera)->priv.required->free)
+                               clientcamera = PRVM_NUM_FOR_EDICT(host_client->edict);
+                       host_client->clientcamera = clientcamera;
 
-                       if( oldclientcamera != host_client->clientcamera ) {
-                               MSG_WriteByte (&sv.reliable_datagram, svc_setview );
-                               MSG_WriteShort (&host_client->netconnection->message, host_client->clientcamera);
+                       if (oldclientcamera != host_client->clientcamera && host_client->netconnection)
+                       {
+                               MSG_WriteByte(&host_client->netconnection->message, svc_setview);
+                               MSG_WriteShort(&host_client->netconnection->message, host_client->clientcamera);
                        }
                }
 
                // frags
-               host_client->frags = (int)host_client->edict->fields.server->frags;
-               if(gamemode == GAME_NEXUIZ)
-                       if(!host_client->spawned && host_client->netconnection)
+               host_client->frags = (int)PRVM_serveredictfloat(host_client->edict, frags);
+               if(IS_OLDNEXUIZ_DERIVED(gamemode))
+                       if(!host_client->begun && host_client->netconnection)
                                host_client->frags = -666;
                if (host_client->old_frags != host_client->frags)
                {
@@ -2384,7 +2588,7 @@ static void SV_UpdateToReliableMessages (void)
        }
 
        for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
-               if (client->netconnection && (client->spawned || client->clientconnectcalled)) // also send MSG_ALL to people who are past ClientConnect, but not spawned yet
+               if (client->netconnection && (client->begun || client->clientconnectcalled)) // also send MSG_ALL to people who are past ClientConnect, but not spawned yet
                        SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
 
        SZ_Clear (&sv.reliable_datagram);
@@ -2396,7 +2600,7 @@ static void SV_UpdateToReliableMessages (void)
 SV_SendClientMessages
 =======================
 */
-void SV_SendClientMessages (void)
+void SV_SendClientMessages(void)
 {
        int i, prepared = false;
 
@@ -2428,7 +2632,7 @@ void SV_SendClientMessages (void)
                        // only prepare entities once per frame
                        SV_PrepareEntitiesForSending();
                }
-               SV_SendClientDatagram (host_client);
+               SV_SendClientDatagram(host_client);
        }
 
 // clear muzzle flashes
@@ -2710,9 +2914,23 @@ int SV_ModelIndex(const char *s, int precachemode)
                                if (precachemode == 1)
                                        Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
                                strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
-                               sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.modelname : NULL);
-                               if (sv.state != ss_loading)
+                               if (sv.state == ss_loading)
+                               {
+                                       // running from SV_SpawnServer which is launched from the client console command interpreter
+                                       sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.worldname : NULL);
+                               }
+                               else
                                {
+                                       if (svs.threaded)
+                                       {
+                                               // this is running on the server thread, we can't load a model here (it would crash on renderer calls), so only look it up, the svc_precache will cause it to be loaded when it reaches the client
+                                               sv.models[i] = Mod_FindName (sv.model_precache[i], s[0] == '*' ? sv.worldname : NULL);
+                                       }
+                                       else
+                                       {
+                                               // running single threaded, so we can load the model here
+                                               sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.worldname : NULL);
+                                       }
                                        MSG_WriteByte(&sv.reliable_datagram, svc_precache);
                                        MSG_WriteShort(&sv.reliable_datagram, i);
                                        MSG_WriteString(&sv.reliable_datagram, filename);
@@ -2805,7 +3023,7 @@ int SV_ParticleEffectIndex(const char *name)
                        if (filepass == 0)
                                dpsnprintf(filename, sizeof(filename), "effectinfo.txt");
                        else if (filepass == 1)
-                               dpsnprintf(filename, sizeof(filename), "maps/%s_effectinfo.txt", sv.name);
+                               dpsnprintf(filename, sizeof(filename), "%s_effectinfo.txt", sv.worldnamenoextension);
                        else
                                break;
                        filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
@@ -2819,7 +3037,7 @@ int SV_ParticleEffectIndex(const char *name)
                                argc = 0;
                                for (;;)
                                {
-                                       if (!COM_ParseToken_Simple(&text, true, false) || !strcmp(com_token, "\n"))
+                                       if (!COM_ParseToken_Simple(&text, true, false, true) || !strcmp(com_token, "\n"))
                                                break;
                                        if (argc < 16)
                                        {
@@ -2835,7 +3053,7 @@ int SV_ParticleEffectIndex(const char *name)
                                {
                                        if (argc == 2)
                                        {
-                                               for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME;effectnameindex++)
+                                               for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME;effectnameindex++)
                                                {
                                                        if (sv.particleeffectname[effectnameindex][0])
                                                        {
@@ -2849,7 +3067,7 @@ int SV_ParticleEffectIndex(const char *name)
                                                        }
                                                }
                                                // if we run out of names, abort
-                                               if (effectnameindex == SV_MAX_PARTICLEEFFECTNAME)
+                                               if (effectnameindex == MAX_PARTICLEEFFECTNAME)
                                                {
                                                        Con_Printf("%s:%i: too many effects!\n", filename, linenumber);
                                                        break;
@@ -2861,7 +3079,7 @@ int SV_ParticleEffectIndex(const char *name)
                }
        }
        // search for the name
-       for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
+       for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
                if (!strcmp(sv.particleeffectname[effectnameindex], name))
                        return effectnameindex;
        // return 0 if we couldn't find it
@@ -2875,10 +3093,11 @@ dp_model_t *SV_GetModelByIndex(int modelindex)
 
 dp_model_t *SV_GetModelFromEdict(prvm_edict_t *ed)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int modelindex;
        if (!ed || ed->priv.server->free)
                return NULL;
-       modelindex = (int)ed->fields.server->modelindex;
+       modelindex = (int)PRVM_serveredictfloat(ed, modelindex);
        return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
 }
 
@@ -2890,10 +3109,11 @@ SV_CreateBaseline
 */
 static void SV_CreateBaseline (void)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int i, entnum, large;
        prvm_edict_t *svent;
 
-       // LordHavoc: clear *all* states (note just active ones)
+       // LordHavoc: clear *all* baselines (not just active ones)
        for (entnum = 0;entnum < prog->max_edicts;entnum++)
        {
                // get the current server version
@@ -2904,14 +3124,14 @@ static void SV_CreateBaseline (void)
 
                if (svent->priv.server->free)
                        continue;
-               if (entnum > svs.maxclients && !svent->fields.server->modelindex)
+               if (entnum > svs.maxclients && !PRVM_serveredictfloat(svent, modelindex))
                        continue;
 
                // create entity baseline
-               VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
-               VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
-               svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
-               svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
+               VectorCopy (PRVM_serveredictvector(svent, origin), svent->priv.server->baseline.origin);
+               VectorCopy (PRVM_serveredictvector(svent, angles), svent->priv.server->baseline.angles);
+               svent->priv.server->baseline.frame = (int)PRVM_serveredictfloat(svent, frame);
+               svent->priv.server->baseline.skin = (int)PRVM_serveredictfloat(svent, skin);
                if (entnum > 0 && entnum <= svs.maxclients)
                {
                        svent->priv.server->baseline.colormap = entnum;
@@ -2920,7 +3140,7 @@ static void SV_CreateBaseline (void)
                else
                {
                        svent->priv.server->baseline.colormap = 0;
-                       svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
+                       svent->priv.server->baseline.modelindex = (int)PRVM_serveredictfloat(svent, modelindex);
                }
 
                large = false;
@@ -2971,7 +3191,7 @@ Load csprogs.dat and comperss it so it doesn't need to be
 reloaded on request.
 ================
 */
-void SV_Prepare_CSQC(void)
+static void SV_Prepare_CSQC(void)
 {
        fs_offset_t progsize;
 
@@ -3022,9 +3242,10 @@ transition to another level
 */
 void SV_SaveSpawnparms (void)
 {
+       prvm_prog_t *prog = SVVM_prog;
        int             i, j;
 
-       svs.serverflags = (int)prog->globals.server->serverflags;
+       svs.serverflags = (int)PRVM_serverglobalfloat(serverflags);
 
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        {
@@ -3032,10 +3253,11 @@ void SV_SaveSpawnparms (void)
                        continue;
 
        // call the progs to get default spawn parms for the new client
-               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-               PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
+               PRVM_serverglobalfloat(time) = sv.time;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+               prog->ExecuteProgram(prog, PRVM_serverfunction(SetChangeParms), "QC function SetChangeParms is missing");
                for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
-                       host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
+                       host_client->spawn_parms[j] = (&PRVM_serverglobalfloat(parm1))[j];
        }
 }
 
@@ -3049,11 +3271,13 @@ This is called at the start of each level
 
 void SV_SpawnServer (const char *server)
 {
+       prvm_prog_t *prog = SVVM_prog;
        prvm_edict_t *ent;
        int i;
        char *entities;
        dp_model_t *worldmodel;
-       char modelname[sizeof(sv.modelname)];
+       char modelname[sizeof(sv.worldname)];
+       char vabuf[1024];
 
        Con_DPrintf("SpawnServer: %s\n", server);
 
@@ -3061,39 +3285,55 @@ void SV_SpawnServer (const char *server)
 
        if (!FS_FileExists(modelname))
        {
-               Con_Printf("SpawnServer: no map file named %s\n", modelname);
-               return;
+               dpsnprintf (modelname, sizeof(modelname), "maps/%s", server);
+               if (!FS_FileExists(modelname))
+               {
+                       Con_Printf("SpawnServer: no map file named maps/%s.bsp\n", server);
+                       return;
+               }
        }
 
+//     SV_LockThreadMutex();
+
+       if(cls.state == ca_dedicated)
+               Sys_MakeProcessNice();
+
        if (cls.state != ca_dedicated)
        {
-               SCR_BeginLoadingPlaque();
+               SCR_BeginLoadingPlaque(false);
                S_StopAllSounds();
        }
 
        if(sv.active)
        {
-               SV_VM_Begin();
                World_End(&sv.world);
-               if(prog->funcoffsets.SV_Shutdown)
+               if(PRVM_serverfunction(SV_Shutdown))
                {
-                       func_t s = prog->funcoffsets.SV_Shutdown;
-                       prog->funcoffsets.SV_Shutdown = 0; // prevent it from getting called again
-                       PRVM_ExecuteProgram(s,"SV_Shutdown() required");
+                       func_t s = PRVM_serverfunction(SV_Shutdown);
+                       PRVM_serverglobalfloat(time) = sv.time;
+                       PRVM_serverfunction(SV_Shutdown) = 0; // prevent it from getting called again
+                       prog->ExecuteProgram(prog, s,"SV_Shutdown() required");
                }
-               SV_VM_End();
        }
 
        // free q3 shaders so that any newly downloaded shaders will be active
        Mod_FreeQ3Shaders();
 
-       worldmodel = Mod_ForName(modelname, false, developer.integer != 0, NULL);
+       worldmodel = Mod_ForName(modelname, false, developer.integer > 0, NULL);
        if (!worldmodel || !worldmodel->TraceBox)
        {
                Con_Printf("Couldn't load map %s\n", modelname);
+
+               if(cls.state == ca_dedicated)
+                       Sys_MakeProcessMean();
+
+//             SV_UnlockThreadMutex();
+
                return;
        }
 
+       Collision_Cache_Reset(true);
+
        // let's not have any servers with no name
        if (hostname.string[0] == 0)
                Cvar_Set ("hostname", "UNNAMED");
@@ -3145,6 +3385,8 @@ void SV_SpawnServer (const char *server)
        cls.signon = 0;
 
        Cvar_SetValue("halflifebsp", worldmodel->brush.ishlbsp);
+       Cvar_SetValue("sv_mapformat_is_quake2", worldmodel->brush.isq2bsp);
+       Cvar_SetValue("sv_mapformat_is_quake3", worldmodel->brush.isq3bsp);
 
        if(*sv_random_seed.string)
        {
@@ -3156,7 +3398,15 @@ void SV_SpawnServer (const char *server)
 
        sv.active = true;
 
+       // set level base name variables for later use
        strlcpy (sv.name, server, sizeof (sv.name));
+       strlcpy(sv.worldname, modelname, sizeof(sv.worldname));
+       FS_StripExtension(sv.worldname, sv.worldnamenoextension, sizeof(sv.worldnamenoextension));
+       strlcpy(sv.worldbasename, !strncmp(sv.worldnamenoextension, "maps/", 5) ? sv.worldnamenoextension + 5 : sv.worldnamenoextension, sizeof(sv.worldbasename));
+       //Cvar_SetQuick(&sv_worldmessage, sv.worldmessage); // set later after QC is spawned
+       Cvar_SetQuick(&sv_worldname, sv.worldname);
+       Cvar_SetQuick(&sv_worldnamenoextension, sv.worldnamenoextension);
+       Cvar_SetQuick(&sv_worldbasename, sv.worldbasename);
 
        sv.protocol = Protocol_EnumForName(sv_protocolname.string);
        if (sv.protocol == PROTOCOL_UNKNOWN)
@@ -3167,8 +3417,6 @@ void SV_SpawnServer (const char *server)
                sv.protocol = PROTOCOL_QUAKE;
        }
 
-       SV_VM_Begin();
-
 // load progs to get entity field count
        //PR_LoadProgs ( sv_progs.string );
 
@@ -3191,30 +3439,28 @@ void SV_SpawnServer (const char *server)
        prog->allowworldwrites = true;
        sv.paused = false;
 
-       prog->globals.server->time = sv.time = 1.0;
+       sv.time = 1.0;
 
        Mod_ClearUsed();
        worldmodel->used = true;
 
-       strlcpy (sv.name, server, sizeof (sv.name));
-       strlcpy(sv.modelname, modelname, sizeof(sv.modelname));
        sv.worldmodel = worldmodel;
        sv.models[1] = sv.worldmodel;
 
 //
 // clear world interaction links
 //
-       World_SetSize(&sv.world, sv.worldmodel->name, sv.worldmodel->normalmins, sv.worldmodel->normalmaxs);
+       World_SetSize(&sv.world, sv.worldname, sv.worldmodel->normalmins, sv.worldmodel->normalmaxs, prog);
        World_Start(&sv.world);
 
        strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
 
        strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
-       strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
+       strlcpy(sv.model_precache[1], sv.worldname, sizeof(sv.model_precache[1]));
        for (i = 1;i < sv.worldmodel->brush.numsubmodels && i+1 < MAX_MODELS;i++)
        {
                dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
-               sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, sv.modelname);
+               sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, sv.worldname);
        }
        if(i < sv.worldmodel->brush.numsubmodels)
                Con_Printf("Too many submodels (MAX_MODELS is %i)\n", MAX_MODELS);
@@ -3224,26 +3470,26 @@ void SV_SpawnServer (const char *server)
 //
        // AK possible hack since num_edicts is still 0
        ent = PRVM_EDICT_NUM(0);
-       memset (ent->fields.server, 0, prog->progs->entityfields * 4);
+       memset (ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
        ent->priv.server->free = false;
-       ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
-       ent->fields.server->modelindex = 1;             // world model
-       ent->fields.server->solid = SOLID_BSP;
-       ent->fields.server->movetype = MOVETYPE_PUSH;
-       VectorCopy(sv.world.mins, ent->fields.server->mins);
-       VectorCopy(sv.world.maxs, ent->fields.server->maxs);
-       VectorCopy(sv.world.mins, ent->fields.server->absmin);
-       VectorCopy(sv.world.maxs, ent->fields.server->absmax);
+       PRVM_serveredictstring(ent, model) = PRVM_SetEngineString(prog, sv.worldname);
+       PRVM_serveredictfloat(ent, modelindex) = 1;             // world model
+       PRVM_serveredictfloat(ent, solid) = SOLID_BSP;
+       PRVM_serveredictfloat(ent, movetype) = MOVETYPE_PUSH;
+       VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, mins));
+       VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, maxs));
+       VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, absmin));
+       VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, absmax));
 
        if (coop.value)
-               prog->globals.server->coop = coop.integer;
+               PRVM_serverglobalfloat(coop) = coop.integer;
        else
-               prog->globals.server->deathmatch = deathmatch.integer;
+               PRVM_serverglobalfloat(deathmatch) = deathmatch.integer;
 
-       prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
+       PRVM_serverglobalstring(mapname) = PRVM_SetEngineString(prog, sv.name);
 
 // serverflags are for cross level information (sigils)
-       prog->globals.server->serverflags = svs.serverflags;
+       PRVM_serverglobalfloat(serverflags) = svs.serverflags;
 
        // we need to reset the spawned flag on all connected clients here so that
        // their thinks don't run during startup (before PutClientInServer)
@@ -3251,37 +3497,40 @@ void SV_SpawnServer (const char *server)
        // and we need to set the ->edict pointers to point into the progs edicts
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        {
-               host_client->spawned = false;
+               host_client->begun = false;
                host_client->edict = PRVM_EDICT_NUM(i + 1);
-               PRVM_ED_ClearEdict(host_client->edict);
+               PRVM_ED_ClearEdict(prog, host_client->edict);
        }
 
        // load replacement entity file if found
-       if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
+       if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.ent", sv.worldnamenoextension), tempmempool, true, NULL)))
        {
-               Con_Printf("Loaded maps/%s.ent\n", sv.name);
-               PRVM_ED_LoadFromFile (entities);
+               Con_Printf("Loaded %s.ent\n", sv.worldnamenoextension);
+               PRVM_ED_LoadFromFile(prog, entities);
                Mem_Free(entities);
        }
        else
-               PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
+               PRVM_ED_LoadFromFile(prog, sv.worldmodel->brush.entities);
 
 
        // LordHavoc: clear world angles (to fix e3m3.bsp)
-       VectorClear(prog->edicts->fields.server->angles);
+       VectorClear(PRVM_serveredictvector(prog->edicts, angles));
 
 // all setup is completed, any further precache statements are errors
 //     sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
        prog->allowworldwrites = false;
 
 // run two frames to allow everything to settle
-       prog->globals.server->time = sv.time = 1.0001;
-       for (i = 0;i < 2;i++)
+       sv.time = 1.0001;
+       for (i = 0;i < sv_init_frame_count.integer;i++)
        {
                sv.frametime = 0.1;
                SV_Physics ();
        }
 
+       // Once all init frames have been run, we consider svqc code fully initialized.
+       prog->inittime = realtime;
+
        if (cls.state == ca_dedicated)
                Mod_PurgeUnused();
 
@@ -3291,9 +3540,6 @@ void SV_SpawnServer (const char *server)
 
        sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
 
-       // to prevent network timeouts
-       realtime = Sys_DoubleTime();
-       
 // send serverinfo to all connected clients, and set up botclients coming back from a level change
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        {
@@ -3310,45 +3556,52 @@ void SV_SpawnServer (const char *server)
 
                        // copy spawn parms out of the client_t
                        for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
-                               (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
+                               (&PRVM_serverglobalfloat(parm1))[j] = host_client->spawn_parms[j];
 
                        // call the spawn function
                        host_client->clientconnectcalled = true;
-                       prog->globals.server->time = sv.time;
-                       prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-                       PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
-                       PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
-                       host_client->spawned = true;
+                       PRVM_serverglobalfloat(time) = sv.time;
+                       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+                       prog->ExecuteProgram(prog, PRVM_serverfunction(ClientConnect), "QC function ClientConnect is missing");
+                       prog->ExecuteProgram(prog, PRVM_serverfunction(PutClientInServer), "QC function PutClientInServer is missing");
+                       host_client->begun = true;
                }
        }
 
+       // update the map title cvar
+       strlcpy(sv.worldmessage, PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)), sizeof(sv.worldmessage)); // map title (not related to filename)
+       Cvar_SetQuick(&sv_worldmessage, sv.worldmessage);
+
        Con_DPrint("Server spawned.\n");
        NetConn_Heartbeat (2);
 
-       SV_VM_End();
+       if(cls.state == ca_dedicated)
+               Sys_MakeProcessMean();
+
+//     SV_UnlockThreadMutex();
 }
 
 /////////////////////////////////////////////////////
 // SV VM stuff
 
-static void SV_VM_CB_BeginIncreaseEdicts(void)
+static void SVVM_begin_increase_edicts(prvm_prog_t *prog)
 {
        // links don't survive the transition, so unlink everything
        World_UnlinkAll(&sv.world);
 }
 
-static void SV_VM_CB_EndIncreaseEdicts(void)
+static void SVVM_end_increase_edicts(prvm_prog_t *prog)
 {
        int i;
        prvm_edict_t *ent;
 
        // link every entity except world
-       for (i = 1, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
+       for (i = 1, ent = prog->edicts;i < prog->num_edicts;i++, ent++)
                if (!ent->priv.server->free)
                        SV_LinkEdict(ent);
 }
 
-static void SV_VM_CB_InitEdict(prvm_edict_t *e)
+static void SVVM_init_edict(prvm_prog_t *prog, prvm_edict_t *e)
 {
        // LordHavoc: for consistency set these here
        int num = PRVM_NUM_FOR_EDICT(e) - 1;
@@ -3357,56 +3610,69 @@ static void SV_VM_CB_InitEdict(prvm_edict_t *e)
 
        if (num >= 0 && num < svs.maxclients)
        {
-               prvm_eval_t *val;
                // set colormap and team on newly created player entity
-               e->fields.server->colormap = num + 1;
-               e->fields.server->team = (svs.clients[num].colors & 15) + 1;
+               PRVM_serveredictfloat(e, colormap) = num + 1;
+               PRVM_serveredictfloat(e, team) = (svs.clients[num].colors & 15) + 1;
                // set netname/clientcolors back to client values so that
                // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
                // reset them
-               e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
-               if ((val = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.clientcolors)))
-                       val->_float = svs.clients[num].colors;
+               PRVM_serveredictstring(e, netname) = PRVM_SetEngineString(prog, svs.clients[num].name);
+               PRVM_serveredictfloat(e, clientcolors) = svs.clients[num].colors;
                // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
-               if( prog->fieldoffsets.playermodel >= 0 )
-                       PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
-               if( prog->fieldoffsets.playerskin >= 0 )
-                       PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
+               PRVM_serveredictstring(e, playermodel) = PRVM_SetEngineString(prog, svs.clients[num].playermodel);
+               PRVM_serveredictstring(e, playerskin) = PRVM_SetEngineString(prog, svs.clients[num].playerskin);
                // Assign netaddress (IP Address, etc)
-               if(prog->fieldoffsets.netaddress >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL)
-                       {// Valid Address; Assign
-                               // Acquire Readable Address
-                               LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
-                               PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString(svs.clients[num].netaddress);
-                       }
-                       else
-                               // Invalid / Bot
-                               PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString("null/botclient");
+               if(svs.clients[num].netconnection != NULL)
+               {
+                       // Acquire Readable Address
+                       LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
+                       PRVM_serveredictstring(e, netaddress) = PRVM_SetEngineString(prog, svs.clients[num].netaddress);
                }
+               else
+                       PRVM_serveredictstring(e, netaddress) = PRVM_SetEngineString(prog, "null/botclient");
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_idfp[0])
+                       PRVM_serveredictstring(e, crypto_idfp) = PRVM_SetEngineString(prog, svs.clients[num].netconnection->crypto.client_idfp);
+               else
+                       PRVM_serveredictstring(e, crypto_idfp) = 0;
+               PRVM_serveredictfloat(e, crypto_idfp_signed) = (svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_issigned);
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_keyfp[0])
+                       PRVM_serveredictstring(e, crypto_keyfp) = PRVM_SetEngineString(prog, svs.clients[num].netconnection->crypto.client_keyfp);
+               else
+                       PRVM_serveredictstring(e, crypto_keyfp) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.server_keyfp[0])
+                       PRVM_serveredictstring(e, crypto_mykeyfp) = PRVM_SetEngineString(prog, svs.clients[num].netconnection->crypto.server_keyfp);
+               else
+                       PRVM_serveredictstring(e, crypto_mykeyfp) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.use_aes)
+                       PRVM_serveredictstring(e, crypto_encryptmethod) = PRVM_SetEngineString(prog, "AES128");
+               else
+                       PRVM_serveredictstring(e, crypto_encryptmethod) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated)
+                       PRVM_serveredictstring(e, crypto_signmethod) = PRVM_SetEngineString(prog, "HMAC-SHA256");
+               else
+                       PRVM_serveredictstring(e, crypto_signmethod) = 0;
        }
 }
 
-static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
+static void SVVM_free_edict(prvm_prog_t *prog, prvm_edict_t *ed)
 {
        int i;
        int e;
 
        World_UnlinkEdict(ed);          // unlink from world bsp
 
-       ed->fields.server->model = 0;
-       ed->fields.server->takedamage = 0;
-       ed->fields.server->modelindex = 0;
-       ed->fields.server->colormap = 0;
-       ed->fields.server->skin = 0;
-       ed->fields.server->frame = 0;
-       VectorClear(ed->fields.server->origin);
-       VectorClear(ed->fields.server->angles);
-       ed->fields.server->nextthink = -1;
-       ed->fields.server->solid = 0;
-
-       VM_RemoveEdictSkeleton(ed);
+       PRVM_serveredictstring(ed, model) = 0;
+       PRVM_serveredictfloat(ed, takedamage) = 0;
+       PRVM_serveredictfloat(ed, modelindex) = 0;
+       PRVM_serveredictfloat(ed, colormap) = 0;
+       PRVM_serveredictfloat(ed, skin) = 0;
+       PRVM_serveredictfloat(ed, frame) = 0;
+       VectorClear(PRVM_serveredictvector(ed, origin));
+       VectorClear(PRVM_serveredictvector(ed, angles));
+       PRVM_serveredictfloat(ed, nextthink) = -1;
+       PRVM_serveredictfloat(ed, solid) = 0;
+
+       VM_RemoveEdictSkeleton(prog, ed);
        World_Physics_RemoveFromEntity(&sv.world, ed);
        World_Physics_RemoveJointFromEntity(&sv.world, ed);
 
@@ -3414,14 +3680,10 @@ static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
        e = PRVM_NUM_FOR_EDICT(ed);
        sv.csqcentityversion[e] = 0;
        for (i = 0;i < svs.maxclients;i++)
-       {
-               if (svs.clients[i].csqcentityscope[e])
-                       svs.clients[i].csqcentityscope[e] = 1; // removed, awaiting send
                svs.clients[i].csqcentitysendflags[e] = 0xFFFFFF;
-       }
 }
 
-static void SV_VM_CB_CountEdicts(void)
+static void SVVM_count_edicts(prvm_prog_t *prog)
 {
        int             i;
        prvm_edict_t    *ent;
@@ -3434,11 +3696,11 @@ static void SV_VM_CB_CountEdicts(void)
                if (ent->priv.server->free)
                        continue;
                active++;
-               if (ent->fields.server->solid)
+               if (PRVM_serveredictfloat(ent, solid))
                        solid++;
-               if (ent->fields.server->model)
+               if (PRVM_serveredictstring(ent, model))
                        models++;
-               if (ent->fields.server->movetype == MOVETYPE_STEP)
+               if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP)
                        step++;
        }
 
@@ -3449,21 +3711,21 @@ static void SV_VM_CB_CountEdicts(void)
        Con_Printf("step      :%3i\n", step);
 }
 
-static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
+static qboolean SVVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
 {
        // remove things from different skill levels or deathmatch
        if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
        {
                if (deathmatch.integer)
                {
-                       if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
+                       if (((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_DEATHMATCH))
                        {
                                return false;
                        }
                }
-               else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY  ))
-                       || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
-                       || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD  )))
+               else if ((current_skill <= 0 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_EASY  ))
+                       || (current_skill == 1 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_MEDIUM))
+                       || (current_skill >= 2 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_HARD  )))
                {
                        return false;
                }
@@ -3473,16 +3735,14 @@ static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
 
 static void SV_VM_Setup(void)
 {
-       PRVM_Begin;
-       PRVM_InitProg( PRVM_SERVERPROG );
+       prvm_prog_t *prog = SVVM_prog;
+       PRVM_Prog_Init(prog);
 
        // allocate the mempools
        // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
        prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
        prog->builtins = vm_sv_builtins;
        prog->numbuiltins = vm_sv_numbuiltins;
-       prog->headercrc = PROGHEADER_CRC;
-       prog->headercrc2 = PROGHEADER_CRC_TENEBRAE;
        prog->max_edicts = 512;
        if (sv.protocol == PROTOCOL_QUAKE)
                prog->limit_edicts = 640; // before quake mission pack 1 this was 512
@@ -3500,65 +3760,330 @@ static void SV_VM_Setup(void)
        prog->extensionstring = vm_sv_extensions;
        prog->loadintoworld = true;
 
-       prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
-       prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
-       prog->init_edict = SV_VM_CB_InitEdict;
-       prog->free_edict = SV_VM_CB_FreeEdict;
-       prog->count_edicts = SV_VM_CB_CountEdicts;
-       prog->load_edict = SV_VM_CB_LoadEdict;
-       prog->init_cmd = VM_SV_Cmd_Init;
-       prog->reset_cmd = VM_SV_Cmd_Reset;
-       prog->error_cmd = Host_Error;
-       prog->ExecuteProgram = SVVM_ExecuteProgram;
+       // all callbacks must be defined (pointers are not checked before calling)
+       prog->begin_increase_edicts = SVVM_begin_increase_edicts;
+       prog->end_increase_edicts   = SVVM_end_increase_edicts;
+       prog->init_edict            = SVVM_init_edict;
+       prog->free_edict            = SVVM_free_edict;
+       prog->count_edicts          = SVVM_count_edicts;
+       prog->load_edict            = SVVM_load_edict;
+       prog->init_cmd              = SVVM_init_cmd;
+       prog->reset_cmd             = SVVM_reset_cmd;
+       prog->error_cmd             = Host_Error;
+       prog->ExecuteProgram        = SVVM_ExecuteProgram;
 
-       // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
-       PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields, 0, NULL );
+       PRVM_Prog_Load(prog, sv_progs.string, NULL, 0, SV_REQFUNCS, sv_reqfuncs, SV_REQFIELDS, sv_reqfields, SV_REQGLOBALS, sv_reqglobals);
 
        // some mods compiled with scrambling compilers lack certain critical
        // global names and field names such as "self" and "time" and "nextthink"
        // so we have to set these offsets manually, matching the entvars_t
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
-       // OP_STATE is always supported on server (due to entvars_t)
+       // but we only do this if the prog header crc matches, otherwise it's totally freeform
+       if (prog->progs_crc == PROGHEADER_CRC || prog->progs_crc == PROGHEADER_CRC_TENEBRAE)
+       {
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, modelindex);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, absmin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, absmax);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ltime);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, movetype);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, solid);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, origin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, oldorigin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, velocity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, avelocity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, punchangle);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, model);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, skin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, effects);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, mins);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, maxs);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, size);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, touch);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, use);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, blocked);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, health);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frags);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weapon);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weaponmodel);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weaponframe);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, currentammo);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_shells);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_nails);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_rockets);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_cells);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, items);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, takedamage);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, deadflag);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, view_ofs);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button0);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button1);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button2);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, impulse);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, fixangle);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, v_angle);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, idealpitch);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, netname);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, enemy);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, flags);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, colormap);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, team);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, max_health);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, teleport_time);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, armortype);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, armorvalue);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, waterlevel);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, watertype);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, aiment);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, goalentity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, spawnflags);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, target);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, targetname);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_take);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_save);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_inflictor);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, owner);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, movedir);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, message);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, sounds);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise1);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise2);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise3);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, other);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, world);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, frametime);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, force_retouch);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, mapname);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, deathmatch);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, coop);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, teamplay);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, serverflags);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, total_secrets);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, total_monsters);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, found_secrets);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, killed_monsters);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm1);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm2);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm3);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm4);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm5);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm6);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm7);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm8);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm9);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm10);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm11);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm12);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm13);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm14);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm15);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm16);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, msg_entity);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, main);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, StartFrame);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PlayerPreThink);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PlayerPostThink);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientKill);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientConnect);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PutClientInServer);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientDisconnect);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, SetNewParms);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, SetChangeParms);
+       }
+       else
+               Con_DPrintf("%s: %s system vars have been modified (CRC %i != engine %i), will not load in other engines\n", prog->name, sv_progs.string, prog->progs_crc, PROGHEADER_CRC);
+
+       // OP_STATE is always supported on server because we add fields/globals for it
        prog->flag |= PRVM_OP_STATE;
 
        VM_CustomStats_Clear();//[515]: csqc
 
-       PRVM_End;
-
        SV_Prepare_CSQC();
 }
 
-void SV_VM_Begin(void)
+extern cvar_t host_maxwait;
+extern cvar_t host_framerate;
+static int SV_ThreadFunc(void *voiddata)
 {
-       PRVM_Begin;
-       PRVM_SetProg( PRVM_SERVERPROG );
+       prvm_prog_t *prog = SVVM_prog;
+       qboolean playing = false;
+       double sv_timer = 0;
+       double sv_deltarealtime, sv_oldrealtime, sv_realtime;
+       double wait;
+       int i;
+       char vabuf[1024];
+       sv_realtime = Sys_DirtyTime();
+       while (!svs.threadstop)
+       {
+               // FIXME: we need to handle Host_Error in the server thread somehow
+//             if (setjmp(sv_abortframe))
+//                     continue;                       // something bad happened in the server game
+
+               sv_oldrealtime = sv_realtime;
+               sv_realtime = Sys_DirtyTime();
+               sv_deltarealtime = sv_realtime - sv_oldrealtime;
+               if (sv_deltarealtime < 0 || sv_deltarealtime >= 1800) sv_deltarealtime = 0;
+
+               sv_timer += sv_deltarealtime;
+
+               svs.perf_acc_realtime += sv_deltarealtime;
+
+               // at this point we start doing real server work, and must block on any client activity pertaining to the server (such as executing SV_SpawnServer)
+               SV_LockThreadMutex();
+
+               // Look for clients who have spawned
+               playing = false;
+               if (sv.active)
+                       for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
+                               if(host_client->begun)
+                                       if(host_client->netconnection)
+                                               playing = true;
+               if(sv.time < 10)
+               {
+                       // don't accumulate time for the first 10 seconds of a match
+                       // so things can settle
+                       svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0;
+               }
+               else if(svs.perf_acc_realtime > 5)
+               {
+                       svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime;
+                       svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime;
+                       if(svs.perf_acc_offset_samples > 0)
+                       {
+                               svs.perf_offset_max = svs.perf_acc_offset_max;
+                               svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples;
+                               svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg);
+                       }
+                       if(svs.perf_lost > 0 && developer_extra.integer)
+                               if(playing)
+                                       Con_DPrintf("Server can't keep up: %s\n", Host_TimingReport(vabuf, sizeof(vabuf)));
+                       svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0;
+               }
+
+               // get new packets
+               if (sv.active)
+                       NetConn_ServerFrame();
+
+               // if the accumulators haven't become positive yet, wait a while
+               wait = sv_timer * -1000000.0;
+               if (wait >= 1)
+               {
+                       double time0, delta;
+                       SV_UnlockThreadMutex(); // don't keep mutex locked while sleeping
+                       if (host_maxwait.value <= 0)
+                               wait = min(wait, 1000000.0);
+                       else
+                               wait = min(wait, host_maxwait.value * 1000.0);
+                       if(wait < 1)
+                               wait = 1; // because we cast to int
+                       time0 = Sys_DirtyTime();
+                       Sys_Sleep((int)wait);
+                       delta = Sys_DirtyTime() - time0;if (delta < 0 || delta >= 1800) delta = 0;
+                       svs.perf_acc_sleeptime += delta;
+                       continue;
+               }
+
+               if (sv.active && sv_timer > 0)
+               {
+                       // execute one server frame
+                       double advancetime;
+                       float offset;
+
+                       if (sys_ticrate.value <= 0)
+                               advancetime = min(sv_timer, 0.1); // don't step more than 100ms
+                       else
+                               advancetime = sys_ticrate.value;
+
+                       if(advancetime > 0)
+                       {
+                               offset = sv_timer + (Sys_DirtyTime() - sv_realtime); // LordHavoc: FIXME: I don't understand this line
+                               ++svs.perf_acc_offset_samples;
+                               svs.perf_acc_offset += offset;
+                               svs.perf_acc_offset_squared += offset * offset;
+                               if(svs.perf_acc_offset_max < offset)
+                                       svs.perf_acc_offset_max = offset;
+                       }
+
+                       // only advance time if not paused
+                       // the game also pauses in singleplayer when menu or console is used
+                       sv.frametime = advancetime * slowmo.value;
+                       if (host_framerate.value)
+                               sv.frametime = host_framerate.value;
+                       if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused)))
+                               sv.frametime = 0;
+
+                       sv_timer -= advancetime;
 
-       prog->globals.server->time = (float) sv.time;
+                       // move things around and think unless paused
+                       if (sv.frametime)
+                               SV_Physics();
+
+                       // send all messages to the clients
+                       SV_SendClientMessages();
+
+                       if (sv.paused == 1 && sv_realtime > sv.pausedstart && sv.pausedstart > 0)
+                       {
+                               PRVM_serverglobalfloat(time) = sv.time;
+                               prog->globals.fp[OFS_PARM0] = sv_realtime - sv.pausedstart;
+                               prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing");
+                       }
+
+                       // send an heartbeat if enough time has passed since the last one
+                       NetConn_Heartbeat(0);
+
+               }
+
+               // we're back to safe code now
+               SV_UnlockThreadMutex();
+
+               // if there is some time remaining from this frame, reset the timers
+               if (sv_timer >= 0)
+               {
+                       svs.perf_acc_lost += sv_timer;
+                       sv_timer = 0;
+               }
+       }
+       return 0;
 }
 
-void SV_VM_End(void)
+void SV_StartThread(void)
 {
-       PRVM_End;
+       if (!sv_threaded.integer || !Thread_HasThreads())
+               return;
+       svs.threaded = true;
+       svs.threadstop = false;
+       svs.threadmutex = Thread_CreateMutex();
+       svs.thread = Thread_CreateThread(SV_ThreadFunc, NULL);
+}
+
+void SV_StopThread(void)
+{
+       if (!svs.threaded)
+               return;
+       svs.threadstop = true;
+       Thread_WaitThread(svs.thread, 0);
+       Thread_DestroyMutex(svs.threadmutex);
+       svs.threaded = false;
 }