added r_sortsurfaces cvar, default off, sorting them seems to be a very minor slowdow...
[divverent/darkplaces.git] / cl_parse.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 // cl_parse.c  -- parse a message received from the server
21
22 #include "quakedef.h"
23
24 char *svc_strings[128] =
25 {
26         "svc_bad",
27         "svc_nop",
28         "svc_disconnect",
29         "svc_updatestat",
30         "svc_version",          // [long] server version
31         "svc_setview",          // [short] entity number
32         "svc_sound",                    // <see code>
33         "svc_time",                     // [float] server time
34         "svc_print",                    // [string] null terminated string
35         "svc_stufftext",                // [string] stuffed into client's console buffer
36                                                 // the string should be \n terminated
37         "svc_setangle",         // [vec3] set the view angle to this absolute value
38
39         "svc_serverinfo",               // [long] version
40                                                 // [string] signon string
41                                                 // [string]..[0]model cache [string]...[0]sounds cache
42                                                 // [string]..[0]item cache
43         "svc_lightstyle",               // [byte] [string]
44         "svc_updatename",               // [byte] [string]
45         "svc_updatefrags",      // [byte] [short]
46         "svc_clientdata",               // <shortbits + data>
47         "svc_stopsound",                // <see code>
48         "svc_updatecolors",     // [byte] [byte]
49         "svc_particle",         // [vec3] <variable>
50         "svc_damage",                   // [byte] impact [byte] blood [vec3] from
51
52         "svc_spawnstatic",
53         "OBSOLETE svc_spawnbinary",
54         "svc_spawnbaseline",
55
56         "svc_temp_entity",              // <variable>
57         "svc_setpause",
58         "svc_signonnum",
59         "svc_centerprint",
60         "svc_killedmonster",
61         "svc_foundsecret",
62         "svc_spawnstaticsound",
63         "svc_intermission",
64         "svc_finale",                   // [string] music [string] text
65         "svc_cdtrack",                  // [byte] track [byte] looptrack
66         "svc_sellscreen",
67         "svc_cutscene",
68         "svc_showlmp",  // [string] iconlabel [string] lmpfile [short] x [short] y
69         "svc_hidelmp",  // [string] iconlabel
70         "svc_skybox", // [string] skyname
71         "", // 38
72         "", // 39
73         "", // 40
74         "", // 41
75         "", // 42
76         "", // 43
77         "", // 44
78         "", // 45
79         "", // 46
80         "", // 47
81         "", // 48
82         "", // 49
83         "svc_cgame", //                         50              // [short] length [bytes] data
84         "svc_unusedlh1", //                     51              // unused
85         "svc_effect", //                        52              // [vector] org [byte] modelindex [byte] startframe [byte] framecount [byte] framerate
86         "svc_effect2", //                       53              // [vector] org [short] modelindex [short] startframe [byte] framecount [byte] framerate
87         "svc_sound2", //                        54              // short soundindex instead of byte
88         "svc_spawnbaseline2", //        55              // short modelindex instead of byte
89         "svc_spawnstatic2", //          56              // short modelindex instead of byte
90         "svc_entities", //                      57              // [int] deltaframe [int] thisframe [float vector] eye [variable length] entitydata
91         "svc_unusedlh3", //                     58
92         "svc_spawnstaticsound2", //     59              // [coord3] [short] samp [byte] vol [byte] aten
93 };
94
95 //=============================================================================
96
97 cvar_t demo_nehahra = {0, "demo_nehahra", "0"};
98
99 void CL_Parse_Init(void)
100 {
101         // LordHavoc: added demo_nehahra cvar
102         Cvar_RegisterVariable (&demo_nehahra);
103         if (gamemode == GAME_NEHAHRA)
104                 Cvar_SetValue("demo_nehahra", 1);
105 }
106
107 qboolean Nehahrademcompatibility; // LordHavoc: to allow playback of the early Nehahra movie segments
108 int dpprotocol; // LordHavoc: version of network protocol, or 0 if not DarkPlaces
109
110 /*
111 ==================
112 CL_ParseStartSoundPacket
113 ==================
114 */
115 void CL_ParseStartSoundPacket(int largesoundindex)
116 {
117     vec3_t  pos;
118     int         channel, ent;
119     int         sound_num;
120     int         volume;
121     int         field_mask;
122     float       attenuation;
123         int             i;
124                    
125     field_mask = MSG_ReadByte();
126
127     if (field_mask & SND_VOLUME)
128                 volume = MSG_ReadByte ();
129         else
130                 volume = DEFAULT_SOUND_PACKET_VOLUME;
131         
132     if (field_mask & SND_ATTENUATION)
133                 attenuation = MSG_ReadByte () / 64.0;
134         else
135                 attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
136         
137         channel = MSG_ReadShort ();
138         if (largesoundindex)
139                 sound_num = (unsigned short) MSG_ReadShort ();
140         else
141                 sound_num = MSG_ReadByte ();
142
143         if (sound_num >= MAX_SOUNDS)
144                 Host_Error("CL_ParseStartSoundPacket: sound_num (%i) >= MAX_SOUNDS (%i)\n", sound_num, MAX_SOUNDS);
145
146         ent = channel >> 3;
147         channel &= 7;
148
149         if (ent > MAX_EDICTS)
150                 Host_Error ("CL_ParseStartSoundPacket: ent = %i", ent);
151         
152         for (i=0 ; i<3 ; i++)
153                 pos[i] = MSG_ReadCoord ();
154
155     S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);
156 }
157
158 /*
159 ==================
160 CL_KeepaliveMessage
161
162 When the client is taking a long time to load stuff, send keepalive messages
163 so the server doesn't disconnect.
164 ==================
165 */
166 void CL_KeepaliveMessage (void)
167 {
168         float   time;
169         static float lastmsg;
170         int             ret;
171         int             c;
172         sizebuf_t       old;
173         qbyte           olddata[8192];
174         
175         if (sv.active)
176                 return;         // no need if server is local
177         if (cls.demoplayback)
178                 return;
179
180 // read messages from server, should just be nops
181         old = net_message;
182         memcpy (olddata, net_message.data, net_message.cursize);
183         
184         do
185         {
186                 ret = CL_GetMessage ();
187                 switch (ret)
188                 {
189                 default:
190                         Host_Error ("CL_KeepaliveMessage: CL_GetMessage failed");
191                 case 0:
192                         break;  // nothing waiting
193                 case 1:
194                         Host_Error ("CL_KeepaliveMessage: received a message");
195                         break;
196                 case 2:
197                         c = MSG_ReadByte();
198                         if (c != svc_nop)
199                                 Host_Error ("CL_KeepaliveMessage: datagram wasn't a nop");
200                         break;
201                 }
202         } while (ret);
203
204         net_message = old;
205         memcpy (net_message.data, olddata, net_message.cursize);
206
207 // check time
208         time = Sys_DoubleTime ();
209         if (time - lastmsg < 5)
210                 return;
211         lastmsg = time;
212
213 // write out a nop
214         Con_Printf ("--> client to server keepalive\n");
215
216         MSG_WriteByte (&cls.message, clc_nop);
217         NET_SendMessage (cls.netcon, &cls.message);
218         SZ_Clear (&cls.message);
219 }
220
221 void CL_ParseEntityLump(char *entdata)
222 {
223         char *data;
224         char key[128], value[4096];
225         FOG_clear(); // LordHavoc: no fog until set
226         R_SetSkyBox(""); // LordHavoc: no environment mapped sky until set
227         data = entdata;
228         if (!data)
229                 return;
230         data = COM_Parse(data);
231         if (!data)
232                 return; // error
233         if (com_token[0] != '{')
234                 return; // error
235         while (1)
236         {
237                 data = COM_Parse(data);
238                 if (!data)
239                         return; // error
240                 if (com_token[0] == '}')
241                         break; // end of worldspawn
242                 if (com_token[0] == '_')
243                         strcpy(key, com_token + 1);
244                 else
245                         strcpy(key, com_token);
246                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
247                         key[strlen(key)-1] = 0;
248                 data = COM_Parse(data);
249                 if (!data)
250                         return; // error
251                 strcpy(value, com_token);
252                 if (!strcmp("sky", key))
253                         R_SetSkyBox(value);
254                 else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
255                         R_SetSkyBox(value);
256                 else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
257                         R_SetSkyBox(value);
258                 else if (!strcmp("fog", key))
259                         sscanf(value, "%f %f %f %f", &fog_density, &fog_red, &fog_green, &fog_blue);
260                 else if (!strcmp("fog_density", key))
261                         fog_density = atof(value);
262                 else if (!strcmp("fog_red", key))
263                         fog_red = atof(value);
264                 else if (!strcmp("fog_green", key))
265                         fog_green = atof(value);
266                 else if (!strcmp("fog_blue", key))
267                         fog_blue = atof(value);
268         }
269 }
270
271 /*
272 =====================
273 CL_SignonReply
274
275 An svc_signonnum has been received, perform a client side setup
276 =====================
277 */
278 static void CL_SignonReply (void)
279 {
280         //char  str[8192];
281
282 Con_DPrintf ("CL_SignonReply: %i\n", cls.signon);
283
284         switch (cls.signon)
285         {
286         case 1:
287                 MSG_WriteByte (&cls.message, clc_stringcmd);
288                 MSG_WriteString (&cls.message, "prespawn");
289                 break;
290
291         case 2:
292                 MSG_WriteByte (&cls.message, clc_stringcmd);
293                 MSG_WriteString (&cls.message, va("name \"%s\"\n", cl_name.string));
294
295                 MSG_WriteByte (&cls.message, clc_stringcmd);
296                 MSG_WriteString (&cls.message, va("color %i %i\n", cl_color.integer >> 4, cl_color.integer & 15));
297
298                 if (cl_pmodel.integer)
299                 {
300                         MSG_WriteByte (&cls.message, clc_stringcmd);
301                         MSG_WriteString (&cls.message, va("pmodel %i\n", cl_pmodel.integer));
302                 }
303
304                 MSG_WriteByte (&cls.message, clc_stringcmd);
305                 //sprintf (str, "spawn %s", cls.spawnparms);
306                 //MSG_WriteString (&cls.message, str);
307                 MSG_WriteString (&cls.message, "spawn");
308                 break;
309
310         case 3:
311                 MSG_WriteByte (&cls.message, clc_stringcmd);
312                 MSG_WriteString (&cls.message, "begin");
313                 break;
314
315         case 4:
316                 Con_ClearNotify();
317                 break;
318         }
319 }
320
321 /*
322 ==================
323 CL_ParseServerInfo
324 ==================
325 */
326 qbyte entlife[MAX_EDICTS];
327 void CL_ParseServerInfo (void)
328 {
329         char *str;
330         int i;
331         int nummodels, numsounds;
332         char model_precache[MAX_MODELS][MAX_QPATH];
333         char sound_precache[MAX_SOUNDS][MAX_QPATH];
334         entity_t *ent;
335
336         Con_DPrintf ("Serverinfo packet received.\n");
337 //
338 // wipe the client_state_t struct
339 //
340         CL_ClearState ();
341
342 // parse protocol version number
343         i = MSG_ReadLong ();
344         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION1 && i != DPPROTOCOL_VERSION2 && i != DPPROTOCOL_VERSION3 && i != 250)
345         {
346                 Con_Printf ("Server is protocol %i, not %i, %i, %i or %i", i, DPPROTOCOL_VERSION1, DPPROTOCOL_VERSION2, DPPROTOCOL_VERSION3, PROTOCOL_VERSION);
347                 return;
348         }
349         Nehahrademcompatibility = false;
350         if (i == 250)
351                 Nehahrademcompatibility = true;
352         if (cls.demoplayback && demo_nehahra.integer)
353                 Nehahrademcompatibility = true;
354         dpprotocol = i;
355         if (dpprotocol != DPPROTOCOL_VERSION1 && dpprotocol != DPPROTOCOL_VERSION2 && dpprotocol != DPPROTOCOL_VERSION3)
356                 dpprotocol = 0;
357
358 // parse maxclients
359         cl.maxclients = MSG_ReadByte ();
360         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
361         {
362                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
363                 return;
364         }
365         cl.scores = Mem_Alloc(cl_scores_mempool, cl.maxclients*sizeof(*cl.scores));
366
367 // parse gametype
368         cl.gametype = MSG_ReadByte ();
369
370 // parse signon message
371         str = MSG_ReadString ();
372         strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
373
374 // seperate the printfs so the server message can have a color
375         if (!Nehahrademcompatibility) // no messages when playing the Nehahra movie
376         {
377                 Con_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
378                 Con_Printf ("%c%s\n", 2, str);
379         }
380
381 //
382 // first we go through and touch all of the precache data that still
383 // happens to be in the cache, so precaching something else doesn't
384 // needlessly purge it
385 //
386
387         Mem_CheckSentinelsGlobal();
388
389         Mod_ClearUsed();
390
391 // precache models
392         memset (cl.model_precache, 0, sizeof(cl.model_precache));
393         for (nummodels=1 ; ; nummodels++)
394         {
395                 str = MSG_ReadString ();
396                 if (!str[0])
397                         break;
398                 if (nummodels==MAX_MODELS)
399                 {
400                         Host_Error ("Server sent too many model precaches\n");
401                         return;
402                 }
403                 if (strlen(str) >= MAX_QPATH)
404                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
405                 strcpy (model_precache[nummodels], str);
406                 Mod_TouchModel (str);
407         }
408
409 // precache sounds
410         memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
411         for (numsounds=1 ; ; numsounds++)
412         {
413                 str = MSG_ReadString ();
414                 if (!str[0])
415                         break;
416                 if (numsounds==MAX_SOUNDS)
417                 {
418                         Host_Error ("Server sent too many sound precaches\n");
419                         return;
420                 }
421                 if (strlen(str) >= MAX_QPATH)
422                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
423                 strcpy (sound_precache[numsounds], str);
424                 S_TouchSound (str);
425         }
426
427         Mod_PurgeUnused();
428
429 //
430 // now we try to load everything else until a cache allocation fails
431 //
432
433         for (i=1 ; i<nummodels ; i++)
434         {
435                 // LordHavoc: i == 1 means the first model is the world model
436                 cl.model_precache[i] = Mod_ForName (model_precache[i], false, false, i == 1);
437
438                 if (cl.model_precache[i] == NULL)
439                 {
440                         Host_Error("Model %s not found\n", model_precache[i]);
441                         return;
442                 }
443                 CL_KeepaliveMessage ();
444         }
445
446         S_BeginPrecaching ();
447         for (i=1 ; i<numsounds ; i++)
448         {
449                 cl.sound_precache[i] = S_PrecacheSound (sound_precache[i], true);
450                 CL_KeepaliveMessage ();
451         }
452         S_EndPrecaching ();
453
454 // local state
455         ent = &cl_entities[0];
456         // entire entity array was cleared, so just fill in a few fields
457         ent->state_current.active = true;
458         ent->render.model = cl.worldmodel = cl.model_precache[1];
459         ent->render.scale = 1;
460         ent->render.alpha = 1;
461         VectorAdd(ent->render.origin, ent->render.model->normalmins, ent->render.mins);
462         VectorAdd(ent->render.origin, ent->render.model->normalmaxs, ent->render.maxs);
463         // clear entlife array
464         memset(entlife, 0, MAX_EDICTS);
465
466         cl_num_entities = 1;
467
468         R_NewMap ();
469
470         CL_CGVM_Start();
471
472         Mem_CheckSentinelsGlobal();
473
474         noclip_anglehack = false;               // noclip is turned off at start
475 }
476
477 void CL_ValidateState(entity_state_t *s)
478 {
479         model_t *model;
480
481         if (!s->active)
482                 return;
483
484         if (s->modelindex >= MAX_MODELS)
485                 Host_Error("CL_ValidateState: modelindex (%i) >= MAX_MODELS (%i)\n", s->modelindex, MAX_MODELS);
486
487         // colormap is client index + 1
488         if (s->colormap > cl.maxclients)
489                 Host_Error ("CL_ValidateState: colormap (%i) > cl.maxclients (%i)", s->colormap, cl.maxclients);
490
491         model = cl.model_precache[s->modelindex];
492         Mod_CheckLoaded(model);
493         if (model && s->frame >= model->numframes)
494         {
495                 Con_DPrintf("CL_ValidateState: no such frame %i in \"%s\"\n", s->frame, model->name);
496                 s->frame = 0;
497         }
498         if (model && s->skin > 0 && s->skin >= model->numskins)
499         {
500                 Con_DPrintf("CL_ValidateState: no such skin %i in \"%s\"\n", s->skin, model->name);
501                 s->skin = 0;
502         }
503 }
504
505 /*
506 ==================
507 CL_ParseUpdate
508
509 Parse an entity update message from the server
510 If an entities model or origin changes from frame to frame, it must be
511 relinked.  Other attributes can change without relinking.
512 ==================
513 */
514 int bitprofile[32], bitprofilecount = 0;
515 void CL_ParseUpdate (int bits)
516 {
517         int i, num;
518         entity_t *ent;
519         entity_state_t new;
520
521         if (bits & U_MOREBITS)
522                 bits |= (MSG_ReadByte()<<8);
523         if ((bits & U_EXTEND1) && (!Nehahrademcompatibility))
524         {
525                 bits |= MSG_ReadByte() << 16;
526                 if (bits & U_EXTEND2)
527                         bits |= MSG_ReadByte() << 24;
528         }
529
530         if (bits & U_LONGENTITY)
531                 num = (unsigned) MSG_ReadShort ();
532         else
533                 num = (unsigned) MSG_ReadByte ();
534
535         if (num >= MAX_EDICTS)
536                 Host_Error("CL_ParseUpdate: entity number (%i) >= MAX_EDICTS (%i)\n", num, MAX_EDICTS);
537         if (num < 1)
538                 Host_Error("CL_ParseUpdate: invalid entity number (%i)\n", num);
539
540         ent = cl_entities + num;
541
542         for (i = 0;i < 32;i++)
543                 if (bits & (1 << i))
544                         bitprofile[i]++;
545         bitprofilecount++;
546
547         // note: this inherits the 'active' state of the baseline chosen
548         // (state_baseline is always active, state_current may not be active if
549         // the entity was missing in the last frame)
550         if (bits & U_DELTA)
551                 new = ent->state_current;
552         else
553         {
554                 new = ent->state_baseline;
555                 new.active = true;
556         }
557
558         new.number = num;
559         new.time = cl.mtime[0];
560         new.flags = 0;
561         if (bits & U_MODEL)             new.modelindex = (new.modelindex & 0xFF00) | MSG_ReadByte();
562         if (bits & U_FRAME)             new.frame = (new.frame & 0xFF00) | MSG_ReadByte();
563         if (bits & U_COLORMAP)  new.colormap = MSG_ReadByte();
564         if (bits & U_SKIN)              new.skin = MSG_ReadByte();
565         if (bits & U_EFFECTS)   new.effects = (new.effects & 0xFF00) | MSG_ReadByte();
566         if (bits & U_ORIGIN1)   new.origin[0] = MSG_ReadCoord();
567         if (bits & U_ANGLE1)    new.angles[0] = MSG_ReadAngle();
568         if (bits & U_ORIGIN2)   new.origin[1] = MSG_ReadCoord();
569         if (bits & U_ANGLE2)    new.angles[1] = MSG_ReadAngle();
570         if (bits & U_ORIGIN3)   new.origin[2] = MSG_ReadCoord();
571         if (bits & U_ANGLE3)    new.angles[2] = MSG_ReadAngle();
572         if (bits & U_STEP)              new.flags |= RENDER_STEP;
573         if (bits & U_ALPHA)             new.alpha = MSG_ReadByte();
574         if (bits & U_SCALE)             new.scale = MSG_ReadByte();
575         if (bits & U_EFFECTS2)  new.effects = (new.effects & 0x00FF) | (MSG_ReadByte() << 8);
576         if (bits & U_GLOWSIZE)  new.glowsize = MSG_ReadByte();
577         if (bits & U_GLOWCOLOR) new.glowcolor = MSG_ReadByte();
578         // apparently the dpcrush demo uses this (unintended, and it uses white anyway)
579         if (bits & U_COLORMOD)  MSG_ReadByte();
580         if (bits & U_GLOWTRAIL) new.flags |= RENDER_GLOWTRAIL;
581         if (bits & U_FRAME2)    new.frame = (new.frame & 0x00FF) | (MSG_ReadByte() << 8);
582         if (bits & U_MODEL2)    new.modelindex = (new.modelindex & 0x00FF) | (MSG_ReadByte() << 8);
583         if (bits & U_VIEWMODEL) new.flags |= RENDER_VIEWMODEL;
584         if (bits & U_EXTERIORMODEL)     new.flags |= RENDER_EXTERIORMODEL;
585
586         // LordHavoc: to allow playback of the Nehahra movie
587         if (Nehahrademcompatibility && (bits & U_EXTEND1))
588         {
589                 // LordHavoc: evil format
590                 int i = MSG_ReadFloat();
591                 int j = MSG_ReadFloat() * 255.0f;
592                 if (i == 2)
593                 {
594                         i = MSG_ReadFloat();
595                         if (i)
596                                 new.effects |= EF_FULLBRIGHT;
597                 }
598                 if (j < 0)
599                         new.alpha = 0;
600                 else if (j == 0 || j >= 255)
601                         new.alpha = 255;
602                 else
603                         new.alpha = j;
604         }
605
606         if (new.active)
607                 CL_ValidateState(&new);
608
609         if (new.flags & RENDER_STEP) // FIXME: rename this flag?
610         {
611                 // make time identical for memcmp
612                 new.time = ent->state_current.time;
613                 if (memcmp(&new, &ent->state_current, sizeof(entity_state_t)))
614                 {
615                         // set it back to what it should be
616                         new.time = cl.mtime[0] + 0.1;
617                         // state has changed
618                         ent->state_previous = ent->state_current;
619                         ent->state_current = new;
620                         // assume 10fps animation
621                         //ent->state_previous.time = cl.mtime[0] - 0.1;
622                 }
623         }
624         else
625         {
626                 ent->state_previous = ent->state_current;
627                 ent->state_current = new;
628         }
629         if (ent->state_current.active)
630         {
631                 cl_entities_active[ent->state_current.number] = true;
632                 // mark as visible (no kill this frame)
633                 entlife[ent->state_current.number] = 2;
634         }
635 }
636
637 void CL_ReadEntityFrame(void)
638 {
639         entity_t *ent;
640         entity_frame_t entityframe;
641         int i;
642         EntityFrame_Read(&cl.entitydatabase);
643         EntityFrame_FetchFrame(&cl.entitydatabase, EntityFrame_MostRecentlyRecievedFrameNum(&cl.entitydatabase), &entityframe);
644         for (i = 0;i < entityframe.numentities;i++)
645         {
646                 // copy the states
647                 ent = &cl_entities[entityframe.entitydata[i].number];
648                 ent->state_previous = ent->state_current;
649                 ent->state_current = entityframe.entitydata[i];
650                 ent->state_current.time = cl.mtime[0];
651                 // the entity lives again...
652                 entlife[ent->state_current.number] = 2;
653                 cl_entities_active[ent->state_current.number] = true;
654         }
655         VectorCopy(cl.viewentoriginnew, cl.viewentoriginold);
656         VectorCopy(entityframe.eye, cl.viewentoriginnew);
657 }
658
659 char *bitprofilenames[32] =
660 {
661         "U_MOREBITS",
662         "U_ORIGIN1",
663         "U_ORIGIN2",
664         "U_ORIGIN3",
665         "U_ANGLE2",
666         "U_STEP",
667         "U_FRAME",
668         "U_SIGNAL",
669         "U_ANGLE1",
670         "U_ANGLE3",
671         "U_MODEL",
672         "U_COLORMAP",
673         "U_SKIN",
674         "U_EFFECTS",
675         "U_LONGENTITY",
676         "U_EXTEND1",
677         "U_DELTA",
678         "U_ALPHA",
679         "U_SCALE",
680         "U_EFFECTS2",
681         "U_GLOWSIZE",
682         "U_GLOWCOLOR",
683         "obsolete U_COLORMOD",
684         "U_EXTEND2",
685         "U_GLOWTRAIL",
686         "U_VIEWMODEL",
687         "U_FRAME2",
688         "U_MODEL2",
689         "U_EXTERIORMODEL",
690         "U_UNUSED29",
691         "U_UNUSED30",
692         "U_EXTEND3",
693 };
694
695 void CL_BitProfile_f(void)
696 {
697         int i;
698         Con_Printf("bitprofile: %i updates\n");
699         if (bitprofilecount)
700                 for (i = 0;i < 32;i++)
701                         Con_Printf("%s: %i %3.2f%%\n", bitprofilenames[i], bitprofile[i], bitprofile[i] * 100.0 / bitprofilecount);
702         Con_Printf("\n");
703         for (i = 0;i < 32;i++)
704                 bitprofile[i] = 0;
705         bitprofilecount = 0;
706 }
707
708 void CL_EntityUpdateSetup(void)
709 {
710 }
711
712 void CL_EntityUpdateEnd(void)
713 {
714         int i;
715         // disable entities that disappeared this frame
716         for (i = 1;i < MAX_EDICTS;i++)
717         {
718                 // clear only the entities that were active last frame but not this
719                 // frame, don't waste time clearing all entities (which would cause
720                 // cache misses)
721                 if (entlife[i])
722                 {
723                         entlife[i]--;
724                         if (!entlife[i])
725                                 cl_entities[i].state_previous.active = cl_entities[i].state_current.active = 0;
726                 }
727         }
728 }
729
730 /*
731 ==================
732 CL_ParseBaseline
733 ==================
734 */
735 void CL_ParseBaseline (entity_t *ent, int large)
736 {
737         int i;
738
739         memset(&ent->state_baseline, 0, sizeof(entity_state_t));
740         ent->state_baseline.active = true;
741         if (large)
742         {
743                 ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
744                 ent->state_baseline.frame = (unsigned short) MSG_ReadShort ();
745         }
746         else
747         {
748                 ent->state_baseline.modelindex = MSG_ReadByte ();
749                 ent->state_baseline.frame = MSG_ReadByte ();
750         }
751         ent->state_baseline.colormap = MSG_ReadByte();
752         ent->state_baseline.skin = MSG_ReadByte();
753         for (i = 0;i < 3;i++)
754         {
755                 ent->state_baseline.origin[i] = MSG_ReadCoord ();
756                 ent->state_baseline.angles[i] = MSG_ReadAngle ();
757         }
758         ent->state_baseline.alpha = 255;
759         ent->state_baseline.scale = 16;
760         ent->state_baseline.glowsize = 0;
761         ent->state_baseline.glowcolor = 254;
762         ent->state_previous = ent->state_current = ent->state_baseline;
763
764         CL_ValidateState(&ent->state_baseline);
765 }
766
767
768 /*
769 ==================
770 CL_ParseClientdata
771
772 Server information pertaining to this client only
773 ==================
774 */
775 void CL_ParseClientdata (int bits)
776 {
777         int i, j;
778
779         bits &= 0xFFFF;
780         if (bits & SU_EXTEND1)
781                 bits |= (MSG_ReadByte() << 16);
782         if (bits & SU_EXTEND2)
783                 bits |= (MSG_ReadByte() << 24);
784
785         if (bits & SU_VIEWHEIGHT)
786                 cl.viewheight = MSG_ReadChar ();
787         else
788                 cl.viewheight = DEFAULT_VIEWHEIGHT;
789
790         if (bits & SU_IDEALPITCH)
791                 cl.idealpitch = MSG_ReadChar ();
792         else
793                 cl.idealpitch = 0;
794
795         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
796         for (i=0 ; i<3 ; i++)
797         {
798                 if (bits & (SU_PUNCH1<<i) )
799                 {
800                         if (dpprotocol)
801                                 cl.punchangle[i] = MSG_ReadPreciseAngle();
802                         else
803                                 cl.punchangle[i] = MSG_ReadChar();
804                 }
805                 else
806                         cl.punchangle[i] = 0;
807                 if (bits & (SU_PUNCHVEC1<<i))
808                         cl.punchvector[i] = MSG_ReadCoord();
809                 else
810                         cl.punchvector[i] = 0;
811                 if (bits & (SU_VELOCITY1<<i) )
812                         cl.mvelocity[0][i] = MSG_ReadChar()*16;
813                 else
814                         cl.mvelocity[0][i] = 0;
815         }
816
817         i = MSG_ReadLong ();
818         if (cl.items != i)
819         {       // set flash times
820                 for (j=0 ; j<32 ; j++)
821                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
822                                 cl.item_gettime[j] = cl.time;
823                 cl.items = i;
824         }
825
826         cl.onground = (bits & SU_ONGROUND) != 0;
827         cl.inwater = (bits & SU_INWATER) != 0;
828
829         cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
830         cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
831         cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
832         cl.stats[STAT_HEALTH] = MSG_ReadShort();
833         cl.stats[STAT_AMMO] = MSG_ReadByte();
834
835         cl.stats[STAT_SHELLS] = MSG_ReadByte();
836         cl.stats[STAT_NAILS] = MSG_ReadByte();
837         cl.stats[STAT_ROCKETS] = MSG_ReadByte();
838         cl.stats[STAT_CELLS] = MSG_ReadByte();
839
840         i = MSG_ReadByte ();
841
842         if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
843                 cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
844         else
845                 cl.stats[STAT_ACTIVEWEAPON] = i;
846
847         cl.viewzoomold = cl.viewzoomnew; // for interpolation
848         if (bits & SU_VIEWZOOM)
849         {
850                 i = MSG_ReadByte();
851                 if (i < 2)
852                         i = 2;
853                 cl.viewzoomnew = (float) i * (1.0f / 255.0f);
854         }
855         else
856                 cl.viewzoomnew = 1;
857
858 }
859
860 /*
861 =====================
862 CL_ParseStatic
863 =====================
864 */
865 void CL_ParseStatic (int large)
866 {
867         entity_t *ent;
868
869         if (cl_num_static_entities >= cl_max_static_entities)
870                 Host_Error ("Too many static entities");
871         ent = &cl_static_entities[cl_num_static_entities++];
872         CL_ParseBaseline (ent, large);
873
874 // copy it to the current state
875         ent->render.model = cl.model_precache[ent->state_baseline.modelindex];
876         ent->render.frame = ent->render.frame1 = ent->render.frame2 = ent->state_baseline.frame;
877         ent->render.framelerp = 0;
878         // make torchs play out of sync
879         ent->render.frame1time = ent->render.frame2time = lhrandom(-10, -1);
880         ent->render.colormap = -1; // no special coloring
881         ent->render.skinnum = ent->state_baseline.skin;
882         ent->render.effects = ent->state_baseline.effects;
883         ent->render.alpha = 1;
884         ent->render.scale = 1;
885         ent->render.alpha = 1;
886
887         VectorCopy (ent->state_baseline.origin, ent->render.origin);
888         VectorCopy (ent->state_baseline.angles, ent->render.angles);
889
890         if (ent->render.angles[0] || ent->render.angles[2])
891         {
892                 // pitch or roll
893                 VectorAdd(ent->render.origin, ent->render.model->rotatedmins, ent->render.mins);
894                 VectorAdd(ent->render.origin, ent->render.model->rotatedmaxs, ent->render.maxs);
895         }
896         else if (ent->render.angles[1])
897         {
898                 // yaw
899                 VectorAdd(ent->render.origin, ent->render.model->yawmins, ent->render.mins);
900                 VectorAdd(ent->render.origin, ent->render.model->yawmaxs, ent->render.maxs);
901         }
902         else
903         {
904                 VectorAdd(ent->render.origin, ent->render.model->normalmins, ent->render.mins);
905                 VectorAdd(ent->render.origin, ent->render.model->normalmaxs, ent->render.maxs);
906         }
907
908         // This is definitely cheating...
909         if (ent->render.model == NULL)
910                 cl_num_static_entities--;
911 }
912
913 /*
914 ===================
915 CL_ParseStaticSound
916 ===================
917 */
918 void CL_ParseStaticSound (int large)
919 {
920         vec3_t          org;
921         int                     sound_num, vol, atten;
922
923         MSG_ReadVector(org);
924         if (large)
925                 sound_num = (unsigned short) MSG_ReadShort ();
926         else
927                 sound_num = MSG_ReadByte ();
928         vol = MSG_ReadByte ();
929         atten = MSG_ReadByte ();
930
931         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
932 }
933
934 void CL_ParseEffect (void)
935 {
936         vec3_t          org;
937         int                     modelindex, startframe, framecount, framerate;
938
939         MSG_ReadVector(org);
940         modelindex = MSG_ReadByte ();
941         startframe = MSG_ReadByte ();
942         framecount = MSG_ReadByte ();
943         framerate = MSG_ReadByte ();
944
945         CL_Effect(org, modelindex, startframe, framecount, framerate);
946 }
947
948 void CL_ParseEffect2 (void)
949 {
950         vec3_t          org;
951         int                     modelindex, startframe, framecount, framerate;
952
953         MSG_ReadVector(org);
954         modelindex = MSG_ReadShort ();
955         startframe = MSG_ReadShort ();
956         framecount = MSG_ReadByte ();
957         framerate = MSG_ReadByte ();
958
959         CL_Effect(org, modelindex, startframe, framecount, framerate);
960 }
961
962
963 #define SHOWNET(x) if(cl_shownet.integer==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
964
965 static qbyte cgamenetbuffer[65536];
966
967 /*
968 =====================
969 CL_ParseServerMessage
970 =====================
971 */
972 void CL_ParseServerMessage (void)
973 {
974         int                     cmd;
975         int                     i, entitiesupdated;
976         qbyte           cmdlog[32];
977         char            *cmdlogname[32], *temp;
978         int                     cmdindex, cmdcount = 0;
979
980 //
981 // if recording demos, copy the message out
982 //
983         if (cl_shownet.integer == 1)
984                 Con_Printf ("%i ",net_message.cursize);
985         else if (cl_shownet.integer == 2)
986                 Con_Printf ("------------------\n");
987
988         cl.onground = false;    // unless the server says otherwise
989 //
990 // parse the message
991 //
992         MSG_BeginReading ();
993
994         entitiesupdated = false;
995
996         while (1)
997         {
998                 if (msg_badread)
999                         Host_Error ("CL_ParseServerMessage: Bad server message");
1000
1001                 cmd = MSG_ReadByte ();
1002
1003                 if (cmd == -1)
1004                 {
1005                         SHOWNET("END OF MESSAGE");
1006                         break;          // end of message
1007                 }
1008
1009                 cmdindex = cmdcount & 31;
1010                 cmdcount++;
1011                 cmdlog[cmdindex] = cmd;
1012
1013                 // if the high bit of the command byte is set, it is a fast update
1014                 if (cmd & 128)
1015                 {
1016                         // LordHavoc: fix for bizarre problem in MSVC that I do not understand (if I assign the string pointer directly it ends up storing a NULL pointer)
1017                         temp = "entity";
1018                         cmdlogname[cmdindex] = temp;
1019                         SHOWNET("fast update");
1020                         if (cls.signon == SIGNONS - 1)
1021                         {
1022                                 // first update is the final signon stage
1023                                 cls.signon = SIGNONS;
1024                                 CL_SignonReply ();
1025                         }
1026                         CL_ParseUpdate (cmd&127);
1027                         continue;
1028                 }
1029
1030                 SHOWNET(svc_strings[cmd]);
1031                 cmdlogname[cmdindex] = svc_strings[cmd];
1032                 if (!cmdlogname[cmdindex])
1033                 {
1034                         // LordHavoc: fix for bizarre problem in MSVC that I do not understand (if I assign the string pointer directly it ends up storing a NULL pointer)
1035                         temp = "<unknown>";
1036                         cmdlogname[cmdindex] = temp;
1037                 }
1038
1039                 // other commands
1040                 switch (cmd)
1041                 {
1042                 default:
1043                         {
1044                                 char description[32*64], temp[64];
1045                                 int count;
1046                                 strcpy(description, "packet dump: ");
1047                                 i = cmdcount - 32;
1048                                 if (i < 0)
1049                                         i = 0;
1050                                 count = cmdcount - i;
1051                                 i &= 31;
1052                                 while(count > 0)
1053                                 {
1054                                         sprintf(temp, "%3i:%s ", cmdlog[i], cmdlogname[i]);
1055                                         strcat(description, temp);
1056                                         count--;
1057                                         i++;
1058                                         i &= 31;
1059                                 }
1060                                 description[strlen(description)-1] = '\n'; // replace the last space with a newline
1061                                 Con_Printf("%s", description);
1062                                 Host_Error ("CL_ParseServerMessage: Illegible server message\n");
1063                         }
1064                         break;
1065
1066                 case svc_nop:
1067                         break;
1068
1069                 case svc_time:
1070                         if (!entitiesupdated)
1071                         {
1072                                 // this is a new frame, we'll be seeing entities,
1073                                 // so prepare for entity updates
1074                                 CL_EntityUpdateSetup();
1075                                 entitiesupdated = true;
1076                         }
1077                         cl.mtime[1] = cl.mtime[0];
1078                         cl.mtime[0] = MSG_ReadFloat ();
1079                         break;
1080
1081                 case svc_clientdata:
1082                         i = MSG_ReadShort ();
1083                         CL_ParseClientdata (i);
1084                         break;
1085
1086                 case svc_version:
1087                         i = MSG_ReadLong ();
1088                         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION1 && i != DPPROTOCOL_VERSION2 && i != DPPROTOCOL_VERSION3 && i != 250)
1089                                 Host_Error ("CL_ParseServerMessage: Server is protocol %i, not %i, %i, %i or %i", i, DPPROTOCOL_VERSION1, DPPROTOCOL_VERSION2, DPPROTOCOL_VERSION3, PROTOCOL_VERSION);
1090                         Nehahrademcompatibility = false;
1091                         if (i == 250)
1092                                 Nehahrademcompatibility = true;
1093                         if (cls.demoplayback && demo_nehahra.integer)
1094                                 Nehahrademcompatibility = true;
1095                         dpprotocol = i;
1096                         if (dpprotocol != DPPROTOCOL_VERSION1 && dpprotocol != DPPROTOCOL_VERSION2 && dpprotocol != DPPROTOCOL_VERSION3)
1097                                 dpprotocol = 0;
1098                         break;
1099
1100                 case svc_disconnect:
1101                         Host_EndGame ("Server disconnected\n");
1102
1103                 case svc_print:
1104                         Con_Printf ("%s", MSG_ReadString ());
1105                         break;
1106
1107                 case svc_centerprint:
1108                         SCR_CenterPrint (MSG_ReadString ());
1109                         break;
1110
1111                 case svc_stufftext:
1112                         Cbuf_AddText (MSG_ReadString ());
1113                         break;
1114
1115                 case svc_damage:
1116                         V_ParseDamage ();
1117                         break;
1118
1119                 case svc_serverinfo:
1120                         CL_ParseServerInfo ();
1121                         break;
1122
1123                 case svc_setangle:
1124                         for (i=0 ; i<3 ; i++)
1125                                 cl.viewangles[i] = MSG_ReadAngle ();
1126                         break;
1127
1128                 case svc_setview:
1129                         cl.viewentity = MSG_ReadShort ();
1130                         // LordHavoc: assume first setview recieved is the real player entity
1131                         if (!cl.playerentity)
1132                                 cl.playerentity = cl.viewentity;
1133                         break;
1134
1135                 case svc_lightstyle:
1136                         i = MSG_ReadByte ();
1137                         if (i >= MAX_LIGHTSTYLES)
1138                                 Host_Error ("svc_lightstyle >= MAX_LIGHTSTYLES");
1139                         strncpy (cl_lightstyle[i].map,  MSG_ReadString(), MAX_STYLESTRING - 1);
1140                         cl_lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
1141                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
1142                         break;
1143
1144                 case svc_sound:
1145                         CL_ParseStartSoundPacket(false);
1146                         break;
1147
1148                 case svc_sound2:
1149                         CL_ParseStartSoundPacket(true);
1150                         break;
1151
1152                 case svc_stopsound:
1153                         i = MSG_ReadShort();
1154                         S_StopSound(i>>3, i&7);
1155                         break;
1156
1157                 case svc_updatename:
1158                         i = MSG_ReadByte ();
1159                         if (i >= cl.maxclients)
1160                                 Host_Error ("CL_ParseServerMessage: svc_updatename >= cl.maxclients");
1161                         strcpy (cl.scores[i].name, MSG_ReadString ());
1162                         break;
1163
1164                 case svc_updatefrags:
1165                         i = MSG_ReadByte ();
1166                         if (i >= cl.maxclients)
1167                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
1168                         cl.scores[i].frags = MSG_ReadShort ();
1169                         break;
1170
1171                 case svc_updatecolors:
1172                         i = MSG_ReadByte ();
1173                         if (i >= cl.maxclients)
1174                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors >= cl.maxclients");
1175                         cl.scores[i].colors = MSG_ReadByte ();
1176                         break;
1177
1178                 case svc_particle:
1179                         CL_ParseParticleEffect ();
1180                         break;
1181
1182                 case svc_effect:
1183                         CL_ParseEffect ();
1184                         break;
1185
1186                 case svc_effect2:
1187                         CL_ParseEffect2 ();
1188                         break;
1189
1190                 case svc_spawnbaseline:
1191                         i = MSG_ReadShort ();
1192                         if (i < 0 || i >= MAX_EDICTS)
1193                                 Host_Error ("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
1194                         CL_ParseBaseline (cl_entities + i, false);
1195                         break;
1196                 case svc_spawnbaseline2:
1197                         i = MSG_ReadShort ();
1198                         if (i < 0 || i >= MAX_EDICTS)
1199                                 Host_Error ("CL_ParseServerMessage: svc_spawnbaseline2: invalid entity number %i", i);
1200                         CL_ParseBaseline (cl_entities + i, true);
1201                         break;
1202                 case svc_spawnstatic:
1203                         CL_ParseStatic (false);
1204                         break;
1205                 case svc_spawnstatic2:
1206                         CL_ParseStatic (true);
1207                         break;
1208                 case svc_temp_entity:
1209                         CL_ParseTEnt ();
1210                         break;
1211
1212                 case svc_setpause:
1213                         cl.paused = MSG_ReadByte ();
1214                         if (cl.paused)
1215                                 CDAudio_Pause ();
1216                         else
1217                                 CDAudio_Resume ();
1218                         break;
1219
1220                 case svc_signonnum:
1221                         i = MSG_ReadByte ();
1222                         if (i <= cls.signon)
1223                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
1224                         cls.signon = i;
1225                         CL_SignonReply ();
1226                         break;
1227
1228                 case svc_killedmonster:
1229                         cl.stats[STAT_MONSTERS]++;
1230                         break;
1231
1232                 case svc_foundsecret:
1233                         cl.stats[STAT_SECRETS]++;
1234                         break;
1235
1236                 case svc_updatestat:
1237                         i = MSG_ReadByte ();
1238                         if (i < 0 || i >= MAX_CL_STATS)
1239                                 Host_Error ("svc_updatestat: %i is invalid", i);
1240                         cl.stats[i] = MSG_ReadLong ();
1241                         break;
1242
1243                 case svc_spawnstaticsound:
1244                         CL_ParseStaticSound (false);
1245                         break;
1246
1247                 case svc_spawnstaticsound2:
1248                         CL_ParseStaticSound (true);
1249                         break;
1250
1251                 case svc_cdtrack:
1252                         cl.cdtrack = MSG_ReadByte ();
1253                         cl.looptrack = MSG_ReadByte ();
1254                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
1255                                 CDAudio_Play ((qbyte)cls.forcetrack, true);
1256                         else
1257                                 CDAudio_Play ((qbyte)cl.cdtrack, true);
1258                         break;
1259
1260                 case svc_intermission:
1261                         cl.intermission = 1;
1262                         cl.completed_time = cl.time;
1263                         break;
1264
1265                 case svc_finale:
1266                         cl.intermission = 2;
1267                         cl.completed_time = cl.time;
1268                         SCR_CenterPrint (MSG_ReadString ());
1269                         break;
1270
1271                 case svc_cutscene:
1272                         cl.intermission = 3;
1273                         cl.completed_time = cl.time;
1274                         SCR_CenterPrint (MSG_ReadString ());
1275                         break;
1276
1277                 case svc_sellscreen:
1278                         Cmd_ExecuteString ("help", src_command);
1279                         break;
1280                 case svc_hidelmp:
1281                         SHOWLMP_decodehide();
1282                         break;
1283                 case svc_showlmp:
1284                         SHOWLMP_decodeshow();
1285                         break;
1286                 case svc_skybox:
1287                         R_SetSkyBox(MSG_ReadString());
1288                         break;
1289                 case svc_cgame:
1290                         {
1291                                 int length;
1292                                 length = (int) ((unsigned short) MSG_ReadShort());
1293                                 for (i = 0;i < length;i++)
1294                                         cgamenetbuffer[i] = MSG_ReadByte();
1295                                 if (!msg_badread)
1296                                         CL_CGVM_ParseNetwork(cgamenetbuffer, length);
1297                         }
1298                         break;
1299                 case svc_entities:
1300                         if (cls.signon == SIGNONS - 1)
1301                         {
1302                                 // first update is the final signon stage
1303                                 cls.signon = SIGNONS;
1304                                 CL_SignonReply ();
1305                         }
1306                         CL_ReadEntityFrame();
1307                         break;
1308                 }
1309         }
1310
1311         if (entitiesupdated)
1312                 CL_EntityUpdateEnd();
1313 }
1314