updated to version 1.50, build 75.
[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 * 4096] density [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 float fog_density;
223 extern float fog_red;
224 extern float fog_green;
225 extern float fog_blue;
226 extern void R_SetSkyBox (char *sky);
227 extern void FOG_clear();
228 extern cvar_t r_farclip;
229
230 void CL_ParseEntityLump(char *entdata)
231 {
232         char *data;
233         char key[128], value[1024];
234         char wadname[128];
235         int i, j, k;
236         FOG_clear(); // LordHavoc: no fog until set
237         skyname[0] = 0; // LordHavoc: no enviroment mapped sky until set
238         r_farclip.value = 6144; // LordHavoc: default farclip distance
239         data = entdata;
240         if (!data)
241                 return;
242         data = COM_Parse(data);
243         if (!data)
244                 return; // valid exit
245         if (com_token[0] != '{')
246                 return; // error
247         while (1)
248         {
249                 data = COM_Parse(data);
250                 if (!data)
251                         return; // error
252                 if (com_token[0] == '}')
253                         return; // since we're just parsing the first ent (worldspawn), exit
254                 strcpy(key, com_token);
255                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
256                         key[strlen(key)-1] = 0;
257                 data = COM_Parse(data);
258                 if (!data)
259                         return; // error
260                 strcpy(value, com_token);
261                 if (!strcmp("sky", key))
262                         R_SetSkyBox(value);
263                 else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
264                         R_SetSkyBox(value);
265                 else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
266                         R_SetSkyBox(value);
267                 else if (!strcmp("farclip", key))
268                 {
269                         r_farclip.value = atof(value);
270                         if (r_farclip.value < 64)
271                                 r_farclip.value = 64;
272                 }
273                 else if (!strcmp("fog", key))
274                 {
275                         scanf(value, "%f %f %f %f", &fog_density, &fog_red, &fog_green, &fog_blue);
276                         j = 0;
277                 }
278                 else if (!strcmp("fog_density", key))
279                         fog_density = atof(value);
280                 else if (!strcmp("fog_red", key))
281                         fog_red = atof(value);
282                 else if (!strcmp("fog_green", key))
283                         fog_green = atof(value);
284                 else if (!strcmp("fog_blue", key))
285                         fog_blue = atof(value);
286                 else if (!strcmp("wad", key)) // for HalfLife maps
287                 {
288                         j = 0;
289                         for (i = 0;i < 128;i++)
290                                 if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':')
291                                         break;
292                         if (value[i])
293                         {
294                                 for (;i < 128;i++)
295                                 {
296                                         // ignore path - the \\ check is for HalfLife... stupid windoze 'programmers'...
297                                         if (value[i] == '\\' || value[i] == '/' || value[i] == ':')
298                                                 j = i+1;
299                                         else if (value[i] == ';' || value[i] == 0)
300                                         {
301                                                 k = value[i];
302                                                 value[i] = 0;
303                                                 strcpy(wadname, "textures/");
304                                                 strcat(wadname, &value[j]);
305                                                 W_LoadTextureWadFile (wadname, FALSE);
306                                                 j = i+1;
307                                                 if (!k)
308                                                         break;
309                                         }
310                                 }
311                         }
312                 }
313         }
314 }
315
316 /*
317 ==================
318 CL_ParseServerInfo
319 ==================
320 */
321 extern cvar_t demo_nehahra;
322 void CL_ParseServerInfo (void)
323 {
324         char    *str;
325         int             i;
326         int             nummodels, numsounds;
327         char    model_precache[MAX_MODELS][MAX_QPATH];
328         char    sound_precache[MAX_SOUNDS][MAX_QPATH];
329         
330         Con_DPrintf ("Serverinfo packet received.\n");
331 //
332 // wipe the client_state_t struct
333 //
334         CL_ClearState ();
335
336 // parse protocol version number
337         i = MSG_ReadLong ();
338         if (i != PROTOCOL_VERSION && i != 250)
339         {
340                 Con_Printf ("Server returned version %i, not %i", i, PROTOCOL_VERSION);
341                 return;
342         }
343         Nehahrademcompatibility = false;
344         if (i == 250)
345                 Nehahrademcompatibility = true;
346         if (cls.demoplayback && demo_nehahra.value)
347                 Nehahrademcompatibility = true;
348         dpprotocol = i == DPPROTOCOL_VERSION;
349
350 // parse maxclients
351         cl.maxclients = MSG_ReadByte ();
352         if (cl.maxclients < 1 || cl.maxclients > MAX_SCOREBOARD)
353         {
354                 Con_Printf("Bad maxclients (%u) from server\n", cl.maxclients);
355                 return;
356         }
357         cl.scores = Hunk_AllocName (cl.maxclients*sizeof(*cl.scores), "scores");
358
359 // parse gametype
360         cl.gametype = MSG_ReadByte ();
361
362 // parse signon message
363         str = MSG_ReadString ();
364         strncpy (cl.levelname, str, sizeof(cl.levelname)-1);
365
366 // seperate the printfs so the server message can have a color
367         if (!Nehahrademcompatibility) // no messages when playing the Nehahra movie
368         {
369                 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");
370                 Con_Printf ("%c%s\n", 2, str);
371         }
372
373 //
374 // first we go through and touch all of the precache data that still
375 // happens to be in the cache, so precaching something else doesn't
376 // needlessly purge it
377 //
378
379 // precache models
380         memset (cl.model_precache, 0, sizeof(cl.model_precache));
381         for (nummodels=1 ; ; nummodels++)
382         {
383                 str = MSG_ReadString ();
384                 if (!str[0])
385                         break;
386                 if (nummodels==MAX_MODELS)
387                 {
388                         Con_Printf ("Server sent too many model precaches\n");
389                         return;
390                 }
391                 strcpy (model_precache[nummodels], str);
392                 Mod_TouchModel (str);
393         }
394
395 // precache sounds
396         memset (cl.sound_precache, 0, sizeof(cl.sound_precache));
397         for (numsounds=1 ; ; numsounds++)
398         {
399                 str = MSG_ReadString ();
400                 if (!str[0])
401                         break;
402                 if (numsounds==MAX_SOUNDS)
403                 {
404                         Con_Printf ("Server sent too many sound precaches\n");
405                         return;
406                 }
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 //int   bitcounts[16];
457
458 void CL_ParseUpdate (int bits)
459 {
460         int                     i, modnum, num, skin, alpha, scale, glowsize, glowcolor, colormod;
461         model_t         *model;
462         qboolean        forcelink;
463         entity_t        *ent;
464         entity_state_t *baseline;
465
466         if (cls.signon == SIGNONS - 1)
467         {       // first update is the final signon stage
468                 cls.signon = SIGNONS;
469                 CL_SignonReply ();
470         }
471
472         if (bits & U_MOREBITS)
473         {
474                 i = MSG_ReadByte ();
475                 bits |= (i<<8);
476         }
477         if (bits & U_EXTEND1 && !Nehahrademcompatibility)
478         {
479                 bits |= MSG_ReadByte() << 16;
480                 if (bits & U_EXTEND2)
481                         bits |= MSG_ReadByte() << 24;
482         }
483
484         if (bits & U_LONGENTITY)        
485                 num = MSG_ReadShort ();
486         else
487                 num = MSG_ReadByte ();
488
489         ent = CL_EntityNum (num);
490
491 //for (i=0 ; i<16 ; i++)
492 //if (bits&(1<<i))
493 //      bitcounts[i]++;
494
495         forcelink = ent->msgtime != cl.mtime[1]; // no previous frame to lerp from
496
497         ent->msgtime = cl.mtime[0];
498         
499         // LordHavoc: new protocol stuff
500         baseline = &ent->baseline;
501         if (bits & U_DELTA)
502                 baseline = &ent->deltabaseline;
503
504         modnum = bits & U_MODEL ? MSG_ReadByte() : baseline->modelindex;
505         if (modnum >= MAX_MODELS)
506                 Host_Error ("CL_ParseModel: bad modnum");
507         ent->deltabaseline.modelindex = modnum;
508                 
509         model = cl.model_precache[modnum];
510         if (model != ent->model)
511         {
512                 ent->model = model;
513         // automatic animation (torches, etc) can be either all together
514         // or randomized
515                 if (model)
516                         ent->syncbase = model->synctype == ST_RAND ? (float)(rand()&0x7fff) / 0x7fff : 0.0;
517                 else
518                         forcelink = true;       // hack to make null model players work
519         }
520
521         ent->frame = ((bits & U_FRAME) ? MSG_ReadByte() : (baseline->frame & 0xFF));
522
523         i = bits & U_COLORMAP ? MSG_ReadByte() : baseline->colormap;
524         ent->deltabaseline.colormap = i;
525         if (!i)
526                 ent->colormap = -1; // no special coloring
527         else
528         {
529                 if (i > cl.maxclients)
530                         Host_Error ("i >= cl.maxclients");
531                 ent->colormap = cl.scores[i-1].colors; // color it
532         }
533
534         skin = bits & U_SKIN ? MSG_ReadByte() : baseline->skin;
535         if (skin != ent->skinnum)
536         {
537                 ent->skinnum = skin;
538         }
539         ent->deltabaseline.skin = skin;
540
541         ent->effects = ((bits & U_EFFECTS) ? MSG_ReadByte() : (baseline->effects & 0xFF));
542
543 // shift the known values for interpolation
544         VectorCopy (ent->msg_origins[0], ent->msg_origins[1]);
545         VectorCopy (ent->msg_angles[0], ent->msg_angles[1]);
546         VectorCopy (baseline->origin, ent->msg_origins[0]);
547         VectorCopy (baseline->angles, ent->msg_angles[0]);
548
549         if (bits & U_ORIGIN1) ent->msg_origins[0][0] = MSG_ReadCoord ();
550         if (bits & U_ANGLE1) ent->msg_angles[0][0] = MSG_ReadAngle();
551         if (bits & U_ORIGIN2) ent->msg_origins[0][1] = MSG_ReadCoord ();
552         if (bits & U_ANGLE2) ent->msg_angles[0][1] = MSG_ReadAngle();
553         if (bits & U_ORIGIN3) ent->msg_origins[0][2] = MSG_ReadCoord ();
554         if (bits & U_ANGLE3) ent->msg_angles[0][2] = MSG_ReadAngle();
555
556         VectorCopy(ent->msg_origins[0], ent->deltabaseline.origin);
557         VectorCopy(ent->msg_angles[0], ent->deltabaseline.angles);
558
559         alpha = bits & U_ALPHA ? MSG_ReadByte() : baseline->alpha;
560         scale = bits & U_SCALE ? MSG_ReadByte() : baseline->scale;
561         ent->effects |= ((bits & U_EFFECTS2) ? (MSG_ReadByte() << 8) : (baseline->effects & 0xFF00));
562         glowsize = bits & U_GLOWSIZE ? MSG_ReadByte() : baseline->glowsize;
563         glowcolor = bits & U_GLOWCOLOR ? MSG_ReadByte() : baseline->glowcolor;
564         colormod = bits & U_COLORMOD ? MSG_ReadByte() : baseline->colormod;
565         ent->frame |= ((bits & U_FRAME2) ? (MSG_ReadByte() << 8) : (baseline->frame & 0xFF00));
566         ent->deltabaseline.alpha = alpha;
567         ent->deltabaseline.scale = scale;
568         ent->deltabaseline.effects = ent->effects;
569         ent->deltabaseline.glowsize = glowsize;
570         ent->deltabaseline.glowcolor = glowcolor;
571         ent->deltabaseline.colormod = colormod;
572         ent->deltabaseline.frame = ent->frame;
573         ent->alpha = (float) alpha * (1.0 / 255.0);
574         ent->scale = (float) scale * (1.0 / 16.0);
575         ent->glowsize = glowsize * 4.0;
576         ent->glowcolor = glowcolor;
577         ent->colormod[0] = (float) ((colormod >> 5) & 7) * (1.0 / 7.0);
578         ent->colormod[1] = (float) ((colormod >> 2) & 7) * (1.0 / 7.0);
579         ent->colormod[2] = (float) (colormod & 3) * (1.0 / 3.0);
580         if (bits & U_EXTEND1 && Nehahrademcompatibility) // LordHavoc: to allow playback of the early Nehahra movie segments
581         {
582                 i = MSG_ReadFloat();
583                 ent->alpha = MSG_ReadFloat();
584                 if (i == 2 && MSG_ReadFloat() != 0.0)
585                         ent->effects |= EF_FULLBRIGHT;
586                 if (ent->alpha == 0)
587                         ent->alpha = 1;
588         }
589
590         //if ( bits & U_NOLERP )
591         //      ent->forcelink = true;
592         //if (bits & U_STEP) // FIXME: implement clientside interpolation of monsters
593
594         if ( forcelink )
595         {       // didn't have an update last message
596                 VectorCopy (ent->msg_origins[0], ent->msg_origins[1]);
597                 VectorCopy (ent->msg_origins[0], ent->origin);
598                 VectorCopy (ent->msg_angles[0], ent->msg_angles[1]);
599                 VectorCopy (ent->msg_angles[0], ent->angles);
600                 ent->forcelink = true;
601         }
602 }
603
604 /*
605 ==================
606 CL_ParseBaseline
607 ==================
608 */
609 void CL_ParseBaseline (entity_t *ent)
610 {
611         int                     i;
612         
613         ent->baseline.modelindex = MSG_ReadByte ();
614         ent->baseline.frame = MSG_ReadByte ();
615         ent->baseline.colormap = MSG_ReadByte();
616         ent->baseline.skin = MSG_ReadByte();
617         for (i=0 ; i<3 ; i++)
618         {
619                 ent->baseline.origin[i] = MSG_ReadCoord ();
620                 ent->baseline.angles[i] = MSG_ReadAngle ();
621         }
622         ent->baseline.alpha = 255;
623         ent->baseline.scale = 16;
624         ent->baseline.glowsize = 0;
625         ent->baseline.glowcolor = 254;
626         ent->baseline.colormod = 255;
627 }
628
629
630 /*
631 ==================
632 CL_ParseClientdata
633
634 Server information pertaining to this client only
635 ==================
636 */
637 void CL_ParseClientdata (int bits)
638 {
639         int             i, j;
640         
641         if (bits & SU_VIEWHEIGHT)
642                 cl.viewheight = MSG_ReadChar ();
643         else
644                 cl.viewheight = DEFAULT_VIEWHEIGHT;
645
646         if (bits & SU_IDEALPITCH)
647                 cl.idealpitch = MSG_ReadChar ();
648         else
649                 cl.idealpitch = 0;
650         
651         VectorCopy (cl.mvelocity[0], cl.mvelocity[1]);
652         for (i=0 ; i<3 ; i++)
653         {
654                 if (bits & (SU_PUNCH1<<i) )
655                         cl.punchangle[i] = MSG_ReadChar();
656                 else
657                         cl.punchangle[i] = 0;
658                 if (bits & (SU_VELOCITY1<<i) )
659                         cl.mvelocity[0][i] = MSG_ReadChar()*16;
660                 else
661                         cl.mvelocity[0][i] = 0;
662         }
663
664 // [always sent]        if (bits & SU_ITEMS)
665                 i = MSG_ReadLong ();
666
667         if (cl.items != i)
668         {       // set flash times
669 //              Sbar_Changed ();
670                 for (j=0 ; j<32 ; j++)
671                         if ( (i & (1<<j)) && !(cl.items & (1<<j)))
672                                 cl.item_gettime[j] = cl.time;
673                 cl.items = i;
674         }
675                 
676         cl.onground = (bits & SU_ONGROUND) != 0;
677         cl.inwater = (bits & SU_INWATER) != 0;
678
679         if (bits & SU_WEAPONFRAME)
680                 cl.stats[STAT_WEAPONFRAME] = MSG_ReadByte ();
681         else
682                 cl.stats[STAT_WEAPONFRAME] = 0;
683
684         if (bits & SU_ARMOR)
685                 i = MSG_ReadByte ();
686         else
687                 i = 0;
688         if (cl.stats[STAT_ARMOR] != i)
689         {
690                 cl.stats[STAT_ARMOR] = i;
691 //              Sbar_Changed ();
692         }
693
694         if (bits & SU_WEAPON)
695                 i = MSG_ReadByte ();
696         else
697                 i = 0;
698         if (cl.stats[STAT_WEAPON] != i)
699         {
700                 cl.stats[STAT_WEAPON] = i;
701 //              Sbar_Changed ();
702         }
703         
704         i = MSG_ReadShort ();
705         if (cl.stats[STAT_HEALTH] != i)
706         {
707                 cl.stats[STAT_HEALTH] = i;
708 //              Sbar_Changed ();
709         }
710
711         i = MSG_ReadByte ();
712         if (cl.stats[STAT_AMMO] != i)
713         {
714                 cl.stats[STAT_AMMO] = i;
715 //              Sbar_Changed ();
716         }
717
718         for (i=0 ; i<4 ; i++)
719         {
720                 j = MSG_ReadByte ();
721                 if (cl.stats[STAT_SHELLS+i] != j)
722                 {
723                         cl.stats[STAT_SHELLS+i] = j;
724 //                      Sbar_Changed ();
725                 }
726         }
727
728         i = MSG_ReadByte ();
729
730         if (standard_quake)
731         {
732                 if (cl.stats[STAT_ACTIVEWEAPON] != i)
733                 {
734                         cl.stats[STAT_ACTIVEWEAPON] = i;
735 //                      Sbar_Changed ();
736                 }
737         }
738         else
739         {
740                 if (cl.stats[STAT_ACTIVEWEAPON] != (1<<i))
741                 {
742                         cl.stats[STAT_ACTIVEWEAPON] = (1<<i);
743 //                      Sbar_Changed ();
744                 }
745         }
746 }
747
748 /*
749 =====================
750 CL_ParseStatic
751 =====================
752 */
753 void CL_ParseStatic (void)
754 {
755         entity_t *ent;
756         int             i;
757                 
758         i = cl.num_statics;
759         if (i >= MAX_STATIC_ENTITIES)
760                 Host_Error ("Too many static entities");
761         ent = &cl_static_entities[i];
762         cl.num_statics++;
763         CL_ParseBaseline (ent);
764
765 // copy it to the current state
766         ent->model = cl.model_precache[ent->baseline.modelindex];
767         ent->frame = ent->baseline.frame;
768         ent->colormap = -1; // no special coloring
769         ent->skinnum = ent->baseline.skin;
770         ent->effects = ent->baseline.effects;
771         ent->alpha = 1;
772         ent->scale = 1;
773         ent->alpha = 1;
774         ent->glowsize = 0;
775         ent->glowcolor = 254;
776         ent->colormod[0] = ent->colormod[1] = ent->colormod[2] = 1;
777
778         VectorCopy (ent->baseline.origin, ent->origin);
779         VectorCopy (ent->baseline.angles, ent->angles); 
780         R_AddEfrags (ent);
781 }
782
783 /*
784 ===================
785 CL_ParseStaticSound
786 ===================
787 */
788 void CL_ParseStaticSound (void)
789 {
790         vec3_t          org;
791         int                     sound_num, vol, atten;
792         int                     i;
793         
794         for (i=0 ; i<3 ; i++)
795                 org[i] = MSG_ReadCoord ();
796         sound_num = MSG_ReadByte ();
797         vol = MSG_ReadByte ();
798         atten = MSG_ReadByte ();
799         
800         S_StaticSound (cl.sound_precache[sound_num], org, vol, atten);
801 }
802
803
804 #define SHOWNET(x) if(cl_shownet.value==2)Con_Printf ("%3i:%s\n", msg_readcount-1, x);
805
806 extern void SHOWLMP_decodehide();
807 extern void SHOWLMP_decodeshow();
808 extern void R_SetSkyBox(char* sky);
809
810 extern float fog_density;
811 extern float fog_red;
812 extern float fog_green;
813 extern float fog_blue;
814
815 /*
816 =====================
817 CL_ParseServerMessage
818 =====================
819 */
820 void CL_ParseServerMessage (void)
821 {
822         int                     cmd;
823         int                     i;
824         
825 //
826 // if recording demos, copy the message out
827 //
828         if (cl_shownet.value == 1)
829                 Con_Printf ("%i ",net_message.cursize);
830         else if (cl_shownet.value == 2)
831                 Con_Printf ("------------------\n");
832         
833         cl.onground = false;    // unless the server says otherwise     
834 //
835 // parse the message
836 //
837         MSG_BeginReading ();
838         
839         while (1)
840         {
841                 if (msg_badread)
842                         Host_Error ("CL_ParseServerMessage: Bad server message");
843
844                 cmd = MSG_ReadByte ();
845
846                 if (cmd == -1)
847                 {
848                         SHOWNET("END OF MESSAGE");
849                         return;         // end of message
850                 }
851
852         // if the high bit of the command byte is set, it is a fast update
853                 if (cmd & 128)
854                 {
855                         SHOWNET("fast update");
856                         CL_ParseUpdate (cmd&127);
857                         continue;
858                 }
859
860                 SHOWNET(svc_strings[cmd]);
861         
862         // other commands
863                 switch (cmd)
864                 {
865                 default:
866                         Host_Error ("CL_ParseServerMessage: Illegible server message\n");
867                         break;
868                         
869                 case svc_nop:
870 //                      Con_Printf ("svc_nop\n");
871                         break;
872                         
873                 case svc_time:
874                         cl.mtime[1] = cl.mtime[0];
875                         cl.mtime[0] = MSG_ReadFloat ();                 
876                         break;
877                         
878                 case svc_clientdata:
879                         i = MSG_ReadShort ();
880                         CL_ParseClientdata (i);
881                         break;
882                 
883                 case svc_version:
884                         i = MSG_ReadLong ();
885                         if (i != PROTOCOL_VERSION && i != 250)
886                                 Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, PROTOCOL_VERSION);
887                         Nehahrademcompatibility = i == 250;
888                         break;
889                         
890                 case svc_disconnect:
891                         Host_EndGame ("Server disconnected\n");
892
893                 case svc_print:
894                         Con_Printf ("%s", MSG_ReadString ());
895                         break;
896                         
897                 case svc_centerprint:
898                         SCR_CenterPrint (MSG_ReadString ());
899                         break;
900                         
901                 case svc_stufftext:
902                         Cbuf_AddText (MSG_ReadString ());
903                         break;
904                         
905                 case svc_damage:
906                         V_ParseDamage ();
907                         break;
908                         
909                 case svc_serverinfo:
910                         CL_ParseServerInfo ();
911                         vid.recalc_refdef = true;       // leave intermission full screen
912                         break;
913                         
914                 case svc_setangle:
915                         for (i=0 ; i<3 ; i++)
916                                 cl.viewangles[i] = MSG_ReadAngle ();
917                         break;
918                         
919                 case svc_setview:
920                         cl.viewentity = MSG_ReadShort ();
921                         break;
922                                         
923                 case svc_lightstyle:
924                         i = MSG_ReadByte ();
925                         if (i >= MAX_LIGHTSTYLES)
926                                 Host_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
927                         strcpy (cl_lightstyle[i].map,  MSG_ReadString());
928                         cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
929                         break;
930                         
931                 case svc_sound:
932                         CL_ParseStartSoundPacket();
933                         break;
934                         
935                 case svc_stopsound:
936                         i = MSG_ReadShort();
937                         S_StopSound(i>>3, i&7);
938                         break;
939                 
940                 case svc_updatename:
941 //                      Sbar_Changed ();
942                         i = MSG_ReadByte ();
943                         if (i >= cl.maxclients)
944                                 Host_Error ("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD");
945                         strcpy (cl.scores[i].name, MSG_ReadString ());
946                         break;
947                         
948                 case svc_updatefrags:
949 //                      Sbar_Changed ();
950                         i = MSG_ReadByte ();
951                         if (i >= cl.maxclients)
952                                 Host_Error ("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD");
953                         cl.scores[i].frags = MSG_ReadShort ();
954                         break;                  
955
956                 case svc_updatecolors:
957 //                      Sbar_Changed ();
958                         i = MSG_ReadByte ();
959                         if (i >= cl.maxclients)
960                                 Host_Error ("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD");
961                         cl.scores[i].colors = MSG_ReadByte ();
962                         break;
963                         
964                 case svc_particle:
965                         R_ParseParticleEffect ();
966                         break;
967
968                 case svc_spawnbaseline:
969                         i = MSG_ReadShort ();
970                         // must use CL_EntityNum() to force cl.num_entities up
971                         CL_ParseBaseline (CL_EntityNum(i));
972                         break;
973                 case svc_spawnstatic:
974                         CL_ParseStatic ();
975                         break;                  
976                 case svc_temp_entity:
977                         CL_ParseTEnt ();
978                         break;
979
980                 case svc_setpause:
981                         {
982                                 cl.paused = MSG_ReadByte ();
983
984                                 if (cl.paused)
985                                         CDAudio_Pause ();
986                                 else
987                                         CDAudio_Resume ();
988                         }
989                         break;
990                         
991                 case svc_signonnum:
992                         i = MSG_ReadByte ();
993                         if (i <= cls.signon)
994                                 Host_Error ("Received signon %i when at %i", i, cls.signon);
995                         cls.signon = i;
996                         CL_SignonReply ();
997                         break;
998
999                 case svc_killedmonster:
1000                         cl.stats[STAT_MONSTERS]++;
1001                         break;
1002
1003                 case svc_foundsecret:
1004                         cl.stats[STAT_SECRETS]++;
1005                         break;
1006
1007                 case svc_updatestat:
1008                         i = MSG_ReadByte ();
1009                         if (i < 0 || i >= MAX_CL_STATS)
1010                                 Host_Error ("svc_updatestat: %i is invalid", i);
1011                         cl.stats[i] = MSG_ReadLong ();;
1012                         break;
1013                         
1014                 case svc_spawnstaticsound:
1015                         CL_ParseStaticSound ();
1016                         break;
1017
1018                 case svc_cdtrack:
1019                         cl.cdtrack = MSG_ReadByte ();
1020                         cl.looptrack = MSG_ReadByte ();
1021                         if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
1022                                 CDAudio_Play ((byte)cls.forcetrack, true);
1023                         else
1024                                 CDAudio_Play ((byte)cl.cdtrack, true);
1025                         break;
1026
1027                 case svc_intermission:
1028                         cl.intermission = 1;
1029                         cl.completed_time = cl.time;
1030                         vid.recalc_refdef = true;       // go to full screen
1031                         break;
1032
1033                 case svc_finale:
1034                         cl.intermission = 2;
1035                         cl.completed_time = cl.time;
1036                         vid.recalc_refdef = true;       // go to full screen
1037                         SCR_CenterPrint (MSG_ReadString ());                    
1038                         break;
1039
1040                 case svc_cutscene:
1041                         cl.intermission = 3;
1042                         cl.completed_time = cl.time;
1043                         vid.recalc_refdef = true;       // go to full screen
1044                         SCR_CenterPrint (MSG_ReadString ());                    
1045                         break;
1046
1047                 case svc_sellscreen:
1048                         Cmd_ExecuteString ("help", src_command);
1049                         break;
1050                 case svc_hidelmp:
1051                         SHOWLMP_decodehide();
1052                         break;
1053                 case svc_showlmp:
1054                         SHOWLMP_decodeshow();
1055                         break;
1056         // LordHavoc: extra worldspawn fields (fog, sky, farclip)
1057                 case svc_skybox:
1058                         R_SetSkyBox(MSG_ReadString());
1059                         break;
1060                 case svc_farclip:
1061                         r_farclip.value = MSG_ReadCoord();
1062                         break;
1063                 case svc_fog:
1064                         if (MSG_ReadByte())
1065                         {
1066                                 fog_density = MSG_ReadShort() * (1.0f / 4096.0f);
1067                                 fog_red = MSG_ReadByte() * (1.0 / 255.0);
1068                                 fog_green = MSG_ReadByte() * (1.0 / 255.0);
1069                                 fog_blue = MSG_ReadByte() * (1.0 / 255.0);
1070                         }
1071                         else
1072                                 fog_density = 0.0f;
1073                         break;
1074                 }
1075         }
1076 }
1077