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
27 static void SV_SaveEntFile_f(void);
28 static void SV_StartDownload_f(void);
29 static void SV_Download_f(void);
30 static void SV_VM_Setup(void);
31 extern cvar_t net_connecttimeout;
33 void VM_CustomStats_Clear (void);
34 void VM_SV_UpdateCustomStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);
36 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)"};
37 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)"};
38 cvar_t fraglimit = {CVAR_NOTIFY, "fraglimit","0", "ends level if this many frags is reached by any player"};
39 cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
40 cvar_t noexit = {CVAR_NOTIFY, "noexit","0", "kills anyone attempting to use an exit"};
41 cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
42 cvar_t pausable = {0, "pausable","1", "allow players to pause or not"};
43 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)"};
44 cvar_t samelevel = {CVAR_NOTIFY, "samelevel","0", "repeats same level if level ends (due to timelimit or someone hitting an exit)"};
45 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)"};
46 cvar_t slowmo = {0, "slowmo", "1.0", "controls game speed, 0.5 is half speed, 2 is double speed"};
48 cvar_t sv_accelerate = {0, "sv_accelerate", "10", "rate at which a player accelerates to sv_maxspeed"};
49 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"};
50 cvar_t sv_airaccel_qw = {0, "sv_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration"};
51 cvar_t sv_airaccel_sideways_friction = {0, "sv_airaccel_sideways_friction", "", "anti-sideways movement stabilization (reduces speed gain when zigzagging)"};
52 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"};
53 cvar_t sv_airstopaccelerate = {0, "sv_airstopaccelerate", "0", "when set, replacement for sv_airaccelerate when moving backwards"};
54 cvar_t sv_airstrafeaccelerate = {0, "sv_airstrafeaccelerate", "0", "when set, replacement for sv_airaccelerate when just strafing"};
55 cvar_t sv_maxairstrafespeed = {0, "sv_maxairstrafespeed", "0", "when set, replacement for sv_maxairspeed when just strafing"};
56 cvar_t sv_aircontrol = {0, "sv_aircontrol", "0", "CPMA-style air control"};
57 cvar_t sv_allowdownloads = {0, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};
58 cvar_t sv_allowdownloads_archive = {0, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};
59 cvar_t sv_allowdownloads_config = {0, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};
60 cvar_t sv_allowdownloads_dlcache = {0, "sv_allowdownloads_dlcache", "0", "whether to allow downloads of dlcache files (dlcache/)"};
61 cvar_t sv_allowdownloads_inarchive = {0, "sv_allowdownloads_inarchive", "0", "whether to allow downloads from archives (pak/pk3)"};
62 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"};
63 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"};
64 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"};
65 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)"};
66 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)"};
67 cvar_t sv_clmovement_inputtimeout = {0, "sv_clmovement_inputtimeout", "0.2", "when a client does not send input for this many seconds, force them to move anyway (unlike QuakeWorld)"};
68 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!)"};
69 cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"};
70 cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
71 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"};
72 cvar_t sv_cullentities_trace_delay = {0, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
73 cvar_t sv_cullentities_trace_delay_players = {0, "sv_cullentities_trace_delay_players", "0.2", "number of seconds until the entity gets actually culled if it is a player entity"};
74 cvar_t sv_cullentities_trace_enlarge = {0, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
75 cvar_t sv_cullentities_trace_prediction = {0, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};
76 cvar_t sv_cullentities_trace_samples = {0, "sv_cullentities_trace_samples", "1", "number of samples to test for entity culling"};
77 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"};
78 cvar_t sv_cullentities_trace_samples_players = {0, "sv_cullentities_trace_samples_players", "8", "number of samples to test for entity culling when the entity is a player entity"};
79 cvar_t sv_debugmove = {CVAR_NOTIFY, "sv_debugmove", "0", "disables collision detection optimizations for debugging purposes"};
80 cvar_t sv_echobprint = {CVAR_SAVE, "sv_echobprint", "1", "prints gamecode bprint() calls to server console"};
81 cvar_t sv_edgefriction = {0, "edgefriction", "1", "how much you slow down when nearing a ledge you might fall off, multiplier of sv_friction (Quake used 2, QuakeWorld used 1 due to a bug in physics code)"};
82 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)"};
83 cvar_t sv_fixedframeratesingleplayer = {0, "sv_fixedframeratesingleplayer", "1", "allows you to use server-style timing system in singleplayer (don't run faster than sys_ticrate)"};
84 cvar_t sv_freezenonclients = {CVAR_NOTIFY, "sv_freezenonclients", "0", "freezes time, except for players, allowing you to walk around and take screenshots of explosions"};
85 cvar_t sv_friction = {CVAR_NOTIFY, "sv_friction","4", "how fast you slow down"};
86 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"};
87 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"};
88 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)"};
89 cvar_t sv_gameplayfix_droptofloorstartsolid_nudgetocorrect = {0, "sv_gameplayfix_droptofloorstartsolid_nudgetocorrect", "1", "tries to nudge stuck items and monsters out of walls before droptofloor is performed"};
90 cvar_t sv_gameplayfix_easierwaterjump = {0, "sv_gameplayfix_easierwaterjump", "1", "changes water jumping to make it easier to get out of water (exactly like in QuakeWorld)"};
91 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"};
92 cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
93 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"};
94 cvar_t sv_gameplayfix_slidemoveprojectiles = {0, "sv_gameplayfix_slidemoveprojectiles", "1", "allows MOVETYPE_FLY/FLYMISSILE/TOSS/BOUNCE/BOUNCEMISSILE entities to finish their move in a frame even if they hit something, fixes 'gravity accumulation' bug for grenades on steep slopes"};
95 cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1", "causes entities (corpses, items, etc) sitting ontop of moving entities (players) to fall when the moving entity (player) is no longer supporting them"};
96 cvar_t sv_gameplayfix_noairborncorpse_allowsuspendeditems = {0, "sv_gameplayfix_noairborncorpse_allowsuspendeditems", "1", "causes entities sitting ontop of objects that are instantaneously remove to float in midair (special hack to allow a common level design trick for floating items)"};
97 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"};
98 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)"};
99 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)"};
100 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"};
101 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"};
102 cvar_t sv_gameplayfix_gravityunaffectedbyticrate = {0, "sv_gameplayfix_gravityunaffectedbyticrate", "0", "fix some ticrate issues in physics."};
103 cvar_t sv_gameplayfix_q2airaccelerate = {0, "sv_gameplayfix_q2airaccelerate", "0", "Quake2-style air acceleration"};
104 cvar_t sv_gravity = {CVAR_NOTIFY, "sv_gravity","800", "how fast you fall (512 = roughly earth gravity)"};
105 cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8", "how much to look up/down slopes and stairs when not using freelook"};
106 cvar_t sv_jumpstep = {CVAR_NOTIFY, "sv_jumpstep", "0", "whether you can step up while jumping (sv_gameplayfix_stepwhilejumping must also be 1)"};
107 cvar_t sv_jumpvelocity = {0, "sv_jumpvelocity", "270", "cvar that can be used by QuakeC code for jump velocity"};
108 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)"};
109 cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "1000000", "upper limit on client rate cvar, should reflect your network connection quality"};
110 cvar_t sv_maxspeed = {CVAR_NOTIFY, "sv_maxspeed", "320", "maximum speed a player can accelerate to when on ground (can be exceeded by tricks)"};
111 cvar_t sv_maxvelocity = {CVAR_NOTIFY, "sv_maxvelocity","2000", "universal speed limit on all entities"};
112 cvar_t sv_newflymove = {CVAR_NOTIFY, "sv_newflymove", "0", "enables simpler/buggier player physics (not recommended)"};
113 cvar_t sv_nostep = {CVAR_NOTIFY, "sv_nostep","0", "prevents MOVETYPE_STEP entities (monsters) from moving"};
114 cvar_t sv_playerphysicsqc = {CVAR_NOTIFY, "sv_playerphysicsqc", "1", "enables QuakeC function to override player physics"};
115 cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
116 cvar_t sv_protocolname = {0, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
117 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"};
118 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)"};
119 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)"};
120 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)"};
121 cvar_t sv_stepheight = {CVAR_NOTIFY, "sv_stepheight", "18", "how high you can step up (TW_SV_STEPCONTROL extension)"};
122 cvar_t sv_stopspeed = {CVAR_NOTIFY, "sv_stopspeed","100", "how fast you come to a complete stop"};
123 cvar_t sv_wallfriction = {CVAR_NOTIFY, "sv_wallfriction", "1", "how much you slow down when sliding along a wall"};
124 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"};
125 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"};
126 cvar_t sv_warsowbunny_airforwardaccel = {0, "sv_warsowbunny_airforwardaccel", "1.00001", "how fast you accelerate until you reach sv_maxspeed"};
127 cvar_t sv_warsowbunny_accel = {0, "sv_warsowbunny_accel", "0.1585", "how fast you accelerate until after reaching sv_maxspeed (it gets harder as you near sv_warsowbunny_topspeed)"};
128 cvar_t sv_warsowbunny_topspeed = {0, "sv_warsowbunny_topspeed", "925", "soft speed limit (can get faster with rjs and on ramps)"};
129 cvar_t sv_warsowbunny_turnaccel = {0, "sv_warsowbunny_turnaccel", "0", "max sharpness of turns (also master switch for the sv_warsowbunny_* mode; set this to 9 to enable)"};
130 cvar_t sv_warsowbunny_backtosideratio = {0, "sv_warsowbunny_backtosideratio", "0.8", "lower values make it easier to change direction without losing speed; the drawback is \"understeering\" in sharp turns"};
131 cvar_t sys_ticrate = {CVAR_SAVE, "sys_ticrate","0.0138889", "how long a server frame is in seconds, 0.05 is 20fps server rate, 0.1 is 10fps (can not be set higher than 0.1), 0 runs as many server frames as possible (makes games against bots a little smoother, overwhelms network players), 0.0138889 matches QuakeWorld physics"};
132 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"};
133 cvar_t timelimit = {CVAR_NOTIFY, "timelimit","0", "ends level at this time (in minutes)"};
135 cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
136 cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
137 cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
138 cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
139 cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
140 cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"};
141 cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"};
142 cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"};
143 cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"};
144 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)"};
146 cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
147 cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
148 cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
149 cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
150 cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
151 cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
152 cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
153 cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
154 cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
155 cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
156 cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
157 cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
158 cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
159 cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
160 cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
161 cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
162 cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
163 cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
164 cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
165 cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
166 cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
168 cvar_t sv_autodemo_perclient = {CVAR_SAVE, "sv_autodemo_perclient", "0", "set to 1 to enable autorecorded per-client demos (they'll start to record at the beginning of a match); set it to 2 to also record client->server packets (for debugging)"};
169 cvar_t sv_autodemo_perclient_nameformat = {CVAR_SAVE, "sv_autodemo_perclient_nameformat", "sv_autodemos/%Y-%m-%d_%H-%M", "The format of the sv_autodemo_perclient filename, followed by the map name, the client number and the IP address + port number, separated by underscores (the date is encoded using strftime escapes)" };
171 cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
176 mempool_t *sv_mempool = NULL;
178 extern cvar_t slowmo;
179 extern float scr_centertime_off;
181 // MUST match effectnameindex_t in client.h
182 static const char *standardeffectnames[EFFECT_TOTAL] =
206 "TE_TEI_BIGEXPLOSION",
222 #define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t))
224 prvm_required_field_t reqfields[] =
226 {ev_entity, "cursor_trace_ent"},
227 {ev_entity, "drawonlytoclient"},
228 {ev_entity, "exteriormodeltoclient"},
229 {ev_entity, "nodrawtoclient"},
230 {ev_entity, "tag_entity"},
231 {ev_entity, "viewmodelforclient"},
232 {ev_float, "SendFlags"},
233 {ev_float, "Version"},
235 {ev_float, "ammo_cells1"},
236 {ev_float, "ammo_lava_nails"},
237 {ev_float, "ammo_multi_rockets"},
238 {ev_float, "ammo_nails1"},
239 {ev_float, "ammo_plasma"},
240 {ev_float, "ammo_rockets1"},
241 {ev_float, "ammo_shells1"},
242 {ev_float, "button3"},
243 {ev_float, "button4"},
244 {ev_float, "button5"},
245 {ev_float, "button6"},
246 {ev_float, "button7"},
247 {ev_float, "button8"},
248 {ev_float, "button9"},
249 {ev_float, "button10"},
250 {ev_float, "button11"},
251 {ev_float, "button12"},
252 {ev_float, "button13"},
253 {ev_float, "button14"},
254 {ev_float, "button15"},
255 {ev_float, "button16"},
256 {ev_float, "buttonchat"},
257 {ev_float, "buttonuse"},
258 {ev_float, "clientcolors"},
259 {ev_float, "cursor_active"},
260 {ev_float, "disableclientprediction"},
261 {ev_float, "fullbright"},
262 {ev_float, "glow_color"},
263 {ev_float, "glow_size"},
264 {ev_float, "glow_trail"},
265 {ev_float, "gravity"},
266 {ev_float, "idealpitch"},
267 {ev_float, "items2"},
268 {ev_float, "light_lev"},
269 {ev_float, "modelflags"},
270 {ev_float, "pflags"},
272 {ev_float, "pitch_speed"},
273 {ev_float, "pmodel"},
274 {ev_float, "renderamt"}, // HalfLife support
275 {ev_float, "rendermode"}, // HalfLife support
278 {ev_float, "tag_index"},
279 {ev_float, "viewzoom"},
280 {ev_function, "SendEntity"},
281 {ev_function, "contentstransition"}, // DRESK - Support for Entity Contents Transition Event
282 {ev_function, "customizeentityforclient"},
283 {ev_function, "movetypesteplandevent"}, // DRESK - Support for MOVETYPE_STEP Entity Land Event
284 {ev_string, "netaddress"},
285 {ev_string, "playermodel"},
286 {ev_string, "playerskin"},
287 {ev_vector, "color"},
288 {ev_vector, "colormod"},
289 {ev_vector, "cursor_screen"},
290 {ev_vector, "cursor_trace_endpos"},
291 {ev_vector, "cursor_trace_start"},
292 {ev_vector, "movement"},
293 {ev_vector, "punchvector"},
298 //============================================================================
300 void SV_AreaStats_f(void)
302 World_PrintAreaStats(&sv.world, "server");
312 // init the csqc progs cvars, since they are updated/used by the server code
313 // TODO: fix this since this is a quick hack to make some of [515]'s broken code run ;) [9/13/2006 Black]
314 extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat
315 extern cvar_t csqc_progcrc;
316 extern cvar_t csqc_progsize;
317 Cvar_RegisterVariable (&csqc_progname);
318 Cvar_RegisterVariable (&csqc_progcrc);
319 Cvar_RegisterVariable (&csqc_progsize);
321 Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
322 Cmd_AddCommand("sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
323 Cmd_AddCommand_WithClientCommand("sv_startdownload", NULL, SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
324 Cmd_AddCommand_WithClientCommand("download", NULL, SV_Download_f, "downloads a specified file from the server");
326 Cvar_RegisterVariable (&coop);
327 Cvar_RegisterVariable (&deathmatch);
328 Cvar_RegisterVariable (&fraglimit);
329 Cvar_RegisterVariable (&gamecfg);
330 Cvar_RegisterVariable (&noexit);
331 Cvar_RegisterVariable (&nomonsters);
332 Cvar_RegisterVariable (&pausable);
333 Cvar_RegisterVariable (&pr_checkextension);
334 Cvar_RegisterVariable (&samelevel);
335 Cvar_RegisterVariable (&skill);
336 Cvar_RegisterVariable (&slowmo);
337 Cvar_RegisterVariable (&sv_accelerate);
338 Cvar_RegisterVariable (&sv_aim);
339 Cvar_RegisterVariable (&sv_airaccel_qw);
340 Cvar_RegisterVariable (&sv_airaccel_sideways_friction);
341 Cvar_RegisterVariable (&sv_airaccelerate);
342 Cvar_RegisterVariable (&sv_airstopaccelerate);
343 Cvar_RegisterVariable (&sv_airstrafeaccelerate);
344 Cvar_RegisterVariable (&sv_maxairstrafespeed);
345 Cvar_RegisterVariable (&sv_aircontrol);
346 Cvar_RegisterVariable (&sv_allowdownloads);
347 Cvar_RegisterVariable (&sv_allowdownloads_archive);
348 Cvar_RegisterVariable (&sv_allowdownloads_config);
349 Cvar_RegisterVariable (&sv_allowdownloads_dlcache);
350 Cvar_RegisterVariable (&sv_allowdownloads_inarchive);
351 Cvar_RegisterVariable (&sv_areagrid_mingridsize);
352 Cvar_RegisterVariable (&sv_checkforpacketsduringsleep);
353 Cvar_RegisterVariable (&sv_clmovement_enable);
354 Cvar_RegisterVariable (&sv_clmovement_minping);
355 Cvar_RegisterVariable (&sv_clmovement_minping_disabletime);
356 Cvar_RegisterVariable (&sv_clmovement_inputtimeout);
357 Cvar_RegisterVariable (&sv_cullentities_nevercullbmodels);
358 Cvar_RegisterVariable (&sv_cullentities_pvs);
359 Cvar_RegisterVariable (&sv_cullentities_stats);
360 Cvar_RegisterVariable (&sv_cullentities_trace);
361 Cvar_RegisterVariable (&sv_cullentities_trace_delay);
362 Cvar_RegisterVariable (&sv_cullentities_trace_delay_players);
363 Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
364 Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
365 Cvar_RegisterVariable (&sv_cullentities_trace_samples);
366 Cvar_RegisterVariable (&sv_cullentities_trace_samples_extra);
367 Cvar_RegisterVariable (&sv_cullentities_trace_samples_players);
368 Cvar_RegisterVariable (&sv_debugmove);
369 Cvar_RegisterVariable (&sv_echobprint);
370 Cvar_RegisterVariable (&sv_edgefriction);
371 Cvar_RegisterVariable (&sv_entpatch);
372 Cvar_RegisterVariable (&sv_fixedframeratesingleplayer);
373 Cvar_RegisterVariable (&sv_freezenonclients);
374 Cvar_RegisterVariable (&sv_friction);
375 Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
376 Cvar_RegisterVariable (&sv_gameplayfix_delayprojectiles);
377 Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid);
378 Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid_nudgetocorrect);
379 Cvar_RegisterVariable (&sv_gameplayfix_easierwaterjump);
380 Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
381 Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
382 Cvar_RegisterVariable (&sv_gameplayfix_multiplethinksperframe);
383 Cvar_RegisterVariable (&sv_gameplayfix_slidemoveprojectiles);
384 Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
385 Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse_allowsuspendeditems);
386 Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
387 Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
388 Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
389 Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
390 Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
391 Cvar_RegisterVariable (&sv_gameplayfix_gravityunaffectedbyticrate);
392 Cvar_RegisterVariable (&sv_gameplayfix_q2airaccelerate);
393 Cvar_RegisterVariable (&sv_gravity);
394 Cvar_RegisterVariable (&sv_idealpitchscale);
395 Cvar_RegisterVariable (&sv_jumpstep);
396 Cvar_RegisterVariable (&sv_jumpvelocity);
397 Cvar_RegisterVariable (&sv_maxairspeed);
398 Cvar_RegisterVariable (&sv_maxrate);
399 Cvar_RegisterVariable (&sv_maxspeed);
400 Cvar_RegisterVariable (&sv_maxvelocity);
401 Cvar_RegisterVariable (&sv_newflymove);
402 Cvar_RegisterVariable (&sv_nostep);
403 Cvar_RegisterVariable (&sv_playerphysicsqc);
404 Cvar_RegisterVariable (&sv_progs);
405 Cvar_RegisterVariable (&sv_protocolname);
406 Cvar_RegisterVariable (&sv_random_seed);
407 Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
408 Cvar_RegisterVariable (&sv_sound_land);
409 Cvar_RegisterVariable (&sv_sound_watersplash);
410 Cvar_RegisterVariable (&sv_stepheight);
411 Cvar_RegisterVariable (&sv_stopspeed);
412 Cvar_RegisterVariable (&sv_wallfriction);
413 Cvar_RegisterVariable (&sv_wateraccelerate);
414 Cvar_RegisterVariable (&sv_waterfriction);
415 Cvar_RegisterVariable (&sv_warsowbunny_airforwardaccel);
416 Cvar_RegisterVariable (&sv_warsowbunny_accel);
417 Cvar_RegisterVariable (&sv_warsowbunny_topspeed);
418 Cvar_RegisterVariable (&sv_warsowbunny_turnaccel);
419 Cvar_RegisterVariable (&sv_warsowbunny_backtosideratio);
420 Cvar_RegisterVariable (&sys_ticrate);
421 Cvar_RegisterVariable (&teamplay);
422 Cvar_RegisterVariable (&timelimit);
424 Cvar_RegisterVariable (&saved1);
425 Cvar_RegisterVariable (&saved2);
426 Cvar_RegisterVariable (&saved3);
427 Cvar_RegisterVariable (&saved4);
428 Cvar_RegisterVariable (&savedgamecfg);
429 Cvar_RegisterVariable (&scratch1);
430 Cvar_RegisterVariable (&scratch2);
431 Cvar_RegisterVariable (&scratch3);
432 Cvar_RegisterVariable (&scratch4);
433 Cvar_RegisterVariable (&temp1);
435 // LordHavoc: Nehahra uses these to pass data around cutscene demos
436 if (gamemode == GAME_NEHAHRA)
438 Cvar_RegisterVariable (&nehx00);
439 Cvar_RegisterVariable (&nehx01);
440 Cvar_RegisterVariable (&nehx02);
441 Cvar_RegisterVariable (&nehx03);
442 Cvar_RegisterVariable (&nehx04);
443 Cvar_RegisterVariable (&nehx05);
444 Cvar_RegisterVariable (&nehx06);
445 Cvar_RegisterVariable (&nehx07);
446 Cvar_RegisterVariable (&nehx08);
447 Cvar_RegisterVariable (&nehx09);
448 Cvar_RegisterVariable (&nehx10);
449 Cvar_RegisterVariable (&nehx11);
450 Cvar_RegisterVariable (&nehx12);
451 Cvar_RegisterVariable (&nehx13);
452 Cvar_RegisterVariable (&nehx14);
453 Cvar_RegisterVariable (&nehx15);
454 Cvar_RegisterVariable (&nehx16);
455 Cvar_RegisterVariable (&nehx17);
456 Cvar_RegisterVariable (&nehx18);
457 Cvar_RegisterVariable (&nehx19);
459 Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
461 Cvar_RegisterVariable (&sv_autodemo_perclient);
462 Cvar_RegisterVariable (&sv_autodemo_perclient_nameformat);
464 Cvar_RegisterVariable (&halflifebsp);
466 // any special defaults for gamemodes go here
467 if (gamemode == GAME_NEHAHRA)
469 // Nehahra pushable crates malfunction in some levels if this is on
470 Cvar_SetValueQuick (&sv_gameplayfix_upwardvelocityclearsongroundflag, 0);
471 // Nehahra NPC AI is confused by this feature
472 Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
474 if (gamemode == GAME_HIPNOTIC)
476 // 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.
477 Cvar_SetValueQuick (&sv_gameplayfix_blowupfallenzombies, 0);
478 // hipnotic mission pack has issues with bobbing water entities 'jittering' between different heights on alternate frames at the default 0.0138889 ticrate, 0.02 avoids this issue
479 Cvar_SetValueQuick (&sys_ticrate, 0.02);
480 // hipnotic mission pack has issues in their proximity mine sticking code, which causes them to bounce off.
481 Cvar_SetValueQuick (&sv_gameplayfix_slidemoveprojectiles, 0);
483 if (gamemode == GAME_ROGUE)
485 // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
486 Cvar_SetValueQuick (&sv_gameplayfix_findradiusdistancetobox, 0);
488 if (gamemode == GAME_NEXUIZ)
490 // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
491 Cvar_SetValueQuick (&sv_gameplayfix_q2airaccelerate, 1);
494 sv_mempool = Mem_AllocPool("server", 0, NULL);
497 static void SV_SaveEntFile_f(void)
499 char basename[MAX_QPATH];
500 if (!sv.active || !sv.worldmodel)
502 Con_Print("Not running a server\n");
505 FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
506 FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
511 =============================================================================
515 =============================================================================
522 Make sure the event gets sent to all clients
525 void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
529 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
531 MSG_WriteByte (&sv.datagram, svc_particle);
532 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
533 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
534 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
535 for (i=0 ; i<3 ; i++)
536 MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
537 MSG_WriteByte (&sv.datagram, count);
538 MSG_WriteByte (&sv.datagram, color);
539 SV_FlushBroadcastMessages();
546 Make sure the event gets sent to all clients
549 void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
551 if (modelindex >= 256 || startframe >= 256)
553 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
555 MSG_WriteByte (&sv.datagram, svc_effect2);
556 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
557 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
558 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
559 MSG_WriteShort (&sv.datagram, modelindex);
560 MSG_WriteShort (&sv.datagram, startframe);
561 MSG_WriteByte (&sv.datagram, framecount);
562 MSG_WriteByte (&sv.datagram, framerate);
566 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
568 MSG_WriteByte (&sv.datagram, svc_effect);
569 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
570 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
571 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
572 MSG_WriteByte (&sv.datagram, modelindex);
573 MSG_WriteByte (&sv.datagram, startframe);
574 MSG_WriteByte (&sv.datagram, framecount);
575 MSG_WriteByte (&sv.datagram, framerate);
577 SV_FlushBroadcastMessages();
584 Each entity can have eight independant sound sources, like voice,
587 Channel 0 is an auto-allocate channel, the others override anything
588 already running on that entity/channel pair.
590 An attenuation of 0 will play full volume everywhere in the level.
591 Larger attenuations will drop off. (max 4 attenuation)
595 void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation)
597 int sound_num, field_mask, i, ent;
599 if (volume < 0 || volume > 255)
601 Con_Printf ("SV_StartSound: volume = %i\n", volume);
605 if (attenuation < 0 || attenuation > 4)
607 Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
611 if (channel < 0 || channel > 7)
613 Con_Printf ("SV_StartSound: channel = %i\n", channel);
617 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
620 // find precache number for sound
621 sound_num = SV_SoundIndex(sample, 1);
625 ent = PRVM_NUM_FOR_EDICT(entity);
628 if (volume != DEFAULT_SOUND_PACKET_VOLUME)
629 field_mask |= SND_VOLUME;
630 if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
631 field_mask |= SND_ATTENUATION;
633 field_mask |= SND_LARGEENTITY;
634 if (sound_num >= 256 || channel >= 8)
635 field_mask |= SND_LARGESOUND;
637 // directed messages go only to the entity they are targeted on
638 MSG_WriteByte (&sv.datagram, svc_sound);
639 MSG_WriteByte (&sv.datagram, field_mask);
640 if (field_mask & SND_VOLUME)
641 MSG_WriteByte (&sv.datagram, volume);
642 if (field_mask & SND_ATTENUATION)
643 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
644 if (field_mask & SND_LARGEENTITY)
646 MSG_WriteShort (&sv.datagram, ent);
647 MSG_WriteByte (&sv.datagram, channel);
650 MSG_WriteShort (&sv.datagram, (ent<<3) | channel);
651 if ((field_mask & SND_LARGESOUND) || sv.protocol == PROTOCOL_NEHAHRABJP2)
652 MSG_WriteShort (&sv.datagram, sound_num);
654 MSG_WriteByte (&sv.datagram, sound_num);
655 for (i = 0;i < 3;i++)
656 MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
657 SV_FlushBroadcastMessages();
664 Nearly the same logic as SV_StartSound, except an origin
665 instead of an entity is provided and channel is omitted.
667 The entity sent to the client is 0 (world) and the channel
668 is 0 (CHAN_AUTO). SND_LARGEENTITY will never occur in this
669 function, therefore the check for it is omitted.
673 void SV_StartPointSound (vec3_t origin, const char *sample, int volume, float attenuation)
675 int sound_num, field_mask, i;
677 if (volume < 0 || volume > 255)
679 Con_Printf ("SV_StartPointSound: volume = %i\n", volume);
683 if (attenuation < 0 || attenuation > 4)
685 Con_Printf ("SV_StartPointSound: attenuation = %f\n", attenuation);
689 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
692 // find precache number for sound
693 sound_num = SV_SoundIndex(sample, 1);
698 if (volume != DEFAULT_SOUND_PACKET_VOLUME)
699 field_mask |= SND_VOLUME;
700 if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
701 field_mask |= SND_ATTENUATION;
702 if (sound_num >= 256)
703 field_mask |= SND_LARGESOUND;
705 // directed messages go only to the entity they are targeted on
706 MSG_WriteByte (&sv.datagram, svc_sound);
707 MSG_WriteByte (&sv.datagram, field_mask);
708 if (field_mask & SND_VOLUME)
709 MSG_WriteByte (&sv.datagram, volume);
710 if (field_mask & SND_ATTENUATION)
711 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
712 // Always write entnum 0 for the world entity
713 MSG_WriteShort (&sv.datagram, (0<<3) | 0);
714 if (field_mask & SND_LARGESOUND)
715 MSG_WriteShort (&sv.datagram, sound_num);
717 MSG_WriteByte (&sv.datagram, sound_num);
718 for (i = 0;i < 3;i++)
719 MSG_WriteCoord (&sv.datagram, origin[i], sv.protocol);
720 SV_FlushBroadcastMessages();
724 ==============================================================================
728 ==============================================================================
735 Sends the first message from the server to a connected client.
736 This will be sent on the initial connection and upon each server load.
739 void SV_SendServerinfo (client_t *client)
744 // we know that this client has a netconnection and thus is not a bot
746 // edicts get reallocated on level changes, so we need to update it here
747 client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
749 // clear cached stuff that depends on the level
750 client->weaponmodel[0] = 0;
751 client->weaponmodelindex = 0;
753 // LordHavoc: clear entityframe tracking
754 client->latestframenum = 0;
756 // initialize the movetime, so a speedhack can't make use of the time before this client joined
757 client->cmd.time = sv.time;
759 if (client->entitydatabase)
760 EntityFrame_FreeDatabase(client->entitydatabase);
761 if (client->entitydatabase4)
762 EntityFrame4_FreeDatabase(client->entitydatabase4);
763 if (client->entitydatabase5)
764 EntityFrame5_FreeDatabase(client->entitydatabase5);
766 memset(client->stats, 0, sizeof(client->stats));
767 memset(client->statsdeltabits, 0, sizeof(client->statsdeltabits));
769 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
771 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
772 client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
773 else if (sv.protocol == PROTOCOL_DARKPLACES4)
774 client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
776 client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
779 // reset csqc entity versions
780 for (i = 0;i < prog->max_edicts;i++)
782 client->csqcentityscope[i] = 0;
783 client->csqcentitysendflags[i] = 0xFFFFFF;
784 client->csqcentityglobalhistory[i] = 0;
786 for (i = 0;i < NUM_CSQCENTITYDB_FRAMES;i++)
788 client->csqcentityframehistory[i].num = 0;
789 client->csqcentityframehistory[i].framenum = -1;
791 client->csqcnumedicts = 0;
792 client->csqcentityframehistory_next = 0;
794 SZ_Clear (&client->netconnection->message);
795 MSG_WriteByte (&client->netconnection->message, svc_print);
796 dpsnprintf (message, sizeof (message), "\nServer: %s build %s (progs %i crc)", gamename, buildstring, prog->filecrc);
797 MSG_WriteString (&client->netconnection->message,message);
799 SV_StopDemoRecording(client); // to split up demos into different files
800 if(sv_autodemo_perclient.integer && client->netconnection)
802 char demofile[MAX_OSPATH];
803 char levelname[MAX_QPATH];
804 char ipaddress[MAX_QPATH];
807 // start a new demo file
808 strlcpy(levelname, FS_FileWithoutPath(sv.worldmodel->name), sizeof(levelname));
809 if (strrchr(levelname, '.'))
810 *(strrchr(levelname, '.')) = 0;
812 LHNETADDRESS_ToString(&(client->netconnection->peeraddress), ipaddress, sizeof(ipaddress), true);
813 for(i = 0; ipaddress[i]; ++i)
814 if(!isalnum(ipaddress[i]))
816 dpsnprintf (demofile, sizeof(demofile), "%s_%s_%d_%s.dem", Sys_TimeString (sv_autodemo_perclient_nameformat.string), levelname, PRVM_NUM_FOR_EDICT(client->edict), ipaddress);
818 SV_StartDemoRecording(client, demofile, -1);
821 //[515]: init csprogs according to version of svprogs, check the crc, etc.
822 if (sv.csqc_progname[0])
825 Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
826 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
827 MSG_WriteString (&client->netconnection->message, va("csqc_progname %s\n", sv.csqc_progname));
828 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
829 MSG_WriteString (&client->netconnection->message, va("csqc_progsize %i\n", sv.csqc_progsize));
830 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
831 MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i\n", sv.csqc_progcrc));
833 if(client->sv_demo_file != NULL)
836 char buf[NET_MAXMESSAGE];
839 sb.data = (unsigned char *) buf;
840 sb.maxsize = sizeof(buf);
842 while(MakeDownloadPacket(sv.csqc_progname, svs.csqc_progdata, sv.csqc_progsize, sv.csqc_progcrc, i++, &sb, sv.protocol))
843 SV_WriteDemoMessage(client, &sb, false);
846 //[515]: init stufftext string (it is sent before svc_serverinfo)
847 val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.SV_InitCmd);
850 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
851 MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(val->string)));
855 //if (sv_allowdownloads.integer)
856 // always send the info that the server supports the protocol, even if downloads are forbidden
857 // only because of that, the CSQC exception can work
859 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
860 MSG_WriteString (&client->netconnection->message, "cl_serverextension_download 2\n");
863 // send at this time so it's guaranteed to get executed at the right time
867 host_client = client;
868 Curl_SendRequirements();
872 MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
873 MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
874 MSG_WriteByte (&client->netconnection->message, svs.maxclients);
876 if (!coop.integer && deathmatch.integer)
877 MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
879 MSG_WriteByte (&client->netconnection->message, GAME_COOP);
881 MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
883 for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
884 MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
885 MSG_WriteByte (&client->netconnection->message, 0);
887 for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
888 MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
889 MSG_WriteByte (&client->netconnection->message, 0);
892 MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
893 MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
894 MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
897 // store this in clientcamera, too
898 client->clientcamera = PRVM_NUM_FOR_EDICT(client->edict);
899 MSG_WriteByte (&client->netconnection->message, svc_setview);
900 MSG_WriteShort (&client->netconnection->message, client->clientcamera);
902 MSG_WriteByte (&client->netconnection->message, svc_signonnum);
903 MSG_WriteByte (&client->netconnection->message, 1);
905 client->spawned = false; // need prespawn, spawn, etc
906 client->sendsignon = 1; // send this message, and increment to 2, 2 will be set to 0 by the prespawn command
908 // clear movement info until client enters the new level properly
909 memset(&client->cmd, 0, sizeof(client->cmd));
910 client->movesequence = 0;
911 #ifdef NUM_PING_TIMES
912 for (i = 0;i < NUM_PING_TIMES;i++)
913 client->ping_times[i] = 0;
914 client->num_pings = 0;
918 // allow the client some time to send his keepalives, even if map loading took ages
919 client->netconnection->timeout = realtime + net_connecttimeout.value;
926 Initializes a client_t for a new net connection. This will only be called
927 once for a player each game, not once for each level change.
930 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
934 float spawn_parms[NUM_SPAWN_PARMS];
936 client = svs.clients + clientnum;
938 // set up the client_t
940 memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
941 memset (client, 0, sizeof(*client));
942 client->active = true;
943 client->netconnection = netconnection;
945 Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
947 strlcpy(client->name, "unconnected", sizeof(client->name));
948 strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
949 client->spawned = false;
950 client->edict = PRVM_EDICT_NUM(clientnum+1);
951 if (client->netconnection)
952 client->netconnection->message.allowoverflow = true; // we can catch it
953 // prepare the unreliable message buffer
954 client->unreliablemsg.data = client->unreliablemsg_data;
955 client->unreliablemsg.maxsize = sizeof(client->unreliablemsg_data);
956 // updated by receiving "rate" command from client, this is also the default if not using a DP client
957 client->rate = 1000000000;
958 // no limits for local player
959 if (client->netconnection && LHNETADDRESS_GetAddressType(&client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP)
960 client->rate = 1000000000;
961 client->connecttime = realtime;
964 memcpy (client->spawn_parms, spawn_parms, sizeof(spawn_parms));
967 // call the progs to get default spawn parms for the new client
968 // set self to world to intentionally cause errors with broken SetNewParms code in some mods
969 prog->globals.server->self = 0;
970 PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
971 for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
972 client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
974 // set up the entity for this client (including .colormap, .team, etc)
975 PRVM_ED_ClearEdict(client->edict);
978 // don't call SendServerinfo for a fresh botclient because its fields have
979 // not been set up by the qc yet
980 if (client->netconnection)
981 SV_SendServerinfo (client);
983 client->spawned = true;
988 ===============================================================================
992 ===============================================================================
996 =============================================================================
998 The PVS must include a small area around the client to allow head bobbing
999 or other small motion on the client side. Otherwise, a bob might cause an
1000 entity that should be visible to not show up, especially when the bob
1001 crosses a waterline.
1003 =============================================================================
1006 static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int enumber)
1009 unsigned int sendflags;
1010 unsigned int version;
1011 unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
1012 unsigned int customizeentityforclient;
1014 vec3_t cullmins, cullmaxs;
1016 prvm_eval_t *val, *val2;
1018 // this 2 billion unit check is actually to detect NAN origins
1019 // (we really don't want to send those)
1020 if (!(VectorLength2(ent->fields.server->origin) < 2000000000.0*2000000000.0))
1023 // EF_NODRAW prevents sending for any reason except for your own
1024 // client, so we must keep all clients in this superset
1025 effects = (unsigned)ent->fields.server->effects;
1027 // we can omit invisible entities with no effects that are not clients
1028 // LordHavoc: this could kill tags attached to an invisible entity, I
1029 // just hope we never have to support that case
1030 i = (int)ent->fields.server->modelindex;
1031 modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model)) ? i : 0;
1034 i = (int)(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_size)->_float * 0.25f);
1035 glowsize = (unsigned char)bound(0, i, 255);
1036 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->_float)
1037 flags |= RENDER_GLOWTRAIL;
1038 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict)
1039 flags |= RENDER_VIEWMODEL;
1041 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[0]*256;
1042 light[0] = (unsigned short)bound(0, f, 65535);
1043 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[1]*256;
1044 light[1] = (unsigned short)bound(0, f, 65535);
1045 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[2]*256;
1046 light[2] = (unsigned short)bound(0, f, 65535);
1047 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.light_lev)->_float;
1048 light[3] = (unsigned short)bound(0, f, 65535);
1049 lightstyle = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.style)->_float;
1050 lightpflags = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pflags)->_float;
1052 if (gamemode == GAME_TENEBRAE)
1054 // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
1058 lightpflags |= PFLAGS_FULLDYNAMIC;
1060 // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
1064 light[0] = (int)(0.2*256);
1065 light[1] = (int)(1.0*256);
1066 light[2] = (int)(0.2*256);
1068 lightpflags |= PFLAGS_FULLDYNAMIC;
1072 specialvisibilityradius = 0;
1073 if (lightpflags & PFLAGS_FULLDYNAMIC)
1074 specialvisibilityradius = max(specialvisibilityradius, light[3]);
1076 specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
1077 if (flags & RENDER_GLOWTRAIL)
1078 specialvisibilityradius = max(specialvisibilityradius, 100);
1079 if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
1081 if (effects & EF_BRIGHTFIELD)
1082 specialvisibilityradius = max(specialvisibilityradius, 80);
1083 if (effects & EF_MUZZLEFLASH)
1084 specialvisibilityradius = max(specialvisibilityradius, 100);
1085 if (effects & EF_BRIGHTLIGHT)
1086 specialvisibilityradius = max(specialvisibilityradius, 400);
1087 if (effects & EF_DIMLIGHT)
1088 specialvisibilityradius = max(specialvisibilityradius, 200);
1089 if (effects & EF_RED)
1090 specialvisibilityradius = max(specialvisibilityradius, 200);
1091 if (effects & EF_BLUE)
1092 specialvisibilityradius = max(specialvisibilityradius, 200);
1093 if (effects & EF_FLAME)
1094 specialvisibilityradius = max(specialvisibilityradius, 250);
1095 if (effects & EF_STARDUST)
1096 specialvisibilityradius = max(specialvisibilityradius, 100);
1099 // early culling checks
1100 // (final culling is done by SV_MarkWriteEntityStateToClient)
1101 customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function;
1102 if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
1107 cs->number = enumber;
1108 VectorCopy(ent->fields.server->origin, cs->origin);
1109 VectorCopy(ent->fields.server->angles, cs->angles);
1111 cs->effects = effects;
1112 cs->colormap = (unsigned)ent->fields.server->colormap;
1113 cs->modelindex = modelindex;
1114 cs->skin = (unsigned)ent->fields.server->skin;
1115 cs->frame = (unsigned)ent->fields.server->frame;
1116 cs->viewmodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict;
1117 cs->exteriormodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.exteriormodeltoclient)->edict;
1118 cs->nodrawtoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict;
1119 cs->drawonlytoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict;
1120 cs->customizeentityforclient = customizeentityforclient;
1121 cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict;
1122 cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
1123 cs->glowsize = glowsize;
1125 // don't need to init cs->colormod because the defaultstate did that for us
1126 //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
1127 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod);
1128 if (val->vector[0] || val->vector[1] || val->vector[2])
1130 i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
1131 i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
1132 i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
1135 cs->modelindex = modelindex;
1138 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f);
1142 cs->alpha = (unsigned char)bound(0, i, 255);
1145 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float);
1149 cs->alpha = (unsigned char)bound(0, i, 255);
1153 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f);
1157 cs->scale = (unsigned char)bound(0, i, 255);
1160 cs->glowcolor = 254;
1161 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float);
1163 cs->glowcolor = (int)f;
1165 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float)
1166 cs->effects |= EF_FULLBRIGHT;
1168 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.modelflags);
1169 if (val && val->_float)
1170 cs->effects |= ((unsigned int)val->_float & 0xff) << 24;
1172 if (ent->fields.server->movetype == MOVETYPE_STEP)
1173 cs->flags |= RENDER_STEP;
1174 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)
1175 cs->flags |= RENDER_LOWPRECISION;
1176 if (ent->fields.server->colormap >= 1024)
1177 cs->flags |= RENDER_COLORMAPPED;
1178 if (cs->viewmodelforclient)
1179 cs->flags |= RENDER_VIEWMODEL; // show relative to the view
1181 cs->light[0] = light[0];
1182 cs->light[1] = light[1];
1183 cs->light[2] = light[2];
1184 cs->light[3] = light[3];
1185 cs->lightstyle = lightstyle;
1186 cs->lightpflags = lightpflags;
1188 cs->specialvisibilityradius = specialvisibilityradius;
1190 // calculate the visible box of this entity (don't use the physics box
1191 // as that is often smaller than a model, and would not count
1192 // specialvisibilityradius)
1193 if ((model = sv.models[modelindex]) && (model->type != mod_null))
1195 float scale = cs->scale * (1.0f / 16.0f);
1196 if (cs->angles[0] || cs->angles[2]) // pitch and roll
1198 VectorMA(cs->origin, scale, model->rotatedmins, cullmins);
1199 VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs);
1201 else if (cs->angles[1])
1203 VectorMA(cs->origin, scale, model->yawmins, cullmins);
1204 VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs);
1208 VectorMA(cs->origin, scale, model->normalmins, cullmins);
1209 VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs);
1214 // if there is no model (or it could not be loaded), use the physics box
1215 VectorAdd(cs->origin, ent->fields.server->mins, cullmins);
1216 VectorAdd(cs->origin, ent->fields.server->maxs, cullmaxs);
1218 if (specialvisibilityradius)
1220 cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius);
1221 cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius);
1222 cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius);
1223 cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius);
1224 cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius);
1225 cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius);
1228 // calculate center of bbox for network prioritization purposes
1229 VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, cs->netcenter);
1231 // if culling box has moved, update pvs cluster links
1232 if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
1234 VectorCopy(cullmins, ent->priv.server->cullmins);
1235 VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
1236 // a value of -1 for pvs_numclusters indicates that the links are not
1237 // cached, and should be re-tested each time, this is the case if the
1238 // culling box touches too many pvs clusters to store, or if the world
1239 // model does not support FindBoxClusters
1240 ent->priv.server->pvs_numclusters = -1;
1241 if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
1243 i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
1244 if (i <= MAX_ENTITYCLUSTERS)
1245 ent->priv.server->pvs_numclusters = i;
1249 // we need to do some csqc entity upkeep here
1250 // get self.SendFlags and clear them
1251 // (to let the QC know that they've been read)
1252 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.SendEntity);
1255 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.SendFlags);
1256 sendflags = (unsigned int)val->_float;
1258 // legacy self.Version system
1259 val2 = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.Version);
1262 version = (unsigned int)val2->_float;
1263 if (sv.csqcentityversion[enumber] != version)
1264 sendflags = 0xFFFFFF;
1265 sv.csqcentityversion[enumber] = version;
1267 // move sendflags into the per-client sendflags
1269 for (i = 0;i < svs.maxclients;i++)
1270 svs.clients[i].csqcentitysendflags[enumber] |= sendflags;
1276 void SV_PrepareEntitiesForSending(void)
1280 // send all entities that touch the pvs
1281 sv.numsendentities = 0;
1282 sv.sendentitiesindex[0] = NULL;
1283 memset(sv.sendentitiesindex, 0, prog->num_edicts * sizeof(*sv.sendentitiesindex));
1284 for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent))
1286 if (!ent->priv.server->free && SV_PrepareEntityForSending(ent, sv.sendentities + sv.numsendentities, e))
1288 sv.sendentitiesindex[e] = sv.sendentities + sv.numsendentities;
1289 sv.numsendentities++;
1294 void SV_MarkWriteEntityStateToClient(entity_state_t *s)
1299 if (sv.sententitiesconsideration[s->number] == sv.sententitiesmark)
1301 sv.sententitiesconsideration[s->number] = sv.sententitiesmark;
1302 sv.writeentitiestoclient_stats_totalentities++;
1304 if (s->customizeentityforclient)
1306 prog->globals.server->self = s->number;
1307 prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
1308 PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
1309 if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
1313 // never reject player
1314 if (s->number != sv.writeentitiestoclient_cliententitynumber)
1316 // check various rejection conditions
1317 if (s->nodrawtoclient == sv.writeentitiestoclient_cliententitynumber)
1319 if (s->drawonlytoclient && s->drawonlytoclient != sv.writeentitiestoclient_cliententitynumber)
1321 if (s->effects & EF_NODRAW)
1323 // LordHavoc: only send entities with a model or important effects
1324 if (!s->modelindex && s->specialvisibilityradius == 0)
1327 isbmodel = (model = sv.models[s->modelindex]) != NULL && model->name[0] == '*';
1328 // viewmodels don't have visibility checking
1329 if (s->viewmodelforclient)
1331 if (s->viewmodelforclient != sv.writeentitiestoclient_cliententitynumber)
1334 else if (s->tagentity)
1336 // tag attached entities simply check their parent
1337 if (!sv.sendentitiesindex[s->tagentity])
1339 SV_MarkWriteEntityStateToClient(sv.sendentitiesindex[s->tagentity]);
1340 if (sv.sententities[s->tagentity] != sv.sententitiesmark)
1343 // always send world submodels in newer protocols because they don't
1344 // generate much traffic (in old protocols they hog bandwidth)
1345 // but only if sv_cullentities_nevercullbmodels is off
1346 else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE))
1348 // entity has survived every check so far, check if visible
1349 ed = PRVM_EDICT_NUM(s->number);
1351 // if not touching a visible leaf
1352 if (sv_cullentities_pvs.integer && !r_novis.integer && sv.writeentitiestoclient_pvsbytes)
1354 if (ed->priv.server->pvs_numclusters < 0)
1356 // entity too big for clusters list
1357 if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
1359 sv.writeentitiestoclient_stats_culled_pvs++;
1366 // check cached clusters list
1367 for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
1368 if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
1370 if (i == ed->priv.server->pvs_numclusters)
1372 sv.writeentitiestoclient_stats_culled_pvs++;
1378 // or not seen by random tracelines
1379 if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel->brush.TraceLineOfSight)
1382 s->number <= svs.maxclients
1383 ? sv_cullentities_trace_samples_players.integer
1385 s->specialvisibilityradius
1386 ? sv_cullentities_trace_samples_extra.integer
1387 : sv_cullentities_trace_samples.integer;
1388 float enlarge = sv_cullentities_trace_enlarge.value;
1390 qboolean visible = TRUE;
1396 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, sv.writeentitiestoclient_testeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
1397 break; // directly visible from the server's view
1399 if(sv_cullentities_trace_prediction.integer)
1403 // get player velocity
1404 float predtime = bound(0, host_client->ping, 0.2); // / 2
1405 // sorry, no wallhacking by high ping please, and at 200ms
1406 // ping a FPS is annoying to play anyway and a player is
1407 // likely to have changed his direction
1408 VectorMA(sv.writeentitiestoclient_testeye, predtime, host_client->edict->fields.server->velocity, predeye);
1409 if(sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, sv.writeentitiestoclient_testeye, predeye)) // must be able to go there...
1411 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, predeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
1412 break; // directly visible from the predicted view
1416 //Con_DPrintf("Trying to walk into solid in a pingtime... not predicting for culling\n");
1420 // when we get here, we can't see the entity
1426 svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number] =
1428 s->number <= svs.maxclients
1429 ? sv_cullentities_trace_delay_players.value
1430 : sv_cullentities_trace_delay.value
1432 else if (realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number])
1434 sv.writeentitiestoclient_stats_culled_trace++;
1442 // this just marks it for sending
1443 // FIXME: it would be more efficient to send here, but the entity
1444 // compressor isn't that flexible
1445 sv.writeentitiestoclient_stats_visibleentities++;
1446 sv.sententities[s->number] = sv.sententitiesmark;
1449 void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int maxsize)
1451 qboolean need_empty = false;
1452 int i, numsendstates;
1454 prvm_edict_t *camera;
1457 // if there isn't enough space to accomplish anything, skip it
1458 if (msg->cursize + 25 > maxsize)
1461 sv.writeentitiestoclient_msg = msg;
1462 sv.writeentitiestoclient_clientnumber = client - svs.clients;
1464 sv.writeentitiestoclient_stats_culled_pvs = 0;
1465 sv.writeentitiestoclient_stats_culled_trace = 0;
1466 sv.writeentitiestoclient_stats_visibleentities = 0;
1467 sv.writeentitiestoclient_stats_totalentities = 0;
1469 // find the client's PVS
1470 // the real place being tested from
1471 camera = PRVM_EDICT_NUM( client->clientcamera );
1472 VectorAdd(camera->fields.server->origin, clent->fields.server->view_ofs, sv.writeentitiestoclient_testeye);
1473 sv.writeentitiestoclient_pvsbytes = 0;
1474 if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
1475 sv.writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv.writeentitiestoclient_testeye, 8, sv.writeentitiestoclient_pvs, sizeof(sv.writeentitiestoclient_pvs), false);
1477 sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
1479 sv.sententitiesmark++;
1481 for (i = 0;i < sv.numsendentities;i++)
1482 SV_MarkWriteEntityStateToClient(sv.sendentities + i);
1485 for (i = 0;i < sv.numsendentities;i++)
1487 if (sv.sententities[sv.sendentities[i].number] == sv.sententitiesmark)
1489 s = &sv.writeentitiestoclient_sendstates[numsendstates++];
1490 *s = sv.sendentities[i];
1491 if (s->exteriormodelforclient && s->exteriormodelforclient == sv.writeentitiestoclient_cliententitynumber)
1492 s->flags |= RENDER_EXTERIORMODEL;
1496 if (sv_cullentities_stats.integer)
1497 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);
1499 if(client->entitydatabase5)
1500 need_empty = EntityFrameCSQC_WriteFrame(msg, maxsize, numsendstates, sv.writeentitiestoclient_sendstates, client->entitydatabase5->latestframenum + 1);
1502 EntityFrameCSQC_WriteFrame(msg, maxsize, numsendstates, sv.writeentitiestoclient_sendstates, 0);
1504 if(client->num_skippedentityframes >= 10)
1505 need_empty = true; // force every 10th frame to be not empty (or cl_movement replay takes too long)
1507 if (client->entitydatabase5)
1508 success = EntityFrame5_WriteFrame(msg, maxsize, client->entitydatabase5, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1, client->movesequence, need_empty);
1509 else if (client->entitydatabase4)
1511 success = EntityFrame4_WriteFrame(msg, maxsize, client->entitydatabase4, numsendstates, sv.writeentitiestoclient_sendstates);
1512 Protocol_WriteStatsReliable();
1514 else if (client->entitydatabase)
1516 success = EntityFrame_WriteFrame(msg, maxsize, client->entitydatabase, numsendstates, sv.writeentitiestoclient_sendstates, client - svs.clients + 1);
1517 Protocol_WriteStatsReliable();
1521 success = EntityFrameQuake_WriteFrame(msg, maxsize, numsendstates, sv.writeentitiestoclient_sendstates);
1522 Protocol_WriteStatsReliable();
1526 client->num_skippedentityframes = 0;
1528 ++client->num_skippedentityframes;
1537 static void SV_CleanupEnts (void)
1542 ent = PRVM_NEXT_EDICT(prog->edicts);
1543 for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
1544 ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
1549 SV_WriteClientdataToMessage
1553 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1557 prvm_edict_t *other;
1563 float *statsf = (float *)stats;
1566 // send a damage message
1568 if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
1570 other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
1571 MSG_WriteByte (msg, svc_damage);
1572 MSG_WriteByte (msg, (int)ent->fields.server->dmg_save);
1573 MSG_WriteByte (msg, (int)ent->fields.server->dmg_take);
1574 for (i=0 ; i<3 ; i++)
1575 MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
1577 ent->fields.server->dmg_take = 0;
1578 ent->fields.server->dmg_save = 0;
1582 // send the current viewpos offset from the view entity
1584 SV_SetIdealPitch (); // how much to look up / down ideally
1586 // a fixangle might get lost in a dropped packet. Oh well.
1587 if(ent->fields.server->fixangle)
1589 // angle fixing was requested by global thinking code...
1590 // so store the current angles for later use
1591 memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
1592 host_client->fixangle_angles_set = TRUE;
1594 // and clear fixangle for the next frame
1595 ent->fields.server->fixangle = 0;
1598 if (host_client->fixangle_angles_set)
1600 MSG_WriteByte (msg, svc_setangle);
1601 for (i=0 ; i < 3 ; i++)
1602 MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
1603 host_client->fixangle_angles_set = FALSE;
1606 // stuff the sigil bits into the high bits of items for sbar, or else
1608 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.items2);
1609 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1610 items = (int)ent->fields.server->items | ((int)val->_float << 23);
1612 items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
1614 VectorClear(punchvector);
1615 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.punchvector)))
1616 VectorCopy(val->vector, punchvector);
1618 // cache weapon model name and index in client struct to save time
1619 // (this search can be almost 1% of cpu time!)
1620 s = PRVM_GetString(ent->fields.server->weaponmodel);
1621 if (strcmp(s, client->weaponmodel))
1623 strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
1624 client->weaponmodelindex = SV_ModelIndex(s, 1);
1628 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewzoom)))
1629 viewzoom = (int)(val->_float * 255.0f);
1635 if ((int)ent->fields.server->flags & FL_ONGROUND)
1636 bits |= SU_ONGROUND;
1637 if (ent->fields.server->waterlevel >= 2)
1639 if (ent->fields.server->idealpitch)
1640 bits |= SU_IDEALPITCH;
1642 for (i=0 ; i<3 ; i++)
1644 if (ent->fields.server->punchangle[i])
1645 bits |= (SU_PUNCH1<<i);
1646 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
1648 bits |= (SU_PUNCHVEC1<<i);
1649 if (ent->fields.server->velocity[i])
1650 bits |= (SU_VELOCITY1<<i);
1653 memset(stats, 0, sizeof(int[MAX_CL_STATS]));
1654 stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];
1655 stats[STAT_ITEMS] = items;
1656 stats[STAT_WEAPONFRAME] = (int)ent->fields.server->weaponframe;
1657 stats[STAT_ARMOR] = (int)ent->fields.server->armorvalue;
1658 stats[STAT_WEAPON] = client->weaponmodelindex;
1659 stats[STAT_HEALTH] = (int)ent->fields.server->health;
1660 stats[STAT_AMMO] = (int)ent->fields.server->currentammo;
1661 stats[STAT_SHELLS] = (int)ent->fields.server->ammo_shells;
1662 stats[STAT_NAILS] = (int)ent->fields.server->ammo_nails;
1663 stats[STAT_ROCKETS] = (int)ent->fields.server->ammo_rockets;
1664 stats[STAT_CELLS] = (int)ent->fields.server->ammo_cells;
1665 stats[STAT_ACTIVEWEAPON] = (int)ent->fields.server->weapon;
1666 stats[STAT_VIEWZOOM] = viewzoom;
1667 stats[STAT_TOTALSECRETS] = (int)prog->globals.server->total_secrets;
1668 stats[STAT_TOTALMONSTERS] = (int)prog->globals.server->total_monsters;
1669 // the QC bumps these itself by sending svc_'s, so we have to keep them
1670 // zero or they'll be corrected by the engine
1671 //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
1672 //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
1674 // movement settings for prediction
1675 // note: these are not sent in protocols with lower MAX_CL_STATS limits
1676 stats[STAT_MOVEFLAGS] = MOVEFLAG_VALID
1677 | (sv_gameplayfix_q2airaccelerate.integer ? MOVEFLAG_Q2AIRACCELERATE : 0)
1679 statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
1680 statsf[STAT_MOVEVARS_TIMESCALE] = slowmo.value;
1681 statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
1682 statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
1683 statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
1684 statsf[STAT_MOVEVARS_SPECTATORMAXSPEED] = sv_maxspeed.value; // FIXME: QW has a separate cvar for this
1685 statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
1686 statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
1687 statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
1688 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.gravity);
1689 statsf[STAT_MOVEVARS_ENTGRAVITY] = (val && val->_float != 0) ? val->_float : 1.0f;
1690 statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
1691 statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
1692 statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
1693 statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
1694 statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
1695 statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
1696 statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value;
1697 statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
1698 statsf[STAT_MOVEVARS_AIRSTOPACCELERATE] = sv_airstopaccelerate.value;
1699 statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE] = sv_airstrafeaccelerate.value;
1700 statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED] = sv_maxairstrafespeed.value;
1701 statsf[STAT_MOVEVARS_AIRCONTROL] = sv_aircontrol.value;
1702 statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL] = sv_warsowbunny_airforwardaccel.value;
1703 statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL] = sv_warsowbunny_accel.value;
1704 statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED] = sv_warsowbunny_topspeed.value;
1705 statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL] = sv_warsowbunny_turnaccel.value;
1706 statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO] = sv_warsowbunny_backtosideratio.value;
1707 statsf[STAT_FRAGLIMIT] = fraglimit.value;
1708 statsf[STAT_TIMELIMIT] = timelimit.value;
1710 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1712 if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
1714 if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
1715 if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
1717 // FIXME: which protocols support this? does PROTOCOL_DARKPLACES3 support viewzoom?
1718 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1719 if (viewzoom != 255)
1720 bits |= SU_VIEWZOOM;
1725 if (bits >= 16777216)
1729 MSG_WriteByte (msg, svc_clientdata);
1730 MSG_WriteShort (msg, bits);
1731 if (bits & SU_EXTEND1)
1732 MSG_WriteByte(msg, bits >> 16);
1733 if (bits & SU_EXTEND2)
1734 MSG_WriteByte(msg, bits >> 24);
1736 if (bits & SU_VIEWHEIGHT)
1737 MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
1739 if (bits & SU_IDEALPITCH)
1740 MSG_WriteChar (msg, (int)ent->fields.server->idealpitch);
1742 for (i=0 ; i<3 ; i++)
1744 if (bits & (SU_PUNCH1<<i))
1746 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1747 MSG_WriteChar(msg, (int)ent->fields.server->punchangle[i]);
1749 MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
1751 if (bits & (SU_PUNCHVEC1<<i))
1753 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1754 MSG_WriteCoord16i(msg, punchvector[i]);
1756 MSG_WriteCoord32f(msg, punchvector[i]);
1758 if (bits & (SU_VELOCITY1<<i))
1760 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1761 MSG_WriteChar(msg, (int)(ent->fields.server->velocity[i] * (1.0f / 16.0f)));
1763 MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
1767 if (bits & SU_ITEMS)
1768 MSG_WriteLong (msg, stats[STAT_ITEMS]);
1770 if (sv.protocol == PROTOCOL_DARKPLACES5)
1772 if (bits & SU_WEAPONFRAME)
1773 MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
1774 if (bits & SU_ARMOR)
1775 MSG_WriteShort (msg, stats[STAT_ARMOR]);
1776 if (bits & SU_WEAPON)
1777 MSG_WriteShort (msg, stats[STAT_WEAPON]);
1778 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1779 MSG_WriteShort (msg, stats[STAT_AMMO]);
1780 MSG_WriteShort (msg, stats[STAT_SHELLS]);
1781 MSG_WriteShort (msg, stats[STAT_NAILS]);
1782 MSG_WriteShort (msg, stats[STAT_ROCKETS]);
1783 MSG_WriteShort (msg, stats[STAT_CELLS]);
1784 MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
1785 if (bits & SU_VIEWZOOM)
1786 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1788 else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1790 if (bits & SU_WEAPONFRAME)
1791 MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
1792 if (bits & SU_ARMOR)
1793 MSG_WriteByte (msg, stats[STAT_ARMOR]);
1794 if (bits & SU_WEAPON)
1796 if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1797 MSG_WriteShort (msg, stats[STAT_WEAPON]);
1799 MSG_WriteByte (msg, stats[STAT_WEAPON]);
1801 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1802 MSG_WriteByte (msg, stats[STAT_AMMO]);
1803 MSG_WriteByte (msg, stats[STAT_SHELLS]);
1804 MSG_WriteByte (msg, stats[STAT_NAILS]);
1805 MSG_WriteByte (msg, stats[STAT_ROCKETS]);
1806 MSG_WriteByte (msg, stats[STAT_CELLS]);
1807 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
1809 for (i = 0;i < 32;i++)
1810 if (stats[STAT_ACTIVEWEAPON] & (1<<i))
1812 MSG_WriteByte (msg, i);
1815 MSG_WriteByte (msg, stats[STAT_ACTIVEWEAPON]);
1816 if (bits & SU_VIEWZOOM)
1818 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1819 MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
1821 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1826 void SV_FlushBroadcastMessages(void)
1830 if (sv.datagram.cursize <= 0)
1832 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1834 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])))
1836 SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
1837 client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
1839 SZ_Clear(&sv.datagram);
1842 static void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg, int maxsize, int maxsize2)
1844 // scan the splitpoints to find out how many we can fit in
1845 int numsegments, j, split;
1846 if (!client->unreliablemsg_splitpoints)
1848 // always accept the first one if it's within 1024 bytes, this ensures
1849 // that very big datagrams which are over the rate limit still get
1850 // through, just to keep it working
1851 for (numsegments = 1;numsegments < client->unreliablemsg_splitpoints;numsegments++)
1852 if (msg->cursize + client->unreliablemsg_splitpoint[numsegments] > maxsize)
1854 // the first segment gets an exemption from the rate limiting, otherwise
1855 // it could get dropped consistently due to a low rate limit
1856 if (numsegments == 1)
1858 // some will fit, so add the ones that will fit
1859 split = client->unreliablemsg_splitpoint[numsegments-1];
1860 // note this discards ones that were accepted by the segments scan but
1861 // can not fit, such as a really huge first one that will never ever
1862 // fit in a packet...
1863 if (msg->cursize + split <= maxsize)
1864 SZ_Write(msg, client->unreliablemsg.data, split);
1865 // remove the part we sent, keeping any remaining data
1866 client->unreliablemsg.cursize -= split;
1867 if (client->unreliablemsg.cursize > 0)
1868 memmove(client->unreliablemsg.data, client->unreliablemsg.data + split, client->unreliablemsg.cursize);
1869 // adjust remaining splitpoints
1870 client->unreliablemsg_splitpoints -= numsegments;
1871 for (j = 0;j < client->unreliablemsg_splitpoints;j++)
1872 client->unreliablemsg_splitpoint[j] = client->unreliablemsg_splitpoint[numsegments + j] - split;
1876 =======================
1877 SV_SendClientDatagram
1878 =======================
1880 static void SV_SendClientDatagram (client_t *client)
1882 int clientrate, maxrate, maxsize, maxsize2, downloadsize;
1884 int stats[MAX_CL_STATS];
1885 unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE];
1887 // obey rate limit by limiting packet frequency if the packet size
1889 // (usually this is caused by reliable messages)
1890 if (!NetConn_CanSend(client->netconnection))
1893 // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
1894 maxrate = max(NET_MINRATE, sv_maxrate.integer);
1895 if (sv_maxrate.integer != maxrate)
1896 Cvar_SetValueQuick(&sv_maxrate, maxrate);
1898 // clientrate determines the 'cleartime' of a packet
1899 // (how long to wait before sending another, based on this packet's size)
1900 clientrate = bound(NET_MINRATE, client->rate, maxrate);
1902 switch (sv.protocol)
1904 case PROTOCOL_QUAKE:
1905 case PROTOCOL_QUAKEDP:
1906 case PROTOCOL_NEHAHRAMOVIE:
1907 case PROTOCOL_NEHAHRABJP:
1908 case PROTOCOL_NEHAHRABJP2:
1909 case PROTOCOL_NEHAHRABJP3:
1910 case PROTOCOL_QUAKEWORLD:
1911 // no packet size limit support on Quake protocols because it just
1912 // causes missing entities/effects
1913 // packets are simply sent less often to obey the rate limit
1917 case PROTOCOL_DARKPLACES1:
1918 case PROTOCOL_DARKPLACES2:
1919 case PROTOCOL_DARKPLACES3:
1920 case PROTOCOL_DARKPLACES4:
1921 // no packet size limit support on DP1-4 protocols because they kick
1922 // the client off if they overflow, and miss effects
1923 // packets are simply sent less often to obey the rate limit
1924 maxsize = sizeof(sv_sendclientdatagram_buf);
1925 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1928 // DP5 and later protocols support packet size limiting which is a
1929 // better method than limiting packet frequency as QW does
1931 // at very low rates (or very small sys_ticrate) the packet size is
1932 // not reduced below 128, but packets may be sent less often
1933 maxsize = (int)(clientrate * sys_ticrate.value);
1934 maxsize = bound(128, maxsize, 1400);
1936 // csqc entities can easily exceed 128 bytes, so disable throttling in
1937 // mods that use csqc (they are likely to use less bandwidth anyway)
1938 if (sv.csqc_progsize > 0)
1943 if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !sv_ratelimitlocalplayer.integer)
1945 // for good singleplayer, send huge packets
1946 maxsize = sizeof(sv_sendclientdatagram_buf);
1947 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1948 // never limit frequency in singleplayer
1949 clientrate = 1000000000;
1952 // while downloading, limit entity updates to half the packet
1953 // (any leftover space will be used for downloading)
1954 if (host_client->download_file)
1957 msg.data = sv_sendclientdatagram_buf;
1958 msg.maxsize = sizeof(sv_sendclientdatagram_buf);
1960 msg.allowoverflow = false;
1962 if (host_client->spawned)
1964 // the player is in the game
1965 MSG_WriteByte (&msg, svc_time);
1966 MSG_WriteFloat (&msg, sv.time);
1968 // add the client specific data to the datagram
1969 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
1970 // now update the stats[] array using any registered custom fields
1971 VM_SV_UpdateCustomStats (client, client->edict, &msg, stats);
1972 // set host_client->statsdeltabits
1973 Protocol_UpdateClientStats (stats);
1975 // add as many queued unreliable messages (effects) as we can fit
1976 // limit effects to half of the remaining space
1977 if (client->unreliablemsg.cursize)
1978 SV_WriteUnreliableMessages (client, &msg, maxsize/2, maxsize2);
1980 // now write as many entities as we can fit, and also sends stats
1981 SV_WriteEntitiesToClient (client, client->edict, &msg, maxsize);
1983 else if (realtime > client->keepalivetime)
1985 // the player isn't totally in the game yet
1986 // send small keepalive messages if too much time has passed
1987 // (may also be sending downloads)
1988 client->keepalivetime = realtime + 5;
1989 MSG_WriteChar (&msg, svc_nop);
1992 // if a download is active, see if there is room to fit some download data
1994 downloadsize = min(maxsize*2,maxsize2) - msg.cursize - 7;
1995 if (host_client->download_file && host_client->download_started && downloadsize > 0)
1997 fs_offset_t downloadstart;
1998 unsigned char data[1400];
1999 downloadstart = FS_Tell(host_client->download_file);
2000 downloadsize = min(downloadsize, (int)sizeof(data));
2001 downloadsize = FS_Read(host_client->download_file, data, downloadsize);
2002 // note this sends empty messages if at the end of the file, which is
2003 // necessary to keep the packet loss logic working
2004 // (the last blocks may be lost and need to be re-sent, and that will
2005 // only occur if the client acks the empty end messages, revealing
2006 // a gap in the download progress, causing the last blocks to be
2008 MSG_WriteChar (&msg, svc_downloaddata);
2009 MSG_WriteLong (&msg, downloadstart);
2010 MSG_WriteShort (&msg, downloadsize);
2011 if (downloadsize > 0)
2012 SZ_Write (&msg, data, downloadsize);
2015 // reliable only if none is in progress
2016 if(client->sendsignon != 2 && !client->netconnection->sendMessageLength)
2017 SV_WriteDemoMessage(client, &(client->netconnection->message), false);
2019 SV_WriteDemoMessage(client, &msg, false);
2021 // send the datagram
2022 NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->sendsignon == 2);
2023 if (client->sendsignon == 1 && !client->netconnection->message.cursize)
2024 client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
2028 =======================
2029 SV_UpdateToReliableMessages
2030 =======================
2032 static void SV_UpdateToReliableMessages (void)
2041 // check for changes to be sent over the reliable streams
2042 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2044 // update the host_client fields we care about according to the entity fields
2045 host_client->edict = PRVM_EDICT_NUM(i+1);
2048 name = PRVM_GetString(host_client->edict->fields.server->netname);
2051 // always point the string back at host_client->name to keep it safe
2052 strlcpy (host_client->name, name, sizeof (host_client->name));
2053 host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
2054 if (strcmp(host_client->old_name, host_client->name))
2056 if (host_client->spawned)
2057 SV_BroadcastPrintf("%s ^7changed name to %s\n", host_client->old_name, host_client->name);
2058 strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
2059 // send notification to all clients
2060 MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
2061 MSG_WriteByte (&sv.reliable_datagram, i);
2062 MSG_WriteString (&sv.reliable_datagram, host_client->name);
2063 SV_WriteNetnameIntoDemo(host_client);
2066 // DP_SV_CLIENTCOLORS
2067 // this is always found (since it's added by the progs loader)
2068 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcolors)))
2069 host_client->colors = (int)val->_float;
2070 if (host_client->old_colors != host_client->colors)
2072 host_client->old_colors = host_client->colors;
2073 // send notification to all clients
2074 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
2075 MSG_WriteByte (&sv.reliable_datagram, i);
2076 MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
2079 // NEXUIZ_PLAYERMODEL
2080 if( prog->fieldoffsets.playermodel >= 0 ) {
2081 model = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string);
2084 // always point the string back at host_client->name to keep it safe
2085 strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
2086 PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
2089 // NEXUIZ_PLAYERSKIN
2090 if( prog->fieldoffsets.playerskin >= 0 ) {
2091 skin = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string);
2094 // always point the string back at host_client->name to keep it safe
2095 strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
2096 PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
2099 // TODO: add an extension name for this [1/17/2008 Black]
2100 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcamera)) && val->edict > 0 ) {
2101 int oldclientcamera = host_client->clientcamera;
2102 if( val->edict >= prog->max_edicts || PRVM_EDICT_NUM( val->edict )->priv.required->free ) {
2103 val->edict = host_client->clientcamera = PRVM_NUM_FOR_EDICT( host_client->edict );
2105 host_client->clientcamera = val->edict;
2108 if( oldclientcamera != host_client->clientcamera ) {
2109 MSG_WriteByte (&sv.reliable_datagram, svc_setview );
2110 MSG_WriteShort (&host_client->netconnection->message, host_client->clientcamera);
2115 host_client->frags = (int)host_client->edict->fields.server->frags;
2116 if(gamemode == GAME_NEXUIZ)
2117 if(!host_client->spawned && host_client->netconnection)
2118 host_client->frags = -666;
2119 if (host_client->old_frags != host_client->frags)
2121 host_client->old_frags = host_client->frags;
2122 // send notification to all clients
2123 MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
2124 MSG_WriteByte (&sv.reliable_datagram, i);
2125 MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
2129 for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
2130 if (client->netconnection && (client->spawned || client->clientconnectcalled)) // also send MSG_ALL to people who are past ClientConnect, but not spawned yet
2131 SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
2133 SZ_Clear (&sv.reliable_datagram);
2138 =======================
2139 SV_SendClientMessages
2140 =======================
2142 void SV_SendClientMessages (void)
2144 int i, prepared = false;
2146 if (sv.protocol == PROTOCOL_QUAKEWORLD)
2147 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
2149 SV_FlushBroadcastMessages();
2151 // update frags, names, etc
2152 SV_UpdateToReliableMessages();
2154 // build individual updates
2155 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2157 if (!host_client->active)
2159 if (!host_client->netconnection)
2162 if (host_client->netconnection->message.overflowed)
2164 SV_DropClient (true); // if the message couldn't send, kick off
2171 // only prepare entities once per frame
2172 SV_PrepareEntitiesForSending();
2174 SV_SendClientDatagram (host_client);
2177 // clear muzzle flashes
2181 static void SV_StartDownload_f(void)
2183 if (host_client->download_file)
2184 host_client->download_started = true;
2188 * Compression extension negotiation:
2191 * cl_serverextension_download 2
2194 * download <filename> <list of zero or more suppported compressions in order of preference>
2196 * download maps/map1.bsp lzo deflate huffman
2199 * cl_downloadbegin <compressed size> <filename> <compression method actually used>
2201 * cl_downloadbegin 123456 maps/map1.bsp deflate
2203 * The server may choose not to compress the file by sending no compression name, like:
2204 * cl_downloadbegin 345678 maps/map1.bsp
2206 * NOTE: the "download" command may only specify compression algorithms if
2207 * cl_serverextension_download is 2!
2208 * If cl_serverextension_download has a different value, the client must
2209 * assume this extension is not supported!
2212 static void Download_CheckExtensions(void)
2215 int argc = Cmd_Argc();
2217 // first reset them all
2218 host_client->download_deflate = false;
2220 for(i = 2; i < argc; ++i)
2222 if(!strcmp(Cmd_Argv(i), "deflate"))
2224 host_client->download_deflate = true;
2230 static void SV_Download_f(void)
2232 const char *whichpack, *whichpack2, *extension;
2233 qboolean is_csqc; // so we need to check only once
2237 SV_ClientPrintf("usage: download <filename> {<extensions>}*\n");
2238 SV_ClientPrintf(" supported extensions: deflate\n");
2242 if (FS_CheckNastyPath(Cmd_Argv(1), false))
2244 SV_ClientPrintf("Download rejected: nasty filename \"%s\"\n", Cmd_Argv(1));
2248 if (host_client->download_file)
2250 // at this point we'll assume the previous download should be aborted
2251 Con_DPrintf("Download of %s aborted by %s starting a new download\n", host_client->download_name, host_client->name);
2252 Host_ClientCommands("\nstopdownload\n");
2254 // close the file and reset variables
2255 FS_Close(host_client->download_file);
2256 host_client->download_file = NULL;
2257 host_client->download_name[0] = 0;
2258 host_client->download_expectedposition = 0;
2259 host_client->download_started = false;
2262 is_csqc = (sv.csqc_progname[0] && strcmp(Cmd_Argv(1), sv.csqc_progname) == 0);
2264 if (!sv_allowdownloads.integer && !is_csqc)
2266 SV_ClientPrintf("Downloads are disabled on this server\n");
2267 Host_ClientCommands("\nstopdownload\n");
2271 Download_CheckExtensions();
2273 strlcpy(host_client->download_name, Cmd_Argv(1), sizeof(host_client->download_name));
2274 extension = FS_FileExtension(host_client->download_name);
2276 // host_client is asking to download a specified file
2277 if (developer.integer >= 100)
2278 Con_Printf("Download request for %s by %s\n", host_client->download_name, host_client->name);
2282 char extensions[MAX_QPATH]; // make sure this can hold all extensions
2283 extensions[0] = '\0';
2285 if(host_client->download_deflate)
2286 strlcat(extensions, " deflate", sizeof(extensions));
2288 Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
2290 if(host_client->download_deflate && svs.csqc_progdata_deflated)
2291 host_client->download_file = FS_FileFromData(svs.csqc_progdata_deflated, svs.csqc_progsize_deflated, true);
2293 host_client->download_file = FS_FileFromData(svs.csqc_progdata, sv.csqc_progsize, true);
2295 // no, no space is needed between %s and %s :P
2296 Host_ClientCommands("\ncl_downloadbegin %i %s%s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name, extensions);
2298 host_client->download_expectedposition = 0;
2299 host_client->download_started = false;
2300 host_client->sendsignon = true; // make sure this message is sent
2304 if (!FS_FileExists(host_client->download_name))
2306 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);
2307 Host_ClientCommands("\nstopdownload\n");
2311 // check if the user is trying to download part of registered Quake(r)
2312 whichpack = FS_WhichPack(host_client->download_name);
2313 whichpack2 = FS_WhichPack("gfx/pop.lmp");
2314 if ((whichpack && whichpack2 && !strcasecmp(whichpack, whichpack2)) || FS_IsRegisteredQuakePack(host_client->download_name))
2316 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);
2317 Host_ClientCommands("\nstopdownload\n");
2321 // check if the server has forbidden archive downloads entirely
2322 if (!sv_allowdownloads_inarchive.integer)
2324 whichpack = FS_WhichPack(host_client->download_name);
2327 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);
2328 Host_ClientCommands("\nstopdownload\n");
2333 if (!sv_allowdownloads_config.integer)
2335 if (!strcasecmp(extension, "cfg"))
2337 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);
2338 Host_ClientCommands("\nstopdownload\n");
2343 if (!sv_allowdownloads_dlcache.integer)
2345 if (!strncasecmp(host_client->download_name, "dlcache/", 8))
2347 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);
2348 Host_ClientCommands("\nstopdownload\n");
2353 if (!sv_allowdownloads_archive.integer)
2355 if (!strcasecmp(extension, "pak") || !strcasecmp(extension, "pk3"))
2357 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);
2358 Host_ClientCommands("\nstopdownload\n");
2363 host_client->download_file = FS_OpenVirtualFile(host_client->download_name, true);
2364 if (!host_client->download_file)
2366 SV_ClientPrintf("Download rejected: server could not open the file \"%s\"\n", host_client->download_name);
2367 Host_ClientCommands("\nstopdownload\n");
2371 if (FS_FileSize(host_client->download_file) > 1<<30)
2373 SV_ClientPrintf("Download rejected: file \"%s\" is very large\n", host_client->download_name);
2374 Host_ClientCommands("\nstopdownload\n");
2375 FS_Close(host_client->download_file);
2376 host_client->download_file = NULL;
2380 if (FS_FileSize(host_client->download_file) < 0)
2382 SV_ClientPrintf("Download rejected: file \"%s\" is not a regular file\n", host_client->download_name);
2383 Host_ClientCommands("\nstopdownload\n");
2384 FS_Close(host_client->download_file);
2385 host_client->download_file = NULL;
2389 Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
2392 * we can only do this if we would actually deflate on the fly
2393 * which we do not (yet)!
2395 char extensions[MAX_QPATH]; // make sure this can hold all extensions
2396 extensions[0] = '\0';
2398 if(host_client->download_deflate)
2399 strlcat(extensions, " deflate", sizeof(extensions));
2401 // no, no space is needed between %s and %s :P
2402 Host_ClientCommands("\ncl_downloadbegin %i %s%s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name, extensions);
2405 Host_ClientCommands("\ncl_downloadbegin %i %s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name);
2407 host_client->download_expectedposition = 0;
2408 host_client->download_started = false;
2409 host_client->sendsignon = true; // make sure this message is sent
2411 // the rest of the download process is handled in SV_SendClientDatagram
2412 // and other code dealing with svc_downloaddata and clc_ackdownloaddata
2414 // no svc_downloaddata messages will be sent until sv_startdownload is
2415 // sent by the client
2419 ==============================================================================
2423 ==============================================================================
2432 int SV_ModelIndex(const char *s, int precachemode)
2434 int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3) ? 256 : MAX_MODELS);
2435 char filename[MAX_QPATH];
2439 //if (precachemode == 2)
2441 strlcpy(filename, s, sizeof(filename));
2442 for (i = 2;i < limit;i++)
2444 if (!sv.model_precache[i][0])
2448 if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
2450 Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
2453 if (precachemode == 1)
2454 Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2455 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
2456 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, s[0] == '*' ? sv.modelname : NULL);
2457 if (sv.state != ss_loading)
2459 MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2460 MSG_WriteShort(&sv.reliable_datagram, i);
2461 MSG_WriteString(&sv.reliable_datagram, filename);
2465 Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
2468 if (!strcmp(sv.model_precache[i], filename))
2471 Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
2481 int SV_SoundIndex(const char *s, int precachemode)
2483 int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3) ? 256 : MAX_SOUNDS);
2484 char filename[MAX_QPATH];
2488 //if (precachemode == 2)
2490 strlcpy(filename, s, sizeof(filename));
2491 for (i = 1;i < limit;i++)
2493 if (!sv.sound_precache[i][0])
2497 if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
2499 Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
2502 if (precachemode == 1)
2503 Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
2504 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
2505 if (sv.state != ss_loading)
2507 MSG_WriteByte(&sv.reliable_datagram, svc_precache);
2508 MSG_WriteShort(&sv.reliable_datagram, i + 32768);
2509 MSG_WriteString(&sv.reliable_datagram, filename);
2513 Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
2516 if (!strcmp(sv.sound_precache[i], filename))
2519 Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
2525 SV_ParticleEffectIndex
2529 int SV_ParticleEffectIndex(const char *name)
2531 int i, argc, linenumber, effectnameindex;
2532 fs_offset_t filesize;
2533 unsigned char *filedata;
2534 const char *text, *textstart, *textend;
2535 char argv[16][1024];
2536 if (!sv.particleeffectnamesloaded)
2538 sv.particleeffectnamesloaded = true;
2539 memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
2540 for (i = 0;i < EFFECT_TOTAL;i++)
2541 strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
2542 filedata = FS_LoadFile("effectinfo.txt", tempmempool, true, &filesize);
2545 textstart = (const char *)filedata;
2546 textend = (const char *)filedata + filesize;
2548 for (linenumber = 1;;linenumber++)
2553 if (!COM_ParseToken_Simple(&text, true, false) || !strcmp(com_token, "\n"))
2557 strlcpy(argv[argc], com_token, sizeof(argv[argc]));
2561 if (com_token[0] == 0)
2562 break; // if the loop exited and it's not a \n, it's EOF
2565 if (!strcmp(argv[0], "effect"))
2569 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME;effectnameindex++)
2571 if (sv.particleeffectname[effectnameindex][0])
2573 if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
2578 strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
2582 // if we run out of names, abort
2583 if (effectnameindex == SV_MAX_PARTICLEEFFECTNAME)
2585 Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
2594 // search for the name
2595 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
2596 if (!strcmp(sv.particleeffectname[effectnameindex], name))
2597 return effectnameindex;
2598 // return 0 if we couldn't find it
2608 static void SV_CreateBaseline (void)
2610 int i, entnum, large;
2611 prvm_edict_t *svent;
2613 // LordHavoc: clear *all* states (note just active ones)
2614 for (entnum = 0;entnum < prog->max_edicts;entnum++)
2616 // get the current server version
2617 svent = PRVM_EDICT_NUM(entnum);
2619 // LordHavoc: always clear state values, whether the entity is in use or not
2620 svent->priv.server->baseline = defaultstate;
2622 if (svent->priv.server->free)
2624 if (entnum > svs.maxclients && !svent->fields.server->modelindex)
2627 // create entity baseline
2628 VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
2629 VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
2630 svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
2631 svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
2632 if (entnum > 0 && entnum <= svs.maxclients)
2634 svent->priv.server->baseline.colormap = entnum;
2635 svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
2639 svent->priv.server->baseline.colormap = 0;
2640 svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
2644 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
2647 if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2651 // add to the message
2653 MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
2655 MSG_WriteByte (&sv.signon, svc_spawnbaseline);
2656 MSG_WriteShort (&sv.signon, entnum);
2660 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2661 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
2663 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
2665 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
2666 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2670 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
2671 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
2673 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
2674 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
2675 for (i=0 ; i<3 ; i++)
2677 MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
2678 MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
2687 Load csprogs.dat and comperss it so it doesn't need to be
2688 reloaded on request.
2691 void SV_Prepare_CSQC(void)
2693 fs_offset_t progsize;
2695 if(svs.csqc_progdata)
2697 Con_DPrintf("Unloading old CSQC data.\n");
2698 Mem_Free(svs.csqc_progdata);
2699 if(svs.csqc_progdata_deflated)
2700 Mem_Free(svs.csqc_progdata_deflated);
2703 svs.csqc_progdata = NULL;
2704 svs.csqc_progdata_deflated = NULL;
2706 Con_Print("Loading csprogs.dat\n");
2708 sv.csqc_progname[0] = 0;
2709 svs.csqc_progdata = FS_LoadFile(csqc_progname.string, sv_mempool, false, &progsize);
2713 size_t deflated_size;
2715 sv.csqc_progsize = (int)progsize;
2716 sv.csqc_progcrc = CRC_Block(svs.csqc_progdata, progsize);
2717 strlcpy(sv.csqc_progname, csqc_progname.string, sizeof(sv.csqc_progname));
2718 Con_Printf("server detected csqc progs file \"%s\" with size %i and crc %i\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
2720 Con_Print("Compressing csprogs.dat\n");
2721 //unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflated_size, int level, mempool_t *mempool);
2722 svs.csqc_progdata_deflated = FS_Deflate(svs.csqc_progdata, progsize, &deflated_size, -1, sv_mempool);
2723 svs.csqc_progsize_deflated = (int)deflated_size;
2724 if(svs.csqc_progdata_deflated)
2726 Con_Printf("Deflated: %g%%\n", 100.0 - 100.0 * (deflated_size / (float)progsize));
2727 Con_DPrintf("Uncompressed: %u\nCompressed: %u\n", (unsigned)sv.csqc_progsize, (unsigned)svs.csqc_progsize_deflated);
2730 Con_Printf("Cannot compress - need zlib for this. Using uncompressed progs only.\n");
2738 Grabs the current state of each client for saving across the
2739 transition to another level
2742 void SV_SaveSpawnparms (void)
2746 svs.serverflags = (int)prog->globals.server->serverflags;
2748 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2750 if (!host_client->active)
2753 // call the progs to get default spawn parms for the new client
2754 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2755 PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
2756 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
2757 host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
2765 This is called at the start of each level
2769 void SV_SpawnServer (const char *server)
2774 dp_model_t *worldmodel;
2775 char modelname[sizeof(sv.modelname)];
2777 Con_DPrintf("SpawnServer: %s\n", server);
2779 dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
2781 if (!FS_FileExists(modelname))
2783 Con_Printf("SpawnServer: no map file named %s\n", modelname);
2787 if (cls.state != ca_dedicated)
2789 SCR_BeginLoadingPlaque();
2796 if(prog->funcoffsets.SV_Shutdown)
2798 func_t s = prog->funcoffsets.SV_Shutdown;
2799 prog->funcoffsets.SV_Shutdown = 0; // prevent it from getting called again
2800 PRVM_ExecuteProgram(s,"SV_Shutdown() required");
2805 // free q3 shaders so that any newly downloaded shaders will be active
2806 Mod_FreeQ3Shaders();
2808 worldmodel = Mod_ForName(modelname, false, true, NULL);
2809 if (!worldmodel || !worldmodel->TraceBox)
2811 Con_Printf("Couldn't load map %s\n", modelname);
2815 // let's not have any servers with no name
2816 if (hostname.string[0] == 0)
2817 Cvar_Set ("hostname", "UNNAMED");
2818 scr_centertime_off = 0;
2820 svs.changelevel_issued = false; // now safe to issue another
2822 // make the map a required file for clients
2823 Curl_ClearRequirements();
2824 Curl_RequireFile(modelname);
2827 // tell all connected clients that we are going to a new level
2832 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
2834 if (client->netconnection)
2836 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
2837 MSG_WriteString(&client->netconnection->message, "reconnect\n");
2844 NetConn_OpenServerPorts(true);
2848 // make cvars consistant
2851 Cvar_SetValue ("deathmatch", 0);
2852 // LordHavoc: it can be useful to have skills outside the range 0-3...
2853 //current_skill = bound(0, (int)(skill.value + 0.5), 3);
2854 //Cvar_SetValue ("skill", (float)current_skill);
2855 current_skill = (int)(skill.value + 0.5);
2858 // set up the new server
2860 memset (&sv, 0, sizeof(sv));
2861 // if running a local client, make sure it doesn't try to access the last
2862 // level's data which is no longer valiud
2865 Cvar_SetValue("halflifebsp", worldmodel->brush.ishlbsp);
2867 if(*sv_random_seed.string)
2869 srand(sv_random_seed.integer);
2870 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);
2877 strlcpy (sv.name, server, sizeof (sv.name));
2879 sv.protocol = Protocol_EnumForName(sv_protocolname.string);
2880 if (sv.protocol == PROTOCOL_UNKNOWN)
2883 Protocol_Names(buffer, sizeof(buffer));
2884 Con_Printf("Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
2885 sv.protocol = PROTOCOL_QUAKE;
2890 // load progs to get entity field count
2891 //PR_LoadProgs ( sv_progs.string );
2893 sv.datagram.maxsize = sizeof(sv.datagram_buf);
2894 sv.datagram.cursize = 0;
2895 sv.datagram.data = sv.datagram_buf;
2897 sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
2898 sv.reliable_datagram.cursize = 0;
2899 sv.reliable_datagram.data = sv.reliable_datagram_buf;
2901 sv.signon.maxsize = sizeof(sv.signon_buf);
2902 sv.signon.cursize = 0;
2903 sv.signon.data = sv.signon_buf;
2905 // leave slots at start for clients only
2906 //prog->num_edicts = svs.maxclients+1;
2908 sv.state = ss_loading;
2909 prog->allowworldwrites = true;
2912 prog->globals.server->time = sv.time = 1.0;
2915 worldmodel->used = true;
2917 strlcpy (sv.name, server, sizeof (sv.name));
2918 strlcpy(sv.modelname, modelname, sizeof(sv.modelname));
2919 sv.worldmodel = worldmodel;
2920 sv.models[1] = sv.worldmodel;
2923 // clear world interaction links
2925 World_SetSize(&sv.world, sv.worldmodel->name, sv.worldmodel->normalmins, sv.worldmodel->normalmaxs);
2927 strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
2929 strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
2930 strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
2931 for (i = 1;i < sv.worldmodel->brush.numsubmodels && i+1 < MAX_MODELS;i++)
2933 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
2934 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, sv.modelname);
2936 if(i < sv.worldmodel->brush.numsubmodels)
2937 Con_Printf("Too many submodels (MAX_MODELS is %i)\n", MAX_MODELS);
2940 // load the rest of the entities
2942 // AK possible hack since num_edicts is still 0
2943 ent = PRVM_EDICT_NUM(0);
2944 memset (ent->fields.server, 0, prog->progs->entityfields * 4);
2945 ent->priv.server->free = false;
2946 ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
2947 ent->fields.server->modelindex = 1; // world model
2948 ent->fields.server->solid = SOLID_BSP;
2949 ent->fields.server->movetype = MOVETYPE_PUSH;
2950 VectorCopy(sv.world.mins, ent->fields.server->mins);
2951 VectorCopy(sv.world.maxs, ent->fields.server->maxs);
2952 VectorCopy(sv.world.mins, ent->fields.server->absmin);
2953 VectorCopy(sv.world.maxs, ent->fields.server->absmax);
2956 prog->globals.server->coop = coop.integer;
2958 prog->globals.server->deathmatch = deathmatch.integer;
2960 prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
2962 // serverflags are for cross level information (sigils)
2963 prog->globals.server->serverflags = svs.serverflags;
2965 // we need to reset the spawned flag on all connected clients here so that
2966 // their thinks don't run during startup (before PutClientInServer)
2967 // we also need to set up the client entities now
2968 // and we need to set the ->edict pointers to point into the progs edicts
2969 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2971 host_client->spawned = false;
2972 host_client->edict = PRVM_EDICT_NUM(i + 1);
2973 PRVM_ED_ClearEdict(host_client->edict);
2976 // load replacement entity file if found
2977 if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
2979 Con_Printf("Loaded maps/%s.ent\n", sv.name);
2980 PRVM_ED_LoadFromFile (entities);
2984 PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
2987 // LordHavoc: clear world angles (to fix e3m3.bsp)
2988 VectorClear(prog->edicts->fields.server->angles);
2990 // all setup is completed, any further precache statements are errors
2991 // sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
2992 prog->allowworldwrites = false;
2994 // run two frames to allow everything to settle
2995 prog->globals.server->time = sv.time = 1.0001;
2996 for (i = 0;i < 2;i++)
3002 if (cls.state == ca_dedicated)
3005 // create a baseline for more efficient communications
3006 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
3007 SV_CreateBaseline ();
3009 sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
3011 // to prevent network timeouts
3012 realtime = Sys_DoubleTime();
3014 // send serverinfo to all connected clients, and set up botclients coming back from a level change
3015 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
3017 host_client->clientconnectcalled = false; // do NOT call ClientDisconnect if he drops before ClientConnect!
3018 if (!host_client->active)
3020 if (host_client->netconnection)
3021 SV_SendServerinfo(host_client);
3025 // if client is a botclient coming from a level change, we need to
3026 // set up client info that normally requires networking
3028 // copy spawn parms out of the client_t
3029 for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
3030 (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
3032 // call the spawn function
3033 host_client->clientconnectcalled = true;
3034 prog->globals.server->time = sv.time;
3035 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
3036 PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
3037 PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
3038 host_client->spawned = true;
3042 Con_DPrint("Server spawned.\n");
3043 NetConn_Heartbeat (2);
3048 /////////////////////////////////////////////////////
3051 static void SV_VM_CB_BeginIncreaseEdicts(void)
3053 // links don't survive the transition, so unlink everything
3054 World_UnlinkAll(&sv.world);
3057 static void SV_VM_CB_EndIncreaseEdicts(void)
3062 // link every entity except world
3063 for (i = 1, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
3064 if (!ent->priv.server->free)
3065 SV_LinkEdict(ent, false);
3068 static void SV_VM_CB_InitEdict(prvm_edict_t *e)
3070 // LordHavoc: for consistency set these here
3071 int num = PRVM_NUM_FOR_EDICT(e) - 1;
3073 e->priv.server->move = false; // don't move on first frame
3075 if (num >= 0 && num < svs.maxclients)
3078 // set colormap and team on newly created player entity
3079 e->fields.server->colormap = num + 1;
3080 e->fields.server->team = (svs.clients[num].colors & 15) + 1;
3081 // set netname/clientcolors back to client values so that
3082 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
3084 e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
3085 if ((val = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.clientcolors)))
3086 val->_float = svs.clients[num].colors;
3087 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
3088 if( prog->fieldoffsets.playermodel >= 0 )
3089 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
3090 if( prog->fieldoffsets.playerskin >= 0 )
3091 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
3092 // Assign netaddress (IP Address, etc)
3093 if(prog->fieldoffsets.netaddress >= 0)
3094 { // Valid Field; Process
3095 if(svs.clients[num].netconnection != NULL)
3096 {// Valid Address; Assign
3097 // Acquire Readable Address
3098 LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
3099 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString(svs.clients[num].netaddress);
3103 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.netaddress)->string = PRVM_SetEngineString("null/botclient");
3108 static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
3113 World_UnlinkEdict(ed); // unlink from world bsp
3115 ed->fields.server->model = 0;
3116 ed->fields.server->takedamage = 0;
3117 ed->fields.server->modelindex = 0;
3118 ed->fields.server->colormap = 0;
3119 ed->fields.server->skin = 0;
3120 ed->fields.server->frame = 0;
3121 VectorClear(ed->fields.server->origin);
3122 VectorClear(ed->fields.server->angles);
3123 ed->fields.server->nextthink = -1;
3124 ed->fields.server->solid = 0;
3126 // make sure csqc networking is aware of the removed entity
3127 e = PRVM_NUM_FOR_EDICT(ed);
3128 sv.csqcentityversion[e] = 0;
3129 for (i = 0;i < svs.maxclients;i++)
3131 if (svs.clients[i].csqcentityscope[e])
3132 svs.clients[i].csqcentityscope[e] = 1; // removed, awaiting send
3133 svs.clients[i].csqcentitysendflags[e] = 0xFFFFFF;
3137 static void SV_VM_CB_CountEdicts(void)
3141 int active, models, solid, step;
3143 active = models = solid = step = 0;
3144 for (i=0 ; i<prog->num_edicts ; i++)
3146 ent = PRVM_EDICT_NUM(i);
3147 if (ent->priv.server->free)
3150 if (ent->fields.server->solid)
3152 if (ent->fields.server->model)
3154 if (ent->fields.server->movetype == MOVETYPE_STEP)
3158 Con_Printf("num_edicts:%3i\n", prog->num_edicts);
3159 Con_Printf("active :%3i\n", active);
3160 Con_Printf("view :%3i\n", models);
3161 Con_Printf("touch :%3i\n", solid);
3162 Con_Printf("step :%3i\n", step);
3165 static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
3167 // remove things from different skill levels or deathmatch
3168 if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
3170 if (deathmatch.integer)
3172 if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
3177 else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY ))
3178 || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
3179 || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD )))
3187 static void SV_VM_Setup(void)
3190 PRVM_InitProg( PRVM_SERVERPROG );
3192 // allocate the mempools
3193 // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
3194 prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
3195 prog->builtins = vm_sv_builtins;
3196 prog->numbuiltins = vm_sv_numbuiltins;
3197 prog->headercrc = PROGHEADER_CRC;
3198 prog->headercrc2 = PROGHEADER_CRC_TENEBRAE;
3199 prog->max_edicts = 512;
3200 if (sv.protocol == PROTOCOL_QUAKE)
3201 prog->limit_edicts = 640; // before quake mission pack 1 this was 512
3202 else if (sv.protocol == PROTOCOL_QUAKEDP)
3203 prog->limit_edicts = 2048; // guessing
3204 else if (sv.protocol == PROTOCOL_NEHAHRAMOVIE)
3205 prog->limit_edicts = 2048; // guessing!
3206 else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
3207 prog->limit_edicts = 4096; // guessing!
3209 prog->limit_edicts = MAX_EDICTS;
3210 prog->reserved_edicts = svs.maxclients;
3211 prog->edictprivate_size = sizeof(edict_engineprivate_t);
3212 prog->name = "server";
3213 prog->extensionstring = vm_sv_extensions;
3214 prog->loadintoworld = true;
3216 prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
3217 prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
3218 prog->init_edict = SV_VM_CB_InitEdict;
3219 prog->free_edict = SV_VM_CB_FreeEdict;
3220 prog->count_edicts = SV_VM_CB_CountEdicts;
3221 prog->load_edict = SV_VM_CB_LoadEdict;
3222 prog->init_cmd = VM_SV_Cmd_Init;
3223 prog->reset_cmd = VM_SV_Cmd_Reset;
3224 prog->error_cmd = Host_Error;
3226 // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
3227 PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields, 0, NULL );
3229 // some mods compiled with scrambling compilers lack certain critical
3230 // global names and field names such as "self" and "time" and "nextthink"
3231 // so we have to set these offsets manually, matching the entvars_t
3232 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
3233 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
3234 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
3235 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
3236 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
3237 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
3238 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
3239 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
3240 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
3241 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
3242 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
3243 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
3244 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
3245 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
3246 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
3247 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
3248 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
3249 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
3250 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
3251 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
3252 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
3253 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
3254 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
3255 // OP_STATE is always supported on server (due to entvars_t)
3256 prog->flag |= PRVM_OP_STATE;
3258 VM_CustomStats_Clear();//[515]: csqc
3265 void SV_VM_Begin(void)
3268 PRVM_SetProg( PRVM_SERVERPROG );
3270 prog->globals.server->time = (float) sv.time;
3273 void SV_VM_End(void)