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
28 void VM_AutoSentStats_Clear (void);
29 void EntityFrameCSQC_ClearVersions (void);
30 void EntityFrameCSQC_InitClientVersions (int client, qboolean clear);
31 void VM_SV_WriteAutoSentStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);
32 void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states);
35 // select which protocol to host, this is fed to Protocol_EnumForName
36 cvar_t sv_protocolname = {0, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
37 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)"};
38 cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "10000", "upper limit on client rate cvar, should reflect your network connection quality"};
39 cvar_t sv_allowdownloads = {0, "sv_allowdownloads", "1", "whether to allow clients to download files from the server (does not affect http downloads)"};
40 cvar_t sv_allowdownloads_inarchive = {0, "sv_allowdownloads_inarchive", "0", "whether to allow downloads from archives (pak/pk3)"};
41 cvar_t sv_allowdownloads_archive = {0, "sv_allowdownloads_archive", "0", "whether to allow downloads of archives (pak/pk3)"};
42 cvar_t sv_allowdownloads_config = {0, "sv_allowdownloads_config", "0", "whether to allow downloads of config files (cfg)"};
43 cvar_t sv_allowdownloads_dlcache = {0, "sv_allowdownloads_dlcache", "0", "whether to allow downloads of dlcache files (dlcache/)"};
45 extern cvar_t sv_random_seed;
47 static cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"}; // fast but loose
48 static 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"}; // tends to get false negatives, uses a timeout to keep entities visible a short time after becoming hidden
49 static cvar_t sv_cullentities_trace_samples = {0, "sv_cullentities_trace_samples", "1", "number of samples to test for entity culling"};
50 static 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"};
51 static cvar_t sv_cullentities_trace_enlarge = {0, "sv_cullentities_trace_enlarge", "0", "box enlargement for entity culling"};
52 static cvar_t sv_cullentities_trace_delay = {0, "sv_cullentities_trace_delay", "1", "number of seconds until the entity gets actually culled"};
53 static cvar_t sv_cullentities_trace_prediction = {0, "sv_cullentities_trace_prediction", "1", "also trace from the predicted player position"};
54 static 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!)"};
55 static cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
56 static 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)"};
58 cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
59 cvar_t sv_gameplayfix_noairborncorpse = {0, "sv_gameplayfix_noairborncorpse", "1", "causes entities (corpses) sitting ontop of moving entities (players) to fall when the moving entity (player) is no longer supporting them"};
60 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)"};
61 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)"};
62 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"};
63 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"};
64 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"};
65 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"};
66 cvar_t sv_gameplayfix_qwplayerphysics = {0, "sv_gameplayfix_qwplayerphysics", "1", "changes water jumping to make it easier to get out of water, and prevents friction on landing when bunnyhopping"};
67 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"};
68 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)"};
70 cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
72 // TODO: move these cvars here
73 extern cvar_t sv_clmovement_enable;
74 extern cvar_t sv_clmovement_minping;
75 extern cvar_t sv_clmovement_minping_disabletime;
76 extern cvar_t sv_clmovement_waitforinput;
81 mempool_t *sv_mempool = NULL;
83 //============================================================================
85 extern void SV_Phys_Init (void);
86 static void SV_SaveEntFile_f(void);
87 static void SV_StartDownload_f(void);
88 static void SV_Download_f(void);
90 void SV_AreaStats_f(void)
92 World_PrintAreaStats(&sv.world, "server");
102 // init the csqc progs cvars, since they are updated/used by the server code
103 // TODO: fix this since this is a quick hack to make some of [515]'s broken code run ;) [9/13/2006 Black]
104 extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat
105 extern cvar_t csqc_progcrc;
106 extern cvar_t csqc_progsize;
107 Cvar_RegisterVariable (&csqc_progname);
108 Cvar_RegisterVariable (&csqc_progcrc);
109 Cvar_RegisterVariable (&csqc_progsize);
111 Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
112 Cmd_AddCommand("sv_areastats", SV_AreaStats_f, "prints statistics on entity culling during collision traces");
113 Cmd_AddCommand_WithClientCommand("sv_startdownload", NULL, SV_StartDownload_f, "begins sending a file to the client (network protocol use only)");
114 Cmd_AddCommand_WithClientCommand("download", NULL, SV_Download_f, "downloads a specified file from the server");
115 Cvar_RegisterVariable (&sv_maxvelocity);
116 Cvar_RegisterVariable (&sv_gravity);
117 Cvar_RegisterVariable (&sv_friction);
118 Cvar_RegisterVariable (&sv_waterfriction);
119 Cvar_RegisterVariable (&sv_edgefriction);
120 Cvar_RegisterVariable (&sv_stopspeed);
121 Cvar_RegisterVariable (&sv_maxspeed);
122 Cvar_RegisterVariable (&sv_maxairspeed);
123 Cvar_RegisterVariable (&sv_accelerate);
124 Cvar_RegisterVariable (&sv_airaccelerate);
125 Cvar_RegisterVariable (&sv_wateraccelerate);
126 Cvar_RegisterVariable (&sv_clmovement_enable);
127 Cvar_RegisterVariable (&sv_clmovement_minping);
128 Cvar_RegisterVariable (&sv_clmovement_minping_disabletime);
129 Cvar_RegisterVariable (&sv_clmovement_waitforinput);
130 Cvar_RegisterVariable (&sv_idealpitchscale);
131 Cvar_RegisterVariable (&sv_aim);
132 Cvar_RegisterVariable (&sv_nostep);
133 Cvar_RegisterVariable (&sv_cullentities_pvs);
134 Cvar_RegisterVariable (&sv_cullentities_trace);
135 Cvar_RegisterVariable (&sv_cullentities_trace_samples);
136 Cvar_RegisterVariable (&sv_cullentities_trace_samples_extra);
137 Cvar_RegisterVariable (&sv_cullentities_trace_enlarge);
138 Cvar_RegisterVariable (&sv_cullentities_trace_delay);
139 Cvar_RegisterVariable (&sv_cullentities_trace_prediction);
140 Cvar_RegisterVariable (&sv_cullentities_nevercullbmodels);
141 Cvar_RegisterVariable (&sv_cullentities_stats);
142 Cvar_RegisterVariable (&sv_entpatch);
143 Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
144 Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
145 Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
146 Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
147 Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
148 Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
149 Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
150 Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
151 Cvar_RegisterVariable (&sv_gameplayfix_qwplayerphysics);
152 Cvar_RegisterVariable (&sv_gameplayfix_upwardvelocityclearsongroundflag);
153 Cvar_RegisterVariable (&sv_gameplayfix_droptofloorstartsolid);
154 Cvar_RegisterVariable (&sv_protocolname);
155 Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
156 Cvar_RegisterVariable (&sv_maxrate);
157 Cvar_RegisterVariable (&sv_allowdownloads);
158 Cvar_RegisterVariable (&sv_allowdownloads_inarchive);
159 Cvar_RegisterVariable (&sv_allowdownloads_archive);
160 Cvar_RegisterVariable (&sv_allowdownloads_config);
161 Cvar_RegisterVariable (&sv_allowdownloads_dlcache);
162 Cvar_RegisterVariable (&sv_progs);
167 sv_mempool = Mem_AllocPool("server", 0, NULL);
170 static void SV_SaveEntFile_f(void)
172 char basename[MAX_QPATH];
173 if (!sv.active || !sv.worldmodel)
175 Con_Print("Not running a server\n");
178 FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
179 FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
184 =============================================================================
188 =============================================================================
195 Make sure the event gets sent to all clients
198 void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
202 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
204 MSG_WriteByte (&sv.datagram, svc_particle);
205 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
206 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
207 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
208 for (i=0 ; i<3 ; i++)
209 MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
210 MSG_WriteByte (&sv.datagram, count);
211 MSG_WriteByte (&sv.datagram, color);
218 Make sure the event gets sent to all clients
221 void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
223 if (modelindex >= 256 || startframe >= 256)
225 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
227 MSG_WriteByte (&sv.datagram, svc_effect2);
228 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
229 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
230 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
231 MSG_WriteShort (&sv.datagram, modelindex);
232 MSG_WriteShort (&sv.datagram, startframe);
233 MSG_WriteByte (&sv.datagram, framecount);
234 MSG_WriteByte (&sv.datagram, framerate);
238 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
240 MSG_WriteByte (&sv.datagram, svc_effect);
241 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
242 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
243 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
244 MSG_WriteByte (&sv.datagram, modelindex);
245 MSG_WriteByte (&sv.datagram, startframe);
246 MSG_WriteByte (&sv.datagram, framecount);
247 MSG_WriteByte (&sv.datagram, framerate);
255 Each entity can have eight independant sound sources, like voice,
258 Channel 0 is an auto-allocate channel, the others override anything
259 already running on that entity/channel pair.
261 An attenuation of 0 will play full volume everywhere in the level.
262 Larger attenuations will drop off. (max 4 attenuation)
266 void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation)
268 int sound_num, field_mask, i, ent;
270 if (volume < 0 || volume > 255)
272 Con_Printf ("SV_StartSound: volume = %i\n", volume);
276 if (attenuation < 0 || attenuation > 4)
278 Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
282 if (channel < 0 || channel > 7)
284 Con_Printf ("SV_StartSound: channel = %i\n", channel);
288 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
291 // find precache number for sound
292 sound_num = SV_SoundIndex(sample, 1);
296 ent = PRVM_NUM_FOR_EDICT(entity);
299 if (volume != DEFAULT_SOUND_PACKET_VOLUME)
300 field_mask |= SND_VOLUME;
301 if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
302 field_mask |= SND_ATTENUATION;
304 field_mask |= SND_LARGEENTITY;
305 if (sound_num >= 256 || channel >= 8)
306 field_mask |= SND_LARGESOUND;
308 // directed messages go only to the entity they are targeted on
309 MSG_WriteByte (&sv.datagram, svc_sound);
310 MSG_WriteByte (&sv.datagram, field_mask);
311 if (field_mask & SND_VOLUME)
312 MSG_WriteByte (&sv.datagram, volume);
313 if (field_mask & SND_ATTENUATION)
314 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
315 if (field_mask & SND_LARGEENTITY)
317 MSG_WriteShort (&sv.datagram, ent);
318 MSG_WriteByte (&sv.datagram, channel);
321 MSG_WriteShort (&sv.datagram, (ent<<3) | channel);
322 if (field_mask & SND_LARGESOUND)
323 MSG_WriteShort (&sv.datagram, sound_num);
325 MSG_WriteByte (&sv.datagram, sound_num);
326 for (i = 0;i < 3;i++)
327 MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
331 ==============================================================================
335 ==============================================================================
342 Sends the first message from the server to a connected client.
343 This will be sent on the initial connection and upon each server load.
346 void SV_SendServerinfo (client_t *client)
351 // we know that this client has a netconnection and thus is not a bot
353 // edicts get reallocated on level changes, so we need to update it here
354 client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
356 // clear cached stuff that depends on the level
357 client->weaponmodel[0] = 0;
358 client->weaponmodelindex = 0;
360 // LordHavoc: clear entityframe tracking
361 client->latestframenum = 0;
363 if (client->entitydatabase)
364 EntityFrame_FreeDatabase(client->entitydatabase);
365 if (client->entitydatabase4)
366 EntityFrame4_FreeDatabase(client->entitydatabase4);
367 if (client->entitydatabase5)
368 EntityFrame5_FreeDatabase(client->entitydatabase5);
370 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)
372 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
373 client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
374 else if (sv.protocol == PROTOCOL_DARKPLACES4)
375 client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
377 client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
380 SZ_Clear (&client->netconnection->message);
381 MSG_WriteByte (&client->netconnection->message, svc_print);
382 dpsnprintf (message, sizeof (message), "\nServer: %s build %s (progs %i crc)", gamename, buildstring, prog->filecrc);
383 MSG_WriteString (&client->netconnection->message,message);
385 //[515]: init csprogs according to version of svprogs, check the crc, etc.
386 if (sv.csqc_progname[0])
389 Con_DPrintf("sending csqc info to client (\"%s\" with size %i and crc %i)\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
390 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
391 MSG_WriteString (&client->netconnection->message, va("csqc_progname %s\n", sv.csqc_progname));
392 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
393 MSG_WriteString (&client->netconnection->message, va("csqc_progsize %i\n", sv.csqc_progsize));
394 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
395 MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i\n", sv.csqc_progcrc));
396 //[515]: init stufftext string (it is sent before svc_serverinfo)
397 val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.SV_InitCmd);
400 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
401 MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(val->string)));
405 if (sv_allowdownloads.integer)
407 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
408 MSG_WriteString (&client->netconnection->message, "cl_serverextension_download 1");
411 // send at this time so it's guaranteed to get executed at the right time
415 host_client = client;
416 Curl_SendRequirements();
420 MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
421 MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
422 MSG_WriteByte (&client->netconnection->message, svs.maxclients);
424 if (!coop.integer && deathmatch.integer)
425 MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
427 MSG_WriteByte (&client->netconnection->message, GAME_COOP);
429 MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
431 for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
432 MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
433 MSG_WriteByte (&client->netconnection->message, 0);
435 for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
436 MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
437 MSG_WriteByte (&client->netconnection->message, 0);
440 MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
441 MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
442 MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
445 MSG_WriteByte (&client->netconnection->message, svc_setview);
446 MSG_WriteShort (&client->netconnection->message, PRVM_NUM_FOR_EDICT(client->edict));
448 MSG_WriteByte (&client->netconnection->message, svc_signonnum);
449 MSG_WriteByte (&client->netconnection->message, 1);
451 client->spawned = false; // need prespawn, spawn, etc
453 // clear movement info until client enters the new level properly
454 memset(&client->cmd, 0, sizeof(client->cmd));
455 client->movesequence = 0;
456 #ifdef NUM_PING_TIMES
457 for (i = 0;i < NUM_PING_TIMES;i++)
458 client->ping_times[i] = 0;
459 client->num_pings = 0;
468 Initializes a client_t for a new net connection. This will only be called
469 once for a player each game, not once for each level change.
472 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
476 float spawn_parms[NUM_SPAWN_PARMS];
478 client = svs.clients + clientnum;
480 if(netconnection)//[515]: bots don't play with csqc =)
481 EntityFrameCSQC_InitClientVersions(clientnum, false);
483 // set up the client_t
485 memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
486 memset (client, 0, sizeof(*client));
487 client->active = true;
488 client->netconnection = netconnection;
490 Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
492 strlcpy(client->name, "unconnected", sizeof(client->name));
493 strlcpy(client->old_name, "unconnected", sizeof(client->old_name));
494 client->spawned = false;
495 client->edict = PRVM_EDICT_NUM(clientnum+1);
496 if (client->netconnection)
497 client->netconnection->message.allowoverflow = true; // we can catch it
498 // updated by receiving "rate" command from client
499 client->rate = NET_MINRATE;
500 // no limits for local player
501 if (client->netconnection && LHNETADDRESS_GetAddressType(&client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP)
502 client->rate = 1000000000;
503 client->connecttime = realtime;
506 memcpy (client->spawn_parms, spawn_parms, sizeof(spawn_parms));
509 // call the progs to get default spawn parms for the new client
510 // set self to world to intentionally cause errors with broken SetNewParms code in some mods
511 prog->globals.server->self = 0;
512 PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
513 for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
514 client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
516 // set up the entity for this client (including .colormap, .team, etc)
517 PRVM_ED_ClearEdict(client->edict);
520 // don't call SendServerinfo for a fresh botclient because its fields have
521 // not been set up by the qc yet
522 if (client->netconnection)
523 SV_SendServerinfo (client);
525 client->spawned = true;
530 ===============================================================================
534 ===============================================================================
543 void SV_ClearDatagram (void)
545 SZ_Clear (&sv.datagram);
549 =============================================================================
551 The PVS must include a small area around the client to allow head bobbing
552 or other small motion on the client side. Otherwise, a bob might cause an
553 entity that should be visible to not show up, especially when the bob
556 =============================================================================
559 int sv_writeentitiestoclient_pvsbytes;
560 unsigned char sv_writeentitiestoclient_pvs[MAX_MAP_LEAFS/8];
562 static int numsendentities;
563 static entity_state_t sendentities[MAX_EDICTS];
564 static entity_state_t *sendentitiesindex[MAX_EDICTS];
566 qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int e)
569 unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
570 unsigned int customizeentityforclient;
572 vec3_t cullmins, cullmaxs;
576 // EF_NODRAW prevents sending for any reason except for your own
577 // client, so we must keep all clients in this superset
578 effects = (unsigned)ent->fields.server->effects;
580 // we can omit invisible entities with no effects that are not clients
581 // LordHavoc: this could kill tags attached to an invisible entity, I
582 // just hope we never have to support that case
583 i = (int)ent->fields.server->modelindex;
584 modelindex = (i >= 1 && i < MAX_MODELS && *PRVM_GetString(ent->fields.server->model)) ? i : 0;
587 i = (int)(PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_size)->_float * 0.25f);
588 glowsize = (unsigned char)bound(0, i, 255);
589 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_trail)->_float)
590 flags |= RENDER_GLOWTRAIL;
592 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[0]*256;
593 light[0] = (unsigned short)bound(0, f, 65535);
594 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[1]*256;
595 light[1] = (unsigned short)bound(0, f, 65535);
596 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.color)->vector[2]*256;
597 light[2] = (unsigned short)bound(0, f, 65535);
598 f = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.light_lev)->_float;
599 light[3] = (unsigned short)bound(0, f, 65535);
600 lightstyle = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.style)->_float;
601 lightpflags = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.pflags)->_float;
603 if (gamemode == GAME_TENEBRAE)
605 // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
609 lightpflags |= PFLAGS_FULLDYNAMIC;
611 // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
615 light[0] = (int)(0.2*256);
616 light[1] = (int)(1.0*256);
617 light[2] = (int)(0.2*256);
619 lightpflags |= PFLAGS_FULLDYNAMIC;
623 specialvisibilityradius = 0;
624 if (lightpflags & PFLAGS_FULLDYNAMIC)
625 specialvisibilityradius = max(specialvisibilityradius, light[3]);
627 specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
628 if (flags & RENDER_GLOWTRAIL)
629 specialvisibilityradius = max(specialvisibilityradius, 100);
630 if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
632 if (effects & EF_BRIGHTFIELD)
633 specialvisibilityradius = max(specialvisibilityradius, 80);
634 if (effects & EF_MUZZLEFLASH)
635 specialvisibilityradius = max(specialvisibilityradius, 100);
636 if (effects & EF_BRIGHTLIGHT)
637 specialvisibilityradius = max(specialvisibilityradius, 400);
638 if (effects & EF_DIMLIGHT)
639 specialvisibilityradius = max(specialvisibilityradius, 200);
640 if (effects & EF_RED)
641 specialvisibilityradius = max(specialvisibilityradius, 200);
642 if (effects & EF_BLUE)
643 specialvisibilityradius = max(specialvisibilityradius, 200);
644 if (effects & EF_FLAME)
645 specialvisibilityradius = max(specialvisibilityradius, 250);
646 if (effects & EF_STARDUST)
647 specialvisibilityradius = max(specialvisibilityradius, 100);
650 // early culling checks
651 // (final culling is done by SV_MarkWriteEntityStateToClient)
652 customizeentityforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.customizeentityforclient)->function;
653 if (!customizeentityforclient)
655 if (e > svs.maxclients && (!modelindex && !specialvisibilityradius))
657 // this 2 billion unit check is actually to detect NAN origins
658 // (we really don't want to send those)
659 if (VectorLength2(ent->fields.server->origin) > 2000000000.0*2000000000.0)
667 VectorCopy(ent->fields.server->origin, cs->origin);
668 VectorCopy(ent->fields.server->angles, cs->angles);
670 cs->effects = effects;
671 cs->colormap = (unsigned)ent->fields.server->colormap;
672 cs->modelindex = modelindex;
673 cs->skin = (unsigned)ent->fields.server->skin;
674 cs->frame = (unsigned)ent->fields.server->frame;
675 cs->viewmodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewmodelforclient)->edict;
676 cs->exteriormodelforclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.exteriormodeltoclient)->edict;
677 cs->nodrawtoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.nodrawtoclient)->edict;
678 cs->drawonlytoclient = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.drawonlytoclient)->edict;
679 cs->customizeentityforclient = customizeentityforclient;
680 cs->tagentity = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)->edict;
681 cs->tagindex = (unsigned char)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
682 cs->glowsize = glowsize;
684 // don't need to init cs->colormod because the defaultstate did that for us
685 //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
686 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod);
687 if (val->vector[0] || val->vector[1] || val->vector[2])
689 i = (int)(val->vector[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
690 i = (int)(val->vector[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
691 i = (int)(val->vector[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
694 cs->modelindex = modelindex;
697 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)->_float * 255.0f);
701 cs->alpha = (unsigned char)bound(0, i, 255);
704 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderamt)->_float);
708 cs->alpha = (unsigned char)bound(0, i, 255);
712 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)->_float * 16.0f);
716 cs->scale = (unsigned char)bound(0, i, 255);
720 f = (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glow_color)->_float);
722 cs->glowcolor = (int)f;
724 if (PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.fullbright)->_float)
725 cs->effects |= EF_FULLBRIGHT;
727 if (ent->fields.server->movetype == MOVETYPE_STEP)
728 cs->flags |= RENDER_STEP;
729 if ((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)
730 cs->flags |= RENDER_LOWPRECISION;
731 if (ent->fields.server->colormap >= 1024)
732 cs->flags |= RENDER_COLORMAPPED;
733 if (cs->viewmodelforclient)
734 cs->flags |= RENDER_VIEWMODEL; // show relative to the view
736 cs->light[0] = light[0];
737 cs->light[1] = light[1];
738 cs->light[2] = light[2];
739 cs->light[3] = light[3];
740 cs->lightstyle = lightstyle;
741 cs->lightpflags = lightpflags;
743 cs->specialvisibilityradius = specialvisibilityradius;
745 // calculate the visible box of this entity (don't use the physics box
746 // as that is often smaller than a model, and would not count
747 // specialvisibilityradius)
748 if ((model = sv.models[modelindex]))
750 float scale = cs->scale * (1.0f / 16.0f);
751 if (cs->angles[0] || cs->angles[2]) // pitch and roll
753 VectorMA(cs->origin, scale, model->rotatedmins, cullmins);
754 VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs);
756 else if (cs->angles[1])
758 VectorMA(cs->origin, scale, model->yawmins, cullmins);
759 VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs);
763 VectorMA(cs->origin, scale, model->normalmins, cullmins);
764 VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs);
769 // if there is no model (or it could not be loaded), use the physics box
770 VectorAdd(cs->origin, ent->fields.server->mins, cullmins);
771 VectorAdd(cs->origin, ent->fields.server->maxs, cullmaxs);
773 if (specialvisibilityradius)
775 cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius);
776 cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius);
777 cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius);
778 cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius);
779 cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius);
780 cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius);
782 // calculate center of bbox for network prioritization purposes
783 VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, cs->netcenter);
784 // if culling box has moved, update pvs cluster links
785 if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
787 VectorCopy(cullmins, ent->priv.server->cullmins);
788 VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
789 // a value of -1 for pvs_numclusters indicates that the links are not
790 // cached, and should be re-tested each time, this is the case if the
791 // culling box touches too many pvs clusters to store, or if the world
792 // model does not support FindBoxClusters
793 ent->priv.server->pvs_numclusters = -1;
794 if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
796 i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
797 if (i <= MAX_ENTITYCLUSTERS)
798 ent->priv.server->pvs_numclusters = i;
805 void SV_PrepareEntitiesForSending(void)
809 // send all entities that touch the pvs
811 sendentitiesindex[0] = NULL;
812 memset(sendentitiesindex, 0, prog->num_edicts * sizeof(entity_state_t *));
813 for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent))
815 if (!ent->priv.server->free && SV_PrepareEntityForSending(ent, sendentities + numsendentities, e))
817 sendentitiesindex[e] = sendentities + numsendentities;
823 static int sententitiesmark = 0;
824 static int sententities[MAX_EDICTS];
825 static int sententitiesconsideration[MAX_EDICTS];
826 static int sv_writeentitiestoclient_culled_pvs;
827 static int sv_writeentitiestoclient_culled_trace;
828 static int sv_writeentitiestoclient_visibleentities;
829 static int sv_writeentitiestoclient_totalentities;
830 //static entity_frame_t sv_writeentitiestoclient_entityframe;
831 static int sv_writeentitiestoclient_clentnum;
832 static vec3_t sv_writeentitiestoclient_testeye;
833 static client_t *sv_writeentitiestoclient_client;
835 void SV_MarkWriteEntityStateToClient(entity_state_t *s)
840 if (sententitiesconsideration[s->number] == sententitiesmark)
842 sententitiesconsideration[s->number] = sententitiesmark;
843 sv_writeentitiestoclient_totalentities++;
845 if (s->customizeentityforclient)
847 prog->globals.server->self = s->number;
848 prog->globals.server->other = sv_writeentitiestoclient_clentnum;
849 PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
850 if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
854 // never reject player
855 if (s->number != sv_writeentitiestoclient_clentnum)
857 // check various rejection conditions
858 if (s->nodrawtoclient == sv_writeentitiestoclient_clentnum)
860 if (s->drawonlytoclient && s->drawonlytoclient != sv_writeentitiestoclient_clentnum)
862 if (s->effects & EF_NODRAW)
864 // LordHavoc: only send entities with a model or important effects
865 if (!s->modelindex && s->specialvisibilityradius == 0)
868 isbmodel = (model = sv.models[s->modelindex]) != NULL && model->name[0] == '*';
869 // viewmodels don't have visibility checking
870 if (s->viewmodelforclient)
872 if (s->viewmodelforclient != sv_writeentitiestoclient_clentnum)
875 else if (s->tagentity)
877 // tag attached entities simply check their parent
878 if (!sendentitiesindex[s->tagentity])
880 SV_MarkWriteEntityStateToClient(sendentitiesindex[s->tagentity]);
881 if (sententities[s->tagentity] != sententitiesmark)
884 // always send world submodels in newer protocols because they don't
885 // generate much traffic (in old protocols they hog bandwidth)
886 // but only if sv_cullentities_alwayssendbmodels is on
887 else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE))
889 // entity has survived every check so far, check if visible
890 ed = PRVM_EDICT_NUM(s->number);
892 // if not touching a visible leaf
893 if (sv_cullentities_pvs.integer && sv_writeentitiestoclient_pvsbytes)
895 if (ed->priv.server->pvs_numclusters < 0)
897 // entity too big for clusters list
898 if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv_writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
900 sv_writeentitiestoclient_culled_pvs++;
907 // check cached clusters list
908 for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
909 if (CHECKPVSBIT(sv_writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
911 if (i == ed->priv.server->pvs_numclusters)
913 sv_writeentitiestoclient_culled_pvs++;
919 // or not seen by random tracelines
920 if (sv_cullentities_trace.integer && !isbmodel)
922 int samples = s->specialvisibilityradius ? sv_cullentities_trace_samples_extra.integer : sv_cullentities_trace_samples.integer;
923 float enlarge = sv_cullentities_trace_enlarge.value;
925 qboolean visible = TRUE;
929 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, sv_writeentitiestoclient_testeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
930 break; // directly visible from the server's view
932 if(sv_cullentities_trace_prediction.integer)
936 // get player velocity
937 float predtime = bound(0, host_client->ping, 0.2); // / 2
938 // sorry, no wallhacking by high ping please, and at 200ms
939 // ping a FPS is annoying to play anyway and a player is
940 // likely to have changed his direction
941 VectorMA(sv_writeentitiestoclient_testeye, predtime, host_client->edict->fields.server->velocity, predeye);
942 if(sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, sv_writeentitiestoclient_testeye, predeye)) // must be able to go there...
944 if(Mod_CanSeeBox_Trace(samples, enlarge, sv.worldmodel, predeye, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
945 break; // directly visible from the predicted view
949 //Con_DPrintf("Trying to walk into solid in a pingtime... not predicting for culling\n");
953 // when we get here, we can't see the entity
959 sv_writeentitiestoclient_client->visibletime[s->number] = realtime + sv_cullentities_trace_delay.value;
961 if (realtime > sv_writeentitiestoclient_client->visibletime[s->number])
963 sv_writeentitiestoclient_culled_trace++;
970 // this just marks it for sending
971 // FIXME: it would be more efficient to send here, but the entity
972 // compressor isn't that flexible
973 sv_writeentitiestoclient_visibleentities++;
974 sententities[s->number] = sententitiesmark;
977 entity_state_t sendstates[MAX_EDICTS];
978 extern int csqc_clientnum;
980 void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int *stats)
982 int i, numsendstates;
985 // if there isn't enough space to accomplish anything, skip it
986 if (msg->cursize + 25 > msg->maxsize)
989 sv_writeentitiestoclient_client = client;
991 sv_writeentitiestoclient_culled_pvs = 0;
992 sv_writeentitiestoclient_culled_trace = 0;
993 sv_writeentitiestoclient_visibleentities = 0;
994 sv_writeentitiestoclient_totalentities = 0;
996 // find the client's PVS
997 // the real place being tested from
998 VectorAdd(clent->fields.server->origin, clent->fields.server->view_ofs, sv_writeentitiestoclient_testeye);
999 sv_writeentitiestoclient_pvsbytes = 0;
1000 if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
1001 sv_writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv_writeentitiestoclient_testeye, 8, sv_writeentitiestoclient_pvs, sizeof(sv_writeentitiestoclient_pvs));
1003 sv_writeentitiestoclient_clentnum = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
1004 csqc_clientnum = sv_writeentitiestoclient_clentnum - 1;
1008 for (i = 0;i < numsendentities;i++)
1009 SV_MarkWriteEntityStateToClient(sendentities + i);
1012 for (i = 0;i < numsendentities;i++)
1014 if (sententities[sendentities[i].number] == sententitiesmark)
1016 s = &sendstates[numsendstates++];
1017 *s = sendentities[i];
1018 if (s->exteriormodelforclient && s->exteriormodelforclient == sv_writeentitiestoclient_clentnum)
1019 s->flags |= RENDER_EXTERIORMODEL;
1023 if (sv_cullentities_stats.integer)
1024 Con_Printf("client \"%s\" entities: %d total, %d visible, %d culled by: %d pvs %d trace\n", client->name, sv_writeentitiestoclient_totalentities, sv_writeentitiestoclient_visibleentities, sv_writeentitiestoclient_culled_pvs + sv_writeentitiestoclient_culled_trace, sv_writeentitiestoclient_culled_pvs, sv_writeentitiestoclient_culled_trace);
1026 EntityFrameCSQC_WriteFrame(msg, numsendstates, sendstates);
1028 if (client->entitydatabase5)
1029 EntityFrame5_WriteFrame(msg, client->entitydatabase5, numsendstates, sendstates, client - svs.clients + 1, stats, client->movesequence);
1030 else if (client->entitydatabase4)
1031 EntityFrame4_WriteFrame(msg, client->entitydatabase4, numsendstates, sendstates);
1032 else if (client->entitydatabase)
1033 EntityFrame_WriteFrame(msg, client->entitydatabase, numsendstates, sendstates, client - svs.clients + 1);
1035 EntityFrameQuake_WriteFrame(msg, numsendstates, sendstates);
1044 void SV_CleanupEnts (void)
1049 ent = PRVM_NEXT_EDICT(prog->edicts);
1050 for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
1051 ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
1056 SV_WriteClientdataToMessage
1060 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1064 prvm_edict_t *other;
1072 // send a damage message
1074 if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
1076 other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
1077 MSG_WriteByte (msg, svc_damage);
1078 MSG_WriteByte (msg, (int)ent->fields.server->dmg_save);
1079 MSG_WriteByte (msg, (int)ent->fields.server->dmg_take);
1080 for (i=0 ; i<3 ; i++)
1081 MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
1083 ent->fields.server->dmg_take = 0;
1084 ent->fields.server->dmg_save = 0;
1088 // send the current viewpos offset from the view entity
1090 SV_SetIdealPitch (); // how much to look up / down ideally
1092 // a fixangle might get lost in a dropped packet. Oh well.
1093 if(ent->fields.server->fixangle)
1095 // angle fixing was requested by global thinking code...
1096 // so store the current angles for later use
1097 memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
1098 host_client->fixangle_angles_set = TRUE;
1100 // and clear fixangle for the next frame
1101 ent->fields.server->fixangle = 0;
1104 if (host_client->fixangle_angles_set)
1106 MSG_WriteByte (msg, svc_setangle);
1107 for (i=0 ; i < 3 ; i++)
1108 MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
1109 host_client->fixangle_angles_set = FALSE;
1112 // stuff the sigil bits into the high bits of items for sbar, or else
1114 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.items2);
1115 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1116 items = (int)ent->fields.server->items | ((int)val->_float << 23);
1118 items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
1120 VectorClear(punchvector);
1121 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.punchvector)))
1122 VectorCopy(val->vector, punchvector);
1124 // cache weapon model name and index in client struct to save time
1125 // (this search can be almost 1% of cpu time!)
1126 s = PRVM_GetString(ent->fields.server->weaponmodel);
1127 if (strcmp(s, client->weaponmodel))
1129 strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
1130 client->weaponmodelindex = SV_ModelIndex(s, 1);
1134 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.viewzoom)))
1135 viewzoom = (int)(val->_float * 255.0f);
1141 if ((int)ent->fields.server->flags & FL_ONGROUND)
1142 bits |= SU_ONGROUND;
1143 if (ent->fields.server->waterlevel >= 2)
1145 if (ent->fields.server->idealpitch)
1146 bits |= SU_IDEALPITCH;
1148 for (i=0 ; i<3 ; i++)
1150 if (ent->fields.server->punchangle[i])
1151 bits |= (SU_PUNCH1<<i);
1152 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)
1154 bits |= (SU_PUNCHVEC1<<i);
1155 if (ent->fields.server->velocity[i])
1156 bits |= (SU_VELOCITY1<<i);
1159 memset(stats, 0, sizeof(int[MAX_CL_STATS]));
1160 stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];
1161 stats[STAT_ITEMS] = items;
1162 stats[STAT_WEAPONFRAME] = (int)ent->fields.server->weaponframe;
1163 stats[STAT_ARMOR] = (int)ent->fields.server->armorvalue;
1164 stats[STAT_WEAPON] = client->weaponmodelindex;
1165 stats[STAT_HEALTH] = (int)ent->fields.server->health;
1166 stats[STAT_AMMO] = (int)ent->fields.server->currentammo;
1167 stats[STAT_SHELLS] = (int)ent->fields.server->ammo_shells;
1168 stats[STAT_NAILS] = (int)ent->fields.server->ammo_nails;
1169 stats[STAT_ROCKETS] = (int)ent->fields.server->ammo_rockets;
1170 stats[STAT_CELLS] = (int)ent->fields.server->ammo_cells;
1171 stats[STAT_ACTIVEWEAPON] = (int)ent->fields.server->weapon;
1172 stats[STAT_VIEWZOOM] = viewzoom;
1173 stats[STAT_TOTALSECRETS] = prog->globals.server->total_secrets;
1174 stats[STAT_TOTALMONSTERS] = prog->globals.server->total_monsters;
1175 // the QC bumps these itself by sending svc_'s, so we have to keep them
1176 // zero or they'll be corrected by the engine
1177 //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
1178 //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
1180 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1182 if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
1184 if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
1185 if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
1187 // FIXME: which protocols support this? does PROTOCOL_DARKPLACES3 support viewzoom?
1188 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1189 if (viewzoom != 255)
1190 bits |= SU_VIEWZOOM;
1195 if (bits >= 16777216)
1199 MSG_WriteByte (msg, svc_clientdata);
1200 MSG_WriteShort (msg, bits);
1201 if (bits & SU_EXTEND1)
1202 MSG_WriteByte(msg, bits >> 16);
1203 if (bits & SU_EXTEND2)
1204 MSG_WriteByte(msg, bits >> 24);
1206 if (bits & SU_VIEWHEIGHT)
1207 MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
1209 if (bits & SU_IDEALPITCH)
1210 MSG_WriteChar (msg, (int)ent->fields.server->idealpitch);
1212 for (i=0 ; i<3 ; i++)
1214 if (bits & (SU_PUNCH1<<i))
1216 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
1217 MSG_WriteChar(msg, (int)ent->fields.server->punchangle[i]);
1219 MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
1221 if (bits & (SU_PUNCHVEC1<<i))
1223 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1224 MSG_WriteCoord16i(msg, punchvector[i]);
1226 MSG_WriteCoord32f(msg, punchvector[i]);
1228 if (bits & (SU_VELOCITY1<<i))
1230 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1231 MSG_WriteChar(msg, (int)(ent->fields.server->velocity[i] * (1.0f / 16.0f)));
1233 MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
1237 if (bits & SU_ITEMS)
1238 MSG_WriteLong (msg, stats[STAT_ITEMS]);
1240 if (sv.protocol == PROTOCOL_DARKPLACES5)
1242 if (bits & SU_WEAPONFRAME)
1243 MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
1244 if (bits & SU_ARMOR)
1245 MSG_WriteShort (msg, stats[STAT_ARMOR]);
1246 if (bits & SU_WEAPON)
1247 MSG_WriteShort (msg, stats[STAT_WEAPON]);
1248 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1249 MSG_WriteShort (msg, stats[STAT_AMMO]);
1250 MSG_WriteShort (msg, stats[STAT_SHELLS]);
1251 MSG_WriteShort (msg, stats[STAT_NAILS]);
1252 MSG_WriteShort (msg, stats[STAT_ROCKETS]);
1253 MSG_WriteShort (msg, stats[STAT_CELLS]);
1254 MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
1255 if (bits & SU_VIEWZOOM)
1256 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1258 else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1260 if (bits & SU_WEAPONFRAME)
1261 MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
1262 if (bits & SU_ARMOR)
1263 MSG_WriteByte (msg, stats[STAT_ARMOR]);
1264 if (bits & SU_WEAPON)
1265 MSG_WriteByte (msg, stats[STAT_WEAPON]);
1266 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1267 MSG_WriteByte (msg, stats[STAT_AMMO]);
1268 MSG_WriteByte (msg, stats[STAT_SHELLS]);
1269 MSG_WriteByte (msg, stats[STAT_NAILS]);
1270 MSG_WriteByte (msg, stats[STAT_ROCKETS]);
1271 MSG_WriteByte (msg, stats[STAT_CELLS]);
1272 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
1274 for (i = 0;i < 32;i++)
1275 if (stats[STAT_WEAPON] & (1<<i))
1277 MSG_WriteByte (msg, i);
1280 MSG_WriteByte (msg, stats[STAT_WEAPON]);
1281 if (bits & SU_VIEWZOOM)
1283 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1284 MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
1286 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1292 =======================
1293 SV_SendClientDatagram
1294 =======================
1296 static unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE]; // FIXME?
1297 void SV_SendClientDatagram (client_t *client)
1299 int rate, maxrate, maxsize, maxsize2, downloadsize;
1301 int stats[MAX_CL_STATS];
1303 if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !sv_ratelimitlocalplayer.integer)
1305 // for good singleplayer, send huge packets
1306 maxsize = sizeof(sv_sendclientdatagram_buf);
1307 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1309 else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1311 // no rate limiting support on older protocols because dp protocols
1312 // 1-4 kick the client off if they overflow, and quake protocol shows
1313 // less than the full entity set if rate limited
1319 // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
1320 maxrate = max(NET_MINRATE, sv_maxrate.integer);
1321 if (sv_maxrate.integer != maxrate)
1322 Cvar_SetValueQuick(&sv_maxrate, maxrate);
1324 // this rate limiting does not understand sys_ticrate 0
1325 // (but no one should be running that on a server!)
1326 rate = bound(NET_MINRATE, client->rate, maxrate);
1327 rate = (int)(rate * sys_ticrate.value);
1328 maxsize = bound(50, rate, 1400);
1332 // while downloading, limit entity updates to half the packet
1333 // (any leftover space will be used for downloading)
1334 if (host_client->download_file)
1337 msg.data = sv_sendclientdatagram_buf;
1338 msg.maxsize = maxsize;
1341 if (host_client->spawned)
1343 MSG_WriteByte (&msg, svc_time);
1344 MSG_WriteFloat (&msg, sv.time);
1346 // add the client specific data to the datagram
1347 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
1348 VM_SV_WriteAutoSentStats (client, client->edict, &msg, stats);
1349 SV_WriteEntitiesToClient (client, client->edict, &msg, stats);
1351 // expand packet size to allow effects to go over the rate limit
1352 // (dropping them is FAR too ugly)
1353 msg.maxsize = maxsize2;
1355 // copy the server datagram if there is space
1356 // FIXME: put in delayed queue of effects to send
1357 if (sv.datagram.cursize > 0 && msg.cursize + sv.datagram.cursize <= msg.maxsize)
1358 SZ_Write (&msg, sv.datagram.data, sv.datagram.cursize);
1360 else if (realtime > client->keepalivetime)
1362 // the player isn't totally in the game yet
1363 // send small keepalive messages if too much time has passed
1364 msg.maxsize = maxsize2;
1365 client->keepalivetime = realtime + 5;
1366 MSG_WriteChar (&msg, svc_nop);
1369 msg.maxsize = maxsize2;
1371 // if a download is active, see if there is room to fit some download data
1373 downloadsize = maxsize * 2 - msg.cursize - 7;
1374 if (host_client->download_file && host_client->download_started && downloadsize > 0)
1376 fs_offset_t downloadstart;
1377 unsigned char data[1400];
1378 downloadstart = FS_Tell(host_client->download_file);
1379 downloadsize = min(downloadsize, (int)sizeof(data));
1380 downloadsize = FS_Read(host_client->download_file, data, downloadsize);
1381 // note this sends empty messages if at the end of the file, which is
1382 // necessary to keep the packet loss logic working
1383 // (the last blocks may be lost and need to be re-sent, and that will
1384 // only occur if the client acks the empty end messages, revealing
1385 // a gap in the download progress, causing the last blocks to be
1387 MSG_WriteChar (&msg, svc_downloaddata);
1388 MSG_WriteLong (&msg, downloadstart);
1389 MSG_WriteShort (&msg, downloadsize);
1390 if (downloadsize > 0)
1391 SZ_Write (&msg, data, downloadsize);
1394 // send the datagram
1395 NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol);
1399 =======================
1400 SV_UpdateToReliableMessages
1401 =======================
1403 void SV_UpdateToReliableMessages (void)
1412 // check for changes to be sent over the reliable streams
1413 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1415 // update the host_client fields we care about according to the entity fields
1416 host_client->edict = PRVM_EDICT_NUM(i+1);
1419 name = PRVM_GetString(host_client->edict->fields.server->netname);
1422 // always point the string back at host_client->name to keep it safe
1423 strlcpy (host_client->name, name, sizeof (host_client->name));
1424 host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
1425 if (strcmp(host_client->old_name, host_client->name))
1427 if (host_client->spawned)
1428 SV_BroadcastPrintf("%s changed name to %s\n", host_client->old_name, host_client->name);
1429 strlcpy(host_client->old_name, host_client->name, sizeof(host_client->old_name));
1430 // send notification to all clients
1431 MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
1432 MSG_WriteByte (&sv.reliable_datagram, i);
1433 MSG_WriteString (&sv.reliable_datagram, host_client->name);
1436 // DP_SV_CLIENTCOLORS
1437 // this is always found (since it's added by the progs loader)
1438 if ((val = PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.clientcolors)))
1439 host_client->colors = (int)val->_float;
1440 if (host_client->old_colors != host_client->colors)
1442 host_client->old_colors = host_client->colors;
1443 // send notification to all clients
1444 MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1445 MSG_WriteByte (&sv.reliable_datagram, i);
1446 MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1449 // NEXUIZ_PLAYERMODEL
1450 if( prog->fieldoffsets.playermodel >= 0 ) {
1451 model = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string);
1454 // always point the string back at host_client->name to keep it safe
1455 strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
1456 PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
1459 // NEXUIZ_PLAYERSKIN
1460 if( prog->fieldoffsets.playerskin >= 0 ) {
1461 skin = PRVM_GetString(PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string);
1464 // always point the string back at host_client->name to keep it safe
1465 strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
1466 PRVM_EDICTFIELDVALUE(host_client->edict, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
1470 host_client->frags = (int)host_client->edict->fields.server->frags;
1471 if (host_client->old_frags != host_client->frags)
1473 host_client->old_frags = host_client->frags;
1474 // send notification to all clients
1475 MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
1476 MSG_WriteByte (&sv.reliable_datagram, i);
1477 MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
1481 for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1482 if (client->netconnection)
1483 SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
1485 SZ_Clear (&sv.reliable_datagram);
1490 =======================
1491 SV_SendClientMessages
1492 =======================
1494 void SV_SendClientMessages (void)
1496 int i, prepared = false;
1498 if (sv.protocol == PROTOCOL_QUAKEWORLD)
1499 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
1501 // update frags, names, etc
1502 SV_UpdateToReliableMessages();
1504 // build individual updates
1505 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1507 if (!host_client->active)
1509 if (!host_client->netconnection)
1512 if (host_client->netconnection->message.overflowed)
1514 SV_DropClient (true); // if the message couldn't send, kick off
1521 // only prepare entities once per frame
1522 SV_PrepareEntitiesForSending();
1524 SV_SendClientDatagram (host_client);
1527 // clear muzzle flashes
1531 void SV_StartDownload_f(void)
1533 if (host_client->download_file)
1534 host_client->download_started = true;
1537 void SV_Download_f(void)
1539 const char *whichpack, *whichpack2, *extension;
1541 if (Cmd_Argc() != 2)
1543 SV_ClientPrintf("usage: download <filename>\n");
1547 if (FS_CheckNastyPath(Cmd_Argv(1), false))
1549 SV_ClientPrintf("Download rejected: nasty filename \"%s\"\n", Cmd_Argv(1));
1553 if (host_client->download_file)
1555 // at this point we'll assume the previous download should be aborted
1556 Con_DPrintf("Download of %s aborted by %s starting a new download\n", host_client->download_name, host_client->name);
1557 Host_ClientCommands("\nstopdownload\n");
1559 // close the file and reset variables
1560 FS_Close(host_client->download_file);
1561 host_client->download_file = NULL;
1562 host_client->download_name[0] = 0;
1563 host_client->download_expectedposition = 0;
1564 host_client->download_started = false;
1567 if (!sv_allowdownloads.integer)
1569 SV_ClientPrintf("Downloads are disabled on this server\n");
1570 Host_ClientCommands("\nstopdownload\n");
1574 strlcpy(host_client->download_name, Cmd_Argv(1), sizeof(host_client->download_name));
1575 extension = FS_FileExtension(host_client->download_name);
1577 // host_client is asking to download a specified file
1578 if (developer.integer >= 100)
1579 Con_Printf("Download request for %s by %s\n", host_client->download_name, host_client->name);
1581 if (!FS_FileExists(host_client->download_name))
1583 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);
1584 Host_ClientCommands("\nstopdownload\n");
1588 // check if the user is trying to download part of registered Quake(r)
1589 whichpack = FS_WhichPack(host_client->download_name);
1590 whichpack2 = FS_WhichPack("gfx/pop.lmp");
1591 if ((whichpack && whichpack2 && !strcasecmp(whichpack, whichpack2)) || FS_IsRegisteredQuakePack(host_client->download_name))
1593 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);
1594 Host_ClientCommands("\nstopdownload\n");
1598 // check if the server has forbidden archive downloads entirely
1599 if (!sv_allowdownloads_inarchive.integer)
1601 whichpack = FS_WhichPack(host_client->download_name);
1604 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);
1605 Host_ClientCommands("\nstopdownload\n");
1610 if (!sv_allowdownloads_config.integer)
1612 if (!strcasecmp(extension, "cfg"))
1614 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);
1615 Host_ClientCommands("\nstopdownload\n");
1620 if (!sv_allowdownloads_dlcache.integer)
1622 if (!strncasecmp(host_client->download_name, "dlcache/", 8))
1624 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);
1625 Host_ClientCommands("\nstopdownload\n");
1630 if (!sv_allowdownloads_archive.integer)
1632 if (!strcasecmp(extension, "pak") || !strcasecmp(extension, "pk3"))
1634 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);
1635 Host_ClientCommands("\nstopdownload\n");
1640 host_client->download_file = FS_Open(host_client->download_name, "rb", true, false);
1641 if (!host_client->download_file)
1643 SV_ClientPrintf("Download rejected: server could not open the file \"%s\"\n", host_client->download_name);
1644 Host_ClientCommands("\nstopdownload\n");
1648 if (FS_FileSize(host_client->download_file) > 1<<30)
1650 SV_ClientPrintf("Download rejected: file \"%s\" is very large\n", host_client->download_name);
1651 Host_ClientCommands("\nstopdownload\n");
1652 FS_Close(host_client->download_file);
1653 host_client->download_file = NULL;
1657 Con_DPrintf("Downloading %s to %s\n", host_client->download_name, host_client->name);
1659 Host_ClientCommands("\ncl_downloadbegin %i %s\n", (int)FS_FileSize(host_client->download_file), host_client->download_name);
1661 host_client->download_expectedposition = 0;
1662 host_client->download_started = false;
1664 // the rest of the download process is handled in SV_SendClientDatagram
1665 // and other code dealing with svc_downloaddata and clc_ackdownloaddata
1667 // no svc_downloaddata messages will be sent until sv_startdownload is
1668 // sent by the client
1672 ==============================================================================
1676 ==============================================================================
1685 int SV_ModelIndex(const char *s, int precachemode)
1687 int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_MODELS);
1688 char filename[MAX_QPATH];
1692 //if (precachemode == 2)
1694 strlcpy(filename, s, sizeof(filename));
1695 for (i = 2;i < limit;i++)
1697 if (!sv.model_precache[i][0])
1701 if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
1703 Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
1706 if (precachemode == 1)
1707 Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
1708 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
1709 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, false);
1710 if (sv.state != ss_loading)
1712 MSG_WriteByte(&sv.reliable_datagram, svc_precache);
1713 MSG_WriteShort(&sv.reliable_datagram, i);
1714 MSG_WriteString(&sv.reliable_datagram, filename);
1718 Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
1721 if (!strcmp(sv.model_precache[i], filename))
1724 Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
1734 int SV_SoundIndex(const char *s, int precachemode)
1736 int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_SOUNDS);
1737 char filename[MAX_QPATH];
1741 //if (precachemode == 2)
1743 strlcpy(filename, s, sizeof(filename));
1744 for (i = 1;i < limit;i++)
1746 if (!sv.sound_precache[i][0])
1750 if (sv.state != ss_loading && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5))
1752 Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
1755 if (precachemode == 1)
1756 Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
1757 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
1758 if (sv.state != ss_loading)
1760 MSG_WriteByte(&sv.reliable_datagram, svc_precache);
1761 MSG_WriteShort(&sv.reliable_datagram, i + 32768);
1762 MSG_WriteString(&sv.reliable_datagram, filename);
1766 Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
1769 if (!strcmp(sv.sound_precache[i], filename))
1772 Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
1776 // MUST match effectnameindex_t in client.h
1777 static const char *standardeffectnames[EFFECT_TOTAL] =
1785 "TE_SUPERSPIKEQUAD",
1801 "TE_TEI_BIGEXPLOSION",
1819 SV_ParticleEffectIndex
1823 int SV_ParticleEffectIndex(const char *name)
1825 int i, argc, linenumber, effectnameindex;
1826 fs_offset_t filesize;
1827 unsigned char *filedata;
1828 const char *text, *textstart, *textend;
1829 char argv[16][1024];
1830 if (!sv.particleeffectnamesloaded)
1832 sv.particleeffectnamesloaded = true;
1833 memset(sv.particleeffectname, 0, sizeof(sv.particleeffectname));
1834 for (i = 0;i < EFFECT_TOTAL;i++)
1835 strlcpy(sv.particleeffectname[i], standardeffectnames[i], sizeof(sv.particleeffectname[i]));
1836 filedata = FS_LoadFile("effectinfo.txt", tempmempool, true, &filesize);
1839 textstart = (const char *)filedata;
1840 textend = (const char *)filedata + filesize;
1842 for (linenumber = 1;;linenumber++)
1847 if (!COM_ParseToken(&text, true) || !strcmp(com_token, "\n"))
1851 strlcpy(argv[argc], com_token, sizeof(argv[argc]));
1855 if (com_token[0] == 0)
1856 break; // if the loop exited and it's not a \n, it's EOF
1859 if (!strcmp(argv[0], "effect"))
1863 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME;effectnameindex++)
1865 if (sv.particleeffectname[effectnameindex][0])
1867 if (!strcmp(sv.particleeffectname[effectnameindex], argv[1]))
1872 strlcpy(sv.particleeffectname[effectnameindex], argv[1], sizeof(sv.particleeffectname[effectnameindex]));
1876 // if we run out of names, abort
1877 if (effectnameindex == SV_MAX_PARTICLEEFFECTNAME)
1879 Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
1888 // search for the name
1889 for (effectnameindex = 1;effectnameindex < SV_MAX_PARTICLEEFFECTNAME && sv.particleeffectname[effectnameindex][0];effectnameindex++)
1890 if (!strcmp(sv.particleeffectname[effectnameindex], name))
1891 return effectnameindex;
1892 // return 0 if we couldn't find it
1902 void SV_CreateBaseline (void)
1904 int i, entnum, large;
1905 prvm_edict_t *svent;
1907 // LordHavoc: clear *all* states (note just active ones)
1908 for (entnum = 0;entnum < prog->max_edicts;entnum++)
1910 // get the current server version
1911 svent = PRVM_EDICT_NUM(entnum);
1913 // LordHavoc: always clear state values, whether the entity is in use or not
1914 svent->priv.server->baseline = defaultstate;
1916 if (svent->priv.server->free)
1918 if (entnum > svs.maxclients && !svent->fields.server->modelindex)
1921 // create entity baseline
1922 VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
1923 VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
1924 svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
1925 svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
1926 if (entnum > 0 && entnum <= svs.maxclients)
1928 svent->priv.server->baseline.colormap = entnum;
1929 svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
1933 svent->priv.server->baseline.colormap = 0;
1934 svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
1938 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
1941 // add to the message
1943 MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
1945 MSG_WriteByte (&sv.signon, svc_spawnbaseline);
1946 MSG_WriteShort (&sv.signon, entnum);
1950 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
1951 MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
1955 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
1956 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
1958 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
1959 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
1960 for (i=0 ; i<3 ; i++)
1962 MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
1963 MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
1973 Grabs the current state of each client for saving across the
1974 transition to another level
1977 void SV_SaveSpawnparms (void)
1981 svs.serverflags = (int)prog->globals.server->serverflags;
1983 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1985 if (!host_client->active)
1988 // call the progs to get default spawn parms for the new client
1989 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1990 PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
1991 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
1992 host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
1996 void SV_IncreaseEdicts(void)
2000 int oldmax_edicts = prog->max_edicts;
2001 void *oldedictsengineprivate = prog->edictprivate;
2002 void *oldedictsfields = prog->edictsfields;
2003 void *oldmoved_edicts = sv.moved_edicts;
2005 if (prog->max_edicts >= MAX_EDICTS)
2008 // links don't survive the transition, so unlink everything
2009 for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2011 if (!ent->priv.server->free)
2012 SV_UnlinkEdict(prog->edicts + i);
2013 memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid));
2015 World_Clear(&sv.world);
2017 prog->max_edicts = min(prog->max_edicts + 256, MAX_EDICTS);
2018 prog->edictprivate = PR_Alloc(prog->max_edicts * sizeof(edict_engineprivate_t));
2019 prog->edictsfields = PR_Alloc(prog->max_edicts * prog->edict_size);
2020 sv.moved_edicts = PR_Alloc(prog->max_edicts * sizeof(prvm_edict_t *));
2022 memcpy(prog->edictprivate, oldedictsengineprivate, oldmax_edicts * sizeof(edict_engineprivate_t));
2023 memcpy(prog->edictsfields, oldedictsfields, oldmax_edicts * prog->edict_size);
2025 for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2027 ent->priv.vp = (unsigned char*) prog->edictprivate + i * prog->edictprivate_size;
2028 ent->fields.server = (void *)((unsigned char *)prog->edictsfields + i * prog->edict_size);
2029 // link every entity except world
2030 if (!ent->priv.server->free)
2031 SV_LinkEdict(ent, false);
2034 PR_Free(oldedictsengineprivate);
2035 PR_Free(oldedictsfields);
2036 PR_Free(oldmoved_edicts);
2043 This is called at the start of each level
2046 extern float scr_centertime_off;
2048 void SV_SpawnServer (const char *server)
2053 model_t *worldmodel;
2054 char modelname[sizeof(sv.modelname)];
2056 Con_DPrintf("SpawnServer: %s\n", server);
2058 if (cls.state != ca_dedicated)
2059 SCR_BeginLoadingPlaque();
2061 dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
2062 worldmodel = Mod_ForName(modelname, false, true, true);
2063 if (!worldmodel || !worldmodel->TraceBox)
2065 Con_Printf("Couldn't load map %s\n", modelname);
2069 // let's not have any servers with no name
2070 if (hostname.string[0] == 0)
2071 Cvar_Set ("hostname", "UNNAMED");
2072 scr_centertime_off = 0;
2074 svs.changelevel_issued = false; // now safe to issue another
2076 // make the map a required file for clients
2077 Curl_ClearRequirements();
2078 Curl_RequireFile(modelname);
2081 // tell all connected clients that we are going to a new level
2086 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
2088 if (client->netconnection)
2090 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
2091 MSG_WriteString(&client->netconnection->message, "reconnect\n");
2098 NetConn_OpenServerPorts(true);
2102 // make cvars consistant
2105 Cvar_SetValue ("deathmatch", 0);
2106 // LordHavoc: it can be useful to have skills outside the range 0-3...
2107 //current_skill = bound(0, (int)(skill.value + 0.5), 3);
2108 //Cvar_SetValue ("skill", (float)current_skill);
2109 current_skill = (int)(skill.value + 0.5);
2112 // set up the new server
2114 memset (&sv, 0, sizeof(sv));
2115 // if running a local client, make sure it doesn't try to access the last
2116 // level's data which is no longer valiud
2119 if(*sv_random_seed.string)
2121 srand(sv_random_seed.integer);
2122 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);
2129 strlcpy (sv.name, server, sizeof (sv.name));
2131 sv.protocol = Protocol_EnumForName(sv_protocolname.string);
2132 if (sv.protocol == PROTOCOL_UNKNOWN)
2135 Protocol_Names(buffer, sizeof(buffer));
2136 Con_Printf("Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
2137 sv.protocol = PROTOCOL_QUAKE;
2142 // load progs to get entity field count
2143 //PR_LoadProgs ( sv_progs.string );
2145 // allocate server memory
2146 /*// start out with just enough room for clients and a reasonable estimate of entities
2147 prog->max_edicts = max(svs.maxclients + 1, 512);
2148 prog->max_edicts = min(prog->max_edicts, MAX_EDICTS);
2150 // prvm_edict_t structures (hidden from progs)
2151 prog->edicts = PR_Alloc(MAX_EDICTS * sizeof(prvm_edict_t));
2152 // engine private structures (hidden from progs)
2153 prog->edictprivate = PR_Alloc(prog->max_edicts * sizeof(edict_engineprivate_t));
2154 // progs fields, often accessed by server
2155 prog->edictsfields = PR_Alloc(prog->max_edicts * prog->edict_size);*/
2156 // used by PushMove to move back pushed entities
2157 sv.moved_edicts = (prvm_edict_t **)PRVM_Alloc(prog->max_edicts * sizeof(prvm_edict_t *));
2158 /*for (i = 0;i < prog->max_edicts;i++)
2160 ent = prog->edicts + i;
2161 ent->priv.vp = (unsigned char*) prog->edictprivate + i * prog->edictprivate_size;
2162 ent->fields.server = (void *)((unsigned char *)prog->edictsfields + i * prog->edict_size);
2165 // reset client csqc entity versions right away.
2166 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2167 EntityFrameCSQC_InitClientVersions(i, true);
2169 sv.datagram.maxsize = sizeof(sv.datagram_buf);
2170 sv.datagram.cursize = 0;
2171 sv.datagram.data = sv.datagram_buf;
2173 sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
2174 sv.reliable_datagram.cursize = 0;
2175 sv.reliable_datagram.data = sv.reliable_datagram_buf;
2177 sv.signon.maxsize = sizeof(sv.signon_buf);
2178 sv.signon.cursize = 0;
2179 sv.signon.data = sv.signon_buf;
2181 // leave slots at start for clients only
2182 //prog->num_edicts = svs.maxclients+1;
2184 sv.state = ss_loading;
2185 prog->allowworldwrites = true;
2188 prog->globals.server->time = sv.time = 1.0;
2191 worldmodel->used = true;
2193 strlcpy (sv.name, server, sizeof (sv.name));
2194 strlcpy(sv.modelname, modelname, sizeof(sv.modelname));
2195 sv.worldmodel = worldmodel;
2196 sv.models[1] = sv.worldmodel;
2199 // clear world interaction links
2201 VectorCopy(sv.worldmodel->normalmins, sv.world.areagrid_mins);
2202 VectorCopy(sv.worldmodel->normalmaxs, sv.world.areagrid_maxs);
2203 World_Clear(&sv.world);
2205 strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
2207 strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
2208 strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
2209 for (i = 1;i < sv.worldmodel->brush.numsubmodels;i++)
2211 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
2212 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, false);
2216 // load the rest of the entities
2218 // AK possible hack since num_edicts is still 0
2219 ent = PRVM_EDICT_NUM(0);
2220 memset (ent->fields.server, 0, prog->progs->entityfields * 4);
2221 ent->priv.server->free = false;
2222 ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
2223 ent->fields.server->modelindex = 1; // world model
2224 ent->fields.server->solid = SOLID_BSP;
2225 ent->fields.server->movetype = MOVETYPE_PUSH;
2226 VectorCopy(sv.worldmodel->normalmins, ent->fields.server->mins);
2227 VectorCopy(sv.worldmodel->normalmaxs, ent->fields.server->maxs);
2228 VectorCopy(sv.worldmodel->normalmins, ent->fields.server->absmin);
2229 VectorCopy(sv.worldmodel->normalmaxs, ent->fields.server->absmax);
2232 prog->globals.server->coop = coop.integer;
2234 prog->globals.server->deathmatch = deathmatch.integer;
2236 prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
2238 // serverflags are for cross level information (sigils)
2239 prog->globals.server->serverflags = svs.serverflags;
2241 // we need to reset the spawned flag on all connected clients here so that
2242 // their thinks don't run during startup (before PutClientInServer)
2243 // we also need to set up the client entities now
2244 // and we need to set the ->edict pointers to point into the progs edicts
2245 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2247 host_client->spawned = false;
2248 host_client->edict = PRVM_EDICT_NUM(i + 1);
2249 PRVM_ED_ClearEdict(host_client->edict);
2252 // load replacement entity file if found
2253 if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
2255 Con_Printf("Loaded maps/%s.ent\n", sv.name);
2256 PRVM_ED_LoadFromFile (entities);
2260 PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
2263 // LordHavoc: clear world angles (to fix e3m3.bsp)
2264 VectorClear(prog->edicts->fields.server->angles);
2266 // all setup is completed, any further precache statements are errors
2267 sv.state = ss_active;
2268 prog->allowworldwrites = false;
2270 // run two frames to allow everything to settle
2271 for (i = 0;i < 2;i++)
2279 // create a baseline for more efficient communications
2280 if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
2281 SV_CreateBaseline ();
2283 // send serverinfo to all connected clients, and set up botclients coming back from a level change
2284 for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
2286 if (!host_client->active)
2288 if (host_client->netconnection)
2289 SV_SendServerinfo(host_client);
2293 // if client is a botclient coming from a level change, we need to
2294 // set up client info that normally requires networking
2296 // copy spawn parms out of the client_t
2297 for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
2298 (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
2300 // call the spawn function
2301 host_client->clientconnectcalled = true;
2302 prog->globals.server->time = sv.time;
2303 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
2304 PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
2305 PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
2306 host_client->spawned = true;
2310 Con_DPrint("Server spawned.\n");
2311 NetConn_Heartbeat (2);
2316 /////////////////////////////////////////////////////
2319 void SV_VM_CB_BeginIncreaseEdicts(void)
2324 PRVM_Free( sv.moved_edicts );
2325 sv.moved_edicts = (prvm_edict_t **)PRVM_Alloc(prog->max_edicts * sizeof(prvm_edict_t *));
2327 // links don't survive the transition, so unlink everything
2328 for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2330 if (!ent->priv.server->free)
2331 World_UnlinkEdict(prog->edicts + i);
2332 memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid));
2334 World_Clear(&sv.world);
2337 void SV_VM_CB_EndIncreaseEdicts(void)
2342 // link every entity except world
2343 for (i = 1, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
2344 if (!ent->priv.server->free)
2345 SV_LinkEdict(ent, false);
2348 void SV_VM_CB_InitEdict(prvm_edict_t *e)
2350 // LordHavoc: for consistency set these here
2351 int num = PRVM_NUM_FOR_EDICT(e) - 1;
2353 e->priv.server->move = false; // don't move on first frame
2355 if (num >= 0 && num < svs.maxclients)
2358 // set colormap and team on newly created player entity
2359 e->fields.server->colormap = num + 1;
2360 e->fields.server->team = (svs.clients[num].colors & 15) + 1;
2361 // set netname/clientcolors back to client values so that
2362 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
2364 e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
2365 if ((val = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.clientcolors)))
2366 val->_float = svs.clients[num].colors;
2367 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
2368 if( prog->fieldoffsets.playermodel >= 0 )
2369 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
2370 if( prog->fieldoffsets.playerskin >= 0 )
2371 PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
2375 void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
2377 World_UnlinkEdict(ed); // unlink from world bsp
2379 ed->fields.server->model = 0;
2380 ed->fields.server->takedamage = 0;
2381 ed->fields.server->modelindex = 0;
2382 ed->fields.server->colormap = 0;
2383 ed->fields.server->skin = 0;
2384 ed->fields.server->frame = 0;
2385 VectorClear(ed->fields.server->origin);
2386 VectorClear(ed->fields.server->angles);
2387 ed->fields.server->nextthink = -1;
2388 ed->fields.server->solid = 0;
2391 void SV_VM_CB_CountEdicts(void)
2395 int active, models, solid, step;
2397 active = models = solid = step = 0;
2398 for (i=0 ; i<prog->num_edicts ; i++)
2400 ent = PRVM_EDICT_NUM(i);
2401 if (ent->priv.server->free)
2404 if (ent->fields.server->solid)
2406 if (ent->fields.server->model)
2408 if (ent->fields.server->movetype == MOVETYPE_STEP)
2412 Con_Printf("num_edicts:%3i\n", prog->num_edicts);
2413 Con_Printf("active :%3i\n", active);
2414 Con_Printf("view :%3i\n", models);
2415 Con_Printf("touch :%3i\n", solid);
2416 Con_Printf("step :%3i\n", step);
2419 qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
2421 // remove things from different skill levels or deathmatch
2422 if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
2424 if (deathmatch.integer)
2426 if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
2431 else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY ))
2432 || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
2433 || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD )))
2441 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)"};
2442 cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
2443 cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
2444 cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"};
2445 cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"};
2446 cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"};
2447 cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"};
2448 cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2449 cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2450 cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2451 cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2452 cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2453 cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
2454 cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
2455 cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
2456 cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
2457 cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
2458 cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
2459 cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
2460 cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
2461 cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
2462 cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
2463 cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
2464 cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
2465 cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
2466 cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
2467 cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
2468 cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
2469 cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
2470 cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
2471 cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
2472 cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
2473 cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
2475 void SV_VM_Init(void)
2477 Cvar_RegisterVariable (&pr_checkextension);
2478 Cvar_RegisterVariable (&nomonsters);
2479 Cvar_RegisterVariable (&gamecfg);
2480 Cvar_RegisterVariable (&scratch1);
2481 Cvar_RegisterVariable (&scratch2);
2482 Cvar_RegisterVariable (&scratch3);
2483 Cvar_RegisterVariable (&scratch4);
2484 Cvar_RegisterVariable (&savedgamecfg);
2485 Cvar_RegisterVariable (&saved1);
2486 Cvar_RegisterVariable (&saved2);
2487 Cvar_RegisterVariable (&saved3);
2488 Cvar_RegisterVariable (&saved4);
2489 // LordHavoc: Nehahra uses these to pass data around cutscene demos
2490 if (gamemode == GAME_NEHAHRA)
2492 Cvar_RegisterVariable (&nehx00);
2493 Cvar_RegisterVariable (&nehx01);
2494 Cvar_RegisterVariable (&nehx02);
2495 Cvar_RegisterVariable (&nehx03);
2496 Cvar_RegisterVariable (&nehx04);
2497 Cvar_RegisterVariable (&nehx05);
2498 Cvar_RegisterVariable (&nehx06);
2499 Cvar_RegisterVariable (&nehx07);
2500 Cvar_RegisterVariable (&nehx08);
2501 Cvar_RegisterVariable (&nehx09);
2502 Cvar_RegisterVariable (&nehx10);
2503 Cvar_RegisterVariable (&nehx11);
2504 Cvar_RegisterVariable (&nehx12);
2505 Cvar_RegisterVariable (&nehx13);
2506 Cvar_RegisterVariable (&nehx14);
2507 Cvar_RegisterVariable (&nehx15);
2508 Cvar_RegisterVariable (&nehx16);
2509 Cvar_RegisterVariable (&nehx17);
2510 Cvar_RegisterVariable (&nehx18);
2511 Cvar_RegisterVariable (&nehx19);
2513 Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
2516 #define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t))
2518 prvm_required_field_t reqfields[] =
2520 {ev_entity, "cursor_trace_ent"},
2521 {ev_entity, "drawonlytoclient"},
2522 {ev_entity, "exteriormodeltoclient"},
2523 {ev_entity, "nodrawtoclient"},
2524 {ev_entity, "tag_entity"},
2525 {ev_entity, "viewmodelforclient"},
2526 {ev_float, "alpha"},
2527 {ev_float, "ammo_cells1"},
2528 {ev_float, "ammo_lava_nails"},
2529 {ev_float, "ammo_multi_rockets"},
2530 {ev_float, "ammo_nails1"},
2531 {ev_float, "ammo_plasma"},
2532 {ev_float, "ammo_rockets1"},
2533 {ev_float, "ammo_shells1"},
2534 {ev_float, "button3"},
2535 {ev_float, "button4"},
2536 {ev_float, "button5"},
2537 {ev_float, "button6"},
2538 {ev_float, "button7"},
2539 {ev_float, "button8"},
2540 {ev_float, "button9"},
2541 {ev_float, "button10"},
2542 {ev_float, "button11"},
2543 {ev_float, "button12"},
2544 {ev_float, "button13"},
2545 {ev_float, "button14"},
2546 {ev_float, "button15"},
2547 {ev_float, "button16"},
2548 {ev_float, "buttonchat"},
2549 {ev_float, "buttonuse"},
2550 {ev_float, "clientcolors"},
2551 {ev_float, "cursor_active"},
2552 {ev_float, "disableclientprediction"},
2553 {ev_float, "fullbright"},
2554 {ev_float, "glow_color"},
2555 {ev_float, "glow_size"},
2556 {ev_float, "glow_trail"},
2557 {ev_float, "gravity"},
2558 {ev_float, "idealpitch"},
2559 {ev_float, "items2"},
2560 {ev_float, "light_lev"},
2561 {ev_float, "pflags"},
2563 {ev_float, "pitch_speed"},
2564 {ev_float, "pmodel"},
2565 {ev_float, "renderamt"}, // HalfLife support
2566 {ev_float, "rendermode"}, // HalfLife support
2567 {ev_float, "scale"},
2568 {ev_float, "style"},
2569 {ev_float, "tag_index"},
2570 {ev_float, "Version"},
2571 {ev_float, "viewzoom"},
2572 {ev_vector, "color"},
2573 {ev_vector, "colormod"},
2574 {ev_vector, "cursor_screen"},
2575 {ev_vector, "cursor_trace_endpos"},
2576 {ev_vector, "cursor_trace_start"},
2577 {ev_vector, "movement"},
2578 {ev_vector, "punchvector"},
2579 {ev_string, "playermodel"},
2580 {ev_string, "playerskin"},
2581 {ev_function, "SendEntity"},
2582 {ev_function, "customizeentityforclient"},
2583 // DRESK - Support for Entity Contents Transition Event
2584 {ev_function, "contentstransition"},
2587 void SV_VM_Setup(void)
2589 extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat
2590 extern cvar_t csqc_progcrc;
2591 extern cvar_t csqc_progsize;
2592 size_t csprogsdatasize;
2594 PRVM_InitProg( PRVM_SERVERPROG );
2596 // allocate the mempools
2597 // TODO: move the magic numbers/constants into #defines [9/13/2006 Black]
2598 prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
2599 prog->builtins = vm_sv_builtins;
2600 prog->numbuiltins = vm_sv_numbuiltins;
2601 prog->headercrc = PROGHEADER_CRC;
2602 prog->max_edicts = 512;
2603 prog->limit_edicts = MAX_EDICTS;
2604 prog->reserved_edicts = svs.maxclients;
2605 prog->edictprivate_size = sizeof(edict_engineprivate_t);
2606 prog->name = "server";
2607 prog->extensionstring = vm_sv_extensions;
2608 prog->loadintoworld = true;
2610 prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
2611 prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
2612 prog->init_edict = SV_VM_CB_InitEdict;
2613 prog->free_edict = SV_VM_CB_FreeEdict;
2614 prog->count_edicts = SV_VM_CB_CountEdicts;
2615 prog->load_edict = SV_VM_CB_LoadEdict;
2616 prog->init_cmd = VM_SV_Cmd_Init;
2617 prog->reset_cmd = VM_SV_Cmd_Reset;
2618 prog->error_cmd = Host_Error;
2620 // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
2621 PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields, 0, NULL );
2623 // some mods compiled with scrambling compilers lack certain critical
2624 // global names and field names such as "self" and "time" and "nextthink"
2625 // so we have to set these offsets manually, matching the entvars_t
2626 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
2627 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
2628 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
2629 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
2630 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
2631 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
2632 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
2633 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
2634 PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
2635 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
2636 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
2637 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
2638 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
2639 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
2640 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
2641 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
2642 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
2643 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
2644 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
2645 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
2646 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
2647 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
2648 PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
2649 // OP_STATE is always supported on server (due to entvars_t)
2650 prog->flag |= PRVM_OP_STATE;
2652 VM_AutoSentStats_Clear();//[515]: csqc
2653 EntityFrameCSQC_ClearVersions();//[515]: csqc
2657 // see if there is a csprogs.dat installed, and if so, set the csqc_progcrc accordingly, this will be sent to connecting clients to tell them to only load a matching csprogs.dat file
2658 sv.csqc_progname[0] = 0;
2659 sv.csqc_progcrc = FS_CRCFile(csqc_progname.string, &csprogsdatasize);
2660 sv.csqc_progsize = csprogsdatasize;
2661 if (sv.csqc_progsize > 0)
2663 strlcpy(sv.csqc_progname, csqc_progname.string, sizeof(sv.csqc_progname));
2664 Con_DPrintf("server detected csqc progs file \"%s\" with size %i and crc %i\n", sv.csqc_progname, sv.csqc_progsize, sv.csqc_progcrc);
2668 void SV_VM_Begin(void)
2671 PRVM_SetProg( PRVM_SERVERPROG );
2673 prog->globals.server->time = (float) sv.time;
2676 void SV_VM_End(void)