2 Copyright (C) 1996-1997 Id Software, Inc.
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.
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.
13 See the GNU General Public License for more details.
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.
20 // sv_main.c -- server main program
25 static void SV_SaveEntFile_f(void);
26 static void SV_StartDownload_f(void);
27 static void SV_Download_f(void);
28 static void SV_VM_Setup();
30 void VM_CustomStats_Clear (void);
31 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);
32 void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states);
34 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)"};
35 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)"};
36 cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};
37 cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
38 cvar_t noexit = {CVAR_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};
39 cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
40 cvar_t pausable = {0, "pausable","1", "allow players to pause or not"};
41 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)"};
42 cvar_t samelevel = {CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
43 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)"};
44 cvar_t slowmo = {0, "slowmo", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
46 cvar_t sv_accelerate = {0, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
47 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"};
48 cvar_t sv_airaccel_qw = {0, "sv_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration"};
49 cvar_t sv_airaccel_sideways_friction = {0, "sv_airaccel_sideways_friction", "", "anti-sideways movement stabilization (reduces speed gain when zigzagging)"};
50 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"};
51 cvar_t sv_allowdownloads = {0, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};
52 cvar_t sv_allowdownloads_archive = {0, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};
53 cvar_t sv_allowdownloads_config = {0, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};
54 cvar_t sv_allowdownloads_dlcache = {0, "sv_allowdownloads_dlcache", "0", "whether to allow downloads of dlcache files (dlcache/)"};
55 cvar_t sv_allowdownloads_inarchive = {0, "sv_allowdownloads_inarchive", "0", "whether to allow downloads from archives (pak/pk3)"};
56 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"};
57 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"};
58 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"};
59 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)"};
60 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)"};
61 cvar_t sv_clmovement_waitforinput = {0, "sv_clmovement_waitforinput", "16", "when a client does not send input for this many frames, force them to move anyway (unlike QuakeWorld)"};
62 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!)"};
63 cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"};
64 cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
65 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"};
66 cvar_t sv_cullentities_trace_delay = {0, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
67 cvar_t sv_cullentities_trace_enlarge = {0, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
68 cvar_t sv_cullentities_trace_prediction = {0, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};
69 cvar_t sv_cullentities_trace_samples = {0, "sv_cullentities_trace_samples", "1", "number of samples to test for entity culling"};
70 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"};
71 cvar_t sv_debugmove = {CVAR_NOTIFY, "sv_debugmove", "0", "disables collision detection optimizations for debugging purposes"};
72 cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1", "prints gamecode bprint() calls to server console"};
73 cvar_t sv_edgefriction = {0, "edgefriction", "2", "how much you slow down when nearing a ledge you might fall off"};
74 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)"};
75 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)"};
76 cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
77 cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4", "how fast you slow down"};
78 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"};
79 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"};
80 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)"};
81 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"};
82 cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
83 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"};
84 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"};
85 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"};
86 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"};
87 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)"};
88 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)"};
89 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"};
90 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"};
91 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
92 cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};
93 cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
94 cvar_t sv_jumpvelocity = {0, "sv_jumpvelocity", "270", "cvar that can be used by QuakeC code for jump velocity"};
95 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)"};
96 cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "1000000", "upper limit on client rate cvar, should reflect your network connection quality"};
97 cvar_t sv_maxspeed = {CVAR_NOTIFY, "sv_maxspeed", "320", "maximum speed a player can accelerate to when on ground (can be exceeded by tricks)"};
98 cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
99 cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0", "enables simpler/buggier player physics (not recommended)"};
100 cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
101 cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
102 cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
103 cvar_t sv_protocolname = {0, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
104 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"};
105 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)"};
106 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)"};
107 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)"};
108 cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
109 cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
110 cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
111 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"};
112 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"};
113 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)"};
114 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"};
115 cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};
117 cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
118 cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
119 cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
120 cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
121 cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
122 cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"};
123 cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"};
124 cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"};
125 cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"};
126 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 cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
129 cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
130 cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
131 cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
132 cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
133 cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
134 cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
135 cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
136 cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
137 cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
138 cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
139 cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
140 cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
141 cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
142 cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
143 cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
144 cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
145 cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
146 cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
147 cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
148 cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
153 mempool_t *sv_mempool = NULL;
155 extern cvar_t slowmo;
156 extern float scr_centertime_off;
158 // MUST match effectnameindex_t in client.h
159 static const char *standardeffectnames[EFFECT_TOTAL] =
183 "TE_TEI_BIGEXPLOSION",
199 #define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t))
201 prvm_required_field_t reqfields[] =
203 {ev_entity, "cursor_trace_ent"},
204 {ev_entity, "drawonlytoclient"},
205 {ev_entity, "exteriormodeltoclient"},
206 {ev_entity, "nodrawtoclient"},
207 {ev_entity, "tag_entity"},
208 {ev_entity, "viewmodelforclient"},
209 {ev_float, "Version"},
211 {ev_float, "ammo_cells1"},
212 {ev_float, "ammo_lava_nails"},
213 {ev_float, "ammo_multi_rockets"},
214 {ev_float, "ammo_nails1"},
215 {ev_float, "ammo_plasma"},
216 {ev_float, "ammo_rockets1"},
217 {ev_float, "ammo_shells1"},
218 {ev_float, "button3"},
219 {ev_float, "button4"},
220 {ev_float, "button5"},
221 {ev_float, "button6"},
222 {ev_float, "button7"},
223 {ev_float, "button8"},
224 {ev_float, "button9"},
225 {ev_float, "button10"},
226 {ev_float, "button11"},
227 {ev_float, "button12"},
228 {ev_float, "button13"},
229 {ev_float, "button14"},
230 {ev_float, "button15"},
231 {ev_float, "button16"},
232 {ev_float, "buttonchat"},
233 {ev_float, "buttonuse"},
234 {ev_float, "clientcolors"},
235 {ev_float, "cursor_active"},
236 {ev_float, "disableclientprediction"},
237 {ev_float, "fullbright"},
238 {ev_float, "glow_color"},
239 {ev_float, "glow_size"},
240 {ev_float, "glow_trail"},
241 {ev_float, "gravity"},
242 {ev_float, "idealpitch"},
243 {ev_float, "items2"},
244 {ev_float, "light_lev"},
245 {ev_float, "modelflags"},
246 {ev_float, "pflags"},
248 {ev_float, "pitch_speed"},
249 {ev_float, "pmodel"},
250 {ev_float, "renderamt"}, // HalfLife support
251 {ev_float, "rendermode"}, // HalfLife support
254 {ev_float, "tag_index"},
255 {ev_float, "viewzoom"},
256 {ev_function, "SendEntity"},
257 {ev_function, "contentstransition"}, // DRESK - Support for Entity Contents Transition Event
258 {ev_function, "customizeentityforclient"},
259 {ev_string, "netaddress"},
260 {ev_string, "playermodel"},
261 {ev_string, "playerskin"},
262 {ev_vector, "color"},
263 {ev_vector, "colormod"},
264 {ev_vector, "cursor_screen"},
265 {ev_vector, "cursor_trace_endpos"},
266 {ev_vector, "cursor_trace_start"},
267 {ev_vector, "movement"},
268 {ev_vector, "punchvector"},
273 //============================================================================
275 void SV_AreaStats_f(void)
277 World_PrintAreaStats(&sv.world, "server");
287 // init the csqc progs cvars, since they are updated/used by the server code
288 // TODO: fix this since this is a quick hack to make some of [515]'s broken code run ;) [9/13/2006 Black]
289 extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat
290 extern cvar_t csqc_progcrc;
291 extern cvar_t csqc_progsize;
292 Cvar_RegisterVariable (&csqc_progname);
293 Cvar_RegisterVariable (&csqc_progcrc);
294 Cvar_RegisterVariable (&csqc_progsize);
296 Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
297 Cmd_AddCommand("sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
298 Cmd_AddCommand_WithClientCommand("sv_startdownload", NULL, SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
299 Cmd_AddCommand_WithClientCommand("download", NULL, SV_Download_f, "downloads a specified file from the server");
301 Cvar_RegisterVariable (&coop);
302 Cvar_RegisterVariable (&deathmatch);
303 Cvar_RegisterVariable (&fraglimit);
304 Cvar_RegisterVariable (&gamecfg);
305 Cvar_RegisterVariable (&noexit);
306 Cvar_RegisterVariable (&nomonsters);
307 Cvar_RegisterVariable (&pausable);
308 Cvar_RegisterVariable (&pr_checkextension);
309 Cvar_RegisterVariable (&samelevel);
310 Cvar_RegisterVariable (&skill);
311 Cvar_RegisterVariable (&slowmo);
312 Cvar_RegisterVariable (&sv_accelerate);
313 Cvar_RegisterVariable (&sv_aim);
314 Cvar_RegisterVariable (&sv_airaccel_qw);
315 Cvar_RegisterVariable (&sv_airaccel_sideways_friction);
316 Cvar_RegisterVariable (&sv_airaccelerate);
317 Cvar_RegisterVariable (&sv_allowdownloads);
318 Cvar_RegisterVariable (&sv_allowdownloads_archive);
319 Cvar_RegisterVariable (&sv_allowdownloads_config);
320 Cvar_RegisterVariable (&sv_allowdownloads_dlcache);
321 Cvar_RegisterVariable (&sv_allowdownloads_inarchive);
322 Cvar_RegisterVariable (&sv_areagrid_mingridsize);
323 Cvar_RegisterVariable (&sv_checkforpacketsduringsleep);
324 Cvar_RegisterVariable (&sv_clmovement_enable);
325 Cvar_RegisterVariable (&sv_clmovement_minping);
326 Cvar_RegisterVariable (&sv_clmovement_minping_disabletime);
327 Cvar_RegisterVariable (&sv_clmovement_waitforinput);
328 Cvar_RegisterVariable (&sv_cullentities_nevercullbmodels);
329 Cvar_RegisterVariable (&sv_cullentities_pvs);
330 Cvar_RegisterVariable (&sv_cullentities_stats);
331 Cvar_RegisterVariable (&sv_cullentities_trace);
332 Cvar_RegisterVariable (&sv_cullentities_trace_delay);
333 Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
334 Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
335 Cvar_RegisterVariable (&sv_cullentities_trace_samples);
336 Cvar_RegisterVariable (&sv_cullentities_trace_samples_extra);
337 Cvar_RegisterVariable (&sv_debugmove);
338 Cvar_RegisterVariable (&sv_echobprint);
339 Cvar_RegisterVariable (&sv_edgefriction);
340 Cvar_RegisterVariable (&sv_entpatch);
341 Cvar_RegisterVariable (&sv_fixedframeratesingleplayer);
342 Cvar_RegisterVariable (&sv_freezenonclients);
343 Cvar_RegisterVariable (&sv_friction);
344 Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
345 Cvar_RegisterVariable (&sv_gameplayfix_delayprojectiles);
346 Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid);
347 Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
348 Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
349 Cvar_RegisterVariable (&sv_gameplayfix_multiplethinksperframe);
350 Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
351 Cvar_RegisterVariable (&sv_gameplayfix_qwplayerphysics);
352 Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
353 Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
354 Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
355 Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
356 Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
357 Cvar_RegisterVariable (&sv_gravity);
358 Cvar_RegisterVariable (&sv_idealpitchscale);
359 Cvar_RegisterVariable (&sv_jumpstep);
360 Cvar_RegisterVariable (&sv_jumpvelocity);
361 Cvar_RegisterVariable (&sv_maxairspeed);
362 Cvar_RegisterVariable (&sv_maxrate);
363 Cvar_RegisterVariable (&sv_maxspeed);
364 Cvar_RegisterVariable (&sv_maxvelocity);
365 Cvar_RegisterVariable (&sv_newflymove);
366 Cvar_RegisterVariable (&sv_nostep);
367 Cvar_RegisterVariable (&sv_playerphysicsqc);
368 Cvar_RegisterVariable (&sv_progs);
369 Cvar_RegisterVariable (&sv_protocolname);
370 Cvar_RegisterVariable (&sv_random_seed);
371 Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
372 Cvar_RegisterVariable (&sv_sound_land);
373 Cvar_RegisterVariable (&sv_sound_watersplash);
374 Cvar_RegisterVariable (&sv_stepheight);
375 Cvar_RegisterVariable (&sv_stopspeed);
376 Cvar_RegisterVariable (&sv_wallfriction);
377 Cvar_RegisterVariable (&sv_wateraccelerate);
378 Cvar_RegisterVariable (&sv_waterfriction);
379 Cvar_RegisterVariable (&sys_ticrate);
380 Cvar_RegisterVariable (&teamplay);
381 Cvar_RegisterVariable (&timelimit);
383 Cvar_RegisterVariable (&saved1);
384 Cvar_RegisterVariable (&saved2);
385 Cvar_RegisterVariable (&saved3);
386 Cvar_RegisterVariable (&saved4);
387 Cvar_RegisterVariable (&savedgamecfg);
388 Cvar_RegisterVariable (&scratch1);
389 Cvar_RegisterVariable (&scratch2);
390 Cvar_RegisterVariable (&scratch3);
391 Cvar_RegisterVariable (&scratch4);
392 Cvar_RegisterVariable (&temp1);
394 // LordHavoc: Nehahra uses these to pass data around cutscene demos
395 if (gamemode == GAME_NEHAHRA)
397 Cvar_RegisterVariable (&nehx00);
398 Cvar_RegisterVariable (&nehx01);
399 Cvar_RegisterVariable (&nehx02);
400 Cvar_RegisterVariable (&nehx03);
401 Cvar_RegisterVariable (&nehx04);
402 Cvar_RegisterVariable (&nehx05);
403 Cvar_RegisterVariable (&nehx06);
404 Cvar_RegisterVariable (&nehx07);
405 Cvar_RegisterVariable (&nehx08);
406 Cvar_RegisterVariable (&nehx09);
407 Cvar_RegisterVariable (&nehx10);
408 Cvar_RegisterVariable (&nehx11);
409 Cvar_RegisterVariable (&nehx12);
410 Cvar_RegisterVariable (&nehx13);
411 Cvar_RegisterVariable (&nehx14);
412 Cvar_RegisterVariable (&nehx15);
413 Cvar_RegisterVariable (&nehx16);
414 Cvar_RegisterVariable (&nehx17);
415 Cvar_RegisterVariable (&nehx18);
416 Cvar_RegisterVariable (&nehx19);
418 Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
420 // any special defaults for gamemodes go here
421 if (gamemode == GAME_HIPNOTIC)
423 // 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.
424 Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
426 if (gamemode == GAME_ROGUE)
428 // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
429 Cvar_SetValueQuick (&sv_gameplayfix_findradiusdistancetobox, 0);
432 sv_mempool = Mem_AllocPool("server", 0, NULL);
435 static void SV_SaveEntFile_f(void)
437 char basename[MAX_QPATH];
438 if (!sv.active || !sv.worldmodel)
440 Con_Print("Not running a server\n");
443 FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
444 FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
449 =============================================================================
453 =============================================================================
460 Make sure the event gets sent to all clients
463 void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
467 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
469 MSG_WriteByte (&sv.datagram, svc_particle);
470 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
471 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
472 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
473 for (i=0 ; i<3 ; i++)
474 MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
475 MSG_WriteByte (&sv.datagram, count);
476 MSG_WriteByte (&sv.datagram, color);
477 SV_FlushBroadcastMessages();
484 Make sure the event gets sent to all clients
487 void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
489 if (modelindex >= 256 || startframe >= 256)
491 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
493 MSG_WriteByte (&sv.datagram, svc_effect2);
494 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
495 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
496 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
497 MSG_WriteShort (&sv.datagram, modelindex);
498 MSG_WriteShort (&sv.datagram, startframe);
499 MSG_WriteByte (&sv.datagram, framecount);
500 MSG_WriteByte (&sv.datagram, framerate);
504 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
506 MSG_WriteByte (&sv.datagram, svc_effect);
507 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
508 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
509 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
510 MSG_WriteByte (&sv.datagram, modelindex);
511 MSG_WriteByte (&sv.datagram, startframe);
512 MSG_WriteByte (&sv.datagram, framecount);
513 MSG_WriteByte (&sv.datagram, framerate);
515 SV_FlushBroadcastMessages();
522 Each entity can have eight independant sound sources, like voice,
525 Channel 0 is an auto-allocate channel, the others override anything
526 already running on that entity/channel pair.
528 An attenuation of 0 will play full volume everywhere in the level.
529 Larger attenuations will drop off. (max 4 attenuation)
533 void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation)
535 int sound_num, field_mask, i, ent;
537 if (volume < 0 || volume > 255)
539 Con_Printf ("SV_StartSound: volume = %i\n", volume);
543 if (attenuation < 0 || attenuation > 4)
545 Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
549 if (channel < 0 || channel > 7)
551 Con_Printf ("SV_StartSound: channel = %i\n", channel);
555 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
558 // find precache number for sound
559 sound_num = SV_SoundIndex(sample, 1);
563 ent = PRVM_NUM_FOR_EDICT(entity);
566 if (volume != DEFAULT_SOUND_PACKET_VOLUME)
567 field_mask |= SND_VOLUME;
568 if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
569 field_mask |= SND_ATTENUATION;
571 field_mask |= SND_LARGEENTITY;
572 if (sound_num >= 256 || channel >= 8)
573 field_mask |= SND_LARGESOUND;
575 // directed messages go only to the entity they are targeted on
576 MSG_WriteByte (&sv.datagram, svc_sound);
577 MSG_WriteByte (&sv.datagram, field_mask);
578 if (field_mask & SND_VOLUME)
579 MSG_WriteByte (&sv.datagram, volume);
580 if (field_mask & SND_ATTENUATION)
581 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
582 if (field_mask & SND_LARGEENTITY)
584 MSG_WriteShort (&sv.datagram, ent);
585 MSG_WriteByte (&sv.datagram, channel);
588 MSG_WriteShort (&sv.datagram, (ent<<3) | channel);
589 if (field_mask & SND_LARGESOUND)
590 MSG_WriteShort (&sv.datagram, sound_num);
592 MSG_WriteByte (&sv.datagram, sound_num);
593 for (i = 0;i < 3;i++)
594 MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
595 SV_FlushBroadcastMessages();
599 ==============================================================================
603 ==============================================================================
610 Sends the first message from the server to a connected client.
611 This will be sent on the initial connection and upon each server load.
614 void SV_SendServerinfo (client_t *client)
619 // we know that this client has a netconnection and thus is not a bot
621 // edicts get reallocated on level changes, so we need to update it here
622 client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
624 // clear cached stuff that depends on the level
625 client->weaponmodel[0] = 0;
626 client->weaponmodelindex = 0;
628 // LordHavoc: clear entityframe tracking
629 client->latestframenum = 0;
631 if (client->entitydatabase)
632 EntityFrame_FreeDatabase(client->entitydatabase);
633 if (client->entitydatabase4)
634 EntityFrame4_FreeDatabase(client->entitydatabase4);
635 if (client->entitydatabase5)
636 EntityFrame5_FreeDatabase(client->entitydatabase5);
638 memset(client->stats, 0, sizeof(client->stats));
639 memset(client->statsdeltabits, 0, sizeof(client->statsdeltabits));
641 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)
643 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
644 client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
645 else if (sv.protocol == PROTOCOL_DARKPLACES4)
646 client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
648 client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
651 // reset csqc entity versions
652 memset(client->csqcentityversion, 0, sizeof(client->csqcentityversion));
654 SZ_Clear (&client->netconnection->message);
655 MSG_WriteByte (&client->netconnection->message, svc_print);
656 dpsnprintf (message, sizeof (message), "\nServer: %s build %s (progs %i crc)", gamename, buildstring, prog->filecrc);
657 MSG_WriteString (&client->netconnection->message,message);
659 //[515]: init csprogs according to version of svprogs, check the crc, etc.
660 if (sv.csqc_progname[0])
663 Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
664 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
665 MSG_WriteString (&client->netconnection->message, va("csqc_progname %s\n", sv.csqc_progname));
666 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
667 MSG_WriteString (&client->netconnection->message, va("csqc_progsize %i\n", sv.csqc_progsize));
668 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
669 MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i\n", sv.csqc_progcrc));
670 //[515]: init stufftext string (it is sent before svc_serverinfo)
671 val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.SV_InitCmd);
674 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
675 MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(val->string)));
679 if (sv_allowdownloads.integer)
681 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
682 MSG_WriteString (&client->netconnection->message, "cl_serverextension_download 1");
685 // send at this time so it's guaranteed to get executed at the right time
689 host_client = client;
690 Curl_SendRequirements();
694 MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
695 MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
696 MSG_WriteByte (&client->netconnection->message, svs.maxclients);
698 if (!coop.integer && deathmatch.integer)
699 MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
701 MSG_WriteByte (&client->netconnection->message, GAME_COOP);
703 MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
705 for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
706 MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
707 MSG_WriteByte (&client->netconnection->message, 0);
709 for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
710 MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
711 MSG_WriteByte (&client->netconnection->message, 0);
714 MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
715 MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
716 MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
719 MSG_WriteByte (&client->netconnection->message, svc_setview);
720 MSG_WriteShort (&client->netconnection->message, PRVM_NUM_FOR_EDICT(client->edict));
722 MSG_WriteByte (&client->netconnection->message, svc_signonnum);
723 MSG_WriteByte (&client->netconnection->message, 1);
725 client->spawned = false; // need prespawn, spawn, etc
726 client->sendsignon = 1; // send this message, and increment to 2, 2 will be set to 0 by the prespawn command
728 // clear movement info until client enters the new level properly
729 memset(&client->cmd, 0, sizeof(client->cmd));
730 client->movesequence = 0;
731 #ifdef NUM_PING_TIMES
732 for (i = 0;i < NUM_PING_TIMES;i++)
733 client->ping_times[i] = 0;
734 client->num_pings = 0;
743 Initializes a client_t for a new net connection. This will only be called
744 once for a player each game, not once for each level change.
747 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
751 float spawn_parms[NUM_SPAWN_PARMS];
753 client = svs.clients + clientnum;
755 // set up the client_t
757 memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
758 memset (client, 0, sizeof(*client));
759 client->active = true;
760 client->netconnection = netconnection;
762 Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
764 strlcpy(client->name, "unconnected", sizeof(client->name));
765 strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
766 client->spawned = false;
767 client->edict = PRVM_EDICT_NUM(clientnum+1);
768 if (client->netconnection)
769 client->netconnection->message.allowoverflow = true; // we can catch it
770 // prepare the unreliable message buffer
771 client->unreliablemsg.data = client->unreliablemsg_data;
772 client->unreliablemsg.maxsize = sizeof(client->unreliablemsg_data);
773 // updated by receiving "rate" command from client, this is also the default if not using a DP client
774 client->rate = 1000000000;
775 // no limits for local player
776 if (client->netconnection && LHNETADDRESS_GetAddressType(&client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP)
777 client->rate = 1000000000;
778 client->connecttime = realtime;
781 memcpy (client->spawn_parms, spawn_parms, sizeof(spawn_parms));
784 // call the progs to get default spawn parms for the new client
785 // set self to world to intentionally cause errors with broken SetNewParms code in some mods
786 prog->globals.server->self = 0;
787 PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
788 for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
789 client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
791 // set up the entity for this client (including .colormap, .team, etc)
792 PRVM_ED_ClearEdict(client->edict);
795 // don't call SendServerinfo for a fresh botclient because its fields have
796 // not been set up by the qc yet
797 if (client->netconnection)
798 SV_SendServerinfo (client);
800 client->spawned = true;
805 ===============================================================================
809 ===============================================================================
813 =============================================================================
815 The PVS must include a small area around the client to allow head bobbing
816 or other small motion on the client side. Otherwise, a bob might cause an
817 entity that should be visible to not show up, especially when the bob
820 =============================================================================
823 static qboolean SV_BuildEntityState (entity_state_t *cs, prvm_edict_t *ent, int enumber)
826 unsigned int tagentity;
827 unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
828 unsigned int customizeentityforclient;
830 vec3_t cullmins, cullmaxs, netcenter;
834 // see if the customizeentityforclient extension is used by this entity
835 customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function;
836 if (customizeentityforclient)
838 prog->globals.server->self = enumber;
839 prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
840 PRVM_ExecuteProgram(customizeentityforclient, "customizeentityforclient: NULL function");
841 // customizeentityforclient can return false to reject the entity
842 if (!PRVM_G_FLOAT(OFS_RETURN))
846 // this 2 billion unit check is actually to detect NAN origins
847 // (we really don't want to send those)
848 if (!(VectorLength2(ent->fields.server->origin) < 2000000000.0*2000000000.0))
851 // EF_NODRAW prevents sending for any reason except for your own
852 // client, so we must keep all clients in this superset
853 effects = (unsigned)ent->fields.server->effects;
855 // we can omit invisible entities with no effects that are not clients
856 // LordHavoc: this could kill tags attached to an invisible entity, I
857 // just hope we never have to support that case
858 i = (int)ent->fields.server->modelindex;
859 modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model)) ? i : 0;
862 i = (int)(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_size)->_float * 0.25f);
863 glowsize = (unsigned char)bound(0, i, 255);
864 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->_float)
865 flags |= RENDER_GLOWTRAIL;
866 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict)
867 flags |= RENDER_VIEWMODEL;
869 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[0]*256;
870 light[0] = (unsigned short)bound(0, f, 65535);
871 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[1]*256;
872 light[1] = (unsigned short)bound(0, f, 65535);
873 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[2]*256;
874 light[2] = (unsigned short)bound(0, f, 65535);
875 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.light_lev)->_float;
876 light[3] = (unsigned short)bound(0, f, 65535);
877 lightstyle = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.style)->_float;
878 lightpflags = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pflags)->_float;
880 if (gamemode == GAME_TENEBRAE)
882 // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
886 lightpflags |= PFLAGS_FULLDYNAMIC;
888 // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
892 light[0] = (int)(0.2*256);
893 light[1] = (int)(1.0*256);
894 light[2] = (int)(0.2*256);
896 lightpflags |= PFLAGS_FULLDYNAMIC;
900 specialvisibilityradius = 0;
901 if (lightpflags & PFLAGS_FULLDYNAMIC)
902 specialvisibilityradius = max(specialvisibilityradius, light[3]);
904 specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
905 if (flags & RENDER_GLOWTRAIL)
906 specialvisibilityradius = max(specialvisibilityradius, 100);
907 if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
909 if (effects & EF_BRIGHTFIELD)
910 specialvisibilityradius = max(specialvisibilityradius, 80);
911 if (effects & EF_MUZZLEFLASH)
912 specialvisibilityradius = max(specialvisibilityradius, 100);
913 if (effects & EF_BRIGHTLIGHT)
914 specialvisibilityradius = max(specialvisibilityradius, 400);
915 if (effects & EF_DIMLIGHT)
916 specialvisibilityradius = max(specialvisibilityradius, 200);
917 if (effects & EF_RED)
918 specialvisibilityradius = max(specialvisibilityradius, 200);
919 if (effects & EF_BLUE)
920 specialvisibilityradius = max(specialvisibilityradius, 200);
921 if (effects & EF_FLAME)
922 specialvisibilityradius = max(specialvisibilityradius, 250);
923 if (effects & EF_STARDUST)
924 specialvisibilityradius = max(specialvisibilityradius, 100);
927 // don't send uninteresting entities
928 if (enumber != sv.writeentitiestoclient_cliententitynumber)
930 if (!modelindex && !specialvisibilityradius)
932 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict == sv.writeentitiestoclient_cliententitynumber)
934 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict != sv.writeentitiestoclient_cliententitynumber)
936 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict != sv.writeentitiestoclient_cliententitynumber)
938 if (flags & RENDER_VIEWMODEL && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict != sv.writeentitiestoclient_cliententitynumber)
940 if (effects & EF_NODRAW)
944 // don't send child if parent was rejected
945 // FIXME: it would be better to force the parent to send...
946 tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict;
947 if (tagentity && !SV_BuildEntityState(NULL, PRVM_EDICT_NUM(tagentity), tagentity))
950 // calculate the visible box of this entity (don't use the physics box
951 // as that is often smaller than a model, and would not count
952 // specialvisibilityradius)
953 if ((model = sv.models[modelindex]))
955 float scale = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float;
957 scale *= (1.0f / 16.0f);
960 if (ent->fields.server->angles[0] || ent->fields.server->angles[2]) // pitch and roll
962 VectorMA(ent->fields.server->origin, scale, model->rotatedmins, cullmins);
963 VectorMA(ent->fields.server->origin, scale, model->rotatedmaxs, cullmaxs);
965 else if (ent->fields.server->angles[1])
967 VectorMA(ent->fields.server->origin, scale, model->yawmins, cullmins);
968 VectorMA(ent->fields.server->origin, scale, model->yawmaxs, cullmaxs);
972 VectorMA(ent->fields.server->origin, scale, model->normalmins, cullmins);
973 VectorMA(ent->fields.server->origin, scale, model->normalmaxs, cullmaxs);
978 // if there is no model (or it could not be loaded), use the physics box
979 VectorAdd(ent->fields.server->origin, ent->fields.server->mins, cullmins);
980 VectorAdd(ent->fields.server->origin, ent->fields.server->maxs, cullmaxs);
982 if (specialvisibilityradius)
984 cullmins[0] = min(cullmins[0], ent->fields.server->origin[0] - specialvisibilityradius);
985 cullmins[1] = min(cullmins[1], ent->fields.server->origin[1] - specialvisibilityradius);
986 cullmins[2] = min(cullmins[2], ent->fields.server->origin[2] - specialvisibilityradius);
987 cullmaxs[0] = max(cullmaxs[0], ent->fields.server->origin[0] + specialvisibilityradius);
988 cullmaxs[1] = max(cullmaxs[1], ent->fields.server->origin[1] + specialvisibilityradius);
989 cullmaxs[2] = max(cullmaxs[2], ent->fields.server->origin[2] + specialvisibilityradius);
992 // calculate center of bbox for network prioritization purposes
993 VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, netcenter);
995 // if culling box has moved, update pvs cluster links
996 if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
998 VectorCopy(cullmins, ent->priv.server->cullmins);
999 VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
1000 // a value of -1 for pvs_numclusters indicates that the links are not
1001 // cached, and should be re-tested each time, this is the case if the
1002 // culling box touches too many pvs clusters to store, or if the world
1003 // model does not support FindBoxClusters
1004 ent->priv.server->pvs_numclusters = -1;
1005 if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
1007 i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
1008 if (i <= MAX_ENTITYCLUSTERS)
1009 ent->priv.server->pvs_numclusters = i;
1013 if (enumber != sv.writeentitiestoclient_cliententitynumber && !(effects & EF_NODEPTHTEST) && !(flags & RENDER_VIEWMODEL) && !tagentity)
1015 qboolean isbmodel = (model = sv.models[modelindex]) != NULL && model->name[0] == '*';
1016 if (!isbmodel || !sv_cullentities_nevercullbmodels.integer)
1018 // cull based on visibility
1020 // if not touching a visible leaf
1021 if (sv_cullentities_pvs.integer && sv.writeentitiestoclient_pvsbytes)
1023 if (ent->priv.server->pvs_numclusters < 0)
1025 // entity too big for clusters list
1026 if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, cullmins, cullmaxs))
1028 sv.writeentitiestoclient_stats_culled_pvs++;
1035 // check cached clusters list
1036 for (i = 0;i < ent->priv.server->pvs_numclusters;i++)
1037 if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ent->priv.server->pvs_clusterlist[i]))
1039 if (i == ent->priv.server->pvs_numclusters)
1041 sv.writeentitiestoclient_stats_culled_pvs++;
1047 // or not seen by random tracelines
1048 if (sv_cullentities_trace.integer && !isbmodel)
1050 int samples = specialvisibilityradius ? sv_cullentities_trace_samples_extra.integer : sv_cullentities_trace_samples.integer;
1051 float enlarge = sv_cullentities_trace_enlarge.value;
1053 qboolean visible = true;
1057 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, sv.writeentitiestoclient_testeye, cullmins, cullmaxs))
1058 break; // directly visible from the server's view
1060 if(sv_cullentities_trace_prediction.integer)
1064 // get player velocity
1065 float predtime = bound(0, host_client->ping, 0.2); // / 2
1066 // sorry, no wallhacking by high ping please, and at 200ms
1067 // ping a FPS is annoying to play anyway and a player is
1068 // likely to have changed his direction
1069 VectorMA(sv.writeentitiestoclient_testeye, predtime, host_client->edict->fields.server->velocity, predeye);
1070 if(sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, sv.writeentitiestoclient_testeye, predeye)) // must be able to go there...
1072 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, predeye, cullmins, cullmaxs))
1073 break; // directly visible from the predicted view
1077 //Con_DPrintf("Trying to walk into solid in a pingtime... not predicting for culling\n");
1081 // when we get here, we can't see the entity
1087 svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[enumber] = realtime + sv_cullentities_trace_delay.value;
1088 else if (realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[enumber])
1090 sv.writeentitiestoclient_stats_culled_trace++;
1097 // if the caller was just checking... return true
1103 cs->number = enumber;
1104 VectorCopy(netcenter, cs->netcenter);
1105 VectorCopy(ent->fields.server->origin, cs->origin);
1106 VectorCopy(ent->fields.server->angles, cs->angles);
1108 cs->effects = effects;
1109 cs->colormap = (unsigned)ent->fields.server->colormap;
1110 cs->modelindex = modelindex;
1111 cs->skin = (unsigned)ent->fields.server->skin;
1112 cs->frame = (unsigned)ent->fields.server->frame;
1113 cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict;
1114 cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
1115 cs->glowsize = glowsize;
1117 // don't need to init cs->colormod because the defaultstate did that for us
1118 //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
1119 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod);
1120 if (val->vector[0] || val->vector[1] || val->vector[2])
1122 i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
1123 i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
1124 i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
1127 cs->modelindex = modelindex;
1130 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f);
1134 cs->alpha = (unsigned char)bound(0, i, 255);
1137 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float);
1141 cs->alpha = (unsigned char)bound(0, i, 255);
1145 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f);
1149 cs->scale = (unsigned char)bound(0, i, 255);
1152 cs->glowcolor = 254;
1153 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float);
1155 cs->glowcolor = (int)f;
1157 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float)
1158 cs->effects |= EF_FULLBRIGHT;
1160 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.modelflags);
1161 if (val && val->_float)
1162 cs->effects |= ((unsigned int)val->_float & 0xff) << 24;
1164 if (ent->fields.server->movetype == MOVETYPE_STEP)
1165 cs->flags |= RENDER_STEP;
1166 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)
1167 cs->flags |= RENDER_LOWPRECISION;
1168 if (ent->fields.server->colormap >= 1024)
1169 cs->flags |= RENDER_COLORMAPPED;
1170 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->edict && PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->edict == sv.writeentitiestoclient_cliententitynumber)
1171 cs->flags |= RENDER_EXTERIORMODEL;
1173 cs->light[0] = light[0];
1174 cs->light[1] = light[1];
1175 cs->light[2] = light[2];
1176 cs->light[3] = light[3];
1177 cs->lightstyle = lightstyle;
1178 cs->lightpflags = lightpflags;
1183 static void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg)
1189 // if there isn't enough space to accomplish anything, skip it
1190 if (msg->cursize + 25 > msg->maxsize)
1193 sv.writeentitiestoclient_msg = msg;
1194 sv.writeentitiestoclient_clientnumber = client - svs.clients;
1196 sv.writeentitiestoclient_stats_culled_pvs = 0;
1197 sv.writeentitiestoclient_stats_culled_trace = 0;
1198 sv.writeentitiestoclient_stats_visibleentities = 0;
1199 sv.writeentitiestoclient_stats_totalentities = 0;
1201 // find the client's PVS
1202 // the real place being tested from
1203 VectorAdd(clent->fields.server->origin, clent->fields.server->view_ofs, sv.writeentitiestoclient_testeye);
1204 sv.writeentitiestoclient_pvsbytes = 0;
1205 if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
1206 sv.writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv.writeentitiestoclient_testeye, 8, sv.writeentitiestoclient_pvs, sizeof(sv.writeentitiestoclient_pvs));
1208 sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
1210 // send all entities that touch the pvs
1212 for (i = 1, ent = PRVM_NEXT_EDICT(prog->edicts);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1213 if (!ent->priv.server->free && SV_BuildEntityState(sv.writeentitiestoclient_sendstates + numsendstates, ent, i))
1216 if (sv_cullentities_stats.integer)
1217 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);
1219 EntityFrameCSQC_WriteFrame(msg, numsendstates, sv.writeentitiestoclient_sendstates);
1221 if (client->entitydatabase5)
1222 EntityFrame5_WriteFrame(msg, client->entitydatabase5, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1, client->movesequence);
1223 else if (client->entitydatabase4)
1225 EntityFrame4_WriteFrame(msg, client->entitydatabase4, numsendstates, sv.writeentitiestoclient_sendstates);
1226 Protocol_WriteStatsReliable();
1228 else if (client->entitydatabase)
1230 EntityFrame_WriteFrame(msg, client->entitydatabase, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1);
1231 Protocol_WriteStatsReliable();
1235 EntityFrameQuake_WriteFrame(msg, numsendstates, sv.writeentitiestoclient_sendstates);
1236 Protocol_WriteStatsReliable();
1246 static void SV_CleanupEnts (void)
1251 ent = PRVM_NEXT_EDICT(prog->edicts);
1252 for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
1253 ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
1258 SV_WriteClientdataToMessage
1262 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1266 prvm_edict_t *other;
1272 float *statsf = (float *)stats;
1275 // send a damage message
1277 if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
1279 other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
1280 MSG_WriteByte (msg, svc_damage);
1281 MSG_WriteByte (msg, (int)ent->fields.server->dmg_save);
1282 MSG_WriteByte (msg, (int)ent->fields.server->dmg_take);
1283 for (i=0 ; i<3 ; i++)
1284 MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
1286 ent->fields.server->dmg_take = 0;
1287 ent->fields.server->dmg_save = 0;
1291 // send the current viewpos offset from the view entity
1293 SV_SetIdealPitch (); // how much to look up / down ideally
1295 // a fixangle might get lost in a dropped packet. Oh well.
1296 if(ent->fields.server->fixangle)
1298 // angle fixing was requested by global thinking code...
1299 // so store the current angles for later use
1300 memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
1301 host_client->fixangle_angles_set = TRUE;
1303 // and clear fixangle for the next frame
1304 ent->fields.server->fixangle = 0;
1307 if (host_client->fixangle_angles_set)
1309 MSG_WriteByte (msg, svc_setangle);
1310 for (i=0 ; i < 3 ; i++)
1311 MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
1312 host_client->fixangle_angles_set = FALSE;
1315 // stuff the sigil bits into the high bits of items for sbar, or else
1317 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.items2);
1318 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1319 items = (int)ent->fields.server->items | ((int)val->_float << 23);
1321 items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
1323 VectorClear(punchvector);
1324 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.punchvector)))
1325 VectorCopy(val->vector, punchvector);
1327 // cache weapon model name and index in client struct to save time
1328 // (this search can be almost 1% of cpu time!)
1329 s = PRVM_GetString(ent->fields.server->weaponmodel);
1330 if (strcmp(s, client->weaponmodel))
1332 strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
1333 client->weaponmodelindex = SV_ModelIndex(s, 1);
1337 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewzoom)))
1338 viewzoom = (int)(val->_float * 255.0f);
1344 if ((int)ent->fields.server->flags & FL_ONGROUND)
1345 bits |= SU_ONGROUND;
1346 if (ent->fields.server->waterlevel >= 2)
1348 if (ent->fields.server->idealpitch)
1349 bits |= SU_IDEALPITCH;
1351 for (i=0 ; i<3 ; i++)
1353 if (ent->fields.server->punchangle[i])
1354 bits |= (SU_PUNCH1<<i);
1355 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)
1357 bits |= (SU_PUNCHVEC1<<i);
1358 if (ent->fields.server->velocity[i])
1359 bits |= (SU_VELOCITY1<<i);
1362 memset(stats, 0, sizeof(int[MAX_CL_STATS]));
1363 stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];
1364 stats[STAT_ITEMS] = items;
1365 stats[STAT_WEAPONFRAME] = (int)ent->fields.server->weaponframe;
1366 stats[STAT_ARMOR] = (int)ent->fields.server->armorvalue;
1367 stats[STAT_WEAPON] = client->weaponmodelindex;
1368 stats[STAT_HEALTH] = (int)ent->fields.server->health;
1369 stats[STAT_AMMO] = (int)ent->fields.server->currentammo;
1370 stats[STAT_SHELLS] = (int)ent->fields.server->ammo_shells;
1371 stats[STAT_NAILS] = (int)ent->fields.server->ammo_nails;
1372 stats[STAT_ROCKETS] = (int)ent->fields.server->ammo_rockets;
1373 stats[STAT_CELLS] = (int)ent->fields.server->ammo_cells;
1374 stats[STAT_ACTIVEWEAPON] = (int)ent->fields.server->weapon;
1375 stats[STAT_VIEWZOOM] = viewzoom;
1376 stats[STAT_TOTALSECRETS] = prog->globals.server->total_secrets;
1377 stats[STAT_TOTALMONSTERS] = prog->globals.server->total_monsters;
1378 // the QC bumps these itself by sending svc_'s, so we have to keep them
1379 // zero or they'll be corrected by the engine
1380 //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
1381 //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
1383 // movement settings for prediction
1384 // note: these are not sent in protocols with lower MAX_CL_STATS limits
1385 statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
1386 statsf[STAT_MOVEVARS_TIMESCALE] = slowmo.value;
1387 statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
1388 statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
1389 statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
1390 statsf[STAT_MOVEVARS_SPECTATORMAXSPEED] = sv_maxspeed.value; // FIXME: QW has a separate cvar for this
1391 statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
1392 statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
1393 statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
1394 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.gravity);
1395 statsf[STAT_MOVEVARS_ENTGRAVITY] = (val && val->_float != 0) ? val->_float : 1.0f;
1396 statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
1397 statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
1398 statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
1399 statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
1400 statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
1401 statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
1402 statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value;
1403 statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
1404 statsf[STAT_FRAGLIMIT] = fraglimit.value;
1405 statsf[STAT_TIMELIMIT] = timelimit.value;
1407 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1409 if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
1411 if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
1412 if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
1414 // FIXME: which protocols support this? does PROTOCOL_DARKPLACES3 support viewzoom?
1415 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1416 if (viewzoom != 255)
1417 bits |= SU_VIEWZOOM;
1422 if (bits >= 16777216)
1426 MSG_WriteByte (msg, svc_clientdata);
1427 MSG_WriteShort (msg, bits);
1428 if (bits & SU_EXTEND1)
1429 MSG_WriteByte(msg, bits >> 16);
1430 if (bits & SU_EXTEND2)
1431 MSG_WriteByte(msg, bits >> 24);
1433 if (bits & SU_VIEWHEIGHT)
1434 MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
1436 if (bits & SU_IDEALPITCH)
1437 MSG_WriteChar (msg, (int)ent->fields.server->idealpitch);
1439 for (i=0 ; i<3 ; i++)
1441 if (bits & (SU_PUNCH1<<i))
1443 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
1444 MSG_WriteChar(msg, (int)ent->fields.server->punchangle[i]);
1446 MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
1448 if (bits & (SU_PUNCHVEC1<<i))
1450 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1451 MSG_WriteCoord16i(msg, punchvector[i]);
1453 MSG_WriteCoord32f(msg, punchvector[i]);
1455 if (bits & (SU_VELOCITY1<<i))
1457 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1458 MSG_WriteChar(msg, (int)(ent->fields.server->velocity[i] * (1.0f / 16.0f)));
1460 MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
1464 if (bits & SU_ITEMS)
1465 MSG_WriteLong (msg, stats[STAT_ITEMS]);
1467 if (sv.protocol == PROTOCOL_DARKPLACES5)
1469 if (bits & SU_WEAPONFRAME)
1470 MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
1471 if (bits & SU_ARMOR)
1472 MSG_WriteShort (msg, stats[STAT_ARMOR]);
1473 if (bits & SU_WEAPON)
1474 MSG_WriteShort (msg, stats[STAT_WEAPON]);
1475 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1476 MSG_WriteShort (msg, stats[STAT_AMMO]);
1477 MSG_WriteShort (msg, stats[STAT_SHELLS]);
1478 MSG_WriteShort (msg, stats[STAT_NAILS]);
1479 MSG_WriteShort (msg, stats[STAT_ROCKETS]);
1480 MSG_WriteShort (msg, stats[STAT_CELLS]);
1481 MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
1482 if (bits & SU_VIEWZOOM)
1483 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1485 else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1487 if (bits & SU_WEAPONFRAME)
1488 MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
1489 if (bits & SU_ARMOR)
1490 MSG_WriteByte (msg, stats[STAT_ARMOR]);
1491 if (bits & SU_WEAPON)
1492 MSG_WriteByte (msg, stats[STAT_WEAPON]);
1493 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1494 MSG_WriteByte (msg, stats[STAT_AMMO]);
1495 MSG_WriteByte (msg, stats[STAT_SHELLS]);
1496 MSG_WriteByte (msg, stats[STAT_NAILS]);
1497 MSG_WriteByte (msg, stats[STAT_ROCKETS]);
1498 MSG_WriteByte (msg, stats[STAT_CELLS]);
1499 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
1501 for (i = 0;i < 32;i++)
1502 if (stats[STAT_ACTIVEWEAPON] & (1<<i))
1504 MSG_WriteByte (msg, i);
1507 MSG_WriteByte (msg, stats[STAT_ACTIVEWEAPON]);
1508 if (bits & SU_VIEWZOOM)
1510 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1511 MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
1513 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1518 void SV_FlushBroadcastMessages(void)
1522 if (sv.datagram.cursize <= 0)
1524 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1526 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])))
1528 SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
1529 client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
1531 SZ_Clear(&sv.datagram);
1534 static void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg)
1536 // scan the splitpoints to find out how many we can fit in
1537 int numsegments, j, split;
1538 if (!client->unreliablemsg_splitpoints)
1540 // always accept the first one if it's within 1400 bytes, this ensures
1541 // that very big datagrams which are over the rate limit still get
1542 // through, just to keep it working
1543 if (msg->cursize + client->unreliablemsg_splitpoint[0] > msg->maxsize && msg->maxsize < 1400)
1546 msg->maxsize = 1400;
1549 for (numsegments = 0;numsegments < client->unreliablemsg_splitpoints;numsegments++)
1550 if (msg->cursize + client->unreliablemsg_splitpoint[numsegments] > msg->maxsize)
1552 if (numsegments > 0)
1554 // some will fit, so add the ones that will fit
1555 split = client->unreliablemsg_splitpoint[numsegments-1];
1556 // note this discards ones that were accepted by the segments scan but
1557 // can not fit, such as a really huge first one that will never ever
1558 // fit in a packet...
1559 if (msg->cursize + split <= msg->maxsize)
1560 SZ_Write(msg, client->unreliablemsg.data, split);
1561 // remove the part we sent, keeping any remaining data
1562 client->unreliablemsg.cursize -= split;
1563 if (client->unreliablemsg.cursize > 0)
1564 memmove(client->unreliablemsg.data, client->unreliablemsg.data + split, client->unreliablemsg.cursize);
1565 // adjust remaining splitpoints
1566 client->unreliablemsg_splitpoints -= numsegments;
1567 for (j = 0;j < client->unreliablemsg_splitpoints;j++)
1568 client->unreliablemsg_splitpoint[j] = client->unreliablemsg_splitpoint[numsegments + j] - split;
1573 =======================
1574 SV_SendClientDatagram
1575 =======================
1577 static void SV_SendClientDatagram (client_t *client)
1579 int clientrate, maxrate, maxsize, maxsize2, downloadsize;
1581 int stats[MAX_CL_STATS];
1582 unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE];
1584 // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
1585 maxrate = max(NET_MINRATE, sv_maxrate.integer);
1586 if (sv_maxrate.integer != maxrate)
1587 Cvar_SetValueQuick(&sv_maxrate, maxrate);
1588 // clientrate determines the 'cleartime' of a packet
1589 // (how long to wait before sending another, based on this packet's size)
1590 clientrate = bound(NET_MINRATE, client->rate, maxrate);
1592 if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !sv_ratelimitlocalplayer.integer)
1594 // for good singleplayer, send huge packets and never limit frequency
1595 clientrate = 1000000000;
1596 maxsize = sizeof(sv_sendclientdatagram_buf);
1597 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1599 else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1601 // no packet size limit support on older protocols because DP1-4 kick
1602 // the client off if they overflow, and quake protocol shows less than
1603 // the full entity set if rate limited
1604 clientrate = max(NET_MINRATE, client->rate);
1610 // DP5 and later protocols support packet size limiting which is a
1611 // better method than limiting packet frequency as QW does
1613 // this rate limiting does not understand sys_ticrate 0
1614 // (but no one should be running that on a server!)
1615 maxsize = (int)(clientrate * sys_ticrate.value);
1616 maxsize = bound(100, maxsize, 1400);
1620 // while downloading, limit entity updates to half the packet
1621 // (any leftover space will be used for downloading)
1622 if (host_client->download_file)
1625 msg.data = sv_sendclientdatagram_buf;
1626 msg.maxsize = maxsize;
1629 // obey rate limit by limiting packet frequency if the packet size
1631 // (usually this is caused by reliable messages)
1632 if (!NetConn_CanSend(client->netconnection))
1634 // send the datagram
1635 //NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, true);
1638 else if (host_client->spawned)
1640 MSG_WriteByte (&msg, svc_time);
1641 MSG_WriteFloat (&msg, sv.time);
1643 // add the client specific data to the datagram
1644 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
1645 // now update the stats[] array using any registered custom fields
1646 VM_SV_UpdateCustomStats (client, client->edict, &msg, stats);
1647 // set host_client->statsdeltabits
1648 Protocol_UpdateClientStats (stats);
1650 // add as many queued unreliable messages (effects) as we can fit
1651 // limit effects to half of the remaining space
1652 msg.maxsize -= (msg.maxsize - msg.cursize) / 2;
1653 if (client->unreliablemsg.cursize)
1654 SV_WriteUnreliableMessages (client, &msg);
1656 msg.maxsize = maxsize;
1658 // now write as many entities as we can fit, and also sends stats
1659 SV_WriteEntitiesToClient (client, client->edict, &msg);
1661 else if (realtime > client->keepalivetime)
1663 // the player isn't totally in the game yet
1664 // send small keepalive messages if too much time has passed
1665 msg.maxsize = maxsize2;
1666 client->keepalivetime = realtime + 5;
1667 MSG_WriteChar (&msg, svc_nop);
1670 msg.maxsize = maxsize2;
1672 // if a download is active, see if there is room to fit some download data
1674 downloadsize = maxsize * 2 - msg.cursize - 7;
1675 if (host_client->download_file && host_client->download_started && downloadsize > 0)
1677 fs_offset_t downloadstart;
1678 unsigned char data[1400];
1679 downloadstart = FS_Tell(host_client->download_file);
1680 downloadsize = min(downloadsize, (int)sizeof(data));
1681 downloadsize = FS_Read(host_client->download_file, data, downloadsize);
1682 // note this sends empty messages if at the end of the file, which is
1683 // necessary to keep the packet loss logic working
1684 // (the last blocks may be lost and need to be re-sent, and that will
1685 // only occur if the client acks the empty end messages, revealing
1686 // a gap in the download progress, causing the last blocks to be
1688 MSG_WriteChar (&msg, svc_downloaddata);
1689 MSG_WriteLong (&msg, downloadstart);
1690 MSG_WriteShort (&msg, downloadsize);
1691 if (downloadsize > 0)
1692 SZ_Write (&msg, data, downloadsize);
1695 // send the datagram
1696 NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->sendsignon == 2);
1697 if (client->sendsignon == 1 && !client->netconnection->message.cursize)
1698 client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
1702 =======================
1703 SV_UpdateToReliableMessages
1704 =======================
1706 static void SV_UpdateToReliableMessages (void)
1715 // check for changes to be sent over the reliable streams
1716 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1718 // update the host_client fields we care about according to the entity fields
1719 host_client->edict = PRVM_EDICT_NUM(i+1);
1722 name = PRVM_GetString(host_client->edict->fields.server->netname);
1725 // always point the string back at host_client->name to keep it safe
1726 strlcpy (host_client->name, name, sizeof (host_client->name));
1727 host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
1728 if (strcmp(host_client->old_name, host_client->name))
1730 if (host_client->spawned)
1731 SV_BroadcastPrintf("%s changed name to %s\n", host_client->old_name, host_client->name);
1732 strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
1733 // send notification to all clients
1734 MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
1735 MSG_WriteByte (&sv.reliable_datagram, i);
1736 MSG_WriteString (&sv.reliable_datagram, host_client->name);
1739 // DP_SV_CLIENTCOLORS
1740 // this is always found (since it's added by the progs loader)
1741 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcolors)))
1742 host_client->colors = (int)val->_float;
1743 if (host_client->old_colors != host_client->colors)
1745 host_client->old_colors = host_client->colors;
1746 // send notification to all clients
1747 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1748 MSG_WriteByte (&sv.reliable_datagram, i);
1749 MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1752 // NEXUIZ_PLAYERMODEL
1753 if( prog->fieldoffsets.playermodel >= 0 ) {
1754 model = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string);
1757 // always point the string back at host_client->name to keep it safe
1758 strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
1759 PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
1762 // NEXUIZ_PLAYERSKIN
1763 if( prog->fieldoffsets.playerskin >= 0 ) {
1764 skin = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string);
1767 // always point the string back at host_client->name to keep it safe
1768 strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
1769 PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
1773 host_client->frags = (int)host_client->edict->fields.server->frags;
1774 if (host_client->old_frags != host_client->frags)
1776 host_client->old_frags = host_client->frags;
1777 // send notification to all clients
1778 MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
1779 MSG_WriteByte (&sv.reliable_datagram, i);
1780 MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
1784 for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1785 if (client->netconnection)
1786 SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
1788 SZ_Clear (&sv.reliable_datagram);
1793 =======================
1794 SV_SendClientMessages
1795 =======================
1797 void SV_SendClientMessages (void)
1801 if (sv.protocol == PROTOCOL_QUAKEWORLD)
1802 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
1804 SV_FlushBroadcastMessages();
1806 // update frags, names, etc
1807 SV_UpdateToReliableMessages();
1809 // build individual updates
1810 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1812 if (!host_client->active)
1814 if (!host_client->netconnection)
1817 if (host_client->netconnection->message.overflowed)
1819 SV_DropClient (true); // if the message couldn't send, kick off
1823 SV_SendClientDatagram (host_client);
1826 // clear muzzle flashes
1830 static void SV_StartDownload_f(void)
1832 if (host_client->download_file)
1833 host_client->download_started = true;
1836 static void SV_Download_f(void)
1838 const char *whichpack, *whichpack2, *extension;
1840 if (Cmd_Argc() != 2)
1842 SV_ClientPrintf("usage: download <filename>\n");
1846 if (FS_CheckNastyPath(Cmd_Argv(1), false))
1848 SV_ClientPrintf("Download rejected: nasty filename \"%s\"\n", Cmd_Argv(1));
1852 if (host_client->download_file)
1854 // at this point we'll assume the previous download should be aborted
1855 Con_DPrintf("Download of %s aborted by %s starting a new download\n", host_client->download_name, host_client->name);
1856 Host_ClientCommands("\nstopdownload\n");
1858 // close the file and reset variables
1859 FS_Close(host_client->download_file);
1860 host_client->download_file = NULL;
1861 host_client->download_name[0] = 0;
1862 host_client->download_expectedposition = 0;
1863 host_client->download_started = false;
1866 if (!sv_allowdownloads.integer)
1868 SV_ClientPrintf("Downloads are disabled on this server\n");
1869 Host_ClientCommands("\nstopdownload\n");
1873 strlcpy(host_client->download_name, Cmd_Argv(1), sizeof(host_client->download_name));
1874 extension = FS_FileExtension(host_client->download_name);
1876 // host_client is asking to download a specified file
1877 if (developer.integer >= 100)
1878 Con_Printf("Download request for %s by %s\n", host_client->download_name, host_client->name);
1880 if (!FS_FileExists(host_client->download_name))
1882 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);
1883 Host_ClientCommands("\nstopdownload\n");
1887 // check if the user is trying to download part of registered Quake(r)
1888 whichpack = FS_WhichPack(host_client->download_name);
1889 whichpack2 = FS_WhichPack("gfx/pop.lmp");
1890 if ((whichpack && whichpack2 && !strcasecmp(whichpack, whichpack2)) || FS_IsRegisteredQuakePack(host_client->download_name))
1892 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);
1893 Host_ClientCommands("\nstopdownload\n");
1897 // check if the server has forbidden archive downloads entirely
1898 if (!sv_allowdownloads_inarchive.integer)
1900 whichpack = FS_WhichPack(host_client->download_name);
1903 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);
1904 Host_ClientCommands("\nstopdownload\n");
1909 if (!sv_allowdownloads_config.integer)
1911 if (!strcasecmp(extension, "cfg"))
1913 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);
1914 Host_ClientCommands("\nstopdownload\n");
1919 if (!sv_allowdownloads_dlcache.integer)
1921 if (!strncasecmp(host_client->download_name, "dlcache/", 8))
1923 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);
1924 Host_ClientCommands("\nstopdownload\n");
1929 if (!sv_allowdownloads_archive.integer)
1931 if (!strcasecmp(extension, "pak") || !strcasecmp(extension, "pk3"))
1933 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);
1934 Host_ClientCommands("\nstopdownload\n");
1939 host_client->download_file = FS_Open(host_client->download_name, "rb", true, false);
1940 if (!host_client->download_file)
1942 SV_ClientPrintf("Download rejected: server could not open the file \"%s\"\n", host_client->download_name);
1943 Host_ClientCommands("\nstopdownload\n");
1947 if (FS_FileSize(host_client->download_file) > 1<<30)
1949 SV_ClientPrintf("Download rejected: file \"%s\" is very large\n", host_client->download_name);
1950 Host_ClientCommands("\nstopdownload\n");
1951 FS_Close(host_client->download_file);
1952 host_client->download_file = NULL;
1956 Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
1958 Host_ClientCommands("\ncl_downloadbegin %i %s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name);
1960 host_client->download_expectedposition = 0;
1961 host_client->download_started = false;
1962 host_client->sendsignon = true; // make sure this message is sent
1964 // the rest of the download process is handled in SV_SendClientDatagram
1965 // and other code dealing with svc_downloaddata and clc_ackdownloaddata
1967 // no svc_downloaddata messages will be sent until sv_startdownload is
1968 // sent by the client
1972 ==============================================================================
1976 ==============================================================================
1985 int SV_ModelIndex(const char *s, int precachemode)
1987 int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_MODELS);
1988 char filename[MAX_QPATH];
1992 //if (precachemode == 2)
1994 strlcpy(filename, s, sizeof(filename));
1995 for (i = 2;i < limit;i++)
1997 if (!sv.model_precache[i][0])
2001 if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
2003 Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
2006 if (precachemode == 1)
2007 Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2008 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
2009 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, false);
2010 if (sv.state != ss_loading)
2012 MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2013 MSG_WriteShort(&sv.reliable_datagram, i);
2014 MSG_WriteString(&sv.reliable_datagram, filename);
2018 Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
2021 if (!strcmp(sv.model_precache[i], filename))
2024 Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
2034 int SV_SoundIndex(const char *s, int precachemode)
2036 int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_SOUNDS);
2037 char filename[MAX_QPATH];
2041 //if (precachemode == 2)
2043 strlcpy(filename, s, sizeof(filename));
2044 for (i = 1;i < limit;i++)
2046 if (!sv.sound_precache[i][0])
2050 if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
2052 Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
2055 if (precachemode == 1)
2056 Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2057 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
2058 if (sv.state != ss_loading)
2060 MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2061 MSG_WriteShort(&sv.reliable_datagram, i + 32768);
2062 MSG_WriteString(&sv.reliable_datagram, filename);
2066 Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
2069 if (!strcmp(sv.sound_precache[i], filename))
2072 Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
2078 SV_ParticleEffectIndex
2082 int SV_ParticleEffectIndex(const char *name)
2084 int i, argc, linenumber, effectnameindex;
2085 fs_offset_t filesize;
2086 unsigned char *filedata;
2087 const char *text, *textstart, *textend;
2088 char argv[16][1024];
2089 if (!sv.particleeffectnamesloaded)
2091 sv.particleeffectnamesloaded = true;
2092 memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
2093 for (i = 0;i < EFFECT_TOTAL;i++)
2094 strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
2095 filedata = FS_LoadFile("effectinfo.txt", tempmempool, true, &filesize);
2098 textstart = (const char *)filedata;
2099 textend = (const char *)filedata + filesize;
2101 for (linenumber = 1;;linenumber++)
2106 if (!COM_ParseToken_Simple(&text, true) || !strcmp(com_token, "\n"))
2110 strlcpy(argv[argc], com_token, sizeof(argv[argc]));
2114 if (com_token[0] == 0)
2115 break; // if the loop exited and it's not a \n, it's EOF
2118 if (!strcmp(argv[0], "effect"))
2122 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME;effectnameindex++)
2124 if (sv.particleeffectname[effectnameindex][0])
2126 if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
2131 strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
2135 // if we run out of names, abort
2136 if (effectnameindex == SV_MAX_PARTICLEEFFECTNAME)
2138 Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
2147 // search for the name
2148 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
2149 if (!strcmp(sv.particleeffectname[effectnameindex], name))
2150 return effectnameindex;
2151 // return 0 if we couldn't find it
2161 static void SV_CreateBaseline (void)
2163 int i, entnum, large;
2164 prvm_edict_t *svent;
2166 // LordHavoc: clear *all* states (note just active ones)
2167 for (entnum = 0;entnum < prog->max_edicts;entnum++)
2169 // get the current server version
2170 svent = PRVM_EDICT_NUM(entnum);
2172 // LordHavoc: always clear state values, whether the entity is in use or not
2173 svent->priv.server->baseline = defaultstate;
2175 if (svent->priv.server->free)
2177 if (entnum > svs.maxclients && !svent->fields.server->modelindex)
2180 // create entity baseline
2181 VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
2182 VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
2183 svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
2184 svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
2185 if (entnum > 0 && entnum <= svs.maxclients)
2187 svent->priv.server->baseline.colormap = entnum;
2188 svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
2192 svent->priv.server->baseline.colormap = 0;
2193 svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
2197 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
2200 // add to the message
2202 MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
2204 MSG_WriteByte (&sv.signon, svc_spawnbaseline);
2205 MSG_WriteShort (&sv.signon, entnum);
2209 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2210 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
2214 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
2215 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2217 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
2218 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
2219 for (i=0 ; i<3 ; i++)
2221 MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
2222 MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
2232 Grabs the current state of each client for saving across the
2233 transition to another level
2236 void SV_SaveSpawnparms (void)
2240 svs.serverflags = (int)prog->globals.server->serverflags;
2242 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2244 if (!host_client->active)
2247 // call the progs to get default spawn parms for the new client
2248 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2249 PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
2250 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
2251 host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
2259 This is called at the start of each level
2263 void SV_SpawnServer (const char *server)
2268 model_t *worldmodel;
2269 char modelname[sizeof(sv.modelname)];
2271 Con_DPrintf("SpawnServer: %s\n", server);
2273 if (cls.state != ca_dedicated)
2275 SCR_BeginLoadingPlaque();
2279 dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
2280 worldmodel = Mod_ForName(modelname, false, true, true);
2281 if (!worldmodel || !worldmodel->TraceBox)
2283 Con_Printf("Couldn't load map %s\n", modelname);
2287 // let's not have any servers with no name
2288 if (hostname.string[0] == 0)
2289 Cvar_Set ("hostname", "UNNAMED");
2290 scr_centertime_off = 0;
2292 svs.changelevel_issued = false; // now safe to issue another
2294 // make the map a required file for clients
2295 Curl_ClearRequirements();
2296 Curl_RequireFile(modelname);
2299 // tell all connected clients that we are going to a new level
2304 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
2306 if (client->netconnection)
2308 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
2309 MSG_WriteString(&client->netconnection->message, "reconnect\n");
2316 NetConn_OpenServerPorts(true);
2320 // make cvars consistant
2323 Cvar_SetValue ("deathmatch", 0);
2324 // LordHavoc: it can be useful to have skills outside the range 0-3...
2325 //current_skill = bound(0, (int)(skill.value + 0.5), 3);
2326 //Cvar_SetValue ("skill", (float)current_skill);
2327 current_skill = (int)(skill.value + 0.5);
2330 // set up the new server
2332 memset (&sv, 0, sizeof(sv));
2333 // if running a local client, make sure it doesn't try to access the last
2334 // level's data which is no longer valiud
2337 if(*sv_random_seed.string)
2339 srand(sv_random_seed.integer);
2340 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);
2347 strlcpy (sv.name, server, sizeof (sv.name));
2349 sv.protocol = Protocol_EnumForName(sv_protocolname.string);
2350 if (sv.protocol == PROTOCOL_UNKNOWN)
2353 Protocol_Names(buffer, sizeof(buffer));
2354 Con_Printf("Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
2355 sv.protocol = PROTOCOL_QUAKE;
2360 // load progs to get entity field count
2361 //PR_LoadProgs ( sv_progs.string );
2363 sv.datagram.maxsize = sizeof(sv.datagram_buf);
2364 sv.datagram.cursize = 0;
2365 sv.datagram.data = sv.datagram_buf;
2367 sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
2368 sv.reliable_datagram.cursize = 0;
2369 sv.reliable_datagram.data = sv.reliable_datagram_buf;
2371 sv.signon.maxsize = sizeof(sv.signon_buf);
2372 sv.signon.cursize = 0;
2373 sv.signon.data = sv.signon_buf;
2375 // leave slots at start for clients only
2376 //prog->num_edicts = svs.maxclients+1;
2378 sv.state = ss_loading;
2379 prog->allowworldwrites = true;
2382 prog->globals.server->time = sv.time = 1.0;
2385 worldmodel->used = true;
2387 strlcpy (sv.name, server, sizeof (sv.name));
2388 strlcpy(sv.modelname, modelname, sizeof(sv.modelname));
2389 sv.worldmodel = worldmodel;
2390 sv.models[1] = sv.worldmodel;
2393 // clear world interaction links
2395 VectorCopy(sv.worldmodel->normalmins, sv.world.areagrid_mins);
2396 VectorCopy(sv.worldmodel->normalmaxs, sv.world.areagrid_maxs);
2397 World_Clear(&sv.world);
2399 strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
2401 strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
2402 strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
2403 for (i = 1;i < sv.worldmodel->brush.numsubmodels;i++)
2405 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
2406 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, false);
2410 // load the rest of the entities
2412 // AK possible hack since num_edicts is still 0
2413 ent = PRVM_EDICT_NUM(0);
2414 memset (ent->fields.server, 0, prog->progs->entityfields * 4);
2415 ent->priv.server->free = false;
2416 ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
2417 ent->fields.server->modelindex = 1; // world model
2418 ent->fields.server->solid = SOLID_BSP;
2419 ent->fields.server->movetype = MOVETYPE_PUSH;
2420 VectorCopy(sv.worldmodel->normalmins, ent->fields.server->mins);
2421 VectorCopy(sv.worldmodel->normalmaxs, ent->fields.server->maxs);
2422 VectorCopy(sv.worldmodel->normalmins, ent->fields.server->absmin);
2423 VectorCopy(sv.worldmodel->normalmaxs, ent->fields.server->absmax);
2426 prog->globals.server->coop = coop.integer;
2428 prog->globals.server->deathmatch = deathmatch.integer;
2430 prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
2432 // serverflags are for cross level information (sigils)
2433 prog->globals.server->serverflags = svs.serverflags;
2435 // we need to reset the spawned flag on all connected clients here so that
2436 // their thinks don't run during startup (before PutClientInServer)
2437 // we also need to set up the client entities now
2438 // and we need to set the ->edict pointers to point into the progs edicts
2439 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2441 host_client->spawned = false;
2442 host_client->edict = PRVM_EDICT_NUM(i + 1);
2443 PRVM_ED_ClearEdict(host_client->edict);
2446 // load replacement entity file if found
2447 if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
2449 Con_Printf("Loaded maps/%s.ent\n", sv.name);
2450 PRVM_ED_LoadFromFile (entities);
2454 PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
2457 // LordHavoc: clear world angles (to fix e3m3.bsp)
2458 VectorClear(prog->edicts->fields.server->angles);
2460 // all setup is completed, any further precache statements are errors
2461 sv.state = ss_active;
2462 prog->allowworldwrites = false;
2464 // run two frames to allow everything to settle
2465 for (i = 0;i < 2;i++)
2473 // create a baseline for more efficient communications
2474 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
2475 SV_CreateBaseline ();
2477 // send serverinfo to all connected clients, and set up botclients coming back from a level change
2478 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2480 if (!host_client->active)
2482 if (host_client->netconnection)
2483 SV_SendServerinfo(host_client);
2487 // if client is a botclient coming from a level change, we need to
2488 // set up client info that normally requires networking
2490 // copy spawn parms out of the client_t
2491 for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
2492 (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
2494 // call the spawn function
2495 host_client->clientconnectcalled = true;
2496 prog->globals.server->time = sv.time;
2497 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2498 PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
2499 PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
2500 host_client->spawned = true;
2504 Con_DPrint("Server spawned.\n");
2505 NetConn_Heartbeat (2);
2510 /////////////////////////////////////////////////////
2513 static void SV_VM_CB_BeginIncreaseEdicts(void)
2518 // links don't survive the transition, so unlink everything
2519 for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2521 if (!ent->priv.server->free)
2522 World_UnlinkEdict(prog->edicts + i);
2523 memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid));
2525 World_Clear(&sv.world);
2528 static void SV_VM_CB_EndIncreaseEdicts(void)
2533 // link every entity except world
2534 for (i = 1, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2535 if (!ent->priv.server->free)
2536 SV_LinkEdict(ent, false);
2539 static void SV_VM_CB_InitEdict(prvm_edict_t *e)
2541 // LordHavoc: for consistency set these here
2542 int num = PRVM_NUM_FOR_EDICT(e) - 1;
2544 e->priv.server->move = false; // don't move on first frame
2546 if (num >= 0 && num < svs.maxclients)
2549 // set colormap and team on newly created player entity
2550 e->fields.server->colormap = num + 1;
2551 e->fields.server->team = (svs.clients[num].colors & 15) + 1;
2552 // set netname/clientcolors back to client values so that
2553 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
2555 e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
2556 if ((val = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.clientcolors)))
2557 val->_float = svs.clients[num].colors;
2558 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
2559 if( prog->fieldoffsets.playermodel >= 0 )
2560 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
2561 if( prog->fieldoffsets.playerskin >= 0 )
2562 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
2563 // Assign netaddress (IP Address, etc)
2564 if(prog->fieldoffsets.netaddress >= 0)
2565 { // Valid Field; Process
2566 if(svs.clients[num].netconnection != NULL)
2567 {// Valid Address; Assign
2568 // Acquire Readable Address
2569 LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
2570 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString(svs.clients[num].netaddress);
2574 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString("null/botclient");
2579 static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
2581 World_UnlinkEdict(ed); // unlink from world bsp
2583 ed->fields.server->model = 0;
2584 ed->fields.server->takedamage = 0;
2585 ed->fields.server->modelindex = 0;
2586 ed->fields.server->colormap = 0;
2587 ed->fields.server->skin = 0;
2588 ed->fields.server->frame = 0;
2589 VectorClear(ed->fields.server->origin);
2590 VectorClear(ed->fields.server->angles);
2591 ed->fields.server->nextthink = -1;
2592 ed->fields.server->solid = 0;
2595 static void SV_VM_CB_CountEdicts(void)
2599 int active, models, solid, step;
2601 active = models = solid = step = 0;
2602 for (i=0 ; i<prog->num_edicts ; i++)
2604 ent = PRVM_EDICT_NUM(i);
2605 if (ent->priv.server->free)
2608 if (ent->fields.server->solid)
2610 if (ent->fields.server->model)
2612 if (ent->fields.server->movetype == MOVETYPE_STEP)
2616 Con_Printf("num_edicts:%3i\n", prog->num_edicts);
2617 Con_Printf("active :%3i\n", active);
2618 Con_Printf("view :%3i\n", models);
2619 Con_Printf("touch :%3i\n", solid);
2620 Con_Printf("step :%3i\n", step);
2623 static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
2625 // remove things from different skill levels or deathmatch
2626 if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
2628 if (deathmatch.integer)
2630 if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
2635 else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY ))
2636 || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
2637 || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD )))
2645 static void SV_VM_Setup(void)
2647 extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat
2648 extern cvar_t csqc_progcrc;
2649 extern cvar_t csqc_progsize;
2650 size_t csprogsdatasize;
2652 PRVM_InitProg( PRVM_SERVERPROG );
2654 // allocate the mempools
2655 // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
2656 prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
2657 prog->builtins = vm_sv_builtins;
2658 prog->numbuiltins = vm_sv_numbuiltins;
2659 prog->headercrc = PROGHEADER_CRC;
2660 prog->max_edicts = 512;
2661 if (sv.protocol == PROTOCOL_QUAKE)
2662 prog->limit_edicts = 640; // before quake mission pack 1 this was 512
2663 else if (sv.protocol == PROTOCOL_QUAKEDP)
2664 prog->limit_edicts = 2048; // guessing
2665 else if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
2666 prog->limit_edicts = 2048; // guessing!
2668 prog->limit_edicts = MAX_EDICTS;
2669 prog->reserved_edicts = svs.maxclients;
2670 prog->edictprivate_size = sizeof(edict_engineprivate_t);
2671 prog->name = "server";
2672 prog->extensionstring = vm_sv_extensions;
2673 prog->loadintoworld = true;
2675 prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
2676 prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
2677 prog->init_edict = SV_VM_CB_InitEdict;
2678 prog->free_edict = SV_VM_CB_FreeEdict;
2679 prog->count_edicts = SV_VM_CB_CountEdicts;
2680 prog->load_edict = SV_VM_CB_LoadEdict;
2681 prog->init_cmd = VM_SV_Cmd_Init;
2682 prog->reset_cmd = VM_SV_Cmd_Reset;
2683 prog->error_cmd = Host_Error;
2685 // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
2686 PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields, 0, NULL );
2688 // some mods compiled with scrambling compilers lack certain critical
2689 // global names and field names such as "self" and "time" and "nextthink"
2690 // so we have to set these offsets manually, matching the entvars_t
2691 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
2692 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
2693 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
2694 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
2695 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
2696 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
2697 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
2698 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
2699 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
2700 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
2701 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
2702 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
2703 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
2704 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
2705 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
2706 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
2707 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
2708 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
2709 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
2710 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
2711 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
2712 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
2713 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
2714 // OP_STATE is always supported on server (due to entvars_t)
2715 prog->flag |= PRVM_OP_STATE;
2717 VM_CustomStats_Clear();//[515]: csqc
2721 // 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
2722 sv.csqc_progname[0] = 0;
2723 sv.csqc_progcrc = FS_CRCFile(csqc_progname.string, &csprogsdatasize);
2724 sv.csqc_progsize = csprogsdatasize;
2725 if (sv.csqc_progsize > 0)
2727 strlcpy(sv.csqc_progname, csqc_progname.string, sizeof(sv.csqc_progname));
2728 Con_DPrintf("server detected csqc progs file \"%s\" with size %i and crc %i\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
2732 void SV_VM_Begin(void)
2735 PRVM_SetProg( PRVM_SERVERPROG );
2737 prog->globals.server->time = (float) sv.time;
2740 void SV_VM_End(void)