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