clarifications about the format of svc_fog
[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[] =
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 [byte] x [byte] 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_farclip", // [coord] size
84         "svc_fog", // [byte] enable <optional past this point, only included if enable is true> [short] density*4096 [byte] red [byte] green [byte] blue
85         "svc_playerposition" // [float] x [float] y [float] z
86 };
87
88 //=============================================================================
89
90 qboolean Nehahrademcompatibility; // LordHavoc: to allow playback of the early Nehahra movie segments
91 qboolean dpprotocol; // LordHavoc: whether or not the current network stream is the enhanced DarkPlaces protocol
92
93 /*
94 ===============
95 CL_EntityNum
96
97 This error checks and tracks the total number of entities
98 ===============
99 */
100 entity_t        *CL_EntityNum (int num)
101 {
102         if (num >= cl.num_entities)
103         {
104                 if (num >= MAX_EDICTS)
105                         Host_Error ("CL_EntityNum: %i is an invalid number",num);
106                 while (cl.num_entities<=num)
107                 {
108                         cl_entities[cl.num_entities].colormap = -1; // no special coloring
109                         cl.num_entities++;
110                 }
111         }
112                 
113         return &cl_entities[num];
114 }
115
116
117 /*
118 ==================
119 CL_ParseStartSoundPacket
120 ==================
121 */
122 void CL_ParseStartSoundPacket(void)
123 {
124     vec3_t  pos;
125     int         channel, ent;
126     int         sound_num;
127     int         volume;
128     int         field_mask;
129     float       attenuation;  
130         int             i;
131                    
132     field_mask = MSG_ReadByte(); 
133
134     if (field_mask & SND_VOLUME)
135                 volume = MSG_ReadByte ();
136         else
137                 volume = DEFAULT_SOUND_PACKET_VOLUME;
138         
139     if (field_mask & SND_ATTENUATION)
140                 attenuation = MSG_ReadByte () / 64.0;
141         else
142                 attenuation = DEFAULT_SOUND_PACKET_ATTENUATION;
143         
144         channel = MSG_ReadShort ();
145         sound_num = MSG_ReadByte ();
146
147         ent = channel >> 3;
148         channel &= 7;
149
150         if (ent > MAX_EDICTS)
151                 Host_Error ("CL_ParseStartSoundPacket: ent = %i", ent);
152         
153         for (i=0 ; i<3 ; i++)
154                 pos[i] = MSG_ReadCoord ();
155  
156     S_StartSound (ent, channel, cl.sound_precache[sound_num], pos, volume/255.0, attenuation);
157 }       
158
159 /*
160 ==================
161 CL_KeepaliveMessage
162
163 When the client is taking a long time to load stuff, send keepalive messages
164 so the server doesn't disconnect.
165 ==================
166 */
167 void CL_KeepaliveMessage (void)
168 {
169         float   time;
170         static float lastmsg;
171         int             ret;
172         sizebuf_t       old;
173         byte            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                         if (MSG_ReadByte() != svc_nop)
198                                 Host_Error ("CL_KeepaliveMessage: datagram wasn't a nop");
199                         break;
200                 }
201         } while (ret);
202
203         net_message = old;
204         memcpy (net_message.data, olddata, net_message.cursize);
205
206 // check time
207         time = Sys_FloatTime ();
208         if (time - lastmsg < 5)
209                 return;
210         lastmsg = time;
211
212 // write out a nop
213         Con_Printf ("--> client to server keepalive\n");
214
215         MSG_WriteByte (&cls.message, clc_nop);
216         NET_SendMessage (cls.netcon, &cls.message);
217         SZ_Clear (&cls.message);
218 }
219
220 extern qboolean isworldmodel;
221 extern char skyname[];
222 extern void R_SetSkyBox (char *sky);
223 extern void FOG_clear();
224 extern cvar_t r_farclip;
225
226 void CL_ParseEntityLump(char *entdata)
227 {
228         char *data;
229         char key[128], value[1024];
230         char wadname[128];
231         int i, j, k;
232         FOG_clear(); // LordHavoc: no fog until set
233         skyname[0] = 0; // LordHavoc: no enviroment mapped sky until set
234         r_farclip.value = 6144; // LordHavoc: default farclip distance
235         data = entdata;
236         if (!data)
237                 return;
238         data = COM_Parse(data);
239         if (!data)
240                 return; // valid exit
241         if (com_token[0] != '{')
242                 return; // error
243         while (1)
244         {
245                 data = COM_Parse(data);
246                 if (!data)
247                         return; // error
248                 if (com_token[0] == '}')
249                         return; // since we're just parsing the first ent (worldspawn), exit
250                 strcpy(key, com_token);
251                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
252                         key[strlen(key)-1] = 0;
253                 data = COM_Parse(data);
254                 if (!data)
255                         return; // error
256                 strcpy(value, com_token);
257                 if (!strcmp("sky", key))
258                         R_SetSkyBox(value);
259                 else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
260                         R_SetSkyBox(value);
261                 else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
262                         R_SetSkyBox(value);
263                 else if (!strcmp("farclip", key))
264                 {
265                         r_farclip.value = atof(value);
266                         if (r_farclip.value < 64)
267                                 r_farclip.value = 64;
268                 }
269                 else if (!strcmp("fog", key))
270                 {
271                         scanf(value, "%f %f %f %f", &fog_density, &fog_red, &fog_green, &fog_blue);
272                         j = 0;
273                 }
274                 else if (!strcmp("fog_density", key))
275                         fog_density = atof(value);
276                 else if (!strcmp("fog_red", key))
277                         fog_red = atof(value);
278                 else if (!strcmp("fog_green", key))
279                         fog_green = atof(value);
280                 else if (!strcmp("fog_blue", key))
281                         fog_blue = atof(value);
282                 else if (!strcmp("wad", key)) // for HalfLife maps
283                 {
284                         j = 0;
285                         for (i = 0;i < 128;i++)
286                                 if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':')
287                                         break;
288                         if (value[i])
289                         {
290                                 for (;i < 128;i++)
291                                 {
292                                         // ignore path - the \\ check is for HalfLife... stupid windoze 'programmers'...
293                                         if (value[i] == '\\' || value[i] == '/' || value[i] == ':')
294                                                 j = i+1;
295                                         else if (value[i] == ';' || value[i] == 0)
296                                         {
297                                                 k = value[i];
298                                                 value[i] = 0;
299                                                 strcpy(wadname, "textures/");
300                                                 strcat(wadname, &value[j]);
301                                                 W_LoadTextureWadFile (wadname, FALSE);
302                                                 j = i+1;
303                                                 if (!k)
304                                                         break;
305                                         }
306                                 }
307                         }
308                 }
309         }
310 }
311
312 /*
313 ==================
314 CL_ParseServerInfo
315 ==================
316 */
317 extern cvar_t demo_nehahra;
318 void CL_ParseServerInfo (void)
319 {
320         char    *str;
321         int             i;
322         int             nummodels, numsounds;
323         char    model_precache[MAX_MODELS][MAX_QPATH];
324         char    sound_precache[MAX_SOUNDS][MAX_QPATH];
325         
326         Con_DPrintf ("Serverinfo packet received.\n");
327 //
328 // wipe the client_state_t struct
329 //
330         CL_ClearState ();
331
332 // parse protocol version number
333         i = MSG_ReadLong ();
334         if (i != PROTOCOL_VERSION && i != 250)
335         {
336                 Con_Printf ("Server returned version %i, not %i", i, PROTOCOL_VERSION);
337                 return;
338         }
339         Nehahrademcompatibility = false;
340         if (i == 250)
341                 Nehahrademcompatibility = true;
342         if (cls.demoplayback && demo_nehahra.value)
343                 Nehahrademcompatibility = true;
344         dpprotocol = i == DPPROTOCOL_VERSION;
345
346 // parse maxclients
347         cl.maxclients = MSG_ReadByte ();
348         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
349         {
350                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
351                 return;
352         }
353         cl.scores = Hunk_AllocName (cl.maxclients*sizeof(*cl.scores), "scores");
354
355 // parse gametype
356         cl.gametype = MSG_ReadByte ();
357
358 // parse signon message
359         str = MSG_ReadString ();
360         strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
361
362 // seperate the printfs so the server message can have a color
363         if (!Nehahrademcompatibility) // no messages when playing the Nehahra movie
364         {
365                 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");
366                 Con_Printf ("%c%s\n", 2, str);
367         }
368
369 //
370 // first we go through and touch all of the precache data that still
371 // happens to be in the cache, so precaching something else doesn't
372 // needlessly purge it
373 //
374
375 // precache models
376         memset (cl.model_precache, 0, sizeof(cl.model_precache));
377         for (nummodels=1 ; ; nummodels++)
378         {
379                 str = MSG_ReadString ();
380                 if (!str[0])
381                         break;
382                 if (nummodels==MAX_MODELS)
383                 {
384                         Con_Printf ("Server sent too many model precaches\n");
385                         return;
386                 }
387                 if (strlen(str) >= MAX_QPATH)
388                         Host_Error ("Server sent a precache name of %i characters (max %i)", strlen(str), MAX_QPATH - 1);
389                 strcpy (model_precache[nummodels], str);
390                 Mod_TouchModel (str);
391         }
392
393 // precache sounds
394         memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
395         for (numsounds=1 ; ; numsounds++)
396         {
397                 str = MSG_ReadString ();
398                 if (!str[0])
399                         break;
400                 if (numsounds==MAX_SOUNDS)
401                 {
402                         Con_Printf ("Server sent too many sound 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 (sound_precache[numsounds], str);
408                 S_TouchSound (str);
409         }
410
411 //
412 // now we try to load everything else until a cache allocation fails
413 //
414
415         for (i=1 ; i<nummodels ; i++)
416         {
417                 isworldmodel = i == 1; // LordHavoc: first model is the world model
418                 cl.model_precache[i] = Mod_ForName (model_precache[i], false);
419                 if (cl.model_precache[i] == NULL)
420                 {
421                         Con_Printf("Model %s not found\n", model_precache[i]);
422                         return;
423                 }
424                 CL_KeepaliveMessage ();
425         }
426
427         S_BeginPrecaching ();
428         for (i=1 ; i<numsounds ; i++)
429         {
430                 cl.sound_precache[i] = S_PrecacheSound (sound_precache[i]);
431                 CL_KeepaliveMessage ();
432         }
433         S_EndPrecaching ();
434
435
436 // local state
437         cl_entities[0].model = cl.worldmodel = cl.model_precache[1];
438         
439         R_NewMap ();
440
441         Hunk_Check ();          // make sure nothing is hurt
442         
443         noclip_anglehack = false;               // noclip is turned off at start        
444 }
445
446
447 /*
448 ==================
449 CL_ParseUpdate
450
451 Parse an entity update message from the server
452 If an entities model or origin changes from frame to frame, it must be
453 relinked.  Other attributes can change without relinking.
454 ==================
455 */
456 void CL_ParseUpdate (int bits)
457 {
458         int                     i, modnum, num, alpha, scale, glowsize, glowcolor, colormod;
459         model_t         *model;
460         qboolean        forcelink;
461         entity_t        *ent;
462         entity_state_t *baseline;
463
464         if (cls.signon == SIGNONS - 1)
465         {       // first update is the final signon stage
466                 cls.signon = SIGNONS;
467                 CL_SignonReply ();
468         }
469
470         if (bits & U_MOREBITS)
471                 bits |= (MSG_ReadByte()<<8);
472         if (bits & U_EXTEND1 && !Nehahrademcompatibility)
473         {
474                 bits |= MSG_ReadByte() << 16;
475                 if (bits & U_EXTEND2)
476                         bits |= MSG_ReadByte() << 24;
477         }
478
479         if (bits & U_LONGENTITY)        
480                 num = MSG_ReadShort ();
481         else
482                 num = MSG_ReadByte ();
483
484         ent = CL_EntityNum (num);
485
486         forcelink = ent->msgtime != cl.mtime[1]; // no previous frame to lerp from
487
488         ent->msgtime = cl.mtime[0];
489         
490         // LordHavoc: new protocol stuff
491         baseline = &ent->baseline;
492         if (bits & U_DELTA)
493                 baseline = &ent->deltabaseline;
494
495         if (forcelink)
496         {
497                 ent->deltabaseline.origin[0] = ent->deltabaseline.origin[1] = ent->deltabaseline.origin[2] = 0;
498                 ent->deltabaseline.angles[0] = ent->deltabaseline.angles[1] = ent->deltabaseline.angles[2] = 0;
499                 ent->deltabaseline.effects = 0;
500                 ent->deltabaseline.modelindex = 0;
501                 ent->deltabaseline.frame = 0;
502                 ent->deltabaseline.colormap = 0;
503                 ent->deltabaseline.skin = 0;
504                 ent->deltabaseline.alpha = 255;
505                 ent->deltabaseline.scale = 16;
506                 ent->deltabaseline.glowsize = 0;
507                 ent->deltabaseline.glowcolor = 254;
508                 ent->deltabaseline.colormod = 255;
509         }
510
511         modnum = bits & U_MODEL ? MSG_ReadByte() : baseline->modelindex;
512         if (modnum >= MAX_MODELS)
513                 Host_Error ("CL_ParseModel: bad modnum");
514         ent->deltabaseline.modelindex = modnum;
515                 
516         model = cl.model_precache[modnum];
517         if (model != ent->model)
518         {
519                 ent->model = model;
520         // automatic animation (torches, etc) can be either all together
521         // or randomized
522                 if (model)
523                         ent->syncbase = model->synctype == ST_RAND ? (float)(rand()&0x7fff) / 0x7fff : 0.0;
524                 else
525                         forcelink = true;       // hack to make null model players work
526         }
527
528         ent->frame = ((bits & U_FRAME) ? MSG_ReadByte() : (baseline->frame & 0xFF));
529
530         i = bits & U_COLORMAP ? MSG_ReadByte() : baseline->colormap;
531         ent->deltabaseline.colormap = i;
532         if (!i)
533                 ent->colormap = -1; // no special coloring
534         else
535         {
536                 if (i > cl.maxclients)
537                         Host_Error ("i >= cl.maxclients");
538                 ent->colormap = cl.scores[i-1].colors; // color it
539         }
540
541         ent->deltabaseline.skin = ent->skinnum = bits & U_SKIN ? MSG_ReadByte() : baseline->skin;
542
543         ent->effects = ((bits & U_EFFECTS) ? MSG_ReadByte() : (baseline->effects & 0xFF));
544
545 // shift the known values for interpolation
546         VectorCopy (ent->msg_origins[0], ent->msg_origins[1]);
547         VectorCopy (ent->msg_angles[0], ent->msg_angles[1]);
548         VectorCopy (baseline->origin, ent->msg_origins[0]);
549         VectorCopy (baseline->angles, ent->msg_angles[0]);
550
551         if (bits & U_ORIGIN1) ent->msg_origins[0][0] = MSG_ReadCoord ();
552         if (bits & U_ANGLE1) ent->msg_angles[0][0] = MSG_ReadAngle();
553         if (bits & U_ORIGIN2) ent->msg_origins[0][1] = MSG_ReadCoord ();
554         if (bits & U_ANGLE2) ent->msg_angles[0][1] = MSG_ReadAngle();
555         if (bits & U_ORIGIN3) ent->msg_origins[0][2] = MSG_ReadCoord ();
556         if (bits & U_ANGLE3) ent->msg_angles[0][2] = MSG_ReadAngle();
557
558         VectorCopy(ent->msg_origins[0], ent->deltabaseline.origin);
559         VectorCopy(ent->msg_angles[0], ent->deltabaseline.angles);
560
561         alpha = bits & U_ALPHA ? MSG_ReadByte() : baseline->alpha;
562         scale = bits & U_SCALE ? MSG_ReadByte() : baseline->scale;
563         ent->effects |= ((bits & U_EFFECTS2) ? (MSG_ReadByte() << 8) : (baseline->effects & 0xFF00));
564         glowsize = bits & U_GLOWSIZE ? MSG_ReadByte() : baseline->glowsize;
565         glowcolor = bits & U_GLOWCOLOR ? MSG_ReadByte() : baseline->glowcolor;
566         colormod = bits & U_COLORMOD ? MSG_ReadByte() : baseline->colormod;
567         ent->frame |= ((bits & U_FRAME2) ? (MSG_ReadByte() << 8) : (baseline->frame & 0xFF00));
568         ent->deltabaseline.alpha = alpha;
569         ent->deltabaseline.scale = scale;
570         ent->deltabaseline.effects = ent->effects;
571         ent->deltabaseline.glowsize = glowsize;
572         ent->deltabaseline.glowcolor = glowcolor;
573         ent->deltabaseline.colormod = colormod;
574         ent->deltabaseline.frame = ent->frame;
575         ent->alpha = (float) alpha * (1.0 / 255.0);
576         ent->scale = (float) scale * (1.0 / 16.0);
577         ent->glowsize = glowsize * 4.0;
578         ent->glowcolor = glowcolor;
579         ent->colormod[0] = (float) ((colormod >> 5) & 7) * (1.0 / 7.0);
580         ent->colormod[1] = (float) ((colormod >> 2) & 7) * (1.0 / 7.0);
581         ent->colormod[2] = (float) (colormod & 3) * (1.0 / 3.0);
582         if (bits & U_EXTEND1 && Nehahrademcompatibility) // LordHavoc: to allow playback of the early Nehahra movie segments
583         {
584                 i = MSG_ReadFloat();
585                 ent->alpha = MSG_ReadFloat();
586                 if (i == 2 && MSG_ReadFloat() != 0.0)
587                         ent->effects |= EF_FULLBRIGHT;
588                 if (ent->alpha == 0)
589                         ent->alpha = 1;
590         }
591
592         //if ( bits & U_NOLERP )
593         //      ent->forcelink = true;
594         //if (bits & U_STEP) // FIXME: implement clientside interpolation of monsters
595
596         if ( forcelink )
597         {       // didn't have an update last message
598                 VectorCopy (ent->msg_origins[0], ent->msg_origins[1]);
599                 VectorCopy (ent->msg_origins[0], ent->origin);
600                 VectorCopy (ent->msg_angles[0], ent->msg_angles[1]);
601                 VectorCopy (ent->msg_angles[0], ent->angles);
602                 ent->forcelink = true;
603         }
604 }
605
606 /*
607 ==================
608 CL_ParseBaseline
609 ==================
610 */
611 void CL_ParseBaseline (entity_t *ent)
612 {
613         int                     i;
614         
615         ent->baseline.modelindex = MSG_ReadByte ();
616         ent->baseline.frame = MSG_ReadByte ();
617         ent->baseline.colormap = MSG_ReadByte();
618         ent->baseline.skin = MSG_ReadByte();
619         for (i=0 ; i<3 ; i++)
620         {
621                 ent->baseline.origin[i] = MSG_ReadCoord ();
622                 ent->baseline.angles[i] = MSG_ReadAngle ();
623         }
624         ent->baseline.alpha = 255;
625         ent->baseline.scale = 16;
626         ent->baseline.glowsize = 0;
627         ent->baseline.glowcolor = 254;
628         ent->baseline.colormod = 255;
629 }
630
631
632 /*
633 ==================
634 CL_ParseClientdata
635
636 Server information pertaining to this client only
637 ==================
638 */
639 void CL_ParseClientdata (int bits)
640 {
641         int             i, j;
642         
643         if (bits & SU_VIEWHEIGHT)
644                 cl.viewheight = MSG_ReadChar ();
645         else
646                 cl.viewheight = DEFAULT_VIEWHEIGHT;
647
648         if (bits & SU_IDEALPITCH)
649                 cl.idealpitch = MSG_ReadChar ();
650         else
651                 cl.idealpitch = 0;
652         
653         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
654         for (i=0 ; i<3 ; i++)
655         {
656                 if (bits & (SU_PUNCH1<<i) )
657                         cl.punchangle[i] = MSG_ReadChar();
658                 else
659                         cl.punchangle[i] = 0;
660                 if (bits & (SU_VELOCITY1<<i) )
661                         cl.mvelocity[0][i] = MSG_ReadChar()*16;
662                 else
663                         cl.mvelocity[0][i] = 0;
664         }
665
666         i = MSG_ReadLong ();
667         if (cl.items != i)
668         {       // set flash times
669                 for (j=0 ; j<32 ; j++)
670                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
671                                 cl.item_gettime[j] = cl.time;
672                 cl.items = i;
673         }
674                 
675         cl.onground = (bits & SU_ONGROUND) != 0;
676         cl.inwater = (bits & SU_INWATER) != 0;
677
678         cl.stats[STAT_WEAPONFRAME] = (bits & SU_WEAPONFRAME) ? MSG_ReadByte() : 0;
679         cl.stats[STAT_ARMOR] = (bits & SU_ARMOR) ? MSG_ReadByte() : 0;
680         cl.stats[STAT_WEAPON] = (bits & SU_WEAPON) ? MSG_ReadByte() : 0;
681         cl.stats[STAT_HEALTH] = MSG_ReadShort();
682         cl.stats[STAT_AMMO] = MSG_ReadByte();
683
684         cl.stats[STAT_SHELLS] = MSG_ReadByte();
685         cl.stats[STAT_NAILS] = MSG_ReadByte();
686         cl.stats[STAT_ROCKETS] = MSG_ReadByte();
687         cl.stats[STAT_CELLS] = MSG_ReadByte();
688
689         i = MSG_ReadByte ();
690
691         if (standard_quake)
692                 cl.stats[STAT_ACTIVEWEAPON] = i;
693         else
694                 cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
695 }
696
697 /*
698 =====================
699 CL_ParseStatic
700 =====================
701 */
702 void CL_ParseStatic (void)
703 {
704         entity_t *ent;
705         int             i;
706                 
707         i = cl.num_statics;
708         if (i >= MAX_STATIC_ENTITIES)
709                 Host_Error ("Too many static entities");
710         ent = &cl_static_entities[i];
711         cl.num_statics++;
712         CL_ParseBaseline (ent);
713
714 // copy it to the current state
715         ent->model = cl.model_precache[ent->baseline.modelindex];
716         ent->frame = ent->baseline.frame;
717         ent->colormap = -1; // no special coloring
718         ent->skinnum = ent->baseline.skin;
719         ent->effects = ent->baseline.effects;
720         ent->alpha = 1;
721         ent->scale = 1;
722         ent->alpha = 1;
723         ent->glowsize = 0;
724         ent->glowcolor = 254;
725         ent->colormod[0] = ent->colormod[1] = ent->colormod[2] = 1;
726
727         VectorCopy (ent->baseline.origin, ent->origin);
728         VectorCopy (ent->baseline.angles, ent->angles); 
729         R_AddEfrags (ent);
730 }
731
732 /*
733 ===================
734 CL_ParseStaticSound
735 ===================
736 */
737 void CL_ParseStaticSound (void)
738 {
739         vec3_t          org;
740         int                     sound_num, vol, atten;
741         int                     i;
742         
743         for (i=0 ; i<3 ; i++)
744                 org[i] = MSG_ReadCoord ();
745         sound_num = MSG_ReadByte ();
746         vol = MSG_ReadByte ();
747         atten = MSG_ReadByte ();
748         
749         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
750 }
751
752
753 #define SHOWNET(x) if(cl_shownet.value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
754
755 extern void SHOWLMP_decodehide();
756 extern void SHOWLMP_decodeshow();
757 extern void R_SetSkyBox(char* sky);
758
759 /*
760 =====================
761 CL_ParseServerMessage
762 =====================
763 */
764 void CL_ParseServerMessage (void)
765 {
766         int                     cmd;
767         int                     i;
768         
769 //
770 // if recording demos, copy the message out
771 //
772         if (cl_shownet.value == 1)
773                 Con_Printf ("%i ",net_message.cursize);
774         else if (cl_shownet.value == 2)
775                 Con_Printf ("------------------\n");
776         
777         cl.onground = false;    // unless the server says otherwise     
778 //
779 // parse the message
780 //
781         MSG_BeginReading ();
782         
783         while (1)
784         {
785                 if (msg_badread)
786                         Host_Error ("CL_ParseServerMessage: Bad server message");
787
788                 cmd = MSG_ReadByte ();
789
790                 if (cmd == -1)
791                 {
792                         SHOWNET("END OF MESSAGE");
793                         return;         // end of message
794                 }
795
796         // if the high bit of the command byte is set, it is a fast update
797                 if (cmd & 128)
798                 {
799                         SHOWNET("fast update");
800                         CL_ParseUpdate (cmd&127);
801                         continue;
802                 }
803
804                 SHOWNET(svc_strings[cmd]);
805         
806         // other commands
807                 switch (cmd)
808                 {
809                 default:
810                         Host_Error ("CL_ParseServerMessage: Illegible server message\n");
811                         break;
812                         
813                 case svc_nop:
814 //                      Con_Printf ("svc_nop\n");
815                         break;
816                         
817                 case svc_time:
818                         cl.mtime[1] = cl.mtime[0];
819                         cl.mtime[0] = MSG_ReadFloat ();                 
820                         break;
821                         
822                 case svc_clientdata:
823                         i = MSG_ReadShort ();
824                         CL_ParseClientdata (i);
825                         break;
826                 
827                 case svc_version:
828                         i = MSG_ReadLong ();
829                         if (i != PROTOCOL_VERSION && i != 250)
830                                 Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, PROTOCOL_VERSION);
831                         Nehahrademcompatibility = i == 250;
832                         break;
833                         
834                 case svc_disconnect:
835                         Host_EndGame ("Server disconnected\n");
836
837                 case svc_print:
838                         Con_Printf ("%s", MSG_ReadString ());
839                         break;
840                         
841                 case svc_centerprint:
842                         SCR_CenterPrint (MSG_ReadString ());
843                         break;
844                         
845                 case svc_stufftext:
846                         Cbuf_AddText (MSG_ReadString ());
847                         break;
848                         
849                 case svc_damage:
850                         V_ParseDamage ();
851                         break;
852                         
853                 case svc_serverinfo:
854                         CL_ParseServerInfo ();
855                         vid.recalc_refdef = true;       // leave intermission full screen
856                         break;
857                         
858                 case svc_setangle:
859                         for (i=0 ; i<3 ; i++)
860                                 cl.viewangles[i] = MSG_ReadAngle ();
861                         break;
862                         
863                 case svc_setview:
864                         cl.viewentity = MSG_ReadShort ();
865                         break;
866                                         
867                 case svc_lightstyle:
868                         i = MSG_ReadByte ();
869                         if (i >= MAX_LIGHTSTYLES)
870                                 Host_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
871                         strcpy (cl_lightstyle[i].map,  MSG_ReadString());
872                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
873                         break;
874                         
875                 case svc_sound:
876                         CL_ParseStartSoundPacket();
877                         break;
878                         
879                 case svc_stopsound:
880                         i = MSG_ReadShort();
881                         S_StopSound(i>>3, i&7);
882                         break;
883                 
884                 case svc_updatename:
885                         i = MSG_ReadByte ();
886                         if (i >= cl.maxclients)
887                                 Host_Error ("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD");
888                         strcpy (cl.scores[i].name, MSG_ReadString ());
889                         break;
890                         
891                 case svc_updatefrags:
892                         i = MSG_ReadByte ();
893                         if (i >= cl.maxclients)
894                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD");
895                         cl.scores[i].frags = MSG_ReadShort ();
896                         break;                  
897
898                 case svc_updatecolors:
899                         i = MSG_ReadByte ();
900                         if (i >= cl.maxclients)
901                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD");
902                         cl.scores[i].colors = MSG_ReadByte ();
903                         break;
904                         
905                 case svc_particle:
906                         R_ParseParticleEffect ();
907                         break;
908
909                 case svc_spawnbaseline:
910                         i = MSG_ReadShort ();
911                         // must use CL_EntityNum() to force cl.num_entities up
912                         CL_ParseBaseline (CL_EntityNum(i));
913                         break;
914                 case svc_spawnstatic:
915                         CL_ParseStatic ();
916                         break;                  
917                 case svc_temp_entity:
918                         CL_ParseTEnt ();
919                         break;
920
921                 case svc_setpause:
922                         {
923                                 cl.paused = MSG_ReadByte ();
924
925                                 if (cl.paused)
926                                         CDAudio_Pause ();
927                                 else
928                                         CDAudio_Resume ();
929                         }
930                         break;
931                         
932                 case svc_signonnum:
933                         i = MSG_ReadByte ();
934                         if (i <= cls.signon)
935                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
936                         cls.signon = i;
937                         CL_SignonReply ();
938                         break;
939
940                 case svc_killedmonster:
941                         cl.stats[STAT_MONSTERS]++;
942                         break;
943
944                 case svc_foundsecret:
945                         cl.stats[STAT_SECRETS]++;
946                         break;
947
948                 case svc_updatestat:
949                         i = MSG_ReadByte ();
950                         if (i < 0 || i >= MAX_CL_STATS)
951                                 Host_Error ("svc_updatestat: %i is invalid", i);
952                         cl.stats[i] = MSG_ReadLong ();;
953                         break;
954                         
955                 case svc_spawnstaticsound:
956                         CL_ParseStaticSound ();
957                         break;
958
959                 case svc_cdtrack:
960                         cl.cdtrack = MSG_ReadByte ();
961                         cl.looptrack = MSG_ReadByte ();
962                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
963                                 CDAudio_Play ((byte)cls.forcetrack, true);
964                         else
965                                 CDAudio_Play ((byte)cl.cdtrack, true);
966                         break;
967
968                 case svc_intermission:
969                         cl.intermission = 1;
970                         cl.completed_time = cl.time;
971                         vid.recalc_refdef = true;       // go to full screen
972                         break;
973
974                 case svc_finale:
975                         cl.intermission = 2;
976                         cl.completed_time = cl.time;
977                         vid.recalc_refdef = true;       // go to full screen
978                         SCR_CenterPrint (MSG_ReadString ());                    
979                         break;
980
981                 case svc_cutscene:
982                         cl.intermission = 3;
983                         cl.completed_time = cl.time;
984                         vid.recalc_refdef = true;       // go to full screen
985                         SCR_CenterPrint (MSG_ReadString ());                    
986                         break;
987
988                 case svc_sellscreen:
989                         Cmd_ExecuteString ("help", src_command);
990                         break;
991                 case svc_hidelmp:
992                         SHOWLMP_decodehide();
993                         break;
994                 case svc_showlmp:
995                         SHOWLMP_decodeshow();
996                         break;
997         // LordHavoc: extra worldspawn fields (fog, sky, farclip)
998                 case svc_skybox:
999                         R_SetSkyBox(MSG_ReadString());
1000                         break;
1001                 case svc_farclip:
1002                         r_farclip.value = MSG_ReadCoord();
1003                         break;
1004                 case svc_fog:
1005                         if (MSG_ReadByte())
1006                         {
1007                                 fog_density = MSG_ReadShort() * (1.0f / 4096.0f);
1008                                 fog_red = MSG_ReadByte() * (1.0 / 255.0);
1009                                 fog_green = MSG_ReadByte() * (1.0 / 255.0);
1010                                 fog_blue = MSG_ReadByte() * (1.0 / 255.0);
1011                         }
1012                         else
1013                                 fog_density = 0.0f;
1014                         break;
1015                 }
1016         }
1017 }
1018