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", "0", "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.05", "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)"};
 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)
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 and never limit frequency
1749                 clientrate = 1000000000;
1750                 maxsize = sizeof(sv_sendclientdatagram_buf);
1751                 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1752         }
1753         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)
1754         {
1755                 // no packet size limit support on older protocols because DP1-4 kick
1756                 // the client off if they overflow, and quake protocol shows less than
1757                 // the full entity set if rate limited
1758                 clientrate = max(NET_MINRATE, client->rate);
1759                 maxsize = 1024;
1760                 maxsize2 = 1024;
1761         }
1762         else
1763         {
1764                 // DP5 and later protocols support packet size limiting which is a
1765                 // better method than limiting packet frequency as QW does
1766                 //
1767                 // this rate limiting does not understand sys_ticrate 0
1768                 // (but no one should be running that on a server!)
1769                 maxsize = (int)(clientrate * sys_ticrate.value);
1770                 maxsize = bound(100, maxsize, 1400);
1771                 maxsize2 = 1400;
1772         }
1773
1774         // while downloading, limit entity updates to half the packet
1775         // (any leftover space will be used for downloading)
1776         if (host_client->download_file)
1777                 maxsize /= 2;
1778
1779         msg.data = sv_sendclientdatagram_buf;
1780         msg.maxsize = maxsize;
1781         msg.cursize = 0;
1782
1783         // obey rate limit by limiting packet frequency if the packet size
1784         // limiting fails
1785         // (usually this is caused by reliable messages)
1786         if (!NetConn_CanSend(client->netconnection))
1787         {
1788                 // send the datagram
1789                 //NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, true);
1790                 return;
1791         }
1792         else if (host_client->spawned)
1793         {
1794                 MSG_WriteByte (&msg, svc_time);
1795                 MSG_WriteFloat (&msg, sv.time);
1796
1797                 // add the client specific data to the datagram
1798                 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
1799                 // now update the stats[] array using any registered custom fields
1800                 VM_SV_UpdateCustomStats (client, client->edict, &msg, stats);
1801                 // set host_client->statsdeltabits
1802                 Protocol_UpdateClientStats (stats);
1803
1804                 // add as many queued unreliable messages (effects) as we can fit
1805                 // limit effects to half of the remaining space
1806                 msg.maxsize -= (msg.maxsize - msg.cursize) / 2;
1807                 if (client->unreliablemsg.cursize)
1808                         SV_WriteUnreliableMessages (client, &msg);
1809
1810                 msg.maxsize = maxsize;
1811
1812                 // now write as many entities as we can fit, and also sends stats
1813                 SV_WriteEntitiesToClient (client, client->edict, &msg);
1814         }
1815         else if (realtime > client->keepalivetime)
1816         {
1817                 // the player isn't totally in the game yet
1818                 // send small keepalive messages if too much time has passed
1819                 msg.maxsize = maxsize2;
1820                 client->keepalivetime = realtime + 5;
1821                 MSG_WriteChar (&msg, svc_nop);
1822         }
1823
1824         msg.maxsize = maxsize2;
1825
1826         // if a download is active, see if there is room to fit some download data
1827         // in this packet
1828         downloadsize = maxsize * 2 - msg.cursize - 7;
1829         if (host_client->download_file && host_client->download_started && downloadsize > 0)
1830         {
1831                 fs_offset_t downloadstart;
1832                 unsigned char data[1400];
1833                 downloadstart = FS_Tell(host_client->download_file);
1834                 downloadsize = min(downloadsize, (int)sizeof(data));
1835                 downloadsize = FS_Read(host_client->download_file, data, downloadsize);
1836                 // note this sends empty messages if at the end of the file, which is
1837                 // necessary to keep the packet loss logic working
1838                 // (the last blocks may be lost and need to be re-sent, and that will
1839                 //  only occur if the client acks the empty end messages, revealing
1840                 //  a gap in the download progress, causing the last blocks to be
1841                 //  sent again)
1842                 MSG_WriteChar (&msg, svc_downloaddata);
1843                 MSG_WriteLong (&msg, downloadstart);
1844                 MSG_WriteShort (&msg, downloadsize);
1845                 if (downloadsize > 0)
1846                         SZ_Write (&msg, data, downloadsize);
1847         }
1848
1849         // reliable only if none is in progress
1850         if(client->sendsignon != 2 && !client->netconnection->sendMessageLength)
1851                 SV_WriteDemoMessage(client, &(client->netconnection->message));
1852         // unreliable
1853         SV_WriteDemoMessage(client, &msg);
1854
1855 // send the datagram
1856         NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->sendsignon == 2);
1857         if (client->sendsignon == 1 && !client->netconnection->message.cursize)
1858                 client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
1859 }
1860
1861 /*
1862 =======================
1863 SV_UpdateToReliableMessages
1864 =======================
1865 */
1866 static void SV_UpdateToReliableMessages (void)
1867 {
1868         int i, j;
1869         client_t *client;
1870         prvm_eval_t *val;
1871         const char *name;
1872         const char *model;
1873         const char *skin;
1874
1875 // check for changes to be sent over the reliable streams
1876         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1877         {
1878                 // update the host_client fields we care about according to the entity fields
1879                 host_client->edict = PRVM_EDICT_NUM(i+1);
1880
1881                 // DP_SV_CLIENTNAME
1882                 name = PRVM_GetString(host_client->edict->fields.server->netname);
1883                 if (name == NULL)
1884                         name = "";
1885                 // always point the string back at host_client->name to keep it safe
1886                 strlcpy (host_client->name, name, sizeof (host_client->name));
1887                 host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
1888                 if (strcmp(host_client->old_name, host_client->name))
1889                 {
1890                         if (host_client->spawned)
1891                                 SV_BroadcastPrintf("%s changed name to %s\n", host_client->old_name, host_client->name);
1892                         strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
1893                         // send notification to all clients
1894                         MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
1895                         MSG_WriteByte (&sv.reliable_datagram, i);
1896                         MSG_WriteString (&sv.reliable_datagram, host_client->name);
1897                         SV_WriteNetnameIntoDemo(host_client);
1898                 }
1899
1900                 // DP_SV_CLIENTCOLORS
1901                 // this is always found (since it's added by the progs loader)
1902                 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcolors)))
1903                         host_client->colors = (int)val->_float;
1904                 if (host_client->old_colors != host_client->colors)
1905                 {
1906                         host_client->old_colors = host_client->colors;
1907                         // send notification to all clients
1908                         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1909                         MSG_WriteByte (&sv.reliable_datagram, i);
1910                         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1911                 }
1912
1913                 // NEXUIZ_PLAYERMODEL
1914                 if( prog->fieldoffsets.playermodel >= 0 ) {
1915                         model = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string);
1916                         if (model == NULL)
1917                                 model = "";
1918                         // always point the string back at host_client->name to keep it safe
1919                         strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
1920                         PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
1921                 }
1922
1923                 // NEXUIZ_PLAYERSKIN
1924                 if( prog->fieldoffsets.playerskin >= 0 ) {
1925                         skin = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string);
1926                         if (skin == NULL)
1927                                 skin = "";
1928                         // always point the string back at host_client->name to keep it safe
1929                         strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
1930                         PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
1931                 }
1932
1933                 // frags
1934                 host_client->frags = (int)host_client->edict->fields.server->frags;
1935                 if(gamemode == GAME_NEXUIZ)
1936                         if(!host_client->spawned && host_client->netconnection)
1937                                 host_client->frags = -666;
1938                 if (host_client->old_frags != host_client->frags)
1939                 {
1940                         host_client->old_frags = host_client->frags;
1941                         // send notification to all clients
1942                         MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
1943                         MSG_WriteByte (&sv.reliable_datagram, i);
1944                         MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
1945                 }
1946         }
1947
1948         for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1949                 if (client->netconnection)
1950                         SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
1951
1952         SZ_Clear (&sv.reliable_datagram);
1953 }
1954
1955
1956 /*
1957 =======================
1958 SV_SendClientMessages
1959 =======================
1960 */
1961 void SV_SendClientMessages (void)
1962 {
1963         int i, prepared = false;
1964
1965         if (sv.protocol == PROTOCOL_QUAKEWORLD)
1966                 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
1967
1968         SV_FlushBroadcastMessages();
1969
1970 // update frags, names, etc
1971         SV_UpdateToReliableMessages();
1972
1973 // build individual updates
1974         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1975         {
1976                 if (!host_client->active)
1977                         continue;
1978                 if (!host_client->netconnection)
1979                         continue;
1980
1981                 if (host_client->netconnection->message.overflowed)
1982                 {
1983                         SV_DropClient (true);   // if the message couldn't send, kick off
1984                         continue;
1985                 }
1986
1987                 if (!prepared)
1988                 {
1989                         prepared = true;
1990                         // only prepare entities once per frame
1991                         SV_PrepareEntitiesForSending();
1992                 }
1993                 SV_SendClientDatagram (host_client);
1994         }
1995
1996 // clear muzzle flashes
1997         SV_CleanupEnts();
1998 }
1999
2000 static void SV_StartDownload_f(void)
2001 {
2002         if (host_client->download_file)
2003                 host_client->download_started = true;
2004 }
2005
2006 static void SV_Download_f(void)
2007 {
2008         const char *whichpack, *whichpack2, *extension;
2009
2010         if (Cmd_Argc() != 2)
2011         {
2012                 SV_ClientPrintf("usage: download <filename>\n");
2013                 return;
2014         }
2015
2016         if (FS_CheckNastyPath(Cmd_Argv(1), false))
2017         {
2018                 SV_ClientPrintf("Download rejected: nasty filename \"%s\"\n", Cmd_Argv(1));
2019                 return;
2020         }
2021
2022         if (host_client->download_file)
2023         {
2024                 // at this point we'll assume the previous download should be aborted
2025                 Con_DPrintf("Download of %s aborted by %s starting a new download\n", host_client->download_name, host_client->name);
2026                 Host_ClientCommands("\nstopdownload\n");
2027
2028                 // close the file and reset variables
2029                 FS_Close(host_client->download_file);
2030                 host_client->download_file = NULL;
2031                 host_client->download_name[0] = 0;
2032                 host_client->download_expectedposition = 0;
2033                 host_client->download_started = false;
2034         }
2035
2036         if (!sv_allowdownloads.integer)
2037         {
2038                 SV_ClientPrintf("Downloads are disabled on this server\n");
2039                 Host_ClientCommands("\nstopdownload\n");
2040                 return;
2041         }
2042
2043         strlcpy(host_client->download_name, Cmd_Argv(1), sizeof(host_client->download_name));
2044         extension = FS_FileExtension(host_client->download_name);
2045
2046         // host_client is asking to download a specified file
2047         if (developer.integer >= 100)
2048                 Con_Printf("Download request for %s by %s\n", host_client->download_name, host_client->name);
2049
2050         if (!FS_FileExists(host_client->download_name))
2051         {
2052                 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);
2053                 Host_ClientCommands("\nstopdownload\n");
2054                 return;
2055         }
2056
2057         // check if the user is trying to download part of registered Quake(r)
2058         whichpack = FS_WhichPack(host_client->download_name);
2059         whichpack2 = FS_WhichPack("gfx/pop.lmp");
2060         if ((whichpack && whichpack2 && !strcasecmp(whichpack, whichpack2)) || FS_IsRegisteredQuakePack(host_client->download_name))
2061         {
2062                 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);
2063                 Host_ClientCommands("\nstopdownload\n");
2064                 return;
2065         }
2066
2067         // check if the server has forbidden archive downloads entirely
2068         if (!sv_allowdownloads_inarchive.integer)
2069         {
2070                 whichpack = FS_WhichPack(host_client->download_name);
2071                 if (whichpack)
2072                 {
2073                         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);
2074                         Host_ClientCommands("\nstopdownload\n");
2075                         return;
2076                 }
2077         }
2078
2079         if (!sv_allowdownloads_config.integer)
2080         {
2081                 if (!strcasecmp(extension, "cfg"))
2082                 {
2083                         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);
2084                         Host_ClientCommands("\nstopdownload\n");
2085                         return;
2086                 }
2087         }
2088
2089         if (!sv_allowdownloads_dlcache.integer)
2090         {
2091                 if (!strncasecmp(host_client->download_name, "dlcache/", 8))
2092                 {
2093                         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);
2094                         Host_ClientCommands("\nstopdownload\n");
2095                         return;
2096                 }
2097         }
2098
2099         if (!sv_allowdownloads_archive.integer)
2100         {
2101                 if (!strcasecmp(extension, "pak") || !strcasecmp(extension, "pk3"))
2102                 {
2103                         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);
2104                         Host_ClientCommands("\nstopdownload\n");
2105                         return;
2106                 }
2107         }
2108
2109         host_client->download_file = FS_Open(host_client->download_name, "rb", true, false);
2110         if (!host_client->download_file)
2111         {
2112                 SV_ClientPrintf("Download rejected: server could not open the file \"%s\"\n", host_client->download_name);
2113                 Host_ClientCommands("\nstopdownload\n");
2114                 return;
2115         }
2116
2117         if (FS_FileSize(host_client->download_file) > 1<<30)
2118         {
2119                 SV_ClientPrintf("Download rejected: file \"%s\" is very large\n", host_client->download_name);
2120                 Host_ClientCommands("\nstopdownload\n");
2121                 FS_Close(host_client->download_file);
2122                 host_client->download_file = NULL;
2123                 return;
2124         }
2125
2126         Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
2127
2128         Host_ClientCommands("\ncl_downloadbegin %i %s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name);
2129
2130         host_client->download_expectedposition = 0;
2131         host_client->download_started = false;
2132         host_client->sendsignon = true; // make sure this message is sent
2133
2134         // the rest of the download process is handled in SV_SendClientDatagram
2135         // and other code dealing with svc_downloaddata and clc_ackdownloaddata
2136         //
2137         // no svc_downloaddata messages will be sent until sv_startdownload is
2138         // sent by the client
2139 }
2140
2141 /*
2142 ==============================================================================
2143
2144 SERVER SPAWNING
2145
2146 ==============================================================================
2147 */
2148
2149 /*
2150 ================
2151 SV_ModelIndex
2152
2153 ================
2154 */
2155 int SV_ModelIndex(const char *s, int precachemode)
2156 {
2157         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);
2158         char filename[MAX_QPATH];
2159         if (!s || !*s)
2160                 return 0;
2161         // testing
2162         //if (precachemode == 2)
2163         //      return 0;
2164         strlcpy(filename, s, sizeof(filename));
2165         for (i = 2;i < limit;i++)
2166         {
2167                 if (!sv.model_precache[i][0])
2168                 {
2169                         if (precachemode)
2170                         {
2171                                 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))
2172                                 {
2173                                         Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
2174                                         return 0;
2175                                 }
2176                                 if (precachemode == 1)
2177                                         Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2178                                 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
2179                                 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, false);
2180                                 if (sv.state != ss_loading)
2181                                 {
2182                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2183                                         MSG_WriteShort(&sv.reliable_datagram, i);
2184                                         MSG_WriteString(&sv.reliable_datagram, filename);
2185                                 }
2186                                 return i;
2187                         }
2188                         Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
2189                         return 0;
2190                 }
2191                 if (!strcmp(sv.model_precache[i], filename))
2192                         return i;
2193         }
2194         Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
2195         return 0;
2196 }
2197
2198 /*
2199 ================
2200 SV_SoundIndex
2201
2202 ================
2203 */
2204 int SV_SoundIndex(const char *s, int precachemode)
2205 {
2206         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);
2207         char filename[MAX_QPATH];
2208         if (!s || !*s)
2209                 return 0;
2210         // testing
2211         //if (precachemode == 2)
2212         //      return 0;
2213         strlcpy(filename, s, sizeof(filename));
2214         for (i = 1;i < limit;i++)
2215         {
2216                 if (!sv.sound_precache[i][0])
2217                 {
2218                         if (precachemode)
2219                         {
2220                                 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))
2221                                 {
2222                                         Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
2223                                         return 0;
2224                                 }
2225                                 if (precachemode == 1)
2226                                         Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2227                                 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
2228                                 if (sv.state != ss_loading)
2229                                 {
2230                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2231                                         MSG_WriteShort(&sv.reliable_datagram, i + 32768);
2232                                         MSG_WriteString(&sv.reliable_datagram, filename);
2233                                 }
2234                                 return i;
2235                         }
2236                         Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
2237                         return 0;
2238                 }
2239                 if (!strcmp(sv.sound_precache[i], filename))
2240                         return i;
2241         }
2242         Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
2243         return 0;
2244 }
2245
2246 /*
2247 ================
2248 SV_ParticleEffectIndex
2249
2250 ================
2251 */
2252 int SV_ParticleEffectIndex(const char *name)
2253 {
2254         int i, argc, linenumber, effectnameindex;
2255         fs_offset_t filesize;
2256         unsigned char *filedata;
2257         const char *text, *textstart, *textend;
2258         char argv[16][1024];
2259         if (!sv.particleeffectnamesloaded)
2260         {
2261                 sv.particleeffectnamesloaded = true;
2262                 memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
2263                 for (i = 0;i < EFFECT_TOTAL;i++)
2264                         strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
2265                 filedata = FS_LoadFile("effectinfo.txt", tempmempool, true, &filesize);
2266                 if (filedata)
2267                 {
2268                         textstart = (const char *)filedata;
2269                         textend = (const char *)filedata + filesize;
2270                         text = textstart;
2271                         for (linenumber = 1;;linenumber++)
2272                         {
2273                                 argc = 0;
2274                                 for (;;)
2275                                 {
2276                                         if (!COM_ParseToken_Simple(&text, true, false) || !strcmp(com_token, "\n"))
2277                                                 break;
2278                                         if (argc < 16)
2279                                         {
2280                                                 strlcpy(argv[argc], com_token, sizeof(argv[argc]));
2281                                                 argc++;
2282                                         }
2283                                 }
2284                                 if (com_token[0] == 0)
2285                                         break; // if the loop exited and it's not a \n, it's EOF
2286                                 if (argc < 1)
2287                                         continue;
2288                                 if (!strcmp(argv[0], "effect"))
2289                                 {
2290                                         if (argc == 2)
2291                                         {
2292                                                 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME;effectnameindex++)
2293                                                 {
2294                                                         if (sv.particleeffectname[effectnameindex][0])
2295                                                         {
2296                                                                 if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
2297                                                                         break;
2298                                                         }
2299                                                         else
2300                                                         {
2301                                                                 strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
2302                                                                 break;
2303                                                         }
2304                                                 }
2305                                                 // if we run out of names, abort
2306                                                 if (effectnameindex == SV_MAX_PARTICLEEFFECTNAME)
2307                                                 {
2308                                                         Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
2309                                                         break;
2310                                                 }
2311                                         }
2312                                 }
2313                         }
2314                         Mem_Free(filedata);
2315                 }
2316         }
2317         // search for the name
2318         for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
2319                 if (!strcmp(sv.particleeffectname[effectnameindex], name))
2320                         return effectnameindex;
2321         // return 0 if we couldn't find it
2322         return 0;
2323 }
2324
2325 /*
2326 ================
2327 SV_CreateBaseline
2328
2329 ================
2330 */
2331 static void SV_CreateBaseline (void)
2332 {
2333         int i, entnum, large;
2334         prvm_edict_t *svent;
2335
2336         // LordHavoc: clear *all* states (note just active ones)
2337         for (entnum = 0;entnum < prog->max_edicts;entnum++)
2338         {
2339                 // get the current server version
2340                 svent = PRVM_EDICT_NUM(entnum);
2341
2342                 // LordHavoc: always clear state values, whether the entity is in use or not
2343                 svent->priv.server->baseline = defaultstate;
2344
2345                 if (svent->priv.server->free)
2346                         continue;
2347                 if (entnum > svs.maxclients && !svent->fields.server->modelindex)
2348                         continue;
2349
2350                 // create entity baseline
2351                 VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
2352                 VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
2353                 svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
2354                 svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
2355                 if (entnum > 0 && entnum <= svs.maxclients)
2356                 {
2357                         svent->priv.server->baseline.colormap = entnum;
2358                         svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
2359                 }
2360                 else
2361                 {
2362                         svent->priv.server->baseline.colormap = 0;
2363                         svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
2364                 }
2365
2366                 large = false;
2367                 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
2368                 {
2369                         large = true;
2370                         if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2371                                 large = false;
2372                 }
2373
2374                 // add to the message
2375                 if (large)
2376                         MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
2377                 else
2378                         MSG_WriteByte (&sv.signon, svc_spawnbaseline);
2379                 MSG_WriteShort (&sv.signon, entnum);
2380
2381                 if (large)
2382                 {
2383                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2384                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
2385                 }
2386                 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2387                 {
2388                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2389                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2390                 }
2391                 else
2392                 {
2393                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
2394                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2395                 }
2396                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
2397                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
2398                 for (i=0 ; i<3 ; i++)
2399                 {
2400                         MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
2401                         MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
2402                 }
2403         }
2404 }
2405
2406
2407 /*
2408 ================
2409 SV_SaveSpawnparms
2410
2411 Grabs the current state of each client for saving across the
2412 transition to another level
2413 ================
2414 */
2415 void SV_SaveSpawnparms (void)
2416 {
2417         int             i, j;
2418
2419         svs.serverflags = (int)prog->globals.server->serverflags;
2420
2421         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2422         {
2423                 if (!host_client->active)
2424                         continue;
2425
2426         // call the progs to get default spawn parms for the new client
2427                 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2428                 PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
2429                 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
2430                         host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
2431         }
2432 }
2433
2434 /*
2435 ================
2436 SV_SpawnServer
2437
2438 This is called at the start of each level
2439 ================
2440 */
2441
2442 void SV_SpawnServer (const char *server)
2443 {
2444         prvm_edict_t *ent;
2445         int i;
2446         char *entities;
2447         model_t *worldmodel;
2448         char modelname[sizeof(sv.modelname)];
2449
2450         Con_DPrintf("SpawnServer: %s\n", server);
2451
2452         if (cls.state != ca_dedicated)
2453         {
2454                 SCR_BeginLoadingPlaque();
2455                 S_StopAllSounds();
2456         }
2457
2458         dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
2459         worldmodel = Mod_ForName(modelname, false, true, true);
2460         if (!worldmodel || !worldmodel->TraceBox)
2461         {
2462                 Con_Printf("Couldn't load map %s\n", modelname);
2463                 return;
2464         }
2465
2466         // let's not have any servers with no name
2467         if (hostname.string[0] == 0)
2468                 Cvar_Set ("hostname", "UNNAMED");
2469         scr_centertime_off = 0;
2470
2471         svs.changelevel_issued = false;         // now safe to issue another
2472
2473         // make the map a required file for clients
2474         Curl_ClearRequirements();
2475         Curl_RequireFile(modelname);
2476
2477 //
2478 // tell all connected clients that we are going to a new level
2479 //
2480         if (sv.active)
2481         {
2482                 client_t *client;
2483                 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
2484                 {
2485                         if (client->netconnection)
2486                         {
2487                                 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
2488                                 MSG_WriteString(&client->netconnection->message, "reconnect\n");
2489                         }
2490                 }
2491         }
2492         else
2493         {
2494                 // open server port
2495                 NetConn_OpenServerPorts(true);
2496         }
2497
2498 //
2499 // make cvars consistant
2500 //
2501         if (coop.integer)
2502                 Cvar_SetValue ("deathmatch", 0);
2503         // LordHavoc: it can be useful to have skills outside the range 0-3...
2504         //current_skill = bound(0, (int)(skill.value + 0.5), 3);
2505         //Cvar_SetValue ("skill", (float)current_skill);
2506         current_skill = (int)(skill.value + 0.5);
2507
2508 //
2509 // set up the new server
2510 //
2511         memset (&sv, 0, sizeof(sv));
2512         // if running a local client, make sure it doesn't try to access the last
2513         // level's data which is no longer valiud
2514         cls.signon = 0;
2515
2516         if(*sv_random_seed.string)
2517         {
2518                 srand(sv_random_seed.integer);
2519                 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);
2520         }
2521
2522         SV_VM_Setup();
2523
2524         sv.active = true;
2525
2526         strlcpy (sv.name, server, sizeof (sv.name));
2527
2528         sv.protocol = Protocol_EnumForName(sv_protocolname.string);
2529         if (sv.protocol == PROTOCOL_UNKNOWN)
2530         {
2531                 char buffer[1024];
2532                 Protocol_Names(buffer, sizeof(buffer));
2533                 Con_Printf("Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
2534                 sv.protocol = PROTOCOL_QUAKE;
2535         }
2536
2537         SV_VM_Begin();
2538
2539 // load progs to get entity field count
2540         //PR_LoadProgs ( sv_progs.string );
2541
2542         sv.datagram.maxsize = sizeof(sv.datagram_buf);
2543         sv.datagram.cursize = 0;
2544         sv.datagram.data = sv.datagram_buf;
2545
2546         sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
2547         sv.reliable_datagram.cursize = 0;
2548         sv.reliable_datagram.data = sv.reliable_datagram_buf;
2549
2550         sv.signon.maxsize = sizeof(sv.signon_buf);
2551         sv.signon.cursize = 0;
2552         sv.signon.data = sv.signon_buf;
2553
2554 // leave slots at start for clients only
2555         //prog->num_edicts = svs.maxclients+1;
2556
2557         sv.state = ss_loading;
2558         prog->allowworldwrites = true;
2559         sv.paused = false;
2560
2561         prog->globals.server->time = sv.time = 1.0;
2562
2563         Mod_ClearUsed();
2564         worldmodel->used = true;
2565
2566         strlcpy (sv.name, server, sizeof (sv.name));
2567         strlcpy(sv.modelname, modelname, sizeof(sv.modelname));
2568         sv.worldmodel = worldmodel;
2569         sv.models[1] = sv.worldmodel;
2570
2571 //
2572 // clear world interaction links
2573 //
2574         VectorCopy(sv.worldmodel->normalmins, sv.world.areagrid_mins);
2575         VectorCopy(sv.worldmodel->normalmaxs, sv.world.areagrid_maxs);
2576         World_Clear(&sv.world);
2577
2578         strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
2579
2580         strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
2581         strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
2582         for (i = 1;i < sv.worldmodel->brush.numsubmodels;i++)
2583         {
2584                 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
2585                 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, false);
2586         }
2587
2588 //
2589 // load the rest of the entities
2590 //
2591         // AK possible hack since num_edicts is still 0
2592         ent = PRVM_EDICT_NUM(0);
2593         memset (ent->fields.server, 0, prog->progs->entityfields * 4);
2594         ent->priv.server->free = false;
2595         ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
2596         ent->fields.server->modelindex = 1;             // world model
2597         ent->fields.server->solid = SOLID_BSP;
2598         ent->fields.server->movetype = MOVETYPE_PUSH;
2599         VectorCopy(sv.worldmodel->normalmins, ent->fields.server->mins);
2600         VectorCopy(sv.worldmodel->normalmaxs, ent->fields.server->maxs);
2601         VectorCopy(sv.worldmodel->normalmins, ent->fields.server->absmin);
2602         VectorCopy(sv.worldmodel->normalmaxs, ent->fields.server->absmax);
2603
2604         if (coop.value)
2605                 prog->globals.server->coop = coop.integer;
2606         else
2607                 prog->globals.server->deathmatch = deathmatch.integer;
2608
2609         prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
2610
2611 // serverflags are for cross level information (sigils)
2612         prog->globals.server->serverflags = svs.serverflags;
2613
2614         // we need to reset the spawned flag on all connected clients here so that
2615         // their thinks don't run during startup (before PutClientInServer)
2616         // we also need to set up the client entities now
2617         // and we need to set the ->edict pointers to point into the progs edicts
2618         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2619         {
2620                 host_client->spawned = false;
2621                 host_client->edict = PRVM_EDICT_NUM(i + 1);
2622                 PRVM_ED_ClearEdict(host_client->edict);
2623         }
2624
2625         // load replacement entity file if found
2626         if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
2627         {
2628                 Con_Printf("Loaded maps/%s.ent\n", sv.name);
2629                 PRVM_ED_LoadFromFile (entities);
2630                 Mem_Free(entities);
2631         }
2632         else
2633                 PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
2634
2635
2636         // LordHavoc: clear world angles (to fix e3m3.bsp)
2637         VectorClear(prog->edicts->fields.server->angles);
2638
2639 // all setup is completed, any further precache statements are errors
2640         sv.state = ss_active;
2641         prog->allowworldwrites = false;
2642
2643 // run two frames to allow everything to settle
2644         for (i = 0;i < 2;i++)
2645         {
2646                 sv.frametime = 0.1;
2647                 SV_Physics ();
2648         }
2649
2650         Mod_PurgeUnused();
2651
2652 // create a baseline for more efficient communications
2653         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)
2654                 SV_CreateBaseline ();
2655
2656 // send serverinfo to all connected clients, and set up botclients coming back from a level change
2657         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2658         {
2659                 if (!host_client->active)
2660                         continue;
2661                 if (host_client->netconnection)
2662                         SV_SendServerinfo(host_client);
2663                 else
2664                 {
2665                         int j;
2666                         // if client is a botclient coming from a level change, we need to
2667                         // set up client info that normally requires networking
2668
2669                         // copy spawn parms out of the client_t
2670                         for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
2671                                 (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
2672
2673                         // call the spawn function
2674                         host_client->clientconnectcalled = true;
2675                         prog->globals.server->time = sv.time;
2676                         prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2677                         PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
2678                         PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
2679                         host_client->spawned = true;
2680                 }
2681         }
2682
2683         Con_DPrint("Server spawned.\n");
2684         NetConn_Heartbeat (2);
2685
2686         SV_VM_End();
2687 }
2688
2689 /////////////////////////////////////////////////////
2690 // SV VM stuff
2691
2692 static void SV_VM_CB_BeginIncreaseEdicts(void)
2693 {
2694         int i;
2695         prvm_edict_t *ent;
2696
2697         // links don't survive the transition, so unlink everything
2698         for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2699         {
2700                 if (!ent->priv.server->free)
2701                         World_UnlinkEdict(prog->edicts + i);
2702                 memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid));
2703         }
2704         World_Clear(&sv.world);
2705 }
2706
2707 static void SV_VM_CB_EndIncreaseEdicts(void)
2708 {
2709         int i;
2710         prvm_edict_t *ent;
2711
2712         // link every entity except world
2713         for (i = 1, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2714                 if (!ent->priv.server->free)
2715                         SV_LinkEdict(ent, false);
2716 }
2717
2718 static void SV_VM_CB_InitEdict(prvm_edict_t *e)
2719 {
2720         // LordHavoc: for consistency set these here
2721         int num = PRVM_NUM_FOR_EDICT(e) - 1;
2722
2723         e->priv.server->move = false; // don't move on first frame
2724
2725         if (num >= 0 && num < svs.maxclients)
2726         {
2727                 prvm_eval_t *val;
2728                 // set colormap and team on newly created player entity
2729                 e->fields.server->colormap = num + 1;
2730                 e->fields.server->team = (svs.clients[num].colors & 15) + 1;
2731                 // set netname/clientcolors back to client values so that
2732                 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
2733                 // reset them
2734                 e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
2735                 if ((val = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.clientcolors)))
2736                         val->_float = svs.clients[num].colors;
2737                 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
2738                 if( prog->fieldoffsets.playermodel >= 0 )
2739                         PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
2740                 if( prog->fieldoffsets.playerskin >= 0 )
2741                         PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
2742                 // Assign netaddress (IP Address, etc)
2743                 if(prog->fieldoffsets.netaddress >= 0)
2744                 { // Valid Field; Process
2745                         if(svs.clients[num].netconnection != NULL)
2746                         {// Valid Address; Assign
2747                                 // Acquire Readable Address
2748                                 LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
2749                                 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString(svs.clients[num].netaddress);
2750                         }
2751                         else
2752                                 // Invalid / Bot
2753                                 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString("null/botclient");
2754                 }
2755         }
2756 }
2757
2758 static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
2759 {
2760         World_UnlinkEdict(ed);          // unlink from world bsp
2761
2762         ed->fields.server->model = 0;
2763         ed->fields.server->takedamage = 0;
2764         ed->fields.server->modelindex = 0;
2765         ed->fields.server->colormap = 0;
2766         ed->fields.server->skin = 0;
2767         ed->fields.server->frame = 0;
2768         VectorClear(ed->fields.server->origin);
2769         VectorClear(ed->fields.server->angles);
2770         ed->fields.server->nextthink = -1;
2771         ed->fields.server->solid = 0;
2772 }
2773
2774 static void SV_VM_CB_CountEdicts(void)
2775 {
2776         int             i;
2777         prvm_edict_t    *ent;
2778         int             active, models, solid, step;
2779
2780         active = models = solid = step = 0;
2781         for (i=0 ; i<prog->num_edicts ; i++)
2782         {
2783                 ent = PRVM_EDICT_NUM(i);
2784                 if (ent->priv.server->free)
2785                         continue;
2786                 active++;
2787                 if (ent->fields.server->solid)
2788                         solid++;
2789                 if (ent->fields.server->model)
2790                         models++;
2791                 if (ent->fields.server->movetype == MOVETYPE_STEP)
2792                         step++;
2793         }
2794
2795         Con_Printf("num_edicts:%3i\n", prog->num_edicts);
2796         Con_Printf("active    :%3i\n", active);
2797         Con_Printf("view      :%3i\n", models);
2798         Con_Printf("touch     :%3i\n", solid);
2799         Con_Printf("step      :%3i\n", step);
2800 }
2801
2802 static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
2803 {
2804         // remove things from different skill levels or deathmatch
2805         if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
2806         {
2807                 if (deathmatch.integer)
2808                 {
2809                         if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
2810                         {
2811                                 return false;
2812                         }
2813                 }
2814                 else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY  ))
2815                         || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
2816                         || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD  )))
2817                 {
2818                         return false;
2819                 }
2820         }
2821         return true;
2822 }
2823
2824 static void SV_VM_Setup(void)
2825 {
2826         extern cvar_t csqc_progname;    //[515]: csqc crc check and right csprogs name according to progs.dat
2827         extern cvar_t csqc_progcrc;
2828         extern cvar_t csqc_progsize;
2829         size_t csprogsdatasize;
2830         PRVM_Begin;
2831         PRVM_InitProg( PRVM_SERVERPROG );
2832
2833         // allocate the mempools
2834         // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
2835         prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
2836         prog->builtins = vm_sv_builtins;
2837         prog->numbuiltins = vm_sv_numbuiltins;
2838         prog->headercrc = PROGHEADER_CRC;
2839         prog->max_edicts = 512;
2840         if (sv.protocol == PROTOCOL_QUAKE)
2841                 prog->limit_edicts = 640; // before quake mission pack 1 this was 512
2842         else if (sv.protocol == PROTOCOL_QUAKEDP)
2843                 prog->limit_edicts = 2048; // guessing
2844         else if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
2845                 prog->limit_edicts = 2048; // guessing!
2846         else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2847                 prog->limit_edicts = 4096; // guessing!
2848         else
2849                 prog->limit_edicts = MAX_EDICTS;
2850         prog->reserved_edicts = svs.maxclients;
2851         prog->edictprivate_size = sizeof(edict_engineprivate_t);
2852         prog->name = "server";
2853         prog->extensionstring = vm_sv_extensions;
2854         prog->loadintoworld = true;
2855
2856         prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
2857         prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
2858         prog->init_edict = SV_VM_CB_InitEdict;
2859         prog->free_edict = SV_VM_CB_FreeEdict;
2860         prog->count_edicts = SV_VM_CB_CountEdicts;
2861         prog->load_edict = SV_VM_CB_LoadEdict;
2862         prog->init_cmd = VM_SV_Cmd_Init;
2863         prog->reset_cmd = VM_SV_Cmd_Reset;
2864         prog->error_cmd = Host_Error;
2865
2866         // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
2867         PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields, 0, NULL );
2868
2869         // some mods compiled with scrambling compilers lack certain critical
2870         // global names and field names such as "self" and "time" and "nextthink"
2871         // so we have to set these offsets manually, matching the entvars_t
2872         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
2873         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
2874         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
2875         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
2876         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
2877         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
2878         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
2879         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
2880         PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
2881         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
2882         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
2883         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
2884         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
2885         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
2886         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
2887         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
2888         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
2889         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
2890         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
2891         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
2892         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
2893         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
2894         PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
2895         // OP_STATE is always supported on server (due to entvars_t)
2896         prog->flag |= PRVM_OP_STATE;
2897
2898         VM_CustomStats_Clear();//[515]: csqc
2899
2900         PRVM_End;
2901
2902         // 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
2903         sv.csqc_progname[0] = 0;
2904         sv.csqc_progcrc = FS_CRCFile(csqc_progname.string, &csprogsdatasize);
2905         sv.csqc_progsize = csprogsdatasize;
2906         if (sv.csqc_progsize > 0)
2907         {
2908                 strlcpy(sv.csqc_progname, csqc_progname.string, sizeof(sv.csqc_progname));
2909                 Con_DPrintf("server detected csqc progs file \"%s\" with size %i and crc %i\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
2910         }
2911 }
2912
2913 void SV_VM_Begin(void)
2914 {
2915         PRVM_Begin;
2916         PRVM_SetProg( PRVM_SERVERPROG );
2917
2918         prog->globals.server->time = (float) sv.time;
2919 }
2920
2921 void SV_VM_End(void)
2922 {
2923         PRVM_End;
2924 }