split render portion of entity_t struct into entity_render_t
[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         "", // 37
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         "", // 50
84         "svc_fog", // 51
85         "svc_effect", // [vector] org [byte] modelindex [byte] startframe [byte] framecount [byte] framerate
86         "svc_effect2", // [vector] org [short] modelindex [short] startframe [byte] framecount [byte] framerate
87 };
88
89 //=============================================================================
90
91 cvar_t demo_nehahra = {"demo_nehahra", "0"};
92
93 void CL_Parse_Init(void)
94 {
95         // LordHavoc: added demo_nehahra cvar
96         Cvar_RegisterVariable (&demo_nehahra);
97         if (nehahra)
98                 Cvar_SetValue("demo_nehahra", 1);
99 }
100
101 qboolean Nehahrademcompatibility; // LordHavoc: to allow playback of the early Nehahra movie segments
102 qboolean dpprotocol; // LordHavoc: whether or not the current network stream is the enhanced DarkPlaces protocol
103
104 /*
105 ===============
106 CL_EntityNum
107
108 This error checks and tracks the total number of entities
109 ===============
110 */
111 entity_t        *CL_EntityNum (int num)
112 {
113         /*
114         if (num >= cl.num_entities)
115         {
116                 if (num >= MAX_EDICTS)
117                         Host_Error ("CL_EntityNum: %i is an invalid number",num);
118                 cl.num_entities = num;
119 //              while (cl.num_entities <= num)
120 //              {
121 //                      cl_entities[cl.num_entities].colormap = -1; // no special coloring
122 //                      cl.num_entities++;
123 //              }
124         }
125         */
126         if (num >= MAX_EDICTS)
127                 Host_Error ("CL_EntityNum: %i is an invalid number",num);
128                 
129         return &cl_entities[num];
130 }
131
132
133 /*
134 ==================
135 CL_ParseStartSoundPacket
136 ==================
137 */
138 void CL_ParseStartSoundPacket(int largesoundindex)
139 {
140     vec3_t  pos;
141     int         channel, ent;
142     int         sound_num;
143     int         volume;
144     int         field_mask;
145     float       attenuation;
146         int             i;
147                    
148     field_mask = MSG_ReadByte(); 
149
150     if (field_mask & SND_VOLUME)
151                 volume = MSG_ReadByte ();
152         else
153                 volume = DEFAULT_SOUND_PACKET_VOLUME;
154         
155     if (field_mask & SND_ATTENUATION)
156                 attenuation = MSG_ReadByte () / 64.0;
157         else
158                 attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
159         
160         channel = MSG_ReadShort ();
161         if (largesoundindex)
162                 sound_num = (unsigned short) MSG_ReadShort ();
163         else
164                 sound_num = MSG_ReadByte ();
165
166         if (sound_num >= MAX_SOUNDS)
167                 Host_Error("CL_ParseStartSoundPacket: sound_num (%i) >= MAX_SOUNDS (%i)\n", sound_num, MAX_SOUNDS);
168
169         ent = channel >> 3;
170         channel &= 7;
171
172         if (ent > MAX_EDICTS)
173                 Host_Error ("CL_ParseStartSoundPacket: ent = %i", ent);
174         
175         for (i=0 ; i<3 ; i++)
176                 pos[i] = MSG_ReadCoord ();
177  
178     S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);
179 }       
180
181 /*
182 ==================
183 CL_KeepaliveMessage
184
185 When the client is taking a long time to load stuff, send keepalive messages
186 so the server doesn't disconnect.
187 ==================
188 */
189 void CL_KeepaliveMessage (void)
190 {
191         float   time;
192         static float lastmsg;
193         int             ret;
194         sizebuf_t       old;
195         byte            olddata[8192];
196         
197         if (sv.active)
198                 return;         // no need if server is local
199         if (cls.demoplayback)
200                 return;
201
202 // read messages from server, should just be nops
203         old = net_message;
204         memcpy (olddata, net_message.data, net_message.cursize);
205         
206         do
207         {
208                 ret = CL_GetMessage ();
209                 switch (ret)
210                 {
211                 default:
212                         Host_Error ("CL_KeepaliveMessage: CL_GetMessage failed");               
213                 case 0:
214                         break;  // nothing waiting
215                 case 1:
216                         Host_Error ("CL_KeepaliveMessage: received a message");
217                         break;
218                 case 2:
219                         if (MSG_ReadByte() != svc_nop)
220                                 Host_Error ("CL_KeepaliveMessage: datagram wasn't a nop");
221                         break;
222                 }
223         } while (ret);
224
225         net_message = old;
226         memcpy (net_message.data, olddata, net_message.cursize);
227
228 // check time
229         time = Sys_DoubleTime ();
230         if (time - lastmsg < 5)
231                 return;
232         lastmsg = time;
233
234 // write out a nop
235         Con_Printf ("--> client to server keepalive\n");
236
237         MSG_WriteByte (&cls.message, clc_nop);
238         NET_SendMessage (cls.netcon, &cls.message);
239         SZ_Clear (&cls.message);
240 }
241
242 void CL_ParseEntityLump(char *entdata)
243 {
244         char *data;
245         char key[128], value[4096];
246         char wadname[128];
247         int i, j, k;
248         FOG_clear(); // LordHavoc: no fog until set
249         skyname[0] = 0; // LordHavoc: no enviroment mapped sky until set
250         r_farclip.value = 6144; // LordHavoc: default farclip distance
251         data = entdata;
252         if (!data)
253                 return;
254         data = COM_Parse(data);
255         if (!data)
256                 return; // valid exit
257         if (com_token[0] != '{')
258                 return; // error
259         while (1)
260         {
261                 data = COM_Parse(data);
262                 if (!data)
263                         return; // error
264                 if (com_token[0] == '}')
265                         return; // since we're just parsing the first ent (worldspawn), exit
266                 strcpy(key, com_token);
267                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
268                         key[strlen(key)-1] = 0;
269                 data = COM_Parse(data);
270                 if (!data)
271                         return; // error
272                 strcpy(value, com_token);
273                 if (!strcmp("sky", key))
274                         R_SetSkyBox(value);
275                 else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
276                         R_SetSkyBox(value);
277                 else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
278                         R_SetSkyBox(value);
279                 else if (!strcmp("farclip", key))
280                 {
281                         r_farclip.value = atof(value);
282                         if (r_farclip.value < 64)
283                                 r_farclip.value = 64;
284                 }
285                 else if (!strcmp("fog", key))
286                 {
287                         scanf(value, "%f %f %f %f", &fog_density, &fog_red, &fog_green, &fog_blue);
288                         j = 0;
289                 }
290                 else if (!strcmp("fog_density", key))
291                         fog_density = atof(value);
292                 else if (!strcmp("fog_red", key))
293                         fog_red = atof(value);
294                 else if (!strcmp("fog_green", key))
295                         fog_green = atof(value);
296                 else if (!strcmp("fog_blue", key))
297                         fog_blue = atof(value);
298                 else if (!strcmp("wad", key)) // for HalfLife maps
299                 {
300                         if (hlbsp)
301                         {
302                                 j = 0;
303                                 for (i = 0;i < 4096;i++)
304                                         if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':')
305                                                 break;
306                                 if (value[i])
307                                 {
308                                         for (;i < 4096;i++)
309                                         {
310                                                 // ignore path - the \\ check is for HalfLife... stupid windoze 'programmers'...
311                                                 if (value[i] == '\\' || value[i] == '/' || value[i] == ':')
312                                                         j = i+1;
313                                                 else if (value[i] == ';' || value[i] == 0)
314                                                 {
315                                                         k = value[i];
316                                                         value[i] = 0;
317                                                         strcpy(wadname, "textures/");
318                                                         strcat(wadname, &value[j]);
319                                                         W_LoadTextureWadFile (wadname, false);
320                                                         j = i+1;
321                                                         if (!k)
322                                                                 break;
323                                                 }
324                                         }
325                                 }
326                         }
327                 }
328         }
329 }
330
331 /*
332 ==================
333 CL_ParseServerInfo
334 ==================
335 */
336 void CL_ParseServerInfo (void)
337 {
338         char    *str;
339         int             i;
340         int             nummodels, numsounds;
341         char    model_precache[MAX_MODELS][MAX_QPATH];
342         char    sound_precache[MAX_SOUNDS][MAX_QPATH];
343         
344         Con_DPrintf ("Serverinfo packet received.\n");
345 //
346 // wipe the client_state_t struct
347 //
348         CL_ClearState ();
349
350 // parse protocol version number
351         i = MSG_ReadLong ();
352         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION && i != 250)
353         {
354                 Con_Printf ("Server returned version %i, not %i or %i", i, DPPROTOCOL_VERSION, PROTOCOL_VERSION);
355                 return;
356         }
357         Nehahrademcompatibility = false;
358         if (i == 250)
359                 Nehahrademcompatibility = true;
360         if (cls.demoplayback && demo_nehahra.value)
361                 Nehahrademcompatibility = true;
362         dpprotocol = i == DPPROTOCOL_VERSION;
363
364 // parse maxclients
365         cl.maxclients = MSG_ReadByte ();
366         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
367         {
368                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
369                 return;
370         }
371         cl.scores = Hunk_AllocName (cl.maxclients*sizeof(*cl.scores), "scores");
372
373 // parse gametype
374         cl.gametype = MSG_ReadByte ();
375
376 // parse signon message
377         str = MSG_ReadString ();
378         strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
379
380 // seperate the printfs so the server message can have a color
381         if (!Nehahrademcompatibility) // no messages when playing the Nehahra movie
382         {
383                 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");
384                 Con_Printf ("%c%s\n", 2, str);
385         }
386
387 //
388 // first we go through and touch all of the precache data that still
389 // happens to be in the cache, so precaching something else doesn't
390 // needlessly purge it
391 //
392
393 // precache models
394         memset (cl.model_precache, 0, sizeof(cl.model_precache));
395         for (nummodels=1 ; ; nummodels++)
396         {
397                 str = MSG_ReadString ();
398                 if (!str[0])
399                         break;
400                 if (nummodels==MAX_MODELS)
401                 {
402                         Con_Printf ("Server sent too many model precaches\n");
403                         return;
404                 }
405                 if (strlen(str) >= MAX_QPATH)
406                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
407                 strcpy (model_precache[nummodels], str);
408                 Mod_TouchModel (str);
409         }
410
411 // precache sounds
412         memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
413         for (numsounds=1 ; ; numsounds++)
414         {
415                 str = MSG_ReadString ();
416                 if (!str[0])
417                         break;
418                 if (numsounds==MAX_SOUNDS)
419                 {
420                         Con_Printf ("Server sent too many sound precaches\n");
421                         return;
422                 }
423                 if (strlen(str) >= MAX_QPATH)
424                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
425                 strcpy (sound_precache[numsounds], str);
426                 S_TouchSound (str);
427         }
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                 isworldmodel = i == 1; // LordHavoc: first model is the world model
436                 cl.model_precache[i] = Mod_ForName (model_precache[i], false);
437                 if (cl.model_precache[i] == NULL)
438                 {
439                         Con_Printf("Model %s not found\n", model_precache[i]);
440                         return;
441                 }
442                 CL_KeepaliveMessage ();
443         }
444
445         S_BeginPrecaching ();
446         for (i=1 ; i<numsounds ; i++)
447         {
448                 cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);
449                 CL_KeepaliveMessage ();
450         }
451         S_EndPrecaching ();
452
453
454 // local state
455         cl_entities[0].render.model = cl.worldmodel = cl.model_precache[1];
456         
457         R_NewMap ();
458
459         Hunk_Check ();          // make sure nothing is hurt
460         
461         noclip_anglehack = false;               // noclip is turned off at start        
462 }
463
464 void CL_ValidateState(entity_state_t *s)
465 {
466         model_t *model;
467
468         if (!s->active)
469                 return;
470
471         if (s->modelindex >= MAX_MODELS)
472                 Host_Error("CL_ValidateState: modelindex (%i) >= MAX_MODELS (%i)\n", s->modelindex, MAX_MODELS);
473
474         // colormap is client index + 1
475         if (s->colormap > cl.maxclients)
476                 Host_Error ("CL_ValidateState: colormap (%i) > cl.maxclients (%i)", s->colormap, cl.maxclients);
477
478         model = cl.model_precache[s->modelindex];
479         if (model && s->frame >= model->numframes)
480         {
481                 Con_DPrintf("CL_ValidateState: no such frame %i in \"%s\"\n", s->frame, model->name);
482                 s->frame = 0;
483         }
484 }
485
486 /*
487 ==================
488 CL_ParseUpdate
489
490 Parse an entity update message from the server
491 If an entities model or origin changes from frame to frame, it must be
492 relinked.  Other attributes can change without relinking.
493 ==================
494 */
495 byte entkill[MAX_EDICTS];
496 int bitprofile[32], bitprofilecount = 0;
497 void CL_ParseUpdate (int bits)
498 {
499         int i, num, deltadie;
500         entity_t *ent;
501
502         if (cls.signon == SIGNONS - 1)
503         {       // first update is the final signon stage
504                 cls.signon = SIGNONS;
505                 CL_SignonReply ();
506         }
507
508         if (bits & U_MOREBITS)
509                 bits |= (MSG_ReadByte()<<8);
510         if ((bits & U_EXTEND1) && (!Nehahrademcompatibility))
511         {
512                 bits |= MSG_ReadByte() << 16;
513                 if (bits & U_EXTEND2)
514                         bits |= MSG_ReadByte() << 24;
515         }
516
517         if (bits & U_LONGENTITY)        
518                 num = (unsigned) MSG_ReadShort ();
519         else
520                 num = (unsigned) MSG_ReadByte ();
521
522         if (num >= MAX_EDICTS)
523                 Host_Error("CL_ParseUpdate: entity number (%i) >= MAX_EDICTS (%i)\n", num, MAX_EDICTS);
524         if (num < 1)
525                 Host_Error("CL_ParseUpdate: invalid entity number (%i)\n", num);
526
527         // mark as visible (no kill)
528         entkill[num] = 0;
529
530         ent = CL_EntityNum (num);
531
532         for (i = 0;i < 32;i++)
533                 if (bits & (1 << i))
534                         bitprofile[i]++;
535         bitprofilecount++;
536
537         ent->state_previous = ent->state_current;
538         deltadie = false;
539         if (bits & U_DELTA)
540         {
541                 if (!ent->state_current.active)
542                         deltadie = true; // was not present in previous frame, leave hidden until next full update
543         }
544         else
545                 ent->state_current = ent->state_baseline;
546
547         ent->state_current.time = cl.mtime[0];
548
549         ent->state_current.flags = 0;
550         ent->state_current.active = true;
551         if (bits & U_MODEL)             ent->state_current.modelindex = (ent->state_current.modelindex & 0xFF00) | MSG_ReadByte();
552         if (bits & U_FRAME)             ent->state_current.frame = (ent->state_current.frame & 0xFF00) | MSG_ReadByte();
553         if (bits & U_COLORMAP)  ent->state_current.colormap = MSG_ReadByte();
554         if (bits & U_SKIN)              ent->state_current.skin = MSG_ReadByte();
555         if (bits & U_EFFECTS)   ent->state_current.effects = (ent->state_current.effects & 0xFF00) | MSG_ReadByte();
556         if (bits & U_ORIGIN1)   ent->state_current.origin[0] = MSG_ReadCoord();
557         if (bits & U_ANGLE1)    ent->state_current.angles[0] = MSG_ReadAngle();
558         if (bits & U_ORIGIN2)   ent->state_current.origin[1] = MSG_ReadCoord();
559         if (bits & U_ANGLE2)    ent->state_current.angles[1] = MSG_ReadAngle();
560         if (bits & U_ORIGIN3)   ent->state_current.origin[2] = MSG_ReadCoord();
561         if (bits & U_ANGLE3)    ent->state_current.angles[2] = MSG_ReadAngle();
562         if (bits & U_STEP)              ent->state_current.flags |= RENDER_STEP;
563         if (bits & U_ALPHA)             ent->state_current.alpha = MSG_ReadByte();
564         if (bits & U_SCALE)             ent->state_current.scale = MSG_ReadByte();
565         if (bits & U_EFFECTS2)  ent->state_current.effects = (ent->state_current.effects & 0x00FF) | (MSG_ReadByte() << 8);
566         if (bits & U_GLOWSIZE)  ent->state_current.glowsize = MSG_ReadByte();
567         if (bits & U_GLOWCOLOR) ent->state_current.glowcolor = MSG_ReadByte();
568         if (bits & U_GLOWTRAIL) ent->state_current.flags |= RENDER_GLOWTRAIL;
569         if (bits & U_COLORMOD)  ent->state_current.colormod = MSG_ReadByte();
570         if (bits & U_FRAME2)    ent->state_current.frame = (ent->state_current.frame & 0x00FF) | (MSG_ReadByte() << 8);
571         if (bits & U_MODEL2)    ent->state_current.modelindex = (ent->state_current.modelindex & 0x00FF) | (MSG_ReadByte() << 8);
572         if (bits & U_VIEWMODEL) ent->state_current.flags |= RENDER_VIEWMODEL;
573         if (bits & U_EXTERIORMODEL)     ent->state_current.flags |= RENDER_EXTERIORMODEL;
574
575         // LordHavoc: to allow playback of the Nehahra movie
576         if (Nehahrademcompatibility && (bits & U_EXTEND1))
577         {
578                 // LordHavoc: evil format
579                 int i = MSG_ReadFloat();
580                 int j = MSG_ReadFloat() * 255.0f;
581                 if (i == 2)
582                 {
583                         if (MSG_ReadFloat())
584                                 ent->state_current.effects |= EF_FULLBRIGHT;
585                 }
586                 if (j < 0)
587                         ent->state_current.alpha = 0;
588                 else if (j == 0 || j >= 255)
589                         ent->state_current.alpha = 255;
590                 else
591                         ent->state_current.alpha = j;
592         }
593
594         if (deltadie)
595         {
596                 // hide the entity
597                 ent->state_current.active = false;
598         }
599         else
600         {
601                 CL_ValidateState(&ent->state_current);
602
603                 /*
604                 if (!ent->state_current.active)
605                 {
606                         if (bits & U_DELTA)
607                         {
608                                 if (bits & U_MODEL)
609                                         Con_Printf("CL_ParseUpdate: delta NULL model on %i: %i %i\n", num, ent->state_previous.modelindex, ent->state_current.modelindex);
610                                 else
611                                         Con_Printf("CL_ParseUpdate: delta NULL model on %i: %i\n", num, ent->state_previous.modelindex);
612                         }
613                         else
614                         {
615                                 if (bits & U_MODEL)
616                                         Con_Printf("CL_ParseUpdate:       NULL model on %i: %i %i\n", num, ent->state_baseline.modelindex, ent->state_current.modelindex);
617                                 else
618                                         Con_Printf("CL_ParseUpdate:       NULL model on %i: %i\n", num, ent->state_baseline.modelindex);
619                         }
620                 }
621                 */
622         }
623 }
624
625 char *bitprofilenames[32] =
626 {
627         "U_MOREBITS",
628         "U_ORIGIN1",
629         "U_ORIGIN2",
630         "U_ORIGIN3",
631         "U_ANGLE2",
632         "U_STEP",
633         "U_FRAME",
634         "U_SIGNAL",
635         "U_ANGLE1",
636         "U_ANGLE3",
637         "U_MODEL",
638         "U_COLORMAP",
639         "U_SKIN",
640         "U_EFFECTS",
641         "U_LONGENTITY",
642         "U_EXTEND1",
643         "U_DELTA",
644         "U_ALPHA",
645         "U_SCALE",
646         "U_EFFECTS2",
647         "U_GLOWSIZE",
648         "U_GLOWCOLOR",
649         "U_COLORMOD",
650         "U_EXTEND2",
651         "U_GLOWTRAIL",
652         "U_VIEWMODEL",
653         "U_FRAME2",
654         "U_MODEL2",
655         "U_EXTERIORMODEL",
656         "U_UNUSED29",
657         "U_UNUSED30",
658         "U_EXTEND3",
659 };
660
661 void CL_BitProfile_f(void)
662 {
663         int i;
664         Con_Printf("bitprofile: %i updates\n");
665         if (bitprofilecount)
666                 for (i = 0;i < 32;i++)
667 //                      if (bitprofile[i])
668                                 Con_Printf("%s: %i %3.2f%%\n", bitprofilenames[i], bitprofile[i], bitprofile[i] * 100.0 / bitprofilecount);
669         Con_Printf("\n");
670         for (i = 0;i < 32;i++)
671                 bitprofile[i] = 0;
672         bitprofilecount = 0;
673 }
674
675 void CL_EntityUpdateSetup(void)
676 {
677         memset(entkill, 1, MAX_EDICTS);
678 }
679
680 void CL_EntityUpdateEnd(void)
681 {
682         int i;
683         for (i = 1;i < MAX_EDICTS;i++)
684                 if (entkill[i])
685                         cl_entities[i].state_previous.active = cl_entities[i].state_current.active = 0;
686 }
687
688 /*
689 ==================
690 CL_ParseBaseline
691 ==================
692 */
693 void CL_ParseBaseline (entity_t *ent, int large)
694 {
695         int i;
696
697         memset(&ent->state_baseline, 0, sizeof(entity_state_t));
698         ent->state_baseline.active = true;
699         if (large)
700         {
701                 ent->state_baseline.modelindex = (unsigned short) MSG_ReadShort ();
702                 ent->state_baseline.frame = (unsigned short) MSG_ReadShort ();
703         }
704         else
705         {
706                 ent->state_baseline.modelindex = MSG_ReadByte ();
707                 ent->state_baseline.frame = MSG_ReadByte ();
708         }
709         ent->state_baseline.colormap = MSG_ReadByte();
710         ent->state_baseline.skin = MSG_ReadByte();
711         for (i = 0;i < 3;i++)
712         {
713                 ent->state_baseline.origin[i] = MSG_ReadCoord ();
714                 ent->state_baseline.angles[i] = MSG_ReadAngle ();
715         }
716         ent->state_baseline.alpha = 255;
717         ent->state_baseline.scale = 16;
718         ent->state_baseline.glowsize = 0;
719         ent->state_baseline.glowcolor = 254;
720         ent->state_baseline.colormod = 255;
721         ent->state_previous = ent->state_current = ent->state_baseline;
722
723         CL_ValidateState(&ent->state_baseline);
724 }
725
726
727 /*
728 ==================
729 CL_ParseClientdata
730
731 Server information pertaining to this client only
732 ==================
733 */
734 void CL_ParseClientdata (int bits)
735 {
736         int i, j;
737
738         bits &= 0xFFFF;
739         if (bits & SU_EXTEND1)
740                 bits |= (MSG_ReadByte() << 16);
741         if (bits & SU_EXTEND2)
742                 bits |= (MSG_ReadByte() << 24);
743
744         if (bits & SU_VIEWHEIGHT)
745                 cl.viewheight = MSG_ReadChar ();
746         else
747                 cl.viewheight = DEFAULT_VIEWHEIGHT;
748
749         if (bits & SU_IDEALPITCH)
750                 cl.idealpitch = MSG_ReadChar ();
751         else
752                 cl.idealpitch = 0;
753         
754         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
755         for (i=0 ; i<3 ; i++)
756         {
757                 if (bits & (SU_PUNCH1<<i) )
758                 {
759                         if (dpprotocol)
760                                 cl.punchangle[i] = MSG_ReadPreciseAngle();
761                         else
762                                 cl.punchangle[i] = MSG_ReadChar();
763                 }
764                 else
765                         cl.punchangle[i] = 0;
766                 if (bits & (SU_PUNCHVEC1<<i))
767                         cl.punchvector[i] = MSG_ReadFloatCoord();
768                 else
769                         cl.punchvector[i] = 0;
770                 if (bits & (SU_VELOCITY1<<i) )
771                         cl.mvelocity[0][i] = MSG_ReadChar()*16;
772                 else
773                         cl.mvelocity[0][i] = 0;
774         }
775
776         i = MSG_ReadLong ();
777         if (cl.items != i)
778         {       // set flash times
779                 for (j=0 ; j<32 ; j++)
780                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
781                                 cl.item_gettime[j] = cl.time;
782                 cl.items = i;
783         }
784                 
785         cl.onground = (bits & SU_ONGROUND) != 0;
786         cl.inwater = (bits & SU_INWATER) != 0;
787
788         cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
789         cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
790         cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
791         cl.stats[STAT_HEALTH] = MSG_ReadShort();
792         cl.stats[STAT_AMMO] = MSG_ReadByte();
793
794         cl.stats[STAT_SHELLS] = MSG_ReadByte();
795         cl.stats[STAT_NAILS] = MSG_ReadByte();
796         cl.stats[STAT_ROCKETS] = MSG_ReadByte();
797         cl.stats[STAT_CELLS] = MSG_ReadByte();
798
799         i = MSG_ReadByte ();
800
801         if (standard_quake)
802                 cl.stats[STAT_ACTIVEWEAPON] = i;
803         else
804                 cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
805 }
806
807 /*
808 =====================
809 CL_ParseStatic
810 =====================
811 */
812 void CL_ParseStatic (int large)
813 {
814         entity_t *ent;
815                 
816         if (cl.num_statics >= MAX_STATIC_ENTITIES)
817                 Host_Error ("Too many static entities");
818         ent = &cl_static_entities[cl.num_statics++];
819         CL_ParseBaseline (ent, large);
820
821 // copy it to the current state
822         ent->render.model = cl.model_precache[ent->state_baseline.modelindex];
823         ent->render.frame = ent->render.frame1 = ent->render.frame2 = ent->state_baseline.frame;
824         ent->render.framelerp = 0;
825         ent->render.lerp_starttime = -1;
826         // make torchs play out of sync
827         ent->render.frame1start = ent->render.frame2start = -(rand() & 32767);
828         ent->render.colormap = -1; // no special coloring
829         ent->render.skinnum = ent->state_baseline.skin;
830         ent->render.effects = ent->state_baseline.effects;
831         ent->render.alpha = 1;
832         ent->render.scale = 1;
833         ent->render.alpha = 1;
834         ent->render.colormod[0] = ent->render.colormod[1] = ent->render.colormod[2] = 1;
835
836         VectorCopy (ent->state_baseline.origin, ent->render.origin);
837         VectorCopy (ent->state_baseline.angles, ent->render.angles);    
838 }
839
840 /*
841 ===================
842 CL_ParseStaticSound
843 ===================
844 */
845 void CL_ParseStaticSound (int large)
846 {
847         vec3_t          org;
848         int                     sound_num, vol, atten;
849
850         MSG_ReadVector(org);
851         if (large)
852                 sound_num = (unsigned short) MSG_ReadShort ();
853         else
854                 sound_num = MSG_ReadByte ();
855         vol = MSG_ReadByte ();
856         atten = MSG_ReadByte ();
857         
858         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
859 }
860
861 void CL_ParseEffect (void)
862 {
863         vec3_t          org;
864         int                     modelindex, startframe, framecount, framerate;
865
866         MSG_ReadVector(org);
867         modelindex = MSG_ReadByte ();
868         startframe = MSG_ReadByte ();
869         framecount = MSG_ReadByte ();
870         framerate = MSG_ReadByte ();
871
872         CL_Effect(org, modelindex, startframe, framecount, framerate);
873 }
874
875 void CL_ParseEffect2 (void)
876 {
877         vec3_t          org;
878         int                     modelindex, startframe, framecount, framerate;
879
880         MSG_ReadVector(org);
881         modelindex = MSG_ReadShort ();
882         startframe = MSG_ReadShort ();
883         framecount = MSG_ReadByte ();
884         framerate = MSG_ReadByte ();
885
886         CL_Effect(org, modelindex, startframe, framecount, framerate);
887 }
888
889
890 #define SHOWNET(x) if(cl_shownet.value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
891
892 /*
893 =====================
894 CL_ParseServerMessage
895 =====================
896 */
897 void CL_ParseServerMessage (void)
898 {
899         int                     cmd;
900         int                     i, entitiesupdated;
901         byte            cmdlog[32];
902         char            *cmdlogname[32], *temp;
903         int                     cmdindex, cmdcount = 0;
904         
905 //
906 // if recording demos, copy the message out
907 //
908         if (cl_shownet.value == 1)
909                 Con_Printf ("%i ",net_message.cursize);
910         else if (cl_shownet.value == 2)
911                 Con_Printf ("------------------\n");
912         
913         cl.onground = false;    // unless the server says otherwise     
914 //
915 // parse the message
916 //
917         MSG_BeginReading ();
918
919         entitiesupdated = false;
920         CL_EntityUpdateSetup();
921         
922         while (1)
923         {
924                 if (msg_badread)
925                         Host_Error ("CL_ParseServerMessage: Bad server message");
926
927                 cmd = MSG_ReadByte ();
928
929                 if (cmd == -1)
930                 {
931                         SHOWNET("END OF MESSAGE");
932                         break;          // end of message
933                 }
934
935                 cmdindex = cmdcount & 31;
936                 cmdcount++;
937                 cmdlog[cmdindex] = cmd;
938
939                 // if the high bit of the command byte is set, it is a fast update
940                 if (cmd & 128)
941                 {
942                         // 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)
943                         temp = "entity";
944                         cmdlogname[cmdindex] = temp;
945                         SHOWNET("fast update");
946                         CL_ParseUpdate (cmd&127);
947                         continue;
948                 }
949
950                 SHOWNET(svc_strings[cmd]);
951                 cmdlogname[cmdindex] = svc_strings[cmd];
952                 if (!cmdlogname[cmdindex])
953                 {
954                         // 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)
955                         temp = "<unknown>";
956                         cmdlogname[cmdindex] = temp;
957                 }
958         
959                 // other commands
960                 switch (cmd)
961                 {
962                 default:
963                         {
964                                 char description[32*64], temp[64];
965                                 int count;
966                                 strcpy(description, "packet dump: ");
967                                 i = cmdcount - 32;
968                                 if (i < 0)
969                                         i = 0;
970                                 count = cmdcount - i;
971                                 i &= 31;
972                                 while(count > 0)
973                                 {
974                                         sprintf(temp, "%3i:%s ", cmdlog[i], cmdlogname[i]);
975                                         strcat(description, temp);
976                                         count--;
977                                         i++;
978                                         i &= 31;
979                                 }
980                                 description[strlen(description)-1] = '\n'; // replace the last space with a newline
981                                 Con_Printf(description);
982                                 Host_Error ("CL_ParseServerMessage: Illegible server message\n");
983                         }
984                         break;
985                         
986                 case svc_nop:
987 //                      Con_Printf ("svc_nop\n");
988                         break;
989                         
990                 case svc_time:
991                         // handle old protocols which do not have entity update ranges
992                         entitiesupdated = true;
993                         cl.mtime[1] = cl.mtime[0];
994                         cl.mtime[0] = MSG_ReadFloat ();                 
995                         break;
996                         
997                 case svc_clientdata:
998                         i = MSG_ReadShort ();
999                         CL_ParseClientdata (i);
1000                         break;
1001                 
1002                 case svc_version:
1003                         i = MSG_ReadLong ();
1004                         if (i != PROTOCOL_VERSION && i != DPPROTOCOL_VERSION && i != 250)
1005                                 Host_Error ("CL_ParseServerMessage: Server is protocol %i, not %i or %i", i, DPPROTOCOL_VERSION, PROTOCOL_VERSION);
1006                         Nehahrademcompatibility = false;
1007                         if (i == 250)
1008                                 Nehahrademcompatibility = true;
1009                         if (cls.demoplayback && demo_nehahra.value)
1010                                 Nehahrademcompatibility = true;
1011                         dpprotocol = i == DPPROTOCOL_VERSION;
1012                         break;
1013                         
1014                 case svc_disconnect:
1015                         Host_EndGame ("Server disconnected\n");
1016
1017                 case svc_print:
1018                         Con_Printf ("%s", MSG_ReadString ());
1019                         break;
1020                         
1021                 case svc_centerprint:
1022                         SCR_CenterPrint (MSG_ReadString ());
1023                         break;
1024                         
1025                 case svc_stufftext:
1026                         Cbuf_AddText (MSG_ReadString ());
1027                         break;
1028                         
1029                 case svc_damage:
1030                         V_ParseDamage ();
1031                         break;
1032                         
1033                 case svc_serverinfo:
1034                         CL_ParseServerInfo ();
1035                         vid.recalc_refdef = true;       // leave intermission full screen
1036                         break;
1037                         
1038                 case svc_setangle:
1039                         for (i=0 ; i<3 ; i++)
1040                                 cl.viewangles[i] = MSG_ReadAngle ();
1041                         break;
1042                         
1043                 case svc_setview:
1044                         cl.viewentity = MSG_ReadShort ();
1045                         break;
1046                                         
1047                 case svc_lightstyle:
1048                         i = MSG_ReadByte ();
1049                         if (i >= MAX_LIGHTSTYLES)
1050                                 Host_Error ("svc_lightstyle >= MAX_LIGHTSTYLES");
1051                         strncpy (cl_lightstyle[i].map,  MSG_ReadString(), MAX_STYLESTRING - 1);
1052                         cl_lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
1053                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
1054                         break;
1055                         
1056                 case svc_sound:
1057                         CL_ParseStartSoundPacket(false);
1058                         break;
1059
1060                 case svc_sound2:
1061                         CL_ParseStartSoundPacket(true);
1062                         break;
1063
1064                 case svc_stopsound:
1065                         i = MSG_ReadShort();
1066                         S_StopSound(i>>3, i&7);
1067                         break;
1068                 
1069                 case svc_updatename:
1070                         i = MSG_ReadByte ();
1071                         if (i >= cl.maxclients)
1072                                 Host_Error ("CL_ParseServerMessage: svc_updatename >= MAX_SCOREBOARD");
1073                         strcpy (cl.scores[i].name, MSG_ReadString ());
1074                         break;
1075                         
1076                 case svc_updatefrags:
1077                         i = MSG_ReadByte ();
1078                         if (i >= cl.maxclients)
1079                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags >= MAX_SCOREBOARD");
1080                         cl.scores[i].frags = MSG_ReadShort ();
1081                         break;                  
1082
1083                 case svc_updatecolors:
1084                         i = MSG_ReadByte ();
1085                         if (i >= cl.maxclients)
1086                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors >= MAX_SCOREBOARD");
1087                         cl.scores[i].colors = MSG_ReadByte ();
1088                         break;
1089                         
1090                 case svc_particle:
1091                         R_ParseParticleEffect ();
1092                         break;
1093
1094                 case svc_effect:
1095                         CL_ParseEffect ();
1096                         break;
1097
1098                 case svc_effect2:
1099                         CL_ParseEffect2 ();
1100                         break;
1101
1102                 case svc_spawnbaseline:
1103                         i = MSG_ReadShort ();
1104                         // must use CL_EntityNum() to force cl.num_entities up
1105                         CL_ParseBaseline (CL_EntityNum(i), false);
1106                         break;
1107                 case svc_spawnbaseline2:
1108                         i = MSG_ReadShort ();
1109                         // must use CL_EntityNum() to force cl.num_entities up
1110                         CL_ParseBaseline (CL_EntityNum(i), true);
1111                         break;
1112                 case svc_spawnstatic:
1113                         CL_ParseStatic (false);
1114                         break;
1115                 case svc_spawnstatic2:
1116                         CL_ParseStatic (true);
1117                         break;
1118                 case svc_temp_entity:
1119                         CL_ParseTEnt ();
1120                         break;
1121
1122                 case svc_setpause:
1123                         cl.paused = MSG_ReadByte ();
1124                         if (cl.paused)
1125                                 CDAudio_Pause ();
1126                         else
1127                                 CDAudio_Resume ();
1128                         break;
1129                         
1130                 case svc_signonnum:
1131                         i = MSG_ReadByte ();
1132                         if (i <= cls.signon)
1133                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
1134                         cls.signon = i;
1135                         CL_SignonReply ();
1136                         break;
1137
1138                 case svc_killedmonster:
1139                         cl.stats[STAT_MONSTERS]++;
1140                         break;
1141
1142                 case svc_foundsecret:
1143                         cl.stats[STAT_SECRETS]++;
1144                         break;
1145
1146                 case svc_updatestat:
1147                         i = MSG_ReadByte ();
1148                         if (i < 0 || i >= MAX_CL_STATS)
1149                                 Host_Error ("svc_updatestat: %i is invalid", i);
1150                         cl.stats[i] = MSG_ReadLong ();
1151                         break;
1152                         
1153                 case svc_spawnstaticsound:
1154                         CL_ParseStaticSound (false);
1155                         break;
1156
1157                 case svc_spawnstaticsound2:
1158                         CL_ParseStaticSound (true);
1159                         break;
1160
1161                 case svc_cdtrack:
1162                         cl.cdtrack = MSG_ReadByte ();
1163                         cl.looptrack = MSG_ReadByte ();
1164                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
1165                                 CDAudio_Play ((byte)cls.forcetrack, true);
1166                         else
1167                                 CDAudio_Play ((byte)cl.cdtrack, true);
1168                         break;
1169
1170                 case svc_intermission:
1171                         cl.intermission = 1;
1172                         cl.completed_time = cl.time;
1173                         vid.recalc_refdef = true;       // go to full screen
1174                         break;
1175
1176                 case svc_finale:
1177                         cl.intermission = 2;
1178                         cl.completed_time = cl.time;
1179                         vid.recalc_refdef = true;       // go to full screen
1180                         SCR_CenterPrint (MSG_ReadString ());                    
1181                         break;
1182
1183                 case svc_cutscene:
1184                         cl.intermission = 3;
1185                         cl.completed_time = cl.time;
1186                         vid.recalc_refdef = true;       // go to full screen
1187                         SCR_CenterPrint (MSG_ReadString ());                    
1188                         break;
1189
1190                 case svc_sellscreen:
1191                         Cmd_ExecuteString ("help", src_command);
1192                         break;
1193                 case svc_hidelmp:
1194                         SHOWLMP_decodehide();
1195                         break;
1196                 case svc_showlmp:
1197                         SHOWLMP_decodeshow();
1198                         break;
1199                 }
1200         }
1201
1202         if (entitiesupdated)
1203                 CL_EntityUpdateEnd();
1204 }