sv_main.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // sv_main.c -- server main program
  21
  22 #include "quakedef.h"
  23 #include "sv_demo.h"
  24 #include "libcurl.h"
  25 #include "csprogs.h"
  26 #include "thread.h"
  27
  28 // current client
  29 client_t *host_client;
  30
  31 static void SV_SaveEntFile_f(cmd_state_t *cmd);
  32 static void SV_StartDownload_f(cmd_state_t *cmd);
  33 static void SV_Download_f(cmd_state_t *cmd);
  34 static void SV_VM_Setup(void);
  35 extern cvar_t net_connecttimeout;
  36
  37 cvar_t sv_worldmessage = {CF_SERVER | CF_READONLY, "sv_worldmessage", "", "title of current level"};
  38 cvar_t sv_worldname = {CF_SERVER | CF_READONLY, "sv_worldname", "", "name of current worldmodel"};
  39 cvar_t sv_worldnamenoextension = {CF_SERVER | CF_READONLY, "sv_worldnamenoextension", "", "name of current worldmodel without extension"};
  40 cvar_t sv_worldbasename = {CF_SERVER | CF_READONLY, "sv_worldbasename", "", "name of current worldmodel without maps/ prefix or extension"};
  41
  42 cvar_t sv_disablenotify = {CF_SERVER, "sv_disablenotify", "0", "suppress broadcast prints when certain cvars are changed (CF_NOTIFY flag in engine code)"};
  43 cvar_t coop = {CF_SERVER, "coop","0", "coop mode, 0 = no coop, 1 = coop mode, multiple players playing through the singleplayer game (coop mode also shuts off deathmatch)"};
  44 cvar_t deathmatch = {CF_SERVER, "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)"};
  45 cvar_t fraglimit = {CF_SERVER | CF_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};
  46 cvar_t gamecfg = {CF_SERVER, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
  47 cvar_t noexit = {CF_SERVER | CF_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};
  48 cvar_t nomonsters = {CF_SERVER, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
  49 cvar_t pausable = {CF_SERVER, "pausable","1", "allow players to pause or not (otherwise, only the server admin can)"};
  50 cvar_t pr_checkextension = {CF_SERVER | CF_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"};
  51 cvar_t samelevel = {CF_SERVER | CF_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
  52 cvar_t skill = {CF_SERVER, "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)"};
  53 cvar_t host_timescale = {CF_CLIENT | CF_SERVER, "host_timescale", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
  54
  55 cvar_t sv_accelerate = {CF_SERVER, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
  56 cvar_t sv_aim = {CF_SERVER | CF_ARCHIVE, "sv_aim", "2", "maximum cosine angle for quake's vertical autoaim, a value above 1 completely disables the autoaim, quake used 0.93"};
  57 cvar_t sv_airaccel_qw = {CF_SERVER, "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"};
  58 cvar_t sv_airaccel_qw_stretchfactor = {CF_SERVER, "sv_airaccel_qw_stretchfactor", "0", "when set, the maximum acceleration increase the player may get compared to forward-acceleration when strafejumping"};
  59 cvar_t sv_airaccel_sideways_friction = {CF_SERVER, "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"};
  60 cvar_t sv_airaccelerate = {CF_SERVER, "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"};
  61 cvar_t sv_airstopaccelerate = {CF_SERVER, "sv_airstopaccelerate", "0", "when set, replacement for sv_airaccelerate when moving backwards"};
  62 cvar_t sv_airspeedlimit_nonqw = {CF_SERVER, "sv_airspeedlimit_nonqw", "0", "when set, this is a soft speed limit while in air when using airaccel_qw not equal to 1"};
  63 cvar_t sv_airstrafeaccelerate = {CF_SERVER, "sv_airstrafeaccelerate", "0", "when set, replacement for sv_airaccelerate when just strafing"};
  64 cvar_t sv_maxairstrafespeed = {CF_SERVER, "sv_maxairstrafespeed", "0", "when set, replacement for sv_maxairspeed when just strafing"};
  65 cvar_t sv_airstrafeaccel_qw = {CF_SERVER, "sv_airstrafeaccel_qw", "0", "when set, replacement for sv_airaccel_qw when just strafing"};
  66 cvar_t sv_aircontrol = {CF_SERVER, "sv_aircontrol", "0", "CPMA-style air control"};
  67 cvar_t sv_aircontrol_power = {CF_SERVER, "sv_aircontrol_power", "2", "CPMA-style air control exponent"};
  68 cvar_t sv_aircontrol_penalty = {CF_SERVER, "sv_aircontrol_penalty", "0", "deceleration while using CPMA-style air control"};
  69 cvar_t sv_allowdownloads = {CF_SERVER, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};
  70 cvar_t sv_allowdownloads_archive = {CF_SERVER, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};
  71 cvar_t sv_allowdownloads_config = {CF_SERVER, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};
  72 cvar_t sv_allowdownloads_dlcache = {CF_SERVER, "sv_allowdownloads_dlcache", "0", "whether to allow downloads of dlcache files (dlcache/)"};
  73 cvar_t sv_allowdownloads_inarchive = {CF_SERVER, "sv_allowdownloads_inarchive", "0", "whether to allow downloads from archives (pak/pk3)"};
  74 cvar_t sv_areagrid_mingridsize = {CF_SERVER | CF_NOTIFY, "sv_areagrid_mingridsize", "128", "minimum areagrid cell size, smaller values work better for lots of small objects, higher values for large objects"};
  75 cvar_t sv_checkforpacketsduringsleep = {CF_SERVER, "sv_checkforpacketsduringsleep", "0", "uses select() function to wait between frames which can be interrupted by packets being received, instead of Sleep()/usleep()/SDL_Sleep() functions which do not check for packets"};
  76 cvar_t sv_clmovement_enable = {CF_SERVER, "sv_clmovement_enable", "1", "whether to allow clients to use cl_movement prediction, which can cause choppy movement on the server which may annoy other players"};
  77 cvar_t sv_clmovement_maxping = {CF_SERVER, "sv_clmovement_maxping", "1000", "if client ping is above this time in milliseconds, then their ability to use cl_movement prediction is disabled for a while"};
  78 cvar_t sv_clmovement_minping = {CF_SERVER, "sv_clmovement_minping", "0", "if client ping is below this time in milliseconds, then their ability to use cl_movement prediction is disabled for a while (as they don't need it)"};
  79 cvar_t sv_clmovement_minping_disabletime = {CF_SERVER, "sv_clmovement_minping_disabletime", "1000", "when client falls below minping, disable their prediction for this many milliseconds (should be at least 1000 or else their prediction may turn on/off frequently)"};
  80 cvar_t sv_clmovement_inputtimeout = {CF_SERVER, "sv_clmovement_inputtimeout", "0.1", "when a client does not send input for this many seconds (max 0.1), force them to move anyway (unlike QuakeWorld)"};
  81 cvar_t sv_clmovement_inputtimeout_strict = {CF_SERVER, "sv_clmovement_inputtimeout_strict", "1", "prevent lagaporting (in other players' perspectives) and speeding up (in lagging player's perspective) when inputtimeout is exceeded"};
  82 cvar_t sv_cullentities_nevercullbmodels = {CF_SERVER, "sv_cullentities_nevercullbmodels", "0", "if enabled the clients are always notified of moving doors and lifts and other submodels of world (warning: eats a lot of network bandwidth on some levels!)"};
  83 cvar_t sv_cullentities_pvs = {CF_SERVER, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"};
  84 cvar_t sv_cullentities_stats = {CF_SERVER, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
  85 cvar_t sv_cullentities_trace = {CF_SERVER, "sv_cullentities_trace", "0", "somewhat slow but very tight culling of hidden entities, minimizes network traffic and makes wallhack cheats useless"};
  86 cvar_t sv_cullentities_trace_delay = {CF_SERVER, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  87 cvar_t sv_cullentities_trace_delay_players = {CF_SERVER, "sv_cullentities_trace_delay_players", "0.2", "number of seconds until the entity gets actually culled if it is a player entity"};
  88 cvar_t sv_cullentities_trace_enlarge = {CF_SERVER, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  89 cvar_t sv_cullentities_trace_expand = {CF_SERVER, "sv_cullentities_trace_expand", "0", "box is expanded by this many units for entity culling"};
  90 cvar_t sv_cullentities_trace_eyejitter = {CF_SERVER, "sv_cullentities_trace_eyejitter", "16", "jitter the eye by this much for each trace"};
  91 cvar_t sv_cullentities_trace_prediction = {CF_SERVER, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};
  92 cvar_t sv_cullentities_trace_prediction_time = {CF_SERVER, "sv_cullentities_trace_prediction_time", "0.2", "how many seconds of prediction to use"};
  93 cvar_t sv_cullentities_trace_entityocclusion = {CF_SERVER, "sv_cullentities_trace_entityocclusion", "0", "also check if doors and other bsp models are in the way"};
  94 cvar_t sv_cullentities_trace_samples = {CF_SERVER, "sv_cullentities_trace_samples", "2", "number of samples to test for entity culling"};
  95 cvar_t sv_cullentities_trace_samples_extra = {CF_SERVER, "sv_cullentities_trace_samples_extra", "2", "number of samples to test for entity culling when the entity affects its surroundings by e.g. dlight"};
  96 cvar_t sv_cullentities_trace_samples_players = {CF_SERVER, "sv_cullentities_trace_samples_players", "8", "number of samples to test for entity culling when the entity is a player entity"};
  97 cvar_t sv_debugmove = {CF_SERVER | CF_NOTIFY, "sv_debugmove", "0", "disables collision detection optimizations for debugging purposes"};
  98 cvar_t sv_echobprint = {CF_SERVER | CF_ARCHIVE, "sv_echobprint", "1", "prints gamecode bprint() calls to server console"};
  99 cvar_t sv_edgefriction = {CF_SERVER, "edgefriction", "1", "how much you slow down when nearing a ledge you might fall off, multiplier of sv_friction (Quake used 2, QuakeWorld used 1 due to a bug in physics code)"};
 100 cvar_t sv_entpatch = {CF_SERVER, "sv_entpatch", "1", "enables loading of .ent files to override entities in the bsp (for example Threewave CTF server pack contains .ent patch files enabling play of CTF on id1 maps)"};
 101 cvar_t sv_freezenonclients = {CF_SERVER | CF_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
 102 cvar_t sv_friction = {CF_SERVER | CF_NOTIFY, "sv_friction","4", "how fast you slow down"};
 103 cvar_t sv_gameplayfix_blowupfallenzombies = {CF_SERVER, "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"};
 104 cvar_t sv_gameplayfix_consistentplayerprethink = {CF_SERVER, "sv_gameplayfix_consistentplayerprethink", "0", "improves fairness in multiplayer by running all PlayerPreThink functions (which fire weapons) before performing physics, then running all PlayerPostThink functions"};
 105 cvar_t sv_gameplayfix_delayprojectiles = {CF_SERVER, "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"};
 106 cvar_t sv_gameplayfix_droptofloorstartsolid = {CF_SERVER, "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)"};
 107 cvar_t sv_gameplayfix_droptofloorstartsolid_nudgetocorrect = {CF_SERVER, "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect", "1", "tries to nudge stuck items and monsters out of walls before droptofloor is performed"};
 108 cvar_t sv_gameplayfix_easierwaterjump = {CF_SERVER, "sv_gameplayfix_easierwaterjump", "1", "changes water jumping to make it easier to get out of water (exactly like in QuakeWorld)"};
 109 cvar_t sv_gameplayfix_findradiusdistancetobox = {CF_SERVER, "sv_gameplayfix_findradiusdistancetobox", "1", "causes findradius to check the distance to the corner of a box rather than the center of the box, makes findradius detect bmodels such as very large doors that would otherwise be unaffected by splash damage"};
 110 cvar_t sv_gameplayfix_gravityunaffectedbyticrate = {CF_SERVER, "sv_gameplayfix_gravityunaffectedbyticrate", "0", "fix some ticrate issues in physics."};
 111 cvar_t sv_gameplayfix_grenadebouncedownslopes = {CF_SERVER, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
 112 cvar_t sv_gameplayfix_multiplethinksperframe = {CF_SERVER, "sv_gameplayfix_multiplethinksperframe", "1", "allows entities to think more often than the server framerate, primarily useful for very high fire rate weapons"};
 113 cvar_t sv_gameplayfix_noairborncorpse = {CF_SERVER, "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"};
 114 cvar_t sv_gameplayfix_noairborncorpse_allowsuspendeditems = {CF_SERVER, "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)"};
 115 cvar_t sv_gameplayfix_nudgeoutofsolid = {CF_SERVER, "sv_gameplayfix_nudgeoutofsolid", "0", "attempts to fix physics errors (where an object ended up in solid for some reason)"};
 116 cvar_t sv_gameplayfix_nudgeoutofsolid_separation = {CF_SERVER, "sv_gameplayfix_nudgeoutofsolid_separation", "0.03125", "keep objects this distance apart to prevent collision issues on seams"};
 117 cvar_t sv_gameplayfix_q2airaccelerate = {CF_SERVER, "sv_gameplayfix_q2airaccelerate", "0", "Quake2-style air acceleration"};
 118 cvar_t sv_gameplayfix_nogravityonground = {CF_SERVER, "sv_gameplayfix_nogravityonground", "0", "turn off gravity when on ground (to get rid of sliding)"};
 119 cvar_t sv_gameplayfix_setmodelrealbox = {CF_SERVER, "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"};
 120 cvar_t sv_gameplayfix_slidemoveprojectiles = {CF_SERVER, "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"};
 121 cvar_t sv_gameplayfix_stepdown = {CF_SERVER, "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)"};
 122 cvar_t sv_gameplayfix_stepmultipletimes = {CF_SERVER, "sv_gameplayfix_stepmultipletimes", "0", "applies step-up onto a ledge more than once in a single frame, when running quickly up stairs"};
 123 cvar_t sv_gameplayfix_nostepmoveonsteepslopes = {CF_SERVER, "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"};
 124 cvar_t sv_gameplayfix_swiminbmodels = {CF_SERVER, "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"};
 125 cvar_t sv_gameplayfix_upwardvelocityclearsongroundflag = {CF_SERVER, "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"};
 126 cvar_t sv_gameplayfix_downtracesupportsongroundflag = {CF_SERVER, "sv_gameplayfix_downtracesupportsongroundflag", "1", "prevents very short moves from clearing onground (which may make the player stick to the floor at high netfps)"};
 127 cvar_t sv_gameplayfix_q1bsptracelinereportstexture = {CF_SERVER, "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"};
 128 cvar_t sv_gameplayfix_unstickplayers = {CF_SERVER, "sv_gameplayfix_unstickplayers", "1", "big hack to try and fix the rare case of MOVETYPE_WALK entities getting stuck in the world clipping hull."};
 129 cvar_t sv_gameplayfix_unstickentities = {CF_SERVER, "sv_gameplayfix_unstickentities", "1", "hack to check if entities are crossing world collision hull and try to move them to the right position"};
 130 cvar_t sv_gameplayfix_fixedcheckwatertransition = {CF_SERVER, "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)"};
 131 cvar_t sv_gameplayfix_customstats = {CF_SERVER, "sv_gameplayfix_customstats", "0", "Disable stats higher than 220, for use by certain games such as Xonotic"};
 132 cvar_t sv_gravity = {CF_SERVER | CF_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
 133 cvar_t sv_init_frame_count = {CF_SERVER, "sv_init_frame_count", "2", "number of frames to run to allow everything to settle before letting clients connect"};
 134 cvar_t sv_idealpitchscale = {CF_SERVER, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};
 135 cvar_t sv_jumpstep = {CF_SERVER | CF_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping"};
 136 cvar_t sv_jumpvelocity = {CF_SERVER, "sv_jumpvelocity", "270", "cvar that can be used by QuakeC code for jump velocity"};
 137 cvar_t sv_maxairspeed = {CF_SERVER, "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)"};
 138 cvar_t sv_maxrate = {CF_SERVER | CF_ARCHIVE | CF_NOTIFY, "sv_maxrate", "1000000", "upper limit on client rate cvar, should reflect your network connection quality"};
 139 cvar_t sv_maxspeed = {CF_SERVER | CF_NOTIFY, "sv_maxspeed", "320", "maximum speed a player can accelerate to when on ground (can be exceeded by tricks)"};
 140 cvar_t sv_maxvelocity = {CF_SERVER | CF_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
 141 cvar_t sv_nostep = {CF_SERVER | CF_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
 142 cvar_t sv_playerphysicsqc = {CF_SERVER | CF_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
 143 cvar_t sv_progs = {CF_SERVER, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
 144 cvar_t sv_protocolname = {CF_SERVER, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
 145 cvar_t sv_random_seed = {CF_SERVER, "sv_random_seed", "", "random seed; when set, on every map start this random seed is used to initialize the random number generator. Don't touch it unless for benchmarking or debugging"};
 146 cvar_t host_limitlocal = {CF_SERVER, "host_limitlocal", "0", "whether to apply rate limiting to the local player in a listen server (only useful for testing)"};
 147 cvar_t sv_sound_land = {CF_SERVER, "sv_sound_land", "demon/dland2.wav", "sound to play when MOVETYPE_STEP entity hits the ground at high speed (empty cvar disables the sound)"};
 148 cvar_t sv_sound_watersplash = {CF_SERVER, "sv_sound_watersplash", "misc/h2ohit1.wav", "sound to play when MOVETYPE_FLY/TOSS/BOUNCE/STEP entity enters or leaves water (empty cvar disables the sound)"};
 149 cvar_t sv_stepheight = {CF_SERVER | CF_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
 150 cvar_t sv_stopspeed = {CF_SERVER | CF_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
 151 cvar_t sv_wallfriction = {CF_SERVER | CF_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
 152 cvar_t sv_wateraccelerate = {CF_SERVER, "sv_wateraccelerate", "-1", "rate at which a player accelerates to sv_maxspeed while in water, if less than 0 the sv_accelerate variable is used instead"};
 153 cvar_t sv_waterfriction = {CF_SERVER | CF_NOTIFY, "sv_waterfriction","-1", "how fast you slow down in water, if less than 0 the sv_friction variable is used instead"};
 154 cvar_t sv_warsowbunny_airforwardaccel = {CF_SERVER, "sv_warsowbunny_airforwardaccel", "1.00001", "how fast you accelerate until you reach sv_maxspeed"};
 155 cvar_t sv_warsowbunny_accel = {CF_SERVER, "sv_warsowbunny_accel", "0.1585", "how fast you accelerate until after reaching sv_maxspeed (it gets harder as you near sv_warsowbunny_topspeed)"};
 156 cvar_t sv_warsowbunny_topspeed = {CF_SERVER, "sv_warsowbunny_topspeed", "925", "soft speed limit (can get faster with rjs and on ramps)"};
 157 cvar_t sv_warsowbunny_turnaccel = {CF_SERVER, "sv_warsowbunny_turnaccel", "0", "max sharpness of turns (also master switch for the sv_warsowbunny_* mode; set this to 9 to enable)"};
 158 cvar_t sv_warsowbunny_backtosideratio = {CF_SERVER, "sv_warsowbunny_backtosideratio", "0.8", "lower values make it easier to change direction without losing speed; the drawback is \"understeering\" in sharp turns"};
 159 cvar_t sv_onlycsqcnetworking = {CF_SERVER, "sv_onlycsqcnetworking", "0", "disables legacy entity networking code for higher performance (except on clients, which can still be legacy)"};
 160 cvar_t sv_areadebug = {CF_SERVER, "sv_areadebug", "0", "disables physics culling for debugging purposes (only for development)"};
 161 cvar_t sys_ticrate = {CF_SERVER | CF_ARCHIVE, "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"};
 162 cvar_t teamplay = {CF_SERVER | CF_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"};
 163 cvar_t timelimit = {CF_SERVER | CF_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};
 164 cvar_t sv_threaded = {CF_SERVER, "sv_threaded", "0", "enables a separate thread for server code, improving performance, especially when hosting a game while playing, EXPERIMENTAL, may be crashy"};
 165
 166 cvar_t sv_rollspeed = {CF_CLIENT, "sv_rollspeed", "200", "how much strafing is necessary to tilt the view"};
 167 cvar_t sv_rollangle = {CF_CLIENT, "sv_rollangle", "2.0", "how much to tilt the view when strafing"};
 168
 169 cvar_t saved1 = {CF_SERVER | CF_ARCHIVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 170 cvar_t saved2 = {CF_SERVER | CF_ARCHIVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 171 cvar_t saved3 = {CF_SERVER | CF_ARCHIVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 172 cvar_t saved4 = {CF_SERVER | CF_ARCHIVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 173 cvar_t savedgamecfg = {CF_SERVER | CF_ARCHIVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 174 cvar_t scratch1 = {CF_SERVER, "scratch1", "0", "unused cvar in quake, can be used by mods"};
 175 cvar_t scratch2 = {CF_SERVER,"scratch2", "0", "unused cvar in quake, can be used by mods"};
 176 cvar_t scratch3 = {CF_SERVER, "scratch3", "0", "unused cvar in quake, can be used by mods"};
 177 cvar_t scratch4 = {CF_SERVER, "scratch4", "0", "unused cvar in quake, can be used by mods"};
 178 cvar_t temp1 = {CF_SERVER, "temp1","0", "general cvar for mods to use, in stock id1 this selects which death animation to use on players (0 = random death, other values select specific death scenes)"};
 179
 180 cvar_t nehx00 = {CF_SERVER, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
 181 cvar_t nehx01 = {CF_SERVER, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
 182 cvar_t nehx02 = {CF_SERVER, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
 183 cvar_t nehx03 = {CF_SERVER, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
 184 cvar_t nehx04 = {CF_SERVER, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
 185 cvar_t nehx05 = {CF_SERVER, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
 186 cvar_t nehx06 = {CF_SERVER, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
 187 cvar_t nehx07 = {CF_SERVER, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
 188 cvar_t nehx08 = {CF_SERVER, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
 189 cvar_t nehx09 = {CF_SERVER, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
 190 cvar_t nehx10 = {CF_SERVER, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
 191 cvar_t nehx11 = {CF_SERVER, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
 192 cvar_t nehx12 = {CF_SERVER, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
 193 cvar_t nehx13 = {CF_SERVER, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
 194 cvar_t nehx14 = {CF_SERVER, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
 195 cvar_t nehx15 = {CF_SERVER, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
 196 cvar_t nehx16 = {CF_SERVER, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
 197 cvar_t nehx17 = {CF_SERVER, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
 198 cvar_t nehx18 = {CF_SERVER, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
 199 cvar_t nehx19 = {CF_SERVER, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
 200 cvar_t cutscene = {CF_SERVER, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
 201
 202 cvar_t sv_autodemo_perclient = {CF_SERVER | CF_ARCHIVE, "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)"};
 203 cvar_t sv_autodemo_perclient_nameformat = {CF_SERVER | CF_ARCHIVE, "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)" };
 204 cvar_t sv_autodemo_perclient_discardable = {CF_SERVER | CF_ARCHIVE, "sv_autodemo_perclient_discardable", "0", "Allow game code to decide whether a demo should be kept or discarded."};
 205
 206 cvar_t halflifebsp = {CF_SERVER, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
 207 cvar_t sv_mapformat_is_quake2 = {CF_SERVER, "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)"};
 208 cvar_t sv_mapformat_is_quake3 = {CF_SERVER, "sv_mapformat_is_quake3", "0", "indicates the current map is q2bsp format (useful to know because of different entity behaviors)"};
 209
 210 cvar_t sv_writepicture_quality = {CF_SERVER | CF_ARCHIVE, "sv_writepicture_quality", "10", "WritePicture quality offset (higher means better quality, but slower)"};
 211
 212 server_t sv;
 213 server_static_t svs;
 214
 215 mempool_t *sv_mempool = NULL;
 216
 217 extern cvar_t host_timescale;
 218 extern float            scr_centertime_off;
 219
 220 // MUST match effectnameindex_t in client.h
 221 static const char *standardeffectnames[EFFECT_TOTAL] =
 222 {
 223         "",
 224         "TE_GUNSHOT",
 225         "TE_GUNSHOTQUAD",
 226         "TE_SPIKE",
 227         "TE_SPIKEQUAD",
 228         "TE_SUPERSPIKE",
 229         "TE_SUPERSPIKEQUAD",
 230         "TE_WIZSPIKE",
 231         "TE_KNIGHTSPIKE",
 232         "TE_EXPLOSION",
 233         "TE_EXPLOSIONQUAD",
 234         "TE_TAREXPLOSION",
 235         "TE_TELEPORT",
 236         "TE_LAVASPLASH",
 237         "TE_SMALLFLASH",
 238         "TE_FLAMEJET",
 239         "EF_FLAME",
 240         "TE_BLOOD",
 241         "TE_SPARK",
 242         "TE_PLASMABURN",
 243         "TE_TEI_G3",
 244         "TE_TEI_SMOKE",
 245         "TE_TEI_BIGEXPLOSION",
 246         "TE_TEI_PLASMAHIT",
 247         "EF_STARDUST",
 248         "TR_ROCKET",
 249         "TR_GRENADE",
 250         "TR_BLOOD",
 251         "TR_WIZSPIKE",
 252         "TR_SLIGHTBLOOD",
 253         "TR_KNIGHTSPIKE",
 254         "TR_VORESPIKE",
 255         "TR_NEHAHRASMOKE",
 256         "TR_NEXUIZPLASMA",
 257         "TR_GLOWTRAIL",
 258         "SVC_PARTICLE"
 259 };
 260
 261 #define SV_REQFUNCS 0
 262 #define sv_reqfuncs NULL
 263
 264 //#define SV_REQFUNCS (sizeof(sv_reqfuncs) / sizeof(const char *))
 265 //static const char *sv_reqfuncs[] = {
 266 //};
 267
 268 #define SV_REQFIELDS (sizeof(sv_reqfields) / sizeof(prvm_required_field_t))
 269
 270 prvm_required_field_t sv_reqfields[] =
 271 {
 272 #define PRVM_DECLARE_serverglobalfloat(x)
 273 #define PRVM_DECLARE_serverglobalvector(x)
 274 #define PRVM_DECLARE_serverglobalstring(x)
 275 #define PRVM_DECLARE_serverglobaledict(x)
 276 #define PRVM_DECLARE_serverglobalfunction(x)
 277 #define PRVM_DECLARE_clientglobalfloat(x)
 278 #define PRVM_DECLARE_clientglobalvector(x)
 279 #define PRVM_DECLARE_clientglobalstring(x)
 280 #define PRVM_DECLARE_clientglobaledict(x)
 281 #define PRVM_DECLARE_clientglobalfunction(x)
 282 #define PRVM_DECLARE_menuglobalfloat(x)
 283 #define PRVM_DECLARE_menuglobalvector(x)
 284 #define PRVM_DECLARE_menuglobalstring(x)
 285 #define PRVM_DECLARE_menuglobaledict(x)
 286 #define PRVM_DECLARE_menuglobalfunction(x)
 287 #define PRVM_DECLARE_serverfieldfloat(x) {ev_float, #x},
 288 #define PRVM_DECLARE_serverfieldvector(x) {ev_vector, #x},
 289 #define PRVM_DECLARE_serverfieldstring(x) {ev_string, #x},
 290 #define PRVM_DECLARE_serverfieldedict(x) {ev_entity, #x},
 291 #define PRVM_DECLARE_serverfieldfunction(x) {ev_function, #x},
 292 #define PRVM_DECLARE_clientfieldfloat(x)
 293 #define PRVM_DECLARE_clientfieldvector(x)
 294 #define PRVM_DECLARE_clientfieldstring(x)
 295 #define PRVM_DECLARE_clientfieldedict(x)
 296 #define PRVM_DECLARE_clientfieldfunction(x)
 297 #define PRVM_DECLARE_menufieldfloat(x)
 298 #define PRVM_DECLARE_menufieldvector(x)
 299 #define PRVM_DECLARE_menufieldstring(x)
 300 #define PRVM_DECLARE_menufieldedict(x)
 301 #define PRVM_DECLARE_menufieldfunction(x)
 302 #define PRVM_DECLARE_serverfunction(x)
 303 #define PRVM_DECLARE_clientfunction(x)
 304 #define PRVM_DECLARE_menufunction(x)
 305 #define PRVM_DECLARE_field(x)
 306 #define PRVM_DECLARE_global(x)
 307 #define PRVM_DECLARE_function(x)
 308 #include "prvm_offsets.h"
 309 #undef PRVM_DECLARE_serverglobalfloat
 310 #undef PRVM_DECLARE_serverglobalvector
 311 #undef PRVM_DECLARE_serverglobalstring
 312 #undef PRVM_DECLARE_serverglobaledict
 313 #undef PRVM_DECLARE_serverglobalfunction
 314 #undef PRVM_DECLARE_clientglobalfloat
 315 #undef PRVM_DECLARE_clientglobalvector
 316 #undef PRVM_DECLARE_clientglobalstring
 317 #undef PRVM_DECLARE_clientglobaledict
 318 #undef PRVM_DECLARE_clientglobalfunction
 319 #undef PRVM_DECLARE_menuglobalfloat
 320 #undef PRVM_DECLARE_menuglobalvector
 321 #undef PRVM_DECLARE_menuglobalstring
 322 #undef PRVM_DECLARE_menuglobaledict
 323 #undef PRVM_DECLARE_menuglobalfunction
 324 #undef PRVM_DECLARE_serverfieldfloat
 325 #undef PRVM_DECLARE_serverfieldvector
 326 #undef PRVM_DECLARE_serverfieldstring
 327 #undef PRVM_DECLARE_serverfieldedict
 328 #undef PRVM_DECLARE_serverfieldfunction
 329 #undef PRVM_DECLARE_clientfieldfloat
 330 #undef PRVM_DECLARE_clientfieldvector
 331 #undef PRVM_DECLARE_clientfieldstring
 332 #undef PRVM_DECLARE_clientfieldedict
 333 #undef PRVM_DECLARE_clientfieldfunction
 334 #undef PRVM_DECLARE_menufieldfloat
 335 #undef PRVM_DECLARE_menufieldvector
 336 #undef PRVM_DECLARE_menufieldstring
 337 #undef PRVM_DECLARE_menufieldedict
 338 #undef PRVM_DECLARE_menufieldfunction
 339 #undef PRVM_DECLARE_serverfunction
 340 #undef PRVM_DECLARE_clientfunction
 341 #undef PRVM_DECLARE_menufunction
 342 #undef PRVM_DECLARE_field
 343 #undef PRVM_DECLARE_global
 344 #undef PRVM_DECLARE_function
 345 };
 346
 347 #define SV_REQGLOBALS (sizeof(sv_reqglobals) / sizeof(prvm_required_field_t))
 348
 349 prvm_required_field_t sv_reqglobals[] =
 350 {
 351 #define PRVM_DECLARE_serverglobalfloat(x) {ev_float, #x},
 352 #define PRVM_DECLARE_serverglobalvector(x) {ev_vector, #x},
 353 #define PRVM_DECLARE_serverglobalstring(x) {ev_string, #x},
 354 #define PRVM_DECLARE_serverglobaledict(x) {ev_entity, #x},
 355 #define PRVM_DECLARE_serverglobalfunction(x) {ev_function, #x},
 356 #define PRVM_DECLARE_clientglobalfloat(x)
 357 #define PRVM_DECLARE_clientglobalvector(x)
 358 #define PRVM_DECLARE_clientglobalstring(x)
 359 #define PRVM_DECLARE_clientglobaledict(x)
 360 #define PRVM_DECLARE_clientglobalfunction(x)
 361 #define PRVM_DECLARE_menuglobalfloat(x)
 362 #define PRVM_DECLARE_menuglobalvector(x)
 363 #define PRVM_DECLARE_menuglobalstring(x)
 364 #define PRVM_DECLARE_menuglobaledict(x)
 365 #define PRVM_DECLARE_menuglobalfunction(x)
 366 #define PRVM_DECLARE_serverfieldfloat(x)
 367 #define PRVM_DECLARE_serverfieldvector(x)
 368 #define PRVM_DECLARE_serverfieldstring(x)
 369 #define PRVM_DECLARE_serverfieldedict(x)
 370 #define PRVM_DECLARE_serverfieldfunction(x)
 371 #define PRVM_DECLARE_clientfieldfloat(x)
 372 #define PRVM_DECLARE_clientfieldvector(x)
 373 #define PRVM_DECLARE_clientfieldstring(x)
 374 #define PRVM_DECLARE_clientfieldedict(x)
 375 #define PRVM_DECLARE_clientfieldfunction(x)
 376 #define PRVM_DECLARE_menufieldfloat(x)
 377 #define PRVM_DECLARE_menufieldvector(x)
 378 #define PRVM_DECLARE_menufieldstring(x)
 379 #define PRVM_DECLARE_menufieldedict(x)
 380 #define PRVM_DECLARE_menufieldfunction(x)
 381 #define PRVM_DECLARE_serverfunction(x)
 382 #define PRVM_DECLARE_clientfunction(x)
 383 #define PRVM_DECLARE_menufunction(x)
 384 #define PRVM_DECLARE_field(x)
 385 #define PRVM_DECLARE_global(x)
 386 #define PRVM_DECLARE_function(x)
 387 #include "prvm_offsets.h"
 388 #undef PRVM_DECLARE_serverglobalfloat
 389 #undef PRVM_DECLARE_serverglobalvector
 390 #undef PRVM_DECLARE_serverglobalstring
 391 #undef PRVM_DECLARE_serverglobaledict
 392 #undef PRVM_DECLARE_serverglobalfunction
 393 #undef PRVM_DECLARE_clientglobalfloat
 394 #undef PRVM_DECLARE_clientglobalvector
 395 #undef PRVM_DECLARE_clientglobalstring
 396 #undef PRVM_DECLARE_clientglobaledict
 397 #undef PRVM_DECLARE_clientglobalfunction
 398 #undef PRVM_DECLARE_menuglobalfloat
 399 #undef PRVM_DECLARE_menuglobalvector
 400 #undef PRVM_DECLARE_menuglobalstring
 401 #undef PRVM_DECLARE_menuglobaledict
 402 #undef PRVM_DECLARE_menuglobalfunction
 403 #undef PRVM_DECLARE_serverfieldfloat
 404 #undef PRVM_DECLARE_serverfieldvector
 405 #undef PRVM_DECLARE_serverfieldstring
 406 #undef PRVM_DECLARE_serverfieldedict
 407 #undef PRVM_DECLARE_serverfieldfunction
 408 #undef PRVM_DECLARE_clientfieldfloat
 409 #undef PRVM_DECLARE_clientfieldvector
 410 #undef PRVM_DECLARE_clientfieldstring
 411 #undef PRVM_DECLARE_clientfieldedict
 412 #undef PRVM_DECLARE_clientfieldfunction
 413 #undef PRVM_DECLARE_menufieldfloat
 414 #undef PRVM_DECLARE_menufieldvector
 415 #undef PRVM_DECLARE_menufieldstring
 416 #undef PRVM_DECLARE_menufieldedict
 417 #undef PRVM_DECLARE_menufieldfunction
 418 #undef PRVM_DECLARE_serverfunction
 419 #undef PRVM_DECLARE_clientfunction
 420 #undef PRVM_DECLARE_menufunction
 421 #undef PRVM_DECLARE_field
 422 #undef PRVM_DECLARE_global
 423 #undef PRVM_DECLARE_function
 424 };
 425
 426 static void Host_Timescale_c(cvar_t *var)
 427 {
 428         if(var->value < 0.00001 && var->value != 0)
 429                 Cvar_SetValueQuick(var, 0);
 430 }
 431
 432 //============================================================================
 433
 434 static void SV_AreaStats_f(cmd_state_t *cmd)
 435 {
 436         World_PrintAreaStats(&sv.world, "server");
 437 }
 438
 439 static void SV_ServerOptions (void)
 440 {
 441         int i;
 442
 443         // general default
 444         svs.maxclients = 8;
 445
 446 // COMMANDLINEOPTION: Server: -dedicated [playerlimit] starts a dedicated server (with a command console), default playerlimit is 8
 447 // COMMANDLINEOPTION: Server: -listen [playerlimit] starts a multiplayer server with graphical client, like singleplayer but other players can connect, default playerlimit is 8
 448         // if no client is in the executable or -dedicated is specified on
 449         // commandline, start a dedicated server
 450         i = Sys_CheckParm ("-dedicated");
 451         if (i || !cl_available)
 452         {
 453                 cls.state = ca_dedicated;
 454                 // check for -dedicated specifying how many players
 455                 if (i && i + 1 < sys.argc && atoi (sys.argv[i+1]) >= 1)
 456                         svs.maxclients = atoi (sys.argv[i+1]);
 457                 if (Sys_CheckParm ("-listen"))
 458                         Con_Printf ("Only one of -dedicated or -listen can be specified\n");
 459                 // default sv_public on for dedicated servers (often hosted by serious administrators), off for listen servers (often hosted by clueless users)
 460                 Cvar_SetValue(&cvars_all, "sv_public", 1);
 461         }
 462         else if (cl_available)
 463         {
 464                 // client exists and not dedicated, check if -listen is specified
 465                 cls.state = ca_disconnected;
 466                 i = Sys_CheckParm ("-listen");
 467                 if (i)
 468                 {
 469                         // default players unless specified
 470                         if (i + 1 < sys.argc && atoi (sys.argv[i+1]) >= 1)
 471                                 svs.maxclients = atoi (sys.argv[i+1]);
 472                 }
 473                 else
 474                 {
 475                         // default players in some games, singleplayer in most
 476                         if (gamemode != GAME_GOODVSBAD2 && !IS_NEXUIZ_DERIVED(gamemode) && gamemode != GAME_BATTLEMECH)
 477                                 svs.maxclients = 1;
 478                 }
 479         }
 480
 481         svs.maxclients = svs.maxclients_next = bound(1, svs.maxclients, MAX_SCOREBOARD);
 482
 483         svs.clients = (client_t *)Mem_Alloc(sv_mempool, sizeof(client_t) * svs.maxclients);
 484
 485         if (svs.maxclients > 1 && !deathmatch.integer && !coop.integer)
 486                 Cvar_SetValueQuick(&deathmatch, 1);
 487 }
 488
 489 /*
 490 ===============
 491 SV_Init
 492 ===============
 493 */
 494 void SV_Init (void)
 495 {
 496         // init the csqc progs cvars, since they are updated/used by the server code
 497         // TODO: fix this since this is a quick hack to make some of [515]'s broken code run ;) [9/13/2006 Black]
 498         extern cvar_t csqc_progname;    //[515]: csqc crc check and right csprogs name according to progs.dat
 499         extern cvar_t csqc_progcrc;
 500         extern cvar_t csqc_progsize;
 501         extern cvar_t csqc_usedemoprogs;
 502
 503         Cvar_RegisterVariable(&sv_worldmessage);
 504         Cvar_RegisterVariable(&sv_worldname);
 505         Cvar_RegisterVariable(&sv_worldnamenoextension);
 506         Cvar_RegisterVariable(&sv_worldbasename);
 507
 508         Cvar_RegisterVariable (&csqc_progname);
 509         Cvar_RegisterVariable (&csqc_progcrc);
 510         Cvar_RegisterVariable (&csqc_progsize);
 511         Cvar_RegisterVariable (&csqc_usedemoprogs);
 512
 513         Cmd_AddCommand(CF_SHARED, "sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
 514         Cmd_AddCommand(CF_SHARED, "sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
 515         Cmd_AddCommand(CF_CLIENT | CF_SERVER_FROM_CLIENT, "sv_startdownload", SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
 516         Cmd_AddCommand(CF_CLIENT | CF_SERVER_FROM_CLIENT, "download", SV_Download_f, "downloads a specified file from the server");
 517
 518         Cvar_RegisterVariable (&sv_disablenotify);
 519         Cvar_RegisterVariable (&coop);
 520         Cvar_RegisterVariable (&deathmatch);
 521         Cvar_RegisterVariable (&fraglimit);
 522         Cvar_RegisterVariable (&gamecfg);
 523         Cvar_RegisterVariable (&noexit);
 524         Cvar_RegisterVariable (&nomonsters);
 525         Cvar_RegisterVariable (&pausable);
 526         Cvar_RegisterVariable (&pr_checkextension);
 527         Cvar_RegisterVariable (&samelevel);
 528         Cvar_RegisterVariable (&skill);
 529         Cvar_RegisterVariable (&host_timescale);
 530         Cvar_RegisterCallback (&host_timescale, Host_Timescale_c);
 531         Cvar_RegisterAlias (&host_timescale, "slowmo");
 532         Cvar_RegisterAlias (&host_timescale, "timescale");
 533         Cvar_RegisterVariable (&sv_accelerate);
 534         Cvar_RegisterVariable (&sv_aim);
 535         Cvar_RegisterVariable (&sv_airaccel_qw);
 536         Cvar_RegisterVariable (&sv_airaccel_qw_stretchfactor);
 537         Cvar_RegisterVariable (&sv_airaccel_sideways_friction);
 538         Cvar_RegisterVariable (&sv_airaccelerate);
 539         Cvar_RegisterVariable (&sv_airstopaccelerate);
 540         Cvar_RegisterVariable (&sv_airstrafeaccelerate);
 541         Cvar_RegisterVariable (&sv_maxairstrafespeed);
 542         Cvar_RegisterVariable (&sv_airstrafeaccel_qw);
 543         Cvar_RegisterVariable (&sv_airspeedlimit_nonqw);
 544         Cvar_RegisterVariable (&sv_aircontrol);
 545         Cvar_RegisterVariable (&sv_aircontrol_power);
 546         Cvar_RegisterVariable (&sv_aircontrol_penalty);
 547         Cvar_RegisterVariable (&sv_allowdownloads);
 548         Cvar_RegisterVariable (&sv_allowdownloads_archive);
 549         Cvar_RegisterVariable (&sv_allowdownloads_config);
 550         Cvar_RegisterVariable (&sv_allowdownloads_dlcache);
 551         Cvar_RegisterVariable (&sv_allowdownloads_inarchive);
 552         Cvar_RegisterVariable (&sv_areagrid_mingridsize);
 553         Cvar_RegisterVariable (&sv_checkforpacketsduringsleep);
 554         Cvar_RegisterVariable (&sv_clmovement_enable);
 555         Cvar_RegisterVariable (&sv_clmovement_maxping);
 556         Cvar_RegisterVariable (&sv_clmovement_minping);
 557         Cvar_RegisterVariable (&sv_clmovement_minping_disabletime);
 558         Cvar_RegisterVariable (&sv_clmovement_inputtimeout);
 559         Cvar_RegisterVariable (&sv_clmovement_inputtimeout_strict);
 560         Cvar_RegisterVariable (&sv_cullentities_nevercullbmodels);
 561         Cvar_RegisterVariable (&sv_cullentities_pvs);
 562         Cvar_RegisterVariable (&sv_cullentities_stats);
 563         Cvar_RegisterVariable (&sv_cullentities_trace);
 564         Cvar_RegisterVariable (&sv_cullentities_trace_delay);
 565         Cvar_RegisterVariable (&sv_cullentities_trace_delay_players);
 566         Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
 567         Cvar_RegisterVariable (&sv_cullentities_trace_expand);
 568         Cvar_RegisterVariable (&sv_cullentities_trace_eyejitter);
 569         Cvar_RegisterVariable (&sv_cullentities_trace_entityocclusion);
 570         Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
 571         Cvar_RegisterVariable (&sv_cullentities_trace_prediction_time);
 572         Cvar_RegisterVariable (&sv_cullentities_trace_samples);
 573         Cvar_RegisterVariable (&sv_cullentities_trace_samples_extra);
 574         Cvar_RegisterVariable (&sv_cullentities_trace_samples_players);
 575         Cvar_RegisterVariable (&sv_debugmove);
 576         Cvar_RegisterVariable (&sv_echobprint);
 577         Cvar_RegisterVariable (&sv_edgefriction);
 578         Cvar_RegisterVariable (&sv_entpatch);
 579         Cvar_RegisterVariable (&sv_freezenonclients);
 580         Cvar_RegisterVariable (&sv_friction);
 581         Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
 582         Cvar_RegisterVariable (&sv_gameplayfix_consistentplayerprethink);
 583         Cvar_RegisterVariable (&sv_gameplayfix_delayprojectiles);
 584         Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid);
 585         Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid_nudgetocorrect);
 586         Cvar_RegisterVariable (&sv_gameplayfix_easierwaterjump);
 587         Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
 588         Cvar_RegisterVariable (&sv_gameplayfix_gravityunaffectedbyticrate);
 589         Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
 590         Cvar_RegisterVariable (&sv_gameplayfix_multiplethinksperframe);
 591         Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
 592         Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse_allowsuspendeditems);
 593         Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid);
 594         Cvar_RegisterVariable (&sv_gameplayfix_nudgeoutofsolid_separation);
 595         Cvar_RegisterVariable (&sv_gameplayfix_q2airaccelerate);
 596         Cvar_RegisterVariable (&sv_gameplayfix_nogravityonground);
 597         Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
 598         Cvar_RegisterVariable (&sv_gameplayfix_slidemoveprojectiles);
 599         Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
 600         Cvar_RegisterVariable (&sv_gameplayfix_stepmultipletimes);
 601         Cvar_RegisterVariable (&sv_gameplayfix_nostepmoveonsteepslopes);
 602         Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
 603         Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
 604         Cvar_RegisterVariable (&sv_gameplayfix_downtracesupportsongroundflag);
 605         Cvar_RegisterVariable (&sv_gameplayfix_q1bsptracelinereportstexture);
 606         Cvar_RegisterVariable (&sv_gameplayfix_unstickplayers);
 607         Cvar_RegisterVariable (&sv_gameplayfix_unstickentities);
 608         Cvar_RegisterVariable (&sv_gameplayfix_fixedcheckwatertransition);
 609         Cvar_RegisterVariable (&sv_gameplayfix_customstats);
 610         Cvar_RegisterVariable (&sv_gravity);
 611         Cvar_RegisterVariable (&sv_init_frame_count);
 612         Cvar_RegisterVariable (&sv_idealpitchscale);
 613         Cvar_RegisterVariable (&sv_jumpstep);
 614         Cvar_RegisterVariable (&sv_jumpvelocity);
 615         Cvar_RegisterVariable (&sv_maxairspeed);
 616         Cvar_RegisterVariable (&sv_maxrate);
 617         Cvar_RegisterVariable (&sv_maxspeed);
 618         Cvar_RegisterVariable (&sv_maxvelocity);
 619         Cvar_RegisterVariable (&sv_nostep);
 620         Cvar_RegisterVariable (&sv_playerphysicsqc);
 621         Cvar_RegisterVariable (&sv_progs);
 622         Cvar_RegisterVariable (&sv_protocolname);
 623         Cvar_RegisterVariable (&sv_random_seed);
 624         Cvar_RegisterVariable (&host_limitlocal);
 625         Cvar_RegisterAlias(&host_limitlocal, "sv_ratelimitlocalplayer");
 626         Cvar_RegisterVariable (&sv_sound_land);
 627         Cvar_RegisterVariable (&sv_sound_watersplash);
 628         Cvar_RegisterVariable (&sv_stepheight);
 629         Cvar_RegisterVariable (&sv_stopspeed);
 630         Cvar_RegisterVariable (&sv_wallfriction);
 631         Cvar_RegisterVariable (&sv_wateraccelerate);
 632         Cvar_RegisterVariable (&sv_waterfriction);
 633         Cvar_RegisterVariable (&sv_warsowbunny_airforwardaccel);
 634         Cvar_RegisterVariable (&sv_warsowbunny_accel);
 635         Cvar_RegisterVariable (&sv_warsowbunny_topspeed);
 636         Cvar_RegisterVariable (&sv_warsowbunny_turnaccel);
 637         Cvar_RegisterVariable (&sv_warsowbunny_backtosideratio);
 638         Cvar_RegisterVariable (&sv_onlycsqcnetworking);
 639         Cvar_RegisterVariable (&sv_areadebug);
 640         Cvar_RegisterVariable (&sys_ticrate);
 641         Cvar_RegisterVariable (&teamplay);
 642         Cvar_RegisterVariable (&timelimit);
 643         Cvar_RegisterVariable (&sv_threaded);
 644
 645         Cvar_RegisterVariable (&sv_rollangle);
 646         Cvar_RegisterVariable (&sv_rollspeed);
 647
 648         Cvar_RegisterVariable (&saved1);
 649         Cvar_RegisterVariable (&saved2);
 650         Cvar_RegisterVariable (&saved3);
 651         Cvar_RegisterVariable (&saved4);
 652         Cvar_RegisterVariable (&savedgamecfg);
 653         Cvar_RegisterVariable (&scratch1);
 654         Cvar_RegisterVariable (&scratch2);
 655         Cvar_RegisterVariable (&scratch3);
 656         Cvar_RegisterVariable (&scratch4);
 657         Cvar_RegisterVariable (&temp1);
 658
 659         // LadyHavoc: Nehahra uses these to pass data around cutscene demos
 660         Cvar_RegisterVariable (&nehx00);
 661         Cvar_RegisterVariable (&nehx01);
 662         Cvar_RegisterVariable (&nehx02);
 663         Cvar_RegisterVariable (&nehx03);
 664         Cvar_RegisterVariable (&nehx04);
 665         Cvar_RegisterVariable (&nehx05);
 666         Cvar_RegisterVariable (&nehx06);
 667         Cvar_RegisterVariable (&nehx07);
 668         Cvar_RegisterVariable (&nehx08);
 669         Cvar_RegisterVariable (&nehx09);
 670         Cvar_RegisterVariable (&nehx10);
 671         Cvar_RegisterVariable (&nehx11);
 672         Cvar_RegisterVariable (&nehx12);
 673         Cvar_RegisterVariable (&nehx13);
 674         Cvar_RegisterVariable (&nehx14);
 675         Cvar_RegisterVariable (&nehx15);
 676         Cvar_RegisterVariable (&nehx16);
 677         Cvar_RegisterVariable (&nehx17);
 678         Cvar_RegisterVariable (&nehx18);
 679         Cvar_RegisterVariable (&nehx19);
 680         Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
 681
 682         Cvar_RegisterVariable (&sv_autodemo_perclient);
 683         Cvar_RegisterVariable (&sv_autodemo_perclient_nameformat);
 684         Cvar_RegisterVariable (&sv_autodemo_perclient_discardable);
 685
 686         Cvar_RegisterVariable (&halflifebsp);
 687         Cvar_RegisterVariable (&sv_mapformat_is_quake2);
 688         Cvar_RegisterVariable (&sv_mapformat_is_quake3);
 689
 690         Cvar_RegisterVariable (&sv_writepicture_quality);
 691
 692         SV_InitOperatorCommands();
 693         host.hook.SV_Shutdown = SV_Shutdown;
 694
 695         sv_mempool = Mem_AllocPool("server", 0, NULL);
 696
 697         SV_ServerOptions();
 698         Cvar_Callback(&sv_netport);
 699 }
 700
 701 static void SV_SaveEntFile_f(cmd_state_t *cmd)
 702 {
 703         char vabuf[1024];
 704         if (!sv.active || !sv.worldmodel)
 705         {
 706                 Con_Print("Not running a server\n");
 707                 return;
 708         }
 709         FS_WriteFile(va(vabuf, sizeof(vabuf), "%s.ent", sv.worldnamenoextension), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
 710 }
 711
 712 /*
 713 ==============================================================================
 714
 715 CLIENT SPAWNING
 716
 717 ==============================================================================
 718 */
 719
 720 /*
 721 ================
 722 SV_SendServerinfo
 723
 724 Sends the first message from the server to a connected client.
 725 This will be sent on the initial connection and upon each server load.
 726 ================
 727 */
 728 void SV_SendServerinfo (client_t *client)
 729 {
 730         prvm_prog_t *prog = SVVM_prog;
 731         int i;
 732         char message[128];
 733         char vabuf[1024];
 734
 735         // we know that this client has a netconnection and thus is not a bot
 736
 737         // edicts get reallocated on level changes, so we need to update it here
 738         client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
 739
 740         // clear cached stuff that depends on the level
 741         client->weaponmodel[0] = 0;
 742         client->weaponmodelindex = 0;
 743
 744         // LadyHavoc: clear entityframe tracking
 745         client->latestframenum = 0;
 746
 747         // initialize the movetime, so a speedhack can't make use of the time before this client joined
 748         client->cmd.time = sv.time;
 749
 750         if (client->entitydatabase)
 751                 EntityFrame_FreeDatabase(client->entitydatabase);
 752         if (client->entitydatabase4)
 753                 EntityFrame4_FreeDatabase(client->entitydatabase4);
 754         if (client->entitydatabase5)
 755                 EntityFrame5_FreeDatabase(client->entitydatabase5);
 756
 757         memset(client->stats, 0, sizeof(client->stats));
 758         memset(client->statsdeltabits, 0, sizeof(client->statsdeltabits));
 759
 760         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)
 761         {
 762                 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
 763                         client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
 764                 else if (sv.protocol == PROTOCOL_DARKPLACES4)
 765                         client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
 766                 else
 767                         client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
 768         }
 769
 770         // reset csqc entity versions
 771         for (i = 0;i < prog->max_edicts;i++)
 772         {
 773                 client->csqcentityscope[i] = 0;
 774                 client->csqcentitysendflags[i] = 0xFFFFFF;
 775         }
 776         for (i = 0;i < NUM_CSQCENTITYDB_FRAMES;i++)
 777         {
 778                 client->csqcentityframehistory[i].num = 0;
 779                 client->csqcentityframehistory[i].framenum = -1;
 780         }
 781         client->csqcnumedicts = 0;
 782         client->csqcentityframehistory_next = 0;
 783
 784         SZ_Clear (&client->netconnection->message);
 785         MSG_WriteByte (&client->netconnection->message, svc_print);
 786         dpsnprintf (message, sizeof (message), "\nServer: %s build %s (progs %i crc)\n", gamename, buildstring, prog->filecrc);
 787         MSG_WriteString (&client->netconnection->message,message);
 788
 789         SV_StopDemoRecording(client); // to split up demos into different files
 790         if(sv_autodemo_perclient.integer)
 791         {
 792                 char demofile[MAX_OSPATH];
 793                 char ipaddress[MAX_QPATH];
 794                 size_t j;
 795
 796                 // start a new demo file
 797                 LHNETADDRESS_ToString(&(client->netconnection->peeraddress), ipaddress, sizeof(ipaddress), true);
 798                 for(j = 0; ipaddress[j]; ++j)
 799                         if(!isalnum(ipaddress[j]))
 800                                 ipaddress[j] = '-';
 801                 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);
 802
 803                 SV_StartDemoRecording(client, demofile, -1);
 804         }
 805
 806         //[515]: init csprogs according to version of svprogs, check the crc, etc.
 807         if (sv.csqc_progname[0])
 808         {
 809                 Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
 810                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 811                 MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progname %s\n", sv.csqc_progname));
 812                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 813                 MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progsize %i\n", sv.csqc_progsize));
 814                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 815                 MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "csqc_progcrc %i\n", sv.csqc_progcrc));
 816
 817                 if(client->sv_demo_file != NULL)
 818                 {
 819                         int k;
 820                         static char buf[NET_MAXMESSAGE];
 821                         sizebuf_t sb;
 822
 823                         sb.data = (unsigned char *) buf;
 824                         sb.maxsize = sizeof(buf);
 825                         k = 0;
 826                         while(MakeDownloadPacket(sv.csqc_progname, svs.csqc_progdata, sv.csqc_progsize, sv.csqc_progcrc, k++, &sb, sv.protocol))
 827                                 SV_WriteDemoMessage(client, &sb, false);
 828                 }
 829
 830                 //[515]: init stufftext string (it is sent before svc_serverinfo)
 831                 if (PRVM_GetString(prog, PRVM_serverglobalstring(SV_InitCmd)))
 832                 {
 833                         MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 834                         MSG_WriteString (&client->netconnection->message, va(vabuf, sizeof(vabuf), "%s\n", PRVM_GetString(prog, PRVM_serverglobalstring(SV_InitCmd))));
 835                 }
 836         }
 837
 838         //if (sv_allowdownloads.integer)
 839         // always send the info that the server supports the protocol, even if downloads are forbidden
 840         // only because of that, the CSQC exception can work
 841         {
 842                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 843                 MSG_WriteString (&client->netconnection->message, "cl_serverextension_download 2\n");
 844         }
 845
 846         // send at this time so it's guaranteed to get executed at the right time
 847         {
 848                 client_t *save;
 849                 save = host_client;
 850                 host_client = client;
 851                 Curl_SendRequirements();
 852                 host_client = save;
 853         }
 854
 855         MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
 856         MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
 857         MSG_WriteByte (&client->netconnection->message, svs.maxclients);
 858
 859         if (!coop.integer && deathmatch.integer)
 860                 MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
 861         else
 862                 MSG_WriteByte (&client->netconnection->message, GAME_COOP);
 863
 864         MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)));
 865
 866         for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
 867                 MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
 868         MSG_WriteByte (&client->netconnection->message, 0);
 869
 870         for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
 871                 MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
 872         MSG_WriteByte (&client->netconnection->message, 0);
 873
 874 // send music
 875         MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
 876         MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
 877         MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
 878
 879 // set view
 880 // store this in clientcamera, too
 881         client->clientcamera = PRVM_NUM_FOR_EDICT(client->edict);
 882         MSG_WriteByte (&client->netconnection->message, svc_setview);
 883         MSG_WriteShort (&client->netconnection->message, client->clientcamera);
 884
 885         MSG_WriteByte (&client->netconnection->message, svc_signonnum);
 886         MSG_WriteByte (&client->netconnection->message, 1);
 887
 888         client->prespawned = false;             // need prespawn, spawn, etc
 889         client->spawned = false;                // need prespawn, spawn, etc
 890         client->begun = false;                  // need prespawn, spawn, etc
 891         client->sendsignon = 1;                 // send this message, and increment to 2, 2 will be set to 0 by the prespawn command
 892
 893         // clear movement info until client enters the new level properly
 894         memset(&client->cmd, 0, sizeof(client->cmd));
 895         client->movesequence = 0;
 896         client->movement_highestsequence_seen = 0;
 897         memset(&client->movement_count, 0, sizeof(client->movement_count));
 898         client->ping = 0;
 899
 900         // allow the client some time to send his keepalives, even if map loading took ages
 901         client->netconnection->timeout = host.realtime + net_connecttimeout.value;
 902 }
 903
 904 /*
 905 ================
 906 SV_ConnectClient
 907
 908 Initializes a client_t for a new net connection.  This will only be called
 909 once for a player each game, not once for each level change.
 910 ================
 911 */
 912 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
 913 {
 914         prvm_prog_t *prog = SVVM_prog;
 915         client_t                *client;
 916         int                             i;
 917
 918         client = svs.clients + clientnum;
 919
 920 // set up the client_t
 921         if (sv.loadgame)
 922         {
 923                 float backupparms[NUM_SPAWN_PARMS];
 924                 memcpy(backupparms, client->spawn_parms, sizeof(backupparms));
 925                 memset(client, 0, sizeof(*client));
 926                 memcpy(client->spawn_parms, backupparms, sizeof(backupparms));
 927         }
 928         else
 929                 memset(client, 0, sizeof(*client));
 930         client->active = true;
 931         client->netconnection = netconnection;
 932
 933         Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
 934
 935         if(client->netconnection && client->netconnection->crypto.authenticated)
 936         {
 937                 Con_Printf("%s connection to %s has been established: client is %s@%s%.*s, I am %.*s@%s%.*s\n",
 938                                 client->netconnection->crypto.use_aes ? "Encrypted" : "Authenticated",
 939                                 client->netconnection->address,
 940                                 client->netconnection->crypto.client_idfp[0] ? client->netconnection->crypto.client_idfp : "-",
 941                                 (client->netconnection->crypto.client_issigned || !client->netconnection->crypto.client_keyfp[0]) ? "" : "~",
 942                                 crypto_keyfp_recommended_length, client->netconnection->crypto.client_keyfp[0] ? client->netconnection->crypto.client_keyfp : "-",
 943                                 crypto_keyfp_recommended_length, client->netconnection->crypto.server_idfp[0] ? client->netconnection->crypto.server_idfp : "-",
 944                                 (client->netconnection->crypto.server_issigned || !client->netconnection->crypto.server_keyfp[0]) ? "" : "~",
 945                                 crypto_keyfp_recommended_length, client->netconnection->crypto.server_keyfp[0] ? client->netconnection->crypto.server_keyfp : "-"
 946                                 );
 947         }
 948
 949         strlcpy(client->name, "unconnected", sizeof(client->name));
 950         strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
 951         client->prespawned = false;
 952         client->spawned = false;
 953         client->begun = false;
 954         client->edict = PRVM_EDICT_NUM(clientnum+1);
 955         if (client->netconnection)
 956                 client->netconnection->message.allowoverflow = true;            // we can catch it
 957         // prepare the unreliable message buffer
 958         client->unreliablemsg.data = client->unreliablemsg_data;
 959         client->unreliablemsg.maxsize = sizeof(client->unreliablemsg_data);
 960         // updated by receiving "rate" command from client, this is also the default if not using a DP client
 961         client->rate = 1000000000;
 962         client->connecttime = host.realtime;
 963
 964         if (!sv.loadgame)
 965         {
 966                 // call the progs to get default spawn parms for the new client
 967                 // set self to world to intentionally cause errors with broken SetNewParms code in some mods
 968                 PRVM_serverglobalfloat(time) = sv.time;
 969                 PRVM_serverglobaledict(self) = 0;
 970                 prog->ExecuteProgram(prog, PRVM_serverfunction(SetNewParms), "QC function SetNewParms is missing");
 971                 for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
 972                         client->spawn_parms[i] = (&PRVM_serverglobalfloat(parm1))[i];
 973
 974                 // set up the entity for this client (including .colormap, .team, etc)
 975                 PRVM_ED_ClearEdict(prog, client->edict);
 976         }
 977
 978         // don't call SendServerinfo for a fresh botclient because its fields have
 979         // not been set up by the qc yet
 980         if (client->netconnection)
 981                 SV_SendServerinfo (client);
 982         else
 983                 client->prespawned = client->spawned = client->begun = true;
 984 }
 985
 986 /*
 987 =====================
 988 SV_DropClient
 989
 990 Called when the player is getting totally kicked off the host
 991 if (crash = true), don't bother sending signofs
 992 =====================
 993 */
 994 void SV_DropClient(qbool crash)
 995 {
 996         prvm_prog_t *prog = SVVM_prog;
 997         int i;
 998         Con_Printf("Client \"%s\" dropped\n", host_client->name);
 999
1000         SV_StopDemoRecording(host_client);
1001
1002         // make sure edict is not corrupt (from a level change for example)
1003         host_client->edict = PRVM_EDICT_NUM(host_client - svs.clients + 1);
1004
1005         if (host_client->netconnection)
1006         {
1007                 // tell the client to be gone
1008                 if (!crash)
1009                 {
1010                         // LadyHavoc: no opportunity for resending, so use unreliable 3 times
1011                         unsigned char bufdata[8];
1012                         sizebuf_t buf;
1013                         memset(&buf, 0, sizeof(buf));
1014                         buf.data = bufdata;
1015                         buf.maxsize = sizeof(bufdata);
1016                         MSG_WriteByte(&buf, svc_disconnect);
1017                         NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
1018                         NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
1019                         NetConn_SendUnreliableMessage(host_client->netconnection, &buf, sv.protocol, 10000, 0, false);
1020                 }
1021         }
1022
1023         // call qc ClientDisconnect function
1024         // LadyHavoc: don't call QC if server is dead (avoids recursive
1025         // Host_Error in some mods when they run out of edicts)
1026         if (host_client->clientconnectcalled && sv.active && host_client->edict)
1027         {
1028                 // call the prog function for removing a client
1029                 // this will set the body to a dead frame, among other things
1030                 int saveSelf = PRVM_serverglobaledict(self);
1031                 host_client->clientconnectcalled = false;
1032                 PRVM_serverglobalfloat(time) = sv.time;
1033                 PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
1034                 prog->ExecuteProgram(prog, PRVM_serverfunction(ClientDisconnect), "QC function ClientDisconnect is missing");
1035                 PRVM_serverglobaledict(self) = saveSelf;
1036         }
1037
1038         if (host_client->netconnection)
1039         {
1040                 // break the net connection
1041                 NetConn_Close(host_client->netconnection);
1042                 host_client->netconnection = NULL;
1043         }
1044
1045         // if a download is active, close it
1046         if (host_client->download_file)
1047         {
1048                 Con_DPrintf("Download of %s aborted when %s dropped\n", host_client->download_name, host_client->name);
1049                 FS_Close(host_client->download_file);
1050                 host_client->download_file = NULL;
1051                 host_client->download_name[0] = 0;
1052                 host_client->download_expectedposition = 0;
1053                 host_client->download_started = false;
1054         }
1055
1056         // remove leaving player from scoreboard
1057         host_client->name[0] = 0;
1058         host_client->colors = 0;
1059         host_client->frags = 0;
1060         // send notification to all clients
1061         // get number of client manually just to make sure we get it right...
1062         i = host_client - svs.clients;
1063         MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
1064         MSG_WriteByte (&sv.reliable_datagram, i);
1065         MSG_WriteString (&sv.reliable_datagram, host_client->name);
1066         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1067         MSG_WriteByte (&sv.reliable_datagram, i);
1068         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1069         MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
1070         MSG_WriteByte (&sv.reliable_datagram, i);
1071         MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
1072
1073         // free the client now
1074         if (host_client->entitydatabase)
1075                 EntityFrame_FreeDatabase(host_client->entitydatabase);
1076         if (host_client->entitydatabase4)
1077                 EntityFrame4_FreeDatabase(host_client->entitydatabase4);
1078         if (host_client->entitydatabase5)
1079                 EntityFrame5_FreeDatabase(host_client->entitydatabase5);
1080
1081         if (sv.active)
1082         {
1083                 // clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
1084                 PRVM_ED_ClearEdict(prog, host_client->edict);
1085         }
1086
1087         // clear the client struct (this sets active to false)
1088         memset(host_client, 0, sizeof(*host_client));
1089
1090         // update server listing on the master because player count changed
1091         // (which the master uses for filtering empty/full servers)
1092         NetConn_Heartbeat(1);
1093
1094         if (sv.loadgame)
1095         {
1096                 for (i = 0;i < svs.maxclients;i++)
1097                         if (svs.clients[i].active && !svs.clients[i].spawned)
1098                                 break;
1099                 if (i == svs.maxclients)
1100                 {
1101                         Con_Printf("Loaded game, everyone rejoined - unpausing\n");
1102                         sv.paused = sv.loadgame = false; // we're basically done with loading now
1103                 }
1104         }
1105 }
1106
1107 static void SV_StartDownload_f(cmd_state_t *cmd)
1108 {
1109         if (host_client->download_file)
1110                 host_client->download_started = true;
1111 }
1112
1113 /*
1114  * Compression extension negotiation:
1115  *
1116  * Server to client:
1117  *   cl_serverextension_download 2
1118  *
1119  * Client to server:
1120  *   download <filename> <list of zero or more suppported compressions in order of preference>
1121  * e.g.
1122  *   download maps/map1.bsp lzo deflate huffman
1123  *
1124  * Server to client:
1125  *   cl_downloadbegin <compressed size> <filename> <compression method actually used>
1126  * e.g.
1127  *   cl_downloadbegin 123456 maps/map1.bsp deflate
1128  *
1129  * The server may choose not to compress the file by sending no compression name, like:
1130  *   cl_downloadbegin 345678 maps/map1.bsp
1131  *
1132  * NOTE: the "download" command may only specify compression algorithms if
1133  *       cl_serverextension_download is 2!
1134  *       If cl_serverextension_download has a different value, the client must
1135  *       assume this extension is not supported!
1136  */
1137
1138 static void Download_CheckExtensions(cmd_state_t *cmd)
1139 {
1140         int i;
1141         int argc = Cmd_Argc(cmd);
1142
1143         // first reset them all
1144         host_client->download_deflate = false;
1145
1146         for(i = 2; i < argc; ++i)
1147         {
1148                 if(!strcmp(Cmd_Argv(cmd, i), "deflate"))
1149                 {
1150                         host_client->download_deflate = true;
1151                         break;
1152                 }
1153         }
1154 }
1155
1156 static void SV_Download_f(cmd_state_t *cmd)
1157 {
1158         const char *whichpack, *whichpack2, *extension;
1159         qbool is_csqc; // so we need to check only once
1160
1161         if (Cmd_Argc(cmd) < 2)
1162         {
1163                 SV_ClientPrintf("usage: download <filename> {<extensions>}*\n");
1164                 SV_ClientPrintf("       supported extensions: deflate\n");
1165                 return;
1166         }
1167
1168         if (FS_CheckNastyPath(Cmd_Argv(cmd, 1), false))
1169         {
1170                 SV_ClientPrintf("Download rejected: nasty filename \"%s\"\n", Cmd_Argv(cmd, 1));
1171                 return;
1172         }
1173
1174         if (host_client->download_file)
1175         {
1176                 // at this point we'll assume the previous download should be aborted
1177                 Con_DPrintf("Download of %s aborted by %s starting a new download\n", host_client->download_name, host_client->name);
1178                 SV_ClientCommands("\nstopdownload\n");
1179
1180                 // close the file and reset variables
1181                 FS_Close(host_client->download_file);
1182                 host_client->download_file = NULL;
1183                 host_client->download_name[0] = 0;
1184                 host_client->download_expectedposition = 0;
1185                 host_client->download_started = false;
1186         }
1187
1188         is_csqc = (sv.csqc_progname[0] && strcmp(Cmd_Argv(cmd, 1), sv.csqc_progname) == 0);
1189
1190         if (!sv_allowdownloads.integer && !is_csqc)
1191         {
1192                 SV_ClientPrintf("Downloads are disabled on this server\n");
1193                 SV_ClientCommands("\nstopdownload\n");
1194                 return;
1195         }
1196
1197         Download_CheckExtensions(cmd);
1198
1199         strlcpy(host_client->download_name, Cmd_Argv(cmd, 1), sizeof(host_client->download_name));
1200         extension = FS_FileExtension(host_client->download_name);
1201
1202         // host_client is asking to download a specified file
1203         if (developer_extra.integer)
1204                 Con_DPrintf("Download request for %s by %s\n", host_client->download_name, host_client->name);
1205
1206         if(is_csqc)
1207         {
1208                 char extensions[MAX_QPATH]; // make sure this can hold all extensions
1209                 extensions[0] = '\0';
1210
1211                 if(host_client->download_deflate)
1212                         strlcat(extensions, " deflate", sizeof(extensions));
1213
1214                 Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
1215
1216                 if(host_client->download_deflate && svs.csqc_progdata_deflated)
1217                         host_client->download_file = FS_FileFromData(svs.csqc_progdata_deflated, svs.csqc_progsize_deflated, true);
1218                 else
1219                         host_client->download_file = FS_FileFromData(svs.csqc_progdata, sv.csqc_progsize, true);
1220
1221                 // no, no space is needed between %s and %s :P
1222                 SV_ClientCommands("\ncl_downloadbegin %i %s%s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name, extensions);
1223
1224                 host_client->download_expectedposition = 0;
1225                 host_client->download_started = false;
1226                 host_client->sendsignon = true; // make sure this message is sent
1227                 return;
1228         }
1229
1230         if (!FS_FileExists(host_client->download_name))
1231         {
1232                 SV_ClientPrintf("Download rejected: server does not have the file \"%s\"\nYou may need to separately download or purchase the data archives for this game/mod to get this file\n", host_client->download_name);
1233                 SV_ClientCommands("\nstopdownload\n");
1234                 return;
1235         }
1236
1237         // check if the user is trying to download part of registered Quake(r)
1238         whichpack = FS_WhichPack(host_client->download_name);
1239         whichpack2 = FS_WhichPack("gfx/pop.lmp");
1240         if ((whichpack && whichpack2 && !strcasecmp(whichpack, whichpack2)) || FS_IsRegisteredQuakePack(host_client->download_name))
1241         {
1242                 SV_ClientPrintf("Download rejected: file \"%s\" is part of registered Quake(r)\nYou must purchase Quake(r) from id Software or a retailer to get this file\nPlease go to http://www.idsoftware.com/games/quake/quake/index.php?game_section=buy\n", host_client->download_name);
1243                 SV_ClientCommands("\nstopdownload\n");
1244                 return;
1245         }
1246
1247         // check if the server has forbidden archive downloads entirely
1248         if (!sv_allowdownloads_inarchive.integer)
1249         {
1250                 whichpack = FS_WhichPack(host_client->download_name);
1251                 if (whichpack)
1252                 {
1253                         SV_ClientPrintf("Download rejected: file \"%s\" is in an archive (\"%s\")\nYou must separately download or purchase the data archives for this game/mod to get this file\n", host_client->download_name, whichpack);
1254                         SV_ClientCommands("\nstopdownload\n");
1255                         return;
1256                 }
1257         }
1258
1259         if (!sv_allowdownloads_config.integer)
1260         {
1261                 if (!strcasecmp(extension, "cfg"))
1262                 {
1263                         SV_ClientPrintf("Download rejected: file \"%s\" is a .cfg file which is forbidden for security reasons\nYou must separately download or purchase the data archives for this game/mod to get this file\n", host_client->download_name);
1264                         SV_ClientCommands("\nstopdownload\n");
1265                         return;
1266                 }
1267         }
1268
1269         if (!sv_allowdownloads_dlcache.integer)
1270         {
1271                 if (!strncasecmp(host_client->download_name, "dlcache/", 8))
1272                 {
1273                         SV_ClientPrintf("Download rejected: file \"%s\" is in the dlcache/ directory which is forbidden for security reasons\nYou must separately download or purchase the data archives for this game/mod to get this file\n", host_client->download_name);
1274                         SV_ClientCommands("\nstopdownload\n");
1275                         return;
1276                 }
1277         }
1278
1279         if (!sv_allowdownloads_archive.integer)
1280         {
1281                 if (!strcasecmp(extension, "pak") || !strcasecmp(extension, "pk3"))
1282                 {
1283                         SV_ClientPrintf("Download rejected: file \"%s\" is an archive\nYou must separately download or purchase the data archives for this game/mod to get this file\n", host_client->download_name);
1284                         SV_ClientCommands("\nstopdownload\n");
1285                         return;
1286                 }
1287         }
1288
1289         host_client->download_file = FS_OpenVirtualFile(host_client->download_name, true);
1290         if (!host_client->download_file)
1291         {
1292                 SV_ClientPrintf("Download rejected: server could not open the file \"%s\"\n", host_client->download_name);
1293                 SV_ClientCommands("\nstopdownload\n");
1294                 return;
1295         }
1296
1297         if (FS_FileSize(host_client->download_file) > 1<<30)
1298         {
1299                 SV_ClientPrintf("Download rejected: file \"%s\" is very large\n", host_client->download_name);
1300                 SV_ClientCommands("\nstopdownload\n");
1301                 FS_Close(host_client->download_file);
1302                 host_client->download_file = NULL;
1303                 return;
1304         }
1305
1306         if (FS_FileSize(host_client->download_file) < 0)
1307         {
1308                 SV_ClientPrintf("Download rejected: file \"%s\" is not a regular file\n", host_client->download_name);
1309                 SV_ClientCommands("\nstopdownload\n");
1310                 FS_Close(host_client->download_file);
1311                 host_client->download_file = NULL;
1312                 return;
1313         }
1314
1315         Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
1316
1317         /*
1318          * we can only do this if we would actually deflate on the fly
1319          * which we do not (yet)!
1320         {
1321                 char extensions[MAX_QPATH]; // make sure this can hold all extensions
1322                 extensions[0] = '\0';
1323
1324                 if(host_client->download_deflate)
1325                         strlcat(extensions, " deflate", sizeof(extensions));
1326
1327                 // no, no space is needed between %s and %s :P
1328                 SV_ClientCommands("\ncl_downloadbegin %i %s%s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name, extensions);
1329         }
1330         */
1331         SV_ClientCommands("\ncl_downloadbegin %i %s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name);
1332
1333         host_client->download_expectedposition = 0;
1334         host_client->download_started = false;
1335         host_client->sendsignon = true; // make sure this message is sent
1336
1337         // the rest of the download process is handled in SV_SendClientDatagram
1338         // and other code dealing with svc_downloaddata and clc_ackdownloaddata
1339         //
1340         // no svc_downloaddata messages will be sent until sv_startdownload is
1341         // sent by the client
1342 }
1343
1344 /*
1345 ==============================================================================
1346
1347 SERVER SPAWNING
1348
1349 ==============================================================================
1350 */
1351
1352 /*
1353 ================
1354 SV_ModelIndex
1355
1356 ================
1357 */
1358 int SV_ModelIndex(const char *s, int precachemode)
1359 {
1360         int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_MODELS);
1361         char filename[MAX_QPATH];
1362         if (!s || !*s)
1363                 return 0;
1364         // testing
1365         //if (precachemode == 2)
1366         //      return 0;
1367         strlcpy(filename, s, sizeof(filename));
1368         for (i = 2;i < limit;i++)
1369         {
1370                 if (!sv.model_precache[i][0])
1371                 {
1372                         if (precachemode)
1373                         {
1374                                 if (sv.state != ss_loading && (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 || sv.protocol == PROTOCOL_DARKPLACES5))
1375                                 {
1376                                         Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
1377                                         return 0;
1378                                 }
1379                                 if (precachemode == 1)
1380                                         Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
1381                                 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
1382                                 if (sv.state == ss_loading)
1383                                 {
1384                                         // running from SV_SpawnServer which is launched from the client console command interpreter
1385                                         sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.worldname : NULL);
1386                                 }
1387                                 else
1388                                 {
1389                                         if (svs.threaded)
1390                                         {
1391                                                 // 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
1392                                                 sv.models[i] = Mod_FindName (sv.model_precache[i], s[0] == '*' ? sv.worldname : NULL);
1393                                         }
1394                                         else
1395                                         {
1396                                                 // running single threaded, so we can load the model here
1397                                                 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.worldname : NULL);
1398                                         }
1399                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
1400                                         MSG_WriteShort(&sv.reliable_datagram, i);
1401                                         MSG_WriteString(&sv.reliable_datagram, filename);
1402                                 }
1403                                 return i;
1404                         }
1405                         Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
1406                         return 0;
1407                 }
1408                 if (!strcmp(sv.model_precache[i], filename))
1409                         return i;
1410         }
1411         Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
1412         return 0;
1413 }
1414
1415 /*
1416 ================
1417 SV_SoundIndex
1418
1419 ================
1420 */
1421 int SV_SoundIndex(const char *s, int precachemode)
1422 {
1423         int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP) ? 256 : MAX_SOUNDS);
1424         char filename[MAX_QPATH];
1425         if (!s || !*s)
1426                 return 0;
1427         // testing
1428         //if (precachemode == 2)
1429         //      return 0;
1430         strlcpy(filename, s, sizeof(filename));
1431         for (i = 1;i < limit;i++)
1432         {
1433                 if (!sv.sound_precache[i][0])
1434                 {
1435                         if (precachemode)
1436                         {
1437                                 if (sv.state != ss_loading && (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 || sv.protocol == PROTOCOL_DARKPLACES5))
1438                                 {
1439                                         Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
1440                                         return 0;
1441                                 }
1442                                 if (precachemode == 1)
1443                                         Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
1444                                 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
1445                                 if (sv.state != ss_loading)
1446                                 {
1447                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
1448                                         MSG_WriteShort(&sv.reliable_datagram, i + 32768);
1449                                         MSG_WriteString(&sv.reliable_datagram, filename);
1450                                 }
1451                                 return i;
1452                         }
1453                         Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
1454                         return 0;
1455                 }
1456                 if (!strcmp(sv.sound_precache[i], filename))
1457                         return i;
1458         }
1459         Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
1460         return 0;
1461 }
1462
1463 /*
1464 ================
1465 SV_ParticleEffectIndex
1466
1467 ================
1468 */
1469 int SV_ParticleEffectIndex(const char *name)
1470 {
1471         int i, argc, linenumber, effectnameindex;
1472         int filepass;
1473         fs_offset_t filesize;
1474         unsigned char *filedata;
1475         const char *text;
1476         const char *textstart;
1477         //const char *textend;
1478         char argv[16][1024];
1479         char filename[MAX_QPATH];
1480         if (!sv.particleeffectnamesloaded)
1481         {
1482                 sv.particleeffectnamesloaded = true;
1483                 memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
1484                 for (i = 0;i < EFFECT_TOTAL;i++)
1485                         strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
1486                 for (filepass = 0;;filepass++)
1487                 {
1488                         if (filepass == 0)
1489                                 dpsnprintf(filename, sizeof(filename), "effectinfo.txt");
1490                         else if (filepass == 1)
1491                                 dpsnprintf(filename, sizeof(filename), "%s_effectinfo.txt", sv.worldnamenoextension);
1492                         else
1493                                 break;
1494                         filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
1495                         if (!filedata)
1496                                 continue;
1497                         textstart = (const char *)filedata;
1498                         //textend = (const char *)filedata + filesize;
1499                         text = textstart;
1500                         for (linenumber = 1;;linenumber++)
1501                         {
1502                                 argc = 0;
1503                                 for (;;)
1504                                 {
1505                                         if (!COM_ParseToken_Simple(&text, true, false, true) || !strcmp(com_token, "\n"))
1506                                                 break;
1507                                         if (argc < 16)
1508                                         {
1509                                                 strlcpy(argv[argc], com_token, sizeof(argv[argc]));
1510                                                 argc++;
1511                                         }
1512                                 }
1513                                 if (com_token[0] == 0)
1514                                         break; // if the loop exited and it's not a \n, it's EOF
1515                                 if (argc < 1)
1516                                         continue;
1517                                 if (!strcmp(argv[0], "effect"))
1518                                 {
1519                                         if (argc == 2)
1520                                         {
1521                                                 for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME;effectnameindex++)
1522                                                 {
1523                                                         if (sv.particleeffectname[effectnameindex][0])
1524                                                         {
1525                                                                 if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
1526                                                                         break;
1527                                                         }
1528                                                         else
1529                                                         {
1530                                                                 strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
1531                                                                 break;
1532                                                         }
1533                                                 }
1534                                                 // if we run out of names, abort
1535                                                 if (effectnameindex == MAX_PARTICLEEFFECTNAME)
1536                                                 {
1537                                                         Con_Printf("%s:%i: too many effects!\n", filename, linenumber);
1538                                                         break;
1539                                                 }
1540                                         }
1541                                 }
1542                         }
1543                         Mem_Free(filedata);
1544                 }
1545         }
1546         // search for the name
1547         for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
1548                 if (!strcmp(sv.particleeffectname[effectnameindex], name))
1549                         return effectnameindex;
1550         // return 0 if we couldn't find it
1551         return 0;
1552 }
1553
1554 model_t *SV_GetModelByIndex(int modelindex)
1555 {
1556         return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
1557 }
1558
1559 model_t *SV_GetModelFromEdict(prvm_edict_t *ed)
1560 {
1561         prvm_prog_t *prog = SVVM_prog;
1562         int modelindex;
1563         if (!ed || ed->priv.server->free)
1564                 return NULL;
1565         modelindex = (int)PRVM_serveredictfloat(ed, modelindex);
1566         return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
1567 }
1568
1569 /*
1570 ================
1571 SV_CreateBaseline
1572
1573 ================
1574 */
1575 static void SV_CreateBaseline (void)
1576 {
1577         prvm_prog_t *prog = SVVM_prog;
1578         int i, entnum, large;
1579         prvm_edict_t *svent;
1580
1581         // LadyHavoc: clear *all* baselines (not just active ones)
1582         for (entnum = 0;entnum < prog->max_edicts;entnum++)
1583         {
1584                 // get the current server version
1585                 svent = PRVM_EDICT_NUM(entnum);
1586
1587                 // LadyHavoc: always clear state values, whether the entity is in use or not
1588                 svent->priv.server->baseline = defaultstate;
1589
1590                 if (svent->priv.server->free)
1591                         continue;
1592                 if (entnum > svs.maxclients && !PRVM_serveredictfloat(svent, modelindex))
1593                         continue;
1594
1595                 // create entity baseline
1596                 VectorCopy (PRVM_serveredictvector(svent, origin), svent->priv.server->baseline.origin);
1597                 VectorCopy (PRVM_serveredictvector(svent, angles), svent->priv.server->baseline.angles);
1598                 svent->priv.server->baseline.frame = (int)PRVM_serveredictfloat(svent, frame);
1599                 svent->priv.server->baseline.skin = (int)PRVM_serveredictfloat(svent, skin);
1600                 if (entnum > 0 && entnum <= svs.maxclients)
1601                 {
1602                         svent->priv.server->baseline.colormap = entnum;
1603                         svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
1604                 }
1605                 else
1606                 {
1607                         svent->priv.server->baseline.colormap = 0;
1608                         svent->priv.server->baseline.modelindex = (int)PRVM_serveredictfloat(svent, modelindex);
1609                 }
1610
1611                 large = false;
1612                 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
1613                 {
1614                         large = true;
1615                         if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1616                                 large = false;
1617                 }
1618
1619                 // add to the message
1620                 if (large)
1621                         MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
1622                 else
1623                         MSG_WriteByte (&sv.signon, svc_spawnbaseline);
1624                 MSG_WriteShort (&sv.signon, entnum);
1625
1626                 if (large)
1627                 {
1628                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
1629                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
1630                 }
1631                 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1632                 {
1633                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
1634                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
1635                 }
1636                 else
1637                 {
1638                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
1639                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
1640                 }
1641                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
1642                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
1643                 for (i=0 ; i<3 ; i++)
1644                 {
1645                         MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
1646                         MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
1647                 }
1648         }
1649 }
1650
1651 /*
1652 ================
1653 SV_Prepare_CSQC
1654
1655 Load csprogs.dat and comperss it so it doesn't need to be
1656 reloaded on request.
1657 ================
1658 */
1659 static void SV_Prepare_CSQC(void)
1660 {
1661         fs_offset_t progsize;
1662
1663         if(svs.csqc_progdata)
1664         {
1665                 Con_DPrintf("Unloading old CSQC data.\n");
1666                 Mem_Free(svs.csqc_progdata);
1667                 if(svs.csqc_progdata_deflated)
1668                         Mem_Free(svs.csqc_progdata_deflated);
1669         }
1670
1671         svs.csqc_progdata = NULL;
1672         svs.csqc_progdata_deflated = NULL;
1673
1674         sv.csqc_progname[0] = 0;
1675         svs.csqc_progdata = FS_LoadFile(csqc_progname.string, sv_mempool, false, &progsize);
1676
1677         if(progsize > 0)
1678         {
1679                 size_t deflated_size;
1680
1681                 sv.csqc_progsize = (int)progsize;
1682                 sv.csqc_progcrc = CRC_Block(svs.csqc_progdata, progsize);
1683                 strlcpy(sv.csqc_progname, csqc_progname.string, sizeof(sv.csqc_progname));
1684                 Con_DPrintf("server detected csqc progs file \"%s\" with size %i and crc %i\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
1685
1686                 Con_DPrint("Compressing csprogs.dat\n");
1687                 //unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool);
1688                 svs.csqc_progdata_deflated = FS_Deflate(svs.csqc_progdata, progsize, &deflated_size, -1, sv_mempool);
1689                 svs.csqc_progsize_deflated = (int)deflated_size;
1690                 if(svs.csqc_progdata_deflated)
1691                 {
1692                         Con_DPrintf("Deflated: %g%%\n", 100.0 - 100.0 * (deflated_size / (float)progsize));
1693                         Con_DPrintf("Uncompressed: %u\nCompressed:   %u\n", (unsigned)sv.csqc_progsize, (unsigned)svs.csqc_progsize_deflated);
1694                 }
1695                 else
1696                         Con_DPrintf("Cannot compress - need zlib for this. Using uncompressed progs only.\n");
1697         }
1698 }
1699
1700 /*
1701 ================
1702 SV_SaveSpawnparms
1703
1704 Grabs the current state of each client for saving across the
1705 transition to another level
1706 ================
1707 */
1708 void SV_SaveSpawnparms (void)
1709 {
1710         prvm_prog_t *prog = SVVM_prog;
1711         int             i, j;
1712
1713         svs.serverflags = (int)PRVM_serverglobalfloat(serverflags);
1714
1715         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1716         {
1717                 if (!host_client->active)
1718                         continue;
1719
1720         // call the progs to get default spawn parms for the new client
1721                 PRVM_serverglobalfloat(time) = sv.time;
1722                 PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
1723                 prog->ExecuteProgram(prog, PRVM_serverfunction(SetChangeParms), "QC function SetChangeParms is missing");
1724                 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
1725                         host_client->spawn_parms[j] = (&PRVM_serverglobalfloat(parm1))[j];
1726         }
1727 }
1728
1729 // Returns 1 if we're singleplayer, > 1 if we're a listen server
1730 int SV_IsLocalServer(void)
1731 {
1732         return (host_isclient.integer && sv.active ? svs.maxclients : 0);
1733 }
1734
1735 /*
1736 ================
1737 SV_SpawnServer
1738
1739 This is called at the start of each level
1740 ================
1741 */
1742
1743 void SV_SpawnServer (const char *map)
1744 {
1745         prvm_prog_t *prog = SVVM_prog;
1746         prvm_edict_t *ent;
1747         int i;
1748         char *entities;
1749         model_t *worldmodel;
1750         char modelname[sizeof(sv.worldname)];
1751         char vabuf[1024];
1752
1753         Con_Printf("SpawnServer: %s\n", map);
1754
1755         dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", map);
1756
1757         if (!FS_FileExists(modelname))
1758         {
1759                 dpsnprintf (modelname, sizeof(modelname), "maps/%s", map);
1760                 if (!FS_FileExists(modelname))
1761                 {
1762                         Con_Printf("SpawnServer: no map file named %s\n", modelname);
1763                         return;
1764                 }
1765         }
1766
1767 //      SV_LockThreadMutex();
1768
1769         if(!host_isclient.integer)
1770                 Sys_MakeProcessNice();
1771         else
1772         {
1773                 SCR_BeginLoadingPlaque(false);
1774                 S_StopAllSounds();
1775         }
1776
1777         if(sv.active)
1778         {
1779                 World_End(&sv.world);
1780                 if(PRVM_serverfunction(SV_Shutdown))
1781                 {
1782                         func_t s = PRVM_serverfunction(SV_Shutdown);
1783                         PRVM_serverglobalfloat(time) = sv.time;
1784                         PRVM_serverfunction(SV_Shutdown) = 0; // prevent it from getting called again
1785                         prog->ExecuteProgram(prog, s,"SV_Shutdown() required");
1786                 }
1787         }
1788
1789         // free q3 shaders so that any newly downloaded shaders will be active
1790         Mod_FreeQ3Shaders();
1791
1792         worldmodel = Mod_ForName(modelname, false, developer.integer > 0, NULL);
1793         if (!worldmodel || !worldmodel->TraceBox)
1794         {
1795                 Con_Printf("Couldn't load map %s\n", modelname);
1796
1797                 if(!host_isclient.integer)
1798                         Sys_MakeProcessMean();
1799
1800 //              SV_UnlockThreadMutex();
1801
1802                 return;
1803         }
1804
1805         Collision_Cache_Reset(true);
1806
1807         // let's not have any servers with no name
1808         if (hostname.string[0] == 0)
1809                 Cvar_SetQuick(&hostname, "UNNAMED");
1810         scr_centertime_off = 0;
1811
1812         svs.changelevel_issued = false;         // now safe to issue another
1813
1814         // make the map a required file for clients
1815         Curl_ClearRequirements();
1816         Curl_RequireFile(modelname);
1817
1818 //
1819 // tell all connected clients that we are going to a new level
1820 //
1821         if (sv.active)
1822         {
1823                 client_t *client;
1824                 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1825                 {
1826                         if (client->netconnection)
1827                         {
1828                                 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
1829                                 MSG_WriteString(&client->netconnection->message, "reconnect\n");
1830                         }
1831                 }
1832         }
1833         else
1834         {
1835                 // open server port
1836                 NetConn_OpenServerPorts(true);
1837         }
1838
1839 //
1840 // make cvars consistant
1841 //
1842         if (coop.integer)
1843                 Cvar_SetValueQuick(&deathmatch, 0);
1844         // LadyHavoc: it can be useful to have skills outside the range 0-3...
1845         //current_skill = bound(0, (int)(skill.value + 0.5), 3);
1846         //Cvar_SetValue ("skill", (float)current_skill);
1847         current_skill = (int)(skill.value + 0.5);
1848
1849 //
1850 // set up the new server
1851 //
1852         memset (&sv, 0, sizeof(sv));
1853         // if running a local client, make sure it doesn't try to access the last
1854         // level's data which is no longer valiud
1855         cls.signon = 0;
1856
1857         Cvar_SetValueQuick(&halflifebsp, worldmodel->brush.ishlbsp);
1858         Cvar_SetValueQuick(&sv_mapformat_is_quake2, worldmodel->brush.isq2bsp);
1859         Cvar_SetValueQuick(&sv_mapformat_is_quake3, worldmodel->brush.isq3bsp);
1860
1861         if(*sv_random_seed.string)
1862         {
1863                 srand(sv_random_seed.integer);
1864                 Con_Printf(CON_WARN "NOTE: random seed is %d; use for debugging/benchmarking only!\nUnset sv_random_seed to get real random numbers again.\n", sv_random_seed.integer);
1865         }
1866
1867         SV_VM_Setup();
1868
1869         sv.active = true;
1870
1871         // set level base name variables for later use
1872         strlcpy (sv.name, map, sizeof (sv.name));
1873         strlcpy(sv.worldname, modelname, sizeof(sv.worldname));
1874         FS_StripExtension(sv.worldname, sv.worldnamenoextension, sizeof(sv.worldnamenoextension));
1875         strlcpy(sv.worldbasename, !strncmp(sv.worldnamenoextension, "maps/", 5) ? sv.worldnamenoextension + 5 : sv.worldnamenoextension, sizeof(sv.worldbasename));
1876         //Cvar_SetQuick(&sv_worldmessage, sv.worldmessage); // set later after QC is spawned
1877         Cvar_SetQuick(&sv_worldname, sv.worldname);
1878         Cvar_SetQuick(&sv_worldnamenoextension, sv.worldnamenoextension);
1879         Cvar_SetQuick(&sv_worldbasename, sv.worldbasename);
1880
1881         sv.protocol = Protocol_EnumForName(sv_protocolname.string);
1882         if (sv.protocol == PROTOCOL_UNKNOWN)
1883         {
1884                 char buffer[1024];
1885                 Protocol_Names(buffer, sizeof(buffer));
1886                 Con_Printf(CON_ERROR "Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
1887                 sv.protocol = PROTOCOL_QUAKE;
1888         }
1889
1890 // load progs to get entity field count
1891         //PR_LoadProgs ( sv_progs.string );
1892
1893         sv.datagram.maxsize = sizeof(sv.datagram_buf);
1894         sv.datagram.cursize = 0;
1895         sv.datagram.data = sv.datagram_buf;
1896
1897         sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
1898         sv.reliable_datagram.cursize = 0;
1899         sv.reliable_datagram.data = sv.reliable_datagram_buf;
1900
1901         sv.signon.maxsize = sizeof(sv.signon_buf);
1902         sv.signon.cursize = 0;
1903         sv.signon.data = sv.signon_buf;
1904
1905 // leave slots at start for clients only
1906         //prog->num_edicts = svs.maxclients+1;
1907
1908         sv.state = ss_loading;
1909         prog->allowworldwrites = true;
1910         sv.paused = false;
1911
1912         sv.time = 1.0;
1913
1914         Mod_ClearUsed();
1915         worldmodel->used = true;
1916
1917         sv.worldmodel = worldmodel;
1918         sv.models[1] = sv.worldmodel;
1919
1920 //
1921 // clear world interaction links
1922 //
1923         World_SetSize(&sv.world, sv.worldname, sv.worldmodel->normalmins, sv.worldmodel->normalmaxs, prog);
1924         World_Start(&sv.world);
1925
1926         strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
1927
1928         strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
1929         strlcpy(sv.model_precache[1], sv.worldname, sizeof(sv.model_precache[1]));
1930         for (i = 1;i < sv.worldmodel->brush.numsubmodels && i+1 < MAX_MODELS;i++)
1931         {
1932                 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
1933                 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, sv.worldname);
1934         }
1935         if(i < sv.worldmodel->brush.numsubmodels)
1936                 Con_Printf("Too many submodels (MAX_MODELS is %i)\n", MAX_MODELS);
1937
1938 //
1939 // load the rest of the entities
1940 //
1941         // AK possible hack since num_edicts is still 0
1942         ent = PRVM_EDICT_NUM(0);
1943         memset (ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
1944         ent->priv.server->free = false;
1945         PRVM_serveredictstring(ent, model) = PRVM_SetEngineString(prog, sv.worldname);
1946         PRVM_serveredictfloat(ent, modelindex) = 1;             // world model
1947         PRVM_serveredictfloat(ent, solid) = SOLID_BSP;
1948         PRVM_serveredictfloat(ent, movetype) = MOVETYPE_PUSH;
1949         VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, mins));
1950         VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, maxs));
1951         VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, absmin));
1952         VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, absmax));
1953
1954         if (coop.value)
1955                 PRVM_serverglobalfloat(coop) = coop.integer;
1956         else
1957                 PRVM_serverglobalfloat(deathmatch) = deathmatch.integer;
1958
1959         PRVM_serverglobalstring(mapname) = PRVM_SetEngineString(prog, sv.name);
1960
1961 // serverflags are for cross level information (sigils)
1962         PRVM_serverglobalfloat(serverflags) = svs.serverflags;
1963
1964         // we need to reset the spawned flag on all connected clients here so that
1965         // their thinks don't run during startup (before PutClientInServer)
1966         // we also need to set up the client entities now
1967         // and we need to set the ->edict pointers to point into the progs edicts
1968         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1969         {
1970                 host_client->begun = false;
1971                 host_client->edict = PRVM_EDICT_NUM(i + 1);
1972                 PRVM_ED_ClearEdict(prog, host_client->edict);
1973         }
1974
1975         // load replacement entity file if found
1976         if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va(vabuf, sizeof(vabuf), "%s.ent", sv.worldnamenoextension), tempmempool, true, NULL)))
1977         {
1978                 Con_Printf("Loaded %s.ent\n", sv.worldnamenoextension);
1979                 PRVM_ED_LoadFromFile(prog, entities);
1980                 Mem_Free(entities);
1981         }
1982         else
1983                 PRVM_ED_LoadFromFile(prog, sv.worldmodel->brush.entities);
1984
1985
1986         // LadyHavoc: clear world angles (to fix e3m3.bsp)
1987         VectorClear(PRVM_serveredictvector(prog->edicts, angles));
1988
1989 // all setup is completed, any further precache statements are errors
1990 //      sv.state = ss_active; // LadyHavoc: workaround for svc_precache bug
1991         prog->allowworldwrites = false;
1992
1993 // run two frames to allow everything to settle
1994         sv.time = 1.0001;
1995         for (i = 0;i < sv_init_frame_count.integer;i++)
1996         {
1997                 sv.frametime = 0.1;
1998                 SV_Physics ();
1999         }
2000
2001         // Once all init frames have been run, we consider svqc code fully initialized.
2002         prog->inittime = host.realtime;
2003
2004         if(!host_isclient.integer)
2005                 Mod_PurgeUnused();
2006
2007 // create a baseline for more efficient communications
2008         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)
2009                 SV_CreateBaseline ();
2010
2011         sv.state = ss_active; // LadyHavoc: workaround for svc_precache bug
2012
2013 // send serverinfo to all connected clients, and set up botclients coming back from a level change
2014         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2015         {
2016                 host_client->clientconnectcalled = false; // do NOT call ClientDisconnect if he drops before ClientConnect!
2017                 if (!host_client->active)
2018                         continue;
2019                 if (host_client->netconnection)
2020                         SV_SendServerinfo(host_client);
2021                 else
2022                 {
2023                         int j;
2024                         // if client is a botclient coming from a level change, we need to
2025                         // set up client info that normally requires networking
2026
2027                         // copy spawn parms out of the client_t
2028                         for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
2029                                 (&PRVM_serverglobalfloat(parm1))[j] = host_client->spawn_parms[j];
2030
2031                         // call the spawn function
2032                         host_client->clientconnectcalled = true;
2033                         PRVM_serverglobalfloat(time) = sv.time;
2034                         PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
2035                         prog->ExecuteProgram(prog, PRVM_serverfunction(ClientConnect), "QC function ClientConnect is missing");
2036                         prog->ExecuteProgram(prog, PRVM_serverfunction(PutClientInServer), "QC function PutClientInServer is missing");
2037                         host_client->begun = true;
2038                 }
2039         }
2040
2041         // update the map title cvar
2042         strlcpy(sv.worldmessage, PRVM_GetString(prog, PRVM_serveredictstring(prog->edicts, message)), sizeof(sv.worldmessage)); // map title (not related to filename)
2043         Cvar_SetQuick(&sv_worldmessage, sv.worldmessage);
2044
2045         Con_Printf("Server spawned.\n");
2046         NetConn_Heartbeat (2);
2047
2048         if(!host_isclient.integer)
2049                 Sys_MakeProcessMean();
2050
2051 //      SV_UnlockThreadMutex();
2052 }
2053
2054 /*
2055 ==================
2056 SV_Shutdown
2057
2058 This only happens at the end of a game, not between levels
2059 ==================
2060 */
2061 void SV_Shutdown(void)
2062 {
2063         prvm_prog_t *prog = SVVM_prog;
2064         int i;
2065
2066         SV_LockThreadMutex();
2067
2068         if (!sv.active)
2069                 goto end;
2070
2071         Con_DPrintf("SV_Shutdown\n");
2072
2073         NetConn_Heartbeat(2);
2074         NetConn_Heartbeat(2);
2075
2076 // make sure all the clients know we're disconnecting
2077         World_End(&sv.world);
2078         if(prog->loaded)
2079         {
2080                 if(PRVM_serverfunction(SV_Shutdown))
2081                 {
2082                         func_t s = PRVM_serverfunction(SV_Shutdown);
2083                         PRVM_serverglobalfloat(time) = sv.time;
2084                         PRVM_serverfunction(SV_Shutdown) = 0; // prevent it from getting called again
2085                         prog->ExecuteProgram(prog, s,"SV_Shutdown() required");
2086                 }
2087         }
2088         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2089                 if (host_client->active)
2090                         SV_DropClient(false); // server shutdown
2091
2092         NetConn_CloseServerPorts();
2093
2094         sv.active = false;
2095 //
2096 // clear structures
2097 //
2098         memset(&sv, 0, sizeof(sv));
2099         memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
2100 end:
2101         SV_UnlockThreadMutex();
2102 }
2103
2104 /////////////////////////////////////////////////////
2105 // SV VM stuff
2106
2107 static void SVVM_begin_increase_edicts(prvm_prog_t *prog)
2108 {
2109         // links don't survive the transition, so unlink everything
2110         World_UnlinkAll(&sv.world);
2111 }
2112
2113 static void SVVM_end_increase_edicts(prvm_prog_t *prog)
2114 {
2115         int i;
2116         prvm_edict_t *ent;
2117
2118         // link every entity except world
2119         for (i = 1, ent = prog->edicts;i < prog->num_edicts;i++, ent++)
2120                 if (!ent->priv.server->free && !VectorCompare(PRVM_serveredictvector(ent, absmin), PRVM_serveredictvector(ent, absmax)))
2121                         SV_LinkEdict(ent);
2122 }
2123
2124 static void SVVM_init_edict(prvm_prog_t *prog, prvm_edict_t *e)
2125 {
2126         // LadyHavoc: for consistency set these here
2127         int num = PRVM_NUM_FOR_EDICT(e) - 1;
2128
2129         e->priv.server->move = false; // don't move on first frame
2130
2131         if (num >= 0 && num < svs.maxclients)
2132         {
2133                 // set colormap and team on newly created player entity
2134                 PRVM_serveredictfloat(e, colormap) = num + 1;
2135                 PRVM_serveredictfloat(e, team) = (svs.clients[num].colors & 15) + 1;
2136                 // set netname/clientcolors back to client values so that
2137                 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
2138                 // reset them
2139                 PRVM_serveredictstring(e, netname) = PRVM_SetEngineString(prog, svs.clients[num].name);
2140                 PRVM_serveredictfloat(e, clientcolors) = svs.clients[num].colors;
2141                 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
2142                 PRVM_serveredictstring(e, playermodel) = PRVM_SetEngineString(prog, svs.clients[num].playermodel);
2143                 PRVM_serveredictstring(e, playerskin) = PRVM_SetEngineString(prog, svs.clients[num].playerskin);
2144                 // Assign netaddress (IP Address, etc)
2145                 if(svs.clients[num].netconnection != NULL)
2146                 {
2147                         // Acquire Readable Address
2148                         LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
2149                         PRVM_serveredictstring(e, netaddress) = PRVM_SetEngineString(prog, svs.clients[num].netaddress);
2150                 }
2151                 else
2152                         PRVM_serveredictstring(e, netaddress) = PRVM_SetEngineString(prog, "null/botclient");
2153                 if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_idfp[0])
2154                         PRVM_serveredictstring(e, crypto_idfp) = PRVM_SetEngineString(prog, svs.clients[num].netconnection->crypto.client_idfp);
2155                 else
2156                         PRVM_serveredictstring(e, crypto_idfp) = 0;
2157                 PRVM_serveredictfloat(e, crypto_idfp_signed) = (svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_issigned);
2158                 if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_keyfp[0])
2159                         PRVM_serveredictstring(e, crypto_keyfp) = PRVM_SetEngineString(prog, svs.clients[num].netconnection->crypto.client_keyfp);
2160                 else
2161                         PRVM_serveredictstring(e, crypto_keyfp) = 0;
2162                 if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.server_keyfp[0])
2163                         PRVM_serveredictstring(e, crypto_mykeyfp) = PRVM_SetEngineString(prog, svs.clients[num].netconnection->crypto.server_keyfp);
2164                 else
2165                         PRVM_serveredictstring(e, crypto_mykeyfp) = 0;
2166                 if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.use_aes)
2167                         PRVM_serveredictstring(e, crypto_encryptmethod) = PRVM_SetEngineString(prog, "AES128");
2168                 else
2169                         PRVM_serveredictstring(e, crypto_encryptmethod) = 0;
2170                 if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated)
2171                         PRVM_serveredictstring(e, crypto_signmethod) = PRVM_SetEngineString(prog, "HMAC-SHA256");
2172                 else
2173                         PRVM_serveredictstring(e, crypto_signmethod) = 0;
2174         }
2175 }
2176
2177 static void SVVM_free_edict(prvm_prog_t *prog, prvm_edict_t *ed)
2178 {
2179         int i;
2180         int e;
2181
2182         World_UnlinkEdict(ed);          // unlink from world bsp
2183
2184         PRVM_serveredictstring(ed, model) = 0;
2185         PRVM_serveredictfloat(ed, takedamage) = 0;
2186         PRVM_serveredictfloat(ed, modelindex) = 0;
2187         PRVM_serveredictfloat(ed, colormap) = 0;
2188         PRVM_serveredictfloat(ed, skin) = 0;
2189         PRVM_serveredictfloat(ed, frame) = 0;
2190         VectorClear(PRVM_serveredictvector(ed, origin));
2191         VectorClear(PRVM_serveredictvector(ed, angles));
2192         PRVM_serveredictfloat(ed, nextthink) = -1;
2193         PRVM_serveredictfloat(ed, solid) = 0;
2194
2195         VM_RemoveEdictSkeleton(prog, ed);
2196         World_Physics_RemoveFromEntity(&sv.world, ed);
2197         World_Physics_RemoveJointFromEntity(&sv.world, ed);
2198
2199         // make sure csqc networking is aware of the removed entity
2200         e = PRVM_NUM_FOR_EDICT(ed);
2201         sv.csqcentityversion[e] = 0;
2202         for (i = 0;i < svs.maxclients;i++)
2203                 svs.clients[i].csqcentitysendflags[e] = 0xFFFFFF;
2204 }
2205
2206 static void SVVM_count_edicts(prvm_prog_t *prog)
2207 {
2208         int             i;
2209         prvm_edict_t    *ent;
2210         int             active, models, solid, step;
2211
2212         active = models = solid = step = 0;
2213         for (i=0 ; i<prog->num_edicts ; i++)
2214         {
2215                 ent = PRVM_EDICT_NUM(i);
2216                 if (ent->priv.server->free)
2217                         continue;
2218                 active++;
2219                 if (PRVM_serveredictfloat(ent, solid))
2220                         solid++;
2221                 if (PRVM_serveredictstring(ent, model))
2222                         models++;
2223                 if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP)
2224                         step++;
2225         }
2226
2227         Con_Printf("num_edicts:%3i\n", prog->num_edicts);
2228         Con_Printf("active    :%3i\n", active);
2229         Con_Printf("view      :%3i\n", models);
2230         Con_Printf("touch     :%3i\n", solid);
2231         Con_Printf("step      :%3i\n", step);
2232 }
2233
2234 static qbool SVVM_load_edict(prvm_prog_t *prog, prvm_edict_t *ent)
2235 {
2236         // remove things from different skill levels or deathmatch
2237         if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
2238         {
2239                 if (deathmatch.integer)
2240                 {
2241                         if (((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_DEATHMATCH))
2242                         {
2243                                 return false;
2244                         }
2245                 }
2246                 else if ((current_skill <= 0 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_EASY  ))
2247                         || (current_skill == 1 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_MEDIUM))
2248                         || (current_skill >= 2 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_HARD  )))
2249                 {
2250                         return false;
2251                 }
2252         }
2253         return true;
2254 }
2255
2256 static void SV_VM_Setup(void)
2257 {
2258         prvm_prog_t *prog = SVVM_prog;
2259         PRVM_Prog_Init(prog, cmd_local);
2260
2261         // allocate the mempools
2262         // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
2263         prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
2264         prog->builtins = vm_sv_builtins;
2265         prog->numbuiltins = vm_sv_numbuiltins;
2266         prog->max_edicts = 512;
2267         if (sv.protocol == PROTOCOL_QUAKE)
2268                 prog->limit_edicts = 640; // before quake mission pack 1 this was 512
2269         else if (sv.protocol == PROTOCOL_QUAKEDP)
2270                 prog->limit_edicts = 2048; // guessing
2271         else if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
2272                 prog->limit_edicts = 2048; // guessing!
2273         else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2274                 prog->limit_edicts = 4096; // guessing!
2275         else
2276                 prog->limit_edicts = MAX_EDICTS;
2277         prog->reserved_edicts = svs.maxclients;
2278         prog->edictprivate_size = sizeof(edict_engineprivate_t);
2279         prog->name = "server";
2280         prog->extensionstring = vm_sv_extensions;
2281         prog->loadintoworld = true;
2282
2283         // all callbacks must be defined (pointers are not checked before calling)
2284         prog->begin_increase_edicts = SVVM_begin_increase_edicts;
2285         prog->end_increase_edicts   = SVVM_end_increase_edicts;
2286         prog->init_edict            = SVVM_init_edict;
2287         prog->free_edict            = SVVM_free_edict;
2288         prog->count_edicts          = SVVM_count_edicts;
2289         prog->load_edict            = SVVM_load_edict;
2290         prog->init_cmd              = SVVM_init_cmd;
2291         prog->reset_cmd             = SVVM_reset_cmd;
2292         prog->error_cmd             = Host_Error;
2293         prog->ExecuteProgram        = SVVM_ExecuteProgram;
2294
2295         PRVM_Prog_Load(prog, sv_progs.string, NULL, 0, SV_REQFUNCS, sv_reqfuncs, SV_REQFIELDS, sv_reqfields, SV_REQGLOBALS, sv_reqglobals);
2296
2297         // some mods compiled with scrambling compilers lack certain critical
2298         // global names and field names such as "self" and "time" and "nextthink"
2299         // so we have to set these offsets manually, matching the entvars_t
2300         // but we only do this if the prog header crc matches, otherwise it's totally freeform
2301         if (prog->progs_crc == PROGHEADER_CRC || prog->progs_crc == PROGHEADER_CRC_TENEBRAE)
2302         {
2303                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, modelindex);
2304                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, absmin);
2305                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, absmax);
2306                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ltime);
2307                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, movetype);
2308                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, solid);
2309                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, origin);
2310                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, oldorigin);
2311                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, velocity);
2312                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
2313                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, avelocity);
2314                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, punchangle);
2315                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
2316                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, model);
2317                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
2318                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, skin);
2319                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, effects);
2320                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, mins);
2321                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, maxs);
2322                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, size);
2323                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, touch);
2324                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, use);
2325                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
2326                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, blocked);
2327                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
2328                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
2329                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, health);
2330                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frags);
2331                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weapon);
2332                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weaponmodel);
2333                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weaponframe);
2334                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, currentammo);
2335                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_shells);
2336                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_nails);
2337                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_rockets);
2338                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_cells);
2339                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, items);
2340                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, takedamage);
2341                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
2342                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, deadflag);
2343                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, view_ofs);
2344                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button0);
2345                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button1);
2346                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button2);
2347                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, impulse);
2348                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, fixangle);
2349                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, v_angle);
2350                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, idealpitch);
2351                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, netname);
2352                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, enemy);
2353                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, flags);
2354                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, colormap);
2355                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, team);
2356                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, max_health);
2357                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, teleport_time);
2358                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, armortype);
2359                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, armorvalue);
2360                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, waterlevel);
2361                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, watertype);
2362                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
2363                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
2364                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, aiment);
2365                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, goalentity);
2366                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, spawnflags);
2367                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, target);
2368                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, targetname);
2369                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_take);
2370                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_save);
2371                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_inflictor);
2372                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, owner);
2373                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, movedir);
2374                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, message);
2375                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, sounds);
2376                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise);
2377                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise1);
2378                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise2);
2379                 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise3);
2380                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
2381                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, other);
2382                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, world);
2383                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
2384                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, frametime);
2385                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, force_retouch);
2386                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, mapname);
2387                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, deathmatch);
2388                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, coop);
2389                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, teamplay);
2390                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, serverflags);
2391                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, total_secrets);
2392                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, total_monsters);
2393                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, found_secrets);
2394                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, killed_monsters);
2395                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm1);
2396                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm2);
2397                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm3);
2398                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm4);
2399                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm5);
2400                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm6);
2401                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm7);
2402                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm8);
2403                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm9);
2404                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm10);
2405                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm11);
2406                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm12);
2407                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm13);
2408                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm14);
2409                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm15);
2410                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm16);
2411                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
2412                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
2413                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
2414                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
2415                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
2416                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
2417                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
2418                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
2419                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
2420                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
2421                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
2422                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
2423                 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, msg_entity);
2424 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, main);
2425 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, StartFrame);
2426 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PlayerPreThink);
2427 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PlayerPostThink);
2428 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientKill);
2429 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientConnect);
2430 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PutClientInServer);
2431 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientDisconnect);
2432 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, SetNewParms);
2433 //              PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, SetChangeParms);
2434         }
2435         else
2436                 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);
2437
2438         // OP_STATE is always supported on server because we add fields/globals for it
2439         prog->flag |= PRVM_OP_STATE;
2440
2441         VM_CustomStats_Clear();//[515]: csqc
2442
2443         SV_Prepare_CSQC();
2444 }
2445
2446 static void SV_CheckTimeouts(void)
2447 {
2448         int i;
2449
2450         // never timeout loopback connections
2451         for (i = (host_isclient.integer ? 1 : 0), host_client = &svs.clients[i]; i < svs.maxclients; i++, host_client++)
2452         {
2453                 if (host_client->netconnection && host.realtime > host_client->netconnection->timeout)
2454                 {
2455                         if (host_client->begun)
2456                                 SV_BroadcastPrintf("Client \"%s\" connection timed out\n", host_client->name);
2457                         else
2458                                 Con_Printf("Client \"%s\" connection timed out\n", host_client->name);
2459
2460                         SV_DropClient(false);
2461                 }
2462         }
2463 }
2464
2465 /*
2466 ==================
2467 SV_TimeReport
2468
2469 Returns a time report string, for example for
2470 ==================
2471 */
2472 const char *SV_TimingReport(char *buf, size_t buflen)
2473 {
2474         return va(buf, buflen, "%.1f%% CPU, %.2f%% lost, offset avg %.1fms, max %.1fms, sdev %.1fms", svs.perf_cpuload * 100, svs.perf_lost * 100, svs.perf_offset_avg * 1000, svs.perf_offset_max * 1000, svs.perf_offset_sdev * 1000);
2475 }
2476
2477 extern cvar_t host_maxwait;
2478 extern cvar_t host_framerate;
2479 extern cvar_t cl_maxphysicsframesperserverframe;
2480 double SV_Frame(double time)
2481 {
2482         static double sv_timer;
2483         int i;
2484         char vabuf[1024];
2485         qbool playing = false;
2486
2487         if (!svs.threaded)
2488         {
2489                 svs.perf_acc_sleeptime = host.sleeptime;
2490                 svs.perf_acc_realtime += time;
2491
2492                 // Look for clients who have spawned
2493                 for (i = 0, host_client = svs.clients; i < svs.maxclients; i++, host_client++)
2494                         if(host_client->begun && host_client->netconnection)
2495                                 playing = true;
2496
2497                 if(svs.perf_acc_realtime > 5)
2498                 {
2499                         svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime;
2500                         svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime;
2501
2502                         if(svs.perf_acc_offset_samples > 0)
2503                         {
2504                                 svs.perf_offset_max = svs.perf_acc_offset_max;
2505                                 svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples;
2506                                 svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg);
2507                         }
2508
2509                         if(svs.perf_lost > 0 && developer_extra.integer && playing) // only complain if anyone is looking
2510                                 Con_DPrintf("Server can't keep up: %s\n", SV_TimingReport(vabuf, sizeof(vabuf)));
2511                 }
2512
2513                 if(svs.perf_acc_realtime > 5 || sv.time < 10)
2514                 {
2515                         /*
2516                          * Don't accumulate time for the first 10 seconds of a match
2517                          * so things can settle
2518                          */
2519                         svs.perf_acc_realtime = svs.perf_acc_sleeptime =
2520                         svs.perf_acc_lost = svs.perf_acc_offset =
2521                         svs.perf_acc_offset_squared = svs.perf_acc_offset_max =
2522                         svs.perf_acc_offset_samples = host.sleeptime = 0;
2523                 }
2524
2525                 /*
2526                  * Receive packets on each main loop iteration, as the main loop may
2527                  * be undersleeping due to select() detecting a new packet
2528                  */
2529                 if (sv.active)
2530                 {
2531                         NetConn_ServerFrame();
2532                         SV_CheckTimeouts();
2533                 }
2534         }
2535
2536         /*
2537          * If the accumulator hasn't become positive, don't
2538          * run the frame. Everything that happens before this
2539          * point will happen even if we're sleeping this frame.
2540          */
2541         if((sv_timer += time) < 0)
2542                 return sv_timer;
2543
2544         // limit the frametime steps to no more than 100ms each
2545         if (sv_timer > 0.1)
2546         {
2547                 if (!svs.threaded)
2548                         svs.perf_acc_lost += (sv_timer - 0.1);
2549                 sv_timer = 0.1;
2550         }
2551
2552         if (sv.active && sv_timer > 0 && !svs.threaded)
2553         {
2554                 /*
2555                  * Execute one or more server frames, with an upper limit on how much
2556                  * execution time to spend on server frames to avoid freezing the game if
2557                  * the server is overloaded. This execution time limit means the game will
2558                  * slow down if the server is taking too long.
2559                  */
2560                 int framecount, framelimit = 1;
2561                 double advancetime, aborttime = 0;
2562                 float offset;
2563                 prvm_prog_t *prog = SVVM_prog;
2564
2565                 // run the world state
2566                 // don't allow simulation to run too fast or too slow or logic glitches can occur
2567
2568                 // stop running server frames if the wall time reaches this value
2569                 if (sys_ticrate.value <= 0)
2570                         advancetime = sv_timer;
2571                 else
2572                 {
2573                         advancetime = sys_ticrate.value;
2574                         // listen servers can run multiple server frames per client frame
2575                         framelimit = cl_maxphysicsframesperserverframe.integer;
2576                         aborttime = Sys_DirtyTime() + 0.1;
2577                 }
2578
2579                 if(host_timescale.value > 0 && host_timescale.value < 1)
2580                         advancetime = min(advancetime, 0.1 / host_timescale.value);
2581                 else
2582                         advancetime = min(advancetime, 0.1);
2583
2584                 if(advancetime > 0)
2585                 {
2586                         offset = Sys_DirtyTime() - host.dirtytime;
2587                         if (offset < 0 || offset >= 1800)
2588                                 offset = 0;
2589
2590                         offset += sv_timer;
2591                         ++svs.perf_acc_offset_samples;
2592                         svs.perf_acc_offset += offset;
2593                         svs.perf_acc_offset_squared += offset * offset;
2594
2595                         if(svs.perf_acc_offset_max < offset)
2596                                 svs.perf_acc_offset_max = offset;
2597                 }
2598
2599                 // only advance time if not paused
2600                 // the game also pauses in singleplayer when menu or console is used
2601                 sv.frametime = advancetime * host_timescale.value;
2602                 if (host_framerate.value)
2603                         sv.frametime = host_framerate.value;
2604                 if (sv.paused || host.paused)
2605                         sv.frametime = 0;
2606
2607                 for (framecount = 0; framecount < framelimit && sv_timer > 0; framecount++)
2608                 {
2609                         sv_timer -= advancetime;
2610
2611                         // move things around and think unless paused
2612                         if (sv.frametime)
2613                                 SV_Physics();
2614
2615                         // if this server frame took too long, break out of the loop
2616                         if (framelimit > 1 && Sys_DirtyTime() >= aborttime)
2617                                 break;
2618                 }
2619
2620                 R_TimeReport("serverphysics");
2621
2622                 // send all messages to the clients
2623                 SV_SendClientMessages();
2624
2625                 if (sv.paused == 1 && host.realtime > sv.pausedstart && sv.pausedstart > 0) {
2626                         prog->globals.fp[OFS_PARM0] = host.realtime - sv.pausedstart;
2627                         PRVM_serverglobalfloat(time) = sv.time;
2628                         prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing");
2629                 }
2630
2631                 // send an heartbeat if enough time has passed since the last one
2632                 NetConn_Heartbeat(0);
2633                 R_TimeReport("servernetwork");
2634         }
2635         else
2636         {
2637                 // don't let r_speeds display jump around
2638                 R_TimeReport("serverphysics");
2639                 R_TimeReport("servernetwork");
2640         }
2641
2642         // if there is some time remaining from this frame, reset the timer
2643         if (sv_timer >= 0)
2644         {
2645                 if (!svs.threaded)
2646                         svs.perf_acc_lost += sv_timer;
2647                 sv_timer = 0;
2648         }
2649
2650         return sv_timer;
2651 }
2652
2653 static int SV_ThreadFunc(void *voiddata)
2654 {
2655         prvm_prog_t *prog = SVVM_prog;
2656         qbool playing = false;
2657         double sv_timer = 0;
2658         double sv_deltarealtime, sv_oldrealtime, sv_realtime;
2659         double wait;
2660         int i;
2661         char vabuf[1024];
2662         sv_realtime = Sys_DirtyTime();
2663         while (!svs.threadstop)
2664         {
2665                 // FIXME: we need to handle Host_Error in the server thread somehow
2666 //              if (setjmp(sv_abortframe))
2667 //                      continue;                       // something bad happened in the server game
2668
2669                 sv_oldrealtime = sv_realtime;
2670                 sv_realtime = Sys_DirtyTime();
2671                 sv_deltarealtime = sv_realtime - sv_oldrealtime;
2672                 if (sv_deltarealtime < 0 || sv_deltarealtime >= 1800) sv_deltarealtime = 0;
2673
2674                 sv_timer += sv_deltarealtime;
2675
2676                 svs.perf_acc_realtime += sv_deltarealtime;
2677
2678                 // 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)
2679                 SV_LockThreadMutex();
2680
2681                 // Look for clients who have spawned
2682                 playing = false;
2683                 if (sv.active)
2684                         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2685                                 if(host_client->begun)
2686                                         if(host_client->netconnection)
2687                                                 playing = true;
2688                 if(sv.time < 10)
2689                 {
2690                         // don't accumulate time for the first 10 seconds of a match
2691                         // so things can settle
2692                         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;
2693                 }
2694                 else if(svs.perf_acc_realtime > 5)
2695                 {
2696                         svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime;
2697                         svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime;
2698                         if(svs.perf_acc_offset_samples > 0)
2699                         {
2700                                 svs.perf_offset_max = svs.perf_acc_offset_max;
2701                                 svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples;
2702                                 svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg);
2703                         }
2704                         if(svs.perf_lost > 0 && developer_extra.integer)
2705                                 if(playing)
2706                                         Con_DPrintf("Server can't keep up: %s\n", SV_TimingReport(vabuf, sizeof(vabuf)));
2707                         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;
2708                 }
2709
2710                 // get new packets
2711                 if (sv.active)
2712                 {
2713                         NetConn_ServerFrame();
2714                         SV_CheckTimeouts();
2715                 }
2716
2717                 // if the accumulators haven't become positive yet, wait a while
2718                 wait = sv_timer * -1000000.0;
2719                 if (wait >= 1)
2720                 {
2721                         double time0, delta;
2722                         SV_UnlockThreadMutex(); // don't keep mutex locked while sleeping
2723                         if (host_maxwait.value <= 0)
2724                                 wait = min(wait, 1000000.0);
2725                         else
2726                                 wait = min(wait, host_maxwait.value * 1000.0);
2727                         if(wait < 1)
2728                                 wait = 1; // because we cast to int
2729                         time0 = Sys_DirtyTime();
2730                         Sys_Sleep((int)wait);
2731                         delta = Sys_DirtyTime() - time0;if (delta < 0 || delta >= 1800) delta = 0;
2732                         svs.perf_acc_sleeptime += delta;
2733                         continue;
2734                 }
2735
2736                 if (sv.active && sv_timer > 0)
2737                 {
2738                         // execute one server frame
2739                         double advancetime;
2740                         float offset;
2741
2742                         if (sys_ticrate.value <= 0)
2743                                 advancetime = min(sv_timer, 0.1); // don't step more than 100ms
2744                         else
2745                                 advancetime = sys_ticrate.value;
2746
2747                         if(advancetime > 0)
2748                         {
2749                                 offset = sv_timer + (Sys_DirtyTime() - sv_realtime); // LadyHavoc: FIXME: I don't understand this line
2750                                 ++svs.perf_acc_offset_samples;
2751                                 svs.perf_acc_offset += offset;
2752                                 svs.perf_acc_offset_squared += offset * offset;
2753                                 if(svs.perf_acc_offset_max < offset)
2754                                         svs.perf_acc_offset_max = offset;
2755                         }
2756
2757                         // only advance time if not paused
2758                         // the game also pauses in singleplayer when menu or console is used
2759                         sv.frametime = advancetime * host_timescale.value;
2760                         if (host_framerate.value)
2761                                 sv.frametime = host_framerate.value;
2762                         if (sv.paused || host.paused)
2763                                 sv.frametime = 0;
2764
2765                         sv_timer -= advancetime;
2766
2767                         // move things around and think unless paused
2768                         if (sv.frametime)
2769                                 SV_Physics();
2770
2771                         // send all messages to the clients
2772                         SV_SendClientMessages();
2773
2774                         if (sv.paused == 1 && sv_realtime > sv.pausedstart && sv.pausedstart > 0)
2775                         {
2776                                 PRVM_serverglobalfloat(time) = sv.time;
2777                                 prog->globals.fp[OFS_PARM0] = sv_realtime - sv.pausedstart;
2778                                 prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing");
2779                         }
2780
2781                         // send an heartbeat if enough time has passed since the last one
2782                         NetConn_Heartbeat(0);
2783
2784                 }
2785
2786                 // we're back to safe code now
2787                 SV_UnlockThreadMutex();
2788
2789                 // if there is some time remaining from this frame, reset the timers
2790                 if (sv_timer >= 0)
2791                 {
2792                         svs.perf_acc_lost += sv_timer;
2793                         sv_timer = 0;
2794                 }
2795         }
2796         return 0;
2797 }
2798
2799 void SV_StartThread(void)
2800 {
2801         if (!sv_threaded.integer || !Thread_HasThreads())
2802                 return;
2803         svs.threaded = true;
2804         svs.threadstop = false;
2805         svs.threadmutex = Thread_CreateMutex();
2806         svs.thread = Thread_CreateThread(SV_ThreadFunc, NULL);
2807 }
2808
2809 void SV_StopThread(void)
2810 {
2811         if (!svs.threaded)
2812                 return;
2813         svs.threadstop = true;
2814         Thread_WaitThread(svs.thread, 0);
2815         Thread_DestroyMutex(svs.threadmutex);
2816         svs.threaded = false;
2817 }