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