implemented DP_TRACE_HITCONTENTSMASK_SURFACEINFO extension, this allows QC to find...
[xonotic/darkplaces.git] / sv_main.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // sv_main.c -- server main program
21
22 #include "quakedef.h"
23
24 void SV_VM_Init();
25 void SV_VM_Setup();
26
27 void VM_AutoSentStats_Clear (void);
28 void EntityFrameCSQC_ClearVersions (void);
29 void EntityFrameCSQC_InitClientVersions (int client, qboolean clear);
30 void VM_SV_WriteAutoSentStats (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats);
31 void EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int numstates, const entity_state_t *states);
32
33
34 // select which protocol to host, this is fed to Protocol_EnumForName
35 cvar_t sv_protocolname = {0, "sv_protocolname", "DP7", "selects network protocol to host for (values include QUAKE, QUAKEDP, NEHAHRAMOVIE, DP1 and up)"};
36 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)"};
37 cvar_t sv_maxrate = {CVAR_SAVE | CVAR_NOTIFY, "sv_maxrate", "10000", "upper limit on client rate cvar, should reflect your network connection quality"};
38
39 static cvar_t sv_cullentities_pvs = {0, "sv_cullentities_pvs", "1", "fast but loose culling of hidden entities"}; // fast but loose
40 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
41 static cvar_t sv_cullentities_stats = {0, "sv_cullentities_stats", "0", "displays stats on network entities culled by various methods for each client"};
42 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)"};
43
44 cvar_t sv_gameplayfix_grenadebouncedownslopes = {0, "sv_gameplayfix_grenadebouncedownslopes", "1", "prevents MOVETYPE_BOUNCE (grenades) from getting stuck when fired down a downward sloping surface"};
45 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"};
46 cvar_t sv_gameplayfix_stepdown = {0, "sv_gameplayfix_stepdown", "1", "attempts to step down stairs, not just up them (prevents the familiar thud..thud..thud.. when running down stairs and slopes)"};
47 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)"};
48 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"};
49 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"};
50 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"};
51 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"};
52
53 cvar_t sv_progs = {0, "sv_progs", "progs.dat", "selects which quakec progs.dat file to run" };
54
55 server_t sv;
56 server_static_t svs;
57
58 mempool_t *sv_mempool = NULL;
59
60 //============================================================================
61
62 extern void SV_Phys_Init (void);
63 extern void SV_World_Init (void);
64 static void SV_SaveEntFile_f(void);
65
66 /*
67 ===============
68 SV_Init
69 ===============
70 */
71 void SV_Init (void)
72 {
73         Cmd_AddCommand("sv_saveentfile", SV_SaveEntFile_f, "save map entities to .ent file (to allow external editing)");
74         Cvar_RegisterVariable (&sv_maxvelocity);
75         Cvar_RegisterVariable (&sv_gravity);
76         Cvar_RegisterVariable (&sv_friction);
77         Cvar_RegisterVariable (&sv_edgefriction);
78         Cvar_RegisterVariable (&sv_stopspeed);
79         Cvar_RegisterVariable (&sv_maxspeed);
80         Cvar_RegisterVariable (&sv_maxairspeed);
81         Cvar_RegisterVariable (&sv_accelerate);
82         Cvar_RegisterVariable (&sv_idealpitchscale);
83         Cvar_RegisterVariable (&sv_aim);
84         Cvar_RegisterVariable (&sv_nostep);
85         Cvar_RegisterVariable (&sv_cullentities_pvs);
86         Cvar_RegisterVariable (&sv_cullentities_trace);
87         Cvar_RegisterVariable (&sv_cullentities_stats);
88         Cvar_RegisterVariable (&sv_entpatch);
89         Cvar_RegisterVariable (&sv_gameplayfix_grenadebouncedownslopes);
90         Cvar_RegisterVariable (&sv_gameplayfix_noairborncorpse);
91         Cvar_RegisterVariable (&sv_gameplayfix_stepdown);
92         Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
93         Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
94         Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
95         Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
96         Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
97         Cvar_RegisterVariable (&sv_protocolname);
98         Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
99         Cvar_RegisterVariable (&sv_maxrate);
100         Cvar_RegisterVariable (&sv_progs);
101
102         SV_VM_Init();
103         SV_Phys_Init();
104         SV_World_Init();
105
106         sv_mempool = Mem_AllocPool("server", 0, NULL);
107 }
108
109 static void SV_SaveEntFile_f(void)
110 {
111         char basename[MAX_QPATH];
112         if (!sv.active || !sv.worldmodel)
113         {
114                 Con_Print("Not running a server\n");
115                 return;
116         }
117         FS_StripExtension(sv.worldmodel->name, basename, sizeof(basename));
118         FS_WriteFile(va("%s.ent", basename), sv.worldmodel->brush.entities, (fs_offset_t)strlen(sv.worldmodel->brush.entities));
119 }
120
121
122 /*
123 =============================================================================
124
125 EVENT MESSAGES
126
127 =============================================================================
128 */
129
130 /*
131 ==================
132 SV_StartParticle
133
134 Make sure the event gets sent to all clients
135 ==================
136 */
137 void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
138 {
139         int             i, v;
140
141         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
142                 return;
143         MSG_WriteByte (&sv.datagram, svc_particle);
144         MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
145         MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
146         MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
147         for (i=0 ; i<3 ; i++)
148         {
149                 v = dir[i]*16;
150                 if (v > 127)
151                         v = 127;
152                 else if (v < -128)
153                         v = -128;
154                 MSG_WriteChar (&sv.datagram, v);
155         }
156         MSG_WriteByte (&sv.datagram, count);
157         MSG_WriteByte (&sv.datagram, color);
158 }
159
160 /*
161 ==================
162 SV_StartEffect
163
164 Make sure the event gets sent to all clients
165 ==================
166 */
167 void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
168 {
169         if (modelindex >= 256 || startframe >= 256)
170         {
171                 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
172                         return;
173                 MSG_WriteByte (&sv.datagram, svc_effect2);
174                 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
175                 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
176                 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
177                 MSG_WriteShort (&sv.datagram, modelindex);
178                 MSG_WriteShort (&sv.datagram, startframe);
179                 MSG_WriteByte (&sv.datagram, framecount);
180                 MSG_WriteByte (&sv.datagram, framerate);
181         }
182         else
183         {
184                 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
185                         return;
186                 MSG_WriteByte (&sv.datagram, svc_effect);
187                 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
188                 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
189                 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
190                 MSG_WriteByte (&sv.datagram, modelindex);
191                 MSG_WriteByte (&sv.datagram, startframe);
192                 MSG_WriteByte (&sv.datagram, framecount);
193                 MSG_WriteByte (&sv.datagram, framerate);
194         }
195 }
196
197 /*
198 ==================
199 SV_StartSound
200
201 Each entity can have eight independant sound sources, like voice,
202 weapon, feet, etc.
203
204 Channel 0 is an auto-allocate channel, the others override anything
205 already running on that entity/channel pair.
206
207 An attenuation of 0 will play full volume everywhere in the level.
208 Larger attenuations will drop off.  (max 4 attenuation)
209
210 ==================
211 */
212 void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int volume, float attenuation)
213 {
214         int sound_num, field_mask, i, ent;
215
216         if (volume < 0 || volume > 255)
217         {
218                 Con_Printf ("SV_StartSound: volume = %i\n", volume);
219                 return;
220         }
221
222         if (attenuation < 0 || attenuation > 4)
223         {
224                 Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
225                 return;
226         }
227
228         if (channel < 0 || channel > 7)
229         {
230                 Con_Printf ("SV_StartSound: channel = %i\n", channel);
231                 return;
232         }
233
234         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
235                 return;
236
237 // find precache number for sound
238         sound_num = SV_SoundIndex(sample, 1);
239         if (!sound_num)
240                 return;
241
242         ent = PRVM_NUM_FOR_EDICT(entity);
243
244         field_mask = 0;
245         if (volume != DEFAULT_SOUND_PACKET_VOLUME)
246                 field_mask |= SND_VOLUME;
247         if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
248                 field_mask |= SND_ATTENUATION;
249         if (ent >= 8192)
250                 field_mask |= SND_LARGEENTITY;
251         if (sound_num >= 256 || channel >= 8)
252                 field_mask |= SND_LARGESOUND;
253
254 // directed messages go only to the entity they are targeted on
255         MSG_WriteByte (&sv.datagram, svc_sound);
256         MSG_WriteByte (&sv.datagram, field_mask);
257         if (field_mask & SND_VOLUME)
258                 MSG_WriteByte (&sv.datagram, volume);
259         if (field_mask & SND_ATTENUATION)
260                 MSG_WriteByte (&sv.datagram, attenuation*64);
261         if (field_mask & SND_LARGEENTITY)
262         {
263                 MSG_WriteShort (&sv.datagram, ent);
264                 MSG_WriteByte (&sv.datagram, channel);
265         }
266         else
267                 MSG_WriteShort (&sv.datagram, (ent<<3) | channel);
268         if (field_mask & SND_LARGESOUND)
269                 MSG_WriteShort (&sv.datagram, sound_num);
270         else
271                 MSG_WriteByte (&sv.datagram, sound_num);
272         for (i = 0;i < 3;i++)
273                 MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
274 }
275
276 /*
277 ==============================================================================
278
279 CLIENT SPAWNING
280
281 ==============================================================================
282 */
283
284 static const char *SV_InitCmd;  //[515]: svprogs able to send cmd to client on connect
285 extern qboolean csqc_loaded;
286 /*
287 ================
288 SV_SendServerinfo
289
290 Sends the first message from the server to a connected client.
291 This will be sent on the initial connection and upon each server load.
292 ================
293 */
294 void SV_SendServerinfo (client_t *client)
295 {
296         int i;
297         char message[128];
298
299         // we know that this client has a netconnection and thus is not a bot
300
301         // edicts get reallocated on level changes, so we need to update it here
302         client->edict = PRVM_EDICT_NUM((client - svs.clients) + 1);
303
304         // clear cached stuff that depends on the level
305         client->weaponmodel[0] = 0;
306         client->weaponmodelindex = 0;
307
308         // LordHavoc: clear entityframe tracking
309         client->latestframenum = 0;
310
311         if (client->entitydatabase)
312                 EntityFrame_FreeDatabase(client->entitydatabase);
313         if (client->entitydatabase4)
314                 EntityFrame4_FreeDatabase(client->entitydatabase4);
315         if (client->entitydatabase5)
316                 EntityFrame5_FreeDatabase(client->entitydatabase5);
317
318         if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)
319         {
320                 if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
321                         client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
322                 else if (sv.protocol == PROTOCOL_DARKPLACES4)
323                         client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
324                 else
325                         client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
326         }
327
328         SZ_Clear (&client->netconnection->message);
329         MSG_WriteByte (&client->netconnection->message, svc_print);
330         dpsnprintf (message, sizeof (message), "\002\nServer: %s build %s (progs %i crc)", gamename, buildstring, prog->filecrc);
331         MSG_WriteString (&client->netconnection->message,message);
332
333         // FIXME: LordHavoc: this does not work on dedicated servers, needs fixing.
334 //[515]: init csprogs according to version of svprogs, check the crc, etc.
335         if(csqc_loaded && (cls.state == ca_dedicated || PRVM_NUM_FOR_EDICT(client->edict) != 1))
336         {
337                 MSG_WriteByte (&client->netconnection->message, svc_stufftext);
338                 if(SV_InitCmd)
339                         MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i;%s\n", csqc_progcrc.integer, SV_InitCmd));
340                 else
341                         MSG_WriteString (&client->netconnection->message, va("csqc_progcrc %i\n", csqc_progcrc.integer));
342         }
343
344         MSG_WriteByte (&client->netconnection->message, svc_serverinfo);
345         MSG_WriteLong (&client->netconnection->message, Protocol_NumberForEnum(sv.protocol));
346         MSG_WriteByte (&client->netconnection->message, svs.maxclients);
347
348         if (!coop.integer && deathmatch.integer)
349                 MSG_WriteByte (&client->netconnection->message, GAME_DEATHMATCH);
350         else
351                 MSG_WriteByte (&client->netconnection->message, GAME_COOP);
352
353         MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
354
355         for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
356                 MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
357         MSG_WriteByte (&client->netconnection->message, 0);
358
359         for (i = 1;i < MAX_SOUNDS && sv.sound_precache[i][0];i++)
360                 MSG_WriteString (&client->netconnection->message, sv.sound_precache[i]);
361         MSG_WriteByte (&client->netconnection->message, 0);
362
363 // send music
364         MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
365         MSG_WriteByte (&client->netconnection->message, prog->edicts->fields.server->sounds);
366         MSG_WriteByte (&client->netconnection->message, prog->edicts->fields.server->sounds);
367
368 // set view
369         MSG_WriteByte (&client->netconnection->message, svc_setview);
370         MSG_WriteShort (&client->netconnection->message, PRVM_NUM_FOR_EDICT(client->edict));
371
372         MSG_WriteByte (&client->netconnection->message, svc_signonnum);
373         MSG_WriteByte (&client->netconnection->message, 1);
374
375         client->spawned = false;                // need prespawn, spawn, etc
376 }
377
378 /*
379 ================
380 SV_ConnectClient
381
382 Initializes a client_t for a new net connection.  This will only be called
383 once for a player each game, not once for each level change.
384 ================
385 */
386 void SV_ConnectClient (int clientnum, netconn_t *netconnection)
387 {
388         client_t                *client;
389         int                             i;
390         float                   spawn_parms[NUM_SPAWN_PARMS];
391
392         client = svs.clients + clientnum;
393
394         if(netconnection)//[515]: bots don't play with csqc =)
395                 EntityFrameCSQC_InitClientVersions(clientnum, false);
396
397 // set up the client_t
398         if (sv.loadgame)
399                 memcpy (spawn_parms, client->spawn_parms, sizeof(spawn_parms));
400         memset (client, 0, sizeof(*client));
401         client->active = true;
402         client->netconnection = netconnection;
403
404         Con_DPrintf("Client %s connected\n", client->netconnection ? client->netconnection->address : "botclient");
405
406         strcpy(client->name, "unconnected");
407         strcpy(client->old_name, "unconnected");
408         client->spawned = false;
409         client->edict = PRVM_EDICT_NUM(clientnum+1);
410         if (client->netconnection)
411                 client->netconnection->message.allowoverflow = true;            // we can catch it
412         // updated by receiving "rate" command from client
413         client->rate = NET_MINRATE;
414         // no limits for local player
415         if (client->netconnection && LHNETADDRESS_GetAddressType(&client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP)
416                 client->rate = 1000000000;
417         client->connecttime = realtime;
418
419         if (sv.loadgame)
420                 memcpy (client->spawn_parms, spawn_parms, sizeof(spawn_parms));
421         else
422         {
423                 // call the progs to get default spawn parms for the new client
424                 // set self to world to intentionally cause errors with broken SetNewParms code in some mods
425                 prog->globals.server->self = 0;
426                 PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
427                 for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
428                         client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
429
430                 // set up the entity for this client (including .colormap, .team, etc)
431                 PRVM_ED_ClearEdict(client->edict);
432         }
433
434         // don't call SendServerinfo for a fresh botclient because its fields have
435         // not been set up by the qc yet
436         if (client->netconnection)
437                 SV_SendServerinfo (client);
438         else
439                 client->spawned = true;
440 }
441
442
443 /*
444 ===============================================================================
445
446 FRAME UPDATES
447
448 ===============================================================================
449 */
450
451 /*
452 ==================
453 SV_ClearDatagram
454
455 ==================
456 */
457 void SV_ClearDatagram (void)
458 {
459         SZ_Clear (&sv.datagram);
460 }
461
462 /*
463 =============================================================================
464
465 The PVS must include a small area around the client to allow head bobbing
466 or other small motion on the client side.  Otherwise, a bob might cause an
467 entity that should be visible to not show up, especially when the bob
468 crosses a waterline.
469
470 =============================================================================
471 */
472
473 int sv_writeentitiestoclient_pvsbytes;
474 unsigned char sv_writeentitiestoclient_pvs[MAX_MAP_LEAFS/8];
475
476 static int numsendentities;
477 static entity_state_t sendentities[MAX_EDICTS];
478 static entity_state_t *sendentitiesindex[MAX_EDICTS];
479
480 qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int e)
481 {
482         int i;
483         unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
484         unsigned int customizeentityforclient;
485         float f;
486         vec3_t cullmins, cullmaxs;
487         model_t *model;
488         prvm_eval_t *val;
489
490         // EF_NODRAW prevents sending for any reason except for your own
491         // client, so we must keep all clients in this superset
492         effects = (unsigned)ent->fields.server->effects;
493
494         // we can omit invisible entities with no effects that are not clients
495         // LordHavoc: this could kill tags attached to an invisible entity, I
496         // just hope we never have to support that case
497         i = (int)ent->fields.server->modelindex;
498         modelindex = (i >= 1 && i < MAX_MODELS && *PRVM_GetString(ent->fields.server->model)) ? i : 0;
499
500         flags = 0;
501         i = (int)(PRVM_GETEDICTFIELDVALUE(ent, eval_glow_size)->_float * 0.25f);
502         glowsize = (unsigned char)bound(0, i, 255);
503         if (PRVM_GETEDICTFIELDVALUE(ent, eval_glow_trail)->_float)
504                 flags |= RENDER_GLOWTRAIL;
505
506         f = PRVM_GETEDICTFIELDVALUE(ent, eval_color)->vector[0]*256;
507         light[0] = (unsigned short)bound(0, f, 65535);
508         f = PRVM_GETEDICTFIELDVALUE(ent, eval_color)->vector[1]*256;
509         light[1] = (unsigned short)bound(0, f, 65535);
510         f = PRVM_GETEDICTFIELDVALUE(ent, eval_color)->vector[2]*256;
511         light[2] = (unsigned short)bound(0, f, 65535);
512         f = PRVM_GETEDICTFIELDVALUE(ent, eval_light_lev)->_float;
513         light[3] = (unsigned short)bound(0, f, 65535);
514         lightstyle = (unsigned char)PRVM_GETEDICTFIELDVALUE(ent, eval_style)->_float;
515         lightpflags = (unsigned char)PRVM_GETEDICTFIELDVALUE(ent, eval_pflags)->_float;
516
517         if (gamemode == GAME_TENEBRAE)
518         {
519                 // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
520                 if (effects & 16)
521                 {
522                         effects &= ~16;
523                         lightpflags |= PFLAGS_FULLDYNAMIC;
524                 }
525                 // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
526                 if (effects & 32)
527                 {
528                         effects &= ~32;
529                         light[0] = 0.2;
530                         light[1] = 1;
531                         light[2] = 0.2;
532                         light[3] = 200;
533                         lightpflags |= PFLAGS_FULLDYNAMIC;
534                 }
535         }
536
537         specialvisibilityradius = 0;
538         if (lightpflags & PFLAGS_FULLDYNAMIC)
539                 specialvisibilityradius = max(specialvisibilityradius, light[3]);
540         if (glowsize)
541                 specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
542         if (flags & RENDER_GLOWTRAIL)
543                 specialvisibilityradius = max(specialvisibilityradius, 100);
544         if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
545         {
546                 if (effects & EF_BRIGHTFIELD)
547                         specialvisibilityradius = max(specialvisibilityradius, 80);
548                 if (effects & EF_MUZZLEFLASH)
549                         specialvisibilityradius = max(specialvisibilityradius, 100);
550                 if (effects & EF_BRIGHTLIGHT)
551                         specialvisibilityradius = max(specialvisibilityradius, 400);
552                 if (effects & EF_DIMLIGHT)
553                         specialvisibilityradius = max(specialvisibilityradius, 200);
554                 if (effects & EF_RED)
555                         specialvisibilityradius = max(specialvisibilityradius, 200);
556                 if (effects & EF_BLUE)
557                         specialvisibilityradius = max(specialvisibilityradius, 200);
558                 if (effects & EF_FLAME)
559                         specialvisibilityradius = max(specialvisibilityradius, 250);
560                 if (effects & EF_STARDUST)
561                         specialvisibilityradius = max(specialvisibilityradius, 100);
562         }
563
564         // early culling checks
565         // (final culling is done by SV_MarkWriteEntityStateToClient)
566         customizeentityforclient = PRVM_GETEDICTFIELDVALUE(ent, eval_customizeentityforclient)->function;
567         if (!customizeentityforclient)
568         {
569                 if (e > svs.maxclients && (!modelindex && !specialvisibilityradius))
570                         return false;
571                 // this 2 billion unit check is actually to detect NAN origins
572                 // (we really don't want to send those)
573                 if (VectorLength2(ent->fields.server->origin) > 2000000000.0*2000000000.0)
574                         return false;
575         }
576
577
578         *cs = defaultstate;
579         cs->active = true;
580         cs->number = e;
581         VectorCopy(ent->fields.server->origin, cs->origin);
582         VectorCopy(ent->fields.server->angles, cs->angles);
583         cs->flags = flags;
584         cs->effects = effects;
585         cs->colormap = (unsigned)ent->fields.server->colormap;
586         cs->modelindex = modelindex;
587         cs->skin = (unsigned)ent->fields.server->skin;
588         cs->frame = (unsigned)ent->fields.server->frame;
589         cs->viewmodelforclient = PRVM_GETEDICTFIELDVALUE(ent, eval_viewmodelforclient)->edict;
590         cs->exteriormodelforclient = PRVM_GETEDICTFIELDVALUE(ent, eval_exteriormodeltoclient)->edict;
591         cs->nodrawtoclient = PRVM_GETEDICTFIELDVALUE(ent, eval_nodrawtoclient)->edict;
592         cs->drawonlytoclient = PRVM_GETEDICTFIELDVALUE(ent, eval_drawonlytoclient)->edict;
593         cs->customizeentityforclient = customizeentityforclient;
594         cs->tagentity = PRVM_GETEDICTFIELDVALUE(ent, eval_tag_entity)->edict;
595         cs->tagindex = (unsigned char)PRVM_GETEDICTFIELDVALUE(ent, eval_tag_index)->_float;
596         cs->glowsize = glowsize;
597
598         // don't need to init cs->colormod because the defaultstate did that for us
599         //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
600         val = PRVM_GETEDICTFIELDVALUE(ent, eval_colormod);
601         if (val->vector[0] || val->vector[1] || val->vector[2])
602         {
603                 i = val->vector[0] * 32.0f;cs->colormod[0] = bound(0, i, 255);
604                 i = val->vector[1] * 32.0f;cs->colormod[1] = bound(0, i, 255);
605                 i = val->vector[2] * 32.0f;cs->colormod[2] = bound(0, i, 255);
606         }
607
608         cs->modelindex = modelindex;
609
610         cs->alpha = 255;
611         f = (PRVM_GETEDICTFIELDVALUE(ent, eval_alpha)->_float * 255.0f);
612         if (f)
613         {
614                 i = (int)f;
615                 cs->alpha = (unsigned char)bound(0, i, 255);
616         }
617         // halflife
618         f = (PRVM_GETEDICTFIELDVALUE(ent, eval_renderamt)->_float);
619         if (f)
620         {
621                 i = (int)f;
622                 cs->alpha = (unsigned char)bound(0, i, 255);
623         }
624
625         cs->scale = 16;
626         f = (PRVM_GETEDICTFIELDVALUE(ent, eval_scale)->_float * 16.0f);
627         if (f)
628         {
629                 i = (int)f;
630                 cs->scale = (unsigned char)bound(0, i, 255);
631         }
632
633         cs->glowcolor = 254;
634         f = (PRVM_GETEDICTFIELDVALUE(ent, eval_glow_color)->_float);
635         if (f)
636                 cs->glowcolor = (int)f;
637
638         if (PRVM_GETEDICTFIELDVALUE(ent, eval_fullbright)->_float)
639                 cs->effects |= EF_FULLBRIGHT;
640
641         if (ent->fields.server->movetype == MOVETYPE_STEP)
642                 cs->flags |= RENDER_STEP;
643         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)
644                 cs->flags |= RENDER_LOWPRECISION;
645         if (ent->fields.server->colormap >= 1024)
646                 cs->flags |= RENDER_COLORMAPPED;
647         if (cs->viewmodelforclient)
648                 cs->flags |= RENDER_VIEWMODEL; // show relative to the view
649
650         cs->light[0] = light[0];
651         cs->light[1] = light[1];
652         cs->light[2] = light[2];
653         cs->light[3] = light[3];
654         cs->lightstyle = lightstyle;
655         cs->lightpflags = lightpflags;
656
657         cs->specialvisibilityradius = specialvisibilityradius;
658
659         // calculate the visible box of this entity (don't use the physics box
660         // as that is often smaller than a model, and would not count
661         // specialvisibilityradius)
662         if ((model = sv.models[modelindex]))
663         {
664                 float scale = cs->scale * (1.0f / 16.0f);
665                 if (cs->angles[0] || cs->angles[2]) // pitch and roll
666                 {
667                         VectorMA(cs->origin, scale, model->rotatedmins, cullmins);
668                         VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs);
669                 }
670                 else if (cs->angles[1])
671                 {
672                         VectorMA(cs->origin, scale, model->yawmins, cullmins);
673                         VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs);
674                 }
675                 else
676                 {
677                         VectorMA(cs->origin, scale, model->normalmins, cullmins);
678                         VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs);
679                 }
680         }
681         else
682         {
683                 VectorCopy(cs->origin, cullmins);
684                 VectorCopy(cs->origin, cullmaxs);
685         }
686         if (specialvisibilityradius)
687         {
688                 cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius);
689                 cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius);
690                 cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius);
691                 cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius);
692                 cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius);
693                 cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius);
694         }
695         if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
696         {
697                 VectorCopy(cullmins, ent->priv.server->cullmins);
698                 VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
699                 ent->priv.server->pvs_numclusters = -1;
700                 if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
701                 {
702                         i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
703                         if (i <= MAX_ENTITYCLUSTERS)
704                                 ent->priv.server->pvs_numclusters = i;
705                 }
706         }
707
708         return true;
709 }
710
711 void SV_PrepareEntitiesForSending(void)
712 {
713         int e;
714         prvm_edict_t *ent;
715         // send all entities that touch the pvs
716         numsendentities = 0;
717         sendentitiesindex[0] = NULL;
718         memset(sendentitiesindex, 0, prog->num_edicts * sizeof(entity_state_t *));
719         for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent))
720         {
721                 if (!ent->priv.server->free && SV_PrepareEntityForSending(ent, sendentities + numsendentities, e))
722                 {
723                         sendentitiesindex[e] = sendentities + numsendentities;
724                         numsendentities++;
725                 }
726         }
727 }
728
729 static int sententitiesmark = 0;
730 static int sententities[MAX_EDICTS];
731 static int sententitiesconsideration[MAX_EDICTS];
732 static int sv_writeentitiestoclient_culled_pvs;
733 static int sv_writeentitiestoclient_culled_trace;
734 static int sv_writeentitiestoclient_visibleentities;
735 static int sv_writeentitiestoclient_totalentities;
736 //static entity_frame_t sv_writeentitiestoclient_entityframe;
737 static int sv_writeentitiestoclient_clentnum;
738 static vec3_t sv_writeentitiestoclient_testeye;
739 static client_t *sv_writeentitiestoclient_client;
740
741 void SV_MarkWriteEntityStateToClient(entity_state_t *s)
742 {
743         int isbmodel;
744         vec3_t testorigin;
745         model_t *model;
746         prvm_edict_t *ed;
747         trace_t trace;
748         if (sententitiesconsideration[s->number] == sententitiesmark)
749                 return;
750         sententitiesconsideration[s->number] = sententitiesmark;
751         sv_writeentitiestoclient_totalentities++;
752
753         if (s->customizeentityforclient)
754         {
755                 prog->globals.server->self = s->number;
756                 prog->globals.server->other = sv_writeentitiestoclient_clentnum;
757                 PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
758                 if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
759                         return;
760         }
761
762         // never reject player
763         if (s->number != sv_writeentitiestoclient_clentnum)
764         {
765                 // check various rejection conditions
766                 if (s->nodrawtoclient == sv_writeentitiestoclient_clentnum)
767                         return;
768                 if (s->drawonlytoclient && s->drawonlytoclient != sv_writeentitiestoclient_clentnum)
769                         return;
770                 if (s->effects & EF_NODRAW)
771                         return;
772                 // LordHavoc: only send entities with a model or important effects
773                 if (!s->modelindex && s->specialvisibilityradius == 0)
774                         return;
775
776                 // viewmodels don't have visibility checking
777                 if (s->viewmodelforclient)
778                 {
779                         if (s->viewmodelforclient != sv_writeentitiestoclient_clentnum)
780                                 return;
781                 }
782                 else if (s->tagentity)
783                 {
784                         // tag attached entities simply check their parent
785                         if (!sendentitiesindex[s->tagentity])
786                                 return;
787                         SV_MarkWriteEntityStateToClient(sendentitiesindex[s->tagentity]);
788                         if (sententities[s->tagentity] != sententitiesmark)
789                                 return;
790                 }
791                 // always send world submodels in newer protocols because they don't
792                 // generate much traffic (in old protocols they hog bandwidth)
793                 else if (!(s->effects & EF_NODEPTHTEST) && !((isbmodel = (model = sv.models[s->modelindex]) != NULL && model->name[0] == '*') && (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)))
794                 {
795                         // entity has survived every check so far, check if visible
796                         ed = PRVM_EDICT_NUM(s->number);
797
798                         // if not touching a visible leaf
799                         if (sv_cullentities_pvs.integer && sv_writeentitiestoclient_pvsbytes)
800                         {
801                                 if (ed->priv.server->pvs_numclusters < 0)
802                                 {
803                                         // entity too big for clusters list
804                                         if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv_writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
805                                         {
806                                                 sv_writeentitiestoclient_culled_pvs++;
807                                                 return;
808                                         }
809                                 }
810                                 else
811                                 {
812                                         int i;
813                                         // check cached clusters list
814                                         for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
815                                                 if (CHECKPVSBIT(sv_writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
816                                                         break;
817                                         if (i == ed->priv.server->pvs_numclusters)
818                                         {
819                                                 sv_writeentitiestoclient_culled_pvs++;
820                                                 return;
821                                         }
822                                 }
823                         }
824
825                         // or not seen by random tracelines
826                         if (sv_cullentities_trace.integer && !isbmodel)
827                         {
828                                 // LordHavoc: test center first
829                                 testorigin[0] = (ed->priv.server->cullmins[0] + ed->priv.server->cullmaxs[0]) * 0.5f;
830                                 testorigin[1] = (ed->priv.server->cullmins[1] + ed->priv.server->cullmaxs[1]) * 0.5f;
831                                 testorigin[2] = (ed->priv.server->cullmins[2] + ed->priv.server->cullmaxs[2]) * 0.5f;
832                                 sv.worldmodel->TraceBox(sv.worldmodel, 0, &trace, sv_writeentitiestoclient_testeye, sv_writeentitiestoclient_testeye, testorigin, testorigin, SUPERCONTENTS_SOLID);
833                                 if (trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
834                                         sv_writeentitiestoclient_client->visibletime[s->number] = realtime + 1;
835                                 else
836                                 {
837                                         // LordHavoc: test random offsets, to maximize chance of detection
838                                         testorigin[0] = lhrandom(ed->priv.server->cullmins[0], ed->priv.server->cullmaxs[0]);
839                                         testorigin[1] = lhrandom(ed->priv.server->cullmins[1], ed->priv.server->cullmaxs[1]);
840                                         testorigin[2] = lhrandom(ed->priv.server->cullmins[2], ed->priv.server->cullmaxs[2]);
841                                         sv.worldmodel->TraceBox(sv.worldmodel, 0, &trace, sv_writeentitiestoclient_testeye, sv_writeentitiestoclient_testeye, testorigin, testorigin, SUPERCONTENTS_SOLID);
842                                         if (trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
843                                                 sv_writeentitiestoclient_client->visibletime[s->number] = realtime + 1;
844                                         else
845                                         {
846                                                 if (s->specialvisibilityradius)
847                                                 {
848                                                         // LordHavoc: test random offsets, to maximize chance of detection
849                                                         testorigin[0] = lhrandom(ed->priv.server->cullmins[0], ed->priv.server->cullmaxs[0]);
850                                                         testorigin[1] = lhrandom(ed->priv.server->cullmins[1], ed->priv.server->cullmaxs[1]);
851                                                         testorigin[2] = lhrandom(ed->priv.server->cullmins[2], ed->priv.server->cullmaxs[2]);
852                                                         sv.worldmodel->TraceBox(sv.worldmodel, 0, &trace, sv_writeentitiestoclient_testeye, sv_writeentitiestoclient_testeye, testorigin, testorigin, SUPERCONTENTS_SOLID);
853                                                         if (trace.fraction == 1 || BoxesOverlap(trace.endpos, trace.endpos, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
854                                                                 sv_writeentitiestoclient_client->visibletime[s->number] = realtime + 1;
855                                                 }
856                                         }
857                                 }
858                                 if (realtime > sv_writeentitiestoclient_client->visibletime[s->number])
859                                 {
860                                         sv_writeentitiestoclient_culled_trace++;
861                                         return;
862                                 }
863                         }
864                 }
865         }
866
867         // this just marks it for sending
868         // FIXME: it would be more efficient to send here, but the entity
869         // compressor isn't that flexible
870         sv_writeentitiestoclient_visibleentities++;
871         sententities[s->number] = sententitiesmark;
872 }
873
874 entity_state_t sendstates[MAX_EDICTS];
875 extern int csqc_clent;
876
877 void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *msg, int *stats)
878 {
879         int i, numsendstates;
880         entity_state_t *s;
881
882         // if there isn't enough space to accomplish anything, skip it
883         if (msg->cursize + 25 > msg->maxsize)
884                 return;
885
886         sv_writeentitiestoclient_client = client;
887
888         sv_writeentitiestoclient_culled_pvs = 0;
889         sv_writeentitiestoclient_culled_trace = 0;
890         sv_writeentitiestoclient_visibleentities = 0;
891         sv_writeentitiestoclient_totalentities = 0;
892
893 // find the client's PVS
894         // the real place being tested from
895         VectorAdd(clent->fields.server->origin, clent->fields.server->view_ofs, sv_writeentitiestoclient_testeye);
896         sv_writeentitiestoclient_pvsbytes = 0;
897         if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
898                 sv_writeentitiestoclient_pvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, sv_writeentitiestoclient_testeye, 8, sv_writeentitiestoclient_pvs, sizeof(sv_writeentitiestoclient_pvs));
899
900         csqc_clent = sv_writeentitiestoclient_clentnum = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
901
902         sententitiesmark++;
903
904         for (i = 0;i < numsendentities;i++)
905                 SV_MarkWriteEntityStateToClient(sendentities + i);
906
907         numsendstates = 0;
908         for (i = 0;i < numsendentities;i++)
909         {
910                 if (sententities[sendentities[i].number] == sententitiesmark)
911                 {
912                         s = &sendstates[numsendstates++];
913                         *s = sendentities[i];
914                         if (s->exteriormodelforclient && s->exteriormodelforclient == sv_writeentitiestoclient_clentnum)
915                                 s->flags |= RENDER_EXTERIORMODEL;
916                 }
917         }
918
919         if (sv_cullentities_stats.integer)
920                 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);
921
922         EntityFrameCSQC_WriteFrame(msg, numsendstates, sendstates);
923
924         if (client->entitydatabase5)
925                 EntityFrame5_WriteFrame(msg, client->entitydatabase5, numsendstates, sendstates, client - svs.clients + 1, stats, client->movesequence);
926         else if (client->entitydatabase4)
927                 EntityFrame4_WriteFrame(msg, client->entitydatabase4, numsendstates, sendstates);
928         else if (client->entitydatabase)
929                 EntityFrame_WriteFrame(msg, client->entitydatabase, numsendstates, sendstates, client - svs.clients + 1);
930         else
931                 EntityFrameQuake_WriteFrame(msg, numsendstates, sendstates);
932 }
933
934 /*
935 =============
936 SV_CleanupEnts
937
938 =============
939 */
940 void SV_CleanupEnts (void)
941 {
942         int             e;
943         prvm_edict_t    *ent;
944
945         ent = PRVM_NEXT_EDICT(prog->edicts);
946         for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
947                 ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
948 }
949
950 /*
951 ==================
952 SV_WriteClientdataToMessage
953
954 ==================
955 */
956 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
957 {
958         int             bits;
959         int             i;
960         prvm_edict_t    *other;
961         int             items;
962         prvm_eval_t     *val;
963         vec3_t  punchvector;
964         unsigned char   viewzoom;
965         const char *s;
966
967 //
968 // send a damage message
969 //
970         if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
971         {
972                 other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
973                 MSG_WriteByte (msg, svc_damage);
974                 MSG_WriteByte (msg, ent->fields.server->dmg_save);
975                 MSG_WriteByte (msg, ent->fields.server->dmg_take);
976                 for (i=0 ; i<3 ; i++)
977                         MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
978
979                 ent->fields.server->dmg_take = 0;
980                 ent->fields.server->dmg_save = 0;
981         }
982
983 //
984 // send the current viewpos offset from the view entity
985 //
986         SV_SetIdealPitch ();            // how much to look up / down ideally
987
988 // a fixangle might get lost in a dropped packet.  Oh well.
989         if ( ent->fields.server->fixangle )
990         {
991                 MSG_WriteByte (msg, svc_setangle);
992                 for (i=0 ; i < 3 ; i++)
993                         MSG_WriteAngle (msg, ent->fields.server->angles[i], sv.protocol);
994                 ent->fields.server->fixangle = 0;
995         }
996
997         // stuff the sigil bits into the high bits of items for sbar, or else
998         // mix in items2
999         val = PRVM_GETEDICTFIELDVALUE(ent, eval_items2);
1000         if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
1001                 items = (int)ent->fields.server->items | ((int)val->_float << 23);
1002         else
1003                 items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
1004
1005         VectorClear(punchvector);
1006         if ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_punchvector)))
1007                 VectorCopy(val->vector, punchvector);
1008
1009         // cache weapon model name and index in client struct to save time
1010         // (this search can be almost 1% of cpu time!)
1011         s = PRVM_GetString(ent->fields.server->weaponmodel);
1012         if (strcmp(s, client->weaponmodel))
1013         {
1014                 strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
1015                 client->weaponmodelindex = SV_ModelIndex(s, 1);
1016         }
1017
1018         viewzoom = 255;
1019         if ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_viewzoom)))
1020                 viewzoom = val->_float * 255.0f;
1021         if (viewzoom == 0)
1022                 viewzoom = 255;
1023
1024         bits = 0;
1025
1026         if ((int)ent->fields.server->flags & FL_ONGROUND)
1027                 bits |= SU_ONGROUND;
1028         if (ent->fields.server->waterlevel >= 2)
1029                 bits |= SU_INWATER;
1030         if (ent->fields.server->idealpitch)
1031                 bits |= SU_IDEALPITCH;
1032
1033         for (i=0 ; i<3 ; i++)
1034         {
1035                 if (ent->fields.server->punchangle[i])
1036                         bits |= (SU_PUNCH1<<i);
1037                 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE)
1038                         if (punchvector[i])
1039                                 bits |= (SU_PUNCHVEC1<<i);
1040                 if (ent->fields.server->velocity[i])
1041                         bits |= (SU_VELOCITY1<<i);
1042         }
1043
1044         memset(stats, 0, sizeof(int[MAX_CL_STATS]));
1045         stats[STAT_VIEWHEIGHT] = ent->fields.server->view_ofs[2];
1046         stats[STAT_ITEMS] = items;
1047         stats[STAT_WEAPONFRAME] = ent->fields.server->weaponframe;
1048         stats[STAT_ARMOR] = ent->fields.server->armorvalue;
1049         stats[STAT_WEAPON] = client->weaponmodelindex;
1050         stats[STAT_HEALTH] = ent->fields.server->health;
1051         stats[STAT_AMMO] = ent->fields.server->currentammo;
1052         stats[STAT_SHELLS] = ent->fields.server->ammo_shells;
1053         stats[STAT_NAILS] = ent->fields.server->ammo_nails;
1054         stats[STAT_ROCKETS] = ent->fields.server->ammo_rockets;
1055         stats[STAT_CELLS] = ent->fields.server->ammo_cells;
1056         stats[STAT_ACTIVEWEAPON] = ent->fields.server->weapon;
1057         stats[STAT_VIEWZOOM] = viewzoom;
1058         // the QC bumps these itself by sending svc_'s, so we have to keep them
1059         // zero or they'll be corrected by the engine
1060         //stats[STAT_TOTALSECRETS] = prog->globals.server->total_secrets;
1061         //stats[STAT_TOTALMONSTERS] = prog->globals.server->total_monsters;
1062         //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
1063         //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
1064
1065         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)
1066         {
1067                 if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
1068                 bits |= SU_ITEMS;
1069                 if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
1070                 if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
1071                 bits |= SU_WEAPON;
1072                 // FIXME: which protocols support this?  does PROTOCOL_DARKPLACES3 support viewzoom?
1073                 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1074                         if (viewzoom != 255)
1075                                 bits |= SU_VIEWZOOM;
1076         }
1077
1078         if (bits >= 65536)
1079                 bits |= SU_EXTEND1;
1080         if (bits >= 16777216)
1081                 bits |= SU_EXTEND2;
1082
1083         // send the data
1084         MSG_WriteByte (msg, svc_clientdata);
1085         MSG_WriteShort (msg, bits);
1086         if (bits & SU_EXTEND1)
1087                 MSG_WriteByte(msg, bits >> 16);
1088         if (bits & SU_EXTEND2)
1089                 MSG_WriteByte(msg, bits >> 24);
1090
1091         if (bits & SU_VIEWHEIGHT)
1092                 MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
1093
1094         if (bits & SU_IDEALPITCH)
1095                 MSG_WriteChar (msg, ent->fields.server->idealpitch);
1096
1097         for (i=0 ; i<3 ; i++)
1098         {
1099                 if (bits & (SU_PUNCH1<<i))
1100                 {
1101                         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
1102                                 MSG_WriteChar(msg, ent->fields.server->punchangle[i]);
1103                         else
1104                                 MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
1105                 }
1106                 if (bits & (SU_PUNCHVEC1<<i))
1107                 {
1108                         if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1109                                 MSG_WriteCoord16i(msg, punchvector[i]);
1110                         else
1111                                 MSG_WriteCoord32f(msg, punchvector[i]);
1112                 }
1113                 if (bits & (SU_VELOCITY1<<i))
1114                 {
1115                         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1116                                 MSG_WriteChar(msg, ent->fields.server->velocity[i] * (1.0f / 16.0f));
1117                         else
1118                                 MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
1119                 }
1120         }
1121
1122         if (bits & SU_ITEMS)
1123                 MSG_WriteLong (msg, stats[STAT_ITEMS]);
1124
1125         if (sv.protocol == PROTOCOL_DARKPLACES5)
1126         {
1127                 if (bits & SU_WEAPONFRAME)
1128                         MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
1129                 if (bits & SU_ARMOR)
1130                         MSG_WriteShort (msg, stats[STAT_ARMOR]);
1131                 if (bits & SU_WEAPON)
1132                         MSG_WriteShort (msg, stats[STAT_WEAPON]);
1133                 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1134                 MSG_WriteShort (msg, stats[STAT_AMMO]);
1135                 MSG_WriteShort (msg, stats[STAT_SHELLS]);
1136                 MSG_WriteShort (msg, stats[STAT_NAILS]);
1137                 MSG_WriteShort (msg, stats[STAT_ROCKETS]);
1138                 MSG_WriteShort (msg, stats[STAT_CELLS]);
1139                 MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
1140                 if (bits & SU_VIEWZOOM)
1141                         MSG_WriteShort (msg, min(stats[STAT_VIEWZOOM], 65535));
1142         }
1143         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)
1144         {
1145                 if (bits & SU_WEAPONFRAME)
1146                         MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
1147                 if (bits & SU_ARMOR)
1148                         MSG_WriteByte (msg, stats[STAT_ARMOR]);
1149                 if (bits & SU_WEAPON)
1150                         MSG_WriteByte (msg, stats[STAT_WEAPON]);
1151                 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1152                 MSG_WriteByte (msg, stats[STAT_AMMO]);
1153                 MSG_WriteByte (msg, stats[STAT_SHELLS]);
1154                 MSG_WriteByte (msg, stats[STAT_NAILS]);
1155                 MSG_WriteByte (msg, stats[STAT_ROCKETS]);
1156                 MSG_WriteByte (msg, stats[STAT_CELLS]);
1157                 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_NEXUIZ)
1158                 {
1159                         for (i = 0;i < 32;i++)
1160                                 if (stats[STAT_WEAPON] & (1<<i))
1161                                         break;
1162                         MSG_WriteByte (msg, i);
1163                 }
1164                 else
1165                         MSG_WriteByte (msg, stats[STAT_WEAPON]);
1166                 if (bits & SU_VIEWZOOM)
1167                 {
1168                         if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1169                                 MSG_WriteByte (msg, min(stats[STAT_VIEWZOOM], 255));
1170                         else
1171                                 MSG_WriteShort (msg, min(stats[STAT_VIEWZOOM], 65535));
1172                 }
1173         }
1174 }
1175
1176 /*
1177 =======================
1178 SV_SendClientDatagram
1179 =======================
1180 */
1181 static unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE]; // FIXME?
1182 void SV_SendClientDatagram (client_t *client)
1183 {
1184         int rate, maxrate, maxsize, maxsize2;
1185         sizebuf_t msg;
1186         int stats[MAX_CL_STATS];
1187
1188         if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !sv_ratelimitlocalplayer.integer)
1189         {
1190                 // for good singleplayer, send huge packets
1191                 maxsize = sizeof(sv_sendclientdatagram_buf);
1192                 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1193         }
1194         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)
1195         {
1196                 // no rate limiting support on older protocols because dp protocols
1197                 // 1-4 kick the client off if they overflow, and quake protocol shows
1198                 // less than the full entity set if rate limited
1199                 maxsize = 1400;
1200                 maxsize2 = 1400;
1201         }
1202         else
1203         {
1204                 // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
1205                 maxrate = bound(NET_MINRATE, sv_maxrate.integer, NET_MAXRATE);
1206                 if (sv_maxrate.integer != maxrate)
1207                         Cvar_SetValueQuick(&sv_maxrate, maxrate);
1208
1209                 // this rate limiting does not understand sys_ticrate 0
1210                 // (but no one should be running that on a server!)
1211                 rate = bound(NET_MINRATE, client->rate, maxrate);
1212                 rate = (int)(client->rate * sys_ticrate.value);
1213                 maxsize = bound(100, rate, 1400);
1214                 maxsize2 = 1400;
1215         }
1216
1217         msg.data = sv_sendclientdatagram_buf;
1218         msg.maxsize = maxsize;
1219         msg.cursize = 0;
1220
1221         if (host_client->spawned)
1222         {
1223                 MSG_WriteByte (&msg, svc_time);
1224                 MSG_WriteFloat (&msg, sv.time);
1225
1226                 // add the client specific data to the datagram
1227                 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
1228                 VM_SV_WriteAutoSentStats (client, client->edict, &msg, stats);
1229                 SV_WriteEntitiesToClient (client, client->edict, &msg, stats);
1230
1231                 // expand packet size to allow effects to go over the rate limit
1232                 // (dropping them is FAR too ugly)
1233                 msg.maxsize = maxsize2;
1234
1235                 // copy the server datagram if there is space
1236                 // FIXME: put in delayed queue of effects to send
1237                 if (sv.datagram.cursize > 0 && msg.cursize + sv.datagram.cursize <= msg.maxsize)
1238                         SZ_Write (&msg, sv.datagram.data, sv.datagram.cursize);
1239         }
1240         else if (realtime > client->keepalivetime)
1241         {
1242                 // the player isn't totally in the game yet
1243                 // send small keepalive messages if too much time has passed
1244                 client->keepalivetime = realtime + 5;
1245                 MSG_WriteChar (&msg, svc_nop);
1246         }
1247
1248 // send the datagram
1249         NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol);
1250 }
1251
1252 /*
1253 =======================
1254 SV_UpdateToReliableMessages
1255 =======================
1256 */
1257 void SV_UpdateToReliableMessages (void)
1258 {
1259         int i, j;
1260         client_t *client;
1261         prvm_eval_t *val;
1262         const char *name;
1263         const char *model;
1264         const char *skin;
1265
1266 // check for changes to be sent over the reliable streams
1267         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1268         {
1269                 // update the host_client fields we care about according to the entity fields
1270                 host_client->edict = PRVM_EDICT_NUM(i+1);
1271
1272                 // DP_SV_CLIENTNAME
1273                 name = PRVM_GetString(host_client->edict->fields.server->netname);
1274                 if (name == NULL)
1275                         name = "";
1276                 // always point the string back at host_client->name to keep it safe
1277                 strlcpy (host_client->name, name, sizeof (host_client->name));
1278                 host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
1279                 if (strcmp(host_client->old_name, host_client->name))
1280                 {
1281                         if (host_client->spawned)
1282                                 SV_BroadcastPrintf("%s changed name to %s\n", host_client->old_name, host_client->name);
1283                         strcpy(host_client->old_name, host_client->name);
1284                         // send notification to all clients
1285                         MSG_WriteByte (&sv.reliable_datagram, svc_updatename);
1286                         MSG_WriteByte (&sv.reliable_datagram, i);
1287                         MSG_WriteString (&sv.reliable_datagram, host_client->name);
1288                 }
1289
1290                 // DP_SV_CLIENTCOLORS
1291                 // this is always found (since it's added by the progs loader)
1292                 if ((val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
1293                         host_client->colors = (int)val->_float;
1294                 if (host_client->old_colors != host_client->colors)
1295                 {
1296                         host_client->old_colors = host_client->colors;
1297                         // send notification to all clients
1298                         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1299                         MSG_WriteByte (&sv.reliable_datagram, i);
1300                         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1301                 }
1302
1303                 // NEXUIZ_PLAYERMODEL
1304                 if( eval_playermodel ) {
1305                         model = PRVM_GetString(PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string);
1306                         if (model == NULL)
1307                                 model = "";
1308                         // always point the string back at host_client->name to keep it safe
1309                         strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
1310                         PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
1311                 }
1312
1313                 // NEXUIZ_PLAYERSKIN
1314                 if( eval_playerskin ) {
1315                         skin = PRVM_GetString(PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string);
1316                         if (skin == NULL)
1317                                 skin = "";
1318                         // always point the string back at host_client->name to keep it safe
1319                         strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
1320                         PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
1321                 }
1322
1323                 // frags
1324                 host_client->frags = (int)host_client->edict->fields.server->frags;
1325                 if (host_client->old_frags != host_client->frags)
1326                 {
1327                         host_client->old_frags = host_client->frags;
1328                         // send notification to all clients
1329                         MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
1330                         MSG_WriteByte (&sv.reliable_datagram, i);
1331                         MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
1332                 }
1333         }
1334
1335         for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1336                 if (client->netconnection)
1337                         SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
1338
1339         SZ_Clear (&sv.reliable_datagram);
1340 }
1341
1342
1343 /*
1344 =======================
1345 SV_SendClientMessages
1346 =======================
1347 */
1348 void SV_SendClientMessages (void)
1349 {
1350         int i, prepared = false;
1351
1352         if (sv.protocol == PROTOCOL_QUAKEWORLD)
1353                 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
1354
1355 // update frags, names, etc
1356         SV_UpdateToReliableMessages();
1357
1358 // build individual updates
1359         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1360         {
1361                 if (!host_client->active)
1362                         continue;
1363                 if (!host_client->netconnection)
1364                         continue;
1365
1366                 if (host_client->netconnection->message.overflowed)
1367                 {
1368                         SV_DropClient (true);   // if the message couldn't send, kick off
1369                         continue;
1370                 }
1371
1372                 if (!prepared)
1373                 {
1374                         prepared = true;
1375                         // only prepare entities once per frame
1376                         SV_PrepareEntitiesForSending();
1377                 }
1378                 SV_SendClientDatagram (host_client);
1379         }
1380
1381 // clear muzzle flashes
1382         SV_CleanupEnts();
1383 }
1384
1385
1386 /*
1387 ==============================================================================
1388
1389 SERVER SPAWNING
1390
1391 ==============================================================================
1392 */
1393
1394 /*
1395 ================
1396 SV_ModelIndex
1397
1398 ================
1399 */
1400 int SV_ModelIndex(const char *s, int precachemode)
1401 {
1402         int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_MODELS);
1403         char filename[MAX_QPATH];
1404         if (!s || !*s)
1405                 return 0;
1406         // testing
1407         //if (precachemode == 2)
1408         //      return 0;
1409         strlcpy(filename, s, sizeof(filename));
1410         for (i = 2;i < limit;i++)
1411         {
1412                 if (!sv.model_precache[i][0])
1413                 {
1414                         if (precachemode)
1415                         {
1416                                 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))
1417                                 {
1418                                         Con_Printf("SV_ModelIndex(\"%s\"): precache_model can only be done in spawn functions\n", filename);
1419                                         return 0;
1420                                 }
1421                                 if (precachemode == 1)
1422                                         Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
1423                                 strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
1424                                 sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, false);
1425                                 if (sv.state != ss_loading)
1426                                 {
1427                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
1428                                         MSG_WriteShort(&sv.reliable_datagram, i);
1429                                         MSG_WriteString(&sv.reliable_datagram, filename);
1430                                 }
1431                                 return i;
1432                         }
1433                         Con_Printf("SV_ModelIndex(\"%s\"): not precached\n", filename);
1434                         return 0;
1435                 }
1436                 if (!strcmp(sv.model_precache[i], filename))
1437                         return i;
1438         }
1439         Con_Printf("SV_ModelIndex(\"%s\"): i (%i) == MAX_MODELS (%i)\n", filename, i, MAX_MODELS);
1440         return 0;
1441 }
1442
1443 /*
1444 ================
1445 SV_SoundIndex
1446
1447 ================
1448 */
1449 int SV_SoundIndex(const char *s, int precachemode)
1450 {
1451         int i, limit = ((sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE) ? 256 : MAX_SOUNDS);
1452         char filename[MAX_QPATH];
1453         if (!s || !*s)
1454                 return 0;
1455         // testing
1456         //if (precachemode == 2)
1457         //      return 0;
1458         strlcpy(filename, s, sizeof(filename));
1459         for (i = 1;i < limit;i++)
1460         {
1461                 if (!sv.sound_precache[i][0])
1462                 {
1463                         if (precachemode)
1464                         {
1465                                 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))
1466                                 {
1467                                         Con_Printf("SV_SoundIndex(\"%s\"): precache_sound can only be done in spawn functions\n", filename);
1468                                         return 0;
1469                                 }
1470                                 if (precachemode == 1)
1471                                         Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
1472                                 strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
1473                                 if (sv.state != ss_loading)
1474                                 {
1475                                         MSG_WriteByte(&sv.reliable_datagram, svc_precache);
1476                                         MSG_WriteShort(&sv.reliable_datagram, i + 32768);
1477                                         MSG_WriteString(&sv.reliable_datagram, filename);
1478                                 }
1479                                 return i;
1480                         }
1481                         Con_Printf("SV_SoundIndex(\"%s\"): not precached\n", filename);
1482                         return 0;
1483                 }
1484                 if (!strcmp(sv.sound_precache[i], filename))
1485                         return i;
1486         }
1487         Con_Printf("SV_SoundIndex(\"%s\"): i (%i) == MAX_SOUNDS (%i)\n", filename, i, MAX_SOUNDS);
1488         return 0;
1489 }
1490
1491 /*
1492 ================
1493 SV_CreateBaseline
1494
1495 ================
1496 */
1497 void SV_CreateBaseline (void)
1498 {
1499         int i, entnum, large;
1500         prvm_edict_t *svent;
1501
1502         // LordHavoc: clear *all* states (note just active ones)
1503         for (entnum = 0;entnum < prog->max_edicts;entnum++)
1504         {
1505                 // get the current server version
1506                 svent = PRVM_EDICT_NUM(entnum);
1507
1508                 // LordHavoc: always clear state values, whether the entity is in use or not
1509                 svent->priv.server->baseline = defaultstate;
1510
1511                 if (svent->priv.server->free)
1512                         continue;
1513                 if (entnum > svs.maxclients && !svent->fields.server->modelindex)
1514                         continue;
1515
1516                 // create entity baseline
1517                 VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
1518                 VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
1519                 svent->priv.server->baseline.frame = svent->fields.server->frame;
1520                 svent->priv.server->baseline.skin = svent->fields.server->skin;
1521                 if (entnum > 0 && entnum <= svs.maxclients)
1522                 {
1523                         svent->priv.server->baseline.colormap = entnum;
1524                         svent->priv.server->baseline.modelindex = SV_ModelIndex("progs/player.mdl", 1);
1525                 }
1526                 else
1527                 {
1528                         svent->priv.server->baseline.colormap = 0;
1529                         svent->priv.server->baseline.modelindex = svent->fields.server->modelindex;
1530                 }
1531
1532                 large = false;
1533                 if (svent->priv.server->baseline.modelindex & 0xFF00 || svent->priv.server->baseline.frame & 0xFF00)
1534                         large = true;
1535
1536                 // add to the message
1537                 if (large)
1538                         MSG_WriteByte (&sv.signon, svc_spawnbaseline2);
1539                 else
1540                         MSG_WriteByte (&sv.signon, svc_spawnbaseline);
1541                 MSG_WriteShort (&sv.signon, entnum);
1542
1543                 if (large)
1544                 {
1545                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.modelindex);
1546                         MSG_WriteShort (&sv.signon, svent->priv.server->baseline.frame);
1547                 }
1548                 else
1549                 {
1550                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.modelindex);
1551                         MSG_WriteByte (&sv.signon, svent->priv.server->baseline.frame);
1552                 }
1553                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.colormap);
1554                 MSG_WriteByte (&sv.signon, svent->priv.server->baseline.skin);
1555                 for (i=0 ; i<3 ; i++)
1556                 {
1557                         MSG_WriteCoord(&sv.signon, svent->priv.server->baseline.origin[i], sv.protocol);
1558                         MSG_WriteAngle(&sv.signon, svent->priv.server->baseline.angles[i], sv.protocol);
1559                 }
1560         }
1561 }
1562
1563
1564 /*
1565 ================
1566 SV_SaveSpawnparms
1567
1568 Grabs the current state of each client for saving across the
1569 transition to another level
1570 ================
1571 */
1572 void SV_SaveSpawnparms (void)
1573 {
1574         int             i, j;
1575
1576         svs.serverflags = prog->globals.server->serverflags;
1577
1578         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1579         {
1580                 if (!host_client->active)
1581                         continue;
1582
1583         // call the progs to get default spawn parms for the new client
1584                 prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1585                 PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
1586                 for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
1587                         host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
1588         }
1589 }
1590 /*
1591 void SV_IncreaseEdicts(void)
1592 {
1593         int i;
1594         prvm_edict_t *ent;
1595         int oldmax_edicts = prog->max_edicts;
1596         void *oldedictsengineprivate = prog->edictprivate;
1597         void *oldedictsfields = prog->edictsfields;
1598         void *oldmoved_edicts = sv.moved_edicts;
1599
1600         if (prog->max_edicts >= MAX_EDICTS)
1601                 return;
1602
1603         // links don't survive the transition, so unlink everything
1604         for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
1605         {
1606                 if (!ent->priv.server->free)
1607                         SV_UnlinkEdict(prog->edicts + i);
1608                 memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid));
1609         }
1610         SV_ClearWorld();
1611
1612         prog->max_edicts   = min(prog->max_edicts + 256, MAX_EDICTS);
1613         prog->edictprivate = PR_Alloc(prog->max_edicts * sizeof(edict_engineprivate_t));
1614         prog->edictsfields = PR_Alloc(prog->max_edicts * prog->edict_size);
1615         sv.moved_edicts = PR_Alloc(prog->max_edicts * sizeof(prvm_edict_t *));
1616
1617         memcpy(prog->edictprivate, oldedictsengineprivate, oldmax_edicts * sizeof(edict_engineprivate_t));
1618         memcpy(prog->edictsfields, oldedictsfields, oldmax_edicts * prog->edict_size);
1619
1620         for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
1621         {
1622                 ent->priv.vp = (unsigned char*) prog->edictprivate + i * prog->edictprivate_size;
1623                 ent->fields.server = (void *)((unsigned char *)prog->edictsfields + i * prog->edict_size);
1624                 // link every entity except world
1625                 if (!ent->priv.server->free)
1626                         SV_LinkEdict(ent, false);
1627         }
1628
1629         PR_Free(oldedictsengineprivate);
1630         PR_Free(oldedictsfields);
1631         PR_Free(oldmoved_edicts);
1632 }*/
1633
1634 /*
1635 ================
1636 SV_SpawnServer
1637
1638 This is called at the start of each level
1639 ================
1640 */
1641 extern float            scr_centertime_off;
1642
1643 void SV_SpawnServer (const char *server)
1644 {
1645         prvm_edict_t *ent;
1646         int i;
1647         char *entities;
1648         model_t *worldmodel;
1649         char modelname[sizeof(sv.modelname)];
1650
1651         Con_DPrintf("SpawnServer: %s\n", server);
1652
1653         if (cls.state != ca_dedicated)
1654                 SCR_BeginLoadingPlaque();
1655
1656         dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
1657         worldmodel = Mod_ForName(modelname, false, true, true);
1658         if (!worldmodel || !worldmodel->TraceBox)
1659         {
1660                 Con_Printf("Couldn't load map %s\n", modelname);
1661                 return;
1662         }
1663
1664         // let's not have any servers with no name
1665         if (hostname.string[0] == 0)
1666                 Cvar_Set ("hostname", "UNNAMED");
1667         scr_centertime_off = 0;
1668
1669         svs.changelevel_issued = false;         // now safe to issue another
1670
1671 //
1672 // tell all connected clients that we are going to a new level
1673 //
1674         if (sv.active)
1675         {
1676                 client_t *client;
1677                 for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1678                 {
1679                         if (client->netconnection)
1680                         {
1681                                 MSG_WriteByte(&client->netconnection->message, svc_stufftext);
1682                                 MSG_WriteString(&client->netconnection->message, "reconnect\n");
1683                         }
1684                 }
1685         }
1686         else
1687         {
1688                 // open server port
1689                 NetConn_OpenServerPorts(true);
1690         }
1691
1692 //
1693 // make cvars consistant
1694 //
1695         if (coop.integer)
1696                 Cvar_SetValue ("deathmatch", 0);
1697         // LordHavoc: it can be useful to have skills outside the range 0-3...
1698         //current_skill = bound(0, (int)(skill.value + 0.5), 3);
1699         //Cvar_SetValue ("skill", (float)current_skill);
1700         current_skill = (int)(skill.value + 0.5);
1701
1702 //
1703 // set up the new server
1704 //
1705         memset (&sv, 0, sizeof(sv));
1706
1707         SV_VM_Setup();
1708
1709         sv.active = true;
1710
1711         strlcpy (sv.name, server, sizeof (sv.name));
1712
1713         sv.protocol = Protocol_EnumForName(sv_protocolname.string);
1714         if (sv.protocol == PROTOCOL_UNKNOWN)
1715         {
1716                 char buffer[1024];
1717                 Protocol_Names(buffer, sizeof(buffer));
1718                 Con_Printf("Unknown sv_protocolname \"%s\", valid values are:\n%s\n", sv_protocolname.string, buffer);
1719                 sv.protocol = PROTOCOL_QUAKE;
1720         }
1721
1722         SV_VM_Begin();
1723
1724 // load progs to get entity field count
1725         //PR_LoadProgs ( sv_progs.string );
1726
1727         // allocate server memory
1728         /*// start out with just enough room for clients and a reasonable estimate of entities
1729         prog->max_edicts = max(svs.maxclients + 1, 512);
1730         prog->max_edicts = min(prog->max_edicts, MAX_EDICTS);
1731
1732         // prvm_edict_t structures (hidden from progs)
1733         prog->edicts = PR_Alloc(MAX_EDICTS * sizeof(prvm_edict_t));
1734         // engine private structures (hidden from progs)
1735         prog->edictprivate = PR_Alloc(prog->max_edicts * sizeof(edict_engineprivate_t));
1736         // progs fields, often accessed by server
1737         prog->edictsfields = PR_Alloc(prog->max_edicts * prog->edict_size);*/
1738         // used by PushMove to move back pushed entities
1739         sv.moved_edicts = (prvm_edict_t **)PRVM_Alloc(prog->max_edicts * sizeof(prvm_edict_t *));
1740         /*for (i = 0;i < prog->max_edicts;i++)
1741         {
1742                 ent = prog->edicts + i;
1743                 ent->priv.vp = (unsigned char*) prog->edictprivate + i * prog->edictprivate_size;
1744                 ent->fields.server = (void *)((unsigned char *)prog->edictsfields + i * prog->edict_size);
1745         }*/
1746
1747         // reset client csqc entity versions right away.
1748         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1749                 EntityFrameCSQC_InitClientVersions(i, true);
1750
1751         sv.datagram.maxsize = sizeof(sv.datagram_buf);
1752         sv.datagram.cursize = 0;
1753         sv.datagram.data = sv.datagram_buf;
1754
1755         sv.reliable_datagram.maxsize = sizeof(sv.reliable_datagram_buf);
1756         sv.reliable_datagram.cursize = 0;
1757         sv.reliable_datagram.data = sv.reliable_datagram_buf;
1758
1759         sv.signon.maxsize = sizeof(sv.signon_buf);
1760         sv.signon.cursize = 0;
1761         sv.signon.data = sv.signon_buf;
1762
1763 // leave slots at start for clients only
1764         //prog->num_edicts = svs.maxclients+1;
1765
1766         sv.state = ss_loading;
1767         prog->allowworldwrites = true;
1768         sv.paused = false;
1769
1770         *prog->time = sv.time = 1.0;
1771
1772         Mod_ClearUsed();
1773         worldmodel->used = true;
1774
1775         strlcpy (sv.name, server, sizeof (sv.name));
1776         strcpy(sv.modelname, modelname);
1777         sv.worldmodel = worldmodel;
1778         sv.models[1] = sv.worldmodel;
1779
1780 //
1781 // clear world interaction links
1782 //
1783         SV_ClearWorld ();
1784
1785         strlcpy(sv.sound_precache[0], "", sizeof(sv.sound_precache[0]));
1786
1787         strlcpy(sv.model_precache[0], "", sizeof(sv.model_precache[0]));
1788         strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
1789         for (i = 1;i < sv.worldmodel->brush.numsubmodels;i++)
1790         {
1791                 dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
1792                 sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, false);
1793         }
1794
1795 //
1796 // load the rest of the entities
1797 //
1798         // AK possible hack since num_edicts is still 0
1799         ent = PRVM_EDICT_NUM(0);
1800         memset (ent->fields.server, 0, prog->progs->entityfields * 4);
1801         ent->priv.server->free = false;
1802         ent->fields.server->model = PRVM_SetEngineString(sv.modelname);
1803         ent->fields.server->modelindex = 1;             // world model
1804         ent->fields.server->solid = SOLID_BSP;
1805         ent->fields.server->movetype = MOVETYPE_PUSH;
1806
1807         if (coop.value)
1808                 prog->globals.server->coop = coop.integer;
1809         else
1810                 prog->globals.server->deathmatch = deathmatch.integer;
1811
1812         prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
1813
1814 // serverflags are for cross level information (sigils)
1815         prog->globals.server->serverflags = svs.serverflags;
1816
1817         // we need to reset the spawned flag on all connected clients here so that
1818         // their thinks don't run during startup (before PutClientInServer)
1819         // we also need to set up the client entities now
1820         // and we need to set the ->edict pointers to point into the progs edicts
1821         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1822         {
1823                 host_client->spawned = false;
1824                 host_client->edict = PRVM_EDICT_NUM(i + 1);
1825                 PRVM_ED_ClearEdict(host_client->edict);
1826         }
1827
1828         // load replacement entity file if found
1829         if (sv_entpatch.integer && (entities = (char *)FS_LoadFile(va("maps/%s.ent", sv.name), tempmempool, true, NULL)))
1830         {
1831                 Con_Printf("Loaded maps/%s.ent\n", sv.name);
1832                 PRVM_ED_LoadFromFile (entities);
1833                 Mem_Free(entities);
1834         }
1835         else
1836                 PRVM_ED_LoadFromFile (sv.worldmodel->brush.entities);
1837
1838
1839         // LordHavoc: clear world angles (to fix e3m3.bsp)
1840         VectorClear(prog->edicts->fields.server->angles);
1841
1842 // all setup is completed, any further precache statements are errors
1843         sv.state = ss_active;
1844         prog->allowworldwrites = false;
1845
1846 // run two frames to allow everything to settle
1847         for (i = 0;i < 2;i++)
1848         {
1849                 sv.frametime = host_frametime = 0.1;
1850                 SV_Physics ();
1851         }
1852
1853         Mod_PurgeUnused();
1854
1855 // create a baseline for more efficient communications
1856         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE)
1857                 SV_CreateBaseline ();
1858
1859 // send serverinfo to all connected clients, and set up botclients coming back from a level change
1860         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1861         {
1862                 if (!host_client->active)
1863                         continue;
1864                 if (host_client->netconnection)
1865                         SV_SendServerinfo(host_client);
1866                 else
1867                 {
1868                         int j;
1869                         // if client is a botclient coming from a level change, we need to
1870                         // set up client info that normally requires networking
1871
1872                         // copy spawn parms out of the client_t
1873                         for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
1874                                 (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
1875
1876                         // call the spawn function
1877                         host_client->clientconnectcalled = true;
1878                         prog->globals.server->time = sv.time;
1879                         prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
1880                         PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
1881                         PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
1882                         host_client->spawned = true;
1883                 }
1884         }
1885
1886         Con_DPrint("Server spawned.\n");
1887         NetConn_Heartbeat (2);
1888
1889         SV_VM_End();
1890 }
1891
1892 /////////////////////////////////////////////////////
1893 // SV VM stuff
1894
1895 void SV_VM_CB_BeginIncreaseEdicts(void)
1896 {
1897         int i;
1898         prvm_edict_t *ent;
1899
1900         PRVM_Free( sv.moved_edicts );
1901         sv.moved_edicts = (prvm_edict_t **)PRVM_Alloc(prog->max_edicts * sizeof(prvm_edict_t *));
1902
1903         // links don't survive the transition, so unlink everything
1904         for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
1905         {
1906                 if (!ent->priv.server->free)
1907                         SV_UnlinkEdict(prog->edicts + i);
1908                 memset(&ent->priv.server->areagrid, 0, sizeof(ent->priv.server->areagrid));
1909         }
1910         SV_ClearWorld();
1911 }
1912
1913 void SV_VM_CB_EndIncreaseEdicts(void)
1914 {
1915         int i;
1916         prvm_edict_t *ent;
1917
1918         for (i = 0, ent = prog->edicts;i < prog->max_edicts;i++, ent++)
1919         {
1920                 // link every entity except world
1921                 if (!ent->priv.server->free)
1922                         SV_LinkEdict(ent, false);
1923         }
1924 }
1925
1926 void SV_VM_CB_InitEdict(prvm_edict_t *e)
1927 {
1928         // LordHavoc: for consistency set these here
1929         int num = PRVM_NUM_FOR_EDICT(e) - 1;
1930
1931         e->priv.server->move = false; // don't move on first frame
1932
1933         if (num >= 0 && num < svs.maxclients)
1934         {
1935                 prvm_eval_t *val;
1936                 // set colormap and team on newly created player entity
1937                 e->fields.server->colormap = num + 1;
1938                 e->fields.server->team = (svs.clients[num].colors & 15) + 1;
1939                 // set netname/clientcolors back to client values so that
1940                 // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
1941                 // reset them
1942                 e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
1943                 if ((val = PRVM_GETEDICTFIELDVALUE(e, eval_clientcolors)))
1944                         val->_float = svs.clients[num].colors;
1945                 // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
1946                 if( eval_playermodel )
1947                         PRVM_GETEDICTFIELDVALUE(e, eval_playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
1948                 if( eval_playerskin )
1949                         PRVM_GETEDICTFIELDVALUE(e, eval_playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
1950         }
1951 }
1952
1953 void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
1954 {
1955         SV_UnlinkEdict (ed);            // unlink from world bsp
1956
1957         ed->fields.server->model = 0;
1958         ed->fields.server->takedamage = 0;
1959         ed->fields.server->modelindex = 0;
1960         ed->fields.server->colormap = 0;
1961         ed->fields.server->skin = 0;
1962         ed->fields.server->frame = 0;
1963         VectorClear(ed->fields.server->origin);
1964         VectorClear(ed->fields.server->angles);
1965         ed->fields.server->nextthink = -1;
1966         ed->fields.server->solid = 0;
1967 }
1968
1969 void SV_VM_CB_CountEdicts(void)
1970 {
1971         int             i;
1972         prvm_edict_t    *ent;
1973         int             active, models, solid, step;
1974
1975         active = models = solid = step = 0;
1976         for (i=0 ; i<prog->num_edicts ; i++)
1977         {
1978                 ent = PRVM_EDICT_NUM(i);
1979                 if (ent->priv.server->free)
1980                         continue;
1981                 active++;
1982                 if (ent->fields.server->solid)
1983                         solid++;
1984                 if (ent->fields.server->model)
1985                         models++;
1986                 if (ent->fields.server->movetype == MOVETYPE_STEP)
1987                         step++;
1988         }
1989
1990         Con_Printf("num_edicts:%3i\n", prog->num_edicts);
1991         Con_Printf("active    :%3i\n", active);
1992         Con_Printf("view      :%3i\n", models);
1993         Con_Printf("touch     :%3i\n", solid);
1994         Con_Printf("step      :%3i\n", step);
1995 }
1996
1997 qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
1998 {
1999         // remove things from different skill levels or deathmatch
2000         if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
2001         {
2002                 if (deathmatch.integer)
2003                 {
2004                         if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
2005                         {
2006                                 return false;
2007                         }
2008                 }
2009                 else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY  ))
2010                         || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
2011                         || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD  )))
2012                 {
2013                         return false;
2014                 }
2015         }
2016         return true;
2017 }
2018
2019 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)"};
2020 cvar_t nomonsters = {0, "nomonsters", "0", "unused cvar in quake, can be used by mods"};
2021 cvar_t gamecfg = {0, "gamecfg", "0", "unused cvar in quake, can be used by mods"};
2022 cvar_t scratch1 = {0, "scratch1", "0", "unused cvar in quake, can be used by mods"};
2023 cvar_t scratch2 = {0,"scratch2", "0", "unused cvar in quake, can be used by mods"};
2024 cvar_t scratch3 = {0, "scratch3", "0", "unused cvar in quake, can be used by mods"};
2025 cvar_t scratch4 = {0, "scratch4", "0", "unused cvar in quake, can be used by mods"};
2026 cvar_t savedgamecfg = {CVAR_SAVE, "savedgamecfg", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2027 cvar_t saved1 = {CVAR_SAVE, "saved1", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2028 cvar_t saved2 = {CVAR_SAVE, "saved2", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2029 cvar_t saved3 = {CVAR_SAVE, "saved3", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2030 cvar_t saved4 = {CVAR_SAVE, "saved4", "0", "unused cvar in quake that is saved to config.cfg on exit, can be used by mods"};
2031 cvar_t nehx00 = {0, "nehx00", "0", "nehahra data storage cvar (used in singleplayer)"};
2032 cvar_t nehx01 = {0, "nehx01", "0", "nehahra data storage cvar (used in singleplayer)"};
2033 cvar_t nehx02 = {0, "nehx02", "0", "nehahra data storage cvar (used in singleplayer)"};
2034 cvar_t nehx03 = {0, "nehx03", "0", "nehahra data storage cvar (used in singleplayer)"};
2035 cvar_t nehx04 = {0, "nehx04", "0", "nehahra data storage cvar (used in singleplayer)"};
2036 cvar_t nehx05 = {0, "nehx05", "0", "nehahra data storage cvar (used in singleplayer)"};
2037 cvar_t nehx06 = {0, "nehx06", "0", "nehahra data storage cvar (used in singleplayer)"};
2038 cvar_t nehx07 = {0, "nehx07", "0", "nehahra data storage cvar (used in singleplayer)"};
2039 cvar_t nehx08 = {0, "nehx08", "0", "nehahra data storage cvar (used in singleplayer)"};
2040 cvar_t nehx09 = {0, "nehx09", "0", "nehahra data storage cvar (used in singleplayer)"};
2041 cvar_t nehx10 = {0, "nehx10", "0", "nehahra data storage cvar (used in singleplayer)"};
2042 cvar_t nehx11 = {0, "nehx11", "0", "nehahra data storage cvar (used in singleplayer)"};
2043 cvar_t nehx12 = {0, "nehx12", "0", "nehahra data storage cvar (used in singleplayer)"};
2044 cvar_t nehx13 = {0, "nehx13", "0", "nehahra data storage cvar (used in singleplayer)"};
2045 cvar_t nehx14 = {0, "nehx14", "0", "nehahra data storage cvar (used in singleplayer)"};
2046 cvar_t nehx15 = {0, "nehx15", "0", "nehahra data storage cvar (used in singleplayer)"};
2047 cvar_t nehx16 = {0, "nehx16", "0", "nehahra data storage cvar (used in singleplayer)"};
2048 cvar_t nehx17 = {0, "nehx17", "0", "nehahra data storage cvar (used in singleplayer)"};
2049 cvar_t nehx18 = {0, "nehx18", "0", "nehahra data storage cvar (used in singleplayer)"};
2050 cvar_t nehx19 = {0, "nehx19", "0", "nehahra data storage cvar (used in singleplayer)"};
2051 cvar_t cutscene = {0, "cutscene", "1", "enables cutscenes in nehahra, can be used by other mods"};
2052
2053 void SV_VM_Init(void)
2054 {
2055         Cvar_RegisterVariable (&pr_checkextension);
2056         Cvar_RegisterVariable (&nomonsters);
2057         Cvar_RegisterVariable (&gamecfg);
2058         Cvar_RegisterVariable (&scratch1);
2059         Cvar_RegisterVariable (&scratch2);
2060         Cvar_RegisterVariable (&scratch3);
2061         Cvar_RegisterVariable (&scratch4);
2062         Cvar_RegisterVariable (&savedgamecfg);
2063         Cvar_RegisterVariable (&saved1);
2064         Cvar_RegisterVariable (&saved2);
2065         Cvar_RegisterVariable (&saved3);
2066         Cvar_RegisterVariable (&saved4);
2067         // LordHavoc: Nehahra uses these to pass data around cutscene demos
2068         if (gamemode == GAME_NEHAHRA)
2069         {
2070                 Cvar_RegisterVariable (&nehx00);
2071                 Cvar_RegisterVariable (&nehx01);
2072                 Cvar_RegisterVariable (&nehx02);
2073                 Cvar_RegisterVariable (&nehx03);
2074                 Cvar_RegisterVariable (&nehx04);
2075                 Cvar_RegisterVariable (&nehx05);
2076                 Cvar_RegisterVariable (&nehx06);
2077                 Cvar_RegisterVariable (&nehx07);
2078                 Cvar_RegisterVariable (&nehx08);
2079                 Cvar_RegisterVariable (&nehx09);
2080                 Cvar_RegisterVariable (&nehx10);
2081                 Cvar_RegisterVariable (&nehx11);
2082                 Cvar_RegisterVariable (&nehx12);
2083                 Cvar_RegisterVariable (&nehx13);
2084                 Cvar_RegisterVariable (&nehx14);
2085                 Cvar_RegisterVariable (&nehx15);
2086                 Cvar_RegisterVariable (&nehx16);
2087                 Cvar_RegisterVariable (&nehx17);
2088                 Cvar_RegisterVariable (&nehx18);
2089                 Cvar_RegisterVariable (&nehx19);
2090         }
2091         Cvar_RegisterVariable (&cutscene); // for Nehahra but useful to other mods as well
2092 }
2093
2094 // LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue...  these are defined as externs in progs.h
2095 int eval_gravity;
2096 int eval_button3;
2097 int eval_button4;
2098 int eval_button5;
2099 int eval_button6;
2100 int eval_button7;
2101 int eval_button8;
2102 int eval_button9;
2103 int eval_button10;
2104 int eval_button11;
2105 int eval_button12;
2106 int eval_button13;
2107 int eval_button14;
2108 int eval_button15;
2109 int eval_button16;
2110 int eval_buttonuse;
2111 int eval_buttonchat;
2112 int eval_glow_size;
2113 int eval_glow_trail;
2114 int eval_glow_color;
2115 int eval_items2;
2116 int eval_scale;
2117 int eval_alpha;
2118 int eval_renderamt; // HalfLife support
2119 int eval_rendermode; // HalfLife support
2120 int eval_fullbright;
2121 int eval_ammo_shells1;
2122 int eval_ammo_nails1;
2123 int eval_ammo_lava_nails;
2124 int eval_ammo_rockets1;
2125 int eval_ammo_multi_rockets;
2126 int eval_ammo_cells1;
2127 int eval_ammo_plasma;
2128 int eval_idealpitch;
2129 int eval_pitch_speed;
2130 int eval_viewmodelforclient;
2131 int eval_nodrawtoclient;
2132 int eval_exteriormodeltoclient;
2133 int eval_drawonlytoclient;
2134 int eval_ping;
2135 int eval_movement;
2136 int eval_pmodel;
2137 int eval_punchvector;
2138 int eval_viewzoom;
2139 int eval_clientcolors;
2140 int eval_tag_entity;
2141 int eval_tag_index;
2142 int eval_light_lev;
2143 int eval_color;
2144 int eval_style;
2145 int eval_pflags;
2146 int eval_cursor_active;
2147 int eval_cursor_screen;
2148 int eval_cursor_trace_start;
2149 int eval_cursor_trace_endpos;
2150 int eval_cursor_trace_ent;
2151 int eval_colormod;
2152 int eval_playermodel;
2153 int eval_playerskin;
2154 int eval_SendEntity;
2155 int eval_Version;
2156 int eval_customizeentityforclient;
2157 int eval_dphitcontentsmask;
2158
2159 int gval_trace_dpstartcontents;
2160 int gval_trace_dphitcontents;
2161 int gval_trace_dphitq3surfaceflags;
2162 int gval_trace_dphittexturename;
2163
2164 mfunction_t *SV_PlayerPhysicsQC;
2165 mfunction_t *EndFrameQC;
2166 //KrimZon - SERVER COMMANDS IN QUAKEC
2167 mfunction_t *SV_ParseClientCommandQC;
2168
2169 ddef_t *PRVM_ED_FindGlobal(const char *name);
2170
2171 void SV_VM_FindEdictFieldOffsets(void)
2172 {
2173         eval_gravity = PRVM_ED_FindFieldOffset("gravity");
2174         eval_button3 = PRVM_ED_FindFieldOffset("button3");
2175         eval_button4 = PRVM_ED_FindFieldOffset("button4");
2176         eval_button5 = PRVM_ED_FindFieldOffset("button5");
2177         eval_button6 = PRVM_ED_FindFieldOffset("button6");
2178         eval_button7 = PRVM_ED_FindFieldOffset("button7");
2179         eval_button8 = PRVM_ED_FindFieldOffset("button8");
2180         eval_button9 = PRVM_ED_FindFieldOffset("button9");
2181         eval_button10 = PRVM_ED_FindFieldOffset("button10");
2182         eval_button11 = PRVM_ED_FindFieldOffset("button11");
2183         eval_button12 = PRVM_ED_FindFieldOffset("button12");
2184         eval_button13 = PRVM_ED_FindFieldOffset("button13");
2185         eval_button14 = PRVM_ED_FindFieldOffset("button14");
2186         eval_button15 = PRVM_ED_FindFieldOffset("button15");
2187         eval_button16 = PRVM_ED_FindFieldOffset("button16");
2188         eval_buttonuse = PRVM_ED_FindFieldOffset("buttonuse");
2189         eval_buttonchat = PRVM_ED_FindFieldOffset("buttonchat");
2190         eval_glow_size = PRVM_ED_FindFieldOffset("glow_size");
2191         eval_glow_trail = PRVM_ED_FindFieldOffset("glow_trail");
2192         eval_glow_color = PRVM_ED_FindFieldOffset("glow_color");
2193         eval_items2 = PRVM_ED_FindFieldOffset("items2");
2194         eval_scale = PRVM_ED_FindFieldOffset("scale");
2195         eval_alpha = PRVM_ED_FindFieldOffset("alpha");
2196         eval_renderamt = PRVM_ED_FindFieldOffset("renderamt"); // HalfLife support
2197         eval_rendermode = PRVM_ED_FindFieldOffset("rendermode"); // HalfLife support
2198         eval_fullbright = PRVM_ED_FindFieldOffset("fullbright");
2199         eval_ammo_shells1 = PRVM_ED_FindFieldOffset("ammo_shells1");
2200         eval_ammo_nails1 = PRVM_ED_FindFieldOffset("ammo_nails1");
2201         eval_ammo_lava_nails = PRVM_ED_FindFieldOffset("ammo_lava_nails");
2202         eval_ammo_rockets1 = PRVM_ED_FindFieldOffset("ammo_rockets1");
2203         eval_ammo_multi_rockets = PRVM_ED_FindFieldOffset("ammo_multi_rockets");
2204         eval_ammo_cells1 = PRVM_ED_FindFieldOffset("ammo_cells1");
2205         eval_ammo_plasma = PRVM_ED_FindFieldOffset("ammo_plasma");
2206         eval_idealpitch = PRVM_ED_FindFieldOffset("idealpitch");
2207         eval_pitch_speed = PRVM_ED_FindFieldOffset("pitch_speed");
2208         eval_viewmodelforclient = PRVM_ED_FindFieldOffset("viewmodelforclient");
2209         eval_nodrawtoclient = PRVM_ED_FindFieldOffset("nodrawtoclient");
2210         eval_exteriormodeltoclient = PRVM_ED_FindFieldOffset("exteriormodeltoclient");
2211         eval_drawonlytoclient = PRVM_ED_FindFieldOffset("drawonlytoclient");
2212         eval_ping = PRVM_ED_FindFieldOffset("ping");
2213         eval_movement = PRVM_ED_FindFieldOffset("movement");
2214         eval_pmodel = PRVM_ED_FindFieldOffset("pmodel");
2215         eval_punchvector = PRVM_ED_FindFieldOffset("punchvector");
2216         eval_viewzoom = PRVM_ED_FindFieldOffset("viewzoom");
2217         eval_clientcolors = PRVM_ED_FindFieldOffset("clientcolors");
2218         eval_tag_entity = PRVM_ED_FindFieldOffset("tag_entity");
2219         eval_tag_index = PRVM_ED_FindFieldOffset("tag_index");
2220         eval_light_lev = PRVM_ED_FindFieldOffset("light_lev");
2221         eval_color = PRVM_ED_FindFieldOffset("color");
2222         eval_style = PRVM_ED_FindFieldOffset("style");
2223         eval_pflags = PRVM_ED_FindFieldOffset("pflags");
2224         eval_cursor_active = PRVM_ED_FindFieldOffset("cursor_active");
2225         eval_cursor_screen = PRVM_ED_FindFieldOffset("cursor_screen");
2226         eval_cursor_trace_start = PRVM_ED_FindFieldOffset("cursor_trace_start");
2227         eval_cursor_trace_endpos = PRVM_ED_FindFieldOffset("cursor_trace_endpos");
2228         eval_cursor_trace_ent = PRVM_ED_FindFieldOffset("cursor_trace_ent");
2229         eval_colormod = PRVM_ED_FindFieldOffset("colormod");
2230         eval_playermodel = PRVM_ED_FindFieldOffset("playermodel");
2231         eval_playerskin = PRVM_ED_FindFieldOffset("playerskin");
2232         eval_SendEntity = PRVM_ED_FindFieldOffset("SendEntity");
2233         eval_Version = PRVM_ED_FindFieldOffset("Version");
2234         eval_customizeentityforclient = PRVM_ED_FindFieldOffset("customizeentityforclient");
2235         eval_dphitcontentsmask = PRVM_ED_FindFieldOffset("dphitcontentsmask");
2236
2237         // LordHavoc: allowing QuakeC to override the player movement code
2238         SV_PlayerPhysicsQC = PRVM_ED_FindFunction ("SV_PlayerPhysics");
2239         // LordHavoc: support for endframe
2240         EndFrameQC = PRVM_ED_FindFunction ("EndFrame");
2241         //KrimZon - SERVER COMMANDS IN QUAKEC
2242         SV_ParseClientCommandQC = PRVM_ED_FindFunction ("SV_ParseClientCommand");
2243
2244         //[515]: init stufftext string (it is sent before svc_serverinfo)
2245         if(PRVM_ED_FindGlobal("SV_InitCmd") && PRVM_ED_FindGlobal("SV_InitCmd")->type & ev_string)
2246                 SV_InitCmd = PRVM_G_STRING(PRVM_ED_FindGlobal("SV_InitCmd")->ofs);
2247         else
2248                 SV_InitCmd = NULL;
2249
2250         gval_trace_dpstartcontents = PRVM_ED_FindGlobalOffset("trace_dpstartcontents");
2251         gval_trace_dphitcontents = PRVM_ED_FindGlobalOffset("trace_dphitcontents");
2252         gval_trace_dphitq3surfaceflags = PRVM_ED_FindGlobalOffset("trace_dphitq3surfaceflags");
2253         gval_trace_dphittexturename = PRVM_ED_FindGlobalOffset("trace_dphittexturename");
2254 }
2255
2256 #define REQFIELDS (sizeof(reqfields) / sizeof(prvm_required_field_t))
2257
2258 prvm_required_field_t reqfields[] =
2259 {
2260         {ev_entity, "cursor_trace_ent"},
2261         {ev_entity, "drawonlytoclient"},
2262         {ev_entity, "exteriormodeltoclient"},
2263         {ev_entity, "nodrawtoclient"},
2264         {ev_entity, "tag_entity"},
2265         {ev_entity, "viewmodelforclient"},
2266         {ev_float, "alpha"},
2267         {ev_float, "ammo_cells1"},
2268         {ev_float, "ammo_lava_nails"},
2269         {ev_float, "ammo_multi_rockets"},
2270         {ev_float, "ammo_nails1"},
2271         {ev_float, "ammo_plasma"},
2272         {ev_float, "ammo_rockets1"},
2273         {ev_float, "ammo_shells1"},
2274         {ev_float, "button3"},
2275         {ev_float, "button4"},
2276         {ev_float, "button5"},
2277         {ev_float, "button6"},
2278         {ev_float, "button7"},
2279         {ev_float, "button8"},
2280         {ev_float, "button9"},
2281         {ev_float, "button10"},
2282         {ev_float, "button11"},
2283         {ev_float, "button12"},
2284         {ev_float, "button13"},
2285         {ev_float, "button14"},
2286         {ev_float, "button15"},
2287         {ev_float, "button16"},
2288         {ev_float, "buttonchat"},
2289         {ev_float, "buttonuse"},
2290         {ev_float, "clientcolors"},
2291         {ev_float, "cursor_active"},
2292         {ev_float, "fullbright"},
2293         {ev_float, "glow_color"},
2294         {ev_float, "glow_size"},
2295         {ev_float, "glow_trail"},
2296         {ev_float, "gravity"},
2297         {ev_float, "idealpitch"},
2298         {ev_float, "items2"},
2299         {ev_float, "light_lev"},
2300         {ev_float, "pflags"},
2301         {ev_float, "ping"},
2302         {ev_float, "pitch_speed"},
2303         {ev_float, "pmodel"},
2304         {ev_float, "renderamt"}, // HalfLife support
2305         {ev_float, "rendermode"}, // HalfLife support
2306         {ev_float, "scale"},
2307         {ev_float, "style"},
2308         {ev_float, "tag_index"},
2309         {ev_float, "Version"},
2310         {ev_float, "viewzoom"},
2311         {ev_vector, "color"},
2312         {ev_vector, "colormod"},
2313         {ev_vector, "cursor_screen"},
2314         {ev_vector, "cursor_trace_endpos"},
2315         {ev_vector, "cursor_trace_start"},
2316         {ev_vector, "movement"},
2317         {ev_vector, "punchvector"},
2318         {ev_string, "playermodel"},
2319         {ev_string, "playerskin"},
2320         {ev_function, "SendEntity"},
2321         {ev_function, "customizeentityforclient"},
2322 };
2323
2324 void SV_VM_Setup(void)
2325 {
2326         PRVM_Begin;
2327         PRVM_InitProg( PRVM_SERVERPROG );
2328
2329         // allocate the mempools
2330         prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
2331         prog->builtins = vm_sv_builtins;
2332         prog->numbuiltins = vm_sv_numbuiltins;
2333         prog->headercrc = PROGHEADER_CRC;
2334         prog->max_edicts = 512;
2335         prog->limit_edicts = MAX_EDICTS;
2336         prog->reserved_edicts = svs.maxclients;
2337         prog->edictprivate_size = sizeof(edict_engineprivate_t);
2338         prog->name = "server";
2339         prog->extensionstring = vm_sv_extensions;
2340         prog->loadintoworld = true;
2341
2342         prog->begin_increase_edicts = SV_VM_CB_BeginIncreaseEdicts;
2343         prog->end_increase_edicts = SV_VM_CB_EndIncreaseEdicts;
2344         prog->init_edict = SV_VM_CB_InitEdict;
2345         prog->free_edict = SV_VM_CB_FreeEdict;
2346         prog->count_edicts = SV_VM_CB_CountEdicts;
2347         prog->load_edict = SV_VM_CB_LoadEdict;
2348         prog->init_cmd = VM_SV_Cmd_Init;
2349         prog->reset_cmd = VM_SV_Cmd_Reset;
2350         prog->error_cmd = Host_Error;
2351
2352         // TODO: add a requiredfuncs list (ask LH if this is necessary at all)
2353         PRVM_LoadProgs( sv_progs.string, 0, NULL, REQFIELDS, reqfields );
2354         SV_VM_FindEdictFieldOffsets();
2355
2356         VM_AutoSentStats_Clear();//[515]: csqc
2357         EntityFrameCSQC_ClearVersions();//[515]: csqc
2358
2359         PRVM_End;
2360 }
2361
2362 void SV_VM_Begin(void)
2363 {
2364         PRVM_Begin;
2365         PRVM_SetProg( PRVM_SERVERPROG );
2366
2367         *prog->time = (float) sv.time;
2368 }
2369
2370 void SV_VM_End(void)
2371 {
2372         PRVM_End;
2373 }