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