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
  27 static void SV_SaveEntFile_f(void);
  28 static void SV_StartDownload_f(void);
  29 static void SV_Download_f(void);
  30 static void SV_VM_Setup(void);
  31 extern cvar_t net_connecttimeout;
  32
  33 void VM_CustomStats_Clear (void);
  34 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);
  35
  36 cvar_t coop = {0, "coop","0", "coop mode, 0 = no coop, 1 = coop mode, multiple players playing through the singleplayer game (coop mode also shuts off deathmatch)"};
  37 cvar_t deathmatch = {0, "deathmatch","0", "deathmatch mode, values depend on mod but typically 0 = no deathmatch, 1 = normal deathmatch with respawning weapons, 2 = weapons stay (players can only pick up new weapons)"};
  38 cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};
  39 cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
  40 cvar_t noexit = {CVAR_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};
  41 cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
  42 cvar_t pausable = {0, "pausable","1", "allow players to pause or not"};
  43 cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1", "indicates to QuakeC that the standard quakec extensions system is available (if 0, quakec should not attempt to use extensions)"};
  44 cvar_t samelevel = {CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
  45 cvar_t skill = {0, "skill","1", "difficulty level of game, affects monster layouts in levels, 0 = easy, 1 = normal, 2 = hard, 3 = nightmare (same layout as hard but monsters fire twice)"};
  46 cvar_t slowmo = {0, "slowmo", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
  47
  48 cvar_t sv_accelerate = {0, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
  49 cvar_t sv_aim = {CVAR_SAVE, "sv_aim", "2", "maximum cosine angle for quake's vertical autoaim, a value above 1 completely disables the autoaim, quake used 0.93"};
  50 cvar_t sv_airaccel_qw = {0, "sv_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration"};
  51 cvar_t sv_airaccel_sideways_friction = {0, "sv_airaccel_sideways_friction", "", "anti-sideways movement stabilization (reduces speed gain when zigzagging)"};
  52 cvar_t sv_airaccelerate = {0, "sv_airaccelerate", "-1", "rate at which a player accelerates to sv_maxairspeed while in the air, if less than 0 the sv_accelerate variable is used instead"};
  53 cvar_t sv_airstopaccelerate = {0, "sv_airstopaccelerate", "0", "when set, replacement for sv_airaccelerate when moving backwards"};
  54 cvar_t sv_airstrafeaccelerate = {0, "sv_airstrafeaccelerate", "0", "when set, replacement for sv_airaccelerate when just strafing"};
  55 cvar_t sv_maxairstrafespeed = {0, "sv_maxairstrafespeed", "0", "when set, replacement for sv_maxairspeed when just strafing"};
  56 cvar_t sv_aircontrol = {0, "sv_aircontrol", "0", "CPMA-style air control"};
  57 cvar_t sv_allowdownloads = {0, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};
  58 cvar_t sv_allowdownloads_archive = {0, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};
  59 cvar_t sv_allowdownloads_config = {0, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};
  60 cvar_t sv_allowdownloads_dlcache = {0, "sv_allowdownloads_dlcache", "0", "whether to allow downloads of dlcache files (dlcache/)"};
  61 cvar_t sv_allowdownloads_inarchive = {0, "sv_allowdownloads_inarchive", "0", "whether to allow downloads from archives (pak/pk3)"};
  62 cvar_t sv_areagrid_mingridsize = {CVAR_NOTIFY, "sv_areagrid_mingridsize", "64", "minimum areagrid cell size, smaller values work better for lots of small objects, higher values for large objects"};
  63 cvar_t sv_checkforpacketsduringsleep = {0, "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"};
  64 cvar_t sv_clmovement_enable = {0, "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"};
  65 cvar_t sv_clmovement_minping = {0, "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)"};
  66 cvar_t sv_clmovement_minping_disabletime = {0, "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)"};
  67 cvar_t sv_clmovement_inputtimeout = {0, "sv_clmovement_inputtimeout", "0.2", "when a client does not send input for this many seconds, force them to move anyway (unlike QuakeWorld)"};
  68 cvar_t sv_cullentities_nevercullbmodels = {0, "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!)"};
  69 cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"};
  70 cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
  71 cvar_t sv_cullentities_trace = {0, "sv_cullentities_trace", "0", "somewhat slow but very tight culling of hidden entities, minimizes network traffic and makes wallhack cheats useless"};
  72 cvar_t sv_cullentities_trace_delay = {0, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
  73 cvar_t sv_cullentities_trace_delay_players = {0, "sv_cullentities_trace_delay_players", "0.2", "number of seconds until the entity gets actually culled if it is a player entity"};
  74 cvar_t sv_cullentities_trace_enlarge = {0, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
  75 cvar_t sv_cullentities_trace_prediction = {0, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};
  76 cvar_t sv_cullentities_trace_samples = {0, "sv_cullentities_trace_samples", "1", "number of samples to test for entity culling"};
  77 cvar_t sv_cullentities_trace_samples_extra = {0, "sv_cullentities_trace_samples_extra", "2", "number of samples to test for entity culling when the entity affects its surroundings by e.g. dlight"};
  78 cvar_t sv_cullentities_trace_samples_players = {0, "sv_cullentities_trace_samples_players", "8", "number of samples to test for entity culling when the entity is a player entity"};
  79 cvar_t sv_debugmove = {CVAR_NOTIFY, "sv_debugmove", "0", "disables collision detection optimizations for debugging purposes"};
  80 cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1", "prints gamecode bprint() calls to server console"};
  81 cvar_t sv_edgefriction = {0, "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)"};
  82 cvar_t sv_entpatch = {0, "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)"};
  83 cvar_t sv_fixedframeratesingleplayer = {0, "sv_fixedframeratesingleplayer", "1", "allows you to use server-style timing system in singleplayer (don't run faster than sys_ticrate)"};
  84 cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
  85 cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4", "how fast you slow down"};
  86 cvar_t sv_gameplayfix_blowupfallenzombies = {0, "sv_gameplayfix_blowupfallenzombies", "1", "causes findradius to detect SOLID_NOT entities such as zombies and corpses on the floor, allowing splash damage to apply to them"};
  87 cvar_t sv_gameplayfix_consistentplayerprethink = {0, "sv_gameplayfix_consistentplayerprethink", "1", "improves fairness in multiplayer by running all PlayerPreThink functions (which fire weapons) before performing physics, then runing all PlayerPostThink functions"};
  88 cvar_t sv_gameplayfix_delayprojectiles = {0, "sv_gameplayfix_delayprojectiles", "1", "causes entities to not move on the same frame they are spawned, meaning that projectiles wait until the next frame to perform their first move, giving proper interpolation and rocket trails, but making weapons harder to use at low framerates"};
  89 cvar_t sv_gameplayfix_droptofloorstartsolid = {0, "sv_gameplayfix_droptofloorstartsolid", "1", "prevents items and monsters that start in a solid area from falling out of the level (makes droptofloor treat trace_startsolid as an acceptable outcome)"};
  90 cvar_t sv_gameplayfix_droptofloorstartsolid_nudgetocorrect = {0, "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect", "1", "tries to nudge stuck items and monsters out of walls before droptofloor is performed"};
  91 cvar_t sv_gameplayfix_easierwaterjump = {0, "sv_gameplayfix_easierwaterjump", "1", "changes water jumping to make it easier to get out of water (exactly like in QuakeWorld)"};
  92 cvar_t sv_gameplayfix_findradiusdistancetobox = {0, "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"};
  93 cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
  94 cvar_t sv_gameplayfix_multiplethinksperframe = {0, "sv_gameplayfix_multiplethinksperframe", "1", "allows entities to think more often than the server framerate, primarily useful for very high fire rate weapons"};
  95 cvar_t sv_gameplayfix_slidemoveprojectiles = {0, "sv_gameplayfix_slidemoveprojectiles", "1", "allows MOVETYPE_FLY/FLYMISSILE/TOSS/BOUNCE/BOUNCEMISSILE entities to finish their move in a frame even if they hit something, fixes 'gravity accumulation' bug for grenades on steep slopes"};
  96 cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1", "causes entities (corpses, items, etc) sitting ontop of moving entities (players) to fall when the moving entity (player) is no longer supporting them"};
  97 cvar_t sv_gameplayfix_noairborncorpse_allowsuspendeditems = {0, "sv_gameplayfix_noairborncorpse_allowsuspendeditems", "1", "causes entities sitting ontop of objects that are instantaneously remove to float in midair (special hack to allow a common level design trick for floating items)"};
  98 cvar_t sv_gameplayfix_setmodelrealbox = {0, "sv_gameplayfix_setmodelrealbox", "1", "fixes a bug in Quake that made setmodel always set the entity box to ('-16 -16 -16', '16 16 16') rather than properly checking the model box, breaks some poorly coded mods"};
  99 cvar_t sv_gameplayfix_stepdown = {0, "sv_gameplayfix_stepdown", "0", "attempts to step down stairs, not just up them (prevents the familiar thud..thud..thud.. when running down stairs and slopes)"};
 100 cvar_t sv_gameplayfix_stepwhilejumping = {0, "sv_gameplayfix_stepwhilejumping", "1", "applies step-up onto a ledge even while airborn, useful if you would otherwise just-miss the floor when running across small areas with gaps (for instance running across the moving platforms in dm2, or jumping to the megahealth and red armor in dm2 rather than using the bridge)"};
 101 cvar_t sv_gameplayfix_swiminbmodels = {0, "sv_gameplayfix_swiminbmodels", "1", "causes pointcontents (used to determine if you are in a liquid) to check bmodel entities as well as the world model, so you can swim around in (possibly moving) water bmodel entities"};
 102 cvar_t sv_gameplayfix_upwardvelocityclearsongroundflag = {0, "sv_gameplayfix_upwardvelocityclearsongroundflag", "1", "prevents monsters, items, and most other objects from being stuck to the floor when pushed around by damage, and other situations in mods"};
 103 cvar_t sv_gameplayfix_gravityunaffectedbyticrate = {0, "sv_gameplayfix_gravityunaffectedbyticrate", "0", "fix some ticrate issues in physics."};
 104 cvar_t sv_gameplayfix_q2airaccelerate = {0, "sv_gameplayfix_q2airaccelerate", "0", "Quake2-style air acceleration"};
 105 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
 106 cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};
 107 cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
 108 cvar_t sv_jumpvelocity = {0, "sv_jumpvelocity", "270", "cvar that can be used by QuakeC code for jump velocity"};
 109 cvar_t sv_maxairspeed = {0, "sv_maxairspeed", "30", "maximum speed a player can accelerate to when airborn (note that it is possible to completely stop by moving the opposite direction)"};
 110 cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "1000000", "upper limit on client rate cvar, should reflect your network connection quality"};
 111 cvar_t sv_maxspeed = {CVAR_NOTIFY, "sv_maxspeed", "320", "maximum speed a player can accelerate to when on ground (can be exceeded by tricks)"};
 112 cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
 113 cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0", "enables simpler/buggier player physics (not recommended)"};
 114 cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
 115 cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
 116 cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
 117 cvar_t sv_protocolname = {0, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
 118 cvar_t sv_random_seed = {0, "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"};
 119 cvar_t sv_ratelimitlocalplayer = {0, "sv_ratelimitlocalplayer", "0", "whether to apply rate limiting to the local player in a listen server (only useful for testing)"};
 120 cvar_t sv_sound_land = {0, "sv_sound_land", "demon/dland2.wav", "sound to play when MOVETYPE_STEP entity hits the ground at high speed (empty cvar disables the sound)"};
 121 cvar_t sv_sound_watersplash = {0, "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)"};
 122 cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
 123 cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
 124 cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
 125 cvar_t sv_wateraccelerate = {0, "sv_wateraccelerate", "-1", "rate at which a player accelerates to sv_maxspeed while in the air, if less than 0 the sv_accelerate variable is used instead"};
 126 cvar_t sv_waterfriction = {CVAR_NOTIFY, "sv_waterfriction","-1", "how fast you slow down, if less than 0 the sv_friction variable is used instead"};
 127 cvar_t sv_warsowbunny_airforwardaccel = {0, "sv_warsowbunny_airforwardaccel", "1.00001", "how fast you accelerate until you reach sv_maxspeed"};
 128 cvar_t sv_warsowbunny_accel = {0, "sv_warsowbunny_accel", "0.1585", "how fast you accelerate until after reaching sv_maxspeed (it gets harder as you near sv_warsowbunny_topspeed)"};
 129 cvar_t sv_warsowbunny_topspeed = {0, "sv_warsowbunny_topspeed", "925", "soft speed limit (can get faster with rjs and on ramps)"};
 130 cvar_t sv_warsowbunny_turnaccel = {0, "sv_warsowbunny_turnaccel", "0", "max sharpness of turns (also master switch for the sv_warsowbunny_* mode; set this to 9 to enable)"};
 131 cvar_t sv_warsowbunny_backtosideratio = {0, "sv_warsowbunny_backtosideratio", "0.8", "lower values make it easier to change direction without losing speed; the drawback is \"understeering\" in sharp turns"};
 132 cvar_t sv_onlycsqcnetworking = {0, "sv_onlycsqcnetworking", "0", "disables legacy entity networking code for higher performance (except on clients, which can still be legacy)"};
 133 cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.0138889", "how long a server frame is in seconds, 0.05 is 20fps server rate, 0.1 is 10fps (can not be set higher than 0.1), 0 runs as many server frames as possible (makes games against bots a little smoother, overwhelms network players), 0.0138889 matches QuakeWorld physics"};
 134 cvar_t teamplay = {CVAR_NOTIFY, "teamplay","0", "teamplay mode, values depend on mod but typically 0 = no teams, 1 = no team damage no self damage, 2 = team damage and self damage, some mods support 3 = no team damage but can damage self"};
 135 cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};
 136
 137 cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 138 cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 139 cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 140 cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 141 cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
 142 cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"};
 143 cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"};
 144 cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"};
 145 cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"};
 146 cvar_t temp1 = {0, "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)"};
 147
 148 cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
 149 cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
 150 cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
 151 cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
 152 cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
 153 cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
 154 cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
 155 cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
 156 cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
 157 cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
 158 cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
 159 cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
 160 cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
 161 cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
 162 cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
 163 cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
 164 cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
 165 cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
 166 cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
 167 cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
 168 cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
 169
 170 cvar_t sv_autodemo_perclient = {CVAR_SAVE, "sv_autodemo_perclient", "0", "set to 1 to enable autorecorded per-client demos (they'll start to record at the beginning of a match); set it to 2 to also record client->server packets (for debugging)"};
 171 cvar_t sv_autodemo_perclient_nameformat = {CVAR_SAVE, "sv_autodemo_perclient_nameformat", "sv_autodemos/%Y-%m-%d_%H-%M", "The format of the sv_autodemo_perclient filename, followed by the map name, the client number and the IP address + port number, separated by underscores (the date is encoded using strftime escapes)" };
 172
 173 cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
 174
 175 server_t sv;
 176 server_static_t svs;
 177
 178 mempool_t *sv_mempool = NULL;
 179
 180 extern cvar_t slowmo;
 181 extern float            scr_centertime_off;
 182
 183 // MUST match effectnameindex_t in client.h
 184 static const char *standardeffectnames[EFFECT_TOTAL] =
 185 {
 186         "",
 187         "TE_GUNSHOT",
 188         "TE_GUNSHOTQUAD",
 189         "TE_SPIKE",
 190         "TE_SPIKEQUAD",
 191         "TE_SUPERSPIKE",
 192         "TE_SUPERSPIKEQUAD",
 193         "TE_WIZSPIKE",
 194         "TE_KNIGHTSPIKE",
 195         "TE_EXPLOSION",
 196         "TE_EXPLOSIONQUAD",
 197         "TE_TAREXPLOSION",
 198         "TE_TELEPORT",
 199         "TE_LAVASPLASH",
 200         "TE_SMALLFLASH",
 201         "TE_FLAMEJET",
 202         "EF_FLAME",
 203         "TE_BLOOD",
 204         "TE_SPARK",
 205         "TE_PLASMABURN",
 206         "TE_TEI_G3",
 207         "TE_TEI_SMOKE",
 208         "TE_TEI_BIGEXPLOSION",
 209         "TE_TEI_PLASMAHIT",
 210         "EF_STARDUST",
 211         "TR_ROCKET",
 212         "TR_GRENADE",
 213         "TR_BLOOD",
 214         "TR_WIZSPIKE",
 215         "TR_SLIGHTBLOOD",
 216         "TR_KNIGHTSPIKE",
 217         "TR_VORESPIKE",
 218         "TR_NEHAHRASMOKE",
 219         "TR_NEXUIZPLASMA",
 220         "TR_GLOWTRAIL",
 221         "SVC_PARTICLE"
 222 };
 223
 224 #define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t))
 225
 226 prvm_required_field_t reqfields[] =
 227 {
 228         {ev_entity, "cursor_trace_ent"},
 229         {ev_entity, "drawonlytoclient"},
 230         {ev_entity, "exteriormodeltoclient"},
 231         {ev_entity, "nodrawtoclient"},
 232         {ev_entity, "tag_entity"},
 233         {ev_entity, "viewmodelforclient"},
 234         {ev_float, "SendFlags"},
 235         {ev_float, "Version"},
 236         {ev_float, "alpha"},
 237         {ev_float, "ammo_cells1"},
 238         {ev_float, "ammo_lava_nails"},
 239         {ev_float, "ammo_multi_rockets"},
 240         {ev_float, "ammo_nails1"},
 241         {ev_float, "ammo_plasma"},
 242         {ev_float, "ammo_rockets1"},
 243         {ev_float, "ammo_shells1"},
 244         {ev_float, "button3"},
 245         {ev_float, "button4"},
 246         {ev_float, "button5"},
 247         {ev_float, "button6"},
 248         {ev_float, "button7"},
 249         {ev_float, "button8"},
 250         {ev_float, "button9"},
 251         {ev_float, "button10"},
 252         {ev_float, "button11"},
 253         {ev_float, "button12"},
 254         {ev_float, "button13"},
 255         {ev_float, "button14"},
 256         {ev_float, "button15"},
 257         {ev_float, "button16"},
 258         {ev_float, "buttonchat"},
 259         {ev_float, "buttonuse"},
 260         {ev_float, "clientcolors"},
 261         {ev_float, "cursor_active"},
 262         {ev_float, "disableclientprediction"},
 263         {ev_float, "fullbright"},
 264         {ev_float, "glow_color"},
 265         {ev_float, "glow_size"},
 266         {ev_float, "glow_trail"},
 267         {ev_float, "gravity"},
 268         {ev_float, "idealpitch"},
 269         {ev_float, "items2"},
 270         {ev_float, "light_lev"},
 271         {ev_float, "modelflags"},
 272         {ev_float, "pflags"},
 273         {ev_float, "ping"},
 274         {ev_float, "pitch_speed"},
 275         {ev_float, "pmodel"},
 276         {ev_float, "renderamt"}, // HalfLife support
 277         {ev_float, "rendermode"}, // HalfLife support
 278         {ev_float, "scale"},
 279         {ev_float, "style"},
 280         {ev_float, "tag_index"},
 281         {ev_float, "viewzoom"},
 282         {ev_function, "SendEntity"},
 283         {ev_function, "contentstransition"}, // DRESK - Support for Entity Contents Transition Event
 284         {ev_function, "customizeentityforclient"},
 285         {ev_function, "movetypesteplandevent"}, // DRESK - Support for MOVETYPE_STEP Entity Land Event
 286         {ev_string, "netaddress"},
 287         {ev_string, "playermodel"},
 288         {ev_string, "playerskin"},
 289         {ev_vector, "color"},
 290         {ev_vector, "colormod"},
 291         {ev_vector, "cursor_screen"},
 292         {ev_vector, "cursor_trace_endpos"},
 293         {ev_vector, "cursor_trace_start"},
 294         {ev_vector, "glowmod"},
 295         {ev_vector, "movement"},
 296         {ev_vector, "punchvector"},
 297 };
 298
 299
 300
 301 //============================================================================
 302
 303 void SV_AreaStats_f(void)
 304 {
 305         World_PrintAreaStats(&sv.world, "server");
 306 }
 307
 308 /*
 309 ===============
 310 SV_Init
 311 ===============
 312 */
 313 void SV_Init (void)
 314 {
 315         // init the csqc progs cvars, since they are updated/used by the server code
 316         // TODO: fix this since this is a quick hack to make some of [515]'s broken code run ;) [9/13/2006 Black]
 317         extern cvar_t csqc_progname;    //[515]: csqc crc check and right csprogs name according to progs.dat
 318         extern cvar_t csqc_progcrc;
 319         extern cvar_t csqc_progsize;
 320         Cvar_RegisterVariable (&csqc_progname);
 321         Cvar_RegisterVariable (&csqc_progcrc);
 322         Cvar_RegisterVariable (&csqc_progsize);
 323
 324         Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
 325         Cmd_AddCommand("sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
 326         Cmd_AddCommand_WithClientCommand("sv_startdownload", NULL, SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
 327         Cmd_AddCommand_WithClientCommand("download", NULL, SV_Download_f, "downloads a specified file from the server");
 328
 329         Cvar_RegisterVariable (&coop);
 330         Cvar_RegisterVariable (&deathmatch);
 331         Cvar_RegisterVariable (&fraglimit);
 332         Cvar_RegisterVariable (&gamecfg);
 333         Cvar_RegisterVariable (&noexit);
 334         Cvar_RegisterVariable (&nomonsters);
 335         Cvar_RegisterVariable (&pausable);
 336         Cvar_RegisterVariable (&pr_checkextension);
 337         Cvar_RegisterVariable (&samelevel);
 338         Cvar_RegisterVariable (&skill);
 339         Cvar_RegisterVariable (&slowmo);
 340         Cvar_RegisterVariable (&sv_accelerate);
 341         Cvar_RegisterVariable (&sv_aim);
 342         Cvar_RegisterVariable (&sv_airaccel_qw);
 343         Cvar_RegisterVariable (&sv_airaccel_sideways_friction);
 344         Cvar_RegisterVariable (&sv_airaccelerate);
 345         Cvar_RegisterVariable (&sv_airstopaccelerate);
 346         Cvar_RegisterVariable (&sv_airstrafeaccelerate);
 347         Cvar_RegisterVariable (&sv_maxairstrafespeed);
 348         Cvar_RegisterVariable (&sv_aircontrol);
 349         Cvar_RegisterVariable (&sv_allowdownloads);
 350         Cvar_RegisterVariable (&sv_allowdownloads_archive);
 351         Cvar_RegisterVariable (&sv_allowdownloads_config);
 352         Cvar_RegisterVariable (&sv_allowdownloads_dlcache);
 353         Cvar_RegisterVariable (&sv_allowdownloads_inarchive);
 354         Cvar_RegisterVariable (&sv_areagrid_mingridsize);
 355         Cvar_RegisterVariable (&sv_checkforpacketsduringsleep);
 356         Cvar_RegisterVariable (&sv_clmovement_enable);
 357         Cvar_RegisterVariable (&sv_clmovement_minping);
 358         Cvar_RegisterVariable (&sv_clmovement_minping_disabletime);
 359         Cvar_RegisterVariable (&sv_clmovement_inputtimeout);
 360         Cvar_RegisterVariable (&sv_cullentities_nevercullbmodels);
 361         Cvar_RegisterVariable (&sv_cullentities_pvs);
 362         Cvar_RegisterVariable (&sv_cullentities_stats);
 363         Cvar_RegisterVariable (&sv_cullentities_trace);
 364         Cvar_RegisterVariable (&sv_cullentities_trace_delay);
 365         Cvar_RegisterVariable (&sv_cullentities_trace_delay_players);
 366         Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
 367         Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
 368         Cvar_RegisterVariable (&sv_cullentities_trace_samples);
 369         Cvar_RegisterVariable (&sv_cullentities_trace_samples_extra);
 370         Cvar_RegisterVariable (&sv_cullentities_trace_samples_players);
 371         Cvar_RegisterVariable (&sv_debugmove);
 372         Cvar_RegisterVariable (&sv_echobprint);
 373         Cvar_RegisterVariable (&sv_edgefriction);
 374         Cvar_RegisterVariable (&sv_entpatch);
 375         Cvar_RegisterVariable (&sv_fixedframeratesingleplayer);
 376         Cvar_RegisterVariable (&sv_freezenonclients);
 377         Cvar_RegisterVariable (&sv_friction);
 378         Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
 379         Cvar_RegisterVariable (&sv_gameplayfix_consistentplayerprethink);
 380         Cvar_RegisterVariable (&sv_gameplayfix_delayprojectiles);
 381         Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid);
 382         Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid_nudgetocorrect);
 383         Cvar_RegisterVariable (&sv_gameplayfix_easierwaterjump);
 384         Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
 385         Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
 386         Cvar_RegisterVariable (&sv_gameplayfix_multiplethinksperframe);
 387         Cvar_RegisterVariable (&sv_gameplayfix_slidemoveprojectiles);
 388         Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
 389         Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse_allowsuspendeditems);
 390         Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
 391         Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
 392         Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
 393         Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
 394         Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
 395         Cvar_RegisterVariable (&sv_gameplayfix_gravityunaffectedbyticrate);
 396         Cvar_RegisterVariable (&sv_gameplayfix_q2airaccelerate);
 397         Cvar_RegisterVariable (&sv_gravity);
 398         Cvar_RegisterVariable (&sv_idealpitchscale);
 399         Cvar_RegisterVariable (&sv_jumpstep);
 400         Cvar_RegisterVariable (&sv_jumpvelocity);
 401         Cvar_RegisterVariable (&sv_maxairspeed);
 402         Cvar_RegisterVariable (&sv_maxrate);
 403         Cvar_RegisterVariable (&sv_maxspeed);
 404         Cvar_RegisterVariable (&sv_maxvelocity);
 405         Cvar_RegisterVariable (&sv_newflymove);
 406         Cvar_RegisterVariable (&sv_nostep);
 407         Cvar_RegisterVariable (&sv_playerphysicsqc);
 408         Cvar_RegisterVariable (&sv_progs);
 409         Cvar_RegisterVariable (&sv_protocolname);
 410         Cvar_RegisterVariable (&sv_random_seed);
 411         Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
 412         Cvar_RegisterVariable (&sv_sound_land);
 413         Cvar_RegisterVariable (&sv_sound_watersplash);
 414         Cvar_RegisterVariable (&sv_stepheight);
 415         Cvar_RegisterVariable (&sv_stopspeed);
 416         Cvar_RegisterVariable (&sv_wallfriction);
 417         Cvar_RegisterVariable (&sv_wateraccelerate);
 418         Cvar_RegisterVariable (&sv_waterfriction);
 419         Cvar_RegisterVariable (&sv_warsowbunny_airforwardaccel);
 420         Cvar_RegisterVariable (&sv_warsowbunny_accel);
 421         Cvar_RegisterVariable (&sv_warsowbunny_topspeed);
 422         Cvar_RegisterVariable (&sv_warsowbunny_turnaccel);
 423         Cvar_RegisterVariable (&sv_warsowbunny_backtosideratio);
 424         Cvar_RegisterVariable (&sv_onlycsqcnetworking);
 425         Cvar_RegisterVariable (&sys_ticrate);
 426         Cvar_RegisterVariable (&teamplay);
 427         Cvar_RegisterVariable (&timelimit);
 428
 429         Cvar_RegisterVariable (&saved1);
 430         Cvar_RegisterVariable (&saved2);
 431         Cvar_RegisterVariable (&saved3);
 432         Cvar_RegisterVariable (&saved4);
 433         Cvar_RegisterVariable (&savedgamecfg);
 434         Cvar_RegisterVariable (&scratch1);
 435         Cvar_RegisterVariable (&scratch2);
 436         Cvar_RegisterVariable (&scratch3);
 437         Cvar_RegisterVariable (&scratch4);
 438         Cvar_RegisterVariable (&temp1);
 439
 440         // LordHavoc: Nehahra uses these to pass data around cutscene demos
 441         if (gamemode == GAME_NEHAHRA)
 442         {
 443                 Cvar_RegisterVariable (&nehx00);
 444                 Cvar_RegisterVariable (&nehx01);
 445                 Cvar_RegisterVariable (&nehx02);
 446                 Cvar_RegisterVariable (&nehx03);
 447                 Cvar_RegisterVariable (&nehx04);
 448                 Cvar_RegisterVariable (&nehx05);
 449                 Cvar_RegisterVariable (&nehx06);
 450                 Cvar_RegisterVariable (&nehx07);
 451                 Cvar_RegisterVariable (&nehx08);
 452                 Cvar_RegisterVariable (&nehx09);
 453                 Cvar_RegisterVariable (&nehx10);
 454                 Cvar_RegisterVariable (&nehx11);
 455                 Cvar_RegisterVariable (&nehx12);
 456                 Cvar_RegisterVariable (&nehx13);
 457                 Cvar_RegisterVariable (&nehx14);
 458                 Cvar_RegisterVariable (&nehx15);
 459                 Cvar_RegisterVariable (&nehx16);
 460                 Cvar_RegisterVariable (&nehx17);
 461                 Cvar_RegisterVariable (&nehx18);
 462                 Cvar_RegisterVariable (&nehx19);
 463         }
 464         Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
 465
 466         Cvar_RegisterVariable (&sv_autodemo_perclient);
 467         Cvar_RegisterVariable (&sv_autodemo_perclient_nameformat);
 468
 469         Cvar_RegisterVariable (&halflifebsp);
 470
 471         // any special defaults for gamemodes go here
 472         if (gamemode == GAME_NEHAHRA)
 473         {
 474                 // Nehahra pushable crates malfunction in some levels if this is on
 475                 Cvar_SetValueQuick (&sv_gameplayfix_upwardvelocityclearsongroundflag, 0);
 476                 // Nehahra NPC AI is confused by this feature
 477                 Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
 478         }
 479         if (gamemode == GAME_HIPNOTIC)
 480         {
 481                 // hipnotic mission pack has issues in their 'friendly monster' ai, which seem to attempt to attack themselves for some reason when findradius() returns non-solid entities.
 482                 Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
 483                 // hipnotic mission pack has issues with bobbing water entities 'jittering' between different heights on alternate frames at the default 0.0138889 ticrate, 0.02 avoids this issue
 484                 Cvar_SetValueQuick (&sys_ticrate, 0.02);
 485                 // hipnotic mission pack has issues in their proximity mine sticking code, which causes them to bounce off.
 486                 Cvar_SetValueQuick (&sv_gameplayfix_slidemoveprojectiles, 0);
 487         }
 488         if (gamemode == GAME_ROGUE)
 489         {
 490                 // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
 491                 Cvar_SetValueQuick (&sv_gameplayfix_findradiusdistancetobox, 0);
 492         }
 493         if (gamemode == GAME_NEXUIZ)
 494         {
 495                 // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
 496                 Cvar_SetValueQuick (&sv_gameplayfix_q2airaccelerate, 1);
 497         }
 498
 499         sv_mempool = Mem_AllocPool("server", 0, NULL);
 500 }
 501
 502 static void SV_SaveEntFile_f(void)
 503 {
 504         char basename[MAX_QPATH];
 505         if (!sv.active || !sv.worldmodel)
 506         {
 507                 Con_Print("Not running a server\n");
 508                 return;
 509         }
 510         FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
 511         FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
 512 }
 513
 514
 515 /*
 516 =============================================================================
 517
 518 EVENT MESSAGES
 519
 520 =============================================================================
 521 */
 522
 523 /*
 524 ==================
 525 SV_StartParticle
 526
 527 Make sure the event gets sent to all clients
 528 ==================
 529 */
 530 void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
 531 {
 532         int i;
 533
 534         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
 535                 return;
 536         MSG_WriteByte (&sv.datagram, svc_particle);
 537         MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
 538         MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
 539         MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 540         for (i=0 ; i<3 ; i++)
 541                 MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
 542         MSG_WriteByte (&sv.datagram, count);
 543         MSG_WriteByte (&sv.datagram, color);
 544         SV_FlushBroadcastMessages();
 545 }
 546
 547 /*
 548 ==================
 549 SV_StartEffect
 550
 551 Make sure the event gets sent to all clients
 552 ==================
 553 */
 554 void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
 555 {
 556         if (modelindex >= 256 || startframe >= 256)
 557         {
 558                 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
 559                         return;
 560                 MSG_WriteByte (&sv.datagram, svc_effect2);
 561                 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
 562                 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
 563                 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 564                 MSG_WriteShort (&sv.datagram, modelindex);
 565                 MSG_WriteShort (&sv.datagram, startframe);
 566                 MSG_WriteByte (&sv.datagram, framecount);
 567                 MSG_WriteByte (&sv.datagram, framerate);
 568         }
 569         else
 570         {
 571                 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
 572                         return;
 573                 MSG_WriteByte (&sv.datagram, svc_effect);
 574                 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
 575                 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
 576                 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 577                 MSG_WriteByte (&sv.datagram, modelindex);
 578                 MSG_WriteByte (&sv.datagram, startframe);
 579                 MSG_WriteByte (&sv.datagram, framecount);
 580                 MSG_WriteByte (&sv.datagram, framerate);
 581         }
 582         SV_FlushBroadcastMessages();
 583 }
 584
 585 /*
 586 ==================
 587 SV_StartSound
 588
 589 Each entity can have eight independant sound sources, like voice,
 590 weapon, feet, etc.
 591
 592 Channel 0 is an auto-allocate channel, the others override anything
 593 already running on that entity/channel pair.
 594
 595 An attenuation of 0 will play full volume everywhere in the level.
 596 Larger attenuations will drop off.  (max 4 attenuation)
 597
 598 ==================
 599 */
 600 void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation)
 601 {
 602         int sound_num, field_mask, i, ent;
 603
 604         if (volume < 0 || volume > 255)
 605         {
 606                 Con_Printf ("SV_StartSound: volume = %i\n", volume);
 607                 return;
 608         }
 609
 610         if (attenuation < 0 || attenuation > 4)
 611         {
 612                 Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
 613                 return;
 614         }
 615
 616         if (channel < 0 || channel > 7)
 617         {
 618                 Con_Printf ("SV_StartSound: channel = %i\n", channel);
 619                 return;
 620         }
 621
 622         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
 623                 return;
 624
 625 // find precache number for sound
 626         sound_num = SV_SoundIndex(sample, 1);
 627         if (!sound_num)
 628                 return;
 629
 630         ent = PRVM_NUM_FOR_EDICT(entity);
 631
 632         field_mask = 0;
 633         if (volume != DEFAULT_SOUND_PACKET_VOLUME)
 634                 field_mask |= SND_VOLUME;
 635         if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
 636                 field_mask |= SND_ATTENUATION;
 637         if (ent >= 8192)
 638                 field_mask |= SND_LARGEENTITY;
 639         if (sound_num >= 256 || channel >= 8)
 640                 field_mask |= SND_LARGESOUND;
 641
 642 // directed messages go only to the entity they are targeted on
 643         MSG_WriteByte (&sv.datagram, svc_sound);
 644         MSG_WriteByte (&sv.datagram, field_mask);
 645         if (field_mask & SND_VOLUME)
 646                 MSG_WriteByte (&sv.datagram, volume);
 647         if (field_mask & SND_ATTENUATION)
 648                 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
 649         if (field_mask & SND_LARGEENTITY)
 650         {
 651                 MSG_WriteShort (&sv.datagram, ent);
 652                 MSG_WriteByte (&sv.datagram, channel);
 653         }
 654         else
 655                 MSG_WriteShort (&sv.datagram, (ent<<3) | channel);
 656         if ((field_mask & SND_LARGESOUND) || sv.protocol == PROTOCOL_NEHAHRABJP2)
 657                 MSG_WriteShort (&sv.datagram, sound_num);
 658         else
 659                 MSG_WriteByte (&sv.datagram, sound_num);
 660         for (i = 0;i < 3;i++)
 661                 MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
 662         SV_FlushBroadcastMessages();
 663 }
 664
 665 /*
 666 ==================
 667 SV_StartPointSound
 668
 669 Nearly the same logic as SV_StartSound, except an origin
 670 instead of an entity is provided and channel is omitted.
 671
 672 The entity sent to the client is 0 (world) and the channel
 673 is 0 (CHAN_AUTO).  SND_LARGEENTITY will never occur in this
 674 function, therefore the check for it is omitted.
 675
 676 ==================
 677 */
 678 void SV_StartPointSound (vec3_t origin, const char *sample, int volume, float attenuation)
 679 {
 680         int sound_num, field_mask, i;
 681
 682         if (volume < 0 || volume > 255)
 683         {
 684                 Con_Printf ("SV_StartPointSound: volume = %i\n", volume);
 685                 return;
 686         }
 687
 688         if (attenuation < 0 || attenuation > 4)
 689         {
 690                 Con_Printf ("SV_StartPointSound: attenuation = %f\n", attenuation);
 691                 return;
 692         }
 693
 694         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
 695                 return;
 696
 697         // find precache number for sound
 698         sound_num = SV_SoundIndex(sample, 1);
 699         if (!sound_num)
 700                 return;
 701
 702         field_mask = 0;
 703         if (volume != DEFAULT_SOUND_PACKET_VOLUME)
 704                 field_mask |= SND_VOLUME;
 705         if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
 706                 field_mask |= SND_ATTENUATION;
 707         if (sound_num >= 256)
 708                 field_mask |= SND_LARGESOUND;
 709
 710 // directed messages go only to the entity they are targeted on
 711         MSG_WriteByte (&sv.datagram, svc_sound);
 712         MSG_WriteByte (&sv.datagram, field_mask);
 713         if (field_mask & SND_VOLUME)
 714                 MSG_WriteByte (&sv.datagram, volume);
 715         if (field_mask & SND_ATTENUATION)
 716                 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
 717         // Always write entnum 0 for the world entity
 718         MSG_WriteShort (&sv.datagram, (0<<3) | 0);
 719         if (field_mask & SND_LARGESOUND)
 720                 MSG_WriteShort (&sv.datagram, sound_num);
 721         else
 722                 MSG_WriteByte (&sv.datagram, sound_num);
 723         for (i = 0;i < 3;i++)
 724                 MSG_WriteCoord (&sv.datagram, origin[i], sv.protocol);
 725         SV_FlushBroadcastMessages();
 726 }
 727
 728 /*
 729 ==============================================================================
 730
 731 CLIENT SPAWNING
 732
 733 ==============================================================================
 734 */
 735
 736 /*
 737 ================
 738 SV_SendServerinfo
 739
 740 Sends the first message from the server to a connected client.
 741 This will be sent on the initial connection and upon each server load.
 742 ================
 743 */
 744 void SV_SendServerinfo (client_t *client)
 745 {
 746         int i;
 747         char message[128];
 748
 749         // we know that this client has a netconnection and thus is not a bot
 750
 751         // edicts get reallocated on level changes, so we need to update it here
 752         client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
 753
 754         // clear cached stuff that depends on the level
 755         client->weaponmodel[0] = 0;
 756         client->weaponmodelindex = 0;
 757
 758         // LordHavoc: clear entityframe tracking
 759         client->latestframenum = 0;
 760
 761         // initialize the movetime, so a speedhack can't make use of the time before this client joined
 762         client->cmd.time = sv.time;
 763
 764         if (client->entitydatabase)
 765                 EntityFrame_FreeDatabase(client->entitydatabase);
 766         if (client->entitydatabase4)
 767                 EntityFrame4_FreeDatabase(client->entitydatabase4);
 768         if (client->entitydatabase5)
 769                 EntityFrame5_FreeDatabase(client->entitydatabase5);
 770
 771         memset(client->stats, 0, sizeof(client->stats));
 772         memset(client->statsdeltabits, 0, sizeof(client->statsdeltabits));
 773
 774         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)
 775         {
 776                 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
 777                         client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
 778                 else if (sv.protocol == PROTOCOL_DARKPLACES4)
 779                         client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
 780                 else
 781                         client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
 782         }
 783
 784         // reset csqc entity versions
 785         for (i = 0;i < prog->max_edicts;i++)
 786         {
 787                 client->csqcentityscope[i] = 0;
 788                 client->csqcentitysendflags[i] = 0xFFFFFF;
 789                 client->csqcentityglobalhistory[i] = 0;
 790         }
 791         for (i = 0;i < NUM_CSQCENTITYDB_FRAMES;i++)
 792         {
 793                 client->csqcentityframehistory[i].num = 0;
 794                 client->csqcentityframehistory[i].framenum = -1;
 795         }
 796         client->csqcnumedicts = 0;
 797         client->csqcentityframehistory_next = 0;
 798
 799         SZ_Clear (&client->netconnection->message);
 800         MSG_WriteByte (&client->netconnection->message, svc_print);
 801         dpsnprintf (message, sizeof (message), "\nServer: %s build %s (progs %i crc)", gamename, buildstring, prog->filecrc);
 802         MSG_WriteString (&client->netconnection->message,message);
 803
 804         SV_StopDemoRecording(client); // to split up demos into different files
 805         if(sv_autodemo_perclient.integer && client->netconnection)
 806         {
 807                 char demofile[MAX_OSPATH];
 808                 char levelname[MAX_QPATH];
 809                 char ipaddress[MAX_QPATH];
 810                 size_t i;
 811
 812                 // start a new demo file
 813                 strlcpy(levelname, FS_FileWithoutPath(sv.worldmodel->name), sizeof(levelname));
 814                 if (strrchr(levelname, '.'))
 815                         *(strrchr(levelname, '.')) = 0;
 816
 817                 LHNETADDRESS_ToString(&(client->netconnection->peeraddress), ipaddress, sizeof(ipaddress), true);
 818                 for(i = 0; ipaddress[i]; ++i)
 819                         if(!isalnum(ipaddress[i]))
 820                                 ipaddress[i] = '-';
 821                 dpsnprintf (demofile, sizeof(demofile), "%s_%s_%d_%s.dem", Sys_TimeString (sv_autodemo_perclient_nameformat.string), levelname, PRVM_NUM_FOR_EDICT(client->edict), ipaddress);
 822
 823                 SV_StartDemoRecording(client, demofile, -1);
 824         }
 825
 826         //[515]: init csprogs according to version of svprogs, check the crc, etc.
 827         if (sv.csqc_progname[0])
 828         {
 829                 prvm_eval_t *val;
 830                 Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
 831                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 832                 MSG_WriteString (&client->netconnection->message, va("csqc_progname %s\n", sv.csqc_progname));
 833                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 834                 MSG_WriteString (&client->netconnection->message, va("csqc_progsize %i\n", sv.csqc_progsize));
 835                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 836                 MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i\n", sv.csqc_progcrc));
 837
 838                 if(client->sv_demo_file != NULL)
 839                 {
 840                         int i;
 841                         char buf[NET_MAXMESSAGE];
 842                         sizebuf_t sb;
 843
 844                         sb.data = (unsigned char *) buf;
 845                         sb.maxsize = sizeof(buf);
 846                         i = 0;
 847                         while(MakeDownloadPacket(sv.csqc_progname, svs.csqc_progdata, sv.csqc_progsize, sv.csqc_progcrc, i++, &sb, sv.protocol))
 848                                 SV_WriteDemoMessage(client, &sb, false);
 849                 }
 850
 851                 //[515]: init stufftext string (it is sent before svc_serverinfo)
 852                 val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.SV_InitCmd);
 853                 if (val)
 854                 {
 855                         MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 856                         MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(val->string)));
 857                 }
 858         }
 859
 860         //if (sv_allowdownloads.integer)
 861         // always send the info that the server supports the protocol, even if downloads are forbidden
 862         // only because of that, the CSQC exception can work
 863         {
 864                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
 865                 MSG_WriteString (&client->netconnection->message, "cl_serverextension_download 2\n");
 866         }
 867
 868         // send at this time so it's guaranteed to get executed at the right time
 869         {
 870                 client_t *save;
 871                 save = host_client;
 872                 host_client = client;
 873                 Curl_SendRequirements();
 874                 host_client = save;
 875         }
 876
 877         MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
 878         MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
 879         MSG_WriteByte (&client->netconnection->message, svs.maxclients);
 880
 881         if (!coop.integer && deathmatch.integer)
 882                 MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
 883         else
 884                 MSG_WriteByte (&client->netconnection->message, GAME_COOP);
 885
 886         MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
 887
 888         for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
 889                 MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
 890         MSG_WriteByte (&client->netconnection->message, 0);
 891
 892         for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
 893                 MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
 894         MSG_WriteByte (&client->netconnection->message, 0);
 895
 896 // send music
 897         MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
 898         MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
 899         MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
 900
 901 // set view
 902 // store this in clientcamera, too
 903         client->clientcamera = PRVM_NUM_FOR_EDICT(client->edict);
 904         MSG_WriteByte (&client->netconnection->message, svc_setview);
 905         MSG_WriteShort (&client->netconnection->message, client->clientcamera);
 906
 907         MSG_WriteByte (&client->netconnection->message, svc_signonnum);
 908         MSG_WriteByte (&client->netconnection->message, 1);
 909
 910         client->spawned = false;                // need prespawn, spawn, etc
 911         client->sendsignon = 1;                 // send this message, and increment to 2, 2 will be set to 0 by the prespawn command
 912
 913         // clear movement info until client enters the new level properly
 914         memset(&client->cmd, 0, sizeof(client->cmd));
 915         client->movesequence = 0;
 916 #ifdef NUM_PING_TIMES
 917         for (i = 0;i < NUM_PING_TIMES;i++)
 918                 client->ping_times[i] = 0;
 919         client->num_pings = 0;
 920 #endif
 921         client->ping = 0;
 922
 923         // allow the client some time to send his keepalives, even if map loading took ages
 924         client->netconnection->timeout = realtime + net_connecttimeout.value;
 925 }
 926
 927 /*
 928 ================
 929 SV_ConnectClient
 930
 931 Initializes a client_t for a new net connection.  This will only be called
 932 once for a player each game, not once for each level change.
 933 ================
 934 */
 935 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
 936 {
 937         client_t                *client;
 938         int                             i;
 939         float                   spawn_parms[NUM_SPAWN_PARMS];
 940
 941         client = svs.clients + clientnum;
 942
 943 // set up the client_t
 944         if (sv.loadgame)
 945                 memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
 946         memset (client, 0, sizeof(*client));
 947         client->active = true;
 948         client->netconnection = netconnection;
 949
 950         Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
 951
 952         strlcpy(client->name, "unconnected", sizeof(client->name));
 953         strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
 954         client->spawned = false;
 955         client->edict = PRVM_EDICT_NUM(clientnum+1);
 956         if (client->netconnection)
 957                 client->netconnection->message.allowoverflow = true;            // we can catch it
 958         // prepare the unreliable message buffer
 959         client->unreliablemsg.data = client->unreliablemsg_data;
 960         client->unreliablemsg.maxsize = sizeof(client->unreliablemsg_data);
 961         // updated by receiving "rate" command from client, this is also the default if not using a DP client
 962         client->rate = 1000000000;
 963         // no limits for local player
 964         if (client->netconnection && LHNETADDRESS_GetAddressType(&client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP)
 965                 client->rate = 1000000000;
 966         client->connecttime = realtime;
 967
 968         if (sv.loadgame)
 969                 memcpy (client->spawn_parms, spawn_parms, sizeof(spawn_parms));
 970         else
 971         {
 972                 // call the progs to get default spawn parms for the new client
 973                 // set self to world to intentionally cause errors with broken SetNewParms code in some mods
 974                 prog->globals.server->self = 0;
 975                 PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
 976                 for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
 977                         client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
 978
 979                 // set up the entity for this client (including .colormap, .team, etc)
 980                 PRVM_ED_ClearEdict(client->edict);
 981         }
 982
 983         // don't call SendServerinfo for a fresh botclient because its fields have
 984         // not been set up by the qc yet
 985         if (client->netconnection)
 986                 SV_SendServerinfo (client);
 987         else
 988                 client->spawned = true;
 989 }
 990
 991
 992 /*
 993 ===============================================================================
 994
 995 FRAME UPDATES
 996
 997 ===============================================================================
 998 */
 999
1000 /*
1001 =============================================================================
1002
1003 The PVS must include a small area around the client to allow head bobbing
1004 or other small motion on the client side.  Otherwise, a bob might cause an
1005 entity that should be visible to not show up, especially when the bob
1006 crosses a waterline.
1007
1008 =============================================================================
1009 */
1010
1011 static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int enumber)
1012 {
1013         int i;
1014         unsigned int sendflags;
1015         unsigned int version;
1016         unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
1017         unsigned int customizeentityforclient;
1018         unsigned int sendentity;
1019         float f;
1020         vec3_t cullmins, cullmaxs;
1021         dp_model_t *model;
1022         prvm_eval_t *val, *val2;
1023
1024         // fast path for games that do not use legacy entity networking
1025         // note: still networks clients even if they are legacy
1026         sendentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.SendEntity)->function;
1027         if (sv_onlycsqcnetworking.integer && !sendentity && enumber > svs.maxclients)
1028                 return false;
1029
1030         // this 2 billion unit check is actually to detect NAN origins
1031         // (we really don't want to send those)
1032         if (!(VectorLength2(ent->fields.server->origin) < 2000000000.0*2000000000.0))
1033                 return false;
1034
1035         // EF_NODRAW prevents sending for any reason except for your own
1036         // client, so we must keep all clients in this superset
1037         effects = (unsigned)ent->fields.server->effects;
1038
1039         // we can omit invisible entities with no effects that are not clients
1040         // LordHavoc: this could kill tags attached to an invisible entity, I
1041         // just hope we never have to support that case
1042         i = (int)ent->fields.server->modelindex;
1043         modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model)) ? i : 0;
1044
1045         flags = 0;
1046         i = (int)(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_size)->_float * 0.25f);
1047         glowsize = (unsigned char)bound(0, i, 255);
1048         if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->_float)
1049                 flags |= RENDER_GLOWTRAIL;
1050         if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict)
1051                 flags |= RENDER_VIEWMODEL;
1052
1053         f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[0]*256;
1054         light[0] = (unsigned short)bound(0, f, 65535);
1055         f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[1]*256;
1056         light[1] = (unsigned short)bound(0, f, 65535);
1057         f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[2]*256;
1058         light[2] = (unsigned short)bound(0, f, 65535);
1059         f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.light_lev)->_float;
1060         light[3] = (unsigned short)bound(0, f, 65535);
1061         lightstyle = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.style)->_float;
1062         lightpflags = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pflags)->_float;
1063
1064         if (gamemode == GAME_TENEBRAE)
1065         {
1066                 // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
1067                 if (effects & 16)
1068                 {
1069                         effects &= ~16;
1070                         lightpflags |= PFLAGS_FULLDYNAMIC;
1071                 }
1072                 // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
1073                 if (effects & 32)
1074                 {
1075                         effects &= ~32;
1076                         light[0] = (int)(0.2*256);
1077                         light[1] = (int)(1.0*256);
1078                         light[2] = (int)(0.2*256);
1079                         light[3] = 200;
1080                         lightpflags |= PFLAGS_FULLDYNAMIC;
1081                 }
1082         }
1083
1084         specialvisibilityradius = 0;
1085         if (lightpflags & PFLAGS_FULLDYNAMIC)
1086                 specialvisibilityradius = max(specialvisibilityradius, light[3]);
1087         if (glowsize)
1088                 specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
1089         if (flags & RENDER_GLOWTRAIL)
1090                 specialvisibilityradius = max(specialvisibilityradius, 100);
1091         if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
1092         {
1093                 if (effects & EF_BRIGHTFIELD)
1094                         specialvisibilityradius = max(specialvisibilityradius, 80);
1095                 if (effects & EF_MUZZLEFLASH)
1096                         specialvisibilityradius = max(specialvisibilityradius, 100);
1097                 if (effects & EF_BRIGHTLIGHT)
1098                         specialvisibilityradius = max(specialvisibilityradius, 400);
1099                 if (effects & EF_DIMLIGHT)
1100                         specialvisibilityradius = max(specialvisibilityradius, 200);
1101                 if (effects & EF_RED)
1102                         specialvisibilityradius = max(specialvisibilityradius, 200);
1103                 if (effects & EF_BLUE)
1104                         specialvisibilityradius = max(specialvisibilityradius, 200);
1105                 if (effects & EF_FLAME)
1106                         specialvisibilityradius = max(specialvisibilityradius, 250);
1107                 if (effects & EF_STARDUST)
1108                         specialvisibilityradius = max(specialvisibilityradius, 100);
1109         }
1110
1111         // early culling checks
1112         // (final culling is done by SV_MarkWriteEntityStateToClient)
1113         customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function;
1114         if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
1115                 return false;
1116
1117         *cs = defaultstate;
1118         cs->active = ACTIVE_NETWORK;
1119         cs->number = enumber;
1120         VectorCopy(ent->fields.server->origin, cs->origin);
1121         VectorCopy(ent->fields.server->angles, cs->angles);
1122         cs->flags = flags;
1123         cs->effects = effects;
1124         cs->colormap = (unsigned)ent->fields.server->colormap;
1125         cs->modelindex = modelindex;
1126         cs->skin = (unsigned)ent->fields.server->skin;
1127         cs->frame = (unsigned)ent->fields.server->frame;
1128         cs->viewmodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict;
1129         cs->exteriormodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.exteriormodeltoclient)->edict;
1130         cs->nodrawtoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict;
1131         cs->drawonlytoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict;
1132         cs->customizeentityforclient = customizeentityforclient;
1133         cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict;
1134         cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
1135         cs->glowsize = glowsize;
1136
1137         // don't need to init cs->colormod because the defaultstate did that for us
1138         //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
1139         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod);
1140         if (val->vector[0] || val->vector[1] || val->vector[2])
1141         {
1142                 i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
1143                 i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
1144                 i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
1145         }
1146
1147         // don't need to init cs->glowmod because the defaultstate did that for us
1148         //cs->glowmod[0] = cs->glowmod[1] = cs->glowmod[2] = 32;
1149         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glowmod);
1150         if (val->vector[0] || val->vector[1] || val->vector[2])
1151         {
1152                 i = (int)(val->vector[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);
1153                 i = (int)(val->vector[1] * 32.0f);cs->glowmod[1] = bound(0, i, 255);
1154                 i = (int)(val->vector[2] * 32.0f);cs->glowmod[2] = bound(0, i, 255);
1155         }
1156
1157         cs->modelindex = modelindex;
1158
1159         cs->alpha = 255;
1160         f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f);
1161         if (f)
1162         {
1163                 i = (int)f;
1164                 cs->alpha = (unsigned char)bound(0, i, 255);
1165         }
1166         // halflife
1167         f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float);
1168         if (f)
1169         {
1170                 i = (int)f;
1171                 cs->alpha = (unsigned char)bound(0, i, 255);
1172         }
1173
1174         cs->scale = 16;
1175         f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f);
1176         if (f)
1177         {
1178                 i = (int)f;
1179                 cs->scale = (unsigned char)bound(0, i, 255);
1180         }
1181
1182         cs->glowcolor = 254;
1183         f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float);
1184         if (f)
1185                 cs->glowcolor = (int)f;
1186
1187         if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float)
1188                 cs->effects |= EF_FULLBRIGHT;
1189
1190         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.modelflags);
1191         if (val && val->_float)
1192                 cs->effects |= ((unsigned int)val->_float & 0xff) << 24;
1193
1194         if (ent->fields.server->movetype == MOVETYPE_STEP)
1195                 cs->flags |= RENDER_STEP;
1196         if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767)
1197                 cs->flags |= RENDER_LOWPRECISION;
1198         if (ent->fields.server->colormap >= 1024)
1199                 cs->flags |= RENDER_COLORMAPPED;
1200         if (cs->viewmodelforclient)
1201                 cs->flags |= RENDER_VIEWMODEL; // show relative to the view
1202
1203         cs->light[0] = light[0];
1204         cs->light[1] = light[1];
1205         cs->light[2] = light[2];
1206         cs->light[3] = light[3];
1207         cs->lightstyle = lightstyle;
1208         cs->lightpflags = lightpflags;
1209
1210         cs->specialvisibilityradius = specialvisibilityradius;
1211
1212         // calculate the visible box of this entity (don't use the physics box
1213         // as that is often smaller than a model, and would not count
1214         // specialvisibilityradius)
1215         if ((model = sv.models[modelindex]) && (model->type != mod_null))
1216         {
1217                 float scale = cs->scale * (1.0f / 16.0f);
1218                 if (cs->angles[0] || cs->angles[2]) // pitch and roll
1219                 {
1220                         VectorMA(cs->origin, scale, model->rotatedmins, cullmins);
1221                         VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs);
1222                 }
1223                 else if (cs->angles[1])
1224                 {
1225                         VectorMA(cs->origin, scale, model->yawmins, cullmins);
1226                         VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs);
1227                 }
1228                 else
1229                 {
1230                         VectorMA(cs->origin, scale, model->normalmins, cullmins);
1231                         VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs);
1232                 }
1233         }
1234         else
1235         {
1236                 // if there is no model (or it could not be loaded), use the physics box
1237                 VectorAdd(cs->origin, ent->fields.server->mins, cullmins);
1238                 VectorAdd(cs->origin, ent->fields.server->maxs, cullmaxs);
1239         }
1240         if (specialvisibilityradius)
1241         {
1242                 cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius);
1243                 cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius);
1244                 cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius);
1245                 cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius);
1246                 cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius);
1247                 cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius);
1248         }
1249
1250         // calculate center of bbox for network prioritization purposes
1251         VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, cs->netcenter);
1252
1253         // if culling box has moved, update pvs cluster links
1254         if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
1255         {
1256                 VectorCopy(cullmins, ent->priv.server->cullmins);
1257                 VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
1258                 // a value of -1 for pvs_numclusters indicates that the links are not
1259                 // cached, and should be re-tested each time, this is the case if the
1260                 // culling box touches too many pvs clusters to store, or if the world
1261                 // model does not support FindBoxClusters
1262                 ent->priv.server->pvs_numclusters = -1;
1263                 if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
1264                 {
1265                         i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
1266                         if (i <= MAX_ENTITYCLUSTERS)
1267                                 ent->priv.server->pvs_numclusters = i;
1268                 }
1269         }
1270
1271         // we need to do some csqc entity upkeep here
1272         // get self.SendFlags and clear them
1273         // (to let the QC know that they've been read)
1274         if (sendentity)
1275         {
1276                 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.SendFlags);
1277                 sendflags = (unsigned int)val->_float;
1278                 val->_float = 0;
1279                 // legacy self.Version system
1280                 val2 = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.Version);
1281                 if (val2->_float)
1282                 {
1283                         version = (unsigned int)val2->_float;
1284                         if (sv.csqcentityversion[enumber] != version)
1285                                 sendflags = 0xFFFFFF;
1286                         sv.csqcentityversion[enumber] = version;
1287                 }
1288                 // move sendflags into the per-client sendflags
1289                 if (sendflags)
1290                         for (i = 0;i < svs.maxclients;i++)
1291                                 svs.clients[i].csqcentitysendflags[enumber] |= sendflags;
1292                 // mark it as inactive for non-csqc networking
1293                 cs->active = ACTIVE_SHARED;
1294         }
1295
1296         return true;
1297 }
1298
1299 void SV_PrepareEntitiesForSending(void)
1300 {
1301         int e;
1302         prvm_edict_t *ent;
1303         // send all entities that touch the pvs
1304         sv.numsendentities = 0;
1305         sv.sendentitiesindex[0] = NULL;
1306         memset(sv.sendentitiesindex, 0, prog->num_edicts * sizeof(*sv.sendentitiesindex));
1307         for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent))
1308         {
1309                 if (!ent->priv.server->free && SV_PrepareEntityForSending(ent, sv.sendentities + sv.numsendentities, e))
1310                 {
1311                         sv.sendentitiesindex[e] = sv.sendentities + sv.numsendentities;
1312                         sv.numsendentities++;
1313                 }
1314         }
1315 }
1316
1317 void SV_MarkWriteEntityStateToClient(entity_state_t *s)
1318 {
1319         int isbmodel;
1320         dp_model_t *model;
1321         prvm_edict_t *ed;
1322         if (sv.sententitiesconsideration[s->number] == sv.sententitiesmark)
1323                 return;
1324         sv.sententitiesconsideration[s->number] = sv.sententitiesmark;
1325         sv.writeentitiestoclient_stats_totalentities++;
1326
1327         if (s->customizeentityforclient)
1328         {
1329                 prog->globals.server->self = s->number;
1330                 prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
1331                 PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
1332                 if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
1333                         return;
1334         }
1335
1336         // never reject player
1337         if (s->number != sv.writeentitiestoclient_cliententitynumber)
1338         {
1339                 // check various rejection conditions
1340                 if (s->nodrawtoclient == sv.writeentitiestoclient_cliententitynumber)
1341                         return;
1342                 if (s->drawonlytoclient && s->drawonlytoclient != sv.writeentitiestoclient_cliententitynumber)
1343                         return;
1344                 if (s->effects & EF_NODRAW)
1345                         return;
1346                 // LordHavoc: only send entities with a model or important effects
1347                 if (!s->modelindex && s->specialvisibilityradius == 0)
1348                         return;
1349
1350                 isbmodel = (model = sv.models[s->modelindex]) != NULL && model->name[0] == '*';
1351                 // viewmodels don't have visibility checking
1352                 if (s->viewmodelforclient)
1353                 {
1354                         if (s->viewmodelforclient != sv.writeentitiestoclient_cliententitynumber)
1355                                 return;
1356                 }
1357                 else if (s->tagentity)
1358                 {
1359                         // tag attached entities simply check their parent
1360                         if (!sv.sendentitiesindex[s->tagentity])
1361                                 return;
1362                         SV_MarkWriteEntityStateToClient(sv.sendentitiesindex[s->tagentity]);
1363                         if (sv.sententities[s->tagentity] != sv.sententitiesmark)
1364                                 return;
1365                 }
1366                 // always send world submodels in newer protocols because they don't
1367                 // generate much traffic (in old protocols they hog bandwidth)
1368                 // but only if sv_cullentities_nevercullbmodels is off
1369                 else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE))
1370                 {
1371                         // entity has survived every check so far, check if visible
1372                         ed = PRVM_EDICT_NUM(s->number);
1373
1374                         // if not touching a visible leaf
1375                         if (sv_cullentities_pvs.integer && !r_novis.integer && sv.writeentitiestoclient_pvsbytes)
1376                         {
1377                                 if (ed->priv.server->pvs_numclusters < 0)
1378                                 {
1379                                         // entity too big for clusters list
1380                                         if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
1381                                         {
1382                                                 sv.writeentitiestoclient_stats_culled_pvs++;
1383                                                 return;
1384                                         }
1385                                 }
1386                                 else
1387                                 {
1388                                         int i;
1389                                         // check cached clusters list
1390                                         for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
1391                                                 if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
1392                                                         break;
1393                                         if (i == ed->priv.server->pvs_numclusters)
1394                                         {
1395                                                 sv.writeentitiestoclient_stats_culled_pvs++;
1396                                                 return;
1397                                         }
1398                                 }
1399                         }
1400
1401                         // or not seen by random tracelines
1402                         if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel->brush.TraceLineOfSight)
1403                         {
1404                                 int samples =
1405                                         s->number <= svs.maxclients
1406                                                 ? sv_cullentities_trace_samples_players.integer
1407                                                 :
1408                                         s->specialvisibilityradius
1409                                                 ? sv_cullentities_trace_samples_extra.integer
1410                                                 : sv_cullentities_trace_samples.integer;
1411                                 float enlarge = sv_cullentities_trace_enlarge.value;
1412
1413                                 qboolean visible = TRUE;
1414
1415                                 if(samples > 0)
1416                                 {
1417                                         do
1418                                         {
1419                                                 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, sv.writeentitiestoclient_testeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
1420                                                         break; // directly visible from the server's view
1421
1422                                                 if(sv_cullentities_trace_prediction.integer)
1423                                                 {
1424                                                         vec3_t predeye;
1425
1426                                                         // get player velocity
1427                                                         float predtime = bound(0, host_client->ping, 0.2); // / 2
1428                                                                 // sorry, no wallhacking by high ping please, and at 200ms
1429                                                                 // ping a FPS is annoying to play anyway and a player is
1430                                                                 // likely to have changed his direction
1431                                                         VectorMA(sv.writeentitiestoclient_testeye, predtime, host_client->edict->fields.server->velocity, predeye);
1432                                                         if(sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, sv.writeentitiestoclient_testeye, predeye)) // must be able to go there...
1433                                                         {
1434                                                                 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, predeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
1435                                                                         break; // directly visible from the predicted view
1436                                                         }
1437                                                         else
1438                                                         {
1439                                                                 //Con_DPrintf("Trying to walk into solid in a pingtime... not predicting for culling\n");
1440                                                         }
1441                                                 }
1442
1443                                                 // when we get here, we can't see the entity
1444                                                 visible = false;
1445                                         }
1446                                         while(0);
1447
1448                                         if(visible)
1449                                                 svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number] =
1450                                                         realtime + (
1451                                                                 s->number <= svs.maxclients
1452                                                                         ? sv_cullentities_trace_delay_players.value
1453                                                                         : sv_cullentities_trace_delay.value
1454                                                         );
1455                                         else if (realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number])
1456                                         {
1457                                                 sv.writeentitiestoclient_stats_culled_trace++;
1458                                                 return;
1459                                         }
1460                                 }
1461                         }
1462                 }
1463         }
1464
1465         // this just marks it for sending
1466         // FIXME: it would be more efficient to send here, but the entity
1467         // compressor isn't that flexible
1468         sv.writeentitiestoclient_stats_visibleentities++;
1469         sv.sententities[s->number] = sv.sententitiesmark;
1470 }
1471
1472 void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int maxsize)
1473 {
1474         qboolean need_empty = false;
1475         int i, numsendstates, numcsqcsendstates;
1476         entity_state_t *s;
1477         prvm_edict_t *camera;
1478         qboolean success;
1479
1480         // if there isn't enough space to accomplish anything, skip it
1481         if (msg->cursize + 25 > maxsize)
1482                 return;
1483
1484         sv.writeentitiestoclient_msg = msg;
1485         sv.writeentitiestoclient_clientnumber = client - svs.clients;
1486
1487         sv.writeentitiestoclient_stats_culled_pvs = 0;
1488         sv.writeentitiestoclient_stats_culled_trace = 0;
1489         sv.writeentitiestoclient_stats_visibleentities = 0;
1490         sv.writeentitiestoclient_stats_totalentities = 0;
1491
1492 // find the client's PVS
1493         // the real place being tested from
1494         camera = PRVM_EDICT_NUM( client->clientcamera );
1495         VectorAdd(camera->fields.server->origin, clent->fields.server->view_ofs, sv.writeentitiestoclient_testeye);
1496         sv.writeentitiestoclient_pvsbytes = 0;
1497         if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
1498                 sv.writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv.writeentitiestoclient_testeye, 8, sv.writeentitiestoclient_pvs, sizeof(sv.writeentitiestoclient_pvs), false);
1499
1500         sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
1501
1502         sv.sententitiesmark++;
1503
1504         for (i = 0;i < sv.numsendentities;i++)
1505                 SV_MarkWriteEntityStateToClient(sv.sendentities + i);
1506
1507         numsendstates = 0;
1508         numcsqcsendstates = 0;
1509         for (i = 0;i < sv.numsendentities;i++)
1510         {
1511                 if (sv.sententities[sv.sendentities[i].number] == sv.sententitiesmark)
1512                 {
1513                         if(sv.sendentities[i].active == ACTIVE_NETWORK)
1514                         {
1515                                 s = &sv.writeentitiestoclient_sendstates[numsendstates++];
1516                                 *s = sv.sendentities[i];
1517                                 if (s->exteriormodelforclient && s->exteriormodelforclient == sv.writeentitiestoclient_cliententitynumber)
1518                                         s->flags |= RENDER_EXTERIORMODEL;
1519                         }
1520                         else if(sv.sendentities[i].active == ACTIVE_SHARED)
1521                                 sv.writeentitiestoclient_csqcsendstates[numcsqcsendstates++] = sv.sendentities[i].number;
1522                         else
1523                                 Con_Printf("entity %d is in sv.sendentities and marked, but not active, please breakpoint me\n", sv.sendentities[i].number);
1524                 }
1525         }
1526
1527         if (sv_cullentities_stats.integer)
1528                 Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, sv.writeentitiestoclient_stats_totalentities, sv.writeentitiestoclient_stats_visibleentities, sv.writeentitiestoclient_stats_culled_pvs + sv.writeentitiestoclient_stats_culled_trace, sv.writeentitiestoclient_stats_culled_pvs, sv.writeentitiestoclient_stats_culled_trace);
1529
1530         if(client->entitydatabase5)
1531                 need_empty = EntityFrameCSQC_WriteFrame(msg, maxsize, numcsqcsendstates, sv.writeentitiestoclient_csqcsendstates, client->entitydatabase5->latestframenum + 1);
1532         else
1533                 EntityFrameCSQC_WriteFrame(msg, maxsize, numcsqcsendstates, sv.writeentitiestoclient_csqcsendstates, 0);
1534
1535         if(client->num_skippedentityframes >= 10)
1536                 need_empty = true; // force every 10th frame to be not empty (or cl_movement replay takes too long)
1537
1538         if (client->entitydatabase5)
1539                 success = EntityFrame5_WriteFrame(msg, maxsize, client->entitydatabase5, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1, client->movesequence, need_empty);
1540         else if (client->entitydatabase4)
1541         {
1542                 success = EntityFrame4_WriteFrame(msg, maxsize, client->entitydatabase4, numsendstates, sv.writeentitiestoclient_sendstates);
1543                 Protocol_WriteStatsReliable();
1544         }
1545         else if (client->entitydatabase)
1546         {
1547                 success = EntityFrame_WriteFrame(msg, maxsize, client->entitydatabase, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1);
1548                 Protocol_WriteStatsReliable();
1549         }
1550         else
1551         {
1552                 success = EntityFrameQuake_WriteFrame(msg, maxsize, numsendstates, sv.writeentitiestoclient_sendstates);
1553                 Protocol_WriteStatsReliable();
1554         }
1555
1556         if(success)
1557                 client->num_skippedentityframes = 0;
1558         else
1559                 ++client->num_skippedentityframes;
1560 }
1561
1562 /*
1563 =============
1564 SV_CleanupEnts
1565
1566 =============
1567 */
1568 static void SV_CleanupEnts (void)
1569 {
1570         int             e;
1571         prvm_edict_t    *ent;
1572
1573         ent = PRVM_NEXT_EDICT(prog->edicts);
1574         for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
1575                 ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
1576 }
1577
1578 /*
1579 ==================
1580 SV_WriteClientdataToMessage
1581
1582 ==================
1583 */
1584 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1585 {
1586         int             bits;
1587         int             i;
1588         prvm_edict_t    *other;
1589         int             items;
1590         prvm_eval_t     *val;
1591         vec3_t  punchvector;
1592         int             viewzoom;
1593         const char *s;
1594         float   *statsf = (float *)stats;
1595
1596 //
1597 // send a damage message
1598 //
1599         if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
1600         {
1601                 other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
1602                 MSG_WriteByte (msg, svc_damage);
1603                 MSG_WriteByte (msg, (int)ent->fields.server->dmg_save);
1604                 MSG_WriteByte (msg, (int)ent->fields.server->dmg_take);
1605                 for (i=0 ; i<3 ; i++)
1606                         MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
1607
1608                 ent->fields.server->dmg_take = 0;
1609                 ent->fields.server->dmg_save = 0;
1610         }
1611
1612 //
1613 // send the current viewpos offset from the view entity
1614 //
1615         SV_SetIdealPitch ();            // how much to look up / down ideally
1616
1617 // a fixangle might get lost in a dropped packet.  Oh well.
1618         if(ent->fields.server->fixangle)
1619         {
1620                 // angle fixing was requested by global thinking code...
1621                 // so store the current angles for later use
1622                 memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
1623                 host_client->fixangle_angles_set = TRUE;
1624
1625                 // and clear fixangle for the next frame
1626                 ent->fields.server->fixangle = 0;
1627         }
1628
1629         if (host_client->fixangle_angles_set)
1630         {
1631                 MSG_WriteByte (msg, svc_setangle);
1632                 for (i=0 ; i < 3 ; i++)
1633                         MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
1634                 host_client->fixangle_angles_set = FALSE;
1635         }
1636
1637         // stuff the sigil bits into the high bits of items for sbar, or else
1638         // mix in items2
1639         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.items2);
1640         if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1641                 items = (int)ent->fields.server->items | ((int)val->_float << 23);
1642         else
1643                 items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
1644
1645         VectorClear(punchvector);
1646         if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.punchvector)))
1647                 VectorCopy(val->vector, punchvector);
1648
1649         // cache weapon model name and index in client struct to save time
1650         // (this search can be almost 1% of cpu time!)
1651         s = PRVM_GetString(ent->fields.server->weaponmodel);
1652         if (strcmp(s, client->weaponmodel))
1653         {
1654                 strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
1655                 client->weaponmodelindex = SV_ModelIndex(s, 1);
1656         }
1657
1658         viewzoom = 255;
1659         if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewzoom)))
1660                 viewzoom = (int)(val->_float * 255.0f);
1661         if (viewzoom == 0)
1662                 viewzoom = 255;
1663
1664         bits = 0;
1665
1666         if ((int)ent->fields.server->flags & FL_ONGROUND)
1667                 bits |= SU_ONGROUND;
1668         if (ent->fields.server->waterlevel >= 2)
1669                 bits |= SU_INWATER;
1670         if (ent->fields.server->idealpitch)
1671                 bits |= SU_IDEALPITCH;
1672
1673         for (i=0 ; i<3 ; i++)
1674         {
1675                 if (ent->fields.server->punchangle[i])
1676                         bits |= (SU_PUNCH1<<i);
1677                 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)
1678                         if (punchvector[i])
1679                                 bits |= (SU_PUNCHVEC1<<i);
1680                 if (ent->fields.server->velocity[i])
1681                         bits |= (SU_VELOCITY1<<i);
1682         }
1683
1684         memset(stats, 0, sizeof(int[MAX_CL_STATS]));
1685         stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];
1686         stats[STAT_ITEMS] = items;
1687         stats[STAT_WEAPONFRAME] = (int)ent->fields.server->weaponframe;
1688         stats[STAT_ARMOR] = (int)ent->fields.server->armorvalue;
1689         stats[STAT_WEAPON] = client->weaponmodelindex;
1690         stats[STAT_HEALTH] = (int)ent->fields.server->health;
1691         stats[STAT_AMMO] = (int)ent->fields.server->currentammo;
1692         stats[STAT_SHELLS] = (int)ent->fields.server->ammo_shells;
1693         stats[STAT_NAILS] = (int)ent->fields.server->ammo_nails;
1694         stats[STAT_ROCKETS] = (int)ent->fields.server->ammo_rockets;
1695         stats[STAT_CELLS] = (int)ent->fields.server->ammo_cells;
1696         stats[STAT_ACTIVEWEAPON] = (int)ent->fields.server->weapon;
1697         stats[STAT_VIEWZOOM] = viewzoom;
1698         stats[STAT_TOTALSECRETS] = (int)prog->globals.server->total_secrets;
1699         stats[STAT_TOTALMONSTERS] = (int)prog->globals.server->total_monsters;
1700         // the QC bumps these itself by sending svc_'s, so we have to keep them
1701         // zero or they'll be corrected by the engine
1702         //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
1703         //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
1704
1705         // movement settings for prediction
1706         // note: these are not sent in protocols with lower MAX_CL_STATS limits
1707         stats[STAT_MOVEFLAGS] = MOVEFLAG_VALID
1708                 | (sv_gameplayfix_q2airaccelerate.integer ? MOVEFLAG_Q2AIRACCELERATE : 0)
1709         ;
1710         statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
1711         statsf[STAT_MOVEVARS_TIMESCALE] = slowmo.value;
1712         statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
1713         statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
1714         statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
1715         statsf[STAT_MOVEVARS_SPECTATORMAXSPEED] = sv_maxspeed.value; // FIXME: QW has a separate cvar for this
1716         statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
1717         statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
1718         statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
1719         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.gravity);
1720         statsf[STAT_MOVEVARS_ENTGRAVITY] = (val && val->_float != 0) ? val->_float : 1.0f;
1721         statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
1722         statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
1723         statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
1724         statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
1725         statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
1726         statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
1727         statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value;
1728         statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
1729         statsf[STAT_MOVEVARS_AIRSTOPACCELERATE] = sv_airstopaccelerate.value;
1730         statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE] = sv_airstrafeaccelerate.value;
1731         statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED] = sv_maxairstrafespeed.value;
1732         statsf[STAT_MOVEVARS_AIRCONTROL] = sv_aircontrol.value;
1733         statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL] = sv_warsowbunny_airforwardaccel.value;
1734         statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL] = sv_warsowbunny_accel.value;
1735         statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED] = sv_warsowbunny_topspeed.value;
1736         statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL] = sv_warsowbunny_turnaccel.value;
1737         statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO] = sv_warsowbunny_backtosideratio.value;
1738         statsf[STAT_FRAGLIMIT] = fraglimit.value;
1739         statsf[STAT_TIMELIMIT] = timelimit.value;
1740
1741         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1742         {
1743                 if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
1744                 bits |= SU_ITEMS;
1745                 if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
1746                 if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
1747                 bits |= SU_WEAPON;
1748                 // FIXME: which protocols support this?  does PROTOCOL_DARKPLACES3 support viewzoom?
1749                 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1750                         if (viewzoom != 255)
1751                                 bits |= SU_VIEWZOOM;
1752         }
1753
1754         if (bits >= 65536)
1755                 bits |= SU_EXTEND1;
1756         if (bits >= 16777216)
1757                 bits |= SU_EXTEND2;
1758
1759         // send the data
1760         MSG_WriteByte (msg, svc_clientdata);
1761         MSG_WriteShort (msg, bits);
1762         if (bits & SU_EXTEND1)
1763                 MSG_WriteByte(msg, bits >> 16);
1764         if (bits & SU_EXTEND2)
1765                 MSG_WriteByte(msg, bits >> 24);
1766
1767         if (bits & SU_VIEWHEIGHT)
1768                 MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
1769
1770         if (bits & SU_IDEALPITCH)
1771                 MSG_WriteChar (msg, (int)ent->fields.server->idealpitch);
1772
1773         for (i=0 ; i<3 ; i++)
1774         {
1775                 if (bits & (SU_PUNCH1<<i))
1776                 {
1777                         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)
1778                                 MSG_WriteChar(msg, (int)ent->fields.server->punchangle[i]);
1779                         else
1780                                 MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
1781                 }
1782                 if (bits & (SU_PUNCHVEC1<<i))
1783                 {
1784                         if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1785                                 MSG_WriteCoord16i(msg, punchvector[i]);
1786                         else
1787                                 MSG_WriteCoord32f(msg, punchvector[i]);
1788                 }
1789                 if (bits & (SU_VELOCITY1<<i))
1790                 {
1791                         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1792                                 MSG_WriteChar(msg, (int)(ent->fields.server->velocity[i] * (1.0f / 16.0f)));
1793                         else
1794                                 MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
1795                 }
1796         }
1797
1798         if (bits & SU_ITEMS)
1799                 MSG_WriteLong (msg, stats[STAT_ITEMS]);
1800
1801         if (sv.protocol == PROTOCOL_DARKPLACES5)
1802         {
1803                 if (bits & SU_WEAPONFRAME)
1804                         MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
1805                 if (bits & SU_ARMOR)
1806                         MSG_WriteShort (msg, stats[STAT_ARMOR]);
1807                 if (bits & SU_WEAPON)
1808                         MSG_WriteShort (msg, stats[STAT_WEAPON]);
1809                 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1810                 MSG_WriteShort (msg, stats[STAT_AMMO]);
1811                 MSG_WriteShort (msg, stats[STAT_SHELLS]);
1812                 MSG_WriteShort (msg, stats[STAT_NAILS]);
1813                 MSG_WriteShort (msg, stats[STAT_ROCKETS]);
1814                 MSG_WriteShort (msg, stats[STAT_CELLS]);
1815                 MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
1816                 if (bits & SU_VIEWZOOM)
1817                         MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1818         }
1819         else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1820         {
1821                 if (bits & SU_WEAPONFRAME)
1822                         MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
1823                 if (bits & SU_ARMOR)
1824                         MSG_WriteByte (msg, stats[STAT_ARMOR]);
1825                 if (bits & SU_WEAPON)
1826                 {
1827                         if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1828                                 MSG_WriteShort (msg, stats[STAT_WEAPON]);
1829                         else
1830                                 MSG_WriteByte (msg, stats[STAT_WEAPON]);
1831                 }
1832                 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1833                 MSG_WriteByte (msg, stats[STAT_AMMO]);
1834                 MSG_WriteByte (msg, stats[STAT_SHELLS]);
1835                 MSG_WriteByte (msg, stats[STAT_NAILS]);
1836                 MSG_WriteByte (msg, stats[STAT_ROCKETS]);
1837                 MSG_WriteByte (msg, stats[STAT_CELLS]);
1838                 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
1839                 {
1840                         for (i = 0;i < 32;i++)
1841                                 if (stats[STAT_ACTIVEWEAPON] & (1<<i))
1842                                         break;
1843                         MSG_WriteByte (msg, i);
1844                 }
1845                 else
1846                         MSG_WriteByte (msg, stats[STAT_ACTIVEWEAPON]);
1847                 if (bits & SU_VIEWZOOM)
1848                 {
1849                         if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1850                                 MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
1851                         else
1852                                 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1853                 }
1854         }
1855 }
1856
1857 void SV_FlushBroadcastMessages(void)
1858 {
1859         int i;
1860         client_t *client;
1861         if (sv.datagram.cursize <= 0)
1862                 return;
1863         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1864         {
1865                 if (!client->spawned || !client->netconnection || client->unreliablemsg.cursize + sv.datagram.cursize > client->unreliablemsg.maxsize || client->unreliablemsg_splitpoints >= (int)(sizeof(client->unreliablemsg_splitpoint)/sizeof(client->unreliablemsg_splitpoint[0])))
1866                         continue;
1867                 SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
1868                 client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
1869         }
1870         SZ_Clear(&sv.datagram);
1871 }
1872
1873 static void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg, int maxsize, int maxsize2)
1874 {
1875         // scan the splitpoints to find out how many we can fit in
1876         int numsegments, j, split;
1877         if (!client->unreliablemsg_splitpoints)
1878                 return;
1879         // always accept the first one if it's within 1024 bytes, this ensures
1880         // that very big datagrams which are over the rate limit still get
1881         // through, just to keep it working
1882         for (numsegments = 1;numsegments < client->unreliablemsg_splitpoints;numsegments++)
1883                 if (msg->cursize + client->unreliablemsg_splitpoint[numsegments] > maxsize)
1884                         break;
1885         // the first segment gets an exemption from the rate limiting, otherwise
1886         // it could get dropped consistently due to a low rate limit
1887         if (numsegments == 1)
1888                 maxsize = maxsize2;
1889         // some will fit, so add the ones that will fit
1890         split = client->unreliablemsg_splitpoint[numsegments-1];
1891         // note this discards ones that were accepted by the segments scan but
1892         // can not fit, such as a really huge first one that will never ever
1893         // fit in a packet...
1894         if (msg->cursize + split <= maxsize)
1895                 SZ_Write(msg, client->unreliablemsg.data, split);
1896         // remove the part we sent, keeping any remaining data
1897         client->unreliablemsg.cursize -= split;
1898         if (client->unreliablemsg.cursize > 0)
1899                 memmove(client->unreliablemsg.data, client->unreliablemsg.data + split, client->unreliablemsg.cursize);
1900         // adjust remaining splitpoints
1901         client->unreliablemsg_splitpoints -= numsegments;
1902         for (j = 0;j < client->unreliablemsg_splitpoints;j++)
1903                 client->unreliablemsg_splitpoint[j] = client->unreliablemsg_splitpoint[numsegments + j] - split;
1904 }
1905
1906 /*
1907 =======================
1908 SV_SendClientDatagram
1909 =======================
1910 */
1911 static void SV_SendClientDatagram (client_t *client)
1912 {
1913         int clientrate, maxrate, maxsize, maxsize2, downloadsize;
1914         sizebuf_t msg;
1915         int stats[MAX_CL_STATS];
1916         unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE];
1917
1918         // obey rate limit by limiting packet frequency if the packet size
1919         // limiting fails
1920         // (usually this is caused by reliable messages)
1921         if (!NetConn_CanSend(client->netconnection))
1922                 return;
1923
1924         // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
1925         maxrate = max(NET_MINRATE, sv_maxrate.integer);
1926         if (sv_maxrate.integer != maxrate)
1927                 Cvar_SetValueQuick(&sv_maxrate, maxrate);
1928
1929         // clientrate determines the 'cleartime' of a packet
1930         // (how long to wait before sending another, based on this packet's size)
1931         clientrate = bound(NET_MINRATE, client->rate, maxrate);
1932
1933         switch (sv.protocol)
1934         {
1935         case PROTOCOL_QUAKE:
1936         case PROTOCOL_QUAKEDP:
1937         case PROTOCOL_NEHAHRAMOVIE:
1938         case PROTOCOL_NEHAHRABJP:
1939         case PROTOCOL_NEHAHRABJP2:
1940         case PROTOCOL_NEHAHRABJP3:
1941         case PROTOCOL_QUAKEWORLD:
1942                 // no packet size limit support on Quake protocols because it just
1943                 // causes missing entities/effects
1944                 // packets are simply sent less often to obey the rate limit
1945                 maxsize = 1024;
1946                 maxsize2 = 1024;
1947                 break;
1948         case PROTOCOL_DARKPLACES1:
1949         case PROTOCOL_DARKPLACES2:
1950         case PROTOCOL_DARKPLACES3:
1951         case PROTOCOL_DARKPLACES4:
1952                 // no packet size limit support on DP1-4 protocols because they kick
1953                 // the client off if they overflow, and miss effects
1954                 // packets are simply sent less often to obey the rate limit
1955                 maxsize = sizeof(sv_sendclientdatagram_buf);
1956                 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1957                 break;
1958         default:
1959                 // DP5 and later protocols support packet size limiting which is a
1960                 // better method than limiting packet frequency as QW does
1961                 //
1962                 // at very low rates (or very small sys_ticrate) the packet size is
1963                 // not reduced below 128, but packets may be sent less often
1964                 maxsize = (int)(clientrate * sys_ticrate.value);
1965                 maxsize = bound(128, maxsize, 1400);
1966                 maxsize2 = 1400;
1967                 // csqc entities can easily exceed 128 bytes, so disable throttling in
1968                 // mods that use csqc (they are likely to use less bandwidth anyway)
1969                 if (sv.csqc_progsize > 0)
1970                         maxsize = maxsize2;
1971                 break;
1972         }
1973
1974         if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !sv_ratelimitlocalplayer.integer)
1975         {
1976                 // for good singleplayer, send huge packets
1977                 maxsize = sizeof(sv_sendclientdatagram_buf);
1978                 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1979                 // never limit frequency in singleplayer
1980                 clientrate = 1000000000;
1981         }
1982
1983         // while downloading, limit entity updates to half the packet
1984         // (any leftover space will be used for downloading)
1985         if (host_client->download_file)
1986                 maxsize /= 2;
1987
1988         msg.data = sv_sendclientdatagram_buf;
1989         msg.maxsize = sizeof(sv_sendclientdatagram_buf);
1990         msg.cursize = 0;
1991         msg.allowoverflow = false;
1992
1993         if (host_client->spawned)
1994         {
1995                 // the player is in the game
1996                 MSG_WriteByte (&msg, svc_time);
1997                 MSG_WriteFloat (&msg, sv.time);
1998
1999                 // add the client specific data to the datagram
2000                 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
2001                 // now update the stats[] array using any registered custom fields
2002                 VM_SV_UpdateCustomStats (client, client->edict, &msg, stats);
2003                 // set host_client->statsdeltabits
2004                 Protocol_UpdateClientStats (stats);
2005
2006                 // add as many queued unreliable messages (effects) as we can fit
2007                 // limit effects to half of the remaining space
2008                 if (client->unreliablemsg.cursize)
2009                         SV_WriteUnreliableMessages (client, &msg, maxsize/2, maxsize2);
2010
2011                 // now write as many entities as we can fit, and also sends stats
2012                 SV_WriteEntitiesToClient (client, client->edict, &msg, maxsize);
2013         }
2014         else if (realtime > client->keepalivetime)
2015         {
2016                 // the player isn't totally in the game yet
2017                 // send small keepalive messages if too much time has passed
2018                 // (may also be sending downloads)
2019                 client->keepalivetime = realtime + 5;
2020                 MSG_WriteChar (&msg, svc_nop);
2021         }
2022
2023         // if a download is active, see if there is room to fit some download data
2024         // in this packet
2025         downloadsize = min(maxsize*2,maxsize2) - msg.cursize - 7;
2026         if (host_client->download_file && host_client->download_started && downloadsize > 0)
2027         {
2028                 fs_offset_t downloadstart;
2029                 unsigned char data[1400];
2030                 downloadstart = FS_Tell(host_client->download_file);
2031                 downloadsize = min(downloadsize, (int)sizeof(data));
2032                 downloadsize = FS_Read(host_client->download_file, data, downloadsize);
2033                 // note this sends empty messages if at the end of the file, which is
2034                 // necessary to keep the packet loss logic working
2035                 // (the last blocks may be lost and need to be re-sent, and that will
2036                 //  only occur if the client acks the empty end messages, revealing
2037                 //  a gap in the download progress, causing the last blocks to be
2038                 //  sent again)
2039                 MSG_WriteChar (&msg, svc_downloaddata);
2040                 MSG_WriteLong (&msg, downloadstart);
2041                 MSG_WriteShort (&msg, downloadsize);
2042                 if (downloadsize > 0)
2043                         SZ_Write (&msg, data, downloadsize);
2044         }
2045
2046         // reliable only if none is in progress
2047         if(client->sendsignon != 2 && !client->netconnection->sendMessageLength)
2048                 SV_WriteDemoMessage(client, &(client->netconnection->message), false);
2049         // unreliable
2050         SV_WriteDemoMessage(client, &msg, false);
2051
2052 // send the datagram
2053         NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->sendsignon == 2);
2054         if (client->sendsignon == 1 && !client->netconnection->message.cursize)
2055                 client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
2056 }
2057
2058 /*
2059 =======================
2060 SV_UpdateToReliableMessages
2061 =======================
2062 */
2063 static void SV_UpdateToReliableMessages (void)
2064 {
2065         int i, j;
2066         client_t *client;
2067         prvm_eval_t *val;
2068         const char *name;
2069         const char *model;
2070         const char *skin;
2071
2072 // check for changes to be sent over the reliable streams
2073         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2074         {
2075                 // update the host_client fields we care about according to the entity fields
2076                 host_client->edict = PRVM_EDICT_NUM(i+1);
2077
2078                 // DP_SV_CLIENTNAME
2079                 name = PRVM_GetString(host_client->edict->fields.server->netname);
2080                 if (name == NULL)
2081                         name = "";
2082                 // always point the string back at host_client->name to keep it safe
2083                 strlcpy (host_client->name, name, sizeof (host_client->name));
2084                 host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
2085                 if (strcmp(host_client->old_name, host_client->name))
2086                 {
2087                         if (host_client->spawned)
2088                                 SV_BroadcastPrintf("%s ^7changed name to %s\n", host_client->old_name, host_client->name);
2089                         strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
2090                         // send notification to all clients
2091                         MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
2092                         MSG_WriteByte (&sv.reliable_datagram, i);
2093                         MSG_WriteString (&sv.reliable_datagram, host_client->name);
2094                         SV_WriteNetnameIntoDemo(host_client);
2095                 }
2096
2097                 // DP_SV_CLIENTCOLORS
2098                 // this is always found (since it's added by the progs loader)
2099                 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcolors)))
2100                         host_client->colors = (int)val->_float;
2101                 if (host_client->old_colors != host_client->colors)
2102                 {
2103                         host_client->old_colors = host_client->colors;
2104                         // send notification to all clients
2105                         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
2106                         MSG_WriteByte (&sv.reliable_datagram, i);
2107                         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
2108                 }
2109
2110                 // NEXUIZ_PLAYERMODEL
2111                 if( prog->fieldoffsets.playermodel >= 0 ) {
2112                         model = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string);
2113                         if (model == NULL)
2114                                 model = "";
2115                         // always point the string back at host_client->name to keep it safe
2116                         strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
2117                         PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
2118                 }
2119
2120                 // NEXUIZ_PLAYERSKIN
2121                 if( prog->fieldoffsets.playerskin >= 0 ) {
2122                         skin = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string);
2123                         if (skin == NULL)
2124                                 skin = "";
2125                         // always point the string back at host_client->name to keep it safe
2126                         strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
2127                         PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
2128                 }
2129
2130                 // TODO: add an extension name for this [1/17/2008 Black]
2131                 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcamera)) && val->edict > 0 ) {
2132                         int oldclientcamera = host_client->clientcamera;
2133                         if( val->edict >= prog->max_edicts || PRVM_EDICT_NUM( val->edict )->priv.required->free ) {
2134                                 val->edict = host_client->clientcamera = PRVM_NUM_FOR_EDICT( host_client->edict );
2135                         } else {
2136                                 host_client->clientcamera = val->edict;
2137                         }
2138
2139                         if( oldclientcamera != host_client->clientcamera ) {
2140                                 MSG_WriteByte (&sv.reliable_datagram, svc_setview );
2141                                 MSG_WriteShort (&host_client->netconnection->message, host_client->clientcamera);
2142                         }
2143                 }
2144
2145                 // frags
2146                 host_client->frags = (int)host_client->edict->fields.server->frags;
2147                 if(gamemode == GAME_NEXUIZ)
2148                         if(!host_client->spawned && host_client->netconnection)
2149                                 host_client->frags = -666;
2150                 if (host_client->old_frags != host_client->frags)
2151                 {
2152                         host_client->old_frags = host_client->frags;
2153                         // send notification to all clients
2154                         MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
2155                         MSG_WriteByte (&sv.reliable_datagram, i);
2156                         MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
2157                 }
2158         }
2159
2160         for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
2161                 if (client->netconnection && (client->spawned || client->clientconnectcalled)) // also send MSG_ALL to people who are past ClientConnect, but not spawned yet
2162                         SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
2163
2164         SZ_Clear (&sv.reliable_datagram);
2165 }
2166
2167
2168 /*
2169 =======================
2170 SV_SendClientMessages
2171 =======================
2172 */
2173 void SV_SendClientMessages (void)
2174 {
2175         int i, prepared = false;
2176
2177         if (sv.protocol == PROTOCOL_QUAKEWORLD)
2178                 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
2179
2180         SV_FlushBroadcastMessages();
2181
2182 // update frags, names, etc
2183         SV_UpdateToReliableMessages();
2184
2185 // build individual updates
2186         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2187         {
2188                 if (!host_client->active)
2189                         continue;
2190                 if (!host_client->netconnection)
2191                         continue;
2192
2193                 if (host_client->netconnection->message.overflowed)
2194                 {
2195                         SV_DropClient (true);   // if the message couldn't send, kick off
2196                         continue;
2197                 }
2198
2199                 if (!prepared)
2200                 {
2201                         prepared = true;
2202                         // only prepare entities once per frame
2203                         SV_PrepareEntitiesForSending();
2204                 }
2205                 SV_SendClientDatagram (host_client);
2206         }
2207
2208 // clear muzzle flashes
2209         SV_CleanupEnts();
2210 }
2211
2212 static void SV_StartDownload_f(void)
2213 {
2214         if (host_client->download_file)
2215                 host_client->download_started = true;
2216 }
2217
2218 /*
2219  * Compression extension negotiation:
2220  *
2221  * Server to client:
2222  *   cl_serverextension_download 2
2223  *
2224  * Client to server:
2225  *   download <filename> <list of zero or more suppported compressions in order of preference>
2226  * e.g.
2227  *   download maps/map1.bsp lzo deflate huffman
2228  *
2229  * Server to client:
2230  *   cl_downloadbegin <compressed size> <filename> <compression method actually used>
2231  * e.g.
2232  *   cl_downloadbegin 123456 maps/map1.bsp deflate
2233  *
2234  * The server may choose not to compress the file by sending no compression name, like:
2235  *   cl_downloadbegin 345678 maps/map1.bsp
2236  *
2237  * NOTE: the "download" command may only specify compression algorithms if
2238  *       cl_serverextension_download is 2!
2239  *       If cl_serverextension_download has a different value, the client must
2240  *       assume this extension is not supported!
2241  */
2242
2243 static void Download_CheckExtensions(void)
2244 {
2245         int i;
2246         int argc = Cmd_Argc();
2247
2248         // first reset them all
2249         host_client->download_deflate = false;
2250
2251         for(i = 2; i < argc; ++i)
2252         {
2253                 if(!strcmp(Cmd_Argv(i), "deflate"))
2254                 {
2255                         host_client->download_deflate = true;
2256                         break;
2257                 }
2258         }
2259 }
2260
2261 static void SV_Download_f(void)
2262 {
2263         const char *whichpack, *whichpack2, *extension;
2264         qboolean is_csqc; // so we need to check only once
2265
2266         if (Cmd_Argc() < 2)
2267         {
2268                 SV_ClientPrintf("usage: download <filename> {<extensions>}*\n");
2269                 SV_ClientPrintf("       supported extensions: deflate\n");
2270                 return;
2271         }
2272
2273         if (FS_CheckNastyPath(Cmd_Argv(1), false))
2274         {
2275                 SV_ClientPrintf("Download rejected: nasty filename \"%s\"\n", Cmd_Argv(1));
2276                 return;
2277         }
2278
2279         if (host_client->download_file)
2280         {
2281                 // at this point we'll assume the previous download should be aborted
2282                 Con_DPrintf("Download of %s aborted by %s starting a new download\n", host_client->download_name, host_client->name);
2283                 Host_ClientCommands("\nstopdownload\n");
2284
2285                 // close the file and reset variables
2286                 FS_Close(host_client->download_file);
2287                 host_client->download_file = NULL;
2288                 host_client->download_name[0] = 0;
2289                 host_client->download_expectedposition = 0;
2290                 host_client->download_started = false;
2291         }
2292
2293         is_csqc = (sv.csqc_progname[0] && strcmp(Cmd_Argv(1), sv.csqc_progname) == 0);
2294
2295         if (!sv_allowdownloads.integer && !is_csqc)
2296         {
2297                 SV_ClientPrintf("Downloads are disabled on this server\n");
2298                 Host_ClientCommands("\nstopdownload\n");
2299                 return;
2300         }
2301
2302         Download_CheckExtensions();
2303
2304         strlcpy(host_client->download_name, Cmd_Argv(1), sizeof(host_client->download_name));
2305         extension = FS_FileExtension(host_client->download_name);
2306
2307         // host_client is asking to download a specified file
2308         if (developer.integer >= 100)
2309                 Con_Printf("Download request for %s by %s\n", host_client->download_name, host_client->name);
2310
2311         if(is_csqc)
2312         {
2313                 char extensions[MAX_QPATH]; // make sure this can hold all extensions
2314                 extensions[0] = '\0';
2315
2316                 if(host_client->download_deflate)
2317                         strlcat(extensions, " deflate", sizeof(extensions));
2318
2319                 Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
2320
2321                 if(host_client->download_deflate && svs.csqc_progdata_deflated)
2322                         host_client->download_file = FS_FileFromData(svs.csqc_progdata_deflated, svs.csqc_progsize_deflated, true);
2323                 else
2324                         host_client->download_file = FS_FileFromData(svs.csqc_progdata, sv.csqc_progsize, true);
2325
2326                 // no, no space is needed between %s and %s :P
2327                 Host_ClientCommands("\ncl_downloadbegin %i %s%s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name, extensions);
2328
2329                 host_client->download_expectedposition = 0;
2330                 host_client->download_started = false;
2331                 host_client->sendsignon = true; // make sure this message is sent
2332                 return;
2333         }
2334
2335         if (!FS_FileExists(host_client->download_name))
2336         {
2337                 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);
2338                 Host_ClientCommands("\nstopdownload\n");
2339                 return;
2340         }
2341
2342         // check if the user is trying to download part of registered Quake(r)
2343         whichpack = FS_WhichPack(host_client->download_name);
2344         whichpack2 = FS_WhichPack("gfx/pop.lmp");
2345         if ((whichpack && whichpack2 && !strcasecmp(whichpack, whichpack2)) || FS_IsRegisteredQuakePack(host_client->download_name))
2346         {
2347                 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);
2348                 Host_ClientCommands("\nstopdownload\n");
2349                 return;
2350         }
2351
2352         // check if the server has forbidden archive downloads entirely
2353         if (!sv_allowdownloads_inarchive.integer)
2354         {
2355                 whichpack = FS_WhichPack(host_client->download_name);
2356                 if (whichpack)
2357                 {
2358                         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);
2359                         Host_ClientCommands("\nstopdownload\n");
2360                         return;
2361                 }
2362         }
2363
2364         if (!sv_allowdownloads_config.integer)
2365         {
2366                 if (!strcasecmp(extension, "cfg"))
2367                 {
2368                         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);
2369                         Host_ClientCommands("\nstopdownload\n");
2370                         return;
2371                 }
2372         }
2373
2374         if (!sv_allowdownloads_dlcache.integer)
2375         {
2376                 if (!strncasecmp(host_client->download_name, "dlcache/", 8))
2377                 {
2378                         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);
2379                         Host_ClientCommands("\nstopdownload\n");
2380                         return;
2381                 }
2382         }
2383
2384         if (!sv_allowdownloads_archive.integer)
2385         {
2386                 if (!strcasecmp(extension, "pak") || !strcasecmp(extension, "pk3"))
2387                 {
2388                         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);
2389                         Host_ClientCommands("\nstopdownload\n");
2390                         return;
2391                 }
2392         }
2393
2394         host_client->download_file = FS_OpenVirtualFile(host_client->download_name, true);
2395         if (!host_client->download_file)
2396         {
2397                 SV_ClientPrintf("Download rejected: server could not open the file \"%s\"\n", host_client->download_name);
2398                 Host_ClientCommands("\nstopdownload\n");
2399                 return;
2400         }
2401
2402         if (FS_FileSize(host_client->download_file) > 1<<30)
2403         {
2404                 SV_ClientPrintf("Download rejected: file \"%s\" is very large\n", host_client->download_name);
2405                 Host_ClientCommands("\nstopdownload\n");
2406                 FS_Close(host_client->download_file);
2407                 host_client->download_file = NULL;
2408                 return;
2409         }
2410
2411         if (FS_FileSize(host_client->download_file) < 0)
2412         {
2413                 SV_ClientPrintf("Download rejected: file \"%s\" is not a regular file\n", host_client->download_name);
2414                 Host_ClientCommands("\nstopdownload\n");
2415                 FS_Close(host_client->download_file);
2416                 host_client->download_file = NULL;
2417                 return;
2418         }
2419
2420         Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
2421
2422         /*
2423          * we can only do this if we would actually deflate on the fly
2424          * which we do not (yet)!
2425         {
2426                 char extensions[MAX_QPATH]; // make sure this can hold all extensions
2427                 extensions[0] = '\0';
2428
2429                 if(host_client->download_deflate)
2430                         strlcat(extensions, " deflate", sizeof(extensions));
2431
2432                 // no, no space is needed between %s and %s :P
2433                 Host_ClientCommands("\ncl_downloadbegin %i %s%s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name, extensions);
2434         }
2435         */
2436         Host_ClientCommands("\ncl_downloadbegin %i %s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name);
2437
2438         host_client->download_expectedposition = 0;
2439         host_client->download_started = false;
2440         host_client->sendsignon = true; // make sure this message is sent
2441
2442         // the rest of the download process is handled in SV_SendClientDatagram
2443         // and other code dealing with svc_downloaddata and clc_ackdownloaddata
2444         //
2445         // no svc_downloaddata messages will be sent until sv_startdownload is
2446         // sent by the client
2447 }
2448
2449 /*
2450 ==============================================================================
2451
2452 SERVER SPAWNING
2453
2454 ==============================================================================
2455 */
2456
2457 /*
2458 ================
2459 SV_ModelIndex
2460
2461 ================
2462 */
2463 int SV_ModelIndex(const char *s, int precachemode)
2464 {
2465         int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3) ? 256 : MAX_MODELS);
2466         char filename[MAX_QPATH];
2467         if (!s || !*s)
2468                 return 0;
2469         // testing
2470         //if (precachemode == 2)
2471         //      return 0;
2472         strlcpy(filename, s, sizeof(filename));
2473         for (i = 2;i < limit;i++)
2474         {
2475                 if (!sv.model_precache[i][0])
2476                 {
2477                         if (precachemode)
2478                         {
2479                                 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))
2480                                 {
2481                                         Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
2482                                         return 0;
2483                                 }
2484                                 if (precachemode == 1)
2485                                         Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2486                                 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
2487                                 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.modelname : NULL);
2488                                 if (sv.state != ss_loading)
2489                                 {
2490                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2491                                         MSG_WriteShort(&sv.reliable_datagram, i);
2492                                         MSG_WriteString(&sv.reliable_datagram, filename);
2493                                 }
2494                                 return i;
2495                         }
2496                         Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
2497                         return 0;
2498                 }
2499                 if (!strcmp(sv.model_precache[i], filename))
2500                         return i;
2501         }
2502         Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
2503         return 0;
2504 }
2505
2506 /*
2507 ================
2508 SV_SoundIndex
2509
2510 ================
2511 */
2512 int SV_SoundIndex(const char *s, int precachemode)
2513 {
2514         int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3) ? 256 : MAX_SOUNDS);
2515         char filename[MAX_QPATH];
2516         if (!s || !*s)
2517                 return 0;
2518         // testing
2519         //if (precachemode == 2)
2520         //      return 0;
2521         strlcpy(filename, s, sizeof(filename));
2522         for (i = 1;i < limit;i++)
2523         {
2524                 if (!sv.sound_precache[i][0])
2525                 {
2526                         if (precachemode)
2527                         {
2528                                 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))
2529                                 {
2530                                         Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
2531                                         return 0;
2532                                 }
2533                                 if (precachemode == 1)
2534                                         Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2535                                 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
2536                                 if (sv.state != ss_loading)
2537                                 {
2538                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2539                                         MSG_WriteShort(&sv.reliable_datagram, i + 32768);
2540                                         MSG_WriteString(&sv.reliable_datagram, filename);
2541                                 }
2542                                 return i;
2543                         }
2544                         Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
2545                         return 0;
2546                 }
2547                 if (!strcmp(sv.sound_precache[i], filename))
2548                         return i;
2549         }
2550         Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
2551         return 0;
2552 }
2553
2554 /*
2555 ================
2556 SV_ParticleEffectIndex
2557
2558 ================
2559 */
2560 int SV_ParticleEffectIndex(const char *name)
2561 {
2562         int i, argc, linenumber, effectnameindex;
2563         fs_offset_t filesize;
2564         unsigned char *filedata;
2565         const char *text, *textstart, *textend;
2566         char argv[16][1024];
2567         if (!sv.particleeffectnamesloaded)
2568         {
2569                 sv.particleeffectnamesloaded = true;
2570                 memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
2571                 for (i = 0;i < EFFECT_TOTAL;i++)
2572                         strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
2573                 filedata = FS_LoadFile("effectinfo.txt", tempmempool, true, &filesize);
2574                 if (filedata)
2575                 {
2576                         textstart = (const char *)filedata;
2577                         textend = (const char *)filedata + filesize;
2578                         text = textstart;
2579                         for (linenumber = 1;;linenumber++)
2580                         {
2581                                 argc = 0;
2582                                 for (;;)
2583                                 {
2584                                         if (!COM_ParseToken_Simple(&text, true, false) || !strcmp(com_token, "\n"))
2585                                                 break;
2586                                         if (argc < 16)
2587                                         {
2588                                                 strlcpy(argv[argc], com_token, sizeof(argv[argc]));
2589                                                 argc++;
2590                                         }
2591                                 }
2592                                 if (com_token[0] == 0)
2593                                         break; // if the loop exited and it's not a \n, it's EOF
2594                                 if (argc < 1)
2595                                         continue;
2596                                 if (!strcmp(argv[0], "effect"))
2597                                 {
2598                                         if (argc == 2)
2599                                         {
2600                                                 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME;effectnameindex++)
2601                                                 {
2602                                                         if (sv.particleeffectname[effectnameindex][0])
2603                                                         {
2604                                                                 if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
2605                                                                         break;
2606                                                         }
2607                                                         else
2608                                                         {
2609                                                                 strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
2610                                                                 break;
2611                                                         }
2612                                                 }
2613                                                 // if we run out of names, abort
2614                                                 if (effectnameindex == SV_MAX_PARTICLEEFFECTNAME)
2615                                                 {
2616                                                         Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
2617                                                         break;
2618                                                 }
2619                                         }
2620                                 }
2621                         }
2622                         Mem_Free(filedata);
2623                 }
2624         }
2625         // search for the name
2626         for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
2627                 if (!strcmp(sv.particleeffectname[effectnameindex], name))
2628                         return effectnameindex;
2629         // return 0 if we couldn't find it
2630         return 0;
2631 }
2632
2633 /*
2634 ================
2635 SV_CreateBaseline
2636
2637 ================
2638 */
2639 static void SV_CreateBaseline (void)
2640 {
2641         int i, entnum, large;
2642         prvm_edict_t *svent;
2643
2644         // LordHavoc: clear *all* states (note just active ones)
2645         for (entnum = 0;entnum < prog->max_edicts;entnum++)
2646         {
2647                 // get the current server version
2648                 svent = PRVM_EDICT_NUM(entnum);
2649
2650                 // LordHavoc: always clear state values, whether the entity is in use or not
2651                 svent->priv.server->baseline = defaultstate;
2652
2653                 if (svent->priv.server->free)
2654                         continue;
2655                 if (entnum > svs.maxclients && !svent->fields.server->modelindex)
2656                         continue;
2657
2658                 // create entity baseline
2659                 VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
2660                 VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
2661                 svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
2662                 svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
2663                 if (entnum > 0 && entnum <= svs.maxclients)
2664                 {
2665                         svent->priv.server->baseline.colormap = entnum;
2666                         svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
2667                 }
2668                 else
2669                 {
2670                         svent->priv.server->baseline.colormap = 0;
2671                         svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
2672                 }
2673
2674                 large = false;
2675                 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
2676                 {
2677                         large = true;
2678                         if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2679                                 large = false;
2680                 }
2681
2682                 // add to the message
2683                 if (large)
2684                         MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
2685                 else
2686                         MSG_WriteByte (&sv.signon, svc_spawnbaseline);
2687                 MSG_WriteShort (&sv.signon, entnum);
2688
2689                 if (large)
2690                 {
2691                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2692                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
2693                 }
2694                 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2695                 {
2696                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2697                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2698                 }
2699                 else
2700                 {
2701                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
2702                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2703                 }
2704                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
2705                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
2706                 for (i=0 ; i<3 ; i++)
2707                 {
2708                         MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
2709                         MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
2710                 }
2711         }
2712 }
2713
2714 /*
2715 ================
2716 SV_Prepare_CSQC
2717
2718 Load csprogs.dat and comperss it so it doesn't need to be
2719 reloaded on request.
2720 ================
2721 */
2722 void SV_Prepare_CSQC(void)
2723 {
2724         fs_offset_t progsize;
2725
2726         if(svs.csqc_progdata)
2727         {
2728                 Con_DPrintf("Unloading old CSQC data.\n");
2729                 Mem_Free(svs.csqc_progdata);
2730                 if(svs.csqc_progdata_deflated)
2731                         Mem_Free(svs.csqc_progdata_deflated);
2732         }
2733
2734         svs.csqc_progdata = NULL;
2735         svs.csqc_progdata_deflated = NULL;
2736
2737         Con_Print("Loading csprogs.dat\n");
2738
2739         sv.csqc_progname[0] = 0;
2740         svs.csqc_progdata = FS_LoadFile(csqc_progname.string, sv_mempool, false, &progsize);
2741
2742         if(progsize > 0)
2743         {
2744                 size_t deflated_size;
2745
2746                 sv.csqc_progsize = (int)progsize;
2747                 sv.csqc_progcrc = CRC_Block(svs.csqc_progdata, progsize);
2748                 strlcpy(sv.csqc_progname, csqc_progname.string, sizeof(sv.csqc_progname));
2749                 Con_Printf("server detected csqc progs file \"%s\" with size %i and crc %i\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
2750
2751                 Con_Print("Compressing csprogs.dat\n");
2752                 //unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool);
2753                 svs.csqc_progdata_deflated = FS_Deflate(svs.csqc_progdata, progsize, &deflated_size, -1, sv_mempool);
2754                 svs.csqc_progsize_deflated = (int)deflated_size;
2755                 if(svs.csqc_progdata_deflated)
2756                 {
2757                         Con_Printf("Deflated: %g%%\n", 100.0 - 100.0 * (deflated_size / (float)progsize));
2758                         Con_DPrintf("Uncompressed: %u\nCompressed:   %u\n", (unsigned)sv.csqc_progsize, (unsigned)svs.csqc_progsize_deflated);
2759                 }
2760                 else
2761                         Con_Printf("Cannot compress - need zlib for this. Using uncompressed progs only.\n");
2762         }
2763 }
2764
2765 /*
2766 ================
2767 SV_SaveSpawnparms
2768
2769 Grabs the current state of each client for saving across the
2770 transition to another level
2771 ================
2772 */
2773 void SV_SaveSpawnparms (void)
2774 {
2775         int             i, j;
2776
2777         svs.serverflags = (int)prog->globals.server->serverflags;
2778
2779         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2780         {
2781                 if (!host_client->active)
2782                         continue;
2783
2784         // call the progs to get default spawn parms for the new client
2785                 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2786                 PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
2787                 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
2788                         host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
2789         }
2790 }
2791
2792 /*
2793 ================
2794 SV_SpawnServer
2795
2796 This is called at the start of each level
2797 ================
2798 */
2799
2800 void SV_SpawnServer (const char *server)
2801 {
2802         prvm_edict_t *ent;
2803         int i;
2804         char *entities;
2805         dp_model_t *worldmodel;
2806         char modelname[sizeof(sv.modelname)];
2807
2808         Con_DPrintf("SpawnServer: %s\n", server);
2809
2810         dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
2811
2812         if (!FS_FileExists(modelname))
2813         {
2814                 Con_Printf("SpawnServer: no map file named %s\n", modelname);
2815                 return;
2816         }
2817
2818         if (cls.state != ca_dedicated)
2819         {
2820                 SCR_BeginLoadingPlaque();
2821                 S_StopAllSounds();
2822         }
2823
2824         if(sv.active)
2825         {
2826                 SV_VM_Begin();
2827                 if(prog->funcoffsets.SV_Shutdown)
2828                 {
2829                         func_t s = prog->funcoffsets.SV_Shutdown;
2830                         prog->funcoffsets.SV_Shutdown = 0; // prevent it from getting called again
2831                         PRVM_ExecuteProgram(s,"SV_Shutdown() required");
2832                 }
2833                 SV_VM_End();
2834         }
2835
2836         // free q3 shaders so that any newly downloaded shaders will be active
2837         Mod_FreeQ3Shaders();
2838
2839         worldmodel = Mod_ForName(modelname, false, true, NULL);
2840         if (!worldmodel || !worldmodel->TraceBox)
2841         {
2842                 Con_Printf("Couldn't load map %s\n", modelname);
2843                 return;
2844         }
2845
2846         // let's not have any servers with no name
2847         if (hostname.string[0] == 0)
2848                 Cvar_Set ("hostname", "UNNAMED");
2849         scr_centertime_off = 0;
2850
2851         svs.changelevel_issued = false;         // now safe to issue another
2852
2853         // make the map a required file for clients
2854         Curl_ClearRequirements();
2855         Curl_RequireFile(modelname);
2856
2857 //
2858 // tell all connected clients that we are going to a new level
2859 //
2860         if (sv.active)
2861         {
2862                 client_t *client;
2863                 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
2864                 {
2865                         if (client->netconnection)
2866                         {
2867                                 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
2868                                 MSG_WriteString(&client->netconnection->message, "reconnect\n");
2869                         }
2870                 }
2871         }
2872         else
2873         {
2874                 // open server port
2875                 NetConn_OpenServerPorts(true);
2876         }
2877
2878 //
2879 // make cvars consistant
2880 //
2881         if (coop.integer)
2882                 Cvar_SetValue ("deathmatch", 0);
2883         // LordHavoc: it can be useful to have skills outside the range 0-3...
2884         //current_skill = bound(0, (int)(skill.value + 0.5), 3);
2885         //Cvar_SetValue ("skill", (float)current_skill);
2886         current_skill = (int)(skill.value + 0.5);
2887
2888 //
2889 // set up the new server
2890 //
2891         memset (&sv, 0, sizeof(sv));
2892         // if running a local client, make sure it doesn't try to access the last
2893         // level's data which is no longer valiud
2894         cls.signon = 0;
2895
2896         Cvar_SetValue("halflifebsp", worldmodel->brush.ishlbsp);
2897
2898         if(*sv_random_seed.string)
2899         {
2900                 srand(sv_random_seed.integer);
2901                 Con_Printf("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);
2902         }
2903
2904         SV_VM_Setup();
2905
2906         sv.active = true;
2907
2908         strlcpy (sv.name, server, sizeof (sv.name));
2909
2910         sv.protocol = Protocol_EnumForName(sv_protocolname.string);
2911         if (sv.protocol == PROTOCOL_UNKNOWN)
2912         {
2913                 char buffer[1024];
2914                 Protocol_Names(buffer, sizeof(buffer));
2915                 Con_Printf("Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
2916                 sv.protocol = PROTOCOL_QUAKE;
2917         }
2918
2919         SV_VM_Begin();
2920
2921 // load progs to get entity field count
2922         //PR_LoadProgs ( sv_progs.string );
2923
2924         sv.datagram.maxsize = sizeof(sv.datagram_buf);
2925         sv.datagram.cursize = 0;
2926         sv.datagram.data = sv.datagram_buf;
2927
2928         sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
2929         sv.reliable_datagram.cursize = 0;
2930         sv.reliable_datagram.data = sv.reliable_datagram_buf;
2931
2932         sv.signon.maxsize = sizeof(sv.signon_buf);
2933         sv.signon.cursize = 0;
2934         sv.signon.data = sv.signon_buf;
2935
2936 // leave slots at start for clients only
2937         //prog->num_edicts = svs.maxclients+1;
2938
2939         sv.state = ss_loading;
2940         prog->allowworldwrites = true;
2941         sv.paused = false;
2942
2943         prog->globals.server->time = sv.time = 1.0;
2944
2945         Mod_ClearUsed();
2946         worldmodel->used = true;
2947
2948         strlcpy (sv.name, server, sizeof (sv.name));
2949         strlcpy(sv.modelname, modelname, sizeof(sv.modelname));
2950         sv.worldmodel = worldmodel;
2951         sv.models[1] = sv.worldmodel;
2952
2953 //
2954 // clear world interaction links
2955 //
2956         World_SetSize(&sv.world, sv.worldmodel->name, sv.worldmodel->normalmins, sv.worldmodel->normalmaxs);
2957
2958         strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
2959
2960         strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
2961         strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
2962         for (i = 1;i < sv.worldmodel->brush.numsubmodels && i+1 < MAX_MODELS;i++)
2963         {
2964                 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
2965                 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, sv.modelname);
2966         }
2967         if(i < sv.worldmodel->brush.numsubmodels)
2968                 Con_Printf("Too many submodels (MAX_MODELS is %i)\n", MAX_MODELS);
2969
2970 //
2971 // load the rest of the entities
2972 //
2973         // AK possible hack since num_edicts is still 0
2974         ent = PRVM_EDICT_NUM(0);
2975         memset (ent->fields.server, 0, prog->progs->entityfields * 4);
2976         ent->priv.server->free = false;
2977         ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
2978         ent->fields.server->modelindex = 1;             // world model
2979         ent->fields.server->solid = SOLID_BSP;
2980         ent->fields.server->movetype = MOVETYPE_PUSH;
2981         VectorCopy(sv.world.mins, ent->fields.server->mins);
2982         VectorCopy(sv.world.maxs, ent->fields.server->maxs);
2983         VectorCopy(sv.world.mins, ent->fields.server->absmin);
2984         VectorCopy(sv.world.maxs, ent->fields.server->absmax);
2985
2986         if (coop.value)
2987                 prog->globals.server->coop = coop.integer;
2988         else
2989                 prog->globals.server->deathmatch = deathmatch.integer;
2990
2991         prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
2992
2993 // serverflags are for cross level information (sigils)
2994         prog->globals.server->serverflags = svs.serverflags;
2995
2996         // we need to reset the spawned flag on all connected clients here so that
2997         // their thinks don't run during startup (before PutClientInServer)
2998         // we also need to set up the client entities now
2999         // and we need to set the ->edict pointers to point into the progs edicts
3000         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
3001         {
3002                 host_client->spawned = false;
3003                 host_client->edict = PRVM_EDICT_NUM(i + 1);
3004                 PRVM_ED_ClearEdict(host_client->edict);
3005         }
3006
3007         // load replacement entity file if found
3008         if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
3009         {
3010                 Con_Printf("Loaded maps/%s.ent\n", sv.name);
3011                 PRVM_ED_LoadFromFile (entities);
3012                 Mem_Free(entities);
3013         }
3014         else
3015                 PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
3016
3017
3018         // LordHavoc: clear world angles (to fix e3m3.bsp)
3019         VectorClear(prog->edicts->fields.server->angles);
3020
3021 // all setup is completed, any further precache statements are errors
3022 //      sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
3023         prog->allowworldwrites = false;
3024
3025 // run two frames to allow everything to settle
3026         prog->globals.server->time = sv.time = 1.0001;
3027         for (i = 0;i < 2;i++)
3028         {
3029                 sv.frametime = 0.1;
3030                 SV_Physics ();
3031         }
3032
3033         if (cls.state == ca_dedicated)
3034                 Mod_PurgeUnused();
3035
3036 // create a baseline for more efficient communications
3037         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)
3038                 SV_CreateBaseline ();
3039
3040         sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
3041
3042         // to prevent network timeouts
3043         realtime = Sys_DoubleTime();
3044
3045 // send serverinfo to all connected clients, and set up botclients coming back from a level change
3046         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
3047         {
3048                 host_client->clientconnectcalled = false; // do NOT call ClientDisconnect if he drops before ClientConnect!
3049                 if (!host_client->active)
3050                         continue;
3051                 if (host_client->netconnection)
3052                         SV_SendServerinfo(host_client);
3053                 else
3054                 {
3055                         int j;
3056                         // if client is a botclient coming from a level change, we need to
3057                         // set up client info that normally requires networking
3058
3059                         // copy spawn parms out of the client_t
3060                         for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
3061                                 (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
3062
3063                         // call the spawn function
3064                         host_client->clientconnectcalled = true;
3065                         prog->globals.server->time = sv.time;
3066                         prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
3067                         PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
3068                         PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
3069                         host_client->spawned = true;
3070                 }
3071         }
3072
3073         Con_DPrint("Server spawned.\n");
3074         NetConn_Heartbeat (2);
3075
3076         SV_VM_End();
3077 }
3078
3079 /////////////////////////////////////////////////////
3080 // SV VM stuff
3081
3082 static void SV_VM_CB_BeginIncreaseEdicts(void)
3083 {
3084         // links don't survive the transition, so unlink everything
3085         World_UnlinkAll(&sv.world);
3086 }
3087
3088 static void SV_VM_CB_EndIncreaseEdicts(void)
3089 {
3090         int i;
3091         prvm_edict_t *ent;
3092
3093         // link every entity except world
3094         for (i = 1, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
3095                 if (!ent->priv.server->free)
3096                         SV_LinkEdict(ent);
3097 }
3098
3099 static void SV_VM_CB_InitEdict(prvm_edict_t *e)
3100 {
3101         // LordHavoc: for consistency set these here
3102         int num = PRVM_NUM_FOR_EDICT(e) - 1;
3103
3104         e->priv.server->move = false; // don't move on first frame
3105
3106         if (num >= 0 && num < svs.maxclients)
3107         {
3108                 prvm_eval_t *val;
3109                 // set colormap and team on newly created player entity
3110                 e->fields.server->colormap = num + 1;
3111                 e->fields.server->team = (svs.clients[num].colors & 15) + 1;
3112                 // set netname/clientcolors back to client values so that
3113                 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
3114                 // reset them
3115                 e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
3116                 if ((val = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.clientcolors)))
3117                         val->_float = svs.clients[num].colors;
3118                 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
3119                 if( prog->fieldoffsets.playermodel >= 0 )
3120                         PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
3121                 if( prog->fieldoffsets.playerskin >= 0 )
3122                         PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
3123                 // Assign netaddress (IP Address, etc)
3124                 if(prog->fieldoffsets.netaddress >= 0)
3125                 { // Valid Field; Process
3126                         if(svs.clients[num].netconnection != NULL)
3127                         {// Valid Address; Assign
3128                                 // Acquire Readable Address
3129                                 LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
3130                                 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString(svs.clients[num].netaddress);
3131                         }
3132                         else
3133                                 // Invalid / Bot
3134                                 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString("null/botclient");
3135                 }
3136         }
3137 }
3138
3139 static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
3140 {
3141         int i;
3142         int e;
3143
3144         World_UnlinkEdict(ed);          // unlink from world bsp
3145
3146         ed->fields.server->model = 0;
3147         ed->fields.server->takedamage = 0;
3148         ed->fields.server->modelindex = 0;
3149         ed->fields.server->colormap = 0;
3150         ed->fields.server->skin = 0;
3151         ed->fields.server->frame = 0;
3152         VectorClear(ed->fields.server->origin);
3153         VectorClear(ed->fields.server->angles);
3154         ed->fields.server->nextthink = -1;
3155         ed->fields.server->solid = 0;
3156
3157         // make sure csqc networking is aware of the removed entity
3158         e = PRVM_NUM_FOR_EDICT(ed);
3159         sv.csqcentityversion[e] = 0;
3160         for (i = 0;i < svs.maxclients;i++)
3161         {
3162                 if (svs.clients[i].csqcentityscope[e])
3163                         svs.clients[i].csqcentityscope[e] = 1; // removed, awaiting send
3164                 svs.clients[i].csqcentitysendflags[e] = 0xFFFFFF;
3165         }
3166 }
3167
3168 static void SV_VM_CB_CountEdicts(void)
3169 {
3170         int             i;
3171         prvm_edict_t    *ent;
3172         int             active, models, solid, step;
3173
3174         active = models = solid = step = 0;
3175         for (i=0 ; i<prog->num_edicts ; i++)
3176         {
3177                 ent = PRVM_EDICT_NUM(i);
3178                 if (ent->priv.server->free)
3179                         continue;
3180                 active++;
3181                 if (ent->fields.server->solid)
3182                         solid++;
3183                 if (ent->fields.server->model)
3184                         models++;
3185                 if (ent->fields.server->movetype == MOVETYPE_STEP)
3186                         step++;
3187         }
3188
3189         Con_Printf("num_edicts:%3i\n", prog->num_edicts);
3190         Con_Printf("active    :%3i\n", active);
3191         Con_Printf("view      :%3i\n", models);
3192         Con_Printf("touch     :%3i\n", solid);
3193         Con_Printf("step      :%3i\n", step);
3194 }
3195
3196 static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
3197 {
3198         // remove things from different skill levels or deathmatch
3199         if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
3200         {
3201                 if (deathmatch.integer)
3202                 {
3203                         if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
3204                         {
3205                                 return false;
3206                         }
3207                 }
3208                 else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY  ))
3209                         || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
3210                         || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD  )))
3211                 {
3212                         return false;
3213                 }
3214         }
3215         return true;
3216 }
3217
3218 static void SV_VM_Setup(void)
3219 {
3220         PRVM_Begin;
3221         PRVM_InitProg( PRVM_SERVERPROG );
3222
3223         // allocate the mempools
3224         // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
3225         prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
3226         prog->builtins = vm_sv_builtins;
3227         prog->numbuiltins = vm_sv_numbuiltins;
3228         prog->headercrc = PROGHEADER_CRC;
3229         prog->headercrc2 = PROGHEADER_CRC_TENEBRAE;
3230         prog->max_edicts = 512;
3231         if (sv.protocol == PROTOCOL_QUAKE)
3232                 prog->limit_edicts = 640; // before quake mission pack 1 this was 512
3233         else if (sv.protocol == PROTOCOL_QUAKEDP)
3234                 prog->limit_edicts = 2048; // guessing
3235         else if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
3236                 prog->limit_edicts = 2048; // guessing!
3237         else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
3238                 prog->limit_edicts = 4096; // guessing!
3239         else
3240                 prog->limit_edicts = MAX_EDICTS;
3241         prog->reserved_edicts = svs.maxclients;
3242         prog->edictprivate_size = sizeof(edict_engineprivate_t);
3243         prog->name = "server";
3244         prog->extensionstring = vm_sv_extensions;
3245         prog->loadintoworld = true;
3246
3247         prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
3248         prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
3249         prog->init_edict = SV_VM_CB_InitEdict;
3250         prog->free_edict = SV_VM_CB_FreeEdict;
3251         prog->count_edicts = SV_VM_CB_CountEdicts;
3252         prog->load_edict = SV_VM_CB_LoadEdict;
3253         prog->init_cmd = VM_SV_Cmd_Init;
3254         prog->reset_cmd = VM_SV_Cmd_Reset;
3255         prog->error_cmd = Host_Error;
3256         prog->ExecuteProgram = SVVM_ExecuteProgram;
3257
3258         // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
3259         PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields, 0, NULL );
3260
3261         // some mods compiled with scrambling compilers lack certain critical
3262         // global names and field names such as "self" and "time" and "nextthink"
3263         // so we have to set these offsets manually, matching the entvars_t
3264         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
3265         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
3266         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
3267         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
3268         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
3269         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
3270         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
3271         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
3272         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
3273         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
3274         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
3275         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
3276         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
3277         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
3278         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
3279         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
3280         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
3281         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
3282         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
3283         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
3284         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
3285         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
3286         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
3287         // OP_STATE is always supported on server (due to entvars_t)
3288         prog->flag |= PRVM_OP_STATE;
3289
3290         VM_CustomStats_Clear();//[515]: csqc
3291
3292         PRVM_End;
3293
3294         SV_Prepare_CSQC();
3295 }
3296
3297 void SV_VM_Begin(void)
3298 {
3299         PRVM_Begin;
3300         PRVM_SetProg( PRVM_SERVERPROG );
3301
3302         prog->globals.server->time = (float) sv.time;
3303 }
3304
3305 void SV_VM_End(void)
3306 {
3307         PRVM_End;
3308 }